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

Much more performance improvements

Browse Source
This commit is contained in:
SpoinkyNL 2016-06-06 14:55:34 +02:00
parent b7423ad6d6
commit 49ca507a5c
44 changed files with 382 additions and 432 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Artemis/Artemis/InjectionFactories/ILayerEditorVmFactory.cs
View File

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

34
Artemis/Artemis/Managers/LoopManager.cs
View File

@ -120,19 +120,29 @@ namespace Artemis.Managers
renderEffect.Update();
// Get ActiveEffect's bitmap
var bitmap = renderEffect.Initialized
? renderEffect.GenerateBitmap()
: null;
Bitmap bitmap = null;
System.Windows.Media.Brush mouseBrush = 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.GenerateBitmap(bitmap)
: overlayModel.GenerateBitmap();
overlayModel.RenderOverlay(ref bitmap, ref mouseBrush, ref headsetBrush, mice.Any(), headsets.Any());
}
// 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));
}
}
}

4
Artemis/Artemis/Managers/ProfileManager.cs
View File

@ -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))
ProfilePreviewModel.SelectedProfile = activePreview.ProfileEditor.SelectedProfile;
if (!ReferenceEquals(ProfilePreviewModel.Profile, activePreview.ProfileEditor.SelectedProfile))
ProfilePreviewModel.Profile = activePreview.ProfileEditor.SelectedProfile;
}
}
}

37
Artemis/Artemis/Models/EffectModel.cs
View File

@ -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 abstract Bitmap GenerateBitmap();
public IDataModel DataModel { get; set; }
public ProfileModel Profile { get; set; }
public abstract Brush GenerateMouseBrush();
public abstract Brush GenerateHeadsetBrush();
// Called after every update
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);
}
}

9
Artemis/Artemis/Models/GameModel.cs
View File

@ -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; }
}
}

2
Artemis/Artemis/Models/Interfaces/GameDataModel.cs
View File

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

6
Artemis/Artemis/Models/OverlayModel.cs
View File

@ -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);
}
}

2
Artemis/Artemis/Models/Profiles/LayerConditionModel.cs
View File

@ -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;

81
Artemis/Artemis/Models/Profiles/LayerModel.cs
View File

@ -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 (!Enabled)
if (LayerType != LayerType.Keyboard && LayerType != LayerType.KeyboardGif)
return;
// Preview simply shows the properties as they are. When not previewing they are applied
AppliedProperties appliedProperties;
if (!preview)
{
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);
var appliedProperties = !preview
? Properties.GetAppliedProperties(dataModel)
: Properties.GetAppliedProperties(dataModel, true);
// Update animations on layer types that support them
if (LayerType == LayerType.Keyboard || LayerType == LayerType.KeyboardGif)
{
AnimationUpdater.UpdateAnimation((KeyboardPropertiesModel) Properties, updateAnimations);
}
switch (LayerType)
{
// 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;
}
// Update animations
AnimationUpdater.UpdateAnimation((KeyboardPropertiesModel) Properties, updateAnimations);
if (LayerType == LayerType.Keyboard)
Drawer.Draw(c, (KeyboardPropertiesModel) Properties, appliedProperties);
else if (LayerType == LayerType.KeyboardGif)
GifImage = Drawer.DrawGif(c, (KeyboardPropertiesModel) Properties, appliedProperties, GifImage);
}
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

89
Artemis/Artemis/Models/Profiles/ProfileModel.cs
View File

@ -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;
}
}
}

6
Artemis/Artemis/Models/Profiles/Properties/DynamicPropertiesModel.cs
View File

@ -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);

2
Artemis/Artemis/Models/Profiles/Properties/FolderPropertiesModel.cs
View File

@ -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();
}

4
Artemis/Artemis/Models/Profiles/Properties/HeadsetPropertiesModel.cs
View File

@ -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};
}
}
}

2
Artemis/Artemis/Models/Profiles/Properties/KeyboardPropertiesModel.cs
View File

@ -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
{

2
Artemis/Artemis/Models/Profiles/Properties/LayerPropertiesModel.cs
View File

@ -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

4
Artemis/Artemis/Models/Profiles/Properties/MousePropertiesModel.cs
View File

@ -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 };
}
}
}

35
Artemis/Artemis/Modules/Effects/AmbientLightning/AmbientLightningEffectModel.cs
View File

@ -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()
{
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()
public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
{
return null;
}

63
Artemis/Artemis/Modules/Effects/AudioVisualizer/AudioVisualizerModel.cs
View File

@ -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;
}
}
}

27
Artemis/Artemis/Modules/Effects/Debug/DebugEffectModel.cs
View File

@ -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;
}
}
}

56
Artemis/Artemis/Modules/Effects/ProfilePreview/ProfilePreviewModel.cs
View File

@ -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)
public ProfilePreviewModel(MainManager mainManager) : base(mainManager, new ProfilePreviewDataModel())
{
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 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;
return Profile.GetRenderLayers<ProfilePreviewDataModel>(DataModel, renderMice, renderHeadsets, true);
}
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()
{
return SelectedProfile?.GenerateBrush<ProfilePreviewDataModel>(_previewDataModel, LayerType.Headset, true, true);
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), 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
{
}
}

41
Artemis/Artemis/Modules/Effects/TypeWave/TypeWaveModel.cs
View File

@ -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);
using (var g = Graphics.FromImage(bitmap))
public override void Render(out Bitmap keyboard, out Brush mouse, out Brush headset, bool renderMice, bool renderHeadsets)
{
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,
_waves[i].Point.Y - _waves[i].Size/2, _waves[i].Size, _waves[i].Size);
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);
}
}
return bitmap;
}
public override Brush GenerateMouseBrush()
{
return null;
}
public override Brush GenerateHeadsetBrush()
{
return null;
}
}

2
Artemis/Artemis/Modules/Games/CounterStrike/CounterStrikeDataModel.cs
View File

@ -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; }

34
Artemis/Artemis/Modules/Games/CounterStrike/CounterStrikeModel.cs
View File

@ -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);
}
}
}

2
Artemis/Artemis/Modules/Games/Dota2/Dota2DataModel.cs
View File

@ -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; }

40
Artemis/Artemis/Modules/Games/Dota2/Dota2Model.cs
View File

@ -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);
}
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);
dataModel.map.dayCyclePercentage = (int) (100.00/240*timeLeft);
}
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);
}
}
}

2
Artemis/Artemis/Modules/Games/Overwatch/OverwatchDataModel.cs
View File

@ -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; }

33
Artemis/Artemis/Modules/Games/Overwatch/OverwatchModel.cs
View File

@ -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 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);
return Profile.GetRenderLayers<OverwatchDataModel>(DataModel, renderMice, renderHeadsets);
}
}

2
Artemis/Artemis/Modules/Games/RocketLeague/RocketLeagueDataModel.cs
View File

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

41
Artemis/Artemis/Modules/Games/RocketLeague/RocketLeagueModel.cs
View File

@ -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)
((RocketLeagueDataModel) GameDataModel).Boost = 0;
if (((RocketLeagueDataModel) GameDataModel).Boost > 100)
((RocketLeagueDataModel) GameDataModel).Boost = 100;
if (((RocketLeagueDataModel) DataModel).Boost < 0)
((RocketLeagueDataModel) DataModel).Boost = 0;
if (((RocketLeagueDataModel) DataModel).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 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);
return Profile.GetRenderLayers<RocketLeagueDataModel>(DataModel, renderMice, renderHeadsets);
}
}
}

2
Artemis/Artemis/Modules/Games/TheDivision/TheDivisionDataModel.cs
View File

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

28
Artemis/Artemis/Modules/Games/TheDivision/TheDivisionModel.cs
View File

@ -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()
{
if (Profile == null || GameDataModel == null)
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);
public override List<LayerModel> GetRenderLayers(bool renderMice, bool renderHeadsets)
{
return Profile.GetRenderLayers<TheDivisionDataModel>(DataModel, renderMice, renderHeadsets);
}
}
}

2
Artemis/Artemis/Modules/Games/Witcher3/Witcher3DataModel.cs
View File

@ -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; }
}

27
Artemis/Artemis/Modules/Games/Witcher3/Witcher3Model.cs
View File

@ -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 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);
return Profile.GetRenderLayers<Witcher3DataModel>(DataModel, renderMice, renderHeadsets);
}
}
}

34
Artemis/Artemis/Modules/Overlays/VolumeDisplay/VolumeDisplayModel.cs
View File

@ -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()
{
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)
public 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));
}
}
}

2
Artemis/Artemis/Utilities/DataReaders/MmfReader.cs
View File

@ -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())

2
Artemis/Artemis/ViewModels/Abstract/GameViewModel.cs
View File

@ -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)

18
Artemis/Artemis/ViewModels/Profiles/LayerEditorViewModel.cs
View File

@ -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);
}

2
Artemis/Artemis/ViewModels/Profiles/ProfileEditorViewModel.cs
View File

@ -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
{

9
Artemis/Artemis/ViewModels/Profiles/ProfileViewModel.cs
View File

@ -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
.OrderByDescending(l => l.Order)
.Where(l => l.MustDraw() || (l.Enabled && l.LayerType == LayerType.Folder))
.ToList();
var drawLayers = SelectedProfile.GetRenderLayers<ProfilePreviewDataModel>(
new ProfilePreviewDataModel(), false, false, true);
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"];

4
Artemis/Artemis/ViewModels/Profiles/Properties/FolderPropertiesViewModel.cs
View File

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

4
Artemis/Artemis/ViewModels/Profiles/Properties/HeadsetPropertiesViewModel.cs
View File

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

6
Artemis/Artemis/ViewModels/Profiles/Properties/KeyboardPropertiesViewModel.cs
View File

@ -13,15 +13,15 @@ namespace Artemis.ViewModels.Profiles.Properties
private bool _isGif;
private KeyboardPropertiesModel _proposedProperties;
public KeyboardPropertiesViewModel(IGameDataModel gameDataModel, LayerPropertiesModel properties)
: base(gameDataModel)
public KeyboardPropertiesViewModel(IDataModel dataModel, LayerPropertiesModel properties)
: 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);

6
Artemis/Artemis/ViewModels/Profiles/Properties/LayerPropertiesViewModel.cs
View File

@ -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();

4
Artemis/Artemis/ViewModels/Profiles/Properties/MousePropertiesViewModel.cs
View File

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