Merge pull request #108 from Unity-Technologies/variant-reduction

Chman · web-flow · commit 35d0b5defab1 · 2017-03-09T15:14:56.000+01:00
Reduced the amount of variants
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/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
@@ -149,10 +149,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/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/VignetteModel.cs b/PostProcessing/Runtime/Models/VignetteModel.cs
@@ -8,7 +8,6 @@ public class VignetteModel : PostProcessingModel
         public enum Mode
         {
             Classic,
-            Round,
             Masked
         }
 
@@ -40,6 +39,9 @@ public struct Settings
             [Range(0f, 1f), Tooltip("Mask opacity.")]
             public float opacity;
 
+            [Tooltip("Should the vignette be perfectly round or be dependent on the current aspect ratio?")]
+            public bool rounded;
+
             public static Settings defaultSettings
             {
                 get
@@ -53,7 +55,8 @@ public static Settings defaultSettings
                         smoothness = 0.2f,
                         roundness = 1f,
                         mask = null,
-                        opacity = 1f
+                        opacity = 1f,
+                        rounded = false
                     };
                 }
             }
diff --git a/PostProcessing/Runtime/PostProcessingBehaviour.cs b/PostProcessing/Runtime/PostProcessingBehaviour.cs
@@ -220,13 +220,15 @@ void OnRenderImage(RenderTexture source, RenderTexture destination)
                 dst = m_RenderTextureFactory.Get(src);
 #endif
 
-            Texture autoExposure = null;
+            Texture autoExposure = GraphicsUtils.whiteTexture;
             if (m_EyeAdaptation.active)
             {
                 uberActive = true;
                 autoExposure = m_EyeAdaptation.Prepare(src, uberMaterial);
             }
 
+            uberMaterial.SetTexture("_AutoExposure", autoExposure);
+
             if (dofActive)
             {
                 uberActive = true;
diff --git a/PostProcessing/Runtime/Utils/GraphicsUtils.cs b/PostProcessing/Runtime/Utils/GraphicsUtils.cs
@@ -18,6 +18,22 @@ public static bool supportsDX11
 #endif
         }
 
+        static Texture2D s_WhiteTexture;
+        public static Texture2D whiteTexture
+        {
+            get
+            {
+                if (s_WhiteTexture != null)
+                    return s_WhiteTexture;
+
+                s_WhiteTexture = new Texture2D(1, 1, TextureFormat.ARGB32, false);
+                s_WhiteTexture.SetPixel(0, 0, new Color(1f, 1f, 1f, 1f));
+                s_WhiteTexture.Apply();
+
+                return s_WhiteTexture;
+            }
+        }
+
         static Mesh s_Quad;
         public static Mesh quad
         {

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
`@@ -149,10 +149,6 @@ public Texture Prepare(RenderTexture source, Material uberMaterial)`
`149`	`149`	`m_CurrentAutoExposure = dst;`
`150`	`150`	`}`
`151`	`151`
`152`		`- // Uber setup`
`153`		`- uberMaterial.EnableKeyword("EYE_ADAPTATION");`
`154`		`- uberMaterial.SetTexture(Uniforms._AutoExposure, m_CurrentAutoExposure);`
`155`		`-`
`156`	`152`	`// Generate debug histogram`
`157`	`153`	`if (context.profile.debugViews.IsModeActive(BuiltinDebugViewsModel.Mode.EyeAdaptation))`
`158`	`154`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,6 @@ public class VignetteModel : PostProcessingModel`
`8`	`8`	`public enum Mode`
`9`	`9`	`{`
`10`	`10`	`Classic,`
`11`		`- Round,`
`12`	`11`	`Masked`
`13`	`12`	`}`
`14`	`13`
`@@ -40,6 +39,9 @@ public struct Settings`
`40`	`39`	`[Range(0f, 1f), Tooltip("Mask opacity.")]`
`41`	`40`	`public float opacity;`
`42`	`41`
	`42`	`+ [Tooltip("Should the vignette be perfectly round or be dependent on the current aspect ratio?")]`
	`43`	`+ public bool rounded;`
	`44`	`+`
`43`	`45`	`public static Settings defaultSettings`
`44`	`46`	`{`
`45`	`47`	`get`
`@@ -53,7 +55,8 @@ public static Settings defaultSettings`
`53`	`55`	`smoothness = 0.2f,`
`54`	`56`	`roundness = 1f,`
`55`	`57`	`mask = null,`
`56`		`- opacity = 1f`
	`58`	`+ opacity = 1f,`
	`59`	`+ rounded = false`
`57`	`60`	`};`
`58`	`61`	`}`
`59`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -220,13 +220,15 @@ void OnRenderImage(RenderTexture source, RenderTexture destination)`
`220`	`220`	`dst = m_RenderTextureFactory.Get(src);`
`221`	`221`	`#endif`
`222`	`222`
`223`		`- Texture autoExposure = null;`
	`223`	`+ Texture autoExposure = GraphicsUtils.whiteTexture;`
`224`	`224`	`if (m_EyeAdaptation.active)`
`225`	`225`	`{`
`226`	`226`	`uberActive = true;`
`227`	`227`	`autoExposure = m_EyeAdaptation.Prepare(src, uberMaterial);`
`228`	`228`	`}`
`229`	`229`
	`230`	`+ uberMaterial.SetTexture("_AutoExposure", autoExposure);`
	`231`	`+`
`230`	`232`	`if (dofActive)`
`231`	`233`	`{`
`232`	`234`	`uberActive = true;`