Implemented merge layers for different types

src/PixiEditor.ChangeableDocument/Changes/Drawing/CombineStructureMembersOnto_Change.cs

@@ -1,4 +1,6 @@
 using PixiEditor.ChangeableDocument.Changeables.Graph.Nodes;
+using PixiEditor.ChangeableDocument.Changeables.Interfaces;
+using PixiEditor.ChangeableDocument.Changes.Structure;
 using PixiEditor.ChangeableDocument.Rendering;
 using PixiEditor.DrawingApi.Core.Bridge;
 using PixiEditor.DrawingApi.Core.Numerics;
@@ -15,6 +17,7 @@ internal class CombineStructureMembersOnto_Change : Change
 
     private Guid targetLayer;
     private CommittedChunkStorage? originalChunks;
+    
 
     [GenerateMakeChangeAction]
     public CombineStructureMembersOnto_Change(HashSet<Guid> membersToMerge, Guid targetLayer, int frame)
@@ -62,24 +65,36 @@ internal class CombineStructureMembersOnto_Change : Change
     public override OneOf<None, IChangeInfo, List<IChangeInfo>> Apply(Document target, bool firstApply,
         out bool ignoreInUndo)
     {
-        //TODO: Add support for different Layer types
-        var toDrawOn = target.FindMemberOrThrow<ImageLayerNode>(targetLayer);
+        // TODO: add merging similar layers (vector -> vector)
+        var toDrawOn = target.FindMemberOrThrow<LayerNode>(targetLayer);
 
         var chunksToCombine = new HashSet<VecI>();
         foreach (var guid in layersToCombine)
         {
-            var layer = target.FindMemberOrThrow<ImageLayerNode>(guid);
-            var layerImage = layer.GetLayerImageAtFrame(frame);
-            chunksToCombine.UnionWith(layerImage.FindAllChunks());
-        }
+            var layer = target.FindMemberOrThrow<LayerNode>(guid);
+            if(layer is not IRasterizable or ImageLayerNode)
+                continue;
 
-        var toDrawOnImage = toDrawOn.GetLayerImageAtFrame(frame);
+            if (layer is ImageLayerNode imageLayerNode)
+            {
+                var layerImage = imageLayerNode.GetLayerImageAtFrame(frame);
+                chunksToCombine.UnionWith(layerImage.FindAllChunks());
+            }
+            else
+            {
+                AddChunksByTightBounds(layer, chunksToCombine);
+            }
+        }
+        
+        List<IChangeInfo> changes = new();
+        
+        var toDrawOnImage = ((ImageLayerNode)toDrawOn).GetLayerImageAtFrame(frame);
         toDrawOnImage.EnqueueClear();
 
         DocumentRenderer renderer = new(target);
 
         AffectedArea affArea = new();
-        DrawingBackendApi.Current.RenderingServer.Invoke(() =>
+        DrawingBackendApi.Current.RenderingDispatcher.Invoke(() =>
         {
             RectI? globalClippingRect = new RectI(0, 0, target.Size.X, target.Size.Y);
             foreach (var chunk in chunksToCombine)
@@ -100,7 +115,27 @@ internal class CombineStructureMembersOnto_Change : Change
 
 
         ignoreInUndo = false;
-        return new LayerImageArea_ChangeInfo(targetLayer, affArea);
+        
+        changes.Add(new LayerImageArea_ChangeInfo(targetLayer, affArea));
+        return changes;
+    }
+
+    private void AddChunksByTightBounds(LayerNode layer, HashSet<VecI> chunksToCombine)
+    {
+        var tightBounds = layer.GetTightBounds(frame);
+        if (tightBounds.HasValue)
+        {
+            VecI chunk = (VecI)tightBounds.Value.TopLeft / ChunkyImage.FullChunkSize;
+            VecI sizeInChunks = ((VecI)tightBounds.Value.Size / ChunkyImage.FullChunkSize);
+            sizeInChunks = new VecI(Math.Max(1, sizeInChunks.X), Math.Max(1, sizeInChunks.Y));
+            for (int x = 0; x < sizeInChunks.X; x++)
+            {
+                for (int y = 0; y < sizeInChunks.Y; y++)
+                {
+                    chunksToCombine.Add(chunk + new VecI(x, y));
+                }
+            }
+        }
     }
 
     public override OneOf<None, IChangeInfo, List<IChangeInfo>> Revert(Document target)
@@ -109,7 +144,11 @@ internal class CombineStructureMembersOnto_Change : Change
         var affectedArea =
             DrawingChangeHelper.ApplyStoredChunksDisposeAndSetToNull(toDrawOn.GetLayerImageAtFrame(frame),
                 ref originalChunks);
-        return new LayerImageArea_ChangeInfo(targetLayer, affectedArea);
+        
+        List<IChangeInfo> changes = new();
+        changes.Add(new LayerImageArea_ChangeInfo(targetLayer, affectedArea));
+
+        return changes; 
     }
 
     public override void Dispose()

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

@@ -28,7 +28,7 @@ namespace PixiEditor.DrawingApi.Core.Bridge
             }
             
             _current = backend;
-            _current.RenderingServer = server;
+            _current.RenderingDispatcher = server;
             backend.Setup();
         }
     }

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

@@ -24,6 +24,6 @@ namespace PixiEditor.DrawingApi.Core.Bridge
         public IImageFilterImplementation ImageFilterImplementation { get; }
         public IShaderImplementation ShaderImplementation { get; set; }
         public bool IsHardwareAccelerated { get; }
-        public IRenderingServer RenderingServer { get; set; }
+        public IRenderingServer RenderingDispatcher { get; set; }
     }
 }

src/PixiEditor.DrawingApi.Skia/SkiaDrawingBackend.cs

@@ -29,7 +29,7 @@ namespace PixiEditor.DrawingApi.Skia
         
         public bool IsHardwareAccelerated => GraphicsContext != null;
         
-        public IRenderingServer RenderingServer { get; set; }
+        public IRenderingServer RenderingDispatcher { get; set; }
 
         public IColorImplementation ColorImplementation { get; }
         public IImageImplementation ImageImplementation { get; }

src/PixiEditor/ViewModels/Document/DocumentViewModel.Serialization.cs

@@ -208,7 +208,7 @@ internal partial class DocumentViewModel
         if (tightBounds == null || tightBounds.Value.IsZeroArea) return;
 
         Image toSave = null;
-        DrawingBackendApi.Current.RenderingServer.Invoke(() =>
+        DrawingBackendApi.Current.RenderingDispatcher.Invoke(() =>
         {
             using Texture rendered = Renderer.RenderLayer(imageNode.Id, ChunkResolution.Full, atTime.Frame);
 

src/PixiEditor/ViewModels/Document/DocumentViewModel.cs

@@ -504,7 +504,7 @@ internal partial class DocumentViewModel : PixiObservableObject, IDocument
         {
             Surface finalSurface = new Surface(SizeBindable);
             VecI sizeInChunks = (VecI)((VecD)SizeBindable / ChunkyImage.FullChunkSize).Ceiling();
-            DrawingBackendApi.Current.RenderingServer.Invoke(() =>
+            DrawingBackendApi.Current.RenderingDispatcher.Invoke(() =>
             {
                 for (int i = 0; i < sizeInChunks.X; i++)
                 {

src/PixiEditor/Views/Dialogs/ExportFilePopup.axaml.cs

@@ -301,7 +301,7 @@ internal partial class ExportFilePopup : PixiEditorPopup
                             int x = index % clampedColumns;
                             int y = index / clampedColumns;
                             var resized = frame.ResizeNearestNeighbor(new VecI(singleFrameSize.X, singleFrameSize.Y));
-                            DrawingBackendApi.Current.RenderingServer.Invoke(() =>
+                            DrawingBackendApi.Current.RenderingDispatcher.Invoke(() =>
                             {
                                 if (ExportPreview.IsDisposed) return;
                                 ExportPreview!.DrawingSurface.Canvas.DrawSurface(resized.DrawingSurface,