Merge branch 'master' of https://github.com/Unity-Technologies/ScriptableRenderLoop into shadows

Assets/LowEndMobilePipeline/TestScenes/Materials/LegacyMobileMaterials/LegacyMobileColors.mat.meta

   userData: 
   assetBundleName: 
   assetBundleVariant: 
-

Assets/LowEndMobilePipeline/TestScenes/Materials/LegacyMobileMaterials/LegacyMobileGlass.mat.meta

   userData: 
   assetBundleName: 
   assetBundleVariant: 
-

Assets/LowEndMobilePipeline/TestScenes/Materials/LegacyMobileMaterials/LegacyMobilePlane.mat.meta

   userData: 
   assetBundleName: 
   assetBundleVariant: 
-

Assets/ScriptableRenderPipeline/AdditionalLightData.cs

-using UnityEngine;
+using UnityEngine;
-    public enum LightArchetype { Punctual, Rectangle, Line };
+    public enum LightArchetype { Punctual, Area, Projector };
 
     //@TODO: We should continuously move these values
     // into the engine when we can see them being generally useful
         public bool affectSpecular = true;
 
         public LightArchetype archetype = LightArchetype.Punctual;
-        public bool isDoubleSided = false;
+        public bool isDoubleSided = false; // Rectangular area lights only
-        public float areaLightLength = 0.0f;
+        public float lightLength = 0.0f; // Area & projector lights
-        public float areaLightWidth = 0.0f;
+        public float lightWidth  = 0.0f; // Area & projector lights
 
         // shadow related parameters
         [System.Serializable]

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

             // Get attribute to get the start number of the value for the enum
             var attr = attributes[0] as GenerateHLSL;
 
-            if (!attr.needParamDefines)
+            if (!attr.needParamDebug)
             {
                 return;
             }

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

             }
 
             // Broadcast SSS parameters to all shaders.
+            Shader.SetGlobalInt("_EnableSSS", globalDebugSettings.renderingDebugSettings.enableSSS ? 1 : 0);
+            cmd.SetGlobalVectorArray("_TintColors",     sssParameters.tintColors);
-
-            if (globalDebugSettings.renderingDebugSettings.enableSSS)
-            {
-                cmd.EnableShaderKeyword("_SUBSURFACE_SCATTERING");
-            }
-            else
-            {
-                cmd.DisableShaderKeyword("_SUBSURFACE_SCATTERING");
-            }
 
             renderContext.ExecuteCommandBuffer(cmd);
             cmd.Dispose();

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightDefinition.cs

         public int cookieIndex;
 
         public GPULightType lightType;
-        // Area Light specific
-        public Vector2 size; // x = cot(outerHalfAngle) for spot lights
-        public bool twoSided;
+        
+        public Vector2 size;  // Used by area, projector and spot lights; x = cot(outerHalfAngle) for spot lights
+        public bool twoSided; // Used by rectangular area lights only
     };
 
     [GenerateHLSL]

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

 //
 float3 GetPositionWS(LightData value)
 {
-    return value.positionWS;
+	return value.positionWS;
-    return value.invSqrAttenuationRadius;
+	return value.invSqrAttenuationRadius;
-    return value.color;
+	return value.color;
-    return value.angleScale;
+	return value.angleScale;
-    return value.forward;
+	return value.forward;
-    return value.angleOffset;
+	return value.angleOffset;
-    return value.up;
+	return value.up;
-    return value.diffuseScale;
+	return value.diffuseScale;
-    return value.right;
+	return value.right;
-    return value.specularScale;
+	return value.specularScale;
-    return value.shadowDimmer;
+	return value.shadowDimmer;
-    return value.shadowIndex;
+	return value.shadowIndex;
-    return value.IESIndex;
+	return value.IESIndex;
-    return value.cookieIndex;
+	return value.cookieIndex;
-    return value.lightType;
+	return value.lightType;
-    return value.size;
+	return value.size;
-    return value.twoSided;
+	return value.twoSided;
 }
 
 //
 {
-    return value.forward;
+	return value.forward;
-    return value.diffuseScale;
+	return value.diffuseScale;
-    return value.up;
+	return value.up;
-    return value.invScaleY;
+	return value.invScaleY;
-    return value.right;
+	return value.right;
-    return value.invScaleX;
+	return value.invScaleX;
-    return value.positionWS;
+	return value.positionWS;
-    return value.tileCookie;
+	return value.tileCookie;
-    return value.color;
+	return value.color;
-    return value.specularScale;
+	return value.specularScale;
-    return value.cosAngle;
+	return value.cosAngle;
-    return value.sinAngle;
+	return value.sinAngle;
-    return value.shadowIndex;
+	return value.shadowIndex;
-    return value.cookieIndex;
+	return value.cookieIndex;
 }
 
 //
 {
-    return value.worldToShadow;
+	return value.worldToShadow;
-    return value.bias;
+	return value.bias;
-    return value.quality;
+	return value.quality;
-    return value.unused;
+	return value.unused;
-    return value.unused2;
+	return value.unused2;
-    return value.invResolution;
+	return value.invResolution;
 }
 
 //
 {
-    return value.positionWS;
+	return value.positionWS;
-    return value.envShapeType;
+	return value.envShapeType;
-    return value.forward;
+	return value.forward;
-    return value.envIndex;
+	return value.envIndex;
-    return value.up;
+	return value.up;
-    return value.blendDistance;
+	return value.blendDistance;
-    return value.right;
+	return value.right;
-    return value.unused0;
+	return value.unused0;
-    return value.innerDistance;
+	return value.innerDistance;
-    return value.unused1;
+	return value.unused1;
-    return value.offsetLS;
+	return value.offsetLS;
-    return value.unused2;
+	return value.unused2;
 }
 
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/FeatureFlags.hlsl

 
 static const uint FeatureVariantFlags[NUM_FEATURE_VARIANTS] =
 {
-/* 0 */ 0 | FEATURE_FLAG_ALL_MATERIALS,
-/* 1 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
-/* 2 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
-/* 3 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
-/* 3 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
-/* 5 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
-/* 6 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
-/* 7 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_ALL_MATERIALS,
-/* 8 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_ALL_MATERIALS,
-/* 9 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_ALL_MATERIALS,
-/*10 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_ALL_MATERIALS,
-/*11 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_ALL_MATERIALS,
-/*12 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_ALL_MATERIALS,
-/*13 */ 0xFFFFFFFF,
-/*14 */ 0xFFFFFFFF,
-/*15 */ 0xFFFFFFFF,
+/*  0 */ 0 | FEATURE_FLAG_ALL_MATERIALS,
+/*  1 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
+/*  2 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
+/*  3 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
+/*  3 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
+/*  5 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
+/*  6 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
+/*  7 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_LIGHT_PROJECTOR | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
+/*  8 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_ALL_MATERIALS,
+/*  9 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_ALL_MATERIALS,
+/* 10 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_ALL_MATERIALS,
+/* 11 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_ALL_MATERIALS,
+/* 12 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_ALL_MATERIALS,
+/* 13 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_ALL_MATERIALS,
+/* 14 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_LIGHT_PROJECTOR |  FEATURE_FLAG_ALL_MATERIALS,
+/* 15 */ 0xFFFFFFFF
 };
 
 uint FeatureFlagsToTileVariant(uint featureFlags)

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Resources/lightlistbuild-clustered.compute

 
 	// All our cull data are in the same list, but at render time envLights are separated so we need to shit the index
 	// to make it work correctly
-	int shiftIndex[LIGHTCATEGORY_COUNT] = {0, 0, _EnvLightIndexShift}; // 3 for now, will throw an error if we change LIGHTCATEGORY_COUNT
+	int shiftIndex[LIGHTCATEGORY_COUNT];
+	ZERO_INITIALIZE_ARRAY(int, shiftIndex, LIGHTCATEGORY_COUNT);
+	shiftIndex[LIGHTCATEGORY_COUNT - 1] = _EnvLightIndexShift;
-	int categoryListCount[LIGHTCATEGORY_COUNT]={0,0,0};		// direct light count and reflection lights
+	int categoryListCount[LIGHTCATEGORY_COUNT]; // direct light count and reflection lights
+	ZERO_INITIALIZE_ARRAY(int, categoryListCount, LIGHTCATEGORY_COUNT);
 	uint offs = start;
 	for(int ll=0; ll<iNrCoarseLights; ll+=4)
 	{

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Resources/lightlistbuild.compute

 #endif
 groupshared int ldsNrLightsFinal;
 
-groupshared int ldsCategoryListCount[LIGHTCATEGORY_COUNT];		// since LIGHTCATEGORY_COUNT is 3
+groupshared int ldsCategoryListCount[LIGHTCATEGORY_COUNT];
 
 #ifdef PERFORM_SPHERICAL_INTERSECTION_TESTS
 groupshared uint lightOffsSph;
 
 	// All our cull data are in the same list, but at render time envLights are separated so we need to shit the index
 	// to make it work correctly
-	int shiftIndex[LIGHTCATEGORY_COUNT] = {0, 0, _EnvLightIndexShift}; // 3 for now, will throw an error if we change LIGHTCATEGORY_COUNT
+	int shiftIndex[LIGHTCATEGORY_COUNT];
+	ZERO_INITIALIZE_ARRAY(int, shiftIndex, LIGHTCATEGORY_COUNT);
+	shiftIndex[LIGHTCATEGORY_COUNT - 1] = _EnvLightIndexShift;
 
 	for(int category=0; category<LIGHTCATEGORY_COUNT; category++)
 	{

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

         {
             Punctual,
             Area,
+            Projector,
             Env,
             Count
         }
         {
-            public static uint FEATURE_FLAG_LIGHT_PUNCTUAL = 1 << 0;
-            public static uint FEATURE_FLAG_LIGHT_AREA = 1 << 1;
+            public static uint FEATURE_FLAG_LIGHT_PUNCTUAL    = 1 << 0;
+            public static uint FEATURE_FLAG_LIGHT_AREA        = 1 << 1;
-            public static uint FEATURE_FLAG_LIGHT_ENV = 1 << 3;
-            public static uint FEATURE_FLAG_LIGHT_SKY = 1 << 4;
+            public static uint FEATURE_FLAG_LIGHT_PROJECTOR   = 1 << 3;
+            public static uint FEATURE_FLAG_LIGHT_ENV         = 1 << 4;
+            public static uint FEATURE_FLAG_LIGHT_SKY         = 1 << 5;
         }
 
         [GenerateHLSL]
 
         public class LightLoop : BaseLightLoop
         {
-            public const int k_MaxDirectionalLightsOnScreen = 10;
-            public const int k_MaxPunctualLightsOnScreen = 512;
-            public const int k_MaxAreaLightsOnSCreen = 128;
-            public const int k_MaxLightsOnScreen = k_MaxDirectionalLightsOnScreen + k_MaxPunctualLightsOnScreen + k_MaxAreaLightsOnSCreen;
+            public const int k_MaxDirectionalLightsOnScreen = 4;
+            public const int k_MaxPunctualLightsOnScreen    = 512;
+            public const int k_MaxAreaLightsOnScreen        = 64;
+            public const int k_MaxProjectorLightsOnScreen   = 64;
+            public const int k_MaxLightsOnScreen = k_MaxDirectionalLightsOnScreen + k_MaxPunctualLightsOnScreen + k_MaxAreaLightsOnScreen + k_MaxProjectorLightsOnScreen;
             public const int k_MaxEnvLightsOnScreen = 64;
             public const int k_MaxShadowOnScreen = 16;
             public const int k_MaxCascadeCount = 4; //Should be not less than m_Settings.directionalLightCascadeCount;
             LightList m_lightList;
             int m_punctualLightCount = 0;
             int m_areaLightCount = 0;
+            int m_projectorLightCount = 0;
             int m_lightCount = 0;
 
             private ComputeShader buildScreenAABBShader { get { return m_PassResources.buildScreenAABBShader; } }
                 m_lightList.Allocate();
 
                 s_DirectionalLightDatas = new ComputeBuffer(k_MaxDirectionalLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalLightData)));
-                s_LightDatas = new ComputeBuffer(k_MaxPunctualLightsOnScreen + k_MaxAreaLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
+                s_LightDatas = new ComputeBuffer(k_MaxPunctualLightsOnScreen + k_MaxAreaLightsOnScreen + k_MaxProjectorLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
                 s_EnvLightDatas = new ComputeBuffer(k_MaxEnvLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(EnvLightData)));
                 s_shadowDatas = new ComputeBuffer(k_MaxCascadeCount + k_MaxShadowOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(ShadowData)));
 
                 m_CubeCookieTexArray.AllocTextureArray(4, textureSettings.pointCookieSize, TextureFormat.RGBA32, true);
                 m_CubeReflTexArray = new TextureCacheCubemap();
-                m_CubeReflTexArray.AllocTextureArray(32, textureSettings.reflectionCubemapSize, TextureCache.GetPreferredCompressedTextureFormat, true);
+                m_CubeReflTexArray.AllocTextureArray(32, textureSettings.reflectionCubemapSize, TextureCache.GetPreferredHdrCompressedTextureFormat, true);
 
                 s_GenAABBKernel = buildScreenAABBShader.FindKernel("ScreenBoundsAABB");
 
                             lightData.cookieIndex = m_CubeCookieTexArray.FetchSlice(light.light.cookie);
                             break;
                     }
+
+                    if (additionalData.archetype == LightArchetype.Projector)
+                    {
+                        lightData.cookieIndex = m_CookieTexArray.FetchSlice(light.light.cookie);
+                    }
                 }
                 float shadowDistanceFade = ComputeLinearDistanceFade(distanceToCamera, additionalData.shadowFadeDistance);
                 lightData.shadowDimmer = additionalData.shadowDimmer * shadowDistanceFade;
                 if (additionalData.archetype != LightArchetype.Punctual)
                 {
                     lightData.twoSided = additionalData.isDoubleSided;
-                    lightData.size = new Vector2(additionalData.areaLightLength, additionalData.areaLightWidth);
+                    lightData.size = new Vector2(additionalData.lightLength, additionalData.lightWidth);
                 }
 
                 m_lightList.lights.Add(lightData);
                 lightVolumeData.lightCategory = (uint)lightCategory;
                 lightVolumeData.lightVolume = (uint)lightVolumeType;
 
-                if (gpuLightType == GPULightType.Spot)
+                if (gpuLightType == GPULightType.Spot || gpuLightType == GPULightType.ProjectorPyramid)
-                    Vector3 lightDir = lightToWorld.GetColumn(2);   // Z axis in world space
+                    Vector3 lightDir = lightToWorld.GetColumn(2);
-                    var vz = lightDir;                      // Z axis in world space
+                    Vector3 vz = lightDir;                      // Z axis in world space
 
                     // transform to camera space (becomes a left hand coordinate frame in Unity since Determinant(worldToView)<0)
                     vx = worldToView.MultiplyVector(vx);
                     const float degToRad = (float)(pi / 180.0);
 
                     var sa = light.light.spotAngle;
-
+                    if (gpuLightType == GPULightType.ProjectorPyramid)
+                    {
+                        Vector3 lightPosToProjWindowCorner = (0.5f * lightData.size.x) * vx + (0.5f * lightData.size.y) * vy + 1.0f * vz;
+                        cs = Vector3.Dot(vz, Vector3.Normalize(lightPosToProjWindowCorner));
+                        si = Mathf.Sqrt(1.0f - cs * cs);
+                    }
+
                     const float FltMax = 3.402823466e+38F;
                     var ta = cs > 0.0f ? (si / cs) : FltMax;
                     var cota = si > 0.0f ? (cs / si) : FltMax;
 
                     fAltDx *= range; fAltDy *= range;
 
-                    // Handle case of pyramid with this select
-                    var altDist = Mathf.Sqrt(fAltDy * fAltDy + (gpuLightType == GPULightType.Spot ? 1.0f : 2.0f) * fAltDx * fAltDx);
+                    // Handle case of pyramid with this select (currently unused)
+                    var altDist = Mathf.Sqrt(fAltDy * fAltDy + (true ? 1.0f : 2.0f) * fAltDx * fAltDx);
                     bound.radius = altDist > (0.5f * range) ? altDist : (0.5f * range);       // will always pick fAltDist
                     bound.scaleXY = squeeze ? new Vector2(0.01f, 0.01f) : new Vector2(1.0f, 1.0f);
 
                     lightVolumeData.lightPos = worldToView.MultiplyPoint(lightPos);
                     lightVolumeData.radiusSq = range * range;
                     lightVolumeData.cotan = cota;
-                    lightVolumeData.featureFlags = LightFeatureFlags.FEATURE_FLAG_LIGHT_PUNCTUAL;
+                    lightVolumeData.featureFlags = (gpuLightType == GPULightType.Spot) ? LightFeatureFlags.FEATURE_FLAG_LIGHT_PUNCTUAL
+                                                                                       : LightFeatureFlags.FEATURE_FLAG_LIGHT_PROJECTOR;
                 }
                 else if (gpuLightType == GPULightType.Point)
                 {
 
                     if (!lightData.twoSided)
                     {
-                        centerVS -= zAxisVS * radius * 0.5f;
+                        centerVS += zAxisVS * radius * 0.5f;
                         dimensions.z *= 0.5f;
                     }
 
                     lightVolumeData.boxInvRange.Set(1.0f / radius, 1.0f / radius, 1.0f / radius);
                     lightVolumeData.featureFlags = LightFeatureFlags.FEATURE_FLAG_LIGHT_AREA;
                 }
+                else if (gpuLightType == GPULightType.ProjectorOrtho)
+                {
+                    Vector3 posVS   = worldToView.MultiplyPoint(lightData.positionWS);
+                    Vector3 xAxisVS = worldToView.MultiplyVector(lightData.right);
+                    Vector3 yAxisVS = worldToView.MultiplyVector(lightData.up);
+                    Vector3 zAxisVS = worldToView.MultiplyVector(lightData.forward);
+
+                    // Projector lights point forwards (along Z). The projection window is aligned with the XY plane.
+                    Vector3 boxDims  = new Vector3(lightData.size.x, lightData.size.y, 1000000.0f);
+                    Vector3 halfDims = 0.5f * boxDims;
+
+                    bound.center   = posVS;
+                    bound.boxAxisX = halfDims.x * xAxisVS;                                                    // Should this be halved or not?
+                    bound.boxAxisY = halfDims.y * yAxisVS;                                                    // Should this be halved or not?
+                    bound.boxAxisZ = halfDims.z * zAxisVS;                                                    // Should this be halved or not?
+                    bound.radius   = halfDims.magnitude;                                                      // Radius of a circumscribed sphere?
+                    bound.scaleXY.Set(1.0f, 1.0f);
+
+                    lightVolumeData.lightPos     = posVS;                                                     // Is this the center of the volume?
+                    lightVolumeData.lightAxisX   = xAxisVS;
+                    lightVolumeData.lightAxisY   = yAxisVS;
+                    lightVolumeData.lightAxisZ   = zAxisVS;
+                    lightVolumeData.boxInnerDist = halfDims;                                                  // No idea what this is. Document your code
+                    lightVolumeData.boxInvRange.Set(1.0f / halfDims.x, 1.0f / halfDims.y, 1.0f / halfDims.z); // No idea what this is. Document your code
+                    lightVolumeData.featureFlags = LightFeatureFlags.FEATURE_FLAG_LIGHT_PROJECTOR;
+                }
-                    // TODO implement unsupported type
-                    Debug.Assert(false);
+                    Debug.Assert(false, "TODO: encountered an unknown GPULightType.");
                 }
 
                 m_lightList.bounds.Add(bound);
                 if (cullResults.visibleLights.Length != 0 || cullResults.visibleReflectionProbes.Length != 0)
                 {
 #if !SHADOWS_OLD
-                // 0. deal with shadows
-                {
-                    m_FrameId.frameCount++;
-                    // get the indices for all lights that want to have shadows
-                    m_ShadowRequests.Clear();
-                    m_ShadowRequests.Capacity = cullResults.visibleLights.Length;
-                    int lcnt = cullResults.visibleLights.Length;
-                    for (int i = 0; i < lcnt; ++i)
+                    // 0. deal with shadows
-                        VisibleLight vl = cullResults.visibleLights[i];
-                        AdditionalLightData ald = vl.light.GetComponent<AdditionalLightData>();
-                        if( vl.light.shadows != LightShadows.None && ald != null && ald.shadowDimmer > 0.0f )
-                            m_ShadowRequests.Add( i );
-                    }
-                    // pass this list to a routine that assigns shadows based on some heuristic
-                    uint    shadowRequestCount = (uint)m_ShadowRequests.Count;
-                    int[]   shadowRequests = m_ShadowRequests.ToArray();
-                    int[]   shadowDataIndices;
-                    uint    originalRequestCount = shadowRequestCount;
-                    m_ShadowMgr.ProcessShadowRequests(m_FrameId, cullResults, camera, cullResults.visibleLights,
-                        ref shadowRequestCount, shadowRequests, out shadowDataIndices);
+                        m_FrameId.frameCount++;
+                        // get the indices for all lights that want to have shadows
+                        m_ShadowRequests.Clear();
+                        m_ShadowRequests.Capacity = cullResults.visibleLights.Length;
+                        int lcnt = cullResults.visibleLights.Length;
+                        for (int i = 0; i < lcnt; ++i)
+                        {
+                            VisibleLight vl = cullResults.visibleLights[i];
+                            AdditionalLightData ald = vl.light.GetComponent<AdditionalLightData>();
+                            if( vl.light.shadows != LightShadows.None && ald != null && ald.shadowDimmer > 0.0f )
+                                m_ShadowRequests.Add( i );
+                        }
+                        // pass this list to a routine that assigns shadows based on some heuristic
+                        uint    shadowRequestCount = (uint)m_ShadowRequests.Count;
+                        int[]   shadowRequests = m_ShadowRequests.ToArray();
+                        int[]   shadowDataIndices;
+                        uint    originalRequestCount = shadowRequestCount;
+                        m_ShadowMgr.ProcessShadowRequests(m_FrameId, cullResults, camera, cullResults.visibleLights,
+                            ref shadowRequestCount, shadowRequests, out shadowDataIndices);
-                    // update the visibleLights with the shadow information
-                    m_ShadowIndices.Clear();
-                    for (uint i = 0; i < shadowRequestCount; i++)
-                    {
-                        m_ShadowIndices.Add(shadowRequests[i], shadowDataIndices[i]);
+                        // update the visibleLights with the shadow information
+                        m_ShadowIndices.Clear();
+                        for (uint i = 0; i < shadowRequestCount; i++)
+                        {
+                            m_ShadowIndices.Add(shadowRequests[i], shadowDataIndices[i]);
+                        }
-                }
 #endif
                     float oldSpecularGlobalDimmer = m_PassSettings.specularGlobalDimmer;
                     // Change some parameters in case of "special" rendering (can be preview, reflection, etc.
                     int directionalLightcount = 0;
                     int punctualLightcount = 0;
                     int areaLightCount = 0;
+                    int projectorLightCount = 0;
 
                     int lightCount = Math.Min(cullResults.visibleLights.Length, k_MaxLightsOnScreen);
                     var sortKeys = new uint[lightCount];
                         GPULightType gpuLightType = GPULightType.Point;
                         LightVolumeType lightVolumeType = LightVolumeType.Count;
 
-                        // Note: LightType.Area is offline only, use for baking, no need to test it
-                        if (additionalData.archetype == LightArchetype.Punctual)
+                    // Note: LightType.Area is offline only, use for baking, no need to test it
+                    if (additionalData.archetype == LightArchetype.Punctual)
+                    {
+                        switch (light.lightType)
-                            switch (light.lightType)
-                            {
-                                case LightType.Point:
-                                    if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
-                                        continue;
-                                    lightCategory = LightCategory.Punctual;
-                                    gpuLightType = GPULightType.Point;
-                                    lightVolumeType = LightVolumeType.Sphere;
-                                    break;
-
-                                case LightType.Spot:
-                                    if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
-                                        continue;
-                                    lightCategory = LightCategory.Punctual;
-                                    gpuLightType = GPULightType.Spot;
-                                    lightVolumeType = LightVolumeType.Cone;
-                                    break;
+                            case LightType.Point:
+                                if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
+                                    continue;
+                                lightCategory = LightCategory.Punctual;
+                                gpuLightType = GPULightType.Point;
+                                lightVolumeType = LightVolumeType.Sphere;
+                                break;
-                                case LightType.Directional:
-                                    if (directionalLightcount >= k_MaxDirectionalLightsOnScreen)
-                                        continue;
-                                    lightCategory = LightCategory.Punctual;
-                                    gpuLightType = GPULightType.Directional;
-                                    // No need to add volume, always visible
-                                    lightVolumeType = LightVolumeType.Count; // Count is none
-                                    break;
+                            case LightType.Spot:
+                                if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
+                                    continue;
+                                lightCategory = LightCategory.Punctual;
+                                gpuLightType = GPULightType.Spot;
+                                lightVolumeType = LightVolumeType.Cone;
+                                break;
-                                default:
+                            case LightType.Directional:
+                                if (directionalLightcount >= k_MaxDirectionalLightsOnScreen)
-                            }
+                                lightCategory = LightCategory.Punctual;
+                                gpuLightType = GPULightType.Directional;
+                                // No need to add volume, always visible
+                                lightVolumeType = LightVolumeType.Count; // Count is none
+                                break;
+
+                            default:
+                                Debug.Assert(false, "TODO: encountered an unknown LightType.");
+                                break;
-                        else
+                    }
+                    else
+                    {
+                        switch (additionalData.archetype)
-                            switch (additionalData.archetype)
-                            {
-                                case LightArchetype.Rectangle:
-                                    if (areaLightCount >= k_MaxAreaLightsOnSCreen)
-                                        continue;
-                                    lightCategory = LightCategory.Area;
-                                    gpuLightType = GPULightType.Rectangle;
-                                    lightVolumeType = LightVolumeType.Box;
-                                    break;
-
-                                case LightArchetype.Line:
-                                    if (areaLightCount >= k_MaxAreaLightsOnSCreen)
-                                        continue;
-                                    lightCategory = LightCategory.Area;
-                                    gpuLightType = GPULightType.Line;
-                                    lightVolumeType = LightVolumeType.Box;
-                                    break;
-
-                                default:
-                                    continue;
-                            }
+                            case LightArchetype.Area:
+                                if (areaLightCount >= k_MaxAreaLightsOnScreen) { continue; }
+                                lightCategory   = LightCategory.Area;
+                                gpuLightType    = (additionalData.lightWidth > 0) ? GPULightType.Rectangle : GPULightType.Line;
+                                lightVolumeType = LightVolumeType.Box;
+                                break;
+                            case LightArchetype.Projector:
+                                if (projectorLightCount >= k_MaxProjectorLightsOnScreen) { continue; }
+                                lightCategory = LightCategory.Projector;
+                                switch (light.lightType)
+                                {
+                                    case LightType.Directional:
+                                        gpuLightType    = GPULightType.ProjectorOrtho;
+                                        lightVolumeType = LightVolumeType.Box;
+                                        break;
+                                    case LightType.Spot:
+                                        gpuLightType    = GPULightType.ProjectorPyramid;
+                                        lightVolumeType = LightVolumeType.Cone;
+                                        break;
+                                    default:
+                                        Debug.Assert(false, "Projectors can only be Spot or Directional lights.");
+                                        break;
+                                }
+                                break;
+                            default:
+                                Debug.Assert(false, "TODO: encountered an unknown LightArchetype.");
+                                break;
+                    }
 
 #if SHADOWS_OLD
                     // 5 bit (0x1F) light category, 5 bit (0x1F) GPULightType, 6 bit (0x3F) lightVolume, 16 bit index
 
                     Array.Sort(sortKeys);
 
-                // TODO: Refactor shadow management
-                // The good way of managing shadow:
-                // Here we sort everyone and we decide which light is important or not (this is the responsibility of the lightloop)
-                // we allocate shadow slot based on maximum shadow allowed on screen and attribute slot by bigger solid angle
-                // THEN we ask to the ShadowRender to render the shadow, not the reverse as it is today (i.e render shadow than expect they
-                // will be use...)
-                // The lightLoop is in charge, not the shadow pass.
-                // For now we will still apply the maximum of shadow here but we don't apply the sorting by priority + slot allocation yet
+                    // TODO: Refactor shadow management
+                    // The good way of managing shadow:
+                    // Here we sort everyone and we decide which light is important or not (this is the responsibility of the lightloop)
+                    // we allocate shadow slot based on maximum shadow allowed on screen and attribute slot by bigger solid angle
+                    // THEN we ask to the ShadowRender to render the shadow, not the reverse as it is today (i.e render shadow than expect they
+                    // will be use...)
+                    // The lightLoop is in charge, not the shadow pass.
+                    // For now we will still apply the maximum of shadow here but we don't apply the sorting by priority + slot allocation yet
-                int directionalShadowcount = 0;
-                int shadowCount = 0;
+                    int directionalShadowcount = 0;
+                    int shadowCount = 0;
-                m_CurrentSunLight = null;
+                    m_CurrentSunLight = null;
 
                     // 2. Go thought all lights, convert them to GPU format.
                     // Create simultaneously data for culling (LigthVolumeData and rendering)
                         LightCategory lightCategory = (LightCategory)((sortKey >> 27) & 0x1F);
                         GPULightType gpuLightType = (GPULightType)((sortKey >> 22) & 0x1F);
 #if SHADOWS_OLD
-                    LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 16) & 0x3F);
+                        LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 16) & 0x3F);
-                    LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 17) & 0x1F);
+                        LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 17) & 0x1F);
 #endif
                         int lightIndex = (int)(sortKey & 0xFFFF);
 
 #else
                         if(GetLightData(shadowSettings, camera, gpuLightType, light, additionalData, lightIndex))
 #endif
+                        // Punctual, area, projector lights - the rendering side.
-                            if (lightCategory == LightCategory.Punctual)
-                                punctualLightcount++;
-                            else if (lightCategory == LightCategory.Area)
-                                areaLightCount++;
-                            else
-                                Debug.Assert(false); // Should not be anything else here.
+                            switch (lightCategory)
+                            {
+                                case LightCategory.Punctual:
+                                    punctualLightcount++;
+                                    break;
+                                case LightCategory.Area:
+                                    areaLightCount++;
+                                    break;
+                                case LightCategory.Projector:
+                                    projectorLightCount++;
+                                    break;
+                                default:
+                                    Debug.Assert(false, "TODO: encountered an unknown LightCategory.");
+                                    break;
+                            }
+
                             // Then culling side. Must be call in this order as we pass the created Light data to the function
                             GetLightVolumeDataAndBound(lightCategory, gpuLightType, lightVolumeType, light, m_lightList.lights[m_lightList.lights.Count - 1], worldToView);
                         }
                     Debug.Assert(m_lightList.directionalLights.Count == directionalLightcount);
-                    Debug.Assert(m_lightList.lights.Count == areaLightCount + punctualLightcount);
-                    m_areaLightCount = areaLightCount;
-                    m_punctualLightCount = punctualLightcount;
+                    Debug.Assert(m_lightList.lights.Count == areaLightCount + punctualLightcount + projectorLightCount);
+
+                    m_punctualLightCount  = punctualLightcount;
+                    m_areaLightCount      = areaLightCount;
+                    m_projectorLightCount = projectorLightCount;
 
                     // Redo everything but this time with envLights
                     int envLightCount = 0;
                 SetGlobalBuffer("_LightDatas", s_LightDatas);
                 SetGlobalInt("_PunctualLightCount", m_punctualLightCount);
                 SetGlobalInt("_AreaLightCount", m_areaLightCount);
+                SetGlobalInt("_ProjectorLightCount", m_projectorLightCount);
                 SetGlobalBuffer("_EnvLightDatas", s_EnvLightDatas);
                 SetGlobalInt("_EnvLightCount", m_lightList.envLights.Count);
                 SetGlobalBuffer("_ShadowDatas", s_shadowDatas);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs.hlsl

 //
 #define LIGHTCATEGORY_PUNCTUAL (0)
 #define LIGHTCATEGORY_AREA (1)
-#define LIGHTCATEGORY_ENV (2)
-#define LIGHTCATEGORY_COUNT (3)
+#define LIGHTCATEGORY_PROJECTOR (2)
+#define LIGHTCATEGORY_ENV (3)
+#define LIGHTCATEGORY_COUNT (4)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.TilePass.LightFeatureFlags:  static fields
 #define FEATURE_FLAG_LIGHT_DIRECTIONAL (4)
-#define FEATURE_FLAG_LIGHT_ENV (8)
-#define FEATURE_FLAG_LIGHT_SKY (16)
+#define FEATURE_FLAG_LIGHT_PROJECTOR (8)
+#define FEATURE_FLAG_LIGHT_ENV (16)
+#define FEATURE_FLAG_LIGHT_SKY (32)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.TilePass.LightDefinitions:  static fields
 //
 float3 GetBoxAxisX(SFiniteLightBound value)
 {
-    return value.boxAxisX;
+	return value.boxAxisX;
-    return value.boxAxisY;
+	return value.boxAxisY;
-    return value.boxAxisZ;
+	return value.boxAxisZ;
-    return value.center;
+	return value.center;
-    return value.scaleXY;
+	return value.scaleXY;
-    return value.radius;
+	return value.radius;
 }
 
 //
 {
-    return value.lightPos;
+	return value.lightPos;
-    return value.lightVolume;
+	return value.lightVolume;
-    return value.lightAxisX;
+	return value.lightAxisX;
-    return value.lightCategory;
+	return value.lightCategory;
-    return value.lightAxisY;
+	return value.lightAxisY;
-    return value.radiusSq;
+	return value.radiusSq;
-    return value.lightAxisZ;
+	return value.lightAxisZ;
-    return value.cotan;
+	return value.cotan;
-    return value.boxInnerDist;
+	return value.boxInnerDist;
-    return value.featureFlags;
+	return value.featureFlags;
-    return value.boxInvRange;
+	return value.boxInvRange;
-    return value.unused2;
+	return value.unused2;
 }
 
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.hlsl

 #define PROCESS_DIRECTIONAL_LIGHT
 #define PROCESS_PUNCTUAL_LIGHT
 #define PROCESS_AREA_LIGHT
+#define PROCESS_PROJECTOR_LIGHT
 #endif
 
 #if defined (LIGHTLOOP_TILE_INDIRECT) || defined(LIGHTLOOP_TILE_ALL)
 uint _DirectionalLightCount;
 uint _PunctualLightCount;
 uint _AreaLightCount;
+uint _ProjectorLightCount;
 uint _EnvLightCount;
 float4 _DirShadowSplitSpheres[4]; // TODO: share this max between C# and hlsl
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePassLoop.hlsl

     }
 #endif
 
+#ifdef PROCESS_PROJECTOR_LIGHT
+    if(featureFlags & FEATURE_FLAG_LIGHT_PROJECTOR)
+    {
+        // TODO: Convert the for loop below to a while on each type as we know we are sorted!
+        uint projectorLightStart;
+        uint projectorLightCount;
+        GetCountAndStart(posInput, LIGHTCATEGORY_PROJECTOR, projectorLightStart, projectorLightCount);
+        for(i = 0; i < projectorLightCount; ++i)
+        {
+            float3 localDiffuseLighting, localSpecularLighting;
+
+            uint projectorIndex = FetchIndex(projectorLightStart, i);
+
+            EvaluateBSDF_Projector(context, V, posInput, prelightData, _LightDatas[projectorIndex], bsdfData,
+                                   localDiffuseLighting, localSpecularLighting);
+
+            diffuseLighting += localDiffuseLighting;
+            specularLighting += localSpecularLighting;
+        }
+    }
+#endif
+
 #ifdef PROCESS_ENV_LIGHT
     float3 iblDiffuseLighting = float3(0.0, 0.0, 0.0);
     float3 iblSpecularLighting = float3(0.0, 0.0, 0.0);
         specularLighting += localSpecularLighting;
     }
 
-    // Area are store with punctual, just offset the index
-    for (i = _PunctualLightCount; i < _AreaLightCount + _PunctualLightCount; ++i)
+    for (; i < _PunctualLightCount + _AreaLightCount; ++i)
     {
         float3 localDiffuseLighting, localSpecularLighting;
 
             EvaluateBSDF_Area(  context, V, posInput, prelightData, _LightDatas[i], bsdfData,
                                 localDiffuseLighting, localSpecularLighting);
         }
+
+        diffuseLighting += localDiffuseLighting;
+        specularLighting += localSpecularLighting;
+    }
+
+    for (; i < _PunctualLightCount + _AreaLightCount + _ProjectorLightCount; ++i)
+    {
+        float3 localDiffuseLighting, localSpecularLighting;
+
+        EvaluateBSDF_Projector(  context, V, posInput, prelightData, _LightDatas[i], bsdfData,
+                                 localDiffuseLighting, localSpecularLighting);
 
         diffuseLighting += localDiffuseLighting;
         specularLighting += localSpecularLighting;

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

             // We would prefer to split lighting and material information but for performance reasons,
             // those lighting information are fill
             // at the same time than material information.
-            [SurfaceDataAttributes("Bake Diffuse Lighting")]
+            [SurfaceDataAttributes("Bake Diffuse Lighting", false, true)]
-            [SurfaceDataAttributes("Emissive Color")]
+            [SurfaceDataAttributes("Emissive Color", false, true)]
             public Vector3 emissiveColor;
             [SurfaceDataAttributes("Emissive Intensity")]
             public float emissiveIntensity;
         };
 
         //-----------------------------------------------------------------------------
-        // LighTransportData
+        // LightTransportData
-        public struct LighTransportData
+        public struct LightTransportData
+            [SurfaceDataAttributes("", false, true)]
-            public Vector3 emissiveColor;
+            public Vector3 emissiveColor; // HDR value
         };
 
         public class RenderLoop : Object

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Builtin/BuiltinData.cs.hlsl

 #define DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET (107)
 
 //
-// UnityEngine.Experimental.Rendering.HDPipeline.Builtin.LighTransportData:  static fields
+// UnityEngine.Experimental.Rendering.HDPipeline.Builtin.LightTransportData:  static fields
-#define DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_DIFFUSE_COLOR (120)
-#define DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_EMISSIVE_COLOR (121)
+#define DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_DIFFUSE_COLOR (120)
+#define DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_EMISSIVE_COLOR (121)
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.Builtin.BuiltinData
 // PackingRules = Exact
     float depthOffset;
 };
 
-// Generated from UnityEngine.Experimental.Rendering.HDPipeline.Builtin.LighTransportData
+// Generated from UnityEngine.Experimental.Rendering.HDPipeline.Builtin.LightTransportData
-struct LighTransportData
+struct LightTransportData
+
+//
+// Debug functions
+//
+void GetGeneratedBuiltinDataDebug(uint paramId, BuiltinData builtindata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_OPACITY:
+            result = builtindata.opacity.xxx;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_BAKE_DIFFUSE_LIGHTING:
+            result = builtindata.bakeDiffuseLighting;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_COLOR:
+            result = builtindata.emissiveColor;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_INTENSITY:
+            result = builtindata.emissiveIntensity.xxx;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_VELOCITY:
+            result = float3(builtindata.velocity, 0.0);
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION:
+            result = float3(builtindata.distortion, 0.0);
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION_BLUR:
+            result = builtindata.distortionBlur.xxx;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET:
+            result = builtindata.depthOffset.xxx;
+            break;
+    }
+}
+
+//
+// Debug functions
+//
+void GetGeneratedLightTransportDataDebug(uint paramId, LightTransportData lighttransportdata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_DIFFUSE_COLOR:
+            result = lighttransportdata.diffuseColor;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_EMISSIVE_COLOR:
+            result = lighttransportdata.emissiveColor;
+            break;
+    }
+}
 
 
 #endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Builtin/BuiltinData.hlsl

 // Note: These parameters can be store in GBuffer if the writer wants
 //-----------------------------------------------------------------------------
 
-//TODO: return this original relative path include after fixing a bug in Unity side
-//#include "BuiltinData.cs.hlsl"
-#include "../../Material/Builtin/BuiltinData.cs.hlsl"
+#include "BuiltinData.cs.hlsl"
 
 //-----------------------------------------------------------------------------
 // common Encode/Decode functions
 
 void GetBuiltinDataDebug(uint paramId, BuiltinData builtinData, inout float3 result, inout bool needLinearToSRGB)
 {
+    GetGeneratedBuiltinDataDebug(paramId, builtinData, result, needLinearToSRGB);
+
-    case DEBUGVIEW_BUILTIN_BUILTINDATA_OPACITY:
-        result = builtinData.opacity.xxx;
-        break;
     case DEBUGVIEW_BUILTIN_BUILTINDATA_BAKE_DIFFUSE_LIGHTING:
         // TODO: require a remap
         // TODO: we should not gamma correct, but easier to debug for now without correct high range value
         // emissiveColor is premultiply by emissive intensity
         result = (builtinData.emissiveColor / builtinData.emissiveIntensity); needLinearToSRGB = true;
         break;
-    case DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_INTENSITY:
-        result = builtinData.emissiveIntensity.xxx;
-        break;
-    case DEBUGVIEW_BUILTIN_BUILTINDATA_VELOCITY:
-        result = float3(builtinData.velocity, 0.0);
-        break;
-    case DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION:
-        result = float3(builtinData.distortion, 0.0);
-        break;
-    case DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION_BLUR:
-        result = builtinData.distortionBlur.xxx;
-        break;
     case DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET:
         result = builtinData.depthOffset.xxx * 10.0; // * 10 assuming 1 unity unity is 1m
         break;
-void GetLighTransportDataDebug(uint paramId, LighTransportData lightTransportData, inout float3 result, inout bool needLinearToSRGB)
+void GetLightTransportDataDebug(uint paramId, LightTransportData lightTransportData, inout float3 result, inout bool needLinearToSRGB)
+    GetGeneratedLightTransportDataDebug(paramId, lightTransportData, result, needLinearToSRGB);
+
-    case DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_DIFFUSE_COLOR:
-        result = lightTransportData.diffuseColor; needLinearToSRGB = true;
-        break;
-    case DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_EMISSIVE_COLOR:
+    case DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_EMISSIVE_COLOR:
         // TODO: Need a tonemap ?
         result = lightTransportData.emissiveColor;
         break;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

         _Stiffness("Stiffness", float) = 1.0
         _Drag("Drag", float) = 1.0
         _ShiverDrag("Shiver Drag", float) = 0.2
+        _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
 
         _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
         _EmissiveColorMap("EmissiveColorMap", 2D) = "white" {}

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

         _Stiffness("Stiffness", float) = 1.0
         _Drag("Drag", float) = 1.0
         _ShiverDrag("Shiver Drag", float) = 0.2
+        _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
 
         _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
         _EmissiveColorMap("EmissiveColorMap", 2D) = "white" {}

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

             public static GUIContent windStiffnessText = new GUIContent("Stiffness");
             public static GUIContent windDragText = new GUIContent("Drag");
             public static GUIContent windShiverDragText = new GUIContent("Shiver Drag");
+            public static GUIContent windShiverDirectionalityText = new GUIContent("Shiver Directionality");
 
             public static string vertexAnimation = "Vertex Animation";
         }
         protected const string kWindDrag = "_Drag";
         protected MaterialProperty windShiverDrag = null;
         protected const string kWindShiverDrag = "_ShiverDrag";
+        protected MaterialProperty windShiverDirectionality = null;
+        protected const string kWindShiverDirectionality = "_ShiverDirectionality";
 
         // Per pixel displacement params
         protected MaterialProperty enablePerPixelDisplacement = null;
             windStiffness = FindProperty(kWindStiffness, props);
             windDrag = FindProperty(kWindDrag, props);
             windShiverDrag = FindProperty(kWindShiverDrag, props);
+            windShiverDirectionality = FindProperty(kWindShiverDirectionality, props);
         }
 
         void TessellationModePopup()
                 m_MaterialEditor.ShaderProperty(windStiffness, StylesBaseLit.windStiffnessText);
                 m_MaterialEditor.ShaderProperty(windDrag, StylesBaseLit.windDragText);
                 m_MaterialEditor.ShaderProperty(windShiverDrag, StylesBaseLit.windShiverDragText);
+                m_MaterialEditor.ShaderProperty(windShiverDirectionality, StylesBaseLit.windShiverDirectionalityText);
                 EditorGUI.indentLevel--;
             }
 

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

         [GenerateHLSL(PackingRules.Exact, false, true, 1000)]
         public struct SurfaceData
         {
-            [SurfaceDataAttributes("Base Color")]
+            [SurfaceDataAttributes("Base Color", false, true)]
-            [SurfaceDataAttributes("Normal")]
+            [SurfaceDataAttributes("Normal", true)]
             public Vector3 normalWS;
             [SurfaceDataAttributes("Smoothness")]
             public float perceptualSmoothness;
             // MaterialId dependent attribute
 
             // standard
-            [SurfaceDataAttributes("Tangent")]
+            [SurfaceDataAttributes("Tangent", true)]
             public Vector3 tangentWS;
             [SurfaceDataAttributes("Anisotropy")]
             public float anisotropy; // anisotropic ratio(0->no isotropic; 1->full anisotropy in tangent direction)
             public int subsurfaceProfile;
 
             // Clearcoat
-            [SurfaceDataAttributes("Coat Normal")]
+            [SurfaceDataAttributes("Coat Normal", true)]
-            [SurfaceDataAttributes("Specular Color")]
+            [SurfaceDataAttributes("Specular Color", false, true)]
             public Vector3 specularColor;
         };
 
         [GenerateHLSL(PackingRules.Exact, false, true, 1030)]
         public struct BSDFData
         {
+            [SurfaceDataAttributes("", false, true)]
             public Vector3 diffuseColor;
 
             public Vector3 fresnel0;
+            [SurfaceDataAttributes("", true)]
-            public float materialId;
+            public int materialId;
+            [SurfaceDataAttributes("", true)]
+            [SurfaceDataAttributes("", true)]
             public Vector3 bitangentWS;
             public float roughnessT;
             public float roughnessB;
             public Vector3 transmittance;
 
             // Clearcoat
+            [SurfaceDataAttributes("", true)]
             public Vector3 coatNormalWS;
             public float coatRoughness;
 

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

     float3 normalWS;
     float perceptualRoughness;
     float roughness;
-    float materialId;
+    int materialId;
     float3 tangentWS;
     float3 bitangentWS;
     float roughnessT;
     float3 coatNormalWS;
     float coatRoughness;
 };
+
+//
+// Debug functions
+//
+void GetGeneratedSurfaceDataDebug(uint paramId, SurfaceData surfacedata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_LIT_SURFACEDATA_BASE_COLOR:
+            result = surfacedata.baseColor;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_OCCLUSION:
+            result = surfacedata.specularOcclusion.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_NORMAL_WS:
+            result = surfacedata.normalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_PERCEPTUAL_SMOOTHNESS:
+            result = surfacedata.perceptualSmoothness.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_MATERIAL_ID:
+            result = GetIndexColor(surfacedata.materialId);
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_AMBIENT_OCCLUSION:
+            result = surfacedata.ambientOcclusion.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_TANGENT_WS:
+            result = surfacedata.tangentWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_ANISOTROPY:
+            result = surfacedata.anisotropy.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_METALLIC:
+            result = surfacedata.metallic.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR:
+            result = surfacedata.specular.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_RADIUS:
+            result = surfacedata.subsurfaceRadius.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_THICKNESS:
+            result = surfacedata.thickness.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_PROFILE:
+            result = GetIndexColor(surfacedata.subsurfaceProfile);
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_COAT_NORMAL_WS:
+            result = surfacedata.coatNormalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_COAT_PERCEPTUAL_SMOOTHNESS:
+            result = surfacedata.coatPerceptualSmoothness.xxx;
+            break;
+        case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR:
+            result = surfacedata.specularColor;
+            needLinearToSRGB = true;
+            break;
+    }
+}
+
+//
+// Debug functions
+//
+void GetGeneratedBSDFDataDebug(uint paramId, BSDFData bsdfdata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_LIT_BSDFDATA_DIFFUSE_COLOR:
+            result = bsdfdata.diffuseColor;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_FRESNEL0:
+            result = bsdfdata.fresnel0;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_SPECULAR_OCCLUSION:
+            result = bsdfdata.specularOcclusion.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_NORMAL_WS:
+            result = bsdfdata.normalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_PERCEPTUAL_ROUGHNESS:
+            result = bsdfdata.perceptualRoughness.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS:
+            result = bsdfdata.roughness.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_MATERIAL_ID:
+            result = GetIndexColor(bsdfdata.materialId);
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_TANGENT_WS:
+            result = bsdfdata.tangentWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_BITANGENT_WS:
+            result = bsdfdata.bitangentWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_T:
+            result = bsdfdata.roughnessT.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_B:
+            result = bsdfdata.roughnessB.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_ANISOTROPY:
+            result = bsdfdata.anisotropy.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_RADIUS:
+            result = bsdfdata.subsurfaceRadius.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_THICKNESS:
+            result = bsdfdata.thickness.xxx;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_PROFILE:
+            result = GetIndexColor(bsdfdata.subsurfaceProfile);
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_ENABLE_TRANSMISSION:
+            result = (bsdfdata.enableTransmission) ? float3(1.0, 1.0, 1.0) : float3(0.0, 0.0, 0.0);
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_TRANSMITTANCE:
+            result = bsdfdata.transmittance;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_COAT_NORMAL_WS:
+            result = bsdfdata.coatNormalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_LIT_BSDFDATA_COAT_ROUGHNESS:
+            result = bsdfdata.coatRoughness.xxx;
+            break;
+    }
+}
 
 
 #endif

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

 
 // SSS parameters
 #define SSS_N_PROFILES 8
-#define SSS_UNIT_CONVERSION (1.0 / 300.0)                  // From meters to 1/3 centimeters
+#define SSS_UNIT_CONVERSION (1.0 / 300.0)                  // From 1/3 centimeters to meters
+uint   _EnableSSS;                                         // Globally toggles subsurface scattering on/off
+float4 _TintColors[SSS_N_PROFILES];                        // For transmission; alpha is unused
 float  _ThicknessRemaps[SSS_N_PROFILES][2];                // Remap: 0 = start, 1 = end - start
 float4 _HalfRcpVariancesAndLerpWeights[SSS_N_PROFILES][2]; // 2x Gaussians per color channel, A is the the associated interpolation weight
 
 // Ref: Real-Time Realistic Skin Translucency (2010), equation 9 (modified).
 float3 ComputeTransmittance(float3 halfRcpVariance1, float lerpWeight1,
                             float3 halfRcpVariance2, float lerpWeight2,
-                            float thickness, float radiusScale)
+                            float3 tintColor, float thickness, float radiusScale)
 {
 
     // Thickness and SSS radius are decoupled for artists.
     float t2 = thickness * thickness;
 
     // TODO: 6 exponentials is kind of expensive... Should we use a LUT instead?
-    // lerp(exp(-t2 * halfRcpVariance1), exp(-t2 * halfRcpVariance2), lerpWeight2)
-    return exp(-t2 * halfRcpVariance1) * lerpWeight1 + exp(-t2 * halfRcpVariance2) * lerpWeight2;
+    // T = lerp(exp(-t2 * halfRcpVariance1), exp(-t2 * halfRcpVariance2), lerpWeight2)
+    float3 transmittance = exp(-t2 * halfRcpVariance1) * lerpWeight1
+                         + exp(-t2 * halfRcpVariance2) * lerpWeight2;
+    return transmittance * tintColor;
 }
 
 //-----------------------------------------------------------------------------
         bsdfData.fresnel0 = 0.04; /* 0.028 ? */
         bsdfData.subsurfaceProfile = surfaceData.subsurfaceProfile;
         // Make the Std. Dev. of 1 correspond to the effective radius of 1 cm (three-sigma rule).
-        bsdfData.subsurfaceRadius  = SSS_UNIT_CONVERSION * surfaceData.subsurfaceRadius;
+        bsdfData.subsurfaceRadius  = SSS_UNIT_CONVERSION * surfaceData.subsurfaceRadius + 0.0001;
         bsdfData.thickness         = SSS_UNIT_CONVERSION * (_ThicknessRemaps[bsdfData.subsurfaceProfile][0] +
                                                             _ThicknessRemaps[bsdfData.subsurfaceProfile][1] * surfaceData.thickness);
         bsdfData.enableTransmission = IsBitSet(_TransmissionFlags, bsdfData.subsurfaceProfile);
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][0].w,
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].xyz,
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].w,
-                                                          bsdfData.thickness, bsdfData.subsurfaceRadius);
+                                                          _TintColors[bsdfData.subsurfaceProfile].rgb, bsdfData.thickness, bsdfData.subsurfaceRadius);
         }
     }
     else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
         bsdfData.fresnel0 = 0.04; /* 0.028 ? */
         bsdfData.subsurfaceProfile = (SSS_N_PROFILES - 1) * inGBuffer2.a;
         // Make the Std. Dev. of 1 correspond to the effective radius of 1 cm (three-sigma rule).
-        bsdfData.subsurfaceRadius  = SSS_UNIT_CONVERSION * inGBuffer2.r;
+        bsdfData.subsurfaceRadius  = SSS_UNIT_CONVERSION * inGBuffer2.r + 0.0001;
         bsdfData.thickness         = SSS_UNIT_CONVERSION * (_ThicknessRemaps[bsdfData.subsurfaceProfile][0] +
                                                             _ThicknessRemaps[bsdfData.subsurfaceProfile][1] * inGBuffer2.g);
         bsdfData.enableTransmission = IsBitSet(_TransmissionFlags, bsdfData.subsurfaceProfile);
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][0].w,
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].xyz,
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][1].w,
-                                                          bsdfData.thickness, bsdfData.subsurfaceRadius);
+                                                          _TintColors[bsdfData.subsurfaceProfile].rgb, bsdfData.thickness, bsdfData.subsurfaceRadius);
         }
     }
     else if (supportsClearCoat && bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
 
 void GetSurfaceDataDebug(uint paramId, SurfaceData surfaceData, inout float3 result, inout bool needLinearToSRGB)
 {
+    GetGeneratedSurfaceDataDebug(paramId, surfaceData, result, needLinearToSRGB);
+
-        case DEBUGVIEW_LIT_SURFACEDATA_BASE_COLOR:
-            result = surfaceData.baseColor; needLinearToSRGB = true;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_OCCLUSION:
-            result = surfaceData.specularOcclusion.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_NORMAL_WS:
-            result = surfaceData.normalWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_PERCEPTUAL_SMOOTHNESS:
-            result = surfaceData.perceptualSmoothness.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_MATERIAL_ID:
-            result = GetIndexColor(surfaceData.materialId);
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_AMBIENT_OCCLUSION:
-            result = surfaceData.ambientOcclusion.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_TANGENT_WS:
-            result = surfaceData.tangentWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_ANISOTROPY:
-            result = surfaceData.anisotropy.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_METALLIC:
-            result = surfaceData.metallic.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_RADIUS:
-            result = surfaceData.subsurfaceRadius.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_THICKNESS:
-            result = surfaceData.thickness.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_PROFILE:
-            result = GetIndexColor(surfaceData.subsurfaceProfile);
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_COAT_NORMAL_WS:
-            result = surfaceData.coatNormalWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_COAT_PERCEPTUAL_SMOOTHNESS:
-            result = surfaceData.coatPerceptualSmoothness.xxx;
-            break;
-        case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR:
-            result = surfaceData.specularColor; needLinearToSRGB = true;
-            break;
-    switch (paramId)
-    {
-        case DEBUGVIEW_LIT_BSDFDATA_DIFFUSE_COLOR:
-            result = bsdfData.diffuseColor; needLinearToSRGB = true;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_FRESNEL0:
-            result = bsdfData.fresnel0;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_SPECULAR_OCCLUSION:
-            result = bsdfData.specularOcclusion.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_NORMAL_WS:
-            result = bsdfData.normalWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_PERCEPTUAL_ROUGHNESS:
-            result = bsdfData.perceptualRoughness.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS:
-            result = bsdfData.roughness.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_MATERIAL_ID:
-            result = GetIndexColor(bsdfData.materialId);
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_TANGENT_WS:
-            result = bsdfData.tangentWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_BITANGENT_WS:
-            result = bsdfData.bitangentWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_T:
-            result = bsdfData.roughnessT.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_B:
-            result = bsdfData.roughnessB.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_ANISOTROPY:
-            result = bsdfData.anisotropy.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_RADIUS:
-            result = bsdfData.subsurfaceRadius.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_THICKNESS:
-            result = bsdfData.thickness.xxx;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_PROFILE:
-            result = GetIndexColor(bsdfData.subsurfaceProfile);
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_COAT_NORMAL_WS:
-            result = bsdfData.coatNormalWS * 0.5 + 0.5;
-            break;
-        case DEBUGVIEW_LIT_BSDFDATA_COAT_ROUGHNESS:
-            result = bsdfData.coatRoughness.xxx;
-            break;
-    }
+    GetGeneratedBSDFDataDebug(paramId, bsdfData, result, needLinearToSRGB);
 }
 
 //-----------------------------------------------------------------------------
 // light transport functions
 //-----------------------------------------------------------------------------
 
-LighTransportData GetLightTransportData(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData)
+LightTransportData GetLightTransportData(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData)
-    LighTransportData lightTransportData;
+    LightTransportData lightTransportData;
 
     // diffuseColor for lightmapping should basically be diffuse color.
     // But rough metals (black diffuse) still scatter quite a lot of light around, so
 
     [branch] if (lightData.cookieIndex >= 0 && illuminance > 0.0)
     {
-        float3 unL = positionWS - lightData.positionWS;
+        float3 lightToSurface = positionWS - lightData.positionWS;
-        // Project 'unL' onto the light's axes.
-        float2 coord = float2(dot(unL, lightData.right), dot(unL, lightData.up));
+        // Project 'lightToSurface' onto the light's axes.
+        float2 coord = float2(dot(lightToSurface, lightData.right), dot(lightToSurface, lightData.up));
-        // Rescale the texture.
+        // Compute the NDC coordinates (in [-1, 1]^2).
-        // Remap the texture coordinates from [-1, 1]^2 to [0, 1]^2.
-        coord = coord * 0.5 + 0.5;
+        if (lightData.tileCookie || (abs(coord.x) <= 1 && abs(coord.y) <= 1))
+        {
+            // Remap the texture coordinates from [-1, 1]^2 to [0, 1]^2.
+            coord = coord * 0.5 + 0.5;
-        // Tile the texture if the 'repeat' wrap mode is enabled.
-        if (lightData.tileCookie)
-            coord = frac(coord);
+            // Tile the texture if the 'repeat' wrap mode is enabled.
+            if (lightData.tileCookie) { coord = frac(coord); }
-        cookie = SampleCookie2D(lightLoopContext, coord, lightData.cookieIndex);
+            cookie = SampleCookie2D(lightLoopContext, coord, lightData.cookieIndex);
+        }
+        else
+        {
+            cookie = float4(0, 0, 0, 0);
+        }
 
         illuminance *= cookie.a;
     }
     {
         // Reverse the normal.
         illuminance = saturate(dot(-bsdfData.normalWS, L));
-
-        [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
-        {
-            // TODO: factor out the biased position?
-            float3 biasedPositionWS = positionWS + bsdfData.normalWS * bsdfData.thickness;
-#ifdef SHADOWS_USE_SHADOWCTXT
-			float shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, biasedPositionWS, bsdfData.normalWS, lightData.shadowIndex, L, posInput.unPositionSS);
-#else
-            float shadow = GetDirectionalShadowAttenuation(lightLoopContext, biasedPositionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-#endif
-
-            illuminance *= shadow;
-        }
-
+        // Apply the cookie. Do not apply shadows.
         illuminance *= cookie.a;
 
         // The difference between the Disney Diffuse and the Lambertian BRDF for transmittance is negligible.
     {
         // Reverse the normal.
         illuminance = saturate(dot(-bsdfData.normalWS, L)) * attenuation;
+        // Apply the cookie. Do not apply shadows.
+        illuminance *= cookie.a;
-        [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
-        {
-            // TODO: factor out the common biased position?
-            float3 biasedPositionWS = positionWS + bsdfData.normalWS * bsdfData.thickness;
-            float3 offset = float3(0.0, 0.0, 0.0); // GetShadowPosOffset(nDotL, normal);
+        // The difference between the Disney Diffuse and the Lambertian BRDF for transmittance is negligible.
+        float3 backLight = (cookie.rgb * lightData.color) * (illuminance * lightData.diffuseScale * Lambert());
+        // TODO: multiplication by 'diffuseColor' and 'transmittance' is the same for each light.
+        float3 transmittedLight = backLight * bsdfData.diffuseColor * bsdfData.transmittance;
+
+        // We use diffuse lighting for accumulation since it is going to be blurred during the SSS pass.
+        diffuseLighting += transmittedLight;
+    }
+}
+
+//-----------------------------------------------------------------------------
+// EvaluateBSDF_Projector
+//-----------------------------------------------------------------------------
+
+void EvaluateBSDF_Projector(LightLoopContext lightLoopContext,
+                            float3 V, PositionInputs posInput, PreLightData preLightData, LightData lightData, BSDFData bsdfData,
+                            out float3 diffuseLighting,
+                            out float3 specularLighting)
+{
+    float3 positionWS = posInput.positionWS;
+
+    // Translate and rotate 'positionWS' into the light space.
+    float3 positionLS = mul(positionWS - lightData.positionWS,
+                            transpose(float3x3(lightData.right, lightData.up, lightData.forward)));
+
+    if (lightData.lightType == GPULIGHTTYPE_PROJECTOR_PYRAMID)
+    {
+        // Perform perspective division.
+        positionLS *= rcp(positionLS.z);
+    }
+    else
+    {
+        // For orthographic projection, the Z coordinate plays no role.
+        positionLS.z = 0;
+    }
+
+    // Compute the NDC position (in [-1, 1]^2). TODO: precompute the inverse?
+    float2 positionNDC = positionLS.xy * rcp(0.5 * lightData.size);
+
+    // Perform clipping.
+    float clipFactor = ((positionLS.z >= 0) && (abs(positionNDC.x) <= 1 && abs(positionNDC.y) <= 1)) ? 1 : 0;
+
+    float3 L = -lightData.forward; // Lights are pointing backward in Unity
+    float illuminance = saturate(dot(bsdfData.normalWS, L) * clipFactor);
+
+    diffuseLighting  = float3(0.0, 0.0, 0.0);
+    specularLighting = float3(0.0, 0.0, 0.0);
+    float4 cookie    = float4(1.0, 1.0, 1.0, 1.0);
+
+    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
+    {
-			float shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, biasedPositionWS + offset, bsdfData.normalWS, lightData.shadowIndex, L, posInput.unPositionSS);
+        float shadow = GetDirectionalShadowAttenuation(lightLoopContext.shadowContext, positionWS, bsdfData.normalWS, lightData.shadowIndex, L, posInput.unPositionSS);
-            float shadow = GetPunctualShadowAttenuation(lightLoopContext, lightData.lightType, biasedPositionWS + offset, lightData.shadowIndex, L, posInput.unPositionSS);
+        float shadow = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, lightData.shadowIndex, L, posInput.unPositionSS);
-            shadow = lerp(1.0, shadow, lightData.shadowDimmer);
+
+        illuminance *= shadow;
+    }
-            illuminance *= shadow;
-        }
+    [branch] if (lightData.cookieIndex >= 0 && illuminance > 0.0)
+    {
+        // Compute the texture coordinates in [0, 1]^2.
+        float2 coord = positionNDC * 0.5 + 0.5;
+        cookie = SampleCookie2D(lightLoopContext, coord, lightData.cookieIndex);
+
+        illuminance *= cookie.a;
+    }
+
+    [branch] if (illuminance > 0.0)
+    {
+        BSDF(V, L, positionWS, preLightData, bsdfData, diffuseLighting, specularLighting);
+
+        diffuseLighting  *= (cookie.rgb * lightData.color) * (illuminance * lightData.diffuseScale);
+        specularLighting *= (cookie.rgb * lightData.color) * (illuminance * lightData.specularScale);
+    }
+
+    [branch] if (bsdfData.enableTransmission)
+    {
+        // Reverse the normal.
+        illuminance = saturate(dot(-bsdfData.normalWS, L) * clipFactor);
+        // Apply the cookie. Do not apply shadows.
         illuminance *= cookie.a;
 
         // The difference between the Disney Diffuse and the Lambertian BRDF for transmittance is negligible.
     float  len = lightData.size.x;
     float3 T   = lightData.right;
 
-    float3 unL = positionWS - lightData.positionWS;
+    float3 unL = lightData.positionWS - positionWS;
 
     // Pick the major axis of the ellipsoid.
     float3 axis = lightData.right;
         float2 u = Hammersley2d(i, sampleCount);
         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));
+        // Lights in Unity point backward.
+        float4x4 localToWorld = float4x4(float4(lightData.right, 0.0), float4(lightData.up, 0.0), float4(-lightData.forward, 0.0), float4(lightData.positionWS, 1.0));
 
         switch (lightData.lightType)
         {
     float halfWidth  = lightData.size.x * 0.5;
     float halfHeight = lightData.size.y * 0.5;
 
-    float3 unL = positionWS - lightData.positionWS;
+    float3 unL = lightData.positionWS - positionWS;
-    float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
+    float3x3 lightToWorld = float3x3(lightData.right, lightData.up, -lightData.forward);
     unL = mul(unL, transpose(lightToWorld));
 
     // Define the dimensions of the attenuation volume.
     lightData.specularScale *= intensity;
 
     // TODO: store 4 points and save 12 cycles (24x MADs - 12x MOVs).
-    float3 p0 = lightData.positionWS + lightData.right * -halfWidth + lightData.up *  halfHeight;
-    float3 p1 = lightData.positionWS + lightData.right * -halfWidth + lightData.up * -halfHeight;
-    float3 p2 = lightData.positionWS + lightData.right *  halfWidth + lightData.up * -halfHeight;
-    float3 p3 = lightData.positionWS + lightData.right *  halfWidth + lightData.up *  halfHeight;
+    float3 p0 = lightData.positionWS + lightData.right *  halfWidth + lightData.up *  halfHeight;
+    float3 p1 = lightData.positionWS + lightData.right *  halfWidth + lightData.up * -halfHeight;
+    float3 p2 = lightData.positionWS + lightData.right * -halfWidth + lightData.up * -halfHeight;
+    float3 p3 = lightData.positionWS + lightData.right * -halfWidth + lightData.up *  halfHeight;
 
     float4x3 matL = float4x3(p0, p1, p2, p3) - float4x3(positionWS, positionWS, positionWS, positionWS);
 

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

         _AnisotropyMap("AnisotropyMap", 2D) = "white" {}
 
         _SubsurfaceProfile("Subsurface Profile", Int) = 0
-        _SubsurfaceRadius("Subsurface Radius", Range(0.004, 1.0)) = 1.0
+        _SubsurfaceRadius("Subsurface Radius", Range(0.0, 1.0)) = 1.0
-        _Thickness("Thickness", Range(0.004, 1.0)) = 1.0
+        _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
 
         // Wind
         _Drag("Drag", float) = 1.0
         _ShiverDrag("Shiver Drag", float) = 0.2
+        _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
 
         //_CoatCoverage("CoatCoverage", Range(0.0, 1.0)) = 0
         //_CoatCoverageMap("CoatCoverageMapMap", 2D) = "white" {}
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _SUBSURFACE_RADIUS_MAP
     #pragma shader_feature _THICKNESS_MAP
-    #pragma shader_feature _SUBSURFACE_SCATTERING
     #pragma shader_feature _VERTEX_WIND
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

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

     // This part of the code is not used in case of layered shader but we keep the same macro system for simplicity
 #if !defined(LAYERED_LIT_SHADER)
 
-#ifdef _SUBSURFACE_SCATTERING
-    surfaceData.materialId = _MaterialID;
-#else
-    surfaceData.materialId = (_MaterialID == MATERIALID_LIT_SSS) ? 0 : _MaterialID;
-#endif
+    surfaceData.materialId = (_EnableSSS || _MaterialID != MATERIALID_LIT_SSS) ? _MaterialID : MATERIALID_LIT_STANDARD;
 
     // TODO: think about using BC5
 #ifdef _TANGENTMAP
     surfaceData.specular = 0.04;
 
     surfaceData.subsurfaceProfile = _SubsurfaceProfile;
+    surfaceData.subsurfaceRadius  = _SubsurfaceRadius;
+    surfaceData.thickness         = _Thickness;
+
-    surfaceData.subsurfaceRadius = SAMPLE_UVMAPPING_TEXTURE2D(_SubsurfaceRadiusMap, sampler_SubsurfaceRadiusMap, layerTexCoord.base).r * _SubsurfaceRadius;
-#else
-    surfaceData.subsurfaceRadius = _SubsurfaceRadius;
+    surfaceData.subsurfaceRadius *= SAMPLE_UVMAPPING_TEXTURE2D(_SubsurfaceRadiusMap, sampler_SubsurfaceRadiusMap, layerTexCoord.base).r;
-    surfaceData.thickness = SAMPLE_UVMAPPING_TEXTURE2D(_ThicknessMap, sampler_ThicknessMap, layerTexCoord.base).r;
-#else
-    surfaceData.thickness = _Thickness;
+    surfaceData.thickness *= SAMPLE_UVMAPPING_TEXTURE2D(_ThicknessMap, sampler_ThicknessMap, layerTexCoord.base).r;
 #endif
 
     surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);

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

 float _Stiffness;
 float _Drag;
 float _ShiverDrag;
+float _ShiverDirectionality;
 
 #ifndef LAYERED_LIT_SHADER
 

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

         _AnisotropyMap("AnisotropyMap", 2D) = "white" {}
 
         _SubsurfaceProfile("Subsurface Profile", Int) = 0
-        _SubsurfaceRadius("Subsurface Radius", Range(0.004, 1.0)) = 1.0
+        _SubsurfaceRadius("Subsurface Radius", Range(0.0, 1.0)) = 1.0
-        _Thickness("Thickness", Range(0.004, 1.0)) = 1.0
+        _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
 
         // Wind
         _Drag("Drag", float) = 1.0
         _ShiverDrag("Shiver Drag", float) = 0.2
+        _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
 
         //_CoatCoverage("CoatCoverage", Range(0.0, 1.0)) = 0
         //_CoatCoverageMap("CoatCoverageMapMap", 2D) = "white" {}
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _SUBSURFACE_RADIUS_MAP
     #pragma shader_feature _THICKNESS_MAP
-    #pragma shader_feature _SUBSURFACE_SCATTERING
     #pragma shader_feature _VERTEX_WIND
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

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

                     float zDistance   = invDistScale * sampleDepth - (invDistScale * centerPosVS.z);
                     sampleWeight     *= exp(-zDistance * zDistance * halfRcpVariance);
 
+                    if (any(sampleIrradiance) == false)
+                    {
+                        // The irradiance is 0. This could happen for 2 reasons.
+                        // Most likely, the surface fragment does not have an SSS material.
+                        // Alternatively, the surface fragment could be completely shadowed.
+                        // Our blur is energy-preserving, so 'sampleWeight' should be set to 0.
+                        // We do not terminate the loop since we want to gather the contribution
+                        // of the remaining samples (e.g. in case of hair covering skin).
+                        continue;
+                    }
+
                     totalIrradiance += sampleWeight * sampleIrradiance;
                     totalWeight     += sampleWeight;
                 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringProfile.cs

         public float         lerpWeight;
         public TexturingMode texturingMode;
         public bool          enableTransmission;
+        public Color         tintColor;
         public Vector2       thicknessRemap;
         [HideInInspector]
         public int           settingsIndex;
             lerpWeight         = 0.5f;
             texturingMode      = TexturingMode.PreAndPostScatter;
             enableTransmission = false;
+            tintColor          = Color.white;
             thicknessRemap     = new Vector2(0, 1);
             settingsIndex      = SubsurfaceScatteringSettings.neutralProfileID; // Updated by SubsurfaceScatteringSettings.OnValidate() once assigned
 
 
             Vector3 weightSum = new Vector3(0, 0, 0);
 
+            float rcpNumSamples = 1.0f / numSamples;
+
-                float u   = (i + 0.5f) / numSamples;
+                float u = (i <= numSamples / 2) ? 0.5f - i * rcpNumSamples    // The center and to the left
+                                                : (i + 0.5f) * rcpNumSamples; // From the center to the right
+
                 float pos = GaussianCombinationCdfInverse(u, maxStdDev1, maxStdDev2, lerpWeight);
                 float pdf = GaussianCombination(pos, maxStdDev1, maxStdDev2, lerpWeight);
 
     }
 
     [Serializable]
-    public class SubsurfaceScatteringSettings
+    public class SubsurfaceScatteringSettings : ISerializationCallbackReceiver
     {
         public const int maxNumProfiles   = 8;
         public const int neutralProfileID = 7;
         // Below is the cache filled during OnValidate().
         [NonSerialized] public int           texturingModeFlags; // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
         [NonSerialized] public int           transmissionFlags;  // 1 bit/profile; 0 = inf. thick, 1 = supports transmission
+        [NonSerialized] public Vector4[]     tintColors;         // For transmission; alpha is unused
         [NonSerialized] public float[]       thicknessRemaps;
         [NonSerialized] public Vector4[]     halfRcpVariancesAndLerpWeights;
         [NonSerialized] public Vector4[]     halfRcpWeightedVariances;
             profiles[0]                    = null;
             texturingModeFlags             = 0;
             transmissionFlags              = 0;
+            tintColors                     = null;
-            OnValidate(); // Perform initialization
+            UpdateCache();
         }
 
         public void OnValidate()
                 }
             }
 
-            if (thicknessRemaps == null || thicknessRemaps.Length != (maxNumProfiles * 2))
-            {
-                thicknessRemaps = new float[maxNumProfiles * 2];
-            }
-
-            if (halfRcpVariancesAndLerpWeights == null || halfRcpVariancesAndLerpWeights.Length != (maxNumProfiles * 2))
-            {
-                halfRcpVariancesAndLerpWeights = new Vector4[maxNumProfiles * 2];
-            }
-
-            if (halfRcpWeightedVariances == null || halfRcpWeightedVariances.Length != maxNumProfiles)
-            {
-                halfRcpWeightedVariances = new Vector4[maxNumProfiles];
-            }
-
-            if (filterKernels == null || filterKernels.Length != (maxNumProfiles * SubsurfaceScatteringProfile.numSamples))
-            {
-                filterKernels = new Vector4[maxNumProfiles * SubsurfaceScatteringProfile.numSamples];
-            }
-
             Color c = new Color();
 
             for (int i = 0; i < numProfiles; i++)
 
                 profiles[i].lerpWeight = Mathf.Clamp01(profiles[i].lerpWeight);
 
+                profiles[i].tintColor.r = Mathf.Clamp01(profiles[i].tintColor.r);
+                profiles[i].tintColor.g = Mathf.Clamp01(profiles[i].tintColor.g);
+                profiles[i].tintColor.b = Mathf.Clamp01(profiles[i].tintColor.b);
+                profiles[i].tintColor.a = 1.0f;
+
                 profiles[i].thicknessRemap.x = Mathf.Clamp(profiles[i].thicknessRemap.x, 0, profiles[i].thicknessRemap.y);
                 profiles[i].thicknessRemap.y = Mathf.Max(profiles[i].thicknessRemap.x, profiles[i].thicknessRemap.y);
 
+            UpdateCache();
+        }
+
+        public void UpdateCache()
+        {
-            // Use the updated data to fill the cache.
+            if (tintColors == null || tintColors.Length != maxNumProfiles)
+            {
+                tintColors = new Vector4[maxNumProfiles];
+            }
+
+            if (thicknessRemaps == null || thicknessRemaps.Length != (maxNumProfiles * 2))
+            {
+                thicknessRemaps = new float[maxNumProfiles * 2];
+            }
+
+            if (halfRcpVariancesAndLerpWeights == null || halfRcpVariancesAndLerpWeights.Length != (maxNumProfiles * 2))
+            {
+                halfRcpVariancesAndLerpWeights = new Vector4[maxNumProfiles * 2];
+            }
+
+            if (halfRcpWeightedVariances == null || halfRcpWeightedVariances.Length != maxNumProfiles)
+            {
+                halfRcpWeightedVariances = new Vector4[maxNumProfiles];
+            }
+
+            if (filterKernels == null || filterKernels.Length != (maxNumProfiles * SubsurfaceScatteringProfile.numSamples))
+            {
+                filterKernels = new Vector4[maxNumProfiles * SubsurfaceScatteringProfile.numSamples];
+            }
+
             for (int i = 0; i < numProfiles; i++)
             {
                 // Skip unassigned profiles.
                 transmissionFlags  |= (profiles[i].enableTransmission ? 1 : 0) << i;
 
+                tintColors[i]                               = profiles[i].tintColor;
                 thicknessRemaps[2 * i]                      = profiles[i].thicknessRemap.x;
                 thicknessRemaps[2 * i + 1]                  = profiles[i].thicknessRemap.y - profiles[i].thicknessRemap.x;
                 halfRcpVariancesAndLerpWeights[2 * i]       = profiles[i].halfRcpVariances[0];
                 }
             }
         }
+
+        public void OnBeforeSerialize()
+        {
+            // No special action required.
+        }
+
+        public void OnAfterDeserialize()
+        {
+            UpdateCache();
+        }
     }
 
 #if UNITY_EDITOR
     {
         private class Styles
         {
-            public readonly GUIContent   sssProfilePreview0       = new GUIContent("Profile preview");
-            public readonly GUIContent   sssProfilePreview1       = new GUIContent("Shows the fraction of light scattered from the source as radius increases to 1.");
-            public readonly GUIContent   sssProfilePreview2       = new GUIContent("Note that the intensity of the region in the center may be clamped.");
-            public readonly GUIContent   sssTransmittancePreview0 = new GUIContent("Transmittance preview");
-            public readonly GUIContent   sssTransmittancePreview1 = new GUIContent("Shows the fraction of light passing through the object as thickness increases to 1.");
-            public readonly GUIContent   sssProfileStdDev1        = new GUIContent("Standard deviation #1", "Determines the shape of the 1st Gaussian filter. Increases the strength and the radius of the blur of the corresponding color channel.");
-            public readonly GUIContent   sssProfileStdDev2        = new GUIContent("Standard deviation #2", "Determines the shape of the 2nd Gaussian filter. Increases the strength and the radius of the blur of the corresponding color channel.");
-            public readonly GUIContent   sssProfileLerpWeight     = new GUIContent("Filter interpolation", "Controls linear interpolation between the two Gaussian filters.");
-            public readonly GUIContent   sssTexturingMode         = new GUIContent("Texturing mode", "Specifies when the diffuse texture should be applied.");
-            public readonly GUIContent[] sssTexturingModeOptions  = new GUIContent[2]
+            public readonly GUIContent   sssProfilePreview0        = new GUIContent("Profile Preview");
+            public readonly GUIContent   sssProfilePreview1        = new GUIContent("Shows the fraction of light scattered from the source as radius increases to 1.");
+            public readonly GUIContent   sssProfilePreview2        = new GUIContent("Note that the intensity of the region in the center may be clamped.");
+            public readonly GUIContent   sssTransmittancePreview0  = new GUIContent("Transmittance Preview");
+            public readonly GUIContent   sssTransmittancePreview1  = new GUIContent("Shows the fraction of light passing through the object as thickness increases to 1.");
+            public readonly GUIContent   sssProfileStdDev1         = new GUIContent("Standard Deviation #1", "Determines the shape of the 1st Gaussian filter. Increases the strength and the radius of the blur of the corresponding color channel.");
+            public readonly GUIContent   sssProfileStdDev2         = new GUIContent("Standard Deviation #2", "Determines the shape of the 2nd Gaussian filter. Increases the strength and the radius of the blur of the corresponding color channel.");
+            public readonly GUIContent   sssProfileLerpWeight      = new GUIContent("Filter Interpolation", "Controls linear interpolation between the two Gaussian filters.");
+            public readonly GUIContent   sssTexturingMode          = new GUIContent("Texturing Mode", "Specifies when the diffuse texture should be applied.");
+            public readonly GUIContent[] sssTexturingModeOptions   = new GUIContent[2]
-            public readonly GUIContent   sssProfileTransmission   = new GUIContent("Enable transmission", "Toggles simulation of light passing through thin objects. Depends on the thickness of the material.");
-            public readonly GUIContent   sssProfileThicknessRemap = new GUIContent("Thickness remap", "Remaps the thickness parameter from [0, 1] to the desired range.");
+            public readonly GUIContent   sssProfileTransmission    = new GUIContent("Enable Transmission", "Toggles simulation of light passing through thin objects. Depends on the thickness of the material.");
+            public readonly GUIContent   sssProfileTintColor       = new GUIContent("Transmission Tint Color", "Tints transmitted light.");
+            public readonly GUIContent   sssProfileMinMaxThickness = new GUIContent("Min-Max Thickness", "Shows the values of the thickness remap below.");
+            public readonly GUIContent   sssProfileThicknessRemap  = new GUIContent("Thickness Remap", "Remaps the thickness parameter from [0, 1] to the desired range.");
-            public readonly GUIStyle     centeredMiniBoldLabel    = new GUIStyle(GUI.skin.label);
+            public readonly GUIStyle     centeredMiniBoldLabel     = new GUIStyle(GUI.skin.label);
 
             public Styles()
             {
 
         private RenderTexture      m_ProfileImage, m_TransmittanceImage;
         private Material           m_ProfileMaterial, m_TransmittanceMaterial;
-        private SerializedProperty m_StdDev1, m_StdDev2, m_LerpWeight,
+        private SerializedProperty m_StdDev1, m_StdDev2, m_LerpWeight, m_TintColor,
                                    m_TexturingMode, m_Transmission, m_ThicknessRemap;
 
         void OnEnable()
             m_LerpWeight     = serializedObject.FindProperty("lerpWeight");
             m_TexturingMode  = serializedObject.FindProperty("texturingMode");
             m_Transmission   = serializedObject.FindProperty("enableTransmission");
+            m_TintColor      = serializedObject.FindProperty("tintColor");
             m_ThicknessRemap = serializedObject.FindProperty("thicknessRemap");
 
             m_ProfileMaterial       = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawGaussianProfile");
                 EditorGUILayout.PropertyField(m_LerpWeight,   styles.sssProfileLerpWeight);
                 m_TexturingMode.intValue = EditorGUILayout.Popup(styles.sssTexturingMode, m_TexturingMode.intValue, styles.sssTexturingModeOptions);
                 EditorGUILayout.PropertyField(m_Transmission, styles.sssProfileTransmission);
+                EditorGUILayout.PropertyField(m_TintColor,    styles.sssProfileTintColor);
+                EditorGUILayout.PropertyField(m_ThicknessRemap, styles.sssProfileMinMaxThickness);
-                EditorGUILayout.LabelField("Min thickness: ", thicknessRemap.x.ToString());
-                EditorGUILayout.LabelField("Max thickness: ", thicknessRemap.y.ToString());
                 EditorGUILayout.MinMaxSlider(styles.sssProfileThicknessRemap, ref thicknessRemap.x, ref thicknessRemap.y, 0, 10);
                 m_ThicknessRemap.vector2Value = thicknessRemap;
 
             m_TransmittanceMaterial.SetColor("_StdDev2",         m_StdDev2.colorValue);
             m_TransmittanceMaterial.SetFloat("_LerpWeight",      m_LerpWeight.floatValue);
             m_TransmittanceMaterial.SetVector("_ThicknessRemap", m_ThicknessRemap.vector2Value);
+            m_TransmittanceMaterial.SetVector("_TintColor",      m_TintColor.colorValue);
             EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(16, 16), m_TransmittanceImage, m_TransmittanceMaterial, ScaleMode.ScaleToFit, 16.0f);
 
             serializedObject.ApplyModifiedProperties();

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.cs

         [GenerateHLSL(PackingRules.Exact, false, true, 1100)]
         public struct SurfaceData
         {
-            [SurfaceDataAttributes("Color")]
+            [SurfaceDataAttributes("Color", false, true)]
             public Vector3 color;
         };
 
         [GenerateHLSL(PackingRules.Exact, false, true, 1130)]
         public struct BSDFData
         {
+            [SurfaceDataAttributes("", false, true)]
             public Vector3 color;
         };
     }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.cs.hlsl

     float3 color;
 };
 
+//
+// Debug functions
+//
+void GetGeneratedSurfaceDataDebug(uint paramId, SurfaceData surfacedata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_UNLIT_SURFACEDATA_COLOR:
+            result = surfacedata.color;
+            needLinearToSRGB = true;
+            break;
+    }
+}
+
+//
+// Debug functions
+//
+void GetGeneratedBSDFDataDebug(uint paramId, BSDFData bsdfdata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_UNLIT_BSDFDATA_COLOR:
+            result = bsdfdata.color;
+            needLinearToSRGB = true;
+            break;
+    }
+}
+
 
 #endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.hlsl

 }
 
 //-----------------------------------------------------------------------------
-// No light evaluation, this is unlit
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-    switch (paramId)
-    {
-    case DEBUGVIEW_UNLIT_SURFACEDATA_COLOR:
-        result = surfaceData.color; needLinearToSRGB = true;
-        break;
-    }
+    GetGeneratedSurfaceDataDebug(paramId, surfaceData, result, needLinearToSRGB);
-    switch (paramId)
-    {
-    case DEBUGVIEW_UNLIT_SURFACEDATA_COLOR:
-        result = bsdfData.color; needLinearToSRGB = true;
-        break;
-    }
+    GetGeneratedBSDFDataDebug(paramId, bsdfData, result, needLinearToSRGB);
-LighTransportData GetLightTransportData(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData)
+//-----------------------------------------------------------------------------
+// No light evaluation, this is unlit
+//-----------------------------------------------------------------------------
+
+LightTransportData GetLightTransportData(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData)
-    LighTransportData lightTransportData;
+    LightTransportData lightTransportData;
 
     lightTransportData.diffuseColor = float3(0.0, 0.0, 0.0);
     lightTransportData.emissiveColor = builtinData.emissiveColor;

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/Resources/DrawTransmittanceGraph.shader

         [HideInInspector] _StdDev2("", Color) = (0, 0, 0)
         [HideInInspector] _LerpWeight("", Float) = 0
         [HideInInspector] _ThicknessScale("", Float) = 0
+        [HideInInspector] _TintColor("", Color) = (0, 0, 0)
     }
 
     SubShader
             // Inputs & outputs
             //-------------------------------------------------------------------------------------
 
-            float4 _StdDev1, _StdDev2, _ThicknessRemap;
+            float4 _StdDev1, _StdDev2, _ThicknessRemap, _TintColor;
             float _LerpWeight; // See 'SubsurfaceScatteringParameters'
 
             //-------------------------------------------------------------------------------------
                 float3 transmittance = lerp(exp(-t2 * 0.5 * rcp(var1)),
                                             exp(-t2 * 0.5 * rcp(var2)), _LerpWeight);
 
-                return float4(transmittance, 1);
+                return float4(transmittance * _TintColor.rgb, 1);
             }
             ENDHLSL
         }

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassLightTransport.hlsl

     GetSurfaceAndBuiltinData(input, V, posInput, surfaceData, builtinData);
 
     BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData);
-    LighTransportData lightTransportData = GetLightTransportData(surfaceData, builtinData, bsdfData);
+    LightTransportData lightTransportData = GetLightTransportData(surfaceData, builtinData, bsdfData);
 
     // This shader is call two time. Once for getting emissiveColor, the other time to get diffuseColor
     // We use unity_MetaFragmentControl to make the distinction.

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/VertMesh.hlsl

 
 #if _VERTEX_WIND
     float3 rootWP = mul(GetObjectToWorldMatrix(), float4(0, 0, 0, 1)).xyz;
-    ApplyWind(positionWS, normalWS, rootWP, _Stiffness, _Drag, _ShiverDrag, _InitialBend, vertexColor.a, _Time);
+    ApplyWind(positionWS, normalWS, rootWP, _Stiffness, _Drag, _ShiverDrag, _ShiverDirectionality, _InitialBend, vertexColor.a, _Time);
 #endif
 
 #ifdef TESSELLATION_ON

Assets/ScriptableRenderPipeline/ShaderLibrary/API/D3D11.hlsl

 // Initialize arbitrary structure with zero values.
 // Do not exist on some platform, in this case we need to have a standard name that call a function that will initialize all parameters to 0
 #define ZERO_INITIALIZE(type, name) name = (type)0;
+#define ZERO_INITIALIZE_ARRAY(type, name, arraySize) { for (int arrayIndex = 0; arrayIndex < arraySize; arrayIndex++) { name[arrayIndex] = (type)0; } }
 
 // Texture util abstraction
 

Assets/ScriptableRenderPipeline/ShaderLibrary/API/Metal.hlsl

 // Initialize arbitrary structure with zero values.
 // Do not exist on some platform, in this case we need to have a standard name that call a function that will initialize all parameters to 0
 #define ZERO_INITIALIZE(type, name) name = (type)0;
+#define ZERO_INITIALIZE_ARRAY(type, name, arraySize) { for (int arrayIndex = 0; arrayIndex < arraySize; arrayIndex++) { name[arrayIndex] = (type)0; } }
 
 // Texture util abstraction
 

Assets/ScriptableRenderPipeline/ShaderLibrary/API/PSSL.hlsl

 // Initialize arbitrary structure with zero values.
 // Do not exist on some platform, in this case we need to have a standard name that call a function that will initialize all parameters to 0
 #define ZERO_INITIALIZE(type, name) name = (type)0;
+#define ZERO_INITIALIZE_ARRAY(type, name, arraySize) { for (int arrayIndex = 0; arrayIndex < arraySize; arrayIndex++) { name[arrayIndex] = (type)0; } }
 
 // Texture util abstraction
 

Assets/ScriptableRenderPipeline/ShaderLibrary/Common.hlsl

 // Example: unL for unormalized light vector
 
 // use capital letter for regular vector, vector are always pointing outward the current pixel position (ready for lighting equation)
-// capital letter mean the vector is normalize, unless we put un in front of it.
+// capital letter mean the vector is normalize, unless we put 'un' in front of it.
 // V: View vector  (no eye vector)
 // L: Light vector
 // N: Normal vector
 #define FLT_MIN     1.175494351e-38 // Minimum representable positive floating-point number
 #define FLT_MAX     3.402823466e+38 // Maximum representable floating-point number
 
-#define MERGE_NAME(X, Y) X##Y
-
 float DegToRad(float deg)
 {
     return deg * PI / 180.0;
     return (x < 0.0) ? -t0 : t0;
 }
 
-// Same smoothstep except it assume 0, 1 interval for x
+// Same as smoothstep except it assume 0, 1 interval for x
 float smoothstep01(float x)
 {
     return x * x * (3.0 - (2.0 * x));
 // Texture format sampling
 // ----------------------------------------------------------------------------
 
-float2 DirectionToLatLongCoordinate(float3 dir_in)
+float2 DirectionToLatLongCoordinate(float3 unDir)
-    float3 dir = normalize(dir_in);
+    float3 dir = normalize(unDir);
     // 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);
 }
     posInput.depthVS  = positionCS.w;
     posInput.depthRaw = positionCS.z / positionCS.w;
 }
+
+// ----------------------------------------------------------------------------
+// Misc utilities
+// ----------------------------------------------------------------------------
 
 // Generates a triangle in homogeneous clip space, s.t.
 // v0 = (-1, -1, 1), v1 = (3, -1, 1), v2 = (-1, 3, 1).

Assets/ScriptableRenderPipeline/ShaderLibrary/Wind.hlsl

     float3 Direction;
     float Strength;
     float3 ShiverStrength;
+    float3 ShiverDirection;
 };
 
 
     float shiver = length(shiverNoise);
 
     result.Direction = dir;
+    result.ShiverDirection = shiverNoise;
-    result.ShiverStrength = shiver;
+    result.ShiverStrength = shiver + shiver * gust;
 
     return result;
 }
-void ApplyWind(inout float3 worldPos, inout float3 worldNormal, float3 rootWP, float stiffness, float drag, float shiverDrag, float initialBend, float shiverMask, float4 time)
+void ApplyWind( inout float3    worldPos, 
+                inout float3    worldNormal,
+                float3          rootWP,
+                float           stiffness,
+                float           drag,
+                float           shiverDrag,
+                float           shiverDirectionality,
+                float           initialBend,
+                float           shiverMask,
+                float4          time)
 {
     WindData wind = GetAnalyticalWind(worldPos, rootWP, drag, shiverDrag, initialBend, time);
 
         float3 rotAxis = cross(float3(0, 1, 0), wind.Direction);
 
         worldPos = Rotate(rootWP, worldPos, rotAxis, (wind.Strength) * 0.001 * att);
-        worldPos += wind.ShiverStrength * worldNormal * shiverMask;
+        
+        float3 shiverDirection = normalize(lerp(worldNormal, normalize(wind.Direction + wind.ShiverDirection), shiverDirectionality));
+        worldPos += wind.ShiverStrength * shiverDirection * shiverMask;
     }
 
 }

Assets/ScriptableRenderPipeline/common/Shadow/Shadow.cs

                 float area = vl.screenRect.width * vl.screenRect.height;
                 long val = ShadowUtils.Asint( area );
                 val <<= 32;
-                val |= (long)(uint)vlidx;
+                val |= (uint)vlidx;
                 m_TmpSortKeys.AddUnchecked( val );
             }
             m_TmpSortKeys.Sort();

Assets/ScriptableRenderPipeline/common/Shadow/ShadowUtilities.cs

             return proj * view;
         }
 
-        public static bool MapLightType( LightArchetype la, LightType lt, out HDPipeline.GPULightType gputype, out GPUShadowType shadowtype )
-        {
-            switch( la )
-            {
-            case LightArchetype.Punctual    : return MapLightType( lt, out gputype, out shadowtype );
-            case LightArchetype.Rectangle   : gputype = HDPipeline.GPULightType.Rectangle; shadowtype = GPUShadowType.Unknown; return true;
-            case LightArchetype.Line        : gputype = HDPipeline.GPULightType.Line; shadowtype = GPUShadowType.Unknown; return true;
-            default                         : gputype = HDPipeline.GPULightType.Spot; shadowtype = GPUShadowType.Unknown; return false; // <- probably not what you want
-            }
-
-        }
         public static bool MapLightType( LightType lt,  out HDPipeline.GPULightType gputype, out GPUShadowType shadowtype )
         {
             switch( lt )
             {
                 case LightArchetype.Punctual:
                     return MapLightType(lt, out shadowtype);
-                case LightArchetype.Rectangle:
+                case LightArchetype.Area:
-                case LightArchetype.Line:
+                case LightArchetype.Projector:
                     shadowtype = GPUShadowType.Unknown;
                     return true;
                 default:

Assets/ScriptableRenderPipeline/common/TextureCache.cs

             }
         }
 
-        public static TextureFormat GetPreferredCompressedTextureFormat
+        public static TextureFormat GetPreferredHdrCompressedTextureFormat
         {
             get
             {
 
                 // On editor the texture is uncompressed when operating against mobile build targets
+#if UNITY_2017_2_OR_NEWER
+                if (SystemInfo.SupportsTextureFormat(probeFormat) && !UnityEngine.Rendering.GraphicsSettings.HasShaderDefine(UnityEngine.Rendering.BuiltinShaderDefine.UNITY_NO_DXT5nm))
+                    format = probeFormat;
+#else
+#endif
 
                 return format;
             }
         {
             get
             {
+#if UNITY_2017_2_OR_NEWER
+                return !UnityEngine.Rendering.GraphicsSettings.HasShaderDefine(UnityEngine.Rendering.BuiltinShaderDefine.UNITY_NO_CUBEMAP_ARRAY);
+#else
+#endif
             }
         }
 

Assets/ScriptableRenderPipeline/fptl/FptlLighting.cs

             m_CubeReflTexArray = new TextureCacheCubemap();
             m_CookieTexArray.AllocTextureArray(8, m_TextureSettings.spotCookieSize, m_TextureSettings.spotCookieSize, TextureFormat.RGBA32, true);
             m_CubeCookieTexArray.AllocTextureArray(4, m_TextureSettings.pointCookieSize, TextureFormat.RGBA32, true);
-            m_CubeReflTexArray.AllocTextureArray(64, m_TextureSettings.reflectionCubemapSize, TextureCache.GetPreferredCompressedTextureFormat, true);
+            m_CubeReflTexArray.AllocTextureArray(64, m_TextureSettings.reflectionCubemapSize, TextureCache.GetPreferredHdrCompressedTextureFormat, true);
 
             //m_DeferredMaterial.SetTexture("_spotCookieTextures", m_cookieTexArray.GetTexCache());
             //m_DeferredMaterial.SetTexture("_pointCookieTextures", m_cubeCookieTexArray.GetTexCache());
                     lightData[idxOut] = light;
                 }
             }
-            var numLightsOut = offsets[LightDefinitions.DIRECT_LIGHT, numVolTypes - 1] + numEntries[LightDefinitions.DIRECT_LIGHT, numVolTypes - 1];
+            int numLightsOut = 0;
+            for(int v=0; v<numVolTypes; v++) numLightsOut += numEntries[LightDefinitions.DIRECT_LIGHT, v];
 
             // probe.m_BlendDistance
             // Vector3f extents = 0.5*Abs(probe.m_BoxSize);
                 lightData[idxOut] = lgtData;
             }
 
-            var numProbesOut = offsets[LightDefinitions.REFLECTION_LIGHT, numVolTypes - 1] + numEntries[LightDefinitions.REFLECTION_LIGHT, numVolTypes - 1];
+            int numProbesOut = 0;
+            for(int v=0; v<numVolTypes; v++) numProbesOut += numEntries[LightDefinitions.REFLECTION_LIGHT, v];
+
             for (var m = 0; m < numModels; m++)
             {
                 for (var v = 0; v < numVolTypes; v++)

Assets/ScriptableRenderPipeline/fptl/LightDefinitions.cs.hlsl

 //
 float GetPenumbra(SFiniteLightData value)
 {
-    return value.penumbra;
+	return value.penumbra;
-    return value.flags;
+	return value.flags;
-    return value.lightType;
+	return value.lightType;
-    return value.lightModel;
+	return value.lightModel;
-    return value.lightPos;
+	return value.lightPos;
-    return value.lightIntensity;
+	return value.lightIntensity;
-    return value.lightAxisX;
+	return value.lightAxisX;
-    return value.recipRange;
+	return value.recipRange;
-    return value.lightAxisY;
+	return value.lightAxisY;
-    return value.radiusSq;
+	return value.radiusSq;
-    return value.lightAxisZ;
+	return value.lightAxisZ;
-    return value.cotan;
+	return value.cotan;
-    return value.color;
+	return value.color;
-    return value.sliceIndex;
+	return value.sliceIndex;
-    return value.boxInnerDist;
+	return value.boxInnerDist;
-    return value.decodeExp;
+	return value.decodeExp;
-    return value.boxInvRange;
+	return value.boxInvRange;
-    return value.shadowLightIndex;
+	return value.shadowLightIndex;
-    return value.localCubeCapturePoint;
+	return value.localCubeCapturePoint;
-    return value.probeBlendDistance;
+	return value.probeBlendDistance;
 }
 
 //
 {
-    return value.boxAxisX;
+	return value.boxAxisX;
-    return value.boxAxisY;
+	return value.boxAxisY;
-    return value.boxAxisZ;
+	return value.boxAxisZ;
-    return value.center;
+	return value.center;
-    return value.scaleXY;
+	return value.scaleXY;
-    return value.radius;
+	return value.radius;
 }
 
 //
 {
-    return value.color;
+	return value.color;
-    return value.intensity;
+	return value.intensity;
-    return value.lightAxisX;
+	return value.lightAxisX;
-    return value.shadowLightIndex;
+	return value.shadowLightIndex;
-    return value.lightAxisY;
+	return value.lightAxisY;
-    return value.pad0;
+	return value.pad0;
-    return value.lightAxisZ;
+	return value.lightAxisZ;
-    return value.pad1;
+	return value.pad1;
 }
 
 

Assets/ShaderGenerator/Editor/CSharpToHLSL.cs

                         }
                     }
 
+                    foreach (var gen in it.Value)
+                    {
+                        if (gen.hasStatics && gen.hasFields && gen.needParamDebug)
+                        {
+                            writer.Write(gen.EmitFunctions() + "\n");
+                        }
+                    }                    
+
+
                 }
             }
         }

Assets/ShaderGenerator/Editor/ShaderTypeGeneration.cs

             public Accessor accessor;
         };
 
+        class DebugFieldInfo
+        {
+            public DebugFieldInfo(string defineName, string fieldName, Type fieldType, bool isDirection, bool isSRGB)
+            {
+                this.defineName = defineName;
+                this.fieldName = fieldName;
+                this.fieldType = fieldType;
+                this.isDirection = isDirection;
+                this.isSRGB = isSRGB;
+            }
+
+            public string defineName;
+            public string fieldName;
+            public Type fieldType;
+            public bool isDirection;
+            public bool isSRGB;            
+        }
+
         void Error(string error)
         {
             if (errors == null)
             return shaderText;
         }
 
+        public string EmitFunctions()
+        {
+            string shaderText = string.Empty;
+
+            // In case users ask for debug functions
+            if (!attr.needParamDebug)
+                return shaderText;
+
+            // Specific to HDRenderPipeline            
+            string lowerStructName = type.Name.ToLower();
+
+            shaderText += "//\n";
+            shaderText += "// Debug functions\n";
+            shaderText += "//\n";
+
+            shaderText += "void GetGenerated" + type.Name + "Debug(uint paramId, " + type.Name + " " + lowerStructName + ", inout float3 result, inout bool needLinearToSRGB)\n";
+            shaderText += "{\n";
+            shaderText += "    switch (paramId)\n";
+            shaderText += "    {\n";
+
+            foreach (var debugField in m_DebugFields)
+            {
+                shaderText += "        case " + debugField.defineName + ":\n";
+                if (debugField.fieldType == typeof(float))
+                {
+                    if (debugField.isDirection)
+                    {
+                        shaderText += "            result = " + lowerStructName + "." + debugField.fieldName + ".xxx * 0.5 + 0.5;\n";
+                    }
+                    else 
+                    {
+                        shaderText += "            result = " + lowerStructName + "." + debugField.fieldName + ".xxx;\n";
+                    }
+                }
+                else if (debugField.fieldType == typeof(Vector2))
+                {
+                    shaderText += "            result = float3(" + lowerStructName + "." + debugField.fieldName + ", 0.0);\n";
+                }
+                else if (debugField.fieldType == typeof(Vector3))
+                {
+                    if (debugField.isDirection)
+                    {
+                        shaderText += "            result = " + lowerStructName + "." + debugField.fieldName + " * 0.5 + 0.5;\n";
+                    }
+                    else 
+                    {
+                        shaderText += "            result = " + lowerStructName + "." + debugField.fieldName + ";\n";
+                    }                    
+                }
+                else if (debugField.fieldType == typeof(Vector4))
+                {
+                    shaderText += "            result = " + lowerStructName + "." + debugField.fieldName + ".xyz;\n";
+                }
+                else if (debugField.fieldType == typeof(bool))
+                {
+                    shaderText += "            result = (" + lowerStructName + "." + debugField.fieldName + ") ? float3(1.0, 1.0, 1.0) : float3(0.0, 0.0, 0.0);\n";
+                }
+                else if (debugField.fieldType == typeof(uint) || debugField.fieldType == typeof(int))
+                {
+                    shaderText += "            result = GetIndexColor(" + lowerStructName + "." + debugField.fieldName + ");\n";
+                }
+                else // This case left is suppose to be a complex structure. Either we don't support it or it is an enum. Consider it is an enum with GetIndexColor, user can override it if he want.
+                {
+                    shaderText += "            result = GetIndexColor(" + lowerStructName + "." + debugField.fieldName + ");\n";       
+                }
+                
+                if (debugField.isSRGB)
+                {
+                    shaderText += "            needLinearToSRGB = true;\n";
+                }
+
+                shaderText += "            break;\n";
+            }
+
+            shaderText += "    }\n";
+            shaderText += "}\n";            
+
+            return shaderText;
+        }
+
-        // This function is a helper to follow unity convertion
-        // when converting fooBar ro FOO_BAR
+        // This function is a helper to follow unity convention
+        // when converting fooBar to FOO_BAR
         string InsertUnderscore(string name)
         {
             for (int i = 1; i < name.Length; i++)
 
             FieldInfo[] fields = type.GetFields();
             m_ShaderFields = new List<ShaderFieldInfo>();
+            m_DebugFields = new List<DebugFieldInfo>();
 
             if (type.IsEnum)
             {
                     continue;
                 }
 
-                if (attr.needParamDefines)
+                if (attr.needParamDebug)
-                    m_Statics[("DEBUGVIEW_" + subNamespace + "_" + type.Name + "_" + name).ToUpper()] = Convert.ToString(attr.paramDefinesStart + debugCounter++);
+                    string defineName = ("DEBUGVIEW_" + subNamespace + "_" + type.Name + "_" + name).ToUpper();
+                    m_Statics[defineName] = Convert.ToString(attr.paramDefinesStart + debugCounter++);
+
+                    bool isDirection = false;
+                    bool sRGBDisplay = false;
+
+                    // Check if the display name have been override by the users
+                    if (Attribute.IsDefined(field, typeof(SurfaceDataAttributes)))
+                    {
+                        var propertyAttr = (SurfaceDataAttributes[])field.GetCustomAttributes(typeof(SurfaceDataAttributes), false);
+                        isDirection = propertyAttr[0].isDirection;
+                        sRGBDisplay = propertyAttr[0].sRGBDisplay;
+                    }
+
+                    m_DebugFields.Add(new DebugFieldInfo(defineName, field.Name, field.FieldType, isDirection, sRGBDisplay));
                 }
 
                 if (field.FieldType.IsPrimitive)
         {
             get { return attr.needAccessors; }
         }
+        public bool needParamDebug
+        {
+            get { return attr.needParamDebug; }
+        }
 
         public Type type;
         public GenerateHLSL attr;
         Dictionary<string, string> m_Statics;
         List<ShaderFieldInfo> m_ShaderFields;
         List<ShaderFieldInfo> m_PackedFields;
+        List<DebugFieldInfo> m_DebugFields;
     }
 }

Assets/ShaderGenerator/ShaderGeneratorAttributes.cs

     {
         public PackingRules packingRules;
         public bool needAccessors; // Whether or not to generate the accessors
-        public bool needParamDefines; // Wheter or not to generate define for each parameters of the struc
+        public bool needParamDebug; // // Whether or not to generate define for each field of the struct + debug function (use in HDRenderPipeline)
-        public GenerateHLSL(PackingRules rules = PackingRules.Exact, bool needAccessors = true, bool needParamDefines = false, int paramDefinesStart = 1)
+        public GenerateHLSL(PackingRules rules = PackingRules.Exact, bool needAccessors = true, bool needParamDebug = false, int paramDefinesStart = 1)
-            this.needParamDefines = needParamDefines;
+            this.needParamDebug = needParamDebug;
             this.paramDefinesStart = paramDefinesStart;
         }
     }
     {
         public string displayName;
+        public bool isDirection;
+        public bool sRGBDisplay;
-        public SurfaceDataAttributes(string displayName = "")
+        public SurfaceDataAttributes(string displayName = "", bool isDirection = false, bool sRGBDisplay = false)
+            this.isDirection = isDirection;
+            this.sRGBDisplay = sRGBDisplay;
         }
     }
 }

Assets/TestScenes/HDTest/GraphicTest/Two Sided/Prefabs/Materials.meta

-fileFormatVersion: 2
-guid: 0e2aa881811d0644896d4b5a732945cc
+fileFormatVersion: 2
+guid: ee9aedf6876b41c459d476afd81ab708
-timeCreated: 1485804900
+timeCreated: 1492083994
 licenseType: Pro
 DefaultImporter:
   userData: 

Assets/TestScenes/HDTest/LayeredLitTest/Mesh/Materials.meta

-fileFormatVersion: 2
-guid: e8f6ad2e481134b4fa6108a280b52de7
+fileFormatVersion: 2
+guid: babcbb0e8a80beb4ca87d6a963225ae6
-timeCreated: 1484331445
+timeCreated: 1492083990
 licenseType: Pro
 DefaultImporter:
   userData: 

Assets/TestScenes/HDTest/WindTest/Materials.meta

-fileFormatVersion: 2
-guid: cd06bfc6da39fbc4886b6bb4be0f70be
+fileFormatVersion: 2
+guid: fd0f1959e62dce14aa6e413beba5bdb4
-timeCreated: 1491817104
+timeCreated: 1492083997
 licenseType: Pro
 DefaultImporter:
   userData: 

Assets/Textures/cookieTest.png.meta

 fileFormatVersion: 2
-guid: 32c4b9c8ddc1c5d49ac7d10122540447
-timeCreated: 1472821822
+guid: 55fd692de65e703408cbda23b0eae8d0
+timeCreated: 1492083821
-  fileIDToRecycleName:
-    8900000: generatedCubemap
+  fileIDToRecycleName: {}
   serializedVersion: 4
   mipmaps:
     mipMapMode: 0
     fadeOut: 0
-    borderMipMap: 1
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
     mipMapFadeDistanceStart: 1
     mipMapFadeDistanceEnd: 3
   bumpmap:
     normalMapFilter: 0
-  isReadable: 1
+  isReadable: 0
-  cubemapConvolution: 1
+  cubemapConvolution: 0
+    serializedVersion: 2
-    aniso: 0
+    aniso: -1
-    wrapMode: 1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
   nPOTScale: 1
   lightmap: 0
   compressionQuality: 50
   spritePivot: {x: 0.5, y: 0.5}
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
   spritePixelsToUnits: 100
-  alphaUsage: 2
-  alphaIsTransparency: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
   spriteTessellationDetail: -1
   textureType: 0
   textureShape: 1
     crunchedCompression: 0
     allowsAlphaSplitting: 0
     overridden: 0
-  - buildTarget: Standalone
-    maxTextureSize: 512
-    textureFormat: 4
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 1
-  - buildTarget: iPhone
-    maxTextureSize: 2048
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-  - buildTarget: tvOS
-    maxTextureSize: 2048
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-  - buildTarget: Windows Store Apps
-    maxTextureSize: 2048
-    textureFormat: -1
-    textureCompression: 1
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
+    physicsShape: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

Assets/Textures/Batman.png.meta

+fileFormatVersion: 2
+guid: a5f5ba3665c610f469d392e02dadb3bd
+timeCreated: 1491904075
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 2
+    aniso: -1
+    mipBias: -1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 0
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: iPhone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: tvOS
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Two Sided/Prefabs/Materials/GroundLeaf_Albedo.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: GroundLeaf_Albedo
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.5882353, g: 0.5882353, b: 0.5882353, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/GraphicTest/Two Sided/Prefabs/Materials/GroundLeaf_Albedo.mat.meta

+fileFormatVersion: 2
+guid: 32cc1012aa8bda142b86f39a95e7973d
+timeCreated: 1492083994
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/LayeredLitTest/Mesh/Materials/No Name.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: No Name
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/LayeredLitTest/Mesh/Materials/No Name.mat.meta

+fileFormatVersion: 2
+guid: b2d32da2c9c5b24438e73edfe16d8a6c
+timeCreated: 1492083990
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/WindTest/Materials/Branches_03_BC.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Branches_03_BC
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.588, g: 0.588, b: 0.588, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/WindTest/Materials/Branches_03_BC.mat.meta

+fileFormatVersion: 2
+guid: e02899e01b0528c47b5574d9529b2499
+timeCreated: 1492083997
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/WindTest/Materials/Material #30.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: 'Material #30'
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.588, g: 0.588, b: 0.588, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/WindTest/Materials/Material #30.mat.meta

+fileFormatVersion: 2
+guid: 63d92d273fccd644c8421e55f662e015
+timeCreated: 1492083997
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/WindTest/Materials/Tree_03_Trunk_BC.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Tree_03_Trunk_BC
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.588, g: 0.588, b: 0.588, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/WindTest/Materials/Tree_03_Trunk_BC.mat.meta

+fileFormatVersion: 2
+guid: 55f64669d1dd1424ca41db9370e4a1eb
+timeCreated: 1492083997
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: