Merge pull request #1389 from Unity-Technologies/lw/profiler-markers

Added CommandBuffer profiler markers

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

             foreach (Camera camera in cameras)
             {
                 BeginCameraRendering(camera);
-                m_IsCameraRendering = true;
+                string renderCameraTag = "Render " + camera.name;
+                CommandBuffer cmd = CommandBufferPool.Get(renderCameraTag);
+                using (new ProfilingSample(cmd, renderCameraTag))
+                {
+                    m_IsCameraRendering = true;
-                CameraData cameraData;
-                InitializeCameraData(camera, out cameraData);
-                SetupPerCameraShaderConstants(cameraData);
+                    CameraData cameraData;
+                    InitializeCameraData(camera, out cameraData);
+                    SetupPerCameraShaderConstants(cameraData);
-                ScriptableCullingParameters cullingParameters;
-                if (!CullResults.GetCullingParameters(camera, cameraData.isStereoEnabled, out cullingParameters))
-                    continue;
+                    ScriptableCullingParameters cullingParameters;
+                    if (!CullResults.GetCullingParameters(camera, cameraData.isStereoEnabled, out cullingParameters))
+                    {
+                        CommandBufferPool.Release(cmd);
+                        continue;
+                    }
+
+                    cullingParameters.shadowDistance = Mathf.Min(cameraData.maxShadowDistance, camera.farClipPlane);
-                cullingParameters.shadowDistance = Mathf.Min(cameraData.maxShadowDistance, camera.farClipPlane);
+                    context.ExecuteCommandBuffer(cmd);
+                    cmd.Clear();
-                // Emit scene view UI
-                if (cameraData.isSceneViewCamera)
-                    ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
+                    // Emit scene view UI
+                    if (cameraData.isSceneViewCamera)
+                        ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
-                CullResults.Cull(ref cullingParameters, context, ref m_CullResults);
-                List<VisibleLight> visibleLights = m_CullResults.visibleLights;
+                    CullResults.Cull(ref cullingParameters, context, ref m_CullResults);
+                    List<VisibleLight> visibleLights = m_CullResults.visibleLights;
-                RenderingData renderingData;
-                InitializeRenderingData(ref cameraData, visibleLights, m_Renderer.maxSupportedLocalLightsPerPass, m_Renderer.maxSupportedVertexLights, out renderingData);
-                m_Renderer.Setup(ref context, ref m_CullResults, ref renderingData);
-                m_Renderer.Execute(ref context, ref m_CullResults, ref renderingData);
+                    RenderingData renderingData;
+                    InitializeRenderingData(ref cameraData, visibleLights, m_Renderer.maxSupportedLocalLightsPerPass, m_Renderer.maxSupportedVertexLights, out renderingData);
+                    m_Renderer.Setup(ref context, ref m_CullResults, ref renderingData);
+                    m_Renderer.Execute(ref context, ref m_CullResults, ref renderingData);
+                    
+                    m_IsCameraRendering = false;
+                }
+                context.ExecuteCommandBuffer(cmd);
+                CommandBufferPool.Release(cmd);
-
-                m_IsCameraRendering = false;
             }
         }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Passes/DepthOnlyPass.cs

 {
     public class DepthOnlyPass : ScriptableRenderPass
     {
-        const string kProfilerTag = "Depth Prepass Setup";
-        const string kCommandBufferTag = "Depth Prepass";
+        const string k_SetupRenderTargetTag = "Setup Render Target";
+        const string k_DepthPrepassTag = "Depth Prepass";
 
         int kDepthBufferBits = 32;
 
 
         public override void Execute(ref ScriptableRenderContext context, ref CullResults cullResults, ref RenderingData renderingData)
         {
-            CommandBuffer cmd = CommandBufferPool.Get(kCommandBufferTag);
-            using (new ProfilingSample(cmd, kProfilerTag))
+            CommandBuffer cmd = CommandBufferPool.Get(k_DepthPrepassTag);
+            using (new ProfilingSample(cmd, k_SetupRenderTargetTag))
             {
                 SetRenderTarget(cmd, GetSurface(depthAttachmentHandle), RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
                     ClearFlag.Depth, Color.black);

ScriptableRenderPipeline/LightweightPipeline/LWRP/Passes/DirectionalShadowsPass.cs

         ShadowSliceData[] m_CascadeSlices;
         Vector4[] m_CascadeSplitDistances;
 
+        const string k_SetupRenderTargetTag = "Setup Render Target";
+        const string k_RenderDirectionalShadowmapTag = "Render Directional Shadowmap";
+
         public DirectionalShadowsPass(LightweightForwardRenderer renderer) : base(renderer)
         {
             RegisterShaderPassName("ShadowCaster");
             if (!cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds))
                 return;
 
-            CommandBuffer cmd = CommandBufferPool.Get("Prepare Directional Shadowmap");
-            m_ShadowCasterCascadesCount = shadowData.directionalLightCascadeCount;
+            CommandBuffer cmd = CommandBufferPool.Get(k_RenderDirectionalShadowmapTag);
+            using (new ProfilingSample(cmd, k_SetupRenderTargetTag))
+            {
+                m_ShadowCasterCascadesCount = shadowData.directionalLightCascadeCount;
-            int shadowResolution = LightweightShadowUtils.GetMaxTileResolutionInAtlas(shadowData.directionalShadowAtlasWidth, shadowData.directionalShadowAtlasHeight, m_ShadowCasterCascadesCount);
-            float shadowNearPlane = light.shadowNearPlane;
+                int shadowResolution = LightweightShadowUtils.GetMaxTileResolutionInAtlas(shadowData.directionalShadowAtlasWidth, shadowData.directionalShadowAtlasHeight, m_ShadowCasterCascadesCount);
+                float shadowNearPlane = light.shadowNearPlane;
-            Matrix4x4 view, proj;
-            var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
+                Matrix4x4 view, proj;
+                var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
-            m_DirectionalShadowmapTexture = RenderTexture.GetTemporary(shadowData.directionalShadowAtlasWidth,
-                    shadowData.directionalShadowAtlasHeight, k_ShadowmapBufferBits, m_ShadowmapFormat);
-            m_DirectionalShadowmapTexture.filterMode = FilterMode.Bilinear;
-            m_DirectionalShadowmapTexture.wrapMode = TextureWrapMode.Clamp;
-            SetRenderTarget(cmd, m_DirectionalShadowmapTexture, RenderBufferLoadAction.DontCare,
-                RenderBufferStoreAction.Store, ClearFlag.Depth, Color.black);
+                m_DirectionalShadowmapTexture = RenderTexture.GetTemporary(shadowData.directionalShadowAtlasWidth,
+                        shadowData.directionalShadowAtlasHeight, k_ShadowmapBufferBits, m_ShadowmapFormat);
+                m_DirectionalShadowmapTexture.filterMode = FilterMode.Bilinear;
+                m_DirectionalShadowmapTexture.wrapMode = TextureWrapMode.Clamp;
+                SetRenderTarget(cmd, m_DirectionalShadowmapTexture, RenderBufferLoadAction.DontCare,
+                    RenderBufferStoreAction.Store, ClearFlag.Depth, Color.black);
-            bool success = false;
-            for (int cascadeIndex = 0; cascadeIndex < m_ShadowCasterCascadesCount; ++cascadeIndex)
-            {
-                success = LightweightShadowUtils.ExtractDirectionalLightMatrix(ref cullResults, ref shadowData, shadowLightIndex, cascadeIndex, shadowResolution, shadowNearPlane, out m_CascadeSplitDistances[cascadeIndex], out m_CascadeSlices[cascadeIndex], out view, out proj);
-                if (success)
+                bool success = false;
+                for (int cascadeIndex = 0; cascadeIndex < m_ShadowCasterCascadesCount; ++cascadeIndex)
-                    LightweightShadowUtils.SetupShadowCasterConstants(cmd, ref shadowLight, proj, shadowResolution);
-                    LightweightShadowUtils.RenderShadowSlice(cmd, ref context, ref m_CascadeSlices[cascadeIndex], proj,
-                        view, settings);
+                    success = LightweightShadowUtils.ExtractDirectionalLightMatrix(ref cullResults, ref shadowData, shadowLightIndex, cascadeIndex, shadowResolution, shadowNearPlane, out m_CascadeSplitDistances[cascadeIndex], out m_CascadeSlices[cascadeIndex], out view, out proj);
+                    if (success)
+                    {
+                        LightweightShadowUtils.SetupShadowCasterConstants(cmd, ref shadowLight, proj, shadowResolution);
+                        LightweightShadowUtils.RenderShadowSlice(cmd, ref context, ref m_CascadeSlices[cascadeIndex], proj,
+                            view, settings);
+                    }
-            }
-            if (success)
-            {
-                shadowQuality = (shadowData.supportsSoftShadows) ? light.shadows : LightShadows.Hard;
+                if (success)
+                {
+                    shadowQuality = (shadowData.supportsSoftShadows) ? light.shadows : LightShadows.Hard;
-                // In order to avoid shader variants explosion we only do hard shadows when sampling shadowmap in the lit pass.
-                // GLES2 platform is forced to hard single cascade shadows.
-                if (!shadowData.requiresScreenSpaceShadowResolve)
-                    shadowQuality = LightShadows.Hard;
+                    // In order to avoid shader variants explosion we only do hard shadows when sampling shadowmap in the lit pass.
+                    // GLES2 platform is forced to hard single cascade shadows.
+                    if (!shadowData.requiresScreenSpaceShadowResolve)
+                        shadowQuality = LightShadows.Hard;
-                SetupDirectionalShadowReceiverConstants(ref context, cmd, ref shadowData, shadowLight);
+                    SetupDirectionalShadowReceiverConstants(ref context, cmd, ref shadowData, shadowLight);
+                }
-
             context.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
 
             cmd.SetGlobalVector(DirectionalShadowConstantBuffer._ShadowOffset3, new Vector4(invHalfShadowAtlasWidth, invHalfShadowAtlasHeight, 0.0f, 0.0f));
             cmd.SetGlobalVector(DirectionalShadowConstantBuffer._ShadowmapSize, new Vector4(invShadowAtlasWidth, invShadowAtlasHeight,
                     shadowData.directionalShadowAtlasWidth, shadowData.directionalShadowAtlasHeight));
-            context.ExecuteCommandBuffer(cmd);
-            cmd.Clear();
         }
     };
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Passes/ForwardLitPass.cs

         float[] m_OpaqueScalerValues = {1.0f, 0.5f, 0.25f, 0.25f};
         int m_SampleOffsetShaderHandle;
 
+        const string k_SetupRenderTargetTag = "Setup Render Target";
+        const string k_RenderOpaquesTag = "Render Opaques";
+        const string k_RenderTransparentsTag = "Render Transparents";
+
         List<ShaderPassName> m_LegacyShaderPassNames;
 
         public ForwardLitPass(LightweightForwardRenderer renderer) : base(renderer)
 
         void RenderOpaques(ref ScriptableRenderContext context, ref CullResults cullResults, ref CameraData cameraData, RendererConfiguration rendererConfiguration, bool dynamicBatching)
         {
-            CommandBuffer cmd = CommandBufferPool.Get("Render Opaques");
-            Camera camera = cameraData.camera;
-
-            ClearFlag clearFlag = GetCameraClearFlag(camera);
+            CommandBuffer cmd = CommandBufferPool.Get(k_RenderOpaquesTag);
+            using (new ProfilingSample(cmd, k_SetupRenderTargetTag))
+            {
+                Camera camera = cameraData.camera;
+                ClearFlag clearFlag = GetCameraClearFlag(camera);
+                SetRenderTarget(cmd, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, clearFlag, CoreUtils.ConvertSRGBToActiveColorSpace(camera.backgroundColor));
-            // TODO: This was merged from previous LOAD/STORE PR. It seems this should not be DontCare
-            // and instead we should check clearFlags to wheter set to Clear or DontCare
-            // Same in screenspace shadow resolve pass. Also we should check for the msaa resolve actions.
-            SetRenderTarget(cmd, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, clearFlag, CoreUtils.ConvertSRGBToActiveColorSpace(camera.backgroundColor));
-            context.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
+                // If rendering to an intermediate RT we resolve viewport on blit due to offset not being supported
+                // while rendering to a RT.
+                if (colorAttachmentHandle == -1 && cameraData.isDefaultViewport)
+                    cmd.SetViewport(camera.pixelRect);
-            // If rendering to an intermediate RT we resolve viewport on blit due to offset not being supported
-            // while rendering to a RT.
-            if (colorAttachmentHandle == -1 && cameraData.isDefaultViewport)
-                cmd.SetViewport(camera.pixelRect);
+                context.ExecuteCommandBuffer(cmd);
+                cmd.Clear();
-            var drawSettings = CreateDrawRendererSettings(camera, SortFlags.CommonOpaque, rendererConfiguration, dynamicBatching);
-            context.DrawRenderers(cullResults.visibleRenderers, ref drawSettings, renderer.opaqueFilterSettings);
+                var drawSettings = CreateDrawRendererSettings(camera, SortFlags.CommonOpaque, rendererConfiguration, dynamicBatching);
+                context.DrawRenderers(cullResults.visibleRenderers, ref drawSettings, renderer.opaqueFilterSettings);
-            // Render objects that did not match any shader pass with error shader
-            RenderObjectsWithError(ref context, ref cullResults, camera, renderer.opaqueFilterSettings, SortFlags.None);
+                // Render objects that did not match any shader pass with error shader
+                RenderObjectsWithError(ref context, ref cullResults, camera, renderer.opaqueFilterSettings, SortFlags.None);
-            if (camera.clearFlags == CameraClearFlags.Skybox)
-                context.DrawSkybox(camera);
+                if (camera.clearFlags == CameraClearFlags.Skybox)
+                    context.DrawSkybox(camera);
+            }
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
-            CommandBuffer cmd = CommandBufferPool.Get("Render Transparents");
-            Camera camera = cameraData.camera;
-            SetRenderTarget(cmd, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store, ClearFlag.None, Color.black);
+            CommandBuffer cmd = CommandBufferPool.Get(k_RenderTransparentsTag);
+            using (new ProfilingSample(cmd, k_SetupRenderTargetTag))
+            {
+                Camera camera = cameraData.camera;
+                SetRenderTarget(cmd, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store, ClearFlag.None, Color.black);
+                context.ExecuteCommandBuffer(cmd);
+                cmd.Clear();
+                
+                var drawSettings = CreateDrawRendererSettings(camera, SortFlags.CommonTransparent, rendererConfiguration, dynamicBatching);
+                context.DrawRenderers(cullResults.visibleRenderers, ref drawSettings, renderer.transparentFilterSettings);
+
+                // Render objects that did not match any shader pass with error shader
+                RenderObjectsWithError(ref context, ref cullResults, camera, renderer.transparentFilterSettings, SortFlags.None);
+            }
-
-            var drawSettings = CreateDrawRendererSettings(camera, SortFlags.CommonTransparent, rendererConfiguration, dynamicBatching);
-            context.DrawRenderers(cullResults.visibleRenderers, ref drawSettings, renderer.transparentFilterSettings);
-
-            // Render objects that did not match any shader pass with error shader
-            RenderObjectsWithError(ref context, ref cullResults, camera, renderer.transparentFilterSettings, SortFlags.None);
         }
 
         void FinalBlitPass(ref ScriptableRenderContext context, ref CameraData cameraData)

ScriptableRenderPipeline/LightweightPipeline/LWRP/Passes/LocalShadowsPass.cs

         ShadowSliceData[] m_LocalLightSlices;
         float[] m_LocalShadowStrength;
 
+        const string k_SetupRenderTargetTag = "Setup Render Target";
+        const string k_RenderLocalShadows = "Render Local Shadows";
+
         public LocalShadowsPass(LightweightForwardRenderer renderer) : base(renderer)
         {
             RegisterShaderPassName("ShadowCaster");
             if (shadowCastingLightsCount == 0)
                 return;
 
-            CommandBuffer cmd = CommandBufferPool.Get("Prepare Local Lights Shadowmap");
-
-            // TODO: Add support to point light shadows. We make a simplification here that only works
-            // for spot lights and with max spot shadows per pass.
-            int atlasWidth = shadowData.localShadowAtlasWidth;
-            int atlasHeight = shadowData.localShadowAtlasHeight;
-            int sliceResolution = LightweightShadowUtils.GetMaxTileResolutionInAtlas(atlasWidth, atlasHeight, shadowCastingLightsCount);
-            m_LocalShadowmapTexture = RenderTexture.GetTemporary(shadowData.localShadowAtlasWidth,
-                    shadowData.localShadowAtlasHeight, k_ShadowmapBufferBits, m_LocalShadowmapFormat);
-            m_LocalShadowmapTexture.filterMode = FilterMode.Bilinear;
-            m_LocalShadowmapTexture.wrapMode = TextureWrapMode.Clamp;
+            CommandBuffer cmd = CommandBufferPool.Get(k_RenderLocalShadows);
+            using (new ProfilingSample(cmd, k_SetupRenderTargetTag))
+            {
+                // TODO: Add support to point light shadows. We make a simplification here that only works
+                // for spot lights and with max spot shadows per pass.
+                int atlasWidth = shadowData.localShadowAtlasWidth;
+                int atlasHeight = shadowData.localShadowAtlasHeight;
+                int sliceResolution = LightweightShadowUtils.GetMaxTileResolutionInAtlas(atlasWidth, atlasHeight, shadowCastingLightsCount);
+                
+                m_LocalShadowmapTexture = RenderTexture.GetTemporary(shadowData.localShadowAtlasWidth,
+                        shadowData.localShadowAtlasHeight, k_ShadowmapBufferBits, m_LocalShadowmapFormat);
+                m_LocalShadowmapTexture.filterMode = FilterMode.Bilinear;
+                m_LocalShadowmapTexture.wrapMode = TextureWrapMode.Clamp;
-            SetRenderTarget(cmd, m_LocalShadowmapTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
-                ClearFlag.Depth, Color.black);
+                SetRenderTarget(cmd, m_LocalShadowmapTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
+                    ClearFlag.Depth, Color.black);
-            for (int i = 0; i < localLightsCount; ++i)
-            {
-                int shadowLightIndex = localLightIndices[i];
-                VisibleLight shadowLight = visibleLights[shadowLightIndex];
-                Light light = shadowLight.light;
+                for (int i = 0; i < localLightsCount; ++i)
+                {
+                    int shadowLightIndex = localLightIndices[i];
+                    VisibleLight shadowLight = visibleLights[shadowLightIndex];
+                    Light light = shadowLight.light;
-                // TODO: Add support to point light shadows
-                if (shadowLight.lightType != LightType.Spot || shadowLight.light.shadows == LightShadows.None)
-                    continue;
+                    // TODO: Add support to point light shadows
+                    if (shadowLight.lightType != LightType.Spot || shadowLight.light.shadows == LightShadows.None)
+                        continue;
-                if (!cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds))
-                    continue;
+                    if (!cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds))
+                        continue;
-                Matrix4x4 shadowTransform;
-                bool success = LightweightShadowUtils.ExtractSpotLightMatrix(ref cullResults, ref shadowData,
-                        shadowLightIndex, out shadowTransform, out view, out proj);
+                    Matrix4x4 shadowTransform;
+                    bool success = LightweightShadowUtils.ExtractSpotLightMatrix(ref cullResults, ref shadowData,
+                            shadowLightIndex, out shadowTransform, out view, out proj);
-                if (success)
-                {
-                    // This way of computing the shadow slice only work for spots and with most 4 shadow casting lights per pass
-                    // Change this when point lights are supported.
-                    Debug.Assert(localLightsCount <= 4 && shadowLight.lightType == LightType.Spot);
+                    if (success)
+                    {
+                        // This way of computing the shadow slice only work for spots and with most 4 shadow casting lights per pass
+                        // Change this when point lights are supported.
+                        Debug.Assert(localLightsCount <= 4 && shadowLight.lightType == LightType.Spot);
-                    // TODO: We need to pass bias and scale list to shader to be able to support multiple
-                    // shadow casting local lights.
-                    m_LocalLightSlices[i].offsetX = (i % 2) * sliceResolution;
-                    m_LocalLightSlices[i].offsetY = (i / 2) * sliceResolution;
-                    m_LocalLightSlices[i].resolution = sliceResolution;
-                    m_LocalLightSlices[i].shadowTransform = shadowTransform;
-
-                    m_LocalShadowStrength[i] = light.shadowStrength;
-                    shadowSampling = Math.Max(shadowSampling, (int)light.shadows);
+                        // TODO: We need to pass bias and scale list to shader to be able to support multiple
+                        // shadow casting local lights.
+                        m_LocalLightSlices[i].offsetX = (i % 2) * sliceResolution;
+                        m_LocalLightSlices[i].offsetY = (i / 2) * sliceResolution;
+                        m_LocalLightSlices[i].resolution = sliceResolution;
+                        m_LocalLightSlices[i].shadowTransform = shadowTransform;
-                    if (shadowCastingLightsCount > 1)
-                        LightweightShadowUtils.ApplySliceTransform(ref m_LocalLightSlices[i], atlasWidth, atlasHeight);
+                        m_LocalShadowStrength[i] = light.shadowStrength;
+                        shadowSampling = Math.Max(shadowSampling, (int)light.shadows);
-                    LightweightShadowUtils.SetupShadowCasterConstants(cmd, ref shadowLight, proj, sliceResolution);
+                        if (shadowCastingLightsCount > 1)
+                            LightweightShadowUtils.ApplySliceTransform(ref m_LocalLightSlices[i], atlasWidth, atlasHeight);
-                    var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
-                    LightweightShadowUtils.RenderShadowSlice(cmd, ref context, ref m_LocalLightSlices[i], proj, view, settings);
+                        var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
+                        LightweightShadowUtils.SetupShadowCasterConstants(cmd, ref shadowLight, proj, sliceResolution);
+                        LightweightShadowUtils.RenderShadowSlice(cmd, ref context, ref m_LocalLightSlices[i], proj, view, settings);
+                    }
+
+                SetupLocalLightsShadowReceiverConstants(ref context, cmd, ref shadowData);
-
-            SetupLocalLightsShadowReceiverConstants(ref context, cmd, ref shadowData);
             context.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
 
             cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowOffset3, new Vector4(invHalfShadowAtlasWidth, invHalfShadowAtlasHeight, 0.0f, 0.0f));
             cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowmapSize, new Vector4(invShadowAtlasWidth, invShadowAtlasHeight,
                     shadowData.localShadowAtlasWidth, shadowData.localShadowAtlasHeight));
-            context.ExecuteCommandBuffer(cmd);
-            cmd.Clear();
         }
     }
 }