🫧Art_007 GenArt Arrangements

다양한 배열 모드를 적용할 수 있는 보일러플레이트

📄GenArtArrangements.cs

using UnityEngine;
using System.Collections.Generic;

#if UNITY_EDITOR
using UnityEditor;
#endif

[ExecuteAlways]
public class GenArtArrangements : MonoBehaviour
{
    // ============================================================
    // 배열 모드
    // ============================================================
    public enum ArrangementMode
    {
        Grid,           // 직교 격자
        HexGrid,        // 육각 격자
        SineWave,       // X축 사인파 변위
        NoiseField,     // Perlin noise 3D 변위
        Circle,         // 동심원
        Spiral,         // 아르키메데스 나선
        Phyllotaxis,    // 피보나치/해바라기 배열
        Lissajous,      // 리사주 곡선
    }

    // ============================================================
    // 인스펙터 파라미터
    // ============================================================

    [Header("배열 모드")]
    public ArrangementMode mode = ArrangementMode.Grid;

    // ----- 구조 파라미터 (변경 시 재생성) -------------------------
    [Header("구조 설정 (변경 시 오브젝트 재생성)")]
    public int countX = 20;
    public int countY = 20;
    public float spacing = 1.0f;
    public float objectSize = 0.3f;

    [Header("Noise Field 설정")]
    public float noiseScale = 0.25f;
    public float noiseAmplitude = 2.5f;

    [Header("Sine Wave 설정")]
    public float sineFrequency = 1.0f;
    public float sineAmplitude = 2.0f;

    [Header("Phyllotaxis 설정")]
    [Tooltip("황금각 = 137.5077°. 살짝 바꾸면 전혀 다른 패턴이 나옵니다")]
    public float phyllotaxisAngle = 137.5077f;
    public float phyllotaxisRadius = 0.4f;

    [Header("Lissajous 설정")]
    public float lissA = 3f;
    public float lissB = 2f;
    public float lissDelta = 0f;   // 위상차 (라디안)
    public float lissScale = 8f;

    // ----- 애니메이션 파라미터 -----------------------------------
    [Header("애니메이션 설정 (실시간 반영)")]
    public float animSpeed = 1.0f;
    public float waveHeight = 1.5f;
    public float waveFrequency = 0.6f;

    // ----- 재질 설정 --------------------------------------------
    [Header("재질 설정")]
    public Mesh instanceMesh;
    public Material instanceMaterial;

    // ============================================================
    // 내부 데이터
    // ============================================================
    struct InstanceData
    {
        public Vector3 basePos;
        public float noiseOffset; // 인스턴스별 위상 (noise/wave 변주용)
    }

    List<InstanceData> _instances = new List<InstanceData>();
    Matrix4x4[] _matrices;
    int _totalCount;

    const int BATCH_SIZE = 1023;
    bool _generated = false;

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

    // 구조 파라미터 캐시
    ArrangementMode _cachedMode;
    int _cachedCountX, _cachedCountY;
    float _cachedSpacing, _cachedObjectSize;
    float _cachedNoiseScale, _cachedNoiseAmplitude;
    float _cachedSineFrequency, _cachedSineAmplitude;
    float _cachedPhylAngle, _cachedPhylRadius;
    float _cachedLissA, _cachedLissB, _cachedLissDelta, _cachedLissScale;

#if UNITY_EDITOR
    bool _generateQueued = false;
#endif

    // ============================================================
    // Unity 이벤트
    // ============================================================
    void OnEnable()
    {
        _pipeline = DetectPipeline();
        EnsureResources();
        Generate();
        CacheStructureParams();
    }

    void OnValidate()
    {
#if UNITY_EDITOR
        _pipeline = DetectPipeline();
        EnsureResources();
        if (StructureParamsChanged())
        {
            CacheStructureParams();
            QueueGenerate();
        }
        else
        {
            Animate(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 (!_generated) return;

        if (!Application.isPlaying)
        {
            Animate(0f);
            RenderInstances();
            return;
        }

        Animate(Time.time * animSpeed);
        RenderInstances();
    }

    // ============================================================
    // [아트워크 로직] Generate — 배열 공식
    // ============================================================
    void Generate()
    {
        _instances.Clear();
        _totalCount = countX * countY;

        for (int y = 0; y < countY; y++)
            for (int x = 0; x < countX; x++)
            {
                int idx = y * countX + x;
                float fx = x - (countX - 1) * 0.5f;   // 중심 기준 정규화
                float fy = y - (countY - 1) * 0.5f;

                Vector3 pos = Vector3.zero;

                switch (mode)
                {
                    // ── 직교 격자 ─────────────────────────────────────────
                    // 가장 기본. spacing으로 XZ 평면에 균등 배치
                    case ArrangementMode.Grid:
                        pos = new Vector3(fx * spacing, 0f, fy * spacing);
                        break;

                    // ── 육각 격자 ────────────────────────────────────────
                    // 짝수 행을 spacing * 0.5 만큼 X 오프셋하고
                    // Y 간격을 √3/2 배로 줄여 정삼각형 타일을 구성
                    case ArrangementMode.HexGrid:
                        {
                            float xOffset = (y % 2 == 0) ? 0f : spacing * 0.5f;
                            pos = new Vector3(
                                fx * spacing + xOffset,
                                0f,
                                fy * spacing * 0.866f);   // 0.866 ≈ √3/2
                            break;
                        }

                    // ── X축 사인파 ───────────────────────────────────────
                    // X 위치를 인수로 사인파를 계산해 Y 방향으로 변위
                    // Generate 시엔 t=0 스냅샷, Animate에서 실시간 갱신
                    case ArrangementMode.SineWave:
                        pos = new Vector3(fx * spacing, 0f, fy * spacing);
                        break;

                    // ── Perlin Noise 필드 ────────────────────────────────
                    // 각 인스턴스 위치를 seed로 노이즈를 샘플링해 Y 변위
                    // noiseOffset에 샘플 좌표를 저장해 Animate에서 재사용
                    case ArrangementMode.NoiseField:
                        pos = new Vector3(fx * spacing, 0f, fy * spacing);
                        break;

                    // ── 동심원 ───────────────────────────────────────────
                    // y = 반지름 인덱스, x = 각도 인덱스
                    // 각 링에 countX개 오브젝트를 균등 배치
                    case ArrangementMode.Circle:
                        {
                            float radius = (y + 1) * spacing;
                            float angle = (float)x / countX * Mathf.PI * 2f;
                            pos = new Vector3(
                                Mathf.Cos(angle) * radius,
                                0f,
                                Mathf.Sin(angle) * radius);
                            break;
                        }

                    // ── 아르키메데스 나선 ─────────────────────────────────
                    // 각도와 반지름이 모두 인덱스에 비례하여 증가
                    // countY를 감는 횟수로 사용
                    case ArrangementMode.Spiral:
                        {
                            float t = (float)idx / _totalCount;
                            float angle = t * Mathf.PI * 2f * countY;
                            float r = t * spacing * countX * 0.5f;
                            pos = new Vector3(Mathf.Cos(angle) * r, 0f, Mathf.Sin(angle) * r);
                            break;
                        }

                    // ── 피보나치 / 해바라기 (Phyllotaxis) ───────────────
                    // 황금각(137.5°)을 회전하면서 반지름은 √n 에 비례
                    // phyllotaxisAngle을 조금씩 바꾸면 완전히 다른 패턴
                    case ArrangementMode.Phyllotaxis:
                        {
                            float angle = idx * phyllotaxisAngle * Mathf.Deg2Rad;
                            float r = phyllotaxisRadius * Mathf.Sqrt(idx);
                            pos = new Vector3(Mathf.Cos(angle) * r, 0f, Mathf.Sin(angle) * r);
                            break;
                        }

                    // ── 리사주 곡선 (Lissajous) ──────────────────────────
                    // x(t) = sin(a·t + δ),  z(t) = sin(b·t)
                    // lissA, lissB 비율에 따라 다양한 곡선 패턴 생성
                    // countX * countY 개의 점을 곡선 위에 균등 분포
                    case ArrangementMode.Lissajous:
                        {
                            float t = (float)idx / (_totalCount - 1) * Mathf.PI * 2f;
                            float px = Mathf.Sin(lissA * t + lissDelta) * lissScale;
                            float pz = Mathf.Sin(lissB * t) * lissScale;
                            // Y 방향으로 살짝 무작위 변위를 주면 입체감이 생김
                            float py = Mathf.Cos((lissA + lissB) * t) * lissScale * 0.2f;
                            pos = new Vector3(px, py, pz);
                            break;
                        }
                }

                _instances.Add(new InstanceData
                {
                    basePos = pos,
                    noiseOffset = x * noiseScale + y * noiseScale * 1.3f  // 노이즈 샘플 좌표
                });
            }

        // GPU 전송 배열 초기화
        _matrices = new Matrix4x4[_totalCount];
        _generated = true;

        Animate(0f);  // 초기 스냅샷
    }

    // ============================================================
    // [아트워크 로직] Animate — 매 프레임 변위 공식
    // ============================================================
    void Animate(float t)
    {
        if (!_generated || _instances.Count == 0) return;

        for (int i = 0; i < _instances.Count; i++)
        {
            InstanceData inst = _instances[i];
            Vector3 pos = inst.basePos;
            Vector3 scale = Vector3.one * objectSize;

            switch (mode)
            {
                case ArrangementMode.Grid:
                case ArrangementMode.HexGrid:
                case ArrangementMode.Circle:
                case ArrangementMode.Spiral:
                case ArrangementMode.Phyllotaxis:
                case ArrangementMode.Lissajous:
                    // 기본 배열들: Y축으로 잔잔한 사인파 리플
                    float ripple = Mathf.Sin(
                        (pos.x + pos.z) * waveFrequency + t) * waveHeight * 0.3f;
                    pos.y += ripple;
                    break;

                case ArrangementMode.SineWave:
                    // X 위치를 인수로 사인파 Y 변위
                    pos.y = Mathf.Sin(pos.x * waveFrequency + t) * sineAmplitude;
                    break;

                case ArrangementMode.NoiseField:
                    // Perlin noise로 Y 변위 + 스케일 변조
                    float n = Mathf.PerlinNoise(inst.noiseOffset + t * 0.4f,
                                                inst.noiseOffset * 0.7f + t * 0.2f);
                    pos.y = (n - 0.5f) * 2f * noiseAmplitude;
                    scale = Vector3.one * objectSize * Mathf.Lerp(0.3f, 1.4f, n);
                    break;
            }

            Vector3 worldPos = transform.TransformPoint(pos);
            _matrices[i] = Matrix4x4.TRS(worldPos, transform.rotation, scale);
        }
    }

    // ============================================================
    // 인프라 코드 — 수정 불필요
    // ============================================================
    void RenderInstances()
    {
        if (instanceMesh == null || instanceMaterial == null) return;

        int total = _instances.Count;
        int index = 0;
        while (total > 0)
        {
            int batch = Mathf.Min(BATCH_SIZE, total);
            var batchMatrices = new Matrix4x4[batch];
            System.Array.Copy(_matrices, index, batchMatrices, 0, batch);

            Graphics.DrawMeshInstanced(
                instanceMesh, 0, instanceMaterial, batchMatrices, batch);

            index += batch;
            total -= batch;
        }
    }

    void EnsureResources()
    {
        if (instanceMesh == null)
        {
            var tmp = GameObject.CreatePrimitive(PrimitiveType.Cube);
            instanceMesh = tmp.GetComponent<MeshFilter>().sharedMesh;
            DestroyImmediate(tmp);
        }
        if (instanceMaterial == null)
        {
            Shader shader = null;
            switch (_pipeline)
            {
                case RenderPipeline.URP: shader = Shader.Find("Universal Render Pipeline/Lit"); break;
                case RenderPipeline.HDRP: shader = Shader.Find("HDRP/Lit"); break;
                default: shader = Shader.Find("Standard"); break;
            }
            instanceMaterial = new Material(shader);
            instanceMaterial.enableInstancing = true;
        }
    }

    bool StructureParamsChanged() =>
        mode != _cachedMode ||
        countX != _cachedCountX ||
        countY != _cachedCountY ||
        spacing != _cachedSpacing ||
        objectSize != _cachedObjectSize ||
        noiseScale != _cachedNoiseScale ||
        noiseAmplitude != _cachedNoiseAmplitude ||
        sineFrequency != _cachedSineFrequency ||
        sineAmplitude != _cachedSineAmplitude ||
        phyllotaxisAngle != _cachedPhylAngle ||
        phyllotaxisRadius != _cachedPhylRadius ||
        lissA != _cachedLissA ||
        lissB != _cachedLissB ||
        lissDelta != _cachedLissDelta ||
        lissScale != _cachedLissScale;

    void CacheStructureParams()
    {
        _cachedMode = mode;
        _cachedCountX = countX;
        _cachedCountY = countY;
        _cachedSpacing = spacing;
        _cachedObjectSize = objectSize;
        _cachedNoiseScale = noiseScale;
        _cachedNoiseAmplitude = noiseAmplitude;
        _cachedSineFrequency = sineFrequency;
        _cachedSineAmplitude = sineAmplitude;
        _cachedPhylAngle = phyllotaxisAngle;
        _cachedPhylRadius = phyllotaxisRadius;
        _cachedLissA = lissA;
        _cachedLissB = lissB;
        _cachedLissDelta = lissDelta;
        _cachedLissScale = lissScale;
    }

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