public void Setup(LightweightForwardRenderer renderer, ref ScriptableRenderContext context,
ref CullResults cullResults, ref RenderingData renderingData)
{
Init(renderer);
renderer.Clear();
renderer.SetupPerObjectLightIndices(ref cullResults, ref renderingData.lightData);
RenderTextureDescriptor baseDescriptor = renderer.CreateRTDesc(ref renderingData.cameraData);
RenderTextureDescriptor shadowDescriptor = baseDescriptor;
shadowDescriptor.dimension = TextureDimension.Tex2D;
bool requiresCameraDepth = renderingData.cameraData.requiresDepthTexture;
bool requiresDepthPrepass = renderingData.shadowData.requiresScreenSpaceShadowResolve ||
renderingData.cameraData.isSceneViewCamera ||
(requiresCameraDepth &&
!LightweightForwardRenderer.CanCopyDepth(ref renderingData.cameraData));
// For now VR requires a depth prepass until we figure out how to properly resolve texture2DMS in stereo
requiresDepthPrepass |= renderingData.cameraData.isStereoEnabled;
if (renderingData.shadowData.renderDirectionalShadows)
{
m_DirectionalShadowPass.Setup(DirectionalShadowmap);
renderer.EnqueuePass(m_DirectionalShadowPass);
}
if (renderingData.shadowData.renderLocalShadows)
{
m_LocalShadowPass.Setup(LocalShadowmap);
renderer.EnqueuePass(m_LocalShadowPass);
}
renderer.EnqueuePass(m_SetupForwardRenderingPass);
if (requiresDepthPrepass)
{
m_DepthOnlyPass.Setup(baseDescriptor, DepthTexture, SampleCount.One);
renderer.EnqueuePass(m_DepthOnlyPass);
}
if (renderingData.shadowData.renderDirectionalShadows &&
renderingData.shadowData.requiresScreenSpaceShadowResolve)
{
m_ScreenSpaceShadowResovePass.Setup(baseDescriptor, ScreenSpaceShadowmap);
renderer.EnqueuePass(m_ScreenSpaceShadowResovePass);
}
bool requiresDepthAttachment = requiresCameraDepth && !requiresDepthPrepass;
bool requiresColorAttachment =
LightweightForwardRenderer.RequiresIntermediateColorTexture(
ref renderingData.cameraData,
baseDescriptor,
requiresDepthAttachment);
RenderTargetHandle colorHandle = (requiresColorAttachment) ? Color : RenderTargetHandle.CameraTarget;
RenderTargetHandle depthHandle = (requiresDepthAttachment) ? DepthAttachment : RenderTargetHandle.CameraTarget;
var sampleCount = (SampleCount)renderingData.cameraData.msaaSamples;
m_CreateLightweightRenderTexturesPass.Setup(baseDescriptor, colorHandle, depthHandle, sampleCount);
renderer.EnqueuePass(m_CreateLightweightRenderTexturesPass);
if (renderingData.cameraData.isStereoEnabled)
{
renderer.EnqueuePass(m_BeginXrRenderingPass);
}
Camera camera = renderingData.cameraData.camera;
bool dynamicBatching = renderingData.supportsDynamicBatching;
RendererConfiguration rendererConfiguration = LightweightForwardRenderer.GetRendererConfiguration(renderingData.lightData.totalAdditionalLightsCount);
renderer.EnqueuePass(m_SetupLightweightConstants);
m_RenderOpaqueForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, LightweightForwardRenderer.GetCameraClearFlag(camera), camera.backgroundColor, rendererConfiguration, dynamicBatching);
renderer.EnqueuePass(m_RenderOpaqueForwardPass);
if (renderingData.cameraData.postProcessEnabled &&
renderingData.cameraData.postProcessLayer.HasOpaqueOnlyEffects(renderer.postProcessRenderContext))
{
m_OpaquePostProcessPass.Setup(baseDescriptor, colorHandle);
renderer.EnqueuePass(m_OpaquePostProcessPass);
}
if (camera.clearFlags == CameraClearFlags.Skybox)
{
renderer.EnqueuePass(m_DrawSkyboxPass);
}
if (depthHandle != RenderTargetHandle.CameraTarget)
{
m_CopyDepthPass.Setup(depthHandle, DepthTexture);
renderer.EnqueuePass(m_CopyDepthPass);
}
if (renderingData.cameraData.requiresOpaqueTexture)
{
m_CopyColorPass.Setup(colorHandle, OpaqueColor);
renderer.EnqueuePass(m_CopyColorPass);
}
m_RenderTransparentForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, ClearFlag.None, camera.backgroundColor, rendererConfiguration, dynamicBatching);
renderer.EnqueuePass(m_RenderTransparentForwardPass);
if (renderingData.cameraData.postProcessEnabled)
{
m_TransparentPostProcessPass.Setup(baseDescriptor, colorHandle);
renderer.EnqueuePass(m_TransparentPostProcessPass);
}
else if (!renderingData.cameraData.isOffscreenRender && colorHandle != RenderTargetHandle.CameraTarget)
{
m_FinalBlitPass.Setup(baseDescriptor, colorHandle);
renderer.EnqueuePass(m_FinalBlitPass);
}
if (renderingData.cameraData.isStereoEnabled)
{
renderer.EnqueuePass(m_EndXrRenderingPass);
}
#if UNITY_EDITOR
if (renderingData.cameraData.isSceneViewCamera)
{
m_SceneViewDepthCopyPass.Setup(DepthTexture);
renderer.EnqueuePass(m_SceneViewDepthCopyPass);
}
#endif
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get(k_PostProcessingTag);
renderer.RenderPostProcess(cmd, ref renderingData.cameraData, descriptor.colorFormat, colorAttachmentHandle.Identifier(), destination, false);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <summary> /// Execute the pass. This is where custom rendering occurs. Specific details are left to the implementation /// </summary> /// <param name="renderer">The currently executing renderer. Contains configuration for the current execute call.</param> /// <param name="context">Use this render context to issue any draw commands during execution</param> /// <param name="renderingData">Current rendering state information</param> public abstract void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData);
public abstract void Execute(ScriptableRenderer renderer, ref ScriptableRenderContext context,
ref CullResults cullResults,
ref RenderingData renderingData);
void InitializeRenderingData(ref CameraData cameraData, List <VisibleLight> visibleLights, int maxSupportedLocalLightsPerPass, int maxSupportedVertexLights, out RenderingData renderingData)
{
m_LocalLightIndices.Clear();
bool hasDirectionalShadowCastingLight = false;
bool hasLocalShadowCastingLight = false;
if (cameraData.maxShadowDistance > 0.0f)
{
for (int i = 0; i < visibleLights.Count; ++i)
{
Light light = visibleLights[i].light;
bool castShadows = light != null && light.shadows != LightShadows.None;
if (visibleLights[i].lightType == LightType.Directional)
{
hasDirectionalShadowCastingLight |= castShadows;
}
else
{
hasLocalShadowCastingLight |= castShadows;
m_LocalLightIndices.Add(i);
}
}
}
renderingData.cameraData = cameraData;
InitializeLightData(visibleLights, maxSupportedLocalLightsPerPass, maxSupportedVertexLights, out renderingData.lightData);
InitializeShadowData(hasDirectionalShadowCastingLight, hasLocalShadowCastingLight, out renderingData.shadowData);
renderingData.supportsDynamicBatching = pipelineAsset.supportsDynamicBatching;
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
if (renderingData.shadowData.supportsAdditionalLightShadows)
{
Clear();
RenderAdditionalShadowmapAtlas(ref context, ref renderingData.cullResults, ref renderingData.lightData, ref renderingData.shadowData);
}
}
public void Setup(ref ScriptableRenderContext context, ref CullResults cullResults, ref RenderingData renderingData)
{
Clear();
SetupPerObjectLightIndices(ref cullResults, ref renderingData.lightData);
RenderTextureDescriptor baseDescriptor = CreateRTDesc(ref renderingData.cameraData);
RenderTextureDescriptor shadowDescriptor = baseDescriptor;
shadowDescriptor.dimension = TextureDimension.Tex2D;
bool requiresCameraDepth = renderingData.cameraData.requiresDepthTexture;
bool requiresDepthPrepass = renderingData.shadowData.requiresScreenSpaceShadowResolve ||
renderingData.cameraData.isSceneViewCamera || (requiresCameraDepth && !CanCopyDepth(ref renderingData.cameraData));
// For now VR requires a depth prepass until we figure out how to properly resolve texture2DMS in stereo
requiresDepthPrepass |= renderingData.cameraData.isStereoEnabled;
CommandBuffer cmd = CommandBufferPool.Get("Setup Rendering");
if (requiresDepthPrepass)
{
EnqueuePass(cmd, RenderPassHandles.DepthPrepass, baseDescriptor, null, RenderTargetHandles.DepthTexture);
}
if (renderingData.shadowData.renderDirectionalShadows)
{
EnqueuePass(cmd, RenderPassHandles.DirectionalShadows, shadowDescriptor);
if (renderingData.shadowData.requiresScreenSpaceShadowResolve)
{
EnqueuePass(cmd, RenderPassHandles.ScreenSpaceShadowResolve, baseDescriptor, new[] { RenderTargetHandles.ScreenSpaceShadowmap });
}
}
if (renderingData.shadowData.renderLocalShadows)
{
EnqueuePass(cmd, RenderPassHandles.LocalShadows, shadowDescriptor);
}
bool requiresDepthAttachment = requiresCameraDepth && !requiresDepthPrepass;
bool requiresColorAttachment = RequiresIntermediateColorTexture(ref renderingData.cameraData, baseDescriptor, requiresDepthAttachment);
int[] colorHandles = (requiresColorAttachment) ? new[] { RenderTargetHandles.Color } : null;
int depthHandle = (requiresDepthAttachment) ? RenderTargetHandles.DepthAttachment : -1;
EnqueuePass(cmd, RenderPassHandles.ForwardLit, baseDescriptor, colorHandles, depthHandle, renderingData.cameraData.msaaSamples);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
CommandBuffer cmd = CommandBufferPool.Get(_kRenderOITTag);
using (new ProfilingSample(cmd, _kRenderOITTag))
{
cmd.GetTemporaryRT(_B0Handle.id, _DescriptorFloat);
cmd.GetTemporaryRT(_B1Handle.id, _DescriptorFloat4);
if (MomentsCount._8 == _MomentsCount)
{
cmd.GetTemporaryRT(_B2Handle.id, _DescriptorFloat4);
}
else if (MomentsCount._6 == _MomentsCount)
{
cmd.GetTemporaryRT(_B2Handle.id, _DescriptorFloat2);
}
CoreUtils.SetKeyword(cmd, "_MOMENT6", MomentsCount._6 == _MomentsCount);
CoreUtils.SetKeyword(cmd, "_MOMENT8", MomentsCount._8 == _MomentsCount);
CoreUtils.SetKeyword(cmd, "_MOMENT_HALF_PRECISION", FloatPrecision._Half == _MomentsPrecision);
CoreUtils.SetKeyword(cmd, "_TRIGONOMETRIC", _Trigonometric);
cmd.SetRenderTarget(_GMBinding);
cmd.ClearRenderTarget(false, true, Color.black);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
Vector2 logViewDepthMinDelta = new Vector2(Mathf.Log(_ViewDepthMinMax.x), Mathf.Log(_ViewDepthMinMax.y));
logViewDepthMinDelta.y = logViewDepthMinDelta.y - logViewDepthMinDelta.x;
cmd.SetGlobalVector("_LogViewDepthMinDelta", logViewDepthMinDelta);
//cmd.SetGlobalFloat("_Overestimation", 0.25f);
//cmd.SetGlobalFloat("_MomentBias", 0);
if (_Trigonometric)
{
Vector4 _WrappingZoneParameters = new Vector4();
_WrappingZoneParameters.x = 3.14f;
_WrappingZoneParameters.y = 3.14f - 0.5f * _WrappingZoneParameters.x;
float a = _WrappingZoneParameters.y * 2;
float x = Mathf.Cos(a);
float y = Mathf.Sin(a);
float r = Mathf.Abs(y) - Mathf.Abs(x);
r = (x < 0) ? (2.0f - r) : r;
r = (y < 0) ? (6.0f - r) : r;
_WrappingZoneParameters.z = 1 / (7 - r);
_WrappingZoneParameters.w = 1 - 7 * _WrappingZoneParameters.z;
cmd.SetGlobalVector("_WrappingZoneParameters", _WrappingZoneParameters);
}
Camera camera = renderingData.cameraData.camera;
var drawSettings = CreateDrawRendererSettings(camera, SortFlags.None, _RendererConfiguration, renderingData.supportsDynamicBatching);
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, _OITFilterSettings);
// Render objects that did not match any shader pass with error shader
renderer.RenderObjectsWithError(context, ref renderingData.cullResults, camera, _OITFilterSettings, SortFlags.None);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
cmd.GetTemporaryRT(_MOITHandle.id, _Descriptor);
if (renderingData.shadowData.supportsDeepShadowMaps)
{
cmd.GetTemporaryRT(_GIALHandle.id, _Descriptor);
cmd.SetRenderTarget(_RMBinding);
cmd.ClearRenderTarget(false, true, Color.black);
}
else
{
CoreUtils.SetRenderTarget(cmd,
_MOITHandle.Identifier(), RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
_DepthAttachmentHandle.Identifier(), RenderBufferLoadAction.Load, RenderBufferStoreAction.DontCare,
ClearFlag.Color, Color.black);
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
cmd.SetGlobalTexture("_b0", _B0Handle.id);
cmd.SetGlobalTexture("_b1", _B1Handle.id);
if (MomentsCount._4 != _MomentsCount)
{
cmd.SetGlobalTexture("_b2", _B2Handle.id);
}
drawSettings.SetShaderPassName(0, new ShaderPassName("ResolveMoments"));
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, _OITFilterSettings);
// Render objects that did not match any shader pass with error shader
renderer.RenderObjectsWithError(context, ref renderingData.cullResults, camera, _OITFilterSettings, SortFlags.None);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CoreUtils.SetRenderTarget(cmd,
_ColorAttachmentHandle.Identifier(), RenderBufferLoadAction.Load, RenderBufferStoreAction.Store,
ClearFlag.None);
cmd.Blit(_ColorAttachmentHandle.Identifier(), _ColorAttachmentHandle.Identifier(), renderer.GetMaterial(MaterialHandle.MomentOITComposite));
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
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);
}
public void Setup(ScriptableRenderer renderer, ref RenderingData renderingData)
{
Init();
Camera camera = renderingData.cameraData.camera;
renderer.SetupPerObjectLightIndices(ref renderingData.cullResults, ref renderingData.lightData);
RenderTextureDescriptor baseDescriptor = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData);
RenderTextureDescriptor shadowDescriptor = baseDescriptor;
shadowDescriptor.dimension = TextureDimension.Tex2D;
bool requiresDepthPrepass = renderingData.shadowData.requiresScreenSpaceShadowResolve || renderingData.cameraData.isSceneViewCamera ||
(renderingData.cameraData.requiresDepthTexture && !CanCopyDepth(ref renderingData.cameraData));
// For now VR requires a depth prepass until we figure out how to properly resolve texture2DMS in stereo
requiresDepthPrepass |= renderingData.cameraData.isStereoEnabled;
if (renderingData.shadowData.renderDirectionalShadows)
{
m_DirectionalShadowPass.Setup(DirectionalShadowmap);
renderer.EnqueuePass(m_DirectionalShadowPass);
}
if (renderingData.shadowData.renderLocalShadows)
{
m_LocalShadowPass.Setup(LocalShadowmap, renderer.maxVisibleLocalLights);
renderer.EnqueuePass(m_LocalShadowPass);
}
renderer.EnqueuePass(m_SetupForwardRenderingPass);
if (requiresDepthPrepass)
{
m_DepthOnlyPass.Setup(baseDescriptor, DepthTexture, SampleCount.One);
renderer.EnqueuePass(m_DepthOnlyPass);
foreach (var pass in camera.GetComponents <IAfterDepthPrePass>())
{
renderer.EnqueuePass(pass.GetPassToEnqueue(m_DepthOnlyPass.descriptor, DepthTexture));
}
}
if (renderingData.shadowData.renderDirectionalShadows &&
renderingData.shadowData.requiresScreenSpaceShadowResolve)
{
m_ScreenSpaceShadowResolvePass.Setup(baseDescriptor, ScreenSpaceShadowmap);
renderer.EnqueuePass(m_ScreenSpaceShadowResolvePass);
}
bool requiresRenderToTexture = ScriptableRenderer.RequiresIntermediateColorTexture(ref renderingData.cameraData, baseDescriptor);
RenderTargetHandle colorHandle = RenderTargetHandle.CameraTarget;
RenderTargetHandle depthHandle = RenderTargetHandle.CameraTarget;
if (requiresRenderToTexture)
{
colorHandle = ColorAttachment;
depthHandle = DepthAttachment;
var sampleCount = (SampleCount)renderingData.cameraData.msaaSamples;
m_CreateLightweightRenderTexturesPass.Setup(baseDescriptor, colorHandle, depthHandle, sampleCount);
renderer.EnqueuePass(m_CreateLightweightRenderTexturesPass);
}
if (renderingData.cameraData.isStereoEnabled)
{
renderer.EnqueuePass(m_BeginXrRenderingPass);
}
RendererConfiguration rendererConfiguration = ScriptableRenderer.GetRendererConfiguration(renderingData.lightData.totalAdditionalLightsCount);
m_SetupLightweightConstants.Setup(renderer.maxVisibleLocalLights, renderer.perObjectLightIndices);
renderer.EnqueuePass(m_SetupLightweightConstants);
m_RenderOpaqueForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, ScriptableRenderer.GetCameraClearFlag(camera), camera.backgroundColor, rendererConfiguration);
renderer.EnqueuePass(m_RenderOpaqueForwardPass);
foreach (var pass in camera.GetComponents <IAfterOpaquePass>())
{
renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
}
if (renderingData.cameraData.postProcessEnabled &&
renderingData.cameraData.postProcessLayer.HasOpaqueOnlyEffects(renderer.postProcessingContext))
{
m_OpaquePostProcessPass.Setup(renderer.postProcessingContext, baseDescriptor, colorHandle);
renderer.EnqueuePass(m_OpaquePostProcessPass);
foreach (var pass in camera.GetComponents <IAfterOpaquePostProcess>())
{
renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
}
}
if (camera.clearFlags == CameraClearFlags.Skybox)
{
m_DrawSkyboxPass.Setup(colorHandle, depthHandle);
renderer.EnqueuePass(m_DrawSkyboxPass);
}
foreach (var pass in camera.GetComponents <IAfterSkyboxPass>())
{
renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
}
if (renderingData.cameraData.requiresDepthTexture && !requiresDepthPrepass)
{
m_CopyDepthPass.Setup(depthHandle, DepthTexture);
renderer.EnqueuePass(m_CopyDepthPass);
}
if (renderingData.cameraData.requiresOpaqueTexture)
{
m_CopyColorPass.Setup(colorHandle, OpaqueColor);
renderer.EnqueuePass(m_CopyColorPass);
}
m_RenderTransparentForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, rendererConfiguration);
renderer.EnqueuePass(m_RenderTransparentForwardPass);
foreach (var pass in camera.GetComponents <IAfterTransparentPass>())
{
renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
}
if (!renderingData.cameraData.isStereoEnabled && renderingData.cameraData.postProcessEnabled)
{
m_TransparentPostProcessPass.Setup(renderer.postProcessingContext, baseDescriptor, colorHandle, BuiltinRenderTextureType.CameraTarget);
renderer.EnqueuePass(m_TransparentPostProcessPass);
}
else if (!renderingData.cameraData.isOffscreenRender && colorHandle != RenderTargetHandle.CameraTarget)
{
m_FinalBlitPass.Setup(baseDescriptor, colorHandle);
renderer.EnqueuePass(m_FinalBlitPass);
}
foreach (var pass in camera.GetComponents <IAfterRender>())
{
renderer.EnqueuePass(pass.GetPassToEnqueue());
}
if (renderingData.cameraData.isStereoEnabled)
{
renderer.EnqueuePass(m_EndXrRenderingPass);
}
#if UNITY_EDITOR
if (renderingData.cameraData.isSceneViewCamera)
{
m_SceneViewDepthCopyPass.Setup(DepthTexture);
renderer.EnqueuePass(m_SceneViewDepthCopyPass);
}
#endif
}
/// <summary>
/// Configure the pass before execution
/// </summary>
/// <param name="baseDescriptor">Current target descriptor</param>
/// <param name="colorAttachmentHandle">Color attachment to render into</param>
/// <param name="depthAttachmentHandle">Depth attachment to render into</param>
/// <param name="configuration">Specific render configuration</param>
public bool Setup(
RenderTextureDescriptor baseDescriptor,
RenderTargetHandle colorAttachmentHandle,
RenderTargetHandle depthAttachmentHandle,
RendererConfiguration configuration,
SampleCount samples,
RenderingData renderingData)
{
if (!GetViewDepthMinMaxWithRenderQueue(renderingData.cameraData.camera, RenderQueueUtils.oit, out _ViewDepthMinMax))
{
return(false);
}
this._ColorAttachmentHandle = colorAttachmentHandle;
this._DepthAttachmentHandle = depthAttachmentHandle;
_RendererConfiguration = configuration;
if ((int)samples > 1)
{
baseDescriptor.bindMS = false;
baseDescriptor.msaaSamples = (int)samples;
}
baseDescriptor.depthBufferBits = 0;
_Descriptor = baseDescriptor;
_MomentsPrecision = renderingData.cameraData.momentsPrecision;
if (_MomentsPrecision == FloatPrecision._Single)
{
baseDescriptor.colorFormat = RenderTextureFormat.ARGBFloat;
_DescriptorFloat4 = baseDescriptor;
baseDescriptor.colorFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RGFloat)
? RenderTextureFormat.RGFloat
: RenderTextureFormat.ARGBFloat;
_DescriptorFloat2 = baseDescriptor;
baseDescriptor.colorFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RFloat)
? RenderTextureFormat.RFloat
: RenderTextureFormat.ARGBFloat;
_DescriptorFloat = baseDescriptor;
}
else
{
baseDescriptor.colorFormat = RenderTextureFormat.ARGBHalf;
_DescriptorFloat4 = baseDescriptor;
baseDescriptor.colorFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RGHalf)
? RenderTextureFormat.RGHalf
: RenderTextureFormat.ARGBHalf;
_DescriptorFloat2 = baseDescriptor;
baseDescriptor.colorFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RHalf)
? RenderTextureFormat.RHalf
: RenderTextureFormat.ARGBHalf;
_DescriptorFloat = baseDescriptor;
}
_B0Handle.Init("_B0");
_B1Handle.Init("_B1");
_B2Handle.Init("_B2");
_MomentsCount = (MomentsCount)renderingData.cameraData.momentsCount;
if (MomentsCount._4 != _MomentsCount)
{
_GMBinding = new RenderTargetBinding(
new RenderTargetIdentifier[]
{
_B0Handle.Identifier(),
_B1Handle.Identifier(),
_B2Handle.Identifier(),
},
new RenderBufferLoadAction[]
{
RenderBufferLoadAction.DontCare,
RenderBufferLoadAction.DontCare,
RenderBufferLoadAction.DontCare,
},
new RenderBufferStoreAction[]
{
RenderBufferStoreAction.Store,
RenderBufferStoreAction.Store,
RenderBufferStoreAction.Store,
},
_DepthAttachmentHandle.Identifier(),
RenderBufferLoadAction.Load,
RenderBufferStoreAction.DontCare);
}
else
{
_GMBinding = new RenderTargetBinding(
new RenderTargetIdentifier[]
{
_B0Handle.Identifier(),
_B1Handle.Identifier(),
},
new RenderBufferLoadAction[]
{
RenderBufferLoadAction.DontCare,
RenderBufferLoadAction.DontCare,
},
new RenderBufferStoreAction[]
{
RenderBufferStoreAction.Store,
RenderBufferStoreAction.Store,
},
_DepthAttachmentHandle.Identifier(),
RenderBufferLoadAction.Load,
RenderBufferStoreAction.DontCare);
}
_MOITHandle.Init("_MOIT");
_GIALHandle.Init("_GIAL");
_RMBinding = new RenderTargetBinding(
new RenderTargetIdentifier[]
{
_MOITHandle.Identifier(),
_GIALHandle.Identifier(),
},
new RenderBufferLoadAction[]
{
RenderBufferLoadAction.DontCare,
RenderBufferLoadAction.DontCare,
},
new RenderBufferStoreAction[]
{
RenderBufferStoreAction.Store,
RenderBufferStoreAction.Store,
},
_DepthAttachmentHandle.Identifier(),
RenderBufferLoadAction.Load,
RenderBufferStoreAction.DontCare
);
return(true);
}
public override void Execute(ref ScriptableRenderContext context, ref CullResults cullResults, ref RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get("Depth Copy");
RenderTargetIdentifier depthSurface = source.Identifier();
RenderTargetIdentifier copyDepthSurface = destination.Identifier();
RenderTextureDescriptor descriptor = renderer.CreateRTDesc(ref renderingData.cameraData);
descriptor.colorFormat = RenderTextureFormat.Depth;
descriptor.depthBufferBits = 32; //TODO: fix this ;
descriptor.msaaSamples = 1;
descriptor.bindMS = false;
cmd.GetTemporaryRT(destination.id, descriptor, FilterMode.Point);
if (renderingData.cameraData.msaaSamples > 1)
{
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthNoMsaa);
if (renderingData.cameraData.msaaSamples == 4)
{
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa2);
cmd.EnableShaderKeyword(LightweightKeywordStrings.DepthMsaa4);
}
else
{
cmd.EnableShaderKeyword(LightweightKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa4);
}
cmd.Blit(depthSurface, copyDepthSurface, m_DepthCopyMaterial);
}
else
{
cmd.EnableShaderKeyword(LightweightKeywordStrings.DepthNoMsaa);
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa4);
LightweightPipeline.CopyTexture(cmd, depthSurface, copyDepthSurface, m_DepthCopyMaterial);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
static void InitializeRenderingData(PipelineSettings settings, ref CameraData cameraData, ref CullResults cullResults,
int maxVisibleAdditionalLights, int maxPerObjectAdditionalLights, out RenderingData renderingData)
{
List <VisibleLight> visibleLights = cullResults.visibleLights;
int mainLightIndex = GetMainLight(settings, visibleLights);
bool mainLightCastShadows = false;
bool additionalLightsCastShadows = false;
if (cameraData.maxShadowDistance > 0.0f)
{
mainLightCastShadows = (mainLightIndex != -1 && visibleLights[mainLightIndex].light != null &&
visibleLights[mainLightIndex].light.shadows != LightShadows.None);
// If additional lights are shaded per-pixel they cannot cast shadows
if (settings.additionalLightsRenderingMode == LightRenderingMode.PerPixel)
{
for (int i = 0; i < visibleLights.Count; ++i)
{
if (i == mainLightIndex)
{
continue;
}
Light light = visibleLights[i].light;
// LWRP doesn't support additional directional lights or point light shadows yet
if (visibleLights[i].lightType == LightType.Spot && light != null && light.shadows != LightShadows.None)
{
additionalLightsCastShadows = true;
break;
}
}
}
}
renderingData.cullResults = cullResults;
renderingData.cameraData = cameraData;
InitializeLightData(settings, visibleLights, mainLightIndex, maxVisibleAdditionalLights, maxPerObjectAdditionalLights, out renderingData.lightData);
InitializeShadowData(settings, visibleLights, mainLightCastShadows, additionalLightsCastShadows && !renderingData.lightData.shadeAdditionalLightsPerVertex, out renderingData.shadowData);
renderingData.supportsDynamicBatching = settings.supportsDynamicBatching;
}
public override void Execute(ref ScriptableRenderContext context, ref CullResults cullResults, ref RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get("Render Opaque PostProcess Effects");
RenderTargetIdentifier source = colorAttachmentHandle.Identifier();
LightweightPipeline.RenderPostProcess(cmd, renderer.postProcessRenderContext, ref renderingData.cameraData, descriptor.colorFormat, source, colorAttachmentHandle.Identifier(), true);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException(nameof(renderer));
}
CommandBuffer cmd = CommandBufferPool.Get(k_CreateRenderTexturesTag);
if (colorAttachmentHandle != RenderTargetHandle.CameraTarget)
{
var colorDescriptor = descriptor;
colorDescriptor.depthBufferBits = 0;
colorDescriptor.sRGB = true;
colorDescriptor.msaaSamples = (int)samples;
cmd.GetTemporaryRT(colorAttachmentHandle.id, colorDescriptor, FilterMode.Bilinear);
}
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");
}
// Restore Render target for additional editor rendering.
// Note: Scene view camera always perform depth prepass
CommandBuffer cmd = CommandBufferPool.Get(k_CopyDepthToCameraTag);
CoreUtils.SetRenderTarget(cmd, BuiltinRenderTextureType.CameraTarget);
cmd.SetGlobalTexture("_CameraDepthAttachment", source.Identifier());
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthNoMsaa);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
cmd.Blit(source.Identifier(), BuiltinRenderTextureType.CameraTarget, renderer.GetMaterial(MaterialHandle.CopyDepth));
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");
}
if (!renderingData.shadowData.supportsDeepShadowMaps)
{
return;
}
LightData lightData = renderingData.lightData;
int shadowLightIndex = lightData.mainLightIndex;
if (shadowLightIndex == -1)
{
return;
}
VisibleLight shadowLight = lightData.visibleLights[shadowLightIndex];
ShadowData shadowData = renderingData.shadowData;
if (!GetVPMatrix(shadowLight.light))
{
return;
}
if (null == _ResetCompute)
{
_ResetCompute = renderer.GetCompute(ComputeHandle.ResetDeepShadowDataCompute);
KernelResetBuffer = _ResetCompute.FindKernel("KernelResetBuffer");
}
CommandBuffer cmd = CommandBufferPool.Get(k_RenderDeepShadowCaster);
using (new ProfilingSample(cmd, k_RenderDeepShadowCaster))
{
int deepShadowMapsSize = shadowData.deepShadowMapsSize;
int deepShadowMapsDepth = shadowData.deepShadowMapsDepth;
// Reset
cmd.SetComputeBufferParam(_ResetCompute, KernelResetBuffer, "_CountBuffer", _CountBuffer);
cmd.SetComputeBufferParam(_ResetCompute, KernelResetBuffer, "_DataBuffer", _DataBuffer);
cmd.SetComputeIntParam(_ResetCompute, "_DeepShadowMapSize", deepShadowMapsSize);
cmd.SetComputeIntParam(_ResetCompute, "_DeepShadowMapDepth", deepShadowMapsDepth);
cmd.DispatchCompute(_ResetCompute, KernelResetBuffer, deepShadowMapsSize / 8, deepShadowMapsSize / 8, 1);
_Temp = RenderTexture.GetTemporary(deepShadowMapsSize, deepShadowMapsSize, 0, RenderTextureFormat.R8); //Without rt, the second row of the vp matrix is negated
// Cast
SetRenderTarget(cmd, _Temp, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.DontCare,
ClearFlag.Color, Color.black, TextureDimension.Tex2D);
cmd.SetViewport(new Rect(Vector2.zero, Vector2.one * deepShadowMapsSize));
Vector4 shadowBias = ShadowUtils.GetShadowBias(ref shadowLight, shadowLightIndex, ref shadowData, _ProjMatrix, shadowData.deepShadowMapsSize);
ShadowUtils.SetupShadowCasterConstantBuffer(cmd, ref shadowLight, shadowBias);
cmd.SetViewProjectionMatrices(_ViewMatrix, _ProjMatrix);
cmd.SetRandomWriteTarget(1, _CountBuffer);
cmd.SetRandomWriteTarget(2, _DataBuffer);
cmd.SetGlobalInt("_DeepShadowMapSize", deepShadowMapsSize);
cmd.SetGlobalInt("_DeepShadowMapDepth", deepShadowMapsDepth);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
//foreach (var r in _Renderers)
//{
// for (int i = 0, imax = r.sharedMaterials.Length; i < imax; i++)
// {
// cmd.DrawRenderer(r, r.sharedMaterials[i], i, r.sharedMaterials[i].FindPass("DeepShadowCaster"));
// }
//}
ShadowSliceData slice = new ShadowSliceData()
{
offsetX = 0,
offsetY = 0,
resolution = deepShadowMapsSize,
};
cmd.SetGlobalMatrix("_DeepShadowMapsWorldToShadow", _DeepShadowMatrix);
DrawShadowsSettings settings = new DrawShadowsSettings(renderingData.cullResults, shadowLightIndex);
settings.splitData.cullingSphere = _CullingSphere;
cmd.EnableShaderKeyword("_DEEP_SHADOW_CASTER");
cmd.SetGlobalInt("_ShadowCasterZWrite", 0);
ShadowUtils.RenderShadowSlice(cmd, ref context, ref slice, ref settings, _ProjMatrix, _ViewMatrix);
cmd.DisableShaderKeyword("_DEEP_SHADOW_CASTER");
cmd.SetGlobalInt("_ShadowCasterZWrite", 1);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
// For Resolve
SetupDeepShadowMapResolverConstants(cmd, ref shadowData, shadowLight);
cmd.ClearRandomWriteTargets();
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, 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 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);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
CommandBuffer cmd = CommandBufferPool.Get(k_RenderOpaquesTag);
using (new ProfilingSample(cmd, k_RenderOpaquesTag))
{
RenderBufferLoadAction loadOp = RenderBufferLoadAction.DontCare;
RenderBufferStoreAction storeOp = RenderBufferStoreAction.Store;
SetRenderTarget(cmd, colorAttachmentHandle.Identifier(), loadOp, storeOp,
depthAttachmentHandle.Identifier(), loadOp, storeOp, clearFlag, clearColor, descriptor.dimension);
// TODO: We need a proper way to handle multiple camera/ camera stack. Issue is: multiple cameras can share a same RT
// (e.g, split screen games). However devs have to be dilligent with it and know when to clear/preserve color.
// For now we make it consistent by resolving viewport with a RT until we can have a proper camera management system
//if (colorAttachmentHandle == -1 && !cameraData.isDefaultViewport)
// cmd.SetViewport(camera.pixelRect);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
Camera camera = renderingData.cameraData.camera;
XRUtils.DrawOcclusionMesh(cmd, camera, renderingData.cameraData.isStereoEnabled);
var sortFlags = renderingData.cameraData.defaultOpaqueSortFlags;
var drawSettings = CreateDrawRendererSettings(camera, sortFlags, rendererConfiguration, renderingData.supportsDynamicBatching);
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, m_OpaqueFilterSettings);
// Render objects that did not match any shader pass with error shader
renderer.RenderObjectsWithError(context, ref renderingData.cullResults, camera, m_OpaqueFilterSettings, SortFlags.None);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ref ScriptableRenderContext context, ref CullResults cullResults, ref RenderingData renderingData)
{
if (renderingData.shadowData.renderDirectionalShadows)
{
Clear();
RenderDirectionalCascadeShadowmap(ref context, ref cullResults, ref renderingData.lightData, ref renderingData.shadowData);
}
}
public void Execute(ref ScriptableRenderContext context, ref CullResults cullResults, ref RenderingData renderingData)
{
// TODO: The reason we have to separate passes into two queues is because shadows require different camera
// context. We need to take a look at approaches to effectively share shadow between cameras, then we
// can move this out
for (int i = 0; i < m_ActiveShadowQueue.Count; ++i)
{
m_ActiveShadowQueue[i].Execute(ref context, ref cullResults, ref renderingData);
}
// SetupCameraProperties does the following:
// Setup Camera RenderTarget and Viewport
// VR Camera Setup and SINGLE_PASS_STEREO props
// Setup camera view, proj and their inv matrices.
// Setup properties: _WorldSpaceCameraPos, _ProjectionParams, _ScreenParams, _ZBufferParams, unity_OrthoParams
// Setup camera world clip planes props
// setup HDR keyword
// Setup global time properties (_Time, _SinTime, _CosTime)
context.SetupCameraProperties(renderingData.cameraData.camera, renderingData.cameraData.isStereoEnabled);
for (int i = 0; i < m_ActiveRenderPassQueue.Count; ++i)
{
m_ActiveRenderPassQueue[i].Execute(ref context, ref cullResults, ref renderingData);
}
#if UNITY_EDITOR
if (renderingData.cameraData.isSceneViewCamera)
{
// Restore Render target for additional editor rendering.
// Note: Scene view camera always perform depth prepass
CommandBuffer cmd = CommandBufferPool.Get("Copy Depth to Camera");
CoreUtils.SetRenderTarget(cmd, BuiltinRenderTextureType.CameraTarget);
cmd.EnableShaderKeyword(LightweightKeywordStrings.DepthNoMsaa);
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa4);
cmd.Blit(GetSurface(RenderTargetHandles.DepthTexture), BuiltinRenderTextureType.CameraTarget, GetMaterial(MaterialHandles.DepthCopy));
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
#endif
DisposePasses(ref context);
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get(k_CreateRenderTexturesTag);
if (colorAttachmentHandle != RenderTargetHandle.CameraTarget)
{
var colorDescriptor = descriptor;
colorDescriptor.depthBufferBits = 0;
colorDescriptor.sRGB = true;
colorDescriptor.msaaSamples = (int)samples;
cmd.GetTemporaryRT(colorAttachmentHandle.id, colorDescriptor, FilterMode.Bilinear);
}
if (depthAttachmentHandle != RenderTargetHandle.CameraTarget)
{
var depthDescriptor = descriptor;
depthDescriptor.colorFormat = RenderTextureFormat.Depth;
depthDescriptor.depthBufferBits = k_DepthStencilBufferBits;
depthDescriptor.msaaSamples = (int)samples;
depthDescriptor.bindMS = (int)samples > 1;
cmd.GetTemporaryRT(depthAttachmentHandle.id, depthDescriptor, FilterMode.Point);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ref ScriptableRenderContext context, ref CullResults cullResults, ref RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get(k_RenderTransparentsTag);
using (new ProfilingSample(cmd, k_RenderTransparentsTag))
{
SetRenderTarget(cmd, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store, clearFlag, CoreUtils.ConvertSRGBToActiveColorSpace(clearColor));
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
Camera camera = renderingData.cameraData.camera;
var drawSettings = CreateDrawRendererSettings(camera, SortFlags.CommonTransparent, rendererConfiguration, dynamicBatching);
context.DrawRenderers(cullResults.visibleRenderers, ref drawSettings, renderer.transparentFilterSettings);
// Render objects that did not match any shader pass with error shader
RenderObjectsWithError(ref context, ref cullResults, camera, renderer.transparentFilterSettings, SortFlags.None);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public void Setup(ScriptableRenderer renderer, ref RenderingData renderingData)
{
Init();
Camera camera = renderingData.cameraData.camera;
renderer.SetupPerObjectLightIndices(ref renderingData.cullResults, ref renderingData.lightData);
RenderTextureDescriptor baseDescriptor = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData);
RenderTextureDescriptor shadowDescriptor = baseDescriptor;
shadowDescriptor.dimension = TextureDimension.Tex2D;
bool mainLightShadows = false;
if (renderingData.shadowData.supportsMainLightShadows)
{
mainLightShadows = m_MainLightShadowCasterPass.Setup(m_MainLightShadowmap, ref renderingData);
if (mainLightShadows)
{
renderer.EnqueuePass(m_MainLightShadowCasterPass);
}
}
if (renderingData.shadowData.supportsAdditionalLightShadows)
{
bool additionalLightShadows = m_AdditionalLightsShadowCasterPass.Setup(m_AdditionalLightsShadowmap, ref renderingData, renderer.maxVisibleAdditionalLights);
if (additionalLightShadows)
{
renderer.EnqueuePass(m_AdditionalLightsShadowCasterPass);
}
}
bool resolveShadowsInScreenSpace = mainLightShadows && renderingData.shadowData.requiresScreenSpaceShadowResolve;
bool requiresDepthPrepass = resolveShadowsInScreenSpace || renderingData.cameraData.isSceneViewCamera ||
(renderingData.cameraData.requiresDepthTexture && (!CanCopyDepth(ref renderingData.cameraData)));
// For now VR requires a depth prepass until we figure out how to properly resolve texture2DMS in stereo
requiresDepthPrepass |= renderingData.cameraData.isStereoEnabled;
renderer.EnqueuePass(m_SetupForwardRenderingPass);
camera.GetComponents(m_AfterDepthpasses);
camera.GetComponents(m_AfterOpaquePasses);
camera.GetComponents(m_AfterOpaquePostProcessPasses);
camera.GetComponents(m_AfterSkyboxPasses);
camera.GetComponents(m_AfterTransparentPasses);
camera.GetComponents(m_AfterRenderPasses);
if (requiresDepthPrepass)
{
m_DepthOnlyPass.Setup(baseDescriptor, m_DepthTexture, SampleCount.One);
renderer.EnqueuePass(m_DepthOnlyPass);
foreach (var pass in m_AfterDepthpasses)
{
renderer.EnqueuePass(pass.GetPassToEnqueue(m_DepthOnlyPass.descriptor, m_DepthTexture));
}
}
if (resolveShadowsInScreenSpace)
{
m_ScreenSpaceShadowResolvePass.Setup(baseDescriptor, m_ScreenSpaceShadowmap);
renderer.EnqueuePass(m_ScreenSpaceShadowResolvePass);
}
bool requiresRenderToTexture = RequiresIntermediateColorTexture(ref renderingData.cameraData, baseDescriptor) ||
m_AfterDepthpasses.Count != 0 ||
m_AfterOpaquePasses.Count != 0 ||
m_AfterOpaquePostProcessPasses.Count != 0 ||
m_AfterSkyboxPasses.Count != 0 ||
m_AfterTransparentPasses.Count != 0 ||
m_AfterRenderPasses.Count != 0;
RenderTargetHandle colorHandle = RenderTargetHandle.CameraTarget;
RenderTargetHandle depthHandle = RenderTargetHandle.CameraTarget;
var sampleCount = (SampleCount)renderingData.cameraData.msaaSamples;
if (requiresRenderToTexture)
{
colorHandle = m_ColorAttachment;
depthHandle = m_DepthAttachment;
m_CreateLightweightRenderTexturesPass.Setup(baseDescriptor, colorHandle, depthHandle, sampleCount);
renderer.EnqueuePass(m_CreateLightweightRenderTexturesPass);
}
if (renderingData.cameraData.isStereoEnabled)
{
renderer.EnqueuePass(m_BeginXrRenderingPass);
}
var rendererConfiguration = ScriptableRenderer.GetRendererConfiguration(renderingData.lightData.additionalLightsCount);
m_SetupLightweightConstants.Setup(renderer.maxVisibleAdditionalLights, renderer.perObjectLightIndices);
renderer.EnqueuePass(m_SetupLightweightConstants);
m_RenderOpaqueForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, ScriptableRenderer.GetCameraClearFlag(camera), camera.backgroundColor, rendererConfiguration);
renderer.EnqueuePass(m_RenderOpaqueForwardPass);
foreach (var pass in m_AfterOpaquePasses)
{
renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
}
if (renderingData.cameraData.postProcessEnabled &&
renderingData.cameraData.postProcessLayer.HasOpaqueOnlyEffects(renderer.postProcessingContext))
{
m_CreatePostOpaqueColorPass.Setup(baseDescriptor, m_ColorAttachmentAfterOpaquePost, sampleCount);
renderer.EnqueuePass(m_CreatePostOpaqueColorPass);
m_OpaquePostProcessPass.Setup(baseDescriptor, colorHandle, m_ColorAttachmentAfterOpaquePost, true, false);
renderer.EnqueuePass(m_OpaquePostProcessPass);
colorHandle = m_ColorAttachmentAfterOpaquePost;
foreach (var pass in m_AfterOpaquePostProcessPasses)
{
renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
}
}
if (camera.clearFlags == CameraClearFlags.Skybox)
{
m_DrawSkyboxPass.Setup(colorHandle, depthHandle);
renderer.EnqueuePass(m_DrawSkyboxPass);
}
foreach (var pass in m_AfterSkyboxPasses)
{
renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
}
if (renderingData.cameraData.requiresDepthTexture && !requiresDepthPrepass)
{
m_CopyDepthPass.Setup(depthHandle, m_DepthTexture);
renderer.EnqueuePass(m_CopyDepthPass);
}
if (renderingData.cameraData.requiresOpaqueTexture)
{
m_CopyColorPass.Setup(colorHandle, m_OpaqueColor);
renderer.EnqueuePass(m_CopyColorPass);
}
m_RenderTransparentForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, rendererConfiguration);
renderer.EnqueuePass(m_RenderTransparentForwardPass);
foreach (var pass in m_AfterTransparentPasses)
{
renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
}
bool afterRenderExists = m_AfterRenderPasses.Count != 0;
// if we have additional filters
// we need to stay in a RT
if (afterRenderExists)
{
// perform post with src / dest the same
if (!renderingData.cameraData.isStereoEnabled && renderingData.cameraData.postProcessEnabled)
{
m_CreatePostTransparentColorPass.Setup(baseDescriptor, m_ColorAttachmentAfterTransparentPost, sampleCount);
renderer.EnqueuePass(m_CreatePostTransparentColorPass);
m_PostProcessPass.Setup(baseDescriptor, colorHandle, m_ColorAttachmentAfterTransparentPost, false, false);
renderer.EnqueuePass(m_PostProcessPass);
colorHandle = m_ColorAttachmentAfterTransparentPost;
}
//execute after passes
foreach (var pass in m_AfterRenderPasses)
{
renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
}
//now blit into the final target
if (colorHandle != RenderTargetHandle.CameraTarget)
{
m_FinalBlitPass.Setup(baseDescriptor, colorHandle);
renderer.EnqueuePass(m_FinalBlitPass);
}
}
else
{
if (!renderingData.cameraData.isStereoEnabled && renderingData.cameraData.postProcessEnabled)
{
m_PostProcessPass.Setup(baseDescriptor, colorHandle, RenderTargetHandle.CameraTarget, false, (!renderingData.cameraData.isStereoEnabled && renderingData.cameraData.camera.targetTexture == null));
renderer.EnqueuePass(m_PostProcessPass);
}
else if (colorHandle != RenderTargetHandle.CameraTarget)
{
m_FinalBlitPass.Setup(baseDescriptor, colorHandle);
renderer.EnqueuePass(m_FinalBlitPass);
}
}
if (renderingData.cameraData.isStereoEnabled)
{
renderer.EnqueuePass(m_EndXrRenderingPass);
}
#if UNITY_EDITOR
if (renderingData.cameraData.isSceneViewCamera)
{
m_SceneViewDepthCopyPass.Setup(m_DepthTexture);
renderer.EnqueuePass(m_SceneViewDepthCopyPass);
}
#endif
}
public bool Setup(RenderTargetHandle destination, ref RenderingData renderingData, int maxVisibleAdditinalLights)
{
Clear();
this.destination = destination;
if (m_AdditionalLightShadowMatrices.Length != maxVisibleAdditinalLights)
{
m_AdditionalLightShadowMatrices = new Matrix4x4[maxVisibleAdditinalLights];
m_AdditionalLightSlices = new ShadowSliceData[maxVisibleAdditinalLights];
m_AdditionalLightsShadowStrength = new float[maxVisibleAdditinalLights];
}
m_AdditionalShadowCastingLightIndices.Clear();
Bounds bounds;
var visibleLights = renderingData.lightData.visibleLights;
int additionalLightsCount = renderingData.lightData.additionalLightsCount;
for (int i = 0; i < visibleLights.Length && m_AdditionalShadowCastingLightIndices.Count < additionalLightsCount; ++i)
{
if (i == renderingData.lightData.mainLightIndex)
{
continue;
}
VisibleLight shadowLight = visibleLights[i];
Light light = shadowLight.light;
if (shadowLight.lightType == LightType.Spot && light != null && light.shadows != LightShadows.None)
{
if (renderingData.cullResults.GetShadowCasterBounds(i, out bounds))
{
m_AdditionalShadowCastingLightIndices.Add(i);
}
}
}
int shadowCastingLightsCount = m_AdditionalShadowCastingLightIndices.Count;
if (shadowCastingLightsCount == 0)
{
return(false);
}
// TODO: Add support to point light shadows. We make a simplification here that only works
// for spot lights and with max spot shadows per pass.
int atlasWidth = renderingData.shadowData.additionalLightsShadowmapWidth;
int atlasHeight = renderingData.shadowData.additionalLightsShadowmapHeight;
int sliceResolution = ShadowUtils.GetMaxTileResolutionInAtlas(atlasWidth, atlasHeight, shadowCastingLightsCount);
bool anyShadows = false;
int shadowSlicesPerRow = (atlasWidth / sliceResolution);
for (int i = 0; i < shadowCastingLightsCount; ++i)
{
int shadowLightIndex = m_AdditionalShadowCastingLightIndices[i];
VisibleLight shadowLight = visibleLights[shadowLightIndex];
// Currently Only Spot Lights are supported in additional lights
Debug.Assert(shadowLight.lightType == LightType.Spot);
Matrix4x4 shadowTransform;
bool success = ShadowUtils.ExtractSpotLightMatrix(ref renderingData.cullResults, ref renderingData.shadowData,
shadowLightIndex, out shadowTransform, out m_AdditionalLightSlices[i].viewMatrix, out m_AdditionalLightSlices[i].projectionMatrix);
if (success)
{
// TODO: We need to pass bias and scale list to shader to be able to support multiple
// shadow casting additional lights.
m_AdditionalLightSlices[i].offsetX = (i % shadowSlicesPerRow) * sliceResolution;
m_AdditionalLightSlices[i].offsetY = (i / shadowSlicesPerRow) * sliceResolution;
m_AdditionalLightSlices[i].resolution = sliceResolution;
m_AdditionalLightSlices[i].shadowTransform = shadowTransform;
m_AdditionalLightsShadowStrength[i] = shadowLight.light.shadowStrength;
anyShadows = true;
}
else
{
m_AdditionalShadowCastingLightIndices.RemoveAt(i--);
}
}
return(anyShadows);
}
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);
}
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
if (renderingData.shadowData.supportsMainLightShadows)
{
RenderMainLightCascadeShadowmap(ref context, ref renderingData.cullResults, ref renderingData.lightData, ref renderingData.shadowData);
}
}
static void InitializeRenderingData(PipelineSettings settings, ref CameraData cameraData, ref CullResults cullResults,
int maxVisibleAdditionalLights, int maxPerObjectAdditionalLights, out RenderingData renderingData)
{
List <VisibleLight> visibleLights = cullResults.visibleLights;
List <int> additionalLightIndices = new List <int>();
bool hasDirectionalShadowCastingLight = false;
bool hasPunctualShadowCastingLight = false;
if (cameraData.maxShadowDistance > 0.0f)
{
for (int i = 0; i < visibleLights.Count; ++i)
{
Light light = visibleLights[i].light;
bool castShadows = light != null && light.shadows != LightShadows.None;
// LWRP doesn't support point light shadows yet
castShadows &= visibleLights[i].lightType != LightType.Point;
if (visibleLights[i].lightType == LightType.Directional)
{
hasDirectionalShadowCastingLight |= castShadows;
}
else if (additionalLightIndices.Count < maxVisibleAdditionalLights)
{
hasPunctualShadowCastingLight |= (castShadows && settings.additionalLightsRenderingMode == LightRenderingMode.PerPixel);
additionalLightIndices.Add(i);
}
}
}
renderingData.cullResults = cullResults;
renderingData.cameraData = cameraData;
InitializeLightData(settings, visibleLights, additionalLightIndices, maxPerObjectAdditionalLights, out renderingData.lightData);
InitializeShadowData(settings, visibleLights, hasDirectionalShadowCastingLight, hasPunctualShadowCastingLight && !renderingData.lightData.shadeAdditionalLightsPerVertex, out renderingData.shadowData);
renderingData.supportsDynamicBatching = settings.supportsDynamicBatching;
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get(k_DepthCopyTag);
RenderTargetIdentifier depthSurface = source.Identifier();
RenderTargetIdentifier copyDepthSurface = destination.Identifier();
Material depthCopyMaterial = renderer.GetMaterial(MaterialHandles.DepthCopy);
RenderTextureDescriptor descriptor = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData);
descriptor.colorFormat = RenderTextureFormat.Depth;
descriptor.depthBufferBits = 32; //TODO: fix this ;
descriptor.msaaSamples = 1;
descriptor.bindMS = false;
cmd.GetTemporaryRT(destination.id, descriptor, FilterMode.Point);
cmd.SetGlobalTexture("_CameraDepthAttachment", source.Identifier());
if (renderingData.cameraData.msaaSamples > 1)
{
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthNoMsaa);
if (renderingData.cameraData.msaaSamples == 4)
{
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa2);
cmd.EnableShaderKeyword(LightweightKeywordStrings.DepthMsaa4);
}
else
{
cmd.EnableShaderKeyword(LightweightKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa4);
}
cmd.Blit(depthSurface, copyDepthSurface, depthCopyMaterial);
}
else
{
cmd.EnableShaderKeyword(LightweightKeywordStrings.DepthNoMsaa);
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa4);
ScriptableRenderer.CopyTexture(cmd, depthSurface, copyDepthSurface, depthCopyMaterial);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get(k_OpaquePostProcessTag);
RenderTargetIdentifier source = colorAttachmentHandle.Identifier();
renderer.RenderPostProcess(cmd, ref renderingData.cameraData, descriptor.colorFormat, source, colorAttachmentHandle.Identifier(), true);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
