Merge pull request #238 from Unity-Technologies/Clean-clear-coat---add-specular-color

HDRenderPipeline: Clear coat model, expose specualr color model

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/LitUI.cs

             public static GUIContent thicknessText = new GUIContent("Thickness", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.");
             public static GUIContent thicknessMapText = new GUIContent("Thickness map", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.");
 
+            // Specular color
+            public static GUIContent specularColorText = new GUIContent("Specular Color", "Specular color (RGB)");
+
             // Emissive
             public static string lightingText = "Inputs Lighting";
             public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
         {
             Standard = 0,
             SubsurfaceScattering = 1,
-            ClearCoat = 2,
-            SpecularColor = 3
+            SpecularColor = 2
         }
 
         protected MaterialProperty UVBase = null;
         protected const string kAnisotropy = "_Anisotropy";
         protected MaterialProperty anisotropyMap = null;
         protected const string kAnisotropyMap = "_AnisotropyMap";
+        protected MaterialProperty specularColor = null;
+        protected const string kSpecularColor = "_SpecularColor";
+        protected MaterialProperty specularColorMap = null;
+        protected const string kSpecularColorMap = "_SpecularColorMap";
 
         protected MaterialProperty UVDetail = null;
         protected const string kUVDetail = "_UVDetail";
             tangentMap = FindProperty(kTangentMap, props);
             anisotropy = FindProperty(kAnisotropy, props);
             anisotropyMap = FindProperty(kAnisotropyMap, props);
+            specularColor = FindProperty(kSpecularColor, props);
+            specularColorMap = FindProperty(kSpecularColorMap, props);
 
             // Details
             UVDetail = FindProperty(kUVDetail, props);
             {
                 ShaderSSSInputGUI(material);
             }
+            else if ((MaterialIDType)materialID.floatValue == MaterialIDType.SpecularColor)
+            {
+                m_MaterialEditor.TexturePropertySingleLine(Styles.specularColorText, specularColorMap, specularColor);
+            }
 
             EditorGUILayout.Space();
             GUILayout.Label("    " + Styles.textureControlText, EditorStyles.label);
             SetKeyword(material, "_ANISOTROPYMAP", material.GetTexture(kAnisotropyMap));
             SetKeyword(material, "_DETAIL_MAP", material.GetTexture(kDetailMap));
             SetKeyword(material, "_SUBSURFACE_RADIUS_MAP", material.GetTexture(kSubsurfaceRadiusMap));
-            SetKeyword(material, "_THICKNESS_MAP", material.GetTexture(kThicknessMap));
+            SetKeyword(material, "_THICKNESSMAP", material.GetTexture(kThicknessMap));
+            SetKeyword(material, "_SPECULARCOLORMAP", material.GetTexture(kSpecularColorMap));
 
             bool needUV2 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV2 && (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV0;
             bool needUV3 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV3 && (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV0;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs

         {
             LitStandard = 0,
             LitSSS = 1,
-            LitClearCoat = 2,
-            LitSpecular = 3,
+            LitSpecular = 2,
+            LitUnused = 3,
             LitAniso = 4 // Should be the last as it is not setup by the users but generated based on anisotropy property
         };
 
             public static uint FEATURE_FLAG_MATERIAL_LIT_STANDARD = 1 << 12;
             public static uint FEATURE_FLAG_MATERIAL_LIT_SSS = 1 << 13;
-            public static uint FEATURE_FLAG_MATERIAL_LIT_CLEAR_COAT = 1 << 14;
-            public static uint FEATURE_FLAG_MATERIAL_LIT_SPECULAR = 1 << 15;
-            public static uint FEATURE_FLAG_MATERIAL_LIT_ANISO = 1 << 16;
+            public static uint FEATURE_FLAG_MATERIAL_LIT_SPECULAR = 1 << 14;
+            public static uint FEATURE_FLAG_MATERIAL_LIT_ANISO = 1 << 15;
         }
 
         //-----------------------------------------------------------------------------
             [SurfaceDataAttributes("Subsurface Profile")]
             public int subsurfaceProfile;
 
-            // Clearcoat
-            [SurfaceDataAttributes("Coat Normal", true)]
-            public Vector3 coatNormalWS;
-            [SurfaceDataAttributes("Coat Smoothness")]
-            public float coatPerceptualSmoothness;
-
             // SpecColor
             [SurfaceDataAttributes("Specular Color", false, true)]
             public Vector3 specularColor;
             public int     subsurfaceProfile;
             public bool    enableTransmission; // Read from the SSS profile
             public Vector3 transmittance;
-
-            // Clearcoat
-            [SurfaceDataAttributes("", true)]
-            public Vector3 coatNormalWS;
-            public float coatRoughness;
 
             // SpecColor
             // fold into fresnel0

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

 //
 #define MATERIALID_LIT_STANDARD (0)
 #define MATERIALID_LIT_SSS (1)
-#define MATERIALID_LIT_CLEAR_COAT (2)
-#define MATERIALID_LIT_SPECULAR (3)
+#define MATERIALID_LIT_SPECULAR (2)
+#define MATERIALID_LIT_UNUSED (3)
 #define MATERIALID_LIT_ANISO (4)
 
 //
 #define FEATURE_FLAG_MATERIAL_LIT_SSS (8192)
-#define FEATURE_FLAG_MATERIAL_LIT_CLEAR_COAT (16384)
-#define FEATURE_FLAG_MATERIAL_LIT_SPECULAR (32768)
-#define FEATURE_FLAG_MATERIAL_LIT_ANISO (65536)
+#define FEATURE_FLAG_MATERIAL_LIT_SPECULAR (16384)
+#define FEATURE_FLAG_MATERIAL_LIT_ANISO (32768)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit.SurfaceData:  static fields
 #define DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_RADIUS (1010)
 #define DEBUGVIEW_LIT_SURFACEDATA_THICKNESS (1011)
 #define DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_PROFILE (1012)
-#define DEBUGVIEW_LIT_SURFACEDATA_COAT_NORMAL_WS (1013)
-#define DEBUGVIEW_LIT_SURFACEDATA_COAT_PERCEPTUAL_SMOOTHNESS (1014)
-#define DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR (1015)
+#define DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR (1013)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit.BSDFData:  static fields
 #define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_PROFILE (1044)
 #define DEBUGVIEW_LIT_BSDFDATA_ENABLE_TRANSMISSION (1045)
 #define DEBUGVIEW_LIT_BSDFDATA_TRANSMITTANCE (1046)
-#define DEBUGVIEW_LIT_BSDFDATA_COAT_NORMAL_WS (1047)
-#define DEBUGVIEW_LIT_BSDFDATA_COAT_ROUGHNESS (1048)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit.GBufferMaterial:  static fields
     float subsurfaceRadius;
     float thickness;
     int subsurfaceProfile;
-    float3 coatNormalWS;
-    float coatPerceptualSmoothness;
     float3 specularColor;
 };
 
     int subsurfaceProfile;
     bool enableTransmission;
     float3 transmittance;
-    float3 coatNormalWS;
-    float coatRoughness;
 };
 
 //
         case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_PROFILE:
             result = GetIndexColor(surfacedata.subsurfaceProfile);
             break;
-        case DEBUGVIEW_LIT_SURFACEDATA_COAT_NORMAL_WS:
-            result = surfacedata.coatNormalWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_COAT_PERCEPTUAL_SMOOTHNESS:
-            result = surfacedata.coatPerceptualSmoothness.xxx;
-            break;
         case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR:
             result = surfacedata.specularColor;
             needLinearToSRGB = true;
             break;
         case DEBUGVIEW_LIT_BSDFDATA_TRANSMITTANCE:
             result = bsdfdata.transmittance;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_COAT_NORMAL_WS:
-            result = bsdfdata.coatNormalWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_COAT_ROUGHNESS:
-            result = bsdfdata.coatRoughness.xxx;
             break;
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 #endif
 }
 
+// We modify diffuseColor here so it affect all the lighting + GI (lightprobe / lightmap) (Need to be done also in GBuffer pass) + transmittance.
+// DiffuseColor will be use during lighting pass. The other contribution will be apply in subsurfacescattering convolution.
-    bsdfData.diffuseColor = performPostScatterTexturing ? float3(1, 1, 1)
-                                                        : sqrt(bsdfData.diffuseColor);
+    bsdfData.diffuseColor = performPostScatterTexturing ? float3(1.0, 1.0, 1.0) : sqrt(bsdfData.diffuseColor);
 }
 
 // Evaluates transmittance for a linear combination of two normalized 2D Gaussians.
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].w,
                                                           _TintColors[bsdfData.subsurfaceProfile].rgb, bsdfData.thickness, bsdfData.subsurfaceRadius);
         }
-    }
-    else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
-    {
-        bsdfData.diffuseColor = surfaceData.baseColor * (1.0 - surfaceData.metallic);
-        bsdfData.fresnel0 = lerp(float3(surfaceData.specular, surfaceData.specular, surfaceData.specular), surfaceData.baseColor, surfaceData.metallic);
-        bsdfData.coatNormalWS = surfaceData.coatNormalWS;
-        bsdfData.coatRoughness = PerceptualSmoothnessToRoughness(surfaceData.coatPerceptualSmoothness);
+
+        ConfigureTexturingForSSS(bsdfData);
     }
     else if (bsdfData.materialId == MATERIALID_LIT_SPECULAR)
     {
 
-#ifdef OUTPUT_SPLIT_LIGHTING
-    ConfigureTexturingForSSS(bsdfData);
-#endif
     ApplyDebugToBSDFData(bsdfData);
 
     return bsdfData;
     else if (surfaceData.materialId == MATERIALID_LIT_SSS)
     {
         outGBuffer2 = float4(surfaceData.subsurfaceRadius, surfaceData.thickness, 0.0, surfaceData.subsurfaceProfile * rcp(SSS_N_PROFILES - 1));
-    }
-    else if (surfaceData.materialId == MATERIALID_LIT_CLEAR_COAT)
-    {
-        // Encode coat normal on 16bit with oct compression
-        float2 octCoatNormalWS = PackNormalOctEncode(surfaceData.coatNormalWS);
-        // TODO: store metal and specular together, specular should be an enum (fixed value)
-        outGBuffer2 = float4(octCoatNormalWS * 0.5 + 0.5, PerceptualSmoothnessToRoughness(surfaceData.coatPerceptualSmoothness), surfaceData.metallic);
     }
     else if (surfaceData.materialId == MATERIALID_LIT_SPECULAR)
     {
 
     int supportsStandard = (featureFlags & (FEATURE_FLAG_MATERIAL_LIT_STANDARD | FEATURE_FLAG_MATERIAL_LIT_ANISO)) != 0;
     int supportsSSS = (featureFlags & (FEATURE_FLAG_MATERIAL_LIT_SSS)) != 0;
-    int supportsClearCoat = (featureFlags & (MATERIALID_LIT_CLEAR_COAT)) != 0;
-    if(supportsStandard + supportsSSS + supportsClearCoat + supportsSpecular > 1)
+    if(supportsStandard + supportsSSS + supportsSpecular > 1)
     {
         bsdfData.materialId = UnpackMaterialId(inGBuffer1.a);   // only fetch materialid if it is not statically known from feature flags
     }
         if(supportsStandard) bsdfData.materialId = MATERIALID_LIT_STANDARD;
         else if(supportsSSS) bsdfData.materialId = MATERIALID_LIT_SSS;
-        else if(supportsClearCoat) bsdfData.materialId = MATERIALID_LIT_CLEAR_COAT;
         else bsdfData.materialId = MATERIALID_LIT_SPECULAR;
     }
 
     else if (supportsSSS && bsdfData.materialId == MATERIALID_LIT_SSS)
     {
         bsdfData.diffuseColor = baseColor;
+
         // TODO take from subsurfaceProfile
         bsdfData.fresnel0 = 0.04; /* 0.028 ? */
         bsdfData.subsurfaceProfile = (SSS_N_PROFILES - 0.9) * inGBuffer2.a; // Need to bias for integers to round trip through the G-buffer
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].w,
                                                           _TintColors[bsdfData.subsurfaceProfile].rgb, bsdfData.thickness, bsdfData.subsurfaceRadius);
         }
-    }
-    else if (supportsClearCoat && bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
-    {
-        float metallic = inGBuffer2.a;
-        // TODO extract spec
-        float specular = 0.04;
-        bsdfData.diffuseColor = baseColor * (1.0 - metallic);
-        bsdfData.fresnel0 = lerp(float3(specular, specular, specular), baseColor, metallic);
-        bsdfData.coatNormalWS = UnpackNormalOctEncode(float2(inGBuffer2.rg * 2.0 - 1.0));
-        bsdfData.coatRoughness = inGBuffer2.b;
+        ConfigureTexturingForSSS(bsdfData);
     }
     else if (supportsSpecular && bsdfData.materialId == MATERIALID_LIT_SPECULAR)
     {
 
     bakeDiffuseLighting = inGBuffer3.rgb;
 
-#ifdef OUTPUT_SPLIT_LIGHTING
-    ConfigureTexturingForSSS(bsdfData);
-#endif
     ApplyDebugToBSDFData(bsdfData);
 }
 
     else if (materialId == MATERIALID_LIT_SSS)
     {
         featureFlags |= FEATURE_FLAG_MATERIAL_LIT_SSS;
-    }
-    else if (materialId == MATERIALID_LIT_CLEAR_COAT)
-    {
-        featureFlags |= FEATURE_FLAG_MATERIAL_LIT_CLEAR_COAT;
     }
     else if (materialId == MATERIALID_LIT_SPECULAR)
     {

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

         _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
 
+        _SpecularColor("SpecularColor", Color) = (1, 1, 1, 1)
+        _SpecularColorMap("SpecularColorMap", 2D) = "white" {}
+
         // Wind
         [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
         _InitialBend("Initial Bend", float) = 1.0
         _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
 
-        //_CoatCoverage("CoatCoverage", Range(0.0, 1.0)) = 0
-        //_CoatCoverageMap("CoatCoverageMapMap", 2D) = "white" {}
-
-        //_CoatRoughness("CoatRoughness", Range(0.0, 1.0)) = 0
-        //_CoatRoughnessMap("CoatRoughnessMap", 2D) = "white" {}
-
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
 
         // Following options are for the GUI inspector and different from the input parameters above
         [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace("NormalMap space", Float) = 0
 
-        [Enum(Standard, 0, Subsurface Scattering, 1, Clear Coat, 2, Specular Color, 3)] _MaterialID("MaterialId", Int) = 0
+        [Enum(Standard, 0, Subsurface Scattering, 1, Specular Color, 2)] _MaterialID("MaterialId", Int) = 0
 
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
     #pragma shader_feature _ANISOTROPYMAP
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _SUBSURFACE_RADIUS_MAP
-    #pragma shader_feature _THICKNESS_MAP
+    #pragma shader_feature _THICKNESSMAP
+    #pragma shader_feature _SPECULARCOLORMAP
     #pragma shader_feature _VERTEX_WIND
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

     surfaceData.subsurfaceRadius = 1.0;
     surfaceData.thickness = 0.0;
     surfaceData.subsurfaceProfile = 0;
-    surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
-    surfaceData.coatPerceptualSmoothness = 1.0;
     surfaceData.specularColor = float3(0.0, 0.0, 0.0);
 
     GetNormalAndTangentWS(input, V, normalTS, surfaceData.normalWS, surfaceData.tangentWS);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitDataInternal.hlsl

     surfaceData.subsurfaceRadius *= SAMPLE_UVMAPPING_TEXTURE2D(_SubsurfaceRadiusMap, sampler_SubsurfaceRadiusMap, layerTexCoord.base).r;
 #endif
 
-#ifdef _THICKNESS_MAP
+#ifdef _THICKNESSMAP
-    surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
-    surfaceData.coatPerceptualSmoothness = 1.0;
-    surfaceData.specularColor = float3(0.0, 0.0, 0.0);
+    surfaceData.specularColor = _SpecularColor.rgb;
+#ifdef _SPECULARCOLORMAP
+    surfaceData.specularColor *= SAMPLE_UVMAPPING_TEXTURE2D(_SpecularColorMap, sampler_SpecularColorMap, layerTexCoord.base).rgb;
+#endif
 
 #else // #if !defined(LAYERED_LIT_SHADER)
 
     surfaceData.thickness = 0.0;
     surfaceData.subsurfaceProfile = 0;
 
-    surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
-    surfaceData.coatPerceptualSmoothness = 0.0;
     surfaceData.specularColor = float3(0.0, 0.0, 0.0);
 
 #endif // #if !defined(LAYERED_LIT_SHADER)

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitProperties.hlsl

 TEXTURE2D(_ThicknessMap);
 SAMPLER2D(sampler_ThicknessMap);
 
-// float _CoatCoverage;
-//TEXTURE2D(_CoatCoverageMap);
-//SAMPLER2D(sampler_CoatCoverageMap);
-
-// float _CoatRoughness;
-//TEXTURE2D(_CoatRoughnessMap);
-//SAMPLER2D(sampler_CoatRoughnessMap);
+float4 _SpecularColor;
+TEXTURE2D(_SpecularColorMap);
+SAMPLER2D(sampler_SpecularColorMap);
 
 float _TexWorldScale;
 float4 _UVMappingMask;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

         _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
 
+        _SpecularColor("SpecularColor", Color) = (1, 1, 1, 1)
+        _SpecularColorMap("SpecularColorMap", 2D) = "white" {}
+
         // Wind
         [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
         _InitialBend("Initial Bend", float) = 1.0
         _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
-
-        //_CoatCoverage("CoatCoverage", Range(0.0, 1.0)) = 0
-        //_CoatCoverageMap("CoatCoverageMapMap", 2D) = "white" {}
-
-        //_CoatRoughness("CoatRoughness", Range(0.0, 1.0)) = 0
-        //_CoatRoughnessMap("CoatRoughnessMap", 2D) = "white" {}
 
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
 
         [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace("NormalMap space", Float) = 0
 
-        [Enum(Standard, 0, Subsurface Scattering, 1, Clear Coat, 2, Specular Color, 3)] _MaterialID("MaterialId", Int) = 0
+        [Enum(Standard, 0, Subsurface Scattering, 1, Specular Color, 2)] _MaterialID("MaterialId", Int) = 0
 
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
     #pragma shader_feature _ANISOTROPYMAP
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _SUBSURFACE_RADIUS_MAP
-    #pragma shader_feature _THICKNESS_MAP
+    #pragma shader_feature _THICKNESSMAP
+    #pragma shader_feature _SPECULARCOLORMAP
     #pragma shader_feature _VERTEX_WIND
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

Assets/ScriptableRenderPipeline/HDRenderPipeline/Utilities.cs

         None      = 0,
         SSS       = 0 + Lit.MaterialId.LitSSS,       // 1
         Standard  = 2 + Lit.MaterialId.LitStandard,  // 2
-        ClearCoat = 1 + Lit.MaterialId.LitClearCoat, // 3
         All       = 255 // 0xff
     }