Cinemachine代码中自定义抖动事件

抖动事件监听脚本

using UnityEngine;

namespace Cinemachine
{
    /// <summary>
    /// 此脚本是复制CinemachineIndependentImpulseListener脚本，因为我们不想创建抖动频道文件，所有复制一份，公开m_ChannelMask
    /// 此脚本挂载到摄像机上，针对于在代码中自定义抖动事件
    /// </summary>
    public class FixedCinemachineImpulseListener : MonoBehaviour
    {
        private Vector3 impulsePosLastFrame;
        private Quaternion impulseRotLastFrame;
        
        /// <summary>
        /// 此脚本监听的抖动频道
        /// </summary>
        public int m_ChannelMask = 1;

        /// <summary>
        /// Gain to apply to the Impulse signal.
        /// </summary>
        public float m_Gain = 1;

        /// <summary>
        /// Enable this to perform distance calculation in 2D (ignore Z).
        /// </summary>
        public bool m_Use2DDistance = false;


        private void OnEnable()
        {
            impulsePosLastFrame = Vector3.zero;
            impulseRotLastFrame = Quaternion.identity;
        }

        private void Update()
        {
            // Unapply previous shake
            transform.position -= impulsePosLastFrame;
            transform.rotation = transform.rotation * Quaternion.Inverse(impulseRotLastFrame);
        }

        // We do this in LateUpdate specifically to support attaching this script to the
        // Camera with the CinemachineBrain.  Script execution order is after the brain.
        private void LateUpdate()
        {
            // Apply the shake
            if (CinemachineImpulseManager.Instance.GetImpulseAt(
                transform.position, m_Use2DDistance, m_ChannelMask, 
                out impulsePosLastFrame, out impulseRotLastFrame))
            {
                impulsePosLastFrame *= m_Gain;
                impulseRotLastFrame = Quaternion.SlerpUnclamped(
                    Quaternion.identity, impulseRotLastFrame, -m_Gain);
                transform.position += impulsePosLastFrame;
                transform.rotation = transform.rotation * impulseRotLastFrame;
            }
        }
    }
}

发出抖动事件

using Cinemachine;
using System.Collections.Generic;
using UnityEngine;

public class ImpulseScriptEditor : MonoBehaviour
{

    public bool OnPlay = false;
    private bool m_play = false;


    private void Start()
    {

    }

    private void Update()
    {
        if (m_play != OnPlay)
        {
            m_play = OnPlay;
            if (OnPlay)
            {

                Debug.Log("执行一次");

                AddImpulseEvent();

            }
        }
    }

    private void AddImpulseEvent()
    {
        NoiseSettings noiseSettings = GetNoiseSettings();
        CinemachineImpulseManager.ImpulseEvent e = CinemachineImpulseManager.Instance.NewImpulseEvent();
        e.m_Envelope = new CinemachineImpulseManager.EnvelopeDefinition();

        e.m_Envelope.m_SustainTime = 3;
        e.m_Envelope.m_ScaleWithImpact = true;
        if (e.m_Envelope.m_ScaleWithImpact)
        {
            e.m_Envelope.m_DecayTime *= Mathf.Sqrt(Vector3.down.magnitude) * 0.7f;
        }
        else
        {
            e.m_Envelope.m_DecayTime = 0.7f;
        }
        e.m_SignalSource = noiseSettings;
        e.m_Position = transform.position;//震动中心点
        e.m_Radius = 100;//具有完整信号值的信号原点周围的半径。距离耗散在该距离之后开始
        e.m_Channel = 99;
        e.m_DirectionMode = CinemachineImpulseManager.ImpulseEvent.DirectionMode.Fixed;
        e.m_DissipationMode = CinemachineImpulseManager.ImpulseEvent.DissipationMode.ExponentialDecay;
        e.m_DissipationDistance = 1000;
        e.m_PropagationSpeed = 340;
        CinemachineImpulseManager.Instance.AddImpulseEvent(e);
    }
    private NoiseSettings GetNoiseSettings()
    {
        NoiseSettings noiseSettings = new NoiseSettings();

        List<NoiseSettings.TransformNoiseParams> positionNoises = new List<NoiseSettings.TransformNoiseParams>();
        NoiseSettings.TransformNoiseParams positionNoise = new NoiseSettings.TransformNoiseParams();
        positionNoise.X.Frequency = 2;
        positionNoise.X.Amplitude = 1;
        positionNoise.X.Constant = false;
        positionNoise.Y.Frequency = 2;
        positionNoise.Y.Amplitude = 1;
        positionNoise.Y.Constant = false;
        positionNoise.Z.Frequency = 2;
        positionNoise.Z.Amplitude = 1;
        positionNoise.Z.Constant = false;

        positionNoises.Add(positionNoise);

        noiseSettings.PositionNoise = positionNoises.ToArray();

        List<NoiseSettings.TransformNoiseParams> orientationNoises = new List<NoiseSettings.TransformNoiseParams>();
        NoiseSettings.TransformNoiseParams orientationNoise = new NoiseSettings.TransformNoiseParams();
        orientationNoise.X.Frequency = 1;
        orientationNoise.X.Amplitude = 1;
        orientationNoise.X.Constant = false;
        orientationNoise.Y.Frequency = 1;
        orientationNoise.Y.Amplitude = 1;
        orientationNoise.Y.Constant = false;
        orientationNoise.Z.Frequency = 1;
        orientationNoise.Z.Amplitude = 1;
        orientationNoise.Z.Constant = false;

        orientationNoises.Add(orientationNoise);

        noiseSettings.OrientationNoise = orientationNoises.ToArray();

        return noiseSettings;
    }
}