void RenderObjects(ScriptableRenderContext renderContext, CommandBuffer cmd, Material overrideMaterial, int passIndex, CompareFunction depthCompare, CullingResults cullingResult, HDCamera hdCamera, StencilState?overrideStencil = null) { // Render the objects in the layer blur mask into a mask buffer with their materials so we keep the alpha-clip and transparency if there is any. var result = new RendererListDesc(shaderTags, cullingResult, hdCamera.camera) { rendererConfiguration = PerObjectData.None, renderQueueRange = RenderQueueRange.all, sortingCriteria = SortingCriteria.BackToFront, excludeObjectMotionVectors = false, overrideMaterial = overrideMaterial, overrideMaterialPassIndex = passIndex, layerMask = seeThroughLayer, stateBlock = new RenderStateBlock(RenderStateMask.Depth) { depthState = new DepthState(true, depthCompare) }, }; if (overrideStencil != null) { var block = result.stateBlock.Value; block.mask |= RenderStateMask.Stencil; block.stencilState = overrideStencil.Value; result.stateBlock = block; } CoreUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result)); }
// This function is called from the custom post process at the before post process injection point, just after TAA public void RenderVideoObjects(CommandBuffer cmd) { // Fix depth buffer jittering if (fixDepthBufferJittering) { using (new ProfilingScope(cmd, new ProfilingSampler("Render Depth Buffer without jittering"))) { // We need to re-render everything to get the non-jittered depth buffer :/ CoreUtils.SetRenderTarget(cmd, videoDepthBuffer); CoreUtils.ClearRenderTarget(cmd, ClearFlag.Depth, Color.black); var tags = new ShaderTagId[] { new ShaderTagId("DepthForwardOnly"), new ShaderTagId("DepthOnly") }; var result = new RendererListDesc(tags, context.cullingResults, context.hdCamera.camera) { rendererConfiguration = PerObjectData.None, renderQueueRange = RenderQueueRange.all, sortingCriteria = SortingCriteria.CommonOpaque, excludeObjectMotionVectors = false, layerMask = fixDepthBufferJitteringMask, // stateBlock = overrideRenderState, }; CoreUtils.DrawRendererList(context.renderContext, context.cmd, RendererList.Create(result)); } } // TODO: add an option to render the "frame" objects in the unjittered depth-buffer to avoid flickering CoreUtils.SetRenderTarget(cmd, videoColorBuffer, fixDepthBufferJittering ? videoDepthBuffer : context.cameraDepthBuffer, ClearFlag.Color); var renderState = new RenderStateBlock(RenderStateMask.Depth) { depthState = new DepthState(false, CompareFunction.LessEqual) }; CustomPassUtils.DrawRenderers(context, videoObjectMask, overrideRenderState: renderState); }
protected override void Execute(CustomPassContext ctx) { if (!ctx.hdCamera.frameSettings.IsEnabled(FrameSettingsField.ObjectMotionVectors) || !ctx.hdCamera.frameSettings.IsEnabled(FrameSettingsField.OpaqueObjects)) { Debug.Log("Motion Vectors are disabled on the camera!"); return; } SyncRenderTextureAspect(motionVectorTexture, ctx.hdCamera.camera); var tags = new ShaderTagId("MotionVectors"); var motionVectorRendererListDesc = new RendererListDesc(tags, ctx.cullingResults, ctx.hdCamera.camera) { rendererConfiguration = PerObjectData.MotionVectors, renderQueueRange = RenderQueueRange.all, sortingCriteria = SortingCriteria.BackToFront, excludeObjectMotionVectors = false, layerMask = renderingMask }; if (ctx.hdCamera.msaaSamples != MSAASamples.None) { CoreUtils.SetRenderTarget(ctx.cmd, new RenderTargetIdentifier[] { dummy.colorBuffer, motionVectorTexture }, dummy.depthBuffer, ClearFlag.All); } else { CoreUtils.SetRenderTarget(ctx.cmd, new RenderTargetIdentifier[] { motionVectorTexture }, motionVectorTexture.depthBuffer, ClearFlag.All); } RendererList motionVectorsRendererList = RendererList.Create(motionVectorRendererListDesc); CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, motionVectorsRendererList); }
void DrawObjectToFurify(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) { var result = new RendererListDesc(shaderTags, cullingResult, hdCamera.camera) { rendererConfiguration = PerObjectData.None, renderQueueRange = RenderQueueRange.all, sortingCriteria = SortingCriteria.BackToFront, excludeObjectMotionVectors = false, overrideMaterial = scatterFurPointsMaterial, overrideMaterialPassIndex = 0, layerMask = furMask, }; scatterFurPointsMaterial.SetBuffer("furData", furData); // CoreUtils.SetRenderTarget(cmd, furMask, maskDepthBuffer, ClearFlag.All); CoreUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result)); if (furMesh != null && furMaterial != null) { //Update draw arguments: drawArgs[0] = furMesh.GetIndexCount(0); drawArgs[1] = 100; // this is filled by the geometry shader drawArgs[2] = furMesh.GetIndexStart(0); drawArgs[3] = furMesh.GetBaseVertex(0); drawFurBuffer.SetData(drawArgs); furMaterial.SetBuffer("furData", furData); cmd.DrawMeshInstancedIndirect(furMesh, 0, furMaterial, 0, drawFurBuffer); } }
protected override void Execute(CustomPassContext ctx) { // Executed every frame for all the camera inside the pass volume. // The context contains the command buffer to use to enqueue graphics commands. CommandBuffer cmd = ctx.cmd; Camera shadowCamera = ctx.hdCamera.camera; cmd.SetGlobalTexture("_SelfShadowTexture", m_MainLightShadowmapTexture); CoreUtils.SetRenderTarget(cmd, m_MainLightShadowmapTexture, ClearFlag.All, Color.black); var renstateBlock = new RenderStateBlock(RenderStateMask.Depth) { depthState = new DepthState(true, CompareFunction.LessEqual), stencilState = new StencilState(false), }; var hairResult = new RendererListDesc(new ShaderTagId("DepthOnly"), ctx.cullingResults, shadowCamera) { rendererConfiguration = PerObjectData.None, renderQueueRange = RenderQueueRange.all, // to change sortingCriteria = SortingCriteria.BackToFront, excludeObjectMotionVectors = false, overrideMaterial = shadowMaterial, overrideMaterialPassIndex = (shadowMaterial != null) ? shadowMaterial.FindPass("DepthOnly") : 0, stateBlock = renstateBlock, layerMask = hairLayerMask, }; CoreUtils.DrawRendererList(ctx.renderContext, cmd, RendererList.Create(hairResult)); }
protected override void Execute(CustomPassContext ctx) { #region Draw Vertex Color // use MRT to render JTRP Shader after Opaque / Sky // CoreUtils.SetRenderTarget(ctx.cmd, _customBuffer); // CoreUtils.ClearRenderTarget(ctx.cmd, ClearFlag.Color, Color.white); // // CoreUtils.SetRenderTarget(ctx.cmd, new RenderTargetIdentifier[] {ctx.cameraColorBuffer, _customBuffer}, // ctx.cameraDepthBuffer); #endregion // render PP to tempBuffer and zhen copy back to cameraColor if (enablePPOutline) { SetupPPTempBuffer(ctx); CoreUtils.SetRenderTarget(ctx.cmd, _postProcessTempBuffer, ctx.cameraDepthBuffer); CoreUtils.ClearRenderTarget(ctx.cmd, ClearFlag.Color, Color.blue); DoPPOutline(ctx); BlitToCameraColorTexture(ctx, _postProcessTempBuffer); } // draw opaque var resultJTRPOpaque = new RendererListDesc(new ShaderTagId("JTRPLitToon"), ctx.cullingResults, ctx.hdCamera.camera) { rendererConfiguration = (PerObjectData) 2047, // all renderQueueRange = RenderQueueRange.opaque, sortingCriteria = SortingCriteria.CommonOpaque }; SetRenderTargetAuto(ctx.cmd); CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, RendererList.Create(resultJTRPOpaque)); // Procedural Geometry Outline if (enableGeometryOutline) { if (enable3XDepth) { Setup3XDepthBuffer(); CoreUtils.SetRenderTarget(ctx.cmd, _depthBuffer, _depthBuffer); CoreUtils.ClearRenderTarget(ctx.cmd, ClearFlag.Depth, Color.black); var resultOpaqueDepthOnly = new RendererListDesc(new ShaderTagId("DepthOnly"), ctx.cullingResults, ctx.hdCamera.camera) { rendererConfiguration = (PerObjectData) 2047, // all renderQueueRange = RenderQueueRange.opaque, sortingCriteria = SortingCriteria.CommonOpaque }; CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, RendererList.Create(resultOpaqueDepthOnly)); SetRenderTargetAuto(ctx.cmd); Shader.SetGlobalTexture(_camera3XDepthTexture, _depthBuffer); } DoGeometryOutline(ctx); } }
/// <summary> /// Execute the DrawRenderers with parameters setup from the editor /// </summary> /// <param name="ctx">The context of the custom pass. Contains command buffer, render context, buffer, etc.</param> protected override void Execute(CustomPassContext ctx) { var shaderPasses = GetShaderTagIds(); if (overrideMaterial != null) { shaderPasses[shaderPasses.Length - 1] = new ShaderTagId(overrideMaterialPassName); overrideMaterial.SetFloat(fadeValueId, fadeValue); } if (shaderPasses.Length == 0) { Debug.LogWarning("Attempt to call DrawRenderers with an empty shader passes. Skipping the call to avoid errors"); return; } var mask = overrideDepthState ? RenderStateMask.Depth : 0; mask |= overrideDepthState && !depthWrite ? RenderStateMask.Stencil : 0; var stateBlock = new RenderStateBlock(mask) { depthState = new DepthState(depthWrite, depthCompareFunction), // We disable the stencil when the depth is overwritten but we don't write to it, to prevent writing to the stencil. stencilState = new StencilState(false), }; PerObjectData renderConfig = ctx.hdCamera.frameSettings.IsEnabled(FrameSettingsField.Shadowmask) ? HDUtils.GetBakedLightingWithShadowMaskRenderConfig() : HDUtils.GetBakedLightingRenderConfig(); var result = new RendererUtils.RendererListDesc(shaderPasses, ctx.cullingResults, ctx.hdCamera.camera) { rendererConfiguration = renderConfig, renderQueueRange = GetRenderQueueRange(renderQueueType), sortingCriteria = sortingCriteria, excludeObjectMotionVectors = false, overrideMaterial = overrideMaterial, overrideMaterialPassIndex = (overrideMaterial != null) ? overrideMaterial.FindPass(overrideMaterialPassName) : 0, stateBlock = stateBlock, layerMask = layerMask, }; var renderCtx = ctx.renderContext; CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, renderCtx.CreateRendererList(result)); }
public SRP0802_BasePassData Render_SRP0802_BasePass(Camera camera, RenderGraph graph, CullingResults cull) { using (var builder = graph.AddRenderPass <SRP0802_BasePassData>("Base Pass", out var passData, new ProfilingSampler("Base Pass Profiler"))) { //Textures - Multi-RenderTarget TextureHandle Albedo = CreateColorTexture(graph, camera, "Albedo"); passData.m_Albedo = builder.UseColorBuffer(Albedo, 0); TextureHandle Emission = CreateColorTexture(graph, camera, "Emission"); passData.m_Emission = builder.UseColorBuffer(Emission, 1); TextureHandle Depth = CreateDepthTexture(graph, camera); passData.m_Depth = builder.UseDepthBuffer(Depth, DepthAccess.Write); //Renderers UnityEngine.Rendering.RendererUtils.RendererListDesc rendererDesc_base_Opaque = new UnityEngine.Rendering.RendererUtils.RendererListDesc(m_PassName1, cull, camera); rendererDesc_base_Opaque.sortingCriteria = SortingCriteria.CommonOpaque; rendererDesc_base_Opaque.renderQueueRange = RenderQueueRange.opaque; RendererListHandle rHandle_base_Opaque = graph.CreateRendererList(rendererDesc_base_Opaque); passData.m_renderList_opaque = builder.UseRendererList(rHandle_base_Opaque); UnityEngine.Rendering.RendererUtils.RendererListDesc rendererDesc_base_Transparent = new UnityEngine.Rendering.RendererUtils.RendererListDesc(m_PassName1, cull, camera); rendererDesc_base_Transparent.sortingCriteria = SortingCriteria.CommonTransparent; rendererDesc_base_Transparent.renderQueueRange = RenderQueueRange.transparent; RendererListHandle rHandle_base_Transparent = graph.CreateRendererList(rendererDesc_base_Transparent); passData.m_renderList_transparent = builder.UseRendererList(rHandle_base_Transparent); //Builder builder.SetRenderFunc((SRP0802_BasePassData data, RenderGraphContext context) => { //Skybox - this will draw to the first target, i.e. Albedo if (camera.clearFlags == CameraClearFlags.Skybox) { context.renderContext.DrawSkybox(camera); } CoreUtils.DrawRendererList(context.renderContext, context.cmd, data.m_renderList_opaque); CoreUtils.DrawRendererList(context.renderContext, context.cmd, data.m_renderList_transparent); }); return(passData); } }
protected override void Execute(CustomPassContext ctx) { PerObjectData renderConfig = PerObjectData.LightProbe | PerObjectData.Lightmaps | PerObjectData.LightProbeProxyVolume; if (ctx.hdCamera.frameSettings.IsEnabled(FrameSettingsField.Shadowmask)) { renderConfig |= PerObjectData.OcclusionProbe | PerObjectData.OcclusionProbeProxyVolume | PerObjectData.ShadowMask; } // We use a different HDRP shader passes for depth prepass (where we write depth + normal) and forward (were we only write color) bool isDepthNormal = injectionPoint == CustomPassInjectionPoint.AfterOpaqueDepthAndNormal; var ids = isDepthNormal ? depthPrepassIds : forwardIds; var result = new RendererListDesc(ids, ctx.cullingResults, ctx.hdCamera.camera) { rendererConfiguration = renderConfig, renderQueueRange = GetRenderQueueRange(RenderQueueType.AllOpaque), sortingCriteria = SortingCriteria.CommonOpaque, excludeObjectMotionVectors = false, layerMask = layerMask, }; if (isDepthNormal) { // Bind normal + depth buffer CoreUtils.SetRenderTarget(ctx.cmd, ctx.cameraNormalBuffer, ctx.cameraDepthBuffer, ClearFlag.None); // Enable keyword to write normal in the depth pre-pass CoreUtils.SetKeyword(ctx.cmd, "WRITE_NORMAL_BUFFER", true); } // Render all the opaque objects in the layer CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, RendererList.Create(result)); if (isDepthNormal) { // Reset the keyword to it's default value CoreUtils.SetKeyword(ctx.cmd, "WRITE_NORMAL_BUFFER", ctx.hdCamera.frameSettings.litShaderMode == LitShaderMode.Forward); } }
void DrawOutlineMeshes(CustomPassContext ctx) { // TODO: see how we can render objects without lights here. // Their rendered color is compared to black to find the outline... black on black... var result = new RendererListDesc(shaderTags, ctx.cullingResults, ctx.hdCamera.camera) { // We need the lighting render configuration to support rendering lit objects rendererConfiguration = PerObjectData.LightProbe | PerObjectData.LightProbeProxyVolume | PerObjectData.Lightmaps, renderQueueRange = RenderQueueRange.all, sortingCriteria = SortingCriteria.BackToFront, excludeObjectMotionVectors = false, layerMask = outlineLayer, overrideMaterial = fullscreenOutline, overrideMaterialPassIndex = 0 }; CoreUtils.SetRenderTarget(ctx.cmd, outlineBuffer, ctx.cameraDepthBuffer, ClearFlag.Color, new Color(99.0f, 99.0f, 99.0f) // clear target with a big number, hopefully bigger than anything. Next compare if <, instead of > ); CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, RendererList.Create(result)); }
protected override void Execute(CustomPassContext ctx) { // This pass doesn't work with scene views if (ctx.hdCamera.camera.cameraType == CameraType.SceneView) { return; } CustomPassUtils.GaussianBlur(ctx, ctx.cameraColorBuffer, ctx.cameraColorBuffer, downSampleBuffer, radius: blurRadius); ShaderTagId[] litForwardTags = { HDShaderPassNames.s_ForwardOnlyName, HDShaderPassNames.s_ForwardName, HDShaderPassNames.s_SRPDefaultUnlitName }; var result = new RendererListDesc(litForwardTags, ctx.cullingResults, ctx.hdCamera.camera) { rendererConfiguration = PerObjectData.None, renderQueueRange = RenderQueueRange.transparent, sortingCriteria = SortingCriteria.CommonTransparent, excludeObjectMotionVectors = false, layerMask = uiLayer, }; CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, RendererList.Create(result)); }
void ExecuteNormalBufferBlur(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, RTHandle cameraColor, RTHandle cameraDepth, RTHandle cameraNormal, CullingResults cullingResults) { if (!EnsureMaterial(ref passMaterial, NAME_SHADER)) { return; } if (layerMask == 0) { return; } if (!hdCamera.frameSettings.IsEnabled(FrameSettingsField.Decals)) { return; } int bufferW = cameraColor.rt.width; int bufferH = cameraColor.rt.height; // allocate temporary buffers cmd.GetTemporaryRT(rtRegions, bufferW, bufferH, (int)DepthBits.None, FilterMode.Point, RenderTextureFormat.R8, RenderTextureReadWrite.Linear, 1, false); cmd.GetTemporaryRT(rtDecoded, bufferW, bufferH, (int)DepthBits.None, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear, 1, false); // render decals to mark blur regions CoreUtils.SetRenderTarget(cmd, rtRegions, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, cameraDepth, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store, ClearFlag.Color, Color.white ); CoreUtils.SetViewport(cmd, cameraDepth); RendererListDesc renderListDesc = new RendererListDesc(NAME_PASS_REPLACE_TAG, cullingResults, hdCamera.camera) { rendererConfiguration = PerObjectData.None, renderQueueRange = GetRenderQueueRange(queue), sortingCriteria = SortingCriteria.None, layerMask = layerMask, overrideMaterial = passMaterial, overrideMaterialPassIndex = PASS_MARK, stateBlock = null, excludeObjectMotionVectors = false, }; #if UNITY_2021_2_OR_NEWER CoreUtils.DrawRendererList(renderContext, cmd, renderContext.CreateRendererList(renderListDesc)); #elif UNITY_2020_2_OR_NEWER CoreUtils.DrawRendererList(renderContext, cmd, RendererList.Create(renderListDesc)); #else HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(renderListDesc)); #endif // decode normal buffer in marked regions CoreUtils.SetRenderTarget(cmd, rtDecoded, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, cameraDepth, RenderBufferLoadAction.Load, RenderBufferStoreAction.DontCare, ClearFlag.None ); CoreUtils.SetViewport(cmd, cameraDepth); cmd.SetRandomWriteTarget(2, cameraNormal); cmd.DrawProcedural(Matrix4x4.identity, passMaterial, PASS_DECODE, MeshTopology.Triangles, 3, 1); cmd.ClearRandomWriteTargets(); // blur and re-encode normals in marked regions cmd.SetGlobalTexture(rtRegions, rtRegions); cmd.SetGlobalTexture(rtDecoded, rtDecoded); if (dbufferNormalMaskRTIDs != null) { CoreUtils.SetRenderTarget(cmd, dbufferNormalMaskRTIDs, cameraDepth, ClearFlag.None); CoreUtils.SetViewport(cmd, cameraDepth); cmd.SetRandomWriteTarget(2, cameraNormal); cmd.DrawProcedural(Matrix4x4.identity, passMaterial, PASS_BLUR_AND_ENCODE_AND_DECAL, MeshTopology.Triangles, 3, 1); cmd.ClearRandomWriteTargets(); } else { CoreUtils.SetRenderTarget(cmd, cameraDepth, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store, ClearFlag.None ); CoreUtils.SetViewport(cmd, cameraDepth); cmd.SetRandomWriteTarget(2, cameraNormal); cmd.DrawProcedural(Matrix4x4.identity, passMaterial, PASS_BLUR_AND_ENCODE, MeshTopology.Triangles, 3, 1); cmd.ClearRandomWriteTargets(); } // free temporary buffers cmd.ReleaseTemporaryRT(rtRegions); cmd.ReleaseTemporaryRT(rtDecoded); }
// TODO // 1.Draw hair vertex color to custom mask buffer // 2.Draw face with hair buffer and shadow map protected override void Execute(CustomPassContext ctx) { var renderCtx = ctx.renderContext; // Draw Vertex Color Mask CoreUtils.SetRenderTarget(ctx.cmd, _customBuffer); CoreUtils.ClearRenderTarget(ctx.cmd, ClearFlag.Color, Color.black); var resultJTRPMask = new RendererListDesc(_shaderTagId_JTRPMask, ctx.cullingResults, ctx.hdCamera.camera) { rendererConfiguration = PerObjectData.None, renderQueueRange = RenderQueueRange.all, sortingCriteria = SortingCriteria.CommonTransparent, // layerMask = LayerMask.GetMask("Hair"), }; CoreUtils.DrawRendererList(renderCtx, ctx.cmd, renderCtx.CreateRendererList(resultJTRPMask)); // Draw UTS Face SetRenderTargetAuto(ctx.cmd); ctx.cmd.SetGlobalTexture(_jtrpMask_Map, _customBuffer); var resultJTRPFace = new RendererListDesc(_shaderTagId_JTRPFace, ctx.cullingResults, ctx.hdCamera.camera) { rendererConfiguration = (PerObjectData)2047, // all renderQueueRange = RenderQueueRange.all, sortingCriteria = SortingCriteria.CommonTransparent, // layerMask = LayerMask.GetMask("Face"), }; CoreUtils.DrawRendererList(renderCtx, ctx.cmd, renderCtx.CreateRendererList(resultJTRPFace)); // render PP to tempBuffer and zhen copy back to cameraColor if (enablePPOutline) { SetupPPTempBuffer(ctx); CoreUtils.SetRenderTarget(ctx.cmd, _postProcessTempBuffer, ctx.cameraDepthBuffer); CoreUtils.ClearRenderTarget(ctx.cmd, ClearFlag.Color, Color.blue); DoPPOutline(ctx); BlitToCameraColorTexture(ctx, _postProcessTempBuffer); } // Procedural Geometry Outline if (enableGeometryOutline) { if (enable3XDepth) { Setup3XDepthBuffer(); CoreUtils.SetRenderTarget(ctx.cmd, _depthBuffer, _depthBuffer); CoreUtils.ClearRenderTarget(ctx.cmd, ClearFlag.Depth, Color.black); var resultOpaqueDepthOnly = new RendererListDesc(new ShaderTagId("DepthOnly"), ctx.cullingResults, ctx.hdCamera.camera) { rendererConfiguration = (PerObjectData)2047, // all renderQueueRange = RenderQueueRange.opaque, sortingCriteria = SortingCriteria.CommonOpaque }; CoreUtils.DrawRendererList(renderCtx, ctx.cmd, renderCtx.CreateRendererList(resultOpaqueDepthOnly)); SetRenderTargetAuto(ctx.cmd); Shader.SetGlobalTexture(_camera3XDepthTexture, _depthBuffer); } DoGeometryOutline(ctx); } // Set BackFace Outline Shader.SetGlobalFloat("_JTRP_Enable_Global_BackFace_Outline", enableBackFaceOutline ? 1 : 0); }