Added GTWeen

GTweensGodot/GTweens/Source/Tweeners/FloatTweener.cs

@@ -0,0 +1,25 @@
+using GTweens.Delegates;
+using GTweens.Interpolators;
+
+namespace GTweens.Tweeners;
+    
+public sealed class FloatTweener : Tweener<float>
+{
+    public FloatTweener(
+        Getter currentValueGetter, 
+        Setter setter, 
+        Getter to, 
+        float duration, 
+        ValidationDelegates.Validation validation
+    )
+        : base(
+            currentValueGetter, 
+            setter, 
+            to, 
+            duration,
+            FloatInterpolator.Instance, 
+            validation
+        )
+    {
+    }
+}

GTweensGodot/GTweens/Source/Tweeners/FloatTweener.cs.uid

@@ -0,0 +1 @@
+uid://bywdapy07yjny

GTweensGodot/GTweens/Source/Tweeners/ITweener.cs

@@ -0,0 +1,25 @@
+using GTweens.Easings;
+using GTweens.Enums;
+
+namespace GTweens.Tweeners
+{
+    public interface ITweener
+    {
+        float Duration { get; }
+        float Elapsed { get; }
+        float Remaining { get; }
+
+        bool IsPlaying { get; }
+        bool IsCompleted { get; }
+        bool IsKilled { get; }
+        bool IsCompletedOrKilled { get; }
+
+        void SetEasing(EasingDelegate easingFunction);
+
+        void Reset(ResetMode mode);
+        void Start();
+        void Tick(float deltaTime);
+        void Complete();
+        void Kill();
+    }
+}

GTweensGodot/GTweens/Source/Tweeners/ITweener.cs.uid

@@ -0,0 +1 @@
+uid://k17rtk6wh5xf

GTweensGodot/GTweens/Source/Tweeners/IntTweener.cs

@@ -0,0 +1,26 @@
+using GTweens.Delegates;
+using GTweens.Interpolators;
+
+namespace GTweens.Tweeners
+{
+    public sealed class IntTweener : Tweener<int>
+    {
+        internal IntTweener(
+            Getter currValueGetter, 
+            Setter setter, 
+            Getter to, 
+            float duration, 
+            ValidationDelegates.Validation validation
+            )
+            : base(
+                  currValueGetter, 
+                  setter, 
+                  to, 
+                  duration,
+                  IntInterpolator.Instance, 
+                  validation
+                  )
+        {
+        }
+    }
+}

GTweensGodot/GTweens/Source/Tweeners/IntTweener.cs.uid

@@ -0,0 +1 @@
+uid://ntjjh7jiu8vt

GTweensGodot/GTweens/Source/Tweeners/SystemColorTweener.cs

@@ -0,0 +1,26 @@
+using System.Drawing;
+using GTweens.Delegates;
+using GTweens.Interpolators;
+
+namespace GTweens.Tweeners
+{
+    public sealed class SystemColorTweener : Tweener<Color>
+    {
+        public SystemColorTweener(
+            Getter currValueGetter, 
+            Setter setter, 
+            Getter to, 
+            float duration, 
+            ValidationDelegates.Validation validation
+            )
+            : base(currValueGetter, 
+                  setter, 
+                  to, 
+                  duration,
+                  SystemColorInterpolator.Instance, 
+                  validation
+                  )
+        {
+        }
+    }
+}

GTweensGodot/GTweens/Source/Tweeners/SystemColorTweener.cs.uid

@@ -0,0 +1 @@
+uid://bugpyjerorwcw

GTweensGodot/GTweens/Source/Tweeners/SystemQuaternionTweener.cs

@@ -0,0 +1,27 @@
+using System.Numerics;
+using GTweens.Delegates;
+using GTweens.Interpolators;
+
+namespace GTweens.Tweeners
+{
+    public sealed class SystemQuaternionTweener : Tweener<Quaternion>
+    {
+        public SystemQuaternionTweener(
+            Getter currValueGetter,
+            Setter setter,
+            Getter to,
+            float duration,
+            ValidationDelegates.Validation validation
+            )
+            : base(
+                  currValueGetter,
+                  setter,
+                  to,
+                  duration,
+                  SystemQuaternionInterpolator.Instance,
+                  validation
+                  )
+        {
+        }
+    }
+}

GTweensGodot/GTweens/Source/Tweeners/SystemQuaternionTweener.cs.uid

@@ -0,0 +1 @@
+uid://cvhxhs2yx2njy

GTweensGodot/GTweens/Source/Tweeners/SystemVector2Tweener.cs

@@ -0,0 +1,27 @@
+using System.Numerics;
+using GTweens.Delegates;
+using GTweens.Interpolators;
+
+namespace GTweens.Tweeners
+{
+    public sealed class SystemVector2Tweener : Tweener<Vector2>
+    {
+        public SystemVector2Tweener(
+            Getter currValueGetter, 
+            Setter setter, 
+            Getter to, 
+            float duration, 
+            ValidationDelegates.Validation validation
+            )
+            : base(
+                  currValueGetter, 
+                  setter, 
+                  to, 
+                  duration,
+                  SystemVector2Interpolator.Instance, 
+                  validation
+                  )
+        {
+        }
+    }
+}

GTweensGodot/GTweens/Source/Tweeners/SystemVector2Tweener.cs.uid

@@ -0,0 +1 @@
+uid://ckm388yjwcuu6

GTweensGodot/GTweens/Source/Tweeners/SystemVector3Tweener.cs

@@ -0,0 +1,27 @@
+using System.Numerics;
+using GTweens.Delegates;
+using GTweens.Interpolators;
+
+namespace GTweens.Tweeners
+{
+    public sealed class SystemVector3Tweener : Tweener<Vector3>
+    {
+        public SystemVector3Tweener(
+            Getter currValueGetter, 
+            Setter setter, 
+            Getter to, 
+            float duration, 
+            ValidationDelegates.Validation validation
+            )
+            : base(
+                  currValueGetter, 
+                  setter, 
+                  to, 
+                  duration,
+                  SystemVector3Interpolator.Instance, 
+                  validation
+                  )
+        {
+        }
+    }
+}

GTweensGodot/GTweens/Source/Tweeners/SystemVector3Tweener.cs.uid

@@ -0,0 +1 @@
+uid://bpptxf58855kt

GTweensGodot/GTweens/Source/Tweeners/SystemVector4Tweener.cs

@@ -0,0 +1,27 @@
+using System.Numerics;
+using GTweens.Delegates;
+using GTweens.Interpolators;
+
+namespace GTweens.Tweeners
+{
+    public sealed class SystemVector4Tweener : Tweener<Vector4>
+    {
+        public SystemVector4Tweener(
+            Getter currValueGetter,
+            Setter setter,
+            Getter to,
+            float duration,
+            ValidationDelegates.Validation validation
+        )
+            : base(
+                currValueGetter,
+                setter,
+                to,
+                duration,
+                SystemVector4Interpolator.Instance,
+                validation
+            )
+        {
+        }
+    }
+}

GTweensGodot/GTweens/Source/Tweeners/SystemVector4Tweener.cs.uid

@@ -0,0 +1 @@
+uid://b4534l80h30dx

GTweensGodot/GTweens/Source/Tweeners/Tweener.cs

@@ -0,0 +1,234 @@
+using System;
+using GTweens.Delegates;
+using GTweens.Easings;
+using GTweens.Enums;
+using GTweens.Extensions;
+using GTweens.Interpolators;
+
+namespace GTweens.Tweeners
+{
+    public abstract class Tweener<T> : ITweener
+    {
+        public delegate void Setter(T currentValue);
+        public delegate T Getter();
+        
+        public bool IsPlaying { get; private set; }
+        public bool IsCompleted { get; private set; }
+        public bool IsKilled { get; private set; }
+        public bool IsCompletedOrKilled => IsCompleted || IsKilled;
+
+        public float Duration { get; }
+        public float Elapsed { get; private set; }
+        public float Remaining => Math.Max(Duration - Elapsed, 0f);
+        
+        readonly Getter _getter;
+        readonly Setter _setter;
+        readonly Getter _to;
+        readonly ValidationDelegates.Validation _validation;
+        
+        readonly IInterpolator<T> _interpolator;
+
+        bool _hasFirstTimeValues;
+        T _firstTimeInitialValue = default!;
+        T _firstTimeFinalValue = default!;
+
+        T _initialValue = default!;
+        T _finalValue = default!;
+        T _currentValue = default!;
+
+        EasingDelegate _easingFunction = PresetEasingDelegateFactory.GetEaseDelegate(Easing.Linear);
+
+        public Tweener(
+            Getter getter, 
+            Setter setter, 
+            Getter to, 
+            float duration, 
+            IInterpolator<T> interpolator,
+            ValidationDelegates.Validation validation
+            )
+        {
+            _getter = getter;
+            _setter = setter;
+            _to = to;
+            _interpolator = interpolator;
+            _validation = validation;
+            
+            Duration = Math.Max(duration, 0.0f);
+        }
+
+        public void Start()
+        {
+            if (IsPlaying)
+            {
+                return;
+            }
+
+            IsPlaying = true;
+            IsCompleted = false;
+            IsKilled = false;
+
+            Elapsed = 0.0f;
+
+            bool valid = Validate();
+
+            if(!valid)
+            {
+                Kill();
+                return;
+            }
+
+            _initialValue = _getter.Invoke();
+
+            GetFirstTimeValues();
+
+            CompleteIfInstant();
+        }
+
+        public void Reset(ResetMode mode)
+        {
+            bool valid = Validate();
+
+            if (!valid)
+            {
+                Kill();
+                return;
+            }
+            
+            GetFirstTimeValues();
+
+            IsCompleted = false;
+            IsKilled = false;
+            Elapsed = 0.0f;
+
+            switch (mode)
+            {
+                default:
+                case ResetMode.InitialValues:
+                    {
+                        _setter(_firstTimeInitialValue);
+                        _finalValue = _firstTimeFinalValue;
+                    }
+                    break;
+
+                case ResetMode.IncrementalValues:
+                    {
+                        T difference = _interpolator.Subtract(_firstTimeInitialValue, _firstTimeFinalValue);
+                        _finalValue = _interpolator.Add(_currentValue, difference);
+                    }
+                    break;
+                
+                case ResetMode.PingPong:
+                    {
+                        _finalValue = _initialValue;
+                    } 
+                    break;
+            }
+        }
+
+        public void Tick(float deltaTime)
+        {
+            if (!IsPlaying)
+            {
+                return;
+            }
+
+            bool valid = Validate();
+
+            if (!valid)
+            {
+                Kill();
+                return;
+            }
+            
+            Elapsed = Math.Min(Duration, Elapsed + deltaTime);
+
+            if (Elapsed < Duration)
+            {
+                float timeNormalized = MathExtensions.SafeDivide(Elapsed, Duration);
+
+                _currentValue = _interpolator.Evaluate(
+                    _initialValue,
+                    _finalValue,
+                    timeNormalized,
+                    _easingFunction
+                );
+
+                _setter(_currentValue);
+            }
+            else
+            {
+                Complete();
+            }
+        }
+
+        public void Complete()
+        {
+            bool valid = Validate();
+
+            if (!valid)
+            {
+                return;
+            }
+            
+            GetFirstTimeValues();
+
+            T newValue = _interpolator.Evaluate(
+                _initialValue,
+                _finalValue,
+                1.0f,
+                _easingFunction
+            );
+
+            _setter(newValue);
+
+            IsPlaying = false;
+            IsCompleted = true;
+        }
+
+        public void Kill()
+        {
+            IsKilled = true;
+            IsPlaying = false;
+        }
+
+        public void SetEasing(EasingDelegate easingFunction)
+        {
+            _easingFunction = easingFunction;
+        }
+
+        void CompleteIfInstant()
+        {
+            if (!IsPlaying)
+            {
+                return;
+            }
+
+            bool isInstant = Duration == 0.0f;
+
+            if (isInstant)
+            {
+                Complete();
+            }
+        }
+
+        bool Validate()
+        {
+            return _validation.Invoke();
+        }
+
+        void GetFirstTimeValues()
+        {
+            if (_hasFirstTimeValues)
+            {
+                return;
+            }
+
+            _hasFirstTimeValues = true;
+
+            _finalValue = _to.Invoke();
+            
+            _firstTimeInitialValue = _initialValue;
+            _firstTimeFinalValue = _finalValue;
+        }
+    }
+}

GTweensGodot/GTweens/Source/Tweeners/Tweener.cs.uid

@@ -0,0 +1 @@
+uid://cy5dli5pvpgrj

GTweensGodot/GTweens/Source/Tweeners/Vector3RotationTweener.cs

@@ -0,0 +1,27 @@
+// using Juce.Tweening.Interpolators;
+// using UnityEngine;
+//
+// namespace Juce.Tweening.Tweeners
+// {
+//     public class Vector3RotationTweener : Tweener<Vector3>
+//     {
+//         public Vector3RotationTweener(
+//             Getter currValueGetter,
+//             Setter setter,
+//             Getter finalValueGetter,
+//             RotationMode rotationMode,
+//             float duration,
+//             Validation validation
+//             )
+//             : base(
+//                   currValueGetter,
+//                   setter,
+//                   finalValueGetter,
+//                   duration,
+//                   new SystemVector3RotationInterpolator(rotationMode),
+//                   validation
+//                   )
+//         {
+//         }
+//     }
+// }

GTweensGodot/GTweens/Source/Tweeners/Vector3RotationTweener.cs.uid

@@ -0,0 +1 @@
+uid://by4baldnaurb8