Probe volumes rotation + reflection probe normalization fixes and improvements. Also lots of cleanup to avoid debug-only + lightmapper work when in playmode. Cleaned out old deadcode + comments. Cleaned some GC cases (#1)

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

Author: pastasfuture

com.unity.render-pipelines.high-definition/Editor/Lighting/Reflection/HDProbeEditor.cs

@@ -14,6 +14,7 @@ interface IHDProbeEditor
         HDProbe GetTarget(Object editorTarget);
 
         bool showChromeGizmo { get; set; }
+        bool showLuminanceSH { get; set; }
     }
 
     abstract class HDProbeEditor<TProvider, TSerialized> : Editor, IHDProbeEditor, IDefaultFrameSettingsType
@@ -53,13 +54,28 @@ public bool showChromeGizmo
             }
         }
 
+        const string k_ShowLuminanceSHKey = "HDRP:ReflectionProbe:LuminanceSH";
+        static bool m_ShowLuminanceSH = true;
+        public bool showLuminanceSH
+        {
+            get => m_ShowLuminanceSH;
+            set
+            {
+                m_ShowLuminanceSH = value;
+                EditorPrefs.SetBool(k_ShowLuminanceSHKey, value);
+            }
+        }
+
         protected virtual void OnEnable()
         {
             m_SerializedHDProbe = NewSerializedObject(serializedObject);
 
             if (EditorPrefs.HasKey(k_ShowChromeGizmoKey))
                 m_ShowChromeGizmo = EditorPrefs.GetBool(k_ShowChromeGizmoKey);
 
+            if (EditorPrefs.HasKey(k_ShowLuminanceSHKey))
+                m_ShowLuminanceSH = EditorPrefs.GetBool(k_ShowLuminanceSHKey);
+
             m_SerializedHDProbePerTarget = new Dictionary<Object, TSerialized>(targets.Length);
             m_TypedTargets = new HDProbe[targets.Length];
             for (var i = 0; i < m_TypedTargets.Length; i++)

com.unity.render-pipelines.high-definition/Editor/Lighting/Reflection/HDProbeUI.Drawers.cs

@@ -23,6 +23,7 @@ internal enum ToolBar
             MirrorPosition = 1 << 4,
             MirrorRotation = 1 << 5,
             ShowChromeGizmo = 1 << 6, //not really an edit mode. Should be move later to contextual tool overlay
+            ShowLuminanceSH = 1 << 7, //not really an edit mode. Should be move later to contextual tool overlay
         }
 
         internal interface IProbeUISettingsProvider
@@ -92,6 +93,10 @@ static Drawer()
                             {
                                 listContent.Add(k_ToolbarContents[toolbarJ]);
                             }
+                            else if (toolBar == ToolBar.ShowLuminanceSH)
+                            {
+                                listContent.Add(k_ToolbarContents[toolbarJ]);
+                            }
                             else
                             {
                                 listMode.Add(k_ToolbarMode[toolbarJ]);
@@ -114,15 +119,23 @@ public static void DrawToolbars(SerializedHDProbe serialized, Editor owner)
                 GUILayout.FlexibleSpace();
                 GUI.changed = false;
 
-                for (int i = 0; i < k_ListModes.Length - 1; ++i)
+                for (int i = 0; i < k_ListModes.Length - 2; ++i)
                     EditMode.DoInspectorToolbar(k_ListModes[i], k_ListContent[i], HDEditorUtils.GetBoundsGetter(owner), owner);
 
                 //Special case: show chrome gizmo should be mouved to overlay tool.
                 //meanwhile, display it as an option of toolbar
                 EditorGUI.BeginChangeCheck();
                 IHDProbeEditor probeEditor = owner as IHDProbeEditor;
-                int selected = probeEditor.showChromeGizmo ? 0 : -1;
-                int newSelected = GUILayout.Toolbar(selected, new[] { k_ListContent[k_ListModes.Length - 1][0] }, GUILayout.Height(20), GUILayout.Width(30));
+                int selected = -1;
+                if (probeEditor.showChromeGizmo)
+                {
+                    selected = 0;
+                }
+                else if (probeEditor.showLuminanceSH)
+                {
+                    selected = 1;
+                }
+                int newSelected = GUILayout.Toolbar(selected, new[] { k_ListContent[k_ListModes.Length - 2][0], k_ListContent[k_ListModes.Length - 1][0] }, GUILayout.Height(20), GUILayout.Width(30 * 2));
                 if(EditorGUI.EndChangeCheck())
                 {
                     //allow deselection
@@ -131,6 +144,7 @@ public static void DrawToolbars(SerializedHDProbe serialized, Editor owner)
                     else
                         selected = newSelected;
                     probeEditor.showChromeGizmo = selected == 0;
+                    probeEditor.showLuminanceSH = selected == 1;
                     SceneView.RepaintAll();
                 }
 

com.unity.render-pipelines.high-definition/Editor/Lighting/Reflection/HDProbeUI.Skin.cs

@@ -32,6 +32,7 @@ static partial class HDProbeUI
             { ToolBar.MirrorPosition,  EditorGUIUtility.TrIconContent("MoveTool", "Change the mirror position.") },
             { ToolBar.MirrorRotation,  EditorGUIUtility.TrIconContent("RotateTool", "Change the mirror rotation.") },
             { ToolBar.ShowChromeGizmo,  EditorGUIUtility.TrIconContent(IconReflectionProbeGizmoId, "Display the chrome gizmo.") },
+            { ToolBar.ShowLuminanceSH,  EditorGUIUtility.TrIconContent(IconReflectionProbeLuminanceSHGizmoId, "Display Luminance SH (Reflection Probe Normalization Data).") },
         };
 
         const string IconReflectionProbeGizmoId =
@@ -41,5 +42,7 @@ static partial class HDProbeUI
             "ReflectionProbe Gizmo"
 #endif
             ;
+
+        const string IconReflectionProbeLuminanceSHGizmoId = "d_PreMatLight0";
     }
 }

com.unity.render-pipelines.high-definition/Editor/Lighting/Reflection/HDReflectionProbeEditor.Gizmos.cs

@@ -1,12 +1,14 @@
 using UnityEngine;
 using UnityEngine.Rendering.HighDefinition;
+using UnityEngine.Rendering;
 
 namespace UnityEditor.Rendering.HighDefinition
 {
     sealed partial class HDReflectionProbeEditor
     {
         static Mesh sphere;
         static Material material;
+        static Material materialLuminanceSH;
 
         [DrawGizmo(GizmoType.Selected)]
         static void DrawSelectedGizmo(ReflectionProbe reflectionProbe, GizmoType gizmoType)
@@ -25,15 +27,23 @@ static void DrawSelectedGizmo(ReflectionProbe reflectionProbe, GizmoType gizmoTy
             );
 
             if (e.showChromeGizmo)
+            {
                 Gizmos_CapturePoint(reflectionProbe);
+            }
+            else if (e.showLuminanceSH)
+            {
+                Gizmos_CapturePointLuminanceSH(reflectionProbe);
+            }
         }
 
         static void Gizmos_CapturePoint(ReflectionProbe target)
         {
             if(sphere == null)
                 sphere = Resources.GetBuiltinResource<Mesh>("New-Sphere.fbx");
+
             if(material == null)
                 material = new Material(Shader.Find("Hidden/Debug/ReflectionProbePreview"));
+
             var probe = target.GetComponent<HDAdditionalReflectionData>();
             var probePositionSettings = ProbeCapturePositionSettings.ComputeFrom(probe, null);
             HDRenderUtilities.ComputeCameraSettingsFromProbeSettings(
@@ -43,6 +53,7 @@ static void Gizmos_CapturePoint(ReflectionProbe target)
             var capturePosition = cameraPositionSettings.position;
 
             material.SetTexture("_Cubemap", probe.texture);
+            
             material.SetPass(0);
             Graphics.DrawMeshNow(sphere, Matrix4x4.TRS(capturePosition, Quaternion.identity, Vector3.one * capturePointPreviewSize));
 
@@ -64,5 +75,55 @@ static void Gizmos_CapturePoint(ReflectionProbe target)
                 Handles.DrawWireDisc(hit.point, hit.normal, 0.5f);
             }
         }
+
+        static void Gizmos_CapturePointLuminanceSH(ReflectionProbe target)
+        {
+            if (sphere == null)
+                sphere = Resources.GetBuiltinResource<Mesh>("New-Sphere.fbx");
+            if (materialLuminanceSH == null)
+                materialLuminanceSH = new Material(Shader.Find("Hidden/Debug/ReflectionProbeLuminanceSHPreview"));
+
+            var probe = target.GetComponent<HDAdditionalReflectionData>();
+            var probePositionSettings = ProbeCapturePositionSettings.ComputeFrom(probe, null);
+            HDRenderUtilities.ComputeCameraSettingsFromProbeSettings(
+                probe.settings, probePositionSettings,
+                out _, out var cameraPositionSettings, 0
+            );
+            var capturePosition = cameraPositionSettings.position;
+
+            bool _LuminanceSHEnabled = true;
+            if (!probe.GetLuminanceSHL2ForNormalization(out Vector4 _L0L1, out Vector4 _L2_1, out float _L2_2))
+            {
+                _LuminanceSHEnabled = false;
+                _L0L1 = Vector4.zero;
+                _L2_1 = Vector4.zero;
+                _L2_2 = 0.0f;
+            }
+            materialLuminanceSH.SetInt("_LuminanceSHEnabled", _LuminanceSHEnabled ? 1 : 0);
+            materialLuminanceSH.SetVector("_L0L1", _L0L1);
+            materialLuminanceSH.SetVector("_L2_1", _L2_1);
+            materialLuminanceSH.SetFloat("_L2_2", _L2_2);
+
+            materialLuminanceSH.SetPass(0);
+            Graphics.DrawMeshNow(sphere, Matrix4x4.TRS(capturePosition, Quaternion.identity, Vector3.one * capturePointPreviewSize));
+
+            var ray = new Ray(capturePosition, Vector3.down);
+            if (Physics.Raycast(ray, out RaycastHit hit))
+            {
+                var startPoint = capturePosition - Vector3.up * 0.5f * capturePointPreviewSize;
+                var c = InfluenceVolumeUI.k_GizmoThemeColorBase;
+                c.a = 0.8f;
+                Handles.color = c;
+                Handles.zTest = UnityEngine.Rendering.CompareFunction.LessEqual;
+                Handles.DrawLine(startPoint, hit.point);
+                Handles.DrawWireDisc(hit.point, hit.normal, 0.5f);
+
+                c.a = 0.25f;
+                Handles.color = c;
+                Handles.zTest = UnityEngine.Rendering.CompareFunction.Greater;
+                Handles.DrawLine(capturePosition, hit.point);
+                Handles.DrawWireDisc(hit.point, hit.normal, 0.5f);
+            }
+        }
     }
 }

com.unity.render-pipelines.high-definition/Editor/Lighting/Reflection/HDReflectionProbeEditor.cs

@@ -106,7 +106,8 @@ struct HDProbeSettingsProvider : HDProbeUI.IProbeUISettingsProvider, InfluenceVo
         {
             HDProbeUI.ToolBar.InfluenceShape | HDProbeUI.ToolBar.NormalBlend | HDProbeUI.ToolBar.Blend,
             HDProbeUI.ToolBar.CapturePosition,
-            HDProbeUI.ToolBar.ShowChromeGizmo
+            HDProbeUI.ToolBar.ShowChromeGizmo,
+            HDProbeUI.ToolBar.ShowLuminanceSH
         };
         HDProbeUI.ToolBar[] HDProbeUI.IProbeUISettingsProvider.toolbars => k_ToolBars;
 

com.unity.render-pipelines.high-definition/Editor/Lighting/Reflection/ReflectionProbesLuminanceSHPreview.shader

@@ -0,0 +1,133 @@
+Shader "Debug/ReflectionProbeLuminanceSHPreview"
+{
+    Properties
+    {
+        _LuminanceSHEnabled("_LuminanceSHEnabled", Int) = 0
+        _L0L1("_L0L1", Vector) = (0,0,0,0)
+        _L2_1("_L2_1", Vector) = (0,0,0,0)
+        _L2_2("_L2_2", Float) = 0.0
+        _Exposure("_Exposure", Range(-10.0,10.0)) = 0.0
+
+    }
+
+    SubShader
+    {
+        Tags{ "RenderPipeline" = "HDRenderPipeline" "RenderType" = "Opaque" "Queue" = "Transparent" }
+        ZWrite On
+        Cull Back
+
+        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"
+
+            struct appdata
+            {
+                float4 positionOS : POSITION;
+                float3 normalOS : NORMAL;
+            };
+
+            struct v2f
+            {
+                float4 positionCS : SV_POSITION;
+                float3 normalWS : NORMAL;
+                float3 positionWS : TEXCOORD0;
+            };
+
+            int _LuminanceSHEnabled;
+            float4 _L0L1;
+            float4 _L2_1;
+            float _L2_2;
+            float _Exposure;
+
+            v2f vert(appdata v)
+            {
+                v2f o;
+                // Transform local to world before custom vertex code
+                o.positionWS = TransformObjectToWorld(v.positionOS.xyz);
+                o.positionCS = TransformWorldToHClip(o.positionWS);
+                o.normalWS = TransformObjectToWorldNormal(v.normalOS);
+
+                return o;
+            }
+
+            // Ref: "Efficient Evaluation of Irradiance Environment Maps" from ShaderX 2
+            float SHEvalLinearL0L1Luminance(float3 N, float4 shA)
+            {
+                // Linear (L1) + constant (L0) polynomial terms
+                return dot(shA.xyz, N) + shA.w;
+            }
+
+            float SHEvalLinearL2Luminance(float3 N, float4 shB, float shC)
+            {
+                // 4 of the quadratic (L2) polynomials
+                float4 vB = N.xyzz * N.yzzx;
+                float x2 = dot(shB, vB);
+
+                // Final (5th) quadratic (L2) polynomial
+                float vC = N.x * N.x - N.y * N.y;
+                float x3 = shC * vC;
+
+                return x2 + x3;
+            }
+
+            float SampleSH9Luminance(float3 N, float4 shA, float4 shB, float shC)
+            {
+                // Linear + constant polynomial terms
+                float res = SHEvalLinearL0L1Luminance(N, shA);
+
+                // Quadratic polynomials
+                res += SHEvalLinearL2Luminance(N, shB, shC);
+
+                return res;
+            }
+
+            float GetReflectionProbeNormalizationFactor(float3 sampleDirectionWS, float4 reflProbeSHL0L1, float4 reflProbeSHL2_1, float reflProbeSHL2_2)
+            {
+                // SHEvalLinearL0L1() expects coefficients in float4 shAr, float4 shAg, float4 shAb vectors whos channels are laid out {x, y, z, DC}
+                float4 shALuminance = float4(reflProbeSHL0L1.w, reflProbeSHL0L1.y, reflProbeSHL0L1.z, reflProbeSHL0L1.x);
+
+                float4 shBLuminance = reflProbeSHL2_1;
+                float shCLuminance = reflProbeSHL2_2;
+
+                // // Normalize DC term:
+                shALuminance.w -= shBLuminance.z;
+
+                // // Normalize Quadratic term:
+                shBLuminance.z *= 3.0f;
+
+                return  SampleSH9Luminance(sampleDirectionWS, shALuminance, shBLuminance, shCLuminance);
+            }
+
+            float4 frag(v2f i) : SV_Target
+            {
+                float3 N = normalize(i.normalWS);
+
+                float luminanceSH = GetReflectionProbeNormalizationFactor(N, _L0L1, _L2_1, _L2_2);
+                float4 colorLuminanceSH = (_LuminanceSHEnabled > 0)
+                    ? (luminanceSH < 0.0f)
+                        ? float4(1.0f, 0.0f, 0.0f, 1.0f)
+                        : float4(luminanceSH, luminanceSH, luminanceSH, 1.0f)
+                    : float4(1.0f, 0.0f, 1.0f, 1.0f);
+
+                float4 color = colorLuminanceSH;
+
+                color.rgb = color.rgb * exp2(_Exposure) * GetCurrentExposureMultiplier();
+
+                return float4(color);
+            }
+            ENDHLSL
+        }
+    }
+}