HDRenderLoop: Add depth prepass +DepthPrepass for forward opaque

Assets/ScriptableRenderLoop/HDRenderLoop/Editor/HDRenderLoopInspector.cs

             public readonly GUIContent exposure = new GUIContent("Exposure");
 
             public readonly GUIContent useForwardRenderingOnly = new GUIContent("Use Forward Rendering Only");
+            public readonly GUIContent useDepthPrepass = new GUIContent("Use Depth Prepass");
 
             public bool isDebugViewMaterialInit = false;
             public GUIContent[] debugViewMaterialStrings = null;
             debugParameters.displayOpaqueObjects = EditorGUILayout.Toggle(styles.displayOpaqueObjects, debugParameters.displayOpaqueObjects);
             debugParameters.displayTransparentObjects = EditorGUILayout.Toggle(styles.displayTransparentObjects, debugParameters.displayTransparentObjects);
 			debugParameters.useForwardRenderingOnly = EditorGUILayout.Toggle(styles.useForwardRenderingOnly, debugParameters.useForwardRenderingOnly);
+            debugParameters.useDepthPrepass = EditorGUILayout.Toggle(styles.useDepthPrepass, debugParameters.useDepthPrepass);            
 
             if (EditorGUI.EndChangeCheck())
             {

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.asset.meta

 fileFormatVersion: 2
 guid: 2400b74f5ce370c4481e5dc417d03703
-timeCreated: 1478912125
+timeCreated: 1479232893
 licenseType: Pro
 NativeFormatImporter:
   userData: 

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

             public bool displayTransparentObjects = true;
 
             public bool useForwardRenderingOnly = false; // TODO: Currently there is no way to strip the extra forward shaders generated by the shaders compiler, so we can switch dynamically.
+            public bool useDepthPrepass = false;
 
             public bool enableTonemap = true;
             public float exposure = 0;
             // END TEMP
         }
 
-        // TODO: Create an opaque and transparent list!
+        void RenderOpaqueNoLightingRenderList(CullResults cull, Camera camera, RenderLoop renderLoop, string passName)
+        {
+            if (!debugParameters.displayOpaqueObjects)
+                return;
+
+            var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
+            {
+                rendererConfiguration = 0,
+                sorting = { sortOptions = SortOptions.SortByMaterialThenMesh }
+            };        
+            settings.inputFilter.SetQueuesOpaque();
+            renderLoop.DrawRenderers(ref settings);
+        }
+
-            DrawRendererSettings settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName));
-            settings.sorting.sortOptions = SortOptions.SortByMaterialThenMesh;
+            var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
+            {
+                rendererConfiguration = RendererConfiguration.PerObjectLightProbe | RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbeProxyVolume,
+                sorting = { sortOptions = SortOptions.SortByMaterialThenMesh }
+            };
-			settings.rendererConfiguration = RendererConfiguration.PerObjectLightProbe | RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbeProxyVolume;
+            renderLoop.DrawRenderers(ref settings);
+        }
+
+        void RenderTransparentNoLightingRenderList(CullResults cull, Camera camera, RenderLoop renderLoop, string passName)
+        {
+            if (!debugParameters.displayTransparentObjects)
+                return;
+
+            var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
+            {
+                rendererConfiguration = 0,
+                sorting = { sortOptions = SortOptions.BackToFront }
+            };
+            settings.inputFilter.SetQueuesTransparent();
-        void RenderTransparentRenderList(CullResults cull, Camera camera, RenderLoop renderLoop, string passName)
+        void RenderTransparentRenderList(CullResults cull, Camera camera, RenderLoop renderLoop, string passName)        
         {
             if (!debugParameters.displayTransparentObjects)
                 return;
             renderLoop.DrawRenderers(ref settings);
         }
 
+        void RenderDepthPrepass(CullResults cull, Camera camera, RenderLoop renderLoop)
+        {
+            // If we are forward only we will do a depth prepass
+            // TODO: Depth prepass should be enabled based on light loop settings. LightLoop define if they need a depth prepass + forward only...
+            if (!debugParameters.useDepthPrepass)
+                return;
+
+              // TODO: Must do opaque then alpha masked for performance! 
+            // TODO: front to back for opaque and by materal for opaque tested when we split in two
+            var cmd = new CommandBuffer { name = "Depth Prepass" };
+            cmd.SetRenderTarget(new RenderTargetIdentifier(s_CameraDepthBuffer));
+            renderLoop.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
+
+            RenderOpaqueNoLightingRenderList(cull, camera, renderLoop, "DepthOnly");
+        }
+
         void RenderGBuffer(CullResults cull, Camera camera, RenderLoop renderLoop)
         {
             if (debugParameters.useForwardRenderingOnly)
 
             // render opaque objects into GBuffer
             RenderOpaqueRenderList(cull, camera, renderLoop, "GBuffer");
+        }
+
+        // This pass is use in case of forward opaque and deferred rendering. We need to render forward objects before tile lighting pass
+        void RenderForwardOpaqueDepth(CullResults cull, Camera camera, RenderLoop renderLoop)
+        {
+            // If we have render a depth prepass, no need for this pass
+            if (debugParameters.useDepthPrepass)
+                return;
+
+            // TODO: Use the render queue index to only send the forward opaque!
+            var cmd = new CommandBuffer { name = "Depth Prepass" };
+            cmd.SetRenderTarget(new RenderTargetIdentifier(s_CameraDepthBuffer));
+            renderLoop.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
+
+            RenderOpaqueNoLightingRenderList(cull, camera, renderLoop, "DepthOnly");
         }
 
         void RenderDebugViewMaterial(CullResults cull, Camera camera, RenderLoop renderLoop)
             renderLoop.ExecuteCommandBuffer(cmd);
             cmd.Dispose();
 
-            RenderOpaqueRenderList(cullResults, camera, renderLoop, "ForwardUnlit");
-            RenderTransparentRenderList(cullResults, camera, renderLoop, "ForwardUnlit");
+            RenderOpaqueNoLightingRenderList(cullResults, camera, renderLoop, "ForwardUnlit");
+            RenderTransparentNoLightingRenderList(cullResults, camera, renderLoop, "ForwardUnlit");
         }
 
         void RenderVelocity(CullResults cullResults, Camera camera, RenderLoop renderLoop)
             renderLoop.ExecuteCommandBuffer(cmd);
             cmd.Dispose();
 
-            RenderOpaqueRenderList(cullResults, camera, renderLoop, "MotionVectors");
+            RenderOpaqueNoLightingRenderList(cullResults, camera, renderLoop, "MotionVectors");
 #pragma warning restore 162, 429
         }
 
             cmd.Dispose();
 
             // Only transparent object can render distortion vectors
-            RenderTransparentRenderList(cullResults, camera, renderLoop, "DistortionVectors");
+            RenderTransparentNoLightingRenderList(cullResults, camera, renderLoop, "DistortionVectors");
         }
 
 
 
                 InitAndClearBuffer(camera, renderLoop);
 
+                RenderDepthPrepass(cullResults, camera, renderLoop);
+
+
+                // For tile lighting with forward opaque
+                //RenderForwardOpaqueDepth(cullResults, camera, renderLoop);
 
                 if (debugParameters.debugViewMaterial != 0)
                 {

Assets/ScriptableRenderLoop/HDRenderLoop/Material/LayeredLit/LayeredLit.shader

 
         Pass
         {
+            Name "DepthOnly"
+            Tags{ "LightMode" = "DepthOnly" }
+
+            Cull[_CullMode]
+
+            ZWrite On ZTest LEqual
+
+            HLSLPROGRAM
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #define LAYERED_LIT_SHADER
+            #include "../../Material/Material.hlsl"
+            #include "../Lit/LitData.hlsl"
+            #include "../Lit/LitDepthPass.hlsl"
+
+            #include "../../ShaderPass/ShaderPassDepthOnly.hlsl"
+
+            ENDHLSL
+        }
+
+        Pass
+        {
             Name "Forward" // Name is not used
             Tags{ "LightMode" = "Forward" } // This will be only for transparent object based on the RenderQueue index
 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/Lit.shader

 
         Pass
         {
+            Name "DepthOnly"
+            Tags{ "LightMode" = "DepthOnly" }
+
+            Cull[_CullMode]
+
+            ZWrite On ZTest LEqual
+
+            HLSLPROGRAM
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #include "../../Material/Material.hlsl"            
+            #include "LitData.hlsl"
+            #include "LitDepthPass.hlsl"
+
+            #include "../../ShaderPass/ShaderPassDepthOnly.hlsl"
+
+            ENDHLSL
+        }
+
+        Pass
+        {
             Name "Motion Vectors"
             Tags{ "LightMode" = "MotionVectors" } // Caution, this need to be call like this to setup the correct parameters by C++ (legacy Unity)