From 5014e87755827a9ccf5a31e95d0ef787140b1535 Mon Sep 17 00:00:00 2001
From: Alex <ritt.alex@gmail.com>
Date: Wed, 6 May 2020 21:16:59 +0200
Subject: [PATCH 1/3] Fix gradiant layer: gradial brush

---
 .../Controls/Control_GradientEditor.xaml      |   9 +-
 .../Controls/Control_GradientEditor.xaml.cs   |   1 -
 .../Controls/EffectSettingsWindow.xaml        |  19 +--
 .../Controls/EffectSettingsWindow.xaml.cs     |   9 -
 .../EffectsEngine/EffectBrush.cs              | 160 +++++++++++++++++-
 .../EffectsEngine/EffectLayer.cs              |  85 +++-------
 .../Profiles/CloneHero/CloneHeroProfile.cs    |   1 -
 .../Settings/LayerEffectConfig.cs             |  17 +-
 .../Layers/Control_GradientFillLayer.xaml     |  15 --
 .../Layers/Control_GradientLayer.xaml         |  19 +--
 .../Layers/Control_GradientLayer.xaml.cs      |   7 -
 .../Layers/GradientFillLayerHandler.cs        |   2 +-
 .../Settings/Layers/GradientLayerHandler.cs   |   2 +-
 .../Project-Aurora/Utils/EnumUtils.cs         |   5 -
 14 files changed, 186 insertions(+), 165 deletions(-)

diff --git a/Project-Aurora/Project-Aurora/Controls/Control_GradientEditor.xaml b/Project-Aurora/Project-Aurora/Controls/Control_GradientEditor.xaml
index 00e8e0420..302f2274e 100644
--- a/Project-Aurora/Project-Aurora/Controls/Control_GradientEditor.xaml
+++ b/Project-Aurora/Project-Aurora/Controls/Control_GradientEditor.xaml
@@ -31,15 +31,12 @@
         <Label Content="Brush:" Grid.Row="0" HorizontalAlignment="Right" />
         <ncore:ColorBox Grid.Row="0" Grid.Column="1" Brush="{Binding Brush, Converter={StaticResource BrushConverter}, Mode=TwoWay}" />
 
-        <Label Content="Animation Type:" Grid.Row="1" HorizontalAlignment="Right" />
-        <ComboBox x:Name="animTypeCb" Grid.Row="1" Grid.Column="1" Margin="0,0,0,2" DisplayMemberPath="Key" SelectedValuePath="Value"  SelectedValue="{Binding AnimationType}" />
-
         <Label Content="Speed:" Grid.Row="2" HorizontalAlignment="Right" />
-        <xctk:SingleUpDown Grid.Row="2" Grid.Column="1" Value="{Binding Speed}" Margin="0,2" />
+        <xctk:SingleUpDown Grid.Row="1" Grid.Column="1" Value="{Binding Speed}" Margin="0,2" />
 
         <Label Content="Angle:" Grid.Row="3" HorizontalAlignment="Right" />
-        <xctk:SingleUpDown Grid.Row="3" Grid.Column="1" Value="{Binding Angle}" Margin="0,2" />
+        <xctk:SingleUpDown Grid.Row="2" Grid.Column="1" Value="{Binding Angle}" Margin="0,2" />
         
-        <CheckBox Grid.Row="4" Grid.Column="1" Content="Reverse Direction?" IsChecked="{Binding AnimationReverse}" />
+        <CheckBox Grid.Row="3" Grid.Column="1" Content="Reverse Direction?" IsChecked="{Binding AnimationReverse}" />
     </Grid>
 </UserControl>
diff --git a/Project-Aurora/Project-Aurora/Controls/Control_GradientEditor.xaml.cs b/Project-Aurora/Project-Aurora/Controls/Control_GradientEditor.xaml.cs
index 5fcb0cf0d..6e8a11a96 100644
--- a/Project-Aurora/Project-Aurora/Controls/Control_GradientEditor.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Controls/Control_GradientEditor.xaml.cs
@@ -11,7 +11,6 @@ public partial class Control_GradientEditor : UserControl {
 
         public Control_GradientEditor(LayerEffectConfig gradient) {
             InitializeComponent();
-            animTypeCb.ItemsSource = Utils.EnumUtils.GetEnumItemsSource<AnimationType>();
             DataContext = gradient;
         }
     }
diff --git a/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml b/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml
index 2c9becd27..0df744df6 100644
--- a/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml
+++ b/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml
@@ -10,21 +10,6 @@
              xmlns:ncore="http://schemas.ncore.com/wpf/xaml/colorbox" x:Class="Aurora.Controls.EffectSettingsWindow"
              xmlns:eff_config="clr-namespace:Aurora.Settings"
              mc:Ignorable="d" ShowInTaskbar="False" ResizeMode="NoResize" Title="Effect Settings" Height="260" Width="440" Topmost="True" WindowStartupLocation="CenterOwner" Activated="Window_Activated" Deactivated="Window_Deactivated" Background="Transparent">
-    <Window.Resources>
-        <ResourceDictionary>
-
-            <ObjectDataProvider x:Key="AnimationType" MethodName="GetValues" ObjectType="{x:Type System:Enum}">
-                <ObjectDataProvider.MethodParameters>
-                    <x:Type TypeName="eff_config:AnimationType" />
-                </ObjectDataProvider.MethodParameters>
-            </ObjectDataProvider>
-            <EnumValueConverters:AnimationTypeToStringVC x:Key="AnimationTypeToStringVC"/>
-            <DataTemplate x:Key="AnimationTypeTemplate">
-                <TextBlock Text="{Binding Converter={StaticResource AnimationTypeToStringVC}}" />
-            </DataTemplate>
-
-        </ResourceDictionary>
-    </Window.Resources>
 
     <Grid>
         <TextBlock HorizontalAlignment="Left" Margin="10,13,0,0" TextWrapping="Wrap" Text="Primary Color:" VerticalAlignment="Top"/>
@@ -40,8 +25,6 @@
         <xctk:IntegerUpDown x:Name="effect_angle" HorizontalAlignment="Left" Height="20" Margin="84,92,0,0" VerticalAlignment="Top" Width="60" Value="0" Minimum="-360" Maximum="360" Increment="1" ValueChanged="effect_angle_ValueChanged"/>
         <ncore:ColorBox x:Name="gradient_editor" HorizontalAlignment="Left" Height="150" Margin="264,37,0,0" VerticalAlignment="Top" Width="150"/>
         <TextBlock HorizontalAlignment="Left" Margin="264,16,0,0" TextWrapping="Wrap" Text="Effect Gradient: " VerticalAlignment="Top"/>
-        <TextBlock HorizontalAlignment="Left" Margin="10,120,0,0" TextWrapping="Wrap" Text="Animation Type: " VerticalAlignment="Top"/>
-        <ComboBox x:Name="effect_animation_type" HorizontalAlignment="Left" Margin="104,117,0,0" VerticalAlignment="Top" Width="155" IsSynchronizedWithCurrentItem="True" SelectedIndex="0" ItemsSource="{Binding Source={StaticResource AnimationType}}" ItemTemplate="{Binding Source={StaticResource AnimationTypeTemplate}}" SelectionChanged="effect_animation_type_SelectionChanged"/>
-        <CheckBox x:Name="effect_animation_reversed" Content="Reverse animation direction" HorizontalAlignment="Left" Margin="10,144,0,0" VerticalAlignment="Top" Checked="effect_animation_reversed_Checked" Unchecked="effect_animation_reversed_Checked"/>
+        <CheckBox x:Name="effect_animation_reversed" Content="Reverse animation direction" HorizontalAlignment="Left" Margin="10,117,0,0" VerticalAlignment="Top" Checked="effect_animation_reversed_Checked" Unchecked="effect_animation_reversed_Checked"/>
     </Grid>
 </Window>
diff --git a/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml.cs b/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml.cs
index 3099c6b5b..363a924d4 100644
--- a/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml.cs
@@ -52,7 +52,6 @@ public EffectSettingsWindow(LayerEffectConfig EffectConfig)
             this.effect_speed_slider.Value = EffectConfig.speed;
             this.effect_speed_label.Text = "x " + EffectConfig.speed;
             this.effect_angle.Text = EffectConfig.angle.ToString();
-            this.effect_animation_type.SelectedIndex = (int)EffectConfig.animation_type;
             this.effect_animation_reversed.IsChecked = EffectConfig.animation_reverse;
             Brush brush = EffectConfig.brush.GetMediaBrush();
             try
@@ -150,14 +149,6 @@ private void effect_angle_ValueChanged(object sender, RoutedPropertyChangedEvent
             }
         }
 
-        private void effect_animation_type_SelectionChanged(object sender, SelectionChangedEventArgs e)
-        {
-            if (IsLoaded)
-            {
-                EffectConfig.animation_type = (AnimationType)Enum.Parse(typeof(AnimationType),effect_animation_type.SelectedIndex.ToString());
-            }
-        }
-
         private void effect_animation_reversed_Checked(object sender, RoutedEventArgs e)
         {
             if (IsLoaded)
diff --git a/Project-Aurora/Project-Aurora/EffectsEngine/EffectBrush.cs b/Project-Aurora/Project-Aurora/EffectsEngine/EffectBrush.cs
index fab2d4c20..52b9a2512 100644
--- a/Project-Aurora/Project-Aurora/EffectsEngine/EffectBrush.cs
+++ b/Project-Aurora/Project-Aurora/EffectsEngine/EffectBrush.cs
@@ -58,7 +58,7 @@ public EffectBrush(ColorSpectrum spectrum)
         {
             type = BrushType.Linear;
 
-            foreach(var color in spectrum.GetSpectrumColors())
+            foreach (var color in spectrum.GetSpectrumColors())
                 colorGradients.Add(color.Key, color.Value);
 
             start = new System.Drawing.PointF(0, 0);
@@ -192,15 +192,15 @@ public EffectBrush(System.Drawing.Brush brush)
 
             }
 
-            if(colorGradients.Count > 0)
+            if (colorGradients.Count > 0)
             {
                 bool firstFound = false;
                 System.Drawing.Color first_color = new System.Drawing.Color();
                 System.Drawing.Color last_color = new System.Drawing.Color();
 
-                foreach(var kvp in colorGradients)
+                foreach (var kvp in colorGradients)
                 {
-                    if(!firstFound)
+                    if (!firstFound)
                     {
                         first_color = kvp.Value;
                         firstFound = true;
@@ -224,7 +224,7 @@ public EffectBrush(System.Drawing.Brush brush)
                     colorGradients.Add(1.0f, System.Drawing.Color.Transparent);
             }
 
-            
+
         }
 
         public EffectBrush(System.Windows.Media.Brush brush)
@@ -462,7 +462,157 @@ public System.Drawing.Brush GetDrawingBrush()
 
             return _drawingBrush;
         }
+        private SortedDictionary<float, System.Drawing.Color> GetColorGradientsForWindow(float shift, float window_size, float starting_value = 0)
+        {
+            SortedDictionary<float, System.Drawing.Color> gradients = new SortedDictionary<float, System.Drawing.Color>();
+            float previousKey = 0;
+            foreach (var kvp in colorGradients)
+            {
+                if (kvp.Key >= shift)
+                {
+                    if (gradients.Count == 0 && kvp.Key != 0)
+                    {
+                        gradients[starting_value] = Utils.ColorUtils.BlendColors(colorGradients[previousKey], kvp.Value, (shift - previousKey)/(kvp.Key - previousKey));
+                    }
+
+                    if (kvp.Key <= shift + window_size)
+                    {
+                        float index = starting_value + (kvp.Key - shift) / window_size;
+                        if (index >= 1)
+                        {
+                            gradients[1] = kvp.Value;
+                            break;
+                        }
+                        gradients[index] = kvp.Value;
+                    }
+                    else
+                    {
+                        gradients[1] = Utils.ColorUtils.BlendColors(colorGradients[previousKey], kvp.Value, (shift + window_size - previousKey) / (kvp.Key - previousKey));
+                        return gradients;
+                    }
+
+                    if (kvp.Key == 1)
+                    {
+                        foreach (var gradient in GetColorGradientsForWindow(0, window_size +shift-previousKey, starting_value + (1 - shift) / window_size))
+                        {
+                            gradients[gradient.Key] = gradient.Value;
+                        }
+                    }
+                }
+                previousKey = kvp.Key;
+            }
+            return gradients;
+        }
+        public System.Drawing.Brush GetDrawingBrush(float shift, float window_size)
+        {
+            if (true/*_drawingbrush == null*/)
+            {
+                if (type == BrushType.Solid)
+                {
+                    _drawingBrush = new System.Drawing.SolidBrush(colorGradients[0.0f]);
+                }
+                else if (type == BrushType.Linear)
+                {
+                    System.Drawing.Drawing2D.LinearGradientBrush brush = new System.Drawing.Drawing2D.LinearGradientBrush(
+                        start,
+                        new System.Drawing.PointF(100/window_size,0),
+                        System.Drawing.Color.Red,
+                        System.Drawing.Color.Red
+                        );
+
+                    List<System.Drawing.Color> brush_colors = new List<System.Drawing.Color>();
+                    List<float> brush_positions = new List<float>();
+
+                    foreach (var kvp in colorGradients)
+                    {
+                        brush_positions.Add(kvp.Key);
+                        brush_colors.Add(kvp.Value);
+                    }
+
+                    System.Drawing.Drawing2D.ColorBlend color_blend = new System.Drawing.Drawing2D.ColorBlend();
+                    color_blend.Colors = brush_colors.ToArray();
+                    color_blend.Positions = brush_positions.ToArray();
+                    brush.InterpolationColors = color_blend;
+
+                    switch (wrap)
+                    {
+                        //case BrushWrap.None:
+                        //    brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
+                        //    break;
+                        case BrushWrap.Repeat:
+                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Tile;
+                            break;
+                        case BrushWrap.Reflect:
+                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.TileFlipXY;
+                            break;
+                    }
+
+                    _drawingBrush = brush;
+                }
+                else if (type == BrushType.Radial)
+                {
+                    System.Drawing.Drawing2D.GraphicsPath g_path = new System.Drawing.Drawing2D.GraphicsPath();
+                    g_path.AddEllipse(
+                        new System.Drawing.RectangleF(
+                        start.X,
+                        start.Y,
+                        end.X,
+                        end.Y
+                        ));
+
+                    System.Drawing.Drawing2D.PathGradientBrush brush = new System.Drawing.Drawing2D.PathGradientBrush(
+                        g_path
+                        );
+
+                    switch (wrap)
+                    {
+                        //// Clamp causes an exception, it's a bug in the Drawing Brush.
+                        //case BrushWrap.None:
+                        //    brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
+                        //    break;
+                        case BrushWrap.Repeat:
+                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Tile;
+                            break;
+                        case BrushWrap.Reflect:
+                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.TileFlipXY;
+                            break;
+                    }
+
+                    List<System.Drawing.Color> brush_colors = new List<System.Drawing.Color>();
+                    List<float> brush_positions = new List<float>();
+
+                    foreach (var kvp in GetColorGradientsForWindow(Math.Abs(shift), window_size/100))
+                    {
+                        if (shift < 0)
+                            brush_positions.Add(1.0f - kvp.Key);
+                        else
+                            brush_positions.Add(kvp.Key);
+                        brush_colors.Add(kvp.Value);
+                    }
+
+                    if (shift < 0)
+                    {
+                        brush_colors.Reverse();
+                        brush_positions.Reverse();
+                    }
+
+                    brush.CenterPoint = center;
 
+                    System.Drawing.Drawing2D.ColorBlend color_blend = new System.Drawing.Drawing2D.ColorBlend();
+                    color_blend.Colors = brush_colors.ToArray();
+                    color_blend.Positions = brush_positions.ToArray();
+                    brush.InterpolationColors = color_blend;
+
+                    _drawingBrush = brush;
+                }
+                else
+                {
+                    _drawingBrush = new System.Drawing.SolidBrush(System.Drawing.Color.Transparent);
+                }
+            }
+
+            return _drawingBrush;
+        }
         public System.Windows.Media.Brush GetMediaBrush()
         {
             if (_mediaBrush == null)
diff --git a/Project-Aurora/Project-Aurora/EffectsEngine/EffectLayer.cs b/Project-Aurora/Project-Aurora/EffectsEngine/EffectLayer.cs
index f3b54fe36..9bdb4be52 100755
--- a/Project-Aurora/Project-Aurora/EffectsEngine/EffectLayer.cs
+++ b/Project-Aurora/Project-Aurora/EffectsEngine/EffectLayer.cs
@@ -114,8 +114,7 @@ public EffectLayer(string name, Color color)
                     effect_config.shift_amount += ((Utils.Time.GetMillisecondsSinceEpoch() - effect_config.last_effect_call) / 1000.0f) * 5.0f * effect_config.speed;
                     effect_config.shift_amount = effect_config.shift_amount % Effects.canvas_biggest;
 
-                    if (effect_config.animation_type == AnimationType.Translate_XY)
-                        shift = effect_config.shift_amount;
+                    shift = effect_config.shift_amount;
 
                     if (effect_config.animation_reverse)
                         shift *= -1.0f;
@@ -132,8 +131,7 @@ public EffectLayer(string name, Color color)
                     effect_config.shift_amount += ((Utils.Time.GetMillisecondsSinceEpoch() - effect_config.last_effect_call) / 1000.0f) * 5.0f * effect_config.speed;
                     effect_config.shift_amount = effect_config.shift_amount % Effects.canvas_biggest;
 
-                    if (effect_config.animation_type == AnimationType.Translate_XY)
-                        shift = effect_config.shift_amount;
+                    shift = effect_config.shift_amount;
 
                     if (effect_config.animation_reverse)
                         shift *= -1.0f;
@@ -150,8 +148,7 @@ public EffectLayer(string name, Color color)
                     effect_config.shift_amount += ((Utils.Time.GetMillisecondsSinceEpoch() - effect_config.last_effect_call) / 1000.0f) * 5.0f * effect_config.speed;
                     effect_config.shift_amount = effect_config.shift_amount % Effects.canvas_biggest;
 
-                    if (effect_config.animation_type == AnimationType.Translate_XY)
-                        shift = effect_config.shift_amount;
+                    shift = effect_config.shift_amount;
 
                     if (effect_config.animation_reverse)
                         shift *= -1.0f;
@@ -168,8 +165,7 @@ public EffectLayer(string name, Color color)
                     effect_config.shift_amount += ((Utils.Time.GetMillisecondsSinceEpoch() - effect_config.last_effect_call) / 1000.0f) * 5.0f * effect_config.speed;
                     effect_config.shift_amount = effect_config.shift_amount % Effects.canvas_biggest;
 
-                    if (effect_config.animation_type == AnimationType.Translate_XY)
-                        shift = effect_config.shift_amount;
+                    shift = effect_config.shift_amount;
 
                     if (effect_config.animation_reverse)
                         shift *= -1.0f;
@@ -187,8 +183,7 @@ public EffectLayer(string name, Color color)
                     effect_config.shift_amount = effect_config.shift_amount % Effects.canvas_biggest;
 
 
-                    if (effect_config.animation_type == AnimationType.Translate_XY)
-                        shift = effect_config.shift_amount;
+                    shift = effect_config.shift_amount;
 
                     if (effect_config.animation_reverse)
                         shift *= -1.0f;
@@ -205,73 +200,39 @@ public EffectLayer(string name, Color color)
                     effect_config.shift_amount += ((Utils.Time.GetMillisecondsSinceEpoch() - effect_config.last_effect_call) / 1000.0f) * 0.067f * effect_config.speed;
                     effect_config.shift_amount = effect_config.shift_amount % Effects.canvas_biggest;
 
-                    if (effect_config.animation_type == AnimationType.Translate_XY)
-                        shift = effect_config.shift_amount;
-                    else if (effect_config.animation_type == AnimationType.Zoom_in && effect_config.brush.type == EffectBrush.BrushType.Radial)
-                        shift = ((Effects.canvas_biggest - effect_config.shift_amount) * 40.0f) % Effects.canvas_biggest;
-                    else if (effect_config.animation_type == AnimationType.Zoom_out && effect_config.brush.type == EffectBrush.BrushType.Radial)
-                        shift = (effect_config.shift_amount * 40.0f) % Effects.canvas_biggest;
+                    shift = effect_config.shift_amount;
+
+                    float brush_width = !rect.IsEmpty ? rect.Width : Effects.canvas_width;
+                    float brush_height = !rect.IsEmpty ? rect.Height : Effects.canvas_height;
 
                     if (effect_config.animation_reverse)
                         shift *= -1.0f;
-
-                    brush = effect_config.brush.GetDrawingBrush();
+                    float percent = shift / (Effects.canvas_biggest / effect_config.gradient_size);
+                    brush = effect_config.brush.GetDrawingBrush(percent % 1 , effect_config.gradient_size);
                     if (effect_config.brush.type == EffectBrush.BrushType.Linear)
                     {
-                        if (!rect.IsEmpty)
-                        {
-                            (brush as LinearGradientBrush).TranslateTransform(rect.X, rect.Y);
-                            (brush as LinearGradientBrush).ScaleTransform(rect.Width * 100 / effect_config.gradient_size, rect.Height * 100 / effect_config.gradient_size);
-                        }
-                        else
-                        {
-                            (brush as LinearGradientBrush).ScaleTransform(Effects.canvas_height * 100 / effect_config.gradient_size, Effects.canvas_height * 100 / effect_config.gradient_size);
-                        }
-
+                        (brush as LinearGradientBrush).ScaleTransform(brush_width, brush_height);
                         (brush as LinearGradientBrush).RotateTransform(effect_config.angle);
                         (brush as LinearGradientBrush).TranslateTransform(shift, shift);
+
                     }
                     else if (effect_config.brush.type == EffectBrush.BrushType.Radial)
                     {
-                        if (effect_config.animation_type == AnimationType.Zoom_in || effect_config.animation_type == AnimationType.Zoom_out)
-                        {
-                            float percent = shift / Effects.canvas_biggest;
-
-                            float x_offset = (Effects.canvas_width / 2.0f) * percent;
-                            float y_offset = (Effects.canvas_height / 2.0f) * percent;
-
-
-                            (brush as PathGradientBrush).WrapMode = WrapMode.Clamp;
+                        brush_height *= (float)Math.Sqrt(2);
+                        brush_width *= (float)Math.Sqrt(2);
+                        float x_offset = -(float)(Math.Sqrt(2) - 1) * brush_width / 2;
+                        float y_offset = -(float)(Math.Sqrt(2) - 1) * brush_height / 2;
 
-                            if (!rect.IsEmpty)
-                            {
-                                x_offset = (rect.Width / 2.0f) * percent;
-                                y_offset = (rect.Height / 2.0f) * percent;
-
-                                (brush as PathGradientBrush).TranslateTransform(rect.X + x_offset, rect.Y + y_offset);
-                                (brush as PathGradientBrush).ScaleTransform((rect.Width - (2.0f * x_offset)) * 100 / effect_config.gradient_size, (rect.Height - (2.0f * y_offset)) * 100 / effect_config.gradient_size);
-                            }
-                            else
-                            {
-                                (brush as PathGradientBrush).ScaleTransform((Effects.canvas_height + x_offset) * 100 / effect_config.gradient_size, (Effects.canvas_height + y_offset) * 100 / effect_config.gradient_size);
-                            }
-                        }
-                        else
+                        if (!rect.IsEmpty)
                         {
-                            if (!rect.IsEmpty)
-                            {
-                                (brush as PathGradientBrush).TranslateTransform(rect.X, rect.Y);
-                                (brush as PathGradientBrush).ScaleTransform(rect.Width * 100 / effect_config.gradient_size, rect.Height * 100 / effect_config.gradient_size);
-                            }
-                            else
-                            {
-                                (brush as PathGradientBrush).ScaleTransform(Effects.canvas_height * 100 / effect_config.gradient_size, Effects.canvas_height * 100 / effect_config.gradient_size);
-                            }
+                            x_offset += rect.X;
+                            y_offset += rect.Y;
                         }
 
-                        (brush as PathGradientBrush).RotateTransform(effect_config.angle);
+                        (brush as PathGradientBrush).TranslateTransform(x_offset, y_offset);
+                        (brush as PathGradientBrush).ScaleTransform(brush_width, brush_height);
 
-                        //(brush as PathGradientBrush).TranslateTransform(x_shift, y_shift);
+                        (brush as PathGradientBrush).WrapMode = WrapMode.Clamp;
                     }
 
                     Fill(brush);
diff --git a/Project-Aurora/Project-Aurora/Profiles/CloneHero/CloneHeroProfile.cs b/Project-Aurora/Project-Aurora/Profiles/CloneHero/CloneHeroProfile.cs
index 962274d5c..629f03f47 100644
--- a/Project-Aurora/Project-Aurora/Profiles/CloneHero/CloneHeroProfile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/CloneHero/CloneHeroProfile.cs
@@ -53,7 +53,6 @@ public override void Reset()
                             secondary = Color.FromArgb(39, 73, 167),
                             speed = 3,
                             angle = 0,
-                            animation_type = AnimationType.Translate_XY,
                             animation_reverse = false,
                             brush =
                             {
diff --git a/Project-Aurora/Project-Aurora/Settings/LayerEffectConfig.cs b/Project-Aurora/Project-Aurora/Settings/LayerEffectConfig.cs
index b85205f31..7c9faf071 100644
--- a/Project-Aurora/Project-Aurora/Settings/LayerEffectConfig.cs
+++ b/Project-Aurora/Project-Aurora/Settings/LayerEffectConfig.cs
@@ -5,17 +5,6 @@
 
 namespace Aurora.Settings
 {
-    public enum AnimationType
-    {
-        [Description("No Animation")]
-        None,
-        [Description("Translate X and Y")]
-        Translate_XY,
-        [Description("(Radial only) Zoom in")]
-        Zoom_in,
-        [Description("(Radial only) Zoom out")]
-        Zoom_out,
-    };
 
     public class LayerEffectConfig
     {
@@ -24,7 +13,6 @@ public class LayerEffectConfig
         public float speed;
         public float angle;
         public float gradient_size = 100.0f;
-        public AnimationType animation_type;
         public bool animation_reverse;
         public EffectBrush brush;
 
@@ -34,10 +22,9 @@ public class LayerEffectConfig
         // profiles. >:( Little bit frustrating and verbose. Perhaps we can replace this next time there is a breaking change...
         [JsonIgnore] public Color Primary { get => primary; set => primary = value; }
         [JsonIgnore] public Color Secondary { get => secondary; set => secondary = value; }
-        [JsonIgnore] public float Speed { get => speed; set => speed = value; }
+        [JsonIgnore] public float AnimationSpeed { get => speed; set => speed = value; }
         [JsonIgnore] public float Angle { get => angle; set => angle = value; }
         [JsonIgnore] public float GradientSize { get => gradient_size; set => gradient_size = value; }
-        [JsonIgnore] public AnimationType AnimationType { get => animation_type; set => animation_type = value; }
         [JsonIgnore] public bool AnimationReverse { get => animation_reverse; set => animation_reverse = value; }
         [JsonIgnore] public EffectBrush Brush { get => brush; set => brush = value; }
 
@@ -61,7 +48,6 @@ public LayerEffectConfig(Color primary_color, Color secondary_color)
             secondary = secondary_color;
             speed = 1.0f;
             angle = 0.0f;
-            animation_type = AnimationType.Translate_XY;
             animation_reverse = false;
             brush = new EffectBrush(
                 new System.Drawing.Drawing2D.LinearGradientBrush(
@@ -86,7 +72,6 @@ public LayerEffectConfig(LayerEffectConfig otherConfig)
             secondary = otherConfig.secondary;
             speed = otherConfig.speed;
             angle = otherConfig.angle;
-            animation_type = otherConfig.animation_type;
             animation_reverse = otherConfig.animation_reverse;
             brush = otherConfig.brush;
         }
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientFillLayer.xaml b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientFillLayer.xaml
index c4b4ee082..0340f5b62 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientFillLayer.xaml
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientFillLayer.xaml
@@ -11,21 +11,6 @@
              xmlns:eff_config="clr-namespace:Aurora.Settings"
              xmlns:Controls="clr-namespace:Aurora.Controls" x:Class="Aurora.Settings.Layers.Control_GradientFillLayer"
              mc:Ignorable="d" Loaded="UserControl_Loaded">
-    <UserControl.Resources>
-        <ResourceDictionary>
-
-            <ObjectDataProvider x:Key="AnimationType" MethodName="GetValues" ObjectType="{x:Type System:Enum}">
-                <ObjectDataProvider.MethodParameters>
-                    <x:Type TypeName="eff_config:AnimationType" />
-                </ObjectDataProvider.MethodParameters>
-            </ObjectDataProvider>
-            <EnumValueConverters:AnimationTypeToStringVC x:Key="AnimationTypeToStringVC"/>
-            <DataTemplate x:Key="AnimationTypeTemplate">
-                <TextBlock Text="{Binding Converter={StaticResource AnimationTypeToStringVC}}" />
-            </DataTemplate>
-
-        </ResourceDictionary>
-    </UserControl.Resources>
 
     <Grid>
         <Controls:KeySequence x:Name="KeySequence_keys" Margin="265,0,0,0" HorizontalAlignment="Left" Width="230" RecordingTag="SolidColorLayer" Title="Affected Keys" SequenceUpdated="KeySequence_keys_SequenceUpdated"/>
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml
index 114ca5ac8..7806df573 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml
@@ -11,21 +11,6 @@
              xmlns:eff_config="clr-namespace:Aurora.Settings"
              xmlns:Controls="clr-namespace:Aurora.Controls" x:Class="Aurora.Settings.Layers.Control_GradientLayer"
              mc:Ignorable="d" Loaded="UserControl_Loaded">
-    <UserControl.Resources>
-        <ResourceDictionary>
-
-            <ObjectDataProvider x:Key="AnimationType" MethodName="GetValues" ObjectType="{x:Type System:Enum}">
-                <ObjectDataProvider.MethodParameters>
-                    <x:Type TypeName="eff_config:AnimationType" />
-                </ObjectDataProvider.MethodParameters>
-            </ObjectDataProvider>
-            <EnumValueConverters:AnimationTypeToStringVC x:Key="AnimationTypeToStringVC"/>
-            <DataTemplate x:Key="AnimationTypeTemplate">
-                <TextBlock Text="{Binding Converter={StaticResource AnimationTypeToStringVC}}" />
-            </DataTemplate>
-
-        </ResourceDictionary>
-    </UserControl.Resources>
 
     <Grid>
         <Controls:KeySequence x:Name="KeySequence_keys" Margin="265,0,0,24" HorizontalAlignment="Left" Width="230" RecordingTag="SolidColorLayer" Title="Affected Keys" SequenceUpdated="KeySequence_keys_SequenceUpdated"/>
@@ -42,9 +27,7 @@
         <TextBlock HorizontalAlignment="Left" Margin="0,183,0,0" TextWrapping="Wrap" Text="Effect Angle: " VerticalAlignment="Top"/>
         <TextBlock HorizontalAlignment="Left" Margin="139,183,0,0" TextWrapping="Wrap" Text="degrees" VerticalAlignment="Top"/>
         <xctk:IntegerUpDown x:Name="effect_angle" HorizontalAlignment="Left" Height="20" Margin="74,183,0,0" VerticalAlignment="Top" Width="60" Value="0" Minimum="-360" Maximum="360" Increment="1" ValueChanged="effect_angle_ValueChanged"/>
-        <TextBlock HorizontalAlignment="Left" Margin="0,211,0,0" TextWrapping="Wrap" Text="Animation Type: " VerticalAlignment="Top"/>
-        <ComboBox x:Name="effect_animation_type" HorizontalAlignment="Left" Margin="94,208,0,-3" VerticalAlignment="Top" Width="155" IsSynchronizedWithCurrentItem="True" SelectedIndex="0" ItemsSource="{Binding Source={StaticResource AnimationType}}" ItemTemplate="{Binding Source={StaticResource AnimationTypeTemplate}}" SelectionChanged="effect_animation_type_SelectionChanged"/>
-        <CheckBox x:Name="effect_animation_reversed" Content="Reverse animation direction" HorizontalAlignment="Left" Margin="0,235,0,-23" VerticalAlignment="Top" Checked="effect_animation_reversed_Checked" Unchecked="effect_animation_reversed_Checked"/>
+        <CheckBox x:Name="effect_animation_reversed" Content="Reverse animation direction" HorizontalAlignment="Left" Margin="0,221,0,-23" VerticalAlignment="Top" Checked="effect_animation_reversed_Checked" Unchecked="effect_animation_reversed_Checked"/>
 
     </Grid>
 </UserControl>
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml.cs b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml.cs
index e058dcf5b..291cf87c9 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml.cs
@@ -45,7 +45,6 @@ public void SetSettings()
                 this.effect_speed_slider.Value = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.speed;
                 this.effect_speed_label.Text = "x " + (this.DataContext as GradientLayerHandler).Properties._GradientConfig.speed;
                 this.effect_angle.Text = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.angle.ToString();
-                this.effect_animation_type.SelectedIndex = (int)(this.DataContext as GradientLayerHandler).Properties._GradientConfig.animation_type;
                 this.effect_animation_reversed.IsChecked = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.animation_reverse;
                 Brush brush = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush.GetMediaBrush();
                 try
@@ -147,12 +146,6 @@ private void effect_angle_ValueChanged(object sender, RoutedPropertyChangedEvent
             }
         }
 
-        private void effect_animation_type_SelectionChanged(object sender, SelectionChangedEventArgs e)
-        {
-            if (IsLoaded && settingsset && this.DataContext is GradientLayerHandler && sender is ComboBox)
-                (this.DataContext as GradientLayerHandler).Properties._GradientConfig.animation_type = (AnimationType)Enum.Parse(typeof(AnimationType), (sender as ComboBox).SelectedIndex.ToString());
-        }
-
         private void effect_animation_reversed_Checked(object sender, RoutedEventArgs e)
         {
             if (IsLoaded && settingsset && this.DataContext is GradientLayerHandler && sender is CheckBox)
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/GradientFillLayerHandler.cs b/Project-Aurora/Project-Aurora/Settings/Layers/GradientFillLayerHandler.cs
index 743094b65..56733ab33 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/GradientFillLayerHandler.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/GradientFillLayerHandler.cs
@@ -33,7 +33,7 @@ public GradientFillLayerHandlerProperties(bool assign_default = false) : base(as
         public override void Default()
         {
             base.Default();
-            this._GradientConfig = new LayerEffectConfig(Utils.ColorUtils.GenerateRandomColor(), Utils.ColorUtils.GenerateRandomColor()) { AnimationType = AnimationType.None };
+            this._GradientConfig = new LayerEffectConfig(Utils.ColorUtils.GenerateRandomColor(), Utils.ColorUtils.GenerateRandomColor()) { AnimationSpeed = 0 };
             this._FillEntireKeyboard = false;
         }
     }
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/GradientLayerHandler.cs b/Project-Aurora/Project-Aurora/Settings/Layers/GradientLayerHandler.cs
index 55094009b..2ca2605dc 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/GradientLayerHandler.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/GradientLayerHandler.cs
@@ -28,7 +28,7 @@ public GradientLayerHandlerProperties(bool assign_default = false) : base(assign
         public override void Default()
         {
             base.Default();
-            this._GradientConfig = new LayerEffectConfig(Utils.ColorUtils.GenerateRandomColor(), Utils.ColorUtils.GenerateRandomColor()) { AnimationType = AnimationType.None };
+            this._GradientConfig = new LayerEffectConfig(Utils.ColorUtils.GenerateRandomColor(), Utils.ColorUtils.GenerateRandomColor()) { AnimationSpeed = 0 };
         }
     }
 
diff --git a/Project-Aurora/Project-Aurora/Utils/EnumUtils.cs b/Project-Aurora/Project-Aurora/Utils/EnumUtils.cs
index 21c034242..0321fabf1 100755
--- a/Project-Aurora/Project-Aurora/Utils/EnumUtils.cs
+++ b/Project-Aurora/Project-Aurora/Utils/EnumUtils.cs
@@ -266,11 +266,6 @@ public class appexitmodeToStringVC : EnumToStringVC
         public appexitmodeToStringVC() : base(AppExitMode.Ask) { }
     }
 
-    public class AnimationTypeToStringVC : EnumToStringVC
-    {
-        public AnimationTypeToStringVC() : base(AnimationType.None) { }
-    }
-
     /*public class LayerTypeToStringVC : EnumToStringVC
     {
         public LayerTypeToStringVC() : base(LayerType.Solid) { }

From ee74e8f506a06449c59a0e2ea08eb5776d860979 Mon Sep 17 00:00:00 2001
From: Alex <ritt.alex@gmail.com>
Date: Thu, 7 May 2020 01:10:52 +0200
Subject: [PATCH 2/3] Refactor EffectBrush

---
 .../Controls/EffectSettingsWindow.xaml.cs     |    6 +-
 .../AnimationFilledGradientRectangle.cs       |    4 +-
 .../Animations/AnimationGradientCircle.cs     |    5 +-
 .../EffectsEngine/EffectBrush.cs              | 1074 ++++++++++-------
 .../EffectsEngine/EffectLayer.cs              |   16 +-
 .../Profiles/CloneHero/CloneHeroProfile.cs    |    3 +-
 .../Profiles/Desktop/DesktopProfile.cs        |    3 +-
 .../Profiles/ETS2/ETS2Profile.cs              |   15 +-
 .../Project-Aurora/Profiles/Osu/OsuProfile.cs |    3 +-
 .../RocketLeague/RocketLeagueProfile.cs       |    4 +-
 .../Profiles/Subnautica/SubnauticaProfile.cs  |    3 +-
 .../Profiles/Terraria/TerrariaProfile.cs      |    6 +-
 .../Settings/LayerEffectConfig.cs             |    2 +-
 .../Layers/Control_EqualizerLayer.xaml.cs     |    6 +-
 .../Layers/Control_GradientFillLayer.xaml.cs  |    6 +-
 .../Layers/Control_GradientLayer.xaml.cs      |    6 +-
 .../Control_PercentGradientLayer.xaml.cs      |    2 +-
 .../Settings/Layers/EqualizerLayerHandler.cs  |    8 +-
 .../Layers/InteractiveLayerHandler.cs         |    4 +-
 .../Layers/PercentGradientLayerHandler.cs     |    4 +-
 .../Layers/SimpleParticleLayerHandler.cs      |    2 +-
 .../Settings/ProfileImporter.cs               |   52 +-
 .../Project-Aurora/Utils/ColorUtils.cs        |    2 +-
 23 files changed, 686 insertions(+), 550 deletions(-)

diff --git a/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml.cs b/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml.cs
index 363a924d4..be68247d3 100644
--- a/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml.cs
@@ -70,7 +70,7 @@ public EffectSettingsWindow(LayerEffectConfig EffectConfig)
 
         private void Gradient_editor_BrushChanged(object sender, ColorBox.BrushChangedEventArgs e)
         {
-            EffectConfig.brush = new EffectsEngine.EffectBrush(this.gradient_editor.Brush);
+            EffectConfig.brush = EffectsEngine.EffectBrush.GetEffectBrush(this.gradient_editor.Brush);
         }
 
         private void FireEffectConfigUpdated()
@@ -79,7 +79,7 @@ private void FireEffectConfigUpdated()
                 EffectConfigUpdated(this, new EventArgs());
         }
 
-
+        
         private void effect_speed_slider_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
         {
             if (this.IsLoaded)
@@ -114,7 +114,7 @@ private void secondary_color_SelectedColorChanged(object sender, RoutedPropertyC
 
         private void accept_button_Click(object sender, RoutedEventArgs e)
         {
-            EffectConfig.brush = new EffectsEngine.EffectBrush(this.gradient_editor.Brush);
+            EffectConfig.brush = EffectsEngine.EffectBrush.GetEffectBrush(this.gradient_editor.Brush);
             FireEffectConfigUpdated();
             Close();
         }
diff --git a/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationFilledGradientRectangle.cs b/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationFilledGradientRectangle.cs
index 3823b2237..e70e54e63 100644
--- a/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationFilledGradientRectangle.cs
+++ b/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationFilledGradientRectangle.cs
@@ -37,7 +37,7 @@ public AnimationFilledGradientRectangle(float x, float y, float rect_width, floa
 
             PointF rotatePoint = new PointF(_scaledDimension.X, _scaledDimension.Y);
 
-            EffectBrush _newbrush = new EffectBrush(_gradientBrush);
+            EffectBrush _newbrush = (EffectBrush)_gradientBrush.Clone();
             _newbrush.start = new PointF(_newbrush.start.X * scale, _newbrush.start.Y * scale);
             _newbrush.end = new PointF(_newbrush.end.X * scale, _newbrush.end.Y * scale);
 
@@ -79,7 +79,7 @@ public override AnimationFrame GetCopy()
                 _dimension.Height
                 );
 
-            return new AnimationFilledGradientRectangle(newrect, new EffectBrush(_gradientBrush), _duration).SetAngle(_angle).SetTransitionType(_transitionType);
+            return new AnimationFilledGradientRectangle(newrect, (EffectBrush)_gradientBrush.Clone(), _duration).SetAngle(_angle).SetTransitionType(_transitionType);
         }
 
         public override bool Equals(object obj)
diff --git a/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationGradientCircle.cs b/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationGradientCircle.cs
index 0560bb3ad..031e57fdf 100644
--- a/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationGradientCircle.cs
+++ b/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationGradientCircle.cs
@@ -41,7 +41,7 @@ public AnimationGradientCircle(float x, float y, float radius, EffectBrush brush
             RectangleF _scaledDimension = new RectangleF(_dimension.X * scale, _dimension.Y * scale, _dimension.Width * scale, _dimension.Height * scale);
             _scaledDimension.Offset(offset);
 
-            EffectBrush _newbrush = new EffectBrush(_gradientBrush);
+            EffectBrush _newbrush = new RadialEffectBrush(_gradientBrush);
             _newbrush.start = new PointF(0.0f, 0.0f);
             _newbrush.end = new PointF(1.0f, 1.0f);
             _newbrush.center = new PointF(0.5f, 0.5f);
@@ -77,7 +77,6 @@ public AnimationGradientCircle(float x, float y, float radius, EffectBrush brush
                 newColorGradients.Add(0.0f, spectrum.GetColorAt((1 - 1 / _cutOffPoint)));
             }
 
-            _newbrush.SetBrushType(EffectBrush.BrushType.Radial);
             Brush brush = _newbrush.GetDrawingBrush();
 
             if(brush is PathGradientBrush)
@@ -124,7 +123,7 @@ public override AnimationFrame GetCopy()
                 _dimension.Height
                 );
 
-            return new AnimationGradientCircle(newrect, new EffectBrush(_gradientBrush), _width, _duration).SetAngle(_angle).SetTransitionType(_transitionType);
+            return new AnimationGradientCircle(newrect, (EffectBrush)_gradientBrush.Clone(), _width, _duration).SetAngle(_angle).SetTransitionType(_transitionType);
         }
 
         public override bool Equals(object obj)
diff --git a/Project-Aurora/Project-Aurora/EffectsEngine/EffectBrush.cs b/Project-Aurora/Project-Aurora/EffectsEngine/EffectBrush.cs
index 52b9a2512..9ff5c45c4 100644
--- a/Project-Aurora/Project-Aurora/EffectsEngine/EffectBrush.cs
+++ b/Project-Aurora/Project-Aurora/EffectsEngine/EffectBrush.cs
@@ -1,18 +1,12 @@
-using Newtonsoft.Json;
+using Aurora.Utils;
+using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
 
 namespace Aurora.EffectsEngine
 {
-    public class EffectBrush
+    public abstract class EffectBrush : ICloneable
     {
-        public enum BrushType
-        {
-            None,
-            Solid,
-            Linear,
-            Radial
-        };
 
         public enum BrushWrap
         {
@@ -21,7 +15,6 @@ public enum BrushWrap
             Reflect
         };
 
-        public BrushType type = BrushType.None;
         public BrushWrap wrap = BrushWrap.None;
         [JsonProperty("color_gradients")]
         public SortedDictionary<float, System.Drawing.Color> colorGradients = new SortedDictionary<float, System.Drawing.Color>();
@@ -29,12 +22,182 @@ public enum BrushWrap
         public System.Drawing.PointF end;
         public System.Drawing.PointF center;
 
-        private System.Drawing.Brush _drawingBrush = null;
-        private System.Windows.Media.Brush _mediaBrush = null;
+        protected System.Drawing.Brush _drawingBrush = null;
+        protected System.Windows.Media.Brush _mediaBrush = null;
+
+        public static EffectBrush GetEffectBrush(System.Drawing.Brush brush)
+        {
+            if (brush is System.Drawing.SolidBrush solidBrush)
+            {
+                return new SolidEffectBrush(solidBrush);
+            }
+            else if (brush is System.Drawing.Drawing2D.LinearGradientBrush linearBrush)
+            {
+                return new LinearEffectBrush(linearBrush);
+            }
+            else if (brush is System.Drawing.Drawing2D.PathGradientBrush radialBrush)
+            {
+                return new RadialEffectBrush(radialBrush);
+            }
+            return new SolidEffectBrush(brush as System.Drawing.SolidBrush);
+        }
+        public static EffectBrush GetEffectBrush(System.Windows.Media.Brush brush)
+        {
+            if (brush is System.Windows.Media.SolidColorBrush solidBrush)
+            {
+                return new SolidEffectBrush(solidBrush);
+            }
+            else if (brush is System.Windows.Media.LinearGradientBrush linearBrush)
+            {
+                return new LinearEffectBrush(linearBrush);
+            }
+            else if (brush is System.Windows.Media.RadialGradientBrush radialBrush)
+            {
+                return new RadialEffectBrush(radialBrush);
+            }
+            return new SolidEffectBrush(brush as System.Windows.Media.SolidColorBrush);
+        }
+
+        public EffectBrush SetWrap(BrushWrap wrap)
+        {
+            this.wrap = wrap;
+            return this;
+        }
+        protected void CheckColorGradients()
+        {
+            if (colorGradients.Count > 0)
+            {
+                bool firstFound = false;
+                System.Drawing.Color first_color = new System.Drawing.Color();
+                System.Drawing.Color last_color = new System.Drawing.Color();
+
+                foreach (var kvp in colorGradients)
+                {
+                    if (!firstFound)
+                    {
+                        first_color = kvp.Value;
+                        firstFound = true;
+                    }
+
+                    last_color = kvp.Value;
+                }
+
+                if (!colorGradients.ContainsKey(0.0f))
+                    colorGradients.Add(0.0f, first_color);
+
+                if (!colorGradients.ContainsKey(1.0f))
+                    colorGradients.Add(1.0f, last_color);
+            }
+            else
+            {
+                if (!colorGradients.ContainsKey(0.0f))
+                    colorGradients.Add(0.0f, System.Drawing.Color.Transparent);
+
+                if (!colorGradients.ContainsKey(1.0f))
+                    colorGradients.Add(1.0f, System.Drawing.Color.Transparent);
+            }
+        }
+        protected SortedDictionary<float, System.Drawing.Color> GetColorGradientsForWindow(float shift, float window_size, float starting_value = 0)
+        {
+            SortedDictionary<float, System.Drawing.Color> gradients = new SortedDictionary<float, System.Drawing.Color>();
+            float previousKey = 0;
+            foreach (var kvp in colorGradients)
+            {
+                if (kvp.Key >= shift)
+                {
+                    if (gradients.Count == 0 && kvp.Key != 0)
+                    {
+                        gradients[starting_value] = Utils.ColorUtils.BlendColors(colorGradients[previousKey], kvp.Value, (shift - previousKey) / (kvp.Key - previousKey));
+                    }
+
+                    float index = starting_value + (kvp.Key - shift) / window_size;
+                    if (kvp.Key <= shift + window_size && index <= 1)
+                    {
+                        gradients[index] = kvp.Value;
+                    }
+                    else
+                    {
+                        gradients[1] = Utils.ColorUtils.BlendColors(colorGradients[previousKey], kvp.Value, (shift + window_size - previousKey) / (kvp.Key - previousKey));
+                        return gradients;
+                    }
+
+                    if (kvp.Key == 1)
+                    {
+                        foreach (var gradient in GetColorGradientsForWindow(0, window_size + shift - previousKey, starting_value + (1 - shift) / window_size))
+                        {
+                            gradients[gradient.Key] = gradient.Value;
+                        }
+                    }
+                }
+                previousKey = kvp.Key;
+            }
+            return gradients;
+        }
+        public abstract System.Drawing.Brush GetDrawingBrush();
+        public abstract System.Drawing.Brush GetDrawingBrush(float shift, float window_size);
+
+        public abstract System.Windows.Media.Brush GetMediaBrush();
+
+        public abstract ColorSpectrum GetColorSpectrum();
+
+        /// <summary>
+        /// Blends two EffectBrushes together by a specified amount
+        /// </summary>
+        /// <param name="otherBrush">The foreground EffectBrush (When percent is at 1.0D, only this EffectBrush is shown)</param>
+        /// <param name="percent">The blending percent value</param>
+        /// <returns>The blended EffectBrush</returns>
+        public abstract EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent);
+
+        public object Clone()
+        {
+            var clone = (EffectBrush)this.MemberwiseClone();
+            HandleCloned(clone);
+            return clone;
+        }
+        protected virtual void HandleCloned(EffectBrush clone)
+        {
+            //Nothing particular in the base class, but maybe useful for children.
+            //Not abstract so children may not implement this if they don't need to.
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((EffectBrush)obj);
+        }
+
+        public bool Equals(EffectBrush p)
+        {
+            if (ReferenceEquals(null, p)) return false;
+            if (ReferenceEquals(this, p)) return true;
+
+            return (wrap == p.wrap &&
+                colorGradients.Equals(p.colorGradients) &&
+                start.Equals(p.start) &&
+                end.Equals(p.end) &&
+                center.Equals(p.center));
+        }
 
-        public EffectBrush()
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+                hash = hash * 23 + wrap.GetHashCode();
+                hash = hash * 23 + colorGradients.GetHashCode();
+                hash = hash * 23 + start.GetHashCode();
+                hash = hash * 23 + end.GetHashCode();
+                hash = hash * 23 + center.GetHashCode();
+                return hash;
+            }
+        }
+    }
+    public class SolidEffectBrush : EffectBrush
+    {
+        public SolidEffectBrush()
         {
-            type = BrushType.Solid;
 
             colorGradients.Add(0.0f, System.Drawing.Color.Red);
             colorGradients.Add(1.0f, System.Drawing.Color.Blue);
@@ -44,20 +207,16 @@ public EffectBrush()
             center = new System.Drawing.PointF(0.0f, 0.0f);
         }
 
-        public EffectBrush(EffectBrush otherBrush)
+        public SolidEffectBrush(EffectBrush otherBrush)
         {
-            this.type = otherBrush.type;
             this.wrap = otherBrush.wrap;
             this.colorGradients = otherBrush.colorGradients;
             this.start = otherBrush.start;
             this.end = otherBrush.end;
             this.center = otherBrush.center;
         }
-
-        public EffectBrush(ColorSpectrum spectrum)
+        public SolidEffectBrush(ColorSpectrum spectrum)
         {
-            type = BrushType.Linear;
-
             foreach (var color in spectrum.GetSpectrumColors())
                 colorGradients.Add(color.Key, color.Value);
 
@@ -66,189 +225,196 @@ public EffectBrush(ColorSpectrum spectrum)
             center = new System.Drawing.PointF(0.0f, 0.0f);
         }
 
-        public EffectBrush(System.Drawing.Brush brush)
+
+        public SolidEffectBrush(System.Drawing.SolidBrush brush)
         {
-            if (brush is System.Drawing.SolidBrush)
-            {
-                type = BrushType.Solid;
 
-                colorGradients.Add(0.0f, (brush as System.Drawing.SolidBrush).Color);
-                colorGradients.Add(1.0f, (brush as System.Drawing.SolidBrush).Color);
+            colorGradients.Add(0.0f, brush.Color);
+            colorGradients.Add(1.0f, brush.Color);
 
-                wrap = BrushWrap.Repeat;
-            }
-            else if (brush is System.Drawing.Drawing2D.LinearGradientBrush)
-            {
-                type = BrushType.Linear;
+            wrap = BrushWrap.Repeat;
 
-                System.Drawing.Drawing2D.LinearGradientBrush lgb = (brush as System.Drawing.Drawing2D.LinearGradientBrush);
+            CheckColorGradients();
 
-                start = lgb.Rectangle.Location;
-                end = new System.Drawing.PointF(lgb.Rectangle.Width, lgb.Rectangle.Height);
-                center = new System.Drawing.PointF(0.0f, 0.0f);
+        }
 
-                switch (lgb.WrapMode)
-                {
-                    case (System.Drawing.Drawing2D.WrapMode.Clamp):
-                        wrap = BrushWrap.None;
-                        break;
-                    case (System.Drawing.Drawing2D.WrapMode.Tile):
-                        wrap = BrushWrap.Repeat;
-                        break;
-                    case (System.Drawing.Drawing2D.WrapMode.TileFlipXY):
-                        wrap = BrushWrap.Reflect;
-                        break;
-                }
+        public SolidEffectBrush(System.Windows.Media.SolidColorBrush brush)
+        {
+            wrap = BrushWrap.Repeat;
 
-                try
-                {
-                    if (lgb.InterpolationColors != null && lgb.InterpolationColors.Colors.Length == lgb.InterpolationColors.Positions.Length)
-                    {
-                        for (int x = 0; x < lgb.InterpolationColors.Colors.Length; x++)
-                        {
-                            if (!colorGradients.ContainsKey(lgb.InterpolationColors.Positions[x]) && (lgb.InterpolationColors.Positions[x] >= 0.0f && lgb.InterpolationColors.Positions[x] <= 1.0f))
-                                colorGradients.Add(
-                                    lgb.InterpolationColors.Positions[x],
-                                    lgb.InterpolationColors.Colors[x]
-                                    );
-                        }
-                    }
-                }
-                catch (Exception exc)
-                {
-                    colorGradients.Clear();
+            colorGradients.Add(0.0f, Utils.ColorUtils.MediaColorToDrawingColor(brush.Color));
+            colorGradients.Add(1.0f, Utils.ColorUtils.MediaColorToDrawingColor(brush.Color));
 
-                    for (int x = 0; x < lgb.LinearColors.Length; x++)
-                    {
-                        float pos = x / (float)(lgb.LinearColors.Length - 1);
+            CheckColorGradients();
+        }
+        public override System.Drawing.Brush GetDrawingBrush()
+        {
+            if (true/*_drawingbrush == null*/)
+            {
+                    _drawingBrush = new System.Drawing.SolidBrush(colorGradients[0.0f]);
 
-                        if (!colorGradients.ContainsKey(pos))
-                            colorGradients.Add(
-                                pos,
-                                lgb.LinearColors[x]
-                                );
-                    }
-                }
             }
-            else if (brush is System.Drawing.Drawing2D.PathGradientBrush)
+
+            return _drawingBrush;
+        }
+
+        public override System.Drawing.Brush GetDrawingBrush(float shift, float window_size)
+        {
+            if (true/*_drawingbrush == null*/)
+            {
+                    _drawingBrush = new System.Drawing.SolidBrush(colorGradients[0.0f]);
+     
+            }
+
+            return _drawingBrush;
+        }
+        public override System.Windows.Media.Brush GetMediaBrush()
+        {
+            if (_mediaBrush == null)
             {
-                type = BrushType.Radial;
+                    System.Windows.Media.SolidColorBrush brush = new System.Windows.Media.SolidColorBrush(
+                        Utils.ColorUtils.DrawingColorToMediaColor(colorGradients[0.0f])
+                        );
+                    brush.Freeze();
 
-                System.Drawing.Drawing2D.PathGradientBrush pgb = (brush as System.Drawing.Drawing2D.PathGradientBrush);
+                    _mediaBrush = brush;
+            }
 
-                start = pgb.Rectangle.Location;
-                end = new System.Drawing.PointF(pgb.Rectangle.Width, pgb.Rectangle.Height);
-                center = new System.Drawing.PointF(
-                    pgb.CenterPoint.X,
-                    pgb.CenterPoint.Y
-                    );
+            return _mediaBrush;
+        }
 
+        public override ColorSpectrum GetColorSpectrum() => new ColorSpectrum(colorGradients[0.0f]);
 
-                switch (pgb.WrapMode)
-                {
-                    case (System.Drawing.Drawing2D.WrapMode.Clamp):
-                        wrap = BrushWrap.None;
-                        break;
-                    case (System.Drawing.Drawing2D.WrapMode.Tile):
-                        wrap = BrushWrap.Repeat;
-                        break;
-                    case (System.Drawing.Drawing2D.WrapMode.TileFlipXY):
-                        wrap = BrushWrap.Reflect;
-                        break;
-                }
 
-                try
-                {
-                    if (pgb.InterpolationColors != null && pgb.InterpolationColors.Colors.Length == pgb.InterpolationColors.Positions.Length)
-                    {
-                        for (int x = 0; x < pgb.InterpolationColors.Colors.Length; x++)
-                        {
-                            if (!colorGradients.ContainsKey(pgb.InterpolationColors.Positions[x]) && (pgb.InterpolationColors.Positions[x] >= 0.0f && pgb.InterpolationColors.Positions[x] <= 1.0f))
-                                colorGradients.Add(
-                                    pgb.InterpolationColors.Positions[x],
-                                    pgb.InterpolationColors.Colors[x]
-                                    );
-                        }
-                    }
-                }
-                catch (Exception exc)
-                {
-                    colorGradients.Clear();
+        /// <summary>
+        /// Blends two EffectBrushes together by a specified amount
+        /// </summary>
+        /// <param name="otherBrush">The foreground EffectBrush (When percent is at 1.0D, only this EffectBrush is shown)</param>
+        /// <param name="percent">The blending percent value</param>
+        /// <returns>The blended EffectBrush</returns>
+        public override EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent)
+        {
+            if (percent <= 0.0)
+                return (EffectBrush)this.Clone();
+            else if (percent >= 1.0)
+                return (EffectBrush)otherBrush.Clone();
 
-                    for (int x = 0; x < pgb.SurroundColors.Length; x++)
-                    {
-                        float pos = x / (float)(pgb.SurroundColors.Length - 1);
+            ColorSpectrum currentSpectrum = new ColorSpectrum(GetColorSpectrum());
+            ColorSpectrum newSpectrum = new ColorSpectrum(currentSpectrum).MultiplyByScalar(1.0 - percent);
 
-                        if (!colorGradients.ContainsKey(pos))
-                            colorGradients.Add(
-                                pos,
-                                pgb.SurroundColors[x]
-                                );
-                    }
-                }
-            }
-            else
+            foreach (var kvp in otherBrush.colorGradients)
             {
+                System.Drawing.Color bgColor = currentSpectrum.GetColorAt(kvp.Key);
+                System.Drawing.Color fgColor = kvp.Value;
 
+                newSpectrum.SetColorAt(kvp.Key, Utils.ColorUtils.BlendColors(bgColor, fgColor, percent));
             }
 
-            if (colorGradients.Count > 0)
+            EffectBrush returnBrush = new SolidEffectBrush(newSpectrum);
+            returnBrush.wrap = wrap;
+
+            returnBrush.start = new System.Drawing.PointF((float)(start.X * (1.0 - percent) + otherBrush.start.X * (percent)), (float)(start.Y * (1.0 - percent) + otherBrush.start.Y * (percent)));
+            returnBrush.end = new System.Drawing.PointF((float)(end.X * (1.0 - percent) + otherBrush.end.X * (percent)), (float)(end.Y * (1.0 - percent) + otherBrush.end.Y * (percent)));
+            returnBrush.center = new System.Drawing.PointF((float)(center.X * (1.0 - percent) + otherBrush.center.X * (percent)), (float)(center.Y * (1.0 - percent) + otherBrush.center.Y * (percent)));
+
+            return returnBrush;
+        }
+        
+    }
+    public class LinearEffectBrush : EffectBrush
+    {
+        public LinearEffectBrush()
+        {
+            colorGradients.Add(0.0f, System.Drawing.Color.Red);
+            colorGradients.Add(1.0f, System.Drawing.Color.Blue);
+
+            start = new System.Drawing.PointF(0, 0);
+            end = new System.Drawing.PointF(1, 0);
+            center = new System.Drawing.PointF(0.0f, 0.0f);
+        }
+
+        public LinearEffectBrush(EffectBrush otherBrush)
+        {
+            this.wrap = otherBrush.wrap;
+            this.colorGradients = otherBrush.colorGradients;
+            this.start = otherBrush.start;
+            this.end = otherBrush.end;
+            this.center = otherBrush.center;
+        }
+
+        public LinearEffectBrush(ColorSpectrum spectrum)
+        {
+            foreach (var color in spectrum.GetSpectrumColors())
+                colorGradients.Add(color.Key, color.Value);
+
+            start = new System.Drawing.PointF(0, 0);
+            end = new System.Drawing.PointF(1, 0);
+            center = new System.Drawing.PointF(0.0f, 0.0f);
+        }
+
+        public LinearEffectBrush(System.Drawing.Drawing2D.LinearGradientBrush brush)
+        {
+            start = brush.Rectangle.Location;
+            end = new System.Drawing.PointF(brush.Rectangle.Width, brush.Rectangle.Height);
+            center = new System.Drawing.PointF(0.0f, 0.0f);
+
+            switch (brush.WrapMode)
             {
-                bool firstFound = false;
-                System.Drawing.Color first_color = new System.Drawing.Color();
-                System.Drawing.Color last_color = new System.Drawing.Color();
+                case (System.Drawing.Drawing2D.WrapMode.Clamp):
+                    wrap = BrushWrap.None;
+                    break;
+                case (System.Drawing.Drawing2D.WrapMode.Tile):
+                    wrap = BrushWrap.Repeat;
+                    break;
+                case (System.Drawing.Drawing2D.WrapMode.TileFlipXY):
+                    wrap = BrushWrap.Reflect;
+                    break;
+            }
 
-                foreach (var kvp in colorGradients)
+            try
+            {
+                if (brush.InterpolationColors != null && brush.InterpolationColors.Colors.Length == brush.InterpolationColors.Positions.Length)
                 {
-                    if (!firstFound)
+                    for (int x = 0; x < brush.InterpolationColors.Colors.Length; x++)
                     {
-                        first_color = kvp.Value;
-                        firstFound = true;
+                        if (!colorGradients.ContainsKey(brush.InterpolationColors.Positions[x]) && (brush.InterpolationColors.Positions[x] >= 0.0f && brush.InterpolationColors.Positions[x] <= 1.0f))
+                            colorGradients.Add(
+                                brush.InterpolationColors.Positions[x],
+                                brush.InterpolationColors.Colors[x]
+                                );
                     }
-
-                    last_color = kvp.Value;
                 }
-
-                if (!colorGradients.ContainsKey(0.0f))
-                    colorGradients.Add(0.0f, first_color);
-
-                if (!colorGradients.ContainsKey(1.0f))
-                    colorGradients.Add(1.0f, last_color);
             }
-            else
+            catch (Exception exc)
             {
-                if (!colorGradients.ContainsKey(0.0f))
-                    colorGradients.Add(0.0f, System.Drawing.Color.Transparent);
+                colorGradients.Clear();
 
-                if (!colorGradients.ContainsKey(1.0f))
-                    colorGradients.Add(1.0f, System.Drawing.Color.Transparent);
-            }
+                for (int x = 0; x < brush.LinearColors.Length; x++)
+                {
+                    float pos = x / (float)(brush.LinearColors.Length - 1);
 
+                    if (!colorGradients.ContainsKey(pos))
+                        colorGradients.Add(
+                            pos,
+                            brush.LinearColors[x]
+                            );
+                }
+            }
 
-        }
 
-        public EffectBrush(System.Windows.Media.Brush brush)
-        {
-            if (brush is System.Windows.Media.SolidColorBrush)
-            {
-                type = BrushType.Solid;
+            CheckColorGradients();
 
-                wrap = BrushWrap.Repeat;
 
-                colorGradients.Add(0.0f, Utils.ColorUtils.MediaColorToDrawingColor((brush as System.Windows.Media.SolidColorBrush).Color));
-                colorGradients.Add(1.0f, Utils.ColorUtils.MediaColorToDrawingColor((brush as System.Windows.Media.SolidColorBrush).Color));
-            }
-            else if (brush is System.Windows.Media.LinearGradientBrush)
-            {
-                type = BrushType.Linear;
+        }
 
-                System.Windows.Media.LinearGradientBrush lgb = (brush as System.Windows.Media.LinearGradientBrush);
+        public LinearEffectBrush(System.Windows.Media.LinearGradientBrush brush)
+        {
 
-                start = new System.Drawing.PointF((float)lgb.StartPoint.X, (float)lgb.StartPoint.Y);
-                end = new System.Drawing.PointF((float)lgb.EndPoint.X, (float)lgb.EndPoint.Y);
+                start = new System.Drawing.PointF((float)brush.StartPoint.X, (float)brush.StartPoint.Y);
+                end = new System.Drawing.PointF((float)brush.EndPoint.X, (float)brush.EndPoint.Y);
                 center = new System.Drawing.PointF(0.0f, 0.0f);
 
-                switch (lgb.SpreadMethod)
+                switch (brush.SpreadMethod)
                 {
                     case (System.Windows.Media.GradientSpreadMethod.Pad):
                         wrap = BrushWrap.None;
@@ -261,7 +427,7 @@ public EffectBrush(System.Windows.Media.Brush brush)
                         break;
                 }
 
-                foreach (var grad in lgb.GradientStops)
+                foreach (var grad in brush.GradientStops)
                 {
                     if (!colorGradients.ContainsKey((float)grad.Offset) && ((float)grad.Offset >= 0.0f && (float)grad.Offset <= 1.0f))
                         colorGradients.Add(
@@ -269,140 +435,311 @@ public EffectBrush(System.Windows.Media.Brush brush)
                             Utils.ColorUtils.MediaColorToDrawingColor(grad.Color)
                             );
                 }
+
+
+            CheckColorGradients();
+        }
+        public override System.Drawing.Brush GetDrawingBrush()
+        {
+            if (true/*_drawingbrush == null*/)
+            {
+                    System.Drawing.Drawing2D.LinearGradientBrush brush = new System.Drawing.Drawing2D.LinearGradientBrush(
+                        start,
+                        end,
+                        System.Drawing.Color.Red,
+                        System.Drawing.Color.Red
+                        );
+
+                    List<System.Drawing.Color> brush_colors = new List<System.Drawing.Color>();
+                    List<float> brush_positions = new List<float>();
+
+                    foreach (var kvp in colorGradients)
+                    {
+                        brush_positions.Add(kvp.Key);
+                        brush_colors.Add(kvp.Value);
+                    }
+
+                    System.Drawing.Drawing2D.ColorBlend color_blend = new System.Drawing.Drawing2D.ColorBlend();
+                    color_blend.Colors = brush_colors.ToArray();
+                    color_blend.Positions = brush_positions.ToArray();
+                    brush.InterpolationColors = color_blend;
+
+                    switch (wrap)
+                    {
+                        //case BrushWrap.None:
+                        //    brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
+                        //    break;
+                        case BrushWrap.Repeat:
+                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Tile;
+                            break;
+                        case BrushWrap.Reflect:
+                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.TileFlipXY;
+                            break;
+                    }
+
+                    _drawingBrush = brush;
+
+            }
+
+            return _drawingBrush;
+        }
+
+        public override System.Drawing.Brush GetDrawingBrush(float shift, float window_size)
+        {
+            if (true/*_drawingbrush == null*/)
+            {
+
+                    System.Drawing.Drawing2D.LinearGradientBrush brush = new System.Drawing.Drawing2D.LinearGradientBrush(
+                        start,
+                        new System.Drawing.PointF(100 / window_size, 0),
+                        System.Drawing.Color.Red,
+                        System.Drawing.Color.Red
+                        );
+
+                    List<System.Drawing.Color> brush_colors = new List<System.Drawing.Color>();
+                    List<float> brush_positions = new List<float>();
+
+                    foreach (var kvp in colorGradients)
+                    {
+                        brush_positions.Add(kvp.Key);
+                        brush_colors.Add(kvp.Value);
+                    }
+
+                    System.Drawing.Drawing2D.ColorBlend color_blend = new System.Drawing.Drawing2D.ColorBlend();
+                    color_blend.Colors = brush_colors.ToArray();
+                    color_blend.Positions = brush_positions.ToArray();
+                    brush.InterpolationColors = color_blend;
+
+                    switch (wrap)
+                    {
+                        //case BrushWrap.None:
+                        //    brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
+                        //    break;
+                        case BrushWrap.Repeat:
+                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Tile;
+                            break;
+                        case BrushWrap.Reflect:
+                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.TileFlipXY;
+                            break;
+                    }
+
+                    _drawingBrush = brush;
+               
             }
-            else if (brush is System.Windows.Media.RadialGradientBrush)
+
+            return _drawingBrush;
+        }
+        public override System.Windows.Media.Brush GetMediaBrush()
+        {
+            if (_mediaBrush == null)
             {
-                type = BrushType.Radial;
+                System.Windows.Media.GradientStopCollection collection = new System.Windows.Media.GradientStopCollection();
 
-                System.Windows.Media.RadialGradientBrush rgb = (brush as System.Windows.Media.RadialGradientBrush);
+                foreach (var kvp in colorGradients)
+                {
+                    collection.Add(
+                        new System.Windows.Media.GradientStop(
+                            Utils.ColorUtils.DrawingColorToMediaColor(kvp.Value),
+                            kvp.Key)
+                        );
+                }
 
-                start = new System.Drawing.PointF(0, 0);
-                end = new System.Drawing.PointF((float)rgb.RadiusX * 2.0f, (float)rgb.RadiusY * 2.0f);
-                center = new System.Drawing.PointF(
-                    (float)rgb.Center.X,
-                    (float)rgb.Center.Y
-                    );
+                System.Windows.Media.LinearGradientBrush brush = new System.Windows.Media.LinearGradientBrush(collection);
+                brush.StartPoint = new System.Windows.Point(start.X, start.Y);
+                brush.EndPoint = new System.Windows.Point(end.X, end.Y);
 
-                switch (rgb.SpreadMethod)
+                switch (wrap)
                 {
-                    case (System.Windows.Media.GradientSpreadMethod.Pad):
-                        wrap = BrushWrap.None;
+                    case BrushWrap.None:
+                        brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Pad;
                         break;
-                    case (System.Windows.Media.GradientSpreadMethod.Repeat):
-                        wrap = BrushWrap.Repeat;
+                    case BrushWrap.Repeat:
+                        brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Repeat;
                         break;
-                    case (System.Windows.Media.GradientSpreadMethod.Reflect):
-                        wrap = BrushWrap.Reflect;
+                    case BrushWrap.Reflect:
+                        brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Reflect;
                         break;
                 }
 
-                foreach (var grad in rgb.GradientStops)
-                {
-                    if (!colorGradients.ContainsKey((float)grad.Offset) && ((float)grad.Offset >= 0.0f && (float)grad.Offset <= 1.0f))
-                        colorGradients.Add(
-                            (float)grad.Offset,
-                            Utils.ColorUtils.MediaColorToDrawingColor(grad.Color)
-                            );
-                }
+                _mediaBrush = brush;
             }
-            else
+
+            return _mediaBrush;
+        }
+
+        public override ColorSpectrum GetColorSpectrum()
+        {
+            ColorSpectrum spectrum = new ColorSpectrum();
+            foreach (var color in colorGradients)
+                spectrum.SetColorAt(color.Key, color.Value);
+
+
+            return spectrum;
+        }
+
+        /// <summary>
+        /// Blends two EffectBrushes together by a specified amount
+        /// </summary>
+        /// <param name="otherBrush">The foreground EffectBrush (When percent is at 1.0D, only this EffectBrush is shown)</param>
+        /// <param name="percent">The blending percent value</param>
+        /// <returns>The blended EffectBrush</returns>
+        public override EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent)
+        {
+            if (percent <= 0.0)
+                return (EffectBrush)this.Clone();
+            else if (percent >= 1.0)
+                return (EffectBrush)otherBrush.Clone();
+
+            ColorSpectrum currentSpectrum = new ColorSpectrum(GetColorSpectrum());
+            ColorSpectrum newSpectrum = new ColorSpectrum(currentSpectrum).MultiplyByScalar(1.0 - percent);
+
+            foreach (var kvp in otherBrush.colorGradients)
             {
+                System.Drawing.Color bgColor = currentSpectrum.GetColorAt(kvp.Key);
+                System.Drawing.Color fgColor = kvp.Value;
+
+                newSpectrum.SetColorAt(kvp.Key, Utils.ColorUtils.BlendColors(bgColor, fgColor, percent));
+            }
+
+            EffectBrush returnBrush = new LinearEffectBrush(newSpectrum);
+            returnBrush.wrap =wrap;
+
+            returnBrush.start = new System.Drawing.PointF((float)(start.X * (1.0 - percent) + otherBrush.start.X * (percent)), (float)(start.Y * (1.0 - percent) + otherBrush.start.Y * (percent)));
+            returnBrush.end = new System.Drawing.PointF((float)(end.X * (1.0 - percent) + otherBrush.end.X * (percent)), (float)(end.Y * (1.0 - percent) + otherBrush.end.Y * (percent)));
+            returnBrush.center = new System.Drawing.PointF((float)(center.X * (1.0 - percent) + otherBrush.center.X * (percent)), (float)(center.Y * (1.0 - percent) + otherBrush.center.Y * (percent)));
+
+            return returnBrush;
+        }
+    }
+    public class RadialEffectBrush : EffectBrush
+    {
+        public RadialEffectBrush()
+        {
+
+            colorGradients.Add(0.0f, System.Drawing.Color.Red);
+            colorGradients.Add(1.0f, System.Drawing.Color.Blue);
+
+            start = new System.Drawing.PointF(0, 0);
+            end = new System.Drawing.PointF(1, 0);
+            center = new System.Drawing.PointF(0.0f, 0.0f);
+        }
+
+        public RadialEffectBrush(EffectBrush otherBrush)
+        {
+            this.wrap = otherBrush.wrap;
+            this.colorGradients = otherBrush.colorGradients;
+            this.start = otherBrush.start;
+            this.end = otherBrush.end;
+            this.center = otherBrush.center;
+        }
+
+        public RadialEffectBrush(ColorSpectrum spectrum)
+        {
+            foreach (var color in spectrum.GetSpectrumColors())
+                colorGradients.Add(color.Key, color.Value);
+
+            start = new System.Drawing.PointF(0, 0);
+            end = new System.Drawing.PointF(1, 0);
+            center = new System.Drawing.PointF(0.0f, 0.0f);
+        }
 
-            }
+        public RadialEffectBrush(System.Drawing.Drawing2D.PathGradientBrush brush)
+        {
+            start = brush.Rectangle.Location;
+            end = new System.Drawing.PointF(brush.Rectangle.Width, brush.Rectangle.Height);
+            center = new System.Drawing.PointF(
+                brush.CenterPoint.X,
+                brush.CenterPoint.Y
+                );
 
-            if (colorGradients.Count > 0)
+
+            switch (brush.WrapMode)
             {
-                bool firstFound = false;
-                System.Drawing.Color first_color = new System.Drawing.Color();
-                System.Drawing.Color last_color = new System.Drawing.Color();
+                case (System.Drawing.Drawing2D.WrapMode.Clamp):
+                    wrap = BrushWrap.None;
+                    break;
+                case (System.Drawing.Drawing2D.WrapMode.Tile):
+                    wrap = BrushWrap.Repeat;
+                    break;
+                case (System.Drawing.Drawing2D.WrapMode.TileFlipXY):
+                    wrap = BrushWrap.Reflect;
+                    break;
+            }
 
-                foreach (var kvp in colorGradients)
+            try
+            {
+                if (brush.InterpolationColors != null && brush.InterpolationColors.Colors.Length == brush.InterpolationColors.Positions.Length)
                 {
-                    if (!firstFound)
+                    for (int x = 0; x < brush.InterpolationColors.Colors.Length; x++)
                     {
-                        first_color = kvp.Value;
-                        firstFound = true;
+                        if (!colorGradients.ContainsKey(brush.InterpolationColors.Positions[x]) && (brush.InterpolationColors.Positions[x] >= 0.0f && brush.InterpolationColors.Positions[x] <= 1.0f))
+                            colorGradients.Add(
+                                brush.InterpolationColors.Positions[x],
+                                brush.InterpolationColors.Colors[x]
+                                );
                     }
-
-                    last_color = kvp.Value;
                 }
-
-                if (!colorGradients.ContainsKey(0.0f))
-                    colorGradients.Add(0.0f, first_color);
-
-                if (!colorGradients.ContainsKey(1.0f))
-                    colorGradients.Add(1.0f, last_color);
             }
-            else
+            catch (Exception exc)
             {
-                if (!colorGradients.ContainsKey(0.0f))
-                    colorGradients.Add(0.0f, System.Drawing.Color.Transparent);
+                colorGradients.Clear();
 
-                if (!colorGradients.ContainsKey(1.0f))
-                    colorGradients.Add(1.0f, System.Drawing.Color.Transparent);
+                for (int x = 0; x < brush.SurroundColors.Length; x++)
+                {
+                    float pos = x / (float)(brush.SurroundColors.Length - 1);
+
+                    if (!colorGradients.ContainsKey(pos))
+                        colorGradients.Add(
+                            pos,
+                            brush.SurroundColors[x]
+                            );
+                }
             }
-        }
 
-        public EffectBrush SetBrushType(BrushType type)
-        {
-            this.type = type;
-            return this;
-        }
 
-        public EffectBrush SetWrap(BrushWrap wrap)
-        {
-            this.wrap = wrap;
-            return this;
+            CheckColorGradients();
+
+
         }
 
-        public System.Drawing.Brush GetDrawingBrush()
+        public RadialEffectBrush(System.Windows.Media.RadialGradientBrush brush)
         {
-            if (true/*_drawingbrush == null*/)
-            {
-                if (type == BrushType.Solid)
-                {
-                    _drawingBrush = new System.Drawing.SolidBrush(colorGradients[0.0f]);
-                }
-                else if (type == BrushType.Linear)
-                {
-                    System.Drawing.Drawing2D.LinearGradientBrush brush = new System.Drawing.Drawing2D.LinearGradientBrush(
-                        start,
-                        end,
-                        System.Drawing.Color.Red,
-                        System.Drawing.Color.Red
-                        );
 
-                    List<System.Drawing.Color> brush_colors = new List<System.Drawing.Color>();
-                    List<float> brush_positions = new List<float>();
-
-                    foreach (var kvp in colorGradients)
-                    {
-                        brush_positions.Add(kvp.Key);
-                        brush_colors.Add(kvp.Value);
-                    }
+            start = new System.Drawing.PointF(0, 0);
+            end = new System.Drawing.PointF((float)brush.RadiusX * 2.0f, (float)brush.RadiusY * 2.0f);
+            center = new System.Drawing.PointF(
+                (float)brush.Center.X,
+                (float)brush.Center.Y
+                );
 
-                    System.Drawing.Drawing2D.ColorBlend color_blend = new System.Drawing.Drawing2D.ColorBlend();
-                    color_blend.Colors = brush_colors.ToArray();
-                    color_blend.Positions = brush_positions.ToArray();
-                    brush.InterpolationColors = color_blend;
+            switch (brush.SpreadMethod)
+            {
+                case (System.Windows.Media.GradientSpreadMethod.Pad):
+                    wrap = BrushWrap.None;
+                    break;
+                case (System.Windows.Media.GradientSpreadMethod.Repeat):
+                    wrap = BrushWrap.Repeat;
+                    break;
+                case (System.Windows.Media.GradientSpreadMethod.Reflect):
+                    wrap = BrushWrap.Reflect;
+                    break;
+            }
 
-                    switch (wrap)
-                    {
-                        //case BrushWrap.None:
-                        //    brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
-                        //    break;
-                        case BrushWrap.Repeat:
-                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Tile;
-                            break;
-                        case BrushWrap.Reflect:
-                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.TileFlipXY;
-                            break;
-                    }
+            foreach (var grad in brush.GradientStops)
+            {
+                if (!colorGradients.ContainsKey((float)grad.Offset) && ((float)grad.Offset >= 0.0f && (float)grad.Offset <= 1.0f))
+                    colorGradients.Add(
+                        (float)grad.Offset,
+                        Utils.ColorUtils.MediaColorToDrawingColor(grad.Color)
+                        );
+            }
 
-                    _drawingBrush = brush;
-                }
-                else if (type == BrushType.Radial)
-                {
+            CheckColorGradients();
+        }
+        public override System.Drawing.Brush GetDrawingBrush()
+        {
+            if (true/*_drawingbrush == null*/)
+            {
                     System.Drawing.Drawing2D.GraphicsPath g_path = new System.Drawing.Drawing2D.GraphicsPath();
                     g_path.AddEllipse(
                         new System.Drawing.RectangleF(
@@ -453,104 +790,16 @@ public System.Drawing.Brush GetDrawingBrush()
                     brush.InterpolationColors = color_blend;
 
                     _drawingBrush = brush;
-                }
-                else
-                {
-                    _drawingBrush = new System.Drawing.SolidBrush(System.Drawing.Color.Transparent);
-                }
+
             }
 
             return _drawingBrush;
         }
-        private SortedDictionary<float, System.Drawing.Color> GetColorGradientsForWindow(float shift, float window_size, float starting_value = 0)
-        {
-            SortedDictionary<float, System.Drawing.Color> gradients = new SortedDictionary<float, System.Drawing.Color>();
-            float previousKey = 0;
-            foreach (var kvp in colorGradients)
-            {
-                if (kvp.Key >= shift)
-                {
-                    if (gradients.Count == 0 && kvp.Key != 0)
-                    {
-                        gradients[starting_value] = Utils.ColorUtils.BlendColors(colorGradients[previousKey], kvp.Value, (shift - previousKey)/(kvp.Key - previousKey));
-                    }
-
-                    if (kvp.Key <= shift + window_size)
-                    {
-                        float index = starting_value + (kvp.Key - shift) / window_size;
-                        if (index >= 1)
-                        {
-                            gradients[1] = kvp.Value;
-                            break;
-                        }
-                        gradients[index] = kvp.Value;
-                    }
-                    else
-                    {
-                        gradients[1] = Utils.ColorUtils.BlendColors(colorGradients[previousKey], kvp.Value, (shift + window_size - previousKey) / (kvp.Key - previousKey));
-                        return gradients;
-                    }
 
-                    if (kvp.Key == 1)
-                    {
-                        foreach (var gradient in GetColorGradientsForWindow(0, window_size +shift-previousKey, starting_value + (1 - shift) / window_size))
-                        {
-                            gradients[gradient.Key] = gradient.Value;
-                        }
-                    }
-                }
-                previousKey = kvp.Key;
-            }
-            return gradients;
-        }
-        public System.Drawing.Brush GetDrawingBrush(float shift, float window_size)
+        public override System.Drawing.Brush GetDrawingBrush(float shift, float window_size)
         {
             if (true/*_drawingbrush == null*/)
             {
-                if (type == BrushType.Solid)
-                {
-                    _drawingBrush = new System.Drawing.SolidBrush(colorGradients[0.0f]);
-                }
-                else if (type == BrushType.Linear)
-                {
-                    System.Drawing.Drawing2D.LinearGradientBrush brush = new System.Drawing.Drawing2D.LinearGradientBrush(
-                        start,
-                        new System.Drawing.PointF(100/window_size,0),
-                        System.Drawing.Color.Red,
-                        System.Drawing.Color.Red
-                        );
-
-                    List<System.Drawing.Color> brush_colors = new List<System.Drawing.Color>();
-                    List<float> brush_positions = new List<float>();
-
-                    foreach (var kvp in colorGradients)
-                    {
-                        brush_positions.Add(kvp.Key);
-                        brush_colors.Add(kvp.Value);
-                    }
-
-                    System.Drawing.Drawing2D.ColorBlend color_blend = new System.Drawing.Drawing2D.ColorBlend();
-                    color_blend.Colors = brush_colors.ToArray();
-                    color_blend.Positions = brush_positions.ToArray();
-                    brush.InterpolationColors = color_blend;
-
-                    switch (wrap)
-                    {
-                        //case BrushWrap.None:
-                        //    brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
-                        //    break;
-                        case BrushWrap.Repeat:
-                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Tile;
-                            break;
-                        case BrushWrap.Reflect:
-                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.TileFlipXY;
-                            break;
-                    }
-
-                    _drawingBrush = brush;
-                }
-                else if (type == BrushType.Radial)
-                {
                     System.Drawing.Drawing2D.GraphicsPath g_path = new System.Drawing.Drawing2D.GraphicsPath();
                     g_path.AddEllipse(
                         new System.Drawing.RectangleF(
@@ -581,7 +830,7 @@ public System.Drawing.Brush GetDrawingBrush(float shift, float window_size)
                     List<System.Drawing.Color> brush_colors = new List<System.Drawing.Color>();
                     List<float> brush_positions = new List<float>();
 
-                    foreach (var kvp in GetColorGradientsForWindow(Math.Abs(shift), window_size/100))
+                    foreach (var kvp in GetColorGradientsForWindow(Math.Abs(shift), window_size / 100))
                     {
                         if (shift < 0)
                             brush_positions.Add(1.0f - kvp.Key);
@@ -604,62 +853,14 @@ public System.Drawing.Brush GetDrawingBrush(float shift, float window_size)
                     brush.InterpolationColors = color_blend;
 
                     _drawingBrush = brush;
-                }
-                else
-                {
-                    _drawingBrush = new System.Drawing.SolidBrush(System.Drawing.Color.Transparent);
-                }
             }
 
             return _drawingBrush;
         }
-        public System.Windows.Media.Brush GetMediaBrush()
+        public override System.Windows.Media.Brush GetMediaBrush()
         {
             if (_mediaBrush == null)
             {
-                if (type == BrushType.Solid)
-                {
-                    System.Windows.Media.SolidColorBrush brush = new System.Windows.Media.SolidColorBrush(
-                        Utils.ColorUtils.DrawingColorToMediaColor(colorGradients[0.0f])
-                        );
-                    brush.Freeze();
-
-                    _mediaBrush = brush;
-                }
-                else if (type == BrushType.Linear)
-                {
-                    System.Windows.Media.GradientStopCollection collection = new System.Windows.Media.GradientStopCollection();
-
-                    foreach (var kvp in colorGradients)
-                    {
-                        collection.Add(
-                            new System.Windows.Media.GradientStop(
-                                Utils.ColorUtils.DrawingColorToMediaColor(kvp.Value),
-                                kvp.Key)
-                            );
-                    }
-
-                    System.Windows.Media.LinearGradientBrush brush = new System.Windows.Media.LinearGradientBrush(collection);
-                    brush.StartPoint = new System.Windows.Point(start.X, start.Y);
-                    brush.EndPoint = new System.Windows.Point(end.X, end.Y);
-
-                    switch (wrap)
-                    {
-                        case BrushWrap.None:
-                            brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Pad;
-                            break;
-                        case BrushWrap.Repeat:
-                            brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Repeat;
-                            break;
-                        case BrushWrap.Reflect:
-                            brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Reflect;
-                            break;
-                    }
-
-                    _mediaBrush = brush;
-                }
-                else if (type == BrushType.Radial)
-                {
                     System.Windows.Media.GradientStopCollection collection = new System.Windows.Media.GradientStopCollection();
 
                     foreach (var kvp in colorGradients)
@@ -690,34 +891,17 @@ public System.Windows.Media.Brush GetMediaBrush()
                     }
 
                     _mediaBrush = brush;
-                }
-                else
-                {
-                    System.Windows.Media.SolidColorBrush brush = new System.Windows.Media.SolidColorBrush(
-                        System.Windows.Media.Color.FromArgb(255, 255, 0, 0)
-                        );
-                    brush.Freeze();
-
-                    _mediaBrush = brush;
-                }
             }
 
             return _mediaBrush;
         }
 
-        public ColorSpectrum GetColorSpectrum()
+        public override ColorSpectrum GetColorSpectrum()
         {
             ColorSpectrum spectrum = new ColorSpectrum();
 
-            if(type == BrushType.Solid)
-            {
-                spectrum = new ColorSpectrum(colorGradients[0.0f]);
-            }
-            else
-            {
                 foreach (var color in colorGradients)
                     spectrum.SetColorAt(color.Key, color.Value);
-            }
 
             return spectrum;
         }
@@ -728,12 +912,12 @@ public ColorSpectrum GetColorSpectrum()
         /// <param name="otherBrush">The foreground EffectBrush (When percent is at 1.0D, only this EffectBrush is shown)</param>
         /// <param name="percent">The blending percent value</param>
         /// <returns>The blended EffectBrush</returns>
-        public EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent)
+        public override EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent)
         {
             if (percent <= 0.0)
-                return new EffectBrush(this);
+                return (EffectBrush)this.Clone();
             else if (percent >= 1.0)
-                return new EffectBrush(otherBrush);
+                return (EffectBrush)otherBrush.Clone();
 
             ColorSpectrum currentSpectrum = new ColorSpectrum(GetColorSpectrum());
             ColorSpectrum newSpectrum = new ColorSpectrum(currentSpectrum).MultiplyByScalar(1.0 - percent);
@@ -746,8 +930,8 @@ public EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent)
                 newSpectrum.SetColorAt(kvp.Key, Utils.ColorUtils.BlendColors(bgColor, fgColor, percent));
             }
 
-            EffectBrush returnBrush = new EffectBrush(newSpectrum);
-            returnBrush.SetBrushType(type).SetWrap(wrap);
+            EffectBrush returnBrush = new RadialEffectBrush(newSpectrum);
+            returnBrush.wrap = wrap;
 
             returnBrush.start = new System.Drawing.PointF((float)(start.X * (1.0 - percent) + otherBrush.start.X * (percent)), (float)(start.Y * (1.0 - percent) + otherBrush.start.Y * (percent)));
             returnBrush.end = new System.Drawing.PointF((float)(end.X * (1.0 - percent) + otherBrush.end.X * (percent)), (float)(end.Y * (1.0 - percent) + otherBrush.end.Y * (percent)));
@@ -755,41 +939,5 @@ public EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent)
 
             return returnBrush;
         }
-
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj)) return false;
-            if (ReferenceEquals(this, obj)) return true;
-            if (obj.GetType() != this.GetType()) return false;
-            return Equals((EffectBrush)obj);
-        }
-
-        public bool Equals(EffectBrush p)
-        {
-            if (ReferenceEquals(null, p)) return false;
-            if (ReferenceEquals(this, p)) return true;
-
-            return (type == p.type &&
-                wrap == p.wrap &&
-                colorGradients.Equals(p.colorGradients) &&
-                start.Equals(p.start) &&
-                end.Equals(p.end) &&
-                center.Equals(p.center));
-        }
-
-        public override int GetHashCode()
-        {
-            unchecked
-            {
-                int hash = 17;
-                hash = hash * 23 + type.GetHashCode();
-                hash = hash * 23 + wrap.GetHashCode();
-                hash = hash * 23 + colorGradients.GetHashCode();
-                hash = hash * 23 + start.GetHashCode();
-                hash = hash * 23 + end.GetHashCode();
-                hash = hash * 23 + center.GetHashCode();
-                return hash;
-            }
-        }
     }
 }
diff --git a/Project-Aurora/Project-Aurora/EffectsEngine/EffectLayer.cs b/Project-Aurora/Project-Aurora/EffectsEngine/EffectLayer.cs
index 9bdb4be52..226697c35 100755
--- a/Project-Aurora/Project-Aurora/EffectsEngine/EffectLayer.cs
+++ b/Project-Aurora/Project-Aurora/EffectsEngine/EffectLayer.cs
@@ -209,14 +209,14 @@ public EffectLayer(string name, Color color)
                         shift *= -1.0f;
                     float percent = shift / (Effects.canvas_biggest / effect_config.gradient_size);
                     brush = effect_config.brush.GetDrawingBrush(percent % 1 , effect_config.gradient_size);
-                    if (effect_config.brush.type == EffectBrush.BrushType.Linear)
+                    if (brush is LinearGradientBrush linear_brush)
                     {
-                        (brush as LinearGradientBrush).ScaleTransform(brush_width, brush_height);
-                        (brush as LinearGradientBrush).RotateTransform(effect_config.angle);
-                        (brush as LinearGradientBrush).TranslateTransform(shift, shift);
+                        linear_brush.ScaleTransform(brush_width, brush_height);
+                        linear_brush.RotateTransform(effect_config.angle);
+                        linear_brush.TranslateTransform(shift, shift);
 
                     }
-                    else if (effect_config.brush.type == EffectBrush.BrushType.Radial)
+                    else if (brush is PathGradientBrush radial_brush)
                     {
                         brush_height *= (float)Math.Sqrt(2);
                         brush_width *= (float)Math.Sqrt(2);
@@ -229,10 +229,10 @@ public EffectLayer(string name, Color color)
                             y_offset += rect.Y;
                         }
 
-                        (brush as PathGradientBrush).TranslateTransform(x_offset, y_offset);
-                        (brush as PathGradientBrush).ScaleTransform(brush_width, brush_height);
+                        radial_brush.TranslateTransform(x_offset, y_offset);
+                        radial_brush.ScaleTransform(brush_width, brush_height);
 
-                        (brush as PathGradientBrush).WrapMode = WrapMode.Clamp;
+                        radial_brush.WrapMode = WrapMode.Clamp;
                     }
 
                     Fill(brush);
diff --git a/Project-Aurora/Project-Aurora/Profiles/CloneHero/CloneHeroProfile.cs b/Project-Aurora/Project-Aurora/Profiles/CloneHero/CloneHeroProfile.cs
index 629f03f47..d78287728 100644
--- a/Project-Aurora/Project-Aurora/Profiles/CloneHero/CloneHeroProfile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/CloneHero/CloneHeroProfile.cs
@@ -55,8 +55,7 @@ public override void Reset()
                             angle = 0,
                             animation_reverse = false,
                             brush =
-                            {
-                                type = EffectBrush.BrushType.Linear,
+                            new LinearEffectBrush{
                                 wrap = EffectBrush.BrushWrap.Repeat,
                                 colorGradients = new SortedDictionary<float, Color>()
                                 {
diff --git a/Project-Aurora/Project-Aurora/Profiles/Desktop/DesktopProfile.cs b/Project-Aurora/Project-Aurora/Profiles/Desktop/DesktopProfile.cs
index b2106740c..b022b1078 100755
--- a/Project-Aurora/Project-Aurora/Profiles/Desktop/DesktopProfile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/Desktop/DesktopProfile.cs
@@ -45,9 +45,8 @@ private void setVolumeOverlay()
                             Devices.DeviceKeys.F5, Devices.DeviceKeys.F6, Devices.DeviceKeys.F7, Devices.DeviceKeys.F8,
                             Devices.DeviceKeys.F9, Devices.DeviceKeys.F10, Devices.DeviceKeys.F11, Devices.DeviceKeys.F12
                         }),
-                    _Gradient = new EffectsEngine.EffectBrush()
+                    _Gradient = new EffectsEngine.LinearEffectBrush()
                     {
-                        type = EffectBrush.BrushType.Linear,
                         colorGradients = new SortedDictionary<float, Color> {
                                 { 0f, Color.FromArgb(255, 0, 255, 0) },
                                 { 0.5f, Color.OrangeRed },
diff --git a/Project-Aurora/Project-Aurora/Profiles/ETS2/ETS2Profile.cs b/Project-Aurora/Project-Aurora/Profiles/ETS2/ETS2Profile.cs
index b4ed1d8ee..e7f7fdb4c 100644
--- a/Project-Aurora/Project-Aurora/Profiles/ETS2/ETS2Profile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/ETS2/ETS2Profile.cs
@@ -60,8 +60,7 @@ public override void Reset() {
 
                 new Layer("Throttle Key", new PercentGradientLayerHandler {
                     Properties = new PercentGradientLayerHandlerProperties {
-                        _Gradient = new EffectBrush() {
-                            type = EffectBrush.BrushType.Linear,
+                        _Gradient = new LinearEffectBrush() {
                             colorGradients = new SortedDictionary<float, Color> {
                                 { 0, Color.FromArgb(0, 255, 255) },
                                 { 1, Color.FromArgb(0, 255, 0) }
@@ -76,8 +75,7 @@ public override void Reset() {
 
                 new Layer("Brake Key", new PercentGradientLayerHandler {
                     Properties = new PercentGradientLayerHandlerProperties {
-                        _Gradient = new EffectBrush() {
-                            type = EffectBrush.BrushType.Linear,
+                        _Gradient = new LinearEffectBrush() {
                             colorGradients = new SortedDictionary<float, Color> {
                                 { 0, Color.FromArgb(0, 255, 255) },
                                 { 1, Color.FromArgb(255, 0, 0) }
@@ -104,8 +102,7 @@ public override void Reset() {
 
                 new Layer("RPM", new PercentGradientLayerHandler {
                     Properties = new PercentGradientLayerHandlerProperties {
-                        _Gradient = new EffectBrush() {
-                            type = EffectBrush.BrushType.Linear,
+                        _Gradient = new LinearEffectBrush() {
                             colorGradients = new SortedDictionary<float, Color> {
                                 { 0, Color.FromArgb(65, 255, 0) },
                                 { 0.65f, Color.FromArgb(67, 255, 0) },
@@ -240,8 +237,7 @@ public override void Reset() {
 
                 new Layer("Fuel", new PercentGradientLayerHandler {
                     Properties = new PercentGradientLayerHandlerProperties {
-                        _Gradient = new EffectBrush() {
-                            type = EffectBrush.BrushType.Linear,
+                        _Gradient = new LinearEffectBrush() {
                             colorGradients = new SortedDictionary<float, Color> {
                                 { 0f, Color.FromArgb(255, 0, 0) },
                                 { 0.25f, Color.FromArgb(255, 0, 0) },
@@ -260,8 +256,7 @@ public override void Reset() {
 
                 new Layer("Air Pressure", new PercentGradientLayerHandler {
                     Properties = new PercentGradientLayerHandlerProperties {
-                        _Gradient = new EffectBrush() {
-                            type = EffectBrush.BrushType.Linear,
+                        _Gradient = new LinearEffectBrush() {
                             colorGradients = new SortedDictionary<float, Color> {
                                 { 0f, Color.FromArgb(255, 0, 0) },
                                 { 0.25f, Color.FromArgb(255, 0, 0) },
diff --git a/Project-Aurora/Project-Aurora/Profiles/Osu/OsuProfile.cs b/Project-Aurora/Project-Aurora/Profiles/Osu/OsuProfile.cs
index 562b1925d..90f0c9d94 100644
--- a/Project-Aurora/Project-Aurora/Profiles/Osu/OsuProfile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/Osu/OsuProfile.cs
@@ -131,8 +131,7 @@ public override void Reset() {
                     Properties = new EqualizerLayerHandlerProperties {
                         _ViewType = EqualizerPresentationType.GradientColorShift,
                         _MaxAmplitude = 25,
-                        _Gradient = new EffectsEngine.EffectBrush {
-                            type = EffectsEngine.EffectBrush.BrushType.Linear,
+                        _Gradient = new EffectsEngine.LinearEffectBrush {
                             colorGradients = new SortedDictionary<float, Color> {
                                 { 0, Color.Magenta },
                                 { 0.5f, Color.Cyan },
diff --git a/Project-Aurora/Project-Aurora/Profiles/RocketLeague/RocketLeagueProfile.cs b/Project-Aurora/Project-Aurora/Profiles/RocketLeague/RocketLeagueProfile.cs
index bfad387c0..1559fe642 100644
--- a/Project-Aurora/Project-Aurora/Profiles/RocketLeague/RocketLeagueProfile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/RocketLeague/RocketLeagueProfile.cs
@@ -28,7 +28,7 @@ public override void Reset()
                     {
                         _PercentType = PercentEffectType.AllAtOnce,
                         _Sequence = new KeySequence(new Devices.DeviceKeys[] { Devices.DeviceKeys.Peripheral, Devices.DeviceKeys.Peripheral_Logo } ),
-                        _Gradient = new EffectsEngine.EffectBrush(new ColorSpectrum(Color.Yellow, Color.Red).SetColorAt(0.75f, Color.OrangeRed)),
+                        _Gradient = new EffectsEngine.LinearEffectBrush(new ColorSpectrum(Color.Yellow, Color.Red).SetColorAt(0.75f, Color.OrangeRed)),
                         _BlinkThreshold = 0.0,
                         _BlinkDirection = false,
                         _VariablePath = "Player/Boost",
@@ -45,7 +45,7 @@ public override void Reset()
                             Devices.DeviceKeys.F6, Devices.DeviceKeys.F7, Devices.DeviceKeys.F8, Devices.DeviceKeys.F9, Devices.DeviceKeys.F10,
                             Devices.DeviceKeys.F11, Devices.DeviceKeys.F12
                         }),
-                        _Gradient = new EffectsEngine.EffectBrush(new ColorSpectrum(Color.Yellow, Color.Red).SetColorAt(0.75f, Color.OrangeRed)),
+                        _Gradient = new EffectsEngine.LinearEffectBrush(new ColorSpectrum(Color.Yellow, Color.Red).SetColorAt(0.75f, Color.OrangeRed)),
                         _BlinkThreshold = 0.0,
                         _BlinkDirection = false,
                         _VariablePath = "Player/Boost",
diff --git a/Project-Aurora/Project-Aurora/Profiles/Subnautica/SubnauticaProfile.cs b/Project-Aurora/Project-Aurora/Profiles/Subnautica/SubnauticaProfile.cs
index 001832f69..530acb463 100644
--- a/Project-Aurora/Project-Aurora/Profiles/Subnautica/SubnauticaProfile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/Subnautica/SubnauticaProfile.cs
@@ -118,8 +118,7 @@ public override void Reset() {
 
                 new Layer("Background", new PercentGradientLayerHandler() {
                     Properties = new PercentGradientLayerHandlerProperties {
-                        _Gradient = new EffectBrush() {
-                            type = EffectBrush.BrushType.Linear,
+                        _Gradient = new LinearEffectBrush() {
                             start = new PointF(0, 0),
                             end = new PointF(1, 0),
                             colorGradients = new SortedDictionary<float, Color> {
diff --git a/Project-Aurora/Project-Aurora/Profiles/Terraria/TerrariaProfile.cs b/Project-Aurora/Project-Aurora/Profiles/Terraria/TerrariaProfile.cs
index 8796ccb09..896c8a514 100644
--- a/Project-Aurora/Project-Aurora/Profiles/Terraria/TerrariaProfile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/Terraria/TerrariaProfile.cs
@@ -45,8 +45,7 @@ public override void Reset() {
                 }),
                 new Layer("Background", new PercentGradientLayerHandler() {
                     Properties = new PercentGradientLayerHandlerProperties {
-                        _Gradient = new EffectBrush() {
-                            type = EffectBrush.BrushType.Linear,
+                        _Gradient = new LinearEffectBrush() {
                             start = new PointF(0, 0),
                             end = new PointF(1, 0),
                             colorGradients = new SortedDictionary<float, Color> {
@@ -79,9 +78,8 @@ public override void Reset() {
 
         private static EffectBrush GetColorGradient(Color start, Color end)
         {
-            return new EffectBrush()
+            return new LinearEffectBrush()
             {
-                type = EffectBrush.BrushType.Linear,
                 start = new PointF(0, 0),
                 end = new PointF(1, 0),
                 colorGradients = new SortedDictionary<float, Color> {
diff --git a/Project-Aurora/Project-Aurora/Settings/LayerEffectConfig.cs b/Project-Aurora/Project-Aurora/Settings/LayerEffectConfig.cs
index 7c9faf071..0d7233d22 100644
--- a/Project-Aurora/Project-Aurora/Settings/LayerEffectConfig.cs
+++ b/Project-Aurora/Project-Aurora/Settings/LayerEffectConfig.cs
@@ -49,7 +49,7 @@ public LayerEffectConfig(Color primary_color, Color secondary_color)
             speed = 1.0f;
             angle = 0.0f;
             animation_reverse = false;
-            brush = new EffectBrush(
+            brush = EffectBrush.GetEffectBrush(
                 new System.Drawing.Drawing2D.LinearGradientBrush(
                     new PointF(0, 0),
                     new PointF(1, 0),
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/Control_EqualizerLayer.xaml.cs b/Project-Aurora/Project-Aurora/Settings/Layers/Control_EqualizerLayer.xaml.cs
index 321475832..e0d4ac420 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/Control_EqualizerLayer.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/Control_EqualizerLayer.xaml.cs
@@ -105,12 +105,12 @@ private void Clr_secondary_color_SelectedColorChanged(object sender, RoutedPrope
         private void Gradient_editor_BrushChanged(object sender, ColorBox.BrushChangedEventArgs e)
         {
             if (IsLoaded && settingsset && this.DataContext is EqualizerLayerHandler && sender is ColorBox.ColorBox)
-                (this.DataContext as EqualizerLayerHandler).Properties._Gradient = new EffectsEngine.EffectBrush((sender as ColorBox.ColorBox).Brush);
+                (this.DataContext as EqualizerLayerHandler).Properties._Gradient = EffectsEngine.EffectBrush.GetEffectBrush((sender as ColorBox.ColorBox).Brush);
         }
 
         private void Button_SetGradientRainbow_Click(object sender, RoutedEventArgs e)
         {
-            (this.DataContext as EqualizerLayerHandler).Properties._Gradient = new EffectBrush(ColorSpectrum.Rainbow);
+            (this.DataContext as EqualizerLayerHandler).Properties._Gradient = new LinearEffectBrush(ColorSpectrum.Rainbow);
 
             Brush brush = (this.DataContext as EqualizerLayerHandler).Properties._Gradient.GetMediaBrush();
             try
@@ -125,7 +125,7 @@ private void Button_SetGradientRainbow_Click(object sender, RoutedEventArgs e)
 
         private void Button_SetGradientRainbowLoop_Click(object sender, RoutedEventArgs e)
         {
-            (this.DataContext as EqualizerLayerHandler).Properties._Gradient = new EffectBrush(ColorSpectrum.RainbowLoop);
+            (this.DataContext as EqualizerLayerHandler).Properties._Gradient = new LinearEffectBrush(ColorSpectrum.RainbowLoop);
 
             Brush brush = (this.DataContext as EqualizerLayerHandler).Properties._Gradient.GetMediaBrush();
             try
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientFillLayer.xaml.cs b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientFillLayer.xaml.cs
index ef270e53f..4602a551e 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientFillLayer.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientFillLayer.xaml.cs
@@ -62,12 +62,12 @@ public void SetSettings()
         private void Gradient_editor_BrushChanged(object sender, ColorBox.BrushChangedEventArgs e)
         {
             if (IsLoaded && settingsset && this.DataContext is GradientFillLayerHandler && sender is ColorBox.ColorBox)
-                (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush = new EffectsEngine.EffectBrush((sender as ColorBox.ColorBox).Brush);
+                (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush = EffectsEngine.EffectBrush.GetEffectBrush((sender as ColorBox.ColorBox).Brush);
         }
 
         private void Button_SetGradientRainbow_Click(object sender, RoutedEventArgs e)
         {
-            (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush = new EffectBrush(ColorSpectrum.Rainbow);
+            (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush = new LinearEffectBrush(ColorSpectrum.Rainbow);
 
             Brush brush = (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush.GetMediaBrush();
             try
@@ -82,7 +82,7 @@ private void Button_SetGradientRainbow_Click(object sender, RoutedEventArgs e)
 
         private void Button_SetGradientRainbowLoop_Click(object sender, RoutedEventArgs e)
         {
-            (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush = new EffectBrush(ColorSpectrum.RainbowLoop);
+            (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush = new LinearEffectBrush(ColorSpectrum.RainbowLoop);
 
             Brush brush = (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush.GetMediaBrush();
             try
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml.cs b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml.cs
index 291cf87c9..ad99fd099 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml.cs
@@ -65,12 +65,12 @@ public void SetSettings()
         private void Gradient_editor_BrushChanged(object sender, ColorBox.BrushChangedEventArgs e)
         {
             if (IsLoaded && settingsset && this.DataContext is GradientLayerHandler && sender is ColorBox.ColorBox)
-                (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush = new EffectsEngine.EffectBrush((sender as ColorBox.ColorBox).Brush);
+                (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush = EffectsEngine.EffectBrush.GetEffectBrush((sender as ColorBox.ColorBox).Brush);
         }
 
         private void Button_SetGradientRainbow_Click(object sender, RoutedEventArgs e)
         {
-            (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush = new EffectBrush(ColorSpectrum.Rainbow);
+            (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush = new LinearEffectBrush(ColorSpectrum.Rainbow);
 
             Brush brush = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush.GetMediaBrush();
             try
@@ -85,7 +85,7 @@ private void Button_SetGradientRainbow_Click(object sender, RoutedEventArgs e)
 
         private void Button_SetGradientRainbowLoop_Click(object sender, RoutedEventArgs e)
         {
-            (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush = new EffectBrush(ColorSpectrum.RainbowLoop);
+            (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush = new LinearEffectBrush(ColorSpectrum.RainbowLoop);
 
             Brush brush = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush.GetMediaBrush();
             try
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/Control_PercentGradientLayer.xaml.cs b/Project-Aurora/Project-Aurora/Settings/Layers/Control_PercentGradientLayer.xaml.cs
index d17fff7a4..033f62522 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/Control_PercentGradientLayer.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/Control_PercentGradientLayer.xaml.cs
@@ -79,7 +79,7 @@ private void UserControl_Loaded(object sender, RoutedEventArgs e)
         private void Gradient_editor_BrushChanged(object sender, ColorBox.BrushChangedEventArgs e)
         {
             if (IsLoaded && settingsset && this.DataContext is PercentGradientLayerHandler && sender is ColorBox.ColorBox)
-                (this.DataContext as PercentGradientLayerHandler).Properties._Gradient = new EffectsEngine.EffectBrush((sender as ColorBox.ColorBox).Brush);
+                (this.DataContext as PercentGradientLayerHandler).Properties._Gradient = EffectsEngine.EffectBrush.GetEffectBrush((sender as ColorBox.ColorBox).Brush);
         }
 
         private void ColorPicker_progressColor_SelectedColorChanged(object sender, RoutedPropertyChangedEventArgs<Color?> e)
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/EqualizerLayerHandler.cs b/Project-Aurora/Project-Aurora/Settings/Layers/EqualizerLayerHandler.cs
index 47dc5077e..0e462dfef 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/EqualizerLayerHandler.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/EqualizerLayerHandler.cs
@@ -78,7 +78,7 @@ public class EqualizerLayerHandlerProperties : LayerHandlerProperties<EqualizerL
         [LogicOverridable("Gradient")]
         public EffectBrush _Gradient { get; set; }
         [JsonIgnore]
-        public EffectBrush Gradient { get { return Logic._Gradient ?? _Gradient ?? new EffectBrush().SetBrushType(EffectBrush.BrushType.Linear); } }
+        public EffectBrush Gradient { get { return Logic._Gradient ?? _Gradient ?? new LinearEffectBrush(); } }
 
         [LogicOverridable("Equalizer Type")]
         public EqualizerType? _EQType { get; set; }
@@ -130,7 +130,7 @@ public override void Default()
             _Sequence = new KeySequence(Effects.WholeCanvasFreeForm);
             _PrimaryColor = Utils.ColorUtils.GenerateRandomColor();
             _SecondaryColor = Utils.ColorUtils.GenerateRandomColor();
-            _Gradient = new EffectBrush(ColorSpectrum.RainbowLoop).SetBrushType(EffectBrush.BrushType.Linear);
+            _Gradient = new LinearEffectBrush(ColorSpectrum.RainbowLoop);
             _EQType = EqualizerType.PowerBars;
             _ViewType = EqualizerPresentationType.SolidColor;
             _MaxAmplitude = 20.0f;
@@ -428,7 +428,7 @@ private Brush GetBrush(float value, float position, float max_position)
                 return new SolidBrush(Properties.Gradient.GetColorSpectrum().GetColorAt(position, max_position));
             else if (Properties.ViewType == EqualizerPresentationType.GradientHorizontal)
             {
-                EffectBrush e_brush = new EffectBrush(Properties.Gradient.GetColorSpectrum()) {
+                EffectBrush e_brush = new LinearEffectBrush(Properties.Gradient.GetColorSpectrum()) {
                     start = PointF.Empty,
                     end = new PointF(sourceRect.Width, 0)
                 };
@@ -439,7 +439,7 @@ private Brush GetBrush(float value, float position, float max_position)
                 return new SolidBrush(Properties.Gradient.GetColorSpectrum().GetColorAt(Utils.Time.GetMilliSeconds(), 1000));
             else if (Properties.ViewType == EqualizerPresentationType.GradientVertical)
             {
-                EffectBrush e_brush = new EffectBrush(Properties.Gradient.GetColorSpectrum()) {
+                EffectBrush e_brush = new LinearEffectBrush(Properties.Gradient.GetColorSpectrum()) {
                     start = new PointF(0, sourceRect.Height),
                     end = PointF.Empty
                 };
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/InteractiveLayerHandler.cs b/Project-Aurora/Project-Aurora/Settings/Layers/InteractiveLayerHandler.cs
index 5d3b7bf33..10f7cd1b2 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/InteractiveLayerHandler.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/InteractiveLayerHandler.cs
@@ -221,8 +221,8 @@ private input_item CreateInputItem(Devices.DeviceKeys key, PointF origin)
             {
                 AnimationTrack rainbowWave = new AnimationTrack("Rainbow Wave", 1.0f);
 
-                rainbowWave.SetFrame(0.0f, new AnimationGradientCircle(origin, 0, new EffectBrush(new ColorSpectrum(ColorSpectrum.Rainbow).Flip()).SetBrushType(EffectBrush.BrushType.Radial), Properties.EffectWidth));
-                rainbowWave.SetFrame(1.0f, new AnimationGradientCircle(origin, Effects.canvas_width + (Properties.EffectWidth / 2), new EffectBrush(new ColorSpectrum(ColorSpectrum.Rainbow).Flip()).SetBrushType(EffectBrush.BrushType.Radial), Properties.EffectWidth));
+                rainbowWave.SetFrame(0.0f, new AnimationGradientCircle(origin, 0, new RadialEffectBrush(new ColorSpectrum(ColorSpectrum.Rainbow).Flip()), Properties.EffectWidth));
+                rainbowWave.SetFrame(1.0f, new AnimationGradientCircle(origin, Effects.canvas_width + (Properties.EffectWidth / 2), new RadialEffectBrush(new ColorSpectrum(ColorSpectrum.Rainbow).Flip()), Properties.EffectWidth));
 
                 anim_mix.AddTrack(rainbowWave);
             }
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/PercentGradientLayerHandler.cs b/Project-Aurora/Project-Aurora/Settings/Layers/PercentGradientLayerHandler.cs
index e8d942501..dfcef421d 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/PercentGradientLayerHandler.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/PercentGradientLayerHandler.cs
@@ -20,12 +20,12 @@ public PercentGradientLayerHandlerProperties(bool empty = false) : base(empty) {
         [Overrides.LogicOverridable("Gradient")]
         public EffectBrush _Gradient { get; set; }
         [JsonIgnore]
-        public EffectBrush Gradient { get { return Logic._Gradient ?? _Gradient ?? new EffectBrush().SetBrushType(EffectBrush.BrushType.Linear); } }
+        public EffectBrush Gradient { get { return Logic._Gradient ?? _Gradient ?? new LinearEffectBrush(); } }
         
         public override void Default()
         {
             base.Default();
-            this._Gradient = new EffectBrush().SetBrushType(EffectBrush.BrushType.Linear);
+            this._Gradient = new LinearEffectBrush();
         }
     }
 
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/SimpleParticleLayerHandler.cs b/Project-Aurora/Project-Aurora/Settings/Layers/SimpleParticleLayerHandler.cs
index 4b3798b83..4e5c3e1ca 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/SimpleParticleLayerHandler.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/SimpleParticleLayerHandler.cs
@@ -128,7 +128,7 @@ public class SimpleParticleLayerProperties<TSelf> : ParticleLayerPropertiesBase<
         [JsonIgnore] public ColorStopCollection ParticleColorStops => Logic._ParticleColorStops ?? _ParticleColorStops ?? defaultParticleColor;
 
         // An override proxy for setting the particle color stops
-        [JsonIgnore, LogicOverridable("Color over time")] public EffectBrush _ParticleBrush { get => new EffectBrush(_ParticleColorStops.ToMediaBrush()); set => _ParticleColorStops = value == null ? null : ColorStopCollection.FromMediaBrush(value.GetMediaBrush()); }
+        [JsonIgnore, LogicOverridable("Color over time")] public EffectBrush _ParticleBrush { get => EffectBrush.GetEffectBrush(_ParticleColorStops.ToMediaBrush()); set => _ParticleColorStops = value == null ? null : ColorStopCollection.FromMediaBrush(value.GetMediaBrush()); }
 
         private static readonly ColorStopCollection defaultParticleColor = new ColorStopCollection {
             {0f, Color.White },
diff --git a/Project-Aurora/Project-Aurora/Settings/ProfileImporter.cs b/Project-Aurora/Project-Aurora/Settings/ProfileImporter.cs
index 7990a41ef..07b32e1d5 100644
--- a/Project-Aurora/Project-Aurora/Settings/ProfileImporter.cs
+++ b/Project-Aurora/Project-Aurora/Settings/ProfileImporter.cs
@@ -421,28 +421,28 @@ private static void ImportCueprofile(this Application app, string filepath)
                                                         _angleOffset = (width / 2.0f) - _angleOffset;
 
 
-                                                        animTrack.SetFrame(terminalTime*smallest, new AnimationFilledGradientRectangle(-width - _angleOffset, 0, width, Effects.canvas_height * 10, new EffectsEngine.EffectBrush(transitions)).SetAngle(angle));
+                                                        animTrack.SetFrame(terminalTime*smallest, new AnimationFilledGradientRectangle(-width - _angleOffset, 0, width, Effects.canvas_height * 10, new EffectsEngine.LinearEffectBrush(transitions)).SetAngle(angle));
 
-                                                        animTrack.SetFrame(terminalTime*largest, new AnimationFilledGradientRectangle( _angleOffset, 0, width, Effects.canvas_height * 10, new EffectsEngine.EffectBrush(transitions)).SetAngle(angle));
+                                                        animTrack.SetFrame(terminalTime*largest, new AnimationFilledGradientRectangle( _angleOffset, 0, width, Effects.canvas_height * 10, new EffectsEngine.LinearEffectBrush(transitions)).SetAngle(angle));
                                                     }
                                                     else if (angle > 45 && angle < 135)
                                                     {
-                                                        animTrack.SetFrame(terminalTime * smallest, new AnimationFilledGradientRectangle(0,  width / 2, width, Effects.canvas_width * 10, new EffectsEngine.EffectBrush(transitions)).SetAngle(angle));
+                                                        animTrack.SetFrame(terminalTime * smallest, new AnimationFilledGradientRectangle(0,  width / 2, width, Effects.canvas_width * 10, new EffectsEngine.LinearEffectBrush(transitions)).SetAngle(angle));
 
-                                                        animTrack.SetFrame(terminalTime*largest, new AnimationFilledGradientRectangle(0, (width / 2) - (Effects.canvas_width + width), width, Effects.canvas_width * 10, new EffectsEngine.EffectBrush(transitions)).SetAngle(angle));
+                                                        animTrack.SetFrame(terminalTime*largest, new AnimationFilledGradientRectangle(0, (width / 2) - (Effects.canvas_width + width), width, Effects.canvas_width * 10, new EffectsEngine.LinearEffectBrush(transitions)).SetAngle(angle));
 
                                                     }
                                                     else if (angle >= 135 && angle <= 225)
                                                     {
-                                                        animTrack.SetFrame(terminalTime * smallest, new AnimationFilledGradientRectangle( width, 0, width, Effects.canvas_height * 10, new EffectsEngine.EffectBrush(transitions)).SetAngle(angle));
+                                                        animTrack.SetFrame(terminalTime * smallest, new AnimationFilledGradientRectangle( width, 0, width, Effects.canvas_height * 10, new EffectsEngine.LinearEffectBrush(transitions)).SetAngle(angle));
 
-                                                        animTrack.SetFrame(terminalTime*largest, new AnimationFilledGradientRectangle(-width, 0, width, Effects.canvas_height * 10, new EffectsEngine.EffectBrush(transitions)).SetAngle(angle));
+                                                        animTrack.SetFrame(terminalTime*largest, new AnimationFilledGradientRectangle(-width, 0, width, Effects.canvas_height * 10, new EffectsEngine.LinearEffectBrush(transitions)).SetAngle(angle));
                                                     }
                                                     else if (angle > 225 && angle < 315)
                                                     {
-                                                        animTrack.SetFrame(terminalTime * smallest, new AnimationFilledGradientRectangle(0, -width / 2, width, Effects.canvas_width * 10, new EffectsEngine.EffectBrush(transitions)).SetAngle(angle));
+                                                        animTrack.SetFrame(terminalTime * smallest, new AnimationFilledGradientRectangle(0, -width / 2, width, Effects.canvas_width * 10, new EffectsEngine.LinearEffectBrush(transitions)).SetAngle(angle));
 
-                                                        animTrack.SetFrame(terminalTime*largest, new AnimationFilledGradientRectangle(0, (-width / 2) + (Effects.canvas_width + width), width, Effects.canvas_width * 10, new EffectsEngine.EffectBrush(transitions)).SetAngle(angle));
+                                                        animTrack.SetFrame(terminalTime*largest, new AnimationFilledGradientRectangle(0, (-width / 2) + (Effects.canvas_width + width), width, Effects.canvas_width * 10, new EffectsEngine.LinearEffectBrush(transitions)).SetAngle(angle));
                                                     }
 
                                                     animTracks.Add(animTrack);
@@ -458,7 +458,7 @@ private static void ImportCueprofile(this Application app, string filepath)
                                                     if ((angle >= 315 || angle <= 45) || (angle >= 135 && angle <= 225))
                                                     {
                                                         //Right Side
-                                                        EffectsEngine.EffectBrush _initialBrushRight = new EffectsEngine.EffectBrush(transitions);
+                                                        EffectsEngine.EffectBrush _initialBrushRight = new EffectsEngine.LinearEffectBrush(transitions);
                                                         _initialBrushRight.start = new System.Drawing.PointF(Effects.canvas_width_center, 0);
                                                         _initialBrushRight.end = new System.Drawing.PointF(Effects.canvas_width_center - width, 0);
 
@@ -466,13 +466,13 @@ private static void ImportCueprofile(this Application app, string filepath)
 
                                                         if (_widthFillTime < _terminalTime)
                                                         {
-                                                            EffectsEngine.EffectBrush _fillBrushRight = new EffectsEngine.EffectBrush(_initialBrushRight);
+                                                            EffectsEngine.EffectBrush _fillBrushRight = new EffectsEngine.LinearEffectBrush(_initialBrushRight);
                                                             _fillBrushRight.start = new System.Drawing.PointF(Effects.canvas_width_center + width, 0);
                                                             _fillBrushRight.end = new System.Drawing.PointF(Effects.canvas_width_center, 0);
 
                                                             animTrack.SetFrame(_widthFillTime, new AnimationFilledGradientRectangle(Effects.canvas_width_center, 0, width, Effects.canvas_height * 3, _fillBrushRight).SetAngle(angle));
 
-                                                            EffectsEngine.EffectBrush _terminalBrushRight = new EffectsEngine.EffectBrush(_fillBrushRight);
+                                                            EffectsEngine.EffectBrush _terminalBrushRight = new EffectsEngine.LinearEffectBrush(_fillBrushRight);
                                                             _terminalBrushRight.start = new System.Drawing.PointF(Effects.canvas_width_center + _terminalOffset, 0);
                                                             _terminalBrushRight.end = new System.Drawing.PointF(Effects.canvas_width_center + _terminalOffset - width, 0);
 
@@ -481,7 +481,7 @@ private static void ImportCueprofile(this Application app, string filepath)
                                                         }
                                                         else
                                                         {
-                                                            EffectsEngine.EffectBrush _terminalBrushRight = new EffectsEngine.EffectBrush(_initialBrushRight);
+                                                            EffectsEngine.EffectBrush _terminalBrushRight = new EffectsEngine.LinearEffectBrush(_initialBrushRight);
                                                             _terminalBrushRight.start = new System.Drawing.PointF(Effects.canvas_width_center + _terminalOffset, 0);
                                                             _terminalBrushRight.end = new System.Drawing.PointF(Effects.canvas_width_center + _terminalOffset - width, 0);
 
@@ -489,7 +489,7 @@ private static void ImportCueprofile(this Application app, string filepath)
                                                         }
 
                                                         //Left Side
-                                                        EffectsEngine.EffectBrush _initialBrushLeft = new EffectsEngine.EffectBrush(transitions);
+                                                        EffectsEngine.EffectBrush _initialBrushLeft = new EffectsEngine.LinearEffectBrush(transitions);
                                                         _initialBrushLeft.start = new System.Drawing.PointF(Effects.canvas_width_center, 0);
                                                         _initialBrushLeft.end = new System.Drawing.PointF(Effects.canvas_width_center + width, 0);
 
@@ -497,13 +497,13 @@ private static void ImportCueprofile(this Application app, string filepath)
 
                                                         if (_widthFillTime < _terminalTime)
                                                         {
-                                                            EffectsEngine.EffectBrush _fillBrushLeft = new EffectsEngine.EffectBrush(_initialBrushLeft);
+                                                            EffectsEngine.EffectBrush _fillBrushLeft = new EffectsEngine.LinearEffectBrush(_initialBrushLeft);
                                                             _fillBrushLeft.start = new System.Drawing.PointF(Effects.canvas_width_center - width, 0);
                                                             _fillBrushLeft.end = new System.Drawing.PointF(Effects.canvas_width_center, 0);
 
                                                             animTrack2.SetFrame(_widthFillTime, new AnimationFilledGradientRectangle(Effects.canvas_width_center - width, 0, width, Effects.canvas_height * 3, _fillBrushLeft).SetAngle(angle));
 
-                                                            EffectsEngine.EffectBrush _terminalBrushLeft = new EffectsEngine.EffectBrush(_initialBrushLeft);
+                                                            EffectsEngine.EffectBrush _terminalBrushLeft = new EffectsEngine.LinearEffectBrush(_initialBrushLeft);
                                                             _terminalBrushLeft.start = new System.Drawing.PointF(Effects.canvas_width_center - _terminalOffset, 0);
                                                             _terminalBrushLeft.end = new System.Drawing.PointF(Effects.canvas_width_center - _terminalOffset + width, 0);
 
@@ -511,7 +511,7 @@ private static void ImportCueprofile(this Application app, string filepath)
                                                         }
                                                         else
                                                         {
-                                                            EffectsEngine.EffectBrush _terminalBrushLeft = new EffectsEngine.EffectBrush(_initialBrushLeft);
+                                                            EffectsEngine.EffectBrush _terminalBrushLeft = new EffectsEngine.LinearEffectBrush(_initialBrushLeft);
                                                             _terminalBrushLeft.start = new System.Drawing.PointF(Effects.canvas_width_center - _terminalOffset, 0);
                                                             _terminalBrushLeft.end = new System.Drawing.PointF(Effects.canvas_width_center - _terminalOffset + width, 0);
 
@@ -523,7 +523,7 @@ private static void ImportCueprofile(this Application app, string filepath)
                                                         angle -= 90;
 
                                                         //Bottom Side
-                                                        EffectsEngine.EffectBrush _initialBrushBottom = new EffectsEngine.EffectBrush(transitions);
+                                                        EffectsEngine.EffectBrush _initialBrushBottom = new EffectsEngine.LinearEffectBrush(transitions);
                                                         _initialBrushBottom.start = new System.Drawing.PointF(0, Effects.canvas_height_center);
                                                         _initialBrushBottom.end = new System.Drawing.PointF(0, Effects.canvas_height_center - width);
 
@@ -531,14 +531,14 @@ private static void ImportCueprofile(this Application app, string filepath)
 
                                                         if (_widthFillTime < _terminalTime)
                                                         {
-                                                            EffectsEngine.EffectBrush _fillBrushBottom = new EffectsEngine.EffectBrush(_initialBrushBottom);
+                                                            EffectsEngine.EffectBrush _fillBrushBottom = new EffectsEngine.LinearEffectBrush(_initialBrushBottom);
                                                             _fillBrushBottom.start = new System.Drawing.PointF(0, Effects.canvas_height_center + width);
                                                             _fillBrushBottom.end = new System.Drawing.PointF(0, Effects.canvas_height_center);
 
 
                                                             animTrack.SetFrame(_widthFillTime, new AnimationFilledGradientRectangle(0, Effects.canvas_height_center, Effects.canvas_width * 3, width, _fillBrushBottom).SetAngle(angle));
 
-                                                            EffectsEngine.EffectBrush _terminalBrushBottom = new EffectsEngine.EffectBrush(_fillBrushBottom);
+                                                            EffectsEngine.EffectBrush _terminalBrushBottom = new EffectsEngine.LinearEffectBrush(_fillBrushBottom);
                                                             _terminalBrushBottom.start = new System.Drawing.PointF(0, Effects.canvas_height_center + _terminalOffset);
                                                             _terminalBrushBottom.end = new System.Drawing.PointF(0, Effects.canvas_height_center + _terminalOffset - width);
 
@@ -546,7 +546,7 @@ private static void ImportCueprofile(this Application app, string filepath)
                                                         }
                                                         else
                                                         {
-                                                            EffectsEngine.EffectBrush _terminalBrushBottom = new EffectsEngine.EffectBrush(_initialBrushBottom);
+                                                            EffectsEngine.EffectBrush _terminalBrushBottom = new EffectsEngine.LinearEffectBrush(_initialBrushBottom);
                                                             _terminalBrushBottom.start = new System.Drawing.PointF(0, Effects.canvas_height_center + _terminalOffset);
                                                             _terminalBrushBottom.end = new System.Drawing.PointF(0, Effects.canvas_height_center + _terminalOffset - width);
 
@@ -554,7 +554,7 @@ private static void ImportCueprofile(this Application app, string filepath)
                                                         }
 
                                                         //Top Side
-                                                        EffectsEngine.EffectBrush _initialBrushtTop = new EffectsEngine.EffectBrush(transitions);
+                                                        EffectsEngine.EffectBrush _initialBrushtTop = new EffectsEngine.LinearEffectBrush(transitions);
                                                         _initialBrushtTop.start = new System.Drawing.PointF(0, Effects.canvas_height_center);
                                                         _initialBrushtTop.end = new System.Drawing.PointF(0, Effects.canvas_height_center + width);
 
@@ -562,20 +562,20 @@ private static void ImportCueprofile(this Application app, string filepath)
 
                                                         if (_widthFillTime < _terminalTime)
                                                         {
-                                                            EffectsEngine.EffectBrush _fillBrushTop = new EffectsEngine.EffectBrush(_initialBrushtTop);
+                                                            EffectsEngine.EffectBrush _fillBrushTop = new EffectsEngine.LinearEffectBrush(_initialBrushtTop);
                                                             _fillBrushTop.start = new System.Drawing.PointF(0, Effects.canvas_height_center - width);
                                                             _fillBrushTop.end = new System.Drawing.PointF(0, Effects.canvas_height_center);
 
                                                             animTrack2.SetFrame(_widthFillTime, new AnimationFilledGradientRectangle(0, Effects.canvas_height_center - width, Effects.canvas_width * 3, width, _fillBrushTop).SetAngle(angle));
 
-                                                            EffectsEngine.EffectBrush _terminalBrushTop = new EffectsEngine.EffectBrush(_initialBrushtTop);
+                                                            EffectsEngine.EffectBrush _terminalBrushTop = new EffectsEngine.LinearEffectBrush(_initialBrushtTop);
                                                             _terminalBrushTop.start = new System.Drawing.PointF(0, Effects.canvas_height_center - _terminalOffset);
                                                             _terminalBrushTop.end = new System.Drawing.PointF(0, Effects.canvas_height_center - _terminalOffset + width);
                                                             animTrack2.SetFrame(_terminalTime, new AnimationFilledGradientRectangle(0, Effects.canvas_height_center - _terminalOffset, Effects.canvas_width * 3, width, _terminalBrushTop).SetAngle(angle));
                                                         }
                                                         else
                                                         {
-                                                            EffectsEngine.EffectBrush _terminalBrushTop = new EffectsEngine.EffectBrush(_initialBrushtTop);
+                                                            EffectsEngine.EffectBrush _terminalBrushTop = new EffectsEngine.LinearEffectBrush(_initialBrushtTop);
                                                             _terminalBrushTop.start = new System.Drawing.PointF(0, Effects.canvas_height_center - _terminalOffset);
                                                             _terminalBrushTop.end = new System.Drawing.PointF(0, Effects.canvas_height_center - _terminalOffset + width);
 
@@ -669,9 +669,9 @@ private static void ImportCueprofile(this Application app, string filepath)
                                                     centerX = 0;
                                                     centerY = 0;
                                                 }
-                                                animTrack.SetFrame(0.0f, new AnimationGradientCircle(centerX, centerY, 0, new EffectsEngine.EffectBrush(transitions).SetBrushType(EffectsEngine.EffectBrush.BrushType.Radial), (int)width));
+                                                animTrack.SetFrame(0.0f, new AnimationGradientCircle(centerX, centerY, 0, new EffectsEngine.RadialEffectBrush(transitions), (int)width));
 
-                                                animTrack.SetFrame(terminalTime, new AnimationGradientCircle(centerX, centerY, Effects.canvas_biggest, new EffectsEngine.EffectBrush(transitions).SetBrushType(EffectsEngine.EffectBrush.BrushType.Radial), (int)width));
+                                                animTrack.SetFrame(terminalTime, new AnimationGradientCircle(centerX, centerY, Effects.canvas_biggest, new EffectsEngine.RadialEffectBrush(transitions), (int)width));
                                                 app.Profile.Layers.Add(new Layers.Layer()
                                                 {
                                                     Name = layerName,
diff --git a/Project-Aurora/Project-Aurora/Utils/ColorUtils.cs b/Project-Aurora/Project-Aurora/Utils/ColorUtils.cs
index 67fdbc025..f94267108 100644
--- a/Project-Aurora/Project-Aurora/Utils/ColorUtils.cs
+++ b/Project-Aurora/Project-Aurora/Utils/ColorUtils.cs
@@ -503,7 +503,7 @@ public class RealColorConverter : IValueConverter {
     /// </summary>
     public class EffectBrushToBrushConverter : IValueConverter {
         public object Convert(object value, Type targetType, object parameter, CultureInfo culture) => ((EffectsEngine.EffectBrush)value).GetMediaBrush();
-        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) => new EffectsEngine.EffectBrush((System.Windows.Media.Brush)value);
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) => EffectsEngine.EffectBrush.GetEffectBrush((System.Windows.Media.Brush)value);
     }
 
     public class BoolToColorConverter : IValueConverter

From 64134130d23f4bc920bd3655a4a9265719dc1e30 Mon Sep 17 00:00:00 2001
From: Alex <ritt.alex@gmail.com>
Date: Sun, 10 May 2020 13:03:14 +0200
Subject: [PATCH 3/3] Change the Colorbox stored BrushType from Media.Brush to
 EffectBrush

---
 Project-Aurora/ColorBox/ColorBox.csproj       |   8 +
 .../ColorBox/Implementation/ColorBox.cs       | 354 ++++---
 .../Implementation/GradientStopSlider.cs      |   5 +-
 Project-Aurora/ColorBox/Themes/Generic.xaml   | 132 ++-
 .../Utils}/ColorSpectrum.cs                   |  13 +-
 Project-Aurora/ColorBox/Utils/ColorUtils.cs   | 465 +++++++++
 Project-Aurora/ColorBox/Utils/EffectBrush.cs  | 556 +++++++++++
 Project-Aurora/ColorBox/packages.config       |   4 +
 .../Controls/Control_FieldPresenter.xaml.cs   |   2 +-
 .../Controls/Control_GradientEditor.xaml      |   7 +-
 .../Controls/EffectSettingsWindow.xaml.cs     |  28 +-
 .../AnimationFilledGradientRectangle.cs       |   2 -
 .../Animations/AnimationGradientCircle.cs     |   9 +-
 .../EffectsEngine/EffectBrush.cs              | 943 ------------------
 .../EffectsEngine/EffectLayer.cs              |  22 +-
 .../Profiles/CloneHero/CloneHeroProfile.cs    |  18 +-
 .../Profiles/Desktop/DesktopProfile.cs        |   2 +-
 .../Profiles/Desktop/Event_Idle.cs            |   4 +-
 .../Profiles/ETS2/ETS2Profile.cs              |  10 +-
 .../Project-Aurora/Profiles/Osu/OsuProfile.cs |   2 +-
 .../Layers/PD2BackgroundLayerHandler.cs       |   4 +-
 .../RocketLeague/RocketLeagueProfile.cs       |   4 +-
 .../Profiles/Subnautica/SubnauticaProfile.cs  |   4 +-
 .../Profiles/Terraria/TerrariaProfile.cs      |   8 +-
 .../Project-Aurora/Project-Aurora.csproj      |   2 -
 .../Settings/LayerEffectConfig.cs             |  16 +-
 .../Layers/Control_EqualizerLayer.xaml.cs     |  37 +-
 .../Layers/Control_GradientFillLayer.xaml.cs  |  38 +-
 .../Layers/Control_GradientLayer.xaml.cs      |  38 +-
 .../Layers/Control_ParticleLayer.xaml.cs      |   2 +-
 .../Control_PercentGradientLayer.xaml.cs      |  14 +-
 .../Layers/Control_RadialLayer.xaml.cs        |   8 +-
 .../Settings/Layers/EqualizerLayerHandler.cs  |   9 +-
 .../Layers/InteractiveLayerHandler.cs         |  11 +-
 .../Layers/SimpleParticleLayerHandler.cs      |   2 +-
 .../Settings/ProfileImporter.cs               |  84 +-
 .../Project-Aurora/Utils/ColorUtils.cs        |   9 -
 .../Project-Aurora/Utils/JSONUtils.cs         |   3 +
 38 files changed, 1435 insertions(+), 1444 deletions(-)
 rename Project-Aurora/{Project-Aurora/EffectsEngine => ColorBox/Utils}/ColorSpectrum.cs (96%)
 create mode 100644 Project-Aurora/ColorBox/Utils/ColorUtils.cs
 create mode 100644 Project-Aurora/ColorBox/Utils/EffectBrush.cs
 create mode 100644 Project-Aurora/ColorBox/packages.config
 delete mode 100644 Project-Aurora/Project-Aurora/EffectsEngine/EffectBrush.cs

diff --git a/Project-Aurora/ColorBox/ColorBox.csproj b/Project-Aurora/ColorBox/ColorBox.csproj
index 8f7ce9ebc..3ae093541 100644
--- a/Project-Aurora/ColorBox/ColorBox.csproj
+++ b/Project-Aurora/ColorBox/ColorBox.csproj
@@ -41,10 +41,14 @@
     <AssemblyOriginatorKeyFile>ColorBox.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Newtonsoft.Json, Version=12.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>..\packages\Newtonsoft.Json.12.0.3\lib\net40\Newtonsoft.Json.dll</HintPath>
+    </Reference>
     <Reference Include="PresentationCore" />
     <Reference Include="PresentationFramework" />
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
     <Reference Include="System.Xaml" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
@@ -67,6 +71,9 @@
     <Compile Include="Implementation\SaturationBrightnessSelector.cs" />
     <Compile Include="Implementation\SpinEventArgs.cs" />
     <Compile Include="Implementation\Spinner.cs" />
+    <Compile Include="Utils\ColorSpectrum.cs" />
+    <Compile Include="Utils\ColorUtils.cs" />
+    <Compile Include="Utils\EffectBrush.cs" />
     <Compile Include="Utils\TextBoxBehavior.cs" />
     <Compile Include="Implementation\UpDownBase.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -81,6 +88,7 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="ColorBox.snk" />
+    <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
     <Content Include="LICENSE.txt" />
diff --git a/Project-Aurora/ColorBox/Implementation/ColorBox.cs b/Project-Aurora/ColorBox/Implementation/ColorBox.cs
index d5cc7337f..9a9673eef 100644
--- a/Project-Aurora/ColorBox/Implementation/ColorBox.cs
+++ b/Project-Aurora/ColorBox/Implementation/ColorBox.cs
@@ -20,6 +20,7 @@ This program is provided to you under the terms of the Microsoft Public
 using System.Windows.Input;
 using System.ComponentModel;
 using System.Windows.Data;
+using Aurora.EffectsEngine;
 
 namespace ColorBox
 {
@@ -97,7 +98,7 @@ private void ReverseGradientStop_Executed(object sender, ExecutedRoutedEventArgs
             this.SetBrush();
         }
 
-        void InitTransform()
+        /*void InitTransform()
         {
             if (this.Brush.Transform == null || this.Brush.Transform.Value.IsIdentity)
             {
@@ -112,120 +113,88 @@ void InitTransform()
 
                 this._BrushSetInternally = false;
             }
-        }
+        }*/
 
         #region Private Properties
-
-        double StartX
+        /*float StartX
         {
-            get { return (double)GetValue(StartXProperty); }
+            get { return (float)GetValue(StartXProperty); }
             set { SetValue(StartXProperty, value); }
         }
         static readonly DependencyProperty StartXProperty =
-            DependencyProperty.Register("StartX", typeof(double), typeof(ColorBox), new PropertyMetadata(0.5, new PropertyChangedCallback(StartXChanged)));
+            DependencyProperty.Register("StartX", typeof(float), typeof(ColorBox), new PropertyMetadata(0f, new PropertyChangedCallback(StartXChanged)));
         static void StartXChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
         {
             ColorBox cp = property as ColorBox;
-            if (cp.Brush is LinearGradientBrush)
-            {
-                cp._BrushSetInternally = true;
-                (cp.Brush as LinearGradientBrush).StartPoint = new Point((double)args.NewValue, (cp.Brush as LinearGradientBrush).StartPoint.Y);
-                cp._BrushSetInternally = false;
-            }
+            cp._BrushSetInternally = true;
+            cp.Brush.start.X = (float)args.NewValue;
+            cp._BrushSetInternally = false;
         }
 
-        double StartY
+        float StartY
         {
-            get { return (double)GetValue(StartYProperty); }
+            get { return (float)GetValue(StartYProperty); }
             set { SetValue(StartYProperty, value); }
         }
         static readonly DependencyProperty StartYProperty =
-            DependencyProperty.Register("StartY", typeof(double), typeof(ColorBox), new PropertyMetadata(0.0, new PropertyChangedCallback(StartYChanged)));
+            DependencyProperty.Register("StartY", typeof(float), typeof(ColorBox), new PropertyMetadata(0.0f, new PropertyChangedCallback(StartYChanged)));
         static void StartYChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
         {
             ColorBox cp = property as ColorBox;
-            if (cp.Brush is LinearGradientBrush)
-            {
-                cp._BrushSetInternally = true;
-                (cp.Brush as LinearGradientBrush).StartPoint = new Point((cp.Brush as LinearGradientBrush).StartPoint.X, (double)args.NewValue);
-                cp._BrushSetInternally = false;
-            }
+            cp._BrushSetInternally = true;
+            cp.Brush.start.Y = (float)args.NewValue;
+            cp._BrushSetInternally = false;
         }
 
-        double EndX
+        float EndX
         {
-            get { return (double)GetValue(EndXProperty); }
+            get { return (float)GetValue(EndXProperty); }
             set { SetValue(EndXProperty, value); }
         }
         static readonly DependencyProperty EndXProperty =
-            DependencyProperty.Register("EndX", typeof(double), typeof(ColorBox), new PropertyMetadata(0.5, new PropertyChangedCallback(EndXChanged)));
+            DependencyProperty.Register("EndX", typeof(float), typeof(ColorBox), new PropertyMetadata(1.0f, new PropertyChangedCallback(EndXChanged)));
         static void EndXChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
         {
             ColorBox cp = property as ColorBox;
-            if (cp.Brush is LinearGradientBrush)
-            {
-                cp._BrushSetInternally = true;
-                (cp.Brush as LinearGradientBrush).EndPoint = new Point((double)args.NewValue, (cp.Brush as LinearGradientBrush).EndPoint.Y);
-                cp._BrushSetInternally = false;
-            }
+            cp._BrushSetInternally = true;
+            cp.Brush.end.X = (float)args.NewValue;
+            cp._BrushSetInternally = false;
         }
 
-        double EndY
+        float EndY
         {
-            get { return (double)GetValue(EndYProperty); }
+            get { return (float)GetValue(EndYProperty); }
             set { SetValue(EndYProperty, value); }
         }
         static readonly DependencyProperty EndYProperty =
-            DependencyProperty.Register("EndY", typeof(double), typeof(ColorBox), new PropertyMetadata(1.0, new PropertyChangedCallback(EndYChanged)));
+            DependencyProperty.Register("EndY", typeof(float), typeof(ColorBox), new PropertyMetadata(1.0f, new PropertyChangedCallback(EndYChanged)));
         static void EndYChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
         {
             ColorBox cp = property as ColorBox;
-            if (cp.Brush is LinearGradientBrush)
-            {
-                cp._BrushSetInternally = true;
-                (cp.Brush as LinearGradientBrush).EndPoint = new Point((cp.Brush as LinearGradientBrush).EndPoint.X, (double)args.NewValue);
-                cp._BrushSetInternally = false;
-            }
-        }
-
-
-
-        double GradientOriginX
+            cp._BrushSetInternally = true;
+            cp.Brush.end.Y = (float)args.NewValue;
+            cp._BrushSetInternally = false;
+        }*/
+        int Angle
         {
-            get { return (double)GetValue(GradientOriginXProperty); }
-            set { SetValue(GradientOriginXProperty, value); }
+            get { return (int)GetValue(AngleProperty); }
+            set { SetValue(AngleProperty, value); }
         }
-        static readonly DependencyProperty GradientOriginXProperty =
-            DependencyProperty.Register("GradientOriginX", typeof(double), typeof(ColorBox), new PropertyMetadata(0.5, new PropertyChangedCallback(GradientOriginXChanged)));
-        static void GradientOriginXChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
+        static readonly DependencyProperty AngleProperty =
+            DependencyProperty.Register("Angle", typeof(int), typeof(ColorBox), new PropertyMetadata(0, new PropertyChangedCallback(AngleChanged)));
+        static void AngleChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
         {
             ColorBox cp = property as ColorBox;
-            if (cp.Brush is RadialGradientBrush)
-            {
-                cp._BrushSetInternally = true;
-                (cp.Brush as RadialGradientBrush).GradientOrigin = new Point((double)args.NewValue, (cp.Brush as RadialGradientBrush).GradientOrigin.Y);
-                cp._BrushSetInternally = false;
-            }
-        }
-
-        double GradientOriginY
-        {
-            get { return (double)GetValue(GradientOriginYProperty); }
-            set { SetValue(GradientOriginYProperty, value); }
-        }
-        static readonly DependencyProperty GradientOriginYProperty =
-            DependencyProperty.Register("GradientOriginY", typeof(double), typeof(ColorBox), new PropertyMetadata(0.5, new PropertyChangedCallback(GradientOriginYChanged)));
-        static void GradientOriginYChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
-        {
-            ColorBox cp = property as ColorBox;
-            if (cp.Brush is RadialGradientBrush)
+            
+            if (cp.Brush is LinearEffectBrush linearBrush)
             {
                 cp._BrushSetInternally = true;
-                (cp.Brush as RadialGradientBrush).GradientOrigin = new Point((cp.Brush as RadialGradientBrush).GradientOrigin.X, (double)args.NewValue);
+                linearBrush.Angle = (int)args.NewValue;
+                cp.SetBrush();
                 cp._BrushSetInternally = false;
             }
+            
         }
-
         double CenterX
         {
             get { return (double)GetValue(CenterXProperty); }
@@ -236,10 +205,12 @@ double CenterX
         static void CenterXChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
         {
             ColorBox cp = property as ColorBox;
-            if (cp.Brush is RadialGradientBrush)
+            if (cp.Brush is RadialEffectBrush radialBrush)
             {
+                float centerX = (float)((double)args.NewValue % 1);
+
                 cp._BrushSetInternally = true;
-                (cp.Brush as RadialGradientBrush).Center = new Point((double)args.NewValue, (cp.Brush as RadialGradientBrush).Center.Y);
+                radialBrush.Center.X = centerX;
                 cp._BrushSetInternally = false;
             }
         }
@@ -254,50 +225,36 @@ double CenterY
         static void CenterYChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
         {
             ColorBox cp = property as ColorBox;
-            if (cp.Brush is RadialGradientBrush)
+            if (cp.Brush is RadialEffectBrush radialBrush)
             {
+                float centerY = (float)((double)args.NewValue);
+                if (centerY > 1f) 
+                {
+                    centerY %= 1;
+                }
                 cp._BrushSetInternally = true;
-                (cp.Brush as RadialGradientBrush).Center = new Point((cp.Brush as RadialGradientBrush).Center.X, (double)args.NewValue);
+                radialBrush.Center.Y = centerY;
                 cp._BrushSetInternally = false;
             }
         }
 
-        double RadiusX
+        float SampleWindowSize
         {
-            get { return (double)GetValue(RadiusXProperty); }
-            set { SetValue(RadiusXProperty, value); }
+            get { return (float)GetValue(SampleWindowSizeProperty); }
+            set { SetValue(SampleWindowSizeProperty, value); }
         }
-        static readonly DependencyProperty RadiusXProperty =
-            DependencyProperty.Register("RadiusX", typeof(double), typeof(ColorBox), new PropertyMetadata(0.5, new PropertyChangedCallback(RadiusXChanged)));
-        static void RadiusXChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
+        static readonly DependencyProperty SampleWindowSizeProperty =
+            DependencyProperty.Register("SampleWindowSize", typeof(float), typeof(ColorBox), new PropertyMetadata(1.0f, new PropertyChangedCallback(SampleWindowSizeChanged)));
+        static void SampleWindowSizeChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
         {
             ColorBox cp = property as ColorBox;
-            if (cp.Brush is RadialGradientBrush)
-            {
-                cp._BrushSetInternally = true;
-                (cp.Brush as RadialGradientBrush).RadiusX = (double)args.NewValue;
-                cp._BrushSetInternally = false;
-            }
-        }
 
-        double RadiusY
-        {
-            get { return (double)GetValue(RadiusYProperty); }
-            set { SetValue(RadiusYProperty, value); }
-        }
-        static readonly DependencyProperty RadiusYProperty =
-            DependencyProperty.Register("RadiusY", typeof(double), typeof(ColorBox), new PropertyMetadata(0.5, new PropertyChangedCallback(RadiusYChanged)));
-        static void RadiusYChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
-        {
-            ColorBox cp = property as ColorBox;
-            if (cp.Brush is RadialGradientBrush)
-            {
-                cp._BrushSetInternally = true;
-                (cp.Brush as RadialGradientBrush).RadiusY = (double)args.NewValue;
-                cp._BrushSetInternally = false;
-            }
+            cp._BrushSetInternally = true;
+            cp.Brush.SampleWindowSize = (float)args.NewValue;
+            cp._BrushSetInternally = false;
         }
 
+
         double BrushOpacity
         {
             get { return (double)GetValue(BrushOpacityProperty); }
@@ -313,41 +270,20 @@ double BrushOpacity
         //    cp._BrushSetInternally = false;            
         //}
 
-        GradientSpreadMethod SpreadMethod
+        /*EffectBrush.BrushWrap SpreadMethod
         {
-            get { return (GradientSpreadMethod)GetValue(SpreadMethodProperty); }
+            get { return (EffectBrush.BrushWrap)GetValue(SpreadMethodProperty); }
             set { SetValue(SpreadMethodProperty, value); }
         }
         static readonly DependencyProperty SpreadMethodProperty =
-            DependencyProperty.Register("SpreadMethod", typeof(GradientSpreadMethod), typeof(ColorBox), new PropertyMetadata(GradientSpreadMethod.Pad, new PropertyChangedCallback(SpreadMethodChanged)));
+            DependencyProperty.Register("SpreadMethod", typeof(EffectBrush.BrushWrap), typeof(ColorBox), new PropertyMetadata(EffectBrush.BrushWrap.None, new PropertyChangedCallback(SpreadMethodChanged)));
         static void SpreadMethodChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
         {
             ColorBox cp = property as ColorBox;
-            if (cp.Brush is GradientBrush)
-            {
-                cp._BrushSetInternally = true;
-                (cp.Brush as GradientBrush).SpreadMethod = (GradientSpreadMethod)args.NewValue;
-                cp._BrushSetInternally = false;
-            }
-        }
-
-        BrushMappingMode MappingMode
-        {
-            get { return (BrushMappingMode)GetValue(MappingModeProperty); }
-            set { SetValue(MappingModeProperty, value); }
-        }
-        static readonly DependencyProperty MappingModeProperty =
-            DependencyProperty.Register("MappingMode", typeof(BrushMappingMode), typeof(ColorBox), new PropertyMetadata(BrushMappingMode.RelativeToBoundingBox, new PropertyChangedCallback(MappingModeChanged)));
-        static void MappingModeChanged(DependencyObject property, DependencyPropertyChangedEventArgs args)
-        {
-            ColorBox cp = property as ColorBox;
-            if (cp.Brush is GradientBrush)
-            {
-                cp._BrushSetInternally = true;
-                (cp.Brush as GradientBrush).MappingMode = (BrushMappingMode)args.NewValue;
-                cp._BrushSetInternally = false;
-            }
-        }
+            cp._BrushSetInternally = true;
+            cp.Brush.wrap = (EffectBrush.BrushWrap)args.NewValue;
+            cp._BrushSetInternally = false;
+        }*/
 
         #endregion
 
@@ -430,17 +366,18 @@ public IEnumerable<Enum> AvailableBrushTypes
             }
         }
 
-        public Brush Brush
+        public Brush MediaBrush
         {
-            get { return (Brush)GetValue(BrushProperty); }
-            set { SetValue(BrushProperty, value); }
+            get { return (Brush)GetValue(MediaBrushProperty); }
+            set { SetValue(MediaBrushProperty, value); }
         }
-        public static readonly DependencyProperty BrushProperty =
-            DependencyProperty.Register("Brush", typeof(Brush), typeof(ColorBox)
-            , new FrameworkPropertyMetadata(null, new PropertyChangedCallback(BrushChangedInternal)));
-        static void BrushChangedInternal(DependencyObject property, DependencyPropertyChangedEventArgs args)
+
+        public static readonly DependencyProperty MediaBrushProperty =
+            DependencyProperty.Register("MediaBrush", typeof(Brush), typeof(ColorBox)
+            , new FrameworkPropertyMetadata(null, new PropertyChangedCallback(MediaBrushChangedInternal)));
+        static void MediaBrushChangedInternal(DependencyObject property, DependencyPropertyChangedEventArgs args)
         {
-            ColorBox c = property as ColorBox;         
+            ColorBox c = property as ColorBox;
             Brush brush = args.NewValue as Brush;
 
             if (!c._BrushSetInternally)
@@ -461,12 +398,12 @@ static void BrushChangedInternal(DependencyObject property, DependencyPropertyCh
                 {
                     LinearGradientBrush lgb = brush as LinearGradientBrush;
                     //c.Opacity = lgb.Opacity;
-                    c.StartX = lgb.StartPoint.X;
-                    c.StartY = lgb.StartPoint.Y;
-                    c.EndX = lgb.EndPoint.X;
-                    c.EndY = lgb.EndPoint.Y;
-                    c.MappingMode = lgb.MappingMode;
-                    c.SpreadMethod = lgb.SpreadMethod;                       
+                    /* c.StartX = lgb.StartPoint.X;
+                     c.StartY = lgb.StartPoint.Y;
+                     c.EndX = lgb.EndPoint.X;
+                     c.EndY = lgb.EndPoint.Y;
+                     c.MappingMode = lgb.MappingMode;
+                     c.SpreadMethod = lgb.SpreadMethod;*/
                     c.Gradients = new ObservableCollection<GradientStop>(lgb.GradientStops);
                     c.BrushType = BrushTypes.Linear;
                     //c.Color = lgb.GradientStops.OrderBy(x => x.Offset).Last().Color;
@@ -480,19 +417,19 @@ static void BrushChangedInternal(DependencyObject property, DependencyPropertyCh
                     */
 
                     RadialGradientBrush rgb = brush as RadialGradientBrush;
-                    c.GradientOriginX = rgb.GradientOrigin.X;
+                    /*c.GradientOriginX = rgb.GradientOrigin.X;
                     c.GradientOriginY = rgb.GradientOrigin.Y;
                     c.RadiusX = rgb.RadiusX;
                     c.RadiusY = rgb.RadiusY;
                     c.CenterX = rgb.Center.X;
                     c.CenterY = rgb.Center.Y;
                     c.MappingMode = rgb.MappingMode;
-                    c.SpreadMethod = rgb.SpreadMethod;
+                    c.SpreadMethod = rgb.SpreadMethod;*/
                     c.Gradients = new ObservableCollection<GradientStop>(rgb.GradientStops);
                     c.BrushType = BrushTypes.Radial;
                     //c.Color = rgb.GradientStops.OrderBy(x => x.Offset).Last().Color;
                     //c.SelectedGradient = rgb.GradientStops.OrderBy(x => x.Offset).Last();
-                    
+
                 }
 
                 c._BrushTypeSetInternally = false;
@@ -501,7 +438,69 @@ static void BrushChangedInternal(DependencyObject property, DependencyPropertyCh
             {
                 c.RaiseBrushChangedEvent((Brush)args.NewValue);
             }
-        }        
+        }
+        public EffectBrush Brush
+        {
+            get { return (EffectBrush)GetValue(BrushProperty); }
+            set {
+                SetValue(BrushProperty, value);
+                SetValue(MediaBrushProperty, value.MediaBrush);
+            }
+        }
+        public static readonly DependencyProperty BrushProperty =
+            DependencyProperty.Register("Brush", typeof(EffectBrush), typeof(ColorBox)
+            , new FrameworkPropertyMetadata(null));//, new PropertyChangedCallback(BrushChangedInternal)));
+        /*static void BrushChangedInternal(DependencyObject property, DependencyPropertyChangedEventArgs args)
+        {
+            ColorBox c = property as ColorBox;
+            EffectBrush brush = args.NewValue as EffectBrush;
+
+            if (!c._BrushSetInternally)
+            {
+                c._BrushTypeSetInternally = true;
+
+                if (brush == null)
+                {
+                    c.BrushType = BrushTypes.Solid;
+                    c.Color = Color.FromArgb(255, 255, 0, 0);
+                }
+                else if (brush is SolidEffectBrush)
+                {
+                    c.BrushType = BrushTypes.Solid;
+                    c.Color = ColorExt.ToMediaColor(brush.colorGradients[0]);
+                }
+                else if (brush is LinearEffectBrush lgb)
+                {
+
+                    c.SpreadMethod = lgb.wrap;                       
+                    c.Gradients = new ObservableCollection<GradientStop>(lgb.GetGradientStops());
+                    c.BrushType = BrushTypes.Linear;
+                    //c.SampleWindowSize = lgb.SampleWindowSize;
+                    //c.Color = lgb.GradientStops.OrderBy(x => x.Offset).Last().Color;
+                    //c.SelectedGradient = lgb.GradientStops.OrderBy(x => x.Offset).Last();
+                }
+                else
+                {
+
+                    RadialEffectBrush rgb = brush as RadialEffectBrush;
+
+                    //c.SampleWindowSize = rgb.SampleWindowSize;
+                    c.SpreadMethod = rgb.wrap;
+                    c.Gradients = new ObservableCollection<GradientStop>(rgb.GetGradientStops());
+                    c.BrushType = BrushTypes.Radial;
+                    //c.Color = rgb.GradientStops.OrderBy(x => x.Offset).Last().Color;
+                    //c.SelectedGradient = rgb.GradientStops.OrderBy(x => x.Offset).Last();
+                    
+                }
+
+                c._BrushTypeSetInternally = false;
+            }
+            else
+            {
+                c.RaiseBrushChangedEvent(((EffectBrush)args.NewValue).MediaBrush);
+            }
+            //c.MediaBrush = brush.GetMediaBrush();
+        }   */     
 
         public Color Color
         {
@@ -763,6 +762,21 @@ void RaiseBrushChangedEvent(Brush brush)
         #endregion
         
 
+        private ColorSpectrum CalcColorSpectrum()
+        {
+            var colors = new ColorSpectrum();
+            GradientStop first = new GradientStop(new Color(), 1.0f);
+            GradientStop last = new GradientStop(new Color(), 0.0f);
+            foreach (var grad in Gradients)
+            {
+                if (grad.Offset < first.Offset) first = grad;
+                if (grad.Offset > last.Offset) last = grad;
+                colors.SetColorAt((float)grad.Offset, ColorUtils.MediaColorToDrawingColor(grad.Color));
+            }
+            colors.SetColorAt(0, ColorUtils.MediaColorToDrawingColor(first.Color));
+            colors.SetColorAt(1, ColorUtils.MediaColorToDrawingColor(last.Color));
+            return colors;
+        }
         internal void SetBrush()
         {
             if (!_UpdateBrush)
@@ -770,14 +784,6 @@ internal void SetBrush()
 
             this._BrushSetInternally = true;
 
-            // retain old opacity
-            double opacity = 1;
-            TransformGroup tempTG = null;
-            if (this.Brush != null)
-            {
-                opacity = this.Brush.Opacity;
-                tempTG = Brush.Transform as TransformGroup;
-            }
 
             switch (BrushType)
             {
@@ -785,44 +791,28 @@ internal void SetBrush()
 
                 case BrushTypes.Solid:
                     
-                    Brush = new SolidColorBrush(this.Color);
+                    Brush = new SolidEffectBrush(new SolidColorBrush(this.Color));
 
                     break;
 
                 case BrushTypes.Linear:
+                    var brush = new LinearEffectBrush(CalcColorSpectrum());
+                    brush.SampleWindowSize = this.SampleWindowSize;
+                    brush.Angle = Angle;
+                    Brush = new LinearEffectBrush(brush);
 
-                    var brush = new LinearGradientBrush();                    
-                    foreach (GradientStop g in Gradients)
-                    {
-                        brush.GradientStops.Add(new GradientStop(g.Color, g.Offset));
-                    }
-                    brush.StartPoint = new Point(this.StartX, this.StartY);
-                    brush.EndPoint = new Point(this.EndX, this.EndY);
-                    brush.MappingMode = this.MappingMode;
-                    brush.SpreadMethod = this.SpreadMethod;
-                    Brush = brush;
-                    
                     break;
 
                 
                 case BrushTypes.Radial:
 
-                    var brush1 = new RadialGradientBrush();                   
-                    foreach (GradientStop g in Gradients)
-                    {
-                        brush1.GradientStops.Add(new GradientStop(g.Color, g.Offset));
-                    }
-                    brush1.GradientOrigin = new Point(this.GradientOriginX, this.GradientOriginY);
-                    brush1.Center = new Point(this.CenterX, this.CenterY);
-                    brush1.RadiusX = this.RadiusX;
-                    brush1.RadiusY = this.RadiusY;
-                    brush1.MappingMode = this.MappingMode;
-                    brush1.SpreadMethod = this.SpreadMethod;
-                    Brush = brush1;
+                    var brush1 = new RadialEffectBrush(CalcColorSpectrum());
+                    brush1.SampleWindowSize = this.SampleWindowSize;
+                    brush1.Center = new System.Drawing.PointF((float)CenterX, (float)CenterY);
+                    Brush = (RadialEffectBrush)brush1.Clone();
 
                     break;
             }
-            
             /*
             if (this.BrushType != BrushTypes.None)
             {
diff --git a/Project-Aurora/ColorBox/Implementation/GradientStopSlider.cs b/Project-Aurora/ColorBox/Implementation/GradientStopSlider.cs
index 8efd85c78..468bb7afa 100644
--- a/Project-Aurora/ColorBox/Implementation/GradientStopSlider.cs
+++ b/Project-Aurora/ColorBox/Implementation/GradientStopSlider.cs
@@ -26,18 +26,17 @@ protected override void OnPreviewMouseLeftButtonDown(MouseButtonEventArgs e)
             if (this.ColorBox != null)
             {
                 this.ColorBox._BrushSetInternally = true;
-                this.ColorBox._UpdateBrush = false;        
+                this.ColorBox._UpdateBrush = false;
 
                 this.ColorBox.SelectedGradient = this.SelectedGradient;
                 this.ColorBox.Color = this.SelectedGradient.Color;
-                
+
                 this.ColorBox._UpdateBrush = true;
                 //this.ColorBox._BrushSetInternally = false;
 
                 //e.Handled = true;
             }
         }
-
         protected override void OnValueChanged(double oldValue, double newValue)
         {
             base.OnValueChanged(oldValue, newValue);
diff --git a/Project-Aurora/ColorBox/Themes/Generic.xaml b/Project-Aurora/ColorBox/Themes/Generic.xaml
index 50ff0f2f6..bb6a9a120 100644
--- a/Project-Aurora/ColorBox/Themes/Generic.xaml
+++ b/Project-Aurora/ColorBox/Themes/Generic.xaml
@@ -28,7 +28,7 @@
     </Style>
 
     <Style TargetType="Slider" x:Key="OpacitySliderStyle">
-        <Setter Property="Value" Value="{Binding Brush.Opacity, RelativeSource={RelativeSource TemplatedParent}, Mode=TwoWay}"/>
+        <Setter Property="Value" Value="{Binding MediaBrush.Opacity, RelativeSource={RelativeSource TemplatedParent}, Mode=TwoWay}"/>
         <Setter Property="IsMoveToPointEnabled" Value="True"/>
         <Setter Property="Margin" Value="2"/>
         <Setter Property="Minimum" Value="0"/>
@@ -59,6 +59,7 @@
     <Style x:Key="SliderThumbStyle" TargetType="Thumb">
         <Setter Property="SnapsToDevicePixels" Value="True" />
         <Setter Property="BorderBrush" Value="Black" />
+        
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="Thumb">
@@ -191,13 +192,90 @@
                                           MinHeight="20"
                                           Padding="1"
                                           Foreground="{TemplateBinding Foreground}"
-                                          Background="{TemplateBinding Brush}">
+                                          Background="{TemplateBinding MediaBrush}">
                                 <ToggleButton.Style>
                                     <Style TargetType="{x:Type ToggleButton}">
                                         <Setter Property="Template">
                                             <Setter.Value>
                                                 <ControlTemplate TargetType="{x:Type ToggleButton}">
                                                     <DockPanel Background="Transparent" Margin="{TemplateBinding Padding}">
+                                                        <!-- Available brush types -->
+                                                        <ListBox x:Name="listAvailableBrushType"                                                
+                                                 HorizontalContentAlignment="Center"
+                                                 SelectedItem="{Binding BrushType, RelativeSource={RelativeSource TemplatedParent}, Mode=TwoWay}" 
+                                                 ItemsSource="{Binding AvailableBrushTypes, RelativeSource={RelativeSource TemplatedParent}}">
+                                                            <ListBox.ItemsPanel>
+                                                                <ItemsPanelTemplate>
+                                                                    <UniformGrid Rows="1" Columns="4"/>
+                                                                </ItemsPanelTemplate>
+                                                            </ListBox.ItemsPanel>
+                                                            <ListBox.ItemContainerStyle>
+                                                                <Style TargetType="ListBoxItem">
+                                                                    <Setter Property="Template">
+                                                                        <Setter.Value>
+                                                                            <ControlTemplate TargetType="ListBoxItem">
+                                                                                <Border x:Name="Border" Background="Transparent" Padding="0,3">
+                                                                                    <Path x:Name="Icon" Height="12" Width="20" Stretch="Fill" Fill="#FF5F5F5F" StrokeThickness="1" Stroke="White"
+                                                                          Data="M371,190L557,190 557,293 371,293 371,190z"/>
+                                                                                </Border>
+
+                                                                                <ControlTemplate.Triggers>
+                                                                                    <Trigger Property="IsMouseOver" Value="True">
+                                                                                        <Setter Property="Background" Value="Gray" TargetName="Border"/>
+                                                                                        <Setter Property="Foreground" Value="White"/>
+                                                                                    </Trigger>
+                                                                                    <Trigger Property="IsSelected" Value="True">
+                                                                                        <Setter Property="Background" Value="Gray" TargetName="Border"/>
+                                                                                        <Setter Property="Foreground" Value="White"/>
+                                                                                    </Trigger>
+
+                                                                                    <!--
+                                                                    <DataTrigger Binding="{Binding}" Value="None">
+                                                                        <Setter Property="ToolTip" Value="No Brush"/>
+                                                                        <Setter Property="StrokeThickness" TargetName="Icon" Value="0"/>
+                                                                        <Setter TargetName="Icon" Property="Data">
+                                                                            <Setter.Value>
+                                                                                <Geometry>M612,189L452.949,189L452.949,266.024L612,189 M612,196.999L452.949,273.999L612,273.999L612,196.999</Geometry>
+                                                                            </Setter.Value>
+                                                                        </Setter>
+                                                                    </DataTrigger>
+                                                                    -->
+                                                                                    <DataTrigger Binding="{Binding}" Value="Solid">
+                                                                                        <Setter Property="ToolTip" Value="Solid Color Brush"/>
+                                                                                        <Setter Property="Fill" TargetName="Icon" Value="#FF403C3C"/>
+                                                                                    </DataTrigger>
+                                                                                    <DataTrigger Binding="{Binding}" Value="Linear">
+                                                                                        <Setter Property="ToolTip" Value="Linear Gradient Brush"/>
+                                                                                        <Setter Property="Fill" TargetName="Icon">
+                                                                                            <Setter.Value>
+                                                                                                <LinearGradientBrush StartPoint="0,.5" EndPoint="1,.5">
+                                                                                                    <GradientStop Color="#FF403C3C" Offset="0"></GradientStop>
+                                                                                                    <GradientStop Color="White" Offset="1"></GradientStop>
+                                                                                                </LinearGradientBrush>
+                                                                                            </Setter.Value>
+                                                                                        </Setter>
+                                                                                    </DataTrigger>
+
+                                                                                    <DataTrigger Binding="{Binding}" Value="Radial">
+                                                                                        <Setter Property="ToolTip" Value="Radial Gradient Brush"/>
+                                                                                        <Setter Property="Fill" TargetName="Icon">
+                                                                                            <Setter.Value>
+                                                                                                <RadialGradientBrush>
+                                                                                                    <GradientStop Color="#FF403C3C" Offset="1"/>
+                                                                                                    <GradientStop Color="White"/>
+                                                                                                </RadialGradientBrush>
+                                                                                            </Setter.Value>
+                                                                                        </Setter>
+                                                                                    </DataTrigger>
+
+                                                                                </ControlTemplate.Triggers>
+                                                                            </ControlTemplate>
+                                                                        </Setter.Value>
+                                                                    </Setter>
+                                                                </Style>
+                                                            </ListBox.ItemContainerStyle>
+
+                                                        </ListBox>
                                                         <Border MinWidth="20" Background="{StaticResource AlphaBrush}">
                                                             <Border Background="{TemplateBinding Background}" />
                                                         </Border>
@@ -452,7 +530,7 @@
                                                                          FocusVisualStyle="{x:Null}"
                                                                          ColorBox="{Binding RelativeSource={RelativeSource TemplatedParent}}">
                                                     <local:GradientStopAdder.Background>
-                                                        <LinearGradientBrush GradientStops="{Binding Brush.GradientStops, RelativeSource={RelativeSource TemplatedParent}}" 
+                                                        <LinearGradientBrush GradientStops="{Binding MediaBrush.GradientStops, RelativeSource={RelativeSource TemplatedParent}}" 
                                                                              StartPoint="0, .5" EndPoint="1, .5"/>
                                                     </local:GradientStopAdder.Background>
                                                     <Button.Style>
@@ -666,7 +744,7 @@
                                                 <DockPanel>
                                                     <DockPanel.Style>
                                                         <Style TargetType="DockPanel">
-                                                            <Setter Property="Visibility" Value="Visible"/>
+                                                            <Setter Property="Visibility" Value="Collapsed"/>
                                                             <Style.Triggers>
                                                                 <DataTrigger Binding="{Binding ElementName=listAvailableBrushType, Path=SelectedValue}" Value="Linear">
                                                                     <Setter Property="Visibility" Value="Visible"/>
@@ -675,37 +753,34 @@
                                                         </Style>
                                                     </DockPanel.Style>
 
-                                                    <UniformGrid Rows="5" DockPanel.Dock="Left" Margin="0,0,5,0" >
-                                                        <TextBlock Text="Start Point" VerticalAlignment="Center"/>
-                                                        <TextBlock Text="End Point" VerticalAlignment="Center"/>
-                                                        <TextBlock Text="Mapping Mode" VerticalAlignment="Center"/>
+                                                    <UniformGrid Rows="6" DockPanel.Dock="Left" Margin="0,0,5,0" >
+                                                        <TextBlock Text="Sample Window Size" VerticalAlignment="Center"/>
+                                                        <TextBlock Text="Angle" VerticalAlignment="Center"/>
+                                                        <!-- <TextBlock Text="Mapping Mode" VerticalAlignment="Center"/>
                                                         <TextBlock Text="Spread Method" VerticalAlignment="Center"/>
-                                                        <!-- <TextBlock Text="Opacity" VerticalAlignment="Center"/> -->
+                                                        <TextBlock Text="Opacity" VerticalAlignment="Center"/> -->
                                                     </UniformGrid>
-
-                                                    <UniformGrid Rows="5" DockPanel.Dock="Right">
+                                                    
+                                                    <UniformGrid Rows="6" DockPanel.Dock="Right">
                                                         <UniformGrid Rows="1">
-                                                            <local:DoubleUpDown Value="{Binding StartX, RelativeSource={RelativeSource TemplatedParent}}"/>
-                                                            <local:DoubleUpDown Value="{Binding StartY, RelativeSource={RelativeSource TemplatedParent}}"/>
+                                                            <Slider  Minimum="0" SmallChange="0.01" SelectionStart="1" IsSnapToTickEnabled="True" TickFrequency="0.01" Maximum="1" Value="{Binding SampleWindowSize, RelativeSource={RelativeSource TemplatedParent}}"/>
                                                         </UniformGrid>
-
                                                         <UniformGrid Rows="1">
-                                                            <local:DoubleUpDown Value="{Binding EndX, RelativeSource={RelativeSource TemplatedParent}}"/>
-                                                            <local:DoubleUpDown Value="{Binding EndY, RelativeSource={RelativeSource TemplatedParent}}"/>
+                                                            <local:DoubleUpDown Value="{Binding Angle, RelativeSource={RelativeSource TemplatedParent}}"/>
                                                         </UniformGrid>
-
+                                                        <!--
                                                         <ComboBox Margin="2" ItemsSource="{Binding MappingModeTypes, RelativeSource={RelativeSource TemplatedParent}}"
                                                                   SelectedItem="{Binding MappingMode, RelativeSource={RelativeSource TemplatedParent}}"/>
 
                                                         <ComboBox Margin="2" ItemsSource="{Binding SpreadMethodTypes, RelativeSource={RelativeSource TemplatedParent}}"
                                                                   SelectedItem="{Binding SpreadMethod, RelativeSource={RelativeSource TemplatedParent}}"/>
-
+                                                        -->
                                                         <!-- <Slider Style="{StaticResource OpacitySliderStyle}"/> -->
                                                     </UniformGrid>
                                                 </DockPanel>
 
                                                 <!-- Radial brush -->
-                                                <!--
+                                                
                                                 <DockPanel>
                                                     <DockPanel.Style>
                                                         <Style TargetType="DockPanel">
@@ -719,16 +794,25 @@
                                                     </DockPanel.Style>
 
                                                     <UniformGrid Rows="7" DockPanel.Dock="Left" Margin="0,0,5,0">
-                                                        <TextBlock Text="Gradient Origin" VerticalAlignment="Center"/>
-                                                        <TextBlock Text="Center" VerticalAlignment="Center"/>
+                                                        <TextBlock Text="Sample Window Size" VerticalAlignment="Center"/>
+                                                        <TextBlock Text="Center Point" VerticalAlignment="Center"/>
+                                                        <!--
                                                         <TextBlock Text="Radius X" VerticalAlignment="Center"/>
                                                         <TextBlock Text="Radius Y" VerticalAlignment="Center"/>
                                                         <TextBlock Text="Mapping Mode" VerticalAlignment="Center"/>
                                                         <TextBlock Text="Spread Method" VerticalAlignment="Center"/>
-                                                        <TextBlock Text="Opacity" VerticalAlignment="Center"/>
+                                                        <TextBlock Text="Opacity" VerticalAlignment="Center"/>-->
                                                     </UniformGrid>
 
                                                     <UniformGrid Rows="7" DockPanel.Dock="Right">
+                                                        <UniformGrid Rows="1">
+                                                            <Slider  Minimum="0" SmallChange="0.01" SelectionStart="1" IsSnapToTickEnabled="True" TickFrequency="0.01" Maximum="1" Value="{Binding SampleWindowSize, RelativeSource={RelativeSource TemplatedParent}}"/>
+                                                        </UniformGrid>
+                                                        <UniformGrid Rows="1">
+                                                            <local:DoubleUpDown Value="{Binding CenterX, RelativeSource={RelativeSource TemplatedParent}}"/>
+                                                            <local:DoubleUpDown Value="{Binding CenterY, RelativeSource={RelativeSource TemplatedParent}}"/>
+                                                        </UniformGrid>
+                                                        <!--
                                                         <UniformGrid Rows="1">
                                                             <local:DoubleUpDown Value="{Binding GradientOriginX, RelativeSource={RelativeSource TemplatedParent}}"/>
                                                             <local:DoubleUpDown Value="{Binding GradientOriginY, RelativeSource={RelativeSource TemplatedParent}}"/>
@@ -751,10 +835,10 @@
                                                                   ItemsSource="{Binding SpreadMethodTypes, RelativeSource={RelativeSource TemplatedParent}}"
                                                                   SelectedItem="{Binding SpreadMethod, RelativeSource={RelativeSource TemplatedParent}}"/>
 
-                                                        <Slider Style="{StaticResource OpacitySliderStyle}"/>
+                                                        <Slider Style="{StaticResource OpacitySliderStyle}"/>-->
                                                     </UniformGrid>
                                                 </DockPanel>    
-                                                -->
+                                                
                                             </StackPanel>
                                         </StackPanel>
                                     </StackPanel>
diff --git a/Project-Aurora/Project-Aurora/EffectsEngine/ColorSpectrum.cs b/Project-Aurora/ColorBox/Utils/ColorSpectrum.cs
similarity index 96%
rename from Project-Aurora/Project-Aurora/EffectsEngine/ColorSpectrum.cs
rename to Project-Aurora/ColorBox/Utils/ColorSpectrum.cs
index c922004ea..2df817c89 100644
--- a/Project-Aurora/Project-Aurora/EffectsEngine/ColorSpectrum.cs
+++ b/Project-Aurora/ColorBox/Utils/ColorSpectrum.cs
@@ -3,8 +3,9 @@
 using System.Drawing;
 using System.Drawing.Drawing2D;
 using System.Linq;
+using ColorBox;
 
-namespace Aurora.EffectsEngine
+namespace ColorBox
 {
 	/// <summary>
 	/// A class that represents a spectrum of colors. After creating an instance, you can then retrieve a blended color within a range of [0.0f, 1.0f].
@@ -201,8 +202,8 @@ public Color GetColorAt(float position, float max_position = 1.0f, double opacit
 				}
 			}
 
-			return Utils.ColorUtils.MultiplyColorByScalar(
-				Utils.ColorUtils.BlendColors(
+			return ColorUtils.MultiplyColorByScalar(
+				ColorUtils.BlendColors(
 					colors[closest_lower], colors[closest_higher], ((double)(position - closest_lower) / (double)(closest_higher - closest_lower))
 					),
 				opacity
@@ -221,7 +222,7 @@ public Color GetColorAt(float position, float max_position = 1.0f, double opacit
 		public LinearGradientBrush ToLinearGradient(float width, float height = 0.0f, float x = 0.0f, float y = 0.0f, double opacity = 1.0D)
 		{
 			var newColors = colors.Keys
-				.Select(val => new KeyValuePair<float, Color>(val, Utils.ColorUtils.MultiplyColorByScalar(colors[val], opacity)))
+				.Select(val => new KeyValuePair<float, Color>(val, ColorUtils.MultiplyColorByScalar(colors[val], opacity)))
 				.OrderBy(val => val.Key)
 				.ToList();
 
@@ -242,7 +243,7 @@ public LinearGradientBrush ToLinearGradient(float width, float height = 0.0f, fl
 					.OrderBy(val => val.Key)
 					.ToList();
 
-				var endColor = Utils.ColorUtils.BlendColors(
+				var endColor = ColorUtils.BlendColors(
 					newColors.First().Value, newColors.Last().Value,
 					((double) (newColors.First().Key) / (double) (newColors.First().Key + 1.0f - newColors.Last().Key)));
 
@@ -288,7 +289,7 @@ public ColorSpectrum MultiplyByScalar(double scalar)
 			Dictionary<float, Color> newcolors = new Dictionary<float, Color>();
 
 			foreach (KeyValuePair<float, Color> kvp in colors)
-				newcolors[kvp.Key] = Utils.ColorUtils.MultiplyColorByScalar(kvp.Value, scalar);
+				newcolors[kvp.Key] = ColorUtils.MultiplyColorByScalar(kvp.Value, scalar);
 
 			colors = newcolors;
 
diff --git a/Project-Aurora/ColorBox/Utils/ColorUtils.cs b/Project-Aurora/ColorBox/Utils/ColorUtils.cs
new file mode 100644
index 000000000..755308451
--- /dev/null
+++ b/Project-Aurora/ColorBox/Utils/ColorUtils.cs
@@ -0,0 +1,465 @@
+using Newtonsoft.Json;
+using System;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Globalization;
+using System.Windows.Data;
+
+namespace ColorBox
+{
+    public static class ColorExt
+    {
+        public static System.Drawing.Color ToDrawingColor(this System.Windows.Media.Color self)
+        {
+            return ColorUtils.MediaColorToDrawingColor(self);
+        }
+
+        public static System.Windows.Media.Color ToMediaColor(this System.Drawing.Color self)
+        {
+            return ColorUtils.DrawingColorToMediaColor(self);
+        }
+
+        public static System.Windows.Media.Color Clone(this System.Windows.Media.Color self)
+        {
+            return ColorUtils.CloneMediaColor(self);
+        }
+
+        public static System.Drawing.Color Clone(this System.Drawing.Color clr)
+        {
+            return ColorUtils.CloneDrawingColor(clr);
+        }
+    }   
+
+    /// <summary>
+    /// Various color utilities
+    /// </summary>
+    public static class ColorUtils
+    {
+        private static Random randomizer = new Random();
+
+        /// <summary>
+        /// Converts from System.Windows.Media.Color to System.Drawing.Color
+        /// </summary>
+        /// <param name="in_color">A Windows Media Color</param>
+        /// <returns>A Drawing Color</returns>
+        public static System.Drawing.Color MediaColorToDrawingColor(System.Windows.Media.Color in_color)
+        {
+            return System.Drawing.Color.FromArgb(in_color.A, in_color.R, in_color.G, in_color.B);
+        }
+
+        /// <summary>
+        /// Converts from System.Drawing.Color to System.Windows.Media.Color
+        /// </summary>
+        /// <param name="in_color">A Drawing Color</param>
+        /// <returns>A Windows Media Color</returns>
+        public static System.Windows.Media.Color DrawingColorToMediaColor(System.Drawing.Color in_color)
+        {
+            return System.Windows.Media.Color.FromArgb(in_color.A, in_color.R, in_color.G, in_color.B);
+        }
+
+        /// <summary>
+        /// Multiplies a byte by a specified double balue
+        /// </summary>
+        /// <param name="color">Part of the color, as a byte</param>
+        /// <param name="value">The value to multiply the byte by</param>
+        /// <returns>The color byte</returns>
+        public static byte ColorByteMultiplication(byte color, double value)
+        {
+            byte returnbyte = color;
+
+            if ((double)returnbyte * value >= 255.0)
+                returnbyte = 255;
+            else if ((double)returnbyte * value <= 0.0)
+                returnbyte = 0;
+            else
+                returnbyte = (byte)((double)returnbyte * value);
+
+            return returnbyte;
+        }
+
+        /// <summary>
+        /// Blends two colors together by a specified amount
+        /// </summary>
+        /// <param name="background">The background color (When percent is at 0.0D, only this color is shown)</param>
+        /// <param name="foreground">The foreground color (When percent is at 1.0D, only this color is shown)</param>
+        /// <param name="percent">The blending percent value</param>
+        /// <returns>The blended color</returns>
+        public static System.Drawing.Color BlendColors(System.Drawing.Color background, System.Drawing.Color foreground, double percent)
+        {
+            if (percent < 0.0)
+                percent = 0.0;
+            else if (percent > 1.0)
+                percent = 1.0;
+
+            int Red = (byte)Math.Min((Int32)foreground.R * percent + (Int32)background.R * (1.0 - percent), 255);
+            int Green = (byte)Math.Min((Int32)foreground.G * percent + (Int32)background.G * (1.0 - percent), 255);
+            int Blue = (byte)Math.Min((Int32)foreground.B * percent + (Int32)background.B * (1.0 - percent), 255);
+            int Alpha = (byte)Math.Min((Int32)foreground.A * percent + (Int32)background.A * (1.0 - percent), 255);
+
+            return System.Drawing.Color.FromArgb(Alpha, Red, Green, Blue);
+        }
+
+        /// <summary>
+        /// Blends two colors together by a specified amount
+        /// </summary>
+        /// <param name="background">The background color (When percent is at 0.0D, only this color is shown)</param>
+        /// <param name="foreground">The foreground color (When percent is at 1.0D, only this color is shown)</param>
+        /// <param name="percent">The blending percent value</param>
+        /// <returns>The blended color</returns>
+        public static System.Windows.Media.Color BlendColors(System.Windows.Media.Color background, System.Windows.Media.Color foreground, double percent)
+        {
+            if (percent < 0.0)
+                percent = 0.0;
+            else if (percent > 1.0)
+                percent = 1.0;
+
+            int Red = (byte)Math.Min((Int32)foreground.R * percent + (Int32)background.R * (1.0 - percent), 255);
+            int Green = (byte)Math.Min((Int32)foreground.G * percent + (Int32)background.G * (1.0 - percent), 255);
+            int Blue = (byte)Math.Min((Int32)foreground.B * percent + (Int32)background.B * (1.0 - percent), 255);
+            int Alpha = (byte)Math.Min((Int32)foreground.A * percent + (Int32)background.A * (1.0 - percent), 255);
+
+            return System.Windows.Media.Color.FromArgb((byte)Alpha, (byte)Red, (byte)Green, (byte)Blue);
+        }
+
+        /// <summary>
+        /// Adds two colors together by using the alpha component of the foreground color
+        /// </summary>
+        /// <param name="background">The background color</param>
+        /// <param name="foreground">The foreground color (must have transparency to allow color blending)</param>
+        /// <returns>The sum of two colors</returns>
+        public static System.Drawing.Color AddColors(System.Drawing.Color background, System.Drawing.Color foreground)
+        {
+            if ((object)background == null)
+                return foreground;
+
+            if ((object)foreground == null)
+                return background;
+
+            return BlendColors(background, foreground, foreground.A / 255.0);
+        }
+
+        /// <summary>
+        /// Multiplies all non-alpha values by alpha/255.
+        /// Device integrations don't support alpha values, so we correct them here
+        /// </summary>
+        /// <param name="color">Color to correct</param>
+        /// <returns>Corrected Color</returns>
+        public static System.Drawing.Color CorrectWithAlpha(System.Drawing.Color color)
+        {
+            float scalar = color.A / 255.0f;
+
+            int Red = ColorByteMultiplication(color.R, scalar);
+            int Green = ColorByteMultiplication(color.G, scalar);
+            int Blue = ColorByteMultiplication(color.B, scalar);
+
+            return System.Drawing.Color.FromArgb(255, Red, Green, Blue);
+        }
+
+        /// <summary>
+        /// Multiplies a Drawing Color instance by a scalar value
+        /// </summary>
+        /// <param name="color">The color to be multiplied</param>
+        /// <param name="scalar">The scalar amount for multiplication</param>
+        /// <returns>The multiplied Color</returns>
+        public static System.Drawing.Color MultiplyColorByScalar(System.Drawing.Color color, double scalar)
+        {
+            int Red = ColorByteMultiplication(color.R, scalar);
+            int Green = ColorByteMultiplication(color.G, scalar);
+            int Blue = ColorByteMultiplication(color.B, scalar);
+            int Alpha = ColorByteMultiplication(color.A, scalar);
+
+            return System.Drawing.Color.FromArgb(Alpha, Red, Green, Blue);
+        }
+
+        /// <summary>
+        /// Multiplies a Drawing Color instance by a scalar value
+        /// </summary>
+        /// <param name="color">The color to be multiplied</param>
+        /// <param name="scalar">The scalar amount for multiplication</param>
+        /// <returns>The multiplied Color</returns>
+        public static System.Windows.Media.Color MultiplyColorByScalar(System.Windows.Media.Color color, double scalar)
+        {
+            int Red = ColorByteMultiplication(color.R, scalar);
+            int Green = ColorByteMultiplication(color.G, scalar);
+            int Blue = ColorByteMultiplication(color.B, scalar);
+            int Alpha = ColorByteMultiplication(color.A, scalar);
+
+            return System.Windows.Media.Color.FromArgb((byte)Alpha, (byte)Red, (byte)Green, (byte)Blue);
+        }
+
+        /// <summary>
+        /// Generates a random color
+        /// </summary>
+        /// <returns>A random color</returns>
+        public static System.Drawing.Color GenerateRandomColor()
+        {
+            return System.Drawing.Color.FromArgb(randomizer.Next(255), randomizer.Next(255), randomizer.Next(255));
+        }
+
+        /// <summary>
+        /// Generates a random color within a certain base color range
+        /// </summary>
+        /// <param name="baseColor">A base color range</param>
+        /// <returns>A random color within a base range</returns>
+        public static System.Drawing.Color GenerateRandomColor(System.Drawing.Color baseColor)
+        {
+            int red = (randomizer.Next(255) + baseColor.R) / 2;
+            int green = (randomizer.Next(255) + baseColor.G) / 2;
+            int blue = (randomizer.Next(255) + baseColor.B) / 2;
+            int alpha = (255 + baseColor.A) / 2;
+
+            return System.Drawing.Color.FromArgb(alpha, red, green, blue);
+        }
+
+        /// <summary>
+        /// Returns an average color from a presented Bitmap
+        /// </summary>
+        /// <param name="bitmap">The bitmap to be evaluated</param>
+        /// <returns>An average color from the bitmap</returns>
+        public static Color GetAverageColor(System.Windows.Media.Imaging.BitmapSource bitmap)
+        {
+            var format = bitmap.Format;
+
+            if (format != System.Windows.Media.PixelFormats.Bgr24 &&
+                format != System.Windows.Media.PixelFormats.Bgr32 &&
+                format != System.Windows.Media.PixelFormats.Bgra32 &&
+                format != System.Windows.Media.PixelFormats.Pbgra32)
+            {
+                throw new InvalidOperationException("BitmapSource must have Bgr24, Bgr32, Bgra32 or Pbgra32 format");
+            }
+
+            var width = bitmap.PixelWidth;
+            var height = bitmap.PixelHeight;
+            var numPixels = width * height;
+            var bytesPerPixel = format.BitsPerPixel / 8;
+            var pixelBuffer = new byte[numPixels * bytesPerPixel];
+
+            bitmap.CopyPixels(pixelBuffer, width * bytesPerPixel, 0);
+
+            long blue = 0;
+            long green = 0;
+            long red = 0;
+
+            for (int i = 0; i < pixelBuffer.Length; i += bytesPerPixel)
+            {
+                blue += pixelBuffer[i];
+                green += pixelBuffer[i + 1];
+                red += pixelBuffer[i + 2];
+            }
+
+            return Color.FromArgb((byte)(red / numPixels), (byte)(green / numPixels), (byte)(blue / numPixels));
+        }
+
+        public static Color GetColorFromInt(int interger)
+        {
+            if (interger < 0)
+                interger = 0;
+            else if (interger > 16777215)
+                interger = 16777215;
+
+            int R = interger >> 16;
+            int G = (interger >> 8) & 255;
+            int B = interger & 255;
+
+            return Color.FromArgb(R, G, B);
+        }
+
+        public static int GetIntFromColor(Color color)
+        {
+            return (color.R << 16) | (color.G << 8) | (color.B);
+        }
+
+        public static void ToHsv(Color color, out double hue, out double saturation, out double value)
+        {
+            var max = Math.Max(color.R, Math.Max(color.G, color.B));
+            var min = Math.Min(color.R, Math.Min(color.G, color.B));
+
+            var delta = max - min;
+
+            hue = 0d;
+            if (delta != 0)
+            {
+                if (color.R == max) hue = (color.G - color.B) / (double)delta;
+                else if (color.G == max) hue = 2d + (color.B - color.R) / (double)delta;
+                else if (color.B == max) hue = 4d + (color.R - color.G) / (double)delta;
+            }
+
+            hue *= 60;
+            if (hue < 0.0) hue += 360;
+
+            saturation = (max == 0) ? 0 : 1d - (1d * min / max);
+            value = max / 255d;
+        }
+
+        public static Color FromHsv(double hue, double saturation, double value)
+        {
+            saturation = Math.Max(Math.Min(saturation, 1), 0);
+            value = Math.Max(Math.Min(value, 1), 0);
+
+            var hi = Convert.ToInt32(Math.Floor(hue / 60)) % 6;
+            var f = hue / 60 - Math.Floor(hue / 60);
+
+            value *= 255;
+            var v = (byte)(value);
+            var p = (byte)(value * (1 - saturation));
+            var q = (byte)(value * (1 - f * saturation));
+            var t = (byte)(value * (1 - (1 - f) * saturation));
+
+            switch (hi)
+            {
+                case 0: return Color.FromArgb(v, t, p);
+                case 1: return Color.FromArgb(q, v, p);
+                case 2: return Color.FromArgb(p, v, t);
+                case 3: return Color.FromArgb(p, q, v);
+                case 4: return Color.FromArgb(t, p, v);
+                default: return Color.FromArgb(v, p, q);
+            }
+        }
+
+        /// <summary>
+        /// Changes the hue of <paramref name="color"/>
+        /// </summary>
+        /// <param name="color">Color to be modified</param>
+        /// <param name="offset">Hue offset in degrees</param>
+        /// <returns>Color with modified hue</returns>
+        public static Color ChangeHue(Color color, double offset)
+        {
+            if (offset == 0)
+                return color;
+
+            ToHsv(color, out var hue, out var saturation, out var value);
+
+            hue += offset;
+
+            while (hue > 360) hue -= 360;
+            while (hue < 0) hue += 360;
+
+            return FromHsv(hue, saturation, value);
+        }
+
+
+
+        /// <summary>
+        /// Returns a Luma coefficient for brightness of a color
+        /// </summary>
+        /// <param name="color">Color to be evaluated</param>
+        /// <returns>The brightness of the color. [0 = Dark, 255 = Bright]</returns>
+        public static byte GetColorBrightness(System.Drawing.Color color)
+        {
+            //Source: http://stackoverflow.com/a/12043228
+            return (byte)(0.2126 * color.R + 0.7152 * color.G + 0.0722 * color.B);
+        }
+
+        /// <summary>
+        /// Returns whether or not a color is considered to be dark, based on Luma coefficient
+        /// </summary>
+        /// <param name="color">Color to be evaluated</param>
+        /// <returns>Whether or not the color is dark</returns>
+        public static bool IsColorDark(System.Drawing.Color color)
+        {
+            //Source: http://stackoverflow.com/a/12043228
+            return GetColorBrightness(color) < 40;
+        }
+
+        public static System.Windows.Media.Color CloneMediaColor(System.Windows.Media.Color clr)
+        {
+            return System.Windows.Media.Color.FromArgb(clr.A, clr.R, clr.G, clr.B);
+        }
+
+        public static System.Drawing.Color CloneDrawingColor(System.Drawing.Color clr)
+        {
+            return System.Drawing.Color.FromArgb(clr.ToArgb());
+        }
+    }
+
+    public class ColorConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            return ColorUtils.DrawingColorToMediaColor((System.Drawing.Color)value);
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            return ColorUtils.MediaColorToDrawingColor((System.Windows.Media.Color)value);
+        }
+    }
+
+    /// <summary>
+    /// Converts between a RealColor and Media color so that the RealColor class can be used with the Xceed Color Picker
+    /// </summary>
+    public class RealColorConverter : IValueConverter {
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture) => ((RealColor)value).GetMediaColor();
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) => new RealColor((System.Windows.Media.Color)value);
+    }
+
+    public class BoolToColorConverter : IValueConverter
+    {
+        public static Tuple<Color, Color> TextWhiteRed = new Tuple<Color, Color>(Color.FromArgb(255, 186, 186, 186), Color.Red);
+
+        public static Tuple<Color, Color> TextRedWhite = new Tuple<Color, Color>(Color.Red, Color.FromArgb(255, 186, 186, 186));
+
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            bool b = (bool)value;
+            Tuple<Color, Color> clrs = parameter as Tuple<Color, Color> ?? TextWhiteRed;
+            Color clr = b ? clrs.Item1 : clrs.Item2;
+
+            return new System.Windows.Media.SolidColorBrush(ColorUtils.DrawingColorToMediaColor(clr));
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+    public class RealColor : ICloneable
+    {
+        [JsonProperty]
+        private System.Drawing.Color Color { get; set; }
+
+        public RealColor()
+        {
+            Color = Color.Transparent;
+        }
+
+        public RealColor(System.Windows.Media.Color clr)
+        {
+            this.SetMediaColor(clr);
+        }
+
+        public RealColor(System.Drawing.Color color)
+        {
+            this.Color = color.Clone();
+        }
+
+        public System.Drawing.Color GetDrawingColor()
+        {
+            return Color.Clone();
+        }
+
+        public System.Windows.Media.Color GetMediaColor()
+        {
+            return Color.ToMediaColor();
+        }
+
+        public void SetDrawingColor(System.Drawing.Color clr)
+        {
+            this.Color = clr.Clone();
+        }
+
+        public void SetMediaColor(System.Windows.Media.Color clr)
+        {
+            this.Color = clr.ToDrawingColor();
+        }
+
+        public object Clone()
+        {
+            return new RealColor(this.Color.Clone());
+        }
+
+        public static implicit operator System.Drawing.Color(RealColor c) => c.GetDrawingColor();
+        public static implicit operator System.Windows.Media.Color(RealColor c) => c.GetMediaColor();
+    }
+}
diff --git a/Project-Aurora/ColorBox/Utils/EffectBrush.cs b/Project-Aurora/ColorBox/Utils/EffectBrush.cs
new file mode 100644
index 000000000..839940de7
--- /dev/null
+++ b/Project-Aurora/ColorBox/Utils/EffectBrush.cs
@@ -0,0 +1,556 @@
+using ColorBox;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+
+namespace Aurora.EffectsEngine
+{
+    public abstract class EffectBrush : ICloneable
+    {
+
+        [JsonProperty("color_gradients")]
+        public SortedDictionary<float, System.Drawing.Color> ColorGradients = new SortedDictionary<float, System.Drawing.Color>();
+        public float SampleWindowSize = 1;
+
+        protected System.Drawing.Brush _drawingBrush = null;
+        protected System.Windows.Media.Brush _mediaBrush = null;
+
+        protected System.Windows.Media.GradientStopCollection GetGradientStopCollection()
+        {
+            System.Windows.Media.GradientStopCollection collection = new System.Windows.Media.GradientStopCollection();
+
+            foreach (var kvp in ColorGradients)
+            {
+                collection.Add(
+                    new System.Windows.Media.GradientStop(
+                        ColorUtils.DrawingColorToMediaColor(kvp.Value),
+                        kvp.Key)
+                    );
+            }
+            return collection;
+        }
+        public System.Windows.Media.Brush MediaBrush => GetMediaBrush();
+        protected void CheckColorGradients()
+        {
+            if (ColorGradients.Count > 0)
+            {
+                bool firstFound = false;
+                System.Drawing.Color first_color = new System.Drawing.Color();
+                System.Drawing.Color last_color = new System.Drawing.Color();
+
+                foreach (var kvp in ColorGradients)
+                {
+                    if (!firstFound)
+                    {
+                        first_color = kvp.Value;
+                        firstFound = true;
+                    }
+
+                    last_color = kvp.Value;
+                }
+
+                if (!ColorGradients.ContainsKey(0.0f))
+                    ColorGradients.Add(0.0f, first_color);
+
+                if (!ColorGradients.ContainsKey(1.0f))
+                    ColorGradients.Add(1.0f, last_color);
+            }
+            else
+            {
+                if (!ColorGradients.ContainsKey(0.0f))
+                    ColorGradients.Add(0.0f, System.Drawing.Color.Transparent);
+
+                if (!ColorGradients.ContainsKey(1.0f))
+                    ColorGradients.Add(1.0f, System.Drawing.Color.Transparent);
+            }
+        }
+        protected System.Drawing.Color GetColorAtShift(float shift)
+        {
+            float previousKey = 0;
+            foreach (var kvp in ColorGradients)
+            {
+                if (kvp.Key >= shift)
+                {
+                    return ColorUtils.BlendColors(ColorGradients[previousKey], kvp.Value, (shift - previousKey) / (kvp.Key - previousKey));
+                }
+                previousKey = kvp.Key;
+            }
+            return new System.Drawing.Color();
+        }
+
+        public abstract System.Drawing.Brush GetDrawingBrush(float shift = 0, float window_size = 0);
+
+        public abstract System.Windows.Media.Brush GetMediaBrush();
+
+        public virtual ColorSpectrum GetColorSpectrum()
+        {
+            ColorSpectrum spectrum = new ColorSpectrum();
+
+            foreach (var color in ColorGradients)
+                spectrum.SetColorAt(color.Key, color.Value);
+
+            return spectrum;
+        }
+
+        /// <summary>
+        /// Blends two EffectBrushes together by a specified amount
+        /// </summary>
+        /// <param name="otherBrush">The foreground EffectBrush (When percent is at 1.0D, only this EffectBrush is shown)</param>
+        /// <param name="percent">The blending percent value</param>
+        /// <returns>The blended EffectBrush</returns>
+        public abstract EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent);
+
+        public object Clone()
+        {
+            var clone = (EffectBrush)this.MemberwiseClone();
+            HandleCloned(clone);
+            return clone;
+        }
+        protected virtual void HandleCloned(EffectBrush clone)
+        {
+            //Nothing particular in the base class, but maybe useful for children.
+            //Not abstract so children may not implement this if they don't need to.
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((EffectBrush)obj);
+        }
+
+        public bool Equals(EffectBrush p)
+        {
+            if (ReferenceEquals(null, p)) return false;
+            if (ReferenceEquals(this, p)) return true;
+
+            return (SampleWindowSize == p.SampleWindowSize &&
+                ColorGradients.Equals(p.ColorGradients));
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+                hash = hash * 23 + SampleWindowSize.GetHashCode();
+                hash = hash * 23 + ColorGradients.GetHashCode();
+                return hash;
+            }
+        }
+    }
+    public class SolidEffectBrush : EffectBrush
+    {
+        public SolidEffectBrush()
+        {
+
+            ColorGradients.Add(0.0f, System.Drawing.Color.Red);
+            ColorGradients.Add(1.0f, System.Drawing.Color.Blue);
+        }
+
+        public SolidEffectBrush(EffectBrush otherBrush)
+        {
+            this.ColorGradients = otherBrush.ColorGradients;
+            this.SampleWindowSize = otherBrush.SampleWindowSize;
+        }
+        public SolidEffectBrush(ColorSpectrum spectrum)
+        {
+            foreach (var color in spectrum.GetSpectrumColors())
+                ColorGradients.Add(color.Key, color.Value);
+        }
+
+        public SolidEffectBrush(System.Windows.Media.SolidColorBrush brush)
+        {
+            ColorGradients.Add(0.0f, ColorUtils.MediaColorToDrawingColor(brush.Color));
+            ColorGradients.Add(1.0f, ColorUtils.MediaColorToDrawingColor(brush.Color));
+
+            CheckColorGradients();
+        }
+
+        public override System.Drawing.Brush GetDrawingBrush(float shift, float window_size)
+        {
+            if (true/*_drawingbrush == null*/)
+            {
+                _drawingBrush = new System.Drawing.SolidBrush(ColorGradients[0.0f]);
+            }
+            return _drawingBrush;
+        }
+        public override System.Windows.Media.Brush GetMediaBrush()
+        {
+            if (_mediaBrush == null)
+            {
+                System.Windows.Media.SolidColorBrush brush = new System.Windows.Media.SolidColorBrush(
+                    ColorUtils.DrawingColorToMediaColor(ColorGradients[0.0f])
+                    );
+                brush.Freeze();
+
+                _mediaBrush = brush;
+            }
+
+            return _mediaBrush;
+        }
+
+        public override ColorSpectrum GetColorSpectrum() => new ColorSpectrum(ColorGradients[0.0f]);
+
+
+        /// <summary>
+        /// Blends two EffectBrushes together by a specified amount
+        /// </summary>
+        /// <param name="otherBrush">The foreground EffectBrush (When percent is at 1.0D, only this EffectBrush is shown)</param>
+        /// <param name="percent">The blending percent value</param>
+        /// <returns>The blended EffectBrush</returns>
+        public override EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent)
+        {
+            if (percent <= 0.0)
+                return (EffectBrush)this.Clone();
+            else if (percent >= 1.0)
+                return (EffectBrush)otherBrush.Clone();
+
+            ColorSpectrum currentSpectrum = new ColorSpectrum(GetColorSpectrum());
+            ColorSpectrum newSpectrum = new ColorSpectrum(currentSpectrum).MultiplyByScalar(1.0 - percent);
+
+            foreach (var kvp in otherBrush.ColorGradients)
+            {
+                System.Drawing.Color bgColor = currentSpectrum.GetColorAt(kvp.Key);
+                System.Drawing.Color fgColor = kvp.Value;
+
+                newSpectrum.SetColorAt(kvp.Key, ColorUtils.BlendColors(bgColor, fgColor, percent));
+            }
+
+            EffectBrush returnBrush = new SolidEffectBrush(newSpectrum);
+            returnBrush.SampleWindowSize = SampleWindowSize * (float)(1.0 - percent) + otherBrush.SampleWindowSize * (float)percent;
+
+            return returnBrush;
+        }
+        
+    }
+    public class LinearEffectBrush : EffectBrush
+    {
+
+        public int Angle = 0;
+        public LinearEffectBrush()
+        {
+            ColorGradients.Add(0.0f, System.Drawing.Color.Red);
+            ColorGradients.Add(1.0f, System.Drawing.Color.Blue);
+        }
+
+        public LinearEffectBrush(EffectBrush otherBrush)
+        {
+            this.ColorGradients = otherBrush.ColorGradients;
+            this.SampleWindowSize = otherBrush.SampleWindowSize;
+            if (otherBrush is LinearEffectBrush otherLinearBrush)
+                this.Angle = otherLinearBrush.Angle;
+        }
+
+        public LinearEffectBrush(ColorSpectrum spectrum)
+        {
+            foreach (var color in spectrum.GetSpectrumColors())
+                ColorGradients.Add(color.Key, color.Value);
+
+            CheckColorGradients();
+        }
+
+        public LinearEffectBrush(System.Windows.Media.LinearGradientBrush brush)
+        {
+
+            foreach (var grad in brush.GradientStops)
+            {
+                if (!ColorGradients.ContainsKey((float)grad.Offset) && ((float)grad.Offset >= 0.0f && (float)grad.Offset <= 1.0f))
+                    ColorGradients.Add(
+                        (float)grad.Offset,
+                        ColorUtils.MediaColorToDrawingColor(grad.Color)
+                        );
+            }
+
+
+            CheckColorGradients();
+        }
+
+        public override System.Drawing.Brush GetDrawingBrush(float shift = 0, float window_size = 0)
+        {
+            if (true/*_drawingbrush == null*/)
+            {
+
+                if (SampleWindowSize == 0)
+                {
+                    _drawingBrush = new System.Drawing.SolidBrush(GetColorAtShift(shift));
+                }
+                else
+                {
+                    double angle = (Angle) / 360.0 * 2 * Math.PI;
+                    float sin = (float)Math.Sin(angle)/2; //* (1 / SampleWindowSize)/2;
+                    float cos = (float)Math.Cos(angle)/2;// * (1 / SampleWindowSize)/2;
+                    float move = shift;// + (float)(Math.Sin((Angle + 45) % 90 * 2 / 360.0 * 2 * Math.PI) * (Math.Sqrt(2) - 1)) * shift;
+
+                    System.Drawing.Drawing2D.LinearGradientBrush brush = new System.Drawing.Drawing2D.LinearGradientBrush(
+                        new System.Drawing.PointF(move * (1 / SampleWindowSize), move * (1 / SampleWindowSize)),
+                        new System.Drawing.PointF((move + cos) * (1 / SampleWindowSize), (move + sin) * (1 / SampleWindowSize)),
+                        System.Drawing.Color.Red,
+                        System.Drawing.Color.Red
+                        );
+
+                    List<System.Drawing.Color> brush_colors = new List<System.Drawing.Color>();
+                    List<float> brush_positions = new List<float>();
+
+                    foreach (var kvp in ColorGradients)
+                    {
+                        brush_positions.Add(kvp.Key);
+                        brush_colors.Add(kvp.Value);
+                    }
+
+                    System.Drawing.Drawing2D.ColorBlend color_blend = new System.Drawing.Drawing2D.ColorBlend();
+                    color_blend.Colors = brush_colors.ToArray();
+                    color_blend.Positions = brush_positions.ToArray();
+                    brush.InterpolationColors = color_blend;
+
+                    brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Tile;
+                    _drawingBrush = brush;
+                }
+            }
+
+            return _drawingBrush;
+        }
+        public override System.Windows.Media.Brush GetMediaBrush()
+        {
+            if (_mediaBrush == null)
+            {
+                //double angle = (Angle + 225) / 360.0 * 2 * Math.PI;
+                double angle = Angle / 360.0 * 2 * Math.PI;
+                double sin = Math.Sin(angle);// * ((Math.Sqrt(2) - 1) * Math.Abs(Math.Sin(angle * 2 / 360.0 * 2 * Math.PI)) + 1); //* (1 / SampleWindowSize)/2;
+                double cos = Math.Cos(angle);// * ((Math.Sqrt(2) - 1) * Math.Abs(Math.Sin((Angle) * 2 / 360.0 * 2 * Math.PI)) + 1);// * (1 / SampleWindowSize)/2;
+                double size =  (sin < cos? (1/sin+1)/2: (1/cos + 1) / 2);// 1/Math.Tan(angle);//Math.Sqrt(sin * sin + cos * cos);// Math.Abs(Math.Cos((Angle) * 2 / 360.0 * 2 * Math.PI))*2;
+                //double size = (sin > cos ? 2/(sin + sin* sin) : 2 / (cos + cos* cos));
+                System.Windows.Media.LinearGradientBrush brush = new System.Windows.Media.LinearGradientBrush(GetGradientStopCollection());
+                brush.StartPoint = new System.Windows.Point(0, 0);// phase + cos, phase + sin);
+                brush.EndPoint = new System.Windows.Point( cos , sin);
+
+                /*switch (wrap)
+                {
+                    case BrushWrap.None:
+                        brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Pad;
+                        break;
+                    case BrushWrap.Repeat:
+                        brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Repeat;
+                        break;
+                    case BrushWrap.Reflect:
+                        brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Reflect;
+                        break;
+                }*/
+                brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Repeat;
+
+                _mediaBrush = brush;
+            }
+
+            return _mediaBrush;
+        }
+
+        /// <summary>
+        /// Blends two EffectBrushes together by a specified amount
+        /// </summary>
+        /// <param name="otherBrush">The foreground EffectBrush (When percent is at 1.0D, only this EffectBrush is shown)</param>
+        /// <param name="percent">The blending percent value</param>
+        /// <returns>The blended EffectBrush</returns>
+        public override EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent)
+        {
+            if (percent <= 0.0)
+                return (EffectBrush)this.Clone();
+            else if (percent >= 1.0)
+                return (EffectBrush)otherBrush.Clone();
+
+            ColorSpectrum currentSpectrum = new ColorSpectrum(GetColorSpectrum());
+            ColorSpectrum newSpectrum = new ColorSpectrum(currentSpectrum).MultiplyByScalar(1.0 - percent);
+
+            foreach (var kvp in otherBrush.ColorGradients)
+            {
+                System.Drawing.Color bgColor = currentSpectrum.GetColorAt(kvp.Key);
+                System.Drawing.Color fgColor = kvp.Value;
+
+                newSpectrum.SetColorAt(kvp.Key, ColorUtils.BlendColors(bgColor, fgColor, percent));
+            }
+
+            EffectBrush returnBrush = new LinearEffectBrush(newSpectrum);
+            returnBrush.SampleWindowSize = SampleWindowSize * (float)(1.0 - percent) + otherBrush.SampleWindowSize * (float)percent;
+
+            return returnBrush;
+        }
+    }
+    public class RadialEffectBrush : EffectBrush
+    {
+        public System.Drawing.PointF Center = new System.Drawing.PointF(0.5f, 0.5f);
+        public RadialEffectBrush()
+        {
+
+            ColorGradients.Add(0.0f, System.Drawing.Color.Red);
+            ColorGradients.Add(1.0f, System.Drawing.Color.Blue);
+        }
+
+        public RadialEffectBrush(EffectBrush otherBrush)
+        {
+            this.ColorGradients = otherBrush.ColorGradients;
+            this.SampleWindowSize = otherBrush.SampleWindowSize;
+            if (otherBrush is RadialEffectBrush otherRadialBrush)
+                this.Center = otherRadialBrush.Center;
+
+        }
+
+        public RadialEffectBrush(ColorSpectrum spectrum)
+        {
+            foreach (var color in spectrum.GetSpectrumColors())
+                ColorGradients.Add(color.Key, color.Value);
+        }
+        public RadialEffectBrush(System.Windows.Media.RadialGradientBrush brush)
+        {
+
+            foreach (var grad in brush.GradientStops)
+            {
+                if (!ColorGradients.ContainsKey((float)grad.Offset) && ((float)grad.Offset >= 0.0f && (float)grad.Offset <= 1.0f))
+                    ColorGradients.Add(
+                        (float)grad.Offset,
+                        ColorUtils.MediaColorToDrawingColor(grad.Color)
+                        );
+            }
+
+            CheckColorGradients();
+        }
+        protected SortedDictionary<float, System.Drawing.Color> GetColorGradientsForWindow(float shift, float window_size, float starting_value = 0)
+        { 
+            SortedDictionary<float, System.Drawing.Color> gradients = new SortedDictionary<float, System.Drawing.Color>();
+            if (window_size == 0)
+            {
+                var color = GetColorAtShift(shift);
+                gradients[0] = color;
+                gradients[1] = color;
+                return gradients;
+            }
+           
+            float previousKey = 0;
+            foreach (var kvp in ColorGradients)
+            {
+                if (kvp.Key >= shift)
+                {
+                    if (gradients.Count == 0 && kvp.Key != 0)
+                    {
+                        gradients[starting_value / window_size] = ColorUtils.BlendColors(ColorGradients[previousKey], kvp.Value, (shift - previousKey) / (kvp.Key - previousKey));
+                    }
+
+                    float index = (starting_value + kvp.Key - shift) / window_size;
+                    if (kvp.Key <= shift + window_size - starting_value && index <= 1)
+                    {
+                        gradients[index] = kvp.Value;
+                    }
+                    else
+                    {
+                        gradients[1] = ColorUtils.BlendColors(ColorGradients[previousKey], kvp.Value, (shift + window_size - starting_value - previousKey) / (kvp.Key - previousKey));
+                        return gradients;
+                    }
+
+                    if (kvp.Key == 1)
+                    {
+                        /*if(window_size - (1 - shift) <= 0.05f)
+                        {
+                            gradients[1] = ColorUtils.BlendColors(kvp.Value, colorGradients[0], window_size - (1 - shift) / 0.05f);
+                            return gradients;
+                        }*/
+                        foreach (var gradient in GetColorGradientsForWindow(0, window_size, (1 - shift)))
+                        {
+                            gradients[gradient.Key] = gradient.Value;
+                        }
+                    }
+                }
+                previousKey = kvp.Key;
+            }
+            return gradients;
+        }
+        public override System.Drawing.Brush GetDrawingBrush(float shift, float window_size)
+        {
+            if (true/*_drawingbrush == null*/)
+            {
+                System.Drawing.Drawing2D.GraphicsPath g_path = new System.Drawing.Drawing2D.GraphicsPath();
+                g_path.AddEllipse(new System.Drawing.RectangleF(-(float)(Math.Sqrt(2) - 1), -(float)(Math.Sqrt(2) - 1), 2f, 2f));
+
+                System.Drawing.Drawing2D.PathGradientBrush brush = new System.Drawing.Drawing2D.PathGradientBrush(
+                    g_path
+                    );
+
+                List<System.Drawing.Color> brush_colors = new List<System.Drawing.Color>();
+                List<float> brush_positions = new List<float>();
+
+                foreach (var kvp in GetColorGradientsForWindow(Math.Abs(shift), SampleWindowSize))
+                {
+                    if (shift < 0)
+                        brush_positions.Add(1.0f - kvp.Key);
+                    else
+                        brush_positions.Add(kvp.Key);
+                    brush_colors.Add(kvp.Value);
+                }
+
+                if (shift < 0)
+                {
+                    brush_colors.Reverse();
+                    brush_positions.Reverse();
+                }
+
+                brush.CenterPoint = Center;
+
+                System.Drawing.Drawing2D.ColorBlend color_blend = new System.Drawing.Drawing2D.ColorBlend();
+                color_blend.Colors = brush_colors.ToArray();
+                color_blend.Positions = brush_positions.ToArray();
+                brush.InterpolationColors = color_blend;
+
+                _drawingBrush = brush;
+            }
+
+            return _drawingBrush;
+        }
+        public override System.Windows.Media.Brush GetMediaBrush()
+        {
+            if (_mediaBrush == null)
+            {
+
+                System.Windows.Media.RadialGradientBrush brush = new System.Windows.Media.RadialGradientBrush(GetGradientStopCollection());
+                brush.Center = new System.Windows.Point(Center.X, Center.Y);
+                brush.RadiusX = 0.5;
+                brush.RadiusY = 0.5;
+                //brush.
+
+                brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Pad;
+                _mediaBrush = brush;
+            }
+
+            return _mediaBrush;
+        }
+
+        /// <summary>
+        /// Blends two EffectBrushes together by a specified amount
+        /// </summary>
+        /// <param name="otherBrush">The foreground EffectBrush (When percent is at 1.0D, only this EffectBrush is shown)</param>
+        /// <param name="percent">The blending percent value</param>
+        /// <returns>The blended EffectBrush</returns>
+        public override EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent)
+        {
+            if (percent <= 0.0)
+                return (EffectBrush)this.Clone();
+            else if (percent >= 1.0)
+                return (EffectBrush)otherBrush.Clone();
+
+            ColorSpectrum currentSpectrum = new ColorSpectrum(GetColorSpectrum());
+            ColorSpectrum newSpectrum = new ColorSpectrum(currentSpectrum).MultiplyByScalar(1.0 - percent);
+
+            foreach (var kvp in otherBrush.ColorGradients)
+            {
+                System.Drawing.Color bgColor = currentSpectrum.GetColorAt(kvp.Key);
+                System.Drawing.Color fgColor = kvp.Value;
+
+                newSpectrum.SetColorAt(kvp.Key, ColorUtils.BlendColors(bgColor, fgColor, percent));
+            }
+
+            EffectBrush returnBrush = new RadialEffectBrush(newSpectrum);
+            returnBrush.SampleWindowSize = SampleWindowSize * (float)(1.0 - percent) + otherBrush.SampleWindowSize * (float)percent;
+
+            return returnBrush;
+        }
+    }
+}
diff --git a/Project-Aurora/ColorBox/packages.config b/Project-Aurora/ColorBox/packages.config
new file mode 100644
index 000000000..0fa4e0151
--- /dev/null
+++ b/Project-Aurora/ColorBox/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Newtonsoft.Json" version="12.0.3" targetFramework="net40" />
+</packages>
\ No newline at end of file
diff --git a/Project-Aurora/Project-Aurora/Controls/Control_FieldPresenter.xaml.cs b/Project-Aurora/Project-Aurora/Controls/Control_FieldPresenter.xaml.cs
index d6132e83c..4cb2a4301 100644
--- a/Project-Aurora/Project-Aurora/Controls/Control_FieldPresenter.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Controls/Control_FieldPresenter.xaml.cs
@@ -86,7 +86,7 @@ public object Value {
 
             // Gradient colour
             { typeof(Settings.LayerEffectConfig), bind => new Control_GradientEditor((Settings.LayerEffectConfig)((Control_FieldPresenter)bind.Source).Value) },
-            { typeof(EffectsEngine.EffectBrush), bind => new ColorBox.ColorBox().SetBindingChain(ColorBox.ColorBox.BrushProperty, bind, new EffectBrushToBrushConverter(), BindingMode.TwoWay) },
+            { typeof(EffectsEngine.EffectBrush), bind => new ColorBox.ColorBox().SetBindingChain(ColorBox.ColorBox.BrushProperty, bind, bindingMode: BindingMode.TwoWay) },
 
             // KeySequences
             { typeof(Settings.KeySequence), bind => new Controls.KeySequence {
diff --git a/Project-Aurora/Project-Aurora/Controls/Control_GradientEditor.xaml b/Project-Aurora/Project-Aurora/Controls/Control_GradientEditor.xaml
index 302f2274e..8ae32b437 100644
--- a/Project-Aurora/Project-Aurora/Controls/Control_GradientEditor.xaml
+++ b/Project-Aurora/Project-Aurora/Controls/Control_GradientEditor.xaml
@@ -9,10 +9,7 @@
              xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"
              mc:Ignorable="d" 
              d:DesignHeight="160" d:DesignWidth="240">
-    <UserControl.Resources>
-        <utils:EffectBrushToBrushConverter x:Key="BrushConverter" />
-    </UserControl.Resources>
-    
+
     <Grid>
         <Grid.RowDefinitions>
             <RowDefinition Height="Auto" />
@@ -29,7 +26,7 @@
 
 
         <Label Content="Brush:" Grid.Row="0" HorizontalAlignment="Right" />
-        <ncore:ColorBox Grid.Row="0" Grid.Column="1" Brush="{Binding Brush, Converter={StaticResource BrushConverter}, Mode=TwoWay}" />
+        <ncore:ColorBox Grid.Row="0" Grid.Column="1" Brush="{Binding Brush, Mode=TwoWay}" />
 
         <Label Content="Speed:" Grid.Row="2" HorizontalAlignment="Right" />
         <xctk:SingleUpDown Grid.Row="1" Grid.Column="1" Value="{Binding Speed}" Margin="0,2" />
diff --git a/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml.cs b/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml.cs
index be68247d3..04267c2ad 100644
--- a/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Controls/EffectSettingsWindow.xaml.cs
@@ -27,17 +27,9 @@ public EffectSettingsWindow()
             this.effect_speed_slider.Value = EffectConfig.speed;
             this.effect_speed_label.Text = "x " + EffectConfig.speed;
             this.effect_angle.Text = EffectConfig.angle.ToString();
-            Brush brush = EffectConfig.brush.GetMediaBrush();
-            try
-            {
-                this.gradient_editor.Brush = brush;
-            }
-            catch (Exception exc)
-            {
-                Global.logger.Error("Could not set brush, exception: " + exc);
 
-                //this.gradient_editor.Brush = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromArgb(255, 255, 0, 0));
-            }
+            this.gradient_editor.Brush = EffectConfig.brush;
+
 
             this.gradient_editor.BrushChanged += Gradient_editor_BrushChanged;
         }
@@ -53,24 +45,14 @@ public EffectSettingsWindow(LayerEffectConfig EffectConfig)
             this.effect_speed_label.Text = "x " + EffectConfig.speed;
             this.effect_angle.Text = EffectConfig.angle.ToString();
             this.effect_animation_reversed.IsChecked = EffectConfig.animation_reverse;
-            Brush brush = EffectConfig.brush.GetMediaBrush();
-            try
-            {
-                this.gradient_editor.Brush = brush;
-            }
-            catch(Exception exc)
-            {
-                Global.logger.Error("Could not set brush, exception: " + exc);
-
-                //this.gradient_editor.Brush = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromArgb(255, 255, 0, 0));
-            }
+            this.gradient_editor.Brush = EffectConfig.brush;
 
             this.gradient_editor.BrushChanged += Gradient_editor_BrushChanged;
         }
 
         private void Gradient_editor_BrushChanged(object sender, ColorBox.BrushChangedEventArgs e)
         {
-            EffectConfig.brush = EffectsEngine.EffectBrush.GetEffectBrush(this.gradient_editor.Brush);
+            EffectConfig.brush = this.gradient_editor.Brush;
         }
 
         private void FireEffectConfigUpdated()
@@ -114,7 +96,7 @@ private void secondary_color_SelectedColorChanged(object sender, RoutedPropertyC
 
         private void accept_button_Click(object sender, RoutedEventArgs e)
         {
-            EffectConfig.brush = EffectsEngine.EffectBrush.GetEffectBrush(this.gradient_editor.Brush);
+            EffectConfig.brush = this.gradient_editor.Brush;
             FireEffectConfigUpdated();
             Close();
         }
diff --git a/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationFilledGradientRectangle.cs b/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationFilledGradientRectangle.cs
index e70e54e63..09f9b461b 100644
--- a/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationFilledGradientRectangle.cs
+++ b/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationFilledGradientRectangle.cs
@@ -38,8 +38,6 @@ public AnimationFilledGradientRectangle(float x, float y, float rect_width, floa
             PointF rotatePoint = new PointF(_scaledDimension.X, _scaledDimension.Y);
 
             EffectBrush _newbrush = (EffectBrush)_gradientBrush.Clone();
-            _newbrush.start = new PointF(_newbrush.start.X * scale, _newbrush.start.Y * scale);
-            _newbrush.end = new PointF(_newbrush.end.X * scale, _newbrush.end.Y * scale);
 
             Matrix rotationMatrix = new Matrix();
             rotationMatrix.RotateAt(-_angle, rotatePoint, MatrixOrder.Append);
diff --git a/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationGradientCircle.cs b/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationGradientCircle.cs
index 031e57fdf..8e3d35b62 100644
--- a/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationGradientCircle.cs
+++ b/Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationGradientCircle.cs
@@ -42,13 +42,10 @@ public AnimationGradientCircle(float x, float y, float radius, EffectBrush brush
             _scaledDimension.Offset(offset);
 
             EffectBrush _newbrush = new RadialEffectBrush(_gradientBrush);
-            _newbrush.start = new PointF(0.0f, 0.0f);
-            _newbrush.end = new PointF(1.0f, 1.0f);
-            _newbrush.center = new PointF(0.5f, 0.5f);
 
             SortedDictionary<float, System.Drawing.Color> newColorGradients = new SortedDictionary<float, System.Drawing.Color>();
-            ColorSpectrum spectrum = _newbrush.GetColorSpectrum();
-            var colors = _newbrush.colorGradients;
+            ColorBox.ColorSpectrum spectrum = _newbrush.GetColorSpectrum();
+            var colors = _newbrush.ColorGradients;
 
             float _cutOffPoint = _width / _radius;
 
@@ -62,7 +59,7 @@ public AnimationGradientCircle(float x, float y, float radius, EffectBrush brush
                 newColorGradients.Add(_cutOffPoint - 0.0001f, Color.Transparent);
                 newColorGradients.Add(0.0f, Color.Transparent);
 
-                _newbrush.colorGradients = newColorGradients;
+                _newbrush.ColorGradients = newColorGradients;
             }
             else if (_cutOffPoint > 1.0f)
             {
diff --git a/Project-Aurora/Project-Aurora/EffectsEngine/EffectBrush.cs b/Project-Aurora/Project-Aurora/EffectsEngine/EffectBrush.cs
deleted file mode 100644
index 9ff5c45c4..000000000
--- a/Project-Aurora/Project-Aurora/EffectsEngine/EffectBrush.cs
+++ /dev/null
@@ -1,943 +0,0 @@
-using Aurora.Utils;
-using Newtonsoft.Json;
-using System;
-using System.Collections.Generic;
-
-namespace Aurora.EffectsEngine
-{
-    public abstract class EffectBrush : ICloneable
-    {
-
-        public enum BrushWrap
-        {
-            None,
-            Repeat,
-            Reflect
-        };
-
-        public BrushWrap wrap = BrushWrap.None;
-        [JsonProperty("color_gradients")]
-        public SortedDictionary<float, System.Drawing.Color> colorGradients = new SortedDictionary<float, System.Drawing.Color>();
-        public System.Drawing.PointF start;
-        public System.Drawing.PointF end;
-        public System.Drawing.PointF center;
-
-        protected System.Drawing.Brush _drawingBrush = null;
-        protected System.Windows.Media.Brush _mediaBrush = null;
-
-        public static EffectBrush GetEffectBrush(System.Drawing.Brush brush)
-        {
-            if (brush is System.Drawing.SolidBrush solidBrush)
-            {
-                return new SolidEffectBrush(solidBrush);
-            }
-            else if (brush is System.Drawing.Drawing2D.LinearGradientBrush linearBrush)
-            {
-                return new LinearEffectBrush(linearBrush);
-            }
-            else if (brush is System.Drawing.Drawing2D.PathGradientBrush radialBrush)
-            {
-                return new RadialEffectBrush(radialBrush);
-            }
-            return new SolidEffectBrush(brush as System.Drawing.SolidBrush);
-        }
-        public static EffectBrush GetEffectBrush(System.Windows.Media.Brush brush)
-        {
-            if (brush is System.Windows.Media.SolidColorBrush solidBrush)
-            {
-                return new SolidEffectBrush(solidBrush);
-            }
-            else if (brush is System.Windows.Media.LinearGradientBrush linearBrush)
-            {
-                return new LinearEffectBrush(linearBrush);
-            }
-            else if (brush is System.Windows.Media.RadialGradientBrush radialBrush)
-            {
-                return new RadialEffectBrush(radialBrush);
-            }
-            return new SolidEffectBrush(brush as System.Windows.Media.SolidColorBrush);
-        }
-
-        public EffectBrush SetWrap(BrushWrap wrap)
-        {
-            this.wrap = wrap;
-            return this;
-        }
-        protected void CheckColorGradients()
-        {
-            if (colorGradients.Count > 0)
-            {
-                bool firstFound = false;
-                System.Drawing.Color first_color = new System.Drawing.Color();
-                System.Drawing.Color last_color = new System.Drawing.Color();
-
-                foreach (var kvp in colorGradients)
-                {
-                    if (!firstFound)
-                    {
-                        first_color = kvp.Value;
-                        firstFound = true;
-                    }
-
-                    last_color = kvp.Value;
-                }
-
-                if (!colorGradients.ContainsKey(0.0f))
-                    colorGradients.Add(0.0f, first_color);
-
-                if (!colorGradients.ContainsKey(1.0f))
-                    colorGradients.Add(1.0f, last_color);
-            }
-            else
-            {
-                if (!colorGradients.ContainsKey(0.0f))
-                    colorGradients.Add(0.0f, System.Drawing.Color.Transparent);
-
-                if (!colorGradients.ContainsKey(1.0f))
-                    colorGradients.Add(1.0f, System.Drawing.Color.Transparent);
-            }
-        }
-        protected SortedDictionary<float, System.Drawing.Color> GetColorGradientsForWindow(float shift, float window_size, float starting_value = 0)
-        {
-            SortedDictionary<float, System.Drawing.Color> gradients = new SortedDictionary<float, System.Drawing.Color>();
-            float previousKey = 0;
-            foreach (var kvp in colorGradients)
-            {
-                if (kvp.Key >= shift)
-                {
-                    if (gradients.Count == 0 && kvp.Key != 0)
-                    {
-                        gradients[starting_value] = Utils.ColorUtils.BlendColors(colorGradients[previousKey], kvp.Value, (shift - previousKey) / (kvp.Key - previousKey));
-                    }
-
-                    float index = starting_value + (kvp.Key - shift) / window_size;
-                    if (kvp.Key <= shift + window_size && index <= 1)
-                    {
-                        gradients[index] = kvp.Value;
-                    }
-                    else
-                    {
-                        gradients[1] = Utils.ColorUtils.BlendColors(colorGradients[previousKey], kvp.Value, (shift + window_size - previousKey) / (kvp.Key - previousKey));
-                        return gradients;
-                    }
-
-                    if (kvp.Key == 1)
-                    {
-                        foreach (var gradient in GetColorGradientsForWindow(0, window_size + shift - previousKey, starting_value + (1 - shift) / window_size))
-                        {
-                            gradients[gradient.Key] = gradient.Value;
-                        }
-                    }
-                }
-                previousKey = kvp.Key;
-            }
-            return gradients;
-        }
-        public abstract System.Drawing.Brush GetDrawingBrush();
-        public abstract System.Drawing.Brush GetDrawingBrush(float shift, float window_size);
-
-        public abstract System.Windows.Media.Brush GetMediaBrush();
-
-        public abstract ColorSpectrum GetColorSpectrum();
-
-        /// <summary>
-        /// Blends two EffectBrushes together by a specified amount
-        /// </summary>
-        /// <param name="otherBrush">The foreground EffectBrush (When percent is at 1.0D, only this EffectBrush is shown)</param>
-        /// <param name="percent">The blending percent value</param>
-        /// <returns>The blended EffectBrush</returns>
-        public abstract EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent);
-
-        public object Clone()
-        {
-            var clone = (EffectBrush)this.MemberwiseClone();
-            HandleCloned(clone);
-            return clone;
-        }
-        protected virtual void HandleCloned(EffectBrush clone)
-        {
-            //Nothing particular in the base class, but maybe useful for children.
-            //Not abstract so children may not implement this if they don't need to.
-        }
-
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj)) return false;
-            if (ReferenceEquals(this, obj)) return true;
-            if (obj.GetType() != this.GetType()) return false;
-            return Equals((EffectBrush)obj);
-        }
-
-        public bool Equals(EffectBrush p)
-        {
-            if (ReferenceEquals(null, p)) return false;
-            if (ReferenceEquals(this, p)) return true;
-
-            return (wrap == p.wrap &&
-                colorGradients.Equals(p.colorGradients) &&
-                start.Equals(p.start) &&
-                end.Equals(p.end) &&
-                center.Equals(p.center));
-        }
-
-        public override int GetHashCode()
-        {
-            unchecked
-            {
-                int hash = 17;
-                hash = hash * 23 + wrap.GetHashCode();
-                hash = hash * 23 + colorGradients.GetHashCode();
-                hash = hash * 23 + start.GetHashCode();
-                hash = hash * 23 + end.GetHashCode();
-                hash = hash * 23 + center.GetHashCode();
-                return hash;
-            }
-        }
-    }
-    public class SolidEffectBrush : EffectBrush
-    {
-        public SolidEffectBrush()
-        {
-
-            colorGradients.Add(0.0f, System.Drawing.Color.Red);
-            colorGradients.Add(1.0f, System.Drawing.Color.Blue);
-
-            start = new System.Drawing.PointF(0, 0);
-            end = new System.Drawing.PointF(1, 0);
-            center = new System.Drawing.PointF(0.0f, 0.0f);
-        }
-
-        public SolidEffectBrush(EffectBrush otherBrush)
-        {
-            this.wrap = otherBrush.wrap;
-            this.colorGradients = otherBrush.colorGradients;
-            this.start = otherBrush.start;
-            this.end = otherBrush.end;
-            this.center = otherBrush.center;
-        }
-        public SolidEffectBrush(ColorSpectrum spectrum)
-        {
-            foreach (var color in spectrum.GetSpectrumColors())
-                colorGradients.Add(color.Key, color.Value);
-
-            start = new System.Drawing.PointF(0, 0);
-            end = new System.Drawing.PointF(1, 0);
-            center = new System.Drawing.PointF(0.0f, 0.0f);
-        }
-
-
-        public SolidEffectBrush(System.Drawing.SolidBrush brush)
-        {
-
-            colorGradients.Add(0.0f, brush.Color);
-            colorGradients.Add(1.0f, brush.Color);
-
-            wrap = BrushWrap.Repeat;
-
-            CheckColorGradients();
-
-        }
-
-        public SolidEffectBrush(System.Windows.Media.SolidColorBrush brush)
-        {
-            wrap = BrushWrap.Repeat;
-
-            colorGradients.Add(0.0f, Utils.ColorUtils.MediaColorToDrawingColor(brush.Color));
-            colorGradients.Add(1.0f, Utils.ColorUtils.MediaColorToDrawingColor(brush.Color));
-
-            CheckColorGradients();
-        }
-        public override System.Drawing.Brush GetDrawingBrush()
-        {
-            if (true/*_drawingbrush == null*/)
-            {
-                    _drawingBrush = new System.Drawing.SolidBrush(colorGradients[0.0f]);
-
-            }
-
-            return _drawingBrush;
-        }
-
-        public override System.Drawing.Brush GetDrawingBrush(float shift, float window_size)
-        {
-            if (true/*_drawingbrush == null*/)
-            {
-                    _drawingBrush = new System.Drawing.SolidBrush(colorGradients[0.0f]);
-     
-            }
-
-            return _drawingBrush;
-        }
-        public override System.Windows.Media.Brush GetMediaBrush()
-        {
-            if (_mediaBrush == null)
-            {
-                    System.Windows.Media.SolidColorBrush brush = new System.Windows.Media.SolidColorBrush(
-                        Utils.ColorUtils.DrawingColorToMediaColor(colorGradients[0.0f])
-                        );
-                    brush.Freeze();
-
-                    _mediaBrush = brush;
-            }
-
-            return _mediaBrush;
-        }
-
-        public override ColorSpectrum GetColorSpectrum() => new ColorSpectrum(colorGradients[0.0f]);
-
-
-        /// <summary>
-        /// Blends two EffectBrushes together by a specified amount
-        /// </summary>
-        /// <param name="otherBrush">The foreground EffectBrush (When percent is at 1.0D, only this EffectBrush is shown)</param>
-        /// <param name="percent">The blending percent value</param>
-        /// <returns>The blended EffectBrush</returns>
-        public override EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent)
-        {
-            if (percent <= 0.0)
-                return (EffectBrush)this.Clone();
-            else if (percent >= 1.0)
-                return (EffectBrush)otherBrush.Clone();
-
-            ColorSpectrum currentSpectrum = new ColorSpectrum(GetColorSpectrum());
-            ColorSpectrum newSpectrum = new ColorSpectrum(currentSpectrum).MultiplyByScalar(1.0 - percent);
-
-            foreach (var kvp in otherBrush.colorGradients)
-            {
-                System.Drawing.Color bgColor = currentSpectrum.GetColorAt(kvp.Key);
-                System.Drawing.Color fgColor = kvp.Value;
-
-                newSpectrum.SetColorAt(kvp.Key, Utils.ColorUtils.BlendColors(bgColor, fgColor, percent));
-            }
-
-            EffectBrush returnBrush = new SolidEffectBrush(newSpectrum);
-            returnBrush.wrap = wrap;
-
-            returnBrush.start = new System.Drawing.PointF((float)(start.X * (1.0 - percent) + otherBrush.start.X * (percent)), (float)(start.Y * (1.0 - percent) + otherBrush.start.Y * (percent)));
-            returnBrush.end = new System.Drawing.PointF((float)(end.X * (1.0 - percent) + otherBrush.end.X * (percent)), (float)(end.Y * (1.0 - percent) + otherBrush.end.Y * (percent)));
-            returnBrush.center = new System.Drawing.PointF((float)(center.X * (1.0 - percent) + otherBrush.center.X * (percent)), (float)(center.Y * (1.0 - percent) + otherBrush.center.Y * (percent)));
-
-            return returnBrush;
-        }
-        
-    }
-    public class LinearEffectBrush : EffectBrush
-    {
-        public LinearEffectBrush()
-        {
-            colorGradients.Add(0.0f, System.Drawing.Color.Red);
-            colorGradients.Add(1.0f, System.Drawing.Color.Blue);
-
-            start = new System.Drawing.PointF(0, 0);
-            end = new System.Drawing.PointF(1, 0);
-            center = new System.Drawing.PointF(0.0f, 0.0f);
-        }
-
-        public LinearEffectBrush(EffectBrush otherBrush)
-        {
-            this.wrap = otherBrush.wrap;
-            this.colorGradients = otherBrush.colorGradients;
-            this.start = otherBrush.start;
-            this.end = otherBrush.end;
-            this.center = otherBrush.center;
-        }
-
-        public LinearEffectBrush(ColorSpectrum spectrum)
-        {
-            foreach (var color in spectrum.GetSpectrumColors())
-                colorGradients.Add(color.Key, color.Value);
-
-            start = new System.Drawing.PointF(0, 0);
-            end = new System.Drawing.PointF(1, 0);
-            center = new System.Drawing.PointF(0.0f, 0.0f);
-        }
-
-        public LinearEffectBrush(System.Drawing.Drawing2D.LinearGradientBrush brush)
-        {
-            start = brush.Rectangle.Location;
-            end = new System.Drawing.PointF(brush.Rectangle.Width, brush.Rectangle.Height);
-            center = new System.Drawing.PointF(0.0f, 0.0f);
-
-            switch (brush.WrapMode)
-            {
-                case (System.Drawing.Drawing2D.WrapMode.Clamp):
-                    wrap = BrushWrap.None;
-                    break;
-                case (System.Drawing.Drawing2D.WrapMode.Tile):
-                    wrap = BrushWrap.Repeat;
-                    break;
-                case (System.Drawing.Drawing2D.WrapMode.TileFlipXY):
-                    wrap = BrushWrap.Reflect;
-                    break;
-            }
-
-            try
-            {
-                if (brush.InterpolationColors != null && brush.InterpolationColors.Colors.Length == brush.InterpolationColors.Positions.Length)
-                {
-                    for (int x = 0; x < brush.InterpolationColors.Colors.Length; x++)
-                    {
-                        if (!colorGradients.ContainsKey(brush.InterpolationColors.Positions[x]) && (brush.InterpolationColors.Positions[x] >= 0.0f && brush.InterpolationColors.Positions[x] <= 1.0f))
-                            colorGradients.Add(
-                                brush.InterpolationColors.Positions[x],
-                                brush.InterpolationColors.Colors[x]
-                                );
-                    }
-                }
-            }
-            catch (Exception exc)
-            {
-                colorGradients.Clear();
-
-                for (int x = 0; x < brush.LinearColors.Length; x++)
-                {
-                    float pos = x / (float)(brush.LinearColors.Length - 1);
-
-                    if (!colorGradients.ContainsKey(pos))
-                        colorGradients.Add(
-                            pos,
-                            brush.LinearColors[x]
-                            );
-                }
-            }
-
-
-            CheckColorGradients();
-
-
-        }
-
-        public LinearEffectBrush(System.Windows.Media.LinearGradientBrush brush)
-        {
-
-                start = new System.Drawing.PointF((float)brush.StartPoint.X, (float)brush.StartPoint.Y);
-                end = new System.Drawing.PointF((float)brush.EndPoint.X, (float)brush.EndPoint.Y);
-                center = new System.Drawing.PointF(0.0f, 0.0f);
-
-                switch (brush.SpreadMethod)
-                {
-                    case (System.Windows.Media.GradientSpreadMethod.Pad):
-                        wrap = BrushWrap.None;
-                        break;
-                    case (System.Windows.Media.GradientSpreadMethod.Repeat):
-                        wrap = BrushWrap.Repeat;
-                        break;
-                    case (System.Windows.Media.GradientSpreadMethod.Reflect):
-                        wrap = BrushWrap.Reflect;
-                        break;
-                }
-
-                foreach (var grad in brush.GradientStops)
-                {
-                    if (!colorGradients.ContainsKey((float)grad.Offset) && ((float)grad.Offset >= 0.0f && (float)grad.Offset <= 1.0f))
-                        colorGradients.Add(
-                            (float)grad.Offset,
-                            Utils.ColorUtils.MediaColorToDrawingColor(grad.Color)
-                            );
-                }
-
-
-            CheckColorGradients();
-        }
-        public override System.Drawing.Brush GetDrawingBrush()
-        {
-            if (true/*_drawingbrush == null*/)
-            {
-                    System.Drawing.Drawing2D.LinearGradientBrush brush = new System.Drawing.Drawing2D.LinearGradientBrush(
-                        start,
-                        end,
-                        System.Drawing.Color.Red,
-                        System.Drawing.Color.Red
-                        );
-
-                    List<System.Drawing.Color> brush_colors = new List<System.Drawing.Color>();
-                    List<float> brush_positions = new List<float>();
-
-                    foreach (var kvp in colorGradients)
-                    {
-                        brush_positions.Add(kvp.Key);
-                        brush_colors.Add(kvp.Value);
-                    }
-
-                    System.Drawing.Drawing2D.ColorBlend color_blend = new System.Drawing.Drawing2D.ColorBlend();
-                    color_blend.Colors = brush_colors.ToArray();
-                    color_blend.Positions = brush_positions.ToArray();
-                    brush.InterpolationColors = color_blend;
-
-                    switch (wrap)
-                    {
-                        //case BrushWrap.None:
-                        //    brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
-                        //    break;
-                        case BrushWrap.Repeat:
-                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Tile;
-                            break;
-                        case BrushWrap.Reflect:
-                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.TileFlipXY;
-                            break;
-                    }
-
-                    _drawingBrush = brush;
-
-            }
-
-            return _drawingBrush;
-        }
-
-        public override System.Drawing.Brush GetDrawingBrush(float shift, float window_size)
-        {
-            if (true/*_drawingbrush == null*/)
-            {
-
-                    System.Drawing.Drawing2D.LinearGradientBrush brush = new System.Drawing.Drawing2D.LinearGradientBrush(
-                        start,
-                        new System.Drawing.PointF(100 / window_size, 0),
-                        System.Drawing.Color.Red,
-                        System.Drawing.Color.Red
-                        );
-
-                    List<System.Drawing.Color> brush_colors = new List<System.Drawing.Color>();
-                    List<float> brush_positions = new List<float>();
-
-                    foreach (var kvp in colorGradients)
-                    {
-                        brush_positions.Add(kvp.Key);
-                        brush_colors.Add(kvp.Value);
-                    }
-
-                    System.Drawing.Drawing2D.ColorBlend color_blend = new System.Drawing.Drawing2D.ColorBlend();
-                    color_blend.Colors = brush_colors.ToArray();
-                    color_blend.Positions = brush_positions.ToArray();
-                    brush.InterpolationColors = color_blend;
-
-                    switch (wrap)
-                    {
-                        //case BrushWrap.None:
-                        //    brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
-                        //    break;
-                        case BrushWrap.Repeat:
-                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Tile;
-                            break;
-                        case BrushWrap.Reflect:
-                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.TileFlipXY;
-                            break;
-                    }
-
-                    _drawingBrush = brush;
-               
-            }
-
-            return _drawingBrush;
-        }
-        public override System.Windows.Media.Brush GetMediaBrush()
-        {
-            if (_mediaBrush == null)
-            {
-                System.Windows.Media.GradientStopCollection collection = new System.Windows.Media.GradientStopCollection();
-
-                foreach (var kvp in colorGradients)
-                {
-                    collection.Add(
-                        new System.Windows.Media.GradientStop(
-                            Utils.ColorUtils.DrawingColorToMediaColor(kvp.Value),
-                            kvp.Key)
-                        );
-                }
-
-                System.Windows.Media.LinearGradientBrush brush = new System.Windows.Media.LinearGradientBrush(collection);
-                brush.StartPoint = new System.Windows.Point(start.X, start.Y);
-                brush.EndPoint = new System.Windows.Point(end.X, end.Y);
-
-                switch (wrap)
-                {
-                    case BrushWrap.None:
-                        brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Pad;
-                        break;
-                    case BrushWrap.Repeat:
-                        brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Repeat;
-                        break;
-                    case BrushWrap.Reflect:
-                        brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Reflect;
-                        break;
-                }
-
-                _mediaBrush = brush;
-            }
-
-            return _mediaBrush;
-        }
-
-        public override ColorSpectrum GetColorSpectrum()
-        {
-            ColorSpectrum spectrum = new ColorSpectrum();
-            foreach (var color in colorGradients)
-                spectrum.SetColorAt(color.Key, color.Value);
-
-
-            return spectrum;
-        }
-
-        /// <summary>
-        /// Blends two EffectBrushes together by a specified amount
-        /// </summary>
-        /// <param name="otherBrush">The foreground EffectBrush (When percent is at 1.0D, only this EffectBrush is shown)</param>
-        /// <param name="percent">The blending percent value</param>
-        /// <returns>The blended EffectBrush</returns>
-        public override EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent)
-        {
-            if (percent <= 0.0)
-                return (EffectBrush)this.Clone();
-            else if (percent >= 1.0)
-                return (EffectBrush)otherBrush.Clone();
-
-            ColorSpectrum currentSpectrum = new ColorSpectrum(GetColorSpectrum());
-            ColorSpectrum newSpectrum = new ColorSpectrum(currentSpectrum).MultiplyByScalar(1.0 - percent);
-
-            foreach (var kvp in otherBrush.colorGradients)
-            {
-                System.Drawing.Color bgColor = currentSpectrum.GetColorAt(kvp.Key);
-                System.Drawing.Color fgColor = kvp.Value;
-
-                newSpectrum.SetColorAt(kvp.Key, Utils.ColorUtils.BlendColors(bgColor, fgColor, percent));
-            }
-
-            EffectBrush returnBrush = new LinearEffectBrush(newSpectrum);
-            returnBrush.wrap =wrap;
-
-            returnBrush.start = new System.Drawing.PointF((float)(start.X * (1.0 - percent) + otherBrush.start.X * (percent)), (float)(start.Y * (1.0 - percent) + otherBrush.start.Y * (percent)));
-            returnBrush.end = new System.Drawing.PointF((float)(end.X * (1.0 - percent) + otherBrush.end.X * (percent)), (float)(end.Y * (1.0 - percent) + otherBrush.end.Y * (percent)));
-            returnBrush.center = new System.Drawing.PointF((float)(center.X * (1.0 - percent) + otherBrush.center.X * (percent)), (float)(center.Y * (1.0 - percent) + otherBrush.center.Y * (percent)));
-
-            return returnBrush;
-        }
-    }
-    public class RadialEffectBrush : EffectBrush
-    {
-        public RadialEffectBrush()
-        {
-
-            colorGradients.Add(0.0f, System.Drawing.Color.Red);
-            colorGradients.Add(1.0f, System.Drawing.Color.Blue);
-
-            start = new System.Drawing.PointF(0, 0);
-            end = new System.Drawing.PointF(1, 0);
-            center = new System.Drawing.PointF(0.0f, 0.0f);
-        }
-
-        public RadialEffectBrush(EffectBrush otherBrush)
-        {
-            this.wrap = otherBrush.wrap;
-            this.colorGradients = otherBrush.colorGradients;
-            this.start = otherBrush.start;
-            this.end = otherBrush.end;
-            this.center = otherBrush.center;
-        }
-
-        public RadialEffectBrush(ColorSpectrum spectrum)
-        {
-            foreach (var color in spectrum.GetSpectrumColors())
-                colorGradients.Add(color.Key, color.Value);
-
-            start = new System.Drawing.PointF(0, 0);
-            end = new System.Drawing.PointF(1, 0);
-            center = new System.Drawing.PointF(0.0f, 0.0f);
-        }
-
-        public RadialEffectBrush(System.Drawing.Drawing2D.PathGradientBrush brush)
-        {
-            start = brush.Rectangle.Location;
-            end = new System.Drawing.PointF(brush.Rectangle.Width, brush.Rectangle.Height);
-            center = new System.Drawing.PointF(
-                brush.CenterPoint.X,
-                brush.CenterPoint.Y
-                );
-
-
-            switch (brush.WrapMode)
-            {
-                case (System.Drawing.Drawing2D.WrapMode.Clamp):
-                    wrap = BrushWrap.None;
-                    break;
-                case (System.Drawing.Drawing2D.WrapMode.Tile):
-                    wrap = BrushWrap.Repeat;
-                    break;
-                case (System.Drawing.Drawing2D.WrapMode.TileFlipXY):
-                    wrap = BrushWrap.Reflect;
-                    break;
-            }
-
-            try
-            {
-                if (brush.InterpolationColors != null && brush.InterpolationColors.Colors.Length == brush.InterpolationColors.Positions.Length)
-                {
-                    for (int x = 0; x < brush.InterpolationColors.Colors.Length; x++)
-                    {
-                        if (!colorGradients.ContainsKey(brush.InterpolationColors.Positions[x]) && (brush.InterpolationColors.Positions[x] >= 0.0f && brush.InterpolationColors.Positions[x] <= 1.0f))
-                            colorGradients.Add(
-                                brush.InterpolationColors.Positions[x],
-                                brush.InterpolationColors.Colors[x]
-                                );
-                    }
-                }
-            }
-            catch (Exception exc)
-            {
-                colorGradients.Clear();
-
-                for (int x = 0; x < brush.SurroundColors.Length; x++)
-                {
-                    float pos = x / (float)(brush.SurroundColors.Length - 1);
-
-                    if (!colorGradients.ContainsKey(pos))
-                        colorGradients.Add(
-                            pos,
-                            brush.SurroundColors[x]
-                            );
-                }
-            }
-
-
-            CheckColorGradients();
-
-
-        }
-
-        public RadialEffectBrush(System.Windows.Media.RadialGradientBrush brush)
-        {
-
-            start = new System.Drawing.PointF(0, 0);
-            end = new System.Drawing.PointF((float)brush.RadiusX * 2.0f, (float)brush.RadiusY * 2.0f);
-            center = new System.Drawing.PointF(
-                (float)brush.Center.X,
-                (float)brush.Center.Y
-                );
-
-            switch (brush.SpreadMethod)
-            {
-                case (System.Windows.Media.GradientSpreadMethod.Pad):
-                    wrap = BrushWrap.None;
-                    break;
-                case (System.Windows.Media.GradientSpreadMethod.Repeat):
-                    wrap = BrushWrap.Repeat;
-                    break;
-                case (System.Windows.Media.GradientSpreadMethod.Reflect):
-                    wrap = BrushWrap.Reflect;
-                    break;
-            }
-
-            foreach (var grad in brush.GradientStops)
-            {
-                if (!colorGradients.ContainsKey((float)grad.Offset) && ((float)grad.Offset >= 0.0f && (float)grad.Offset <= 1.0f))
-                    colorGradients.Add(
-                        (float)grad.Offset,
-                        Utils.ColorUtils.MediaColorToDrawingColor(grad.Color)
-                        );
-            }
-
-            CheckColorGradients();
-        }
-        public override System.Drawing.Brush GetDrawingBrush()
-        {
-            if (true/*_drawingbrush == null*/)
-            {
-                    System.Drawing.Drawing2D.GraphicsPath g_path = new System.Drawing.Drawing2D.GraphicsPath();
-                    g_path.AddEllipse(
-                        new System.Drawing.RectangleF(
-                        start.X,
-                        start.Y,
-                        end.X,
-                        end.Y
-                        ));
-
-                    System.Drawing.Drawing2D.PathGradientBrush brush = new System.Drawing.Drawing2D.PathGradientBrush(
-                        g_path
-                        );
-
-                    switch (wrap)
-                    {
-                        //// Clamp causes an exception, it's a bug in the Drawing Brush.
-                        //case BrushWrap.None:
-                        //    brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
-                        //    break;
-                        case BrushWrap.Repeat:
-                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Tile;
-                            break;
-                        case BrushWrap.Reflect:
-                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.TileFlipXY;
-                            break;
-                    }
-
-                    List<System.Drawing.Color> brush_colors = new List<System.Drawing.Color>();
-                    List<float> brush_positions = new List<float>();
-
-                    foreach (var kvp in colorGradients)
-                    {
-                        brush_positions.Add(1.0f - kvp.Key);
-                        brush_colors.Add(kvp.Value);
-                    }
-
-                    brush.CenterPoint = center;
-                    //brush.CenterColor = brush_colors[0];
-
-                    //brush.SurroundColors = brush_colors.ToArray();
-
-                    brush_colors.Reverse();
-                    brush_positions.Reverse();
-
-                    System.Drawing.Drawing2D.ColorBlend color_blend = new System.Drawing.Drawing2D.ColorBlend();
-                    color_blend.Colors = brush_colors.ToArray();
-                    color_blend.Positions = brush_positions.ToArray();
-                    brush.InterpolationColors = color_blend;
-
-                    _drawingBrush = brush;
-
-            }
-
-            return _drawingBrush;
-        }
-
-        public override System.Drawing.Brush GetDrawingBrush(float shift, float window_size)
-        {
-            if (true/*_drawingbrush == null*/)
-            {
-                    System.Drawing.Drawing2D.GraphicsPath g_path = new System.Drawing.Drawing2D.GraphicsPath();
-                    g_path.AddEllipse(
-                        new System.Drawing.RectangleF(
-                        start.X,
-                        start.Y,
-                        end.X,
-                        end.Y
-                        ));
-
-                    System.Drawing.Drawing2D.PathGradientBrush brush = new System.Drawing.Drawing2D.PathGradientBrush(
-                        g_path
-                        );
-
-                    switch (wrap)
-                    {
-                        //// Clamp causes an exception, it's a bug in the Drawing Brush.
-                        //case BrushWrap.None:
-                        //    brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
-                        //    break;
-                        case BrushWrap.Repeat:
-                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.Tile;
-                            break;
-                        case BrushWrap.Reflect:
-                            brush.WrapMode = System.Drawing.Drawing2D.WrapMode.TileFlipXY;
-                            break;
-                    }
-
-                    List<System.Drawing.Color> brush_colors = new List<System.Drawing.Color>();
-                    List<float> brush_positions = new List<float>();
-
-                    foreach (var kvp in GetColorGradientsForWindow(Math.Abs(shift), window_size / 100))
-                    {
-                        if (shift < 0)
-                            brush_positions.Add(1.0f - kvp.Key);
-                        else
-                            brush_positions.Add(kvp.Key);
-                        brush_colors.Add(kvp.Value);
-                    }
-
-                    if (shift < 0)
-                    {
-                        brush_colors.Reverse();
-                        brush_positions.Reverse();
-                    }
-
-                    brush.CenterPoint = center;
-
-                    System.Drawing.Drawing2D.ColorBlend color_blend = new System.Drawing.Drawing2D.ColorBlend();
-                    color_blend.Colors = brush_colors.ToArray();
-                    color_blend.Positions = brush_positions.ToArray();
-                    brush.InterpolationColors = color_blend;
-
-                    _drawingBrush = brush;
-            }
-
-            return _drawingBrush;
-        }
-        public override System.Windows.Media.Brush GetMediaBrush()
-        {
-            if (_mediaBrush == null)
-            {
-                    System.Windows.Media.GradientStopCollection collection = new System.Windows.Media.GradientStopCollection();
-
-                    foreach (var kvp in colorGradients)
-                    {
-                        collection.Add(
-                            new System.Windows.Media.GradientStop(
-                                Utils.ColorUtils.DrawingColorToMediaColor(kvp.Value),
-                                kvp.Key)
-                            );
-                    }
-
-                    System.Windows.Media.RadialGradientBrush brush = new System.Windows.Media.RadialGradientBrush(collection);
-                    brush.Center = new System.Windows.Point(center.X, center.Y);
-                    brush.RadiusX = end.X / 2.0;
-                    brush.RadiusY = end.Y / 2.0;
-
-                    switch (wrap)
-                    {
-                        case BrushWrap.None:
-                            brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Pad;
-                            break;
-                        case BrushWrap.Repeat:
-                            brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Repeat;
-                            break;
-                        case BrushWrap.Reflect:
-                            brush.SpreadMethod = System.Windows.Media.GradientSpreadMethod.Reflect;
-                            break;
-                    }
-
-                    _mediaBrush = brush;
-            }
-
-            return _mediaBrush;
-        }
-
-        public override ColorSpectrum GetColorSpectrum()
-        {
-            ColorSpectrum spectrum = new ColorSpectrum();
-
-                foreach (var color in colorGradients)
-                    spectrum.SetColorAt(color.Key, color.Value);
-
-            return spectrum;
-        }
-
-        /// <summary>
-        /// Blends two EffectBrushes together by a specified amount
-        /// </summary>
-        /// <param name="otherBrush">The foreground EffectBrush (When percent is at 1.0D, only this EffectBrush is shown)</param>
-        /// <param name="percent">The blending percent value</param>
-        /// <returns>The blended EffectBrush</returns>
-        public override EffectBrush BlendEffectBrush(EffectBrush otherBrush, double percent)
-        {
-            if (percent <= 0.0)
-                return (EffectBrush)this.Clone();
-            else if (percent >= 1.0)
-                return (EffectBrush)otherBrush.Clone();
-
-            ColorSpectrum currentSpectrum = new ColorSpectrum(GetColorSpectrum());
-            ColorSpectrum newSpectrum = new ColorSpectrum(currentSpectrum).MultiplyByScalar(1.0 - percent);
-
-            foreach (var kvp in otherBrush.colorGradients)
-            {
-                System.Drawing.Color bgColor = currentSpectrum.GetColorAt(kvp.Key);
-                System.Drawing.Color fgColor = kvp.Value;
-
-                newSpectrum.SetColorAt(kvp.Key, Utils.ColorUtils.BlendColors(bgColor, fgColor, percent));
-            }
-
-            EffectBrush returnBrush = new RadialEffectBrush(newSpectrum);
-            returnBrush.wrap = wrap;
-
-            returnBrush.start = new System.Drawing.PointF((float)(start.X * (1.0 - percent) + otherBrush.start.X * (percent)), (float)(start.Y * (1.0 - percent) + otherBrush.start.Y * (percent)));
-            returnBrush.end = new System.Drawing.PointF((float)(end.X * (1.0 - percent) + otherBrush.end.X * (percent)), (float)(end.Y * (1.0 - percent) + otherBrush.end.Y * (percent)));
-            returnBrush.center = new System.Drawing.PointF((float)(center.X * (1.0 - percent) + otherBrush.center.X * (percent)), (float)(center.Y * (1.0 - percent) + otherBrush.center.Y * (percent)));
-
-            return returnBrush;
-        }
-    }
-}
diff --git a/Project-Aurora/Project-Aurora/EffectsEngine/EffectLayer.cs b/Project-Aurora/Project-Aurora/EffectsEngine/EffectLayer.cs
index 226697c35..7d5a2e68c 100755
--- a/Project-Aurora/Project-Aurora/EffectsEngine/EffectLayer.cs
+++ b/Project-Aurora/Project-Aurora/EffectsEngine/EffectLayer.cs
@@ -30,7 +30,7 @@ public class EffectLayer : IDisposable
                 Devices.DeviceKeys.Peripheral_Logo
             };
 
-        static private ColorSpectrum rainbow = new ColorSpectrum(ColorSpectrum.RainbowLoop);
+        static private ColorBox.ColorSpectrum rainbow = new ColorBox.ColorSpectrum(ColorBox.ColorSpectrum.RainbowLoop);
 
         /// <summary>
         /// Creates a new instance of the EffectLayer class with default parameters.
@@ -207,18 +207,18 @@ public EffectLayer(string name, Color color)
 
                     if (effect_config.animation_reverse)
                         shift *= -1.0f;
-                    float percent = shift / (Effects.canvas_biggest / effect_config.gradient_size);
+                    float percent = shift;
                     brush = effect_config.brush.GetDrawingBrush(percent % 1 , effect_config.gradient_size);
                     if (brush is LinearGradientBrush linear_brush)
                     {
                         linear_brush.ScaleTransform(brush_width, brush_height);
                         linear_brush.RotateTransform(effect_config.angle);
-                        linear_brush.TranslateTransform(shift, shift);
+                        //linear_brush.TranslateTransform(shift, shift);
 
                     }
                     else if (brush is PathGradientBrush radial_brush)
                     {
-                        brush_height *= (float)Math.Sqrt(2);
+                        /*brush_height *= (float)Math.Sqrt(2);
                         brush_width *= (float)Math.Sqrt(2);
                         float x_offset = -(float)(Math.Sqrt(2) - 1) * brush_width / 2;
                         float y_offset = -(float)(Math.Sqrt(2) - 1) * brush_height / 2;
@@ -227,10 +227,10 @@ public EffectLayer(string name, Color color)
                         {
                             x_offset += rect.X;
                             y_offset += rect.Y;
-                        }
-
-                        radial_brush.TranslateTransform(x_offset, y_offset);
-                        radial_brush.ScaleTransform(brush_width, brush_height);
+                        }*/
+                        //radial_brush.TranslateTransform(0, -(brush_width) / 2);
+                        radial_brush.TranslateTransform(0, -(brush_width-brush_height)/2);
+                        radial_brush.ScaleTransform(brush_width, brush_width);
 
                         radial_brush.WrapMode = WrapMode.Clamp;
                     }
@@ -760,7 +760,7 @@ public EffectLayer PercentEffect(Color foregroundColor, Color backgroundColor, S
         /// <param name="total">The maxiumum progress value</param>
         /// <param name="percentEffectType">The percent effect type</param>
         /// <returns>Itself</returns>
-        public EffectLayer PercentEffect(ColorSpectrum spectrum, Settings.KeySequence sequence, double value, double total = 1.0D, PercentEffectType percentEffectType = PercentEffectType.Progressive, double flash_past = 0.0, bool flash_reversed = false, bool blink_background = false)
+        public EffectLayer PercentEffect(ColorBox.ColorSpectrum spectrum, Settings.KeySequence sequence, double value, double total = 1.0D, PercentEffectType percentEffectType = PercentEffectType.Progressive, double flash_past = 0.0, bool flash_reversed = false, bool blink_background = false)
         {
             if (sequence.type == KeySequenceType.Sequence)
                 PercentEffect(spectrum, sequence.keys.ToArray(), value, total, percentEffectType, flash_past, flash_reversed);
@@ -849,7 +849,7 @@ public EffectLayer PercentEffect(Color foregroundColor, Color backgroundColor, D
         /// <param name="total">The maxiumum progress value</param>
         /// <param name="percentEffectType">The percent effect type</param>
         /// <returns>Itself</returns>
-        public EffectLayer PercentEffect(ColorSpectrum spectrum, Devices.DeviceKeys[] keys, double value, double total, PercentEffectType percentEffectType = PercentEffectType.Progressive, double flash_past = 0.0, bool flash_reversed = false)
+        public EffectLayer PercentEffect(ColorBox.ColorSpectrum spectrum, Devices.DeviceKeys[] keys, double value, double total, PercentEffectType percentEffectType = PercentEffectType.Progressive, double flash_past = 0.0, bool flash_reversed = false)
         {
             double progress_total = value / total;
             if (progress_total < 0.0)
@@ -983,7 +983,7 @@ public EffectLayer PercentEffect(Color foregroundColor, Color backgroundColor, S
         /// <param name="total">The maxiumum progress value</param>
         /// <param name="percentEffectType">The percent effect type</param>
         /// <returns>Itself</returns>
-        public EffectLayer PercentEffect(ColorSpectrum spectrum, Settings.FreeFormObject freeform, double value, double total, PercentEffectType percentEffectType = PercentEffectType.Progressive, double flash_past = 0.0, bool flash_reversed = false)
+        public EffectLayer PercentEffect(ColorBox.ColorSpectrum spectrum, Settings.FreeFormObject freeform, double value, double total, PercentEffectType percentEffectType = PercentEffectType.Progressive, double flash_past = 0.0, bool flash_reversed = false)
         {
             double progress_total = value / total;
             if (progress_total < 0.0)
diff --git a/Project-Aurora/Project-Aurora/Profiles/CloneHero/CloneHeroProfile.cs b/Project-Aurora/Project-Aurora/Profiles/CloneHero/CloneHeroProfile.cs
index d78287728..2643a4841 100644
--- a/Project-Aurora/Project-Aurora/Profiles/CloneHero/CloneHeroProfile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/CloneHero/CloneHeroProfile.cs
@@ -56,28 +56,12 @@ public override void Reset()
                             animation_reverse = false,
                             brush =
                             new LinearEffectBrush{
-                                wrap = EffectBrush.BrushWrap.Repeat,
-                                colorGradients = new SortedDictionary<float, Color>()
+                                ColorGradients = new SortedDictionary<float, Color>()
                                 {
                                     {0, Color.FromArgb(9, 43, 83) },
                                     {0.298960835f, Color.FromArgb(187, 18, 194) },
                                     {0.685535133f, Color.FromArgb(17, 185, 217) },
                                     {1, Color.FromArgb(9, 43, 83) }
-                                },
-                                start =
-                                {
-                                    X = 0,
-                                    Y = -0.5f
-                                },
-                                end =
-                                {
-                                    X = 1,
-                                    Y = 1
-                                },
-                                center =
-                                {
-                                    X = 0,
-                                    Y = 0
                                 }
 
                             },
diff --git a/Project-Aurora/Project-Aurora/Profiles/Desktop/DesktopProfile.cs b/Project-Aurora/Project-Aurora/Profiles/Desktop/DesktopProfile.cs
index b022b1078..29b466741 100755
--- a/Project-Aurora/Project-Aurora/Profiles/Desktop/DesktopProfile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/Desktop/DesktopProfile.cs
@@ -47,7 +47,7 @@ private void setVolumeOverlay()
                         }),
                     _Gradient = new EffectsEngine.LinearEffectBrush()
                     {
-                        colorGradients = new SortedDictionary<float, Color> {
+                        ColorGradients = new SortedDictionary<float, Color> {
                                 { 0f, Color.FromArgb(255, 0, 255, 0) },
                                 { 0.5f, Color.OrangeRed },
                                 { 1f, Color.Red }
diff --git a/Project-Aurora/Project-Aurora/Profiles/Desktop/Event_Idle.cs b/Project-Aurora/Project-Aurora/Profiles/Desktop/Event_Idle.cs
index e60d56b81..52dcecddb 100644
--- a/Project-Aurora/Project-Aurora/Profiles/Desktop/Event_Idle.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/Desktop/Event_Idle.cs
@@ -127,7 +127,7 @@ public override void UpdateLights(EffectFrame frame)
 
                     Devices.DeviceKeys[] raindrops_keys = raindrops.Keys.ToArray();
 
-                    ColorSpectrum drop_spec = new ColorSpectrum(Global.Configuration.idle_effect_primary_color, Color.FromArgb(0, Global.Configuration.idle_effect_primary_color));
+                    var drop_spec = new ColorBox.ColorSpectrum(Global.Configuration.idle_effect_primary_color, Color.FromArgb(0, Global.Configuration.idle_effect_primary_color));
 
                     foreach (Devices.DeviceKeys raindrop in raindrops_keys)
                     {
@@ -217,7 +217,7 @@ public override void UpdateLights(EffectFrame frame)
 					}
 					layer.Fill(Global.Configuration.idle_effect_secondary_color);
 
-					ColorSpectrum drop_spec2 = new ColorSpectrum(
+					var drop_spec2 = new ColorBox.ColorSpectrum(
 						Global.Configuration.idle_effect_primary_color,
 						Color.FromArgb(0, Global.Configuration.idle_effect_primary_color));
 
diff --git a/Project-Aurora/Project-Aurora/Profiles/ETS2/ETS2Profile.cs b/Project-Aurora/Project-Aurora/Profiles/ETS2/ETS2Profile.cs
index e7f7fdb4c..0924c5f69 100644
--- a/Project-Aurora/Project-Aurora/Profiles/ETS2/ETS2Profile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/ETS2/ETS2Profile.cs
@@ -61,7 +61,7 @@ public override void Reset() {
                 new Layer("Throttle Key", new PercentGradientLayerHandler {
                     Properties = new PercentGradientLayerHandlerProperties {
                         _Gradient = new LinearEffectBrush() {
-                            colorGradients = new SortedDictionary<float, Color> {
+                            ColorGradients = new SortedDictionary<float, Color> {
                                 { 0, Color.FromArgb(0, 255, 255) },
                                 { 1, Color.FromArgb(0, 255, 0) }
                             }
@@ -76,7 +76,7 @@ public override void Reset() {
                 new Layer("Brake Key", new PercentGradientLayerHandler {
                     Properties = new PercentGradientLayerHandlerProperties {
                         _Gradient = new LinearEffectBrush() {
-                            colorGradients = new SortedDictionary<float, Color> {
+                            ColorGradients = new SortedDictionary<float, Color> {
                                 { 0, Color.FromArgb(0, 255, 255) },
                                 { 1, Color.FromArgb(255, 0, 0) }
                             }
@@ -103,7 +103,7 @@ public override void Reset() {
                 new Layer("RPM", new PercentGradientLayerHandler {
                     Properties = new PercentGradientLayerHandlerProperties {
                         _Gradient = new LinearEffectBrush() {
-                            colorGradients = new SortedDictionary<float, Color> {
+                            ColorGradients = new SortedDictionary<float, Color> {
                                 { 0, Color.FromArgb(65, 255, 0) },
                                 { 0.65f, Color.FromArgb(67, 255, 0) },
                                 { 0.75f, Color.FromArgb(0, 100, 255) },
@@ -238,7 +238,7 @@ public override void Reset() {
                 new Layer("Fuel", new PercentGradientLayerHandler {
                     Properties = new PercentGradientLayerHandlerProperties {
                         _Gradient = new LinearEffectBrush() {
-                            colorGradients = new SortedDictionary<float, Color> {
+                            ColorGradients = new SortedDictionary<float, Color> {
                                 { 0f, Color.FromArgb(255, 0, 0) },
                                 { 0.25f, Color.FromArgb(255, 0, 0) },
                                 { 0.375f, Color.FromArgb(255, 255, 0) },
@@ -257,7 +257,7 @@ public override void Reset() {
                 new Layer("Air Pressure", new PercentGradientLayerHandler {
                     Properties = new PercentGradientLayerHandlerProperties {
                         _Gradient = new LinearEffectBrush() {
-                            colorGradients = new SortedDictionary<float, Color> {
+                            ColorGradients = new SortedDictionary<float, Color> {
                                 { 0f, Color.FromArgb(255, 0, 0) },
                                 { 0.25f, Color.FromArgb(255, 0, 0) },
                                 { 0.375f, Color.FromArgb(255, 255, 0) },
diff --git a/Project-Aurora/Project-Aurora/Profiles/Osu/OsuProfile.cs b/Project-Aurora/Project-Aurora/Profiles/Osu/OsuProfile.cs
index 90f0c9d94..03cad1507 100644
--- a/Project-Aurora/Project-Aurora/Profiles/Osu/OsuProfile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/Osu/OsuProfile.cs
@@ -132,7 +132,7 @@ public override void Reset() {
                         _ViewType = EqualizerPresentationType.GradientColorShift,
                         _MaxAmplitude = 25,
                         _Gradient = new EffectsEngine.LinearEffectBrush {
-                            colorGradients = new SortedDictionary<float, Color> {
+                            ColorGradients = new SortedDictionary<float, Color> {
                                 { 0, Color.Magenta },
                                 { 0.5f, Color.Cyan },
                                 { 1, Color.Magenta }
diff --git a/Project-Aurora/Project-Aurora/Profiles/Payday 2/Layers/PD2BackgroundLayerHandler.cs b/Project-Aurora/Project-Aurora/Profiles/Payday 2/Layers/PD2BackgroundLayerHandler.cs
index 59099b133..0a3d898ea 100644
--- a/Project-Aurora/Project-Aurora/Profiles/Payday 2/Layers/PD2BackgroundLayerHandler.cs	
+++ b/Project-Aurora/Project-Aurora/Profiles/Payday 2/Layers/PD2BackgroundLayerHandler.cs	
@@ -203,7 +203,7 @@ public override EffectLayer Render(IGameState state)
                     {
                         double percentSuspicious = ((double)pd2.Players.LocalPlayer.SuspicionAmount / (double)1.0);
 
-                        ColorSpectrum suspicion_spec = new ColorSpectrum(Properties.LowSuspicionColor, Properties.HighSuspicionColor);
+                        var suspicion_spec = new ColorBox.ColorSpectrum(Properties.LowSuspicionColor, Properties.HighSuspicionColor);
                         suspicion_spec.SetColorAt(0.5f, Properties.MediumSuspicionColor);
 
                         Settings.KeySequence suspicionSequence = new Settings.KeySequence(new Settings.FreeFormObject(0, 0, 1.0f / (Effects.editor_to_canvas_width / Effects.canvas_width), 1.0f / (Effects.editor_to_canvas_height / Effects.canvas_height)));
@@ -216,7 +216,7 @@ public override EffectLayer Render(IGameState state)
                 }
                 else if (pd2.Level.Phase == LevelPhase.Point_of_no_return && pd2.Game.State == GameStates.Ingame)
                 {
-                    ColorSpectrum no_return_spec = new ColorSpectrum(Color.Red, Color.Yellow);
+                    var no_return_spec = new ColorBox.ColorSpectrum(Color.Red, Color.Yellow);
                     if (pd2.Level.NoReturnTime != no_return_timeleft)
                     {
                         no_return_timeleft = pd2.Level.NoReturnTime;
diff --git a/Project-Aurora/Project-Aurora/Profiles/RocketLeague/RocketLeagueProfile.cs b/Project-Aurora/Project-Aurora/Profiles/RocketLeague/RocketLeagueProfile.cs
index 1559fe642..ed85df39a 100644
--- a/Project-Aurora/Project-Aurora/Profiles/RocketLeague/RocketLeagueProfile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/RocketLeague/RocketLeagueProfile.cs
@@ -28,7 +28,7 @@ public override void Reset()
                     {
                         _PercentType = PercentEffectType.AllAtOnce,
                         _Sequence = new KeySequence(new Devices.DeviceKeys[] { Devices.DeviceKeys.Peripheral, Devices.DeviceKeys.Peripheral_Logo } ),
-                        _Gradient = new EffectsEngine.LinearEffectBrush(new ColorSpectrum(Color.Yellow, Color.Red).SetColorAt(0.75f, Color.OrangeRed)),
+                        _Gradient = new EffectsEngine.LinearEffectBrush(new ColorBox.ColorSpectrum(Color.Yellow, Color.Red).SetColorAt(0.75f, Color.OrangeRed)),
                         _BlinkThreshold = 0.0,
                         _BlinkDirection = false,
                         _VariablePath = "Player/Boost",
@@ -45,7 +45,7 @@ public override void Reset()
                             Devices.DeviceKeys.F6, Devices.DeviceKeys.F7, Devices.DeviceKeys.F8, Devices.DeviceKeys.F9, Devices.DeviceKeys.F10,
                             Devices.DeviceKeys.F11, Devices.DeviceKeys.F12
                         }),
-                        _Gradient = new EffectsEngine.LinearEffectBrush(new ColorSpectrum(Color.Yellow, Color.Red).SetColorAt(0.75f, Color.OrangeRed)),
+                        _Gradient = new EffectsEngine.LinearEffectBrush(new ColorBox.ColorSpectrum(Color.Yellow, Color.Red).SetColorAt(0.75f, Color.OrangeRed)),
                         _BlinkThreshold = 0.0,
                         _BlinkDirection = false,
                         _VariablePath = "Player/Boost",
diff --git a/Project-Aurora/Project-Aurora/Profiles/Subnautica/SubnauticaProfile.cs b/Project-Aurora/Project-Aurora/Profiles/Subnautica/SubnauticaProfile.cs
index 530acb463..f27170189 100644
--- a/Project-Aurora/Project-Aurora/Profiles/Subnautica/SubnauticaProfile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/Subnautica/SubnauticaProfile.cs
@@ -119,9 +119,7 @@ public override void Reset() {
                 new Layer("Background", new PercentGradientLayerHandler() {
                     Properties = new PercentGradientLayerHandlerProperties {
                         _Gradient = new LinearEffectBrush() {
-                            start = new PointF(0, 0),
-                            end = new PointF(1, 0),
-                            colorGradients = new SortedDictionary<float, Color> {
+                            ColorGradients = new SortedDictionary<float, Color> {
                                 { 0, Color.FromArgb(46, 176, 255) },
                                 { 1, Color.FromArgb(0, 3, 53) }
                             }
diff --git a/Project-Aurora/Project-Aurora/Profiles/Terraria/TerrariaProfile.cs b/Project-Aurora/Project-Aurora/Profiles/Terraria/TerrariaProfile.cs
index 896c8a514..aed722ca8 100644
--- a/Project-Aurora/Project-Aurora/Profiles/Terraria/TerrariaProfile.cs
+++ b/Project-Aurora/Project-Aurora/Profiles/Terraria/TerrariaProfile.cs
@@ -46,9 +46,7 @@ public override void Reset() {
                 new Layer("Background", new PercentGradientLayerHandler() {
                     Properties = new PercentGradientLayerHandlerProperties {
                         _Gradient = new LinearEffectBrush() {
-                            start = new PointF(0, 0),
-                            end = new PointF(1, 0),
-                            colorGradients = new SortedDictionary<float, Color> {
+                            ColorGradients = new SortedDictionary<float, Color> {
                                 { 0, Color.White },
                                 { 1, Color.DarkGray }
                             }
@@ -80,9 +78,7 @@ private static EffectBrush GetColorGradient(Color start, Color end)
         {
             return new LinearEffectBrush()
             {
-                start = new PointF(0, 0),
-                end = new PointF(1, 0),
-                colorGradients = new SortedDictionary<float, Color> {
+                ColorGradients = new SortedDictionary<float, Color> {
                     { 0, start },
                     { 1, end }
                 }
diff --git a/Project-Aurora/Project-Aurora/Project-Aurora.csproj b/Project-Aurora/Project-Aurora/Project-Aurora.csproj
index 931376966..f81e8bfe6 100644
--- a/Project-Aurora/Project-Aurora/Project-Aurora.csproj
+++ b/Project-Aurora/Project-Aurora/Project-Aurora.csproj
@@ -333,7 +333,6 @@
     <Compile Include="EffectsEngine\Animations\AnimationMix.cs" />
     <Compile Include="EffectsEngine\Animations\AnimationRectangle.cs" />
     <Compile Include="EffectsEngine\Animations\AnimationTrack.cs" />
-    <Compile Include="EffectsEngine\EffectBrush.cs" />
     <Compile Include="Profiles\ATS\ATSApplication.cs" />
     <Compile Include="Profiles\ATS\Control_ATS.xaml.cs">
       <DependentUpon>Control_ATS.xaml</DependentUpon>
@@ -1256,7 +1255,6 @@
     <Compile Include="Devices\Device.cs" />
     <Compile Include="Devices\Logitech\LogitechDevice.cs" />
     <Compile Include="EffectsEngine\EffectColor.cs" />
-    <Compile Include="EffectsEngine\ColorSpectrum.cs" />
     <Compile Include="EffectsEngine\EffectFrame.cs" />
     <Compile Include="EffectsEngine\EffectLayer.cs" />
     <Compile Include="EffectsEngine\Effects.cs" />
diff --git a/Project-Aurora/Project-Aurora/Settings/LayerEffectConfig.cs b/Project-Aurora/Project-Aurora/Settings/LayerEffectConfig.cs
index 0d7233d22..57327d2a4 100644
--- a/Project-Aurora/Project-Aurora/Settings/LayerEffectConfig.cs
+++ b/Project-Aurora/Project-Aurora/Settings/LayerEffectConfig.cs
@@ -49,21 +49,7 @@ public LayerEffectConfig(Color primary_color, Color secondary_color)
             speed = 1.0f;
             angle = 0.0f;
             animation_reverse = false;
-            brush = EffectBrush.GetEffectBrush(
-                new System.Drawing.Drawing2D.LinearGradientBrush(
-                    new PointF(0, 0),
-                    new PointF(1, 0),
-                    primary,
-                    secondary
-                    )
-                {
-                    InterpolationColors = new System.Drawing.Drawing2D.ColorBlend(2)
-                    {
-                        Colors = new Color[] { primary, secondary },
-                        Positions = new float[] { 0.0f, 1.0f }
-                    }
-                }
-                );
+            brush = new LinearEffectBrush(new ColorBox.ColorSpectrum(primary_color, secondary_color));
         }
 
         public LayerEffectConfig(LayerEffectConfig otherConfig)
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/Control_EqualizerLayer.xaml.cs b/Project-Aurora/Project-Aurora/Settings/Layers/Control_EqualizerLayer.xaml.cs
index e0d4ac420..e665b5dbf 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/Control_EqualizerLayer.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/Control_EqualizerLayer.xaml.cs
@@ -52,16 +52,7 @@ public void SetSettings()
                 this.eq_background_mode.SelectedItem = (this.DataContext as EqualizerLayerHandler).Properties._BackgroundMode;
                 this.Clr_primary_color.SelectedColor = Utils.ColorUtils.DrawingColorToMediaColor((this.DataContext as EqualizerLayerHandler).Properties._PrimaryColor ?? System.Drawing.Color.Empty);
                 this.Clr_secondary_color.SelectedColor = Utils.ColorUtils.DrawingColorToMediaColor((this.DataContext as EqualizerLayerHandler).Properties._SecondaryColor ?? System.Drawing.Color.Empty);
-
-                Brush brush = (this.DataContext as EqualizerLayerHandler).Properties._Gradient.GetMediaBrush();
-                try
-                {
-                    this.gradient_editor.Brush = brush;
-                }
-                catch (Exception exc)
-                {
-                    Global.logger.Error("Could not set brush, exception: " + exc);
-                }
+                this.gradient_editor.Brush = (this.DataContext as EqualizerLayerHandler).Properties._Gradient;
 
                 this.updown_max_amplitude_value.Value = (int)(this.DataContext as EqualizerLayerHandler).Properties._MaxAmplitude;
                 this.Clr_dim_color.SelectedColor = Utils.ColorUtils.DrawingColorToMediaColor((this.DataContext as EqualizerLayerHandler).Properties._DimColor ?? System.Drawing.Color.Empty);
@@ -105,37 +96,21 @@ private void Clr_secondary_color_SelectedColorChanged(object sender, RoutedPrope
         private void Gradient_editor_BrushChanged(object sender, ColorBox.BrushChangedEventArgs e)
         {
             if (IsLoaded && settingsset && this.DataContext is EqualizerLayerHandler && sender is ColorBox.ColorBox)
-                (this.DataContext as EqualizerLayerHandler).Properties._Gradient = EffectsEngine.EffectBrush.GetEffectBrush((sender as ColorBox.ColorBox).Brush);
+                (this.DataContext as EqualizerLayerHandler).Properties._Gradient = (sender as ColorBox.ColorBox).Brush;
         }
 
         private void Button_SetGradientRainbow_Click(object sender, RoutedEventArgs e)
         {
-            (this.DataContext as EqualizerLayerHandler).Properties._Gradient = new LinearEffectBrush(ColorSpectrum.Rainbow);
+            (this.DataContext as EqualizerLayerHandler).Properties._Gradient = new LinearEffectBrush(ColorBox.ColorSpectrum.Rainbow);
 
-            Brush brush = (this.DataContext as EqualizerLayerHandler).Properties._Gradient.GetMediaBrush();
-            try
-            {
-                this.gradient_editor.Brush = brush;
-            }
-            catch (Exception exc)
-            {
-                Global.logger.Error("Could not set brush, exception: " + exc);
-            }
+            this.gradient_editor.Brush = (this.DataContext as EqualizerLayerHandler).Properties._Gradient;
         }
 
         private void Button_SetGradientRainbowLoop_Click(object sender, RoutedEventArgs e)
         {
-            (this.DataContext as EqualizerLayerHandler).Properties._Gradient = new LinearEffectBrush(ColorSpectrum.RainbowLoop);
+            (this.DataContext as EqualizerLayerHandler).Properties._Gradient = new LinearEffectBrush(ColorBox.ColorSpectrum.RainbowLoop);
 
-            Brush brush = (this.DataContext as EqualizerLayerHandler).Properties._Gradient.GetMediaBrush();
-            try
-            {
-                this.gradient_editor.Brush = brush;
-            }
-            catch (Exception exc)
-            {
-                Global.logger.Error("Could not set brush, exception: " + exc);
-            }
+            this.gradient_editor.Brush = (this.DataContext as EqualizerLayerHandler).Properties._Gradient;
         }
 
         private void updown_max_amplitude_value_ValueChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientFillLayer.xaml.cs b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientFillLayer.xaml.cs
index 4602a551e..dbd1db0f4 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientFillLayer.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientFillLayer.xaml.cs
@@ -43,16 +43,7 @@ public void SetSettings()
                 this.effect_speed_slider.Value = (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.speed;
                 this.effect_speed_label.Text = "x " + (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.speed;
                 this.CheckBox_FillEntire.IsChecked = (this.DataContext as GradientFillLayerHandler).Properties._FillEntireKeyboard;
-                Brush brush = (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush.GetMediaBrush();
-                try
-                {
-                    this.gradient_editor.Brush = brush;
-                }
-                catch (Exception exc)
-                {
-                    Global.logger.Error("Could not set brush, exception: " + exc);
-                }
-
+                this.gradient_editor.Brush = (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush;
                 this.KeySequence_keys.Sequence = (this.DataContext as GradientFillLayerHandler).Properties._Sequence;
 
                 settingsset = true;
@@ -62,37 +53,20 @@ public void SetSettings()
         private void Gradient_editor_BrushChanged(object sender, ColorBox.BrushChangedEventArgs e)
         {
             if (IsLoaded && settingsset && this.DataContext is GradientFillLayerHandler && sender is ColorBox.ColorBox)
-                (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush = EffectsEngine.EffectBrush.GetEffectBrush((sender as ColorBox.ColorBox).Brush);
+                (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush = (sender as ColorBox.ColorBox).Brush;
         }
 
         private void Button_SetGradientRainbow_Click(object sender, RoutedEventArgs e)
         {
-            (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush = new LinearEffectBrush(ColorSpectrum.Rainbow);
-
-            Brush brush = (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush.GetMediaBrush();
-            try
-            {
-                this.gradient_editor.Brush = brush;
-            }
-            catch (Exception exc)
-            {
-                Global.logger.Error("Could not set brush, exception: " + exc);
-            }
+            (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush = new LinearEffectBrush(ColorBox.ColorSpectrum.Rainbow);
+             this.gradient_editor.Brush = (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush;
         }
 
         private void Button_SetGradientRainbowLoop_Click(object sender, RoutedEventArgs e)
         {
-            (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush = new LinearEffectBrush(ColorSpectrum.RainbowLoop);
+            (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush = new LinearEffectBrush(ColorBox.ColorSpectrum.RainbowLoop);
 
-            Brush brush = (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush.GetMediaBrush();
-            try
-            {
-                this.gradient_editor.Brush = brush;
-            }
-            catch (Exception exc)
-            {
-                Global.logger.Error("Could not set brush, exception: " + exc);
-            }
+            this.gradient_editor.Brush = (this.DataContext as GradientFillLayerHandler).Properties._GradientConfig.brush;
         }
 
         private void effect_speed_slider_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml.cs b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml.cs
index ad99fd099..ea2ead544 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/Control_GradientLayer.xaml.cs
@@ -46,16 +46,7 @@ public void SetSettings()
                 this.effect_speed_label.Text = "x " + (this.DataContext as GradientLayerHandler).Properties._GradientConfig.speed;
                 this.effect_angle.Text = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.angle.ToString();
                 this.effect_animation_reversed.IsChecked = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.animation_reverse;
-                Brush brush = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush.GetMediaBrush();
-                try
-                {
-                    this.gradient_editor.Brush = brush;
-                }
-                catch (Exception exc)
-                {
-                    Global.logger.Error("Could not set brush, exception: " + exc);
-                }
-
+                this.gradient_editor.Brush = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush;
                 this.KeySequence_keys.Sequence = (this.DataContext as GradientLayerHandler).Properties._Sequence;
 
                 settingsset = true;
@@ -65,37 +56,20 @@ public void SetSettings()
         private void Gradient_editor_BrushChanged(object sender, ColorBox.BrushChangedEventArgs e)
         {
             if (IsLoaded && settingsset && this.DataContext is GradientLayerHandler && sender is ColorBox.ColorBox)
-                (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush = EffectsEngine.EffectBrush.GetEffectBrush((sender as ColorBox.ColorBox).Brush);
+                (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush = (sender as ColorBox.ColorBox).Brush;
         }
 
         private void Button_SetGradientRainbow_Click(object sender, RoutedEventArgs e)
         {
-            (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush = new LinearEffectBrush(ColorSpectrum.Rainbow);
-
-            Brush brush = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush.GetMediaBrush();
-            try
-            {
-                this.gradient_editor.Brush = brush;
-            }
-            catch (Exception exc)
-            {
-                Global.logger.Error("Could not set brush, exception: " + exc);
-            }
+            (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush = new LinearEffectBrush(ColorBox.ColorSpectrum.Rainbow);
+            this.gradient_editor.Brush = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush;
         }
 
         private void Button_SetGradientRainbowLoop_Click(object sender, RoutedEventArgs e)
         {
-            (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush = new LinearEffectBrush(ColorSpectrum.RainbowLoop);
+            (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush = new LinearEffectBrush(ColorBox.ColorSpectrum.RainbowLoop);
 
-            Brush brush = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush.GetMediaBrush();
-            try
-            {
-                this.gradient_editor.Brush = brush;
-            }
-            catch (Exception exc)
-            {
-                Global.logger.Error("Could not set brush, exception: " + exc);
-            }
+            this.gradient_editor.Brush = (this.DataContext as GradientLayerHandler).Properties._GradientConfig.brush;
         }
         private void effect_speed_slider_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
         {
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/Control_ParticleLayer.xaml.cs b/Project-Aurora/Project-Aurora/Settings/Layers/Control_ParticleLayer.xaml.cs
index f7694fb4b..bb5e26b33 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/Control_ParticleLayer.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/Control_ParticleLayer.xaml.cs
@@ -28,7 +28,7 @@ public Control_ParticleLayer(SimpleParticleLayerHandler context) {
         private void ApplyGradientToEditor() {
             // Note that I tried using a binding instead of this but since it'd need a IValueConverter which would have to create a new brush and
             // the _values_ on that brush change not the brush itself, the binding was not actually being triggered.
-            gradientEditor.Brush = handler.Properties._ParticleColorStops.ToMediaBrush();
+            gradientEditor.Brush = new EffectsEngine.LinearEffectBrush(handler.Properties._ParticleColorStops.ToMediaBrush());
         }
 
         private void GradientEditor_BrushChanged(object sender, ColorBox.BrushChangedEventArgs e) {
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/Control_PercentGradientLayer.xaml.cs b/Project-Aurora/Project-Aurora/Settings/Layers/Control_PercentGradientLayer.xaml.cs
index 033f62522..ae2527057 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/Control_PercentGradientLayer.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/Control_PercentGradientLayer.xaml.cs
@@ -43,17 +43,7 @@ public void SetSettings()
                 this.updown_blink_value.Value = (int)((this.DataContext as PercentGradientLayerHandler).Properties._BlinkThreshold * 100);
                 this.CheckBox_threshold_reverse.IsChecked = (this.DataContext as PercentGradientLayerHandler).Properties._BlinkDirection;
                 this.KeySequence_keys.Sequence = (this.DataContext as PercentGradientLayerHandler).Properties._Sequence;
-
-                Brush brush = (this.DataContext as PercentGradientLayerHandler).Properties._Gradient.GetMediaBrush();
-                try
-                {
-                    this.gradient_editor.Brush = brush;
-                }
-                catch (Exception exc)
-                {
-                    Global.logger.Error("Could not set brush, exception: " + exc);
-                }
-
+                this.gradient_editor.Brush = (this.DataContext as PercentGradientLayerHandler).Properties._Gradient;
                 settingsset = true;
             }
         }
@@ -79,7 +69,7 @@ private void UserControl_Loaded(object sender, RoutedEventArgs e)
         private void Gradient_editor_BrushChanged(object sender, ColorBox.BrushChangedEventArgs e)
         {
             if (IsLoaded && settingsset && this.DataContext is PercentGradientLayerHandler && sender is ColorBox.ColorBox)
-                (this.DataContext as PercentGradientLayerHandler).Properties._Gradient = EffectsEngine.EffectBrush.GetEffectBrush((sender as ColorBox.ColorBox).Brush);
+                (this.DataContext as PercentGradientLayerHandler).Properties._Gradient = (sender as ColorBox.ColorBox).Brush;
         }
 
         private void ColorPicker_progressColor_SelectedColorChanged(object sender, RoutedPropertyChangedEventArgs<Color?> e)
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/Control_RadialLayer.xaml.cs b/Project-Aurora/Project-Aurora/Settings/Layers/Control_RadialLayer.xaml.cs
index ff5b6c0a4..f6b55a6ea 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/Control_RadialLayer.xaml.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/Control_RadialLayer.xaml.cs
@@ -1,5 +1,7 @@
-using Aurora.Utils;
+using Aurora.EffectsEngine;
+using Aurora.Utils;
 using System.Windows.Controls;
+using System.Windows.Media;
 
 namespace Aurora.Settings.Layers {
 
@@ -13,12 +15,12 @@ public Control_RadialLayer(RadialLayerHandler context) {
         }
 
         private void UserControl_Loaded(object sender, System.Windows.RoutedEventArgs e) {
-            GradientPicker.Brush = handler.Properties.Brush.Colors.ToMediaBrush();
+            GradientPicker.Brush = new LinearEffectBrush(handler.Properties.Brush.Colors.ToMediaBrush());
             Loaded -= UserControl_Loaded;
         }
 
         private void GradientPicker_BrushChanged(object sender, ColorBox.BrushChangedEventArgs e) {
-            handler.Properties.Brush.Colors = ColorStopCollection.FromMediaBrush(GradientPicker.Brush);
+            handler.Properties.Brush.Colors = ColorStopCollection.FromMediaBrush(GradientPicker.Brush.GetMediaBrush());
         }
     }
 }
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/EqualizerLayerHandler.cs b/Project-Aurora/Project-Aurora/Settings/Layers/EqualizerLayerHandler.cs
index 0e462dfef..66d25ec99 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/EqualizerLayerHandler.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/EqualizerLayerHandler.cs
@@ -130,7 +130,7 @@ public override void Default()
             _Sequence = new KeySequence(Effects.WholeCanvasFreeForm);
             _PrimaryColor = Utils.ColorUtils.GenerateRandomColor();
             _SecondaryColor = Utils.ColorUtils.GenerateRandomColor();
-            _Gradient = new LinearEffectBrush(ColorSpectrum.RainbowLoop);
+            _Gradient = new LinearEffectBrush(ColorBox.ColorSpectrum.RainbowLoop);
             _EQType = EqualizerType.PowerBars;
             _ViewType = EqualizerPresentationType.SolidColor;
             _MaxAmplitude = 20.0f;
@@ -429,8 +429,7 @@ private Brush GetBrush(float value, float position, float max_position)
             else if (Properties.ViewType == EqualizerPresentationType.GradientHorizontal)
             {
                 EffectBrush e_brush = new LinearEffectBrush(Properties.Gradient.GetColorSpectrum()) {
-                    start = PointF.Empty,
-                    end = new PointF(sourceRect.Width, 0)
+                    SampleWindowSize = 1 / sourceRect.Width
                 };
 
                 return e_brush.GetDrawingBrush();
@@ -440,8 +439,8 @@ private Brush GetBrush(float value, float position, float max_position)
             else if (Properties.ViewType == EqualizerPresentationType.GradientVertical)
             {
                 EffectBrush e_brush = new LinearEffectBrush(Properties.Gradient.GetColorSpectrum()) {
-                    start = new PointF(0, sourceRect.Height),
-                    end = PointF.Empty
+                    SampleWindowSize = 1 / sourceRect.Width,
+                    Angle = 90
                 };
 
                 return e_brush.GetDrawingBrush();
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/InteractiveLayerHandler.cs b/Project-Aurora/Project-Aurora/Settings/Layers/InteractiveLayerHandler.cs
index 10f7cd1b2..0ce6c2d4c 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/InteractiveLayerHandler.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/InteractiveLayerHandler.cs
@@ -30,7 +30,7 @@ public enum input_type
         public float progress;
         public bool waitOnKeyUp;
         public AnimationMix animation;
-        public ColorSpectrum spectrum;
+        public ColorBox.ColorSpectrum spectrum;
         public readonly input_type type;
 
         public input_item(Devices.DeviceKeys key, float progress, bool waitOnKeyUp, AnimationMix animation)
@@ -43,7 +43,7 @@ public input_item(Devices.DeviceKeys key, float progress, bool waitOnKeyUp, Anim
             type = input_type.AnimationMix;
         }
 
-        public input_item(Devices.DeviceKeys key, float progress, bool waitOnKeyUp, ColorSpectrum spectrum)
+        public input_item(Devices.DeviceKeys key, float progress, bool waitOnKeyUp, ColorBox.ColorSpectrum spectrum)
         {
             this.key = key;
             this.progress = progress;
@@ -221,8 +221,8 @@ private input_item CreateInputItem(Devices.DeviceKeys key, PointF origin)
             {
                 AnimationTrack rainbowWave = new AnimationTrack("Rainbow Wave", 1.0f);
 
-                rainbowWave.SetFrame(0.0f, new AnimationGradientCircle(origin, 0, new RadialEffectBrush(new ColorSpectrum(ColorSpectrum.Rainbow).Flip()), Properties.EffectWidth));
-                rainbowWave.SetFrame(1.0f, new AnimationGradientCircle(origin, Effects.canvas_width + (Properties.EffectWidth / 2), new RadialEffectBrush(new ColorSpectrum(ColorSpectrum.Rainbow).Flip()), Properties.EffectWidth));
+                rainbowWave.SetFrame(0.0f, new AnimationGradientCircle(origin, 0, new RadialEffectBrush(new ColorBox.ColorSpectrum(ColorBox.ColorSpectrum.Rainbow).Flip()), Properties.EffectWidth));
+                rainbowWave.SetFrame(1.0f, new AnimationGradientCircle(origin, Effects.canvas_width + (Properties.EffectWidth / 2), new RadialEffectBrush(new ColorBox.ColorSpectrum(ColorBox.ColorSpectrum.Rainbow).Flip()), Properties.EffectWidth));
 
                 anim_mix.AddTrack(rainbowWave);
             }
@@ -242,8 +242,7 @@ private input_item CreateInputItem(Devices.DeviceKeys key, PointF origin)
             }
             else if (Properties.InteractiveEffect == InteractiveEffects.KeyPress)
             {
-                ColorSpectrum spec = new ColorSpectrum(primary_c, secondary_c);
-                spec = new ColorSpectrum(primary_c, Color.FromArgb(0, secondary_c));
+                var spec = new ColorBox.ColorSpectrum(primary_c, Color.FromArgb(0, secondary_c));
                 spec.SetColorAt(0.80f, secondary_c);
 
                 return new input_item(key, 0.0f, Properties.WaitOnKeyUp, spec);
diff --git a/Project-Aurora/Project-Aurora/Settings/Layers/SimpleParticleLayerHandler.cs b/Project-Aurora/Project-Aurora/Settings/Layers/SimpleParticleLayerHandler.cs
index 4e5c3e1ca..5bf517c7e 100644
--- a/Project-Aurora/Project-Aurora/Settings/Layers/SimpleParticleLayerHandler.cs
+++ b/Project-Aurora/Project-Aurora/Settings/Layers/SimpleParticleLayerHandler.cs
@@ -128,7 +128,7 @@ public class SimpleParticleLayerProperties<TSelf> : ParticleLayerPropertiesBase<
         [JsonIgnore] public ColorStopCollection ParticleColorStops => Logic._ParticleColorStops ?? _ParticleColorStops ?? defaultParticleColor;
 
         // An override proxy for setting the particle color stops
-        [JsonIgnore, LogicOverridable("Color over time")] public EffectBrush _ParticleBrush { get => EffectBrush.GetEffectBrush(_ParticleColorStops.ToMediaBrush()); set => _ParticleColorStops = value == null ? null : ColorStopCollection.FromMediaBrush(value.GetMediaBrush()); }
+        [JsonIgnore, LogicOverridable("Color over time")] public EffectBrush _ParticleBrush { get => new LinearEffectBrush(_ParticleColorStops.ToMediaBrush()); set => _ParticleColorStops = value == null ? null : ColorStopCollection.FromMediaBrush(value.GetMediaBrush()); }
 
         private static readonly ColorStopCollection defaultParticleColor = new ColorStopCollection {
             {0f, Color.White },
diff --git a/Project-Aurora/Project-Aurora/Settings/ProfileImporter.cs b/Project-Aurora/Project-Aurora/Settings/ProfileImporter.cs
index 07b32e1d5..198c75cc3 100644
--- a/Project-Aurora/Project-Aurora/Settings/ProfileImporter.cs
+++ b/Project-Aurora/Project-Aurora/Settings/ProfileImporter.cs
@@ -345,7 +345,7 @@ private static void ImportCueprofile(this Application app, string filepath)
 
                                                 List<AnimationTrack> animTracks = new List<AnimationTrack>();
 
-                                                EffectsEngine.ColorSpectrum transitions = new EffectsEngine.ColorSpectrum();
+                                                var transitions = new ColorBox.ColorSpectrum();
 
                                                 float smallest = 0.5f;
                                                 float largest = 0.5f;
@@ -458,62 +458,54 @@ private static void ImportCueprofile(this Application app, string filepath)
                                                     if ((angle >= 315 || angle <= 45) || (angle >= 135 && angle <= 225))
                                                     {
                                                         //Right Side
-                                                        EffectsEngine.EffectBrush _initialBrushRight = new EffectsEngine.LinearEffectBrush(transitions);
-                                                        _initialBrushRight.start = new System.Drawing.PointF(Effects.canvas_width_center, 0);
-                                                        _initialBrushRight.end = new System.Drawing.PointF(Effects.canvas_width_center - width, 0);
+                                                        EffectsEngine.LinearEffectBrush _initialBrushRight = new EffectsEngine.LinearEffectBrush(transitions);
+                                                        _initialBrushRight.Angle = (int)angle;
 
                                                         animTrack.SetFrame(0.0f, new AnimationFilledGradientRectangle(Effects.canvas_width_center, 0, 0, Effects.canvas_height * 3, _initialBrushRight).SetAngle(angle));
 
                                                         if (_widthFillTime < _terminalTime)
                                                         {
-                                                            EffectsEngine.EffectBrush _fillBrushRight = new EffectsEngine.LinearEffectBrush(_initialBrushRight);
-                                                            _fillBrushRight.start = new System.Drawing.PointF(Effects.canvas_width_center + width, 0);
-                                                            _fillBrushRight.end = new System.Drawing.PointF(Effects.canvas_width_center, 0);
+                                                            EffectsEngine.LinearEffectBrush _fillBrushRight = new EffectsEngine.LinearEffectBrush(_initialBrushRight);
+                                                            _fillBrushRight.Angle = (int)angle;
 
                                                             animTrack.SetFrame(_widthFillTime, new AnimationFilledGradientRectangle(Effects.canvas_width_center, 0, width, Effects.canvas_height * 3, _fillBrushRight).SetAngle(angle));
 
-                                                            EffectsEngine.EffectBrush _terminalBrushRight = new EffectsEngine.LinearEffectBrush(_fillBrushRight);
-                                                            _terminalBrushRight.start = new System.Drawing.PointF(Effects.canvas_width_center + _terminalOffset, 0);
-                                                            _terminalBrushRight.end = new System.Drawing.PointF(Effects.canvas_width_center + _terminalOffset - width, 0);
+                                                            EffectsEngine.LinearEffectBrush _terminalBrushRight = new EffectsEngine.LinearEffectBrush(_fillBrushRight);
+                                                            _terminalBrushRight.Angle = (int)angle;
 
                                                             animTrack.SetFrame(_terminalTime, new AnimationFilledGradientRectangle(Effects.canvas_width_center + _terminalOffset - width, 0, width, Effects.canvas_height * 3, _terminalBrushRight).SetAngle(angle));
 
                                                         }
                                                         else
                                                         {
-                                                            EffectsEngine.EffectBrush _terminalBrushRight = new EffectsEngine.LinearEffectBrush(_initialBrushRight);
-                                                            _terminalBrushRight.start = new System.Drawing.PointF(Effects.canvas_width_center + _terminalOffset, 0);
-                                                            _terminalBrushRight.end = new System.Drawing.PointF(Effects.canvas_width_center + _terminalOffset - width, 0);
+                                                            EffectsEngine.LinearEffectBrush _terminalBrushRight = new EffectsEngine.LinearEffectBrush(_initialBrushRight);
+                                                            _terminalBrushRight.Angle = (int)angle;
 
                                                             animTrack.SetFrame(_terminalTime, new AnimationFilledGradientRectangle(Effects.canvas_width_center, 0, _terminalOffset, Effects.canvas_height * 3, _terminalBrushRight).SetAngle(angle));
                                                         }
 
                                                         //Left Side
-                                                        EffectsEngine.EffectBrush _initialBrushLeft = new EffectsEngine.LinearEffectBrush(transitions);
-                                                        _initialBrushLeft.start = new System.Drawing.PointF(Effects.canvas_width_center, 0);
-                                                        _initialBrushLeft.end = new System.Drawing.PointF(Effects.canvas_width_center + width, 0);
+                                                        EffectsEngine.LinearEffectBrush _initialBrushLeft = new EffectsEngine.LinearEffectBrush(transitions);
+                                                        _initialBrushLeft.Angle = (int)angle;
 
                                                         animTrack2.SetFrame(0.0f, new AnimationFilledGradientRectangle(Effects.canvas_width_center, 0, 0, Effects.canvas_height * 3, _initialBrushLeft).SetAngle(angle));
 
                                                         if (_widthFillTime < _terminalTime)
                                                         {
-                                                            EffectsEngine.EffectBrush _fillBrushLeft = new EffectsEngine.LinearEffectBrush(_initialBrushLeft);
-                                                            _fillBrushLeft.start = new System.Drawing.PointF(Effects.canvas_width_center - width, 0);
-                                                            _fillBrushLeft.end = new System.Drawing.PointF(Effects.canvas_width_center, 0);
+                                                            EffectsEngine.LinearEffectBrush _fillBrushLeft = new EffectsEngine.LinearEffectBrush(_initialBrushLeft);
+                                                            _fillBrushLeft.Angle = (int)angle;
 
                                                             animTrack2.SetFrame(_widthFillTime, new AnimationFilledGradientRectangle(Effects.canvas_width_center - width, 0, width, Effects.canvas_height * 3, _fillBrushLeft).SetAngle(angle));
 
-                                                            EffectsEngine.EffectBrush _terminalBrushLeft = new EffectsEngine.LinearEffectBrush(_initialBrushLeft);
-                                                            _terminalBrushLeft.start = new System.Drawing.PointF(Effects.canvas_width_center - _terminalOffset, 0);
-                                                            _terminalBrushLeft.end = new System.Drawing.PointF(Effects.canvas_width_center - _terminalOffset + width, 0);
+                                                            EffectsEngine.LinearEffectBrush _terminalBrushLeft = new EffectsEngine.LinearEffectBrush(_initialBrushLeft);
+                                                            _terminalBrushLeft.Angle = (int)angle;
 
                                                             animTrack2.SetFrame(_terminalTime, new AnimationFilledGradientRectangle(Effects.canvas_width_center - _terminalOffset, 0, width, Effects.canvas_height * 3, _terminalBrushLeft).SetAngle(angle));
                                                         }
                                                         else
                                                         {
-                                                            EffectsEngine.EffectBrush _terminalBrushLeft = new EffectsEngine.LinearEffectBrush(_initialBrushLeft);
-                                                            _terminalBrushLeft.start = new System.Drawing.PointF(Effects.canvas_width_center - _terminalOffset, 0);
-                                                            _terminalBrushLeft.end = new System.Drawing.PointF(Effects.canvas_width_center - _terminalOffset + width, 0);
+                                                            EffectsEngine.LinearEffectBrush _terminalBrushLeft = new EffectsEngine.LinearEffectBrush(_initialBrushLeft);
+                                                            _terminalBrushLeft.Angle = (int)angle;
 
                                                             animTrack2.SetFrame(_terminalTime, new AnimationFilledGradientRectangle(Effects.canvas_width_center - _terminalOffset, 0, _terminalOffset, Effects.canvas_height * 3, _terminalBrushLeft).SetAngle(angle));
                                                         }
@@ -523,61 +515,53 @@ private static void ImportCueprofile(this Application app, string filepath)
                                                         angle -= 90;
 
                                                         //Bottom Side
-                                                        EffectsEngine.EffectBrush _initialBrushBottom = new EffectsEngine.LinearEffectBrush(transitions);
-                                                        _initialBrushBottom.start = new System.Drawing.PointF(0, Effects.canvas_height_center);
-                                                        _initialBrushBottom.end = new System.Drawing.PointF(0, Effects.canvas_height_center - width);
+                                                        EffectsEngine.LinearEffectBrush _initialBrushBottom = new EffectsEngine.LinearEffectBrush(transitions);
+                                                        _initialBrushBottom.Angle = (int)angle;
 
                                                         animTrack.SetFrame(0.0f, new AnimationFilledGradientRectangle(0, Effects.canvas_height_center, Effects.canvas_width * 3, 0, _initialBrushBottom).SetAngle(angle));
 
                                                         if (_widthFillTime < _terminalTime)
                                                         {
-                                                            EffectsEngine.EffectBrush _fillBrushBottom = new EffectsEngine.LinearEffectBrush(_initialBrushBottom);
-                                                            _fillBrushBottom.start = new System.Drawing.PointF(0, Effects.canvas_height_center + width);
-                                                            _fillBrushBottom.end = new System.Drawing.PointF(0, Effects.canvas_height_center);
+                                                            EffectsEngine.LinearEffectBrush _fillBrushBottom = new EffectsEngine.LinearEffectBrush(_initialBrushBottom);
+                                                            _fillBrushBottom.Angle = (int)angle;
 
 
                                                             animTrack.SetFrame(_widthFillTime, new AnimationFilledGradientRectangle(0, Effects.canvas_height_center, Effects.canvas_width * 3, width, _fillBrushBottom).SetAngle(angle));
 
-                                                            EffectsEngine.EffectBrush _terminalBrushBottom = new EffectsEngine.LinearEffectBrush(_fillBrushBottom);
-                                                            _terminalBrushBottom.start = new System.Drawing.PointF(0, Effects.canvas_height_center + _terminalOffset);
-                                                            _terminalBrushBottom.end = new System.Drawing.PointF(0, Effects.canvas_height_center + _terminalOffset - width);
+                                                            EffectsEngine.LinearEffectBrush _terminalBrushBottom = new EffectsEngine.LinearEffectBrush(_fillBrushBottom);
+                                                            _terminalBrushBottom.Angle = (int)angle;
 
                                                             animTrack.SetFrame(_terminalTime, new AnimationFilledGradientRectangle(0, Effects.canvas_height_center + _terminalOffset - width, Effects.canvas_width * 3, width, _terminalBrushBottom).SetAngle(angle));
                                                         }
                                                         else
                                                         {
-                                                            EffectsEngine.EffectBrush _terminalBrushBottom = new EffectsEngine.LinearEffectBrush(_initialBrushBottom);
-                                                            _terminalBrushBottom.start = new System.Drawing.PointF(0, Effects.canvas_height_center + _terminalOffset);
-                                                            _terminalBrushBottom.end = new System.Drawing.PointF(0, Effects.canvas_height_center + _terminalOffset - width);
+                                                            EffectsEngine.LinearEffectBrush _terminalBrushBottom = new EffectsEngine.LinearEffectBrush(_initialBrushBottom);
+                                                            _terminalBrushBottom.Angle = (int)angle;
 
                                                             animTrack.SetFrame(_terminalTime, new AnimationFilledGradientRectangle(0, Effects.canvas_height_center, Effects.canvas_width * 3, _terminalOffset, _terminalBrushBottom).SetAngle(angle));
                                                         }
 
                                                         //Top Side
-                                                        EffectsEngine.EffectBrush _initialBrushtTop = new EffectsEngine.LinearEffectBrush(transitions);
-                                                        _initialBrushtTop.start = new System.Drawing.PointF(0, Effects.canvas_height_center);
-                                                        _initialBrushtTop.end = new System.Drawing.PointF(0, Effects.canvas_height_center + width);
+                                                        EffectsEngine.LinearEffectBrush _initialBrushtTop = new EffectsEngine.LinearEffectBrush(transitions);
+                                                        _initialBrushtTop.Angle = (int)angle;
 
                                                         animTrack2.SetFrame(0.0f, new AnimationFilledGradientRectangle(0, Effects.canvas_height_center, Effects.canvas_width * 3, 0, _initialBrushtTop).SetAngle(angle));
 
                                                         if (_widthFillTime < _terminalTime)
                                                         {
-                                                            EffectsEngine.EffectBrush _fillBrushTop = new EffectsEngine.LinearEffectBrush(_initialBrushtTop);
-                                                            _fillBrushTop.start = new System.Drawing.PointF(0, Effects.canvas_height_center - width);
-                                                            _fillBrushTop.end = new System.Drawing.PointF(0, Effects.canvas_height_center);
+                                                            EffectsEngine.LinearEffectBrush _fillBrushTop = new EffectsEngine.LinearEffectBrush(_initialBrushtTop);
+                                                            _fillBrushTop.Angle = (int)angle;
 
                                                             animTrack2.SetFrame(_widthFillTime, new AnimationFilledGradientRectangle(0, Effects.canvas_height_center - width, Effects.canvas_width * 3, width, _fillBrushTop).SetAngle(angle));
 
-                                                            EffectsEngine.EffectBrush _terminalBrushTop = new EffectsEngine.LinearEffectBrush(_initialBrushtTop);
-                                                            _terminalBrushTop.start = new System.Drawing.PointF(0, Effects.canvas_height_center - _terminalOffset);
-                                                            _terminalBrushTop.end = new System.Drawing.PointF(0, Effects.canvas_height_center - _terminalOffset + width);
+                                                            EffectsEngine.LinearEffectBrush _terminalBrushTop = new EffectsEngine.LinearEffectBrush(_initialBrushtTop);
+                                                            _terminalBrushTop.Angle = (int)angle;
                                                             animTrack2.SetFrame(_terminalTime, new AnimationFilledGradientRectangle(0, Effects.canvas_height_center - _terminalOffset, Effects.canvas_width * 3, width, _terminalBrushTop).SetAngle(angle));
                                                         }
                                                         else
                                                         {
-                                                            EffectsEngine.EffectBrush _terminalBrushTop = new EffectsEngine.LinearEffectBrush(_initialBrushtTop);
-                                                            _terminalBrushTop.start = new System.Drawing.PointF(0, Effects.canvas_height_center - _terminalOffset);
-                                                            _terminalBrushTop.end = new System.Drawing.PointF(0, Effects.canvas_height_center - _terminalOffset + width);
+                                                            EffectsEngine.LinearEffectBrush _terminalBrushTop = new EffectsEngine.LinearEffectBrush(_initialBrushtTop);
+                                                            _terminalBrushTop.Angle = (int)angle;
 
                                                             animTrack2.SetFrame(_terminalTime, new AnimationFilledGradientRectangle(0, Effects.canvas_height_center - _terminalOffset, Effects.canvas_width * 3, _terminalOffset, _terminalBrushTop).SetAngle(angle));
                                                         }
@@ -615,7 +599,7 @@ private static void ImportCueprofile(this Application app, string filepath)
                                             {
                                                 float duration = float.Parse(lightingInfo.Element("ptr_wrapper").Element("data").Element("base").Element("base").Element("duration").Value, CultureInfo.InvariantCulture);
 
-                                                EffectsEngine.ColorSpectrum transitions = new EffectsEngine.ColorSpectrum();
+                                                var transitions = new ColorBox.ColorSpectrum();
 
                                                 float smallest = 0.5f;
                                                 float largest = 0.5f;
diff --git a/Project-Aurora/Project-Aurora/Utils/ColorUtils.cs b/Project-Aurora/Project-Aurora/Utils/ColorUtils.cs
index f94267108..0b20066b1 100644
--- a/Project-Aurora/Project-Aurora/Utils/ColorUtils.cs
+++ b/Project-Aurora/Project-Aurora/Utils/ColorUtils.cs
@@ -497,15 +497,6 @@ public class RealColorConverter : IValueConverter {
         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) => new RealColor((System.Windows.Media.Color)value);
     }
 
-    /// <summary>
-    /// Class to convert between a <see cref="EffectsEngine.EffectBrush"></see> and a <see cref="System.Windows.Media.Brush"></see> so that it can be
-    /// used with the ColorBox gradient editor control.
-    /// </summary>
-    public class EffectBrushToBrushConverter : IValueConverter {
-        public object Convert(object value, Type targetType, object parameter, CultureInfo culture) => ((EffectsEngine.EffectBrush)value).GetMediaBrush();
-        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) => EffectsEngine.EffectBrush.GetEffectBrush((System.Windows.Media.Brush)value);
-    }
-
     public class BoolToColorConverter : IValueConverter
     {
         public static Tuple<Color, Color> TextWhiteRed = new Tuple<Color, Color>(Color.FromArgb(255, 186, 186, 186), Color.Red);
diff --git a/Project-Aurora/Project-Aurora/Utils/JSONUtils.cs b/Project-Aurora/Project-Aurora/Utils/JSONUtils.cs
index 5a2836f8a..1c24ade79 100755
--- a/Project-Aurora/Project-Aurora/Utils/JSONUtils.cs
+++ b/Project-Aurora/Project-Aurora/Utils/JSONUtils.cs
@@ -8,6 +8,7 @@
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using System.Collections.ObjectModel;
+using Aurora.EffectsEngine;
 
 namespace Aurora.Utils
 {
@@ -33,6 +34,8 @@ public override Type BindToType(string assemblyName, string typeName)
                     //Resolve typo'd AbilityLayerHandler type
                 case "Aurora.Profiles.Dota_2.Layers.Dota2AbiltiyLayerHandler":
                     return typeof(Profiles.Dota_2.Layers.Dota2AbilityLayerHandler);
+                case "Aurora.EffectsEngine.EffectBrush":
+                    return typeof(LinearEffectBrush);
                 case "Aurora.Profiles.Dota_2.Layers.Dota2HeroAbiltiyEffectsLayerHandler":
                     return typeof(Profiles.Dota_2.Layers.Dota2HeroAbilityEffectsLayerHandler);
                 case "Aurora.Profiles.Dota_2.Layers.Dota2HeroAbiltiyEffectsLayerHandlerProperties":