private void EndForwardRendering(Camera camera, ref ScriptableRenderContext context, bool stereoEnabled) { if (m_RenderToIntermediateTarget) { var cmd = CommandBufferPool.Get("Blit"); if (m_IntermediateTextureArray) { cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, 0, CubemapFace.Unknown, -1); cmd.Blit(m_CameraRTID, BuiltinRenderTextureType.CurrentActive); } else { cmd.Blit(BuiltinRenderTextureType.CurrentActive, BuiltinRenderTextureType.CameraTarget); } if (camera.cameraType == CameraType.SceneView) { cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget); } context.ExecuteCommandBuffer(cmd); CommandBufferPool.Release(cmd); } if (stereoEnabled) { context.StopMultiEye(camera); context.StereoEndRender(camera); } }
private void EndForwardRendering(ref ScriptableRenderContext context, bool stereoEnabled, bool postProcessing) { if (m_RenderToIntermediateTarget || postProcessing) { var cmd = CommandBufferPool.Get("Blit"); if (m_IntermediateTextureArray) { cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, 0, CubemapFace.Unknown, -1); cmd.Blit(m_CameraRTID, BuiltinRenderTextureType.CurrentActive); } // If PostProcessing is enabled, it is already blitted to CameraTarget. else if (!postProcessing) { cmd.Blit(BuiltinRenderTextureType.CurrentActive, BuiltinRenderTextureType.CameraTarget); } cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget); context.ExecuteCommandBuffer(cmd); CommandBufferPool.Release(cmd); } if (stereoEnabled) { context.StopMultiEye(m_CurrCamera); context.StereoEndRender(m_CurrCamera); } }
/// <inheritdoc/> public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData) { Camera camera = renderingData.cameraData.camera; context.StopMultiEye(camera); context.StereoEndRender(camera); }
public void Render(ScriptableRenderContext renderContext, Camera camera, VXGIRenderer renderer) { UpdateResolution(); float realtime = Time.realtimeSinceStartup; bool tracingThrottled = throttleTracing; #if UNITY_EDITOR tracingThrottled &= UnityEditor.EditorApplication.isPlaying; #endif if (tracingThrottled) { if (_previousTrace + 1f / tracingRate < realtime) { _previousTrace = realtime; PrePass(renderContext, renderer); } } else { PrePass(renderContext, renderer); } renderContext.SetupCameraProperties(camera, camera.stereoEnabled); if (camera.stereoEnabled) { renderContext.StartMultiEye(camera); } _command.ClearRenderTarget( (camera.clearFlags & CameraClearFlags.Depth) != 0, camera.clearFlags == CameraClearFlags.Color, camera.backgroundColor ); renderContext.ExecuteCommandBuffer(_command); _command.Clear(); if (camera.clearFlags == CameraClearFlags.Skybox) { renderContext.DrawSkybox(camera); } if (visualizeMipmap) { renderer.RenderMipmap(renderContext, camera, this); } else { SetupShader(renderContext); renderer.RenderDeferred(renderContext, camera, this); } if (camera.stereoEnabled) { renderContext.StopMultiEye(camera); renderContext.StereoEndRender(camera); } }
public override void Execute(LightweightForwardRenderer renderer, ref ScriptableRenderContext context, ref CullResults cullResults, ref RenderingData renderingData) { Camera camera = renderingData.cameraData.camera; context.StopMultiEye(camera); context.StereoEndRender(camera); }
/// <inheritdoc/> public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData) { if (renderer == null) { throw new ArgumentNullException("renderer"); } Camera camera = renderingData.cameraData.camera; context.StopMultiEye(camera); context.StereoEndRender(camera); }
public override void Execute(ref ScriptableRenderContext context, ref CullResults cullResults, ref RenderingData renderingData) { Camera camera = renderingData.cameraData.camera; bool dynamicBatching = renderingData.supportsDynamicBatching; SetupShaderConstants(ref context, ref renderingData.cameraData, ref renderingData.lightData, ref renderingData.shadowData); RendererConfiguration rendererConfiguration = GetRendererConfiguration(renderingData.lightData.totalAdditionalLightsCount); if (renderingData.cameraData.isStereoEnabled) { context.StartMultiEye(camera); } RenderOpaques(ref context, ref cullResults, ref renderingData.cameraData, rendererConfiguration, dynamicBatching); if (renderingData.cameraData.postProcessEnabled && renderingData.cameraData.postProcessLayer.HasOpaqueOnlyEffects(renderer.postProcessRenderContext)) { OpaquePostProcessSubPass(ref context, ref renderingData.cameraData); } if (depthAttachmentHandle != -1) { CopyDepthSubPass(ref context, ref renderingData.cameraData); } if (renderingData.cameraData.requiresOpaqueTexture) { CopyColorSubpass(ref context, ref renderingData.cameraData); } RenderTransparents(ref context, ref cullResults, ref renderingData.cameraData, rendererConfiguration, dynamicBatching); if (renderingData.cameraData.postProcessEnabled) { PostProcessPass(ref context, ref renderingData.cameraData); } else if (!renderingData.cameraData.isOffscreenRender && colorAttachmentHandle != -1) { FinalBlitPass(ref context, ref renderingData.cameraData); } if (renderingData.cameraData.isStereoEnabled) { context.StopMultiEye(camera); context.StereoEndRender(camera); } }
private void EndForwardRendering(ref ScriptableRenderContext context, FrameRenderingConfiguration renderingConfig, CameraContext cameraContext) { // No additional rendering needs to be done if this is an off screen rendering camera if (cameraContext.IsOffscreenCamera) { return; } var camera = cameraContext.Camera; m_TextureUtil.Blit(context, m_TextureUtil.CurrCameraColorRT, renderingConfig, camera); if (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.Stereo)) { context.StopMultiEye(camera); context.StereoEndRender(camera); } }
// Main entry point for our scriptable render loop public static void Render(ScriptableRenderContext context, IEnumerable <Camera> cameras, bool useIntermediateBlitPath) { bool stereoEnabled = XRSettings.isDeviceActive; foreach (var 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); } RenderTargetIdentifier intermediateRTID = new RenderTargetIdentifier(BuiltinRenderTextureType.CurrentActive); bool isIntermediateRTTexArray = false; if (useIntermediateBlitPath) { ConfigureAndBindIntermediateRenderTarget(context, camera, stereoEnabled, out intermediateRTID, out isIntermediateRTTexArray); } // clear depth buffer var cmd = CommandBufferPool.Get(); cmd.ClearRenderTarget(true, false, Color.black); context.ExecuteCommandBuffer(cmd); CommandBufferPool.Release(cmd); // Setup global lighting shader variables SetupLightShaderVariables(cull.visibleLights, context); // Draw opaque objects using BasicPass shader pass var drawSettings = new DrawRendererSettings(camera, new ShaderPassName("BasicPass")) { sorting = { flags = SortFlags.CommonOpaque } }; var filterSettings = new FilterRenderersSettings(true) { renderQueueRange = RenderQueueRange.opaque }; context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings); // Draw skybox context.DrawSkybox(camera); // Draw transparent objects using BasicPass shader pass drawSettings.sorting.flags = SortFlags.CommonTransparent; filterSettings.renderQueueRange = RenderQueueRange.transparent; context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings); if (useIntermediateBlitPath) { BlitFromIntermediateToCameraTarget(context, intermediateRTID, isIntermediateRTTexArray); } 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(); } }
public void RenderDeferred(ScriptableRenderContext renderContext, Camera camera, VXGI vxgi) { OnPreRender(camera); // SetDesc(); ScriptableCullingParameters cullingParams; if (!CullResults.GetCullingParameters(camera, out cullingParams)) { return; } CullResults.Cull(ref cullingParams, renderContext, ref _cullResults); //Initialize Stereo renderContext.SetupCameraProperties(camera, camera.stereoEnabled); if (camera.stereoEnabled) { renderContext.StartMultiEye(camera); } int width = camera.pixelWidth; int height = camera.pixelHeight; _command.GetTemporaryRT(_cameraDepthTextureID, width, height, 24, FilterMode.Point, RenderTextureFormat.Depth, RenderTextureReadWrite.Linear); _command.GetTemporaryRT(_cameraGBufferTexture0ID, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear); _command.GetTemporaryRT(_cameraGBufferTexture1ID, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear); _command.GetTemporaryRT(_cameraGBufferTexture2ID, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGB2101010, RenderTextureReadWrite.Linear); _command.GetTemporaryRT(_cameraGBufferTexture3ID, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear); _command.GetTemporaryRT(_frameBufferID, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear); _command.SetRenderTarget(_gBufferBinding); _command.ClearRenderTarget(true, true, Color.clear); renderContext.ExecuteCommandBuffer(_command); _command.Clear(); var drawSettings = new DrawRendererSettings(camera, new ShaderPassName("Deferred")); drawSettings.flags = _renderPipeline.drawRendererFlags; drawSettings.rendererConfiguration = _renderPipeline.rendererConfiguration; drawSettings.sorting.flags = SortFlags.CommonOpaque; renderContext.DrawRenderers(_cullResults.visibleRenderers, ref drawSettings, _filterSettings); if (camera.cameraType != CameraType.SceneView) { _command.EnableShaderKeyword("PROJECTION_PARAMS_X"); } else { _command.DisableShaderKeyword("PROJECTION_PARAMS_X"); } _command.GetTemporaryRT(_dummyID, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear); _command.Blit(_cameraDepthTextureID, BuiltinRenderTextureType.CameraTarget, UtilityShader.material, (int)UtilityShader.Pass.DepthCopy); //WORKS //It seems there is an issue everywhere we sample this BuiltinRenderTextureType.CameraTarget _command.Blit(BuiltinRenderTextureType.CameraTarget, _dummyID, UtilityShader.material, (int)UtilityShader.Pass.BlitCopy); _command.Blit(_dummyID, _frameBufferID); _command.ReleaseTemporaryRT(_dummyID); renderContext.ExecuteCommandBuffer(_command); _command.Clear(); // Matrix4x4 _WorldToCameraMatrix = camera.worldToCameraMatrix; // Matrix4x4 _CameraToWorldMatrix = _WorldToCameraMatrix.inverse; // Matrix4x4 _ProjectionMatrix = GL.GetGPUProjectionMatrix(camera.projectionMatrix, false); // Matrix4x4 _ViewProjectionMatrix = _ProjectionMatrix * _CameraToWorldMatrix; Matrix4x4 clipToWorld = camera.cameraToWorldMatrix * GL.GetGPUProjectionMatrix(camera.projectionMatrix, false).inverse; _command.SetGlobalMatrix("ClipToWorld", clipToWorld); _command.SetGlobalMatrix("ClipToVoxel", vxgi.worldToVoxel * clipToWorld); _command.SetGlobalMatrix("WorldToVoxel", vxgi.worldToVoxel); _command.SetGlobalMatrix("VoxelToWorld", vxgi.voxelToWorld); bool depthNormalsNeeded = (camera.depthTextureMode & DepthTextureMode.DepthNormals) != DepthTextureMode.None; if (depthNormalsNeeded) { _command.GetTemporaryRT(_cameraDepthNormalsTextureID, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear); _command.Blit(_cameraDepthTextureID, _cameraDepthNormalsTextureID, UtilityShader.material, (int)UtilityShader.Pass.EncodeDepthNormal); } renderContext.ExecuteCommandBuffer(_command); _command.Clear(); _renderScale[2] = vxgi.diffuseResolutionScale; for (int i = 0; i < _lightingPasses.Length; i++) { _lightingPasses[i].Execute(renderContext, camera, _frameBufferID, _renderScale[i]); } RenderPostProcessing(renderContext, camera); _command.Blit(_frameBufferID, BuiltinRenderTextureType.CameraTarget); RenderPostProcessingDebug(renderContext, camera); if (depthNormalsNeeded) { _command.ReleaseTemporaryRT(_cameraDepthNormalsTextureID); } _command.ReleaseTemporaryRT(_cameraDepthTextureID); _command.ReleaseTemporaryRT(_cameraGBufferTexture0ID); _command.ReleaseTemporaryRT(_cameraGBufferTexture1ID); _command.ReleaseTemporaryRT(_cameraGBufferTexture2ID); _command.ReleaseTemporaryRT(_cameraGBufferTexture3ID); _command.ReleaseTemporaryRT(_frameBufferID); renderContext.ExecuteCommandBuffer(_command); //Deactivate Stereo if (camera.stereoEnabled) { renderContext.StopMultiEye(camera); renderContext.StereoEndRender(camera); } _command.Clear(); }
// 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(); } }
public void Render(ScriptableRenderContext renderContext, Camera camera) { #if UNITY_EDITOR if (camera.cameraType == CameraType.SceneView) { ScriptableRenderContext.EmitWorldGeometryForSceneView(camera); } #endif // UNITY_EDITOR renderContext.SetupCameraProperties(camera, camera.stereoEnabled); if (camera.TryGetCullingParameters(true, out ScriptableCullingParameters cullingParameters) == false) { return; } CullResults = renderContext.Cull(ref cullingParameters); CommandBuffer.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, 0, CubemapFace.Unknown, -1); if (camera.stereoEnabled) { CommandBuffer.SetSinglePassStereo(SinglePassStereoMode.Instancing); renderContext.StartMultiEye(camera); } else { CommandBuffer.SetSinglePassStereo(SinglePassStereoMode.None); } CommandBuffer.ClearRenderTarget(true, true, camera.backgroundColor, 1.0f); renderContext.ExecuteCommandBuffer(CommandBuffer); CommandBuffer.Clear(); SortingSettings sortingSettings = new SortingSettings(camera); sortingSettings.criteria = SortingCriteria.CommonOpaque; DrawingSettings drawSettings = new DrawingSettings(new ShaderTagId("SRPDefaultUnlit"), sortingSettings); drawSettings.enableDynamicBatching = false; drawSettings.enableInstancing = true; drawSettings.sortingSettings = sortingSettings; drawSettings.perObjectData = 0; FilteringSettings filterSettings = new FilteringSettings(RenderQueueRange.opaque); renderContext.DrawRenderers(CullResults, ref drawSettings, ref filterSettings); if (camera.stereoEnabled) { renderContext.StopMultiEye(camera); } #if UNITY_EDITOR if (UnityEditor.Handles.ShouldRenderGizmos()) { renderContext.DrawGizmos(camera, GizmoSubset.PreImageEffects); renderContext.DrawGizmos(camera, GizmoSubset.PostImageEffects); } #endif // UNITY_EDITOR if (camera.stereoEnabled) { renderContext.StereoEndRender(camera); } renderContext.Submit(); }