internal RenderStateBlock GetRenderStateBlock(RenderStateBlock renderStateBlock)
{
DebugSceneOverrideMode sceneOverrideMode = RenderingSettings.debugSceneOverrideMode;
// Potentially override parts of the RenderStateBlock
switch (sceneOverrideMode)
{
case DebugSceneOverrideMode.Overdraw:
{
RenderTargetBlendState additiveBlend = new RenderTargetBlendState(sourceColorBlendMode: BlendMode.One, destinationColorBlendMode: BlendMode.One);
// Additive-blend but leave z-write and culling as they are when we draw normally
renderStateBlock.blendState = new BlendState {
blendState0 = additiveBlend
};
renderStateBlock.mask = RenderStateMask.Blend;
break;
}
case DebugSceneOverrideMode.SolidWireframe:
case DebugSceneOverrideMode.ShadedWireframe:
{
if (m_Index == 1)
{
// Ensure we render the wireframe in front of the solid triangles of the previous pass...
renderStateBlock.rasterState = new RasterState(offsetUnits: -1, offsetFactor: -1);
renderStateBlock.mask = RenderStateMask.Raster;
}
break;
}
}
return(renderStateBlock);
}
public AdditionalUIRenderPass(string profilerTag, RenderPassEvent renderPassEvent, string[] shaderTags, int layerMask,
ClearFlag clearFlag)
{
m_profilerTag = profilerTag;
this.renderPassEvent = renderPassEvent + 2;
m_clearFlag = clearFlag;
var renderQueueRange = RenderQueueRange.all;
m_filteringSettings = new FilteringSettings(renderQueueRange, layerMask);
if (shaderTags != null && shaderTags.Length > 0)
{
foreach (var passName in shaderTags)
{
m_shaderTagIdList.Add(new ShaderTagId(passName));
}
}
else
{
m_shaderTagIdList.Add(new ShaderTagId("UniversalForward"));
m_shaderTagIdList.Add(new ShaderTagId("LightweightForward"));
m_shaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
}
m_renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
}
public RenderLayerObjectPass(string profilerTag, RenderPassEvent renderPassEvent, string[] shaderTags, RenderLayerObjectFeature.RenderQueueType renderQueueType, uint layerMask, RenderLayerObjectFeature.CustomCameraSettings cameraSettings)
{
m_ProfilerTag = profilerTag;
m_ProfilingSampler = new ProfilingSampler(profilerTag);
this.renderPassEvent = renderPassEvent;
this.renderQueueType = renderQueueType;
this.overrideMaterial = null;
this.overrideMaterialPassIndex = 0;
RenderQueueRange renderQueueRange = (renderQueueType == RenderLayerObjectFeature.RenderQueueType.Transparent)
? RenderQueueRange.transparent
: RenderQueueRange.opaque;
m_FilteringSettings = new FilteringSettings(renderQueueRange, -1, layerMask);
if (shaderTags != null && shaderTags.Length > 0)
{
foreach (var passName in shaderTags)
{
m_ShaderTagIdList.Add(new ShaderTagId(passName));
}
}
else
{
m_ShaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
m_ShaderTagIdList.Add(new ShaderTagId("UniversalForward"));
m_ShaderTagIdList.Add(new ShaderTagId("LightweightForward"));
}
m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
m_CameraSettings = cameraSettings;
}
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);
}
public StencilRenderPass(ScreenSpacePlanarReflectionsSettings settings)
{
m_Settings = settings;
m_RenderStateBlock = new RenderStateBlock();
m_RenderStateBlock.mask |= RenderStateMask.Depth;
m_RenderStateBlock.depthState = new DepthState(false, CompareFunction.Always);
m_RenderStateBlock.mask |= RenderStateMask.Stencil;
StencilState stencilState = StencilState.defaultValue;
stencilState.enabled = true;
stencilState.SetCompareFunction(CompareFunction.Always);
stencilState.SetPassOperation(StencilOp.Replace);
stencilState.SetFailOperation(StencilOp.Zero);
stencilState.SetZFailOperation(StencilOp.Keep);
m_RenderStateBlock.stencilReference = settings.StencilValue;
m_RenderStateBlock.stencilState = stencilState;
m_FilteringSettings = new FilteringSettings(RenderQueueRange.opaque, settings.ReflectiveSurfaceLayer);
m_ShaderTagIdList.Add(new ShaderTagId("DepthOnly"));
m_DepthTexture.Init("_CameraDepthTexture");
}
//Execute the render pass itself proper
public override void Execute(ScriptableRenderContext _context, ref RenderingData _renderingData)
{
//Get command buffer to create draw commands
CommandBuffer _cmd = CommandBufferPool.Get(profilerTag);
//Magic happens in here
{
//Setup a draw call (opaque only, ALL masks, with custom normals material)
List <ShaderTagId> _shaderTagIdList = new List <ShaderTagId>();
_shaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
_shaderTagIdList.Add(new ShaderTagId("UniversalForward"));
_shaderTagIdList.Add(new ShaderTagId("LightweightForward"));
DrawingSettings _drawSets = CreateDrawingSettings(_shaderTagIdList, ref _renderingData, _renderingData.cameraData.defaultOpaqueSortFlags);
_drawSets.overrideMaterial = material;
FilteringSettings _filterSets = new FilteringSettings(RenderQueueRange.opaque);
RenderStateBlock _renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
//Draw renderers -- the rendering layer masks provide the correct material
_context.DrawRenderers(_renderingData.cullResults, ref _drawSets, ref _filterSets, ref _renderStateBlock);
//Set params
_cmd.SetGlobalTexture("_CustomCamNormals", tempRT.id);
}
//Execute the commands listed
_context.ExecuteCommandBuffer(_cmd);
//Erase the command buffer
_cmd.Clear();
CommandBufferPool.Release(_cmd);
}
protected override void Execute(CustomPassContext ctx)
{
// Disable it for scene view because it's horrible
if (ctx.hdCamera.camera.cameraType == CameraType.SceneView)
{
return;
}
var currentCam = ctx.hdCamera.camera;
// Copy settings of our current camera
foregroundCamera.transform.SetPositionAndRotation(currentCam.transform.position, currentCam.transform.rotation);
foregroundCamera.CopyFrom(ctx.hdCamera.camera);
// Make sure the camera is disabled, we don't want it to render anything.
foregroundCamera.enabled = false;
foregroundCamera.fieldOfView = fov;
foregroundCamera.cullingMask = foregroundMask;
var depthTestOverride = new RenderStateBlock(RenderStateMask.Depth)
{
depthState = new DepthState(false, CompareFunction.Always),
};
// TODO: Nuke the depth in the after depth and normal injection point
// Override depth to 0 (avoid artifacts with screen-space effects)
ctx.cmd.SetRenderTarget(trueDepthBuffer, 0, CubemapFace.Unknown, 0); // TODO: make it work in VR
CustomPassUtils.RenderFromCamera(ctx, foregroundCamera, null, null, ClearFlag.None, foregroundMask, overrideMaterial: depthClearMaterial, overrideMaterialIndex: 0);
// Render the object color
CustomPassUtils.RenderFromCamera(ctx, foregroundCamera, ctx.cameraColorBuffer, ctx.cameraDepthBuffer, ClearFlag.None, foregroundMask, overrideRenderState: depthTestOverride);
}
protected override void Execute(CustomPassContext ctx)
{
if (!render || bakingCamera == null ||
ctx.hdCamera.camera == bakingCamera)
{
return;
}
bakingCamera.TryGetCullingParameters(out var cullingParams);
cullingParams.cullingOptions = CullingOptions.ShadowCasters;
// Assign the custom culling result to the context
// so it'll be used for the following operations
cullingResultField.SetValueDirect(__makeref(ctx), ctx.renderContext.Cull(ref cullingParams));
var overrideDepthTest = new RenderStateBlock(RenderStateMask.Depth)
{
depthState = new DepthState(true, CompareFunction.LessEqual)
};
// Sync baking camera aspect ratio with RT (see https://github.com/alelievr/HDRP-Custom-Passes/issues/24)
bakingCamera.aspect = ctx.hdCamera.camera.aspect;
bakingCamera.pixelRect = ctx.hdCamera.camera.pixelRect;
// Depth
if (depthTexture != null)
{
SyncRenderTextureAspect(depthTexture, ctx.hdCamera.camera);
CoreUtils.SetRenderTarget(ctx.cmd, depthTexture, ClearFlag.Depth);
CustomPassUtils.RenderDepthFromCamera(ctx, bakingCamera, bakingCamera.cullingMask, overrideRenderState: overrideDepthTest);
}
// ctx.hdCamera.camera.pixelRect = oldRect;
}
void DrawOpaque(ref ScriptableRenderContext context, Camera camera, ref CullingResults cullingResults)
{
buffer.BeginSample("Opaque");
var sortingSettings = new SortingSettings(camera);
sortingSettings.criteria = SortingCriteria.CommonOpaque;
var drawSettings = new DrawingSettings(ShaderPassTags.Forward, sortingSettings)
{
enableDynamicBatching = true,
enableInstancing = true,
perObjectData = PerObjectData.Lightmaps | PerObjectData.LightProbe
};
var filterSettings = FilteringSettings.defaultValue;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
filterSettings.layerMask = ~0;
RenderStateBlock stateBlock = new RenderStateBlock(RenderStateMask.Nothing);
context.DrawRenderers(cullingResults, ref drawSettings, ref filterSettings);
buffer.EndSample("Opaque");
context.ExecuteCommandBuffer(buffer);
buffer.Clear();
}
public override void Render(ScriptableRenderContext context, ref RenderingData renderingData)
{
var camera = renderingData.camera;
var cmd = CommandBufferPool.Get("RenderOpaque");
using (new ProfilingSample(cmd, "RenderOpaque"))
{
// Start profilling
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
SetupLights(context, ref renderingData);
FilteringSettings filteringSettings = new FilteringSettings(RenderQueueRange.opaque);
SortingSettings sortingSettings = new SortingSettings(camera);
sortingSettings.criteria = SortingCriteria.CommonOpaque;
DrawingSettings drawingSettings = new DrawingSettings(new ShaderTagId("ForwardLit"), sortingSettings)
{
mainLightIndex = GetMainLightIndex(ref renderingData),
enableDynamicBatching = true
};
RenderStateBlock stateBlock = new RenderStateBlock(RenderStateMask.Nothing);
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filteringSettings, ref stateBlock);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
// Constructor
// Copies over settings and sets up member variables
public RenderObjectsWithKeywordsPass(string profilerTag, RenderObjectsWithKeywords.Settings settings)
{
mProfilerTag = profilerTag;
mProfilingSampler = new ProfilingSampler(profilerTag);
mSettings = settings;
RenderQueueRange renderQueueRange = (settings.filter.renderQueueType == RenderQueueType.Transparent)
? RenderQueueRange.transparent
: RenderQueueRange.opaque;
mFilteringSettings = new FilteringSettings(renderQueueRange, settings.filter.layerMask);
mShaderTagIdList.Add(new ShaderTagId("UniversalForward"));
mShaderTagIdList.Add(new ShaderTagId("LightweightForward"));
mShaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
mRenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
if (settings.dstType == RenderTarget.RenderTextureObject)
{
mDestination = settings.dstTextureObject;
}
else
{
mDestination = new RenderTargetIdentifier();
}
mRenderStateBlock.mask |= RenderStateMask.Depth;
mRenderStateBlock.depthState = new DepthState(true, CompareFunction.Less);
}
public RenderObjectsToTexturePass(string profilerTag, RenderPassEvent renderPassEvent, string[] shaderTags, RenderQueueType renderQueueType, int layerMask, RenderObjectsToTexture.CustomCameraSettings cameraSettings)
{
m_ProfilerTag = profilerTag;
this.renderPassEvent = renderPassEvent;
this.renderQueueType = renderQueueType;
this.overrideMaterial = null;
this.overrideMaterialPassIndex = 0;
RenderQueueRange renderQueueRange = (renderQueueType == RenderQueueType.Transparent)
? RenderQueueRange.transparent
: RenderQueueRange.opaque;
m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask);
if (shaderTags != null && shaderTags.Length > 0)
{
foreach (var passName in shaderTags)
{
m_ShaderTagIdList.Add(new ShaderTagId(passName));
}
}
else
{
m_ShaderTagIdList.Add(new ShaderTagId("LightweightForward"));
m_ShaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
}
m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
m_CameraSettings = cameraSettings;
// Copy depth buffer material
m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(Shader.Find("Hidden/Lightweight Render Pipeline/CopyDepth"));
}
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));
}
public RenderObjectsPass(string profilerTag, RenderPassEvent renderPassEvent, string[] shaderTags, RenderQueueType renderQueueType, int layerMask, RenderObjects.CustomCameraSettings cameraSettings)
{
m_ProfilerTag = profilerTag;
this.renderPassEvent = renderPassEvent;
this.renderQueueType = renderQueueType;
this.overrideMaterial = null;
this.overrideMaterialPassIndex = 0;
RenderQueueRange renderQueueRange = (renderQueueType == RenderQueueType.Transparent)
? RenderQueueRange.transparent
: RenderQueueRange.opaque;
m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask);
if (shaderTags != null && shaderTags.Length > 0)
{
foreach (var passName in shaderTags)
{
m_ShaderTagIdList.Add(new ShaderTagId(passName));
}
}
else
{
m_ShaderTagIdList.Add(new ShaderTagId("LightweightForward"));
m_ShaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
}
m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
m_CameraSettings = cameraSettings;
_dest = new RenderTargetHandle();
_dest.Init("go_ReflectionTex");
//_dest.id = 1198;
}
private void DrawOpaque(ScriptableRenderContext pRenderContext, Camera pCamera)
{
m_FilteringSettings = new FilteringSettings(RenderQueueRange.opaque, ~0);
m_DefaultStencilState = StencilState.defaultValue;
m_DefaultStencilState.enabled = stencilData.overrideStencilState;
m_DefaultStencilState.SetCompareFunction(stencilData.stencilCompareFunction);
m_DefaultStencilState.SetPassOperation(stencilData.passOperation);
m_DefaultStencilState.SetFailOperation(stencilData.failOperation);
m_DefaultStencilState.SetZFailOperation(stencilData.zFailOperation);
m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
m_RenderStateBlock.stencilReference = stencilData.stencilReference;
m_RenderStateBlock.mask = RenderStateMask.Stencil;
m_RenderStateBlock.stencilState = m_DefaultStencilState;
SortingSettings sortingSettings = new SortingSettings(pCamera)
{
criteria = SortingCriteria.CommonOpaque
};
settings = new DrawingSettings(m_ShaderTagIdList[0], sortingSettings)
{
perObjectData = PerObjectData.None,
enableInstancing = true,
mainLightIndex = 0,
enableDynamicBatching = false,
};
for (int i = 1; i < m_ShaderTagIdList.Count; ++i)
{
settings.SetShaderPassName(i, m_ShaderTagIdList[i]);
}
pRenderContext.DrawRenderers(outCull, ref settings, ref m_FilteringSettings);
}
/// <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));
}
internal RenderStateBlock GetDefaultRenderStateBlock(bool stencilTest, StencilTestOptions stencilTestOptions)
{
RenderStateBlock renderStateBlock = new RenderStateBlock();
if (stencilTest && m_stencilTestState != StencilTestState.None)
{
int stencilMask = StencilMaskAllocator.GetCurrentBit();
renderStateBlock.mask = RenderStateMask.Stencil;
renderStateBlock.stencilReference = stencilMask;
if (m_stencilTestState == StencilTestState.BothSide)
{
if ((stencilTestOptions & StencilTestOptions.PreventOverwriting) == 0)
{
renderStateBlock.stencilState = new StencilState(true, (byte)stencilMask, 0, CompareFunction.Equal, StencilOp.Keep, StencilOp.Keep, StencilOp.Keep);
}
else
{
renderStateBlock.stencilState = new StencilState(true, (byte)stencilMask, (byte)stencilMask, CompareFunction.Equal, StencilOp.Zero, StencilOp.Keep, StencilOp.Keep);
}
}
else
{
if ((stencilTestOptions & StencilTestOptions.PreventOverwriting) == 0)
{
renderStateBlock.stencilState = new StencilState(true, (byte)stencilMask, 0, CompareFunction.NotEqual, StencilOp.Keep, StencilOp.Keep, StencilOp.Keep);
}
else
{
renderStateBlock.stencilState = new StencilState(true, (byte)stencilMask, (byte)stencilMask, CompareFunction.NotEqual, StencilOp.Replace, StencilOp.Keep, StencilOp.Keep);
}
}
}
return(renderStateBlock);
}
// 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);
}
public CustomRendererPass(string profilerTag, ShaderTagId[] shaderTagIds, bool opaque, RenderPassEvent evt, RenderQueueRange renderQueueRange, LayerMask layerMask, StencilState stencilState, int stencilReference)
{
base.profilingSampler = new ProfilingSampler(nameof(CustomRendererPass));
m_ProfilerTag = profilerTag;
m_ProfilingSampler = new ProfilingSampler(profilerTag);
//将要识别的Shader标签加入队列
foreach (ShaderTagId sid in shaderTagIds)
{
m_ShaderTagIdList.Add(sid);
}
renderPassEvent = evt;
m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask);
//模板测试据盒
m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
m_IsOpaque = opaque;
if (stencilState.enabled)//模板测试是否激活
{
m_RenderStateBlock.stencilReference = stencilReference;
m_RenderStateBlock.mask = RenderStateMask.Stencil;
m_RenderStateBlock.stencilState = stencilState;
}
}
protected override void Execute(CustomPassContext ctx)
{
// Disable it for scene view because it's horrible
if (ctx.hdCamera.camera.cameraType == CameraType.SceneView)
{
return;
}
var currentCam = ctx.hdCamera.camera;
// Copy settings of our current camera
foregroundCamera.transform.SetPositionAndRotation(currentCam.transform.position, currentCam.transform.rotation);
foregroundCamera.CopyFrom(ctx.hdCamera.camera);
// Make sure the camera is disabled, we don't want it to render anything.
foregroundCamera.enabled = false;
foregroundCamera.fieldOfView = fov;
foregroundCamera.cullingMask = foregroundMask;
var depthTestOverride = new RenderStateBlock(RenderStateMask.Depth)
{
depthState = new DepthState(true, CompareFunction.LessEqual),
};
CustomPassUtils.RenderFromCamera(ctx, foregroundCamera, ctx.cameraColorBuffer, ctx.cameraDepthBuffer, ClearFlag.None, foregroundMask, overrideRenderState: depthTestOverride);
}
public RenderMetaballsDepthPass(string profilerTag, RenderPassEvent renderPassEvent,
string[] shaderTags, RenderQueueType renderQueueType, int layerMask)
{
profilingSampler = new ProfilingSampler(nameof(RenderObjectsPass));
_profilingSampler = new ProfilingSampler(profilerTag);
this.renderPassEvent = renderPassEvent;
this._renderQueueType = renderQueueType;
RenderQueueRange renderQueueRange = (renderQueueType == RenderQueueType.Transparent)
? RenderQueueRange.transparent
: RenderQueueRange.opaque;
_filteringSettings = new FilteringSettings(renderQueueRange, layerMask);
if (shaderTags != null && shaderTags.Length > 0)
{
foreach (var passName in shaderTags)
{
_shaderTagIdList.Add(new ShaderTagId(passName));
}
}
else
{
_shaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
_shaderTagIdList.Add(new ShaderTagId("UniversalForward"));
_shaderTagIdList.Add(new ShaderTagId("UniversalForwardOnly"));
_shaderTagIdList.Add(new ShaderTagId("LightweightForward"));
}
_renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
}
public OnlyDepthShadowmapRenderPass(string profilerTag, bool opaque, RenderPassEvent evt, RenderQueueRange renderQueueRange, LayerMask layerMask)//, StencilState stencilState, int stencilReference)
{
m_ProfilerTag = profilerTag;
m_ProfilingSampler = new ProfilingSampler(profilerTag);
m_ShaderTagIdList.Add(new ShaderTagId("ShadowCaster"));
renderPassEvent = evt;
m_MainLightShadowmap.Init("_ZorroShadowmapTexture");
m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask);
m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
//if (stencilState.enabled)
//{
// m_RenderStateBlock.stencilReference = stencilReference;
// m_RenderStateBlock.mask = RenderStateMask.Stencil;
// m_RenderStateBlock.stencilState = stencilState;
//}
_CustomWorldToShadowID = Shader.PropertyToID("_ZorroShadowMatrix");
_CustomShadowParams = Shader.PropertyToID("_ZorroShadowParams");
//m_MainLightShadowmap.Init("_CustomLightShadowmapTexture");
}
public GBufferPass(RenderPassEvent evt, RenderQueueRange renderQueueRange, LayerMask layerMask, StencilState stencilState, int stencilReference, DeferredLights deferredLights)
{
base.profilingSampler = new ProfilingSampler(nameof(GBufferPass));
base.renderPassEvent = evt;
m_DeferredLights = deferredLights;
m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask);
m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
m_RenderStateBlock.stencilState = stencilState;
m_RenderStateBlock.stencilReference = stencilReference;
m_RenderStateBlock.mask = RenderStateMask.Stencil;
m_ShaderTagValues = new ShaderTagId[4];
m_ShaderTagValues[0] = s_ShaderTagLit;
m_ShaderTagValues[1] = s_ShaderTagSimpleLit;
m_ShaderTagValues[2] = s_ShaderTagUnlit;
m_ShaderTagValues[3] = new ShaderTagId(); // Special catch all case for materials where UniversalMaterialType is not defined or the tag value doesn't match anything we know.
m_RenderStateBlocks = new RenderStateBlock[4];
m_RenderStateBlocks[0] = DeferredLights.OverwriteStencil(m_RenderStateBlock, (int)StencilUsage.MaterialMask, (int)StencilUsage.MaterialLit);
m_RenderStateBlocks[1] = DeferredLights.OverwriteStencil(m_RenderStateBlock, (int)StencilUsage.MaterialMask, (int)StencilUsage.MaterialSimpleLit);
m_RenderStateBlocks[2] = DeferredLights.OverwriteStencil(m_RenderStateBlock, (int)StencilUsage.MaterialMask, (int)StencilUsage.MaterialUnlit);
m_RenderStateBlocks[3] = m_RenderStateBlocks[0];
}
void InitRecursiveRenderer()
{
m_RaytracingFlagStateBlock = new RenderStateBlock
{
depthState = new DepthState(false, CompareFunction.LessEqual),
mask = RenderStateMask.Depth
};
}
void InitRecursiveRenderer()
{
m_RaytracingFlagStateBlock = new RenderStateBlock
{
depthState = new DepthState(false, CompareFunction.LessEqual),
mask = RenderStateMask.Depth
};
m_FlagMaskTextureRT = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R8_SNorm, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "FlagMaskTexture");
}
public MyRenderObjectsPass(RenderTargetHandle destination, int layerMask, Material overrideMaterial)
{
_destination = destination;
_overrideMaterial = overrideMaterial;
_filteringSettings = new FilteringSettings(RenderQueueRange.opaque, layerMask);
_renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
}
void DrawObjectMotionVectors(ScriptableRenderContext context, ref RenderingData renderingData, Camera camera)
{
var drawingSettings = GetDrawingSettings(ref renderingData);
var filteringSettings = new FilteringSettings(RenderQueueRange.opaque, camera.cullingMask);
var renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
// Draw Renderers
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filteringSettings, ref renderStateBlock);
}
public void Render(ScriptableRenderContext context, Camera cam, bool enableDynamicBatching, bool enableInstancing)
{
CullingResults cullingResults;
if (!m_cullingResults.TryGetValue(cam, out cullingResults))
{
return;
}
if (useStencilTest)
{
if (m_stencilProperties == null)
{
m_stencilProperties = new MaterialPropertyBlock();
}
m_stencilProperties.SetFloat(s_shaderPropIdStencilRef, stencilRef);
m_stencilProperties.SetFloat(s_shaderPropIdStencilMask, stencilMask);
if (m_stencilPassCommands == null)
{
m_stencilPassCommands = new CommandBuffer();
}
m_stencilPassCommands.Clear();
m_stencilPassCommands.DrawMesh(m_meshFrustum, transform.localToWorldMatrix, stencilPassMaterial, 0, 0, m_stencilProperties);
m_stencilPassCommands.DrawMesh(m_meshFrustum, transform.localToWorldMatrix, stencilPassMaterial, 0, 1, m_stencilProperties);
context.ExecuteCommandBuffer(m_stencilPassCommands);
}
if (m_copiedProjectorMaterial == null)
{
m_copiedProjectorMaterial = new Material(m_projector.material);
}
m_copiedProjectorMaterial.CopyPropertiesFromMaterial(m_projector.material);
m_copiedProjectorMaterial.EnableKeyword(PROJECTOR_SHADER_KEYWORD);
m_copiedProjectorMaterial.SetMatrix(s_shaderPropIdFsrWorldToProjector, uvProjectionMatrix);
m_copiedProjectorMaterial.SetVector(s_shaderPropIdFsrWorldProjectDir, projectorDir);
DrawingSettings drawingSettings = new DrawingSettings(m_shaderTagIdList[0], new SortingSettings(cam));
for (int i = 1; i < m_shaderTagIdList.Length; ++i)
{
drawingSettings.SetShaderPassName(i, m_shaderTagIdList[i]);
}
drawingSettings.overrideMaterial = m_copiedProjectorMaterial;
drawingSettings.overrideMaterialPassIndex = 0;
drawingSettings.enableDynamicBatching = enableDynamicBatching;
drawingSettings.enableInstancing = enableInstancing;
drawingSettings.perObjectData = m_perObjectData;
FilteringSettings filteringSettings = new FilteringSettings(new RenderQueueRange(m_renderQueueLowerBound, m_renderQueueUpperBound), cam.cullingMask & ~m_projector.ignoreLayers);
RenderStateBlock renderStateBlock = new RenderStateBlock();
if (useStencilTest)
{
renderStateBlock.mask = RenderStateMask.Stencil;
renderStateBlock.stencilReference = m_stencilRef;
renderStateBlock.stencilState = new StencilState(true, (byte)m_stencilMask, 0, CompareFunction.Equal, StencilOp.Zero, StencilOp.Keep, StencilOp.Keep);
}
context.DrawRenderers(cullingResults, ref drawingSettings, ref filteringSettings, ref renderStateBlock);
}
protected override void Execute(CustomPassContext ctx)
{
if (!render || ctx.hdCamera.camera == bakingCamera || bakingCamera == null || ctx.hdCamera.camera.cameraType == CameraType.SceneView)
{
return;
}
if (depthTexture == null && normalTexture == null && tangentTexture == null)
{
return;
}
// We need to be careful about the aspect ratio of render textures when doing the culling, otherwise it could result in objects poping:
if (depthTexture != null)
{
bakingCamera.aspect = Mathf.Max(bakingCamera.aspect, depthTexture.width / (float)depthTexture.height);
}
if (normalTexture != null)
{
bakingCamera.aspect = Mathf.Max(bakingCamera.aspect, normalTexture.width / (float)normalTexture.height);
}
if (tangentTexture != null)
{
bakingCamera.aspect = Mathf.Max(bakingCamera.aspect, tangentTexture.width / (float)tangentTexture.height);
}
bakingCamera.TryGetCullingParameters(out var cullingParams);
cullingParams.cullingOptions = CullingOptions.None;
// Assign the custom culling result to the context
// so it'll be used for the following operations
ctx.cullingResults = ctx.renderContext.Cull(ref cullingParams);
var overrideDepthTest = new RenderStateBlock(RenderStateMask.Depth)
{
depthState = new DepthState(true, CompareFunction.LessEqual)
};
// Depth
if (depthTexture != null)
{
CustomPassUtils.RenderDepthFromCamera(ctx, bakingCamera, depthTexture, ClearFlag.Depth, bakingCamera.cullingMask, overrideRenderState: overrideDepthTest);
}
// Normal
if (normalTexture != null)
{
CustomPassUtils.RenderNormalFromCamera(ctx, bakingCamera, normalTexture, ClearFlag.All, bakingCamera.cullingMask, overrideRenderState: overrideDepthTest);
}
// Tangent
if (tangentTexture != null)
{
CustomPassUtils.RenderTangentFromCamera(ctx, bakingCamera, tangentTexture, ClearFlag.All, bakingCamera.cullingMask, overrideRenderState: overrideDepthTest);
}
}
void RenderDecal(ScriptableRenderContext context, Decal decal, CullingResults cullingResults, ref RenderingData renderingData)
{
// Create Settings
var drawingSettings = GetDrawingSettings(decal, ref renderingData);
var filteringSettings = new FilteringSettings(RenderQueueRange.all, decal.decalData.layerMask);
var renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
// Draw Renderers
context.DrawRenderers(cullingResults, ref drawingSettings, ref filteringSettings, ref renderStateBlock);
}
