feat: add RenderNode, RenderNodeContext, and RenderNodeOperation clas…

…ses for rendering framework

src/Beutl.Engine/Graphics/Rendering/V2/RenderNode.cs

@@ -0,0 +1,31 @@
+namespace Beutl.Graphics.Rendering.V2;
+
+public abstract class RenderNode : INode
+{
+    ~RenderNode()
+    {
+        if (!IsDisposed)
+        {
+            OnDispose(false);
+            IsDisposed = true;
+        }
+    }
+
+    public bool IsDisposed { get; private set; }
+
+    public abstract RenderNodeOperation[] Process(RenderNodeContext context);
+
+    public void Dispose()
+    {
+        if (!IsDisposed)
+        {
+            OnDispose(true);
+            IsDisposed = true;
+            GC.SuppressFinalize(this);
+        }
+    }
+
+    protected virtual void OnDispose(bool disposing)
+    {
+    }
+}

src/Beutl.Engine/Graphics/Rendering/V2/RenderNodeContext.cs

@@ -0,0 +1,15 @@
+namespace Beutl.Graphics.Rendering.V2;
+
+public class RenderNodeContext(IImmediateCanvasFactory canvasFactory, RenderNodeOperation[] input)
+{
+    public RenderNodeOperation[] Input { get; } = input;
+
+    public IImmediateCanvasFactory CanvasFactory { get; } = canvasFactory;
+
+    public bool IsRenderCacheEnabled { get; set; } = true;
+
+    public Rect CalculateBounds()
+    {
+        return Input.Aggregate<RenderNodeOperation, Rect>(default, (current, operation) => current.Union(operation.Bounds));
+    }
+}

src/Beutl.Engine/Graphics/Rendering/V2/RenderNodeOperation.cs

@@ -0,0 +1,70 @@
+using SkiaSharp;
+
+namespace Beutl.Graphics.Rendering.V2;
+
+public abstract class RenderNodeOperation : IDisposable
+{
+    public bool IsDisposed { get; private set; }
+
+    // Invalidになることはない
+    public abstract Rect Bounds { get; }
+
+    public abstract void Render(ImmediateCanvas canvas);
+
+    public abstract bool HitTest(Point point);
+
+    public void Dispose()
+    {
+        if (!IsDisposed)
+        {
+            OnDispose(true);
+            IsDisposed = true;
+            GC.SuppressFinalize(this);
+        }
+    }
+
+    protected virtual void OnDispose(bool disposing)
+    {
+    }
+
+    public static RenderNodeOperation CreateDecorator(
+        RenderNodeOperation child, Action<ImmediateCanvas> render,
+        Func<Point, bool>? hitTest = null,
+        Action? onDispose = null)
+    {
+        return CreateLambda(child.Bounds, render, hitTest: hitTest ?? child.HitTest, onDispose: () =>
+        {
+            child.Dispose();
+            onDispose?.Invoke();
+        });
+    }
+
+    public static RenderNodeOperation CreateLambda(
+        Rect bounds, Action<ImmediateCanvas> render,
+        Func<Point, bool>? hitTest = null,
+        Action? onDispose = null)
+    {
+        return new LambdaRenderNodeOperation(bounds, render, hitTest, onDispose);
+    }
+
+    public static RenderNodeOperation CreateFromSurface(Rect bounds, Point position, SKSurface surface)
+    {
+        return CreateLambda(bounds, canvas => canvas.DrawSurface(surface, position), bounds.Contains, surface.Dispose);
+    }
+
+    private class LambdaRenderNodeOperation(
+        Rect bounds,
+        Action<ImmediateCanvas> render,
+        Func<Point, bool>? hitTest,
+        Action? onDispose)
+        : RenderNodeOperation
+    {
+        public override Rect Bounds => bounds;
+
+        public override void Render(ImmediateCanvas canvas) => render(canvas);
+
+        public override bool HitTest(Point point) => hitTest?.Invoke(point) ?? false;
+
+        protected override void OnDispose(bool disposing) => onDispose?.Invoke();
+    }
+}