🫧Art_012 Swirl Artwork

블렌더에서 구현한 유사 아트워크

사용 방법

파일 배치:

SwirlUnlit.shader → Assets/Shaders/
SwirlArtwork.cs → Assets/Scripts/
씬의 빈 GameObject에 SwirlArtwork 컴포넌트 추가

Code

📄SwirlArtwork.cs

// SwirlArtwork.cs
// 나선형 스웜 파티클 아트웍. [ExecuteAlways]로 에디터에서도 프리뷰 표시.
// Assets/Scripts/ 폴더에 배치 후 씬의 빈 GameObject에 컴포넌트 추가.
// 요구사항: Unity 6.0 + URP, Custom/SwirlUnlit 셰이더 필요.

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

[ExecuteAlways]
[AddComponentMenu("GenArt/Swirl Artwork")]
public class SwirlArtwork : MonoBehaviour
{
  // === Spawn & Motion ===

  [Header("Spawn & Motion")]
  [Tooltip("파티클 최대 개수. 초과시 가장 오래된 파티클 파괴.")]
  [Range(10, 2000)] public int maxCount = 1000;

  [Tooltip("파티클이 파괴되는 최대 높이 (Y축).")]
  [Range(1f, 30f)] public float maxHeight = 10f;

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

  [Tooltip("파티클 최소 상승 속도 (유닛/초).")]
  [Range(0.02f, 3f)] public float minSpeed = 0.1f;

  [Tooltip("파티클 최대 상승 속도 (유닛/초).")]
  [Range(0.02f, 5f)] public float maxSpeed = 0.6f;

  [Tooltip("파티클 최소 크기.")]
  [Range(0.01f, 0.3f)] public float minSize = 0.04f;

  [Tooltip("파티클 최대 크기.")]
  [Range(0.05f, 0.8f)] public float maxSize = 0.18f;

  // === Spiral Shape ===

  [Header("Spiral Shape")]
  [Tooltip("나선의 반지름.")]
  [Range(0.1f, 6f)] public float spiralRadius = 1.2f;

  [Tooltip("maxHeight까지 감기는 회전 수.")]
  [Range(1f, 12f)] public float spiralTurns = 4f;

  [Tooltip("나선 경로로부터 랜덤 이격 범위 (spiralRadius의 배율).")]
  [Range(0f, 1f)] public float jitterRange = 0.25f;

  // === Color ===

  [Header("Color")]
  [Tooltip("높이 0 (바닥) 의 색상.")]
  public Color bottomColor = new Color(1f, 0.35f, 0.65f); // pink
  [Tooltip("높이 maxHeight (꼭대기) 의 색상.")]
  public Color topColor = new Color(0.25f, 0.45f, 1f);    // blue

  // === Mouse Repulsion ===

  [Header("Mouse Repulsion")]
  [Tooltip("마우스 반발 영향 반경 (픽셀 단위). 화면 해상도 기준으로 직관적으로 조절.")]
  [Range(20f, 600f)] public float repulsionRadius = 150f;

  [Tooltip("반발력 최대 세기.")]
  [Range(1f, 60f)] public float repulsionStrength = 14f;

  [Tooltip("가우시안 분포의 시그마 값 (픽셀). 클수록 반발이 넓은 범위에서 부드럽게 퍼짐.")]
  [Range(10f, 400f)] public float gaussianSigma = 60f;

  [Tooltip("나선 경로로 복원하는 스프링 강도.")]
  [Range(1f, 100f)] public float springStrength = 28f;

  [Tooltip("속도 감쇠 상수 (지수 감쇠). 클수록 빠르게 정지.")]
  [Range(0.1f, 20f)] public float dampingDecay = 5f;

  // ----- 내부 구조체 -----

  private struct Particle
  {
    public Vector3 basePos;       // 나선 경로 위의 목표 위치
    public Vector3 pos;           // 실제 현재 위치 (반발로 이탈 가능)
    public Vector3 vel;           // 현재 속도
    public float t;             // 0~1 (높이 진행도)
    public float speed;         // t 단위 속도 (= worldSpeed / maxHeight)
    public float size;          // 스피어 스케일
    public float radialJitter;  // 반지름 고정 오프셋 (스폰시 결정)
    public float angularJitter; // 각도 고정 오프셋 (스폰시 결정)
  }

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

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

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

  // DrawMeshInstanced 배치 최대치 = 1023
  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;
    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;
      Spawn(dt);
      var _mouse = Mouse.current;
      _mouseScreen = _mouse != null ? _mouse.position.ReadValue() : Vector2.zero;
      Simulate(dt);
    }

    Render();

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

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

  // 메시·머티리얼 생성 (없을 때만 실행)
  void InitResources()
  {
    if (_mesh == null)
    {
      // Resources API로 내장 구체 메시 직접 참조 (GameObject 생성 불필요)
      _mesh = Resources.GetBuiltinResource<Mesh>("Sphere.fbx");
    }

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

    _mpb ??= new MaterialPropertyBlock();
  }

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

  // 재생 정지 상태에서 나선 분포 스냅샷 생성
  void BuildEditorPreview()
  {
    _p.Clear();
    // 최대 600개로 제한해 에디터 부하 완화
    int count = Mathf.Min(maxCount, 600);
    for (int i = 0; i < count; i++)
    {
      float t = (float)i / count;
      _p.Add(MakeParticle(t));
    }
  }

  // === 파티클 생성 ===

  // t (0~1) 위치에 파티클 하나 생성
  Particle MakeParticle(float t)
  {
    var p = new Particle
    {
      t = t,
      speed = Random.Range(minSpeed, maxSpeed) / Mathf.Max(maxHeight, 0.001f),
      size = Random.Range(minSize, maxSize),
      radialJitter = Random.Range(-jitterRange, jitterRange) * spiralRadius,
      angularJitter = Random.Range(-jitterRange, jitterRange) * Mathf.PI
    };
    p.basePos = SpiralPos(p);
    p.pos = p.basePos;
    p.vel = Vector3.zero;
    return p;
  }

  // t·jitter 값으로 나선 기준 위치 계산
  Vector3 SpiralPos(in Particle p)
  {
    float y = p.t * maxHeight;
    float angle = p.t * spiralTurns * Mathf.PI * 2f + p.angularJitter;
    float radius = spiralRadius + p.radialJitter;
    return new Vector3(
        radius * Mathf.Sin(angle),
        y,
        radius * Mathf.Cos(angle)
    );
  }

  // === 스폰 ===

  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;
      _p.Add(MakeParticle(0f));
    }
    // 누적 방지: 프레임 드롭으로 타이머가 폭발하면 리셋
    if (_spawnTimer > interval * 4f)
      _spawnTimer = 0f;
  }

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

  void Simulate(float dt)
  {
    // 프레임레이트 독립 지수 감쇠: vel *= exp(-decay * dt)
    float dampFactor = Mathf.Exp(-dampingDecay * dt);

    var cam = Camera.main;
    bool hasCam = cam != null;

    for (int i = _p.Count - 1; i >= 0; i--)
    {
      var p = _p[i];

      // 높이 진행
      p.t += p.speed * dt;

      // 높이 초과 또는 maxCount 초과시 파괴
      if (p.t >= 1f || _p.Count > maxCount)
      {
        _p.RemoveAt(i);
        continue;
      }

      // 현재 t에 맞는 나선 기준 위치 갱신
      p.basePos = SpiralPos(p);

      // 나선 경로 복원 스프링 힘
      p.vel += (p.basePos - p.pos) * (springStrength * dt);

      // 마우스 반발력: 스크린 픽셀 거리 기반 (카메라 각도 독립)
      if (hasCam)
      {
        Vector3 sp = cam.WorldToScreenPoint(p.pos);
        if (sp.z > 0f) // 카메라 앞에 있는 파티클만 처리
        {
          float screenDist = Vector2.Distance(new Vector2(sp.x, sp.y), _mouseScreen);
          if (screenDist < repulsionRadius && screenDist > 0.5f)
          {
            float g = Mathf.Exp(-(screenDist * screenDist)
                                / (2f * gaussianSigma * gaussianSigma));
            // 파티클 깊이 기준으로 마우스를 월드 역투영 → 정확한 3D 반발 방향
            Vector3 mWorld = cam.ScreenToWorldPoint(
                                 new Vector3(_mouseScreen.x, _mouseScreen.y, sp.z));
            Vector3 away = (p.pos - mWorld).normalized;
            p.vel += away * (repulsionStrength * g * dt);
          }
        }
      }

      // 감쇠 적용 후 위치 적분
      p.vel *= dampFactor;
      p.pos += p.vel * dt;

      _p[i] = p;
    }
  }

  // === 렌더링 ===

  // 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];

        // TRS 매트릭스: 위치 + 균등 스케일 (회전 불필요)
        _mBuf[i] = Matrix4x4.TRS(p.pos, Quaternion.identity, Vector3.one * p.size);

        // 높이 기반 색상 lerp: 0 → bottomColor, maxHeight → topColor
        float tc = Mathf.Clamp01(p.pos.y / Mathf.Max(maxHeight, 0.001f));
        Color c = Color.Lerp(bottomColor, topColor, tc);
        _cBuf[i] = new Vector4(c.r, c.g, c.b, c.a);
      }

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

      offset += n;
    }
  }

  // SampleMouseWorld 제거 — Simulate() 내부에서 Mouse.current 직접 처리

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

#if UNITY_EDITOR
    // 인스펙터 값 변경시 에디터 프리뷰 재생성
    void OnValidate()
    {
        if (Application.isPlaying) return;
        // OnValidate는 직렬화 도중 호출될 수 있으므로 null 체크 필수
        if (_mesh == null || _mat == null)
            InitResources();
        if (_mesh != null && _mat != null)
        {
            BuildEditorPreview();
            SceneView.RepaintAll();
        }
    }
#endif
}

📄SwirlUnlit.shader

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

Shader "Custom/SwirlUnlit"
{
    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
        }
    }
}