From e2c1605c1986c34f23c85dc9ec22f00f16bca21d Mon Sep 17 00:00:00 2001 From: mob-sakai <12690315+mob-sakai@users.noreply.github.com> Date: Sat, 9 Nov 2024 18:51:57 +0900 Subject: [PATCH] feat: add UIEffectTweener component `UIEffectTweener` component animates `UIEffect` intensity or rate, enabling easy control over effect animations without the need for an `AnimationClip`. --- Packages/src/Editor/UIEffectTweenerEditor.cs | 149 ++++++++++ .../src/Editor/UIEffectTweenerEditor.cs.meta | 12 + Packages/src/Runtime/UIEffectTweener.cs | 280 ++++++++++++++++++ Packages/src/Runtime/UIEffectTweener.cs.meta | 11 + 4 files changed, 452 insertions(+) create mode 100644 Packages/src/Editor/UIEffectTweenerEditor.cs create mode 100644 Packages/src/Editor/UIEffectTweenerEditor.cs.meta create mode 100644 Packages/src/Runtime/UIEffectTweener.cs create mode 100644 Packages/src/Runtime/UIEffectTweener.cs.meta diff --git a/Packages/src/Editor/UIEffectTweenerEditor.cs b/Packages/src/Editor/UIEffectTweenerEditor.cs new file mode 100644 index 0000000..a44ad96 --- /dev/null +++ b/Packages/src/Editor/UIEffectTweenerEditor.cs @@ -0,0 +1,149 @@ +using UnityEditor; +using UnityEngine; +using UnityEngine.Profiling; + +namespace Coffee.UIEffects.Editors +{ + [CanEditMultipleObjects] + [CustomEditor(typeof(UIEffectTweener))] + internal class UIMaterialPropertyTweenerEditor : Editor + { + private SerializedProperty _cullingMask; + private SerializedProperty _direction; + private SerializedProperty _curve; + private SerializedProperty _delay; + private SerializedProperty _duration; + private SerializedProperty _interval; + private SerializedProperty _restartOnEnable; + private SerializedProperty _updateMode; + private SerializedProperty _wrapMode; + + private void OnEnable() + { + _cullingMask = serializedObject.FindProperty("m_CullingMask"); + _direction = serializedObject.FindProperty("m_Direction"); + _curve = serializedObject.FindProperty("m_Curve"); + _restartOnEnable = serializedObject.FindProperty("m_RestartOnEnable"); + _delay = serializedObject.FindProperty("m_Delay"); + _duration = serializedObject.FindProperty("m_Duration"); + _interval = serializedObject.FindProperty("m_Interval"); + _wrapMode = serializedObject.FindProperty("m_WrapMode"); + _updateMode = serializedObject.FindProperty("m_UpdateMode"); + } + + public override void OnInspectorGUI() + { + Profiler.BeginSample("(MPI)[MPTweenerEditor] OnInspectorGUI"); + serializedObject.UpdateIfRequiredOrScript(); + EditorGUILayout.PropertyField(_cullingMask); + EditorGUILayout.PropertyField(_direction); + EditorGUILayout.PropertyField(_curve); + EditorGUILayout.PropertyField(_delay); + EditorGUILayout.PropertyField(_duration); + EditorGUILayout.PropertyField(_interval); + EditorGUILayout.PropertyField(_restartOnEnable); + EditorGUILayout.PropertyField(_wrapMode); + EditorGUILayout.PropertyField(_updateMode); + serializedObject.ApplyModifiedProperties(); + DrawPlayer(target as UIEffectTweener); + Profiler.EndSample(); + } + + private void DrawPlayer(UIEffectTweener tweener) + { + if (!tweener) return; + + EditorGUILayout.BeginHorizontal(); + EditorGUI.BeginDisabledGroup(!Application.isPlaying); + var icon = EditorGUIUtility.IconContent("icons/playbutton.png"); + var r = EditorGUILayout.GetControlRect(false); + + var rButton = new Rect(r.x, r.y, 20, r.height); + if (GUI.Button(rButton, icon, "IconButton")) + { + tweener.SetTime(0); + } + + EditorGUI.EndDisabledGroup(); + + var totalTime = tweener.totalTime; + var time = tweener.time; + var label = EditorGUIUtility.TrTempContent($"{time:N2}/{totalTime:N2}"); + var wLabel = Mathf.CeilToInt(EditorStyles.label.CalcSize(label).x / 5f) * 5f; + wLabel = 80; + var rLabel = new Rect(r.x + r.width - wLabel, r.y, wLabel, r.height); + GUI.Label(rLabel, label, "RightLabel"); + EditorGUILayout.EndHorizontal(); + + EditorGUI.BeginChangeCheck(); + var rSlider = new Rect(r.x + 20, r.y, r.width - wLabel - 20, r.height); + + // + + var + r0 = rSlider; //new Rect(rSlider.x, rSlider.y, rSlider.width * tweener.interval / totalTime, rSlider.height); + r0.y += 4; + r0.height -= 8; + r0.width = rSlider.width * tweener.delay / totalTime; + GUI.color = Color.blue; + GUI.Label(r0, GUIContent.none, "TE DefaultTime"); + + r0.x += r0.width; + r0.width = rSlider.width * tweener.duration / totalTime; + GUI.color = Color.green; + GUI.Label(r0, GUIContent.none, "TE DefaultTime"); + + r0.x += r0.width; + r0.width = rSlider.width * tweener.interval / totalTime; + GUI.color = Color.red; + GUI.Label(r0, GUIContent.none, "TE DefaultTime"); + + if (UIEffectTweener.WrapMode.PingPongOnce <= tweener.wrapMode) + { + r0.x += r0.width; + r0.width = rSlider.width * tweener.duration / totalTime; + GUI.color = Color.green; + GUI.Label(r0, GUIContent.none, "TE DefaultTime"); + } + + if (UIEffectTweener.WrapMode.PingPongLoop <= tweener.wrapMode) + { + r0.x += r0.width; + r0.width = rSlider.width * tweener.interval / totalTime; + GUI.color = Color.red; + GUI.Label(r0, GUIContent.none, "TE DefaultTime"); + } + + + GUI.color = Color.white; + + time = GUI.HorizontalSlider(rSlider, time, 0, totalTime); + if (EditorGUI.EndChangeCheck()) + { + tweener.SetTime(time); + } + + if (Application.isPlaying && tweener.isActiveAndEnabled) + { + Repaint(); + } + } + + // private static void PostAddElement(SerializedProperty prop, string propertyName) + // { + // prop.FindPropertyRelative("m_From.m_Type").intValue = -1; + // prop.FindPropertyRelative("m_From.m_PropertyName").stringValue = propertyName; + // prop.FindPropertyRelative("m_To.m_Type").intValue = -1; + // prop.FindPropertyRelative("m_To.m_PropertyName").stringValue = propertyName; + // } + // + // private void ResetCallback() + // { + // var current = serializedObject.targetObject as UIEffectTweener; + // if (!current) return; + // + // Undo.RecordObject(current, "Reset Values"); + // current.ResetPropertiesToDefault(); + // } + } +} diff --git a/Packages/src/Editor/UIEffectTweenerEditor.cs.meta b/Packages/src/Editor/UIEffectTweenerEditor.cs.meta new file mode 100644 index 0000000..3ef5e0b --- /dev/null +++ b/Packages/src/Editor/UIEffectTweenerEditor.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 27bd0b04cc3fb4d338bb2ffc5f9d3e7c +timeCreated: 1487152293 +licenseType: Pro +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Packages/src/Runtime/UIEffectTweener.cs b/Packages/src/Runtime/UIEffectTweener.cs new file mode 100644 index 0000000..da87668 --- /dev/null +++ b/Packages/src/Runtime/UIEffectTweener.cs @@ -0,0 +1,280 @@ +using System; +using UnityEngine; + +namespace Coffee.UIEffects +{ + [RequireComponent(typeof(UIEffectBase))] + public class UIEffectTweener : MonoBehaviour + { + [Flags] + public enum CullingMask + { + Tone = 1 << 0, + Color = 1 << 1, + Sampling = 1 << 2, + Transition = 1 << 3 + } + + public enum UpdateMode + { + Normal, + Unscaled, + Manual + } + + public enum WrapMode + { + Once, + Loop, + PingPongOnce, + PingPongLoop + } + + public enum Direction + { + Forward, + Reverse + } + + [Tooltip("The culling mask of the tween.")] + [SerializeField] + private CullingMask m_CullingMask = + CullingMask.Tone | CullingMask.Color | CullingMask.Sampling | CullingMask.Transition; + + [Tooltip("The direction of the tween.")] + [SerializeField] + private Direction m_Direction = Direction.Forward; + + [Tooltip("The curve to tween the properties.")] + [SerializeField] + private AnimationCurve m_Curve = AnimationCurve.Linear(0, 0, 1, 1); + + [Tooltip("The delay in seconds before the tween starts.")] + [SerializeField] + [Range(0f, 10)] + private float m_Delay; + + [Tooltip("The duration in seconds of the tween.")] + [SerializeField] + [Range(0.05f, 10)] + private float m_Duration = 1; + + [Tooltip("The interval in seconds between each loop.")] + [SerializeField] + [Range(0f, 10)] + private float m_Interval; + + [Tooltip("Whether to restart the tween when enabled.")] + [SerializeField] + private bool m_RestartOnEnable = true; + + [Tooltip("The wrap mode of the tween.\n" + + " Clamp: Clamp the tween value (not loop).\n" + + " Loop: Loop the tween value.\n" + + " PingPongOnce: PingPong the tween value (not loop).\n" + + " PingPong: PingPong the tween value.")] + [SerializeField] + private WrapMode m_WrapMode = WrapMode.Loop; + + [Tooltip("Specifies how to get delta time.\n" + + " Normal: Use `Time.deltaTime`.\n" + + " Unscaled: Use `Time.unscaledDeltaTime`.\n" + + " Manual: Not updated automatically and update manually with `UpdateTime` or `SetTime` method.")] + [SerializeField] + private UpdateMode m_UpdateMode = UpdateMode.Normal; + + private float _rate; + private float _time; + private UIEffectBase _target; + + /// + /// The target UIMaterialPropertyInjector to tween. + /// + private UIEffectBase target => _target ? _target : _target = GetComponent(); + + public CullingMask cullingMask + { + get => m_CullingMask; + set => m_CullingMask = value; + } + + public Direction direction + { + get => m_Direction; + set => m_Direction = value; + } + + /// + /// The rate of the tween. + /// + public float rate + { + get => _rate; + set + { + value = Mathf.Clamp01(value); + if (Mathf.Approximately(_rate, value)) return; + + _rate = value; + + if (!target || cullingMask == 0) return; + var evaluatedRate = m_Curve.Evaluate(_rate); + target.SetRate(evaluatedRate, cullingMask); + } + } + + /// + /// The duration in seconds of the tween. + /// + public float duration + { + get => m_Duration; + set => m_Duration = Mathf.Max(0.001f, value); + } + + /// + /// The delay in seconds before the tween starts. + /// + public float delay + { + get => m_Delay; + set => m_Delay = Mathf.Max(0, value); + } + + /// + /// The interval in seconds between each loop. + /// + public float interval + { + get => m_Interval; + set => m_Interval = Mathf.Max(0, value); + } + + /// + /// The current time of the tween. + /// + /// + public float time + { + get + { + if (_time < delay) return _time; + var t = _time - delay; + switch (wrapMode) + { + case WrapMode.Once: + case WrapMode.PingPongOnce: + return Mathf.Clamp(t, 0, totalTime - delay) + delay; + case WrapMode.Loop: + case WrapMode.PingPongLoop: + return Mathf.Repeat(t, totalTime - delay) + delay; + default: + throw new ArgumentOutOfRangeException(); + } + } + } + + public float totalTime + { + get + { + switch (wrapMode) + { + case WrapMode.Once: return delay + duration; + case WrapMode.Loop: return delay + duration + interval; + case WrapMode.PingPongOnce: return delay + duration * 2 + interval; + case WrapMode.PingPongLoop: return delay + duration * 2 + interval * 2; + default: + throw new ArgumentOutOfRangeException(); + } + } + } + + public bool restartOnEnable + { + get => m_RestartOnEnable; + set => m_RestartOnEnable = value; + } + + public WrapMode wrapMode + { + get => m_WrapMode; + set => m_WrapMode = value; + } + + public UpdateMode updateMode + { + get => m_UpdateMode; + set => m_UpdateMode = value; + } + + public AnimationCurve curve + { + get => m_Curve; + set => m_Curve = value; + } + + private void Update() + { + switch (m_UpdateMode) + { + case UpdateMode.Normal: + UpdateTime(Time.deltaTime); + break; + case UpdateMode.Unscaled: + UpdateTime(Time.unscaledDeltaTime); + break; + } + } + + private void OnEnable() + { + if (m_RestartOnEnable) + { + Restart(); + } + } + + public void Restart() + { + SetTime(0); + } + + public void SetTime(float sec) + { + _time = 0; + UpdateTime(sec); + } + + public void UpdateTime(float deltaSec) + { + rate = UpdateTime_Internal(Mathf.Max(0, deltaSec)) / duration; + } + + private float UpdateTime_Internal(float delta) + { + _time += direction == Direction.Forward ? delta : -delta; + if (_time < delay) return 0; + + var t = _time - delay; + switch (wrapMode) + { + case WrapMode.Loop: + t = Mathf.Repeat(t, duration + interval); + break; + case WrapMode.PingPongOnce: + t = Mathf.Clamp(t, 0, duration * 2 + interval); + t = Mathf.PingPong(t, duration + interval * 0.5f); + break; + case WrapMode.PingPongLoop: + t = Mathf.Repeat(t, (duration + interval) * 2); + t = t < duration * 2 + interval + ? Mathf.PingPong(t, duration + interval * 0.5f) + : 0; + break; + } + + return Mathf.Clamp(t, 0, duration); + } + } +} diff --git a/Packages/src/Runtime/UIEffectTweener.cs.meta b/Packages/src/Runtime/UIEffectTweener.cs.meta new file mode 100644 index 0000000..8ef821d --- /dev/null +++ b/Packages/src/Runtime/UIEffectTweener.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 90ac5d06c7b714c29a6b7b3b80e443a7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {fileID: 617344605838670728, guid: ba0cc6c34514c480c878314286014b4a, type: 2} + userData: + assetBundleName: + assetBundleVariant: