HDRP: StackLit Triplanar - handling of local and world correctly per attribute

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/BaseMaterialUI.cs

                 }
             }
         }
-         
+
         public class Property : BaseProperty
         {
             public string PropertyName;
             {
                 get { return m_MaterialProperty != null; }
             }
-        
+
             public float FloatValue
             {
                 get { return m_MaterialProperty.floatValue; }
                 A,
             }
 
+            public enum PlanarSpace
+            {
+                World,
+                Local
+            }
+
             public enum UVMapping
             {
                 UV0,
 
             public ComboProperty m_UvSetProperty;
 
-            public Property m_LocalOrWorldProperty;
+            public ComboProperty m_LocalOrWorldProperty;
 
             public Property m_ChannelProperty;
 
                 m_TextureProperty = new TextureOneLineProperty(parent, propertyName, useConstantAsTint ? constantPropertyName : string.Empty, guiText, toolTip, isMandatory);
 
                 m_UvSetProperty = new ComboProperty(parent, propertyName + "UV", "UV Mapping", Enum.GetNames(typeof(UVMapping)), false);
-                m_LocalOrWorldProperty = new Property(parent, propertyName + "LocalOrWorld", "Local Space", "Whether Planar or Triplanar is using Local or World space.", false);
+                m_LocalOrWorldProperty = new ComboProperty(parent, propertyName + "UVLocal", "Local or world", Enum.GetNames(typeof(PlanarSpace)), false);
 
                 m_ChannelProperty = new ComboProperty(parent, propertyName + "Channel", "Channel", Enum.GetNames(typeof(Channel)), false);
 
                         if (m_TextureProperty.TextureValue != null)
                         {
                             m_UvSetProperty.OnGUI();
-                            m_LocalOrWorldProperty.OnGUI();
-                            m_LocalOrWorldProperty.OnGUI();
+                            if (m_UvSetProperty.FloatValue >= (float)UVMapping.PlanarXY)
+                            {
+                                m_LocalOrWorldProperty.OnGUI();
+                            }
 
                             if (m_RemapProperty.IsValid)
                             {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/StackLitUI.cs

         //protected const string kRefractionModel = "_RefractionModel";
         //protected MaterialProperty refractionSSRayModel = null;
         //protected const string kRefractionSSRayModel = "_RefractionSSRayModel";
-
-        protected MaterialProperty useLocalPlanarMapping = null;
-        protected const string k_UseLocalPlanarMapping = "_UseLocalPlanarMapping";
         #endregion
 
         // Add the properties into an array.
         protected override void FindMaterialProperties(MaterialProperty[] props)
         {
             //base.FindMaterialProperties(props);
-            useLocalPlanarMapping = FindProperty(k_UseLocalPlanarMapping, props);
             _materialProperties.OnFindProperty(props);
         }
 
-            m_MaterialEditor.ShaderProperty(useLocalPlanarMapping, StylesStackLit.useLocalPlanarMapping);
             _baseMaterialProperties.OnGUI();
         }
 
                 requireTriplanar = requireTriplanar || uvIndices[i] == TextureProperty.UVMapping.Triplanar;
             }
 
-            CoreUtils.SetKeyword(material, "_USE_UV2", requireUv2);
-            CoreUtils.SetKeyword(material, "_USE_UV3", requireUv3);
+            //CoreUtils.SetKeyword(material, "_USE_UV2", requireUv2);
+            //CoreUtils.SetKeyword(material, "_USE_UV3", requireUv3);
             CoreUtils.SetKeyword(material, "_USE_TRIPLANAR", requireTriplanar);
         }
     }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.shader

         _BaseColorMap("BaseColor Map", 2D) = "white" {}
         [HideInInspector] _BaseColorMapShow("BaseColor Map Show", Float) = 0
         _BaseColorMapUV("BaseColor Map UV", Float) = 0.0
+        _BaseColorMapUVLocal("BaseColorMap UV Local", Float) = 0.0
 
         [HideInInspector] _MetallicMapShow("Metallic Map Show", Float) = 0
         _Metallic("Metallic", Range(0.0, 1.0)) = 0
+        _MetallicMapUVLocal("Metallic Map UV Local", Float) = 0.0
         _MetallicMapChannel("Metallic Map Channel", Float) = 0.0
         _MetallicMapChannelMask("Metallic Map Channel Mask", Vector) = (1, 0, 0, 0)
         _MetallicRemap("Metallic Remap", Vector) = (0, 1, 0, 0)
         _SmoothnessAMap("SmoothnessA Map", 2D) = "white" {}
         _SmoothnessAUseMap("SmoothnessA Use Map", Float) = 0
         _SmoothnessAMapUV("SmoothnessA Map UV", Float) = 0.0
+        _SmoothnessAMapUVLocal("_SmoothnessA Map UV Local", Float) = 0.0
         _SmoothnessAMapChannel("SmoothnessA Map Channel", Float) = 0.0
         _SmoothnessAMapChannelMask("SmoothnessA Map Channel Mask", Vector) = (1, 0, 0, 0)
         _SmoothnessARemap("SmoothnessA Remap", Vector)  = (0, 1, 0, 0)
         _SmoothnessBMap("SmoothnessB Map", 2D) = "white" {}
         _SmoothnessBUseMap("SmoothnessB Use Map", Float) = 0
         _SmoothnessBMapUV("SmoothnessB Map UV", Float) = 0.0
+        _SmoothnessAMapUVLocal("_SmoothnessB Map UV Local", Float) = 0.0
         _SmoothnessBMapChannel("SmoothnessB Map Channel", Float) = 0.0
         _SmoothnessBMapChannelMask("SmoothnessB Map Channel Mask", Vector) = (1, 0, 0, 0)
         _SmoothnessBRemap("SmoothnessB Remap", Vector) = (0, 1, 0, 0)
         _EmissiveColor("Emissive Color", Color) = (1, 1, 1)
         _EmissiveColorMap("Emissive Color Map", 2D) = "white" {}
         _EmissiveColorMapUV("Emissive Color Map UV", Range(0.0, 1.0)) = 0
+        _EmissiveColorMapUVLocal("Emissive Color Map UV Local", Float) = 0.0
         _EmissiveIntensity("Emissive Intensity", Float) = 0
         [ToggleUI] _AlbedoAffectEmissive("Albedo Affect Emissive", Float) = 0.0
 
         [ToggleUI]  _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
         _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
         _TransparentSortPriority("_TransparentSortPriority", Float) = 0
-
-        // global control
-        [ToggleUI] _UseLocalPlanarMapping("Use Local Planar Mapping", Float) = 0.0
 
         // Stencil state
         [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilLightingUsage.RegularLighting  (fixed at compile time)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitData.hlsl

 #define TEXCOORD_INDEX_TRIPLANAR    (7)
 #define TEXCOORD_INDEX_COUNT        (TEXCOORD_INDEX_TRIPLANAR) // Triplanar is not consider as having mapping
 
+struct TextureUVMapping
+{
+    float2 texcoords[TEXCOORD_INDEX_COUNT][2];
+#ifdef _USE_TRIPLANAR
+    float3 triplanarWeights[2];
+#endif
+
+#ifdef SURFACE_GRADIENT
+   // float3 vertexTangentWS[4];
+   // float3 vertexBitangentWS[4];
+#endif
+};
+
+float4 SampleTexture2DPlanar(TEXTURE2D_ARGS(textureName, samplerName), float textureNameUV, float textureNameUVLocal, float4 textureNameST, TextureUVMapping uvMapping)
+{
+    return SAMPLE_TEXTURE2D(textureName, samplerName, (uvMapping.texcoords[textureNameUV][textureNameUVLocal] * textureNameST.xy + textureNameST.zw));
+}
+
-float4 SampleTexture2DTriplanar(TEXTURE2D_ARGS(textureName, samplerName), float textureNameUV, float4 textureNameST, float2 texcoords[TEXCOORD_INDEX_COUNT], float3 triplanarWeights)
+float4 SampleTexture2DTriplanar(TEXTURE2D_ARGS(textureName, samplerName), float textureNameUV, float textureNameUVLocal, float4 textureNameST, TextureUVMapping uvMapping)
-        if (triplanarWeights.x > 0.0)
-            val += triplanarWeights.x * SAMPLE_TEXTURE2D(textureName, samplerName, (texcoords[TEXCOORD_INDEX_PLANAR_YZ] * textureNameST.xy + textureNameST.zw));
-        if (triplanarWeights.y > 0.0)
-            val += triplanarWeights.y * SAMPLE_TEXTURE2D(textureName, samplerName, (texcoords[TEXCOORD_INDEX_PLANAR_ZX] * textureNameST.xy + textureNameST.zw));
-        if (triplanarWeights.z > 0.0)
-            val += triplanarWeights.z * SAMPLE_TEXTURE2D(textureName, samplerName, (texcoords[TEXCOORD_INDEX_PLANAR_XY] * textureNameST.xy + textureNameST.zw));
+        if (uvMapping.triplanarWeights[textureNameUVLocal].x > 0.0)
+            val += uvMapping.triplanarWeights[textureNameUVLocal].x * SAMPLE_TEXTURE2D(textureName, samplerName, (uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_YZ][textureNameUVLocal] * textureNameST.xy + textureNameST.zw));
+        if (uvMapping.triplanarWeights[textureNameUVLocal].y > 0.0)
+            val += uvMapping.triplanarWeights[textureNameUVLocal].y * SAMPLE_TEXTURE2D(textureName, samplerName, (uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_ZX][textureNameUVLocal] * textureNameST.xy + textureNameST.zw));
+        if (uvMapping.triplanarWeights[textureNameUVLocal].z > 0.0)
+            val += uvMapping.triplanarWeights[textureNameUVLocal].z * SAMPLE_TEXTURE2D(textureName, samplerName, (uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_XY][textureNameUVLocal] * textureNameST.xy + textureNameST.zw));
-        return SAMPLE_TEXTURE2D(textureName, samplerName, (texcoords[textureNameUV] * textureNameST.xy + textureNameST.zw));
+        return SampleTexture2DPlanar(TEXTURE2D_PARAM(textureName, samplerName), textureNameUV, textureNameUVLocal, textureNameST, uvMapping);
-#define SAMPLE_TEXTURE2D_SCALE_BIAS(name) SampleTexture2DTriplanar(name, sampler##name, name##UV, name##_ST, texcoords, triplanarWeights)
-
+#define SAMPLE_TEXTURE2D_SCALE_BIAS(name) SampleTexture2DTriplanar(name, sampler##name, name##UV, name##UVLocal, name##_ST, uvMapping)
-#define SAMPLE_TEXTURE2D_SCALE_BIAS(name) SAMPLE_TEXTURE2D(name, sampler##name, (texcoords[name##UV] * name##_ST.xy + name##_ST.zw))
+#define SAMPLE_TEXTURE2D_SCALE_BIAS(name) SampleTexture2DPlanar(name, sampler##name, name##UV, name##UVLocal, name##_ST, uvMapping)
-void InitializeMappingData(FragInputs input, out float2 texcoords[TEXCOORD_INDEX_COUNT], out float3 triplanarWeights)
+void InitializeMappingData(FragInputs input, out TextureUVMapping uvMapping)
-    // If we use local planar mapping, convert to local space
-    position = _UseLocalPlanarMapping ? TransformWorldToObject(position) : position;
-    // planar/triplanar
+
+    // Build the texcoords array.
+    uvMapping.texcoords[TEXCOORD_INDEX_UV0][0] = uvMapping.texcoords[TEXCOORD_INDEX_UV0][1] = input.texCoord0.xy;
+    uvMapping.texcoords[TEXCOORD_INDEX_UV1][0] = uvMapping.texcoords[TEXCOORD_INDEX_UV1][1] = input.texCoord1.xy;
+    uvMapping.texcoords[TEXCOORD_INDEX_UV2][0] = uvMapping.texcoords[TEXCOORD_INDEX_UV2][1] = input.texCoord2.xy;
+    uvMapping.texcoords[TEXCOORD_INDEX_UV3][0] = uvMapping.texcoords[TEXCOORD_INDEX_UV3][1] = input.texCoord3.xy;
+
+    // planar/triplanar
+    uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_XY][0] = uvXY;
+    uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_YZ][0] = uvZY;
+    uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_ZX][0] = uvXZ;
+
+    // If we use local planar mapping, convert to local space
+    position = TransformWorldToObject(position);
+    GetTriplanarCoordinate(position, uvXZ, uvXY, uvZY);
+    uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_XY][1] = uvXY;
+    uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_YZ][1] = uvZY;
+    uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_ZX][1] = uvXZ;
-    float3 vertexNormal = input.worldToTangent[2].xyz; // normal in WS
-    vertexNormal = _UseLocalPlanarMapping ? TransformWorldToObjectDir(vertexNormal) : vertexNormal;
-    triplanarWeights = ComputeTriplanarWeights(vertexNormal);
-#else
-    triplanarWeights = float3(0.0, 0.0, 0.0);
+    float3 vertexNormal = input.worldToTangent[2].xyz;
+    uvMapping.triplanarWeights[0] = ComputeTriplanarWeights(vertexNormal);
+    // If we use local planar mapping, convert to local space
+    vertexNormal = TransformWorldToObjectDir(vertexNormal);
+    uvMapping.triplanarWeights[1] = ComputeTriplanarWeights(vertexNormal);
-    // Build the texcoords array.
-    texcoords[TEXCOORD_INDEX_UV0] = input.texCoord0;
-    texcoords[TEXCOORD_INDEX_UV1] = input.texCoord1;
-#ifdef _USE_UV2
-    texcoords[TEXCOORD_INDEX_UV2] = input.texCoord2;
-#else
-    texcoords[TEXCOORD_INDEX_UV2] = float2(0.0, 0.0);
-#endif
-#ifdef _USE_UV3
-    texcoords[TEXCOORD_INDEX_UV3] = input.texCoord3;
-#else
-    texcoords[TEXCOORD_INDEX_UV3] = float2(0.0, 0.0);
-#endif
-    texcoords[TEXCOORD_INDEX_PLANAR_XY] = uvXY;
-    texcoords[TEXCOORD_INDEX_PLANAR_YZ] = uvZY;
-    texcoords[TEXCOORD_INDEX_PLANAR_ZX] = uvXZ;
+    // Normal mapping with surface gradient
+#ifdef SURFACE_GRADIENT
+    float3 vertexNormalWS = input.worldToTangent[2];
+
+    uvMapping.vertexTangentWS[0] = input.worldToTangent[0];
+    uvMapping.vertexBitangentWS[0] = input.worldToTangent[1];
+
+    float3 dPdx = ddx_fine(input.positionWS);
+    float3 dPdy = ddy_fine(input.positionWS);
+
+    float3 sigmaX = dPdx - dot(dPdx, vertexNormalWS) * vertexNormalWS;
+    float3 sigmaY = dPdy - dot(dPdy, vertexNormalWS) * vertexNormalWS;
+    //float flipSign = dot(sigmaY, cross(vertexNormalWS, sigmaX) ) ? -1.0 : 1.0;
+    float flipSign = dot(dPdy, cross(vertexNormalWS, dPdx)) < 0.0 ? -1.0 : 1.0; // gives same as the commented out line above
+
+    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord1, uvMapping.vertexTangentWS[1], uvMapping.vertexBitangentWS[1]);
+    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord2, uvMapping.vertexTangentWS[2], uvMapping.vertexBitangentWS[2]);
+    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord3, uvMapping.vertexTangentWS[3], uvMapping.vertexBitangentWS[3]);
+#endif // SURFACE_GRADIENT
 }
 
 //-----------------------------------------------------------------------------
 {
     ApplyDoubleSidedFlipOrMirror(input); // Apply double sided flip on the vertex normal.
 
-    float2 texcoords[TEXCOORD_INDEX_COUNT];
-    float3 triplanarWeights;
-    InitializeMappingData(input, texcoords, triplanarWeights);
+    TextureUVMapping uvMapping;
+    InitializeMappingData(input, uvMapping);
 
     // -------------------------------------------------------------
     // Surface Data:
 
     //surfaceData.normalWS = float3(0.0, 0.0, 0.0);
 
-    normalTS = GetNormalTS(input, texcoords[_NormalMapUV], detailNormalTS, detailMask);
+    normalTS = float3(0, 0, 1); // GetNormalTS(input, texcoords[_NormalMapUV], detailNormalTS, detailMask);
     //TODO: bentNormalTS
 
     surfaceData.perceptualSmoothnessA = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_SmoothnessAMap), _SmoothnessAMapChannelMask);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitProperties.hlsl

 float4 _BaseColorMap_TexelSize;
 float4 _BaseColorMap_MipInfo;
 float _BaseColorMapUV;
+float _BaseColorMapUVLocal;
+float _MetallicMapUVLocal;
 float4 _MetallicMap_ST;
 float4 _MetallicMap_TexelSize;
 float4 _MetallicMap_MipInfo;
 float _SmoothnessA;
 float _SmoothnessAUseMap;
 float _SmoothnessAMapUV;
+float _SmoothnessAMapUVLocal;
 float4 _SmoothnessAMap_ST;
 float4 _SmoothnessAMap_TexelSize;
 float4 _SmoothnessAMap_MipInfo;
 float _SmoothnessBUseMap;
 float _SmoothnessBMapUV;
+float _SmoothnessBMapUVLocal;
 float4 _SmoothnessBMap_ST;
 float4 _SmoothnessBMap_TexelSize;
 float4 _SmoothnessBMap_MipInfo;
 float4 _EmissiveColorMap_TexelSize;
 float4 _EmissiveColorMap_MipInfo;
 float _EmissiveColorMapUV;
+float _EmissiveColorMapUVLocal;
 float _EmissiveIntensity;
 float _AlbedoAffectEmissive;
 
 float _DistortionBlurScale;
 float _DistortionBlurRemapMin;
 float _DistortionBlurRemapMax;
-
-float _UseLocalPlanarMapping;
 
 // Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
 // value that exist to identify if the GI emission need to be enabled.