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

.gitignore

 
 Library/*
 Temp/*
+obj/*
 *.csproj
 *.sln
 *.suo
 *.aspx
 *.sdf
 *.userprefs
-
-Assets/UnityHDRI.meta
-Assets/UnityHDRI/Gareoult/GareoultWhiteBalanced.exr
-obj/Debug/Assembly-CSharp.csproj.FileListAbsolute.txt

Assets/ScriptableRenderLoop/HDRenderLoop/Debug/Resources/DebugViewMaterialGBuffer.shader

             #pragma target 5.0
             #pragma only_renderers d3d11 // TEMP: unitl we go futher in dev
 
-            #pragma vertex VertDeferred
-            #pragma fragment FragDeferred
+            #pragma vertex Vert
+            #pragma fragment Frag
 
             #include "Common.hlsl"
             #include "Color.hlsl"
                 float4 positionCS : SV_POSITION;
             };
 
-            Varyings VertDeferred(Attributes input)
+            Varyings Vert(Attributes input)
             {
                 // TODO: implement SV_vertexID full screen quad
                 Varyings output;
                 return output;
             }
 
-            float4 FragDeferred(Varyings input) : SV_Target
+            float4 Frag(Varyings input) : SV_Target
-                float depth = _CameraDepthTexture.Load(uint3(coord.unPositionSS, 0)).x;
+                float depth = LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).x;
 
                 FETCH_GBUFFER(gbuffer, _GBufferTexture, coord.unPositionSS);
                 BSDFData bsdfData;

Assets/ScriptableRenderLoop/HDRenderLoop/Debug/Resources/DebugViewTiles.shader

             #pragma target 5.0
             #pragma only_renderers d3d11 // TEMP: unitl we go futher in dev
 
-            #pragma vertex VertViewTiles
-            #pragma fragment FragViewTiles
+            #pragma vertex Vert
+            #pragma fragment Frag
 
             #define LIGHTLOOP_TILE_PASS 1            
             #define LIGHTLOOP_TILE_ALL	1
 
 	        uint _ViewTilesFlags;
 
-	        TEXTURE2D(_CameraDepthTexture);
-	        SAMPLER2D(sampler_CameraDepthTexture);
+            TEXTURE2D(_CameraDepthTexture);
+            SAMPLER2D(sampler_CameraDepthTexture);
+
+            float4x4 _InvViewProjMatrix;
-	        float4 VertViewTiles(float3 positionOS : POSITION): SV_POSITION
+	        float4 Vert(float3 positionOS : POSITION): SV_POSITION
 	        {
 		        return TransformWorldToHClip(TransformObjectToWorld(positionOS));
 	        }
                     float4(1.0, 0.0, 0.0, 0.9)    // strong red
                 };
 
-                float maxNrLightsPerTile = 31;
+                float maxNrLightsPerTile = 31; // TODO: setup a constant for that
-                int nColorIndex = numLights == 0 ? 0 : (1 + (int)floor(10 * (log2((float)numLights) / log2(maxNrLightsPerTile))));
-                nColorIndex = nColorIndex<0 ? 0 : nColorIndex;
-                float4 col = nColorIndex>11 ? float4(1.0, 1.0, 1.0, 1.0) : kRadarColors[nColorIndex];
+                int colorIndex = numLights == 0 ? 0 : (1 + (int)floor(10 * (log2((float)numLights) / log2(maxNrLightsPerTile))));
+                colorIndex = colorIndex < 0 ? 0 : colorIndex;
+                float4 col = colorIndex > 11 ? float4(1.0, 1.0, 1.0, 1.0) : kRadarColors[colorIndex];
 
                 int2 coord = pixCoord - int2(1, 1);
 
                 return color;
             }
 
-	        float4 FragViewTiles(float4 positionCS : SV_POSITION) : SV_Target
+	        float4 Frag(float4 positionCS : SV_POSITION) : SV_Target
+                // Perform same calculation than in deferred.shader
-                float linearDepth = GetLinearDepth(depth); // View space linear depth
+                float3 positionWS = UnprojectToWorld(depth, coord.positionSS, _InvViewProjMatrix);
+                float linearDepth = TransformWorldToView(positionWS).z; // View space linear depth
                 #else
                 float linearDepth = 0.0; // unused
                 #endif

Assets/ScriptableRenderLoop/HDRenderLoop/Editor/HDRenderLoopInspector.cs

             public readonly GUIContent tileLightLoopDebugMode = new GUIContent("Enable Debug mode", "Toggle overheat map mode");
             public readonly GUIContent directIndirectSinglePass = new GUIContent("Enable direct and indirect lighting in single pass", "Toggle");
             public readonly GUIContent bigTilePrepass = new GUIContent("Enable big tile prepass", "Toggle");
-            public readonly GUIContent clustered = new GUIContent("Enable clusted", "Toggle");   
+            public readonly GUIContent clustered = new GUIContent("Enable clustered", "Toggle");
+
+
+            public readonly GUIContent textureSettings = new GUIContent("texture Settings");
+
+            public readonly GUIContent spotCookieSize = new GUIContent("spotCookie Size");
+            public readonly GUIContent pointCookieSize = new GUIContent("pointCookie Size");
+            public readonly GUIContent reflectionCubemapSize = new GUIContent("reflectionCubemap Size");              
         }
 
         private static Styles s_Styles = null;
                 FillWithProperties(typeof(Builtin.BuiltinData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Lit.SurfaceData)), ref index);
                 FillWithProperties(typeof(Lit.SurfaceData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Lit.SurfaceData)), ref index);
                 FillWithProperties(typeof(Builtin.BuiltinData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Unlit.SurfaceData)), ref index);
-                FillWithProperties(typeof(Unlit.SurfaceData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Unlit.SurfaceData)), ref index);                
+                FillWithProperties(typeof(Unlit.SurfaceData), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, false, GetSubNameSpaceName(typeof(Unlit.SurfaceData)), ref index);
 
                 // Engine
                 FillWithPropertiesEnum(typeof(Attributes.DebugViewGbuffer), styles.debugViewMaterialStrings, styles.debugViewMaterialValues, "", true, ref index);
             EditorGUILayout.Space();
             debugParameters.displayOpaqueObjects = EditorGUILayout.Toggle(styles.displayOpaqueObjects, debugParameters.displayOpaqueObjects);
             debugParameters.displayTransparentObjects = EditorGUILayout.Toggle(styles.displayTransparentObjects, debugParameters.displayTransparentObjects);
-			debugParameters.useForwardRenderingOnly = EditorGUILayout.Toggle(styles.useForwardRenderingOnly, debugParameters.useForwardRenderingOnly);
+            debugParameters.useForwardRenderingOnly = EditorGUILayout.Toggle(styles.useForwardRenderingOnly, debugParameters.useForwardRenderingOnly);
-            debugParameters.useSinglePassLightLoop = EditorGUILayout.Toggle(styles.useSinglePassLightLoop, debugParameters.useSinglePassLightLoop);     
+            debugParameters.useSinglePassLightLoop = EditorGUILayout.Toggle(styles.useSinglePassLightLoop, debugParameters.useSinglePassLightLoop);
 
             if (EditorGUI.EndChangeCheck())
             {
             EditorGUI.indentLevel++;
             EditorGUI.BeginChangeCheck();
 
-
             shadowParameters.enabled = EditorGUILayout.Toggle(styles.shadowsEnabled, shadowParameters.enabled);
             shadowParameters.shadowAtlasWidth = Mathf.Max(0, EditorGUILayout.IntField(styles.shadowsAtlasWidth, shadowParameters.shadowAtlasWidth));
             shadowParameters.shadowAtlasHeight = Mathf.Max(0, EditorGUILayout.IntField(styles.shadowsAtlasHeight, shadowParameters.shadowAtlasHeight));
             EditorGUI.indentLevel++;
-            for (int i = 0; i < shadowParameters.directionalLightCascadeCount-1; i++)
+            for (int i = 0; i < shadowParameters.directionalLightCascadeCount - 1; i++)
-            
             if (EditorGUI.EndChangeCheck())
             {
                 EditorUtility.SetDirty(renderLoop); // Repaint
             EditorGUILayout.Space();
-            EditorGUILayout.LabelField(styles.tileLightLoopSettings);
+            var textureParameters = renderLoop.textureSettings;
+
+            EditorGUILayout.LabelField(styles.textureSettings);
-            renderLoop.tilePassLightLoop.debugViewTilesFlags = (TilePass.DebugViewTilesFlags)EditorGUILayout.EnumMaskField("DebugView Tiles", renderLoop.tilePassLightLoop.debugViewTilesFlags);
-            renderLoop.tilePassLightLoop.enableDirectIndirectSinglePass = EditorGUILayout.Toggle(styles.directIndirectSinglePass, renderLoop.tilePassLightLoop.enableDirectIndirectSinglePass);
-            renderLoop.tilePassLightLoop.enableBigTilePrepass = EditorGUILayout.Toggle(styles.bigTilePrepass, renderLoop.tilePassLightLoop.enableBigTilePrepass);
-            renderLoop.tilePassLightLoop.enableClustered = EditorGUILayout.Toggle(styles.clustered, renderLoop.tilePassLightLoop.enableClustered);
+            textureParameters.spotCookieSize = Mathf.NextPowerOfTwo(Mathf.Clamp(EditorGUILayout.IntField(styles.spotCookieSize, textureParameters.spotCookieSize), 16, 1024));
+            textureParameters.pointCookieSize = Mathf.NextPowerOfTwo(Mathf.Clamp(EditorGUILayout.IntField(styles.pointCookieSize, textureParameters.pointCookieSize), 16, 1024));
+            textureParameters.reflectionCubemapSize = Mathf.NextPowerOfTwo(Mathf.Clamp(EditorGUILayout.IntField(styles.reflectionCubemapSize, textureParameters.reflectionCubemapSize), 64, 1024));
 
             if (EditorGUI.EndChangeCheck())
             {
+
+
+            EditorGUILayout.Space();
+
+            if (renderLoop.tilePassLightLoop != null)
+            {
+                EditorGUILayout.LabelField(styles.tileLightLoopSettings);
+                EditorGUI.indentLevel++;
+                EditorGUI.BeginChangeCheck();
+
+                renderLoop.tilePassLightLoop.debugViewTilesFlags = (TilePass.DebugViewTilesFlags)EditorGUILayout.EnumMaskField("DebugView Tiles", renderLoop.tilePassLightLoop.debugViewTilesFlags);
+                renderLoop.tilePassLightLoop.enableDirectIndirectSinglePass = EditorGUILayout.Toggle(styles.directIndirectSinglePass, renderLoop.tilePassLightLoop.enableDirectIndirectSinglePass);
+                renderLoop.tilePassLightLoop.enableBigTilePrepass = EditorGUILayout.Toggle(styles.bigTilePrepass, renderLoop.tilePassLightLoop.enableBigTilePrepass);
+                renderLoop.tilePassLightLoop.enableClustered = EditorGUILayout.Toggle(styles.clustered, renderLoop.tilePassLightLoop.enableClustered);
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    EditorUtility.SetDirty(renderLoop); // Repaint
+
+                    // If something is chanage on tilePassLightLoop we need to force a OnValidate() OnHDRenderLoop, else change Rebuild() will not be call
+                    renderLoop.OnValidate();
+                }
+                EditorGUI.indentLevel--;
+            }
         }
     }
 }

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.asset

     rotation: 0
     exposure: 0
     multiplier: 1
+    skyResolution: 256
   m_ShadowSettings:
     enabled: 1
     shadowAtlasWidth: 4096

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

         [SerializeField]
         TextureSettings m_TextureSettings = TextureSettings.Default;
 
+        public TextureSettings textureSettings
+        {
+            get { return m_TextureSettings; }
+        }
+
         // Various set of material use in render loop
         Material m_FinalPassMaterial;
         Material m_DebugViewMaterialGBuffer;
         int m_VelocityBuffer;
         int m_DistortionBuffer;
 
-        bool m_Dirty = false;
+        public bool m_Dirty = false;
 
         RenderTargetIdentifier m_CameraColorBufferRT;
         RenderTargetIdentifier m_CameraDepthBufferRT;
         int m_HeightOnRecord;
 
         // TODO: Find a way to automatically create/iterate through lightloop
-        SinglePass.LightLoop m_SinglePassLightLoop;
-        TilePass.LightLoop m_TilePassLightLoop = null;
+        // This must be init externally else The value can't be set in the inspector... (as it will recreate the class with default value)
+        SinglePass.LightLoop m_SinglePassLightLoop = new SinglePass.LightLoop();
+        TilePass.LightLoop m_TilePassLightLoop = new TilePass.LightLoop();
         public TilePass.LightLoop tilePassLightLoop
         {
             get { return m_TilePassLightLoop; }
-        Lit.RenderLoop m_LitRenderLoop;
+        // TODO TO CHECK: SebL I move allocation from Rebuild() to here, but there was a comment "// Our object can be garbage collected, so need to be allocate here", it is still true ?
+        Lit.RenderLoop m_LitRenderLoop = new Lit.RenderLoop();
-        private void OnValidate()
+        public void OnValidate()
+            // Calling direction Rebuild() here cause this warning:
+            // "SendMessage cannot be called during Awake, CheckConsistency, or OnValidate UnityEngine.Experimental.ScriptableRenderLoop.HDRenderLoop:OnValidate()"
+            // Workaround is to declare this dirty flag and call REbuild in Render()
-            m_CameraColorBuffer  = Shader.PropertyToID("_CameraColorTexture");
+            // We call Cleanup() here because Rebuild() can be call by OnValidate(), i.e when inspector is touch
+            // Note that module don't need to do the same as the call here is propagated correctly
+            Cleanup();
+
+            m_CameraColorBuffer = Shader.PropertyToID("_CameraColorTexture");
             m_CameraDepthBuffer  = Shader.PropertyToID("_CameraDepthTexture");
 
             m_CameraColorBufferRT = new RenderTargetIdentifier(m_CameraColorBuffer);
 
             m_ShadowPass = new ShadowRenderPass(m_ShadowSettings);
 
-            // Init Gbuffer description
-            m_LitRenderLoop = new Lit.RenderLoop(); // Our object can be garbage collected, so need to be allocate here
+            // Init Gbuffer description            
 
             m_gbufferManager.gbufferCount = m_LitRenderLoop.GetMaterialGBufferCount();
             RenderTextureFormat[] RTFormat; RenderTextureReadWrite[] RTReadWrite;
             m_LitRenderLoop.Rebuild();
 
             m_CookieTexArray = new TextureCache2D();
-            m_CookieTexArray.AllocTextureArray(8, (int)m_TextureSettings.spotCookieSize, (int)m_TextureSettings.spotCookieSize, TextureFormat.RGBA32, true);
+            m_CookieTexArray.AllocTextureArray(8, m_TextureSettings.spotCookieSize, m_TextureSettings.spotCookieSize, TextureFormat.RGBA32, true);
-            m_CubeCookieTexArray.AllocTextureArray(4, (int)m_TextureSettings.pointCookieSize, TextureFormat.RGBA32, true);
+            m_CubeCookieTexArray.AllocTextureArray(4, m_TextureSettings.pointCookieSize, TextureFormat.RGBA32, true);
-            m_CubeReflTexArray.AllocTextureArray(32, (int)m_TextureSettings.reflectionCubemapSize, TextureFormat.BC6H, true);
+            m_CubeReflTexArray.AllocTextureArray(32, m_TextureSettings.reflectionCubemapSize, TextureFormat.BC6H, true);
-            m_SinglePassLightLoop = new SinglePass.LightLoop();
-            m_TilePassLightLoop = new TilePass.LightLoop();
             tilePassLightLoop.Rebuild();
 
             m_lightList = new LightList();
 
         public override void Cleanup()
         {
-            m_LitRenderLoop.OnDisable();
-            m_SinglePassLightLoop.OnDisable();
-            tilePassLightLoop.OnDisable();
+            m_LitRenderLoop.Cleanup();
+            m_SinglePassLightLoop.Cleanup();
+            m_TilePassLightLoop.Cleanup();
-            m_CubeReflTexArray.Release();
-            m_CookieTexArray.Release();
-            m_CubeCookieTexArray.Release();
+            if (m_CubeReflTexArray != null)
+            {
+                m_CubeReflTexArray.Release();
+                m_CubeReflTexArray = null;
+            }
+            if (m_CookieTexArray != null)
+            {
+                m_CookieTexArray.Release();
+                m_CookieTexArray = null;
+            }
+            if (m_CubeCookieTexArray != null)
+            {
+                m_CubeCookieTexArray.Release();
+                m_CubeCookieTexArray = null;
+            }
-            m_SkyRenderer.OnDisable();
+            if (m_SkyRenderer != null)
+            {
+                m_SkyRenderer.Cleanup();
+            }
 
 #if UNITY_EDITOR
             UnityEditor.SupportedRenderingFeatures.active = UnityEditor.SupportedRenderingFeatures.Default;
 
                     var directionalLightData = new DirectionalLightData();
                     // Light direction for directional and is opposite to the forward direction
-                    directionalLightData.direction = -light.light.transform.forward;
+                    directionalLightData.direction  = -light.light.transform.forward;
+                    directionalLightData.up         = light.light.transform.up;
+                    directionalLightData.right      = light.light.transform.right;
+                    directionalLightData.positionWS = light.light.transform.position;
+                    directionalLightData.invScaleX = 1.0f / light.light.transform.localScale.x;
+                    directionalLightData.invScaleY = 1.0f / light.light.transform.localScale.y;
+                    directionalLightData.cookieIndex = -1;
+
+                    if (light.light.cookie != null)
+                    {
+                        directionalLightData.tileCookie  = (light.light.cookie.wrapMode == TextureWrapMode.Repeat);
+                        directionalLightData.cookieIndex = m_CookieTexArray.FetchSlice(light.light.cookie);
+                    }
 
                     bool hasDirectionalShadows = light.light.shadows != LightShadows.None && shadowOutput.GetShadowSliceCountLightIndex(lightIndex) != 0;
                     bool hasDirectionalNotReachMaxLimit = lightList.directionalShadows.Count == 0; // Only one cascade shadow allowed
 
                     var innerConePercent = additionalData.GetInnerSpotPercent01();
                     var cosSpotOuterHalfAngle = Mathf.Clamp(Mathf.Cos(spotAngle * 0.5f * Mathf.Deg2Rad), 0.0f, 1.0f);
+                    var sinSpotOuterHalfAngle = Mathf.Sqrt(1.0f - cosSpotOuterHalfAngle * cosSpotOuterHalfAngle);
+
+                    // TODO: find a proper place to store the cotangent.
+                    lightData.size.x = cosSpotOuterHalfAngle / sinSpotOuterHalfAngle;
                 }
                 else
                 {
                 lightData.cookieIndex = -1;
                 lightData.shadowIndex = -1;
 
-                bool hasCookie = light.light.cookie != null;
-                if (hasCookie)
+                if (light.light.cookie != null)
-                    if (light.lightType == LightType.Point)
+                    // TODO: add texture atlas support for cookie textures.
+                    switch (light.lightType)
-                        lightData.cookieIndex = m_CubeCookieTexArray.FetchSlice(light.light.cookie);
-                    }
-                    else if (light.lightType == LightType.Spot)
-                    {
-                        lightData.cookieIndex = m_CookieTexArray.FetchSlice(light.light.cookie);
+                        case LightType.Spot:
+                            lightData.cookieIndex = m_CookieTexArray.FetchSlice(light.light.cookie);
+                            break;
+                        case LightType.Point:
+                            lightData.cookieIndex = m_CubeCookieTexArray.FetchSlice(light.light.cookie);
+                            break;
                     }
                 }
 
                     }
                 }
 
-                lightData.size = new Vector2(additionalData.areaLightLength, additionalData.areaLightWidth);
-                lightData.twoSided = additionalData.isDoubleSided;
-
                 if (additionalData.archetype == LightArchetype.Punctual)
                 {
                     lightList.punctualLights.Add(lightData);
                 {
+                    lightData.twoSided = additionalData.isDoubleSided;
+                    lightData.size     = new Vector2(additionalData.areaLightLength,
+                                                     additionalData.areaLightWidth);
+
                     // Area and line lights are both currently stored as area lights on the GPU.
                     lightList.areaLights.Add(lightData);
                     lightList.areaCullIndices.Add(lightIndex);
 
         public void PushGlobalParams(Camera camera, RenderLoop renderLoop, HDRenderLoop.LightList lightList)
         {
-            //Shader.SetGlobalTexture("_CookieTextures", m_CookieTexArray.GetTexCache());
-            //Shader.SetGlobalTexture("_CubeCookieTextures", m_CubeCookieTexArray.GetTexCache());
+            Shader.SetGlobalTexture("_CookieTextures", m_CookieTexArray.GetTexCache());
+            Shader.SetGlobalTexture("_CookieCubeTextures", m_CubeCookieTexArray.GetTexCache());
+
             Shader.SetGlobalTexture("_EnvTextures", m_CubeReflTexArray.GetTexCache());
 
             if (m_SkyRenderer.IsSkyValid(m_SkyParameters))

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightDefinition.cs

     public enum GPULightType
     {
         Directional,
-        Spot, 
+        Spot,
         Point,
         ProjectorOrtho,
         ProjectorPyramid,
         public float invSqrAttenuationRadius;
 
         public Vector3 color;
-        public float angleScale; // Spot light
+        public float angleScale;  // Spot light
-        public float angleOffset;
+        public float angleOffset; // Spot light
-        public float diffuseScale; // Spot light
+        public float diffuseScale;
-        
+
         public float shadowDimmer;
         // index are -1 if not used
         public int shadowIndex;
-        public GPULightType lightType;   
+        public GPULightType lightType;
-        public Vector2 size;
+        public Vector2 size; // x = cot(outerHalfAngle) for spot lights
         public bool twoSided;
     };
 
         public Vector3 direction;
-        public float diffuseScale;
+        public float   diffuseScale;
+
+        public Vector3 up;
+        public float   invScaleY;
+
+        public Vector3 right;
+        public float   invScaleX;
+
+        public Vector3 positionWS;
+        public bool    tileCookie;
-        public float specularScale;        
+        public float   specularScale;
-        // Sun disc size 
-        public float cosAngle; // Distance to disk
-        public float sinAngle; // Disk radius
-        public int shadowIndex;
-        public float unused;
+        // Sun disc size
+        public float cosAngle;  // Distance to the disk
+        public float sinAngle;  // Disk radius
+        public int shadowIndex; // -1 if unused
+        public int cookieIndex; // -1 if unused
     };
 
 

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

 {
 	float3 direction;
 	float diffuseScale;
+	float3 up;
+	float invScaleY;
+	float3 right;
+	float invScaleX;
+	float3 positionWS;
+	bool tileCookie;
-	float unused;
+	int cookieIndex;
 };
 
 // Generated from UnityEngine.Experimental.ScriptableRenderLoop.PunctualShadowData
 {
 	return value.diffuseScale;
 }
+float3 GetUp(DirectionalLightData value)
+{
+	return value.up;
+}
+float GetInvScaleY(DirectionalLightData value)
+{
+	return value.invScaleY;
+}
+float3 GetRight(DirectionalLightData value)
+{
+	return value.right;
+}
+float GetInvScaleX(DirectionalLightData value)
+{
+	return value.invScaleX;
+}
+float3 GetPositionWS(DirectionalLightData value)
+{
+	return value.positionWS;
+}
+bool GetTileCookie(DirectionalLightData value)
+{
+	return value.tileCookie;
+}
 float3 GetColor(DirectionalLightData value)
 {
 	return value.color;
 {
 	return value.shadowIndex;
 }
-float GetUnused(DirectionalLightData value)
+int GetCookieIndex(DirectionalLightData value)
-	return value.unused;
+	return value.cookieIndex;
 }
 
 //

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Resources/Deferred.shader

             #pragma target 5.0
             #pragma only_renderers d3d11 // TEMP: unitl we go futher in dev
 
-            #pragma vertex VertDeferred
-            #pragma fragment FragDeferred
+            #pragma vertex Vert
+            #pragma fragment Frag
 
             // Chose supported lighting architecture in case of deferred rendering
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
                 float4 positionCS : SV_POSITION;
             };
 
-            Varyings VertDeferred(Attributes input)
+            Varyings Vert(Attributes input)
             {
                 // TODO: implement SV_vertexID full screen quad
                 // Lights are draw as one fullscreen quad
                 return output;
             }
 
-            float4 FragDeferred(Varyings input) : SV_Target
+            float4 Frag(Varyings input) : SV_Target
             {
 				float4 unPositionSS = input.positionCS; // as input we have the vpos
                 Coordinate coord = GetCoordinate(unPositionSS.xy, _ScreenSize.zw);

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePass.cs

             }
 
             // Static keyword is required here else we get a "DestroyBuffer can only be call in main thread"
-            static ComputeBuffer s_DirectionalLights;
-            static ComputeBuffer s_PunctualLightList;
-            static ComputeBuffer s_EnvLightList;
-            static ComputeBuffer s_AreaLightList;
-            static ComputeBuffer s_PunctualShadowList;
-            static ComputeBuffer s_DirectionalShadowList;
+            static ComputeBuffer s_DirectionalLights = null;
+            static ComputeBuffer s_PunctualLightList = null;
+            static ComputeBuffer s_EnvLightList = null;
+            static ComputeBuffer s_AreaLightList = null;
+            static ComputeBuffer s_PunctualShadowList = null;
+            static ComputeBuffer s_DirectionalShadowList = null;
-            Material m_DeferredMaterial;
-
-            void ClearComputeBuffers()
-            {
-                if (s_DirectionalLights != null)
-                    s_DirectionalLights.Release();
-
-                if (s_DirectionalShadowList != null)
-                    s_DirectionalShadowList.Release();
-
-                if (s_PunctualLightList != null)
-                    s_PunctualLightList.Release();
-
-                if (s_AreaLightList != null)
-                    s_AreaLightList.Release();
-
-                if (s_PunctualShadowList != null)
-                    s_PunctualShadowList.Release();
-
-                if (s_EnvLightList != null)
-                    s_EnvLightList.Release();
-            }
+            Material m_DeferredMaterial = null;
-                ClearComputeBuffers();
-
                 s_DirectionalLights = new ComputeBuffer(HDRenderLoop.k_MaxDirectionalLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalLightData)));
                 s_DirectionalShadowList = new ComputeBuffer(HDRenderLoop.k_MaxCascadeCount, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalShadowData)));
                 s_PunctualLightList = new ComputeBuffer(HDRenderLoop.k_MaxPunctualLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
                 m_DeferredMaterial.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
             }
 
-            public void OnDisable()
+            public void Cleanup()
-                s_DirectionalLights.Release();
-                s_DirectionalLights = null;
-                s_DirectionalShadowList.Release();
-                s_DirectionalShadowList = null;
-                s_PunctualLightList.Release();
-                s_PunctualLightList = null;
-                s_AreaLightList.Release();
-                s_AreaLightList = null;
-                s_EnvLightList.Release();
-                s_EnvLightList = null;
-                s_PunctualShadowList.Release();
-                s_PunctualShadowList = null;
+                Utilities.SafeRelease(s_DirectionalLights);
+                Utilities.SafeRelease(s_DirectionalShadowList);
+                Utilities.SafeRelease(s_PunctualLightList);
+                Utilities.SafeRelease(s_AreaLightList);
+                Utilities.SafeRelease(s_EnvLightList);
+                Utilities.SafeRelease(s_PunctualShadowList);
 
                 Utilities.Destroy(m_DeferredMaterial);
             }

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePass.hlsl

 StructuredBuffer<LightData>  	        _AreaLightList;
 StructuredBuffer<EnvLightData>          _EnvLightList;
 
-//TEXTURE2D_ARRAY(_ShadowArray);
-//SAMPLER2D_SHADOW(sampler_ShadowArray);
-//SAMPLER2D(sampler_ManualShadowArray); // TODO: settings sampler individually is not supported in shader yet...
-
 // Use texture atlas for shadow map
 //TEXTURE2D(_ShadowAtlas);
 //SAMPLER2D_SHADOW(sampler_ShadowAtlas);
 // Use texture array for IES
 TEXTURE2D_ARRAY(_IESArray);
 SAMPLER2D(sampler_IESArray);
+
+// Used by directional and spot lights
+TEXTURE2D_ARRAY(_CookieTextures);
+SAMPLER2D(sampler_CookieTextures);
+
+// Used by point lights
+TEXTURECUBE_ARRAY(_CookieCubeTextures);
+SAMPLERCUBE(sampler_CookieCubeTextures);
 
 // Use texture array for reflection
 TEXTURECUBE_ARRAY(_EnvTextures);
     // float3 shadowPosDY = ddy_fine(positionTXS);
 
     return SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, positionTXS);
+}
+
+//-----------------------------------------------------------------------------
+// Cookie sampling functions
+// ----------------------------------------------------------------------------
+
+#define SINGLE_PASS_CONTEXT_SAMPLE_COOKIE_TEXTURES 0
+
+// Used by directional and spot lights.
+// Returns the color in the RGB components, and the transparency (lack of occlusion) in A.
+float4 SampleCookie2D(LightLoopContext lightLoopContext, float2 coord, int index)
+{
+    return SAMPLE_TEXTURE2D_ARRAY_LOD(_CookieTextures, sampler_CookieTextures, coord, index, 0);
+}
+
+#define SINGLE_PASS_CONTEXT_SAMPLE_COOKIE_CUBE_TEXTURES 0
+
+// Used by point lights.
+// Returns the color in the RGB components, and the transparency (lack of occlusion) in A.
+float4 SampleCookieCube(LightLoopContext lightLoopContext, float3 coord, int index)
+{
+    return SAMPLE_TEXTURECUBE_ARRAY_LOD(_CookieCubeTextures, sampler_CookieCubeTextures, coord, index, 0);
 }
 
 //-----------------------------------------------------------------------------

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.cs

             public const int MaxNumDirLights = 2;
             public const float FltMax = 3.402823466e+38F;
 
-            static ComputeShader buildScreenAABBShader;
-            static ComputeShader buildPerTileLightListShader;     // FPTL
-            static ComputeShader buildPerBigTileLightListShader;
-            static ComputeShader buildPerVoxelLightListShader;    // clustered
+            static ComputeShader buildScreenAABBShader = null;
+            static ComputeShader buildPerTileLightListShader = null;     // FPTL
+            static ComputeShader buildPerBigTileLightListShader = null;
+            static ComputeShader buildPerVoxelLightListShader = null;    // clustered
-            private static ComputeBuffer s_LightShapeDataBuffer;
-            private static ComputeBuffer s_ConvexBoundsBuffer;
-            private static ComputeBuffer s_AABBBoundsBuffer;
-            private static ComputeBuffer s_LightList;
+            private static ComputeBuffer s_LightShapeDataBuffer = null;
+            private static ComputeBuffer s_ConvexBoundsBuffer = null;
+            private static ComputeBuffer s_AABBBoundsBuffer = null;
+            private static ComputeBuffer s_LightList = null;
-            private static ComputeBuffer s_BigTileLightList;        // used for pre-pass coarse culling on 64x64 tiles
+            private static ComputeBuffer s_BigTileLightList = null;        // used for pre-pass coarse culling on 64x64 tiles
-            public bool disableFptlWhenClustered = false;    // still useful on opaques
+            public bool disableFptlWhenClustered = true;    // still useful on opaques. Should be false by default to force tile on opaque.
             public bool enableBigTilePrepass = true;
             public bool enableDrawLightBoundsDebug = false;
             public bool enableDirectIndirectSinglePass = false;
             const int k_Log2NumClusters = 6;     // accepted range is from 0 to 6. NumClusters is 1<<g_iLog2NumClusters
             const float k_ClustLogBase = 1.02f;     // each slice 2% bigger than the previous
             float m_ClustScale;
-            private static ComputeBuffer s_PerVoxelLightLists;
-            private static ComputeBuffer s_PerVoxelOffset;
-            private static ComputeBuffer s_PerTileLogBaseTweak;
-            private static ComputeBuffer s_GlobalLightListAtomic;
+            private static ComputeBuffer s_PerVoxelLightLists = null;
+            private static ComputeBuffer s_PerVoxelOffset = null;
+            private static ComputeBuffer s_PerTileLogBaseTweak = null;
+            private static ComputeBuffer s_GlobalLightListAtomic = null;
             // clustered light list specific buffers and data end
 
             SFiniteLightBound[] m_boundData;
             }
 
             // Static keyword is required here else we get a "DestroyBuffer can only be call in main thread"
-            static ComputeBuffer s_DirectionalLights;
-            static ComputeBuffer s_PunctualLightList;
-            static ComputeBuffer s_EnvLightList;
-            static ComputeBuffer s_AreaLightList;
-            static ComputeBuffer s_PunctualShadowList;
-            static ComputeBuffer s_DirectionalShadowList;
+            static ComputeBuffer s_DirectionalLights = null;
+            static ComputeBuffer s_PunctualLightList = null;
+            static ComputeBuffer s_EnvLightList = null;
+            static ComputeBuffer s_AreaLightList = null;
+            static ComputeBuffer s_PunctualShadowList = null;
+            static ComputeBuffer s_DirectionalShadowList = null;
-            Material m_DeferredDirectMaterial;
-            Material m_DeferredIndirectMaterial;
-            Material m_DeferredAllMaterial;
-            Material m_DebugViewTilesMaterial;
+            Material m_DeferredDirectMaterial = null;
+            Material m_DeferredIndirectMaterial = null;
+            Material m_DeferredAllMaterial = null;
+            Material m_DebugViewTilesMaterial = null;
 
             const int k_TileSize = 16;
 
                 return (camera.pixelHeight + (k_TileSize - 1)) / k_TileSize;
             }
 
-            // Local function
-            void ClearComputeBuffers()
-            {
-                ReleaseResolutionDependentBuffers();
-
-                if (s_AABBBoundsBuffer != null)
-                    s_AABBBoundsBuffer.Release();
-
-                if (s_ConvexBoundsBuffer != null)
-                    s_ConvexBoundsBuffer.Release();
-
-                if (s_LightShapeDataBuffer != null)
-                    s_LightShapeDataBuffer.Release();
-
-                if (enableClustered)
-                {
-                    if (s_GlobalLightListAtomic != null)
-                        s_GlobalLightListAtomic.Release();
-                }
-
-                if (s_DirectionalLights != null)
-                    s_DirectionalLights.Release();
-
-                if (s_DirectionalShadowList != null)
-                    s_DirectionalShadowList.Release();
-
-                if (s_PunctualLightList != null)
-                    s_PunctualLightList.Release();
-
-                if (s_AreaLightList != null)
-                    s_AreaLightList.Release();
-
-                if (s_PunctualShadowList != null)
-                    s_PunctualShadowList.Release();
-
-                if (s_EnvLightList != null)
-                    s_EnvLightList.Release();
-            }
-
-                ClearComputeBuffers();
-
                 buildScreenAABBShader = Resources.Load<ComputeShader>("scrbound");
                 buildPerTileLightListShader = Resources.Load<ComputeShader>("lightlistbuild");
                 buildPerBigTileLightListShader = Resources.Load<ComputeShader>("lightlistbuild-bigtile");
                 m_DeferredAllMaterial.DisableKeyword("LIGHTLOOP_TILE_INDIRECT");
                 m_DeferredAllMaterial.EnableKeyword("LIGHTLOOP_TILE_ALL");
 
-
-
-            public void OnDisable()
+            public void Cleanup()
-                // TODO: do something for Resources.Load<ComputeShader> ?
-
-                s_AABBBoundsBuffer.Release();
-                s_ConvexBoundsBuffer.Release();
-                s_LightShapeDataBuffer.Release();
-                if (enableClustered)
-                {
-                    s_GlobalLightListAtomic.Release();
-                }
+                Utilities.SafeRelease(s_AABBBoundsBuffer);
+                Utilities.SafeRelease(s_ConvexBoundsBuffer);
+                Utilities.SafeRelease(s_LightShapeDataBuffer);           
-                s_DirectionalLights.Release();
-                s_DirectionalLights = null;
-                s_DirectionalShadowList.Release();
-                s_DirectionalShadowList = null;
-                s_PunctualLightList.Release();
-                s_PunctualLightList = null;
-                s_AreaLightList.Release();
-                s_AreaLightList = null;
-                s_EnvLightList.Release();
-                s_EnvLightList = null;
-                s_PunctualShadowList.Release();
-                s_PunctualShadowList = null;
+                // enableClustered
+                Utilities.SafeRelease(s_GlobalLightListAtomic);
+
+                Utilities.SafeRelease(s_DirectionalLights);
+                Utilities.SafeRelease(s_DirectionalShadowList);
+                Utilities.SafeRelease(s_PunctualLightList);
+                Utilities.SafeRelease(s_AreaLightList);
+                Utilities.SafeRelease(s_EnvLightList);
+                Utilities.SafeRelease(s_PunctualShadowList);
 
                 Utilities.Destroy(m_DeferredDirectMaterial);
                 Utilities.Destroy(m_DeferredIndirectMaterial);
 
             public bool NeedResize()
             {
-                return s_LightList == null || (s_BigTileLightList == null && enableBigTilePrepass) || (s_PerVoxelLightLists == null && enableClustered);
+                return  s_LightList == null || 
+                        (s_BigTileLightList == null && enableBigTilePrepass) || 
+                        (s_PerVoxelLightLists == null && enableClustered);
-                if (s_LightList != null)
-                    s_LightList.Release();
-
-                if (enableClustered)
-                {
-                    if (s_PerVoxelLightLists != null)
-                        s_PerVoxelLightLists.Release();
+                Utilities.SafeRelease(s_LightList);
-                    if (s_PerVoxelOffset != null)
-                        s_PerVoxelOffset.Release();
+                // enableClustered
+                Utilities.SafeRelease(s_PerVoxelLightLists);
+                Utilities.SafeRelease(s_PerVoxelOffset);
+                Utilities.SafeRelease(s_PerTileLogBaseTweak);
-                    if (k_UseDepthBuffer && s_PerTileLogBaseTweak != null)
-                        s_PerTileLogBaseTweak.Release();
-                }
-
-                if (enableBigTilePrepass)
-                {
-                    if (s_BigTileLightList != null)
-                        s_BigTileLightList.Release();
-                }
+                // enableBigTilePrepass
+                Utilities.SafeRelease(s_BigTileLightList);
             }
 
             int NumLightIndicesPerClusteredTile()
                 m_DeferredAllMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
                 m_DeferredAllMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                 m_DeferredAllMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                
+
+                m_DebugViewTilesMaterial.SetMatrix("_InvViewProjMatrix", invViewProj);
                 m_DebugViewTilesMaterial.SetVector("_ScreenSize", screenSize);
                 m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)debugViewTilesFlags);
                 m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
 
                     var cmd = new CommandBuffer();
                     cmd.SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
+
+                    cmd.name = bUseClusteredForDeferred ? "Clustered pass" : "Tiled pass";
 
                     // In case of bUseClusteredForDeferred disable toggle option since we're using m_perVoxelLightLists as opposed to lightList
                     if (bUseClusteredForDeferred)

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.hlsl

 // these uniforms are only needed for when OPAQUES_ONLY is NOT defined
 // but there's a problem with our front-end compilation of compute shaders with multiple kernels causing it to error
 //#ifdef USE_CLUSTERED_LIGHTLIST
+float4x4 g_mInvScrProjection;
+
 float g_fClustScale;
 float g_fClustBase;
 float g_fNearPlane;

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePassLoop.hlsl

         return FetchIndexCluster(tileOffset, lightIndex);
 }
 
-float GetLinearDepth(float zDptBufSpace)    // 0 is near 1 is far
-{
-    // todo (simplify): m22 is zero and m23 is +1/-1 (depends on left/right hand proj)
-    float m22 = g_mInvScrProjection[2].z, m23 = g_mInvScrProjection[2].w;
-    float m32 = g_mInvScrProjection[3].z, m33 = g_mInvScrProjection[3].w;
-
-    return (m22 * zDptBufSpace + m23) / (m32 * zDptBufSpace + m33);
-
-    //float3 vP = float3(0.0f,0.0f,zDptBufSpace);
-    //float4 v4Pres = mul(g_mInvScrProjection, float4(vP,1.0));
-    //return v4Pres.z / v4Pres.w;
-}
-
 #endif
 
 // bakeDiffuseLighting is part of the prototype so a user is able to implement a "base pass" with GI and multipass direct light (aka old unity rendering path)
 {
 #ifdef USE_CLUSTERED_LIGHTLIST
-    // TODO: Think more about the design, it is ok to do that ? hope the compiler could optimize it out as we already depth before LightLoop call, else need to pass it as argument...
-    float depth = LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).x;
-    float linearDepth = GetLinearDepth(depth); // View space linear depth
+    float linearDepth = TransformWorldToView(positionWS).z; // View space linear depth
 #else
     float linearDepth = 0.0; // unused
 #endif

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/Lit.cs

                 isInit = false;
             }
 
-            public void OnDisable()
+            public void Cleanup()
-                if (m_InitPreFGD) DestroyImmediate(m_InitPreFGD);
+                Utilities.Destroy(m_InitPreFGD);
+
                 // TODO: how to delete RenderTexture ?
                 isInit = false;
             }

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

     float3 L = lightData.direction;
     float illuminance = saturate(dot(bsdfData.normalWS, L));
 
-    diffuseLighting = float3(0.0, 0.0, 0.0);
-    specularLighting = float3(0.0, 0.0, 0.0);
+    diffuseLighting    = float3(0.0, 0.0, 0.0);
+    specularLighting   = float3(0.0, 0.0, 0.0);
+    float3 cookieColor = float3(1.0, 1.0, 1.0);
 
     [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0f)
     {
     }
 
+    [branch] if (lightData.cookieIndex >= 0 && illuminance > 0.0)
+    {
+        float3 unL = positionWS - lightData.positionWS;
+
+        // Project 'unL' onto the light's axes.
+        float2 coord = float2(dot(unL, lightData.right), dot(unL, lightData.up));
+
+        // Rescale the texture.
+        coord.x *= lightData.invScaleX;
+        coord.y *= lightData.invScaleY;
+
+        // 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);
+
+        float4 cookie = SampleCookie2D(lightLoopContext, coord, lightData.cookieIndex);
+
+        cookieColor  = cookie.rgb;
+        illuminance *= cookie.a;
+    }
+
-        diffuseLighting *= lightData.color * illuminance * lightData.diffuseScale;
-        specularLighting *= lightData.color * illuminance * lightData.specularScale;
+        diffuseLighting  *= (cookieColor * lightData.color) * (illuminance * lightData.diffuseScale);
+        specularLighting *= (cookieColor * lightData.color) * (illuminance * lightData.specularScale);
     }
 }
 
     attenuation *= GetAngleAttenuation(L, -lightData.forward, lightData.angleScale, lightData.angleOffset);
     float illuminance = saturate(dot(bsdfData.normalWS, L)) * attenuation;
 
-    diffuseLighting = float3(0.0, 0.0, 0.0);
-    specularLighting = float3(0.0, 0.0, 0.0);
+    diffuseLighting    = float3(0.0, 0.0, 0.0);
+    specularLighting   = float3(0.0, 0.0, 0.0);
+    float3 cookieColor = float3(1.0, 1.0, 1.0);
-    /*
-    [branch] if (lightData.cookieIndex && illuminance > 0.0f)
+    [branch] if (lightData.cookieIndex >= 0 && illuminance > 0.0)
-        illuminance *= SampleCookie(lightData.cookieIndex, lightToWorld, L);
+
+        // Rotate 'L' into the light space.
+        // We perform the negation because lights are oriented backwards (-Z).
+        float3 coord = mul(-L, transpose(lightToWorld));
+
+        float4 cookie;
+
+        [branch] if (lightData.lightType == GPULIGHTTYPE_SPOT)
+        {
+            // Perform the perspective projection of the hemisphere onto the disk.
+            coord.xy /= coord.z;
+
+            // Rescale the projective coordinates to fit into the [-1, 1]^2 range.
+            float cotOuterHalfAngle = lightData.size.x;
+            coord.xy *= cotOuterHalfAngle;
+
+            // Remap the texture coordinates from [-1, 1]^2 to [0, 1]^2.
+            coord.xy = coord.xy * 0.5 + 0.5;
+
+            cookie = SampleCookie2D(lightLoopContext, coord.xy, lightData.cookieIndex);
+        }
+        else // GPULIGHTTYPE_POINT
+        {
+            cookie = SampleCookieCube(lightLoopContext, coord, lightData.cookieIndex);
+        }
+
+        cookieColor  = cookie.rgb;
+        illuminance *= cookie.a;
-    */
-    [branch] if (lightData.IESIndex >= 0 && illuminance > 0.0f)
+    [branch] if (lightData.IESIndex >= 0 && illuminance > 0.0)
     {
         float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
         float2 sphericalCoord = GetIESTextureCoordinate(lightToWorld, L);
-    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0f)
+    [branch] if (lightData.shadowIndex >= 0 && illuminance > 0.0)
     {
         float3 offset = float3(0.0, 0.0, 0.0); // GetShadowPosOffset(nDotL, normal);
         float shadowAttenuation = GetPunctualShadowAttenuation(lightLoopContext, positionWS + offset, lightData.shadowIndex, L, preLightData.unPositionSS);
     }
 
-    [branch] if (illuminance > 0.0f)
+    [branch] if (illuminance > 0.0)
-        diffuseLighting *= lightData.color * illuminance * lightData.diffuseScale;
-        specularLighting *= lightData.color * illuminance * lightData.specularScale;
+
+        diffuseLighting  *= (cookieColor * lightData.color) * (illuminance * lightData.diffuseScale);
+        specularLighting *= (cookieColor * lightData.color) * (illuminance * lightData.specularScale);
     }
 }
 

Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl

 // TODO: move this to constant buffer by Pass
 float4		_ScreenSize;
 
+float4x4 GetWorldToViewMatrix()
+{
+    return unity_MatrixV;
+}
 
 float4x4 GetObjectToWorldMatrix()
 {
     return unity_WorldTransformParams.w;
 }
 
-
+}
+
+float3 TransformWorldToView(float3 positionWS)
+{
+    return mul(GetWorldToViewMatrix(), float4(positionWS, 1.0)).xyz;
 }
 
 float3 TransformObjectToWorld(float3 positionOS)

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/AtmosphericParameters.cs

         if (instance == this)
         {
             // TODO: what's the point of doing this?
-            OnDisable();
+            Cleanup();
             OnEnable();
         }
 
         instance = this;
     }
 
-    void OnDisable()
+    void Cleanup()
     {
         // Undefine all preprocessor symbols.
         UpdateKeywords(false);

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/SkyRenderer.cs

             if ((m_SkyboxCubemapRT != null) && (m_SkyboxCubemapRT.width != (int)skyParameters.skyResolution))
             {
                 Utilities.Destroy(m_SkyboxCubemapRT);
-                m_SkyboxCubemapRT = null;
-                m_SkyboxGGXCubemapRT = null;
             }
             
             if (m_SkyboxCubemapRT == null)
             }
         }
 
-        public void OnDisable()
+        public void Cleanup()
         {
             Utilities.Destroy(m_StandardSkyboxMaterial);
             Utilities.Destroy(m_SkyHDRIMaterial);

Assets/ScriptableRenderLoop/HDRenderLoop/Utilities.cs

 #else
                     UnityObject.Destroy(obj);
 #endif
+                obj = null;
+            }
+        }
+
+        public static void SafeRelease(ComputeBuffer buffer)
+        {
+            if (buffer != null)
+            {
+                buffer.Release();
+                buffer = null;
             }
         }
 

Assets/ScriptableRenderLoop/ShaderLibrary/AreaLighting.hlsl

     float tLDDL2 = l2rcpD / (d * d + l2 * l2);
     float intWt  = LineFwt(tLDDL2, l2) - LineFwt(tLDDL1, l1);
     float intP0  = LineFpo(tLDDL2, l2rcpD, rcp(d)) - LineFpo(tLDDL1, l1rcpD, rcp(d));
-    // Guard against numerical precision issues.
-    return max(intP0 * normal.z + intWt * tangent.z, 0.0);
+    return intP0 * normal.z + intWt * tangent.z;
 }
 
 // Computes 1.0 / length(mul(ortho, transpose(inverse(invM)))).
 
     float width = ComputeLineWidthFactor(invM, B);
 
-    if (P2.z <= 0.0)
+    if (P1.z > P2.z)
-        // Convention: 'P2' is above the horizon.
+        // Convention: 'P2' is above 'P1', with the tangent pointing upwards.
         Swap(P1, P2);
     }
 
     // Integrate the clamped cosine over the line segment.
     float irradiance = LineIrradiance(l1, l2, P0, T);
 
-    return INV_PI * width * irradiance;
+    // Guard against numerical precision issues.
+    return max(INV_PI * width * irradiance, 0.0);
 }
 
 #endif // UNITY_AREA_LIGHTING_INCLUDED

Assets/ScriptableRenderLoop/common/TextureSettings.cs

-[System.Serializable]
-public struct TextureSettings
+namespace UnityEngine.Experimental.ScriptableRenderLoop
-    public uint spotCookieSize;
-    public uint pointCookieSize;
-    public uint reflectionCubemapSize;
+    [System.Serializable]
+    public struct TextureSettings
+    {
+        public int spotCookieSize;
+        public int pointCookieSize;
+        public int reflectionCubemapSize;
-    public static TextureSettings Default
-    {
-        get
+        public static TextureSettings Default
-            TextureSettings settings;
-            settings.spotCookieSize = 128;
-            settings.pointCookieSize = 512;
-            settings.reflectionCubemapSize = 128;
-            return settings;
+            get
+            {
+                TextureSettings settings = new TextureSettings();
+                settings.spotCookieSize = 128;
+                settings.pointCookieSize = 512;
+                settings.reflectionCubemapSize = 128;
+                return settings;
+            }
         }
     }
 }

Assets/ScriptableRenderLoop/fptl/FptlLighting.cs

             m_CookieTexArray = new TextureCache2D();
             m_CubeCookieTexArray = new TextureCacheCubemap();
             m_CubeReflTexArray = new TextureCacheCubemap();
-            m_CookieTexArray.AllocTextureArray(8, (int)m_TextureSettings.spotCookieSize, (int)m_TextureSettings.spotCookieSize, TextureFormat.RGBA32, true);
-            m_CubeCookieTexArray.AllocTextureArray(4, (int)m_TextureSettings.pointCookieSize, TextureFormat.RGBA32, true);
-            m_CubeReflTexArray.AllocTextureArray(64, (int)m_TextureSettings.reflectionCubemapSize, TextureFormat.BC6H, true);
+            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, TextureFormat.BC6H, true);
 
             //m_DeferredMaterial.SetTexture("_spotCookieTextures", m_cookieTexArray.GetTexCache());
             //m_DeferredMaterial.SetTexture("_pointCookieTextures", m_cubeCookieTexArray.GetTexCache());

Assets/TestScenes/HDTest/HDRenderLoopTest.unity

     minRegionArea: 2
     manualCellSize: 0
     cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
     accuratePlacement: 0
   m_NavMeshData: {fileID: 0}
 --- !u!1 &68487706
     m_RemovedComponents: []
   m_ParentPrefab: {fileID: 100100000, guid: 646b4ac0331f8e447bd20f06eba916a3, type: 3}
   m_IsPrefabParent: 0
+--- !u!1 &192903503
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 192903504}
+  - component: {fileID: 192903506}
+  - component: {fileID: 192903505}
+  m_Layer: 0
+  m_Name: Spot Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &192903504
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 192903503}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: -0.05, y: -0.25, z: -2.0000005}
+  m_LocalScale: {x: 0, y: 0, z: 1.0000005}
+  m_Children: []
+  m_Father: {fileID: 2026378394}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 90, y: 0, z: 0}
+--- !u!114 &192903505
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 192903503}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  shadowResolution: 512
+  shadowDimmer: 1
+  affectDiffuse: 1
+  affectSpecular: 1
+  archetype: 0
+  isDoubleSided: 1
+  areaLightLength: 4
+  areaLightWidth: 2
+--- !u!108 &192903506
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 192903503}
+  m_Enabled: 1
+  serializedVersion: 7
+  m_Type: 0
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_Intensity: 50
+  m_Range: 6
+  m_SpotAngle: 60
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 0
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 2800000, guid: 32c4b9c8ddc1c5d49ac7d10122540447, type: 3}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
 --- !u!1 &209784732
 GameObject:
   m_ObjectHideFlags: 0
   m_Name: 
   m_EditorClassIdentifier: 
   worldRayleighColorRamp:
-    key0:
-      serializedVersion: 2
-      rgba: 4288243277
-    key1:
-      serializedVersion: 2
-      rgba: 4291598720
-    key2:
-      serializedVersion: 2
-      rgba: 0
-    key3:
-      serializedVersion: 2
-      rgba: 0
-    key4:
-      serializedVersion: 2
-      rgba: 0
-    key5:
-      serializedVersion: 2
-      rgba: 0
-    key6:
-      serializedVersion: 2
-      rgba: 0
-    key7:
-      serializedVersion: 2
-      rgba: 0
+    serializedVersion: 2
+    key0: {r: 0.3019608, g: 0.4, b: 0.6, a: 1}
+    key1: {r: 0.5019608, g: 0.6, b: 0.8, a: 1}
+    key2: {r: 0, g: 0, b: 0, a: 0}
+    key3: {r: 0, g: 0, b: 0, a: 0}
+    key4: {r: 0, g: 0, b: 0, a: 0}
+    key5: {r: 0, g: 0, b: 0, a: 0}
+    key6: {r: 0, g: 0, b: 0, a: 0}
+    key7: {r: 0, g: 0, b: 0, a: 0}
     ctime0: 0
     ctime1: 65535
     ctime2: 0
   worldRayleighExtinctionFactor: 1.1
   worldRayleighIndirectScatter: 0.33
   worldMieColorRamp:
-    key0:
-      serializedVersion: 2
-      rgba: 4286627826
-    key1:
-      serializedVersion: 2
-      rgba: 4294960895
-    key2:
-      serializedVersion: 2
-      rgba: 0
-    key3:
-      serializedVersion: 2
-      rgba: 0
-    key4:
-      serializedVersion: 2
-      rgba: 0
-    key5:
-      serializedVersion: 2
-      rgba: 0
-    key6:
-      serializedVersion: 2
-      rgba: 0
-    key7:
-      serializedVersion: 2
-      rgba: 0
+    serializedVersion: 2
+    key0: {r: 0.9490196, g: 0.7490196, b: 0.5019608, a: 1}
+    key1: {r: 1, g: 0.9019608, b: 1, a: 1}
+    key2: {r: 0, g: 0, b: 0, a: 0}
+    key3: {r: 0, g: 0, b: 0, a: 0}
+    key4: {r: 0, g: 0, b: 0, a: 0}
+    key5: {r: 0, g: 0, b: 0, a: 0}
+    key6: {r: 0, g: 0, b: 0, a: 0}
+    key7: {r: 0, g: 0, b: 0, a: 0}
     ctime0: 0
     ctime1: 65535
     ctime2: 0
   heightPlaneShift: {x: 0, y: 0, z: 0}
   heightNearScatterPush: 0
   heightNormalDistance: 1000
+  atmosphericShaderOverride: {fileID: 0}
-  atmosphericShader: {fileID: 0}
+  depthTexture: 0
   debugMode: 0
 --- !u!1 &609148480
 GameObject:
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1
-  m_Range: 10
+  m_Range: 12
   m_SpotAngle: 30
   m_CookieSize: 10
   m_Shadows:
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1
-  m_Range: 10
+  m_Range: 12
   m_SpotAngle: 30
   m_CookieSize: 10
   m_Shadows:
   m_Father: {fileID: 1586360512}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &858501138
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 858501139}
+  - component: {fileID: 858501141}
+  - component: {fileID: 858501140}
+  m_Layer: 0
+  m_Name: Point Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &858501139
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 858501138}
+  m_LocalRotation: {x: -0, y: 0, z: -0, w: 1}
+  m_LocalPosition: {x: 0.25, y: -0, z: -2.72}
+  m_LocalScale: {x: 0, y: 0, z: 1}
+  m_Children: []
+  m_Father: {fileID: 2026378394}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 90, y: 0, z: 0}
+--- !u!114 &858501140
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 858501138}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  shadowResolution: 512
+  shadowDimmer: 1
+  affectDiffuse: 1
+  affectSpecular: 1
+  archetype: 0
+  isDoubleSided: 1
+  areaLightLength: 4
+  areaLightWidth: 2
+--- !u!108 &858501141
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 858501138}
+  m_Enabled: 1
+  serializedVersion: 7
+  m_Type: 2
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_Intensity: 50
+  m_Range: 6
+  m_SpotAngle: 30
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 0
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 8900000, guid: 7daac0a2e2877f94fb9990a7e09d9691, type: 3}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
 --- !u!1 &891124079
 GameObject:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1072084077}
   m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!1 &1085128921
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1085128922}
+  - component: {fileID: 1085128924}
+  - component: {fileID: 1085128923}
+  m_Layer: 0
+  m_Name: Directional light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1085128922
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1085128921}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: -0.3, y: 0, z: -2.0000005}
+  m_LocalScale: {x: 1, y: 1, z: 1.0000005}
+  m_Children: []
+  m_Father: {fileID: 2026378394}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 90, y: 0, z: 0}
+--- !u!114 &1085128923
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1085128921}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  shadowResolution: 512
+  shadowDimmer: 1
+  affectDiffuse: 1
+  affectSpecular: 1
+  archetype: 0
+  isDoubleSided: 1
+  areaLightLength: 4
+  areaLightWidth: 2
+--- !u!108 &1085128924
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1085128921}
+  m_Enabled: 1
+  serializedVersion: 7
+  m_Type: 1
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_Intensity: 10
+  m_Range: 6
+  m_SpotAngle: 30
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 0
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 2800000, guid: 32c4b9c8ddc1c5d49ac7d10122540447, type: 3}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
 --- !u!1 &1124705054
 GameObject:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1269195139}
   m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!1 &1279943772
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1279943773}
+  - component: {fileID: 1279943776}
+  - component: {fileID: 1279943775}
+  - component: {fileID: 1279943774}
+  m_Layer: 0
+  m_Name: Quad
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1279943773
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1279943772}
+  m_LocalRotation: {x: -0.7071068, y: 0, z: 0, w: 0.7071068}
+  m_LocalPosition: {x: 0.2515, y: 0.0954, z: -1.61}
+  m_LocalScale: {x: 0.3, y: 8, z: 1}
+  m_Children: []
+  m_Father: {fileID: 2026378394}
+  m_RootOrder: 4
+  m_LocalEulerAnglesHint: {x: -90, y: 0, z: 0}
+--- !u!23 &1279943774
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1279943772}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: f03665895dc89b84487310c5216b8458, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!64 &1279943775
+MeshCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1279943772}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Convex: 0
+  m_InflateMesh: 0
+  m_SkinWidth: 0.01
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!33 &1279943776
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1279943772}
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
 --- !u!1001 &1314842926
 Prefab:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1989256444}
   m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!1 &2015022933
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 2015022934}
+  - component: {fileID: 2015022936}
+  - component: {fileID: 2015022935}
+  m_Layer: 0
+  m_Name: Spot Light (1)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2015022934
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2015022933}
+  m_LocalRotation: {x: -0.258819, y: 0, z: 0, w: 0.9659259}
+  m_LocalPosition: {x: -0.05, y: 0, z: -2}
+  m_LocalScale: {x: 0, y: 0, z: 1.0000005}
+  m_Children: []
+  m_Father: {fileID: 2026378394}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: -30, y: 0, z: 0}
+--- !u!114 &2015022935
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2015022933}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  shadowResolution: 512
+  shadowDimmer: 1
+  affectDiffuse: 1
+  affectSpecular: 1
+  archetype: 0
+  isDoubleSided: 1
+  areaLightLength: 4
+  areaLightWidth: 2
+--- !u!108 &2015022936
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2015022933}
+  m_Enabled: 1
+  serializedVersion: 7
+  m_Type: 0
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_Intensity: 50
+  m_Range: 6
+  m_SpotAngle: 60
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 0
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 2800000, guid: 32c4b9c8ddc1c5d49ac7d10122540447, type: 3}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
 --- !u!1 &2018759379
 GameObject:
   m_ObjectHideFlags: 0
   m_Children: []
   m_Father: {fileID: 1269195140}
   m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &2026378390
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 2026378394}
+  - component: {fileID: 2026378393}
+  - component: {fileID: 2026378392}
+  - component: {fileID: 2026378391}
+  m_Layer: 0
+  m_Name: Test - Light Cookies
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!23 &2026378391
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2026378390}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: f03665895dc89b84487310c5216b8458, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!64 &2026378392
+MeshCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2026378390}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Convex: 0
+  m_InflateMesh: 0
+  m_SkinWidth: 0.01
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!33 &2026378393
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2026378390}
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &2026378394
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2026378390}
+  m_LocalRotation: {x: 0.7071068, y: -0, z: -0, w: 0.7071068}
+  m_LocalPosition: {x: -125, y: -0, z: 36}
+  m_LocalScale: {x: 20, y: 12, z: 1}
+  m_Children:
+  - {fileID: 858501139}
+  - {fileID: 192903504}
+  - {fileID: 2015022934}
+  - {fileID: 1085128922}
+  - {fileID: 1279943773}
+  m_Father: {fileID: 0}
+  m_RootOrder: 27
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &2028486192
 GameObject: