🫧Art_008 Compute Shader

Compute Shader

Compute Shader로 만든 결과를 오브젝트의 머티리얼에 공급해 시각적 효과를 주는 방식

• 기본적으로 코드 기반(HLSL, .compute 파일)입니다.
• 노드 GUI가 아니라 스레드/커널 단위로 GPU 연산을 직접 작성합니다.
• 파티클 시뮬레이션, 군중 계산, 노이즈 필드, 후처리용 데이터 생성 같은 대량 병렬 연산에 강합니다.
• C# 스크립트에서 ComputeBuffer, Dispatch()로 실행을 제어합니다.

적용 방법

1. GameObject 생성
2. ComputePreview.cs (컨트롤러 역할) 작성한 다음에 GameObject에 부착
3. GameObject의 Inspector에서 참조 설정
   • Compute : NoiseCompute.compute 코드
   • Target Renderer : Scene에 존재하는 오브젝트 선택

코드 개요

• NoiseCompute.compute에서 GPU 연산(노이즈 생성)을 수행
• ComputePreview.cs가 컴퓨트 셰이더를 실행(Dispatch)하고 결과 RenderTexture를 받음
• 그 텍스처를 대상 오브젝트(Renderer)에 연결해 화면에 표시
• [ExecuteAlways]로 에디터에서도 즉시 미리보기 가능
• MaterialPropertyBlock으로 적용해서 머티리얼 에셋 오염/전파 문제 방지

📄NoiseCompute.compute

// 이 파일에서 사용할 커널(진입 함수) 이름 선언
#pragma kernel CSMain

// Compute Shader가 최종 결과를 기록할 출력 텍스처
// RWTexture2D: 읽기/쓰기 가능(여기서는 쓰기 중심)
RWTexture2D<float4> Result;

// C#에서 SetInt/SetFloat로 전달받는 파라미터들
uint _Width;       // 출력 텍스처 가로 해상도
uint _Height;      // 출력 텍스처 세로 해상도
float _TimeValue;  // 시간 값(플레이 모드에서는 Time.time, 에디터는 고정값 가능)
float _Scale;      // 노이즈 확대/축소 정도
float _Speed;      // 시간에 따른 흐름 속도

float4 _ColorA;    // C#에서 전달받는 두 색 (RGB만 사용, A는 무시 가능)
float4 _ColorB;

// 2D 좌표 -> 0~1 랜덤값처럼 보이는 해시 함수
// 완전한 랜덤은 아니고, 좌표 기반 의사난수 생성기
float hash21(float2 p)
{
    p = frac(p * float2(123.34, 456.21));
    p += dot(p, p + 45.32);
    return frac(p.x * p.y);
}

// value noise 스타일의 2D 노이즈 함수
// uv 위치에서 주변 4개 그리드 값(a,b,c,d)을 보간해 부드러운 값 생성
float noise2(float2 uv)
{
    // 현재 uv가 속한 정수 격자 좌표
    float2 i = floor(uv);

    // 격자 내 로컬 좌표(0~1)
    float2 f = frac(uv);

    // 격자 4개 꼭짓점에서 해시값 샘플
    float a = hash21(i);
    float b = hash21(i + float2(1.0, 0.0));
    float c = hash21(i + float2(0.0, 1.0));
    float d = hash21(i + float2(1.0, 1.0));

    // 보간 곡선(부드러운 스텝): f*f*(3-2f)
    float2 u = f * f * (3.0 - 2.0 * f);

    // x방향 보간 후 y방향 보간
    return lerp(lerp(a, b, u.x), lerp(c, d, u.x), u.y);
}

// 스레드 그룹 크기(한 그룹에 8x8 스레드)
// C# Dispatch에서 (ceil(width/8), ceil(height/8), 1)로 맞춰 실행
[numthreads(8, 8, 1)]
void CSMain(uint3 id : SV_DispatchThreadID)
{
    // id.x, id.y가 텍스처 범위를 넘으면 즉시 종료
    // (가장자리 그룹에서 초과 스레드가 생길 수 있어서 필요)
    if (id.x >= _Width || id.y >= _Height) return;

    // 현재 픽셀 id를 0~1 UV로 정규화
    // +0.5는 픽셀 중심 샘플링 느낌을 주기 위한 오프셋
    float2 uv = float2((id.x + 0.5) / (float)_Width, (id.y + 0.5) / (float)_Height);

    // 시간에 따라 x축 방향으로 이동하는 노이즈
    // _Scale: 패턴 크기, _Speed: 움직임 속도
    float n = noise2(uv * _Scale + float2(_TimeValue * _Speed, 0.0));

    // 노이즈 패턴에 쓰이는 두 색을 n으로 보간
    float3 col = lerp(_ColorA.rgb, _ColorB.rgb, n);

    // 결과를 출력 텍스처의 현재 픽셀에 기록
    Result[int2(id.xy)] = float4(col, 1.0);
}

📄ComputePreview.cs

using UnityEngine;

// ================================================================
// ComputePreview
// [ExecuteAlways] 로 에디터/플레이 모드 모두에서 실행됩니다.
// 컴퓨트 셰이더로 프로시저럴 노이즈 텍스처를 생성하고,
// MaterialPropertyBlock을 통해 타겟 렌더러에 실시간 반영합니다.
// ================================================================
[ExecuteAlways]  // 에디터와 플레이 모드 모두에서 실행되도록 설정
public class ComputePreview : MonoBehaviour
{
    // ----------------------------------------------------------------
    // 인스펙터 노출 필드
    // ----------------------------------------------------------------

    [Header("References")]
    [SerializeField] ComputeShader compute;       // 노이즈 생성용 컴퓨트 셰이더
    [SerializeField] Renderer targetRenderer;     // 텍스처를 입힐 대상 렌더러

    [Header("Texture")]
    [SerializeField, Range(32, 2048)] int width  = 512;  // 렌더 텍스처 가로 해상도
    [SerializeField, Range(32, 2048)] int height = 512;  // 렌더 텍스처 세로 해상도

    [Header("Noise Params")]
    [SerializeField, Min(0.01f)] float scale = 8f;  // 노이즈 공간 스케일 (클수록 거친 패턴)
    [SerializeField] float speed = 0.5f;            // 노이즈 시간 진행 속도

    [Header("Gradient Colors")]
    [SerializeField] Color colorA = new Color(0.05f, 0.10f, 0.30f, 1f);  // 노이즈 0 쪽 색
    [SerializeField] Color colorB = new Color(0.90f, 0.40f, 0.20f, 1f);  // 노이즈 1 쪽 색

    [Header("Editor Preview")]
    [SerializeField] bool showInSceneEditor = true;   // 씬 뷰 미리보기 활성 여부
    [SerializeField] float editorPreviewTime = 0f;    // 에디터 모드에서 사용할 가상 시간값

    // ----------------------------------------------------------------
    // 내부 런타임 상태
    // ----------------------------------------------------------------

    RenderTexture rt;           // GPU에 할당된 결과 텍스처
    MaterialPropertyBlock mpb;  // 머티리얼 인스턴스 없이 프로퍼티를 덮어쓰는 블록
    int kernel = -1;            // CSMain 커널 인덱스 (-1 = 아직 탐색 전)
    int prevW  = -1;            // 이전 너비  — 해상도 변경 감지용
    int prevH  = -1;            // 이전 높이  — 해상도 변경 감지용
    bool ready;                 // 렌더링 가능 상태 플래그 (초기화 여부)

    // ----------------------------------------------------------------
    // 셰이더 프로퍼티 ID 캐싱
    // Shader.PropertyToID() 는 매 프레임 호출 시 비용이 있으므로
    // static readonly 로 한 번만 해시화해 재사용합니다.
    // ----------------------------------------------------------------

    static readonly int ID_Result  = Shader.PropertyToID("Result");
    static readonly int ID_Width   = Shader.PropertyToID("_Width");
    static readonly int ID_Height  = Shader.PropertyToID("_Height");
    static readonly int ID_Time    = Shader.PropertyToID("_TimeValue");
    static readonly int ID_Scale   = Shader.PropertyToID("_Scale");
    static readonly int ID_Speed   = Shader.PropertyToID("_Speed");
    static readonly int ID_ColorA  = Shader.PropertyToID("_ColorA");
    static readonly int ID_ColorB  = Shader.PropertyToID("_ColorB");
    static readonly int ID_BaseMap = Shader.PropertyToID("_BaseMap");  // URP / HDRP
    static readonly int ID_MainTex = Shader.PropertyToID("_MainTex");  // Built-in RP

    // 컴퓨트 셰이더의 [numthreads(8, 8, 1)] 과 반드시 일치해야 합니다.
    // 셰이더 numthreads 를 바꾸면 이 값도 함께 수정하세요.
    const int THREAD_GROUP_SIZE = 8;


    // ================================================================
    // Unity 생명주기
    // ================================================================

    void OnEnable()    // 컴포넌트가 활성화될 때 호출
    {
				// 활성화 시 초기화 후 즉시 한 번 렌더링해 빈 화면을 방지합니다.
        EnsureInit();  // 초기화 확인
        RenderNow();   // 즉시 렌더링해서 빈 화면 방지
    }

    void OnDisable()   // 컴포넌트가 비활성화될 때 호출
    {
        // 비활성화 시 렌더러에서 텍스처 참조를 먼저 끊은 뒤 GPU 리소스를 해제합니다.
        // 순서가 반대면 렌더러가 이미 해제된 텍스처를 잠시 참조하게 됩니다.
        ClearPropertyBlockTexture(); // 프로퍼티 블록 텍스쳐 초기화
        ReleaseAll();  // 모든 리소스 해제
    }

    void OnDestroy()
    {
        // OnDisable 이 항상 먼저 호출되지만, 서브클래싱 등 확장을 고려해
        // 명시적으로 한 번 더 정리합니다. ReleaseAll 은 중복 호출에 안전합니다.
        ReleaseAll();
    }

    void OnValidate()  // 인스펙터 값이 변경될 때 호출
    {
        // Range / Min 어트리뷰트가 이미 클램핑을 담당하지만,
        // 코드로 직접 값을 넣는 경우를 대비한 방어 처리입니다.
        width  = Mathf.Max(32, width);     // 너비 최소값 설정
        height = Mathf.Max(32, height);    // 높이 최소값 설정
        scale  = Mathf.Max(0.01f, scale);  // 스케일 최소값 설정

        // OnValidate 는 에디터 직렬화 콜백으로 타이밍이 불안정할 수 있습니다.
        // 컴포넌트가 비활성 상태라면 GPU 작업을 시도하지 않습니다.
        if (!isActiveAndEnabled) return;   // 활성화되지 않았다면 종료

        EnsureInit();  // 초기화 확인
        RenderNow();   // 즉시 렌더링
    }

    void Update()  // 매 프레임 호출
    {
        if (!isActiveAndEnabled) return;   // 활성화되지 않았다면 종료
        if (!EnsureInit()) return;    		 // 초기화 실패 시 종료

        if (Application.isPlaying)
        {
            RenderNow();  // 플레이 모드 — 매 프레임 갱신 (Time.time 기반 애니메이션)
            return;
        }

        // 에디터 모드 — 씬 뷰 미리보기가 켜진 경우에만 렌더링
        if (showInSceneEditor) RenderNow();
    }


    // ================================================================
    // 초기화
    // ================================================================

    // 커널 탐색 → RenderTexture 생성 → MPB 준비를 순서대로 수행합니다.
    // 이미 준비된 상태면 변경된 부분만 재처리합니다.
    // 반환값: 렌더링 가능 여부
    bool EnsureInit()
    {
        if (compute == null || targetRenderer == null)
        {
            ready = false;	// Compute Shader나 렌더러가 없으면 준비 완료 아님
            return false;
        }

        // 커널 인덱스가 아직 없으면 탐색합니다.
        if (kernel < 0)
        {
            if (!compute.HasKernel("CSMain"))
            {
                Debug.LogError("[ComputePreview] 컴퓨트 셰이더에 'CSMain' 커널이 없습니다.", this);
                ready = false; // 커널이 없으면 준비 완료 아님
                return false;
            }
            kernel = compute.FindKernel("CSMain");	// 커널 ID 가져오기
        }

        // 해상도가 바뀌었거나 텍스처가 없으면 재생성합니다.
        if (rt == null || prevW != width || prevH != height)
            CreateRT();  												// 렌더 텍스처 생성 또는 갱신

        if (mpb == null)
            mpb = new MaterialPropertyBlock();  // 렌더 텍스처 생성 또는 갱신

        // rt.IsCreated() 로 GPU 상의 실제 생성 여부를 검증합니다.
        // rt.Create() 가 실패해도 rt != null 이므로 이 체크가 필요합니다.
        ready = rt != null && rt.IsCreated() && kernel >= 0;
        return ready;
    }

    // 현재 해상도 설정으로 RenderTexture 를 새로 생성합니다.
    // enableRandomWrite = true 는 컴퓨트 셰이더의 RWTexture2D 바인딩에 필수입니다.
    void CreateRT()
    {
        ReleaseRT();  // 기존 텍스처가 있으면 먼저 해제

        rt = new RenderTexture(width, height, 0, RenderTextureFormat.ARGB32); // 새로운 렌더 텍스처 생성
        rt.enableRandomWrite = true;							// 랜덤 쓰기 활성화
        rt.wrapMode   = TextureWrapMode.Repeat;		// 텍스처 반복 모드
        rt.filterMode = FilterMode.Bilinear;			// 필터 모드 설정

        if (!rt.Create())		
        {
            // GPU 텍스처 생성 실패 — 해상도가 너무 크거나 VRAM 부족일 수 있습니다.
            Debug.LogError(
                $"[ComputePreview] RenderTexture 생성 실패 ({width}x{height}). " +
                "해상도를 낮추거나 GPU 메모리를 확인하세요.", this);
            DestroyImmediate(rt);
            rt = null;
            return;
        }

        prevW = width;   // 이전 너비 저장
        prevH = height;  // 이전 높이 저장
    }


    // ================================================================
    // 렌더링
    // ================================================================

    // 플레이 모드 → Time.time (실제 경과 시간)
    // 에디터 모드 → editorPreviewTime (인스펙터에서 수동 설정)
    float GetTimeValue()  // 현재 시간 값 가져오기
    {
        return Application.isPlaying ? Time.time : editorPreviewTime;
    }

    // 컴퓨트 셰이더에 파라미터를 전달하고 Dispatch 한 뒤,
    // 결과 텍스처를 MPB 를 통해 렌더러에 반영합니다.
    void RenderNow()
    {
        if (!ready || compute == null || rt == null || kernel < 0) return;

        compute.SetTexture(kernel, ID_Result, rt);
        compute.SetInt   (ID_Width,  width);
        compute.SetInt   (ID_Height, height);
        compute.SetFloat (ID_Time,   GetTimeValue());
        compute.SetFloat (ID_Scale,  scale);
        compute.SetFloat (ID_Speed,  speed);
        compute.SetVector(ID_ColorA, colorA);
        compute.SetVector(ID_ColorB, colorB);

        // 스레드 그룹 수 = 텍스처 크기 / numthreads 크기 (올림)
        // 예: 512 / 8 = 64 그룹 → 64 * 8 = 512 스레드로 전체 픽셀을 커버
        int gx = Mathf.CeilToInt(width  / (float)THREAD_GROUP_SIZE);
        int gy = Mathf.CeilToInt(height / (float)THREAD_GROUP_SIZE);
        compute.Dispatch(kernel, gx, gy, 1);

        ApplyPropertyBlockTexture();
    }


    // ================================================================
    // MaterialPropertyBlock 관리
    // ================================================================

    // 렌더러의 MPB 에 생성된 텍스처를 적용합니다.
    // _BaseMap(URP/HDRP) 과 _MainTex(Built-in RP) 를 모두 설정해
    // 렌더 파이프라인에 관계없이 동작하도록 합니다.
    void ApplyPropertyBlockTexture()
    {
        if (targetRenderer == null || rt == null) return;
        if (mpb == null) mpb = new MaterialPropertyBlock();

        targetRenderer.GetPropertyBlock(mpb);  // 기존 MPB 값을 유지한 채 가져옵니다.
        mpb.SetTexture(ID_BaseMap, rt);
        mpb.SetTexture(ID_MainTex, rt);
        targetRenderer.SetPropertyBlock(mpb);
    }

    // 렌더러에서 텍스처 참조를 제거합니다.
    // SetTexture(..., null) 은 Unity 버전에 따라 경고/예외가 발생할 수 있으므로
    // mpb.Clear() 로 블록 전체를 초기화하는 방식을 사용합니다.
    void ClearPropertyBlockTexture()
    {
        if (targetRenderer == null) return;
        if (mpb == null) mpb = new MaterialPropertyBlock();

        mpb.Clear();
        targetRenderer.SetPropertyBlock(mpb);
    }


    // ================================================================
    // GPU 리소스 해제
    // ================================================================

    // [ExecuteAlways] 환경에서는 Destroy() 대신 DestroyImmediate() 를 사용해야
    // 에디터 모드에서 즉시 해제됩니다. (Destroy 는 플레이 모드에서만 동작)
    void ReleaseRT()
    {
        if (rt == null) return;
        rt.Release();          // GPU 메모리 반환 (텍스쳐 해제)
        DestroyImmediate(rt);  // 렌더 텍스쳐 즉시 삭제
        rt = null;						 // 참조 초기화	
    }

    // 모든 GPU 리소스와 내부 상태를 초기화합니다.
    // kernel 을 -1 로 리셋해 다음 EnsureInit() 호출 시 재탐색하도록 합니다.
    void ReleaseAll()
    {
        ReleaseRT();					 // 렌더 텍스쳐 해제
        kernel = -1;				   // 커널 ID 초기화
        ready  = false;			   // 준비 완료 상태 초기화
    }
}