bool StripUnusedVariant(PipelineCapabilities capabilities, ShaderCompilerData compilerData)
{
if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.AdditionalLights) &&
!CoreUtils.HasFlag(capabilities, PipelineCapabilities.AdditionalLights))
{
return(true);
}
if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.VertexLights) &&
!CoreUtils.HasFlag(capabilities, PipelineCapabilities.VertexLights))
{
return(true);
}
if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.DirectionalShadows) &&
!CoreUtils.HasFlag(capabilities, PipelineCapabilities.DirectionalShadows))
{
return(true);
}
if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.LocalShadows) &&
!CoreUtils.HasFlag(capabilities, PipelineCapabilities.LocalShadows))
{
return(true);
}
if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.SoftShadows) &&
!CoreUtils.HasFlag(capabilities, PipelineCapabilities.SoftShadows))
{
return(true);
}
return(false);
}
public static void StopStereoRendering(Camera camera, ref ScriptableRenderContext context, FrameRenderingConfiguration renderingConfiguration)
{
if (CoreUtils.HasFlag(renderingConfiguration, FrameRenderingConfiguration.Stereo))
{
context.StopMultiEye(camera);
}
}
bool StripUnusedShader(ShaderFeatures features, Shader shader, ShaderCompilerData compilerData)
{
if (shader.name.Contains("Debug"))
{
return(true);
}
if (shader.name.Contains("HDRenderPipeline"))
{
return(true);
}
if (!CoreUtils.HasFlag(features, ShaderFeatures.MainLightShadows) &&
shader.name.Contains("ScreenSpaceShadows"))
{
return(true);
}
if (shader.name == "Hidden/Lightweight Render Pipeline/Blit")
{
bool preserveAlpha = PlayerSettings.preserveFramebufferAlpha && compilerData.platformKeywordSet.IsEnabled(BuiltinShaderDefine.SHADER_API_MOBILE);
bool shaderPreserveAlpha = !compilerData.shaderKeywordSet.IsEnabled(m_KillAlpha);
if (preserveAlpha != shaderPreserveAlpha)
{
return(true);
}
}
return(false);
}
bool StripUnusedShader(ShaderFeatures features, Shader shader, ShaderCompilerData compilerData)
{
if (!CoreUtils.HasFlag(features, ShaderFeatures.MainLightShadows) &&
shader.name.Contains("ScreenSpaceShadows"))
{
return(true);
}
return(false);
}
bool StripUnusedFeatures(ShaderFeatures features, ShaderCompilerData compilerData)
{
// strip main light shadows and cascade variants
if (!CoreUtils.HasFlag(features, ShaderFeatures.MainLightShadows))
{
if (compilerData.shaderKeywordSet.IsEnabled(m_MainLightShadows))
{
return(true);
}
if (compilerData.shaderKeywordSet.IsEnabled(m_CascadeShadows))
{
return(true);
}
}
bool isAdditionalLightPerVertex = compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightsVertex);
bool isAdditionalLightPerPixel = compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightsPixel);
bool isAdditionalLightShadow = compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightShadows);
// Additional light are shaded per-vertex. Strip additional lights per-pixel and shadow variants
if (CoreUtils.HasFlag(features, ShaderFeatures.VertexLighting) &&
(isAdditionalLightPerPixel || isAdditionalLightShadow))
{
return(true);
}
// No additional lights
if (!CoreUtils.HasFlag(features, ShaderFeatures.AdditionalLights) &&
(isAdditionalLightPerPixel || isAdditionalLightPerVertex || isAdditionalLightShadow))
{
return(true);
}
// No additional light shadows
if (!CoreUtils.HasFlag(features, ShaderFeatures.AdditionalLightShadows) && isAdditionalLightShadow)
{
return(true);
}
if (!CoreUtils.HasFlag(features, ShaderFeatures.SoftShadows) &&
compilerData.shaderKeywordSet.IsEnabled(m_SoftShadows))
{
return(true);
}
if (compilerData.shaderKeywordSet.IsEnabled(m_MixedLightingSubtractive) &&
!CoreUtils.HasFlag(features, ShaderFeatures.MixedLighting))
{
return(true);
}
return(false);
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
var cmd = CommandBufferPool.Get("Clear Color");
cmd.SetRenderTarget(m_ColorHandle.Identifier());
cmd.ClearRenderTarget(CoreUtils.HasFlag(m_ClearFlag, ClearFlag.Color), CoreUtils.HasFlag(m_ClearFlag, ClearFlag.Depth), Color.yellow);
RenderTextureDescriptor opaqueDesc = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData);
cmd.GetTemporaryRT(beforeAll.id, opaqueDesc, FilterMode.Point);
cmd.Blit(m_ColorHandle.Identifier(), beforeAll.Identifier());
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
bool StripUnusedPass(ShaderFeatures features, ShaderSnippetData snippetData)
{
if (snippetData.passType == PassType.Meta)
{
return(true);
}
if (snippetData.passType == PassType.ShadowCaster)
{
if (!CoreUtils.HasFlag(features, ShaderFeatures.MainLightShadows) && !CoreUtils.HasFlag(features, ShaderFeatures.AdditionalLightShadows))
{
return(true);
}
}
return(false);
}
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;
}
return(shaderFeatures);
}
bool StripUnusedPass(PipelineCapabilities capabilities, ShaderSnippetData snippetData)
{
if (snippetData.passType == PassType.Meta)
{
return(true);
}
if (snippetData.passType == PassType.ShadowCaster)
{
if (!CoreUtils.HasFlag(capabilities, PipelineCapabilities.DirectionalShadows) && !CoreUtils.HasFlag(capabilities, PipelineCapabilities.LocalShadows))
{
return(true);
}
}
return(false);
}
/// <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 colorLoadOp = (CoreUtils.HasFlag(clearFlag, ClearFlag.Color))
? RenderBufferLoadAction.DontCare
: RenderBufferLoadAction.Load;
RenderBufferStoreAction colorStoreOp = RenderBufferStoreAction.Store;
RenderBufferLoadAction depthLoadOp = (CoreUtils.HasFlag(clearFlag, ClearFlag.Depth))
? RenderBufferLoadAction.DontCare
: RenderBufferLoadAction.Load;
RenderBufferStoreAction depthStoreOp = RenderBufferStoreAction.Store;
SetRenderTarget(cmd, colorAttachmentHandle.Identifier(), colorLoadOp, colorStoreOp,
depthAttachmentHandle.Identifier(), depthLoadOp, depthStoreOp, 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 = CreateDrawingSettings(camera, sortFlags, rendererConfiguration, renderingData.supportsDynamicBatching, renderingData.lightData.mainLightIndex);
context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref m_OpaqueFilterSettings);
// Render objects that did not match any shader pass with error shader
renderer.RenderObjectsWithError(context, ref renderingData.cullResults, camera, m_OpaqueFilterSettings, SortingCriteria.None);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
bool StripUnusedShader(ShaderFeatures features, Shader shader)
{
if (shader.name.Contains("Debug"))
{
return(true);
}
if (shader.name.Contains("HDRP"))
{
return(true);
}
if (!CoreUtils.HasFlag(features, ShaderFeatures.MainLightShadows) &&
shader.name.Contains("ScreenSpaceShadows"))
{
return(true);
}
return(false);
}
bool StripUnusedShader(PipelineCapabilities capabilities, Shader shader)
{
if (shader.name.Contains("Debug"))
{
return(true);
}
if (shader.name.Contains("HDRenderPipeline"))
{
return(true);
}
if (!CoreUtils.HasFlag(capabilities, PipelineCapabilities.DirectionalShadows) &&
shader.name.Contains("ScreenSpaceShadows"))
{
return(true);
}
return(false);
}
bool StripUnusedPass(ShaderFeatures features, ShaderSnippetData snippetData)
{
if (snippetData.passType == PassType.Meta)
{
return(true);
}
if (snippetData.passType == PassType.ShadowCaster)
{
if (!CoreUtils.HasFlag(features, ShaderFeatures.MainLightShadows) && !CoreUtils.HasFlag(features, ShaderFeatures.AdditionalLightShadows))
{
return(true);
}
}
// TODO: Test against lightMode tag instead.
if (!CoreUtils.HasFlag(features, ShaderFeatures.DeferredShading) && snippetData.passName == kPassNameGBuffer)
{
return(true);
}
return(false);
}
public static void SetSupportedShaderFeatures(LightweightRenderPipelineAsset pipelineAsset)
{
s_ShaderFeatures = ShaderFeatures.MainLight;
if (pipelineAsset.supportsMainLightShadows)
{
s_ShaderFeatures |= ShaderFeatures.MainLightShadows;
}
if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerVertex)
{
s_ShaderFeatures |= ShaderFeatures.AdditionalLights;
s_ShaderFeatures |= ShaderFeatures.VertexLighting;
}
else if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerPixel)
{
s_ShaderFeatures |= ShaderFeatures.AdditionalLights;
if (pipelineAsset.supportsAdditionalLightShadows)
{
s_ShaderFeatures |= ShaderFeatures.AdditionalLightShadows;
}
}
bool anyShadows = pipelineAsset.supportsMainLightShadows ||
CoreUtils.HasFlag(s_ShaderFeatures, ShaderFeatures.AdditionalLightShadows);
if (pipelineAsset.supportsSoftShadows && anyShadows)
{
s_ShaderFeatures |= ShaderFeatures.SoftShadows;
}
if (pipelineAsset.supportsMixedLighting)
{
s_ShaderFeatures |= ShaderFeatures.MixedLighting;
}
}
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);
}
bool StripUnusedFeatures(ShaderFeatures features, Shader shader, ShaderCompilerData compilerData)
{
// strip main light shadows and cascade variants
if (!CoreUtils.HasFlag(features, ShaderFeatures.MainLightShadows))
{
if (compilerData.shaderKeywordSet.IsEnabled(m_MainLightShadows))
{
return(true);
}
if (compilerData.shaderKeywordSet.IsEnabled(m_CascadeShadows))
{
return(true);
}
}
bool isAdditionalLightPerVertex = compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightsVertex);
bool isAdditionalLightPerPixel = compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightsPixel);
bool isAdditionalLightShadow = compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightShadows);
// Additional light are shaded per-vertex. Strip additional lights per-pixel and shadow variants
if (CoreUtils.HasFlag(features, ShaderFeatures.VertexLighting) &&
(isAdditionalLightPerPixel || isAdditionalLightShadow))
{
return(true);
}
// No additional lights
if (!CoreUtils.HasFlag(features, ShaderFeatures.AdditionalLights) &&
(isAdditionalLightPerPixel || isAdditionalLightPerVertex || isAdditionalLightShadow))
{
return(true);
}
// No additional light shadows
if (!CoreUtils.HasFlag(features, ShaderFeatures.AdditionalLightShadows) && isAdditionalLightShadow)
{
return(true);
}
if (!CoreUtils.HasFlag(features, ShaderFeatures.SoftShadows) &&
compilerData.shaderKeywordSet.IsEnabled(m_SoftShadows))
{
return(true);
}
if (compilerData.shaderKeywordSet.IsEnabled(m_MixedLightingSubtractive) &&
!CoreUtils.HasFlag(features, ShaderFeatures.MixedLighting))
{
return(true);
}
bool isBuiltInTerrainLit = shader.name.Contains("Universal Render Pipeline/Terrain/Lit");
if (isBuiltInTerrainLit && compilerData.shaderKeywordSet.IsEnabled(m_AlphaTestOn) &&
!CoreUtils.HasFlag(features, ShaderFeatures.TerrainHoles))
{
return(true);
}
return(false);
}
bool StripUnusedFeatures(ShaderFeatures features, Shader shader, ShaderSnippetData snippetData, ShaderCompilerData compilerData)
{
// strip main light shadows and cascade variants
if (!CoreUtils.HasFlag(features, ShaderFeatures.MainLightShadows))
{
if (compilerData.shaderKeywordSet.IsEnabled(m_MainLightShadows))
{
return(true);
}
if (compilerData.shaderKeywordSet.IsEnabled(m_CascadeShadows))
{
return(true);
}
}
bool isAdditionalLightPerVertex = compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightsVertex);
bool isAdditionalLightPerPixel = compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightsPixel);
bool isAdditionalLightShadow = compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightShadows);
// Additional light are shaded per-vertex. Strip additional lights per-pixel and shadow variants
if (CoreUtils.HasFlag(features, ShaderFeatures.VertexLighting) &&
(isAdditionalLightPerPixel || isAdditionalLightShadow))
{
return(true);
}
// No additional lights
if (!CoreUtils.HasFlag(features, ShaderFeatures.AdditionalLights) &&
(isAdditionalLightPerPixel || isAdditionalLightPerVertex || isAdditionalLightShadow))
{
return(true);
}
// No additional light shadows
if (!CoreUtils.HasFlag(features, ShaderFeatures.AdditionalLightShadows) && isAdditionalLightShadow)
{
return(true);
}
if (!CoreUtils.HasFlag(features, ShaderFeatures.SoftShadows) &&
compilerData.shaderKeywordSet.IsEnabled(m_SoftShadows))
{
return(true);
}
if (compilerData.shaderKeywordSet.IsEnabled(m_MixedLightingSubtractive) &&
!CoreUtils.HasFlag(features, ShaderFeatures.MixedLighting))
{
return(true);
}
bool isBuiltInTerrainLit = shader.name.Contains("Universal Render Pipeline/Terrain/Lit");
if (isBuiltInTerrainLit && compilerData.shaderKeywordSet.IsEnabled(m_AlphaTestOn) &&
!CoreUtils.HasFlag(features, ShaderFeatures.TerrainHoles))
{
return(true);
}
// TODO: Test against lightMode tag instead.
if (snippetData.passName == kPassNameGBuffer)
{
if (CoreUtils.HasFlag(features, ShaderFeatures.DeferredWithAccurateGbufferNormals) && !compilerData.shaderKeywordSet.IsEnabled(m_GbufferNormalsOct))
{
return(true);
}
if (CoreUtils.HasFlag(features, ShaderFeatures.DeferredWithoutAccurateGbufferNormals) && compilerData.shaderKeywordSet.IsEnabled(m_GbufferNormalsOct))
{
return(true);
}
}
return(false);
}
