블렌더 아트워크 블로그

핵심 로직

• 이미지 픽셀 → luminance 계산 (ITU-R BT.709)
• luminance → 회전각 매핑 (어두울수록 큰 각도)
• 판들이 랜덤 딜레이로 뒤집혔다 돌아오는 사이클 반복

• 인스펙터에서 할당할 이미지의 Import Settings에서 Read/Write Enabled를 체크해야 GetPixel()이 동작합니다.

• 피벗 오프셋 처리: 블로그 원본처럼 판이 한쪽 모서리를 축으로 뒤집히도록 pivot 보정 오프셋을 Animate()에서 계산합니다. plateSize * 0.5f 값이 그 기준입니다.

코드

📒PixelLuminanceFlip.cs

using System.Collections.Generic;
using UnityEngine;

#if UNITY_EDITOR
using UnityEditor;
#endif

[ExecuteAlways]
public class PixelLuminanceFlip : MonoBehaviour
{
    enum RenderPipeline { BuiltIn, URP, HDRP }

    struct PlateData
    {
        public float   targetAngle;   // luminance에서 계산한 목표 회전각 (degrees)
        public float   startDelay;    // 사이클 내 랜덤 시작 지연
        public Color   color;         // 이미지에서 샘플링한 픽셀 색상
        public Vector3 localPos;      // 그리드 로컬 위치
    }

    // =========================================================
    [Header("Image")]
    [SerializeField, Tooltip("픽셀 luminance를 분석할 소스 이미지. Import Settings > Read/Write Enabled 필수.")]
    Texture2D sourceImage;
    [SerializeField, Tooltip("true: 어두울수록 큰 각도 / false: 밝을수록 큰 각도")]
    bool invertLuminance = true;

    [Header("Grid")]
    [SerializeField] int   gridSize  = 30;
    [SerializeField] float spacing   = 0.52f;
    [SerializeField] float plateSize = 0.5f;

    [Header("Flip Animation")]
    [SerializeField, Range(1f, 180f), Tooltip("완전히 어두운 픽셀의 최대 회전 각도")]
    float maxAngleDeg = 90f;
    [SerializeField, Range(0.05f, 2f), Tooltip("뒤집히는 데 걸리는 시간 (초)")]
    float flipDuration = 0.25f;
    [SerializeField, Range(0f, 5f), Tooltip("뒤집힌 채 유지되는 시간 (초)")]
    float holdDuration = 0.8f;
    [SerializeField, Range(0.5f, 10f), Tooltip("한 사이클의 전체 길이 (초)")]
    float cycleInterval = 4f;
    [SerializeField, Range(0f, 5f), Tooltip("판들의 랜덤 시작 지연 최대값 (초)")]
    float delaySpread = 1.5f;
    [SerializeField] int randomSeed = 42;

    [Header("Color")]
    [SerializeField, Tooltip("true: 이미지 픽셀 색상 / false: 단색")]
    bool useImageColor = true;
    [SerializeField] Color overrideColor = Color.white;

    [Header("Rendering")]
    [SerializeField] Mesh     instanceMesh;
    [SerializeField] Material instanceMaterial;

    // =========================================================
    const int BATCH_SIZE = 1023;

    readonly List<PlateData> _plates = new List<PlateData>();
    Matrix4x4[] _matrices;
    Vector4[]   _colors;

    bool  _generated;
    float _simTime;
    RenderPipeline _pipeline;

    // --- 구조 캐시 ---
    int       _cachedGridSize;
    float     _cachedSpacing, _cachedPlateSize, _cachedMaxAngle, _cachedDelaySpread;
    int       _cachedSeed;
    Texture2D _cachedImage;

#if UNITY_EDITOR
    bool _generateQueued;
#endif

    // =========================================================
    void OnEnable()
    {
        _pipeline = DetectPipeline();
        EnsureResources();
        Generate();
        CacheStructureParams();
    }

    void OnValidate()
    {
        gridSize     = Mathf.Max(2, gridSize);
        spacing      = Mathf.Max(0.01f, spacing);
        plateSize    = Mathf.Max(0.01f, plateSize);
        flipDuration = Mathf.Max(0.01f, flipDuration);
        holdDuration = Mathf.Max(0f, holdDuration);
        delaySpread  = Mathf.Max(0f, delaySpread);
        // cycleInterval은 flipOut + hold + flipBack + 여유보다 커야 함
        cycleInterval = Mathf.Max(flipDuration * 2f + holdDuration + 0.1f, cycleInterval);

#if UNITY_EDITOR
        _pipeline = DetectPipeline();
        EnsureResources();

        if (StructureParamsChanged())
        {
            CacheStructureParams();
            QueueGenerate();
        }
        else
        {
            Animate(Application.isPlaying ? _simTime : 0f);
        }
#endif
    }

    void Update()
    {
        if (!_generated) return;

        if (!Application.isPlaying)
        {
            Animate(0f);
            RenderInstances();
            return;
        }

        _simTime += Time.deltaTime;
        Animate(_simTime);
        RenderInstances();
    }

    // =========================================================
    // 기본 메시를 Cube로 생성. 커스텀 셰이더 없으면 URP Unlit 폴백.
    void EnsureResources()
    {
        if (instanceMesh == null)
        {
            GameObject temp = GameObject.CreatePrimitive(PrimitiveType.Cube);
            instanceMesh = temp.GetComponent<MeshFilter>().sharedMesh;
            DestroyImmediate(temp);
        }

        if (instanceMaterial == null)
        {
            Shader shader =
                Shader.Find("Custom/SpiralVortexUnlit") ??
                Shader.Find("Universal Render Pipeline/Unlit") ??
                Shader.Find("Standard");

            instanceMaterial = new Material(shader);
            instanceMaterial.enableInstancing = true;
        }
    }

    // 이미지 luminance 분석 후 플레이트 배열 생성
    void Generate()
    {
        _plates.Clear();
        _generated = false;
        _simTime   = 0f;

        Random.InitState(randomSeed);

        float[] luminances = SampleLuminances();
        NormalizeLuminances(luminances, out float[] normalized);

        float totalW = (gridSize - 1) * spacing;
        float totalH = (gridSize - 1) * spacing;

        for (int y = 0; y < gridSize; y++)
        {
            for (int x = 0; x < gridSize; x++)
            {
                int   idx = y * gridSize + x;
                float t   = invertLuminance ? 1f - normalized[idx] : normalized[idx];

                _plates.Add(new PlateData
                {
                    targetAngle = t * maxAngleDeg,
                    startDelay  = Random.Range(0f, delaySpread),
                    color       = useImageColor ? SampleColor(x, y) : overrideColor,
                    localPos    = new Vector3(
                        x * spacing - totalW * 0.5f,
                        0f,
                        y * spacing - totalH * 0.5f)
                });
            }
        }

        _matrices = new Matrix4x4[_plates.Count];
        _colors   = new Vector4[_plates.Count];

        _generated = true;
        Animate(0f);
    }

    // =========================================================
    // 매 프레임 각 플레이트의 회전각을 SmoothStep으로 보간
    void Animate(float t)
    {
        if (_matrices == null || _colors == null) return;

        float cycleT = t % cycleInterval;   // 전체 사이클 내 현재 위치

        for (int i = 0; i < _plates.Count; i++)
        {
            PlateData plate  = _plates[i];
            float     localT = cycleT - plate.startDelay;   // 플레이트 개별 타이머
            float     angle  = 0f;

            if (localT > 0f)
            {
                float tFlipOut  = flipDuration;
                float tHold     = tFlipOut + holdDuration;
                float tFlipBack = tHold    + flipDuration;

                if      (localT < tFlipOut)  angle = Mathf.SmoothStep(0f,                plate.targetAngle, localT / flipDuration);
                else if (localT < tHold)     angle = plate.targetAngle;
                else if (localT < tFlipBack) angle = Mathf.SmoothStep(plate.targetAngle, 0f,                (localT - tHold) / flipDuration);
                // tFlipBack 이후: angle = 0 (평면 유지)
            }

            // 피벗을 앞 모서리로 이동해서 회전 (문처럼 뒤집히는 느낌)
            // 로컬: 회전 전 중심을 Z 방향으로 plateSize/2 앞으로 이동 후 회전, 다시 복원
            Quaternion rot    = Quaternion.Euler(angle, 0f, 0f);
            Vector3    pivot  = new Vector3(0f, 0f, plateSize * 0.5f);
            Vector3    offset = rot * -pivot + pivot;   // 피벗 보정 오프셋

            Vector3 worldPos  = transform.TransformPoint(plate.localPos + offset);
            Quaternion worldRot = transform.rotation * rot;
            Vector3 scale     = new Vector3(plateSize, plateSize * 0.1f, plateSize);

            _matrices[i] = Matrix4x4.TRS(worldPos, worldRot, scale);

            Color c = plate.color;
            _colors[i] = new Vector4(c.r, c.g, c.b, c.a);
        }
    }

    // 1023개 단위 배치 드로우
    void RenderInstances()
    {
        if (instanceMesh == null || instanceMaterial == null) return;

        string colorProp = GetColorPropertyName();
        int total = _plates.Count;
        int index = 0;

        while (total > 0)
        {
            int batch = Mathf.Min(BATCH_SIZE, total);

            Matrix4x4[] batchMatrices = new Matrix4x4[batch];
            Vector4[]   batchColors   = new Vector4[batch];

            System.Array.Copy(_matrices, index, batchMatrices, 0, batch);
            System.Array.Copy(_colors,   index, batchColors,   0, batch);

            MaterialPropertyBlock block = new MaterialPropertyBlock();
            block.SetVectorArray(colorProp, batchColors);

            Graphics.DrawMeshInstanced(
                instanceMesh, 0, instanceMaterial,
                batchMatrices, batch, block
            );

            index += batch;
            total -= batch;
        }
    }

    // =========================================================
    // 그리드 전체 좌표의 luminance를 이미지에서 샘플링 (ITU-R BT.709)
    float[] SampleLuminances()
    {
        float[] result = new float[gridSize * gridSize];

        if (sourceImage == null)
        {
            for (int i = 0; i < result.Length; i++) result[i] = 0.5f;
            return result;
        }

        int w = sourceImage.width;
        int h = sourceImage.height;

        for (int y = 0; y < gridSize; y++)
        {
            for (int x = 0; x < gridSize; x++)
            {
                int px = Mathf.RoundToInt((float)x / (gridSize - 1) * (w - 1));
                int py = Mathf.RoundToInt((float)y / (gridSize - 1) * (h - 1));
                Color c = sourceImage.GetPixel(px, py);
                result[y * gridSize + x] = 0.2126f * c.r + 0.7152f * c.g + 0.0722f * c.b;
            }
        }

        return result;
    }

    // luminance 배열을 0~1로 정규화
    void NormalizeLuminances(float[] src, out float[] dst)
    {
        dst = new float[src.Length];
        float minL = float.MaxValue, maxL = float.MinValue;
        foreach (float l in src) { minL = Mathf.Min(minL, l); maxL = Mathf.Max(maxL, l); }
        float range = Mathf.Max(maxL - minL, 0.0001f);
        for (int i = 0; i < src.Length; i++) dst[i] = (src[i] - minL) / range;
    }

    // 그리드 좌표에 대응하는 이미지 픽셀 색상 반환
    Color SampleColor(int gx, int gy)
    {
        if (sourceImage == null) return Color.white;
        int px = Mathf.RoundToInt((float)gx / (gridSize - 1) * (sourceImage.width  - 1));
        int py = Mathf.RoundToInt((float)gy / (gridSize - 1) * (sourceImage.height - 1));
        return sourceImage.GetPixel(px, py);
    }

    // =========================================================
    RenderPipeline DetectPipeline()
    {
        var rp = UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline;
        if (rp == null) return RenderPipeline.BuiltIn;
        string name = rp.GetType().Name;
        if (name.Contains("Universal")) return RenderPipeline.URP;
        if (name.Contains("HighDefinition") || name.Contains("HDRP")) return RenderPipeline.HDRP;
        return RenderPipeline.BuiltIn;
    }

    string GetColorPropertyName() => _pipeline switch
    {
        RenderPipeline.URP  => "_BaseColor",
        RenderPipeline.HDRP => "_BaseColor",
        _                   => "_Color"
    };

    bool StructureParamsChanged() =>
        _cachedGridSize    != gridSize      ||
        _cachedImage       != sourceImage   ||
        !Mathf.Approximately(_cachedSpacing,     spacing)     ||
        !Mathf.Approximately(_cachedPlateSize,   plateSize)   ||
        !Mathf.Approximately(_cachedMaxAngle,    maxAngleDeg) ||
        !Mathf.Approximately(_cachedDelaySpread, delaySpread) ||
        _cachedSeed        != randomSeed;

    void CacheStructureParams()
    {
        _cachedGridSize    = gridSize;
        _cachedSpacing     = spacing;
        _cachedPlateSize   = plateSize;
        _cachedMaxAngle    = maxAngleDeg;
        _cachedDelaySpread = delaySpread;
        _cachedSeed        = randomSeed;
        _cachedImage       = sourceImage;
    }

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