HDRenderPipeline: Also split tangent

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

         void RenderDebugViewMaterial(CullResults cull, HDCamera hdCamera, ScriptableRenderContext renderContext)
         {
             using (new Utilities.ProfilingSample("DisplayDebug ViewMaterial", renderContext))
-            // Render Opaque forward
+                // Render Opaque forward
-            }
-            // Render GBuffer opaque
-            if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
-            {
-                Utilities.SetupMaterialHDCamera(hdCamera, m_DebugViewMaterialGBuffer);
+                // Render GBuffer opaque
+                if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
+                {
+                    Utilities.SetupMaterialHDCamera(hdCamera, m_DebugViewMaterialGBuffer);
-                // m_gbufferManager.BindBuffers(m_DebugViewMaterialGBuffer);
-                // TODO: Bind depth textures
-                var cmd = new CommandBuffer { name = "DebugViewMaterialGBuffer" };
-                cmd.Blit(null, m_CameraColorBufferRT, m_DebugViewMaterialGBuffer, 0);
-                renderContext.ExecuteCommandBuffer(cmd);
-                cmd.Dispose();
-            }
+                    // m_gbufferManager.BindBuffers(m_DebugViewMaterialGBuffer);
+                    // TODO: Bind depth textures
+                    var cmd = new CommandBuffer { name = "DebugViewMaterialGBuffer" };
+                    cmd.Blit(null, m_CameraColorBufferRT, m_DebugViewMaterialGBuffer, 0);
+                    renderContext.ExecuteCommandBuffer(cmd);
+                    cmd.Dispose();
+                }
-            // Render forward transparent
-            {
-                RenderTransparentRenderList(cull, hdCamera.camera, renderContext, "ForwardDisplayDebug", Utilities.kRendererConfigurationBakedLighting);
+                // Render forward transparent
+                {
+                    RenderTransparentRenderList(cull, hdCamera.camera, renderContext, "ForwardDisplayDebug", Utilities.kRendererConfigurationBakedLighting);
+                }
             }
 
             // Last blit

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

 
             public static GUIContent normalMapSpaceText = new GUIContent("Normal/Tangent Map space", "");
             public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map (BC7/BC5/DXT5(nm))");
+            public static GUIContent normalMapOSText = new GUIContent("Normal Map OS", "Normal Map (BC7/DXT1/RGB)");
             public static GUIContent specularOcclusionMapText = new GUIContent("Specular Occlusion Map (RGBA)", "Specular Occlusion Map");
             public static GUIContent horizonFadeText = new GUIContent("Horizon Fade (Spec occlusion)", "horizon fade is use to control specular occlusion");
 
 
-            public static GUIContent tangentMapText = new GUIContent("Tangent Map", "Tangent Map (BC5) - DXT5 for test");
+            public static GUIContent tangentMapText = new GUIContent("Tangent Map", "Tangent Map (BC7/BC5/DXT5(nm))");
+            public static GUIContent tangentMapOSText = new GUIContent("Tangent Map OS", "Tangent Map (BC7/DXT1/RGB)");
             public static GUIContent anisotropyText = new GUIContent("Anisotropy", "Anisotropy scale factor");
             public static GUIContent anisotropyMapText = new GUIContent("Anisotropy Map (B)", "Anisotropy");
 
         protected const string kHeightCenter = "_HeightCenter";
         protected MaterialProperty tangentMap = null;
         protected const string kTangentMap = "_TangentMap";
+        protected MaterialProperty tangentMapOS = null;
+        protected const string kTangentMapOS = "_TangentMapOS";
         protected MaterialProperty anisotropy = null;
         protected const string kAnisotropy = "_Anisotropy";
         protected MaterialProperty anisotropyMap = null;
             heightAmplitude = FindProperty(kHeightAmplitude, props);
             heightCenter = FindProperty(kHeightCenter, props);
             tangentMap = FindProperty(kTangentMap, props);
+            tangentMapOS = FindProperty(kTangentMapOS, props);
             anisotropy = FindProperty(kAnisotropy, props);
             anisotropyMap = FindProperty(kAnisotropyMap, props);
             specularColor = FindProperty(kSpecularColor, props);
 
         protected void ShaderStandardInputGUI()
         {
-            m_MaterialEditor.TexturePropertySingleLine(Styles.tangentMapText, tangentMap);
+            if ((NormalMapSpace)normalMapSpace.floatValue == NormalMapSpace.TangentSpace)
+            {
+                m_MaterialEditor.TexturePropertySingleLine(Styles.tangentMapText, tangentMap);
+            }
+            else
+            {
+                m_MaterialEditor.TexturePropertySingleLine(Styles.tangentMapOSText, tangentMapOS);
+            }
             m_MaterialEditor.ShaderProperty(anisotropy, Styles.anisotropyText);
             m_MaterialEditor.TexturePropertySingleLine(Styles.anisotropyMapText, anisotropyMap);
         }
             else
             {
                 // No scaling in object space
-                m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMapOS);
+                m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapOSText, normalMapOS);
             }
 
             m_MaterialEditor.TexturePropertySingleLine(Styles.heightMapText, heightMap);
             {
                 // With details map, we always use a normal map and Unity provide a default (0, 0, 1) normal map for it
                 SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMap) || material.GetTexture(kDetailMap));
+                SetKeyword(material, "_TANGENTMAP", material.GetTexture(kTangentMap));
+                SetKeyword(material, "_TANGENTMAP", material.GetTexture(kTangentMapOS));
-            SetKeyword(material, "_TANGENTMAP", material.GetTexture(kTangentMap));
             SetKeyword(material, "_ANISOTROPYMAP", material.GetTexture(kAnisotropyMap));
             SetKeyword(material, "_DETAIL_MAP", material.GetTexture(kDetailMap));
             SetKeyword(material, "_SUBSURFACE_RADIUS_MAP", material.GetTexture(kSubsurfaceRadiusMap));

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

         _DetailSmoothnessScale("_DetailSmoothnessScale", Range(-2.0, 2.0)) = 1
 
         _TangentMap("TangentMap", 2D) = "bump" {}
+        _TangentMapOS("TangentMapOS", 2D) = "white" {}
         _Anisotropy("Anisotropy", Range(0.0, 1.0)) = 0
         _AnisotropyMap("AnisotropyMap", 2D) = "white" {}
 

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

     surfaceData.tangentWS = TransformTangentToWorld(tangentTS, input.worldToTangent);
     #else // Object space
     // Note: There is no such a thing like triplanar with object space normal, so we call directly 2D function
-    float3 tangentOS = UnpackNormalRGB(SAMPLE_TEXTURE2D(_TangentMap, sampler_TangentMap,  layerTexCoord.base.uv), 1.0);
+    float3 tangentOS = UnpackNormalRGB(SAMPLE_TEXTURE2D(_TangentMapOS, sampler_TangentMapOS,  layerTexCoord.base.uv), 1.0);
     surfaceData.tangentWS = TransformObjectToWorldDir(tangentOS);
     #endif
 #else

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

 
 TEXTURE2D(_TangentMap);
 SAMPLER2D(sampler_TangentMap);
+TEXTURE2D(_TangentMapOS);
+SAMPLER2D(sampler_TangentMapOS);
 
 float _Anisotropy;
 TEXTURE2D(_AnisotropyMap);

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

         _DetailSmoothnessScale("_DetailSmoothnessScale", Range(-2.0, 2.0)) = 1
 
         _TangentMap("TangentMap", 2D) = "bump" {}
+        _TangentMapOS("TangentMapOS", 2D) = "white" {}
         _Anisotropy("Anisotropy", Range(0.0, 1.0)) = 0
         _AnisotropyMap("AnisotropyMap", 2D) = "white" {}
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

 
 float3 TransformObjectToTangent(float3 dirOS, float3x3 worldToTangent)
 {
-    return mul(worldToTangent, mul((float3x3)unity_ObjectToWorld, dirOS));
+    return mul(worldToTangent, TransformObjectToWorldDir(dirOS));
 }
 #endif // UNITY_SHADER_VARIABLES_INCLUDED