🫧Art_014 Wave Flow Generator

Code

📄 Art_014_Wave_Flow_Generator.cs

using UnityEngine;
using UnityEngine.Rendering;

#if UNITY_EDITOR
using UnityEditor;
#endif

// ============================================================
// WaveFlowGenerator
// 여러 개의 리본 띠(Band)가 파동치며 흐르는 제너레이티브 아트워크.
// 총 오브젝트 수 = bandCount x segmentCount
// [ExecuteAlways] 로 에디터 Scene 뷰에서도 미리보기가 동작합니다.
// ============================================================
[ExecuteAlways]
public class WaveFlowGenerator : MonoBehaviour
{
  // -----------------------------------------------------------
  // Inspector 파라미터
  // -----------------------------------------------------------

  [Header("구조 설정 (변경 시 재생성)")]
  public int bandCount = 40;    // 리본 띠 개수
  public int segmentCount = 30;   // 띠 당 쿼드 세그먼트 수
  public float bandSpread = 5f;    // 밴드 전체 X축 펼침 너비
  public float flowLength = 10f;   // 흐름 방향(Y축) 전체 길이
  public float segmentWidth = 0.07f; // 쿼드 하나의 너비 (리본 두께)

  [Header("웨이브 형태")]
  public float waveAmp1 = 0.15f;    // 1차 웨이브 진폭 (주요 굴곡)
  public float waveFreq1 = 0.5f;    // 1차 웨이브 주파수
  public float waveAmp2 = 0.4f;    // 2차 웨이브 진폭 (세부 굴곡)
  public float waveFreq2 = 2.0f;    // 2차 웨이브 주파수
  public float twistAmount = 1.5f;    // 밴드 간 위상 차이 (전체 비틀림량)

  [Header("애니메이션")]
  public float flowSpeed = 0.15f;     // 흐름 진행 속도
  public float waveSpeed = 0.8f;      // 웨이브 진동 속도

  [Header("색상")]
  [Range(0f, 1f)] public float hueStart = 0.0f;
  [Range(0f, 1f)] public float hueEnd = 0.0f;
  [Range(0f, 1f)] public float saturation = 0.0f;
  [Range(0f, 1f)] public float brightness = 1.0f;
  [Range(0f, 3f)] public float emissionIntensity = 0.0f;

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

  private int _cachedBandCount;
  private int _cachedSegmentCount;
  private float _cachedBandSpread;
  private float _cachedFlowLength;
  private float _cachedSegmentWidth;

  // -----------------------------------------------------------
  // 세그먼트 데이터
  // -----------------------------------------------------------

  struct SegData
  {
    public Transform tr;
    public Material mat;
    public float tBand;       // 0~1 (밴드 횡방향 위치)
    public float tSeg;        // 0~1 (세그먼트 흐름 방향 위치)
    public float phaseOffset; // 밴드별 고유 위상
  }

  SegData[] _segs = new SegData[0];
  Mesh _sharedQuadMesh;

  // segmentCount 에서 계산되는 쿼드 높이
  private float _segHeight;

#if UNITY_EDITOR
    bool _generateQueued = false;
#endif

  // -----------------------------------------------------------
  // Unity 이벤트
  // -----------------------------------------------------------

  void OnEnable()
  {
    if (_segs.Length == 0)
      Generate();
    CacheStructureParams();
  }

  void OnDisable() => Clear();
  void OnDestroy() => Clear();

  void OnValidate()
  {
#if UNITY_EDITOR
        if (StructureParamsChanged())
        {
            CacheStructureParams();
            QueueGenerate();
        }
        else
        {
            // 색상·애니메이션 파라미터만 변경 시 즉시 미리보기 갱신
            ApplyAnimation(0f);
        }
#endif
  }

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

  void Update()
  {
#if UNITY_EDITOR
        if (!Application.isPlaying) return;
#endif
    ApplyAnimation(Time.time);
  }

  // -----------------------------------------------------------
  // 구조 파라미터 변경 감지
  // -----------------------------------------------------------

  bool StructureParamsChanged()
  {
    return bandCount != _cachedBandCount
        || segmentCount != _cachedSegmentCount
        || bandSpread != _cachedBandSpread
        || flowLength != _cachedFlowLength
        || segmentWidth != _cachedSegmentWidth;
  }

  void CacheStructureParams()
  {
    _cachedBandCount = bandCount;
    _cachedSegmentCount = segmentCount;
    _cachedBandSpread = bandSpread;
    _cachedFlowLength = flowLength;
    _cachedSegmentWidth = segmentWidth;
  }

  // -----------------------------------------------------------
  // 생성
  // -----------------------------------------------------------

  void Generate()
  {
    Clear();

    Shader litShader = Shader.Find("Universal Render Pipeline/Lit");
    if (litShader == null)
    {
      Debug.LogError("[WaveFlowGenerator] URP Lit 셰이더를 찾을 수 없습니다. URP 프로젝트인지 확인하세요.");
      return;
    }

    _sharedQuadMesh = GetBuiltinQuadMesh();
    if (_sharedQuadMesh == null)
    {
      Debug.LogError("[WaveFlowGenerator] Quad Mesh를 가져올 수 없습니다.");
      return;
    }

    // 세그먼트 쿼드 높이: 흐름 길이를 세그먼트 수로 균등 분할
    _segHeight = flowLength / segmentCount;

    int total = bandCount * segmentCount;
    _segs = new SegData[total];

    for (int b = 0; b < bandCount; b++)
    {
      float tBand = (bandCount > 1) ? (float)b / (bandCount - 1) : 0f;
      float phase = tBand * twistAmount * Mathf.PI * 2f;

      for (int s = 0; s < segmentCount; s++)
      {
        float tSeg = (segmentCount > 1) ? (float)s / (segmentCount - 1) : 0f;
        int idx = b * segmentCount + s;

        _segs[idx] = SpawnSegment(idx, tBand, tSeg, phase, litShader);
      }
    }

    ApplyAnimation(0f);
  }

  // 쿼드를 수동으로 조립해 BoxCollider 생성을 막음
  SegData SpawnSegment(int index, float tBand, float tSeg, float phaseOffset, Shader shader)
  {
    GameObject go = new GameObject($"Seg_{index}");
    go.transform.SetParent(transform, false);
    go.transform.localScale = new Vector3(segmentWidth, _segHeight, 1f);

    MeshFilter mf = go.AddComponent<MeshFilter>();
    mf.sharedMesh = _sharedQuadMesh;

    MeshRenderer mr = go.AddComponent<MeshRenderer>();
    mr.shadowCastingMode = ShadowCastingMode.Off;
    mr.receiveShadows = false;

    Material mat = new Material(shader);
    mat.EnableKeyword("_EMISSION");
    mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;
    mr.material = mat;

    return new SegData
    {
      tr = go.transform,
      mat = mat,
      tBand = tBand,
      tSeg = tSeg,
      phaseOffset = phaseOffset
    };
  }

  // 임시 오브젝트로 빌트인 Quad Mesh 획득 후 즉시 파괴
  Mesh GetBuiltinQuadMesh()
  {
    GameObject temp = GameObject.CreatePrimitive(PrimitiveType.Quad);
    Mesh mesh = temp.GetComponent<MeshFilter>().sharedMesh;
    DestroyImmediate(temp);
    return mesh;
  }

  // -----------------------------------------------------------
  // 정리
  // -----------------------------------------------------------

  void Clear()
  {
    if (_segs != null)
    {
      for (int i = 0; i < _segs.Length; i++)
      {
        if (_segs[i].mat != null)
          DestroyImmediate(_segs[i].mat);
      }
    }

    _segs = new SegData[0];

    while (transform.childCount > 0)
    {
#if UNITY_EDITOR
            DestroyImmediate(transform.GetChild(0).gameObject);
#else
      Destroy(transform.GetChild(0).gameObject);
#endif
    }
  }

  // -----------------------------------------------------------
  // 애니메이션
  // -----------------------------------------------------------

  void ApplyAnimation(float t)
  {
    float invSegCount = 1f / segmentCount;

    for (int i = 0; i < _segs.Length; i++)
    {
      ref SegData seg = ref _segs[i];
      if (seg.tr == null || seg.mat == null) continue;

      // 현재 위치 및 다음 위치 (탄젠트 계산용)
      Vector3 pos0 = CalcPosition(seg.tBand, seg.tSeg, seg.phaseOffset, t);
      Vector3 pos1 = CalcPosition(seg.tBand, seg.tSeg + invSegCount, seg.phaseOffset, t);

      seg.tr.localPosition = pos0;

      // 쿼드 로컬 Y를 흐름 방향 탄젠트에 정렬
      Vector3 tangent = pos1 - pos0;
      if (tangent.sqrMagnitude > 0.0001f)
        seg.tr.localRotation = Quaternion.FromToRotation(Vector3.up, tangent.normalized);

      // 색상
      // tBand 로 Hue 결정, tSeg 으로 밝기 변조 (끝단을 약간 어둡게)
      float hue = Mathf.Lerp(hueStart, hueEnd, seg.tBand);
      float brightnessVar = brightness * (0.55f + 0.45f * Mathf.Abs(Mathf.Sin(seg.tSeg * Mathf.PI)));
      Color albedo = Color.HSVToRGB(hue, saturation, brightnessVar);
      Color emission = Color.HSVToRGB(hue, 1f, brightnessVar) * emissionIntensity;

      seg.mat.SetColor("_BaseColor", albedo);
      seg.mat.SetColor("_EmissionColor", emission);
    }
  }

  // 세그먼트 위치 계산 (ApplyAnimation 에서 탄젠트용으로 두 번 호출)
  Vector3 CalcPosition(float tBand, float tSeg, float phase, float t)
  {
    // tFlow: 시간에 따라 흐름 방향으로 지속 이동
    float tFlow = tSeg + t * flowSpeed;

    // 1차 웨이브: X 방향 주요 굴곡
    float wave1X = Mathf.Sin(tFlow * waveFreq1 * Mathf.PI * 2f + phase) * waveAmp1;
    // 2차 웨이브: X 방향 세부 굴곡 + 독립 진동
    float wave2X = Mathf.Sin(tFlow * waveFreq2 * Mathf.PI * 2f + phase * 0.7f + t * waveSpeed) * waveAmp2;

    // Z 깊이 웨이브: 코사인 (X와 90도 위상 차이 → 나선감)
    float wave1Z = Mathf.Cos(tFlow * waveFreq1 * Mathf.PI * 2f + phase) * waveAmp1 * 0.4f;
    float wave2Z = Mathf.Cos(tFlow * waveFreq2 * Mathf.PI * 2f + phase * 0.7f + t * waveSpeed) * waveAmp2 * 0.3f;

    float x = (tBand - 0.5f) * bandSpread + wave1X + wave2X;
    float y = (tSeg - 0.5f) * flowLength;
    float z = wave1Z + wave2Z;

    return new Vector3(x, y, z);
  }
}

실행 구조 및 함수 설명

📐 전체 실행 구조 요약

이 코드는 크게 4개의 구획으로 나뉩니다:

┌──────────────────────────────────────┐
│ 1. Unity 이벤트 (라이프사이클 관리)      │ ← 상태 변화 감지, 초기화, 정리
│    • OnEnable/Disable/Destroy        │
│    • OnValidate, Update              │
├──────────────────────────────────────┤
│ 2. 구조 파라미터 관리 (분기 로직)        │ ← "재생성 필요한지?" 판단
│    • StructureParamsChanged()        │
│    • CacheStructureParams()          │
├──────────────────────────────────────┤
│ 3. 오브젝트 생성 (게임 오브젝트 구축)     │ ← 실제 GameObject, Mesh, Material 생성
│    • Generate(), SpawnSegment()      │
│    • GetBuiltinQuadMesh()            │
├──────────────────────────────────────┤
│ 4. 애니메이션 (프레임별 시각 업데이트)    │ ← 위치/회전/색상 실시간 계산
│    • ApplyAnimation(), CalcPosition()│
└──────────────────────────────────────┘

🔁 1. Unity 이벤트 함수 (관리용 코드)

void OnEnable()

void OnEnable()
{
    if (_segs.Length == 0) Generate();  // 최초 실행 시 구조 생성
    CacheStructureParams();              // 현재 파라미터값 캐싱
}

• 의미: 컴포넌트가 활성화될 때 또는 GameObject 가 켜질 때 자동으로 호출
• 작동:
  1. _segs 배열이 비어있으면 Generate() 를 호출해 오브젝트들을 처음 생성
  2. 구조 파라미터들(bandCount, segmentCount 등)을 _cached~ 변수에 저장
• 목적: "초기화 시점"을 관리하여 불필요한 재생성을 방지
  

void OnDisenable() / void OnDestroy()

void OnDisable() => Clear();
void OnDestroy() => Clear();

• 의미: 컴포넌트 비활성화/소멸 시 호출
• 작동: Clear() 를 호출해 생성된 모든 자식 오브젝트와 머티리얼을 정리
• 목적: 메모리 누수 방지, 에디터/런타임에서 잔여물 제거

void OnValidate() ✨ (에디터 전용)

void OnValidate()
{
#if UNITY_EDITOR
    if (StructureParamsChanged())  // 구조 파라미터 변경 감지
    {
        CacheStructureParams();
        QueueGenerate();           // 재생성 큐 등록 (비동기)
    }
    else
    {
        ApplyAnimation(0f);        // 색상/애니 파라미터만 변경 → 즉시 미리보기
    }
#endif
}

• 의미: 인스펙터에서 값이 변경될 때마다 에디터에서 자동 호출
• 작동:
  • 구조 파라미터(bandCount, segmentCount 등) 변경 → QueueGenerate() 로 재생성 예약
  • 시각 파라미터(색상, 진폭, 속도 등) 변경 → 즉시 ApplyAnimation(0f) 으로 미리보기 갱신
• 목적: 에디터에서 실시간 프리뷰 제공 + 불필요한 재생성 방지

void QueueGenerate() ✨ (에디터 전용)

void QueueGenerate()
{
    if (_generateQueued) return;
    _generateQueued = true;
    EditorApplication.delayCall += () =>  // 다음 에디터 프레임으로 지연
    {
        _generateQueued = false;
        if (this == null) return;
        Generate();  // 실제 재생성 실행
    };
}

• 의미: 재생성 작업을 에디터의 다음 프레임으로 미룸
• 작동:
  1. _generateQueued 플래그로 중복 큐 방지
  2. EditorApplication.delayCall 로 작업 스케줄링
  3. 실제 Generate() 실행 전에 null 체크로 안전성 확보
     목적: 인스펙터에서 슬라이더를 빠르게 움직일 때 매 프레임마다 재생성되는 성능 저하 방지

void Update()

void Update()
{
#if UNITY_EDITOR
    if (!Application.isPlaying) return;  // 에디터에선 플레이 모드일 때만 실행
#endif
    ApplyAnimation(Time.time);  // 게임 시간에 기반한 애니메이션 적용
}

• 의미: 매 프레임 호출되는 메인 루프
• 작동:
  -에디터에서는 Application.isPlaying 이 참일 때만 실행 (프리뷰와 플레이 모드 분리)
  -Time.time 을 ApplyAnimation() 에 전달해 시간에 따른 웨이브 애니메이션 계산
• 목적: 런타임에서 부드러운 애니메이션 구동

⚙️ 구조 파라미터 관리 함수 (분기 로직)

bool StructureParamsChanged()

bool StructureParamsChanged()
{
    return bandCount    != _cachedBandCount
        || segmentCount != _cachedSegmentCount
        || bandSpread   != _cachedBandSpread
        || flowLength   != _cachedFlowLength
        || segmentWidth != _cachedSegmentWidth;
}

• 의미: "오브젝트 구조를 다시 만들어야 하나?" 를 판단하는 감지기
• 작동: 현재 공개 파라미터와 캐시된 이전 값을 비교하여 변경 여부 반환
• 목적: OnValidate() 에서 재생성 필요 여부를 결정하는 핵심 로직

void CacheStructureParams()

void CacheStructureParams()
{
    _cachedBandCount     = bandCount;
    _cachedSegmentCount  = segmentCount;
    // ... 나머지 파라미터도 동일하게 캐싱
}

• 의미: 현재 구조 파라미터 값을 "이전 값"으로 저장
• 작동: 공개 필드 값을 비공개 _cached~ 필드에 복사
• 목적: 다음 변경 감지를 위한 기준점 설정

🏗️ 오브젝트 생성 함수 (게임 오브젝트 구축)

void Generate()

void Generate()
{
    Clear();  // 기존 오브젝트 정리
    // 1. 셰이더 로딩 (URP Lit)
    Shader litShader = Shader.Find("Universal Render Pipeline/Lit");
    // 2. 기본 쿼드 메쉬 획득
    _sharedQuadMesh = GetBuiltinQuadMesh();
    // 3. 세그먼트 높이 계산
    _segHeight = flowLength / segmentCount;
    // 4. 세그먼트 배열 할당
    int total = bandCount * segmentCount;
    _segs = new SegData[total];
    // 5. 이중 루프로 모든 세그먼트 생성
    for (int b = 0; b < bandCount; b++)
    {
        float tBand = (bandCount > 1) ? (float)b / (bandCount - 1) : 0f;
        float phase = tBand * twistAmount * Mathf.PI * 2f;  // 밴드별 위상 오프셋 
        for (int s = 0; s < segmentCount; s++)
        {
            float tSeg = (segmentCount > 1) ? (float)s / (segmentCount - 1) : 0f;
            int idx = b * segmentCount + s;
            _segs[idx] = SpawnSegment(idx, tBand, tSeg, phase, litShader);
        }
    }
    ApplyAnimation(0f);  // 초기 시각 상태 적용
}

• 의미: 전체 리본 구조를 처음부터 구축하는 메인 생성 함수
• 작동:
  1. 기존 오브젝트 정리 (Clear())
  2. URP Lit 셰이더와 기본 Quad Mesh 준비
  3. bandCount × segmentCount 만큼 SpawnSegment() 호출
  4. 각 세그먼트에 tBand(0~1, 가로 위치), tSeg(0~1, 세로 위치), phase(위상차) 파라미터 부여
• 목적: 파라미터에 기반한 제너레이티브 아트워크의 물리적 구조 생성

SegData SpawnSegment(...)

SegData SpawnSegment(int index, float tBand, float tSeg, float phaseOffset, Shader shader)
{
    	// 1. GameObject 생성 및 계층 설정
    GameObject go = new GameObject($"Seg_{index}");
    go.transform.SetParent(transform, false);
    go.transform.localScale = new Vector3(segmentWidth, _segHeight, 1f);
    	// 2. MeshFilter: 공유 쿼드 메쉬 할당
    MeshFilter mf = go.AddComponent<MeshFilter>();
    mf.sharedMesh = _sharedQuadMesh;
       // 3. MeshRenderer: 그림자 설정 끄기
    MeshRenderer mr = go.AddComponent<MeshRenderer>();
    mr.shadowCastingMode = ShadowCastingMode.Off;
    mr.receiveShadows = false;
        // 4. Material: 발광 키워드 활성화
    Material mat = new Material(shader);
    mat.EnableKeyword("_EMISSION");
    mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;
    mr.material = mat;
        // 5. 데이터 구조체로 반환
    return new SegData { tr = go.transform, mat = mat, tBand = tBand, tSeg = tSeg, phaseOffset = phaseOffset };
}

• 의미: 단일 세그먼트(쿼드) 오브젝트를 생성하고 설정하는 팩토리 함수
• 작동:
  • GameObject 생성 → Transform 설정 → MeshFilter/Renderer 추가 → Material 생성
  • 발광(_EMISSION) 키워드 활성화로 네온 느낌 구현
  • 생성된 참조들과 파라미터를 SegData 구조체로 묶어 반환
• 목적: 재사용 가능한 세그먼트 생성 로직 캡슐화

Mesh GetBuiltinQuadMesh()

Mesh GetBuiltinQuadMesh()
{
    GameObject temp = GameObject.CreatePrimitive(PrimitiveType.Quad);
    Mesh mesh = temp.GetComponent<MeshFilter>().sharedMesh;
    DestroyImmediate(temp);  // 임시 오브젝트는 즉시 삭제
    return mesh;  // 메쉬 참조만 반환 (Unity 내장 리소스)
}

• 의미: Unity 내장 Quad 메쉬를 참조만 얻어오는 헬퍼
• 작동: 임시 Quad 생성 → 메쉬 참조 추출 → 임시 오브젝트 즉시 삭제
• 목적: 메쉬 데이터를 중복 생성하지 않고 공유하여 메모리 효율화

🧹 정리 함수

void Clear()

void Clear()
{
    // 1. 모든 머티리얼 수동 삭제 (메모리 누수 방지)
    if (_segs != null)
    {
        for (int i = 0; i < _segs.Length; i++)
        {
            if (_segs[i].mat != null)
                DestroyImmediate(_segs[i].mat);  // 에디터용
        }
    }
    
    // 2. 배열 초기화
    _segs = new SegData[0];
    
    // 3. 모든 자식 GameObject 삭제
    while (transform.childCount > 0)
    {
#if UNITY_EDITOR
        DestroyImmediate(transform.GetChild(0).gameObject);
#else
        Destroy(transform.GetChild(0).gameObject);  // 런타임용
#endif
    }
}

• 의미: 생성된 모든 리소스를 정리하는 소멸자 역할
• 작동:
  • Material 은 DestroyImmediate 로 즉시 해제 (에디터에서 중요)
  • GameObject 는 에디터/런타임에 따라 DestroyImmediate / Destroy 분기 처리
• 목적: 재생성 시 중복 생성 방지, 메모리 누수 차단

🎬 애니메이션 함수 (시각 업데이트)

void ApplyAnimation(float t)

void ApplyAnimation(float t)
{
    float invSegCount = 1f / segmentCount;
    
    for (int i = 0; i < _segs.Length; i++)
    {
        ref SegData seg = ref _segs[i];
        if (seg.tr == null || seg.mat == null) continue;  // 안전 체크
        
        // 1. 위치 계산: 현재와 다음 지점으로 탄젠트(방향) 구함
        Vector3 pos0 = CalcPosition(seg.tBand, seg.tSeg, seg.phaseOffset, t);
        Vector3 pos1 = CalcPosition(seg.tBand, seg.tSeg + invSegCount, seg.phaseOffset, t);
        
        seg.tr.localPosition = pos0;  // 위치 적용
        
        // 2. 회전: 쿼드의 Y 축을 흐름 방향(탄젠트)에 정렬
        Vector3 tangent = pos1 - pos0;
        if (tangent.sqrMagnitude > 0.0001f)
            seg.tr.localRotation = Quaternion.FromToRotation(Vector3.up, tangent.normalized);
        
        // 3. 색상: tBand 로 Hue 그라데이션, tSeg 로 밝기 변조
        float hue = Mathf.Lerp(hueStart, hueEnd, seg.tBand);
        float brightnessVar = brightness * (0.55f + 0.45f * Mathf.Abs(Mathf.Sin(seg.tSeg * Mathf.PI)));
        Color albedo = Color.HSVToRGB(hue, saturation, brightnessVar);
        Color emission = Color.HSVToRGB(hue, 1f, brightnessVar) * emissionIntensity;
        
        seg.mat.SetColor("_BaseColor", albedo);
        seg.mat.SetColor("_EmissionColor", emission);
    }
}

• 의미: 매 프레임 모든 세그먼트의 시각 상태를 업데이트하는 메인 애니메이션 함수
• 작동:
  1. 위치: CalcPosition() 으로 3D 좌표 계산
  2. 회전: 현재-다음 위치의 벡터 차이로 탄젠트 계산 → 쿼드를 흐름 방향에 정렬
  3. 색상:
     - tBand 로 hueStart~hueEnd 를 보간하여 가로 방향 그라데이션
     - tSeg 로 사인 함수를 이용해 끝단이 어두워지는 밝기 변조
     - _BaseColor(표면) 와 _EmissionColor(발광) 분리 설정
     목적: 파라미터 기반의 유기적인 웨이브 애니메이션 구현

Vector3 CalcPosition(float tBand, float tSeg, float phase, float t)

Vector3 CalcPosition(float tBand, float tSeg, float phase, float t)
{
    // 1. 흐름 방향 이동: 시간에 따라 tSeg 가 증가
    float tFlow = tSeg + t * flowSpeed;
    
    // 2. X 축 웨이브: 1 차(주요) + 2 차(세부) 사인 파 중첩
    float wave1X = Mathf.Sin(tFlow * waveFreq1 * Mathf.PI * 2f + phase) * waveAmp1;
    float wave2X = Mathf.Sin(tFlow * waveFreq2 * Mathf.PI * 2f + phase * 0.7f + t * waveSpeed) * waveAmp2;
    
    // 3. Z 축 웨이브: 코사인 (X 와 90 도 위상차 → 나선형 효과)
    float wave1Z = Mathf.Cos(tFlow * waveFreq1 * Mathf.PI * 2f + phase) * waveAmp1 * 0.4f;
    float wave2Z = Mathf.Cos(tFlow * waveFreq2 * Mathf.PI * 2f + phase * 0.7f + t * waveSpeed) * waveAmp2 * 0.3f;
    
    // 4. 최종 좌표 조합
    float x = (tBand - 0.5f) * bandSpread + wave1X + wave2X;  // 가로 위치 + 웨이브
    float y = (tSeg - 0.5f) * flowLength;                      // 세로 기본 위치
    float z = wave1Z + wave2Z;                                 // 깊이 웨이브
    
    return new Vector3(x, y, z);
}

• 의미: 단일 세그먼트의 3D 위치를 수학적으로 계산하는 핵심 함수
• 작동:
  • tFlow: 시간에 따라 흐르는 파라미터 (애니메이션의 핵심)
  • wave1X / wave2X: 서로 다른 주파수/진폭의 사인파 중첩으로 복잡한 굴곡 생성
  • wave1Z / wave2Z: 코사인파로 X 와 위상차를 주어 3 차원 나선감 표현
  • phase: 밴드마다 다른 위상 오프셋으로 전체적인 비틀림 효과
• 목적: 파라미터 조절만으로 다양한 유기적 웨이브 패턴 생성