Insanely huge initial commit

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 76b756cf8480fcd4bb9db669233c29c5
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/Legacy.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7637ac98d89986948b50c6158d9a78e7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/Legacy/MMFeedbackCinemachineImpulse.cs

@@ -0,0 +1,74 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	[AddComponentMenu("")]
+	[FeedbackPath("Camera/Cinemachine Impulse")]
+	[FeedbackHelp("This feedback lets you trigger a Cinemachine Impulse event. You'll need a Cinemachine Impulse Listener on your camera for this to work.")]
+	public class MMFeedbackCinemachineImpulse : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.CameraColor; } }
+		#endif
+
+		[Header("Cinemachine Impulse")]
+		#if MM_CINEMACHINE
+		/// the impulse definition to broadcast
+		[Tooltip("the impulse definition to broadcast")]
+		[CinemachineImpulseDefinitionProperty]
+		public CinemachineImpulseDefinition m_ImpulseDefinition;
+		#endif
+        
+		/// the velocity to apply to the impulse shake
+		[Tooltip("the velocity to apply to the impulse shake")]
+		public Vector3 Velocity;
+		/// whether or not to clear impulses (stopping camera shakes) when the Stop method is called on that feedback
+		[Tooltip("whether or not to clear impulses (stopping camera shakes) when the Stop method is called on that feedback")]
+		public bool ClearImpulseOnStop = false;
+
+		#if MM_CINEMACHINE
+		/// the duration of this feedback is the duration of the impulse
+		public override float FeedbackDuration { get { return m_ImpulseDefinition.m_TimeEnvelope.Duration; } }
+		#endif
+
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}       
+			#if MM_CINEMACHINE 
+			CinemachineImpulseManager.Instance.IgnoreTimeScale = (Timing.TimescaleMode == TimescaleModes.Unscaled);
+			float intensityMultiplier = Timing.ConstantIntensity ? 1f : feedbacksIntensity;
+			m_ImpulseDefinition.CreateEvent(position, Velocity * intensityMultiplier);
+			#endif
+		}
+
+		/// <summary>
+		/// Stops the animation if needed
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!Active || !FeedbackTypeAuthorized || !ClearImpulseOnStop)
+			{
+				return;
+			}
+			base.CustomStopFeedback(position, feedbacksIntensity);
+            
+			#if MM_CINEMACHINE
+			CinemachineImpulseManager.Instance.Clear();
+			#endif
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/Legacy/MMFeedbackCinemachineImpulse.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/Legacy/MMFeedbackCinemachineImpulseClear.cs

@@ -0,0 +1,34 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	[AddComponentMenu("")]
+	[FeedbackPath("Camera/Cinemachine Impulse Clear")]
+	[FeedbackHelp("This feedback lets you trigger a Cinemachine Impulse clear, stopping instantly any impulse that may be playing.")]
+	public class MMFeedbackCinemachineImpulseClear : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.CameraColor; } }
+		#endif
+
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			#if MM_CINEMACHINE
+			CinemachineImpulseManager.Instance.Clear();
+			#endif
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/Legacy/MMFeedbackCinemachineImpulseClear.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/Legacy/MMFeedbackCinemachineTransition.cs

@@ -0,0 +1,100 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback will let you change the priorities of your cameras. 
+	/// It requires a bit of setup : adding a MMCinemachinePriorityListener to your different cameras, with unique Channel values on them.
+	/// Optionally, you can add a MMCinemachinePriorityBrainListener on your Cinemachine Brain to handle different transition types and durations.
+	/// Then all you have to do is pick a channel and a new priority on your feedback, and play it. Magic transition!
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackPath("Camera/Cinemachine Transition")]
+	[FeedbackHelp("This feedback will let you change the priorities of your cameras. It requires a bit of setup : " +
+	              "adding a MMCinemachinePriorityListener to your different cameras, with unique Channel values on them. " +
+	              "Optionally, you can add a MMCinemachinePriorityBrainListener on your Cinemachine Brain to handle different transition types and durations. " +
+	              "Then all you have to do is pick a channel and a new priority on your feedback, and play it. Magic transition!")]
+	public class MMFeedbackCinemachineTransition : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		public enum Modes { Event, Binding }
+        
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.CameraColor; } }
+		#endif
+		/// the duration of this feedback is the duration of the shake
+		#if MM_CINEMACHINE
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(BlendDefintion.m_Time); } set { BlendDefintion.m_Time = value; } }
+		#endif
+
+		[Header("Cinemachine Transition")] 
+		/// the selected mode (either via event, or via direct binding of a specific camera)
+		[Tooltip("the selected mode (either via event, or via direct binding of a specific camera)")]
+		public Modes Mode = Modes.Event;
+		/// the channel to emit on
+		[Tooltip("the channel to emit on")]
+		public int Channel = 0;
+		#if MM_CINEMACHINE
+		/// the virtual camera to target
+		[Tooltip("the virtual camera to target")]
+		[MMFEnumCondition("Mode", (int)Modes.Binding)]
+		public CinemachineVirtualCamera TargetVirtualCamera;
+		#endif
+		/// whether or not to reset the target's values after shake
+		[Tooltip("whether or not to reset the target's values after shake")]
+		public bool ResetValuesAfterTransition = true;
+
+		[Header("Priority")]
+		/// the new priority to apply to all virtual cameras on the specified channel
+		[Tooltip("the new priority to apply to all virtual cameras on the specified channel")]
+		public int NewPriority = 10;
+		/// whether or not to force all virtual cameras on other channels to reset their priority to zero
+		[Tooltip("whether or not to force all virtual cameras on other channels to reset their priority to zero")]
+		public bool ForceMaxPriority = true;
+		/// whether or not to apply a new blend
+		[Tooltip("whether or not to apply a new blend")]
+		public bool ForceTransition = false;
+        
+		#if MM_CINEMACHINE
+		/// the new blend definition to apply
+		[Tooltip("the new blend definition to apply")]
+		[MMFCondition("ForceTransition", true)]
+		public CinemachineBlendDefinition BlendDefintion;
+
+		protected CinemachineBlendDefinition _tempBlend;
+		#endif
+
+		/// <summary>
+		/// Triggers a priority change on listening virtual cameras
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			#if MM_CINEMACHINE
+			_tempBlend = BlendDefintion;
+			_tempBlend.m_Time = FeedbackDuration;
+			if (Mode == Modes.Event)
+			{
+				MMCinemachinePriorityEvent.Trigger(ChannelData(Channel), ForceMaxPriority, NewPriority, ForceTransition, _tempBlend, ResetValuesAfterTransition, Timing.TimescaleMode);    
+			}
+			else
+			{
+				MMCinemachinePriorityEvent.Trigger(ChannelData(Channel), ForceMaxPriority, 0, ForceTransition, _tempBlend, ResetValuesAfterTransition, Timing.TimescaleMode); 
+				TargetVirtualCamera.Priority = NewPriority;
+			}
+			#endif
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/Legacy/MMFeedbackCinemachineTransition.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/MMF_CinemachineImpulse.cs

@@ -0,0 +1,73 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	[AddComponentMenu("")]
+	#if MM_CINEMACHINE
+	[FeedbackPath("Camera/Cinemachine Impulse")]
+	#endif
+	[FeedbackHelp("This feedback lets you trigger a Cinemachine Impulse event. You'll need a Cinemachine Impulse Listener on your camera for this to work.")]
+	public class MMF_CinemachineImpulse : MMF_Feedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.CameraColor; } }
+		#endif
+		public override bool HasRandomness => true;
+
+		#if MM_CINEMACHINE
+		[MMFInspectorGroup("Cinemachine Impulse", true, 28)]
+		/// the impulse definition to broadcast
+		[Tooltip("the impulse definition to broadcast")]
+		public CinemachineImpulseDefinition m_ImpulseDefinition;
+		/// the velocity to apply to the impulse shake
+		[Tooltip("the velocity to apply to the impulse shake")]
+		public Vector3 Velocity;
+		/// whether or not to clear impulses (stopping camera shakes) when the Stop method is called on that feedback
+		[Tooltip("whether or not to clear impulses (stopping camera shakes) when the Stop method is called on that feedback")]
+		public bool ClearImpulseOnStop = false;
+
+		/// the duration of this feedback is the duration of the impulse
+		public override float FeedbackDuration { get { return m_ImpulseDefinition.m_TimeEnvelope.Duration; } }
+		#endif
+
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+
+			#if MM_CINEMACHINE
+			CinemachineImpulseManager.Instance.IgnoreTimeScale = !InScaledTimescaleMode;
+			float intensityMultiplier = ComputeIntensity(feedbacksIntensity, position);
+			m_ImpulseDefinition.CreateEvent(position, Velocity * intensityMultiplier);
+			#endif
+		}
+
+		/// <summary>
+		/// Stops the animation if needed
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			#if MM_CINEMACHINE
+			if (!Active || !FeedbackTypeAuthorized || !ClearImpulseOnStop)
+			{
+				return;
+			}
+			base.CustomStopFeedback(position, feedbacksIntensity);
+			CinemachineImpulseManager.Instance.Clear();
+			#endif
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/MMF_CinemachineImpulse.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/MMF_CinemachineImpulseClear.cs

@@ -0,0 +1,36 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	[AddComponentMenu("")]
+	#if MM_CINEMACHINE
+	[FeedbackPath("Camera/Cinemachine Impulse Clear")]
+	#endif
+	[FeedbackHelp("This feedback lets you trigger a Cinemachine Impulse clear, stopping instantly any impulse that may be playing.")]
+	public class MMF_CinemachineImpulseClear : MMF_Feedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.CameraColor; } }
+		#endif
+
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			#if MM_CINEMACHINE
+			CinemachineImpulseManager.Instance.Clear();
+			#endif
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/MMF_CinemachineImpulseClear.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/MMF_CinemachineImpulseSource.cs

@@ -0,0 +1,90 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	[AddComponentMenu("")]
+	#if MM_CINEMACHINE
+	[FeedbackPath("Camera/Cinemachine Impulse Source")]
+	#endif
+	[FeedbackHelp("This feedback lets you generate an impulse on a Cinemachine Impulse source. You'll need a Cinemachine Impulse Listener on your camera for this to work.")]
+	public class MMF_CinemachineImpulseSource : MMF_Feedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.CameraColor; } }
+		#if MM_CINEMACHINE
+		public override bool EvaluateRequiresSetup() { return (ImpulseSource == null); }
+		public override string RequiredTargetText { get { return ImpulseSource != null ? ImpulseSource.name : "";  } }
+		#endif
+		public override string RequiresSetupText { get { return "This feedback requires that an ImpulseSource be set to be able to work properly. You can set one below."; } }
+		#endif
+
+		[MMFInspectorGroup("Cinemachine Impulse Source", true, 28)]
+
+		/// the velocity to apply to the impulse shake
+		[Tooltip("the velocity to apply to the impulse shake")]
+		public Vector3 Velocity = new Vector3(1f,1f,1f);
+		#if MM_CINEMACHINE
+		/// the impulse definition to broadcast
+		[Tooltip("the impulse definition to broadcast")]
+		public CinemachineImpulseSource ImpulseSource;
+		#endif
+		/// whether or not to clear impulses (stopping camera shakes) when the Stop method is called on that feedback
+		[Tooltip("whether or not to clear impulses (stopping camera shakes) when the Stop method is called on that feedback")]
+		public bool ClearImpulseOnStop = false;
+        
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+
+			#if MM_CINEMACHINE
+			if (ImpulseSource != null)
+			{
+				ImpulseSource.GenerateImpulse(Velocity);
+			}
+			#endif
+		}
+
+		/// <summary>
+		/// Stops the animation if needed
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!Active || !FeedbackTypeAuthorized || !ClearImpulseOnStop)
+			{
+				return;
+			}
+			base.CustomStopFeedback(position, feedbacksIntensity);
+            
+			#if MM_CINEMACHINE
+			CinemachineImpulseManager.Instance.Clear();
+			#endif
+		}
+		
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			#if MM_CINEMACHINE
+			CinemachineImpulseManager.Instance.Clear();
+			#endif
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/MMF_CinemachineImpulseSource.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/MMF_CinemachineTransition.cs

@@ -0,0 +1,116 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+#if MM_CINEMACHINE
+using Cinemachine;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback will let you change the priorities of your cameras. 
+	/// It requires a bit of setup : adding a MMCinemachinePriorityListener to your different cameras, with unique Channel values on them.
+	/// Optionally, you can add a MMCinemachinePriorityBrainListener on your Cinemachine Brain to handle different transition types and durations.
+	/// Then all you have to do is pick a channel and a new priority on your feedback, and play it. Magic transition!
+	/// </summary>
+	[AddComponentMenu("")]
+	#if MM_CINEMACHINE
+	[FeedbackPath("Camera/Cinemachine Transition")]
+	#endif
+	[FeedbackHelp("This feedback will let you change the priorities of your cameras. It requires a bit of setup : " +
+	              "adding a MMCinemachinePriorityListener to your different cameras, with unique Channel values on them. " +
+	              "Optionally, you can add a MMCinemachinePriorityBrainListener on your Cinemachine Brain to handle different transition types and durations. " +
+	              "Then all you have to do is pick a channel and a new priority on your feedback, and play it. Magic transition!")]
+	public class MMF_CinemachineTransition : MMF_Feedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		public enum Modes { Event, Binding }
+        
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.CameraColor; } }
+		public override string RequiredTargetText => RequiredChannelText;
+		#endif
+		#if MM_CINEMACHINE
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(BlendDefintion.m_Time); } set { BlendDefintion.m_Time = value; } }
+		#endif
+		public override bool HasChannel => true;
+
+		[MMFInspectorGroup("Cinemachine Transition", true, 52)]
+		/// the selected mode (either via event, or via direct binding of a specific camera)
+		[Tooltip("the selected mode (either via event, or via direct binding of a specific camera)")]
+		public Modes Mode = Modes.Event;
+		#if MM_CINEMACHINE
+		/// the virtual camera to target
+		[Tooltip("the virtual camera to target")]
+		[MMFEnumCondition("Mode", (int)Modes.Binding)]
+		public CinemachineVirtualCamera TargetVirtualCamera;
+		#endif
+		/// whether or not to reset the target's values after shake
+		[Tooltip("whether or not to reset the target's values after shake")]
+		public bool ResetValuesAfterTransition = true;
+
+		[Header("Priority")]
+		/// the new priority to apply to all virtual cameras on the specified channel
+		[Tooltip("the new priority to apply to all virtual cameras on the specified channel")]
+		public int NewPriority = 10;
+		/// whether or not to force all virtual cameras on other channels to reset their priority to zero
+		[Tooltip("whether or not to force all virtual cameras on other channels to reset their priority to zero")]
+		public bool ForceMaxPriority = true;
+		/// whether or not to apply a new blend
+		[Tooltip("whether or not to apply a new blend")]
+		public bool ForceTransition = false;
+		#if MM_CINEMACHINE
+		/// the new blend definition to apply
+		[Tooltip("the new blend definition to apply")]
+		[MMFCondition("ForceTransition", true)]
+		public CinemachineBlendDefinition BlendDefintion;
+
+		protected CinemachineBlendDefinition _tempBlend;
+		#endif
+
+		/// <summary>
+		/// Triggers a priority change on listening virtual cameras
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			#if MM_CINEMACHINE
+			_tempBlend = BlendDefintion;
+			_tempBlend.m_Time = FeedbackDuration;
+			if (Mode == Modes.Event)
+			{
+				MMCinemachinePriorityEvent.Trigger(ChannelData, ForceMaxPriority, NewPriority, ForceTransition, _tempBlend, ResetValuesAfterTransition, ComputedTimescaleMode);    
+			}
+			else
+			{
+				MMCinemachinePriorityEvent.Trigger(ChannelData, ForceMaxPriority, 0, ForceTransition, _tempBlend, ResetValuesAfterTransition, ComputedTimescaleMode); 
+				TargetVirtualCamera.Priority = NewPriority;
+			}
+			#endif
+		}
+		
+		/// <summary>
+		/// On restore, we restore our initial state
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			#if MM_CINEMACHINE
+			MMCinemachinePriorityEvent.Trigger(ChannelData, ForceMaxPriority, 0, ForceTransition, _tempBlend, ResetValuesAfterTransition, ComputedTimescaleMode, true); 
+			#endif
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/Feedbacks/MMF_CinemachineTransition.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/MoreMountains.Feedbacks.Cinemachine.asmdef

@@ -0,0 +1,23 @@
+{
+    "name": "MoreMountains.Feedbacks.Cinemachine",
+    "references": [
+        "GUID:4307f53044263cf4b835bd812fc161a4",
+        "GUID:8087d854c1f812e4b9a74437dfc524e0",
+        "GUID:4a1cb1490dc4df8409b2580d6b44e75e"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.cinemachine",
+            "expression": "1.0.0",
+            "define": "MM_CINEMACHINE"
+        }
+    ],
+    "noEngineReferences": false
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/Cinemachine/MoreMountains.Feedbacks.Cinemachine.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 3e8495bfd2df0ff4ca1f5b0f360e50a7
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 22217fa6cb1ecde4ba6e2ccdeff4ba33
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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: