internal static StencilState OverwriteStencil(StencilState s, int stencilWriteMask)
{
if (!s.enabled)
{
//没激活模板缓冲各种情况状态设置
return(new StencilState(
true,
0, (byte)stencilWriteMask,
CompareFunction.Always, StencilOp.Replace, StencilOp.Keep, StencilOp.Keep,
CompareFunction.Always, StencilOp.Replace, StencilOp.Keep, StencilOp.Keep
));
}
//打开模板缓冲后的设置
CompareFunction funcFront = s.compareFunctionFront != CompareFunction.Disabled ? s.compareFunctionFront : CompareFunction.Always;
CompareFunction funcBack = s.compareFunctionBack != CompareFunction.Disabled ? s.compareFunctionBack : CompareFunction.Always;
StencilOp passFront = s.passOperationFront;
StencilOp failFront = s.failOperationFront;
StencilOp zfailFront = s.zFailOperationFront;
StencilOp passBack = s.passOperationBack;
StencilOp failBack = s.failOperationBack;
StencilOp zfailBack = s.zFailOperationBack;
return(new StencilState(
true,
(byte)(s.readMask & 0x0F), (byte)(s.writeMask | stencilWriteMask),
funcFront, passFront, failFront, zfailFront,
funcBack, passBack, failBack, zfailBack
));
}
public ToonForwardRenderer(ToonForwardRendererData data) : base(data)
{
m_BlitMaterial = CoreUtils.CreateEngineMaterial(data.shaders.blitPS);
m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(data.shaders.copyDepthPS);
m_SamplingMaterial = CoreUtils.CreateEngineMaterial(data.shaders.samplingPS);
m_ScreenspaceShadowsMaterial = CoreUtils.CreateEngineMaterial(data.shaders.screenSpaceShadowPS);
StencilStateData stencilData = data.defaultStencilState;
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);
// Note: Since all custom render passes inject first and we have stable sort,
// we inject the builtin passes in the before events.
m_MainLightShadowCasterPass = new MainLightShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
m_AdditionalLightsShadowCasterPass = new AdditionalLightsShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
m_DepthPrepass = new DepthOnlyPass(RenderPassEvent.BeforeRenderingPrepasses, RenderQueueRange.opaque, data.opaqueLayerMask);
m_ScreenSpaceShadowResolvePass = new ScreenSpaceShadowResolvePass(RenderPassEvent.BeforeRenderingPrepasses, m_ScreenspaceShadowsMaterial);
m_ColorGradingLutPass = new ColorGradingLutPass(RenderPassEvent.BeforeRenderingPrepasses, data.postProcessData);
m_RenderOutlineForwardPass = new DrawOutlinePass("Render Outline", true, RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference);
m_RenderOpaqueForwardPass = new DrawObjectsPass("Render Opaques", true, RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference);
m_CopyDepthPass = new CopyDepthPass(RenderPassEvent.AfterRenderingSkybox, m_CopyDepthMaterial);
m_DrawSkyboxPass = new DrawSkyboxPass(RenderPassEvent.BeforeRenderingSkybox);
m_CopyColorPass = new CopyColorPass(RenderPassEvent.BeforeRenderingTransparents, m_SamplingMaterial);
m_TransparentSettingsPass = new TransparentSettingsPass(RenderPassEvent.BeforeRenderingTransparents, data.shadowTransparentReceive);
m_RenderTransparentForwardPass = new DrawObjectsPass("Render Transparents", false, RenderPassEvent.BeforeRenderingTransparents, RenderQueueRange.transparent, data.transparentLayerMask, m_DefaultStencilState, stencilData.stencilReference);
m_OnRenderObjectCallbackPass = new InvokeOnRenderObjectCallbackPass(RenderPassEvent.BeforeRenderingPostProcessing);
m_PostProcessPass = new PostProcessPass(RenderPassEvent.BeforeRenderingPostProcessing, data.postProcessData, m_BlitMaterial);
m_FinalPostProcessPass = new PostProcessPass(RenderPassEvent.AfterRendering + 1, data.postProcessData, m_BlitMaterial);
m_CapturePass = new CapturePass(RenderPassEvent.AfterRendering);
m_FinalBlitPass = new FinalBlitPass(RenderPassEvent.AfterRendering + 1, m_BlitMaterial);
#if POST_PROCESSING_STACK_2_0_0_OR_NEWER
m_OpaquePostProcessPassCompat = new PostProcessPassCompat(RenderPassEvent.BeforeRenderingOpaques, true);
m_PostProcessPassCompat = new PostProcessPassCompat(RenderPassEvent.BeforeRenderingPostProcessing);
#endif
#if UNITY_EDITOR
m_SceneViewDepthCopyPass = new SceneViewDepthCopyPass(RenderPassEvent.AfterRendering + 9, m_CopyDepthMaterial);
#endif
// RenderTexture format depends on camera and pipeline (HDR, non HDR, etc)
// Samples (MSAA) depend on camera and pipeline
m_CameraColorAttachment.Init("_CameraColorTexture");
m_CameraDepthAttachment.Init("_CameraDepthAttachment");
m_DepthTexture.Init("_CameraDepthTexture");
m_OpaqueColor.Init("_CameraOpaqueTexture");
m_AfterPostProcessColor.Init("_AfterPostProcessTexture");
m_ColorGradingLut.Init("_InternalGradingLut");
m_ForwardLights = new ForwardLights();
supportedRenderingFeatures = new RenderingFeatures()
{
cameraStacking = true,
};
}
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);
}
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");
}
/// <summary>
/// Initializes a new instance of the <see cref="DepthStencilStates"/> class.
/// </summary>
public DepthStencilStates()
{
IsDepthWriteEnabled = true;
StencilReference = 0;
DepthComparison = ComparisonOperator.Less;
DepthBias = 0;
StencilReadMask = 0xFF;
StencilWriteMask = 0xFF;
FrontFace = new StencilState();
BackFace = new StencilState();
}
public void SetStencilState(int reference, CompareFunction compareFunction, StencilOp passOp, StencilOp failOp, StencilOp zFailOp)
{
StencilState stencilState = StencilState.defaultValue;
stencilState.enabled = true;
stencilState.SetCompareFunction(compareFunction);
stencilState.SetPassOperation(passOp);
stencilState.SetFailOperation(failOp);
stencilState.SetZFailOperation(zFailOp);
m_RenderStateBlock.mask |= RenderStateMask.Stencil;
m_RenderStateBlock.stencilReference = reference;
m_RenderStateBlock.stencilState = stencilState;
}
public Test107Renderer(Test107RendererData data) : base(data)
{
m_DefaultStencilState = new StencilState();
m_DepthPrepass = new DepthOnlyPass(RenderPassEvent.BeforeRenderingPrePasses, RenderQueueRange.opaque, -1 /*data.opaqueLayerMask*/);
m_RenderOpaqueForwardPass = new DrawObjectsPass("Render Opaques", false, RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, -1 /*data.opaqueLayerMask*/, m_DefaultStencilState, 0 /*stencilData.stencilReference*/);
m_BlitMaterial = CoreUtils.CreateEngineMaterial(data.shaders.blitPS);
m_FinalBlitPass = new FinalBlitPass(RenderPassEvent.AfterRendering, m_BlitMaterial);
m_CameraColor = RTHandles.Alloc("_CameraColor", "_CameraColor");
m_CameraDepth = RTHandles.Alloc("_CameraDepth", "_CameraDepth");
}
public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
{
if (system == null)
{
system = FindObjectOfType <SkyboxSystem>();
}
m_RenderStateBlock.mask = RenderStateMask.Stencil | RenderStateMask.Depth;
StencilState stencilState = StencilState.defaultValue;
stencilState.SetCompareFunction(CompareFunction.Equal);
m_RenderStateBlock.stencilReference = 0;
m_RenderStateBlock.stencilState = stencilState;
m_TransparentFilteringSettings = new FilteringSettings(RenderQueueRange.transparent, mask);
}
public ForwardRenderer(ForwardRendererData data) : base(data)
{
Downsampling downsamplingMethod = LightweightRenderPipeline.asset.opaqueDownsampling;
Material blitMaterial = CoreUtils.CreateEngineMaterial(data.shaders.blitPS);
Material copyDepthMaterial = CoreUtils.CreateEngineMaterial(data.shaders.copyDepthPS);
Material samplingMaterial = CoreUtils.CreateEngineMaterial(data.shaders.samplingPS);
Material screenspaceShadowsMaterial = CoreUtils.CreateEngineMaterial(data.shaders.screenSpaceShadowPS);
StencilStateData stencilData = data.defaultStencilState;
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);
// Note: Since all custom render passes inject first and we have stable sort,
// we inject the builtin passes in the before events.
m_MainLightShadowCasterPass = new MainLightShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
m_AdditionalLightsShadowCasterPass = new AdditionalLightsShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
m_DepthPrepass = new DepthOnlyPass(RenderPassEvent.BeforeRenderingPrepasses, RenderQueueRange.opaque, data.opaqueLayerMask);
m_ScreenSpaceShadowResolvePass = new ScreenSpaceShadowResolvePass(RenderPassEvent.BeforeRenderingPrepasses, screenspaceShadowsMaterial);
m_ScreenSpaceShadowComputePass = new ScreenSpaceShadowComputePass(RenderPassEvent.BeforeRenderingPrepasses, data.shaders.screenSpaceShadowCS); //seongdae;vxsm
m_RenderOpaqueForwardPass = new DrawObjectsPass("Render Opaques", true, RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference);
m_CopyDepthPass = new CopyDepthPass(RenderPassEvent.BeforeRenderingOpaques, copyDepthMaterial);
m_OpaquePostProcessPass = new PostProcessPass(RenderPassEvent.BeforeRenderingOpaques, true);
m_DrawSkyboxPass = new DrawSkyboxPass(RenderPassEvent.BeforeRenderingSkybox);
m_CopyColorPass = new CopyColorPass(RenderPassEvent.BeforeRenderingTransparents, samplingMaterial, downsamplingMethod);
m_RenderTransparentForwardPass = new DrawObjectsPass("Render Transparents", false, RenderPassEvent.BeforeRenderingTransparents, RenderQueueRange.transparent, data.transparentLayerMask, m_DefaultStencilState, stencilData.stencilReference);
m_PostProcessPass = new PostProcessPass(RenderPassEvent.BeforeRenderingPostProcessing);
m_CapturePass = new CapturePass(RenderPassEvent.AfterRendering);
m_FinalBlitPass = new FinalBlitPass(RenderPassEvent.AfterRendering, blitMaterial);
#if UNITY_EDITOR
m_SceneViewDepthCopyPass = new SceneViewDepthCopyPass(RenderPassEvent.AfterRendering + 9, copyDepthMaterial);
#endif
// RenderTexture format depends on camera and pipeline (HDR, non HDR, etc)
// Samples (MSAA) depend on camera and pipeline
m_CameraColorAttachment.Init("_CameraColorTexture");
m_CameraDepthAttachment.Init("_CameraDepthAttachment");
m_DepthTexture.Init("_CameraDepthTexture");
m_OpaqueColor.Init("_CameraOpaqueTexture");
m_ForwardLights = new ForwardLights();
}
private void InitDefaultRenderState(ref ForwardRendererData data)
{
m_BlitMaterial = CoreUtils.CreateEngineMaterial(data.shaders.blitPS);
m_CustomBlitMaterail = CoreUtils.CreateEngineMaterial(data.shaders.customBlitPS);
m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(data.shaders.copyDepthPS);
m_SamplingMaterial = CoreUtils.CreateEngineMaterial(data.shaders.samplingPS);
m_ScreenspaceShadowsMaterial = CoreUtils.CreateEngineMaterial(data.shaders.screenSpaceShadowPS);
StencilStateData stencilData = data.defaultStencilState;
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);
}
protected override void Execute(CustomPassContext ctx)
{
// We first render objects into the user stencil bit 0, this will allow us to detect
// if the object is behind another object.
stencilMaterial.SetInt("_StencilWriteMask", (int)UserStencilUsage.UserBit0);
RenderObjects(ctx.renderContext, ctx.cmd, stencilMaterial, 0, CompareFunction.LessEqual, ctx.cullingResults, ctx.hdCamera);
// Then we render the objects that are behind walls using the stencil buffer with Greater Equal ZTest:
StencilState seeThroughStencil = new StencilState(
enabled: true,
readMask: (byte)UserStencilUsage.UserBit0,
compareFunction: CompareFunction.Equal
);
RenderObjects(ctx.renderContext, ctx.cmd, seeThroughMaterial, seeThroughMaterial.FindPass("ForwardOnly"), CompareFunction.GreaterEqual, ctx.cullingResults, ctx.hdCamera, seeThroughStencil);
}
public ShadowRenderer(ShadowRendererData data) : base(data)
{
Material blitMaterial = CoreUtils.CreateEngineMaterial(data.shaders.blitPS);
Material copyDepthMaterial = CoreUtils.CreateEngineMaterial(data.shaders.copyDepthPS);
Material samplingMaterial = CoreUtils.CreateEngineMaterial(data.shaders.samplingPS);
Material screenspaceShadowsMaterial = CoreUtils.CreateEngineMaterial(data.shaders.screenSpaceShadowPS);
StencilStateData stencilData = data.defaultStencilState;
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);
// Note: Since all custom render passes inject first and we have stable sort,
// we inject the builtin passes in the before events.
m_MainLightShadowCasterPass = new MainLightShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
m_AdditionalLightsShadowCasterPass = new AdditionalLightsShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
m_DepthPrepass = new DepthOnlyPass(RenderPassEvent.BeforeRenderingPrepasses, RenderQueueRange.opaque, LayerMask.GetMask("AR", "Tridify", "Outline"));
m_ScreenSpaceShadowResolvePass = new ScreenSpaceShadowResolvePass(RenderPassEvent.BeforeRenderingPrepasses, screenspaceShadowsMaterial);
m_CopyDepthPass = new CopyDepthPass(RenderPassEvent.BeforeRenderingOpaques, copyDepthMaterial);
m_CopyColorPass = new CopyColorPass(RenderPassEvent.BeforeRenderingTransparents, samplingMaterial);
m_CapturePass = new CapturePassCopy(RenderPassEvent.AfterRendering);
m_FinalBlitPass = new FinalBlitPass(RenderPassEvent.AfterRendering, blitMaterial);
#if UNITY_EDITOR
m_SceneViewDepthCopyPass = new SceneViewDepthCopyPassCopy(RenderPassEvent.AfterRendering + 9, copyDepthMaterial);
#endif
// RenderTexture format depends on camera and pipeline (HDR, non HDR, etc)
// Samples (MSAA) depend on camera and pipeline
m_CameraColorAttachment.Init("_CameraColorTexture");
m_CameraDepthAttachment.Init("_CameraDepthAttachment");
m_DepthTexture.Init("_CameraDepthTexture");
m_OpaqueColor.Init("_CameraOpaqueTexture");
m_ForwardLights = new ForwardLights();
}
public bool Equals(GLCmdBufferPipelineItem other)
{
// if (!Pipeline.Equals (other.Pipeline))
// return false;
//
// if (!Pass.Equals (other.Pass))
// return false;
if (!Flags.Equals(other.Flags))
{
return(false);
}
if (!DepthState.Equals(other.DepthState))
{
return(false);
}
if (!StencilState.Equals(other.StencilState))
{
return(false);
}
// if (!Rasterization.Equals (other.Rasterization))
// return false;
if (!ColorBlendEnums.Equals(other.ColorBlendEnums))
{
return(false);
}
if (!ClearValues.Equals(other.ClearValues))
{
return(false);
}
return(true);
}
public void Render()
{
Framebuffer.Execute();
Viewport.Execute();
BlendState.Execute();
FaceCullState.Execute();
MaskState.Execute();
DepthState.Execute();
StencilState.Execute();
Clear.Execute();
camera.UpdateFrame();
camera.UpdateViewport(Viewport.Viewport);
foreach (var item in renderItems)
{
#if false
if (item.Model.Frame != frame)
{
camera.UpdateModelFrame(frame);
}
#endif
//item.Batch.Mesh.ApplyAttributes(
}
}
public override void Create()
{
//模板缓冲相关设置
StencilStateData stencilData = new StencilStateData()
{
passOperation = StencilOp.Replace
}; // 默认与延迟渲染兼容
//模板缓冲状态设置
var 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);
// Bits [5,6] are used for material types.
StencilState forwardOnlyStencilState = OverwriteStencil(m_DefaultStencilState, 0b_0110_0000);
forwardOnlyStencilState.enabled = false;
int forwardOnlyStencilRef = stencilData.stencilReference | 0b_0000_0000;
//能被识别的有这些Tag的ShaderPass
ShaderTagId[] forwardOnlyShaderTagIds = new ShaderTagId[] {
new ShaderTagId("SRPDefaultUnlit"), new ShaderTagId("UniversalForward"), new ShaderTagId("UniversalForwardOnly"), new ShaderTagId("LightweightForward")
};
//本示例只给出不透明和半透明两种队列选择
var queueRange = m_Queue == RenderQueue.opaque ? RenderQueueRange.opaque : RenderQueueRange.transparent;
m_Pass = new CustomRendererPass("RenderObjectTest", forwardOnlyShaderTagIds, m_Queue == RenderQueue.opaque, passEvent, queueRange, layerMask, forwardOnlyStencilState, forwardOnlyStencilRef);
//将拷贝颜色和深度信息配置传到Pass里
m_Pass.Init(m_Color, m_Depth, m_TexName, m_TexFormat);
}
public DrawObjectsPass(string profilerTag, ShaderTagId[] shaderTagIds, bool opaque, RenderPassEvent evt, RenderQueueRange renderQueueRange, LayerMask layerMask, StencilState stencilState, int stencilReference)
{
base.profilingSampler = new ProfilingSampler(nameof(DrawObjectsPass));
m_ProfilerTag = profilerTag;
m_ProfilingSampler = new ProfilingSampler(profilerTag);
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;
}
}
public void SetStencilState(StencilState state)
{
stencilState = state;
stencilStateDirty = true;
}
// 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();
}
}
private void Draw(DrawState state, Vector2 scale, byte clipDepth)
{
Element parent = this.parent;
Matrix matrix;
if (parent == null)
{
this.clipTestActive = false;
state.RenderState.Push();
state.RenderState.CurrentRasterState.MultiSampleAntiAlias = false;
state.RenderState.CurrentDepthState.DepthWriteEnabled = WriteToDepth;
state.RenderState.CurrentDepthState.DepthTestEnabled = WriteToDepth;
if (camera == null)
{
camera = state.Application.UserValues[cameraID] as Xen.Camera.Camera2D;
if (camera == null)
{
camera = new Xen.Camera.Camera2D(true);
state.Application.UserValues[cameraID] = camera;
}
}
state.Camera.Push(camera);
}
else
this.clipTestActive = parent.clipTestActive | parent.ClipsChildren;
StencilState stencilState = new StencilState();
if (clipTestActive)
{
stencilState.Enabled = true;
stencilState.ReferenceValue = clipDepth;
stencilState.StencilFunction = CompareFunction.Equal;
stencilState.StencilPassOperation = StencilOperation.Keep;
}
bool clearStencil = false;
if (this.ClipsChildren)
{
clearStencil = clipDepth == 255;
clipDepth--;
if (!clipTestActive)
{
//check there actually is a stencil buffer
#if DEBUG
DepthFormat format = state.DrawTarget.SurfaceDepthFormat;
if (format != DepthFormat.Depth24Stencil8)
throw new InvalidOperationException("ElementRect.ClipChildren requires the DrawTarget has a valid Depth Buffer with an 8bit Stencil Buffer");
#endif
stencilState.Enabled = true;
stencilState.ReferenceValue = clipDepth;
stencilState.StencilPassOperation = StencilOperation.Replace;
}
else
stencilState.StencilPassOperation = StencilOperation.Decrement;
}
if ((scale.X != 0 && scale.Y != 0))
{
Vector2 size = ElementSize;
GetDisplayMatrix(out matrix, scale, ref size);
using (state.WorldMatrix.PushMultiply(ref matrix))
{
IShader shader = BindShader(state, false);
if (shader != null)
state.Shader.Push(shader);
state.RenderState.CurrentBlendState = blend;
state.RenderState.CurrentStencilState = stencilState;
if (!UseSize)
size = new Vector2(1, 1);
else
if (IsNormalised)
size *= scale;
PreDraw(size);
DrawElement(state);
List<Element> children = Children;
if (children != null)
foreach (Element child in children)
if (((IDraw)child).CullTest(state))
child.Draw(state, size, clipDepth);
if (shader != null)
state.Shader.Pop();
if (clearStencil)
{
shader = BindShader(state, true);
if (shader != null)
state.Shader.Push(shader);
stencilState = new StencilState();
stencilState.Enabled = true;
stencilState.StencilFunction = CompareFunction.Never;
stencilState.StencilFailOperation = StencilOperation.Zero;
state.RenderState.CurrentStencilState = stencilState;
DrawElement(state);
if (shader != null)
state.Shader.Pop();
}
}
}
if (parent == null)
{
state.RenderState.Pop();
state.Camera.Pop();
}
}
public ForwardRenderer(ForwardRendererData data) : base(data)
{
#if ENABLE_VR && ENABLE_XR_MODULE
UniversalRenderPipeline.m_XRSystem.InitializeXRSystemData(data.xrSystemData);
#endif
m_BlitMaterial = CoreUtils.CreateEngineMaterial(data.shaders.blitPS);
m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(data.shaders.copyDepthPS);
m_SamplingMaterial = CoreUtils.CreateEngineMaterial(data.shaders.samplingPS);
m_ScreenspaceShadowsMaterial = CoreUtils.CreateEngineMaterial(data.shaders.screenSpaceShadowPS);
StencilStateData stencilData = data.defaultStencilState;
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);
// Note: Since all custom render passes inject first and we have stable sort,
// we inject the builtin passes in the before events.
m_MainLightShadowCasterPass = new MainLightShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
m_AdditionalLightsShadowCasterPass = new AdditionalLightsShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
#if ENABLE_VR && ENABLE_XR_MODULE
m_XROcclusionMeshPass = new XROcclusionMeshPass(RenderPassEvent.BeforeRenderingOpaques);
#endif
m_DepthPrepass = new DepthOnlyPass(RenderPassEvent.BeforeRenderingPrepasses, RenderQueueRange.opaque, data.opaqueLayerMask);
m_DepthNormalPrepass = new DepthNormalOnlyPass(RenderPassEvent.BeforeRenderingPrepasses, RenderQueueRange.opaque, data.opaqueLayerMask);
m_ColorGradingLutPass = new ColorGradingLutPass(RenderPassEvent.BeforeRenderingPrepasses, data.postProcessData);
m_RenderOpaqueForwardPass = new DrawObjectsPass(URPProfileId.DrawOpaqueObjects, true, RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference);
m_CopyDepthPass = new CopyDepthPass(RenderPassEvent.AfterRenderingSkybox, m_CopyDepthMaterial);
m_DrawSkyboxPass = new DrawSkyboxPass(RenderPassEvent.BeforeRenderingSkybox);
m_CopyColorPass = new CopyColorPass(RenderPassEvent.AfterRenderingSkybox, m_SamplingMaterial, m_BlitMaterial);
#if ADAPTIVE_PERFORMANCE_2_0_0_OR_NEWER
if (!UniversalRenderPipeline.asset.useAdaptivePerformance || AdaptivePerformance.AdaptivePerformanceRenderSettings.SkipTransparentObjects == false)
#endif
{
m_TransparentSettingsPass = new TransparentSettingsPass(RenderPassEvent.BeforeRenderingTransparents, data.shadowTransparentReceive);
m_RenderTransparentForwardPass = new DrawObjectsPass(URPProfileId.DrawTransparentObjects, false, RenderPassEvent.BeforeRenderingTransparents, RenderQueueRange.transparent, data.transparentLayerMask, m_DefaultStencilState, stencilData.stencilReference);
}
m_OnRenderObjectCallbackPass = new InvokeOnRenderObjectCallbackPass(RenderPassEvent.BeforeRenderingPostProcessing);
m_PostProcessPass = new PostProcessPass(RenderPassEvent.BeforeRenderingPostProcessing, data.postProcessData, m_BlitMaterial);
m_FinalPostProcessPass = new PostProcessPass(RenderPassEvent.AfterRendering + 1, data.postProcessData, m_BlitMaterial);
m_CapturePass = new CapturePass(RenderPassEvent.AfterRendering);
m_FinalBlitPass = new FinalBlitPass(RenderPassEvent.AfterRendering + 1, m_BlitMaterial);
#if UNITY_EDITOR
m_SceneViewDepthCopyPass = new SceneViewDepthCopyPass(RenderPassEvent.AfterRendering + 9, m_CopyDepthMaterial);
#endif
// RenderTexture format depends on camera and pipeline (HDR, non HDR, etc)
// Samples (MSAA) depend on camera and pipeline
m_CameraColorAttachment.Init("_CameraColorTexture");
m_CameraDepthAttachment.Init("_CameraDepthAttachment");
m_DepthTexture.Init("_CameraDepthTexture");
m_NormalsTexture.Init("_CameraNormalsTexture");
m_OpaqueColor.Init("_CameraOpaqueTexture");
m_AfterPostProcessColor.Init("_AfterPostProcessTexture");
m_ColorGradingLut.Init("_InternalGradingLut");
m_ForwardLights = new ForwardLights();
supportedRenderingFeatures = new RenderingFeatures()
{
cameraStacking = true,
};
}
[ThreadSafe] public extern static IntPtr CreateStencilState(StencilState stencilState);
public GBufferPass(RenderPassEvent evt, RenderQueueRange renderQueueRange, LayerMask layerMask, StencilState stencilState, int stencilReference, DeferredLights deferredLights)
{
base.renderPassEvent = evt;
m_DeferredLights = deferredLights;
m_HasDepthPrepass = false;
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;
}
}
internal DrawObjectsPass(URPProfileId profileId, bool opaque, RenderPassEvent evt, RenderQueueRange renderQueueRange, LayerMask layerMask, StencilState stencilState, int stencilReference)
: this(profileId.GetType().Name, opaque, evt, renderQueueRange, layerMask, stencilState, stencilReference)
{
m_ProfilingSampler = ProfilingSampler.Get(profileId);
}
public DrawObjectsPass(string profilerTag, bool opaque, RenderPassEvent evt, RenderQueueRange renderQueueRange, LayerMask layerMask, StencilState stencilState, int stencilReference)
: this(profilerTag,
new ShaderTagId[] { new ShaderTagId("SRPDefaultUnlit"), new ShaderTagId("UniversalForward"), new ShaderTagId("UniversalForwardOnly"), new ShaderTagId("LightweightForward") },
opaque, evt, renderQueueRange, layerMask, stencilState, stencilReference)
{
}
public DrawOutlinePass(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("Outline"));
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;
}
}