DarthAffe/Artemis
1
0 Fork 0
mirror of https://github.com/Artemis-RGB/Artemis synced 2026-11-11 19:36:28 +00:00
Code Issues Releases Wiki Activity

Plugins - Moved test data model to a seperate plugin

Browse Source 
Core - Moved built-in types to a separate folder and namespace
This commit is contained in:
Robert committed 2020-09-16 19:22:37 +02:00
1 parent d788183f25
commit d9017c67b4
59 files changed
+350 -131
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/Artemis.Core/Models/Profile/Conditions/Operators/EqualsConditionOperator.cs
-19
View File
@@ -1,19 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace Artemis.Core
{
internal class EqualsConditionOperator : ConditionOperator
{
public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(object)};
public override string Description => "Equals";
public override string Icon => "Equal";
public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
{
return Expression.Equal(leftSide, rightSide);
}
}
}
src/Artemis.Core/Models/Profile/Conditions/Operators/GreaterThanConditionOperator.cs
-19
View File
@@ -1,19 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace Artemis.Core
{
internal class GreaterThanConditionOperator : ConditionOperator
{
public override IReadOnlyCollection<Type> CompatibleTypes => Constants.NumberTypes;
public override string Description => "Is greater than";
public override string Icon => "GreaterThan";
public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
{
return Expression.GreaterThan(leftSide, rightSide);
}
}
}
src/Artemis.Core/Models/Profile/Conditions/Operators/GreaterThanOrEqualConditionOperator.cs
-19
View File
@@ -1,19 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace Artemis.Core
{
internal class GreaterThanOrEqualConditionOperator : ConditionOperator
{
public override IReadOnlyCollection<Type> CompatibleTypes => Constants.NumberTypes;
public override string Description => "Is greater than or equal to";
public override string Icon => "GreaterThanOrEqual";
public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
{
return Expression.GreaterThanOrEqual(leftSide, rightSide);
}
}
}
src/Artemis.Core/Models/Profile/Conditions/Operators/LessThanConditionOperator.cs
-19
View File
@@ -1,19 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace Artemis.Core
{
internal class LessThanConditionOperator : ConditionOperator
{
public override IReadOnlyCollection<Type> CompatibleTypes => Constants.NumberTypes;
public override string Description => "Is less than";
public override string Icon => "LessThan";
public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
{
return Expression.LessThan(leftSide, rightSide);
}
}
}
src/Artemis.Core/Models/Profile/Conditions/Operators/LessThanOrEqualConditionOperator.cs
-19
View File
@@ -1,19 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace Artemis.Core
{
internal class LessThanOrEqualConditionOperator : ConditionOperator
{
public override IReadOnlyCollection<Type> CompatibleTypes => Constants.NumberTypes;
public override string Description => "Is less than or equal to";
public override string Icon => "LessThanOrEqual";
public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
{
return Expression.LessThanOrEqual(leftSide, rightSide);
}
}
}
src/Artemis.Core/Models/Profile/Conditions/Operators/NotEqualConditionOperator.cs
-19
View File
@@ -1,19 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace Artemis.Core
{
internal class NotEqualConditionOperator : ConditionOperator
{
public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(object)};
public override string Description => "Does not equal";
public override string Icon => "NotEqualVariant";
public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
{
return Expression.NotEqual(leftSide, rightSide);
}
}
}
src/Artemis.Core/Models/Profile/Conditions/Operators/StringContainsConditionOperator.cs
-29
View File
@@ -1,29 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;
namespace Artemis.Core
{
internal class StringContainsConditionOperator : ConditionOperator
{
private readonly MethodInfo _contains;
private readonly MethodInfo _toLower;
public StringContainsConditionOperator()
{
_toLower = typeof(string).GetMethod("ToLower", new Type[] { });
_contains = typeof(string).GetMethod("Contains", new[] {typeof(string)});
}
public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(string)};
public override string Description => "Contains";
public override string Icon => "Contain";
public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
{
return Expression.Equal(Expression.Call(Expression.Call(leftSide, _toLower), _contains, Expression.Call(rightSide, _toLower)), Expression.Constant(true));
}
}
}
src/Artemis.Core/Models/Profile/Conditions/Operators/StringEndsWithConditionOperator.cs
-29
View File
@@ -1,29 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;
namespace Artemis.Core
{
internal class StringEndsWithConditionOperator : ConditionOperator
{
private readonly MethodInfo _endsWith;
private readonly MethodInfo _toLower;
public StringEndsWithConditionOperator()
{
_toLower = typeof(string).GetMethod("ToLower", new Type[] { });
_endsWith = typeof(string).GetMethod("EndsWith", new[] {typeof(string)});
}
public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(string)};
public override string Description => "Ends with";
public override string Icon => "ContainEnd";
public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
{
return Expression.Equal(Expression.Call(Expression.Call(leftSide, _toLower), _endsWith, Expression.Call(rightSide, _toLower)), Expression.Constant(true));
}
}
}
src/Artemis.Core/Models/Profile/Conditions/Operators/StringEqualsConditionOperator.cs
-27
View File
@@ -1,27 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;
namespace Artemis.Core
{
internal class StringEqualsConditionOperator : ConditionOperator
{
private readonly MethodInfo _toLower;
public StringEqualsConditionOperator()
{
_toLower = typeof(string).GetMethod("ToLower", new Type[] { });
}
public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(string)};
public override string Description => "Equals";
public override string Icon => "Equal";
public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
{
return Expression.Equal(Expression.Call(leftSide, _toLower), Expression.Call(rightSide, _toLower));
}
}
}
src/Artemis.Core/Models/Profile/Conditions/Operators/StringNotContainsConditionOperator.cs
-29
View File
@@ -1,29 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;
namespace Artemis.Core
{
internal class StringNotContainsConditionOperator : ConditionOperator
{
private readonly MethodInfo _contains;
private readonly MethodInfo _toLower;
public StringNotContainsConditionOperator()
{
_toLower = typeof(string).GetMethod("ToLower", new Type[] { });
_contains = typeof(string).GetMethod("Contains", new[] {typeof(string)});
}
public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(string)};
public override string Description => "Does not contain";
public override string Icon => "FormatStrikethrough";
public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
{
return Expression.Equal(Expression.Call(Expression.Call(leftSide, _toLower), _contains, Expression.Call(rightSide, _toLower)), Expression.Constant(false));
}
}
}
src/Artemis.Core/Models/Profile/Conditions/Operators/StringNotEqualConditionOperator.cs
-27
View File
@@ -1,27 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;
namespace Artemis.Core
{
internal class StringNotEqualConditionOperator : ConditionOperator
{
private readonly MethodInfo _toLower;
public StringNotEqualConditionOperator()
{
_toLower = typeof(string).GetMethod("ToLower", new Type[] { });
}
public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(string)};
public override string Description => "Does not equal";
public override string Icon => "NotEqualVariant";
public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
{
return Expression.NotEqual(Expression.Call(leftSide, _toLower), Expression.Call(rightSide, _toLower));
}
}
}
src/Artemis.Core/Models/Profile/Conditions/Operators/StringNullConditionOperator.cs
-24
View File
@@ -1,24 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace Artemis.Core
{
internal class StringNullConditionOperator : ConditionOperator
{
public StringNullConditionOperator()
{
SupportsRightSide = false;
}
public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(string)};
public override string Description => "Is null";
public override string Icon => "Null";
public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
{
return Expression.Equal(leftSide, Expression.Constant(null, leftSide.Type));
}
}
}
src/Artemis.Core/Models/Profile/Conditions/Operators/StringStartsWithConditionOperator.cs
-29
View File
@@ -1,29 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;
namespace Artemis.Core
{
internal class StringStartsWithConditionOperator : ConditionOperator
{
private readonly MethodInfo _startsWith;
private readonly MethodInfo _toLower;
public StringStartsWithConditionOperator()
{
_toLower = typeof(string).GetMethod("ToLower", new Type[] { });
_startsWith = typeof(string).GetMethod("StartsWith", new[] {typeof(string)});
}
public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(string)};
public override string Description => "Starts with";
public override string Icon => "ContainStart";
public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
{
return Expression.Equal(Expression.Call(Expression.Call(leftSide, _toLower), _startsWith, Expression.Call(rightSide, _toLower)), Expression.Constant(true));
}
}
}
src/Artemis.Core/Models/Profile/DataBindings/Converters/FloatDataBindingConverter.cs
-51
View File
@@ -1,51 +0,0 @@
using System;
using SkiaSharp;
namespace Artemis.Core
{
/// <inheritdoc />
public class FloatDataBindingConverter : FloatDataBindingConverter<float>
{
}
/// <inheritdoc />
/// <typeparam name="T">The type of layer property this converter is applied to</typeparam>
public class FloatDataBindingConverter<T> : DataBindingConverter<T, float>
{
/// <summary>
/// Creates a new instance of the <see cref="FloatDataBindingConverter{T}" /> class
/// </summary>
public FloatDataBindingConverter()
{
SupportsSum = true;
SupportsInterpolate = true;
}
/// <inheritdoc />
public override float Sum(float a, float b)
{
return a + b;
}
/// <inheritdoc />
public override float Interpolate(float a, float b, double progress)
{
var diff = b - a;
return (float) (a + diff * progress);
}
/// <inheritdoc />
public override void ApplyValue(float value)
{
if (ValueTypeSetExpression == null)
return;
if (DataBinding.LayerProperty.PropertyDescription.MaxInputValue is float max)
value = Math.Min(value, max);
if (DataBinding.LayerProperty.PropertyDescription.MinInputValue is float min)
value = Math.Max(value, min);
base.ApplyValue(value);
}
}
}
src/Artemis.Core/Models/Profile/DataBindings/Converters/GeneralDataBindingConverter.cs
-26
View File
@@ -1,26 +0,0 @@
using System;
namespace Artemis.Core
{
/// <inheritdoc />
public class GeneralDataBindingConverter<T> : DataBindingConverter<T, object> where T : ILayerProperty
{
public GeneralDataBindingConverter()
{
SupportsSum = false;
SupportsInterpolate = false;
}
/// <inheritdoc />
public override object Sum(object a, object b)
{
throw new NotSupportedException();
}
/// <inheritdoc />
public override object Interpolate(object a, object b, double progress)
{
throw new NotSupportedException();
}
}
}
src/Artemis.Core/Models/Profile/DataBindings/Converters/IntDataBindingConverter.cs
-41
View File
@@ -1,41 +0,0 @@
using System;
namespace Artemis.Core
{
/// <inheritdoc />
public class IntDataBindingConverter : IntDataBindingConverter<int>
{
}
/// <inheritdoc />
public class IntDataBindingConverter<T> : DataBindingConverter<T, int>
{
/// <summary>
/// Creates a new instance of the <see cref="IntDataBindingConverter{T}" /> class
/// </summary>
public IntDataBindingConverter()
{
SupportsSum = true;
SupportsInterpolate = true;
}
/// <summary>
/// Gets or sets the <see cref="MidpointRounding" /> mode used for rounding during interpolation. Defaults to
/// <see cref="MidpointRounding.AwayFromZero" />
/// </summary>
public MidpointRounding InterpolationRoundingMode { get; set; } = MidpointRounding.AwayFromZero;
/// <inheritdoc />
public override int Sum(int a, int b)
{
return a + b;
}
/// <inheritdoc />
public override int Interpolate(int a, int b, double progress)
{
var diff = b - a;
return (int) Math.Round(a + diff * progress, InterpolationRoundingMode);
}
}
}
src/Artemis.Core/Models/Profile/DataBindings/Converters/Internal/SKColorArgbDataBindingConverter.cs
-70
View File
@@ -1,70 +0,0 @@
using System;
using SkiaSharp;
namespace Artemis.Core
{
// This is internal because it's mainly a proof-of-concept
internal class SKColorArgbDataBindingConverter : DataBindingConverter<SKColor, byte>
{
private readonly Channel _channel;
public SKColorArgbDataBindingConverter(Channel channel)
{
_channel = channel;
SupportsSum = true;
SupportsInterpolate = true;
}
public override byte Sum(byte a, byte b)
{
return ClampToByte(a + b);
}
public override byte Interpolate(byte a, byte b, double progress)
{
var diff = b - a;
return ClampToByte(a + diff * progress);
}
public override void ApplyValue(byte value)
{
switch (_channel)
{
case Channel.Alpha:
DataBinding.LayerProperty.CurrentValue = DataBinding.LayerProperty.CurrentValue.WithAlpha(value);
break;
case Channel.Red:
DataBinding.LayerProperty.CurrentValue = DataBinding.LayerProperty.CurrentValue.WithRed(value);
break;
case Channel.Green:
DataBinding.LayerProperty.CurrentValue = DataBinding.LayerProperty.CurrentValue.WithGreen(value);
break;
case Channel.Blue:
DataBinding.LayerProperty.CurrentValue = DataBinding.LayerProperty.CurrentValue.WithBlue(value);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public override byte ConvertFromObject(object source)
{
var saveValue = Convert.ToDouble(source);
return ClampToByte(saveValue);
}
private static byte ClampToByte(double value)
{
return (byte) Math.Clamp(value, 0, 255);
}
public enum Channel
{
Alpha,
Red,
Green,
Blue
}
}
}
src/Artemis.Core/Models/Profile/DataBindings/Converters/SKColorDataBindingConverter.cs
-20
View File
@@ -1,20 +0,0 @@
using SkiaSharp;
namespace Artemis.Core
{
/// <inheritdoc />
public class SKColorDataBindingConverter : DataBindingConverter<SKColor, SKColor>
{
/// <inheritdoc />
public override SKColor Sum(SKColor a, SKColor b)
{
return a.Sum(b);
}
/// <inheritdoc />
public override SKColor Interpolate(SKColor a, SKColor b, double progress)
{
return a.Interpolate(b, (float)progress);
}
}
}
src/Artemis.Core/Models/Profile/DataBindings/Modifiers/Abstract/DataBindingModifierType.cs → src/Artemis.Core/Models/Profile/DataBindings/DataBindingModifierType.cs
View File
File renamed without changes.
src/Artemis.Core/Models/Profile/DataBindings/Modifiers/DivideModifierType.cs
-28
View File
@@ -1,28 +0,0 @@
using System;
using System.Collections.Generic;
namespace Artemis.Core
{
internal class DivideModifierType : DataBindingModifierType
{
public DivideModifierType()
{
PreferredParameterType = typeof(float);
}
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/FloorModifierType.cs
-24
View File
@@ -1,24 +0,0 @@
using System;
using System.Collections.Generic;
namespace Artemis.Core
{
internal class FloorModifierType : DataBindingModifierType
{
public FloorModifierType()
{
SupportsParameter = false;
}
public override IReadOnlyCollection<Type> CompatibleTypes => Constants.NumberTypes;
public override string Description => "Floor";
public override string Icon => "ArrowDownDropCircleOutline";
public override object Apply(object currentValue, object parameterValue)
{
var floatValue = Convert.ToSingle(currentValue);
return Math.Floor(floatValue);
}
}
}
src/Artemis.Core/Models/Profile/DataBindings/Modifiers/MultiplicationModifier.cs
-23
View File
@@ -1,23 +0,0 @@
using System;
using System.Collections.Generic;
namespace Artemis.Core
{
internal class MultiplicationModifierType : DataBindingModifierType
{
public MultiplicationModifierType()
{
PreferredParameterType = typeof(float);
}
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/DataBindings/Modifiers/PercentageOfModifierType.cs
-28
View File
@@ -1,28 +0,0 @@
using System;
using System.Collections.Generic;
namespace Artemis.Core
{
internal class PercentageOfModifierType : DataBindingModifierType
{
public PercentageOfModifierType()
{
PreferredParameterType = typeof(float);
}
public override IReadOnlyCollection<Type> CompatibleTypes => Constants.NumberTypes;
public override string Description => "Percentage of";
public override string Icon => "Percent";
public override object Apply(object currentValue, object parameterValue)
{
var parameter = Convert.ToSingle(parameterValue);
// Ye ye none of that
if (parameter == 0f)
return 100f;
return 100f / Convert.ToSingle(parameterValue) * Convert.ToSingle(currentValue);
}
}
}
src/Artemis.Core/Models/Profile/LayerGeneralProperties.cs
+2 -1
View File
@@ -1,4 +1,5 @@
using SkiaSharp;
using Artemis.Core.DefaultTypes;
using SkiaSharp;
namespace Artemis.Core
{
src/Artemis.Core/Models/Profile/LayerProperties/Types/ColorGradientLayerProperty.cs
-35
View File
@@ -1,35 +0,0 @@
namespace Artemis.Core
{
/// <inheritdoc />
public class ColorGradientLayerProperty : LayerProperty<ColorGradient>
{
internal ColorGradientLayerProperty()
{
KeyframesSupported = false;
DataBindingsSupported = false;
BaseValueChanged += OnBaseValueChanged;
}
/// <summary>
/// Implicitly converts an <see cref="ColorGradientLayerProperty" /> to a <see cref="ColorGradient" />
/// </summary>
public static implicit operator ColorGradient(ColorGradientLayerProperty p)
{
return p.CurrentValue;
}
/// <inheritdoc />
protected override void UpdateCurrentValue(float keyframeProgress, float keyframeProgressEased)
{
throw new ArtemisCoreException("Color Gradients do not support keyframes.");
}
private void OnBaseValueChanged(object sender, LayerPropertyEventArgs<ColorGradient> e)
{
// Don't allow color gradients to be null
if (BaseValue == null)
BaseValue = DefaultValue ?? new ColorGradient();
}
}
}
src/Artemis.Core/Models/Profile/LayerProperties/Types/EnumLayerProperty.cs
-36
View File
@@ -1,36 +0,0 @@
using System;
namespace Artemis.Core
{
/// <inheritdoc />
public class EnumLayerProperty<T> : LayerProperty<T> where T : Enum
{
internal EnumLayerProperty()
{
KeyframesSupported = false;
DataBindingsSupported = false;
}
/// <summary>
/// Implicitly converts an <see cref="EnumLayerProperty{T}" /> to a <typeparamref name="T"/>
/// </summary>
public static implicit operator T(EnumLayerProperty<T> p)
{
return p.CurrentValue;
}
/// <summary>
/// Implicitly converts an <see cref="EnumLayerProperty{T}" /> to an <see cref="int" />
/// </summary>
public static implicit operator int(EnumLayerProperty<T> p)
{
return Convert.ToInt32(p.CurrentValue);
}
/// <inheritdoc />
protected override void UpdateCurrentValue(float keyframeProgress, float keyframeProgressEased)
{
throw new ArtemisCoreException("Enum properties do not support keyframes.");
}
}
}
src/Artemis.Core/Models/Profile/LayerProperties/Types/FloatLayerProperty.cs
-34
View File
@@ -1,34 +0,0 @@
namespace Artemis.Core
{
/// <inheritdoc />
public class FloatLayerProperty : LayerProperty<float>
{
internal FloatLayerProperty()
{
RegisterDataBindingProperty(value => value, new FloatDataBindingConverter());
}
/// <summary>
/// Implicitly converts an <see cref="FloatLayerProperty" /> to a <see cref="float" />
/// </summary>
public static implicit operator float(FloatLayerProperty p)
{
return p.CurrentValue;
}
/// <summary>
/// Implicitly converts an <see cref="FloatLayerProperty" /> to a <see cref="double" />
/// </summary>
public static implicit operator double(FloatLayerProperty p)
{
return p.CurrentValue;
}
/// <inheritdoc />
protected override void UpdateCurrentValue(float keyframeProgress, float keyframeProgressEased)
{
var diff = NextKeyframe.Value - CurrentKeyframe.Value;
CurrentValue = CurrentKeyframe.Value + diff * keyframeProgressEased;
}
}
}
src/Artemis.Core/Models/Profile/LayerProperties/Types/IntLayerProperty.cs
-44
View File
@@ -1,44 +0,0 @@
using System;
namespace Artemis.Core
{
/// <inheritdoc />
public class IntLayerProperty : LayerProperty<int>
{
internal IntLayerProperty()
{
RegisterDataBindingProperty(value => value, new IntDataBindingConverter());
}
/// <summary>
/// Implicitly converts an <see cref="IntLayerProperty" /> to an <see cref="int" />
/// </summary>
public static implicit operator int(IntLayerProperty p)
{
return p.CurrentValue;
}
/// <summary>
/// Implicitly converts an <see cref="IntLayerProperty" /> to a <see cref="float" />
/// </summary>
public static implicit operator float(IntLayerProperty p)
{
return p.CurrentValue;
}
/// <summary>
/// Implicitly converts an <see cref="IntLayerProperty" /> to a <see cref="double" />
/// </summary>
public static implicit operator double(IntLayerProperty p)
{
return p.CurrentValue;
}
/// <inheritdoc />
protected override void UpdateCurrentValue(float keyframeProgress, float keyframeProgressEased)
{
var diff = NextKeyframe.Value - CurrentKeyframe.Value;
CurrentValue = (int) Math.Round(CurrentKeyframe.Value + diff * keyframeProgressEased, MidpointRounding.AwayFromZero);
}
}
}
src/Artemis.Core/Models/Profile/LayerProperties/Types/LayerBrushReferenceLayerProperty.cs
-28
View File
@@ -1,28 +0,0 @@
namespace Artemis.Core
{
/// <summary>
/// A special layer property used to configure the selected layer brush
/// </summary>
public class LayerBrushReferenceLayerProperty : LayerProperty<LayerBrushReference>
{
internal LayerBrushReferenceLayerProperty()
{
KeyframesSupported = false;
DataBindingsSupported = false;
}
/// <summary>
/// Implicitly converts an <see cref="LayerBrushReferenceLayerProperty" /> to an <see cref="LayerBrushReference" />
/// </summary>
public static implicit operator LayerBrushReference(LayerBrushReferenceLayerProperty p)
{
return p.CurrentValue;
}
/// <inheritdoc />
protected override void UpdateCurrentValue(float keyframeProgress, float keyframeProgressEased)
{
throw new ArtemisCoreException("Layer brush references do not support keyframes.");
}
}
}
src/Artemis.Core/Models/Profile/LayerProperties/Types/SKColorLayerProperty.cs
-29
View File
@@ -1,29 +0,0 @@
using SkiaSharp;
namespace Artemis.Core
{
/// <inheritdoc />
public class SKColorLayerProperty : LayerProperty<SKColor>
{
internal SKColorLayerProperty()
{
RegisterDataBindingProperty(value => value, new SKColorDataBindingConverter());
}
/// <summary>
/// Implicitly converts an <see cref="SKColorLayerProperty" /> to an <see cref="SKColor" />¶
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public static implicit operator SKColor(SKColorLayerProperty p)
{
return p.CurrentValue;
}
/// <inheritdoc />
protected override void UpdateCurrentValue(float keyframeProgress, float keyframeProgressEased)
{
CurrentValue = CurrentKeyframe.Value.Interpolate(NextKeyframe.Value, keyframeProgressEased);
}
}
}
src/Artemis.Core/Models/Profile/LayerProperties/Types/SKPointLayerProperty.cs
-30
View File
@@ -1,30 +0,0 @@
using SkiaSharp;
namespace Artemis.Core
{
/// <inheritdoc />
public class SKPointLayerProperty : LayerProperty<SKPoint>
{
internal SKPointLayerProperty()
{
RegisterDataBindingProperty(point => point.X, new FloatDataBindingConverter<SKPoint>());
RegisterDataBindingProperty(point => point.Y, new FloatDataBindingConverter<SKPoint>());
}
/// <summary>
/// Implicitly converts an <see cref="SKPointLayerProperty" /> to an <see cref="SKPoint" />
/// </summary>
public static implicit operator SKPoint(SKPointLayerProperty p)
{
return p.CurrentValue;
}
/// <inheritdoc />
protected override void UpdateCurrentValue(float keyframeProgress, float keyframeProgressEased)
{
var xDiff = NextKeyframe.Value.X - CurrentKeyframe.Value.X;
var yDiff = NextKeyframe.Value.Y - CurrentKeyframe.Value.Y;
CurrentValue = new SKPoint(CurrentKeyframe.Value.X + xDiff * keyframeProgressEased, CurrentKeyframe.Value.Y + yDiff * keyframeProgressEased);
}
}
}
src/Artemis.Core/Models/Profile/LayerProperties/Types/SKSizeLayerProperty.cs
-30
View File
@@ -1,30 +0,0 @@
using SkiaSharp;
namespace Artemis.Core
{
/// <inheritdoc />
public class SKSizeLayerProperty : LayerProperty<SKSize>
{
internal SKSizeLayerProperty()
{
RegisterDataBindingProperty(size => size.Height, new FloatDataBindingConverter<SKSize>());
RegisterDataBindingProperty(size => size.Width, new FloatDataBindingConverter<SKSize>());
}
/// <summary>
/// Implicitly converts an <see cref="SKSizeLayerProperty" /> to an <see cref="SKSize" />
/// </summary>
public static implicit operator SKSize(SKSizeLayerProperty p)
{
return p.CurrentValue;
}
/// <inheritdoc />
protected override void UpdateCurrentValue(float keyframeProgress, float keyframeProgressEased)
{
var widthDiff = NextKeyframe.Value.Width - CurrentKeyframe.Value.Width;
var heightDiff = NextKeyframe.Value.Height - CurrentKeyframe.Value.Height;
CurrentValue = new SKSize(CurrentKeyframe.Value.Width + widthDiff * keyframeProgressEased, CurrentKeyframe.Value.Height + heightDiff * keyframeProgressEased);
}
}
}
src/Artemis.Core/Models/Profile/LayerTransformProperties.cs
+2 -1
View File
@@ -1,4 +1,5 @@
using SkiaSharp;
using Artemis.Core.DefaultTypes;
using SkiaSharp;
namespace Artemis.Core
{