🫧Art_021 Mesh Volume Artwork

BamgasiJM·2026년 4월 2일

Unity GenArt

목록 보기

32/41

MeshVolumeArtwork — 아트워크 개요 및 기술 문서

1. 아트워크 개요

FBX로 제작한 3D 모델링의 내부 부피를 수천 개의 작은 파티클로 채우고, 각 파티클이 Perlin Noise를 기반으로 메시 내부에서 천천히 부유하는 생성 아트워크입니다.
파티클은 모델링의 겉 표면이 아닌 닫힌 메시의 내부 공간에 무작위로 배치됩니다. 파티클 자체는 Unity의 Particle System을 사용하지 않으며, GPU Instancing으로 수천 개를 단일 드로우 콜에 가까운 비용으로 렌더링합니다.

2. 전체 시스템 구조

이 아트워크는 4개의 파일로 구성된 모듈 시스템 위에서 동작합니다.

GenArtResources	        — 메시·머티리얼 자동 생성 (static 유틸)
GPUInstanceRenderer     — DrawMeshInstanced 1023 배치 분할 (일반 클래스)
GenArtBase              — Unity 라이프사이클 전담 (abstract MonoBehaviour)
  └── MeshVolumeArtwork — 아트워크 로직 (concrete 서브클래스)

MeshVolumeArtwork는 GenArtBase를 상속하고 4개의 abstract 메서드만 구현합니다. Unity 이벤트(OnEnable, OnValidate, Update), 에디터 안전 패턴(QueueGenerate), GPU 드로우 호출은 모두 상위 클래스가 처리합니다.

3. 실행 흐름

OnEnable()
  └── Generate()
        ├── BuildWorldTriangleCache()   삼각형 데이터를 월드 공간으로 변환·캐싱
        ├── CalcWorldBounds()           월드 바운딩 박스 계산
        ├── Rejection Sampling 루프     내부 판정 통과한 점만 _instances에 추가
        │     └── IsInsideWorld()
        │           └── RayIntersectsTriangle() (삼각형 수만큼 반복)
        └── Animate(0f)                 초기 정지 상태 계산

Update() → 매 프레임
  ├── Animate(Time.time)               _matrices, _colors 갱신
  └── GPUInstanceRenderer.Render()     DrawMeshInstanced 호출

파일 구조

Assets/
├── GPUInstancingLit.shader ← 셰이더
├── GenArtResources.cs ← 유틸
├── GenArtBase.cs ← 베이스 클래스
├── GPUInstanceRenderer.cs ← 드로우 클래스
└── MeshVolumeArtwork.cs ← 메시 내부 파티클 아트워크

코드

📒 MeshVolumeArtwork.cs

using UnityEngine;
using System.Collections.Generic;

// ============================================================
// MeshVolumeArtwork — GenArtBase 서브클래스
//
// FBX 메시의 내부 부피를 파티클로 채우고 Perlin Noise로 부유시킵니다.
//
// [내부 판정 전략]
// 삼각형을 월드 공간으로 변환해서 캐싱합니다.
// FBX Import 시 Unity가 적용하는 스케일/회전이 자동으로 반영됩니다.
// 샘플 후보 점에 미세 지터를 추가해 엣지 통과 수치 오류를 회피합니다.
// ============================================================
public class MeshVolumeArtwork : GenArtBase
{
    // ============================================================
    // 인스펙터 파라미터
    // ============================================================

    [Header("구조 설정 (변경 시 재생성)")]
    public MeshFilter targetMeshFilter;
    public int        particleCount = 3000;
    public int        colorSeed     = 0;

    [Header("파티클 설정 (실시간 반영)")]
    [Range(0.005f, 0.3f)] public float particleSize = 0.04f;

    [Header("부유 설정 (실시간 반영)")]
    [Tooltip("노이즈 시간 진행 속도")]
    [Range(0f,     3f)]   public float floatSpeed     = 0.4f;

    [Tooltip("노이즈 공간 주파수")]
    [Range(0.01f,  3f)]   public float noiseScale     = 0.6f;

    [Tooltip("대범위 부유 크기. 0이어도 baseJitter로 항상 미세하게 움직입니다.")]
    [Range(0f,     5f)] public float floatAmplitude = 0.0f;

    [Tooltip("항상 적용되는 최소 진동 크기")]
    [Range(0.001f, 0.05f)] public float baseJitter    = 0.008f;

    [Header("색상 설정 (실시간 반영)")]
    [Range(0f, 1f)] public float hueBase    = 0.55f;
    [Range(0f, 1f)] public float hueRange   = 0.30f;
    [Range(0f, 1f)] public float saturation = 0.75f;
    [Range(0f, 1f)] public float brightness = 0.90f;

    // ============================================================
    // 인스턴스 데이터
    // ============================================================

    struct InstanceData
    {
        public Vector3 worldBasePos; // 월드 공간 기준 위치
        public float   hue;
        public float   phase;
        public float   jitterAmp;
    }

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

    // 월드 공간 삼각형 캐시
    Vector3[] _triA;
    Vector3[] _triB;
    Vector3[] _triC;

    // 샘플링용 월드 바운딩 박스
    Bounds _worldBounds;

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

    MeshFilter _cachedMeshFilter;
    int        _cachedParticleCount;
    int        _cachedColorSeed;

    // ============================================================
    // Generate
    // ============================================================

    protected override void Generate()
    {
        _instances.Clear();
        _generated = false;

        if (targetMeshFilter == null || targetMeshFilter.sharedMesh == null)
        {
            Debug.LogWarning("[MeshVolumeArtwork] Target Mesh Filter가 할당되지 않았습니다.");
            return;
        }

        Mesh      mesh          = targetMeshFilter.sharedMesh;
        Transform meshTransform = targetMeshFilter.transform;

        // 삼각형을 월드 공간으로 변환해서 캐싱합니다.
        // localToWorldMatrix 한 번으로 스케일·회전·위치가 모두 반영됩니다.
        BuildWorldTriangleCache(mesh, meshTransform);

        // 월드 공간 바운딩 박스를 계산합니다.
        _worldBounds = CalcWorldBounds(mesh.bounds, meshTransform);

        Random.InitState(colorSeed);
        int maxAttempts = particleCount * 30;
        int attempts    = 0;

        while (_instances.Count < particleCount && attempts < maxAttempts)
        {
            attempts++;

            // 월드 공간에서 랜덤 후보점을 생성합니다.
            Vector3 candidate = new Vector3(
                Random.Range(_worldBounds.min.x, _worldBounds.max.x),
                Random.Range(_worldBounds.min.y, _worldBounds.max.y),
                Random.Range(_worldBounds.min.z, _worldBounds.max.z)
            );

            // 엣지 통과 수치 오류 방지: 후보점에 미세 지터를 추가합니다.
            // 방향이 아니라 점 자체를 흔들어야 엣지 케이스를 안전하게 회피합니다.
            Vector3 jittered = candidate + new Vector3(
                (Random.value - 0.5f) * 0.0001f,
                (Random.value - 0.5f) * 0.0001f,
                (Random.value - 0.5f) * 0.0001f
            );

            if (IsInsideWorld(jittered))
            {
                _instances.Add(new InstanceData
                {
                    worldBasePos = candidate, // 원래 좌표 저장 (지터 없는 값)
                    hue          = (hueBase + Random.value * hueRange) % 1f,
                    phase        = Random.Range(0f, 100f),
                    jitterAmp    = Random.Range(0.7f, 1.3f)
                });
            }
        }

        if (_instances.Count == 0)
        {
            Debug.LogError("[MeshVolumeArtwork] 파티클을 배치하지 못했습니다. " +
                           "메시가 닫힌 형태(Closed Mesh)인지 확인하세요.");
            return;
        }

        if (_instances.Count < particleCount)
            Debug.LogWarning($"[MeshVolumeArtwork] 목표 {particleCount}개 중 {_instances.Count}개 배치. " +
                             $"(시도: {attempts}회)");
        else
            Debug.Log($"[MeshVolumeArtwork] {_instances.Count}개 배치 완료. (시도: {attempts}회)");

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

        _generated = true;
        Animate(0f);
    }

    // ============================================================
    // 삼각형 캐시 — 월드 공간으로 변환해서 저장합니다.
    // FBX의 localScale이 (0.01, 0.01, 0.01)이어도 정확하게 반영됩니다.
    // ============================================================

    void BuildWorldTriangleCache(Mesh mesh, Transform t)
    {
        Vector3[]  verts    = mesh.vertices;
        int[]      tris     = mesh.triangles;
        int        triCount = tris.Length / 3;
        Matrix4x4  l2w      = t.localToWorldMatrix;

        _triA = new Vector3[triCount];
        _triB = new Vector3[triCount];
        _triC = new Vector3[triCount];

        for (int i = 0; i < triCount; i++)
        {
            _triA[i] = l2w.MultiplyPoint3x4(verts[tris[i * 3 + 0]]);
            _triB[i] = l2w.MultiplyPoint3x4(verts[tris[i * 3 + 1]]);
            _triC[i] = l2w.MultiplyPoint3x4(verts[tris[i * 3 + 2]]);
        }
    }

    // ============================================================
    // 메시 내부 판정 — 월드 공간 단일 방향 레이캐스트
    //
    // +Y 방향으로 발사한 광선의 교차 횟수가 홀수이면 내부입니다.
    // 삼각형이 월드 공간으로 변환되어 있으므로 스케일 불일치 오류가 없습니다.
    // ============================================================

    bool IsInsideWorld(Vector3 worldPoint)
    {
        int hits = 0;
        for (int i = 0; i < _triA.Length; i++)
        {
            if (RayIntersectsTriangle(worldPoint, Vector3.up, _triA[i], _triB[i], _triC[i]))
                hits++;
        }
        return hits % 2 == 1;
    }

    // Möller–Trumbore 광선-삼각형 교차 알고리즘
    static bool RayIntersectsTriangle(Vector3 origin, Vector3 direction,
                                      Vector3 a,      Vector3 b,      Vector3 c)
    {
        const float EPSILON = 1e-6f;

        Vector3 edge1 = b - a;
        Vector3 edge2 = c - a;
        Vector3 h     = Vector3.Cross(direction, edge2);
        float   det   = Vector3.Dot(edge1, h);

        if (det > -EPSILON && det < EPSILON) return false;

        float   invDet = 1f / det;
        Vector3 s      = origin - a;
        float   u      = invDet * Vector3.Dot(s, h);

        if (u < 0f || u > 1f) return false;

        Vector3 q = Vector3.Cross(s, edge1);
        float   v = invDet * Vector3.Dot(direction, q);

        if (v < 0f || u + v > 1f) return false;

        float t = invDet * Vector3.Dot(edge2, q);
        return t > EPSILON;
    }

    // ============================================================
    // 월드 바운딩 박스 계산
    // ============================================================

    static Bounds CalcWorldBounds(Bounds localBounds, Transform t)
    {
        Vector3 c = localBounds.center;
        Vector3 e = localBounds.extents;

        Vector3[] corners = new Vector3[8]
        {
            t.TransformPoint(c + new Vector3(-e.x, -e.y, -e.z)),
            t.TransformPoint(c + new Vector3( e.x, -e.y, -e.z)),
            t.TransformPoint(c + new Vector3(-e.x,  e.y, -e.z)),
            t.TransformPoint(c + new Vector3( e.x,  e.y, -e.z)),
            t.TransformPoint(c + new Vector3(-e.x, -e.y,  e.z)),
            t.TransformPoint(c + new Vector3( e.x, -e.y,  e.z)),
            t.TransformPoint(c + new Vector3(-e.x,  e.y,  e.z)),
            t.TransformPoint(c + new Vector3( e.x,  e.y,  e.z)),
        };

        Bounds wb = new Bounds(corners[0], Vector3.zero);
        for (int i = 1; i < 8; i++) wb.Encapsulate(corners[i]);
        return wb;
    }

    // ============================================================
    // Animate — 이중 레이어 부유 (월드 공간)
    //
    // Layer 1 (baseJitter): 항상 동작하는 미세 진동
    // Layer 2 (floatAmplitude): 추가 대범위 이동
    // ============================================================

    protected override void Animate(float t)
    {
        if (!_generated) return;

        float animT = t * floatSpeed;

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

            // Layer 1 — 미세 진동 (floatAmplitude = 0일 때 주 움직임 담당)
            float jitterScale = baseJitter * inst.jitterAmp
                              * (floatAmplitude < 0.001f ? 2f : 1f);

            float jx = SampleNoise(inst.worldBasePos.x * 2.3f, inst.worldBasePos.z * 2.1f,
                                   inst.phase,         animT * 1.7f) * jitterScale;
            float jy = SampleNoise(inst.worldBasePos.y * 2.1f, inst.worldBasePos.x * 2.4f,
                                   inst.phase + 31.4f, animT * 1.7f) * jitterScale;
            float jz = SampleNoise(inst.worldBasePos.z * 2.4f, inst.worldBasePos.y * 2.2f,
                                   inst.phase + 72.8f, animT * 1.7f) * jitterScale;

            // Layer 2 — 대범위 부유
            float nx = SampleNoise(inst.worldBasePos.x, inst.worldBasePos.z,
                                   inst.phase,         animT) * floatAmplitude;
            float ny = SampleNoise(inst.worldBasePos.y, inst.worldBasePos.x,
                                   inst.phase + 31.4f, animT) * floatAmplitude;
            float nz = SampleNoise(inst.worldBasePos.z, inst.worldBasePos.y,
                                   inst.phase + 72.8f, animT) * floatAmplitude;

            Vector3 animPos = SoftClampWorld(
                inst.worldBasePos + new Vector3(jx + nx, jy + ny, jz + nz),
                inst.worldBasePos
            );

            _matrices[i] = Matrix4x4.TRS(animPos, Quaternion.identity, Vector3.one * particleSize);

            Color col  = Color.HSVToRGB(inst.hue, saturation, brightness);
            _colors[i] = new Vector4(col.r, col.g, col.b, 1f);
        }
    }

    float SampleNoise(float a, float b, float phase, float t)
    {
        return (Mathf.PerlinNoise(a * noiseScale + t + phase, b * noiseScale + phase) - 0.5f) * 2f;
    }

    // 월드 바운딩 박스를 벗어나면 basePos 방향으로 복원합니다.
    Vector3 SoftClampWorld(Vector3 pos, Vector3 basePos)
    {
        if (_worldBounds.Contains(pos)) return pos;
        return Vector3.Lerp(pos, basePos, 0.7f);
    }

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

    protected override bool StructureParamsChanged()
    {
        return targetMeshFilter != _cachedMeshFilter
            || particleCount   != _cachedParticleCount
            || colorSeed       != _cachedColorSeed;
    }

    protected override void CacheStructureParams()
    {
        _cachedMeshFilter    = targetMeshFilter;
        _cachedParticleCount = particleCount;
        _cachedColorSeed     = colorSeed;
    }
}

📒 GPUInstanceRenderer.cs

using UnityEngine;

// ============================================================
// GPU Instancing 드로우 콜 전담 클래스
// ============================================================
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 배열을 1023개 단위 배치로 나눠 GPU에 전송합니다.
    // count는 배열의 실제 사용 길이입니다.
    public void Render(Matrix4x4[] matrices, Vector4[] colors, 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];

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

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

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

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

GenArtBase.cs

using UnityEngine;

#if UNITY_EDITOR
using UnityEditor;
#endif

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

    // 서브클래스에서 Animate()가 채우고 렌더러가 읽는 배열
    protected Matrix4x4[] _matrices;
    protected Vector4[]   _colors;

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

    GPUInstanceRenderer _renderer;

#if UNITY_EDITOR
    bool _generateQueued;
#endif

    // ============================================================
    // Unity 이벤트
    // ============================================================

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

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

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

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

        if (!Application.isPlaying)
        {
            Animate(0f);
            _renderer.Render(_matrices, _colors, _matrices.Length);
            return;
        }

        Animate(Time.time);
        _renderer.Render(_matrices, _colors, _matrices.Length);
    }

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

    void EnsureResources()
    {
        if (instanceMesh     == null) instanceMesh     = GenArtResources.CreateDefaultMesh();
        if (instanceMaterial == null) instanceMaterial = GenArtResources.CreateDefaultMaterial();

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

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

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

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

    // ============================================================
    // 서브클래스 구현 요구
    // ============================================================

    protected abstract void Generate();
    protected abstract void Animate(float t);
    protected abstract bool StructureParamsChanged();
    protected abstract void CacheStructureParams();
}

📒 GenArtResources.cs

using UnityEngine;
using UnityEngine.Rendering;

// ============================================================
// 메시·머티리얼 자동 생성 유틸리티
// 인스펙터 슬롯이 비어있을 때 GenArtBase.OnEnable에서 호출됩니다.
// ============================================================
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;

        return mat;
    }

    // ============================================================
    // 셰이더 해결 순서
    // 1순위: Custom/GPUInstancingLit (UNITY_INSTANCING_BUFFER 기반)
    // 2순위: Shader.Find() 폴백
    // ============================================================
    static Shader ResolveShader()
    {
        // 1순위: 커스텀 인스턴싱 셰이더
        // 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");
    }
}

📒 GPUInstancingLit.shader

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

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

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

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

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

            // SRP Batcher를 우회하는 per-instance 프로퍼티 버퍼입니다.
            // MaterialPropertyBlock.SetVectorArray("_BaseColor", ...) 값이 여기로 들어옵니다.
            UNITY_INSTANCING_BUFFER_START(Props)
                UNITY_DEFINE_INSTANCED_PROP(float4, _BaseColor)
            UNITY_INSTANCING_BUFFER_END(Props)

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

            struct Varyings
            {
                float4 positionHCS : SV_POSITION;
                float3 normalWS    : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            Varyings vert(Attributes IN)
            {
                Varyings OUT;
                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);

                // Lambert diffuse + ambient
                Light   mainLight = GetMainLight();
                float3  normalWS  = normalize(IN.normalWS);
                float   NdotL     = saturate(dot(normalWS, mainLight.direction));

                float3 diffuse = baseColor.rgb * mainLight.color.rgb * NdotL;
                float3 ambient = baseColor.rgb * 0.25;

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

        // ----------------------------------------------------------
        // ShadowCaster Pass
        // ----------------------------------------------------------
        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode" = "ShadowCaster" }

            ZWrite    On
            ZTest     LEqual
            ColorMask 0
            Cull      Back

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

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

            // ShadowCaster는 색상 데이터가 필요 없지만,
            // 인스턴싱 버퍼를 선언해야 UNITY_SETUP_INSTANCE_ID가 정상 동작합니다.
            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 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);
                OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
                return OUT;
            }

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

핵심 기술: 메시 내부 판정

Rejection Sampling

메시 내부에 파티클을 균일하게 채우는 방법입니다.

메시의 월드 바운딩 박스 안에서 랜덤 후보점을 생성합니다.
후보점이 메시 내부인지 판정합니다.
내부이면 _instances에 추가하고, 외부이면 버립니다.
목표 파티클 수에 도달할 때까지 반복합니다.

바운딩 박스 대비 메시 부피가 작을수록 버려지는 후보점이 많아집니다. 구 형태는 효율이 높고(약 52%), 납작하거나 구멍이 많은 형태는 낮습니다.

Odd-Even Rule (홀짝 규칙)

후보점이 메시 내부인지 판정하는 알고리즘입니다.
임의의 점 P에서 임의의 방향으로 광선을 발사해 메시 표면과 교차하는 횟수를 셉니다.

교차 횟수 홀수 → 내부
교차 횟수 짝수 → 외부 (또는 메시 표면 위)

이 코드에서는 +Y 방향으로 발사하고 월드 공간으로 변환된 삼각형 배열 전체를 순회합니다.

Möller–Trumbore 알고리즘

광선과 삼각형의 교차 여부를 계산하는 알고리즘입니다. 그래픽스 교재에서 광선-삼각형 교차의 표준으로 사용됩니다.
행렬 역변환 없이 벡터 외적·내적 연산만으로 교차점의 무게중심 좌표 (u, v)와 광선 거리 t를 동시에 계산합니다.

edge1 = B - A
edge2 = C - A
h     = Cross(direction, edge2)
det   = Dot(edge1, h)          ← 0에 가까우면 광선이 삼각형과 평행
u     = Dot(origin-A, h) / det ← 무게중심 좌표 u
v     = Dot(direction, Cross(origin-A, edge1)) / det ← 무게중심 좌표 v
t     = Dot(edge2, Cross(origin-A, edge1)) / det     ← 교차 거리

조건: 0 ≤ u ≤ 1, 0 ≤ v, u+v ≤ 1, t > 0 → 교차

t > 0 조건으로 광선 뒤쪽(반대 방향)의 교차를 제외합니다.

월드 공간 기반 판정

삼각형을 로컬 공간이 아닌 월드 공간으로 변환해서 캐싱합니다.

Matrix4x4 l2w = meshTransform.localToWorldMatrix;
_triA[i] = l2w.MultiplyPoint3x4(verts[tris[i * 3 + 0]]);

FBX Import 시 Unity가 자동으로 적용하는 스케일(localScale = (0.01, 0.01, 0.01) 등)이 판정 과정에 그대로 반영됩니다. 로컬 공간으로 판정하면 스케일 불일치로 내부/외부 판정이 전면 오류가 납니다.

수치 안정성 — 후보점 jitter

후보점이 삼각형 엣지를 정확히 통과하면 교차 횟수가 0 또는 2로 계산되어 외부로 오판됩니다. 이를 방지하기 위해 판정 직전 후보점에 0.0001 수준의 미세 랜덤 오프셋을 추가합니다.

Vector3 jittered = candidate + new Vector3(
    (Random.value - 0.5f) * 0.0001f,
    (Random.value - 0.5f) * 0.0001f,
    (Random.value - 0.5f) * 0.0001f
);

저장되는worldBasePos는 지터가 없는 원래 좌표를 사용합니다.

핵심 기술: GPU Instancing

Graphics.DrawMeshInstanced

Unity에서 GameObject 없이 메시를 렌더링하는 API입니다. 씬 계층(Hierarchy)에 오브젝트를 등록하지 않고 위치·색상 배열만 GPU에 전달합니다.

Graphics.DrawMeshInstanced(
    mesh,           // 렌더링할 메시
    0,              // 서브메시 인덱스
    material,       // 머티리얼
    batchMatrices,  // 인스턴스별 TRS 행렬 배열
    batch,          // 이번 배치의 인스턴스 수
    block           // 인스턴스별 색상 (MaterialPropertyBlock)
);

한 번 호출에 최대 1023개까지만 처리하므로 GPUInstanceRenderer가 while 루프로 배치를 분할합니다.

UNITY_INSTANCING_BUFFER

URP의 SRP Batcher는 GPU Instancing과 동시에 동작하지 않습니다. MaterialPropertyBlock으로 주입하는 색상 데이터를 SRP Batcher가 덮어쓰는 문제가 있습니다.

커스텀 셰이더에서 UNITY_INSTANCING_BUFFER_START/END 블록으로 색상 프로퍼티를 선언하면 SRP Batcher 대신 GPU Instancing 전용 버퍼에서 데이터를 읽습니다.

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

// 셰이더 내부에서 인스턴스별 색상을 읽습니다
float4 baseColor = UNITY_ACCESS_INSTANCED_PROP(Props, _BaseColor);

Matrix4x4.TRS

각 파티클의 위치·회전·크기를 하나의 행렬로 표현합니다.

_matrices[i] = Matrix4x4.TRS(
    animPos,              // Translation: 월드 위치
    Quaternion.identity,  // Rotation: 회전 없음
    Vector3.one * particleSize  // Scale: 균일 크기
);

GPU는 이 행렬 하나로 해당 인스턴스의 모든 공간 변환을 처리합니다.

핵심 기술: Perlin Noise 부유 애니메이션

이중 레이어 구조

레이어	파라미터	역할
Layer 1	`baseJitter`	항상 동작하는 미세 진동. `floatAmplitude = 0`이어도 파티클은 살아있는 느낌으로 움직입니다.
Layer 2	`floatAmplitude`	추가적인 대범위 이동. 0이면 비활성.

floatAmplitude = 0이면 Layer 1의 스케일을 2배로 키워 주 움직임을 담당하게 합니다.

3D Perlin Noise 근사

Unity의 Mathf.PerlinNoise()는 2D입니다. 세 축 각각 독립적인 움직임을 만들기 위해 축마다 다른 UV 조합과 큰 위상 오프셋을 사용합니다.

float nx = SampleNoise(pos.x, pos.z, phase,         t); // X축 이동
float ny = SampleNoise(pos.y, pos.x, phase + 31.4f, t); // Y축 이동
float nz = SampleNoise(pos.z, pos.y, phase + 72.8f, t); // Z축 이동

phase는 파티클마다 다른 랜덤 값이므로 모든 파티클이 동일하게 움직이는 동조 현상이 없습니다.
SampleNoise()는 0~1 범위인 Perlin 출력을 -1~+1로 정규화합니다.

float SampleNoise(float a, float b, float phase, float t)
{
    return (Mathf.PerlinNoise(a * noiseScale + t + phase, b * noiseScale + phase) - 0.5f) * 2f;
}

SoftClamp

파티클이 부유 중 바운딩 박스 밖으로 나가면 basePos 방향으로 70% 복원합니다. 완전히 클램프하면 경계에서 파티클이 딱딱하게 멈추는 느낌이 나므로 Lerp로 부드럽게 끌어당깁니다.

인스펙터 파라미터 요약

파라미터	분류	설명
`targetMeshFilter`	구조	파티클을 채울 FBX 오브젝트의 MeshFilter
`particleCount`	구조	배치할 파티클 총 수
`colorSeed`	구조	색상 무작위 시드
`particleSize`	시각	파티클 하나의 크기
`floatSpeed`	시각	노이즈 시간 진행 속도
`noiseScale`	시각	노이즈 공간 주파수 (클수록 파티클 간 움직임이 제각각)
`floatAmplitude`	시각	대범위 부유 크기. 0이어도 기본 진동은 동작함
`baseJitter`	시각	항상 적용되는 최소 진동 크기
`hueBase`	시각	색상 Hue 시작값
`hueRange`	시각	파티클 간 Hue 분포 범위
`saturation`	시각	채도
`brightness`	시각	명도

구조 파라미터가 변경되면 Generate()가 재실행됩니다. 시각 파라미터는 Animate(0f)만 재실행되어 즉시 반영됩니다.

메시 조건

닫힌 형태(Closed Mesh) 여야 합니다. 구멍이 있으면 홀짝 판정이 오작동합니다.
폴리곤 수가 많을수록 Generate() 시간이 길어집니다. 실시간 렌더링 속도에는 영향이 없습니다.
Blender에서 Export할 때 Apply Transforms를 체크하면 스케일 문제를 방지할 수 있습니다.

BamgasiJM

Coding Art with Blender / oF / Processing / p5.js / nannou

이전 포스트

🫧Art_020 Pixel Luminance Flip

다음 포스트