Plugins - Adjusted namespaces

src/Artemis.Core/Plugins/LayerBrushes/BrushConfigurationViewModel.cs

@@ -0,0 +1,15 @@
+using Artemis.Core.Plugins.LayerBrushes.Internal;
+using Stylet;
+
+namespace Artemis.Core.Plugins.LayerBrushes
+{
+    public abstract class BrushConfigurationViewModel : Screen
+    {
+        protected BrushConfigurationViewModel(BaseLayerBrush layerBrush)
+        {
+            LayerBrush = layerBrush;
+        }
+
+        public BaseLayerBrush LayerBrush { get; }
+    }
+}

src/Artemis.Core/Plugins/LayerBrushes/Internal/BaseLayerBrush.cs

@@ -0,0 +1,134 @@
+using System;
+using Artemis.Core.Models.Profile;
+using Artemis.Core.Plugins.Exceptions;
+using Artemis.Core.Services.Interfaces;
+using SkiaSharp;
+using Stylet;
+
+namespace Artemis.Core.Plugins.LayerBrushes.Internal
+{
+    /// <summary>
+    ///     For internal use only, please use <see cref="LayerBrush{T}" /> or <see cref="RgbNetLayerBrush{T}" /> or instead
+    /// </summary>
+    public abstract class BaseLayerBrush : PropertyChangedBase, IDisposable
+    {
+        private LayerBrushType _brushType;
+        private LayerBrushConfigurationDialog _configurationDialog;
+        private LayerBrushDescriptor _descriptor;
+        private Layer _layer;
+        private bool _supportsTransformation = true;
+
+        /// <summary>
+        ///     Gets the layer this brush is applied to
+        /// </summary>
+        public Layer Layer
+        {
+            get => _layer;
+            internal set => SetAndNotify(ref _layer, value);
+        }
+
+        /// <summary>
+        ///     Gets the descriptor of this brush
+        /// </summary>
+        public LayerBrushDescriptor Descriptor
+        {
+            get => _descriptor;
+            internal set => SetAndNotify(ref _descriptor, value);
+        }
+
+        /// <summary>
+        ///     Gets or sets a configuration dialog complementing the regular properties
+        /// </summary>
+        public LayerBrushConfigurationDialog ConfigurationDialog
+        {
+            get => _configurationDialog;
+            protected set => SetAndNotify(ref _configurationDialog, value);
+        }
+
+        /// <summary>
+        ///     Gets the type of layer brush
+        /// </summary>
+        public LayerBrushType BrushType
+        {
+            get => _brushType;
+            internal set => SetAndNotify(ref _brushType, value);
+        }
+
+        /// <summary>
+        ///     Gets the plugin info that defined this brush
+        /// </summary>
+        public PluginInfo PluginInfo => Descriptor.LayerBrushProvider.PluginInfo;
+
+        /// <summary>
+        ///     Gets a reference to the layer property group without knowing it's type
+        /// </summary>
+        public virtual LayerPropertyGroup BaseProperties => null;
+
+        /// <summary>
+        ///     Gets or sets whether the brush supports transformations
+        ///     <para>Note: RGB.NET brushes can never be transformed and setting this to true will throw an exception</para>
+        /// </summary>
+        public bool SupportsTransformation
+        {
+            get => _supportsTransformation;
+            protected set
+            {
+                if (value && BrushType == LayerBrushType.RgbNet)
+                    throw new ArtemisPluginException(PluginInfo, "An RGB.NET brush cannot support transformation");
+                _supportsTransformation = value;
+            }
+        }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            DisableLayerBrush();
+            BaseProperties.Dispose();
+
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        ///     Called when the layer brush is activated
+        /// </summary>
+        public abstract void EnableLayerBrush();
+
+        /// <summary>
+        ///     Called when the layer brush is deactivated
+        /// </summary>
+        public abstract void DisableLayerBrush();
+
+        /// <summary>
+        ///     Called before rendering every frame, write your update logic here
+        /// </summary>
+        /// <param name="deltaTime">Seconds passed since last update</param>
+        public abstract void Update(double deltaTime);
+
+        // Not only is this needed to initialize properties on the layer brushes, it also prevents implementing anything
+        // but LayerBrush<T> and RgbNetLayerBrush<T> outside the core
+        internal abstract void Initialize(IRenderElementService renderElementService);
+
+        internal abstract void InternalRender(SKCanvas canvas, SKImageInfo canvasInfo, SKPath path, SKPaint paint);
+
+        internal virtual void Dispose(bool disposing)
+        {
+        }
+    }
+
+    /// <summary>
+    ///     Describes the type of a layer brush
+    /// </summary>
+    public enum LayerBrushType
+    {
+        /// <summary>
+        ///     A regular brush that users Artemis' SkiaSharp-based rendering engine
+        /// </summary>
+        Regular,
+
+        /// <summary>
+        ///     An RGB.NET brush that uses RGB.NET's per-LED rendering engine.     
+        /// </summary>
+        RgbNet
+    }
+}

src/Artemis.Core/Plugins/LayerBrushes/Internal/PropertiesLayerBrush.cs

@@ -0,0 +1,48 @@
+using System;
+using Artemis.Core.Models.Profile;
+using Artemis.Core.Plugins.Exceptions;
+using Artemis.Core.Services.Interfaces;
+
+namespace Artemis.Core.Plugins.LayerBrushes.Internal
+{
+    /// <summary>
+    ///     For internal use only, please use <see cref="LayerBrush{T}" /> or <see cref="RgbNetLayerBrush{T}" /> or instead
+    /// </summary>
+    public abstract class PropertiesLayerBrush<T> : BaseLayerBrush where T : LayerPropertyGroup
+    {
+        private T _properties;
+
+        /// <summary>
+        ///     Gets whether all properties on this brush are initialized
+        /// </summary>
+        public bool PropertiesInitialized { get; internal set; }
+
+        /// <inheritdoc />
+        public override LayerPropertyGroup BaseProperties => Properties;
+
+        /// <summary>
+        ///     Gets the properties of this brush.
+        /// </summary>
+        public T Properties
+        {
+            get
+            {
+                // I imagine a null reference here can be confusing, so lets throw an exception explaining what to do
+                if (_properties == null)
+                    throw new ArtemisPluginException("Cannot access brush properties until OnPropertiesInitialized has been called");
+                return _properties;
+            }
+            internal set => _properties = value;
+        }
+
+        internal void InitializeProperties(IRenderElementService renderElementService)
+        {
+            Properties = Activator.CreateInstance<T>();
+            Properties.LayerBrush = this;
+            Properties.InitializeProperties(renderElementService, Layer, "LayerBrush.");
+            PropertiesInitialized = true;
+
+            EnableLayerBrush();
+        }
+    }
+}

src/Artemis.Core/Plugins/LayerBrushes/LayerBrush.cs

@@ -0,0 +1,36 @@
+using Artemis.Core.Models.Profile;
+using Artemis.Core.Plugins.LayerBrushes.Internal;
+using Artemis.Core.Services.Interfaces;
+using SkiaSharp;
+
+namespace Artemis.Core.Plugins.LayerBrushes
+{
+    public abstract class LayerBrush<T> : PropertiesLayerBrush<T> where T : LayerPropertyGroup
+    {
+        protected LayerBrush()
+        {
+            BrushType = LayerBrushType.Regular;
+        }
+
+        /// <summary>
+        ///     The main method of rendering anything to the layer. The provided <see cref="SKCanvas" /> is specific to the layer
+        ///     and matches it's width and height.
+        ///     <para>Called during rendering or layer preview, in the order configured on the layer</para>
+        /// </summary>
+        /// <param name="canvas">The layer canvas</param>
+        /// <param name="canvasInfo"></param>
+        /// <param name="path">The path to be filled, represents the shape</param>
+        /// <param name="paint">The paint to be used to fill the shape</param>
+        public abstract void Render(SKCanvas canvas, SKImageInfo canvasInfo, SKPath path, SKPaint paint);
+
+        internal override void InternalRender(SKCanvas canvas, SKImageInfo canvasInfo, SKPath path, SKPaint paint)
+        {
+            Render(canvas, canvasInfo, path, paint);
+        }
+
+        internal override void Initialize(IRenderElementService renderElementService)
+        {
+            InitializeProperties(renderElementService);
+        }
+    }
+}

src/Artemis.Core/Plugins/LayerBrushes/LayerBrushConfigurationDialog.cs

@@ -0,0 +1,28 @@
+using System;
+using Artemis.Core.Plugins.LayerBrushes.Internal;
+
+namespace Artemis.Core.Plugins.LayerBrushes
+{
+    /// <inheritdoc />
+    public class LayerBrushConfigurationDialog<T> : LayerBrushConfigurationDialog where T : BrushConfigurationViewModel
+    {
+        /// <inheritdoc />
+        public override Type Type => typeof(T);
+    }
+
+    /// <summary>
+    ///     Describes a UI tab for a layer brush
+    /// </summary>
+    public abstract class LayerBrushConfigurationDialog
+    {
+        /// <summary>
+        ///     The layer brush this dialog belongs to
+        /// </summary>
+        internal BaseLayerBrush LayerBrush { get; set; }
+
+        /// <summary>
+        ///     The type of view model the tab contains
+        /// </summary>
+        public abstract Type Type { get; }
+    }
+}

src/Artemis.Core/Plugins/LayerBrushes/LayerBrushDescriptor.cs

@@ -0,0 +1,45 @@
+using System;
+
+namespace Artemis.Core.Plugins.LayerBrushes
+{
+    /// <summary>
+    ///     A class that describes a layer brush
+    /// </summary>
+    public class LayerBrushDescriptor
+    {
+        internal LayerBrushDescriptor(string displayName, string description, string icon, Type layerBrushType, LayerBrushProvider layerBrushProvider)
+        {
+            DisplayName = displayName;
+            Description = description;
+            Icon = icon;
+            LayerBrushType = layerBrushType;
+            LayerBrushProvider = layerBrushProvider;
+        }
+
+        /// <summary>
+        ///     The name that is displayed in the UI
+        /// </summary>
+        public string DisplayName { get; }
+
+        /// <summary>
+        ///     The description that is displayed in the UI
+        /// </summary>
+        public string Description { get; }
+
+        /// <summary>
+        ///     The Material icon to display in the UI, a full reference can be found
+        ///     <see href="https://materialdesignicons.com">here</see>
+        /// </summary>
+        public string Icon { get; }
+
+        /// <summary>
+        ///     The type of the layer brush
+        /// </summary>
+        public Type LayerBrushType { get; }
+
+        /// <summary>
+        ///     The plugin that provided this <see cref="LayerBrushDescriptor" />
+        /// </summary>
+        public LayerBrushProvider LayerBrushProvider { get; }
+    }
+}

src/Artemis.Core/Plugins/LayerBrushes/LayerBrushProvider.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Artemis.Core.Plugins.Exceptions;
+using Artemis.Core.Plugins.LayerBrushes.Internal;
+
+namespace Artemis.Core.Plugins.LayerBrushes
+{
+    /// <summary>
+    ///     Allows you to create one or more <see cref="LayerBrush{T}" />s usable by profile layers.
+    /// </summary>
+    public abstract class LayerBrushProvider : Plugin
+    {
+        private readonly List<LayerBrushDescriptor> _layerBrushDescriptors;
+
+        /// <summary>
+        ///     Allows you to register one or more <see cref="LayerBrush{T}" />s usable by profile layers.
+        /// </summary>
+        protected LayerBrushProvider()
+        {
+            _layerBrushDescriptors = new List<LayerBrushDescriptor>();
+            PluginDisabled += OnPluginDisabled;
+        }
+
+        /// <summary>
+        ///     A read-only collection of all layer brushes added with <see cref="RegisterLayerBrushDescriptor{T}" />
+        /// </summary>
+        public ReadOnlyCollection<LayerBrushDescriptor> LayerBrushDescriptors => _layerBrushDescriptors.AsReadOnly();
+
+        /// <summary>
+        ///     Registers a layer brush descriptor for a given layer brush, so that it appears in the UI.
+        ///     <para>Note: You do not need to manually remove these on disable</para>
+        /// </summary>
+        /// <typeparam name="T">The type of the layer brush you wish to register</typeparam>
+        /// <param name="displayName">The name to display in the UI</param>
+        /// <param name="description">The description to display in the UI</param>
+        /// <param name="icon">
+        ///     The Material icon to display in the UI, a full reference can be found
+        ///     <see href="https://materialdesignicons.com">here</see>
+        /// </param>
+        protected void RegisterLayerBrushDescriptor<T>(string displayName, string description, string icon) where T : BaseLayerBrush
+        {
+            if (!Enabled)
+                throw new ArtemisPluginException(PluginInfo, "Can only add a layer brush descriptor when the plugin is enabled");
+
+            _layerBrushDescriptors.Add(new LayerBrushDescriptor(displayName, description, icon, typeof(T), this));
+        }
+
+        private void OnPluginDisabled(object sender, EventArgs e)
+        {
+            _layerBrushDescriptors.Clear();
+        }
+    }
+}

src/Artemis.Core/Plugins/LayerBrushes/PerLedLayerBrush.cs

@@ -0,0 +1,81 @@
+using Artemis.Core.Models.Profile;
+using Artemis.Core.Models.Surface;
+using Artemis.Core.Plugins.LayerBrushes.Internal;
+using Artemis.Core.Services.Interfaces;
+using SkiaSharp;
+
+namespace Artemis.Core.Plugins.LayerBrushes
+{
+    public abstract class PerLedLayerBrush<T> : PropertiesLayerBrush<T> where T : LayerPropertyGroup
+    {
+        protected PerLedLayerBrush()
+        {
+            BrushType = LayerBrushType.Regular;
+        }
+
+
+        /// <summary>
+        ///     The main method of rendering for this type of brush. Called once per frame for each LED in the layer
+        ///     <para>
+        ///         Note: Due to transformations, the render point may not match the position of the LED, always use the render
+        ///         point to determine where the color will go.
+        ///     </para>
+        /// </summary>
+        /// <param name="led">The LED that will receive the color</param>
+        /// <param name="renderPoint">The point at which the color is located</param>
+        /// <returns>The color the LED will receive</returns>
+        public abstract SKColor GetColor(ArtemisLed led, SKPoint renderPoint);
+
+        internal override void InternalRender(SKCanvas canvas, SKImageInfo canvasInfo, SKPath path, SKPaint paint)
+        {
+            // We don't want translations on this canvas because that'll displace the LEDs, translations are applied to the points of each LED instead
+            Layer.ExcludeCanvasFromTranslation(canvas, true);
+
+            if (Layer.General.ResizeMode == LayerResizeMode.Normal)
+            {
+                // Apply a translated version of the shape as the clipping mask
+                var shapePath = new SKPath(Layer.LayerShape.Path);
+                Layer.IncludePathInTranslation(shapePath, true);
+                canvas.ClipPath(shapePath);
+            }
+
+            using var pointsPath = new SKPath();
+            using var ledPaint = new SKPaint();
+            foreach (var artemisLed in Layer.Leds)
+            {
+                pointsPath.AddPoly(new[]
+                {
+                    new SKPoint(0, 0),
+                    new SKPoint(artemisLed.AbsoluteRenderRectangle.Left - Layer.Bounds.Left, artemisLed.AbsoluteRenderRectangle.Top - Layer.Bounds.Top)
+                });
+            }
+
+            Layer.ExcludePathFromTranslation(pointsPath, true);
+            var points = pointsPath.Points;
+            for (var index = 0; index < Layer.Leds.Count; index++)
+            {
+                var artemisLed = Layer.Leds[index];
+                var renderPoint = points[index * 2 + 1];
+                if (!float.IsFinite(renderPoint.X) || !float.IsFinite(renderPoint.Y))
+                    continue;
+
+                // Let the brush determine the color
+                ledPaint.Color = GetColor(artemisLed, renderPoint);
+
+                var ledRectangle = SKRect.Create(
+                    artemisLed.AbsoluteRenderRectangle.Left - Layer.Bounds.Left,
+                    artemisLed.AbsoluteRenderRectangle.Top - Layer.Bounds.Top,
+                    artemisLed.AbsoluteRenderRectangle.Width,
+                    artemisLed.AbsoluteRenderRectangle.Height
+                );
+
+                canvas.DrawRect(ledRectangle, ledPaint);
+            }
+        }
+
+        internal override void Initialize(IRenderElementService renderElementService)
+        {
+            InitializeProperties(renderElementService);
+        }
+    }
+}

src/Artemis.Core/Plugins/LayerBrushes/RgbNetLayerBrush.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Linq;
+using Artemis.Core.Models.Profile;
+using Artemis.Core.Plugins.LayerBrushes.Internal;
+using Artemis.Core.Services.Interfaces;
+using RGB.NET.Core;
+using RGB.NET.Groups;
+using SkiaSharp;
+
+namespace Artemis.Core.Plugins.LayerBrushes
+{
+    /// <summary>
+    ///     An RGB.NET brush that uses RGB.NET's per-LED rendering engine.
+    ///     <para>Note: This brush type always renders on top of regular brushes</para>
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public abstract class RgbNetLayerBrush<T> : PropertiesLayerBrush<T> where T : LayerPropertyGroup
+    {
+        /// <summary>
+        ///     Creates a new instance of the <see cref="RgbNetLayerBrush{T}" /> class
+        /// </summary>
+        protected RgbNetLayerBrush()
+        {
+            BrushType = LayerBrushType.RgbNet;
+            SupportsTransformation = false;
+        }
+
+        /// <summary>
+        ///     The LED group this layer effect is applied to
+        /// </summary>
+        public ListLedGroup LedGroup { get; internal set; }
+
+        /// <summary>
+        ///     Called when Artemis needs an instance of the RGB.NET effect you are implementing
+        /// </summary>
+        /// <returns>Your RGB.NET effect</returns>
+        public abstract IBrush GetBrush();
+
+        internal void UpdateLedGroup()
+        {
+            // TODO: This simply renders it on top of the rest, get a ZIndex based on layer position
+            LedGroup.ZIndex = 1;
+
+            var missingLeds = Layer.Leds.Where(l => !LedGroup.ContainsLed(l.RgbLed)).Select(l => l.RgbLed).ToList();
+            var extraLeds = LedGroup.GetLeds().Where(l => Layer.Leds.All(layerLed => layerLed.RgbLed != l)).ToList();
+            LedGroup.AddLeds(missingLeds);
+            LedGroup.RemoveLeds(extraLeds);
+            LedGroup.Brush = GetBrush();
+        }
+
+        internal override void Initialize(IRenderElementService renderElementService)
+        {
+            LedGroup = new ListLedGroup();
+            Layer.RenderPropertiesUpdated += LayerOnRenderPropertiesUpdated;
+
+            InitializeProperties(renderElementService);
+            UpdateLedGroup();
+        }
+
+        internal override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                Layer.RenderPropertiesUpdated -= LayerOnRenderPropertiesUpdated;
+                LedGroup.Detach();
+            }
+
+            base.Dispose(disposing);
+        }
+
+        // Not used in this effect type
+        internal override void InternalRender(SKCanvas canvas, SKImageInfo canvasInfo, SKPath path, SKPaint paint)
+        {
+            throw new NotImplementedException("RGB.NET layer effectes do not implement InternalRender");
+        }
+
+        private void LayerOnRenderPropertiesUpdated(object sender, EventArgs e)
+        {
+            UpdateLedGroup();
+        }
+    }
+}