How to use Graphics.DrawProceduralIndirect to draw to multiple seperate render textures?

Questions & Answers
1

I have a setup where I have multiple lights. The goal is to have a compute shader generate a shadow mesh for each individual light, and then using the camera, save that mesh to a render texture. The compute shader is working fine.
My problem is that each Graphics.DrawProceduralIndirect (Graphics.DPI for short) call overrides the last, so by the end of the loop I am only left with the last Graphics.DPI call. The only mesh visible to the camera is the last Graphics.DPI call.
In addition, I would expect each render texture to be unique. Unfortunately this is not the case, and each light’s render texture looks identical and has the same ID.

Ideally I want to do this:
For each Light:

  1. Generate a shadow mesh using Graphics.DPI (working)
  2. Save camera view of the shadow mesh to that light’s UNQIUE render texture.
  3. Get rid of that lights shadow mesh.
  4. Repeat for each light.

By the end I need each light to have a stored render texture of its own unique shadow mesh.

Thank you,
NL

void LateUpdate()
{
    if (initialized)
    {
        // For each light in the scene, create a shadow mask and save it to a render texture.
        for (int i = 0; i < transform.childCount; i++)

            if (transform.GetChild(i).GetComponent<Light>())
            {
                // Clear the compute buffer of the last frame's data.
                writeTriangleBuffer.SetCounterValue(0);

                // Update the compute shader with the specific data.
                lightPosition = transform.GetChild(i).transform.position;
                shadowComputeShader.SetFloats("_LightPosition", new float[] { lightPosition.x, lightPosition.y, lightPosition.z });
                shadowComputeShader.SetMatrix("_LocalToWorldTransformMatrix", shadowObject.transform.localToWorldMatrix);
                // Dispatch the compute shader to run on the GPU.
                shadowComputeShader.Dispatch(idShadowKernel, dispatchSize, 1, 1);

                /* Get the count of the draw buffer into the argurment buffer. 
                 * This sets the vertex count for the draw call.
                 */
                ComputeBuffer.CopyCount(writeTriangleBuffer, argsBuffer, 0);

                /* The shadow compute shader outputs triangles, but the graphics shader needs the number of vertices.
                   To fix this, we will multiply the vertex count by 3. To avoid transfering data back to the CPU,
                   This will be done on the GPU with a small compute shader.
                */
                triangleToVertexCountComputeShader.Dispatch(idTriangleToVertexCountKernel, 1, 1, 1);

                // Write draw to render texture. Pass that render texture to the light game object.
                RenderTexture rt = RenderTexture.GetTemporary(Screen.width, Screen.height, 24);
                Graphics.SetRenderTarget(cam.targetTexture);
                Graphics.DrawProceduralIndirect(material, bounds, MeshTopology.Triangles, argsBuffer, 0, cam, null, ShadowCastingMode.Off, true, gameObject.layer);
                Graphics.Blit(cam.targetTexture, rt);
                transform.GetChild(i).GetComponent<Light>().shadowMask = rt;
                RenderTexture.ReleaseTemporary(rt);
            }
    }
}