Merge branch 'master' into LayeredLit

# Conflicts:
#	Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitSurfaceData.hlsl

Assets/BasicRenderLoopTutorial/BasicRenderLoop.cs

 using UnityEngine;
 using UnityEngine.Rendering;
 using UnityEngine.Experimental.Rendering;
-using UnityEngine.ScriptableRenderPipeline;
 
 // Very basic scriptable rendering loop example:
 // - Use with BasicRenderLoopShader.shader (the loop expects "BasicPass" pass type to exist)

Assets/Editor/Tests/RenderloopTests/RenderloopTestFixture.cs

-using System;
-using System.Collections.Generic;
-using UnityEngine.ScriptableRenderPipeline;
 
 [ExecuteInEditMode]
 public class RenderLoopTestFixture : RenderPipelineAsset

Assets/Editor/Tests/ShaderGeneratorTests/ShaderGeneratorTests.cs

 using UnityEngine;
 using UnityEditor;
 using UnityEngine.Experimental.Rendering;
-using UnityEngine.Experimental.ScriptableRenderLoop;
+using UnityEditor.Experimental.Rendering;
 
 [TestFixture]
 public class ShaderGeneratorTests

Assets/ScriptableRenderLoop/AdditionalLightData.cs

-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering
 {
     public enum LightArchetype {Punctual, Rectangle, Line};
 
                 return DefaultShadowResolution;
         }
 
-        [RangeAttribute(0.0F, 100.0F)]
+        [Range(0.0F, 100.0F)]
         private float m_innerSpotPercent = 0.0F;
 
         public float GetInnerSpotPercent01()
 
-        [RangeAttribute(0.0F, 1.0F)]
+        [Range(0.0F, 1.0F)]
         public float shadowDimmer = 1.0f;
 
         public bool affectDiffuse = true;
         public bool isDoubleSided = false;
 
-        [RangeAttribute(0.0f, 20.0f)]
+        [Range(0.0f, 20.0f)]
-        [RangeAttribute(0.0f, 20.0f)]
+        [Range(0.0f, 20.0f)]
         public float areaLightWidth = 0.0f;
     }
 }

Assets/ScriptableRenderLoop/Editor/MaterialUpgrader.cs

-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
-namespace UnityEditor.Experimental.ScriptableRenderLoop
+namespace UnityEditor.Experimental.Rendering
 {
     public class MaterialUpgrader
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugViewMaterial.cs

-using UnityEngine;
-
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     namespace Attributes
     {
             BakeDiffuseLighting,
         }
     }
-} // namespace UnityEngine.Experimental.ScriptableRenderLoop
+}

Assets/ScriptableRenderLoop/HDRenderPipeline/Editor/UpgradeStandardShaderMaterials.cs

-using System.Collections;
-using UnityEditor;
-using System;
-using NUnit.Framework;
-namespace UnityEditor.Experimental.ScriptableRenderLoop
+namespace UnityEditor.Experimental.Rendering.HDPipeline
-    public class UpgradeStandardShaderMaterials
+	public class UpgradeStandardShaderMaterials
     {
         static List<MaterialUpgrader> GetHDUpgraders()
         {

Assets/ScriptableRenderLoop/HDRenderPipeline/Editor/HDRenderPipelineMenuItems.cs

 using UnityEngine;
 using UnityEditor;
 
-using UnityEngine.Experimental.ScriptableRenderLoop;
+using UnityEngine.Experimental.Rendering.HDPipeline;
 
 namespace UnityEditor.Experimental.ScriptableRenderLoop
 {
             }
         }
 
-        [UnityEditor.MenuItem("HDRenderLoop/Synchronize all Layered materials")]
+        [UnityEditor.MenuItem("HDRenderPipeline/Synchronize all Layered materials")]
         static void SynchronizeAllLayeredMaterial()
         {
             Object[] materials = Resources.FindObjectsOfTypeAll<Material>();

Assets/ScriptableRenderLoop/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

 
 //using EditorGUIUtility=UnityEditor.EditorGUIUtility;
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [CustomEditor(typeof(HDRenderPipeline))]
     public class HDRenderPipelineInspector : Editor

Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderPipeline.cs

 using UnityEngine.Rendering;
-using UnityEngine.Experimental.Rendering;
-using UnityEngine.ScriptableRenderPipeline;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     public class HDRenderPipelineInstance : RenderPipeline
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/LightDefinition.cs

 using UnityEngine;
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     //-----------------------------------------------------------------------------
     // structure definition
         // Include scale and bias for shadow atlas if any
         public Matrix4x4 worldToShadow;
 
-        public GPULightType lightType;
+        public float unused2;
         public Vector4 invResolution;
     };
 
         public Vector3 offsetLS;
         public float unused2;
     };
-} // namespace UnityEngine.Experimental.ScriptableRenderLoop
+}

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/LightDefinition.cs.hlsl

 struct ShadowData
 {
 	float4x4 worldToShadow;
-	int lightType;
+	float unused2;
 	float4 invResolution;
 };
 
 {
 	return value.worldToShadow;
 }
-int GetLightType(ShadowData value)
-{
-	return value.lightType;
-}
 float GetBias(ShadowData value)
 {
 	return value.bias;
 float GetUnused(ShadowData value)
 {
 	return value.unused;
+}
+float GetUnused2(ShadowData value)
+{
+	return value.unused2;
 }
 float4 GetInvResolution(ShadowData value)
 {

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/LightLoop.cs

 using UnityEngine;
 using UnityEngine.Rendering;
-using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     public class BaseLightLoop
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePass.cs

 using UnityEngine;
-using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     namespace TilePass
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePass.hlsl

 TEXTURECUBE_ARRAY(_CookieCubeTextures);
 SAMPLERCUBE(sampler_CookieCubeTextures);
 
-// Use texture array for reflection
+// Use texture array for reflection (or LatLong 2D array for mobile)
+#ifdef CUBE_ARRAY_NOT_SUPPORTED
+TEXTURE2D_ARRAY(_EnvTextures);
+SAMPLER2D(sampler_EnvTextures);
+#else
+#endif
 
 TEXTURECUBE(_SkyTexture);
 SAMPLERCUBE(sampler_SkyTexture); // NOTE: Sampler could be share here with _EnvTextures. Don't know if the shader compiler will complain...
 // Shadow sampling function
 // ----------------------------------------------------------------------------
 
-float GetPunctualShadowAttenuation(LightLoopContext lightLoopContext, float3 positionWS, int index, float3 L, float2 unPositionSS)
+float GetPunctualShadowAttenuation(LightLoopContext lightLoopContext, uint lightType, float3 positionWS, int index, float3 L, float2 unPositionSS)
-    if (_ShadowDatas[index].lightType == GPULIGHTTYPE_POINT)
+    if (lightType == GPULIGHTTYPE_POINT)
     {
         GetCubeFaceID(L, faceIndex);
     }
 // EnvIndex can also be use to fetch in another array of struct (to  atlas information etc...).
 float4 SampleEnv(LightLoopContext lightLoopContext, int index, float3 texCoord, float lod)
 {
-    lod = min(lod, UNITY_SPECCUBE_LOD_STEPS);
-
+        #ifdef CUBE_ARRAY_NOT_SUPPORTED
+        return SAMPLE_TEXTURE2D_ARRAY_LOD(_EnvTextures, sampler_EnvTextures, DirectionToLatLongCoordinate(texCoord), index, lod);
+        #else
+        #endif
     }
     else // SINGLE_PASS_SAMPLE_SKY
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Builtin/BuiltinData.cs

 //-----------------------------------------------------------------------------
 // structure definition
 //-----------------------------------------------------------------------------
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     namespace Builtin
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

         _NormalMap2("NormalMap2", 2D) = "bump" {}
         _NormalMap3("NormalMap3", 2D) = "bump" {}
 
+        _NormalScale0("_NormalScale0", Range(0.0, 2.0)) = 1
+        _NormalScale1("_NormalScale1", Range(0.0, 2.0)) = 1
+        _NormalScale2("_NormalScale2", Range(0.0, 2.0)) = 1
+        _NormalScale3("_NormalScale3", Range(0.0, 2.0)) = 1
+
         _HeightMap0("HeightMap0", 2D) = "black" {}
         _HeightMap1("HeightMap1", 2D) = "black" {}
         _HeightMap2("HeightMap2", 2D) = "black" {}

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

         protected const string kSpecularOcclusionMap = "_SpecularOcclusionMap";
         protected MaterialProperty normalMap = null;
         protected const string kNormalMap = "_NormalMap";
+        protected MaterialProperty normalScale = null;
+        protected const string kNormalScale = "_NormalScale";
         protected MaterialProperty heightMap = null;
         protected const string kHeightMap = "_HeightMap";
         protected MaterialProperty heightScale = null;
             maskMap = FindProperty(kMaskMap, props);
             specularOcclusionMap = FindProperty(kSpecularOcclusionMap, props);
             normalMap = FindProperty(kNormalMap, props);
+            normalScale = FindProperty(kNormalScale, props);           
             heightMap = FindProperty(kHeightMap, props);
             heightScale = FindProperty(kHeightScale, props);
             heightBias = FindProperty(kHeightBias, props);
             W = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV3) ? 1.0f : 0.0f;
             UVDetailsMappingMask.colorValue = new Color(X, Y, Z, W);
 
-            m_MaterialEditor.ShaderProperty(detailMapMode, Styles.detailMapModeText.text);
+            //m_MaterialEditor.ShaderProperty(detailMapMode, Styles.detailMapModeText.text);
             m_MaterialEditor.ShaderProperty(normalMapSpace, Styles.normalMapSpaceText.text);
             m_MaterialEditor.ShaderProperty(heightMapMode, Styles.heightMapModeText.text);
             m_MaterialEditor.ShaderProperty(emissiveColorMode, Styles.emissiveColorModeText.text);
 
             m_MaterialEditor.TexturePropertySingleLine(Styles.specularOcclusionMapText, specularOcclusionMap);
 
-            m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap);
+            m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap, normalScale);
 
             m_MaterialEditor.TexturePropertySingleLine(Styles.heightMapText, heightMap, heightScale, heightBias);
 
             m_MaterialEditor.ShaderProperty(detailAlbedoScale, Styles.detailAlbedoScaleText);
             m_MaterialEditor.ShaderProperty(detailNormalScale, Styles.detailNormalScaleText);
             m_MaterialEditor.ShaderProperty(detailSmoothnessScale, Styles.detailSmoothnessScaleText);
-            m_MaterialEditor.ShaderProperty(detailHeightScale, Styles.detailHeightScaleText);
-            m_MaterialEditor.ShaderProperty(detailAOScale, Styles.detailAOScaleText);
+            //m_MaterialEditor.ShaderProperty(detailHeightScale, Styles.detailHeightScaleText);
+            //m_MaterialEditor.ShaderProperty(detailAOScale, Styles.detailAOScaleText);
             EditorGUI.indentLevel--;
 
             EditorGUILayout.Space();

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Editor/StandardSpecularToHDLitMaterialUpgrader.cs

-using System;
-namespace UnityEditor.Experimental.ScriptableRenderLoop
+namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
     class StandardSpecularToHDLitMaterialUpgrader : MaterialUpgrader
     {
             RenameColor("_Color", "_BaseColor");
             RenameFloat("_Glossiness", "_Smoothness");
             RenameTexture("_BumpMap", "_NormalMap");
+            RenameFloat("_BumpScale", "_NormalScale");
-
-            //@Seb: Bumpmap scale doesn't exist in new shader
-            //_BumpScale("Scale", Float) = 1.0
 
             // Anything reasonable that can be done here?
             //RenameFloat("_SpecColor", ...);

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Editor/StandardToHDLitMaterialUpgrader.cs

-using System;
-namespace UnityEditor.Experimental.ScriptableRenderLoop
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+
-    class StandardToHDLitMaterialUpgrader : MaterialUpgrader
+	class StandardToHDLitMaterialUpgrader : MaterialUpgrader
     {
         public StandardToHDLitMaterialUpgrader()
         {
             RenameColor("_Color", "_BaseColor");
             RenameFloat("_Glossiness", "_Smoothness");
             RenameTexture("_BumpMap", "_NormalMap");
+            RenameFloat("_BumpScale", "_NormalScale");
             RenameColor("_EmissionColor", "_EmissiveColor");
             RenameFloat("_DetailNormalMapScale", "_DetailNormalScale");
 
             RenameTexture("_DetailNormalMap", "_DetailMap");
-
-            //@Seb: Bumpmap scale doesn't exist in new shader
-            //_BumpScale("Scale", Float) = 1.0
 
             // Metallic uses [Gamma] attribute in standard shader but not in Lit. 
             // @Seb: Should we convert?

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.cs

-using UnityEngine;
-using System;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     namespace Lit
     {
             public void Build()
             {
                 m_InitPreFGD = CreateEngineMaterial("Hidden/HDRenderPipeline/PreIntegratedFGD");
+                // TODO: switch to RGBA64 when it becomes available.
                 m_PreIntegratedFGD = new RenderTexture(128, 128, 0, RenderTextureFormat.ARGBHalf);
 
                 m_LtcGGXMatrix                    = LoadLUT(TextureFormat.RGBAHalf, s_LtcGGXMatrixData);

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.hlsl

     float3 specularFGD; // Store preconvole BRDF for both specular and diffuse
     float diffuseFGD;
 
-    // TODO: if we want we can store ambient occlusion here from SSAO pass for example that can be use for IBL specular occlusion
-    // float ambientOcclusion; // Feed from an ambient occlusion buffer
-
     // area light
     float3x3 ltcXformGGX;                // TODO: make sure the compiler not wasting VGPRs on constants
     float3x3 ltcXformDisneyDiffuse;      // TODO: make sure the compiler not wasting VGPRs on constants
-
-    // Shadow (sampling rotation disc)
-    float2 unPositionSS;
 };
 
 PreLightData GetPreLightData(float3 V, PositionInputs posInput, BSDFData bsdfData)
     float3 iblR = reflect(-V, iblNormalWS);
     preLightData.iblDirWS = GetSpecularDominantDir(bsdfData.normalWS, iblR, bsdfData.roughness);
 
-    // #if SHADERPASS == SHADERPASS_GBUFFER
-    // preLightData.ambientOcclusion = LOAD_TEXTURE2D(_AmbientOcclusion, posInput.unPositionSS).x;
-    // #endif
-
     // Area light specific
     // UVs for sampling the LUTs
     float theta = FastACos(dot(bsdfData.normalWS, V));
     preLightData.ltcGGXFresnelMagnitudeDiff = ltcMagnitude.r;
     preLightData.ltcGGXFresnelMagnitude     = ltcMagnitude.g;
     preLightData.ltcDisneyDiffuseMagnitude  = ltcMagnitude.b;
-
-    // Shadow
-    preLightData.unPositionSS = posInput.unPositionSS;
 
     return preLightData;
 }
     // Maybe always using aniso maybe a win ?
     if (bsdfData.materialId == MATERIALID_LIT_ANISO)
     {
-        float TdotL = saturate(dot(bsdfData.tangentWS, L));
-        float BdotL = saturate(dot(bsdfData.bitangentWS, L));
+        // For anisotropy we must not saturate these values
+        float TdotH = dot(bsdfData.tangentWS, H);
+        float TdotL = dot(bsdfData.tangentWS, L);
+        float BdotH = dot(bsdfData.bitangentWS, H);
+        float BdotL = dot(bsdfData.bitangentWS, L);
 
         #ifdef LIT_USE_BSDF_PRE_LAMBDAV
         Vis = V_SmithJointGGXAnisoLambdaV(  preLightData.TdotV, preLightData.BdotV, preLightData.NdotV, TdotL, BdotL, NdotL,
                                     bsdfData.roughnessT, bsdfData.roughnessB);
         #endif
 
-        // For anisotropy we must not saturate these values
-        float TdotH = dot(bsdfData.tangentWS, H);
-        float BdotH = dot(bsdfData.bitangentWS, H);
         D = D_GGXAniso(TdotH, BdotH, NdotH, bsdfData.roughnessT, bsdfData.roughnessB);
     }
     else
 
     [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0f)
     {
-        float shadowAttenuation = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, preLightData.unPositionSS);
+        float shadowAttenuation = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
 
         illuminance *= shadowAttenuation;
     }
 
     // TODO: measure impact of having all these dynamic branch here and the gain (or not) of testing illuminace > 0
 
+    [branch] if (lightData.IESIndex >= 0 && illuminance > 0.0)
+    {
+        float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
+        float2 sphericalCoord = GetIESTextureCoordinate(lightToWorld, L);
+        illuminance *= SampleIES(lightLoopContext, lightData.IESIndex, sphericalCoord, 0).r;
+    }
+
+    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
+    {
+        float3 offset = float3(0.0, 0.0, 0.0); // GetShadowPosOffset(nDotL, normal);
+        float shadowAttenuation = GetPunctualShadowAttenuation(lightLoopContext, lightData.lightType, positionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
+        shadowAttenuation = lerp(1.0, shadowAttenuation, lightData.shadowDimmer);
+
+        illuminance *= shadowAttenuation;
+    }
+
     [branch] if (lightData.cookieIndex >= 0 && illuminance > 0.0)
     {
         float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
         illuminance *= cookie.a;
     }
 
-    [branch] if (lightData.IESIndex >= 0 && illuminance > 0.0)
-    {
-        float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
-        float2 sphericalCoord = GetIESTextureCoordinate(lightToWorld, L);
-        illuminance *= SampleIES(lightLoopContext, lightData.IESIndex, sphericalCoord, 0).r;
-    }
-
-    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
-    {
-        float3 offset = float3(0.0, 0.0, 0.0); // GetShadowPosOffset(nDotL, normal);
-        float shadowAttenuation = GetPunctualShadowAttenuation(lightLoopContext, positionWS + offset, lightData.shadowIndex, L, preLightData.unPositionSS);
-        shadowAttenuation = lerp(1.0, shadowAttenuation, lightData.shadowDimmer);
-
-        illuminance *= shadowAttenuation;
-    }
-
     [branch] if (illuminance > 0.0)
     {
         BSDF(V, L, positionWS, preLightData, bsdfData, diffuseLighting, specularLighting);
         float lightPdf = 0.0;               // Pdf of the light sample
 
         float2 u = Hammersley2d(i, sampleCount);
-        u = frac(u + randNum + 0.5);
+        u = frac(u + randNum);
 
         float4x4 localToWorld = float4x4(float4(lightData.right, 0.0), float4(lightData.up, 0.0), float4(lightData.forward, 0.0), float4(lightData.positionWS, 1.0));
 
     for (uint i = 0; i < sampleCount; ++i)
     {
         float2 u    = Hammersley2d(i, sampleCount);
-        u           = frac(u + randNum + 0.5);
+        u           = frac(u + randNum);
 
         float3 L;
         float NdotL;
     for (uint i = 0; i < sampleCount; ++i)
     {
         float2 u    = Hammersley2d(i, sampleCount);
-        u           = frac(u + randNum + 0.5);
+        u           = frac(u + randNum);
 
         float3 L;
         float NdotL;
     float3x3 localToWorld = GetLocalFrame(N, tangentX);
     float    NdotV        = GetShiftedNdotV(N, V, false);
     float3   acc          = float3(0.0, 0.0, 0.0);
+
 
     // Add some jittering on Hammersley2d
     float2 randNum  = InitRandom(V.xy * 0.5 + 0.5);
         float2 u    = Hammersley2d(i, sampleCount);
-        u           = frac(u + randNum + 0.5);
+        u           = frac(u + randNum);
 
         float VdotH;
         float NdotL;
         // GGX BRDF
-        if (bsdfData.materialId = MATERIALID_LIT_ANISO)
+        if (bsdfData.materialId == MATERIALID_LIT_ANISO)
         {
             ImportanceSampleAnisoGGX(u, V, N, tangentX, tangentY, bsdfData.roughnessT, bsdfData.roughnessB, NdotV, L, VdotH, NdotL, weightOverPdf);
         }

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.shader

         _SpecularOcclusionMap("SpecularOcclusion", 2D) = "white" {}
 
         _NormalMap("NormalMap", 2D) = "bump" {}
+        _NormalScale("_NormalScale", Range(0.0, 2.0)) = 1
 
         _HeightMap("HeightMap", 2D) = "black" {}
         _HeightScale("Height Scale", Float) = 0.01

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

 
 // TODO: Handle BC5 format, currently this code is for DXT5nm
 // THis function below must call UnpackNormalmapRGorAG
-float3 SampleNormalLayer(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights)
+float3 SampleNormalLayer(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float scale)
 {
     if (layerUV.isTriplanar)
     {
-            val += weights.x * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvYZ));
+            val += weights.x * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvYZ), scale);
-            val += weights.y * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvZX));
+            val += weights.y * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvZX), scale);
-            val += weights.z * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvXY));
+            val += weights.z * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvXY), scale);
-        return UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uv));
+        return UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uv), scale);
-float3 SampleNormalLayerAG(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights)
+float3 SampleNormalLayerAG(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float scale)
 {
     if (layerUV.isTriplanar)
     {
-            val += weights.x * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvYZ));
+            val += weights.x * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvYZ), scale);
-            val += weights.y * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvZX));
+            val += weights.y * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvZX), scale);
-            val += weights.z * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvXY));
+            val += weights.z * UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvXY), scale);
-        return UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uv));
+        return UnpackNormalAG(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uv), scale);
+    }
+}
+
+// This version is for normalmap with RGB encoding only, i.e non encoding. It is necessary to use this abstraction to handle correctly triplanar
+// plus consistent with the normal scale parameter
+float3 SampleNormalLayerRGB(TEXTURE2D_ARGS(layerTex, layerSampler), LayerUV layerUV, float3 weights, float scale)
+{
+    if (layerUV.isTriplanar)
+    {
+        float3 val = float3(0.0, 0.0, 0.0);
+
+        if (weights.x > 0.0)
+            val += weights.x * UnpackNormalRGB(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvYZ), scale);
+        if (weights.y > 0.0)
+            val += weights.y * UnpackNormalRGB(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvZX), scale);
+        if (weights.z > 0.0)
+            val += weights.z * UnpackNormalRGB(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uvXY), scale);
+
+        return normalize(val);
+    }
+    else
+    {
+        return UnpackNormalRGB(SAMPLE_TEXTURE2D(layerTex, layerSampler, layerUV.uv), scale);
-#define SAMPLE_LAYER_NORMALMAP(textureName, samplerName, coord) SampleNormalLayer(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights)
-#define SAMPLE_LAYER_NORMALMAP_AG(textureName, samplerName, coord) SampleNormalLayerAG(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights)
+#define SAMPLE_LAYER_NORMALMAP(textureName, samplerName, coord, scale) SampleNormalLayer(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale)
+#define SAMPLE_LAYER_NORMALMAP_AG(textureName, samplerName, coord, scale) SampleNormalLayerAG(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale)
+#define SAMPLE_LAYER_NORMALMAP_RGB(textureName, samplerName, coord, scale) SampleNormalLayerRGB(TEXTURE2D_PARAM(textureName, samplerName), coord, layerTexCoord.weights, scale)
 
 // Transforms 2D UV by scale/bias property
 #define TRANSFORM_TEX(tex,name) ((tex.xy) * name##_ST.xy + name##_ST.zw)

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitDepthPass.hlsl

     float2 uv0 : TEXCOORD0;
 #endif
 #if NEED_TANGENT_TO_WORLD
+    float3 normalOS  : NORMAL;
     float4 tangentOS : TANGENT;
 #endif
 };
     Varyings output;
 
     float3 positionWS = TransformObjectToWorld(input.positionOS);
-        output.positionCS = TransformWorldToHClip(positionWS);
+    output.positionCS = TransformWorldToHClip(positionWS);
 
 #if NEED_TEXCOORD0
     output.texCoord0 = input.uv0;

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

 
 TEXTURE2D(_NormalMap);
 SAMPLER2D(sampler_NormalMap);
+float _NormalScale;
 
 TEXTURE2D(_DetailMask);
 SAMPLER2D(sampler_DetailMask);
 PROP_DECL_TEX2D(_SpecularOcclusionMap);
 
 PROP_DECL_TEX2D(_NormalMap);
+PROP_DECL(float, _NormalScale);
+
 PROP_DECL_TEX2D(_HeightMap);
 
 PROP_DECL_TEX2D(_DetailMask);

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitSurfaceData.hlsl

     #ifdef _DETAIL_MAP_WITH_NORMAL
     // Resample the detail map but this time for the normal map. This call should be optimize by the compiler
     // We split both call due to trilinear mapping
-    float3 detailNormalTS = SAMPLE_LAYER_NORMALMAP_AG(ADD_IDX(_DetailMap), ADD_ZERO_IDX(sampler_DetailMap), ADD_IDX(layerTexCoord.details));
+    float3 detailNormalTS = SAMPLE_LAYER_NORMALMAP_AG(ADD_IDX(_DetailMap), ADD_ZERO_IDX(sampler_DetailMap), ADD_IDX(layerTexCoord.details), ADD_ZERO_IDX(_DetailNormalScale));
     //float detailAO = 0.0;
     #else
     // TODO: Use heightmap as a derivative with Morten Mikklesen approach, how this work with our abstraction and triplanar ?
     float3 vertexNormalWS = normalize(input.tangentToWorld[2].xyz);
 
 #ifdef _NORMALMAP
-#ifdef _NORMALMAP_TANGENT_SPACE
-        normalTS = SAMPLE_LAYER_NORMALMAP(ADD_IDX(_NormalMap), ADD_ZERO_IDX(sampler_NormalMap), ADD_IDX(layerTexCoord.base));
-#else // Object space
-        // TODO: We are suppose to do * 2 - 1 here. how to deal with triplanar...
-        float3 normalOS = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_NormalMap), ADD_ZERO_IDX(sampler_NormalMap), ADD_IDX(layerTexCoord.base)).rgb * 2.0 - 1.0;
+    #ifdef _NORMALMAP_TANGENT_SPACE
+        normalTS = SAMPLE_LAYER_NORMALMAP(ADD_IDX(_NormalMap), ADD_ZERO_IDX(sampler_NormalMap), ADD_IDX(layerTexCoord.base), ADD_ZERO_IDX(_NormalScale));
+    #else // Object space
+        float3 normalOS = SAMPLE_LAYER_NORMALMAP_RGB(ADD_IDX(_NormalMap), ADD_ZERO_IDX(sampler_NormalMap), ADD_IDX(layerTexCoord.base), ADD_ZERO_IDX(_NormalScale)).rgb;
-    #ifdef _DETAIL_MAP
+        #ifdef _DETAIL_MAP
-    #endif
+        #endif
 #else
     normalTS = float3(0.0, 0.0, 1.0);
 #endif
     // TODO: think about using BC5
 #ifdef _TANGENTMAP
 #ifdef _NORMALMAP_TANGENT_SPACE // Normal and tangent use same space
-    float3 tangentTS = SAMPLE_LAYER_NORMALMAP(ADD_IDX(_TangentMap), ADD_ZERO_IDX(sampler_TangentMap), ADD_IDX(layerTexCoord.base));
+    float3 tangentTS = SAMPLE_LAYER_NORMALMAP(ADD_IDX(_TangentMap), ADD_ZERO_IDX(sampler_TangentMap), ADD_IDX(layerTexCoord.base), 1.0);
-#else // Object space (TODO: We need to apply the world rotation here! - Require to pass world transform)
-    surfaceData.tangentWS = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_TangentMap), ADD_ZERO_IDX(sampler_TangentMap), ADD_IDX(layerTexCoord.base)).rgb;
+#else // Object space
+    float3 tangentOS = SAMPLE_LAYER_NORMALMAP_RGB(ADD_IDX(_TangentMap), ADD_ZERO_IDX(sampler_TangentMap), ADD_IDX(layerTexCoord.base), 1.0).rgb;
+    surfaceData.tangentWS = TransformObjectToWorldDir(tangentOS);
 #endif
 #else
     surfaceData.tangentWS = normalize(input.tangentToWorld[0].xyz);

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LtcData.DisneyDiffuse.cs

 using UnityEngine.Rendering;
 using System;
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     namespace Lit
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LtcData.GGX.cs

 using UnityEngine.Rendering;
 using System;
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     namespace Lit
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Unlit/Unlit.cs

 using UnityEngine;
-using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     namespace Unlit
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/SceneSettings/CommonSettings.cs

 using System.Linq;
 using System.Reflection;
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [ExecuteInEditMode]
     [DisallowMultipleComponent]

Assets/ScriptableRenderLoop/HDRenderPipeline/SceneSettings/Editor/CommonSettingsEditor.cs

 using System.Linq;
 using System.Reflection;
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [CustomEditor(typeof(CommonSettings))]
     [CanEditMultipleObjects]

Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderConfig.cs

 // Configuration
 //-----------------------------------------------------------------------------
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [GenerateHLSL(PackingRules.Exact)]
     public enum ShaderOptions

Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderPass/ShaderPass.cs

 using UnityEngine;
-using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [GenerateHLSL(PackingRules.Exact)]
     public enum ShaderPass

Assets/ScriptableRenderLoop/HDRenderPipeline/Shadow/FixedSizePCF/FixedSizePCF.cs

 using UnityEngine;
-using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     public class ShadowFilteringFixedSizePCF
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/HDRISky/Editor/HDRISkyEditor.cs

 using UnityEngine;
 using UnityEditor;
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [CanEditMultipleObjects]
     [CustomEditor(typeof(HDRISkyParameters))]

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/HDRISky/HDRISkyParameters.cs

 using System.Collections.Generic;
 using UnityEngine;
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [DisallowMultipleComponent]
     public class HDRISkyParameters

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/HDRISky/HDRISkyRenderer.cs

 using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.Rendering;
-using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     public class HDRISkyRenderer
         : SkyRenderer<HDRISkyParameters>

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/ProceduralSky/Editor/ProceduralSkyEditor.cs

 using UnityEngine;
 using UnityEditor;
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     //[CanEditMultipleObjects]
     //[CustomEditor(typeof(ProceduralSkyParameters))]

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/ProceduralSky/ProceduralSkyParameters.cs

 using System.Collections.Generic;
 using UnityEngine;
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [ExecuteInEditMode]
     [DisallowMultipleComponent]

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/ProceduralSky/ProceduralSkyRenderer.cs

 using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.Rendering;
-using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     public class ProceduralSkyRenderer
         : SkyRenderer<ProceduralSkyParameters>

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/SkyManager.cs

 using UnityEngine.Rendering;
-using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [Serializable]
     public enum SkyResolution

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/SkyParameters.cs

 using System.Reflection;
 using System.Linq;
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [ExecuteInEditMode]
     public class SkyParameters : MonoBehaviour

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/SkyRenderer.cs

 using UnityEngine.Rendering;
-using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     abstract public class SkyRenderer
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Utilities.cs

 using System;
 using UnityEngine.Rendering;
-using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [Flags]
     public enum ClearFlag

Assets/ScriptableRenderLoop/RenderPasses/ShadowRenderPass.cs

 using System.Collections.Generic;
 using System;
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering
 {
     [System.Serializable]
     public class ShadowSettings

Assets/ScriptableRenderLoop/ShaderLibrary/BSDF.hlsl

     return PI * g;
 }
 
+// Ref: Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs, p. 19, 29.
+float G_MaskingSmithGGX(float NdotV, float VdotH, float roughness)
+{
+    roughness = max(roughness, UNITY_MIN_ROUGHNESS);
+
+    // G1(V, H)    = HeavisideStep(VdotH) / (1 + Λ(V)).
+    // Λ(V)        = -0.5 + 0.5 * sqrt(1 + 1 / a²).
+    // a           = 1 / (roughness * tan(theta)).
+    // 1 + Λ(V)    = 0.5 + 0.5 * sqrt(1 + roughness² * tan²(theta)).
+    // tan²(theta) = (1 - cos²(theta)) / cos²(theta) = 1 / cos²(theta) - 1.
+
+    float hs = VdotH > 0.0 ? 1.0 : 0.0;
+    float a2 = roughness * roughness;
+    float z2 = NdotV * NdotV;
+
+    return hs / (0.5 + 0.5 * sqrt(1.0 + a2 * (1.0 / z2 - 1.0)));
+}
+
+// Ref: Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs, p. 12.
+float D_GGX_Visible(float NdotH, float NdotV, float VdotH, float roughness)
+{
+    // Note that we pass 1.0 instead of 'VdotH' since the multiplication will already clamp.
+    return D_GGX(NdotH, roughness) * G_MaskingSmithGGX(NdotV, 1.0, roughness) * VdotH / NdotV;
+}
+
 // Ref: http://jcgt.org/published/0003/02/03/paper.pdf
 float V_SmithJointGGX(float NdotL, float NdotV, float roughness)
 {

Assets/ScriptableRenderLoop/ShaderLibrary/Common.hlsl

     float4 t = a; a = b; b = t;
 }
 
+#define CUBEMAPFACE_POSITIVE_X 0
+#define CUBEMAPFACE_NEGATIVE_X 1
+#define CUBEMAPFACE_POSITIVE_Y 2
+#define CUBEMAPFACE_NEGATIVE_Y 3
+#define CUBEMAPFACE_POSITIVE_Z 4
+#define CUBEMAPFACE_NEGATIVE_Z 5
+
 #ifndef INTRINSIC_CUBEMAP_FACE_ID
 // TODO: implement this. Is the reference implementation of cubemapID provide by AMD the reverse of our ?
 /*
     return faceID;
 }
 */
-#endif // INTRINSIC_CUBEMAP_FACE_ID
-
-#define CUBEMAPFACE_POSITIVE_X 0
-#define CUBEMAPFACE_NEGATIVE_X 1
-#define CUBEMAPFACE_POSITIVE_Y 2
-#define CUBEMAPFACE_NEGATIVE_Y 3
-#define CUBEMAPFACE_POSITIVE_Z 4
-#define CUBEMAPFACE_NEGATIVE_Z 5
 
 void GetCubeFaceID(float3 dir, out int faceIndex)
 {
         faceIndex = dir.y > 0.0 ? CUBEMAPFACE_NEGATIVE_Y : CUBEMAPFACE_POSITIVE_Y;
     }
 }
+
+#endif // INTRINSIC_CUBEMAP_FACE_ID
 
 // ----------------------------------------------------------------------------
 // Common math definition and fastmath function
 }
 
 // ----------------------------------------------------------------------------
+// Texture format sampling
+// ----------------------------------------------------------------------------
+
+float2 DirectionToLatLongCoordinate(float3 dir)
+{
+    // coordinate frame is (-Z, X) meaning negative Z is primary axis and X is secondary axis.
+    return float2(1.0 - 0.5 * INV_PI * atan2(dir.x, -dir.z), asin(dir.y) * INV_PI + 0.5);
+}
+
+// ----------------------------------------------------------------------------
-// Z buffer to linear 0..1 depth
+// Z buffer to linear 0..1 depth (0 at near plane, 1 at far plane)
+float Linear01DepthFromNear(float depth, float4 zBufferParam)
+{
+    return 1.0 / (zBufferParam.x + zBufferParam.y / depth);
+}
+
+// Z buffer to linear 0..1 depth (0 at camera position, 1 at far plane)
 float Linear01Depth(float depth, float4 zBufferParam)
 {
     return 1.0 / (zBufferParam.x * depth + zBufferParam.y);

Assets/ScriptableRenderLoop/ShaderLibrary/ImageBasedLighting.hlsl

 
 void ImportanceSampleCosDir(float2   u,
                             float3x3 localToWorld,
-                        out float3   L)
+                        out float3   L,
+                        out float    NdotL)
-    float cosTheta = sqrt(saturate(1.0 - u.x));
+    float cosTheta = sqrt(1.0 - u.x);
-    L = SphericalToCartesian(phi, sinTheta, cosTheta);
-    L = mul(L, localToWorld);
+    float3 localL = SphericalToCartesian(phi, sinTheta, cosTheta);
+
+    NdotL = localL.z;
+
+    L = mul(localL, localToWorld);
 }
 
 void ImportanceSampleGGXDir(float2   u,
                         out float3   L,
+                        out float    NdotL,
                         out float    NdotH,
                         out float    VdotH,
                             bool     VeqN = false)
         VdotH  = saturate(dot(localV, localH));
     }
 
-    // Compute { L = reflect(-localV, localH) }
-    L = -localV + 2.0 * VdotH * localH;
+    // Compute { localL = reflect(-localV, localH) }
+    float3 localL = -localV + 2.0 * VdotH * localH;
+
+    NdotL = localL.z;
-    L = mul(L, localToWorld);
+    L = mul(localL, localToWorld);
 }
 
 // ref: http://blog.selfshadow.com/publications/s2012-shading-course/burley/s2012_pbs_disney_brdf_notes_v3.pdf p26
                          out float    NdotL,
                          out float    weightOverPdf)
 {
-    ImportanceSampleCosDir(u, localToWorld, L);
-
-    NdotL = saturate(dot(localToWorld[2], L));
+    ImportanceSampleCosDir(u, localToWorld, L, NdotL);
 
     // Importance sampling weight for each sample
     // pdf = N.L / PI
                      out float    NdotL,
                      out float    weightOverPdf)
 {
-    float3 H;
-    float  NdotH;
-    ImportanceSampleGGXDir(u, V, localToWorld, roughness, L, NdotH, VdotH);
-
-    NdotL = saturate(dot(localToWorld[2], L));
+    float NdotH;
+    ImportanceSampleGGXDir(u, V, localToWorld, roughness, L, NdotL, NdotH, VdotH);
 
     // Importance sampling weight for each sample
     // pdf = D(H) * (N.H) / (4 * (L.H))
     // weightOverPdf = F(H) * 4 * (N.L) * V(V, L) * (L.H) / (N.H) with V(V, L) = G(V, L) / (4 * (N.L) * (N.V))
     // Remind (L.H) == (V.H)
     // F is apply outside the function
+
+    // For anisotropy we must not saturate these values
-    float TdotL = saturate(dot(tangentX, L));
-    float BdotL = saturate(dot(tangentY, L));
+    float TdotL = dot(tangentX, L);
+    float BdotL = dot(tangentY, L);
 
     float Vis = V_SmithJointGGXAniso(TdotV, BdotV, NdotV, TdotL, BdotL, NdotL, roughnessT, roughnessB);
     weightOverPdf = 4.0 * Vis * NdotL * VdotH / NdotH;
 // Ref: Listing 18 in "Moving Frostbite to PBR" + https://knarkowicz.wordpress.com/2014/12/27/analytical-dfg-term-for-ibl/
 float4 IntegrateGGXAndDisneyFGD(float3 V, float3 N, float roughness, uint sampleCount)
 {
-    float NdotV     = GetShiftedNdotV(N, V, false);
+    float NdotV     = saturate(dot(N, V));
     float4 acc      = float4(0.0, 0.0, 0.0, 0.0);
     // Add some jittering on Hammersley2d
     float2 randNum  = InitRandom(V.xy * 0.5 + 0.5);
         u.x = lerp(u.x, 0.0, bias);
 
         float3 L;
-        float  NdotH, VdotH;
-        ImportanceSampleGGXDir(u, V, localToWorld, roughness, L, NdotH, VdotH, true);
-
-        float NdotL = saturate(dot(N, L));
+        float  NdotL, NdotH, VdotH;
+        ImportanceSampleGGXDir(u, V, localToWorld, roughness, L, NdotL, NdotH, VdotH, true);
 
         float mipLevel;
 

Assets/ScriptableRenderLoop/ShaderLibrary/Packing.hlsl

     return normalize(n);
 }
 
+float3 UnpackNormalRGB(float4 packedNormal, float scale = 1.0)
+{
+    float3 normal;
+    normal.xyz = packedNormal.rgb * 2.0 - 1.0;
+    normal.xy *= scale;
+    return normalize(normal);
+}
+
 float3 UnpackNormalAG(float4 packedNormal, float scale = 1.0)
 {
     float3 normal;
 }
 
 // Unpack normal as DXT5nm (1, y, 0, x) or BC5 (x, y, 0, 1)
-float3 UnpackNormalmapRGorAG(float4 packedNormal)
+float3 UnpackNormalmapRGorAG(float4 packedNormal, float scale = 1.0)
 {
     // This do the trick
     packedNormal.x *= packedNormal.w;
+    normal.xy *= scale;
     normal.z = sqrt(1.0 - saturate(dot(normal.xy, normal.xy)));
     return normal;
 }

Assets/ScriptableRenderLoop/common/TextureSettings.cs

-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering
 {
     [System.Serializable]
     public struct TextureSettings

Assets/ScriptableRenderLoop/core/RenderPipeline.cs

 using System;
-using System.Collections.Generic;
-using UnityEngine.Experimental.Rendering;
-namespace UnityEngine.ScriptableRenderPipeline
+namespace UnityEngine.Experimental.Rendering
 {
     public abstract class RenderPipeline : IRenderPipeline
     {

Assets/ScriptableRenderLoop/fptl/FptlLighting.cs

 using UnityEngine.Rendering;
-using UnityEngine.Experimental.Rendering;
-using UnityEngine.ScriptableRenderPipeline;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering.Fptl
 {
     public class FptlLightingInstance : RenderPipeline
     {

Assets/ScriptableRenderLoop/fptl/LightDefinitions.cs

 using UnityEngine;
-using UnityEngine.Experimental.ScriptableRenderLoop;
+using UnityEngine.Experimental.Rendering;
 
 [GenerateHLSL]
 public struct SFiniteLightData

Assets/ShaderGenerator/Editor/CSharpToHLSL.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using UnityEditor;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEditor.Experimental.Rendering
 {
     public class CSharpToHLSL
     {

Assets/ShaderGenerator/Editor/ShaderGeneratorMenu.cs

-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEditor.Experimental.Rendering
 {
     public class ShaderGeneratorMenu
     {

Assets/ShaderGenerator/Editor/ShaderTypeGeneration.cs

 using System;
 using System.Collections.Generic;
 using System.Reflection;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEditor.Experimental.Rendering
 {
     internal class ShaderTypeGenerator
     {

Assets/ShaderGenerator/ShaderGeneratorAttributes.cs

 using System;
 
-namespace UnityEngine.Experimental.ScriptableRenderLoop
+namespace UnityEngine.Experimental.Rendering
 {
     public enum PackingRules
     {

Assets/TestScenes/HDTest/GlobalIlluminationTest/TestRealtime.cs

-using System.Collections;
-using System.Collections.Generic;
-
-using UnityEngine.Experimental.ScriptableRenderLoop;
+using UnityEngine.Experimental.Rendering.HDPipeline;
 
 public class TestRealtime : MonoBehaviour {
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Editor/HDRenderPipelineMenuItems.cs.meta

+fileFormatVersion: 2
+guid: da95c0a9c012b9643997ec8490107b14
+timeCreated: 1483628158
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/Editor/HDRenderLoopMenuItems.cs.meta

-fileFormatVersion: 2
-guid: 19042aef0dcb65e4496d778558fefad9
-timeCreated: 1481793704
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: