DarthAffe/Artemis
1
0
Fork 0
mirror of https://github.com/Artemis-RGB/Artemis synced 2025-12-13 05:48:35 +00:00
Code Issues Releases Wiki Activity

Refactored shape brushes to use the properties system

Browse Source
This commit is contained in:
Robert 2020-02-11 19:10:31 +01:00
parent 022e14e98d
commit 9b1d28840c
40 changed files with 650 additions and 686 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Artemis.Core/Artemis.Core.csproj
View File

@ -152,8 +152,10 @@
<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\SKColorKeyframeEngine.cs" />
<Compile Include="Models\Profile\KeyframeEngines\SKPointKeyframeEngine.cs" />
<Compile Include="Models\Profile\KeyframeEngines\SKSizeKeyframeEngine.cs" />
<Compile Include="Models\Profile\LayerBrushReference.cs" />
<Compile Include="Models\Profile\LayerProperties\BaseKeyframe.cs" />
<Compile Include="Models\Profile\LayerProperties\Keyframe.cs" />
<Compile Include="Models\Profile\LayerProperties\BaseLayerProperty.cs" />
@ -178,8 +180,6 @@
<Compile Include="Plugins\LayerBrush\LayerBrush.cs" />
<Compile Include="Plugins\LayerBrush\LayerBrushDescriptor.cs" />
<Compile Include="Plugins\LayerBrush\LayerBrushProvider.cs" />
<Compile Include="Plugins\LayerBrush\LayerBrushSettings.cs" />
<Compile Include="Plugins\LayerBrush\LayerBrushViewModel.cs" />
<Compile Include="Plugins\Models\PluginInfo.cs" />
<Compile Include="Plugins\Models\PluginSetting.cs" />
<Compile Include="Plugins\Models\PluginSettings.cs" />

2
src/Artemis.Core/Constants.cs
View File

@ -1,4 +1,5 @@
using System;
using Artemis.Core.Plugins.Models;
namespace Artemis.Core
{
@ -6,5 +7,6 @@ namespace Artemis.Core
{
public static readonly string DataFolder = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + "\\Artemis\\";
public static readonly string ConnectionString = $"FileName={DataFolder}\\database.db;Mode=Exclusive";
public static readonly PluginInfo CorePluginInfo = new PluginInfo {Guid = Guid.Parse("ffffffff-ffff-ffff-ffff-ffffffffffff"), Name = "Artemis Core"};
}
}

31
src/Artemis.Core/Models/Profile/KeyframeEngines/SKColorKeyframeEngine.cs Normal file
View File

@ -0,0 +1,31 @@
using System;
using System.Collections.Generic;
using Artemis.Core.Models.Profile.LayerProperties;
using SkiaSharp;
namespace Artemis.Core.Models.Profile.KeyframeEngines
{
/// <inheritdoc />
public class SKColorKeyframeEngine : KeyframeEngine
{
public sealed override List<Type> CompatibleTypes { get; } = new List<Type> {typeof(SKColor)};
protected override object GetInterpolatedValue()
{
var currentKeyframe = (Keyframe<SKColor>) CurrentKeyframe;
var nextKeyframe = (Keyframe<SKColor>) NextKeyframe;
var redDiff = nextKeyframe.Value.Red - currentKeyframe.Value.Red;
var greenDiff = nextKeyframe.Value.Green - currentKeyframe.Value.Green;
var blueDiff = nextKeyframe.Value.Blue - currentKeyframe.Value.Blue;
var alphaDiff = nextKeyframe.Value.Alpha - currentKeyframe.Value.Alpha;
return new SKColor(
(byte) (currentKeyframe.Value.Red + redDiff * KeyframeProgressEased),
(byte) (currentKeyframe.Value.Green + greenDiff * KeyframeProgressEased),
(byte) (currentKeyframe.Value.Blue + blueDiff * KeyframeProgressEased),
(byte)(currentKeyframe.Value.Alpha + alphaDiff * KeyframeProgressEased)
);
}
}
}

276
src/Artemis.Core/Models/Profile/Layer.cs
View File

@ -8,15 +8,18 @@ using Artemis.Core.Models.Profile.LayerProperties;
using Artemis.Core.Models.Profile.LayerShapes;
using Artemis.Core.Models.Surface;
using Artemis.Core.Plugins.LayerBrush;
using Artemis.Core.Plugins.Models;
using Artemis.Storage.Entities.Profile;
using Newtonsoft.Json;
using Ninject;
using Ninject.Parameters;
using SkiaSharp;
namespace Artemis.Core.Models.Profile
{
public sealed class Layer : ProfileElement
{
private readonly Dictionary<string, BaseLayerProperty> _properties;
private readonly Dictionary<(Guid, string), BaseLayerProperty> _properties;
private LayerShape _layerShape;
private List<ArtemisLed> _leds;
private SKPath _path;
@ -31,12 +34,12 @@ namespace Artemis.Core.Models.Profile
Name = name;
_leds = new List<ArtemisLed>();
_properties = new Dictionary<string, BaseLayerProperty>();
_properties = new Dictionary<(Guid, string), BaseLayerProperty>();
CreateDefaultProperties();
CreateShapeType();
ApplyShapeType();
ShapeTypeProperty.ValueChanged += (sender, args) => CreateShapeType();
ShapeTypeProperty.ValueChanged += (sender, args) => ApplyShapeType();
}
internal Layer(Profile profile, ProfileElement parent, LayerEntity layerEntity)
@ -50,27 +53,12 @@ namespace Artemis.Core.Models.Profile
Order = layerEntity.Order;
_leds = new List<ArtemisLed>();
_properties = new Dictionary<string, BaseLayerProperty>();
_properties = new Dictionary<(Guid, string), BaseLayerProperty>();
CreateDefaultProperties();
CreateShapeType();
ApplyShapeType();
ShapeTypeProperty.ValueChanged += (sender, args) => CreateShapeType();
}
private void CreateShapeType()
{
switch (ShapeTypeProperty.CurrentValue)
{
case LayerShapeType.Ellipse:
LayerShape = new Ellipse(this);
break;
case LayerShapeType.Rectangle:
LayerShape = new Rectangle(this);
break;
default:
throw new ArgumentOutOfRangeException();
}
ShapeTypeProperty.ValueChanged += (sender, args) => ApplyShapeType();
}
internal LayerEntity LayerEntity { get; set; }
@ -126,6 +114,8 @@ namespace Artemis.Core.Models.Profile
public LayerProperty<SKBlendMode> BlendModeProperty { get; set; }
public LayerProperty<LayerBrushReference> BrushReferenceProperty { get; set; }
/// <summary>
/// The anchor point property of this layer, also found in <see cref="Properties" />
/// </summary>
@ -156,6 +146,39 @@ namespace Artemis.Core.Models.Profile
/// </summary>
public LayerBrush LayerBrush { get; internal set; }
#region Storage
internal override void ApplyToEntity()
{
// Properties
LayerEntity.Id = EntityId;
LayerEntity.ParentId = Parent?.EntityId ?? new Guid();
LayerEntity.Order = Order;
LayerEntity.Name = Name;
LayerEntity.ProfileId = Profile.EntityId;
foreach (var layerProperty in Properties)
layerProperty.ApplyToEntity();
// LEDs
LayerEntity.Leds.Clear();
foreach (var artemisLed in Leds)
{
var ledEntity = new LedEntity
{
DeviceHash = artemisLed.Device.RgbDevice.GetDeviceHashCode(),
LedName = artemisLed.RgbLed.Id.ToString()
};
LayerEntity.Leds.Add(ledEntity);
}
// Conditions TODO
LayerEntity.Condition.Clear();
}
#endregion
#region Rendering
public override void Update(double deltaTime)
{
foreach (var property in Properties)
@ -276,6 +299,29 @@ namespace Artemis.Core.Models.Profile
LayerBrush?.Render(canvas, LayerShape.Path, paint);
}
internal void CalculateRenderProperties()
{
if (!Leds.Any())
{
Path = new SKPath();
LayerShape?.CalculateRenderProperties();
OnRenderPropertiesUpdated();
return;
}
var path = new SKPath {FillType = SKPathFillType.Winding};
foreach (var artemisLed in Leds)
path.AddRect(artemisLed.AbsoluteRenderRectangle);
Path = path;
// This is called here so that the shape's render properties are up to date when other code
// responds to OnRenderPropertiesUpdated
LayerShape?.CalculateRenderProperties();
OnRenderPropertiesUpdated();
}
private SKPoint GetLayerAnchorPosition()
{
var positionProperty = PositionProperty.CurrentValue;
@ -290,43 +336,9 @@ namespace Artemis.Core.Models.Profile
return position;
}
internal override void ApplyToEntity()
{
// Properties
LayerEntity.Id = EntityId;
LayerEntity.ParentId = Parent?.EntityId ?? new Guid();
LayerEntity.Order = Order;
LayerEntity.Name = Name;
LayerEntity.ProfileId = Profile.EntityId;
foreach (var layerProperty in Properties)
layerProperty.ApplyToEntity();
#endregion
// LEDs
LayerEntity.Leds.Clear();
foreach (var artemisLed in Leds)
{
var ledEntity = new LedEntity
{
DeviceHash = artemisLed.Device.RgbDevice.GetDeviceHashCode(),
LedName = artemisLed.RgbLed.Id.ToString()
};
LayerEntity.Leds.Add(ledEntity);
}
// Conditions TODO
LayerEntity.Condition.Clear();
// Brush
if (LayerBrush != null)
{
LayerEntity.BrushEntity = new BrushEntity
{
BrushPluginGuid = LayerBrush.Descriptor.LayerBrushProvider.PluginInfo.Guid,
BrushType = LayerBrush.GetType().Name,
Configuration = JsonConvert.SerializeObject(LayerBrush.Settings)
};
}
}
#region LED management
/// <summary>
/// Adds a new <see cref="ArtemisLed" /> to the layer and updates the render properties.
@ -385,47 +397,39 @@ namespace Artemis.Core.Models.Profile
CalculateRenderProperties();
}
internal void CalculateRenderProperties()
#endregion
#region Shape management
private void ApplyShapeType()
{
if (!Leds.Any())
switch (ShapeTypeProperty.CurrentValue)
{
Path = new SKPath();
LayerShape?.CalculateRenderProperties();
OnRenderPropertiesUpdated();
return;
case LayerShapeType.Ellipse:
LayerShape = new Ellipse(this);
break;
case LayerShapeType.Rectangle:
LayerShape = new Rectangle(this);
break;
default:
throw new ArgumentOutOfRangeException();
}
var path = new SKPath {FillType = SKPathFillType.Winding};
foreach (var artemisLed in Leds)
path.AddRect(artemisLed.AbsoluteRenderRectangle);
Path = path;
// This is called here so that the shape's render properties are up to date when other code
// responds to OnRenderPropertiesUpdated
LayerShape?.CalculateRenderProperties();
OnRenderPropertiesUpdated();
}
public override string ToString()
{
return $"[Layer] {nameof(Name)}: {Name}, {nameof(Order)}: {Order}";
}
#endregion
#region Properties
/// <summary>
/// Adds the provided layer property to the layer.
/// Adds the provided layer property and its children to the layer.
/// If found, the last stored base value and keyframes will be applied to the provided property.
/// </summary>
/// <typeparam name="T">The type of value of the layer property</typeparam>
/// <param name="layerProperty">The property to apply to the layer</param>
/// <returns>True if an existing value was found and applied, otherwise false.</returns>
public bool AddLayerProperty<T>(LayerProperty<T> layerProperty)
public bool RegisterLayerProperty<T>(LayerProperty<T> layerProperty)
{
return AddLayerProperty((BaseLayerProperty) layerProperty);
return RegisterLayerProperty((BaseLayerProperty) layerProperty);
}
/// <summary>
@ -434,9 +438,9 @@ namespace Artemis.Core.Models.Profile
/// </summary>
/// <param name="layerProperty">The property to apply to the layer</param>
/// <returns>True if an existing value was found and applied, otherwise false.</returns>
public bool AddLayerProperty(BaseLayerProperty layerProperty)
public bool RegisterLayerProperty(BaseLayerProperty layerProperty)
{
if (_properties.ContainsKey(layerProperty.Id))
if (_properties.ContainsKey((layerProperty.PluginInfo.Guid, layerProperty.Id)))
throw new ArtemisCoreException($"Duplicate property ID detected. Layer already contains a property with ID {layerProperty.Id}.");
var propertyEntity = LayerEntity.PropertyEntities.FirstOrDefault(p => p.Id == layerProperty.Id && p.ValueType == layerProperty.Type.Name);
@ -444,66 +448,91 @@ namespace Artemis.Core.Models.Profile
if (propertyEntity != null)
layerProperty.ApplyToProperty(propertyEntity);
_properties.Add(layerProperty.Id, layerProperty);
_properties.Add((layerProperty.PluginInfo.Guid, layerProperty.Id), layerProperty);
OnLayerPropertyRegistered();
return propertyEntity != null;
}
/// <summary>
/// Removes the provided layer property from the layer.
/// </summary>
/// <typeparam name="T">The type of value of the layer property</typeparam>
/// <param name="layerProperty">The property to remove from the layer</param>
public void RemoveLayerProperty<T>(LayerProperty<T> layerProperty)
{
RemoveLayerProperty((BaseLayerProperty) layerProperty);
}
/// <summary>
/// Removes the provided layer property from the layer.
/// </summary>
/// <param name="layerProperty">The property to remove from the layer</param>
public void RemoveLayerProperty(BaseLayerProperty layerProperty)
{
if (!_properties.ContainsKey((layerProperty.PluginInfo.Guid, layerProperty.Id)))
throw new ArtemisCoreException($"Could not find a property with ID {layerProperty.Id}.");
var property = _properties[(layerProperty.PluginInfo.Guid, layerProperty.Id)];
property.Parent?.Children.Remove(property);
_properties.Remove((layerProperty.PluginInfo.Guid, layerProperty.Id));
OnLayerPropertyRemoved();
}
/// <summary>
/// If found, returns the <see cref="LayerProperty{T}" /> matching the provided ID
/// </summary>
/// <typeparam name="T">The type of the layer property</typeparam>
/// <param name="pluginInfo">The plugin this property belongs to</param>
/// <param name="id"></param>
/// <returns></returns>
public LayerProperty<T> GetLayerPropertyById<T>(string id)
public LayerProperty<T> GetLayerPropertyById<T>(PluginInfo pluginInfo, string id)
{
if (!_properties.ContainsKey(id))
if (!_properties.ContainsKey((pluginInfo.Guid, id)))
return null;
var property = _properties[id];
var property = _properties[(pluginInfo.Guid, id)];
if (property.Type != typeof(T))
throw new ArtemisCoreException($"Property type mismatch. Expected property {property} to have type {typeof(T)} but it has {property.Type} instead.");
return (LayerProperty<T>) _properties[id];
return (LayerProperty<T>) _properties[(pluginInfo.Guid, id)];
}
private void CreateDefaultProperties()
{
var shape = new LayerProperty<object>(this, null, "Core.Shape", "Shape", "A collection of basic shape properties.");
// Shape
var shape = new LayerProperty<object>(this, "Core.Shape", "Shape", "A collection of basic shape properties.");
ShapeTypeProperty = new LayerProperty<LayerShapeType>(this, shape, "Core.ShapeType", "Shape type", "The type of shape to draw in this layer.") {CanUseKeyframes = false};
FillTypeProperty = new LayerProperty<LayerFillType>(this, shape, "Core.FillType", "Fill type", "How to make the shape adjust to scale changes.") {CanUseKeyframes = false};
BlendModeProperty = new LayerProperty<SKBlendMode>(this, shape, "Core.BlendMode", "Blend mode", "How to blend this layer into the resulting image.") {CanUseKeyframes = false};
shape.Children.Add(ShapeTypeProperty);
shape.Children.Add(FillTypeProperty);
shape.Children.Add(BlendModeProperty);
ShapeTypeProperty.Value = LayerShapeType.Rectangle;
FillTypeProperty.Value = LayerFillType.Stretch;
BlendModeProperty.Value = SKBlendMode.SrcOver;
var transform = new LayerProperty<object>(this, null, "Core.Transform", "Transform", "A collection of transformation properties.") {ExpandByDefault = true};
RegisterLayerProperty(shape);
foreach (var shapeProperty in shape.Children)
RegisterLayerProperty(shapeProperty);
// Brush
var brush = new LayerProperty<object>(this, "Core.Brush", "Brush", "A collection of properties that configure the selected brush.");
BrushReferenceProperty = new LayerProperty<LayerBrushReference>(this, brush, "Core.BrushReference", "Brush type", "The type of brush to use for this layer.") {CanUseKeyframes = false};
RegisterLayerProperty(brush);
foreach (var brushProperty in brush.Children)
RegisterLayerProperty(brushProperty);
// Transform
var transform = new LayerProperty<object>(this, "Core.Transform", "Transform", "A collection of transformation properties.") {ExpandByDefault = true};
AnchorPointProperty = new LayerProperty<SKPoint>(this, transform, "Core.AnchorPoint", "Anchor Point", "The point at which the shape is attached to its position.");
PositionProperty = new LayerProperty<SKPoint>(this, transform, "Core.Position", "Position", "The position of the shape.");
ScaleProperty = new LayerProperty<SKSize>(this, transform, "Core.Scale", "Scale", "The scale of the shape.") {InputAffix = "%"};
RotationProperty = new LayerProperty<float>(this, transform, "Core.Rotation", "Rotation", "The rotation of the shape in degrees.") {InputAffix = "°"};
OpacityProperty = new LayerProperty<float>(this, transform, "Core.Opacity", "Opacity", "The opacity of the shape.") {InputAffix = "%"};
transform.Children.Add(AnchorPointProperty);
transform.Children.Add(PositionProperty);
transform.Children.Add(ScaleProperty);
transform.Children.Add(RotationProperty);
// Set default values
ShapeTypeProperty.Value = LayerShapeType.Rectangle;
FillTypeProperty.Value = LayerFillType.Stretch;
BlendModeProperty.Value = SKBlendMode.SrcOver;
ScaleProperty.Value = new SKSize(100, 100);
OpacityProperty.Value = 100;
transform.Children.Add(OpacityProperty);
AddLayerProperty(shape);
foreach (var shapeProperty in shape.Children)
AddLayerProperty(shapeProperty);
AddLayerProperty(transform);
RegisterLayerProperty(transform);
foreach (var transformProperty in transform.Children)
AddLayerProperty(transformProperty);
RegisterLayerProperty(transformProperty);
}
#endregion
@ -512,6 +541,8 @@ namespace Artemis.Core.Models.Profile
public event EventHandler RenderPropertiesUpdated;
public event EventHandler ShapePropertiesUpdated;
public event EventHandler LayerPropertyRegistered;
public event EventHandler LayerPropertyRemoved;
private void OnRenderPropertiesUpdated()
{
@ -524,6 +555,21 @@ namespace Artemis.Core.Models.Profile
}
#endregion
public override string ToString()
{
return $"[Layer] {nameof(Name)}: {Name}, {nameof(Order)}: {Order}";
}
private void OnLayerPropertyRegistered()
{
LayerPropertyRegistered?.Invoke(this, EventArgs.Empty);
}
private void OnLayerPropertyRemoved()
{
LayerPropertyRemoved?.Invoke(this, EventArgs.Empty);
}
}
public enum LayerShapeType

21
src/Artemis.Core/Models/Profile/LayerBrushReference.cs Normal file
View File

@ -0,0 +1,21 @@
using System;
using Artemis.Core.Plugins.LayerBrush;
namespace Artemis.Core.Models.Profile
{
/// <summary>
/// A reference to a <see cref="LayerBrushDescriptor" />
/// </summary>
public class LayerBrushReference
{
/// <summary>
/// The GUID of the plugin the brush descriptor resides in
/// </summary>
public Guid BrushPluginGuid { get; set; }
/// <summary>
/// The full type name of the brush descriptor
/// </summary>
public string BrushType { get; set; }
}
}

15
src/Artemis.Core/Models/Profile/LayerProperties/BaseLayerProperty.cs
View File

@ -3,6 +3,7 @@ using System.Collections.Generic;
using System.Linq;
using Artemis.Core.Exceptions;
using Artemis.Core.Models.Profile.KeyframeEngines;
using Artemis.Core.Plugins.Models;
using Artemis.Core.Utilities;
using Artemis.Storage.Entities.Profile;
using Newtonsoft.Json;
@ -13,9 +14,10 @@ namespace Artemis.Core.Models.Profile.LayerProperties
{
private object _baseValue;
protected BaseLayerProperty(Layer layer, BaseLayerProperty parent, string id, string name, string description, Type type)
protected BaseLayerProperty(Layer layer, PluginInfo pluginInfo, BaseLayerProperty parent, string id, string name, string description, Type type)
{
Layer = layer;
PluginInfo = pluginInfo;
Parent = parent;
Id = id;
Name = name;
@ -23,8 +25,14 @@ namespace Artemis.Core.Models.Profile.LayerProperties
Type = type;
CanUseKeyframes = true;
// This can only be null if accessed internally
if (PluginInfo == null)
PluginInfo = Constants.CorePluginInfo;
Children = new List<BaseLayerProperty>();
BaseKeyframes = new List<BaseKeyframe>();
parent?.Children.Add(this);
}
/// <summary>
@ -32,6 +40,11 @@ namespace Artemis.Core.Models.Profile.LayerProperties
/// </summary>
public Layer Layer { get; }
/// <summary>
/// Info of the plugin associated with this property
/// </summary>
public PluginInfo PluginInfo { get; }
/// <summary>
/// Gets the parent property of this property.
/// </summary>

63
src/Artemis.Core/Models/Profile/LayerProperties/LayerProperty.cs
View File

@ -1,14 +1,73 @@
using System.Collections.ObjectModel;
using System;
using System.Collections.ObjectModel;
using System.Linq;
using Artemis.Core.Plugins.Models;
namespace Artemis.Core.Models.Profile.LayerProperties
{
/// <summary>
/// Represents a property on the layer. This property is visible in the profile editor and can be key-framed (unless
/// opted out)
/// </summary>
/// <typeparam name="T"></typeparam>
public class LayerProperty<T> : BaseLayerProperty
{
public LayerProperty(Layer layer, BaseLayerProperty parent, string id, string name, string description) : base(layer, parent, id, name, description, typeof(T))
internal LayerProperty(Layer layer, BaseLayerProperty parent, string id, string name, string description) : base(layer, null, parent, id, name, description, typeof(T))
{
}
internal LayerProperty(Layer layer, string id, string name, string description) : base(layer, null, null, id, name, description, typeof(T))
{
}
/// <summary>
/// Represents a property on the layer. This property is visible in the profile editor and can be key-framed (unless
/// opted out)
/// <para>
/// Note: The value and keyframes of the property are stored using the ID, after adding the property to the layer
/// these are restored.
/// </para>
/// </summary>
/// <param name="layer">The layer the property is applied to</param>
/// <param name="pluginInfo">The plugin to create this property for</param>
/// <param name="parent">The parent of this property, use this to create a tree-hierarchy in the editor</param>
/// <param name="id">A and ID identifying your property, must be unique within your plugin</param>
/// <param name="name">A name for your property, this is visible in the editor</param>
/// <param name="description">A description for your property, this is visible in the editor</param>
public LayerProperty(Layer layer, PluginInfo pluginInfo, BaseLayerProperty parent, string id, string name, string description) : base(layer, pluginInfo, parent, id, name, description,
typeof(T))
{
if (layer == null)
throw new ArgumentNullException(nameof(layer));
if (pluginInfo == null)
throw new ArgumentNullException(nameof(pluginInfo));
if (id == null)
throw new ArgumentNullException(nameof(id));
}
/// <summary>
/// Represents a property on the layer. This property is visible in the profile editor and can be key-framed (unless
/// opted out)
/// <para>
/// Note: The value and keyframes of the property are stored using the ID, after adding the property to the layer
/// these are restored.
/// </para>
/// </summary>
/// <param name="layer">The layer the property is applied to</param>
/// <param name="pluginInfo">The plugin to create this property for</param>
/// <param name="id">A and ID identifying your property, must be unique within your plugin</param>
/// <param name="name">A name for your property, this is visible in the editor</param>
/// <param name="description">A description for your property, this is visible in the editor</param>
public LayerProperty(Layer layer, PluginInfo pluginInfo, string id, string name, string description) : base(layer, pluginInfo, null, id, name, description, typeof(T))
{
if (layer == null)
throw new ArgumentNullException(nameof(layer));
if (pluginInfo == null)
throw new ArgumentNullException(nameof(pluginInfo));
if (id == null)
throw new ArgumentNullException(nameof(id));
}
/// <summary>
/// Gets or sets the value of the property without any keyframes applied
/// </summary>

44
src/Artemis.Core/Plugins/LayerBrush/LayerBrush.cs
View File

@ -1,32 +1,25 @@
using System;
using Artemis.Core.Models.Profile;
using Artemis.Core.Models.Profile.LayerProperties;
using SkiaSharp;
namespace Artemis.Core.Plugins.LayerBrush
{
public abstract class LayerBrush : IDisposable
{
protected LayerBrush(Layer layer, LayerBrushSettings settings, LayerBrushDescriptor descriptor)
protected LayerBrush(Layer layer, LayerBrushDescriptor descriptor)
{
Layer = layer;
Settings = settings;
Descriptor = descriptor;
}
public Layer Layer { get; }
public LayerBrushSettings Settings { get; }
public LayerBrushDescriptor Descriptor { get; }
public virtual void Dispose()
{
}
/// <summary>
/// Called by the profile editor to populate the brush properties panel
/// </summary>
/// <returns></returns>
public abstract LayerBrushViewModel GetViewModel();
/// <summary>
/// Called before rendering every frame, write your update logic here
/// </summary>
@ -46,5 +39,38 @@ namespace Artemis.Core.Plugins.LayerBrush
public virtual void Render(SKCanvas canvas, SKPath path, SKPaint paint)
{
}
/// <summary>
/// Provides an easy way to add your own properties to the layer, for more info see <see cref="LayerProperty{T}" />.
/// <para>Note: If found, the last value and keyframes are loaded and set when calling this method.</para>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="parent">The parent of this property, use this to create a tree-hierarchy in the editor</param>
/// <param name="id">A and ID identifying your property, must be unique within your plugin</param>
/// <param name="name">A name for your property, this is visible in the editor</param>
/// <param name="description">A description for your property, this is visible in the editor</param>
/// <returns>The layer property</returns>
protected LayerProperty<T> RegisterLayerProperty<T>(BaseLayerProperty parent, string id, string name, string description)
{
var property = new LayerProperty<T>(Layer, Descriptor.LayerBrushProvider.PluginInfo, parent, id, name, description);
Layer.RegisterLayerProperty(property);
return property;
}
/// <summary>
/// Provides an easy way to add your own properties to the layer, for more info see <see cref="LayerProperty{T}" />.
/// <para>Note: If found, the last value and keyframes are loaded and set when calling this method.</para>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="id">A and ID identifying your property, must be unique within your plugin</param>
/// <param name="name">A name for your property, this is visible in the editor</param>
/// <param name="description">A description for your property, this is visible in the editor</param>
/// <returns>The layer property</returns>
protected LayerProperty<T> RegisterLayerProperty<T>(string id, string name, string description)
{
var property = new LayerProperty<T>(Layer, Descriptor.LayerBrushProvider.PluginInfo, Layer.BrushReferenceProperty.Parent, id, name, description);
Layer.RegisterLayerProperty(property);
return property;
}
}
}

18
src/Artemis.Core/Plugins/LayerBrush/LayerBrushSettings.cs
View File

@ -1,18 +0,0 @@
using System;
using System.Xml.Serialization;
using Newtonsoft.Json;
using Stylet;
namespace Artemis.Core.Plugins.LayerBrush
{
public abstract class LayerBrushSettings : PropertyChangedBase
{
/// <summary>
/// Gets or sets the dispatcher to use to dispatch PropertyChanged events. Defaults to
/// Execute.DefaultPropertyChangedDispatcher
/// </summary>
[XmlIgnore]
[JsonIgnore]
public override Action<Action> PropertyChangedDispatcher { get; set; } = Execute.DefaultPropertyChangedDispatcher;
}
}

14
src/Artemis.Core/Plugins/LayerBrush/LayerBrushViewModel.cs
View File

@ -1,14 +0,0 @@
using Stylet;
namespace Artemis.Core.Plugins.LayerBrush
{
public abstract class LayerBrushViewModel : PropertyChangedBase
{
protected LayerBrushViewModel(LayerBrush brush)
{
Brush = brush;
}
public LayerBrush Brush { get; }
}
}

5
src/Artemis.Core/RGB.NET/BitmapBrush.cs
View File

@ -75,14 +75,9 @@ namespace Artemis.Core.RGB.NET
{
foreach (var renderTarget in renderTargets)
{
if (renderTarget.Led.Id == LedId.Keyboard_W)
Console.WriteLine();
var scaledLocation = renderTarget.Point * Scale;
if (scaledLocation.X < Bitmap.Width && scaledLocation.Y < Bitmap.Height)
{
var test = Bitmap.GetPixel(scaledLocation.X.RoundToInt(), scaledLocation.Y.RoundToInt());
RenderedTargets[renderTarget] = Bitmap.GetPixel(scaledLocation.X.RoundToInt(), scaledLocation.Y.RoundToInt()).ToRgbColor();
}
}
}

4
src/Artemis.Core/Services/Interfaces/ILayerService.cs
View File

@ -12,10 +12,8 @@ namespace Artemis.Core.Services.Interfaces
/// <see cref="LayerBrushDescriptor" /> to the provided <see cref="Layer" />.
/// </summary>
/// <param name="layer">The layer to add the new layer element to</param>
/// <param name="brushDescriptor">The descriptor of the new layer brush</param>
/// <param name="settings">JSON settings to be deserialized and injected into the layer brush</param>
/// <returns></returns>
LayerBrush InstantiateLayerBrush(Layer layer, LayerBrushDescriptor brushDescriptor, string settings = null);
LayerBrush InstantiateLayerBrush(Layer layer);
/// <summary>
/// Instantiates and adds a compatible <see cref="KeyframeEngine" /> to the provided <see cref="LayerProperty{T}" />

67
src/Artemis.Core/Services/LayerService.cs
View File

@ -1,13 +1,10 @@
using System;
using System.Collections.Generic;
using System.Collections.Generic;
using System.Linq;
using Artemis.Core.Models.Profile;
using Artemis.Core.Models.Profile.KeyframeEngines;
using Artemis.Core.Models.Profile.LayerProperties;
using Artemis.Core.Plugins.Exceptions;
using Artemis.Core.Plugins.LayerBrush;
using Artemis.Core.Services.Interfaces;
using Newtonsoft.Json;
using Ninject;
using Ninject.Parameters;
using Serilog;
@ -18,57 +15,38 @@ namespace Artemis.Core.Services
{
private readonly IKernel _kernel;
private readonly ILogger _logger;
private readonly IPluginService _pluginService;
public LayerService(IKernel kernel, ILogger logger)
public LayerService(IKernel kernel, ILogger logger, IPluginService pluginService)
{
_kernel = kernel;
_logger = logger;
_pluginService = pluginService;
}
public LayerBrush InstantiateLayerBrush(Layer layer, LayerBrushDescriptor brushDescriptor, string settings)
public LayerBrush InstantiateLayerBrush(Layer layer)
{
// Determine the settings type declared by the layer element
object settingsInstance = null;
var properties = brushDescriptor.LayerBrushType.GetProperties();
var settingsType = properties.FirstOrDefault(p => p.Name == "Settings" &&
p.DeclaringType == brushDescriptor.LayerBrushType)?.PropertyType;
RemoveLayerBrush(layer);
// Deserialize the settings if provided, check for null in JSON as well
if (settings != null && settings != "null")
{
// Setting where provided but no settings type was found, something is wrong
if (settingsType == null)
{
throw new ArtemisPluginException(
brushDescriptor.LayerBrushProvider.PluginInfo,
$"Settings where provided but layer element of type {brushDescriptor.LayerBrushType.Name} has no Settings property."
);
}
var descriptorReference = layer.BrushReferenceProperty.CurrentValue;
if (descriptorReference == null)
return null;
try
{
settingsInstance = JsonConvert.DeserializeObject(settings, settingsType);
}
catch (JsonSerializationException e)
{
_logger.Warning(e, "Failed to deserialize settings for layer type {type}, resetting element settings - Plugin info: {pluginInfo}",
brushDescriptor.LayerBrushType.Name,
brushDescriptor.LayerBrushProvider.PluginInfo);
// Get a matching descriptor
var layerBrushProviders = _pluginService.GetPluginsOfType<LayerBrushProvider>();
var descriptors = layerBrushProviders.SelectMany(l => l.LayerBrushDescriptors).ToList();
var descriptor = descriptors.FirstOrDefault(d => d.LayerBrushProvider.PluginInfo.Guid == descriptorReference.BrushPluginGuid &&
d.LayerBrushType.Name == descriptorReference.BrushType);
settingsInstance = Activator.CreateInstance(settingsType);
}
}
// If no settings found, provide a fresh instance of the settings type
else if (settingsType != null)
settingsInstance = Activator.CreateInstance(settingsType);
if (descriptor == null)
return null;
var arguments = new IParameter[]
{
new ConstructorArgument("layer", layer),
new ConstructorArgument("settings", settingsInstance),
new ConstructorArgument("descriptor", brushDescriptor)
new ConstructorArgument("descriptor", descriptor)
};
var layerElement = (LayerBrush) _kernel.Get(brushDescriptor.LayerBrushType, arguments);
var layerElement = (LayerBrush) _kernel.Get(descriptor.LayerBrushType, arguments);
layer.LayerBrush = layerElement;
return layerElement;
@ -92,10 +70,17 @@ namespace Artemis.Core.Services
return keyframeEngine;
}
public void RemoveLayerBrush(Layer layer, LayerBrush layerElement)
public void RemoveLayerBrush(Layer layer)
{
if (layer.LayerBrush == null)
return;
var brush = layer.LayerBrush;
layer.LayerBrush = null;
var propertiesToRemove = layer.Properties.Where(l => l.PluginInfo == brush.Descriptor.LayerBrushProvider.PluginInfo).ToList();
foreach (var layerProperty in propertiesToRemove)
layer.RemoveLayerProperty(layerProperty);
brush.Dispose();
}
}

3
src/Artemis.Core/Services/SettingsService.cs
View File

@ -12,8 +12,7 @@ namespace Artemis.Core.Services
internal SettingsService(IPluginSettingRepository pluginSettingRepository)
{
var pluginInfo = new PluginInfo {Guid = Guid.Parse("ffffffff-ffff-ffff-ffff-ffffffffffff"), Name = "Artemis Core"};
_pluginSettings = new PluginSettings(pluginInfo, pluginSettingRepository);
_pluginSettings = new PluginSettings(Constants.CorePluginInfo, pluginSettingRepository);
}
public PluginSetting<T> GetSetting<T>(string name, T defaultValue = default)

15
src/Artemis.Core/Services/Storage/ProfileService.cs
View File

@ -148,20 +148,9 @@ namespace Artemis.Core.Services.Storage
private void InstantiateProfileLayerBrushes(Profile profile)
{
var layerBrushProviders = _pluginService.GetPluginsOfType<LayerBrushProvider>();
var descriptors = layerBrushProviders.SelectMany(l => l.LayerBrushDescriptors).ToList();
// Only instantiate brushes for layers without an existing brush instance
foreach (var layer in profile.GetAllLayers().Where(l => l.LayerBrush == null && l.LayerEntity.BrushEntity != null))
{
// Get a matching descriptor
var descriptor = descriptors.FirstOrDefault(d => d.LayerBrushProvider.PluginInfo.Guid == layer.LayerEntity.BrushEntity.BrushPluginGuid &&
d.LayerBrushType.Name == layer.LayerEntity.BrushEntity.BrushType);
// If a descriptor that matches if found, instantiate it with the GUID of the element entity
if (descriptor != null)
_layerService.InstantiateLayerBrush(layer, descriptor, layer.LayerEntity.BrushEntity.Configuration);
}
foreach (var layer in profile.GetAllLayers().Where(l => l.LayerBrush == null))
_layerService.InstantiateLayerBrush(layer);
}
private void InstantiateProfileKeyframeEngines(Profile profile)

8
src/Artemis.Plugins.LayerBrushes.Color/Artemis.Plugins.LayerBrushes.Color.csproj
View File

@ -90,8 +90,6 @@
<Reference Include="WindowsBase" />
</ItemGroup>
<ItemGroup>
<Compile Include="ColorBrushSettings.cs" />
<Compile Include="ColorBrushViewModel.cs" />
<Compile Include="ColorBrush.cs" />
<Compile Include="ColorBrushProvider.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
@ -114,12 +112,6 @@
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
</ItemGroup>
<ItemGroup>
<Page Include="ColorBrushView.xaml">
<SubType>Designer</SubType>
<Generator>MSBuild:Compile</Generator>
</Page>
</ItemGroup>
<ItemGroup />
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<PropertyGroup>

44
src/Artemis.Plugins.LayerBrushes.Color/ColorBrush.cs
View File

@ -1,7 +1,8 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.ComponentModel;
using Artemis.Core.Models.Profile;
using Artemis.Core.Models.Profile.LayerProperties;
using Artemis.Core.Plugins.LayerBrush;
using SkiaSharp;
@ -10,12 +11,15 @@ namespace Artemis.Plugins.LayerBrushes.Color
public class ColorBrush : LayerBrush
{
private readonly List<SKColor> _testColors;
private SKColor _color;
private SKPaint _paint;
private SKShader _shader;
public ColorBrush(Layer layer, ColorBrushSettings settings, LayerBrushDescriptor descriptor) : base(layer, settings, descriptor)
public ColorBrush(Layer layer, LayerBrushDescriptor descriptor) : base(layer, descriptor)
{
Settings = settings;
ColorProperty = RegisterLayerProperty<SKColor>("Brush.Color", "Main color", "The color of the brush.");
GradientTypeProperty = RegisterLayerProperty<GradientType>("Brush.GradientType", "Gradient type", "The scale of the noise.");
GradientTypeProperty.CanUseKeyframes = false;
_testColors = new List<SKColor>();
for (var i = 0; i < 9; i++)
@ -28,19 +32,19 @@ namespace Artemis.Plugins.LayerBrushes.Color
CreateShader();
Layer.RenderPropertiesUpdated += (sender, args) => CreateShader();
Settings.PropertyChanged += (sender, args) => CreateShader();
}
public new ColorBrushSettings Settings { get; }
public LayerProperty<SKColor> ColorProperty { get; set; }
public LayerProperty<GradientType> GradientTypeProperty { get; set; }
private void CreateShader()
{
var center = new SKPoint(Layer.Bounds.MidX, Layer.Bounds.MidY);
SKShader shader;
switch (Settings.GradientType)
switch (GradientTypeProperty.CurrentValue)
{
case GradientType.Solid:
shader = SKShader.CreateColor(_testColors.First());
shader = SKShader.CreateColor(_color);
break;
case GradientType.LinearGradient:
shader = SKShader.CreateLinearGradient(new SKPoint(0, 0), new SKPoint(Layer.Bounds.Width, 0), _testColors.ToArray(), SKShaderTileMode.Repeat);
@ -63,9 +67,16 @@ namespace Artemis.Plugins.LayerBrushes.Color
oldPaint?.Dispose();
}
public override LayerBrushViewModel GetViewModel()
public override void Update(double deltaTime)
{
return new ColorBrushViewModel(this);
// Only recreate the shader if the color changed
if (_color != ColorProperty.CurrentValue)
{
_color = ColorProperty.CurrentValue;
CreateShader();
}
base.Update(deltaTime);
}
public override void Render(SKCanvas canvas, SKPath path, SKPaint paint)
@ -74,4 +85,19 @@ namespace Artemis.Plugins.LayerBrushes.Color
canvas.DrawPath(path, paint);
}
}
public enum GradientType
{
[Description("Solid")]
Solid,
[Description("Linear Gradient")]
LinearGradient,
[Description("Radial Gradient")]
RadialGradient,
[Description("Sweep Gradient")]
SweepGradient
}
}

46
src/Artemis.Plugins.LayerBrushes.Color/ColorBrushSettings.cs
View File

@ -1,46 +0,0 @@
using System.Collections.Generic;
using System.ComponentModel;
using Artemis.Core.Plugins.LayerBrush;
using SkiaSharp;
namespace Artemis.Plugins.LayerBrushes.Color
{
public class ColorBrushSettings : LayerBrushSettings
{
private List<SKColor> _colors;
private GradientType _gradientType;
public ColorBrushSettings()
{
GradientType = GradientType.Solid;
Colors = new List<SKColor>();
}
public GradientType GradientType
{
get => _gradientType;
set => SetAndNotify(ref _gradientType, value);
}
public List<SKColor> Colors
{
get => _colors;
set => SetAndNotify(ref _colors, value);
}
}
public enum GradientType
{
[Description("Solid")]
Solid,
[Description("Linear Gradient")]
LinearGradient,
[Description("Radial Gradient")]
RadialGradient,
[Description("Sweep Gradient")]
SweepGradient
}
}

134
src/Artemis.Plugins.LayerBrushes.Color/ColorBrushView.xaml
View File

@ -1,134 +0,0 @@
<UserControl x:Class="Artemis.Plugins.LayerBrushes.Color.ColorBrushView"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:colorBrush="clr-namespace:Artemis.Plugins.LayerBrushes.Color"
mc:Ignorable="d"
d:DesignHeight="450" d:DesignWidth="800"
d:DataContext="{d:DesignInstance {x:Type colorBrush:ColorBrushViewModel}}">
<UserControl.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="pack://application:,,,/MaterialDesignThemes.Wpf;component/Themes/MaterialDesignTheme.Light.xaml" />
<ResourceDictionary Source="pack://application:,,,/MaterialDesignThemes.Wpf;component/Themes/MaterialDesignTheme.Defaults.xaml" />
<ResourceDictionary Source="pack://application:,,,/MaterialDesignColors;component/Themes/Recommended/Primary/MaterialDesignColor.Teal.xaml" />
<ResourceDictionary Source="pack://application:,,,/MaterialDesignColors;component/Themes/Recommended/Accent/MaterialDesignColor.Teal.xaml" />
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</UserControl.Resources>
<Grid Margin="12">
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
</Grid.RowDefinitions>
<!-- Brush type -->
<Grid Grid.Row="0">
<Grid.RowDefinitions>
<RowDefinition />
<RowDefinition />
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="Auto" />
</Grid.ColumnDefinitions>
<StackPanel Grid.Column="0" VerticalAlignment="Center">
<TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}">Brush type</TextBlock>
</StackPanel>
<StackPanel Grid.Row="0" Grid.Column="1" VerticalAlignment="Center">
<ComboBox HorizontalAlignment="Left"
ItemsSource="{Binding Path=BrushTypes}"
SelectedValuePath="Value"
DisplayMemberPath="Description"
SelectedValue="{Binding Path=ColorBrush.Settings.GradientType}" />
</StackPanel>
<Separator Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Style="{StaticResource MaterialDesignSeparator}" />
</Grid>
<!-- Sample 1 -->
<Grid Grid.Row="2">
<Grid.RowDefinitions>
<RowDefinition />
<RowDefinition />
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="Auto" />
</Grid.ColumnDefinitions>
<StackPanel Grid.Column="0">
<TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}">Setting title</TextBlock>
<TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}" Foreground="{DynamicResource MaterialDesignCheckBoxDisabled}">Setting subtitle</TextBlock>
</StackPanel>
<StackPanel Grid.Row="0" Grid.Column="1" VerticalAlignment="Center">
<ToggleButton Style="{StaticResource MaterialDesignSwitchToggleButton}" ToolTip="Default ToggleButton Style" />
</StackPanel>
<Separator Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Style="{StaticResource MaterialDesignSeparator}" />
</Grid>
<!-- Sample 1 -->
<Grid Grid.Row="3">
<Grid.RowDefinitions>
<RowDefinition />
<RowDefinition />
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="Auto" />
</Grid.ColumnDefinitions>
<StackPanel Grid.Column="0">
<TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}">Setting title</TextBlock>
<TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}" Foreground="{DynamicResource MaterialDesignCheckBoxDisabled}">Setting subtitle</TextBlock>
</StackPanel>
<StackPanel Grid.Row="0" Grid.Column="1" VerticalAlignment="Center">
<ToggleButton Style="{StaticResource MaterialDesignSwitchToggleButton}" ToolTip="Default ToggleButton Style" />
</StackPanel>
<Separator Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Style="{StaticResource MaterialDesignSeparator}" />
</Grid>
<!-- Setting 2 -->
<Grid Grid.Row="4">
<Grid.RowDefinitions>
<RowDefinition />
<RowDefinition />
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="Auto" />
</Grid.ColumnDefinitions>
<StackPanel Grid.Column="0">
<TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}">Setting title</TextBlock>
<TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}" Foreground="{DynamicResource MaterialDesignCheckBoxDisabled}">Setting subtitle</TextBlock>
</StackPanel>
<StackPanel Grid.Row="0" Grid.Column="1" VerticalAlignment="Center">
<ToggleButton Style="{StaticResource MaterialDesignSwitchToggleButton}" ToolTip="Default ToggleButton Style" />
</StackPanel>
<Separator Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Style="{StaticResource MaterialDesignSeparator}" />
</Grid>
<!-- Setting 2 -->
<Grid Grid.Row="5">
<Grid.RowDefinitions>
<RowDefinition />
<RowDefinition />
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="Auto" />
</Grid.ColumnDefinitions>
<StackPanel Grid.Column="0">
<TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}">Setting title</TextBlock>
<TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}" Foreground="{DynamicResource MaterialDesignCheckBoxDisabled}">Setting subtitle</TextBlock>
</StackPanel>
<StackPanel Grid.Row="0" Grid.Column="1" VerticalAlignment="Center">
<ToggleButton Style="{StaticResource MaterialDesignSwitchToggleButton}" ToolTip="Default ToggleButton Style" />
</StackPanel>
<Separator Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Style="{StaticResource MaterialDesignSeparator}" />
</Grid>
</Grid>
</UserControl>

17
src/Artemis.Plugins.LayerBrushes.Color/ColorBrushViewModel.cs
View File

@ -1,17 +0,0 @@
using System.Collections.Generic;
using Artemis.Core.Plugins.LayerBrush;
using Artemis.UI.Shared.Utilities;
namespace Artemis.Plugins.LayerBrushes.Color
{
public class ColorBrushViewModel : LayerBrushViewModel
{
public ColorBrushViewModel(ColorBrush element) : base(element)
{
ColorBrush = element;
}
public ColorBrush ColorBrush { get; }
public IEnumerable<ValueDescription> BrushTypes => EnumUtilities.GetAllValuesAndDescriptions(typeof(GradientType));
}
}

10
src/Artemis.Plugins.LayerBrushes.Noise/Artemis.Plugins.LayerBrushes.Noise.csproj
View File

@ -12,7 +12,7 @@
<TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<Deterministic>true</Deterministic>
<ShouldIncludeNativeSkiaSharp>false</ShouldIncludeNativeSkiaSharp>
<ShouldIncludeNativeSkiaSharp>false</ShouldIncludeNativeSkiaSharp>
<TargetFrameworkProfile />
<NuGetPackageImportStamp>
</NuGetPackageImportStamp>
@ -90,8 +90,6 @@
<Reference Include="WindowsBase" />
</ItemGroup>
<ItemGroup>
<Compile Include="NoiseBrushSettings.cs" />
<Compile Include="NoiseBrushViewModel.cs" />
<Compile Include="NoiseBrush.cs" />
<Compile Include="NoiseBrushProvider.cs" />
<Compile Include="Utilities\OpenSimplexNoise.cs" />
@ -115,12 +113,6 @@
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
</ItemGroup>
<ItemGroup>
<Page Include="NoiseBrushView.xaml">
<SubType>Designer</SubType>
<Generator>MSBuild:Compile</Generator>
</Page>
</ItemGroup>
<ItemGroup />
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<PropertyGroup>

31
src/Artemis.Plugins.LayerBrushes.Noise/NoiseBrush.cs
View File

@ -1,5 +1,6 @@
using System;
using Artemis.Core.Models.Profile;
using Artemis.Core.Models.Profile.LayerProperties;
using Artemis.Core.Plugins.LayerBrush;
using Artemis.Plugins.LayerBrushes.Noise.Utilities;
using SkiaSharp;
@ -13,20 +14,25 @@ namespace Artemis.Plugins.LayerBrushes.Noise
private readonly OpenSimplexNoise _noise;
private float _z;
public NoiseBrush(Layer layer, NoiseBrushSettings settings, LayerBrushDescriptor descriptor) : base(layer, settings, descriptor)
public NoiseBrush(Layer layer, LayerBrushDescriptor descriptor) : base(layer, descriptor)
{
Settings = settings;
MainColorProperty = RegisterLayerProperty<SKColor>("Brush.MainColor", "Main color", "The main color of the noise.");
ScaleProperty = RegisterLayerProperty<SKSize>("Brush.Scale", "Scale", "The scale of the noise.");
AnimationSpeedProperty = RegisterLayerProperty<float>("Brush.AnimationSpeed", "Animation speed", "The speed at which the noise moves.");
ScaleProperty.InputAffix = "%";
_z = Rand.Next(0, 4096);
_noise = new OpenSimplexNoise(Rand.Next(0, 4096));
}
public new NoiseBrushSettings Settings { get; }
public LayerProperty<SKColor> MainColorProperty { get; set; }
public LayerProperty<SKSize> ScaleProperty { get; set; }
public LayerProperty<float> AnimationSpeedProperty { get; set; }
public override void Update(double deltaTime)
{
// TODO: Come up with a better way to use deltaTime
_z += Settings.AnimationSpeed / 500f / 0.04f * (float) deltaTime;
_z += AnimationSpeedProperty.CurrentValue / 500f / 0.04f * (float) deltaTime;
if (_z >= float.MaxValue)
_z = 0;
@ -34,17 +40,15 @@ namespace Artemis.Plugins.LayerBrushes.Noise
base.Update(deltaTime);
}
public override LayerBrushViewModel GetViewModel()
{
return new NoiseBrushViewModel(this);
}
public override void Render(SKCanvas canvas, SKPath path, SKPaint paint)
{
var mainColor = MainColorProperty.CurrentValue;
var scale = ScaleProperty.CurrentValue;
// Scale down the render path to avoid computing a value for every pixel
var width = (int) (Math.Max(path.Bounds.Width, path.Bounds.Height) / Scale);
var height = (int) (Math.Max(path.Bounds.Width, path.Bounds.Height) / Scale);
var opacity = (float) Math.Round(Settings.Color.Alpha / 255.0, 2, MidpointRounding.AwayFromZero);
var opacity = (float) Math.Round(mainColor.Alpha / 255.0, 2, MidpointRounding.AwayFromZero);
using (var bitmap = new SKBitmap(new SKImageInfo(width, height)))
{
bitmap.Erase(new SKColor(0, 0, 0, 0));
@ -60,15 +64,14 @@ namespace Artemis.Plugins.LayerBrushes.Noise
{
for (var y = yStart; y < yEnd; y++)
{
var v = _noise.Evaluate(Settings.XScale * x / width, Settings.YScale * y / height, _z);
var v = _noise.Evaluate(scale.Width * x / width, scale.Height * y / height, _z);
var alpha = (byte) ((v + 1) * 127 * opacity);
// There's some fun stuff we can do here, like creating hard lines
// if (alpha > 128)
// alpha = 255;
// else
// alpha = 0;
var color = new SKColor(Settings.Color.Red, Settings.Color.Green, Settings.Color.Blue, alpha);
bitmap.SetPixel((int) x, (int) y, color);
bitmap.SetPixel((int) x, (int) y, new SKColor(mainColor.Red, mainColor.Green, mainColor.Blue, alpha));
}
}
}

44
src/Artemis.Plugins.LayerBrushes.Noise/NoiseBrushSettings.cs
View File

@ -1,44 +0,0 @@
using Artemis.Core.Plugins.LayerBrush;
using SkiaSharp;
namespace Artemis.Plugins.LayerBrushes.Noise
{
public class NoiseBrushSettings : LayerBrushSettings
{
private float _animationSpeed;
private SKBlendMode _blendMode;
private SKColor _color;
private float _xScale;
private float _yScale;
public SKColor Color
{
get => _color;
set => SetAndNotify(ref _color, value);
}
public SKBlendMode BlendMode
{
get => _blendMode;
set => SetAndNotify(ref _blendMode, value);
}
public float XScale
{
get => _xScale;
set => SetAndNotify(ref _xScale, value);
}
public float YScale
{
get => _yScale;
set => SetAndNotify(ref _yScale, value);
}
public float AnimationSpeed
{
get => _animationSpeed;
set => SetAndNotify(ref _animationSpeed, value);
}
}
}

140
src/Artemis.Plugins.LayerBrushes.Noise/NoiseBrushView.xaml
View File

@ -1,140 +0,0 @@
<UserControl x:Class="Artemis.Plugins.LayerBrushes.Noise.NoiseBrushView"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:artemis="clr-namespace:Artemis.UI.Shared;assembly=Artemis.UI.Shared"
xmlns:converters="clr-namespace:Artemis.UI.Shared.Converters;assembly=Artemis.UI.Shared"
xmlns:noiseBrush="clr-namespace:Artemis.Plugins.LayerBrushes.Noise"
mc:Ignorable="d"
d:DesignHeight="450" d:DesignWidth="800"
d:DataContext="{d:DesignInstance {x:Type noiseBrush:NoiseBrushViewModel}}">
<!-- <UserControl.Resources> -->
<!-- <ResourceDictionary> -->
<!-- <ResourceDictionary.MergedDictionaries> -->
<!-- <ResourceDictionary Source="pack://application:,,,/MaterialDesignThemes.Wpf;component/Themes/MaterialDesignTheme.Defaults.xaml" /> -->
<!-- </ResourceDictionary.MergedDictionaries> -->
<!-- <converters:SKColorToColorConverter x:Key="SKColorToColorConverter" /> -->
<!-- </ResourceDictionary> -->
<!-- </UserControl.Resources> -->
<!-- -->
<!-- <Grid Margin="12"> -->
<!-- <Grid.RowDefinitions> -->
<!-- <RowDefinition Height="Auto" /> -->
<!-- <RowDefinition Height="Auto" /> -->
<!-- <RowDefinition Height="Auto" /> -->
<!-- <RowDefinition Height="Auto" /> -->
<!-- <RowDefinition Height="Auto" /> -->
<!-- <RowDefinition Height="Auto" /> -->
<!-- </Grid.RowDefinitions> -->
<!-- -->
<!-- <Grid Grid.Row="0"> -->
<!-- <Grid.RowDefinitions> -->
<!-- <RowDefinition /> -->
<!-- <RowDefinition /> -->
<!-- </Grid.RowDefinitions> -->
<!-- <Grid.ColumnDefinitions> -->
<!-- <ColumnDefinition Width="*" /> -->
<!-- <ColumnDefinition Width="Auto" /> -->
<!-- </Grid.ColumnDefinitions> -->
<!-- <StackPanel Grid.Column="0" VerticalAlignment="Center"> -->
<!-- <TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}" Text="Noise color" /> -->
<!-- </StackPanel> -->
<!-- <StackPanel Grid.Row="0" Grid.Column="1" VerticalAlignment="Center"> -->
<!-- <artemis:ColorPicker Color="{Binding Brush.Settings.Color, Converter={StaticResource SKColorToColorConverter}}" Width="100" /> -->
<!-- </StackPanel> -->
<!-- <Separator Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Style="{StaticResource MaterialDesignSeparator}" /> -->
<!-- </Grid> -->
<!-- -->
<!-- <Grid Grid.Row="1"> -->
<!-- <Grid.RowDefinitions> -->
<!-- <RowDefinition /> -->
<!-- <RowDefinition /> -->
<!-- </Grid.RowDefinitions> -->
<!-- <Grid.ColumnDefinitions> -->
<!-- <ColumnDefinition Width="*" /> -->
<!-- <ColumnDefinition Width="Auto" /> -->
<!-- </Grid.ColumnDefinitions> -->
<!-- <StackPanel Grid.Column="0" VerticalAlignment="Center"> -->
<!-- <TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}"> -->
<!-- <Run Text="Blend mode" /> -->
<!-- </TextBlock> -->
<!-- <TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}" Foreground="{DynamicResource MaterialDesignCheckBoxDisabled}"> -->
<!-- <Run Text="Affects how the noise is rendered on the rest of the layer" /> -->
<!-- </TextBlock> -->
<!-- </StackPanel> -->
<!-- <StackPanel Grid.Row="0" Grid.Column="1" VerticalAlignment="Center"> -->
<!-- <ComboBox HorizontalAlignment="Left" -->
<!-- ItemsSource="{Binding BlendModes}" -->
<!-- SelectedValuePath="Value" -->
<!-- DisplayMemberPath="Description" -->
<!-- Width="100" -->
<!-- SelectedValue="{Binding Brush.Settings.BlendMode}" /> -->
<!-- </StackPanel> -->
<!-- <Separator Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Style="{StaticResource MaterialDesignSeparator}" /> -->
<!-- </Grid> -->
<!-- -->
<!-- <Grid Grid.Row="2"> -->
<!-- <Grid.RowDefinitions> -->
<!-- <RowDefinition /> -->
<!-- <RowDefinition /> -->
<!-- </Grid.RowDefinitions> -->
<!-- <Grid.ColumnDefinitions> -->
<!-- <ColumnDefinition Width="*" /> -->
<!-- <ColumnDefinition Width="Auto" /> -->
<!-- </Grid.ColumnDefinitions> -->
<!-- <StackPanel Grid.Column="0" VerticalAlignment="Center"> -->
<!-- <TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}"> -->
<!-- <Run Text="X Scale" /> -->
<!-- </TextBlock> -->
<!-- </StackPanel> -->
<!-- <StackPanel Grid.Row="0" Grid.Column="1" VerticalAlignment="Center"> -->
<!-- <Slider Orientation="Horizontal" TickFrequency="0.5" Minimum="0.5" Maximum="40" Value="{Binding Brush.Settings.XScale}" Width="100" /> -->
<!-- </StackPanel> -->
<!-- <Separator Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Style="{StaticResource MaterialDesignSeparator}" /> -->
<!-- </Grid> -->
<!-- -->
<!-- ~1~ Sample 1 @1@ -->
<!-- <Grid Grid.Row="3"> -->
<!-- <Grid.RowDefinitions> -->
<!-- <RowDefinition /> -->
<!-- <RowDefinition /> -->
<!-- </Grid.RowDefinitions> -->
<!-- <Grid.ColumnDefinitions> -->
<!-- <ColumnDefinition Width="*" /> -->
<!-- <ColumnDefinition Width="Auto" /> -->
<!-- </Grid.ColumnDefinitions> -->
<!-- <StackPanel Grid.Column="0" VerticalAlignment="Center"> -->
<!-- <TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}"> -->
<!-- <Run Text="Y Scale" /> -->
<!-- </TextBlock> -->
<!-- </StackPanel> -->
<!-- <StackPanel Grid.Row="0" Grid.Column="1" VerticalAlignment="Center"> -->
<!-- <Slider Orientation="Horizontal" TickFrequency="0.5" Minimum="0.5" Maximum="40" Value="{Binding Brush.Settings.YScale}" Width="100" /> -->
<!-- </StackPanel> -->
<!-- <Separator Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Style="{StaticResource MaterialDesignSeparator}" /> -->
<!-- </Grid> -->
<!-- -->
<!-- ~1~ Setting 2 @1@ -->
<!-- <Grid Grid.Row="4"> -->
<!-- <Grid.RowDefinitions> -->
<!-- <RowDefinition /> -->
<!-- <RowDefinition /> -->
<!-- </Grid.RowDefinitions> -->
<!-- <Grid.ColumnDefinitions> -->
<!-- <ColumnDefinition Width="*" /> -->
<!-- <ColumnDefinition Width="Auto" /> -->
<!-- </Grid.ColumnDefinitions> -->
<!-- <StackPanel Grid.Column="0" VerticalAlignment="Center"> -->
<!-- <TextBlock Style="{StaticResource MaterialDesignBody1TextBlock}"> -->
<!-- <Run Text="Animation speed" /> -->
<!-- </TextBlock> -->
<!-- </StackPanel> -->
<!-- <StackPanel Grid.Row="0" Grid.Column="1" VerticalAlignment="Center"> -->
<!-- -->
<!-- <Slider Orientation="Horizontal" TickFrequency="1" Minimum="1" Maximum="100" Value="{Binding Brush.Settings.AnimationSpeed}" Width="100" /> -->
<!-- </StackPanel> -->
<!-- <Separator Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Style="{StaticResource MaterialDesignSeparator}" /> -->
<!-- </Grid> -->
<!-- </Grid> -->
</UserControl>

18
src/Artemis.Plugins.LayerBrushes.Noise/NoiseBrushViewModel.cs
View File

@ -1,18 +0,0 @@
using System.Collections.Generic;
using Artemis.Core.Plugins.LayerBrush;
using Artemis.UI.Shared.Utilities;
using SkiaSharp;
namespace Artemis.Plugins.LayerBrushes.Noise
{
public class NoiseBrushViewModel : LayerBrushViewModel
{
public NoiseBrushViewModel(NoiseBrush brush) : base(brush)
{
Brush = brush;
}
public new NoiseBrush Brush { get; }
public IEnumerable<ValueDescription> BlendModes => EnumUtilities.GetAllValuesAndDescriptions(typeof(SKBlendMode));
}
}

2
src/Artemis.Storage/Entities/Profile/LayerEntity.cs
View File

@ -23,8 +23,6 @@ namespace Artemis.Storage.Entities.Profile
public List<PropertyEntity> PropertyEntities { get; set; }
public List<ProfileConditionEntity> Condition { get; set; }
public BrushEntity BrushEntity { get; set; }
[BsonRef("ProfileEntity")]
public ProfileEntity Profile { get; set; }

15
src/Artemis.UI.Shared/ColorPicker.xaml
View File

@ -89,15 +89,24 @@
</ResourceDictionary>
</UserControl.Resources>
<Grid HorizontalAlignment="Stretch">
<!-- Style="{StaticResource MaterialDesignFloatingHintTextBox}" -->
<!-- Padding="0 0 10 0" -->
<TextBox x:Name="ColorCodeTextBox"
materialDesign:TextFieldAssist.TextBoxViewMargin="1 0 1 0"
Style="{StaticResource MaterialDesignFloatingHintTextBox}"
Text="{Binding Color, RelativeSource={RelativeSource AncestorType={x:Type UserControl}}, Converter={StaticResource ColorToStringConverter}}"
MinWidth="95"
Padding="0 0 10 0"
MaxLength="9"
Margin="0"
Padding="-1"
HorizontalAlignment="Stretch" />
<Border Width="15" Height="15" CornerRadius="15" Margin="0,0,0,5" VerticalAlignment="Bottom" HorizontalAlignment="Right" Background="{StaticResource Checkerboard}">
<Border Width="15"
Height="15"
CornerRadius="15"
Margin="0,0,0,2"
VerticalAlignment="Center"
HorizontalAlignment="Right"
Background="{StaticResource Checkerboard}">
<Ellipse Stroke="{DynamicResource NormalBorderBrush}" Cursor="Hand" MouseUp="UIElement_OnMouseUp">
<Ellipse.Fill>
<SolidColorBrush Color="{Binding Color, RelativeSource={RelativeSource AncestorType={x:Type UserControl}}, Mode=OneWay}" />

16
src/Artemis.UI/Artemis.UI.csproj
View File

@ -169,6 +169,10 @@
</Compile>
<Compile Include="Screens\Module\ProfileEditor\LayerProperties\LayerPropertiesViewModel.cs" />
<Compile Include="Screens\Module\ProfileEditor\LayerProperties\LayerPropertyViewModel.cs" />
<Compile Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\BrushPropertyInputView.xaml.cs">
<DependentUpon>BrushPropertyInputView.xaml</DependentUpon>
</Compile>
<Compile Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\BrushPropertyInputViewModel.cs" />
<Compile Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\EnumPropertyInputView.xaml.cs">
<DependentUpon>EnumPropertyInputView.xaml</DependentUpon>
</Compile>
@ -176,6 +180,10 @@
<Compile Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\FloatPropertyInputViewModel.cs" />
<Compile Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\IntPropertyInputViewModel.cs" />
<Compile Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\PropertyInputViewModel.cs" />
<Compile Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\SKColorPropertyInputView.xaml.cs">
<DependentUpon>SKColorPropertyInputView.xaml</DependentUpon>
</Compile>
<Compile Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\SKColorPropertyInputViewModel.cs" />
<Compile Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\SKPointPropertyInputViewModel.cs" />
<Compile Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\SKSizePropertyInputViewModel.cs" />
<Compile Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyTreeChildViewModel.cs" />
@ -302,6 +310,10 @@
<SubType>Designer</SubType>
<Generator>MSBuild:Compile</Generator>
</Page>
<Page Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\BrushPropertyInputView.xaml">
<SubType>Designer</SubType>
<Generator>MSBuild:Compile</Generator>
</Page>
<Page Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\EnumPropertyInputView.xaml">
<SubType>Designer</SubType>
<Generator>MSBuild:Compile</Generator>
@ -314,6 +326,10 @@
<SubType>Designer</SubType>
<Generator>MSBuild:Compile</Generator>
</Page>
<Page Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\SKColorPropertyInputView.xaml">
<SubType>Designer</SubType>
<Generator>MSBuild:Compile</Generator>
</Page>
<Page Include="Screens\Module\ProfileEditor\LayerProperties\PropertyTree\PropertyInput\SKPointPropertyInputView.xaml">
<SubType>Designer</SubType>
<Generator>MSBuild:Compile</Generator>

6
src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/LayerPropertiesView.xaml.cs
View File

@ -15,11 +15,11 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties
// Keeping the scroll viewers in sync is up to the view, not a viewmodel concern
private void TimelineScrollChanged(object sender, ScrollChangedEventArgs e)
{
if (sender == TimelineHeaderScrollViewer)
if (e.OriginalSource == TimelineHeaderScrollViewer)
TimelineRailsScrollViewer.ScrollToHorizontalOffset(e.HorizontalOffset);
else if (sender == PropertyTreeScrollViewer)
else if (e.OriginalSource == PropertyTreeScrollViewer)
TimelineRailsScrollViewer.ScrollToVerticalOffset(e.VerticalOffset);
else if (sender == TimelineRailsScrollViewer)
else if (e.OriginalSource == TimelineRailsScrollViewer)
{
TimelineHeaderScrollViewer.ScrollToHorizontalOffset(e.HorizontalOffset);
PropertyTreeScrollViewer.ScrollToVerticalOffset(e.VerticalOffset);

1
src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/LayerPropertiesViewModel.cs
View File

@ -41,6 +41,7 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties
PopulateProperties();
_profileEditorService.SelectedProfileElementChanged += (sender, args) => PopulateProperties();
_profileEditorService.SelectedProfileChanged += (sender, args) => PopulateProperties();
_profileEditorService.CurrentTimeChanged += ProfileEditorServiceOnCurrentTimeChanged;
}

28
src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/PropertyTree/PropertyInput/BrushPropertyInputView.xaml Normal file
View File

@ -0,0 +1,28 @@
<UserControl x:Class="Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree.PropertyInput.BrushPropertyInputView"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:local="clr-namespace:Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree.PropertyInput"
xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
xmlns:s="https://github.com/canton7/Stylet"
mc:Ignorable="d"
d:DesignHeight="450" d:DesignWidth="800">
<StackPanel Orientation="Horizontal">
<TextBlock Margin="0 0 5 0" Width="10" VerticalAlignment="Bottom" Text="{Binding LayerPropertyViewModel.LayerProperty.InputPrefix}" />
<ComboBox Width="132"
Margin="0 2"
Padding="0 -1"
Height="15"
materialDesign:ValidationAssist.UsePopup="True"
HorizontalAlignment="Left"
ItemsSource="{Binding Path=EnumValues}"
SelectedValuePath="Value"
DisplayMemberPath="Description"
SelectedValue="{Binding Path=BrushInputValue}"
RequestBringIntoView="{s:Action OnRequestBringIntoView}"
materialDesign:ComboBoxAssist.ClassicMode="True">
</ComboBox>
<TextBlock Margin="5 0 0 0" Width="10" VerticalAlignment="Bottom" Text="{Binding LayerPropertyViewModel.LayerProperty.InputAffix}" />
</StackPanel>
</UserControl>

28
src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/PropertyTree/PropertyInput/BrushPropertyInputView.xaml.cs Normal file
View File

@ -0,0 +1,28 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree.PropertyInput
{
/// <summary>
/// Interaction logic for BrushPropertyInputView.xaml
/// </summary>
public partial class BrushPropertyInputView : UserControl
{
public BrushPropertyInputView()
{
InitializeComponent();
}
}
}

68
src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/PropertyTree/PropertyInput/BrushPropertyInputViewModel.cs Normal file
View File

@ -0,0 +1,68 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Artemis.Core.Models.Profile;
using Artemis.Core.Plugins.LayerBrush;
using Artemis.Core.Services.Interfaces;
using Artemis.UI.Services.Interfaces;
using Artemis.UI.Shared.Utilities;
using Stylet;
namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree.PropertyInput
{
public class BrushPropertyInputViewModel : PropertyInputViewModel
{
private readonly ILayerService _layerService;
private readonly IPluginService _pluginService;
public BrushPropertyInputViewModel(IProfileEditorService profileEditorService, ILayerService layerService, IPluginService pluginService) : base(profileEditorService)
{
_layerService = layerService;
_pluginService = pluginService;
EnumValues = new BindableCollection<ValueDescription>();
_pluginService.PluginLoaded += (sender, args) => UpdateEnumValues();
}
public BindableCollection<ValueDescription> EnumValues { get; }
public sealed override List<Type> CompatibleTypes { get; } = new List<Type> {typeof(LayerBrushReference)};
public LayerBrushReference BrushInputValue
{
get => (LayerBrushReference) InputValue;
set
{
InputValue = value;
_layerService.InstantiateLayerBrush(LayerPropertyViewModel.LayerProperty.Layer);
}
}
protected override void OnInitialized()
{
UpdateEnumValues();
base.OnInitialized();
}
public void UpdateEnumValues()
{
var layerBrushProviders = _pluginService.GetPluginsOfType<LayerBrushProvider>();
var descriptors = layerBrushProviders.SelectMany(l => l.LayerBrushDescriptors).ToList();
EnumValues.Clear();
foreach (var layerBrushDescriptor in descriptors)
{
var brushName = layerBrushDescriptor.LayerBrushType.Name;
var brushGuid = layerBrushDescriptor.LayerBrushProvider.PluginInfo.Guid;
if (BrushInputValue != null && BrushInputValue.BrushType == brushName && BrushInputValue.BrushPluginGuid == brushGuid)
EnumValues.Add(new ValueDescription {Description = layerBrushDescriptor.DisplayName, Value = BrushInputValue});
else
EnumValues.Add(new ValueDescription {Description = layerBrushDescriptor.DisplayName, Value = new LayerBrushReference {BrushType = brushName, BrushPluginGuid = brushGuid}});
}
}
public override void Update()
{
NotifyOfPropertyChange(() => BrushInputValue);
}
}
}

5
src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/PropertyTree/PropertyInput/EnumPropertyInputView.xaml
View File

@ -23,11 +23,6 @@
SelectedValue="{Binding Path=EnumInputValue}"
RequestBringIntoView="{s:Action OnRequestBringIntoView}"
materialDesign:ComboBoxAssist.ClassicMode="True">
<ComboBox.ItemContainerStyle>
<Style TargetType="ComboBoxItem" BasedOn="{StaticResource MaterialDesignComboBoxItemStyle}">
<EventSetter Event="RequestBringIntoView" Handler="OnRequestBringIntoView"/>
</Style>
</ComboBox.ItemContainerStyle>
</ComboBox>
<TextBlock Margin="5 0 0 0" Width="10" VerticalAlignment="Bottom" Text="{Binding LayerPropertyViewModel.LayerProperty.InputAffix}" />
</StackPanel>

5
src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/PropertyTree/PropertyInput/EnumPropertyInputView.xaml.cs
View File

@ -24,10 +24,5 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree.P
{
InitializeComponent();
}
private void OnRequestBringIntoView(object sender, RequestBringIntoViewEventArgs e)
{
e.Handled = true;
}
}
}

25
src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/PropertyTree/PropertyInput/SKColorPropertyInputView.xaml Normal file
View File

@ -0,0 +1,25 @@
<UserControl x:Class="Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree.PropertyInput.SKColorPropertyInputView"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:local="clr-namespace:Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree.PropertyInput"
xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
xmlns:s="https://github.com/canton7/Stylet"
xmlns:artemis="clr-namespace:Artemis.UI.Shared;assembly=Artemis.UI.Shared"
xmlns:converters="clr-namespace:Artemis.UI.Shared.Converters;assembly=Artemis.UI.Shared"
mc:Ignorable="d"
d:DesignHeight="25" d:DesignWidth="800"
d:DataContext="{d:DesignInstance local:SKColorPropertyInputViewModel}">
<UserControl.Resources>
<converters:SKColorToColorConverter x:Key="SKColorToColorConverter" />
</UserControl.Resources>
<StackPanel Orientation="Horizontal">
<TextBlock Margin="0 0 5 0" Width="10" VerticalAlignment="Bottom" Text="{Binding LayerPropertyViewModel.LayerProperty.InputPrefix}" />
<artemis:ColorPicker Width="132"
Margin="0 2"
Padding="0 -1"
Color="{Binding SKColorInputValue, Converter={StaticResource SKColorToColorConverter}}" />
<TextBlock Margin="5 0 0 0" Width="10" VerticalAlignment="Bottom" Text="{Binding LayerPropertyViewModel.LayerProperty.InputAffix}" />
</StackPanel>
</UserControl>

28
src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/PropertyTree/PropertyInput/SKColorPropertyInputView.xaml.cs Normal file
View File

@ -0,0 +1,28 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree.PropertyInput
{
/// <summary>
/// Interaction logic for SKColorPropertyInputView.xaml
/// </summary>
public partial class SKColorPropertyInputView : UserControl
{
public SKColorPropertyInputView()
{
InitializeComponent();
}
}
}

27
src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/PropertyTree/PropertyInput/SKColorPropertyInputViewModel.cs Normal file
View File

@ -0,0 +1,27 @@
using System;
using System.Collections.Generic;
using Artemis.UI.Services.Interfaces;
using SkiaSharp;
namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree.PropertyInput
{
public class SKColorPropertyInputViewModel : PropertyInputViewModel
{
public SKColorPropertyInputViewModel(IProfileEditorService profileEditorService) : base(profileEditorService)
{
}
public sealed override List<Type> CompatibleTypes { get; } = new List<Type> {typeof(SKColor)};
public SKColor SKColorInputValue
{
get => (SKColor?) InputValue ?? new SKColor();
set => InputValue = value;
}
public override void Update()
{
NotifyOfPropertyChange(() => SKColorInputValue);
}
}
}

4
src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/PropertyTree/PropertyTreeChildViewModel.cs
View File

@ -16,12 +16,12 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree
public override void Update(bool forceUpdate)
{
if (forceUpdate)
PropertyInputViewModel.Update();
PropertyInputViewModel?.Update();
else
{
// Only update if visible and if keyframes are enabled
if (LayerPropertyViewModel.Parent.IsExpanded && LayerPropertyViewModel.KeyframesEnabled)
PropertyInputViewModel.Update();
PropertyInputViewModel?.Update();
}
}
}

4
src/Artemis.UI/Screens/Module/ProfileEditor/Visualization/ProfileView.xaml
View File

@ -91,10 +91,10 @@
<ColumnDefinition />
<ColumnDefinition />
</Grid.ColumnDefinitions>
<Rectangle Grid.Row="0" Grid.Column="0" Fill="{DynamicResource MaterialDesignPaper}" />
<Rectangle Grid.Row="0" Grid.Column="0" Fill="Black" Opacity="0.15" />
<Rectangle Grid.Row="0" Grid.Column="1" />
<Rectangle Grid.Row="1" Grid.Column="0" />
<Rectangle Grid.Row="1" Grid.Column="1" Fill="{DynamicResource MaterialDesignPaper}" />
<Rectangle Grid.Row="1" Grid.Column="1" Fill="Black" Opacity="0.15" />
</Grid>
</VisualBrush.Visual>
</VisualBrush>