diff --git a/Assembly-CSharp-firstpass.csproj b/Assembly-CSharp-firstpass.csproj
index bba7bd6..1fadb60 100644
--- a/Assembly-CSharp-firstpass.csproj
+++ b/Assembly-CSharp-firstpass.csproj
@@ -51,18 +51,14 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-     <Compile Include="Assets\Standard Assets\Environment\Water\Scripts\Displace.cs" />
-     <Compile Include="Assets\Standard Assets\Environment\Water\Scripts\GerstnerDisplace.cs" />
-     <Compile Include="Assets\Standard Assets\Environment\Water\Scripts\MeshContainer.cs" />
-     <Compile Include="Assets\Standard Assets\Environment\Water\Scripts\PlanarReflection.cs" />
-     <Compile Include="Assets\Standard Assets\Environment\Water\Scripts\SpecularLighting.cs" />
-     <Compile Include="Assets\Standard Assets\Environment\Water\Scripts\Water.cs" />
-     <Compile Include="Assets\Standard Assets\Environment\Water\Scripts\WaterBase.cs" />
-     <Compile Include="Assets\Standard Assets\Environment\Water\Scripts\WaterTile.cs" />
+     <Compile Include="Assets\Standard Assets\Effects\DepthOfField\DepthOfField.cs" />
      <None Include="Assets\Other\Enter Sansman Font\!license.txt" />
+     <None Include="Assets\Scripts\ImageEffects\Resources\DepthOfField.shader" />
      <None Include="Assets\Scripts\ImageEffects\CameraMotionBlurDX11.shader" />
      <None Include="Assets\Scripts\ImageEffects\CameraMotionBlur.shader" />
-     <None Include="Assets\Standard Assets\Environment\Water\Shaders\FXWaterPro.shader" />
+     <None Include="Assets\Objects\Water\Shaders\FXWaterPro.shader" />
+     <None Include="Assets\Scripts\ImageEffects\Resources\MedianFilter.shader" />
+     <None Include="Assets\Scripts\ImageEffects\Resources\BokehSplatting.shader" />
  <Reference Include="UnityEngine.UI">
  <HintPath>B:/Unity/Editor/Data/UnityExtensions/Unity/GUISystem/UnityEngine.UI.dll</HintPath>
  </Reference>
diff --git a/Assembly-CSharp.csproj b/Assembly-CSharp.csproj
index df857c4..0b75efc 100644
--- a/Assembly-CSharp.csproj
+++ b/Assembly-CSharp.csproj
@@ -80,7 +80,11 @@
      <Compile Include="Assets\Scripts\Helpers\RandomSound.cs" />
      <Compile Include="Assets\Scripts\Helpers\SimpleLookAt.cs" />
      <Compile Include="Assets\Scripts\ImageEffects\CameraMotionBlur.cs" />
+     <Compile Include="Assets\Scripts\ImageEffects\DepthOfField.cs" />
+     <Compile Include="Assets\Scripts\ImageEffects\ImageEffectHelper.cs" />
+     <Compile Include="Assets\Scripts\ImageEffects\MinAttribute.cs" />
      <Compile Include="Assets\Scripts\ImageEffects\PostEffectsBase.cs" />
+     <Compile Include="Assets\Scripts\ImageEffects\RenderTextureUtility.cs" />
      <Compile Include="Assets\Scripts\Menus\Calibration.cs" />
      <Compile Include="Assets\Scripts\Menus\Customization\Attachment.cs" />
      <Compile Include="Assets\Scripts\Menus\Customization\AttachmentPicker.cs" />
@@ -103,9 +107,12 @@
      <Compile Include="Assets\Scripts\Weapons\Scatter.cs" />
      <Compile Include="Assets\Scripts\Weapons\WeaponBase.cs" />
      <None Include="Assets\Other\Enter Sansman Font\!license.txt" />
+     <None Include="Assets\Scripts\ImageEffects\DepthOfField.shader" />
      <None Include="Assets\Scripts\ImageEffects\CameraMotionBlurDX11.shader" />
      <None Include="Assets\Scripts\ImageEffects\CameraMotionBlur.shader" />
      <None Include="Assets\Objects\Water\Shaders\FXWaterPro.shader" />
+     <None Include="Assets\Scripts\ImageEffects\MedianFilter.shader" />
+     <None Include="Assets\Scripts\ImageEffects\BokehSplatting.shader" />
  <Reference Include="UnityEngine.UI">
  <HintPath>B:/Unity/Editor/Data/UnityExtensions/Unity/GUISystem/UnityEngine.UI.dll</HintPath>
  </Reference>
@@ -134,10 +141,6 @@
  <HintPath>B:/Unity/Mayhem/Assets/SDK/LeapMotion/Core/Plugins/LeapCSharp.NET3.5.dll</HintPath>
  </Reference>
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="Assembly-CSharp-firstpass.csproj">
-      <Project>{7F32AB24-E0E8-6554-66C8-AAB8DABB2F87}</Project>      <Name>Assembly-CSharp-firstpass</Name>    </ProjectReference>
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/Assets/Scenes/Menu.unity b/Assets/Scenes/Menu.unity
index 916df61..031ee60 100644
Binary files a/Assets/Scenes/Menu.unity and b/Assets/Scenes/Menu.unity differ
diff --git a/Assets/Scripts/ImageEffects/BokehSplatting.shader b/Assets/Scripts/ImageEffects/BokehSplatting.shader
new file mode 100644
index 0000000..9358a21
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/BokehSplatting.shader
@@ -0,0 +1,237 @@
+// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
+
+/*
+    DX11 Bokeh splatting
+
+    Basic algorithm:
+    * Find bright spots
+    * Verify high frequency (otherwise dont care)
+    * If positive, replace with black pixel and add to append buffer
+    * Blend bokeh texture sprites via append buffer on top of blurred buffer
+*/
+
+Shader "Hidden/DepthOfField/BokehSplatting"
+{
+    Properties
+    {
+        _MainTex ("", 2D) = "white" {}
+        _BlurredColor ("", 2D) = "white" {}
+        _FgCocMask ("", 2D) = "white" {}
+    }
+
+    CGINCLUDE
+
+        #include "UnityCG.cginc"
+
+        #define BOKEH_ZERO_VEC (float4(0.0,0.0,0.0,0.0))
+        #define BOKEH_ONE_VEC (float4(1.0,1.0,1.0,1.0))
+
+        float4 _BokehParams; // dx11BokehScale, dx11BokehIntensity,dx11BokehThreshhold, internalBlurWidth
+        float4 _MainTex_TexelSize;
+        float3 _Screen;
+        float _SpawnHeuristic;
+
+        sampler2D_float _CameraDepthTexture;
+        sampler2D _BlurredColor;
+        sampler2D _MainTex;
+        sampler2D _FgCocMask;
+
+        struct appendStruct
+        {
+            float3 pos;
+            float4 color;
+        };
+
+        struct gs_out
+        {
+            float4 pos : SV_POSITION;
+            float3 uv : TEXCOORD0;
+            float4 color : TEXCOORD1;
+            float4 misc : TEXCOORD2;
+        };
+
+        // TODO: activate border clamp tex sampler state instead?
+        inline float4 clampBorderColor(float2 uv)
+        {
+        #if 1
+            if(uv.x <= 0.0) return BOKEH_ZERO_VEC; if(uv.x >= 1.0) return BOKEH_ZERO_VEC;
+            if(uv.y <= 0.0) return BOKEH_ZERO_VEC; if(uv.y >= 1.0) return BOKEH_ZERO_VEC;
+        #endif
+            return BOKEH_ONE_VEC;
+        }
+
+        struct vs_out
+        {
+            float4 pos : SV_POSITION;
+            float2 uv : TEXCOORD0;
+            float4 color : TEXCOORD1;
+            float cocOverlap : TEXCOORD2;
+        };
+
+        struct appdata
+        {
+            float4 vertex : POSITION;
+            float2 texcoord : TEXCOORD0;
+        };
+
+        struct v2f
+        {
+            float4 pos : SV_POSITION;
+            float2 uv_flip : TEXCOORD0;
+            float2 uv : TEXCOORD1;
+        };
+
+        AppendStructuredBuffer<appendStruct> pointBufferOutput : register(u1);
+        StructuredBuffer<appendStruct> pointBuffer;
+
+        vs_out vertApply (uint id : SV_VertexID)
+        {
+            vs_out o = (vs_out)0;
+            float2 pos = pointBuffer[id].pos.xy ;
+            o.pos = float4(pos * 2.0 - 1.0, 0.0, 1.0);
+            o.color =  pointBuffer[id].color;
+
+        #if UNITY_UV_STARTS_AT_TOP
+            o.pos.y *= -1.0;
+        #endif
+
+            o.cocOverlap = pointBuffer[id].pos.z;
+
+            return o;
+        }
+
+        v2f vertCollect (appdata v)
+        {
+            v2f o;
+            o.pos = UnityObjectToClipPos (v.vertex);
+            o.uv = v.texcoord;
+            o.uv_flip = v.texcoord;
+
+        #if UNITY_UV_STARTS_AT_TOP
+            if (_MainTex_TexelSize.y < 0.0)
+            {
+                o.uv_flip.y = 1.0 - o.uv_flip.y;
+                o.pos.y *= -1.0;
+            }
+        #endif
+
+            return o;
+        }
+
+        [maxvertexcount(4)]
+        void geom (point vs_out input[1], inout TriangleStream<gs_out> outStream)
+        {
+            // NEW ENERGY CONSERVATION:
+            float2 scale2 = _BokehParams.ww * input[0].color.aa * _BokehParams.xx;
+            float4 offs = 0.0;
+            offs.xy = float2(3.0, 3.0) + 2.0 * floor(scale2 + float2(0.5, 0.5));
+
+            float2 rs = ((float2(1.0, 1.0) + 2.0 * (scale2 + float2(0.5, 0.5))));;
+            float2 f2 = offs.xy / rs;
+
+            float energyAdjustment = (_BokehParams.y) / (rs.x * rs.y);
+            offs.xy *= _Screen.xy;
+
+            gs_out output;
+
+            output.pos = input[0].pos + offs * float4(-1.0, 1.0, 0.0, 0.0);
+            output.misc = float4(f2, 0.0, 0.0);
+            output.uv = float3(0.0, 1.0, input[0].cocOverlap);
+            output.color = input[0].color * energyAdjustment;
+            outStream.Append (output);
+
+            output.pos = input[0].pos + offs*float4(1.0, 1.0, 0.0, 0.0);
+            output.misc = float4(f2, 0.0, 0.0);
+            output.uv = float3(1.0, 1.0, input[0].cocOverlap);
+            output.color = input[0].color * energyAdjustment;
+            outStream.Append (output);
+
+            output.pos = input[0].pos + offs*float4(-1.0, -1.0, 0.0, 0.0);
+            output.misc = float4(f2, 0.0, 0.0);
+            output.uv = float3(0.0, 0.0, input[0].cocOverlap);
+            output.color = input[0].color * energyAdjustment;
+            outStream.Append (output);
+
+            output.pos = input[0].pos + offs*float4(1.0, -1.0, 0.0, 0.0);
+            output.misc = float4(f2, 0.0, 0.0);
+            output.uv = float3(1.0, 0.0, input[0].cocOverlap);
+            output.color = input[0].color * energyAdjustment;
+            outStream.Append (output);
+
+            outStream.RestartStrip();
+        }
+
+        float4 collectBrightPixel(half2 uv)
+        {
+            half4 c = tex2D(_MainTex, uv);
+            half  coc = abs(c.a);
+            half  lumc = Luminance(c.rgb);
+
+            half4 cblurred = tex2D(_BlurredColor, uv);
+            half  cocBlurred = abs(cblurred.a);
+            half  lumblurred = Luminance(cblurred.rgb);
+            half  fgCoc = -min(c.a, 0.0);
+
+            [branch]
+            if (coc * _BokehParams.w > 1.0 && cocBlurred > 0.1 && lumc > _BokehParams.z && abs(lumc - lumblurred) > _SpawnHeuristic)
+            {
+                appendStruct append = (appendStruct)0;
+                append.pos = float3(uv, fgCoc);
+                append.color.rgba = half4(c.rgb * saturate(coc * 4.0), coc);
+                pointBufferOutput.Append(append);
+                c = half4(c.rgb * saturate(1.0 - coc * 4.0), c.a);
+            }
+
+            return c;
+        }
+
+    ENDCG
+
+    SubShader
+    {
+        // Pass 0: bokeh splatting
+        Pass
+        {
+            ZWrite Off ZTest Always Cull Off
+            BlendOp Add, Add
+            Blend DstAlpha One, Zero One
+            ColorMask RGBA
+
+            CGPROGRAM
+
+                #pragma target 5.0
+                #pragma vertex vertApply
+                #pragma geometry geom
+                #pragma fragment frag
+
+                fixed4 frag (gs_out i) : SV_Target
+                {
+                    float2 uv = (i.uv.xy) * i.misc.xy + (float2(1,1)-i.misc.xy) * 0.5;  // smooth uv scale
+                    return float4(i.color.rgb, 1) * float4(tex2D(_MainTex, uv.xy).rgb, i.uv.z) * clampBorderColor (uv);
+                }
+
+            ENDCG
+        }
+
+        // Pass 1: append buffer "collect"
+        Pass
+        {
+            ZWrite Off ZTest Always Cull Off
+
+            CGPROGRAM
+
+                #pragma vertex vertCollect
+                #pragma fragment frag
+                #pragma target 5.0
+
+                float4 frag (v2f i) : SV_Target
+                {
+                    return collectBrightPixel(i.uv);
+                }
+
+            ENDCG
+        }
+    }
+
+    Fallback Off
+}
diff --git a/Assets/Scripts/ImageEffects/BokehSplatting.shader.meta b/Assets/Scripts/ImageEffects/BokehSplatting.shader.meta
new file mode 100644
index 0000000..36cccae
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/BokehSplatting.shader.meta
@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: c961b8ed1f00f924d804ada5143bd0e8
+timeCreated: 1449750679
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/ImageEffects/DepthOfField.cs b/Assets/Scripts/ImageEffects/DepthOfField.cs
new file mode 100644
index 0000000..1753e0c
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/DepthOfField.cs
@@ -0,0 +1,874 @@
+using UnityEngine;
+using System;
+
+namespace UnityStandardAssets.CinematicEffects
+{
+    //Improvement ideas:
+    //  Use rgba8 buffer in ldr / in some pass in hdr (in correlation to previous point and remapping coc from -1/0/1 to 0/0.5/1)
+    //  Use temporal stabilisation
+    //  Add a mode to do bokeh texture in quarter res as well
+    //  Support different near and far blur for the bokeh texture
+    //  Try distance field for the bokeh texture
+    //  Try to separate the output of the blur pass to two rendertarget near+far, see the gain in quality vs loss in performance
+    //  Try swirl effect on the samples of the circle blur
+
+    //References :
+    //  This DOF implementation use ideas from public sources, a big thank to them :
+    //  http://www.iryoku.com/next-generation-post-processing-in-call-of-duty-advanced-warfare
+    //  http://www.crytek.com/download/Sousa_Graphics_Gems_CryENGINE3.pdf
+    //  http://graphics.cs.williams.edu/papers/MedianShaderX6/
+    //  http://http.developer.nvidia.com/GPUGems/gpugems_ch24.html
+    //  http://vec3.ca/bicubic-filtering-in-fewer-taps/
+
+    [ExecuteInEditMode]
+    [AddComponentMenu("Image Effects/Cinematic/Depth Of Field")]
+    [RequireComponent(typeof(Camera))]
+    public class DepthOfField : MonoBehaviour
+    {
+        private const float kMaxBlur = 40.0f;
+
+        #region Render passes
+        private enum Passes
+        {
+            BlurAlphaWeighted,
+            BoxBlur,
+            DilateFgCocFromColor,
+            DilateFgCoc,
+            CaptureCocExplicit,
+            VisualizeCocExplicit,
+            CocPrefilter,
+            CircleBlur,
+            CircleBlurWithDilatedFg,
+            CircleBlurLowQuality,
+            CircleBlowLowQualityWithDilatedFg,
+            MergeExplicit,
+            ShapeLowQuality,
+            ShapeLowQualityDilateFg,
+            ShapeLowQualityMerge,
+            ShapeLowQualityMergeDilateFg,
+            ShapeMediumQuality,
+            ShapeMediumQualityDilateFg,
+            ShapeMediumQualityMerge,
+            ShapeMediumQualityMergeDilateFg,
+            ShapeHighQuality,
+            ShapeHighQualityDilateFg,
+            ShapeHighQualityMerge,
+            ShapeHighQualityMergeDilateFg
+        }
+
+        private enum MedianPasses
+        {
+            Median3,
+            Median3X3
+        }
+
+        private enum BokehTexturesPasses
+        {
+            Apply,
+            Collect
+        }
+        #endregion
+
+        public enum TweakMode
+        {
+            Range,
+            Explicit
+        }
+
+        public enum ApertureShape
+        {
+            Circular,
+            Hexagonal,
+            Octogonal
+        }
+
+        public enum QualityPreset
+        {
+            Low,
+            Medium,
+            High
+        }
+
+        public enum FilterQuality
+        {
+            None,
+            Normal,
+            High
+        }
+
+        #region Settings
+        [Serializable]
+        public struct GlobalSettings
+        {
+            [Tooltip("Allows to view where the blur will be applied. Yellow for near blur, blue for far blur.")]
+            public bool visualizeFocus;
+
+            [Tooltip("Setup mode. Use \"Advanced\" if you need more control on blur settings and/or want to use a bokeh texture. \"Explicit\" is the same as \"Advanced\" but makes use of \"Near Plane\" and \"Far Plane\" values instead of \"F-Stop\".")]
+            public TweakMode tweakMode;
+
+            [Tooltip("Quality presets. Use \"Custom\" for more advanced settings.")]
+            public QualityPreset filteringQuality;
+
+            [Tooltip("\"Circular\" is the fastest, followed by \"Hexagonal\" and \"Octogonal\".")]
+            public ApertureShape apertureShape;
+
+            [Range(0f, 179f), Tooltip("Rotates the aperture when working with \"Hexagonal\" and \"Ortogonal\".")]
+            public float apertureOrientation;
+
+            public static GlobalSettings defaultSettings
+            {
+                get
+                {
+                    return new GlobalSettings
+                    {
+                        visualizeFocus = false,
+                        tweakMode = TweakMode.Range,
+                        filteringQuality = QualityPreset.High,
+                        apertureShape = ApertureShape.Circular,
+                        apertureOrientation = 0f
+                    };
+                }
+            }
+        }
+
+        [Serializable]
+        public struct QualitySettings
+        {
+            [Tooltip("Enable this to get smooth bokeh.")]
+            public bool prefilterBlur;
+
+            [Tooltip("Applies a median filter for even smoother bokeh.")]
+            public FilterQuality medianFilter;
+
+            [Tooltip("Dilates near blur over in focus area.")]
+            public bool dilateNearBlur;
+
+            public static QualitySettings[] presetQualitySettings =
+            {
+                // Low
+                new QualitySettings
+                {
+                    prefilterBlur = false,
+                    medianFilter = FilterQuality.None,
+                    dilateNearBlur = false
+                },
+
+                // Medium
+                new QualitySettings
+                {
+                    prefilterBlur = true,
+                    medianFilter = FilterQuality.Normal,
+                    dilateNearBlur = false
+                },
+
+                // High
+                new QualitySettings
+                {
+                    prefilterBlur = true,
+                    medianFilter = FilterQuality.High,
+                    dilateNearBlur = true
+                }
+            };
+        }
+
+        [Serializable]
+        public struct FocusSettings
+        {
+            [Tooltip("Auto-focus on a selected transform.")]
+            public Transform transform;
+
+            [Min(0f), Tooltip("Focus distance (in world units).")]
+            public float focusPlane;
+
+            [Min(0.1f), Tooltip("Focus range (in world units). The focus plane is located in the center of the range.")]
+            public float range;
+
+            [Min(0f), Tooltip("Near focus distance (in world units).")]
+            public float nearPlane;
+
+            [Min(0f), Tooltip("Near blur falloff (in world units).")]
+            public float nearFalloff;
+
+            [Min(0f), Tooltip("Far focus distance (in world units).")]
+            public float farPlane;
+
+            [Min(0f), Tooltip("Far blur falloff (in world units).")]
+            public float farFalloff;
+
+            [Range(0f, kMaxBlur), Tooltip("Maximum blur radius for the near plane.")]
+            public float nearBlurRadius;
+
+            [Range(0f, kMaxBlur), Tooltip("Maximum blur radius for the far plane.")]
+            public float farBlurRadius;
+
+            public static FocusSettings defaultSettings
+            {
+                get
+                {
+                    return new FocusSettings
+                    {
+                        transform = null,
+                        focusPlane = 20f,
+                        range = 35f,
+                        nearPlane = 2.5f,
+                        nearFalloff = 15f,
+                        farPlane = 37.5f,
+                        farFalloff = 50f,
+                        nearBlurRadius = 15f,
+                        farBlurRadius = 20f
+                    };
+                }
+            }
+        }
+
+        [Serializable]
+        public struct BokehTextureSettings
+        {
+            [Tooltip("Adding a texture to this field will enable the use of \"Bokeh Textures\". Use with care. This feature is only available on Shader Model 5 compatible-hardware and performance scale with the amount of bokeh.")]
+            public Texture2D texture;
+
+            [Range(0.01f, 10f), Tooltip("Maximum size of bokeh textures on screen.")]
+            public float scale;
+
+            [Range(0.01f, 100f), Tooltip("Bokeh brightness.")]
+            public float intensity;
+
+            [Range(0.01f, 5f), Tooltip("Controls the amount of bokeh textures. Lower values mean more bokeh splats.")]
+            public float threshold;
+
+            [Range(0.01f, 1f), Tooltip("Controls the spawn conditions. Lower values mean more visible bokeh.")]
+            public float spawnHeuristic;
+
+            public static BokehTextureSettings defaultSettings
+            {
+                get
+                {
+                    return new BokehTextureSettings
+                    {
+                        texture = null,
+                        scale = 1f,
+                        intensity = 50f,
+                        threshold = 2f,
+                        spawnHeuristic = 0.15f
+                    };
+                }
+            }
+        }
+        #endregion
+
+        public GlobalSettings settings = GlobalSettings.defaultSettings;
+        public FocusSettings focus = FocusSettings.defaultSettings;
+        public BokehTextureSettings bokehTexture = BokehTextureSettings.defaultSettings;
+
+        [SerializeField]
+        private Shader m_FilmicDepthOfFieldShader;
+
+        public Shader filmicDepthOfFieldShader
+        {
+            get
+            {
+                if (m_FilmicDepthOfFieldShader == null)
+                    m_FilmicDepthOfFieldShader = Shader.Find("Hidden/DepthOfField/DepthOfField");
+
+                return m_FilmicDepthOfFieldShader;
+            }
+        }
+
+        [SerializeField]
+        private Shader m_MedianFilterShader;
+
+        public Shader medianFilterShader
+        {
+            get
+            {
+                if (m_MedianFilterShader == null)
+                    m_MedianFilterShader = Shader.Find("Hidden/DepthOfField/MedianFilter");
+
+                return m_MedianFilterShader;
+            }
+        }
+
+        [SerializeField]
+        private Shader m_TextureBokehShader;
+
+        public Shader textureBokehShader
+        {
+            get
+            {
+                if (m_TextureBokehShader == null)
+                    m_TextureBokehShader = Shader.Find("Hidden/DepthOfField/BokehSplatting");
+
+                return m_TextureBokehShader;
+            }
+        }
+
+        private RenderTextureUtility m_RTU = new RenderTextureUtility();
+
+        private Material m_FilmicDepthOfFieldMaterial;
+
+        public Material filmicDepthOfFieldMaterial
+        {
+            get
+            {
+                if (m_FilmicDepthOfFieldMaterial == null)
+                    m_FilmicDepthOfFieldMaterial = ImageEffectHelper.CheckShaderAndCreateMaterial(filmicDepthOfFieldShader);
+
+                return m_FilmicDepthOfFieldMaterial;
+            }
+        }
+
+        private Material m_MedianFilterMaterial;
+
+        public Material medianFilterMaterial
+        {
+            get
+            {
+                if (m_MedianFilterMaterial == null)
+                    m_MedianFilterMaterial = ImageEffectHelper.CheckShaderAndCreateMaterial(medianFilterShader);
+
+                return m_MedianFilterMaterial;
+            }
+        }
+
+        private Material m_TextureBokehMaterial;
+
+        public Material textureBokehMaterial
+        {
+            get
+            {
+                if (m_TextureBokehMaterial == null)
+                    m_TextureBokehMaterial = ImageEffectHelper.CheckShaderAndCreateMaterial(textureBokehShader);
+
+                return m_TextureBokehMaterial;
+            }
+        }
+
+        private ComputeBuffer m_ComputeBufferDrawArgs;
+
+        public ComputeBuffer computeBufferDrawArgs
+        {
+            get
+            {
+                if (m_ComputeBufferDrawArgs == null)
+                {
+#if UNITY_5_4_OR_NEWER
+                    m_ComputeBufferDrawArgs = new ComputeBuffer(1, 16, ComputeBufferType.IndirectArguments);
+#else
+                    m_ComputeBufferDrawArgs = new ComputeBuffer(1, 16, ComputeBufferType.DrawIndirect);
+#endif
+                    m_ComputeBufferDrawArgs.SetData(new[] {0, 1, 0, 0});
+                }
+
+                return m_ComputeBufferDrawArgs;
+            }
+        }
+
+        private ComputeBuffer m_ComputeBufferPoints;
+
+        public ComputeBuffer computeBufferPoints
+        {
+            get
+            {
+                if (m_ComputeBufferPoints == null)
+                    m_ComputeBufferPoints = new ComputeBuffer(90000, 12 + 16, ComputeBufferType.Append);
+
+                return m_ComputeBufferPoints;
+            }
+        }
+
+        private QualitySettings m_CurrentQualitySettings;
+        private float m_LastApertureOrientation;
+        private Vector4 m_OctogonalBokehDirection1;
+        private Vector4 m_OctogonalBokehDirection2;
+        private Vector4 m_OctogonalBokehDirection3;
+        private Vector4 m_OctogonalBokehDirection4;
+        private Vector4 m_HexagonalBokehDirection1;
+        private Vector4 m_HexagonalBokehDirection2;
+        private Vector4 m_HexagonalBokehDirection3;
+
+        private int m_BlurParams;
+        private int m_BlurCoe;
+        private int m_Offsets;
+        private int m_BlurredColor;
+        private int m_SpawnHeuristic;
+        private int m_BokehParams;
+        private int m_Convolved_TexelSize;
+        private int m_SecondTex;
+        private int m_ThirdTex;
+        private int m_MainTex;
+        private int m_Screen;
+
+        private void Awake()
+        {
+            m_BlurParams = Shader.PropertyToID("_BlurParams");
+            m_BlurCoe = Shader.PropertyToID("_BlurCoe");
+            m_Offsets = Shader.PropertyToID("_Offsets");
+            m_BlurredColor = Shader.PropertyToID("_BlurredColor");
+            m_SpawnHeuristic = Shader.PropertyToID("_SpawnHeuristic");
+            m_BokehParams = Shader.PropertyToID("_BokehParams");
+            m_Convolved_TexelSize = Shader.PropertyToID("_Convolved_TexelSize");
+            m_SecondTex = Shader.PropertyToID("_SecondTex");
+            m_ThirdTex = Shader.PropertyToID("_ThirdTex");
+            m_MainTex = Shader.PropertyToID("_MainTex");
+            m_Screen = Shader.PropertyToID("_Screen");
+        }
+
+        private void OnEnable()
+        {
+            if (!ImageEffectHelper.IsSupported(filmicDepthOfFieldShader, true, true, this) || !ImageEffectHelper.IsSupported(medianFilterShader, true, true, this))
+            {
+                enabled = false;
+                return;
+            }
+
+            if (ImageEffectHelper.supportsDX11 && !ImageEffectHelper.IsSupported(textureBokehShader, true, true, this))
+            {
+                enabled = false;
+                return;
+            }
+
+            ComputeBlurDirections(true);
+            GetComponent<Camera>().depthTextureMode |= DepthTextureMode.Depth;
+        }
+
+        private void OnDisable()
+        {
+            ReleaseComputeResources();
+
+            if (m_FilmicDepthOfFieldMaterial != null)
+                DestroyImmediate(m_FilmicDepthOfFieldMaterial);
+
+            if (m_TextureBokehMaterial != null)
+                DestroyImmediate(m_TextureBokehMaterial);
+
+            if (m_MedianFilterMaterial != null)
+                DestroyImmediate(m_MedianFilterMaterial);
+
+            m_FilmicDepthOfFieldMaterial = null;
+            m_TextureBokehMaterial = null;
+            m_MedianFilterMaterial = null;
+
+            m_RTU.ReleaseAllTemporaryRenderTextures();
+        }
+
+        //-------------------------------------------------------------------//
+        // Main entry point                                                  //
+        //-------------------------------------------------------------------//
+        [ImageEffectOpaque]
+        private void OnRenderImage(RenderTexture source, RenderTexture destination)
+        {
+            if (medianFilterMaterial == null || filmicDepthOfFieldMaterial == null)
+            {
+                Graphics.Blit(source, destination);
+                return;
+            }
+
+            if (settings.visualizeFocus)
+            {
+                Vector4 blurrinessParam;
+                Vector4 blurrinessCoe;
+                ComputeCocParameters(out blurrinessParam, out blurrinessCoe);
+                filmicDepthOfFieldMaterial.SetVector(m_BlurParams, blurrinessParam);
+                filmicDepthOfFieldMaterial.SetVector(m_BlurCoe, blurrinessCoe);
+                Graphics.Blit(null, destination, filmicDepthOfFieldMaterial, (int)Passes.VisualizeCocExplicit);
+            }
+            else
+            {
+                DoDepthOfField(source, destination);
+            }
+
+            m_RTU.ReleaseAllTemporaryRenderTextures();
+        }
+
+        private void DoDepthOfField(RenderTexture source, RenderTexture destination)
+        {
+            m_CurrentQualitySettings = QualitySettings.presetQualitySettings[(int)settings.filteringQuality];
+
+            float radiusAdjustement = source.height / 720f;
+
+            float textureBokehScale = radiusAdjustement;
+            float textureBokehMaxRadius = Mathf.Max(focus.nearBlurRadius, focus.farBlurRadius) * textureBokehScale * 0.75f;
+
+            float nearBlurRadius = focus.nearBlurRadius * radiusAdjustement;
+            float farBlurRadius = focus.farBlurRadius * radiusAdjustement;
+            float maxBlurRadius = Mathf.Max(nearBlurRadius, farBlurRadius);
+            switch (settings.apertureShape)
+            {
+                case ApertureShape.Hexagonal:
+                    maxBlurRadius *= 1.2f;
+                    break;
+                case ApertureShape.Octogonal:
+                    maxBlurRadius *= 1.15f;
+                    break;
+            }
+
+            if (maxBlurRadius < 0.5f)
+            {
+                Graphics.Blit(source, destination);
+                return;
+            }
+
+            // Quarter resolution
+            int rtW = source.width / 2;
+            int rtH = source.height / 2;
+            var blurrinessCoe = new Vector4(nearBlurRadius * 0.5f, farBlurRadius * 0.5f, 0f, 0f);
+            var colorAndCoc = m_RTU.GetTemporaryRenderTexture(rtW, rtH);
+            var colorAndCoc2 = m_RTU.GetTemporaryRenderTexture(rtW, rtH);
+
+            // Downsample to Color + COC buffer
+            Vector4 cocParam;
+            Vector4 cocCoe;
+            ComputeCocParameters(out cocParam, out cocCoe);
+            filmicDepthOfFieldMaterial.SetVector(m_BlurParams, cocParam);
+            filmicDepthOfFieldMaterial.SetVector(m_BlurCoe, cocCoe);
+            Graphics.Blit(source, colorAndCoc2, filmicDepthOfFieldMaterial, (int)Passes.CaptureCocExplicit);
+            var src = colorAndCoc2;
+            var dst = colorAndCoc;
+
+            // Collect texture bokeh candidates and replace with a darker pixel
+            if (shouldPerformBokeh)
+            {
+                // Blur a bit so we can do a frequency check
+                var blurred = m_RTU.GetTemporaryRenderTexture(rtW, rtH);
+                Graphics.Blit(src, blurred, filmicDepthOfFieldMaterial, (int)Passes.BoxBlur);
+                filmicDepthOfFieldMaterial.SetVector(m_Offsets, new Vector4(0f, 1.5f, 0f, 1.5f));
+                Graphics.Blit(blurred, dst, filmicDepthOfFieldMaterial, (int)Passes.BlurAlphaWeighted);
+                filmicDepthOfFieldMaterial.SetVector(m_Offsets, new Vector4(1.5f, 0f, 0f, 1.5f));
+                Graphics.Blit(dst, blurred, filmicDepthOfFieldMaterial, (int)Passes.BlurAlphaWeighted);
+
+                // Collect texture bokeh candidates and replace with a darker pixel
+                textureBokehMaterial.SetTexture(m_BlurredColor, blurred);
+                textureBokehMaterial.SetFloat(m_SpawnHeuristic, bokehTexture.spawnHeuristic);
+                textureBokehMaterial.SetVector(m_BokehParams, new Vector4(bokehTexture.scale * textureBokehScale, bokehTexture.intensity, bokehTexture.threshold, textureBokehMaxRadius));
+                Graphics.SetRandomWriteTarget(1, computeBufferPoints);
+                Graphics.Blit(src, dst, textureBokehMaterial, (int)BokehTexturesPasses.Collect);
+                Graphics.ClearRandomWriteTargets();
+                SwapRenderTexture(ref src, ref dst);
+                m_RTU.ReleaseTemporaryRenderTexture(blurred);
+            }
+
+            filmicDepthOfFieldMaterial.SetVector(m_BlurParams, cocParam);
+            filmicDepthOfFieldMaterial.SetVector(m_BlurCoe, blurrinessCoe);
+
+            // Dilate near blur factor
+            RenderTexture blurredFgCoc = null;
+            if (m_CurrentQualitySettings.dilateNearBlur)
+            {
+                var blurredFgCoc2 = m_RTU.GetTemporaryRenderTexture(rtW, rtH, 0, RenderTextureFormat.RGHalf);
+                blurredFgCoc = m_RTU.GetTemporaryRenderTexture(rtW, rtH, 0, RenderTextureFormat.RGHalf);
+                filmicDepthOfFieldMaterial.SetVector(m_Offsets, new Vector4(0f, nearBlurRadius * 0.75f, 0f, 0f));
+                Graphics.Blit(src, blurredFgCoc2, filmicDepthOfFieldMaterial, (int)Passes.DilateFgCocFromColor);
+                filmicDepthOfFieldMaterial.SetVector(m_Offsets, new Vector4(nearBlurRadius * 0.75f, 0f, 0f, 0f));
+                Graphics.Blit(blurredFgCoc2, blurredFgCoc, filmicDepthOfFieldMaterial, (int)Passes.DilateFgCoc);
+                m_RTU.ReleaseTemporaryRenderTexture(blurredFgCoc2);
+                blurredFgCoc.filterMode = FilterMode.Point;
+            }
+
+            // Blur downsampled color to fill the gap between samples
+            if (m_CurrentQualitySettings.prefilterBlur)
+            {
+                Graphics.Blit(src, dst, filmicDepthOfFieldMaterial, (int)Passes.CocPrefilter);
+                SwapRenderTexture(ref src, ref dst);
+            }
+
+            // Apply blur : Circle / Hexagonal or Octagonal (blur will create bokeh if bright pixel where not removed by "m_UseBokehTexture")
+            switch (settings.apertureShape)
+            {
+                case ApertureShape.Circular:
+                    DoCircularBlur(blurredFgCoc, ref src, ref dst, maxBlurRadius);
+                    break;
+                case ApertureShape.Hexagonal:
+                    DoHexagonalBlur(blurredFgCoc, ref src, ref dst, maxBlurRadius);
+                    break;
+                case ApertureShape.Octogonal:
+                    DoOctogonalBlur(blurredFgCoc, ref src, ref dst, maxBlurRadius);
+                    break;
+            }
+
+            // Smooth result
+            switch (m_CurrentQualitySettings.medianFilter)
+            {
+                case FilterQuality.Normal:
+                {
+                    medianFilterMaterial.SetVector(m_Offsets, new Vector4(1f, 0f, 0f, 0f));
+                    Graphics.Blit(src, dst, medianFilterMaterial, (int)MedianPasses.Median3);
+                    SwapRenderTexture(ref src, ref dst);
+                    medianFilterMaterial.SetVector(m_Offsets, new Vector4(0f, 1f, 0f, 0f));
+                    Graphics.Blit(src, dst, medianFilterMaterial, (int)MedianPasses.Median3);
+                    SwapRenderTexture(ref src, ref dst);
+                    break;
+                }
+                case FilterQuality.High:
+                {
+                    Graphics.Blit(src, dst, medianFilterMaterial, (int)MedianPasses.Median3X3);
+                    SwapRenderTexture(ref src, ref dst);
+                    break;
+                }
+            }
+
+            // Merge to full resolution (with boost) + upsampling (linear or bicubic)
+            filmicDepthOfFieldMaterial.SetVector(m_BlurCoe, blurrinessCoe);
+            filmicDepthOfFieldMaterial.SetVector(m_Convolved_TexelSize, new Vector4(src.width, src.height, 1f / src.width, 1f / src.height));
+            filmicDepthOfFieldMaterial.SetTexture(m_SecondTex, src);
+            int mergePass = (int)Passes.MergeExplicit;
+
+            // Apply texture bokeh
+            if (shouldPerformBokeh)
+            {
+                var tmp = m_RTU.GetTemporaryRenderTexture(source.height, source.width, 0, source.format);
+                Graphics.Blit(source, tmp, filmicDepthOfFieldMaterial, mergePass);
+
+                Graphics.SetRenderTarget(tmp);
+                ComputeBuffer.CopyCount(computeBufferPoints, computeBufferDrawArgs, 0);
+                textureBokehMaterial.SetBuffer("pointBuffer", computeBufferPoints);
+                textureBokehMaterial.SetTexture(m_MainTex, bokehTexture.texture);
+                textureBokehMaterial.SetVector(m_Screen, new Vector3(1f / (1f * source.width), 1f / (1f * source.height), textureBokehMaxRadius));
+                textureBokehMaterial.SetPass((int)BokehTexturesPasses.Apply);
+                Graphics.DrawProceduralIndirect(MeshTopology.Points, computeBufferDrawArgs, 0);
+                Graphics.Blit(tmp, destination); // Hackaround for DX11 flipfun (OPTIMIZEME)
+            }
+            else
+            {
+                Graphics.Blit(source, destination, filmicDepthOfFieldMaterial, mergePass);
+            }
+        }
+
+        //-------------------------------------------------------------------//
+        // Blurs                                                             //
+        //-------------------------------------------------------------------//
+        private void DoHexagonalBlur(RenderTexture blurredFgCoc, ref RenderTexture src, ref RenderTexture dst, float maxRadius)
+        {
+            ComputeBlurDirections(false);
+
+            int blurPass;
+            int blurPassMerge;
+            GetDirectionalBlurPassesFromRadius(blurredFgCoc, maxRadius, out blurPass, out blurPassMerge);
+            filmicDepthOfFieldMaterial.SetTexture(m_SecondTex, blurredFgCoc);
+            var tmp = m_RTU.GetTemporaryRenderTexture(src.width, src.height, 0, src.format);
+
+            filmicDepthOfFieldMaterial.SetVector(m_Offsets, m_HexagonalBokehDirection1);
+            Graphics.Blit(src, tmp, filmicDepthOfFieldMaterial, blurPass);
+
+            filmicDepthOfFieldMaterial.SetVector(m_Offsets, m_HexagonalBokehDirection2);
+            Graphics.Blit(tmp, src, filmicDepthOfFieldMaterial, blurPass);
+
+            filmicDepthOfFieldMaterial.SetVector(m_Offsets, m_HexagonalBokehDirection3);
+            filmicDepthOfFieldMaterial.SetTexture(m_ThirdTex, src);
+            Graphics.Blit(tmp, dst, filmicDepthOfFieldMaterial, blurPassMerge);
+            m_RTU.ReleaseTemporaryRenderTexture(tmp);
+            SwapRenderTexture(ref src, ref dst);
+        }
+
+        private void DoOctogonalBlur(RenderTexture blurredFgCoc, ref RenderTexture src, ref RenderTexture dst, float maxRadius)
+        {
+            ComputeBlurDirections(false);
+
+            int blurPass;
+            int blurPassMerge;
+            GetDirectionalBlurPassesFromRadius(blurredFgCoc, maxRadius, out blurPass, out blurPassMerge);
+            filmicDepthOfFieldMaterial.SetTexture(m_SecondTex, blurredFgCoc);
+            var tmp = m_RTU.GetTemporaryRenderTexture(src.width, src.height, 0, src.format);
+
+            filmicDepthOfFieldMaterial.SetVector(m_Offsets, m_OctogonalBokehDirection1);
+            Graphics.Blit(src, tmp, filmicDepthOfFieldMaterial, blurPass);
+
+            filmicDepthOfFieldMaterial.SetVector(m_Offsets, m_OctogonalBokehDirection2);
+            Graphics.Blit(tmp, dst, filmicDepthOfFieldMaterial, blurPass);
+
+            filmicDepthOfFieldMaterial.SetVector(m_Offsets, m_OctogonalBokehDirection3);
+            Graphics.Blit(src, tmp, filmicDepthOfFieldMaterial, blurPass);
+
+            filmicDepthOfFieldMaterial.SetVector(m_Offsets, m_OctogonalBokehDirection4);
+            filmicDepthOfFieldMaterial.SetTexture(m_ThirdTex, dst);
+            Graphics.Blit(tmp, src, filmicDepthOfFieldMaterial, blurPassMerge);
+            m_RTU.ReleaseTemporaryRenderTexture(tmp);
+        }
+
+        private void DoCircularBlur(RenderTexture blurredFgCoc, ref RenderTexture src, ref RenderTexture dst, float maxRadius)
+        {
+            int bokehPass;
+
+            if (blurredFgCoc != null)
+            {
+                filmicDepthOfFieldMaterial.SetTexture(m_SecondTex, blurredFgCoc);
+                bokehPass = (maxRadius > 10f) ? (int)Passes.CircleBlurWithDilatedFg : (int)Passes.CircleBlowLowQualityWithDilatedFg;
+            }
+            else
+            {
+                bokehPass = (maxRadius > 10f) ? (int)Passes.CircleBlur : (int)Passes.CircleBlurLowQuality;
+            }
+
+            Graphics.Blit(src, dst, filmicDepthOfFieldMaterial, bokehPass);
+            SwapRenderTexture(ref src, ref dst);
+        }
+
+        //-------------------------------------------------------------------//
+        // Helpers                                                           //
+        //-------------------------------------------------------------------//
+        private void ComputeCocParameters(out Vector4 blurParams, out Vector4 blurCoe)
+        {
+            var sceneCamera = GetComponent<Camera>();
+
+            float focusDistance;
+            float nearFalloff = focus.nearFalloff * 2f;
+            float farFalloff = focus.farFalloff * 2f;
+            float nearPlane = focus.nearPlane;
+            float farPlane = focus.farPlane;
+
+            if (settings.tweakMode == TweakMode.Range)
+            {
+                if (focus.transform != null)
+                    focusDistance = sceneCamera.WorldToViewportPoint(focus.transform.position).z;
+                else
+                    focusDistance = focus.focusPlane;
+
+                float s = focus.range * 0.5f;
+                nearPlane = focusDistance - s;
+                farPlane = focusDistance + s;
+            }
+
+            nearPlane -= (nearFalloff * 0.5f);
+            farPlane += (farFalloff * 0.5f);
+            focusDistance = (nearPlane + farPlane) * 0.5f;
+
+            float focusDistance01 = focusDistance / sceneCamera.farClipPlane;
+            float nearDistance01 = nearPlane / sceneCamera.farClipPlane;
+            float farDistance01 = farPlane / sceneCamera.farClipPlane;
+
+            var dof = farPlane - nearPlane;
+            var dof01 = farDistance01 - nearDistance01;
+            var nearFalloff01 = nearFalloff / dof;
+            var farFalloff01 = farFalloff / dof;
+            float nearFocusRange01 = (1f - nearFalloff01) * (dof01 * 0.5f);
+            float farFocusRange01 = (1f - farFalloff01) * (dof01 * 0.5f);
+
+            if (focusDistance01 <= nearDistance01)
+                focusDistance01 = nearDistance01 + 1e-6f;
+            if (focusDistance01 >= farDistance01)
+                focusDistance01 = farDistance01 - 1e-6f;
+
+            if ((focusDistance01 - nearFocusRange01) <= nearDistance01)
+                nearFocusRange01 = focusDistance01 - nearDistance01 - 1e-6f;
+            if ((focusDistance01 + farFocusRange01) >= farDistance01)
+                farFocusRange01 = farDistance01 - focusDistance01 - 1e-6f;
+
+            float a1 = 1f / (nearDistance01 - focusDistance01 + nearFocusRange01);
+            float a2 = 1f / (farDistance01 - focusDistance01 - farFocusRange01);
+            float b1 = 1f - a1 * nearDistance01;
+            float b2 = 1f - a2 * farDistance01;
+            const float c1 = -1f;
+            const float c2 = 1f;
+            blurParams = new Vector4(c1 * a1, c1 * b1, c2 * a2, c2 * b2);
+            blurCoe = new Vector4(0f, 0f, (b2 - b1) / (a1 - a2), 0f);
+
+            // Save values so we can switch from one tweak mode to the other on the fly
+            focus.nearPlane = nearPlane + (nearFalloff * 0.5f);
+            focus.farPlane = farPlane - (farFalloff * 0.5f);
+            focus.focusPlane = (focus.nearPlane + focus.farPlane) * 0.5f;
+            focus.range = focus.farPlane - focus.nearPlane;
+        }
+
+        private void ReleaseComputeResources()
+        {
+            if (m_ComputeBufferDrawArgs != null)
+                m_ComputeBufferDrawArgs.Release();
+
+            if (m_ComputeBufferPoints != null)
+                m_ComputeBufferPoints.Release();
+
+            m_ComputeBufferDrawArgs = null;
+            m_ComputeBufferPoints = null;
+        }
+
+        private void ComputeBlurDirections(bool force)
+        {
+            if (!force && Math.Abs(m_LastApertureOrientation - settings.apertureOrientation) < float.Epsilon)
+                return;
+
+            m_LastApertureOrientation = settings.apertureOrientation;
+
+            float rotationRadian = settings.apertureOrientation * Mathf.Deg2Rad;
+            float cosinus = Mathf.Cos(rotationRadian);
+            float sinus = Mathf.Sin(rotationRadian);
+
+            m_OctogonalBokehDirection1 = new Vector4(0.5f, 0f, 0f, 0f);
+            m_OctogonalBokehDirection2 = new Vector4(0f, 0.5f, 1f, 0f);
+            m_OctogonalBokehDirection3 = new Vector4(-0.353553f, 0.353553f, 1f, 0f);
+            m_OctogonalBokehDirection4 = new Vector4(0.353553f, 0.353553f, 1f, 0f);
+
+            m_HexagonalBokehDirection1 = new Vector4(0.5f, 0f, 0f, 0f);
+            m_HexagonalBokehDirection2 = new Vector4(0.25f, 0.433013f, 1f, 0f);
+            m_HexagonalBokehDirection3 = new Vector4(0.25f, -0.433013f, 1f, 0f);
+
+            if (rotationRadian > float.Epsilon)
+            {
+                Rotate2D(ref m_OctogonalBokehDirection1, cosinus, sinus);
+                Rotate2D(ref m_OctogonalBokehDirection2, cosinus, sinus);
+                Rotate2D(ref m_OctogonalBokehDirection3, cosinus, sinus);
+                Rotate2D(ref m_OctogonalBokehDirection4, cosinus, sinus);
+                Rotate2D(ref m_HexagonalBokehDirection1, cosinus, sinus);
+                Rotate2D(ref m_HexagonalBokehDirection2, cosinus, sinus);
+                Rotate2D(ref m_HexagonalBokehDirection3, cosinus, sinus);
+            }
+        }
+
+        private bool shouldPerformBokeh
+        {
+            get { return ImageEffectHelper.supportsDX11 && bokehTexture.texture != null && textureBokehMaterial; }
+        }
+
+        private static void Rotate2D(ref Vector4 direction, float cosinus, float sinus)
+        {
+            var source = direction;
+            direction.x = source.x * cosinus - source.y * sinus;
+            direction.y = source.x * sinus + source.y * cosinus;
+        }
+
+        private static void SwapRenderTexture(ref RenderTexture src, ref RenderTexture dst)
+        {
+            RenderTexture tmp = dst;
+            dst = src;
+            src = tmp;
+        }
+
+        private static void GetDirectionalBlurPassesFromRadius(RenderTexture blurredFgCoc, float maxRadius, out int blurPass, out int blurAndMergePass)
+        {
+            if (blurredFgCoc == null)
+            {
+                if (maxRadius > 10f)
+                {
+                    blurPass = (int)Passes.ShapeHighQuality;
+                    blurAndMergePass = (int)Passes.ShapeHighQualityMerge;
+                }
+                else if (maxRadius > 5f)
+                {
+                    blurPass = (int)Passes.ShapeMediumQuality;
+                    blurAndMergePass = (int)Passes.ShapeMediumQualityMerge;
+                }
+                else
+                {
+                    blurPass = (int)Passes.ShapeLowQuality;
+                    blurAndMergePass = (int)Passes.ShapeLowQualityMerge;
+                }
+            }
+            else
+            {
+                if (maxRadius > 10f)
+                {
+                    blurPass = (int)Passes.ShapeHighQualityDilateFg;
+                    blurAndMergePass = (int)Passes.ShapeHighQualityMergeDilateFg;
+                }
+                else if (maxRadius > 5f)
+                {
+                    blurPass = (int)Passes.ShapeMediumQualityDilateFg;
+                    blurAndMergePass = (int)Passes.ShapeMediumQualityMergeDilateFg;
+                }
+                else
+                {
+                    blurPass = (int)Passes.ShapeLowQualityDilateFg;
+                    blurAndMergePass = (int)Passes.ShapeLowQualityMergeDilateFg;
+                }
+            }
+        }
+    }
+}
diff --git a/Assets/Scripts/ImageEffects/DepthOfField.cs.meta b/Assets/Scripts/ImageEffects/DepthOfField.cs.meta
new file mode 100644
index 0000000..c12eba8
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/DepthOfField.cs.meta
@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 8a338d679868f45439ea43c7ae035e36
+timeCreated: 1453985420
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences:
+  - m_FilmicDepthOfFieldShader: {fileID: 4800000, guid: bff0e5458fb914f5c9985ba4f09171d2,
+      type: 3}
+  - m_MedianFilterShader: {fileID: 4800000, guid: a058b22d4123add4b807e832604e5e7b,
+      type: 3}
+  - m_TextureBokehShader: {fileID: 4800000, guid: c961b8ed1f00f924d804ada5143bd0e8,
+      type: 3}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/ImageEffects/DepthOfField.shader b/Assets/Scripts/ImageEffects/DepthOfField.shader
new file mode 100644
index 0000000..4ba133d
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/DepthOfField.shader
@@ -0,0 +1,1223 @@
+// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
+
+Shader "Hidden/DepthOfField/DepthOfField"
+{
+    Properties
+    {
+        _MainTex ("-", 2D) = "black"
+        _SecondTex ("-", 2D) = "black"
+        _ThirdTex ("-", 2D) = "black"
+    }
+
+    CGINCLUDE
+
+        #pragma target 3.0
+        #pragma fragmentoption ARB_precision_hint_fastest
+        #include "UnityCG.cginc"
+
+        // Undef USE_LOCAL_TONEMAPPING if you dont want to use local tonemapping.
+        // Tweaking these values down will trade stability for less bokeh (see Tonemap/TonemapInvert methods below).
+        #ifndef SHADER_API_MOBILE
+            #define USE_LOCAL_TONEMAPPING
+        #endif
+        #define LOCAL_TONEMAP_START_LUMA 1.0
+        #define LOCAL_TONEMAP_RANGE_LUMA 5.0
+
+        sampler2D _SecondTex;
+        sampler2D _ThirdTex;
+
+        uniform half4 _MainTex_TexelSize;
+        uniform half4 _BlurCoe;
+        uniform half4 _BlurParams;
+        uniform half4 _Convolved_TexelSize;
+        uniform float4 _Offsets;
+
+        uniform half4 _MainTex_ST;
+        uniform half4 _SecondTex_ST;
+        uniform half4 _ThirdTex_ST;
+
+        #if (SHADER_TARGET >= 50 && !defined(SHADER_API_PSSL))
+            #define USE_TEX2DOBJECT_FOR_COC
+        #endif
+
+        #if defined(USE_TEX2DOBJECT_FOR_COC)
+            Texture2D _CameraDepthTexture;
+            SamplerState sampler_CameraDepthTexture;
+            Texture2D _MainTex;
+            SamplerState sampler_MainTex;
+        #else
+            sampler2D _MainTex;
+            sampler2D _CameraDepthTexture;
+        #endif
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Verter Shaders and declaration
+        ///////////////////////////////////////////////////////////////////////////////
+
+        struct v2f
+        {
+            float4 pos : SV_POSITION;
+            float2 uv  : TEXCOORD0;
+            float2 uv1 : TEXCOORD1;
+        };
+
+        struct v2fDepth
+        {
+            half4 pos  : SV_POSITION;
+            half2 uv   : TEXCOORD0;
+        };
+
+        struct v2fBlur
+        {
+            float4 pos  : SV_POSITION;
+            float2 uv   : TEXCOORD0;
+            float4 uv01 : TEXCOORD1;
+            float4 uv23 : TEXCOORD2;
+            float4 uv45 : TEXCOORD3;
+            float4 uv67 : TEXCOORD4;
+            float4 uv89 : TEXCOORD5;
+        };
+
+        v2fDepth vert(appdata_img v)
+        {
+            v2fDepth o;
+            o.pos = UnityObjectToClipPos(v.vertex);
+            o.uv = v.texcoord.xy;
+
+        #if UNITY_UV_STARTS_AT_TOP
+            if (_MainTex_TexelSize.y < 0.0)
+                o.uv.y = 1.0 - o.uv.y;
+        #endif
+
+            return o;
+        }
+
+        v2fDepth vertNoFlip(appdata_img v)
+        {
+            v2fDepth o;
+            o.pos = UnityObjectToClipPos(v.vertex);
+            o.uv = v.texcoord.xy;
+            return o;
+        }
+
+        v2f vert_d(appdata_img v)
+        {
+            v2f o;
+            o.pos = UnityObjectToClipPos (v.vertex);
+            o.uv1.xy = v.texcoord.xy;
+            o.uv.xy = v.texcoord.xy;
+
+        #if UNITY_UV_STARTS_AT_TOP
+            if (_MainTex_TexelSize.y < 0.0)
+                o.uv.y = 1.0 - o.uv.y;
+        #endif
+
+            return o;
+        }
+
+        v2f vertFlip(appdata_img v)
+        {
+            v2f o;
+            o.pos = UnityObjectToClipPos (v.vertex);
+            o.uv1.xy = v.texcoord.xy;
+            o.uv.xy = v.texcoord.xy;
+
+        #if UNITY_UV_STARTS_AT_TOP
+            if (_MainTex_TexelSize.y < 0.0)
+            {
+                o.uv.y = 1.0 - o.uv.y;
+                o.uv1.y = 1.0 - o.uv1.y;
+            }
+        #endif
+
+            return o;
+        }
+
+        v2fBlur vertBlurPlusMinus(appdata_img v)
+        {
+            v2fBlur o;
+            o.pos = UnityObjectToClipPos(v.vertex);
+            o.uv.xy = v.texcoord.xy;
+            o.uv01 =  v.texcoord.xyxy + _Offsets.xyxy * float4(1,1, -1,-1) * _MainTex_TexelSize.xyxy / 6.0;
+            o.uv23 =  v.texcoord.xyxy + _Offsets.xyxy * float4(2,2, -2,-2) * _MainTex_TexelSize.xyxy / 6.0;
+            o.uv45 =  v.texcoord.xyxy + _Offsets.xyxy * float4(3,3, -3,-3) * _MainTex_TexelSize.xyxy / 6.0;
+            o.uv67 =  v.texcoord.xyxy + _Offsets.xyxy * float4(4,4, -4,-4) * _MainTex_TexelSize.xyxy / 6.0;
+            o.uv89 =  v.texcoord.xyxy + _Offsets.xyxy * float4(5,5, -5,-5) * _MainTex_TexelSize.xyxy / 6.0;
+            return o;
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Helpers
+        ///////////////////////////////////////////////////////////////////////////////
+
+        inline half4 FetchMainTex(float2 uv)
+        {
+        #if defined(USE_TEX2DOBJECT_FOR_COC)
+            return _MainTex.SampleLevel(sampler_MainTex, uv, 0.0);
+        #else
+            return tex2Dlod(_MainTex, float4(uv, 0.0, 0.0));
+        #endif
+        }
+
+        inline half2 GetBilinearFetchTexOffsetFromAbsCoc(half4 absCoc)
+        {
+            half4 cocWeights = absCoc * absCoc * absCoc;
+
+            half2 offset = 0.0;
+            offset += cocWeights.r * float2(-1.0, 1.0);
+            offset += cocWeights.g * float2( 1.0, 1.0);
+            offset += cocWeights.b * float2( 1.0,-1.0);
+            offset += cocWeights.a * float2(-1.0,-1.0);
+            offset = clamp((half2)-1.0,(half2)1.0, offset);
+            offset *= 0.5;
+            return offset;
+        }
+
+        inline half4 FetchColorAndCocFromMainTex(float2 uv, float2 offsetFromKernelCenter)
+        {
+            // Bilinear
+            half4 fetch =  FetchMainTex(uv);
+
+            // CoC can't be linearly interpolated while doing "scatter and gather" or we will have haloing where coc vary sharply.
+            #if defined(USE_TEX2DOBJECT_FOR_COC)
+                half4 allCoc = _MainTex.GatherAlpha(sampler_MainTex, uv);
+                half cocAB = (abs(allCoc.r) < abs(allCoc.g)) ? allCoc.r : allCoc.g;
+                half cocCD = (abs(allCoc.b) < abs(allCoc.a)) ? allCoc.b : allCoc.a;
+                half coc = (abs(cocAB) < abs(cocCD)) ? cocAB : cocCD;
+            #else
+                // No gather available -> instead point sample the coc from the fartest away texel (not as good).
+                half2 bilinearCenter = floor(uv * _MainTex_TexelSize.zw - 0.5) + 1.0;
+                half2 cocUV = bilinearCenter + 0.5 * sign(offsetFromKernelCenter);
+                half coc = tex2Dlod(_MainTex, float4(cocUV * _MainTex_TexelSize.xy, 0.0, 0.0)).a;
+            #endif
+
+            fetch.a = coc;
+            return fetch;
+        }
+
+        inline half GetCocFromZValue(half d)
+        {
+            d = Linear01Depth(d);
+            half coc = d < _BlurCoe.z
+                ? clamp((_BlurParams.x * d + _BlurParams.y), -1.0, 0.0)
+                : saturate((_BlurParams.z * d + _BlurParams.w));
+            return coc;
+        }
+
+        inline half GetCocFromDepth(half2 uv)
+        {
+        #if defined(USE_TEX2DOBJECT_FOR_COC)
+            half d = _CameraDepthTexture.SampleLevel(sampler_CameraDepthTexture, uv, 0.0);
+        #else
+            half d = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv);
+        #endif
+            return GetCocFromZValue(d);
+        }
+
+    #if (SHADER_TARGET < 50 && !defined(SHADER_API_PSSL))
+        half rcp(half x)
+        {
+            return 1.0 / x;
+        }
+    #endif
+
+        // From http://graphicrants.blogspot.dk/2013/12/tone-mapping.html
+        inline half3 Tonemap(half3 color)
+        {
+        #ifdef USE_LOCAL_TONEMAPPING
+            half a = LOCAL_TONEMAP_START_LUMA;
+            half b = LOCAL_TONEMAP_RANGE_LUMA;
+
+            half luma = max(color.r, max(color.g, color.b));
+            if (luma <= a)
+                return color;
+
+            return color * rcp(luma) * (a * a - b * luma) / (2.0 * a - b - luma);
+        #else
+            return color;
+        #endif
+        }
+
+        inline half3 TonemapInvert(half3 color)
+        {
+        #ifdef USE_LOCAL_TONEMAPPING
+            half a = LOCAL_TONEMAP_START_LUMA;
+            half b = LOCAL_TONEMAP_RANGE_LUMA;
+
+            half luma = max(color.r, max(color.g, color.b));
+            if (luma <= a)
+                return color;
+
+            return color * rcp(luma) * (a * a - (2.0 * a - b) * luma) / (b - luma);
+        #else
+            return color;
+        #endif
+        }
+
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Directional (hexagonal/octogonal) bokeh
+        ///////////////////////////////////////////////////////////////////////////////
+
+        #define SAMPLE_NUM_L    6
+        #define SAMPLE_NUM_M    11
+        #define SAMPLE_NUM_H    16
+
+        inline half4 shapeDirectionalBlur(half2 uv, bool mergePass, int numSample, bool sampleDilatedFG)
+        {
+            half4 centerTap = FetchMainTex(uv);
+            half  fgCoc = centerTap.a;
+            half  fgBlendFromPreviousPass = centerTap.a * _Offsets.z;
+
+            if (sampleDilatedFG)
+            {
+                half2 cocs = tex2Dlod(_SecondTex, half4(uv, 0.0, 0.0)).rg;
+                fgCoc = min(cocs.r, cocs.g);
+                centerTap.a = cocs.g;
+            }
+
+            half bgRadius = smoothstep(0.0, 0.85, centerTap.a) * _BlurCoe.y;
+            half fgRadius = smoothstep(0.0, 0.85, -fgCoc) * _BlurCoe.x;
+            half radius = max(bgRadius, fgRadius);
+
+            if (radius < 1e-2)
+                return half4(centerTap.rgb, (sampleDilatedFG || mergePass) ? fgBlendFromPreviousPass : centerTap.a);
+
+            half radOtherFgRad = radius / (fgRadius + 1e-2);
+            half radOtherBgRad = radius / (bgRadius + 1e-2);
+            half2 range = radius * _MainTex_TexelSize.xy;
+
+            half fgWeight = 1e-3;
+            half bgWeight = 1e-3;
+            half3 fgSum = half3(0.0, 0.0, 0.0);
+            half3 bgSum = half3(0.0, 0.0, 0.0);
+
+            for (int k = 0; k < numSample; k++)
+            {
+                half t = (half)k / half(numSample - 1.0);
+                half2 kVal = lerp(_Offsets.xy, -_Offsets.xy, t);
+                half2 offset = kVal * range;
+                half2 texCoord = uv + offset;
+                half4 sample0 = FetchColorAndCocFromMainTex(texCoord, offset);
+
+                if (sampleDilatedFG)
+                    sample0.a = tex2Dlod(_SecondTex, half4(texCoord, 0.0, 0.0)).g;
+
+                half dist = abs(2.0 * t - 1.0);
+                half distanceFactor = saturate(-0.5 * abs(sample0.a - centerTap.a) * dist + 1.0);
+                half isNear = max(0.0, -sample0.a);
+                half isFar  = max(0.0, sample0.a)  * distanceFactor;
+                isNear *= 1.0 - smoothstep(1.0, 2.0, dist * radOtherFgRad);
+                isFar  *= 1.0 - smoothstep(1.0, 2.0, dist * radOtherBgRad);
+
+                fgWeight += isNear;
+                fgSum += sample0.rgb * isNear;
+                bgWeight += isFar;
+                bgSum += sample0.rgb * isFar;
+            }
+
+            half3 fgColor = fgSum / (fgWeight + 1e-4);
+            half3 bgColor = bgSum / (bgWeight + 1e-4);
+            half bgBlend = saturate(2.0 * bgWeight / numSample);
+            half fgBlend = saturate(2.0 * fgWeight / numSample);
+
+            half3 finalBg = lerp(centerTap.rgb, bgColor, bgBlend);
+            half3 finalColor = lerp(finalBg, fgColor, max(max(0.0 , -centerTap.a), fgBlend));
+
+            if (mergePass)
+                finalColor = min(finalColor, tex2Dlod(_ThirdTex, half4(uv, 0.0, 0.0)).rgb);
+
+            finalColor = lerp(centerTap.rgb, finalColor, saturate(bgBlend + fgBlend));
+            fgBlend = max(fgBlendFromPreviousPass, fgBlend);
+            return half4(finalColor, (sampleDilatedFG || mergePass) ? fgBlend : centerTap.a);
+        }
+
+        half4 fragShapeLowQuality(v2fDepth i) : SV_Target
+        {
+            return shapeDirectionalBlur(i.uv, false, SAMPLE_NUM_L, false);
+        }
+
+        half4 fragShapeLowQualityDilateFg(v2fDepth i) : SV_Target
+        {
+            return shapeDirectionalBlur(i.uv, false, SAMPLE_NUM_L, true);
+        }
+
+        half4 fragShapeLowQualityMerge(v2fDepth i) : SV_Target
+        {
+            return shapeDirectionalBlur(i.uv, true, SAMPLE_NUM_L, false);
+        }
+
+        half4 fragShapeLowQualityMergeDilateFg(v2fDepth i) : SV_Target
+        {
+            return shapeDirectionalBlur(i.uv, true, SAMPLE_NUM_L, true);
+        }
+
+        half4 fragShapeMediumQuality(v2fDepth i) : SV_Target
+        {
+            return shapeDirectionalBlur(i.uv, false, SAMPLE_NUM_M, false);
+        }
+
+        half4 fragShapeMediumQualityDilateFg(v2fDepth i) : SV_Target
+        {
+            return shapeDirectionalBlur(i.uv, false, SAMPLE_NUM_M, true);
+        }
+
+        half4 fragShapeMediumQualityMerge(v2fDepth i) : SV_Target
+        {
+            return shapeDirectionalBlur(i.uv, true, SAMPLE_NUM_M, false);
+        }
+
+        half4 fragShapeMediumQualityMergeDilateFg(v2fDepth i) : SV_Target
+        {
+            return shapeDirectionalBlur(i.uv, true, SAMPLE_NUM_M, true);
+        }
+
+        half4 fragShapeHighQuality(v2fDepth i) : SV_Target
+        {
+            return shapeDirectionalBlur(i.uv, false, SAMPLE_NUM_H, false);
+        }
+
+        half4 fragShapeHighQualityDilateFg(v2fDepth i) : SV_Target
+        {
+            return shapeDirectionalBlur(i.uv, false, SAMPLE_NUM_H, true);
+        }
+
+        half4 fragShapeHighQualityMerge(v2fDepth i) : SV_Target
+        {
+            return shapeDirectionalBlur(i.uv, true, SAMPLE_NUM_H, false);
+        }
+
+        half4 fragShapeHighQualityMergeDilateFg(v2fDepth i) : SV_Target
+        {
+            return shapeDirectionalBlur(i.uv, true, SAMPLE_NUM_H, true);
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Disk Bokeh
+        ///////////////////////////////////////////////////////////////////////////////
+
+        static const half3 DiscBokeh48[48] =
+        {
+            // 48 tap regularly spaced circular kernel (x,y, length)
+            // Fill free to change the shape to try other bokehs style :)
+            half3( 0.99144h, 0.13053h, 1.0h),
+            half3( 0.92388h, 0.38268h, 1.0h),
+            half3( 0.79335h, 0.60876h, 1.0h),
+            half3( 0.60876h, 0.79335h, 1.0h),
+            half3( 0.38268h, 0.92388h, 1.0h),
+            half3( 0.13053h, 0.99144h, 1.0h),
+            half3(-0.13053h, 0.99144h, 1.0h),
+            half3(-0.38268h, 0.92388h, 1.0h),
+            half3(-0.60876h, 0.79335h, 1.0h),
+            half3(-0.79335h, 0.60876h, 1.0h),
+            half3(-0.92388h, 0.38268h, 1.0h),
+            half3(-0.99144h, 0.13053h, 1.0h),
+            half3(-0.99144h,-0.13053h, 1.0h),
+            half3(-0.92388h,-0.38268h, 1.0h),
+            half3(-0.79335h,-0.60876h, 1.0h),
+            half3(-0.60876h,-0.79335h, 1.0h),
+            half3(-0.38268h,-0.92388h, 1.0h),
+            half3(-0.13053h,-0.99144h, 1.0h),
+            half3( 0.13053h,-0.99144h, 1.0h),
+            half3( 0.38268h,-0.92388h, 1.0h),
+            half3( 0.60876h,-0.79335h, 1.0h),
+            half3( 0.79335h,-0.60876h, 1.0h),
+            half3( 0.92388h,-0.38268h, 1.0h),
+            half3( 0.99144h,-0.13053h, 1.0h),
+            half3( 0.64732h, 0.12876h, 0.66h),
+            half3( 0.54877h, 0.36668h, 0.66h),
+            half3( 0.36668h, 0.54877h, 0.66h),
+            half3( 0.12876h, 0.64732h, 0.66h),
+            half3(-0.12876h, 0.64732h, 0.66h),
+            half3(-0.36668h, 0.54877h, 0.66h),
+            half3(-0.54877h, 0.36668h, 0.66h),
+            half3(-0.64732h, 0.12876h, 0.66h),
+            half3(-0.64732h,-0.12876h, 0.66h),
+            half3(-0.54877h,-0.36668h, 0.66h),
+            half3(-0.36668h,-0.54877h, 0.66h),
+            half3(-0.12876h,-0.64732h, 0.66h),
+            half3( 0.12876h,-0.64732h, 0.66h),
+            half3( 0.36668h,-0.54877h, 0.66h),
+            half3( 0.54877h,-0.36668h, 0.66h),
+            half3( 0.64732h,-0.12876h, 0.66h),
+            half3( 0.30488h, 0.12629h, 0.33h),
+            half3( 0.12629h, 0.30488h, 0.33h),
+            half3(-0.12629h, 0.30488h, 0.33h),
+            half3(-0.30488h, 0.12629h, 0.33h),
+            half3(-0.30488h,-0.12629h, 0.33h),
+            half3(-0.12629h,-0.30488h, 0.33h),
+            half3( 0.12629h,-0.30488h, 0.33h),
+            half3( 0.30488h,-0.12629h, 0.33h)
+        };
+
+        inline half4 circleCocBokeh(half2 uv, bool sampleDilatedFG, int increment)
+        {
+            half4 centerTap = FetchMainTex(uv);
+            half  fgCoc = centerTap.a;
+
+            if (sampleDilatedFG)
+                fgCoc = min(tex2Dlod(_SecondTex, half4(uv, 0.0, 0.0)).r, fgCoc);
+
+            half bgRadius = 0.5 * smoothstep(0.0, 0.85, centerTap.a)  * _BlurCoe.y;
+            half fgRadius = 0.5 * smoothstep(0.0, 0.85, -fgCoc) * _BlurCoe.x;
+            half radius = max(bgRadius, fgRadius);
+
+            if (radius < 1e-2)
+                return half4(centerTap.rgb, 0.0);
+
+            half2 poissonScale = radius * _MainTex_TexelSize.xy;
+            half fgWeight = max(0.0,-centerTap.a);
+            half bgWeight = max(0.0, centerTap.a);
+            half3 fgSum = centerTap.rgb * fgWeight;
+            half3 bgSum = centerTap.rgb * bgWeight;
+
+            half radOtherFgRad = radius / (fgRadius + 1e-2);
+            half radOtherBgRad = radius / (bgRadius + 1e-2);
+
+            for (int l = 0; l < 48; l += increment)
+            {
+                half2 sampleUV = uv + DiscBokeh48[l].xy * poissonScale.xy;
+                half4 sample0  = FetchColorAndCocFromMainTex(sampleUV, DiscBokeh48[l].xy);
+
+                half isNear = max(0.0, -sample0.a);
+                half distanceFactor = saturate(-0.5 * abs(sample0.a - centerTap.a) * DiscBokeh48[l].z + 1.0);
+                half isFar = max(0.0, sample0.a)  * distanceFactor;
+                isNear *= 1.0 - smoothstep(1.0, 2.0, DiscBokeh48[l].z * radOtherFgRad);
+                isFar  *= 1.0 - smoothstep(1.0, 2.0, DiscBokeh48[l].z * radOtherBgRad);
+
+                fgWeight += isNear;
+                fgSum += sample0.rgb * isNear;
+                bgWeight += isFar;
+                bgSum += sample0.rgb * isFar;
+            }
+
+            half3 fgColor = fgSum / (fgWeight + 1e-4);
+            half3 bgColor = bgSum / (bgWeight + 1e-4);
+            half bgBlend = saturate(2.0 * bgWeight / 49.0);
+            half fgBlend = saturate(2.0 * fgWeight / 49.0);
+
+            half3 finalBg = lerp(centerTap.rgb, bgColor, bgBlend);
+            half3 finalColor = lerp(finalBg, fgColor, max(max(0.0 , -centerTap.a), fgBlend));
+            half4 returnValue = half4(finalColor, fgBlend);
+
+            return returnValue;
+        }
+
+        half4 fragCircleBlurWithDilatedFg(v2fDepth i) : SV_Target
+        {
+            return circleCocBokeh(i.uv, true, 1);
+        }
+
+        half4 fragCircleBlur(v2fDepth i) : SV_Target
+        {
+            return circleCocBokeh(i.uv, false, 1);
+        }
+
+        half4 fragCircleBlurWithDilatedFgLowQuality(v2fDepth i) : SV_Target
+        {
+            return circleCocBokeh(i.uv, true, 2);
+        }
+
+        half4 fragCircleBlurLowQuality(v2fDepth i) : SV_Target
+        {
+            return circleCocBokeh(i.uv, false, 2);
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Prefilter blur
+        ///////////////////////////////////////////////////////////////////////////////
+
+        #define DISC_PREFILTER_SAMPLE   9
+        static const half2 DiscPrefilter[DISC_PREFILTER_SAMPLE] =
+        {
+            half2(0.01288369,  0.5416069),
+            half2(-0.9192798, -0.09529364),
+            half2( 0.7596578,  0.1922738),
+            half2(  -0.14132, -0.2880242),
+            half2(-0.5249333,  0.7777638),
+            half2(-0.5871695, -0.7403569),
+            half2( 0.3202196, -0.6442268),
+            half2( 0.8553214, -0.3920982),
+            half2( 0.5827708,  0.7599297)
+        };
+
+        half4 fragCocPrefilter(v2fDepth i) : SV_Target
+        {
+            half4 centerTap = FetchMainTex(i.uv);
+            half  radius = 0.33 * 0.5 * (centerTap.a < 0.0
+                ? -(centerTap.a * _BlurCoe.x)
+                :  (centerTap.a * _BlurCoe.y));
+            half2 poissonScale = radius * _MainTex_TexelSize.xy;
+
+            if (radius < 1e-2)
+                return centerTap;
+
+            half  sampleCount = 1.0;
+            half3 sum = centerTap.rgb;
+
+            for (int l = 0; l < DISC_PREFILTER_SAMPLE; l++)
+            {
+                half2 sampleUV = i.uv + DiscPrefilter[l].xy * poissonScale.xy;
+                half4 sample0 = FetchColorAndCocFromMainTex(sampleUV, DiscPrefilter[l].xy);
+                half weight = max(sample0.a * centerTap.a, 0.0);
+                sum += sample0.rgb * weight;
+                sampleCount += weight;
+            }
+
+            half4 returnValue = half4(sum / sampleCount, centerTap.a);
+            return returnValue;
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Final merge and upsample
+        ///////////////////////////////////////////////////////////////////////////////
+
+        inline half4 upSampleConvolved(half2 uv)
+        {
+            half2 convolvedTexelPos    = uv * _Convolved_TexelSize.xy;
+            half2 convolvedTexelCenter = floor( convolvedTexelPos ) + 0.5;
+            half2 convolvedTexelOffsetFromCenter = convolvedTexelPos - convolvedTexelCenter;
+            half2 offsetFromCoc = half2(0.0, 0.0);
+
+        #if defined(USE_TEX2DOBJECT_FOR_COC)
+            half2 cocUV = (convolvedTexelOffsetFromCenter * _Convolved_TexelSize.zw) + uv;
+            half4 coc = _CameraDepthTexture.GatherRed(sampler_CameraDepthTexture, cocUV);
+            coc.r = GetCocFromZValue(coc.r);
+            coc.g = GetCocFromZValue(coc.g);
+            coc.b = GetCocFromZValue(coc.b);
+            coc.a = GetCocFromZValue(coc.a);
+
+            half4 absCoc = abs(coc);
+            offsetFromCoc = GetBilinearFetchTexOffsetFromAbsCoc(absCoc) * 0.5;
+            uv += offsetFromCoc * _Convolved_TexelSize.zw;
+        #endif
+
+            /*
+            // Bicubic upsampling (B-spline) - Uncomment me for higher quality upsampling
+            // Adding offsetFromCoc "antialias" haloing from bright in focus region on dark out of focus region.
+            // However its a hack as we should consider all the COC of the bicubic region and kill the bicubic
+            // interpolation to avoid in any leaking but that would be too expensive, so when this is a problem
+            // one should rather disable bicubic interpolation.
+            half2 f  = convolvedTexelOffsetFromCenter + offsetFromCoc;
+            half2 f2 = f * f;
+            half2 f3 = f * f2;
+
+            half2 w0 = -0.166 * f3 + 0.5 * f2 - 0.5 * f + 0.166;
+            half2 w1 =  0.5   * f3 - f2 + 0.666;
+            half2 w3 =  0.166 * f3;
+            half2 w2 =  1.0 - w0 - w1 - w3;
+
+            half2 s0 = w0 + w1;
+            half2 s1 = w2 + w3;
+            half2 f0 = w1 / s0;
+            half2 f1 = w3 / s1;
+
+            half2 t0 = _Convolved_TexelSize.zw * (convolvedTexelCenter - 1.0 + f0);
+            half2 t1 = _Convolved_TexelSize.zw * (convolvedTexelCenter + 1.0 + f1);
+
+            return tex2Dlod(_SecondTex, half4(t0.x, t0.y, 0.0, 0.0)) * s0.x * s0.y +
+                    tex2Dlod(_SecondTex, half4(t1.x, t0.y, 0.0, 0.0)) * s1.x * s0.y +
+                    tex2Dlod(_SecondTex, half4(t0.x, t1.y, 0.0, 0.0)) * s0.x * s1.y +
+                    tex2Dlod(_SecondTex, half4(t1.x, t1.y, 0.0, 0.0)) * s1.x * s1.y;
+            */
+
+            return tex2Dlod(_SecondTex, half4(uv, 0.0, 0.0));
+        }
+
+        inline half4 dofMerge(half2 uv)
+        {
+            half4 convolvedTap = upSampleConvolved(uv);
+            convolvedTap.rgb = TonemapInvert(convolvedTap.rgb);
+
+            half4 sourceTap = FetchMainTex(uv);
+            half  coc       = GetCocFromDepth(uv);
+
+            coc = (coc * _BlurCoe.y > 1.0) ? coc : 0.0;
+            half blendValue = smoothstep(0.0, 0.33, max(coc, convolvedTap.a));
+            half3 returnValue = lerp(sourceTap.rgb, convolvedTap.rgb, blendValue);
+            return (blendValue < 1e-2) ? sourceTap : half4(returnValue.rgb, sourceTap.a);
+        }
+
+        half4 fragMergeExplicit(v2fDepth i) : SV_Target
+        {
+            return dofMerge(i.uv);
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Downsampling and COC computation
+        ///////////////////////////////////////////////////////////////////////////////
+
+        inline half4 captureCoc(half2 uvColor, half2 uvDepth)
+        {
+            /*****************/
+            /* coc.a | coc.b */
+            /* coc.r | coc.g */
+            /*****************/
+        #if defined(USE_TEX2DOBJECT_FOR_COC)
+            half4 coc = _CameraDepthTexture.GatherRed(sampler_CameraDepthTexture, uvDepth);
+            coc.r = GetCocFromZValue(coc.r);
+            coc.g = GetCocFromZValue(coc.g);
+            coc.b = GetCocFromZValue(coc.b);
+            coc.a = GetCocFromZValue(coc.a);
+        #else
+            half4 coc;
+            coc.r = GetCocFromDepth(uvDepth + _MainTex_TexelSize.xy * half2(-0.25, 0.25));
+            coc.g = GetCocFromDepth(uvDepth + _MainTex_TexelSize.xy * half2( 0.25, 0.25));
+            coc.b = GetCocFromDepth(uvDepth + _MainTex_TexelSize.xy * half2( 0.25,-0.25));
+            coc.a = GetCocFromDepth(uvDepth + _MainTex_TexelSize.xy * half2(-0.25,-0.25));
+        #endif
+
+            half4 absCoc = abs(coc);
+            half2 offset = GetBilinearFetchTexOffsetFromAbsCoc(absCoc) * _MainTex_TexelSize.xy;
+            half4 color = FetchMainTex(uvColor + offset);
+
+            half cocRG = (absCoc.r<absCoc.g)?coc.r:coc.g;
+            half cocBA = (absCoc.b<absCoc.a)?coc.b:coc.a;
+            color.a    = (abs(cocRG)<abs(cocBA))?cocRG:cocBA;
+
+            color.rgb = Tonemap(color);
+
+            return color;
+        }
+
+        half4 fragCaptureCocExplicit(v2f i) : SV_Target
+        {
+            return captureCoc(i.uv, i.uv1);
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Coc visualisation
+        ///////////////////////////////////////////////////////////////////////////////
+
+        inline half4 visualizeCoc(half2 uv)
+        {
+            half coc = GetCocFromDepth(uv);
+            return (coc < 0.0)
+                ? half4(-coc, -coc, 0.0, 1.0)
+                : half4(0.0, coc, coc, 1.0);
+        }
+
+        half4 fragVisualizeCocExplicit(v2fDepth i) : SV_Target
+        {
+            return visualizeCoc(i.uv);
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Foreground blur dilatation
+        ///////////////////////////////////////////////////////////////////////////////
+
+        inline half2 fgCocSourceChannel(half2 uv, bool fromAlpha)
+        {
+            if (fromAlpha)
+                return FetchMainTex(uv).aa;
+            else
+                return FetchMainTex(uv).rg;
+        }
+
+        inline half2 weigthedFGCocBlur(v2fBlur i, bool fromAlpha)
+        {
+            half2 fgCoc00 = fgCocSourceChannel(i.uv.xy  , fromAlpha);
+            half2 fgCoc01 = fgCocSourceChannel(i.uv01.zw, fromAlpha) * 1.0;
+            half2 fgCoc02 = fgCocSourceChannel(i.uv01.xy, fromAlpha) * 1.0;
+            half2 fgCoc03 = fgCocSourceChannel(i.uv23.xy, fromAlpha) * 0.8;
+            half2 fgCoc04 = fgCocSourceChannel(i.uv23.zw, fromAlpha) * 0.8;
+            half2 fgCoc05 = fgCocSourceChannel(i.uv45.xy, fromAlpha) * 0.6;
+            half2 fgCoc06 = fgCocSourceChannel(i.uv45.zw, fromAlpha) * 0.6;
+            half2 fgCoc07 = fgCocSourceChannel(i.uv67.xy, fromAlpha) * 0.4;
+            half2 fgCoc08 = fgCocSourceChannel(i.uv67.zw, fromAlpha) * 0.4;
+            half2 fgCoc09 = fgCocSourceChannel(i.uv89.xy, fromAlpha) * 0.25;
+            half2 fgCoc10 = fgCocSourceChannel(i.uv89.zw, fromAlpha) * 0.25;
+
+            half fgCoc;
+            fgCoc = min(  0.0, fgCoc00.r);
+            fgCoc = min(fgCoc, fgCoc01.r);
+            fgCoc = min(fgCoc, fgCoc02.r);
+            fgCoc = min(fgCoc, fgCoc03.r);
+            fgCoc = min(fgCoc, fgCoc04.r);
+            fgCoc = min(fgCoc, fgCoc05.r);
+            fgCoc = min(fgCoc, fgCoc06.r);
+            fgCoc = min(fgCoc, fgCoc07.r);
+            fgCoc = min(fgCoc, fgCoc08.r);
+            fgCoc = min(fgCoc, fgCoc09.r);
+            fgCoc = min(fgCoc, fgCoc10.r);
+
+            return half2(fgCoc,fgCoc00.g);
+        }
+
+        half4 fragDilateFgCocFromColor(v2fBlur i) : SV_Target
+        {
+            return weigthedFGCocBlur(i, true).xyxy;
+        }
+
+        half4 fragDilateFgCoc(v2fBlur i) : SV_Target
+        {
+            return weigthedFGCocBlur(i, false).xyxy;
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Texture Bokeh related
+        ///////////////////////////////////////////////////////////////////////////////
+
+        half4 fragBlurAlphaWeighted(v2fBlur i) : SV_Target
+        {
+            const half ALPHA_WEIGHT = 2.0;
+            half4 sum = half4(0.0, 0.0, 0.0, 0.0);
+            half w = 0.0;
+            half weights = 0.0;
+            const half G_WEIGHTS[6] = { 1.0, 0.8, 0.675, 0.5, 0.2, 0.075 };
+
+            half4 sampleA = FetchMainTex(i.uv.xy);
+            half4 sampleB = FetchMainTex(i.uv01.xy);
+            half4 sampleC = FetchMainTex(i.uv01.zw);
+            half4 sampleD = FetchMainTex(i.uv23.xy);
+            half4 sampleE = FetchMainTex(i.uv23.zw);
+            half4 sampleF = FetchMainTex(i.uv45.xy);
+            half4 sampleG = FetchMainTex(i.uv45.zw);
+            half4 sampleH = FetchMainTex(i.uv67.xy);
+            half4 sampleI = FetchMainTex(i.uv67.zw);
+            half4 sampleJ = FetchMainTex(i.uv89.xy);
+            half4 sampleK = FetchMainTex(i.uv89.zw);
+
+            w = sampleA.a * G_WEIGHTS[0]; sum += sampleA * w; weights += w;
+            w = saturate(ALPHA_WEIGHT * sampleB.a) * G_WEIGHTS[1]; sum += sampleB * w; weights += w;
+            w = saturate(ALPHA_WEIGHT * sampleC.a) * G_WEIGHTS[1]; sum += sampleC * w; weights += w;
+            w = saturate(ALPHA_WEIGHT * sampleD.a) * G_WEIGHTS[2]; sum += sampleD * w; weights += w;
+            w = saturate(ALPHA_WEIGHT * sampleE.a) * G_WEIGHTS[2]; sum += sampleE * w; weights += w;
+            w = saturate(ALPHA_WEIGHT * sampleF.a) * G_WEIGHTS[3]; sum += sampleF * w; weights += w;
+            w = saturate(ALPHA_WEIGHT * sampleG.a) * G_WEIGHTS[3]; sum += sampleG * w; weights += w;
+            w = saturate(ALPHA_WEIGHT * sampleH.a) * G_WEIGHTS[4]; sum += sampleH * w; weights += w;
+            w = saturate(ALPHA_WEIGHT * sampleI.a) * G_WEIGHTS[4]; sum += sampleI * w; weights += w;
+            w = saturate(ALPHA_WEIGHT * sampleJ.a) * G_WEIGHTS[5]; sum += sampleJ * w; weights += w;
+            w = saturate(ALPHA_WEIGHT * sampleK.a) * G_WEIGHTS[5]; sum += sampleK * w; weights += w;
+
+            sum /= weights + 1e-4;
+
+            sum.a = sampleA.a;
+            if(sampleA.a < 1e-2)
+                sum.rgb = sampleA.rgb;
+
+            return sum;
+        }
+
+        half4 fragBoxBlur(v2f i) : SV_Target
+        {
+            half4 returnValue = FetchMainTex(i.uv1.xy + 0.75 * _MainTex_TexelSize.xy);
+            returnValue += FetchMainTex(i.uv1.xy - 0.75 * _MainTex_TexelSize.xy);
+            returnValue += FetchMainTex(i.uv1.xy + 0.75 * _MainTex_TexelSize.xy * half2(1.0, -1.0));
+            returnValue += FetchMainTex(i.uv1.xy - 0.75 * _MainTex_TexelSize.xy * half2(1.0, -1.0));
+            return returnValue / 4.0;
+        }
+
+    ENDCG
+
+    ///////////////////////////////////////////////////////////////////////////////
+
+    SubShader
+    {
+        Tags { "Name" = "MainSubShader_SM5" }
+        // If adding or removing a pass please also update the fallback subshader below
+
+        ZTest Always Cull Off ZWrite Off Fog { Mode Off } Lighting Off Blend Off
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vertBlurPlusMinus
+                #pragma fragment fragBlurAlphaWeighted
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert_d
+                #pragma fragment fragBoxBlur
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vertBlurPlusMinus
+                #pragma fragment fragDilateFgCocFromColor
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vertBlurPlusMinus
+                #pragma fragment fragDilateFgCoc
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert_d
+                #pragma fragment fragCaptureCocExplicit
+                #pragma target 5.0
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragVisualizeCocExplicit
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragCocPrefilter
+                #pragma target 5.0
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragCircleBlur
+                #pragma target 5.0
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragCircleBlurWithDilatedFg
+                #pragma target 5.0
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragCircleBlurLowQuality
+                #pragma target 5.0
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragCircleBlurWithDilatedFgLowQuality
+                #pragma target 5.0
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vertNoFlip
+                #pragma fragment fragMergeExplicit
+                #pragma target 5.0
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeLowQuality
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeLowQualityDilateFg
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeLowQualityMerge
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeLowQualityMergeDilateFg
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeMediumQuality
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeMediumQualityDilateFg
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeMediumQualityMerge
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeMediumQualityMergeDilateFg
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeHighQuality
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeHighQualityDilateFg
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeHighQualityMerge
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeHighQualityMergeDilateFg
+            ENDCG
+        }
+    }
+
+    SubShader
+    {
+        Tags { "Name" = "FallbackSubShader_SM3" }
+        // If adding or removing a pass please also update the main subshader above
+
+        ZTest Always Cull Off ZWrite Off Fog { Mode Off } Lighting Off Blend Off
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vertBlurPlusMinus
+                #pragma fragment fragBlurAlphaWeighted
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert_d
+                #pragma fragment fragBoxBlur
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vertBlurPlusMinus
+                #pragma fragment fragDilateFgCocFromColor
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vertBlurPlusMinus
+                #pragma fragment fragDilateFgCoc
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert_d
+                #pragma fragment fragCaptureCocExplicit
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragVisualizeCocExplicit
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragCocPrefilter
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragCircleBlur
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragCircleBlurWithDilatedFg
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragCircleBlurLowQuality
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragCircleBlurWithDilatedFgLowQuality
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vertNoFlip
+                #pragma fragment fragMergeExplicit
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeLowQuality
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeLowQualityDilateFg
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeLowQualityMerge
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeLowQualityMergeDilateFg
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeMediumQuality
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeMediumQualityDilateFg
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeMediumQualityMerge
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeMediumQualityMergeDilateFg
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeHighQuality
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeHighQualityDilateFg
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeHighQualityMerge
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragShapeHighQualityMergeDilateFg
+            ENDCG
+        }
+    }
+
+    FallBack Off
+}
diff --git a/Assets/Scripts/ImageEffects/DepthOfField.shader.meta b/Assets/Scripts/ImageEffects/DepthOfField.shader.meta
new file mode 100644
index 0000000..0c5a9a1
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/DepthOfField.shader.meta
@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: bff0e5458fb914f5c9985ba4f09171d2
+timeCreated: 1447081022
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/ImageEffects/HexShape.psd b/Assets/Scripts/ImageEffects/HexShape.psd
new file mode 100644
index 0000000..eef48cb
Binary files /dev/null and b/Assets/Scripts/ImageEffects/HexShape.psd differ
diff --git a/Assets/Scripts/ImageEffects/HexShape.psd.meta b/Assets/Scripts/ImageEffects/HexShape.psd.meta
new file mode 100644
index 0000000..c46144f
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/HexShape.psd.meta
@@ -0,0 +1,55 @@
+fileFormatVersion: 2
+guid: a4cdca73d61814d33ac1587f6c163bca
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    linearTexture: 0
+    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: 64
+  textureSettings:
+    filterMode: -1
+    aniso: 0
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 1
+  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: 0
+  textureType: -1
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/ImageEffects/ImageEffectHelper.cs b/Assets/Scripts/ImageEffects/ImageEffectHelper.cs
new file mode 100644
index 0000000..c1ba9a3
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/ImageEffectHelper.cs
@@ -0,0 +1,67 @@
+using UnityEngine;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace UnityStandardAssets.CinematicEffects
+{
+    public static class ImageEffectHelper
+    {
+        public static bool IsSupported(Shader s, bool needDepth, bool needHdr, MonoBehaviour effect)
+        {
+#if UNITY_EDITOR
+            // Don't check for shader compatibility while it's building as it would disable most effects
+            // on build farms without good-enough gaming hardware.
+            if (!BuildPipeline.isBuildingPlayer)
+            {
+#endif
+                if (s == null || !s.isSupported)
+                {
+                    Debug.LogWarningFormat("Missing shader for image effect {0}", effect);
+                    return false;
+                }
+
+#if UNITY_5_5_OR_NEWER
+                if (!SystemInfo.supportsImageEffects)
+#else
+                if (!SystemInfo.supportsImageEffects || !SystemInfo.supportsRenderTextures)
+#endif
+                {
+                    Debug.LogWarningFormat("Image effects aren't supported on this device ({0})", effect);
+                    return false;
+                }
+
+                if (needDepth && !SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.Depth))
+                {
+                    Debug.LogWarningFormat("Depth textures aren't supported on this device ({0})", effect);
+                    return false;
+                }
+
+                if (needHdr && !SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBHalf))
+                {
+                    Debug.LogWarningFormat("Floating point textures aren't supported on this device ({0})", effect);
+                    return false;
+                }
+#if UNITY_EDITOR
+            }
+#endif
+
+            return true;
+        }
+
+        public static Material CheckShaderAndCreateMaterial(Shader s)
+        {
+            if (s == null || !s.isSupported)
+                return null;
+
+            var material = new Material(s);
+            material.hideFlags = HideFlags.DontSave;
+            return material;
+        }
+
+        public static bool supportsDX11
+        {
+            get { return SystemInfo.graphicsShaderLevel >= 50 && SystemInfo.supportsComputeShaders; }
+        }
+    }
+}
diff --git a/Assets/Scripts/ImageEffects/ImageEffectHelper.cs.meta b/Assets/Scripts/ImageEffects/ImageEffectHelper.cs.meta
new file mode 100644
index 0000000..2e5b46d
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/ImageEffectHelper.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ab6a3f50deeee984c88794eeeb901226
+timeCreated: 1448544124
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/ImageEffects/MedianFilter.shader b/Assets/Scripts/ImageEffects/MedianFilter.shader
new file mode 100644
index 0000000..023ec46
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/MedianFilter.shader
@@ -0,0 +1,164 @@
+// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
+
+Shader "Hidden/DepthOfField/MedianFilter"
+{
+    Properties
+    {
+        _MainTex ("-", 2D) = "black"
+    }
+
+    CGINCLUDE
+
+        #pragma target 3.0
+        #pragma fragmentoption ARB_precision_hint_fastest
+        #include "UnityCG.cginc"
+
+        sampler2D _MainTex;
+        uniform half4 _MainTex_TexelSize;
+        uniform half4 _MainTex_ST;
+        uniform float4 _Offsets;
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Verter Shaders and declaration
+        ///////////////////////////////////////////////////////////////////////////////
+
+        struct v2f
+        {
+            half4 pos  : SV_POSITION;
+            half2 uv   : TEXCOORD0;
+        };
+
+        v2f vert(appdata_img v)
+        {
+            v2f o;
+            o.pos = UnityObjectToClipPos(v.vertex);
+            o.uv = v.texcoord.xy;
+
+        #if UNITY_UV_STARTS_AT_TOP
+            if (_MainTex_TexelSize.y < 0.0)
+            o.uv.y = 1.0 - o.uv.y;
+        #endif
+
+            return o;
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+
+        float4 fragCocMedian3 (v2f i) : SV_Target
+        {
+            // TODO: Use med3 on GCN architecture.
+            half4 A = tex2Dlod(_MainTex, half4(i.uv, 0.0, 0.0));
+            half3 B = tex2Dlod(_MainTex, half4(i.uv + _Offsets.xy * _MainTex_TexelSize.xy, 0.0, 0.0)).rgb;
+            half3 C = tex2Dlod(_MainTex, half4(i.uv - _Offsets.xy * _MainTex_TexelSize.xy, 0.0, 0.0)).rgb;
+
+            half3 minAB = min(A.rgb,B);
+            half3 maxAB = max(A.rgb,B);
+            half3 temp = min(C, maxAB);
+            half3 median = max(minAB, temp);
+
+            return half4(lerp(A.rgb, median, A.a * A.a), A.a);
+        }
+
+        /*/////////////////////////////////////////////////////////////////////////////
+        3x3 Median
+        Morgan McGuire and Kyle Whitson
+        http://graphics.cs.williams.edu
+
+        Copyright (c) Morgan McGuire and Williams College, 2006
+        All rights reserved.
+
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are
+        met:
+
+        Redistributions of source code must retain the above copyright notice,
+        this list of conditions and the following disclaimer.
+
+        Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+        "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+        LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+        A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+        HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+        SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+        LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+        DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+        THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+        (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        */
+        #define s2(a, b)                temp = a; a = min(a, b); b = max(temp, b);
+        #define mn3(a, b, c)            s2(a, b); s2(a, c);
+        #define mx3(a, b, c)            s2(b, c); s2(a, c);
+        #define mnmx3(a, b, c)          mx3(a, b, c); s2(a, b);
+        #define mnmx4(a, b, c, d)       s2(a, b); s2(c, d); s2(a, c); s2(b, d);
+        #define mnmx5(a, b, c, d, e)    s2(a, b); s2(c, d); mn3(a, c, e); mx3(b, d, e);
+        #define mnmx6(a, b, c, d, e, f) s2(a, d); s2(b, e); s2(c, f); mn3(a, b, c); mx3(d, e, f);
+
+        float4 fragCocMedian3x3 (v2f i) : SV_Target
+        {
+            half4 center = tex2Dlod(_MainTex, half4(i.uv + half2(0, 0) * _MainTex_TexelSize.xy,0,0));
+
+            half3 v[9];
+            // Add the pixels which make up our window to the pixel array.
+            v[0] = tex2Dlod(_MainTex, half4(i.uv + half2(-1, -1) * _MainTex_TexelSize.xy, 0, 0)).rgb;
+            v[1] = tex2Dlod(_MainTex, half4(i.uv + half2(-1,  0) * _MainTex_TexelSize.xy, 0, 0)).rgb;
+            v[2] = tex2Dlod(_MainTex, half4(i.uv + half2(-1,  1) * _MainTex_TexelSize.xy, 0, 0)).rgb;
+            v[3] = tex2Dlod(_MainTex, half4(i.uv + half2( 0, -1) * _MainTex_TexelSize.xy, 0, 0)).rgb;
+            v[4] = center.rgb;
+            v[5] = tex2Dlod(_MainTex, half4(i.uv + half2( 0,  1) * _MainTex_TexelSize.xy, 0, 0)).rgb;
+            v[6] = tex2Dlod(_MainTex, half4(i.uv + half2( 1, -1) * _MainTex_TexelSize.xy, 0, 0)).rgb;
+            v[7] = tex2Dlod(_MainTex, half4(i.uv + half2( 1,  0) * _MainTex_TexelSize.xy, 0, 0)).rgb;
+            v[8] = tex2Dlod(_MainTex, half4(i.uv + half2( 1,  1) * _MainTex_TexelSize.xy, 0, 0)).rgb;
+
+            half3 temp;
+            // TODO: use med3 on GCN architecture.
+            // Starting with a subset of size 6, remove the min and max each time
+            mnmx6(v[0], v[1], v[2], v[3], v[4], v[5]);
+            mnmx5(v[1], v[2], v[3], v[4], v[6]);
+            mnmx4(v[2], v[3], v[4], v[7]);
+            mnmx3(v[3], v[4], v[8]);
+
+            return half4(lerp(center.rgb, v[4], center.a*center.a), center.a);
+        }
+
+        #undef s2
+        #undef mn3
+        #undef mx3
+        #undef mnmx3
+        #undef mnmx4
+        #undef mnmx5
+        #undef mnmx6
+
+        ///////////////////////////////////////////////////////////////////////////////
+
+    ENDCG
+
+    SubShader
+    {
+        ZTest Always Cull Off ZWrite Off Fog { Mode Off } Lighting Off Blend Off
+
+        // 0
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragCocMedian3
+            ENDCG
+        }
+
+        // 1
+        Pass
+        {
+            CGPROGRAM
+                #pragma vertex vert
+                #pragma fragment fragCocMedian3x3
+            ENDCG
+        }
+    }
+
+    FallBack Off
+}
diff --git a/Assets/Scripts/ImageEffects/MedianFilter.shader.meta b/Assets/Scripts/ImageEffects/MedianFilter.shader.meta
new file mode 100644
index 0000000..d571e38
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/MedianFilter.shader.meta
@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a058b22d4123add4b807e832604e5e7b
+timeCreated: 1449046205
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/ImageEffects/MinAttribute.cs b/Assets/Scripts/ImageEffects/MinAttribute.cs
new file mode 100644
index 0000000..84e7c1a
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/MinAttribute.cs
@@ -0,0 +1,14 @@
+namespace UnityStandardAssets.CinematicEffects
+{
+    using UnityEngine;
+
+    public sealed class MinAttribute : PropertyAttribute
+    {
+        public readonly float min;
+
+        public MinAttribute(float min)
+        {
+            this.min = min;
+        }
+    }
+}
diff --git a/Assets/Scripts/ImageEffects/MinAttribute.cs.meta b/Assets/Scripts/ImageEffects/MinAttribute.cs.meta
new file mode 100644
index 0000000..0b42bb8
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/MinAttribute.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: b07292ae638766047a6751da7552e566
+timeCreated: 1453220005
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/ImageEffects/RenderTextureUtility.cs b/Assets/Scripts/ImageEffects/RenderTextureUtility.cs
new file mode 100644
index 0000000..ae71657
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/RenderTextureUtility.cs
@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityStandardAssets.CinematicEffects
+{
+    public class RenderTextureUtility
+    {
+        //Temporary render texture handling
+        private List<RenderTexture> m_TemporaryRTs = new List<RenderTexture>();
+
+        public RenderTexture GetTemporaryRenderTexture(int width, int height, int depthBuffer = 0, RenderTextureFormat format = RenderTextureFormat.ARGBHalf, FilterMode filterMode = FilterMode.Bilinear)
+        {
+            var rt = RenderTexture.GetTemporary(width, height, depthBuffer, format);
+            rt.filterMode = filterMode;
+            rt.wrapMode = TextureWrapMode.Clamp;
+            rt.name = "RenderTextureUtilityTempTexture";
+            m_TemporaryRTs.Add(rt);
+            return rt;
+        }
+
+        public void ReleaseTemporaryRenderTexture(RenderTexture rt)
+        {
+            if (rt == null)
+                return;
+
+            if (!m_TemporaryRTs.Contains(rt))
+            {
+                Debug.LogErrorFormat("Attempting to remove texture that was not allocated: {0}", rt);
+                return;
+            }
+
+            m_TemporaryRTs.Remove(rt);
+            RenderTexture.ReleaseTemporary(rt);
+        }
+
+        public void ReleaseAllTemporaryRenderTextures()
+        {
+            for (int i = 0; i < m_TemporaryRTs.Count; ++i)
+                RenderTexture.ReleaseTemporary(m_TemporaryRTs[i]);
+
+            m_TemporaryRTs.Clear();
+        }
+    }
+}
diff --git a/Assets/Scripts/ImageEffects/RenderTextureUtility.cs.meta b/Assets/Scripts/ImageEffects/RenderTextureUtility.cs.meta
new file mode 100644
index 0000000..6de4df1
--- /dev/null
+++ b/Assets/Scripts/ImageEffects/RenderTextureUtility.cs.meta
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 054e694bae00c374a97c2bc495fca66b
+timeCreated: 1449148391
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: