📔Boilerplate (Cube Sculpture)

Boilerplate Code for Generative Art

[사용 방법]

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

[코드의 기능]

[GPU 파티클 버전(GenArtBoilerplate)과의 차이]

• 각 큐브가 실제 GameObject로 생성됩니다.
• 수십~수백 개 규모의 조형물에 적합합니다.
• 각 큐브에 Collider, Rigidbody 등 컴포넌트를 붙일 수 있습니다.
• 수천 개 이상이 필요하면 GPU 버전을 사용하세요.

📄BoilerplateSculpture.cs

using UnityEngine;
using System.Collections.Generic;

#if UNITY_EDITOR
using UnityEditor; // EditorApplication.delayCall 사용을 위해 에디터 전용으로 임포트
#endif

[ExecuteAlways] // 에디터 모드(Play 전)에서도 Update 등 Unity 이벤트가 호출되게 합니다
public class BoilerplateSculpture : MonoBehaviour
{
    // ============================================================
    // 인스펙터 파라미터
    // ============================================================

    // ----- 구조 파라미터 ----------------------------------------
    // 이 값들이 바뀌면 모든 GameObject를 삭제하고 다시 생성합니다.
    [Header("구조 설정 (변경 시 오브젝트 재생성)")]
    public int   countX   = 5;    // X축 큐브 개수
    public int   countY   = 5;    // Y축 큐브 개수
    public int   countZ   = 5;    // Z축 큐브 개수
    public float spacing  = 1.2f; // 큐브 간격
    public float cubeSize = 0.8f; // 큐브 크기 (spacing보다 작으면 틈이 생깁니다)
    public int   colorSeed = 0;   // 색상 무작위 시드 (같은 시드 = 같은 색상 배치)

    // ----- 애니메이션 파라미터 ----------------------------------
    // 이 값들이 바뀌면 재생성 없이 ApplyAnimation(0f)만 호출합니다.
    [Header("애니메이션 설정 (실시간 반영)")]
    public float pulseSpeed     = 1.0f; // 맥동 속도
    public float pulseIntensity = 0.15f; // 맥동 크기 (큐브 크기 변화량)
    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 Material baseMaterial; // null이면 자동 생성

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

    // 큐브 하나의 데이터 (Generate 시 결정, 이후 ApplyAnimation에서 참조)
    struct CubeData
    {
        public Transform tr;       // 큐브의 Transform (위치/크기 조작에 사용)
        public Material  mat;      // 큐브 전용 머티리얼 인스턴스 (색상 개별 적용)
        public Vector3   basePos;  // 생성 시 결정된 기준 위치
        public float     hue;      // 생성 시 결정된 고유 색상 hue
        public float     phase;    // 생성 시 결정된 맥동 위상 오프셋 (큐브마다 다른 타이밍)
    }

    List<CubeData> _cubes = new List<CubeData>(); // 전체 큐브 데이터 목록

    // 렌더 파이프라인 종류 (OnEnable에서 자동 감지)
    enum RenderPipeline { BuiltIn, URP, HDRP }
    RenderPipeline _pipeline;

    // ============================================================
    // 구조 파라미터 캐시
    // OnValidate에서 실제로 값이 바뀌었는지 비교하기 위한 이전 값 저장소
    // ============================================================
    int   _cachedCountX;
    int   _cachedCountY;
    int   _cachedCountZ;
    float _cachedSpacing;
    float _cachedCubeSize;
    int   _cachedColorSeed;

#if UNITY_EDITOR
    // QueueGenerate 중복 호출 방지 플래그 (에디터 전용)
    bool _generateQueued = false;
#endif

    // ============================================================
    // Unity 이벤트 메서드
    // ============================================================

    // OnEnable: 컴포넌트 활성화 시 호출
    void OnEnable()
    {
        _pipeline = DetectPipeline(); // 렌더 파이프라인 자동 감지

        if (baseMaterial == null)
            baseMaterial = CreateFallbackMaterial(); // 머티리얼 자동 생성

        Generate();             // 큐브 GameObject 생성
        CacheStructureParams(); // 구조 파라미터 캐시 저장
    }

    // OnValidate: 인스펙터에서 값이 바뀔 때마다 호출
    // 주의: 이 콜백 안에서 SetParent(), CreatePrimitive()를 직접 호출하면
    //       Unity 경고가 발생합니다 → QueueGenerate()로 우회합니다
    void OnValidate()
    {
#if UNITY_EDITOR
        _pipeline = DetectPipeline();

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

        if (StructureParamsChanged())
        {
            // 구조 파라미터가 바뀌었을 때 → 다음 프레임으로 재생성 예약
            CacheStructureParams();
            QueueGenerate();
        }
        else
        {
            // 애니메이션/색상 파라미터만 바뀌었을 때 → 즉시 시각 갱신
            ApplyAnimation(0f);
        }
#endif
    }

#if UNITY_EDITOR
    // QueueGenerate: Generate()를 한 프레임 뒤로 미루어 실행합니다.
    // OnValidate 컨텍스트에서 씬 그래프를 직접 수정하면 Unity 내부 직렬화와
    // 충돌하기 때문에 EditorApplication.delayCall로 안전한 타이밍에 실행합니다.
    void QueueGenerate()
    {
        if (_generateQueued) return; // 이미 예약되어 있으면 중복 예약하지 않음

        _generateQueued = true;

        EditorApplication.delayCall += () => // 다음 에디터 루프 타이밍에 실행
        {
            _generateQueued = false;

            if (this == null) return; // 오브젝트가 삭제된 경우 안전하게 건너뜀

            Generate();
        };
    }
#endif

    // Update: 매 프레임 호출
    void Update()
    {
#if UNITY_EDITOR
        // 에디터 Scene 뷰: 애니메이션 없이 t=0 정지 상태 유지
        if (!Application.isPlaying) return;
#endif
        // Play 모드: 시간 기반 애니메이션 적용
        ApplyAnimation(Time.time * pulseSpeed);
    }

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

    // 이전 캐시 값과 현재 값을 비교합니다. 하나라도 다르면 true 반환
    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;
    }

    // ============================================================
    // 생성
    // 실제 GameObject 큐브를 생성하고 this.transform 하위에 배치합니다.
    // ============================================================
    void Generate()
    {
        Clear(); // 기존 큐브를 전부 삭제합니다

        Random.InitState(colorSeed); // 시드 고정 → 재생성해도 동일한 색상 배치 재현

        // ---- [아트워크 로직] 여기를 수정하세요 ----
        // 예시: 3차원 그리드 배치

        // 각 축의 그리드를 로컬 원점 기준으로 중앙 정렬합니다.
        // offset 없이 배치하면 (0,0,0)~(max,max,max) 범위가 되어 한쪽으로 치우칩니다.
        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++)
                {
                    // offset을 빼서 그리드 중심이 (0,0,0)이 되도록 합니다
                    Vector3 pos = new Vector3(
                        x * spacing - offsetX,
                        y * spacing - offsetY,
                        z * spacing - offsetZ
                    );

                    // 큐브마다 hueMin~hueMax 범위 안에서 무작위 hue를 부여합니다
                    float hue = Random.Range(hueMin, hueMax);

                    // 큐브마다 맥동 위상을 다르게 줘서 동시에 움직이지 않게 합니다
                    // x/y/z 좌표를 모두 활용해 3차원적으로 위상 차이를 만듭니다
                    float phase = (x + y + z) * pulseFrequency;

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

        ApplyAnimation(0f); // 생성 직후 t=0 기준 초기 상태 적용
    }

    // 큐브 GameObject 하나를 생성하고 _cubes 리스트에 등록합니다
    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;

        // 큐브마다 독립적인 머티리얼 인스턴스를 만들어야
        // 색상을 개별적으로 제어할 수 있습니다.
        // baseMaterial을 직접 수정하면 모든 큐브 색상이 동시에 바뀝니다.
        Material mat = Instantiate(baseMaterial);
        mat.EnableKeyword("_EMISSION");
        mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;

        go.GetComponent<Renderer>().material = mat;

        // 데이터를 리스트에 저장해서 ApplyAnimation에서 참조합니다
        _cubes.Add(new CubeData
        {
            tr      = go.transform,
            mat     = mat,
            basePos = pos,
            hue     = hue,
            phase   = phase
        });
    }

    // 모든 자식 큐브를 삭제하고 리스트를 비웁니다
    void Clear()
    {
        _cubes.Clear(); // 데이터 리스트 초기화

        // DestroyImmediate: 에디터 모드에서는 Destroy 대신 이것을 사용해야
        // 같은 프레임 안에서 삭제가 완료됩니다.
        // Destroy는 Play 모드 전용이며 에디터에서는 다음 프레임까지 지연됩니다.
        while (transform.childCount > 0)
            DestroyImmediate(transform.GetChild(0).gameObject);
    }

    // ============================================================
    // 애니메이션
    // t = 0              → Scene 에디터 정지 상태
    // t = Time.time * pulseSpeed → Play 모드 애니메이션
    // ============================================================
    void ApplyAnimation(float t)
    {
        for (int i = 0; i < _cubes.Count; i++)
        {
            CubeData c = _cubes[i];

            // DestroyImmediate 직후 리스트 정리 전에 무효화된 참조에
            // 접근하면 MissingReferenceException이 발생하므로 null 체크합니다
            if (c.tr == null || c.mat == null) continue;

            // ---- [아트워크 로직] 여기를 수정하세요 ----
            // 예시: 각 큐브가 자신의 위상으로 맥동 (크기 변화)

            // 큐브마다 phase가 달라서 서로 다른 타이밍으로 커지고 작아집니다
            float pulse      = Mathf.Sin(t + c.phase) * pulseIntensity;
            float scale      = cubeSize + pulse;                    // 기본 크기 ± 맥동량
            float normalized = (pulse / pulseIntensity + 1f) * 0.5f; // 0~1 (색상 변조용)

            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);
        }
    }

    // ============================================================
    // 파이프라인별 색상 적용
    // 셰이더 프로퍼티 이름이 파이프라인마다 다르기 때문에 분기 처리합니다.
    //   URP:      _BaseColor,  _EmissionColor
    //   HDRP:     _BaseColor,  _EmissiveColor
    //   Built-in: _Color,      _EmissionColor
    // ============================================================
    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: // Built-in
                mat.SetColor("_Color",         albedo);
                mat.SetColor("_EmissionColor", emission);
                break;
        }
    }

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

    // 프로젝트의 렌더 파이프라인을 자동 감지합니다
    RenderPipeline DetectPipeline()
    {
        var pipeline = UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline;

        if (pipeline == null) return RenderPipeline.BuiltIn; // Built-in은 에셋이 null

        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;
    }

    // 인스펙터에서 baseMaterial이 할당되지 않은 경우 자동으로 생성합니다.
    // 프로젝트의 렌더 파이프라인에 맞는 셰이더를 순서대로 탐색합니다.
    Material CreateFallbackMaterial()
    {
        string[] candidates = {
            "Universal Render Pipeline/Lit", // URP
            "HDRP/Lit",                      // HDRP
            "Standard"                       // Built-in
        };

        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"));
    }
}