Fixed some rendering bugs

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

@@ -130,7 +130,9 @@ public class ImageLayerNode : LayerNode, IReadOnlyImageNode
         int saved = workingSurface.Canvas.Save();
 
         var sceneSize = GetSceneSize(ctx.FrameTime);
-        var region = ctx.VisibleDocumentRegion ?? new RectI(0, 0, layerImage.LatestSize.X, layerImage.LatestSize.Y);
+        RectI latestSize = new(0, 0, layerImage.LatestSize.X, layerImage.LatestSize.Y);
+        var region = ctx.VisibleDocumentRegion ?? latestSize;
+
         VecD topLeft = region.TopLeft - sceneSize / 2;
 
         topLeft *= ctx.ChunkResolution.Multiplier();

src/PixiEditor.ChangeableDocument/Changeables/Graph/Nodes/Matrix/Matrix3X3BaseNode.cs

@@ -40,11 +40,20 @@ public abstract class Matrix3X3BaseNode : RenderNode, IRenderInput
 
         Float3x3 mtx = Matrix.Value.Invoke(FuncContext.NoContext);
 
+        Matrix3X3 constant = mtx.GetConstant() as Matrix3X3? ?? Matrix3X3.Identity;
         surface.Canvas.SetMatrix(
-            surface.Canvas.TotalMatrix.Concat(mtx.GetConstant() as Matrix3X3? ?? Matrix3X3.Identity));
+            surface.Canvas.TotalMatrix.Concat(constant));
+
+        var clonedCtx = context.Clone();
+        if (clonedCtx.VisibleDocumentRegion.HasValue)
+        {
+            clonedCtx.VisibleDocumentRegion =
+                (RectI)constant.Invert().TransformRect((RectD)clonedCtx.VisibleDocumentRegion.Value);
+        }
+
         if (!surface.LocalClipBounds.IsZeroOrNegativeArea)
         {
-            Background.Value?.Paint(context, surface);
+            Background.Value?.Paint(clonedCtx, surface);
         }
 
         surface.Canvas.RestoreToCount(layer);

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

@@ -43,8 +43,13 @@ public class OutputNode : Node, IRenderInput
             if (texture is null) continue;
 
             int saved = texture.DrawingSurface.Canvas.Save();
-            texture.DrawingSurface.Canvas.Scale((float)context.ChunkResolution.Multiplier());
-            Input.Value?.Paint(context, texture.DrawingSurface);
+
+            VecD scaling = PreviewUtility.CalculateUniformScaling(context.DocumentSize, texture.Size);
+            texture.DrawingSurface.Canvas.Scale((float)scaling.X, (float)scaling.Y);
+            var previewCtx =
+                PreviewUtility.CreatePreviewContext(context, scaling, context.RenderOutputSize, texture.Size);
+
+            Input.Value?.Paint(previewCtx, texture.DrawingSurface);
             texture.DrawingSurface.Canvas.RestoreToCount(saved);
         }
     }

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

@@ -169,11 +169,40 @@ public abstract class StructureNode : RenderNode, IReadOnlyStructureNode, IRende
         VecD sceneSize = GetSceneSize(context.FrameTime);
         //renderTarget.Canvas.ClipRect(new RectD(scenePos - (sceneSize / 2f), sceneSize));
 
+        // Custom shader may modify the actual visible region, so we must force rendering full region
+        if (IsConnectedToCustomShaderNode(output))
+        {
+            renderObjectContext.VisibleDocumentRegion = null;
+        }
+
         Render(renderObjectContext);
 
         renderTarget?.Canvas.RestoreToCount(renderSaved);
     }
 
+    private bool IsConnectedToCustomShaderNode(RenderOutputProperty output)
+    {
+        foreach (var conn in output.Connections)
+        {
+            bool isCustomShader = false;
+            conn.Node.TraverseForwards(x =>
+            {
+                if (x is ICustomShaderNode)
+                {
+                    isCustomShader = true;
+                    return false;
+                }
+
+                return true;
+            });
+
+            if (isCustomShader)
+                return true;
+        }
+
+        return false;
+    }
+
     protected SceneObjectRenderContext CreateSceneContext(RenderContext context, DrawingSurface renderTarget,
         RenderOutputProperty output)
     {

src/PixiEditor.ChangeableDocument/Rendering/PreviewRenderRequest.cs

@@ -10,7 +10,7 @@ public record struct PreviewRenderRequest
         {
             if (!accessedTexture)
             {
-                texture = textureCreateFunc();
+                texture = textureCreateFunc(true);
                 accessedTexture = true;
             }
 
@@ -20,11 +20,11 @@ public record struct PreviewRenderRequest
     public string? ElementToRender { get; set; }
     public Action TextureUpdatedAction { get; set; }
 
-    private Func<Texture?> textureCreateFunc;
+    private Func<bool, Texture?> textureCreateFunc;
     private Texture? texture;
     private bool accessedTexture = false;
 
-    public PreviewRenderRequest(Func<Texture?> textureCreateFunc, Action textureUpdatedAction, string? elementToRender = null)
+    public PreviewRenderRequest(Func<bool, Texture?> textureCreateFunc, Action textureUpdatedAction, string? elementToRender = null)
     {
         this.textureCreateFunc = textureCreateFunc;
         TextureUpdatedAction = textureUpdatedAction;
@@ -35,4 +35,9 @@ public record struct PreviewRenderRequest
     {
         TextureUpdatedAction?.Invoke();
     }
+
+    public Texture? GetTextureCached()
+    {
+        return textureCreateFunc(false);
+    }
 }

src/PixiEditor/Models/DocumentModels/ActionAccumulator.cs

@@ -148,7 +148,8 @@ internal class ActionAccumulator
 
                 if (!previewsDisabled)
                 {
-                    if (undoBoundaryPassed || viewportRefreshRequest || refreshPreviewsRequest || refreshPreviewRequest || changeFrameRequest ||
+                    if (undoBoundaryPassed || viewportRefreshRequest || refreshPreviewsRequest ||
+                        refreshPreviewRequest || changeFrameRequest ||
                         document.SizeBindable.LongestAxis <= LiveUpdatePerformanceThreshold)
                     {
                         previewTextures = previewUpdater.GatherPreviewsToUpdate(
@@ -160,19 +161,14 @@ internal class ActionAccumulator
                     }
                 }
 
-                List<Action>? updatePreviewActions = previewTextures?.Values.Select(x => x.Select(r => r.TextureUpdatedAction))
+                List<Action>? updatePreviewActions = previewTextures?.Values
+                    .Select(x => x.Select(r => r.TextureUpdatedAction))
                     .SelectMany(x => x).ToList();
 
                 await document.SceneRenderer.RenderAsync(internals.State.Viewports, affectedAreas.MainImageArea,
                     !previewsDisabled && updateDelayed, previewTextures);
 
-                if (updatePreviewActions != null)
-                {
-                    foreach (var action in updatePreviewActions)
-                    {
-                        action();
-                    }
-                }
+                NotifyUpdatedPreviews(updatePreviewActions);
             }
         }
         catch (Exception e)
@@ -193,6 +189,17 @@ internal class ActionAccumulator
         executing = false;
     }
 
+    private static void NotifyUpdatedPreviews(List<Action>? updatePreviewActions)
+    {
+        if (updatePreviewActions != null)
+        {
+            foreach (var action in updatePreviewActions)
+            {
+                action();
+            }
+        }
+    }
+
     private const int LiveUpdatePerformanceThreshold = 2048;
 
     private bool AreAllPassthrough(List<(ActionSource, IAction)> actions)

src/PixiEditor/Models/Rendering/MemberPreviewUpdater.cs

@@ -134,14 +134,17 @@ internal class MemberPreviewUpdater
                 if (textureSize.X <= 0 || textureSize.Y <= 0)
                     continue;
 
-                Texture? CreateTextureForLayer()
+                Texture? CreateTextureForLayer(bool createIfNull)
                 {
-                    if (structureMemberHandler.Preview.Preview == null ||
-                        structureMemberHandler.Preview.Preview.IsDisposed ||
-                        structureMemberHandler.Preview.Preview.Size != textureSize)
+                    if (createIfNull)
                     {
-                        structureMemberHandler.Preview.Preview?.Dispose();
-                        structureMemberHandler.Preview.Preview = Texture.ForDisplay(textureSize);
+                        if (structureMemberHandler.Preview.Preview == null ||
+                            structureMemberHandler.Preview.Preview.IsDisposed ||
+                            structureMemberHandler.Preview.Preview.Size != textureSize)
+                        {
+                            structureMemberHandler.Preview.Preview?.Dispose();
+                            structureMemberHandler.Preview.Preview = Texture.ForDisplay(textureSize);
+                        }
                     }
 
                     return structureMemberHandler.Preview.Preview;
@@ -263,14 +266,17 @@ internal class MemberPreviewUpdater
                 if (textureSize.X <= 0 || textureSize.Y <= 0)
                     continue;
 
-                Texture? CreateTextureForMask()
+                Texture? CreateTextureForMask(bool createIfNull)
                 {
-                    if (structureMemberHandler.MaskPreview.Preview == null ||
-                        structureMemberHandler.MaskPreview.Preview.IsDisposed ||
-                        structureMemberHandler.MaskPreview.Preview.Size != textureSize)
+                    if (createIfNull)
                     {
-                        structureMemberHandler.MaskPreview.Preview?.Dispose();
-                        structureMemberHandler.MaskPreview.Preview = Texture.ForDisplay(textureSize);
+                        if (structureMemberHandler.MaskPreview.Preview == null ||
+                            structureMemberHandler.MaskPreview.Preview.IsDisposed ||
+                            structureMemberHandler.MaskPreview.Preview.Size != textureSize)
+                        {
+                            structureMemberHandler.MaskPreview.Preview?.Dispose();
+                            structureMemberHandler.MaskPreview.Preview = Texture.ForDisplay(textureSize);
+                        }
                     }
 
                     return structureMemberHandler.MaskPreview.Preview;
@@ -363,13 +369,16 @@ internal class MemberPreviewUpdater
         if (textureSize.X <= 0 || textureSize.Y <= 0)
             return;
 
-        Texture? CreateTextureForNode()
+        Texture? CreateTextureForNode(bool createIfNull)
         {
-            if (nodeVm.Preview.Preview == null || nodeVm.Preview.Preview.IsDisposed ||
-                nodeVm.Preview.Preview.Size != textureSize)
+            if (createIfNull)
             {
-                nodeVm.Preview.Preview?.Dispose();
-                nodeVm.Preview.Preview = Texture.ForDisplay(textureSize);
+                if (nodeVm.Preview.Preview == null || nodeVm.Preview.Preview.IsDisposed ||
+                    nodeVm.Preview.Preview.Size != textureSize)
+                {
+                    nodeVm.Preview.Preview?.Dispose();
+                    nodeVm.Preview.Preview = Texture.ForDisplay(textureSize);
+                }
             }
 
             return nodeVm.Preview.Preview;

src/PixiEditor/Views/Main/ViewportControls/Viewport.axaml.cs

@@ -681,7 +681,7 @@ internal partial class Viewport : UserControl, INotifyPropertyChanged
     private static void OnHighResPreviewChanged(AvaloniaPropertyChangedEventArgs<bool> e)
     {
         Viewport? viewport = (Viewport)e.Sender;
-        viewport.ForceRefreshFinalImage();
+        viewport.Document?.Operations.AddOrUpdateViewport(viewport.GetLocation());
     }
 
     private void MenuItem_OnClick(object? sender, PointerReleasedEventArgs e)

src/PixiEditor/Views/Visuals/PreviewTextureControl.cs

@@ -59,7 +59,7 @@ public class PreviewTextureControl : DrawieControl
 
     public override void Draw(DrawingSurface surface)
     {
-        if (TexturePreview is { Preview: not null })
+        if (TexturePreview is { Preview: not null } && TexturePreview.Preview is { IsDisposed: false })
         {
             VecD scaling = new(Bounds.Size.Width / TexturePreview.Preview.Size.X, Bounds.Size.Height / TexturePreview.Preview.Size.Y);
             surface.Canvas.Save();