🫧Art_001 Spiral Cube Generator

📒 Art_001_Spiral_Cube_Generator.cs

using UnityEngine;
using System.Collections.Generic;

#if UNITY_EDITOR
using UnityEditor;
#endif

[ExecuteAlways]
public class SpiralCubeGenerator : MonoBehaviour
{
    [Header("나선 구조 (변경 시 오브젝트 재생성)")]
    public int cubeCount = 2000;
    public float angleStep = 0.5f;   // 큐브 간 각도 간격 (라디안)
    public float radiusStep = 0.04f;  // 큐브 간 반지름 증가량
    public float depthStep = 0.1f;   // 큐브 간 Z축 전진량

    [Header("애니메이션 설정")]
    public float rotationSpeed = 0.3f;  // 나선 회전 속도
    public float waveAmplitude = 0.2f;  // Z 방향 파동 진폭
    public float waveFrequency = 2.0f;  // 파동 주파수

    [Header("색상")]
    [Range(0f, 1f)] public float hueBase = 0.46f;
    [Range(0f, 1f)] public float hueRange = 0.24f;
    [Range(0f, 1f)] public float saturation = 0.4f;
    [Range(0f, 1f)] public float brightness = 1.0f;

    // ---------------------------------------------------
    // 구조 파라미터 캐시 (OnValidate 비교용)
    // ---------------------------------------------------
    private int   _cachedCubeCount;
    private float _cachedAngleStep;
    private float _cachedRadiusStep;
    private float _cachedDepthStep;

    // ---------------------------------------------------
    // 큐브 데이터
    // ---------------------------------------------------
    struct CubeData
    {
        public Transform tr;
        public Material  mat;
        public float     baseAngle;      // 생성 시 각도
        public float     radius;         // 나선 반지름
        public float     baseDepth;      // Z 기본값
        public float     normalized;     // 0~1 (색상용)
    }

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

#if UNITY_EDITOR
    bool _generateQueued = false;
#endif

    // ---------------------------------------------------
    // Unity 이벤트
    // ---------------------------------------------------

    void OnEnable()
    {
        Generate();
        CacheStructureParams();
    }

    void OnValidate()
    {
#if UNITY_EDITOR
        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()
    {
        // 에디터 Scene 뷰에서는 애니메이션 정지
#if UNITY_EDITOR
        if (!Application.isPlaying) return;
#endif
        ApplyAnimation(Time.time);
    }

    // ---------------------------------------------------
    // 구조 파라미터 변경 감지
    // ---------------------------------------------------

    bool StructureParamsChanged()
    {
        return cubeCount    != _cachedCubeCount
            || angleStep    != _cachedAngleStep
            || radiusStep   != _cachedRadiusStep
            || depthStep    != _cachedDepthStep;
    }

    void CacheStructureParams()
    {
        _cachedCubeCount  = cubeCount;
        _cachedAngleStep  = angleStep;
        _cachedRadiusStep = radiusStep;
        _cachedDepthStep  = depthStep;
    }

    // ---------------------------------------------------
    // 생성
    // ---------------------------------------------------

    void Generate()
    {
        Clear();

        for (int i = 0; i < cubeCount; i++)
        {
            float t     = (cubeCount > 1) ? (float)i / (cubeCount - 1) : 0f;
            float angle = i * angleStep;
            float r     = i * radiusStep;
            float z     = i * depthStep;

            // 나선 공식: XY 평면에서 회전하며 Z 방향으로 전진
            Vector3 pos = new Vector3(
                Mathf.Cos(angle) * r,
                Mathf.Sin(angle) * r,
                z
            );

            SpawnCube(pos, angle, r, z, t);
        }

        ApplyAnimation(0f);
    }

    void SpawnCube(Vector3 pos, float angle, float radius, float depth, float normalized)
    {
        GameObject go = GameObject.CreatePrimitive(PrimitiveType.Cube);
        go.transform.SetParent(transform);
        go.transform.localPosition = pos;

        Material mat = new Material(Shader.Find("Universal Render Pipeline/Lit"));
        mat.EnableKeyword("_EMISSION");
        mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;

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

        _cubes.Add(new CubeData
        {
            tr         = go.transform,
            mat        = mat,
            baseAngle  = angle,
            radius     = radius,
            baseDepth  = depth,
            normalized = normalized
        });
    }

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

    // ---------------------------------------------------
    // 애니메이션
    // ---------------------------------------------------

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

            // 나선 전체를 Z축 중심으로 천천히 회전
            float animAngle = c.baseAngle + t * rotationSpeed;

            // Z축 파동: 각 큐브가 물결치듯 앞뒤로 움직임
            float wave = Mathf.Sin(c.normalized * waveFrequency * Mathf.PI * 2f - t) * waveAmplitude;

            c.tr.localPosition = new Vector3(
                Mathf.Cos(animAngle) * c.radius,
                Mathf.Sin(animAngle) * c.radius,
                c.baseDepth + wave
            );

            // 큐브 자체도 나선 방향으로 자전
            c.tr.localRotation = Quaternion.Euler(0f, 0f, animAngle * Mathf.Rad2Deg);

            // 색상
            float hue     = (hueBase + c.normalized * hueRange) % 1f;
            Color albedo   = Color.HSVToRGB(hue, saturation, brightness);
            Color emission = Color.HSVToRGB(hue, 1f, c.normalized) * 0.5f;

            c.mat.SetColor("_BaseColor",    albedo);
            c.mat.SetColor("_EmissionColor", emission);
        }
    }
}

📄Art_001_Spiral_Cube_Generator_Ver2.cs

using UnityEngine;
using System.Collections.Generic;

#if UNITY_EDITOR
using UnityEditor;
#endif

// ============================================================
// SpiralCubeGenerator
// 나선형으로 큐브를 배치하고 애니메이션을 적용하는 제너레이티브 아트 컴포넌트.
// [ExecuteAlways] 로 에디터 Scene 뷰에서도 미리보기가 동작합니다.
// ============================================================
[ExecuteAlways]
public class SpiralCubeGeneratorVer2 : MonoBehaviour
{
	// -----------------------------------------------------------
	// Inspector 파라미터
	// -----------------------------------------------------------

	[Header("나선 구조 (변경 시 오브젝트 재생성)")]
	public int cubeCount = 2000;
	public float angleStep = 0.5f;   // 큐브 간 각도 간격 (라디안)
	public float radiusStep = 0.04f;  // 큐브 간 반지름 증가량
	public float depthStep = 0.1f;   // 큐브 간 Z축 전진량

	[Header("큐브 크기")]
	public float cubeScale = 0.15f;

	[Header("애니메이션 설정")]
	public float rotationSpeed = 0.3f;  // 나선 회전 속도
	public float waveAmplitude = 0.2f;  // Z 방향 파동 진폭
	public float waveFrequency = 2.0f;  // 파동 주파수

	[Header("색상")]
	[Range(0f, 1f)] public float hueBase = 0.46f;
	[Range(0f, 1f)] public float hueRange = 0.24f;
	[Range(0f, 1f)] public float saturation = 0.4f;
	[Range(0f, 1f)] public float brightness = 1.0f;

	// -----------------------------------------------------------
	// 구조 파라미터 캐시 (재생성 트리거 판단용)
	// -----------------------------------------------------------

	private int _cachedCubeCount;
	private float _cachedAngleStep;
	private float _cachedRadiusStep;
	private float _cachedDepthStep;
	private float _cachedCubeScale;

	// -----------------------------------------------------------
	// 큐브 데이터
	// -----------------------------------------------------------

	struct CubeData
	{
		public Transform tr;
		public Material mat;
		public float baseAngle;   // 생성 시점의 나선 각도
		public float radius;      // 나선 반지름
		public float baseDepth;   // Z 기본값
		public float normalized;  // 0~1 (인덱스 정규화, 색상 계산용)
	}

	// 배열로 선언해 ref 인덱서 접근 가능 (struct 불필요한 복사 방지)
	CubeData[] _cubes = new CubeData[0];

	// 공유 메시 (모든 큐브가 동일한 Mesh 에셋을 참조)
	private Mesh _sharedCubeMesh;

	// waveFrequency * PI * 2 캐시 (매 프레임 반복 계산 방지)
	private float _waveFreqFull;

#if UNITY_EDITOR
    private bool _generateQueued = false;
#endif

	// -----------------------------------------------------------
	// Unity 이벤트
	// -----------------------------------------------------------

	void OnEnable()
	{
		// 이미 큐브가 있으면 재생성 건너뜀 (씬 로드·플레이 전환 시 중복 방지)
		if (_cubes.Length == 0)
			Generate();

		CacheStructureParams();
		CacheWaveFreq();
	}

	void OnDisable()
	{
		// ExecuteAlways 환경에서 컴포넌트 비활성화 시 리소스 정리
		Clear();
	}

	void OnDestroy()
	{
		Clear();
	}

	void OnValidate()
	{
#if UNITY_EDITOR
        CacheWaveFreq();

        if (StructureParamsChanged())
        {
            CacheStructureParams();
            QueueGenerate();
        }
        else
        {
            // 색상·애니메이션 파라미터만 변경된 경우: 즉시 미리보기 갱신
            ApplyAnimation(0f);
        }
#endif
	}

	void Update()
	{
		// 에디터 Scene 뷰에서는 애니메이션 정지 (미리보기는 t=0 고정)
#if UNITY_EDITOR
        if (!Application.isPlaying) return;
#endif
		ApplyAnimation(Time.time);
	}

	// -----------------------------------------------------------
	// 에디터 지연 생성 (OnValidate 내 직접 생성 금지 우회)
	// -----------------------------------------------------------

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

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

	// -----------------------------------------------------------
	// 구조 파라미터 변경 감지
	// -----------------------------------------------------------

	bool StructureParamsChanged()
	{
		return cubeCount != _cachedCubeCount
				|| angleStep != _cachedAngleStep
				|| radiusStep != _cachedRadiusStep
				|| depthStep != _cachedDepthStep
				|| cubeScale != _cachedCubeScale;
	}

	void CacheStructureParams()
	{
		_cachedCubeCount = cubeCount;
		_cachedAngleStep = angleStep;
		_cachedRadiusStep = radiusStep;
		_cachedDepthStep = depthStep;
		_cachedCubeScale = cubeScale;
	}

	// waveFrequency 가 바뀔 때마다 갱신
	void CacheWaveFreq()
	{
		_waveFreqFull = waveFrequency * Mathf.PI * 2f;
	}

	// -----------------------------------------------------------
	// 생성
	// -----------------------------------------------------------

	void Generate()
	{
		Clear();

		// Shader 를 루프 밖에서 한 번만 탐색
		Shader litShader = Shader.Find("Universal Render Pipeline/Lit");
		if (litShader == null)
		{
			Debug.LogError("[SpiralCubeGenerator] URP Lit 셰이더를 찾을 수 없습니다. URP 프로젝트인지 확인하세요.");
			return;
		}

		// 공유 큐브 Mesh 획득 (없으면 빌트인 에셋에서 가져옴)
		_sharedCubeMesh = GetBuiltinCubeMesh();
		if (_sharedCubeMesh == null)
		{
			Debug.LogError("[SpiralCubeGenerator] 기본 큐브 Mesh 를 찾을 수 없습니다.");
			return;
		}

		_cubes = new CubeData[cubeCount];

		for (int i = 0; i < cubeCount; i++)
		{
			float t = (cubeCount > 1) ? (float)i / (cubeCount - 1) : 0f;
			float angle = i * angleStep;
			float r = i * radiusStep;
			float z = i * depthStep;

			Vector3 pos = new Vector3(
					Mathf.Cos(angle) * r,
					Mathf.Sin(angle) * r,
					z
			);

			_cubes[i] = SpawnCube(i, pos, angle, r, z, t, litShader);
		}

		ApplyAnimation(0f);
	}

	// 큐브 GameObject 를 수동으로 구성해 불필요한 Collider 생성을 막음
	CubeData SpawnCube(int index, Vector3 pos, float angle, float radius, float depth, float normalized, Shader shader)
	{
		GameObject go = new GameObject($"Cube_{index}");
		go.transform.SetParent(transform, false);
		go.transform.localPosition = pos;
		go.transform.localScale = Vector3.one * cubeScale;

		// MeshFilter: 모든 큐브가 동일한 Mesh 를 공유 (sharedMesh)
		MeshFilter mf = go.AddComponent<MeshFilter>();
		mf.sharedMesh = _sharedCubeMesh;

		// MeshRenderer: 머티리얼은 인스턴스별로 별도 생성 (색상 개별 제어)
		MeshRenderer mr = go.AddComponent<MeshRenderer>();
		Material mat = new Material(shader);
		mat.EnableKeyword("_EMISSION");
		mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;
		mr.material = mat;

		return new CubeData
		{
			tr = go.transform,
			mat = mat,
			baseAngle = angle,
			radius = radius,
			baseDepth = depth,
			normalized = normalized
		};
	}

	// 에디터 빌트인 큐브 Mesh 를 임시 오브젝트로부터 가져온 후 즉시 파괴
	Mesh GetBuiltinCubeMesh()
	{
		GameObject temp = GameObject.CreatePrimitive(PrimitiveType.Cube);
		Mesh mesh = temp.GetComponent<MeshFilter>().sharedMesh;
		DestroyImmediate(temp);
		return mesh;
	}

	// -----------------------------------------------------------
	// 정리
	// -----------------------------------------------------------

	void Clear()
	{
		// 머티리얼 먼저 해제 (GC 에 맡기면 에디터에서 누수)
		if (_cubes != null)
		{
			for (int i = 0; i < _cubes.Length; i++)
			{
				if (_cubes[i].mat != null)
					DestroyImmediate(_cubes[i].mat);
			}
		}

		_cubes = new CubeData[0];

		// 자식 오브젝트 파괴
		while (transform.childCount > 0)
		{
#if UNITY_EDITOR
            DestroyImmediate(transform.GetChild(0).gameObject);
#else
			Destroy(transform.GetChild(0).gameObject);
#endif
		}
	}

	// -----------------------------------------------------------
	// 애니메이션
	// -----------------------------------------------------------

	void ApplyAnimation(float t)
	{
		for (int i = 0; i < _cubes.Length; i++)
		{
			ref CubeData c = ref _cubes[i];  // ref: 구조체 복사 없이 직접 접근
			if (c.tr == null || c.mat == null) continue;

			// 나선 전체를 Z축 중심으로 천천히 회전
			float animAngle = c.baseAngle + t * rotationSpeed;

			// Z축 파동: 각 큐브가 물결치듯 앞뒤로 움직임
			float wave = Mathf.Sin(c.normalized * _waveFreqFull - t) * waveAmplitude;

			c.tr.localPosition = new Vector3(
					Mathf.Cos(animAngle) * c.radius,
					Mathf.Sin(animAngle) * c.radius,
					c.baseDepth + wave
			);

			// 큐브 자체도 나선 방향으로 자전
			c.tr.localRotation = Quaternion.Euler(0f, 0f, animAngle * Mathf.Rad2Deg);

			// 색상
			float hue = (hueBase + c.normalized * hueRange) % 1f;
			Color albedo = Color.HSVToRGB(hue, saturation, brightness);
			Color emission = Color.HSVToRGB(hue, 1f, c.normalized) * 0.5f;

			c.mat.SetColor("_BaseColor", albedo);
			c.mat.SetColor("_EmissionColor", emission);
		}
	}
}