public override void Execute(ref ScriptableRenderContext context, ref CullResults cullResults, ref RenderingData renderingData)
{
if (renderingData.shadowData.renderedDirectionalShadowQuality == LightShadows.None)
{
return;
}
CommandBuffer cmd = CommandBufferPool.Get("Collect Shadows");
SetShadowCollectPassKeywords(cmd, ref renderingData.shadowData);
// Note: The source isn't actually 'used', but there's an engine peculiarity (bug) that
// doesn't like null sources when trying to determine a stereo-ized blit. So for proper
// stereo functionality, we use the screen-space shadow map as the source (until we have
// a better solution).
// An alternative would be DrawProcedural, but that would require further changes in the shader.
RenderTargetIdentifier screenSpaceOcclusionTexture = GetSurface(colorAttachmentHandle);
SetRenderTarget(cmd, screenSpaceOcclusionTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
ClearFlag.Color | ClearFlag.Depth, Color.white);
cmd.Blit(screenSpaceOcclusionTexture, screenSpaceOcclusionTexture, m_ScreenSpaceShadowsMaterial);
if (renderingData.cameraData.isStereoEnabled)
{
Camera camera = renderingData.cameraData.camera;
context.StartMultiEye(camera);
context.ExecuteCommandBuffer(cmd);
context.StopMultiEye(camera);
}
else
{
context.ExecuteCommandBuffer(cmd);
}
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
Camera camera = renderingData.cameraData.camera;
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);
}
}
public override void Execute(ref ScriptableRenderContext context, ref CullResults cullResults, ref RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get(k_DepthPrepassTag);
using (new ProfilingSample(cmd, k_SetupRenderTargetTag))
{
SetRenderTarget(cmd, GetSurface(depthAttachmentHandle), RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
ClearFlag.Depth, Color.black);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
var drawSettings = CreateDrawRendererSettings(renderingData.cameraData.camera, SortFlags.CommonOpaque, RendererConfiguration.None, renderingData.supportsDynamicBatching);
if (renderingData.cameraData.isStereoEnabled)
{
Camera camera = renderingData.cameraData.camera;
context.StartMultiEye(camera);
context.DrawRenderers(cullResults.visibleRenderers, ref drawSettings, renderer.opaqueFilterSettings);
context.StopMultiEye(camera);
}
else
{
context.DrawRenderers(cullResults.visibleRenderers, ref drawSettings, renderer.opaqueFilterSettings);
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public static void StopStereoRendering(Camera camera, ref ScriptableRenderContext context, FrameRenderingConfiguration renderingConfiguration)
{
if (CoreUtils.HasFlag(renderingConfiguration, FrameRenderingConfiguration.Stereo))
{
context.StopMultiEye(camera);
}
}
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);
}
}
public override void Execute(LightweightForwardRenderer renderer, ref ScriptableRenderContext context,
ref CullResults cullResults,
ref RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get(k_DepthPrepassTag);
using (new ProfilingSample(cmd, k_DepthPrepassTag))
{
cmd.GetTemporaryRT(depthAttachmentHandle.id, descriptor, FilterMode.Point);
SetRenderTarget(
cmd,
depthAttachmentHandle.Identifier(),
RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
ClearFlag.Depth,
Color.black,
descriptor.dimension);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
var drawSettings = CreateDrawRendererSettings(renderingData.cameraData.camera, SortFlags.CommonOpaque, RendererConfiguration.None, renderingData.supportsDynamicBatching);
if (renderingData.cameraData.isStereoEnabled)
{
Camera camera = renderingData.cameraData.camera;
context.StartMultiEye(camera);
context.DrawRenderers(cullResults.visibleRenderers, ref drawSettings, opaqueFilterSettings);
context.StopMultiEye(camera);
}
else
context.DrawRenderers(cullResults.visibleRenderers, ref drawSettings, opaqueFilterSettings);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public static void Stop(ref ScriptableRenderContext context, FrameRenderingConfiguration renderingConfiguration, Camera currentCamera)
{
if (LightweightUtils.HasFlag(renderingConfiguration, FrameRenderingConfiguration.Stereo))
{
context.StopMultiEye(currentCamera);
}
}
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(ScriptableRenderContext context, ref RenderingData renderingData)
{
int kernel = GetComputeShaderKernel(ref renderingData.shadowData);
if (kernel == -1)
{
return;
}
var shadowLightIndex = renderingData.lightData.mainLightIndex;
var shadowLight = renderingData.lightData.visibleLights[shadowLightIndex];
var light = shadowLight.light;
dirVxShadowMap = light.GetComponent <DirectionalVxShadowMap>();
CommandBuffer cmd = CommandBufferPool.Get(k_CollectShadowsTag);
if (mainLightDynamicShadows)
{
mainLightShadowCasterPass.SetMainLightShadowReceiverConstantsOnComputeShader(
cmd, ref renderingData.shadowData, shadowLight, m_ScreenSpaceShadowsComputeShader);
}
SetupVxShadowReceiverConstants(
cmd, kernel, ref m_ScreenSpaceShadowsComputeShader, ref renderingData.cameraData.camera, ref shadowLight);
int x = (renderingData.cameraData.camera.pixelWidth + TileAdditive) / TileSize;
int y = (renderingData.cameraData.camera.pixelHeight + TileAdditive) / TileSize;
cmd.DispatchCompute(m_ScreenSpaceShadowsComputeShader, kernel, x, y, 1);
// even if the main light doesn't have dynamic shadows,
// cascades keyword is needed for screen space shadow map texture in opaque rendering pass.
if (mainLightDynamicShadows == false)
{
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.MainLightShadows, true);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.MainLightShadowCascades, true);
}
else
{
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.MainLightShadowCascades, true);
}
if (renderingData.cameraData.isStereoEnabled)
{
Camera camera = renderingData.cameraData.camera;
context.StartMultiEye(camera);
context.ExecuteCommandBuffer(cmd);
context.StopMultiEye(camera);
}
else
{
context.ExecuteCommandBuffer(cmd);
}
CommandBufferPool.Release(cmd);
}
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);
}
protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult)
{
if (injectionPoint != CustomPassInjectionPoint.AfterPostProcess)
{
Debug.LogError("CustomPassInjectionPoint shouild be set on AfterPostProcess");
return;
}
if (render && hdCamera.camera != bakeCamera && hdCamera.camera.cameraType != CameraType.SceneView)
{
bakeCamera.TryGetCullingParameters(out var cullingParams);
cullingParams.cullingOptions = CullingOptions.ShadowCasters;
cullingResult = renderContext.Cull(ref cullingParams);
var result = new RendererListDesc(shaderTags, cullingResult, bakeCamera)
{
rendererConfiguration = PerObjectData.None,
//renderQueueRange = RenderQueueRange.all,
renderQueueRange = GetRenderQueueRange(RenderQueueType.AllOpaque),
sortingCriteria = SortingCriteria.BackToFront,
excludeObjectMotionVectors = false,
layerMask = -1,
overrideMaterial = depthMaterial,
overrideMaterialPassIndex = depthMaterial.FindPass("ForwardOnly"),
};
//renderContext.StereoEndRender(hdCamera.camera);
renderContext.ExecuteCommandBuffer(cmd);
cmd.Clear();
renderContext.StopMultiEye(hdCamera.camera);
var p = GL.GetGPUProjectionMatrix(bakeCamera.projectionMatrix, true);
Matrix4x4 scaleMatrix = Matrix4x4.identity;
scaleMatrix.m22 = -1.0f;
var v = scaleMatrix * bakeCamera.transform.localToWorldMatrix.inverse;
var vp = p * v;
cmd.SetGlobalMatrix("_ViewMatrix", v);
cmd.SetGlobalMatrix("_InvViewMatrix", v.inverse);
cmd.SetGlobalMatrix("_ProjMatrix", p);
cmd.SetGlobalMatrix("_InvProjMatrix", p.inverse);
cmd.SetGlobalMatrix("_ViewProjMatrix", vp);
cmd.SetGlobalMatrix("_InvViewProjMatrix", vp.inverse);
cmd.SetGlobalMatrix("_CameraViewProjMatrix", vp);
cmd.SetGlobalVector("_WorldSpaceCameraPos", Vector3.zero);
cmd.SetGlobalVector("_ShadowClipPlanes", Vector3.zero);
CoreUtils.SetRenderTarget(cmd, depthFromCam, ClearFlag.All);
HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result));
renderContext.StartMultiEye(hdCamera.camera);
renderContext.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
}
/// <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);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (m_ScreenSpaceShadowsMaterial == null)
{
Debug.LogErrorFormat("Missing {0}. {1} render pass will not execute. Check for missing reference in the renderer resources.", m_ScreenSpaceShadowsMaterial, GetType().Name);
return;
}
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
if (renderingData.lightData.mainLightIndex == -1)
{
return;
}
CommandBuffer cmd = CommandBufferPool.Get(k_CollectShadowsTag);
cmd.GetTemporaryRT(colorAttachmentHandle.id, descriptor, FilterMode.Bilinear);
// Note: The source isn't actually 'used', but there's an engine peculiarity (bug) that
// doesn't like null sources when trying to determine a stereo-ized blit. So for proper
// stereo functionality, we use the screen-space shadow map as the source (until we have
// a better solution).
// An alternative would be DrawProcedural, but that would require further changes in the shader.
RenderTargetIdentifier screenSpaceOcclusionTexture = colorAttachmentHandle.Identifier();
SetRenderTarget(cmd, screenSpaceOcclusionTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
ClearFlag.Color | ClearFlag.Depth, Color.white, descriptor.dimension);
// This blit is troublesome. When MSAA is enabled it will render a fullscreen quad + store resolved MSAA + extra blit
// This consumes about 10MB of extra unnecessary bandwidth on boat attack.
// In order to avoid it we can do a cmd.DrawMesh instead, however because LWRP doesn't setup camera matrices itself,
// we would need to call an extra SetupCameraProperties here just to setup those matrices which is also troublesome.
// We need get rid of SetupCameraProperties and setup camera matrices in LWRP ASAP.
cmd.Blit(screenSpaceOcclusionTexture, screenSpaceOcclusionTexture, m_ScreenSpaceShadowsMaterial);
if (renderingData.cameraData.isStereoEnabled)
{
Camera camera = renderingData.cameraData.camera;
context.StartMultiEye(camera);
context.ExecuteCommandBuffer(cmd);
context.StopMultiEye(camera);
}
else
{
context.ExecuteCommandBuffer(cmd);
}
CommandBufferPool.Release(cmd);
}
protected override void Execute(ScriptableRenderContext context, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult)
{
if (OceanRenderer.Instance == null || OceanRenderer.Instance._lodDataShadow == null)
{
return;
}
var camera = hdCamera.camera;
// Custom passes execute for every camera. We only support one camera for now.
if (!ReferenceEquals(camera.transform, OceanRenderer.Instance.Viewpoint))
{
return;
}
if (context == null)
{
throw new System.ArgumentNullException("context");
}
// TODO: bail when not executing for main light or when no main light exists?
// if (renderingData.lightData.mainLightIndex == -1) return;
var commandBuffer = OceanRenderer.Instance._lodDataShadow.BufCopyShadowMap;
if (commandBuffer == null)
{
return;
}
// Target is not multi-eye so stop mult-eye rendering for this command buffer. Breaks registered shadow
// inputs without this.
if (camera.stereoEnabled)
{
context.StopMultiEye(camera);
}
context.ExecuteCommandBuffer(commandBuffer);
// Even if we do not call StopMultiEye, it is necessary to call StartMultiEye otherwise one eye no longer
// renders.
if (camera.stereoEnabled)
{
context.StartMultiEye(camera);
}
else
{
// Restore matrices otherwise remaining render will have incorrect matrices. Each pass is responsible
// for restoring matrices if required.
commandBuffer.Clear();
commandBuffer.SetViewProjectionMatrices(camera.worldToCameraMatrix, camera.projectionMatrix);
context.ExecuteCommandBuffer(commandBuffer);
}
}
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);
}
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get(k_RenderWaterFXTag);
RenderTextureDescriptor descriptor = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData);
descriptor.width = (int)(descriptor.width * 0.5f);
descriptor.height = (int)(descriptor.height * 0.5f);
descriptor.colorFormat = RenderTextureFormat.Default;
using (new ProfilingSample(cmd, k_RenderWaterFXTag))
{
cmd.GetTemporaryRT(m_WaterFX.id, descriptor, FilterMode.Bilinear);
SetRenderTarget(
cmd,
m_WaterFX.Identifier(),
RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
ClearFlag.Color,
new Color(0.0f, 0.5f, 0.5f, 0.5f),
descriptor.dimension);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
var drawSettings = CreateDrawingSettings(renderingData.cameraData.camera,
SortingCriteria.CommonTransparent, PerObjectData.None, renderingData.supportsDynamicBatching);
var filteringSettings = transparentFilterSettings;
if (renderingData.cameraData.isStereoEnabled)
{
Camera camera = renderingData.cameraData.camera;
context.StartMultiEye(camera);
context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filteringSettings);
context.StopMultiEye(camera);
}
else
{
context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filteringSettings);
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
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);
}
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
if (renderingData.lightData.mainLightIndex == -1)
{
return;
}
CommandBuffer cmd = CommandBufferPool.Get(k_CollectShadowsTag);
cmd.GetTemporaryRT(colorAttachmentHandle.id, descriptor, FilterMode.Bilinear);
VisibleLight shadowLight = renderingData.lightData.visibleLights[renderingData.lightData.mainLightIndex];
SetShadowCollectPassKeywords(cmd, ref shadowLight, ref renderingData.shadowData);
// Note: The source isn't actually 'used', but there's an engine peculiarity (bug) that
// doesn't like null sources when trying to determine a stereo-ized blit. So for proper
// stereo functionality, we use the screen-space shadow map as the source (until we have
// a better solution).
// An alternative would be DrawProcedural, but that would require further changes in the shader.
RenderTargetIdentifier screenSpaceOcclusionTexture = colorAttachmentHandle.Identifier();
SetRenderTarget(cmd, screenSpaceOcclusionTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
ClearFlag.Color | ClearFlag.Depth, Color.white, descriptor.dimension);
cmd.Blit(screenSpaceOcclusionTexture, screenSpaceOcclusionTexture, renderer.GetMaterial(MaterialHandle.ScreenSpaceShadow));
if (renderingData.cameraData.isStereoEnabled)
{
Camera camera = renderingData.cameraData.camera;
context.StartMultiEye(camera);
context.ExecuteCommandBuffer(cmd);
context.StopMultiEye(camera);
}
else
{
context.ExecuteCommandBuffer(cmd);
}
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
CommandBuffer cmd = CommandBufferPool.Get(k_DepthPrepassTag);
using (new ProfilingSample(cmd, k_DepthPrepassTag))
{
cmd.GetTemporaryRT(depthAttachmentHandle.id, descriptor, FilterMode.Point);
SetRenderTarget(
cmd,
depthAttachmentHandle.Identifier(),
RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
ClearFlag.Depth,
Color.black,
descriptor.dimension);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
var sortFlags = renderingData.cameraData.defaultOpaqueSortFlags;
var drawSettings = CreateDrawingSettings(renderingData.cameraData.camera, sortFlags, PerObjectData.None, renderingData.supportsDynamicBatching);
var filteringSettings = opaqueFilterSettings;
if (renderingData.cameraData.isStereoEnabled)
{
Camera camera = renderingData.cameraData.camera;
context.StartMultiEye(camera);
context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filteringSettings);
context.StopMultiEye(camera);
}
else
{
context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filteringSettings);
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
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();
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
CommandBuffer cmd = CommandBufferPool.Get(k_OITDepthPrepassTag);
using (new ProfilingSample(cmd, k_OITDepthPrepassTag))
{
//cmd.GetTemporaryRT(depthAttachmentHandle.id, descriptor, FilterMode.Point);
SetRenderTarget(
cmd,
depthAttachmentHandle.Identifier(),
RenderBufferLoadAction.Load,
RenderBufferStoreAction.Store,
ClearFlag.None,
Color.black,
descriptor.dimension);
if (descriptor.msaaSamples > 1)
{
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthNoMsaa);
if (descriptor.msaaSamples == 4)
{
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
}
else
{
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
}
}
else
{
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthNoMsaa);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
}
CoreUtils.SetKeyword(cmd, "_ALPHATEST_ON", true);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
var drawSettings = CreateDrawRendererSettings(renderingData.cameraData.camera, SortFlags.None, RendererConfiguration.None, renderingData.supportsDynamicBatching);
if (renderingData.cameraData.isStereoEnabled)
{
Camera camera = renderingData.cameraData.camera;
context.StartMultiEye(camera);
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, oitFilterSettings);
context.StopMultiEye(camera);
}
else
{
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, oitFilterSettings);
}
CoreUtils.SetKeyword(cmd, "_ALPHATEST_ON", false);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
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();
}
// 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();
}
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
CommandBuffer cmd = CommandBufferPool.Get(k_DepthNormalsTag);
using (new ProfilingSample(cmd, k_DepthNormalsTag))
{
cmd.GetTemporaryRT(depthNormalsHandle.id, descriptor, FilterMode.Bilinear);
if (isDepthPrepassEnabled)
{
SetRenderTarget(
cmd,
depthNormalsHandle.Identifier(),
RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
depthAttachmentHandle.Identifier(),
RenderBufferLoadAction.Load,
RenderBufferStoreAction.DontCare,
ClearFlag.Color,
Color.black,
TextureDimension.Tex2D);
cmd.DisableShaderKeyword("_ALPHATEST_ON");
}
else
{
SetRenderTarget(
cmd,
depthNormalsHandle.Identifier(),
RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
ClearFlag.Color | ClearFlag.Depth,
Color.black,
TextureDimension.Tex2D);
cmd.EnableShaderKeyword("_ALPHATEST_ON");
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
cmd.SetGlobalInt("_DepthNormalsZWrite", isDepthPrepassEnabled ? 0 : 1);
cmd.SetGlobalInt("_DepthNormalsZTest", (int)(isDepthPrepassEnabled ? ZTest.Equal : ZTest.LEqual));
var sortFlags = renderingData.cameraData.defaultOpaqueSortFlags;
var drawSettings = CreateDrawRendererSettings(renderingData.cameraData.camera, sortFlags, RendererConfiguration.None, renderingData.supportsDynamicBatching);
if (renderingData.cameraData.isStereoEnabled)
{
Camera camera = renderingData.cameraData.camera;
context.StartMultiEye(camera);
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, opaqueFilterSettings);
context.StopMultiEye(camera);
}
else
{
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, opaqueFilterSettings);
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
// 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();
}
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
m_asset.memoryConsumption = 0f;
instance = this;
display = displayList.Count > 0 && displayList[0].running ? displayList[0] : null;
bool xrEnabled = XRSettings.isDeviceActive;
// Sort cameras array by camera depth
Array.Sort(cameras, m_CameraComparer);
// SetupShaderGlobals
// =====================================================================================================
LogTrace("SetupShaderGlobals...");
{
CommandBuffer cmd5 = CommandBufferPool.Get("SetupShaderGlobals");
cmd5.SetGlobalFloat("g_AtlasResolutionScale",
m_asset.atlasResolutionScale / m_asset.visibilityPassDownscale);
float lerpFactor =
Mathf.Clamp01((float)timeSinceLastRender /
(1f / m_asset.atlasRefreshFps)); //TODO: clamp should't been neccesary
cmd5.SetGlobalFloat("g_atlasMorph", lerpFactor);
cmd5.SetGlobalTexture("g_Dither", m_asset.dither[0]);
if (m_asset.TexelSpaceBackfaceCulling)
{
cmd5.EnableShaderKeyword("TRIANGLE_CULLING");
}
else
{
cmd5.DisableShaderKeyword("TRIANGLE_CULLING");
}
context.ExecuteCommandBuffer(cmd5);
CommandBufferPool.Release(cmd5);
}
bool shouldUpdateAtlas = timeSinceLastRender > 1f / m_asset.atlasRefreshFps;
foreach (Camera camera in cameras)
{
//XR
SCREEN_X = camera.pixelWidth;
SCREEN_Y = camera.pixelHeight;
SortingSettings cameraSortSettings = new SortingSettings(camera);
ScriptableCullingParameters cullingParameters;
if (!camera.TryGetCullingParameters(xrEnabled, out cullingParameters))
{
continue;
}
m_CullResults = context.Cull(ref cullingParameters);
context.SetupCameraProperties(camera, xrEnabled);
#region XRtest
{
var cmd = CommandBufferPool.Get("Test");
if (display != null) //Vr is enabled
{
#region setup stero rendering
// XRTODO: Handle stereo mode selection in URP pipeline asset UI
display.textureLayout = XRDisplaySubsystem.TextureLayout.Texture2DArray;
display.zNear = camera.nearClipPlane;
display.zFar = camera.farClipPlane;
display.sRGB = QualitySettings.activeColorSpace == ColorSpace.Linear;
display.GetRenderPass(0, out XRDisplaySubsystem.XRRenderPass xrRenderPass);
cmd.SetRenderTarget(xrRenderPass.renderTarget);
xrRenderPass.GetRenderParameter(camera, 0, out var renderParameter0);
xrRenderPass.GetRenderParameter(camera, 1, out var renderParameter1);
#endregion
#region enable stero rendering
//enable single pass (see XRPass.cs:344)
if (SystemInfo.supportsMultiview)
{
cmd.EnableShaderKeyword("STEREO_MULTIVIEW_ON");
cmd.SetGlobalVectorArray("unity_StereoEyeIndices", stereoEyeIndices);
}
else
{
cmd.EnableShaderKeyword("STEREO_INSTANCING_ON");
const int viewCount = 2;
cmd.SetInstanceMultiplier((uint)viewCount);
}
cmd.EnableShaderKeyword(ShaderKeywordStrings.UseDrawProcedural);
#endregion
}
else
{
cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget);
}
cmd.ClearRenderTarget(true, true, Color.green);
context.ExecuteCommandBuffer(cmd);
//RenderOpaque(context, m_VistaPass, cameraSortSettings);
context.DrawSkybox(camera);
#region Disable stero rendering
if (SystemInfo.supportsMultiview)
{
cmd.DisableShaderKeyword("STEREO_MULTIVIEW_ON");
}
else
{
cmd.DisableShaderKeyword("STEREO_INSTANCING_ON");
cmd.SetInstanceMultiplier(1);
}
cmd.DisableShaderKeyword(ShaderKeywordStrings.UseDrawProcedural);
#endregion
}
#endregion
int targetAtlasSize = m_asset.maximalAtlasSizePixel;
if (g_VistaAtlas_A == null || g_VistaAtlas_A.width != targetAtlasSize)
{
CommandBuffer cmd5 = CommandBufferPool.Get("(Re)initialize Atlas");
if (g_VistaAtlas_A != null)
{
g_VistaAtlas_A.Release();
g_VistaAtlas_B.Release();
}
g_VistaAtlas_A = new RenderTexture(
targetAtlasSize,
targetAtlasSize,
0,
RenderTextureFormat.ARGB2101010,
RenderTextureReadWrite.sRGB);
g_VistaAtlas_A.Create();
g_VistaAtlas_B = new RenderTexture(g_VistaAtlas_A);
g_VistaAtlas_B.Create();
cmd5.SetRenderTarget(g_VistaAtlas_A);
cmd5.ClearRenderTarget(true, true, Color.black);
cmd5.SetRenderTarget(g_VistaAtlas_B);
cmd5.ClearRenderTarget(true, true, Color.black);
context.ExecuteCommandBuffer(cmd5);
CommandBufferPool.Release(cmd5);
}
// TODO: reuse uv output to skip rendering objects a third time in VistaPass
CommandBuffer createCameraRT = CommandBufferPool.Get("Create Camera RT");
createCameraRT.GetTemporaryRT(
g_CameraTarget,
SCREEN_X,
SCREEN_Y,
24,
FilterMode.Bilinear,
RenderTextureFormat.ARGB32,
RenderTextureReadWrite.sRGB,
Mathf.NextPowerOfTwo(m_asset.MSSALevel));
createCameraRT.SetRenderTarget(g_CameraTarget);
createCameraRT.ClearRenderTarget(true, true, Color.clear);
context.ExecuteCommandBuffer(createCameraRT);
if (shouldUpdateAtlas)
{
//Debug.Log(DateTime.Now.ToString("hh.mm.ss.ffffff") + "render" + timeSinceLastRender.ToString());
target_atlasA = !target_atlasA;
// =====================================================================================================
// CopyDataToPreFrameBuffer
// =====================================================================================================
// LogVerbose("CopyDataToPreFrameBuffer...");
CommandBuffer cmd = CommandBufferPool.Get("CopyDataToPreFrameBuffer");
cmd.SetComputeBufferParam(m_ResolveCS, m_cs_CopyDataToPreFrameBuffer, "g_ObjectToAtlasProperties",
g_ObjectToAtlasProperties);
cmd.SetComputeBufferParam(m_ResolveCS, m_cs_CopyDataToPreFrameBuffer, "g_prev_ObjectToAtlasProperties",
g_prev_ObjectToAtlasProperties);
uint threadsX, threadsY, threadsZ;
m_ResolveCS.GetKernelThreadGroupSizes(m_cs_CopyDataToPreFrameBuffer, out threadsX, out threadsY,
out threadsZ);
cmd.DispatchCompute(m_ResolveCS, m_cs_CopyDataToPreFrameBuffer,
Mathf.CeilToInt(MAXIMAL_OBJECTS_PER_VIEW / (float)64.0), 1, 1);
cmd.SetComputeBufferParam(m_ResolveCS, m_cs_InitalizePrimitiveVisiblity, g_PrimitiveVisibilityID,
g_PrimitiveVisibility);
cmd.DispatchCompute(m_ResolveCS, m_cs_InitalizePrimitiveVisiblity,
Mathf.CeilToInt(g_PrimitiveVisibility.count / (float)threadsX), 1, 1);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
// =====================================================================================================
// SetupRenderBuffers
// =====================================================================================================
LogTrace("SetupRenderBuffers...");
CommandBuffer cmd1 = CommandBufferPool.Get("SetupBuffers");
int screenX = camera.pixelWidth;
int screenY = camera.pixelHeight;
g_visibilityBuffer_dimension = new Vector2Int(
Mathf.CeilToInt(screenX / m_asset.visibilityPassDownscale),
Mathf.CeilToInt(screenY / m_asset.visibilityPassDownscale));
cmd1.GetTemporaryRT(g_VisibilityBufferID, g_visibilityBuffer_dimension.x,
g_visibilityBuffer_dimension.y, 32, FilterMode.Point, RenderTextureFormat.RInt,
RenderTextureReadWrite.Linear, 1);
cmd1.SetRenderTarget(g_visibilityBuffer_RT);
cmd1.ClearRenderTarget(true, true, Color.clear);
cmd1.SetRenderTarget(target_atlasA ? g_VistaAtlas_A : g_VistaAtlas_B);
if (m_asset.clearAtlasOnRefresh)
{
cmd1.ClearRenderTarget(true, true, Color.clear);
}
cmd1.SetGlobalTexture("g_VistaAtlas", target_atlasA ? g_VistaAtlas_A : g_VistaAtlas_B);
cmd1.SetGlobalTexture("g_prev_VistaAtlas", target_atlasA ? g_VistaAtlas_B : g_VistaAtlas_A);
cmd1.SetGlobalFloat("g_AtlasSizeExponent", m_asset.maximalAtlasSizeExponent);
context.ExecuteCommandBuffer(cmd1);
CommandBufferPool.Release(cmd1);
// =====================================================================================================
// Visiblity Pass
// Figure out what objects (and triangles) are visible and needed to be rendered.
// =====================================================================================================
// renders the current view as: objectID, primitveID and mipmap level
g_Object_MipmapLevelA.SetCounterValue(0);
CommandBuffer cmd2 = CommandBufferPool.Get("RenderTexelCoverage");
cmd2.SetRenderTarget(g_VisibilityBufferID);
//cmd.SetGlobalBuffer("g_ObjectToAtlasPropertiesRW", g_ObjectToAtlasProperties);
//cmd.SetRandomWriteTarget(1, g_ObjectToAtlasProperties);
//g_vertexIDVisiblity_B.SetData(g_vertexIDVisiblity_B_init);
context.ExecuteCommandBuffer(cmd2);
cameraSortSettings.criteria = SortingCriteria.OptimizeStateChanges;
context.StartMultiEye(camera);
RenderOpaque(context, m_VisibilityPass, cameraSortSettings);
context.StopMultiEye(camera);
cmd2.Clear();
cmd2.ClearRandomWriteTargets();
// VISIBLITY DISSOLVE PASS
// maps the previous rendered data into usable buffers
cmd2.SetComputeTextureParam(m_ResolveCS, m_cs_ExtractVisibility, g_VisibilityBufferID,
g_visibilityBuffer_RT);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_ExtractVisibility, g_PrimitiveVisibilityID,
g_PrimitiveVisibility);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_ExtractVisibility, "g_ObjectToAtlasProperties",
g_ObjectToAtlasProperties);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_ExtractVisibility, "g_ObjectMipMap_append",
g_Object_MipmapLevelA);
cmd2.DispatchCompute(m_ResolveCS, m_cs_ExtractVisibility, SCREEN_X / COMPUTE_COVERAGE_TILE_SIZE,
SCREEN_Y / COMPUTE_COVERAGE_TILE_SIZE, 1);
cmd2.CopyCounterValue(g_Object_MipmapLevelA, g_ObjectMipMapCounterValue, 0);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_MipMapFinalize, "g_ObjectMipMap_consume",
g_Object_MipmapLevelA);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_MipMapFinalize, "g_ObjectToAtlasProperties",
g_ObjectToAtlasProperties);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_MipMapFinalize, "g_ObjectMipMapCounterValue",
g_ObjectMipMapCounterValue);
cmd2.DispatchCompute(m_ResolveCS, m_cs_MipMapFinalize, 1, 1, 1);
context.ExecuteCommandBuffer(cmd2);
cmd2.Clear();
// optional debug pass
switch (m_asset.debugPass)
{
case TexelSpaceDebugMode.VisibilityPassObjectID:
case TexelSpaceDebugMode.VisibilityPassPrimitivID:
case TexelSpaceDebugMode.VisibilityPassMipMapPerObject:
case TexelSpaceDebugMode.VisibilityPassMipMapPerPixel:
int debugView = Shader.PropertyToID("g_DebugTexture");
cmd2.GetTemporaryRT(debugView, SCREEN_X, SCREEN_Y, 16, FilterMode.Point,
RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear, 1, true);
cmd2.SetComputeTextureParam(m_ResolveCS, m_cs_DebugVisibilityBuffer, g_VisibilityBufferID,
g_visibilityBuffer_RT);
cmd2.SetComputeTextureParam(m_ResolveCS, m_cs_DebugVisibilityBuffer, "g_DebugTexture",
debugView);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_DebugVisibilityBuffer,
"g_ObjectToAtlasPropertiesR", g_ObjectToAtlasProperties);
cmd2.SetComputeIntParam(m_ResolveCS, "g_DebugPassID", (int)m_asset.debugPass);
cmd2.DispatchCompute(
m_ResolveCS,
m_cs_DebugVisibilityBuffer,
SCREEN_X / 8,
SCREEN_Y / 8,
1);
cmd2.Blit(debugView, g_CameraTarget);
cmd2.ReleaseTemporaryRT(debugView);
context.ExecuteCommandBuffer(cmd2);
cmd2.Clear();
break;
}
CommandBufferPool.Release(cmd2);
// =====================================================================================================
// PackAtlas
// =====================================================================================================
LogTrace("PackAtlas...");
CommandBuffer cmd3 = CommandBufferPool.Get("PackAtlas");
atlasAxisSize = m_asset.maximalAtlasSizePixel;
for (int i = 0; i < visibleObjects.Count; i++)
{
visibleObjects[i].SetAtlasProperties(i + 1, 1); //objectID 0 is reserved for "undefined"
}
cmd3.SetComputeIntParam(m_ResolveCS, "g_totalObjectsInView", visibleObjects.Count + 1);
cmd3.SetComputeIntParam(m_ResolveCS, "g_atlasAxisSize", atlasAxisSize);
cmd3.SetComputeBufferParam(m_ResolveCS, m_cs_AtlasPacking, "g_ObjectToAtlasProperties",
g_ObjectToAtlasProperties);
cmd3.DispatchCompute(m_ResolveCS, m_cs_AtlasPacking, 1, 1, 1);
visibleObjects.Clear();
context.ExecuteCommandBuffer(cmd3);
CommandBufferPool.Release(cmd3);
// =====================================================================================================
// RenderTexelShading
// =====================================================================================================
CommandBuffer cmd4 = CommandBufferPool.Get("RenderTexelShading");
LogTrace("setup light array...");
NativeArray <VisibleLight> visibleLights = m_CullResults.visibleLights;
g_LightsOriginRange.Clear();
g_LightColorAngle.Clear();
for (int i1 = 0; i1 < MAX_LIGHTS; i1++)
{
if (i1 >= visibleLights.Length)
{
// fill up buffer with zero lights
g_LightsOriginRange.Add(Vector4.zero);
g_LightColorAngle.Add(Vector4.zero);
continue;
}
VisibleLight light = visibleLights[i1];
// if it's a directional light, just treat it as a point light and place it very far away
Vector4 lightOriginRange = light.lightType == LightType.Directional
? -light.light.transform.forward * 99999f
: light.light.transform.position;
lightOriginRange.w = light.lightType == LightType.Directional ? 99999999f : light.range;
g_LightsOriginRange.Add(lightOriginRange);
Vector4 lightColorAngle;
lightColorAngle = light.light.color * light.light.intensity;
lightColorAngle.w = light.lightType == LightType.Directional ? Mathf.Cos(light.spotAngle) : 1f;
g_LightColorAngle.Add(lightColorAngle);
}
cmd4.SetGlobalVectorArray("g_LightsOriginRange", g_LightsOriginRange);
cmd4.SetGlobalVectorArray("g_LightColorAngle", g_LightColorAngle);
cmd4.SetGlobalInt("g_LightsCount", Mathf.Min(MAX_LIGHTS, visibleLights.Length));
cmd4.SetRenderTarget(target_atlasA ? g_VistaAtlas_A : g_VistaAtlas_B);
context.ExecuteCommandBuffer(cmd4);
RenderOpaque(context, m_TexelSpacePass, cameraSortSettings);
cmd4.Clear();
if (m_asset.debugPass == TexelSpaceDebugMode.TexelShadingPass)
{
cmd4.Blit(g_VistaAtlas_A, BuiltinRenderTextureType.CameraTarget);
context.ExecuteCommandBuffer(cmd4);
}
CommandBufferPool.Release(cmd4);
LogTrace("ReleaseBuffers...");
CommandBuffer cmd6 = CommandBufferPool.Get("ReleaseBuffers");
cmd6.ReleaseTemporaryRT(g_PrimitiveVisibilityID);
context.ExecuteCommandBuffer(cmd6);
CommandBufferPool.Release(cmd6);
#if UNITY_EDITOR
// Emit scene view UI
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
}
visibleObjects.Clear();
// =====================================================================================================
// Render Vista + Finalize
// =====================================================================================================
CommandBuffer cmdVista = CommandBufferPool.Get("Render Vista");
cmdVista.SetRenderTarget(g_CameraTarget);
context.ExecuteCommandBuffer(cmdVista);
cmdVista.Clear();
context.StartMultiEye(camera);
switch (m_asset.debugPass)
{
case TexelSpaceDebugMode.None:
cameraSortSettings.criteria = SortingCriteria.OptimizeStateChanges;
RenderOpaque(context, m_VistaPass, cameraSortSettings); // render vista
context.DrawSkybox(camera);
break;
case TexelSpaceDebugMode.VisibilityPassObjectID:
case TexelSpaceDebugMode.VisibilityPassPrimitivID:
case TexelSpaceDebugMode.VisibilityPassMipMapPerObject:
case TexelSpaceDebugMode.VisibilityPassMipMapPerPixel:
break;
case TexelSpaceDebugMode.TexelShadingPass:
cmdVista.Blit(g_VistaAtlas_A, g_CameraTarget);
context.ExecuteCommandBuffer(cmdVista);
cmdVista.Clear();
break;
default:
throw new ArgumentOutOfRangeException();
}
context.StopMultiEye(camera);
cmdVista.Blit(g_CameraTarget, BuiltinRenderTextureType.CameraTarget);
cmdVista.ReleaseTemporaryRT(g_CameraTarget);
context.ExecuteCommandBuffer(cmdVista);
CommandBufferPool.Release(cmdVista);
}
if (shouldUpdateAtlas)
{
timeSinceLastRender = 0f;
}
timeSinceLastRender += Time.deltaTime;
context.Submit();
if (g_VistaAtlas_A)
{
m_asset.memoryConsumption += g_VistaAtlas_A.width * g_VistaAtlas_A.height *
(g_VistaAtlas_A.format == RenderTextureFormat.DefaultHDR ? 8 : 4) * 2;
}
m_asset.memoryConsumption /= 1024 * 1024;
}
