HDRenderLoop: Premultiply EmissiveIntensity and EmissiveColor + few renaming

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/ClusteredUtils.hlsl

 #ifndef __CLUSTEREDUTILS_H__
 #define __CLUSTEREDUTILS_H__
 
-#ifndef FLT_EPSILON
-    #define FLT_EPSILON     1.192092896e-07f
-#endif
-
 float GetScaleFromBase(float base)
 {
     const float C = (float)(1 << g_iLog2NumClusters);

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Builtin/BuiltinData.hlsl

         result = builtinData.bakeDiffuseLighting;
         break;
     case DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_COLOR:
-        result = builtinData.emissiveColor; needLinearToSRGB = true;
+        // emissiveColor is premultiply by emissive intensity
+        result = (builtinData.emissiveColor / builtinData.emissiveIntensity); needLinearToSRGB = true;
         break;
     case DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_INTENSITY:
         result = builtinData.emissiveIntensity.xxx;

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/Lit.hlsl

 TEXTURE2D(_LtcDisneyDiffuseMatrix);          // RGBA
 TEXTURE2D(_LtcMultiGGXFresnelDisneyDiffuse); // RGB, A unused
 
-static const float3x3 _identity3x3 = {1.0, 0.0, 0.0,
-                                      0.0, 1.0, 0.0,
-                                      0.0, 0.0, 1.0};
-
 //-----------------------------------------------------------------------------
 // Helper functions/variable specific to this material
 //-----------------------------------------------------------------------------
 float3 GetBakedDiffuseLigthing(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData, PreLightData preLightData)
 {
     // Premultiply bake diffuse lighting information with DisneyDiffuse pre-integration
-    return builtinData.bakeDiffuseLighting * preLightData.diffuseFGD * surfaceData.ambientOcclusion * bsdfData.diffuseColor + builtinData.emissiveColor * builtinData.emissiveIntensity;
+    return builtinData.bakeDiffuseLighting * preLightData.diffuseFGD * surfaceData.ambientOcclusion * bsdfData.diffuseColor + builtinData.emissiveColor;
 }
 
 //-----------------------------------------------------------------------------
     // we want to take some of that into account too.
 
     lightTransportData.diffuseColor = bsdfData.diffuseColor + bsdfData.fresnel0 * bsdfData.roughness * 0.5 * surfaceData.metallic;
-    lightTransportData.emissiveColor = builtinData.emissiveColor * builtinData.emissiveIntensity;
+    lightTransportData.emissiveColor = builtinData.emissiveColor;
 
     return lightTransportData;
 }
     // Evaluate the diffuse part.
     {
     #ifdef LIT_DIFFUSE_LAMBERT_BRDF
-        ltcValue = LTCEvaluate(P1, P2, B, _identity3x3);
+        ltcValue = LTCEvaluate(P1, P2, B, k_identity3x3);
     #else
         ltcValue = LTCEvaluate(P1, P2, B, preLightData.ltcXformDisneyDiffuse);
     #endif
     {
     #ifdef LIT_DIFFUSE_LAMBERT_BRDF
         ltcValue = LTCEvaluate(matL, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
-                               _identity3x3);
+                               k_identity3x3);
     #else
         ltcValue = LTCEvaluate(matL, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
                                preLightData.ltcXformDisneyDiffuse);

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/LitData.hlsl

     // Note that data input above can be use to sample into lightmap (like normal)
     builtinData.bakeDiffuseLighting = SampleBakedGI(input.positionWS, surfaceData.normalWS, input.texCoord1, input.texCoord2);
 
+    // Emissive Intensity is only use here, but is part of BuiltinData to enforce UI parameters as we want the users to fill one color and one intensity
+    builtinData.emissiveIntensity = _EmissiveIntensity; // We still store intensity here so we can reuse it with debug code
+
-    builtinData.emissiveColor = SAMPLE_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, input.texCoord0).rgb * _EmissiveColor;
+    builtinData.emissiveColor = SAMPLE_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, input.texCoord0).rgb * _EmissiveColor * builtinData.emissiveIntensity;
-    builtinData.emissiveColor = _EmissiveColor;
+    builtinData.emissiveColor = _EmissiveColor * builtinData.emissiveIntensity;
-    builtinData.emissiveColor = surfaceData.baseColor * SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, input.texCoord0).bbb;
+    builtinData.emissiveColor = surfaceData.baseColor * (SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, input.texCoord0).b * builtinData.emissiveIntensity).xxx;
-
-    builtinData.emissiveIntensity = _EmissiveIntensity;
 
     builtinData.velocity = CalculateVelocity(input.positionCS, input.previousPositionCS);
 
     // Note that data input above can be use to sample into lightmap (like normal)
     builtinData.bakeDiffuseLighting = SampleBakedGI(input.positionWS, surfaceData.normalWS, input.texCoord1, input.texCoord2);
 
+    // Emissive Intensity is only use here, but is part of BuiltinData to enforce UI parameters as we want the users to fill one color and one intensity
+    PROP_DECL(float, emissiveIntensity);
+    PROP_ASSIGN(emissiveIntensity, _EmissiveIntensity, r);
+    PROP_BLEND_SCALAR(emissiveIntensity, weights);
+    builtinData.emissiveIntensity = emissiveIntensity; // We still store intensity here so we can reuse it with debug code
+
     // If we chose an emissive color, we have a dedicated texture for it and don't use MaskMap
     PROP_DECL(float3, emissiveColor);
 #ifdef _EMISSIVE_COLOR
     PROP_ASSIGN_VALUE(emissiveColor, float3(0.0, 0.0, 0.0));
 #endif
     PROP_BLEND_COLOR(emissiveColor, weights);
-    builtinData.emissiveColor = emissiveColor;
-
-    PROP_DECL(float, emissiveIntensity);
-    PROP_ASSIGN(emissiveIntensity, _EmissiveIntensity, r);
-    PROP_BLEND_SCALAR(emissiveIntensity, weights);
-    builtinData.emissiveIntensity = emissiveIntensity;
+    builtinData.emissiveColor = emissiveColor * builtinData.emissiveIntensity;
 
     builtinData.velocity = CalculateVelocity(input.positionCS, input.previousPositionCS);
 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Unlit/Unlit.hlsl

     LighTransportData lightTransportData;
 
     lightTransportData.diffuseColor = float3(0.0, 0.0, 0.0);
-    lightTransportData.emissiveColor = builtinData.emissiveColor * builtinData.emissiveIntensity;
+    lightTransportData.emissiveColor = builtinData.emissiveColor;
 
     return lightTransportData;
 }

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Unlit/UnlitData.hlsl

 
     builtinData.bakeDiffuseLighting = float3(0.0, 0.0, 0.0);
 
+    // Emissive Intensity is only use here, but is part of BuiltinData to enforce UI parameters as we want the users to fill one color and one intensity
+    builtinData.emissiveIntensity = _EmissiveIntensity;
+
-    builtinData.emissiveColor = SAMPLE_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, input.texCoord0).rgb * _EmissiveColor;
+    builtinData.emissiveColor = SAMPLE_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, input.texCoord0).rgb * _EmissiveColor * builtinData.emissiveIntensity;
-    builtinData.emissiveColor = _EmissiveColor;
+    builtinData.emissiveColor = _EmissiveColor * builtinData.emissiveIntensity;
-
-    builtinData.emissiveIntensity = _EmissiveIntensity;
 
     builtinData.velocity = float2(0.0, 0.0);
 

Assets/ScriptableRenderLoop/HDRenderLoop/ShaderPass/ShaderPassForwardUnlit.hlsl

 	BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData);
 		
 	// TODO: we must not access bsdfData here, it break the genericity of the code!
-    return float4(bsdfData.color + builtinData.emissiveColor * builtinData.emissiveIntensity, builtinData.opacity);
+    return float4(bsdfData.color + builtinData.emissiveColor, builtinData.opacity);
 }
 

Assets/ScriptableRenderLoop/ShaderLibrary/AreaLighting.hlsl

 float LineFpo(float tLDDL, float lrcpD, float rcpD)
 {
     // Compute: ((l / d) / (d * d + l * l)) + (1.0 / (d * d)) * atan(l / d).
-    return tLDDL + sq(rcpD) * atan(lrcpD);
+    return tLDDL + Square(rcpD) * atan(lrcpD);
 }
 
 float LineFwt(float tLDDL, float l)
     float d      = length(normal);
     float l1rcpD = l1 * rcp(d);
     float l2rcpD = l2 * rcp(d);
-    float tLDDL1 = l1rcpD * rcp(sq(d) + sq(l1));
-    float tLDDL2 = l2rcpD * rcp(sq(d) + sq(l2));
+    float tLDDL1 = l1rcpD * rcp(Square(d) + Square(l1));
+    float tLDDL2 = l2rcpD * rcp(Square(d) + Square(l2));
     float intWt  = LineFwt(tLDDL2, l2) - LineFwt(tLDDL1, l1);
     float intP0  = LineFpo(tLDDL2, l2rcpD, rcp(d)) - LineFpo(tLDDL1, l1rcpD, rcp(d));
     return intP0 * normal.z + intWt * tangent.z;
     if (P2.z <= 0.0)
     {
         // Convention: 'P2' is above the horizon.
-        swap(P1, P2);
+        Swap(P1, P2);
     }
 
     // Recompute the length and the tangent in the new coordinate system.

Assets/ScriptableRenderLoop/ShaderLibrary/Common.hlsl

 }
 #endif // INTRINSIC_MINMAX3
 
-float sq(float x)
+float Square(float x)
-void swap(inout float a, inout float b)
+void Swap(inout float a, inout float b)
-void swap(inout float2 a, inout float2 b)
+void Swap(inout float2 a, inout float2 b)
-void swap(inout float3 a, inout float3 b)
+void Swap(inout float3 a, inout float3 b)
-void swap(inout float4 a, inout float4 b)
+void Swap(inout float4 a, inout float4 b)
 {
     float4 t = a; a = b; b = t;
 }
 {
     return x * x * (3.0 - (2.0 * x));
 }
+
+const float3x3 k_identity3x3 = {1.0, 0.0, 0.0,
+                                0.0, 1.0, 0.0,
+                                0.0, 0.0, 1.0};
+
+                                0.0, 1.0, 0.0, 0.0,
+                                0.0, 0.0, 1.0, 0.0,
+                                0.0, 0.0, 0.0, 1.0 };
 
 // ----------------------------------------------------------------------------
 // World position reconstruction / transformation

Assets/ScriptableRenderLoop/ShaderLibrary/ImageBasedLighting.hlsl

     // For now disabled
 #if 0
     float m = PerceptualRoughnessToRoughness(perceptualRoughness); // m is the real roughness parameter
-    const float fEps = 1.192092896e-07F;        // smallest such that 1.0+FLT_EPSILON != 1.0  (+1e-4h is NOT good here. is visibly very wrong)
-    float n = (2.0 / max(fEps, m*m)) - 2.0;		// remap to spec power. See eq. 21 in --> https://dl.dropboxusercontent.com/u/55891920/papers/mm_brdf.pdf
+    float n = (2.0 / max(FLT_EPSILON, m*m)) - 2.0;		// remap to spec power. See eq. 21 in --> https://dl.dropboxusercontent.com/u/55891920/papers/mm_brdf.pdf
 
     n /= 4.0;									    // remap from n_dot_h formulatino to n_dot_r. See section "Pre-convolved Cube Maps vs Path Tracers" --> https://s3.amazonaws.com/docs.knaldtech.com/knald/1.0.0/lys_power_drops.html