Implemented SkiaSharp layer rendering

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

@@ -50,6 +50,7 @@ namespace Artemis.Core.Models.Profile
         public ReadOnlyCollection<LayerElement> LayerElements => _layerElements.AsReadOnly();
 
         public SKRect RenderRectangle { get; set; }
+        public SKRect AbsoluteRenderRectangle { get; set; }
         public SKPath RenderPath { get; set; }
 
         public override void Update(double deltaTime)
@@ -60,17 +61,40 @@ namespace Artemis.Core.Models.Profile
 
         public override void Render(double deltaTime, ArtemisSurface surface, SKCanvas canvas)
         {
+            if (RenderRectangle == null || AbsoluteRenderRectangle == null || RenderPath == null)
+                return;
+
             canvas.Save();
-            canvas.ClipPath(RenderPath);
 
             foreach (var layerElement in LayerElements)
                 layerElement.RenderPreProcess(surface, canvas);
 
-            foreach (var layerElement in LayerElements)
+            using (var bitmap = new SKBitmap(new SKImageInfo((int) RenderRectangle.Width, (int) RenderRectangle.Height)))
-                layerElement.Render(surface, canvas);
+            using (var layerCanvas = new SKCanvas(bitmap))
+            {
+                layerCanvas.Clear();
 
-            foreach (var layerElement in LayerElements)
+                foreach (var layerElement in LayerElements)
-                layerElement.RenderPostProcess(surface, canvas);
+                    layerElement.Render(surface, layerCanvas);
+
+                var baseShader = SKShader.CreateBitmap(bitmap, SKShaderTileMode.Repeat, SKShaderTileMode.Repeat);
+                foreach (var layerElement in LayerElements)
+                {
+                    var newBaseShader = layerElement.RenderPostProcess(surface, bitmap, baseShader);
+                    if (newBaseShader == null)
+                        continue;
+
+                    // Dispose the old base shader if the layer element provided a new one
+                    if (!ReferenceEquals(baseShader, newBaseShader))
+                        baseShader.Dispose();
+
+                    baseShader = newBaseShader;
+                }
+
+                canvas.ClipPath(RenderPath);
+                canvas.DrawRect(RenderRectangle, new SKPaint {Shader = baseShader, FilterQuality = SKFilterQuality.Low});
+                baseShader.Dispose();
+            }
 
             canvas.Restore();
         }
@@ -169,21 +193,34 @@ namespace Artemis.Core.Models.Profile
             // Determine to top-left and bottom-right
             var minX = Leds.Min(l => l.AbsoluteRenderRectangle.Left);
             var minY = Leds.Min(l => l.AbsoluteRenderRectangle.Top);
-            var maxX = Leds.Max(l => l.AbsoluteRenderRectangle.Bottom);
+            var maxX = Leds.Max(l => l.AbsoluteRenderRectangle.Right);
-            var maxY = Leds.Max(l => l.AbsoluteRenderRectangle.Right);
+            var maxY = Leds.Max(l => l.AbsoluteRenderRectangle.Bottom);
 
             RenderRectangle = SKRect.Create(minX, minY, maxX - minX, maxY - minY);
+            AbsoluteRenderRectangle = SKRect.Create(0, 0, maxX - minX, maxY - minY);
 
             var path = new SKPath {FillType = SKPathFillType.Winding};
             foreach (var artemisLed in Leds)
                 path.AddRect(artemisLed.AbsoluteRenderRectangle);
 
             RenderPath = path;
+            OnRenderPropertiesUpdated();
         }
 
         public override string ToString()
         {
             return $"Layer - {nameof(Name)}: {Name}, {nameof(Order)}: {Order}";
         }
+
+        #region Events
+
+        public event EventHandler RenderPropertiesUpdated;
+
+        private void OnRenderPropertiesUpdated()
+        {
+            RenderPropertiesUpdated?.Invoke(this, EventArgs.Empty);
+        }
+
+        #endregion
     }
 }

src/Artemis.Core/Plugins/LayerElement/LayerElement.cs

@@ -27,21 +27,43 @@ namespace Artemis.Core.Plugins.LayerElement
         ///     Called before rendering every frame, write your update logic here
         /// </summary>
         /// <param name="deltaTime"></param>
-        public abstract void Update(double deltaTime);
+        public virtual void Update(double deltaTime)
+        {
+        }
 
         /// <summary>
-        ///     Called before rendering, in the order configured on the layer
+        ///     Allows you to perform rendering on the surface <see cref="SKCanvas" /> before any layer-clipping is applied
+        ///     <para>Called before rendering, in the order configured on the layer</para>
         /// </summary>
-        public abstract void RenderPreProcess(ArtemisSurface surface, SKCanvas canvas);
+        /// <param name="surface">The surface the layer is rendered on</param>
+        /// <param name="canvas">The entire surface canvas</param>
+        public virtual void RenderPreProcess(ArtemisSurface surface, SKCanvas canvas)
+        {
+        }
 
         /// <summary>
-        ///     Called during rendering, in the order configured on the layer
+        ///     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, in the order configured on the layer</para>
         /// </summary>
-        public abstract void Render(ArtemisSurface surface, SKCanvas canvas);
+        /// <param name="surface">The surface the layer is rendered on</param>
+        /// <param name="canvas">The layer canvas</param>
+        public virtual void Render(ArtemisSurface surface, SKCanvas canvas)
+        {
+        }
 
         /// <summary>
-        ///     Called after rendering, in the order configured on the layer
+        ///     Allows you to modify the <see cref="SKShader" /> used to draw the layer's <see cref="SKBitmap" /> on the
+        ///     <see cref="SKCanvas" />.
+        ///     <para>Called after rendering, in the order configured on the layer.</para>
         /// </summary>
-        public abstract void RenderPostProcess(ArtemisSurface surface, SKCanvas canvas);
+        /// <param name="surface">The surface the layer is rendered on</param>
+        /// <param name="bitmap">The bitmap created from the layer canvas</param>
+        /// <param name="shader">The current shader used to draw the bitmap on the surface canvas</param>
+        /// <returns>The resulting shader used to draw the bitmap on the surface canvas</returns>
+        public virtual SKShader RenderPostProcess(ArtemisSurface surface, SKBitmap bitmap, SKShader shader)
+        {
+            return shader;
+        }
     }
 }

src/Artemis.Plugins.LayerTypes.Brush/Artemis.Plugins.LayerElements.Brush.csproj

@@ -52,6 +52,7 @@
     </Reference>
     <Reference Include="SkiaSharp, Version=1.68.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756, processorArchitecture=MSIL">
       <HintPath>..\packages\SkiaSharp.1.68.1\lib\net45\SkiaSharp.dll</HintPath>
+      <Private>False</Private>
     </Reference>
     <Reference Include="Stylet, Version=1.3.0.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\Stylet.1.3.0\lib\net45\Stylet.dll</HintPath>

src/Artemis.Plugins.LayerTypes.Brush/BrushLayerElement.cs

@@ -1,4 +1,5 @@
-using Artemis.Core.Models.Profile;
+using System.Collections.Generic;
+using Artemis.Core.Models.Profile;
 using Artemis.Core.Models.Surface;
 using Artemis.Core.Plugins.LayerElement;
 using SkiaSharp;
@@ -7,9 +8,39 @@ namespace Artemis.Plugins.LayerElements.Brush
 {
     public class BrushLayerElement : LayerElement
     {
+        private SKShader _shader;
+        private List<SKColor> _testColors;
+
         public BrushLayerElement(Layer layer, BrushLayerElementSettings settings, LayerElementDescriptor descriptor) : base(layer, settings, descriptor)
         {
             Settings = settings ?? new BrushLayerElementSettings();
+
+            _testColors = new List<SKColor>();
+            for (var i = 0; i < 9; i++)
+            {
+                if (i != 8)
+                    _testColors.Add(SKColor.FromHsv(i * 32, 100, 100));
+                else
+                    _testColors.Add(SKColor.FromHsv(0, 100, 100));
+            }
+
+            CreateShader();
+            Layer.RenderPropertiesUpdated += (sender, args) => CreateShader();
+        }
+
+        private void CreateShader()
+        {
+            var shader = SKShader.CreateLinearGradient(
+                new SKPoint(0, 0),
+                new SKPoint(Layer.AbsoluteRenderRectangle.Width, 0),
+                _testColors.ToArray(),
+                null,
+                SKShaderTileMode.Clamp);
+
+            var oldShader = _shader;
+            _shader = shader;
+
+            oldShader?.Dispose();
         }
 
         public new BrushLayerElementSettings Settings { get; }
@@ -19,21 +50,12 @@ namespace Artemis.Plugins.LayerElements.Brush
             return new BrushLayerElementViewModel(this);
         }
 
-        public override void Update(double deltaTime)
-        {
-        }
-
-        public override void RenderPreProcess(ArtemisSurface surface, SKCanvas canvas)
-        {
-        }
-
         public override void Render(ArtemisSurface surface, SKCanvas canvas)
         {
-            canvas.DrawRect(Layer.RenderRectangle, new SKPaint {Color = new SKColor(255, 255, 255, 255)});
+            using (var paint = new SKPaint { Shader = _shader, FilterQuality = SKFilterQuality.Low })
-        }
+            {
-
+                canvas.DrawRect(Layer.AbsoluteRenderRectangle, paint);
-        public override void RenderPostProcess(ArtemisSurface surface, SKCanvas canvas)
+            }
-        {
         }
     }
 }

src/Artemis.Plugins.Modules.General/Artemis.Plugins.Modules.General.csproj

@@ -46,6 +46,7 @@
     </Reference>
     <Reference Include="SkiaSharp, Version=1.68.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756, processorArchitecture=MSIL">
       <HintPath>..\packages\SkiaSharp.1.68.1\lib\net45\SkiaSharp.dll</HintPath>
+      <Private>False</Private>
     </Reference>
     <Reference Include="Stylet, Version=1.3.0.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\Stylet.1.3.0\lib\net45\Stylet.dll</HintPath>

src/Artemis.Plugins.Modules.General/GeneralModule.cs

@@ -59,6 +59,9 @@ namespace Artemis.Plugins.Modules.General
 
         public override void Render(double deltaTime, ArtemisSurface surface, SKCanvas canvas)
         {
+            base.Render(deltaTime, surface, canvas);
+            return;
+
             foreach (var device in surface.Devices)
             {
                 using (var bitmap = new SKBitmap(new SKImageInfo((int) device.RenderRectangle.Width, (int) device.RenderRectangle.Height)))
@@ -66,7 +69,7 @@ namespace Artemis.Plugins.Modules.General
                     using (var layerCanvas = new SKCanvas(bitmap))
                     {
                         layerCanvas.Clear();
-                        SKShader shader = null;
+                        SKShader shader;
                         if (DeviceShaders.ContainsKey(device))
                             shader = DeviceShaders[device];
                         else
@@ -80,18 +83,19 @@ namespace Artemis.Plugins.Modules.General
                             DeviceShaders.Add(device, shader);
                         }
 
-                        layerCanvas.DrawRect(0, 0, device.RenderRectangle.Width, device.RenderRectangle.Height, new SKPaint {Shader = shader});
+                        using (var paint = new SKPaint {Shader = shader, FilterQuality = SKFilterQuality.Low})
+                        {
+                            layerCanvas.DrawRect(0, 0, device.RenderRectangle.Width, device.RenderRectangle.Height, paint);
+                        }
                     }
 
-                    var bitmapShader = SKShader.CreateBitmap(bitmap, SKShaderTileMode.Repeat, SKShaderTileMode.Repeat);
+                    using (var bitmapShader = SKShader.CreateBitmap(bitmap, SKShaderTileMode.Repeat, SKShaderTileMode.Repeat))
-
+                    using (var translated = SKShader.CreateLocalMatrix(bitmapShader, SKMatrix.MakeTranslation(device.RenderRectangle.Width / 100 * MovePercentage * -1, 0)))
-                    canvas.Save();
+                    using (var translatedPaint = new SKPaint {Shader = translated, FilterQuality = SKFilterQuality.Low})
-                    canvas.ClipRect(device.RenderRectangle);
+                    {
-
+                        // Here we can let each module modify the shader as needed
-                    var scaledRect = SKRect.Create(device.RenderRectangle.Left, device.RenderRectangle.Top, device.RenderRectangle.Width * 2, device.RenderRectangle.Height * 2);
+                        canvas.DrawRect(device.RenderRectangle, translatedPaint);
-                    canvas.Translate(device.RenderRectangle.Width / 100 * MovePercentage * -1, 0);
+                    }
-                    canvas.DrawRect(scaledRect, new SKPaint {Shader = bitmapShader});
-                    canvas.Restore();
                 }
             }
         }