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