Implementing mesh dissolve effect from scratch

[StructLayout(LayoutKind.Sequential)]
public struct ParticleData
{
	// Position, velocity, color and size
	public float4 positionWS;
	public float4 velocityWS;
	public float4 color;
	public float size;

	// Defines when the particle is killed (time > lifetime)
	public float lifetime;

	// Time for the particle
	public float time;

	// Random seed for the particle
	public uint seed

#ifndef PARTICLE_DATA_INCLUDED
#define PARTICLE_DATA_INCLUDED

struct ParticleData
{
    float4 positionWS;
    float4 velocityWS;
    float4 color;
    float size;
    float lifetime;
    float time;
	uint seed;
};

#endif

public class GPUParticleSystem : MonoBehaviour
{
	public int maxParticleCount = 1_000_000;

	// Those are the ping-pong buffers that will store the particles
	private GraphicsBuffer particleBufferA = null;
	private GraphicsBuffer particleBufferB = null;

	private void OnEnable()
	{
		// Hook into the rendering
		RenderPipelineManager.beginCameraRendering += RenderPipelineManager_beginCameraRendering;

		// Allocating ping-pong buffers for particles
		particleBufferA = new GraphicsBuffer(Target.Structured | Target.CopySource | Target.Append | Target.Counter, maxParticleCount, UnsafeUtility.SizeOf<ParticleData>());
		particleBufferA.SetCounterValue(0);

		particleBufferB = new GraphicsBuffer(Target.Structured | Target.CopySource | Target.Append | Target.Counter, maxParticleCount, UnsafeUtility.SizeOf<ParticleData>());
		particleBufferB.SetCounterValue(0);
	}

	private void OnDisable()
	{
		// Release all resources allocated in OnEnable
		RenderPipelineManager.beginCameraRendering -= RenderPipelineManager_beginCameraRendering;

		ReleaseBuffer(ref particleBufferA);
		ReleaseBuffer(ref particleBufferB);

		void ReleaseBuffer(ref GraphicsBuffer buffer)
		{
			if (buffer != null)
			{
				buffer.Release();
				buffer = null;
			}
		}
	}

	private void RenderPipelineManager_beginCameraRendering(ScriptableRenderContext context, Camera camera)
	{
		// Render only game view and sceneview
		if (camera.cameraType != CameraType.Game && camera.cameraType != CameraType.SceneView)
			return;

		// Get command buffer
		CommandBuffer cmd = CommandBufferPool.Get(nameof(GPUParticleSystem) + "_" + gameObject.name);

		// Step 1. Append new particles into buffer A
		cmd.SetBufferCounterValue(particleBufferA, 0); // Temporarily clear the particles
		SpawnParticles(cmd, particleBufferA);

		// For now I will skip the steps for particle simulation and buffer swap
		// Because I want to test if the rendering works properly

		// Step 2. Render particles
		RenderParticles(cmd, particleBufferA, camera);

		// Execute command buffer
		context.ExecuteCommandBuffer(cmd);
		CommandBufferPool.Release(cmd);
	}

	private void SpawnParticles(CommandBuffer cmd, GraphicsBuffer particleBufferA)
	{
		// TODO
	}

	private void RenderParticles(CommandBuffer cmd, GraphicsBuffer particleBufferA, Camera camera)
	{
		// TODO

public interface ISpawnGPUParticles
{
	void SpawnParticles(CommandBuffer cmd, GraphicsBuffer appendParticleBuffer

public class GPUParticleSystem : MonoBehaviour
{
	...
	private void SpawnParticles(CommandBuffer cmd, GraphicsBuffer particleBufferA)
	{
		// Get all ISpawnGPUParticles components in child hierarchy
		List<ISpawnGPUParticles> spawners = ListPool<ISpawnGPUParticles>.Get();
		GetComponentsInChildren(false, spawners);

		for (int i = 0; i < spawners.Count; i++)
		{
			// Trigger spawning in each component.
			ISpawnGPUParticles spawner = spawners[i];
			spawner.SpawnParticles(cmd, particleBufferA);
		}

		ListPool<ISpawnGPUParticles>.Release(spawners

// This component implements ISpawnGPUParticles, so it is a spawner
public class SphereParticleSpawner : MonoBehaviour, ISpawnGPUParticles
{
	// Particles to spawn each frame
	[SerializeField] int spawnCount = 100;

	// Compute shader to use
	[SerializeField] private ComputeShader spawnCompute;

	// Used to generate random seed for spawning
	private Unity.Mathematics.Random random;

	private void OnEnable()
	{
		// As usual, I allocate all needed resources in OnEnable
		random = new Unity.Mathematics.Random(768976192u);
	}

	// This method implements particle spawning.
	// It appends new particles into the buffer
	public void SpawnParticles(CommandBuffer cmd, GraphicsBuffer appendParticleBuffer)
	{
		if (spawnCompute == null)
			return;

		// Set compute shader parameters

		// Local to world transform - particles will be spawned in object space and converted to world space
		cmd.SetComputeMatrixParam(spawnCompute, Uniforms._LocalToWorld, transform.localToWorldMatrix);

		// Set spawn count and seed
		cmd.SetComputeIntParam(spawnCompute, Uniforms._SpawnParticleCount, spawnCount);
		cmd.SetComputeIntParam(spawnCompute, Uniforms._SpawnSeed, random.NextInt());

		// Bind the AppendStructuredBuffer with particles to the compute shader
		cmd.SetComputeBufferParam(spawnCompute, 0, Uniforms._Particles, appendParticleBuffer);

		// Dispatch compute shader with the minimum group count that will cover all particles.
		uint3 groupSize;
		spawnCompute.GetKernelThreadGroupSizes(0, out groupSize.x, out groupSize.y, out groupSize.z);
		int3 groupCount = (new int3(spawnCount, 1, 1) + (int3)groupSize - 1) / (int3)groupSize;
		cmd.DispatchCompute(spawnCompute, 0, groupCount.x, groupCount.y, groupCount.z);
	}

	// Gizmos to draw the spawning sphere - useful as an editor feature
	void OnDrawGizmosSelected()
    {
        Gizmos.matrix = transform.localToWorldMatrix;
        Gizmos.color = Color.red;
        Gizmos.DrawWireSphere(Vector3.zero, 1.0f

// Kernel is named SpawnSphereParticles
#pragma kernel SpawnSphereParticles

// To make Nvidia Nsight Graphics able to properly decode all the shader data.
#pragma enable_d3d11_debug_symbols

// Use the ParticleData struct
#include "ParticleData.hlsl"

// Spawner will append new particle instances here
AppendStructuredBuffer<ParticleData> _Particles;

// Properties set from C#
float4x4 _LocalToWorld;
int _SpawnParticleCount;
int _SpawnSeed;

// Returns 0-1 float value from a single uint
float HashUintToFloat01(uint n) {...}

// Returns 0-1 float2 value from a single uint
float2 HashUintToFloat2(uint n) {...}

// Uniform direction on the unit sphere.
float3 RandomUnitDirection(uint seed)
{
	// Formula based on Unity's source code for uniform sphere sampling
	// https://github.com/advancedfx/afx-unity-srp/blob/advancedfx/com.unity.render-pipelines.core/ShaderLibrary/Sampling/Sampling.hlsl
    float2 u = HashUintToFloat2(seed);
    float z = 1.0 - 2.0 * u.x;
    float phi = 6.28318530718 * u.y;
    float r = sqrt(saturate(1.0 - z * z));
    return float3(r * cos(phi), r * sin(phi), z);
}

// Uniform position inside the unit ball (radius 1).
float3 RandomPointInUnitSphere(uint seed)
{
    float radius = pow(HashUintToFloat01(seed + 0xA2C2A892u), 1.0 / 3.0);
    return RandomUnitDirection(seed + 0x7F4A7C15u) * radius;
}

// Returns random color by hashing this seed value
float3 RandomColor(uint seed)
{
    return float3(HashUintToFloat01(seed + 0xBA55C0D3u),
		HashUintToFloat01(seed + 0x27D4EB2Du),
        HashUintToFloat01(seed + 0x165667B1u));
}

[numthreads(16, 1, 1)]
void SpawnSphereParticles(uint3 id : SV_DispatchThreadID)
{
	// Limit the particle spawn to the specified count
    if (id.x >= (uint)_SpawnParticleCount)
        return;

	// Prepare unique seed for each particle
    uint particleSeed = asuint(_SpawnSeed) + id.x * 0x9E3779B9u;

	// Get random position in unit sphere in object space
    float3 positionOS = RandomPointInUnitSphere(particleSeed);

    // Convert position from object space to world space
    float3 positionWS = mul(_LocalToWorld, float4(positionOS, 1.0)).xyz;

	// Create particle struct and fill it with data.
    ParticleData particle;
    particle.positionWS = float4(positionWS, 1.0);
    particle.velocityWS = float4(0.0, 0.0, 0.0, 0.0);
    particle.color = float4(RandomColor(particleSeed + 0x517CC1B7u), 1.0);
    particle.size = 0.01;
    particle.lifetime = lerp(2.0, 8.0, HashUintToFloat01(particleSeed + 0xC2B2AE35u));
    particle.time = 0.0;
    particle.seed = particleSeed;

	// Append the particle to the buffer
    _Particles.Append(particle

public class GPUParticleSystem : MonoBehaviour
{
	...
	// Added mesh and material
	public Mesh mesh;
	public Material material;

	// I added the buffer that will store indirect arguments for the draw calls
	private GraphicsBuffer drawArgsBuffer = null;

	// And I added property block, I will use it to bind the particles buffer to the rendering material
	private MaterialPropertyBlock propertyBlock;

	private void OnEnable()
	{
		...
		// In OnEnable I added the initialization of the drawArgsBuffer and propertyBlock
		drawArgsBuffer = new GraphicsBuffer(Target.IndirectArguments | Target.CopyDestination, 1, IndirectDrawIndexedArgs.size);
        propertyBlock = new MaterialPropertyBlock();
    }

	private void OnDisable()
	{
		...
		// In OnDisable, I release allocated resources
		ReleaseBuffer(ref drawArgsBuffer);

		if (propertyBlock != null)
		{
			propertyBlock.Clear();
			propertyBlock = null;
		}
		...
	}

	// Rendering is implemented in this method
	private void RenderParticles(CommandBuffer cmd, GraphicsBuffer particleBufferA, Camera camera)
	{
		// Don't render without a material or a mesh.
		if (material == null || mesh == null)
            return;

		// Prepare indirect draw arguments in the buffer with correct index count
		var indirectDrawIndexedArgsData = ArrayPool<IndirectDrawIndexedArgs>.Shared.Rent(1);
		indirectDrawIndexedArgsData[0] = new IndirectDrawIndexedArgs()
		{
			indexCountPerInstance = mesh.GetIndexCount(0),
		};
		cmd.SetBufferData(drawArgsBuffer, indirectDrawIndexedArgsData, 0, 0, 1);
		ArrayPool<IndirectDrawIndexedArgs>.Shared.Return(indirectDrawIndexedArgsData);

		// Copy particle buffer counter to the arguments buffer
		cmd.CopyCounterValue(particleBufferA, drawArgsBuffer, sizeof(uint));

		// Bind the particles buffer to the draw call
		propertyBlock.SetBuffer(Uniforms._Particles, particleBufferA);

		// Render the particles into the camera
		RenderParams renderParams = new RenderParams(material);
		renderParams.matProps = propertyBlock;
		renderParams.camera = camera;
		renderParams.worldBounds = new Bounds(Vector3.zero, Vector3.one * 100000.0f); // No culling for now
		Graphics.RenderMeshIndirect(renderParams, mesh, drawArgsBuffer, 1, 0

#ifndef PARTICLE_RENDERER_NODES_INCLUDED
#define PARTICLE_RENDERER_NODES_INCLUDED

#include "ParticleData.hlsl"

// This is the buffer that stores the particles
StructuredBuffer<ParticleData> _Particles;

void GetParticleData_float(
    in uint IN_InstanceID,
    out float3 OUT_PositionWS,
    out float OUT_Size,
    out float4 OUT_Color,
    out float OUT_NormalizedTime)
{
	// Use instance ID to get the particle data
    ParticleData particle = _Particles[IN_InstanceID];

	// And return its position, size, normalized time and color
    OUT_PositionWS = particle.positionWS.xyz;
    OUT_Size = particle.size;
    OUT_NormalizedTime = particle.lifetime > 0.0
        ? saturate(particle.time / particle.lifetime)
        : 0.0;
    OUT_Color = particle.color;
    OUT_Color.a *= 1.0 - OUT_NormalizedTime;
}

#endif

public interface ISimulateGPUParticles
{
	// This function simulates the particles by moving them all from the consume buffer into the append buffer.
	void SimulateParticles(CommandBuffer cmd, GraphicsBuffer consumeBuffer, GraphicsBuffer appendBuffer

private void RenderPipelineManager_beginCameraRendering(ScriptableRenderContext context, Camera camera)
{
	...
	// Step 1. Append new particles into buffer A
	// I removed the counter reset that was set temporarily before this step
	SpawnParticles(cmd, particleBufferA);

	// I added this step.
	// Step 2. Simulate particles
	SimulateParticles(cmd, ref particleBufferA, ref particleBufferB);

	// Step 3. Render particles
	RenderParticles(cmd, particleBufferA, camera

private void SimulateParticles(CommandBuffer cmd, ref GraphicsBuffer consumeBuffer, ref GraphicsBuffer appendBuffer)
{
	// Get all components that can simulate particles
	List<ISimulateGPUParticles> simulationSteps = ListPool<ISimulateGPUParticles>.Get();
	GetComponentsInChildren(false, simulationSteps);

	for (int i = 0; i < simulationSteps.Count; i++)
	{
		// Reset particle counter in buffer B
		cmd.SetBufferCounterValue(particleBufferB, 0);

		// For each component, simulate particles
		ISimulateGPUParticles simulation = simulationSteps[i];
		simulation.SimulateParticles(cmd, particleBufferA, particleBufferB);

		// And swap the buffers
		(consumeBuffer, appendBuffer) = (appendBuffer, consumeBuffer);
	}

	// Release temporary list
	ListPool<ISimulateGPUParticles>.Release(simulationSteps

public class GPUParticleSimulation : MonoBehaviour, ISimulateGPUParticles
{
	// Compute shader used for simulation
	public ComputeShader particleSimulationCompute;

	// Utility class to compute indirect args using a compute shader.
	private IndirectComputeArgsPreparation indirectComputeArgsPreparation;

	// Buffer that stores the current particle count for the compute shader.
	// Only the first uint is used, but the allocation needs Structured + 4 elements (see note below).
	private GraphicsBuffer particleCountBuffer = null;

	private void OnEnable()
	{
		// Initialize resources
		indirectComputeArgsPreparation = new IndirectComputeArgsPreparation();
		particleCountBuffer = new GraphicsBuffer(Target.Structured | Target.CopyDestination, 4, sizeof(uint));
	}

	private void OnDisable()
	{
		// Release resources allocated in OnEnable
		...
	}

	public void SimulateParticles(CommandBuffer cmd, GraphicsBuffer consumeBuffer, GraphicsBuffer appendBuffer)
	{
		// When no compute shader for simulation is set, throw an exception, as this will cause invalid simulation
		if (particleSimulationCompute == null)
			throw new InvalidOperationException("Trying to simulate particles when no compute shader is set");

		// Compute indirect arguments for the simulation shader dispatch
		// This utility calculates execution group count from the target thread count
		// I need to provide the target shader I want to dispatch...
		var indirectArgs = indirectComputeArgsPreparation.ComputeIndirectArgs(cmd, particleSimulationCompute, 0,
			(prepCmd, threadCountBuffer) =>
			{
				uint4[] threadCountData = ArrayPool<uint4>.Shared.Rent(1);
				threadCountData[0] = new uint4(1u, 1u, 1u, 1u);

				// ... and I need to fill in the buffer with target thread count.
				// So here I copy the consume buffer counter to this buffer.
				prepCmd.SetBufferData(threadCountBuffer, threadCountData, 0, 0, 1);
				prepCmd.CopyCounterValue(consumeBuffer, threadCountBuffer, 0);

				ArrayPool<uint4>.Shared.Return(threadCountData);
			});

		// Set particle count value in the counter buffer
		cmd.CopyCounterValue(consumeBuffer, particleCountBuffer, 0);

		// Some values for the simulation
		cmd.SetComputeFloatParam(particleSimulationCompute, Uniforms._DeltaTime, Time.deltaTime);
		cmd.SetComputeFloatParam(particleSimulationCompute, Uniforms._Time, Time.timeSinceLevelLoad);

		// Binding consume and append buffers with particles
		cmd.SetComputeBufferParam(particleSimulationCompute, 0, Uniforms._InputParticles, consumeBuffer);
		cmd.SetComputeBufferParam(particleSimulationCompute, 0, Uniforms._OutputParticles, appendBuffer);

		// And buffer that stores the particle count, so I can read that in the shader
		cmd.SetComputeBufferParam(particleSimulationCompute, 0, Uniforms._InputParticleCount, particleCountBuffer);

		// Dispatch the simulation
		cmd.DispatchCompute(particleSimulationCompute, 0, indirectArgs, 0

#pragma kernel ParticleSimulation

#pragma enable_d3d11_debug_symbols

// Use the particle data struct
#include "ParticleData.hlsl"

// Buffer with all the particles
ConsumeStructuredBuffer<ParticleData> _InputParticles;

// Buffer to append the particles
AppendStructuredBuffer<ParticleData> _OutputParticles;

// Buffer with input particle count
Buffer<uint> _InputParticleCount;

// Time and delta time for simulation
float _DeltaTime;
float _Time;

[numthreads(16, 1, 1)]
void ParticleSimulation(uint3 id : SV_DispatchThreadID)
{
	// Get the input particle count
    uint inputParticleCount = _InputParticleCount.Load(0);

	// Don't process more particles than there are
    if (id.x >= inputParticleCount)
        return;

	// Fetch one particle from the input
    ParticleData particle = _InputParticles.Consume();

	// Update the particle's time,
    particle.time += _DeltaTime;

	// and calculate the normalized time
	// where 0 is the start of the particle and 1 is the end of the particle life.
    float normalizedTime = particle.lifetime > 0.0 ? particle.time / particle.lifetime : 1.01;

	// When the particle is too old, don't process it
	// Skipping the append will kill the particle
    if (normalizedTime > 1.0)
        return;

	// Here is the main simulation
	// For now I just move the particle up
    particle.positionWS.y += _DeltaTime;

	// And output updated particle into the output buffer
    _OutputParticles.Append(particle

public class MeshParticleSpawner : MonoBehaviour, ISpawnGPUParticles
{
	...
	// Added mesh filter field
	[SerializeField] private MeshFilter meshFilter

private GraphicsBuffer vertexBuffer;
private GraphicsBuffer indexBuffer;

private void OnEnable()
{
	...
	if (meshFilter == null || meshFilter.sharedMesh == null)
		return;

	// Update usage flags, so I can bind the buffers to the compute shader
	meshFilter.sharedMesh.vertexBufferTarget |= GraphicsBuffer.Target.Raw;
	meshFilter.sharedMesh.indexBufferTarget |= GraphicsBuffer.Target.Raw;

	// Get the vertex buffer and index buffer
	vertexBuffer = meshFilter.sharedMesh.GetVertexBuffer(0);
	indexBuffer = meshFilter.sharedMesh.GetIndexBuffer();
}

private void OnDisable()
{
	// According to Unity's documentation, the buffers need to be released
	ReleaseBuffer(ref vertexBuffer);
	ReleaseBuffer(ref indexBuffer);

	void ReleaseBuffer(ref GraphicsBuffer buffer)
	{
		if (buffer != null)
		{
			buffer.Release();
			buffer = null

public void SpawnParticles(CommandBuffer cmd, GraphicsBuffer appendParticleBuffer)
{
	// Updated the spawn condition, so it is not possible to spawn particles when there is no mesh
	if (spawnCompute == null || meshFilter == null || meshFilter.sharedMesh == null)
		return;

	// For now, I will spawn one particle for each vertex
    int spawnCount = meshFilter.sharedMesh.GetSubMesh(0).vertexCount;

	// Updated local-to-world matrix, to use matrix from the meshFilter component
	cmd.SetComputeMatrixParam(spawnCompute, Uniforms._LocalToWorld, meshFilter.transform.localToWorldMatrix);
	...

	// Bind vertex buffer and index buffer to the compute shader
	cmd.SetComputeBufferParam(spawnCompute, 0, Uniforms._VertexBuffer, vertexBuffer);
	cmd.SetComputeBufferParam(spawnCompute, 0, Uniforms._IndexBuffer, indexBuffer);

	// Then I dispatch it the same way as the sphere spawner.

// Same as in HLSL
[System.Serializable, StructLayout(LayoutKind.Sequential)]
public struct MeshParams
{
    public uint _VertexBufferStride; // Size of each vertex in vertex buffer
    public uint _PositionAttributeOffset; // Offset from the base vertex address to read the position
    public uint _NormalAttributeOffset; // Offset from the base vertex address to read the normals
    public uint _VertexCount; // Vertex count in the vertex buffer

    public uint _BaseIndex; // Which index starts the mesh
    public uint _IndexCount; // How many indices this mesh has
    public uint _IndexBufferStride; // Format of the index (2 or 4 bytes)
    public uint _Padding2; // Padding to keep the constant buffer aligned to 16 bytes

public class MeshParticleSpawner : MonoBehaviour, ISpawnGPUParticles
{
	...
	// Added constant buffer with mesh params
	private ConstantBuffer<MeshParams> meshParamsConstantBuffer;

	private void OnEnable()
	{
		...
		// Creating constant buffer
		meshParamsConstantBuffer = new();
	}

	private void OnDisable()
	{
		...
		// Releasing constant buffer
		if (meshParamsConstantBuffer != null)
		{
			meshParamsConstantBuffer.Release();
			meshParamsConstantBuffer = null

public void SpawnParticles(CommandBuffer cmd, GraphicsBuffer appendParticleBuffer)
{
	// Get mesh metadata
	Mesh mesh = meshFilter.sharedMesh;
	MeshParams meshParams = new MeshParams()
	{
		_VertexBufferStride = (uint)mesh.GetVertexBufferStride(0),
		_NormalAttributeOffset = (uint)mesh.GetVertexAttributeOffset(VertexAttribute.Normal),
		_PositionAttributeOffset = (uint)mesh.GetVertexAttributeOffset(VertexAttribute.Position),
		_VertexCount = (uint)mesh.vertexCount,
		_IndexCount = (uint)mesh.GetSubMesh(0).indexCount,
		_BaseIndex = (uint)mesh.GetSubMesh(0).indexStart,
		_IndexBufferStride = (mesh.indexFormat == IndexFormat.UInt16) ? 2u : 4u
	};

	// And set the constant buffer
	meshParamsConstantBuffer.UpdateData(cmd, meshParams);
	meshParamsConstantBuffer.Set(cmd, spawnCompute, Uniforms.C_MeshParticleSpawnerParams

...
ByteAddressBuffer _VertexBuffer;
ByteAddressBuffer _IndexBuffer;

cbuffer C_MeshParticleSpawnerParams
{
    uint _VertexBufferStride;
    uint _PositionAttributeOffset;
    uint _NormalAttributeOffset;
    uint _VertexCount;

    uint _BaseIndex;
    uint _IndexCount;
    uint _IndexBufferStride;
    uint _Padding2

float3 GetVertexPosition(uint vertexIndex)
{
    float3 positionOS;

	// Get byte offset where the vertex starts
    uint vertexBaseAddress = vertexIndex * _VertexBufferStride;

    // Read three consecutive 32-bit regions as floats to get the position
    positionOS.x = asfloat(_VertexBuffer.Load(vertexBaseAddress + _PositionAttributeOffset));
    positionOS.y = asfloat(_VertexBuffer.Load(vertexBaseAddress + _PositionAttributeOffset + 4));
    positionOS.z = asfloat(_VertexBuffer.Load(vertexBaseAddress + _PositionAttributeOffset + 8));

    return positionOS;
}

...
float3 GetVertexNormal(uint vertexIndex)
{
	// Exact same implementation, but using _NormalAttributeOffset instead

[numthreads(16, 1, 1)]
void SpawnMeshParticles(uint3 id : SV_DispatchThreadID)
{
	...
	// Get vertex position and use it to spawn the particle
    float3 positionOS = GetVertexPosition(id.x);
    float3 positionWS = mul(_LocalToWorld, float4(positionOS, 1.0)).xyz

// One thread per triangle
// Each three consecutive indices form a triangle
// So to get the triangle count I need to divide the index count by 3
int spawnCount = (int)meshParams._IndexCount / 3

vertexIndex = _IndexBuffer.Load(indexOffset * 4

// Read one 16-bit mesh index from a raw index buffer.
// ByteAddressBuffer.Load only accepts 4-byte-aligned addresses and always returns 32 bits,
// so we load a full 32-bit word and extract the correct uint16 from it.
uint LoadIndex16(uint triangleIndexOffset)
{
    // Each 16-bit index occupies 2 bytes; convert logical index to a byte offset.
    uint byteAddr = triangleIndexOffset * 2;

    // Round down to the nearest 4-byte boundary so Load() is valid.
    // Example: byteAddr 6 -> alignedAddr 4 (the word at bytes [4..7] contains indices at bytes 4-5 and 6-7).
    // Here, just set 2 last bits to 00 to round it
    uint alignedAddr = byteAddr & ~3u;

    // One 32-bit word holds two consecutive uint16 indices:
    // [ low 16 bits = index at alignedAddr | high 16 bits = index at alignedAddr + 2 ]
    uint word = _IndexBuffer.Load(alignedAddr);

    // If byteAddr is 2 mod 4, our index starts at byte 2 inside the loaded word (the upper half), I return high 16 bits
    if ((byteAddr & 2u) != 0)
        return (word >> 16) & 0xFFFFu;

    // Otherwise the index sits in the lower 16 bits of the word.
    return word & 0xFFFFu

uint GetVertexIndex(uint indexOffset)
{
    if (_IndexBufferStride == 4)
        return _IndexBuffer.Load(indexOffset * 4);
    else
        return LoadIndex16(indexOffset

// Don't execute that for more triangles than there are
if (id.x >= (uint)_IndexCount / 3)
	return;

// Get index that starts the triangle
uint triangleIndexOffset = _BaseIndex + id.x * 3;

// Get vertex position for each triangle vertex
float3 positionOS_0 = GetVertexPosition(GetVertexIndex(triangleIndexOffset + 0));
float3 positionOS_1 = GetVertexPosition(GetVertexIndex(triangleIndexOffset + 1));
float3 positionOS_2 = GetVertexPosition(GetVertexIndex(triangleIndexOffset + 2));

// Average position
float3 positionOS = (positionOS_0 + positionOS_1 + positionOS_2) / 3.0f

// Uniform random point inside a triangle using barycentric coordinates.
// Based on Graphics Gems I, 1990, "Generating random points in triangles"
float3 GetRandomBarycentric(uint seed)
{
    float2 random01 = HashUintToFloat2(seed + 0x3C6EF372u);
    float sqrtU = sqrt(random01.x);
    float b0 = 1.0 - sqrtU;
    float b1 = sqrtU * (1.0 - random01.y);
    float b2 = sqrtU * random01.y;

    return float3(b0, b1, b2

// Random position
float3 bar = GetRandomBarycentric(particleSeed);
float3 positionOS = (bar.x * positionOS_0 + bar.y * positionOS_1 + bar.z * positionOS_2

public class MeshParticleSpawner : MonoBehaviour, ISpawnGPUParticles
{
	[SerializeField] private int particlesPerUnitSquare = 100

public void SpawnParticles(CommandBuffer cmd, GraphicsBuffer appendParticleBuffer)
{
	...
	// Set particles per unit square and frame delta time in the spawning shader
	cmd.SetComputeFloatParam(spawnCompute, Uniforms._ParticlesPerUnitSquare, particlesPerUnitSquare);
	cmd.SetComputeFloatParam(spawnCompute, Uniforms._DeltaTime, Time.deltaTime

float GetTriangleArea(float3 a, float3 b, float3 c)
{
    float3 ab = b - a;
    float3 ac = c - a;
    return 0.5 * sqrt(dot(ab, ab) * dot(ac, ac) - dot(ab, ac) * dot(ab, ac

...
// Get vertex position for each triangle vertex
float3 positionOS_0 = GetVertexPosition(GetVertexIndex(triangleIndexOffset + 0));
float3 positionOS_1 = GetVertexPosition(GetVertexIndex(triangleIndexOffset + 1));
float3 positionOS_2 = GetVertexPosition(GetVertexIndex(triangleIndexOffset + 2));

// Convert object space vertices into world space
float3 positionWS_0 = mul(_LocalToWorld, float4(positionOS_0, 1.0)).xyz;
float3 positionWS_1 = mul(_LocalToWorld, float4(positionOS_1, 1.0)).xyz;
float3 positionWS_2 = mul(_LocalToWorld, float4(positionOS_2, 1.0)).xyz;

// Calculate mesh triangle area in world space
float triangleAreaWS = GetTriangleArea(positionWS_0, positionWS_1, positionWS_2

// How many particles to spawn
float spawnCountF = _ParticlesPerUnitSquare * triangleAreaWS * _DeltaTime;
float spawnCountFloor = floor(spawnCountF); // Integer part
float spawnCountFrac = spawnCountF - spawnCountFloor; // Fractional part

// Integer part is fixed
uint spawnCount = uint(spawnCountFloor);

// Fractional part spawns based on probability
spawnCount += ((HashUintToFloat01(particleSeed + 0x97AD7039u) < spawnCountFrac) ? 1.0 : 0.0

// Seed needs to be different in each spawn, so I cache it
uint seed = particleSeed;

// Loop that spawns the particles
for (uint i = 0; i < spawnCount; i++)
{
	// Modify seed
	seed += 0x3A3B7012u;

	// Calculate particle position
	float3 bar = GetRandomBarycentric(seed);
	float3 positionWS = (bar.x * positionWS_0 + bar.y * positionWS_1 + bar.z * positionWS_2);

	ParticleData particle;
	particle.positionWS = float4(positionWS, 1.0);
	// Fill in other particle parameters here
	...

	// And append the particle
	_Particles.Append(particle

...
float3 bar = GetRandomBarycentric(seed);
float3 positionWS = (bar.x * positionWS_0 + bar.y * positionWS_1 + bar.z * positionWS_2);

// Use the same barycentric coordinates to interpolate the normal
float3 normalWS = (bar.x * normalWS_0 + bar.y * normalWS_1 + bar.z * normalWS_2);

ParticleData particle;
particle.positionWS = float4(positionWS, 1.0);
particle.velocityWS = float4(normalWS, 0.0); // And set the velocity

particle.lifetime = lerp(1.1, 5.0, HashUintToFloat01(seed + 0xC2B2AE35u));
particle.color = float4(1.0, 1.0, 1.0, 1.0

particle.positionWS += particle.velocityWS * _DeltaTime * 0.1

// Constants
float noiseStrength = 4.0;
float noiseScale = 1.5;
float3 constantVelocity = float3(1.2, 0.3, 0.1);

// Sample 3D value noise
float3 noiseUV = particle.positionWS.xyz * 1.5 + float3(0.0, -_Time * 1.0, 0.0);
float3 noiseOffset = (Noise3_3(noiseUV) - 0.5) * 4.0;

// Move the particle
particle.positionWS.xyz += (constantVelocity + noiseOffset) * _DeltaTime * sqrt(normalizedTime

// Some function that returns looping noise, in separate HLSL file
float GetBurningMask(float3 position)
{
	// Sample noise
	position *= 1.4;
    float3 noise = 0.0;
	position += 4.7386;
    noise += Noise3_3(position) * 0.75; // Sampling procedural 3D value noise
    noise += Noise3_3(position * 2.0 + 8.471) * 0.25; // Sampling procedural 3D value noise

	// Shift its values over time
    return noise.r - frac(_Time.y * 0.05);
}

// Node for the shader graph
void GetBurningMask_float(in float3 IN_PositionOS, out float OUT_Mask)
{
    OUT_Mask = GetBurningMask(IN_PositionOS

// added the same noise library at the beginning
#include "BurningMask.hlsl"

uint seed = particleSeed;
for (uint i = 0; i < spawnCount; i++)
{
	seed += 0x3A3B7012u;
	float3 bar = GetRandomBarycentric(seed);

	// Get object-space position
	float3 positionOS = bar.x * positionOS_0 + bar.y * positionOS_1 + bar.z * positionOS_2;

	// Get the mask - the same as it was in the shader
	float burningMask = GetBurningMask(positionOS.xyz);

	// Get the strip brightness as spawn probability
	float probability = smoothstep(0.1, 0.0, burningMask) * smoothstep(-0.005, 0.0, burningMask);

	// Based on the probability, cancel the spawn of the particle
	bool shouldSpawn = probability > HashUintToFloat01(seed + 0x19A27E32u);
	if (!shouldSpawn)
		continue;

	// Spawn particles as usual