Independent Coat Normal Map: Input management

6 年前 · 39777104
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/StackLitUI.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/StackLitUI.cs
        protected const string k_CoatIor = "_CoatIor";
        protected const string k_CoatThickness = "_CoatThickness";
        protected const string k_CoatExtinction = "_CoatExtinction";
+        protected const string k_EnableCoatNormalMap = "_EnableCoatNormalMap";
+        protected const string k_CoatNormalMap = "_CoatNormalMap";
+        protected const string k_CoatNormalMapUV = "_CoatNormalMapUV";
+        protected const string k_CoatNormalScale = "_CoatNormalScale";

        // SSS
        protected const string k_EnableSubsurfaceScattering = "_EnableSubsurfaceScattering";
        private Property EnableSSS;
        private Property EnableTransmission;
        private Property EnableCoat;
+        private Property EnableCoatNormalMap;
        private Property EnableAnisotropy;
        private Property EnableDualSpecularLobe;
        private Property EnableIridescence;
            EnableSSS = new Property(this, k_EnableSubsurfaceScattering, "Enable Subsurface Scattering", "Enable Subsurface Scattering", true);
            EnableTransmission = new Property(this, k_EnableTransmission, "Enable Transmission", "Enable Transmission", true);
            EnableCoat = new Property(this, k_EnableCoat, "Enable Coat", "Enable coat layer with true vertical physically based BSDF mixing", true);
+            EnableCoatNormalMap = new Property(this, k_EnableCoatNormalMap, "Enable Coat Normal Map", "Enable separate top coat normal map", true);
            EnableAnisotropy = new Property(this, k_EnableAnisotropy, "Enable Anisotropy", "Enable anisotropy, correct anisotropy for punctual light but very coarse approximated for reflection", true);
            EnableDualSpecularLobe = new Property(this, k_EnableDualSpecularLobe, "Enable Dual Specular Lobe", "Enable a second specular lobe, aim to simulate a mix of a narrow and a haze lobe that better match measured material", true);
            EnableIridescence = new Property(this, k_EnableIridescence, "Enable Iridescence", "Enable physically based iridescence layer", true);
                    EnableDualSpecularLobe,
                    EnableAnisotropy,
                    EnableCoat,
+                    EnableCoatNormalMap,
                    EnableIridescence,
                    EnableSSS,
                    EnableTransmission
                new GroupProperty(this, "_Coat", "Coat", new BaseProperty[]
                {
                    new TextureProperty(this, k_CoatSmoothnessMap, k_CoatSmoothness, "Coat smoothness", "Coat smoothness", false),
+                    new TextureProperty(this, k_CoatNormalMap, k_CoatNormalScale, "Coat Normal Map", "Coat Normal Map", false, false, true,  _ => EnableCoatNormalMap.BoolValue == true),
                    new Property(this, "_CoatIor", "Coat IOR", "Index of refraction", false),
                    new Property(this, "_CoatThickness", "Coat Thickness", "Coat thickness", false),
                    new Property(this, "_CoatExtinction", "Coat Absorption", "Coat absorption tint (the thicker the coat, the more that color is removed)", false),
                (TextureProperty.UVMapping) material.GetFloat(k_AnisotropyMapUV),
                (TextureProperty.UVMapping) material.GetFloat(k_IridescenceThicknessMapUV),
                (TextureProperty.UVMapping) material.GetFloat(k_CoatSmoothnessMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_CoatNormalMapUV),
            };

            // Set keyword for mapping

            bool coatEnabled = material.HasProperty(k_EnableCoat) && material.GetFloat(k_EnableCoat) > 0.0f;
            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_COAT", coatEnabled);
+
+            bool coatNormalMapEnabled = material.HasProperty(k_EnableCoatNormalMap) && material.GetFloat(k_EnableCoatNormalMap) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_COAT_NORMALMAP", coatNormalMapEnabled);

            // TEMP - Remove once dev is finish
            bool debugEnabled = material.HasProperty("_DebugEnable") && material.GetFloat("_DebugEnable") > 0.0f;
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs
            StackLitIridescence             = 1 << 4,
            StackLitSubsurfaceScattering    = 1 << 5,
            StackLitTransmission            = 1 << 6,
+            StackLitCoatNormalMap           = 1 << 7,
        };

        //-----------------------------------------------------------------------------

            [SurfaceDataAttributes(new string[]{"Normal", "Normal View Space"}, true)]
            public Vector3 normalWS;
+
+            [SurfaceDataAttributes(new string[]{"Geometric Normal", "Geometric Normal View Space"}, true)]
+            public Vector3 geomNormalWS;
+
+            [SurfaceDataAttributes(new string[]{"Coat Normal", "Coat Normal View Space"}, true)]
+            public Vector3 coatNormalWS;

            [SurfaceDataAttributes("Smoothness A")]
            public float perceptualSmoothnessA;

            [SurfaceDataAttributes(new string[] { "Normal WS", "Normal View Space" }, true)]
            public Vector3 normalWS;
+
+            [SurfaceDataAttributes(new string[]{"Geometric Normal", "Geometric Normal View Space"}, true)]
+            public Vector3 geomNormalWS;
+
+            [SurfaceDataAttributes(new string[]{"Coat Normal", "Coat Normal View Space"}, true)]
+            public Vector3 coatNormalWS;
+
            public float perceptualRoughnessA;

            // Dual specular lobe
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs.hlsl
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs.hlsl
 #define MATERIALFEATUREFLAGS_STACK_LIT_IRIDESCENCE (16)
 #define MATERIALFEATUREFLAGS_STACK_LIT_SUBSURFACE_SCATTERING (32)
 #define MATERIALFEATUREFLAGS_STACK_LIT_TRANSMISSION (64)
+#define MATERIALFEATUREFLAGS_STACK_LIT_COAT_NORMAL_MAP (128)

 //
 // UnityEngine.Experimental.Rendering.HDPipeline.StackLit+SurfaceData:  static fields
 #define DEBUGVIEW_STACKLIT_SURFACEDATA_IOR (1304)
 #define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL (1305)
 #define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL_VIEW_SPACE (1306)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_A (1307)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_B (1308)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_LOBE_MIXING (1309)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_TANGENT (1310)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_ANISOTROPY (1311)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_IOR (1312)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_THICKNESS (1313)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_ROUGHNESS (1314)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_IOR (1315)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_THICKNESS (1316)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_EXTINCTION_COEFFICIENT (1317)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_DIFFUSION_PROFILE (1318)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_SUBSURFACE_MASK (1319)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_THICKNESS (1320)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_GEOMETRIC_NORMAL (1307)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_GEOMETRIC_NORMAL_VIEW_SPACE (1308)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_NORMAL (1309)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_NORMAL_VIEW_SPACE (1310)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_A (1311)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_B (1312)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_LOBE_MIXING (1313)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_TANGENT (1314)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_ANISOTROPY (1315)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_IOR (1316)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_THICKNESS (1317)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_SMOOTHNESS (1318)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_IOR (1319)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_THICKNESS (1320)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_EXTINCTION_COEFFICIENT (1321)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_DIFFUSION_PROFILE (1322)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SUBSURFACE_MASK (1323)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_THICKNESS (1324)

 //
 // UnityEngine.Experimental.Rendering.HDPipeline.StackLit+BSDFData:  static fields
 #define DEBUGVIEW_STACKLIT_BSDFDATA_AMBIENT_OCCLUSION (1403)
 #define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_WS (1404)
 #define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_VIEW_SPACE (1405)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_A (1406)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_B (1407)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_LOBE_MIX (1408)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_TANGENT_WS (1409)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_BITANGENT_WS (1410)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AT (1411)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AB (1412)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BT (1413)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BB (1414)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ANISOTROPY (1415)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_ROUGHNESS (1416)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_PERCEPTUAL_ROUGHNESS (1417)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_IOR (1418)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_THICKNESS (1419)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_EXTINCTION (1420)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_IRIDESCENCE_IOR (1421)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_IRIDESCENCE_THICKNESS (1422)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_DIFFUSION_PROFILE (1423)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_SUBSURFACE_MASK (1424)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_THICKNESS (1425)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_USE_THICK_OBJECT_MODE (1426)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_TRANSMITTANCE (1427)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_GEOMETRIC_NORMAL (1406)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_GEOMETRIC_NORMAL_VIEW_SPACE (1407)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_NORMAL (1408)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_NORMAL_VIEW_SPACE (1409)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_A (1410)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_B (1411)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_LOBE_MIX (1412)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_TANGENT_WS (1413)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_BITANGENT_WS (1414)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AT (1415)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AB (1416)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BT (1417)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BB (1418)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ANISOTROPY (1419)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_ROUGHNESS (1420)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_PERCEPTUAL_ROUGHNESS (1421)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_IOR (1422)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_THICKNESS (1423)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_EXTINCTION (1424)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_IRIDESCENCE_IOR (1425)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_IRIDESCENCE_THICKNESS (1426)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_DIFFUSION_PROFILE (1427)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_SUBSURFACE_MASK (1428)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_THICKNESS (1429)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_USE_THICK_OBJECT_MODE (1430)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_TRANSMITTANCE (1431)

 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.StackLit+SurfaceData
 // PackingRules = Exact
    float metallic;
    float dielectricIor;
    float3 normalWS;
+    float3 geomNormalWS;
+    float3 coatNormalWS;
    float perceptualSmoothnessA;
    float perceptualSmoothnessB;
    float lobeMix;
    float3 fresnel0;
    float ambientOcclusion;
    float3 normalWS;
+    float3 geomNormalWS;
+    float3 coatNormalWS;
    float perceptualRoughnessA;
    float perceptualRoughnessB;
    float lobeMix;
        case DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL_VIEW_SPACE:
            result = surfacedata.normalWS * 0.5 + 0.5;
            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_GEOMETRIC_NORMAL:
+            result = surfacedata.geomNormalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_GEOMETRIC_NORMAL_VIEW_SPACE:
+            result = surfacedata.geomNormalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_NORMAL:
+            result = surfacedata.coatNormalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_NORMAL_VIEW_SPACE:
+            result = surfacedata.coatNormalWS * 0.5 + 0.5;
+            break;
        case DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_A:
            result = surfacedata.perceptualSmoothnessA.xxx;
            break;
        case DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_THICKNESS:
            result = surfacedata.iridescenceThickness.xxx;
            break;
-        case DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_ROUGHNESS:
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_SMOOTHNESS:
            result = surfacedata.coatPerceptualSmoothness.xxx;
            break;
        case DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_IOR:
            break;
        case DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_VIEW_SPACE:
            result = bsdfdata.normalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_GEOMETRIC_NORMAL:
+            result = bsdfdata.geomNormalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_GEOMETRIC_NORMAL_VIEW_SPACE:
+            result = bsdfdata.geomNormalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_COAT_NORMAL:
+            result = bsdfdata.coatNormalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_COAT_NORMAL_VIEW_SPACE:
+            result = bsdfdata.coatNormalWS * 0.5 + 0.5;
            break;
        case DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_A:
            result = bsdfdata.perceptualRoughnessA.xxx;
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.shader
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.shader
        _CoatThickness("Coat Thickness", Range(0.0, 0.99)) = 0.0
        _CoatExtinction("Coat Extinction Coefficient", Color) = (1,1,1) // in thickness^-1 units

+        [ToggleUI] _EnableCoatNormalMap("Enable Coat Normal Map", Float) = 0.0 // UI only
+        [HideInInspector] _CoatNormalMapShow("Coat NormalMap Show", Float) = 0.0
+        _CoatNormalMap("Coat NormalMap", 2D) = "bump" {}     // Tangent space normal map
+        _CoatNormalMapUV("Coat NormalMapUV", Float) = 0.0
+        _CoatNormalMapUVLocal("Coat NormalMapUV Local", Float) = 0.0
+        _CoatNormalMapObjSpace("Coat NormalMap ObjSpace", Float) = 0.0
+        _CoatNormalScale("Coat NormalMap Scale", Range(0.0, 2.0)) = 1
+
        [HideInInspector] _NormalMapShow("NormalMap Show", Float) = 0.0
        _NormalMap("NormalMap", 2D) = "bump" {}     // Tangent space normal map
        _NormalMapUV("NormalMapUV", Float) = 0.0
    #pragma shader_feature _MATERIAL_FEATURE_DUAL_SPECULAR_LOBE
    #pragma shader_feature _MATERIAL_FEATURE_ANISOTROPY
    #pragma shader_feature _MATERIAL_FEATURE_COAT
+    #pragma shader_feature _MATERIAL_FEATURE_COAT_NORMALMAP
    #pragma shader_feature _MATERIAL_FEATURE_IRIDESCENCE
    #pragma shader_feature _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
    #pragma shader_feature _MATERIAL_FEATURE_TRANSMISSION
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitData.hlsl
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitData.hlsl
    surfaceData.coatExtinction = float3(1.0, 1.0, 1.0);
 #endif

+    float3 coatGradient = float3(0.0, 0.0, 0.0);
+#ifdef _MATERIAL_FEATURE_COAT_NORMALMAP
+    surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_STACK_LIT_COAT_NORMAL_MAP;
+    coatGradient = SAMPLE_TEXTURE2D_NORMAL_SCALE_BIAS(_CoatNormalMap, _CoatNormalScale);
+#endif
+
+
 #ifdef _MATERIAL_FEATURE_IRIDESCENCE
    surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_STACK_LIT_IRIDESCENCE;
    surfaceData.iridescenceIor = _IridescenceIor;
    // Surface Data Part 2 (outsite GetSurfaceData( ) in Lit shader):
    // -------------------------------------------------------------

+    surfaceData.geomNormalWS = input.worldToTangent[2];
+    surfaceData.coatNormalWS = SurfaceGradientResolveNormal(input.worldToTangent[2], coatGradient);

    // TODO: decal etc.

--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitProperties.hlsl
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitProperties.hlsl
 TEXTURE2D(_NormalMap);
 SAMPLER(sampler_NormalMap);

+TEXTURE2D(_CoatNormalMap);
+SAMPLER(sampler_CoatNormalMap);
+
 TEXTURE2D(_SmoothnessBMap);
 SAMPLER(sampler_SmoothnessBMap);

 float _CoatIor;
 float _CoatThickness;
 float3 _CoatExtinction;
+
+float _CoatNormalScale;
+float _CoatNormalMapUV;
+float _CoatNormalMapUVLocal;
+float _CoatNormalMapObjSpace;
+float4 _CoatNormalMap_ST;
+float4 _CoatNormalMap_TexelSize;
+float4 _CoatNormalMap_MipInfo;
+

 float _IridescenceThickness;
 float _IridescenceThicknessUseMap;