Compute Shader

#pragma kernel CSMain

RWTexture2D<float4> Result;

[numthreads(8, 8, 1)]
void CSMain(uint3 id : SV_DispatchThreadID)
{
    // id.xy 直接映射到纹理像素坐标
    float2 uv = id.xy / float2(1024.0, 1024.0);
    Result[id.xy] = float4(uv, 0.0, 1.0);
}

// 创建：指定元素数量和每个元素的字节大小
// sizeof(float3) = 12 bytes
ComputeBuffer buffer = new ComputeBuffer(count, 12);

// 上传数据 CPU → GPU
buffer.SetData(myArray);

// 绑定到 Compute Shader
computeShader.SetBuffer(kernelIndex, "particleBuffer", buffer);

// 绑定到普通 Shader（只读，作为 StructuredBuffer）
material.SetBuffer("particleBuffer", buffer);

// 读回数据 GPU → CPU（同步，会造成 GPU stall！）
buffer.GetData(myArray);

// 释放（必须手动释放，否则内存泄漏）
buffer.Release();

// 默认结构化 Buffer
new ComputeBuffer(count, stride, ComputeBufferType.Default);

// Append/Consume 类型（动态列表）
new ComputeBuffer(count, stride, ComputeBufferType.Append);

// Indirect Dispatch 参数 Buffer（4个 uint）
new ComputeBuffer(1, 16, ComputeBufferType.IndirectArguments);

// 原子计数器
new ComputeBuffer(1, sizeof(uint), ComputeBufferType.Counter);

// 复制 Append Buffer 的计数值到另一个 Buffer（用于 Indirect）
ComputeBuffer.CopyCount(appendBuffer, argsBuffer, dstOffsetBytes);

RenderTexture rt = new RenderTexture(width, height, 0, RenderTextureFormat.ARGBFloat);
rt.enableRandomWrite = true;   // ← 关键：开启 UAV 绑定
rt.Create();

// 绑定到 Compute Shader
computeShader.SetTexture(kernel, "Result", rt);

// 绑定到 Material（直接用于渲染）
material.SetTexture("_MainTex", rt);

#pragma kernel ReduceSum

#define GROUP_SIZE 64

RWStructuredBuffer<float> Input;
RWStructuredBuffer<float> Output;

groupshared float sharedData[GROUP_SIZE];

[numthreads(GROUP_SIZE, 1, 1)]
void ReduceSum(uint3 id    : SV_DispatchThreadID,
               uint  lid   : SV_GroupIndex,
               uint3 gid   : SV_GroupID)
{
    // 第一步：每个线程将数据载入共享内存
    sharedData[lid] = Input[id.x];

    // ★ 等待所有线程完成写入
    GroupMemoryBarrierWithGroupSync();

    // 第二步：二分规约
    [unroll]
    for (uint stride = GROUP_SIZE / 2; stride > 0; stride >>= 1)
    {
        if (lid < stride)
            sharedData[lid] += sharedData[lid + stride];

        // ★ 每轮规约后必须同步
        GroupMemoryBarrierWithGroupSync();
    }

    // 仅 lid==0 的线程写出结果
    if (lid == 0)
        Output[gid.x] = sharedData[0];
}

RWStructuredBuffer<uint> counter;
RWStructuredBuffer<uint> histogram;

[numthreads(64, 1, 1)]
void CSMain(uint3 id : SV_DispatchThreadID)
{
    // 原子加法（返回操作前的旧值）
    uint oldVal;
    InterlockedAdd(counter[0], 1, oldVal);

    // 其他原子操作
    InterlockedMin(histogram[0], id.x);        // 原子取最小
    InterlockedMax(histogram[1], id.x);        // 原子取最大
    InterlockedAnd(histogram[2], 0xFF);        // 原子与
    InterlockedOr(histogram[3],  0x01);        // 原子或
    InterlockedXor(histogram[4], 0x01);        // 原子异或
    InterlockedExchange(counter[0], 0, oldVal); // 原子交换（置0并返回旧值）
    
    // 比较并交换（CAS）
    uint compareVal = 0, newVal = 1;
    InterlockedCompareExchange(counter[0], compareVal, newVal, oldVal);
}

using UnityEngine;
using UnityEngine.Rendering;
using Unity.Collections;

public class AsyncReadbackExample : MonoBehaviour
{
    public ComputeShader cs;
    private ComputeBuffer buffer;
    private AsyncGPUReadbackRequest request;
    private bool requestPending = false;

    void Start()
    {
        // 检查平台支持（OpenGL 不支持）
        if (!SystemInfo.supportsAsyncGPUReadback) return;

        buffer = new ComputeBuffer(1024, sizeof(float) * 3);
        cs.SetBuffer(0, "particleBuffer", buffer);

        // 发起第一次异步请求
        RequestReadback();
    }

    void RequestReadback()
    {
        // 方式一：直接回调
        AsyncGPUReadback.Request(buffer, OnReadbackComplete);

        // 方式二：手动检查（见 Update）
        request = AsyncGPUReadback.Request(buffer);
        requestPending = true;
    }

    void OnReadbackComplete(AsyncGPUReadbackRequest req)
    {
        if (req.hasError) return;
        NativeArray<Vector3> data = req.GetData<Vector3>();
        // 使用 data...
    }

    void Update()
    {
        // Dispatch 计算
        cs.Dispatch(0, 32, 1, 1);

        // 检查异步请求是否完成
        if (requestPending && request.done)
        {
            if (!request.hasError)
            {
                var data = request.GetData<Vector3>();
                // 处理数据...
            }
            RequestReadback(); // 再次请求
            requestPending = false;
        }
    }

    void OnDestroy() => buffer?.Release();
}

void Start()
{
    // 检测 Compute Shader 支持（OpenGL ES 3.1+ / Metal / Vulkan）
    if (!SystemInfo.supportsComputeShaders)
    {
        Debug.LogWarning("当前平台不支持 Compute Shader，切换到降级路径");
        FallbackToCPU();
        return;
    }

    // 检测异步回读支持（OpenGL 系列不支持）
    if (!SystemInfo.supportsAsyncGPUReadback)
    {
        Debug.LogWarning("不支持 AsyncGPUReadback，使用同步 GetData");
        useSyncReadback = true;
    }

    // 检测 Compute Shader Model（普通 Shader 内使用 CS 资源需要 SM 4.5）
    // #pragma target 4.5
    
    // 检测最大线程组尺寸
    int maxThreadGroupSize = SystemInfo.maxComputeWorkGroupSize;
    
    // 获取各维度最大值
    int maxX = SystemInfo.maxComputeWorkGroupSizeX; // 通常 1024
    int maxY = SystemInfo.maxComputeWorkGroupSizeY; // 通常 1024
    int maxZ = SystemInfo.maxComputeWorkGroupSizeZ; // 通常 64
    
    Debug.Log($"Max WorkGroup: ({maxX}, {maxY}, {maxZ})");
}

// 从 Kernel 获取声明的 numthreads
uint threadX, threadY, threadZ;
shader.GetKernelThreadGroupSizes(kernel, out threadX, out threadY, out threadZ);

// 计算覆盖全部元素所需的线程组数（向上取整）
int groupsX = Mathf.CeilToInt((float)dataCount / threadX);

shader.Dispatch(kernel, groupsX, 1, 1);

RWStructuredBuffer<float4> Output;
uint _DataCount;

[numthreads(64, 1, 1)]
void CSMain(uint3 id : SV_DispatchThreadID)
{
    // 关键：线程数可能超过实际数据量
    if (id.x >= _DataCount) return;

    Output[id.x] = float4(id.x, 0, 0, 1);
}

using UnityEngine;
using UnityEngine.Rendering;

public class ComputeViaCommandBuffer : MonoBehaviour
{
    public ComputeShader cs;
    private CommandBuffer cmd;

    void OnEnable()
    {
        cmd = new CommandBuffer { name = "My Compute Pass" };
        Camera.main.AddCommandBuffer(CameraEvent.BeforeForwardOpaque, cmd);
    }

    void Update()
    {
        cmd.Clear();

        // 设置参数
        cmd.SetComputeIntParam(cs, "_FrameCount", Time.frameCount);

        // 录入 Dispatch（不立即执行，等渲染线程调度）
        int kernel = cs.FindKernel("CSMain");
        cmd.DispatchCompute(cs, kernel, 128, 1, 1);
    }

    void OnDisable()
    {
        Camera.main.RemoveCommandBuffer(CameraEvent.BeforeForwardOpaque, cmd);
        cmd.Dispose();
    }
}

// ── 初始化（只做一次）────────────────────────────────────
// 所有物体数据上传一次
allObjectsBuffer.SetData(allObjectData);

// AppendBuffer：存储通过剔除的物体（每帧重置计数）
AppendStructuredBuffer visibleBuffer  // type: Append
visibleBuffer.SetCounterValue(0);

// ArgsBuffer：4×uint：[instanceCount, 1, 1, 0]（Dispatch 参数 / Draw 参数）
ComputeBuffer argsBuffer = new ComputeBuffer(4, 4, ComputeBufferType.IndirectArguments);

// ── 每帧执行 ──────────────────────────────────────────────

// 1. 重置 Append 计数
visibleBuffer.SetCounterValue(0);

// 2. Culling Pass
cullCS.SetBuffer(kernelCull, "_AllObjects",  allObjectsBuffer);
cullCS.SetBuffer(kernelCull, "_VisibleObjects", visibleBuffer);
cullCS.Dispatch(kernelCull, Mathf.CeilToInt(totalCount / 64f), 1, 1);

// 3. 将可见数量复制到 ArgsBuffer（GPU 写 → GPU 读，不回到 CPU）
ComputeBuffer.CopyCount(visibleBuffer, argsBuffer, 0);

// 4. Indirect Dispatch（仅对可见物体执行后续 Pass）
processCS.SetBuffer(kernelProcess, "_VisibleObjects", visibleBuffer);
processCS.DispatchIndirect(kernelProcess, argsBuffer, 0);

// 5. DrawMeshInstancedIndirect（由 ArgsBuffer 决定实例数）
Graphics.DrawMeshInstancedIndirect(mesh, 0, material,
    new Bounds(Vector3.zero, Vector3.one * 10000),
    argsBuffer, 0);