Insanely huge initial commit

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachineCameraShaker.cs

@@ -0,0 +1,205 @@
+using System.Collections;
+using UnityEngine;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this component to your Cinemachine Virtual Camera to have it shake when calling its ShakeCamera methods.
+	/// </summary>
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/Cinemachine/MMCinemachineCameraShaker")]
+	#if MM_CINEMACHINE
+	[RequireComponent(typeof(CinemachineVirtualCamera))]
+	#endif
+	public class MMCinemachineCameraShaker : MonoBehaviour
+	{
+		[Header("Settings")]
+		/// whether to listen on a channel defined by an int or by a MMChannel scriptable object. Ints are simple to setup but can get messy and make it harder to remember what int corresponds to what.
+		/// MMChannel scriptable objects require you to create them in advance, but come with a readable name and are more scalable
+		[Tooltip("whether to listen on a channel defined by an int or by a MMChannel scriptable object. Ints are simple to setup but can get messy and make it harder to remember what int corresponds to what. " +
+		         "MMChannel scriptable objects require you to create them in advance, but come with a readable name and are more scalable")]
+		public MMChannelModes ChannelMode = MMChannelModes.Int;
+		/// the channel to listen to - has to match the one on the feedback
+		[Tooltip("the channel to listen to - has to match the one on the feedback")]
+		[MMFEnumCondition("ChannelMode", (int)MMChannelModes.Int)]
+		public int Channel = 0;
+		/// the MMChannel definition asset to use to listen for events. The feedbacks targeting this shaker will have to reference that same MMChannel definition to receive events - to create a MMChannel,
+		/// right click anywhere in your project (usually in a Data folder) and go MoreMountains > MMChannel, then name it with some unique name
+		[Tooltip("the MMChannel definition asset to use to listen for events. The feedbacks targeting this shaker will have to reference that same MMChannel definition to receive events - to create a MMChannel, " +
+		         "right click anywhere in your project (usually in a Data folder) and go MoreMountains > MMChannel, then name it with some unique name")]
+		[MMFEnumCondition("ChannelMode", (int)MMChannelModes.MMChannel)]
+		public MMChannel MMChannelDefinition = null;
+		/// The default amplitude that will be applied to your shakes if you don't specify one
+		[Tooltip("The default amplitude that will be applied to your shakes if you don't specify one")]
+		public float DefaultShakeAmplitude = .5f;
+		/// The default frequency that will be applied to your shakes if you don't specify one
+		[Tooltip("The default frequency that will be applied to your shakes if you don't specify one")]
+		public float DefaultShakeFrequency = 10f;
+		/// the amplitude of the camera's noise when it's idle
+		[Tooltip("the amplitude of the camera's noise when it's idle")]
+		[MMFReadOnly]
+		public float IdleAmplitude;
+		/// the frequency of the camera's noise when it's idle
+		[Tooltip("the frequency of the camera's noise when it's idle")]
+		[MMFReadOnly]
+		public float IdleFrequency = 1f;
+		/// the speed at which to interpolate the shake
+		[Tooltip("the speed at which to interpolate the shake")]
+		public float LerpSpeed = 5f;
+
+		[Header("Test")]
+		/// a duration (in seconds) to apply when testing this shake via the TestShake button
+		[Tooltip("a duration (in seconds) to apply when testing this shake via the TestShake button")]
+		public float TestDuration = 0.3f;
+		/// the amplitude to apply when testing this shake via the TestShake button
+		[Tooltip("the amplitude to apply when testing this shake via the TestShake button")]
+		public float TestAmplitude = 2f;
+		/// the frequency to apply when testing this shake via the TestShake button
+		[Tooltip("the frequency to apply when testing this shake via the TestShake button")]
+		public float TestFrequency = 20f;
+
+		[MMFInspectorButton("TestShake")]
+		public bool TestShakeButton;
+
+		#if MM_CINEMACHINE
+		public virtual float GetTime() { return (_timescaleMode == TimescaleModes.Scaled) ? Time.time : Time.unscaledTime; }
+		public virtual float GetDeltaTime() { return (_timescaleMode == TimescaleModes.Scaled) ? Time.deltaTime : Time.unscaledDeltaTime; }
+
+		protected TimescaleModes _timescaleMode;
+		protected Vector3 _initialPosition;
+		protected Quaternion _initialRotation;
+		protected Cinemachine.CinemachineBasicMultiChannelPerlin _perlin;
+		protected Cinemachine.CinemachineVirtualCamera _virtualCamera;
+		protected float _targetAmplitude;
+		protected float _targetFrequency;
+		private Coroutine _shakeCoroutine;
+
+		/// <summary>
+		/// On awake we grab our components
+		/// </summary>
+		protected virtual void Awake()
+		{
+			_virtualCamera = this.gameObject.GetComponent<CinemachineVirtualCamera>();
+			_perlin = _virtualCamera.GetCinemachineComponent<Cinemachine.CinemachineBasicMultiChannelPerlin>();
+		}
+
+		/// <summary>
+		/// On Start we reset our camera to apply our base amplitude and frequency
+		/// </summary>
+		protected virtual void Start()
+		{
+			if (_perlin != null)
+			{
+				IdleAmplitude = _perlin.m_AmplitudeGain;
+				IdleFrequency = _perlin.m_FrequencyGain;
+			}            
+
+			_targetAmplitude = IdleAmplitude;
+			_targetFrequency = IdleFrequency;
+		}
+
+		protected virtual void Update()
+		{
+			if (_perlin != null)
+			{
+				_perlin.m_AmplitudeGain = _targetAmplitude;
+				_perlin.m_FrequencyGain = Mathf.Lerp(_perlin.m_FrequencyGain, _targetFrequency, GetDeltaTime() * LerpSpeed);
+			}
+		}
+
+		/// <summary>
+		/// Use this method to shake the camera for the specified duration (in seconds) with the default amplitude and frequency
+		/// </summary>
+		/// <param name="duration">Duration.</param>
+		public virtual void ShakeCamera(float duration, bool infinite, bool useUnscaledTime = false)
+		{
+			StartCoroutine(ShakeCameraCo(duration, DefaultShakeAmplitude, DefaultShakeFrequency, infinite, useUnscaledTime));
+		}
+
+		/// <summary>
+		/// Use this method to shake the camera for the specified duration (in seconds), amplitude and frequency
+		/// </summary>
+		/// <param name="duration">Duration.</param>
+		/// <param name="amplitude">Amplitude.</param>
+		/// <param name="frequency">Frequency.</param>
+		public virtual void ShakeCamera(float duration, float amplitude, float frequency, bool infinite, bool useUnscaledTime = false)
+		{
+			if (_shakeCoroutine != null)
+			{
+				StopCoroutine(_shakeCoroutine);
+			}
+			_shakeCoroutine = StartCoroutine(ShakeCameraCo(duration, amplitude, frequency, infinite, useUnscaledTime));
+		}
+
+		/// <summary>
+		/// This coroutine will shake the 
+		/// </summary>
+		/// <returns>The camera co.</returns>
+		/// <param name="duration">Duration.</param>
+		/// <param name="amplitude">Amplitude.</param>
+		/// <param name="frequency">Frequency.</param>
+		protected virtual IEnumerator ShakeCameraCo(float duration, float amplitude, float frequency, bool infinite, bool useUnscaledTime)
+		{
+			_targetAmplitude  = amplitude;
+			_targetFrequency = frequency;
+			_timescaleMode = useUnscaledTime ? TimescaleModes.Unscaled : TimescaleModes.Scaled;
+			if (!infinite)
+			{
+				yield return new WaitForSeconds(duration);
+				CameraReset();
+			}                        
+		}
+
+		/// <summary>
+		/// Resets the camera's noise values to their idle values
+		/// </summary>
+		public virtual void CameraReset()
+		{
+			_targetAmplitude = IdleAmplitude;
+			_targetFrequency = IdleFrequency;
+		}
+
+		public virtual void OnCameraShakeEvent(float duration, float amplitude, float frequency, float amplitudeX, float amplitudeY, float amplitudeZ, bool infinite, MMChannelData channelData, bool useUnscaledTime)
+		{
+			if (!MMChannel.Match(channelData, ChannelMode, Channel, MMChannelDefinition))
+			{
+				return;
+			}
+			this.ShakeCamera(duration, amplitude, frequency, infinite, useUnscaledTime);
+		}
+
+		public virtual void OnCameraShakeStopEvent(MMChannelData channelData)
+		{
+			if (!MMChannel.Match(channelData, ChannelMode, Channel, MMChannelDefinition))
+			{
+				return;
+			}
+			if (_shakeCoroutine != null)
+			{
+				StopCoroutine(_shakeCoroutine);
+			}            
+			CameraReset();
+		}
+
+		protected virtual void OnEnable()
+		{
+			MMCameraShakeEvent.Register(OnCameraShakeEvent);
+			MMCameraShakeStopEvent.Register(OnCameraShakeStopEvent);
+		}
+
+		protected virtual void OnDisable()
+		{
+			MMCameraShakeEvent.Unregister(OnCameraShakeEvent);
+			MMCameraShakeStopEvent.Unregister(OnCameraShakeStopEvent);
+		}
+
+		protected virtual void TestShake()
+		{
+			MMCameraShakeEvent.Trigger(TestDuration, TestAmplitude, TestFrequency, 0f, 0f, 0f, false, new MMChannelData(ChannelMode, Channel, MMChannelDefinition));
+		}
+		#endif
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachineCameraShaker.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9d66462bf720d28469c8db4b2e52720c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachineClippingPlanesShaker.cs

@@ -0,0 +1,206 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this to a Cinemachine virtual camera and it'll let you control its near and far clipping planes
+	/// </summary>
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/Cinemachine/MMCinemachineClippingPlanesShaker")]
+	#if MM_CINEMACHINE
+	[RequireComponent(typeof(CinemachineVirtualCamera))]
+	#endif
+	public class MMCinemachineClippingPlanesShaker : MMShaker
+	{
+		[MMInspectorGroup("Clipping Planes", true, 45)]
+		/// whether or not to add to the initial value
+		public bool RelativeClippingPlanes = false;
+
+		[MMInspectorGroup("Near Plane", true, 46)]
+		/// the curve used to animate the intensity value on
+		[Tooltip("the curve used to animate the intensity value on")]
+		public AnimationCurve ShakeNear = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
+		/// the value to remap the curve's 0 to        
+		[Tooltip("the value to remap the curve's 0 to")]
+		public float RemapNearZero = 0.3f;
+		/// the value to remap the curve's 1 to        
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapNearOne = 100f;
+
+		[MMInspectorGroup("Far Plane", true, 47)]
+		/// the curve used to animate the intensity value on
+		[Tooltip("the curve used to animate the intensity value on")]
+		public AnimationCurve ShakeFar = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
+		/// the value to remap the curve's 0 to        
+		[Tooltip("the value to remap the curve's 0 to")]
+		public float RemapFarZero = 1000f;
+		/// the value to remap the curve's 1 to        
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapFarOne = 1000f;
+
+		#if MM_CINEMACHINE
+		protected CinemachineVirtualCamera _targetCamera;
+		protected float _initialNear;
+		protected float _initialFar;
+		protected float _originalShakeDuration;
+		protected bool _originalRelativeClippingPlanes;
+		protected AnimationCurve _originalShakeNear;
+		protected float _originalRemapNearZero;
+		protected float _originalRemapNearOne;
+		protected AnimationCurve _originalShakeFar;
+		protected float _originalRemapFarZero;
+		protected float _originalRemapFarOne;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_targetCamera = this.gameObject.GetComponent<CinemachineVirtualCamera>();
+		}
+
+		/// <summary>
+		/// When that shaker gets added, we initialize its shake duration
+		/// </summary>
+		protected virtual void Reset()
+		{
+			ShakeDuration = 0.5f;
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newNear = ShakeFloat(ShakeNear, RemapNearZero, RemapNearOne, RelativeClippingPlanes, _initialNear);
+			_targetCamera.m_Lens.NearClipPlane = newNear;
+			float newFar = ShakeFloat(ShakeFar, RemapFarZero, RemapFarOne, RelativeClippingPlanes, _initialFar);
+			_targetCamera.m_Lens.FarClipPlane = newFar;
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialNear = _targetCamera.m_Lens.NearClipPlane;
+			_initialFar = _targetCamera.m_Lens.FarClipPlane;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="distortionCurve"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeDistortion"></param>
+		/// <param name="feedbacksIntensity"></param>
+		/// <param name="channel"></param>
+		public virtual void OnMMCameraClippingPlanesShakeEvent(AnimationCurve animNearCurve, float duration, float remapNearMin, float remapNearMax, AnimationCurve animFarCurve, float remapFarMin, float remapFarMax, bool relativeValues = false,
+			float feedbacksIntensity = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, bool forwardDirection = true, 
+			TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			if (!CheckEventAllowed(channelData))
+			{
+				return;
+			}
+            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+            
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+            
+			if (!Interruptible && Shaking)
+			{
+				return;
+			}
+            
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalShakeNear = ShakeNear;
+				_originalShakeFar = ShakeFar;
+				_originalRemapNearZero = RemapNearZero;
+				_originalRemapNearOne = RemapNearOne;
+				_originalRemapFarZero = RemapFarZero;
+				_originalRemapFarOne = RemapFarOne;
+				_originalRelativeClippingPlanes = RelativeClippingPlanes;
+			}
+
+			TimescaleMode = timescaleMode;
+			ShakeDuration = duration;
+			ShakeNear = animNearCurve;
+			RemapNearZero = remapNearMin * feedbacksIntensity;
+			RemapNearOne = remapNearMax * feedbacksIntensity;
+			ShakeFar = animFarCurve;
+			RemapFarZero = remapFarMin * feedbacksIntensity;
+			RemapFarOne = remapFarMax * feedbacksIntensity;
+			RelativeClippingPlanes = relativeValues;
+			ForwardDirection = forwardDirection;
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_targetCamera.m_Lens.NearClipPlane = _initialNear;
+			_targetCamera.m_Lens.FarClipPlane = _initialFar;
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			ShakeNear = _originalShakeNear;
+			ShakeFar = _originalShakeFar;
+			RemapNearZero = _originalRemapNearZero;
+			RemapNearOne = _originalRemapNearOne;
+			RemapFarZero = _originalRemapFarZero;
+			RemapFarOne = _originalRemapFarOne;
+			RelativeClippingPlanes = _originalRelativeClippingPlanes;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMCameraClippingPlanesShakeEvent.Register(OnMMCameraClippingPlanesShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMCameraClippingPlanesShakeEvent.Unregister(OnMMCameraClippingPlanesShakeEvent);
+		}
+		#endif
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachineClippingPlanesShaker.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9ff80f834f6ca564da816a2f08bc75f0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachineFieldOfViewShaker.cs

@@ -0,0 +1,177 @@
+using UnityEngine;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this to a Cinemachine virtual camera and it'll let you control its field of view over time, can be piloted by a MMFeedbackCameraFieldOfView
+	/// </summary>
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/Cinemachine/MMCinemachineFieldOfViewShaker")]
+	#if MM_CINEMACHINE
+	[RequireComponent(typeof(CinemachineVirtualCamera))]
+	#endif
+	public class MMCinemachineFieldOfViewShaker : MMShaker
+	{
+		[MMInspectorGroup("Field of view", true, 41)]
+		/// whether or not to add to the initial value
+		[Tooltip("whether or not to add to the initial value")]
+		public bool RelativeFieldOfView = false;
+		/// the curve used to animate the intensity value on
+		[Tooltip("the curve used to animate the intensity value on")]
+		public AnimationCurve ShakeFieldOfView = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
+		/// the value to remap the curve's 0 to
+		[Tooltip("the value to remap the curve's 0 to")]
+		[Range(0f, 179f)]
+		public float RemapFieldOfViewZero = 60f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(0f, 179f)]
+		public float RemapFieldOfViewOne = 120f;
+
+		#if MM_CINEMACHINE
+		protected CinemachineVirtualCamera _targetCamera;
+		protected float _initialFieldOfView;
+		protected float _originalShakeDuration;
+		protected bool _originalRelativeFieldOfView;
+		protected AnimationCurve _originalShakeFieldOfView;
+		protected float _originalRemapFieldOfViewZero;
+		protected float _originalRemapFieldOfViewOne;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_targetCamera = this.gameObject.GetComponent<CinemachineVirtualCamera>();
+		}
+
+		/// <summary>
+		/// When that shaker gets added, we initialize its shake duration
+		/// </summary>
+		protected virtual void Reset()
+		{
+			ShakeDuration = 0.5f;
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newFieldOfView = ShakeFloat(ShakeFieldOfView, RemapFieldOfViewZero, RemapFieldOfViewOne, RelativeFieldOfView, _initialFieldOfView);
+			_targetCamera.m_Lens.FieldOfView = newFieldOfView;
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialFieldOfView = _targetCamera.m_Lens.FieldOfView;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="distortionCurve"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeDistortion"></param>
+		/// <param name="feedbacksIntensity"></param>
+		/// <param name="channel"></param>
+		public virtual void OnMMCameraFieldOfViewShakeEvent(AnimationCurve distortionCurve, float duration, float remapMin, float remapMax, bool relativeDistortion = false,
+			float feedbacksIntensity = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, bool forwardDirection = true, 
+			TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			if (!CheckEventAllowed(channelData))
+			{
+				return;
+			}
+            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+            
+			if (!Interruptible && Shaking)
+			{
+				return;
+			}
+            
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalShakeFieldOfView = ShakeFieldOfView;
+				_originalRemapFieldOfViewZero = RemapFieldOfViewZero;
+				_originalRemapFieldOfViewOne = RemapFieldOfViewOne;
+				_originalRelativeFieldOfView = RelativeFieldOfView;
+			}
+
+			TimescaleMode = timescaleMode;
+			ShakeDuration = duration;
+			ShakeFieldOfView = distortionCurve;
+			RemapFieldOfViewZero = remapMin * feedbacksIntensity;
+			RemapFieldOfViewOne = remapMax * feedbacksIntensity;
+			RelativeFieldOfView = relativeDistortion;
+			ForwardDirection = forwardDirection;
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_targetCamera.m_Lens.FieldOfView = _initialFieldOfView;
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			ShakeFieldOfView = _originalShakeFieldOfView;
+			RemapFieldOfViewZero = _originalRemapFieldOfViewZero;
+			RemapFieldOfViewOne = _originalRemapFieldOfViewOne;
+			RelativeFieldOfView = _originalRelativeFieldOfView;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMCameraFieldOfViewShakeEvent.Register(OnMMCameraFieldOfViewShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMCameraFieldOfViewShakeEvent.Unregister(OnMMCameraFieldOfViewShakeEvent);
+		}
+		#endif
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachineFieldOfViewShaker.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d68394ff0deaba948873307b5fe5a801
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachineFreeLookZoom.cs

@@ -0,0 +1,217 @@
+using UnityEngine;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This class will allow you to trigger zooms on your cinemachine camera by sending MMCameraZoomEvents from any other class
+	/// </summary>
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/Cinemachine/MMCinemachineFreeLookZoom")]
+	#if MM_CINEMACHINE
+	[RequireComponent(typeof(Cinemachine.CinemachineFreeLook))]
+	#endif
+	public class MMCinemachineFreeLookZoom : MonoBehaviour
+	{
+		[Header("Channel")]
+		[MMFInspectorGroup("Shaker Settings", true, 3)]
+		/// whether to listen on a channel defined by an int or by a MMChannel scriptable object. Ints are simple to setup but can get messy and make it harder to remember what int corresponds to what.
+		/// MMChannel scriptable objects require you to create them in advance, but come with a readable name and are more scalable
+		[Tooltip("whether to listen on a channel defined by an int or by a MMChannel scriptable object. Ints are simple to setup but can get messy and make it harder to remember what int corresponds to what. " +
+		         "MMChannel scriptable objects require you to create them in advance, but come with a readable name and are more scalable")]
+		public MMChannelModes ChannelMode = MMChannelModes.Int;
+		/// the channel to listen to - has to match the one on the feedback
+		[Tooltip("the channel to listen to - has to match the one on the feedback")]
+		[MMFEnumCondition("ChannelMode", (int)MMChannelModes.Int)]
+		public int Channel = 0;
+		/// the MMChannel definition asset to use to listen for events. The feedbacks targeting this shaker will have to reference that same MMChannel definition to receive events - to create a MMChannel,
+		/// right click anywhere in your project (usually in a Data folder) and go MoreMountains > MMChannel, then name it with some unique name
+		[Tooltip("the MMChannel definition asset to use to listen for events. The feedbacks targeting this shaker will have to reference that same MMChannel definition to receive events - to create a MMChannel, " +
+		         "right click anywhere in your project (usually in a Data folder) and go MoreMountains > MMChannel, then name it with some unique name")]
+		[MMFEnumCondition("ChannelMode", (int)MMChannelModes.MMChannel)]
+		public MMChannel MMChannelDefinition = null;
+
+		[Header("Transition Speed")]
+		/// the animation curve to apply to the zoom transition
+		[Tooltip("the animation curve to apply to the zoom transition")]
+		public AnimationCurve ZoomCurve = new AnimationCurve(new Keyframe(0f, 0f), new Keyframe(1f, 1f));
+
+		[Header("Test Zoom")]
+		/// the mode to apply the zoom in when using the test button in the inspector
+		[Tooltip("the mode to apply the zoom in when using the test button in the inspector")]
+		public MMCameraZoomModes TestMode;
+		/// the target field of view to apply the zoom in when using the test button in the inspector
+		[Tooltip("the target field of view to apply the zoom in when using the test button in the inspector")]
+		public float TestFieldOfView = 30f;
+		/// the transition duration to apply the zoom in when using the test button in the inspector
+		[Tooltip("the transition duration to apply the zoom in when using the test button in the inspector")]
+		public float TestTransitionDuration = 0.1f;
+		/// the duration to apply the zoom in when using the test button in the inspector
+		[Tooltip("the duration to apply the zoom in when using the test button in the inspector")]
+		public float TestDuration = 0.05f;
+
+		[MMFInspectorButton("TestZoom")]
+		/// an inspector button to test the zoom in play mode
+		public bool TestZoomButton;
+
+		#if MM_CINEMACHINE
+		protected Cinemachine.CinemachineFreeLook _freeLookCamera;
+		protected float _initialFieldOfView;
+		protected MMCameraZoomModes _mode;
+		protected bool _zooming = false;
+		protected float _startFieldOfView;
+		protected float _transitionDuration;
+		protected float _duration;
+		protected float _targetFieldOfView;
+		protected float _delta = 0f;
+		protected int _direction = 1;
+		protected float _reachedDestinationTimestamp;
+		protected bool _destinationReached = false;
+
+		/// <summary>
+		/// On Awake we grab our virtual camera
+		/// </summary>
+		protected virtual void Awake()
+		{
+			_freeLookCamera = this.gameObject.GetComponent<Cinemachine.CinemachineFreeLook>();
+			_initialFieldOfView = _freeLookCamera.m_Lens.FieldOfView;
+		}	
+        
+		/// <summary>
+		/// On Update if we're zooming we modify our field of view accordingly
+		/// </summary>
+		protected virtual void Update()
+		{
+			if (!_zooming)
+			{
+				return;
+			}
+
+			if (_freeLookCamera.m_Lens.FieldOfView != _targetFieldOfView)
+			{
+				_delta += Time.deltaTime / _transitionDuration;
+				_freeLookCamera.m_Lens.FieldOfView = Mathf.LerpUnclamped(_startFieldOfView, _targetFieldOfView, ZoomCurve.Evaluate(_delta));
+			}
+			else
+			{
+				if (!_destinationReached)
+				{
+					_reachedDestinationTimestamp = Time.time;
+					_destinationReached = true;
+				}
+
+				if ((_mode == MMCameraZoomModes.For) && (_direction == 1))
+				{
+					if (Time.time - _reachedDestinationTimestamp > _duration)
+					{
+						_direction = -1;
+						_startFieldOfView = _targetFieldOfView;
+						_targetFieldOfView = _initialFieldOfView;
+						_delta = 0f;
+					}                    
+				}
+				else
+				{
+					_zooming = false;
+				}                
+			}
+		}
+
+		/// <summary>
+		/// A method that triggers the zoom, ideally only to be called via an event, but public for convenience
+		/// </summary>
+		/// <param name="mode"></param>
+		/// <param name="newFieldOfView"></param>
+		/// <param name="transitionDuration"></param>
+		/// <param name="duration"></param>
+		public virtual void Zoom(MMCameraZoomModes mode, float newFieldOfView, float transitionDuration, float duration, bool relative = false)
+		{
+			if (_zooming)
+			{
+				return;
+			}
+
+			_zooming = true;
+			_delta = 0f;
+			_mode = mode;
+
+			_startFieldOfView = _freeLookCamera.m_Lens.FieldOfView;
+			_transitionDuration = transitionDuration;
+			_duration = duration;
+			_transitionDuration = transitionDuration;
+			_direction = 1;
+			_destinationReached = false;
+
+			switch (mode)
+			{
+				case MMCameraZoomModes.For:
+					_targetFieldOfView = newFieldOfView;
+					break;
+
+				case MMCameraZoomModes.Set:
+					_targetFieldOfView = newFieldOfView;
+					break;
+
+				case MMCameraZoomModes.Reset:
+					_targetFieldOfView = _initialFieldOfView;
+					break;
+			}
+
+			if (relative)
+			{
+				_targetFieldOfView += _initialFieldOfView;
+			}
+
+		}
+
+		/// <summary>
+		/// The method used by the test button to trigger a test zoom
+		/// </summary>
+		protected virtual void TestZoom()
+		{
+			Zoom(TestMode, TestFieldOfView, TestTransitionDuration, TestDuration);
+		}
+
+		/// <summary>
+		/// When we get an MMCameraZoomEvent we call our zoom method 
+		/// </summary>
+		/// <param name="zoomEvent"></param>
+		public virtual void OnCameraZoomEvent(MMCameraZoomModes mode, float newFieldOfView, float transitionDuration, float duration, MMChannelData channelData, bool useUnscaledTime, bool stop = false, bool relative = false, bool restore = false)
+		{
+			if (!MMChannel.Match(channelData, ChannelMode, Channel, MMChannelDefinition))
+			{
+				return;
+			}
+			if (stop)
+			{
+				_zooming = false;
+				return;
+			}
+			if (restore)
+			{
+				_freeLookCamera.m_Lens.FieldOfView = _initialFieldOfView;
+				return;
+			}
+			this.Zoom(mode, newFieldOfView, transitionDuration, duration, relative);
+		}
+
+		/// <summary>
+		/// Starts listening for MMCameraZoomEvents
+		/// </summary>
+		protected virtual void OnEnable()
+		{
+			MMCameraZoomEvent.Register(OnCameraZoomEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for MMCameraZoomEvents
+		/// </summary>
+		protected virtual void OnDisable()
+		{
+			MMCameraZoomEvent.Unregister(OnCameraZoomEvent);
+		}
+		#endif
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachineFreeLookZoom.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c5c6086564eb2a44db13fc3cd3a66644
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachineOrthographicSizeShaker.cs

@@ -0,0 +1,173 @@
+using UnityEngine;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this to a Cinemachine virtual camera and it'll let you control its orthographic size over time, can be piloted by a MMFeedbackCameraOrthographicSize
+	/// </summary>
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/Cinemachine/MMCinemachineOrthographicSizeShaker")]
+	#if MM_CINEMACHINE
+	[RequireComponent(typeof(CinemachineVirtualCamera))]
+	#endif
+	public class MMCinemachineOrthographicSizeShaker : MMShaker
+	{
+		[MMInspectorGroup("Orthographic Size", true, 43)]
+		/// whether or not to add to the initial value
+		[Tooltip("whether or not to add to the initial value")]
+		public bool RelativeOrthographicSize = false;
+		/// the curve used to animate the intensity value on
+		[Tooltip("the curve used to animate the intensity value on")]
+		public AnimationCurve ShakeOrthographicSize = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
+		/// the value to remap the curve's 0 to
+		[Tooltip("the value to remap the curve's 0 to")]
+		public float RemapOrthographicSizeZero = 5f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapOrthographicSizeOne = 10f;
+
+		#if MM_CINEMACHINE
+		protected CinemachineVirtualCamera _targetCamera;
+		protected float _initialOrthographicSize;
+		protected float _originalShakeDuration;
+		protected bool _originalRelativeOrthographicSize;
+		protected AnimationCurve _originalShakeOrthographicSize;
+		protected float _originalRemapOrthographicSizeZero;
+		protected float _originalRemapOrthographicSizeOne;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_targetCamera = this.gameObject.GetComponent<CinemachineVirtualCamera>();
+		}
+
+		/// <summary>
+		/// When that shaker gets added, we initialize its shake duration
+		/// </summary>
+		protected virtual void Reset()
+		{
+			ShakeDuration = 0.5f;
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newOrthographicSize = ShakeFloat(ShakeOrthographicSize, RemapOrthographicSizeZero, RemapOrthographicSizeOne, RelativeOrthographicSize, _initialOrthographicSize);
+			_targetCamera.m_Lens.OrthographicSize = newOrthographicSize;
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialOrthographicSize = _targetCamera.m_Lens.OrthographicSize;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="distortionCurve"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeDistortion"></param>
+		/// <param name="feedbacksIntensity"></param>
+		/// <param name="channel"></param>
+		public virtual void OnMMCameraOrthographicSizeShakeEvent(AnimationCurve distortionCurve, float duration, float remapMin, float remapMax, bool relativeDistortion = false,
+			float feedbacksIntensity = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, bool forwardDirection = true, bool stop = false, bool restore = false)
+		{
+			if (!CheckEventAllowed(channelData))
+			{
+				return;
+			}
+            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+            
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+            
+			if (!Interruptible && Shaking)
+			{
+				return;
+			}
+            
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalShakeOrthographicSize = ShakeOrthographicSize;
+				_originalRemapOrthographicSizeZero = RemapOrthographicSizeZero;
+				_originalRemapOrthographicSizeOne = RemapOrthographicSizeOne;
+				_originalRelativeOrthographicSize = RelativeOrthographicSize;
+			}
+
+			ShakeDuration = duration;
+			ShakeOrthographicSize = distortionCurve;
+			RemapOrthographicSizeZero = remapMin * feedbacksIntensity;
+			RemapOrthographicSizeOne = remapMax * feedbacksIntensity;
+			RelativeOrthographicSize = relativeDistortion;
+			ForwardDirection = forwardDirection;
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_targetCamera.m_Lens.OrthographicSize = _initialOrthographicSize;
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			ShakeOrthographicSize = _originalShakeOrthographicSize;
+			RemapOrthographicSizeZero = _originalRemapOrthographicSizeZero;
+			RemapOrthographicSizeOne = _originalRemapOrthographicSizeOne;
+			RelativeOrthographicSize = _originalRelativeOrthographicSize;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMCameraOrthographicSizeShakeEvent.Register(OnMMCameraOrthographicSizeShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMCameraOrthographicSizeShakeEvent.Unregister(OnMMCameraOrthographicSizeShakeEvent);
+		}
+		#endif
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachineOrthographicSizeShaker.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0aded04d7fa45744fb33cc0a43b0d6ef
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachinePriorityBrainListener.cs

@@ -0,0 +1,105 @@
+using System.Collections;
+using UnityEngine;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this to a Cinemachine brain and it'll be able to accept custom blend transitions (used with MMFeedbackCinemachineTransition)
+	/// </summary>
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/Cinemachine/MMCinemachinePriorityBrainListener")]
+	#if MM_CINEMACHINE
+	[RequireComponent(typeof(CinemachineBrain))]
+	#endif
+	public class MMCinemachinePriorityBrainListener : MonoBehaviour
+	{
+        
+		[HideInInspector] 
+		public TimescaleModes TimescaleMode = TimescaleModes.Scaled;
+        
+        
+		public virtual float GetTime() { return (TimescaleMode == TimescaleModes.Scaled) ? Time.time : Time.unscaledTime; }
+		public virtual float GetDeltaTime() { return (TimescaleMode == TimescaleModes.Scaled) ? Time.deltaTime : Time.unscaledDeltaTime; }
+    
+		#if MM_CINEMACHINE    
+		protected CinemachineBrain _brain;
+		protected CinemachineBlendDefinition _initialDefinition;
+		protected Coroutine _coroutine;
+
+		/// <summary>
+		/// On Awake we grab our brain
+		/// </summary>
+		protected virtual void Awake()
+		{
+			_brain = this.gameObject.GetComponent<CinemachineBrain>();
+		}
+
+		/// <summary>
+		/// When getting an event we change our default transition if needed
+		/// </summary>
+		/// <param name="channel"></param>
+		/// <param name="forceMaxPriority"></param>
+		/// <param name="newPriority"></param>
+		/// <param name="forceTransition"></param>
+		/// <param name="blendDefinition"></param>
+		/// <param name="resetValuesAfterTransition"></param>
+		public virtual void OnMMCinemachinePriorityEvent(MMChannelData channelData, bool forceMaxPriority, int newPriority, bool forceTransition, CinemachineBlendDefinition blendDefinition, bool resetValuesAfterTransition, TimescaleModes timescaleMode, bool restore = false)
+		{
+			if (forceTransition)
+			{
+				if (_coroutine != null)
+				{
+					StopCoroutine(_coroutine);
+				}
+				else
+				{
+					_initialDefinition = _brain.m_DefaultBlend;
+				}
+				_brain.m_DefaultBlend = blendDefinition;
+				TimescaleMode = timescaleMode;
+				_coroutine = StartCoroutine(ResetBlendDefinition(blendDefinition.m_Time));                
+			}
+		}
+
+		/// <summary>
+		/// a coroutine used to reset the default transition to its initial value
+		/// </summary>
+		/// <param name="delay"></param>
+		/// <returns></returns>
+		protected virtual IEnumerator ResetBlendDefinition(float delay)
+		{
+			for (float timer = 0; timer < delay; timer += GetDeltaTime())
+			{
+				yield return null;
+			}
+			_brain.m_DefaultBlend = _initialDefinition;
+			_coroutine = null;
+		}
+
+		/// <summary>
+		/// On enable we start listening for events
+		/// </summary>
+		protected virtual void OnEnable()
+		{
+			_coroutine = null;
+			MMCinemachinePriorityEvent.Register(OnMMCinemachinePriorityEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		protected virtual void OnDisable()
+		{
+			if (_coroutine != null)
+			{
+				StopCoroutine(_coroutine);
+			}
+			_coroutine = null;
+			MMCinemachinePriorityEvent.Unregister(OnMMCinemachinePriorityEvent);
+		}
+		#endif
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachinePriorityBrainListener.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2436c2ba147129746badf6cfa2ee2d1b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachinePriorityListener.cs

@@ -0,0 +1,127 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this to a Cinemachine virtual camera and it'll be able to listen to MMCinemachinePriorityEvent, usually triggered by a MMFeedbackCinemachineTransition
+	/// </summary>
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/Cinemachine/MMCinemachinePriorityListener")]
+	#if MM_CINEMACHINE
+	[RequireComponent(typeof(CinemachineVirtualCameraBase))]
+	#endif
+	public class MMCinemachinePriorityListener : MonoBehaviour
+	{
+        
+		[HideInInspector] 
+		public TimescaleModes TimescaleMode = TimescaleModes.Scaled;
+        
+        
+		public virtual float GetTime() { return (TimescaleMode == TimescaleModes.Scaled) ? Time.time : Time.unscaledTime; }
+		public virtual float GetDeltaTime() { return (TimescaleMode == TimescaleModes.Scaled) ? Time.deltaTime : Time.unscaledDeltaTime; }
+        
+		[Header("Priority Listener")]
+		[Tooltip("whether to listen on a channel defined by an int or by a MMChannel scriptable object. Ints are simple to setup but can get messy and make it harder to remember what int corresponds to what. " +
+		         "MMChannel scriptable objects require you to create them in advance, but come with a readable name and are more scalable")]
+		public MMChannelModes ChannelMode = MMChannelModes.Int;
+		/// the channel to listen to - has to match the one on the feedback
+		[Tooltip("the channel to listen to - has to match the one on the feedback")]
+		[MMFEnumCondition("ChannelMode", (int)MMChannelModes.Int)]
+		public int Channel = 0;
+		/// the MMChannel definition asset to use to listen for events. The feedbacks targeting this shaker will have to reference that same MMChannel definition to receive events - to create a MMChannel,
+		/// right click anywhere in your project (usually in a Data folder) and go MoreMountains > MMChannel, then name it with some unique name
+		[Tooltip("the MMChannel definition asset to use to listen for events. The feedbacks targeting this shaker will have to reference that same MMChannel definition to receive events - to create a MMChannel, " +
+		         "right click anywhere in your project (usually in a Data folder) and go MoreMountains > MMChannel, then name it with some unique name")]
+		[MMFEnumCondition("ChannelMode", (int)MMChannelModes.MMChannel)]
+		public MMChannel MMChannelDefinition = null;
+
+		#if MM_CINEMACHINE
+		protected CinemachineVirtualCameraBase _camera;
+		protected int _initialPriority;
+        
+		/// <summary>
+		/// On Awake we store our virtual camera
+		/// </summary>
+		protected virtual void Awake()
+		{
+			_camera = this.gameObject.GetComponent<CinemachineVirtualCameraBase>();
+			_initialPriority = _camera.Priority;
+		}
+
+		/// <summary>
+		/// When we get an event we change our priorities if needed
+		/// </summary>
+		/// <param name="channel"></param>
+		/// <param name="forceMaxPriority"></param>
+		/// <param name="newPriority"></param>
+		/// <param name="forceTransition"></param>
+		/// <param name="blendDefinition"></param>
+		/// <param name="resetValuesAfterTransition"></param>
+		public virtual void OnMMCinemachinePriorityEvent(MMChannelData channelData, bool forceMaxPriority, int newPriority, bool forceTransition, CinemachineBlendDefinition blendDefinition, bool resetValuesAfterTransition, TimescaleModes timescaleMode, bool restore = false)
+		{
+			TimescaleMode = timescaleMode;
+			if (MMChannel.Match(channelData, ChannelMode, Channel, MMChannelDefinition))
+			{
+				if (restore)
+				{
+					_camera.Priority = _initialPriority;	
+					return;
+				}
+				_camera.Priority = newPriority;
+			}
+			else
+			{
+				if (forceMaxPriority)
+				{
+					if (restore)
+					{
+						_camera.Priority = _initialPriority;	
+						return;
+					}
+					_camera.Priority = 0;
+				}
+			}
+		}
+
+		/// <summary>
+		/// On enable we start listening for events
+		/// </summary>
+		protected virtual void OnEnable()
+		{
+			MMCinemachinePriorityEvent.Register(OnMMCinemachinePriorityEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		protected virtual void OnDisable()
+		{
+			MMCinemachinePriorityEvent.Unregister(OnMMCinemachinePriorityEvent);
+		}
+		#endif
+	}
+
+	/// <summary>
+	/// An event used to pilot priorities on cinemachine virtual cameras and brain transitions
+	/// </summary>
+	public struct MMCinemachinePriorityEvent
+	{
+		#if MM_CINEMACHINE
+		static private event Delegate OnEvent;
+		[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)] private static void RuntimeInitialization() { OnEvent = null; }
+		static public void Register(Delegate callback) { OnEvent += callback; }
+		static public void Unregister(Delegate callback) { OnEvent -= callback; }
+
+		public delegate void Delegate(MMChannelData channelData, bool forceMaxPriority, int newPriority, bool forceTransition, CinemachineBlendDefinition blendDefinition, bool resetValuesAfterTransition, TimescaleModes timescaleMode, bool restore = false);
+		static public void Trigger(MMChannelData channelData, bool forceMaxPriority, int newPriority, bool forceTransition, CinemachineBlendDefinition blendDefinition, bool resetValuesAfterTransition, TimescaleModes timescaleMode, bool restore = false)
+		{
+			OnEvent?.Invoke(channelData, forceMaxPriority, newPriority, forceTransition, blendDefinition, resetValuesAfterTransition, timescaleMode, restore);
+		}
+		#endif
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachinePriorityListener.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f8650a79a9f5e38449718559d1d6a2f5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachineZoom.cs

@@ -0,0 +1,222 @@
+using UnityEngine;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This class will allow you to trigger zooms on your cinemachine camera by sending MMCameraZoomEvents from any other class
+	/// </summary>
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/Cinemachine/MMCinemachineZoom")]
+	#if MM_CINEMACHINE
+	[RequireComponent(typeof(Cinemachine.CinemachineVirtualCamera))]
+	#endif
+	public class MMCinemachineZoom : MonoBehaviour
+	{
+		[Header("Channel")]
+		[MMFInspectorGroup("Shaker Settings", true, 3)]
+		/// whether to listen on a channel defined by an int or by a MMChannel scriptable object. Ints are simple to setup but can get messy and make it harder to remember what int corresponds to what.
+		/// MMChannel scriptable objects require you to create them in advance, but come with a readable name and are more scalable
+		[Tooltip("whether to listen on a channel defined by an int or by a MMChannel scriptable object. Ints are simple to setup but can get messy and make it harder to remember what int corresponds to what. " +
+		         "MMChannel scriptable objects require you to create them in advance, but come with a readable name and are more scalable")]
+		public MMChannelModes ChannelMode = MMChannelModes.Int;
+		/// the channel to listen to - has to match the one on the feedback
+		[Tooltip("the channel to listen to - has to match the one on the feedback")]
+		[MMFEnumCondition("ChannelMode", (int)MMChannelModes.Int)]
+		public int Channel = 0;
+		/// the MMChannel definition asset to use to listen for events. The feedbacks targeting this shaker will have to reference that same MMChannel definition to receive events - to create a MMChannel,
+		/// right click anywhere in your project (usually in a Data folder) and go MoreMountains > MMChannel, then name it with some unique name
+		[Tooltip("the MMChannel definition asset to use to listen for events. The feedbacks targeting this shaker will have to reference that same MMChannel definition to receive events - to create a MMChannel, " +
+		         "right click anywhere in your project (usually in a Data folder) and go MoreMountains > MMChannel, then name it with some unique name")]
+		[MMFEnumCondition("ChannelMode", (int)MMChannelModes.MMChannel)]
+		public MMChannel MMChannelDefinition = null;
+
+		[Header("Transition Speed")]
+		/// the animation curve to apply to the zoom transition
+		[Tooltip("the animation curve to apply to the zoom transition")]
+		public AnimationCurve ZoomCurve = new AnimationCurve(new Keyframe(0f, 0f), new Keyframe(1f, 1f));
+
+		[Header("Test Zoom")]
+		/// the mode to apply the zoom in when using the test button in the inspector
+		[Tooltip("the mode to apply the zoom in when using the test button in the inspector")]
+		public MMCameraZoomModes TestMode;
+		/// the target field of view to apply the zoom in when using the test button in the inspector
+		[Tooltip("the target field of view to apply the zoom in when using the test button in the inspector")]
+		public float TestFieldOfView = 30f;
+		/// the transition duration to apply the zoom in when using the test button in the inspector
+		[Tooltip("the transition duration to apply the zoom in when using the test button in the inspector")]
+		public float TestTransitionDuration = 0.1f;
+		/// the duration to apply the zoom in when using the test button in the inspector
+		[Tooltip("the duration to apply the zoom in when using the test button in the inspector")]
+		public float TestDuration = 0.05f;
+
+		[MMFInspectorButton("TestZoom")]
+		/// an inspector button to test the zoom in play mode
+		public bool TestZoomButton;
+
+		public virtual float GetTime() { return (TimescaleMode == TimescaleModes.Scaled) ? Time.time : Time.unscaledTime; }
+		public virtual float GetDeltaTime() { return (TimescaleMode == TimescaleModes.Scaled) ? Time.deltaTime : Time.unscaledDeltaTime; }
+
+		public TimescaleModes TimescaleMode { get; set; }
+        
+		#if MM_CINEMACHINE
+		protected Cinemachine.CinemachineVirtualCamera _virtualCamera;
+		protected float _initialFieldOfView;
+		protected MMCameraZoomModes _mode;
+		protected bool _zooming = false;
+		protected float _startFieldOfView;
+		protected float _transitionDuration;
+		protected float _duration;
+		protected float _targetFieldOfView;
+		protected float _delta = 0f;
+		protected int _direction = 1;
+		protected float _reachedDestinationTimestamp;
+		protected bool _destinationReached = false;
+
+		/// <summary>
+		/// On Awake we grab our virtual camera
+		/// </summary>
+		protected virtual void Awake()
+		{
+			_virtualCamera = this.gameObject.GetComponent<Cinemachine.CinemachineVirtualCamera>();
+			_initialFieldOfView = _virtualCamera.m_Lens.FieldOfView;
+		}	
+        
+		/// <summary>
+		/// On Update if we're zooming we modify our field of view accordingly
+		/// </summary>
+		protected virtual void Update()
+		{
+			if (!_zooming)
+			{
+				return;
+			}
+            
+			if (_virtualCamera.m_Lens.FieldOfView != _targetFieldOfView)
+			{
+				_delta += GetDeltaTime() / _transitionDuration;
+				_virtualCamera.m_Lens.FieldOfView = Mathf.LerpUnclamped(_startFieldOfView, _targetFieldOfView, ZoomCurve.Evaluate(_delta));
+			}
+			else
+			{
+				if (!_destinationReached)
+				{
+					_reachedDestinationTimestamp = GetTime();
+					_destinationReached = true;
+				}
+
+				if ((_mode == MMCameraZoomModes.For) && (_direction == 1))
+				{
+					if (GetTime() - _reachedDestinationTimestamp > _duration)
+					{
+						_direction = -1;
+						_startFieldOfView = _targetFieldOfView;
+						_targetFieldOfView = _initialFieldOfView;
+						_delta = 0f;
+					}                    
+				}
+				else
+				{
+					_zooming = false;
+				}                
+			}
+		}
+
+		/// <summary>
+		/// A method that triggers the zoom, ideally only to be called via an event, but public for convenience
+		/// </summary>
+		/// <param name="mode"></param>
+		/// <param name="newFieldOfView"></param>
+		/// <param name="transitionDuration"></param>
+		/// <param name="duration"></param>
+		public virtual void Zoom(MMCameraZoomModes mode, float newFieldOfView, float transitionDuration, float duration, bool useUnscaledTime, bool relative = false)
+		{
+			if (_zooming)
+			{
+				return;
+			}
+
+			_zooming = true;
+			_delta = 0f;
+			_mode = mode;
+
+			TimescaleMode = useUnscaledTime ? TimescaleModes.Unscaled : TimescaleModes.Scaled;
+			_startFieldOfView = _virtualCamera.m_Lens.FieldOfView;
+			_transitionDuration = transitionDuration;
+			_duration = duration;
+			_transitionDuration = transitionDuration;
+			_direction = 1;
+			_destinationReached = false;
+
+			switch (mode)
+			{
+				case MMCameraZoomModes.For:
+					_targetFieldOfView = newFieldOfView;
+					break;
+
+				case MMCameraZoomModes.Set:
+					_targetFieldOfView = newFieldOfView;
+					break;
+
+				case MMCameraZoomModes.Reset:
+					_targetFieldOfView = _initialFieldOfView;
+					break;
+			}
+
+			if (relative)
+			{
+				_targetFieldOfView += _initialFieldOfView;
+			}
+		}
+
+		/// <summary>
+		/// The method used by the test button to trigger a test zoom
+		/// </summary>
+		protected virtual void TestZoom()
+		{
+			Zoom(TestMode, TestFieldOfView, TestTransitionDuration, TestDuration, false);
+		}
+
+		/// <summary>
+		/// When we get an MMCameraZoomEvent we call our zoom method 
+		/// </summary>
+		/// <param name="zoomEvent"></param>
+		public virtual void OnCameraZoomEvent(MMCameraZoomModes mode, float newFieldOfView, float transitionDuration, float duration, MMChannelData channelData, bool useUnscaledTime, bool stop = false, bool relative = false, bool restore = false)
+		{
+			if (!MMChannel.Match(channelData, ChannelMode, Channel, MMChannelDefinition))
+			{
+				return;
+			}
+			if (stop)
+			{
+				_zooming = false;
+				return;
+			}
+			if (restore)
+			{
+				_virtualCamera.m_Lens.FieldOfView = _initialFieldOfView;
+				return;
+			}
+			this.Zoom(mode, newFieldOfView, transitionDuration, duration, useUnscaledTime, relative);
+		}
+
+		/// <summary>
+		/// Starts listening for MMCameraZoomEvents
+		/// </summary>
+		protected virtual void OnEnable()
+		{
+			MMCameraZoomEvent.Register(OnCameraZoomEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for MMCameraZoomEvents
+		/// </summary>
+		protected virtual void OnDisable()
+		{
+			MMCameraZoomEvent.Unregister(OnCameraZoomEvent);
+		}
+		#endif
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Shakers/MMCinemachineZoom.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 51662a222e352d74a8ad12e5843f7501
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: