iterative traversal command generator

Author: swhitty

SwiftDraw/LayerTree.CommandGenerator.swift

@@ -52,56 +52,76 @@ extension LayerTree {
             self.options = options
         }
 
-        func renderCommands(for layer: Layer, colorConverter: any ColorConverter) -> [RendererCommand<P.Types>] {
+        func renderCommands(for l: Layer, colorConverter c: any ColorConverter) -> [RendererCommand<P.Types>] {
             var commands = [RendererCommand<P.Types>]()
 
-            let state = makeCommandState(for: layer, colorConverter: colorConverter)
-
-            guard state.hasContents else { return commands }
-
-            if state.hasFilters {
-                logUnsupportedFilters(layer.filters)
-            }
-
-            if state.hasOpacity || state.hasTransform || state.hasClip || state.hasMask {
-                commands.append(.pushState)
-            }
-
-            commands.append(contentsOf: renderCommands(forTransforms: layer.transform))
-            commands.append(contentsOf: renderCommands(forOpacity: layer.opacity))
-            commands.append(contentsOf: renderCommands(forClip: layer.clip, using: layer.clipRule))
-
-            if state.hasMask {
-                commands.append(.pushTransparencyLayer)
-            }
-
-            //render all of the layer contents
-            for contents in layer.contents {
-                switch makeRenderContents(for: contents, colorConverter: state.colorConverter) {
-                case let .simple(cmd):
+            var stack: [RenderStep] = [
+                .beginLayer(l, c)
+            ]
+
+            while let step = stack.popLast() {
+                switch step {
+                case let .beginLayer(layer, colorConverter):
+                    let state = makeCommandState(for: layer, colorConverter: colorConverter)
+
+                    //guard state.hasContents else { continue }
+                    stack.append(.endLayer(layer, state))
+
+                    if state.hasFilters {
+                        logUnsupportedFilters(layer.filters)
+                    }
+
+                    if state.hasOpacity || state.hasTransform || state.hasClip || state.hasMask {
+                        commands.append(.pushState)
+                    }
+
+                    commands.append(contentsOf: renderCommands(forTransforms: layer.transform))
+                    commands.append(contentsOf: renderCommands(forOpacity: layer.opacity))
+                    commands.append(contentsOf: renderCommands(forClip: layer.clip, using: layer.clipRule))
+
+                    if state.hasMask {
+                        commands.append(.pushTransparencyLayer)
+                    }
+
+                    //push render of all of the layer contents in reverse order
+                    for contents in layer.contents.reversed() {
+                        switch makeRenderContents(for: contents, colorConverter: colorConverter) {
+                        case let .simple(cmd):
+                            stack.append(.contents(cmd))
+                        case let .layer(layer):
+                            stack.append(.beginLayer(layer, colorConverter))
+                        }
+                    }
+
+                case let .contents(cmd):
                     commands.append(contentsOf: cmd)
-                case let .layer(layer):
-                    commands.append(contentsOf: renderCommands(for: layer, colorConverter: colorConverter))
-                }
-            }
 
-            //render apply mask
-            if state.hasMask {
-                commands.append(contentsOf: renderCommands(forMask: layer.mask))
-                commands.append(.popTransparencyLayer)
-            }
+                case let .endLayer(layer, state):
+                    //render apply mask
+                    if state.hasMask {
+                        commands.append(contentsOf: renderCommands(forMask: layer.mask))
+                        commands.append(.popTransparencyLayer)
+                    }
 
-            if state.hasOpacity {
-                commands.append(.popTransparencyLayer)
-            }
+                    if state.hasOpacity {
+                        commands.append(.popTransparencyLayer)
+                    }
 
-            if state.hasOpacity || state.hasTransform || state.hasClip || state.hasMask {
-                commands.append(.popState)
+                    if state.hasOpacity || state.hasTransform || state.hasClip || state.hasMask {
+                        commands.append(.popState)
+                    }
+                }
             }
 
             return commands
         }
 
+        enum RenderStep {
+            case beginLayer(LayerTree.Layer, any ColorConverter)
+            case contents([RendererCommand<P.Types>])
+            case endLayer(LayerTree.Layer, CommandState)
+        }
+
         struct CommandState {
             var hasOpacity: Bool
             var hasTransform: Bool

SwiftDrawTests/LayerTree.BuilderTests.swift

@@ -175,7 +175,7 @@ extension LayerTree.Builder {
     }
 }
 
-private extension DOM.Group {
+extension DOM.Group {
 
     static func make(child: DOM.GraphicsElement, nestedLevels: Int) -> DOM.Group {
         var group = DOM.Group()

SwiftDrawTests/SVGTests.swift

@@ -148,6 +148,14 @@ final class SVGTests: XCTestCase {
         images.remove(lines)
         XCTAssertFalse(images.contains(SVG.makeLines()))
     }
+
+    func testDeepNestedSVG() async {
+        let circle = DOM.Circle(cx: 50, cy: 50, r: 10)
+        let dom = DOM.SVG(width: 50, height: 50)
+        dom.childElements.append(DOM.Group.make(child: circle, nestedLevels: 500))
+
+        _ = SVG(dom: dom, options: .default)
+    }
 }
 
 private extension SVG {