Started work on the keyframe engine to tie everything together!

src/Artemis.Core/Artemis.Core.csproj

@@ -149,6 +149,11 @@
     <Compile Include="Extensions\TypeExtensions.cs" />
     <Compile Include="JsonConverters\SKColorConverter.cs" />
     <Compile Include="Models\DataModelDescription.cs" />
+    <Compile Include="Models\Profile\KeyframeEngines\FloatKeyframeEngine.cs" />
+    <Compile Include="Models\Profile\KeyframeEngines\IntKeyframeEngine.cs" />
+    <Compile Include="Models\Profile\KeyframeEngines\KeyframeEngine.cs" />
+    <Compile Include="Models\Profile\KeyframeEngines\SKPointKeyframeEngine.cs" />
+    <Compile Include="Models\Profile\KeyframeEngines\SKSizeKeyframeEngine.cs" />
     <Compile Include="Models\Profile\LayerProperties\BaseKeyframe.cs" />
     <Compile Include="Models\Profile\LayerProperties\Keyframe.cs" />
     <Compile Include="Models\Profile\LayerProperties\BaseLayerProperty.cs" />

src/Artemis.Core/Models/Profile/KeyframeEngines/FloatKeyframeEngine.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using Artemis.Core.Models.Profile.LayerProperties;
+
+namespace Artemis.Core.Models.Profile.KeyframeEngines
+{
+    /// <inheritdoc />
+    public class FloatKeyframeEngine : KeyframeEngine
+    {
+        public sealed override List<Type> CompatibleTypes { get; } = new List<Type> {typeof(float)};
+
+        public override object GetCurrentValue()
+        {
+            // Nothing fancy for now, just return the base value
+            return ((LayerProperty<float>) LayerProperty).Value;
+        }
+    }
+}

src/Artemis.Core/Models/Profile/KeyframeEngines/IntKeyframeEngine.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using Artemis.Core.Models.Profile.LayerProperties;
+
+namespace Artemis.Core.Models.Profile.KeyframeEngines
+{
+    /// <inheritdoc />
+    public class IntKeyframeEngine : KeyframeEngine
+    {
+        public sealed override List<Type> CompatibleTypes { get; } = new List<Type> {typeof(int)};
+
+        public override object GetCurrentValue()
+        {
+            // Nothing fancy for now, just return the base value
+            return ((LayerProperty<int>) LayerProperty).Value;
+        }
+    }
+}

src/Artemis.Core/Models/Profile/KeyframeEngines/KeyframeEngine.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using Artemis.Core.Exceptions;
+using Artemis.Core.Models.Profile.LayerProperties;
+
+namespace Artemis.Core.Models.Profile.KeyframeEngines
+{
+    public abstract class KeyframeEngine
+    {
+        /// <summary>
+        ///     Indicates whether <see cref="Initialize" /> has been called.
+        /// </summary>
+        public bool Initialized { get; private set; }
+
+        /// <summary>
+        ///     The layer property this keyframe engine applies to.
+        /// </summary>
+        public BaseLayerProperty LayerProperty { get; set; }
+
+        /// <summary>
+        ///     The keyframe progress in milliseconds.
+        /// </summary>
+        public double Progress { get; set; }
+
+        /// <summary>
+        ///     The types this keyframe engine supports.
+        /// </summary>
+        public abstract List<Type> CompatibleTypes { get; }
+
+        /// <summary>
+        ///     Associates the keyframe engine with the provided layer property.
+        /// </summary>
+        /// <param name="layerProperty"></param>
+        public void Initialize(BaseLayerProperty layerProperty)
+        {
+            if (Initialized)
+                throw new ArtemisCoreException("Cannot initialize the same keyframe engine twice");
+            if (!CompatibleTypes.Contains(layerProperty.Type))
+                throw new ArtemisCoreException($"This property engine does not support the provided type {layerProperty.Type.Name}");
+
+            LayerProperty = layerProperty;
+            Initialized = true;
+        }
+
+        /// <summary>
+        ///     Updates the engine's progress
+        /// </summary>
+        /// <param name="deltaTime"></param>
+        public void Update(double deltaTime)
+        {
+            if (!Initialized)
+                return;
+
+            Progress += deltaTime;
+
+            // LayerProperty determines what's next: reset, stop, continue
+        }
+
+        /// <summary>
+        ///     Gets the current value, if the progress is in between two keyframes the value will be interpolated
+        /// </summary>
+        /// <returns></returns>
+        public abstract object GetCurrentValue();
+    }
+}

src/Artemis.Core/Models/Profile/KeyframeEngines/SKPointKeyframeEngine.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using Artemis.Core.Models.Profile.LayerProperties;
+using SkiaSharp;
+
+namespace Artemis.Core.Models.Profile.KeyframeEngines
+{
+    /// <inheritdoc />
+    public class SKPointKeyframeEngine : KeyframeEngine
+    {
+        public sealed override List<Type> CompatibleTypes { get; } = new List<Type> {typeof(SKPoint)};
+
+        public override object GetCurrentValue()
+        {
+            // Nothing fancy for now, just return the base value
+            return ((LayerProperty<SKPoint>) LayerProperty).Value;
+        }
+    }
+}

src/Artemis.Core/Models/Profile/KeyframeEngines/SKSizeKeyframeEngine.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using Artemis.Core.Models.Profile.LayerProperties;
+using SkiaSharp;
+
+namespace Artemis.Core.Models.Profile.KeyframeEngines
+{
+    /// <inheritdoc />
+    public class SKSizeKeyframeEngine : KeyframeEngine
+    {
+        public sealed override List<Type> CompatibleTypes { get; } = new List<Type> {typeof(SKSize)};
+
+        public override object GetCurrentValue()
+        {
+            // Nothing fancy for now, just return the base value
+            return ((LayerProperty<SKSize>) LayerProperty).Value;
+        }
+    }
+}

src/Artemis.Core/Models/Profile/Layer.cs

@@ -128,9 +128,9 @@ namespace Artemis.Core.Models.Profile
         public LayerProperty<SKPoint> PositionProperty { get; private set; }
 
         /// <summary>
-        ///     The scale property of this layer, also found in <see cref="Properties" />
+        ///     The size property of this layer, also found in <see cref="Properties" />
         /// </summary>
-        public LayerProperty<SKSize> ScaleProperty { get; private set; }
+        public LayerProperty<SKSize> SizeProperty { get; private set; }
 
         /// <summary>
         ///     The rotation property of this layer, also found in <see cref="Properties" />
@@ -304,12 +304,12 @@ namespace Artemis.Core.Models.Profile
             var transformProperty = new LayerProperty<object>(this, null, "Core.Transform", "Transform", "The default properties collection every layer has, allows you to transform the shape.");
             AnchorPointProperty = new LayerProperty<SKPoint>(this, transformProperty, "Core.AnchorPoint", "Anchor Point", "The point at which the shape is attached to its position.");
             PositionProperty = new LayerProperty<SKPoint>(this, transformProperty, "Core.Position", "Position", "The position of the shape.");
-            ScaleProperty = new LayerProperty<SKSize>(this, transformProperty, "Core.Scale", "Scale", "The scale of the shape.") {InputAffix = "%"};
+            SizeProperty = new LayerProperty<SKSize>(this, transformProperty, "Core.Size", "Size", "The size of the shape.") {InputAffix = "%"};
             RotationProperty = new LayerProperty<int>(this, transformProperty, "Core.Rotation", "Rotation", "The rotation of the shape in degrees.") {InputAffix = "°"};
             OpacityProperty = new LayerProperty<float>(this, transformProperty, "Core.Opacity", "Opacity", "The opacity of the shape.") {InputAffix = "%"};
             transformProperty.Children.Add(AnchorPointProperty);
             transformProperty.Children.Add(PositionProperty);
-            transformProperty.Children.Add(ScaleProperty);
+            transformProperty.Children.Add(SizeProperty);
             transformProperty.Children.Add(RotationProperty);
             transformProperty.Children.Add(OpacityProperty);
 
@@ -345,7 +345,10 @@ namespace Artemis.Core.Models.Profile
                 path.AddRect(artemisLed.AbsoluteRenderRectangle);
 
             Path = path;
-            LayerShape?.CalculateRenderProperties();
+            // This is called here so that the shape's render properties are up to date when other code
+            // responds to OnRenderPropertiesUpdated
+            LayerShape?.CalculateRenderProperties(PositionProperty.GetCurrentValue(), SizeProperty.GetCurrentValue());
+
             OnRenderPropertiesUpdated();
         }
 

src/Artemis.Core/Models/Profile/LayerProperties/BaseLayerProperty.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Artemis.Core.Exceptions;
+using Artemis.Core.Models.Profile.KeyframeEngines;
 
 namespace Artemis.Core.Models.Profile.LayerProperties
 {
@@ -67,12 +68,16 @@ namespace Artemis.Core.Models.Profile.LayerProperties
         /// </summary>
         public Type Type { get; set; }
 
-        protected List<BaseKeyframe> BaseKeyframes { get; set; }
         /// <summary>
-        ///     A list of keyframes defining different values of the property in time, this list contains the untyped <see cref="BaseKeyframe"/>.
+        ///     A list of keyframes defining different values of the property in time, this list contains the untyped
+        ///     <see cref="BaseKeyframe" />.
         /// </summary>
         public IReadOnlyCollection<BaseKeyframe> UntypedKeyframes => BaseKeyframes.AsReadOnly();
 
+        public KeyframeEngine KeyframeEngine { get; set; }
+
+        protected List<BaseKeyframe> BaseKeyframes { get; set; }
+
         protected object BaseValue
         {
             get => _baseValue;
@@ -80,11 +85,14 @@ namespace Artemis.Core.Models.Profile.LayerProperties
             {
                 if (value != null && value.GetType() != Type)
                     throw new ArtemisCoreException($"Cannot set value of type {value.GetType()} on property {this}, expected type is {Type}.");
-                _baseValue = value;
+                if (!Equals(_baseValue, value))
+                {
+                    _baseValue = value;
+                    OnValueChanged();
+                }
             }
         }
 
-
         public void ApplyToEntity()
         {
             // Big o' TODO
@@ -94,5 +102,16 @@ namespace Artemis.Core.Models.Profile.LayerProperties
         {
             return $"{nameof(Id)}: {Id}, {nameof(Name)}: {Name}, {nameof(Description)}: {Description}";
         }
+
+        #region Events
+
+        public event EventHandler<EventArgs> ValueChanged;
+
+        protected virtual void OnValueChanged()
+        {
+            ValueChanged?.Invoke(this, EventArgs.Empty);
+        }
+
+        #endregion
     }
 }

src/Artemis.Core/Models/Profile/LayerProperties/LayerProperty.cs

@@ -9,14 +9,18 @@ namespace Artemis.Core.Models.Profile.LayerProperties
         {
         }
 
+        /// <summary>
+        ///     The value of the property without any keyframes applied
+        /// </summary>
         public T Value
         {
-            get => (T) BaseValue;
+            get => BaseValue != null ? (T) BaseValue : default;
             set => BaseValue = value;
         }
 
         /// <summary>
-        ///     A list of keyframes defining different values of the property in time, this list contains the strongly typed <see cref="Keyframe{T}"/>
+        ///     A list of keyframes defining different values of the property in time, this list contains the strongly typed
+        ///     <see cref="Keyframe{T}" />
         /// </summary>
         public ReadOnlyCollection<Keyframe<T>> Keyframes => BaseKeyframes.Cast<Keyframe<T>>().ToList().AsReadOnly();
 
@@ -45,5 +49,17 @@ namespace Artemis.Core.Models.Profile.LayerProperties
         {
             BaseKeyframes.Clear();
         }
+
+        /// <summary>
+        /// Gets the current value using the keyframes
+        /// </summary>
+        /// <returns></returns>
+        public T GetCurrentValue()
+        {
+            if (KeyframeEngine == null)
+                return Value;
+
+            return (T) KeyframeEngine.GetCurrentValue();
+        }
     }
 }

src/Artemis.Core/Models/Profile/LayerShapes/Ellipse.cs

@@ -13,11 +13,11 @@ namespace Artemis.Core.Models.Profile.LayerShapes
         {
         }
 
-        public override void CalculateRenderProperties()
+        public override void CalculateRenderProperties(SKPoint shapePosition, SKSize shapeSize)
         {
             var width = Layer.AbsoluteRectangle.Width;
             var height = Layer.AbsoluteRectangle.Height;
-            var rect = SKRect.Create(Position.X * width, Position.Y * height, Size.Width * width, Size.Height * height);
+            var rect = SKRect.Create(shapePosition.X * width, shapePosition.Y * height, shapeSize.Width * width, shapeSize.Height * height);
 
             var path = new SKPath();
             path.AddOval(rect);

src/Artemis.Core/Models/Profile/LayerShapes/Fill.cs

@@ -1,4 +1,5 @@
 using Artemis.Storage.Entities.Profile;
+using SkiaSharp;
 
 namespace Artemis.Core.Models.Profile.LayerShapes
 {
@@ -12,8 +13,9 @@ namespace Artemis.Core.Models.Profile.LayerShapes
         {
         }
 
-        public override void CalculateRenderProperties()
+        public override void CalculateRenderProperties(SKPoint shapePosition, SKSize shapeSize)
         {
+            // TODO: Scale the path? Not sure if desirable
             RenderPath = Layer.Path;
             RenderRectangle = Layer.Path.GetRect();
         }

src/Artemis.Core/Models/Profile/LayerShapes/LayerShape.cs

@@ -6,9 +6,6 @@ namespace Artemis.Core.Models.Profile.LayerShapes
 {
     public abstract class LayerShape
     {
-        private SKPoint _position;
-        private SKSize _size;
-
         protected LayerShape(Layer layer)
         {
             Layer = layer;
@@ -17,48 +14,13 @@ namespace Artemis.Core.Models.Profile.LayerShapes
         protected LayerShape(Layer layer, ShapeEntity shapeEntity)
         {
             Layer = layer;
-            Anchor = new SKPoint(shapeEntity.Anchor?.X ?? 0, shapeEntity.Anchor?.Y ?? 0);
-            Position = new SKPoint(shapeEntity.Position?.X ?? 0, shapeEntity.Position?.Y ?? 0);
-            Size = new SKSize(shapeEntity.Width, shapeEntity.Height);
         }
 
-
         /// <summary>
         ///     The layer this shape is attached to
         /// </summary>
         public Layer Layer { get; set; }
 
-        /// <summary>
-        ///     At which position the shape is attached to the layer
-        /// </summary>
-        public SKPoint Anchor { get; set; }
-
-        /// <summary>
-        ///     The position of the shape
-        /// </summary>
-        public SKPoint Position
-        {
-            get => _position;
-            set
-            {
-                _position = value;
-                Layer.CalculateRenderProperties();
-            }
-        }
-
-        /// <summary>
-        ///     The size of the shape
-        /// </summary>
-        public SKSize Size
-        {
-            get => _size;
-            set
-            {
-                _size = value;
-                Layer.CalculateRenderProperties();
-            }
-        }
-
         /// <summary>
         ///     A render rectangle relative to the layer
         /// </summary>
@@ -69,17 +31,11 @@ namespace Artemis.Core.Models.Profile.LayerShapes
         /// </summary>
         public SKPath RenderPath { get; protected set; }
 
-        public abstract void CalculateRenderProperties();
+        public abstract void CalculateRenderProperties(SKPoint shapePosition, SKSize shapeSize);
 
         public virtual void ApplyToEntity()
         {
-            Layer.LayerEntity.ShapeEntity = new ShapeEntity
-            {
-                Anchor = new ShapePointEntity {X = Anchor.X, Y = Anchor.Y},
-                Position = new ShapePointEntity {X = Position.X, Y = Position.Y},
-                Width = Size.Width,
-                Height = Size.Height
-            };
+            Layer.LayerEntity.ShapeEntity = new ShapeEntity();
         }
 
         /// <summary>
@@ -90,8 +46,8 @@ namespace Artemis.Core.Models.Profile.LayerShapes
         {
             if (!Layer.Leds.Any())
             {
-                Position = SKPoint.Empty;
-                Size = SKSize.Empty;
+                Layer.PositionProperty.Value = SKPoint.Empty;
+                Layer.SizeProperty.Value = SKSize.Empty;
                 return;
             }
 
@@ -100,8 +56,11 @@ namespace Artemis.Core.Models.Profile.LayerShapes
             var width = Layer.Leds.Max(l => l.RgbLed.AbsoluteLedRectangle.Location.X + l.RgbLed.AbsoluteLedRectangle.Size.Width) - x;
             var height = Layer.Leds.Max(l => l.RgbLed.AbsoluteLedRectangle.Location.Y + l.RgbLed.AbsoluteLedRectangle.Size.Height) - y;
 
-            Position = new SKPoint((float) (100f / width * (rect.Left - x)) / 100f, (float) (100f / height * (rect.Top - y)) / 100f);
-            Size = new SKSize((float) (100f / width * rect.Width) / 100f, (float) (100f / height * rect.Height) / 100f);
+            Layer.PositionProperty.Value = new SKPoint((float) (100f / width * (rect.Left - x)) / 100f, (float) (100f / height * (rect.Top - y)) / 100f);
+            Layer.SizeProperty.Value = new SKSize((float) (100f / width * rect.Width) / 100f, (float) (100f / height * rect.Height) / 100f);
+
+            // TODO: Update keyframes
+            CalculateRenderProperties(Layer.PositionProperty.Value, Layer.SizeProperty.Value);
         }
 
         public SKRect GetUnscaledRectangle()
@@ -115,10 +74,10 @@ namespace Artemis.Core.Models.Profile.LayerShapes
             var height = Layer.Leds.Max(l => l.RgbLed.AbsoluteLedRectangle.Location.Y + l.RgbLed.AbsoluteLedRectangle.Size.Height) - y;
 
             return SKRect.Create(
-                (float) (x + width * Position.X),
-                (float) (y + height * Position.Y),
-                (float) (width * Size.Width),
-                (float) (height * Size.Height)
+                (float) (x + width * Layer.PositionProperty.Value.X),
+                (float) (y + height * Layer.PositionProperty.Value.Y),
+                (float) (width * Layer.SizeProperty.Value.Width),
+                (float) (height * Layer.SizeProperty.Value.Height)
             );
         }
     }

src/Artemis.Core/Models/Profile/LayerShapes/Polygon.cs

@@ -25,7 +25,7 @@ namespace Artemis.Core.Models.Profile.LayerShapes
         /// </summary>
         public List<SKPoint> RenderPoints => Points.Select(p => new SKPoint(p.X * Layer.AbsoluteRectangle.Width, p.Y * Layer.AbsoluteRectangle.Height)).ToList();
 
-        public override void CalculateRenderProperties()
+        public override void CalculateRenderProperties(SKPoint shapePosition, SKSize shapeSize)
         {
             var path = new SKPath();
             path.AddPoly(RenderPoints.ToArray());

src/Artemis.Core/Models/Profile/LayerShapes/Rectangle.cs

@@ -13,11 +13,11 @@ namespace Artemis.Core.Models.Profile.LayerShapes
         {
         }
 
-        public override void CalculateRenderProperties()
+        public override void CalculateRenderProperties(SKPoint shapePosition, SKSize shapeSize)
         {
             var width = Layer.AbsoluteRectangle.Width;
             var height = Layer.AbsoluteRectangle.Height;
-            var rect = SKRect.Create(Position.X * width, Position.Y * height, Size.Width * width, Size.Height * height);
+            var rect = SKRect.Create(shapePosition.X * width, shapePosition.Y * height, shapeSize.Width * width, shapeSize.Height * height);
             var path = new SKPath();
             path.AddRect(rect);
             path.Transform(SKMatrix.MakeTranslation(Layer.Rectangle.Left, Layer.Rectangle.Top));

src/Artemis.Core/Plugins/Models/PluginSetting.cs

@@ -43,8 +43,11 @@ namespace Artemis.Core.Plugins.Models
             get => _value;
             set
             {
-                _value = value;
-                OnSettingChanged();
+                if (!Equals(_value, value))
+                {
+                    _value = value;
+                    OnSettingChanged();
+                }
             }
         }