Single high res texture

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

@@ -38,7 +38,7 @@ public class ImageLayerNode : LayerNode, IReadOnlyImageNode
     protected override bool AffectedByChunkResolution => true;
 
 
-    private Dictionary<ChunkResolution, Texture> renderedSurfaces = new();
+    private Texture fullResrenderedSurface; 
 
     public ImageLayerNode(VecI size)
     {
@@ -51,7 +51,6 @@ public class ImageLayerNode : LayerNode, IReadOnlyImageNode
 
         this.startSize = size;
 
-        CreateRenderCanvases(size, renderedSurfaces);
     }
     
     public override RectD? GetTightBounds(KeyFrameTime frameTime)
@@ -82,10 +81,8 @@ public class ImageLayerNode : LayerNode, IReadOnlyImageNode
     {
         int scaled = workingSurface.Canvas.Save();
         float multiplier = (float)ctx.ChunkResolution.InvertedMultiplier();
-        VecD shiftToCenter = SceneSize - renderedSurfaces[ctx.ChunkResolution].Size;
         workingSurface.Canvas.Translate(ScenePosition);
-        workingSurface.Canvas.Scale(multiplier, multiplier);
-        workingSurface.Canvas.Translate(shiftToCenter / 2f);
+        //workingSurface.Canvas.Scale(multiplier, multiplier);
         base.DrawLayerInScene(ctx, workingSurface, useFilters);
 
         workingSurface.Canvas.RestoreToCount(scaled);
@@ -107,8 +104,19 @@ public class ImageLayerNode : LayerNode, IReadOnlyImageNode
 
     private void DrawLayer(DrawingSurface workingSurface, Paint paint, ChunkResolution resolution)
     {
+        if (fullResrenderedSurface is null)
+        {
+            return;
+        }
+
+        int saved = workingSurface.Canvas.Save();
+
+        //workingSurface.Canvas.Scale((float)resolution.Multiplier());
+        
         VecD topLeft = SceneSize / 2f;
-        workingSurface.Canvas.DrawSurface(renderedSurfaces[resolution].DrawingSurface, -(VecI)topLeft, paint);
+        workingSurface.Canvas.DrawSurface(fullResrenderedSurface.DrawingSurface, -(VecI)topLeft, paint);
+        
+        workingSurface.Canvas.RestoreToCount(saved);
     }
 
     public override bool RenderPreview(Texture renderOn, VecI chunk, ChunkResolution resolution, int frame)
@@ -210,7 +218,7 @@ public class ImageLayerNode : LayerNode, IReadOnlyImageNode
         
         var img = GetLayerImageAtFrame(frameTime.Frame);
 
-        RenderChunkyImageChunk(chunkPos, resolution, img, renderedSurfaces);
+        RenderChunkyImageChunk(chunkPos, resolution, img, ref fullResrenderedSurface);
     }
     
     public void ForEveryFrame(Action<ChunkyImage> action)

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

@@ -33,7 +33,7 @@ public abstract class StructureNode : Node, IReadOnlyStructureNode, IRenderInput
 
     public ChunkyImage? EmbeddedMask { get; set; }
 
-    protected Dictionary<ChunkResolution, Texture> renderedMasks = new();
+    protected Texture renderedMask;
     protected static readonly Paint replacePaint = new Paint() { BlendMode = DrawingApi.Core.Surfaces.BlendMode.Src };
 
     public virtual ShapeCorners GetTransformationCorners(KeyFrameTime frameTime)
@@ -120,22 +120,12 @@ public abstract class StructureNode : Node, IReadOnlyStructureNode, IRenderInput
             }
             else if (EmbeddedMask != null)
             {
-                surface.Canvas.DrawSurface(renderedMasks[context.ChunkResolution].DrawingSurface, 0, 0, maskPaint);
+                // apply resolution scaling
+                surface.Canvas.DrawSurface(renderedMask.DrawingSurface, 0, 0, maskPaint);
             }
         }
     }
 
-    protected static void CreateRenderCanvases(VecI newSize, Dictionary<ChunkResolution, Texture> target)
-    {
-        target[ChunkResolution.Full] = new Texture(newSize);
-        target[ChunkResolution.Half] =
-            new Texture(new VecI(Math.Max(newSize.X / 2, 1), Math.Max(newSize.Y / 2, 1)));
-        target[ChunkResolution.Quarter] =
-            new Texture(new VecI(Math.Max(newSize.X / 4, 1), Math.Max(newSize.Y / 4, 1)));
-        target[ChunkResolution.Eighth] =
-            new Texture(new VecI(Math.Max(newSize.X / 8, 1), Math.Max(newSize.Y / 8, 1)));
-    }
-
     protected override bool CacheChanged(RenderContext context)
     {
         int cacheHash = EmbeddedMask?.GetCacheHash() ?? 0;
@@ -150,37 +140,33 @@ public abstract class StructureNode : Node, IReadOnlyStructureNode, IRenderInput
 
     public virtual void RenderChunk(VecI chunkPos, ChunkResolution resolution, KeyFrameTime frameTime)
     {
-        RenderChunkyImageChunk(chunkPos, resolution, EmbeddedMask, renderedMasks);
+        RenderChunkyImageChunk(chunkPos, resolution, EmbeddedMask, ref renderedMask);
     }
 
     protected void RenderChunkyImageChunk(VecI chunkPos, ChunkResolution resolution, ChunkyImage img,
-        Dictionary<ChunkResolution, Texture> cache)
+        ref Texture? renderSurface)
     {
         if (img is null)
         {
             return;
         }
 
-        VecI targetSize = (VecI)(img.LatestSize * resolution.Multiplier());
-        if (!cache.ContainsKey(resolution))
-        {
-            cache[resolution] = new Texture(targetSize);
-        }
+        VecI targetSize = img.LatestSize;
 
-        if (cache[resolution].Size != targetSize)
+        if (renderSurface == null || renderSurface.Size != targetSize)
         {
-            cache[resolution].Dispose();
-            cache[resolution] = new Texture(targetSize);
+            renderSurface?.Dispose();
+            renderSurface = new Texture(targetSize);
         }
 
         img.DrawMostUpToDateChunkOn(
             chunkPos,
-            resolution,
-            cache[resolution].DrawingSurface,
-            chunkPos * resolution.PixelSize(),
+            ChunkResolution.Full,
+            renderSurface.DrawingSurface,
+            chunkPos * ChunkResolution.Full.PixelSize(),
             replacePaint);
 
-        cache[resolution].DrawingSurface.Flush();
+        renderSurface.DrawingSurface.Flush();
     }
 
     protected void ApplyRasterClip(DrawingSurface toClip, DrawingSurface clipSource)