Merge remote-tracking branch 'refs/remotes/Unity-Technologies/master'

keijiro · keijiro · commit 0854a600e2eb · 2017-03-14T18:04:44.000+09:00
diff --git a/PostProcessing/Editor/Models/EyeAdaptationModelEditor.cs b/PostProcessing/Editor/Models/EyeAdaptationModelEditor.cs
@@ -12,7 +12,8 @@ public class EyeAdaptationModelEditor : PostProcessingModelEditor
         SerializedProperty m_HighPercent;
         SerializedProperty m_MinLuminance;
         SerializedProperty m_MaxLuminance;
-        SerializedProperty m_ExposureCompensation;
+        SerializedProperty m_KeyValue;
+        SerializedProperty m_DynamicKeyValue;
         SerializedProperty m_AdaptationType;
         SerializedProperty m_SpeedUp;
         SerializedProperty m_SpeedDown;
@@ -25,7 +26,8 @@ public override void OnEnable()
             m_HighPercent = FindSetting((Settings x) => x.highPercent);
             m_MinLuminance = FindSetting((Settings x) => x.minLuminance);
             m_MaxLuminance = FindSetting((Settings x) => x.maxLuminance);
-            m_ExposureCompensation = FindSetting((Settings x) => x.exposureCompensation);
+            m_KeyValue = FindSetting((Settings x) => x.keyValue);
+            m_DynamicKeyValue = FindSetting((Settings x) => x.dynamicKeyValue);
             m_AdaptationType = FindSetting((Settings x) => x.adaptationType);
             m_SpeedUp = FindSetting((Settings x) => x.speedUp);
             m_SpeedDown = FindSetting((Settings x) => x.speedDown);
@@ -36,27 +38,39 @@ public override void OnEnable()
         public override void OnInspectorGUI()
         {
             if (!GraphicsUtils.supportsDX11)
-            {
                 EditorGUILayout.HelpBox("This effect requires support for compute shaders. Enabling it won't do anything on unsupported platforms.", MessageType.Warning);
-            }
 
-            EditorGUILayout.PropertyField(m_LogMin, EditorGUIHelper.GetContent("Histogram Log Min"));
-            EditorGUILayout.PropertyField(m_LogMax, EditorGUIHelper.GetContent("Histogram Log Max"));
+            EditorGUILayout.LabelField("Luminosity range", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(m_LogMin, EditorGUIHelper.GetContent("Minimum (EV)"));
+            EditorGUILayout.PropertyField(m_LogMax, EditorGUIHelper.GetContent("Maximum (EV)"));
+            EditorGUI.indentLevel--;
             EditorGUILayout.Space();
 
+            EditorGUILayout.LabelField("Auto exposure", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
             float low = m_LowPercent.floatValue;
             float high = m_HighPercent.floatValue;
 
-            EditorGUILayout.MinMaxSlider(EditorGUIHelper.GetContent("Filter|These values are the lower and upper percentages of the histogram that will be used to find a stable average luminance. Values outside of this range will be discarded and won't contribute to the average luminance."), ref low, ref high, 1f, 99f);
+            EditorGUILayout.MinMaxSlider(EditorGUIHelper.GetContent("Histogram filtering|These values are the lower and upper percentages of the histogram that will be used to find a stable average luminance. Values outside of this range will be discarded and won't contribute to the average luminance."), ref low, ref high, 1f, 99f);
 
             m_LowPercent.floatValue = low;
             m_HighPercent.floatValue = high;
 
-            EditorGUILayout.PropertyField(m_MinLuminance);
-            EditorGUILayout.PropertyField(m_MaxLuminance);
-            EditorGUILayout.PropertyField(m_ExposureCompensation);
+            EditorGUILayout.PropertyField(m_MinLuminance, EditorGUIHelper.GetContent("Minimum (EV)"));
+            EditorGUILayout.PropertyField(m_MaxLuminance, EditorGUIHelper.GetContent("Maximum (EV)"));
+            EditorGUILayout.PropertyField(m_DynamicKeyValue);
 
-            EditorGUILayout.PropertyField(m_AdaptationType);
+            if (!m_DynamicKeyValue.boolValue)
+                EditorGUILayout.PropertyField(m_KeyValue);
+
+            EditorGUI.indentLevel--;
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField("Adaptation", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+
+            EditorGUILayout.PropertyField(m_AdaptationType, EditorGUIHelper.GetContent("Type"));
 
             if (m_AdaptationType.intValue == (int)EyeAdaptationModel.EyeAdaptationType.Progressive)
             {
@@ -65,6 +79,8 @@ public override void OnInspectorGUI()
                 EditorGUILayout.PropertyField(m_SpeedDown);
                 EditorGUI.indentLevel--;
             }
+
+            EditorGUI.indentLevel--;
         }
     }
 }
diff --git a/PostProcessing/Editor/Models/VignetteModelEditor.cs b/PostProcessing/Editor/Models/VignetteModelEditor.cs
@@ -17,6 +17,7 @@ public class VignetteModelEditor : PostProcessingModelEditor
         SerializedProperty m_Roundness;
         SerializedProperty m_Mask;
         SerializedProperty m_Opacity;
+        SerializedProperty m_Rounded;
 
         public override void OnEnable()
         {
@@ -28,21 +29,21 @@ public override void OnEnable()
             m_Roundness = FindSetting((Settings x) => x.roundness);
             m_Mask = FindSetting((Settings x) => x.mask);
             m_Opacity = FindSetting((Settings x) => x.opacity);
+            m_Rounded = FindSetting((Settings x) => x.rounded);
         }
 
         public override void OnInspectorGUI()
         {
             EditorGUILayout.PropertyField(m_Mode);
             EditorGUILayout.PropertyField(m_Color);
 
-            if (m_Mode.intValue <= (int)VignetteMode.Round)
+            if (m_Mode.intValue < (int)VignetteMode.Masked)
             {
                 EditorGUILayout.PropertyField(m_Center);
                 EditorGUILayout.PropertyField(m_Intensity);
                 EditorGUILayout.PropertyField(m_Smoothness);
-
-                if (m_Mode.intValue == (int)VignetteMode.Classic)
-                    EditorGUILayout.PropertyField(m_Roundness);
+                EditorGUILayout.PropertyField(m_Roundness);
+                EditorGUILayout.PropertyField(m_Rounded);
             }
             else
             {
diff --git a/PostProcessing/Resources/Shaders/Bloom.shader b/PostProcessing/Resources/Shaders/Bloom.shader
@@ -79,11 +79,7 @@ Shader "Hidden/Post FX/Bloom"
         {
             float autoExposure = 1.0;
             uv = UnityStereoScreenSpaceUVAdjust(uv, _MainTex_ST);
-
-        #if EYE_ADAPTATION
             autoExposure = tex2D(_AutoExposure, uv).r;
-        #endif
-
             return tex2D(tex, uv) * autoExposure;
         }
 
@@ -151,7 +147,6 @@ Shader "Hidden/Post FX/Bloom"
         Pass
         {
             CGPROGRAM
-                #pragma multi_compile __ EYE_ADAPTATION
                 #pragma multi_compile __ ANTI_FLICKER
                 #pragma multi_compile __ UNITY_COLORSPACE_GAMMA
                 #pragma vertex VertDefault
diff --git a/PostProcessing/Resources/Shaders/EyeAdaptation.shader b/PostProcessing/Resources/Shaders/EyeAdaptation.shader
@@ -8,6 +8,7 @@ Shader "Hidden/Post FX/Eye Adaptation"
     CGINCLUDE
 
         #pragma target 4.5
+        #pragma multi_compile __ AUTO_KEY_VALUE
         #include "UnityCG.cginc"
         #include "Common.cginc"
         #include "EyeAdaptation.cginc"
@@ -86,8 +87,12 @@ Shader "Hidden/Post FX/Eye Adaptation"
         {
             avgLuminance = max(EPSILON, avgLuminance);
 
-            //half keyValue = 1.03 - (2.0 / (2.0 + log2(avgLuminance + 1.0)));
+        #if AUTO_KEY_VALUE
+            half keyValue = 1.03 - (2.0 / (2.0 + log2(avgLuminance + 1.0)));
+        #else
             half keyValue = _ExposureCompensation;
+        #endif
+
             half exposure = keyValue / avgLuminance;
 
             return exposure;
diff --git a/PostProcessing/Resources/Shaders/TAA.cginc b/PostProcessing/Resources/Shaders/TAA.cginc
@@ -10,8 +10,6 @@
 // -----------------------------------------------------------------------------
 // Solver
 
-#define TAA_USE_GATHER4_FOR_DEPTH_SAMPLE (SHADER_TARGET >= 41)
-
 #define TAA_USE_STABLE_BUT_GHOSTY_VARIANT 0
 
 #if !defined(TAA_DILATE_MOTION_VECTOR_SAMPLE)
@@ -39,13 +37,7 @@ struct OutputSolver
 sampler2D _HistoryTex;
 
 sampler2D _CameraMotionVectorsTexture;
-
-#if TAA_USE_GATHER4_FOR_DEPTH_SAMPLE
-Texture2D _CameraDepthTexture;
-SamplerState sampler_CameraDepthTexture;
-#else
 sampler2D _CameraDepthTexture;
-#endif
 
 float4 _HistoryTex_TexelSize;
 float4 _CameraDepthTexture_TexelSize;
@@ -74,20 +66,14 @@ VaryingsSolver VertSolver(AttributesDefault input)
 float2 GetClosestFragment(float2 uv)
 {
     const float2 k = _CameraDepthTexture_TexelSize.xy;
-
-#if TAA_USE_GATHER4_FOR_DEPTH_SAMPLE
-    const float4 neighborhood = _CameraDepthTexture.Gather(sampler_CameraDepthTexture, uv, int2(1, 1));
-    float3 result = float3(0.0, 0.0, _CameraDepthTexture.Sample(sampler_CameraDepthTexture, uv).r);
-#else
     const float4 neighborhood = float4(
         SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv - k),
         SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv + float2(k.x, -k.y)),
         SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv + float2(-k.x, k.y)),
         SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv + k)
         );
-    float3 result = float3(0.0, 0.0, SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv));
-#endif
 
+    float3 result = float3(0.0, 0.0, SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv));
     result = lerp(result, float3(-1.0, -1.0, neighborhood.x), step(neighborhood.x, result.z));
     result = lerp(result, float3( 1.0, -1.0, neighborhood.y), step(neighborhood.y, result.z));
     result = lerp(result, float3(-1.0,  1.0, neighborhood.z), step(neighborhood.z, result.z));
diff --git a/PostProcessing/Resources/Shaders/Uber.shader b/PostProcessing/Resources/Shaders/Uber.shader
@@ -19,14 +19,13 @@ Shader "Hidden/Post FX/Uber Shader"
         #pragma target 3.0
 
         #pragma multi_compile __ UNITY_COLORSPACE_GAMMA
-        #pragma multi_compile __ EYE_ADAPTATION
         #pragma multi_compile __ CHROMATIC_ABERRATION
         #pragma multi_compile __ DEPTH_OF_FIELD DEPTH_OF_FIELD_COC_VIEW
         #pragma multi_compile __ BLOOM BLOOM_LENS_DIRT
         #pragma multi_compile __ COLOR_GRADING COLOR_GRADING_LOG_VIEW
         #pragma multi_compile __ USER_LUT
         #pragma multi_compile __ GRAIN
-        #pragma multi_compile __ VIGNETTE_CLASSIC VIGNETTE_ROUND VIGNETTE_MASKED
+        #pragma multi_compile __ VIGNETTE_CLASSIC VIGNETTE_MASKED
         #pragma multi_compile __ DITHERING
 
         #include "UnityCG.cginc"
@@ -67,7 +66,7 @@ Shader "Hidden/Post FX/Uber Shader"
         // Vignette
         half3 _Vignette_Color;
         half2 _Vignette_Center; // UV space
-        half3 _Vignette_Settings; // x: intensity, y: smoothness, z: roundness
+        half4 _Vignette_Settings; // x: intensity, y: smoothness, z: roundness, w: rounded
         sampler2D _Vignette_Mask;
         half _Vignette_Opacity; // [0;1]
 
@@ -101,14 +100,7 @@ Shader "Hidden/Post FX/Uber Shader"
         half4 FragUber(VaryingsFlipped i) : SV_Target
         {
             float2 uv = i.uv;
-            half autoExposure = 1.0;
-
-            // Store the auto exposure value for later
-            #if EYE_ADAPTATION
-            {
-                autoExposure = tex2D(_AutoExposure, uv).r;
-            }
-            #endif
+            half autoExposure = tex2D(_AutoExposure, uv).r;
 
             half3 color = (0.0).xxx;
             #if DEPTH_OF_FIELD && CHROMATIC_ABERRATION
@@ -235,20 +227,12 @@ Shader "Hidden/Post FX/Uber Shader"
             #if VIGNETTE_CLASSIC
             {
                 half2 d = abs(uv - _Vignette_Center) * _Vignette_Settings.x;
+                d.x *= lerp(1.0, _ScreenParams.x / _ScreenParams.y, _Vignette_Settings.w);
                 d = pow(d, _Vignette_Settings.z); // Roundness
                 half vfactor = pow(saturate(1.0 - dot(d, d)), _Vignette_Settings.y);
                 color *= lerp(_Vignette_Color, (1.0).xxx, vfactor);
             }
 
-            // Perfectly round vignette
-            #elif VIGNETTE_ROUND
-            {
-                half2 d = abs(uv - _Vignette_Center) * _Vignette_Settings.x;
-                d.x *= _ScreenParams.x / _ScreenParams.y;
-                half vfactor = pow(saturate(1.0 - dot(d, d)), _Vignette_Settings.y);
-                color *= lerp(_Vignette_Color, (1.0).xxx, vfactor);
-            }
-
             // Masked vignette
             #elif VIGNETTE_MASKED
             {
diff --git a/PostProcessing/Runtime/Components/BloomComponent.cs b/PostProcessing/Runtime/Components/BloomComponent.cs
@@ -37,12 +37,8 @@ public void Prepare(RenderTexture source, Material uberMaterial, Texture autoExp
             var material = context.materialFactory.Get("Hidden/Post FX/Bloom");
             material.shaderKeywords = null;
 
-            // Apply auto exposure before the prefiltering pass if needed
-            if (autoExposure != null)
-            {
-                material.EnableKeyword("EYE_ADAPTATION");
-                material.SetTexture(Uniforms._AutoExposure, autoExposure);
-            }
+            // Apply auto exposure before the prefiltering pass
+            material.SetTexture(Uniforms._AutoExposure, autoExposure);
 
             // Do bloom on a half-res buffer, full-res doesn't bring much and kills performances on
             // fillrate limited platforms
diff --git a/PostProcessing/Runtime/Components/EyeAdaptationComponent.cs b/PostProcessing/Runtime/Components/EyeAdaptationComponent.cs
@@ -84,6 +84,7 @@ public Texture Prepare(RenderTexture source, Material uberMaterial)
                 m_EyeCompute = Resources.Load<ComputeShader>("Shaders/EyeHistogram");
 
             var material = context.materialFactory.Get("Hidden/Post FX/Eye Adaptation");
+            material.shaderKeywords = null;
 
             if (m_HistogramBuffer == null)
                 m_HistogramBuffer = new ComputeBuffer(k_HistogramBins, sizeof(uint));
@@ -124,10 +125,13 @@ public Texture Prepare(RenderTexture source, Material uberMaterial)
 
             // Compute auto exposure
             material.SetBuffer("_Histogram", m_HistogramBuffer); // No (int, buffer) overload for SetBuffer ?
-            material.SetVector(Uniforms._Params, new Vector4(settings.lowPercent * 0.01f, settings.highPercent * 0.01f, settings.minLuminance, settings.maxLuminance));
+            material.SetVector(Uniforms._Params, new Vector4(settings.lowPercent * 0.01f, settings.highPercent * 0.01f, Mathf.Exp(settings.minLuminance * 0.69314718055994530941723212145818f), Mathf.Exp(settings.maxLuminance * 0.69314718055994530941723212145818f)));
             material.SetVector(Uniforms._Speed, new Vector2(settings.speedDown, settings.speedUp));
             material.SetVector(Uniforms._ScaleOffsetRes, scaleOffsetRes);
-            material.SetFloat(Uniforms._ExposureCompensation, settings.exposureCompensation);
+            material.SetFloat(Uniforms._ExposureCompensation, settings.keyValue);
+
+            if (settings.dynamicKeyValue)
+                material.EnableKeyword("AUTO_KEY_VALUE");
 
             if (m_FirstFrame || !Application.isPlaying)
             {
@@ -149,10 +153,6 @@ public Texture Prepare(RenderTexture source, Material uberMaterial)
                 m_CurrentAutoExposure = dst;
             }
 
-            // Uber setup
-            uberMaterial.EnableKeyword("EYE_ADAPTATION");
-            uberMaterial.SetTexture(Uniforms._AutoExposure, m_CurrentAutoExposure);
-
             // Generate debug histogram
             if (context.profile.debugViews.IsModeActive(BuiltinDebugViewsModel.Mode.EyeAdaptation))
             {
diff --git a/PostProcessing/Runtime/Components/FogComponent.cs b/PostProcessing/Runtime/Components/FogComponent.cs
@@ -22,6 +22,7 @@ public override bool active
             {
                 return model.enabled
                        && context.isGBufferAvailable // In forward fog is already done at shader level
+                       && RenderSettings.fog
                        && !context.interrupted;
             }
         }
diff --git a/PostProcessing/Runtime/Components/VignetteComponent.cs b/PostProcessing/Runtime/Components/VignetteComponent.cs
@@ -30,13 +30,7 @@ public override void Prepare(Material uberMaterial)
                 uberMaterial.SetVector(Uniforms._Vignette_Center, settings.center);
                 uberMaterial.EnableKeyword("VIGNETTE_CLASSIC");
                 float roundness = (1f - settings.roundness) * 6f + settings.roundness;
-                uberMaterial.SetVector(Uniforms._Vignette_Settings, new Vector3(settings.intensity * 3f, settings.smoothness * 5f, roundness));
-            }
-            else if (settings.mode == VignetteModel.Mode.Round)
-            {
-                uberMaterial.SetVector(Uniforms._Vignette_Center, settings.center);
-                uberMaterial.EnableKeyword("VIGNETTE_ROUND");
-                uberMaterial.SetVector(Uniforms._Vignette_Settings, new Vector3(settings.intensity * 3f, settings.smoothness * 5f, 1f));
+                uberMaterial.SetVector(Uniforms._Vignette_Settings, new Vector4(settings.intensity * 3f, settings.smoothness * 5f, roundness, settings.rounded ? 1f : 0f));
             }
             else if (settings.mode == VignetteModel.Mode.Masked)
             {
diff --git a/PostProcessing/Runtime/Models/EyeAdaptationModel.cs b/PostProcessing/Runtime/Models/EyeAdaptationModel.cs
@@ -20,14 +20,17 @@ public struct Settings
             [Range(1f, 99f), Tooltip("Filters the bright part of the histogram when computing the average luminance to avoid very dark pixels from contributing to the auto exposure. Unit is in percent.")]
             public float highPercent;
 
-            [Min(0f), Tooltip("Minimum average luminance to consider for auto exposure.")]
+            [Tooltip("Minimum average luminance to consider for auto exposure (in EV).")]
             public float minLuminance;
 
-            [Min(0f), Tooltip("Maximum average luminance to consider for auto exposure.")]
+            [Tooltip("Maximum average luminance to consider for auto exposure (in EV).")]
             public float maxLuminance;
 
             [Min(0f), Tooltip("Exposure bias. Use this to control the global exposure of the scene.")]
-            public float exposureCompensation;
+            public float keyValue;
+
+            [Tooltip("Set this to true to let Unity handle the key value automatically based on average luminance.")]
+            public bool dynamicKeyValue;
 
             [Tooltip("Use \"Progressive\" if you want the auto exposure to be animated. Use \"Fixed\" otherwise.")]
             public EyeAdaptationType adaptationType;
@@ -38,10 +41,10 @@ public struct Settings
             [Min(0f), Tooltip("Adaptation speed from a light to a dark environment.")]
             public float speedDown;
 
-            [Range(-16, -1), Tooltip("Lower bound for the brightness range of the generated histogram (Log2).")]
+            [Range(-16, -1), Tooltip("Lower bound for the brightness range of the generated histogram (in EV). The bigger the spread between min & max, the lower the precision will be.")]
             public int logMin;
 
-            [Range(1, 16), Tooltip("Upper bound for the brightness range of the generated histogram (Log2).")]
+            [Range(1, 16), Tooltip("Upper bound for the brightness range of the generated histogram (in EV). The bigger the spread between min & max, the lower the precision will be.")]
             public int logMax;
 
             public static Settings defaultSettings
@@ -50,12 +53,13 @@ public static Settings defaultSettings
                 {
                     return new Settings
                     {
-                        lowPercent = 65f,
+                        lowPercent = 45f,
                         highPercent = 95f,
 
-                        minLuminance = 0.03f,
-                        maxLuminance = 2f,
-                        exposureCompensation = 0.5f,
+                        minLuminance = -5f,
+                        maxLuminance = 1f,
+                        keyValue = 0.25f,
+                        dynamicKeyValue = true,
 
                         adaptationType = EyeAdaptationType.Progressive,
                         speedUp = 2f,
diff --git a/PostProcessing/Runtime/Models/VignetteModel.cs b/PostProcessing/Runtime/Models/VignetteModel.cs
diff --git a/PostProcessing/Runtime/PostProcessingBehaviour.cs b/PostProcessing/Runtime/PostProcessingBehaviour.cs
diff --git a/PostProcessing/Runtime/Utils/GraphicsUtils.cs b/PostProcessing/Runtime/Utils/GraphicsUtils.cs
diff --git a/PostProcessing/Utilities/CustomMotionTexture/Shaders/CustomMotionVectorTexture.shader b/PostProcessing/Utilities/CustomMotionTexture/Shaders/CustomMotionVectorTexture.shader

Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ public class VignetteModelEditor : PostProcessingModelEditor`
`17`	`17`	`SerializedProperty m_Roundness;`
`18`	`18`	`SerializedProperty m_Mask;`
`19`	`19`	`SerializedProperty m_Opacity;`
	`20`	`+ SerializedProperty m_Rounded;`
`20`	`21`
`21`	`22`	`public override void OnEnable()`
`22`	`23`	`{`
`@@ -28,21 +29,21 @@ public override void OnEnable()`
`28`	`29`	`m_Roundness = FindSetting((Settings x) => x.roundness);`
`29`	`30`	`m_Mask = FindSetting((Settings x) => x.mask);`
`30`	`31`	`m_Opacity = FindSetting((Settings x) => x.opacity);`
	`32`	`+ m_Rounded = FindSetting((Settings x) => x.rounded);`
`31`	`33`	`}`
`32`	`34`
`33`	`35`	`public override void OnInspectorGUI()`
`34`	`36`	`{`
`35`	`37`	`EditorGUILayout.PropertyField(m_Mode);`
`36`	`38`	`EditorGUILayout.PropertyField(m_Color);`
`37`	`39`
`38`		`- if (m_Mode.intValue <= (int)VignetteMode.Round)`
	`40`	`+ if (m_Mode.intValue < (int)VignetteMode.Masked)`
`39`	`41`	`{`
`40`	`42`	`EditorGUILayout.PropertyField(m_Center);`
`41`	`43`	`EditorGUILayout.PropertyField(m_Intensity);`
`42`	`44`	`EditorGUILayout.PropertyField(m_Smoothness);`
`43`		`-`
`44`		`- if (m_Mode.intValue == (int)VignetteMode.Classic)`
`45`		`- EditorGUILayout.PropertyField(m_Roundness);`
	`45`	`+ EditorGUILayout.PropertyField(m_Roundness);`
	`46`	`+ EditorGUILayout.PropertyField(m_Rounded);`
`46`	`47`	`}`
`47`	`48`	`else`
`48`	`49`	`{`
Original file line number	Diff line number	Diff line change
`@@ -79,11 +79,7 @@ Shader "Hidden/Post FX/Bloom"`
`79`	`79`	`{`
`80`	`80`	`float autoExposure = 1.0;`
`81`	`81`	`uv = UnityStereoScreenSpaceUVAdjust(uv, _MainTex_ST);`
`82`		`-`
`83`		`- #if EYE_ADAPTATION`
`84`	`82`	`autoExposure = tex2D(_AutoExposure, uv).r;`
`85`		`- #endif`
`86`		`-`
`87`	`83`	`return tex2D(tex, uv) * autoExposure;`
`88`	`84`	`}`
`89`	`85`
`@@ -151,7 +147,6 @@ Shader "Hidden/Post FX/Bloom"`
`151`	`147`	`Pass`
`152`	`148`	`{`
`153`	`149`	`CGPROGRAM`
`154`		`- #pragma multi_compile __ EYE_ADAPTATION`
`155`	`150`	`#pragma multi_compile __ ANTI_FLICKER`
`156`	`151`	`#pragma multi_compile __ UNITY_COLORSPACE_GAMMA`
`157`	`152`	`#pragma vertex VertDefault`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ public override bool active`
`22`	`22`	`{`
`23`	`23`	`return model.enabled`
`24`	`24`	`&& context.isGBufferAvailable // In forward fog is already done at shader level`
	`25`	`+ && RenderSettings.fog`
`25`	`26`	`&& !context.interrupted;`
`26`	`27`	`}`
`27`	`28`	`}`