Create new node instead of changing the old one

Fix

Author: f3dm76

Source/model/scene/SceneUtils.swift

@@ -31,4 +31,32 @@ class SceneUtils {
 
         return shape
     }
+    
+    static func copyNode(_ referenceNode: Node) -> Node? {
+        let pos = referenceNode.place
+        let opaque = referenceNode.opaque
+        let visible = referenceNode.visible
+        let clip = referenceNode.clip
+        let tag = referenceNode.tag
+
+        if let shape = referenceNode as? Shape {
+            return Shape(form: shape.form, fill: shape.fill, stroke: shape.stroke, place: pos, opaque: opaque, clip: clip, visible: visible, tag: tag)
+        }
+        if let text = referenceNode as? Text {
+            return Text(text: text.text, font: text.font, fill: text.fill, stroke: text.stroke, align: text.align, baseline: text.baseline, place: pos, opaque: opaque, clip: clip, visible: visible, tag: tag)
+        }
+        if let image = referenceNode as? Image {
+            return Image(src: image.src, xAlign: image.xAlign, yAlign: image.yAlign, aspectRatio: image.aspectRatio, w: image.w, h: image.h, place: pos, opaque: opaque, clip: clip, visible: visible, tag: tag)
+        }
+        if let group = referenceNode as? Group {
+            var contents = [Node]()
+            group.contents.forEach { node in
+                if let copy = copyNode(node) {
+                    contents.append(copy)
+                }
+            }
+            return Group(contents: contents, place: pos, opaque: opaque, clip: clip, visible: visible, tag: tag)
+        }
+        return .none
+    }
 }

Source/render/ShapeRenderer.swift

@@ -175,10 +175,11 @@ class ShapeRenderer: NodeRenderer {
         guard let shape = shape else {
             return
         }
-        if !pattern.userSpace {
-            BoundsUtils.applyTransformToNodeInRespectiveCoords(respectiveNode: pattern.content, absoluteLocus: shape.form)
+        var patternNode = pattern.content
+        if !pattern.userSpace, let node = BoundsUtils.createNodeFromRespectiveCoords(respectiveNode: pattern.content, absoluteLocus: shape.form) {
+            patternNode = node
         }
-        let renderer = RenderUtils.createNodeRenderer(pattern.content, view: view, animationCache: animationCache)
+        let renderer = RenderUtils.createNodeRenderer(patternNode, view: view, animationCache: animationCache)
 
         var patternBounds = pattern.bounds
         if !pattern.userSpace {

Source/svg/SVGParser.swift

@@ -644,8 +644,9 @@ open class SVGParser {
             return Pattern(content: pattern.content, bounds: pattern.bounds.applying(tranform), userSpace: true)
         }
         if pattern.userSpace == true && pattern.contentUserSpace == false {
-            BoundsUtils.applyTransformToNodeInRespectiveCoords(respectiveNode: pattern.content, absoluteLocus: locus!)
-            return Pattern(content: pattern.content, bounds: pattern.bounds, userSpace: pattern.userSpace)
+            if let patternNode = BoundsUtils.createNodeFromRespectiveCoords(respectiveNode: pattern.content, absoluteLocus: locus!) {
+                return Pattern(content: patternNode, bounds: pattern.bounds, userSpace: pattern.userSpace)
+            }
         }
         return Pattern(content: pattern.content, bounds: pattern.bounds, userSpace: true)
     }

Source/utils/BoundsUtils.swift

@@ -62,15 +62,25 @@ final internal class BoundsUtils {
         return Transform.move(dx: absoluteBounds.x, dy: absoluteBounds.y).concat(with: scale)
     }
 
-    class func applyTransformToNodeInRespectiveCoords(respectiveNode: Node, absoluteLocus: Locus) {
-        if let patternShape = respectiveNode as? Shape {
+    class func createNodeFromRespectiveCoords(respectiveNode: Node, absoluteLocus: Locus) -> Node? {
+        guard let copy = SceneUtils.copyNode(respectiveNode) else {
+            return nil
+        }
+
+        if let patternShape = copy as? Shape {
             let tranform = BoundsUtils.transformForLocusInRespectiveCoords(respectiveLocus: patternShape.form, absoluteLocus: absoluteLocus)
             patternShape.place = patternShape.place.concat(with: tranform)
         }
-        if let patternGroup = respectiveNode as? Group {
+        if let patternGroup = copy as? Group {
+            var nodes = [Node]()
             for groupNode in patternGroup.contents {
-                applyTransformToNodeInRespectiveCoords(respectiveNode: groupNode, absoluteLocus: absoluteLocus)
+                if let node = createNodeFromRespectiveCoords(respectiveNode: groupNode, absoluteLocus: absoluteLocus) {
+                    nodes.append(node)
+                }
             }
+            patternGroup.contents = nodes
         }
+
+        return copy
     }
 }