three-stdlib 2.29.8 → 2.29.9

package/loaders/SVGLoader.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
+const COLOR_SPACE_SVG = "srgb";
 class SVGLoader extends THREE.Loader {
   constructor(manager) {
     super(manager);
@@ -37,10 +38,11 @@ class SVGLoader extends THREE.Loader {
       if (node.nodeType !== 1)
         return;
       const transform = getNodeTransform(node);
-      let traverseChildNodes = true;
+      let isDefsNode = false;
       let path = null;
       switch (node.nodeName) {
         case "svg":
+          style = parseStyle(node, style);
           break;
         case "style":
           parseCSSStylesheet(node);
@@ -78,14 +80,12 @@ class SVGLoader extends THREE.Loader {
           path = parseLineNode(node);
           break;
         case "defs":
-          traverseChildNodes = false;
-          break;
-        case "mask":
-          traverseChildNodes = false;
+          isDefsNode = true;
           break;
         case "use":
           style = parseStyle(node, style);
-          const usedNodeId = node.href.baseVal.substring(1);
+          const href = node.getAttributeNS("http://www.w3.org/1999/xlink", "href") || "";
+          const usedNodeId = href.substring(1);
           const usedNode = node.viewportElement.getElementById(usedNodeId);
           if (usedNode) {
             parseNode(usedNode, style);
@@ -96,17 +96,19 @@ class SVGLoader extends THREE.Loader {
       }
       if (path) {
         if (style.fill !== void 0 && style.fill !== "none") {
-          path.color.setStyle(style.fill);
+          path.color.setStyle(style.fill, COLOR_SPACE_SVG);
         }
         transformPath(path, currentTransform);
         paths.push(path);
         path.userData = { node, style };
       }
-      if (traverseChildNodes) {
-        const nodes = node.childNodes;
-        for (let i = 0; i < nodes.length; i++) {
-          parseNode(nodes[i], style);
+      const childNodes = node.childNodes;
+      for (let i = 0; i < childNodes.length; i++) {
+        const node2 = childNodes[i];
+        if (isDefsNode && node2.nodeName !== "style" && node2.nodeName !== "defs") {
+          continue;
         }
+        parseNode(node2, style);
       }
       if (transform) {
         transformStack.pop();
@@ -125,11 +127,13 @@ class SVGLoader extends THREE.Loader {
       let isFirstPoint = true;
       let doSetFirstPoint = false;
       const d = node.getAttribute("d");
+      if (d === "" || d === "none")
+        return null;
       const commands = d.match(/[a-df-z][^a-df-z]*/gi);
       for (let i = 0, l = commands.length; i < l; i++) {
         const command = commands[i];
         const type = command.charAt(0);
-        const data2 = command.substr(1).trim();
+        const data2 = command.slice(1).trim();
         if (isFirstPoint === true) {
           doSetFirstPoint = true;
           isFirstPoint = false;
@@ -442,7 +446,8 @@ class SVGLoader extends THREE.Loader {
           continue;
         const selectorList = stylesheet.selectorText.split(/,/gm).filter(Boolean).map((i2) => i2.trim());
         for (let j = 0; j < selectorList.length; j++) {
-          stylesheets[selectorList[j]] = Object.assign(stylesheets[selectorList[j]] || {}, stylesheet.style);
+          const definitions = Object.fromEntries(Object.entries(stylesheet.style).filter(([, v]) => v !== ""));
+          stylesheets[selectorList[j]] = Object.assign(stylesheets[selectorList[j]] || {}, definitions);
         }
       }
     }
@@ -530,7 +535,7 @@ class SVGLoader extends THREE.Loader {
         }
         index++;
       }
-      const regex = /(-?[\d\.?]+)[,|\s](-?[\d\.?]+)/g;
+      const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g;
       const path = new THREE.ShapePath();
       let index = 0;
       node.getAttribute("points").replace(regex, iterator);
@@ -548,7 +553,7 @@ class SVGLoader extends THREE.Loader {
         }
         index++;
       }
-      const regex = /(-?[\d\.?]+)[,|\s](-?[\d\.?]+)/g;
+      const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g;
       const path = new THREE.ShapePath();
       let index = 0;
       node.getAttribute("points").replace(regex, iterator);
@@ -600,13 +605,12 @@ class SVGLoader extends THREE.Loader {
         stylesheetStyles = Object.assign(stylesheetStyles, stylesheets["#" + node.getAttribute("id")]);
       }
       function addStyle(svgName, jsName, adjustFunction) {
-        if (adjustFunction === void 0) {
+        if (adjustFunction === void 0)
           adjustFunction = function copy(v) {
             if (v.startsWith("url"))
               console.warn("SVGLoader: url access in attributes is not implemented.");
             return v;
           };
-        }
         if (node.hasAttribute(svgName))
           style[jsName] = adjustFunction(node.getAttribute(svgName));
         if (stylesheetStyles[svgName])
@@ -871,14 +875,14 @@ class SVGLoader extends THREE.Loader {
           const openParPos = transformText.indexOf("(");
           const closeParPos = transformText.length;
           if (openParPos > 0 && openParPos < closeParPos) {
-            const transformType = transformText.substr(0, openParPos);
-            const array = parseFloats(transformText.substr(openParPos + 1, closeParPos - openParPos - 1));
+            const transformType = transformText.slice(0, openParPos);
+            const array = parseFloats(transformText.slice(openParPos + 1));
             currentTransform2.identity();
             switch (transformType) {
               case "translate":
                 if (array.length >= 1) {
                   const tx = array[0];
-                  let ty = tx;
+                  let ty = 0;
                   if (array.length >= 2) {
                     ty = array[1];
                   }
@@ -890,15 +894,15 @@ class SVGLoader extends THREE.Loader {
                   let angle = 0;
                   let cx = 0;
                   let cy = 0;
-                  angle = -array[0] * Math.PI / 180;
+                  angle = array[0] * Math.PI / 180;
                   if (array.length >= 3) {
                     cx = array[1];
                     cy = array[2];
                   }
-                  tempTransform1.identity().translate(-cx, -cy);
-                  tempTransform2.identity().rotate(angle);
+                  tempTransform1.makeTranslation(-cx, -cy);
+                  tempTransform2.makeRotation(angle);
                   tempTransform3.multiplyMatrices(tempTransform2, tempTransform1);
-                  tempTransform1.identity().translate(cx, cy);
+                  tempTransform1.makeTranslation(cx, cy);
                   currentTransform2.multiplyMatrices(tempTransform1, tempTransform3);
                 }
                 break;
@@ -939,7 +943,55 @@ class SVGLoader extends THREE.Loader {
         tempV3.set(v2.x, v2.y, 1).applyMatrix3(m);
         v2.set(tempV3.x, tempV3.y);
       }
-      const isRotated = isTransformRotated(m);
+      function transfEllipseGeneric(curve) {
+        const a = curve.xRadius;
+        const b = curve.yRadius;
+        const cosTheta = Math.cos(curve.aRotation);
+        const sinTheta = Math.sin(curve.aRotation);
+        const v1 = new THREE.Vector3(a * cosTheta, a * sinTheta, 0);
+        const v2 = new THREE.Vector3(-b * sinTheta, b * cosTheta, 0);
+        const f1 = v1.applyMatrix3(m);
+        const f2 = v2.applyMatrix3(m);
+        const mF = tempTransform0.set(f1.x, f2.x, 0, f1.y, f2.y, 0, 0, 0, 1);
+        const mFInv = tempTransform1.copy(mF).invert();
+        const mFInvT = tempTransform2.copy(mFInv).transpose();
+        const mQ = mFInvT.multiply(mFInv);
+        const mQe = mQ.elements;
+        const ed = eigenDecomposition(mQe[0], mQe[1], mQe[4]);
+        const rt1sqrt = Math.sqrt(ed.rt1);
+        const rt2sqrt = Math.sqrt(ed.rt2);
+        curve.xRadius = 1 / rt1sqrt;
+        curve.yRadius = 1 / rt2sqrt;
+        curve.aRotation = Math.atan2(ed.sn, ed.cs);
+        const isFullEllipse = (curve.aEndAngle - curve.aStartAngle) % (2 * Math.PI) < Number.EPSILON;
+        if (!isFullEllipse) {
+          const mDsqrt = tempTransform1.set(rt1sqrt, 0, 0, 0, rt2sqrt, 0, 0, 0, 1);
+          const mRT = tempTransform2.set(ed.cs, ed.sn, 0, -ed.sn, ed.cs, 0, 0, 0, 1);
+          const mDRF = mDsqrt.multiply(mRT).multiply(mF);
+          const transformAngle = (phi) => {
+            const { x: cosR, y: sinR } = new THREE.Vector3(Math.cos(phi), Math.sin(phi), 0).applyMatrix3(mDRF);
+            return Math.atan2(sinR, cosR);
+          };
+          curve.aStartAngle = transformAngle(curve.aStartAngle);
+          curve.aEndAngle = transformAngle(curve.aEndAngle);
+          if (isTransformFlipped(m)) {
+            curve.aClockwise = !curve.aClockwise;
+          }
+        }
+      }
+      function transfEllipseNoSkew(curve) {
+        const sx = getTransformScaleX(m);
+        const sy = getTransformScaleY(m);
+        curve.xRadius *= sx;
+        curve.yRadius *= sy;
+        const theta = sx > Number.EPSILON ? Math.atan2(m.elements[1], m.elements[0]) : Math.atan2(-m.elements[3], m.elements[4]);
+        curve.aRotation += theta;
+        if (isTransformFlipped(m)) {
+          curve.aStartAngle *= -1;
+          curve.aEndAngle *= -1;
+          curve.aClockwise = !curve.aClockwise;
+        }
+      }
       const subPaths = path.subPaths;
       for (let i = 0, n = subPaths.length; i < n; i++) {
         const subPath = subPaths[i];
@@ -959,21 +1011,31 @@ class SVGLoader extends THREE.Loader {
             transfVec2(curve.v1);
             transfVec2(curve.v2);
           } else if (curve.isEllipseCurve) {
-            if (isRotated) {
-              console.warn("SVGLoader: Elliptic arc or ellipse rotation or skewing is not implemented.");
-            }
             tempV2.set(curve.aX, curve.aY);
             transfVec2(tempV2);
             curve.aX = tempV2.x;
             curve.aY = tempV2.y;
-            curve.xRadius *= getTransformScaleX(m);
-            curve.yRadius *= getTransformScaleY(m);
+            if (isTransformSkewed(m)) {
+              transfEllipseGeneric(curve);
+            } else {
+              transfEllipseNoSkew(curve);
+            }
           }
         }
       }
     }
-    function isTransformRotated(m) {
-      return m.elements[1] !== 0 || m.elements[3] !== 0;
+    function isTransformFlipped(m) {
+      const te = m.elements;
+      return te[0] * te[4] - te[1] * te[3] < 0;
+    }
+    function isTransformSkewed(m) {
+      const te = m.elements;
+      const basisDot = te[0] * te[3] + te[1] * te[4];
+      if (basisDot === 0)
+        return false;
+      const sx = getTransformScaleX(m);
+      const sy = getTransformScaleY(m);
+      return Math.abs(basisDot / (sx * sy)) > Number.EPSILON;
     }
     function getTransformScaleX(m) {
       const te = m.elements;
@@ -983,6 +1045,45 @@ class SVGLoader extends THREE.Loader {
       const te = m.elements;
       return Math.sqrt(te[3] * te[3] + te[4] * te[4]);
     }
+    function eigenDecomposition(A, B, C) {
+      let rt1, rt2, cs, sn, t;
+      const sm = A + C;
+      const df = A - C;
+      const rt = Math.sqrt(df * df + 4 * B * B);
+      if (sm > 0) {
+        rt1 = 0.5 * (sm + rt);
+        t = 1 / rt1;
+        rt2 = A * t * C - B * t * B;
+      } else if (sm < 0) {
+        rt2 = 0.5 * (sm - rt);
+      } else {
+        rt1 = 0.5 * rt;
+        rt2 = -0.5 * rt;
+      }
+      if (df > 0) {
+        cs = df + rt;
+      } else {
+        cs = df - rt;
+      }
+      if (Math.abs(cs) > 2 * Math.abs(B)) {
+        t = -2 * B / cs;
+        sn = 1 / Math.sqrt(1 + t * t);
+        cs = t * sn;
+      } else if (Math.abs(B) === 0) {
+        cs = 1;
+        sn = 0;
+      } else {
+        t = -0.5 * cs / B;
+        cs = 1 / Math.sqrt(1 + t * t);
+        sn = t * cs;
+      }
+      if (df > 0) {
+        t = cs;
+        cs = -sn;
+        sn = t;
+      }
+      return { rt1, rt2, cs, sn };
+    }
     const paths = [];
     const stylesheets = {};
     const transformStack = [];
@@ -1182,13 +1283,13 @@ class SVGLoader extends THREE.Loader {
         let isHoleFor = null;
         let lastCWValue = null;
         for (let i2 = 0; i2 < stack.length; i2++) {
-          const identifier2 = stack[i2];
+          const identifier = stack[i2];
           if (isHole) {
-            lastCWValue = allPaths[identifier2].isCW;
+            lastCWValue = allPaths[identifier].isCW;
             isHole = false;
-            isHoleFor = identifier2;
-          } else if (lastCWValue !== allPaths[identifier2].isCW) {
-            lastCWValue = allPaths[identifier2].isCW;
+            isHoleFor = identifier;
+          } else if (lastCWValue !== allPaths[identifier].isCW) {
+            lastCWValue = allPaths[identifier].isCW;
             isHole = true;
           }
         }
@@ -1197,7 +1298,6 @@ class SVGLoader extends THREE.Loader {
         console.warn('fill-rule: "' + _fillRule + '" is currently not implemented.');
       }
     }
-    let identifier = 0;
     let scanlineMinX = BIGNUMBER;
     let scanlineMaxX = -BIGNUMBER;
     let simplePaths = shapePath.subPaths.map((p) => {
@@ -1231,13 +1331,22 @@ class SVGLoader extends THREE.Loader {
         curves: p.curves,
         points,
         isCW: THREE.ShapeUtils.isClockWise(points),
-        identifier: identifier++,
+        identifier: -1,
         boundingBox: new THREE.Box2(new THREE.Vector2(minX, minY), new THREE.Vector2(maxX, maxY))
       };
     });
     simplePaths = simplePaths.filter((sp) => sp.points.length > 1);
+    for (let identifier = 0; identifier < simplePaths.length; identifier++) {
+      simplePaths[identifier].identifier = identifier;
+    }
     const isAHole = simplePaths.map(
-      (p) => isHoleTo(p, simplePaths, scanlineMinX, scanlineMaxX, shapePath.userData.style.fillRule)
+      (p) => isHoleTo(
+        p,
+        simplePaths,
+        scanlineMinX,
+        scanlineMaxX,
+        shapePath.userData ? shapePath.userData.style.fillRule : void 0
+      )
     );
     const shapesToReturn = [];
     simplePaths.forEach((p) => {
@@ -1333,9 +1442,8 @@ class SVGLoader extends THREE.Loader {
       if (iPoint === numPoints - 1) {
         if (isClosed) {
           nextPoint = points[1];
-        } else {
+        } else
           nextPoint = void 0;
-        }
       } else {
         nextPoint = points[iPoint + 1];
       }
@@ -1361,7 +1469,7 @@ class SVGLoader extends THREE.Loader {
         tempV2_3.subVectors(nextPoint, currentPoint);
         tempV2_3.normalize();
         const dot = Math.abs(normal1.dot(tempV2_3));
-        if (dot !== 0) {
+        if (dot > Number.EPSILON) {
           const miterSide = strokeWidth2 / dot;
           tempV2_3.multiplyScalar(-miterSide);
           tempV2_4.subVectors(currentPoint, previousPoint);
@@ -1571,8 +1679,8 @@ class SVGLoader extends THREE.Loader {
       addVertex(lastPointL, u0, 0);
       addVertex(currentPointL, u1, 0);
       addVertex(lastPointR, u0, 1);
-      addVertex(currentPointL, u1, 1);
-      addVertex(currentPointR, u1, 0);
+      addVertex(currentPointL, u1, 0);
+      addVertex(currentPointR, u1, 1);
     }
     function makeSegmentWithBevelJoin(joinIsOnLeftSide2, innerSideModified2, u) {
       if (innerSideModified2) {
@@ -1594,8 +1702,8 @@ class SVGLoader extends THREE.Loader {
           addVertex(innerPoint, u1, 0);
           addVertex(currentPointR, u1, 1);
           addVertex(currentPointR, u, 1);
-          addVertex(nextPointR, u, 0);
-          addVertex(innerPoint, u, 0.5);
+          addVertex(innerPoint, u, 0);
+          addVertex(nextPointR, u, 1);
         }
       } else {
         if (joinIsOnLeftSide2) {
@@ -1661,7 +1769,7 @@ class SVGLoader extends THREE.Loader {
               tempV2_4.toArray(vertices, 3 * 3);
             } else {
               tempV2_3.toArray(vertices, 1 * 3);
-              tempV2_3.toArray(vertices, 3 * 3);
+              uvs[3 * 2 + 1] === 1 ? tempV2_4.toArray(vertices, 3 * 3) : tempV2_3.toArray(vertices, 3 * 3);
               tempV2_4.toArray(vertices, 0 * 3);
             }
           } else {
@@ -1675,8 +1783,8 @@ class SVGLoader extends THREE.Loader {
               tempV2_4.toArray(vertices, vl - 2 * 3);
               tempV2_4.toArray(vertices, vl - 4 * 3);
             } else {
-              tempV2_3.toArray(vertices, vl - 2 * 3);
-              tempV2_4.toArray(vertices, vl - 1 * 3);
+              tempV2_4.toArray(vertices, vl - 2 * 3);
+              tempV2_3.toArray(vertices, vl - 1 * 3);
               tempV2_4.toArray(vertices, vl - 4 * 3);
             }
           }