Pfthb

After my main camera renders, I'd like to use (or copy) its depth buffer to a (disabled) camera's depth buffer.
My goal is to draw particles onto a smaller render target (using a separate camera) while using the depth buffer after opaque objects are drawn.
I can't do this in a single camera, since the goal is to use a smaller render target for the particles for performance reasons.

Replacement shaders in Unity aren't an option either: I want my particles to use their existing shaders - i just want the depth buffer of the particle camera to be overwritten with a subsampled version of the main camera's depth buffer before the particles are drawn.

I didn't get any reply to my earlier question; hence, the repost.

Here's the script attached to my main camera. It renders all the non-particle layers and I use OnRenderImage to invoke the particle camera.

public class MagicRenderer : MonoBehaviour 
public Shader particleShader; // shader that uses the main camera's depth buffer to depth test particle Z
public Material blendMat; // material that uses a simple blend shader
public int downSampleFactor = 1;

private RenderTexture particleRT;
private static GameObject pCam;

void Awake () 
 // make the main cameras depth buffer available to the shaders via _CameraDepthTexture
 camera.depthTextureMode = DepthTextureMode.Depth;


// Update is called once per frame
void Update () 



void OnRenderImage(RenderTexture src, RenderTexture dest) 
 // create tmp RT
 particleRT = RenderTexture.GetTemporary (Screen.width / downSampleFactor, Screen.height / downSampleFactor, 0);
 particleRT.antiAliasing = 1;

 // create particle cam
 Camera pCam = GetPCam ();
 pCam.CopyFrom (camera); 
 pCam.clearFlags = CameraClearFlags.SolidColor;
 pCam.backgroundColor = new Color (0.0f, 0.0f, 0.0f, 0.0f);
 pCam.cullingMask = 1 << LayerMask.NameToLayer ("Particles");
 pCam.useOcclusionCulling = false;
 pCam.targetTexture = particleRT;
 pCam.depth = 0;

 // Draw to particleRT's colorBuffer using mainCam's depth buffer
 // ?? - how do i transfer this camera's depth buffer to pCam?
 pCam.Render ();
 // pCam.RenderWithShader (particleShader, "Transparent"); // I don't want to replace the shaders my particles use; os shader replacement isnt an option.

 // blend mainCam's colorBuffer with particleRT's colorBuffer
 // Graphics.Blit(pCam.targetTexture, src, blendMat); 

 // copy resulting buffer to destination
 Graphics.Blit (pCam.targetTexture, dest);


 // clean up
 RenderTexture.ReleaseTemporary(particleRT);


static public Camera GetPCam() 
 if (!pCam) 
 GameObject oldpcam = GameObject.Find("pCam");
 Debug.Log (oldpcam);
 if (oldpcam) Destroy(oldpcam);

 pCam = new GameObject("pCam");
 pCam.AddComponent<Camera>();
 pCam.camera.enabled = false;
 pCam.hideFlags = HideFlags.DontSave;
 

 return pCam.camera;

I've a few additional questions:

1) Why does camera.depthTextureMode = DepthTextureMode.Depth; end up drawing all the objects in the scene just to write to the Z-buffer? Using Intel GPA, I see two passes before OnRenderImage gets called:
(i) Z-PrePass, that only writes to the depth buffer
(ii) Color pass, that writes to both the color and depth buffer.

2) I re-rendered the opaque objects to pCam's RT using a replacement shader that writes (0,0,0,0) to the colorBuffer with ZWrite On (to overcome the depth buffer transfer problem). After that, I reset the layers and clear mask as follows:

pCam.cullingMask = 1 << LayerMask.NameToLayer ("Particles");
pCam.clearFlags = CameraClearFlags.Nothing;

and rendered them using pCam.Render().

I thought this would render the particles using their existing shaders with the ZTest.
Unfortunately, what I notice is that the depth-stencil buffer is cleared before the particles are drawn (inspite me not clearing anything..).

Why does this happen?

I managed to reuse camera Z-buffer "manually" in the shader used for rendering. See http://forum.unity3d.com/threads/reuse-depth-buffer-of-main-camera.280460/ for more.

Just alter the particle shader you use already for particle rendering.