Insanely huge initial commit

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMBloomShaker_HDRP.cs

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMBloomShaker_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMChannelMixerShaker_HDRP.cs

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMChannelMixerShaker_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMChromaticAberrationShaker_HDRP.cs

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMChromaticAberrationShaker_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMColorAdjustmentsShaker_HDRP.cs

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMColorAdjustmentsShaker_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMExposureShaker_HDRP.cs

@@ -0,0 +1,188 @@
+using UnityEngine;
+using UnityEngine.Rendering;
+using MoreMountains.Feedbacks;
+using MoreMountains.Tools;
+#if MM_HDRP
+using UnityEngine.Rendering.HighDefinition;
+#endif
+
+namespace MoreMountains.FeedbacksForThirdParty
+{
+	/// <summary>
+	/// Add this class to a Camera with a HDRP exposure post processing and it'll be able to "shake" its values by getting events
+	/// </summary>
+	#if MM_HDRP
+	[RequireComponent(typeof(Volume))]
+	#endif
+	[AddComponentMenu("More Mountains/Feedbacks/Shakers/PostProcessing/MMExposureShaker_HDRP")]
+	public class MMExposureShaker_HDRP : MMShaker
+	{
+		[MMInspectorGroup("Exposure Intensity", true, 46)]
+		/// whether or not to add to the initial value
+		[Tooltip("whether or not to add to the initial value")]
+		public bool RelativeIntensity = false;
+		/// the curve used to animate the intensity value on
+		[Tooltip("the curve used to animate the intensity value on")]
+		public AnimationCurve ShakeFixedExposure = 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;
+
+		#if MM_HDRP
+		protected Volume _volume;
+		protected Exposure _exposure;
+		protected float _initialFixedExposure;
+		protected float _originalShakeDuration;
+		protected AnimationCurve _originalShakeFixedExposure;
+		protected float _originalRemapFixedExposureZero;
+		protected float _originalRemapFixedExposureOne;
+		protected bool _originalRelativeFixedExposure;
+
+		/// <summary>
+		/// On init we initialize our values
+		/// </summary>
+		protected override void Initialization()
+		{
+			base.Initialization();
+			_volume = this.gameObject.GetComponent<Volume>();
+			_volume.profile.TryGet(out _exposure);
+		}
+
+		/// <summary>
+		/// Shakes values over time
+		/// </summary>
+		protected override void Shake()
+		{
+			float newValue = ShakeFloat(ShakeFixedExposure, RemapFixedExposureZero, RemapFixedExposureOne, RelativeIntensity, _initialFixedExposure);
+			_exposure.fixedExposure.Override(newValue);
+		}
+
+		/// <summary>
+		/// Collects initial values on the target
+		/// </summary>
+		protected override void GrabInitialValues()
+		{
+			_initialFixedExposure = _exposure.fixedExposure.value;
+		}
+
+		/// <summary>
+		/// When we get the appropriate event, we trigger a shake
+		/// </summary>
+		/// <param name="intensity"></param>
+		/// <param name="duration"></param>
+		/// <param name="amplitude"></param>
+		/// <param name="relativeIntensity"></param>
+		/// <param name="attenuation"></param>
+		/// <param name="channel"></param>
+		public virtual void OnExposureShakeEvent(AnimationCurve intensity, float duration, float remapMin, float remapMax, bool relativeIntensity = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			if (!CheckEventAllowed(channelData) || (!Interruptible && Shaking))
+			{
+				return;
+			}
+	            
+			if (stop)
+			{
+				Stop();
+				return;
+			}
+
+			if (restore)
+			{
+				ResetTargetValues();
+				return;
+			}
+	            
+			_resetShakerValuesAfterShake = resetShakerValuesAfterShake;
+			_resetTargetValuesAfterShake = resetTargetValuesAfterShake;
+
+			if (resetShakerValuesAfterShake)
+			{
+				_originalShakeDuration = ShakeDuration;
+				_originalShakeFixedExposure = ShakeFixedExposure;
+				_originalRemapFixedExposureZero = RemapFixedExposureZero;
+				_originalRemapFixedExposureOne = RemapFixedExposureOne;
+				_originalRelativeFixedExposure = RelativeIntensity;
+			}
+
+			TimescaleMode = timescaleMode;
+			ShakeDuration = duration;
+			ShakeFixedExposure = intensity;
+			RemapFixedExposureZero = remapMin * attenuation;
+			RemapFixedExposureOne = remapMax * attenuation;
+			RelativeIntensity = relativeIntensity;
+			ForwardDirection = forwardDirection;
+
+			Play();
+		}
+
+		/// <summary>
+		/// Resets the target's values
+		/// </summary>
+		protected override void ResetTargetValues()
+		{
+			base.ResetTargetValues();
+			_exposure.fixedExposure.Override(_initialFixedExposure);
+		}
+
+		/// <summary>
+		/// Resets the shaker's values
+		/// </summary>
+		protected override void ResetShakerValues()
+		{
+			base.ResetShakerValues();
+			ShakeDuration = _originalShakeDuration;
+			ShakeFixedExposure = _originalShakeFixedExposure;
+			RemapFixedExposureZero = _originalRemapFixedExposureZero;
+			RemapFixedExposureOne = _originalRemapFixedExposureOne;
+			RelativeIntensity = _originalRelativeFixedExposure;
+		}
+
+		/// <summary>
+		/// Starts listening for events
+		/// </summary>
+		public override void StartListening()
+		{
+			base.StartListening();
+			MMExposureShakeEvent_HDRP.Register(OnExposureShakeEvent);
+		}
+
+		/// <summary>
+		/// Stops listening for events
+		/// </summary>
+		public override void StopListening()
+		{
+			base.StopListening();
+			MMExposureShakeEvent_HDRP.Unregister(OnExposureShakeEvent);
+		}
+		#endif
+	}
+
+	/// <summary>
+	/// An event used to trigger exposure shakes
+	/// </summary>
+	public struct MMExposureShakeEvent_HDRP
+	{
+		static private event Delegate OnEvent;
+		[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)] private static void RuntimeInitialization() { OnEvent = null; }
+		static public void Register(Delegate callback) { OnEvent += callback; }
+		static public void Unregister(Delegate callback) { OnEvent -= callback; }
+		
+		public delegate void Delegate(AnimationCurve fixedExposure, float duration, float remapMin, float remapMax, bool relativeFixedExposure = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false);
+		
+		static public void Trigger(AnimationCurve fixedExposure, float duration, float remapMin, float remapMax, bool relativeFixedExposure = false,
+			float attenuation = 1.0f, MMChannelData channelData = null, bool resetShakerValuesAfterShake = true, bool resetTargetValuesAfterShake = true, 
+			bool forwardDirection = true, TimescaleModes timescaleMode = TimescaleModes.Scaled, bool stop = false, bool restore = false)
+		{
+			OnEvent?.Invoke(fixedExposure, duration, remapMin, remapMax, relativeFixedExposure, attenuation, channelData, resetShakerValuesAfterShake, 
+				resetTargetValuesAfterShake, forwardDirection, timescaleMode, stop, restore);
+		}
+	}
+}

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMExposureShaker_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMFilmGrainShaker_HDRP.cs

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMFilmGrainShaker_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMLensDistortionShaker_HDRP.cs

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMLensDistortionShaker_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMMotionBlurShaker_HDRP.cs

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMMotionBlurShaker_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMPaniniProjectionShaker_HDRP.cs

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMPaniniProjectionShaker_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMVignetteShaker_HDRP.cs

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMVignetteShaker_HDRP.cs.meta

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMWhiteBalanceShaker_HDRP.cs

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

Assets/Extensions/Feel/MMFeedbacks/MMFeedbacksForThirdParty/HDRP/Shakers/MMWhiteBalanceShaker_HDRP.cs.meta

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