Merge pull request #101 from Unity-Technologies/simple-fog

Simple fog

Author: Chman

PostProcessing/Editor/Models/FogModelEditor.cs

@@ -0,0 +1,47 @@
+using UnityEngine;
+using UnityEngine.PostProcessing;
+
+namespace UnityEditor.PostProcessing
+{
+    using Settings = FogModel.Settings;
+
+    [PostProcessingModelEditor(typeof(FogModel))]
+    public class FogModelEditor : PostProcessingModelEditor
+    {
+        SerializedProperty m_Color;
+        SerializedProperty m_Mode;
+        SerializedProperty m_Density;
+        SerializedProperty m_Start;
+        SerializedProperty m_End;
+        SerializedProperty m_ExcludeSkybox;
+
+        public override void OnEnable()
+        {
+            m_Color = FindSetting((Settings x) => x.color);
+            m_Mode = FindSetting((Settings x) => x.mode);
+            m_Density = FindSetting((Settings x) => x.density);
+            m_Start = FindSetting((Settings x) => x.start);
+            m_End = FindSetting((Settings x) => x.end);
+            m_ExcludeSkybox = FindSetting((Settings x) => x.excludeSkybox);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.PropertyField(m_Color);
+            EditorGUILayout.PropertyField(m_ExcludeSkybox);
+            EditorGUILayout.PropertyField(m_Mode);
+
+            EditorGUI.indentLevel++;
+            if (m_Mode.intValue == (int)FogMode.Linear)
+            {
+                EditorGUILayout.PropertyField(m_Start);
+                EditorGUILayout.PropertyField(m_End);
+            }
+            else
+            {
+                EditorGUILayout.PropertyField(m_Density);
+            }
+            EditorGUI.indentLevel--;
+        }
+    }
+}

PostProcessing/Editor/Models/FogModelEditor.cs.meta

@@ -0,0 +1,109 @@
+Shader "Hidden/Post FX/Fog"
+{
+    Properties
+    {
+        _MainTex("Main Texture", 2D) = "white" {}
+    }
+
+    CGINCLUDE
+
+        #pragma multi_compile __ FOG_LINEAR FOG_EXP FOG_EXP2
+        #include "UnityCG.cginc"
+        #include "Common.cginc"
+
+        #define SKYBOX_THREASHOLD_VALUE 0.9999
+
+        struct Varyings
+        {
+            float2 uv : TEXCOORD0;
+            float4 vertex : SV_POSITION;
+        };
+
+        Varyings VertFog(AttributesDefault v)
+        {
+            Varyings o;
+            o.vertex = UnityObjectToClipPos(v.vertex);
+            o.uv = UnityStereoScreenSpaceUVAdjust(v.texcoord, _MainTex_ST);
+            return o;
+        }
+
+        sampler2D _CameraDepthTexture;
+
+        half4 _FogColor;
+        float _Density;
+        float _Start;
+        float _End;
+
+        half ComputeFog(float z)
+        {
+            half fog = 0.0;
+        #if FOG_LINEAR
+            fog = (_End - z) / (_End - _Start);
+        #elif FOG_EXP
+            fog = exp2(-_Density * z);
+        #else // FOG_EXP2
+            fog = _Density * z;
+            fog = exp2(-fog * fog);
+        #endif
+            return saturate(fog);
+        }
+
+        float ComputeDistance(float depth)
+        {
+            float dist = depth * _ProjectionParams.z;
+            dist -= _ProjectionParams.y;
+            return dist;
+        }
+
+        half4 FragFog(Varyings i) : SV_Target
+        {
+            half4 color = tex2D(_MainTex, i.uv);
+
+            float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv);
+            depth = Linear01Depth(depth);
+            float dist = ComputeDistance(depth) - _Start;
+            half fog = 1.0 - ComputeFog(dist);
+
+            return lerp(color, _FogColor, fog);
+        }
+
+        half4 FragFogExcludeSkybox(Varyings i) : SV_Target
+        {
+            half4 color = tex2D(_MainTex, i.uv);
+
+            float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv);
+            depth = Linear01Depth(depth);
+            float skybox = depth < SKYBOX_THREASHOLD_VALUE;
+            float dist = ComputeDistance(depth) - _Start;
+            half fog = 1.0 - ComputeFog(dist);
+
+            return lerp(color, _FogColor, fog * skybox);
+        }
+
+    ENDCG
+
+    SubShader
+    {
+        Cull Off ZWrite Off ZTest Always
+
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex VertFog
+                #pragma fragment FragFog
+
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex VertFog
+                #pragma fragment FragFogExcludeSkybox
+
+            ENDCG
+        }
+    }
+}

PostProcessing/Resources/Shaders/Fog.shader

@@ -0,0 +1,91 @@
+using System;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.PostProcessing
+{
+    public sealed class FogComponent : PostProcessingComponentCommandBuffer<FogModel>
+    {
+        static class Uniforms
+        {
+            internal static readonly int _FogColor = Shader.PropertyToID("_FogColor");
+            internal static readonly int _Density  = Shader.PropertyToID("_Density");
+            internal static readonly int _Start    = Shader.PropertyToID("_Start");
+            internal static readonly int _End      = Shader.PropertyToID("_End");
+            internal static readonly int _TempRT   = Shader.PropertyToID("_TempRT");
+        }
+
+        const string k_ShaderString = "Hidden/Post FX/Fog";
+
+        public override bool active
+        {
+            get
+            {
+                return model.enabled
+                       && context.isGBufferAvailable // In forward fog is already done at shader level
+                       && !context.interrupted;
+            }
+        }
+
+        public override string GetName()
+        {
+            return "Fog";
+        }
+
+        public override DepthTextureMode GetCameraFlags()
+        {
+            return DepthTextureMode.Depth;
+        }
+
+        public override CameraEvent GetCameraEvent()
+        {
+            return CameraEvent.BeforeImageEffectsOpaque;
+        }
+
+        public override void Init(PostProcessingContext pcontext, FogModel pmodel)
+        {
+            base.Init(pcontext, pmodel);
+
+            var settings = model.settings;
+            RenderSettings.fog = model.enabled;
+            RenderSettings.fogColor = settings.color;
+            RenderSettings.fogMode = settings.mode;
+            RenderSettings.fogDensity = settings.density;
+            RenderSettings.fogStartDistance = settings.start;
+            RenderSettings.fogEndDistance = settings.end;
+        }
+
+        public override void PopulateCommandBuffer(CommandBuffer cb)
+        {
+            var settings = model.settings;
+
+            var material = context.materialFactory.Get(k_ShaderString);
+            material.shaderKeywords = null;
+            material.SetColor(Uniforms._FogColor, settings.color);
+            material.SetFloat(Uniforms._Density, settings.density);
+            material.SetFloat(Uniforms._Start, settings.start);
+            material.SetFloat(Uniforms._End, settings.end);
+
+            switch (settings.mode)
+            {
+                case FogMode.Linear:
+                    material.EnableKeyword("FOG_LINEAR");
+                    break;
+                case FogMode.Exponential:
+                    material.EnableKeyword("FOG_EXP");
+                    break;
+                case FogMode.ExponentialSquared:
+                    material.EnableKeyword("FOG_EXP2");
+                    break;
+            }
+
+            var fbFormat = context.isHdr
+                ? RenderTextureFormat.DefaultHDR
+                : RenderTextureFormat.Default;
+
+            cb.GetTemporaryRT(Uniforms._TempRT, context.width, context.height, 24, FilterMode.Bilinear, fbFormat);
+            cb.Blit(BuiltinRenderTextureType.CameraTarget, Uniforms._TempRT);
+            cb.Blit(Uniforms._TempRT, BuiltinRenderTextureType.CameraTarget, material, settings.excludeSkybox ? 1 : 0);
+            cb.ReleaseTemporaryRT(Uniforms._TempRT);
+        }
+    }
+}

PostProcessing/Resources/Shaders/Fog.shader.meta

@@ -0,0 +1,59 @@
+using System;
+
+namespace UnityEngine.PostProcessing
+{
+    [Serializable]
+    public class FogModel : PostProcessingModel
+    {
+        [Serializable]
+        public struct Settings
+        {
+            [Tooltip("Controls the color of that fog drawn in the scene.")]
+            public Color color;
+
+            [Tooltip("Controls the mathematical function determining the way fog accumulates with distance from the camera. Options are Linear, Exponential and Exponential Squared.")]
+            public FogMode mode;
+
+            [Tooltip("Controls the density of the fog effect in the Scene when using Exponential or Exponential Squared modes.")]
+            public float density;
+
+            [Tooltip("Controls the distance from the camera where the fog will start in the scene.")]
+            public float start;
+
+            [Tooltip("Controls the distance from the camera where the fog will completely obscure objects in the Scene.")]
+            public float end;
+
+            [Tooltip("Should the fog affect the skybox?")]
+            public bool excludeSkybox;
+
+            public static Settings defaultSettings
+            {
+                get
+                {
+                    return new Settings
+                    {
+                        color = new Color32(102, 108, 113, 154),
+                        mode = FogMode.Exponential,
+                        density = 0.001f,
+                        start = 0f,
+                        end = 600f,
+                        excludeSkybox = true
+                    };
+                }
+            }
+        }
+
+        [SerializeField]
+        Settings m_Settings = Settings.defaultSettings;
+        public Settings settings
+        {
+            get { return m_Settings; }
+            set { m_Settings = value; }
+        }
+
+        public override void Reset()
+        {
+            m_Settings = Settings.defaultSettings;
+        }
+    }
+}

PostProcessing/Runtime/Components/FogComponent.cs

@@ -36,6 +36,7 @@ public class PostProcessingBehaviour : MonoBehaviour
         BuiltinDebugViewsComponent m_DebugViews;
         AmbientOcclusionComponent m_AmbientOcclusion;
         ScreenSpaceReflectionComponent m_ScreenSpaceReflection;
+        FogComponent m_FogComponent;
         MotionBlurComponent m_MotionBlur;
         TaaComponent m_Taa;
         EyeAdaptationComponent m_EyeAdaptation;
@@ -63,6 +64,7 @@ void OnEnable()
             m_DebugViews = AddComponent(new BuiltinDebugViewsComponent());
             m_AmbientOcclusion = AddComponent(new AmbientOcclusionComponent());
             m_ScreenSpaceReflection = AddComponent(new ScreenSpaceReflectionComponent());
+            m_FogComponent = AddComponent(new FogComponent());
             m_MotionBlur = AddComponent(new MotionBlurComponent());
             m_Taa = AddComponent(new TaaComponent());
             m_EyeAdaptation = AddComponent(new EyeAdaptationComponent());
@@ -117,6 +119,7 @@ void OnPreCull()
             m_DebugViews.Init(context, profile.debugViews);
             m_AmbientOcclusion.Init(context, profile.ambientOcclusion);
             m_ScreenSpaceReflection.Init(context, profile.screenSpaceReflection);
+            m_FogComponent.Init(context, profile.fog);
             m_MotionBlur.Init(context, profile.motionBlur);
             m_Taa.Init(context, profile.antialiasing);
             m_EyeAdaptation.Init(context, profile.eyeAdaptation);
@@ -167,6 +170,7 @@ void OnPreRender()
             TryExecuteCommandBuffer(m_DebugViews);
             TryExecuteCommandBuffer(m_AmbientOcclusion);
             TryExecuteCommandBuffer(m_ScreenSpaceReflection);
+            TryExecuteCommandBuffer(m_FogComponent);
 
             if (!m_RenderingInSceneView)
                 TryExecuteCommandBuffer(m_MotionBlur);

PostProcessing/Runtime/Components/FogComponent.cs.meta

@@ -27,7 +27,7 @@ public abstract class PostProcessingComponent<T> : PostProcessingComponentBase
     {
         public T model { get; internal set; }
 
-        public void Init(PostProcessingContext pcontext, T pmodel)
+        public virtual void Init(PostProcessingContext pcontext, T pmodel)
         {
             context = pcontext;
             model = pmodel;