Merge remote-tracking branch 'refs/remotes/origin/master' into Merge-FPTL

# Conflicts:
#	Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

Assets/ScriptableRenderLoop/HDRenderLoop/Editor/HDRenderLoopInspector.cs

             public readonly GUIContent exposure = new GUIContent("Exposure");
 
             public readonly GUIContent useForwardRenderingOnly = new GUIContent("Use Forward Rendering Only");
+            public readonly GUIContent useDepthPrepass = new GUIContent("Use Depth Prepass");
+
+            public readonly GUIContent skyParameters = new GUIContent("Sky Parameters");
+            public readonly GUIContent skyExposure = new GUIContent("Sky Exposure");
+            public readonly GUIContent skyRotation = new GUIContent("Sky Rotation");
+            public readonly GUIContent skyMultiplier = new GUIContent("Sky Multiplier");
         }
 
         private static Styles s_Styles = null;
             debugParameters.displayOpaqueObjects = EditorGUILayout.Toggle(styles.displayOpaqueObjects, debugParameters.displayOpaqueObjects);
             debugParameters.displayTransparentObjects = EditorGUILayout.Toggle(styles.displayTransparentObjects, debugParameters.displayTransparentObjects);
 			debugParameters.useForwardRenderingOnly = EditorGUILayout.Toggle(styles.useForwardRenderingOnly, debugParameters.useForwardRenderingOnly);
+            debugParameters.useDepthPrepass = EditorGUILayout.Toggle(styles.useDepthPrepass, debugParameters.useDepthPrepass);            
+            if (EditorGUI.EndChangeCheck())
+            {
+                EditorUtility.SetDirty(renderLoop); // Repaint
+            }
+            EditorGUI.indentLevel--;
+
+            var skyParameters = renderLoop.skyParameters;
+
+            EditorGUILayout.LabelField(styles.skyParameters);
+            EditorGUI.indentLevel++;
+            EditorGUI.BeginChangeCheck();
+
+            skyParameters.skyHDRI = (Cubemap)EditorGUILayout.ObjectField("Cubemap", skyParameters.skyHDRI, typeof(Cubemap), false);
+            skyParameters.exposure = Mathf.Max(Mathf.Min(EditorGUILayout.FloatField(styles.skyExposure, skyParameters.exposure), 32), -32);
+            skyParameters.multiplier = Mathf.Max(EditorGUILayout.FloatField(styles.skyMultiplier, skyParameters.multiplier), 0);
+            skyParameters.rotation = Mathf.Max(Mathf.Min(EditorGUILayout.FloatField(styles.skyRotation, skyParameters.rotation), 360), 0);
+ 
             if (EditorGUI.EndChangeCheck())
             {
                 EditorUtility.SetDirty(renderLoop); // Repaint

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.asset.meta

 fileFormatVersion: 2
 guid: 2400b74f5ce370c4481e5dc417d03703
-timeCreated: 1478912125
+timeCreated: 1479240578
 licenseType: Pro
 NativeFormatImporter:
   userData: 

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

             BakeDiffuseLighting = 11,
         }
 
+        public class SkyParameters
+        {
+            public Cubemap skyHDRI;
+            public float rotation;
+            public float exposure;
+            public float multiplier;
+        }
+
+        [SerializeField]
+        private SkyParameters m_SkyParameters = new SkyParameters();
+ 
+        public SkyParameters skyParameters
+        {
+            get { return m_SkyParameters; }
+        }
+
         public class DebugParameters
         {
             // Material Debugging
         [SerializeField]
         TextureSettings m_TextureSettings = TextureSettings.Default;
 
+        Material m_SkyboxMaterial;
+        Material m_SkyHDRIMaterial;
         Material m_DeferredMaterial;
         Material m_FinalPassMaterial;
 
             s_envLightList       = new ComputeBuffer(MaxLights,  System.Runtime.InteropServices.Marshal.SizeOf(typeof(EnvLightData)));
             s_punctualShadowList = new ComputeBuffer(MaxShadows, System.Runtime.InteropServices.Marshal.SizeOf(typeof(PunctualShadowData)));
 
+            // TODO: We need to have an API to send our sky information to Enlighten. For now use a workaround through skybox/cubemap material...
+            m_SkyboxMaterial = CreateEngineMaterial("Skybox/Cubemap");
+            RenderSettings.skybox = m_SkyboxMaterial; // Setup this material as the default to be use in RenderSettings
+            RenderSettings.ambientIntensity = 1.0f; // fix this to 1, this parameter should not exist!
+            RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Skybox; // Force skybox for our HDRI
+            RenderSettings.reflectionIntensity = 1.0f;
+        
+            m_SkyHDRIMaterial = CreateEngineMaterial("Hidden/HDRenderLoop/SkyHDRI");
             m_DeferredMaterial   = CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
             m_FinalPassMaterial  = CreateEngineMaterial("Hidden/HDRenderLoop/FinalPass");
 
             s_areaLightList.Release();
             s_envLightList.Release();
             s_punctualShadowList.Release();
-
+     
+            if (m_SkyboxMaterial) DestroyImmediate(m_SkyboxMaterial);
+            if (m_SkyHDRIMaterial) DestroyImmediate(m_SkyHDRIMaterial);
             if (m_DeferredMaterial)  DestroyImmediate(m_DeferredMaterial);
             if (m_FinalPassMaterial) DestroyImmediate(m_FinalPassMaterial);
 
         {
             // If we are forward only we will do a depth prepass
             // TODO: Depth prepass should be enabled based on light loop settings. LightLoop define if they need a depth prepass + forward only...
-            if (!debugParameters.useDepthPrepass || !debugParameters.useForwardRenderingOnly)
+            if (!debugParameters.useDepthPrepass)
                 return;
 
               // TODO: Must do opaque then alpha masked for performance! 
             cmd.Dispose();
         }
 
+        void RenderSky(Camera camera, RenderLoop renderLoop)
+        {
+            /*
+            // Render sky into a cubemap - doesn't happen every frame, can be control
+
+            // TODO: do a render to texture here
+
+            // Downsample the cubemap and provide it to Enlighten
+
+            // TODO: currently workaround is to set the cubemap in a Skybox/cubemap material
+            //m_SkyboxMaterial.SetTexture(cubemap);
+
+            // Render the sky itself
+
+            Vector3[] vertData = new Vector3[4];
+            vertData[0] = new Vector3(-1.0f, -1.0f, 0.0f);
+            vertData[1] = new Vector3(1.0f, -1.0f, 0.0f);
+            vertData[2] = new Vector3(1.0f, 1.0f, 0.0f);
+            vertData[3] = new Vector3(-1.0f, 1.0f, 0.0f);            
+
+            Vector3[] eyeVectorData = new Vector3[4];
+            // camera.worldToCameraMatrix, camera.projectionMatrix
+            // Get view vector vased on the frustrum, i.e (invert transform frustrum get position etc...)
+            eyeVectorData[0] = 
+            eyeVectorData[1] = 
+            eyeVectorData[2] = 
+            eyeVectorData[3] = 
+
+            // Write out the mesh
+            var triangles = new int[4];
+            for (int i = 0; i < 4; i++)
+            {
+                triangles[i] = i;
+            }
+
+            Mesh mesh = new Mesh
+            {
+                vertices = vertData,
+                normals = eyeVectorData,
+                triangles = triangles
+            };
+
+            m_SkyHDRIMaterial.SetTexture("_Cubemap", skyParameters.skyHDRI);
+            m_SkyHDRIMaterial.SetVector("_SkyParam", new Vector4(skyParameters.exposure, skyParameters.multiplier, skyParameters.rotation, 0.0f));
+
+            var cmd = new CommandBuffer { name = "Skybox" };
+            cmd.DrawMesh(mesh, Matrix4x4.identity, m_SkyHDRIMaterial);
+            renderloop.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
+            */
+        }
+
         void RenderForward(CullResults cullResults, Camera camera, RenderLoop renderLoop)
         {
             // Bind material data
                 
                 RenderForwardOpaqueDepth(cullResults, camera, renderLoop);
 
+                // For tile lighting with forward opaque
+                //RenderForwardOpaqueDepth(cullResults, camera, renderLoop);
+
                 if (debugParameters.debugViewMaterial != 0)
                 {
                     RenderDebugViewMaterial(cullResults, camera, renderLoop);
 
                     RenderDeferredLighting(camera, renderLoop);
 
-                    RenderForward(cullResults, camera, renderLoop);
+                    RenderSky(camera, renderLoop);
+
+                    RenderForward(cullResults, camera, renderLoop); // Note: We want to render forward opaque before RenderSky, then RenderTransparent - can only do that once we have material.SetPass feature...
-                    RenderVelocity(cullResults, camera, renderLoop);
+                    RenderVelocity(cullResults, camera, renderLoop); // Note we may have to render velocity earlier if we do temporalAO, temporal volumetric etc... Mean we will not take into account forward opaque in case of deferred rendering ? 
 
                     // TODO: Check with VFX team.
                     // Rendering distortion here have off course lot of artifact.

Assets/ScriptableRenderLoop/HDRenderLoop/Material/LayeredLit/Editor/LayeredLitUI.cs

 {
     internal class LayeredLitGUI : LitGUI
     {
+        public enum LayerMapping
+        {
+            UV0,
+            UV1,
+            Planar,
+            Triplanar,
+        }
+
         private class Styles
         {
             public readonly GUIContent[] materialLayerLabels =
             public readonly GUIContent emission = new GUIContent("Emissive");
             public readonly GUIContent layerMapMask = new GUIContent("Layer Mask", "Layer mask (multiplied by vertex color)");
             public readonly GUIContent layerCount = new GUIContent("Layer Count", "Number of layers.");
+            public readonly GUIContent layerSize = new GUIContent("Size", "Size of the layer mapping in world units.");
+            public readonly GUIContent layerMapping = new GUIContent("Mapping", "Mapping mode of the layer.");
         }
 
         static Styles s_Styles = null;
 
         private const int kMaxLayerCount = 4;
         private const int kSyncButtonWidth = 58;
-        private string kLayerMaskMap = "_LayerMaskMap";
-        private string kLayerCount = "_LayerCount";
+        private const string kLayerMaskMap = "_LayerMaskMap";
+        private const string kLayerCount = "_LayerCount";
+        private const string kLayerMapping = "_LayerMapping";
+        private const string kLayerSize = "_LayerSize";
+        MaterialProperty[] layerMappingProperty = new MaterialProperty[kMaxLayerCount];
+        MaterialProperty[] layerSizeProperty = new MaterialProperty[kMaxLayerCount];
 
         int layerCount
         {
             }
         }
 
-        bool LayersGUI(AssetImporter materialImporter)
+        bool DoLayerGUI(AssetImporter materialImporter, int layerIndex)
+        {
+            bool result = false;
+            EditorGUI.BeginChangeCheck();
+            m_MaterialLayers[layerIndex] = EditorGUILayout.ObjectField(styles.materialLayerLabels[layerIndex], m_MaterialLayers[layerIndex], typeof(Material), true) as Material;
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(materialImporter, "Change layer material");
+                SynchronizeLayerProperties(layerIndex);
+                result = true;
+            }
+
+            EditorGUI.BeginChangeCheck();
+            m_MaterialEditor.ShaderProperty(layerMappingProperty[layerIndex], styles.layerMapping);
+            if (EditorGUI.EndChangeCheck())
+            {
+                result = true;
+            }
+            m_MaterialEditor.ShaderProperty(layerSizeProperty[layerIndex], styles.layerSize);
+
+            return result;
+        }
+
+        bool DoLayersGUI(AssetImporter materialImporter)
         {
             Material material = m_MaterialEditor.target as Material;
 
 
             for (int i = 0; i < layerCount; i++)
             {
-                EditorGUI.BeginChangeCheck();
-                m_MaterialLayers[i] = EditorGUILayout.ObjectField(styles.materialLayerLabels[i], m_MaterialLayers[i], typeof(Material), true) as Material;
-                if (EditorGUI.EndChangeCheck())
-                {
-                    Undo.RecordObject(materialImporter, "Change layer material");
-                    SynchronizeLayerProperties(i);
-                    layerChanged = true;
-                }
+                layerChanged |= DoLayerGUI(materialImporter, i);
             }
 
             EditorGUILayout.Space();
                 SetKeyword(material, "_LAYEREDLIT_4_LAYERS", false);
                 SetKeyword(material, "_LAYEREDLIT_3_LAYERS", false);
             }
+
+            const string kLayerMappingUV1 = "_LAYER_MAPPING_UV1_";
+            const string kLayerMappingPlanar = "_LAYER_MAPPING_PLANAR_";
+            const string kLayerMappingTriplanar = "_LAYER_MAPPING_TRIPLANAR_";
+
+            for (int i = 0 ; i <layerCount ; ++i)
+            {
+                string layerMappingParam = string.Format("{0}{1}", kLayerMapping, i);
+                LayerMapping layerMapping = (LayerMapping)material.GetFloat(layerMappingParam);
+
+                string currentLayerMappingUV1 = string.Format("{0}{1}", kLayerMappingUV1, i);
+                string currentLayerMappingPlanar = string.Format("{0}{1}", kLayerMappingPlanar, i);
+                string currentLayerMappingTriplanar = string.Format("{0}{1}", kLayerMappingTriplanar, i);
+
+                if(layerMapping == LayerMapping.UV1)
+                {
+                    SetKeyword(material, currentLayerMappingUV1, true);
+                    SetKeyword(material, currentLayerMappingPlanar, false);
+                    SetKeyword(material, currentLayerMappingTriplanar, false);
+                }
+                else if(layerMapping == LayerMapping.Planar)
+                {
+                    SetKeyword(material, currentLayerMappingUV1, false);
+                    SetKeyword(material, currentLayerMappingPlanar, true);
+                    SetKeyword(material, currentLayerMappingTriplanar, false);
+                }
+                else if(layerMapping == LayerMapping.Triplanar)
+                {
+                    SetKeyword(material, currentLayerMappingUV1, false);
+                    SetKeyword(material, currentLayerMappingPlanar, false);
+                    SetKeyword(material, currentLayerMappingTriplanar, true);
+                }
+            }
-        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
+        private void FindLayerProperties(MaterialProperty[] props)
-            FindOptionProperties(props);
+            for (int i = 0; i < layerCount; ++i)
+            {
+                layerMappingProperty[i] = FindProperty(string.Format("{0}{1}", kLayerMapping, i), props);
+                layerSizeProperty[i] = FindProperty(string.Format("{0}{1}", kLayerSize, i), props);
+            }
+        }
+
+        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
+        {
+            FindOptionProperties(props);
+            FindLayerProperties(props);
 
             m_MaterialEditor = materialEditor;
 
                 optionsChanged = true;
             }
 
-            bool layerChanged = LayersGUI(materialImporter);
+            bool layerChanged = DoLayersGUI(materialImporter);
 
             CheckLayerConsistency();
 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/LayeredLit/LayeredLit.shader

         _EmissiveIntensity2("EmissiveIntensity2", Float) = 0
         _EmissiveIntensity3("EmissiveIntensity3", Float) = 0
 
+        _LayerSize0("LayerSize0", Float) = 1.0
+        _LayerSize1("LayerSize1", Float) = 1.0
+        _LayerSize2("LayerSize2", Float) = 1.0
+        _LayerSize3("LayerSize3", Float) = 1.0
+
         _LayerMaskMap("LayerMaskMap", 2D) = "white" {}
 
         [ToggleOff]     _DistortionOnly("Distortion Only", Float) = 0.0
         [Enum(Mask Alpha, 0, BaseColor Alpha, 1)] _SmoothnessTextureChannel("Smoothness texture channel", Float) = 1
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
         [Enum(None, 0, DoubleSided, 1, DoubleSidedLigthingFlip, 2, DoubleSidedLigthingMirror, 3)] _DoubleSidedMode("Double sided mode", Float) = 0
+
+        [Enum(UV0, 0, UV1, 1, Planar, 2, Triplanar, 3)] _LayerMapping0("Layer 0 Mapping", Float) = 0
+        [Enum(UV0, 0, UV1, 1, Planar, 2, Triplanar, 3)] _LayerMapping1("Layer 1 Mapping", Float) = 0
+        [Enum(UV0, 0, UV1, 1, Planar, 2, Triplanar, 3)] _LayerMapping2("Layer 2 Mapping", Float) = 0
+        [Enum(UV0, 0, UV1, 1, Planar, 2, Triplanar, 3)] _LayerMapping3("Layer 3 Mapping", Float) = 0
     }
 
     HLSLINCLUDE
     #pragma shader_feature _HEIGHTMAP_AS_DISPLACEMENT
     #pragma shader_feature _LAYERMASKMAP
     #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
+    //#pragma shader_feature _ _LAYER_MAPPING_UV1_0 _LAYER_MAPPING_PLANAR_0 _LAYER_MAPPING_TRIPLANAR_0
+    //#pragma shader_feature _ _LAYER_MAPPING_UV1_1 _LAYER_MAPPING_PLANAR_1 _LAYER_MAPPING_TRIPLANAR_1
+    //#pragma shader_feature _ _LAYER_MAPPING_UV1_2 _LAYER_MAPPING_PLANAR_2 _LAYER_MAPPING_TRIPLANAR_2
+    //#pragma shader_feature _ _LAYER_MAPPING_UV1_3 _LAYER_MAPPING_PLANAR_3 _LAYER_MAPPING_TRIPLANAR_3
 
     //-------------------------------------------------------------------------------------
     // Define
     // variable declaration
     //-------------------------------------------------------------------------------------
 
+
+    #define _MAX_LAYER 4
+
+    #if defined(_LAYEREDLIT_4_LAYERS)
+    #   define _LAYER_COUNT 4
+    #elif defined(_LAYEREDLIT_3_LAYERS)
+    #   define _LAYER_COUNT 3
+    #else
+    #   define _LAYER_COUNT 2
+    #endif
+
+    struct LayerCoordinates
+    {
+        float2  texcoord[_MAX_LAYER];
+        bool    isTriplanar[_MAX_LAYER];
+    };
+
+    float4 SampleLayer(TEXTURE2D_ARGS(layerTex, layerSampler), LayerCoordinates layerCoord, int layerIndex)
+    {
+        if (layerCoord.isTriplanar[layerIndex])
+        {
+            // TODO 
+            return SAMPLE_TEXTURE2D(layerTex, layerSampler, layerCoord.texcoord[layerIndex]);
+        }
+        else
+        {
+            return SAMPLE_TEXTURE2D(layerTex, layerSampler, layerCoord.texcoord[layerIndex]);
+        }
+    }
+
     // Set of users variables
     #define PROP_DECL(type, name) type name, name##0, name##1, name##2, name##3;
     #define PROP_DECL_TEX2D(name)\
         TEXTURE2D(name##2); \
         TEXTURE2D(name##3);
-    #define PROP_SAMPLE(name, textureName, texcoord, swizzle)\
-        name##0 = SAMPLE_TEXTURE2D(textureName##0, sampler##textureName##0, texcoord).##swizzle; \
-        name##1 = SAMPLE_TEXTURE2D(textureName##1, sampler##textureName##0, texcoord).##swizzle; \
-        name##2 = SAMPLE_TEXTURE2D(textureName##2, sampler##textureName##0, texcoord).##swizzle; \
-        name##3 = SAMPLE_TEXTURE2D(textureName##3, sampler##textureName##0, texcoord).##swizzle;
+    #define PROP_SAMPLE(name, textureName, layerCoord, swizzle)\
+        name##0 = SampleLayer(TEXTURE2D_PARAM(textureName##0, sampler##textureName##0), layerCoord, 0).##swizzle; \
+        name##1 = SampleLayer(TEXTURE2D_PARAM(textureName##1, sampler##textureName##0), layerCoord, 1).##swizzle; \
+        name##2 = SampleLayer(TEXTURE2D_PARAM(textureName##2, sampler##textureName##0), layerCoord, 2).##swizzle; \
+        name##3 = SampleLayer(TEXTURE2D_PARAM(textureName##3, sampler##textureName##0), layerCoord, 3).##swizzle;
     #define PROP_MUL(name, multiplier, swizzle)\
         name##0 *= multiplier##0.##swizzle; \
         name##1 *= multiplier##1.##swizzle; \
     #define PROP_BLEND_COLOR(name, mask) name = BlendLayeredColor(name##0, name##1, name##2, name##3, mask);
     #define PROP_BLEND_SCALAR(name, mask) name = BlendLayeredScalar(name##0, name##1, name##2, name##3, mask);
 
-    #define _MAX_LAYER 4
-
-    #if defined(_LAYEREDLIT_4_LAYERS)
-    #   define _LAYER_COUNT 4
-    #elif defined(_LAYEREDLIT_3_LAYERS)
-    #   define _LAYER_COUNT 3
-    #else
-    #   define _LAYER_COUNT 2
-    #endif
-
     //-------------------------------------------------------------------------------------
     // variable declaration
     //-------------------------------------------------------------------------------------
     PROP_DECL(float, _HeightBias);
     PROP_DECL(float3, _EmissiveColor);
     PROP_DECL(float, _EmissiveIntensity);
+    PROP_DECL(float, _LayerSize);
 
     float _AlphaCutoff;
     TEXTURE2D(_LayerMaskMap);

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/LitData.hlsl

 #if !defined(LAYERED_LIT_SHADER)
 
 void GetSurfaceAndBuiltinData(FragInput input, out SurfaceData surfaceData, out BuiltinData builtinData)
-{    
+{
 #ifdef _HEIGHTMAP
     // TODO: in case of shader graph, a node like parallax must be nullify if use to generate code for Meta pass
     #ifndef _HEIGHTMAP_AS_DISPLACEMENT
     outWeights[0] = left;
 }
 
+float2 ComputePlanarXZCoord(float3 worldPos, float layerSize)
+{
+    return frac(worldPos.xz / layerSize);
+}
+
+void ComputeLayerCoordinates(out LayerCoordinates outCoord, FragInput input)
+{
+#if defined(_LAYER_MAPPING_UV1_0)
+    outCoord.texcoord[0] = input.texCoord1;
+    outCoord.isTriplanar[0] = false;
+#elif defined(_LAYER_MAPPING_PLANAR_0)
+    outCoord.texcoord[0] = ComputePlanarXZCoord(input.positionWS, _LayerSize0);
+    outCoord.isTriplanar[0] = false;
+#elif defined(_LAYER_MAPPING_TRIPLANAR_0)
+    outCoord.texcoord[0] = input.texCoord0;
+    outCoord.isTriplanar[0] = true;
+#else
+    outCoord.texcoord[0] = input.texCoord0;
+    outCoord.isTriplanar[0] = false;
+#endif
+
+#if defined(_LAYER_MAPPING_UV1_1)
+    outCoord.texcoord[1] = input.texCoord1;
+    outCoord.isTriplanar[1] = false;
+#elif defined(_LAYER_MAPPING_PLANAR_1)
+    outCoord.texcoord[1] = ComputePlanarXZCoord(input.positionWS, _LayerSize1);
+    outCoord.isTriplanar[1] = false;
+#elif defined(_LAYER_MAPPING_TRIPLANAR_1)
+    outCoord.texcoord[1] = input.texCoord0;
+    outCoord.isTriplanar[1] = true;
+#else
+    outCoord.texcoord[1] = input.texCoord0;
+    outCoord.isTriplanar[1] = false;
+#endif
+
+#if defined(_LAYER_MAPPING_UV1_2)
+    outCoord.texcoord[2] = input.texCoord1;
+    outCoord.isTriplanar[2] = false;
+#elif defined(_LAYER_MAPPING_PLANAR_2)
+    outCoord.texcoord[2] = ComputePlanarXZCoord(input.positionWS, _LayerSize2);
+    outCoord.isTriplanar[2] = false;
+#elif defined(_LAYER_MAPPING_TRIPLANAR_2)
+    outCoord.texcoord[2] = input.texCoord0;
+    outCoord.isTriplanar[2] = true;
+#else
+    outCoord.texcoord[2] = input.texCoord0;
+    outCoord.isTriplanar[2] = false;
+#endif
+
+#if defined(_LAYER_MAPPING_UV1_3)
+    outCoord.texcoord[3] = input.texCoord1;
+    outCoord.isTriplanar[3] = false;
+#elif defined(_LAYER_MAPPING_PLANAR_3)
+    outCoord.texcoord[3] = ComputePlanarXZCoord(input.positionWS, _LayerSize3);
+    outCoord.isTriplanar[3] = false;
+#elif defined(_LAYER_MAPPING_TRIPLANAR_3)
+    outCoord.texcoord[3] = input.texCoord0;
+    outCoord.isTriplanar[3] = true;
+#else
+    outCoord.texcoord[3] = input.texCoord0;
+    outCoord.isTriplanar[3] = false;
+#endif
+}
+    LayerCoordinates layerCoord;
+    ComputeLayerCoordinates(layerCoord, input);
+
     // Mask Values : Layer 1, 2, 3 are r, g, b
     float3 maskValues = float3(0.0, 0.0, 0.0);// input.vertexColor;
 
     ComputeMaskWeights(maskValues, weights);
 
     PROP_DECL(float3, baseColor);
-    PROP_SAMPLE(baseColor, _BaseColorMap, input.texCoord0, rgb);
+    PROP_SAMPLE(baseColor, _BaseColorMap, layerCoord, rgb);
     PROP_MUL(baseColor, _BaseColor, rgb);
     PROP_BLEND_COLOR(baseColor, weights);
 
 #ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
     PROP_ASSIGN(alpha, _BaseColor, a);
 #else
-    PROP_SAMPLE(alpha, _BaseColorMap, input.texCoord0, a);
+    PROP_SAMPLE(alpha, _BaseColorMap, layerCoord, a);
     PROP_MUL(alpha, _BaseColor, a);
 #endif
     PROP_BLEND_SCALAR(alpha, weights);
     PROP_DECL(float, specularOcclusion);
 #ifdef _SPECULAROCCLUSIONMAP
     // TODO: Do something. For now just take alpha channel
-    PROP_SAMPLE(specularOcclusion, _SpecularOcclusionMap, input.texCoord0, a);
+    PROP_SAMPLE(specularOcclusion, _SpecularOcclusionMap, layerCoord, a);
 #else
     // Horizon Occlusion for Normal Mapped Reflections: http://marmosetco.tumblr.com/post/81245981087
     //surfaceData.specularOcclusion = saturate(1.0 + horizonFade * dot(r, input.tangentToWorld[2].xyz);
 
 #ifdef _NORMALMAP
     #ifdef _NORMALMAP_TANGENT_SPACE
-        float3 normalTS0 = UnpackNormalAG(SAMPLE_TEXTURE2D(_NormalMap0, sampler_NormalMap0, input.texCoord0));
-        float3 normalTS1 = UnpackNormalAG(SAMPLE_TEXTURE2D(_NormalMap1, sampler_NormalMap0, input.texCoord0));
-        float3 normalTS2 = UnpackNormalAG(SAMPLE_TEXTURE2D(_NormalMap2, sampler_NormalMap0, input.texCoord0));
-        float3 normalTS3 = UnpackNormalAG(SAMPLE_TEXTURE2D(_NormalMap3, sampler_NormalMap0, input.texCoord0));
+        float3 normalTS0 = UnpackNormalAG(SampleLayer(TEXTURE2D_PARAM(_NormalMap0, sampler_NormalMap0), layerCoord, 0));
+        float3 normalTS1 = UnpackNormalAG(SampleLayer(TEXTURE2D_PARAM(_NormalMap1, sampler_NormalMap0), layerCoord, 1));
+        float3 normalTS2 = UnpackNormalAG(SampleLayer(TEXTURE2D_PARAM(_NormalMap2, sampler_NormalMap0), layerCoord, 2));
+        float3 normalTS3 = UnpackNormalAG(SampleLayer(TEXTURE2D_PARAM(_NormalMap3, sampler_NormalMap0), layerCoord, 3));
 
         float3 normalTS = BlendLayeredNormal(normalTS0, normalTS1, normalTS2, normalTS3, weights);
 
 
     PROP_DECL(float, perceptualSmoothness);
 #ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-    PROP_SAMPLE(perceptualSmoothness, _BaseColorMap, input.texCoord0, a);
+    PROP_SAMPLE(perceptualSmoothness, _BaseColorMap, layerCoord, a);
-    PROP_SAMPLE(perceptualSmoothness, _MaskMap, input.texCoord0, a);
+    PROP_SAMPLE(perceptualSmoothness, _MaskMap, layerCoord, a);
 #else
     PROP_ASSIGN_VALUE(perceptualSmoothness, 1.0);
 #endif
     PROP_DECL(float, metallic);
     PROP_DECL(float, ambientOcclusion);
 #ifdef _MASKMAP
-    PROP_SAMPLE(metallic, _MaskMap, input.texCoord0, a);
-    PROP_SAMPLE(ambientOcclusion, _MaskMap, input.texCoord0, g);
+    PROP_SAMPLE(metallic, _MaskMap, layerCoord, a);
+    PROP_SAMPLE(ambientOcclusion, _MaskMap, layerCoord, g);
 #else
     PROP_ASSIGN_VALUE(metallic, 1.0);
     PROP_ASSIGN_VALUE(ambientOcclusion, 1.0);
     PROP_DECL(float3, emissiveColor);
 #ifdef _EMISSIVE_COLOR
 #ifdef _EMISSIVE_COLOR_MAP
-    PROP_SAMPLE(emissiveColor, _EmissiveColorMap, input.texCoord0, rgb);
+    PROP_SAMPLE(emissiveColor, _EmissiveColorMap, layerCoord, rgb);
-    PROP_SAMPLE(emissiveColor, _MaskMap, input.texCoord0, bbb);
+    PROP_SAMPLE(emissiveColor, _MaskMap, layerCoord, bbb);
     PROP_MUL(emissiveColor, baseColor, rgb);
 #else
     PROP_ASSIGN_VALUE(emissiveColor, float3(0.0, 0.0, 0.0));

Assets/ScriptableRenderLoop/ShaderLibrary/API/D3D11.hlsl

 #define UNITY_UV_STARTS_AT_TOP 1
 #define UNITY_REVERSED_Z 1
 #define UNITY_NEAR_CLIP_VALUE (1.0)
+// This value will not go through any matrix projection convertion
+#define UNITY_RAW_FAR_CLIP_VALUE (0.0)
 #define FRONT_FACE_SEMATIC SV_IsFrontFace
 #define FRONT_FACE_TYPE bool
 #define IS_FRONT_VFACE(VAL, FRONT, BACK) ((VAL) ? (FRONT) : (BACK))

Assets/ScriptableRenderLoop/ShaderLibrary/CommonLighting.hlsl

 #ifndef UNITY_COMMON_LIGHTING_INCLUDED
 #define UNITY_COMMON_LIGHTING_INCLUDED
 
+// These clamping function to max of floating point 16 bit are use to prevent INF in code in case of extreme value
+float ClampToFloat16Max(float value)
+{
+    return min(value, 65504.0);
+}
+
+float2 ClampToFloat16Max(float2 value)
+{
+    return min(value, 65504.0);
+}
+
+float3 ClampToFloat16Max(float3 value)
+{
+    return min(value, 65504.0);
+}
+
+float4 ClampToFloat16Max(float4 value)
+{
+    return min(value, 65504.0);
+}
+
 // Ligthing convention
 // Light direction is oriented backward (-Z). i.e in shader code, light direction is -lightData.forward
 

Assets/TestScenes/HDTest/JulienTest.unity

   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &124873435
 BoxCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!64 &399229769
 MeshCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &1181847331
 BoxCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1192842091
 SphereCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!64 &1197900222
 MeshCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!64 &1237103363
 MeshCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &1317825229
 BoxCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &1330031311
 BoxCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!64 &1438296046
 MeshCollider:
   serializedVersion: 7
   m_Type: 1
   m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
-  m_Intensity: 1
+  m_Intensity: 10
   m_Range: 10
   m_SpotAngle: 30
   m_CookieSize: 10
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1893534342
 SphereCollider:

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/Layered.mat

   m_Name: Layered
   m_Shader: {fileID: 4800000, guid: 81d02e8644315b742b154842a3a2f98c, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
-    _EMISSION _LAYEREDLIT_4_LAYER _LAYEREDLIT_4_LAYERS _LAYERMASKMAP _MASKMAP _NORMALMAP
-    _NORMALMAP_TANGENT_SPACE
+    _EMISSION _LAYEREDLIT_4_LAYER _LAYEREDLIT_4_LAYERS _LAYERMASKMAP _LAYER_MAPPING_PLANAR0
+    _LAYER_MAPPING_PLANAR_0 _LAYER_MAPPING_PLANAR_1 _LAYER_MAPPING_UV1_2 _MASKMAP
+    _NORMALMAP _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_CustomRenderQueue: -1
   stringTagMap: {}
     - _HeightScale2: 1
     - _HeightScale3: 1
     - _LayerCount: 4
+    - _LayerMapping0: 2
+    - _LayerMapping1: 2
+    - _LayerMapping2: 1
+    - _LayerMapping3: 0
+    - _LayerSize0: 4
+    - _LayerSize1: 4
+    - _LayerSize2: 1
+    - _LayerSize3: 1
+    - _LayerTiling0: 10
+    - _LayerTiling1: 10
+    - _LayerTiling2: 1
+    - _LayerTiling3: 1
     - _MaterialId: 0
     - _Metalic: 0
     - _Metalic0: 0
     - _BaseColor0: {r: 1, g: 1, b: 1, a: 1}
     - _BaseColor1: {r: 1, g: 1, b: 1, a: 1}
     - _BaseColor2: {r: 1, g: 1, b: 1, a: 1}
-    - _BaseColor3: {r: 0, g: 0, b: 0, a: 1}
+    - _BaseColor3: {r: 1, g: 0, b: 0, a: 1}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ScriptableRenderLoop/HDRenderLoop/Sky.meta

+fileFormatVersion: 2
+guid: d7469c05ebee66f4886264af0ab8bf2a
+folderAsset: yes
+timeCreated: 1479239906
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/Resources.meta

+fileFormatVersion: 2
+guid: 4cdc45a9a65126a42aca158413a5b089
+folderAsset: yes
+timeCreated: 1479239906
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/Resources/SkyHDRI.shader.meta

+fileFormatVersion: 2
+guid: 0e7a148852dbc8f47a32e829517574ff
+timeCreated: 1479239909
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/Resources/SkyHDRI.shader

+Shader "Hidden/HDRenderLoop/SkyHDRI"
+{
+    SubShader
+    {
+        Pass
+        {
+            ZWrite Off
+            Blend SrcAlpha OneMinusSrcAlpha // We will lerp only the values that are valid
+
+            HLSLPROGRAM
+            #pragma target 5.0
+            #pragma only_renderers d3d11 // TEMP: unitl we go futher in dev
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            #include "Common.hlsl"
+            #include "CommonLighting.hlsl"
+        
+            TEXTURECUBE(_Cubemap);
+            SAMPLERCUBE(sampler_Cubemap);
+            float4 _SkyParam; // x exposure, y multiplier, z rotation
+
+            struct Attributes
+            {
+                float3 positionCS : POSITION;
+                float3 eyeVector : NORMAL;
+            };
+
+            struct Varyings
+            {
+                float4 positionCS : SV_POSITION;
+                float3 eyeVector : TEXCOORD0;
+            };
+
+            Varyings Vert(Attributes input)
+            {
+                // TODO: implement SV_vertexID full screen quad
+                Varyings output;
+                output.positionCS = float4(input.positionCS.xy, UNITY_RAW_FAR_CLIP_VALUE
+                    #if UNITY_REVERSED_Z
+                    + 0.000001
+                    #else
+                    - 0.000001
+                    #endif
+                    , 1.0);
+                output.eyeVector = input.eyeVector;
+
+                return output;
+            }
+
+            float4 Frag(Varyings input) : SV_Target
+            {
+                float3 dir = normalize(input.eyeVector);
+
+                // Rotate direction
+                float phi = _SkyParam.z * PI / 180.0; // Convert to radiant
+                float cosPhi, sinPhi;
+                sincos(phi, cosPhi, sinPhi);
+                float3 rotDirX = float3(cosPhi, 0, sinPhi);
+                float3 rotDirY = float3(sinPhi, 0, -cosPhi);                
+                dir = float3(dot(rotDirX, dir), dir.y, dot(rotDirY, dir));
+
+                return ClampToFloat16Max(SAMPLE_TEXTURECUBE_LOD(_Cubemap, sampler_Cubemap, dir, 0) * exp2(_SkyParam.x) * _SkyParam.y);
+            }
+
+            ENDHLSL
+        }
+
+    }
+    Fallback Off
+}