static void Drawer_SectionPrimarySettings(HDRenderPipelineUI s, SerializedHDRenderPipelineAsset d, Editor o)
{
EditorGUILayout.PropertyField(d.renderPipelineResources, renderPipelineResourcesContent);
HDRenderPipelineAsset hdrpAsset = d.serializedObject.targetObject as HDRenderPipelineAsset;
hdrpAsset.renderPipelineEditorResources = EditorGUILayout.ObjectField(renderPipelineEditorResourcesContent, hdrpAsset.renderPipelineEditorResources, typeof(HDRenderPipelineEditorResources), allowSceneObjects: false) as HDRenderPipelineEditorResources;
EditorGUILayout.PropertyField(d.diffusionProfileSettings, diffusionProfileSettingsContent);
// EditorGUILayout.PropertyField(d.allowShaderVariantStripping, enableShaderVariantStrippingContent);
EditorGUILayout.PropertyField(d.enableSRPBatcher, enableSRPBatcher);
}
public HDRPreprocessShaders()
{
// TODO: Grab correct configuration/quality asset.
HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
if (hdPipeline != null)
{
m_CurrentHDRPAsset = hdPipeline.asset;
materialList = HDEditorUtils.GetBaseShaderPreprocessorList();
}
}
static void Drawer_SectionGeneral(SerializedHDRenderPipelineAsset serialized, Editor owner)
{
EditorGUILayout.PropertyField(serialized.renderPipelineResources, k_RenderPipelineResourcesContent);
// Not serialized as editor only datas... Retrieve them in data
HDRenderPipelineAsset hdrpAsset = serialized.serializedObject.targetObject as HDRenderPipelineAsset;
hdrpAsset.renderPipelineEditorResources = EditorGUILayout.ObjectField(k_RenderPipelineEditorResourcesContent, hdrpAsset.renderPipelineEditorResources, typeof(HDRenderPipelineEditorResources), allowSceneObjects: false) as HDRenderPipelineEditorResources;
EditorGUILayout.PropertyField(serialized.enableSRPBatcher, k_SRPBatcher);
EditorGUILayout.PropertyField(serialized.shaderVariantLogLevel, k_ShaderVariantLogLevel);
}
// Modify this function to add more stripping clauses
internal bool StripShader(HDRenderPipelineAsset hdAsset, ComputeShader shader, string kernelName, ShaderCompilerData inputData)
{
// Strip every useless shadow configs
var shadowInitParams = hdAsset.currentPlatformRenderPipelineSettings.hdShadowInitParams;
foreach (var shadowVariant in m_ShadowKeywords.ShadowVariants)
{
if (shadowVariant.Key != shadowInitParams.shadowFilteringQuality)
{
if (inputData.shaderKeywordSet.IsEnabled(shadowVariant.Value))
{
return(true);
}
}
}
// Screen space shadow variant is exclusive, either we have a variant with dynamic if that support screen space shadow or not
// either we have a variant that don't support at all. We can't have both at the same time.
if (inputData.shaderKeywordSet.IsEnabled(m_ScreenSpaceShadowOFFKeywords) && shadowInitParams.supportScreenSpaceShadows)
{
return(true);
}
if (inputData.shaderKeywordSet.IsEnabled(m_MSAA) && (hdAsset.currentPlatformRenderPipelineSettings.supportedLitShaderMode == RenderPipelineSettings.SupportedLitShaderMode.DeferredOnly))
{
return(true);
}
if (inputData.shaderKeywordSet.IsEnabled(m_ScreenSpaceShadowONKeywords) && !shadowInitParams.supportScreenSpaceShadows)
{
return(true);
}
if (inputData.shaderKeywordSet.IsEnabled(m_EnableAlpha) && !hdAsset.currentPlatformRenderPipelineSettings.SupportsAlpha())
{
return(true);
}
// Global Illumination
if (inputData.shaderKeywordSet.IsEnabled(m_ProbeVolumesL1) &&
(!hdAsset.currentPlatformRenderPipelineSettings.supportProbeVolume || hdAsset.currentPlatformRenderPipelineSettings.probeVolumeSHBands != ProbeVolumeSHBands.SphericalHarmonicsL1))
{
return(true);
}
if (inputData.shaderKeywordSet.IsEnabled(m_ProbeVolumesL2) &&
(!hdAsset.currentPlatformRenderPipelineSettings.supportProbeVolume || hdAsset.currentPlatformRenderPipelineSettings.probeVolumeSHBands != ProbeVolumeSHBands.SphericalHarmonicsL2))
{
return(true);
}
return(false);
}
public HDRPreprocessShaders()
{
// TODO: Grab correct configuration/quality asset.
HDRenderPipelineAsset hdPipelineAsset = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
if (hdPipelineAsset == null)
{
return;
}
materialList = HDEditorUtils.GetBaseShaderPreprocessorList();
}
public override void OnInspectorGUI()
{
HDRenderPipelineAsset currentAsset = (GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset);
if (!currentAsset?.currentPlatformRenderPipelineSettings.supportSSR ?? false)
{
EditorGUILayout.Space();
EditorGUILayout.HelpBox("The current HDRP Asset does not support Screen Space Reflection.", MessageType.Error, wide: true);
return;
}
PropertyField(m_ScreenFadeDistance, EditorGUIUtility.TrTextContent("Screen Edge Fade Distance", "Controls the distance at which HDRP fades out SSR near the edge of the screen."));
PropertyField(m_RayMaxIterations, EditorGUIUtility.TrTextContent("Max Number of Ray Steps", "Sets the maximum number of steps HDRP uses for raytracing. Affects both correctness and performance."));
PropertyField(m_DepthBufferThickness, EditorGUIUtility.TrTextContent("Object Thickness", "Controls the typical thickness of objects the reflection rays may pass behind."));
PropertyField(m_MinSmoothness, EditorGUIUtility.TrTextContent("Min Smoothness", "Controls the smoothness value at which HDRP activates SSR and the smoothness-controlled fade out stops."));
PropertyField(m_SmoothnessFadeStart, EditorGUIUtility.TrTextContent("Smoothness Fade Start", "Controls the smoothness value at which the smoothness-controlled fade out starts. The fade is in the range [Min Smoothness, Smoothness Fade Start]."));
PropertyField(m_ReflectSky, EditorGUIUtility.TrTextContent("Reflect sky", "When enabled, SSR handles sky reflection."));
m_RayMaxIterations.value.intValue = Mathf.Max(0, m_RayMaxIterations.value.intValue);
m_DepthBufferThickness.value.floatValue = Mathf.Clamp(m_DepthBufferThickness.value.floatValue, 0.001f, 1.0f);
m_SmoothnessFadeStart.value.floatValue = Mathf.Max(m_MinSmoothness.value.floatValue, m_SmoothnessFadeStart.value.floatValue);
#if ENABLE_RAYTRACING
PropertyField(m_EnableRaytracing);
if (m_EnableRaytracing.overrideState.boolValue && m_EnableRaytracing.value.boolValue)
{
EditorGUI.indentLevel++;
PropertyField(m_RayLength);
PropertyField(m_ClampValue);
RenderPipelineSettings.RaytracingTier currentTier = currentAsset.currentPlatformRenderPipelineSettings.supportedRaytracingTier;
switch (currentTier)
{
case RenderPipelineSettings.RaytracingTier.Tier1:
{
PropertyField(m_TemporalAccumulationWeight);
PropertyField(m_SpatialFilterRadius);
}
break;
case RenderPipelineSettings.RaytracingTier.Tier2:
{
PropertyField(m_NumSamples);
PropertyField(m_EnableFilter);
PropertyField(m_FilterRadius);
}
break;
}
EditorGUI.indentLevel--;
}
#endif
}
protected static bool IsMaterialQualityVariantStripped(HDRenderPipelineAsset hdrpAsset, ShaderCompilerData inputData)
{
var shaderMaterialLevel = inputData.shaderKeywordSet.GetMaterialQuality();
// if there are material quality defines in this shader
// and they don't match the material quality accepted by the hdrp asset
if (shaderMaterialLevel != 0 && (hdrpAsset.availableMaterialQualityLevels & shaderMaterialLevel) == 0)
{
// then strip this variant
return(true);
}
return(false);
}
public override void OnInspectorGUI()
{
HDRenderPipelineAsset currentAsset = HDRenderPipeline.currentAsset;
if (!currentAsset?.currentPlatformRenderPipelineSettings.supportRayTracing ?? false)
{
EditorGUILayout.Space();
EditorGUILayout.HelpBox("The current HDRP Asset does not support Ray Tracing.", MessageType.Error, wide: true);
return;
}
PropertyField(m_RayBias);
PropertyField(m_ExtendCulling);
}
bool IsDXRGIFSCorrect()
{
HDRenderPipelineAsset hdrpAsset = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset; // Default FrameSettings is a global quality independent parameter
if (hdrpAsset != null)
{
FrameSettings defaultCameraFS = hdrpAsset.GetDefaultFrameSettings(FrameSettingsRenderType.Camera);
return(defaultCameraFS.IsEnabled(FrameSettingsField.SSGI));
}
else
{
return(false);
}
}
public override void OnInspectorGUI()
{
HDRenderPipelineAsset currentAsset = (GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset);
if (!currentAsset?.currentPlatformRenderPipelineSettings.supportRayTracing ?? false)
{
EditorGUILayout.Space();
EditorGUILayout.HelpBox("The current HDRP Asset does not support Ray Tracing.", MessageType.Error, wide: true);
return;
}
#if ENABLE_RAYTRACING
PropertyField(m_RayTracing);
if (m_RayTracing.overrideState.boolValue && m_RayTracing.value.boolValue)
{
EditorGUI.indentLevel++;
PropertyField(m_RayLength);
PropertyField(m_ClampValue);
RenderPipelineSettings.RaytracingTier currentTier = currentAsset.currentPlatformRenderPipelineSettings.supportedRaytracingTier;
switch (currentTier)
{
case RenderPipelineSettings.RaytracingTier.Tier1:
{
PropertyField(m_DeferredMode);
PropertyField(m_RayBinning);
}
break;
case RenderPipelineSettings.RaytracingTier.Tier2:
{
PropertyField(m_SampleCount);
PropertyField(m_BounceCount);
}
break;
}
PropertyField(m_Denoise);
{
EditorGUI.indentLevel++;
PropertyField(m_HalfResolutionDenoiser);
PropertyField(m_DenoiserRadius);
PropertyField(m_SecondDenoiserPass);
PropertyField(m_SecondDenoiserRadius);
EditorGUI.indentLevel--;
}
EditorGUI.indentLevel--;
}
#endif
}
bool IsDXRGIFSCorrect()
{
HDRenderPipelineAsset hdrpAsset = HDRenderPipeline.currentAsset;
if (hdrpAsset != null)
{
FrameSettings defaultCameraFS = hdrpAsset.GetDefaultFrameSettings(FrameSettingsRenderType.Camera);
return(defaultCameraFS.IsEnabled(FrameSettingsField.SSGI));
}
else
{
return(false);
}
}
public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList <ShaderCompilerData> inputData)
{
// TODO: Grab correct configuration/quality asset.
HDRenderPipelineAsset hdPipelineAsset = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
if (hdPipelineAsset == null)
{
return;
}
uint preStrippingCount = (uint)inputData.Count;
// This test will also return if we are not using HDRenderPipelineAsset
if (hdPipelineAsset == null || !hdPipelineAsset.allowShaderVariantStripping)
{
return;
}
int inputShaderVariantCount = inputData.Count;
for (int i = 0; i < inputData.Count; ++i)
{
ShaderCompilerData input = inputData[i];
bool removeInput = false;
// Call list of strippers
// Note that all strippers cumulate each other, so be aware of any conflict here
foreach (BaseShaderPreprocessor material in materialList)
{
if (material.ShadersStripper(hdPipelineAsset, shader, snippet, input))
{
removeInput = true;
}
}
if (removeInput)
{
inputData.RemoveAt(i);
i--;
}
}
if (hdPipelineAsset.shaderVariantLogLevel != ShaderVariantLogLevel.Disabled)
{
m_TotalVariantsInputCount += preStrippingCount;
m_TotalVariantsOutputCount += (uint)inputData.Count;
LogShaderVariants(shader, snippet, hdPipelineAsset.shaderVariantLogLevel, preStrippingCount, (uint)inputData.Count);
}
}
public override void OnInspectorGUI()
{
// This whole editor has nothing to display if the SSR feature is not supported
HDRenderPipelineAsset currentAsset = HDRenderPipeline.currentAsset;
if (!currentAsset?.currentPlatformRenderPipelineSettings.supportSSR ?? false)
{
EditorGUILayout.Space();
EditorGUILayout.HelpBox("The current HDRP Asset does not support Screen Space Reflection.", MessageType.Error, wide: true);
return;
}
PropertyField(m_Enable, EditorGUIUtility.TrTextContent("Enable"));
// The ray tracing enabling checkbox is only displayed if the asset supports ray tracing
bool rayTracingSupported = HDRenderPipeline.pipelineSupportsRayTracing;
if (rayTracingSupported)
{
PropertyField(m_RayTracing, k_RayTracingText);
}
// The rest of the ray tracing UI is only displayed if the asset supports ray tracing and the checkbox is checked.
if (rayTracingSupported && m_RayTracing.overrideState.boolValue && m_RayTracing.value.boolValue)
{
RayTracedReflectionGUI();
}
else
{
// Shared Data
PropertyField(m_MinSmoothness, k_MinimumSmoothnessText);
PropertyField(m_SmoothnessFadeStart, k_SmoothnessFadeStartText);
PropertyField(m_ReflectSky, k_ReflectSkyText);
m_SmoothnessFadeStart.value.floatValue = Mathf.Max(m_MinSmoothness.value.floatValue, m_SmoothnessFadeStart.value.floatValue);
PropertyField(m_ScreenFadeDistance, k_ScreenFaceDistanceText);
PropertyField(m_DepthBufferThickness, k_DepthBufferThicknessText);
m_DepthBufferThickness.value.floatValue = Mathf.Clamp(m_DepthBufferThickness.value.floatValue, 0.001f, 1.0f);
base.OnInspectorGUI();
using (new EditorGUI.DisabledScope(!useCustomValue))
{
EditorGUI.indentLevel++;
PropertyField(m_RayMaxIterations, k_RayMaxIterationsText);
m_RayMaxIterations.value.intValue = Mathf.Max(0, m_RayMaxIterations.value.intValue);
EditorGUI.indentLevel--;
}
}
}
void RayTracedReflectionGUI(RayCastingMode tracingMode)
{
HDRenderPipelineAsset currentAsset = HDRenderPipeline.currentAsset;
PropertyField(m_ReflectSky, k_ReflectSkyText);
PropertyField(m_LayerMask, k_LayerMaskText);
PropertyField(m_TextureLodBias, k_TextureLodBiasText);
if (currentAsset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Both)
{
if (tracingMode == RayCastingMode.RayTracing)
{
PropertyField(m_Mode, k_ModeText);
using (new HDEditorUtils.IndentScope())
{
switch (m_Mode.value.GetEnumValue <RayTracingMode>())
{
case RayTracingMode.Performance:
RayTracingPerformanceModeGUI(false);
break;
case RayTracingMode.Quality:
RayTracingQualityModeGUI();
break;
}
}
}
else
{
RayTracingPerformanceModeGUI(true);
}
}
else if (currentAsset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Quality)
{
if (tracingMode == RayCastingMode.RayTracing)
{
RayTracingQualityModeGUI();
}
else
{
EditorGUILayout.HelpBox("The current HDRP Asset does not support the mixed mode which is only available in performance mode.", MessageType.Error, wide: true);
}
}
else
{
RayTracingPerformanceModeGUI(tracingMode == RayCastingMode.Mixed);
}
}
public void Setup(int index)
{
if (m_OriginalAsset != renderPipelines[index])
{
//Debug.Log("Set Render Pipeline: "+ renderPipelines[index]);
GraphicsSettings.renderPipelineAsset = renderPipelines[index];
// Update Camera Frame Settings (HDRP)
HDAdditionalCameraData additionalCameraData = cameraToUse.gameObject.GetComponent <HDAdditionalCameraData>();
if (additionalCameraData != null)
{
HDRenderPipelineAsset m_Asset = (HDRenderPipelineAsset)renderPipelines[index];
additionalCameraData.UpdateDirtyFrameSettings(true, m_Asset.GetFrameSettings());
}
}
}
static void Drawer_SectionRenderingSettings(FrameSettingsUI s, SerializedFrameSettings p, Editor owner, bool withOverride)
{
//disable temporarily as FrameSettings are not supported for Baked probe at the moment
using (new EditorGUI.DisabledScope((owner is HDProbeEditor) && (owner as HDProbeEditor).GetTarget(owner.target).mode != ReflectionProbeMode.Realtime || (owner is HDRenderPipelineEditor) && HDRenderPipelineUI.selectedFrameSettings == HDRenderPipelineUI.SelectedFrameSettings.BakedOrCustomReflection))
{
HDRenderPipelineAsset hdrpAsset = GetHDRPAssetFor(owner);
RenderPipelineSettings hdrpSettings = hdrpAsset.renderPipelineSettings;
FrameSettings defaultFrameSettings = GetDefaultFrameSettingsFor(owner);
OverridableSettingsArea area = new OverridableSettingsArea(6);
LitShaderMode defaultShaderLitMode;
switch (hdrpSettings.supportedLitShaderMode)
{
case RenderPipelineSettings.SupportedLitShaderMode.ForwardOnly:
defaultShaderLitMode = LitShaderMode.Forward;
break;
case RenderPipelineSettings.SupportedLitShaderMode.DeferredOnly:
defaultShaderLitMode = LitShaderMode.Deferred;
break;
case RenderPipelineSettings.SupportedLitShaderMode.Both:
defaultShaderLitMode = defaultFrameSettings.shaderLitMode;
break;
default:
throw new System.ArgumentOutOfRangeException("Unknown ShaderLitMode");
}
area.Add(p.litShaderMode, litShaderModeContent, () => p.overridesShaderLitMode, a => p.overridesShaderLitMode = a,
() => !GL.wireframe && hdrpSettings.supportedLitShaderMode == RenderPipelineSettings.SupportedLitShaderMode.Both,
defaultValue: defaultShaderLitMode);
bool assetAllowMSAA = hdrpSettings.supportedLitShaderMode != RenderPipelineSettings.SupportedLitShaderMode.DeferredOnly && hdrpSettings.supportMSAA;
bool frameSettingsAllowMSAA = p.litShaderMode.enumValueIndex == (int)LitShaderMode.Forward && p.overridesShaderLitMode || !p.overridesShaderLitMode && defaultShaderLitMode == LitShaderMode.Forward;
area.Add(p.enableMSAA, msaaContent, () => p.overridesMSAA, a => p.overridesMSAA = a,
() => !GL.wireframe &&
assetAllowMSAA && frameSettingsAllowMSAA,
defaultValue: defaultFrameSettings.enableMSAA && hdrpSettings.supportMSAA && !GL.wireframe && (hdrpSettings.supportedLitShaderMode & RenderPipelineSettings.SupportedLitShaderMode.ForwardOnly) != 0 && (p.overridesShaderLitMode && p.litShaderMode.enumValueIndex == (int)LitShaderMode.Forward || !p.overridesShaderLitMode && defaultFrameSettings.shaderLitMode == (int)LitShaderMode.Forward));
area.Add(p.enableDepthPrepassWithDeferredRendering, depthPrepassWithDeferredRenderingContent, () => p.overridesDepthPrepassWithDeferredRendering, a => p.overridesDepthPrepassWithDeferredRendering = a,
() => (defaultFrameSettings.shaderLitMode == LitShaderMode.Deferred && !p.overridesShaderLitMode || p.overridesShaderLitMode && p.litShaderMode.enumValueIndex == (int)LitShaderMode.Deferred) && (hdrpSettings.supportedLitShaderMode & RenderPipelineSettings.SupportedLitShaderMode.DeferredOnly) != 0,
defaultValue: defaultFrameSettings.enableDepthPrepassWithDeferredRendering && (hdrpSettings.supportedLitShaderMode & RenderPipelineSettings.SupportedLitShaderMode.DeferredOnly) != 0 && p.litShaderMode.enumValueIndex == (int)LitShaderMode.Deferred);
area.Add(p.enableOpaqueObjects, opaqueObjectsContent, () => p.overridesOpaqueObjects, a => p.overridesOpaqueObjects = a, defaultValue: defaultFrameSettings.enableOpaqueObjects);
area.Add(p.enableTransparentObjects, transparentObjectsContent, () => p.overridesTransparentObjects, a => p.overridesTransparentObjects = a, defaultValue: defaultFrameSettings.enableTransparentObjects);
area.Add(p.enableRealtimePlanarReflection, realtimePlanarReflectionContent, () => p.overridesRealtimePlanarReflection, a => p.overridesRealtimePlanarReflection = a, defaultValue: defaultFrameSettings.enableRealtimePlanarReflection);
area.Draw(withOverride);
}
}
/// <summary>
/// Renders the properties in the block.
/// </summary>
protected override void OnGUIOpen()
{
bool perChannelMask = false;
HDRenderPipelineAsset hdrp = HDRenderPipeline.currentAsset;
if (hdrp != null)
{
perChannelMask = hdrp.currentPlatformRenderPipelineSettings.decalSettings.perChannelMask;
}
if (affectsAlbedo != null)
{
materialEditor.ShaderProperty(affectsAlbedo, Styles.affectAlbedoText);
}
if (affectsNormal != null)
{
materialEditor.ShaderProperty(affectsNormal, Styles.affectNormalText);
}
using (new EditorGUI.DisabledScope(!perChannelMask))
{
if (affectsMetal != null)
{
materialEditor.ShaderProperty(affectsMetal, Styles.affectMetalText);
}
if (affectsAO != null)
{
materialEditor.ShaderProperty(affectsAO, Styles.affectAmbientOcclusionText);
}
}
if (affectsSmoothness != null)
{
materialEditor.ShaderProperty(affectsSmoothness, Styles.affectSmoothnessText);
}
if (affectsEmission != null)
{
materialEditor.ShaderProperty(affectsEmission, Styles.affectEmissionText);
}
if (!perChannelMask && (affectsMetal != null || affectsAO != null))
{
EditorGUILayout.HelpBox("Enable 'Metal and AO properties' in your HDRP Asset if you want to control the Metal and AO properties of decals. There is a performance cost of enabling this option.",
MessageType.Info);
}
}
// NOTE: All these keyword should be automatically stripped so there's no need to handle them ourselves.
// LIGHTMAP_ON, DIRLIGHTMAP_COMBINED, DYNAMICLIGHTMAP_ON, LIGHTMAP_SHADOW_MIXING, SHADOWS_SHADOWMASK
// FOG_LINEAR, FOG_EXP, FOG_EXP2
// STEREO_INSTANCING_ON, STEREO_MULTIVIEW_ON, STEREO_CUBEMAP_RENDER_ON, UNITY_SINGLE_PASS_STEREO
// INSTANCING_ON
// Several pass are common to all shader, let's share code here
// This remove variant (return true) for:
// - Scene Selection
// - Motion vectors
// - Tile pass for Transparent (not compatible)
// -
protected bool CommonShaderStripper(HDRenderPipelineAsset hdrpAsset, Shader shader, ShaderSnippetData snippet, ShaderCompilerData inputData)
{
bool isSceneSelectionPass = snippet.passName == "SceneSelectionPass";
if (isSceneSelectionPass)
{
return(true);
}
bool isMotionPass = snippet.passName == "Motion Vectors";
if (!hdrpAsset.renderPipelineSettings.supportMotionVectors && isMotionPass)
{
return(true);
}
//bool isForwardPass = (snippet.passName == "Forward") || (snippet.passName == "ForwardOnly");
if (inputData.shaderKeywordSet.IsEnabled(m_Transparent))
{
// If we are transparent we use cluster lighting and not tile lighting
if (inputData.shaderKeywordSet.IsEnabled(m_TileLighting))
{
return(true);
}
}
else // Opaque
{
// Note: we can't assume anything regarding tile/cluster for opaque as multiple view could used different settings and it depends on MSAA
}
// TODO: If static lighting we can remove meta pass, but how to know that?
// If we are in a release build, don't compile debug display variant
// Also don't compile it if not requested by the render pipeline settings
if ((/*!Debug.isDebugBuild || */ !hdrpAsset.renderPipelineSettings.supportRuntimeDebugDisplay) && inputData.shaderKeywordSet.IsEnabled(m_DebugDisplay))
{
return(true);
}
if (inputData.shaderKeywordSet.IsEnabled(m_LodFadeCrossFade) && !hdrpAsset.renderPipelineSettings.supportDitheringCrossFade)
{
return(true);
}
return(false);
}
static void SetupFrameSettings(HDAdditionalCameraData additionalData, HDProbe probe)
{
HDRenderPipelineAsset hdrp = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
if (probe.mode == ReflectionProbeMode.Realtime)
{
hdrp.GetRealtimeReflectionFrameSettings().CopyTo(additionalData.GetFrameSettings());
}
else
{
hdrp.GetBakedOrCustomReflectionFrameSettings().CopyTo(additionalData.GetFrameSettings());
}
if (probe.captureSettings.renderingPath == HDAdditionalCameraData.RenderingPath.Custom)
{
probe.frameSettings.Override(additionalData.GetFrameSettings()).CopyTo(additionalData.GetFrameSettings());
}
}
protected override bool DoShadersStripper(HDRenderPipelineAsset hdrpAsset, Shader shader, ShaderSnippetData snippet, ShaderCompilerData inputData)
{
var globalSettings = HDRenderPipelineGlobalSettings.Ensure();
// If ray tracing is disabled, strip all ray tracing shaders
if (hdrpAsset.currentPlatformRenderPipelineSettings.supportRayTracing == false)
{
// If transparent we don't need the depth only pass
if (snippet.passName == "IndirectDXR" ||
snippet.passName == "ForwardDXR" ||
snippet.passName == "VisibilityDXR" ||
snippet.passName == "PathTracingDXR" ||
snippet.passName == "GBufferDXR" ||
snippet.passName == "SubSurfaceDXR" ||
snippet.passName == "DebugDXR")
{
return(true);
}
}
else
{
// If we only support Performance mode, we do not want the indirectDXR shader
if (hdrpAsset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Performance &&
snippet.passName == "IndirectDXR")
{
return(true);
}
// If we only support Quality mode, we do not want the indirectDXR shader
if (hdrpAsset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Quality &&
snippet.passName == "GBufferDXR")
{
return(true);
}
// If requested by the render pipeline settings, or if we are in a release build
// don't compile the DXR debug pass
bool isDebugDXR = snippet.passName == "DebugDXR";
if (isDebugDXR && (!Debug.isDebugBuild || !globalSettings.supportRuntimeDebugDisplay))
{
return(true);
}
}
return(false);
}
static FrameSettings GetDefaultFrameSettingsFor(Editor owner)
{
HDRenderPipelineAsset hdrpAsset = GetHDRPAssetFor(owner);
if (owner is IHDProbeEditor)
{
if ((owner as IHDProbeEditor).GetTarget(owner.target).mode == ProbeSettings.Mode.Realtime)
{
return(hdrpAsset.GetDefaultFrameSettings(FrameSettingsRenderType.RealtimeReflection));
}
else
{
return(hdrpAsset.GetDefaultFrameSettings(FrameSettingsRenderType.CustomOrBakedReflection));
}
}
return(hdrpAsset.GetDefaultFrameSettings(FrameSettingsRenderType.Camera));
}
internal static FrameSettings GetDefaultFrameSettingsFor(Editor owner)
{
HDRenderPipelineAsset hdrpAsset = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
if (owner is HDProbeEditor)
{
if ((owner as HDProbeEditor).GetTarget(owner.target).mode == ReflectionProbeMode.Realtime)
{
return(hdrpAsset.GetRealtimeReflectionFrameSettings());
}
else
{
return(hdrpAsset.GetBakedOrCustomReflectionFrameSettings());
}
}
return(hdrpAsset.GetFrameSettings());
}
public void OnPreprocessBuild(BuildReport report)
{
// Detect if the users forget to assign an HDRP Asset
if (GraphicsSettings.renderPipelineAsset == null)
{
if (!Application.isBatchMode)
{
if (!EditorUtility.DisplayDialog("Build Player",
"There is no HDRP Asset provided in GraphicsSettings.\nAre you sure you want to continue ?\n Build time can be extremely long without it.", "Ok", "Cancel"))
{
throw new BuildFailedException("Stop build on request.");
}
}
else
{
Debug.LogWarning("There is no HDRP Asset provided in GraphicsSettings. Build time can be extremely long without it.");
}
return;
}
// Don't execute the preprocess if we are not HDRenderPipeline
HDRenderPipelineAsset hdPipelineAsset = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
if (hdPipelineAsset == null)
{
return;
}
// If platform is supported all good
GraphicsDeviceType unsupportedGraphicDevice = GraphicsDeviceType.Null;
if (HDUtils.IsSupportedBuildTarget(report.summary.platform) &&
HDUtils.IsOperatingSystemSupported(SystemInfo.operatingSystem) &&
HDUtils.AreGraphicsAPIsSupported(report.summary.platform, out unsupportedGraphicDevice))
{
return;
}
unsupportedGraphicDevice = (unsupportedGraphicDevice == GraphicsDeviceType.Null) ? SystemInfo.graphicsDeviceType : unsupportedGraphicDevice;
string msg = "The platform " + report.summary.platform.ToString() + " with the graphic API " + unsupportedGraphicDevice + " is not supported with High Definition Render Pipeline";
// Throw an exception to stop the build
throw new BuildFailedException(msg);
}
protected override bool DoShadersStripper(HDRenderPipelineAsset hdrpAsset, Shader shader, ShaderSnippetData snippet, ShaderCompilerData inputData)
{
// If ray tracing is disabled, strip all ray tracing shaders
if (hdrpAsset.currentPlatformRenderPipelineSettings.supportRayTracing == false)
{
// If transparent we don't need the depth only pass
if (snippet.passName == "IndirectDXR" ||
snippet.passName == "ForwardDXR" ||
snippet.passName == "VisibilityDXR" ||
snippet.passName == "PathTracingDXR" ||
snippet.passName == "GBufferDXR")
{
return(true);
}
}
return(false);
}
public override bool QualityEnabled()
{
// Quality always used for SSR
if (!HDRenderPipeline.rayTracingSupportedBySystem || !m_RayTracing.value.boolValue)
{
return(true);
}
// Handle the quality usage for RTGI
HDRenderPipelineAsset currentAsset = HDRenderPipeline.currentAsset;
var bothSupportedAndPerformanceMode = currentAsset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Both &&
m_Mode.value.GetEnumValue <RayTracingMode>() == RayTracingMode.Performance;
var performanceSupported = currentAsset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Performance;
return(bothSupportedAndPerformanceMode || performanceSupported);
}
public override bool ShadersStripper(HDRenderPipelineAsset hdrpAsset, Shader shader, ShaderSnippetData snippet, ShaderCompilerData inputData)
{
// Note: We know that all the rules of common stripper and Lit Stripper are apply, here we only need to do what is specific to AxF shader
bool isForwardPass = snippet.passName == "ForwardOnly";
bool isDepthOnlyPass = snippet.passName == "DepthForwardOnly";
bool isMotionPass = snippet.passName == "Motion Vectors";
// Using Contains to include the Tessellation variants
bool isBuiltInLit = shader.name.Contains("HDRP/AxF");
// Apply following set of rules only to inspector version of shader
if (isBuiltInLit)
{
if (inputData.shaderKeywordSet.IsEnabled(m_Transparent))
{
// If transparent we don't need the depth only pass
if (isDepthOnlyPass)
{
return(true);
}
// If transparent we don't need the motion vector pass
if (isMotionPass)
{
return(true);
}
// If we are transparent we use cluster lighting and not tile lighting
if (inputData.shaderKeywordSet.IsEnabled(m_TileLighting))
{
return(true);
}
}
else // Opaque
{
// TODO: Should we remove Cluster version if we know MSAA is disabled ? This prevent to manipulate LightLoop Settings (useFPTL option)
// For now comment following code
// if (inputData.shaderKeywordSet.IsEnabled(m_ClusterLighting) && !hdrpAsset.currentPlatformRenderPipelineSettings.supportMSAA)
// return true;
}
}
return(false);
}
public HDRPreprocessShaders()
{
// Samplegame hack
m_CurrentHDRPAsset = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
materialList = HDEditorUtils.GetBaseShaderPreprocessorList();
// EXISTING CODE; BROKEN WHEN BUILDING BATCHMOD
/*
* // TODO: Grab correct configuration/quality asset.
* HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
* if (hdPipeline != null)
* {
* m_CurrentHDRPAsset = hdPipeline.asset;
*
* materialList = HDEditorUtils.GetBaseShaderPreprocessorList();
* }
*/
}
static void OnLoad()
{
if (null != GraphicsSettings.renderPipelineAsset)
{
return;
}
var allAssetPaths = AssetDatabase.GetAllAssetPaths();
foreach (var curAssetPath in allAssetPaths)
{
if (curAssetPath.EndsWith("HDRenderPipelineAsset.asset"))
{
HDRenderPipelineAsset pipelineAsset =
AssetDatabase.LoadAssetAtPath <HDRenderPipelineAsset>(curAssetPath);
GraphicsSettings.renderPipelineAsset = pipelineAsset;
PlayerSettings.colorSpace = ColorSpace.Linear;
}
}
}
static void Drawer_SectionRenderingPasses(FrameSettingsUI s, SerializedFrameSettings p, Editor owner, bool withOverride)
{
//disable temporarily as FrameSettings are not supported for Baked probe at the moment
using (new EditorGUI.DisabledScope((owner is HDProbeEditor) && (owner as HDProbeEditor).GetTarget(owner.target).mode != ReflectionProbeMode.Realtime || (owner is HDRenderPipelineEditor) && HDRenderPipelineUI.selectedFrameSettings == HDRenderPipelineUI.SelectedFrameSettings.BakedOrCustomReflection))
{
HDRenderPipelineAsset hdrpAsset = GetHDRPAssetFor(owner);
RenderPipelineSettings hdrpSettings = hdrpAsset.renderPipelineSettings;
FrameSettings defaultFrameSettings = GetDefaultFrameSettingsFor(owner);
OverridableSettingsArea area = new OverridableSettingsArea(8);
area.Add(p.enableTransparentPrepass, transparentPrepassContent, () => p.overridesTransparentPrepass, a => p.overridesTransparentPrepass = a, defaultValue: defaultFrameSettings.enableTransparentPrepass);
area.Add(p.enableTransparentPostpass, transparentPostpassContent, () => p.overridesTransparentPostpass, a => p.overridesTransparentPostpass = a, defaultValue: defaultFrameSettings.enableTransparentPostpass);
area.Add(p.enableMotionVectors, motionVectorContent, () => p.overridesMotionVectors, a => p.overridesMotionVectors = a, () => hdrpSettings.supportMotionVectors, defaultValue: defaultFrameSettings.enableMotionVectors);
area.Add(p.enableObjectMotionVectors, objectMotionVectorsContent, () => p.overridesObjectMotionVectors, a => p.overridesObjectMotionVectors = a, () => hdrpSettings.supportMotionVectors && p.enableMotionVectors.boolValue, defaultValue: defaultFrameSettings.enableObjectMotionVectors, indent: 1);
area.Add(p.enableDecals, decalsContent, () => p.overridesDecals, a => p.overridesDecals = a, () => hdrpSettings.supportDecals, defaultValue: defaultFrameSettings.enableDecals);
area.Add(p.enableRoughRefraction, roughRefractionContent, () => p.overridesRoughRefraction, a => p.overridesRoughRefraction = a, defaultValue: defaultFrameSettings.enableRoughRefraction);
area.Add(p.enableDistortion, distortionContent, () => p.overridesDistortion, a => p.overridesDistortion = a, () => hdrpSettings.supportDistortion, defaultValue: defaultFrameSettings.enableDistortion);
area.Add(p.enablePostprocess, postprocessContent, () => p.overridesPostprocess, a => p.overridesPostprocess = a, defaultValue: defaultFrameSettings.enablePostprocess);
area.Draw(withOverride);
}
}
public HDRPreprocessShaders()
{
// TODO: Grab correct configuration/quality asset.
HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
if (hdPipeline != null)
{
m_CurrentHDRPAsset = hdPipeline.asset;
}
m_StripperFuncs = new Dictionary <string, VariantStrippingFunc>();
List <BaseShaderPreprocessor> materialList = HDEditorUtils.GetBaseShaderPreprocessorList();
// Fill the dictionary with material to handle
foreach (BaseShaderPreprocessor material in materialList)
{
material.AddStripperFuncs(m_StripperFuncs);
}
}
