ichni_Official/Packages/NBPostProcessing/Runtime/PostProcessingManager.cs

using System;
using UnityEngine;
// using Sirenix.OdinInspector;

// #if UNITY_EDITOR
//     using Sirenix.OdinInspector.Editor;
// #endif
#if UNITY_EDITOR
using UnityEditor;
#endif

#if CINIMACHINE_3_0
using Unity.Cinemachine;
#endif

using MhRender.RendererFeatures;


[ExecuteAlways]
public class PostProcessingManager : MonoBehaviour
{
    //单例实现
    private static PostProcessingManager _instance = null;

    public static PostProcessingManager Instance
    {
        get
        {
            if (_instance == null)
            {
                // #if UNITY_2022_1_OR_NEWER
                // _instance = FindFirstObjectByType<PostProcessingManager>();
                // #else
                _instance = FindObjectOfType<PostProcessingManager>();//因为兼容性因素，保留较慢版本
                // #endif
                if (_instance == null)
                {
                    GameObject singletonObj = new GameObject();
                    _instance = singletonObj.AddComponent<PostProcessingManager>();
                    if (Application.isPlaying)
                    {
                        singletonObj.name = "NBPostProcessManager";
                        DontDestroyOnLoad(singletonObj);
                    }
                    else
                    {
                        singletonObj.name = "测试用NB后处理管理器，请美术删除此脚本再上传";
                    }
                }
            }

            return _instance;
        }
    }
    

    private void Awake()
    {
        if (_instance == null)
        {
            _instance = this;
        }
        else
        {
            DestroyImmediate(this);
        }
    }

    // [ReadOnly] public Volume volume;
    // private static VolumeProfile profile;
    // [ReadOnly]
    public static Material material
    {
        get
        {
            return NBPostProcess.NBPostProcessMaterial;
        }
    }
    
    public static NBPostProcessFlags flags = new NBPostProcessFlags();

    // public CinemachineBrain cameraBrain;
    // public CinemachineVirtualCamera currentVirtualCamera;
    #if CINIMACHINE_3_0
    public CinemachineCamera currentVirtualCamera;
    private CinemachineBasicMultiChannelPerlin _perlin;
    #endif
    
    public static void InitMat()
    {
        flags.SetMaterial(PostProcessingManager.material);
        if (_instance)
        {
            _instance.ResetEffect();
        }
    }
    private void OnEnable()
    {
#if UNITY_EDITOR
        if (_controllerIndexFlags > 0)
        {
            ReRegistEditorUpdate();
        }
        else
        {
            EditorApplication.update += EditorUpdate;
        }
        // 注册编辑器帧更新事件
#endif
        // //TODO 后续版本要找比较准确快的找Volume的方式
        // volume = GameObject.FindObjectOfType<Volume>();
        // if (volume != null)
        // {
        //     profile = volume.profile;
        // }

        // #if UNITY_EDITOR
        //         //仅仅用于测试。
        //         if (currentVirtualCamera == null)
        //         {
        //             currentVirtualCamera = FindFirstObjectByType<CinemachineCamera>();
        //
        //             if (currentVirtualCamera)
        //             {
        //                 if (!currentVirtualCamera.gameObject.TryGetComponent<CinemachineBasicMultiChannelPerlin>(out _perlin))
        //                 {
        //                     _perlin = currentVirtualCamera.gameObject.AddComponent<CinemachineBasicMultiChannelPerlin>();
        //                 }
        //             }
        //
        //             if (_perlin)
        //             {
        //                 _perlin.NoiseProfile =
        //                     // ResourceManager.LoadAssetAsync<NoiseSettings>("Assets/AddressableAssets/Shader/CustomPostprocess/3DPostionShake.asset");
        //                     //在runtime下是找不到的。但设计是美术做好然后存引用在预制件里。
        //                     UnityEditor.AssetDatabase.LoadAssetAtPath<NoiseSettings>(
        //                         "Packages/com.r2.render.postprocessing/3DPostionShake.asset");
        //                 _perlin.FrequencyGain = 5f; //做一个自定义
        //                 _perlin.AmplitudeGain = 0f; //一开始先不要震动
        //             }
        //         }
        //
        // #endif
        
        
        //重置Flag
        flags = new NBPostProcessFlags(material);
        flags.SetFlagBits(0);
    }

    private void OnDisable()
    {
#if UNITY_EDITOR
        // 注册编辑器帧更新事件
        EditorApplication.update -= EditorUpdate;
#endif
        flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_NB_POSTPROCESS_ON);
    }


//     [ShowInInspector]
// #if UNITY_EDITOR
//     [BinaryInt(8)]
// #endif
    private int _controllerIndexFlags = 0;

    public static int laseUpdateControllerIndex;
    
    private int GetControllerIndex()
    {
        for (int i = 0; i < 31; i++)
        {
            if (((~_controllerIndexFlags) & (1 << i)) != 0)
            {
                _controllerIndexFlags |= (1 << i);
                laseUpdateControllerIndex = i;
                return i;
            }
        }
        return 32;
    }

    private void ReleaseControllerIndex(int index)
    {
        _controllerIndexFlags &= ~(1 << index);
    }

    private int CountBit(int bit)
    {
        int count = 0;
        while (bit > 0)
        {
            bit = bit & (bit - 1);
            count++;
        }

        return count;
    }
    //每次Controller触发Play都会触发Init
    public void InitController(PostProcessingController controller)
    {
        #if CINIMACHINE_3_0
        if (controller.cinemachineCamera != null)
        {
            currentVirtualCamera = controller.cinemachineCamera;
            _perlin = currentVirtualCamera.gameObject.GetComponent<CinemachineBasicMultiChannelPerlin>();
        }
        #endif

        controller.SetIndex(GetControllerIndex()); 
    }

    public void EndController(PostProcessingController controller)
    {
        #if CINIMACHINE_3_0
        if (currentVirtualCamera == controller.cinemachineCamera)
        {
            currentVirtualCamera = null;
            _perlin = null;
        }
        #endif
        
        ReleaseControllerIndex(controller.index);
        controller.SetIndex(32); //设置32为关闭index
    }

    private void EffectUpdater(Action initEffect,Action updateEffect,Action endEffect,ref bool lastIsEffect,int effectToggles)
    {
        if (effectToggles > 0)
        {
            if (!lastIsEffect)
            {
                initEffect();
            }
            updateEffect();
            lastIsEffect = true;
        }
        else
        {
            if (lastIsEffect)
            {
                endEffect();
                lastIsEffect = false;
            }
        }


    }

    private bool isFirstUpdate = true;

    private void ResetEffect()
    {
        if (_lastIsChromaticAberration)
        {
            EndChromaticAberration();
            _lastIsChromaticAberration = false;
        }

        if (_lastIsRadialBlur)
        {
            EndRadialBlur();
            _lastIsRadialBlur = false;
        }

        if (_lastIsDistortSpeed)
        {
            EndDistortSpeed();
            _lastIsDistortSpeed = false;
        }

#if CINIMACHINE_3_0
            if (_lastIsCameraShake)
            {
                EndCameraShake();
                _lastIsCameraShake = false;
            }
#endif

        if (_lastIsOverlayTexture)
        {
            EndOverlayTexture();
            _lastIsOverlayTexture = false;
        }

        if (_lastIsFlash)
        {
            EndFlash();
            _lastIsFlash = false;
        }

        if (_lastIsVignette)
        {
            EndVignette();
            _lastIsVignette = false;
        }
    }
    
    private void LateUpdate()//晚于所有脚本触发。
    {
        if (isFirstUpdate)
        {
            isFirstUpdate = false;
            return;
        }
        
        if(!material) return;
        /*
#if UNITY_EDITOR
        if (flags.GetMaterial() != PostProcessingManager.material)
        {
            flags.SetMaterial(PostProcessingManager.material);
        }
#endif
        */

        if (_controllerIndexFlags == 0)
        {
            ResetEffect();
            flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_NB_POSTPROCESS_ON);
            return;
        }
        
        EffectUpdater(InitChromaticAberration,UpdateChromaticAberration,EndChromaticAberration,ref _lastIsChromaticAberration,chromaticAberrationToggles);
        EffectUpdater(InitDistortSpeed,UpdateDistortSpeed,EndDistortSpeed,ref _lastIsDistortSpeed,distortSpeedToggles);
        EffectUpdater(InitRadialBlur, UpdateRadialBlur, EndRadialBlur,ref _lastIsRadialBlur, radialBlurToggles);

        bool isSetCustomScreenCenterPos = (chromaticAberrationToggles | distortSpeedToggles | radialBlurToggles) > 0;

        if (isSetCustomScreenCenterPos)
        {
            material.SetVector(_customScreenCenterProperty,
                new Vector4(customScreenCenterPos.x, customScreenCenterPos.y, 0, 0));
        }
        
        #if CINIMACHINE_3_0
        EffectUpdater(() => { },UpdateCameraShake,EndCameraShake,ref _lastIsCameraShake,cameraShakeToggles);
        #endif
        EffectUpdater(InitOverlayTexture, UpdateOverlayTexture, EndOverlayTexture,ref _lastIsOverlayTexture, overlayTextureToggles);
        EffectUpdater(InitFlash, UpdateFlash, EndFlash,ref _lastIsFlash, flashToggles);
        EffectUpdater(InitVignette, UpdateVignette, EndVignette,ref _lastIsVignette, vignetteToggles);
        
        bool hasEffect = 
        (
            chromaticAberrationToggles|
            distortSpeedToggles|
            #if CINIMACHINE_3_0
            cameraShakeToggles|
            #endif
            radialBlurToggles|
            overlayTextureToggles|
            flashToggles|
            vignetteToggles
        ) >0;

        if (hasEffect)
        {
            flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_NB_POSTPROCESS_ON);
        }
        else
        {
            flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_NB_POSTPROCESS_ON);
        }
    }

    
    private readonly int _customScreenCenterProperty = Shader.PropertyToID("_CustomScreenCenter");
    public static Vector2 customScreenCenterPos = new Vector2(0.5f, 0.5f);
    
    
    

    #region 色散

    //色散相关
    // private ChromaticAberration chromaticAberrationComp;
    // private bool preserveChromaticAberrationActive;
    // private float preserveChromaticAberrationIntensity;
    private bool _lastIsChromaticAberration = false;
    private readonly int _chromaticAberrationVecProperty = Shader.PropertyToID("_ChromaticAberrationVec");
    
    public static int chromaticAberrationToggles = 0;

    public static bool isCaByDistort= false;
    private bool _lastIsCaByDistort = false;

    public static float chromaticAberrationIntensity = 0;
    public static float chromaticAberrationPos = 0;
    public static float chromaticAberrationRange = 0;

    private void InitChromaticAberration()
    {
        // Debug.Log("InitCA");
        flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_CHORATICABERRAT);
    }

    private void UpdateChromaticAberration()
    {
        if (_lastIsCaByDistort != isCaByDistort)
        {
            if (isCaByDistort)
            {
                flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_CHORATICABERRAT_BY_DISTORT);
            }
            else
            {
                flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_CHORATICABERRAT_BY_DISTORT);
            }

            _lastIsCaByDistort = isCaByDistort;
        }
        
        material.SetVector(_chromaticAberrationVecProperty, new Vector4(chromaticAberrationIntensity,chromaticAberrationPos,chromaticAberrationRange));
        chromaticAberrationIntensity = 0;//等待下一次update
        chromaticAberrationPos = 0;//等待下一次update
        chromaticAberrationRange = 0;//等待下一次update
    }

    private void EndChromaticAberration()
    {
        // Debug.Log("EndCA");
        flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_CHORATICABERRAT);
    }
    #endregion
    
    #region 径向速度扭曲
    //径向速度扭曲相关
    private readonly int _distortVecProperty = Shader.PropertyToID("_SpeedDistortVec");
    private readonly int _distortVec2Property = Shader.PropertyToID("_SpeedDistortVec2");
    private bool _lastIsDistortSpeed = false;

    public static bool isDistortScreenUVMode;
    private bool _lastIsDistortScreenUVMode;
//     [ShowInInspector]
//     [LabelText("径向扭曲开关")]
// #if UNITY_EDITOR
//     [BinaryInt(8)]
// #endif
    public static int distortSpeedToggles;

    public static Texture2D distortTexture2D;
    
    public static float distortSpeedIntensity = 0;
    public static float distortSpeedPosition = 0;
    public static float distortSpeedRange = 0;
    public static float distortSpeedMoveSpeedX = 0;
    public static float distortSpeedMoveSpeedY = 0;
    public static float distortTextureMidValue = 0;

    private void InitDistortSpeed()
    {
        flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_DISTORT_SPEED); 
    }

    private void UpdateDistortSpeed()
    {
        if (_lastIsDistortScreenUVMode!=isDistortScreenUVMode)
        {
            if (isDistortScreenUVMode)
            {
                flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_POST_DISTORT_SCREEN_UV);
            }
            else
            {
                flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_POST_DISTORT_SCREEN_UV);
            }
            _lastIsDistortScreenUVMode = isDistortScreenUVMode;
        }
        Vector4 distortVec = new Vector4(distortSpeedIntensity, distortSpeedPosition, distortSpeedRange,
            distortTextureMidValue);
        Vector4 distortVec2 = new Vector4(distortSpeedMoveSpeedX, distortSpeedMoveSpeedY, 0, 0);
        material.SetVector(_distortVecProperty, distortVec);
        material.SetVector(_distortVec2Property, distortVec2);
        distortSpeedIntensity = 0;
        distortSpeedPosition = 0;
        distortSpeedRange = 0;
        distortSpeedMoveSpeedX = 0;
        distortSpeedMoveSpeedY = 0;
    }

    private void EndDistortSpeed()
    {
        flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_DISTORT_SPEED);
    }
    #endregion

    #region 径向模糊
    // [ShowInInspector]
    // [LabelText("径向模糊开关")]
    // #if UNITY_EDITOR
    //     [BinaryInt(8)]
    // #endif
    public static int radialBlurToggles = 0;
    private readonly int _radialBlurVecProperty = Shader.PropertyToID("_RadialBlurVec");
    public static float radialBlurIntensity = 0;
    public static float radialBlurPos = 0;
    public static float radialBlurRange = 0;
    public static int radialBlurSampleCount = 4;
    public static bool isRadialBlurByDistort = false;
    private bool _lastIsRadialBlurByDistort = false;

    private bool _lastIsRadialBlur = false;

    private void InitRadialBlur()
    {
        // Debug.Log("InitRB");
        flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_RADIALBLUR);
    }

    private void UpdateRadialBlur()
    {
        if (_lastIsRadialBlurByDistort != isRadialBlurByDistort)
        {
            if (isRadialBlurByDistort)
            {
                flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_RADIALBLUR_BY_DISTORT);
            }
            else
            {
                flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_RADIALBLUR_BY_DISTORT);
            }

            _lastIsRadialBlurByDistort = isRadialBlurByDistort;
        }
        Vector4 radialBlurVec = new Vector4(radialBlurIntensity*0.1f/radialBlurSampleCount, radialBlurPos, radialBlurRange, radialBlurSampleCount);
        material.SetVector(_radialBlurVecProperty,radialBlurVec);
        radialBlurIntensity = 0;
        radialBlurSampleCount = 0;
        radialBlurPos = 0;
        radialBlurRange = 0;
    }

    private void EndRadialBlur()
    {
        // Debug.Log("EndRB");
        flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_RADIALBLUR);
    }

    #endregion

    #region 震屏
    #if CINIMACHINE_3_0

    public static int cameraShakeToggles = 0;


    private bool _lastIsCameraShake = false;
    public static float cameraShakeIntensity = 0;
    private void UpdateCameraShake()
    {
        if (_perlin)
        {
            _perlin.AmplitudeGain = cameraShakeIntensity;
        }

        cameraShakeIntensity = 0;
        // #if UNITY_EDITOR
            if (currentVirtualCamera )
            {
                CinemachineCore.SoloCamera = currentVirtualCamera;
            }
        // #endif
        // Debug.Log(_perlin.m_AmplitudeGain);
    }

    private void EndCameraShake()
    {
        if (_perlin)
        {
            _perlin.AmplitudeGain = 0;
        }
        CinemachineCore.SoloCamera = null;
    }
    #endif
    #endregion

    #region 肌理叠加
 
    //肌理图
    //注意，肌理图就是硬切，只有intensity可以做差值。
//     [ShowInInspector]
//     [LabelText("肌理开关")]
// #if UNITY_EDITOR
//     [BinaryInt(8)]
// #endif
    public static int overlayTextureToggles = 0;

    private bool _lastIsOverlayTexture = false;

    public static float overlayTextureIntensity = 0;

    private readonly int _overlayTextureProperty = Shader.PropertyToID("_TextureOverlay");
    private readonly int _overlayTextureStProperty = Shader.PropertyToID("_TextureOverlay_ST");
    private readonly int _overlayTextureIntensityProperty = Shader.PropertyToID("_TextureOverlayIntensity");

    private void InitOverlayTexture()
    {
        flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_OVERLAYTEXTURE);
    }

    private void UpdateOverlayTexture()
    {
        material.SetFloat(_overlayTextureIntensityProperty, overlayTextureIntensity);
        overlayTextureIntensity = 0;
    }

    private void EndOverlayTexture()
    {
        flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_OVERLAYTEXTURE);
    }

    #endregion

    #region 黑白闪
    
//     [ShowInInspector]
//     [LabelText("黑白闪开关")]
// #if UNITY_EDITOR
//     [BinaryInt(8)]
// #endif
    public static int flashToggles = 0;

    private bool _lastIsFlash = false;

    public static float flashDesaturateIntensity = 0;

    public static float flashInvertIntensity = 0;
    
    public static float flashContrast = 0;

    public static Color flashColor = new Color(1, 1, 1, 1);
    public static Color blackFlashColor = new Color(0, 0, 0, 1);

    private readonly int _flashDesaturateProperty = Shader.PropertyToID("_DeSaturateIntensity");
    private readonly int _flashInvertProperty = Shader.PropertyToID("_InvertIntensity");
    private readonly int _flashContrastProperty = Shader.PropertyToID("_Contrast");
    private readonly int _flashColorProperty = Shader.PropertyToID("_FlashColor");
    private readonly int _blackFlashColorProperty = Shader.PropertyToID("_BlackFlashColor");

    private void InitFlash()
    {
        flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_FLASH);
    }

    private void UpdateFlash()
    {
        material.SetFloat(_flashDesaturateProperty, flashDesaturateIntensity);
        material.SetFloat(_flashInvertProperty, flashInvertIntensity);
        material.SetFloat(_flashContrastProperty, flashContrast);
        material.SetColor(_flashColorProperty,flashColor);
        material.SetColor(_blackFlashColorProperty,blackFlashColor);
        flashDesaturateIntensity = 0;
        flashInvertIntensity = 0;
        flashContrast = 0;
        flashColor = Color.white;
    }

    private void EndFlash()
    {
        flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_FLASH);
    }
    #endregion

    #region 暗角

//     [ShowInInspector]
//     [LabelText("暗角开关")]
// #if UNITY_EDITOR
//     [BinaryInt(8)]
// #endif
    public static int vignetteToggles = 0;

    private bool _lastIsVignette;

    public static float vignetteIntensity = 0f; 
    public static float vignetteRoundness = 0f;
    public static float vignetteSmothness = 0f;

    private readonly int _vignetteVecProperty = Shader.PropertyToID("_VignetteVec");

    private void InitVignette()
    {
        flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_VIGNETTE);    
    }
    

    private void UpdateVignette()
    {
        Vector4 vignetteVec = new Vector4(vignetteIntensity, vignetteRoundness, vignetteSmothness, 0);
        material.SetVector(_vignetteVecProperty,vignetteVec);
        vignetteIntensity = 0;
        vignetteRoundness = 0;
        vignetteSmothness = 0;
    }

    private void EndVignette()
    {
        flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_VIGNETTE);
    }
    

    #endregion

    
    #if UNITY_EDITOR
    void EditorUpdate()
    {
        if (!Application.isPlaying)
        {
            LateUpdate();//每帧Update会导致SceneView闪
        }
    }

    public void ReRegistEditorUpdate()
    {
        EditorApplication.update -= EditorUpdate;
        EditorApplication.update += EditorUpdate;
    }
    #endif

}