🫧Art_013 Particles on Sphere

📄ParticleOnSphere.cs

// 중심에서 스폰된 파티클이 구체 표면으로 끌려붙는 아트워크.
// [ExecuteAlways] - 에디터 프리뷰 지원.
// 요구사항: Unity 6.0 + URP, Assets/Shaders/ShaderUnlit.shader

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;
#if UNITY_EDITOR
using UnityEditor;
#endif

[ExecuteAlways]
[AddComponentMenu("GenArt/Attractor Artwork")]
public class AttractorArtwork : MonoBehaviour
{
    // === Spawn ===

    [Header("Spawn")]
    [Tooltip("동시에 존재할 수 있는 파티클 최대 수. CPU 시뮬레이션이므로 20000 이하 권장.")]
    [Range(100, 20000)] public int maxCount = 5000;

    [Tooltip("초당 파티클 생성 수.")]
    [Range(1f, 2000f)] public float spawnRate = 200f;

    // === Sphere Attractor ===

    [Header("Sphere Attractor")]
    [Tooltip("목표 구체의 반지름.")]
    [Range(0.1f, 10f)] public float sphereRadius = 1.97f;

    [Tooltip("표면을 향한 인력 속도 스케일.")]
    [Range(0.1f, 20f)] public float attractionSpeed = 5f;

    [Tooltip("인력 강도.")]
    [Range(0f, 5f)] public float attractionForce = 0.78f;

    [Tooltip("표면에 달라붙기 시작하는 거리.")]
    [Range(0f, 3f)] public float stickDistance = 1.12f;

    [Tooltip("표면 고정 힘의 강도.")]
    [Range(0f, 5f)] public float stickForce = 1.08f;

    // === Turbulence ===

    [Header("Turbulence")]
    [Tooltip("터뷸런스 세기.")]
    [Range(0f, 3f)] public float turbIntensity = 0.55f;

    [Tooltip("터뷸런스 드래그 (지수 감쇠).")]
    [Range(0f, 10f)] public float turbDrag = 2f;

    [Tooltip("노이즈 공간 주파수. 클수록 세밀한 패턴.")]
    [Range(0.1f, 10f)] public float turbFrequency = 2.11f;

    [Tooltip("노이즈 시간 흐름 속도.")]
    [Range(0f, 2f)] public float turbTimeScale = 0.3f;

    // === Particle Appearance ===

    [Header("Particle Size")]
    [Range(0.001f, 0.1f)] public float minSize = 0.008f;
    [Range(0.001f, 0.15f)] public float maxSize = 0.035f;

    // === Color by Speed ===

    [Header("Color by Speed")]
    [Tooltip("저속 파티클 색상 (표면에 붙은 상태).")]
    public Color slowColor = new Color(0.65f, 0.25f, 1.0f);   // purple

    [Tooltip("고속 파티클 색상 (빠르게 이동 중).")]
    public Color fastColor = new Color(0.15f, 1.0f, 0.85f);  // cyan

    [Tooltip("fastColor에 대응하는 속도 상한. 이 속도 이상은 모두 fastColor.")]
    [Range(0.05f, 10f)] public float speedRangeMax = 1.5f;

    // === 내부 구조체 ===

    private struct Particle
    {
        public Vector3 pos;
        public Vector3 vel;
        public float size;
        public float speedMag; // 이전 프레임 속도 크기 → 색상 계산용
    }

    // === 런타임 상태 ===

    private readonly List<Particle> _p = new();
    private float _spawnTimer;
    private float _time;

    private Mesh _mesh;
    private Material _mat;
    private MaterialPropertyBlock _mpb;

    private const int BATCH = 1023;
    private readonly Matrix4x4[] _mBuf = new Matrix4x4[BATCH];
    private readonly Vector4[] _cBuf = new Vector4[BATCH];

    // === Unity 라이프사이클 ===

    void OnEnable()
    {
        _p.Clear();
        _spawnTimer = 0f;
        _time = 0f;
        InitResources();

        if (!Application.isPlaying)
            BuildEditorPreview();

#if UNITY_EDITOR
        SceneView.RepaintAll();
#endif
    }

    void OnDisable()
    {
        CoreUtils.Destroy(_mat);
        _mat = null;
    }

    void Update()
    {
        if (_mat == null || _mesh == null) return;

        if (Application.isPlaying)
        {
            float dt = Time.deltaTime;
            _time += dt;
            Spawn(dt);
            Simulate(dt);
        }

        Render();

#if UNITY_EDITOR
        if (!Application.isPlaying)
            SceneView.RepaintAll();
#endif
    }

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

    void InitResources()
    {
        if (_mesh == null)
            _mesh = Resources.GetBuiltinResource<Mesh>("Sphere.fbx");

        if (_mat == null)
        {
            var sh = Shader.Find("Custom/ShaderUnlit");
            if (sh == null)
            {
                Debug.LogError("[AttractorArtwork] 셰이더 'Custom/ShaderUnlit'가 없습니다. " +
                               "Assets/Shaders/SwirlUnlit.shader 를 프로젝트에 추가하세요.");
                return;
            }
            _mat = new Material(sh) { enableInstancing = true };
        }

        _mpb ??= new MaterialPropertyBlock();
    }

    // === 에디터 프리뷰 ===

    // 정지 상태에서 구체 표면 분포 스냅샷
    void BuildEditorPreview()
    {
        _p.Clear();
        int count = Mathf.Min(maxCount, 3000);
        for (int i = 0; i < count; i++)
        {
            _p.Add(new Particle
            {
                pos = Random.onUnitSphere * sphereRadius,
                vel = Vector3.zero,
                size = Random.Range(minSize, maxSize),
                speedMag = 0f
            });
        }
    }

    // === 스폰 ===

    // 월드 원점(transform.position 기준) 중심에서 생성
    void Spawn(float dt)
    {
        if (_p.Count >= maxCount) return;

        _spawnTimer += dt;
        float interval = 1f / Mathf.Max(spawnRate, 0.001f);

        while (_spawnTimer >= interval && _p.Count < maxCount)
        {
            _spawnTimer -= interval;

            // 완전한 원점이면 방향 계산 불가 → 아주 작은 랜덤 오프셋
            Vector3 startPos = Random.insideUnitSphere * 0.05f;
            if (startPos.sqrMagnitude < 1e-6f)
                startPos = new Vector3(0.001f, 0f, 0f);

            _p.Add(new Particle
            {
                pos = transform.position + startPos,
                vel = Random.onUnitSphere * 0.15f,
                size = Random.Range(minSize, maxSize),
                speedMag = 0f
            });
        }

        // 프레임 드롭으로 타이머 폭발 방지
        if (_spawnTimer > interval * 5f)
            _spawnTimer = 0f;
    }

    // === 시뮬레이션 ===

    void Simulate(float dt)
    {
        Vector3 center = transform.position;
        float expDrag = Mathf.Exp(-turbDrag * dt);

        for (int i = 0; i < _p.Count; i++)
        {
            var p = _p[i];

            Vector3 fromCenter = p.pos - center;
            float distFromC = fromCenter.magnitude;
            Vector3 radialDir = distFromC > 0.001f ? fromCenter / distFromC : Vector3.up;

            // 구체 표면 목표 지점
            Vector3 surfacePoint = center + radialDir * sphereRadius;
            Vector3 toSurface = surfacePoint - p.pos;
            float distToSurf = toSurface.magnitude;

            // 1. 인력 (Attractor): 표면 방향으로 지속 힘
            p.vel += toSurface.normalized * (attractionForce * attractionSpeed * dt);

            // 2. 고착력 (Stick): 표면 근처에서 선형 증가하는 수렴 힘
            if (distToSurf < stickDistance)
            {
                float t = 1f - (distToSurf / stickDistance);  // 0(경계) ~ 1(표면)
                p.vel += toSurface * (stickForce * t * dt);
            }

            // 3. 터뷸런스: 컬 노이즈(curl noise) 근사 → 표면에 흐름 생성
            p.vel += CurlNoise(p.pos, _time) * dt;

            // 4. 드래그 (지수 감쇠)
            p.vel *= expDrag;

            // 5. 위치 적분
            p.pos += p.vel * dt;

            // 6. 속도 크기 캐시 (색상용)
            p.speedMag = p.vel.magnitude;

            _p[i] = p;
        }
    }

    // === 컬 노이즈 (Curl Noise) ===

    // Perlin 노이즈 6회 샘플로 발산 없는 3D 벡터장 근사.
    // 구체 표면에서 파티클이 흩어지지 않고 표면을 따라 흐르는 효과.
    Vector3 CurlNoise(Vector3 pos, float t)
    {
        float f = turbFrequency;
        float tm = t * turbTimeScale;

        // 각 축에 대해 편미분 근사: ∂Fz/∂y - ∂Fy/∂z 등
        float nx = N(pos.y * f, pos.z * f + tm) - N(pos.z * f, pos.y * f + tm);
        float ny = N(pos.z * f, pos.x * f + tm) - N(pos.x * f, pos.z * f + tm);
        float nz = N(pos.x * f, pos.y * f + tm) - N(pos.y * f, pos.x * f + tm);

        return new Vector3(nx, ny, nz) * turbIntensity;
    }

    // Perlin 노이즈를 -0.5~0.5 범위로 정규화
    float N(float x, float y) => Mathf.PerlinNoise(x + 100f, y + 100f) - 0.5f;

    // === 렌더링 ===

    // 1023 배치 단위 DrawMeshInstanced
    void Render()
    {
        if (_mat == null || _mesh == null || _p.Count == 0) return;

        int total = _p.Count;
        int offset = 0;

        while (offset < total)
        {
            int n = Mathf.Min(BATCH, total - offset);

            for (int i = 0; i < n; i++)
            {
                var p = _p[offset + i];

                _mBuf[i] = Matrix4x4.TRS(p.pos, Quaternion.identity, Vector3.one * p.size);

                // 속도 기반 색상 lerp
                float tc = Mathf.Clamp01(p.speedMag / Mathf.Max(speedRangeMax, 0.001f));
                Color c = Color.Lerp(slowColor, fastColor, tc);
                _cBuf[i] = new Vector4(c.r, c.g, c.b, 1f);
            }

            _mpb.Clear();
            _mpb.SetVectorArray("_BaseColor", _cBuf);
            Graphics.DrawMeshInstanced(_mesh, 0, _mat, _mBuf, n, _mpb);

            offset += n;
        }
    }

    // === 에디터 훅 ===

#if UNITY_EDITOR
    void OnValidate()
    {
        if (Application.isPlaying) return;
        if (_mesh == null || _mat == null) InitResources();
        if (_mesh != null && _mat != null)
        {
            BuildEditorPreview();
            SceneView.RepaintAll();
        }
    }

    // Scene 뷰에서 어트랙터 구체 Gizmo 표시
    void OnDrawGizmosSelected()
    {
        Gizmos.color = new Color(0.2f, 1f, 0.5f, 0.25f);
        Gizmos.DrawWireSphere(transform.position, sphereRadius);
        Gizmos.color = new Color(0.2f, 1f, 0.5f, 0.08f);
        Gizmos.DrawSphere(transform.position, sphereRadius);
    }
#endif
}

📄ShaderUnlit.shader

// SwirlUnlit.shader
// URP 언릿 셰이더. UNITY_INSTANCING_BUFFER로 인스턴스별 _BaseColor 지원.
// Assets/Shaders/ 폴더에 배치.

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

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

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

            HLSLPROGRAM
            #pragma vertex   Vert
            #pragma fragment Frag
            #pragma multi_compile_instancing
            #pragma instancing_options assumeuniformscaling

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

            // === Per-Instance Property Buffer ===
            UNITY_INSTANCING_BUFFER_START(UnityPerMaterial)
                UNITY_DEFINE_INSTANCED_PROP(float4, _BaseColor)
            UNITY_INSTANCING_BUFFER_END(UnityPerMaterial)

            struct Attributes
            {
                float4 posOS : POSITION;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float4 posHCS : SV_POSITION;
                float4 color  : COLOR0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

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

                OUT.posHCS = TransformObjectToHClip(IN.posOS.xyz);
                OUT.color  = UNITY_ACCESS_INSTANCED_PROP(UnityPerMaterial, _BaseColor);
                return OUT;
            }

            half4 Frag(Varyings IN) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(IN);
                return half4(IN.color);
            }

            ENDHLSL
        }
    }
}