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