Merge pull request #40 from Aurora-RGB/master

master -> dev

Author: Aytackydln

Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationCircle.cs

@@ -9,8 +9,8 @@ public class AnimationCircle : AnimationFrame
         [Newtonsoft.Json.JsonProperty]
         internal float _radius = 0.0f;
 
-        public float Radius { get { return _radius; } }
-        public PointF Center { get { return _center; } }
+        public float Radius => _radius;
+        public PointF Center => _center;
 
         public AnimationFrame SetRadius(float radius)
         {
@@ -87,21 +87,22 @@ public AnimationCircle(float x, float y, float radius, Color color, int width =
 
         public override void Draw(Graphics g)
         {
-            if (_pen == null || _invalidated)
+            if (_invalidated)
             {
                 _pen = new Pen(_color);
                 _pen.Width = _width;
-                _pen.Alignment = System.Drawing.Drawing2D.PenAlignment.Center;
-                _pen.ScaleTransform(Scale, Scale);
+                //_pen.Alignment = System.Drawing.Drawing2D.PenAlignment.Center;
+                //_pen.ScaleTransform(Scale, Scale);
 
                 virtUpdate();
                 _invalidated = false;
             }
 
-            if(_scaledDimension.Width > 1 && _scaledDimension.Height > 1)
+            if(_dimension.Width > 1 && _dimension.Height > 1)
             {
                 g.ResetTransform();
-                g.DrawEllipse(_pen, _scaledDimension);
+                g.Transform = _transformationMatrix;
+                g.DrawEllipse(_pen, _dimension);
             }
         }
 

Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationEllipse.cs

@@ -127,7 +127,7 @@ public override void Draw(Graphics g)
             }
 
             g.ResetTransform();
-            g.DrawEllipse(_pen, _scaledDimension);
+            g.DrawEllipse(_pen, _dimension);
         }
 
         public override AnimationFrame BlendWith(AnimationFrame otherAnim, double amount)

Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationFilledCircle.cs

@@ -37,7 +37,7 @@ public override void Draw(Graphics g)
             }
 
             g.ResetTransform();
-            g.FillEllipse(_brush, _scaledDimension);
+            g.FillEllipse(_brush, _dimension);
         }
 
         public override AnimationFrame BlendWith(AnimationFrame otherAnim, double amount)

Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationFilledGradientRectangle.cs

@@ -9,9 +9,9 @@ public class AnimationFilledGradientRectangle : AnimationFilledRectangle
         [Newtonsoft.Json.JsonProperty]
         internal EffectBrush _gradientBrush;
 
-        public EffectBrush GradientBrush { get { return _gradientBrush; } }
+        public EffectBrush GradientBrush => _gradientBrush;
 
-        public AnimationFilledGradientRectangle() : base()
+        public AnimationFilledGradientRectangle()
         {
         }
 
@@ -37,10 +37,16 @@ public AnimationFilledGradientRectangle(float x, float y, float rect_width, floa
 
         public override void Draw(Graphics g)
         {
-            Matrix originalMatrix = g.Transform;
+            if (_invalidated)
+            {
+                virtUpdate();
+                _invalidated = false;
+            }
+            
+            g.ResetTransform();
             g.Transform = _transformationMatrix;
-            g.FillRectangle(_gradientBrush.GetDrawingBrush(), _scaledDimension);
-            g.Transform = originalMatrix;
+            //g.FillRectangle(_gradientBrush.GetDrawingBrush(), _scaledDimension);
+            g.FillRectangle(_gradientBrush.GetDrawingBrush(), _dimension);
         }
 
         public override AnimationFrame BlendWith(AnimationFrame otherAnim, double amount)

Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationFilledRectangle.cs

@@ -6,7 +6,7 @@ namespace Aurora.EffectsEngine.Animations
 {
     public class AnimationFilledRectangle : AnimationRectangle
     {
-        public AnimationFilledRectangle() : base()
+        public AnimationFilledRectangle()
         {
         }
 
@@ -24,16 +24,19 @@ public AnimationFilledRectangle(float x, float y, float rect_width, float rect_h
 
         public override void Draw(Graphics g)
         {
-            if (_brush == null || _invalidated)
+            if (_invalidated)
             {
-                _brush = new SolidBrush(_color);
+                _pen = new Pen(_color);
+                _pen.Width = _width;
+                _pen.Alignment = PenAlignment.Center;
+
                 virtUpdate();
                 _invalidated = false;
             }
 
             g.ResetTransform();
             g.Transform = _transformationMatrix;
-            g.FillRectangle(_brush, _scaledDimension);
+            g.FillRectangle(_brush, _dimension);
         }
 
         public override AnimationFrame BlendWith(AnimationFrame otherAnim, double amount)

Project-Aurora/Project-Aurora/EffectsEngine/Animations/AnimationFrame.cs

@@ -2,8 +2,6 @@
 using System.ComponentModel;
 using System.Drawing;
 using System.Drawing.Drawing2D;
-using System.Threading;
-using System.Windows;
 
 namespace Aurora.EffectsEngine.Animations
 {
@@ -66,20 +64,20 @@ public class AnimationFrame
         [Newtonsoft.Json.JsonProperty]
         internal float _duration;
         internal Pen _pen = null;
-        internal Brush _brush = null;
+        internal Brush _brush;
         internal bool _invalidated = true;
         [Newtonsoft.Json.JsonProperty]
         internal AnimationFrameTransitionType _transitionType = AnimationFrameTransitionType.Linear;
         [Newtonsoft.Json.JsonProperty]
-        internal float _angle = 0.0f;
+        internal float _angle;
         [Newtonsoft.Json.JsonProperty]
-        protected PointF _center;
+        protected PointF _center = PointF.Empty;
 
 
         protected float _scale = 1.0f;
-        protected PointF _offset = default(PointF);
+        protected PointF _offset;
 
-        protected RectangleF _scaledDimension;
+        //protected RectangleF _scaledDimension;
         internal Matrix _transformationMatrix;
 
         public float Scale
@@ -94,39 +92,16 @@ public float Scale
                 }
             }
         }
-        public PointF Offset
-        {
-            get { return _offset; }
-            set
-            {
-                if (_offset != value)
-                {
-                    _offset = value;
-                    _invalidated = true;
-                }
-            }
-        }
-        public PointF RotatePoint
-        {
-            get { return _center; }
-            set
-            {
-                if (_center != value)
-                {
-                    _center = value;
-                    _invalidated = true;
-                }
-            }
-        }
-        public Matrix TransformationMatrix { get { return _transformationMatrix; } }
-        public RectangleF ScaledDimension { get { return _scaledDimension; } }
+        public PointF Offset => _offset;
+
+        public PointF RotatePoint => _center;
 
-        public Color Color { get { return _color; } }
-        public RectangleF Dimension { get { return _dimension; } }
-        public int Width { get { return _width; } }
-        public float Duration { get { return _duration; } }
-        public AnimationFrameTransitionType TransitionType { get { return _transitionType; } }
-        public float Angle { get { return _angle; } }
+        public Color Color => _color;
+        public RectangleF Dimension => _dimension;
+        public int Width => _width;
+        public float Duration => _duration;
+        public AnimationFrameTransitionType TransitionType => _transitionType;
+        public float Angle => _angle;
 
         public AnimationFrame()
         {
@@ -175,14 +150,18 @@ void updateMatrices()
         {
             _transformationMatrix = new Matrix();
 
-            _scaledDimension = new RectangleF(_dimension.X * _scale, _dimension.Y * _scale, _dimension.Width * _scale, _dimension.Height * _scale);
-            _scaledDimension.Offset(_offset);
-
-            if(_center == null) 
-                _center = new PointF(_scaledDimension.X + _dimension.Width/2, _scaledDimension.Y + _scaledDimension.Height/2);
+            //_scaledDimension = new RectangleF(_dimension.X * _scale, _dimension.Y * _scale, _dimension.Width * _scale, _dimension.Height * _scale);
+            //_scaledDimension.Offset(_offset.X * _scale, _offset.Y * _scale);
 
+            if (_center.Equals(PointF.Empty) || float.IsNaN(_center.X))
+            {
+                _center = new PointF(_dimension.Width/2, _dimension.Height/2);
+            }
+            
             _transformationMatrix.RotateAt(-_angle, _center, MatrixOrder.Append);
-            _transformationMatrix.Translate(-_scaledDimension.Width / 2f, -_scaledDimension.Height / 2f);
+            _transformationMatrix.Scale(_scale, _scale);
+            
+            _transformationMatrix.Translate(-_offset.X, -_offset.Y, MatrixOrder.Append);
 
             _invalidated = false;
         }
@@ -196,15 +175,6 @@ public void SetOffset(PointF offset)
             }
         }
 
-        public void SetScale(float scale)
-        {
-            if (_scale != scale)
-            {
-                _scale = scale;
-                _invalidated = true;
-            }
-        }
-
         public AnimationFrame SetColor(Color color)
         {
             _color = color;
@@ -267,21 +237,30 @@ public virtual AnimationFrame BlendWith(AnimationFrame otherAnim, double amount)
                 CalculateNewValue(_dimension.Height, otherAnim._dimension.Height, amount)
                 );
 
-            PointF newRotatingPoint = new PointF(CalculateNewValue(_center.X, otherAnim._center.X, amount),
+            PointF newRotatingPoint = new PointF(
+                CalculateNewValue(_center.X, otherAnim._center.X, amount),
                 CalculateNewValue(_center.Y, otherAnim._center.Y, amount)
                 );
 
+            PointF newOffset = new PointF(
+                CalculateNewValue(_offset.X, otherAnim._offset.X, amount),
+                CalculateNewValue(_offset.Y, otherAnim._offset.Y, amount)
+            );
+
             float newAngle = CalculateNewValue(_angle, otherAnim._angle, amount);
             float newScale = CalculateNewValue(_scale, otherAnim._scale, amount);
             int newWidth = CalculateNewValue(_width, otherAnim._width, amount);
 
             AnimationFrame newframe = new AnimationFrame();
             newframe._dimension = newrect;
+            newframe._center = newRotatingPoint;
+            newframe._offset = newOffset;
 
             newframe._angle = newAngle;
             newframe._scale = newScale;
             newframe._width = newWidth;
             newframe._color = Utils.ColorUtils.BlendColors(_color, otherAnim._color, amount);
+            
 
             return newframe;
         }
@@ -333,16 +312,14 @@ internal float CalculateNewValue(float first, float second, double amount)
         {
             if (first == second)
                 return first;
-            else
-                return (float)(first * (1.0 - amount) + second * (amount));
+            return (float)(first * (1.0 - amount) + second * (amount));
         }
 
         internal double CalculateNewValue(double first, double second, double amount)
         {
             if (first == second)
                 return first;
-            else
-                return (double)(first * (1.0 - amount) + second * (amount));
+            return first * (1.0 - amount) + second * (amount);
         }
 
         internal int CalculateNewValue(int first, int second, double amount)