🫧Art_019 Spiral Vortex [GPU Instancing]

설명

• 나선형을 그리며 위로 올라가는 파티클
• 초기 색과 마지막 색 사이를 Lerp로 부드럽게 연결하기 위해서 shader 파일 작성해 연결
  • Shader.Find("Custom/SpiralVortexLit") : 조명 영향 받는 셰이더
  • Shader.Find("Custom/SpiralVortexUnlit") : 조명 영향 받지 않는 셰이더

색상 Lerp로 전체 그라데이션 만들 때

GPU Instancing으로 파티클을 만들 때 URP/Lit 셰이더는 DrawMeshInstanced + MaterialPropertyBlock의 _BaseColor를 per-instance로 읽지 않습니다. 이 상태는 전체에 동일한 색을 적용합니다.

그라데이션으로 덮으려면 UNITY_INSTANCING_BUFFER를 직접 선언한 커스텀 셰이더를 만듭니다. cs파일과 shader 두 파일을 같은 폴더에 두고 cs에서 커스텀 셰이더를 읽도록 합니다.

방식	per-instance 색상 동작
URP/Lit + MaterialPropertyBlock	❌ 내부적으로 SRP Batcher가 개입해 instanced prop 무시
커스텀 셰이더 + UNITY_INSTANCING_BUFFER	✅ #pragma multi_compile_instancing으로 각 인스턴스가 독립적으로 버퍼 접근

Unlit vs Lit 차이 :

이렇게 커스텀 셰이터를 만들 때 기본적으로 Unlit을 선택하면 라이팅 연산이 전혀 없어서 조명과 완전히 무관한 flat color로만 렌더됩니다.

항목	Unlit	Lit
조명 영향	❌	✅
음영 (Diffuse / Specular)	❌	✅
그림자 수신	❌	✅ (ShadowCaster Pass 필요)
Per-instance Color	✅ (직접 구현)	❌ (SRP Batcher 간섭)
퍼포먼스	가벼움	상대적으로 무거움

조명을 받으려면 셰이더에 라이팅 연산을 추가해야 합니다. 핵심은 두 가지입니다.

• 버텍스에서 월드 노멀 전달
• 프래그먼트에서 GetMainLight()로 메인 라이트를 받아 $Lambert Diffuse$ 계산

---

Code

📒 SpiralVortexGPUInstancing.cs

using System.Collections.Generic;
using UnityEngine;

#if UNITY_EDITOR
using UnityEditor;
#endif

[ExecuteAlways]
public class SpiralVortexGPUInstancing : MonoBehaviour
{
    enum RenderPipeline { BuiltIn, URP, HDRP }

    struct InstanceData
    {
        public float age;
        public float lifetime;
        public float baseAngle;
        public float radiusOffset;
        public float riseSpeed;
        public float size;
        public float noiseSeed;
    }

    // =========================================================
    [Header("Structure")]
    [SerializeField] int particleCount = 2000;
    [SerializeField] float spiralRadius = 2.0f;
    [SerializeField] float radiusJitter = 0.6f;
    [SerializeField] float maxHeight = 8.0f;
    [SerializeField] float riseSpeedMin = 1.0f;
    [SerializeField] float riseSpeedMax = 2.0f;
    [SerializeField] float twistSpeed = 3.0f;
    [SerializeField] int randomSeed = 1234;

    [Header("Radius Growth")]
    [SerializeField, Range(0.1f, 4f),
     Tooltip("반경 성장 곡선. 1=선형 / >1=아래쪽에서 좁게 유지, 위로 갈수록 벌어짐 / <1=빠르게 펼쳐짐")]
    float radiusGrowthCurve = 1.8f;

    [Header("Rise Speed Curve")]
    [SerializeField, Range(0.1f, 3f),
     Tooltip("상승 속도 곡선. <1=빠르게 출발 점점 감속 / 1=선형 / >1=천천히 출발 점점 가속")]
    float riseCurve = 0.4f;

    [Header("Scale")]
    [SerializeField] float minSize = 0.05f;
    [SerializeField] float maxSize = 0.18f;

    [Header("Color")]
    [SerializeField, Tooltip("파티클 생성 직후 색상 (하단)")]
    Color birthColor = new Color(0.2f, 0.8f, 1.0f, 1.0f);
    [SerializeField, Tooltip("파티클 소멸 직전 색상 (상단)")]
    Color deathColor = new Color(1.0f, 0.2f, 0.8f, 1.0f);
    [SerializeField] float emissionIntensity = 1.5f;

    [Header("Noise")]
    [SerializeField] float noiseStrength = 0.35f;
    [SerializeField] float noiseScale = 0.45f;
    [SerializeField] float noiseScrollSpeed = 0.7f;
    [SerializeField] float verticalNoiseAmount = 0.25f;

    [Header("Rendering")]
    [SerializeField] Mesh instanceMesh;
    [SerializeField] Material instanceMaterial;
    // =========================================================

    const int BATCH_SIZE = 1023;

    readonly List<InstanceData> _instances = new List<InstanceData>();
    Matrix4x4[] _matrices;
    Vector4[] _colors;
    Vector4[] _emissions;

    bool _generated;
    float _simTime;
    RenderPipeline _pipeline;

    // --- Structure cache ---
    int _cachedParticleCount;
    float _cachedSpiralRadius, _cachedRadiusJitter, _cachedMaxHeight;
    float _cachedRiseSpeedMin, _cachedRiseSpeedMax, _cachedTwistSpeed;
    float _cachedMinSize, _cachedMaxSize;
    int _cachedRandomSeed;

#if UNITY_EDITOR
    bool _generateQueued;
#endif

    // =========================================================
    void OnEnable()
    {
        _pipeline = DetectPipeline();
        EnsureResources();
        Generate();
        CacheStructureParams();
    }

    void OnValidate()
    {
        particleCount = Mathf.Max(1, particleCount);
        spiralRadius = Mathf.Max(0f, spiralRadius);
        radiusJitter = Mathf.Max(0f, radiusJitter);
        maxHeight = Mathf.Max(0.01f, maxHeight);
        riseSpeedMin = Mathf.Max(0.01f, riseSpeedMin);
        riseSpeedMax = Mathf.Max(riseSpeedMin, riseSpeedMax);
        minSize = Mathf.Max(0.001f, minSize);
        maxSize = Mathf.Max(minSize, maxSize);
        noiseStrength = Mathf.Max(0f, noiseStrength);
        noiseScale = Mathf.Max(0.001f, noiseScale);
        noiseScrollSpeed = Mathf.Max(0f, noiseScrollSpeed);
        verticalNoiseAmount = Mathf.Max(0f, verticalNoiseAmount);

#if UNITY_EDITOR
        _pipeline = DetectPipeline();
        EnsureResources();

        if (StructureParamsChanged())
        {
            CacheStructureParams();
            QueueGenerate();
        }
        else
        {
            Animate(Application.isPlaying ? _simTime : 0f);
        }
#endif
    }

    void Update()
    {
        if (!_generated) return;

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

        float dt = Time.deltaTime;
        _simTime += dt;

        StepSimulation(dt);
        Animate(_simTime);
        RenderInstances();
    }

    // =========================================================
    // 기본 메시를 Cube로 생성. 머티리얼은 파이프라인에 맞춰 자동 선택.
    void EnsureResources()
    {
        if (instanceMesh == null)
        {
            GameObject temp = GameObject.CreatePrimitive(PrimitiveType.Cube);
            instanceMesh = temp.GetComponent<MeshFilter>().sharedMesh;
            DestroyImmediate(temp);
        }

        if (instanceMaterial == null)
        {
            // 커스텀 셰이더 우선, 없으면 URP Unlit 폴백
            Shader shader =
                Shader.Find("Custom/SpiralVortexLit") ??
                Shader.Find("Universal Render Pipeline/Unlit") ??
                Shader.Find("Standard");

            instanceMaterial = new Material(shader);
            instanceMaterial.enableInstancing = true;
        }
    }

    // 파티클 배열 초기화 및 랜덤 배치
    void Generate()
    {
        _instances.Clear();
        _generated = false;
        _simTime = 0f;

        Random.InitState(randomSeed);

        for (int i = 0; i < particleCount; i++)
            _instances.Add(CreateParticle(true));

        _matrices = new Matrix4x4[_instances.Count];
        _colors = new Vector4[_instances.Count];
        _emissions = new Vector4[_instances.Count];

        _generated = true;
        Animate(0f);
    }

    InstanceData CreateParticle(bool randomizeAge)
    {
        float riseSpeed = Random.Range(riseSpeedMin, riseSpeedMax);
        float lifetime = maxHeight / riseSpeed;
        float age = randomizeAge ? Random.Range(0f, lifetime) : 0f;

        return new InstanceData
        {
            age = age,
            lifetime = lifetime,
            baseAngle = Random.Range(0f, Mathf.PI * 2f),
            radiusOffset = Random.Range(-radiusJitter, radiusJitter),
            riseSpeed = riseSpeed,
            size = Random.Range(minSize, maxSize),
            noiseSeed = Random.Range(0f, 1000f)
        };
    }

    void StepSimulation(float dt)
    {
        for (int i = 0; i < _instances.Count; i++)
        {
            InstanceData inst = _instances[i];
            inst.age += dt;
            if (inst.age >= inst.lifetime)
                inst = CreateParticle(false);
            _instances[i] = inst;
        }
    }

    // =========================================================
    // 매 프레임 모든 파티클의 위치 / 회전 / 색상 계산
    void Animate(float t)
    {
        if (_matrices == null || _colors == null || _emissions == null) return;

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

            float life01 = Mathf.Clamp01(inst.age / inst.lifetime);

            // riseCurve < 1 → 아래에서 빠르게 출발, 위로 갈수록 감속
            float curvedLife = Mathf.Pow(life01, riseCurve);
            float yBase = curvedLife * maxHeight;

            // --- 노이즈 ---
            float noiseTime = t * noiseScrollSpeed;
            float n1 = Mathf.PerlinNoise(inst.noiseSeed, yBase * noiseScale + noiseTime);
            float n2 = Mathf.PerlinNoise(inst.noiseSeed + 31.7f, yBase * noiseScale + noiseTime);
            float sn1 = (n1 - 0.5f) * 2f;
            float sn2 = (n2 - 0.5f) * 2f;

            // 반경: 하단에서 0 → 상단에서 spiralRadius 까지 성장 (radiusGrowthCurve로 곡선 제어)
            float angle = inst.baseAngle + inst.age * twistSpeed + sn1 * noiseStrength;
            float radius = Mathf.Pow(life01, radiusGrowthCurve) * spiralRadius
                           + inst.radiusOffset + sn2 * noiseStrength;
            radius = Mathf.Max(0.01f, radius);

            float y = yBase + sn1 * verticalNoiseAmount * noiseStrength;

            Vector3 localPos = new Vector3(Mathf.Cos(angle) * radius, y, Mathf.Sin(angle) * radius);
            Vector3 worldPos = transform.TransformPoint(localPos);
            Quaternion worldRot = transform.rotation * Quaternion.Euler(0f, -Mathf.Rad2Deg * angle, 0f);

            _matrices[i] = Matrix4x4.TRS(worldPos, worldRot, Vector3.one * inst.size);

            // 색상은 Y축 높이에 따라 birthColor → deathColor 그라데이션
            float heightT = Mathf.Clamp01(y / maxHeight);
            Color albedo = Color.Lerp(birthColor, deathColor, heightT);
            Color emission = albedo * emissionIntensity;

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

    // =========================================================
    // 1023개 단위 배치로 DrawMeshInstanced 호출
    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);

            Matrix4x4[] batchMatrices = new Matrix4x4[batch];
            Vector4[] batchColors = new Vector4[batch];

            System.Array.Copy(_matrices, index, batchMatrices, 0, batch);
            System.Array.Copy(_colors, index, batchColors, 0, batch);

            MaterialPropertyBlock block = new MaterialPropertyBlock();
            block.SetVectorArray("_BaseColor", batchColors);

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

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

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

    string GetColorPropertyName() => _pipeline switch
    {
        RenderPipeline.URP => "_BaseColor",
        RenderPipeline.HDRP => "_BaseColor",
        _ => "_Color"
    };

    string GetEmissionPropertyName() => _pipeline switch
    {
        RenderPipeline.HDRP => "_EmissiveColor",
        _ => "_EmissionColor"
    };

    // =========================================================
    bool StructureParamsChanged() =>
        _cachedParticleCount != particleCount ||
        !Mathf.Approximately(_cachedSpiralRadius, spiralRadius) ||
        !Mathf.Approximately(_cachedRadiusJitter, radiusJitter) ||
        !Mathf.Approximately(_cachedMaxHeight, maxHeight) ||
        !Mathf.Approximately(_cachedRiseSpeedMin, riseSpeedMin) ||
        !Mathf.Approximately(_cachedRiseSpeedMax, riseSpeedMax) ||
        !Mathf.Approximately(_cachedTwistSpeed, twistSpeed) ||
        !Mathf.Approximately(_cachedMinSize, minSize) ||
        !Mathf.Approximately(_cachedMaxSize, maxSize) ||
        _cachedRandomSeed != randomSeed;

    void CacheStructureParams()
    {
        _cachedParticleCount = particleCount;
        _cachedSpiralRadius = spiralRadius;
        _cachedRadiusJitter = radiusJitter;
        _cachedMaxHeight = maxHeight;
        _cachedRiseSpeedMin = riseSpeedMin;
        _cachedRiseSpeedMax = riseSpeedMax;
        _cachedTwistSpeed = twistSpeed;
        _cachedMinSize = minSize;
        _cachedMaxSize = maxSize;
        _cachedRandomSeed = randomSeed;
    }

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

📒 SpiralVortexUnlit.shader

Shader "Custom/SpiralVortexUnlit"
{
    Properties
    {
        [PerRendererData] _BaseColor ("Color", Color) = (1,1,1,1)
    }
    SubShader
    {
        Tags
        {
            "RenderType"      = "Opaque"
            "Queue"           = "Geometry"
            "RenderPipeline"  = "UniversalPipeline"
        }
        Cull Back
        ZWrite On

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

            HLSLPROGRAM
            #pragma vertex   vert
            #pragma fragment frag
            #pragma multi_compile_instancing

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

            // per-instance color 버퍼
            UNITY_INSTANCING_BUFFER_START(Props)
                UNITY_DEFINE_INSTANCED_PROP(float4, _BaseColor)
            UNITY_INSTANCING_BUFFER_END(Props)

            struct Attributes
            {
                float4 positionOS : POSITION;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            Varyings vert(Attributes IN)
            {
                Varyings OUT;
                UNITY_SETUP_INSTANCE_ID(IN);
                UNITY_TRANSFER_INSTANCE_ID(IN, OUT);
                OUT.positionCS = TransformObjectToHClip(IN.positionOS.xyz);
                return OUT;
            }

            half4 frag(Varyings IN) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(IN);
                return half4(UNITY_ACCESS_INSTANCED_PROP(Props, _BaseColor));
            }
            ENDHLSL
        }
    }
}

📒 SpiralVortexLit.shader

Shader "Custom/SpiralVortexLit"
{
    Properties
    {
        [PerRendererData] _BaseColor ("Color", Color) = (1,1,1,1)
        _Smoothness ("Smoothness", Range(0,1)) = 0.3
    }
    SubShader
    {
        Tags
        {
            "RenderType"     = "Opaque"
            "Queue"          = "Geometry"
            "RenderPipeline" = "UniversalPipeline"
        }
        Cull Back
        ZWrite On

        // --- 메인 조명 + 음영 패스 ---
        Pass
        {
            Name "UniversalForward"
            Tags { "LightMode" = "UniversalForward" }

            HLSLPROGRAM
            #pragma vertex   vert
            #pragma fragment frag
            #pragma multi_compile_instancing
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE
            #pragma multi_compile _ _SHADOWS_SOFT

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

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

            CBUFFER_START(UnityPerMaterial)
                float _Smoothness;
            CBUFFER_END

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

            struct Varyings
            {
                float4 positionCS  : SV_POSITION;
                float3 normalWS    : TEXCOORD0;
                float3 positionWS  : TEXCOORD1;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

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

                VertexPositionInputs posInputs = GetVertexPositionInputs(IN.positionOS.xyz);
                VertexNormalInputs   nrmInputs = GetVertexNormalInputs(IN.normalOS);

                OUT.positionCS = posInputs.positionCS;
                OUT.positionWS = posInputs.positionWS;
                OUT.normalWS   = nrmInputs.normalWS;
                return OUT;
            }

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

                float4 baseColor = UNITY_ACCESS_INSTANCED_PROP(Props, _BaseColor);

                // 메인 라이트
                float4 shadowCoord = TransformWorldToShadowCoord(IN.positionWS);
                Light  mainLight   = GetMainLight(shadowCoord);

                float3 normalWS  = normalize(IN.normalWS);
                float  NdotL     = saturate(dot(normalWS, mainLight.direction));

                // Lambert diffuse + ambient
                float3 ambient   = SampleSH(normalWS) * baseColor.rgb;
                float3 diffuse   = mainLight.color * mainLight.shadowAttenuation * NdotL * baseColor.rgb;

                return half4(ambient + diffuse, baseColor.a);
            }
            ENDHLSL
        }

        // --- 그림자 캐스터 패스 ---
        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"

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

            struct VaryingsShadow
            {
                float4 positionCS : SV_POSITION;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            VaryingsShadow vertShadow(AttributesShadow IN)
            {
                VaryingsShadow OUT;
                UNITY_SETUP_INSTANCE_ID(IN);
                UNITY_TRANSFER_INSTANCE_ID(IN, OUT);

                float3 posWS  = TransformObjectToWorld(IN.positionOS.xyz);
                float3 nrmWS  = TransformObjectToWorldNormal(IN.normalOS);
                float4 posCS  = TransformWorldToHClip(ApplyShadowBias(posWS, nrmWS, _LightDirection));

                // 뒤집힘 방지
                #if UNITY_REVERSED_Z
                    posCS.z = min(posCS.z, posCS.w * UNITY_NEAR_CLIP_VALUE);
                #else
                    posCS.z = max(posCS.z, posCS.w * UNITY_NEAR_CLIP_VALUE);
                #endif

                OUT.positionCS = posCS;
                return OUT;
            }

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

---