1. 아트워크 개요

.fbx 모델링 파일에서 메시를 추출
파티클이 메시의 표면에 포인트 클라우드를 이루면서 채워짐. 메시의 버텍스를 따르지 않고 표면에 삼각형을 그려서 그 위로 채우는 로직.
마우스의 커서는 깊이 + 범위를 체크하여 파티클을 분산시켜 위로 올라가게 함.

2. 적용 방법

2-1. Compute Shader 작성

1. Create > Shader > Compute Shader로 새로운 Shader 만들고 이름 변경(MeshParticleSwarm.compute)
   

2. 셰이더 스크립트 작성

• Unity 6.0+ / SM 4.5
• 파티클 물리: 마우스 근접 → 터뷸런스 부유, 멀어지면 원점 복귀

2-2. URP Unlit Shader 작성과 Material 설정

1. Asssets / Shader 폴더에 Create > Shader > URP Unlit Shader 만들기 (MeshParticleDraw.shader)
   

2. 스크립트 작성

• URP / HDRP 공용 Unlit Additive 파티클 셰이더
• SV_VertexID 기반 quad billboarding — GeometryShader 없이 동작
• 파티클당 6 verts (2 tri) 로 DrawProcedural 호출

3. Create > Material로 새로운 Material 만들기 - 이름은 임의로 지정 (예: ParticleSwarmMat)
   

4. 생성한 Material을 선택 → Inspector 최상단 Shader 드롭다운 클릭 : Custom > MeshParticleDraw 선택

5. Inspector에 Color, Particle Size, Brightness 프로퍼티 확인

2-3. GameObject 설정

1. GameObject에 MeshParticleSwarm.cs 코드를 컴포넌트로 부착
2. Inspector 창에서 빈 필드에

• Source Mesh에 원하는 메시를 할당
• Compute Shader에 MeshParticleSwarm.compute 코드를 할당
• Particle Material에 ParticleSwarmMat 매터리얼을 할당

2-4. 모델링 준비

1. 블렌더에서 회전 세팅 후 fbx Export
   
   블렌더 기준으로 Front에서 바닥이 보이고, Top에서 뒷모습이 보이도록 회전.
   즉 뒤돌아서 앞으로 고꾸라진 모습으로 해 놓고 fbx로 내보내야지 유니티에서 정면으로 보입니다. 그리고 Option 창에서 Transform을 Z Forward, Y Up으로 합니다.

2. 유니티에서 Assets > Modeling 폴더 속에 fbx 파일을 드래그&드랍해서 불러오기.
3. Scale 수치로 모델링 크기 변경, Read/Write에 반드시 체크할 것.

3. 코드

📒 MeshParticleSwarm.cs

#if UNITY_EDITOR
using UnityEditor;
#endif

using System;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.InputSystem;

[ExecuteAlways]
[RequireComponent(typeof(MeshFilter))]
public sealed class MeshParticleSwarm : MonoBehaviour
{
    [Header("Mesh & Particles")]
    public Mesh sourceMesh;
    public int particleCount = 300_000;

    [Header("Mouse Influence")]
    public float mouseRadius = 2.5f;
    public float liftForce = 6f;

    [Header("Turbulence")]
    public float turbulenceScale = 1.2f;
    public float turbulenceStrength = 3f;

    [Header("Physics")]
    public float gravity = -3f;
    public float returnStrength = 4f;
    [Range(0f, 1f)]
    public float damping = 0.88f;

    [Header("Rendering")]
    public ComputeShader computeShader;
    public Material particleMaterial;
    public float particleSize = 0.018f;
    public Color particleColor = Color.white;
    [Range(0.1f, 5f)]
    public float brightness = 1f;

    struct Particle
    {
        public Vector3 origin;
        public Vector3 position;
        public Vector3 velocity;
        public Vector3 normal;
        public float phase;
        public float influenced;
    }
    const int STRIDE = 14 * sizeof(float);

    ComputeBuffer _particleBuffer;
    MaterialPropertyBlock _mpb;
    int _kernelUpdate;
    Camera _mainCam;
    int _actualCount;
    Bounds _worldBounds;

    static readonly int ID_Particles = Shader.PropertyToID("_Particles");
    static readonly int ID_ParticleSize = Shader.PropertyToID("_ParticleSize");
    static readonly int ID_Color = Shader.PropertyToID("_Color");
    static readonly int ID_Brightness = Shader.PropertyToID("_Brightness");

    // ── 에디터 전용: 파라미터 변경 감지용 캐시 ─────────────────────────────
#if UNITY_EDITOR
    int   _cachedParticleCount;
    Mesh  _cachedMesh;
#endif

    void OnEnable() => Initialize();
    void OnDisable() => Cleanup();

    void Initialize()
    {
        _mainCam = Camera.main;

        Mesh mesh = sourceMesh != null ? sourceMesh : GetComponent<MeshFilter>()?.sharedMesh;
        if (mesh == null || computeShader == null || particleMaterial == null) return;

        Particle[] particles = BuildParticles(mesh);
        _actualCount = particles.Length;

        _particleBuffer = new ComputeBuffer(_actualCount, STRIDE);
        _particleBuffer.SetData(particles);

        _kernelUpdate = computeShader.FindKernel("CSUpdate");
        computeShader.SetBuffer(_kernelUpdate, "_Particles", _particleBuffer);

        _mpb = new MaterialPropertyBlock();

        Bounds local = mesh.bounds;
        Vector3 center = transform.TransformPoint(local.center);
        Vector3 size = Vector3.Scale(local.size, transform.lossyScale) * 3f;
        _worldBounds = new Bounds(center, size);

#if UNITY_EDITOR
        _cachedParticleCount = particleCount;
        _cachedMesh          = mesh;
#endif

        Debug.Log($"[MeshParticleSwarm] {_actualCount:N0}개 초기화 완료 (isPlaying={Application.isPlaying})");
    }

    void Cleanup()
    {
        _particleBuffer?.Release();
        _particleBuffer = null;
    }

    void Update()
    {
        if (_particleBuffer == null) return;

#if UNITY_EDITOR
        // ── 에디터 전용: 파라미터가 바뀌면 재초기화 ─────────────────────
        Mesh currentMesh = sourceMesh != null ? sourceMesh : GetComponent<MeshFilter>()?.sharedMesh;
        if (currentMesh != _cachedMesh || particleCount != _cachedParticleCount)
        {
            Cleanup();
            Initialize();
            return;
        }

        // ── 에디터 모드: 정적 스냅샷만 렌더 (물리 연산 없음) ─────────────
        if (!Application.isPlaying)
        {
            DrawParticles();
            return;
        }
#endif

        // ── Play 모드: 정상 물리 업데이트 ────────────────────────────────
        Vector2 screenPos = Mouse.current != null
            ? Mouse.current.position.ReadValue()
            : Vector2.zero;
        Ray ray = _mainCam != null ? _mainCam.ScreenPointToRay(screenPos) : new Ray();
        var plane = new Plane(-(_mainCam != null ? _mainCam.transform.forward : Vector3.forward),
                                  transform.position);
        Vector3 mouseWorld = plane.Raycast(ray, out float dist)
            ? ray.GetPoint(dist) : Vector3.zero;

        computeShader.SetVector("_MouseWorld", mouseWorld);
        computeShader.SetFloat("_MouseRadius", mouseRadius);
        computeShader.SetFloat("_LiftForce", liftForce);
        computeShader.SetFloat("_TurbulenceScale", turbulenceScale);
        computeShader.SetFloat("_TurbulenceStrength", turbulenceStrength);
        computeShader.SetFloat("_Gravity", gravity);
        computeShader.SetFloat("_ReturnStrength", returnStrength);
        computeShader.SetFloat("_Damping", damping);
        computeShader.SetFloat("_DeltaTime", Time.deltaTime);
        computeShader.SetFloat("_Time", Time.time);

        computeShader.Dispatch(_kernelUpdate, Mathf.CeilToInt(_actualCount / 64f), 1, 1);

        DrawParticles();
    }

    // ── 공통 드로우 호출 ──────────────────────────────────────────────────
    void DrawParticles()
    {
        if (_particleBuffer == null || particleMaterial == null) return;

        _mpb.SetBuffer(ID_Particles, _particleBuffer);
        _mpb.SetFloat(ID_ParticleSize, particleSize);
        _mpb.SetColor(ID_Color, particleColor);
        _mpb.SetFloat(ID_Brightness, brightness);

        Graphics.DrawProcedural(
            particleMaterial,
            _worldBounds,
            MeshTopology.Triangles,
            _actualCount * 6,
            1,
            null,
            _mpb,
            ShadowCastingMode.Off,
            false,
            gameObject.layer);
    }

    void OnDestroy() => Cleanup();

    Particle[] BuildParticles(Mesh mesh)
    {
        Vector3[] verts = mesh.vertices;
        int[] tris = mesh.triangles;
        Vector3[] normals = mesh.normals;
        bool hasNorm = normals != null && normals.Length == verts.Length;

        int triCount = tris.Length / 3;
        float[] cdf = new float[triCount];
        float total = 0f;

        for (int i = 0; i < triCount; i++)
        {
            int i0 = tris[i * 3], i1 = tris[i * 3 + 1], i2 = tris[i * 3 + 2];
            Vector3 a = transform.TransformPoint(verts[i0]);
            Vector3 b = transform.TransformPoint(verts[i1]);
            Vector3 c = transform.TransformPoint(verts[i2]);
            total += Vector3.Cross(b - a, c - a).magnitude * 0.5f;
            cdf[i] = total;
        }
        for (int i = 0; i < triCount; i++) cdf[i] /= total;

        int actual = Mathf.Min(particleCount, triCount * 100);
        var list = new Particle[actual];
        var rng = new System.Random(1337);

        for (int p = 0; p < actual; p++)
        {
            float r = (float)rng.NextDouble();
            int ti = Array.BinarySearch(cdf, r);
            if (ti < 0) ti = ~ti;
            ti = Mathf.Clamp(ti, 0, triCount - 1);

            int i0 = tris[ti * 3], i1 = tris[ti * 3 + 1], i2 = tris[ti * 3 + 2];
            float u = (float)rng.NextDouble();
            float v = (float)rng.NextDouble();
            if (u + v > 1f) { u = 1f - u; v = 1f - v; }
            float w = 1f - u - v;

            Vector3 pos = transform.TransformPoint(
                verts[i0] * w + verts[i1] * u + verts[i2] * v);
            Vector3 nor = hasNorm
                ? transform.TransformDirection(
                    normals[i0] * w + normals[i1] * u + normals[i2] * v).normalized
                : Vector3.up;

            list[p] = new Particle
            {
                origin = pos,
                position = pos,
                velocity = Vector3.zero,
                normal = nor,
                phase = (float)rng.NextDouble() * 97.3f,
                influenced = 0f
            };
        }
        return list;
    }
}

📒 MeshParticleSwarm.compute

// MeshParticleSwarm.compute
// Unity 6.0+ / SM 4.5
// 파티클 물리: 마우스 근접 → 터뷸런스 부유, 멀어지면 원점 복귀
#pragma kernel CSUpdate

// ── 데이터 구조 (C# Particle 구조체와 byte 완전 일치) ────────────────────────
struct Particle
{
    float3 origin;
    float3 position;
    float3 velocity;
    float3 normal;
    float  phase;
    float  influenced;
};

RWStructuredBuffer<Particle> _Particles;

// ── 유니폼 ────────────────────────────────────────────────────────────────────
float3 _MouseWorld;
float  _MouseRadius;
float  _LiftForce;
float  _TurbulenceScale;
float  _TurbulenceStrength;
float  _Gravity;
float  _ReturnStrength;
float  _Damping;
float  _DeltaTime;
float  _Time;

// ══════════════════════════════════════════════════════════════════════════════
// Noise 함수
// ══════════════════════════════════════════════════════════════════════════════

// 3D 해시 (Shadertoy 표준)
float3 hash33(float3 p3)
{
    p3 = frac(p3 * float3(0.1031, 0.1030, 0.0973));
    p3 += dot(p3, p3.yxz + 33.33);
    return frac((p3.xxy + p3.yxx) * p3.zyx);
}

// 3D Gradient Noise
float gradNoise(float3 p)
{
    float3 i = floor(p);
    float3 f = frac(p);
    float3 u = f * f * (3.0 - 2.0 * f);    // smoothstep

    #define GRAD(OFFSET) dot(hash33(i + OFFSET) * 2.0 - 1.0, f - OFFSET)
    float n000 = GRAD(float3(0,0,0));
    float n100 = GRAD(float3(1,0,0));
    float n010 = GRAD(float3(0,1,0));
    float n110 = GRAD(float3(1,1,0));
    float n001 = GRAD(float3(0,0,1));
    float n101 = GRAD(float3(1,0,1));
    float n011 = GRAD(float3(0,1,1));
    float n111 = GRAD(float3(1,1,1));
    #undef GRAD

    return lerp(
        lerp(lerp(n000, n100, u.x), lerp(n010, n110, u.x), u.y),
        lerp(lerp(n001, n101, u.x), lerp(n011, n111, u.x), u.y),
        u.z);
}

// fBm 터뷸런스 (2옥타브)
float3 turbulence(float3 p, float t)
{
    // 시간에 따라 천천히 흘러가는 3채널 노이즈
    float3 base = p * _TurbulenceScale + float3(t * 0.25, t * 0.14, t * 0.19);

    float3 n;
    n.x = gradNoise(base)                  + 0.5 * gradNoise(base * 2.1 + 5.2);
    n.y = gradNoise(base + float3(4.1,0,0)) + 0.5 * gradNoise(base * 2.1 + 1.3);
    n.z = gradNoise(base + float3(0,8.3,0)) + 0.5 * gradNoise(base * 2.1 + 9.7);

    return n * (_TurbulenceStrength / 1.5);   // 정규화 보정
}

// ══════════════════════════════════════════════════════════════════════════════
// 메인 커널
// ══════════════════════════════════════════════════════════════════════════════
[numthreads(64, 1, 1)]
void CSUpdate(uint3 id : SV_DispatchThreadID)
{
    Particle p = _Particles[id.x];

    // ── 마우스 영향도 (이차 감쇠) ────────────────────────────────────────
    float  distMouse  = distance(p.position, _MouseWorld);
    float  t          = saturate(1.0 - distMouse / max(_MouseRadius, 0.001));
    float  influence  = t * t;                  // 0(멀) ~ 1(근접)
    p.influenced      = influence;

    // ── 가속도 누적 ───────────────────────────────────────────────────────
    float3 accel = (float3)0;

    // 1) 중력
    accel.y += _Gravity;

    // 2) 원점 복귀 스프링 (영향도에 따라 약해짐)
    float3 toOrigin      = p.origin - p.position;
    float  springStrength = _ReturnStrength * (1.0 - influence * 0.7);
    accel += toOrigin * springStrength;

    // 3) 마우스 근접 시: 부력 + 터뷸런스
    if (influence > 0.001)
    {
        // 부력: 노멀 방향 30% + 월드 Up 70%
        float3 liftDir = normalize(lerp(float3(0,1,0), p.normal, 0.3));
        accel += liftDir * _LiftForce * influence;

        // 터뷸런스 노이즈 (파티클 고유 위상으로 분산)
        float3 noisePos = p.position + float3(p.phase, p.phase * 0.61, p.phase * 1.37);
        accel += turbulence(noisePos, _Time) * influence;

        // 마우스를 중심으로 약한 소용돌이 (XZ 평면)
        float3 toMouse  = _MouseWorld - p.position;
        float3 swirl    = cross(toMouse, float3(0,1,0));
        accel += normalize(swirl + 0.001) * influence * 1.5;
    }

    // ── 적분 ─────────────────────────────────────────────────────────────
    p.velocity  += accel * _DeltaTime;
    p.velocity  *= _Damping;
    p.position  += p.velocity * _DeltaTime;

    _Particles[id.x] = p;
}

📒 MeshParticleDraw.shader

// MeshParticleDraw.shader
// URP / HDRP 공용 Unlit Additive 파티클 셰이더
// SV_VertexID 기반 quad billboarding — GeometryShader 없이 동작
// 파티클당 6 verts (2 tri) 로 DrawProcedural 호출

Shader "Custom/MeshParticleDraw"
{
    Properties
    {
        _Color        ("Color",         Color)  = (1, 1, 1, 1)
        _ParticleSize ("Particle Size", Float)  = 0.018
        _Brightness   ("Brightness",    Float)  = 1.0
    }

    SubShader
    {
        Tags
        {
            "RenderType"      = "Transparent"
            "Queue"           = "Transparent"
            "RenderPipeline"  = "UniversalPipeline"
            "IgnoreProjector" = "True"
        }

        Blend   One One     // Additive — 파티클 겹침 시 자연스럽게 빛남
        ZWrite  Off
        ZTest   LEqual
        Cull    Off

        Pass
        {
            Name "MeshParticle_Forward"

            HLSLPROGRAM
            #pragma vertex   vert
            #pragma fragment frag
            #pragma target   4.5
            // OpenGL ES 2/3 미지원 (StructuredBuffer 필요)
            #pragma exclude_renderers gles gles3 glcore

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

            // ── GPU 파티클 구조체 (C# / Compute 와 byte 동일) ────────────
            struct Particle
            {
                float3 origin;
                float3 position;
                float3 velocity;
                float3 normal;
                float  phase;
                float  influenced;
            };

            StructuredBuffer<Particle> _Particles;

            CBUFFER_START(UnityPerMaterial)
                float4 _Color;
                float  _ParticleSize;
                float  _Brightness;
            CBUFFER_END

            // ── 6-vertex quad 코너 (CCW) ──────────────────────────────────
            static const float2 quadUV[6] =
            {
                float2(-1, -1), float2( 1, -1), float2( 1,  1),
                float2(-1, -1), float2( 1,  1), float2(-1,  1)
            };

            // ── Varyings ──────────────────────────────────────────────────
            struct Varyings
            {
                float4 posCS : SV_POSITION;
                float2 uv    : TEXCOORD0;   // -1..1 (소프트 서클용)
                float4 col   : COLOR;
            };

            // ── Vertex ────────────────────────────────────────────────────
            Varyings vert(uint vertID : SV_VertexID)
            {
                uint    pid    = vertID / 6u;
                uint    corner = vertID % 6u;
                Particle p     = _Particles[pid];

                // 월드 → 클립
                float4 clipPos = TransformWorldToHClip(p.position);

                // 화면 공간 빌보드 (clip.w 곱 → NDC 고정 크기)
                float2 offset  = quadUV[corner] * _ParticleSize;
                clipPos.xy    += offset * clipPos.w;

                // 색상: 기본 + 영향도에 비례한 블루-화이트 글로우
                float3 baseCol  = _Color.rgb * _Brightness;
                float3 glowCol  = float3(0.4, 0.65, 1.0) * p.influenced * 3.0;
                // 속도 크기로 스트레이킹 힌트
                float  speed    = length(p.velocity);
                float3 speedCol = float3(1.0, 0.8, 0.4) * saturate(speed * 0.15);

                Varyings o;
                o.posCS = clipPos;
                o.uv    = quadUV[corner];
                o.col   = float4(baseCol + glowCol + speedCol, _Color.a);
                return o;
            }

            // ── Fragment ──────────────────────────────────────────────────
            float4 frag(Varyings i) : SV_Target
            {
                // 소프트 원형 알파 (하드 엣지 없음)
                float d     = length(i.uv);
                float alpha = 1.0 - smoothstep(0.4, 1.0, d);
                clip(alpha - 0.01);             // 완전 투명 픽셀 제거

                // 중심 코어 강조
                float core  = 1.0 - smoothstep(0.0, 0.35, d);
                float4 col  = i.col;
                col.rgb    += col.rgb * core * 1.5;

                return col * alpha;
            }

            ENDHLSL
        }
    }

    // Built-in RP 폴백 없음 (URP/HDRP 전용)
    FallBack Off
}