Preparing Water

+{
+    "files.exclude":
+    {
+        "**/.DS_Store":true,
+        "**/.git":true,
+        "**/.gitignore":true,
+        "**/.gitmodules":true,
+        "**/*.booproj":true,
+        "**/*.pidb":true,
+        "**/*.suo":true,
+        "**/*.user":true,
+        "**/*.userprefs":true,
+        "**/*.unityproj":true,
+        "**/*.dll":true,
+        "**/*.exe":true,
+        "**/*.pdf":true,
+        "**/*.mid":true,
+        "**/*.midi":true,
+        "**/*.wav":true,
+        "**/*.gif":true,
+        "**/*.ico":true,
+        "**/*.jpg":true,
+        "**/*.jpeg":true,
+        "**/*.png":true,
+        "**/*.psd":true,
+        "**/*.tga":true,
+        "**/*.tif":true,
+        "**/*.tiff":true,
+        "**/*.3ds":true,
+        "**/*.3DS":true,
+        "**/*.fbx":true,
+        "**/*.FBX":true,
+        "**/*.lxo":true,
+        "**/*.LXO":true,
+        "**/*.ma":true,
+        "**/*.MA":true,
+        "**/*.obj":true,
+        "**/*.OBJ":true,
+        "**/*.asset":true,
+        "**/*.cubemap":true,
+        "**/*.flare":true,
+        "**/*.mat":true,
+        "**/*.meta":true,
+        "**/*.prefab":true,
+        "**/*.unity":true,
+        "build/":true,
+        "Build/":true,
+        "Library/":true,
+        "library/":true,
+        "obj/":true,
+        "Obj/":true,
+        "ProjectSettings/":true,
+        "temp/":true,
+        "Temp/":true
+    }
+}
\ No newline at end of file

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 8a3bdb2cd68f901469e7cc149151eb49, type: 3}
+  m_Name: Basic Enhance
+  m_EditorClassIdentifier: 
+  debugViews:
+    m_Enabled: 1
+    m_Settings:
+      mode: 0
+      depth:
+        scale: 1
+      motionVectors:
+        sourceOpacity: 1
+        motionImageOpacity: 0
+        motionImageAmplitude: 16
+        motionVectorsOpacity: 1
+        motionVectorsResolution: 24
+        motionVectorsAmplitude: 64
+  fog:
+    m_Enabled: 1
+    m_Settings:
+      excludeSkybox: 1
+  antialiasing:
+    m_Enabled: 0
+    m_Settings:
+      method: 0
+      fxaaSettings:
+        preset: 2
+      taaSettings:
+        jitterSpread: 0.75
+        sharpen: 0.3
+        stationaryBlending: 0.95
+        motionBlending: 0.85
+  ambientOcclusion:
+    m_Enabled: 1
+    m_Settings:
+      intensity: 1
+      radius: 0.3
+      sampleCount: 10
+      downsampling: 1
+      forceForwardCompatibility: 0
+      ambientOnly: 0
+      highPrecision: 0
+  screenSpaceReflection:
+    m_Enabled: 0
+    m_Settings:
+      reflection:
+        blendType: 0
+        reflectionQuality: 2
+        maxDistance: 100
+        iterationCount: 256
+        stepSize: 3
+        widthModifier: 0.5
+        reflectionBlur: 1
+        reflectBackfaces: 0
+      intensity:
+        reflectionMultiplier: 1
+        fadeDistance: 100
+        fresnelFade: 1
+        fresnelFadePower: 1
+      screenEdgeMask:
+        intensity: 0.03
+  depthOfField:
+    m_Enabled: 1
+    m_Settings:
+      focusDistance: 10
+      aperture: 5.6
+      focalLength: 50
+      useCameraFov: 1
+      kernelSize: 1
+  motionBlur:
+    m_Enabled: 0
+    m_Settings:
+      shutterAngle: 270
+      sampleCount: 10
+      frameBlending: 0
+  eyeAdaptation:
+    m_Enabled: 0
+    m_Settings:
+      lowPercent: 45
+      highPercent: 95
+      minLuminance: -5
+      maxLuminance: 1
+      keyValue: 0.25
+      dynamicKeyValue: 1
+      adaptationType: 0
+      speedUp: 2
+      speedDown: 1
+      logMin: -8
+      logMax: 4
+  bloom:
+    m_Enabled: 1
+    m_Settings:
+      bloom:
+        intensity: 0.5
+        threshold: 1.1
+        softKnee: 0.5
+        radius: 4
+        antiFlicker: 1
+      lensDirt:
+        texture: {fileID: 0}
+        intensity: 3
+  colorGrading:
+    m_Enabled: 0
+    m_Settings:
+      tonemapping:
+        tonemapper: 2
+        neutralBlackIn: 0.02
+        neutralWhiteIn: 10
+        neutralBlackOut: 0
+        neutralWhiteOut: 10
+        neutralWhiteLevel: 5.3
+        neutralWhiteClip: 10
+      basic:
+        postExposure: 0
+        temperature: 0
+        tint: 0
+        hueShift: 0
+        saturation: 1
+        contrast: 1
+      channelMixer:
+        red: {x: 1, y: 0, z: 0}
+        green: {x: 0, y: 1, z: 0}
+        blue: {x: 0, y: 0, z: 1}
+        currentEditingChannel: 0
+      colorWheels:
+        mode: 1
+        log:
+          slope: {r: 0, g: 0, b: 0, a: 0}
+          power: {r: 0, g: 0, b: 0, a: 0}
+          offset: {r: 0, g: 0, b: 0, a: 0}
+        linear:
+          lift: {r: 0, g: 0, b: 0, a: 0}
+          gamma: {r: 0, g: 0, b: 0, a: 0}
+          gain: {r: 0, g: 0, b: 0, a: 0}
+      curves:
+        master:
+          curve:
+            serializedVersion: 2
+            m_Curve:
+            - serializedVersion: 2
+              time: 0
+              value: 0
+              inSlope: 1
+              outSlope: 1
+              tangentMode: 0
+            - serializedVersion: 2
+              time: 1
+              value: 1
+              inSlope: 1
+              outSlope: 1
+              tangentMode: 0
+            m_PreInfinity: 2
+            m_PostInfinity: 2
+            m_RotationOrder: 4
+          m_Loop: 0
+          m_ZeroValue: 0
+          m_Range: 1
+        red:
+          curve:
+            serializedVersion: 2
+            m_Curve:
+            - serializedVersion: 2
+              time: 0
+              value: 0
+              inSlope: 1
+              outSlope: 1
+              tangentMode: 0
+            - serializedVersion: 2
+              time: 1
+              value: 1
+              inSlope: 1
+              outSlope: 1
+              tangentMode: 0
+            m_PreInfinity: 2
+            m_PostInfinity: 2
+            m_RotationOrder: 4
+          m_Loop: 0
+          m_ZeroValue: 0
+          m_Range: 1
+        green:
+          curve:
+            serializedVersion: 2
+            m_Curve:
+            - serializedVersion: 2
+              time: 0
+              value: 0
+              inSlope: 1
+              outSlope: 1
+              tangentMode: 0
+            - serializedVersion: 2
+              time: 1
+              value: 1
+              inSlope: 1
+              outSlope: 1
+              tangentMode: 0
+            m_PreInfinity: 2
+            m_PostInfinity: 2
+            m_RotationOrder: 4
+          m_Loop: 0
+          m_ZeroValue: 0
+          m_Range: 1
+        blue:
+          curve:
+            serializedVersion: 2
+            m_Curve:
+            - serializedVersion: 2
+              time: 0
+              value: 0
+              inSlope: 1
+              outSlope: 1
+              tangentMode: 0
+            - serializedVersion: 2
+              time: 1
+              value: 1
+              inSlope: 1
+              outSlope: 1
+              tangentMode: 0
+            m_PreInfinity: 2
+            m_PostInfinity: 2
+            m_RotationOrder: 4
+          m_Loop: 0
+          m_ZeroValue: 0
+          m_Range: 1
+        hueVShue:
+          curve:
+            serializedVersion: 2
+            m_Curve: []
+            m_PreInfinity: 2
+            m_PostInfinity: 2
+            m_RotationOrder: 4
+          m_Loop: 1
+          m_ZeroValue: 0.5
+          m_Range: 1
+        hueVSsat:
+          curve:
+            serializedVersion: 2
+            m_Curve: []
+            m_PreInfinity: 2
+            m_PostInfinity: 2
+            m_RotationOrder: 4
+          m_Loop: 1
+          m_ZeroValue: 0.5
+          m_Range: 1
+        satVSsat:
+          curve:
+            serializedVersion: 2
+            m_Curve: []
+            m_PreInfinity: 2
+            m_PostInfinity: 2
+            m_RotationOrder: 4
+          m_Loop: 0
+          m_ZeroValue: 0.5
+          m_Range: 1
+        lumVSsat:
+          curve:
+            serializedVersion: 2
+            m_Curve: []
+            m_PreInfinity: 2
+            m_PostInfinity: 2
+            m_RotationOrder: 4
+          m_Loop: 0
+          m_ZeroValue: 0.5
+          m_Range: 1
+        e_CurrentEditingCurve: 0
+        e_CurveY: 1
+        e_CurveR: 0
+        e_CurveG: 0
+        e_CurveB: 0
+  userLut:
+    m_Enabled: 0
+    m_Settings:
+      lut: {fileID: 0}
+      contribution: 1
+  chromaticAberration:
+    m_Enabled: 0
+    m_Settings:
+      spectralTexture: {fileID: 0}
+      intensity: 0.1
+  grain:
+    m_Enabled: 0
+    m_Settings:
+      colored: 1
+      intensity: 0.5
+      size: 1
+      luminanceContribution: 0.8
+  vignette:
+    m_Enabled: 1
+    m_Settings:
+      mode: 0
+      color: {r: 0, g: 0, b: 0, a: 1}
+      center: {x: 0.5, y: 0.5}
+      intensity: 0.45
+      smoothness: 0.2
+      roundness: 1
+      mask: {fileID: 0}
+      opacity: 1
+      rounded: 0
+  dithering:
+    m_Enabled: 0
+  monitors:
+    currentMonitorID: 0
+    refreshOnPlay: 0
+    histogramMode: 3
+    waveformExposure: 0.12
+    waveformY: 0
+    waveformR: 1
+    waveformG: 1
+    waveformB: 1
+    paradeExposure: 0.12
+    vectorscopeExposure: 0.12
+    vectorscopeShowBackground: 1

+fileFormatVersion: 2
+guid: d8515d2f8d9b4482bb41b19940a27eb0
+timeCreated: 1516852975
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

@@ -38,7 +38,7 @@ RenderSettings:
   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.18028653, g: 0.22571698, b: 0.30692574, a: 1}
+  m_IndirectSpecularColor: {r: 0.25328526, g: 0.2169855, b: 0.23319682, a: 1}
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
@@ -391,6 +391,7 @@ GameObject:
   - component: {fileID: 775083197}
   - component: {fileID: 775083196}
   - component: {fileID: 775083195}
+  - component: {fileID: 775083199}
   m_Layer: 0
   m_Name: Main Camera
   m_TagString: MainCamera
@@ -461,6 +462,18 @@ Transform:
   m_Father: {fileID: 0}
   m_RootOrder: 2
   m_LocalEulerAnglesHint: {x: 28.569002, y: -40, z: 0}
+--- !u!114 &775083199
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 775083194}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: ff26db721962cdf4a8edcdfa9a767d2a, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  profile: {fileID: 11400000, guid: d8515d2f8d9b4482bb41b19940a27eb0, type: 2}
 --- !u!1 &810164710
 GameObject:
   m_ObjectHideFlags: 0

@@ -7,7 +7,7 @@ Material:
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: SkyBox
-  m_Shader: {fileID: 106, guid: 0000000000000000f000000000000000, type: 0}
+  m_Shader: {fileID: 103, guid: 0000000000000000f000000000000000, type: 0}
   m_ShaderKeywords: _SUNDISK_HIGH_QUALITY
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
@@ -17,13 +17,13 @@ Material:
   disabledShaderPasses: []
   m_SavedProperties:
     serializedVersion: 3
-    m_TexEnvs: []
+    m_TexEnvs:
+    - _Tex:
+        m_Texture: {fileID: 8900000, guid: 656a59a5ff93c46498416d97e5c16b66, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     m_Floats:
-    - _AtmosphereThickness: 1
-    - _Exposure: 1.3
-    - _SunDisk: 2
-    - _SunSize: 0.04
-    - _SunSizeConvergence: 5
+    - _Exposure: 1
+    - _Rotation: 0
     m_Colors:
-    - _GroundColor: {r: 0.36899996, g: 0.34899998, b: 0.34099993, a: 1}
-    - _SkyTint: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    - _Tint: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}

+fileFormatVersion: 2
+guid: 5dbfb25c145da4ee3b85fc2e8c46da04
+folderAsset: yes
+timeCreated: 1516852825
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: 83715878d3a8db441aa5636641db69a3
+folderAsset: yes
+timeCreated: 1476176392
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: e7358848dd8737c459f4636f1c075835
+folderAsset: yes
+timeCreated: 1460361782
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+#include "UnityCG.cginc"
+
+RWStructuredBuffer<uint4> _Histogram;
+Texture2D<float4> _Source;
+
+CBUFFER_START (Params)
+    uint _IsLinear;
+    float4 _Res;
+    uint4 _Channels;
+CBUFFER_END
+
+groupshared uint4 gs_histogram[256];
+
+#define GROUP_SIZE 16
+
+#pragma kernel KHistogramGather
+[numthreads(GROUP_SIZE, GROUP_SIZE,1)]
+void KHistogramGather(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupThreadId : SV_GroupThreadID)
+{
+    const uint localThreadId = groupThreadId.y * GROUP_SIZE + groupThreadId.x;
+    
+    if (localThreadId < 256)
+        gs_histogram[localThreadId] = uint4(0, 0, 0, 0);
+
+    GroupMemoryBarrierWithGroupSync();
+
+    if (dispatchThreadId.x < (uint)_Res.x && dispatchThreadId.y < (uint)_Res.y)
+    {
+        // We want a gamma histogram (like Photoshop & all)
+        float3 color = saturate(_Source[dispatchThreadId].xyz);
+        if (_IsLinear > 0)
+            color = LinearToGammaSpace(color);
+        
+        // Convert color & luminance to histogram bin
+        uint3 idx_c = (uint3)(round(color * 255.0));
+        uint idx_l = (uint)(round(dot(color.rgb, float3(0.2125, 0.7154, 0.0721)) * 255.0));
+    
+        // Fill the group shared histogram
+        if (_Channels.x > 0u) InterlockedAdd(gs_histogram[idx_c.x].x, 1); // Red
+        if (_Channels.y > 0u) InterlockedAdd(gs_histogram[idx_c.y].y, 1); // Green
+        if (_Channels.z > 0u) InterlockedAdd(gs_histogram[idx_c.z].z, 1); // Blue
+        if (_Channels.w > 0u) InterlockedAdd(gs_histogram[idx_l].w, 1);   // Luminance
+    }
+
+    GroupMemoryBarrierWithGroupSync();
+
+    // Merge
+    if (localThreadId < 256)
+    {
+        uint4 h = gs_histogram[localThreadId];
+        if (_Channels.x > 0u && h.x > 0) InterlockedAdd(_Histogram[localThreadId].x, h.x); // Red
+        if (_Channels.y > 0u && h.y > 0) InterlockedAdd(_Histogram[localThreadId].y, h.y); // Green
+        if (_Channels.z > 0u && h.z > 0) InterlockedAdd(_Histogram[localThreadId].z, h.z); // Blue
+        if (_Channels.w > 0u && h.w > 0) InterlockedAdd(_Histogram[localThreadId].w, h.w); // Luminance
+    }
+}
+
+// Scaling pass
+groupshared uint4 gs_pyramid[256];
+
+#pragma kernel KHistogramScale
+[numthreads(16,16,1)]
+void KHistogramScale(uint2 groupThreadId : SV_GroupThreadID)
+{
+    const uint localThreadId = groupThreadId.y * 16 + groupThreadId.x;
+    gs_pyramid[localThreadId] = _Histogram[localThreadId];
+
+    GroupMemoryBarrierWithGroupSync();
+
+    // Parallel reduction to find the max value
+    UNITY_UNROLL
+    for(uint i = 256 >> 1; i > 0; i >>= 1)
+    {
+        if(localThreadId < i)
+            gs_pyramid[localThreadId] = max(gs_pyramid[localThreadId], gs_pyramid[localThreadId + i]);
+
+        GroupMemoryBarrierWithGroupSync();
+    }
+
+    // Actual scaling
+    float4 factor = _Res.y / (float4)gs_pyramid[0];
+    _Histogram[localThreadId] = (uint4)round(_Histogram[localThreadId] * factor);
+}
+
+#pragma kernel KHistogramClear
+[numthreads(GROUP_SIZE, GROUP_SIZE, 1)]
+void KHistogramClear(uint2 dispatchThreadId : SV_DispatchThreadID)
+{
+    if (dispatchThreadId.x < (uint)_Res.x && dispatchThreadId.y < (uint)_Res.y)
+        _Histogram[dispatchThreadId.y * _Res.x + dispatchThreadId.x] = uint4(0u, 0u, 0u, 0u);
+}

+fileFormatVersion: 2
+guid: 51b7e4b4448c98f4a849081110fd6212
+timeCreated: 1459956391
+licenseType: Store
+ComputeShaderImporter:
+  currentAPIMask: 4
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+Shader "Hidden/Post FX/Monitors/Histogram Render"
+{
+    SubShader
+    {
+        ZTest Always Cull Off ZWrite Off
+        Fog { Mode off }
+
+        CGINCLUDE
+
+            #pragma fragmentoption ARB_precision_hint_fastest
+            #pragma target 5.0
+            #include "UnityCG.cginc"
+
+            StructuredBuffer<uint4> _Histogram;
+            float2 _Size;
+            uint _Channel;
+            float4 _ColorR;
+            float4 _ColorG;
+            float4 _ColorB;
+            float4 _ColorL;
+
+            float4 FragSingleChannel(v2f_img i) : SV_Target
+            {
+                const float4 COLORS[4] = { _ColorR, _ColorG, _ColorB, _ColorL };
+
+                float remapI = i.uv.x * 255.0;
+                uint index = floor(remapI);
+                float delta = frac(remapI);
+                float v1 = _Histogram[index][_Channel];
+                float v2 = _Histogram[min(index + 1, 255)][_Channel];
+                float h = v1 * (1.0 - delta) + v2 * delta;
+                uint y = (uint)round(i.uv.y * _Size.y);
+
+                float4 color = float4(0.1, 0.1, 0.1, 1.0);
+                float fill = step(y, h);
+                color = lerp(color, COLORS[_Channel], fill);
+                return color;
+            }
+
+            float4 FragRgbMerged(v2f_img i) : SV_Target
+            {
+                const float4 COLORS[3] = { _ColorR, _ColorG, _ColorB };
+
+                float4 targetColor = float4(0.1, 0.1, 0.1, 1.0);
+                float4 emptyColor = float4(0.0, 0.0, 0.0, 1.0);
+
+                float remapI = i.uv.x * 255.0;
+                uint index = floor(remapI);
+                float delta = frac(remapI);
+
+                for (int j = 0; j < 3; j++)
+                {
+                    float v1 = _Histogram[index][j];
+                    float v2 = _Histogram[min(index + 1, 255)][j];
+                    float h = v1 * (1.0 - delta) + v2 * delta;
+                    uint y = (uint)round(i.uv.y * _Size.y);
+                    float fill = step(y, h);
+                    float4 color = lerp(emptyColor, COLORS[j], fill);
+                    targetColor += color;
+                }
+
+                return saturate(targetColor);
+            }
+
+            float4 FragRgbSplitted(v2f_img i) : SV_Target
+            {
+                const float4 COLORS[3] = {_ColorR, _ColorG, _ColorB};
+
+                const float limitB = round(_Size.y / 3.0);
+                const float limitG = limitB * 2;
+
+                float4 color = float4(0.1, 0.1, 0.1, 1.0);
+                uint channel;
+                float offset;
+
+                if (i.pos.y < limitB)
+                {
+                    channel = 2;
+                    offset = 0.0;
+                }
+                else if (i.pos.y < limitG)
+                {
+                    channel = 1;
+                    offset = limitB;
+                }
+                else
+                {
+                    channel = 0;
+                    offset = limitG;
+                }
+
+                float remapI = i.uv.x * 255.0;
+                uint index = floor(remapI);
+                float delta = frac(remapI);
+                float v1 = offset + _Histogram[index][channel] / 3.0;
+                float v2 = offset + _Histogram[min(index + 1, 255)][channel] / 3.0;
+                float h = v1 * (1.0 - delta) + v2 * delta;
+                uint y = (uint)round(i.uv.y * _Size.y);
+
+                float fill = step(y, h);
+                color = lerp(color, COLORS[channel], fill);
+                return color;
+            }
+
+        ENDCG
+
+        // (0) Channel
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex vert_img
+                #pragma fragment FragSingleChannel
+
+            ENDCG
+        }
+
+        // (1) RGB merged
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex vert_img
+                #pragma fragment FragRgbMerged
+
+            ENDCG
+        }
+
+        // (2) RGB splitted
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex vert_img
+                #pragma fragment FragRgbSplitted
+
+            ENDCG
+        }
+    }
+    FallBack off
+}

+fileFormatVersion: 2
+guid: 965efa32cf2345647a1c987546e08f86
+timeCreated: 1459956391
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+Shader "Hidden/Post FX/Monitors/Parade Render"
+{
+    SubShader
+    {
+        ZTest Always Cull Off ZWrite Off
+        Fog { Mode off }
+
+        CGINCLUDE
+
+            #pragma fragmentoption ARB_precision_hint_fastest
+            #pragma target 5.0
+            #include "UnityCG.cginc"
+
+            StructuredBuffer<uint4> _Waveform;
+            float4 _Size;
+            float _Exposure;
+
+            float3 Tonemap(float3 x, float exposure)
+            {
+                const float a = 6.2;
+                const float b = 0.5;
+                const float c = 1.7;
+                const float d = 0.06;
+                x *= exposure;
+                x = max((0.0).xxx, x - (0.004).xxx);
+                x = (x * (a * x + b)) / (x * (a * x + c) + d);
+                return x * x;
+            }
+
+            float4 FragParade(v2f_img i) : SV_Target
+            {
+                const float3 red = float3(1.8, 0.03, 0.02);
+                const float3 green = float3(0.02, 1.3, 0.05);
+                const float3 blue = float3(0.0, 0.45, 1.75);
+                float3 color = float3(0.0, 0.0, 0.0);
+
+                const uint limitR = _Size.x / 3;
+                const uint limitG = limitR * 2;
+
+                if (i.pos.x < (float)limitR)
+                {
+                    uint2 uvI = i.pos.xy;
+                    color = _Waveform[uvI.y + uvI.x * _Size.y].r * red;
+                }
+                else if (i.pos.x < (float)limitG)
+                {
+                    uint2 uvI = uint2(i.pos.x - limitR, i.pos.y);
+                    color = _Waveform[uvI.y + uvI.x * _Size.y].g * green;
+                }
+                else
+                {
+                    uint2 uvI = uint2(i.pos.x - limitG, i.pos.y);
+                    color = _Waveform[uvI.y + uvI.x * _Size.y].b * blue;
+                }
+
+                color = Tonemap(color, _Exposure);
+                color += (0.1).xxx;
+
+                return float4(saturate(color), 1.0);
+            }
+
+        ENDCG
+
+        // (0)
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex vert_img
+                #pragma fragment FragParade
+
+            ENDCG
+        }
+    }
+    FallBack off
+}

+fileFormatVersion: 2
+guid: 5ae1bfc1dd20ac04e8b74aa0f2f12eea
+timeCreated: 1459956391
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+#include "UnityCG.cginc"
+
+RWStructuredBuffer<uint> _Vectorscope;
+Texture2D<float4> _Source;
+
+CBUFFER_START (Params)
+    uint _IsLinear;
+    float4 _Res;
+CBUFFER_END
+
+#define GROUP_SIZE 32
+
+float3 RgbToYUV(float3 c)
+{
+    float Y =  0.299 * c.r + 0.587 * c.g + 0.114 * c.b;
+    float U = -0.169 * c.r - 0.331 * c.g + 0.500 * c.b;
+    float V =  0.500 * c.r - 0.419 * c.g - 0.081 * c.b;
+    return float3(Y, U, V);
+}
+
+#pragma kernel KVectorscope
+[numthreads(GROUP_SIZE,GROUP_SIZE,1)]
+void KVectorscope(uint2 dispatchThreadId : SV_DispatchThreadID)
+{
+    if (dispatchThreadId.x < (uint)_Res.x && dispatchThreadId.y < (uint)_Res.y)
+    {
+        float3 color = saturate(_Source[dispatchThreadId].xyz);
+        if (_IsLinear > 0)
+            color = LinearToGammaSpace(color);
+
+        float3 yuv = RgbToYUV(color);
+
+        if (length(yuv.yz) > 0.49)
+            yuv.yz = normalize(yuv.yz) * 0.49;
+
+        yuv.yz += (0.5).xx;
+        uint u = (uint)floor(yuv.y * _Res.x);
+        uint v = (uint)floor(yuv.z * _Res.y);
+        InterlockedAdd(_Vectorscope[v * _Res.x + u], 1);
+    }
+}
+
+#pragma kernel KVectorscopeClear
+[numthreads(GROUP_SIZE,GROUP_SIZE,1)]
+void KVectorscopeClear(uint2 dispatchThreadId : SV_DispatchThreadID)
+{
+    if (dispatchThreadId.x < (uint)_Res.x && dispatchThreadId.y < (uint)_Res.y)
+        _Vectorscope[dispatchThreadId.y * _Res.x + dispatchThreadId.x] = 0u;
+}

+fileFormatVersion: 2
+guid: 45de9ff58691e934c9810dc23de2ba50
+timeCreated: 1459956391
+licenseType: Store
+ComputeShaderImporter:
+  currentAPIMask: 4
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+Shader "Hidden/Post FX/Monitors/Vectorscope Render"
+{
+    SubShader
+    {
+        ZTest Always Cull Off ZWrite Off
+        Fog { Mode off }
+
+        CGINCLUDE
+
+            #pragma fragmentoption ARB_precision_hint_fastest
+            #pragma target 5.0
+            #include "UnityCG.cginc"
+
+            StructuredBuffer<uint> _Vectorscope;
+            float2 _Size;
+            float _Exposure;
+
+            float Tonemap(float x, float exposure)
+            {
+                const float a = 6.2;
+                const float b = 0.5;
+                const float c = 1.7;
+                const float d = 0.06;
+                x *= exposure;
+                x = max(0.0, x - 0.004);
+                x = (x * (a * x + b)) / (x * (a * x + c) + d);
+                return x * x;
+            }
+
+            float3 YuvToRgb(float3 c)
+            {
+                float R = c.x + 0.000 * c.y + 1.403 * c.z;
+                float G = c.x - 0.344 * c.y - 0.714 * c.z;
+                float B = c.x - 1.773 * c.y + 0.000 * c.z;
+                return float3(R, G, B);
+            }
+
+            float4 FragBackground(v2f_img i) : SV_Target
+            {
+                i.uv.x = 1.0 - i.uv.x;
+                float2 uv = i.uv - (0.5).xx;
+                float3 c = YuvToRgb(float3(0.5, uv.x, uv.y));
+
+                float dist = sqrt(dot(uv, uv));
+                float delta = fwidth(dist);
+                float alphaOut = 1.0 - smoothstep(0.5 - delta, 0.5 + delta, dist);
+                float alphaIn = smoothstep(0.495 - delta, 0.495 + delta, dist);
+
+                uint2 uvI = i.pos.xy;
+                uint v = _Vectorscope[uvI.x + uvI.y * _Size.x];
+                float vt = saturate(Tonemap(v, _Exposure));
+
+                float4 color = float4(lerp(c, (0.0).xxx, vt), alphaOut);
+                color.rgb += alphaIn;
+                return color;
+            }
+
+            float4 FragNoBackground(v2f_img i) : SV_Target
+            {
+                i.uv.x = 1.0 - i.uv.x;
+                float2 uv = i.uv - (0.5).xx;
+
+                float dist = sqrt(dot(uv, uv));
+                float delta = fwidth(dist);
+                float alphaOut = 1.0 - smoothstep(0.5 - delta, 0.5 + delta, dist);
+                float alphaIn = smoothstep(0.495 - delta, 0.495 + delta, dist);
+
+                uint2 uvI = i.pos.xy;
+                uint v = _Vectorscope[uvI.x + uvI.y * _Size.x];
+                float vt = saturate(Tonemap(v, _Exposure));
+
+                float4 color = float4((1.0).xxx, vt + alphaIn * alphaOut);
+                return color;
+            }
+
+        ENDCG
+
+        // (0)
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex vert_img
+                #pragma fragment FragBackground
+
+            ENDCG
+        }
+
+        // (1)
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex vert_img
+                #pragma fragment FragNoBackground
+
+            ENDCG
+        }
+    }
+    FallBack off
+}

+fileFormatVersion: 2
+guid: 1c4298cd35ef7834e892898e49d61ecd
+timeCreated: 1461756159
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+#include "UnityCG.cginc"
+
+RWStructuredBuffer<uint4> _Waveform;
+Texture2D<float4> _Source;
+
+CBUFFER_START (Params)
+    uint _IsLinear;
+    uint4 _Channels;
+CBUFFER_END
+
+#define COLUMNS 384
+
+#pragma kernel KWaveform
+[numthreads(1,COLUMNS,1)]
+void KWaveform(uint2 dispatchThreadId : SV_DispatchThreadID)
+{
+    // We want a gamma corrected colors
+    float3 color = _Source[dispatchThreadId].rgb;
+    if (_IsLinear > 0u)
+        color = LinearToGammaSpace(color);
+
+    color = saturate(color);
+
+    // Convert color & luminance to histogram bins
+    const float kColumnsMinusOne = COLUMNS - 1.0;
+    uint3 idx_c = (uint3)(round(color * kColumnsMinusOne));
+    uint idx_l = (uint)(round(dot(color.rgb, float3(0.2126, 0.7152, 0.0722)) * kColumnsMinusOne));
+
+    // A lot of atomic operations will be skipped so there's no need to over-think this one.
+    uint j = dispatchThreadId.x * COLUMNS;
+    if (_Channels.x > 0u && idx_c.x > 0u) InterlockedAdd(_Waveform[j + idx_c.x].x, 1u); // Red
+    if (_Channels.y > 0u && idx_c.y > 0u) InterlockedAdd(_Waveform[j + idx_c.y].y, 1u); // Green
+    if (_Channels.z > 0u && idx_c.z > 0u) InterlockedAdd(_Waveform[j + idx_c.z].z, 1u); // Blue
+    if (_Channels.w > 0u) InterlockedAdd(_Waveform[j + idx_l].w, 1u); // Luminance
+}
+
+#pragma kernel KWaveformClear
+[numthreads(1, COLUMNS, 1)]
+void KWaveformClear(uint2 dispatchThreadId : SV_DispatchThreadID)
+{
+    _Waveform[dispatchThreadId.x * COLUMNS + dispatchThreadId.y] = uint4(0u, 0u, 0u, 0u);
+}

+fileFormatVersion: 2
+guid: 9d9b886f7a8fe7b4baf56624c42e3420
+timeCreated: 1459956392
+licenseType: Store
+ComputeShaderImporter:
+  currentAPIMask: 4
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+Shader "Hidden/Post FX/Monitors/Waveform Render"
+{
+    SubShader
+    {
+        ZTest Always Cull Off ZWrite Off
+        Fog { Mode off }
+
+        CGINCLUDE
+
+            #pragma fragmentoption ARB_precision_hint_fastest
+            #pragma target 5.0
+            #include "UnityCG.cginc"
+
+            StructuredBuffer<uint4> _Waveform;
+            float2 _Size;
+            float4 _Channels;
+            float _Exposure;
+
+            float3 Tonemap(float3 x, float exposure)
+            {
+                const float a = 6.2;
+                const float b = 0.5;
+                const float c = 1.7;
+                const float d = 0.06;
+                x *= exposure;
+                x = max((0.0).xxx, x - (0.004).xxx);
+                x = (x * (a * x + b)) / (x * (a * x + c) + d);
+                return x * x;
+            }
+
+            float4 FragWaveform(v2f_img i) : SV_Target
+            {
+                const float3 red = float3(1.4, 0.03, 0.02);
+                const float3 green = float3(0.02, 1.1, 0.05);
+                const float3 blue = float3(0.0, 0.25, 1.5);
+                float3 color = float3(0.0, 0.0, 0.0);
+
+                uint2 uvI = i.pos.xy;
+                float4 w = _Waveform[uvI.y + uvI.x * _Size.y]; // Waveform data is stored in columns instead of rows
+
+                color += red * w.r * _Channels.r;
+                color += green * w.g * _Channels.g;
+                color += blue * w.b * _Channels.b;
+                color += w.aaa * _Channels.a * 1.5;
+                color = Tonemap(color, _Exposure);
+                color += (0.1).xxx;
+
+                return float4(saturate(color), 1.0);
+            }
+
+        ENDCG
+
+        // (0)
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex vert_img
+                #pragma fragment FragWaveform
+
+            ENDCG
+        }
+    }
+    FallBack off
+}

+fileFormatVersion: 2
+guid: 8b3e43c50424ab2428a9c172843bc66d
+timeCreated: 1459956391
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: df37d60cc69b7b04d9705a74938179e7
+folderAsset: yes
+timeCreated: 1460627771
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+Shader "Hidden/Post FX/UI/Curve Background"
+{
+    CGINCLUDE
+
+        #pragma target 3.0
+        #include "UnityCG.cginc"
+
+        float _DisabledState;
+
+        float3 HsvToRgb(float3 c)
+        {
+            float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+            float3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
+            return c.z * lerp(K.xxx, saturate(p - K.xxx), c.y);
+        }
+
+        float4 FragHue(v2f_img i) : SV_Target
+        {
+            float3 hsv = HsvToRgb(float3(i.uv.x, 1.0, 0.2));
+            float4 color = float4((0.0).xxx, 1.0);
+            color.rgb = lerp(color.rgb, hsv, smoothstep(0.5, 1.1, 1.0 - i.uv.y)) + lerp(color.rgb, hsv, smoothstep(0.5, 1.1, i.uv.y));
+            color.rgb += (0.15).xxx;
+            return float4(color.rgb, color.a * _DisabledState);
+        }
+
+        float4 FragSat(v2f_img i) : SV_Target
+        {
+            float4 color = float4((0.0).xxx, 1.0);
+            float sat = i.uv.x / 2;
+            color.rgb += lerp(color.rgb, (sat).xxx, smoothstep(0.5, 1.2, 1.0 - i.uv.y)) + lerp(color.rgb, (sat).xxx, smoothstep(0.5, 1.2, i.uv.y));
+            color.rgb += (0.15).xxx;
+            return float4(color.rgb, color.a * _DisabledState);
+        }
+
+    ENDCG
+
+    SubShader
+    {
+        Cull Off ZWrite Off ZTest Always
+
+        // (0) Hue
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex vert_img
+                #pragma fragment FragHue
+
+            ENDCG
+        }
+
+        // (1) Sat/lum
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex vert_img
+                #pragma fragment FragSat
+
+            ENDCG
+        }
+    }
+}

+fileFormatVersion: 2
+guid: b1b2bfb2897659e45983f0c3e7dda2c8
+timeCreated: 1460970196
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: c0fa58091049bd24394fa15b0b6d4c5a
+timeCreated: 1468326774
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    linearTexture: 1
+    correctGamma: 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
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  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
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  buildTargetSettings: []
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+Shader "Hidden/Post FX/UI/Trackball"
+{
+    CGINCLUDE
+
+        #include "UnityCG.cginc"
+
+        #define PI 3.14159265359
+        #define PI2 6.28318530718
+
+        float _Offset;
+        float _DisabledState;
+        float2 _Resolution; // x: size, y: size / 2
+
+        float3 HsvToRgb(float3 c)
+        {
+            float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+            float3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
+            return c.z * lerp(K.xxx, saturate(p - K.xxx), c.y);
+        }
+
+        float4 CreateWheel(v2f_img i, float crossColor, float offsetColor)
+        {
+            const float kHueOuterRadius = 0.45;
+            const float kHueInnerRadius = 0.38;
+            const float kLumOuterRadius = 0.495;
+            const float kLumInnerRadius = 0.48;
+
+            float4 color = (0.0).xxxx;
+            float2 uvc = i.uv - (0.5).xx;
+            float dist = sqrt(dot(uvc, uvc));
+            float delta = fwidth(dist);
+            float angle = atan2(uvc.x, uvc.y);
+
+            // Cross
+            {
+                float radius = (0.5 - kHueInnerRadius) * _Resolution.x + 1.0;
+                float2 pixel = (_Resolution.xx - 1.0) * i.uv + 1.0;
+
+                float vline = step(floor(fmod(pixel.x, _Resolution.y)), 0.0);
+                vline *= step(radius, pixel.y) * step(pixel.y, _Resolution.x - radius);
+
+                float hline = step(floor(fmod(pixel.y, _Resolution.y)), 0.0);
+                hline *= step(radius, pixel.x) * step(pixel.x, _Resolution.x - radius);
+
+                color += hline.xxxx * (1.0).xxxx;
+                color += vline.xxxx * (1.0).xxxx;
+                color = saturate(color);
+                color *= half4((crossColor).xxx, 0.05);
+            }
+
+            // Hue
+            {
+                float alphaOut = smoothstep(kHueOuterRadius - delta, kHueOuterRadius + delta, dist);
+                float alphaIn = smoothstep(kHueInnerRadius - delta, kHueInnerRadius + delta, dist);
+
+                float hue = angle;
+                hue = 1.0 - ((hue > 0.0) ? hue : PI2 + hue) / PI2;
+                float4 c = float4(HsvToRgb(float3(hue, 1.0, 1.0)), 1.0);
+                color += lerp((0.0).xxxx, c, alphaIn - alphaOut);
+            }
+
+            // Offset
+            {
+                float alphaOut = smoothstep(kLumOuterRadius - delta, kLumOuterRadius + delta, dist);
+                float alphaIn = smoothstep(kLumInnerRadius - delta, kLumInnerRadius + delta / 2, dist);
+                float4 c = float4((offsetColor).xxx, 1.0);
+
+                float a = PI * _Offset;
+                if (_Offset >= 0 && angle < a && angle > 0.0)
+                    c = float4((1.0).xxx, 0.5);
+                else if (angle > a && angle < 0.0)
+                    c = float4((1.0).xxx, 0.5);
+
+                color += lerp((0.0).xxxx, c, alphaIn - alphaOut);
+            }
+
+            return color * _DisabledState;
+        }
+
+        float4 FragTrackballDark(v2f_img i) : SV_Target
+        {
+            return CreateWheel(i, 1.0, 0.15);
+        }
+
+        float4 FragTrackballLight(v2f_img i) : SV_Target
+        {
+            return CreateWheel(i, 0.0, 0.3);
+        }
+
+    ENDCG
+
+    SubShader
+    {
+        Cull Off ZWrite Off ZTest Always
+
+        // (0) Dark skin
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex vert_img
+                #pragma fragment FragTrackballDark
+
+            ENDCG
+        }
+
+        // (1) Light skin
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex vert_img
+                #pragma fragment FragTrackballLight
+
+            ENDCG
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 4bf49309c7ab9eb42a86774d2c09b4fa
+timeCreated: 1460627788
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: e0e418747b892364db5c5f4451e67ede
+folderAsset: yes
+timeCreated: 1466586258
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: cc5c690f549b4704eb992a9be781554d
+folderAsset: yes
+timeCreated: 1466769698
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using System;
+
+namespace UnityEditor.PostProcessing
+{
+    public class PostProcessingModelEditorAttribute : Attribute
+    {
+        public readonly Type type;
+        public readonly bool alwaysEnabled;
+
+        public PostProcessingModelEditorAttribute(Type type, bool alwaysEnabled = false)
+        {
+            this.type = type;
+            this.alwaysEnabled = alwaysEnabled;
+        }
+    }
+}

+fileFormatVersion: 2
+guid: c21938aa988055347a2271f03a3e731e
+timeCreated: 1466769734
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: d5341d31985da604db4b100f174142ad
+folderAsset: yes
+timeCreated: 1466769808
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    using Settings = AmbientOcclusionModel.Settings;
+
+    [PostProcessingModelEditor(typeof(AmbientOcclusionModel))]
+    public class AmbientOcclusionModelEditor : PostProcessingModelEditor
+    {
+        SerializedProperty m_Intensity;
+        SerializedProperty m_Radius;
+        SerializedProperty m_SampleCount;
+        SerializedProperty m_Downsampling;
+        SerializedProperty m_ForceForwardCompatibility;
+        SerializedProperty m_AmbientOnly;
+        SerializedProperty m_HighPrecision;
+
+        public override void OnEnable()
+        {
+            m_Intensity = FindSetting((Settings x) => x.intensity);
+            m_Radius = FindSetting((Settings x) => x.radius);
+            m_SampleCount = FindSetting((Settings x) => x.sampleCount);
+            m_Downsampling = FindSetting((Settings x) => x.downsampling);
+            m_ForceForwardCompatibility = FindSetting((Settings x) => x.forceForwardCompatibility);
+            m_AmbientOnly = FindSetting((Settings x) => x.ambientOnly);
+            m_HighPrecision = FindSetting((Settings x) => x.highPrecision);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.PropertyField(m_Intensity);
+            EditorGUILayout.PropertyField(m_Radius);
+            EditorGUILayout.PropertyField(m_SampleCount);
+            EditorGUILayout.PropertyField(m_Downsampling);
+            EditorGUILayout.PropertyField(m_ForceForwardCompatibility);
+            EditorGUILayout.PropertyField(m_HighPrecision, EditorGUIHelper.GetContent("High Precision (Forward)"));
+
+            using (new EditorGUI.DisabledGroupScope(m_ForceForwardCompatibility.boolValue))
+                EditorGUILayout.PropertyField(m_AmbientOnly, EditorGUIHelper.GetContent("Ambient Only (Deferred + HDR)"));
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 9fcb710e23a5a0546a3b8b0ca28c1720
+timeCreated: 1467190133
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    using Method = AntialiasingModel.Method;
+    using Settings = AntialiasingModel.Settings;
+
+    [PostProcessingModelEditor(typeof(AntialiasingModel))]
+    public class AntialiasingModelEditor : PostProcessingModelEditor
+    {
+        SerializedProperty m_Method;
+
+        SerializedProperty m_FxaaPreset;
+
+        SerializedProperty m_TaaJitterSpread;
+        SerializedProperty m_TaaSharpen;
+        SerializedProperty m_TaaStationaryBlending;
+        SerializedProperty m_TaaMotionBlending;
+
+        static string[] s_MethodNames =
+        {
+            "Fast Approximate Anti-aliasing",
+            "Temporal Anti-aliasing"
+        };
+
+        public override void OnEnable()
+        {
+            m_Method = FindSetting((Settings x) => x.method);
+
+            m_FxaaPreset = FindSetting((Settings x) => x.fxaaSettings.preset);
+
+            m_TaaJitterSpread = FindSetting((Settings x) => x.taaSettings.jitterSpread);
+            m_TaaSharpen = FindSetting((Settings x) => x.taaSettings.sharpen);
+            m_TaaStationaryBlending = FindSetting((Settings x) => x.taaSettings.stationaryBlending);
+            m_TaaMotionBlending = FindSetting((Settings x) => x.taaSettings.motionBlending);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            m_Method.intValue = EditorGUILayout.Popup("Method", m_Method.intValue, s_MethodNames);
+
+            if (m_Method.intValue == (int)Method.Fxaa)
+            {
+                EditorGUILayout.PropertyField(m_FxaaPreset);
+            }
+            else if (m_Method.intValue == (int)Method.Taa)
+            {
+                if (QualitySettings.antiAliasing > 1)
+                    EditorGUILayout.HelpBox("Temporal Anti-Aliasing doesn't work correctly when MSAA is enabled.", MessageType.Warning);
+
+                EditorGUILayout.LabelField("Jitter", EditorStyles.boldLabel);
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_TaaJitterSpread, EditorGUIHelper.GetContent("Spread"));
+                EditorGUI.indentLevel--;
+
+                EditorGUILayout.Space();
+
+                EditorGUILayout.LabelField("Blending", EditorStyles.boldLabel);
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_TaaStationaryBlending, EditorGUIHelper.GetContent("Stationary"));
+                EditorGUILayout.PropertyField(m_TaaMotionBlending, EditorGUIHelper.GetContent("Motion"));
+                EditorGUI.indentLevel--;
+
+                EditorGUILayout.Space();
+
+                EditorGUILayout.PropertyField(m_TaaSharpen);
+            }
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 2451939fe695c1a408ba688219837667
+timeCreated: 1467190133
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    using Settings = BloomModel.Settings;
+
+    [PostProcessingModelEditor(typeof(BloomModel))]
+    public class BloomModelEditor : PostProcessingModelEditor
+    {
+        struct BloomSettings
+        {
+            public SerializedProperty intensity;
+            public SerializedProperty threshold;
+            public SerializedProperty softKnee;
+            public SerializedProperty radius;
+            public SerializedProperty antiFlicker;
+        }
+
+        struct LensDirtSettings
+        {
+            public SerializedProperty texture;
+            public SerializedProperty intensity;
+        }
+
+        BloomSettings m_Bloom;
+        LensDirtSettings m_LensDirt;
+
+        public override void OnEnable()
+        {
+            m_Bloom = new BloomSettings
+            {
+                intensity = FindSetting((Settings x) => x.bloom.intensity),
+                threshold = FindSetting((Settings x) => x.bloom.threshold),
+                softKnee = FindSetting((Settings x) => x.bloom.softKnee),
+                radius = FindSetting((Settings x) => x.bloom.radius),
+                antiFlicker = FindSetting((Settings x) => x.bloom.antiFlicker)
+            };
+
+            m_LensDirt = new LensDirtSettings
+            {
+                texture = FindSetting((Settings x) => x.lensDirt.texture),
+                intensity = FindSetting((Settings x) => x.lensDirt.intensity)
+            };
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.Space();
+            PrepareGraph();
+            DrawGraph();
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(m_Bloom.intensity);
+            EditorGUILayout.PropertyField(m_Bloom.threshold, EditorGUIHelper.GetContent("Threshold (Gamma)"));
+            EditorGUILayout.PropertyField(m_Bloom.softKnee);
+            EditorGUILayout.PropertyField(m_Bloom.radius);
+            EditorGUILayout.PropertyField(m_Bloom.antiFlicker);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Dirt", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(m_LensDirt.texture);
+            EditorGUILayout.PropertyField(m_LensDirt.intensity);
+            EditorGUI.indentLevel--;
+        }
+
+        #region Graph
+
+        float m_GraphThreshold;
+        float m_GraphKnee;
+        float m_GraphIntensity;
+
+        // Number of vertices in curve
+        const int k_CurveResolution = 48;
+
+        // Vertex buffers
+        Vector3[] m_RectVertices = new Vector3[4];
+        Vector3[] m_LineVertices = new Vector3[2];
+        Vector3[] m_CurveVertices = new Vector3[k_CurveResolution];
+
+        Rect m_RectGraph;
+        float m_RangeX;
+        float m_RangeY;
+
+        float ResponseFunction(float x)
+        {
+            var rq = Mathf.Clamp(x - m_GraphThreshold + m_GraphKnee, 0, m_GraphKnee * 2);
+            rq = rq * rq * 0.25f / m_GraphKnee;
+            return Mathf.Max(rq, x - m_GraphThreshold) * m_GraphIntensity;
+        }
+
+        // Transform a point into the graph rect
+        Vector3 PointInRect(float x, float y)
+        {
+            x = Mathf.Lerp(m_RectGraph.x, m_RectGraph.xMax, x / m_RangeX);
+            y = Mathf.Lerp(m_RectGraph.yMax, m_RectGraph.y, y / m_RangeY);
+            return new Vector3(x, y, 0);
+        }
+
+        // Draw a line in the graph rect
+        void DrawLine(float x1, float y1, float x2, float y2, float grayscale)
+        {
+            m_LineVertices[0] = PointInRect(x1, y1);
+            m_LineVertices[1] = PointInRect(x2, y2);
+            Handles.color = Color.white * grayscale;
+            Handles.DrawAAPolyLine(2.0f, m_LineVertices);
+        }
+
+        // Draw a rect in the graph rect
+        void DrawRect(float x1, float y1, float x2, float y2, float fill, float line)
+        {
+            m_RectVertices[0] = PointInRect(x1, y1);
+            m_RectVertices[1] = PointInRect(x2, y1);
+            m_RectVertices[2] = PointInRect(x2, y2);
+            m_RectVertices[3] = PointInRect(x1, y2);
+
+            Handles.DrawSolidRectangleWithOutline(
+                m_RectVertices,
+                fill < 0 ? Color.clear : Color.white * fill,
+                line < 0 ? Color.clear : Color.white * line
+                );
+        }
+
+        // Update internal state with a given bloom instance
+        public void PrepareGraph()
+        {
+            var bloom = (BloomModel)target;
+            m_RangeX = 5f;
+            m_RangeY = 2f;
+
+            m_GraphThreshold = bloom.settings.bloom.thresholdLinear;
+            m_GraphKnee = bloom.settings.bloom.softKnee * m_GraphThreshold + 1e-5f;
+
+            // Intensity is capped to prevent sampling errors
+            m_GraphIntensity = Mathf.Min(bloom.settings.bloom.intensity, 10f);
+        }
+
+        // Draw the graph at the current position
+        public void DrawGraph()
+        {
+            using (new GUILayout.HorizontalScope())
+            {
+                GUILayout.Space(EditorGUI.indentLevel * 15f);
+                m_RectGraph = GUILayoutUtility.GetRect(128, 80);
+            }
+
+            // Background
+            DrawRect(0, 0, m_RangeX, m_RangeY, 0.1f, 0.4f);
+
+            // Soft-knee range
+            DrawRect(m_GraphThreshold - m_GraphKnee, 0, m_GraphThreshold + m_GraphKnee, m_RangeY, 0.25f, -1);
+
+            // Horizontal lines
+            for (var i = 1; i < m_RangeY; i++)
+                DrawLine(0, i, m_RangeX, i, 0.4f);
+
+            // Vertical lines
+            for (var i = 1; i < m_RangeX; i++)
+                DrawLine(i, 0, i, m_RangeY, 0.4f);
+
+            // Label
+            Handles.Label(
+                PointInRect(0, m_RangeY) + Vector3.right,
+                "Brightness Response (linear)", EditorStyles.miniLabel
+                );
+
+            // Threshold line
+            DrawLine(m_GraphThreshold, 0, m_GraphThreshold, m_RangeY, 0.6f);
+
+            // Response curve
+            var vcount = 0;
+            while (vcount < k_CurveResolution)
+            {
+                var x = m_RangeX * vcount / (k_CurveResolution - 1);
+                var y = ResponseFunction(x);
+                if (y < m_RangeY)
+                {
+                    m_CurveVertices[vcount++] = PointInRect(x, y);
+                }
+                else
+                {
+                    if (vcount > 1)
+                    {
+                        // Extend the last segment to the top edge of the rect.
+                        var v1 = m_CurveVertices[vcount - 2];
+                        var v2 = m_CurveVertices[vcount - 1];
+                        var clip = (m_RectGraph.y - v1.y) / (v2.y - v1.y);
+                        m_CurveVertices[vcount - 1] = v1 + (v2 - v1) * clip;
+                    }
+                    break;
+                }
+            }
+
+            if (vcount > 1)
+            {
+                Handles.color = Color.white * 0.9f;
+                Handles.DrawAAPolyLine(2.0f, vcount, m_CurveVertices);
+            }
+        }
+
+        #endregion
+    }
+}

+fileFormatVersion: 2
+guid: a95f3f10e7e437c49ade656f531b30d2
+timeCreated: 1467190133
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    using Mode = BuiltinDebugViewsModel.Mode;
+    using Settings = BuiltinDebugViewsModel.Settings;
+
+    [PostProcessingModelEditor(typeof(BuiltinDebugViewsModel), alwaysEnabled: true)]
+    public class BuiltinDebugViewsEditor : PostProcessingModelEditor
+    {
+        struct DepthSettings
+        {
+            public SerializedProperty scale;
+        }
+
+        struct MotionVectorsSettings
+        {
+            public SerializedProperty sourceOpacity;
+            public SerializedProperty motionImageOpacity;
+            public SerializedProperty motionImageAmplitude;
+            public SerializedProperty motionVectorsOpacity;
+            public SerializedProperty motionVectorsResolution;
+            public SerializedProperty motionVectorsAmplitude;
+        }
+
+        SerializedProperty m_Mode;
+        DepthSettings m_Depth;
+        MotionVectorsSettings m_MotionVectors;
+
+        public override void OnEnable()
+        {
+            m_Mode = FindSetting((Settings x) => x.mode);
+
+            m_Depth = new DepthSettings
+            {
+                scale = FindSetting((Settings x) => x.depth.scale)
+            };
+
+            m_MotionVectors = new MotionVectorsSettings
+            {
+                sourceOpacity = FindSetting((Settings x) => x.motionVectors.sourceOpacity),
+                motionImageOpacity = FindSetting((Settings x) => x.motionVectors.motionImageOpacity),
+                motionImageAmplitude = FindSetting((Settings x) => x.motionVectors.motionImageAmplitude),
+                motionVectorsOpacity = FindSetting((Settings x) => x.motionVectors.motionVectorsOpacity),
+                motionVectorsResolution = FindSetting((Settings x) => x.motionVectors.motionVectorsResolution),
+                motionVectorsAmplitude = FindSetting((Settings x) => x.motionVectors.motionVectorsAmplitude),
+            };
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.PropertyField(m_Mode);
+
+            int mode = m_Mode.intValue;
+
+            if (mode == (int)Mode.Depth)
+            {
+                EditorGUILayout.PropertyField(m_Depth.scale);
+            }
+            else if (mode == (int)Mode.MotionVectors)
+            {
+                EditorGUILayout.HelpBox("Switch to play mode to see motion vectors.", MessageType.Info);
+
+                EditorGUILayout.LabelField("Source Image", EditorStyles.boldLabel);
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_MotionVectors.sourceOpacity, EditorGUIHelper.GetContent("Opacity"));
+                EditorGUI.indentLevel--;
+
+                EditorGUILayout.Space();
+
+                EditorGUILayout.LabelField("Motion Vectors (overlay)", EditorStyles.boldLabel);
+                EditorGUI.indentLevel++;
+
+                if (m_MotionVectors.motionImageOpacity.floatValue > 0f)
+                    EditorGUILayout.HelpBox("Please keep opacity to 0 if you're subject to motion sickness.", MessageType.Warning);
+
+                EditorGUILayout.PropertyField(m_MotionVectors.motionImageOpacity, EditorGUIHelper.GetContent("Opacity"));
+                EditorGUILayout.PropertyField(m_MotionVectors.motionImageAmplitude, EditorGUIHelper.GetContent("Amplitude"));
+                EditorGUI.indentLevel--;
+
+                EditorGUILayout.Space();
+
+                EditorGUILayout.LabelField("Motion Vectors (arrows)", EditorStyles.boldLabel);
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_MotionVectors.motionVectorsOpacity, EditorGUIHelper.GetContent("Opacity"));
+                EditorGUILayout.PropertyField(m_MotionVectors.motionVectorsResolution, EditorGUIHelper.GetContent("Resolution"));
+                EditorGUILayout.PropertyField(m_MotionVectors.motionVectorsAmplitude, EditorGUIHelper.GetContent("Amplitude"));
+                EditorGUI.indentLevel--;
+            }
+            else
+            {
+                CheckActiveEffect(mode == (int)Mode.AmbientOcclusion && !profile.ambientOcclusion.enabled, "Ambient Occlusion");
+                CheckActiveEffect(mode == (int)Mode.FocusPlane && !profile.depthOfField.enabled, "Depth Of Field");
+                CheckActiveEffect(mode == (int)Mode.EyeAdaptation && !profile.eyeAdaptation.enabled, "Eye Adaptation");
+                CheckActiveEffect((mode == (int)Mode.LogLut || mode == (int)Mode.PreGradingLog) && !profile.colorGrading.enabled, "Color Grading");
+                CheckActiveEffect(mode == (int)Mode.UserLut && !profile.userLut.enabled, "User Lut");
+            }
+        }
+
+        void CheckActiveEffect(bool expr, string name)
+        {
+            if (expr)
+                EditorGUILayout.HelpBox(string.Format("{0} isn't enabled, the debug view won't work.", name), MessageType.Warning);
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 760ffebbef2ed644c87940a699eb7fe6
+timeCreated: 1468237035
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    [PostProcessingModelEditor(typeof(ChromaticAberrationModel))]
+    public class ChromaticaAberrationModelEditor : DefaultPostFxModelEditor
+    {
+    }
+}

+fileFormatVersion: 2
+guid: 8a713f71a0169794a915a081f6242f60
+timeCreated: 1467190133
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: c3e3bce1d5c900d4fa7aa0f2b21814cf
+timeCreated: 1467190133
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using System.Collections.Generic;
+
+namespace UnityEditor.PostProcessing
+{
+    public class DefaultPostFxModelEditor : PostProcessingModelEditor
+    {
+        List<SerializedProperty> m_Properties = new List<SerializedProperty>();
+
+        public override void OnEnable()
+        {
+            var iter = m_SettingsProperty.Copy().GetEnumerator();
+            while (iter.MoveNext())
+                m_Properties.Add(((SerializedProperty)iter.Current).Copy());
+        }
+
+        public override void OnInspectorGUI()
+        {
+            foreach (var property in m_Properties)
+                EditorGUILayout.PropertyField(property);
+        }
+    }
+}

+fileFormatVersion: 2
+guid: c15016a7fef58974f91a6a4d6b132d94
+timeCreated: 1467190133
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    using Settings = DepthOfFieldModel.Settings;
+
+    [PostProcessingModelEditor(typeof(DepthOfFieldModel))]
+    public class DepthOfFieldModelEditor : PostProcessingModelEditor
+    {
+        SerializedProperty m_FocusDistance;
+        SerializedProperty m_Aperture;
+        SerializedProperty m_FocalLength;
+        SerializedProperty m_UseCameraFov;
+        SerializedProperty m_KernelSize;
+
+        public override void OnEnable()
+        {
+            m_FocusDistance = FindSetting((Settings x) => x.focusDistance);
+            m_Aperture = FindSetting((Settings x) => x.aperture);
+            m_FocalLength = FindSetting((Settings x) => x.focalLength);
+            m_UseCameraFov = FindSetting((Settings x) => x.useCameraFov);
+            m_KernelSize = FindSetting((Settings x) => x.kernelSize);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.PropertyField(m_FocusDistance);
+            EditorGUILayout.PropertyField(m_Aperture, EditorGUIHelper.GetContent("Aperture (f-stop)"));
+
+            EditorGUILayout.PropertyField(m_UseCameraFov, EditorGUIHelper.GetContent("Use Camera FOV"));
+            if (!m_UseCameraFov.boolValue)
+                EditorGUILayout.PropertyField(m_FocalLength, EditorGUIHelper.GetContent("Focal Length (mm)"));
+
+            EditorGUILayout.PropertyField(m_KernelSize);
+        }
+    }
+}

+fileFormatVersion: 2
+guid: dc2f388440e9f8b4f8fc7bb43c01cc7d
+timeCreated: 1467190133
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    [PostProcessingModelEditor(typeof(DitheringModel))]
+    public class DitheringModelEditor : PostProcessingModelEditor
+    {
+        public override void OnInspectorGUI()
+        {
+            if (profile.grain.enabled && target.enabled)
+                EditorGUILayout.HelpBox("Grain is enabled, you probably don't need dithering !", MessageType.Warning);
+            else
+                EditorGUILayout.HelpBox("Nothing to configure !", MessageType.Info);
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 87377c86d84f49a4e912d37d28353e7f
+timeCreated: 1485179854
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    using Settings = EyeAdaptationModel.Settings;
+
+    [PostProcessingModelEditor(typeof(EyeAdaptationModel))]
+    public class EyeAdaptationModelEditor : PostProcessingModelEditor
+    {
+        SerializedProperty m_LowPercent;
+        SerializedProperty m_HighPercent;
+        SerializedProperty m_MinLuminance;
+        SerializedProperty m_MaxLuminance;
+        SerializedProperty m_KeyValue;
+        SerializedProperty m_DynamicKeyValue;
+        SerializedProperty m_AdaptationType;
+        SerializedProperty m_SpeedUp;
+        SerializedProperty m_SpeedDown;
+        SerializedProperty m_LogMin;
+        SerializedProperty m_LogMax;
+
+        public override void OnEnable()
+        {
+            m_LowPercent = FindSetting((Settings x) => x.lowPercent);
+            m_HighPercent = FindSetting((Settings x) => x.highPercent);
+            m_MinLuminance = FindSetting((Settings x) => x.minLuminance);
+            m_MaxLuminance = FindSetting((Settings x) => x.maxLuminance);
+            m_KeyValue = FindSetting((Settings x) => x.keyValue);
+            m_DynamicKeyValue = FindSetting((Settings x) => x.dynamicKeyValue);
+            m_AdaptationType = FindSetting((Settings x) => x.adaptationType);
+            m_SpeedUp = FindSetting((Settings x) => x.speedUp);
+            m_SpeedDown = FindSetting((Settings x) => x.speedDown);
+            m_LogMin = FindSetting((Settings x) => x.logMin);
+            m_LogMax = FindSetting((Settings x) => x.logMax);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (!GraphicsUtils.supportsDX11)
+                EditorGUILayout.HelpBox("This effect requires support for compute shaders. Enabling it won't do anything on unsupported platforms.", MessageType.Warning);
+
+            EditorGUILayout.LabelField("Luminosity range", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(m_LogMin, EditorGUIHelper.GetContent("Minimum (EV)"));
+            EditorGUILayout.PropertyField(m_LogMax, EditorGUIHelper.GetContent("Maximum (EV)"));
+            EditorGUI.indentLevel--;
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField("Auto exposure", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            float low = m_LowPercent.floatValue;
+            float high = m_HighPercent.floatValue;
+
+            EditorGUILayout.MinMaxSlider(EditorGUIHelper.GetContent("Histogram filtering|These values are the lower and upper percentages of the histogram that will be used to find a stable average luminance. Values outside of this range will be discarded and won't contribute to the average luminance."), ref low, ref high, 1f, 99f);
+
+            m_LowPercent.floatValue = low;
+            m_HighPercent.floatValue = high;
+
+            EditorGUILayout.PropertyField(m_MinLuminance, EditorGUIHelper.GetContent("Minimum (EV)"));
+            EditorGUILayout.PropertyField(m_MaxLuminance, EditorGUIHelper.GetContent("Maximum (EV)"));
+            EditorGUILayout.PropertyField(m_DynamicKeyValue);
+
+            if (!m_DynamicKeyValue.boolValue)
+                EditorGUILayout.PropertyField(m_KeyValue);
+
+            EditorGUI.indentLevel--;
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField("Adaptation", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+
+            EditorGUILayout.PropertyField(m_AdaptationType, EditorGUIHelper.GetContent("Type"));
+
+            if (m_AdaptationType.intValue == (int)EyeAdaptationModel.EyeAdaptationType.Progressive)
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_SpeedUp);
+                EditorGUILayout.PropertyField(m_SpeedDown);
+                EditorGUI.indentLevel--;
+            }
+
+            EditorGUI.indentLevel--;
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 489b5c785ba0f614d90c322fa0827216
+timeCreated: 1467190133
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    using Settings = FogModel.Settings;
+
+    [PostProcessingModelEditor(typeof(FogModel))]
+    public class FogModelEditor : PostProcessingModelEditor
+    {
+        SerializedProperty m_ExcludeSkybox;
+
+        public override void OnEnable()
+        {
+            m_ExcludeSkybox = FindSetting((Settings x) => x.excludeSkybox);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.HelpBox("This effect adds fog compatibility to the deferred rendering path; enabling it with the forward rendering path won't have any effect. Actual fog settings should be set in the Lighting panel.", MessageType.Info);
+            EditorGUILayout.PropertyField(m_ExcludeSkybox);
+            EditorGUI.indentLevel--;
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 44a64b44ec891d24b96ed84d958c3d4f
+timeCreated: 1487335049
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    using Settings = GrainModel.Settings;
+
+    [PostProcessingModelEditor(typeof(GrainModel))]
+    public class GrainModelEditor : PostProcessingModelEditor
+    {
+        SerializedProperty m_Colored;
+        SerializedProperty m_Intensity;
+        SerializedProperty m_Size;
+        SerializedProperty m_LuminanceContribution;
+
+        public override void OnEnable()
+        {
+            m_Colored = FindSetting((Settings x) => x.colored);
+            m_Intensity = FindSetting((Settings x) => x.intensity);
+            m_Size = FindSetting((Settings x) => x.size);
+            m_LuminanceContribution = FindSetting((Settings x) => x.luminanceContribution);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.PropertyField(m_Intensity);
+            EditorGUILayout.PropertyField(m_LuminanceContribution);
+            EditorGUILayout.PropertyField(m_Size);
+            EditorGUILayout.PropertyField(m_Colored);
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 8330694e2c90c284f81153ac83b3cb4a
+timeCreated: 1467190133
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    using Settings = MotionBlurModel.Settings;
+
+    [PostProcessingModelEditor(typeof(MotionBlurModel))]
+    public class MotionBlurModelEditor : PostProcessingModelEditor
+    {
+        SerializedProperty m_ShutterAngle;
+        SerializedProperty m_SampleCount;
+        SerializedProperty m_FrameBlending;
+
+        GraphDrawer m_GraphDrawer;
+
+        class GraphDrawer
+        {
+            const float k_Height = 32f;
+
+            Texture m_BlendingIcon;
+
+            GUIStyle m_LowerCenterStyle;
+            GUIStyle m_MiddleCenterStyle;
+
+            Color m_ColorDark;
+            Color m_ColorGray;
+
+            Vector3[] m_RectVertices = new Vector3[4];
+
+            public GraphDrawer()
+            {
+                m_BlendingIcon = EditorResources.Load<Texture>("UI/MotionBlendingIcon.png");
+
+                m_LowerCenterStyle = new GUIStyle(EditorStyles.miniLabel) { alignment = TextAnchor.LowerCenter };
+                m_MiddleCenterStyle = new GUIStyle(EditorStyles.miniLabel) { alignment = TextAnchor.MiddleCenter };
+
+                if (EditorGUIUtility.isProSkin)
+                {
+                    m_ColorDark = new Color(0.18f, 0.18f, 0.18f);
+                    m_ColorGray = new Color(0.43f, 0.43f, 0.43f);
+                }
+                else
+                {
+                    m_ColorDark = new Color(0.64f, 0.64f, 0.64f);
+                    m_ColorGray = new Color(0.92f, 0.92f, 0.92f);
+                }
+            }
+
+            public void DrawShutterGraph(float angle)
+            {
+                var center = GUILayoutUtility.GetRect(128, k_Height).center;
+
+                // Parameters used to make transitions smooth.
+                var zeroWhenOff = Mathf.Min(1f, angle * 0.1f);
+                var zeroWhenFull = Mathf.Min(1f, (360f - angle) * 0.02f);
+
+                // Shutter angle graph
+                var discCenter = center - new Vector2(k_Height * 2.4f, 0f);
+                // - exposure duration indicator
+                DrawDisc(discCenter, k_Height * Mathf.Lerp(0.5f, 0.38f, zeroWhenFull), m_ColorGray);
+                // - shutter disc
+                DrawDisc(discCenter, k_Height * 0.16f * zeroWhenFull, m_ColorDark);
+                // - shutter blade
+                DrawArc(discCenter, k_Height * 0.5f, 360f - angle, m_ColorDark);
+                // - shutter axis
+                DrawDisc(discCenter, zeroWhenOff, m_ColorGray);
+
+                // Shutter label (off/full)
+                var labelSize = new Vector2(k_Height, k_Height);
+                var labelOrigin = discCenter - labelSize * 0.5f;
+                var labelRect = new Rect(labelOrigin, labelSize);
+
+                if (Mathf.Approximately(angle, 0f))
+                    GUI.Label(labelRect, "Off", m_MiddleCenterStyle);
+                else if (Mathf.Approximately(angle, 360f))
+                    GUI.Label(labelRect, "Full", m_MiddleCenterStyle);
+
+                // Exposure time bar graph
+                var outerBarSize = new Vector2(4.75f, 0.5f) * k_Height;
+                var innerBarSize = outerBarSize;
+                innerBarSize.x *= angle / 360f;
+
+                var barCenter = center + new Vector2(k_Height * 0.9f, 0f);
+                var barOrigin = barCenter - outerBarSize * 0.5f;
+
+                DrawRect(barOrigin, outerBarSize, m_ColorDark);
+                DrawRect(barOrigin, innerBarSize, m_ColorGray);
+
+                var barText = "Exposure time = " + (angle / 3.6f).ToString("0") + "% of ΔT";
+                GUI.Label(new Rect(barOrigin, outerBarSize), barText, m_MiddleCenterStyle);
+            }
+
+            public void DrawBlendingGraph(float strength)
+            {
+                var center = GUILayoutUtility.GetRect(128, k_Height).center;
+
+                var iconSize = new Vector2(k_Height, k_Height);
+                var iconStride = new Vector2(k_Height * 0.9f, 0f);
+                var iconOrigin = center - iconSize * 0.5f - iconStride * 2f;
+
+                for (var i = 0; i < 5; i++)
+                {
+                    var weight = BlendingWeight(strength, i / 60f);
+                    var rect = new Rect(iconOrigin + iconStride * i, iconSize);
+
+                    var color = m_ColorGray;
+                    color.a = weight;
+
+                    GUI.color = color;
+                    GUI.Label(rect, m_BlendingIcon);
+
+                    GUI.color = Color.white;
+                    GUI.Label(rect, (weight * 100).ToString("0") + "%", m_LowerCenterStyle);
+                }
+                // EditorGUIUtility.isProSkin
+            }
+
+            // Weight function for multi frame blending
+            float BlendingWeight(float strength, float time)
+            {
+                if (strength > 0f || Mathf.Approximately(time, 0f))
+                    return Mathf.Exp(-time * Mathf.Lerp(80f, 10f, strength));
+
+                return 0;
+            }
+
+            // Draw a solid disc in the graph rect.
+            void DrawDisc(Vector2 center, float radius, Color fill)
+            {
+                Handles.color = fill;
+                Handles.DrawSolidDisc(center, Vector3.forward, radius);
+            }
+
+            // Draw an arc in the graph rect.
+            void DrawArc(Vector2 center, float radius, float angle, Color fill)
+            {
+                var start = new Vector2(
+                        -Mathf.Cos(Mathf.Deg2Rad * angle / 2f),
+                        Mathf.Sin(Mathf.Deg2Rad * angle / 2f)
+                        );
+
+                Handles.color = fill;
+                Handles.DrawSolidArc(center, Vector3.forward, start, angle, radius);
+            }
+
+            // Draw a rectangle in the graph rect.
+            void DrawRect(Vector2 origin, Vector2 size, Color color)
+            {
+                var p0 = origin;
+                var p1 = origin + size;
+
+                m_RectVertices[0] = p0;
+                m_RectVertices[1] = new Vector2(p1.x, p0.y);
+                m_RectVertices[2] = p1;
+                m_RectVertices[3] = new Vector2(p0.x, p1.y);
+
+                Handles.color = Color.white;
+                Handles.DrawSolidRectangleWithOutline(m_RectVertices, color, Color.clear);
+            }
+        }
+
+        public override void OnEnable()
+        {
+            m_ShutterAngle = FindSetting((Settings x) => x.shutterAngle);
+            m_SampleCount = FindSetting((Settings x) => x.sampleCount);
+            m_FrameBlending = FindSetting((Settings x) => x.frameBlending);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (m_GraphDrawer == null)
+                m_GraphDrawer = new GraphDrawer();
+
+            EditorGUILayout.LabelField("Shutter Speed Simulation", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            m_GraphDrawer.DrawShutterGraph(m_ShutterAngle.floatValue);
+            EditorGUILayout.PropertyField(m_ShutterAngle);
+            EditorGUILayout.PropertyField(m_SampleCount);
+            EditorGUI.indentLevel--;
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField("Multiple Frame Blending", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+
+            float fbValue = m_FrameBlending.floatValue;
+            m_GraphDrawer.DrawBlendingGraph(fbValue);
+            EditorGUILayout.PropertyField(m_FrameBlending);
+
+            if (fbValue > 0f)
+                EditorGUILayout.HelpBox("Multi-Frame Blending lowers precision of the final picture for optimization purposes.", MessageType.Info);
+
+
+            EditorGUI.indentLevel--;
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 870806eda355b5144879155e2ba37eb6
+timeCreated: 1468325681
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    using Settings = ScreenSpaceReflectionModel.Settings;
+
+    [PostProcessingModelEditor(typeof(ScreenSpaceReflectionModel))]
+    public class ScreenSpaceReflectionModelEditor : PostProcessingModelEditor
+    {
+        struct IntensitySettings
+        {
+            public SerializedProperty reflectionMultiplier;
+            public SerializedProperty fadeDistance;
+            public SerializedProperty fresnelFade;
+            public SerializedProperty fresnelFadePower;
+        }
+
+        struct ReflectionSettings
+        {
+            public SerializedProperty blendType;
+            public SerializedProperty reflectionQuality;
+            public SerializedProperty maxDistance;
+            public SerializedProperty iterationCount;
+            public SerializedProperty stepSize;
+            public SerializedProperty widthModifier;
+            public SerializedProperty reflectionBlur;
+            public SerializedProperty reflectBackfaces;
+        }
+
+        struct ScreenEdgeMask
+        {
+            public SerializedProperty intensity;
+        }
+
+        IntensitySettings m_Intensity;
+        ReflectionSettings m_Reflection;
+        ScreenEdgeMask m_ScreenEdgeMask;
+
+        public override void OnEnable()
+        {
+            m_Intensity = new IntensitySettings
+            {
+                reflectionMultiplier = FindSetting((Settings x) => x.intensity.reflectionMultiplier),
+                fadeDistance = FindSetting((Settings x) => x.intensity.fadeDistance),
+                fresnelFade = FindSetting((Settings x) => x.intensity.fresnelFade),
+                fresnelFadePower = FindSetting((Settings x) => x.intensity.fresnelFadePower)
+            };
+
+            m_Reflection = new ReflectionSettings
+            {
+                blendType = FindSetting((Settings x) => x.reflection.blendType),
+                reflectionQuality = FindSetting((Settings x) => x.reflection.reflectionQuality),
+                maxDistance = FindSetting((Settings x) => x.reflection.maxDistance),
+                iterationCount = FindSetting((Settings x) => x.reflection.iterationCount),
+                stepSize = FindSetting((Settings x) => x.reflection.stepSize),
+                widthModifier = FindSetting((Settings x) => x.reflection.widthModifier),
+                reflectionBlur = FindSetting((Settings x) => x.reflection.reflectionBlur),
+                reflectBackfaces = FindSetting((Settings x) => x.reflection.reflectBackfaces)
+            };
+
+            m_ScreenEdgeMask = new ScreenEdgeMask
+            {
+                intensity = FindSetting((Settings x) => x.screenEdgeMask.intensity)
+            };
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.HelpBox("This effect only works with the deferred rendering path.", MessageType.Info);
+
+            EditorGUILayout.LabelField("Reflection", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(m_Reflection.blendType);
+            EditorGUILayout.PropertyField(m_Reflection.reflectionQuality);
+            EditorGUILayout.PropertyField(m_Reflection.maxDistance);
+            EditorGUILayout.PropertyField(m_Reflection.iterationCount);
+            EditorGUILayout.PropertyField(m_Reflection.stepSize);
+            EditorGUILayout.PropertyField(m_Reflection.widthModifier);
+            EditorGUILayout.PropertyField(m_Reflection.reflectionBlur);
+            EditorGUILayout.PropertyField(m_Reflection.reflectBackfaces);
+            EditorGUI.indentLevel--;
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Intensity", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(m_Intensity.reflectionMultiplier);
+            EditorGUILayout.PropertyField(m_Intensity.fadeDistance);
+            EditorGUILayout.PropertyField(m_Intensity.fresnelFade);
+            EditorGUILayout.PropertyField(m_Intensity.fresnelFadePower);
+            EditorGUI.indentLevel--;
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Screen Edge Mask", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(m_ScreenEdgeMask.intensity);
+            EditorGUI.indentLevel--;
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 57bbe1f20eec7bb4d9bc90fc65ef381b
+timeCreated: 1467190133
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    using Settings = UserLutModel.Settings;
+
+    [PostProcessingModelEditor(typeof(UserLutModel))]
+    public class UserLutModelEditor : PostProcessingModelEditor
+    {
+        SerializedProperty m_Texture;
+        SerializedProperty m_Contribution;
+
+        public override void OnEnable()
+        {
+            m_Texture = FindSetting((Settings x) => x.lut);
+            m_Contribution = FindSetting((Settings x) => x.contribution);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            var lut = (target as UserLutModel).settings.lut;
+
+            // Checks import settings on the lut, offers to fix them if invalid
+            if (lut != null)
+            {
+                var importer = (TextureImporter)AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(lut));
+
+                if (importer != null) // Fails when using an internal texture
+                {
+#if UNITY_5_5_OR_NEWER
+                    bool valid = importer.anisoLevel == 0
+                        && importer.mipmapEnabled == false
+                        && importer.sRGBTexture == false
+                        && (importer.textureCompression == TextureImporterCompression.Uncompressed);
+#else
+                    bool valid = importer.anisoLevel == 0
+                        && importer.mipmapEnabled == false
+                        && importer.linearTexture == true
+                        && (importer.textureFormat == TextureImporterFormat.RGB24 || importer.textureFormat == TextureImporterFormat.AutomaticTruecolor);
+#endif
+
+                    if (!valid)
+                    {
+                        EditorGUILayout.HelpBox("Invalid LUT import settings.", MessageType.Warning);
+
+                        GUILayout.Space(-32);
+                        using (new EditorGUILayout.HorizontalScope())
+                        {
+                            GUILayout.FlexibleSpace();
+                            if (GUILayout.Button("Fix", GUILayout.Width(60)))
+                            {
+                                SetLUTImportSettings(importer);
+                                AssetDatabase.Refresh();
+                            }
+                            GUILayout.Space(8);
+                        }
+                        GUILayout.Space(11);
+                    }
+                }
+                else
+                {
+                    m_Texture.objectReferenceValue = null;
+                }
+            }
+
+            EditorGUILayout.PropertyField(m_Texture);
+            EditorGUILayout.PropertyField(m_Contribution);
+        }
+
+        void SetLUTImportSettings(TextureImporter importer)
+        {
+#if UNITY_5_5_OR_NEWER
+            importer.textureType = TextureImporterType.Default;
+            importer.sRGBTexture = false;
+            importer.textureCompression = TextureImporterCompression.Uncompressed;
+#else
+            importer.textureType = TextureImporterType.Advanced;
+            importer.linearTexture = true;
+            importer.textureFormat = TextureImporterFormat.RGB24;
+#endif
+            importer.anisoLevel = 0;
+            importer.mipmapEnabled = false;
+            importer.SaveAndReimport();
+        }
+    }
+}

+fileFormatVersion: 2
+guid: b235eb1c486b38c4fa06470234bbfd32
+timeCreated: 1466769818
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    using VignetteMode = VignetteModel.Mode;
+    using Settings = VignetteModel.Settings;
+
+    [PostProcessingModelEditor(typeof(VignetteModel))]
+    public class VignetteModelEditor : PostProcessingModelEditor
+    {
+        SerializedProperty m_Mode;
+        SerializedProperty m_Color;
+        SerializedProperty m_Center;
+        SerializedProperty m_Intensity;
+        SerializedProperty m_Smoothness;
+        SerializedProperty m_Roundness;
+        SerializedProperty m_Mask;
+        SerializedProperty m_Opacity;
+        SerializedProperty m_Rounded;
+
+        public override void OnEnable()
+        {
+            m_Mode = FindSetting((Settings x) => x.mode);
+            m_Color = FindSetting((Settings x) => x.color);
+            m_Center = FindSetting((Settings x) => x.center);
+            m_Intensity = FindSetting((Settings x) => x.intensity);
+            m_Smoothness = FindSetting((Settings x) => x.smoothness);
+            m_Roundness = FindSetting((Settings x) => x.roundness);
+            m_Mask = FindSetting((Settings x) => x.mask);
+            m_Opacity = FindSetting((Settings x) => x.opacity);
+            m_Rounded = FindSetting((Settings x) => x.rounded);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.PropertyField(m_Mode);
+            EditorGUILayout.PropertyField(m_Color);
+
+            if (m_Mode.intValue < (int)VignetteMode.Masked)
+            {
+                EditorGUILayout.PropertyField(m_Center);
+                EditorGUILayout.PropertyField(m_Intensity);
+                EditorGUILayout.PropertyField(m_Smoothness);
+                EditorGUILayout.PropertyField(m_Roundness);
+                EditorGUILayout.PropertyField(m_Rounded);
+            }
+            else
+            {
+                var mask = (target as VignetteModel).settings.mask;
+
+                // Checks import settings on the mask, offers to fix them if invalid
+                if (mask != null)
+                {
+                    var importer = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(mask)) as TextureImporter;
+
+                    if (importer != null) // Fails when using an internal texture
+                    {
+#if UNITY_5_5_OR_NEWER
+                        bool valid = importer.anisoLevel == 0
+                            && importer.mipmapEnabled == false
+                            //&& importer.alphaUsage == TextureImporterAlphaUsage.FromGrayScale
+                            && importer.alphaSource == TextureImporterAlphaSource.FromGrayScale
+                            && importer.textureCompression == TextureImporterCompression.Uncompressed
+                            && importer.wrapMode == TextureWrapMode.Clamp;
+#else
+                        bool valid = importer.anisoLevel == 0
+                            && importer.mipmapEnabled == false
+                            && importer.grayscaleToAlpha == true
+                            && importer.textureFormat == TextureImporterFormat.Alpha8
+                            && importer.wrapMode == TextureWrapMode.Clamp;
+#endif
+
+                        if (!valid)
+                        {
+                            EditorGUILayout.HelpBox("Invalid mask import settings.", MessageType.Warning);
+
+                            GUILayout.Space(-32);
+                            using (new EditorGUILayout.HorizontalScope())
+                            {
+                                GUILayout.FlexibleSpace();
+                                if (GUILayout.Button("Fix", GUILayout.Width(60)))
+                                {
+                                    SetMaskImportSettings(importer);
+                                    AssetDatabase.Refresh();
+                                }
+                                GUILayout.Space(8);
+                            }
+                            GUILayout.Space(11);
+                        }
+                    }
+                }
+
+                EditorGUILayout.PropertyField(m_Mask);
+                EditorGUILayout.PropertyField(m_Opacity);
+            }
+        }
+
+        void SetMaskImportSettings(TextureImporter importer)
+        {
+#if UNITY_5_5_OR_NEWER
+            importer.textureType = TextureImporterType.SingleChannel;
+            //importer.alphaUsage = TextureImporterAlphaUsage.FromGrayScale;
+            importer.alphaSource = TextureImporterAlphaSource.FromGrayScale;
+            importer.textureCompression = TextureImporterCompression.Uncompressed;
+#else
+            importer.textureType = TextureImporterType.Advanced;
+            importer.grayscaleToAlpha = true;
+            importer.textureFormat = TextureImporterFormat.Alpha8;
+#endif
+
+            importer.anisoLevel = 0;
+            importer.mipmapEnabled = false;
+            importer.wrapMode = TextureWrapMode.Clamp;
+            importer.SaveAndReimport();
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 745ad42620dabf04b94761acc86189ba
+timeCreated: 1467190133
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: e31078d57ac582944ad5e1e76a84f36a
+folderAsset: yes
+timeCreated: 1467188891
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: 4581c45ac4aa2264187087659a4cc252
+timeCreated: 1460031632
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: b1f878f3742072e40a280683573bd0ee
+timeCreated: 1460031643
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: 805119df0d94800418006c621cc99cc2
+timeCreated: 1461748750
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: 2d45bc7edb5916446b4fa1ae1b6f9065
+timeCreated: 1459957472
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using System;
+using System.Linq.Expressions;
+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    [CustomEditor(typeof(PostProcessingBehaviour))]
+    public class PostProcessingBehaviourEditor : Editor
+    {
+        SerializedProperty m_Profile;
+
+        public void OnEnable()
+        {
+            m_Profile = FindSetting((PostProcessingBehaviour x) => x.profile);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            EditorGUILayout.PropertyField(m_Profile);
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        SerializedProperty FindSetting<T, TValue>(Expression<Func<T, TValue>> expr)
+        {
+            return serializedObject.FindProperty(ReflectionUtils.GetFieldPath(expr));
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 0c12e797b02402246a52aa270c45059b
+timeCreated: 1476193645
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+using UnityEngine.PostProcessing;
+using UnityEditor.ProjectWindowCallback;
+using System.IO;
+
+namespace UnityEditor.PostProcessing
+{
+    public class PostProcessingFactory
+    {
+        [MenuItem("Assets/Create/Post-Processing Profile", priority = 201)]
+        static void MenuCreatePostProcessingProfile()
+        {
+            var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
+            ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance<DoCreatePostProcessingProfile>(), "New Post-Processing Profile.asset", icon, null);
+        }
+
+        internal static PostProcessingProfile CreatePostProcessingProfileAtPath(string path)
+        {
+            var profile = ScriptableObject.CreateInstance<PostProcessingProfile>();
+            profile.name = Path.GetFileName(path);
+            profile.fog.enabled = true;
+            AssetDatabase.CreateAsset(profile, path);
+            return profile;
+        }
+    }
+
+    class DoCreatePostProcessingProfile : EndNameEditAction
+    {
+        public override void Action(int instanceId, string pathName, string resourceFile)
+        {
+            PostProcessingProfile profile = PostProcessingFactory.CreatePostProcessingProfileAtPath(pathName);
+            ProjectWindowUtil.ShowCreatedAsset(profile);
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 0dfcadb180d67014cb0a6e18d6b11f90
+timeCreated: 1466586271
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+using UnityEngine.PostProcessing;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace UnityEditor.PostProcessing
+{
+    //[CanEditMultipleObjects]
+    [CustomEditor(typeof(PostProcessingProfile))]
+    public class PostProcessingInspector : Editor
+    {
+        static GUIContent s_PreviewTitle = new GUIContent("Monitors");
+
+        PostProcessingProfile m_ConcreteTarget
+        {
+            get { return target as PostProcessingProfile; }
+        }
+
+        int m_CurrentMonitorID
+        {
+            get { return m_ConcreteTarget.monitors.currentMonitorID; }
+            set { m_ConcreteTarget.monitors.currentMonitorID = value; }
+        }
+
+        List<PostProcessingMonitor> m_Monitors;
+        GUIContent[] m_MonitorNames;
+        Dictionary<PostProcessingModelEditor, PostProcessingModel> m_CustomEditors = new Dictionary<PostProcessingModelEditor, PostProcessingModel>();
+
+        public bool IsInteractivePreviewOpened { get; private set; }
+
+        void OnEnable()
+        {
+            if (target == null)
+                return;
+
+            // Aggregate custom post-fx editors
+            var assembly = Assembly.GetAssembly(typeof(PostProcessingInspector));
+
+            var editorTypes = assembly.GetTypes()
+                .Where(x => x.IsDefined(typeof(PostProcessingModelEditorAttribute), false));
+
+            var customEditors = new Dictionary<Type, PostProcessingModelEditor>();
+            foreach (var editor in editorTypes)
+            {
+                var attr = (PostProcessingModelEditorAttribute)editor.GetCustomAttributes(typeof(PostProcessingModelEditorAttribute), false)[0];
+                var effectType = attr.type;
+                var alwaysEnabled = attr.alwaysEnabled;
+
+                var editorInst = (PostProcessingModelEditor)Activator.CreateInstance(editor);
+                editorInst.alwaysEnabled = alwaysEnabled;
+                editorInst.profile = target as PostProcessingProfile;
+                editorInst.inspector = this;
+                customEditors.Add(effectType, editorInst);
+            }
+
+            // ... and corresponding models
+            var baseType = target.GetType();
+            var property = serializedObject.GetIterator();
+
+            while (property.Next(true))
+            {
+                if (!property.hasChildren)
+                    continue;
+
+                var type = baseType;
+                var srcObject = ReflectionUtils.GetFieldValueFromPath(serializedObject.targetObject, ref type, property.propertyPath);
+
+                if (srcObject == null)
+                    continue;
+
+                PostProcessingModelEditor editor;
+                if (customEditors.TryGetValue(type, out editor))
+                {
+                    var effect = (PostProcessingModel)srcObject;
+
+                    if (editor.alwaysEnabled)
+                        effect.enabled = editor.alwaysEnabled;
+
+                    m_CustomEditors.Add(editor, effect);
+                    editor.target = effect;
+                    editor.serializedProperty = property.Copy();
+                    editor.OnPreEnable();
+                }
+            }
+
+            // Prepare monitors
+            m_Monitors = new List<PostProcessingMonitor>();
+
+            var monitors = new List<PostProcessingMonitor>
+            {
+                new HistogramMonitor(),
+                new WaveformMonitor(),
+                new ParadeMonitor(),
+                new VectorscopeMonitor()
+            };
+
+            var monitorNames = new List<GUIContent>();
+
+            foreach (var monitor in monitors)
+            {
+                if (monitor.IsSupported())
+                {
+                    monitor.Init(m_ConcreteTarget.monitors, this);
+                    m_Monitors.Add(monitor);
+                    monitorNames.Add(monitor.GetMonitorTitle());
+                }
+            }
+
+            m_MonitorNames = monitorNames.ToArray();
+
+            if (m_Monitors.Count > 0)
+                m_ConcreteTarget.monitors.onFrameEndEditorOnly = OnFrameEnd;
+        }
+
+        void OnDisable()
+        {
+            if (m_CustomEditors != null)
+            {
+                foreach (var editor in m_CustomEditors.Keys)
+                    editor.OnDisable();
+
+                m_CustomEditors.Clear();
+            }
+
+            if (m_Monitors != null)
+            {
+                foreach (var monitor in m_Monitors)
+                    monitor.Dispose();
+
+                m_Monitors.Clear();
+            }
+
+            if (m_ConcreteTarget != null)
+                m_ConcreteTarget.monitors.onFrameEndEditorOnly = null;
+        }
+
+        void OnFrameEnd(RenderTexture source)
+        {
+            if (!IsInteractivePreviewOpened)
+                return;
+
+            if (m_CurrentMonitorID < m_Monitors.Count)
+                m_Monitors[m_CurrentMonitorID].OnFrameData(source);
+
+            IsInteractivePreviewOpened = false;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            // Handles undo/redo events first (before they get used by the editors' widgets)
+            var e = Event.current;
+            if (e.type == EventType.ValidateCommand && e.commandName == "UndoRedoPerformed")
+            {
+                foreach (var editor in m_CustomEditors)
+                    editor.Value.OnValidate();
+            }
+
+            if (!m_ConcreteTarget.debugViews.IsModeActive(BuiltinDebugViewsModel.Mode.None))
+                EditorGUILayout.HelpBox("A debug view is currently enabled. Changes done to an effect might not be visible.", MessageType.Info);
+
+            foreach (var editor in m_CustomEditors)
+            {
+                EditorGUI.BeginChangeCheck();
+
+                editor.Key.OnGUI();
+
+                if (EditorGUI.EndChangeCheck())
+                    editor.Value.OnValidate();
+            }
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        public override GUIContent GetPreviewTitle()
+        {
+            return s_PreviewTitle;
+        }
+
+        public override bool HasPreviewGUI()
+        {
+            return GraphicsUtils.supportsDX11 && m_Monitors.Count > 0;
+        }
+
+        public override void OnPreviewSettings()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                if (m_CurrentMonitorID < m_Monitors.Count)
+                    m_Monitors[m_CurrentMonitorID].OnMonitorSettings();
+
+                GUILayout.Space(5);
+                m_CurrentMonitorID = EditorGUILayout.Popup(m_CurrentMonitorID, m_MonitorNames, FxStyles.preDropdown, GUILayout.MaxWidth(100f));
+            }
+        }
+
+        public override void OnInteractivePreviewGUI(Rect r, GUIStyle background)
+        {
+            IsInteractivePreviewOpened = true;
+
+            if (m_CurrentMonitorID < m_Monitors.Count)
+                m_Monitors[m_CurrentMonitorID].OnMonitorGUI(r);
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 27fa95984763d9d47bbad59e7fdb66fe
+timeCreated: 1467188923
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+using UnityEngine.PostProcessing;
+using System;
+using System.Linq.Expressions;
+
+namespace UnityEditor.PostProcessing
+{
+    public class PostProcessingModelEditor
+    {
+        public PostProcessingModel target { get; internal set; }
+        public SerializedProperty serializedProperty { get; internal set; }
+
+        protected SerializedProperty m_SettingsProperty;
+        protected SerializedProperty m_EnabledProperty;
+
+        internal bool alwaysEnabled = false;
+        internal PostProcessingProfile profile;
+        internal PostProcessingInspector inspector;
+
+        internal void OnPreEnable()
+        {
+            m_SettingsProperty = serializedProperty.FindPropertyRelative("m_Settings");
+            m_EnabledProperty = serializedProperty.FindPropertyRelative("m_Enabled");
+
+            OnEnable();
+        }
+
+        public virtual void OnEnable()
+        {}
+
+        public virtual void OnDisable()
+        {}
+
+        internal void OnGUI()
+        {
+            GUILayout.Space(5);
+
+            var display = alwaysEnabled
+                ? EditorGUIHelper.Header(serializedProperty.displayName, m_SettingsProperty, Reset)
+                : EditorGUIHelper.Header(serializedProperty.displayName, m_SettingsProperty, m_EnabledProperty, Reset);
+
+            if (display)
+            {
+                EditorGUI.indentLevel++;
+                using (new EditorGUI.DisabledGroupScope(!m_EnabledProperty.boolValue))
+                {
+                    OnInspectorGUI();
+                }
+                EditorGUI.indentLevel--;
+            }
+        }
+
+        void Reset()
+        {
+            var obj = serializedProperty.serializedObject;
+            Undo.RecordObject(obj.targetObject, "Reset");
+            target.Reset();
+            EditorUtility.SetDirty(obj.targetObject);
+        }
+
+        public virtual void OnInspectorGUI()
+        {}
+
+        public void Repaint()
+        {
+            inspector.Repaint();
+        }
+
+        protected SerializedProperty FindSetting<T, TValue>(Expression<Func<T, TValue>> expr)
+        {
+            return m_SettingsProperty.FindPropertyRelative(ReflectionUtils.GetFieldPath(expr));
+        }
+
+        protected SerializedProperty FindSetting<T, TValue>(SerializedProperty prop, Expression<Func<T, TValue>> expr)
+        {
+            return prop.FindPropertyRelative(ReflectionUtils.GetFieldPath(expr));
+        }
+    }
+}

+fileFormatVersion: 2
+guid: afe296d4ede60a0479734dc8c7df82c2
+timeCreated: 1467188923
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using System;
+using UnityEngine;
+
+namespace UnityEditor.PostProcessing
+{
+    using MonitorSettings = UnityEngine.PostProcessing.PostProcessingProfile.MonitorSettings;
+
+    public abstract class PostProcessingMonitor : IDisposable
+    {
+        protected MonitorSettings m_MonitorSettings;
+        protected PostProcessingInspector m_BaseEditor;
+
+        public void Init(MonitorSettings monitorSettings, PostProcessingInspector baseEditor)
+        {
+            m_MonitorSettings = monitorSettings;
+            m_BaseEditor = baseEditor;
+        }
+
+        public abstract bool IsSupported();
+
+        public abstract GUIContent GetMonitorTitle();
+
+        public virtual void OnMonitorSettings()
+        {}
+
+        public abstract void OnMonitorGUI(Rect r);
+
+        public virtual void OnFrameData(RenderTexture source)
+        {}
+
+        public virtual void Dispose()
+        {}
+    }
+}

+fileFormatVersion: 2
+guid: 801186e9e649457469bcddd8ee391c71
+timeCreated: 1467188912
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: ced92f1cc2085ae48acacc79a2b8e196
+folderAsset: yes
+timeCreated: 1467189428
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    [CustomPropertyDrawer(typeof(GetSetAttribute))]
+    sealed class GetSetDrawer : PropertyDrawer
+    {
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            var attribute = (GetSetAttribute)base.attribute;
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.PropertyField(position, property, label);
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                attribute.dirty = true;
+            }
+            else if (attribute.dirty)
+            {
+                var parent = ReflectionUtils.GetParentObject(property.propertyPath, property.serializedObject.targetObject);
+
+                var type = parent.GetType();
+                var info = type.GetProperty(attribute.name);
+
+                if (info == null)
+                    Debug.LogError("Invalid property name \"" + attribute.name + "\"");
+                else
+                    info.SetValue(parent, fieldInfo.GetValue(parent), null);
+
+                attribute.dirty = false;
+            }
+        }
+    }
+}

+fileFormatVersion: 2
+guid: e1a43b92f2bbd914ca2e6b4c6a5dba48
+timeCreated: 1460383963
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    [CustomPropertyDrawer(typeof(MinAttribute))]
+    sealed class MinDrawer : PropertyDrawer
+    {
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            MinAttribute attribute = (MinAttribute)base.attribute;
+
+            if (property.propertyType == SerializedPropertyType.Integer)
+            {
+                int v = EditorGUI.IntField(position, label, property.intValue);
+                property.intValue = (int)Mathf.Max(v, attribute.min);
+            }
+            else if (property.propertyType == SerializedPropertyType.Float)
+            {
+                float v = EditorGUI.FloatField(position, label, property.floatValue);
+                property.floatValue = Mathf.Max(v, attribute.min);
+            }
+            else
+            {
+                EditorGUI.LabelField(position, label.text, "Use Min with float or int.");
+            }
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 8995f52f410f0fb4cb1bdaa71a16e04e
+timeCreated: 1467364278
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using System.Collections.Generic;
+using System.Reflection;
+using UnityEngine;
+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    [CustomPropertyDrawer(typeof(TrackballGroupAttribute))]
+    sealed class TrackballGroupDrawer : PropertyDrawer
+    {
+        static Material s_Material;
+
+        const int k_MinWheelSize = 80;
+        const int k_MaxWheelSize = 256;
+
+        bool m_ResetState;
+
+        // Cached trackball computation methods (for speed reasons)
+        static Dictionary<string, MethodInfo> m_TrackballMethods = new Dictionary<string, MethodInfo>();
+
+        internal static int m_Size
+        {
+            get
+            {
+                int size = Mathf.FloorToInt(EditorGUIUtility.currentViewWidth / 3f) - 18;
+                size = Mathf.Clamp(size, k_MinWheelSize, k_MaxWheelSize);
+                return size;
+            }
+        }
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            if (s_Material == null)
+                s_Material = new Material(Shader.Find("Hidden/Post FX/UI/Trackball")) { hideFlags = HideFlags.HideAndDontSave };
+
+            position = new Rect(position.x, position.y, position.width / 3f, position.height);
+            int size = m_Size;
+            position.x += 5f;
+
+            var enumerator = property.GetEnumerator();
+            while (enumerator.MoveNext())
+            {
+                var prop = enumerator.Current as SerializedProperty;
+                if (prop == null || prop.propertyType != SerializedPropertyType.Color)
+                    continue;
+
+                OnWheelGUI(position, size, prop.Copy());
+                position.x += position.width;
+            }
+        }
+
+        void OnWheelGUI(Rect position, int size, SerializedProperty property)
+        {
+            if (Event.current.type == EventType.Layout)
+                return;
+
+            var value = property.colorValue;
+            float offset = value.a;
+
+            var wheelDrawArea = position;
+            wheelDrawArea.height = size;
+
+            if (wheelDrawArea.width > wheelDrawArea.height)
+            {
+                wheelDrawArea.x += (wheelDrawArea.width - wheelDrawArea.height) / 2.0f;
+                wheelDrawArea.width = position.height;
+            }
+
+            wheelDrawArea.width = wheelDrawArea.height;
+
+            float hsize = size / 2f;
+            float radius = 0.38f * size;
+            Vector3 hsv;
+            Color.RGBToHSV(value, out hsv.x, out hsv.y, out hsv.z);
+
+            if (Event.current.type == EventType.Repaint)
+            {
+                float scale = EditorGUIUtility.pixelsPerPoint;
+
+                // Wheel texture
+                var oldRT = RenderTexture.active;
+                var rt = RenderTexture.GetTemporary((int)(size * scale), (int)(size * scale), 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
+                s_Material.SetFloat("_Offset", offset);
+                s_Material.SetFloat("_DisabledState", GUI.enabled ? 1f : 0.5f);
+                s_Material.SetVector("_Resolution", new Vector2(size * scale, size * scale / 2f));
+                Graphics.Blit(null, rt, s_Material, EditorGUIUtility.isProSkin ? 0 : 1);
+                RenderTexture.active = oldRT;
+
+                GUI.DrawTexture(wheelDrawArea, rt);
+                RenderTexture.ReleaseTemporary(rt);
+
+                // Thumb
+                var thumbPos = Vector2.zero;
+                float theta = hsv.x * (Mathf.PI * 2f);
+                float len = hsv.y * radius;
+                thumbPos.x = Mathf.Cos(theta + (Mathf.PI / 2f));
+                thumbPos.y = Mathf.Sin(theta - (Mathf.PI / 2f));
+                thumbPos *= len;
+                var thumbSize = FxStyles.wheelThumbSize;
+                var thumbSizeH = thumbSize / 2f;
+                FxStyles.wheelThumb.Draw(new Rect(wheelDrawArea.x + hsize + thumbPos.x - thumbSizeH.x, wheelDrawArea.y + hsize + thumbPos.y - thumbSizeH.y, thumbSize.x, thumbSize.y), false, false, false, false);
+            }
+
+            var bounds = wheelDrawArea;
+            bounds.x += hsize - radius;
+            bounds.y += hsize - radius;
+            bounds.width = bounds.height = radius * 2f;
+            hsv = GetInput(bounds, hsv, radius);
+            value = Color.HSVToRGB(hsv.x, hsv.y, 1f);
+            value.a = offset;
+
+            // Luminosity booster
+            position = wheelDrawArea;
+            float oldX = position.x;
+            float oldW = position.width;
+            position.y += position.height + 4f;
+            position.x += (position.width - (position.width * 0.75f)) / 2f;
+            position.width = position.width * 0.75f;
+            position.height = EditorGUIUtility.singleLineHeight;
+            value.a = GUI.HorizontalSlider(position, value.a, -1f, 1f);
+
+            // Advanced controls
+            var data = Vector3.zero;
+
+            if (TryGetDisplayValue(value, property, out data))
+            {
+                position.x = oldX;
+                position.y += position.height;
+                position.width = oldW / 3f;
+
+                using (new EditorGUI.DisabledGroupScope(true))
+                {
+                    GUI.Label(position, data.x.ToString("F2"), EditorStyles.centeredGreyMiniLabel);
+                    position.x += position.width;
+                    GUI.Label(position, data.y.ToString("F2"), EditorStyles.centeredGreyMiniLabel);
+                    position.x += position.width;
+                    GUI.Label(position, data.z.ToString("F2"), EditorStyles.centeredGreyMiniLabel);
+                    position.x += position.width;
+                }
+            }
+
+            // Title
+            position.x = oldX;
+            position.y += position.height;
+            position.width = oldW;
+            GUI.Label(position, property.displayName, EditorStyles.centeredGreyMiniLabel);
+
+            if (m_ResetState)
+            {
+                value = Color.clear;
+                m_ResetState = false;
+            }
+
+            property.colorValue = value;
+        }
+
+        bool TryGetDisplayValue(Color color, SerializedProperty property, out Vector3 output)
+        {
+            output = Vector3.zero;
+            MethodInfo method;
+
+            if (!m_TrackballMethods.TryGetValue(property.name, out method))
+            {
+                var field = ReflectionUtils.GetFieldInfoFromPath(property.serializedObject.targetObject, property.propertyPath);
+
+                if (!field.IsDefined(typeof(TrackballAttribute), false))
+                    return false;
+
+                var attr = (TrackballAttribute)field.GetCustomAttributes(typeof(TrackballAttribute), false)[0];
+                const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
+                method = typeof(ColorGradingComponent).GetMethod(attr.method, flags);
+                m_TrackballMethods.Add(property.name, method);
+            }
+
+            if (method == null)
+                return false;
+
+            output = (Vector3)method.Invoke(property.serializedObject.targetObject, new object[] { color });
+            return true;
+        }
+
+        static readonly int k_ThumbHash = "colorWheelThumb".GetHashCode();
+
+        Vector3 GetInput(Rect bounds, Vector3 hsv, float radius)
+        {
+            var e = Event.current;
+            var id = GUIUtility.GetControlID(k_ThumbHash, FocusType.Passive, bounds);
+
+            var mousePos = e.mousePosition;
+            var relativePos = mousePos - new Vector2(bounds.x, bounds.y);
+
+            if (e.type == EventType.MouseDown && GUIUtility.hotControl == 0 && bounds.Contains(mousePos))
+            {
+                if (e.button == 0)
+                {
+                    var center = new Vector2(bounds.x + radius, bounds.y + radius);
+                    float dist = Vector2.Distance(center, mousePos);
+
+                    if (dist <= radius)
+                    {
+                        e.Use();
+                        GetWheelHueSaturation(relativePos.x, relativePos.y, radius, out hsv.x, out hsv.y);
+                        GUIUtility.hotControl = id;
+                        GUI.changed = true;
+                    }
+                }
+                else if (e.button == 1)
+                {
+                    e.Use();
+                    GUI.changed = true;
+                    m_ResetState = true;
+                }
+            }
+            else if (e.type == EventType.MouseDrag && e.button == 0 && GUIUtility.hotControl == id)
+            {
+                e.Use();
+                GUI.changed = true;
+                GetWheelHueSaturation(relativePos.x, relativePos.y, radius, out hsv.x, out hsv.y);
+            }
+            else if (e.rawType == EventType.MouseUp && e.button == 0 && GUIUtility.hotControl == id)
+            {
+                e.Use();
+                GUIUtility.hotControl = 0;
+            }
+
+            return hsv;
+        }
+
+        void GetWheelHueSaturation(float x, float y, float radius, out float hue, out float saturation)
+        {
+            float dx = (x - radius) / radius;
+            float dy = (y - radius) / radius;
+            float d = Mathf.Sqrt(dx * dx + dy * dy);
+            hue = Mathf.Atan2(dx, -dy);
+            hue = 1f - ((hue > 0) ? hue : (Mathf.PI * 2f) + hue) / (Mathf.PI * 2f);
+            saturation = Mathf.Clamp01(d);
+        }
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            return m_Size + 4f * 2f + EditorGUIUtility.singleLineHeight * 3f;
+        }
+    }
+}

+fileFormatVersion: 2
+guid: a668d493c5ed56d448b53c19b2c3dfd2
+timeCreated: 1460563239
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: b52c69ccefdae7545bfb4d0bf9b7df71
+folderAsset: yes
+timeCreated: 1467189428
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+fileFormatVersion: 2
+guid: afb349ef0bffd144db2bdd25630f648e
+timeCreated: 1472650750
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using System;
+using UnityEngine;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Reflection;
+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    public static class EditorGUIHelper
+    {
+        static EditorGUIHelper()
+        {
+            s_GUIContentCache = new Dictionary<string, GUIContent>();
+        }
+
+        #region GUIContent caching
+
+        static Dictionary<string, GUIContent> s_GUIContentCache;
+
+        public static GUIContent GetContent(string textAndTooltip)
+        {
+            if (string.IsNullOrEmpty(textAndTooltip))
+                return GUIContent.none;
+
+            GUIContent content;
+
+            if (!s_GUIContentCache.TryGetValue(textAndTooltip, out content))
+            {
+                var s = textAndTooltip.Split('|');
+                content = new GUIContent(s[0]);
+
+                if (s.Length > 1 && !string.IsNullOrEmpty(s[1]))
+                    content.tooltip = s[1];
+
+                s_GUIContentCache.Add(textAndTooltip, content);
+            }
+
+            return content;
+        }
+
+        #endregion
+
+        public static bool Header(string title, SerializedProperty group, Action resetAction)
+        {
+            var rect = GUILayoutUtility.GetRect(16f, 22f, FxStyles.header);
+            GUI.Box(rect, title, FxStyles.header);
+
+            var display = group == null || group.isExpanded;
+
+            var foldoutRect = new Rect(rect.x + 4f, rect.y + 2f, 13f, 13f);
+            var e = Event.current;
+
+            var popupRect = new Rect(rect.x + rect.width - FxStyles.paneOptionsIcon.width - 5f, rect.y + FxStyles.paneOptionsIcon.height / 2f + 1f, FxStyles.paneOptionsIcon.width, FxStyles.paneOptionsIcon.height);
+            GUI.DrawTexture(popupRect, FxStyles.paneOptionsIcon);
+
+            if (e.type == EventType.Repaint)
+                FxStyles.headerFoldout.Draw(foldoutRect, false, false, display, false);
+
+            if (e.type == EventType.MouseDown)
+            {
+                if (popupRect.Contains(e.mousePosition))
+                {
+                    var popup = new GenericMenu();
+                    popup.AddItem(GetContent("Reset"), false, () => resetAction());
+                    popup.AddSeparator(string.Empty);
+                    popup.AddItem(GetContent("Copy Settings"), false, () => CopySettings(group));
+
+                    if (CanPaste(group))
+                        popup.AddItem(GetContent("Paste Settings"), false, () => PasteSettings(group));
+                    else
+                        popup.AddDisabledItem(GetContent("Paste Settings"));
+
+                    popup.ShowAsContext();
+                }
+                else if (rect.Contains(e.mousePosition) && group != null)
+                {
+                    display = !display;
+
+                    if (group != null)
+                        group.isExpanded = !group.isExpanded;
+
+                    e.Use();
+                }
+            }
+
+            return display;
+        }
+
+        public static bool Header(string title, SerializedProperty group, SerializedProperty enabledField, Action resetAction)
+        {
+            var field = ReflectionUtils.GetFieldInfoFromPath(enabledField.serializedObject.targetObject, enabledField.propertyPath);
+            object parent = null;
+            PropertyInfo prop = null;
+
+            if (field != null && field.IsDefined(typeof(GetSetAttribute), false))
+            {
+                var attr = (GetSetAttribute)field.GetCustomAttributes(typeof(GetSetAttribute), false)[0];
+                parent = ReflectionUtils.GetParentObject(enabledField.propertyPath, enabledField.serializedObject.targetObject);
+                prop = parent.GetType().GetProperty(attr.name);
+            }
+
+            var display = group == null || group.isExpanded;
+            var enabled = enabledField.boolValue;
+
+            var rect = GUILayoutUtility.GetRect(16f, 22f, FxStyles.header);
+            GUI.Box(rect, title, FxStyles.header);
+
+            var toggleRect = new Rect(rect.x + 4f, rect.y + 4f, 13f, 13f);
+            var e = Event.current;
+
+            var popupRect = new Rect(rect.x + rect.width - FxStyles.paneOptionsIcon.width - 5f, rect.y + FxStyles.paneOptionsIcon.height / 2f + 1f, FxStyles.paneOptionsIcon.width, FxStyles.paneOptionsIcon.height);
+            GUI.DrawTexture(popupRect, FxStyles.paneOptionsIcon);
+
+            if (e.type == EventType.Repaint)
+                FxStyles.headerCheckbox.Draw(toggleRect, false, false, enabled, false);
+
+            if (e.type == EventType.MouseDown)
+            {
+                const float kOffset = 2f;
+                toggleRect.x -= kOffset;
+                toggleRect.y -= kOffset;
+                toggleRect.width += kOffset * 2f;
+                toggleRect.height += kOffset * 2f;
+
+                if (toggleRect.Contains(e.mousePosition))
+                {
+                    enabledField.boolValue = !enabledField.boolValue;
+
+                    if (prop != null)
+                        prop.SetValue(parent, enabledField.boolValue, null);
+
+                    e.Use();
+                }
+                else if (popupRect.Contains(e.mousePosition))
+                {
+                    var popup = new GenericMenu();
+                    popup.AddItem(GetContent("Reset"), false, () => resetAction());
+                    popup.AddSeparator(string.Empty);
+                    popup.AddItem(GetContent("Copy Settings"), false, () => CopySettings(group));
+
+                    if (CanPaste(group))
+                        popup.AddItem(GetContent("Paste Settings"), false, () => PasteSettings(group));
+                    else
+                        popup.AddDisabledItem(GetContent("Paste Settings"));
+
+                    popup.ShowAsContext();
+                }
+                else if (rect.Contains(e.mousePosition) && group != null)
+                {
+                    display = !display;
+                    group.isExpanded = !group.isExpanded;
+                    e.Use();
+                }
+            }
+
+            return display;
+        }
+
+        static void CopySettings(SerializedProperty settings)
+        {
+            var t = typeof(PostProcessingProfile);
+            var settingsStruct = ReflectionUtils.GetFieldValueFromPath(settings.serializedObject.targetObject, ref t, settings.propertyPath);
+            var serializedString = t.ToString() + '|' + JsonUtility.ToJson(settingsStruct);
+            EditorGUIUtility.systemCopyBuffer = serializedString;
+        }
+
+        static bool CanPaste(SerializedProperty settings)
+        {
+            var data = EditorGUIUtility.systemCopyBuffer;
+
+            if (string.IsNullOrEmpty(data))
+                return false;
+
+            var parts = data.Split('|');
+
+            if (string.IsNullOrEmpty(parts[0]))
+                return false;
+
+            var field = ReflectionUtils.GetFieldInfoFromPath(settings.serializedObject.targetObject, settings.propertyPath);
+            return parts[0] == field.FieldType.ToString();
+        }
+
+        static void PasteSettings(SerializedProperty settings)
+        {
+            Undo.RecordObject(settings.serializedObject.targetObject, "Paste effect settings");
+            var field = ReflectionUtils.GetFieldInfoFromPath(settings.serializedObject.targetObject, settings.propertyPath);
+            var json = EditorGUIUtility.systemCopyBuffer.Substring(field.FieldType.ToString().Length + 1);
+            var obj = JsonUtility.FromJson(json, field.FieldType);
+            var parent = ReflectionUtils.GetParentObject(settings.propertyPath, settings.serializedObject.targetObject);
+            field.SetValue(parent, obj, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, CultureInfo.CurrentCulture);
+        }
+    }
+}

+fileFormatVersion: 2
+guid: 7226e17fa48c86148a3d15584e21b4cb
+timeCreated: 1460477750
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+
+namespace UnityEditor.PostProcessing
+{
+    using UnityObject = Object;
+
+    static class EditorResources
+    {
+        static string m_EditorResourcesPath = string.Empty;
+
+        internal static string editorResourcesPath
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(m_EditorResourcesPath))
+                {
+                    string path;
+
+                    if (SearchForEditorResourcesPath(out path))
+                        m_EditorResourcesPath = path;
+                    else
+                        Debug.LogError("Unable to locate editor resources. Make sure the PostProcessing package has been installed correctly.");
+                }
+
+                return m_EditorResourcesPath;
+            }
+        }
+
+        internal static T Load<T>(string name)
+            where T : UnityObject
+        {
+            return AssetDatabase.LoadAssetAtPath<T>(editorResourcesPath + name);
+        }
+
+        static bool SearchForEditorResourcesPath(out string path)
+        {
+            path = string.Empty;
+
+            string searchStr = "/PostProcessing/Editor Resources/";
+            string str = null;
+
+            foreach (var assetPath in AssetDatabase.GetAllAssetPaths())
+            {
+                if (assetPath.Contains(searchStr))
+                {
+                    str = assetPath;
+                    break;
+                }
+            }
+
+            if (str == null)
+                return false;
+
+            path = str.Substring(0, str.LastIndexOf(searchStr) + searchStr.Length);
+            return true;
+        }
+    }
+}

+fileFormatVersion: 2
+guid: a66d7b0165140a1439be89b5afc000fb
+timeCreated: 1476177015
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

+using UnityEngine;
+
+namespace UnityEditor.PostProcessing
+{
+    public static class FxStyles
+    {
+        public static GUIStyle tickStyleRight;
+        public static GUIStyle tickStyleLeft;
+        public static GUIStyle tickStyleCenter;
+
+        public static GUIStyle preSlider;
+        public static GUIStyle preSliderThumb;
+        public static GUIStyle preButton;
+        public static GUIStyle preDropdown;
+
+        public static GUIStyle preLabel;
+        public static GUIStyle hueCenterCursor;
+        public static GUIStyle hueRangeCursor;
+
+        public static GUIStyle centeredBoldLabel;
+        public static GUIStyle wheelThumb;
+        public static Vector2 wheelThumbSize;
+
+        public static GUIStyle header;
+        public static GUIStyle headerCheckbox;
+        public static GUIStyle headerFoldout;
+
+        public static Texture2D playIcon;
+        public static Texture2D checkerIcon;
+        public static Texture2D paneOptionsIcon;
+
+        public static GUIStyle centeredMiniLabel;
+
+        static FxStyles()
+        {
+            tickStyleRight = new GUIStyle("Label")
+            {
+                alignment = TextAnchor.MiddleRight,
+                fontSize = 9
+            };
+
+            tickStyleLeft = new GUIStyle("Label")
+            {
+                alignment = TextAnchor.MiddleLeft,
+                fontSize = 9
+            };
+
+            tickStyleCenter = new GUIStyle("Label")
+            {
+                alignment = TextAnchor.MiddleCenter,
+                fontSize = 9
+            };
+
+            preSlider = new GUIStyle("PreSlider");
+            preSliderThumb = new GUIStyle("PreSliderThumb");
+            preButton = new GUIStyle("PreButton");
+            preDropdown = new GUIStyle("preDropdown");
+
+            preLabel = new GUIStyle("ShurikenLabel");
+
+            hueCenterCursor = new GUIStyle("ColorPicker2DThumb")
+            {
+                normal = { background = (Texture2D)EditorGUIUtility.LoadRequired("Builtin Skins/DarkSkin/Images/ShurikenPlus.png") },
+                fixedWidth = 6,
+                fixedHeight = 6
+            };
+
+            hueRangeCursor = new GUIStyle(hueCenterCursor)
+            {
+                normal = { background = (Texture2D)EditorGUIUtility.LoadRequired("Builtin Skins/DarkSkin/Images/CircularToggle_ON.png") }
+            };
+
+            wheelThumb = new GUIStyle("ColorPicker2DThumb");
+
+            centeredBoldLabel = new GUIStyle(GUI.skin.GetStyle("Label"))
+            {
+                alignment = TextAnchor.UpperCenter,
+                fontStyle = FontStyle.Bold
+            };
+
+            centeredMiniLabel = new GUIStyle(EditorStyles.centeredGreyMiniLabel)
+            {
+                alignment = TextAnchor.UpperCenter
+            };
+
+            wheelThumbSize = new Vector2(
+                    !Mathf.Approximately(wheelThumb.fixedWidth, 0f) ? wheelThumb.fixedWidth : wheelThumb.padding.horizontal,
+                    !Mathf.Approximately(wheelThumb.fixedHeight, 0f) ? wheelThumb.fixedHeight : wheelThumb.padding.vertical
+                    );
+
+            header = new GUIStyle("ShurikenModuleTitle")
+            {
+                font = (new GUIStyle("Label")).font,
+                border = new RectOffset(15, 7, 4, 4),
+                fixedHeight = 22,
+                contentOffset = new Vector2(20f, -2f)
+            };
+
+            headerCheckbox = new GUIStyle("ShurikenCheckMark");
+            headerFoldout = new GUIStyle("Foldout");
+
+            playIcon = (Texture2D)EditorGUIUtility.LoadRequired("Builtin Skins/DarkSkin/Images/IN foldout act.png");
+            checkerIcon = (Texture2D)EditorGUIUtility.LoadRequired("Icons/CheckerFloor.png");
+
+            if (EditorGUIUtility.isProSkin)
+                paneOptionsIcon = (Texture2D)EditorGUIUtility.LoadRequired("Builtin Skins/DarkSkin/Images/pane options.png");
+            else
+                paneOptionsIcon = (Texture2D)EditorGUIUtility.LoadRequired("Builtin Skins/LightSkin/Images/pane options.png");
+        }
+    }
+}