Much more performance improvements

Artemis/Artemis/InjectionFactories/ILayerEditorVmFactory.cs

@@ -7,6 +7,6 @@ namespace Artemis.InjectionFactories
 {
     public interface ILayerEditorVmFactory
     {
-        LayerEditorViewModel CreateLayerEditorVm(IGameDataModel gameDataModel, LayerModel layer);
+        LayerEditorViewModel CreateLayerEditorVm(IDataModel dataModel, LayerModel layer);
     }
 }

Artemis/Artemis/Managers/LoopManager.cs

@@ -120,19 +120,29 @@ namespace Artemis.Managers
                     renderEffect.Update();
 
                 // Get ActiveEffect's bitmap
-                var bitmap = renderEffect.Initialized
+                Bitmap bitmap = null;
-                    ? renderEffect.GenerateBitmap()
+                System.Windows.Media.Brush mouseBrush = null;
-                    : null;
+                System.Windows.Media.Brush headsetBrush = null;
+                var mice = _deviceManager.MiceProviders.Where(m => m.CanUse).ToList();
+                var headsets = _deviceManager.HeadsetProviders.Where(m => m.CanUse).ToList();
 
-                // Draw enabled overlays on top
+                if (renderEffect.Initialized)
+                    renderEffect.Render(out bitmap, out mouseBrush, out headsetBrush, mice.Any(), headsets.Any());
+
+                // Draw enabled overlays on top of the renderEffect
                 foreach (var overlayModel in _effectManager.EnabledOverlays)
                 {
                     overlayModel.Update();
-                    bitmap = bitmap != null
+                    overlayModel.RenderOverlay(ref bitmap, ref mouseBrush, ref headsetBrush, mice.Any(), headsets.Any());
-                        ? overlayModel.GenerateBitmap(bitmap)
-                        : overlayModel.GenerateBitmap();
                 }
 
+                // Update mice and headsets
+                foreach (var mouse in mice)
+                    mouse.UpdateDevice(mouseBrush);
+                foreach (var headset in headsets)
+                    headset.UpdateDevice(headsetBrush);
+
+                // If no bitmap was generated this frame is done
                 if (bitmap == null)
                     return;
 
@@ -146,16 +156,8 @@ namespace Artemis.Managers
 
                 bitmap = fixedBmp;
 
-                // If it exists, send bitmap to the device
+                // Update the keyboard
                 _deviceManager.ActiveKeyboard?.DrawBitmap(bitmap);
-
-                foreach (var mouse in _deviceManager.MiceProviders.Where(m => m.CanUse))
-                    mouse.UpdateDevice(renderEffect.GenerateMouseBrush());
-                foreach (var headset in _deviceManager.HeadsetProviders.Where(h => h.CanUse))
-                    headset.UpdateDevice(renderEffect.GenerateHeadsetBrush());
-
-                // debugging TODO: Disable when window isn't shown (in Debug VM, or get rid of it, w/e)
-                //_events.PublishOnUIThread(new ChangeBitmap(bitmap));
             }
         }
     }

Artemis/Artemis/Managers/ProfileManager.cs

@@ -77,8 +77,8 @@ namespace Artemis.Managers
                 // LoopManager might be running, this method won't do any harm in that case.
                 _loopManager.Start();
 
-                if (!ReferenceEquals(ProfilePreviewModel.SelectedProfile, activePreview.ProfileEditor.SelectedProfile))
+                if (!ReferenceEquals(ProfilePreviewModel.Profile, activePreview.ProfileEditor.SelectedProfile))
-                    ProfilePreviewModel.SelectedProfile = activePreview.ProfileEditor.SelectedProfile;
+                    ProfilePreviewModel.Profile = activePreview.ProfileEditor.SelectedProfile;
             }
         }
     }

Artemis/Artemis/Models/EffectModel.cs

@@ -1,6 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.Drawing;
+using System.Linq;
 using Artemis.Managers;
+using Artemis.Models.Interfaces;
+using Artemis.Models.Profiles;
 using Brush = System.Windows.Media.Brush;
 
 namespace Artemis.Models
@@ -13,9 +17,10 @@ namespace Artemis.Models
         public MainManager MainManager;
         public string Name;
 
-        protected EffectModel(MainManager mainManager)
+        protected EffectModel(MainManager mainManager, IDataModel dataModel)
         {
             MainManager = mainManager;
+            DataModel = dataModel;
         }
 
         public abstract void Dispose();
@@ -23,13 +28,33 @@ namespace Artemis.Models
         // Called on creation
         public abstract void Enable();
 
-        // Called every iteration
+        // Called every frame
         public abstract void Update();
 
-        // Called after every update
+        public IDataModel DataModel { get; set; }
-        public abstract Bitmap GenerateBitmap();
+        public ProfileModel Profile { get; set; }
 
-        public abstract Brush GenerateMouseBrush();
+        // Called after every update
-        public abstract Brush GenerateHeadsetBrush();
+        public virtual void Render(out Bitmap keyboard, out Brush mouse, out Brush headset, bool renderMice, bool renderHeadsets)
+        {
+            keyboard = null;
+            mouse = null;
+            headset = null;
+
+            if (Profile == null || DataModel == null)
+                return;
+
+            // Get all enabled layers who's conditions are met
+            var renderLayers = GetRenderLayers(renderMice, renderHeadsets);
+
+            // Render the keyboard layer-by-layer
+            keyboard = Profile.GenerateBitmap(renderLayers, DataModel, MainManager.DeviceManager.ActiveKeyboard.KeyboardRectangle(4), false, true);
+            // Render the first enabled mouse (will default to null if renderMice was false)
+            mouse = Profile.GenerateBrush(renderLayers.FirstOrDefault(l => l.LayerType == LayerType.Mouse), DataModel);
+            // Render the first enabled headset (will default to null if renderHeadsets was false)
+            headset = Profile.GenerateBrush(renderLayers.FirstOrDefault(l => l.LayerType == LayerType.Headset), DataModel);
+        }
+
+        public abstract List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets);
     }
 }

Artemis/Artemis/Models/GameModel.cs

@@ -1,22 +1,19 @@
-using Artemis.Managers;
+using System.Collections.Generic;
+using Artemis.Managers;
 using Artemis.Models.Interfaces;
 using Artemis.Models.Profiles;
-using Artemis.Modules.Games.RocketLeague;
 
 namespace Artemis.Models
 {
     public abstract class GameModel : EffectModel
     {
-        protected GameModel(MainManager mainManager, GameSettings settings, IGameDataModel gameDataModel) : base(mainManager)
+        protected GameModel(MainManager mainManager, GameSettings settings, IDataModel dataModel) : base(mainManager, dataModel)
         {
             Settings = settings;
-            GameDataModel = gameDataModel;
         }
 
         public GameSettings Settings { get; set; }
         public bool Enabled { get; set; }
         public string ProcessName { get; set; }
-        public IGameDataModel GameDataModel { get; set; }
-        public ProfileModel Profile { get; set; }
     }
 }

Artemis/Artemis/Models/Interfaces/GameDataModel.cs

@@ -1,6 +1,6 @@
 namespace Artemis.Models.Interfaces
 {
-    public interface IGameDataModel
+    public interface IDataModel
     {
     }
 }

Artemis/Artemis/Models/OverlayModel.cs

@@ -1,5 +1,6 @@
 using System.Drawing;
 using Artemis.Managers;
+using Brush = System.Windows.Media.Brush;
 
 namespace Artemis.Models
 {
@@ -8,7 +9,7 @@ namespace Artemis.Models
         private bool _enabled;
         public string ProcessName;
 
-        protected OverlayModel(MainManager mainManager) : base(mainManager)
+        protected OverlayModel(MainManager mainManager) : base(mainManager, null)
         {
         }
 
@@ -28,6 +29,7 @@ namespace Artemis.Models
             }
         }
 
-        public abstract Bitmap GenerateBitmap(Bitmap bitmap);
+        public abstract void RenderOverlay(ref Bitmap keyboard, ref Brush mouse, ref Brush headset, bool renderMice,
+            bool renderHeadsets);
     }
 }

Artemis/Artemis/Models/Profiles/LayerConditionModel.cs

@@ -12,7 +12,7 @@ namespace Artemis.Models.Profiles
         public string Operator { get; set; }
         public string Type { get; set; }
 
-        public bool ConditionMet<T>(IGameDataModel subject)
+        public bool ConditionMet<T>(IDataModel subject)
         {
             if (string.IsNullOrEmpty(Field) || string.IsNullOrEmpty(Value) || string.IsNullOrEmpty(Type))
                 return false;

Artemis/Artemis/Models/Profiles/LayerModel.cs

@@ -38,51 +38,31 @@ namespace Artemis.Models.Profiles
         [XmlIgnore]
         public GifImage GifImage { get; set; }
 
-        public bool ConditionsMet<T>(IGameDataModel dataModel)
+        public bool ConditionsMet<T>(IDataModel dataModel)
         {
             return Enabled && Properties.Conditions.All(cm => cm.ConditionMet<T>(dataModel));
         }
 
-        public void Draw<T>(IGameDataModel dataModel, DrawingContext c, bool preview, bool updateAnimations)
+        public void Draw(IDataModel dataModel, DrawingContext c, bool preview, bool updateAnimations)
         {
-            // Don't draw when the layer is disabled
+            if (LayerType != LayerType.Keyboard && LayerType != LayerType.KeyboardGif)
-            if (!Enabled)
                 return;
 
             // Preview simply shows the properties as they are. When not previewing they are applied
-            AppliedProperties appliedProperties;
+            var appliedProperties = !preview
-            if (!preview)
+                ? Properties.GetAppliedProperties(dataModel)
-            {
+                : Properties.GetAppliedProperties(dataModel, true);
-                if (!ConditionsMet<T>(dataModel))
-                    return; // Don't draw the layer when not previewing and the conditions arent met
-                appliedProperties = Properties.GetAppliedProperties(dataModel);
-            }
-            else
-                appliedProperties = Properties.GetAppliedProperties(dataModel, true);
 
-            // Update animations on layer types that support them
+            // Update animations
-            if (LayerType == LayerType.Keyboard || LayerType == LayerType.KeyboardGif)
+            AnimationUpdater.UpdateAnimation((KeyboardPropertiesModel) Properties, updateAnimations);
-            {
+            
-                AnimationUpdater.UpdateAnimation((KeyboardPropertiesModel) Properties, updateAnimations);
+            if (LayerType == LayerType.Keyboard)
-            }
+                Drawer.Draw(c, (KeyboardPropertiesModel) Properties, appliedProperties);
-
+            else if (LayerType == LayerType.KeyboardGif)
-            switch (LayerType)
+                GifImage = Drawer.DrawGif(c, (KeyboardPropertiesModel) Properties, appliedProperties, GifImage);
-            {
-                // Folders are drawn recursively
-                case LayerType.Folder:
-                    foreach (var layerModel in Children.OrderByDescending(l => l.Order))
-                        layerModel.Draw<T>(dataModel, c, preview, updateAnimations);
-                    break;
-                case LayerType.Keyboard:
-                    Drawer.Draw(c, (KeyboardPropertiesModel) Properties, appliedProperties);
-                    break;
-                case LayerType.KeyboardGif:
-                    GifImage = Drawer.DrawGif(c, (KeyboardPropertiesModel)Properties, appliedProperties, GifImage);
-                    break;
-            }
         }
 
-        public Brush GenerateBrush<T>(LayerType type, IGameDataModel dataModel, bool preview, bool updateAnimations)
+        public Brush GenerateBrush<T>(LayerType type, IDataModel dataModel, bool preview, bool updateAnimations)
         {
             if (!Enabled)
                 return null;
@@ -249,6 +229,39 @@ namespace Artemis.Models.Profiles
         }
 
         #endregion
+
+        /// <summary>
+        ///     Generates a flat list containing all layers that must be rendered on the keyboard,
+        ///     the first mouse layer to be rendered and the first headset layer to be rendered
+        /// </summary>
+        /// <typeparam name="T">The game data model to base the conditions on</typeparam>
+        /// <param name="dataModel">Instance of said game data model</param>
+        /// <param name="includeMice">Whether or not to include mice in the list</param>
+        /// <param name="includeHeadsets">Whether or not to include headsets in the list</param>
+        /// <param name="ignoreConditions"></param>
+        /// <returns>A flat list containing all layers that must be rendered</returns>
+        public List<LayerModel> GetRenderLayers<T>(IDataModel dataModel, bool includeMice, bool includeHeadsets, bool ignoreConditions = false)
+        {
+            var layers = new List<LayerModel>();
+            foreach (var layerModel in Children.OrderByDescending(c => c.Order))
+            {
+                if (!layerModel.Enabled ||
+                    !includeMice && layerModel.LayerType == LayerType.Mouse ||
+                    !includeHeadsets && layerModel.LayerType == LayerType.Headset)
+                    continue;
+
+                if (!ignoreConditions)
+                {
+                    if (!layerModel.ConditionsMet<T>(dataModel))
+                        continue;
+                }
+
+                layers.Add(layerModel);
+                layers.AddRange(layerModel.GetRenderLayers<T>(dataModel, includeMice, includeHeadsets, ignoreConditions));
+            }
+
+            return layers;
+        }
     }
 
     public enum LayerType

Artemis/Artemis/Models/Profiles/ProfileModel.cs

@@ -66,7 +66,7 @@ namespace Artemis.Models.Profiles
                 Layers[i].Order = i;
         }
 
-        public Bitmap GenerateBitmap<T>(Rect keyboardRect, IGameDataModel gameDataModel, bool preview,
+        public Bitmap GenerateBitmap<T>(Rect keyboardRect, IDataModel dataModel, bool preview,
             bool updateAnimations)
         {
             var visual = new DrawingVisual();
@@ -78,22 +78,22 @@ namespace Artemis.Models.Profiles
 
                 // Draw the layers
                 foreach (var layerModel in Layers.OrderByDescending(l => l.Order))
-                    layerModel.Draw<T>(gameDataModel, c, preview, updateAnimations);
+                    layerModel.Draw(dataModel, c, preview, updateAnimations);
 
                 // Remove the clip
                 c.Pop();
             }
 
-            return ImageUtilities.DrawinVisualToBitmap(visual, keyboardRect); 
+            return ImageUtilities.DrawinVisualToBitmap(visual, keyboardRect);
         }
 
-        public Brush GenerateBrush<T>(IGameDataModel gameDataModel, LayerType type, bool preview, bool updateAnimations)
+        public Brush GenerateBrush<T>(IDataModel dataModel, LayerType type, bool preview, bool updateAnimations)
         {
             Brush result = null;
             // Draw the layers
             foreach (var layerModel in Layers.OrderByDescending(l => l.Order))
             {
-                var generated = layerModel.GenerateBrush<T>(type, gameDataModel, preview, updateAnimations);
+                var generated = layerModel.GenerateBrush<T>(type, dataModel, preview, updateAnimations);
                 if (generated != null)
                     result = generated;
             }
@@ -116,6 +116,39 @@ namespace Artemis.Models.Profiles
             return layers;
         }
 
+        /// <summary>
+        ///     Generates a flat list containing all layers that must be rendered on the keyboard,
+        ///     the first mouse layer to be rendered and the first headset layer to be rendered
+        /// </summary>
+        /// <typeparam name="T">The game data model to base the conditions on</typeparam>
+        /// <param name="dataModel">Instance of said game data model</param>
+        /// <param name="includeMice">Whether or not to include mice in the list</param>
+        /// <param name="includeHeadsets">Whether or not to include headsets in the list</param>
+        /// <param name="ignoreConditions"></param>
+        /// <returns>A flat list containing all layers that must be rendered</returns>
+        public List<LayerModel> GetRenderLayers<T>(IDataModel dataModel, bool includeMice, bool includeHeadsets, bool ignoreConditions = false)
+        {
+            var layers = new List<LayerModel>();
+            foreach (var layerModel in Layers.OrderByDescending(l => l.Order))
+            {
+                if (!layerModel.Enabled ||
+                    !includeMice && layerModel.LayerType == LayerType.Mouse ||
+                    !includeHeadsets && layerModel.LayerType == LayerType.Headset)
+                    continue;
+
+                if (!ignoreConditions)
+                {
+                    if (!layerModel.ConditionsMet<T>(dataModel))
+                        continue;
+                }
+
+                layers.Add(layerModel);
+                layers.AddRange(layerModel.GetRenderLayers<T>(dataModel, includeMice, includeHeadsets, ignoreConditions));
+            }
+
+            return layers;
+        }
+
         /// <summary>
         ///     Looks at all the layers wthin the profile and makes sure they are within boundaries of the given rectangle
         /// </summary>
@@ -137,5 +170,51 @@ namespace Artemis.Models.Profiles
                 layer.Properties = props;
             }
         }
+
+        /// <summary>
+        ///     Generates a bitmap showing all the provided layers of type Keyboard and KeyboardGif
+        /// </summary>
+        /// <param name="renderLayers">The layers to render</param>
+        /// <param name="dataModel">The data model to base the layer's properties on</param>
+        /// <param name="keyboardRect">A rectangle matching the current keyboard's size on a scale of 4, used for clipping</param>
+        /// <param name="preview">Indicates wheter the layer is drawn as a preview, ignoring dynamic properties</param>
+        /// <param name="updateAnimations">Wheter or not to update the layer's animations</param>
+        /// <returns>The generated bitmap</returns>
+        internal Bitmap GenerateBitmap(List<LayerModel> renderLayers, IDataModel dataModel, Rect keyboardRect,
+            bool preview,
+            bool updateAnimations)
+        {
+            var visual = new DrawingVisual();
+            using (var c = visual.RenderOpen())
+            {
+                // Setup the DrawingVisual's size
+                c.PushClip(new RectangleGeometry(keyboardRect));
+                c.DrawRectangle(new SolidColorBrush(Color.FromArgb(0, 0, 0, 0)), null, keyboardRect);
+
+                // Draw the layers
+                foreach (var layerModel in renderLayers
+                    .Where(l => l.LayerType == LayerType.Keyboard ||
+                                l.LayerType == LayerType.KeyboardGif))
+                {
+                    layerModel.Draw(dataModel, c, preview, updateAnimations);
+                }
+
+                // Remove the clip
+                c.Pop();
+            }
+
+            return ImageUtilities.DrawinVisualToBitmap(visual, keyboardRect);
+        }
+
+        /// <summary>
+        ///     Generates a brush out of the given layer, for usage with mice and headsets
+        /// </summary>
+        /// <param name="layerModel">The layer to base the brush on</param>
+        /// <param name="dataModel">The game data model to base the layer's properties on</param>
+        /// <returns>The generated brush</returns>
+        public Brush GenerateBrush(LayerModel layerModel, IDataModel dataModel)
+        {
+            return layerModel?.Properties.GetAppliedProperties(dataModel).Brush;
+        }
     }
 }

Artemis/Artemis/Models/Profiles/Properties/DynamicPropertiesModel.cs

@@ -37,7 +37,7 @@ namespace Artemis.Models.Profiles.Properties
         /// </summary>
         public LayerPropertyOptions LayerPropertyOptions { get; set; }
 
-        internal void ApplyProperty(IGameDataModel dataModel, AppliedProperties properties)
+        internal void ApplyProperty(IDataModel dataModel, AppliedProperties properties)
         {
             if (LayerPropertyType == LayerPropertyType.PercentageOf)
                 ApplyPercentageOf(dataModel, properties, PercentageSource);
@@ -45,7 +45,7 @@ namespace Artemis.Models.Profiles.Properties
                 ApplyPercentageOfProperty(dataModel, properties);
         }
 
-        private void ApplyPercentageOf(IGameDataModel dataModel, AppliedProperties properties, double src)
+        private void ApplyPercentageOf(IDataModel dataModel, AppliedProperties properties, double src)
         {
             if (GameProperty == null)
                 return;
@@ -95,7 +95,7 @@ namespace Artemis.Models.Profiles.Properties
                 properties.Opacity = 1.0 - properties.Opacity;
         }
 
-        private void ApplyPercentageOfProperty(IGameDataModel dataModel, AppliedProperties properties)
+        private void ApplyPercentageOfProperty(IDataModel dataModel, AppliedProperties properties)
         {
             var value = dataModel.GetPropValue<int>(PercentageProperty);
             ApplyPercentageOf(dataModel, properties, value);

Artemis/Artemis/Models/Profiles/Properties/FolderPropertiesModel.cs

@@ -5,7 +5,7 @@ namespace Artemis.Models.Profiles.Properties
 {
     public class FolderPropertiesModel : LayerPropertiesModel
     {
-        public override AppliedProperties GetAppliedProperties(IGameDataModel dataModel, bool ignoreDynamic = false)
+        public override AppliedProperties GetAppliedProperties(IDataModel dataModel, bool ignoreDynamic = false)
         {
             return new AppliedProperties();
         }

Artemis/Artemis/Models/Profiles/Properties/HeadsetPropertiesModel.cs

@@ -4,9 +4,9 @@ namespace Artemis.Models.Profiles.Properties
 {
     public class HeadsetPropertiesModel : LayerPropertiesModel
     {
-        public override AppliedProperties GetAppliedProperties(IGameDataModel dataModel, bool ignoreDynamic = false)
+        public override AppliedProperties GetAppliedProperties(IDataModel dataModel, bool ignoreDynamic = false)
         {
-            return new AppliedProperties();
+            return new AppliedProperties {Brush = Brush};
         }
     }
 }

Artemis/Artemis/Models/Profiles/Properties/KeyboardPropertiesModel.cs

@@ -35,7 +35,7 @@ namespace Artemis.Models.Profiles.Properties
             return new Rect(X*scale, Y*scale, Width*scale, Height*scale);
         }
 
-        public override AppliedProperties GetAppliedProperties(IGameDataModel dataModel, bool ignoreDynamic = false)
+        public override AppliedProperties GetAppliedProperties(IDataModel dataModel, bool ignoreDynamic = false)
         {
             var applied = new AppliedProperties
             {

Artemis/Artemis/Models/Profiles/Properties/LayerPropertiesModel.cs

@@ -49,7 +49,7 @@ namespace Artemis.Models.Profiles.Properties
             }
         }
 
-        public abstract AppliedProperties GetAppliedProperties(IGameDataModel dataModel, bool ignoreDynamic = false);
+        public abstract AppliedProperties GetAppliedProperties(IDataModel dataModel, bool ignoreDynamic = false);
     }
 
     public struct AppliedProperties

Artemis/Artemis/Models/Profiles/Properties/MousePropertiesModel.cs

@@ -4,9 +4,9 @@ namespace Artemis.Models.Profiles.Properties
 {
     public class MousePropertiesModel : LayerPropertiesModel
     {
-        public override AppliedProperties GetAppliedProperties(IGameDataModel dataModel, bool ignoreDynamic = false)
+        public override AppliedProperties GetAppliedProperties(IDataModel dataModel, bool ignoreDynamic = false)
         {
-            return new AppliedProperties();
+            return new AppliedProperties { Brush = Brush };
         }
     }
 }

Artemis/Artemis/Modules/Effects/AmbientLightning/AmbientLightningEffectModel.cs

@@ -1,15 +1,12 @@
 using System.Collections.Generic;
 using System.Drawing;
 using System.Drawing.Drawing2D;
-using System.IO;
 using System.Linq;
 using System.Windows.Forms;
 using Artemis.Managers;
 using Artemis.Models;
+using Artemis.Models.Profiles;
 using Artemis.Utilities.Keyboard;
-using Kaliko.ImageLibrary;
-using Kaliko.ImageLibrary.Filters;
-using Brush = System.Windows.Media.Brush;
 
 namespace Artemis.Modules.Effects.AmbientLightning
 {
@@ -22,7 +19,7 @@ namespace Artemis.Modules.Effects.AmbientLightning
         private KeyboardRectangle _topRect;
 
         public AmbientLightningEffectModel(MainManager mainManager, AmbientLightningEffectSettings settings)
-            : base(mainManager)
+            : base(mainManager, null)
         {
             Name = "Ambient Lightning";
             Settings = settings;
@@ -115,33 +112,7 @@ namespace Artemis.Modules.Effects.AmbientLightning
             }
         }
 
-        public override Bitmap GenerateBitmap()
+        public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
-        {
-            var bitmap = MainManager.DeviceManager.ActiveKeyboard.KeyboardBitmap(Scale);
-            using (var g = Graphics.FromImage(bitmap))
-            {
-                var i = 0;
-                foreach (var rectangle in _rectangles)
-                {
-                    g.FillRectangle(new SolidBrush(_colors[i]), rectangle);
-                    i++;
-                }
-            }
-
-            var test = new KalikoImage(bitmap);
-            test.ApplyFilter(new GaussianBlurFilter(8f));
-            var ms = new MemoryStream();
-            test.SaveBmp(ms);
-            ms.Position = 0;
-            return new Bitmap(ms);
-        }
-
-        public override Brush GenerateMouseBrush()
-        {
-            return null;
-        }
-
-        public override Brush GenerateHeadsetBrush()
         {
             return null;
         }

Artemis/Artemis/Modules/Effects/AudioVisualizer/AudioVisualizerModel.cs

@@ -5,6 +5,7 @@ using System.Drawing.Drawing2D;
 using System.Linq;
 using Artemis.Managers;
 using Artemis.Models;
+using Artemis.Models.Profiles;
 using Artemis.Modules.Effects.AudioVisualizer.Utilities;
 using Artemis.Utilities;
 using Artemis.Utilities.Keyboard;
@@ -23,7 +24,7 @@ namespace Artemis.Modules.Effects.AudioVisualizer
         private int _sensitivity;
         private IWaveIn _waveIn;
 
-        public AudioVisualizerModel(MainManager mainManager, AudioVisualizerSettings settings) : base(mainManager)
+        public AudioVisualizerModel(MainManager mainManager, AudioVisualizerSettings settings) : base(mainManager, null)
         {
             Settings = settings;
             Name = "Audiovisualizer";
@@ -137,38 +138,7 @@ namespace Artemis.Modules.Effects.AudioVisualizer
             }
             _generating = false;
         }
-
+        
-        public override Bitmap GenerateBitmap()
-        {
-            if (SpectrumData == null || SoundRectangles == null)
-                return null;
-
-            // Lock the _spectrumData array while busy with it
-            _generating = true;
-
-            var bitmap = MainManager.DeviceManager.ActiveKeyboard.KeyboardBitmap(Scale);
-            using (var g = Graphics.FromImage(bitmap))
-            {
-                foreach (var soundRectangle in SoundRectangles)
-                    soundRectangle.Draw(g);
-            }
-
-            _generating = false;
-            return bitmap;
-        }
-
-        // TODO: Brush according to avg volume
-        public override Brush GenerateMouseBrush()
-        {
-            return null;
-        }
-
-        // TODO: Brush according to avg volume left/right
-        public override Brush GenerateHeadsetBrush()
-        {
-            return null;
-        }
-
         private void OnDataAvailable(object sender, WaveInEventArgs e)
         {
             var buffer = e.Buffer;
@@ -212,5 +182,32 @@ namespace Artemis.Modules.Effects.AudioVisualizer
                 SpectrumData.Add((byte) y);
             }
         }
+
+        public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
+        {
+            return null;
+        }
+
+        public override void Render(out Bitmap keyboard, out Brush mouse, out Brush headset, bool renderMice, bool renderHeadsets)
+        {
+            keyboard = null;
+            mouse = null;
+            headset = null;
+
+            if (SpectrumData == null || SoundRectangles == null)
+                return;
+
+            // Lock the _spectrumData array while busy with it
+            _generating = true;
+
+            keyboard = MainManager.DeviceManager.ActiveKeyboard.KeyboardBitmap(Scale);
+            using (var g = Graphics.FromImage(keyboard))
+            {
+                foreach (var soundRectangle in SoundRectangles)
+                    soundRectangle.Draw(g);
+            }
+
+            _generating = false;
+        }
     }
 }

Artemis/Artemis/Modules/Effects/Debug/DebugEffectModel.cs

@@ -3,6 +3,7 @@ using System.Drawing;
 using System.Drawing.Drawing2D;
 using Artemis.Managers;
 using Artemis.Models;
+using Artemis.Models.Profiles;
 using Artemis.Utilities.Keyboard;
 using Brush = System.Windows.Media.Brush;
 
@@ -11,7 +12,7 @@ namespace Artemis.Modules.Effects.Debug
     // TODO: Remove
     internal class DebugEffectModel : EffectModel
     {
-        public DebugEffectModel(MainManager mainManager, DebugEffectSettings settings) : base(mainManager)
+        public DebugEffectModel(MainManager mainManager, DebugEffectSettings settings) : base(mainManager, null)
         {
             Name = "Debug Effect";
             Settings = settings;
@@ -53,26 +54,22 @@ namespace Artemis.Modules.Effects.Debug
             Scale = Settings.Scale;
         }
 
-        public override Bitmap GenerateBitmap()
+        public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
         {
-            var bitmap = new Bitmap(21*Scale, 6*Scale);
+            return null;
+        }
 
-            using (var g = Graphics.FromImage(bitmap))
+        public override void Render(out Bitmap keyboard, out Brush mouse, out Brush headset, bool renderMice, bool renderHeadsets)
+        {
+            mouse = null;
+            headset = null;
+
+            keyboard = MainManager.DeviceManager.ActiveKeyboard.KeyboardBitmap(Scale);
+            using (var g = Graphics.FromImage(keyboard))
             {
                 g.Clear(Color.Transparent);
                 KeyboardRectangle.Draw(g);
             }
-            return bitmap;
-        }
-
-        public override Brush GenerateMouseBrush()
-        {
-            return null;
-        }
-
-        public override Brush GenerateHeadsetBrush()
-        {
-            return null;
         }
     }
 }

Artemis/Artemis/Modules/Effects/ProfilePreview/ProfilePreviewModel.cs

@@ -1,4 +1,6 @@
-using System.Drawing;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
 using Artemis.Managers;
 using Artemis.Models;
 using Artemis.Models.Interfaces;
@@ -9,20 +11,14 @@ namespace Artemis.Modules.Effects.ProfilePreview
 {
     public class ProfilePreviewModel : EffectModel
     {
-        private readonly ProfilePreviewDataModel _previewDataModel;
+        public ProfilePreviewModel(MainManager mainManager) : base(mainManager, new ProfilePreviewDataModel())
-
-        public ProfilePreviewModel(MainManager mainManager) : base(mainManager)
         {
             Name = "Profile Preview";
-            _previewDataModel = new ProfilePreviewDataModel();
         }
 
-        public ProfileModel SelectedProfile { get; set; }
-
         public override void Dispose()
         {
             Initialized = false;
-            SelectedProfile = null;
         }
 
         public override void Enable()
@@ -34,39 +30,33 @@ namespace Artemis.Modules.Effects.ProfilePreview
         {
         }
 
-        public override Bitmap GenerateBitmap()
+        public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
         {
-            if (MainManager.DeviceManager.ActiveKeyboard == null)
+            return Profile.GetRenderLayers<ProfilePreviewDataModel>(DataModel, renderMice, renderHeadsets, true);
-                return null;
-            var bitmap = MainManager.DeviceManager.ActiveKeyboard.KeyboardBitmap(4);
-
-            if (SelectedProfile == null)
-                return bitmap;
-
-            var keyboardRect = MainManager.DeviceManager.ActiveKeyboard.KeyboardRectangle(4);
-            var image = SelectedProfile.GenerateBitmap<ProfilePreviewDataModel>(keyboardRect, _previewDataModel, true, true);
-            if (image == null)
-                return null;
-
-            // Draw on top of everything else
-            using (var g = Graphics.FromImage(bitmap))
-                g.DrawImage(image, 0, 0);
-
-            return bitmap;
         }
 
-        public override Brush GenerateMouseBrush()
+        public override void Render(out Bitmap keyboard, out Brush mouse, out Brush headset, bool renderMice, bool renderHeadsets)
         {
-            return SelectedProfile?.GenerateBrush<ProfilePreviewDataModel>(_previewDataModel, LayerType.Mouse,  true, true);
+            keyboard = null;
-        }
+            mouse = null;
+            headset = null;
 
-        public override Brush GenerateHeadsetBrush()
+            if (Profile == null || DataModel == null)
-        {
+                return;
-            return SelectedProfile?.GenerateBrush<ProfilePreviewDataModel>(_previewDataModel, LayerType.Headset, true, true);
+
+            // Get all enabled layers who's conditions are met
+            var renderLayers = GetRenderLayers(renderMice, renderHeadsets);
+
+            // Render the keyboard layer-by-layer
+            keyboard = Profile.GenerateBitmap(renderLayers, DataModel, MainManager.DeviceManager.ActiveKeyboard.KeyboardRectangle(4), true, true);
+            // Render the first enabled mouse (will default to null if renderMice was false)
+            mouse = Profile.GenerateBrush(renderLayers.FirstOrDefault(l => l.LayerType == LayerType.Mouse), DataModel);
+            // Render the first enabled headset (will default to null if renderHeadsets was false)
+            headset = Profile.GenerateBrush(renderLayers.FirstOrDefault(l => l.LayerType == LayerType.Headset), DataModel);
         }
     }
 
-    public class ProfilePreviewDataModel : IGameDataModel
+    public class ProfilePreviewDataModel : IDataModel
     {
     }
 }

Artemis/Artemis/Modules/Effects/TypeWave/TypeWaveModel.cs

@@ -7,6 +7,7 @@ using Artemis.DeviceProviders.Corsair;
 using Artemis.DeviceProviders.Logitech.Utilities;
 using Artemis.Managers;
 using Artemis.Models;
+using Artemis.Models.Profiles;
 using Artemis.Utilities;
 using Brush = System.Windows.Media.Brush;
 
@@ -17,7 +18,7 @@ namespace Artemis.Modules.Effects.TypeWave
         private readonly List<Wave> _waves;
         private Color _randomColor;
 
-        public TypeWaveModel(MainManager mainManager, TypeWaveSettings settings) : base(mainManager)
+        public TypeWaveModel(MainManager mainManager, TypeWaveSettings settings) : base(mainManager, null)
         {
             Name = "TypeWave";
             _waves = new List<Wave>();
@@ -92,13 +93,22 @@ namespace Artemis.Modules.Effects.TypeWave
             }
         }
 
-        public override Bitmap GenerateBitmap()
+        public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
         {
-            if (_waves.Count == 0)
+            return null;
-                return null;
+        }
 
-            var bitmap = MainManager.DeviceManager.ActiveKeyboard.KeyboardBitmap(Scale);
+        public override void Render(out Bitmap keyboard, out Brush mouse, out Brush headset, bool renderMice, bool renderHeadsets)
-            using (var g = Graphics.FromImage(bitmap))
+        {
+            keyboard = null;
+            mouse = null;
+            headset = null;
+
+            if (_waves.Count == 0)
+                return;
+
+            keyboard = MainManager.DeviceManager.ActiveKeyboard.KeyboardBitmap(Scale);
+            using (var g = Graphics.FromImage(keyboard))
             {
                 g.Clear(Color.Transparent);
                 g.SmoothingMode = SmoothingMode.HighQuality;
@@ -110,7 +120,7 @@ namespace Artemis.Modules.Effects.TypeWave
                     if (_waves[i].Size == 0)
                         continue;
                     var path = new GraphicsPath();
-                    path.AddEllipse(_waves[i].Point.X - _waves[i].Size/2, _waves[i].Point.Y - _waves[i].Size/2,
+                    path.AddEllipse(_waves[i].Point.X - _waves[i].Size / 2, _waves[i].Point.Y - _waves[i].Size / 2,
                         _waves[i].Size, _waves[i].Size);
 
                     Color fillColor;
@@ -121,7 +131,7 @@ namespace Artemis.Modules.Effects.TypeWave
 
                     var pthGrBrush = new PathGradientBrush(path)
                     {
-                        SurroundColors = new[] {_waves[i].Color},
+                        SurroundColors = new[] { _waves[i].Color },
                         CenterColor = fillColor
                     };
 
@@ -129,21 +139,10 @@ namespace Artemis.Modules.Effects.TypeWave
                     pthGrBrush.FocusScales = new PointF(0.3f, 0.8f);
 
                     g.FillPath(pthGrBrush, path);
-                    g.DrawEllipse(new Pen(pthGrBrush, 1), _waves[i].Point.X - _waves[i].Size/2,
+                    g.DrawEllipse(new Pen(pthGrBrush, 1), _waves[i].Point.X - _waves[i].Size / 2,
-                        _waves[i].Point.Y - _waves[i].Size/2, _waves[i].Size, _waves[i].Size);
+                        _waves[i].Point.Y - _waves[i].Size / 2, _waves[i].Size, _waves[i].Size);
                 }
             }
-            return bitmap;
-        }
-
-        public override Brush GenerateMouseBrush()
-        {
-            return null;
-        }
-
-        public override Brush GenerateHeadsetBrush()
-        {
-            return null;
         }
     }
 

Artemis/Artemis/Modules/Games/CounterStrike/CounterStrikeDataModel.cs

@@ -2,7 +2,7 @@
 
 namespace Artemis.Modules.Games.CounterStrike
 {
-    public class CounterStrikeDataModel : IGameDataModel
+    public class CounterStrikeDataModel : IDataModel
     {
         public Provider provider { get; set; }
         public Map map { get; set; }

Artemis/Artemis/Modules/Games/CounterStrike/CounterStrikeModel.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.Drawing;
+using System.Linq;
 using Artemis.Managers;
 using Artemis.Models;
 using Artemis.Models.Profiles;
@@ -44,31 +46,6 @@ namespace Artemis.Modules.Games.CounterStrike
             // TODO: Set up active weapon in the datamodel
         }
 
-        public override Bitmap GenerateBitmap()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-
-            var keyboardRect = MainManager.DeviceManager.ActiveKeyboard.KeyboardRectangle(Scale);
-            return Profile.GenerateBitmap<CounterStrikeDataModel>(keyboardRect, GameDataModel, false, true);
-        }
-
-        public override Brush GenerateMouseBrush()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-
-            return Profile.GenerateBrush<CounterStrikeDataModel>(GameDataModel, LayerType.Mouse, false, true);
-        }
-
-        public override Brush GenerateHeadsetBrush()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-
-            return Profile.GenerateBrush<CounterStrikeDataModel>(GameDataModel, LayerType.Headset,  false, true);
-        }
-
         public void HandleGameData(object sender, GameDataReceivedEventArgs e)
         {
             var jsonString = e.Json.ToString();
@@ -80,7 +57,7 @@ namespace Artemis.Modules.Games.CounterStrike
             // Parse the JSON
             try
             {
-                GameDataModel = JsonConvert.DeserializeObject<CounterStrikeDataModel>(jsonString);
+                DataModel = JsonConvert.DeserializeObject<CounterStrikeDataModel>(jsonString);
             }
             catch (Exception ex)
             {
@@ -89,5 +66,10 @@ namespace Artemis.Modules.Games.CounterStrike
             }
             
         }
+
+        public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
+        {
+            return Profile.GetRenderLayers<CounterStrikeDataModel>(DataModel, renderMice, renderHeadsets);
+        }
     }
 }

Artemis/Artemis/Modules/Games/Dota2/Dota2DataModel.cs

@@ -2,7 +2,7 @@
 
 namespace Artemis.Modules.Games.Dota2
 {
-    public class Dota2DataModel : IGameDataModel
+    public class Dota2DataModel : IDataModel
     {
         public Provider provider { get; set; }
         public Map map { get; set; }

Artemis/Artemis/Modules/Games/Dota2/Dota2Model.cs

@@ -1,10 +1,9 @@
-using System.Drawing;
+using System.Collections.Generic;
 using Artemis.Managers;
 using Artemis.Models;
 using Artemis.Models.Profiles;
 using Artemis.Utilities.GameState;
 using Newtonsoft.Json;
-using Brush = System.Windows.Media.Brush;
 
 namespace Artemis.Modules.Games.Dota2
 {
@@ -45,38 +44,12 @@ namespace Artemis.Modules.Games.Dota2
 
         private void UpdateDay()
         {
-            var dataModel = GameDataModel as Dota2DataModel;
+            var dataModel = DataModel as Dota2DataModel;
             if (dataModel?.map?.daytime == null)
                 return;
 
             var timeLeft = 240 - dataModel.map.clock_time%240;
-            dataModel.map.dayCyclePercentage = (int) (100.00 / 240 * timeLeft);
+            dataModel.map.dayCyclePercentage = (int) (100.00/240*timeLeft);
-        }
-
-
-        public override Bitmap GenerateBitmap()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-
-            var keyboardRect = MainManager.DeviceManager.ActiveKeyboard.KeyboardRectangle(Scale);
-            return Profile.GenerateBitmap<Dota2DataModel>(keyboardRect, GameDataModel, false, true);
-        }
-
-        public override Brush GenerateMouseBrush()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-
-            return Profile.GenerateBrush<Dota2DataModel>(GameDataModel, LayerType.Mouse, false, true);
-        }
-
-        public override Brush GenerateHeadsetBrush()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-
-            return Profile.GenerateBrush<Dota2DataModel>(GameDataModel, LayerType.Headset, false, true);
         }
 
         public void HandleGameData(object sender, GameDataReceivedEventArgs e)
@@ -88,7 +61,12 @@ namespace Artemis.Modules.Games.Dota2
                 return;
 
             // Parse the JSON
-            GameDataModel = JsonConvert.DeserializeObject<Dota2DataModel>(jsonString);
+            DataModel = JsonConvert.DeserializeObject<Dota2DataModel>(jsonString);
+        }
+
+        public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
+        {
+            return Profile.GetRenderLayers<Dota2DataModel>(DataModel, renderMice, renderHeadsets);
         }
     }
 }

Artemis/Artemis/Modules/Games/Overwatch/OverwatchDataModel.cs

@@ -2,7 +2,7 @@ using Artemis.Models.Interfaces;
 
 namespace Artemis.Modules.Games.Overwatch
 {
-    public class OverwatchDataModel : IGameDataModel
+    public class OverwatchDataModel : IDataModel
     {
         public OverwatchStatus Status { get; set; }
         public OverwatchCharacter Character { get; set; }

Artemis/Artemis/Modules/Games/Overwatch/OverwatchModel.cs

@@ -4,11 +4,11 @@ using System.Linq;
 using Artemis.Events;
 using Artemis.Managers;
 using Artemis.Models;
+using Artemis.Models.Interfaces;
 using Artemis.Models.Profiles;
 using Artemis.Utilities;
 using Artemis.Utilities.DataReaders;
 using Caliburn.Micro;
-using Brush = System.Windows.Media.Brush;
 using Color = System.Windows.Media.Color;
 
 namespace Artemis.Modules.Games.Overwatch
@@ -31,6 +31,11 @@ namespace Artemis.Modules.Games.Overwatch
             LoadOverwatchCharacters();
         }
 
+        public OverwatchModel(MainManager mainManager, GameSettings settings, IDataModel dataModel)
+            : base(mainManager, settings, dataModel)
+        {
+        }
+
         public List<CharacterColor> OverwatchCharacters { get; set; }
 
         public MmfReader MmfReader { get; set; }
@@ -85,7 +90,7 @@ namespace Artemis.Modules.Games.Overwatch
 
         public override void Update()
         {
-            var gameDataModel = (OverwatchDataModel) GameDataModel;
+            var gameDataModel = (OverwatchDataModel) DataModel;
             var colors = MmfReader.GetColorArray();
             if (colors == null)
                 return;
@@ -128,29 +133,9 @@ namespace Artemis.Modules.Games.Overwatch
             gameDataModel.UltimateReady = !characterMatch.Color.Equals(colors[2, 2]);
         }
 
-        public override Bitmap GenerateBitmap()
+        public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
         {
-            if (Profile == null || GameDataModel == null)
+            return Profile.GetRenderLayers<OverwatchDataModel>(DataModel, renderMice, renderHeadsets);
-                return null;
-
-            var keyboardRect = MainManager.DeviceManager.ActiveKeyboard.KeyboardRectangle(Scale);
-            return Profile.GenerateBitmap<OverwatchDataModel>(keyboardRect, GameDataModel, false, true);
-        }
-
-        public override Brush GenerateMouseBrush()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-            return null;
-            return Profile.GenerateBrush<OverwatchDataModel>(GameDataModel, LayerType.Mouse, false, true);
-        }
-
-        public override Brush GenerateHeadsetBrush()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-            return null;
-            return Profile.GenerateBrush<OverwatchDataModel>(GameDataModel, LayerType.Headset, false, true);
         }
     }
 

Artemis/Artemis/Modules/Games/RocketLeague/RocketLeagueDataModel.cs

@@ -2,7 +2,7 @@
 
 namespace Artemis.Modules.Games.RocketLeague
 {
-    public class RocketLeagueDataModel : IGameDataModel
+    public class RocketLeagueDataModel : IDataModel
     {
         public int Boost { get; set; }
     }

Artemis/Artemis/Modules/Games/RocketLeague/RocketLeagueModel.cs

@@ -1,5 +1,5 @@
 using System;
-using System.Drawing;
+using System.Collections.Generic;
 using System.Linq;
 using Artemis.Managers;
 using Artemis.Models;
@@ -8,7 +8,6 @@ using Artemis.Settings;
 using Artemis.Utilities;
 using Artemis.Utilities.Memory;
 using Newtonsoft.Json;
-using Brush = System.Windows.Media.Brush;
 
 namespace Artemis.Modules.Games.RocketLeague
 {
@@ -45,7 +44,7 @@ namespace Artemis.Modules.Games.RocketLeague
             var tempProcess = MemoryHelpers.GetProcessIfRunning(ProcessName);
             if (tempProcess == null)
                 return;
-            
+
             _memory = new Memory(tempProcess);
 
             Initialized = true;
@@ -53,45 +52,25 @@ namespace Artemis.Modules.Games.RocketLeague
 
         public override void Update()
         {
-            if (Profile == null || GameDataModel == null || _memory == null)
+            if (Profile == null || DataModel == null || _memory == null)
                 return;
 
             var offsets = _pointer.GameAddresses.First(ga => ga.Description == "Boost").ToString();
             var boostAddress = _memory.GetAddress("\"RocketLeague.exe\"" + offsets);
             var boostFloat = _memory.ReadFloat(boostAddress)*100/3;
 
-            ((RocketLeagueDataModel) GameDataModel).Boost = (int) Math.Ceiling(boostFloat);
+            ((RocketLeagueDataModel) DataModel).Boost = (int) Math.Ceiling(boostFloat);
 
             // Take care of any reading errors resulting in an OutOfMemory on draw
-            if (((RocketLeagueDataModel) GameDataModel).Boost < 0)
+            if (((RocketLeagueDataModel) DataModel).Boost < 0)
-                ((RocketLeagueDataModel) GameDataModel).Boost = 0;
+                ((RocketLeagueDataModel) DataModel).Boost = 0;
-            if (((RocketLeagueDataModel) GameDataModel).Boost > 100)
+            if (((RocketLeagueDataModel) DataModel).Boost > 100)
-                ((RocketLeagueDataModel) GameDataModel).Boost = 100;
+                ((RocketLeagueDataModel) DataModel).Boost = 100;
         }
 
-        public override Bitmap GenerateBitmap()
+        public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
         {
-            if (Profile == null || GameDataModel == null)
+            return Profile.GetRenderLayers<RocketLeagueDataModel>(DataModel, renderMice, renderHeadsets);
-                return null;
-
-            var keyboardRect = MainManager.DeviceManager.ActiveKeyboard.KeyboardRectangle(Scale);
-            return Profile.GenerateBitmap<RocketLeagueDataModel>(keyboardRect, GameDataModel, false, true);
-        }
-
-        public override Brush GenerateMouseBrush()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-
-            return Profile.GenerateBrush<RocketLeagueDataModel>(GameDataModel, LayerType.Mouse, false, true);
-        }
-
-        public override Brush GenerateHeadsetBrush()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-
-            return Profile.GenerateBrush<RocketLeagueDataModel>(GameDataModel, LayerType.Headset, false, true);
         }
     }
 }

Artemis/Artemis/Modules/Games/TheDivision/TheDivisionDataModel.cs

@@ -2,7 +2,7 @@
 
 namespace Artemis.Modules.Games.TheDivision
 {
-    public class TheDivisionDataModel : IGameDataModel
+    public class TheDivisionDataModel : IDataModel
     {
         public TheDivisionDataModel()
         {

Artemis/Artemis/Modules/Games/TheDivision/TheDivisionModel.cs

@@ -74,7 +74,7 @@ namespace Artemis.Modules.Games.TheDivision
         // Parses Division key data to game data
         private void InterpertrateDivisionKey(IReadOnlyList<int> parts)
         {
-            var gameDataModel = (TheDivisionDataModel) GameDataModel;
+            var gameDataModel = (TheDivisionDataModel) DataModel;
             var keyCode = parts[1];
             var rPer = parts[2];
             var gPer = parts[3];
@@ -131,29 +131,9 @@ namespace Artemis.Modules.Games.TheDivision
             // DataModel updating is done whenever a pipe message is received
         }
 
-        public override Bitmap GenerateBitmap()
+        public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
-        {
+        {
-            if (Profile == null || GameDataModel == null)
+            return Profile.GetRenderLayers<TheDivisionDataModel>(DataModel, renderMice, renderHeadsets);
-                return null;
-
-            var keyboardRect = MainManager.DeviceManager.ActiveKeyboard.KeyboardRectangle(Scale);
-            return Profile.GenerateBitmap<TheDivisionDataModel>(keyboardRect, GameDataModel, false, true);
-        }
-
-        public override Brush GenerateMouseBrush()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-
-            return Profile.GenerateBrush<TheDivisionDataModel>(GameDataModel, LayerType.Mouse, false, true);
-        }
-
-        public override Brush GenerateHeadsetBrush()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-
-            return Profile.GenerateBrush<TheDivisionDataModel>(GameDataModel, LayerType.Headset, false, true);
         }
     }
 }

Artemis/Artemis/Modules/Games/Witcher3/Witcher3DataModel.cs

@@ -2,7 +2,7 @@ using Artemis.Models.Interfaces;
 
 namespace Artemis.Modules.Games.Witcher3
 {
-    public class Witcher3DataModel : IGameDataModel
+    public class Witcher3DataModel : IDataModel
     {
         public WitcherSign WitcherSign { get; set; }
     }

Artemis/Artemis/Modules/Games/Witcher3/Witcher3Model.cs

@@ -9,7 +9,6 @@ using Artemis.Managers;
 using Artemis.Models;
 using Artemis.Models.Profiles;
 using Artemis.Utilities.Keyboard;
-using Brush = System.Windows.Media.Brush;
 
 namespace Artemis.Modules.Games.Witcher3
 {
@@ -67,7 +66,7 @@ namespace Artemis.Modules.Games.Witcher3
 
         public override void Update()
         {
-            var gameDataModel = (Witcher3DataModel) GameDataModel;
+            var gameDataModel = (Witcher3DataModel) DataModel;
             // Witcher effect is very static and reads from disk, don't want to update too often.
             if (_updateSw.ElapsedMilliseconds < 500)
                 return;
@@ -106,29 +105,9 @@ namespace Artemis.Modules.Games.Witcher3
             }
         }
 
-        public override Bitmap GenerateBitmap()
+        public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
         {
-            if (Profile == null || GameDataModel == null)
+            return Profile.GetRenderLayers<Witcher3DataModel>(DataModel, renderMice, renderHeadsets);
-                return null;
-
-            var keyboardRect = MainManager.DeviceManager.ActiveKeyboard.KeyboardRectangle(Scale);
-            return Profile.GenerateBitmap<Witcher3DataModel>(keyboardRect, GameDataModel, false, true);
-        }
-
-        public override Brush GenerateMouseBrush()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-
-            return Profile.GenerateBrush<Witcher3DataModel>(GameDataModel, LayerType.Mouse, false, true);
-        }
-
-        public override Brush GenerateHeadsetBrush()
-        {
-            if (Profile == null || GameDataModel == null)
-                return null;
-
-            return Profile.GenerateBrush<Witcher3DataModel>(GameDataModel, LayerType.Headset, false, true);
         }
     }
 }

Artemis/Artemis/Modules/Overlays/VolumeDisplay/VolumeDisplayModel.cs

@@ -1,8 +1,10 @@
-using System.Drawing;
+using System.Collections.Generic;
+using System.Drawing;
 using System.Runtime.InteropServices;
 using System.Windows.Forms;
 using Artemis.Managers;
 using Artemis.Models;
+using Artemis.Models.Profiles;
 using NAudio.CoreAudioApi;
 using Brush = System.Windows.Media.Brush;
 
@@ -62,24 +64,7 @@ namespace Artemis.Modules.Overlays.VolumeDisplay
             }
         }
 
-        public override Bitmap GenerateBitmap()
+        public Bitmap GenerateBitmap(Bitmap bitmap)
-        {
-            return GenerateBitmap(MainManager.DeviceManager.ActiveKeyboard.KeyboardBitmap(4));
-        }
-
-        // TODO: Color according to volume
-        public override Brush GenerateMouseBrush()
-        {
-            return null;
-        }
-
-        // TODO: Color according to volume
-        public override Brush GenerateHeadsetBrush()
-        {
-            return null;
-        }
-
-        public override Bitmap GenerateBitmap(Bitmap bitmap)
         {
             if (VolumeDisplay == null)
                 return bitmap;
@@ -92,6 +77,11 @@ namespace Artemis.Modules.Overlays.VolumeDisplay
             return bitmap;
         }
 
+        public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
+        {
+            return null;
+        }
+
         private void KeyPressTask(KeyEventArgs e)
         {
             if (e.KeyCode != Keys.VolumeUp && e.KeyCode != Keys.VolumeDown)
@@ -100,5 +90,11 @@ namespace Artemis.Modules.Overlays.VolumeDisplay
             VolumeDisplay.Ttl = 1000;
             VolumeDisplay.Transparancy = 255;
         }
+
+        public override void RenderOverlay(ref Bitmap keyboard, ref Brush mouse, ref Brush headset, bool renderMice,
+            bool renderHeadsets)
+        {
+            keyboard= GenerateBitmap(keyboard ?? MainManager.DeviceManager.ActiveKeyboard.KeyboardBitmap(4));
+        }
     }
 }

Artemis/Artemis/Utilities/DataReaders/MmfReader.cs

@@ -31,7 +31,7 @@ namespace Artemis.Utilities.DataReaders
             if (string.IsNullOrEmpty(mffString))
                 return null;
             var intermediateArray = mffString.Split('|');
-            if (intermediateArray[0] == "1")
+            if (intermediateArray[0] == "1" || intermediateArray.Length < 2)
                 return null;
             var array = intermediateArray[1].Substring(1).Split(' ');
             if (!array.Any())

Artemis/Artemis/ViewModels/Abstract/GameViewModel.cs

@@ -96,7 +96,7 @@ namespace Artemis.ViewModels.Abstract
             if (e.PropertyName != "SelectedProfile" && IsActive)
                 return;
             GameModel.Profile = ProfileEditor.SelectedProfile;
-            ProfilePreviewModel.SelectedProfile = ProfileEditor.SelectedProfile;
+            ProfilePreviewModel.Profile = ProfileEditor.SelectedProfile;
 
             if (e.PropertyName != "SelectedProfile" || !ProfileEditor.ProfileViewModel.Activated ||
                 ProfileEditor.ProfileViewModel.SelectedProfile == null)

Artemis/Artemis/ViewModels/Profiles/LayerEditorViewModel.cs

@@ -17,16 +17,16 @@ namespace Artemis.ViewModels.Profiles
 {
     public sealed class LayerEditorViewModel : Screen
     {
-        private readonly IGameDataModel _gameDataModel;
+        private readonly IDataModel _dataModel;
         private LayerModel _layer;
         private LayerPropertiesViewModel _layerPropertiesViewModel;
         private LayerType _layerType;
         private LayerModel _proposedLayer;
         private LayerPropertiesModel _proposedProperties;
 
-        public LayerEditorViewModel(IGameDataModel gameDataModel, LayerModel layer)
+        public LayerEditorViewModel(IDataModel dataModel, LayerModel layer)
         {
-            _gameDataModel = gameDataModel;
+            _dataModel = dataModel;
 
             Layer = layer;
             ProposedLayer = GeneralHelpers.Clone(layer);
@@ -35,7 +35,7 @@ namespace Artemis.ViewModels.Profiles
                 Layer.SetupProperties();
 
             DataModelProps = new BindableCollection<GeneralHelpers.PropertyCollection>();
-            DataModelProps.AddRange(GeneralHelpers.GenerateTypeMap(gameDataModel));
+            DataModelProps.AddRange(GeneralHelpers.GenerateTypeMap(dataModel));
             LayerConditionVms = new BindableCollection<LayerConditionViewModel>(layer.Properties.Conditions
                 .Select(c => new LayerConditionViewModel(this, c, DataModelProps)));
 
@@ -106,7 +106,7 @@ namespace Artemis.ViewModels.Profiles
             LayerType = ProposedLayer.LayerType;
 
             if (LayerType == LayerType.Folder && !(LayerPropertiesViewModel is FolderPropertiesViewModel))
-                LayerPropertiesViewModel = new FolderPropertiesViewModel(_gameDataModel, ProposedLayer.Properties);
+                LayerPropertiesViewModel = new FolderPropertiesViewModel(_dataModel, ProposedLayer.Properties);
         }
 
         private void PropertiesViewModelHandler(object sender, PropertyChangedEventArgs e)
@@ -136,17 +136,17 @@ namespace Artemis.ViewModels.Profiles
             if ((LayerType == LayerType.Keyboard || LayerType == LayerType.KeyboardGif) &&
                 !(LayerPropertiesViewModel is KeyboardPropertiesViewModel))
             {
-                LayerPropertiesViewModel = new KeyboardPropertiesViewModel(_gameDataModel, ProposedLayer.Properties)
+                LayerPropertiesViewModel = new KeyboardPropertiesViewModel(_dataModel, ProposedLayer.Properties)
                 {
                     IsGif = LayerType == LayerType.KeyboardGif
                 };
             }
             else if (LayerType == LayerType.Mouse && !(LayerPropertiesViewModel is MousePropertiesViewModel))
-                LayerPropertiesViewModel = new MousePropertiesViewModel(_gameDataModel, ProposedLayer.Properties);
+                LayerPropertiesViewModel = new MousePropertiesViewModel(_dataModel, ProposedLayer.Properties);
             else if (LayerType == LayerType.Headset && !(LayerPropertiesViewModel is HeadsetPropertiesViewModel))
-                LayerPropertiesViewModel = new HeadsetPropertiesViewModel(_gameDataModel, ProposedLayer.Properties);
+                LayerPropertiesViewModel = new HeadsetPropertiesViewModel(_dataModel, ProposedLayer.Properties);
             else if (LayerType == LayerType.Folder && !(LayerPropertiesViewModel is FolderPropertiesViewModel))
-                LayerPropertiesViewModel = new FolderPropertiesViewModel(_gameDataModel, ProposedLayer.Properties);
+                LayerPropertiesViewModel = new FolderPropertiesViewModel(_dataModel, ProposedLayer.Properties);
 
             NotifyOfPropertyChange(() => LayerPropertiesViewModel);
         }

Artemis/Artemis/ViewModels/Profiles/ProfileEditorViewModel.cs

@@ -267,7 +267,7 @@ namespace Artemis.ViewModels.Profiles
         public void EditLayer(LayerModel layer)
         {
             IWindowManager manager = new WindowManager();
-            var editorVm = _layerEditorVmFactory.CreateLayerEditorVm(_gameModel.GameDataModel, layer);
+            var editorVm = _layerEditorVmFactory.CreateLayerEditorVm(_gameModel.DataModel, layer);
             dynamic settings = new ExpandoObject();
             var iconImage = new Image
             {

Artemis/Artemis/ViewModels/Profiles/ProfileViewModel.cs

@@ -9,6 +9,7 @@ using Artemis.Events;
 using Artemis.Managers;
 using Artemis.Models.Profiles;
 using Artemis.Models.Profiles.Properties;
+using Artemis.Modules.Effects.ProfilePreview;
 using Artemis.Utilities;
 using Caliburn.Micro;
 using MahApps.Metro;
@@ -109,12 +110,10 @@ namespace Artemis.ViewModels.Profiles
                 drawingContext.DrawRectangle(new SolidColorBrush(Color.FromArgb(0, 0, 0, 0)), null, keyboardRect);
 
                 // Draw the layers
-                var drawLayers = SelectedProfile.Layers
+                var drawLayers = SelectedProfile.GetRenderLayers<ProfilePreviewDataModel>(
-                    .OrderByDescending(l => l.Order)
+                    new ProfilePreviewDataModel(), false, false, true);
-                    .Where(l => l.MustDraw() || (l.Enabled && l.LayerType == LayerType.Folder))
-                    .ToList();
                 foreach (var layer in drawLayers)
-                    layer.Draw<object>(null, drawingContext, true, false);
+                    layer.Draw(null, drawingContext, true, false);
 
                 // Get the selection color
                 var accentColor = ThemeManager.DetectAppStyle(Application.Current)?.Item2?.Resources["AccentColor"];

Artemis/Artemis/ViewModels/Profiles/Properties/FolderPropertiesViewModel.cs

@@ -8,8 +8,8 @@ namespace Artemis.ViewModels.Profiles.Properties
     {
         private LayerPropertiesModel _proposedProperties;
 
-        public FolderPropertiesViewModel(IGameDataModel gameDataModel, LayerPropertiesModel properties)
+        public FolderPropertiesViewModel(IDataModel dataModel, LayerPropertiesModel properties)
-            : base(gameDataModel)
+            : base(dataModel)
         {
             ProposedProperties = GeneralHelpers.Clone(properties);
         }

Artemis/Artemis/ViewModels/Profiles/Properties/HeadsetPropertiesViewModel.cs

@@ -10,8 +10,8 @@ namespace Artemis.ViewModels.Profiles.Properties
         private LayerPropertiesModel _proposedProperties;
         private Brush _brush;
 
-        public HeadsetPropertiesViewModel(IGameDataModel gameDataModel, LayerPropertiesModel properties)
+        public HeadsetPropertiesViewModel(IDataModel dataModel, LayerPropertiesModel properties)
-            : base(gameDataModel)
+            : base(dataModel)
         {
             ProposedProperties = GeneralHelpers.Clone(properties);
             Brush = ProposedProperties.Brush.CloneCurrentValue();

Artemis/Artemis/ViewModels/Profiles/Properties/KeyboardPropertiesViewModel.cs

@@ -13,15 +13,15 @@ namespace Artemis.ViewModels.Profiles.Properties
         private bool _isGif;
         private KeyboardPropertiesModel _proposedProperties;
 
-        public KeyboardPropertiesViewModel(IGameDataModel gameDataModel, LayerPropertiesModel properties)
+        public KeyboardPropertiesViewModel(IDataModel dataModel, LayerPropertiesModel properties)
-            : base(gameDataModel)
+            : base(dataModel)
         {
             var keyboardProperties = (KeyboardPropertiesModel) properties;
             ProposedProperties = GeneralHelpers.Clone(keyboardProperties);
             Brush = ProposedProperties.Brush.CloneCurrentValue();
 
             DataModelProps = new BindableCollection<GeneralHelpers.PropertyCollection>();
-            DataModelProps.AddRange(GeneralHelpers.GenerateTypeMap(gameDataModel));
+            DataModelProps.AddRange(GeneralHelpers.GenerateTypeMap(dataModel));
 
             HeightProperties = new LayerDynamicPropertiesViewModel("Height", DataModelProps, keyboardProperties);
             WidthProperties = new LayerDynamicPropertiesViewModel("Width", DataModelProps, keyboardProperties);

Artemis/Artemis/ViewModels/Profiles/Properties/LayerPropertiesViewModel.cs

@@ -7,11 +7,11 @@ namespace Artemis.ViewModels.Profiles.Properties
 {
     public abstract class LayerPropertiesViewModel : PropertyChangedBase
     {
-        public IGameDataModel GameDataModel { get; set; }
+        public IDataModel DataModel { get; set; }
 
-        protected LayerPropertiesViewModel(IGameDataModel gameDataModel)
+        protected LayerPropertiesViewModel(IDataModel dataModel)
         {
-            GameDataModel = gameDataModel;
+            DataModel = dataModel;
         }
 
         public abstract LayerPropertiesModel GetAppliedProperties();

Artemis/Artemis/ViewModels/Profiles/Properties/MousePropertiesViewModel.cs

@@ -11,8 +11,8 @@ namespace Artemis.ViewModels.Profiles.Properties
         private LayerPropertiesModel _proposedProperties;
         private Brush _brush;
 
-        public MousePropertiesViewModel(IGameDataModel gameDataModel, LayerPropertiesModel properties)
+        public MousePropertiesViewModel(IDataModel dataModel, LayerPropertiesModel properties)
-            : base(gameDataModel)
+            : base(dataModel)
         {
             ProposedProperties = GeneralHelpers.Clone(properties);
             Brush = ProposedProperties.Brush.CloneCurrentValue();