void RenderOpaqueDepth(Camera RenderCamera, FCullingData CullingData, CullingResults CullingResult) { //Request Resource RendererList RenderList = RendererList.Create(CreateRendererListDesc(CullingResult, RenderCamera, InfinityPassIDs.OpaqueDepth, new RenderQueueRange(2450, 2999))); RDGTextureDesc DepthDesc = new RDGTextureDesc(Screen.width, Screen.height) { clearBuffer = true, dimension = TextureDimension.Tex2D, enableMSAA = false, bindTextureMS = false, name = "DepthTexture", depthBufferBits = EDepthBits.Depth32 }; RDGTextureRef DepthTexture = GraphBuilder.ScopeTexture(InfinityShaderIDs.DepthBuffer, DepthDesc); //Add OpaqueDepthPass GraphBuilder.AddPass <FOpaqueDepthData>("OpaqueDepth", ProfilingSampler.Get(CustomSamplerId.OpaqueDepth), (ref FOpaqueDepthData PassData, ref RDGPassBuilder PassBuilder) => { PassData.RendererList = RenderList; PassData.DepthBuffer = PassBuilder.UseDepthBuffer(DepthTexture, EDepthAccess.ReadWrite); DepthPassMeshProcessor.DispatchGather(CullingData, new FMeshPassDesctiption(2450, 2999)); }, (ref FOpaqueDepthData PassData, RDGContext GraphContext) => { RendererList DepthRenderList = PassData.RendererList; DepthRenderList.drawSettings.sortingSettings = new SortingSettings(RenderCamera) { criteria = SortingCriteria.QuantizedFrontToBack }; DepthRenderList.drawSettings.enableInstancing = RenderPipelineAsset.EnableInstanceBatch; DepthRenderList.drawSettings.enableDynamicBatching = RenderPipelineAsset.EnableDynamicBatch; DepthRenderList.filteringSettings.renderQueueRange = new RenderQueueRange(2450, 2999); GraphContext.RenderContext.DrawRenderers(DepthRenderList.cullingResult, ref DepthRenderList.drawSettings, ref DepthRenderList.filteringSettings); //MeshDrawPipeline DepthPassMeshProcessor.DispatchDraw(GraphContext, 1); }); }
protected override void ExecutePass(ScriptableRenderContext renderContext, CommandBuffer cmd, Camera camera, CullingResults cullingResult) { var renderList = CreateRendererListDesc(camera, cullingResult, "FirstPass", 0, m_OverrideMaterial, -1); cmd.ClearRenderTarget(true, true, Color.clear); DrawRendererList(renderContext, cmd, RendererList.Create(renderList)); }
/// <summary> /// Execute the DrawRenderers with parameters setup from the editor /// </summary> /// <param name="renderContext"></param> /// <param name="cmd"></param> /// <param name="camera"></param> /// <param name="cullingResult"></param> protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) { ShaderTagId[] shaderPasses = new ShaderTagId[hdrpShaderTags.Count + ((overrideMaterial != null) ? 1 : 0)]; System.Array.Copy(hdrpShaderTags.ToArray(), shaderPasses, hdrpShaderTags.Count); if (overrideMaterial != null) { shaderPasses[hdrpShaderTags.Count] = new ShaderTagId(overrideMaterial.GetPassName(overrideMaterialPassIndex)); 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 stateBlock = new RenderStateBlock(overrideDepthState ? RenderStateMask.Depth : 0) { depthState = new DepthState(depthWrite, depthCompareFunction), }; var result = new RendererListDesc(shaderPasses, cullingResult, hdCamera.camera) { rendererConfiguration = PerObjectData.None, renderQueueRange = GetRenderQueueRange(renderQueueType), sortingCriteria = sortingCriteria, excludeObjectMotionVectors = false, overrideMaterial = (overrideMaterial != null) ? overrideMaterial : defaultOverrideMaterial, overrideMaterialPassIndex = (overrideMaterial != null) ? overrideMaterialPassIndex : 0, stateBlock = stateBlock, layerMask = layerMask, }; HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result)); }
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(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) { CoreUtils.SetRenderTarget(cmd, bloomDistortionBuffer, ClearFlag.Color); var resultOpaque = new RendererListDesc(new ShaderTagId("BloomDistortion"), cullingResult, hdCamera.camera) { rendererConfiguration = PerObjectData.None, renderQueueRange = RenderQueueRange.opaque, sortingCriteria = SortingCriteria.CommonOpaque, excludeObjectMotionVectors = false, overrideMaterialPassIndex = 0, // layerMask = layer, }; var resultTransparent = new RendererListDesc(new ShaderTagId("BloomDistortion"), cullingResult, hdCamera.camera) { rendererConfiguration = PerObjectData.None, renderQueueRange = RenderQueueRange.transparent, sortingCriteria = SortingCriteria.CommonTransparent, excludeObjectMotionVectors = false, overrideMaterialPassIndex = 0, // layerMask = layer, }; HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(resultOpaque)); HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(resultTransparent)); // SetCameraRenderTarget(cmd); // HDUtils.BlitTexture(cmd, bloomDistortionBuffer, new Vector4(1, 1, 0, 0), 0, false); }
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); } }
// 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); }
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)); }
/// <summary> /// Execute the DrawRenderers with parameters setup from the editor /// </summary> /// <param name="renderContext"></param> /// <param name="cmd"></param> /// <param name="camera"></param> /// <param name="cullingResult"></param> protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) { ShaderTagId[] shaderPasses = new ShaderTagId[hdrpShaderTags.Count + ((overrideMaterial != null) ? 1 : 0)]; System.Array.Copy(hdrpShaderTags.ToArray(), shaderPasses, hdrpShaderTags.Count); if (overrideMaterial != null) { shaderPasses[hdrpShaderTags.Count] = new ShaderTagId(overrideMaterial.GetPassName(overrideMaterialPassIndex)); } if (shaderPasses.Length == 0) { Debug.LogWarning("Attempt to call DrawRenderers with an empty shader passes. Skipping the call to avoid errors"); return; } var result = new RendererListDesc(shaderPasses, cullingResult, hdCamera.camera) { rendererConfiguration = PerObjectData.None, renderQueueRange = GetRenderQueueRange(renderQueueType), sortingCriteria = sortingCriteria, excludeObjectMotionVectors = true, overrideMaterial = overrideMaterial, overrideMaterialPassIndex = overrideMaterialPassIndex, layerMask = layerMask, }; HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result)); }
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); }
protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) { if (blurMaterial == null) { Debug.LogError("Failed to load Liquid Pass Shaders"); return; } var result = new RendererListDesc(shaderTags, cullingResult, hdCamera.camera) { rendererConfiguration = PerObjectData.None, renderQueueRange = RenderQueueRange.all, sortingCriteria = SortingCriteria.BackToFront, excludeObjectMotionVectors = false, layerMask = layerMask.value, }; // Render objects into the custom buffer: HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result)); // Blur the custom buffer: BlurCustomBuffer(cmd, hdCamera); // Composite the result into the camera color buffer SetCameraRenderTarget(cmd); int pass = transparentFullscreenShader.FindPass("Forward"); if (pass == -1) { pass = transparentFullscreenShader.FindPass("ForwardOnly"); } CoreUtils.DrawFullScreen(cmd, blurMaterial, pass); }
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); } }
protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) { if (injectionPoint != CustomPassInjectionPoint.AfterPostProcess) { Debug.LogError("CustomPassInjectionPoint shouild be set on AfterPostProcess"); return; } if (render && hdCamera.camera != bakeCamera && hdCamera.camera.cameraType != CameraType.SceneView) { bakeCamera.TryGetCullingParameters(out var cullingParams); cullingParams.cullingOptions = CullingOptions.ShadowCasters; cullingResult = renderContext.Cull(ref cullingParams); var result = new RendererListDesc(shaderTags, cullingResult, bakeCamera) { rendererConfiguration = PerObjectData.None, //renderQueueRange = RenderQueueRange.all, renderQueueRange = GetRenderQueueRange(RenderQueueType.AllOpaque), sortingCriteria = SortingCriteria.BackToFront, excludeObjectMotionVectors = false, layerMask = -1, overrideMaterial = depthMaterial, overrideMaterialPassIndex = depthMaterial.FindPass("ForwardOnly"), }; //renderContext.StereoEndRender(hdCamera.camera); renderContext.ExecuteCommandBuffer(cmd); cmd.Clear(); renderContext.StopMultiEye(hdCamera.camera); var p = GL.GetGPUProjectionMatrix(bakeCamera.projectionMatrix, true); Matrix4x4 scaleMatrix = Matrix4x4.identity; scaleMatrix.m22 = -1.0f; var v = scaleMatrix * bakeCamera.transform.localToWorldMatrix.inverse; var vp = p * v; cmd.SetGlobalMatrix("_ViewMatrix", v); cmd.SetGlobalMatrix("_InvViewMatrix", v.inverse); cmd.SetGlobalMatrix("_ProjMatrix", p); cmd.SetGlobalMatrix("_InvProjMatrix", p.inverse); cmd.SetGlobalMatrix("_ViewProjMatrix", vp); cmd.SetGlobalMatrix("_InvViewProjMatrix", vp.inverse); cmd.SetGlobalMatrix("_CameraViewProjMatrix", vp); cmd.SetGlobalVector("_WorldSpaceCameraPos", Vector3.zero); cmd.SetGlobalVector("_ShadowClipPlanes", Vector3.zero); CoreUtils.SetRenderTarget(cmd, depthFromCam, ClearFlag.All); HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result)); renderContext.StartMultiEye(hdCamera.camera); renderContext.ExecuteCommandBuffer(cmd); cmd.Clear(); } }
//Render all objects to our target RenderTexture using `overrideMaterial` to use our shader protected override void ExecutePass(ScriptableRenderContext renderContext, CommandBuffer cmd, Camera camera, CullingResults cullingResult) { using (s_ExecuteMarker.Auto()) { cmd.ClearRenderTarget(true, true, Color.black); var result = CreateRendererListDesc(camera, cullingResult, "FirstPass", 0, m_OverrideMaterial, layerMask); DrawRendererList(renderContext, cmd, RendererList.Create(result)); } }
protected override void ExecutePass(ScriptableRenderContext renderContext, CommandBuffer cmd, Camera camera, CullingResults cullingResult) { if (s_LastFrameExecuted == Time.frameCount) { return; } s_LastFrameExecuted = Time.frameCount; var renderList = CreateRendererListDesc(camera, cullingResult, "FirstPass", 0, m_OverrideMaterial, -1); cmd.ClearRenderTarget(true, true, Color.black); DrawRendererList(renderContext, cmd, RendererList.Create(renderList)); }
protected override void ExecutePass(ScriptableRenderContext renderContext, CommandBuffer cmd, Camera camera, CullingResults cullingResult) { if (s_LastFrameExecuted == Time.frameCount) { Debug.LogError("Semantic segmentation was run twice in the same frame. Multiple semantic segmentations are not currently supported."); } s_LastFrameExecuted = Time.frameCount; var renderList = CreateRendererListDesc(camera, cullingResult, "FirstPass", 0, m_OverrideMaterial, -1); cmd.ClearRenderTarget(true, true, Color.black); DrawRendererList(renderContext, cmd, RendererList.Create(renderList)); }
void DrawOutlineMeshes(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) { var result = new RendererListDesc(shaderTags, cullingResult, 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, }; CoreUtils.SetRenderTarget(cmd, outlineBuffer, ClearFlag.Color); HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result)); }
void DrawMaskObjects(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) { // 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, layerMask = maskLayer, }; CoreUtils.SetRenderTarget(cmd, maskBuffer, maskDepthBuffer, ClearFlag.All); HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result)); }
protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera camera, CullingResults cullingResult) { for (int i = 0; i < cameras.Length; i++) { Camera bakingCamera = cameras[i]; RenderTexture targetTexture = bakingCamera.targetTexture; ScriptableCullingParameters cullingParams; bakingCamera.TryGetCullingParameters(out cullingParams); cullingParams.cullingOptions = CullingOptions.ShadowCasters; cullingResult = renderContext.Cull(ref cullingParams); var result = new RendererListDesc(shaderTags, cullingResult, bakingCamera) { rendererConfiguration = PerObjectData.None, renderQueueRange = RenderQueueRange.all, sortingCriteria = SortingCriteria.BackToFront, excludeObjectMotionVectors = false, layerMask = -1, }; Matrix4x4 cameraProjMatrix = cameras[0].projectionMatrix; //cameraProjMatrix.m22 *= -1; //cameraProjMatrix.m23 *= -1; //cameraProjMatrix.m32 *= -1; //bakingCamera.projectionMatrix = cameraProjMatrix; //var p = cameraProjMatrix; var p = GL.GetGPUProjectionMatrix(cameraProjMatrix, true); //Debug.Log(p); //Debug.Log(cameraProjMatrix); Matrix4x4 scaleMatrix = Matrix4x4.identity; scaleMatrix.m22 = -1.0f; var v = scaleMatrix * bakingCamera.transform.localToWorldMatrix.inverse; var vp = p * v; cmd.SetGlobalMatrix("_ViewMatrix", v); cmd.SetGlobalMatrix("_InvViewMatrix", v.inverse); cmd.SetGlobalMatrix("_ProjMatrix", p); cmd.SetGlobalMatrix("_InvProjMatrix", p.inverse); cmd.SetGlobalMatrix("_ViewProjMatrix", vp); cmd.SetGlobalMatrix("_InvViewProjMatrix", vp.inverse); cmd.SetGlobalMatrix("_CameraViewProjMatrix", vp); cmd.SetGlobalVector("_WorldSpaceCameraPos", Vector3.zero); CoreUtils.SetRenderTarget(cmd, targetTexture, ClearFlag.Depth); HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result)); } }
protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) { hdCamera.camera.TryGetCullingParameters(out var cullingParams); cullingParams.cullingMask = (uint)1 << LayerMask.NameToLayer("Liquid"); cullingResult = renderContext.Cull(ref cullingParams); var result = new RendererListDesc(shaderTags, cullingResult, hdCamera.camera) { rendererConfiguration = PerObjectData.None, renderQueueRange = RenderQueueRange.all, sortingCriteria = SortingCriteria.BackToFront, excludeObjectMotionVectors = false, layerMask = 1 << LayerMask.NameToLayer("Liquid"), }; HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result)); GenerateGaussianMips(cmd, hdCamera); }
protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) { PerObjectData renderConfig = PerObjectData.LightProbe | PerObjectData.Lightmaps | PerObjectData.LightProbeProxyVolume; if (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, cullingResult, hdCamera.camera) { rendererConfiguration = renderConfig, renderQueueRange = GetRenderQueueRange(RenderQueueType.AllOpaque), sortingCriteria = SortingCriteria.CommonOpaque, excludeObjectMotionVectors = false, layerMask = layerMask, }; if (isDepthNormal) { // Bind normal + depth buffer var normalBuffer = GetNormalBuffer(); GetCameraBuffers(out _, out var depth); CoreUtils.SetRenderTarget(cmd, normalBuffer, depth, ClearFlag.None); // Enable keyword to write normal in the depth pre-pass CoreUtils.SetKeyword(cmd, "WRITE_NORMAL_BUFFER", true); } // Render all the opaque objects in the layer HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result)); if (isDepthNormal) { // Reset the keyword to it's default value CoreUtils.SetKeyword(cmd, "WRITE_NORMAL_BUFFER", hdCamera.frameSettings.litShaderMode == LitShaderMode.Forward); } }
/// <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.k_RendererConfigurationBakedLightingWithShadowMask : HDUtils.k_RendererConfigurationBakedLighting; var result = new 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, }; HDUtils.DrawRendererList(ctx.renderContext, ctx.cmd, RendererList.Create(result)); }
void RenderOpaqueMotion(Camera RenderCamera, CullingResults CullingData) { RenderCamera.depthTextureMode |= DepthTextureMode.MotionVectors | DepthTextureMode.Depth; //Request Resource RendererList RenderList = RendererList.Create(CreateRendererListDesc(CullingData, RenderCamera, InfinityPassIDs.OpaqueMotion)); RDGTextureRef DepthTexture = GraphBuilder.ScopeTexture(InfinityShaderIDs.RT_DepthBuffer); RDGTextureDesc MotionDesc = new RDGTextureDesc(RenderCamera.pixelWidth, RenderCamera.pixelHeight) { clearBuffer = true, dimension = TextureDimension.Tex2D, clearColor = Color.clear, enableMSAA = false, bindTextureMS = false, name = "MotionBufferTexture", colorFormat = GraphicsFormat.R16G16_SFloat }; RDGTextureRef MotionTexture = GraphBuilder.CreateTexture(MotionDesc, InfinityShaderIDs.RT_MotionBuffer); GraphBuilder.ScopeTexture(InfinityShaderIDs.RT_MotionBuffer, MotionTexture); //Add RenderPass GraphBuilder.AddRenderPass <FOpaqueMotionData>("OpaqueMotion", ProfilingSampler.Get(CustomSamplerId.OpaqueMotion), (ref FOpaqueMotionData PassData, ref RDGPassBuilder PassBuilder) => { PassData.RendererList = RenderList; PassData.MotionBuffer = PassBuilder.UseColorBuffer(MotionTexture, 0); PassData.DepthBuffer = PassBuilder.UseDepthBuffer(DepthTexture, EDepthAccess.Read); }, (ref FOpaqueMotionData PassData, RDGContext GraphContext) => { RendererList MotionRenderList = PassData.RendererList; MotionRenderList.drawSettings.sortingSettings = new SortingSettings(RenderCamera) { criteria = SortingCriteria.CommonOpaque }; MotionRenderList.drawSettings.perObjectData = PerObjectData.MotionVectors; MotionRenderList.drawSettings.enableInstancing = RenderPipelineAsset.EnableInstanceBatch; MotionRenderList.drawSettings.enableDynamicBatching = RenderPipelineAsset.EnableDynamicBatch; MotionRenderList.filteringSettings.renderQueueRange = RenderQueueRange.opaque; MotionRenderList.filteringSettings.excludeMotionVectorObjects = false; GraphContext.RenderContext.DrawRenderers(MotionRenderList.cullingResult, ref MotionRenderList.drawSettings, ref MotionRenderList.filteringSettings); }); }
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)); }
/// <summary> /// Execute the DrawRenderers with parameters setup from the editor /// </summary> /// <param name="renderContext"></param> /// <param name="cmd"></param> /// <param name="camera"></param> /// <param name="cullingResult"></param> protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) { var shaderPasses = GetShaderTagIds(); if (overrideMaterial != null) { shaderPasses[forwardShaderTags.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 stateBlock = new RenderStateBlock(overrideDepthState ? RenderStateMask.Depth : 0) { depthState = new DepthState(depthWrite, depthCompareFunction), }; PerObjectData renderConfig = hdCamera.frameSettings.IsEnabled(FrameSettingsField.Shadowmask) ? HDUtils.k_RendererConfigurationBakedLightingWithShadowMask : HDUtils.k_RendererConfigurationBakedLighting; var result = new RendererListDesc(shaderPasses, cullingResult, hdCamera.camera) { rendererConfiguration = renderConfig, renderQueueRange = GetRenderQueueRange(renderQueueType), sortingCriteria = sortingCriteria, excludeObjectMotionVectors = false, overrideMaterial = overrideMaterial, overrideMaterialPassIndex = (overrideMaterial != null) ? overrideMaterial.FindPass(overrideMaterialPassName) : 0, stateBlock = stateBlock, layerMask = layerMask, }; HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result)); }
protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) { if (compositingMaterial == null || blurMaterial == null) { Debug.LogError("Failed to load Liquid Pass Shaders"); return; } var result = new RendererListDesc(shaderTags, cullingResult, hdCamera.camera) { rendererConfiguration = PerObjectData.None, renderQueueRange = RenderQueueRange.all, sortingCriteria = SortingCriteria.BackToFront, excludeObjectMotionVectors = false, layerMask = layerMask.value, }; // Render objects into the custom buffer: HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result)); // Blur the custom buffer: BlurCustomBuffer(cmd, hdCamera); // Composite the result into the camera color buffer SetCameraRenderTarget(cmd); int pass = transparentFullscreenShader.FindPass("Forward"); if (pass == -1) { pass = transparentFullscreenShader.FindPass("ForwardOnly"); } // Move the mesh to the far plane of the camera float ForwardDistance = hdCamera.camera.nearClipPlane + 0.0001f; cmd.DrawMesh(quad, Matrix4x4.TRS(hdCamera.camera.transform.position + hdCamera.camera.transform.forward * ForwardDistance, hdCamera.camera.transform.rotation, Vector3.one), transparentFullscreenShader, 0, pass); }
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); }
void RenderOpaqueGBuffer(Camera RenderCamera, CullingResults CullingData, NativeArray <FVisibleMeshBatch> VisibleMeshBatchList) { //Request Resource RendererList RenderList = RendererList.Create(CreateRendererListDesc(CullingData, RenderCamera, InfinityPassIDs.OpaqueGBuffer)); RDGTextureRef DepthTexture = GraphBuilder.ScopeTexture(InfinityShaderIDs.RT_DepthBuffer); RDGTextureDesc GBufferDescA = new RDGTextureDesc(RenderCamera.pixelWidth, RenderCamera.pixelHeight) { clearBuffer = true, clearColor = Color.clear, dimension = TextureDimension.Tex2D, enableMSAA = false, bindTextureMS = false, name = "GBufferATexture", colorFormat = GraphicsFormat.R16G16B16A16_UNorm }; RDGTextureDesc GBufferDescB = new RDGTextureDesc(RenderCamera.pixelWidth, RenderCamera.pixelHeight) { clearBuffer = true, clearColor = Color.clear, dimension = TextureDimension.Tex2D, enableMSAA = false, bindTextureMS = false, name = "GBufferBTexture", colorFormat = GraphicsFormat.A2B10G10R10_UIntPack32 }; RDGTextureRef GBufferTextureA = GraphBuilder.CreateTexture(GBufferDescA, InfinityShaderIDs.RT_ThinGBufferA); RDGTextureRef GBufferTextureB = GraphBuilder.CreateTexture(GBufferDescB, InfinityShaderIDs.RT_ThinGBufferB); GraphBuilder.ScopeTexture(InfinityShaderIDs.RT_ThinGBufferA, GBufferTextureA); GraphBuilder.ScopeTexture(InfinityShaderIDs.RT_ThinGBufferB, GBufferTextureB); //Add RenderPass GraphBuilder.AddRenderPass <FOpaqueGBufferData>("OpaqueGBuffer", ProfilingSampler.Get(CustomSamplerId.OpaqueGBuffer), (ref FOpaqueGBufferData PassData, ref RDGPassBuilder PassBuilder) => { PassData.RendererList = RenderList; PassData.GBufferA = PassBuilder.UseColorBuffer(GBufferTextureA, 0); PassData.GBufferB = PassBuilder.UseColorBuffer(GBufferTextureB, 1); PassData.DepthBuffer = PassBuilder.UseDepthBuffer(DepthTexture, EDepthAccess.ReadWrite); }, (ref FOpaqueGBufferData PassData, RDGContext GraphContext) => { //Draw UnityRenderer RendererList GBufferRenderList = PassData.RendererList; GBufferRenderList.drawSettings.perObjectData = PerObjectData.Lightmaps; GBufferRenderList.drawSettings.enableInstancing = RenderPipelineAsset.EnableInstanceBatch; GBufferRenderList.drawSettings.enableDynamicBatching = RenderPipelineAsset.EnableDynamicBatch; GBufferRenderList.filteringSettings.renderQueueRange = new RenderQueueRange(0, 2450); GraphContext.RenderContext.DrawRenderers(GBufferRenderList.cullingResult, ref GBufferRenderList.drawSettings, ref GBufferRenderList.filteringSettings); //Draw CustomRenderer RenderWorld World = GraphContext.World; NativeList <FMeshBatch> MeshBatchList = World.GetMeshBatchColloctor().GetMeshBatchList(); if (VisibleMeshBatchList.Length == 0) { return; } for (int i = 0; i < VisibleMeshBatchList.Length; i++) { FVisibleMeshBatch VisibleMeshBatch = VisibleMeshBatchList[i]; if (VisibleMeshBatch.visible) { FMeshBatch MeshBatch = MeshBatchList[VisibleMeshBatch.index]; Mesh mesh = World.WorldMeshList.Get(MeshBatch.Mesh); Material material = World.WorldMaterialList.Get(MeshBatch.Material); if (mesh && material) { GraphContext.CmdBuffer.DrawMesh(mesh, MeshBatch.Matrix_LocalToWorld, material, MeshBatch.SubmeshIndex, 2); } } } }); }