Merge pull request #142 from Unity-Technologies/postfx-temp

Added more temporary post-processing effects per request

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Editor/PostProcessingEditor.cs

+using System;
+using System.Linq.Expressions;
 using UnityEngine;
 using UnityEngine.Experimental.Rendering.HDPipeline;
 
     [CustomEditor(typeof(PostProcessing))]
     public class PostProcessingEditor : Editor
     {
+        #region Serialized settings
         public class ColorGradingSettings
         {
             public SerializedProperty type;
             public SerializedProperty logMax;
         }
 
+        public class ChromaticAberrationSettings
+        {
+            public SerializedProperty enabled;
+            public SerializedProperty spectralTexture;
+            public SerializedProperty intensity;
+        }
+
+        public class VignetteSettings
+        {
+            public SerializedProperty enabled;
+            public SerializedProperty color;
+            public SerializedProperty center;
+            public SerializedProperty intensity;
+            public SerializedProperty smoothness;
+        }
+
+        public class BloomSettings
+        {
+            public SerializedProperty enabled;
+            public SerializedProperty intensity;
+            public SerializedProperty threshold;
+            public SerializedProperty softKnee;
+            public SerializedProperty radius;
+            public SerializedProperty lensTexture;
+            public SerializedProperty lensIntensity;
+        }
+        #endregion
+
+        public ChromaticAberrationSettings chromaSettings;
+        public VignetteSettings vignetteSettings;
+        public BloomSettings bloomSettings;
+        public SerializedProperty globalDithering;
+
+        SerializedProperty FindProperty<TValue>(Expression<Func<PostProcessing, TValue>> expr)
+        {
+            var path = Utilities.GetFieldPath(expr);
+            return serializedObject.FindProperty(path);
+        }
-            colorGrading = new ColorGradingSettings()
+            colorGrading = new ColorGradingSettings
-                type = serializedObject.FindProperty("colorGrading.type"),
-                exposure = serializedObject.FindProperty("colorGrading.exposure"),
+                type = FindProperty(x => x.colorGrading.type),
+                exposure = FindProperty(x => x.colorGrading.exposure),
-                logLut = serializedObject.FindProperty("colorGrading.logLut"),
+                logLut = FindProperty(x => x.colorGrading.logLut),
-                neutralBlackIn = serializedObject.FindProperty("colorGrading.neutralBlackIn"),
-                neutralWhiteIn = serializedObject.FindProperty("colorGrading.neutralWhiteIn"),
-                neutralBlackOut = serializedObject.FindProperty("colorGrading.neutralBlackOut"),
-                neutralWhiteOut = serializedObject.FindProperty("colorGrading.neutralWhiteOut"),
-                neutralWhiteLevel = serializedObject.FindProperty("colorGrading.neutralWhiteLevel"),
-                neutralWhiteClip = serializedObject.FindProperty("colorGrading.neutralWhiteClip")
+                neutralBlackIn = FindProperty(x => x.colorGrading.neutralBlackIn),
+                neutralWhiteIn = FindProperty(x => x.colorGrading.neutralWhiteIn),
+                neutralBlackOut = FindProperty(x => x.colorGrading.neutralBlackOut),
+                neutralWhiteOut = FindProperty(x => x.colorGrading.neutralWhiteOut),
+                neutralWhiteLevel = FindProperty(x => x.colorGrading.neutralWhiteLevel),
+                neutralWhiteClip = FindProperty(x => x.colorGrading.neutralWhiteClip)
-            eyeAdaptation = new EyeAdaptationSettings()
+            eyeAdaptation = new EyeAdaptationSettings
-                enabled = serializedObject.FindProperty("eyeAdaptation.enabled"),
-                showDebugHistogramInGameView = serializedObject.FindProperty("eyeAdaptation.showDebugHistogramInGameView"),
+                enabled = FindProperty(x => x.eyeAdaptation.enabled),
+                showDebugHistogramInGameView = FindProperty(x => x.eyeAdaptation.showDebugHistogramInGameView),
-                lowPercent = serializedObject.FindProperty("eyeAdaptation.lowPercent"),
-                highPercent = serializedObject.FindProperty("eyeAdaptation.highPercent"),
+                lowPercent = FindProperty(x => x.eyeAdaptation.lowPercent),
+                highPercent = FindProperty(x => x.eyeAdaptation.highPercent),
-                minLuminance = serializedObject.FindProperty("eyeAdaptation.minLuminance"),
-                maxLuminance = serializedObject.FindProperty("eyeAdaptation.maxLuminance"),
-                exposureCompensation = serializedObject.FindProperty("eyeAdaptation.exposureCompensation"),
+                minLuminance = FindProperty(x => x.eyeAdaptation.minLuminance),
+                maxLuminance = FindProperty(x => x.eyeAdaptation.maxLuminance),
+                exposureCompensation = FindProperty(x => x.eyeAdaptation.exposureCompensation),
-                adaptationType = serializedObject.FindProperty("eyeAdaptation.adaptationType"),
+                adaptationType = FindProperty(x => x.eyeAdaptation.adaptationType),
+
+                speedUp = FindProperty(x => x.eyeAdaptation.speedUp),
+                speedDown = FindProperty(x => x.eyeAdaptation.speedDown),
-                speedUp = serializedObject.FindProperty("eyeAdaptation.speedUp"),
-                speedDown = serializedObject.FindProperty("eyeAdaptation.speedDown"),
+                logMin = FindProperty(x => x.eyeAdaptation.logMin),
+                logMax = FindProperty(x => x.eyeAdaptation.logMax)
+            };
-                logMin = serializedObject.FindProperty("eyeAdaptation.logMin"),
-                logMax = serializedObject.FindProperty("eyeAdaptation.logMax")
+            chromaSettings = new ChromaticAberrationSettings
+            {
+                enabled = FindProperty(x => x.chromaSettings.enabled),
+                spectralTexture = FindProperty(x => x.chromaSettings.spectralTexture),
+                intensity = FindProperty(x => x.chromaSettings.intensity)
+
+            vignetteSettings = new VignetteSettings
+            {
+                enabled = FindProperty(x => x.vignetteSettings.enabled),
+                color = FindProperty(x => x.vignetteSettings.color),
+                center = FindProperty(x => x.vignetteSettings.center),
+                intensity = FindProperty(x => x.vignetteSettings.intensity),
+                smoothness = FindProperty(x => x.vignetteSettings.smoothness)
+            };
+
+            bloomSettings = new BloomSettings
+            {
+                enabled = FindProperty(x => x.bloomSettings.enabled),
+
+                intensity = FindProperty(x => x.bloomSettings.intensity),
+                threshold = FindProperty(x => x.bloomSettings.threshold),
+
+                softKnee = FindProperty(x => x.bloomSettings.softKnee),
+                radius = FindProperty(x => x.bloomSettings.radius),
+
+                lensTexture = FindProperty(x => x.bloomSettings.lensTexture),
+                lensIntensity = FindProperty(x => x.bloomSettings.lensIntensity)
+            };
+
+            globalDithering = FindProperty(x => x.globalDithering);
         }
 
         public override void OnInspectorGUI()
-            var camera = (target as PostProcessing).GetComponent<Camera>();
-            if (camera == null)
-                EditorGUILayout.HelpBox("Global post-processing settings will be overriden by local camera settings. Global settings are the only one visible in the scene view.", MessageType.Info);
+            Do("Color Grading", ColorGradingUI);
+            Do("Eye Adaptation", EyeAdaptationUI);
+            Do("Bloom", BloomUI);
+            Do("Chromatic Aberration", ChromaticAberrationUI);
+            Do("Vignette", VignetteUI);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.PropertyField(globalDithering);
-            EditorGUILayout.LabelField("Color Grading", EditorStyles.boldLabel);
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        void Do(string header, Action func)
+        {
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField(header, EditorStyles.boldLabel);
+            if (func != null)
+                func();
+
+            EditorGUI.indentLevel--;
+        }
+
+        void ColorGradingUI()
+        {
+            var camera = (target as PostProcessing).GetComponent<Camera>();
             if (camera != null)
             {
                 using (new EditorGUILayout.HorizontalScope())
             }
 
             EditorGUI.indentLevel--;
-            EditorGUI.indentLevel--;
+        }
-            EditorGUILayout.LabelField("Eye Adaptation", EditorStyles.boldLabel);
-
-            EditorGUI.indentLevel++;
-
+        void EyeAdaptationUI()
+        {
             EditorGUILayout.PropertyField(eyeAdaptation.enabled);
 
             if (eyeAdaptation.enabled.boolValue)
                     EditorGUI.indentLevel--;
                 }
             }
+        }
+
+        void BloomUI()
+        {
+            EditorGUILayout.PropertyField(bloomSettings.enabled);
+
+            if (bloomSettings.enabled.boolValue)
+            {
+                EditorGUILayout.PropertyField(bloomSettings.intensity);
+                EditorGUILayout.PropertyField(bloomSettings.threshold);
+
+                EditorGUILayout.PropertyField(bloomSettings.softKnee);
+                EditorGUILayout.PropertyField(bloomSettings.radius);
+
+                EditorGUILayout.PropertyField(bloomSettings.lensTexture);
+                EditorGUILayout.PropertyField(bloomSettings.lensIntensity);
+
+                bloomSettings.intensity.floatValue = Mathf.Max(0f, bloomSettings.intensity.floatValue);
+                bloomSettings.threshold.floatValue = Mathf.Max(0f, bloomSettings.threshold.floatValue);
+                bloomSettings.lensIntensity.floatValue = Mathf.Max(0f, bloomSettings.lensIntensity.floatValue);
+            }
+        }
-            EditorGUI.indentLevel--;
+        void ChromaticAberrationUI()
+        {
+            EditorGUILayout.PropertyField(chromaSettings.enabled);
-            serializedObject.ApplyModifiedProperties();
+            if (chromaSettings.enabled.boolValue)
+            {
+                EditorGUILayout.PropertyField(chromaSettings.spectralTexture);
+                EditorGUILayout.PropertyField(chromaSettings.intensity);
+            }
+        void VignetteUI()
+        {
+            EditorGUILayout.PropertyField(vignetteSettings.enabled);
+
+            if (vignetteSettings.enabled.boolValue)
+            {
+                EditorGUILayout.PropertyField(vignetteSettings.color);
+                EditorGUILayout.PropertyField(vignetteSettings.center);
+                EditorGUILayout.PropertyField(vignetteSettings.intensity);
+                EditorGUILayout.PropertyField(vignetteSettings.smoothness);
+            }
+        }
+
+        #region Color grading stuff
         void SetLUTImportSettings()
         {
             var lut = (target as PostProcessing).colorGrading.logLut;
             File.WriteAllBytes(path, texture.EncodeToEXR(Texture2D.EXRFlags.CompressPIZ));
             AssetDatabase.Refresh();
         }
+        #endregion
     }
 }

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/PostProcessing.cs

     using GradingType = PostProcessing.ColorGradingSettings.GradingType;
     using EyeAdaptationType = PostProcessing.EyeAdaptationSettings.EyeAdaptationType;
 
-    [ExecuteInEditMode]
-    public sealed class PostProcessing : MonoBehaviour
+    [ExecuteInEditMode, ImageEffectAllowedInSceneView]
+    [RequireComponent(typeof(Camera))]
+    public sealed partial class PostProcessing : MonoBehaviour
-        [Serializable]
-        public sealed class ColorGradingSettings
+        // Quick & very dirty temporary wrapper used for bloom (easy porting from old school render
+        // texture blitting to command buffers)
+        struct RenderTextureWrapper
-            public enum GradingType
-            {
-                None,
-                Neutral,
-                Custom
-            }
-
-            public GradingType type = GradingType.None;
-            public float exposure = 0f;
-
-            public Texture logLut = null;
+            static int s_Counter = 0;
-            [Range(-0.10f,  0.1f)] public float neutralBlackIn    = 0.02f;
-            [Range( 1.00f, 20.0f)] public float neutralWhiteIn    = 10f;
-            [Range(-0.09f,  0.1f)] public float neutralBlackOut   = 0f;
-            [Range( 1.00f, 19.0f)] public float neutralWhiteOut   = 10f;
-            [Range( 0.10f, 20.0f)] public float neutralWhiteLevel = 5.3f;
-            [Range( 1.00f, 10.0f)] public float neutralWhiteClip  = 10f;
-        }
+            public int id;
+            public RenderTargetIdentifier identifier;
+            public int width;
+            public int height;
+            public int depth;
+            public FilterMode filter;
+            public RenderTextureFormat format;
-        [Serializable]
-        public sealed class EyeAdaptationSettings
-        {
-            public enum EyeAdaptationType
+            internal void Release(CommandBuffer cmd)
-                Progressive,
-                Fixed
+                cmd.ReleaseTemporaryRT(id);
+                id = 0;
-            public bool enabled = false;
-            public bool showDebugHistogramInGameView = true;
-
-            [Range(1f, 99f)] public float lowPercent = 65f;
-            [Range(1f, 99f)] public float highPercent = 95f;
-
-            public float minLuminance = 0.03f;
-            public float maxLuminance = 2f;
-            public float exposureCompensation = 0.5f;
-
-            public EyeAdaptationType adaptationType = EyeAdaptationType.Progressive;
+            internal static RenderTextureWrapper Create(CommandBuffer cmd, int width, int height, int depth = 0, FilterMode filter = FilterMode.Bilinear, RenderTextureFormat format = RenderTextureFormat.DefaultHDR)
+            {
+                s_Counter++;
-            public float speedUp = 2f;
-            public float speedDown = 1f;
+                int id = Shader.PropertyToID("_TempRenderTexture_" + s_Counter);
+                cmd.GetTemporaryRT(id, width, height, depth, filter, format);
-            [Range(-16, -1)] public int logMin = -8;
-            [Range(  1, 16)] public int logMax = 4;
+                return new RenderTextureWrapper
+                {
+                    id = id,
+                    identifier = new RenderTargetIdentifier(id),
+                    width = width,
+                    height = height,
+                    depth = depth,
+                    filter = filter,
+                    format = format
+                };
+            }
+        public ChromaticAberrationSettings chromaSettings = new ChromaticAberrationSettings();
+        public VignetteSettings vignetteSettings = new VignetteSettings();
+        public BloomSettings bloomSettings = new BloomSettings();
+        public bool globalDithering = false;
+        Material m_BloomMaterial;
+        int m_TempRt;
+
+        Texture m_DefaultSpectralLut;
+
         readonly RenderTexture[] m_AutoExposurePool = new RenderTexture[2];
         int m_AutoExposurePingPing;
         RenderTexture m_CurrentAutoExposure;
 
+        const int k_MaxPyramidBlurLevel = 16;
+        readonly RenderTextureWrapper[] m_BlurBuffer1 = new RenderTextureWrapper[k_MaxPyramidBlurLevel];
+        readonly RenderTextureWrapper[] m_BlurBuffer2 = new RenderTextureWrapper[k_MaxPyramidBlurLevel];
+        RenderTextureWrapper m_BloomTex;
+
         bool m_FirstFrame = true;
 
         // Don't forget to update 'EyeAdaptation.cginc' if you change these values !
 
+        // Holds 64 64x64 Alpha8 textures (256kb total)
+        const int k_BlueNoiseTextureCount = 64;
+        Texture2D[] m_BlueNoiseTextures;
+        int m_DitheringTexIndex = 0;
+
+            m_EyeAdaptationMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/EyeAdaptation");
+            m_BloomMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Bloom");
-            m_EyeAdaptationMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/EyeAdaptation");
 
             m_EyeCompute = Resources.Load<ComputeShader>("EyeHistogram");
             m_HistogramBuffer = new ComputeBuffer(k_HistogramBins, sizeof(uint));
 
+            m_BlueNoiseTextures = new Texture2D[k_BlueNoiseTextureCount];
+            for (int i = 0; i < k_BlueNoiseTextureCount; i++)
+                m_BlueNoiseTextures[i] = Resources.Load<Texture2D>("Textures/LDR_LLL1_" + i);
+
+            m_TempRt = Shader.PropertyToID("_Source");
+
+            m_DefaultSpectralLut = Resources.Load<Texture2D>("Textures/SpectralLut_GreenPurple");
+
             m_FirstFrame = true;
         }
 
+            Utilities.Destroy(m_BloomMaterial);
             Utilities.Destroy(m_FinalPassMaterial);
 
             foreach (var rt in m_AutoExposurePool)
             Utilities.SafeRelease(m_HistogramBuffer);
+
+            m_EyeAdaptationMaterial = null;
+            m_BloomMaterial = null;
+            m_FinalPassMaterial = null;
         }
 
         public void Render(Camera camera, ScriptableRenderContext context, RenderTargetIdentifier source, RenderTargetIdentifier destination)
             var cmd = new CommandBuffer { name = "Final Pass" };
 
             if (eyeAdaptation.enabled)
-            {
-                int tempRt = Shader.PropertyToID("_Source");
+                DoEyeAdaptation(camera, cmd, source);
-                // Downscale the framebuffer, we don't need an absolute precision for auto exposure
-                // and it helps making it more stable - should be using a previously downscaled pass
-                var scaleOffsetRes = GetHistogramScaleOffsetRes(camera);
+            if (bloomSettings.enabled)
+                DoBloom(camera, cmd, source);
-                cmd.GetTemporaryRT(tempRt, (int)scaleOffsetRes.z, (int)scaleOffsetRes.w, 0, FilterMode.Bilinear, RenderTextureFormat.ARGBHalf);
-                cmd.Blit(source, tempRt);
+            if (chromaSettings.enabled)
+                DoChromaticAberration();
-                // Clears the buffer on every frame as we use it to accumulate luminance values on each frame
-                m_HistogramBuffer.SetData(s_EmptyHistogramBuffer);
+            if (vignetteSettings.enabled)
+                DoVignette();
-                // Gets a log histogram
-                int kernel = m_EyeCompute.FindKernel("KEyeHistogram");
+            if (globalDithering)
+                DoDithering(camera);
-                cmd.SetComputeBufferParam(m_EyeCompute, kernel, "_Histogram", m_HistogramBuffer);
-                cmd.SetComputeTextureParam(m_EyeCompute, kernel, "_Source", tempRt);
-                cmd.SetComputeVectorParam(m_EyeCompute, "_ScaleOffsetRes", scaleOffsetRes);
-                cmd.DispatchCompute(m_EyeCompute, kernel, Mathf.CeilToInt(scaleOffsetRes.z / (float)k_HistogramThreadX), Mathf.CeilToInt(scaleOffsetRes.w / (float)k_HistogramThreadY), 1);
+            DoColorGrading();
+
+            cmd.Blit(source, destination, m_FinalPassMaterial, 0);
-                // Cleanup
-                cmd.ReleaseTemporaryRT(tempRt);
+            if (bloomSettings.enabled)
+                m_BloomTex.Release(cmd);
+
+            context.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
+        }
+
+        Vector4 GetHistogramScaleOffsetRes(Camera camera)
+        {
+            float diff = eyeAdaptation.logMax - eyeAdaptation.logMin;
+            float scale = 1f / diff;
+            float offset = -eyeAdaptation.logMin * scale;
+            return new Vector4(scale, offset, Mathf.Floor(camera.pixelWidth / 2f), Mathf.Floor(camera.pixelHeight / 2f));
+        }
+
+        void DoEyeAdaptation(Camera camera, CommandBuffer cmd, RenderTargetIdentifier source)
+        {
+            // Downscale the framebuffer, we don't need an absolute precision for auto exposure
+            // and it helps making it more stable - should be using a previously downscaled pass
+            var scaleOffsetRes = GetHistogramScaleOffsetRes(camera);
+
+            cmd.GetTemporaryRT(m_TempRt, (int)scaleOffsetRes.z, (int)scaleOffsetRes.w, 0, FilterMode.Bilinear, RenderTextureFormat.ARGBHalf);
+            cmd.Blit(source, m_TempRt);
+
+            // Clears the buffer on every frame as we use it to accumulate luminance values on each frame
+            m_HistogramBuffer.SetData(s_EmptyHistogramBuffer);
+
+            // Gets a log histogram
+            int kernel = m_EyeCompute.FindKernel("KEyeHistogram");
-                // Make sure filtering values are correct to avoid apocalyptic consequences
-                const float kMinDelta = 1e-2f;
-                eyeAdaptation.highPercent = Mathf.Clamp(eyeAdaptation.highPercent, 1f + kMinDelta, 99f);
-                eyeAdaptation.lowPercent = Mathf.Clamp(eyeAdaptation.lowPercent, 1f, eyeAdaptation.highPercent - kMinDelta);
+            cmd.SetComputeBufferParam(m_EyeCompute, kernel, "_Histogram", m_HistogramBuffer);
+            cmd.SetComputeTextureParam(m_EyeCompute, kernel, "_Source", m_TempRt);
+            cmd.SetComputeVectorParam(m_EyeCompute, "_ScaleOffsetRes", scaleOffsetRes);
+            cmd.DispatchCompute(m_EyeCompute, kernel, Mathf.CeilToInt(scaleOffsetRes.z / (float)k_HistogramThreadX), Mathf.CeilToInt(scaleOffsetRes.w / (float)k_HistogramThreadY), 1);
-                // Compute auto exposure
-                m_EyeAdaptationMaterial.SetBuffer("_Histogram", m_HistogramBuffer);
-                m_EyeAdaptationMaterial.SetVector("_Params", new Vector4(eyeAdaptation.lowPercent * 0.01f, eyeAdaptation.highPercent * 0.01f, eyeAdaptation.minLuminance, eyeAdaptation.maxLuminance));
-                m_EyeAdaptationMaterial.SetVector("_Speed", new Vector2(eyeAdaptation.speedDown, eyeAdaptation.speedUp));
-                m_EyeAdaptationMaterial.SetVector("_ScaleOffsetRes", scaleOffsetRes);
-                m_EyeAdaptationMaterial.SetFloat("_ExposureCompensation", eyeAdaptation.exposureCompensation);
+            // Cleanup
+            cmd.ReleaseTemporaryRT(m_TempRt);
-                if (m_FirstFrame || !Application.isPlaying)
-                {
-                    // We don't want eye adaptation when not in play mode because the GameView isn't
-                    // animated, thus making it harder to tweak. Just use the final audo exposure value.
-                    m_CurrentAutoExposure = m_AutoExposurePool[0];
-                    cmd.Blit(null, m_CurrentAutoExposure, m_EyeAdaptationMaterial, (int)EyeAdaptationType.Fixed);
+            // Make sure filtering values are correct to avoid apocalyptic consequences
+            const float kMinDelta = 1e-2f;
+            eyeAdaptation.highPercent = Mathf.Clamp(eyeAdaptation.highPercent, 1f + kMinDelta, 99f);
+            eyeAdaptation.lowPercent = Mathf.Clamp(eyeAdaptation.lowPercent, 1f, eyeAdaptation.highPercent - kMinDelta);
-                    // Copy current exposure to the other pingpong target on first frame to avoid adapting from black
-                    cmd.Blit(m_AutoExposurePool[0], m_AutoExposurePool[1]);
-                } else
-                {
-                    int pp = m_AutoExposurePingPing;
-                    var src = m_AutoExposurePool[++pp % 2];
-                    var dst = m_AutoExposurePool[++pp % 2];
-                    cmd.Blit(src, dst, m_EyeAdaptationMaterial, (int)eyeAdaptation.adaptationType);
-                    m_AutoExposurePingPing = ++pp % 2;
-                    m_CurrentAutoExposure = dst;
-                }
+            // Compute auto exposure
+            m_EyeAdaptationMaterial.SetBuffer(Uniforms._Histogram, m_HistogramBuffer);
+            m_EyeAdaptationMaterial.SetVector(Uniforms._Params, new Vector4(eyeAdaptation.lowPercent * 0.01f, eyeAdaptation.highPercent * 0.01f, eyeAdaptation.minLuminance, eyeAdaptation.maxLuminance));
+            m_EyeAdaptationMaterial.SetVector(Uniforms._Speed, new Vector2(eyeAdaptation.speedDown, eyeAdaptation.speedUp));
+            m_EyeAdaptationMaterial.SetVector(Uniforms._ScaleOffsetRes, scaleOffsetRes);
+            m_EyeAdaptationMaterial.SetFloat(Uniforms._ExposureCompensation, eyeAdaptation.exposureCompensation);
-                m_FinalPassMaterial.EnableKeyword("EYE_ADAPTATION");
-                m_FinalPassMaterial.SetTexture("_AutoExposure", m_CurrentAutoExposure);
+            if (m_FirstFrame || !Application.isPlaying)
+            {
+                // We don't want eye adaptation when not in play mode because the GameView isn't
+                // animated, thus making it harder to tweak. Just use the final audo exposure value.
+                m_CurrentAutoExposure = m_AutoExposurePool[0];
+                cmd.Blit(null, m_CurrentAutoExposure, m_EyeAdaptationMaterial, (int)EyeAdaptationType.Fixed);
-                // Debug histogram visualization
-                if (eyeAdaptation.showDebugHistogramInGameView)
+                // Copy current exposure to the other pingpong target on first frame to avoid adapting from black
+                cmd.Blit(m_AutoExposurePool[0], m_AutoExposurePool[1]);
+            }
+            else
+            {
+                int pp = m_AutoExposurePingPing;
+                var src = m_AutoExposurePool[++pp % 2];
+                var dst = m_AutoExposurePool[++pp % 2];
+                cmd.Blit(src, dst, m_EyeAdaptationMaterial, (int)eyeAdaptation.adaptationType);
+                m_AutoExposurePingPing = ++pp % 2;
+                m_CurrentAutoExposure = dst;
+            }
+
+            m_FinalPassMaterial.EnableKeyword("EYE_ADAPTATION");
+            m_FinalPassMaterial.SetTexture(Uniforms._AutoExposure, m_CurrentAutoExposure);
+
+            // Debug histogram visualization
+            if (eyeAdaptation.showDebugHistogramInGameView)
+            {
+                if (m_DebugHistogram == null || !m_DebugHistogram.IsCreated())
-                    if (m_DebugHistogram == null || !m_DebugHistogram.IsCreated())
+                    m_DebugHistogram = new RenderTexture(256, 128, 0, RenderTextureFormat.ARGB32)
-                        m_DebugHistogram = new RenderTexture(256, 128, 0, RenderTextureFormat.ARGB32)
-                        {
-                            filterMode = FilterMode.Point,
-                            wrapMode = TextureWrapMode.Clamp
-                        };
-                    }
+                        filterMode = FilterMode.Point,
+                        wrapMode = TextureWrapMode.Clamp
+                    };
+                }
+
+                m_EyeAdaptationMaterial.SetFloat(Uniforms._DebugWidth, m_DebugHistogram.width);
+                cmd.Blit(null, m_DebugHistogram, m_EyeAdaptationMaterial, 2);
+            }
+
+            m_FirstFrame = false;
+        }
+
+        void DoBloom(Camera camera, CommandBuffer cmd, RenderTargetIdentifier source)
+        {
+            m_BloomMaterial.shaderKeywords = null;
+
+            // Apply auto exposure before the prefiltering pass if needed
+            if (eyeAdaptation.enabled)
+            {
+                m_BloomMaterial.EnableKeyword("EYE_ADAPTATION");
+                m_BloomMaterial.SetTexture(Uniforms._AutoExposure, m_CurrentAutoExposure);
+            }
+
+            // Do bloom on a half-res buffer, full-res doesn't bring much and kills performances on
+            // fillrate limited platforms
+            int tw = camera.pixelWidth / 2;
+            int th = camera.pixelHeight / 2;
+
+            // Determine the iteration count
+            float logh = Mathf.Log(th, 2f) + bloomSettings.radius - 8f;
+            int logh_i = (int)logh;
+            int iterations = Mathf.Clamp(logh_i, 1, k_MaxPyramidBlurLevel);
+
+            // Uupdate the shader properties
+            float lthresh = Mathf.GammaToLinearSpace(bloomSettings.threshold);;
+            m_BloomMaterial.SetFloat(Uniforms._Threshold, lthresh);
+
+            float knee = lthresh * bloomSettings.softKnee + 1e-5f;
+            var curve = new Vector3(lthresh - knee, knee * 2f, 0.25f / knee);
+            m_BloomMaterial.SetVector(Uniforms._Curve, curve);
+
+            float sampleScale = 0.5f + logh - logh_i;
+            m_BloomMaterial.SetFloat(Uniforms._SampleScale, sampleScale);
+
+            // Prefilter pass
+            var prefiltered = RenderTextureWrapper.Create(cmd, tw, th, 0, FilterMode.Point);
+            cmd.Blit(source, prefiltered.identifier, m_BloomMaterial, 0);
+
+            var last = prefiltered;
+
+            // Construct a mip pyramid
+            for (int level = 0; level < iterations; level++)
+            {
+                m_BlurBuffer1[level] = RenderTextureWrapper.Create(cmd, last.width / 2, last.height / 2);
+                cmd.Blit(last.identifier, m_BlurBuffer1[level].identifier, m_BloomMaterial, level == 0 ? 1 : 2);
+                last = m_BlurBuffer1[level];
+            }
+
+            // Upsample and combine loop
+            for (int level = iterations - 2; level >= 0; level--)
+            {
+                var baseTex = m_BlurBuffer1[level];
+                cmd.SetGlobalTexture(Uniforms._BaseTex, baseTex.identifier); // Boooo
+
+                m_BlurBuffer2[level] = RenderTextureWrapper.Create(cmd, baseTex.width, baseTex.height);
+
+                cmd.Blit(last.identifier, m_BlurBuffer2[level].identifier, m_BloomMaterial, 3);
+                last = m_BlurBuffer2[level];
+            }
+
+            m_BloomTex = last;
+
+            // Release the temporary buffers
+            for (int i = 0; i < k_MaxPyramidBlurLevel; i++)
+            {
+                if (m_BlurBuffer1[i].id != 0)
+                    m_BlurBuffer1[i].Release(cmd);
+
+                if (m_BlurBuffer2[i].id != 0 && m_BlurBuffer2[i].id != m_BloomTex.id)
+                    m_BlurBuffer2[i].Release(cmd);
+            }
+
+            prefiltered.Release(cmd);
+
+            // Push everything to the uber material
+            m_FinalPassMaterial.EnableKeyword("BLOOM");
-                    m_EyeAdaptationMaterial.SetFloat("_DebugWidth", m_DebugHistogram.width);
-                    cmd.Blit(null, m_DebugHistogram, m_EyeAdaptationMaterial, 2);
-                }
+            cmd.SetGlobalTexture(Uniforms._BloomTex, m_BloomTex.identifier);
+            cmd.SetGlobalVector(Uniforms._Bloom_Settings, new Vector2(sampleScale, bloomSettings.intensity));
-                m_FirstFrame = false;
+            if (bloomSettings.lensIntensity > 0f && bloomSettings.lensTexture != null)
+            {
+                m_FinalPassMaterial.EnableKeyword("BLOOM_LENS_DIRT");
+                cmd.SetGlobalTexture(Uniforms._Bloom_DirtTex, bloomSettings.lensTexture);
+                cmd.SetGlobalFloat(Uniforms._Bloom_DirtIntensity, bloomSettings.lensIntensity);
+        }
+        void DoChromaticAberration()
+        {
+            var spectralLut = chromaSettings.spectralTexture == null
+                ? m_DefaultSpectralLut
+                : chromaSettings.spectralTexture;
+
+            m_FinalPassMaterial.EnableKeyword("CHROMATIC_ABERRATION");
+            m_FinalPassMaterial.SetFloat(Uniforms._ChromaticAberration_Amount, chromaSettings.intensity * 0.03f);
+            m_FinalPassMaterial.SetTexture(Uniforms._ChromaticAberration_Lut, spectralLut);
+        }
+
+        void DoVignette()
+        {
+            m_FinalPassMaterial.EnableKeyword("VIGNETTE");
+            m_FinalPassMaterial.SetColor(Uniforms._Vignette_Color, vignetteSettings.color);
+            m_FinalPassMaterial.SetVector(Uniforms._Vignette_Settings, new Vector4(vignetteSettings.intensity * 3f, vignetteSettings.smoothness * 5f, vignetteSettings.center.x, vignetteSettings.center.y));
+        }
+
+        void DoDithering(Camera camera)
+        {
+            m_FinalPassMaterial.EnableKeyword("DITHERING");
+
+            if (++m_DitheringTexIndex >= k_BlueNoiseTextureCount)
+                m_DitheringTexIndex = 0;
+
+            var noiseTex = m_BlueNoiseTextures[m_DitheringTexIndex];
+            m_FinalPassMaterial.SetTexture(Uniforms._DitheringTex, noiseTex);
+            m_FinalPassMaterial.SetVector(Uniforms._DitheringCoords, new Vector4(
+                (float)camera.pixelWidth / (float)noiseTex.width,
+                (float)camera.pixelHeight / (float)noiseTex.height,
+                Random.value, Random.value
+            ));
+        }
+
+        void DoColorGrading()
+        {
-            m_FinalPassMaterial.SetFloat("_Exposure", ev);
+            m_FinalPassMaterial.SetFloat(Uniforms._Exposure, ev);
 
             if (colorGrading.type == GradingType.Neutral)
             {
                 const float e = 0.02f;
                 const float f = 0.30f;
 
-                m_FinalPassMaterial.SetVector("_NeutralTonemapperParams1", new Vector4(a, b, c, d));
-                m_FinalPassMaterial.SetVector("_NeutralTonemapperParams2", new Vector4(e, f, colorGrading.neutralWhiteLevel, colorGrading.neutralWhiteClip / kScaleFactorHalf));
+                m_FinalPassMaterial.SetVector(Uniforms._NeutralTonemapperParams1, new Vector4(a, b, c, d));
+                m_FinalPassMaterial.SetVector(Uniforms._NeutralTonemapperParams2, new Vector4(e, f, colorGrading.neutralWhiteLevel, colorGrading.neutralWhiteClip / kScaleFactorHalf));
                 m_FinalPassMaterial.EnableKeyword("NEUTRAL_GRADING");
             }
             else if (colorGrading.type == GradingType.Custom)
                     var lut = colorGrading.logLut;
-                    m_FinalPassMaterial.SetTexture("_LogLut", lut);
-                    m_FinalPassMaterial.SetVector("_LogLut_Params", new Vector3(1f / lut.width, 1f / lut.height, lut.height - 1f));
+                    m_FinalPassMaterial.SetTexture(Uniforms._LogLut, lut);
+                    m_FinalPassMaterial.SetVector(Uniforms._LogLut_Params, new Vector3(1f / lut.width, 1f / lut.height, lut.height - 1f));
-
-            cmd.Blit(source, destination, m_FinalPassMaterial, 0);
-            context.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
-        }
-
-        Vector4 GetHistogramScaleOffsetRes(Camera camera)
-        {
-            float diff = eyeAdaptation.logMax - eyeAdaptation.logMin;
-            float scale = 1f / diff;
-            float offset = -eyeAdaptation.logMin * scale;
-            return new Vector4(scale, offset, Mathf.Floor(camera.pixelWidth / 2f), Mathf.Floor(camera.pixelHeight / 2f));
         }
 
         void OnGUI()
 
             var rect = new Rect(8f, 8f, m_DebugHistogram.width, m_DebugHistogram.height);
             GUI.DrawTexture(rect, m_DebugHistogram);
+        }
+
+        // Pre-hash uniforms, no need to stress the CPU more than needed on every frame
+        static class Uniforms
+        {
+            internal static readonly int _Histogram                  = Shader.PropertyToID("_Histogram");
+            internal static readonly int _Params                     = Shader.PropertyToID("_Params");
+            internal static readonly int _Speed                      = Shader.PropertyToID("_Speed");
+            internal static readonly int _ScaleOffsetRes             = Shader.PropertyToID("_ScaleOffsetRes");
+            internal static readonly int _ExposureCompensation       = Shader.PropertyToID("_ExposureCompensation");
+
+            internal static readonly int _AutoExposure               = Shader.PropertyToID("_AutoExposure");
+
+            internal static readonly int _DebugWidth                 = Shader.PropertyToID("_DebugWidth");
+
+            internal static readonly int _Threshold                  = Shader.PropertyToID("_Threshold");
+            internal static readonly int _Curve                      = Shader.PropertyToID("_Curve");
+            internal static readonly int _SampleScale                = Shader.PropertyToID("_SampleScale");
+            internal static readonly int _BaseTex                    = Shader.PropertyToID("_BaseTex");
+            internal static readonly int _BloomTex                   = Shader.PropertyToID("_BloomTex");
+            internal static readonly int _Bloom_Settings             = Shader.PropertyToID("_Bloom_Settings");
+            internal static readonly int _Bloom_DirtTex              = Shader.PropertyToID("_Bloom_DirtTex");
+            internal static readonly int _Bloom_DirtIntensity        = Shader.PropertyToID("_Bloom_DirtIntensity");
+
+            internal static readonly int _ChromaticAberration_Amount = Shader.PropertyToID("_ChromaticAberration_Amount");
+            internal static readonly int _ChromaticAberration_Lut    = Shader.PropertyToID("_ChromaticAberration_Lut");
+
+            internal static readonly int _Vignette_Color             = Shader.PropertyToID("_Vignette_Color");
+            internal static readonly int _Vignette_Settings          = Shader.PropertyToID("_Vignette_Settings");
+
+            internal static readonly int _DitheringTex               = Shader.PropertyToID("_DitheringTex");
+            internal static readonly int _DitheringCoords            = Shader.PropertyToID("_DitheringCoords");
+
+            internal static readonly int _Exposure                   = Shader.PropertyToID("_Exposure");
+
+            internal static readonly int _NeutralTonemapperParams1   = Shader.PropertyToID("_NeutralTonemapperParams1");
+            internal static readonly int _NeutralTonemapperParams2   = Shader.PropertyToID("_NeutralTonemapperParams2");
+
+            internal static readonly int _LogLut                     = Shader.PropertyToID("_LogLut");
+            internal static readonly int _LogLut_Params              = Shader.PropertyToID("_LogLut_Params");
         }
     }
 }

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/FinalPass.shader

     HLSLINCLUDE
 
         #pragma target 4.5
+        #include "Color.hlsl"
+        #include "Bloom.hlsl"
+        float4 _MainTex_TexelSize;
 
         TEXTURE2D(_AutoExposure);
         SAMPLER2D(sampler_AutoExposure);
 
         float _Exposure;
 
+        TEXTURE2D(_BloomTex);
+        SAMPLER2D(sampler_BloomTex);
+        float4 _BloomTex_TexelSize;
+        float2 _Bloom_Settings; // x: sampleScale, y: bloom.intensity
+
+        TEXTURE2D(_Bloom_DirtTex);
+        SAMPLER2D(sampler_Bloom_DirtTex);
+        float _Bloom_DirtIntensity;
+
-        struct Attributes 
+        float _ChromaticAberration_Amount;
+        TEXTURE2D(_ChromaticAberration_Lut);
+        SAMPLER2D(sampler_ChromaticAberration_Lut);
+
+        float3 _Vignette_Color;
+        float4 _Vignette_Settings; // x: intensity, y: smoothness, zw: center (uv space)
+
+        TEXTURE2D(_DitheringTex);
+        SAMPLER2D(sampler_DitheringTex);
+        float4 _DitheringCoords;
+
+        struct Attributes
-        struct Varyings 
+        struct Varyings
         {
             float4 vertex : SV_POSITION;
             float2 texcoord : TEXCOORD0;
 
         float4 Frag(Varyings input) : SV_Target
         {
-            float4 color = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, input.texcoord);
+            float2 uv = input.texcoord;
+            float3 color = (0.0).xxx;
+
+            // Chromatic Aberration
+            // Inspired by the method described in "Rendering Inside" [Playdead 2016]
+            // https://twitter.com/pixelmager/status/717019757766123520
+            #if CHROMATIC_ABERRATION
+            {
+                float2 coords = 2.0 * uv - 1.0;
+                float2 end = uv - coords * dot(coords, coords) * _ChromaticAberration_Amount;
+
+                float2 diff = end - uv;
+                int samples = clamp(int(length(_MainTex_TexelSize.zw * diff / 2.0)), 3, 16);
+                float2 delta = diff / samples;
+                float2 pos = uv;
+                float3 sum = (0.0).xxx, filterSum = (0.0).xxx;
+
+                for (int i = 0; i < samples; i++)
+                {
+                    float t = (i + 0.5) / samples;
+                    float3 s = SAMPLE_TEXTURE2D_LOD(_MainTex, sampler_MainTex, pos, 0).rgb;
+                    float3 filter = SAMPLE_TEXTURE2D_LOD(_ChromaticAberration_Lut, sampler_ChromaticAberration_Lut, float2(t, 0.0), 0).rgb;
+
+                    sum += s * filter;
+                    filterSum += filter;
+                    pos += delta;
+                }
+
+                color = sum / filterSum;
+            }
+            #else
+            {
+                color = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv).rgb;
+            }
+            #endif
-                float autoExposure = SAMPLE_TEXTURE2D(_AutoExposure, sampler_AutoExposure, input.texcoord).r;
+                float autoExposure = SAMPLE_TEXTURE2D(_AutoExposure, sampler_AutoExposure, uv).r;
-            color.rgb *= _Exposure; // Exposure is in ev units (or 'stops'), precomputed CPU-side
+            #if BLOOM
+            {
+                float3 bloom = UpsampleFilter(TEXTURE2D_PARAM(_BloomTex, sampler_BloomTex), uv, _BloomTex_TexelSize.xy, _Bloom_Settings.x) * _Bloom_Settings.y; // Flipped
+                color += bloom;
+
+                #if BLOOM_LENS_DIRT
+                {
+                    float3 dirt = SAMPLE_TEXTURE2D(_Bloom_DirtTex, sampler_Bloom_DirtTex, uv).rgb * _Bloom_DirtIntensity; // Flipped
+                    color += bloom * dirt;
+                }
+                #endif
+            }
+            #endif
+
+            #if VIGNETTE
+            {
+                float2 d = abs(uv - _Vignette_Settings.zw) * _Vignette_Settings.x;
+                d.x *= _ScreenParams.x / _ScreenParams.y;
+                float vfactor = pow(saturate(1.0 - dot(d, d)), _Vignette_Settings.y);
+                color *= lerp(_Vignette_Color, (1.0).xxx, vfactor);
+            }
+            #endif
+
+            color *= _Exposure; // Exposure is in ev units (or 'stops'), precomputed CPU-side
-                color.rgb = NeutralTonemap(color.rgb, _NeutralTonemapperParams1, _NeutralTonemapperParams2);
+                color = NeutralTonemap(color, _NeutralTonemapperParams1, _NeutralTonemapperParams2);
             }
             #elif CUSTOM_GRADING
             {
                 uvw.z *= _LogLut_Params.z;
-                half shift = floor(uvw.z);
+                float shift = floor(uvw.z);
-                    SAMPLE_TEXTURE2D(_LogLut, sampler_LogLut, uvw.xy + half2(_LogLut_Params.y, 0)).rgb,
+                    SAMPLE_TEXTURE2D(_LogLut, sampler_LogLut, uvw.xy + float2(_LogLut_Params.y, 0)).rgb,
-                color.rgb = uvw;
+                color = uvw;
             }
             #else
             {
 
-            return color;
+            #if DITHERING
+            {
+                // Symmetric triangular distribution on [-1,1] with maximal density at 0
+                float noise = SAMPLE_TEXTURE2D(_DitheringTex, sampler_DitheringTex, uv * _DitheringCoords.xy + _DitheringCoords.zw).a * 2.0 - 1.0;
+                noise = sign(noise) * (1.0 - sqrt(1.0 - abs(noise)));
+                color = SRGBToLinear(LinearToSRGB(color) + noise / 255.0);
+            }
+            #endif
+
+            return float4(color, 1.0);
         }
 
     ENDHLSL
                 #pragma fragment Frag
                 #pragma multi_compile __ NEUTRAL_GRADING CUSTOM_GRADING
                 #pragma multi_compile __ EYE_ADAPTATION
+                #pragma multi_compile __ BLOOM
+                #pragma multi_compile __ BLOOM_LENS_DIRT
+                #pragma multi_compile __ CHROMATIC_ABERRATION
+                #pragma multi_compile __ VIGNETTE
+                #pragma multi_compile __ DITHERING
 
             ENDHLSL
         }

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/PostProcessing.Settings.cs

+using System;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    partial class PostProcessing
+    {
+        [Serializable]
+        public sealed class ColorGradingSettings
+        {
+            public enum GradingType
+            {
+                None,
+                Neutral,
+                Custom
+            }
+
+            public GradingType type = GradingType.None;
+            public float exposure = 0f;
+
+            public Texture logLut = null;
+
+            [Range(-0.10f,  0.1f)] public float neutralBlackIn    = 0.02f;
+            [Range( 1.00f, 20.0f)] public float neutralWhiteIn    = 10f;
+            [Range(-0.09f,  0.1f)] public float neutralBlackOut   = 0f;
+            [Range( 1.00f, 19.0f)] public float neutralWhiteOut   = 10f;
+            [Range( 0.10f, 20.0f)] public float neutralWhiteLevel = 5.3f;
+            [Range( 1.00f, 10.0f)] public float neutralWhiteClip  = 10f;
+        }
+
+        [Serializable]
+        public sealed class EyeAdaptationSettings
+        {
+            public enum EyeAdaptationType
+            {
+                Progressive,
+                Fixed
+            }
+
+            public bool enabled = false;
+            public bool showDebugHistogramInGameView = true;
+
+            [Range(1f, 99f)] public float lowPercent = 65f;
+            [Range(1f, 99f)] public float highPercent = 95f;
+
+            public float minLuminance = 0.03f;
+            public float maxLuminance = 2f;
+            public float exposureCompensation = 0.5f;
+
+            public EyeAdaptationType adaptationType = EyeAdaptationType.Progressive;
+
+            public float speedUp = 2f;
+            public float speedDown = 1f;
+
+            [Range(-16, -1)] public int logMin = -8;
+            [Range(  1, 16)] public int logMax = 4;
+        }
+
+        [Serializable]
+        public sealed class ChromaticAberrationSettings
+        {
+            public bool enabled = false;
+            public Texture spectralTexture;
+            [Range(0f, 1f)] public float intensity = 0.1f;
+        }
+
+        [Serializable]
+        public sealed class VignetteSettings
+        {
+            public bool enabled = false;
+
+            [ColorUsage(false, true, 0f, 10f, 0f, 10f)]
+            public Color color = new Color(0f, 0f, 0f, 1f);
+
+            public Vector2 center = new Vector2(0.5f, 0.5f);
+
+            [Range(0f, 1f)] public float intensity = 0.3f;
+            [Range(0f, 1f)] public float smoothness = 0.3f;
+        }
+
+        [Serializable]
+        public sealed class BloomSettings
+        {
+            public bool enabled = false;
+
+            public float intensity = 0.5f;
+            public float threshold = 1.1f;
+
+            [Range(0f, 1f)] public float softKnee = 0.5f;
+            [Range(1f, 7f)] public float radius = 5f;
+
+            public Texture lensTexture;
+            public float lensIntensity = 3f;
+        }
+    }
+}

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/PostProcessing.Settings.cs.meta

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

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Bloom.hlsl

+#ifndef UNITY_BLOOM
+#define UNITY_BLOOM
+
+// Downsample with a 4x4 box filter
+float3 DownsampleFilter(TEXTURE2D_ARGS(tex, texSampler), float2 uv, float2 texelSize)
+{
+    float4 d = texelSize.xyxy * float4(-1.0, -1.0, 1.0, 1.0);
+
+    float3 s;
+    s =  SAMPLE_TEXTURE2D(tex, texSampler, uv + d.xy).rgb;
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv + d.zy).rgb;
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv + d.xw).rgb;
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv + d.zw).rgb;
+
+    return s * (1.0 / 4.0);
+}
+
+float3 UpsampleFilter(TEXTURE2D_ARGS(tex, texSampler), float2 uv, float2 texelSize, float sampleScale)
+{
+#if 0
+    // 4-tap bilinear upsampler
+    float4 d = texelSize.xyxy * float4(-1.0, -1.0, 1.0, 1.0) * (sampleScale * 0.5);
+
+    float3 s;
+    s =  SAMPLE_TEXTURE2D(tex, texSampler, uv + d.xy).rgb;
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv + d.zy).rgb;
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv + d.xw).rgb;
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv + d.zw).rgb;
+
+    return s * (1.0 / 4.0);
+#else
+    // 9-tap bilinear upsampler (tent filter)
+    float4 d = texelSize.xyxy * float4(1.0, 1.0, -1.0, 0.0) * sampleScale;
+
+    float3 s;
+    s =  SAMPLE_TEXTURE2D(tex, texSampler, uv - d.xy).rgb;
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv - d.wy).rgb * 2.0;
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv - d.zy).rgb;
+
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv + d.zw).rgb * 2.0;
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv).rgb        * 4.0;
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv + d.xw).rgb * 2.0;
+
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv + d.zy).rgb;
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv + d.wy).rgb * 2.0;
+    s += SAMPLE_TEXTURE2D(tex, texSampler, uv + d.xy).rgb;
+
+    return s * (1.0 / 16.0);
+#endif
+}
+
+#endif // UNITY_BLOOM

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Bloom.hlsl.meta

+fileFormatVersion: 2
+guid: 41784642d71cc4a46acbaa1c81d71109
+timeCreated: 1486047545
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Bloom.shader

+Shader "Hidden/HDRenderPipeline/Bloom"
+{
+    Properties
+    {
+        _MainTex ("", 2D) = "" {}
+        _BaseTex ("", 2D) = "" {}
+        _AutoExposure ("", 2D) = "" {}
+    }
+
+    HLSLINCLUDE
+
+        #pragma target 4.5
+        #include "Common.hlsl"
+        #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
+        #include "Bloom.hlsl"
+
+        TEXTURE2D(_MainTex);
+        SAMPLER2D(sampler_MainTex);
+        float4 _MainTex_TexelSize;
+
+        TEXTURE2D(_BaseTex);
+        SAMPLER2D(sampler_BaseTex);
+        float4 _BaseTex_TexelSize;
+
+        TEXTURE2D(_AutoExposure);
+        SAMPLER2D(sampler_AutoExposure);
+
+        float _Threshold;
+        float3 _Curve;
+        float _SampleScale;
+
+        struct Attributes
+        {
+            float3 vertex : POSITION;
+            float2 texcoord : TEXCOORD0;
+        };
+
+        struct Varyings
+        {
+            float4 vertex : SV_POSITION;
+            float2 texcoord : TEXCOORD0;
+        };
+
+        struct VaryingsMultitex
+        {
+            float4 vertex : SV_POSITION;
+            float2 texcoordMain : TEXCOORD0;
+            float2 texcoordBase : TEXCOORD1;
+        };
+
+        Varyings Vert(Attributes input)
+        {
+            Varyings output;
+            output.vertex = TransformWorldToHClip(input.vertex);
+            output.texcoord = input.texcoord.xy;
+            return output;
+        }
+
+        VaryingsMultitex VertMultitex(Attributes input)
+        {
+            VaryingsMultitex o;
+            o.vertex = TransformWorldToHClip(input.vertex);
+            o.texcoordMain = input.texcoord.xy;
+            o.texcoordBase = o.texcoordMain;
+
+        #if UNITY_UV_STARTS_AT_TOP
+            if (_BaseTex_TexelSize.y < 0.0)
+                o.texcoordMain.y = 1.0 - o.texcoordMain.y;
+        #endif
+
+            return o;
+        }
+
+        float4 FetchAutoExposed(TEXTURE2D_ARGS(tex, texSampler), float2 uv)
+        {
+            float autoExposure = 1.0;
+
+        #if EYE_ADAPTATION
+            autoExposure = SAMPLE_TEXTURE2D(_AutoExposure, sampler_AutoExposure, uv).r;
+        #endif
+
+            return SAMPLE_TEXTURE2D(tex, texSampler, uv) * autoExposure;
+        }
+
+        float4 FragPrefilter(Varyings i) : SV_Target
+        {
+            float2 uv = i.texcoord;
+
+            float4 s0 = min(65504.0, FetchAutoExposed(TEXTURE2D_PARAM(_MainTex, sampler_MainTex), uv));
+            float3 m = s0.rgb;
+
+            // Pixel brightness
+            float br = max(m.r, max(m.g, m.r));
+
+            // Under-threshold part: quadratic curve
+            float rq = clamp(br - _Curve.x, 0.0, _Curve.y);
+            rq = _Curve.z * rq * rq;
+
+            // Combine and apply the brightness response curve.
+            m *= max(rq, br - _Threshold) / max(br, 1e-5);
+
+            return float4(m, 0.0);
+        }
+
+        float4 FragDownsample1(Varyings i) : SV_Target
+        {
+            return float4(DownsampleFilter(TEXTURE2D_PARAM(_MainTex, sampler_MainTex), i.texcoord, _MainTex_TexelSize.xy), 0.0);
+        }
+
+        float4 FragDownsample2(Varyings i) : SV_Target
+        {
+            return float4(DownsampleFilter(TEXTURE2D_PARAM(_MainTex, sampler_MainTex), i.texcoord, _MainTex_TexelSize.xy), 0.0);
+        }
+
+        float4 FragUpsample(VaryingsMultitex i) : SV_Target
+        {
+            float3 base = SAMPLE_TEXTURE2D(_BaseTex, sampler_BaseTex, i.texcoordBase).rgb;
+            float3 blur = UpsampleFilter(TEXTURE2D_PARAM(_MainTex, sampler_MainTex), i.texcoordMain, _MainTex_TexelSize.xy, _SampleScale);
+            return float4(base + blur, 0.0);
+        }
+
+    ENDHLSL
+
+    SubShader
+    {
+        Cull Off ZWrite Off ZTest Always
+
+        Pass
+        {
+            HLSLPROGRAM
+
+                #pragma multi_compile __ EYE_ADAPTATION
+                #pragma vertex Vert
+                #pragma fragment FragPrefilter
+
+            ENDHLSL
+        }
+
+        Pass
+        {
+            HLSLPROGRAM
+
+                #pragma vertex Vert
+                #pragma fragment FragDownsample1
+
+            ENDHLSL
+        }
+
+        Pass
+        {
+            HLSLPROGRAM
+
+                #pragma vertex Vert
+                #pragma fragment FragDownsample2
+
+            ENDHLSL
+        }
+
+        Pass
+        {
+            HLSLPROGRAM
+
+                #pragma vertex VertMultitex
+                #pragma fragment FragUpsample
+
+            ENDHLSL
+        }
+    }
+
+    Fallback Off
+}

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Bloom.shader.meta

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

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures.meta

+fileFormatVersion: 2
+guid: d4d9faa9907d6d64b8f13cff812bc3e0
+folderAsset: yes
+timeCreated: 1485951667
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Textures/LensDirt00.png.meta

+fileFormatVersion: 2
+guid: 69e847bbff1cf5449a4ee0bbd045dbc9
+timeCreated: 1472572785
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 4096
+  textureSettings:
+    filterMode: -1
+    aniso: 0
+    mipBias: -1
+    wrapMode: 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: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 1024
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 1024
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Textures/LensDirt01.png.meta

+fileFormatVersion: 2
+guid: 3884f7a2d04ffe8409ad9200b275896f
+timeCreated: 1472551546
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 4096
+  textureSettings:
+    filterMode: -1
+    aniso: 0
+    mipBias: -1
+    wrapMode: 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: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 1024
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 1024
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Textures/LensDirt02.png.meta

+fileFormatVersion: 2
+guid: a2960ffde020f27409e070d92fb2e00b
+timeCreated: 1472632371
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 4096
+  textureSettings:
+    filterMode: -1
+    aniso: 0
+    mipBias: -1
+    wrapMode: 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: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 1024
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 1024
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/COPYING.txt

+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/COPYING.txt.meta

+fileFormatVersion: 2
+guid: fa3fc398fe396744c9299e70b63bfdd7
+timeCreated: 1485181015
+licenseType: Pro
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_0.png.meta

+fileFormatVersion: 2
+guid: 50b54341495978843a6f85583ed4417d
+timeCreated: 1485958593
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: iPhone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: tvOS
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Windows Store Apps
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_1.png.meta

+fileFormatVersion: 2
+guid: 3c2f1fb7e4b66e74191b7c328ada52d9
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_10.png.meta

+fileFormatVersion: 2
+guid: afe1e502240079342a0a980484b6da8b
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_11.png.meta

+fileFormatVersion: 2
+guid: 771903fe7b4674445829e52e91cff019
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_12.png.meta

+fileFormatVersion: 2
+guid: 980acadb960f8424c94307ec0e585b4e
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_13.png.meta

+fileFormatVersion: 2
+guid: 68613e6a221be1a4b9f31d7fa1c2d1bf
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_14.png.meta

+fileFormatVersion: 2
+guid: f6439b54b28f3884eb67579dec0b6f21
+timeCreated: 1485107929
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_15.png.meta

+fileFormatVersion: 2
+guid: 2ee161d8945169243b5698fec114e1b7
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_16.png.meta

+fileFormatVersion: 2
+guid: 153f7d6dfbe713d4884df0f1e243ba92
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_17.png.meta

+fileFormatVersion: 2
+guid: bf95b6fdc179b0e4f890c841406193fc
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_18.png.meta

+fileFormatVersion: 2
+guid: 74aca53eb7273624baffc2bf5e5cc173
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_19.png.meta

+fileFormatVersion: 2
+guid: 729a3ae164bcb3b4380459386adcf331
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_2.png.meta

+fileFormatVersion: 2
+guid: a469f920b21fc7c4fb5b950917ce2fb2
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_20.png.meta

+fileFormatVersion: 2
+guid: 6dda07f1420a968449cf4c6620c44d9f
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_21.png.meta

+fileFormatVersion: 2
+guid: b7f000750830ddb4bbc80065b9314ce9
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_22.png.meta

+fileFormatVersion: 2
+guid: df01d03f056c6f445b4b8a0ae054207c
+timeCreated: 1485107929
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_23.png.meta

+fileFormatVersion: 2
+guid: bfe953600e8fb1849a804ee08ace7b4c
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_24.png.meta

+fileFormatVersion: 2
+guid: 32c6a5f7143b86c44bd5cdee2ff3f8ad
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_25.png.meta

+fileFormatVersion: 2
+guid: f4b8ab78b57749d4e96d36f6d8a395d0
+timeCreated: 1485107929
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_26.png.meta

+fileFormatVersion: 2
+guid: 09f6c01f98a3ded4daf1afc52a3c260f
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_27.png.meta

+fileFormatVersion: 2
+guid: bdd06fb88ef36ed4a85dd506352c2d80
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_28.png.meta

+fileFormatVersion: 2
+guid: 02c0a84bd64c6f044954d8bde9b46ec8
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_29.png.meta

+fileFormatVersion: 2
+guid: aa80dc44aa4fe4c43bb9d51d90cf2958
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_3.png.meta

+fileFormatVersion: 2
+guid: 373f9bf6b0841af4ebf26d25e4a3f4e2
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_30.png.meta

+fileFormatVersion: 2
+guid: 0fa10b21877c61b4db40ba5708815f81
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_31.png.meta

+fileFormatVersion: 2
+guid: 6b0a189df0bd4d5448eaefb4e673ace8
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_32.png.meta

+fileFormatVersion: 2
+guid: 87a5e40cc271ea648b583616f6ebe7fe
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_33.png.meta

+fileFormatVersion: 2
+guid: b71bb466b71fd13449dd736f63caeb67
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_34.png.meta

+fileFormatVersion: 2
+guid: 319b8e66db3faa4438cf6982e9c89b2f
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_35.png.meta

+fileFormatVersion: 2
+guid: 0a79c155edf9b2d429d4736abee5acdb
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_36.png.meta

+fileFormatVersion: 2
+guid: 351e95d0e20a54849bd4ce5f9b498934
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_37.png.meta

+fileFormatVersion: 2
+guid: 1d6958e30e40a254dbe5a54c573eeb3c
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_38.png.meta

+fileFormatVersion: 2
+guid: 9660a4ca1ca8425408ac25c641932977
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_39.png.meta

+fileFormatVersion: 2
+guid: 547dbd5f858c74047ba3f213e4408307
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_4.png.meta

+fileFormatVersion: 2
+guid: 6fa5cf178eaaa5f42b820f636bb6e0bd
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_40.png.meta

+fileFormatVersion: 2
+guid: 1a9ce5640cde5934aae0022f020464a6
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_41.png.meta

+fileFormatVersion: 2
+guid: cd9006dc442cc244e89b3f492384d46a
+timeCreated: 1485107929
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_42.png.meta

+fileFormatVersion: 2
+guid: b266511438fae724f9d3ce6bd26583e8
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_43.png.meta

+fileFormatVersion: 2
+guid: 71bc1b6b66e8b784b972199b7e90204e
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/Textures/LDR_LLL1_44.png.meta

+fileFormatVersion: 2
+guid: 15e54aa23a938444389469d53765d741
+timeCreated: 1485107928
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    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:
+    filterMode: 0
+    aniso: -1
+    mipBias: -1
+    wrapMode: 0
+  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: 2
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 10
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 64
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: