Mask Volume:

Mask Volume Feature Parity: Mask Volumes use Global Unique ID system … (#32)

* Mask Volume Feature Parity: Mask Volumes use Global Unique ID system just like Probe Volumes, follow the same eviction scheme as probe volumes, have the same debug rendering options as probe volumes (where relevant) and have dead code paths cleaned out. Global Distance Fade Start / End exposed on the Volume System Probe Volume Controller and new Mask Volume Controller to limit atlas subscription when zoomed way out in large scenes. Volumes are now evicted from the atlas when they are culled in the prepare probe volume / mask volume lists stage.

* Add atlas allocation stats for Mask Volumes

Co-authored-by: pastasfuture <[email protected]>

Mask Volumes: Cleanup the state when HDRP has Mask Volumes disabled in the HDRenderPipelineAsset or FrameSettings. Previously we would hit some null reference errors because the disabled paths were not well tested. These fixes should improve the process of setting up Probe Volumes / Mask Volumes in a new project

Author: pastasfuture

com.unity.render-pipelines.high-definition/Editor/Material/MaskVolume/MaskVolumeEditor.cs

@@ -117,8 +117,8 @@ protected void OnSceneGUI()
         {
             MaskVolume maskVolume = target as MaskVolume;
 
-            /* if (Event.current.type == EventType.Layout)
-                maskVolume.DrawSelectedMasks(); */
+            if (Event.current.type == EventType.Layout)
+                maskVolume.DrawSelectedMasks();
 
             if (!blendBoxes.TryGetValue(maskVolume, out HierarchicalBox blendBox)) { return; }
             if (!shapeBoxes.TryGetValue(maskVolume, out HierarchicalBox shapeBox)) { return; }

com.unity.render-pipelines.high-definition/Editor/Material/MaskVolume/MaskVolumeSamplePreview.shader

@@ -0,0 +1,167 @@
+Shader "Hidden/Debug/MaskVolumeSamplePreview"
+{
+    Properties
+    {
+        _Exposure("_Exposure", Range(-10.0,10.0)) = 0.0
+        _MaskVolumeResolution("_MaskVolumeResolution", Vector) = (0, 0, 0, 0)
+        _MaskVolumeProbeDisplayRadiusWS("_MaskVolumeProbeDisplayRadiusWS", Float) = 1.0
+        _MaskVolumeAtlasBiasTexels("_MaskVolumeAtlasBiasTexels", Vector) = (0, 0, 0, 0)
+        _MaskVolumeIsResidentInAtlas("_MaskVolumeIsResidentInAtlas", Float) = 0.0
+        _MaskVolumeDrawWeightThresholdSquared("_MaskVolumeDrawWeightThresholdSquared", Float) = 0.0
+    }
+
+    SubShader
+    {
+        Tags{ "RenderPipeline" = "HDRenderPipeline" "RenderType" = "Opaque" "Queue" = "Transparent" }
+        ZWrite On
+        Cull Front
+
+        Pass
+        {
+            Name "ForwardUnlit"
+            Tags{ "LightMode" = "Forward" }
+
+            HLSLPROGRAM
+
+            #pragma editor_sync_compilation
+
+            #pragma vertex vert
+            #pragma fragment frag
+
+            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
+            #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/EntityLighting.hlsl"
+
+            #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaskVolume/MaskVolumeShaderVariables.hlsl"
+            #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaskVolume/MaskVolumeAtlas.hlsl"
+
+            struct appdata
+            {
+                uint vertexID : SV_VertexID;
+            };
+
+            struct v2f
+            {
+                float4 positionCS : SV_POSITION;
+                float2 uv : TEXCOORD0;
+                float3 probeIndex3D : TEXCOORD1;
+            };
+
+            float _Exposure;
+
+            float3 _MaskVolumeResolution;
+            float4x4 _ProbeIndex3DToPositionWSMatrix;
+            float _MaskVolumeProbeDisplayRadiusWS;
+            float3 _MaskVolumeAtlasBiasTexels;
+            int _MaskVolumeIsResidentInAtlas;
+            float _MaskVolumeDrawWeightThresholdSquared;
+
+            uint3 ComputeWriteIndexFromReadIndex(uint readIndex, float3 resolution)
+            {
+                // _MaskVolumeAtlasReadBuffer[z * resolutionY * resolutionX + y * resolutionX + x]
+                // TODO: Could implement as floating point operations, which is likely faster.
+                // Would need to verify precision.
+                uint x = readIndex % (uint)resolution.x;
+                uint y = (readIndex / (uint)resolution.x) % (uint)resolution.y;
+                uint z = readIndex / ((uint)resolution.y * (uint)resolution.x);
+
+                return uint3(x, y, z);
+            }
+
+            v2f vert(appdata v)
+            {
+                v2f o;
+
+                uint probeIndex1D = v.vertexID / 6u;
+                uint probeTriangleIndex = (v.vertexID / 3u) & 1u;
+                uint probeVertexIndex = v.vertexID - probeIndex1D * 6u - probeTriangleIndex * 3u;
+
+                float2 vertexPositionOS = (probeTriangleIndex == 1u)
+                    ? float2((probeVertexIndex & 1u), saturate(probeVertexIndex))
+                    : float2(saturate(probeVertexIndex), saturate((float)probeVertexIndex - 1.0));
+                o.uv = vertexPositionOS;
+                vertexPositionOS = vertexPositionOS * 2.0 - 1.0;
+                vertexPositionOS *= _MaskVolumeProbeDisplayRadiusWS;
+
+                o.probeIndex3D = ComputeWriteIndexFromReadIndex(probeIndex1D, _MaskVolumeResolution);
+                float3 probeOriginWS = mul(_ProbeIndex3DToPositionWSMatrix, float4(o.probeIndex3D, 1.0)).xyz;
+                float3 probeOriginRWS = GetCameraRelativePositionWS(probeOriginWS);
+                
+                float3 cameraRightWS = mul(float4(1.0, 0.0, 0.0, 0.0), UNITY_MATRIX_V).xyz;
+                float3 cameraUpWS = mul(float4(0.0, 1.0, 0.0, 0.0), UNITY_MATRIX_V).xyz;
+
+                float3 positionRWS = (cameraRightWS * vertexPositionOS.x + cameraUpWS * vertexPositionOS.y) + probeOriginRWS;
+                o.positionCS = TransformWorldToHClip(positionRWS);
+
+                return o;
+            }
+
+            void ClipProbeSphere(float2 uv)
+            {
+                float2 positionProbeCard = uv * 2.0 - 1.0;
+                clip(dot(positionProbeCard, positionProbeCard) < 1.0 ? 1.0 : -1.0);
+            }
+
+            float3 ComputeProbeNormalWSFromCameraFacingOrtho(float2 uv)
+            {
+                // Reconstruct a surface normal vector for our virtual probe sphere using the knowledge that
+                // our card is camera aligned, and we can project from the 2D disc coordinate to 3D sphere surface coordinate.
+                // This will not take into account perspective - but as a method to preview probe SH data, this limitation fine visually.
+                float2 normalOSXY = uv * 2.0 - 1.0;
+                float normalOSZ = (1.0 - dot(normalOSXY, normalOSXY));
+
+                float3 normalWS = mul(float4(normalOSXY, normalOSZ, 0.0), UNITY_MATRIX_V).xyz;
+                return normalWS;
+            }
+
+            float3 SampleProbeMaskData(int3 probeIndexAtlas3D, float3 normalWS)
+            {
+                float3 mask = 0.0;
+
+                MaskVolumeData coefficients;
+                ZERO_INITIALIZE(MaskVolumeData, coefficients);
+                MaskVolumeLoadAccumulate(probeIndexAtlas3D, 1.0f, coefficients);
+                mask = coefficients.data[0].rgb;
+
+                return mask;
+            }
+
+            float3 SampleMaskData(int3 probeIndexAtlas3D, float3 normalWS)
+            {
+                float3 mask = SampleProbeMaskData(probeIndexAtlas3D, normalWS);
+                mask = max(0.0, mask);
+                return mask;
+            }
+
+            void ClipDrawWeightThreshold(float3 mask)
+            {
+                clip((dot(mask, mask) >= (_MaskVolumeDrawWeightThresholdSquared)) ? 1.0 : -1.0);
+            }
+
+            float4 frag(v2f i) : SV_Target
+            {
+                ClipProbeSphere(i.uv);
+                float3 normalWS = ComputeProbeNormalWSFromCameraFacingOrtho(i.uv);
+                
+                float3 mask = 0.0;
+
+                if (_MaskVolumeIsResidentInAtlas)
+                {
+                    // Due to probeIndex3D getting stored as a float and interpolated, we need to round before converting to int.
+                    // Otherwise our texel coordinate will oscillate between probes randomly (based on precision).
+                    int3 probeIndexAtlas3D = (int3)(i.probeIndex3D + 0.5 + _MaskVolumeAtlasBiasTexels);
+
+                    mask = SampleMaskData(probeIndexAtlas3D, normalWS);
+                }
+
+                ClipDrawWeightThreshold(mask);
+
+                mask *= exp2(_Exposure) * GetCurrentExposureMultiplier();
+
+                return float4(mask, 1.0);
+            }
+            ENDHLSL
+        }
+    }
+}

com.unity.render-pipelines.high-definition/Editor/Material/MaskVolume/MaskVolumeSamplePreview.shader.meta

@@ -143,6 +143,11 @@ static void ChannelField(ref bool enabled, ref float value, string label, bool i
         static void Drawer_PrimarySettings(SerializedMaskVolume serialized, Editor owner)
         {
             EditorGUILayout.PropertyField(serialized.drawGizmos, Styles.s_DrawGizmosLabel);
+            if (serialized.drawGizmos.boolValue)
+            {
+                EditorGUILayout.Slider(serialized.drawWeightThreshold, 0.0f, 1.0f, Styles.s_DrawWeightThreshold);
+            }
+
             EditorGUILayout.PropertyField(serialized.maskSpacingMode, Styles.s_MaskSpacingModeLabel);
             switch ((MaskSpacingMode)serialized.maskSpacingMode.enumValueIndex)
             {
@@ -331,7 +336,6 @@ static void Drawer_VolumeContent(SerializedMaskVolume serialized, Editor owner)
             }
 
             EditorGUILayout.PropertyField(serialized.lightLayers);
-            EditorGUILayout.PropertyField(serialized.blendMode, Styles.s_VolumeBlendModeLabel);
             EditorGUILayout.Slider(serialized.weight, 0.0f, 1.0f, Styles.s_WeightLabel);
             {
                 EditorGUI.BeginChangeCheck();

com.unity.render-pipelines.high-definition/Editor/Material/MaskVolume/MaskVolumeUI.Drawer.cs

@@ -27,6 +27,7 @@ internal static class Styles
             internal static readonly GUIContent s_Size = new GUIContent("Size", "Modify the size of this Mask Volume. This is independent of the Transform's Scale.");
             internal static readonly GUIContent s_DebugColorLabel = new GUIContent("Debug Color", "This color is used to visualize per-pixel mask volume weights in the render pipeline debugger.");
             internal static readonly GUIContent s_DrawGizmosLabel = new GUIContent("Draw Gizmos", "Enable or disable drawing gizmos.");
+            internal static readonly GUIContent s_DrawWeightThreshold = new GUIContent("Draw Weight Threshold", "Probes with a total mask weight less than Draw Weight Threshold will be hidden. Debug / Editor Only.");
             internal static readonly GUIContent s_BlendLabel = new GUIContent("Blend Distance", "Interior distance from the Size where the contribution fades in completely.");
             internal static readonly GUIContent s_NormalModeContent = new GUIContent("Normal", "Exposes standard parameters.");
             internal static readonly GUIContent s_AdvancedModeContent = new GUIContent("Advanced", "Exposes advanced parameters.");
@@ -42,7 +43,6 @@ internal static class Styles
             internal static readonly GUIContent s_DensityYLabel = new GUIContent("Density Y", "Modify the density (number of masks per unit in Y). Resolution will be automatically computed based on density.");
             internal static readonly GUIContent s_DensityZLabel = new GUIContent("Density Z", "Modify the density (number of masks per unit in Z). Resolution will be automatically computed based on density.");
 
-            internal static readonly GUIContent s_VolumeBlendModeLabel = new GUIContent("Volume Blend Mode", "A blending mode for the entire volume when overlapping others.");
             internal static readonly GUIContent s_WeightLabel = new GUIContent("Weight", "Weigh the mask contribution for the entire volume.");
             internal static readonly GUIContent s_NormalBiasWSLabel = new GUIContent("Normal Bias", "Controls the distance in world space units to bias along the surface normal to mitigate light leaking and self-shadowing artifacts.\nA value of 0.0 is physically accurate, but can result in self shadowing artifacts on surfaces that contribute to GI.\nIncrease value to mitigate self shadowing artifacts.\nSignificantly large values can have performance implications, as normal bias will dilate a mask volumes bounding box, causing it to be sampled in additional neighboring tiles / clusters.");
 

com.unity.render-pipelines.high-definition/Editor/Material/MaskVolume/MaskVolumeUI.Skin.cs

@@ -6,6 +6,7 @@ class SerializedMaskVolume
         internal SerializedProperty maskVolumeAsset;
         internal SerializedProperty debugColor;
         internal SerializedProperty drawGizmos;
+        internal SerializedProperty drawWeightThreshold;
 
         internal SerializedProperty maskSpacingMode;
 
@@ -17,7 +18,6 @@ class SerializedMaskVolume
         internal SerializedProperty densityY;
         internal SerializedProperty densityZ;
 
-        internal SerializedProperty blendMode;
         internal SerializedProperty weight;
         internal SerializedProperty normalBiasWS;
 
@@ -47,6 +47,7 @@ internal SerializedMaskVolume(SerializedObject serializedObject)
 
             debugColor = maskVolumeParams.FindPropertyRelative("debugColor");
             drawGizmos = maskVolumeParams.FindPropertyRelative("drawGizmos");
+            drawWeightThreshold = maskVolumeParams.FindPropertyRelative("drawWeightThreshold");
 
             maskSpacingMode = maskVolumeParams.FindPropertyRelative("maskSpacingMode");
 
@@ -58,7 +59,6 @@ internal SerializedMaskVolume(SerializedObject serializedObject)
             densityY = maskVolumeParams.FindPropertyRelative("densityY");
             densityZ = maskVolumeParams.FindPropertyRelative("densityZ");
 
-            blendMode = maskVolumeParams.FindPropertyRelative("blendMode");
             weight = maskVolumeParams.FindPropertyRelative("weight");
             normalBiasWS = maskVolumeParams.FindPropertyRelative("normalBiasWS");
 

com.unity.render-pipelines.high-definition/Editor/Material/MaskVolume/SerializedMaskVolume.cs

@@ -288,6 +288,7 @@ public class DebugData
             internal int grayscaleDebugModeIndex;
             internal int probeVolumeDebugModeEnumIndex;
             internal int probeVolumeAtlasSliceModeEnumIndex;
+            internal int maskVolumeDebugModeEnumIndex;
 
             // When settings mutually exclusives enum values, we need to reset the other ones.
             internal void ResetExclusiveEnumIndices()
@@ -733,6 +734,15 @@ internal void SetProbeVolumeAtlasSliceMode(ProbeVolumeAtlasSliceMode value)
             data.lightingDebugSettings.probeVolumeAtlasSliceMode = value;
         }
 
+        /// <summary>
+        /// Set the current Mask Volume Debug Mode.
+        /// </summary>
+        /// <param name="value">Desired Probe Volume Debug Mode.</param>
+        internal void SetMaskVolumeDebugMode(MaskVolumeDebugMode value)
+        {
+            data.lightingDebugSettings.maskVolumeDebugMode = value;
+        }
+
         /// <summary>
         /// Set the current Exposure Debug Mode.
         /// </summary>
@@ -1152,6 +1162,14 @@ void RegisterLightingDebug()
                 }
                 });
 
+                lighting.children.Add(new DebugUI.Foldout
+                {
+                    displayName = "Mask Volumes",
+                    children = {
+                    new DebugUI.EnumField { displayName = "Mask Volume Debug Mode", getter = () => (int)data.lightingDebugSettings.maskVolumeDebugMode, setter = value => SetMaskVolumeDebugMode((MaskVolumeDebugMode)value), autoEnum = typeof(MaskVolumeDebugMode), onValueChanged = RefreshLightingDebug, getIndex = () => data.maskVolumeDebugModeEnumIndex, setIndex = value => data.maskVolumeDebugModeEnumIndex = value }
+                }
+                });
+
                 var exposureFoldout = new DebugUI.Foldout
                 {
                     displayName = "Exposure ",

com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.cs

@@ -223,7 +223,14 @@ internal enum ProbeVolumeAtlasSliceMode
         OctahedralDepth
     }
 
-	/// <summary>
+    [GenerateHLSL]
+    internal enum MaskVolumeDebugMode
+    {
+        None,
+        VisualizeAtlas
+    }
+
+    /// <summary>
     /// Lighting Debug Settings.
     /// </summary>
     [Serializable]
@@ -245,7 +252,8 @@ public bool IsDebugDisplayEnabled()
                 || overrideSpecularColor
                 || overrideEmissiveColor
                 || shadowDebugMode == ShadowMapDebugMode.SingleShadow
-                || probeVolumeDebugMode != ProbeVolumeDebugMode.None;
+                || probeVolumeDebugMode != ProbeVolumeDebugMode.None
+                || maskVolumeDebugMode != MaskVolumeDebugMode.None;
         }
 
         /// <summary>Current Light Filtering.</summary>
@@ -272,7 +280,9 @@ public bool IsDebugDisplayEnabled()
         [SerializeField] internal float probeVolumeMinValue = 0.0f;
 		/// <summary>The maximum display threshold for atlas slices.</summary>
         [SerializeField] internal float probeVolumeMaxValue = 1.0f;
-		/// <summary>True if Shadow Map debug mode should be displayed for the currently selected light.</summary>
+        /// <summary>Current Mask Volume Debug Mode.</summary>
+        [SerializeField] internal MaskVolumeDebugMode maskVolumeDebugMode = MaskVolumeDebugMode.None;
+        /// <summary>True if Shadow Map debug mode should be displayed for the currently selected light.</summary>
         public bool                 shadowDebugUseSelection = false;
         /// <summary>Index in the list of currently visible lights of the shadow map to display.</summary>
         public uint                 shadowMapIndex = 0;

com.unity.render-pipelines.high-definition/Runtime/Debug/LightingDebug.cs

@@ -96,6 +96,11 @@
 #define PROBEVOLUMEATLASSLICEMODE_VALIDITY (9)
 #define PROBEVOLUMEATLASSLICEMODE_OCTAHEDRAL_DEPTH (10)
 
+//
+// UnityEngine.Rendering.HighDefinition.MaskVolumeDebugMode:  static fields
+//
+#define MASKVOLUMEDEBUGMODE_NONE (0)
+#define MASKVOLUMEDEBUGMODE_VISUALIZE_ATLAS (1)
 
 
 #endif

com.unity.render-pipelines.high-definition/Runtime/Debug/LightingDebug.cs.hlsl

@@ -744,6 +744,7 @@ enum ClusterDepthSource : int
         Material m_DebugHDShadowMapMaterial;
         Material m_DebugBlitMaterial;
         Material m_DebugDisplayProbeVolumeMaterial;
+        Material m_DebugDisplayMaskVolumeMaterial;
 
         HashSet<HDAdditionalLightData> m_ScreenSpaceShadowsUnion = new HashSet<HDAdditionalLightData>();
 
@@ -873,6 +874,7 @@ void InitializeLightLoop(IBLFilterBSDF[] iBLFilterBSDFArray)
             m_DebugHDShadowMapMaterial = CoreUtils.CreateEngineMaterial(defaultResources.shaders.debugHDShadowMapPS);
             m_DebugBlitMaterial = CoreUtils.CreateEngineMaterial(defaultResources.shaders.debugBlitQuad);
             m_DebugDisplayProbeVolumeMaterial = CoreUtils.CreateEngineMaterial(defaultResources.shaders.debugDisplayProbeVolumePS);
+            m_DebugDisplayMaskVolumeMaterial = CoreUtils.CreateEngineMaterial(defaultResources.shaders.debugDisplayMaskVolumePS);
 
             m_MaxDirectionalLightsOnScreen = lightLoopSettings.maxDirectionalLightsOnScreen;
             m_MaxPunctualLightsOnScreen = lightLoopSettings.maxPunctualLightsOnScreen;