적용 방법

GameObject에 BoilerplateGPUInstancing.cs 하나만 붙입니다.

Hierarchy
└── GameObject (빈 오브젝트)
        └── BoilerplateGPUInstancing  ← 이것만 Add Component

GPUInstanceRenderer와 GenArtResources는 MonoBehaviour가 아닌 일반 C# 클래스입니다. Unity 컴포넌트 시스템 바깥에 있으므로 Inspector에 붙일 수 없고, 붙일 필요도 없습니다.

BoilerplateGPUInstancing   ← MonoBehaviour → GameObject에 붙는 것
        │ 상속
GenArtBase                 ← MonoBehaviour → 직접 붙이지 않음 (추상 클래스)
        │ 소유 (new)
GPUInstanceRenderer        ← 일반 클래스 → 붙이는 개념 자체가 없음
        │ 호출 (static)
GenArtResources            ← static 클래스 → 붙이는 개념 자체가 없음

GenArtBase도 MonoBehaviour이긴 하지만 abstract이기 때문에 Inspector의 Add Component 목록에 아예 나타나지 않습니다. BoilerplateGPUInstancing을 붙이는 순간 GenArtBase의 OnEnable, Update 등이 자동으로 함께 동작합니다.

참조 방식

Assets/
├── BoilerplateGPUInstancing.cs     
├── GenArtBase.cs           
├── GenArtResources.cs
├── GPUInstanceRenderer.cs 
└── GPUInstancingLit.shader

C#은 같은 어셈블리(Assembly) 안에 있으면 자동으로 서로를 인식합니다.
Unity 프로젝트에서 Assets/ 폴더 안의 모든 .cs 파일은 기본적으로 Assembly-CSharp 라는 하나의 어셈블리로 컴파일됩니다. 같은 어셈블리 안이면 별도의 import 개념 없이 클래스 이름만으로 바로 참조할 수 있습니다.

GPUInstanceRenderer를 MonoBehaviour가 아닌 일반 클래스로 만든 이유

드로우 콜 전담 객체는 Unity 이벤트가 필요 없습니다. GenArtBase가 new GPUInstanceRenderer(mesh, mat)로 소유하는 형태가 인스펙터 노출 없이 깔끔합니다. Inspector에서 mesh/material이 교체될 때 EnsureResources()에서 자동으로 재구성됩니다.

GenArtBase가 Time.time을 그대로 넘기는 이유

waveSpeed 같은 스케일 파라미터는 서브클래스 고유 값입니다. 베이스가 알 수 없으므로 Time.time을 날것으로 전달하고 Animate() 내부에서 t * waveSpeed로 처리합니다.

새 아트워크를 만들 때

BoilerplateGPUInstancing.cs를 복사 → 클래스명 변경 → Generate() 배치 공식, Animate() 수식, 인스펙터 파라미터, 캐시 4곳만 수정하면 됩니다. GenArtBase, GPUInstanceRenderer, GenArtResources는 손댈 필요가 없습니다.

Codes

📄BoilerplateGPUInstancing.cs

using UnityEngine;
using System.Collections.Generic;

// ============================================================
// 보일러플레이트 아트워크 — GenArtBase 서브클래스
//
// 수정해야 할 곳은 두 군데뿐입니다.
//   Generate() : 인스턴스를 몇 개, 어떤 패턴으로 배치할 것인가
//   Animate(t) : 매 프레임 위치·색상을 어떤 수식으로 계산할 것인가
//
// 구조 파라미터(재생성이 필요한 것) vs 시각 파라미터(실시간 반영)를
// 구분해서 인스펙터 헤더를 나누고,
// StructureParamsChanged() / CacheStructureParams()를 함께 관리합니다.
// ============================================================
public class BoilerplateGPUInstancing : GenArtBase
{
    // ============================================================
    // 인스펙터 파라미터
    // ============================================================

    // ----- 구조 파라미터 (변경 시 Generate 재실행) ---------------
    [Header("구조 설정 (변경 시 오브젝트 재생성)")]
    public int   gridSize  = 100;
    public float spacing   = 0.38f;
    public float cubeSize  = 0.30f;
    public int   colorSeed = 0;

    // ----- 시각 파라미터 (변경 시 Animate(0f)만 재실행) ----------
    [Header("애니메이션 설정 (실시간 반영)")]
    public float waveHeight    = 0.60f;
    public float waveSpeed     = 1.2f;
    public float waveFrequency = 0.6f;

    [Header("색상 설정 (실시간 반영)")]
    [Range(0f, 1f)] public float hueBase    = 0.58f;
    [Range(0f, 1f)] public float hueRange   = 0.04f;
    [Range(0f, 1f)] public float saturation = 0.80f;
    public float emissionIntensity = 1.0f;

    // ============================================================
    // 인스턴스 데이터
    // Generate에서 한 번만 계산되는 정적 데이터입니다.
    // Animate에서 매 프레임 참조하지만 값을 변경하지 않습니다.
    // ============================================================
    struct InstanceData
    {
        public Vector3 basePos;    // 기준 위치 (Y = 0 평면)
        public float   hue;        // 고유 색상
        public float   brightness; // 기본 밝기
    }

    readonly List<InstanceData> _instances = new List<InstanceData>();

    // 구조 파라미터 캐시 — OnValidate에서 변경 감지에 사용합니다.
    int   _cachedGridSize;
    float _cachedSpacing;
    float _cachedCubeSize;
    int   _cachedColorSeed;

    // ============================================================
    // Generate — [아트워크 로직] 배치 공식을 여기서 수정합니다.
    // ============================================================
    protected override void Generate()
    {
        _instances.Clear();
        _generated = false;

        Random.InitState(colorSeed); // 같은 시드 = 항상 동일한 색상 배치

        // 그리드 중심을 로컬 원점(0,0,0)에 맞춥니다.
        float offset = (gridSize - 1) * spacing * 0.5f;

        for (int x = 0; x < gridSize; x++)
        {
            for (int z = 0; z < gridSize; z++)
            {
                _instances.Add(new InstanceData
                {
                    basePos    = new Vector3(x * spacing - offset, 0f, z * spacing - offset),
                    hue        = (hueBase + Random.value * hueRange) % 1f,
                    brightness = Random.Range(0.5f, 1.0f)
                });
            }
        }

        // GPU 전송 배열을 인스턴스 수에 맞게 사전 할당합니다.
        int count  = _instances.Count;
        _matrices  = new Matrix4x4[count];
        _colors    = new Vector4[count];
        _emissions = new Vector4[count];

        _generated = true;
        Animate(0f); // 생성 직후 초기 상태 계산
    }

    // ============================================================
    // Animate — [아트워크 로직] 애니메이션 수식을 여기서 수정합니다.
    // t : GenArtBase.Update()에서 Time.time을 전달합니다.
    //     에디터 씬 뷰 / 초기화 시에는 0f가 전달됩니다.
    // ============================================================
    protected override void Animate(float t)
    {
        if (!_generated) return;

        float animT = t * waveSpeed; // 시간 스케일 적용

        for (int i = 0; i < _instances.Count; i++)
        {
            InstanceData inst = _instances[i];

            // X + Z 좌표 합으로 대각선 방향 사인파를 만듭니다.
            float wave = Mathf.Sin(
                (inst.basePos.x + inst.basePos.z) * waveFrequency + animT
            ) * waveHeight;

            // -1~+1 범위를 0~1로 정규화합니다. 색상·밝기 변조에 사용합니다.
            float normalized = (wave / waveHeight + 1f) * 0.5f;

            // 로컬 → 월드 좌표 변환 (부모 GameObject의 위치·회전 반영)
            Vector3 worldPos = transform.TransformPoint(
                new Vector3(inst.basePos.x, wave, inst.basePos.z)
            );

            _matrices[i] = Matrix4x4.TRS(
                worldPos,
                transform.rotation,
                Vector3.one * cubeSize
            );

            float animBrightness = inst.brightness * Mathf.Lerp(0.2f, 1.0f, normalized);
            Color albedo   = Color.HSVToRGB(inst.hue, saturation, animBrightness);
            Color emission = Color.HSVToRGB(inst.hue, saturation, normalized) * emissionIntensity;

            _colors[i]    = new Vector4(albedo.r,   albedo.g,   albedo.b,   1f);
            _emissions[i] = new Vector4(emission.r, emission.g, emission.b, 1f);
        }
    }

    // ============================================================
    // 구조 파라미터 캐시 — 구조 파라미터를 추가/제거하면 여기도 함께 수정합니다.
    // ============================================================

    protected override bool StructureParamsChanged()
    {
        return gridSize  != _cachedGridSize
            || spacing   != _cachedSpacing
            || cubeSize  != _cachedCubeSize
            || colorSeed != _cachedColorSeed;
    }

    protected override void CacheStructureParams()
    {
        _cachedGridSize  = gridSize;
        _cachedSpacing   = spacing;
        _cachedCubeSize  = cubeSize;
        _cachedColorSeed = colorSeed;
    }
}

📄GenArtBase.cs

using UnityEngine;

#if UNITY_EDITOR
using UnityEditor;
#endif

// ============================================================
// 생성 아트 베이스 클래스
// Unity 라이프사이클(OnEnable / OnValidate / Update)과
// 에디터 안전 패턴(QueueGenerate)을 전담합니다.
//
// 서브클래스는 4개의 abstract 메서드만 구현하면 됩니다.
//   Generate()             — 배치 공식
//   Animate(float t)       — 애니메이션 공식
//   StructureParamsChanged() — 구조 파라미터 변경 감지
//   CacheStructureParams() — 구조 파라미터 캐시 저장
// ============================================================
[ExecuteAlways]
public abstract class GenArtBase : MonoBehaviour
{
    [Header("렌더 리소스 (비워두면 자동 생성)")]
    public Mesh     instanceMesh;
    public Material instanceMaterial;

    // 서브클래스에서 Animate()가 채우고 RenderInstances()가 읽습니다.
    protected Matrix4x4[] _matrices;
    protected Vector4[]   _colors;
    protected Vector4[]   _emissions;

    // false이면 Update에서 렌더링을 건너뜁니다.
    protected bool _generated;

    GPUInstanceRenderer _renderer;

#if UNITY_EDITOR
    bool _generateQueued;
#endif

    // ============================================================
    // Unity 이벤트 — 서브클래스에서 override 불필요
    // ============================================================

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

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

        if (StructureParamsChanged())
        {
            // 구조 파라미터 변경 → 재생성 예약
            CacheStructureParams();
            QueueGenerate();
        }
        else
        {
            // 시각 파라미터 변경 → 재생성 없이 즉시 갱신
            Animate(0f);
        }
#endif
    }

    void Update()
    {
        if (!_generated || _renderer == null) return;

        if (!Application.isPlaying)
        {
            // 씬 뷰: 정지 상태로 렌더링합니다.
            Animate(0f);
            _renderer.Render(_matrices, _colors, _emissions, _matrices.Length);
            return;
        }

        // Play 모드: 시간 기반 애니메이션
        Animate(Time.time);
        _renderer.Render(_matrices, _colors, _emissions, _matrices.Length);
    }

    // ============================================================
    // 리소스 초기화
    // ============================================================

    // 메시·머티리얼이 없으면 자동 생성하고 renderer를 (재)구성합니다.
    void EnsureResources()
    {
        if (instanceMesh     == null) instanceMesh     = GenArtResources.CreateDefaultMesh();
        if (instanceMaterial == null) instanceMaterial = GenArtResources.CreateDefaultMaterial();

        // 인스펙터에서 mesh/material이 교체될 경우를 위해 항상 재구성합니다.
        _renderer = new GPUInstanceRenderer(instanceMesh, instanceMaterial);
    }

    // ============================================================
    // 에디터 안전 Generate 예약
    // ============================================================

    // OnValidate 컨텍스트에서 직접 씬을 수정하면 Unity 직렬화와 충돌합니다.
    // delayCall로 에디터 루프 다음 틱에 안전하게 실행합니다.
#if UNITY_EDITOR
    void QueueGenerate()
    {
        if (_generateQueued) return;
        _generateQueued = true;

        EditorApplication.delayCall += () =>
        {
            _generateQueued = false;
            if (this == null) return; // 오브젝트가 삭제된 경우 방어
            Generate();
        };
    }
#endif

    // ============================================================
    // 서브클래스 구현 요구 — 아트워크 로직
    // ============================================================

    // 인스턴스 배치를 계산하고 _matrices, _colors, _emissions 배열을 구성합니다.
    // 마지막에 _generated = true 를 세팅하고 Animate(0f)를 호출해야 합니다.
    protected abstract void Generate();

    // 매 프레임(또는 t=0 정지 상태) 기준으로 _matrices, _colors, _emissions를 갱신합니다.
    // t 값: Update에서는 Time.time, 에디터/초기화에서는 0f
    protected abstract void Animate(float t);

    // 구조 파라미터(오브젝트 수·배치 형태를 결정하는 파라미터)가 바뀌었으면 true를 반환합니다.
    protected abstract bool StructureParamsChanged();

    // 현재 구조 파라미터 값을 캐시에 저장합니다.
    protected abstract void CacheStructureParams();
}

📄GenArtResources.cs

using UnityEngine;
using UnityEngine.Rendering;

// ============================================================
// 메시·머티리얼 자동 생성 유틸리티
// Shader.Find() 대신 씬의 기존 Renderer 또는 GraphicsSettings에서
// 셰이더를 추출합니다. Shader.Find()는 Always Included Shaders에
// 등록되지 않은 셰이더를 런타임에 찾지 못하는 경우가 있습니다.
// ============================================================
public static class GenArtResources
{
    // 임시 Primitive에서 큐브 메시를 추출 후 즉시 삭제합니다.
    // 씬 계층(Hierarchy)에 잔류 오브젝트를 남기지 않습니다.
    public static Mesh CreateDefaultMesh()
    {
        GameObject temp = GameObject.CreatePrimitive(PrimitiveType.Cube);
        Mesh mesh = temp.GetComponent<MeshFilter>().sharedMesh;
        Object.DestroyImmediate(temp);
        return mesh;
    }

    public static Material CreateDefaultMaterial()
    {
        Shader shader = ResolveShader();

        if (shader == null)
        {
            Debug.LogError("[GenArtResources] 유효한 셰이더를 찾을 수 없습니다. " +
                           "instanceMaterial을 인스펙터에서 직접 할당하세요.");
            return null;
        }

        Debug.Log($"[GenArtResources] 사용 셰이더: {shader.name}");

        Material mat = new Material(shader);
        mat.enableInstancing = true;
        mat.EnableKeyword("_EMISSION");
        mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;

        return mat;
    }

    // ============================================================
    // 셰이더 해결 순서
    // 1순위: 커스텀 인스턴싱 셰이더 (SRP Batcher 간섭 없음)
    // 2순위: Shader.Find() 폴백
    // ============================================================
    static Shader ResolveShader()
    {
        // 1순위: UNITY_INSTANCING_BUFFER 기반 커스텀 셰이더
        // SRP Batcher가 활성화된 URP에서 per-instance 색상을 정확히 전달합니다.
        Shader custom = Shader.Find("Custom/GPUInstancingLit");
        if (custom != null) return custom;

        // 2순위: 폴백 (커스텀 셰이더 파일이 없는 경우)
        Debug.LogWarning("[GenArtResources] Custom/GPUInstancingLit 셰이더를 찾을 수 없습니다. " +
                         "GPUInstancingLit.shader를 Assets 폴더에 추가하세요.");
        return Shader.Find("Universal Render Pipeline/Lit")
            ?? Shader.Find("Standard");
    }
}

📄GPUInstanceRenderer.cs

using UnityEngine;

// ============================================================
// GPU Instancing 드로우 콜 전담 클래스
// MonoBehaviour가 아닌 순수 C# 클래스입니다.
// GenArtBase가 소유하며, 아트워크 클래스에서 직접 건드리지 않습니다.
// ============================================================
public class GPUInstanceRenderer
{
    const int BATCH_SIZE = 1023;

    readonly Mesh     _mesh;
    readonly Material _material;

    public GPUInstanceRenderer(Mesh mesh, Material material)
    {
        _mesh     = mesh;
        _material = material;
    }

    // matrices / colors / emissions 배열을 1023개 단위 배치로 나눠 GPU에 전송합니다.
    // count는 배열의 실제 사용 길이입니다 (배열 크기와 다를 수 있음).
    public void Render(Matrix4x4[] matrices, Vector4[] colors, Vector4[] emissions, int count)
    {
        if (_mesh == null || _material == null || count == 0) return;

        int index     = 0;
        int remaining = count;

        while (remaining > 0)
        {
            int batch = Mathf.Min(BATCH_SIZE, remaining);

            // 배치 크기만큼 슬라이스 복사합니다.
            Matrix4x4[] batchMatrices  = new Matrix4x4[batch];
            Vector4[]   batchColors    = new Vector4[batch];
            Vector4[]   batchEmissions = new Vector4[batch];

            System.Array.Copy(matrices,  index, batchMatrices,  0, batch);
            System.Array.Copy(colors,    index, batchColors,    0, batch);
            System.Array.Copy(emissions, index, batchEmissions, 0, batch);

            // 배치마다 new로 생성해야 이전 배치 데이터와 간섭이 없습니다.
            MaterialPropertyBlock block = new MaterialPropertyBlock();
            block.SetVectorArray("_BaseColor",     batchColors);
            block.SetVectorArray("_EmissionColor", batchEmissions);

            Graphics.DrawMeshInstanced(
                _mesh, 0, _material,
                batchMatrices, batch, block
            );

            index     += batch;
            remaining -= batch;
        }
    }
}

📄GPUInstancingLit.shader

Shader "Custom/GPUInstancingLit"
{
    Properties
    {
        _BaseColor   ("Base Color",   Color) = (1,1,1,1)
        _EmissionColor ("Emission Color", Color) = (0,0,0,1)
    }

    SubShader
    {
        Tags
        {
            "RenderType"      = "Opaque"
            "RenderPipeline"  = "UniversalPipeline"
            "Queue"           = "Geometry"
        }

        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode" = "UniversalForward" }

            HLSLPROGRAM
            #pragma vertex   vert
            #pragma fragment frag

            // GPU Instancing 활성화
            #pragma multi_compile_instancing

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

            // --------------------------------------------------------
            // 인스턴스별 프로퍼티 버퍼
            // UNITY_INSTANCING_BUFFER 안에 선언된 변수는
            // 인스턴스마다 다른 값을 GPU에서 직접 읽습니다.
            // MaterialPropertyBlock.SetVectorArray()로 채운 값이 여기로 들어옵니다.
            // --------------------------------------------------------
            UNITY_INSTANCING_BUFFER_START(Props)
                UNITY_DEFINE_INSTANCED_PROP(float4, _BaseColor)
                UNITY_DEFINE_INSTANCED_PROP(float4, _EmissionColor)
            UNITY_INSTANCING_BUFFER_END(Props)

            struct Attributes
            {
                float4 positionOS : POSITION;
                float3 normalOS   : NORMAL;
                UNITY_VERTEX_INPUT_INSTANCE_ID  // 인스턴스 ID 입력
            };

            struct Varyings
            {
                float4 positionHCS : SV_POSITION;
                float3 normalWS    : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID  // fragment로 전달용
            };

            Varyings vert(Attributes IN)
            {
                Varyings OUT;

                // 인스턴스 ID를 현재 컨텍스트에 세팅합니다.
                // UNITY_ACCESS_INSTANCED_PROP 사용 전 반드시 필요합니다.
                UNITY_SETUP_INSTANCE_ID(IN);
                UNITY_TRANSFER_INSTANCE_ID(IN, OUT);

                OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
                OUT.normalWS    = TransformObjectToWorldNormal(IN.normalOS);
                return OUT;
            }

            half4 frag(Varyings IN) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(IN);

                // 인스턴스별 버퍼에서 이 인스턴스의 색상을 읽습니다.
                float4 baseColor     = UNITY_ACCESS_INSTANCED_PROP(Props, _BaseColor);
                float4 emissionColor = UNITY_ACCESS_INSTANCED_PROP(Props, _EmissionColor);

                // 간단한 Lambert diffuse 조명
                Light mainLight = GetMainLight();
                float3 normalWS = normalize(IN.normalWS);
                float  NdotL    = saturate(dot(normalWS, mainLight.direction));
                float3 diffuse  = baseColor.rgb * mainLight.color * NdotL;

                // ambient + diffuse + emission
                float3 ambient = baseColor.rgb * 0.2;
                float3 color   = ambient + diffuse + emissionColor.rgb;

                return half4(color, baseColor.a);
            }
            ENDHLSL
        }

        // ShadowCaster Pass — 그림자 투영을 위해 필요합니다.
        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode" = "ShadowCaster" }

            ZWrite On
            ZTest LEqual
            ColorMask 0

            HLSLPROGRAM
            #pragma vertex   vertShadow
            #pragma fragment fragShadow
            #pragma multi_compile_instancing

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl"

            UNITY_INSTANCING_BUFFER_START(Props)
                UNITY_DEFINE_INSTANCED_PROP(float4, _BaseColor)
                UNITY_DEFINE_INSTANCED_PROP(float4, _EmissionColor)
            UNITY_INSTANCING_BUFFER_END(Props)

            struct Attributes
            {
                float4 positionOS : POSITION;
                float3 normalOS   : NORMAL;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float4 positionHCS : SV_POSITION;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            Varyings vertShadow(Attributes IN)
            {
                Varyings OUT;
                UNITY_SETUP_INSTANCE_ID(IN);
                UNITY_TRANSFER_INSTANCE_ID(IN, OUT);

                float3 posWS      = TransformObjectToWorld(IN.positionOS.xyz);
                float3 normalWS   = TransformObjectToWorldNormal(IN.normalOS);
                float4 posHCS     = TransformWorldToHClip(
                                        ApplyShadowBias(posWS, normalWS, _MainLightPosition.xyz)
                                    );
                OUT.positionHCS = posHCS;
                return OUT;
            }

            half4 fragShadow(Varyings IN) : SV_Target
            {
                return 0;
            }
            ENDHLSL
        }
    }
}