// 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 UnityEngine.Rendering.RendererUtils.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, context.renderContext.CreateRendererList(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 UnityEngine.Rendering.RendererUtils.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, renderContext.CreateRendererList(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 UnityEngine.Rendering.RendererUtils.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);
}
CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, ctx.renderContext.CreateRendererList(motionVectorRendererListDesc));
}
public unsafe RendererList CreateRendererList(RendererUtils.RendererListDesc desc)
{
Validate();
RendererListParams param = RendererUtils.RendererListDesc.ConvertToParameters(desc);
var list = CreateRendererList(ref param);
param.Dispose();
return(list);
}
// RendererList public API
public unsafe RendererUtils.RendererList CreateRendererList(RendererUtils.RendererListDesc desc)
{
Validate();
RendererUtils.RendererListParams param = RendererUtils.RendererListParams.Create(desc);
if (param.stateBlock == null)
{
return(CreateRendererList_Internal(param.cullingResult.ptr, ref param.drawSettings, ref param.filteringSettings, ShaderTagId.none, false, IntPtr.Zero, IntPtr.Zero, 0));
}
else
{
var renderType = new ShaderTagId();
var renderStateBlock = param.stateBlock.Value;
RenderStateBlock *stateBlockPtr = &renderStateBlock;
{
return(CreateRendererList_Internal(param.cullingResult.ptr, ref param.drawSettings, ref param.filteringSettings, ShaderTagId.none, false, (IntPtr)(&renderType), (IntPtr)stateBlockPtr, 1));
}
}
}
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 UnityEngine.Rendering.RendererUtils.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, ctx.renderContext.CreateRendererList(result));
if (isDepthNormal)
{
// Reset the keyword to it's default value
CoreUtils.SetKeyword(ctx.cmd, "WRITE_NORMAL_BUFFER", ctx.hdCamera.frameSettings.litShaderMode == LitShaderMode.Forward);
}
}
