📔Boilerplate (Cube Interaction)

Boilerplate Code for Generative Art

[사용 방법]

1. 이 파일을 복사해서 새 이름으로 저장합니다.
2. 클래스 이름을 파일명과 동일하게 변경합니다.
3. [아트워크 로직] 섹션만 수정해서 새로운 아트워크를 만듭니다.
4. 나머지 섹션([인프라 코드])은 수정하지 않아도 됩니다.

[코드의 기능]

[인터랙션]

• 마우스 클릭: 클릭 지점 근처 큐브를 튕겨냅니다
• 큐브는 스프링 힘으로 원래 위치로 돌아옵니다
• 댐핑으로 자연스럽게 정지합니다

📄BoilerplateSculptureInteraction.cs

using UnityEngine;
using System.Collections.Generic;
using UnityEngine.InputSystem;

#if UNITY_EDITOR
using UnityEditor;
#endif

[ExecuteAlways]
public class BoilerplateSculptureInteraction : MonoBehaviour
{
    // ============================================================
    // 인스펙터 파라미터
    // ============================================================

    [Header("구조 설정 (변경 시 오브젝트 재생성)")]
    public int countX = 5;
    public int countY = 5;
    public int countZ = 5;
    public float spacing = 1.2f;
    public float cubeSize = 0.8f;
    public int colorSeed = 0;

    [Header("맥동 애니메이션 (실시간 반영)")]
    public float pulseSpeed = 1.0f;
    public float pulseIntensity = 0.12f;
    public float pulseFrequency = 1.5f;

    [Header("색상 설정 (실시간 반영)")]
    [Range(0f, 1f)] public float hueMin = 0.55f;
    [Range(0f, 1f)] public float hueMax = 0.75f;
    [Range(0f, 1f)] public float saturation = 0.80f;
    [Range(0f, 1f)] public float brightness = 0.90f;
    public float emissionIntensity = 0.5f;

    [Header("인터랙션 설정")]
    public float explodeRadius = 3.0f;  // 클릭 폭발 영향 반경
    public float explodeForce = 8.0f;  // 튕겨내는 힘의 크기
    public float springStrength = 12.0f; // 스프링 복원력 (클수록 빠르게 돌아옴)
    public float damping = 6.0f;  // 댐핑 (클수록 빠르게 정지)

    [Header("재질 설정")]
    public Material baseMaterial;

    // ============================================================
    // 내부 데이터 구조
    // ============================================================

    struct CubeData
    {
        public Transform tr;
        public Material mat;
        public Vector3 basePos;   // 원래 로컬 위치 (스프링 목표 지점)
        public float hue;
        public float phase;

        // 스프링 물리 상태 (Play 모드에서만 사용)
        public Vector3 velocity;  // 현재 이동 속도
        public Vector3 offset;    // basePos로부터 현재 변위
    }

    List<CubeData> _cubes = new List<CubeData>();

    enum RenderPipeline { BuiltIn, URP, HDRP }
    RenderPipeline _pipeline;

    // ============================================================
    // 구조 파라미터 캐시
    // ============================================================

    int _cachedCountX;
    int _cachedCountY;
    int _cachedCountZ;
    float _cachedSpacing;
    float _cachedCubeSize;
    int _cachedColorSeed;

#if UNITY_EDITOR
    bool _generateQueued = false;
#endif

    // ============================================================
    // Unity 이벤트
    // ============================================================

    void OnEnable()
    {
        _pipeline = DetectPipeline();

        if (baseMaterial == null)
            baseMaterial = CreateFallbackMaterial();

        Generate();
        CacheStructureParams();
    }

    void OnValidate()
    {
#if UNITY_EDITOR
        _pipeline = DetectPipeline();

        if (baseMaterial == null)
            baseMaterial = CreateFallbackMaterial();

        if (StructureParamsChanged())
        {
            CacheStructureParams();
            QueueGenerate();
        }
        else
        {
            ApplyAnimation(0f);
        }
#endif
    }

#if UNITY_EDITOR
    void QueueGenerate()
    {
        if (_generateQueued) return;

        _generateQueued = true;
        EditorApplication.delayCall += () =>
        {
            _generateQueued = false;
            if (this == null) return;
            Generate();
        };
    }
#endif

    void Update()
    {
#if UNITY_EDITOR
        // Scene 뷰: 맥동 애니메이션만 정지 상태로 표시
        if (!Application.isPlaying)
        {
            ApplyAnimation(0f);
            return;
        }
#endif
        // Play 모드: 스프링 물리 → 맥동 → 인터랙션 입력 순서로 처리
        UpdateSpringPhysics();
        ApplyAnimation(Time.time * pulseSpeed);
        HandleInput();
    }

    // ============================================================
    // 구조 파라미터 캐시 유틸
    // ============================================================

    bool StructureParamsChanged()
    {
        return countX != _cachedCountX
            || countY != _cachedCountY
            || countZ != _cachedCountZ
            || spacing != _cachedSpacing
            || cubeSize != _cachedCubeSize
            || colorSeed != _cachedColorSeed;
    }

    void CacheStructureParams()
    {
        _cachedCountX = countX;
        _cachedCountY = countY;
        _cachedCountZ = countZ;
        _cachedSpacing = spacing;
        _cachedCubeSize = cubeSize;
        _cachedColorSeed = colorSeed;
    }

    // ============================================================
    // 생성
    // ============================================================

    void Generate()
    {
        Clear();
        Random.InitState(colorSeed);

        float offsetX = (countX - 1) * spacing * 0.5f;
        float offsetY = (countY - 1) * spacing * 0.5f;
        float offsetZ = (countZ - 1) * spacing * 0.5f;

        // ---- [아트워크 로직] ----
        for (int x = 0; x < countX; x++)
            for (int y = 0; y < countY; y++)
                for (int z = 0; z < countZ; z++)
                {
                    Vector3 pos = new Vector3(x * spacing - offsetX,
                                                y * spacing - offsetY,
                                                z * spacing - offsetZ);
                    float hue = Random.Range(hueMin, hueMax);
                    float phase = (x + y + z) * pulseFrequency;

                    SpawnCube(pos, hue, phase);
                }
        // ---- [아트워크 로직 끝] ----

        ApplyAnimation(0f);
    }

    void SpawnCube(Vector3 pos, float hue, float phase)
    {
        GameObject go = GameObject.CreatePrimitive(PrimitiveType.Cube);
        go.transform.SetParent(transform);
        go.transform.localPosition = pos;
        go.transform.localScale = Vector3.one * cubeSize;

        // 큐브마다 독립적인 머티리얼 인스턴스 (색상 개별 제어용)
        Material mat = Instantiate(baseMaterial);
        mat.EnableKeyword("_EMISSION");
        mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;
        go.GetComponent<Renderer>().material = mat;

        _cubes.Add(new CubeData
        {
            tr = go.transform,
            mat = mat,
            basePos = pos,
            hue = hue,
            phase = phase,
            velocity = Vector3.zero, // 초기 속도 0
            offset = Vector3.zero  // 초기 변위 0
        });
    }

    void Clear()
    {
        _cubes.Clear();
        while (transform.childCount > 0)
            DestroyImmediate(transform.GetChild(0).gameObject);
    }

    // ============================================================
    // 스프링 물리
    // F = -springStrength * offset - damping * velocity
    // 스프링 힘: 변위에 비례해서 원래 위치로 당깁니다
    // 댐핑 힘:  속도에 비례해서 운동을 감쇠합니다
    // ============================================================

    void UpdateSpringPhysics()
    {
        float dt = Time.deltaTime; // 프레임 간격 (물리 계산에 필수)

        for (int i = 0; i < _cubes.Count; i++)
        {
            CubeData c = _cubes[i];
            if (c.tr == null) continue;

            // 스프링 힘 = -(복원력 계수 × 변위) - (댐핑 계수 × 속도)
            Vector3 springForce = -springStrength * c.offset;
            Vector3 dampingForce = -damping * c.velocity;
            Vector3 acceleration = springForce + dampingForce;

            // 오일러 적분: 속도와 변위를 한 프레임씩 누적합니다
            c.velocity += acceleration * dt;
            c.offset += c.velocity * dt;

            // 변위가 매우 작아지면 완전히 정지 처리 (수치 진동 방지)
            if (c.offset.magnitude < 0.001f && c.velocity.magnitude < 0.001f)
            {
                c.offset = Vector3.zero;
                c.velocity = Vector3.zero;
            }

            // 로컬 좌표: 기준 위치 + 물리 변위 (ApplyAnimation의 Y 변화는 별도 가산)
            c.tr.localPosition = c.basePos + c.offset;

            // struct는 값 타입이므로 수정 후 반드시 리스트에 다시 씁니다
            _cubes[i] = c;
        }
    }

    // ============================================================
    // 사용자 입력 처리
    // ============================================================

    void HandleInput()
    {
        Mouse mouse = Mouse.current;
        if (mouse == null) return;

        // New Input System: wasReleasedThisFrame → 클릭 완료 시점 감지
        if (!mouse.leftButton.wasReleasedThisFrame) return;

        // 2D 스크린 좌표를 읽어서 레이캐스트에 사용합니다
        Vector2 screenPos = mouse.position.ReadValue();
        Ray ray = Camera.main.ScreenPointToRay(screenPos);
        RaycastHit hit;

        Vector3 worldHitPoint;

        if (Physics.Raycast(ray, out hit))
            worldHitPoint = hit.point;
        else
            worldHitPoint = ray.GetPoint(10f);

        Vector3 localHitPoint = transform.InverseTransformPoint(worldHitPoint);
        Explode(localHitPoint);
    }

    // 폭발: 클릭 지점 반경 내 큐브에 방사형으로 속도를 부여합니다
    public void Explode(Vector3 localCenter)
    {
        for (int i = 0; i < _cubes.Count; i++)
        {
            CubeData c = _cubes[i];
            if (c.tr == null) continue;

            // 클릭 지점 ~ 큐브 기준 위치까지의 벡터
            Vector3 diff = c.basePos - localCenter;
            float distance = diff.magnitude;

            // 영향 반경 밖이면 건너뜀
            if (distance > explodeRadius) continue;

            // 거리에 반비례하는 힘 (가까울수록 강하게 튕겨냄)
            // Mathf.Max로 0 나누기 방지
            float strength = explodeForce * (1f - distance / explodeRadius);
            Vector3 direction = diff.normalized;

            // 기존 속도에 폭발 속도를 가산합니다 (연속 클릭 시 누적됨)
            c.velocity += direction * strength;
            _cubes[i] = c;
        }
    }

    // ============================================================
    // 애니메이션 (맥동)
    // 스프링 물리로 이미 localPosition이 설정된 상태에서
    // Y축 맥동만 offset에 가산합니다
    // ============================================================

    void ApplyAnimation(float t)
    {
        for (int i = 0; i < _cubes.Count; i++)
        {
            CubeData c = _cubes[i];
            if (c.tr == null || c.mat == null) continue;

            // ---- [아트워크 로직] ----
            float pulse = Mathf.Sin(t + c.phase) * pulseIntensity;
            float normalized = (pulse / pulseIntensity + 1f) * 0.5f;

            // 크기 맥동: 스프링 물리와 독립적으로 크기만 변화
            float scale = cubeSize + pulse;
            c.tr.localScale = Vector3.one * Mathf.Max(0.01f, scale);

            // 색상: 맥동 상태에 따라 밝기 변조
            float animBrightness = brightness * Mathf.Lerp(0.4f, 1.0f, normalized);
            Color albedo = Color.HSVToRGB(c.hue, saturation, animBrightness);
            Color emission = Color.HSVToRGB(c.hue, 1f, normalized) * emissionIntensity;
            // ---- [아트워크 로직 끝] ----

            ApplyColor(c.mat, albedo, emission);
        }
    }

    // ============================================================
    // 파이프라인별 색상 적용
    // ============================================================

    void ApplyColor(Material mat, Color albedo, Color emission)
    {
        switch (_pipeline)
        {
            case RenderPipeline.URP:
                mat.SetColor("_BaseColor", albedo);
                mat.SetColor("_EmissionColor", emission);
                break;
            case RenderPipeline.HDRP:
                mat.SetColor("_BaseColor", albedo);
                mat.SetColor("_EmissiveColor", emission);
                break;
            default:
                mat.SetColor("_Color", albedo);
                mat.SetColor("_EmissionColor", emission);
                break;
        }
    }

    // ============================================================
    // 유틸리티
    // ============================================================

    RenderPipeline DetectPipeline()
    {
        var pipeline = UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline;
        if (pipeline == null) return RenderPipeline.BuiltIn;
        string name = pipeline.GetType().Name;
        if (name.Contains("Universal")) return RenderPipeline.URP;
        if (name.Contains("HighDefinition") || name.Contains("HDRP")) return RenderPipeline.HDRP;
        return RenderPipeline.BuiltIn;
    }

    Material CreateFallbackMaterial()
    {
        string[] candidates = {
            "Universal Render Pipeline/Lit",
            "HDRP/Lit",
            "Standard"
        };
        foreach (string shaderName in candidates)
        {
            Shader s = Shader.Find(shaderName);
            if (s != null)
            {
                Material mat = new Material(s);
                mat.EnableKeyword("_EMISSION");
                mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;
                Debug.Log($"[GenArtSculpture] 셰이더 자동 감지: {shaderName}");
                return mat;
            }
        }
        Debug.LogWarning("[GenArtSculpture] Inspector에서 baseMaterial을 직접 할당해주세요.");
        return new Material(Shader.Find("Diffuse"));
    }
}