Some rendering works

src/PixiEditor.AvaloniaUI/Models/Rendering/CanvasUpdater.cs

@@ -195,7 +195,7 @@ internal class CanvasUpdater
             screenSurface.DrawingSurface.Canvas.ClipRect((RectD)globalScaledClippingRectangle);
         }
 
-        /*ChunkRenderer.MergeWholeStructure(chunkPos, resolution, internals.Tracker.Document.StructureRoot, doc.AnimationHandler.ActiveFrameBindable, globalClippingRectangle).Switch(
+        DocumentEvaluator.RenderChunk(chunkPos, resolution, internals.Tracker.Document.NodeGraph, doc.AnimationHandler.ActiveFrameBindable, globalClippingRectangle).Switch(
             (Chunk chunk) =>
             {
                 screenSurface.DrawingSurface.Canvas.DrawSurface(chunk.Surface.DrawingSurface, chunkPos.Multiply(chunk.PixelSize), ReplacingPaint);
@@ -205,7 +205,7 @@ internal class CanvasUpdater
             {
                 var pos = chunkPos * resolution.PixelSize();
                 screenSurface.DrawingSurface.Canvas.DrawRect(pos.X, pos.Y, resolution.PixelSize(), resolution.PixelSize(), ClearPaint);
-            });*/
+            });
 
         if (globalScaledClippingRectangle is not null)
             screenSurface.DrawingSurface.Canvas.Restore();

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

@@ -7,4 +7,5 @@ public interface IReadOnlyNodeGraph
     public void AddNode(IReadOnlyNode node);
     public void RemoveNode(IReadOnlyNode node);
     public bool TryTraverse(Action<IReadOnlyNode> action);
+    public ChunkyImage? Execute(int frame);
 }

src/PixiEditor.ChangeableDocument/Changeables/Graph/NodeGraph.cs

@@ -33,22 +33,6 @@ public class NodeGraph : IReadOnlyNodeGraph, IDisposable
         _nodes.Remove(node);
     }
 
-    public ChunkyImage Execute()
-    {
-        if (OutputNode == null) return null;
-
-        var queue = CalculateExecutionQueue(OutputNode);
-
-        while (queue.Count > 0)
-        {
-            var node = queue.Dequeue();
-
-            node.Execute(0);
-        }
-
-        return OutputNode.Input.Value;
-    }
-
     private Queue<IReadOnlyNode> CalculateExecutionQueue(OutputNode outputNode)
     {
         // backwards breadth-first search
@@ -108,4 +92,20 @@ public class NodeGraph : IReadOnlyNodeGraph, IDisposable
         
         return true;
     }
+
+    public ChunkyImage? Execute(int frame)
+    {
+        if (OutputNode == null) return null;
+
+        var queue = CalculateExecutionQueue(OutputNode);
+
+        while (queue.Count > 0)
+        {
+            var node = queue.Dequeue();
+
+            node.Execute(frame);
+        }
+
+        return OutputNode.Input.Value;
+    }
 }

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

@@ -28,8 +28,10 @@ public class ImageLayerNode : LayerNode, IReadOnlyImageNode
 
     public override ChunkyImage OnExecute(KeyFrameTime frame)
     {
-        var imageFrame = frames.FirstOrDefault(x => x.IsInFrame(frame.Frame));
-        return imageFrame?.Image ?? frames[0].Image;
+        var imageFrame = frames.FirstOrDefault(x => x.IsInFrame(frame.Frame)); 
+        var result = imageFrame?.Image ?? frames[0].Image;
+        Output.Value = result;
+        return result;
     }
 
     public override void Dispose()

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

@@ -23,11 +23,11 @@ public abstract class Node(Guid? id = null) : IReadOnlyNode, IDisposable
 
     public ChunkyImage? Execute(KeyFrameTime frameTime)
     {
-        foreach (var output in outputs)
+        foreach (var input in inputs)
         {
-            foreach (var connection in output.Connections)
+            if (input.Connection != null)
             {
-                connection.Value = output.Value;
+                input.Value = input.Connection.Value;
             }
         }
 

src/PixiEditor.ChangeableDocument/Rendering/DocumentEvaluator.cs

@@ -1,6 +1,54 @@
-namespace PixiEditor.ChangeableDocument.Rendering;
+using PixiEditor.ChangeableDocument.Changeables.Graph.Interfaces;
+using PixiEditor.Numerics;
+
+namespace PixiEditor.ChangeableDocument.Rendering;
 
 public static class DocumentEvaluator
 {
-    
+    public static OneOf<Chunk, EmptyChunk> RenderChunk(VecI chunkPos, ChunkResolution resolution,
+        IReadOnlyNodeGraph graph, int frame, RectI? globalClippingRect = null)
+    {
+        using RenderingContext context = new();
+        try
+        {
+            RectI? transformedClippingRect = TransformClipRect(globalClippingRect, resolution, chunkPos);
+
+            ChunkyImage? evaulated = graph.Execute(frame);
+            if (evaulated is null)
+            {
+                return new EmptyChunk();
+            }
+
+            Chunk chunk = Chunk.Create(resolution);
+
+            chunk.Surface.DrawingSurface.Canvas.Save();
+            chunk.Surface.DrawingSurface.Canvas.Clear();
+            
+            if (transformedClippingRect is not null)
+            {
+                chunk.Surface.DrawingSurface.Canvas.ClipRect((RectD)transformedClippingRect);
+            }
+
+            evaulated.DrawMostUpToDateChunkOn(chunkPos, resolution, chunk.Surface.DrawingSurface, VecI.Zero,
+                context.ReplacingPaintWithOpacity);
+            
+            chunk.Surface.DrawingSurface.Canvas.Restore();
+
+            return chunk;
+        }
+        catch (ObjectDisposedException)
+        {
+            return new EmptyChunk();
+        }
+    }
+
+    private static RectI? TransformClipRect(RectI? globalClippingRect, ChunkResolution resolution, VecI chunkPos)
+    {
+        if (globalClippingRect is not RectI rect)
+            return null;
+
+        double multiplier = resolution.Multiplier();
+        VecI pixelChunkPos = chunkPos * (int)(ChunkyImage.FullChunkSize * multiplier);
+        return (RectI?)rect.Scale(multiplier).Translate(-pixelChunkPos).RoundOutwards();
+    }
 }