private static ShaderFeatures GetSupportedShaderFeatures(UniversalRenderPipelineAsset pipelineAsset)
{
ShaderFeatures shaderFeatures;
shaderFeatures = ShaderFeatures.MainLight;
if (pipelineAsset.supportsMainLightShadows)
{
shaderFeatures |= ShaderFeatures.MainLightShadows;
}
if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerVertex)
{
shaderFeatures |= ShaderFeatures.VertexLighting;
}
else if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerPixel)
{
shaderFeatures |= ShaderFeatures.AdditionalLights;
if (pipelineAsset.supportsAdditionalLightShadows)
{
shaderFeatures |= ShaderFeatures.AdditionalLightShadows;
}
}
bool anyShadows = pipelineAsset.supportsMainLightShadows ||
(shaderFeatures & ShaderFeatures.AdditionalLightShadows) != 0;
if (pipelineAsset.supportsSoftShadows && anyShadows)
{
shaderFeatures |= ShaderFeatures.SoftShadows;
}
if (pipelineAsset.supportsMixedLighting)
{
shaderFeatures |= ShaderFeatures.MixedLighting;
}
if (pipelineAsset.supportsTerrainHoles)
{
shaderFeatures |= ShaderFeatures.TerrainHoles;
}
if (pipelineAsset.useFastSRGBLinearConversion)
{
shaderFeatures |= ShaderFeatures.UseFastSRGBLinearConversion;
}
bool hasScreenSpaceOcclusion = false;
bool hasDeferredRenderer = false;
bool withAccurateGbufferNormals = false;
bool withoutAccurateGbufferNormals = false;
int rendererCount = pipelineAsset.m_RendererDataList.Length;
for (int rendererIndex = 0; rendererIndex < rendererCount; ++rendererIndex)
{
ScriptableRenderer renderer = pipelineAsset.GetRenderer(rendererIndex);
if (renderer is ForwardRenderer)
{
ForwardRenderer forwardRenderer = (ForwardRenderer)renderer;
if (forwardRenderer.renderingMode == RenderingMode.Deferred)
{
hasDeferredRenderer |= true;
withAccurateGbufferNormals |= forwardRenderer.accurateGbufferNormals;
withoutAccurateGbufferNormals |= !forwardRenderer.accurateGbufferNormals;
}
}
// Check for Screen Space Ambient Occlusion Renderer Feature
ScriptableRendererData rendererData = pipelineAsset.m_RendererDataList[rendererIndex];
if (rendererData != null)
{
for (int rendererFeatureIndex = 0; rendererFeatureIndex < rendererData.rendererFeatures.Count; rendererFeatureIndex++)
{
ScriptableRendererFeature rendererFeature = rendererData.rendererFeatures[rendererFeatureIndex];
ScreenSpaceAmbientOcclusion ssao = rendererFeature as ScreenSpaceAmbientOcclusion;
hasScreenSpaceOcclusion |= ssao != null;
}
}
}
if (hasDeferredRenderer)
{
shaderFeatures |= ShaderFeatures.DeferredShading;
}
// We can only strip accurateGbufferNormals related variants if all DeferredRenderers use the same option.
if (withAccurateGbufferNormals && !withoutAccurateGbufferNormals)
{
shaderFeatures |= ShaderFeatures.DeferredWithAccurateGbufferNormals;
}
if (!withAccurateGbufferNormals && withoutAccurateGbufferNormals)
{
shaderFeatures |= ShaderFeatures.DeferredWithoutAccurateGbufferNormals;
}
if (hasScreenSpaceOcclusion)
{
shaderFeatures |= ShaderFeatures.ScreenSpaceOcclusion;
}
return(shaderFeatures);
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
Clear();
RenderDirectionalCascadeShadowmap(ref context, ref renderingData);
}
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(MainLightShadowmap, ref renderingData);
if (mainLightShadows)
{
renderer.EnqueuePass(m_MainLightShadowCasterPass);
}
}
if (renderingData.shadowData.supportsAdditionalLightShadows)
{
bool additionalLightShadows = m_AdditionalLightsShadowCasterPass.Setup(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) || renderingData.cameraData.isOffscreenRender));
// 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);
if (requiresDepthPrepass)
{
m_DepthOnlyPass.Setup(baseDescriptor, DepthTexture, SampleCount.One);
renderer.EnqueuePass(m_DepthOnlyPass);
foreach (var pass in camera.GetComponents <IAfterDepthPrePass>())
{
renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, DepthTexture));
}
}
if (resolveShadowsInScreenSpace)
{
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.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 camera.GetComponents <IAfterOpaquePass>())
{
renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
}
if (renderingData.cameraData.postProcessEnabled &&
renderingData.cameraData.postProcessLayer.HasOpaqueOnlyEffects(renderer.postProcessingContext))
{
m_OpaquePostProcessPass.Setup(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);
m_RenderTransparentForwardPass2.Setup(baseDescriptor, colorHandle, depthHandle, rendererConfiguration);
renderer.EnqueuePass(m_RenderTransparentForwardPass2);
m_RenderTransparentForwardPass3.Setup(baseDescriptor, colorHandle, depthHandle, rendererConfiguration);
renderer.EnqueuePass(m_RenderTransparentForwardPass3);
foreach (var pass in camera.GetComponents <IAfterTransparentPass>())
{
renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
}
if (!renderingData.cameraData.isStereoEnabled && renderingData.cameraData.postProcessEnabled)
{
m_TransparentPostProcessPass.Setup(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
}
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
renderer.EnqueuePass(m_WaterFxPass);
renderer.EnqueuePass(m_CausticsPass);
}
private static ShaderFeatures GetSupportedShaderFeatures(UniversalRenderPipelineAsset pipelineAsset)
{
ShaderFeatures shaderFeatures;
shaderFeatures = ShaderFeatures.MainLight;
if (pipelineAsset.supportsMainLightShadows)
{
shaderFeatures |= ShaderFeatures.MainLightShadows;
}
if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerVertex)
{
shaderFeatures |= ShaderFeatures.VertexLighting;
}
else if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerPixel)
{
shaderFeatures |= ShaderFeatures.AdditionalLights;
if (pipelineAsset.supportsAdditionalLightShadows)
{
shaderFeatures |= ShaderFeatures.AdditionalLightShadows;
}
}
bool anyShadows = pipelineAsset.supportsMainLightShadows ||
(shaderFeatures & ShaderFeatures.AdditionalLightShadows) != 0;
if (pipelineAsset.supportsSoftShadows && anyShadows)
{
shaderFeatures |= ShaderFeatures.SoftShadows;
}
if (pipelineAsset.supportsMixedLighting)
{
shaderFeatures |= ShaderFeatures.MixedLighting;
}
if (pipelineAsset.supportsTerrainHoles)
{
shaderFeatures |= ShaderFeatures.TerrainHoles;
}
if (pipelineAsset.useFastSRGBLinearConversion)
{
shaderFeatures |= ShaderFeatures.UseFastSRGBLinearConversion;
}
if (pipelineAsset.supportsLightLayers)
{
shaderFeatures |= ShaderFeatures.LightLayers;
}
bool hasScreenSpaceShadows = false;
bool hasScreenSpaceOcclusion = false;
bool hasDeferredRenderer = false;
bool withAccurateGbufferNormals = false;
bool withoutAccurateGbufferNormals = false;
int rendererCount = pipelineAsset.m_RendererDataList.Length;
for (int rendererIndex = 0; rendererIndex < rendererCount; ++rendererIndex)
{
ScriptableRenderer renderer = pipelineAsset.GetRenderer(rendererIndex);
if (renderer is UniversalRenderer)
{
UniversalRenderer universalRenderer = (UniversalRenderer)renderer;
if (universalRenderer.renderingMode == RenderingMode.Deferred)
{
hasDeferredRenderer |= true;
withAccurateGbufferNormals |= universalRenderer.accurateGbufferNormals;
withoutAccurateGbufferNormals |= !universalRenderer.accurateGbufferNormals;
}
}
ScriptableRendererData rendererData = pipelineAsset.m_RendererDataList[rendererIndex];
if (rendererData != null)
{
for (int rendererFeatureIndex = 0; rendererFeatureIndex < rendererData.rendererFeatures.Count; rendererFeatureIndex++)
{
ScriptableRendererFeature rendererFeature = rendererData.rendererFeatures[rendererFeatureIndex];
ScreenSpaceShadows ssshadows = rendererFeature as ScreenSpaceShadows;
hasScreenSpaceShadows |= ssshadows != null;
// Check for Screen Space Ambient Occlusion Renderer Feature
ScreenSpaceAmbientOcclusion ssao = rendererFeature as ScreenSpaceAmbientOcclusion;
hasScreenSpaceOcclusion |= ssao != null;
// Check for Decal Renderer Feature
DecalRendererFeature decal = rendererFeature as DecalRendererFeature;
if (decal != null)
{
var technique = decal.GetTechnique(renderer);
switch (technique)
{
case DecalTechnique.DBuffer:
shaderFeatures |= GetFromDecalSurfaceData(decal.GetDBufferSettings().surfaceData);
break;
case DecalTechnique.ScreenSpace:
shaderFeatures |= GetFromNormalBlend(decal.GetScreenSpaceSettings().normalBlend);
shaderFeatures |= ShaderFeatures.DecalScreenSpace;
break;
case DecalTechnique.GBuffer:
shaderFeatures |= GetFromNormalBlend(decal.GetScreenSpaceSettings().normalBlend);
shaderFeatures |= ShaderFeatures.DecalGBuffer;
break;
}
}
}
}
}
if (hasDeferredRenderer)
{
shaderFeatures |= ShaderFeatures.DeferredShading;
}
// We can only strip accurateGbufferNormals related variants if all DeferredRenderers use the same option.
if (withAccurateGbufferNormals)
{
shaderFeatures |= ShaderFeatures.DeferredWithAccurateGbufferNormals;
}
if (withoutAccurateGbufferNormals)
{
shaderFeatures |= ShaderFeatures.DeferredWithoutAccurateGbufferNormals;
}
if (hasScreenSpaceShadows)
{
shaderFeatures |= ShaderFeatures.ScreenSpaceShadows;
}
if (hasScreenSpaceOcclusion)
{
shaderFeatures |= ShaderFeatures.ScreenSpaceOcclusion;
}
if (pipelineAsset.reflectionProbeBlending)
{
shaderFeatures |= ShaderFeatures.ReflectionProbeBlending;
}
if (pipelineAsset.reflectionProbeBoxProjection)
{
shaderFeatures |= ShaderFeatures.ReflectionProbeBoxProjection;
}
return(shaderFeatures);
}
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
pass.Setup(renderer.cameraColorTarget);
renderer.EnqueuePass(pass);
}
// Here you can inject one or multiple render passes in the renderer.
// This method is called when setting up the renderer once per-camera.
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
renderer.EnqueuePass(_meshSubdivisionPostpass);
}
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
ref Camera camera = ref renderingData.cameraData.camera;
private static ShaderFeatures GetSupportedShaderFeatures(UniversalRenderPipelineAsset pipelineAsset)
{
ShaderFeatures shaderFeatures;
shaderFeatures = ShaderFeatures.MainLight;
if (pipelineAsset.supportsMainLightShadows)
{
shaderFeatures |= ShaderFeatures.MainLightShadows;
}
if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerVertex)
{
shaderFeatures |= ShaderFeatures.AdditionalLights;
shaderFeatures |= ShaderFeatures.VertexLighting;
}
else if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerPixel)
{
shaderFeatures |= ShaderFeatures.AdditionalLights;
if (pipelineAsset.supportsAdditionalLightShadows)
{
shaderFeatures |= ShaderFeatures.AdditionalLightShadows;
}
}
bool anyShadows = pipelineAsset.supportsMainLightShadows ||
CoreUtils.HasFlag(shaderFeatures, ShaderFeatures.AdditionalLightShadows);
if (pipelineAsset.supportsSoftShadows && anyShadows)
{
shaderFeatures |= ShaderFeatures.SoftShadows;
}
if (pipelineAsset.supportsMixedLighting)
{
shaderFeatures |= ShaderFeatures.MixedLighting;
}
if (pipelineAsset.supportsTerrainHoles)
{
shaderFeatures |= ShaderFeatures.TerrainHoles;
}
bool hasDeferredRenderer = false;
bool withAccurateGbufferNormals = false;
bool withoutAccurateGbufferNormals = false;
int rendererCount = pipelineAsset.m_RendererDataList.Length;
for (int rendererIndex = 0; rendererIndex < rendererCount; ++rendererIndex)
{
ScriptableRenderer renderer = pipelineAsset.GetRenderer(rendererIndex);
if (renderer is DeferredRenderer)
{
hasDeferredRenderer |= true;
DeferredRenderer deferredRenderer = (DeferredRenderer)renderer;
withAccurateGbufferNormals |= deferredRenderer.AccurateGbufferNormals;
withoutAccurateGbufferNormals |= !deferredRenderer.AccurateGbufferNormals;
}
}
if (hasDeferredRenderer)
{
shaderFeatures |= ShaderFeatures.DeferredShading;
}
// We can only strip accurateGbufferNormals related variants if all DeferredRenderers use the same option.
if (withAccurateGbufferNormals && !withoutAccurateGbufferNormals)
{
shaderFeatures |= ShaderFeatures.DeferredWithAccurateGbufferNormals;
}
if (!withAccurateGbufferNormals && withoutAccurateGbufferNormals)
{
shaderFeatures |= ShaderFeatures.DeferredWithoutAccurateGbufferNormals;
}
return(shaderFeatures);
}
public void Setup(ScriptableRenderer renderer)
{
_renderer = renderer;
}
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
renderer.EnqueuePass(new BulletFuryRenderPass());
}
public void Setup(ScriptableRenderer renderer, Material material, ScriptableRenderPassInput inputRequirement, RenderPassEvent renderPassEvent, int renderPassEventAdjustment)
{
m_Material = material;
m_Renderer = renderer;
ConfigureInput(inputRequirement);
}
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
currentPass.SetRenderTarget(renderer.cameraColorTarget);
currentPass.SetData(data);
renderer.EnqueuePass(currentPass);
}
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
depthNormalsPass.Setup(renderingData.cameraData.cameraTargetDescriptor, m_DepthNormalsTexture);
renderer.EnqueuePass(depthNormalsPass);
}
// Here you can inject one or multiple render passes in the renderer.
// This method is called when setting up the renderer once per-camera.
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
this.pass.Setup(this.destination);
renderer.EnqueuePass(this.pass);
}
// Here you can inject one or multiple render passes in the renderer.
// This method is called when setting up the renderer once per-camera.
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
m_ScriptablePass.source = renderer.cameraColorTarget;
m_ScriptablePass.destination = RenderTargetHandle.CameraTarget;
renderer.EnqueuePass(m_ScriptablePass);
}
// Here you can inject one or multiple render passes in the renderer.
// This method is called when setting up the renderer once per-camera.
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
simpleBlitRenderPass.source = renderer.cameraColorTarget;
renderer.EnqueuePass(simpleBlitRenderPass);
}
/// <summary>
/// Here you can inject one or multiple render passes in the renderer.
/// This method is called when setting up the renderer once per-camera.
/// </summary>
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
depthPass.Setup(sceneTransparentDepthTexture);
renderer.EnqueuePass(depthPass);
}
// Here you can inject one or multiple render passes in the renderer.
// This method is called when setting up the renderer once per-camera.
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
renderer.EnqueuePass(m_ScriptablePass);
}
protected override void PreparePass(ScriptableRenderer renderer, ref RenderingData renderingData)
{
}
