(WIP) Added debug exposure to material debug views.

ScriptableRenderPipeline/Core/CoreRP/Editor/ShaderGenerator/ShaderTypeGeneration.cs

 
         class DebugFieldInfo
         {
-            public DebugFieldInfo(string defineName, string fieldName, Type fieldType, bool isDirection, bool isSRGB)
+            public DebugFieldInfo(string defineName, string fieldName, Type fieldType, bool isDirection, bool isSRGB, bool needDebugExposure)
             {
                 this.defineName = defineName;
                 this.fieldName = fieldName;
+                this.needDebugExposure = needDebugExposure;
             }
 
             public string defineName;
             public bool isSRGB;
+            public bool needDebugExposure;
         }
 
         void Error(string error)
             shaderText += "// Debug functions\n";
             shaderText += "//\n";
 
-            shaderText += "void GetGenerated" + type.Name + "Debug(uint paramId, " + type.Name + " " + lowerStructName + ", inout float3 result, inout bool needLinearToSRGB)\n";
+            shaderText += "void GetGenerated" + type.Name + "Debug(uint paramId, " + type.Name + " " + lowerStructName + ", inout float3 result, inout bool needLinearToSRGB, float debugExposure)\n";
             shaderText += "{\n";
             shaderText += "    switch (paramId)\n";
             shaderText += "    {\n";
                 else // This case left is suppose to be a complex structure. Either we don't support it or it is an enum. Consider it is an enum with GetIndexColor, user can override it if he want.
                 {
                     shaderText += "            result = GetIndexColor(" + lowerStructName + "." + debugField.fieldName + ");\n";
+                }
+
+                if(debugField.needDebugExposure)
+                {
+                    shaderText += "            result *= exp2(debugExposure);\n";
                 }
 
                 if (debugField.isSRGB)
 
                     bool isDirection = false;
                     bool sRGBDisplay = false;
+                    bool needDebugExposure = false;
 
                     // Check if the display name have been override by the users
                     if (Attribute.IsDefined(field, typeof(SurfaceDataAttributes)))
                         }
                         isDirection = propertyAttr[0].isDirection;
                         sRGBDisplay = propertyAttr[0].sRGBDisplay;
+                        needDebugExposure = propertyAttr[0].needDebugExposure;
                     }
 
                     string className = type.FullName.Substring(type.FullName.LastIndexOf((".")) + 1); // ClassName include nested class
                         string defineName = ("DEBUGVIEW_" + className + "_" + name).ToUpper();
                         m_Statics[defineName] = Convert.ToString(attr.paramDefinesStart + debugCounter++);
 
-                        m_DebugFields.Add(new DebugFieldInfo(defineName, field.Name, field.FieldType, isDirection, sRGBDisplay));
+                        m_DebugFields.Add(new DebugFieldInfo(defineName, field.Name, field.FieldType, isDirection, sRGBDisplay, needDebugExposure));
                     }
                 }
 

ScriptableRenderPipeline/Core/CoreRP/ShaderGenerator/ShaderGeneratorAttributes.cs

         public string[] displayNames;
         public bool isDirection;
         public bool sRGBDisplay;
+        public bool needDebugExposure;
-        public SurfaceDataAttributes(string displayName = "", bool isDirection = false, bool sRGBDisplay = false)
+        public SurfaceDataAttributes(string displayName = "", bool isDirection = false, bool sRGBDisplay = false, bool needDebugExposure = false)
+            this.needDebugExposure = needDebugExposure;
-        public SurfaceDataAttributes(string[] displayName, bool isDirection = false, bool sRGBDisplay = false)
+        public SurfaceDataAttributes(string[] displayName, bool isDirection = false, bool sRGBDisplay = false, bool needDebugExposure = false)
+            this.needDebugExposure = needDebugExposure;
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplay.cs

             DebugViewGbuffer debugGBuffer = (DebugViewGbuffer)materialDebugSettings.debugViewGBuffer;
             return  (debugLighting == DebugLightingMode.DiffuseLighting || debugLighting == DebugLightingMode.SpecularLighting) ||
                     (debugGBuffer == DebugViewGbuffer.BakeDiffuseLightingWithAlbedoPlusEmissive) ||
-                    (fullScreenDebugMode == FullScreenDebugMode.PreRefractionColorPyramid || fullScreenDebugMode == FullScreenDebugMode.FinalColorPyramid);
+                    (fullScreenDebugMode == FullScreenDebugMode.PreRefractionColorPyramid || fullScreenDebugMode == FullScreenDebugMode.FinalColorPyramid) ||
+                    // Not really a good test, we'd prefer to know if the current material debug needs exposure... but since it's generated we can't really know here. It means that color picker will give the wrong result for anything that does not need exposure.
+                    (materialDebugSettings.IsDebugDisplayEnabled());
         }
 
         void RegisterDisplayStatsDebug()

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewMaterialGBuffer.shader

                 }
                 #endif
 
-                GetBSDFDataDebug(_DebugViewMaterial, bsdfData, result, needLinearToSRGB);
+                GetBSDFDataDebug(_DebugViewMaterial, bsdfData, result, needLinearToSRGB, _DebugExposure);
 
                 // f we haven't touch result, we don't blend it. This allow to have the GBuffer debug pass working with the regular forward debug pass.
                 // The forward debug pass will write its value and then the deferred will overwrite only touched texels.

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/MaterialDebug.cs.hlsl

 #define DEBUGVIEWVARYING_VERTEX_NORMAL_WS (7)
 #define DEBUGVIEWVARYING_VERTEX_COLOR (8)
 #define DEBUGVIEWVARYING_VERTEX_COLOR_ALPHA (9)
-#define DEBUGVIEWVARYING_LAST (10)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Attributes.DebugViewGbuffer:  static fields
 #define DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK1 (13)
 #define DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK2 (14)
 #define DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK3 (15)
-#define DEBUGVIEWGBUFFER_LAST (16)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Attributes.DebugViewProperties:  static fields
 #define DEBUGVIEWPROPERTIES_DEPTH_OFFSET (20)
 #define DEBUGVIEWPROPERTIES_LIGHTMAP (21)
 #define DEBUGVIEWPROPERTIES_INSTANCING (22)
-#define DEBUGVIEWPROPERTIES_LAST (23)
 
 
 #endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Builtin/BuiltinData.cs

             // We would prefer to split lighting and material information but for performance reasons,
             // those lighting information are fill
             // at the same time than material information.
-            [SurfaceDataAttributes("Bake Diffuse Lighting", false, true)]
+            [SurfaceDataAttributes("Bake Diffuse Lighting", false, true, true)]
             public Vector3 bakeDiffuseLighting; // This is the result of sampling lightmap/lightprobe/proxyvolume
 
             // Use for float instead of vector4 to ease the debug (no performance impact)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Builtin/BuiltinData.cs.hlsl

 //
 // Debug functions
 //
-void GetGeneratedBuiltinDataDebug(uint paramId, BuiltinData builtindata, inout float3 result, inout bool needLinearToSRGB)
+void GetGeneratedBuiltinDataDebug(uint paramId, BuiltinData builtindata, inout float3 result, inout bool needLinearToSRGB, float debugExposure)
 {
     switch (paramId)
     {
         case DEBUGVIEW_BUILTIN_BUILTINDATA_BAKE_DIFFUSE_LIGHTING:
             result = builtindata.bakeDiffuseLighting;
+            result *= exp2(debugExposure);
             needLinearToSRGB = true;
             break;
         case DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK_0:
 //
 // Debug functions
 //
-void GetGeneratedLightTransportDataDebug(uint paramId, LightTransportData lighttransportdata, inout float3 result, inout bool needLinearToSRGB)
+void GetGeneratedLightTransportDataDebug(uint paramId, LightTransportData lighttransportdata, inout float3 result, inout bool needLinearToSRGB, float debugExposure)
 {
     switch (paramId)
     {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Builtin/BuiltinData.hlsl

     isValidSource = (inBuffer.z != 0.0);
 }
 
-void GetBuiltinDataDebug(uint paramId, BuiltinData builtinData, inout float3 result, inout bool needLinearToSRGB)
+void GetBuiltinDataDebug(uint paramId, BuiltinData builtinData, inout float3 result, inout bool needLinearToSRGB, float debugExposure)
-    GetGeneratedBuiltinDataDebug(paramId, builtinData, result, needLinearToSRGB);
+    GetGeneratedBuiltinDataDebug(paramId, builtinData, result, needLinearToSRGB, debugExposure);
-    case DEBUGVIEW_BUILTIN_BUILTINDATA_BAKE_DIFFUSE_LIGHTING:
-        // TODO: require a remap
-        // TODO: we should not gamma correct, but easier to debug for now without correct high range value
-        result = builtinData.bakeDiffuseLighting; needLinearToSRGB = true;
-        break;
-        // emissiveColor is premultiply by emissive intensity
+        // emissiveColor is premultiplied by emissive intensity
         result = (builtinData.emissiveColor / builtinData.emissiveIntensity); needLinearToSRGB = true;
         break;
     case DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET:
     }
 }
 
-void GetLightTransportDataDebug(uint paramId, LightTransportData lightTransportData, inout float3 result, inout bool needLinearToSRGB)
+void GetLightTransportDataDebug(uint paramId, LightTransportData lightTransportData, inout float3 result, inout bool needLinearToSRGB, float debugExposure)
-    GetGeneratedLightTransportDataDebug(paramId, lightTransportData, result, needLinearToSRGB);
+    GetGeneratedLightTransportDataDebug(paramId, lightTransportData, result, needLinearToSRGB, debugExposure);
 
     switch (paramId)
     {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.cs.hlsl

 //
 // Debug functions
 //
-void GetGeneratedDecalSurfaceDataDebug(uint paramId, DecalSurfaceData decalsurfacedata, inout float3 result, inout bool needLinearToSRGB)
+void GetGeneratedDecalSurfaceDataDebug(uint paramId, DecalSurfaceData decalsurfacedata, inout float3 result, inout bool needLinearToSRGB, float debugExposure)
 {
     switch (paramId)
     {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.cs.hlsl

 //
 // Debug functions
 //
-void GetGeneratedSurfaceDataDebug(uint paramId, SurfaceData surfacedata, inout float3 result, inout bool needLinearToSRGB)
+void GetGeneratedSurfaceDataDebug(uint paramId, SurfaceData surfacedata, inout float3 result, inout bool needLinearToSRGB, float debugExposure)
 {
     switch (paramId)
     {
 //
 // Debug functions
 //
-void GetGeneratedBSDFDataDebug(uint paramId, BSDFData bsdfdata, inout float3 result, inout bool needLinearToSRGB)
+void GetGeneratedBSDFDataDebug(uint paramId, BSDFData bsdfdata, inout float3 result, inout bool needLinearToSRGB, float debugExposure)
 {
     switch (paramId)
     {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

 // Debug method (use to display values)
 //-----------------------------------------------------------------------------
 
-void GetSurfaceDataDebug(uint paramId, SurfaceData surfaceData, inout float3 result, inout bool needLinearToSRGB)
+void GetSurfaceDataDebug(uint paramId, SurfaceData surfaceData, inout float3 result, inout bool needLinearToSRGB, float debugExposure)
-    GetGeneratedSurfaceDataDebug(paramId, surfaceData, result, needLinearToSRGB);
+    GetGeneratedSurfaceDataDebug(paramId, surfaceData, result, needLinearToSRGB, debugExposure);
 
     // Overide debug value output to be more readable
     switch (paramId)
     }
 }
 
-void GetBSDFDataDebug(uint paramId, BSDFData bsdfData, inout float3 result, inout bool needLinearToSRGB)
+void GetBSDFDataDebug(uint paramId, BSDFData bsdfData, inout float3 result, inout bool needLinearToSRGB, float debugExposure)
-    GetGeneratedBSDFDataDebug(paramId, bsdfData, result, needLinearToSRGB);
+    GetGeneratedBSDFDataDebug(paramId, bsdfData, result, needLinearToSRGB, debugExposure);
 
     // Overide debug value output to be more readable
     switch (paramId)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Unlit/Unlit.cs.hlsl

 //
 // Debug functions
 //
-void GetGeneratedSurfaceDataDebug(uint paramId, SurfaceData surfacedata, inout float3 result, inout bool needLinearToSRGB)
+void GetGeneratedSurfaceDataDebug(uint paramId, SurfaceData surfacedata, inout float3 result, inout bool needLinearToSRGB, float debugExposure)
 {
     switch (paramId)
     {
 //
 // Debug functions
 //
-void GetGeneratedBSDFDataDebug(uint paramId, BSDFData bsdfdata, inout float3 result, inout bool needLinearToSRGB)
+void GetGeneratedBSDFDataDebug(uint paramId, BSDFData bsdfdata, inout float3 result, inout bool needLinearToSRGB, float debugExposure)
 {
     switch (paramId)
     {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Unlit/Unlit.hlsl

 // Debug method (use to display values)
 //-----------------------------------------------------------------------------
 
-void GetSurfaceDataDebug(uint paramId, SurfaceData surfaceData, inout float3 result, inout bool needLinearToSRGB)
+void GetSurfaceDataDebug(uint paramId, SurfaceData surfaceData, inout float3 result, inout bool needLinearToSRGB, float debugExposure)
-    GetGeneratedSurfaceDataDebug(paramId, surfaceData, result, needLinearToSRGB);
+    GetGeneratedSurfaceDataDebug(paramId, surfaceData, result, needLinearToSRGB, debugExposure);
-void GetBSDFDataDebug(uint paramId, BSDFData bsdfData, inout float3 result, inout bool needLinearToSRGB)
+void GetBSDFDataDebug(uint paramId, BSDFData bsdfData, inout float3 result, inout bool needLinearToSRGB, float debugExposure)
-    GetGeneratedBSDFDataDebug(paramId, bsdfData, result, needLinearToSRGB);
+    GetGeneratedBSDFDataDebug(paramId, bsdfData, result, needLinearToSRGB, debugExposure);
 }
 
 //-----------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPassForward.hlsl

 
         GetPropertiesDataDebug(_DebugViewMaterial, result, needLinearToSRGB);
         GetVaryingsDataDebug(_DebugViewMaterial, input, result, needLinearToSRGB);
-        GetBuiltinDataDebug(_DebugViewMaterial, builtinData, result, needLinearToSRGB);
-        GetSurfaceDataDebug(_DebugViewMaterial, surfaceData, result, needLinearToSRGB);
-        GetBSDFDataDebug(_DebugViewMaterial, bsdfData, result, needLinearToSRGB);
+        GetBuiltinDataDebug(_DebugViewMaterial, builtinData, result, needLinearToSRGB, _DebugExposure);
+        GetSurfaceDataDebug(_DebugViewMaterial, surfaceData, result, needLinearToSRGB, _DebugExposure);
+        GetBSDFDataDebug(_DebugViewMaterial, bsdfData, result, needLinearToSRGB, _DebugExposure);
 
         // TEMP!
         // For now, the final blit in the backbuffer performs an sRGB write

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPassForwardUnlit.hlsl

 
         GetPropertiesDataDebug(_DebugViewMaterial, result, needLinearToSRGB);
         GetVaryingsDataDebug(_DebugViewMaterial, input, result, needLinearToSRGB);
-        GetBuiltinDataDebug(_DebugViewMaterial, builtinData, result, needLinearToSRGB);
+        GetBuiltinDataDebug(_DebugViewMaterial, builtinData, result, needLinearToSRGB, _DebugExposure);
         GetSurfaceDataDebug(_DebugViewMaterial, surfaceData, result, needLinearToSRGB);
         GetBSDFDataDebug(_DebugViewMaterial, bsdfData, result, needLinearToSRGB);