🫧Art_030 Surface Line Artwork

기본 LineRenderer 구조

• Line Renderer는 월드 좌표상의 여러 점(Position 배열)을 받아 선을 구성합니다.
• 두 점만 설정하면 “직선 세그먼트”가 됩니다.
• 두께는 startWidth, endWidth
• 색상은 Material 또는 colorGradient로 제어합니다.

using UnityEngine;

[RequireComponent(typeof(LineRenderer))]
public class SimpleLineBetweenPoints : MonoBehaviour
{
    [Header("라인 설정")]
    [SerializeField] private float lineWidth = 0.05f;

    [Header("임의 범위")]
    [SerializeField] private Vector3 rangeMin = new Vector3(-5f, -5f, -5f);
    [SerializeField] private Vector3 rangeMax = new Vector3(5f, 5f, 5f);

    private LineRenderer lineRenderer;

    void Awake() // Line Renderer 초기화 및 렌더링 파라미터 설정
    {
        lineRenderer = GetComponent<LineRenderer>();

        // 기본 설정
        lineRenderer.positionCount = 2;
        lineRenderer.useWorldSpace = true; // 오브젝트 이동과 무관하게 공간상의 두 점 유지

        // 두께 설정
        lineRenderer.startWidth = lineWidth;
        lineRenderer.endWidth = lineWidth;

        // 머티리얼 (Unlit 계열 사용)
        lineRenderer.material = new Material(Shader.Find("Sprites/Default"));

        // 색상 (흰색)
        lineRenderer.startColor = Color.white;
        lineRenderer.endColor = Color.white;

        // 그림자/라이트 영향 제거 (아트워크용)
        lineRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
        lineRenderer.receiveShadows = false;
    }

    void Start() // 두 개의 랜덤 포인트 생성 후 라인 연결
    {
        Vector3 pointA = GetRandomPoint();
        Vector3 pointB = GetRandomPoint();
        
		// SetPosition(index, position) : 라인의 각 점을 직접 지정
        lineRenderer.SetPosition(0, pointA);
        lineRenderer.SetPosition(1, pointB);
    }

    private Vector3 GetRandomPoint()
    {
        return new Vector3(
            Random.Range(rangeMin.x, rangeMax.x),
            Random.Range(rangeMin.y, rangeMax.y),
            Random.Range(rangeMin.z, rangeMax.z)
        );
    }
}

SurfaceLineManager (GameObject)
└── Line_000
│   ├── LineRenderer       ← 두 점 사이 선
│   ├── TrailA             ← 점 A의 궤적
│   │   └── TrailRenderer
│   └── TrailB             ← 점 B의 궤적
│       └── TrailRenderer
└── Line_001
    └── ...

using System.Collections.Generic;
using UnityEngine;

public class SurfaceLineManager : MonoBehaviour
{
  // ===

  [Header("박스 크기 (절반 extents)")]
  [SerializeField] private Vector3 boxHalfSize = new Vector3(5f, 5f, 5f);

  [Header("라인 개수")]
  [SerializeField, Range(1, 256)] private int lineCount = 16;

  [Header("라인 두께")]
  [SerializeField] private float lineWidth = 0.05f;

  [Header("이동 속도 범위")]
  [SerializeField] private float minSpeed = 0.5f;
  [SerializeField] private float maxSpeed = 3f;

  [Header("색상")]
  [SerializeField] private Color startColor = Color.white;
  [SerializeField] private Color endColor = Color.white;
  [SerializeField, Range(0f, 1f)] private float startAlpha = 1f;
  [SerializeField, Range(0f, 1f)] private float endAlpha = 1f;

  [Header("트레일")]
  [SerializeField] private bool enableTrail = true;
  [SerializeField] private float trailTime = 0.5f;         // 잔상 지속 시간
  [SerializeField] private float trailStartWidth = 0.04f;  // 트레일 시작 두께
  [SerializeField] private float trailEndWidth = 0f;       // 트레일 끝 두께 (0 = 완전히 사라짐)
  [SerializeField] private Color trailStartColor = Color.white;
  [SerializeField] private Color trailEndColor = Color.clear;  // 끝쪽은 투명

  // ---

  private struct SurfacePoint
  {
    public int faceIndex;
    public Vector2 uv;
    public Vector2 velocity;
  }

  // 라인 하나당 필요한 컴포넌트 묶음
  private struct LineEntry
  {
    public LineRenderer lineRenderer;
    public Transform trailTransformA;  // 점 A 위치 추적용 Transform
    public Transform trailTransformB;  // 점 B 위치 추적용 Transform
  }

  private List<LineEntry> lines = new List<LineEntry>();
  private SurfacePoint[] pointsA;
  private SurfacePoint[] pointsB;

  // ===

  void Awake()
  {
    InitLines();
  }

  void Update()
  {
    for (int i = 0; i < lineCount; i++)
    {
      pointsA[i] = MovePoint(pointsA[i]);
      pointsB[i] = MovePoint(pointsB[i]);

      Vector3 worldA = ToWorld(pointsA[i]);
      Vector3 worldB = ToWorld(pointsB[i]);

      lines[i].lineRenderer.SetPosition(0, worldA);
      lines[i].lineRenderer.SetPosition(1, worldB);

      // TrailRenderer는 Transform 위치를 따라가므로 위치만 갱신
      lines[i].trailTransformA.position = worldA;
      lines[i].trailTransformB.position = worldB;
    }
  }

  // ===

  private void InitLines()
  {
    for (int i = transform.childCount - 1; i >= 0; i--)
      Destroy(transform.GetChild(i).gameObject);

    lines.Clear();

    pointsA = new SurfacePoint[lineCount];
    pointsB = new SurfacePoint[lineCount];

    Shader lineShader = Shader.Find("Universal Render Pipeline/Particles/Unlit");
    if (lineShader == null)
      lineShader = Shader.Find("Sprites/Default");

    Gradient lineGradient = BuildGradient(startColor, endColor, startAlpha, endAlpha);
    Gradient trailGradient = BuildGradient(trailStartColor, trailEndColor, trailStartColor.a, 0f);

    for (int i = 0; i < lineCount; i++)
    {
      // --- 라인 오브젝트
      GameObject lineGO = new GameObject($"Line_{i:000}");
      lineGO.transform.SetParent(transform, false);

      LineRenderer lr = lineGO.AddComponent<LineRenderer>();
      SetupLineRenderer(lr, lineShader, lineGradient);

      // --- 트레일 A (점 A용)
      Transform trailA = CreateTrailObject("TrailA", lineGO.transform, lineShader, trailGradient);

      // --- 트레일 B (점 B용)
      Transform trailB = CreateTrailObject("TrailB", lineGO.transform, lineShader, trailGradient);

      lines.Add(new LineEntry
      {
        lineRenderer = lr,
        trailTransformA = trailA,
        trailTransformB = trailB
      });

      pointsA[i] = SpawnPoint();
      pointsB[i] = SpawnPoint();

      // 초기 위치 설정
      Vector3 wa = ToWorld(pointsA[i]);
      Vector3 wb = ToWorld(pointsB[i]);
      lr.SetPosition(0, wa);
      lr.SetPosition(1, wb);
      trailA.position = wa;
      trailB.position = wb;
    }
  }

  // ---

  // LineRenderer 기본 세팅
  private void SetupLineRenderer(LineRenderer lr, Shader shader, Gradient gradient)
  {
    lr.positionCount = 2;
    lr.useWorldSpace = true;
    lr.startWidth = lineWidth;
    lr.endWidth = lineWidth;
    lr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
    lr.receiveShadows = false;
    lr.material = new Material(shader);
    lr.startColor = Color.white;
    lr.endColor = Color.white;
    lr.colorGradient = gradient;
  }

  // ---

  // TrailRenderer가 붙은 자식 오브젝트 생성
  private Transform CreateTrailObject(string name, Transform parent, Shader shader, Gradient gradient)
  {
    GameObject go = new GameObject(name);
    go.transform.SetParent(parent, false);

    TrailRenderer tr = go.AddComponent<TrailRenderer>();
    tr.time = trailTime;
    tr.startWidth = trailStartWidth;
    tr.endWidth = trailEndWidth;
    tr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
    tr.receiveShadows = false;
    tr.material = new Material(shader);

    // 트레일 컬러: 시작(현재 위치)은 불투명, 끝(오래된 위치)은 투명
    tr.colorGradient = gradient;

    // 트레일이 활성화 여부
    tr.enabled = enableTrail;

    return go.transform;
  }

  // ---

  private SurfacePoint SpawnPoint()
  {
    int face = Random.Range(0, 6);
    Vector2 halfUV = GetFaceHalfExtents(face);

    Vector2 uv = new Vector2(
        Random.Range(-halfUV.x, halfUV.x),
        Random.Range(-halfUV.y, halfUV.y)
    );

    float angle = Random.Range(0f, Mathf.PI * 2f);
    float speed = Random.Range(minSpeed, maxSpeed);
    Vector2 vel = new Vector2(Mathf.Cos(angle), Mathf.Sin(angle)) * speed;

    return new SurfacePoint { faceIndex = face, uv = uv, velocity = vel };
  }

  // ---

  private SurfacePoint MovePoint(SurfacePoint p)
  {
    Vector2 half = GetFaceHalfExtents(p.faceIndex);
    Vector2 newUV = p.uv + p.velocity * Time.deltaTime;
    Vector2 newVel = p.velocity;

    if (newUV.x > half.x) { newUV.x = half.x; newVel.x = -newVel.x; }
    if (newUV.x < -half.x) { newUV.x = -half.x; newVel.x = -newVel.x; }
    if (newUV.y > half.y) { newUV.y = half.y; newVel.y = -newVel.y; }
    if (newUV.y < -half.y) { newUV.y = -half.y; newVel.y = -newVel.y; }

    return new SurfacePoint { faceIndex = p.faceIndex, uv = newUV, velocity = newVel };
  }

  // ---

  private Vector3 ToWorld(SurfacePoint p)
  {
    float u = p.uv.x;
    float v = p.uv.y;

    switch (p.faceIndex)
    {
      case 0: return new Vector3(boxHalfSize.x, u, v);
      case 1: return new Vector3(-boxHalfSize.x, u, v);
      case 2: return new Vector3(u, boxHalfSize.y, v);
      case 3: return new Vector3(u, -boxHalfSize.y, v);
      case 4: return new Vector3(u, v, boxHalfSize.z);
      case 5: return new Vector3(u, v, -boxHalfSize.z);
      default: return Vector3.zero;
    }
  }

  // ---

  private Vector2 GetFaceHalfExtents(int faceIndex)
  {
    switch (faceIndex)
    {
      case 0: case 1: return new Vector2(boxHalfSize.y, boxHalfSize.z);
      case 2: case 3: return new Vector2(boxHalfSize.x, boxHalfSize.z);
      case 4: case 5: return new Vector2(boxHalfSize.x, boxHalfSize.y);
      default: return Vector2.one;
    }
  }

  // ---

  // 범용 Gradient 빌더
  private Gradient BuildGradient(Color colorA, Color colorB, float alphaA, float alphaB)
  {
    Gradient g = new Gradient();
    g.SetKeys(
        new GradientColorKey[] {
                new GradientColorKey(colorA, 0f),
                new GradientColorKey(colorB, 1f)
        },
        new GradientAlphaKey[] {
                new GradientAlphaKey(alphaA, 0f),
                new GradientAlphaKey(alphaB, 1f)
        }
    );
    return g;
  }

  // ===

#if UNITY_EDITOR
  void OnValidate()
  {
    if (!Application.isPlaying) return;

    Gradient lg = BuildGradient(startColor, endColor, startAlpha, endAlpha);
    Gradient tg = BuildGradient(trailStartColor, trailEndColor, trailStartColor.a, 0f);

    foreach (var entry in lines)
    {
      if (entry.lineRenderer == null) continue;

      entry.lineRenderer.startWidth = lineWidth;
      entry.lineRenderer.endWidth = lineWidth;
      entry.lineRenderer.colorGradient = lg;

      ApplyTrailSettings(entry.trailTransformA, tg);
      ApplyTrailSettings(entry.trailTransformB, tg);
    }
  }

  // OnValidate에서 TrailRenderer 설정 갱신
  private void ApplyTrailSettings(Transform t, Gradient gradient)
  {
    if (t == null) return;
    TrailRenderer tr = t.GetComponent<TrailRenderer>();
    if (tr == null) return;

    tr.time = trailTime;
    tr.startWidth = trailStartWidth;
    tr.endWidth = trailEndWidth;
    tr.colorGradient = gradient;
    tr.enabled = enableTrail;
  }
#endif
}