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