Fixed matrices

src/PixiEditor.ChangeableDocument/Changeables/Graph/Interfaces/IReadOnlyStructureNode.cs

@@ -1,7 +1,8 @@
 using PixiEditor.ChangeableDocument.Changeables.Animations;
-using PixiEditor.ChangeableDocument.Enums;
 using PixiEditor.DrawingApi.Core;
+using PixiEditor.DrawingApi.Core.Surfaces;
 using PixiEditor.Numerics;
+using BlendMode = PixiEditor.ChangeableDocument.Enums.BlendMode;
 
 namespace PixiEditor.ChangeableDocument.Changeables.Graph.Interfaces;
 
@@ -11,7 +12,7 @@ public interface IReadOnlyStructureNode : IReadOnlyNode, ISceneObject
     public InputProperty<bool> IsVisible { get; }
     public bool ClipToPreviousMember { get; }
     public InputProperty<BlendMode> BlendMode { get; }
-    public InputProperty<Texture?> CustomMask { get; }
+    public InputProperty<DrawingSurface?> CustomMask { get; }
     public InputProperty<bool> MaskIsVisible { get; }
     public string MemberName { get; set; }
     public RectD? GetTightBounds(KeyFrameTime frameTime);

src/PixiEditor.ChangeableDocument/Changeables/Graph/Nodes/ImageLayerNode.cs

@@ -74,7 +74,7 @@ public class ImageLayerNode : LayerNode, IReadOnlyImageNode
         }*/
     }
 
-    public override VecD ScenePosition => VecD.Zero;
+    public override VecD ScenePosition => size / 2f;
     public override VecD SceneSize => size;
 
     protected override VecI GetTargetSize(RenderContext ctx)
@@ -95,7 +95,8 @@ public class ImageLayerNode : LayerNode, IReadOnlyImageNode
     protected override void DrawWithoutFilters(SceneObjectRenderContext ctx, DrawingSurface workingSurface,
         Paint paint)
     {
-        workingSurface.Canvas.DrawSurface(renderedSurfaces[ctx.ChunkResolution].DrawingSurface, VecI.Zero, paint); 
+        VecD topLeft = size / 2f;
+        workingSurface.Canvas.DrawSurface(renderedSurfaces[ctx.ChunkResolution].DrawingSurface, -(VecI)topLeft, paint); 
     }
 
     // Draw with filters is a bit tricky since some filters sample data from chunks surrounding the chunk being drawn,

src/PixiEditor.ChangeableDocument/Changeables/Graph/Nodes/LayerNode.cs

@@ -71,6 +71,7 @@ public abstract class LayerNode : StructureNode, IReadOnlyLayerNode
             }
 
             var outputWorkingSurface = TryInitWorkingSurface(size, context.ChunkResolution, 1);
+            outputWorkingSurface.DrawingSurface.Canvas.Clear();
             
             DrawLayer(context, outputWorkingSurface.DrawingSurface, true);
 
@@ -91,11 +92,13 @@ public abstract class LayerNode : StructureNode, IReadOnlyLayerNode
                 tempSurface.DrawingSurface.Canvas.DrawSurface(outputWorkingSurface.DrawingSurface, 0, 0,
                     blendPaint);
 
-                //cached.DrawingSurface.Canvas.DrawSurface(tempSurface.DrawingSurface, VecI.Zero, blendPaint);
+                //cached.DrawingSurface.Canvas.DrawSurface(tempSurface.DrawingSurface, VecI.Zero, blendPaint);\
+                renderOnto.Canvas.DrawSurface(tempSurface.DrawingSurface, 0, 0, blendPaint);
                 return;
             }
 
             //cached.DrawingSurface.Canvas.DrawSurface(outputWorkingSurface.DrawingSurface, 0, 0, blendPaint);
+            renderOnto.Canvas.DrawSurface(outputWorkingSurface.DrawingSurface, 0, 0, blendPaint);
         }
     }
 

src/PixiEditor.ChangeableDocument/Changeables/Graph/Nodes/Shapes/Data/EllipseVectorData.cs

@@ -1,4 +1,5 @@
 using PixiEditor.ChangeableDocument.Changeables.Graph.Interfaces.Shapes;
+using PixiEditor.DrawingApi.Core.ColorsImpl;
 using PixiEditor.DrawingApi.Core.Numerics;
 using PixiEditor.DrawingApi.Core.Surfaces;
 using PixiEditor.DrawingApi.Core.Surfaces.PaintImpl;
@@ -11,7 +12,7 @@ public class EllipseVectorData : ShapeVectorData, IReadOnlyEllipseData
 {
     public VecD Radius { get; set; }
     public VecD Center { get; set; }
-    
+
     public override RectD GeometryAABB =>
         new ShapeCorners(Center, Radius * 2).AABBBounds;
 
@@ -37,42 +38,29 @@ public class EllipseVectorData : ShapeVectorData, IReadOnlyEllipseData
 
     private void Rasterize(DrawingSurface drawingSurface, ChunkResolution resolution, Paint paint, bool applyTransform)
     {
-        drawingSurface.Canvas.DrawOval(Radius, Radius, paint);
-        /*var imageSize = (VecI)(Radius * 2);
-        
-        using ChunkyImage img = new ChunkyImage((VecI)GeometryAABB.Size);
+        int saved = drawingSurface.Canvas.Save();
 
-        RectD rotated = new ShapeCorners(RectD.FromTwoPoints(VecD.Zero, imageSize)).AABBBounds;
+        if (applyTransform)
+        {
+            Matrix3X3 canvasMatrix = drawingSurface.Canvas.TotalMatrix;
 
-        VecI shift = new VecI((int)Math.Floor(-rotated.Left), (int)Math.Floor(-rotated.Top));
-        RectI drawRect = new(shift, imageSize);
-        
-        img.EnqueueDrawEllipse(drawRect, StrokeColor, FillColor, StrokeWidth);
-        img.CommitChanges();
+            Matrix3X3 final = TransformationMatrix with { TransX = 0, TransY = 0 }; 
 
-        VecI topLeft = new VecI((int)Math.Round(Center.X - Radius.X), (int)Math.Round(Center.Y - Radius.Y)) - shift;
-        topLeft = (VecI)(topLeft * resolution.Multiplier());
-        
-        RectI region = new(VecI.Zero, (VecI)GeometryAABB.Size);
+            final = canvasMatrix.Concat(final);
 
-        int num = 0;
-        if (applyTransform)
-        {
-            num = drawingSurface.Canvas.Save();
-            Matrix3X3 final = TransformationMatrix with
-            {
-                TransX = TransformationMatrix.TransX * (float)resolution.Multiplier(),
-                TransY = TransformationMatrix.TransY * (float)resolution.Multiplier()
-            };
             drawingSurface.Canvas.SetMatrix(final);
-        }
 
-        img.DrawMostUpToDateRegionOn(region, resolution, drawingSurface, topLeft, paint);
+            paint.Color = FillColor;
+            paint.Style = PaintStyle.Fill;
+            drawingSurface.Canvas.DrawOval(VecD.Zero, Radius, paint);
 
-        if (applyTransform)
-        {
-            drawingSurface.Canvas.RestoreToCount(num);
-        }*/
+            paint.Color = StrokeColor;
+            paint.Style = PaintStyle.Stroke;
+            paint.StrokeWidth = StrokeWidth;
+            drawingSurface.Canvas.DrawOval(VecD.Zero, Radius - new VecD(StrokeWidth / 2f), paint);
+        }
+
+        drawingSurface.Canvas.RestoreToCount(saved);
     }
 
     public override bool IsValid()
@@ -82,7 +70,7 @@ public class EllipseVectorData : ShapeVectorData, IReadOnlyEllipseData
 
     public override int CalculateHash()
     {
-        return HashCode.Combine(Center, Radius, StrokeColor, FillColor, StrokeWidth,  TransformationMatrix);
+        return HashCode.Combine(Center, Radius, StrokeColor, FillColor, StrokeWidth, TransformationMatrix);
     }
 
     public override int GetCacheHash()

src/PixiEditor.ChangeableDocument/Changeables/Graph/Nodes/StructureNode.cs

@@ -24,7 +24,7 @@ public abstract class StructureNode : Node, IReadOnlyStructureNode, IBackgroundI
     public InputProperty<bool> IsVisible { get; }
     public bool ClipToPreviousMember { get; set; }
     public InputProperty<BlendMode> BlendMode { get; }
-    public InputProperty<Texture?> CustomMask { get; }
+    public InputProperty<DrawingSurface?> CustomMask { get; }
     public InputProperty<bool> MaskIsVisible { get; }
     public InputProperty<Filter> Filters { get; }
     public OutputProperty<DrawingSurface?> Output { get; }
@@ -55,7 +55,7 @@ public abstract class StructureNode : Node, IReadOnlyStructureNode, IBackgroundI
         Opacity = CreateInput<float>("Opacity", "OPACITY", 1);
         IsVisible = CreateInput<bool>("IsVisible", "IS_VISIBLE", true);
         BlendMode = CreateInput("BlendMode", "BLEND_MODE", Enums.BlendMode.Normal);
-        CustomMask = CreateInput<Texture?>("Mask", "MASK", null);
+        CustomMask = CreateInput<DrawingSurface?>("Mask", "MASK", null);
         MaskIsVisible = CreateInput<bool>("MaskIsVisible", "MASK_IS_VISIBLE", true);
         Filters = CreateInput<Filter>(nameof(Filters), "FILTERS", null);
 
@@ -75,7 +75,7 @@ public abstract class StructureNode : Node, IReadOnlyStructureNode, IBackgroundI
 
         int savedNum = sceneSurface.Canvas.Save();  
         
-        sceneSurface.Canvas.ClipRect(RectD.Create((VecI)ScenePosition.Floor(), (VecI)SceneSize.Ceiling()));
+        sceneSurface.Canvas.ClipRect(new RectD(ScenePosition - (SceneSize / 2f), SceneSize));
         sceneSurface.Canvas.Translate((float)ScenePosition.X, (float)ScenePosition.Y);
 
         SceneObjectRenderContext renderObjectContext = new SceneObjectRenderContext(sceneSurface, localBounds,
@@ -96,7 +96,7 @@ public abstract class StructureNode : Node, IReadOnlyStructureNode, IBackgroundI
         {
             if (CustomMask.Value != null)
             {
-                surface.Canvas.DrawSurface(CustomMask.Value.DrawingSurface, 0, 0, maskPaint);
+                surface.Canvas.DrawSurface(CustomMask.Value, 0, 0, maskPaint);
             }
             else if (EmbeddedMask != null)
             {

src/PixiEditor.ChangeableDocument/Changeables/Graph/Nodes/VectorLayerNode.cs

@@ -44,7 +44,7 @@ public class VectorLayerNode : LayerNode, ITransformableObject, IReadOnlyVectorN
         Output.Value = context.TargetSurface;
     }
 
-    public override VecD ScenePosition => ShapeData?.TransformedAABB.TopLeft ?? VecD.Zero;
+    public override VecD ScenePosition => ShapeData?.TransformedAABB.Center ?? VecD.Zero;
     public override VecD SceneSize => ShapeData?.TransformedAABB.Size ?? VecD.Zero;
 
     protected override VecI GetTargetSize(RenderContext ctx)

src/PixiEditor.DrawingApi.Core/Bridge/Operations/ICanvasImplementation.cs

@@ -43,5 +43,6 @@ namespace PixiEditor.DrawingApi.Core.Bridge.Operations
         public void DrawPaint(IntPtr objectPointer, Paint paint);
         public void DrawImage(IntPtr objectPointer, Image image, float x, float y, Paint paint);
         public void DrawRoundRect(IntPtr objectPointer, float x, float y, float width, float height, float radiusX, float radiusY, Paint paint);
+        public Matrix3X3 GetTotalMatrix(IntPtr objectPointer);
     }
 }

src/PixiEditor.DrawingApi.Core/Numerics/Matrix3X3.cs

@@ -335,7 +335,6 @@ public struct Matrix3X3 : IEquatable<Matrix3X3>
 
     public readonly bool IsInvertible => TryInvert(out _);
 
-
     /// <param name="inverse">The destination value to store the inverted matrix if the matrix can be inverted.</param>
     /// <summary>Attempts to invert the matrix, if possible the inverse matrix contains the result.</summary>
     /// <returns>

src/PixiEditor.DrawingApi.Core/Surfaces/Canvas.cs

@@ -14,6 +14,7 @@ namespace PixiEditor.DrawingApi.Core.Surfaces
     public class Canvas : NativeObject
     {
         public override object Native => DrawingBackendApi.Current.CanvasImplementation.GetNativeCanvas(ObjectPointer);
+        public Matrix3X3 TotalMatrix => DrawingBackendApi.Current.CanvasImplementation.GetTotalMatrix(ObjectPointer);
 
         public event SurfaceChangedEventHandler? Changed;
 
@@ -37,9 +38,9 @@ namespace PixiEditor.DrawingApi.Core.Surfaces
 
         public void DrawSurface(DrawingSurface original, float x, float y) => DrawSurface(original, x, y, null);
 
-        public void DrawSurface(DrawingSurface surfaceToDraw, VecI size, Paint paint)
+        public void DrawSurface(DrawingSurface surfaceToDraw, VecI position, Paint paint)
         {
-            DrawSurface(surfaceToDraw, size.X, size.Y, paint);
+            DrawSurface(surfaceToDraw, position.X, position.Y, paint);
         }
 
         public void DrawImage(Image image, float x, float y) =>
@@ -195,9 +196,9 @@ namespace PixiEditor.DrawingApi.Core.Surfaces
             Changed?.Invoke(null);
         }
 
-        public void RotateRadians(float dataAngle, float centerX, float centerY)
+        public void RotateRadians(float radians, float centerX, float centerY)
         {
-            DrawingBackendApi.Current.CanvasImplementation.RotateRadians(ObjectPointer, dataAngle, centerX, centerY);
+            DrawingBackendApi.Current.CanvasImplementation.RotateRadians(ObjectPointer, radians, centerX, centerY);
         }
 
         public void RotateDegrees(float degrees, float centerX, float centerY)

src/PixiEditor.DrawingApi.Skia/Implementations/SkiaCanvasImplementation.cs

@@ -82,6 +82,11 @@ namespace PixiEditor.DrawingApi.Skia.Implementations
                 x, y, width, height, radiusX, radiusY, _paintImpl[paint.ObjectPointer]);
         }
 
+        public Matrix3X3 GetTotalMatrix(IntPtr objectPointer)
+        {
+            return ManagedInstances[objectPointer].TotalMatrix.ToMatrix3X3();
+        }
+
         public Matrix3X3 GetActiveMatrix(IntPtr objectPointer)
         {
             return ManagedInstances[objectPointer].TotalMatrix.ToMatrix3X3();