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); }