Added Feel plugin

Assets/External/Feel.meta

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

Assets/External/Feel/MMFeedbacks.meta

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

Assets/External/Feel/MMFeedbacks/Authorizations.meta

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

Assets/External/Feel/MMFeedbacks/Authorizations/MMFeedbacksAuthorizations.cs

@@ -0,0 +1,589 @@
+using MoreMountains.FeedbacksForThirdParty;
+using MoreMountains.Tools;
+
+namespace MoreMountains.Feedbacks
+{
+	/// <summary>
+	/// Add this class to an empty object in your scene and it will prevent any unchecked feedback in its inspector from playing
+	/// </summary>
+	public partial class MMFeedbacksAuthorizations : MMMonoBehaviour
+	{
+		[MMInspectorGroup("Animation", true, 16)] [MMInspectorButton("ToggleAnimation")]
+		public bool ToggleAnimationButton;
+
+		public bool AnimationParameter = true;
+		public bool AnimatorSpeed = true;
+
+		[MMInspectorGroup("Audio", true, 17)] [MMInspectorButton("ToggleAudio")]
+		public bool ToggleAudioButton;
+
+		public bool AudioFilterDistortion = true;
+		public bool AudioFilterEcho = true;
+		public bool AudioFilterHighPass = true;
+		public bool AudioFilterLowPass = true;
+		public bool AudioFilterReverb = true;
+		public bool AudioMixerSnapshotTransition = true;
+		public bool AudioSource = true;
+		public bool AudioSourcePitch = true;
+		public bool AudioSourceStereoPan = true;
+		public bool AudioSourceVolume = true;
+		public bool MMPlaylist = true;
+		public bool MMSoundManagerAllSoundsControl = true;
+		public bool MMSoundManagerSaveAndLoad = true;
+		public bool MMSoundManagerSound = true;
+		public bool MMSoundManagerSoundControl = true;
+		public bool MMSoundManagerSoundFade = true;
+		public bool MMSoundManagerTrackControl = true;
+		public bool MMSoundManagerTrackFade = true;
+		public bool Sound = true;
+
+		[MMInspectorGroup("Camera", true, 18)] [MMInspectorButton("ToggleCamera")]
+		public bool ToggleCameraButton;
+
+		public bool CameraShake = true;
+		public bool CameraZoom = true;
+		#if MM_CINEMACHINE || MM_CINEMACHINE3
+		public bool CinemachineImpulse = true;
+		public bool CinemachineImpulseClear = true;
+		public bool CinemachineImpulseSource = true;
+		public bool CinemachineTransition = true;
+		#endif
+		public bool ClippingPlanes = true;
+		public bool Fade = true;
+		public bool FieldOfView = true;
+		public bool Flash = true;
+		public bool OrthographicSize = true;
+
+		[MMInspectorGroup("Debug", true, 19)] [MMInspectorButton("ToggleDebug")]
+		public bool ToggleDebugButton;
+
+		public bool Comment = true;
+		public bool Log = true;
+
+		[MMInspectorGroup("Events", true, 20)] [MMInspectorButton("ToggleEvents")]
+		public bool ToggleEventsButton;
+
+		public bool MMGameEvent = true;
+		public bool UnityEvents = true;
+
+		[MMInspectorGroup("GameObject", true, 47)] [MMInspectorButton("ToggleGameObject")]
+		public bool ToggleGameObjectButton;
+
+		public bool Broadcast = true;
+		public bool Collider = true;
+		public bool Collider2D = true;
+		public bool DestroyTargetObject = true;
+		public bool EnableBehaviour = true;
+		public bool FloatController = true;
+		public bool InstantiateObject = true;
+		public bool MMRadioSignal = true;
+		public bool Rigidbody = true;
+		public bool Rigidbody2D = true;
+		public bool SetActive = true;
+
+		
+		#if MOREMOUNTAINS_NICEVIBRATIONS_INSTALLED
+		[MMInspectorGroup("Haptics", true, 22)] [MMInspectorButton("ToggleHaptics")]
+		public bool ToggleHapticsButton;
+
+		public bool HapticClip = true;
+		public bool HapticContinuous = true;
+		public bool HapticControl = true;
+		public bool HapticEmphasis = true;
+		public bool HapticPreset = true;
+		#endif
+
+		[MMInspectorGroup("Light", true, 23)] [MMInspectorButton("ToggleLight")]
+		public bool ToggleLightButton;
+
+		public bool Light = true;
+
+		[MMInspectorGroup("Loop", true, 24)] [MMInspectorButton("ToggleLoop")]
+		public bool ToggleLoopButton;
+
+		public bool Looper = true;
+		public bool LooperStart = true;
+
+		[MMInspectorGroup("Particles", true, 25)] [MMInspectorButton("ToggleParticles")]
+		public bool ToggleParticlesButton;
+
+		public bool ParticlesInstantiation = true;
+		public bool ParticlesPlay = true;
+
+		[MMInspectorGroup("Pause", true, 26)] [MMInspectorButton("TogglePause")]
+		public bool TogglePauseButton;
+
+		public bool HoldingPause = true;
+		public bool Pause = true;
+
+		[MMInspectorGroup("Post Process", true, 27)] [MMInspectorButton("TogglePostProcess")]
+		public bool TogglePostProcessButton;
+
+		public bool Bloom = true;
+		public bool ChromaticAberration = true;
+		public bool ColorGrading = true;
+		public bool DepthOfField = true;
+		public bool GlobalPPVolumeAutoBlend = true;
+		public bool LensDistortion = true;
+		public bool PPMovingFilter = true;
+		public bool Vignette = true;
+
+		[MMInspectorGroup("Flicker", true, 28)] [MMInspectorButton("ToggleFlicker")]
+		public bool ToggleFlickerButton;
+
+		public bool Flicker = true;
+		public bool Fog = true;
+		public bool Material = true;
+		public bool MMBlink = true;
+		public bool ShaderGlobal = true;
+		public bool ShaderController = true;
+		public bool Skybox = true;
+		public bool SpriteRenderer = true;
+		public bool TextureOffset = true;
+		public bool TextureScale = true;
+
+		[MMInspectorGroup("Scene", true, 29)] [MMInspectorButton("ToggleScene")]
+		public bool ToggleSceneButton;
+
+		public bool LoadScene = true;
+		public bool UnloadScene = true;
+
+		[MMInspectorGroup("Time", true, 31)] [MMInspectorButton("ToggleTime")]
+		public bool ToggleTimeButton;
+
+		public bool FreezeFrame = true;
+		public bool TimescaleModifier = true;
+
+		[MMInspectorGroup("Transform", true, 32)] [MMInspectorButton("ToggleTransform")]
+		public bool ToggleTransformButton;
+
+		public bool Destination = true;
+		public bool Position = true;
+		public bool PositionShake = true;
+		public bool RotatePositionAround = true;
+		public bool Rotation = true;
+		public bool RotationShake = true;
+		public bool Scale = true;
+		public bool ScaleShake = true;
+		public bool SquashAndStretch = true;
+		public bool Wiggle = true;
+
+		[MMInspectorGroup("UI", true, 33)] [MMInspectorButton("ToggleUI")]
+		public bool ToggleUiButton;
+
+		public bool CanvasGroup = true;
+		public bool CanvasGroupBlocksRaycasts = true;
+		public bool FloatingText = true;
+		public bool Graphic = true;
+		public bool GraphicCrossFade = true;
+		public bool Image = true;
+		public bool ImageAlpha = true;
+		public bool ImageFill = true;
+		public bool ImageRaycastTarget = true;
+		public bool ImageTextureOffset = true;
+		public bool ImageTextureScale = true;
+		public bool RectTransformAnchor = true;
+		public bool RectTransformOffset = true;
+		public bool RectTransformPivot = true;
+		public bool RectTransformSizeDelta = true;
+		public bool Text = true;
+		public bool TextColor = true;
+		public bool TextFontSize = true;
+		public bool VideoPlayer = true;
+		
+		[MMInspectorGroup("TextMesh Pro", true, 30)] [MMInspectorButton("ToggleTextMeshPro")]
+		public bool ToggleTextMeshProButton;
+
+		#if MM_UGUI2
+		public bool TMPAlpha = true;
+		public bool TMPCharacterSpacing = true;
+		public bool TMPColor = true;
+		public bool TMPCountTo = true;
+		public bool TMPDilate = true;
+		public bool TMPFontSize = true;
+		public bool TMPLineSpacing = true;
+		public bool TMPOutlineColor = true;
+		public bool TMPOutlineWidth = true;
+		public bool TMPParagraphSpacing = true;
+		public bool TMPSoftness = true;
+		public bool TMPText = true;
+		public bool TMPTextReveal = true;
+		public bool TMPWordSpacing = true;
+		#endif
+		
+		#region ToggleMethods
+		
+		private void ToggleAnimation()
+		{
+			AnimationParameter = !AnimationParameter;
+			AnimatorSpeed = !AnimatorSpeed;
+		}
+
+		private void ToggleAudio()
+		{
+			AudioFilterDistortion = !AudioFilterDistortion;
+			AudioFilterEcho = !AudioFilterEcho;
+			AudioFilterHighPass = !AudioFilterHighPass;
+			AudioFilterLowPass = !AudioFilterLowPass;
+			AudioFilterReverb = !AudioFilterReverb;
+			AudioMixerSnapshotTransition = !AudioMixerSnapshotTransition;
+			AudioSource = !AudioSource;
+			AudioSourcePitch = !AudioSourcePitch;
+			AudioSourceStereoPan = !AudioSourceStereoPan;
+			AudioSourceVolume = !AudioSourceVolume;
+			MMPlaylist = !MMPlaylist;
+			MMSoundManagerAllSoundsControl = !MMSoundManagerAllSoundsControl;
+			MMSoundManagerSaveAndLoad = !MMSoundManagerSaveAndLoad;
+			MMSoundManagerSound = !MMSoundManagerSound;
+			MMSoundManagerSoundControl = !MMSoundManagerSoundControl;
+			MMSoundManagerSoundFade = !MMSoundManagerSoundFade;
+			MMSoundManagerTrackControl = !MMSoundManagerTrackControl;
+			MMSoundManagerTrackFade = !MMSoundManagerTrackFade;
+			Sound = !Sound;
+		}
+
+		private void ToggleCamera()
+		{
+			CameraShake = !CameraShake;
+			CameraZoom = !CameraZoom;
+			#if MM_CINEMACHINE || MM_CINEMACHINE3
+			CinemachineImpulse = !CinemachineImpulse;
+			CinemachineImpulseClear = !CinemachineImpulseClear;
+			CinemachineImpulseSource = !CinemachineImpulseSource;
+			CinemachineTransition = !CinemachineTransition;
+			#endif
+			ClippingPlanes = !ClippingPlanes;
+			Fade = !Fade;
+			FieldOfView = !FieldOfView;
+			Flash = !Flash;
+			OrthographicSize = !OrthographicSize;
+		}
+
+		private void ToggleDebug()
+		{
+			Comment = !Comment;
+			Log = !Log;
+		}
+
+		private void ToggleEvents()
+		{
+			MMGameEvent = !MMGameEvent;
+			UnityEvents = !UnityEvents;
+		}
+
+		private void ToggleGameObject()
+		{
+			Broadcast = !Broadcast;
+			Collider = !Collider;
+			Collider2D = !Collider2D;
+			DestroyTargetObject = !DestroyTargetObject;
+			EnableBehaviour = !EnableBehaviour;
+			FloatController = !FloatController;
+			InstantiateObject = !InstantiateObject;
+			MMRadioSignal = !MMRadioSignal;
+			Rigidbody = !Rigidbody;
+			Rigidbody2D = !Rigidbody2D;
+			SetActive = !SetActive;
+		}
+		
+		#if MOREMOUNTAINS_NICEVIBRATIONS_INSTALLED
+		private void ToggleHaptics()
+		{
+			HapticClip = !HapticClip;
+			HapticContinuous = !HapticContinuous;
+			HapticControl = !HapticControl;
+			HapticEmphasis = !HapticEmphasis;
+			HapticPreset = !HapticPreset;
+		}
+		#endif
+
+		private void ToggleLight()
+		{
+			Light = !Light;
+		}
+
+		private void ToggleLoop()
+		{
+			Looper = !Looper;
+			LooperStart = !LooperStart;
+		}
+
+		private void ToggleParticles()
+		{
+			ParticlesInstantiation = !ParticlesInstantiation;
+			ParticlesPlay = !ParticlesPlay;
+		}
+
+		private void TogglePause()
+		{
+			HoldingPause = !HoldingPause;
+			Pause = !Pause;
+		}
+
+		#if MM_POSTPROCESSING
+		private void TogglePostProcess()
+		{
+			Bloom = !Bloom;
+			ChromaticAberration = !ChromaticAberration;
+			ColorGrading = !ColorGrading;
+			DepthOfField = !DepthOfField;
+			GlobalPPVolumeAutoBlend = !GlobalPPVolumeAutoBlend;
+			LensDistortion = !LensDistortion;
+			PPMovingFilter = !PPMovingFilter;
+			Vignette = !Vignette;
+		}
+		#endif
+
+		private void ToggleFlicker()
+		{
+			Flicker = !Flicker;
+			Fog = !Fog;
+			Material = !Material;
+			MMBlink = !MMBlink;
+			ShaderGlobal = !ShaderGlobal;
+			ShaderController = !ShaderController;
+			Skybox = !Skybox;
+			SpriteRenderer = !SpriteRenderer;
+			TextureOffset = !TextureOffset;
+			TextureScale = !TextureScale;
+		}
+
+		private void ToggleScene()
+		{
+			LoadScene = !LoadScene;
+			UnloadScene = !UnloadScene;
+		}
+
+		private void ToggleTime()
+		{
+			FreezeFrame = !FreezeFrame;
+			TimescaleModifier = !TimescaleModifier;
+		}
+
+		private void ToggleTransform()
+		{
+			Destination = !Destination;
+			Position = !Position;
+			PositionShake = !PositionShake;
+			RotatePositionAround = !RotatePositionAround;
+			Rotation = !Rotation;
+			RotationShake = !RotationShake;
+			Scale = !Scale;
+			ScaleShake = !ScaleShake;
+			SquashAndStretch = !SquashAndStretch;
+			Wiggle = !Wiggle;
+		}
+
+		private void ToggleUI()
+		{
+			CanvasGroup = !CanvasGroup;
+			CanvasGroupBlocksRaycasts = !CanvasGroupBlocksRaycasts;
+			FloatingText = !FloatingText;
+			Graphic = !Graphic;
+			GraphicCrossFade = !GraphicCrossFade;
+			Image = !Image;
+			ImageAlpha = !ImageAlpha;
+			ImageFill = !ImageFill;
+			ImageRaycastTarget = !ImageRaycastTarget;
+			ImageTextureOffset = !ImageTextureOffset;
+			ImageTextureScale = !ImageTextureScale;
+			RectTransformAnchor = !RectTransformAnchor;
+			RectTransformOffset = !RectTransformOffset;
+			RectTransformPivot = !RectTransformPivot;
+			RectTransformSizeDelta = !RectTransformSizeDelta;
+			Text = !Text;
+			TextColor = !TextColor;
+			TextFontSize = !TextFontSize;
+			VideoPlayer = !VideoPlayer;
+		}
+		
+		#if MM_UGUI2
+		private void ToggleTextMeshPro()
+		{
+			TMPAlpha = !TMPAlpha;
+			TMPCharacterSpacing = !TMPCharacterSpacing;
+			TMPColor = !TMPColor;
+			TMPCountTo = !TMPCountTo;
+			TMPDilate = !TMPDilate;
+			TMPFontSize = !TMPFontSize;
+			TMPLineSpacing = !TMPLineSpacing;
+			TMPOutlineColor = !TMPOutlineColor;
+			TMPOutlineWidth = !TMPOutlineWidth;
+			TMPParagraphSpacing = !TMPParagraphSpacing;
+			TMPSoftness = !TMPSoftness;
+			TMPText = !TMPText;
+			TMPTextReveal = !TMPTextReveal;
+			TMPWordSpacing = !TMPWordSpacing;
+		}
+		#endif
+		
+		#endregion
+
+		private void Start()
+		{
+			MMF_Animation.FeedbackTypeAuthorized = AnimationParameter;
+			MMF_AnimatorSpeed.FeedbackTypeAuthorized = AnimatorSpeed;
+			MMF_AudioFilterDistortion.FeedbackTypeAuthorized = AudioFilterDistortion;
+			MMF_AudioFilterEcho.FeedbackTypeAuthorized = AudioFilterEcho;
+			MMF_AudioFilterHighPass.FeedbackTypeAuthorized = AudioFilterHighPass;
+			MMF_AudioFilterLowPass.FeedbackTypeAuthorized = AudioFilterLowPass;
+			MMF_AudioFilterReverb.FeedbackTypeAuthorized = AudioFilterReverb;
+			MMF_AudioMixerSnapshotTransition.FeedbackTypeAuthorized = AudioMixerSnapshotTransition;
+			MMF_AudioSource.FeedbackTypeAuthorized = AudioSource;
+			MMF_AudioSourcePitch.FeedbackTypeAuthorized = AudioSourcePitch;
+			MMF_AudioSourceStereoPan.FeedbackTypeAuthorized = AudioSourceStereoPan;
+			MMF_AudioSourceVolume.FeedbackTypeAuthorized = AudioSourceVolume;
+			MMF_Playlist.FeedbackTypeAuthorized = MMPlaylist;
+			MMF_MMSoundManagerAllSoundsControl.FeedbackTypeAuthorized = MMSoundManagerAllSoundsControl;
+			MMF_MMSoundManagerSaveLoad.FeedbackTypeAuthorized = MMSoundManagerSaveAndLoad;
+			MMF_MMSoundManagerSound.FeedbackTypeAuthorized = MMSoundManagerSound;
+			MMF_MMSoundManagerSoundControl.FeedbackTypeAuthorized = MMSoundManagerSoundControl;
+			MMF_MMSoundManagerSoundFade.FeedbackTypeAuthorized = MMSoundManagerSoundFade;
+			MMF_MMSoundManagerTrackControl.FeedbackTypeAuthorized = MMSoundManagerTrackControl;
+			MMF_MMSoundManagerTrackFade.FeedbackTypeAuthorized = MMSoundManagerTrackFade;
+			MMF_Sound.FeedbackTypeAuthorized = Sound;
+			MMF_CameraShake.FeedbackTypeAuthorized = CameraShake;
+			MMF_CameraZoom.FeedbackTypeAuthorized = CameraZoom;
+		  
+			#if MM_CINEMACHINE || MM_CINEMACHINE3
+			MMF_CinemachineImpulse.FeedbackTypeAuthorized = CinemachineImpulse;
+			MMF_CinemachineImpulseClear.FeedbackTypeAuthorized = CinemachineImpulseClear;
+			MMF_CinemachineImpulseSource.FeedbackTypeAuthorized = CinemachineImpulseSource;
+			MMF_CinemachineTransition.FeedbackTypeAuthorized = CinemachineTransition;
+			#endif
+		  
+			MMF_CameraClippingPlanes.FeedbackTypeAuthorized = ClippingPlanes;
+			MMF_CameraFieldOfView.FeedbackTypeAuthorized = FieldOfView;
+			MMF_CameraOrthographicSize.FeedbackTypeAuthorized = OrthographicSize;
+			MMF_DebugComment.FeedbackTypeAuthorized = Comment;
+			MMF_DebugLog.FeedbackTypeAuthorized = Log;
+			MMF_MMGameEvent.FeedbackTypeAuthorized = MMGameEvent;
+			MMF_Events.FeedbackTypeAuthorized = UnityEvents;
+			MMF_Broadcast.FeedbackTypeAuthorized = Broadcast;
+			MMF_Collider.FeedbackTypeAuthorized = Collider;
+			MMF_Destroy.FeedbackTypeAuthorized = DestroyTargetObject;
+			MMF_Enable.FeedbackTypeAuthorized = EnableBehaviour;
+			MMF_FloatController.FeedbackTypeAuthorized = FloatController;
+			MMF_InstantiateObject.FeedbackTypeAuthorized = InstantiateObject;
+			MMF_RadioSignal.FeedbackTypeAuthorized = MMRadioSignal;
+			MMF_Rigidbody.FeedbackTypeAuthorized = Rigidbody;
+			MMF_SetActive.FeedbackTypeAuthorized = SetActive;
+			
+			#if MM_PHYSICS2D
+			MMF_Collider2D.FeedbackTypeAuthorized = Collider2D;
+			MMF_Rigidbody2D.FeedbackTypeAuthorized = Rigidbody2D;
+			#endif
+		  
+			#if MOREMOUNTAINS_NICEVIBRATIONS_INSTALLED
+			MMF_Haptics.FeedbackTypeAuthorized = HapticClip;
+			MMF_NVContinuous.FeedbackTypeAuthorized = HapticContinuous;
+			MMF_NVControl.FeedbackTypeAuthorized = HapticControl;
+			MMF_NVEmphasis.FeedbackTypeAuthorized = HapticEmphasis;
+			MMF_NVPreset.FeedbackTypeAuthorized = HapticPreset;
+			#endif
+  
+			MMF_Light.FeedbackTypeAuthorized = Light;
+			MMF_Looper.FeedbackTypeAuthorized = Looper;
+			MMF_LooperStart.FeedbackTypeAuthorized = LooperStart;
+			MMF_ParticlesInstantiation.FeedbackTypeAuthorized = ParticlesInstantiation;
+			MMF_Particles.FeedbackTypeAuthorized = ParticlesPlay;
+			MMF_HoldingPause.FeedbackTypeAuthorized = HoldingPause;
+			MMF_Pause.FeedbackTypeAuthorized = Pause;
+			MMF_Flicker.FeedbackTypeAuthorized = Flicker;
+			MMF_Fog.FeedbackTypeAuthorized = Fog;
+			MMF_Material.FeedbackTypeAuthorized = Material;
+			MMF_Blink.FeedbackTypeAuthorized = MMBlink;
+			MMF_ShaderGlobal.FeedbackTypeAuthorized = ShaderGlobal;
+			MMF_Skybox.FeedbackTypeAuthorized = Skybox;
+			MMF_SpriteRenderer.FeedbackTypeAuthorized = SpriteRenderer;
+			MMF_TextureOffset.FeedbackTypeAuthorized = TextureOffset;
+			MMF_TextureScale.FeedbackTypeAuthorized = TextureScale;
+			MMF_LoadScene.FeedbackTypeAuthorized = LoadScene;
+			MMF_UnloadScene.FeedbackTypeAuthorized = UnloadScene;
+			MMF_FreezeFrame.FeedbackTypeAuthorized = FreezeFrame;
+			MMF_TimescaleModifier.FeedbackTypeAuthorized = TimescaleModifier;
+			MMF_DestinationTransform.FeedbackTypeAuthorized = Destination;
+			MMF_Position.FeedbackTypeAuthorized = Position;
+			MMF_PositionShake.FeedbackTypeAuthorized = PositionShake;
+			MMF_RotatePositionAround.FeedbackTypeAuthorized = RotatePositionAround;
+			MMF_Rotation.FeedbackTypeAuthorized = Rotation;
+			MMF_RotationShake.FeedbackTypeAuthorized = RotationShake;
+			MMF_Scale.FeedbackTypeAuthorized = Scale;
+			MMF_ScaleShake.FeedbackTypeAuthorized = ScaleShake;
+			MMF_SquashAndStretch.FeedbackTypeAuthorized = SquashAndStretch;
+			MMF_Wiggle.FeedbackTypeAuthorized = Wiggle;
+			MMF_CanvasGroup.FeedbackTypeAuthorized = CanvasGroup;
+			MMF_CanvasGroupBlocksRaycasts.FeedbackTypeAuthorized = CanvasGroupBlocksRaycasts;
+			  
+			MMF_FloatingText.FeedbackTypeAuthorized = FloatingText;
+			MMF_RectTransformAnchor.FeedbackTypeAuthorized = RectTransformAnchor;
+			MMF_RectTransformOffset.FeedbackTypeAuthorized = RectTransformOffset;
+			MMF_RectTransformPivot.FeedbackTypeAuthorized = RectTransformPivot;
+			MMF_RectTransformSizeDelta.FeedbackTypeAuthorized = RectTransformSizeDelta;
+			MMF_VideoPlayer.FeedbackTypeAuthorized = VideoPlayer;
+			
+			#if MM_UI
+			MMF_ShaderController.FeedbackTypeAuthorized = ShaderController;
+			MMF_Graphic.FeedbackTypeAuthorized = Graphic;
+			MMF_GraphicCrossFade.FeedbackTypeAuthorized = GraphicCrossFade;
+			MMF_Image.FeedbackTypeAuthorized = Image;
+			MMF_ImageAlpha.FeedbackTypeAuthorized = ImageAlpha;
+			MMF_ImageFill.FeedbackTypeAuthorized = ImageFill;
+			MMF_ImageRaycastTarget.FeedbackTypeAuthorized = ImageRaycastTarget;
+			MMF_ImageTextureOffset.FeedbackTypeAuthorized = ImageTextureOffset;
+			MMF_ImageTextureScale.FeedbackTypeAuthorized = ImageTextureScale;
+			MMF_Text.FeedbackTypeAuthorized = Text;
+			MMF_TextColor.FeedbackTypeAuthorized = TextColor;
+			MMF_TextFontSize.FeedbackTypeAuthorized = TextFontSize;
+			MMF_Fade.FeedbackTypeAuthorized = Fade;
+			MMF_Flash.FeedbackTypeAuthorized = Flash;
+			#endif
+			
+			#if MM_POSTPROCESSING
+			MMF_Bloom.FeedbackTypeAuthorized = Bloom;
+			MMF_ChromaticAberration.FeedbackTypeAuthorized = ChromaticAberration;
+			MMF_ColorGrading.FeedbackTypeAuthorized = ColorGrading;
+			MMF_DepthOfField.FeedbackTypeAuthorized = DepthOfField;
+			MMF_GlobalPPVolumeAutoBlend.FeedbackTypeAuthorized = GlobalPPVolumeAutoBlend;
+			MMF_LensDistortion.FeedbackTypeAuthorized = LensDistortion;
+			MMF_Vignette.FeedbackTypeAuthorized = Vignette;
+			MMF_PPMovingFilter.FeedbackTypeAuthorized = PPMovingFilter;
+			#endif
+			
+			#if MM_HDRP
+			MMF_Bloom_HDRP.FeedbackTypeAuthorized = Bloom;
+			MMF_ChromaticAberration_HDRP.FeedbackTypeAuthorized = ChromaticAberration;
+			MMF_LensDistortion_HDRP.FeedbackTypeAuthorized = LensDistortion;
+			MMF_ColorAdjustments_HDRP.FeedbackTypeAuthorized = ColorGrading;
+			MMF_LensDistortion_HDRP.FeedbackTypeAuthorized = LensDistortion;
+			MMF_Vignette_HDRP.FeedbackTypeAuthorized = Vignette;
+			#endif
+			
+			#if MM_URP
+			MMF_Bloom_URP.FeedbackTypeAuthorized = Bloom;
+			MMF_ChromaticAberration_URP.FeedbackTypeAuthorized = ChromaticAberration;
+			MMF_LensDistortion_URP.FeedbackTypeAuthorized = LensDistortion;
+			MMF_ColorAdjustments_URP.FeedbackTypeAuthorized = ColorGrading;
+			MMF_LensDistortion_URP.FeedbackTypeAuthorized = LensDistortion;
+			MMF_Vignette_URP.FeedbackTypeAuthorized = Vignette;
+			#endif
+			
+			#if MM_UGUI2
+			MMF_TMPAlpha.FeedbackTypeAuthorized = TMPAlpha;
+			MMF_TMPCharacterSpacing.FeedbackTypeAuthorized = TMPCharacterSpacing;
+			MMF_TMPColor.FeedbackTypeAuthorized = TMPColor;
+			MMF_TMPCountTo.FeedbackTypeAuthorized = TMPCountTo;
+			MMF_TMPDilate.FeedbackTypeAuthorized = TMPDilate;
+			MMF_TMPFontSize.FeedbackTypeAuthorized = TMPFontSize;
+			MMF_TMPLineSpacing.FeedbackTypeAuthorized = TMPLineSpacing;
+			MMF_TMPOutlineColor.FeedbackTypeAuthorized = TMPOutlineColor;
+			MMF_TMPOutlineWidth.FeedbackTypeAuthorized = TMPOutlineWidth;
+			MMF_TMPParagraphSpacing.FeedbackTypeAuthorized = TMPParagraphSpacing;
+			MMF_TMPSoftness.FeedbackTypeAuthorized = TMPSoftness;
+			MMF_TMPText.FeedbackTypeAuthorized = TMPText;
+			MMF_TMPTextReveal.FeedbackTypeAuthorized = TMPTextReveal;
+			#endif
+		}
+	}
+
+}

Assets/External/Feel/MMFeedbacks/Authorizations/MMFeedbacksAuthorizations.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: be090172b5d6e3149b78c6da8b309d47
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Authorizations/MMFeedbacksAuthorizations.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Authorizations/MoreMountains.Feedbacks.Authorizations.asmref

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

Assets/External/Feel/MMFeedbacks/Authorizations/MoreMountains.Feedbacks.Authorizations.asmref.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 9a55bdc9c20a8d640a83b706174628dd
+AssemblyDefinitionReferenceImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Authorizations/MoreMountains.Feedbacks.Authorizations.asmref
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor.meta

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

Assets/External/Feel/MMFeedbacks/Editor/Core.meta

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

Assets/External/Feel/MMFeedbacks/Editor/Core/AttributeDrawers.cs

@@ -0,0 +1,250 @@
+using MoreMountains.Tools;
+using UnityEngine;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace MoreMountains.Feedbacks
+{
+	[CustomPropertyDrawer(typeof(MMFEnumConditionAttribute))]
+	public class MMFEnumConditionAttributeDrawer : PropertyDrawer
+	{
+		public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+		{
+			MMFEnumConditionAttribute enumConditionAttribute = (MMFEnumConditionAttribute)attribute;
+			bool enabled = GetConditionAttributeResult(enumConditionAttribute, property);
+			bool previouslyEnabled = GUI.enabled;
+			GUI.enabled = enabled;
+			if (!enumConditionAttribute.Hidden || enabled)
+			{
+				EditorGUI.PropertyField(position, property, label, true);
+			}
+			GUI.enabled = previouslyEnabled;
+		}
+
+		private bool GetConditionAttributeResult(MMFEnumConditionAttribute enumConditionAttribute, SerializedProperty property)
+		{
+			bool enabled = true;
+			string propertyPath = property.propertyPath;
+			string conditionPath = propertyPath.Replace(property.name, enumConditionAttribute.ConditionEnum);
+			SerializedProperty sourcePropertyValue = property.serializedObject.FindProperty(conditionPath);
+
+			if ((sourcePropertyValue != null) && (sourcePropertyValue.propertyType == SerializedPropertyType.Enum))
+			{
+				int currentEnum = sourcePropertyValue.enumValueIndex;
+				enabled = enumConditionAttribute.ContainsBitFlag(currentEnum);
+			}
+			else
+			{
+				Debug.LogWarning("No matching boolean found for ConditionAttribute in object: " + enumConditionAttribute.ConditionEnum);
+			}
+
+			return enabled;
+		}
+
+		public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+		{
+			MMFEnumConditionAttribute enumConditionAttribute = (MMFEnumConditionAttribute)attribute;
+			bool enabled = GetConditionAttributeResult(enumConditionAttribute, property);
+            
+			if (!enumConditionAttribute.Hidden || enabled)
+			{
+				return EditorGUI.GetPropertyHeight(property, label);
+			}
+			else
+			{
+				return -EditorGUIUtility.standardVerticalSpacing;
+			}
+		}
+	}
+
+	// original implementation by http://www.brechtos.com/hiding-or-disabling-inspector-properties-using-propertydrawers-within-unity-5/
+	[CustomPropertyDrawer(typeof(MMFConditionAttribute))]
+	public class MMFConditionAttributeDrawer : PropertyDrawer
+	{
+		public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+		{
+			MMFConditionAttribute conditionAttribute = (MMFConditionAttribute)attribute;
+			bool enabled = GetConditionAttributeResult(conditionAttribute, property);
+			bool previouslyEnabled = GUI.enabled;
+			GUI.enabled = conditionAttribute.Negative ? !enabled : enabled;
+			if (ShouldDisplay(conditionAttribute, enabled))
+			{
+				EditorGUI.PropertyField(position, property, label, true);
+			}
+			GUI.enabled = previouslyEnabled;
+		}
+
+		private bool GetConditionAttributeResult(MMFConditionAttribute conditionAttribute, SerializedProperty property)
+		{
+			bool enabled = true;
+			string propertyPath = property.propertyPath;
+			string conditionPath = propertyPath.Replace(property.name, conditionAttribute.ConditionBoolean);
+			SerializedProperty sourcePropertyValue = property.serializedObject.FindProperty(conditionPath);
+
+			if (sourcePropertyValue != null)
+			{
+				enabled = sourcePropertyValue.boolValue;
+			}
+			else
+			{
+				Debug.LogWarning("No matching boolean found for ConditionAttribute in object: " + conditionAttribute.ConditionBoolean);
+			}
+
+			return enabled;
+		}
+		
+		private bool ShouldDisplay(MMFConditionAttribute conditionAttribute, bool result)
+		{
+			bool shouldDisplay = !conditionAttribute.Hidden || result;
+			if (conditionAttribute.Negative)
+			{
+				shouldDisplay = !shouldDisplay;
+			}
+			return shouldDisplay;
+		}
+
+		public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+		{
+			MMFConditionAttribute conditionAttribute = (MMFConditionAttribute)attribute;
+			bool enabled = GetConditionAttributeResult(conditionAttribute, property);
+
+			if (ShouldDisplay(conditionAttribute, enabled))
+			{
+				return EditorGUI.GetPropertyHeight(property, label);
+			}
+			else
+			{
+				/*int multiplier = 1; // this multiplier fixes issues in differing property spacing between MMFeedbacks and MMF_Player
+				if (property.depth > 0)
+				{
+					//multiplier = property.depth;
+				}*/
+				return -EditorGUIUtility.standardVerticalSpacing /** multiplier*/; 
+			}
+		}
+	}
+
+	[CustomPropertyDrawer(typeof(MMFHiddenAttribute))]
+	public class MMFHiddenAttributeDrawer : PropertyDrawer
+	{
+		public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+		{
+			return 0f;
+		}
+
+		public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+		{
+
+		}
+	}
+
+	[CustomPropertyDrawer(typeof(MMFInformationAttribute))]
+	/// <summary>
+	/// This class allows the display of a message box (warning, info, error...) next to a property (before or after)
+	/// </summary>
+	public class MMFInformationAttributeDrawer : PropertyDrawer
+	{
+		// determines the space after the help box, the space before the text box, and the width of the help box icon
+		const int spaceBeforeTheTextBox = 5;
+		const int spaceAfterTheTextBox = 10;
+		const int iconWidth = 55;
+
+		MMFInformationAttribute informationAttribute { get { return ((MMFInformationAttribute)attribute); } }
+
+		/// <summary>
+		/// OnGUI, displays the property and the textbox in the specified order
+		/// </summary>
+		/// <param name="rect">Rect.</param>
+		/// <param name="prop">Property.</param>
+		/// <param name="label">Label.</param>
+		public override void OnGUI(Rect rect, SerializedProperty prop, GUIContent label)
+		{
+			if (MMMenuHelp.HelpEnabled)
+			{
+				EditorStyles.helpBox.richText = true;
+				Rect helpPosition = rect;
+				Rect textFieldPosition = rect;
+
+				if (!informationAttribute.MessageAfterProperty)
+				{
+					// we position the message before the property
+					helpPosition.height = DetermineTextboxHeight(informationAttribute.Message);
+
+					textFieldPosition.y += helpPosition.height + spaceBeforeTheTextBox;
+					textFieldPosition.height = GetPropertyHeight(prop, label);
+				}
+				else
+				{
+					// we position the property first, then the message
+					textFieldPosition.height = GetPropertyHeight(prop, label);
+
+					helpPosition.height = DetermineTextboxHeight(informationAttribute.Message);
+					// we add the complete property height (property + helpbox, as overridden in this very script), and substract both to get just the property
+					helpPosition.y += GetPropertyHeight(prop, label) - DetermineTextboxHeight(informationAttribute.Message) - spaceAfterTheTextBox;
+				}
+
+				EditorGUI.HelpBox(helpPosition, informationAttribute.Message, informationAttribute.Type);
+				EditorGUI.PropertyField(textFieldPosition, prop, label, true);
+			}
+			else
+			{
+				Rect textFieldPosition = rect;
+				textFieldPosition.height = GetPropertyHeight(prop, label);
+				EditorGUI.PropertyField(textFieldPosition, prop, label, true);
+			}
+		}
+
+		/// <summary>
+		/// Returns the complete height of the whole block (property + help text)
+		/// </summary>
+		/// <returns>The block height.</returns>
+		/// <param name="property">Property.</param>
+		/// <param name="label">Label.</param>
+		public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+		{
+			if (MMMenuHelp.HelpEnabled)
+			{
+				return EditorGUI.GetPropertyHeight(property) + DetermineTextboxHeight(informationAttribute.Message) + spaceAfterTheTextBox + spaceBeforeTheTextBox;
+			}
+			else
+			{
+				return EditorGUI.GetPropertyHeight(property);
+			}
+		}
+
+		/// <summary>
+		/// Determines the height of the textbox.
+		/// </summary>
+		/// <returns>The textbox height.</returns>
+		/// <param name="message">Message.</param>
+		protected virtual float DetermineTextboxHeight(string message)
+		{
+			GUIStyle style = new GUIStyle(EditorStyles.helpBox);
+			style.richText = true;
+
+			float newHeight = style.CalcHeight(new GUIContent(message), EditorGUIUtility.currentViewWidth - iconWidth);
+			return newHeight;
+		}
+	}
+
+	[CustomPropertyDrawer(typeof(MMFReadOnlyAttribute))]
+	public class MMFReadOnlyAttributeDrawer : PropertyDrawer
+	{
+		// Necessary since some properties tend to collapse smaller than their content
+		public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+		{
+			return EditorGUI.GetPropertyHeight(property, label, true);
+		}
+
+		// Draw a disabled property field
+		public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+		{
+			GUI.enabled = false; // Disable fields
+			EditorGUI.PropertyField(position, property, label, true);
+			GUI.enabled = true; // Enable fields
+		}
+	}
+
+
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/AttributeDrawers.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: bb4df52d2a954374b913a14cc5d474d4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/AttributeDrawers.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/MMF_PlayerConfiguration.cs

@@ -0,0 +1,53 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace MoreMountains.Feedbacks
+{
+	/// <summary>
+	/// An asset to store copy information, as well as global feedback settings.
+	/// It requires that one (and only one) MMFeedbacksConfiguration asset be created and stored in a Resources folder.
+	/// That's already done when installing MMFeedbacks.
+	/// </summary>
+	[CreateAssetMenu(menuName = "MoreMountains/MMFeedbacks/Configuration", fileName = "MMFeedbacksConfiguration")]
+	public class MMF_PlayerConfiguration : ScriptableObject
+	{
+		private static MMF_PlayerConfiguration _instance;
+		private static bool _instantiated;
+        
+		/// <summary>
+		/// Singleton pattern
+		/// </summary>
+		public static MMF_PlayerConfiguration Instance
+		{
+			get
+			{
+				if (_instantiated)
+				{
+					return _instance;
+				}
+                
+				string assetName = typeof(MMF_PlayerConfiguration).Name;
+                
+				MMF_PlayerConfiguration loadedAsset = Resources.Load<MMF_PlayerConfiguration>("MMF_PlayerConfiguration");
+				_instance = loadedAsset;    
+				_instantiated = true;
+                
+				return _instance;
+			}
+		}
+        
+		[Header("Help settings")]
+		/// if this is true, inspector tips will be shown for MMFeedbacks
+		public bool ShowInspectorTips = true;
+		/// if this is true, when exiting play mode when KeepPlaymodeChanges is active, it'll turn off automatically, otherwise it'll remain on
+		public bool AutoDisableKeepPlaymodeChanges = true;
+		/// if this is true, when exiting play mode when KeepPlaymodeChanges is active, it'll turn off automatically, otherwise it'll remain on
+		public bool InspectorGroupsExpandedByDefault = true;
+
+
+        
+		private void OnDestroy(){ _instantiated = false; }
+	}    
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/MMF_PlayerConfiguration.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 8bcf466015f0b254893ff0208fccf90f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/MMF_PlayerConfiguration.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/MMF_PlayerCopy.cs

@@ -0,0 +1,145 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using System.Linq;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace MoreMountains.Feedbacks
+{
+	/// <summary>
+	/// A helper class to copy and paste feedback properties
+	/// </summary>
+	static class MMF_PlayerCopy
+	{
+		static public System.Type Type { get; private set; }
+		public static readonly List<MMF_Feedback> CopiedFeedbacks = new List<MMF_Feedback>();
+		public static readonly Dictionary<MMF_Player, List<MMF_Feedback>> RuntimeChanges = new Dictionary<MMF_Player, List<MMF_Feedback>>();
+
+		static string[] IgnoreList = new string[]
+		{
+			"m_ObjectHideFlags",
+			"m_CorrespondingSourceObject",
+			"m_PrefabInstance",
+			"m_PrefabAsset",
+			"m_GameObject",
+			"m_Enabled",
+			"m_EditorHideFlags",
+			"m_Script",
+			"m_Name",
+			"m_EditorClassIdentifier"
+		};
+		
+		static MMF_PlayerCopy()
+		{
+			EditorApplication.playModeStateChanged += ModeChanged;
+		}
+
+		private static void ModeChanged(PlayModeStateChange playModeState)
+		{
+			switch (playModeState)
+			{
+				case PlayModeStateChange.ExitingPlayMode:
+					StoreRuntimeChanges();
+					break;
+        
+				case PlayModeStateChange.EnteredEditMode:
+					ApplyRuntimeChanges();
+					break;
+			}
+		}
+
+		private static void StoreRuntimeChanges()
+		{
+			foreach (MMF_Player player in Object.FindObjectsByType<MMF_Player>(FindObjectsInactive.Include, FindObjectsSortMode.None).Where(p => p.KeepPlayModeChanges))
+			{
+				MMF_PlayerCopy.StoreRuntimeChanges(player);
+			}
+		}
+
+		private static void ApplyRuntimeChanges()
+		{
+			foreach (MMF_Player player in Object.FindObjectsByType<MMF_Player>(FindObjectsInactive.Include, FindObjectsSortMode.None).Where(MMF_PlayerCopy.RuntimeChanges.ContainsKey))
+			{
+				MMF_PlayerCopy.ApplyRuntimeChanges(player);
+			}
+		}
+
+		static public bool HasCopy()
+		{
+			return CopiedFeedbacks != null && CopiedFeedbacks.Count == 1;
+		}
+
+		static public bool HasMultipleCopies()
+		{
+			return CopiedFeedbacks != null && CopiedFeedbacks.Count > 1;
+		}
+
+		static public void Copy(MMF_Feedback feedback)
+		{
+			Type feedbackType = feedback.GetType();
+			MMF_Feedback newFeedback = (MMF_Feedback)Activator.CreateInstance(feedbackType);
+			EditorUtility.CopySerializedManagedFieldsOnly(feedback, newFeedback);
+			CopiedFeedbacks.Clear();
+			CopiedFeedbacks.Add(newFeedback);
+		}
+        
+		static public void CopyAll(MMF_Player sourceFeedbacks)
+		{
+			CopiedFeedbacks.Clear();
+			foreach (MMF_Feedback feedback in sourceFeedbacks.FeedbacksList)
+			{
+				Type feedbackType = feedback.GetType();
+				MMF_Feedback newFeedback = (MMF_Feedback)Activator.CreateInstance(feedbackType);
+				EditorUtility.CopySerializedManagedFieldsOnly(feedback, newFeedback);
+				CopiedFeedbacks.Add(newFeedback);    
+			}
+		}
+
+		// Multiple Copy ----------------------------------------------------------
+
+		static public void PasteAll(MMF_PlayerEditorUITK targetEditor)
+		{
+			foreach (MMF_Feedback feedback in MMF_PlayerCopy.CopiedFeedbacks)
+			{
+				targetEditor.TargetMmfPlayer.AddFeedback(feedback);
+			}
+			CopiedFeedbacks.Clear();
+		}
+		
+		// Runtime Changes
+
+		static public void StoreRuntimeChanges(MMF_Player player)
+		{
+			RuntimeChanges[player] = new List<MMF_Feedback>();
+			foreach (MMF_Feedback feedback in player.FeedbacksList)
+			{
+				Type feedbackType = feedback.GetType();
+				MMF_Feedback newFeedback = (MMF_Feedback)Activator.CreateInstance(feedbackType);
+				EditorUtility.CopySerializedManagedFieldsOnly(feedback, newFeedback);
+				RuntimeChanges[player].Add(newFeedback);    
+			}
+		}
+
+		static public void ApplyRuntimeChanges(MMF_Player player)
+		{
+			SerializedObject playerSerialized = new SerializedObject(player);
+			playerSerialized.Update();
+			Undo.RecordObject(player, "Replace all feedbacks");
+			player.FeedbacksList.Clear();
+			foreach (MMF_Feedback feedback in MMF_PlayerCopy.RuntimeChanges[player])
+			{
+				player.AddFeedback(feedback, true);
+			}
+			playerSerialized.ApplyModifiedProperties();
+			PrefabUtility.RecordPrefabInstancePropertyModifications(player);
+			if (MMF_PlayerConfiguration.Instance.AutoDisableKeepPlaymodeChanges)
+			{
+				playerSerialized.Update();
+				player.KeepPlayModeChanges = false;    
+				playerSerialized.ApplyModifiedProperties();
+			}
+			player.RefreshCache();
+		}
+	}
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/MMF_PlayerCopy.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 5f7bf459716aa484c8db5d1ef3ef8049
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/MMF_PlayerCopy.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/MMFeedbackStyling.cs

@@ -0,0 +1,351 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace MoreMountains.Feedbacks
+{
+	/// <summary>
+	/// A class used to regroup most of the styling options for the MMFeedback editors
+	/// </summary>
+	public static class MMFeedbackStyling
+	{
+		public static readonly GUIStyle SmallTickbox = new GUIStyle("ShurikenToggle");
+
+		static readonly Color _splitterdark = new Color(0.12f, 0.12f, 0.12f, 1.333f);
+		static readonly Color _splitterlight = new Color(0.6f, 0.6f, 0.6f, 1.333f);
+		public static Color Splitter { get { return EditorGUIUtility.isProSkin ? _splitterdark : _splitterlight; } }
+
+		static readonly Color _headerbackgrounddark = new Color(0.1f, 0.1f, 0.1f, 0.2f);
+		static readonly Color _headerbackgroundlight = new Color(1f, 1f, 1f, 0.4f);
+		public static Color HeaderBackground { get { return EditorGUIUtility.isProSkin ? _headerbackgrounddark : _headerbackgroundlight; } }
+
+		static readonly Color _reorderdark = new Color(1f, 1f, 1f, 0.2f);
+		static readonly Color _reorderlight = new Color(0.1f, 0.1f, 0.1f, 0.2f);
+		public static Color Reorder { get { return EditorGUIUtility.isProSkin ? _reorderdark : _reorderlight; } }
+
+		static readonly Color _timingDark = new Color(1f, 1f, 1f, 0.5f);
+		static readonly Color _timingLight = new Color(0f, 0f, 0f, 0.5f);
+        
+		static readonly Texture2D _paneoptionsicondark;
+		static readonly Texture2D _paneoptionsiconlight;
+		public static Texture2D PaneOptionsIcon { get { return EditorGUIUtility.isProSkin ? _paneoptionsicondark : _paneoptionsiconlight; } }
+
+		static MMFeedbackStyling()
+		{
+			_paneoptionsicondark = (Texture2D)EditorGUIUtility.Load("Builtin Skins/DarkSkin/Images/pane options.png");
+			_paneoptionsiconlight = (Texture2D)EditorGUIUtility.Load("Builtin Skins/LightSkin/Images/pane options.png");
+		}
+
+		private static GUIStyle _timingStyle = new GUIStyle();
+
+		/// <summary>
+		/// Simply drow a splitter line and a title bellow
+		/// </summary>
+		static public void DrawSection(string title)
+		{
+			EditorGUILayout.Space();
+
+			DrawSplitter();
+
+			EditorGUILayout.Space();
+			EditorGUILayout.Space();
+
+			EditorGUILayout.LabelField(title, EditorStyles.boldLabel);
+		}
+
+		/// <summary>
+		/// Draw a separator line
+		/// </summary>
+		static public void DrawSplitter()
+		{
+			// Helper to draw a separator line
+
+			var rect = GUILayoutUtility.GetRect(1f, 1f);
+
+			rect.xMin = 0f;
+			rect.width += 4f;
+
+			if (Event.current.type != EventType.Repaint)
+				return;
+
+			EditorGUI.DrawRect(rect, Splitter);
+		}
+
+		/// <summary>
+		/// Draw a header similar to the one used for the post-process stack
+		/// </summary>
+		static public Rect DrawSimpleHeader(ref bool expanded, ref bool activeField, string title)
+		{
+			var e = Event.current;
+
+			// Initialize Rects
+
+			var backgroundRect = GUILayoutUtility.GetRect(1f, 17f);
+            
+			var reorderRect = backgroundRect;
+			reorderRect.xMin -= 8f;
+			reorderRect.y += 5f;
+			reorderRect.width = 9f;
+			reorderRect.height = 9f;
+
+			var labelRect = backgroundRect;
+			labelRect.xMin += 32f;
+			labelRect.xMax -= 20f;
+
+			var foldoutRect = backgroundRect;
+			foldoutRect.y += 1f;
+			foldoutRect.width = 13f;
+			foldoutRect.height = 13f;
+
+			var toggleRect = backgroundRect;
+			toggleRect.x += 16f;
+			toggleRect.y += 2f;
+			toggleRect.width = 13f;
+			toggleRect.height = 13f;
+
+			var menuIcon = PaneOptionsIcon;
+			var menuRect = new Rect(labelRect.xMax + 4f, labelRect.y + 4f, menuIcon.width, menuIcon.height);
+            
+			// Background rect should be full-width
+			backgroundRect.xMin = 0f;
+			backgroundRect.width += 4f;
+
+			// Background
+			EditorGUI.DrawRect(backgroundRect, HeaderBackground);
+
+			// Foldout
+			expanded = GUI.Toggle(foldoutRect, expanded, GUIContent.none, EditorStyles.foldout);
+
+			// Title
+			EditorGUI.LabelField(labelRect, title, EditorStyles.boldLabel);
+
+			// Active checkbox
+			activeField = GUI.Toggle(toggleRect, activeField, GUIContent.none, SmallTickbox);
+            
+			// Handle events
+            
+			if (e.type == EventType.MouseDown && labelRect.Contains(e.mousePosition) && e.button == 0)
+			{
+				expanded = !expanded;
+				e.Use();
+			}
+
+			return backgroundRect;
+		}
+
+		/// <summary>
+		/// Draw a header similar to the one used for the post-process stack
+		/// </summary>
+		static public Rect DrawHeader(ref bool expanded, ref bool activeField, string title, Color feedbackColor, System.Action<GenericMenu> fillGenericMenu, 
+			float startedAt, float duration, float totalDuration, MMFeedbackTiming timing, bool pause, MMFeedbacks host)
+		{
+			float thisTime = timing.TimescaleMode == TimescaleModes.Scaled ? Time.time : Time.unscaledTime;
+			float thisDeltaTime = timing.TimescaleMode == TimescaleModes.Scaled ? Time.deltaTime : Time.unscaledDeltaTime;
+            
+			var e = Event.current;
+
+			// Initialize Rects
+			var backgroundRect = GUILayoutUtility.GetRect(1f, 17f);
+
+			var progressRect = GUILayoutUtility.GetRect(1f, 2f);
+
+			var offset = 4f;
+
+			var reorderRect = backgroundRect;
+			reorderRect.xMin -= 8f;
+			reorderRect.y += 5f;
+			reorderRect.width = 9f;
+			reorderRect.height = 9f;
+
+			var labelRect = backgroundRect;
+			labelRect.xMin += 32f + offset;
+			labelRect.xMax -= 20f;
+
+			var foldoutRect = backgroundRect;
+			foldoutRect.y += 1f;
+			foldoutRect.xMin += offset;
+			foldoutRect.width = 13f;
+			foldoutRect.height = 13f;
+
+			var toggleRect = backgroundRect;
+			toggleRect.x += 16f;
+			toggleRect.xMin += offset;
+			toggleRect.y += 2f;
+			toggleRect.width = 13f;
+			toggleRect.height = 13f;
+
+			var menuIcon = PaneOptionsIcon;
+			var menuRect = new Rect(labelRect.xMax + 4f, labelRect.y + 4f, menuIcon.width, menuIcon.height);
+
+			_timingStyle.normal.textColor = EditorGUIUtility.isProSkin ? _timingDark : _timingLight;
+			_timingStyle.alignment = TextAnchor.MiddleRight;
+
+			var colorRect = new Rect(labelRect.xMin, labelRect.yMin, 5f, 17f);
+			colorRect.xMin = 0f;
+			colorRect.xMax = 5f;
+			EditorGUI.DrawRect(colorRect, feedbackColor);
+
+			// Background rect should be full-width
+			backgroundRect.xMin = 0f;
+			backgroundRect.width += 4f;
+
+			progressRect.xMin = 0f;
+			progressRect.width += 4f;
+
+			Color headerBackgroundColor = Color.white;
+			// Background - if color is white we draw the default color
+			if (!pause)
+			{
+				headerBackgroundColor = HeaderBackground;
+			}
+			else
+			{
+				headerBackgroundColor = feedbackColor;
+			}
+			EditorGUI.DrawRect(backgroundRect, headerBackgroundColor);
+            
+			// Foldout
+			expanded = GUI.Toggle(foldoutRect, expanded, GUIContent.none, EditorStyles.foldout);
+
+			// Title ----------------------------------------------------------------------------------------------------
+
+			using (new EditorGUI.DisabledScope(!activeField))
+			{
+				EditorGUI.LabelField(labelRect, title, EditorStyles.boldLabel);
+			}
+
+			// Direction ----------------------------------------------------------------------------------------------
+
+			float directionRectWidth = 70f;
+			var directionRect = new Rect(labelRect.xMax - directionRectWidth, labelRect.yMin, directionRectWidth, 17f);
+			directionRect.xMin = labelRect.xMax - directionRectWidth;
+			directionRect.xMax = labelRect.xMax;
+
+			if (timing.MMFeedbacksDirectionCondition == MMFeedbackTiming.MMFeedbacksDirectionConditions.OnlyWhenBackwards)
+			{
+				Texture arrowUpIcon = Resources.Load("FeelArrowUp") as Texture;
+				GUIContent directionIcon = new GUIContent(arrowUpIcon);
+				EditorGUI.LabelField(directionRect, directionIcon);
+			}
+
+			if (timing.MMFeedbacksDirectionCondition == MMFeedbackTiming.MMFeedbacksDirectionConditions.OnlyWhenForwards)
+			{
+				Texture arrowDownIcon = Resources.Load("FeelArrowDown") as Texture;
+				GUIContent directionIcon = new GUIContent(arrowDownIcon);
+				EditorGUI.LabelField(directionRect, directionIcon);
+			}
+
+			// Time -----------------------------------------------------------------------------------------------------
+
+			string timingInfo = "";
+			bool displayTotal = false;
+			if (host.DisplayFullDurationDetails)
+			{
+				if (timing.InitialDelay != 0)
+				{
+					timingInfo += host.ApplyTimeMultiplier(timing.InitialDelay).ToString() + "s + ";
+					displayTotal = true;
+				}
+
+				timingInfo += duration.ToString("F2") + "s";
+
+				if (timing.NumberOfRepeats != 0)
+				{
+					float delayBetweenRepeats = host.ApplyTimeMultiplier(timing.DelayBetweenRepeats); 
+                    
+					timingInfo += " + "+ timing.NumberOfRepeats.ToString() + " x ";
+					if (timing.DelayBetweenRepeats > 0)
+					{
+						timingInfo += "(";
+					}
+					timingInfo += duration + "s";
+					if (timing.DelayBetweenRepeats > 0)
+					{
+						timingInfo += " + " + host.ApplyTimeMultiplier(timing.DelayBetweenRepeats) + "s )";
+					}
+					displayTotal = true;
+				}
+
+				if (displayTotal)
+				{
+					timingInfo += " = " + totalDuration.ToString("F2") + "s";
+				}
+			}
+			else
+			{
+				timingInfo = totalDuration.ToString("F2") + "s";
+			}
+
+			//"[ 2s + 3 x (4s + 1s) ]"
+
+			float timingRectWidth = 150f;
+			var timingRect = new Rect(labelRect.xMax - timingRectWidth, labelRect.yMin, timingRectWidth, 17f);
+			timingRect.xMin = labelRect.xMax - timingRectWidth;
+			timingRect.xMax = labelRect.xMax;
+			EditorGUI.LabelField(timingRect, timingInfo, _timingStyle);
+
+			// Progress bar
+			if (totalDuration == 0f)
+			{
+				totalDuration = 0.1f;
+			}
+
+			if (startedAt == 0f)
+			{
+				startedAt = 0.001f;
+			}
+			if ((startedAt > 0f) && (thisTime - startedAt < totalDuration + 0.05f))
+			{
+				float fullWidth = progressRect.width;
+				if (totalDuration == 0f) { totalDuration = 0.1f; }
+				float percent = ((thisTime - startedAt) / totalDuration) * 100f;
+				progressRect.width = percent * fullWidth / 100f;
+				Color barColor = Color.white;
+				if (thisTime - startedAt > totalDuration)
+				{
+					barColor = Color.yellow;
+				}
+				EditorGUI.DrawRect(progressRect, barColor);
+			}
+			else
+			{
+				EditorGUI.DrawRect(progressRect, headerBackgroundColor);
+			}
+
+			// Active checkbox
+			activeField = GUI.Toggle(toggleRect, activeField, GUIContent.none, SmallTickbox);
+
+			// Dropdown menu icon
+			GUI.DrawTexture(menuRect, menuIcon);
+
+			for(int i = 0; i < 3; i++)
+			{
+				Rect r = reorderRect;
+				r.height = 1;
+				r.y = reorderRect.y + reorderRect.height * (i / 3.0f);
+				EditorGUI.DrawRect(r, Reorder);
+			}
+
+
+			// Handle events
+
+			if (e.type == EventType.MouseDown)
+			{
+				if (menuRect.Contains(e.mousePosition))
+				{
+					var menu = new GenericMenu();
+					fillGenericMenu(menu);
+					menu.DropDown(new Rect(new Vector2(menuRect.x, menuRect.yMax), Vector2.zero));
+					e.Use();
+				}
+			}
+            
+			if (e.type == EventType.MouseDown && labelRect.Contains(e.mousePosition) && e.button == 0)
+			{
+				expanded = !expanded;
+				e.Use();
+			}
+
+			return backgroundRect;
+		}
+	}
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/MMFeedbackStyling.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 74bba79889819c645bedf0dcd6d6cfa3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/MMFeedbackStyling.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/MMFeedbacksColors.cs

@@ -0,0 +1,396 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace MoreMountains.Feedbacks
+{
+	/// <summary>
+	/// Color helpers
+	/// </summary>
+	public static class MMFeedbacksColors
+	{
+		// via https://gist.github.com/LotteMakesStuff/f7ce43f11e545a151b95b5e87f76304c
+		// NOTE: The follwing color names come from the CSS3 specification, Section 4.3 Extended Color Keywords
+		// http://www.w3.org/TR/css3-color/#svg-color
+
+		public static readonly Color AliceBlue = new Color32(240, 248, 255, 255);
+		public static readonly Color AntiqueWhite = new Color32(250, 235, 215, 255);
+		public static readonly Color Aqua = new Color32(0, 255, 255, 255);
+		public static readonly Color Aquamarine = new Color32(127, 255, 212, 255);
+		public static readonly Color Azure = new Color32(240, 255, 255, 255);
+		public static readonly Color Beige = new Color32(245, 245, 220, 255);
+		public static readonly Color Bisque = new Color32(255, 228, 196, 255);
+		public static readonly Color Black = new Color32(0, 0, 0, 255);
+		public static readonly Color BlanchedAlmond = new Color32(255, 235, 205, 255);
+		public static readonly Color Blue = new Color32(0, 0, 255, 255);
+		public static readonly Color BlueViolet = new Color32(138, 43, 226, 255);
+		public static readonly Color Brown = new Color32(165, 42, 42, 255);
+		public static readonly Color Burlywood = new Color32(222, 184, 135, 255);
+		public static readonly Color CadetBlue = new Color32(95, 158, 160, 255);
+		public static readonly Color Chartreuse = new Color32(127, 255, 0, 255);
+		public static readonly Color Chocolate = new Color32(210, 105, 30, 255);
+		public static readonly Color Coral = new Color32(255, 127, 80, 255);
+		public static readonly Color CornflowerBlue = new Color32(100, 149, 237, 255);
+		public static readonly Color Cornsilk = new Color32(255, 248, 220, 255);
+		public static readonly Color Crimson = new Color32(220, 20, 60, 255);
+		public static readonly Color Cyan = new Color32(0, 255, 255, 255);
+		public static readonly Color DarkBlue = new Color32(0, 0, 139, 255);
+		public static readonly Color DarkCyan = new Color32(0, 139, 139, 255);
+		public static readonly Color DarkGoldenrod = new Color32(184, 134, 11, 255);
+		public static readonly Color DarkGray = new Color32(169, 169, 169, 255);
+		public static readonly Color DarkGreen = new Color32(0, 100, 0, 255);
+		public static readonly Color DarkKhaki = new Color32(189, 183, 107, 255);
+		public static readonly Color DarkMagenta = new Color32(139, 0, 139, 255);
+		public static readonly Color DarkOliveGreen = new Color32(85, 107, 47, 255);
+		public static readonly Color DarkOrange = new Color32(255, 140, 0, 255);
+		public static readonly Color DarkOrchid = new Color32(153, 50, 204, 255);
+		public static readonly Color DarkRed = new Color32(139, 0, 0, 255);
+		public static readonly Color DarkSalmon = new Color32(233, 150, 122, 255);
+		public static readonly Color DarkSeaGreen = new Color32(143, 188, 143, 255);
+		public static readonly Color DarkSlateBlue = new Color32(72, 61, 139, 255);
+		public static readonly Color DarkSlateGray = new Color32(47, 79, 79, 255);
+		public static readonly Color DarkTurquoise = new Color32(0, 206, 209, 255);
+		public static readonly Color DarkViolet = new Color32(148, 0, 211, 255);
+		public static readonly Color DeepPink = new Color32(255, 20, 147, 255);
+		public static readonly Color DeepSkyBlue = new Color32(0, 191, 255, 255);
+		public static readonly Color DimGray = new Color32(105, 105, 105, 255);
+		public static readonly Color DodgerBlue = new Color32(30, 144, 255, 255);
+		public static readonly Color FireBrick = new Color32(178, 34, 34, 255);
+		public static readonly Color FloralWhite = new Color32(255, 250, 240, 255);
+		public static readonly Color ForestGreen = new Color32(34, 139, 34, 255);
+		public static readonly Color Fuchsia = new Color32(255, 0, 255, 255);
+		public static readonly Color Gainsboro = new Color32(220, 220, 220, 255);
+		public static readonly Color GhostWhite = new Color32(248, 248, 255, 255);
+		public static readonly Color Gold = new Color32(255, 215, 0, 255);
+		public static readonly Color Goldenrod = new Color32(218, 165, 32, 255);
+		public static readonly Color Gray = new Color32(128, 128, 128, 255);
+		public static readonly Color Green = new Color32(0, 128, 0, 255);
+		public static readonly Color GreenYellow = new Color32(173, 255, 47, 255);
+		public static readonly Color Honeydew = new Color32(240, 255, 240, 255);
+		public static readonly Color HotPink = new Color32(255, 105, 180, 255);
+		public static readonly Color IndianRed = new Color32(205, 92, 92, 255);
+		public static readonly Color Indigo = new Color32(75, 0, 130, 255);
+		public static readonly Color Ivory = new Color32(255, 255, 240, 255);
+		public static readonly Color Khaki = new Color32(240, 230, 140, 255);
+		public static readonly Color Lavender = new Color32(230, 230, 250, 255);
+		public static readonly Color Lavenderblush = new Color32(255, 240, 245, 255);
+		public static readonly Color LawnGreen = new Color32(124, 252, 0, 255);
+		public static readonly Color LemonChiffon = new Color32(255, 250, 205, 255);
+		public static readonly Color LightBlue = new Color32(173, 216, 230, 255);
+		public static readonly Color LightCoral = new Color32(240, 128, 128, 255);
+		public static readonly Color LightCyan = new Color32(224, 255, 255, 255);
+		public static readonly Color LightGoldenodYellow = new Color32(250, 250, 210, 255);
+		public static readonly Color LightGray = new Color32(211, 211, 211, 255);
+		public static readonly Color LightGreen = new Color32(144, 238, 144, 255);
+		public static readonly Color LightPink = new Color32(255, 182, 193, 255);
+		public static readonly Color LightSalmon = new Color32(255, 160, 122, 255);
+		public static readonly Color LightSeaGreen = new Color32(32, 178, 170, 255);
+		public static readonly Color LightSkyBlue = new Color32(135, 206, 250, 255);
+		public static readonly Color LightSlateGray = new Color32(119, 136, 153, 255);
+		public static readonly Color LightSteelBlue = new Color32(176, 196, 222, 255);
+		public static readonly Color LightYellow = new Color32(255, 255, 224, 255);
+		public static readonly Color Lime = new Color32(0, 255, 0, 255);
+		public static readonly Color LimeGreen = new Color32(50, 205, 50, 255);
+		public static readonly Color Linen = new Color32(250, 240, 230, 255);
+		public static readonly Color Magenta = new Color32(255, 0, 255, 255);
+		public static readonly Color Maroon = new Color32(128, 0, 0, 255);
+		public static readonly Color MediumAquamarine = new Color32(102, 205, 170, 255);
+		public static readonly Color MediumBlue = new Color32(0, 0, 205, 255);
+		public static readonly Color MediumOrchid = new Color32(186, 85, 211, 255);
+		public static readonly Color MediumPurple = new Color32(147, 112, 219, 255);
+		public static readonly Color MediumSeaGreen = new Color32(60, 179, 113, 255);
+		public static readonly Color MediumSlateBlue = new Color32(123, 104, 238, 255);
+		public static readonly Color MediumSpringGreen = new Color32(0, 250, 154, 255);
+		public static readonly Color MediumTurquoise = new Color32(72, 209, 204, 255);
+		public static readonly Color MediumVioletRed = new Color32(199, 21, 133, 255);
+		public static readonly Color MidnightBlue = new Color32(25, 25, 112, 255);
+		public static readonly Color Mintcream = new Color32(245, 255, 250, 255);
+		public static readonly Color MistyRose = new Color32(255, 228, 225, 255);
+		public static readonly Color Moccasin = new Color32(255, 228, 181, 255);
+		public static readonly Color NavajoWhite = new Color32(255, 222, 173, 255);
+		public static readonly Color Navy = new Color32(0, 0, 128, 255);
+		public static readonly Color OldLace = new Color32(253, 245, 230, 255);
+		public static readonly Color Olive = new Color32(128, 128, 0, 255);
+		public static readonly Color Olivedrab = new Color32(107, 142, 35, 255);
+		public static readonly Color Orange = new Color32(255, 165, 0, 255);
+		public static readonly Color Orangered = new Color32(255, 69, 0, 255);
+		public static readonly Color Orchid = new Color32(218, 112, 214, 255);
+		public static readonly Color PaleGoldenrod = new Color32(238, 232, 170, 255);
+		public static readonly Color PaleGreen = new Color32(152, 251, 152, 255);
+		public static readonly Color PaleTurquoise = new Color32(175, 238, 238, 255);
+		public static readonly Color PaleVioletred = new Color32(219, 112, 147, 255);
+		public static readonly Color PapayaWhip = new Color32(255, 239, 213, 255);
+		public static readonly Color PeachPuff = new Color32(255, 218, 185, 255);
+		public static readonly Color Peru = new Color32(205, 133, 63, 255);
+		public static readonly Color Pink = new Color32(255, 192, 203, 255);
+		public static readonly Color Plum = new Color32(221, 160, 221, 255);
+		public static readonly Color PowderBlue = new Color32(176, 224, 230, 255);
+		public static readonly Color Purple = new Color32(128, 0, 128, 255);
+		public static readonly Color Red = new Color32(255, 0, 0, 255);
+		public static readonly Color RosyBrown = new Color32(188, 143, 143, 255);
+		public static readonly Color RoyalBlue = new Color32(65, 105, 225, 255);
+		public static readonly Color SaddleBrown = new Color32(139, 69, 19, 255);
+		public static readonly Color Salmon = new Color32(250, 128, 114, 255);
+		public static readonly Color SandyBrown = new Color32(244, 164, 96, 255);
+		public static readonly Color SeaGreen = new Color32(46, 139, 87, 255);
+		public static readonly Color Seashell = new Color32(255, 245, 238, 255);
+		public static readonly Color Sienna = new Color32(160, 82, 45, 255);
+		public static readonly Color Silver = new Color32(192, 192, 192, 255);
+		public static readonly Color SkyBlue = new Color32(135, 206, 235, 255);
+		public static readonly Color SlateBlue = new Color32(106, 90, 205, 255);
+		public static readonly Color SlateGray = new Color32(112, 128, 144, 255);
+		public static readonly Color Snow = new Color32(255, 250, 250, 255);
+		public static readonly Color SpringGreen = new Color32(0, 255, 127, 255);
+		public static readonly Color SteelBlue = new Color32(70, 130, 180, 255);
+		public static readonly Color Tan = new Color32(210, 180, 140, 255);
+		public static readonly Color Teal = new Color32(0, 128, 128, 255);
+		public static readonly Color Thistle = new Color32(216, 191, 216, 255);
+		public static readonly Color Tomato = new Color32(255, 99, 71, 255);
+		public static readonly Color Turquoise = new Color32(64, 224, 208, 255);
+		public static readonly Color Violet = new Color32(238, 130, 238, 255);
+		public static readonly Color Wheat = new Color32(245, 222, 179, 255);
+		public static readonly Color White = new Color32(255, 255, 255, 255);
+		public static readonly Color WhiteSmoke = new Color32(245, 245, 245, 255);
+		public static readonly Color Yellow = new Color32(255, 255, 0, 255);
+		public static readonly Color YellowGreen = new Color32(154, 205, 50, 255);
+		public static readonly Color ReunoYellow = new Color32(255, 196, 0, 255);
+		public static readonly Color BestRed = new Color32(255, 24, 0, 255);
+
+		public static Dictionary<int, Color> ColorDictionary;
+
+		public static Color RandomColor()
+		{
+			int random = Random.Range(0, 140);
+			return GetColorAt(random);
+		}
+
+		public static Color GetColorAt(int index)
+		{
+			if (ColorDictionary == null)
+			{
+				InitializeDictionary();
+			}
+	        
+			if (index < ColorDictionary.Count)
+			{
+				return ColorDictionary[index];
+			}
+			else
+			{
+				return Color.white;
+			}
+		}
+
+		public static void InitializeDictionary()
+		{
+			ColorDictionary = new Dictionary<int, Color>
+			{
+				{ 0, AliceBlue },
+				{ 1, AntiqueWhite },
+				{ 2, Aqua },
+				{ 3, Aquamarine },
+				{ 4, Azure },
+				{ 5, Beige },
+				{ 6, Bisque },
+				{ 7, Black },
+				{ 8, BlanchedAlmond },
+				{ 9, Blue },
+				{ 10, BlueViolet },
+				{ 11, Brown },
+				{ 12, Burlywood },
+				{ 13, CadetBlue },
+				{ 14, Chartreuse },
+				{ 15, Chocolate },
+				{ 16, Coral },
+				{ 17, CornflowerBlue },
+				{ 18, Cornsilk },
+				{ 19, Crimson },
+				{ 20, Cyan },
+				{ 21, DarkBlue },
+				{ 22, DarkCyan },
+				{ 23, DarkGoldenrod },
+				{ 24, DarkGray },
+				{ 25, DarkGreen },
+				{ 26, DarkKhaki },
+				{ 27, DarkMagenta },
+				{ 28, DarkOliveGreen },
+				{ 29, DarkOrange },
+				{ 30, DarkOrchid },
+				{ 31, DarkRed },
+				{ 32, DarkSalmon },
+				{ 33, DarkSeaGreen },
+				{ 34, DarkSlateBlue },
+				{ 35, DarkSlateGray },
+				{ 36, DarkTurquoise },
+				{ 37, DarkViolet },
+				{ 38, DeepPink },
+				{ 39, DeepSkyBlue },
+				{ 40, DimGray },
+				{ 41, DodgerBlue },
+				{ 42, FireBrick },
+				{ 43, FloralWhite },
+				{ 44, ForestGreen },
+				{ 45, Fuchsia },
+				{ 46, Gainsboro },
+				{ 47, GhostWhite },
+				{ 48, Gold },
+				{ 49, Goldenrod },
+				{ 50, Gray },
+				{ 51, Green },
+				{ 52, GreenYellow },
+				{ 53, Honeydew },
+				{ 54, HotPink },
+				{ 55, IndianRed },
+				{ 56, Indigo },
+				{ 57, Ivory },
+				{ 58, Khaki },
+				{ 59, Lavender },
+				{ 60, Lavenderblush },
+				{ 61, LawnGreen },
+				{ 62, LemonChiffon },
+				{ 63, LightBlue },
+				{ 64, LightCoral },
+				{ 65, LightCyan },
+				{ 66, LightGoldenodYellow },
+				{ 67, LightGray },
+				{ 68, LightGreen },
+				{ 69, LightPink },
+				{ 70, LightSalmon },
+				{ 71, LightSeaGreen },
+				{ 72, LightSkyBlue },
+				{ 73, LightSlateGray },
+				{ 74, LightSteelBlue },
+				{ 75, LightYellow },
+				{ 76, Lime },
+				{ 77, LimeGreen },
+				{ 78, Linen },
+				{ 79, Magenta },
+				{ 80, Maroon },
+				{ 81, MediumAquamarine },
+				{ 82, MediumBlue },
+				{ 83, MediumOrchid },
+				{ 84, MediumPurple },
+				{ 85, MediumSeaGreen },
+				{ 86, MediumSlateBlue },
+				{ 87, MediumSpringGreen },
+				{ 88, MediumTurquoise },
+				{ 89, MediumVioletRed },
+				{ 90, MidnightBlue },
+				{ 91, Mintcream },
+				{ 92, MistyRose },
+				{ 93, Moccasin },
+				{ 94, NavajoWhite },
+				{ 95, Navy },
+				{ 96, OldLace },
+				{ 97, Olive },
+				{ 98, Olivedrab },
+				{ 99, Orange },
+				{ 100, Orangered },
+				{ 101, Orchid },
+				{ 102, PaleGoldenrod },
+				{ 103, PaleGreen },
+				{ 104, PaleTurquoise },
+				{ 105, PaleVioletred },
+				{ 106, PapayaWhip },
+				{ 107, PeachPuff },
+				{ 108, Peru },
+				{ 109, Pink },
+				{ 110, Plum },
+				{ 111, PowderBlue },
+				{ 112, Purple },
+				{ 113, Red },
+				{ 114, RosyBrown },
+				{ 115, RoyalBlue },
+				{ 116, SaddleBrown },
+				{ 117, Salmon },
+				{ 118, SandyBrown },
+				{ 119, SeaGreen },
+				{ 120, Seashell },
+				{ 121, Sienna },
+				{ 122, Silver },
+				{ 123, SkyBlue },
+				{ 124, SlateBlue },
+				{ 125, SlateGray },
+				{ 126, Snow },
+				{ 127, SpringGreen },
+				{ 128, SteelBlue },
+				{ 129, Tan },
+				{ 130, Teal },
+				{ 131, Thistle },
+				{ 132, Tomato },
+				{ 133, Turquoise },
+				{ 134, Violet },
+				{ 135, Wheat },
+				{ 136, White },
+				{ 137, WhiteSmoke },
+				{ 138, Yellow },
+				{ 139, YellowGreen },
+				{ 140, ReunoYellow },
+				{ 141, BestRed }
+			};
+		}
+
+		/// <summary>
+		/// Returns a random color between the two min/max specified
+		/// </summary>
+		/// <param name="color"></param>
+		/// <param name="min"></param>
+		/// <param name="max"></param>
+		/// <returns></returns>
+		public static Color MMRandomColor(this Color color, Color min, Color max)
+		{
+			Color c = new Color()
+			{
+				r = UnityEngine.Random.Range(min.r, max.r),
+				g = UnityEngine.Random.Range(min.g, max.g),
+				b = UnityEngine.Random.Range(min.b, max.b),
+				a = UnityEngine.Random.Range(min.a, max.a)
+			};
+
+			return c;
+		}
+
+
+		/// <summary>
+		/// Tint : Uses HSV color conversions, keeps the original values, multiplies alpha
+		/// Multiply : The whole color, including alpha, is multiplied over the original 
+		/// Replace : completely replaces the original with the target color
+		/// ReplaceKeepAlpha : color is replaced but the original alpha channel is ignored
+		/// Add : target color gets added (including its alpha)
+		/// </summary>
+		public enum ColoringMode { Tint, Multiply, Replace, ReplaceKeepAlpha, Add }
+
+		public static Color MMColorize(this Color originalColor, Color targetColor, ColoringMode coloringMode, float lerpAmount = 1.0f)
+		{
+			Color resultColor = Color.white;
+			switch (coloringMode)
+			{
+				case ColoringMode.Tint:
+				{
+					float s_h, s_s, s_v, t_h, t_s, t_v;
+					Color.RGBToHSV(originalColor, out s_h, out s_s, out s_v);
+					Color.RGBToHSV(targetColor, out t_h, out t_s, out t_v);
+					resultColor = Color.HSVToRGB(t_h, t_s, s_v * t_v);
+					resultColor.a = originalColor.a * targetColor.a;
+				}
+					break;
+				case ColoringMode.Multiply:
+					resultColor = originalColor * targetColor;
+					break;
+				case ColoringMode.Replace:
+					resultColor = targetColor;
+					break;
+				case ColoringMode.ReplaceKeepAlpha:
+					resultColor = targetColor;
+					resultColor.a = originalColor.a;
+					break;
+				case ColoringMode.Add:
+					resultColor = originalColor + targetColor;
+					break;
+				default:
+					break;
+			}
+			return Color.Lerp(originalColor, resultColor, lerpAmount);
+		}
+	}
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/MMFeedbacksColors.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 822282e53ae1ea84d9795a45c89280db
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/MMFeedbacksColors.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/MMFeedbacksConfiguration.cs

@@ -0,0 +1,51 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace MoreMountains.Feedbacks
+{
+	/// <summary>
+	/// An asset to store copy information, as well as global feedback settings.
+	/// It requires that one (and only one) MMFeedbacksConfiguration asset be created and stored in a Resources folder.
+	/// That's already done when installing MMFeedbacks.
+	/// </summary>
+	[CreateAssetMenu(menuName = "MoreMountains/MMFeedbacks/Configuration", fileName = "MMFeedbacksConfiguration")]
+	public class MMFeedbacksConfiguration : ScriptableObject
+	{
+		private static MMFeedbacksConfiguration _instance;
+		private static bool _instantiated;
+        
+		/// <summary>
+		/// Singleton pattern
+		/// </summary>
+		public static MMFeedbacksConfiguration Instance
+		{
+			get
+			{
+				if (_instantiated)
+				{
+					return _instance;
+				}
+                
+				string assetName = typeof(MMFeedbacksConfiguration).Name;
+                
+				MMFeedbacksConfiguration loadedAsset = Resources.Load<MMFeedbacksConfiguration>("MMFeedbacksConfiguration");
+				_instantiated = true;
+				_instance = loadedAsset;
+                
+				return _instance;
+			}
+		}
+
+		[Header("Debug")]
+		/// storage for copy/paste
+		public MMFeedbacks _mmFeedbacks;
+        
+		[Header("Help settings")]
+		/// if this is true, inspector tips will be shown for MMFeedbacks
+		public bool ShowInspectorTips = true;
+        
+		private void OnDestroy(){ _instantiated = false; }
+	}    
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/MMFeedbacksConfiguration.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 00bf1cad26d9e9342b90f463840caf08
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/MMFeedbacksConfiguration.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/MMFeedbacksEditor.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using MoreMountains.Tools;
+using UnityEditor;
+using UnityEngine;
+
+namespace MoreMountains.Feedbacks
+{
+	/// <summary>
+	/// A custom editor displaying a foldable list of MMFeedbacks, a dropdown to add more, as well as test buttons to test your feedbacks at runtime
+	/// </summary>
+	[CustomEditor(typeof(MMFeedbacks))]
+	public class MMFeedbacksEditor : Editor
+	{
+		/// <summary>
+		/// Draws the inspector, complete with helpbox, init mode selection, list of feedbacks, feedback selection and test buttons 
+		/// </summary>
+		public override void OnInspectorGUI()
+		{
+			
+				EditorGUILayout.HelpBox("The MMFeedbacks component got deprecated with the introduction of the MMF Player, in v3.0.\n\n" +
+				                        "The MMF Player improves performance, lets you keep runtime changes, and much more! And it works just like MMFeedbacks. " +
+				                        "With the release of v4.0, the MMFeedbacks is now completely removed from Feel and phased out.\n\n" +
+				                        "If you've tried adding this component, maybe you're watching an old tutorial, in that case, fear not, all you're watching is still valid, " +
+				                        "just replace MMFeedbacks with MMF Player and you'll be good to go! Have fun with Feel!", MessageType.Warning);  
+		}
+	}
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/MMFeedbacksEditor.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: b44bc3e42b280e843bc6108cbdee8253
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/MMFeedbacksEditor.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit.meta

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

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/FeelScriptIcon.png.meta

@@ -0,0 +1,150 @@
+fileFormatVersion: 2
+guid: d9d54e48cd32e274287fb32bbb13da24
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Win64
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/FeelScriptIcon.png
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_FeedbackPropertyDrawerUITK.cs

@@ -0,0 +1,385 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using MoreMountains.Tools;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace MoreMountains.Feedbacks
+{
+	public class MMFInspectorDrawData
+	{
+		public int Index;
+		public Foldout FeedbackFoldout;
+		public SerializedProperty CurrentProperty;
+		public MMF_Feedback Feedback;
+		public MMF_PlayerEditorUITK PlayerEditor;
+		public Action<SerializedProperty> OnAnyValueChanged;
+		public Action<SerializedProperty, MMFInspectorGroupData, MMF_Feedback> OnFeedbackFieldValueChanged;
+		public Dictionary<MMFInspectorGroupData, MMF_PlayerEditorUITK.MMFFeedbackGroupExtrasContainerData> FeedbackGroupsDictionary;
+		public Dictionary<string, MMFInspectorGroupData> GroupDataDictionary;
+		public List<SerializedProperty> PropertiesList;
+		public Sprite SetupRequiredIcon;
+	}
+	
+	public class MMFInspectorGroupData
+	{
+		public bool GroupIsOpen;
+		public MMFInspectorGroupAttribute GroupAttribute;
+		public List<SerializedProperty> PropertiesList = new List<SerializedProperty>();
+		public HashSet<string> GroupHashSet = new HashSet<string>();
+		public Color GroupColor;
+		public bool Initialized = false;
+
+		public void ClearGroup()
+		{
+			GroupAttribute = null;
+			GroupHashSet.Clear();
+			PropertiesList.Clear();
+			Initialized = false;
+		}
+	}
+	
+	public class MMF_FeedbackPropertyDrawerUITK 
+	{
+		private const string _channelFieldName = "Channel";
+		private const string _channelModeFieldName = "ChannelMode";
+		private const string _channelDefinitionFieldName = "MMChannelDefinition";
+		private const string _automatedTargetAcquisitionName = "AutomatedTargetAcquisition";
+		private const string _timingFieldName = "Timing";
+		protected const string _customInspectorButtonPropertyName = "MMF_Button";
+
+		protected const string _mmfInspectorClassName = "mm-mmf-inspector";
+		protected const string _mmfContainerClassName = "mm-mmf-container";
+		protected const string _mmfGroupClassName = "mm-mmf-group";
+		protected const string _mmfFieldClassName = "mm-mmf-field";
+		protected const string _feedbackGroupHeaderExtrasClassName = "mm-feedback-group-header-extras";
+		
+		public static VisualElement DrawInspector(MMFInspectorDrawData drawData)
+		{
+			// create our inspector root
+			VisualElement root = new VisualElement();
+			root.RegisterCallback<PointerDownEvent>(evt => { evt.StopPropagation(); });
+			root.AddToClassList(_mmfInspectorClassName); 
+			
+			// initialize our data containers
+			Dictionary<string, MMFInspectorGroupData> groupDataDictionary = new Dictionary<string, MMFInspectorGroupData>();
+			List<SerializedProperty> propertiesList = new List<SerializedProperty>();
+			drawData.GroupDataDictionary = groupDataDictionary;
+			drawData.PropertiesList = propertiesList;
+			
+			Initialization(drawData);
+			root.Add(DrawContainer(drawData));
+			
+			// we initialize our groupdata with a delay to make sure OnFeedbackFieldValueChanged isn't called on the first render of each field
+			root.schedule.Execute(() =>
+			{
+				foreach (var keyPair in groupDataDictionary)
+				{
+					keyPair.Value.Initialized = true;
+				}
+			}).StartingIn(1000);
+			
+			return root;
+		}
+		
+		protected static void Initialization(MMFInspectorDrawData drawData)
+		{
+			List<FieldInfo> fieldInfoList;
+			MMFInspectorGroupAttribute previousGroupAttribute = default;
+			int fieldInfoLength = MMF_FieldInfo.GetFieldInfo(drawData.Feedback, out fieldInfoList);
+            
+			for (int i = 0; i < fieldInfoLength; i++)
+			{
+				MMFInspectorGroupAttribute group = Attribute.GetCustomAttribute(fieldInfoList[i], typeof(MMFInspectorGroupAttribute)) as MMFInspectorGroupAttribute;
+
+				MMFInspectorGroupData groupData;
+				if (group == null)
+				{
+					if (previousGroupAttribute != null && previousGroupAttribute.GroupAllFieldsUntilNextGroupAttribute)
+					{
+						if (!drawData.GroupDataDictionary.TryGetValue(previousGroupAttribute.GroupName, out groupData))
+						{
+							if (!ShouldSkipGroup(previousGroupAttribute.GroupName, drawData.Feedback))
+							{
+								drawData.GroupDataDictionary.Add(previousGroupAttribute.GroupName, new MMFInspectorGroupData
+								{
+									GroupAttribute = previousGroupAttribute,
+									GroupHashSet = new HashSet<string> { fieldInfoList[i].Name },
+									GroupColor = MMFeedbacksColors.GetColorAt(previousGroupAttribute.GroupColorIndex)
+								});
+							}
+						}
+						else
+						{
+							groupData.GroupColor = MMFeedbacksColors.GetColorAt(previousGroupAttribute.GroupColorIndex);
+							groupData.GroupHashSet.Add(fieldInfoList[i].Name);
+						}
+					}
+
+					continue;
+				}
+                
+				previousGroupAttribute = group;
+
+				if (!drawData.GroupDataDictionary.TryGetValue(group.GroupName, out groupData))
+				{
+					bool fallbackOpenState = true;
+					if (group.ClosedByDefault) { fallbackOpenState = false; }
+					bool groupIsOpen = EditorPrefs.GetBool(string.Format($"{group.GroupName}{fieldInfoList[i].Name}{drawData.Feedback.UniqueID}"), fallbackOpenState);
+
+					if (!ShouldSkipGroup(previousGroupAttribute.GroupName, drawData.Feedback))
+					{
+						drawData.GroupDataDictionary.Add(group.GroupName, new MMFInspectorGroupData
+						{
+							GroupAttribute = group,
+							GroupColor = MMFeedbacksColors.GetColorAt(previousGroupAttribute.GroupColorIndex),
+							GroupHashSet = new HashSet<string> { fieldInfoList[i].Name }, GroupIsOpen = groupIsOpen 
+						});	
+					}
+				}
+				else
+				{
+					groupData.GroupHashSet.Add(fieldInfoList[i].Name);
+					groupData.GroupColor = MMFeedbacksColors.GetColorAt(previousGroupAttribute.GroupColorIndex);
+				}
+			}
+
+			if (drawData.CurrentProperty.NextVisible(true))
+			{
+				do
+				{
+					FillPropertiesList(drawData.CurrentProperty, drawData.GroupDataDictionary, drawData.PropertiesList);
+				} while (drawData.CurrentProperty.NextVisible(false));
+			}
+		}
+		
+		protected static bool ShouldSkipGroup(string groupName, MMF_Feedback feedback)
+		{
+			bool skip = false;
+            
+			if (groupName == MMF_Feedback._randomnessGroupName && !feedback.HasRandomness)
+			{
+				skip = true;
+			}
+
+			if (groupName == MMF_Feedback._rangeGroupName && !feedback.HasRange)
+			{
+				skip = true;
+			}
+
+			if (groupName == MMF_Feedback._automaticSetupGroupName && !feedback.HasAutomaticShakerSetup)
+			{
+				skip = true;
+			}
+
+			return skip;
+		}
+        
+		public static void FillPropertiesList(SerializedProperty serializedProperty, Dictionary<string, MMFInspectorGroupData> groupDataDictionary, List<SerializedProperty> propertiesList)
+		{
+			bool shouldClose = false;
+
+			foreach (KeyValuePair<string, MMFInspectorGroupData> pair in groupDataDictionary)
+			{
+				if (pair.Value.GroupHashSet.Contains(serializedProperty.name))
+				{
+					SerializedProperty property = serializedProperty.Copy();
+					shouldClose = true;
+					pair.Value.PropertiesList.Add(property);
+					break;
+				}
+			}
+
+			if (!shouldClose)
+			{
+				SerializedProperty property = serializedProperty.Copy();
+				propertiesList.Add(property);
+			}
+		}
+        
+		protected static VisualElement DrawContainer(MMFInspectorDrawData drawData)
+		{
+			VisualElement root = new VisualElement();
+			root.AddToClassList(_mmfContainerClassName);
+			
+			if (drawData.PropertiesList.Count == 0)
+			{
+				return root;
+			}
+            
+			foreach (KeyValuePair<string, MMFInspectorGroupData> pair in drawData.GroupDataDictionary)
+			{
+				VisualElement group = DrawGroup(pair.Value, drawData);
+				root.Add(group);
+			}
+
+			return root;
+		}
+		
+		protected static VisualElement DrawGroup(MMFInspectorGroupData groupData, MMFInspectorDrawData drawData)
+		{
+			VisualElement root = new VisualElement();
+			root.RegisterCallback<PointerDownEvent>(evt => { evt.StopPropagation(); }); 
+			root.AddToClassList(_mmfGroupClassName);
+			
+			Foldout foldout = new Foldout();
+			foldout.text = groupData.GroupAttribute.GroupName;
+			foldout.value = groupData.GroupIsOpen;
+			foldout.AddToClassList(MMF_PlayerEditorUITK._foldoutClassName);
+			foldout.style.borderLeftColor = groupData.GroupColor;
+			foldout.viewDataKey = drawData.Feedback.UniqueID + "-" + drawData.Feedback.Label + "-" + groupData.GroupAttribute.GroupName;
+			root.Add(foldout);
+			
+			var toggleElement = foldout.Q<Toggle>();
+			toggleElement.AddToClassList(MMF_PlayerEditorUITK._foldoutToggleClassName);
+
+			VisualElement headerExtrasContainer = new VisualElement();
+			headerExtrasContainer.AddToClassList(_feedbackGroupHeaderExtrasClassName);
+			headerExtrasContainer.pickingMode = PickingMode.Ignore;
+			foldout.parent.Insert(1, headerExtrasContainer);
+				
+			MMF_PlayerEditorUITK.MMFFeedbackGroupExtrasContainerData feedbackGroupExtrasContainerData = new MMF_PlayerEditorUITK.MMFFeedbackGroupExtrasContainerData();
+			feedbackGroupExtrasContainerData.HeaderExtrasContainer = headerExtrasContainer;
+			feedbackGroupExtrasContainerData.GroupData = groupData;
+			feedbackGroupExtrasContainerData.DrawData = drawData;
+			drawData.FeedbackGroupsDictionary.Add(groupData, feedbackGroupExtrasContainerData);
+			DrawGroupExtrasContainer(feedbackGroupExtrasContainerData);
+			
+			// foldout contents
+			foldout.schedule.Execute(() =>
+			{
+				if (foldout.value) { DrawFoldoutContents(); }
+			}).ExecuteLater(1);
+				
+			EventCallback<ChangeEvent<bool>> callback = null;
+			callback = evt =>
+			{
+				if (evt.newValue) 
+				{
+					if (foldout.childCount == 0) 
+					{
+						DrawFoldoutContents();
+						foldout.UnregisterValueChangedCallback(callback);
+					}
+				}
+			};
+			foldout.RegisterValueChangedCallback(callback);
+
+			void DrawFoldoutContents()
+			{
+				for (int i = 0; i < groupData.PropertiesList.Count; i++)
+				{
+					DrawChild(i, foldout, root);
+				}
+			}
+
+			void DrawChild(int i, Foldout foldout, VisualElement root)
+			{
+				if (!drawData.Feedback.HasChannel 
+				    && (groupData.PropertiesList[i].name == _channelFieldName
+				        || groupData.PropertiesList[i].name == _channelModeFieldName
+				        || groupData.PropertiesList[i].name == _channelDefinitionFieldName))
+				{
+					return;
+				}
+				
+				bool shouldDraw = !((groupData.PropertiesList[i].name == _automatedTargetAcquisitionName) && (!drawData.Feedback.HasAutomatedTargetAcquisition));
+				if (!shouldDraw)
+				{
+					return;
+				}
+				
+				if (!DrawCustomInspectors(groupData.PropertiesList[i], drawData.Feedback, foldout))
+				{
+					PropertyField field = new PropertyField(groupData.PropertiesList[i]);
+					field.label = ObjectNames.NicifyVariableName(groupData.PropertiesList[i].name);
+					field.name = groupData.PropertiesList[i].name;
+					field.tooltip = groupData.PropertiesList[i].tooltip;
+					field.AddToClassList(_mmfFieldClassName);
+					field.Bind(groupData.PropertiesList[i].serializedObject);
+					field.TrackPropertyValue(groupData.PropertiesList[i], drawData.OnAnyValueChanged);
+
+					if (field.name == "Label")
+					{
+						field?.RegisterCallback<ChangeEvent<string>>(evt =>
+						{
+							drawData.FeedbackFoldout.text = drawData.PlayerEditor.DetermineFeedbackLabel(drawData.Index, drawData.Feedback.GetType());
+						});
+					}
+					
+					field.RegisterValueChangeCallback(evt =>
+					{
+						if (groupData.Initialized)
+						{
+							drawData.OnFeedbackFieldValueChanged(groupData.PropertiesList[i], groupData, drawData.Feedback);
+						}
+					});
+					foldout.Add(field);
+					
+					// we register callbacks for all the nested fields under Timing
+					if (field.name == _timingFieldName) 
+					{
+						RegisterNestedCallbacks(field, groupData.PropertiesList[i], groupData, drawData); 
+					}
+				}
+			}
+
+			return root;
+		}
+		
+		private static void RegisterNestedCallbacks(VisualElement field, SerializedProperty property, MMFInspectorGroupData groupData, MMFInspectorDrawData drawData)
+		{
+			field.schedule.Execute(() => // we delay the execution to avoid calling the callback before the Timing foldout is fully built 
+			{
+				foreach (var child in field.Children())
+				{
+					if (child is PropertyField genericField) 
+					{
+						genericField.RegisterValueChangeCallback(evt => drawData.OnFeedbackFieldValueChanged(property, groupData, drawData.Feedback));
+					}
+					if (child.childCount > 0)
+					{
+						RegisterNestedCallbacks(child, property, groupData, drawData);
+					}
+				}
+			}).StartingIn(100);
+		}
+
+		public static void DrawGroupExtrasContainer(MMF_PlayerEditorUITK.MMFFeedbackGroupExtrasContainerData groupExtrasContainerData)
+		{
+			groupExtrasContainerData.HeaderExtrasContainer.Clear();
+			
+			if (groupExtrasContainerData.GroupData.GroupAttribute.RequiresSetup && groupExtrasContainerData.DrawData.Feedback.RequiresSetup)
+			{
+				VisualElement setupRequiredIcon = new VisualElement();
+				setupRequiredIcon.AddToClassList(MMF_PlayerEditorUITK._iconClassName);
+				setupRequiredIcon.AddToClassList(MMF_PlayerEditorUITK._setupRequiredIconClassName);
+				setupRequiredIcon.style.backgroundImage = new StyleBackground(groupExtrasContainerData.DrawData.SetupRequiredIcon);
+				groupExtrasContainerData.HeaderExtrasContainer.Add(setupRequiredIcon);
+			}
+		}
+		
+		protected static bool DrawCustomInspectors(SerializedProperty currentProperty, MMF_Feedback feedback, Foldout foldout)
+		{
+			if (feedback.HasCustomInspectors)
+			{
+				switch (currentProperty.type)
+				{
+					case _customInspectorButtonPropertyName:
+						MMF_Button myButton = (MMF_Button)(currentProperty.MMFGetObjectValue());
+						
+						Button newButton = new Button(() => myButton.TargetMethod());
+						newButton.text = myButton.ButtonText;
+						foldout.Add(newButton);
+						
+						return true;
+				}
+			}
+
+			return false;
+		}
+    }
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_FeedbackPropertyDrawerUITK.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 886d805cbd686b046b8707c00676d919
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_FeedbackPropertyDrawerUITK.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITK.cs.meta

@@ -0,0 +1,41 @@
+fileFormatVersion: 2
+guid: a14b560285de1794cb8915d623ec0462
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences:
+  - StyleSheetBase: {fileID: 7433441132597879392, guid: 8f8bad73dac7361489c555af4bf184ea,
+      type: 3}
+  - StyleSheetControls: {fileID: 7433441132597879392, guid: 5fff0ec3f88bb6146b69ac5122464d3c,
+      type: 3}
+  - StyleSheetFeedbacksList: {fileID: 7433441132597879392, guid: 9377959c627301448afdcf8613b13e77,
+      type: 3}
+  - StyleSheetFoldouts: {fileID: 7433441132597879392, guid: 9bb3dab26afe5274597af318a1c3592c,
+      type: 3}
+  - StyleSheetSettings: {fileID: 7433441132597879392, guid: 390bf4a7227d9094e82fd024ef00a069,
+      type: 3}
+  - StyleSheetLightSkin: {fileID: 7433441132597879392, guid: 14b92bfe5ef8242479d196b4e9916647,
+      type: 3}
+  - GearIcon: {fileID: 21300000, guid: 13a276490eda9164f86cc22771d27073, type: 3}
+  - TopToBottomIcon: {fileID: 21300000, guid: c23294d57f74bea4b9a439f033a6bf15, type: 3}
+  - BottomToTopIcon: {fileID: 21300000, guid: cd807e3eb5122524d9a1783af6375956, type: 3}
+  - ContextlMenuIcon: {fileID: 21300000, guid: ab4146e63d28b4c479103682a751663c, type: 3}
+  - SetupRequiredIcon: {fileID: 21300000, guid: 69bdc1f611c0f8d4dbc71613a9b04b9b,
+      type: 3}
+  - EmptyListImage: {fileID: 21300000, guid: e305d4ff6fcb66148a89b78f93cc03fa, type: 3}
+  - ScriptIcon: {fileID: 21300000, guid: d9d54e48cd32e274287fb32bbb13da24, type: 3}
+  - SearchFieldCloseIcon: {fileID: 21300000, guid: be687c348d0c62c45a733dc1ae6f018f,
+      type: 3}
+  - TargetMmfPlayer: {instanceID: 0}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITK.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet.uss

@@ -0,0 +1,41 @@
+.mmf-editor {
+    margin-left: -15px;
+    margin-right: -6px;
+    overflow: hidden;
+}
+
+.mm-script-field {
+    padding-left: 15px;
+    padding-right: 6px;
+}
+
+.automatic-shaker-setup-button { /* automatic shaker setup button */
+    margin-top: 5px;
+    margin-left: -5px;
+    padding: 2px;
+}
+
+.mm-icon { /* generic small icons */
+    width: 16px;
+    height: 16px;
+}
+
+.unity-list-view__item {
+    background-color: transparent;
+}
+
+.unity-list-view__item:hover {
+    background-color: transparent;
+}
+
+.unity-list-view__item:checked {
+    background-color: transparent;
+}
+
+.unity-list-view__reorderable-item {
+    background-color: transparent;
+    color: rgba(230, 230, 230, 1);
+}
+.unity-list-view__reorderable-item__container {
+    padding-bottom: 0px;
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet.uss.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 8f8bad73dac7361489c555af4bf184ea
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet.uss
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_Controls.uss

@@ -0,0 +1,82 @@
+.mm-controls { /* debug controls panel */
+    margin-top: 0px;
+    margin-left: 0px;
+    padding: 10px;
+    padding-left: 8px;
+    padding-right: 6px;
+}
+
+.mm-controls Button { /* debug controls button */
+    flex-grow: 1;
+    padding: 2px;
+}
+
+.mm-controls-label { /* debug controls label */
+    -unity-font-style: bold;
+    margin-left: 3px;
+}
+
+.mm-playmode-button-active { /* active playmode button */
+    background-color: rgba(244, 52, 0, 1);
+    color: rgba(32, 32, 32, 1);
+}
+
+.mm-script-driven-pause-label{ /* script-driven pause label */
+    background-color: rgba(42, 167, 208, 1);
+    -unity-font-style: bold;
+    color: rgba(32, 32, 32, 1);
+    -unity-text-align: middle-center;
+    padding: 5px;
+    margin: 3px;
+    transition-duration: 0.5s;
+}
+
+.mm-script-driven-pause-label-blink{ /* script-driven pause label blink */
+    background-color: rgba(117, 221, 255, 1);
+}
+
+.mm-bottom-bar { /* bottom bar */
+    border-color: rgba(255, 255, 255, 0.3);
+    background-color: rgba(0, 0, 0, 0.3);
+    border-width: 1px;
+    border-left-width: 0px;
+    border-right-width: 0px;
+    border-top-width: 0px;
+    padding-top: 5px;
+    padding-bottom: 5px;
+    padding-left: 8px;
+    padding-right: 6px;
+    margin-top: 0px;
+}
+
+.mm-add-feedback-search-field { /* add feedback search field */
+    width: 45%;
+    transition: width 0.1s ease-in-out; 
+}
+
+.mm-add-feedback-search-field-placeholder {
+    width: 20%
+}
+
+.mm-add-feedback-search-field Label {
+    display: none;
+    background-color: yellow;
+}
+
+.mm-add-feedback-search-field-placeholder TextInput { /* add feedback search field placeholder */
+    color: rgba(255, 255, 255, 0.3);
+}
+
+.mm-search-add-feedback-button { /* search add feedback button */
+    width: 60%;
+    margin-left: 40%;
+    -unity-text-align: middle-left;
+}
+
+.mm-search-results-row {
+    flex-direction: column;
+}
+
+.mm-search-results-row Button:focus {
+    background-color: rgba(83,191,255,0.3);
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_Controls.uss.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 5fff0ec3f88bb6146b69ac5122464d3c
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_Controls.uss
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_FeedbacksList.uss

@@ -0,0 +1,373 @@
+.mm-feedbacks-list { /* feedbacks list */
+
+}
+
+.mm-feedback-foldout-label, 
+    .mm-feedback-foldout-label:hover, 
+    .mm-feedback-foldout-label:focus, 
+    .mm-feedback-foldout-label:active, 
+    .mm-feedback-foldout-label:selected, 
+    .mm-feedback-foldout-label:checked,
+    .mm-feedbacks-list Label:hover, 
+    .mm-feedbacks-list Label:focus, 
+    .mm-feedbacks-list Label:active { /* labels in the list */
+    color: rgba(220, 220, 220, 1);
+}
+
+.mm-mmf-group .mm-foldout Label,
+.mm-mmf-group .mm-foldout Label:hover,
+.mm-mmf-group .mm-foldout Label:focus,
+.mm-mmf-group .mm-foldout Label:active,
+.mm-mmf-group .mm-foldout Label:selected,
+.mm-mmf-group .mm-foldout Label:checked { /* labels in the foldout groups */
+    color: rgba(220, 220, 220, 1);
+}
+
+.mm-feedbacks-list-title, .mm-feedbacks-list-title:hover { /* feedbacks list title */
+    font-size: 12px;
+    -unity-font-style: bold;
+    padding-left: 15px;
+    padding-right: 6px;
+    margin-top: 10px;
+    padding-bottom: 5px;
+    border-bottom-width: 1px;
+    border-color: black;
+    color: rgba(220, 220, 220, 1);
+}
+
+.mm-feedbacks-list #unity-list-view__reorderable-item { /* feedbacks list item, controls the bg color of the feedback header */
+    border-bottom-width: 1px;
+    border-color: black;
+    background-color: rgba(0, 0, 0, 0.2);
+}
+
+.mm-feedbacks-list .mm-feedback-reorder-blocker { /* prevents reordering */
+    background-color: red;    
+    height: 500px;
+    flex-grow: 1;
+    position: absolute;
+    top: 20px;
+    left: 0px;
+    width: 100%;
+}
+
+.mm-feedbacks-list #unity-list-view__reorderable-handle { /* repositionable handle icon container on the left */
+    height: 20px;
+    padding-top: 8px;
+}
+
+.mm-feedbacks-list #unity-list-view__reorderable-handle #unity-list-view__reorderable-handle-bar { /* repositionable handle icon horizontal bars */
+    background-color: rgba(220, 220, 220, .3);
+}
+
+.mm-feedback-edit-script-button-container { /* edit script button container */
+    margin-left: -51px;
+    margin-right: -6px;
+    padding-left: 10px;
+    -unity-text-align: upper-left;
+    border-left-width: 0px;
+    margin-top: -1px;
+    background-color: rgba(255, 255, 255, 0.05);
+    padding-top: 5px;
+    border-top-width: 0px;
+    border-bottom-width: 0px;
+    border-color: black;
+    flex-direction: row;
+    margin-bottom: 1px;
+    -unity-text-align: middle-left; 
+    align-items: flex-start;
+}
+
+.mm-feedback-edit-script-button-label {
+    white-space: normal;
+    -unity-font-style: normal;
+    color: rgba(140, 140, 140, 1);
+    padding: 5px;
+    padding-left: 8px;
+    border-bottom-width: 0px;
+    flex-grow: 0.46;
+    min-width: 104px;
+    padding-top: 2px;
+}
+
+.mm-feedback-edit-script-button-box
+{
+    background-color: rgba(0, 0, 0, 0.2);
+    color: rgba(255, 255, 255, 0.5);
+    margin-right: 5px;
+    flex-grow: 1;
+    flex-direction: row;
+}
+
+.mm-feedback-edit-script-button-box .mm-icon {
+    width: 14px;
+    height: 14px;
+    opacity: 0.5;
+    margin-top: 2px;
+    margin-left: 2px;
+    margin-right: 0px;    
+} 
+
+.mm-feedback-edit-script-button-box .unity-object-field__selector {
+    position: absolute;
+    right: 0px;
+    background-color: rgba(0, 0, 0, 0);
+    opacity: 0.5;
+}
+
+.mm-feedback-edit-script-button-box Button {
+    flex-grow: 1;
+    border-width: 0;
+    background-color: rgba(0, 0, 0, 0);
+    color: rgba(255, 255, 255, 0.5);
+    -unity-text-align: middle-left;
+    padding-left: 0px;
+}
+
+.mm-feedback-help-box { /* help box */
+    margin-left: -51px;
+    margin-right: -6px; 
+    padding-left: 10px;
+    -unity-text-align: upper-left; 
+    border-left-width: 0px;
+    margin-top: -1px;
+    background-color: rgba(255, 255, 255, 0.05);
+    padding-top: 5px;
+    border-top-width: 1px;
+    border-color: black;
+}
+
+.mm-feedback-help-box Label, .mm-feedback-help-box Label:hover { /* help box labels */
+    white-space: normal;
+    -unity-font-style: normal;
+    color: rgba(140, 140, 140, 1);
+    padding: 5px;
+    padding-top: 0px;
+    font-size: 11px;
+}
+
+.mm-feedback-setup-required-box { /* setup required box */
+    margin-left: -51px;
+    margin-right: -6px; 
+    padding-left: 0px;
+    -unity-text-align: upper-left;
+    color: rgba(20, 20, 20, 1);
+    border-top-width: 1px;
+    border-color: black;
+}
+
+.mm-feedback-setup-required-box Label, .mm-feedback-setup-required-box Label:hover { /* setup required box labels */
+    white-space: normal;
+    -unity-font-style: bold;
+    color: rgba(20, 20, 20, 1);
+    background-color: rgb(255, 97, 33);
+    padding: 10px;
+    margin-left: 0px;
+    padding-top: 0px;
+    padding: 10px;
+    font-size: 11px;
+}
+
+.mm-mmf-inspector { /* per feedback inspector */
+    margin-left: -51px;
+    margin-right: -6px;
+    border-top-width: 0px;
+    border-color: black;
+    background-color: rgba(255, 255, 255, 0.1);
+    padding-left: 8px;
+    padding-bottom: 10px;
+}
+
+.mm-mmf-inspector .unity-decorator-drawers-container .unity-header-drawer__label,
+.mm-mmf-inspector .unity-decorator-drawers-container .unity-header-drawer__label:hover{ /* Header attributes */
+    background-color: rgba(255,255,255,0.00);
+    border-color: rgba(59,163,196,0.3); 
+    border-bottom-width: 1px;
+    margin-top: 0px;
+    margin-bottom: 4px;
+    padding-left: 0px;
+    padding-bottom: 2px;
+    margin-left: -10px;
+    color: rgba(59,163,196,1);
+
+}
+
+.unity-foldout__content { /* foldout content */
+    padding-left: 0px;
+    padding-right: 0px;
+    padding-top: 0px;
+    padding-bottom: 0px;
+}
+
+.mm-mmf-group .mm-foldout { /* feedback foldout */
+    background-color: rgba(0, 0, 0, 0.20);
+    margin-top: 3px;
+}
+
+.mm-mmf-group .mm-foldout-toggle { /* feedback foldout toggle */
+    background-color: rgba(0, 0, 0, 0.08);
+    padding-top: 3px;
+    padding-bottom: 3px;
+    margin-top: 0px;
+}
+
+.mm-feedback-foldout-label { /* feedback foldout label */
+    padding-left: 20px;
+}
+
+.mm-feedback-active-checkbox { /* feedback active checkbox */
+    margin-left: 0px;
+    margin-right: 5px;
+    top: 3px;
+    height: 14px;
+    position: absolute;
+    left: 15px;
+}
+
+.mm-mmf-group #unity-content { /* feedback foldout content */
+    padding-bottom: 10px; 
+}
+
+.mm-feedback-left-border { /* feedback left border */
+    width: 6px;
+    margin-right: 2px;
+    height: 20px;
+}
+
+.mm-feedback-control-buttons { /* play and stop buttons at the bottom */
+    flex-direction: row;
+    justify-content: space-between;
+    margin-left: -51px;
+    margin-right: -6px;
+    background-color: rgba(255, 255, 255, 0.1);
+    padding-left: 4px;
+    padding-right: 5px;
+    padding-bottom: 10px;
+}
+
+.mm-feedback-control-buttons Button { /* play and stop buttons per feedback */
+    flex-grow: 1;
+}
+
+.mm-feedback-header-container { /* feedback header container */
+    position: absolute;
+    top: 0px;
+    left: 0px;
+    right: 0px;
+    height: 21px;
+}
+
+.mm-feedback-group-header-extras { /* feedback subgroup header container */
+    position: absolute;
+    top: 3px;
+    left: 0px;
+    right: 0px;
+    height: 22px;
+}
+
+.mm-feedback-background-color { /* background color of the feedback labels (for pauses, loops etc) */
+    position: absolute;
+    top: 0px;
+    left: 0px;
+    right: 0px;
+    height: 21px;
+}
+
+.mm-feedback-required-target-label { /* required target label */
+    position: absolute;
+    top: 2px;
+    right: 90px;
+    height: 21px;
+    color: rgba(255,255,255,0.4);
+}
+
+.mm-feedback-timing-label { /* required timing label */
+    position: absolute;
+    top: 2px;
+    right: 35px;
+    height: 21px;
+    color: rgba(255,255,255,0.4);
+}
+
+.mm-feedback-contextual-menu-button { /* context menu button */
+    position: absolute;
+    right: 0px;
+    background-color: initial;
+    border-width: 0px;
+    padding-top: 1px;
+}
+
+.mm-feedback-direction-icon { /* direction icon */
+    position: absolute;
+    right: 15px;
+    top: 2px;
+    width: 16px;
+    height: 16px;    
+}
+
+.mm-setup-required-icon { /* setup required icon */
+    position: absolute;
+    right: 90px;
+    top: 2px;
+    width: 16px;
+    height: 16px;
+}
+
+.unity-list-view__empty-label { /* native empty list label */
+    display: none;
+}
+
+.mm-feedbacks-list-empty { /* custom empty list label */
+    padding: 10px;    
+    flex-direction: row;
+    flex-wrap: wrap;
+}
+
+.mm-empty-list-image { /* custom empty list image */
+    width: 75px;
+    min-width: 75px;
+    height: 75px;
+    margin: 0 auto;
+    flex-shrink: 0;
+}
+
+.mm-feedbacks-list-empty Label { /* custom empty list label */
+    background-color: rgba(0, 0, 0, 0.2);
+    padding: 10px;
+    flex-grow: 1;
+    white-space: normal;
+    flex-shrink: 1;
+}
+
+.mm-feedback-progress-line-container { /* progress line */
+    position: absolute;
+    top: 19px;
+    left: -45px;
+    right: -6px;
+    height: 2px;
+}
+
+.mm-feedback-progress-line { /* progress line */
+    position: absolute;
+    height: 2px;
+    width: 0%;
+}
+
+.mm-feedback-group-header-extras .mm-setup-required-icon { /* setup required icon */
+    right: 8px;
+}
+
+.mm-feedbacks-inactive-warning { /* inactive warning */    
+    background-color: rgba(255, 90, 0, 1);
+    color: rgba(255, 255, 255, 0.8);
+    padding: 10px;
+    flex-grow: 1;
+    margin-top: 10px;
+}
+
+.mm-feedbacks-inactive-warning Label { /* inactive warning label */
+    white-space: normal;
+    color: rgba(0,0,0,0.8);
+    font-size: 12px;
+    -unity-font-style: bold;
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_FeedbacksList.uss.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 9377959c627301448afdcf8613b13e77
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_FeedbacksList.uss
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_Foldouts.uss

@@ -0,0 +1,38 @@
+.mm-foldout { /* generic foldout */
+    margin-top: 5px;
+    border-left-color: black;
+    border-left-width: 3px;
+    margin-bottom: 0px;
+    padding-right: 0px;
+    padding-left: 0;
+    padding-bottom: 0;
+    padding-top: 0;
+}
+
+.mm-foldout-toggle { /* generic foldout toggle */
+    padding-top: 5px;
+    padding-left: 5px;
+    margin-left: 0;
+    padding-bottom: 5px;
+    margin-bottom: 0;
+    -unity-font-style: bold;
+}
+
+.mm-foldout #unity-content { /* generic foldout content */
+    padding-top: 2px;
+    margin-top: 0;
+    margin-left: 10px;
+    padding-left: 10px;
+    padding-right: 8px;
+    padding-bottom: 10px;
+}
+
+.mm-foldout .unity-header-drawer__label { /* [Header] attributes inside foldout content */
+    margin-top: 10px;
+    padding-bottom: 5px;
+    padding-top: 5px;
+    margin-left: -20px;
+    padding-left: 20px;
+    -unity-font-style: bold;
+    background-color: rgba(255, 255, 255, 0.04);
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_Foldouts.uss.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 9bb3dab26afe5274597af318a1c3592c
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_Foldouts.uss
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_LightSkin.uss

@@ -0,0 +1,120 @@
+.mm-foldout .unity-header-drawer__label { /* [Header] attributes inside foldout content */
+    background-color: rgba(255, 255, 255, 0.00);
+}
+
+.mm-feedback-foldout-label,
+.mm-feedback-foldout-label:hover,
+.mm-feedback-foldout-label:focus,
+.mm-feedback-foldout-label:active,
+.mm-feedback-foldout-label:selected,
+.mm-feedback-foldout-label:checked,
+.mm-feedbacks-list Label:hover,
+.mm-feedbacks-list Label:focus,
+.mm-feedbacks-list Label:active { /* labels in the list */
+    color: rgba(0, 0, 0, 0.9);
+}
+
+.mm-mmf-group .mm-foldout Label,
+.mm-mmf-group .mm-foldout Label:hover,
+.mm-mmf-group .mm-foldout Label:focus,
+.mm-mmf-group .mm-foldout Label:active,
+.mm-mmf-group .mm-foldout Label:selected,
+.mm-mmf-group .mm-foldout Label:checked { /* labels in the foldout groups */
+    color: rgba(0, 0, 0, 1);
+}
+
+.mm-feedbacks-list-title, .mm-feedbacks-list-title:hover { /* feedbacks list title */
+    color: rgba(0, 0, 0, 1);
+}
+
+.mm-feedbacks-list #unity-list-view__reorderable-item { /* feedbacks list item, controls the bg color of the feedback header */
+    background-color: rgba(0, 0, 0, 0);
+}
+
+.mm-feedbacks-list #unity-list-view__reorderable-handle #unity-list-view__reorderable-handle-bar { /* repositionable handle icon horizontal bars */
+    background-color: rgba(0, 0, 0, .3);
+}
+
+.mm-feedback-help-box { /* help box */
+    background-color: rgba(255, 255, 255, 0.1);
+}
+
+.mm-feedback-help-box Label, .mm-feedback-help-box Label:hover { /* help box labels */
+    color: rgba(100, 100, 100, 1);
+}
+
+.mm-feedback-setup-required-box { /* setup required box */
+    color: rgba(20, 20, 20, 1);
+}
+
+.mm-feedback-setup-required-box Label, .mm-feedback-setup-required-box Label:hover { /* setup required box labels */
+    color: rgba(20, 20, 20, 1);
+    background-color: rgb(255, 97, 33);
+}
+
+.mm-mmf-inspector { /* per feedback inspector */
+    background-color: rgba(255, 255, 255, 0.1);
+}
+
+.mm-mmf-inspector .unity-decorator-drawers-container .unity-header-drawer__label,
+.mm-mmf-inspector .unity-decorator-drawers-container .unity-header-drawer__label:hover{ /* Header attributes */
+    border-color: rgba(59,163,196,0.3);
+    color: rgba(12,13,18,1);
+}
+
+.mm-mmf-group .mm-foldout { /* feedback foldout */
+    background-color: rgba(0, 0, 0, 0.00);
+}
+
+.mm-mmf-group .mm-foldout-toggle { /* feedback foldout toggle */
+    background-color: rgba(0, 0, 0, 0.08);
+}
+
+.mm-feedback-control-buttons { /* play and stop buttons at the bottom */
+    background-color: rgba(255, 255, 255, 0.1);
+}
+.mm-feedback-required-target-label { /* required target label */
+    color: rgba(255,255,255,0.4);
+}
+
+.mm-feedback-timing-label { /* required timing label */
+    color: rgba(255,255,255,0.4);
+}
+
+.mm-feedbacks-list-empty Label { /* custom empty list label */
+    background-color: rgba(0, 0, 0, 0.2);
+}
+
+.mm-bottom-bar { /* bottom bar */
+    border-color: rgba(255, 255, 255, 0.3);
+    background-color: rgba(0, 0, 0, 0.1);
+}
+
+.unity-list-view__reorderable-item {
+    color: rgba(0, 0, 0, 1);
+}
+
+.mm-settings-foldout { /* settings foldout */
+    background-color: rgba(0, 0, 0, 0);
+    border-color: rgba(255, 255, 255, 0);
+}
+
+.mm-settings-foldout Label, mm-settings-foldout Label:hover, mm-settings-foldout Label:active { /* settings foldout label */
+    color: rgba(0, 0, 0, 1);
+}
+
+Toggle.mm-settings-foldout-toggle { /* settings foldout toggle */
+    background-color: rgba(0, 0, 0, 0.1);
+}
+
+.mm-settings-foldout-sub { /* settings sub foldout */
+    background-color: rgba(0, 0, 0, 0.1);
+}
+
+Toggle.mm-settings-foldout-sub-toggle { /* settings sub foldout toggle */
+    background-color: rgba(0, 0, 0, 0.1);
+}
+
+.mm-settings-is-playing {
+    background-color: #FFC400;
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_LightSkin.uss.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 14b92bfe5ef8242479d196b4e9916647
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_LightSkin.uss
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_Settings.uss

@@ -0,0 +1,56 @@
+.mm-settings-foldout { /* settings foldout */
+    background-color: rgba(0, 0, 0, 0);
+    margin-bottom: 5px;
+    border-left-width: 0px;
+    border-color: rgba(255, 255, 255, 0.3);
+    border-width: 1px;
+    border-left-width: 0px;
+    border-right-width: 0px;
+    border-top-width: 0px;
+    padding-right: 0px;
+}
+
+.mm-settings-foldout Label, mm-settings-foldout Label:hover, mm-settings-foldout Label:active { /* settings foldout label */
+    color: rgba(220, 220, 220, 1);
+}
+
+.mm-settings-foldout .unity-toggle__input {
+    padding: 3px;
+}
+
+.mm-settings-icon { /* settings icon */
+    margin-top: 2px;
+}
+
+Toggle.mm-settings-foldout-toggle { /* settings foldout toggle */
+    background-color: rgba(0, 0, 0, 0.3);
+    padding-left: 10px;
+    -unity-background-scale-mode: scale-to-fit;
+}
+
+.mm-settings-foldout-sub { /* settings sub foldout */
+    background-color: rgba(0, 0, 0, 0.1);
+    margin-left: -5px;
+}
+
+Toggle.mm-settings-foldout-sub-toggle { /* settings sub foldout toggle */
+    background-color: rgba(0, 0, 0, 0.4);
+    margin-top: 0px;
+}
+
+.mm-settings-info {
+    flex-direction: row;
+    -unity-font-style: normal;
+}
+
+.mm-settings-is-playing {
+    background-color: #FFC400;
+    color: black;
+    padding: 2px;
+    padding-left: 5px;
+    padding-right: 5px;
+    -unity-font-style: bold;
+    right: 75px;
+    position: absolute;
+    display: none;
+}

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_Settings.uss.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 390bf4a7227d9094e82fd024ef00a069
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/MMF_PlayerEditorUITKStyleSheet_Settings.uss
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures.meta

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

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/FeelBottomToTopIcon@2x.png.meta

@@ -0,0 +1,147 @@
+fileFormatVersion: 2
+guid: cd807e3eb5122524d9a1783af6375956
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/FeelBottomToTopIcon@2x.png
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/FeelCloseSearchField.png.meta

@@ -0,0 +1,137 @@
+fileFormatVersion: 2
+guid: be687c348d0c62c45a733dc1ae6f018f
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/FeelCloseSearchField.png
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/FeelContextMenu@2x.png.meta

@@ -0,0 +1,134 @@
+fileFormatVersion: 2
+guid: ab4146e63d28b4c479103682a751663c
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/FeelContextMenu@2x.png
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/FeelEmptyList.png.meta

@@ -0,0 +1,134 @@
+fileFormatVersion: 2
+guid: e305d4ff6fcb66148a89b78f93cc03fa
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/FeelEmptyList.png
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/FeelGearIcon@2x.png.meta

@@ -0,0 +1,134 @@
+fileFormatVersion: 2
+guid: 13a276490eda9164f86cc22771d27073
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/FeelGearIcon@2x.png
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/FeelSetupRequired@2x.png.meta

@@ -0,0 +1,134 @@
+fileFormatVersion: 2
+guid: 69bdc1f611c0f8d4dbc71613a9b04b9b
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/FeelSetupRequired@2x.png
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/TopToBottomIcon@2x.png.meta

@@ -0,0 +1,147 @@
+fileFormatVersion: 2
+guid: c23294d57f74bea4b9a439f033a6bf15
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Core/UIToolkit/Textures/TopToBottomIcon@2x.png
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Curves.meta

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

Assets/External/Feel/MMFeedbacks/Editor/Curves/Editor.meta

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

Assets/External/Feel/MMFeedbacks/Editor/Curves/Editor/MMFAntiCurves.curves.meta

@@ -0,0 +1,15 @@
+fileFormatVersion: 2
+guid: dcef6f636a0aab845a6c8d9b97bb4b51
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Curves/Editor/MMFAntiCurves.curves
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Curves/Editor/MMFCurves.curves.meta

@@ -0,0 +1,15 @@
+fileFormatVersion: 2
+guid: 378d85c023238454db159ae565d259dd
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Curves/Editor/MMFCurves.curves
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/FeedbackListOutputter.meta

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

Assets/External/Feel/MMFeedbacks/Editor/FeedbackListOutputter/FeedbackListOutputer.cs

@@ -0,0 +1,77 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.PackageManager.Requests;
+using UnityEditor.PackageManager;
+using UnityEngine;
+using System.Threading.Tasks;
+using System.Linq;
+using System.Text;
+using MoreMountains.Tools;
+
+namespace MoreMountains.Feedbacks
+{
+	/// <summary>
+	/// This class is used to automatically install optional dependencies used in MMFeedbacks
+	/// </summary>
+	public static class FeedbackListOutputer 
+	{
+		/// <summary>
+		/// Outputs a list of all MMFeedbacks to the console (there's only one target user for this and it's me hello!)
+		/// </summary>
+		[MenuItem("Tools/More Mountains/MMFeedbacks/Output MMF_Feedbacks list", false, 705)]
+		public static void OutputIFeedbacksList()
+		{
+			// Retrieve available feedbacks
+			List<System.Type> types = (from domainAssembly in System.AppDomain.CurrentDomain.GetAssemblies()
+				from assemblyType in domainAssembly.GetTypes()
+				where assemblyType.IsSubclassOf(typeof(MMF_Feedback))
+				select assemblyType).ToList();
+            
+			List<string> typeNames = new List<string>();
+
+
+			string previousType = "";
+			for (int i = 0; i < types.Count; i++)
+			{
+				MMF_PlayerEditorUITK.FeedbackTypePair newType = new MMF_PlayerEditorUITK.FeedbackTypePair();
+				newType.FeedbackType = types[i];
+				newType.FeedbackName = FeedbackPathAttribute.GetFeedbackDefaultPath(types[i]);
+				if (newType.FeedbackName == "MMF_FeedbackBase")
+				{
+					continue;
+				}
+
+				string newEntry = FeedbackPathAttribute.GetFeedbackDefaultPath(newType.FeedbackType);
+				typeNames.Add(newEntry);
+			}
+            
+			typeNames.Sort();
+			StringBuilder builder = new StringBuilder();
+			int counter = 1;
+			foreach (string typeName in typeNames)
+			{
+				if (typeName == null)
+				{
+					continue;
+				}
+				string[] splitArray =  typeName.Split(char.Parse("/"));
+                
+				if ((previousType != splitArray[0]) && (counter > 1))
+				{
+					builder.Append("\n");
+				}
+                
+				builder.Append("- [ ] ");
+				builder.Append(counter.ToString("000"));
+				builder.Append(" - ");
+				builder.Append(typeName);
+				builder.Append("\n");
+
+				previousType = splitArray[0];
+				counter++;
+			}
+			MMDebug.DebugLogInfo(builder.ToString());
+		}
+	}    
+}

Assets/External/Feel/MMFeedbacks/Editor/FeedbackListOutputter/FeedbackListOutputer.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: f832a347ffbe22e478be454dc5dc3cff
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/FeedbackListOutputter/FeedbackListOutputer.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/MoreMountains.Feedbacks.Editor.asmref

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

Assets/External/Feel/MMFeedbacks/Editor/MoreMountains.Feedbacks.Editor.asmref.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 9722df90d8b438e4b8b47fee471fbbee
+AssemblyDefinitionReferenceImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/MoreMountains.Feedbacks.Editor.asmref
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Resources.meta

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

Assets/External/Feel/MMFeedbacks/Editor/Resources/MMF_PlayerConfiguration.asset

@@ -0,0 +1,17 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 8bcf466015f0b254893ff0208fccf90f, type: 3}
+  m_Name: MMF_PlayerConfiguration
+  m_EditorClassIdentifier: 
+  ShowInspectorTips: 1
+  AutoDisableKeepPlaymodeChanges: 1
+  InspectorGroupsExpandedByDefault: 1

Assets/External/Feel/MMFeedbacks/Editor/Resources/MMF_PlayerConfiguration.asset.meta

@@ -0,0 +1,15 @@
+fileFormatVersion: 2
+guid: c14ab46a507c8324c8b54e6a3fdc2b0e
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Resources/MMF_PlayerConfiguration.asset
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Resources/MMFeedbacksConfiguration.asset

@@ -0,0 +1,16 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 00bf1cad26d9e9342b90f463840caf08, type: 3}
+  m_Name: MMFeedbacksConfiguration
+  m_EditorClassIdentifier: 
+  _mmFeedbacks: {fileID: 0}
+  ShowInspectorTips: 1

Assets/External/Feel/MMFeedbacks/Editor/Resources/MMFeedbacksConfiguration.asset.meta

@@ -0,0 +1,15 @@
+fileFormatVersion: 2
+guid: 59a4add72d602ce4a9693b14a97d2a83
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Resources/MMFeedbacksConfiguration.asset
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Sequencing.meta

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

Assets/External/Feel/MMFeedbacks/Editor/Sequencing/MMInputSequenceRecorderEditor.cs

@@ -0,0 +1,189 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace MoreMountains.Feedbacks
+{
+	/// <summary>
+	/// Custom editor for sequence recorder
+	/// </summary>
+	[CustomEditor(typeof(MMInputSequenceRecorder), true)]
+	[CanEditMultipleObjects]
+	public class MMInputSequenceRecorderEditor : Editor
+	{
+		protected SerializedProperty _Recording;
+		protected float _inspectorWidth;
+		protected int _externalMargin = 10;
+		protected Rect _rect;
+		protected Color _recordingColor =  Color.red;
+		protected Color _recordingTextColor = Color.white;
+		protected Vector2 _boxPosition;
+		protected Vector2 _boxSize;
+		protected GUIStyle _recordingStyle;
+		protected MMInputSequenceRecorder _targetRecorder;
+		protected Event _currentEvent;
+
+		/// <summary>
+		/// Forces constant inspector repaints
+		/// </summary>
+		/// <returns></returns>
+		public override bool RequiresConstantRepaint()
+		{
+			return true;
+		}
+
+		/// <summary>
+		/// On enable we initialize our styles and listen for input in editor mode
+		/// </summary>
+		protected virtual void OnEnable()
+		{
+			_Recording = serializedObject.FindProperty("Recording");
+
+			_recordingStyle = new GUIStyle();
+			_recordingStyle.normal.textColor = Color.white;
+			_recordingStyle.fontSize = 30;
+			_recordingStyle.alignment = TextAnchor.MiddleCenter;
+			_targetRecorder = (MMInputSequenceRecorder)target;
+
+			System.Reflection.FieldInfo info = typeof(EditorApplication).GetField("globalEventHandler", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
+			EditorApplication.CallbackFunction value = (EditorApplication.CallbackFunction)info.GetValue(null);
+			value += EditorGlobalKeyPress;
+			info.SetValue(null, value);
+		}
+
+		/// <summary>
+		/// Looks for input
+		/// </summary>
+		protected virtual void EditorGlobalKeyPress()
+		{
+			if (Application.isPlaying)
+			{
+				return;
+			}
+
+			HandleUtility.AddDefaultControl(GUIUtility.GetControlID(FocusType.Passive));
+			_currentEvent = Event.current;
+            
+			if (_currentEvent == null)
+			{
+				return;
+			}
+
+			DetectStartAndEnd();
+			EditorDetectRecording();
+		}
+
+		/// <summary>
+		/// Detects presses on the start or end keys
+		/// </summary>
+		protected virtual void DetectStartAndEnd()
+		{
+			if (_currentEvent.isKey)
+			{
+				if (!_targetRecorder.Recording)
+				{
+					if ((_currentEvent.keyCode == _targetRecorder.StartRecordingHotkey) && (_currentEvent.type == EventType.KeyDown))
+					{
+						_targetRecorder.StartRecording();
+					}
+				}
+				else
+				{
+					if ((_currentEvent.keyCode == _targetRecorder.StopRecordingHotkey) && (_currentEvent.type == EventType.KeyDown))
+					{
+						_targetRecorder.StopRecording();
+					}
+				}
+			}
+		}
+
+		/// <summary>
+		/// Looks for key presses on sequence key bindings
+		/// </summary>
+		protected virtual void EditorDetectRecording()
+		{
+			if (_targetRecorder.Recording && (_targetRecorder.SequenceScriptableObject != null))
+			{
+				if (_currentEvent.isKey)
+				{
+					foreach (MMSequenceTrack track in _targetRecorder.SequenceScriptableObject.SequenceTracks)
+					{
+						if (_currentEvent.keyCode == (track.Key))
+						{
+							if (track.State == MMSequenceTrackStates.Up)
+							{
+								track.State = MMSequenceTrackStates.Idle;
+							}
+							if (_currentEvent.type == EventType.KeyDown)
+							{
+								if (track.State != MMSequenceTrackStates.Down)
+								{
+									// key is down for the first time
+									_targetRecorder.AddNoteToTrack(track);
+								}
+								track.State = MMSequenceTrackStates.Down;
+							}
+							if (_currentEvent.type == EventType.KeyUp)
+							{
+								// key is up
+								track.State = MMSequenceTrackStates.Up;
+							}
+						}
+					}
+				}
+			}
+		}
+
+		/// <summary>
+		/// Draws the custom inspector
+		/// </summary>
+		public override void OnInspectorGUI()
+		{
+			serializedObject.Update();
+			Undo.RecordObject(target, "Modified Sequence Recorder");
+
+			_inspectorWidth = EditorGUIUtility.currentViewWidth - 24;
+
+			// display recording label
+			if (_Recording.boolValue)
+			{
+				GUILayout.Box("", GUILayout.Width(_inspectorWidth - _externalMargin), GUILayout.Height(50));
+				_boxPosition = GUILayoutUtility.GetLastRect().position;
+				_boxSize = GUILayoutUtility.GetLastRect().size;
+				_rect.x = _boxPosition.x;
+				_rect.y = _boxPosition.y;
+				_rect.width = _boxSize.x;
+				_rect.height = _boxSize.y;
+				EditorGUI.DrawRect(_rect, _recordingColor);
+                
+				EditorGUI.LabelField(_rect, "RECORDING", _recordingStyle);
+			}
+
+			DrawDefaultInspector();
+
+			// separator
+			EditorGUILayout.Space();
+			EditorGUILayout.LabelField("Controls", EditorStyles.boldLabel);
+
+			if (!_Recording.boolValue)
+			{
+				// display start recording button
+				if (GUILayout.Button("Start Recording"))
+				{
+					_targetRecorder.StartRecording();
+				}
+			}
+			else
+			{
+				// display stop recording button
+				if (GUILayout.Button("Stop Recording"))
+				{
+					_targetRecorder.StopRecording();
+				}
+			}
+
+			serializedObject.ApplyModifiedProperties();
+		}
+	}
+}

Assets/External/Feel/MMFeedbacks/Editor/Sequencing/MMInputSequenceRecorderEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 356e077c6b0c8614fa08b93f8099bedf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Sequencing/MMInputSequenceRecorderEditor.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Sequencing/MMSequencerEditor.cs

@@ -0,0 +1,418 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace MoreMountains.Feedbacks
+{
+	/// <summary>
+	/// Custom editor for MMSequencer, handles recalibration and sequencer display
+	/// </summary>
+	[CustomEditor(typeof(MMSequencer), true)]
+	[CanEditMultipleObjects]
+	public class MMSequencerEditor : Editor
+	{
+		protected MMSequencer _targetSequencer;
+		protected float _inspectorWidth;
+		protected GUIStyle _buttonStyle;
+		protected GUIStyle _trackControlStyle;
+		protected GUIStyle _indexStyle;
+		protected Texture2D _buttonBackground;
+		protected Texture2D _dotBackground;
+		protected Color _buttonColor;
+		protected Color _trackControlColor;
+
+		protected Color _emptyButtonColor = new Color(0,0,0,0.5f);
+		protected Color _empty4ButtonColor = new Color(0, 0, 0, 0.75f);
+		protected const float _buttonWidth = 24;
+		protected const float _trackControlWidth = 11;
+		protected const float _distanceBetweenButtons = 6f;
+		protected int _boxesPerLine;
+		protected Color _originalBackgroundColor;
+		protected Color _controlColor;
+
+		protected List<float> _trackControlLastUseTimestamps;
+
+		/// <summary>
+		/// We want constant repaint on this inspector
+		/// </summary>
+		/// <returns></returns>
+		public override bool RequiresConstantRepaint()
+		{
+			return true;
+		}
+
+		/// <summary>
+		/// On enable we grab our textures and initialize our styles
+		/// </summary>
+		protected virtual void OnEnable()
+		{
+			_targetSequencer = (MMSequencer)target;
+			_buttonBackground = Resources.Load("SequencerButtonBackground") as Texture2D;
+			_dotBackground = Resources.Load("SequencerDotBackground") as Texture2D;
+			_originalBackgroundColor = GUI.backgroundColor;
+
+			_buttonStyle = new GUIStyle();
+			_buttonStyle.normal.background = _buttonBackground;
+			_buttonStyle.fixedWidth = _buttonWidth;
+			_buttonStyle.fixedHeight = _buttonWidth;
+
+			_trackControlStyle = new GUIStyle();
+			_trackControlStyle.normal.background = _dotBackground;
+			_trackControlStyle.normal.textColor = (Application.isPlaying) ? Color.black : Color.white;
+			_trackControlStyle.fixedWidth = _trackControlWidth;
+			_trackControlStyle.fixedHeight = _trackControlWidth;            
+			_trackControlStyle.margin = new RectOffset(0, 0, 1, 0);
+			_trackControlStyle.alignment = TextAnchor.MiddleCenter;
+			_trackControlStyle.fontSize = 10;
+
+
+			_indexStyle = new GUIStyle();
+			_indexStyle.normal.background = _dotBackground;
+			_indexStyle.normal.textColor = Color.white;
+			_indexStyle.alignment = TextAnchor.MiddleCenter;
+			_indexStyle.fixedWidth = _trackControlWidth * 1.5f;
+			_indexStyle.fixedHeight = _trackControlWidth * 1.5f;
+
+			FillControlList();
+		}
+
+		protected virtual void FillControlList()
+		{
+			// fill the control timer list
+			if (_targetSequencer.Sequence != null)
+			{
+				_trackControlLastUseTimestamps = new List<float>();
+				foreach (MMSequenceTrack track in _targetSequencer.Sequence.SequenceTracks)
+				{
+					_trackControlLastUseTimestamps.Add(0f);
+				}
+			}
+		}
+
+		/// <summary>
+		/// Draws the default inspector and the sequencer
+		/// </summary>
+		public override void OnInspectorGUI()
+		{
+			serializedObject.Update();
+			Undo.RecordObject(target, "Modified Sequence Recorder");
+
+			DrawDefaultInspector();
+
+			if (_targetSequencer.Sequence == null)
+			{
+				_targetSequencer.LastSequence = null;
+				return;
+			}
+
+			// gets the width and computes how many boxes we can fit per line
+			_inspectorWidth = EditorGUIUtility.currentViewWidth - 24;
+			_boxesPerLine = (int)Mathf.Round(
+				(_inspectorWidth - ((_targetSequencer.Sequence.SequenceTracks.Count) * _distanceBetweenButtons) - _trackControlWidth - _distanceBetweenButtons)
+				/ (_buttonWidth + _distanceBetweenButtons)
+			) + 1;
+
+			LookForChanges();
+            
+			// separator
+			EditorGUILayout.Space();
+			EditorGUILayout.LabelField("Sequencer", EditorStyles.boldLabel);
+
+			EditorGUILayout.BeginHorizontal();
+			if (GUILayout.Button("Destroy and rebuild sequence", EditorStyles.miniButtonLeft))
+			{
+				_targetSequencer.Sequence.QuantizedSequence = null;
+				_targetSequencer.LastTracksCount = -1;
+				_targetSequencer.ApplySequencerLengthToSequence();
+				EditorUtility.SetDirty(_targetSequencer.Sequence);
+			}
+			if (GUILayout.Button("Clear Sequence", EditorStyles.miniButtonMid))
+			{
+				_targetSequencer.ClearSequence();
+				EditorUtility.SetDirty(_targetSequencer.Sequence);
+			}
+			if (GUILayout.Button("[ - ] Length - 1", EditorStyles.miniButtonMid))
+			{
+				_targetSequencer.DecrementLength();
+				EditorUtility.SetDirty(_targetSequencer.Sequence);
+			}
+			if (GUILayout.Button("[ + ] Length + 1", EditorStyles.miniButtonRight))
+			{
+				_targetSequencer.IncrementLength();
+				EditorUtility.SetDirty(_targetSequencer.Sequence);
+			}
+			EditorGUILayout.EndHorizontal();
+            
+			EditorGUILayout.Space();
+			EditorGUILayout.Space();
+			DrawSequenceIndexes();
+			for (int i = 0; i < _targetSequencer.Sequence.SequenceTracks.Count; i++)
+			{
+				DrawTrack(i);
+			}
+
+			DrawControlButtons();
+
+			serializedObject.ApplyModifiedProperties();
+		}
+
+		/// <summary>
+		/// Whenever we detect a change in the settings we recalibrate our sequence accordingly
+		/// </summary>
+		protected virtual void LookForChanges()
+		{
+			if (_targetSequencer.LastSequence != _targetSequencer.Sequence)
+			{
+				FillControlList();
+				if (_targetSequencer.Sequence.QuantizedSequence.Count > 0)
+				{
+					if (_targetSequencer.Sequence.QuantizedSequence[0].Line.Count != _targetSequencer.SequencerLength)
+					{
+						_targetSequencer.SequencerLength = _targetSequencer.Sequence.QuantizedSequence[0].Line.Count;
+						_targetSequencer.LastSequencerLength = _targetSequencer.SequencerLength;
+						_targetSequencer.LastSequence = _targetSequencer.Sequence;
+						_targetSequencer.LastTracksCount = _targetSequencer.Sequence.SequenceTracks.Count;
+					}
+				}
+				else
+				{
+					_targetSequencer.ApplySequencerLengthToSequence();
+					_targetSequencer.LastSequence = _targetSequencer.Sequence;
+					EditorUtility.SetDirty(_targetSequencer.Sequence);
+				}                
+			}   
+            
+			if (_targetSequencer.LastSequence == _targetSequencer.Sequence)
+			{
+				if (_targetSequencer.LastTracksCount != _targetSequencer.Sequence.SequenceTracks.Count)
+				{
+					FillControlList();
+					_targetSequencer.ApplySequencerLengthToSequence();
+					EditorUtility.SetDirty(_targetSequencer.Sequence);
+				}
+				if (_targetSequencer.LastBPM != _targetSequencer.BPM)
+				{
+					_targetSequencer.UpdateTimestampsToMatchNewBPM();
+					EditorUtility.SetDirty(_targetSequencer.Sequence);
+				}
+			}
+
+			_targetSequencer.EditorMaintenance();
+		}
+
+		/// <summary>
+		/// Draws control buttons
+		/// </summary>
+		protected virtual void DrawControlButtons()
+		{
+			if (!Application.isPlaying)
+			{
+				return;
+			}
+			GUI.backgroundColor = _originalBackgroundColor;
+			EditorGUILayout.Space();
+			EditorGUILayout.LabelField("Controls", EditorStyles.boldLabel);
+
+			if (_targetSequencer.Playing)
+			{
+				if (GUILayout.Button("Stop Playing"))
+				{
+					_targetSequencer.StopSequence();
+				}
+			}
+			else
+			{
+				if (GUILayout.Button("Start Playing"))
+				{
+					_targetSequencer.PlaySequence();
+				}
+			}
+			if (GUILayout.Button("Play Next Beat"))
+			{
+				_targetSequencer.PlayBeat();
+			}
+		}
+
+		/// <summary>
+		/// Draws an index for each sequence item
+		/// </summary>
+		protected virtual void DrawSequenceIndexes()
+		{
+			GUILayout.BeginHorizontal();
+
+			GUI.backgroundColor = _emptyButtonColor;
+			GUILayout.Label("", GUILayout.Width(_trackControlWidth + _distanceBetweenButtons), GUILayout.Height(_trackControlWidth));
+			string label = "";
+			for (int i = 0; i < _targetSequencer.SequencerLength; i++)
+			{
+				label = i < 10 ? " " + i.ToString() : i.ToString();
+				_trackControlStyle.fontStyle = (i % 4 == 0) ? FontStyle.Bold : FontStyle.Normal;
+				//GUILayout.Label(label, _indexStyle, GUILayout.Width(_buttonWidth + _distanceBetweenButtons), GUILayout.Height(_trackControlWidth));
+				if (GUILayout.Button(label, _indexStyle, GUILayout.Width(_buttonWidth + _distanceBetweenButtons), GUILayout.Height(_trackControlWidth)))
+				{
+					_targetSequencer.ToggleStep(i);
+					EditorUtility.SetDirty(_targetSequencer.Sequence);
+				}
+			}
+			GUI.backgroundColor = _originalBackgroundColor;
+			GUILayout.EndHorizontal();
+			GUILayout.Space(_distanceBetweenButtons * 1.5f);
+		}
+
+		/// <summary>
+		/// Draws a line of the sequencer
+		/// </summary>
+		/// <param name="trackIndex"></param>
+		protected virtual void DrawTrack(int trackIndex)
+		{
+			int counter = 0;
+
+			if (_targetSequencer.Sequence.QuantizedSequence == null)
+			{
+				return;
+			}
+
+			if (_targetSequencer.Sequence.QuantizedSequence.Count != _targetSequencer.Sequence.SequenceTracks.Count)
+			{
+				return;
+			}
+
+			GUILayout.BeginHorizontal();
+
+
+			GUILayout.BeginVertical();
+
+			// draw active track control
+
+			if (_targetSequencer.Sequence.SequenceTracks[trackIndex].Active)
+			{
+				_trackControlColor = _targetSequencer.Sequence.SequenceTracks[trackIndex].TrackColor;
+			}
+			else
+			{
+				_trackControlColor = _emptyButtonColor;
+			}
+
+			GUI.backgroundColor = _trackControlColor;
+			if (GUILayout.Button("", _trackControlStyle, GUILayout.Width(_trackControlWidth), GUILayout.Height(_trackControlWidth)))
+			{
+				if (_targetSequencer.TrackEvents[trackIndex] != null)
+				{
+					_targetSequencer.ToggleActive(trackIndex);
+					EditorUtility.SetDirty(_targetSequencer.Sequence);
+				}
+			}
+
+			GUILayout.Space(_distanceBetweenButtons / 5);
+
+			// draw test track control
+			_trackControlColor = _targetSequencer.Sequence.SequenceTracks[trackIndex].TrackColor;
+			_controlColor = Application.isPlaying ? SequencerColor(_trackControlLastUseTimestamps[trackIndex], _trackControlColor) : Color.black;
+			GUI.backgroundColor = _controlColor;
+			if (GUILayout.Button(trackIndex.ToString(), _trackControlStyle, GUILayout.Width(_trackControlWidth), GUILayout.Height(_trackControlWidth)))
+			{
+				if (_targetSequencer.TrackEvents[trackIndex] != null)
+				{
+					_trackControlLastUseTimestamps[trackIndex] = Time.time;
+					_targetSequencer.PlayTrackEvent(trackIndex);
+				}
+			}
+			GUILayout.EndVertical();
+
+			GUILayout.Space(_distanceBetweenButtons);
+
+			for (int i = 0; i < _targetSequencer.Sequence.QuantizedSequence[trackIndex].Line.Count; i++)
+			{
+				// handle new lines
+				if (counter > _boxesPerLine )
+				{
+					GUILayout.EndHorizontal();
+					GUILayout.Space(_distanceBetweenButtons);
+					GUILayout.BeginHorizontal();
+					counter = 0;
+				}
+
+				if (_targetSequencer.Sequence.QuantizedSequence[trackIndex].Line[i].ID != -1)
+				{
+					_buttonColor = _targetSequencer.Sequence.SequenceTracks[trackIndex].TrackColor;
+				}
+				else
+				{
+					if (i % 4 == 0)
+					{
+						_buttonColor = _empty4ButtonColor;
+					}
+					else
+					{
+						_buttonColor = _emptyButtonColor;
+					}
+				}
+				// if the track is inactive, we reduce colors
+				if (!_targetSequencer.Sequence.SequenceTracks[trackIndex].Active)
+				{
+					_buttonColor = _buttonColor / 2f;
+				}
+
+				DrawSequenceButton(trackIndex, i, _buttonColor);
+                
+				counter++;
+			}
+			GUILayout.FlexibleSpace();
+			GUILayout.EndHorizontal();
+			GUILayout.Space(_distanceBetweenButtons);
+		}
+
+		/// <summary>
+		/// Draws an interactive button for the sequencer
+		/// </summary>
+		/// <param name="trackIndex"></param>
+		/// <param name="sequenceIndex"></param>
+		/// <param name="buttonColor"></param>
+		protected virtual void DrawSequenceButton(int trackIndex, int sequenceIndex, Color buttonColor)
+		{
+
+			if (Application.isPlaying && _targetSequencer.PlayedOnce && (_targetSequencer.LastBeatIndex == sequenceIndex))
+			{
+				if (_targetSequencer.BeatThisFrame)
+				{
+					_buttonColor = Color.white;
+				}
+				else
+				{
+					_buttonColor = SequencerColor(_targetSequencer.LastBeatTimestamp, buttonColor);
+				}
+			}
+			else
+			{
+				_buttonColor = buttonColor;
+			}
+
+			GUI.backgroundColor = _buttonColor;
+			if (GUILayout.Button("", _buttonStyle, GUILayout.Width(_buttonWidth), GUILayout.Height(_buttonWidth)))
+			{
+				bool active = (_targetSequencer.Sequence.QuantizedSequence[trackIndex].Line[sequenceIndex].ID == _targetSequencer.Sequence.SequenceTracks[trackIndex].ID);
+				_targetSequencer.Sequence.QuantizedSequence[trackIndex].Line[sequenceIndex].ID = active ? -1 : _targetSequencer.Sequence.SequenceTracks[trackIndex].ID;
+				EditorUtility.SetDirty(_targetSequencer.Sequence);
+			}
+			GUILayout.Space(_distanceBetweenButtons);
+		}
+
+		/// <summary>
+		/// Color interpolation on hits
+		/// </summary>
+		/// <param name="lastBeatTimestamp"></param>
+		/// <param name="buttonColor"></param>
+		/// <returns></returns>
+		protected virtual Color SequencerColor(float lastBeatTimestamp, Color buttonColor)
+		{
+			float x = (Time.time - lastBeatTimestamp);
+			float A = 0f;
+			float B = (60f / _targetSequencer.BPM) / 4f;
+			float C = 0f;
+			float D = 1f;
+			float t = C + (x - A) / (B - A) * (D - C);
+			return Color.Lerp(Color.white, buttonColor, t);
+		}
+	}
+}

Assets/External/Feel/MMFeedbacks/Editor/Sequencing/MMSequencerEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 6f57413f575191641b987d9d04e61e3a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Sequencing/MMSequencerEditor.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Sequencing/Resources.meta

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

Assets/External/Feel/MMFeedbacks/Editor/Sequencing/Resources/SequencerButtonBackground.png.meta

@@ -0,0 +1,146 @@
+fileFormatVersion: 2
+guid: e802b29e86b4ef74abe728250ecaf37c
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 10
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: -1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 2, y: 2, z: 2, w: 2}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Sequencing/Resources/SequencerButtonBackground.png
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Sequencing/Resources/SequencerDotBackground.png.meta

@@ -0,0 +1,146 @@
+fileFormatVersion: 2
+guid: 82c9d5c8726c57249b51c39e76eee072
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 10
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: -1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Sequencing/Resources/SequencerDotBackground.png
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Shakers.meta

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

Assets/External/Feel/MMFeedbacks/Editor/Shakers/MMWiggleEditor.cs

@@ -0,0 +1,264 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace MoreMountains.Feedbacks
+{
+	[CanEditMultipleObjects]
+	[CustomEditor(typeof(MMWiggle), true)]
+	public class MMWiggleEditor : Editor
+	{
+		public struct WiggleEditorProperties
+		{
+			public SerializedProperty WigglePermitted;
+
+			public SerializedProperty WiggleType;
+			public SerializedProperty UseUnscaledTime;
+			public SerializedProperty TimeMultiplier;
+			public SerializedProperty RelativeAmplitude;
+			public SerializedProperty UniformValues;
+			public SerializedProperty ForceVectorLength;
+			public SerializedProperty ForcedVectorLength;
+			public SerializedProperty StartWigglingAutomatically;
+
+			public SerializedProperty SmoothPingPong;
+			public SerializedProperty UseSpeedCurve;
+			public SerializedProperty SpeedCurve;
+
+			public SerializedProperty FrequencyMin;
+			public SerializedProperty FrequencyMax;
+
+			public SerializedProperty AmplitudeMin;
+			public SerializedProperty AmplitudeMax;
+			public SerializedProperty PauseMin;
+			public SerializedProperty PauseMax;
+
+			public SerializedProperty NoiseFrequencyMin;
+			public SerializedProperty NoiseFrequencyMax;
+			public SerializedProperty NoiseShiftMin;
+			public SerializedProperty NoiseShiftMax;
+
+			public SerializedProperty LimitedTime;
+			public SerializedProperty LimitedTimeTotal;
+			public SerializedProperty LimitedTimeLeft;
+			public SerializedProperty LimitedTimeFalloff;
+			public SerializedProperty LimitedTimeResetValue;
+
+			public SerializedProperty Curve;
+			public SerializedProperty RemapCurveZeroMin;
+			public SerializedProperty RemapCurveZeroMax;
+			public SerializedProperty RemapCurveOneMin;
+			public SerializedProperty RemapCurveOneMax;
+			public SerializedProperty RelativeCurveAmplitude;
+			public SerializedProperty CurvePingPong;
+		}
+
+		protected SerializedProperty _updateMode;
+
+		protected SerializedProperty _positionActive;
+		protected SerializedProperty _rotationActive;
+		protected SerializedProperty _scaleActive;
+
+		protected SerializedProperty _positionProperties;
+		protected SerializedProperty _rotationProperties;
+		protected SerializedProperty _scaleProperties;
+
+		protected WiggleEditorProperties _positionEditorProperties;
+		protected WiggleEditorProperties _rotationEditorProperties;
+		protected WiggleEditorProperties _scaleEditorProperties;
+
+		protected SerializedProperty _debugWiggleDuration;
+
+		protected MMWiggle _mmWiggle;
+
+		public bool StartWigglingAutomatically = true;
+
+		protected virtual void OnEnable()
+		{
+			_mmWiggle = (MMWiggle)target;
+
+			_updateMode = serializedObject.FindProperty("UpdateMode");
+
+			_positionProperties = serializedObject.FindProperty("PositionWiggleProperties");
+			_rotationProperties = serializedObject.FindProperty("RotationWiggleProperties");
+			_scaleProperties = serializedObject.FindProperty("ScaleWiggleProperties");
+
+			_positionActive = serializedObject.FindProperty("PositionActive");
+			_rotationActive = serializedObject.FindProperty("RotationActive");
+			_scaleActive = serializedObject.FindProperty("ScaleActive");
+
+			_debugWiggleDuration = serializedObject.FindProperty("DebugWiggleDuration");
+
+			InitializeProperties(_positionProperties, ref _positionEditorProperties);
+			InitializeProperties(_rotationProperties, ref _rotationEditorProperties);
+			InitializeProperties(_scaleProperties, ref _scaleEditorProperties);
+		}
+
+		protected virtual void InitializeProperties(SerializedProperty targetProperty, ref WiggleEditorProperties editorProperties)
+		{
+			editorProperties.WigglePermitted = targetProperty.FindPropertyRelative("WigglePermitted");
+			editorProperties.WiggleType = targetProperty.FindPropertyRelative("WiggleType");
+			editorProperties.UseUnscaledTime = targetProperty.FindPropertyRelative("UseUnscaledTime");
+			editorProperties.TimeMultiplier = targetProperty.FindPropertyRelative("TimeMultiplier");
+			editorProperties.RelativeAmplitude = targetProperty.FindPropertyRelative("RelativeAmplitude");
+			editorProperties.UniformValues = targetProperty.FindPropertyRelative("UniformValues");
+			editorProperties.ForceVectorLength = targetProperty.FindPropertyRelative("ForceVectorLength");
+			editorProperties.ForcedVectorLength = targetProperty.FindPropertyRelative("ForcedVectorLength");
+			editorProperties.StartWigglingAutomatically = targetProperty.FindPropertyRelative("StartWigglingAutomatically");
+			editorProperties.SmoothPingPong = targetProperty.FindPropertyRelative("SmoothPingPong");
+			editorProperties.UseSpeedCurve = targetProperty.FindPropertyRelative("UseSpeedCurve");
+			editorProperties.SpeedCurve = targetProperty.FindPropertyRelative("SpeedCurve");
+			editorProperties.FrequencyMin = targetProperty.FindPropertyRelative("FrequencyMin");
+			editorProperties.FrequencyMax = targetProperty.FindPropertyRelative("FrequencyMax");
+			editorProperties.AmplitudeMin = targetProperty.FindPropertyRelative("AmplitudeMin");
+			editorProperties.AmplitudeMax = targetProperty.FindPropertyRelative("AmplitudeMax");
+			editorProperties.PauseMin = targetProperty.FindPropertyRelative("PauseMin");
+			editorProperties.PauseMax = targetProperty.FindPropertyRelative("PauseMax");
+			editorProperties.NoiseFrequencyMin = targetProperty.FindPropertyRelative("NoiseFrequencyMin");
+			editorProperties.NoiseFrequencyMax = targetProperty.FindPropertyRelative("NoiseFrequencyMax");
+			editorProperties.NoiseShiftMin = targetProperty.FindPropertyRelative("NoiseShiftMin");
+			editorProperties.NoiseShiftMax = targetProperty.FindPropertyRelative("NoiseShiftMax");
+			editorProperties.LimitedTime = targetProperty.FindPropertyRelative("LimitedTime");
+			editorProperties.LimitedTimeTotal = targetProperty.FindPropertyRelative("LimitedTimeTotal");
+			editorProperties.LimitedTimeLeft = targetProperty.FindPropertyRelative("LimitedTimeLeft");
+			editorProperties.LimitedTimeFalloff = targetProperty.FindPropertyRelative("LimitedTimeFalloff");
+			editorProperties.LimitedTimeResetValue = targetProperty.FindPropertyRelative("LimitedTimeResetValue");
+			editorProperties.Curve = targetProperty.FindPropertyRelative("Curve");
+			editorProperties.RemapCurveZeroMin = targetProperty.FindPropertyRelative("RemapCurveZeroMin");
+			editorProperties.RemapCurveZeroMax = targetProperty.FindPropertyRelative("RemapCurveZeroMax");
+			editorProperties.RemapCurveOneMin = targetProperty.FindPropertyRelative("RemapCurveOneMin");
+			editorProperties.RemapCurveOneMax = targetProperty.FindPropertyRelative("RemapCurveOneMax");
+			editorProperties.RelativeCurveAmplitude = targetProperty.FindPropertyRelative("RelativeCurveAmplitude");
+			editorProperties.CurvePingPong = targetProperty.FindPropertyRelative("CurvePingPong");
+		}
+
+		public override void OnInspectorGUI()
+		{
+			serializedObject.Update();
+			Undo.RecordObject(target, "Modified MMWiggle");            
+
+			EditorGUILayout.Space();
+			EditorGUILayout.PropertyField(_updateMode);
+			EditorGUILayout.Space();
+			MMFeedbackStyling.DrawSplitter();
+			DrawValueEditor("Position", _positionActive, _positionEditorProperties, _mmWiggle.PositionWiggleProperties.WiggleType);
+			DrawValueEditor("Rotation", _rotationActive, _rotationEditorProperties, _mmWiggle.RotationWiggleProperties.WiggleType);
+			DrawValueEditor("Scale", _scaleActive, _scaleEditorProperties, _mmWiggle.ScaleWiggleProperties.WiggleType);
+			EditorGUILayout.Space();
+
+			EditorGUILayout.LabelField("Debug", EditorStyles.boldLabel);
+			EditorGUILayout.PropertyField(_debugWiggleDuration);
+			EditorGUILayout.BeginHorizontal();
+			{
+				if (GUILayout.Button("Wiggle Position", EditorStyles.miniButtonLeft))
+				{
+					_mmWiggle.WigglePosition(_debugWiggleDuration.floatValue);
+				}
+				if (GUILayout.Button("Wiggle Rotation", EditorStyles.miniButtonMid))
+				{
+					_mmWiggle.WiggleRotation(_debugWiggleDuration.floatValue);
+				}
+				if (GUILayout.Button("Wiggle Scale", EditorStyles.miniButtonRight))
+				{
+					_mmWiggle.WiggleScale(_debugWiggleDuration.floatValue);
+				}
+			}
+			EditorGUILayout.EndHorizontal();
+			EditorGUILayout.Space();
+
+			serializedObject.ApplyModifiedProperties();
+		}
+
+		protected virtual void DrawValueEditor(string title, SerializedProperty propertyActive, WiggleEditorProperties editorProperties, WiggleTypes wiggleType)
+		{
+			bool propertyIsExpanded = propertyActive.isExpanded;
+			bool propertyIsActive = propertyActive.boolValue;
+
+
+			Rect headerRect = MMFeedbackStyling.DrawSimpleHeader(
+				ref propertyIsExpanded,
+				ref propertyIsActive,
+				title);
+
+			propertyActive.isExpanded = propertyIsExpanded;
+			propertyActive.boolValue = propertyIsActive;
+
+			if (propertyIsExpanded)
+			{
+				EditorGUI.BeginDisabledGroup(!propertyIsActive);
+
+				EditorGUILayout.PropertyField(editorProperties.WigglePermitted);
+				EditorGUILayout.PropertyField(editorProperties.WiggleType);
+				EditorGUILayout.PropertyField(editorProperties.UseUnscaledTime);
+				EditorGUILayout.PropertyField(editorProperties.TimeMultiplier);
+
+				if ((wiggleType == WiggleTypes.PingPong) || (wiggleType == WiggleTypes.Random))
+				{
+					if (wiggleType == WiggleTypes.PingPong)
+					{
+						EditorGUILayout.PropertyField(editorProperties.SmoothPingPong);
+					}
+					EditorGUILayout.PropertyField(editorProperties.UseSpeedCurve);
+					if (editorProperties.UseSpeedCurve.boolValue)
+					{
+						EditorGUILayout.PropertyField(editorProperties.SpeedCurve);
+					}
+					EditorGUILayout.PropertyField(editorProperties.AmplitudeMin);
+					EditorGUILayout.PropertyField(editorProperties.AmplitudeMax);
+					EditorGUILayout.PropertyField(editorProperties.RelativeAmplitude);
+					EditorGUILayout.PropertyField(editorProperties.UniformValues);
+					EditorGUILayout.PropertyField(editorProperties.ForceVectorLength);
+					EditorGUILayout.PropertyField(editorProperties.ForcedVectorLength);
+					EditorGUILayout.PropertyField(editorProperties.FrequencyMin);
+					EditorGUILayout.PropertyField(editorProperties.FrequencyMax);
+					EditorGUILayout.PropertyField(editorProperties.PauseMin);
+					EditorGUILayout.PropertyField(editorProperties.PauseMax);
+				}
+
+				if (wiggleType == WiggleTypes.Noise)
+				{
+					EditorGUILayout.PropertyField(editorProperties.AmplitudeMin);
+					EditorGUILayout.PropertyField(editorProperties.AmplitudeMax);
+					EditorGUILayout.PropertyField(editorProperties.RelativeAmplitude);
+					EditorGUILayout.PropertyField(editorProperties.UniformValues);
+					EditorGUILayout.PropertyField(editorProperties.ForceVectorLength);
+					EditorGUILayout.PropertyField(editorProperties.ForcedVectorLength);
+					EditorGUILayout.PropertyField(editorProperties.NoiseFrequencyMin);
+					EditorGUILayout.PropertyField(editorProperties.NoiseFrequencyMax);
+					EditorGUILayout.PropertyField(editorProperties.NoiseShiftMin);
+					EditorGUILayout.PropertyField(editorProperties.NoiseShiftMax);
+				}
+
+				if (wiggleType == WiggleTypes.Curve)
+				{
+					EditorGUILayout.PropertyField(editorProperties.Curve);
+					EditorGUILayout.PropertyField(editorProperties.RemapCurveZeroMin);
+					EditorGUILayout.PropertyField(editorProperties.RemapCurveZeroMax);
+					EditorGUILayout.PropertyField(editorProperties.RemapCurveOneMin);
+					EditorGUILayout.PropertyField(editorProperties.RemapCurveOneMax);
+					EditorGUILayout.PropertyField(editorProperties.RelativeCurveAmplitude);
+					EditorGUILayout.PropertyField(editorProperties.UniformValues);
+					EditorGUILayout.PropertyField(editorProperties.ForceVectorLength);
+					EditorGUILayout.PropertyField(editorProperties.ForcedVectorLength);
+					EditorGUILayout.PropertyField(editorProperties.CurvePingPong);
+					EditorGUILayout.PropertyField(editorProperties.FrequencyMin);
+					EditorGUILayout.PropertyField(editorProperties.FrequencyMax);
+				}
+
+				EditorGUILayout.PropertyField(editorProperties.LimitedTime);
+				if (editorProperties.LimitedTime.boolValue)
+				{
+					EditorGUILayout.PropertyField(editorProperties.LimitedTimeTotal);
+					EditorGUILayout.PropertyField(editorProperties.LimitedTimeLeft);
+					EditorGUILayout.PropertyField(editorProperties.LimitedTimeFalloff);
+					EditorGUILayout.PropertyField(editorProperties.LimitedTimeResetValue);
+				}
+
+				EditorGUI.EndDisabledGroup();
+				EditorGUILayout.Space();
+			}
+			MMFeedbackStyling.DrawSplitter();
+		}
+	}
+}

Assets/External/Feel/MMFeedbacks/Editor/Shakers/MMWiggleEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 0ad790ad6438c39448c9177b592c30fe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Shakers/MMWiggleEditor.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Springs.meta

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

Assets/External/Feel/MMFeedbacks/Editor/Springs/MMSpringColorPropertyDrawer.cs

@@ -0,0 +1,28 @@
+using MoreMountains.Tools;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine.UIElements;
+
+namespace MoreMountains.Feedbacks
+{
+	[CustomPropertyDrawer(typeof(MMSpringColor))]
+	class MMSpringColorPropertyDrawer : PropertyDrawer
+	{
+		protected float _lastTarget;
+		protected float _max;
+		
+		public override VisualElement CreatePropertyGUI(SerializedProperty property)
+		{
+			var root = new VisualElement();
+			
+			SerializedProperty _colorSpring = property.FindPropertyRelative("ColorSpring");
+			root.Add(new PropertyField(_colorSpring));
+			
+			return root;
+		}
+		
+	}
+}
+
+

Assets/External/Feel/MMFeedbacks/Editor/Springs/MMSpringColorPropertyDrawer.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 4d274a27f7628664db49fa023801aa2b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Springs/MMSpringColorPropertyDrawer.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Springs/MMSpringDebugPropertyDrawer.cs

@@ -0,0 +1,71 @@
+using MoreMountains.Tools;
+using UnityEditor;
+using UnityEngine;
+
+namespace MoreMountains.Feedbacks
+{
+	[CustomPropertyDrawer(typeof(MMSpringDebug))]
+	public class MMSpringDebugPropertyDrawer : PropertyDrawer
+	{
+		protected Color _backgroundBarColor = new Color(0f, 0f, 0f, 0.3f);
+		protected Color _frontBarColor = MMColors.Yellow;
+		
+		protected SerializedProperty _currentValue;
+		protected SerializedProperty _targetValue;
+
+		protected Rect _rect;
+		protected float _lastTarget;
+		protected float _max;
+		
+		public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+		{
+			_currentValue = property.FindPropertyRelative("CurrentValue");
+			_targetValue = property.FindPropertyRelative("TargetValue");
+			
+			EditorGUI.BeginProperty(position, label, property);
+			EditorGUI.BeginDisabledGroup(true);
+			position = EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), label);
+			var indent = EditorGUI.indentLevel;
+			EditorGUI.indentLevel = 0;
+
+			_rect.x = position.x;
+			_rect.y = position.y;
+			_rect.width = position.width;
+			_rect.height = position.height;
+			EditorGUI.DrawRect(_rect, _backgroundBarColor);
+
+			if (Application.isPlaying)
+			{
+				float current = _currentValue.floatValue;
+				float target = _targetValue.floatValue;
+				float normalizedValue = 0f;
+				float diff = target - current;
+				if (Mathf.Abs(diff) > Mathf.Abs(_max))
+				{
+					_max = diff;
+				}
+
+				if (_lastTarget != target)
+				{
+					_max = diff;
+				}
+				
+				normalizedValue = MMMaths.Remap(diff, -_max, _max, -1f, 1f);	
+
+				float newWidth = MMMaths.Remap(normalizedValue, -1f, 1f, -position.width/2f, position.width/2f);
+				_rect.x = position.x + (position.width/2f);
+				_rect.y = position.y;
+				_rect.width = newWidth;
+				_rect.height = position.height;
+				EditorGUI.DrawRect(_rect, _frontBarColor);
+				
+				_lastTarget = target;
+			}
+
+			EditorGUI.indentLevel = indent;
+			EditorGUI.EndDisabledGroup();
+			EditorGUI.EndProperty();
+
+		}
+	}	
+}

Assets/External/Feel/MMFeedbacks/Editor/Springs/MMSpringDebugPropertyDrawer.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 35b7126fb201e074ea5a3421ba27c5b1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Springs/MMSpringDebugPropertyDrawer.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Springs/MMSpringFloatPropertyDrawer.cs

@@ -0,0 +1,67 @@
+using MoreMountains.Tools;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine.UIElements;
+
+namespace MoreMountains.Feedbacks
+{
+	[CustomPropertyDrawer(typeof(MMSpringFloat))]
+	class MMSpringFloatPropertyDrawer : PropertyDrawer
+	{
+		protected float _lastTarget;
+		protected float _max;
+		
+		public override VisualElement CreatePropertyGUI(SerializedProperty property)
+		{
+			var root = new VisualElement();
+			
+			root.style.backgroundColor = new StyleColor(new Color(255,255,255,0.03f));
+			root.style.marginTop = 5;
+			root.style.paddingRight = 5;
+			
+			SerializedProperty _damping = property.FindPropertyRelative("Damping");
+			SerializedProperty _frequency = property.FindPropertyRelative("Frequency");
+			SerializedProperty _unifiedSpring = property.FindPropertyRelative("UnifiedSpring");
+			SerializedProperty _springDebug = property.FindPropertyRelative("SpringDebug");
+			
+			root.Add(new PropertyField(_damping));
+			root.Add(new PropertyField(_frequency));
+			
+			if (!_unifiedSpring.boolValue)
+			{
+				SerializedProperty _clampSettings = property.FindPropertyRelative("ClampSettings");
+				root.Add(new PropertyField(_clampSettings));
+			}
+
+			if (Application.isPlaying && !_unifiedSpring.boolValue)
+			{
+				VisualElement horizontalLayout = new VisualElement();
+				horizontalLayout.style.flexDirection = FlexDirection.Row;
+				root.Add(horizontalLayout);
+
+				FloatField currentValue = new FloatField("CurrentValue") { bindingPath = "CurrentValueDisplay", isReadOnly = true, style = { flexGrow = 1, paddingRight = 10 } };
+				currentValue.SetEnabled(false);
+				currentValue.AddToClassList("mm-fixed-width-floatfield");
+				horizontalLayout.Add(currentValue);
+				
+				FloatField targetValue = new FloatField("TargetValue") { bindingPath = "TargetValueDisplay", isReadOnly = true, style = { flexGrow = 1} };
+				targetValue.SetEnabled(false);
+				targetValue.AddToClassList("mm-fixed-width-floatfield");
+				horizontalLayout.Add(targetValue);
+				
+				FloatField velocity = new FloatField("Velocity") { bindingPath = "VelocityDisplay", isReadOnly = true, style = { flexGrow = 1, paddingLeft = 10} };
+				velocity.SetEnabled(false);
+				velocity.AddToClassList("mm-fixed-width-floatfield");
+				horizontalLayout.Add(velocity);
+				
+				root.Add(new PropertyField(_springDebug));
+			}
+
+			return root;
+		}
+		
+	}
+}
+
+

Assets/External/Feel/MMFeedbacks/Editor/Springs/MMSpringFloatPropertyDrawer.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: de1ae83f81ca8aa4ea1a8f2fa8b5a8b2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Springs/MMSpringFloatPropertyDrawer.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Springs/MMSpringVector2PropertyDrawer.cs

@@ -0,0 +1,81 @@
+using MoreMountains.Tools;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine.UIElements;
+
+namespace MoreMountains.Feedbacks
+{
+	[CustomPropertyDrawer(typeof(MMSpringVector2))]
+	class MMSpringVector2PropertyDrawer : PropertyDrawer
+	{
+		protected float _lastTarget;
+		protected float _max;
+		
+		protected PropertyField _unifiedSpringField;
+		protected Label _springXLabel;
+		protected PropertyField _springXField;
+		protected Label _springYLabel;
+		protected PropertyField _springYField;
+		
+		public override VisualElement CreatePropertyGUI(SerializedProperty property)
+		{
+			var root = new VisualElement();
+			
+			SerializedProperty _separateAxis = property.FindPropertyRelative("SeparateAxis");
+			SerializedProperty _unifiedSpring = property.FindPropertyRelative("UnifiedSpring");
+			SerializedProperty _springX = property.FindPropertyRelative("SpringX");
+			SerializedProperty _springY = property.FindPropertyRelative("SpringY");
+   
+			Toggle boolToggle = new Toggle("SeparateAxis") { value = property.FindPropertyRelative("SeparateAxis").boolValue };
+			boolToggle.RegisterValueChangedCallback(evt =>
+			{
+				property.FindPropertyRelative("SeparateAxis").boolValue = evt.newValue;
+				ToggleFields(evt.newValue);
+				_separateAxis.serializedObject.ApplyModifiedProperties();
+			});
+			root.Add(boolToggle);
+
+			_unifiedSpringField = new PropertyField(_unifiedSpring);
+			
+			_springXLabel = new Label("Spring X");
+			_springXLabel.style.backgroundColor = new StyleColor(new Color(255,0,0,0.2f));
+			_springXLabel.style.marginLeft = -10;
+			_springXLabel.style.paddingLeft = 14;
+			_springXLabel.style.paddingBottom = 3;
+			_springXLabel.style.paddingTop = 3;
+			_springXField = new PropertyField(_springX);
+			
+			
+			_springYLabel = new Label("Spring Y");
+			_springYLabel.style.backgroundColor = new StyleColor(new Color(0,255,0,0.1f));
+			_springYLabel.style.marginLeft = -10;
+			_springYLabel.style.paddingLeft = 14;
+			_springYLabel.style.paddingBottom = 3;
+			_springYLabel.style.paddingTop = 3;
+			_springYField = new PropertyField(_springY);
+			
+			root.Add(_unifiedSpringField);
+			root.Add(_springXLabel);
+			root.Add(_springXField);
+			root.Add(_springYLabel);
+			root.Add(_springYField);
+
+			ToggleFields(boolToggle.value);
+			
+			return root;
+		}
+		
+		private void ToggleFields(bool show)
+		{
+			_unifiedSpringField.style.display = show ? DisplayStyle.None : DisplayStyle.Flex;
+			_springXLabel.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springXField.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springYLabel.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springYField.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+		}
+		
+	}
+}
+
+

Assets/External/Feel/MMFeedbacks/Editor/Springs/MMSpringVector2PropertyDrawer.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 8ce385a1b7b20b9489103d52d3105023
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Springs/MMSpringVector2PropertyDrawer.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Springs/MMSpringVector3PropertyDrawer.cs

@@ -0,0 +1,97 @@
+using MoreMountains.Tools;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine.UIElements;
+
+namespace MoreMountains.Feedbacks
+{
+	[CustomPropertyDrawer(typeof(MMSpringVector3))]
+	class MMSpringVector3PropertyDrawer : PropertyDrawer
+	{
+		protected float _lastTarget;
+		protected float _max;
+		
+		protected PropertyField _unifiedSpringField;
+		protected Label _springXLabel;
+		protected PropertyField _springXField;
+		protected Label _springYLabel;
+		protected PropertyField _springYField;
+		protected Label _springZLabel;
+		protected PropertyField _springZField;
+		
+		public override VisualElement CreatePropertyGUI(SerializedProperty property)
+		{
+			var root = new VisualElement();
+			
+			SerializedProperty _separateAxis = property.FindPropertyRelative("SeparateAxis");
+			SerializedProperty _unifiedSpring = property.FindPropertyRelative("UnifiedSpring");
+			SerializedProperty _springX = property.FindPropertyRelative("SpringX");
+			SerializedProperty _springY = property.FindPropertyRelative("SpringY");
+			SerializedProperty _springZ = property.FindPropertyRelative("SpringZ");
+   
+			Toggle boolToggle = new Toggle("SeparateAxis") { value = property.FindPropertyRelative("SeparateAxis").boolValue };
+			boolToggle.RegisterValueChangedCallback(evt =>
+			{
+				property.FindPropertyRelative("SeparateAxis").boolValue = evt.newValue;
+				ToggleFields(evt.newValue);
+				_separateAxis.serializedObject.ApplyModifiedProperties();
+			});
+			root.Add(boolToggle);
+
+			_unifiedSpringField = new PropertyField(_unifiedSpring);
+			
+			_springXLabel = new Label("Spring X");
+			_springXLabel.style.backgroundColor = new StyleColor(new Color(1f,0,0,0.2f));
+			_springXLabel.style.marginLeft = -10;
+			_springXLabel.style.paddingLeft = 14;
+			_springXLabel.style.paddingBottom = 3;
+			_springXLabel.style.paddingTop = 3;
+			_springXField = new PropertyField(_springX);
+			
+			
+			_springYLabel = new Label("Spring Y");
+			_springYLabel.style.backgroundColor = new StyleColor(new Color(0,1f,0,0.1f));
+			_springYLabel.style.marginLeft = -10;
+			_springYLabel.style.paddingLeft = 14;
+			_springYLabel.style.paddingBottom = 3;
+			_springYLabel.style.paddingTop = 3;
+			_springYField = new PropertyField(_springY);
+			
+			
+			_springZLabel = new Label("Spring Z");
+			_springZLabel.style.backgroundColor = new StyleColor(new Color(0,0.4f,0.9f,0.2f));
+			_springZLabel.style.marginLeft = -10;
+			_springZLabel.style.paddingLeft = 14;
+			_springZLabel.style.paddingBottom = 3;
+			_springZLabel.style.paddingTop = 3;
+			_springZField = new PropertyField(_springZ);
+			
+			root.Add(_unifiedSpringField);
+			root.Add(_springXLabel);
+			root.Add(_springXField);
+			root.Add(_springYLabel);
+			root.Add(_springYField);
+			root.Add(_springZLabel);
+			root.Add(_springZField);
+
+			ToggleFields(boolToggle.value);
+			
+			return root;
+		}
+		
+		private void ToggleFields(bool show)
+		{
+			_unifiedSpringField.style.display = show ? DisplayStyle.None : DisplayStyle.Flex;
+			_springXLabel.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springXField.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springYLabel.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springYField.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springZLabel.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springZField.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+		}
+		
+	}
+}
+
+

Assets/External/Feel/MMFeedbacks/Editor/Springs/MMSpringVector3PropertyDrawer.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 0a4e11f66ff9ee844abeabf0af54b970
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Springs/MMSpringVector3PropertyDrawer.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/Editor/Springs/MMSpringVector4PropertyDrawer.cs

@@ -0,0 +1,110 @@
+using MoreMountains.Tools;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine.UIElements;
+
+namespace MoreMountains.Feedbacks
+{
+	[CustomPropertyDrawer(typeof(MMSpringVector4))]
+	class MMSpringVector4PropertyDrawer : PropertyDrawer
+	{
+		protected float _lastTarget;
+		protected float _max;
+		
+		protected PropertyField _unifiedSpringField;
+		protected Label _springXLabel;
+		protected PropertyField _springXField;
+		protected Label _springYLabel;
+		protected PropertyField _springYField;
+		protected Label _springZLabel;
+		protected PropertyField _springZField;
+		protected Label _springWLabel;
+		protected PropertyField _springWField;
+		
+		public override VisualElement CreatePropertyGUI(SerializedProperty property)
+		{
+			var root = new VisualElement();
+			
+			SerializedProperty _separateAxis = property.FindPropertyRelative("SeparateAxis");
+			SerializedProperty _unifiedSpring = property.FindPropertyRelative("UnifiedSpring");
+			SerializedProperty _springX = property.FindPropertyRelative("SpringX");
+			SerializedProperty _springY = property.FindPropertyRelative("SpringY");
+			SerializedProperty _springZ = property.FindPropertyRelative("SpringZ");
+			SerializedProperty _springW = property.FindPropertyRelative("SpringW");
+   
+			Toggle boolToggle = new Toggle("SeparateAxis") { value = property.FindPropertyRelative("SeparateAxis").boolValue };
+			boolToggle.RegisterValueChangedCallback(evt =>
+			{
+				property.FindPropertyRelative("SeparateAxis").boolValue = evt.newValue;
+				ToggleFields(evt.newValue);
+				_separateAxis.serializedObject.ApplyModifiedProperties();
+			});
+			root.Add(boolToggle);
+
+			_unifiedSpringField = new PropertyField(_unifiedSpring);
+			
+			_springXLabel = new Label("Spring X");
+			_springXLabel.style.backgroundColor = new StyleColor(new Color(1f,0,0,0.2f));
+			_springXLabel.style.marginLeft = -10;
+			_springXLabel.style.paddingLeft = 14;
+			_springXLabel.style.paddingBottom = 3;
+			_springXLabel.style.paddingTop = 3;
+			_springXField = new PropertyField(_springX);
+			
+			_springYLabel = new Label("Spring Y");
+			_springYLabel.style.backgroundColor = new StyleColor(new Color(0,1f,0,0.1f));
+			_springYLabel.style.marginLeft = -10;
+			_springYLabel.style.paddingLeft = 14;
+			_springYLabel.style.paddingBottom = 3;
+			_springYLabel.style.paddingTop = 3;
+			_springYField = new PropertyField(_springY);
+			
+			_springZLabel = new Label("Spring Z");
+			_springZLabel.style.backgroundColor = new StyleColor(new Color(0,0.4f,0.9f,0.2f));
+			_springZLabel.style.marginLeft = -10;
+			_springZLabel.style.paddingLeft = 14;
+			_springZLabel.style.paddingBottom = 3;
+			_springZLabel.style.paddingTop = 3;
+			_springZField = new PropertyField(_springZ);
+			
+			_springWLabel = new Label("Spring W");
+			_springWLabel.style.backgroundColor = new StyleColor(new Color(0.7f,0f,0.7f,0.2f));
+			_springWLabel.style.marginLeft = -10;
+			_springWLabel.style.paddingLeft = 14;
+			_springWLabel.style.paddingBottom = 3;
+			_springWLabel.style.paddingTop = 3;
+			_springWField = new PropertyField(_springW);
+			
+			root.Add(_unifiedSpringField);
+			root.Add(_springXLabel);
+			root.Add(_springXField);
+			root.Add(_springYLabel);
+			root.Add(_springYField);
+			root.Add(_springZLabel);
+			root.Add(_springZField);
+			root.Add(_springWLabel);
+			root.Add(_springWField);
+
+			ToggleFields(boolToggle.value);
+			
+			return root;
+		}
+		
+		private void ToggleFields(bool show)
+		{
+			_unifiedSpringField.style.display = show ? DisplayStyle.None : DisplayStyle.Flex;
+			_springXLabel.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springXField.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springYLabel.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springYField.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springZLabel.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springZField.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springWLabel.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+			_springWField.style.display = show ? DisplayStyle.Flex : DisplayStyle.None;
+		}
+		
+	}
+}
+
+

Assets/External/Feel/MMFeedbacks/Editor/Springs/MMSpringVector4PropertyDrawer.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: fbd00ea6a74ff2c4295668162e4661bb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 183370
+  packageName: Feel
+  packageVersion: 5.9.1
+  assetPath: Assets/Feel/MMFeedbacks/Editor/Springs/MMSpringVector4PropertyDrawer.cs
+  uploadId: 830868

Assets/External/Feel/MMFeedbacks/MMFeedbacks.meta

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