poly-extrude 0.16.0 → 0.17.0

package/dist/poly-extrude.mjs

@@ -1,5 +1,5 @@
 /*!
- * poly-extrude v0.16.0
+ * poly-extrude v0.17.0
   */
 function _defineProperties(target, props) {
   for (var i = 0; i < props.length; i++) {
@@ -1693,6 +1693,12 @@ var Vector3 = /*#__PURE__*/function () {
   return Vector3;
 }();
 
+function mergeArray(array1, array2) {
+    let index = array1.length - 1;
+    for (let i = 0, len = array2.length; i < len; i++) {
+        array1[++index] = array2[i];
+    }
+}
 /**
  * https://github.com/Turfjs/turf/blob/master/packages/turf-boolean-clockwise/index.ts
  * @param {*} ring
@@ -1712,6 +1718,63 @@ function isClockwise(ring) {
     }
     return sum > 0;
 }
+function validateRing(ring) {
+    if (!isClosedRing(ring)) {
+        ring.push(ring[0]);
+    }
+}
+function isClosedRing(ring) {
+    const len = ring.length;
+    const [x1, y1] = ring[0], [x2, y2] = ring[len - 1];
+    return (x1 === x2 && y1 === y2);
+}
+function calPolygonPointsCount(polygon) {
+    let count = 0;
+    let i = 0;
+    const len = polygon.length;
+    while (i < len) {
+        count += (polygon[i].length);
+        i++;
+    }
+    return count;
+}
+function getPolygonsBBOX(polygons, bbox) {
+    bbox = bbox || [Infinity, Infinity, -Infinity, -Infinity];
+    for (let i = 0, len = polygons.length; i < len; i++) {
+        const p = polygons[i];
+        if (Array.isArray(p[0][0])) {
+            getPolygonsBBOX(p, bbox);
+        }
+        else {
+            for (let j = 0, len1 = p.length; j < len1; j++) {
+                const c = p[j];
+                const [x, y] = c;
+                bbox[0] = Math.min(bbox[0], x);
+                bbox[1] = Math.min(bbox[1], y);
+                bbox[2] = Math.max(bbox[2], x);
+                bbox[3] = Math.max(bbox[3], y);
+            }
+        }
+    }
+    return bbox;
+}
+function validatePolygon(polygon) {
+    for (let i = 0, len = polygon.length; i < len; i++) {
+        const ring = polygon[i];
+        validateRing(ring);
+        if (i === 0) {
+            if (!isClockwise(ring)) {
+                polygon[i] = ring.reverse();
+            }
+        }
+        else if (isClockwise(ring)) {
+            polygon[i] = ring.reverse();
+        }
+        if (isClosedRing(ring)) {
+            ring.splice(ring.length - 1, 1);
+        }
+    }
+}
 function v3Sub(out, v1, v2) {
     out[0] = v1[0] - v2[0];
     out[1] = v1[1] - v2[1];
@@ -1912,21 +1975,7 @@ function calLineDistance(line) {
 function extrudePolygons(polygons, options) {
     options = Object.assign({}, { depth: 2, top: true }, options);
     const results = polygons.map(polygon => {
-        for (let i = 0, len = polygon.length; i < len; i++) {
-            const ring = polygon[i];
-            validateRing(ring);
-            if (i === 0) {
-                if (!isClockwise(ring)) {
-                    polygon[i] = ring.reverse();
-                }
-            }
-            else if (isClockwise(ring)) {
-                polygon[i] = ring.reverse();
-            }
-            if (isClosedRing(ring)) {
-                ring.splice(ring.length - 1, 1);
-            }
-        }
+        validatePolygon(polygon);
         const result = flatVertices(polygon, options);
         result.polygon = polygon;
         const triangles = earcut(result.flatVertices, result.holes, 2);
@@ -2011,16 +2060,6 @@ function generateSides$1(result, options) {
         }
     }
 }
-function calPolygonPointsCount(polygon) {
-    let count = 0;
-    let i = 0;
-    const len = polygon.length;
-    while (i < len) {
-        count += (polygon[i].length);
-        i++;
-    }
-    return count;
-}
 function flatVertices(polygon, options) {
     const count = calPolygonPointsCount(polygon);
     const len = polygon.length;
@@ -2065,15 +2104,49 @@ function flatVertices(polygon, options) {
         uv
     };
 }
-function validateRing(ring) {
-    if (!isClosedRing(ring)) {
-        ring.push(ring[0]);
+function simplePolygon(polygon, options = {}) {
+    const flatVertices = [], holes = [];
+    let pIndex = -1, aIndex = -1, uvIndex = -1;
+    const points = [], uv = [];
+    for (let i = 0, len = polygon.length; i < len; i++) {
+        const ring = polygon[i];
+        if (i > 0) {
+            holes.push(flatVertices.length / 2);
+        }
+        for (let j = 0, len1 = ring.length; j < len1; j++) {
+            const c = ring[j];
+            flatVertices[++pIndex] = c[0];
+            flatVertices[++pIndex] = c[1];
+            points[++aIndex] = c[0];
+            points[++aIndex] = c[1];
+            points[++aIndex] = c[2] || 0;
+            uv[++uvIndex] = c[0];
+            uv[++uvIndex] = c[1];
+        }
     }
+    const triangles = earcut(flatVertices, holes, 2);
+    const normal = generateNormal(triangles, points);
+    return {
+        normal,
+        uv,
+        points,
+        indices: triangles
+    };
 }
-function isClosedRing(ring) {
-    const len = ring.length;
-    const [x1, y1] = ring[0], [x2, y2] = ring[len - 1];
-    return (x1 === x2 && y1 === y2);
+function polygons(polygons, options = {}) {
+    const results = polygons.map(polygon => {
+        validatePolygon(polygon);
+        const result = simplePolygon(polygon, options);
+        result.polygon = polygon;
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
+        result.normal = new Float32Array(result.normal);
+        return result;
+    });
+    const result = merge(results);
+    result.polygons = polygons;
+    return result;
 }
 
 function checkOptions(options) {
@@ -2369,7 +2442,7 @@ function expandLine(line, options) {
             TEMPV1.y = p0[1] - p1[1];
             TEMPV2.x = p2[0] - p1[0];
             TEMPV2.y = p2[1] - p1[1];
-            const vAngle = getAngle(TEMPV1, TEMPV2);
+            const vAngle = getAngle$1(TEMPV1, TEMPV2);
             rAngle = angle - vAngle / 2;
         }
         const rRad = degToRad(rAngle);
@@ -2406,7 +2479,7 @@ function expandLine(line, options) {
     }
     return { offsetPoints: points, leftPoints, rightPoints, line };
 }
-const getAngle = ({ x: x1, y: y1 }, { x: x2, y: y2 }) => {
+const getAngle$1 = ({ x: x1, y: y1 }, { x: x2, y: y2 }) => {
     const dot = x1 * x2 + y1 * y2;
     const det = x1 * y2 - y1 * x2;
     const angle = Math.atan2(det, dot) / Math.PI * 180;
@@ -3883,7 +3956,7 @@ var PathPointList = /*#__PURE__*/function () {
   return PathPointList;
 }();
 
-const UP$1 = new Vector3(0, 0, 1);
+const UP$2 = new Vector3(0, 0, 1);
 const right = new Vector3();
 const left = new Vector3();
 // for sharp corners
@@ -3897,7 +3970,7 @@ function expandPaths(lines, options) {
         const points = line2Vectors(line);
         const pathPointList = new PathPointList();
         //@ts-ignore
-        pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP$1);
+        pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP$2);
         const params = generatePathVertexData(pathPointList, options);
         const result = {
             position: new Float32Array(params.position),
@@ -4206,15 +4279,15 @@ function generatePathVertexData(pathPointList, options) {
     };
 }
 
-const UP = new Vector3(0, 0, 1);
-const normalDir = new Vector3();
+const UP$1 = new Vector3(0, 0, 1);
+const normalDir$1 = new Vector3();
 function expandTubes(lines, options) {
     options = Object.assign({}, { radius: 1, cornerSplit: 0, radialSegments: 8, startRad: -Math.PI / 4 }, options);
     const results = lines.map(line => {
         const points = line2Vectors(line);
         const pathPointList = new PathPointList();
         //@ts-ignore
-        pathPointList.set(points, 0, options.cornerSplit, UP);
+        pathPointList.set(points, 0, options.cornerSplit, UP$1);
         const result = generateTubeVertexData(pathPointList, options);
         result.line = line;
         result.position = new Float32Array(result.points);
@@ -4261,14 +4334,14 @@ function generateTubeVertexData(pathPointList, options) {
             if (r === radialSegments) {
                 r = 0;
             }
-            normalDir.copy(pathPoint.up).applyAxisAngle(pathPoint.dir, startRad + Math.PI * 2 * r / radialSegments).normalize();
+            normalDir$1.copy(pathPoint.up).applyAxisAngle(pathPoint.dir, startRad + Math.PI * 2 * r / radialSegments).normalize();
             const scale = radius * pathPoint.widthScale;
-            points[++pIndex] = pathPoint.pos.x + normalDir.x * scale;
-            points[++pIndex] = pathPoint.pos.y + normalDir.y * scale;
-            points[++pIndex] = pathPoint.pos.z + normalDir.z * scale;
-            normal[++nIndex] = normalDir.x;
-            normal[++nIndex] = normalDir.y;
-            normal[++nIndex] = normalDir.z;
+            points[++pIndex] = pathPoint.pos.x + normalDir$1.x * scale;
+            points[++pIndex] = pathPoint.pos.y + normalDir$1.y * scale;
+            points[++pIndex] = pathPoint.pos.z + normalDir$1.z * scale;
+            normal[++nIndex] = normalDir$1.x;
+            normal[++nIndex] = normalDir$1.y;
+            normal[++nIndex] = normalDir$1.z;
             uv[++uIndex] = uvDist;
             uv[++uIndex] = i / radialSegments;
             // uvs.push(uvDist, r / radialSegments);
@@ -4383,5 +4456,263 @@ function plane(width, height, devideW, devideH) {
     };
 }
 
-export { cylinder, expandLine, expandPaths, expandTubes, extrudePolygons, extrudePolylines, extrudeSlopes, isClockwise, leftOnLine, merge, plane };
+const UP = new Vector3(0, 0, 1);
+const normalDir = new Vector3();
+function extrudePolygonsOnPath(polygons, options) {
+    options = Object.assign({}, { openEnd: false, openEndUV: true }, options);
+    const { extrudePath, openEnd } = options;
+    if (!extrudePath || !Array.isArray(extrudePath) || extrudePath.length < 2) {
+        console.error('extrudePath is error:', extrudePath);
+        return null;
+    }
+    const bbox = getPolygonsBBOX(polygons);
+    const [minx, miny, maxx, maxy] = bbox;
+    const center = [(minx + maxx) / 2, (miny + maxy) / 2];
+    const points = line2Vectors(extrudePath);
+    const pathPointList = new PathPointList();
+    //@ts-ignore
+    pathPointList.set(points, 0, options.cornerSplit, UP);
+    const results = polygons.map(polygon => {
+        for (let i = 0, len = polygon.length; i < len; i++) {
+            const ring = polygon[i];
+            validateRing(ring);
+            if (i === 0) {
+                if (isClockwise(ring)) {
+                    polygon[i] = ring.reverse();
+                }
+            }
+            else if (!isClockwise(ring)) {
+                polygon[i] = ring.reverse();
+            }
+        }
+        const result = generatePolygonOnPathVertexData(pathPointList, polygon, center);
+        if (!openEnd) {
+            generateStartAndEnd(result, polygon, options);
+        }
+        result.polygon = polygon;
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
+        result.normal = new Float32Array(result.normal);
+        return result;
+    });
+    const result = merge(results);
+    result.polygons = polygons;
+    return result;
+}
+function getAngle(c1, c2) {
+    const [x1, y1] = c1;
+    const [x2, y2] = c2;
+    const dy = y2 - y1;
+    const dx = x2 - x1;
+    return Math.atan2(dy, dx);
+}
+function transformPolygon(polygon, center) {
+    const [cx, cy] = center;
+    const list = [];
+    polygon.forEach((ring, rIndex) => {
+        const data = [];
+        let totalDistance = 0;
+        let tempPoint;
+        for (let i = 0, len = ring.length; i < len; i++) {
+            const p = ring[i];
+            const x1 = p[0], y1 = p[1];
+            const offsetx = x1 - cx, offsety = y1 - cy;
+            let distance = 0;
+            if (i > 0) {
+                const x2 = tempPoint[0], y2 = tempPoint[1];
+                const dx = x2 - x1, dy = y2 - y1;
+                distance = Math.sqrt(dx * dx + dy * dy) + totalDistance;
+                totalDistance = distance;
+            }
+            data[i] = {
+                // dx,
+                // dy,
+                // dz: 0,
+                distance,
+                radius: Math.sqrt(offsetx * offsetx + offsety * offsety),
+                angle: getAngle(center, p)
+            };
+            tempPoint = p;
+        }
+        list[rIndex] = {
+            ring: data,
+            ringLen: totalDistance
+        };
+    });
+    return list;
+}
+const TEMP_VECTOR3 = new Vector3(0, 0, 0);
+// Vertex Data Generate Functions
+// code copy from https://github.com/shawn0326/three.path/blob/master/src/PathGeometry.js
+function generatePolygonOnPathVertexData(pathPointList, polygon, center) {
+    const tpolygon = transformPolygon(polygon, center);
+    // let count = 0;
+    // modify data
+    const points = [];
+    const normal = [];
+    const uv = [];
+    // const uv2 = [];
+    const indices = [];
+    let verticesCount = 0;
+    let pIndex = -1;
+    let nIndex = -1;
+    let uIndex = -1;
+    let iIndex = -1;
+    const startPoints = [], endPoints = [];
+    function addVertices(pathPoint, ring, ringLen, first, end) {
+        const uvDist = pathPoint.dist / ringLen;
+        const radialSegments = ring.length;
+        // const startRad = ring[0].angle;
+        for (let i = 0; i < radialSegments; i++) {
+            const item = ring[i];
+            if (!item) {
+                continue;
+            }
+            const isLast = i === radialSegments - 1;
+            const angle = item.angle;
+            const radius = item.radius;
+            const distance = item.distance;
+            normalDir.copy(pathPoint.up).applyAxisAngle(pathPoint.dir, angle).normalize();
+            const v = TEMP_VECTOR3.copy(pathPoint.up);
+            v.applyAxisAngle(pathPoint.dir, angle);
+            v.x *= radius;
+            v.y *= radius;
+            v.z *= radius;
+            points[++pIndex] = pathPoint.pos.x + v.x;
+            points[++pIndex] = pathPoint.pos.y + v.y;
+            points[++pIndex] = pathPoint.pos.z + v.z;
+            // if (i === 0 || i === radialSegments - 1) {
+            //     console.log(i, radialSegments, v.x, v.y, v.z);
+            // }
+            normal[++nIndex] = normalDir.x;
+            normal[++nIndex] = normalDir.y;
+            normal[++nIndex] = normalDir.z;
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = distance / ringLen;
+            verticesCount++;
+            if (first && !isLast) {
+                let index = startPoints.length - 1;
+                startPoints[++index] = pathPoint.pos.x + v.x;
+                startPoints[++index] = pathPoint.pos.y + v.y;
+                startPoints[++index] = pathPoint.pos.z + v.z;
+            }
+            if (end && !isLast) {
+                let index = endPoints.length - 1;
+                endPoints[++index] = pathPoint.pos.x + v.x;
+                endPoints[++index] = pathPoint.pos.y + v.y;
+                endPoints[++index] = pathPoint.pos.z + v.z;
+            }
+        }
+        if (!first) {
+            const begin1 = verticesCount - (radialSegments) * 2;
+            const begin2 = verticesCount - (radialSegments);
+            for (let i = 0; i < radialSegments; i++) {
+                indices[++iIndex] = begin2 + i;
+                indices[++iIndex] = begin1 + i;
+                indices[++iIndex] = begin1 + i + 1;
+                indices[++iIndex] = begin2 + i;
+                indices[++iIndex] = begin1 + i + 1;
+                indices[++iIndex] = begin2 + i + 1;
+            }
+        }
+    }
+    const polygonLen = tpolygon[0].ringLen;
+    tpolygon.forEach(item => {
+        for (let i = 0; i < pathPointList.count; i++) {
+            const pathPoint = pathPointList.array[i];
+            const { ring, ringLen } = item;
+            addVertices(pathPoint, ring, ringLen, i === 0, i === pathPointList.count - 1);
+        }
+    });
+    return {
+        points,
+        normal,
+        uv,
+        // uv2,
+        indices,
+        startPoints,
+        endPoints,
+        polygonLen
+        // count
+    };
+}
+function generateStartAndEnd(result, polygon, options) {
+    const { openEndUV } = options;
+    for (let i = 0, len = polygon.length; i < len; i++) {
+        const ring = polygon[i];
+        if (isClosedRing(ring)) {
+            ring.splice(ring.length - 1, 1);
+        }
+    }
+    const pointCount = calPolygonPointsCount(polygon);
+    const flatVertices = [], holes = [];
+    let pIndex = -1;
+    for (let i = 0, len = polygon.length; i < len; i++) {
+        const ring = polygon[i];
+        if (i > 0) {
+            holes.push(flatVertices.length / 2);
+        }
+        for (let j = 0, len1 = ring.length; j < len1; j++) {
+            const c = ring[j];
+            flatVertices[++pIndex] = c[0];
+            flatVertices[++pIndex] = c[1];
+        }
+    }
+    const triangles = earcut(flatVertices, holes, 2);
+    const { points, normal, uv, indices, startPoints, endPoints, polygonLen } = result;
+    pIndex = 0;
+    let uIndex = 0;
+    const aPoints1 = [], auv1 = [], aPoints2 = [], auv2 = [];
+    for (let i = 0; i < pointCount; i++) {
+        const idx = i * 3;
+        const x = startPoints[idx];
+        const y = startPoints[idx + 1];
+        const z = startPoints[idx + 2];
+        aPoints1[pIndex] = x;
+        aPoints1[pIndex + 1] = y;
+        aPoints1[pIndex + 2] = z;
+        if (openEndUV) {
+            auv1[uIndex] = y / polygonLen;
+            auv1[uIndex + 1] = z / polygonLen;
+        }
+        else {
+            auv1[uIndex] = 0;
+            auv1[uIndex + 1] = 0;
+        }
+        const x1 = endPoints[idx];
+        const y1 = endPoints[idx + 1];
+        const z1 = endPoints[idx + 2];
+        aPoints2[pIndex] = x1;
+        aPoints2[pIndex + 1] = y1;
+        aPoints2[pIndex + 2] = z1;
+        if (openEndUV) {
+            auv2[uIndex] = y1 / polygonLen;
+            auv2[uIndex + 1] = z1 / polygonLen;
+        }
+        else {
+            auv2[uIndex] = 0;
+            auv2[uIndex + 1] = 0;
+        }
+        pIndex += 3;
+        uIndex += 2;
+    }
+    const indexOffset = points.length / 3;
+    const indexs = [];
+    for (let i = 0, len = triangles.length; i < len; i++) {
+        indexs[i] = triangles[i] + indexOffset;
+        indexs[i + len] = triangles[i] + indexOffset + pointCount;
+    }
+    const anormal1 = generateNormal(triangles, aPoints1);
+    const anormal2 = generateNormal(triangles, aPoints2);
+    mergeArray(points, aPoints1);
+    mergeArray(points, aPoints2);
+    mergeArray(uv, auv1);
+    mergeArray(uv, auv2);
+    mergeArray(normal, anormal1);
+    mergeArray(normal, anormal2);
+    mergeArray(indices, indexs);
+}
+
+export { cylinder, expandLine, expandPaths, expandTubes, extrudePolygons, extrudePolygonsOnPath, extrudePolylines, extrudeSlopes, isClockwise, leftOnLine, merge, plane, polygons };
 //# sourceMappingURL=poly-extrude.mjs.map