Merge remote-tracking branch 'refs/remotes/origin/Unity-2017.3' into Refactor-LightLoop-Glue-Code

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

         _ThicknessMap2("Thickness Map", 2D) = "white" {}
         _ThicknessMap3("Thickness Map", 2D) = "white" {}
 
+        _ThicknessRemap0("Thickness Remap", Vector) = (0, 1, 0, 0)
+        _ThicknessRemap1("Thickness Remap", Vector) = (0, 1, 0, 0)
+        _ThicknessRemap2("Thickness Remap", Vector) = (0, 1, 0, 0)
+        _ThicknessRemap3("Thickness Remap", Vector) = (0, 1, 0, 0)
+
         // All the following properties exist only in layered lit material
 
         // Layer blending options
 
         // Transparency
         [ToggleOff] _PreRefractionPass("PreRefractionPass", Float) = 0.0
+
+        // HACK: GI Baking system relies on some properties existing in the shader ("_MainTex", "_Cutoff" and "_Color") for opacity handling, so we need to store our version of those parameters in the hard-coded name the GI baking system recognizes.
+        _MainTex("Albedo", 2D) = "white" {}
+        _Color("Color", Color) = (1,1,1,1)
+        _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
     }
 
     HLSLINCLUDE

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

         _ThicknessMap2("Thickness Map", 2D) = "white" {}
         _ThicknessMap3("Thickness Map", 2D) = "white" {}
 
+        _ThicknessRemap0("Thickness Remap", Vector) = (0, 1, 0, 0)
+        _ThicknessRemap1("Thickness Remap", Vector) = (0, 1, 0, 0)
+        _ThicknessRemap2("Thickness Remap", Vector) = (0, 1, 0, 0)
+        _ThicknessRemap3("Thickness Remap", Vector) = (0, 1, 0, 0)
+
         // All the following properties exist only in layered lit material
 
         // Layer blending options
 
         // Transparency
         [ToggleOff] _PreRefractionPass("PreRefractionPass", Float) = 0.0
+
+        // HACK: GI Baking system relies on some properties existing in the shader ("_MainTex", "_Cutoff" and "_Color") for opacity handling, so we need to store our version of those parameters in the hard-coded name the GI baking system recognizes.
+        _MainTex("Albedo", 2D) = "white" {}
+        _Color("Color", Color) = (1,1,1,1)
+        _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
     }
 
     HLSLINCLUDE

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

                 TessellationMode tessMode = (TessellationMode)material.GetFloat(kTessellationMode);
                 SetKeyword(material, "_TESSELLATION_PHONG", tessMode == TessellationMode.Phong);
             }
+
+            SetupMainTexForAlphaTestGI("_BaseColorMap", "_BaseColor", material);
         }
 
         static public void SetupBaseLitMaterialPass(Material material)

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

             public static GUIContent subsurfaceRadiusMapText = new GUIContent("Subsurface radius map (R)", "Determines the range of the blur.");
             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 (R)", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.");
+            public static GUIContent thicknessRemapText = new GUIContent("Thickness Remap", "Remaps values of the thickness map from [0, 1] to the specified range.");
 
             // Clear Coat
             public static GUIContent coatCoverageText = new GUIContent("Coat Coverage", "Percentage of clear coat coverage");
         protected const string kThickness = "_Thickness";
         protected MaterialProperty[] thicknessMap = new MaterialProperty[kMaxLayerCount];
         protected const string kThicknessMap = "_ThicknessMap";
+        protected MaterialProperty[] thicknessRemap = new MaterialProperty[kMaxLayerCount];
+        protected const string kThicknessRemap = "_ThicknessRemap";
 
         protected MaterialProperty[] UVDetail = new MaterialProperty[kMaxLayerCount];
         protected const string kUVDetail = "_UVDetail";
                 subsurfaceRadiusMap[i] = FindProperty(string.Format("{0}{1}", kSubsurfaceRadiusMap, m_PropertySuffixes[i]), props);
                 thickness[i] = FindProperty(string.Format("{0}{1}", kThickness, m_PropertySuffixes[i]), props);
                 thicknessMap[i] = FindProperty(string.Format("{0}{1}", kThicknessMap, m_PropertySuffixes[i]), props);
+                thicknessRemap[i] = FindProperty(string.Format("{0}{1}", kThicknessRemap, m_PropertySuffixes[i]), props);
 
                 // Details
                 UVDetail[i] = FindProperty(string.Format("{0}{1}", kUVDetail, m_PropertySuffixes[i]), props);
 
             m_MaterialEditor.ShaderProperty(subsurfaceRadius[layerIndex], Styles.subsurfaceRadiusText);
             m_MaterialEditor.TexturePropertySingleLine(Styles.subsurfaceRadiusMapText, subsurfaceRadiusMap[layerIndex]);
-            m_MaterialEditor.ShaderProperty(thickness[layerIndex], Styles.thicknessText);
+            if (thicknessMap[layerIndex].textureValue != null)
+            {
+                // Display the remap of texture values.
+                Vector2 remap = thicknessRemap[layerIndex].vectorValue;
+                EditorGUI.BeginChangeCheck();
+                EditorGUILayout.MinMaxSlider(Styles.thicknessRemapText, ref remap.x, ref remap.y, 0.0f, 1.0f);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    thicknessRemap[layerIndex].vectorValue = remap;
+                }
+            }
+            else
+            {
+                // Allow the user to set the constant value of thickness if no thickness map is provided.
+                m_MaterialEditor.ShaderProperty(thickness[layerIndex], Styles.thicknessText);
+            }
         }
 
         protected void ShaderClearCoatInputGUI()

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

         _SubsurfaceRadiusMap("Subsurface Radius Map", 2D) = "white" {}
         _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
+        _ThicknessRemap("Thickness Remap", Vector) = (0, 1, 0, 0)
 
         _CoatCoverage("Coat Coverage", Range(0.0, 1.0)) = 1.0
         _CoatIOR("Coat IOR", Range(0.0, 1.0)) = 0.5
         // In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
         // TODO: Fix the code in legacy unity so we can customize the beahvior for GI
         _EmissionColor("Color", Color) = (1, 1, 1)
+
+        // HACK: GI Baking system relies on some properties existing in the shader ("_MainTex", "_Cutoff" and "_Color") for opacity handling, so we need to store our version of those parameters in the hard-coded name the GI baking system recognizes.
+        _MainTex("Albedo", 2D) = "white" {}
+        _Color("Color", Color) = (1,1,1,1)
+        _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
     }
 
     HLSLINCLUDE

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitDataIndividualLayer.hlsl

 
     surfaceData.subsurfaceProfile = ADD_IDX(_SubsurfaceProfile);
     surfaceData.subsurfaceRadius = ADD_IDX(_SubsurfaceRadius);
-    surfaceData.thickness = ADD_IDX(_Thickness);
 
 #ifdef _SUBSURFACE_RADIUS_MAP_IDX
     surfaceData.subsurfaceRadius *= SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_SubsurfaceRadiusMap), SAMPLER_SUBSURFACE_RADIUSMAP_IDX, ADD_IDX(layerTexCoord.base)).r;
-    surfaceData.thickness *= SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_ThicknessMap), SAMPLER_THICKNESSMAP_IDX, ADD_IDX(layerTexCoord.base)).r;
+    surfaceData.thickness = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_ThicknessMap), SAMPLER_THICKNESSMAP_IDX, ADD_IDX(layerTexCoord.base)).r;
+    surfaceData.thickness = ADD_IDX(_ThicknessRemap).x + ADD_IDX(_ThicknessRemap).y * surfaceData.thickness;
+#else
+    surfaceData.thickness = ADD_IDX(_Thickness);
 #endif
 
     // This part of the code is not used in case of layered shader but we keep the same macro system for simplicity

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitProperties.hlsl

 int   _SubsurfaceProfile;
 float _SubsurfaceRadius;
 float _Thickness;
+float4 _ThicknessRemap;
 
 float _CoatCoverage;
 float _CoatIOR;
 PROP_DECL(int, _SubsurfaceProfile);
 PROP_DECL(float, _SubsurfaceRadius);
 PROP_DECL(float, _Thickness);
+PROP_DECL(float4, _ThicknessRemap);
 
 PROP_DECL(float, _OpacityAsDensity);
 float _InheritBaseNormal1;

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

         _SubsurfaceRadiusMap("Subsurface Radius Map", 2D) = "white" {}
         _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
+        _ThicknessRemap("Thickness Remap", Vector) = (0, 1, 0, 0)
 
         _CoatCoverage("Coat Coverage", Range(0.0, 1.0)) = 1.0
         _CoatIOR("Coat IOR", Range(0.0, 1.0)) = 0.5
         _TessellationShapeFactor("Tessellation shape factor", Range(0.0, 1.0)) = 0.75 // Only use with Phong
         _TessellationBackFaceCullEpsilon("Tessellation back face epsilon", Range(-1.0, 0.0)) = -0.25
          // TODO: Handle culling mode for backface culling
+
+        // HACK: GI Baking system relies on some properties existing in the shader ("_MainTex", "_Cutoff" and "_Color") for opacity handling, so we need to store our version of those parameters in the hard-coded name the GI baking system recognizes.
+        _MainTex("Albedo", 2D) = "white" {}
+        _Color("Color", Color) = (1,1,1,1)
+        _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
     }
 
     HLSLINCLUDE

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringSettings.cs

             ValidateArray(ref halfRcpVariancesAndWeights, SssConstants.SSS_N_PROFILES * 2);
             ValidateArray(ref filterKernelsBasic,         SssConstants.SSS_N_PROFILES * SssConstants.SSS_BASIC_N_SAMPLES);
 
-            Debug.Assert(SssConstants.SSS_NEUTRAL_PROFILE_ID < 16, "Transmission flags (32-bit integer) cannot support more than 16 profiles.");
+            Debug.Assert(SssConstants.SSS_NEUTRAL_PROFILE_ID < 16, "Transmission flags (32-bit integer) cannot support more than 16 profiles (2 bits per profile).");
 
             UpdateCache();
         }

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Editor/BaseUnlitUI.cs

             // The fixup routine makes sure that the material is in the correct state if/when changes are made to the mode or color.
             MaterialEditor.FixupEmissiveFlag(material);
 
+            // Commented out for now because unfortunately we used the hard coded property names used by the GI system for our own parameters
+            // So we need a way to work around that before we activate this.
+            //SetupMainTexForAlphaTestGI("_EmissiveColorMap", "_EmissiveColor", material);
+
+        }
+
+        // This is a hack for GI. PVR looks in the shader for a texture named "_MainTex" to extract the opacity of the material for baking. In the same manner, "_Cutoff" and "_Color" are also necessary.
+        // Since we don't have those parameters in our shaders we need to provide a "fake" useless version of them with the right values for the GI to work.
+        protected static void SetupMainTexForAlphaTestGI(string colorMapPropertyName, string colorPropertyName, Material material)
+        {
+            if(material.HasProperty(colorMapPropertyName))
+            {
+                var mainTex = material.GetTexture(colorMapPropertyName);
+                material.SetTexture("_MainTex", mainTex);
+            }
+
+            if(material.HasProperty(colorPropertyName))
+            {
+                var color = material.GetColor(colorPropertyName);
+                material.SetColor("_Color", color);
+            }
+
+            if(material.HasProperty("_AlphaCutoff")) // Same for all our materials
+            {
+                var cutoff = material.GetFloat("_AlphaCutoff");
+                material.SetFloat("_Cutoff", cutoff);
+            }
         }
 
         static public void SetupBaseUnlitMaterialPass(Material material)

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.shader

         // In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
         // TODO: Fix the code in legacy unity so we can customize the beahvior for GI
         _EmissionColor("Color", Color) = (1, 1, 1)
+        
+        // HACK: GI Baking system relies on some properties existing in the shader ("_MainTex", "_Cutoff" and "_Color") for opacity handling, so we need to store our version of those parameters in the hard-coded name the GI baking system recognizes.
+        _MainTex("Albedo", 2D) = "white" {}
+        _Color("Color", Color) = (1,1,1,1)
+        _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
     }
 
     HLSLINCLUDE