/// <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)
{
// 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 RendererListDesc CreateRendererListDesc(Camera camera, CullingResults cullingResult, string overrideMaterialPassName, int overrideMaterialPassIndex, Material overrideMaterial, LayerMask layerMask /*, PerObjectData perObjectData*/)
{
var shaderPasses = new[]
{
new ShaderTagId("Forward"), // HD Lit shader
new ShaderTagId("ForwardOnly"), // HD Unlit shader
new ShaderTagId("SRPDefaultUnlit"), // Cross SRP Unlit shader
new ShaderTagId("UniversalForward"), // URP Forward
new ShaderTagId("LightweightForward"), // LWRP Forward
new ShaderTagId(overrideMaterialPassName), // The override material shader
};
var stateBlock = new RenderStateBlock(0)
{
depthState = new DepthState(true, CompareFunction.LessEqual),
};
var result = new RendererListDesc(shaderPasses, cullingResult, camera)
{
rendererConfiguration = PerObjectData.None,
renderQueueRange = new RenderQueueRange {
lowerBound = 0, upperBound = 5000
},
sortingCriteria = SortingCriteria.CommonOpaque,
excludeObjectMotionVectors = false,
overrideMaterial = overrideMaterial,
overrideMaterialPassIndex = overrideMaterialPassIndex,
stateBlock = stateBlock,
layerMask = layerMask,
};
return(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));
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(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);
}
// 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);
}
}
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));
}
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);
}
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();
}
}
///////////Mesh Batch
public static RendererListDesc CreateRendererListDesc(CullingResults CullingData, Camera RenderCamera, ShaderTagId PassName, PerObjectData rendererConfiguration = 0, RenderQueueRange?renderQueueRange = null, RenderStateBlock?stateBlock = null, Material overrideMaterial = null, bool excludeObjectMotionVectors = false)
{
RendererListDesc result = new RendererListDesc(PassName, CullingData, RenderCamera)
{
rendererConfiguration = rendererConfiguration,
renderQueueRange = RenderQueueRange.opaque,
sortingCriteria = SortingCriteria.CommonOpaque,
stateBlock = stateBlock,
overrideMaterial = overrideMaterial,
excludeObjectMotionVectors = excludeObjectMotionVectors
};
return(result);
}
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));
}
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
RendererListDesc rendererDesc_base_Opaque = new 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);
RendererListDesc rendererDesc_base_Transparent = new 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);
}
}
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));
}
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);
}
/// <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));
}
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);
}
