Insanely huge initial commit

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

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackBloom_HDRP.cs

@@ -0,0 +1,100 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+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_HDRP 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_HDRP component.")]
+	[FeedbackPath("PostProcess/Bloom HDRP")]
+	public class MMFeedbackBloom_HDRP : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.PostProcessColor; } }
+		#endif
+
+		[Header("Bloom")]
+		/// the channel to emit on
+		[Tooltip("the channel to emit on")]
+		public int Channel = 0;
+		/// 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;
+
+		[Header("Intensity")]
+		/// 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;
+
+		[Header("Threshold")]
+		/// 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;
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(ShakeDuration); }  set { ShakeDuration = value;  } }
+
+		/// <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;
+			}
+            
+			MMBloomShakeEvent_HDRP.Trigger(ShakeIntensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, ShakeThreshold, RemapThresholdZero, RemapThresholdOne,
+				RelativeValues, attenuation, ChannelData(Channel), ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, Timing.TimescaleMode);
+            
+		}
+        
+		/// <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_HDRP.Trigger(ShakeIntensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, ShakeThreshold, RemapThresholdZero, RemapThresholdOne,
+				RelativeValues, channelData:ChannelData(Channel), stop:true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackBloom_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackChannelMixer_HDRP.cs

@@ -0,0 +1,126 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control channel mixer's red, green and blue over time.
+	/// It requires you have in your scene an object with a Volume 
+	/// with Channel Mixer active, and a MMChannelMixerShaker_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackPath("PostProcess/Channel Mixer HDRP")]
+	[FeedbackHelp("This feedback allows you to control channel mixer's red, green and blue over time." +
+	              "It requires you have in your scene an object with a Volume" +
+	              "with Channel Mixer active, and a MMChannelMixerShaker_HDRP component.")]
+	public class MMFeedbackChannelMixer_HDRP : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback        
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.PostProcessColor; } }
+		#endif
+
+		[Header("Color Grading")]
+		/// the channel to emit on
+		[Tooltip("the channel to emit on")]
+		public int Channel = 0;
+		/// 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;
+
+		[Header("Red")]
+		/// 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;
+
+		[Header("Green")]
+		/// 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;
+
+		[Header("Blue")]
+		/// 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;
+        
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(ShakeDuration); } set { ShakeDuration = value; } }
+
+		/// <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 = Timing.ConstantIntensity ? 1f : feedbacksIntensity;
+			MMChannelMixerShakeEvent_HDRP.Trigger(ShakeRed, RemapRedZero, RemapRedOne,
+				ShakeGreen, RemapGreenZero, RemapGreenOne,
+				ShakeBlue, RemapBlueZero, RemapBlueOne,
+				FeedbackDuration,
+				RelativeIntensity, intensityMultiplier, ChannelData(Channel), ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, Timing.TimescaleMode);
+		}
+        
+		/// <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_HDRP.Trigger(ShakeRed, RemapRedZero, RemapRedOne,
+				ShakeGreen, RemapGreenZero, RemapGreenOne,
+				ShakeBlue, RemapBlueZero, RemapBlueOne,
+				FeedbackDuration,
+				RelativeIntensity, channelData:ChannelData(Channel), stop:true);
+            
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackChannelMixer_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackChromaticAberration_HDRP.cs

@@ -0,0 +1,95 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+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 HDRP Chromatic Aberration active, and a MMChromaticAberrationShaker_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackPath("PostProcess/Chromatic Aberration HDRP")]
+	[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_HDRP component.")]
+	public class MMFeedbackChromaticAberration_HDRP : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.PostProcessColor; } }
+		#endif
+
+		[Header("Chromatic Aberration")]
+		/// the channel to emit on
+		[Tooltip("the channel to emit on")]
+		public int Channel = 0;
+		/// 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;
+
+		[Header("Intensity")]
+		/// 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;
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(Duration); } set { Duration = value;  } }
+
+		/// <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 = Timing.ConstantIntensity ? 1f : feedbacksIntensity;
+			MMChromaticAberrationShakeEvent_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, intensityMultiplier,
+				ChannelData(Channel), ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, Timing.TimescaleMode);
+		}
+        
+		/// <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_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, channelData:ChannelData(Channel), stop:true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackChromaticAberration_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackColorAdjustments_HDRP.cs

@@ -0,0 +1,167 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+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_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackPath("PostProcess/Color Adjustments HDRP")]
+	[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_HDRP component.")]
+	public class MMFeedbackColorAdjustments_HDRP : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback        
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.PostProcessColor; } }
+		#endif
+
+		[Header("Color Grading")]
+		/// the channel to emit on
+		[Tooltip("the channel to emit on")]
+		public int Channel = 0;
+		/// 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;
+
+		[Header("Post Exposure")]
+		/// 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;
+
+		[Header("Hue Shift")]
+		/// 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;
+
+		[Header("Saturation")]
+		/// 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;
+
+		[Header("Contrast")]
+		/// 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;
+        
+		[Header("Color Filter")] 
+		/// 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_HDRP.ColorFilterModes ColorFilterMode = MMColorAdjustmentsShaker_HDRP.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_HDRP.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_HDRP.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_HDRP.ColorFilterModes.Interpolate)]
+		public AnimationCurve ColorFilterCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 1), new Keyframe(1, 0));
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(ShakeDuration); } set { ShakeDuration = value; } }
+
+		/// <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 = Timing.ConstantIntensity ? 1f : feedbacksIntensity;
+			MMColorAdjustmentsShakeEvent_HDRP.Trigger(ShakePostExposure, RemapPostExposureZero, RemapPostExposureOne,
+				ShakeHueShift, RemapHueShiftZero, RemapHueShiftOne,
+				ShakeSaturation, RemapSaturationZero, RemapSaturationOne,
+				ShakeContrast, RemapContrastZero, RemapContrastOne,
+				ColorFilterMode, ColorFilterGradient, ColorFilterDestination, ColorFilterCurve,
+				FeedbackDuration,
+				RelativeIntensity, intensityMultiplier, ChannelData(Channel), ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, Timing.TimescaleMode);
+            
+		}
+        
+		/// <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_HDRP.Trigger(ShakePostExposure, RemapPostExposureZero, RemapPostExposureOne,
+				ShakeHueShift, RemapHueShiftZero, RemapHueShiftOne,
+				ShakeSaturation, RemapSaturationZero, RemapSaturationOne,
+				ShakeContrast, RemapContrastZero, RemapContrastOne,
+				ColorFilterMode, ColorFilterGradient, ColorFilterDestination, ColorFilterCurve,
+				FeedbackDuration,
+				RelativeIntensity, channelData:ChannelData(Channel), stop:true);
+            
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackColorAdjustments_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackExposure_HDRP.cs

@@ -0,0 +1,93 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control HDRP exposure intensity over time.
+	/// It requires you have in your scene an object with a Volume 
+	/// with Exposure active, and a MMExposureShaker_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackPath("PostProcess/Exposure HDRP")]
+	[FeedbackHelp("This feedback allows you to control Exposure intensity over time. " +
+	              "It requires you have in your scene an object with a Volume " +
+	              "with Exposure active, and a MMExposureShaker_HDRP component.")]
+	public class MMFeedbackExposure_HDRP : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.PostProcessColor; } }
+		#endif
+
+		[Header("Exposure")]
+		/// the channel to emit on
+		[Tooltip("the channel to emit on")]
+		public int Channel = 0;
+		/// 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;
+
+		[Header("Intensity")]
+		/// the curve to animate the intensity on
+		[Tooltip("the curve to animate the intensity on")]
+		public AnimationCurve FixedExposure = 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 RemapFixedExposureZero = 8.5f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapFixedExposureOne = 6f;
+		/// whether or not to add to the initial intensity
+		[Tooltip("whether or not to add to the initial intensity")]
+		public bool RelativeFixedExposure = false;
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(Duration); } set { Duration = value; } }
+
+		/// <summary>
+		/// Triggers a Exposure 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 = Timing.ConstantIntensity ? 1f : feedbacksIntensity;
+			MMExposureShakeEvent_HDRP.Trigger(FixedExposure, FeedbackDuration, RemapFixedExposureZero, RemapFixedExposureOne, RelativeFixedExposure, intensityMultiplier,
+				ChannelData(Channel), ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, Timing.TimescaleMode);
+            
+		}
+        
+		/// <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);
+            
+			MMExposureShakeEvent_HDRP.Trigger(FixedExposure, FeedbackDuration, RemapFixedExposureZero, RemapFixedExposureOne, RelativeFixedExposure, channelData:ChannelData(Channel), stop:true);
+            
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackExposure_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackFilmGrain_HDRP.cs

@@ -0,0 +1,94 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control HDRP Film Grain intensity over time.
+	/// It requires you have in your scene an object with a Volume 
+	/// with Film Grain active, and a MMFilmGrainShaker_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackPath("PostProcess/Film Grain HDRP")]
+	[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_HDRP component.")]
+	public class MMFeedbackFilmGrain_HDRP : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.PostProcessColor; } }
+		#endif
+
+		[Header("Film Grain")]
+		/// the channel to emit on
+		[Tooltip("the channel to emit on")]
+		public int Channel = 0;
+		/// 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;
+
+		[Header("Intensity")]
+		/// 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;
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(Duration); } set { Duration = value; } }
+
+		/// <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 = Timing.ConstantIntensity ? 1f : feedbacksIntensity;
+			MMFilmGrainShakeEvent_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, intensityMultiplier,
+				ChannelData(Channel), ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, Timing.TimescaleMode);
+            
+		}
+        
+		/// <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_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, channelData:ChannelData(Channel), stop:true);
+            
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackFilmGrain_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackLensDistortion_HDRP.cs

@@ -0,0 +1,103 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control HDRP lens distortion intensity over time. 
+	/// It requires you have in your scene an object with a Volume 
+	/// with Lens Distortion active, and a MMLensDistortionShaker_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackPath("PostProcess/Lens Distortion HDRP")]
+	[FeedbackHelp("This feedback allows you to control HDRP lens distortion intensity over time. " +
+	              "It requires you have in your scene an object with a Volume " +
+	              "with Lens Distortion active, and a MMLensDistortionShaker_HDRP component.")]
+	public class MMFeedbackLensDistortion_HDRP : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.PostProcessColor; } }
+		#endif
+
+		[Header("Lens Distortion")]
+		/// the channel to emit on
+		[Tooltip("the channel to emit on")]
+		public int Channel = 0;
+		/// 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;
+
+		[Header("Intensity")]
+		/// 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(-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;
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(Duration); } set { Duration = value; } }
+
+		/// <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 = Timing.ConstantIntensity ? 1f : feedbacksIntensity;
+			MMLensDistortionShakeEvent_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, intensityMultiplier,
+				ChannelData(Channel), ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, Timing.TimescaleMode);
+		}
+        
+		/// <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_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne,
+				RelativeIntensity, channelData: ChannelData(Channel), stop: true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackLensDistortion_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackMotionBlur_HDRP.cs

@@ -0,0 +1,91 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control HDRP motion blur intensity over time.
+	/// It requires you have in your scene an object with a Volume 
+	/// with MotionBlur active, and a MMMotionBlurShaker_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackPath("PostProcess/Motion Blur HDRP")]
+	[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_HDRP component.")]
+	public class MMFeedbackMotionBlur_HDRP : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.PostProcessColor; } }
+		#endif
+
+		[Header("Motion Blur")]
+		/// the channel to emit on
+		[Tooltip("the channel to emit on")]
+		public int Channel = 0;
+		/// 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;
+
+		[Header("Intensity")]
+		/// 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")]
+		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")]
+		public float RemapIntensityOne = 1000f;
+		/// whether or not to add to the initial intensity
+		[Tooltip("whether or not to add to the initial intensity")]
+		public bool RelativeIntensity = false;
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(Duration); } set { Duration = value; } }
+
+		/// <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 = Timing.ConstantIntensity ? 1f : feedbacksIntensity;
+			MMMotionBlurShakeEvent_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, intensityMultiplier,
+				ChannelData(Channel), ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, Timing.TimescaleMode);
+		}
+        
+		/// <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_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne,
+				RelativeIntensity, channelData:ChannelData(Channel), stop: true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackMotionBlur_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackPaniniProjection_HDRP.cs

@@ -0,0 +1,91 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+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_HDRP 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_HDRP component.")]
+	[FeedbackPath("PostProcess/Panini Projection HDRP")]
+	public class MMFeedbackPaniniProjection_HDRP : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.PostProcessColor; } }
+		#endif
+
+		[Header("Panini Projection")]
+		/// the channel to emit on
+		[Tooltip("the channel to emit on")]
+		public int Channel = 0;
+		/// 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;
+
+		[Header("Distance")]
+		/// 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;
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(Duration); } set { Duration = value; } }
+
+		/// <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 = Timing.ConstantIntensity ? 1f : feedbacksIntensity;
+			MMPaniniProjectionShakeEvent_HDRP.Trigger(ShakeDistance, FeedbackDuration, RemapDistanceZero, RemapDistanceOne, RelativeDistance, intensityMultiplier, ChannelData(Channel), 
+				ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, Timing.TimescaleMode);
+		}
+        
+		/// <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_HDRP.Trigger(ShakeDistance, FeedbackDuration, RemapDistanceZero, RemapDistanceOne, RelativeDistance, channelData:ChannelData(Channel), stop:true);
+            
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackPaniniProjection_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackVignette_HDRP.cs

@@ -0,0 +1,92 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control HDRP vignette intensity over time.
+	/// It requires you have in your scene an object with a Volume 
+	/// with Vignette active, and a MMVignetteShaker_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	[FeedbackPath("PostProcess/Vignette HDRP")]
+	[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_HDRP component.")]
+	public class MMFeedbackVignette_HDRP : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.PostProcessColor; } }
+		#endif
+
+		[Header("Vignette")]
+		/// the channel to emit on
+		[Tooltip("the channel to emit on")]
+		public int Channel = 0;
+		/// 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;
+
+		[Header("Intensity")]
+		/// 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;
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(Duration); } set { Duration = value; } }
+
+		/// <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 = Timing.ConstantIntensity ? 1f : feedbacksIntensity;
+			MMVignetteShakeEvent_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, intensityMultiplier,
+				ChannelData(Channel), ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, Timing.TimescaleMode);
+		}
+        
+		/// <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);
+			MMVignetteShakeEvent_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, channelData:ChannelData(Channel), stop:true);
+            
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackVignette_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackWhiteBalance_HDRP.cs

@@ -0,0 +1,105 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+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_HDRP 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_HDRP component.")]
+	[FeedbackPath("PostProcess/White Balance HDRP")]
+	public class MMFeedbackWhiteBalance_HDRP : MMFeedback
+	{
+		/// a static bool used to disable all feedbacks of this type at once
+		public static bool FeedbackTypeAuthorized = true;
+		/// sets the inspector color for this feedback
+		#if UNITY_EDITOR
+		public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.PostProcessColor; } }
+		#endif
+
+		[Header("White Balance")]
+		/// the channel to emit on
+		[Tooltip("the channel to emit on")]
+		public int Channel = 0;
+		/// 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;
+
+		[Header("Temperature")]
+		/// 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;
+
+		[Header("Tint")]
+		/// 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;
+
+		/// the duration of this feedback is the duration of the shake
+		public override float FeedbackDuration { get { return ApplyTimeMultiplier(ShakeDuration); } set { ShakeDuration = value; } }
+
+		/// <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 = Timing.ConstantIntensity ? 1f : feedbacksIntensity;
+			MMWhiteBalanceShakeEvent_HDRP.Trigger(ShakeTemperature, FeedbackDuration, RemapTemperatureZero, RemapTemperatureOne,
+				ShakeTint, RemapTintZero, RemapTintOne, RelativeValues, intensityMultiplier,
+				ChannelData(Channel), ResetShakerValuesAfterShake, ResetTargetValuesAfterShake, NormalPlayDirection, Timing.TimescaleMode);
+		}
+        
+		/// <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_HDRP.Trigger(ShakeTemperature, FeedbackDuration, RemapTemperatureZero, RemapTemperatureOne,
+				ShakeTint, RemapTintZero, RemapTintOne, RelativeValues, channelData:ChannelData(Channel), stop:true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/Legacy/MMFeedbackWhiteBalance_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_Bloom_HDRP.cs

@@ -0,0 +1,117 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+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_HDRP 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_HDRP component.")]
+	#if MM_HDRP
+	[FeedbackPath("PostProcess/Bloom HDRP")]
+	#endif
+	public class MMF_Bloom_HDRP : 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; } }
+		#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, 3)]
+		/// 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, 4)]
+		/// 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, 5)]
+		/// 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_HDRP.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_HDRP.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_HDRP.Trigger(ShakeIntensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, ShakeThreshold, RemapThresholdZero, RemapThresholdOne,
+				RelativeValues, channelData:ChannelData, restore:true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_Bloom_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_ChannelMixer_HDRP.cs

@@ -0,0 +1,141 @@
+using System.Collections;	
+using System.Collections.Generic;	
+using UnityEngine;	
+using MoreMountains.Feedbacks;	
+namespace MoreMountains.FeedbacksForThirdParty	
+{	
+	/// <summary>	
+	/// This feedback allows you to control channel mixer's red, green and blue over time.	
+	/// It requires you have in your scene an object with a Volume 	
+	/// with Channel Mixer active, and a MMChannelMixerShaker_HDRP component.	
+	/// </summary>	
+	[AddComponentMenu("")]	
+	#if MM_HDRP
+	[FeedbackPath("PostProcess/Channel Mixer HDRP")]
+	#endif
+	[FeedbackHelp("This feedback allows you to control channel mixer's red, green and blue over time." +
+	              "It requires you have in your scene an object with a Volume" +
+	              "with Channel Mixer active, and a MM Channel Mixer HDRP component.")]
+	public class MMF_ChannelMixer_HDRP : 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; } }	
+		#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, 10)]
+		/// 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, 13)]
+		/// 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, 12)]
+		/// 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, 11)]
+		/// 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_HDRP.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_HDRP.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_HDRP.Trigger(ShakeRed, RemapRedZero, RemapRedOne,
+				ShakeGreen, RemapGreenZero, RemapGreenOne,
+				ShakeBlue, RemapBlueZero, RemapBlueOne,
+				FeedbackDuration,
+				RelativeIntensity, channelData:ChannelData, restore:true);
+		}
+	}	
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_ChannelMixer_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_ChromaticAberration_HDRP.cs

@@ -0,0 +1,109 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+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 HDRP Chromatic Aberration active, and a MMChromaticAberrationShaker_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	#if MM_HDRP
+	[FeedbackPath("PostProcess/Chromatic Aberration HDRP")]
+	#endif
+	[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_HDRP component.")]
+	public class MMF_ChromaticAberration_HDRP : 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; } }
+		#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, 10)]
+		/// 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, 11)]
+		/// 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_HDRP.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_HDRP.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_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, channelData:ChannelData, restore:true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_ChromaticAberration_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_ColorAdjustments_HDRP.cs

@@ -0,0 +1,187 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+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_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	#if MM_HDRP
+	[FeedbackPath("PostProcess/Color Adjustments HDRP")]
+	#endif
+	[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_HDRP component.")]
+	public class MMF_ColorAdjustments_HDRP : 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; } }
+		#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, 16)]
+		/// 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, 15)]
+		/// 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, 14)]
+		/// 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, 13)]
+		/// 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, 12)]
+		/// 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;
+        
+		[Header("Color Filter")] 
+		/// 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_HDRP.ColorFilterModes ColorFilterMode = MMColorAdjustmentsShaker_HDRP.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_HDRP.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_HDRP.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_HDRP.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_HDRP.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_HDRP.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_HDRP.Trigger(ShakePostExposure, RemapPostExposureZero, RemapPostExposureOne,
+				ShakeHueShift, RemapHueShiftZero, RemapHueShiftOne,
+				ShakeSaturation, RemapSaturationZero, RemapSaturationOne,
+				ShakeContrast, RemapContrastZero, RemapContrastOne,
+				ColorFilterMode, ColorFilterGradient, ColorFilterDestination, ColorFilterCurve,
+				FeedbackDuration,
+				RelativeIntensity, channelData:ChannelData, restore:true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_ColorAdjustments_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_Exposure_HDRP.cs

@@ -0,0 +1,108 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control HDRP exposure intensity over time.
+	/// It requires you have in your scene an object with a Volume 
+	/// with Exposure active, and a MMExposureShaker_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	#if MM_HDRP
+	[FeedbackPath("PostProcess/Exposure HDRP")]
+	#endif
+	[FeedbackHelp("This feedback allows you to control Exposure intensity over time. " +
+	              "It requires you have in your scene an object with a Volume " +
+	              "with Exposure active, and a MMExposureShaker_HDRP component.")]
+	public class MMF_Exposure_HDRP : 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; } }
+		#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("Exposure", true, 17)]
+		/// 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, 18)]
+		/// the curve to animate the intensity on
+		[Tooltip("the curve to animate the intensity on")]
+		public AnimationCurve FixedExposure = 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 RemapFixedExposureZero = 8.5f;
+		/// the value to remap the curve's 1 to
+		[Tooltip("the value to remap the curve's 1 to")]
+		public float RemapFixedExposureOne = 6f;
+		/// whether or not to add to the initial intensity
+		[Tooltip("whether or not to add to the initial intensity")]
+		public bool RelativeFixedExposure = false;
+
+		/// <summary>
+		/// Triggers a Exposure 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);
+			MMExposureShakeEvent_HDRP.Trigger(FixedExposure, FeedbackDuration, RemapFixedExposureZero, RemapFixedExposureOne, RelativeFixedExposure, 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);
+            
+			MMExposureShakeEvent_HDRP.Trigger(FixedExposure, FeedbackDuration, RemapFixedExposureZero, 
+				RemapFixedExposureOne, RelativeFixedExposure, 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;
+			}
+			
+			MMExposureShakeEvent_HDRP.Trigger(FixedExposure, FeedbackDuration, RemapFixedExposureZero, 
+				RemapFixedExposureOne, RelativeFixedExposure, channelData:ChannelData, restore:true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_Exposure_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_FilmGrain_HDRP.cs

@@ -0,0 +1,107 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control HDRP Film Grain intensity over time.
+	/// It requires you have in your scene an object with a Volume 
+	/// with Film Grain active, and a MMFilmGrainShaker_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	#if MM_HDRP
+	[FeedbackPath("PostProcess/Film Grain HDRP")]
+	#endif
+	[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_HDRP component.")]
+	public class MMF_FilmGrain_HDRP : 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; } }
+		#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, 20)]
+		/// 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, 21)]
+		/// 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_HDRP.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_HDRP.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;
+			}
+			
+			MMFilmGrainShakeEvent_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, channelData:ChannelData, restore:true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_FilmGrain_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_LensDistortion_HDRP.cs

@@ -0,0 +1,118 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control HDRP lens distortion intensity over time. 
+	/// It requires you have in your scene an object with a Volume 
+	/// with Lens Distortion active, and a MMLensDistortionShaker_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	#if MM_HDRP
+	[FeedbackPath("PostProcess/Lens Distortion HDRP")]
+	#endif
+	[FeedbackHelp("This feedback allows you to control HDRP lens distortion intensity over time. " +
+	              "It requires you have in your scene an object with a Volume " +
+	              "with Lens Distortion active, and a MMLensDistortionShaker_HDRP component.")]
+	public class MMF_LensDistortion_HDRP : 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; } }
+		#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_HDRP.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_HDRP.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;
+			}
+			
+			MMLensDistortionShakeEvent_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne,
+				RelativeIntensity, channelData:ChannelData, restore: true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_LensDistortion_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_MotionBlur_HDRP.cs

@@ -0,0 +1,106 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control HDRP motion blur intensity over time.
+	/// It requires you have in your scene an object with a Volume 
+	/// with MotionBlur active, and a MMMotionBlurShaker_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	#if MM_HDRP
+	[FeedbackPath("PostProcess/Motion Blur HDRP")]
+	#endif
+	[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_HDRP component.")]
+	public class MMF_MotionBlur_HDRP : 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; } }
+		#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, 24)]
+		/// 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, 25)]
+		/// 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")]
+		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")]
+		public float RemapIntensityOne = 1000f;
+		/// 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_HDRP.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_HDRP.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;
+			}
+			
+			MMMotionBlurShakeEvent_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne,
+				RelativeIntensity, channelData:ChannelData, restore: true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_MotionBlur_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_PaniniProjection_HDRP.cs

@@ -0,0 +1,104 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+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_HDRP 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_HDRP component.")]
+	#if MM_HDRP
+	[FeedbackPath("PostProcess/Panini Projection HDRP")]
+	#endif
+	public class MMF_PaniniProjection_HDRP : 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; } }
+		#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, 26)]
+		/// 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_HDRP.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_HDRP.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_HDRP.Trigger(ShakeDistance, FeedbackDuration, RemapDistanceZero, RemapDistanceOne, RelativeDistance, channelData:ChannelData, restore:true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_PaniniProjection_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_Vignette_HDRP.cs

@@ -0,0 +1,105 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// This feedback allows you to control HDRP vignette intensity over time.
+	/// It requires you have in your scene an object with a Volume 
+	/// with Vignette active, and a MMVignetteShaker_HDRP component.
+	/// </summary>
+	[AddComponentMenu("")]
+	#if MM_HDRP
+	[FeedbackPath("PostProcess/Vignette HDRP")]
+	#endif
+	[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_HDRP component.")]
+	public class MMF_Vignette_HDRP : 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; } }
+		#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;
+
+		/// <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_HDRP.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);
+			MMVignetteShakeEvent_HDRP.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;
+			}
+			
+			MMVignetteShakeEvent_HDRP.Trigger(Intensity, FeedbackDuration, RemapIntensityZero, RemapIntensityOne, RelativeIntensity, channelData:ChannelData, restore:true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_Vignette_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_WhiteBalance_HDRP.cs

@@ -0,0 +1,120 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using MoreMountains.Feedbacks;
+
+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_HDRP 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_HDRP component.")]
+	#if MM_HDRP
+	[FeedbackPath("PostProcess/White Balance HDRP")]
+	#endif
+	public class MMF_WhiteBalance_HDRP : 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; } }
+		#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, 32)]
+		/// 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, 33)]
+		/// 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, 34)]
+		/// 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_HDRP.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_HDRP.Trigger(ShakeTemperature, FeedbackDuration, RemapTemperatureZero, RemapTemperatureOne,
+				ShakeTint, RemapTintZero, RemapTintOne, 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;
+			}
+			
+			MMWhiteBalanceShakeEvent_HDRP.Trigger(ShakeTemperature, FeedbackDuration, RemapTemperatureZero, RemapTemperatureOne,
+				ShakeTint, RemapTintZero, RemapTintOne, RelativeValues, channelData:ChannelData, restore:true);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Feedbacks/MMF_WhiteBalance_HDRP.cs.meta

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