同步最新svn内容

leonard Wu

2018-08-09 a10eea6e4ce647061813519d5b0ea496f29495b9

 Assets/Plugins/PostProcessing/Runtime/PostProcessingBehaviour.cs

@@ -1,475 +1,475 @@
using System;
using System.Collections.Generic;
using UnityEngine.Rendering;

namespace UnityEngine.PostProcessing
{
    using DebugMode = BuiltinDebugViewsModel.Mode;

#if UNITY_5_4_OR_NEWER
    [ImageEffectAllowedInSceneView]
#endif
    [RequireComponent(typeof(Camera)), DisallowMultipleComponent, ExecuteInEditMode]
    [AddComponentMenu("Effects/Post-Processing Behaviour", -1)]
    public class PostProcessingBehaviour : MonoBehaviour
    {
        // Inspector fields
        public PostProcessingProfile profile;

        public Func<Vector2, Matrix4x4> jitteredMatrixFunc;

        // Internal helpers
        Dictionary<Type, KeyValuePair<CameraEvent, CommandBuffer>> m_CommandBuffers;
        List<PostProcessingComponentBase> m_Components;
        Dictionary<PostProcessingComponentBase, bool> m_ComponentStates;

        MaterialFactory m_MaterialFactory;
        RenderTextureFactory m_RenderTextureFactory;
        PostProcessingContext m_Context;
        Camera m_Camera;
        PostProcessingProfile m_PreviousProfile;

        bool m_RenderingInSceneView = false;

        // Effect components
        BuiltinDebugViewsComponent m_DebugViews;
        AmbientOcclusionComponent m_AmbientOcclusion;
        ScreenSpaceReflectionComponent m_ScreenSpaceReflection;
        FogComponent m_FogComponent;
        MotionBlurComponent m_MotionBlur;
        TaaComponent m_Taa;
        EyeAdaptationComponent m_EyeAdaptation;
        DepthOfFieldComponent m_DepthOfField;
        BloomComponent m_Bloom;
        ChromaticAberrationComponent m_ChromaticAberration;
        ColorGradingComponent m_ColorGrading;
        UserLutComponent m_UserLut;
        GrainComponent m_Grain;
        VignetteComponent m_Vignette;
        DitheringComponent m_Dithering;
        FxaaComponent m_Fxaa;

        void OnEnable()
        {
            m_CommandBuffers = new Dictionary<Type, KeyValuePair<CameraEvent, CommandBuffer>>();
            m_MaterialFactory = new MaterialFactory();
            m_RenderTextureFactory = new RenderTextureFactory();
            m_Context = new PostProcessingContext();

            // Keep a list of all post-fx for automation purposes
            m_Components = new List<PostProcessingComponentBase>();

            // Component list
            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());
            m_DepthOfField = AddComponent(new DepthOfFieldComponent());
            m_Bloom = AddComponent(new BloomComponent());
            m_ChromaticAberration = AddComponent(new ChromaticAberrationComponent());
            m_ColorGrading = AddComponent(new ColorGradingComponent());
            m_UserLut = AddComponent(new UserLutComponent());
            m_Grain = AddComponent(new GrainComponent());
            m_Vignette = AddComponent(new VignetteComponent());
            m_Dithering = AddComponent(new DitheringComponent());
            m_Fxaa = AddComponent(new FxaaComponent());

            // Prepare state observers
            m_ComponentStates = new Dictionary<PostProcessingComponentBase, bool>();

            foreach (var component in m_Components)
                m_ComponentStates.Add(component, false);

            useGUILayout = false;
        }

        void OnPreCull()
        {
            // All the per-frame initialization logic has to be done in OnPreCull instead of Update
            // because [ImageEffectAllowedInSceneView] doesn't trigger Update events...

            m_Camera = GetComponent<Camera>();

            if (profile == null || m_Camera == null)
                return;

#if UNITY_EDITOR
            // Track the scene view camera to disable some effects we don't want to see in the
            // scene view
            // Currently disabled effects :
            //  - Temporal Antialiasing
            //  - Depth of Field
            //  - Motion blur
            m_RenderingInSceneView = UnityEditor.SceneView.currentDrawingSceneView != null
                && UnityEditor.SceneView.currentDrawingSceneView.camera == m_Camera;
#endif

            // Prepare context
            var context = m_Context.Reset();
            context.profile = profile;
            context.renderTextureFactory = m_RenderTextureFactory;
            context.materialFactory = m_MaterialFactory;
            context.camera = m_Camera;

            // Prepare components
            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);
            m_DepthOfField.Init(context, profile.depthOfField);
            m_Bloom.Init(context, profile.bloom);
            m_ChromaticAberration.Init(context, profile.chromaticAberration);
            m_ColorGrading.Init(context, profile.colorGrading);
            m_UserLut.Init(context, profile.userLut);
            m_Grain.Init(context, profile.grain);
            m_Vignette.Init(context, profile.vignette);
            m_Dithering.Init(context, profile.dithering);
            m_Fxaa.Init(context, profile.antialiasing);

            // Handles profile change and 'enable' state observers
            if (m_PreviousProfile != profile)
            {
                DisableComponents();
                m_PreviousProfile = profile;
            }

            CheckObservers();

            // Find out which camera flags are needed before rendering begins
            // Note that motion vectors will only be available one frame after being enabled
            var flags = context.camera.depthTextureMode;
            foreach (var component in m_Components)
            {
                if (component.active)
                    flags |= component.GetCameraFlags();
            }

            context.camera.depthTextureMode = flags;

            // Temporal antialiasing jittering, needs to happen before culling
            if (!m_RenderingInSceneView && m_Taa.active && !profile.debugViews.willInterrupt)
                m_Taa.SetProjectionMatrix(jitteredMatrixFunc);
        }

        void OnPreRender()
        {
            if (profile == null)
                return;

            // Command buffer-based effects should be set-up here
            TryExecuteCommandBuffer(m_DebugViews);
            TryExecuteCommandBuffer(m_AmbientOcclusion);
            TryExecuteCommandBuffer(m_ScreenSpaceReflection);
            TryExecuteCommandBuffer(m_FogComponent);

            if (!m_RenderingInSceneView)
                TryExecuteCommandBuffer(m_MotionBlur);
        }

        void OnPostRender()
        {
            if (profile == null || m_Camera == null)
                return;

            if (!m_RenderingInSceneView && m_Taa.active && !profile.debugViews.willInterrupt)
                m_Context.camera.ResetProjectionMatrix();
        }

        // Classic render target pipeline for RT-based effects
        void OnRenderImage(RenderTexture source, RenderTexture destination)
        {
            if (profile == null || m_Camera == null)
            {
                Graphics.Blit(source, destination);
                return;
            }

            // Uber shader setup
            bool uberActive = false;
            bool fxaaActive = m_Fxaa.active;
            bool taaActive = m_Taa.active && !m_RenderingInSceneView;
            bool dofActive = m_DepthOfField.active && !m_RenderingInSceneView;

            var uberMaterial = m_MaterialFactory.Get("Hidden/Post FX/Uber Shader");
            uberMaterial.shaderKeywords = null;

            var src = source;
            var dst = destination;

            if (taaActive)
            {
                var tempRT = m_RenderTextureFactory.Get(src);
                m_Taa.Render(src, tempRT);
                src = tempRT;
            }

#if UNITY_EDITOR
            // Render to a dedicated target when monitors are enabled so they can show information
            // about the final render.
            // At runtime the output will always be the backbuffer or whatever render target is
            // currently set on the camera.
            if (profile.monitors.onFrameEndEditorOnly != null)
                dst = m_RenderTextureFactory.Get(src);
#endif

            Texture autoExposure = GraphicsUtils.whiteTexture;
            if (m_EyeAdaptation.active)
            {
                uberActive = true;
                autoExposure = m_EyeAdaptation.Prepare(src, uberMaterial);
            }

            uberMaterial.SetTexture("_AutoExposure", autoExposure);

            if (dofActive)
            {
                uberActive = true;
                m_DepthOfField.Prepare(src, uberMaterial, taaActive, m_Taa.jitterVector, m_Taa.model.settings.taaSettings.motionBlending);
            }

            if (m_Bloom.active)
            {
                uberActive = true;
                m_Bloom.Prepare(src, uberMaterial, autoExposure);
            }

            uberActive |= TryPrepareUberImageEffect(m_ChromaticAberration, uberMaterial);
            uberActive |= TryPrepareUberImageEffect(m_ColorGrading, uberMaterial);
            uberActive |= TryPrepareUberImageEffect(m_Vignette, uberMaterial);
            uberActive |= TryPrepareUberImageEffect(m_UserLut, uberMaterial);

            var fxaaMaterial = fxaaActive
                ? m_MaterialFactory.Get("Hidden/Post FX/FXAA")
                : null;

            if (fxaaActive)
            {
                fxaaMaterial.shaderKeywords = null;
                TryPrepareUberImageEffect(m_Grain, fxaaMaterial);
                TryPrepareUberImageEffect(m_Dithering, fxaaMaterial);

                if (uberActive)
                {
                    var output = m_RenderTextureFactory.Get(src);
                    Graphics.Blit(src, output, uberMaterial, 0);
                    src = output;
                }

                m_Fxaa.Render(src, dst);
            }
            else
            {
                uberActive |= TryPrepareUberImageEffect(m_Grain, uberMaterial);
                uberActive |= TryPrepareUberImageEffect(m_Dithering, uberMaterial);

                if (uberActive)
                {
                    if (!GraphicsUtils.isLinearColorSpace)
                        uberMaterial.EnableKeyword("UNITY_COLORSPACE_GAMMA");

                    Graphics.Blit(src, dst, uberMaterial, 0);
                }
            }

            if (!uberActive && !fxaaActive)
                Graphics.Blit(src, dst);

#if UNITY_EDITOR
            if (profile.monitors.onFrameEndEditorOnly != null)
            {
                Graphics.Blit(dst, destination);

                var oldRt = RenderTexture.active;
                profile.monitors.onFrameEndEditorOnly(dst);
                RenderTexture.active = oldRt;
            }
#endif

            m_RenderTextureFactory.ReleaseAll();
        }

        void OnGUI()
        {
            if (!this.enabled)
            {
                return;
            }

            if (Event.current.type != EventType.Repaint)
                return;

            if (profile == null || m_Camera == null)
                return;

            if (m_EyeAdaptation.active && profile.debugViews.IsModeActive(DebugMode.EyeAdaptation))
                m_EyeAdaptation.OnGUI();
            else if (m_ColorGrading.active && profile.debugViews.IsModeActive(DebugMode.LogLut))
                m_ColorGrading.OnGUI();
            else if (m_UserLut.active && profile.debugViews.IsModeActive(DebugMode.UserLut))
                m_UserLut.OnGUI();
        }

        void OnDisable()
        {
            // Clear command buffers
            foreach (var cb in m_CommandBuffers.Values)
            {
                m_Camera.RemoveCommandBuffer(cb.Key, cb.Value);
                cb.Value.Dispose();
            }

            m_CommandBuffers.Clear();

            // Clear components
            if (profile != null)
                DisableComponents();

            m_Components.Clear();

            // Factories
            m_MaterialFactory.Dispose();
            m_RenderTextureFactory.Dispose();
            GraphicsUtils.Dispose();
        }

        public void ResetTemporalEffects()
        {
            m_Taa.ResetHistory();
            m_MotionBlur.ResetHistory();
            m_EyeAdaptation.ResetHistory();
        }

        #region State management

        List<PostProcessingComponentBase> m_ComponentsToEnable = new List<PostProcessingComponentBase>();
        List<PostProcessingComponentBase> m_ComponentsToDisable = new List<PostProcessingComponentBase>();

        void CheckObservers()
        {
            foreach (var cs in m_ComponentStates)
            {
                var component = cs.Key;
                var state = component.GetModel().enabled;

                if (state != cs.Value)
                {
                    if (state) m_ComponentsToEnable.Add(component);
                    else m_ComponentsToDisable.Add(component);
                }
            }

            for (int i = 0; i < m_ComponentsToDisable.Count; i++)
            {
                var c = m_ComponentsToDisable[i];
                m_ComponentStates[c] = false;
                c.OnDisable();
            }

            for (int i = 0; i < m_ComponentsToEnable.Count; i++)
            {
                var c = m_ComponentsToEnable[i];
                m_ComponentStates[c] = true;
                c.OnEnable();
            }

            m_ComponentsToDisable.Clear();
            m_ComponentsToEnable.Clear();
        }

        void DisableComponents()
        {
            foreach (var component in m_Components)
            {
                var model = component.GetModel();
                if (model != null && model.enabled)
                    component.OnDisable();
            }
        }

        #endregion

        #region Command buffer handling & rendering helpers
        // Placeholders before the upcoming Scriptable Render Loop as command buffers will be
        // executed on the go so we won't need of all that stuff
        CommandBuffer AddCommandBuffer<T>(CameraEvent evt, string name)
            where T : PostProcessingModel
        {
            var cb = new CommandBuffer { name = name };
            var kvp = new KeyValuePair<CameraEvent, CommandBuffer>(evt, cb);
            m_CommandBuffers.Add(typeof(T), kvp);
            m_Camera.AddCommandBuffer(evt, kvp.Value);
            return kvp.Value;
        }

        void RemoveCommandBuffer<T>()
            where T : PostProcessingModel
        {
            KeyValuePair<CameraEvent, CommandBuffer> kvp;
            var type = typeof(T);

            if (!m_CommandBuffers.TryGetValue(type, out kvp))
                return;

            m_Camera.RemoveCommandBuffer(kvp.Key, kvp.Value);
            m_CommandBuffers.Remove(type);
            kvp.Value.Dispose();
        }

        CommandBuffer GetCommandBuffer<T>(CameraEvent evt, string name)
            where T : PostProcessingModel
        {
            CommandBuffer cb;
            KeyValuePair<CameraEvent, CommandBuffer> kvp;

            if (!m_CommandBuffers.TryGetValue(typeof(T), out kvp))
            {
                cb = AddCommandBuffer<T>(evt, name);
            }
            else if (kvp.Key != evt)
            {
                RemoveCommandBuffer<T>();
                cb = AddCommandBuffer<T>(evt, name);
            }
            else cb = kvp.Value;

            return cb;
        }

        void TryExecuteCommandBuffer<T>(PostProcessingComponentCommandBuffer<T> component)
            where T : PostProcessingModel
        {
            if (component.active)
            {
                var cb = GetCommandBuffer<T>(component.GetCameraEvent(), component.GetName());
                cb.Clear();
                component.PopulateCommandBuffer(cb);
            }
            else RemoveCommandBuffer<T>();
        }

        bool TryPrepareUberImageEffect<T>(PostProcessingComponentRenderTexture<T> component, Material material)
            where T : PostProcessingModel
        {
            if (!component.active)
                return false;

            component.Prepare(material);
            return true;
        }

        T AddComponent<T>(T component)
            where T : PostProcessingComponentBase
        {
            m_Components.Add(component);
            return component;
        }

        #endregion
    }
}
using System;

using System.Collections.Generic;

using UnityEngine.Rendering;



namespace UnityEngine.PostProcessing

{

    using DebugMode = BuiltinDebugViewsModel.Mode;



#if UNITY_5_4_OR_NEWER

    [ImageEffectAllowedInSceneView]

#endif

    [RequireComponent(typeof(Camera)), DisallowMultipleComponent, ExecuteInEditMode]

    [AddComponentMenu("Effects/Post-Processing Behaviour", -1)]

    public class PostProcessingBehaviour : MonoBehaviour

    {

        // Inspector fields

        public PostProcessingProfile profile;



        public Func<Vector2, Matrix4x4> jitteredMatrixFunc;



        // Internal helpers

        Dictionary<Type, KeyValuePair<CameraEvent, CommandBuffer>> m_CommandBuffers;

        List<PostProcessingComponentBase> m_Components;

        Dictionary<PostProcessingComponentBase, bool> m_ComponentStates;



        MaterialFactory m_MaterialFactory;

        RenderTextureFactory m_RenderTextureFactory;

        PostProcessingContext m_Context;

        Camera m_Camera;

        PostProcessingProfile m_PreviousProfile;



        bool m_RenderingInSceneView = false;



        // Effect components

        BuiltinDebugViewsComponent m_DebugViews;

        AmbientOcclusionComponent m_AmbientOcclusion;

        ScreenSpaceReflectionComponent m_ScreenSpaceReflection;

        FogComponent m_FogComponent;

        MotionBlurComponent m_MotionBlur;

        TaaComponent m_Taa;

        EyeAdaptationComponent m_EyeAdaptation;

        DepthOfFieldComponent m_DepthOfField;

        BloomComponent m_Bloom;

        ChromaticAberrationComponent m_ChromaticAberration;

        ColorGradingComponent m_ColorGrading;

        UserLutComponent m_UserLut;

        GrainComponent m_Grain;

        VignetteComponent m_Vignette;

        DitheringComponent m_Dithering;

        FxaaComponent m_Fxaa;



        void OnEnable()

        {

            m_CommandBuffers = new Dictionary<Type, KeyValuePair<CameraEvent, CommandBuffer>>();

            m_MaterialFactory = new MaterialFactory();

            m_RenderTextureFactory = new RenderTextureFactory();

            m_Context = new PostProcessingContext();



            // Keep a list of all post-fx for automation purposes

            m_Components = new List<PostProcessingComponentBase>();



            // Component list

            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());

            m_DepthOfField = AddComponent(new DepthOfFieldComponent());

            m_Bloom = AddComponent(new BloomComponent());

            m_ChromaticAberration = AddComponent(new ChromaticAberrationComponent());

            m_ColorGrading = AddComponent(new ColorGradingComponent());

            m_UserLut = AddComponent(new UserLutComponent());

            m_Grain = AddComponent(new GrainComponent());

            m_Vignette = AddComponent(new VignetteComponent());

            m_Dithering = AddComponent(new DitheringComponent());

            m_Fxaa = AddComponent(new FxaaComponent());



            // Prepare state observers

            m_ComponentStates = new Dictionary<PostProcessingComponentBase, bool>();



            foreach (var component in m_Components)

                m_ComponentStates.Add(component, false);



            useGUILayout = false;

        }



        void OnPreCull()

        {

            // All the per-frame initialization logic has to be done in OnPreCull instead of Update

            // because [ImageEffectAllowedInSceneView] doesn't trigger Update events...



            m_Camera = GetComponent<Camera>();



            if (profile == null || m_Camera == null)

                return;



#if UNITY_EDITOR

            // Track the scene view camera to disable some effects we don't want to see in the

            // scene view

            // Currently disabled effects :

            //  - Temporal Antialiasing

            //  - Depth of Field

            //  - Motion blur

            m_RenderingInSceneView = UnityEditor.SceneView.currentDrawingSceneView != null

                && UnityEditor.SceneView.currentDrawingSceneView.camera == m_Camera;

#endif



            // Prepare context

            var context = m_Context.Reset();

            context.profile = profile;

            context.renderTextureFactory = m_RenderTextureFactory;

            context.materialFactory = m_MaterialFactory;

            context.camera = m_Camera;



            // Prepare components

            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);

            m_DepthOfField.Init(context, profile.depthOfField);

            m_Bloom.Init(context, profile.bloom);

            m_ChromaticAberration.Init(context, profile.chromaticAberration);

            m_ColorGrading.Init(context, profile.colorGrading);

            m_UserLut.Init(context, profile.userLut);

            m_Grain.Init(context, profile.grain);

            m_Vignette.Init(context, profile.vignette);

            m_Dithering.Init(context, profile.dithering);

            m_Fxaa.Init(context, profile.antialiasing);



            // Handles profile change and 'enable' state observers

            if (m_PreviousProfile != profile)

            {

                DisableComponents();

                m_PreviousProfile = profile;

            }



            CheckObservers();



            // Find out which camera flags are needed before rendering begins

            // Note that motion vectors will only be available one frame after being enabled

            var flags = context.camera.depthTextureMode;

            foreach (var component in m_Components)

            {

                if (component.active)

                    flags |= component.GetCameraFlags();

            }



            context.camera.depthTextureMode = flags;



            // Temporal antialiasing jittering, needs to happen before culling

            if (!m_RenderingInSceneView && m_Taa.active && !profile.debugViews.willInterrupt)

                m_Taa.SetProjectionMatrix(jitteredMatrixFunc);

        }



        void OnPreRender()

        {

            if (profile == null)

                return;



            // Command buffer-based effects should be set-up here

            TryExecuteCommandBuffer(m_DebugViews);

            TryExecuteCommandBuffer(m_AmbientOcclusion);

            TryExecuteCommandBuffer(m_ScreenSpaceReflection);

            TryExecuteCommandBuffer(m_FogComponent);



            if (!m_RenderingInSceneView)

                TryExecuteCommandBuffer(m_MotionBlur);

        }



        void OnPostRender()

        {

            if (profile == null || m_Camera == null)

                return;



            if (!m_RenderingInSceneView && m_Taa.active && !profile.debugViews.willInterrupt)

                m_Context.camera.ResetProjectionMatrix();

        }



        // Classic render target pipeline for RT-based effects

        void OnRenderImage(RenderTexture source, RenderTexture destination)

        {

            if (profile == null || m_Camera == null)

            {

                Graphics.Blit(source, destination);

                return;

            }



            // Uber shader setup

            bool uberActive = false;

            bool fxaaActive = m_Fxaa.active;

            bool taaActive = m_Taa.active && !m_RenderingInSceneView;

            bool dofActive = m_DepthOfField.active && !m_RenderingInSceneView;



            var uberMaterial = m_MaterialFactory.Get("Hidden/Post FX/Uber Shader");

            uberMaterial.shaderKeywords = null;



            var src = source;

            var dst = destination;



            if (taaActive)

            {

                var tempRT = m_RenderTextureFactory.Get(src);

                m_Taa.Render(src, tempRT);

                src = tempRT;

            }



#if UNITY_EDITOR

            // Render to a dedicated target when monitors are enabled so they can show information

            // about the final render.

            // At runtime the output will always be the backbuffer or whatever render target is

            // currently set on the camera.

            if (profile.monitors.onFrameEndEditorOnly != null)

                dst = m_RenderTextureFactory.Get(src);

#endif



            Texture autoExposure = GraphicsUtils.whiteTexture;

            if (m_EyeAdaptation.active)

            {

                uberActive = true;

                autoExposure = m_EyeAdaptation.Prepare(src, uberMaterial);

            }



            uberMaterial.SetTexture("_AutoExposure", autoExposure);



            if (dofActive)

            {

                uberActive = true;

                m_DepthOfField.Prepare(src, uberMaterial, taaActive, m_Taa.jitterVector, m_Taa.model.settings.taaSettings.motionBlending);

            }



            if (m_Bloom.active)

            {

                uberActive = true;

                m_Bloom.Prepare(src, uberMaterial, autoExposure);

            }



            uberActive |= TryPrepareUberImageEffect(m_ChromaticAberration, uberMaterial);

            uberActive |= TryPrepareUberImageEffect(m_ColorGrading, uberMaterial);

            uberActive |= TryPrepareUberImageEffect(m_Vignette, uberMaterial);

            uberActive |= TryPrepareUberImageEffect(m_UserLut, uberMaterial);



            var fxaaMaterial = fxaaActive

                ? m_MaterialFactory.Get("Hidden/Post FX/FXAA")

                : null;



            if (fxaaActive)

            {

                fxaaMaterial.shaderKeywords = null;

                TryPrepareUberImageEffect(m_Grain, fxaaMaterial);

                TryPrepareUberImageEffect(m_Dithering, fxaaMaterial);



                if (uberActive)

                {

                    var output = m_RenderTextureFactory.Get(src);

                    Graphics.Blit(src, output, uberMaterial, 0);

                    src = output;

                }



                m_Fxaa.Render(src, dst);

            }

            else

            {

                uberActive |= TryPrepareUberImageEffect(m_Grain, uberMaterial);

                uberActive |= TryPrepareUberImageEffect(m_Dithering, uberMaterial);



                if (uberActive)

                {

                    if (!GraphicsUtils.isLinearColorSpace)

                        uberMaterial.EnableKeyword("UNITY_COLORSPACE_GAMMA");



                    Graphics.Blit(src, dst, uberMaterial, 0);

                }

            }



            if (!uberActive && !fxaaActive)

                Graphics.Blit(src, dst);



#if UNITY_EDITOR

            if (profile.monitors.onFrameEndEditorOnly != null)

            {

                Graphics.Blit(dst, destination);



                var oldRt = RenderTexture.active;

                profile.monitors.onFrameEndEditorOnly(dst);

                RenderTexture.active = oldRt;

            }

#endif



            m_RenderTextureFactory.ReleaseAll();

        }



        void OnGUI()

        {

            if (!this.enabled)

            {

                return;

            }



            if (Event.current.type != EventType.Repaint)

                return;



            if (profile == null || m_Camera == null)

                return;



            if (m_EyeAdaptation.active && profile.debugViews.IsModeActive(DebugMode.EyeAdaptation))

                m_EyeAdaptation.OnGUI();

            else if (m_ColorGrading.active && profile.debugViews.IsModeActive(DebugMode.LogLut))

                m_ColorGrading.OnGUI();

            else if (m_UserLut.active && profile.debugViews.IsModeActive(DebugMode.UserLut))

                m_UserLut.OnGUI();

        }



        void OnDisable()

        {

            // Clear command buffers

            foreach (var cb in m_CommandBuffers.Values)

            {

                m_Camera.RemoveCommandBuffer(cb.Key, cb.Value);

                cb.Value.Dispose();

            }



            m_CommandBuffers.Clear();



            // Clear components

            if (profile != null)

                DisableComponents();



            m_Components.Clear();



            // Factories

            m_MaterialFactory.Dispose();

            m_RenderTextureFactory.Dispose();

            GraphicsUtils.Dispose();

        }



        public void ResetTemporalEffects()

        {

            m_Taa.ResetHistory();

            m_MotionBlur.ResetHistory();

            m_EyeAdaptation.ResetHistory();

        }



        #region State management



        List<PostProcessingComponentBase> m_ComponentsToEnable = new List<PostProcessingComponentBase>();

        List<PostProcessingComponentBase> m_ComponentsToDisable = new List<PostProcessingComponentBase>();



        void CheckObservers()

        {

            foreach (var cs in m_ComponentStates)

            {

                var component = cs.Key;

                var state = component.GetModel().enabled;



                if (state != cs.Value)

                {

                    if (state) m_ComponentsToEnable.Add(component);

                    else m_ComponentsToDisable.Add(component);

                }

            }



            for (int i = 0; i < m_ComponentsToDisable.Count; i++)

            {

                var c = m_ComponentsToDisable[i];

                m_ComponentStates[c] = false;

                c.OnDisable();

            }



            for (int i = 0; i < m_ComponentsToEnable.Count; i++)

            {

                var c = m_ComponentsToEnable[i];

                m_ComponentStates[c] = true;

                c.OnEnable();

            }



            m_ComponentsToDisable.Clear();

            m_ComponentsToEnable.Clear();

        }



        void DisableComponents()

        {

            foreach (var component in m_Components)

            {

                var model = component.GetModel();

                if (model != null && model.enabled)

                    component.OnDisable();

            }

        }



        #endregion



        #region Command buffer handling & rendering helpers

        // Placeholders before the upcoming Scriptable Render Loop as command buffers will be

        // executed on the go so we won't need of all that stuff

        CommandBuffer AddCommandBuffer<T>(CameraEvent evt, string name)

            where T : PostProcessingModel

        {

            var cb = new CommandBuffer { name = name };

            var kvp = new KeyValuePair<CameraEvent, CommandBuffer>(evt, cb);

            m_CommandBuffers.Add(typeof(T), kvp);

            m_Camera.AddCommandBuffer(evt, kvp.Value);

            return kvp.Value;

        }



        void RemoveCommandBuffer<T>()

            where T : PostProcessingModel

        {

            KeyValuePair<CameraEvent, CommandBuffer> kvp;

            var type = typeof(T);



            if (!m_CommandBuffers.TryGetValue(type, out kvp))

                return;



            m_Camera.RemoveCommandBuffer(kvp.Key, kvp.Value);

            m_CommandBuffers.Remove(type);

            kvp.Value.Dispose();

        }



        CommandBuffer GetCommandBuffer<T>(CameraEvent evt, string name)

            where T : PostProcessingModel

        {

            CommandBuffer cb;

            KeyValuePair<CameraEvent, CommandBuffer> kvp;



            if (!m_CommandBuffers.TryGetValue(typeof(T), out kvp))

            {

                cb = AddCommandBuffer<T>(evt, name);

            }

            else if (kvp.Key != evt)

            {

                RemoveCommandBuffer<T>();

                cb = AddCommandBuffer<T>(evt, name);

            }

            else cb = kvp.Value;



            return cb;

        }



        void TryExecuteCommandBuffer<T>(PostProcessingComponentCommandBuffer<T> component)

            where T : PostProcessingModel

        {

            if (component.active)

            {

                var cb = GetCommandBuffer<T>(component.GetCameraEvent(), component.GetName());

                cb.Clear();

                component.PopulateCommandBuffer(cb);

            }

            else RemoveCommandBuffer<T>();

        }



        bool TryPrepareUberImageEffect<T>(PostProcessingComponentRenderTexture<T> component, Material material)

            where T : PostProcessingModel

        {

            if (!component.active)

                return false;



            component.Prepare(material);

            return true;

        }



        T AddComponent<T>(T component)

            where T : PostProcessingComponentBase

        {

            m_Components.Add(component);

            return component;

        }



        #endregion

    }

}