Custom GPU-Driven rendering in Unity

// Executed at the beginning of the CPU-side of the rendering
private void RenderPipelineManager_beginContextRendering(ScriptableRenderContext context, List<Camera> cameras)
{
	foreach (var camera in cameras)
	{
		// Paint only from the game camera - LMB input is player-driven
		if (camera.cameraType == CameraType.Game)
			PaintTexture(context, camera);

		// Display the ground and instances in game and scene view
		if (camera.cameraType == CameraType.SceneView || camera.cameraType == CameraType.Game)
		{
			// Draw the paint texture on the ground plane mesh
			RenderPlaneIntoCamera(context, camera);

			// Generate, cull, and draw all instances for this camera
			RenderInstancesIntoCamera(context, camera

// Allocate HDR paint texture - R channel drives spawn density later
paintTexture = new RenderTexture(
	paintTextureResolution.x, paintTextureResolution.y,
	GraphicsFormat.R16G16B16A16_UNorm, GraphicsFormat.None, 0);
paintTexture.Create();

// Start with empty canvas so old paint does not leak between play sessions
var clearCmd = new CommandBuffer();
clearCmd.SetRenderTarget(paintTexture.colorBuffer, 0);
clearCmd.ClearRenderTarget(false, true, Color.black);
Graphics.ExecuteCommandBuffer(clearCmd);
clearCmd.Dispose

private void RenderPlaneIntoCamera(ScriptableRenderContext context, Camera camera)
{
	// Skip when scene is not wired yet
	if (planeMaterial == null || planeMesh == null)
		return;

	// Bind runtime paint texture - cannot assign it on the material asset
	planePropertyBlock.SetTexture(Uniforms._MainTex, paintTexture, RenderTextureSubElement.Color);

	RenderParams renderParams = new RenderParams(planeMaterial);
	renderParams.camera = camera;
	renderParams.matProps = planePropertyBlock;

	// Draw the ground plane into the active camera
	Graphics.RenderMesh(renderParams, planeMesh, 0, transform.localToWorldMatrix

half4 frag(Varyings IN) : SV_Target
{
	// Sample paint RT and boost contrast so faint strokes stay visible
	return pow(SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv), 2.0

private void PaintTexture(ScriptableRenderContext context, Camera camera)
{
	// Ignore when no mouse is used
	if (Mouse.current == null || !Mouse.current.leftButton.isPressed)
		return;

	// Create a ray from the camera towards the scene, based on where the mouse is
	Ray ray = camera.ScreenPointToRay(Mouse.current.position.ReadValue());
	Plane yPlane = new Plane(Vector3.up, 0.0f);

	// Ignore painting when the ray didn't hit the Y=0 plane
	if (!yPlane.Raycast(ray, out float entryDistance))
		return;

	// Reuse a pooled command buffer for the RT draw
	CommandBuffer cmd = CommandBufferPool.Get(nameof(GPUDrivenInstanceRenderer) + "_Paint");

	// Convert ray hit into world-space brush center
	float3 hitPositionWS = ray.origin + ray.direction * entryDistance;

	// Pass brush parameters to the paint shader
	paintPropertyBlock.SetVector(Uniforms._HitPositionWS, float4(hitPositionWS, 1.0f));
	paintPropertyBlock.SetVector(Uniforms._PaintColor, paintColor);
	paintPropertyBlock.SetFloat(Uniforms._HitRadiusWS, paintRadiusWS);
	paintPropertyBlock.SetFloat(Uniforms._HitAlphaWS,
		1f - Mathf.Exp(-pow(paintRate, 2.0f) * Time.deltaTime));

	// Draw into paint RT and keep previous strokes
	cmd.SetRenderTarget(paintTexture.colorBuffer,
		RenderBufferLoadAction.Load, RenderBufferStoreAction.Store);
	cmd.DrawMesh(planeMesh, transform.localToWorldMatrix, paintMaterial, 0, 0, paintPropertyBlock);

	// And always ensure to execute the command buffer!
	context.ExecuteCommandBuffer(cmd);
	CommandBufferPool.Release(cmd

Varyings vert(Attributes IN)
{
	Varyings OUT;

	// Render in UV space - map mesh UV directly to clip space, not through the camera
	OUT.positionHCS = float4(IN.uv.xy * 2.0 - 1.0, 0.0, 1.0);

	// Flip Y on D3D so RT rows match mesh UV layout
	#if UNITY_UV_STARTS_AT_TOP
		OUT.positionHCS.y *= -1.0;
	#endif

	// Keep world position for distance-based brush falloff in the fragment shader
	OUT.positionWS = TransformObjectToWorld(IN.positionOS.xyz);
	return OUT;
}

half4 frag(Varyings IN) : SV_Target
{
	// Circular brush around the hit point in world space
	float distanceToHit = distance(_HitPositionWS.xyz, IN.positionWS.xyz);
	float paintAlphaMask = smoothstep(_HitRadiusWS, 0.0, distanceToHit);
	paintAlphaMask *= _HitAlphaWS;

	// Alpha-blend paint color into the RT
	float4 paintColor = _PaintColor;
	paintColor.a *= paintAlphaMask;
	return paintColor

// GPU-side record for one spawned instance
[StructLayout(LayoutKind.Sequential)]
public struct InstanceData
{
	public float4x4 modelMatrix;
	public float4 color

// Append buffer - GPU grows the instance list with Append() each frame
instanceBuffer = new GraphicsBuffer(
	Target.Append | Target.Structured | Target.CopySource,
	maxInstanceCount, UnsafeUtility.SizeOf<InstanceData

// Reset append counter - start fresh instance list every frame
cmd.SetBufferCounterValue(instanceBuffer, 0u);

// Bind paint texture as generation input
cmd.SetComputeTextureParam(generateInstanceCompute, 0, Uniforms._PaintTexture, paintTexture.colorBuffer);

// Bind append buffer that will receive InstanceData records
cmd.SetComputeBufferParam(generateInstanceCompute, 0, Uniforms._InstanceBuffer, instanceBuffer);

// Pass plane transform so texel UV maps to world position
cmd.SetComputeMatrixParam(generateInstanceCompute, Uniforms._PlaneLocalToWorldMatrix, transform.localToWorldMatrix);
cmd.SetComputeVectorParam(generateInstanceCompute, Uniforms._InstanceGenerationResolution,
	new float4(instanceGenerationResolution, 0, 0));

// Dispatch one thread group per 8x8 tile in the generation grid
uint3 threadGroupSize;
generateInstanceCompute.GetKernelThreadGroupSizes(0, out threadGroupSize.x, out threadGroupSize.y, out threadGroupSize.z);
int3 groupCount = ((int3(instanceGenerationResolution.xy, 1) - 1) / (int3)threadGroupSize) + 1;
cmd.DispatchCompute(generateInstanceCompute, 0, groupCount.x, groupCount.y, groupCount.z

// Defining instance data using the same format
struct InstanceData
{
	float4x4 modelMatrix;
	float4 color;
};

// Buffer to append instances to
AppendStructuredBuffer<InstanceData> _InstanceBuffer;

// Other data used for instancing
Texture2D _PaintTexture; // Painted texture
SamplerState linearClampSampler; // And its sampler
float4 _InstanceGenerationResolution; // Resolution of the texture
float4x4 _PlaneLocalToWorldMatrix; // Matrix used to paint the texture
float4x4 _PlaneWorldToLocalMatrix; // Matrix used to paint the texture

[numthreads(8,8,1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
	// One thread per texel in the generation grid
	int2 pixelCoord = (int2)id.xy;
	int2 generationResolution = (int2)round(_InstanceGenerationResolution.xy);

	// Ignore out-of-bounds threads from partial dispatch groups
	if (any(pixelCoord < int2(0, 0)) || any(pixelCoord >= generationResolution))
		return;

	// Texel center UV
	float2 uv = (pixelCoord + 0.5) / (float2)generationResolution;

	// Get some random values per instance by hashing the ID of this compute thread
	// You should use some deterministic hash function here, possibly sampling just some predefined kernel
	float2 hashPerInstance = FastHashInt2ToFloat2(id.xy * 7131);
	float2 hashPerInstance2 = FastHashInt2ToFloat2(id.xy * 9315);

	// Sample with flipped V - paint pass wrote with UNITY_UV_STARTS_AT_TOP
	float4 paintTextureValue = _PaintTexture.SampleLevel(linearClampSampler, 1.0 - uv, 0);

	// Stochastic discard - brighter R channel means higher spawn chance
	if (hashPerInstance2.x > paintTextureValue.r)
		return;

	// Map UV to plane position in object space
	float3 positionOS = float3(uv.x * 2.0 - 1.0, 0.0, uv.y * 2.0 - 1.0);
	positionOS *= 5.0f; // I used a mesh that was 10 units in size, so I need to rescale the position accordingly, so it is from -5 to 5.

	// Then calculate it in world space
	float4 positionWS = mul(_PlaneLocalToWorldMatrix, float4(positionOS.xyz, 1.0));
	positionWS.xz += (hashPerInstance2.xy - 0.5) * 0.1;

	// Build TRS matrix from random Y rotation and variable scale
	float angle = hashPerInstance.x * 6.28;
	float4 topDirectionWS = float4(0, 1, 0, 0);
	float4 rightDirectionWS = float4(1, 0, 0, 0);
	rightDirectionWS.xz = mul(float2x2(cos(angle), sin(angle), -sin(angle), cos(angle)), rightDirectionWS.xz);
	float4 forwardDirection = float4(-rightDirectionWS.z, 0.0, rightDirectionWS.x, 0.0);
	float scale = 0.1 * lerp(0.4, 1.0, hashPerInstance2.x);
	float4x4 modelMatrix = transpose(float4x4(
		rightDirectionWS * scale,
		topDirectionWS * scale,
		forwardDirection * scale,
		float4(positionWS.xyz, 1.0)));

	// Append instance record to the GPU buffer
	InstanceData instanceData;
	instanceData.modelMatrix = modelMatrix;
	instanceData.color = lerp(float4(0.4, 0.6, 0.2, 1.0), float4(0.9, 0.7, 0.0, 1.0), hashPerInstance2.y);
	_InstanceBuffer.Append(instanceData

public struct IndirectDrawIndexedArgs
{
	public uint indexCountPerInstance { get; set; }
	public uint instanceCount { get; set; }
	public uint startIndex { get; set; }
	public uint baseVertexIndex { get; set; }
	public uint startInstance { get; set

// Indirect draw args - instanceCount gets overwritten by CopyCounterValue each frame
drawArgsBuffer = new GraphicsBuffer(
	Target.IndirectArguments | Target.CopyDestination,
	1, IndirectDrawIndexedArgs.size

...
cmd.DispatchCompute(generateInstanceCompute, 0, groupCount.x, groupCount.y, groupCount.z);

// Fill static indexed draw args buffer with index count from the mesh
cmd.SetBufferData(drawArgsBuffer, new IndirectDrawIndexedArgs[] { new IndirectDrawIndexedArgs()
{
	indexCountPerInstance = instanceMesh.GetIndexCount(0),
	instanceCount = 0,
	startIndex = 0,
	baseVertexIndex = 0,
	startInstance = 0
}});

// Instruct GPU to copy counter from instanceBuffer into 2nd int of drawArgsBuffer, which is instanceCount
cmd.CopyCounterValue(instanceBuffer, drawArgsBuffer, sizeof(int));

// Don't forget to execute
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);

// Then I bind the instance buffer for the draw shader and render it indirectly
instancedRenderPropertyBlock.SetBuffer(Uniforms._InstanceBuffer, instanceBuffer);

RenderParams renderParams = new RenderParams(instanceMaterial);
renderParams.matProps = instancedRenderPropertyBlock;
renderParams.worldBounds = new Bounds(transform.position,
	Vector3.Scale(new Vector3(10f, 1f, 10f), transform.lossyScale));
renderParams.camera = camera;

// Here, instead of providing classic draw call with index and instance count arguments,
// I provide the GPU buffer that will contain the instance count and triangle count at the moment of draw call invocation.
Graphics.RenderMeshIndirect(renderParams, instanceMesh, drawArgsBuffer

struct Attributes
{
	float4 positionOS : POSITION;
	float4 color : COLOR0;
	float4 normalOS : NORMAL;

	// Fetch instance ID in the vertex shader
	uint instanceID : SV_InstanceID;
};

// Same instance data format as in the compute shader and C# code.
struct InstanceData
{
	float4x4 modelMatrix;
	float4 color;
};

// Declare _InstanceBuffer that contains all the GPU-generated instances
StructuredBuffer<InstanceData> _InstanceBuffer;

// Vertex shader
Varyings vert(Attributes IN)
{
	Varyings OUT;

	// Get instance data
	InstanceData instanceData = _InstanceBuffer[IN.instanceID];

	// Calculate world space position for the instance by multiplying model matrix of the instance with the vertex position
	float4 positionWS = mul(instanceData.modelMatrix, float4(IN.positionOS.xyz, 1.0));
	float3 normalWS = normalize(mul(instanceData.modelMatrix, float4(IN.normalOS.xyz, 0.0)).xyz); // The same with normal, here I assumed uniform scaling

	// Now the usual part of the shader - clip space and other attributes
	OUT.positionHCS = TransformWorldToHClip(positionWS.xyz);
	OUT.color = IN.color * instanceData.color;
	OUT.normalWS = normalWS;
	return OUT;
}

half4 frag(Varyings IN) : SV_Target
{
	// Color with a simple shading
	half4 color = IN.color
		* saturate(dot(normalize(float3(1.0, 1.0, 1.0)), IN.normalWS) * 0.5 + 0.5);
	return color

// Append buffer for visible instance indices - same max count as instanceBuffer
cullingBuffer = new GraphicsBuffer(
	Target.Append | Target.Structured,
	maxInstanceCount, sizeof

// Again - the same data as in all other shaders
struct InstanceData
{
	float4x4 modelMatrix;
	float4 color;
};

// Instance buffer, as input
StructuredBuffer<InstanceData> _InstanceBuffer;

// Buffer that contains only instance count from the _InstanceBuffer in the first element.
// There is no way to read the counter value in the shader, so I will need to copy that into a separate buffer.
StructuredBuffer<uint4> _InstanceBufferCount;

// This is the compute shader output.
AppendStructuredBuffer<uint> _CullingBuffer;

// Constant buffer that contains all frustum planes.
cbuffer C_CameraFrustumPlanes
{
	float4 _FrustumPlane0;
	float4 _FrustumPlane1;
	float4 _FrustumPlane2;
	float4 _FrustumPlane3;
	float4 _FrustumPlane4;
	float4 _FrustumPlane5;
}

// Function to test if the sphere is inside the plane
bool TestPlane(float3 positionWS, float radius, float4 plane)
{
	// Plane encoding: xyz - normal vector, w - offset
	return dot(plane.xyz, positionWS) + plane.w >= -radius;
}

[numthreads(16,1,1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
	// One thread per generated instance
	int instanceBufferCount = (int)_InstanceBufferCount[0].x;
	if ((int)id.x >= instanceBufferCount)
		return;

	// Fetch instance data
	InstanceData instanceData = _InstanceBuffer[id.x];
	float4x4 modelMatrix = transpose(instanceData.modelMatrix); // Transpose to make [index] fetch the column instead of the row

	// Bounding sphere from matrix axes
	float radius = 0.0f;
	radius = max(radius, length(modelMatrix[0].xyz)); // First column
	radius = max(radius, length(modelMatrix[1].xyz)); // Second column
	radius = max(radius, length(modelMatrix[2].xyz)); // Third column
	radius *= 5.0; // mesh extent padding, this hardcoded value should be provided from a mesh bounding box
	float3 positionWS = modelMatrix[3].xyz;

	// Cull when sphere is outside any frustum plane
	if (!TestPlane(positionWS, radius, _FrustumPlane0)) return;
	if (!TestPlane(positionWS, radius, _FrustumPlane1)) return;
	if (!TestPlane(positionWS, radius, _FrustumPlane2)) return;
	if (!TestPlane(positionWS, radius, _FrustumPlane3)) return;
	if (!TestPlane(positionWS, radius, _FrustumPlane4)) return;
	if (!TestPlane(positionWS, radius, _FrustumPlane5)) return;

	// Append instance index to the culling buffer - not a full InstanceData copy. Writing a single uint value is much faster than writing whole instance data.
	_CullingBuffer.Append(id.x

// Normal dispatch - CPU provides group counts directly
cmd.DispatchCompute(instanceCullingCompute, 0, groupCountX, groupCountY, groupCountZ);

// Indirect dispatch - GPU provides group counts from a buffer, where the buffer element contains three consecutive uints defining the group count.
cmd.DispatchCompute(instanceCullingCompute, 0, indirectComputeArgsBuffer, 0

// Thread group size of the culling compute shader
cbuffer C_GroupSizes
{
	uint _GroupSizeX;
	uint _GroupSizeY;
	uint _GroupSizeZ;
	uint _GroupSizesPadding;
}

// Target thread count
StructuredBuffer<uint4> _TargetThreadCount;

// Indirect arguments for the culling compute shader
RWStructuredBuffer<uint4> _IndirectComputeArgs;

[numthreads(1,1,1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
	// Read cull kernel thread group size and total instance count
	uint3 groupSize = uint3(_GroupSizeX, _GroupSizeY, _GroupSizeZ);
	uint3 targetThreadCount = _TargetThreadCount[0].xyz;

	// Compute how many thread groups the cull dispatch needs
	// Ceiling division - needs to be safe when targetThreadCount is 0, otherwise it could overflow to max uint value which could crash the GPU
	uint3 groupCount = (targetThreadCount + groupSize - 1u) / groupSize;

	// Write indirect dispatch args for the cull compute shader
	_IndirectComputeArgs[0] = uint4(groupCount, 0

targetThreadCountBuffer = new GraphicsBuffer(
	Target.Structured | Target.CopyDestination | Target.Raw, 1, UnsafeUtility.SizeOf<uint4>());
groupSizeCBuffer = new GraphicsBuffer(Target.Constant, 1, UnsafeUtility.SizeOf<uint4>());
indirectComputeArgsBuffer = new GraphicsBuffer(
	Target.Structured | Target.IndirectArguments, 1, UnsafeUtility.SizeOf<uint4

// Copy generated instance count into the target thread count buffer
cmd.SetBufferData(targetThreadCountCBuffer, new uint4[] { uint4(1, 1, 1, 1) });
cmd.CopyCounterValue(instanceBuffer, targetThreadCountCBuffer, 0);

// Pass cull kernel thread group size to the args prep shader.
// Group sizes are in a constant buffer.
instanceCullingCompute.GetKernelThreadGroupSizes(0, out threadGroupSize.x, out threadGroupSize.y, out threadGroupSize.z);
cmd.SetBufferData(groupSizeCBuffer, new uint4[] { uint4(threadGroupSize.x, threadGroupSize.y, threadGroupSize.z, 0) });
cmd.SetComputeConstantBufferParam(prepareIndirectComputeArgsCompute, Uniforms.C_GroupSizes,
	groupSizeCBuffer, 0, groupSizeCBuffer.stride);

// Bind input count and output indirect args buffer
cmd.SetComputeBufferParam(prepareIndirectComputeArgsCompute, 0, Uniforms._TargetThreadCount, targetThreadCountCBuffer);
cmd.SetComputeBufferParam(prepareIndirectComputeArgsCompute, 0, Uniforms._IndirectComputeArgs, indirectComputeArgsBuffer);

// Single-thread dispatch - GPU computes cull group count
cmd.DispatchCompute(prepareIndirectComputeArgsCompute, 0, 1, 1, 1

// Upload camera frustum planes for the sphere test
var frustumPlanes = new CameraFrustumPlanes(GeometryUtility.CalculateFrustumPlanes(camera));
cmd.SetBufferData(cameraFrustumPlanesCBuffer, new CameraFrustumPlanes[] { frustumPlanes });
cmd.SetComputeConstantBufferParam(instanceCullingCompute, Uniforms.C_CameraFrustumPlanes,
	cameraFrustumPlanesCBuffer, 0, cameraFrustumPlanesCBuffer.stride);

// Tell the cull shader how many instances were generated
cmd.CopyCounterValue(instanceBuffer, instanceBufferCountCBuffer, 0);
cmd.SetComputeBufferParam(instanceCullingCompute, 0, Uniforms._InstanceBufferCount, instanceBufferCountCBuffer);
cmd.SetComputeBufferParam(instanceCullingCompute, 0, Uniforms._InstanceBuffer, instanceBuffer);

// Reset cull append buffer and bind it as output
cmd.SetBufferCounterValue(cullingBuffer, 0);
cmd.SetComputeBufferParam(instanceCullingCompute, 0, Uniforms._CullingBuffer, cullingBuffer);

// Indirect dispatch - group count comes from prepare-args pass above
cmd.DispatchCompute(instanceCullingCompute, 0, indirectComputeArgsBuffer, 0

// Fill static draw args - instanceCount will be overwritten by the GPU counter
cmd.SetBufferData(drawArgsBuffer, new IndirectDrawIndexedArgs[] { new IndirectDrawIndexedArgs()
{
	indexCountPerInstance = instanceMesh.GetIndexCount(0),
	instanceCount = 0,
	startIndex = 0,
	baseVertexIndex = 0,
	startInstance = 0
}});

// Copy visible instance count from cull append buffer into draw args
// This line replaces the CopyCounterValue(instanceBuffer, ...) from the previous implementation
cmd.CopyCounterValue(cullingBuffer, drawArgsBuffer, sizeof

// Previous way of accessing the instance data
InstanceData instanceData = _InstanceBuffer[IN.instanceID

// Updated way of accessing the instance data
InstanceData instanceData = _InstanceBuffer[_CullingBuffer[IN.instanceID

StructuredBuffer<InstanceData> _InstanceBuffer;
StructuredBuffer<uint> _CullingBuffer; // Added the _CullingBuffer


Varyings vert(Attributes IN)
{
	Varyings OUT;

	// Remap instance ID through culled index list
	InstanceData instanceData = _InstanceBuffer[_CullingBuffer[IN.instanceID]];

	// The rest of the shader stays the same

// Bind instance data and culled index buffer to the draw shader
instancedRenderPropertyBlock.SetBuffer(Uniforms._InstanceBuffer, instanceBuffer);
instancedRenderPropertyBlock.SetBuffer(Uniforms._CullingBuffer, cullingBuffer

// Profiler markers for the three main CPU passes
private static class Markers
{
	public static readonly ProfilerMarker GPUDrivenInstancedRendering = new ProfilerMarker(nameof(GPUDrivenInstancedRendering));
	public static readonly ProfilerMarker PaintTexture = new ProfilerMarker(nameof(PaintTexture));
	public static readonly ProfilerMarker RenderPlane = new ProfilerMarker(nameof(RenderPlane));
	public static readonly ProfilerMarker RenderInstances = new ProfilerMarker(nameof(RenderInstances