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);
}
internal bool GetRenderStateBlock(out RenderStateBlock renderStateBlock)
{
DebugSceneOverrideMode sceneOverrideMode = RenderingSettings.debugSceneOverrideMode;
// Create an empty render-state block and only enable the parts we wish to override...
renderStateBlock = new 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;
return(true);
}
case DebugSceneOverrideMode.Wireframe:
{
return(true);
}
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;
}
return(true);
}
default:
{
// We're not going to override anything...
return(false);
}
} // End of switch.
}
internal RenderStateBlock GetRenderStateBlock(RenderStateBlock renderStateBlock)
{
DebugSceneOverrideMode sceneOverrideMode = RenderingSettings.sceneOverrideMode;
// Potentially override parts of the RenderStateBlock
switch (sceneOverrideMode)
{
case DebugSceneOverrideMode.Overdraw:
{
var isOpaque = m_FilteringSettings.renderQueueRange == RenderQueueRange.opaque || m_FilteringSettings.renderQueueRange == RenderQueueRange.all;
var isTransparent = m_FilteringSettings.renderQueueRange == RenderQueueRange.transparent || m_FilteringSettings.renderQueueRange == RenderQueueRange.all;
var overdrawOpaque =
m_DebugHandler.DebugDisplaySettings.renderingSettings.overdrawMode == DebugOverdrawMode.Opaque ||
m_DebugHandler.DebugDisplaySettings.renderingSettings.overdrawMode == DebugOverdrawMode.All;
var overdrawTransparent =
m_DebugHandler.DebugDisplaySettings.renderingSettings.overdrawMode == DebugOverdrawMode.Transparent ||
m_DebugHandler.DebugDisplaySettings.renderingSettings.overdrawMode == DebugOverdrawMode.All;
var blendOverdraw = isOpaque && overdrawOpaque || isTransparent && overdrawTransparent;
var destination = blendOverdraw ? BlendMode.One : BlendMode.Zero;
RenderTargetBlendState additiveBlend = new RenderTargetBlendState(sourceColorBlendMode: BlendMode.One, destinationColorBlendMode: destination);
// 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);
}
// Main entry point for our scriptable render loop
public static void Render(ScriptableRenderContext context, IEnumerable <Camera> cameras)
{
bool stereoEnabled = XRSettings.isDeviceActive;
foreach (Camera camera in cameras)
{
// Culling
ScriptableCullingParameters cullingParams;
// Stereo-aware culling parameters are configured to perform a single cull for both eyes
if (!CullResults.GetCullingParameters(camera, stereoEnabled, out cullingParams))
{
continue;
}
CullResults cull = new CullResults();
CullResults.Cull(ref cullingParams, context, ref cull);
// Setup camera for rendering (sets render target, view/projection matrices and other
// per-camera built-in shader variables).
// If stereo is enabled, we also configure stereo matrices, viewports, and XR device render targets
context.SetupCameraProperties(camera, stereoEnabled);
// Draws in-between [Start|Stop]MultiEye are stereo-ized by engine
if (stereoEnabled)
{
context.StartMultiEye(camera);
}
// clear depth buffer
CommandBuffer cmd = new CommandBuffer();
cmd.ClearRenderTarget(true, false, Color.black);
context.ExecuteCommandBuffer(cmd);
cmd.Release();
// Setup global lighting shader variables
SetupLightShaderVariables(cull.visibleLights, context);
// Draw skybox
context.DrawSkybox(camera);
// Setup DrawSettings and FilterSettings
ShaderPassName passName = new ShaderPassName("BasicPass");
DrawRendererSettings drawSettings = new DrawRendererSettings(camera, passName);
FilterRenderersSettings filterSettings = new FilterRenderersSettings(true);
//*************************************************************
// Block
RenderStateBlock rsb = new RenderStateBlock(RenderStateMask.Depth | RenderStateMask.Blend | RenderStateMask.Raster | RenderStateMask.Stencil);
DepthState ds = rsb.depthState;//
ds.writeEnabled = true;
ds.compareFunction = CompareFunction.LessEqual;
rsb.depthState = ds; //
BlendState bs = rsb.blendState; //
RenderTargetBlendState rs0 = bs.blendState0; //
bs.alphaToMask = false;
rs0.sourceColorBlendMode = BlendMode.SrcAlpha;
rs0.destinationColorBlendMode = BlendMode.One;
rs0.colorBlendOperation = BlendOp.Add;
rs0.sourceAlphaBlendMode = BlendMode.Zero;
rs0.destinationAlphaBlendMode = BlendMode.One;
rs0.alphaBlendOperation = BlendOp.Add;
rs0.writeMask = ColorWriteMask.All;
bs.blendState0 = rs0; //
rsb.blendState = bs; //
RasterState rs = rsb.rasterState; //
rs.cullingMode = CullMode.Off;
rs.depthClip = false;
rs.offsetFactor = 0;
rs.offsetUnits = 0;
rsb.rasterState = rs;//
StencilState ss = rsb.stencilState;//
rsb.stencilReference = 0;
ss.compareFunction = CompareFunction.Disabled;
ss.compareFunctionBack = CompareFunction.Disabled;
ss.compareFunctionFront = CompareFunction.Disabled;
ss.failOperation = StencilOp.Keep;
ss.failOperationBack = StencilOp.Keep;
ss.failOperationFront = StencilOp.Keep;
ss.passOperation = StencilOp.Keep;
ss.passOperationBack = StencilOp.Keep;
ss.passOperationFront = StencilOp.Keep;
ss.zFailOperation = StencilOp.Keep;
ss.zFailOperationBack = StencilOp.Keep;
ss.zFailOperationFront = StencilOp.Keep;
ss.readMask = 255;
ss.writeMask = 255;
ss.enabled = true;
rsb.stencilState = ss;//
//**************************************************************
//mapping
RenderStateBlock rsb_opaque = new RenderStateBlock(RenderStateMask.Raster | RenderStateMask.Stencil);
rsb_opaque.rasterState = rsb.rasterState;
rsb_opaque.stencilState = rsb.stencilState;
rsb_opaque.stencilReference = rsb.stencilReference;
RenderStateBlock rsb_trans = new RenderStateBlock(RenderStateMask.Blend);
rsb_trans.blendState = rsb.blendState;
RenderStateBlock rsb_over = new RenderStateBlock(RenderStateMask.Raster | RenderStateMask.Depth | RenderStateMask.Stencil);
rsb_over.depthState = rsb.depthState;
rsb_over.rasterState = rsb.rasterState;
rsb_over.stencilState = rsb.stencilState;
rsb_over.stencilReference = rsb.stencilReference;
List <RenderStateMapping> rsm = new List <RenderStateMapping>
{
new RenderStateMapping("Opaque", rsb_opaque),
new RenderStateMapping("Transparent", rsb_trans),
new RenderStateMapping("Overlay", rsb_over)
};
//**************************************************************
// Draw opaque objects using BasicPass shader pass
filterSettings.layerMask = LayerMask.GetMask("Default");
drawSettings.sorting.flags = SortFlags.CommonOpaque;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
// WITH RENDERSTATEBLOCK OPAQUE
filterSettings.layerMask = LayerMask.GetMask("TransparentFX");
drawSettings.sorting.flags = SortFlags.CommonOpaque;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, rsb);
// WITH RENDERSTATEMAPPING OPAQUE
filterSettings.layerMask = LayerMask.GetMask("Ignore Raycast");
drawSettings.sorting.flags = SortFlags.CommonOpaque;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, rsm);
//**************************************************************
// Draw transparent objects using BasicPass shader pass
filterSettings.layerMask = LayerMask.GetMask("Default");
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
// WITH RENDERSTATEBLOCK TRANSPARENT
filterSettings.layerMask = LayerMask.GetMask("TransparentFX");
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, rsb);
// WITH RENDERSTATEMAPPING TRANSPARENT
filterSettings.layerMask = LayerMask.GetMask("Ignore Raycast");
drawSettings.sorting.flags = SortFlags.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, rsm);
//**************************************************************
if (stereoEnabled)
{
context.StopMultiEye(camera);
// StereoEndRender will reset state on the camera to pre-Stereo settings,
// and invoke XR based events/callbacks.
context.StereoEndRender(camera);
}
context.Submit();
}
}
