Merge pull request #391 from Unity-Technologies/Branch_LitAndLayeredImprovements

Branch litandlayeredimprovements

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

         _HeightMap2("HeightMap2", 2D) = "black" {}
         _HeightMap3("HeightMap3", 2D) = "black" {}
 
-        _HeightAmplitude0("Height Scale0", Float) = 1
-        _HeightAmplitude1("Height Scale1", Float) = 1
-        _HeightAmplitude2("Height Scale2", Float) = 1
-        _HeightAmplitude3("Height Scale3", Float) = 1
+        [HideInInspector] _HeightAmplitude0("Height Scale0", Float) = 1
+        [HideInInspector] _HeightAmplitude1("Height Scale1", Float) = 1
+        [HideInInspector] _HeightAmplitude2("Height Scale2", Float) = 1
+        [HideInInspector] _HeightAmplitude3("Height Scale3", Float) = 1
+
+        _HeightMin0("Height Min0", Float) = -1
+        _HeightMin1("Height Min1", Float) = -1
+        _HeightMin2("Height Min2", Float) = -1
+        _HeightMin3("Height Min3", Float) = -1
+
+        _HeightMax0("Height Max0", Float) = 1
+        _HeightMax1("Height Max1", Float) = 1
+        _HeightMax2("Height Max2", Float) = 1
+        _HeightMax3("Height Max3", Float) = 1
 
         _DetailMap0("DetailMap0", 2D) = "black" {}
         _DetailMap1("DetailMap1", 2D) = "black" {}
         _InheritBaseColor2("_InheritBaseColor2", Range(0, 1.0)) = 0.0
         _InheritBaseColor3("_InheritBaseColor3", Range(0, 1.0)) = 0.0
 
-        _OpacityAsDensity0("_OpacityAsDensity0", Range(0, 1.0)) = 0.0
-        _OpacityAsDensity1("_OpacityAsDensity1", Range(0, 1.0)) = 0.0
-        _OpacityAsDensity2("_OpacityAsDensity2", Range(0, 1.0)) = 0.0
-        _OpacityAsDensity3("_OpacityAsDensity3", Range(0, 1.0)) = 0.0
+        [ToggleOff] _OpacityAsDensity0("_OpacityAsDensity0", Float) = 0.0
+        [ToggleOff] _OpacityAsDensity1("_OpacityAsDensity1", Float) = 0.0
+        [ToggleOff] _OpacityAsDensity2("_OpacityAsDensity2", Float) = 0.0
+        [ToggleOff] _OpacityAsDensity3("_OpacityAsDensity3", Float) = 0.0
 
         _LayerTilingBlendMask("_LayerTilingBlendMask", Float) = 1
 

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

         _HeightMap2("HeightMap2", 2D) = "black" {}
         _HeightMap3("HeightMap3", 2D) = "black" {}
 
-        _HeightAmplitude0("Height Scale0", Float) = 1
-        _HeightAmplitude1("Height Scale1", Float) = 1
-        _HeightAmplitude2("Height Scale2", Float) = 1
-        _HeightAmplitude3("Height Scale3", Float) = 1
+        [HideInInspector] _HeightAmplitude0("Height Scale0", Float) = 1
+        [HideInInspector] _HeightAmplitude1("Height Scale1", Float) = 1
+        [HideInInspector] _HeightAmplitude2("Height Scale2", Float) = 1
+        [HideInInspector] _HeightAmplitude3("Height Scale3", Float) = 1
+
+        _HeightMin0("Height Min0", Float) = -1
+        _HeightMin1("Height Min1", Float) = -1
+        _HeightMin2("Height Min2", Float) = -1
+        _HeightMin3("Height Min3", Float) = -1
+
+        _HeightMax0("Height Max0", Float) = 1
+        _HeightMax1("Height Max1", Float) = 1
+        _HeightMax2("Height Max2", Float) = 1
+        _HeightMax3("Height Max3", Float) = 1
 
         _DetailMap0("DetailMap0", 2D) = "black" {}
         _DetailMap1("DetailMap1", 2D) = "black" {}
         _InheritBaseColor2("_InheritBaseColor2", Range(0, 1.0)) = 0.0
         _InheritBaseColor3("_InheritBaseColor3", Range(0, 1.0)) = 0.0
 
-        _OpacityAsDensity0("_OpacityAsDensity0", Range(0, 1.0)) = 0.0
-        _OpacityAsDensity1("_OpacityAsDensity1", Range(0, 1.0)) = 0.0
-        _OpacityAsDensity2("_OpacityAsDensity2", Range(0, 1.0)) = 0.0
-        _OpacityAsDensity3("_OpacityAsDensity3", Range(0, 1.0)) = 0.0
+        [ToggleOff] _OpacityAsDensity0("_OpacityAsDensity0", Float) = 0.0
+        [ToggleOff] _OpacityAsDensity1("_OpacityAsDensity1", Float) = 0.0
+        [ToggleOff] _OpacityAsDensity2("_OpacityAsDensity2", Float) = 0.0
+        [ToggleOff] _OpacityAsDensity3("_OpacityAsDensity3", Float) = 0.0
 
         _LayerTilingBlendMask("_LayerTilingBlendMask", Float) = 1
 

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

             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 heightMapText = new GUIContent("Height Map (R)", "Height Map");
-            public static GUIContent heightMapAmplitudeText = new GUIContent("Height Map Amplitude", "Height Map amplitude in world units (distance between minimum and maximum value in the texture).");
+            public static GUIContent heightMapText = new GUIContent("Height Map (R)", "Height Map.\nFor floating point textures, min, max and base value should be 0, 1 and 0.");
+            public static GUIContent heightMapMinText = new GUIContent("Height Min", "Minimum value in the heightmap (in world units)");
+            public static GUIContent heightMapMaxText = new GUIContent("Height Max", "Maximum value in the heightmap (in world units)");
 
             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)");
         protected const string kHeightAmplitude = "_HeightAmplitude";
         protected MaterialProperty[] heightCenter = new MaterialProperty[kMaxLayerCount];
         protected const string kHeightCenter = "_HeightCenter";
+        protected MaterialProperty[] heightMin = new MaterialProperty[kMaxLayerCount];
+        protected const string kHeightMin = "_HeightMin";
+        protected MaterialProperty[] heightMax = new MaterialProperty[kMaxLayerCount];
+        protected const string kHeightMax = "_HeightMax";
 
         protected MaterialProperty[] UVDetail = new MaterialProperty[kMaxLayerCount];
         protected const string kUVDetail = "_UVDetail";
                 normalMapSpace[i] = FindProperty(string.Format("{0}{1}", kNormalMapSpace, m_PropertySuffixes[i]), props);
                 heightMap[i] = FindProperty(string.Format("{0}{1}", kHeightMap, m_PropertySuffixes[i]), props);
                 heightAmplitude[i] = FindProperty(string.Format("{0}{1}", kHeightAmplitude, m_PropertySuffixes[i]), props);
+                heightMin[i] = FindProperty(string.Format("{0}{1}", kHeightMin, m_PropertySuffixes[i]), props);
+                heightMax[i] = FindProperty(string.Format("{0}{1}", kHeightMax, m_PropertySuffixes[i]), props);
                 heightCenter[i] = FindProperty(string.Format("{0}{1}", kHeightCenter, m_PropertySuffixes[i]), props);
 
                 // Details
             if (!heightMap[layerIndex].hasMixedValue && heightMap[layerIndex].textureValue != null)
             {
                 EditorGUI.indentLevel++;
-                m_MaterialEditor.ShaderProperty(heightAmplitude[layerIndex], Styles.heightMapAmplitudeText);
-                heightAmplitude[layerIndex].floatValue = Math.Max(0.0f, heightAmplitude[layerIndex].floatValue); // Must be positive
+                m_MaterialEditor.ShaderProperty(heightMin[layerIndex], Styles.heightMapMinText);
+                m_MaterialEditor.ShaderProperty(heightMax[layerIndex], Styles.heightMapMaxText);
+                heightAmplitude[layerIndex].floatValue = heightMax[layerIndex].floatValue - heightMin[layerIndex].floatValue;
                 m_MaterialEditor.ShaderProperty(heightCenter[layerIndex], Styles.heightMapCenterText);
                 EditorGUI.showMixedValue = false;
                 EditorGUI.indentLevel--;

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

         _NormalScale("_NormalScale", Range(0.0, 2.0)) = 1
 
         _HeightMap("HeightMap", 2D) = "black" {}
-        _HeightAmplitude("Height Amplitude", Float) = 0.01 // In world units
+        [HideInInspector] _HeightAmplitude("Height Amplitude", Float) = 0.01 // In world units. This will be computed in the UI.
+        _HeightMin("Heightmap Min", Float) = -1
+        _HeightMax("Heightmap Max", Float) = 1
         _HeightCenter("Height Center", Range(0.0, 1.0)) = 0.5 // In texture space
 
         _DetailMap("DetailMap", 2D) = "black" {}

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

         outWeights[i] = 0.0f;
     }
 
+    
+#if defined(_DENSITY_MODE)
+    // Note: blendMasks.argb because a is main layer
+    float4 opacityAsDensity = saturate((inputAlphaMask - (float4(1.0, 1.0, 1.0, 1.0) - blendMasks.argb)) * 20.0); // 20.0 is the number of steps in inputAlphaMask (Density mask. We decided 20 empirically)
+    float4 useOpacityAsDensityParam = float4(_OpacityAsDensity0, _OpacityAsDensity1, _OpacityAsDensity2, _OpacityAsDensity3);
+    blendMasks.argb = lerp(blendMasks.argb, opacityAsDensity, useOpacityAsDensityParam);
+#endif
+
 #if defined(_HEIGHT_BASED_BLEND)
 
 #if defined(_HEIGHTMAP0) || defined(_HEIGHTMAP1) || defined(_HEIGHTMAP2) || defined(_HEIGHTMAP3)
     // If no heightmap is set on any layer, we don't need to try and blend them based on height...
 #endif
 
-#if defined(_DENSITY_MODE)
-    // Note: blendMasks.argb because a is main layer
-    float4 opacityAsDensity = saturate((inputAlphaMask - (float4(1.0, 1.0, 1.0, 1.0) - blendMasks.argb)) * 20.0); // 20.0 is the number of steps in inputAlphaMask (Density mask. We decided 20 empirically)
-    float4 useOpacityAsDensityParam = float4(_OpacityAsDensity0, _OpacityAsDensity1, _OpacityAsDensity2, _OpacityAsDensity3);
-    blendMasks.argb = lerp(blendMasks.argb, opacityAsDensity, useOpacityAsDensityParam);
-#endif
-
     ComputeMaskWeights(blendMasks, outWeights);
 }
 
 
     // THen get Main Layer Normal influence factor. Main layer is 0 because it can't be influence. In this case the final lerp return normalTS.
     float influenceFactor = BlendLayeredScalar(0.0, _InheritBaseNormal1, _InheritBaseNormal2, _InheritBaseNormal3, weights) * influenceMask;
-    // We will add smoothly the contribution of the normal map by using lower mips with help of bias sampling. InfluenceFactor must be [0..numMips] // Caution it cause banding...
+    // We will add smoothly the contribution of the normal map by lerping between vertex normal ( (0,0,1) in tangent space) and the actual normal from the main layer depending on the influence factor.
-    float maxMipBias = log2(max(_NormalMap0_TexelSize.z, _NormalMap0_TexelSize.w)); // don't do + 1 as it is for bias, not lod
-    float3 mainNormalTS = GetNormalTS0(input, layerTexCoord, float3(0.0, 0.0, 1.0), 0.0, true, maxMipBias * (1.0 - influenceFactor));
+    float3 mainNormalTS = lerp(float3(0.0, 0.0, 1.0), normalTS0, influenceFactor);
-    return lerp(normalTS, BlendNormalRNM(normalTS, mainNormalTS), influenceFactor * inputMainLayerMask);
+    return lerp(normalTS, BlendNormalRNM(normalTS, mainNormalTS), influenceFactor * inputMainLayerMask); // Multiply by inputMainLayerMask in order to avoid influence where main layer should never be present
-float3 ComputeMainBaseColorInfluence(float influenceMask, float3 baseColor0, float3 baseColor1, float3 baseColor2, float3 baseColor3, LayerTexCoord layerTexCoord, float weights[_MAX_LAYER])
+float3 ComputeMainBaseColorInfluence(float influenceMask, float3 baseColor0, float3 baseColor1, float3 baseColor2, float3 baseColor3, LayerTexCoord layerTexCoord, float inputMainLayerMask, float weights[_MAX_LAYER])
-    float influenceFactor = BlendLayeredScalar(0.0, _InheritBaseColor1, _InheritBaseColor2, _InheritBaseColor3, weights) * influenceMask;
+    float influenceFactor = BlendLayeredScalar(0.0, _InheritBaseColor1, _InheritBaseColor2, _InheritBaseColor3, weights) * influenceMask * inputMainLayerMask; // Multiply by inputMainLayerMask in order to avoid influence where main layer should never be present
 
     // We want to calculate the mean color of the texture. For this we will sample a low mipmap
     float textureBias = 15.0; // Use maximum bias
 #if defined(_MAIN_LAYER_INFLUENCE_MODE)
     if (influenceMask > 0.0f)
     {
-        surfaceData.baseColor = ComputeMainBaseColorInfluence(influenceMask, surfaceData0.baseColor, surfaceData1.baseColor, surfaceData2.baseColor, surfaceData3.baseColor, layerTexCoord, weights);
+        surfaceData.baseColor = ComputeMainBaseColorInfluence(influenceMask, surfaceData0.baseColor, surfaceData1.baseColor, surfaceData2.baseColor, surfaceData3.baseColor, layerTexCoord, blendMasks.a, weights);
         normalTS = ComputeMainNormalInfluence(influenceMask, input, normalTS0, normalTS1, normalTS2, normalTS3, layerTexCoord, blendMasks.a, weights);
     }
     else

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitDataInternal.hlsl

     #endif
 }
 
-float3 ADD_IDX(GetNormalTS)(FragInputs input, LayerTexCoord layerTexCoord, float3 detailNormalTS, float detailMask, bool useBias, float bias)
+float3 ADD_IDX(GetNormalTS)(FragInputs input, LayerTexCoord layerTexCoord, float3 detailNormalTS, float detailMask)
-    if (useBias)
-    {
-        normalTS = SAMPLE_UVMAPPING_NORMALMAP_BIAS(ADD_IDX(_NormalMap), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base), ADD_IDX(_NormalScale), bias);
-    }
-    else
-    {
-    }
-    // We forbid scale in case of object space as it make no sense
-    // To be able to combine object space normal with detail map then later we will re-transform it to world space.
-    // Note: There is no such a thing like triplanar with object space normal, so we call directly 2D function
-    if (useBias)
-    {
-        #ifdef SURFACE_GRADIENT
-        // /We need to decompress the normal ourselve here as UnpackNormalRGB will return a surface gradient
-        float3 normalOS = SAMPLE_TEXTURE2D_BIAS(ADD_IDX(_NormalMapOS), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base).uv, bias).xyz * 2.0 - 1.0;
-        // no need to renormalize normalOS for SurfaceGradientFromPerturbedNormal
-        normalTS = SurfaceGradientFromPerturbedNormal(input.worldToTangent[2], normalOS);
-        #else
-        float3 normalOS = UnpackNormalRGB(SAMPLE_TEXTURE2D_BIAS(ADD_IDX(_NormalMapOS), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base).uv, bias), 1.0);
-        normalTS = TransformObjectToTangent(normalOS, input.worldToTangent);
-        #endif
-    }
-    else
-    {
+        // We forbid scale in case of object space as it make no sense
+        // To be able to combine object space normal with detail map then later we will re-transform it to world space.
+        // Note: There is no such a thing like triplanar with object space normal, so we call directly 2D function
         #ifdef SURFACE_GRADIENT
         // /We need to decompress the normal ourselve here as UnpackNormalRGB will return a surface gradient
         float3 normalOS = SAMPLE_TEXTURE2D(ADD_IDX(_NormalMapOS), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base).uv).xyz * 2.0 - 1.0;
         float3 normalOS = UnpackNormalRGB(SAMPLE_TEXTURE2D(ADD_IDX(_NormalMapOS), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base).uv), 1.0);
         normalTS = TransformObjectToTangent(normalOS, input.worldToTangent);
         #endif
-    }
     #endif
 
     #ifdef _DETAIL_MAP_IDX
 #endif
     surfaceData.normalWS = float3(0.0, 0.0, 0.0); // Need to init this to keep quiet the compiler, but this is overriden later (0, 0, 0) so if we forget to override the compiler may comply.
 
-    normalTS = ADD_IDX(GetNormalTS)(input, layerTexCoord, detailNormalTS, detailMask, false, 0.0);
+    normalTS = ADD_IDX(GetNormalTS)(input, layerTexCoord, detailNormalTS, detailMask);
 
 #if defined(_MASKMAP_IDX)
     surfaceData.perceptualSmoothness = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_MaskMap), SAMPLER_MASKMAP_IDX, ADD_IDX(layerTexCoord.base)).a;

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

         _NormalScale("_NormalScale", Range(0.0, 2.0)) = 1
 
         _HeightMap("HeightMap", 2D) = "black" {}
-        _HeightAmplitude("Height Amplitude", Float) = 0.01 // In world units
+        [HideInInspector] _HeightAmplitude("Height Amplitude", Float) = 0.01 // In world units
+        _HeightMin("Heightmap Min", Float) = -1
+        _HeightMax("Heightmap Max", Float) = 1
 
         _DetailMap("DetailMap", 2D) = "black" {}
         _DetailMask("DetailMask", 2D) = "white" {}