HDRenderPipeline: Add transmission color

- Add transmission color texture
- Add approximation for energy conservation with fresnel term
- Add unity for thickness

ScriptableRenderPipeline/Core/ShaderLibrary/CommonLighting.hlsl

     return float3x3(localX, localY, localZ);
 }
 
+// ior is a value between 1.0 and 2.5
+float ConvertIORToFresnel0(float ior)
+{
+    return Sqr((ior - 1.0) / (ior + 1.0));
+}
+
 #endif // UNITY_COMMON_LIGHTING_INCLUDED

ScriptableRenderPipeline/Core/ShaderLibrary/Refraction.hlsl

-#ifndef UNITY_REFRACTION_INCLUDED
+#ifndef UNITY_REFRACTION_INCLUDED
 #define UNITY_REFRACTION_INCLUDED
 
 //-----------------------------------------------------------------------------
     float3      rayWS;          // out ray direction
 };
 
-RefractionModelResult RefractionModel_Sphere(float3 V, float3 positionWS, float3 normalWS, float ior, float thickness)
+RefractionModelResult RefractionModelSphere(float3 V, float3 positionWS, float3 normalWS, float ior, float thickness)
 {
     // Sphere shape model:
     //  We approximate locally the shape of the object as sphere, that is tangent to the shape.
     return result;
 }
 
-RefractionModelResult RefractionModel_Plane(float3 V, float3 positionWS, float3 normalWS, float ior, float thickness)
+RefractionModelResult RefractionModelPlane(float3 V, float3 positionWS, float3 normalWS, float ior, float thickness)
 {
     // Plane shape model:
     //  We approximate locally the shape of the object as a plane with normal {normalWS} at {positionWS}
 
     return result;
 }
-#endif
+#endif

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 # include "../../../Core/ShaderLibrary/Refraction.hlsl"
 
 # if defined(_REFRACTION_PLANE)
-#  define REFRACTION_MODEL(V, posInputs, bsdfData) RefractionModel_Plane(V, posInputs.positionWS, bsdfData.normalWS, bsdfData.ior, bsdfData.thickness)
+#  define REFRACTION_MODEL(V, posInputs, bsdfData) RefractionModelPlane(V, posInputs.positionWS, bsdfData.normalWS, bsdfData.ior, bsdfData.thickness)
-#  define REFRACTION_MODEL(V, posInputs, bsdfData) RefractionModel_Sphere(V, posInputs.positionWS, bsdfData.normalWS, bsdfData.ior, bsdfData.thickness)
+#  define REFRACTION_MODEL(V, posInputs, bsdfData) RefractionModelSphere(V, posInputs.positionWS, bsdfData.normalWS, bsdfData.ior, bsdfData.thickness)
 # endif
 #endif
 
     bsdfData.coatCoverage = coatCoverage;
 }
 
-void FillMaterialIdTransparencyData(float ior, float3 transmittanceColor, float atDistance, float thickness, float transmittanceMask, inout BSDFData bsdfData)
+void FillMaterialIdTransparencyData(float3 baseColor, float metallic, float ior, float3 transmittanceColor, float atDistance, float thickness, float transmittanceMask, inout BSDFData bsdfData)
+
+    // IOR define the fresnel0 value, so update it also for consistency (and even if not physical we still need to take into account any metal mask)
+    bsdfData.fresnel0 = lerp(ConvertIORToFresnel0(ior).xxx, baseColor, metallic);
+
     // Absorption coefficient from Disney: http://blog.selfshadow.com/publications/s2015-shading-course/burley/s2015_pbs_disney_bsdf_notes.pdf
     bsdfData.absorptionCoefficient = -log(transmittanceColor + 0.00001) / max(atDistance, 0.000001);
     bsdfData.transmittanceMask = transmittanceMask;
 #if HAS_REFRACTION
     // Note: Will override thickness of SSS's property set
     FillMaterialIdTransparencyData(
-        surfaceData.ior, surfaceData.transmittanceColor, surfaceData.atDistance, surfaceData.thickness, surfaceData.transmittanceMask,
+        surfaceData.baseColor, surfaceData.metallic, surfaceData.ior, surfaceData.transmittanceColor, surfaceData.atDistance, surfaceData.thickness, surfaceData.transmittanceMask,
         bsdfData);
 #endif
 
     lighting.specularTransmitted *= preLightData.transmissionTransmittance;
 
     float weight = 1.0;
-    UpdateLightingHierarchyWeights(hierarchyWeight, weight); // Shouldn't be needed, but safer in case we decide to change hiearchy priority
-    lighting.specularTransmitted *= weight;
+    UpdateLightingHierarchyWeights(hierarchyWeight, weight); // Shouldn't be needed, but safer in case we decide to change hierarchy priority
+    // We use specularFGD as an approximation of the fresnel effect (that also handle smoothness), so take the remaining for transmission
+    lighting.specularTransmitted *= (1.0 - preLightData.specularFGD) * weight;
 #else
     // No refraction, no need to go further
     hierarchyWeight = 1.0;
 #endif
 
     UpdateLightingHierarchyWeights(hierarchyWeight, weight);
+    envLighting *= weight;
-        lighting.specularReflected = envLighting * preLightData.specularFGD * weight;
+        lighting.specularReflected = envLighting * preLightData.specularFGD;
-        lighting.specularTransmitted = envLighting * preLightData.transmissionTransmittance * weight;
+        // specular transmisted lighting is the remaining of the reflection (let's use this approx)
+        lighting.specularTransmitted = (1.0 - preLightData.specularFGD) * envLighting * preLightData.transmissionTransmittance;
 
     return lighting;
 }

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

         _IOR("Indice Of Refraction", Range(1.0, 2.5)) = 1.0
         _ThicknessMultiplier("Thickness Multiplier", Float) = 1.0
         _TransmittanceColor("Transmittance Color", Color) = (1.0, 1.0, 1.0)
+        _TransmittanceColorMap("TransmittanceColorMap", 2D) = "white" {}
         _ATDistance("Transmittance Absorption Distance", Float) = 1.0
         [ToggleOff] _PreRefractionPass("PreRefractionPass", Float) = 0.0
 
     #pragma shader_feature _SUBSURFACE_RADIUS_MAP
     #pragma shader_feature _THICKNESSMAP
     #pragma shader_feature _SPECULARCOLORMAP
+    #pragma shader_feature _TRANSMITTANCECOLORMAP    
 
     // Keyword for transparent
     #pragma shader_feature _SURFACE_TYPE_TRANSPARENT

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitDataIndividualLayer.hlsl

 #if HAS_REFRACTION
     surfaceData.ior = _IOR;
     surfaceData.transmittanceColor = _TransmittanceColor;
+    #ifdef _TRANSMITTANCECOLORMAP
+    surfaceData.transmittanceColor *= SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_TransmittanceColorMap), ADD_ZERO_IDX(sampler_TransmittanceColorMap), ADD_IDX(layerTexCoord.base)).rgb;
+    #endif
+
     surfaceData.atDistance = _ATDistance;
     // Thickness already defined with SSS (from both thickness and thicknessMap)
     surfaceData.thickness *= _ThicknessMultiplier;

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitProperties.hlsl

 TEXTURE2D(_SpecularColorMap);
 SAMPLER2D(sampler_SpecularColorMap);
 
+TEXTURE2D(_TransmittanceColorMap);
+SAMPLER2D(sampler_TransmittanceColorMap);
+
 #else
 
 // Set of users variables

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

         _IOR("Indice Of Refraction", Range(1.0, 2.5)) = 1.0
         _ThicknessMultiplier("Thickness Multiplier", Float) = 1.0
         _TransmittanceColor("Transmittance Color", Color) = (1.0, 1.0, 1.0)
+        _TransmittanceColorMap("TransmittanceColorMap", 2D) = "white" {}
         _ATDistance("Transmittance Absorption Distance", Float) = 1.0
         [ToggleOff] _PreRefractionPass("PreRefractionPass", Float) = 0.0
 
     #pragma shader_feature _SUBSURFACE_RADIUS_MAP
     #pragma shader_feature _THICKNESSMAP
     #pragma shader_feature _SPECULARCOLORMAP
+    #pragma shader_feature _TRANSMITTANCECOLORMAP
 
     // Keyword for transparent
     #pragma shader_feature _SURFACE_TYPE_TRANSPARENT