chore: initial commit

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_Bloom_URP.cs

@@ -0,0 +1,132 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using UnityEngine.Scripting.APIUpdating;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control bloom intensity and threshold over time. It requires you have in your scene an object with a Volume with Bloom active, and a MMBloomShaker_URP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackHelp("This feedback allows you to control bloom intensity and threshold over time. It requires you have in your scene an object with a Volume " +
+	              "with Bloom active, and a MMBloomShaker_URP component.")]
+	#if MM_URP
+	[FeedbackPath("PostProcess/Bloom URP")]
+	#endif
+	[MovedFrom(false, null, "MoreMountains.Feedbacks.URP")]
+	public class MMF_Bloom_URP : 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.PostProcessColor; } }
+		public override bool HasCustomInspectors => true;
+		public override bool HasAutomaticShakerSetup => true;
+		#endif
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(ShakeDuration); }  set { ShakeDuration = value;  } }
+		public override bool HasChannel => true;
+		public override bool HasRandomness => true;
+
+		[MMFInspectorGroup("Bloom", true, 41)]
+		/// the duration of the feedback, in seconds
+		[Tooltip("the duration of the feedback, in seconds")]
+		public float ShakeDuration = 0.2f;
+		/// whether or not to reset shaker values after shake
+		[Tooltip("whether or not to reset shaker values after shake")]
+		public bool ResetShakerValuesAfterShake = true;
+		/// 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 ResetTargetValuesAfterShake = true;
+		/// whether or not to add to the initial intensity
+		[Tooltip("whether or not to add to the initial intensity")]
+		public bool RelativeValues = true;
+
+		[MMFInspectorGroup("Intensity", true, 42)]
+		/// the curve to animate the intensity on
+		[Tooltip("the curve to animate the intensity on")]
+		public AnimationCurve ShakeIntensity = 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 RemapIntensityZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapIntensityOne = 1f;
+        
+		[MMFInspectorGroup("Threshold", true, 43)]
+		/// the curve to animate the threshold on
+		[Tooltip("the curve to animate the threshold on")]
+		public AnimationCurve ShakeThreshold = 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 RemapThresholdZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapThresholdOne = 0f;
+
+		/// <summary>
+		/// Triggers a bloom shake
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="attenuation"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float attenuation = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+
+			attenuation  = ComputeIntensity(attenuation, position);
+			
+			MMBloomShakeEvent_URP.Trigger(ShakeIntensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, ShakeThreshold, RemapThresholdZero, RemapThresholdOne,
+				RelativeValues, attenuation, ChannelData, ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, ComputedTimescaleMode);
+            
+		}
+        
+		/// <summary>
+		/// On stop we stop our transition
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			base.CustomStopFeedback(position, feedbacksIntensity);
+			MMBloomShakeEvent_URP.Trigger(ShakeIntensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, 
+				ShakeThreshold, RemapThresholdZero, RemapThresholdOne,
+				RelativeValues, channelData:ChannelData, stop: true);
+		}
+
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			MMBloomShakeEvent_URP.Trigger(ShakeIntensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, 
+				ShakeThreshold, RemapThresholdZero, RemapThresholdOne,
+				RelativeValues, channelData:ChannelData, restore: true);
+		}
+		
+		/// <summary>
+		/// Automaticall sets up the post processing profile and shaker
+		/// </summary>
+		public override void AutomaticShakerSetup()
+		{
+			#if MM_URP && UNITY_EDITOR
+			MMURPHelpers.GetOrCreateVolume<Bloom, MMBloomShaker_URP>(Owner, "Bloom");
+			#endif
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_Bloom_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_ChannelMixer_URP.cs

@@ -0,0 +1,156 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using UnityEngine.Scripting.APIUpdating;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control bloom intensity and threshold over time. It requires you have in your scene an object with a Volume with Bloom active, and a MMBloomShaker_URP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackHelp("This feedback allows you to control bloom intensity and threshold over time. It requires you have in your scene an object with a Volume " +
+	              "with Bloom active, and a MMBloomShaker_URP component.")]
+	#if MM_URP
+	[FeedbackPath("PostProcess/Channel Mixer URP")]
+	#endif
+	[MovedFrom(false, null, "MoreMountains.Feedbacks.URP")]
+	public class MMF_ChannelMixer_URP : 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.PostProcessColor; } }
+		public override bool HasCustomInspectors => true;
+		public override bool HasAutomaticShakerSetup => true;
+		#endif
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(ShakeDuration); }  set { ShakeDuration = value;  } }
+		public override bool HasChannel => true;
+		public override bool HasRandomness => true;
+
+		[MMFInspectorGroup("Channel Mixer", true, 41)]
+		/// the duration of the shake, in seconds
+		[Tooltip("the duration of the shake, in seconds")]
+		public float ShakeDuration = 1f;
+		/// whether or not to add to the initial intensity
+		[Tooltip("whether or not to add to the initial intensity")]
+		public bool RelativeIntensity = true;
+		/// whether or not to reset shaker values after shake
+		[Tooltip("whether or not to reset shaker values after shake")]
+		public bool ResetShakerValuesAfterShake = true;
+		/// 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 ResetTargetValuesAfterShake = true;
+        
+		[MMFInspectorGroup("Red", true, 42)]
+		/// the curve used to animate the red value on
+		[Tooltip("the curve used to animate the red value on")]
+		public AnimationCurve ShakeRed = 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(-200f, 200f)]
+		public float RemapRedZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-200f, 200f)]
+		public float RemapRedOne = -200f;
+
+		[MMFInspectorGroup("Green", true, 43)]
+		/// the curve used to animate the green value on
+		[Tooltip("the curve used to animate the green value on")]
+		public AnimationCurve ShakeGreen = 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(-200f, 200f)]
+		public float RemapGreenZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-200f, 200f)]
+		public float RemapGreenOne = 200f;
+
+		[MMFInspectorGroup("Blue", true, 44)]
+		/// the curve used to animate the blue value on
+		[Tooltip("the curve used to animate the blue value on")]
+		public AnimationCurve ShakeBlue = 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(-200f, 200f)]
+		public float RemapBlueZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-200f, 200f)]
+		public float RemapBlueOne = 200f;
+
+		/// <summary>
+		/// Triggers a color adjustments shake
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="attenuation"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			float intensityMultiplier = ComputeIntensity(feedbacksIntensity, position);
+			MMChannelMixerShakeEvent_URP.Trigger(ShakeRed, RemapRedZero, RemapRedOne,
+				ShakeGreen, RemapGreenZero, RemapGreenOne,
+				ShakeBlue, RemapBlueZero, RemapBlueOne,
+				FeedbackDuration,
+				RelativeIntensity, intensityMultiplier, ChannelData, ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, ComputedTimescaleMode);
+            
+		}
+        
+		/// <summary>
+		/// On stop we stop our transition
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			base.CustomStopFeedback(position, feedbacksIntensity);
+            
+			MMChannelMixerShakeEvent_URP.Trigger(ShakeRed, RemapRedZero, RemapRedOne,
+				ShakeGreen, RemapGreenZero, RemapGreenOne,
+				ShakeBlue, RemapBlueZero, RemapBlueOne,
+				FeedbackDuration,
+				RelativeIntensity, channelData:ChannelData, stop:true);
+		}
+
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			MMChannelMixerShakeEvent_URP.Trigger(ShakeRed, RemapRedZero, RemapRedOne,
+				ShakeGreen, RemapGreenZero, RemapGreenOne,
+				ShakeBlue, RemapBlueZero, RemapBlueOne,
+				FeedbackDuration,
+				RelativeIntensity, channelData:ChannelData, restore:true);
+		}
+		
+		/// <summary>
+		/// Automaticall sets up the post processing profile and shaker
+		/// </summary>
+		public override void AutomaticShakerSetup()
+		{
+			#if MM_URP && UNITY_EDITOR
+			MMURPHelpers.GetOrCreateVolume<ChannelMixer, MMChannelMixerShaker_URP>(Owner, "Channel Mixer");
+			#endif
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_ChannelMixer_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_ChromaticAberration_URP.cs

@@ -0,0 +1,124 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using UnityEngine.Scripting.APIUpdating;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control chromatic aberration intensity over time. It requires you have in your scene an object with a Volume 
+	/// with URP Chromatic Aberration active, and a MMChromaticAberrationShaker_URP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackHelp("This feedback allows you to control chromatic aberration intensity over time. It requires you have in your scene an object with a Volume " +
+	              "with Chromatic Aberration active, and a MMChromaticAberrationShaker_URP component.")]
+	#if MM_URP
+	[FeedbackPath("PostProcess/Chromatic Aberration URP")]
+	#endif
+	[MovedFrom(false, null, "MoreMountains.Feedbacks.URP")]
+	public class MMF_ChromaticAberration_URP : 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.PostProcessColor; } }
+		public override bool HasCustomInspectors => true;
+		public override bool HasAutomaticShakerSetup => true;
+		#endif
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(Duration); } set { Duration = value;  } }
+		public override bool HasChannel => true;
+		public override bool HasRandomness => true;
+
+		[MMFInspectorGroup("Chromatic Aberration", true, 42)]
+		/// the duration of the shake, in seconds
+		[Tooltip("the duration of the shake, in seconds")]
+		public float Duration = 0.2f;
+		/// whether or not to reset shaker values after shake
+		[Tooltip("whether or not to reset shaker values after shake")]
+		public bool ResetShakerValuesAfterShake = true;
+		/// 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 ResetTargetValuesAfterShake = true;
+		/// the value to remap the curve's 0 to
+		[Tooltip("the value to remap the curve's 0 to")]
+		[Range(0f, 1f)]
+		public float RemapIntensityZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(0f, 1f)]
+		public float RemapIntensityOne = 1f;
+
+		[MMFInspectorGroup("Intensity", true, 43)]
+		/// the curve to animate the intensity on
+		[Tooltip("the curve to animate the intensity on")]
+		public AnimationCurve Intensity = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
+		/// the multiplier to apply to the intensity curve
+		[Tooltip("the multiplier to apply to the intensity curve")]
+		[Range(0f, 1f)]
+		public float Amplitude = 1.0f;
+		/// whether or not to add to the initial intensity
+		[Tooltip("whether or not to add to the initial intensity")]
+		public bool RelativeIntensity = false;
+
+		/// <summary>
+		/// Triggers a chromatic aberration shake
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="attenuation"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			float intensityMultiplier = ComputeIntensity(feedbacksIntensity, position);
+			MMChromaticAberrationShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, intensityMultiplier,
+				ChannelData, ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, ComputedTimescaleMode);
+		}
+        
+		/// <summary>
+		/// On stop we stop our transition
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			base.CustomStopFeedback(position, feedbacksIntensity);
+            
+			MMChromaticAberrationShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, channelData:ChannelData, stop:true);
+		}
+
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			MMChromaticAberrationShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, channelData:ChannelData, restore:true);
+		}
+		
+		/// <summary>
+		/// Automaticall sets up the post processing profile and shaker
+		/// </summary>
+		public override void AutomaticShakerSetup()
+		{
+			#if MM_URP && UNITY_EDITOR
+			MMURPHelpers.GetOrCreateVolume<ChromaticAberration, MMChromaticAberrationShaker_URP>(Owner, "Chromatic Aberration");
+			#endif
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_ChromaticAberration_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_ColorAdjustments_URP.cs

@@ -0,0 +1,201 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using UnityEngine.Scripting.APIUpdating;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control color adjustments' post exposure, hue shift, saturation and contrast over time.
+	/// It requires you have in your scene an object with a Volume 
+	/// with Color Adjustments active, and a MMColorAdjustmentsShaker_URP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackHelp("This feedback allows you to control color adjustments' post exposure, hue shift, saturation and contrast over time. " +
+	              "It requires you have in your scene an object with a Volume " +
+	              "with Color Adjustments active, and a MMColorAdjustmentsShaker_URP component.")]
+	#if MM_URP
+	[FeedbackPath("PostProcess/Color Adjustments URP")]
+	#endif
+	[MovedFrom(false, null, "MoreMountains.Feedbacks.URP")]
+	public class MMF_ColorAdjustments_URP : 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.PostProcessColor; } }
+		public override bool HasCustomInspectors => true;
+		public override bool HasAutomaticShakerSetup => true;
+		#endif
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(ShakeDuration); } set { ShakeDuration = value; } }
+		public override bool HasChannel => true;
+		public override bool HasRandomness => true;
+
+		[MMFInspectorGroup("Color Grading", true, 43)]
+		/// the duration of the shake, in seconds
+		[Tooltip("the duration of the shake, in seconds")]
+		public float ShakeDuration = 1f;
+		/// whether or not to add to the initial intensity
+		[Tooltip("whether or not to add to the initial intensity")]
+		public bool RelativeIntensity = true;
+		/// whether or not to reset shaker values after shake
+		[Tooltip("whether or not to reset shaker values after shake")]
+		public bool ResetShakerValuesAfterShake = true;
+		/// 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 ResetTargetValuesAfterShake = true;
+
+		[MMFInspectorGroup("Post Exposure", true, 48)]
+		/// the curve used to animate the focus distance value on
+		[Tooltip("the curve used to animate the focus distance value on")]
+		public AnimationCurve ShakePostExposure = 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 RemapPostExposureZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapPostExposureOne = 1f;
+
+		[MMFInspectorGroup("Hue Shift", true, 47)]
+		/// the curve used to animate the aperture value on
+		[Tooltip("the curve used to animate the aperture value on")]
+		public AnimationCurve ShakeHueShift = 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(-180f, 180f)]
+		public float RemapHueShiftZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-180f, 180f)]
+		public float RemapHueShiftOne = 180f;
+
+		[MMFInspectorGroup("Saturation", true, 46)]
+		/// the curve used to animate the focal length value on
+		[Tooltip("the curve used to animate the focal length value on")]
+		public AnimationCurve ShakeSaturation = 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(-100f, 100f)]
+		public float RemapSaturationZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-100f, 100f)]
+		public float RemapSaturationOne = 100f;
+
+		[MMFInspectorGroup("Contrast", true, 45)]
+		/// the curve used to animate the focal length value on
+		[Tooltip("the curve used to animate the focal length value on")]
+		public AnimationCurve ShakeContrast = 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(-100f, 100f)]
+		public float RemapContrastZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-100f, 100f)]
+		public float RemapContrastOne = 100f;
+        
+		[MMFInspectorGroup("Color Filter", true, 44)]
+		/// the selected color filter mode :
+		/// None : nothing will happen,
+		/// gradient : evaluates the color over time on that gradient, from left to right,
+		/// interpolate : lerps from the current color to the destination one 
+		[Tooltip("the selected color filter mode :" +
+		         "None : nothing will happen," +
+		         "gradient : evaluates the color over time on that gradient, from left to right," +
+		         "interpolate : lerps from the current color to the destination one ")]
+		public MMColorAdjustmentsShaker_URP.ColorFilterModes ColorFilterMode = MMColorAdjustmentsShaker_URP.ColorFilterModes.None;
+		/// the gradient to use to animate the color filter over time
+		[Tooltip("the gradient to use to animate the color filter over time")]
+		[MMFEnumCondition("ColorFilterMode", (int)MMColorAdjustmentsShaker_URP.ColorFilterModes.Gradient)]
+		[GradientUsage(true)]
+		public Gradient ColorFilterGradient;
+		/// the destination color when in interpolate mode
+		[Tooltip("the destination color when in interpolate mode")]
+		[MMFEnumCondition("ColorFilterMode", (int) MMColorAdjustmentsShaker_URP.ColorFilterModes.Interpolate)]
+		public Color ColorFilterDestination = Color.yellow;
+		/// the curve to use when interpolating towards the destination color
+		[Tooltip("the curve to use when interpolating towards the destination color")]
+		[MMFEnumCondition("ColorFilterMode", (int) MMColorAdjustmentsShaker_URP.ColorFilterModes.Interpolate)]
+		public AnimationCurve ColorFilterCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
+
+		/// <summary>
+		/// Triggers a color adjustments shake
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="attenuation"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			float intensityMultiplier = ComputeIntensity(feedbacksIntensity, position);
+			MMColorAdjustmentsShakeEvent_URP.Trigger(ShakePostExposure, RemapPostExposureZero, RemapPostExposureOne,
+				ShakeHueShift, RemapHueShiftZero, RemapHueShiftOne,
+				ShakeSaturation, RemapSaturationZero, RemapSaturationOne,
+				ShakeContrast, RemapContrastZero, RemapContrastOne,
+				ColorFilterMode, ColorFilterGradient, ColorFilterDestination, ColorFilterCurve,
+				FeedbackDuration,
+				RelativeIntensity, intensityMultiplier, ChannelData, ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, ComputedTimescaleMode);
+            
+		}
+        
+		/// <summary>
+		/// On stop we stop our transition
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			base.CustomStopFeedback(position, feedbacksIntensity);
+            
+			MMColorAdjustmentsShakeEvent_URP.Trigger(ShakePostExposure, RemapPostExposureZero, RemapPostExposureOne,
+				ShakeHueShift, RemapHueShiftZero, RemapHueShiftOne,
+				ShakeSaturation, RemapSaturationZero, RemapSaturationOne,
+				ShakeContrast, RemapContrastZero, RemapContrastOne,
+				ColorFilterMode, ColorFilterGradient, ColorFilterDestination, ColorFilterCurve,
+				FeedbackDuration,
+				RelativeIntensity, channelData: ChannelData, stop: true);
+		}
+
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			MMColorAdjustmentsShakeEvent_URP.Trigger(ShakePostExposure, RemapPostExposureZero, RemapPostExposureOne,
+				ShakeHueShift, RemapHueShiftZero, RemapHueShiftOne,
+				ShakeSaturation, RemapSaturationZero, RemapSaturationOne,
+				ShakeContrast, RemapContrastZero, RemapContrastOne,
+				ColorFilterMode, ColorFilterGradient, ColorFilterDestination, ColorFilterCurve,
+				FeedbackDuration,
+				RelativeIntensity, channelData: ChannelData, restore: true);
+		}
+		
+		/// <summary>
+		/// Automaticall sets up the post processing profile and shaker
+		/// </summary>
+		public override void AutomaticShakerSetup()
+		{
+			#if MM_URP && UNITY_EDITOR
+			MMURPHelpers.GetOrCreateVolume<ColorAdjustments, MMColorAdjustmentsShaker_URP>(Owner, "ColorAdjustments");
+			#endif
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_ColorAdjustments_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_DepthOfField_URP.cs

@@ -0,0 +1,154 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using UnityEngine.Scripting.APIUpdating;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control URP depth of field focus distance, aperture and focal length over time. 
+	/// It requires you have in your scene an object with a Volume 
+	/// with Depth of Field active, and a MMDepthOfFieldShaker_URP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackHelp("This feedback allows you to control URP depth of field focus distance, aperture and focal length over time. " +
+	              "It requires you have in your scene an object with a Volume " +
+	              "with Depth of Field active, and a MMDepthOfFieldShaker_URP component.")]
+	#if MM_URP
+	[FeedbackPath("PostProcess/Depth Of Field URP")]
+	#endif
+	[MovedFrom(false, null, "MoreMountains.Feedbacks.URP")]
+	public class MMF_DepthOfField_URP : 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.PostProcessColor; } }
+		public override bool HasCustomInspectors => true;
+		public override bool HasAutomaticShakerSetup => true;
+		#endif
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(ShakeDuration); } set { ShakeDuration = value; } }
+		public override bool HasChannel => true;
+		public override bool HasRandomness => true;
+
+		[MMFInspectorGroup("Depth Of Field", true, 49)]
+		/// the duration of the shake, in seconds
+		[Tooltip("the duration of the shake, in seconds")]
+		public float ShakeDuration = 2f;
+		/// whether or not to add to the initial values
+		[Tooltip("whether or not to add to the initial values")]
+		public bool RelativeValues = true;
+		/// whether or not to reset shaker values after shake
+		[Tooltip("whether or not to reset shaker values after shake")]
+		public bool ResetShakerValuesAfterShake = true;
+		/// 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 ResetTargetValuesAfterShake = true;
+
+		[MMFInspectorGroup("Focus Distance", true, 50)]
+		/// the curve used to animate the focus distance value on
+		[Tooltip("the curve used to animate the focus distance value on")]
+		public AnimationCurve ShakeFocusDistance = 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 RemapFocusDistanceZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapFocusDistanceOne = 3f;
+
+		[MMFInspectorGroup("Aperture", true, 51)]
+		/// the curve used to animate the aperture value on
+		[Tooltip("the curve used to animate the aperture value on")]
+		public AnimationCurve ShakeAperture = 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(0.1f, 32f)]
+		public float RemapApertureZero = .1f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(0.1f, 32f)]
+		public float RemapApertureOne = 32f;
+
+		[MMFInspectorGroup("Focal Length", true, 20)]
+		/// the curve used to animate the focal length value on
+		[Tooltip("the curve used to animate the focal length value on")]
+		public AnimationCurve ShakeFocalLength = 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, 300f)]
+		public float RemapFocalLengthZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(0f, 300f)]
+		public float RemapFocalLengthOne = 0f;
+
+		/// <summary>
+		/// Triggers a depth of field event
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="attenuation"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			float intensityMultiplier = ComputeIntensity(feedbacksIntensity, position);
+			MMDepthOfFieldShakeEvent_URP.Trigger(ShakeFocusDistance, FeedbackDuration, RemapFocusDistanceZero, RemapFocusDistanceOne,
+				ShakeAperture, RemapApertureZero, RemapApertureOne,
+				ShakeFocalLength, RemapFocalLengthZero, RemapFocalLengthOne,
+				RelativeValues, intensityMultiplier, ChannelData, ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, ComputedTimescaleMode);
+            
+		}
+        
+		/// <summary>
+		/// On stop we stop our transition
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			base.CustomStopFeedback(position, feedbacksIntensity);
+            
+			MMDepthOfFieldShakeEvent_URP.Trigger(ShakeFocusDistance, FeedbackDuration, RemapFocusDistanceZero, RemapFocusDistanceOne,
+				ShakeAperture, RemapApertureZero, RemapApertureOne,
+				ShakeFocalLength, RemapFocalLengthZero, RemapFocalLengthOne,
+				RelativeValues, channelData: ChannelData, stop: true );
+		}
+
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			MMDepthOfFieldShakeEvent_URP.Trigger(ShakeFocusDistance, FeedbackDuration, RemapFocusDistanceZero, RemapFocusDistanceOne,
+				ShakeAperture, RemapApertureZero, RemapApertureOne,
+				ShakeFocalLength, RemapFocalLengthZero, RemapFocalLengthOne,
+				RelativeValues, channelData: ChannelData, restore: true );
+		}
+		
+		/// <summary>
+		/// Automaticall sets up the post processing profile and shaker
+		/// </summary>
+		public override void AutomaticShakerSetup()
+		{
+			#if MM_URP && UNITY_EDITOR
+			MMURPHelpers.GetOrCreateVolume<DepthOfField, MMDepthOfFieldShaker_URP>(Owner, "DepthOfField");
+			#endif
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_DepthOfField_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_FilmGrain_URP.cs

@@ -0,0 +1,123 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using UnityEngine.Scripting.APIUpdating;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control URP Film Grain intensity over time.
+	/// It requires you have in your scene an object with a Volume 
+	/// with Film Grain active, and a MMFilmGrainShaker_URP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	#if MM_URP
+	[FeedbackPath("PostProcess/Film Grain URP")]
+	#endif
+	[MovedFrom(false, null, "MoreMountains.Feedbacks.URP")]
+	[FeedbackHelp("This feedback allows you to control Film Grain intensity over time. " +
+	              "It requires you have in your scene an object with a Volume " +
+	              "with Film Grain active, and a MMFilmGrainShaker_URP component.")]
+	public class MMF_FilmGrain_URP : 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.PostProcessColor; } }
+		public override bool HasCustomInspectors => true;
+		public override bool HasAutomaticShakerSetup => true;
+		#endif
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(Duration); } set { Duration = value; } }
+		public override bool HasChannel => true;
+		public override bool HasRandomness => true;
+
+		[MMFInspectorGroup("Film Grain", true, 21)]
+		/// the duration of the shake, in seconds
+		[Tooltip("the duration of the shake, in seconds")]
+		public float Duration = 0.2f;
+		/// whether or not to reset shaker values after shake
+		[Tooltip("whether or not to reset shaker values after shake")]
+		public bool ResetShakerValuesAfterShake = true;
+		/// 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 ResetTargetValuesAfterShake = true;
+
+		[MMFInspectorGroup("Intensity", true, 22)]
+		/// the curve to animate the intensity on
+		[Tooltip("the curve to animate the intensity on")]
+		public AnimationCurve Intensity = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));        
+		/// the value to remap the curve's zero to
+		[Tooltip("the value to remap the curve's zero to")]
+		[Range(0f, 1f)]
+		public float RemapIntensityZero = 0f;
+		/// the value to remap the curve's one to
+		[Tooltip("the value to remap the curve's one to")]
+		[Range(0f, 1f)]
+		public float RemapIntensityOne = 1.0f;
+		/// whether or not to add to the initial intensity
+		[Tooltip("whether or not to add to the initial intensity")]
+		public bool RelativeIntensity = false;
+
+		/// <summary>
+		/// Triggers a Film Grain shake
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="attenuation"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			float intensityMultiplier = ComputeIntensity(feedbacksIntensity, position);
+			MMFilmGrainShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, intensityMultiplier,
+				ChannelData, ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, ComputedTimescaleMode);
+            
+		}
+        
+		/// <summary>
+		/// On stop we stop our transition
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			base.CustomStopFeedback(position, feedbacksIntensity);
+            
+			MMFilmGrainShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, stop:true, channelData: ChannelData);
+		}
+
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			
+			MMFilmGrainShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, restore:true, channelData: ChannelData);
+		}
+		
+		/// <summary>
+		/// Automaticall sets up the post processing profile and shaker
+		/// </summary>
+		public override void AutomaticShakerSetup()
+		{
+			#if MM_URP && UNITY_EDITOR
+			MMURPHelpers.GetOrCreateVolume<FilmGrain, MMFilmGrainShaker_URP>(Owner, "FilmGrain");
+			#endif
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_FilmGrain_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_GlobalPPVolumeAutoBlend_URP.cs

@@ -0,0 +1,165 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using UnityEngine.Scripting.APIUpdating;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback will let you pilot a Global PostProcessing Volume AutoBlend URP component. A GPPVAB component is placed on a PostProcessing Volume, and will let you control and blend its weight over time on demand.    
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackHelp("This feedback will let you pilot a Global PostProcessing Volume AutoBlend URP component. A GPPVAB component is placed on a PostProcessing Volume, and will let you control and blend its weight over time on demand.")]
+	#if MM_URP
+	[FeedbackPath("PostProcess/Global PP Volume Auto Blend URP")]
+	#endif
+	[MovedFrom(false, null, "MoreMountains.Feedbacks.URP")]
+	public class MMF_GlobalPPVolumeAutoBlend_URP : MMF_Feedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// the possible modes for this feedback :
+		/// - default : will let you trigger Blend() and BlendBack() on the blender
+		/// - override : lets you specify new initial, final, duration and curve values on the blender, and triggers a Blend()
+		public enum Modes { Default, Override }
+		/// the possible actions when in Default mode
+		public enum Actions { Blend, BlendBack }
+
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.PostProcessColor; } }
+		public override bool EvaluateRequiresSetup() { return (TargetAutoBlend == null); }
+		public override string RequiredTargetText { get { return TargetAutoBlend != null ? TargetAutoBlend.name : "";  } }
+		public override string RequiresSetupText { get { return "This feedback requires that a TargetCanvasGroup be set to be able to work properly. You can set one below."; } }
+		#endif
+		public override bool HasAutomatedTargetAcquisition => true;
+		protected override void AutomateTargetAcquisition() => TargetAutoBlend = FindAutomatedTarget<MMGlobalPostProcessingVolumeAutoBlend_URP>();
+
+		/// defines the duration of the feedback
+		public override float FeedbackDuration
+		{
+			get
+			{
+				if (Mode == Modes.Override)
+				{
+					return ApplyTimeMultiplier(BlendDuration);
+				}
+				else
+				{
+					if (TargetAutoBlend == null)
+					{
+						return 0.1f;
+					}
+					else
+					{
+						return ApplyTimeMultiplier(TargetAutoBlend.BlendDuration);
+					}
+				}
+			}
+			set
+			{
+				BlendDuration = value;
+				if (TargetAutoBlend != null)
+				{
+					TargetAutoBlend.BlendDuration = value;
+				}
+			}
+		}
+               
+		[MMFInspectorGroup("PostProcess Volume Blend", true, 22, true)]
+		/// the target auto blend to pilot with this feedback
+		public MMGlobalPostProcessingVolumeAutoBlend_URP TargetAutoBlend;
+		/// the chosen mode
+		public Modes Mode = Modes.Default;
+		/// the chosen action when in default mode
+		[MMFEnumCondition("Mode", (int)Modes.Default)]
+		public Actions BlendAction = Actions.Blend;
+		/// the duration of the blend, in seconds when in override mode
+		[MMFEnumCondition("Mode", (int)Modes.Override)]
+		public float BlendDuration = 1f;
+		/// the curve to apply to the blend
+		[MMFEnumCondition("Mode", (int)Modes.Override)]
+		public AnimationCurve BlendCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(1, 1f));
+		/// the weight to blend from
+		[MMFEnumCondition("Mode", (int)Modes.Override)]
+		public float InitialWeight = 0f;
+		/// the weight to blend to
+		[MMFEnumCondition("Mode", (int)Modes.Override)]
+		public float FinalWeight = 1f;        
+
+		/// <summary>
+		/// On custom play, triggers a blend on the target blender, overriding its settings if needed
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="attenuation"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			if (TargetAutoBlend == null)
+			{
+				Debug.LogWarning(Owner.name + " : this MMFeedbackGlobalPPVolumeAutoBlend needs a TargetAutoBlend, please set one in its inspector.");
+				return;
+			}
+			if (Mode == Modes.Default)
+			{
+				if (BlendAction == Actions.Blend)
+				{
+					TargetAutoBlend.Blend();
+					return;
+				}
+				if (BlendAction == Actions.BlendBack)
+				{
+					TargetAutoBlend.BlendBack();
+					return;
+				}
+			}
+			else
+			{
+				TargetAutoBlend.TimeScale = (ComputedTimescaleMode == TimescaleModes.Scaled) ? MMGlobalPostProcessingVolumeAutoBlend_URP.TimeScales.Scaled : MMGlobalPostProcessingVolumeAutoBlend_URP.TimeScales.Unscaled;
+				TargetAutoBlend.BlendDuration = FeedbackDuration;
+				TargetAutoBlend.Curve = BlendCurve;
+				TargetAutoBlend.InitialWeight = InitialWeight;
+				TargetAutoBlend.FinalWeight = FinalWeight;
+				TargetAutoBlend.Blend();
+			}
+            
+		}
+        
+		/// <summary>
+		/// On stop we stop our transition
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			base.CustomStopFeedback(position, feedbacksIntensity);
+            
+			if (TargetAutoBlend != null)
+			{
+				TargetAutoBlend.StopBlending();
+			}
+		}
+
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			TargetAutoBlend.RestoreInitialValues();
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_GlobalPPVolumeAutoBlend_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_LensDistortion_URP.cs

@@ -0,0 +1,131 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using UnityEngine.Scripting.APIUpdating;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control URP lens distortion intensity over time. 
+	/// It requires you have in your scene an object with a Volume 
+	/// with Lens Distortion active, and a MMLensDistortionShaker_URP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	#if MM_URP
+	[FeedbackPath("PostProcess/Lens Distortion URP")]
+	#endif
+	[MovedFrom(false, null, "MoreMountains.Feedbacks.URP")]
+	[FeedbackHelp("This feedback allows you to control URP lens distortion intensity over time. " +
+	              "It requires you have in your scene an object with a Volume " +
+	              "with Lens Distortion active, and a MMLensDistortionShaker_URP component.")]
+	public class MMF_LensDistortion_URP : 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.PostProcessColor; } }
+		public override bool HasCustomInspectors => true;
+		public override bool HasAutomaticShakerSetup => true;
+		#endif
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(Duration); } set { Duration = value; } }
+		public override bool HasChannel => true;
+		public override bool HasRandomness => true;
+
+		[MMFInspectorGroup("Lens Distortion", true, 22)]
+		/// the duration of the shake in seconds
+		[Tooltip("the duration of the shake in seconds")]
+		public float Duration = 0.8f;
+		/// whether or not to reset shaker values after shake
+		[Tooltip("whether or not to reset shaker values after shake")]
+		public bool ResetShakerValuesAfterShake = true;
+		/// 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 ResetTargetValuesAfterShake = true;
+
+		[MMFInspectorGroup("Intensity", true, 23)]
+		/// whether or not to add to the initial intensity value
+		[Tooltip("whether or not to add to the initial intensity value")]
+		public bool RelativeIntensity = false;
+		/// the curve to animate the intensity on
+		[Tooltip("the curve to animate the intensity on")]
+		public AnimationCurve Intensity = new AnimationCurve(new Keyframe(0, 0),
+			new Keyframe(0.2f, 1),
+			new Keyframe(0.25f, -1),
+			new Keyframe(0.35f, 0.7f),
+			new Keyframe(0.4f, -0.7f),
+			new Keyframe(0.6f, 0.3f),
+			new Keyframe(0.65f, -0.3f),
+			new Keyframe(0.8f, 0.1f),
+			new Keyframe(0.85f, -0.1f),
+			new Keyframe(1, 0));
+		/// the value to remap the curve's 0 to
+		[Tooltip("the value to remap the curve's 0 to")]
+		[Range(-1f, 1f)]
+		public float RemapIntensityZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-1f, 1f)]
+		public float RemapIntensityOne = 0.5f;
+
+		/// <summary>
+		/// Triggers a lens distortion shake
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="attenuation"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			float intensityMultiplier = ComputeIntensity(feedbacksIntensity, position);
+			MMLensDistortionShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, intensityMultiplier,
+				ChannelData, ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, ComputedTimescaleMode);
+            
+		}
+        
+		/// <summary>
+		/// On stop we stop our transition
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			base.CustomStopFeedback(position, feedbacksIntensity);
+			MMLensDistortionShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, stop:true, channelData: ChannelData);
+		}
+
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			
+			MMLensDistortionShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, restore:true, channelData: ChannelData);
+		}
+		
+		/// <summary>
+		/// Automaticall sets up the post processing profile and shaker
+		/// </summary>
+		public override void AutomaticShakerSetup()
+		{
+			#if MM_URP && UNITY_EDITOR
+			MMURPHelpers.GetOrCreateVolume<LensDistortion, MMLensDistortionShaker_URP>(Owner, "LensDistortion");
+			#endif
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_LensDistortion_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_Light2D_URP.cs

@@ -0,0 +1,450 @@
+using System.Collections;
+using MoreMountains.Feedbacks;
+using UnityEngine;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+using UnityEngine.Scripting.APIUpdating;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	#if MM_URP
+	/// <summary>
+	/// This feedback will let you control a 2D light's intensity, color, falloff, shadow strength and volumetric intensity over time, or instantly.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackHelp("This feedback will let you control a 2D light's intensity, color, falloff, shadow strength and volumetric intensity over time, or instantly.")]
+	[MovedFrom(false, null, "MoreMountains.Feedbacks")]
+	[FeedbackPath("Lights/Light2D_URP")]
+	public class MMF_Light2D_URP : 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.LightColor; } }
+		public override bool EvaluateRequiresSetup() { return (BoundLight == null); }
+		public override string RequiredTargetText { get { return BoundLight != null ? BoundLight.name : "";  } }
+		public override string RequiresSetupText { get { return "This feedback requires that a BoundLight be set to be able to work properly. You can set one below."; } }
+		#endif
+
+		/// the duration of this feedback is the duration of the light, or 0 if instant
+		public override float FeedbackDuration { get { return (Mode == Modes.Instant) ? 0f : ApplyTimeMultiplier(Duration); } set { Duration = value; } }
+		public override bool HasChannel => true;
+		public override bool HasRandomness => true;
+		public override bool HasAutomatedTargetAcquisition => true;
+		protected override void AutomateTargetAcquisition() => BoundLight = FindAutomatedTarget<Light2D>();
+
+		/// the possible modes for this feedback
+		public enum Modes { OverTime, Instant, ShakerEvent, ToDestination }
+		
+		[MMFInspectorGroup("Light", true, 37, true)]
+		/// the light to affect when playing the feedback
+		[Tooltip("the light to affect when playing the feedback")]
+		public Light2D BoundLight;
+		/// whether the feedback should affect the light instantly or over a period of time
+		[Tooltip("whether the feedback should affect the light instantly or over a period of time")]
+		public Modes Mode = Modes.OverTime;
+		/// how long the light should change over time
+		[Tooltip("how long the light should change over time")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent, (int)Modes.ToDestination)]
+		public float Duration = 0.2f;
+		/// whether or not that light should be turned off on start
+		[Tooltip("whether or not that light should be turned off on start")]
+		public bool StartsOff = true;
+		/// if this is true, the light will be disabled when this feedbacks is stopped
+		[Tooltip("if this is true, the light will be disabled when this feedbacks is stopped")] 
+		public bool DisableOnStop = false;
+		/// whether or not the values should be relative or not
+		[Tooltip("whether or not the values should be relative or not")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent, (int)Modes.Instant)]
+		public bool RelativeValues = true;
+		/// whether or not to reset shaker values after shake
+		[Tooltip("whether or not to reset shaker values after shake")]
+		[MMFEnumCondition("Mode", (int)Modes.ShakerEvent)]
+		public bool ResetShakerValuesAfterShake = true;
+		/// whether or not to reset the target's values after shake
+		[Tooltip("whether or not to reset the target's values after shake")]
+		[MMFEnumCondition("Mode", (int)Modes.ShakerEvent)]
+		public bool ResetTargetValuesAfterShake = true;
+		/// whether or not to broadcast a range to only affect certain shakers
+		[Tooltip("whether or not to broadcast a range to only affect certain shakers")]
+		[MMFEnumCondition("Mode", (int)Modes.ShakerEvent)]
+		public bool OnlyBroadcastInRange = false;
+		/// the range of the event, in units
+		[Tooltip("the range of the event, in units")]
+		[MMFEnumCondition("Mode", (int)Modes.ShakerEvent)]
+		public float EventRange = 100f;
+		/// the transform to use to broadcast the event as origin point
+		[Tooltip("the transform to use to broadcast the event as origin point")]
+		[MMFEnumCondition("Mode", (int)Modes.ShakerEvent)]
+		public Transform EventOriginTransform;
+		/// if this is true, calling that feedback will trigger it, even if it's in progress. If it's false, it'll prevent any new Play until the current one is over
+		[Tooltip("if this is true, calling that feedback will trigger it, even if it's in progress. If it's false, it'll prevent any new Play until the current one is over")] 
+		public bool AllowAdditivePlays = false;
+
+		[MMFInspectorGroup("Color", true, 38, true)]
+		/// whether or not to modify the color of the light
+		[Tooltip("whether or not to modify the color of the light")]
+		public bool ModifyColor = true;
+		/// the colors to apply to the light over time
+		[Tooltip("the colors to apply to the light over time")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent)]
+		public Gradient ColorOverTime;
+		/// the color to move to in instant mode
+		[Tooltip("the color to move to in instant mode")]
+		[MMFEnumCondition("Mode", (int)Modes.Instant, (int)Modes.ShakerEvent)]
+		public Color InstantColor = Color.red;
+		/// the color to move to in destination mode
+		[Tooltip("the color to move to in destination mode")]
+		[MMFEnumCondition("Mode", (int)Modes.ToDestination)]
+		public Color ToDestinationColor = Color.red;
+
+		[MMFInspectorGroup("Intensity", true, 39, true)]
+		/// whether or not to modify the intensity of the light
+		[Tooltip("whether or not to modify the intensity of the light")]
+		public bool ModifyIntensity = true;
+		/// the curve to tween the intensity on
+		[Tooltip("the curve to tween the intensity on")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent, (int)Modes.ToDestination)]
+		public AnimationCurve IntensityCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.3f, 1f), new Keyframe(1, 0));
+		/// the value to remap the intensity curve's 0 to
+		[Tooltip("the value to remap the intensity curve's 0 to")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent)]
+		public float RemapIntensityZero = 0f;
+		/// the value to remap the intensity curve's 1 to
+		[Tooltip("the value to remap the intensity curve's 1 to")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent)]
+		public float RemapIntensityOne = 1f;
+		/// the value to move the intensity to in instant mode
+		[Tooltip("the value to move the intensity to in instant mode")]
+		[MMFEnumCondition("Mode", (int)Modes.Instant)]
+		public float InstantIntensity = 1f;
+		/// the value to move the intensity to in ToDestination mode
+		[Tooltip("the value to move the intensity to in ToDestination mode")]
+		[MMFEnumCondition("Mode", (int)Modes.ToDestination)]
+		public float ToDestinationIntensity = 1f;
+
+		[MMFInspectorGroup("Falloff", true, 40, true)]
+		/// whether or not to modify the falloff of the light
+		[Tooltip("whether or not to modify the falloff of the light")]
+		public bool ModifyFalloff = true;
+		/// the falloff to apply to the light over time
+		[Tooltip("the falloff to apply to the light over time")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent, (int)Modes.ToDestination)]
+		public AnimationCurve FalloffCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.3f, 1f), new Keyframe(1, 0));
+		/// the value to remap the falloff curve's 0 to
+		[Tooltip("the value to remap the falloff curve's 0 to")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent)]
+		public float RemapFalloffZero = 0f;
+		/// the value to remap the falloff curve's 0 to
+		[Tooltip("the value to remap the falloff curve's 0 to")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent)]
+		public float RemapFalloffOne = 10f;
+		/// the value to move the intensity to in instant mode
+		[Tooltip("the value to move the intensity to in instant mode")]
+		[MMFEnumCondition("Mode", (int)Modes.Instant)]
+		public float InstantFalloff = 10f;
+		/// the value to move the intensity to in ToDestination mode
+		[Tooltip("the value to move the intensity to in ToDestination mode")]
+		[MMFEnumCondition("Mode", (int)Modes.ToDestination)]
+		public float ToDestinationFalloff = 10f;
+
+		[MMFInspectorGroup("Shadow Strength", true, 41, true)]
+		/// whether or not to modify the shadow strength of the light
+		[Tooltip("whether or not to modify the shadow strength of the light")]
+		public bool ModifyShadowStrength = true;
+		/// the shadow strength to apply to the light over time
+		[Tooltip("the shadow strength to apply to the light over time")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent, (int)Modes.ToDestination)]
+		public AnimationCurve ShadowStrengthCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.3f, 1f), new Keyframe(1, 0));
+		/// the value to remap the shadow strength's curve's 0 to
+		[Tooltip("the value to remap the shadow strength's curve's 0 to")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent)]
+		public float RemapShadowStrengthZero = 0f;
+		/// the value to remap the shadow strength's curve's 1 to
+		[Tooltip("the value to remap the shadow strength's curve's 1 to")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent)]
+		public float RemapShadowStrengthOne = 1f;
+		/// the value to move the shadow strength to in instant mode
+		[Tooltip("the value to move the shadow strength to in instant mode")]
+		[MMFEnumCondition("Mode", (int)Modes.Instant)]
+		public float InstantShadowStrength = 1f;
+		/// the value to move the shadow strength to in ToDestination mode
+		[Tooltip("the value to move the shadow strength to in ToDestination mode")]
+		[MMFEnumCondition("Mode", (int)Modes.ToDestination)]
+		public float ToDestinationShadowStrength = 1f;
+
+		[MMFInspectorGroup("Volumetric Intensity", true, 39, true)]
+		/// whether or not to modify the volumetric intensity of the light
+		[Tooltip("whether or not to modify the volumetric intensity of the light")]
+		public bool ModifyVolumetricIntensity = true;
+		/// the curve to tween the volumetric intensity on
+		[Tooltip("the curve to tween the volumetric intensity on")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent, (int)Modes.ToDestination)]
+		public AnimationCurve VolumetricIntensityCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.3f, 1f), new Keyframe(1, 0));
+		/// the value to remap the volumetric intensity curve's 0 to
+		[Tooltip("the value to remap the volumetric intensity curve's 0 to")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent)]
+		public float RemapVolumetricIntensityZero = 0f;
+		/// the value to remap the volumetric intensity curve's 1 to
+		[Tooltip("the value to remap the volumetric intensity curve's 1 to")]
+		[MMFEnumCondition("Mode", (int)Modes.OverTime, (int)Modes.ShakerEvent)]
+		public float RemapVolumetricIntensityOne = 1f;
+		/// the value to move the volumetric intensity to in instant mode
+		[Tooltip("the value to move the volumetric intensity to in instant mode")]
+		[MMFEnumCondition("Mode", (int)Modes.Instant)]
+		public float InstantVolumetricIntensity = 1f;
+		/// the value to move the volumetric intensity to in ToDestination mode
+		[Tooltip("the value to move the volumetric intensity to in ToDestination mode")]
+		[MMFEnumCondition("Mode", (int)Modes.ToDestination)]
+		public float ToDestinationVolumetricIntensity = 1f;
+
+		protected float _initialFalloff;
+		protected float _initialShadowStrength;
+		protected float _initialIntensity;
+		protected float _initialVolumetricIntensity;
+		protected Coroutine _coroutine;
+		protected Color _initialColor;
+		protected Color _targetColor;
+
+		/// <summary>
+		/// On init we turn the light off if needed
+		/// </summary>
+		/// <param name="owner"></param>
+		protected override void CustomInitialization(MMF_Player owner)
+		{
+			base.CustomInitialization(owner);
+
+			if (BoundLight == null)
+			{
+				return;
+			}
+            
+			_initialFalloff = BoundLight.shapeLightFalloffSize ;
+			_initialShadowStrength = BoundLight.shadowIntensity;
+			_initialIntensity = BoundLight.intensity;
+			_initialVolumetricIntensity = BoundLight.volumeIntensity;
+			_initialColor = BoundLight.color;
+
+			if (EventOriginTransform == null)
+			{
+				EventOriginTransform = owner.transform;
+			}
+
+			if (Active)
+			{
+				if (StartsOff)
+				{
+					Turn(false);
+				}
+			}
+		}
+
+		/// <summary>
+		/// On Play we turn our light on and start an over time coroutine if needed
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+
+			if (Mode == Modes.ToDestination)
+			{
+				_initialFalloff = BoundLight.shapeLightFalloffSize ;
+				_initialShadowStrength = BoundLight.shadowIntensity;
+				_initialIntensity = BoundLight.intensity;
+				_initialIntensity = BoundLight.volumeIntensity;
+				_initialColor = BoundLight.color;
+			}
+			
+			float intensityMultiplier = ComputeIntensity(feedbacksIntensity, position);
+			Turn(true);
+			switch (Mode)
+			{
+				case Modes.Instant:
+					BoundLight.intensity = InstantIntensity * intensityMultiplier;
+					BoundLight.intensity = InstantVolumetricIntensity * intensityMultiplier;
+					BoundLight.shadowIntensity = InstantShadowStrength;
+					BoundLight.shapeLightFalloffSize  = InstantFalloff;
+					if (ModifyColor)
+					{
+						BoundLight.color = InstantColor;
+					}                        
+					break;
+				case Modes.OverTime:
+				case Modes.ToDestination:
+					if (!AllowAdditivePlays && (_coroutine != null))
+					{
+						return;
+					}
+					if (_coroutine != null) { Owner.StopCoroutine(_coroutine); }
+					_coroutine = Owner.StartCoroutine(LightSequence(intensityMultiplier));
+					break;
+				case Modes.ShakerEvent:
+					if (EventOriginTransform == null)
+					{
+						EventOriginTransform = Owner.transform;
+					}
+					MMLight2DShakeEvent.Trigger(FeedbackDuration, RelativeValues, ModifyColor, ColorOverTime, IntensityCurve,
+						RemapIntensityZero, RemapIntensityOne, FalloffCurve, RemapFalloffZero * intensityMultiplier, RemapFalloffOne * intensityMultiplier,
+						ShadowStrengthCurve, RemapShadowStrengthZero, RemapShadowStrengthOne, feedbacksIntensity,
+						ChannelData, ResetShakerValuesAfterShake, ResetTargetValuesAfterShake,
+						OnlyBroadcastInRange, EventRange, EventOriginTransform.position);
+					break;
+			}
+		}
+
+		/// <summary>
+		/// This coroutine will modify the intensity and color of the light over time
+		/// </summary>
+		/// <returns></returns>
+		protected virtual IEnumerator LightSequence(float intensityMultiplier)
+		{
+			IsPlaying = true;
+			float journey = NormalPlayDirection ? 0f : FeedbackDuration;
+			while ((journey >= 0) && (journey <= FeedbackDuration) && (FeedbackDuration > 0))
+			{
+				float remappedTime = MMFeedbacksHelpers.Remap(journey, 0f, FeedbackDuration, 0f, 1f);
+
+				SetLightValues(remappedTime, intensityMultiplier);
+
+				journey += NormalPlayDirection ? FeedbackDeltaTime : -FeedbackDeltaTime;
+				yield return null;
+			}
+			SetLightValues(FinalNormalizedTime, intensityMultiplier);
+			if (DisableOnStop)
+			{
+				Turn(false);
+			}            
+			IsPlaying = false;
+			_coroutine = null;
+			yield return null;
+		}
+
+
+		/// <summary>
+		/// Sets the various values on the light on a specified time (between 0 and 1)
+		/// </summary>
+		/// <param name="time"></param>
+		protected virtual void SetLightValues(float time, float intensityMultiplier)
+		{
+			float intensity = 0f;
+			float volumeIntensity = 0f;
+			float falloff = 0f;
+			float shadowStrength = 0f;    
+			
+			switch (Mode)
+			{
+				case Modes.OverTime:
+					intensity = MMFeedbacksHelpers.Remap(IntensityCurve.Evaluate(time), 0f, 1f, RemapIntensityZero, RemapIntensityOne);
+					volumeIntensity = MMFeedbacksHelpers.Remap(VolumetricIntensityCurve.Evaluate(time), 0f, 1f, RemapVolumetricIntensityZero, RemapVolumetricIntensityOne);
+					falloff = MMFeedbacksHelpers.Remap(FalloffCurve.Evaluate(time), 0f, 1f, RemapFalloffZero, RemapFalloffOne);
+					shadowStrength = MMFeedbacksHelpers.Remap(ShadowStrengthCurve.Evaluate(time), 0f, 1f, RemapShadowStrengthZero, RemapShadowStrengthOne);    
+					_targetColor = ColorOverTime.Evaluate(time);
+					break;
+				case Modes.ToDestination:
+					intensity = Mathf.Lerp(_initialIntensity, ToDestinationIntensity, IntensityCurve.Evaluate(time));
+					volumeIntensity = Mathf.Lerp(_initialVolumetricIntensity, ToDestinationVolumetricIntensity, VolumetricIntensityCurve.Evaluate(time));
+					falloff = Mathf.Lerp(_initialFalloff, ToDestinationFalloff, FalloffCurve.Evaluate(time));
+					shadowStrength = Mathf.Lerp(_initialShadowStrength, ToDestinationShadowStrength, ShadowStrengthCurve.Evaluate(time));
+					_targetColor = Color.Lerp(_initialColor, ToDestinationColor, time);
+					break;
+			}    
+
+			if (RelativeValues && (Mode != Modes.ToDestination))
+			{
+				intensity += _initialIntensity;
+				volumeIntensity += _initialVolumetricIntensity;
+				shadowStrength += _initialShadowStrength;
+				falloff += _initialFalloff;
+			}
+
+			if (ModifyIntensity)
+			{
+				BoundLight.intensity = intensity * intensityMultiplier;	
+			}
+			if (ModifyVolumetricIntensity)
+			{
+				BoundLight.volumeIntensity = volumeIntensity * intensityMultiplier;
+			}
+			if (ModifyFalloff)
+			{
+				BoundLight.shapeLightFalloffSize  = falloff;	
+			}
+			if (ModifyShadowStrength)
+			{
+				BoundLight.shadowIntensity = Mathf.Clamp01(shadowStrength);	
+			}
+			if (ModifyColor)
+			{
+				BoundLight.color = _targetColor;
+			}
+		}
+
+		/// <summary>
+		/// Turns the light off on stop
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			base.CustomStopFeedback(position, feedbacksIntensity);
+			IsPlaying = false;
+			if (Active && (_coroutine != null))
+			{
+				Owner.StopCoroutine(_coroutine);
+				_coroutine = null;
+			}
+			if (Active && DisableOnStop)
+			{
+				Turn(false);
+			}
+		}
+
+		/// <summary>
+		/// Turns the light on or off
+		/// </summary>
+		/// <param name="status"></param>
+		protected virtual void Turn(bool status)
+		{
+			if (BoundLight == null)
+			{
+				return;
+			}
+			BoundLight.enabled = status;
+		}
+		
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			
+			BoundLight.shapeLightFalloffSize  = _initialFalloff;
+			BoundLight.shadowIntensity = _initialShadowStrength;
+			BoundLight.intensity = _initialIntensity;
+			BoundLight.volumeIntensity = _initialVolumetricIntensity;
+			BoundLight.color = _initialColor;
+
+			if (StartsOff)
+			{
+				Turn(false);
+			}
+		}
+	}
+	#endif
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_Light2D_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_MotionBlur_URP.cs

@@ -0,0 +1,122 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using UnityEngine.Scripting.APIUpdating;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control URP motion blur intensity over time.
+	/// It requires you have in your scene an object with a Volume 
+	/// with MotionBlur active, and a MMMotionBlurShaker_URP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	#if MM_URP
+	[FeedbackPath("PostProcess/Motion Blur URP")]
+	#endif
+	[MovedFrom(false, null, "MoreMountains.Feedbacks.URP")]
+	[FeedbackHelp("This feedback allows you to control motion blur intensity over time. " +
+	              "It requires you have in your scene an object with a Volume " +
+	              "with MotionBlur active, and a MMMotionBlurShaker_URP component.")]
+	public class MMF_MotionBlur_URP : 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.PostProcessColor; } }
+		public override bool HasCustomInspectors => true;
+		public override bool HasAutomaticShakerSetup => true;
+		#endif
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(Duration); } set { Duration = value; } }
+		public override bool HasChannel => true;
+		public override bool HasRandomness => true;
+
+		[MMFInspectorGroup("Motion Blur", true, 25)]
+		/// the duration of the shake, in seconds
+		[Tooltip("the duration of the shake, in seconds")]
+		public float Duration = 0.2f;
+		/// whether or not to reset shaker values after shake
+		[Tooltip("whether or not to reset shaker values after shake")]
+		public bool ResetShakerValuesAfterShake = true;
+		/// 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 ResetTargetValuesAfterShake = true;
+
+		[MMFInspectorGroup("Intensity", true, 24)]
+		/// the curve to animate the intensity on
+		[Tooltip("the curve to animate the intensity on")]
+		public AnimationCurve Intensity = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
+		/// the value to which to remap the curve's zero to
+		[Tooltip("the value to which to remap the curve's zero to")]
+		[Range(0f, 1f)]
+		public float RemapIntensityZero = 0f;
+		/// the value to which to remap the curve's one to
+		[Tooltip("the value to which to remap the curve's one to")]
+		[Range(0f, 1f)]
+		public float RemapIntensityOne = 1.0f;
+		/// whether or not to add to the initial intensity
+		[Tooltip("whether or not to add to the initial intensity")]
+		public bool RelativeIntensity = false;
+
+		/// <summary>
+		/// Triggers a motion blur shake
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="attenuation"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			float intensityMultiplier = ComputeIntensity(feedbacksIntensity, position);
+			MMMotionBlurShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, intensityMultiplier,
+				ChannelData, ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, ComputedTimescaleMode);
+            
+		}
+        
+		/// <summary>
+		/// On stop we stop our transition
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			base.CustomStopFeedback(position, feedbacksIntensity);
+			MMMotionBlurShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, stop: true, channelData: ChannelData);
+		}
+
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			
+			MMMotionBlurShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, restore: true, channelData: ChannelData);
+		}
+		
+		/// <summary>
+		/// Automaticall sets up the post processing profile and shaker
+		/// </summary>
+		public override void AutomaticShakerSetup()
+		{
+			#if MM_URP && UNITY_EDITOR
+			MMURPHelpers.GetOrCreateVolume<MotionBlur, MMMotionBlurShaker_URP>(Owner, "MotionBlur");
+			#endif
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_MotionBlur_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_PaniniProjection_URP.cs

@@ -0,0 +1,121 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using UnityEngine.Scripting.APIUpdating;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control Panini Projection distance and crop to fit over time. 
+	/// It requires you have in your scene an object with a Volume with Bloom active, and a MMPaniniProjectionShaker_URP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackHelp("This feedback allows you to control Panini Projection distance and crop to fit over time. " +
+	              "It requires you have in your scene an object with a Volume " +
+	              "with PaniniProjection active, and a MMPaniniProjectionShaker_URP component.")]
+	#if MM_URP
+	[FeedbackPath("PostProcess/Panini Projection URP")]
+	#endif
+	[MovedFrom(false, null, "MoreMountains.Feedbacks.URP")]
+	public class MMF_PaniniProjection_URP : 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.PostProcessColor; } }
+		public override bool HasCustomInspectors => true;
+		public override bool HasAutomaticShakerSetup => true;
+		#endif
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(Duration); } set { Duration = value; } }
+		public override bool HasChannel => true;
+		public override bool HasRandomness => true;
+
+		[MMFInspectorGroup("Panini Projection", true, 28)]
+		/// the duration of the shake, in seconds
+		[Tooltip("the duration of the shake, in seconds")]
+		public float Duration = 0.2f;
+		/// whether or not to reset shaker values after shake
+		[Tooltip("whether or not to reset shaker values after shake")]
+		public bool ResetShakerValuesAfterShake = true;
+		/// 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 ResetTargetValuesAfterShake = true;
+
+		[MMFInspectorGroup("Distance", true, 27)]
+		/// whether or not to add to the initial value
+		[Tooltip("whether or not to add to the initial value")]
+		public bool RelativeDistance = false;
+		/// the curve used to animate the distance value on
+		[Tooltip("the curve used to animate the distance value on")]
+		public AnimationCurve ShakeDistance = 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, 1f)]
+		public float RemapDistanceZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(0f, 1f)]
+		public float RemapDistanceOne = 1f;
+
+		/// <summary>
+		/// Triggers a bloom shake
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="attenuation"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			float intensityMultiplier = ComputeIntensity(feedbacksIntensity, position);
+			MMPaniniProjectionShakeEvent_URP.Trigger(ShakeDistance, FeedbackDuration, RemapDistanceZero, RemapDistanceOne, RelativeDistance, intensityMultiplier, ChannelData, 
+				ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, ComputedTimescaleMode);
+            
+		}
+        
+		/// <summary>
+		/// On stop we stop our transition
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			base.CustomStopFeedback(position, feedbacksIntensity);
+			MMPaniniProjectionShakeEvent_URP.Trigger(ShakeDistance, FeedbackDuration, RemapDistanceZero, RemapDistanceOne, RelativeDistance, channelData: ChannelData, stop: true);
+		}
+
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			
+			MMPaniniProjectionShakeEvent_URP.Trigger(ShakeDistance, FeedbackDuration, RemapDistanceZero, RemapDistanceOne, RelativeDistance, channelData: ChannelData, restore: true);
+		}
+		
+		/// <summary>
+		/// Automaticall sets up the post processing profile and shaker
+		/// </summary>
+		public override void AutomaticShakerSetup()
+		{
+			#if MM_URP && UNITY_EDITOR
+			MMURPHelpers.GetOrCreateVolume<PaniniProjection, MMPaniniProjectionShaker_URP>(Owner, "PaniniProjection");
+			#endif
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_PaniniProjection_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_Vignette_URP.cs

@@ -0,0 +1,143 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using UnityEngine.Scripting.APIUpdating;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control URP vignette intensity over time.
+	/// It requires you have in your scene an object with a Volume 
+	/// with Vignette active, and a MMVignetteShaker_URP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	#if MM_URP
+	[FeedbackPath("PostProcess/Vignette URP")]
+	#endif
+	[MovedFrom(false, null, "MoreMountains.Feedbacks.URP")]
+	[FeedbackHelp("This feedback allows you to control vignette intensity over time. " +
+	              "It requires you have in your scene an object with a Volume " +
+	              "with Vignette active, and a MMVignetteShaker_URP component.")]
+	public class MMF_Vignette_URP : 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.PostProcessColor; } }
+		public override bool HasCustomInspectors => true;
+		public override bool HasAutomaticShakerSetup => true;
+		#endif
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(Duration); } set { Duration = value; } }
+		public override bool HasChannel => true;
+		public override bool HasRandomness => true;
+
+		[MMFInspectorGroup("Vignette", true, 28)]
+		/// the duration of the shake, in seconds
+		[Tooltip("the duration of the shake, in seconds")]
+		public float Duration = 0.2f;
+		/// whether or not to reset shaker values after shake
+		[Tooltip("whether or not to reset shaker values after shake")]
+		public bool ResetShakerValuesAfterShake = true;
+		/// 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 ResetTargetValuesAfterShake = true;
+
+		[MMFInspectorGroup("Intensity", true, 29)]
+		/// the curve to animate the intensity on
+		[Tooltip("the curve to animate the intensity on")]
+		public AnimationCurve Intensity = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));        
+		/// the value to remap the curve's zero to
+		[Tooltip("the value to remap the curve's zero to")]
+		[Range(0f, 1f)]
+		public float RemapIntensityZero = 0f;
+		/// the value to remap the curve's one to
+		[Tooltip("the value to remap the curve's one to")]
+		[Range(0f, 1f)]
+		public float RemapIntensityOne = 1.0f;
+		/// whether or not to add to the initial intensity
+		[Tooltip("whether or not to add to the initial intensity")]
+		public bool RelativeIntensity = false;
+		
+		[Header("Color")]
+		/// whether or not to also animate  the vignette's color
+		[Tooltip("whether or not to also animate the vignette's color")]
+		public bool InterpolateColor = false;
+		/// the curve to animate the color on
+		[Tooltip("the curve to animate the color on")]
+		public AnimationCurve ColorCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.05f, 1f), new Keyframe(0.95f, 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(0, 1)]
+		public float RemapColorZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(0f, 1f)]
+		public float RemapColorOne = 1f;
+		/// the color to lerp towards
+		[Tooltip("the color to lerp towards")]
+		public Color TargetColor = Color.red;
+
+		/// <summary>
+		/// Triggers a vignette shake
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="attenuation"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			float intensityMultiplier = ComputeIntensity(feedbacksIntensity, position);
+			MMVignetteShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, intensityMultiplier,
+				ChannelData, ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, ComputedTimescaleMode, false, false, InterpolateColor,
+				ColorCurve, RemapColorZero, RemapColorOne, TargetColor);
+            
+		}
+        
+		/// <summary>
+		/// On stop we stop our transition
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			base.CustomStopFeedback(position, feedbacksIntensity);
+            
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			MMVignetteShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, stop: true, channelData: ChannelData);
+		}
+
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			
+			MMVignetteShakeEvent_URP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, restore: true, channelData: ChannelData);
+		}
+		
+		/// <summary>
+		/// Automaticall sets up the post processing profile and shaker
+		/// </summary>
+		public override void AutomaticShakerSetup()
+		{
+			#if MM_URP && UNITY_EDITOR
+			MMURPHelpers.GetOrCreateVolume<Vignette, MMVignetteShaker_URP>(Owner, "Vignette");
+			#endif
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_Vignette_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_WhiteBalance_URP.cs

@@ -0,0 +1,139 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using UnityEngine.Scripting.APIUpdating;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control white balance temperature and tint over time. 
+	/// It requires you have in your scene an object with a Volume with White Balance active, and a MMWhiteBalanceShaker_URP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackHelp("This feedback allows you to control white balance temperature and tint over time. " +
+	              "It requires you have in your scene an object with a Volume " +
+	              "with WhiteBalance active, and a MMWhiteBalanceShaker_URP component.")]
+	#if MM_URP
+	[FeedbackPath("PostProcess/White Balance URP")]
+	#endif
+	[MovedFrom(false, null, "MoreMountains.Feedbacks.URP")]
+	public class MMF_WhiteBalance_URP : 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.PostProcessColor; } }
+		public override bool HasCustomInspectors => true;
+		public override bool HasAutomaticShakerSetup => true;
+		#endif
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(ShakeDuration); } set { ShakeDuration = value; } }
+		public override bool HasChannel => true;
+		public override bool HasRandomness => true;
+
+		[MMFInspectorGroup("White Balance", true, 29)]
+		/// the duration of the shake, in seconds
+		[Tooltip("the duration of the shake, in seconds")]
+		public float ShakeDuration = 1f;
+		/// whether or not to add to the initial value
+		[Tooltip("whether or not to add to the initial value")]
+		public bool RelativeValues = true;
+		/// whether or not to reset shaker values after shake
+		[Tooltip("whether or not to reset shaker values after shake")]
+		public bool ResetShakerValuesAfterShake = true;
+		/// 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 ResetTargetValuesAfterShake = true;
+
+		[MMFInspectorGroup("Temperature", true, 29)]
+		/// the curve used to animate the temperature value on
+		[Tooltip("the curve used to animate the temperature value on")]
+		public AnimationCurve ShakeTemperature = 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(-100f, 100f)]
+		public float RemapTemperatureZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-100f, 100f)]
+		public float RemapTemperatureOne = 100f;
+
+		[MMFInspectorGroup("Tint", true, 29)]
+		/// the curve used to animate the tint value on
+		[Tooltip("the curve used to animate the tint value on")]
+		public AnimationCurve ShakeTint = 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(-100f, 100f)]
+		public float RemapTintZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-100f, 100f)]
+		public float RemapTintOne = 100f;
+
+		/// <summary>
+		/// Triggers a white balance shake
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="attenuation"></param>
+		protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			float intensityMultiplier = ComputeIntensity(feedbacksIntensity, position);
+			MMWhiteBalanceShakeEvent_URP.Trigger(ShakeTemperature, FeedbackDuration, RemapTemperatureZero, RemapTemperatureOne,
+				ShakeTint, RemapTintZero, RemapTintOne, RelativeValues, intensityMultiplier,
+				ChannelData, ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, ComputedTimescaleMode);
+            
+		}
+        
+		/// <summary>
+		/// On stop we stop our transition
+		/// </summary>
+		/// <param name="position"></param>
+		/// <param name="feedbacksIntensity"></param>
+		protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+            
+			base.CustomStopFeedback(position, feedbacksIntensity);
+            
+			MMWhiteBalanceShakeEvent_URP.Trigger(ShakeTemperature, FeedbackDuration, RemapTemperatureZero, RemapTemperatureOne,
+				ShakeTint, RemapTintZero, RemapTintOne, RelativeValues, stop: true, channelData: ChannelData);
+		}
+
+		/// <summary>
+		/// On restore, we put our object back at its initial position
+		/// </summary>
+		protected override void CustomRestoreInitialValues()
+		{
+			if (!Active || !FeedbackTypeAuthorized)
+			{
+				return;
+			}
+			
+			MMWhiteBalanceShakeEvent_URP.Trigger(ShakeTemperature, FeedbackDuration, RemapTemperatureZero, RemapTemperatureOne,
+				ShakeTint, RemapTintZero, RemapTintOne, RelativeValues, restore: true, channelData: ChannelData);
+		}
+		
+		/// <summary>
+		/// Automaticall sets up the post processing profile and shaker
+		/// </summary>
+		public override void AutomaticShakerSetup()
+		{
+			#if MM_URP && UNITY_EDITOR
+			MMURPHelpers.GetOrCreateVolume<WhiteBalance, MMWhiteBalanceShaker_URP>(Owner, "WhiteBalance");
+			#endif
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Feedbacks/MMF_WhiteBalance_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Helpers.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Helpers/MMGlobalPostProcessingVolumeAutoBlend_URP.cs

@@ -0,0 +1,195 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using UnityEngine.Rendering;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Use this class to have a global PP volume auto blend its weight on cue, between a start and end values
+	/// </summary>
+	#if MM_URP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMGlobalPostProcessingVolumeAutoBlend_URP")]
+	public class MMGlobalPostProcessingVolumeAutoBlend_URP : MonoBehaviour
+	{
+		/// the possible timescales this blend can operate on
+		public enum TimeScales { Scaled, Unscaled }
+		/// the possible blend trigger modes 
+		public enum BlendTriggerModes { OnEnable, Script }
+
+		[Header("Blend")]
+		/// the trigger mode for this MMGlobalPostProcessingVolumeAutoBlend
+		/// Start : will play automatically on enable
+		public BlendTriggerModes BlendTriggerMode = BlendTriggerModes.OnEnable;
+		/// the duration of the blend (in seconds)
+		public float BlendDuration = 1f;
+		/// the curve to use to blend
+		public AnimationCurve Curve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(1, 1f));
+
+		[Header("Weight")]
+		/// the weight at the start of the blend
+		[Range(0f, 1f)]
+		public float InitialWeight = 0f;
+		/// the desired weight at the end of the blend
+		[Range(0f, 1f)]
+		public float FinalWeight = 1f;
+
+		[Header("Behaviour")]
+		/// the timescale to operate on
+		public TimeScales TimeScale = TimeScales.Unscaled;
+		/// whether or not the associated volume should be disabled at 0
+		public bool DisableVolumeOnZeroWeight = true;
+		/// whether or not this blender should disable itself at 0
+		public bool DisableSelfAfterEnd = true;
+		/// whether or not this blender can be interrupted
+		public bool Interruptable = true;
+		/// whether or not this blender should pick the current value as its starting point
+		public bool StartFromCurrentValue = true;
+
+		[Header("Tests")]
+		/// test blend button
+		[MMFInspectorButton("Blend")]
+		public bool TestBlend;
+		/// test blend back button
+		[MMFInspectorButton("BlendBack")]
+		public bool TestBlendBackwards;
+
+		/// <summary>
+		/// Returns the correct timescale based on the chosen settings
+		/// </summary>
+		/// <returns></returns>
+		protected float GetTime()
+		{
+			return (TimeScale == TimeScales.Unscaled) ? Time.unscaledTime : Time.time;
+		}
+
+		protected float _initial;
+		protected float _destination;
+		protected float _startTime;
+		protected bool _blending = false;
+		#if MM_URP
+		protected Volume _volume;
+
+		/// <summary>
+		/// On Awake we store our volume
+		/// </summary>
+		protected virtual void Awake()
+		{
+			_volume = this.gameObject.GetComponent<Volume>();
+			_volume.weight = InitialWeight;
+		}
+		#endif
+
+		/// <summary>
+		/// On start we start blending if needed
+		/// </summary>
+		protected virtual void OnEnable()
+		{
+			if ((BlendTriggerMode == BlendTriggerModes.OnEnable) && !_blending)
+			{
+				Blend();
+			}
+		}
+
+		/// <summary>
+		/// Blends the volume's weight from the initial value to the final one
+		/// </summary>
+		public virtual void Blend()
+		{
+			#if MM_URP
+			if (_blending && !Interruptable)
+			{
+				return;
+			}
+			_initial = StartFromCurrentValue ? _volume.weight : InitialWeight;
+			_destination = FinalWeight;
+			StartBlending();
+			#endif
+		}
+
+		/// <summary>
+		/// Blends the volume's weight from the final value to the initial one
+		/// </summary>
+		public virtual void BlendBack()
+		{
+			#if MM_URP
+			if (_blending && !Interruptable)
+			{
+				return;
+			}
+			_initial = StartFromCurrentValue ? _volume.weight : FinalWeight;
+			_destination = InitialWeight;
+			StartBlending();
+			#endif
+		}
+
+		/// <summary>
+		/// Internal method used to start blending
+		/// </summary>
+		protected virtual void StartBlending()
+		{
+			#if MM_URP
+			_startTime = GetTime();
+			_blending = true;
+			this.enabled = true;
+			if (DisableVolumeOnZeroWeight)
+			{
+				_volume.enabled = true;
+			}
+			#endif
+		}
+        
+		/// <summary>
+		/// Stops any blending that may be in progress
+		/// </summary>
+		public virtual void StopBlending()
+		{
+			_blending = false;
+		}
+
+		/// <summary>
+		/// On update, processes the blend if needed
+		/// </summary>
+		protected virtual void Update()
+		{
+			if (!_blending)
+			{
+				return;
+			}
+            
+			#if MM_URP
+			float timeElapsed = (GetTime() - _startTime);
+			if (timeElapsed < BlendDuration)
+			{                
+				float remapped = MMFeedbacksHelpers.Remap(timeElapsed, 0f, BlendDuration, 0f, 1f);
+				_volume.weight = Mathf.LerpUnclamped(_initial, _destination, Curve.Evaluate(remapped));
+			}
+			else
+			{
+				// after end is reached
+				_volume.weight = _destination;
+				_blending = false;
+				if (DisableVolumeOnZeroWeight && (_volume.weight == 0f))
+				{
+					_volume.enabled = false;
+				}
+				if (DisableSelfAfterEnd)
+				{
+					this.enabled = false;
+				}
+			}
+			#endif
+		}
+	
+		public virtual void RestoreInitialValues()
+		{
+			#if MM_URP
+			_volume.weight = _initial;
+			#endif
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Helpers/MMGlobalPostProcessingVolumeAutoBlend_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Helpers/MMURPHelpers.cs

@@ -0,0 +1,64 @@
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+using UnityEngine;
+#if MM_URP
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+#endif
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	public class MMURPHelpers : MonoBehaviour
+	{
+		#if UNITY_EDITOR && MM_URP
+		public static void GetOrCreateVolume<T, U>(MMF_Player owner, string feedbackName) where T:VolumeComponent where U:MMShaker
+		{
+			string additions = owner.name + " "+feedbackName+" feedback automatic shaker setup : ";
+			
+			if (Application.isPlaying)
+			{
+				Debug.LogWarning("Automatic shaker setup is only available outside of play mode.");
+				return;
+			}
+			
+			// looks for the main camera 
+			UniversalAdditionalCameraData cameraData = Camera.main.GetUniversalAdditionalCameraData();
+			cameraData.renderPostProcessing = true;
+			additions += "Set PostProcessing:true on the "+Camera.main.name+" camera. ";
+				
+			// looks for a Volume
+			Volume volume = (Volume)Object.FindObjectOfType(typeof(Volume));
+			if (volume == null)
+			{
+				GameObject postProcessingObject = GameObject.Instantiate(Resources.Load<GameObject>("MMDefaultURPVolume"));
+				volume = postProcessingObject.GetComponent<Volume>();
+				additions += "Added a Volume to the scene. ";
+			}
+			
+			// looks for a setting on the volume
+			T effect;
+			if (!volume.sharedProfile.TryGet(out effect))
+			{
+				effect = volume.sharedProfile.Add<T>();
+				AssetDatabase.AddObjectToAsset(effect, volume.sharedProfile);
+				EditorUtility.SetDirty(volume.sharedProfile);
+				AssetDatabase.SaveAssets();
+				additions += "Added a "+feedbackName+" post process effect to the "+volume.gameObject.name+" Volume. ";
+			}
+			
+			// looks for a matching shaker
+			U shaker = volume.GetComponent<U>();
+			if (shaker == null)
+			{
+				shaker = volume.gameObject.AddComponent<U>();
+				additions += "Added a "+feedbackName+" Shaker to the "+volume.gameObject.name+" Post Process Volume. ";
+			}
+			
+			MMDebug.DebugLogInfo( additions + "You're all set.");
+		}
+		#endif
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Helpers/MMURPHelpers.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/MoreMountains.Feedbacks.URP.asmref

@@ -0,0 +1,3 @@
+{
+    "reference": "GUID:4a1cb1490dc4df8409b2580d6b44e75e"
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/MoreMountains.Feedbacks.URP.asmref.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4d249ce4961d8fc48b6cb4dc6b165261
+AssemblyDefinitionReferenceImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Resources.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Resources/MMDefaultURPProfile.asset

@@ -0,0 +1,347 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-8933951220825085215
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 81180773991d8724ab7f2d216912b564, type: 3}
+  m_Name: ChromaticAberration
+  m_EditorClassIdentifier: 
+  active: 1
+  intensity:
+    m_OverrideState: 0
+    m_Value: 0
+--- !u!114 &-8836045386534409196
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fb60a22f311433c4c962b888d1393f88, type: 3}
+  m_Name: PaniniProjection
+  m_EditorClassIdentifier: 
+  active: 1
+  distance:
+    m_OverrideState: 0
+    m_Value: 0
+  cropToFit:
+    m_OverrideState: 0
+    m_Value: 1
+--- !u!114 &-8579874560378656748
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: ccf1aba9553839d41ae37dd52e9ebcce, type: 3}
+  m_Name: MotionBlur
+  m_EditorClassIdentifier: 
+  active: 1
+  mode:
+    m_OverrideState: 0
+    m_Value: 0
+  quality:
+    m_OverrideState: 0
+    m_Value: 0
+  intensity:
+    m_OverrideState: 0
+    m_Value: 0
+  clamp:
+    m_OverrideState: 0
+    m_Value: 0.05
+--- !u!114 &-7675463635007233747
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0b2db86121404754db890f4c8dfe81b2, type: 3}
+  m_Name: Bloom
+  m_EditorClassIdentifier: 
+  active: 1
+  skipIterations:
+    m_OverrideState: 0
+    m_Value: 1
+  threshold:
+    m_OverrideState: 0
+    m_Value: 0.9
+  intensity:
+    m_OverrideState: 0
+    m_Value: 0
+  scatter:
+    m_OverrideState: 0
+    m_Value: 0.7
+  clamp:
+    m_OverrideState: 0
+    m_Value: 65472
+  tint:
+    m_OverrideState: 0
+    m_Value: {r: 1, g: 1, b: 1, a: 1}
+  highQualityFiltering:
+    m_OverrideState: 0
+    m_Value: 0
+  downscale:
+    m_OverrideState: 0
+    m_Value: 0
+  maxIterations:
+    m_OverrideState: 0
+    m_Value: 6
+  dirtTexture:
+    m_OverrideState: 0
+    m_Value: {fileID: 0}
+    dimension: 1
+  dirtIntensity:
+    m_OverrideState: 0
+    m_Value: 0
+--- !u!114 &-6671754296521664740
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 221518ef91623a7438a71fef23660601, type: 3}
+  m_Name: WhiteBalance
+  m_EditorClassIdentifier: 
+  active: 1
+  temperature:
+    m_OverrideState: 0
+    m_Value: 0
+  tint:
+    m_OverrideState: 0
+    m_Value: 0
+--- !u!114 &-4481560927439474264
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 66f335fb1ffd8684294ad653bf1c7564, type: 3}
+  m_Name: ColorAdjustments
+  m_EditorClassIdentifier: 
+  active: 1
+  postExposure:
+    m_OverrideState: 0
+    m_Value: 0
+  contrast:
+    m_OverrideState: 0
+    m_Value: 0
+  colorFilter:
+    m_OverrideState: 0
+    m_Value: {r: 1, g: 1, b: 1, a: 1}
+  hueShift:
+    m_OverrideState: 0
+    m_Value: 0
+  saturation:
+    m_OverrideState: 0
+    m_Value: 0
+--- !u!114 &-2517722764101782983
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cdfbdbb87d3286943a057f7791b43141, type: 3}
+  m_Name: ChannelMixer
+  m_EditorClassIdentifier: 
+  active: 1
+  redOutRedIn:
+    m_OverrideState: 0
+    m_Value: 100
+  redOutGreenIn:
+    m_OverrideState: 0
+    m_Value: 0
+  redOutBlueIn:
+    m_OverrideState: 0
+    m_Value: 0
+  greenOutRedIn:
+    m_OverrideState: 0
+    m_Value: 0
+  greenOutGreenIn:
+    m_OverrideState: 0
+    m_Value: 100
+  greenOutBlueIn:
+    m_OverrideState: 0
+    m_Value: 0
+  blueOutRedIn:
+    m_OverrideState: 0
+    m_Value: 0
+  blueOutGreenIn:
+    m_OverrideState: 0
+    m_Value: 0
+  blueOutBlueIn:
+    m_OverrideState: 0
+    m_Value: 100
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d7fd9488000d3734a9e00ee676215985, type: 3}
+  m_Name: MMDefaultURPProfile
+  m_EditorClassIdentifier: 
+  components:
+  - {fileID: -7675463635007233747}
+  - {fileID: -2517722764101782983}
+  - {fileID: -8933951220825085215}
+  - {fileID: -4481560927439474264}
+  - {fileID: 217984836807129381}
+  - {fileID: 6645323203276824829}
+  - {fileID: 6924170477083331223}
+  - {fileID: -8579874560378656748}
+  - {fileID: -8836045386534409196}
+  - {fileID: 6306196269677473977}
+  - {fileID: -6671754296521664740}
+--- !u!114 &217984836807129381
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: c01700fd266d6914ababb731e09af2eb, type: 3}
+  m_Name: DepthOfField
+  m_EditorClassIdentifier: 
+  active: 1
+  mode:
+    m_OverrideState: 0
+    m_Value: 0
+  gaussianStart:
+    m_OverrideState: 0
+    m_Value: 10
+  gaussianEnd:
+    m_OverrideState: 0
+    m_Value: 30
+  gaussianMaxRadius:
+    m_OverrideState: 0
+    m_Value: 1
+  highQualitySampling:
+    m_OverrideState: 0
+    m_Value: 0
+  focusDistance:
+    m_OverrideState: 0
+    m_Value: 10
+  aperture:
+    m_OverrideState: 0
+    m_Value: 5.6
+  focalLength:
+    m_OverrideState: 0
+    m_Value: 50
+  bladeCount:
+    m_OverrideState: 0
+    m_Value: 5
+  bladeCurvature:
+    m_OverrideState: 0
+    m_Value: 1
+  bladeRotation:
+    m_OverrideState: 0
+    m_Value: 0
+--- !u!114 &6306196269677473977
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 899c54efeace73346a0a16faa3afe726, type: 3}
+  m_Name: Vignette
+  m_EditorClassIdentifier: 
+  active: 1
+  color:
+    m_OverrideState: 0
+    m_Value: {r: 0, g: 0, b: 0, a: 1}
+  center:
+    m_OverrideState: 0
+    m_Value: {x: 0.5, y: 0.5}
+  intensity:
+    m_OverrideState: 0
+    m_Value: 0
+  smoothness:
+    m_OverrideState: 0
+    m_Value: 0.2
+  rounded:
+    m_OverrideState: 0
+    m_Value: 0
+--- !u!114 &6645323203276824829
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 29fa0085f50d5e54f8144f766051a691, type: 3}
+  m_Name: FilmGrain
+  m_EditorClassIdentifier: 
+  active: 1
+  type:
+    m_OverrideState: 0
+    m_Value: 0
+  intensity:
+    m_OverrideState: 0
+    m_Value: 0
+  response:
+    m_OverrideState: 0
+    m_Value: 0.8
+  texture:
+    m_OverrideState: 0
+    m_Value: {fileID: 0}
+--- !u!114 &6924170477083331223
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: c5e1dc532bcb41949b58bc4f2abfbb7e, type: 3}
+  m_Name: LensDistortion
+  m_EditorClassIdentifier: 
+  active: 1
+  intensity:
+    m_OverrideState: 0
+    m_Value: 0
+  xMultiplier:
+    m_OverrideState: 0
+    m_Value: 1
+  yMultiplier:
+    m_OverrideState: 0
+    m_Value: 1
+  center:
+    m_OverrideState: 0
+    m_Value: {x: 0.5, y: 0.5}
+  scale:
+    m_OverrideState: 0
+    m_Value: 1

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Resources/MMDefaultURPProfile.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 57d94797548149846b6fb7aec61488f2
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Resources/MMDefaultURPVolume.prefab

@@ -0,0 +1,51 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &4801003995234742267
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 6807295894926285510}
+  - component: {fileID: 312252722905117236}
+  m_Layer: 0
+  m_Name: MMDefaultURPVolume
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &6807295894926285510
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4801003995234742267}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0.16053773, y: 0.068112195, z: 0.110220835}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &312252722905117236
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4801003995234742267}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 172515602e62fb746b5d573b38a5fe58, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_IsGlobal: 1
+  priority: 0
+  blendDistance: 0
+  weight: 1
+  sharedProfile: {fileID: 11400000, guid: 57d94797548149846b6fb7aec61488f2, type: 2}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Resources/MMDefaultURPVolume.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: f41da011e26b4194cbae36ef66842b50
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMAutoFocus_URP.cs

@@ -0,0 +1,64 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This class will set the URP depth of field to focus on the set of targets specified in its inspector.
+	/// </summary>
+	#if MM_URP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMAutoFocus_URP")]
+	public class MMAutoFocus_URP : MonoBehaviour
+	{
+		[Header("Bindings")]
+		/// the position of the camera
+		[Tooltip("the position of the camera")]
+		public Transform CameraTransform;
+		/// a list of all possible targets
+		[Tooltip("a list of all possible targets")]
+		public Transform[] FocusTargets;
+		[Header("Setup")]
+		/// the current target of this auto focus
+		[Tooltip("the current target of this auto focus")]
+		public float FocusTargetID;
+		[Header("Desired Aperture")]
+		/// the aperture to work with
+		[Tooltip("the aperture to work with")]
+		[Range(0.1f, 20f)]
+		public float Aperture = 0.1f;
+
+		#if MM_URP
+		protected Volume _volume;
+		protected VolumeProfile _profile;
+		protected DepthOfField _depthOfField;
+
+		/// <summary>
+		/// On Start, stores volume, profile and DoF
+		/// </summary>
+		void Start()
+		{
+			_volume = GetComponent<Volume>();
+			_profile = _volume.profile;
+			_profile.TryGet<DepthOfField>(out _depthOfField);
+		}
+
+		/// <summary>
+		/// On update we set our focus distance and aperture
+		/// </summary>
+		void Update()
+		{
+			float distance = Vector3.Distance(CameraTransform.position, FocusTargets[Mathf.FloorToInt(FocusTargetID)].position);
+			_depthOfField.focusDistance.Override(distance);
+			_depthOfField.aperture.Override(Aperture);
+		}
+		#endif
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMAutoFocus_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMBloomShaker_URP.cs

@@ -0,0 +1,222 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+using UnityEngine.Rendering;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this class to a Camera with a URP bloom post processing and it'll be able to "shake" its values by getting events
+	/// </summary>
+	#if MM_URP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMBloomShaker_URP")]
+	public class MMBloomShaker_URP : MMShaker
+	{
+		/// whether or not to add to the initial value
+		public bool RelativeValues = true;
+
+		[MMInspectorGroup("Bloom Intensity", true, 51)]
+		/// the curve used to animate the intensity value on
+		[Tooltip("the curve used to animate the intensity value on")]
+		public AnimationCurve ShakeIntensity = 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 RemapIntensityZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapIntensityOne = 1f;
+
+		[MMInspectorGroup("Bloom Threshold", true, 52)]
+		/// the curve used to animate the threshold value on
+		[Tooltip("the curve used to animate the threshold value on")]
+		public AnimationCurve ShakeThreshold = 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 RemapThresholdZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapThresholdOne = 0f;
+
+		#if MM_URP
+		protected Volume _volume;
+		protected Bloom _bloom;
+		protected float _initialIntensity;
+		protected float _initialThreshold;
+		protected float _originalShakeDuration;
+		protected bool _originalRelativeIntensity;
+		protected AnimationCurve _originalShakeIntensity;
+		protected float _originalRemapIntensityZero;
+		protected float _originalRemapIntensityOne;
+		protected AnimationCurve _originalShakeThreshold;
+		protected float _originalRemapThresholdZero;
+		protected float _originalRemapThresholdOne;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_volume = this.gameObject.GetComponent<Volume>();
+			_volume.profile.TryGet(out _bloom);
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newIntensity = ShakeFloat(ShakeIntensity, RemapIntensityZero, RemapIntensityOne, RelativeValues, _initialIntensity);
+			_bloom.intensity.Override(newIntensity);
+			float newThreshold = ShakeFloat(ShakeThreshold, RemapThresholdZero, RemapThresholdOne, RelativeValues, _initialThreshold);
+			_bloom.threshold.Override(newThreshold);
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialIntensity = _bloom.intensity.value;
+			_initialThreshold = _bloom.threshold.value;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="intensity"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeIntensity"></param>
+		/// <param name="attenuation"></param>
+		/// <param name="channel"></param>
+		public virtual void OnBloomShakeEvent(AnimationCurve intensity, float duration, float remapMin, float remapMax,
+			AnimationCurve threshold, float remapThresholdMin, float remapThresholdMax, bool relativeIntensity = false,
+			float attenuation = 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) || (!Interruptible && Shaking))
+			{
+				return;
+			}
+	            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+	            
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalShakeIntensity = ShakeIntensity;
+				_originalRemapIntensityZero = RemapIntensityZero;
+				_originalRemapIntensityOne = RemapIntensityOne;
+				_originalRelativeIntensity = RelativeValues;
+				_originalShakeThreshold = ShakeThreshold;
+				_originalRemapThresholdZero = RemapThresholdZero;
+				_originalRemapThresholdOne = RemapThresholdOne;
+			}
+
+			if (!OnlyUseShakerValues)
+			{
+				TimescaleMode = timescaleMode;
+				ShakeDuration = duration;
+				ShakeIntensity = intensity;
+				RemapIntensityZero = remapMin * attenuation;
+				RemapIntensityOne = remapMax * attenuation;
+				RelativeValues = relativeIntensity;
+				ShakeThreshold = threshold;
+				RemapThresholdZero = remapThresholdMin;
+				RemapThresholdOne = remapThresholdMax;
+				ForwardDirection = forwardDirection;
+			}
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_bloom.intensity.Override(_initialIntensity);
+			_bloom.threshold.Override(_initialThreshold);
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			ShakeIntensity = _originalShakeIntensity;
+			RemapIntensityZero = _originalRemapIntensityZero;
+			RemapIntensityOne = _originalRemapIntensityOne;
+			RelativeValues = _originalRelativeIntensity;
+			ShakeThreshold = _originalShakeThreshold;
+			RemapThresholdZero = _originalRemapThresholdZero;
+			RemapThresholdOne = _originalRemapThresholdOne;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMBloomShakeEvent_URP.Register(OnBloomShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMBloomShakeEvent_URP.Unregister(OnBloomShakeEvent);
+		}
+		#endif
+	}
+
+	/// <summary>
+	/// An event used to trigger vignette shakes
+	/// </summary>
+	public struct MMBloomShakeEvent_URP
+	{
+		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(AnimationCurve intensity, float duration, float remapMin, float remapMax,
+			AnimationCurve threshold, float remapThresholdMin, float remapThresholdMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false);
+
+		static public void Trigger(AnimationCurve intensity, float duration, float remapMin, float remapMax,
+			AnimationCurve threshold, float remapThresholdMin, float remapThresholdMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			OnEvent?.Invoke(intensity, duration, remapMin, remapMax, threshold, remapThresholdMin, remapThresholdMax, relativeIntensity,
+				attenuation, channelData, resetShakerValuesAfterShake, resetTargetValuesAfterShake, forwardDirection, timescaleMode, stop, restore);
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMBloomShaker_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMChannelMixerShaker_URP.cs

@@ -0,0 +1,279 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this class to a Camera with a URP color adjustments post processing and it'll be able to "shake" its values by getting events
+	/// </summary>
+	#if MM_URP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMChannelMixerShaker_URP")]
+	public class MMChannelMixerShaker_URP : MMShaker
+	{
+		/// whether or not to add to the initial value
+		public bool RelativeValues = true;
+
+		[MMInspectorGroup("Red", true, 43)]
+		/// the curve used to animate the red value on
+		[Tooltip("the curve used to animate the red value on")]
+		public AnimationCurve ShakeRed = 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(-200f, 200f)]
+		public float RemapRedZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-200f, 200f)]
+		public float RemapRedOne = 200f;
+
+		[MMInspectorGroup("Green", true, 44)]
+		/// the curve used to animate the green value on
+		[Tooltip("the curve used to animate the green value on")]
+		public AnimationCurve ShakeGreen = 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(-200f, 200f)]
+		public float RemapGreenZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-200f, 200f)]
+		public float RemapGreenOne = 200f;
+
+		[MMInspectorGroup("Blue", true, 45)]
+		/// the curve used to animate the blue value on
+		[Tooltip("the curve used to animate the blue value on")]
+		public AnimationCurve ShakeBlue = 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(-200f, 200f)]
+		public float RemapBlueZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-200f, 200f)]
+		public float RemapBlueOne = 200f;
+        
+		#if MM_URP
+		protected Volume _volume;
+		protected ChannelMixer _channelMixer;
+		protected float _initialRed;
+		protected float _initialGreen;
+		protected float _initialBlue;
+		protected float _initialContrast;
+		protected Color _initialColorFilterColor;
+		protected float _originalShakeDuration;
+		protected bool _originalRelativeValues;
+	        
+		protected AnimationCurve _originalShakeRed;
+		protected float _originalRemapRedZero;
+		protected float _originalRemapRedOne;
+		protected AnimationCurve _originalShakeGreen;
+		protected float _originalRemapGreenZero;
+		protected float _originalRemapGreenOne;
+		protected AnimationCurve _originalShakeBlue;
+		protected float _originalRemapBlueZero;
+		protected float _originalRemapBlueOne;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_volume = this.gameObject.GetComponent<Volume>();
+			_volume.profile.TryGet(out _channelMixer);
+		}
+
+		/// <summary>
+		/// When that shaker gets added, we initialize its shake duration
+		/// </summary>
+		protected virtual void Reset()
+		{
+			ShakeDuration = 0.8f;
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newRed = ShakeFloat(ShakeRed, RemapRedZero, RemapRedOne, RelativeValues, _initialRed);
+			_channelMixer.redOutRedIn.Override(newRed);
+			float newGreen = ShakeFloat(ShakeGreen, RemapGreenZero, RemapGreenOne, RelativeValues, _initialGreen);
+			_channelMixer.greenOutGreenIn.Override(newGreen);
+			float newBlue = ShakeFloat(ShakeBlue, RemapBlueZero, RemapBlueOne, RelativeValues, _initialBlue);
+			_channelMixer.blueOutBlueIn.Override(newBlue);
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialRed = _channelMixer.redOutRedIn.value;
+			_initialGreen = _channelMixer.greenOutGreenIn.value;
+			_initialBlue = _channelMixer.blueOutBlueIn.value;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="intensity"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeIntensity"></param>
+		/// <param name="attenuation"></param>
+		/// <param name="channel"></param>
+		public virtual void OnMMChannelMixerShakeEvent(AnimationCurve shakeRed, float remapRedZero, float remapRedOne,
+			AnimationCurve shakeGreen, float remapGreenZero, float remapGreenOne,
+			AnimationCurve shakeBlue, float remapBlueZero, float remapBlueOne,
+			float duration, bool relativeValues = false,
+			float attenuation = 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) || (!Interruptible && Shaking))
+			{
+				return;
+			}
+	            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalRelativeValues = RelativeValues;
+				_originalShakeRed = ShakeRed;
+				_originalRemapRedZero = RemapRedZero;
+				_originalRemapRedOne = RemapRedOne;
+				_originalShakeGreen = ShakeGreen;
+				_originalRemapGreenZero = RemapGreenZero;
+				_originalRemapGreenOne = RemapGreenOne;
+				_originalShakeBlue = ShakeBlue;
+				_originalRemapBlueZero = RemapBlueZero;
+				_originalRemapBlueOne = RemapBlueOne;
+			}
+
+			if (!OnlyUseShakerValues)
+			{
+				TimescaleMode = timescaleMode;
+				ShakeDuration = duration;
+				RelativeValues = relativeValues;
+				ShakeRed = shakeRed;
+				RemapRedZero = remapRedZero;
+				RemapRedOne = remapRedOne;
+				ShakeGreen = shakeGreen;
+				RemapGreenZero = remapGreenZero;
+				RemapGreenOne = remapGreenOne;
+				ShakeBlue = shakeBlue;
+				RemapBlueZero = remapBlueZero;
+				RemapBlueOne = remapBlueOne;
+				ForwardDirection = forwardDirection;
+			}
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_channelMixer.redOutRedIn.Override(_initialRed);
+			_channelMixer.greenOutGreenIn.Override(_initialGreen);
+			_channelMixer.blueOutBlueIn.Override(_initialBlue);
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			RelativeValues = _originalRelativeValues;
+			ShakeRed = _originalShakeRed;
+			RemapRedZero = _originalRemapRedZero;
+			RemapRedOne = _originalRemapRedOne;
+			ShakeGreen = _originalShakeGreen;
+			RemapGreenZero = _originalRemapGreenZero;
+			RemapGreenOne = _originalRemapGreenOne;
+			ShakeBlue = _originalShakeBlue;
+			RemapBlueZero = _originalRemapBlueZero;
+			RemapBlueOne = _originalRemapBlueOne;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMChannelMixerShakeEvent_URP.Register(OnMMChannelMixerShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMChannelMixerShakeEvent_URP.Unregister(OnMMChannelMixerShakeEvent);
+		}
+		#endif
+	}
+
+	/// <summary>
+	/// An event used to trigger vignette shakes
+	/// </summary>
+	public struct MMChannelMixerShakeEvent_URP
+	{
+		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(
+			AnimationCurve shakeRed, float remapRedZero, float remapRedOne,
+			AnimationCurve shakeGreen, float remapGreenZero, float remapGreenOne,
+			AnimationCurve shakeBlue, float remapBlueZero, float remapBlueOne,
+			float duration, bool relativeValues = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true,
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false);
+
+		static public void Trigger(
+			AnimationCurve shakeRed, float remapRedZero, float remapRedOne,
+			AnimationCurve shakeGreen, float remapGreenZero, float remapGreenOne,
+			AnimationCurve shakeBlue, float remapBlueZero, float remapBlueOne,
+			float duration, bool relativeValues = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true,
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			OnEvent?.Invoke(shakeRed, remapRedZero, remapRedOne,
+				shakeGreen, remapGreenZero, remapGreenOne,
+				shakeBlue, remapBlueZero, remapBlueOne,
+				duration, relativeValues, attenuation, channelData, resetShakerValuesAfterShake, resetTargetValuesAfterShake, forwardDirection, timescaleMode, stop, restore);
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMChannelMixerShaker_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMChromaticAberrationShaker_URP.cs

@@ -0,0 +1,193 @@
+using UnityEngine;
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+using UnityEngine.Rendering;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this class to a Camera with a URP chromatic aberration post processing and it'll be able to "shake" its values by getting events
+	/// </summary>
+	#if MM_URP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMChromaticAberrationShaker_URP")]
+	public class MMChromaticAberrationShaker_URP : MMShaker
+	{
+		[MMInspectorGroup("Chromatic Aberration Intensity", true, 45)]
+		/// whether or not to add to the initial value
+		[Tooltip("whether or not to add to the initial value")]
+		public bool RelativeIntensity = false;
+		/// the curve used to animate the intensity value on
+		[Tooltip("the curve used to animate the intensity value on")]
+		public AnimationCurve ShakeIntensity = 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, 1f)]
+		public float RemapIntensityZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(0f, 1f)]
+		public float RemapIntensityOne = 1f;
+
+		#if MM_URP
+		protected Volume _volume;
+		protected ChromaticAberration _chromaticAberration;
+		protected float _initialIntensity;
+		protected float _originalShakeDuration;
+		protected AnimationCurve _originalShakeIntensity;
+		protected float _originalRemapIntensityZero;
+		protected float _originalRemapIntensityOne;
+		protected bool _originalRelativeIntensity;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_volume = this.gameObject.GetComponent<Volume>();
+			_volume.profile.TryGet(out _chromaticAberration);
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newValue = ShakeFloat(ShakeIntensity, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, _initialIntensity);
+			_chromaticAberration.intensity.Override(newValue);
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialIntensity = _chromaticAberration.intensity.value;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="intensity"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeIntensity"></param>
+		/// <param name="attenuation"></param>
+		/// <param name="channel"></param>
+		public virtual void OnMMChromaticAberrationShakeEvent(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 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) || (!Interruptible && Shaking))
+			{
+				return;
+			}
+	            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+	            
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalShakeIntensity = ShakeIntensity;
+				_originalRemapIntensityZero = RemapIntensityZero;
+				_originalRemapIntensityOne = RemapIntensityOne;
+				_originalRelativeIntensity = RelativeIntensity;
+			}
+
+			if (!OnlyUseShakerValues)
+			{
+				TimescaleMode = timescaleMode;
+				ShakeDuration = duration;
+				ShakeIntensity = intensity;
+				RemapIntensityZero = remapMin * attenuation;
+				RemapIntensityOne = remapMax * attenuation;
+				RelativeIntensity = relativeIntensity;
+				ForwardDirection = forwardDirection;
+			}
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_chromaticAberration.intensity.Override(_initialIntensity);
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			ShakeIntensity = _originalShakeIntensity;
+			RemapIntensityZero = _originalRemapIntensityZero;
+			RemapIntensityOne = _originalRemapIntensityOne;
+			RelativeIntensity = _originalRelativeIntensity;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMChromaticAberrationShakeEvent_URP.Register(OnMMChromaticAberrationShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMChromaticAberrationShakeEvent_URP.Unregister(OnMMChromaticAberrationShakeEvent);
+		}
+		#endif
+	}
+
+	/// <summary>
+	/// An event used to trigger vignette shakes
+	/// </summary>
+	public struct MMChromaticAberrationShakeEvent_URP
+	{
+		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(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false);
+		
+		static public void Trigger(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			OnEvent?.Invoke(intensity, duration, remapMin, remapMax, relativeIntensity, attenuation, channelData, 
+				resetShakerValuesAfterShake, resetTargetValuesAfterShake, forwardDirection, timescaleMode, stop, restore);
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMChromaticAberrationShaker_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMColorAdjustmentsShaker_URP.cs

@@ -0,0 +1,361 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this class to a Camera with a URP color adjustments post processing and it'll be able to "shake" its values by getting events
+	/// </summary>
+	#if MM_URP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMColorAdjustmentsShaker_URP")]
+	public class MMColorAdjustmentsShaker_URP : MMShaker
+	{
+		/// whether or not to add to the initial value
+		public bool RelativeValues = true;
+
+		[MMInspectorGroup("Post Exposure", true, 43)]
+		/// the curve used to animate the focus distance value on
+		[Tooltip("the curve used to animate the focus distance value on")]
+		public AnimationCurve ShakePostExposure = 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 RemapPostExposureZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapPostExposureOne = 1f;
+
+		[MMInspectorGroup("Hue Shift", true, 44)]
+		/// the curve used to animate the aperture value on
+		[Tooltip("the curve used to animate the aperture value on")]
+		public AnimationCurve ShakeHueShift = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
+		/// the value to remap the curve's 0 to
+		[Range(-180f, 180f)]
+		[Tooltip("the value to remap the curve's 0 to")]
+		public float RemapHueShiftZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-180f, 180f)]
+		public float RemapHueShiftOne = 180f;
+
+		[MMInspectorGroup("Saturation", true, 45)]
+		/// the curve used to animate the focal length value on
+		[Tooltip("the curve used to animate the focal length value on")]
+		public AnimationCurve ShakeSaturation = 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(-100f, 100f)]
+		public float RemapSaturationZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-100f, 100f)]
+		public float RemapSaturationOne = 100f;
+
+		[MMInspectorGroup("Contrast", true, 47)]
+		/// the curve used to animate the focal length value on
+		[Tooltip("the curve used to animate the focal length value on")]
+		public AnimationCurve ShakeContrast = 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(-100f, 100f)]
+		public float RemapContrastZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-100f, 100f)]
+		public float RemapContrastOne = 100f;
+        
+		public enum ColorFilterModes { None, Gradient, Interpolate }
+ 
+		[MMInspectorGroup("Color Filter", true, 48)]
+		/// the color filter mode to work with (none, over a gradient, or interpolate to a destination color
+		[Tooltip("the color filter mode to work with (none, over a gradient, or interpolate to a destination color")]
+		public ColorFilterModes ColorFilterMode = ColorFilterModes.None;
+		/// the gradient over which to modify the color filter
+		[Tooltip("the gradient over which to modify the color filter")]
+		[MMFEnumCondition("ColorFilterMode", (int)ColorFilterModes.Gradient)]
+		[GradientUsage(true)]
+		public Gradient ColorFilterGradient;
+		/// the destination color to match when in Interpolate mode
+		[Tooltip("the destination color to match when in Interpolate mode")]
+		[MMFEnumCondition("ColorFilterMode", (int) ColorFilterModes.Interpolate)]
+		public Color ColorFilterDestination = Color.yellow;
+		/// the curve over which to interpolate the color filter
+		[Tooltip("the curve over which to interpolate the color filter")]
+		[MMFEnumCondition("ColorFilterMode", (int) ColorFilterModes.Interpolate)]
+		public AnimationCurve ColorFilterCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
+        
+		#if MM_URP
+		protected Volume _volume;
+		protected ColorAdjustments _colorAdjustments;
+		protected float _initialPostExposure;
+		protected float _initialHueShift;
+		protected float _initialSaturation;
+		protected float _initialContrast;
+		protected Color _initialColorFilterColor;
+		protected float _originalShakeDuration;
+		protected bool _originalRelativeValues;
+		protected AnimationCurve _originalShakePostExposure;
+		protected float _originalRemapPostExposureZero;
+		protected float _originalRemapPostExposureOne;
+		protected AnimationCurve _originalShakeHueShift;
+		protected float _originalRemapHueShiftZero;
+		protected float _originalRemapHueShiftOne;
+		protected AnimationCurve _originalShakeSaturation;
+		protected float _originalRemapSaturationZero;
+		protected float _originalRemapSaturationOne;
+		protected AnimationCurve _originalShakeContrast;
+		protected float _originalRemapContrastZero;
+		protected float _originalRemapContrastOne;
+		protected ColorFilterModes _originalColorFilterMode;
+		protected Gradient _originalColorFilterGradient;
+		protected Color _originalColorFilterDestination;
+		protected AnimationCurve _originalColorFilterCurve;  
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_volume = this.gameObject.GetComponent<Volume>();
+			_volume.profile.TryGet(out _colorAdjustments);
+		}
+
+		/// <summary>
+		/// When that shaker gets added, we initialize its shake duration
+		/// </summary>
+		protected virtual void Reset()
+		{
+			ShakeDuration = 0.8f;
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newPostExposure = ShakeFloat(ShakePostExposure, RemapPostExposureZero, RemapPostExposureOne, RelativeValues, _initialPostExposure);
+			_colorAdjustments.postExposure.Override(newPostExposure);
+			float newHueShift = ShakeFloat(ShakeHueShift, RemapHueShiftZero, RemapHueShiftOne, RelativeValues, _initialHueShift);
+			_colorAdjustments.hueShift.Override(newHueShift);
+			float newSaturation = ShakeFloat(ShakeSaturation, RemapSaturationZero, RemapSaturationOne, RelativeValues, _initialSaturation);
+			_colorAdjustments.saturation.Override(newSaturation);
+			float newContrast = ShakeFloat(ShakeContrast, RemapContrastZero, RemapContrastOne, RelativeValues, _initialContrast);
+			_colorAdjustments.contrast.Override(newContrast);
+
+			_remappedTimeSinceStart = MMFeedbacksHelpers.Remap(Time.time - _shakeStartedTimestamp, 0f, ShakeDuration, 0f, 1f);
+	            
+			if (ColorFilterMode == ColorFilterModes.Gradient)
+			{
+				_colorAdjustments.colorFilter.Override(ColorFilterGradient.Evaluate(_remappedTimeSinceStart));    
+			}
+			else if (ColorFilterMode == ColorFilterModes.Interpolate)
+			{
+				float factor = ColorFilterCurve.Evaluate(_remappedTimeSinceStart);
+				_colorAdjustments.colorFilter.Override(Color.LerpUnclamped(_initialColorFilterColor, ColorFilterDestination, factor));
+			}
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialPostExposure = _colorAdjustments.postExposure.value;
+			_initialHueShift = _colorAdjustments.hueShift.value;
+			_initialSaturation = _colorAdjustments.saturation.value;
+			_initialContrast = _colorAdjustments.contrast.value;
+			_initialColorFilterColor = _colorAdjustments.colorFilter.value;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="intensity"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeIntensity"></param>
+		/// <param name="attenuation"></param>
+		/// <param name="channel"></param>
+		public virtual void OnMMColorGradingShakeEvent(AnimationCurve shakePostExposure, float remapPostExposureZero, float remapPostExposureOne,
+			AnimationCurve shakeHueShift, float remapHueShiftZero, float remapHueShiftOne,
+			AnimationCurve shakeSaturation, float remapSaturationZero, float remapSaturationOne,
+			AnimationCurve shakeContrast, float remapContrastZero, float remapContrastOne,
+			ColorFilterModes colorFilterMode, Gradient colorFilterGradient, Color colorFilterDestination,AnimationCurve colorFilterCurve,  
+			float duration, bool relativeValues = false,
+			float attenuation = 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) || (!Interruptible && Shaking))
+			{
+				return;
+			}
+	            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalRelativeValues = RelativeValues;
+				_originalShakePostExposure = ShakePostExposure;
+				_originalRemapPostExposureZero = RemapPostExposureZero;
+				_originalRemapPostExposureOne = RemapPostExposureOne;
+				_originalShakeHueShift = ShakeHueShift;
+				_originalRemapHueShiftZero = RemapHueShiftZero;
+				_originalRemapHueShiftOne = RemapHueShiftOne;
+				_originalShakeSaturation = ShakeSaturation;
+				_originalRemapSaturationZero = RemapSaturationZero;
+				_originalRemapSaturationOne = RemapSaturationOne;
+				_originalShakeContrast = ShakeContrast;
+				_originalRemapContrastZero = RemapContrastZero;
+				_originalRemapContrastOne = RemapContrastOne;
+				_originalColorFilterMode = ColorFilterMode;
+				_originalColorFilterGradient = ColorFilterGradient;
+				_originalColorFilterDestination = ColorFilterDestination;
+				_originalColorFilterCurve = ColorFilterCurve;
+			}
+
+			if (!OnlyUseShakerValues)
+			{
+				TimescaleMode = timescaleMode;
+				ShakeDuration = duration;
+				RelativeValues = relativeValues;
+				ShakePostExposure = shakePostExposure;
+				RemapPostExposureZero = remapPostExposureZero;
+				RemapPostExposureOne = remapPostExposureOne;
+				ShakeHueShift = shakeHueShift;
+				RemapHueShiftZero = remapHueShiftZero;
+				RemapHueShiftOne = remapHueShiftOne;
+				ShakeSaturation = shakeSaturation;
+				RemapSaturationZero = remapSaturationZero;
+				RemapSaturationOne = remapSaturationOne;
+				ShakeContrast = shakeContrast;
+				RemapContrastZero = remapContrastZero;
+				RemapContrastOne = remapContrastOne;
+				ColorFilterMode = colorFilterMode;
+				ColorFilterGradient = colorFilterGradient;
+				ColorFilterDestination = colorFilterDestination;
+				ColorFilterCurve = colorFilterCurve;
+				ForwardDirection = forwardDirection;
+			}
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_colorAdjustments.postExposure.Override(_initialPostExposure);
+			_colorAdjustments.hueShift.Override(_initialHueShift);
+			_colorAdjustments.saturation.Override(_initialSaturation);
+			_colorAdjustments.contrast.Override(_initialContrast);
+			_colorAdjustments.colorFilter.Override(_initialColorFilterColor);
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			RelativeValues = _originalRelativeValues;
+			ShakePostExposure = _originalShakePostExposure;
+			RemapPostExposureZero = _originalRemapPostExposureZero;
+			RemapPostExposureOne = _originalRemapPostExposureOne;
+			ShakeHueShift = _originalShakeHueShift;
+			RemapHueShiftZero = _originalRemapHueShiftZero;
+			RemapHueShiftOne = _originalRemapHueShiftOne;
+			ShakeSaturation = _originalShakeSaturation;
+			RemapSaturationZero = _originalRemapSaturationZero;
+			RemapSaturationOne = _originalRemapSaturationOne;
+			ShakeContrast = _originalShakeContrast;
+			RemapContrastZero = _originalRemapContrastZero;
+			RemapContrastOne = _originalRemapContrastOne;
+			ColorFilterMode = _originalColorFilterMode;
+			ColorFilterGradient = _originalColorFilterGradient;
+			ColorFilterDestination = _originalColorFilterDestination;
+			ColorFilterCurve = _originalColorFilterCurve;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMColorAdjustmentsShakeEvent_URP.Register(OnMMColorGradingShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMColorAdjustmentsShakeEvent_URP.Unregister(OnMMColorGradingShakeEvent);
+		}
+		#endif
+	}
+
+	/// <summary>
+	/// An event used to trigger vignette shakes
+	/// </summary>
+	public struct MMColorAdjustmentsShakeEvent_URP
+	{
+		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(AnimationCurve shakePostExposure, float remapPostExposureZero, float remapPostExposureOne,
+			AnimationCurve shakeHueShift, float remapHueShiftZero, float remapHueShiftOne,
+			AnimationCurve shakeSaturation, float remapSaturationZero, float remapSaturationOne,
+			AnimationCurve shakeContrast, float remapContrastZero, float remapContrastOne,
+			MMColorAdjustmentsShaker_URP.ColorFilterModes colorFilterMode, Gradient colorFilterGradient, Color colorFilterDestination,AnimationCurve colorFilterCurve,  
+			float duration, bool relativeValues = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false);
+
+		static public void Trigger(AnimationCurve shakePostExposure, float remapPostExposureZero, float remapPostExposureOne,
+			AnimationCurve shakeHueShift, float remapHueShiftZero, float remapHueShiftOne,
+			AnimationCurve shakeSaturation, float remapSaturationZero, float remapSaturationOne,
+			AnimationCurve shakeContrast, float remapContrastZero, float remapContrastOne,
+			MMColorAdjustmentsShaker_URP.ColorFilterModes colorFilterMode, Gradient colorFilterGradient, Color colorFilterDestination,AnimationCurve colorFilterCurve,  
+			float duration, bool relativeValues = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			OnEvent?.Invoke(shakePostExposure, remapPostExposureZero, remapPostExposureOne,
+				shakeHueShift, remapHueShiftZero, remapHueShiftOne,
+				shakeSaturation, remapSaturationZero, remapSaturationOne,
+				shakeContrast, remapContrastZero, remapContrastOne,
+				colorFilterMode, colorFilterGradient, colorFilterDestination, colorFilterCurve,
+				duration, relativeValues, attenuation, channelData, resetShakerValuesAfterShake, resetTargetValuesAfterShake, forwardDirection, timescaleMode, stop, restore);
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMColorAdjustmentsShaker_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMDepthOfFieldShaker_URP.cs

@@ -0,0 +1,272 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this class to a Camera with a URP depth of field post processing and it'll be able to "shake" its values by getting events
+	/// </summary>
+	#if MM_URP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMDepthOfFieldShaker_URP")]
+	public class MMDepthOfFieldShaker_URP : MMShaker
+	{
+		/// whether or not to add to the initial value
+		public bool RelativeValues = true;
+
+		[MMInspectorGroup("Focus Distance", true, 51)]
+		/// the curve used to animate the focus distance value on
+		[Tooltip("the curve used to animate the focus distance value on")]
+		public AnimationCurve ShakeFocusDistance = 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 RemapFocusDistanceZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapFocusDistanceOne = 3f;
+
+		[MMInspectorGroup("Aperture", true, 52)]
+		/// the curve used to animate the aperture value on
+		[Tooltip("the curve used to animate the aperture value on")]
+		public AnimationCurve ShakeAperture = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
+		/// the value to remap the curve's 0 to
+		[Range(0.1f, 32f)]
+		[Tooltip("the value to remap the curve's 0 to")]
+		public float RemapApertureZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Range(0.1f, 32f)]
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapApertureOne = 0f;
+
+		[MMInspectorGroup("Focal Length", true, 53)]
+		/// the curve used to animate the focal length value on
+		[Tooltip("the curve used to animate the focal length value on")]
+		public AnimationCurve ShakeFocalLength = 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, 300f)]
+		public float RemapFocalLengthZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(0f, 300f)]
+		public float RemapFocalLengthOne = 0f;
+
+		#if MM_URP
+		protected Volume _volume;
+		protected DepthOfField _depthOfField;
+		protected float _initialFocusDistance;
+		protected float _initialAperture;
+		protected float _initialFocalLength;
+		protected float _originalShakeDuration;
+		protected bool _originalRelativeValues;
+		protected AnimationCurve _originalShakeFocusDistance;
+		protected float _originalRemapFocusDistanceZero;
+		protected float _originalRemapFocusDistanceOne;
+		protected AnimationCurve _originalShakeAperture;
+		protected float _originalRemapApertureZero;
+		protected float _originalRemapApertureOne;
+		protected AnimationCurve _originalShakeFocalLength;
+		protected float _originalRemapFocalLengthZero;
+		protected float _originalRemapFocalLengthOne;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_volume = this.gameObject.GetComponent<Volume>();
+			_volume.profile.TryGet(out _depthOfField);
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newFocusDistance = ShakeFloat(ShakeFocusDistance, RemapFocusDistanceZero, RemapFocusDistanceOne, RelativeValues, _initialFocusDistance);
+			_depthOfField.focusDistance.Override(newFocusDistance);
+			float newAperture = ShakeFloat(ShakeAperture, RemapApertureZero, RemapApertureOne, RelativeValues, _initialAperture);
+			_depthOfField.aperture.Override(newAperture);
+			float newFocalLength = ShakeFloat(ShakeFocalLength, RemapFocalLengthZero, RemapFocalLengthOne, RelativeValues, _initialFocalLength);
+			_depthOfField.focalLength.Override(newFocalLength);
+		}
+
+		/// <summary>
+		/// When that shaker gets added, we initialize its shake duration
+		/// </summary>
+		protected virtual void Reset()
+		{
+			ShakeDuration = 2f;
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialFocusDistance = _depthOfField.focusDistance.value;
+			_initialAperture = _depthOfField.aperture.value;
+			_initialFocalLength = _depthOfField.focalLength.value;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="intensity"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeIntensity"></param>
+		/// <param name="attenuation"></param>
+		/// <param name="channel"></param>
+		public virtual void OnDepthOfFieldShakeEvent(AnimationCurve focusDistance, float duration, float remapFocusDistanceMin, float remapFocusDistanceMax,
+			AnimationCurve aperture, float remapApertureMin, float remapApertureMax,
+			AnimationCurve focalLength, float remapFocalLengthMin, float remapFocalLengthMax,
+			bool relativeValues = false,
+			float attenuation = 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) || (!Interruptible && Shaking))
+			{
+				return;
+			}
+	            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalRelativeValues = RelativeValues;
+				_originalShakeFocusDistance = ShakeFocusDistance;
+				_originalRemapFocusDistanceZero = RemapFocusDistanceZero;
+				_originalRemapFocusDistanceOne = RemapFocusDistanceOne;
+				_originalShakeAperture = ShakeAperture;
+				_originalRemapApertureZero = RemapApertureZero;
+				_originalRemapApertureOne = RemapApertureOne;
+				_originalShakeFocalLength = ShakeFocalLength;
+				_originalRemapFocalLengthZero = RemapFocalLengthZero;
+				_originalRemapFocalLengthOne = RemapFocalLengthOne;
+			}
+
+			if (!OnlyUseShakerValues)
+			{
+				TimescaleMode = timescaleMode;
+				ShakeDuration = duration;
+				RelativeValues = relativeValues;
+				ShakeFocusDistance = focusDistance;
+				RemapFocusDistanceZero = remapFocusDistanceMin;
+				RemapFocusDistanceOne = remapFocusDistanceMax;
+				ShakeAperture = aperture;
+				RemapApertureZero = remapApertureMin;
+				RemapApertureOne = remapApertureMax;
+				ShakeFocalLength = focalLength;
+				RemapFocalLengthZero = remapFocalLengthMin;
+				RemapFocalLengthOne = remapFocalLengthMax;
+				ForwardDirection = forwardDirection;
+			}
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_depthOfField.focusDistance.Override(_initialFocusDistance);
+			_depthOfField.aperture.Override(_initialAperture);
+			_depthOfField.focalLength.Override(_initialFocalLength);
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			RelativeValues = _originalRelativeValues;
+			ShakeFocusDistance = _originalShakeFocusDistance;
+			RemapFocusDistanceZero = _originalRemapFocusDistanceZero;
+			RemapFocusDistanceOne = _originalRemapFocusDistanceOne;
+			ShakeAperture = _originalShakeAperture;
+			RemapApertureZero = _originalRemapApertureZero;
+			RemapApertureOne = _originalRemapApertureOne;
+			ShakeFocalLength = _originalShakeFocalLength;
+			RemapFocalLengthZero = _originalRemapFocalLengthZero;
+			RemapFocalLengthOne = _originalRemapFocalLengthOne;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMDepthOfFieldShakeEvent_URP.Register(OnDepthOfFieldShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMDepthOfFieldShakeEvent_URP.Unregister(OnDepthOfFieldShakeEvent);
+		}
+		#endif
+	}
+
+	/// <summary>
+	/// An event used to trigger vignette shakes
+	/// </summary>
+	public struct MMDepthOfFieldShakeEvent_URP
+	{
+		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(AnimationCurve focusDistance, float duration, float remapFocusDistanceMin, float remapFocusDistanceMax,
+			AnimationCurve aperture, float remapApertureMin, float remapApertureMax,
+			AnimationCurve focalLength, float remapFocalLengthMin, float remapFocalLengthMax,
+			bool relativeValues = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false);
+
+		static public void Trigger(AnimationCurve focusDistance, float duration, float remapFocusDistanceMin, float remapFocusDistanceMax,
+			AnimationCurve aperture, float remapApertureMin, float remapApertureMax,
+			AnimationCurve focalLength, float remapFocalLengthMin, float remapFocalLengthMax,
+			bool relativeValues = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			OnEvent?.Invoke(focusDistance, duration, remapFocusDistanceMin, remapFocusDistanceMax,
+				aperture, remapApertureMin, remapApertureMax,
+				focalLength, remapFocalLengthMin, remapFocalLengthMax, relativeValues,
+				attenuation, channelData, resetShakerValuesAfterShake, resetTargetValuesAfterShake, forwardDirection, timescaleMode, stop, restore);
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMDepthOfFieldShaker_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMFilmGrainShaker_URP.cs

@@ -0,0 +1,195 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this class to a Camera with a URP FilmGrain post processing and it'll be able to "shake" its values by getting events
+	/// </summary>
+	#if MM_URP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMFilmGrainShaker_URP")]
+	public class MMFilmGrainShaker_URP : MMShaker
+	{
+		[MMInspectorGroup("Film Grain Intensity", true, 51)]
+		/// whether or not to add to the initial value
+		[Tooltip("whether or not to add to the initial value")]
+		public bool RelativeIntensity = false;
+		/// the curve used to animate the intensity value on
+		[Tooltip("the curve used to animate the intensity value on")]
+		public AnimationCurve ShakeIntensity = 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, 1f)]
+		public float RemapIntensityZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(0f, 1f)]
+		public float RemapIntensityOne = 1f;
+
+		#if MM_URP
+		protected Volume _volume;
+		protected FilmGrain _filmGrain;
+		protected float _initialIntensity;
+		protected float _originalShakeDuration;
+		protected AnimationCurve _originalShakeIntensity;
+		protected float _originalRemapIntensityZero;
+		protected float _originalRemapIntensityOne;
+		protected bool _originalRelativeIntensity;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_volume = this.gameObject.GetComponent<Volume>();
+			_volume.profile.TryGet(out _filmGrain);
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newValue = ShakeFloat(ShakeIntensity, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, _initialIntensity);
+			_filmGrain.intensity.Override(newValue);
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialIntensity = _filmGrain.intensity.value;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="intensity"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeIntensity"></param>
+		/// <param name="attenuation"></param>
+		/// <param name="channel"></param>
+		public virtual void OnFilmGrainShakeEvent(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 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) || (!Interruptible && Shaking))
+			{
+				return;
+			}
+	            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+	            
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalShakeIntensity = ShakeIntensity;
+				_originalRemapIntensityZero = RemapIntensityZero;
+				_originalRemapIntensityOne = RemapIntensityOne;
+				_originalRelativeIntensity = RelativeIntensity;
+			}
+
+			if (!OnlyUseShakerValues)
+			{
+				TimescaleMode = timescaleMode;
+				ShakeDuration = duration;
+				ShakeIntensity = intensity;
+				RemapIntensityZero = remapMin * attenuation;
+				RemapIntensityOne = remapMax * attenuation;
+				RelativeIntensity = relativeIntensity;
+				ForwardDirection = forwardDirection;
+			}
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_filmGrain.intensity.Override(_initialIntensity);
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			ShakeIntensity = _originalShakeIntensity;
+			RemapIntensityZero = _originalRemapIntensityZero;
+			RemapIntensityOne = _originalRemapIntensityOne;
+			RelativeIntensity = _originalRelativeIntensity;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMFilmGrainShakeEvent_URP.Register(OnFilmGrainShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMFilmGrainShakeEvent_URP.Unregister(OnFilmGrainShakeEvent);
+		}
+		#endif
+	}
+
+	/// <summary>
+	/// An event used to trigger FilmGrain shakes
+	/// </summary>
+	public struct MMFilmGrainShakeEvent_URP
+	{
+		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(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false);
+		
+		static public void Trigger(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			OnEvent?.Invoke(intensity, duration, remapMin, remapMax, relativeIntensity, attenuation, channelData, 
+				resetShakerValuesAfterShake, resetTargetValuesAfterShake, forwardDirection, timescaleMode, stop, restore);
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMFilmGrainShaker_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMLensDistortionShaker_URP.cs

@@ -0,0 +1,212 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this class to a Camera with a URP lens distortion post processing and it'll be able to "shake" its values by getting events
+	/// </summary>
+	#if MM_URP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMLensDistortionShaker_URP")]
+	public class MMLensDistortionShaker_URP : MMShaker
+	{
+		[MMInspectorGroup("Lens Distortion Intensity", true, 51)]
+		/// whether or not to add to the initial value
+		[Tooltip("whether or not to add to the initial value")]
+		public bool RelativeIntensity = false;
+		/// the curve used to animate the intensity value on
+		[Tooltip("the curve used to animate the intensity value on")]
+		public AnimationCurve ShakeIntensity = new AnimationCurve(new Keyframe(0, 0),
+			new Keyframe(0.2f, 1),
+			new Keyframe(0.25f, -1),
+			new Keyframe(0.35f, 0.7f),
+			new Keyframe(0.4f, -0.7f),
+			new Keyframe(0.6f, 0.3f),
+			new Keyframe(0.65f, -0.3f),
+			new Keyframe(0.8f, 0.1f),
+			new Keyframe(0.85f, -0.1f),
+			new Keyframe(1, 0));
+		/// the value to remap the curve's 0 to
+		[Tooltip("the value to remap the curve's 0 to")]
+		[Range(-100f, 100f)]
+		public float RemapIntensityZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-100f, 100f)]
+		public float RemapIntensityOne = 0.5f;
+
+		#if MM_URP
+		protected Volume _volume;
+		protected LensDistortion _lensDistortion;
+		protected float _initialIntensity;
+		protected float _originalShakeDuration;
+		protected AnimationCurve _originalShakeIntensity;
+		protected float _originalRemapIntensityZero;
+		protected float _originalRemapIntensityOne;
+		protected bool _originalRelativeIntensity;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_volume = this.gameObject.GetComponent<Volume>();
+			_volume.profile.TryGet(out _lensDistortion);
+		}
+
+		/// <summary>
+		/// When that shaker gets added, we initialize its shake duration
+		/// </summary>
+		protected virtual void Reset()
+		{
+			ShakeDuration = 0.8f;
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newValue = ShakeFloat(ShakeIntensity, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, _initialIntensity);
+			_lensDistortion.intensity.Override(newValue);
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialIntensity = _lensDistortion.intensity.value;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="intensity"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeIntensity"></param>
+		/// <param name="attenuation"></param>
+		/// <param name="channel"></param>
+		public virtual void OnMMLensDistortionShakeEvent(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 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) || (!Interruptible && Shaking))
+			{
+				return;
+			}
+	            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+	            
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalShakeIntensity = ShakeIntensity;
+				_originalRemapIntensityZero = RemapIntensityZero;
+				_originalRemapIntensityOne = RemapIntensityOne;
+				_originalRelativeIntensity = RelativeIntensity;
+			}
+
+			if (!OnlyUseShakerValues)
+			{
+				TimescaleMode = timescaleMode;
+				ShakeDuration = duration;
+				ShakeIntensity = intensity;
+				RemapIntensityZero = remapMin * attenuation;
+				RemapIntensityOne = remapMax * attenuation;
+				RelativeIntensity = relativeIntensity;
+				ForwardDirection = forwardDirection;
+			}
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_lensDistortion.intensity.Override(_initialIntensity);
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			ShakeIntensity = _originalShakeIntensity;
+			RemapIntensityZero = _originalRemapIntensityZero;
+			RemapIntensityOne = _originalRemapIntensityOne;
+			RelativeIntensity = _originalRelativeIntensity;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMLensDistortionShakeEvent_URP.Register(OnMMLensDistortionShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMLensDistortionShakeEvent_URP.Unregister(OnMMLensDistortionShakeEvent);
+		}
+		#endif
+	}
+
+	/// <summary>
+	/// An event used to trigger vignette shakes
+	/// </summary>
+	public struct MMLensDistortionShakeEvent_URP
+	{
+		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(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false);
+		
+		static public void Trigger(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			OnEvent?.Invoke(intensity, duration, remapMin, remapMax, relativeIntensity, attenuation, channelData, 
+				resetShakerValuesAfterShake, resetTargetValuesAfterShake, forwardDirection, timescaleMode, stop, restore);
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMLensDistortionShaker_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMLight2DShaker_URP.cs

@@ -0,0 +1,273 @@
+using MoreMountains.Tools;
+using UnityEngine;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace MoreMountains.Feedbacks
+{
+	/// <summary>
+	/// Add this to a light 2D to have it receive MMLightShakeEvents from feedbacks or to shake it locally
+	/// </summary>
+	#if MM_URP
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/Lights/MMLight2DShaker_URP")]
+	[RequireComponent(typeof(Light2D))]
+	#endif
+	public class MMLight2DShaker_URP : MMShaker
+	{
+		#if MM_URP
+		[MMInspectorGroup("Light", true, 37)]
+		/// the light to affect when playing the feedback
+		[Tooltip("the light to affect when playing the feedback")]
+		public Light2D BoundLight;
+		/// whether or not that light should be turned off on start
+		[Tooltip("whether or not that light should be turned off on start")]
+		public bool StartsOff = true;
+		/// whether or not the values should be relative or not
+		[Tooltip("whether or not the values should be relative or not")]
+		public bool RelativeValues = true;
+
+		[MMInspectorGroup("Color", true, 41)]
+		/// whether or not this shaker should modify color 
+		[Tooltip("whether or not this shaker should modify color")]
+		public bool ModifyColor = true;
+		/// the colors to apply to the light over time
+		[Tooltip("the colors to apply to the light over time")]
+		public Gradient ColorOverTime;
+
+		[MMInspectorGroup("Intensity", true, 40)]
+		/// the intensity to apply to the light over time
+		/// the curve to tween the intensity on
+		[Tooltip("the intensity to apply to the light over time")]
+		public AnimationCurve IntensityCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.3f, 1f), new Keyframe(1, 0));
+		/// the value to remap the intensity curve's 0 to
+		[Tooltip("the value to remap the intensity curve's 0 to")]
+		public float RemapIntensityZero = 0f;
+		/// the value to remap the intensity curve's 1 to
+		[Tooltip("the value to remap the intensity curve's 1 to")]
+		public float RemapIntensityOne = 1f;
+
+		[MMInspectorGroup("Range", true, 39)]
+		/// the range to apply to the light over time
+		[Tooltip("the range to apply to the light over time")]
+		public AnimationCurve FalloffCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.3f, 1f), new Keyframe(1, 0));
+		/// the value to remap the range curve's 0 to
+		[Tooltip("the value to remap the range curve's 0 to")]
+		public float FalloffRangeZero = 0f;
+		/// the value to remap the range curve's 0 to
+		[Tooltip("the value to remap the range curve's 0 to")]
+		public float RemapFalloffOne = 10f;
+
+		[MMInspectorGroup("Shadow Strength", true, 38)]
+		/// the range to apply to the light over time
+		[Tooltip("the range to apply to the light over time")]
+		public AnimationCurve ShadowStrengthCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.3f, 1f), new Keyframe(1, 0));
+		/// the value to remap the shadow strength's curve's 0 to
+		[Tooltip("the value to remap the shadow strength's curve's 0 to")]
+		public float RemapShadowStrengthZero = 0f;
+		/// the value to remap the shadow strength's curve's 1 to
+		[Tooltip("the value to remap the shadow strength's curve's 1 to")]
+		public float RemapShadowStrengthOne = 1f;
+
+		protected Color _initialColor;
+		protected float _initialRange;
+		protected float _initialIntensity;
+		protected float _initialShadowStrength;
+
+		protected bool _originalRelativeValues;
+		protected bool _originalModifyColor;
+		protected float _originalShakeDuration;
+		protected Gradient _originalColorOverTime;
+		protected AnimationCurve _originalIntensityCurve;
+		protected float _originalRemapIntensityZero;
+		protected float _originalRemapIntensityOne;
+		protected AnimationCurve _originalRangeCurve;
+		protected float _originalRemapRangeZero;
+		protected float _originalRemapRangeOne;
+		protected AnimationCurve _originalShadowStrengthCurve;
+		protected float _originalRemapShadowStrengthZero;
+		protected float _originalRemapShadowStrengthOne;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			if (BoundLight == null)
+			{
+				BoundLight = this.gameObject.GetComponent<Light2D>();
+			}
+		}
+
+		/// <summary>
+		/// When that shaker gets added, we initialize its shake duration
+		/// </summary>
+		protected virtual void Reset()
+		{
+			ShakeDuration = 1f;
+		}
+               
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newRange = ShakeFloat(FalloffCurve, FalloffRangeZero, RemapFalloffOne, RelativeValues, _initialRange);
+			BoundLight.shapeLightFalloffSize = newRange;
+			float newIntensity = ShakeFloat(IntensityCurve, RemapIntensityZero, RemapIntensityOne, RelativeValues, _initialIntensity);
+			BoundLight.intensity = newIntensity;
+			float newShadowStrength = ShakeFloat(ShadowStrengthCurve, RemapShadowStrengthZero, RemapShadowStrengthOne, RelativeValues, _initialShadowStrength);
+			BoundLight.shadowIntensity = Mathf.Clamp01(newShadowStrength);
+			if (ModifyColor)
+			{
+				BoundLight.color = ColorOverTime.Evaluate(_remappedTimeSinceStart);
+			}            
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialColor = BoundLight.color;
+			_initialRange = BoundLight.shapeLightFalloffSize;
+			_initialIntensity = BoundLight.intensity;
+			_initialShadowStrength = BoundLight.shadowIntensity;
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			BoundLight.color = _initialColor;
+			BoundLight.shapeLightFalloffSize = _initialRange;
+			BoundLight.intensity = _initialIntensity;
+			BoundLight.shadowIntensity = _initialShadowStrength;
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ModifyColor = _originalModifyColor;
+			RelativeValues = _originalRelativeValues;
+			ShakeDuration = _originalShakeDuration;
+			ColorOverTime = _originalColorOverTime;
+			IntensityCurve = _originalIntensityCurve;
+			RemapIntensityZero = _originalRemapIntensityZero;
+			RemapIntensityOne = _originalRemapIntensityOne;
+			FalloffCurve = _originalRangeCurve;
+			FalloffRangeZero  =_originalRemapRangeZero;
+			RemapFalloffOne = _originalRemapRangeOne;
+			ShadowStrengthCurve = _originalShadowStrengthCurve;
+			RemapShadowStrengthZero = _originalRemapShadowStrengthZero;
+			RemapShadowStrengthOne = _originalRemapShadowStrengthOne;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMLight2DShakeEvent.Register(OnMMLight2DShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMLight2DShakeEvent.Unregister(OnMMLight2DShakeEvent);
+		}
+
+		public virtual void OnMMLight2DShakeEvent(float shakeDuration, bool relativeValues, bool modifyColor, Gradient colorOverTime,
+			AnimationCurve intensityCurve, float remapIntensityZero, float remapIntensityOne,
+			AnimationCurve rangeCurve, float remapRangeZero, float remapRangeOne,
+			AnimationCurve shadowStrengthCurve, float remapShadowStrengthZero, float remapShadowStrengthOne,
+			float feedbacksIntensity = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true,
+			bool useRange = false, float eventRange = 0f, Vector3 eventOriginPosition = default(Vector3))
+		{
+			if (!CheckEventAllowed(channelData, useRange, eventRange, eventOriginPosition) || (!Interruptible && Shaking))
+			{
+				return;
+			}
+
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalModifyColor = ModifyColor;
+				_originalRelativeValues = RelativeValues;
+				_originalShakeDuration = ShakeDuration;
+				_originalColorOverTime = ColorOverTime;
+				_originalIntensityCurve = IntensityCurve;
+				_originalRemapIntensityZero = RemapIntensityZero;
+				_originalRemapIntensityOne = RemapIntensityOne;
+				_originalRangeCurve = FalloffCurve;
+				_originalRemapRangeZero = FalloffRangeZero;
+				_originalRemapRangeOne = RemapFalloffOne;
+				_originalShadowStrengthCurve = ShadowStrengthCurve;
+				_originalRemapShadowStrengthZero = RemapShadowStrengthZero;
+				_originalRemapShadowStrengthOne = RemapShadowStrengthOne;
+			}
+
+			if (!OnlyUseShakerValues)
+			{
+				ModifyColor = modifyColor;
+				RelativeValues = relativeValues;
+				ShakeDuration = shakeDuration;
+				ColorOverTime = colorOverTime;
+				IntensityCurve = intensityCurve;
+				RemapIntensityZero = remapIntensityZero;
+				RemapIntensityOne = remapIntensityOne;
+				FalloffCurve = rangeCurve;
+				FalloffRangeZero = remapRangeZero;
+				RemapFalloffOne = remapRangeOne;
+				ShadowStrengthCurve = shadowStrengthCurve;
+				RemapShadowStrengthZero = remapShadowStrengthZero;
+				RemapShadowStrengthOne = remapShadowStrengthOne;
+			}
+
+			Play();
+		}
+	}
+           
+	public struct MMLight2DShakeEvent
+	{
+		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(float shakeDuration, bool relativeValues, bool modifyColor, Gradient colorOverTime, 
+			AnimationCurve intensityCurve, float remapIntensityZero, float remapIntensityOne,
+			AnimationCurve rangeCurve, float remapRangeZero, float remapRangeOne, 
+			AnimationCurve shadowStrengthCurve, float remapShadowStrengthZero, float remapShadowStrengthOne,
+			float feedbacksIntensity = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true,
+			bool useRange = false, float eventRange = 0f, Vector3 eventOriginPosition = default(Vector3));
+
+		static public void Trigger(float shakeDuration, bool relativeValues, bool modifyColor, Gradient colorOverTime,
+			AnimationCurve intensityCurve, float remapIntensityZero, float remapIntensityOne,
+			AnimationCurve rangeCurve, float remapRangeZero, float remapRangeOne,
+			AnimationCurve shadowStrengthCurve, float remapShadowStrengthZero, float remapShadowStrengthOne,
+			float feedbacksIntensity = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true,
+			bool useRange = false, float eventRange = 0f, Vector3 eventOriginPosition = default(Vector3))
+		{
+			OnEvent?.Invoke(shakeDuration, relativeValues, modifyColor, colorOverTime,
+				intensityCurve, remapIntensityZero, remapIntensityOne,
+				rangeCurve, remapRangeZero, remapRangeOne,
+				shadowStrengthCurve, remapShadowStrengthZero, remapShadowStrengthOne, 
+				feedbacksIntensity, channelData, resetShakerValuesAfterShake, resetTargetValuesAfterShake, 
+				useRange, eventRange, eventOriginPosition);
+		}
+		#endif
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMLight2DShaker_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMMotionBlurShaker_URP.cs

@@ -0,0 +1,195 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this class to a Camera with a URP vignette post processing and it'll be able to "shake" its values by getting events
+	/// </summary>
+	#if MM_URP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMMotionBlurShaker_URP")]
+	public class MMMotionBlurShaker_URP : MMShaker
+	{
+		[MMInspectorGroup("Motion Blur Intensity", true, 61)]
+		/// whether or not to add to the initial value
+		[Tooltip("whether or not to add to the initial value")]
+		public bool RelativeIntensity = false;
+		/// the curve used to animate the intensity value on
+		[Tooltip("the curve used to animate the intensity value on")]
+		public AnimationCurve ShakeIntensity = 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, 1f)]
+		public float RemapIntensityZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(0f, 1f)]
+		public float RemapIntensityOne = 1f;
+		
+		#if MM_URP
+		protected Volume _volume;
+		protected MotionBlur _motionBlur;
+		protected float _initialIntensity;
+		protected float _originalShakeDuration;
+		protected AnimationCurve _originalShakeIntensity;
+		protected float _originalRemapIntensityZero;
+		protected float _originalRemapIntensityOne;
+		protected bool _originalRelativeIntensity;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_volume = this.gameObject.GetComponent<Volume>();
+			_volume.profile.TryGet(out _motionBlur);
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newValue = ShakeFloat(ShakeIntensity, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, _initialIntensity);
+			_motionBlur.intensity.Override(newValue);
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialIntensity = _motionBlur.intensity.value;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="intensity"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeIntensity"></param>
+		/// <param name="attenuation"></param>
+		/// <param name="channel"></param>
+		public virtual void OnMotionBlurShakeEvent(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 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) || (!Interruptible && Shaking))
+			{
+				return;
+			}
+	            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+	            
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalShakeIntensity = ShakeIntensity;
+				_originalRemapIntensityZero = RemapIntensityZero;
+				_originalRemapIntensityOne = RemapIntensityOne;
+				_originalRelativeIntensity = RelativeIntensity;
+			}
+
+			if (!OnlyUseShakerValues)
+			{
+				TimescaleMode = timescaleMode;
+				ShakeDuration = duration;
+				ShakeIntensity = intensity;
+				RemapIntensityZero = remapMin * attenuation;
+				RemapIntensityOne = remapMax * attenuation;
+				RelativeIntensity = relativeIntensity;
+				ForwardDirection = forwardDirection;
+			}
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_motionBlur.intensity.Override(_initialIntensity);
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			ShakeIntensity = _originalShakeIntensity;
+			RemapIntensityZero = _originalRemapIntensityZero;
+			RemapIntensityOne = _originalRemapIntensityOne;
+			RelativeIntensity = _originalRelativeIntensity;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMMotionBlurShakeEvent_URP.Register(OnMotionBlurShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMMotionBlurShakeEvent_URP.Unregister(OnMotionBlurShakeEvent);
+		}
+		#endif
+	}
+
+	/// <summary>
+	/// An event used to trigger vignette shakes
+	/// </summary>
+	public struct MMMotionBlurShakeEvent_URP
+	{
+		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(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false);
+		
+		static public void Trigger(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			OnEvent?.Invoke(intensity, duration, remapMin, remapMax, relativeIntensity, attenuation, channelData, 
+				resetShakerValuesAfterShake, resetTargetValuesAfterShake, forwardDirection, timescaleMode, stop, restore);
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMMotionBlurShaker_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMPaniniProjectionShaker_URP.cs

@@ -0,0 +1,195 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this class to a Camera with a URP vignette post processing and it'll be able to "shake" its values by getting events
+	/// </summary>
+	#if MM_URP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMPaniniProjectionShaker_URP")]
+	public class MMPaniniProjectionShaker_URP : MMShaker
+	{
+		[MMInspectorGroup("Distance", true, 62)]
+		/// whether or not to add to the initial value
+		[Tooltip("whether or not to add to the initial value")]
+		public bool RelativeDistance = false;
+		/// the curve used to animate the distance value on
+		[Tooltip("the curve used to animate the distance value on")]
+		public AnimationCurve ShakeDistance = 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, 1f)]
+		public float RemapDistanceZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(0f, 1f)]
+		public float RemapDistanceOne = 1f;
+
+		#if MM_URP
+		protected Volume _volume;
+		protected PaniniProjection _paniniProjection;
+		protected float _initialDistance;
+		protected float _originalShakeDuration;
+		protected AnimationCurve _originalShakeDistance;
+		protected float _originalRemapDistanceZero;
+		protected float _originalRemapDistanceOne;
+		protected bool _originalRelativeDistance;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_volume = this.gameObject.GetComponent<Volume>();
+			_volume.profile.TryGet(out _paniniProjection);
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newValue = ShakeFloat(ShakeDistance, RemapDistanceZero, RemapDistanceOne, RelativeDistance, _initialDistance);
+			_paniniProjection.distance.Override(newValue);
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialDistance = _paniniProjection.distance.value;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="distance"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeDistance"></param>
+		/// <param name="attenuation"></param>
+		/// <param name="channel"></param>
+		public virtual void OnPaniniProjectionShakeEvent(AnimationCurve distance, float duration, float remapMin, float remapMax, bool relativeDistance = false,
+			float attenuation = 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) || (!Interruptible && Shaking))
+			{
+				return;
+			}
+	            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+	            
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalShakeDistance = ShakeDistance;
+				_originalRemapDistanceZero = RemapDistanceZero;
+				_originalRemapDistanceOne = RemapDistanceOne;
+				_originalRelativeDistance = RelativeDistance;
+			}
+
+			if (!OnlyUseShakerValues)
+			{
+				TimescaleMode = timescaleMode;
+				ShakeDuration = duration;
+				ShakeDistance = distance;
+				RemapDistanceZero = remapMin * attenuation;
+				RemapDistanceOne = remapMax * attenuation;
+				RelativeDistance = relativeDistance;
+				ForwardDirection = forwardDirection;
+			}
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_paniniProjection.distance.Override(_initialDistance);
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			ShakeDistance = _originalShakeDistance;
+			RemapDistanceZero = _originalRemapDistanceZero;
+			RemapDistanceOne = _originalRemapDistanceOne;
+			RelativeDistance = _originalRelativeDistance;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMPaniniProjectionShakeEvent_URP.Register(OnPaniniProjectionShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMPaniniProjectionShakeEvent_URP.Unregister(OnPaniniProjectionShakeEvent);
+		}
+		#endif
+	}
+
+	/// <summary>
+	/// An event used to trigger vignette shakes
+	/// </summary>
+	public struct MMPaniniProjectionShakeEvent_URP
+	{
+		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(AnimationCurve distance, float duration, float remapMin, float remapMax, bool relativeDistance = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false);
+		
+		static public void Trigger(AnimationCurve distance, float duration, float remapMin, float remapMax, bool relativeDistance = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			OnEvent?.Invoke(distance, duration, remapMin, remapMax, relativeDistance, attenuation, channelData, 
+				resetShakerValuesAfterShake, resetTargetValuesAfterShake, forwardDirection, timescaleMode, stop, restore);
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMPaniniProjectionShaker_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMVignetteShaker_URP.cs

@@ -0,0 +1,245 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this class to a Camera with a URP vignette post processing and it'll be able to "shake" its values by getting events
+	/// </summary>
+	#if MM_URP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMVignetteShaker_URP")]
+	public class MMVignetteShaker_URP : MMShaker
+	{
+		[MMInspectorGroup("Vignette Intensity", true, 63)]
+		/// whether or not to add to the initial value
+		[Tooltip("whether or not to add to the initial value")]
+		public bool RelativeIntensity = false;
+		/// the curve used to animate the intensity value on
+		[Tooltip("the curve used to animate the intensity value on")]
+		public AnimationCurve ShakeIntensity = 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, 1f)]
+		public float RemapIntensityZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(0f, 1f)]
+		public float RemapIntensityOne = 1f;
+		
+		[MMFInspectorGroup("Vignette Color", true, 60)]
+		/// whether or not to also animate  the vignette's color
+		[Tooltip("whether or not to also animate the vignette's color")]
+		public bool InterpolateColor = false;
+		/// the curve to animate the color on
+		[Tooltip("the curve to animate the color on")]
+		public AnimationCurve ColorCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.05f, 1f), new Keyframe(0.95f, 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(0, 1)]
+		public float RemapColorZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(0f, 1f)]
+		public float RemapColorOne = 1f;
+		/// the color to lerp towards
+		[Tooltip("the color to lerp towards")]
+		public Color TargetColor = Color.red;
+
+		#if MM_URP
+		protected Volume _volume;
+		protected Vignette _vignette;
+		protected float _initialIntensity;
+		protected float _originalShakeDuration;
+		protected AnimationCurve _originalShakeIntensity;
+		protected float _originalRemapIntensityZero;
+		protected float _originalRemapIntensityOne;
+		protected bool _originalRelativeIntensity;
+		protected bool _originalInterpolateColor;
+		protected AnimationCurve _originalColorCurve;
+		protected float _originalRemapColorZero;
+		protected float _originalRemapColorOne;
+		protected Color _originalTargetColor;
+		protected Color _initialColor;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_volume = this.gameObject.GetComponent<Volume>();
+			_volume.profile.TryGet(out _vignette);
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newValue = ShakeFloat(ShakeIntensity, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, _initialIntensity);
+			_vignette.intensity.Override(newValue);
+			
+			if (InterpolateColor)
+			{
+				float newColorValue = ShakeFloat(ColorCurve, RemapColorZero, RemapColorOne, RelativeIntensity, 0);
+				_vignette.color.Override(Color.Lerp(_initialColor, TargetColor, newColorValue));
+			}
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialIntensity = _vignette.intensity.value;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="intensity"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeIntensity"></param>
+		/// <param name="attenuation"></param>
+		/// <param name="channel"></param>
+		public virtual void OnVignetteShakeEvent(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false,
+			bool interpolateColor = false, AnimationCurve colorCurve = null, float remapColorZero = 0f, float remapColorOne = 1f, Color targetColor = default(Color))
+		{
+			if (!CheckEventAllowed(channelData) || (!Interruptible && Shaking))
+			{
+				return;
+			}
+	            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+	            
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalShakeIntensity = ShakeIntensity;
+				_originalRemapIntensityZero = RemapIntensityZero;
+				_originalRemapIntensityOne = RemapIntensityOne;
+				_originalRelativeIntensity = RelativeIntensity;
+				_originalInterpolateColor = InterpolateColor;
+				_originalColorCurve = ColorCurve;
+				_originalRemapColorZero = RemapColorZero;
+				_originalRemapColorOne = RemapColorOne;
+				_originalTargetColor = TargetColor;
+			}
+
+			if (!OnlyUseShakerValues)
+			{
+				TimescaleMode = timescaleMode;
+				ShakeDuration = duration;
+				ShakeIntensity = intensity;
+				RemapIntensityZero = remapMin * attenuation;
+				RemapIntensityOne = remapMax * attenuation;
+				RelativeIntensity = relativeIntensity;
+				ForwardDirection = forwardDirection;
+				InterpolateColor = interpolateColor;
+				ColorCurve = colorCurve;
+				RemapColorZero = remapColorZero;
+				RemapColorOne = remapColorOne;
+				TargetColor = targetColor;
+			}
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_vignette.intensity.Override(_initialIntensity);
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			ShakeIntensity = _originalShakeIntensity;
+			RemapIntensityZero = _originalRemapIntensityZero;
+			RemapIntensityOne = _originalRemapIntensityOne;
+			RelativeIntensity = _originalRelativeIntensity;
+			InterpolateColor = _originalInterpolateColor;
+			ColorCurve = _originalColorCurve;
+			RemapColorZero = _originalRemapColorZero;
+			RemapColorOne = _originalRemapColorOne;
+			TargetColor = _originalTargetColor;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMVignetteShakeEvent_URP.Register(OnVignetteShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMVignetteShakeEvent_URP.Unregister(OnVignetteShakeEvent);
+		}
+		#endif
+	}
+
+	/// <summary>
+	/// An event used to trigger vignette shakes
+	/// </summary>
+	public struct MMVignetteShakeEvent_URP
+	{
+		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(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false,
+			bool interpolateColor = false, AnimationCurve colorCurve = null, float remapColorZero = 0f, float remapColorOne = 1f, Color targetColor = default(Color));
+		
+		static public void Trigger(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false,
+			bool interpolateColor = false, AnimationCurve colorCurve = null, float remapColorZero = 0f, float remapColorOne = 1f, Color targetColor = default(Color))
+		{
+			OnEvent?.Invoke(intensity, duration, remapMin, remapMax, relativeIntensity, attenuation, channelData, 
+				resetShakerValuesAfterShake, resetTargetValuesAfterShake, forwardDirection, timescaleMode, stop, restore, 
+				interpolateColor, colorCurve, remapColorZero, remapColorOne, targetColor);
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMVignetteShaker_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMWhiteBalanceShaker_URP.cs

@@ -0,0 +1,230 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+#if MM_URP
+using UnityEngine.Rendering.Universal;
+#endif
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this class to a Camera with a white balance post processing and it'll be able to "shake" its values by getting events
+	/// </summary>
+	#if MM_URP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMWhiteBalanceShaker_URP")]
+	public class MMWhiteBalanceShaker_URP : MMShaker
+	{
+		/// whether or not to add to the initial value
+		[Tooltip("whether or not to add to the initial value")]
+		public bool RelativeValues = true;
+
+		[MMInspectorGroup("Temperature", true, 55)]
+		/// the curve used to animate the temperature value on
+		[Tooltip("the curve used to animate the temperature value on")]
+		public AnimationCurve ShakeTemperature = 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(-100f, 100f)]
+		public float RemapTemperatureZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-100f, 100f)]
+		public float RemapTemperatureOne = 100f;
+
+		[MMInspectorGroup("Tint", true, 56)]
+		/// the curve used to animate the tint value on
+		[Tooltip("the curve used to animate the tint value on")]
+		public AnimationCurve ShakeTint = 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(-100f, 100f)]
+		public float RemapTintZero = 0f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		[Range(-100f, 100f)]
+		public float RemapTintOne = 100f;
+
+		#if MM_URP
+		protected Volume _volume;
+		protected WhiteBalance _whiteBalance;
+		protected float _initialTemperature;
+		protected float _initialTint;
+		protected float _originalShakeDuration;
+		protected bool _originalRelativeValues;
+		protected AnimationCurve _originalShakeTemperature;
+		protected float _originalRemapTemperatureZero;
+		protected float _originalRemapTemperatureOne;
+		protected AnimationCurve _originalShakeTint;
+		protected float _originalRemapTintZero;
+		protected float _originalRemapTintOne;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_volume = this.gameObject.GetComponent<Volume>();
+			_volume.profile.TryGet(out _whiteBalance);
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newTemperature = ShakeFloat(ShakeTemperature, RemapTemperatureZero, RemapTemperatureOne, RelativeValues, _initialTemperature);
+			_whiteBalance.temperature.Override(newTemperature);
+			float newTint = ShakeFloat(ShakeTint, RemapTintZero, RemapTintOne, RelativeValues, _initialTint);
+			_whiteBalance.tint.Override(newTint);
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialTemperature = _whiteBalance.temperature.value;
+			_initialTint = _whiteBalance.tint.value;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="temperature"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeValues"></param>
+		/// <param name="attenuation"></param>
+		/// <param name="channel"></param>
+		public virtual void OnWhiteBalanceShakeEvent(AnimationCurve temperature, float duration, float remapTemperatureMin, float remapTemperatureMax,
+			AnimationCurve tint, float remapTintMin, float remapTintMax, bool relativeValues = false,
+			float attenuation = 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) || (!Interruptible && Shaking))
+			{
+				return;
+			}
+	            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+	            
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalShakeTemperature = ShakeTemperature;
+				_originalRemapTemperatureZero = RemapTemperatureZero;
+				_originalRemapTemperatureOne = RemapTemperatureOne;
+				_originalRelativeValues = RelativeValues;
+				_originalShakeTint = ShakeTint;
+				_originalRemapTintZero = RemapTintZero;
+				_originalRemapTintOne = RemapTintOne;
+			}
+
+			if (!OnlyUseShakerValues)
+			{
+				TimescaleMode = timescaleMode;
+				ShakeDuration = duration;
+				ShakeTemperature = temperature;
+				RemapTemperatureZero = remapTemperatureMin * attenuation;
+				RemapTemperatureOne = remapTemperatureMax * attenuation;
+				RelativeValues = relativeValues;
+				ShakeTint = tint;
+				RemapTintZero = remapTintMin;
+				RemapTintOne = remapTintMax;
+				ForwardDirection = forwardDirection;
+			}
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_whiteBalance.temperature.Override(_initialTemperature);
+			_whiteBalance.tint.Override(_initialTint);
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			ShakeTemperature = _originalShakeTemperature;
+			RemapTemperatureZero = _originalRemapTemperatureZero;
+			RemapTemperatureOne = _originalRemapTemperatureOne;
+			RelativeValues = _originalRelativeValues;
+			ShakeTint = _originalShakeTint;
+			RemapTintZero = _originalRemapTintZero;
+			RemapTintOne = _originalRemapTintOne;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMWhiteBalanceShakeEvent_URP.Register(OnWhiteBalanceShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMWhiteBalanceShakeEvent_URP.Unregister(OnWhiteBalanceShakeEvent);
+		}
+		#endif
+	}
+
+	/// <summary>
+	/// An event used to trigger vignette shakes
+	/// </summary>
+	public struct MMWhiteBalanceShakeEvent_URP
+	{
+		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(AnimationCurve temperature, float duration, float remapTemperatureMin, float remapTemperatureMax,
+			AnimationCurve tint, float remapTintMin, float remapTintMax, bool relativeValues = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false);
+
+		static public void Trigger(AnimationCurve temperature, float duration, float remapTemperatureMin, float remapTemperatureMax,
+			AnimationCurve tint, float remapTintMin, float remapTintMax, bool relativeValues = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			OnEvent?.Invoke(temperature, duration, remapTemperatureMin, remapTemperatureMax,
+				tint, remapTintMin, remapTintMax, relativeValues,
+				attenuation, channelData, resetShakerValuesAfterShake, resetTargetValuesAfterShake, forwardDirection, timescaleMode, stop, restore);
+		}
+	}
+}

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Shakers/MMWhiteBalanceShaker_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringBloomIntensity_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringBloomIntensity_URP")]
+	public class MMSpringBloomIntensity_URP : MMSpringFloatComponent<Volume>
+	{
+		protected Bloom _bloom;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _bloom);
+			base.Initialization();
+		}
+		
+		public override float TargetFloat
+		{
+			get => _bloom.intensity.value;
+			set => _bloom.intensity.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringBloomIntensity_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringChromaticAberrationIntensity_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringChromaticAberrationIntensity_URP")]
+	public class MMSpringChromaticAberrationIntensity_URP : MMSpringFloatComponent<Volume>
+	{
+		protected ChromaticAberration _chromaticAberration;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _chromaticAberration);
+			base.Initialization();
+		}
+		
+		public override float TargetFloat
+		{
+			get => _chromaticAberration.intensity.value;
+			set => _chromaticAberration.intensity.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringChromaticAberrationIntensity_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringColorAdjustmentsContrast_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringColorAdjustmentsContrast_URP")]
+	public class MMSpringColorAdjustmentsContrast_URP : MMSpringFloatComponent<Volume>
+	{
+		protected ColorAdjustments _colorAdjustments;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _colorAdjustments);
+			base.Initialization();
+		}
+		
+		public override float TargetFloat
+		{
+			get => _colorAdjustments.contrast.value;
+			set => _colorAdjustments.contrast.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringColorAdjustmentsContrast_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringColorAdjustmentsHueShift_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringColorAdjustmentsHueShift_URP")]
+	public class MMSpringColorAdjustmentsHueShift_URP : MMSpringFloatComponent<Volume>
+	{
+		protected ColorAdjustments _colorAdjustments;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _colorAdjustments);
+			base.Initialization();
+		}
+		
+		public override float TargetFloat
+		{
+			get => _colorAdjustments.hueShift.value;
+			set => _colorAdjustments.hueShift.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringColorAdjustmentsHueShift_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringColorAdjustmentsSaturation_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringColorAdjustmentsSaturation_URP")]
+	public class MMSpringColorAdjustmentsSaturation_URP : MMSpringFloatComponent<Volume>
+	{
+		protected ColorAdjustments _colorAdjustments;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _colorAdjustments);
+			base.Initialization();
+		}
+		
+		public override float TargetFloat
+		{
+			get => _colorAdjustments.saturation.value;
+			set => _colorAdjustments.saturation.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringColorAdjustmentsSaturation_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringDepthOfFieldFocalLength_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringDepthOfFieldFocalLength_URP")]
+	public class MMSpringDepthOfFieldFocalLength_URP : MMSpringFloatComponent<Volume>
+	{
+		protected DepthOfField _depthOfField;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _depthOfField);
+			base.Initialization();
+		}
+		
+		public override float TargetFloat
+		{
+			get => _depthOfField.focalLength.value;
+			set => _depthOfField.focalLength.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringDepthOfFieldFocalLength_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringLensDistortionIntensity_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringLensDistortionIntensity_URP")]
+	public class MMSpringLensDistortionIntensity_URP : MMSpringFloatComponent<Volume>
+	{
+		protected LensDistortion _lensDistortion;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _lensDistortion);
+			base.Initialization();
+		}
+		
+		public override float TargetFloat
+		{
+			get => _lensDistortion.intensity.value;
+			set => _lensDistortion.intensity.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringLensDistortionIntensity_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringMotionBlurIntensity_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringMotionBlurIntensity_URP")]
+	public class MMSpringMotionBlurIntensity_URP : MMSpringFloatComponent<Volume>
+	{
+		protected MotionBlur _motionBlur;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _motionBlur);
+			base.Initialization();
+		}
+		
+		public override float TargetFloat
+		{
+			get => _motionBlur.intensity.value;
+			set => _motionBlur.intensity.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringMotionBlurIntensity_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringPaniniProjectionDistance_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringPaniniProjectionDistance_URP")]
+	public class MMSpringPaniniProjectionDistance_URP : MMSpringFloatComponent<Volume>
+	{
+		protected PaniniProjection _paniniProjection;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _paniniProjection);
+			base.Initialization();
+		}
+		
+		public override float TargetFloat
+		{
+			get => _paniniProjection.distance.value;
+			set => _paniniProjection.distance.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringPaniniProjectionDistance_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringVignetteCenter_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringVignetteCenter_URP")]
+	public class MMSpringVignetteCenter_URP : MMSpringVector2Component<Volume>
+	{
+		protected Vignette _vignette;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _vignette);
+			base.Initialization();
+		}
+		
+		public override Vector2 TargetVector2
+		{
+			get => _vignette.center.value;
+			set => _vignette.center.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringVignetteCenter_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringVignetteColor_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringVignetteColor_URP")]
+	public class MMSpringVignetteColor_URP : MMSpringColorComponent<Volume>
+	{
+		protected Vignette _vignette;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _vignette);
+			base.Initialization();
+		}
+		
+		public override Color TargetColor
+		{
+			get => _vignette.color.value;
+			set => _vignette.color.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringVignetteColor_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringVignetteIntensity_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringVignetteIntensity_URP")]
+	public class MMSpringVignetteIntensity_URP : MMSpringFloatComponent<Volume>
+	{
+		protected Vignette _vignette;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _vignette);
+			base.Initialization();
+		}
+		
+		public override float TargetFloat
+		{
+			get => _vignette.intensity.value;
+			set => _vignette.intensity.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringVignetteIntensity_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringWhiteBalanceTemperature_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringWhiteBalanceTemperature_URP")]
+	public class MMSpringWhiteBalanceTemperature_URP : MMSpringFloatComponent<Volume>
+	{
+		protected WhiteBalance _whiteBalance;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _whiteBalance);
+			base.Initialization();
+		}
+		
+		public override float TargetFloat
+		{
+			get => _whiteBalance.temperature.value;
+			set => _whiteBalance.temperature.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringWhiteBalanceTemperature_URP.cs.meta

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

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringWhiteBalanceTint_URP.cs

@@ -0,0 +1,30 @@
+#if MM_URP
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace MoreMountains.Feedbacks
+{
+	[AddComponentMenu("More Mountains/Springs/MMSpringWhiteBalanceTint_URP")]
+	public class MMSpringWhiteBalanceTint_URP : MMSpringFloatComponent<Volume>
+	{
+		protected WhiteBalance _whiteBalance;
+		
+		protected override void Initialization()
+		{
+			if (Target == null)
+			{
+				Target = this.gameObject.GetComponent<Volume>();
+			}
+			Target.profile.TryGet(out _whiteBalance);
+			base.Initialization();
+		}
+		
+		public override float TargetFloat
+		{
+			get => _whiteBalance.tint.value;
+			set => _whiteBalance.tint.Override(value);
+		}
+	}
+}
+#endif

Assets/Feel/MMFeedbacks/MMFeedbacksForThirdParty/URP/Springs/MMSpringWhiteBalanceTint_URP.cs.meta

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