Data bindings - WIP commit

src/Artemis.Core/Artemis.Core.csproj.DotSettings

@@ -9,7 +9,11 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=models_005Cprofile_005Cconditions_005Cabstract/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=models_005Cprofile_005Cconditions_005Coperators/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=models_005Cprofile_005Cdatabindings/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=models_005Cprofile_005Cdatabindings_005Cconverters/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=models_005Cprofile_005Cdatabindings_005Cdatabindingproperties/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=models_005Cprofile_005Cdatabindings_005Cdatabindingproperties_005Cabstract/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=models_005Cprofile_005Cdatabindings_005Cmodifiers/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=models_005Cprofile_005Cdatabindings_005Cmodifiers_005Cabstract/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=models_005Cprofile_005Clayerproperties/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=models_005Cprofile_005Clayerproperties_005Cattributes/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=models_005Cprofile_005Clayerproperties_005Ctypes/@EntryIndexedValue">True</s:Boolean>

src/Artemis.Core/Events/DataBindingPropertyUpdatedEvent.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace Artemis.Core
+{
+    public class DataBindingPropertyUpdatedEvent<T> : EventArgs
+    {
+        public DataBindingPropertyUpdatedEvent(T value)
+        {
+            Value = value;
+        }
+
+        /// <summary>
+        ///     The updated value that should be applied to the layer property
+        /// </summary>
+        public T Value { get; }
+    }
+}

src/Artemis.Core/Extensions/TypeExtensions.cs

@@ -86,5 +86,13 @@ namespace Artemis.Core
                 );
             return castable;
         }
+
+        /// <summary>
+        /// Returns the default value of the given type
+        /// </summary>
+        public static object GetDefault(this Type type)
+        {
+            return type.IsValueType ? Activator.CreateInstance(type) : null;
+        }
     }
 }

src/Artemis.Core/Models/Profile/DataBindings/Converters/FloatDataBindingConverter.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Artemis.Core.Models.Profile.DataBindings.Converters
+{
+   public class FloatDataBindingConverter : IDataBindingConverter
+    {
+        public BaseLayerProperty BaseLayerProperty { get; set; }
+        public object Sum(object a, object b)
+        {
+            return (float) a + (float) b;
+        }
+
+        public object Interpolate(object a, object b, float progress)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void ApplyValue(object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public object GetValue()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/Artemis.Core/Models/Profile/DataBindings/DataBinding.cs

@@ -17,15 +17,23 @@ namespace Artemis.Core
         private readonly List<DataBindingModifier> _modifiers = new List<DataBindingModifier>();
         private bool _isInitialized;
 
-        internal DataBinding(BaseLayerProperty layerProperty, PropertyInfo targetProperty)
+        private object _currentValue;
+        private object _previousValue;
+        private float _easingProgress;
+
+        internal DataBinding(DataBindingRegistration dataBindingRegistration)
         {
-            LayerProperty = layerProperty;
-            TargetProperty = targetProperty;
+            LayerProperty = dataBindingRegistration.LayerProperty;
+            TargetProperty = dataBindingRegistration.Property;
+            Registration = dataBindingRegistration;
+
             Entity = new DataBindingEntity();
 
             ApplyToEntity();
         }
 
+        public DataBindingRegistration Registration { get; private set; }
+
         internal DataBinding(BaseLayerProperty layerProperty, DataBindingEntity entity)
         {
             LayerProperty = layerProperty;
@@ -87,6 +95,8 @@ namespace Artemis.Core
             {
                 modifier.DataBinding = this;
                 _modifiers.Add(modifier);
+
+                OnModifiersUpdated();
             }
         }
 
@@ -99,6 +109,8 @@ namespace Artemis.Core
             {
                 modifier.DataBinding = null;
                 _modifiers.Remove(modifier);
+
+                OnModifiersUpdated();
             }
         }
 
@@ -132,14 +144,6 @@ namespace Artemis.Core
         /// <returns></returns>
         public object GetValue(object baseValue)
         {
-            // Validating this is kinda expensive, it'll fail on ChangeType later anyway ^^
-            // var targetType = TargetProperty.PropertyType;
-            // if (!targetType.IsCastableFrom(baseValue.GetType()))
-            // {
-            //     throw new ArtemisCoreException($"The provided current value type ({baseValue.GetType().Name}) not match the " +
-            //                                    $"target property type ({targetType.Name})");
-            // }
-
             if (CompiledTargetAccessor == null)
                 return baseValue;
 
@@ -147,11 +151,54 @@ namespace Artemis.Core
             foreach (var dataBindingModifier in Modifiers)
                 dataBindingValue = dataBindingModifier.Apply(dataBindingValue);
 
-            return Convert.ChangeType(dataBindingValue, TargetProperty.PropertyType);
+            var value = Convert.ChangeType(dataBindingValue, TargetProperty.PropertyType);
+
+            // If no easing is to be applied simple return whatever the current value is
+            if (EasingTime == TimeSpan.Zero)
+                return value;
+
+            // If the value changed, update the current and previous values used for easing
+            if (!Equals(value, _currentValue))
+            {
+                _previousValue = GetInterpolatedValue();
+                _currentValue = value;
+                _easingProgress = 0f;
+            }
+
+            // Apply interpolation between the previous and current value
+            return GetInterpolatedValue();
         }
 
-        internal void Update(double deltaTime)
+        /// <summary>
+        ///     Returns the type of the source property of this data binding
+        /// </summary>
+        public Type GetSourceType()
         {
+            return SourceDataModel?.GetTypeAtPath(SourcePropertyPath);
+        }
+
+        /// <summary>
+        /// Updates the smoothing progress of the data binding
+        /// </summary>
+        /// <param name="deltaTime"></param>
+        public void Update(double deltaTime)
+        {
+        }
+
+        /// <summary>
+        /// Applies the data binding to the <see cref="Property"/>
+        /// </summary>
+        public void ApplyToProperty()
+        {
+
+        }
+
+        private object GetInterpolatedValue()
+        {
+            if (_easingProgress >= 1.0f)
+                return _currentValue;
+
+            return Registration.Converter.Interpolate(_previousValue, _currentValue, _easingProgress);
         }
 
         internal void ApplyToEntity()
@@ -227,6 +274,20 @@ namespace Artemis.Core
             var lambda = Expression.Lambda<Func<DataModel, object>>(returnValue, parameter);
             CompiledTargetAccessor = lambda.Compile();
         }
+
+        #region Events
+
+        /// <summary>
+        ///     Occurs when a modifier is added or removed
+        /// </summary>
+        public event EventHandler ModifiersUpdated;
+
+        protected virtual void OnModifiersUpdated()
+        {
+            ModifiersUpdated?.Invoke(this, EventArgs.Empty);
+        }
+
+        #endregion
     }
 
     /// <summary>

src/Artemis.Core/Models/Profile/DataBindings/DataBindingModifier.cs

@@ -4,6 +4,7 @@ using System.Linq.Expressions;
 using Artemis.Core.DataModelExpansions;
 using Artemis.Core.Services;
 using Artemis.Storage.Entities.Profile.DataBindings;
+using LiteDB.Engine;
 using Microsoft.VisualBasic;
 using Newtonsoft.Json;
 
@@ -82,14 +83,9 @@ namespace Artemis.Core
         public object ParameterStaticValue { get; private set; }
 
         /// <summary>
-        ///     Gets the compiled function that evaluates this predicate if it of a dynamic <see cref="ParameterType" />
+        /// A compiled expression tree that when given a matching data model returns the value of the modifiers parameter
         /// </summary>
-        public Func<object, DataModel, object> CompiledDynamicPredicate { get; private set; }
-
-        /// <summary>
-        ///     Gets the compiled function that evaluates this predicate if it is of a static <see cref="ParameterType" />
-        /// </summary>
-        public Func<object, object> CompiledStaticPredicate { get; private set; }
+        public Func<DataModel, object> CompiledParameterAccessor { get; set; }
 
         internal DataBindingModifierEntity Entity { get; set; }
 
@@ -100,10 +96,14 @@ namespace Artemis.Core
         /// <returns>The modified value</returns>
         public object Apply(object currentValue)
         {
-            if (CompiledDynamicPredicate != null)
-                return CompiledDynamicPredicate(currentValue, ParameterDataModel);
-            if (CompiledStaticPredicate != null)
-                return CompiledStaticPredicate(currentValue);
+            if (ParameterType == ProfileRightSideType.Dynamic && CompiledParameterAccessor != null)
+            {
+                var value = CompiledParameterAccessor(ParameterDataModel);
+                return ModifierType.Apply(currentValue, value);
+            }
+
+            if (ParameterType == ProfileRightSideType.Static)
+                return ModifierType.Apply(currentValue, ParameterStaticValue);
 
             return currentValue;
         }
@@ -122,7 +122,7 @@ namespace Artemis.Core
                 return;
             }
 
-            var targetType = DataBinding.TargetProperty.GetType();
+            var targetType = DataBinding.TargetProperty.PropertyType;
             if (!modifierType.SupportsType(targetType))
             {
                 throw new ArtemisCoreException($"Cannot apply modifier type {modifierType.GetType().Name} to this modifier because " +
@@ -168,7 +168,7 @@ namespace Artemis.Core
             ParameterDataModel = null;
             ParameterPropertyPath = null;
 
-            var targetType = DataBinding.TargetProperty.GetType();
+            var targetType = DataBinding.TargetProperty.PropertyType;
 
             // If not null ensure the types match and if not, convert it
             if (staticValue != null && staticValue.GetType() == targetType)
@@ -208,7 +208,7 @@ namespace Artemis.Core
             else if (ParameterType == ProfileRightSideType.Static && Entity.ParameterStaticValue != null)
             {
                 // Use the target type so JSON.NET has a better idea what to do
-                var targetType = DataBinding.TargetProperty.GetType();
+                var targetType = DataBinding.TargetProperty.PropertyType;
                 object staticValue;
 
                 try
@@ -231,52 +231,23 @@ namespace Artemis.Core
 
         private void CreateExpression()
         {
-            CompiledDynamicPredicate = null;
-            CompiledStaticPredicate = null;
+            CompiledParameterAccessor = null;
 
             if (ModifierType == null || DataBinding == null)
                 return;
 
             if (ParameterType == ProfileRightSideType.Dynamic && ModifierType.SupportsParameter)
-                CreateDynamicExpression();
-            else
-                CreateStaticExpression();
+            {
+                if (ParameterDataModel == null)
+                    return;
+
+                // If the right side value is null, the constant type cannot be inferred and must be provided based on the data binding target
+                var parameterAccessor = CreateAccessor(ParameterDataModel, ParameterPropertyPath, "parameter", out var rightSideParameter);
+                var lambda = Expression.Lambda<Func<DataModel, object>>(Expression.Convert(parameterAccessor, typeof(object)), rightSideParameter);
+                CompiledParameterAccessor = lambda.Compile();
+            }
         }
-
-        private void CreateDynamicExpression()
-        {
-            if (ParameterDataModel == null)
-                return;
-
-            var currentValueParameter = Expression.Parameter(DataBinding.TargetProperty.GetType());
-
-            // If the right side value is null, the constant type cannot be inferred and must be provided based on the data binding target
-            var rightSideAccessor = CreateAccessor(ParameterDataModel, ParameterPropertyPath, "right", out var rightSideParameter);
-
-            // A conversion may be required if the types differ
-            // This can cause issues if the DisplayConditionOperator wasn't accurate in it's supported types but that is not a concern here
-            if (rightSideAccessor.Type != DataBinding.TargetProperty.GetType())
-                rightSideAccessor = Expression.Convert(rightSideAccessor, DataBinding.TargetProperty.GetType());
-
-            var modifierExpression = ModifierType.CreateExpression(currentValueParameter, rightSideAccessor);
-            var lambda = Expression.Lambda<Func<object, DataModel, object>>(modifierExpression, currentValueParameter, rightSideParameter);
-            CompiledDynamicPredicate = lambda.Compile();
-        }
-
-        private void CreateStaticExpression()
-        {
-            var currentValueParameter = Expression.Parameter(DataBinding.TargetProperty.GetType());
-
-            // If the right side value is null, the constant type cannot be inferred and must be provided based on the data binding target
-            var rightSideConstant = ParameterStaticValue != null
-                ? Expression.Constant(ParameterStaticValue)
-                : Expression.Constant(null, DataBinding.TargetProperty.GetType());
-
-            var modifierExpression = ModifierType.CreateExpression(currentValueParameter, rightSideConstant);
-            var lambda = Expression.Lambda<Func<object, object>>(modifierExpression, currentValueParameter);
-            CompiledStaticPredicate = lambda.Compile();
-        }
-
+        
         private Expression CreateAccessor(DataModel dataModel, string path, string parameterName, out ParameterExpression parameter)
         {
             var listType = dataModel.GetListTypeInPath(path);

src/Artemis.Core/Models/Profile/DataBindings/DataBindingRegistration.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Reflection;
+
+namespace Artemis.Core
+{
+    public class DataBindingRegistration
+    {
+        internal DataBindingRegistration(BaseLayerProperty layerProperty, PropertyInfo property, IDataBindingConverter converter)
+        {
+            LayerProperty = layerProperty ?? throw new ArgumentNullException(nameof(layerProperty));
+            Property = property ?? throw new ArgumentNullException(nameof(property));
+            Converter = converter ?? throw new ArgumentNullException(nameof(converter));
+        }
+
+        public BaseLayerProperty LayerProperty { get; set; }
+        public PropertyInfo Property { get; set; }
+        public IDataBindingConverter Converter { get; set; }
+    }
+}

src/Artemis.Core/Models/Profile/DataBindings/IDataBindingConverter.cs

@@ -0,0 +1,38 @@
+namespace Artemis.Core
+{
+    /// <summary>
+    ///     A data binding converter that acts as the bridge between a <see cref="DataBinding" /> and a
+    ///     <see cref="LayerProperty{T}" />
+    /// </summary>
+    public interface IDataBindingConverter
+    {
+        public BaseLayerProperty BaseLayerProperty { get; set; }
+
+        /// <summary>
+        ///     Returns the sum of <paramref name="a" /> and <paramref name="b" />
+        /// </summary>
+        object Sum(object a, object b);
+
+        /// <summary>
+        ///     Returns the the interpolated value between <paramref name="a" /> and <paramref name="b" /> on a scale (generally)
+        ///     between <c>0.0</c> and <c>1.0</c> defined by the <paramref name="progress" />
+        ///     <para>Note: The progress may go be negative or go beyond <c>1.0</c> depending on the easing method used</para>
+        /// </summary>
+        /// <param name="a">The value to interpolate away from</param>
+        /// <param name="b">The value to interpolate towards</param>
+        /// <param name="progress">The progress of the interpolation between 0.0 and 1.0</param>
+        /// <returns></returns>
+        object Interpolate(object a, object b, float progress);
+
+        /// <summary>
+        ///     Applies the <paramref name="value" /> to the layer property
+        /// </summary>
+        /// <param name="value"></param>
+        void ApplyValue(object value);
+
+        /// <summary>
+        ///     Returns the current base value of the data binding
+        /// </summary>
+        object GetValue();
+    }
+}

src/Artemis.Core/Models/Profile/DataBindings/Modifiers/Abstract/DataBindingModifierType.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Linq.Expressions;
 using Artemis.Core.Services;
 
 namespace Artemis.Core
@@ -51,12 +50,19 @@ namespace Artemis.Core
         }
 
         /// <summary>
-        ///     Creates a binary expression comparing two types
+        ///     Called whenever the modifier must apply to a specific value, must be a value of a type contained in
+        ///     <see cref="CompatibleTypes" />
         /// </summary>
-        /// <param name="currentValue">The current value of the data binding</param>
-        /// <param name="modifierArgument">An argument passed to the modifier, either static of dynamic</param>
-        /// <returns></returns>
-        public abstract Expression<object> CreateExpression(ParameterExpression currentValue, Expression modifierArgument);
+        /// <param name="currentValue">
+        ///     The current value before modification, is always of a type contained in
+        ///     <see cref="CompatibleTypes" />
+        /// </param>
+        /// <param name="parameterValue">
+        ///     The parameter to use for the modification, is always of a type contained in
+        ///     <see cref="CompatibleTypes" />
+        /// </param>
+        /// <returns>The modified value, must be a value of a type contained in <see cref="CompatibleTypes" /></returns>
+        public abstract object Apply(object currentValue, object parameterValue);
 
         internal void Register(PluginInfo pluginInfo, IDataBindingService dataBindingService)
         {

src/Artemis.Core/Models/Profile/DataBindings/Modifiers/DivideModifierType.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+
+namespace Artemis.Core
+{
+    internal class DivideModifierType : DataBindingModifierType
+    {
+        public override IReadOnlyCollection<Type> CompatibleTypes => Constants.NumberTypes;
+
+        public override string Description => "Divide by";
+        public override string Icon => "Divide";
+
+        public override object Apply(object currentValue, object parameterValue)
+        {
+            var parameter = Convert.ToSingle(parameterValue);
+            // Ye ye none of that
+            if (parameter == 0)
+                return 0;
+
+            return Convert.ToSingle(currentValue) / parameter;
+        }
+    }
+}

src/Artemis.Core/Models/Profile/DataBindings/Modifiers/MultiplicationModifier.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+
+namespace Artemis.Core
+{
+    internal class MultiplicationModifierType : DataBindingModifierType
+    {
+        public override IReadOnlyCollection<Type> CompatibleTypes => Constants.NumberTypes;
+
+        public override string Description => "Multiply by";
+        public override string Icon => "Close";
+
+        public override object Apply(object currentValue, object parameterValue)
+        {
+            return Convert.ToSingle(currentValue) * Convert.ToSingle(parameterValue);
+        }
+    }
+}

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

@@ -186,9 +186,6 @@ namespace Artemis.Core
             Transform.ApplyToEntity();
             LayerBrush?.BaseProperties.ApplyToEntity();
 
-            // Effects
-            ApplyRenderElementToEntity();
-
             // LEDs
             LayerEntity.Leds.Clear();
             foreach (var artemisLed in Leds)
@@ -204,6 +201,8 @@ namespace Artemis.Core
             // Conditions
             RenderElementEntity.RootDisplayCondition = DisplayConditionGroup?.Entity;
             DisplayConditionGroup?.ApplyToEntity();
+
+            ApplyRenderElementToEntity();
         }
 
         #endregion
@@ -313,6 +312,18 @@ namespace Artemis.Core
             }
         }
 
+        /// <inheritdoc />
+        public override List<BaseLayerProperty> GetAllLayerProperties()
+        {
+            var result = base.GetAllLayerProperties();
+            result.AddRange(General.GetAllLayerProperties());
+            result.AddRange(Transform.GetAllLayerProperties());
+            if (LayerBrush?.BaseProperties != null) 
+                result.AddRange(LayerBrush.BaseProperties.GetAllLayerProperties());
+
+            return result;
+        }
+
         /// <inheritdoc />
         public override void Render(double deltaTime, SKCanvas canvas, SKImageInfo canvasInfo)
         {

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

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
+using Artemis.Core.Services;
 using Artemis.Storage.Entities.Profile;
 
 namespace Artemis.Core
@@ -11,6 +12,7 @@ namespace Artemis.Core
     public abstract class BaseLayerProperty
     {
         protected readonly List<DataBinding> _dataBindings = new List<DataBinding>();
+        protected readonly List<DataBindingRegistration> _dataBindingRegistrations = new List<DataBindingRegistration>();
         private bool _isHidden;
         private bool _keyframesEnabled;
 
@@ -18,6 +20,11 @@ namespace Artemis.Core
         {
         }
 
+        /// <summary>
+        ///     Gets a list containing the active data bindings
+        /// </summary>
+        public IReadOnlyList<DataBinding> DataBindings => _dataBindings.AsReadOnly();
+
         /// <summary>
         ///     Gets the profile element (such as layer or folder) this effect is applied to
         /// </summary>
@@ -38,11 +45,6 @@ namespace Artemis.Core
         /// </summary>
         public bool DataBindingsSupported { get; protected internal set; } = true;
 
-        /// <summary>
-        ///     Gets a read-only collection of the currently applied data bindings
-        /// </summary>
-        public IReadOnlyCollection<DataBinding> DataBindings => _dataBindings.AsReadOnly();
-
         /// <summary>
         ///     Gets or sets whether keyframes are enabled on this property, has no effect if <see cref="KeyframesSupported" /> is
         ///     False
@@ -104,18 +106,6 @@ namespace Artemis.Core
         /// </summary>
         public abstract Type GetPropertyType();
 
-        /// <summary>
-        ///     Returns a list of properties to which data bindings can be applied
-        /// </summary>
-        /// <returns></returns>
-        public abstract List<PropertyInfo> GetDataBindingProperties();
-
-        /// <summary>
-        ///     Called when the provided data binding must be applied to a property
-        /// </summary>
-        /// <param name="dataBinding"></param>
-        protected abstract void ApplyDataBinding(DataBinding dataBinding);
-
         /// <summary>
         ///     Applies the provided property entity to the layer property by deserializing the JSON base value and keyframe values
         /// </summary>
@@ -132,23 +122,26 @@ namespace Artemis.Core
 
         #region Data bindings
 
-        /// <summary>
-        ///     Applies the current <see cref="DataBindings" /> to the layer property
-        /// </summary>
-        public void ApplyDataBindings()
+        internal DataBindingRegistration RegisterDataBindingProperty(PropertyInfo property, IDataBindingConverter converter)
+        {
+            var registration = new DataBindingRegistration(this, property, converter);
+            _dataBindingRegistrations.Add(registration);
+            return registration;
+        }
+
+        internal void InitializeDataBindings(IDataModelService dataModelService, IDataBindingService dataBindingService)
         {
             foreach (var dataBinding in DataBindings)
-                ApplyDataBinding(dataBinding);
+                dataBinding.Initialize(dataModelService, dataBindingService);
         }
 
         /// <summary>
         ///     Adds a new data binding targeting the given property to the <see cref="DataBindings" /> collection
         /// </summary>
-        /// <param name="targetProperty">The property the new data binding should target</param>
         /// <returns>The newly created data binding</returns>
-        public DataBinding AddDataBinding(PropertyInfo targetProperty)
+        public DataBinding EnableDataBinding(DataBindingRegistration dataBindingRegistration)
         {
-            var dataBinding = new DataBinding(this, targetProperty);
+            var dataBinding = new DataBinding(this, dataBindingProperty);
             _dataBindings.Add(dataBinding);
 
             return dataBinding;
@@ -158,13 +151,11 @@ namespace Artemis.Core
         ///     Removes the provided data binding from the <see cref="DataBindings" /> collection
         /// </summary>
         /// <param name="dataBinding">The data binding to remove</param>
-        public void RemoveDataBinding(DataBinding dataBinding)
+        public void DisableDataBinding(DataBinding dataBinding)
         {
             _dataBindings.Remove(dataBinding);
         }
 
-        
-
         #endregion
 
         #region Events

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

@@ -2,7 +2,9 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Reflection;
+using Artemis.Core.DataModelExpansions;
 using Artemis.Storage.Entities.Profile;
 using Newtonsoft.Json;
 
@@ -16,7 +18,7 @@ namespace Artemis.Core
     ///     </para>
     /// </summary>
     /// <typeparam name="T">The type of property encapsulated in this layer property</typeparam>
-    public class LayerProperty<T> : BaseLayerProperty
+    public abstract class LayerProperty<T> : BaseLayerProperty
     {
         private T _baseValue;
         private bool _isInitialized;
@@ -198,41 +200,6 @@ namespace Artemis.Core
             OnUpdated();
         }
 
-        private void UpdateKeyframes()
-        {
-            if (!KeyframesSupported || !KeyframesEnabled)
-                return;
-
-            // The current keyframe is the last keyframe before the current time
-            CurrentKeyframe = _keyframes.LastOrDefault(k => k.Position <= ProfileElement.TimelinePosition);
-            // Keyframes are sorted by position so we can safely assume the next keyframe's position is after the current 
-            var nextIndex = _keyframes.IndexOf(CurrentKeyframe) + 1;
-            NextKeyframe = _keyframes.Count > nextIndex ? _keyframes[nextIndex] : null;
-
-            // No need to update the current value if either of the keyframes are null
-            if (CurrentKeyframe == null)
-                CurrentValue = _keyframes.Any() ? _keyframes[0].Value : BaseValue;
-            else if (NextKeyframe == null)
-                CurrentValue = CurrentKeyframe.Value;
-            // Only determine progress and current value if both keyframes are present
-            else
-            {
-                var timeDiff = NextKeyframe.Position - CurrentKeyframe.Position;
-                var keyframeProgress = (float) ((ProfileElement.TimelinePosition - CurrentKeyframe.Position).TotalMilliseconds / timeDiff.TotalMilliseconds);
-                var keyframeProgressEased = (float) Easings.Interpolate(keyframeProgress, CurrentKeyframe.EasingFunction);
-                UpdateCurrentValue(keyframeProgress, keyframeProgressEased);
-            }
-        }
-
-        private void UpdateDataBindings(double deltaTime)
-        {
-            foreach (var dataBinding in DataBindings)
-            {
-                dataBinding.Update(deltaTime);
-                ApplyDataBinding(dataBinding);
-            }
-        }
-
         /// <summary>
         ///     Sorts the keyframes in ascending order by position
         /// </summary>
@@ -303,20 +270,88 @@ namespace Artemis.Core
                 Position = k.Position,
                 EasingFunction = (int) k.EasingFunction
             }));
+
+            PropertyEntity.DataBindingEntities.Clear();
+            foreach (var dataBinding in DataBindings)
+            {
+                dataBinding.ApplyToEntity();
+                PropertyEntity.DataBindingEntities.Add(dataBinding.Entity);
+            }
+        }
+
+        private void UpdateKeyframes()
+        {
+            if (!KeyframesSupported || !KeyframesEnabled)
+                return;
+
+            // The current keyframe is the last keyframe before the current time
+            CurrentKeyframe = _keyframes.LastOrDefault(k => k.Position <= ProfileElement.TimelinePosition);
+            // Keyframes are sorted by position so we can safely assume the next keyframe's position is after the current 
+            var nextIndex = _keyframes.IndexOf(CurrentKeyframe) + 1;
+            NextKeyframe = _keyframes.Count > nextIndex ? _keyframes[nextIndex] : null;
+
+            // No need to update the current value if either of the keyframes are null
+            if (CurrentKeyframe == null)
+                CurrentValue = _keyframes.Any() ? _keyframes[0].Value : BaseValue;
+            else if (NextKeyframe == null)
+                CurrentValue = CurrentKeyframe.Value;
+            // Only determine progress and current value if both keyframes are present
+            else
+            {
+                var timeDiff = NextKeyframe.Position - CurrentKeyframe.Position;
+                var keyframeProgress = (float) ((ProfileElement.TimelinePosition - CurrentKeyframe.Position).TotalMilliseconds / timeDiff.TotalMilliseconds);
+                var keyframeProgressEased = (float) Easings.Interpolate(keyframeProgress, CurrentKeyframe.EasingFunction);
+                UpdateCurrentValue(keyframeProgress, keyframeProgressEased);
+            }
         }
 
         #region Data bindings
 
-        /// <inheritdoc />
-        public override List<PropertyInfo> GetDataBindingProperties()
+        public void RegisterDataBindingProperty<TProperty>(Expression<Func<T, TProperty>> propertyLambda, IDataBindingConverter converter)
         {
-            return new List<PropertyInfo> {GetType().GetProperty(nameof(CurrentValue))};
+
+            var propertyInfo = ReflectionUtilities.GetPropertyInfo(CurrentValue, propertyLambda);
+            
         }
 
-        /// <inheritdoc />
-        protected override void ApplyDataBinding(DataBinding dataBinding)
+        /// <summary>
+        ///     Registers the provided property to be available for data binding using a data binding property of type
+        ///     <typeparamref name="TD" />
+        /// </summary>
+        /// <typeparam name="TD">The type of data binding property to use</typeparam>
+        /// <param name="propertyName">The name of the property</param>
+        /// <returns></returns>
+        public TD RegisterDataBindingProperty<TD>(string propertyName, IDataBindingConverter converter) where TD : BaseDataBindingProperty
         {
-            CurrentValue = (T) dataBinding.GetValue(CurrentValue);
+            var property = typeof(T).GetProperty(propertyName);
+            if (property == null)
+            {
+                throw new ArtemisCoreException($"Cannot register data binding property for property {propertyName} " +
+                                               $"because it does not exist on type {typeof(T).Name}");
+            }
+
+            // Create an instance of the converter
+            var dataBindingOperator = (TD) Activator.CreateInstance(typeof(TD), property);
+            if (dataBindingOperator == null)
+                throw new ArtemisCoreException($"Cannot register data binding, failed to create an instance of {typeof(TD).Name}");
+            if (dataBindingOperator.PropertyType != property.PropertyType)
+            {
+                throw new ArtemisCoreException($"Cannot register data binding property for property {propertyName} using a {typeof(TD).Name} " +
+                                               $"because it does not support type {typeof(T).Name}");
+            }
+
+            AddDataBindingConverter(dataBindingOperator);
+
+            return dataBindingOperator;
+        }
+        
+        private void UpdateDataBindings(double deltaTime)
+        {
+            foreach (var dataBinding in DataBindings)
+            {
+                dataBinding.Update(deltaTime);
+                dataBinding.ApplyToProperty();
+            }
         }
 
         #endregion

src/Artemis.Core/Models/Profile/LayerProperties/Types/SKColorLayerProperty.cs

@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
 using SkiaSharp;
 
 namespace Artemis.Core
@@ -11,10 +8,15 @@ namespace Artemis.Core
     {
         internal SKColorLayerProperty()
         {
+            RegisterDataBindingProperty(color => color.Alpha, new SKColorDataBindingConverter(SKColorDataBindingConverter.Channel.Alpha));
+            RegisterDataBindingProperty(color => color.Red, new SKColorDataBindingConverter(SKColorDataBindingConverter.Channel.Red));
+            RegisterDataBindingProperty(color => color.Green, new SKColorDataBindingConverter(SKColorDataBindingConverter.Channel.Green));
+            RegisterDataBindingProperty(color => color.Blue, new SKColorDataBindingConverter(SKColorDataBindingConverter.Channel.Blue));
+            RegisterDataBindingProperty(color => color.Hue, new SKColorDataBindingConverter(SKColorDataBindingConverter.Channel.Hue));
         }
 
         /// <summary>
-        ///  Implicitly converts an <see cref="SKColorLayerProperty" /> to an <see cref="SKColor" />
+        ///     Implicitly converts an <see cref="SKColorLayerProperty" /> to an <see cref="SKColor" />¶
         /// </summary>
         /// <param name="p"></param>
         /// <returns></returns>
@@ -28,29 +30,84 @@ namespace Artemis.Core
         {
             CurrentValue = CurrentKeyframe.Value.Interpolate(NextKeyframe.Value, keyframeProgressEased);
         }
+    }
 
-        /// <inheritdoc />
-        public override List<PropertyInfo> GetDataBindingProperties()
+    internal class SKColorDataBindingConverter : IDataBindingConverter
+    {
+        private readonly Channel _channel;
+
+        public SKColorDataBindingConverter(Channel channel)
         {
-            return typeof(SKColor).GetProperties().ToList();
+            _channel = channel;
         }
 
-        /// <inheritdoc />
-        protected override void ApplyDataBinding(DataBinding dataBinding)
+        public BaseLayerProperty BaseLayerProperty { get; set; }
+
+        public object Sum(object a, object b)
         {
-            if (dataBinding.TargetProperty.Name == nameof(CurrentValue.Alpha))
-                CurrentValue = CurrentValue.WithAlpha((byte) dataBinding.GetValue(BaseValue.Alpha));
-            else if (dataBinding.TargetProperty.Name == nameof(CurrentValue.Red))
-                CurrentValue = CurrentValue.WithRed((byte) dataBinding.GetValue(BaseValue.Red));
-            else if (dataBinding.TargetProperty.Name == nameof(CurrentValue.Green))
-                CurrentValue = CurrentValue.WithGreen((byte) dataBinding.GetValue(BaseValue.Green));
-            else if (dataBinding.TargetProperty.Name == nameof(CurrentValue.Blue))
-                CurrentValue = CurrentValue.WithBlue((byte) dataBinding.GetValue(BaseValue.Blue));
-            else if (dataBinding.TargetProperty.Name == nameof(CurrentValue.Hue))
+            return (float) a + (float) b;
+        }
+
+        public object Interpolate(object a, object b, float progress)
+        {
+            var diff = (float) b - (float) a;
+            return diff * progress;
+        }
+
+        public void ApplyValue(object value)
+        {
+            var property = (SKColorLayerProperty) BaseLayerProperty;
+            switch (_channel)
             {
-                CurrentValue.ToHsv(out var h, out var s, out var v);
-                CurrentValue = SKColor.FromHsv((float) dataBinding.GetValue(h), s, v);
+                case Channel.Alpha:
+                    property.CurrentValue = property.CurrentValue.WithAlpha((byte) value);
+                    break;
+                case Channel.Red:
+                    property.CurrentValue = property.CurrentValue.WithRed((byte) value);
+                    break;
+                case Channel.Green:
+                    property.CurrentValue = property.CurrentValue.WithGreen((byte) value);
+                    break;
+                case Channel.Blue:
+                    property.CurrentValue = property.CurrentValue.WithBlue((byte) value);
+                    break;
+                case Channel.Hue:
+                    property.CurrentValue.ToHsv(out var h, out var s, out var v);
+                    property.CurrentValue = SKColor.FromHsv((float) value, s, v);
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
             }
         }
+
+        public object GetValue()
+        {
+            var property = (SKColorLayerProperty) BaseLayerProperty;
+            switch (_channel)
+            {
+                case Channel.Alpha:
+                    return property.CurrentValue.Alpha;
+                case Channel.Red:
+                    return property.CurrentValue.Red;
+                case Channel.Green:
+                    return property.CurrentValue.Green;
+                case Channel.Blue:
+                    return property.CurrentValue.Blue;
+                case Channel.Hue:
+                    property.CurrentValue.ToHsv(out var h, out _, out _);
+                    return h;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public enum Channel
+        {
+            Alpha,
+            Red,
+            Green,
+            Blue,
+            Hue
+        }
     }
 }

src/Artemis.Core/Models/Profile/LayerProperties/Types/SKPointLayerProperty.cs

@@ -27,20 +27,5 @@ namespace Artemis.Core
             var yDiff = NextKeyframe.Value.Y - CurrentKeyframe.Value.Y;
             CurrentValue = new SKPoint(CurrentKeyframe.Value.X + xDiff * keyframeProgressEased, CurrentKeyframe.Value.Y + yDiff * keyframeProgressEased);
         }
-
-        /// <inheritdoc />
-        public override List<PropertyInfo> GetDataBindingProperties()
-        {
-            return typeof(SKPoint).GetProperties().Where(p => p.CanWrite).ToList();
-        }
-
-        /// <inheritdoc />
-        protected override void ApplyDataBinding(DataBinding dataBinding)
-        {
-            if (dataBinding.TargetProperty.Name == nameof(CurrentValue.X))
-                CurrentValue = new SKPoint((float) dataBinding.GetValue(BaseValue), CurrentValue.Y);
-            else if (dataBinding.TargetProperty.Name == nameof(CurrentValue.Y))
-                CurrentValue = new SKPoint(CurrentValue.X, (float) dataBinding.GetValue(BaseValue));
-        }
     }
 }

src/Artemis.Core/Models/Profile/LayerProperties/Types/SKSizeLayerProperty.cs

@@ -27,20 +27,5 @@ namespace Artemis.Core
             var heightDiff = NextKeyframe.Value.Height - CurrentKeyframe.Value.Height;
             CurrentValue = new SKSize(CurrentKeyframe.Value.Width + widthDiff * keyframeProgressEased, CurrentKeyframe.Value.Height + heightDiff * keyframeProgressEased);
         }
-
-        /// <inheritdoc />
-        public override List<PropertyInfo> GetDataBindingProperties()
-        {
-            return typeof(SKSize).GetProperties().Where(p => p.CanWrite).ToList();
-        }
-
-        /// <inheritdoc />
-        protected override void ApplyDataBinding(DataBinding dataBinding)
-        {
-            if (dataBinding.TargetProperty.Name == nameof(CurrentValue.Height))
-                CurrentValue = new SKSize(CurrentValue.Width, (float) dataBinding.GetValue(BaseValue));
-            else if (dataBinding.TargetProperty.Name == nameof(CurrentValue.Width))
-                CurrentValue = new SKSize((float) dataBinding.GetValue(BaseValue), CurrentValue.Width);
-        }
     }
 }

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

@@ -311,5 +311,17 @@ namespace Artemis.Core
         }
 
         #endregion
+
+        /// <summary>
+        /// Returns all the layer properties of this profile element
+        /// </summary>
+        public virtual List<BaseLayerProperty> GetAllLayerProperties()
+        {
+            var result = new List<BaseLayerProperty>();
+            foreach (var baseLayerEffect in LayerEffects) 
+                result.AddRange(baseLayerEffect.BaseProperties.GetAllLayerProperties());
+
+            return result;
+        }
     }
 }

src/Artemis.Core/Services/DataBindingService.cs

@@ -15,6 +15,8 @@ namespace Artemis.Core.Services
         {
             _logger = logger;
             _registeredDataBindingModifierTypes = new List<DataBindingModifierType>();
+
+            RegisterBuiltInModifiers();
         }
 
         public IReadOnlyCollection<DataBindingModifierType> RegisteredDataBindingModifierTypes
@@ -98,5 +100,10 @@ namespace Artemis.Core.Services
                 dataBindingModifier.Entity.ModifierType
             );
         }
+
+        private void RegisterBuiltInModifiers()
+        {
+            RegisterModifierType(Constants.CorePluginInfo, new MultiplicationModifierType());
+        }
     }
 }

src/Artemis.Core/Services/Interfaces/IRenderElementService.cs

@@ -54,5 +54,6 @@ namespace Artemis.Core.Services
         void RemoveLayerEffect(BaseLayerEffect layerEffect);
 
         void InstantiateDisplayConditions(RenderProfileElement renderElement);
+        void InstantiateDataBindings(RenderProfileElement renderElement);
     }
 }

src/Artemis.Core/Services/RenderElementService.cs

@@ -10,16 +10,18 @@ namespace Artemis.Core.Services
     internal class RenderElementService : IRenderElementService
     {
         private readonly IDataModelService _dataModelService;
+        private readonly IDataBindingService _dataBindingService;
         private readonly IKernel _kernel;
         private readonly ILogger _logger;
         private readonly IPluginService _pluginService;
 
-        public RenderElementService(IKernel kernel, ILogger logger, IPluginService pluginService, IDataModelService dataModelService)
+        public RenderElementService(IKernel kernel, ILogger logger, IPluginService pluginService, IDataModelService dataModelService, IDataBindingService dataBindingService)
         {
             _kernel = kernel;
             _logger = logger;
             _pluginService = pluginService;
             _dataModelService = dataModelService;
+            _dataBindingService = dataBindingService;
         }
 
         public Layer CreateLayer(Profile profile, ProfileElement parent, string name)
@@ -35,6 +37,7 @@ namespace Artemis.Core.Services
             InstantiateLayerBrush(layer);
             InstantiateLayerEffects(layer);
             InstantiateDisplayConditions(layer);
+            InstantiateDataBindings(layer);
             return layer;
         }
 
@@ -156,5 +159,11 @@ namespace Artemis.Core.Services
                 _logger.Warning(e, $"Failed to init display conditions for {renderElement}");
             }
         }
+
+        public void InstantiateDataBindings(RenderProfileElement renderElement)
+        {
+            foreach (var baseLayerProperty in renderElement.GetAllLayerProperties()) 
+                baseLayerProperty.InitializeDataBindings(_dataModelService, _dataBindingService);
+        }
     }
 }

src/Artemis.Core/Services/Storage/ProfileService.cs

@@ -299,6 +299,7 @@ namespace Artemis.Core.Services
                     _renderElementService.RemoveLayerEffect(layerLayerEffect);
 
                 _renderElementService.InstantiateDisplayConditions(folder);
+                _renderElementService.InstantiateDataBindings(folder);
             }
         }
 
@@ -324,6 +325,7 @@ namespace Artemis.Core.Services
                     _renderElementService.RemoveLayerEffect(layerLayerEffect);
 
                 _renderElementService.InstantiateDisplayConditions(layer);
+                _renderElementService.InstantiateDataBindings(layer);
             }
         }