+ plugins project

10 files changed, 632 insertions, 0 deletions

diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/ColorTween.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/ColorTween.cs
new file mode 100644
index 0000000..2e98e5d
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/ColorTween.cs
@@ -0,0 +1,15 @@
+using Microsoft.Xna.Framework;
+
+namespace MonoGame.Extended.Tweening;
+
+public class ColorTween: Tween<Color>
+{
+    internal ColorTween(object target, float duration, float delay, TweenMember<Color> member, Color endValue) : base(target, duration, delay, member, endValue)
+    {
+    }
+
+    protected override void Interpolate(float n)
+    {
+        Member.Value = Color.Lerp(_startValue, _endValue, n);
+    }
+}
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/EasingFunctions.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/EasingFunctions.cs
new file mode 100644
index 0000000..f93a5ff
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/EasingFunctions.cs
@@ -0,0 +1,120 @@
+using System;
+using Microsoft.Xna.Framework;
+
+namespace MonoGame.Extended.Tweening
+{
+    public static class EasingFunctions
+    {
+        public static float Linear(float value) => value;
+
+        public static float CubicIn(float value) => Power.In(value, 3);
+        public static float CubicOut(float value) => Power.Out(value, 3);
+        public static float CubicInOut(float value) => Power.InOut(value, 3);
+
+        public static float QuadraticIn(float value) => Power.In(value, 2);
+        public static float QuadraticOut(float value) => Power.Out(value, 2);
+        public static float QuadraticInOut(float value) => Power.InOut(value, 2);
+
+        public static float QuarticIn(float value) => Power.In(value, 4);
+        public static float QuarticOut(float value) => Power.Out(value, 4);
+        public static float QuarticInOut(float value) => Power.InOut(value, 4);
+
+        public static float QuinticIn(float value) => Power.In(value, 5);
+        public static float QuinticOut(float value) => Power.Out(value, 5);
+        public static float QuinticInOut(float value) => Power.InOut(value, 5);
+
+        public static float SineIn(float value) => (float) Math.Sin(value*MathHelper.PiOver2 - MathHelper.PiOver2) + 1;
+        public static float SineOut(float value) => (float) Math.Sin(value*MathHelper.PiOver2);
+        public static float SineInOut(float value) => (float) (Math.Sin(value*MathHelper.Pi - MathHelper.PiOver2) + 1)/2;
+
+        public static float ExponentialIn(float value) => (float) Math.Pow(2, 10*(value - 1));
+        public static float ExponentialOut(float value) => Out(value, ExponentialIn);
+        public static float ExponentialInOut(float value) => InOut(value, ExponentialIn);
+
+        public static float CircleIn(float value) => (float) -(Math.Sqrt(1 - value * value) - 1);
+        public static float CircleOut(float value) => (float) Math.Sqrt(1 - (value - 1) * (value - 1));
+        public static float CircleInOut(float value) => (float) (value <= .5 ? (Math.Sqrt(1 - value * value * 4) - 1) / -2 : (Math.Sqrt(1 - (value * 2 - 2) * (value * 2 - 2)) + 1) / 2);
+
+        public static float ElasticIn(float value)
+        {
+            const int oscillations = 1;
+            const float springiness = 3f;
+            var e = (Math.Exp(springiness*value) - 1)/(Math.Exp(springiness) - 1);
+            return (float) (e*Math.Sin((MathHelper.PiOver2 + MathHelper.TwoPi*oscillations)*value));
+        }
+
+        public static float ElasticOut(float value) => Out(value, ElasticIn);
+        public static float ElasticInOut(float value) => InOut(value, ElasticIn);
+
+        public static float BackIn(float value)
+        {
+            const float amplitude = 1f;
+            return (float) (Math.Pow(value, 3) - value*amplitude*Math.Sin(value*MathHelper.Pi));
+        }
+
+        public static float BackOut(float value) => Out(value, BackIn);
+        public static float BackInOut(float value) => InOut(value, BackIn);
+
+        public static float BounceOut(float value) => Out(value, BounceIn);
+        public static float BounceInOut(float value) => InOut(value, BounceIn);
+
+        public static float BounceIn(float value)
+        {
+            const float bounceConst1 = 2.75f;
+            var bounceConst2 = (float) Math.Pow(bounceConst1, 2);
+
+            value = 1 - value; //flip x-axis
+
+            if (value < 1/bounceConst1) // big bounce
+                return 1f - bounceConst2*value*value;
+
+            if (value < 2/bounceConst1)
+                return 1 - (float) (bounceConst2*Math.Pow(value - 1.5f/bounceConst1, 2) + .75);
+
+            if (value < 2.5/bounceConst1)
+                return 1 - (float) (bounceConst2*Math.Pow(value - 2.25f/bounceConst1, 2) + .9375);
+
+            //small bounce
+            return 1f - (float) (bounceConst2*Math.Pow(value - 2.625f/bounceConst1, 2) + .984375);
+        }
+
+
+        private static float Out(float value, Func<float, float> function)
+        {
+            return 1 - function(1 - value);
+        }
+
+        private static float InOut(float value, Func<float, float> function)
+        {
+            if (value < 0.5f)
+                return 0.5f*function(value*2);
+
+            return 1f - 0.5f*function(2 - value*2);
+        }
+
+        private static class Power
+        {
+            public static float In(double value, int power)
+            {
+                return (float) Math.Pow(value, power);
+            }
+
+            public static float Out(double value, int power)
+            {
+                var sign = power%2 == 0 ? -1 : 1;
+                return (float) (sign*(Math.Pow(value - 1, power) + sign));
+            }
+
+            public static float InOut(double s, int power)
+            {
+                s *= 2;
+
+                if (s < 1)
+                    return In(s, power)/2;
+
+                var sign = power%2 == 0 ? -1 : 1;
+                return (float) (sign/2.0*(Math.Pow(s - 2, power) + sign*2));
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/LinearOperations.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/LinearOperations.cs
new file mode 100644
index 0000000..12a03a8
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/LinearOperations.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Linq.Expressions;
+
+namespace MonoGame.Extended.Tweening;
+
+public class LinearOperations<T>
+{
+    static LinearOperations()
+    {
+        var a = Expression.Parameter(typeof(T));
+        var b = Expression.Parameter(typeof(T));
+        var c = Expression.Parameter(typeof(float));
+        Add = Expression.Lambda<Func<T, T, T>>(Expression.Add(a, b), a, b).Compile();
+        Subtract = Expression.Lambda<Func<T, T, T>>(Expression.Subtract(a, b), a, b).Compile();
+        Multiply = Expression.Lambda<Func<T, float, T>>(Expression.Multiply(a, c), a, c).Compile();
+    }
+
+    public static Func<T, T, T> Add { get; }
+    public static Func<T, T, T> Subtract { get; }
+    public static Func<T, float, T> Multiply { get; }
+}
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/LinearTween.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/LinearTween.cs
new file mode 100644
index 0000000..8469a13
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/LinearTween.cs
@@ -0,0 +1,23 @@
+namespace MonoGame.Extended.Tweening;
+
+public class LinearTween<T>: Tween<T>
+    where T: struct
+{
+    private T _range;
+
+    internal LinearTween(object target, float duration, float delay, TweenMember<T> member, T endValue) : base(target, duration, delay, member, endValue)
+    {
+    }
+
+    protected override void Initialize()
+    {
+        base.Initialize();
+        _range = LinearOperations<T>.Subtract(_endValue, _startValue);
+    }
+
+    protected override void Interpolate(float n)
+    {
+        var value = LinearOperations<T>.Add(_startValue, LinearOperations<T>.Multiply(_range, n));
+        Member.Value = value;
+    }
+}
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/MonoGame.Extended.Tweening.csproj b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/MonoGame.Extended.Tweening.csproj
new file mode 100644
index 0000000..8395e42
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/MonoGame.Extended.Tweening.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Description>A tweening system to make MonoGame more awesome.</Description>
+    <PackageTags>monogame animations tweening</PackageTags>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MonoGame.Extended\MonoGame.Extended.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/Tween.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/Tween.cs
new file mode 100644
index 0000000..ad29251
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/Tween.cs
@@ -0,0 +1,184 @@
+using System;
+using Microsoft.Xna.Framework;
+
+namespace MonoGame.Extended.Tweening
+{
+    public abstract class Tween<T> : Tween
+        where T : struct
+    {
+        internal Tween(object target, float duration, float delay, TweenMember<T> member, T endValue)
+            : base(target, duration, delay)
+        {
+            Member = member;
+            _endValue = endValue;
+        }
+
+        public TweenMember<T> Member { get; }
+        public override string MemberName => Member.Name;
+
+        protected T _startValue;
+        protected T _endValue;
+
+        protected override void Initialize()
+        {
+            _startValue = Member.Value;
+        }
+
+        protected override void Swap()
+        {
+            _endValue = _startValue;
+            Initialize();
+        }
+    }
+
+    public abstract class Tween
+    {
+        internal Tween(object target, float duration, float delay)
+        {
+            Target = target;
+            Duration = duration;
+            Delay = delay;
+            IsAlive = true;
+
+            _remainingDelay = delay;
+        }
+
+        public object Target { get; }
+        public abstract string MemberName { get; }
+        public float Duration { get; }
+        public float Delay { get; }
+        public bool IsPaused { get; set; }
+        public bool IsRepeating => _remainingRepeats != 0;
+        public bool IsRepeatingForever => _remainingRepeats < 0;
+        public bool IsAutoReverse { get; private set; }
+        public bool IsAlive { get; private set; }
+        public bool IsComplete { get; private set; }
+        public float TimeRemaining => Duration - _elapsedDuration;
+        public float Completion => MathHelper.Clamp(_completion, 0, 1);
+
+        private Func<float, float> _easingFunction;
+        private bool _isInitialized;
+        private float _completion;
+        private float _elapsedDuration;
+        private float _remainingDelay;
+        private float _repeatDelay;
+        private int _remainingRepeats;
+        private Action<Tween> _onBegin;
+        private Action<Tween> _onEnd;
+
+        public Tween Easing(Func<float, float> easingFunction) { _easingFunction = easingFunction; return this; }
+        public Tween OnBegin(Action<Tween> action) { _onBegin = action; return this; }
+        public Tween OnEnd(Action<Tween> action) { _onEnd = action; return this; }
+        public Tween Pause() { IsPaused = true; return this; }
+        public Tween Resume() { IsPaused = false; return this; }
+
+        public Tween Repeat(int count, float repeatDelay = 0f)
+        {
+            _remainingRepeats = count;
+            _repeatDelay = repeatDelay;
+            return this;
+        }
+
+        public Tween RepeatForever(float repeatDelay = 0f)
+        {
+            _remainingRepeats = -1;
+            _repeatDelay = repeatDelay;
+            return this;
+        }
+
+        public Tween AutoReverse()
+        {
+            if (_remainingRepeats == 0)
+                _remainingRepeats = 1;
+
+            IsAutoReverse = true;
+            return this;
+        }
+
+        protected abstract void Initialize();
+        protected abstract void Interpolate(float n);
+        protected abstract void Swap();
+
+        public void Cancel()
+        {
+            _remainingRepeats = 0;
+            IsAlive = false;
+        }
+
+        public void CancelAndComplete()
+        {
+            if (IsAlive)
+            {
+                _completion = 1;
+
+                Interpolate(1);
+                IsComplete = true;
+                _onEnd?.Invoke(this);
+            }
+
+            Cancel();
+        }
+
+        public void Update(float elapsedSeconds)
+        {
+            if(IsPaused || !IsAlive)
+                return;
+
+            if (_remainingDelay > 0)
+            {
+                _remainingDelay -= elapsedSeconds;
+
+                if (_remainingDelay > 0)
+                    return;
+            }
+
+            if (!_isInitialized)
+            {
+                _isInitialized = true;
+                Initialize();
+                _onBegin?.Invoke(this);
+            }
+
+            if (IsComplete)
+            {
+                IsComplete = false;
+                _elapsedDuration = 0;
+                _onBegin?.Invoke(this);
+
+                if (IsAutoReverse)
+                    Swap();
+            }
+
+            _elapsedDuration += elapsedSeconds;
+
+            var n = _completion = _elapsedDuration / Duration;
+
+            if (_easingFunction != null)
+                n = _easingFunction(n);
+
+            if (_elapsedDuration >= Duration)
+            {
+                if (_remainingRepeats != 0)
+                {
+                    if(_remainingRepeats > 0)
+                        _remainingRepeats--;
+
+                    _remainingDelay = _repeatDelay;
+                }
+                else if (_remainingRepeats == 0)
+                {
+                    IsAlive = false;
+                }
+
+                n = _completion = 1;
+                IsComplete = true;
+            }
+
+            Interpolate(n);
+
+            if (IsComplete)
+                _onEnd?.Invoke(this);
+        }
+
+    }
+}
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/TweenFieldMember.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/TweenFieldMember.cs
new file mode 100644
index 0000000..da2f75d
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/TweenFieldMember.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Diagnostics;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace MonoGame.Extended.Tweening
+{
+    public sealed class TweenFieldMember<T> : TweenMember<T>
+        where T : struct 
+    {
+        private readonly FieldInfo _fieldInfo;
+
+        public TweenFieldMember(object target, FieldInfo fieldInfo) 
+            : base(target, CompileGetMethod(fieldInfo), CompileSetMethod(fieldInfo))
+        {
+            _fieldInfo = fieldInfo;
+        }
+
+        private static Func<object, object> CompileGetMethod(FieldInfo fieldInfo)
+        {
+            var self = Expression.Parameter(typeof(object));
+            var instance = Expression.Convert(self, fieldInfo.DeclaringType);
+            var field = Expression.Field(instance, fieldInfo);
+            var convert = Expression.TypeAs(field, typeof(object));
+
+            return Expression.Lambda<Func<object, object>>(convert, self).Compile();
+        }
+
+        private static Action<object, object> CompileSetMethod(FieldInfo fieldInfo)
+        {
+            Debug.Assert(fieldInfo.DeclaringType != null);
+
+            var self = Expression.Parameter(typeof(object));
+            var value = Expression.Parameter(typeof(object));
+            var fieldExp = Expression.Field(Expression.Convert(self, fieldInfo.DeclaringType), fieldInfo);
+            var assignExp = Expression.Assign(fieldExp, Expression.Convert(value, fieldInfo.FieldType));
+
+            return Expression.Lambda<Action<object, object>>(assignExp, self, value).Compile();
+        }
+
+        public override Type Type => _fieldInfo.FieldType;
+        public override string Name => _fieldInfo.Name;
+    }
+}
\ No newline at end of file
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/TweenMember.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/TweenMember.cs
new file mode 100644
index 0000000..adcee59
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/TweenMember.cs
@@ -0,0 +1,37 @@
+using System;
+using System.Linq.Expressions;
+
+namespace MonoGame.Extended.Tweening
+{
+    public abstract class TweenMember
+    {
+        protected TweenMember(object target)
+        {
+            Target = target;
+        }
+
+        public object Target { get; }
+        public abstract Type Type { get; }
+        public abstract string Name { get; }
+    }
+
+    public abstract class TweenMember<T> : TweenMember
+        where T : struct
+    {
+        protected TweenMember(object target, Func<object, object> getMethod, Action<object, object> setMethod)
+            : base(target)
+        {
+            _getMethod = getMethod;
+            _setMethod = setMethod;
+        }
+
+        private readonly Func<object, object> _getMethod;
+        private readonly Action<object, object> _setMethod;
+
+        public T Value
+        {
+            get { return (T) _getMethod(Target); }
+            set { _setMethod(Target, value); }
+        }
+    }
+}
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/TweenPropertyMember.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/TweenPropertyMember.cs
new file mode 100644
index 0000000..7b1db71
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/TweenPropertyMember.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Diagnostics;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace MonoGame.Extended.Tweening
+{
+    public sealed class TweenPropertyMember<T> : TweenMember<T>
+        where T : struct 
+    {
+        private readonly PropertyInfo _propertyInfo;
+
+        public TweenPropertyMember(object target, PropertyInfo propertyInfo)
+            : base(target, CompileGetMethod(propertyInfo), CompileSetMethod(propertyInfo))
+        {
+            _propertyInfo = propertyInfo;
+        }
+
+        public override Type Type => _propertyInfo.PropertyType;
+        public override string Name => _propertyInfo.Name;
+
+        private static Func<object, object> CompileGetMethod(PropertyInfo propertyInfo)
+        {
+            var param = Expression.Parameter(typeof(object));
+            var instance = Expression.Convert(param, propertyInfo.DeclaringType);
+            var convert = Expression.TypeAs(Expression.Property(instance, propertyInfo), typeof(object));
+            return Expression.Lambda<Func<object, object>>(convert, param).Compile();
+        }
+
+        private static Action<object, object> CompileSetMethod(PropertyInfo propertyInfo)
+        {
+            Debug.Assert(propertyInfo.DeclaringType != null);
+
+            var param = Expression.Parameter(typeof(object));
+            var argument = Expression.Parameter(typeof(object));
+            var expression = Expression.Convert(param, propertyInfo.DeclaringType);
+            var methodInfo = propertyInfo.SetMethod;
+            var arguments = Expression.Convert(argument, propertyInfo.PropertyType);
+            var setterCall = Expression.Call(expression, methodInfo, arguments);
+            return Expression.Lambda<Action<object, object>>(setterCall, param, argument).Compile();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/Tweener.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/Tweener.cs
new file mode 100644
index 0000000..61b55f9
--- /dev/null
+++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Tweening/Tweener.cs
@@ -0,0 +1,133 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using Microsoft.Xna.Framework;
+
+namespace MonoGame.Extended.Tweening
+{
+    public class Tweener : IDisposable
+    {
+        public Tweener()
+        {
+        }
+
+        public void Dispose()
+        {
+            CancelAll();
+            _activeTweens.Clear();
+            _memberCache.Clear();
+        }
+
+        public long AllocationCount { get; private set; }
+
+        private readonly List<Tween> _activeTweens = new List<Tween>();
+
+        public Tween<TMember> TweenTo<TTarget, TMember>(TTarget target, Expression<Func<TTarget, TMember>> expression, TMember toValue, float duration, float delay = 0f)
+            where TTarget : class
+            where TMember : struct
+        {
+            switch (toValue)
+            {
+                case Color toValueColor:
+                    return (Tween<TMember>)(object)TweenTo<TTarget, Color, ColorTween>(target, expression as Expression<Func<TTarget, Color>>, toValueColor, duration, delay);
+                default:
+                    return TweenTo<TTarget, TMember, LinearTween<TMember>>(target, expression, toValue, duration, delay);
+            }
+
+        }
+
+        public Tween<TMember> TweenTo<TTarget, TMember, TTween>(TTarget target, Expression<Func<TTarget, TMember>> expression, TMember toValue, float duration, float delay = 0f)
+            where TTarget : class
+            where TMember : struct
+            where TTween : Tween<TMember>
+        {
+            var memberExpression = (MemberExpression)expression.Body;
+            var memberInfo = memberExpression.Member;
+            var member = GetMember<TMember>(target, memberInfo.Name);
+            var activeTween = FindTween(target, member.Name);
+
+            activeTween?.Cancel();
+
+            AllocationCount++;
+            var tween = (TTween)Activator.CreateInstance(typeof(TTween),
+                BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null,
+                new object[]{target, duration, delay, member, toValue}, null);
+            _activeTweens.Add(tween);
+            return tween;
+        }
+
+        public void Update(float elapsedSeconds)
+        {
+            for (var i = _activeTweens.Count - 1; i >= 0; i--)
+            {
+                var tween = _activeTweens[i];
+
+                tween.Update(elapsedSeconds);
+
+                if (!tween.IsAlive)
+                    _activeTweens.RemoveAt(i);
+            }
+        }
+
+        public Tween FindTween(object target, string memberName)
+        {
+            return _activeTweens.FirstOrDefault(t => t.Target == target && t.MemberName == memberName);
+        }
+
+        public void CancelAll()
+        {
+            foreach (var tween in _activeTweens)
+                tween.Cancel();
+        }
+
+        public void CancelAndCompleteAll()
+        {
+            foreach (var tween in _activeTweens)
+                tween.CancelAndComplete();
+        }
+
+        private struct TweenMemberKey
+        {
+#pragma warning disable 414
+            public object Target;
+            public string MemberName;
+#pragma warning restore 414
+        }
+
+        private readonly Dictionary<TweenMemberKey, TweenMember> _memberCache = new Dictionary<TweenMemberKey, TweenMember>();
+
+        private TweenMember<T> GetMember<T>(object target, string memberName)
+            where T : struct
+        {
+            var key = new TweenMemberKey { Target = target, MemberName = memberName };
+
+            if (_memberCache.TryGetValue(key, out var member))
+                return (TweenMember<T>) member;
+
+            member = CreateMember<T>(target, memberName);
+            _memberCache.Add(key, member);
+            return (TweenMember<T>) member;
+        }
+
+        private TweenMember<T> CreateMember<T>(object target, string memberName)
+            where T : struct
+        {
+            AllocationCount++;
+
+            var type = target.GetType();
+            var property = type.GetTypeInfo().GetProperty(memberName);
+
+            if (property != null)
+                return new TweenPropertyMember<T>(target, property);
+
+            var field = type.GetTypeInfo().GetField(memberName);
+
+            if (field != null)
+                return new TweenFieldMember<T>(target, field);
+
+            throw new InvalidOperationException($"'{memberName}' is not a property or field of the target");
+        }
+    }
+}