More native objects implemented

src/ChunkyImageLib/ChunkyImageLib.csproj

@@ -10,7 +10,7 @@
 
   <ItemGroup>
     <PackageReference Include="ComputeSharp.Core" Version="2.0.0-alpha.27" />
-    <PackageReference Include="ComputeSharp.Dynamic" Version="2.0.0-alpha.27" />
+    <PackageReference Include="ComputeSharp.Dynamic" Version="2.0.0-alpha.28" />
     <PackageReference Include="OneOf" Version="3.0.216" />
   </ItemGroup>
 

src/PixiEditor.DrawingApi.Core/Bridge/IDrawingBackend.cs

@@ -8,7 +8,7 @@ namespace PixiEditor.DrawingApi.Core.Bridge
         public void Setup();
         public IColorImplementation ColorImplementation { get; }
         public IImageImplementation ImageImplementation { get; }
-        public ICanvasOperations CanvasOperations { get; }
+        public ICanvasImplementation CanvasImplementation { get; }
         public IPaintImplementation PaintImplementation { get; }
         public IVectorPathImplementation PathImplementation { get; }
         public IMatrix3X3Implementation MatrixImplementation { get; }

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

@@ -0,0 +1,36 @@
+using System;
+using PixiEditor.DrawingApi.Core.ColorsImpl;
+using PixiEditor.DrawingApi.Core.Numerics;
+using PixiEditor.DrawingApi.Core.Surface;
+using PixiEditor.DrawingApi.Core.Surface.ImageData;
+using PixiEditor.DrawingApi.Core.Surface.Vector;
+
+namespace PixiEditor.DrawingApi.Core.Bridge.Operations
+{
+    public interface ICanvasImplementation
+    {
+        public void DrawPixel(IntPtr objPtr, int posX, int posY, Paint drawingPaint);
+        public void DrawSurface(IntPtr objPtr, DrawingSurface drawingSurface, int x, int y, Paint? paint);
+        public void DrawImage(IntPtr objPtr, Image image, int x, int y);
+        public int Save(IntPtr objPtr);
+        public void Restore(IntPtr objPtr);
+        public void Scale(IntPtr objPtr, float sizeX, float sizeY);
+        public void Translate(IntPtr objPtr, float translationX, float translationY);
+        public void DrawPath(IntPtr objPtr, VectorPath path, Paint paint);
+        public void DrawPoint(IntPtr objPtr, VecI pos, Paint paint);
+        public void DrawPoints(IntPtr objPtr, PointMode pointMode, Point[] points, Paint paint);
+        public void DrawRect(IntPtr objPtr, int x, int y, int width, int height, Paint paint);
+        public void ClipPath(IntPtr objPtr, VectorPath clipPath, ClipOperation clipOperation, bool antialias);
+        public void ClipRect(IntPtr objPtr, RectD rect, ClipOperation clipOperation);
+        public void Clear(IntPtr objPtr);
+        public void Clear(IntPtr objPtr, Color color);
+        public void DrawLine(IntPtr objPtr, VecI from, VecI to, Paint paint);
+        public void Flush(IntPtr objPtr);
+        public void SetMatrix(IntPtr objPtr, Matrix3X3 finalMatrix);
+        public void RestoreToCount(IntPtr objPtr, int count);
+        public void DrawColor(IntPtr objPtr, Color color, BlendMode paintBlendMode);
+        public void RotateRadians(IntPtr objPtr, float radians, float centerX, float centerY);
+        public void DrawImage(IntPtr objPtr, Image image, RectD rect, Paint paint);
+        public void DrawBitmap(IntPtr objPtr, Bitmap bitmap, int x, int y);
+    }
+}

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

@@ -1,35 +0,0 @@
-using PixiEditor.DrawingApi.Core.ColorsImpl;
-using PixiEditor.DrawingApi.Core.Numerics;
-using PixiEditor.DrawingApi.Core.Surface;
-using PixiEditor.DrawingApi.Core.Surface.ImageData;
-using PixiEditor.DrawingApi.Core.Surface.Vector;
-
-namespace PixiEditor.DrawingApi.Core.Bridge.Operations
-{
-    public interface ICanvasOperations
-    {
-        public void DrawPixel(int posX, int posY, Paint drawingPaint);
-        public void DrawSurface(DrawingSurface drawingSurface, int x, int y, Paint? paint);
-        public void DrawImage(Image image, int x, int y);
-        public int Save();
-        public void Restore();
-        public void Scale(float sizeX, float sizeY);
-        public void Translate(float translationX, float translationY);
-        public void DrawPath(VectorPath path, Paint paint);
-        public void DrawPoint(VecI pos, Paint paint);
-        public void DrawPoints(PointMode pointMode, Point[] points, Paint paint);
-        public void DrawRect(int x, int y, int width, int height, Paint paint);
-        public void ClipPath(VectorPath clipPath, ClipOperation clipOperation, bool antialias);
-        public void ClipRect(RectD rect, ClipOperation clipOperation);
-        public void Clear();
-        public void Clear(Color color);
-        public void DrawLine(VecI from, VecI to, Paint paint);
-        public void Flush();
-        public void SetMatrix(Matrix3X3 finalMatrix);
-        public void RestoreToCount(int count);
-        public void DrawColor(Color color, BlendMode paintBlendMode);
-        public void RotateRadians(float dataAngle, float centerX, float centerY);
-        public void DrawImage(Image image, RectD rect, Paint paint);
-        public void DrawBitmap(Bitmap bitmap, int x, int y);
-    }
-}

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

@@ -9,10 +9,10 @@ namespace PixiEditor.DrawingApi.Core.Surface
     public class Canvas
     {
         public void DrawPixel(VecI position, Paint drawingPaint) => DrawPixel(position.X, position.Y, drawingPaint);
-        public void DrawPixel(int posX, int posY, Paint drawingPaint) => DrawingBackendApi.Current.CanvasOperations.DrawPixel(posX, posY, drawingPaint);
+        public void DrawPixel(int posX, int posY, Paint drawingPaint) => DrawingBackendApi.Current.CanvasImplementation.DrawPixel(posX, posY, drawingPaint);
 
         public void DrawSurface(DrawingSurface original, int x, int y, Paint? paint) 
-            => DrawingBackendApi.Current.CanvasOperations.DrawSurface(original, x, y, paint);
+            => DrawingBackendApi.Current.CanvasImplementation.DrawSurface(original, x, y, paint);
         
         public void DrawSurface(DrawingSurface original, int x, int y) => DrawSurface(original, x, y, null);
         
@@ -21,30 +21,30 @@ namespace PixiEditor.DrawingApi.Core.Surface
             DrawSurface(surfaceToDraw, size.X, size.Y, paint);
         }
 
-        public void DrawImage(Image image, int x, int y) => DrawingBackendApi.Current.CanvasOperations.DrawImage(image, x, y);
+        public void DrawImage(Image image, int x, int y) => DrawingBackendApi.Current.CanvasImplementation.DrawImage(image, x, y);
         
-        public void DrawImage(Image image, RectD rect, Paint paint) => DrawingBackendApi.Current.CanvasOperations.DrawImage(image, rect, paint);
+        public void DrawImage(Image image, RectD rect, Paint paint) => DrawingBackendApi.Current.CanvasImplementation.DrawImage(image, rect, paint);
 
         public int Save()
         {
-            return DrawingBackendApi.Current.CanvasOperations.Save();
+            return DrawingBackendApi.Current.CanvasImplementation.Save();
         }
 
         public void Restore()
         {
-            DrawingBackendApi.Current.CanvasOperations.Restore();
+            DrawingBackendApi.Current.CanvasImplementation.Restore();
         }
         
-        public void Scale(float s) => DrawingBackendApi.Current.CanvasOperations.Scale(s, s);
+        public void Scale(float s) => DrawingBackendApi.Current.CanvasImplementation.Scale(s, s);
 
         /// <param name="sx">The amount to scale in the x-direction.</param>
         /// <param name="sy">The amount to scale in the y-direction.</param>
         /// <summary>Pre-concatenates the current matrix with the specified scale.</summary>
-        public void Scale(float sx, float sy) => DrawingBackendApi.Current.CanvasOperations.Scale(sx, sy);
+        public void Scale(float sx, float sy) => DrawingBackendApi.Current.CanvasImplementation.Scale(sx, sy);
 
         /// <param name="size">The amount to scale.</param>
         /// <summary>Pre-concatenates the current matrix with the specified scale.</summary>
-        public void Scale(Point size) => DrawingBackendApi.Current.CanvasOperations.Scale(size.X, size.Y);
+        public void Scale(Point size) => DrawingBackendApi.Current.CanvasImplementation.Scale(size.X, size.Y);
 
         /// <param name="sx">The amount to scale in the x-direction.</param>
         /// <param name="sy">The amount to scale in the y-direction.</param>
@@ -60,29 +60,29 @@ namespace PixiEditor.DrawingApi.Core.Surface
 
         public void Translate(float translationX, float translationY)
         {
-            DrawingBackendApi.Current.CanvasOperations.Translate(translationX, translationY);
+            DrawingBackendApi.Current.CanvasImplementation.Translate(translationX, translationY);
         }
         
         public void Translate(VecD vector) => Translate((float)vector.X, (float)vector.Y);
 
         public void DrawPath(VectorPath path, Paint paint)
         {
-            DrawingBackendApi.Current.CanvasOperations.DrawPath(path, paint);
+            DrawingBackendApi.Current.CanvasImplementation.DrawPath(path, paint);
         }
         
         public void DrawPoint(VecI pos, Paint paint)
         {
-            DrawingBackendApi.Current.CanvasOperations.DrawPoint(pos, paint);
+            DrawingBackendApi.Current.CanvasImplementation.DrawPoint(pos, paint);
         }
 
         public void DrawPoints(PointMode pointMode, Point[] points, Paint paint)
         {
-            DrawingBackendApi.Current.CanvasOperations.DrawPoints(pointMode, points, paint);
+            DrawingBackendApi.Current.CanvasImplementation.DrawPoints(pointMode, points, paint);
         }
 
         public void DrawRect(int x, int y, int width, int height, Paint paint)
         {
-            DrawingBackendApi.Current.CanvasOperations.DrawRect(x, y, width, height, paint);
+            DrawingBackendApi.Current.CanvasImplementation.DrawRect(x, y, width, height, paint);
         }
         
         public void DrawRect(RectI rect, Paint paint) => DrawRect(rect.X, rect.Y, rect.Width, rect.Height, paint);
@@ -94,57 +94,57 @@ namespace PixiEditor.DrawingApi.Core.Surface
         
         public void ClipPath(VectorPath clipPath, ClipOperation clipOperation, bool antialias)
         {
-            DrawingBackendApi.Current.CanvasOperations.ClipPath(clipPath, clipOperation, antialias);
+            DrawingBackendApi.Current.CanvasImplementation.ClipPath(clipPath, clipOperation, antialias);
         }
 
         public void ClipRect(RectD rect, ClipOperation clipOperation = ClipOperation.Intersect)
         {
-            DrawingBackendApi.Current.CanvasOperations.ClipRect(rect, clipOperation);
+            DrawingBackendApi.Current.CanvasImplementation.ClipRect(rect, clipOperation);
         }
 
         public void Clear()
         {
-            DrawingBackendApi.Current.CanvasOperations.Clear();
+            DrawingBackendApi.Current.CanvasImplementation.Clear();
         }
         
         public void Clear(Color color)
         {
-            DrawingBackendApi.Current.CanvasOperations.Clear(color);
+            DrawingBackendApi.Current.CanvasImplementation.Clear(color);
         }
 
         public void DrawLine(VecI from, VecI to, Paint paint)
         {
-            DrawingBackendApi.Current.CanvasOperations.DrawLine(from, to, paint);
+            DrawingBackendApi.Current.CanvasImplementation.DrawLine(from, to, paint);
         }
 
         public void Flush()
         {
-            DrawingBackendApi.Current.CanvasOperations.Flush();
+            DrawingBackendApi.Current.CanvasImplementation.Flush();
         }
 
         public void SetMatrix(Matrix3X3 finalMatrix)
         {
-            DrawingBackendApi.Current.CanvasOperations.SetMatrix(finalMatrix);
+            DrawingBackendApi.Current.CanvasImplementation.SetMatrix(finalMatrix);
         }
 
         public void RestoreToCount(int count)
         {
-            DrawingBackendApi.Current.CanvasOperations.RestoreToCount(count);
+            DrawingBackendApi.Current.CanvasImplementation.RestoreToCount(count);
         }
 
         public void DrawColor(Color color, BlendMode paintBlendMode)
         {
-            DrawingBackendApi.Current.CanvasOperations.DrawColor(color, paintBlendMode);
+            DrawingBackendApi.Current.CanvasImplementation.DrawColor(color, paintBlendMode);
         }
 
         public void RotateRadians(float dataAngle, float centerX, float centerY)
         {
-            DrawingBackendApi.Current.CanvasOperations.RotateRadians(dataAngle, centerX, centerY);
+            DrawingBackendApi.Current.CanvasImplementation.RotateRadians(dataAngle, centerX, centerY);
         }
 
         public void DrawBitmap(Bitmap bitmap, int x, int y)
         {
-            DrawingBackendApi.Current.CanvasOperations.DrawBitmap(bitmap, x, y);
+            DrawingBackendApi.Current.CanvasImplementation.DrawBitmap(bitmap, x, y);
         }
     }
 }

src/PixiEditor.DrawingApi.Core/Surface/PaintImpl/Paint.cs

@@ -18,7 +18,7 @@ namespace PixiEditor.DrawingApi.Core.Surface
         public float StrokeWidth { get; set; }
         
         
-        internal Paint(IntPtr objPtr) : base(objPtr)
+        public Paint(IntPtr objPtr) : base(objPtr)
         {
         }
         

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

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using SkiaSharp;
+
+namespace PixiEditor.DrawingApi.Skia.Implementations
+{
+    public abstract class SkObjectImplementation<T> where T : SKObject
+    {
+        internal Dictionary<IntPtr, T> ManagedInstances = new Dictionary<IntPtr, T>();
+        
+        public virtual void DisposeObject(IntPtr objPtr)
+        {
+            ManagedInstances[objPtr].Dispose();
+            ManagedInstances.Remove(objPtr);
+        }
+        
+        public T this[IntPtr objPtr]
+        {
+            get => ManagedInstances[objPtr];
+            set => ManagedInstances[objPtr] = value;
+        }
+    }
+}

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

@@ -0,0 +1,160 @@
+using System;
+using PixiEditor.DrawingApi.Core.Bridge.Operations;
+using PixiEditor.DrawingApi.Core.ColorsImpl;
+using PixiEditor.DrawingApi.Core.Numerics;
+using PixiEditor.DrawingApi.Core.Surface;
+using PixiEditor.DrawingApi.Core.Surface.ImageData;
+using PixiEditor.DrawingApi.Core.Surface.Vector;
+using SkiaSharp;
+
+namespace PixiEditor.DrawingApi.Skia.Implementations
+{
+    public sealed class SkiaCanvasImplementation : SkObjectImplementation<SKCanvas>, ICanvasImplementation
+    {
+        private readonly SkObjectImplementation<SKPaint> _paintImpl;
+        private readonly SkObjectImplementation<SKSurface> _surfaceImpl;
+        private readonly SkObjectImplementation<SKImage> _imageImpl;
+        private readonly SkObjectImplementation<SKBitmap> _bitmapImpl;
+        private readonly SkObjectImplementation<SKPath> _pathImpl;
+
+        public SkiaCanvasImplementation(SkObjectImplementation<SKPaint> paintImpl)
+        {
+            _paintImpl = paintImpl;
+        }
+        
+        public void DrawPixel(IntPtr objectPointer, int posX, int posY, Paint drawingPaint)
+        {
+            ManagedInstances[objectPointer].DrawPoint(
+                posX, 
+                posY, 
+                _paintImpl.ManagedInstances[drawingPaint.ObjectPointer]);
+        }
+
+        public void DrawSurface(IntPtr objPtr, DrawingSurface drawingSurface, int x, int y, Paint? paint)
+        {
+            ManagedInstances[objPtr]
+                .DrawSurface(
+                    _surfaceImpl.ManagedInstances[drawingSurface.ObjectPointer],
+                    x, y, 
+                    paint != null ? _paintImpl.ManagedInstances[paint.ObjectPointer] : null);
+        }
+
+        public void DrawImage(IntPtr objPtr, Image image, int x, int y)
+        {
+            ManagedInstances[objPtr]
+                .DrawImage(
+                    _imageImpl.ManagedInstances[image.ObjectPointer], x, y);
+        }
+
+        public int Save(IntPtr objPtr)
+        {
+            return ManagedInstances[objPtr].Save();
+        }
+
+        public void Restore(IntPtr objPtr)
+        {
+            ManagedInstances[objPtr].Restore();
+        }
+
+        public void Scale(IntPtr objPtr, float sizeX, float sizeY)
+        {
+            ManagedInstances[objPtr].Scale(sizeX, sizeY);
+        }
+
+        public void Translate(IntPtr objPtr, float translationX, float translationY)
+        {
+            ManagedInstances[objPtr].Scale(translationX, translationY);
+        }
+
+        public void DrawPath(IntPtr objPtr, VectorPath path, Paint paint)
+        {
+            ManagedInstances[objPtr].DrawPath(
+                _pathImpl[path.ObjectPointer], 
+                _paintImpl[paint.ObjectPointer]);
+        }
+
+        public void DrawPoint(IntPtr objPtr, VecI pos, Paint paint)
+        {
+            ManagedInstances[objPtr].DrawPoint(
+                pos.X, 
+                pos.Y, 
+                _paintImpl[paint.ObjectPointer]);
+        }
+
+        public void DrawPoints(IntPtr objPtr, PointMode pointMode, Point[] points, Paint paint)
+        {
+            ManagedInstances[objPtr].DrawPoints(
+                (SKPointMode)pointMode,
+                points,
+                _paintImpl[paint.ObjectPointer]);
+        }
+
+        public void DrawRect(IntPtr objPtr, int x, int y, int width, int height, Paint paint)
+        {
+            ManagedInstances[objPtr].DrawRect(x, y, width, height, _paintImpl[paint.ObjectPointer]);
+        }
+
+        public void ClipPath(IntPtr objPtr, VectorPath clipPath, ClipOperation clipOperation, bool antialias)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void ClipRect(IntPtr objPtr, RectD rect, ClipOperation clipOperation)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Clear(IntPtr objPtr)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Clear(IntPtr objPtr, Color color)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void DrawLine(IntPtr objPtr, VecI from, VecI to, Paint paint)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Flush(IntPtr objPtr)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetMatrix(IntPtr objPtr, Matrix3X3 finalMatrix)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void RestoreToCount(IntPtr objPtr, int count)
+        {
+            ManagedInstances[objPtr].RestoreToCount(count);
+        }
+
+        public void DrawColor(IntPtr objPtr, Color color, BlendMode paintBlendMode)
+        {
+            ManagedInstances[objPtr].DrawColor(color, (SKBlendMode)paintBlendMode);
+        }
+
+        public void RotateRadians(IntPtr objPtr, float radians, float centerX, float centerY)
+        {
+            ManagedInstances[objPtr].RotateRadians(radians, centerX, centerY);
+        }
+
+        public void DrawImage(IntPtr objPtr, Image image, RectD rect, Paint paint)
+        {
+            ManagedInstances[objPtr].DrawImage(
+                _imageImpl[image.ObjectPointer],
+                rect, 
+                _paintImpl[paint.ObjectPointer]);
+        }
+
+        public void DrawBitmap(IntPtr objPtr, Bitmap bitmap, int x, int y)
+        {
+            ManagedInstances[objPtr].DrawBitmap(_bitmapImpl[bitmap.ObjectPointer], x, y);
+        }
+    }
+}

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

@@ -7,13 +7,11 @@ using SkiaSharp;
 
 namespace PixiEditor.DrawingApi.Skia.Implementations
 {
-    public class SkiaImageImplementation : IImageImplementation
+    public class SkiaImageImplementation : SkObjectImplementation<SKImage>, IImageImplementation
     {
-        internal readonly Dictionary<IntPtr, SKImage> ManagedImages = new Dictionary<IntPtr, SKImage>();
-
-        private readonly SkiaImgDataImplementation _imgImplementation;
+        private readonly SkObjectImplementation<SKData> _imgImplementation;
         
-        public SkiaImageImplementation(SkiaImgDataImplementation imgDataImplementation)
+        public SkiaImageImplementation(SkObjectImplementation<SKData> imgDataImplementation)
         {
             _imgImplementation = imgDataImplementation;
         }
@@ -25,14 +23,14 @@ namespace PixiEditor.DrawingApi.Skia.Implementations
 
         public void DisposeImage(Image image)
         {
-            ManagedImages[image.ObjectPointer].Dispose();
-            ManagedImages.Remove(image.ObjectPointer);
+            ManagedInstances[image.ObjectPointer].Dispose();
+            ManagedInstances.Remove(image.ObjectPointer);
         }
 
         public Image FromEncodedData(string path)
         {
             var nativeImg = SKImage.FromEncodedData(path);
-            ManagedImages[nativeImg.Handle] = nativeImg;
+            ManagedInstances[nativeImg.Handle] = nativeImg;
             return new Image(nativeImg.Handle);
         }
 
@@ -47,20 +45,20 @@ namespace PixiEditor.DrawingApi.Skia.Implementations
 
         public ImgData Encode(Image image)
         {
-            var native = ManagedImages[image.ObjectPointer];
+            var native = ManagedInstances[image.ObjectPointer];
             var encoded = native.Encode();
-            _imgImplementation.ManagedImgDataObjects[encoded.Handle] = encoded;
+            _imgImplementation.ManagedInstances[encoded.Handle] = encoded;
             return new ImgData(encoded.Handle);
         }
 
         public int GetWidth(IntPtr objectPointer)
         {
-            return ManagedImages[objectPointer].Width;
+            return ManagedInstances[objectPointer].Width;
         }
 
         public int GetHeight(IntPtr objectPointer)
         {
-            return ManagedImages[objectPointer].Height;
+            return ManagedInstances[objectPointer].Height;
         }
     }
 }

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

@@ -7,28 +7,26 @@ using SkiaSharp;
 
 namespace PixiEditor.DrawingApi.Skia.Implementations
 {
-    public sealed class SkiaImgDataImplementation : IImgDataImplementation
+    public sealed class SkiaImgDataImplementation : SkObjectImplementation<SKData>, IImgDataImplementation
     {
-        internal readonly Dictionary<IntPtr, SKData> ManagedImgDataObjects = new Dictionary<IntPtr, SKData>();
-
         public void Dispose(IntPtr objectPointer)
         {
-            if (ManagedImgDataObjects.ContainsKey(objectPointer))
+            if (ManagedInstances.ContainsKey(objectPointer))
             {
-                ManagedImgDataObjects[objectPointer].Dispose();
-                ManagedImgDataObjects.Remove(objectPointer);
+                ManagedInstances[objectPointer].Dispose();
+                ManagedInstances.Remove(objectPointer);
             }
         }
 
         public void SaveTo(ImgData imgData, FileStream stream)
         {
-            SKData data = ManagedImgDataObjects[imgData.ObjectPointer];
+            SKData data = ManagedInstances[imgData.ObjectPointer];
             data.SaveTo(stream);
         }
 
         public Stream AsStream(ImgData imgData)
         {
-            SKData data = ManagedImgDataObjects[imgData.ObjectPointer];
+            SKData data = ManagedInstances[imgData.ObjectPointer];
             return data.AsStream();
         }
     }

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

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using PixiEditor.DrawingApi.Core.Bridge.NativeObjectsImpl;
+using PixiEditor.DrawingApi.Core.Surface;
+using SkiaSharp;
+
+namespace PixiEditor.DrawingApi.Skia.Implementations
+{
+    public class SkiaPaintImplementation : SkObjectImplementation<SKPaint>, IPaintImplementation
+    {
+        public IntPtr CreatePaint()
+        {
+            SKPaint paint = new SKPaint();
+            ManagedInstances[paint.Handle] = paint;
+            return paint.Handle;
+        }
+
+        public void Dispose(IntPtr paintObjPointer)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Paint Clone(IntPtr paintObjPointer)
+        {
+            SKPaint clone = ManagedInstances[paintObjPointer].Clone();
+            return new Paint(clone.Handle);
+        }
+    }
+}

src/PixiEditor.DrawingApi.Skia/SkiaDrawingBackend.cs

@@ -10,7 +10,7 @@ namespace PixiEditor.DrawingApi.Skia
         public IColorImplementation ColorImplementation { get; }
         public IImageImplementation ImageImplementation { get; }
         public IImgDataImplementation ImgDataImplementation { get; }
-        public ICanvasOperations CanvasOperations { get; }
+        public ICanvasImplementation CanvasImplementation { get; }
         public IPaintImplementation PaintImplementation { get; }
         public IVectorPathImplementation PathImplementation { get; }
         public IMatrix3X3Implementation MatrixImplementation { get; }