poly-extrude 0.12.0 → 0.14.0

package/src/path.ts

@@ -0,0 +1,385 @@
+import { Vector3 } from './math/Vector3';
+import { PathPoint } from './path/PathPoint';
+import { PathPointList } from './path/PathPointList';
+import { PolylineType, ResultType } from './type';
+import { line2Vectors, merge } from './util';
+const UP = new Vector3(0, 0, 1);
+
+const right = new Vector3();
+const left = new Vector3();
+
+// for sharp corners
+const leftOffset = new Vector3();
+const rightOffset = new Vector3();
+const tempPoint1 = new Vector3();
+const tempPoint2 = new Vector3();
+
+type PathsOptions = {
+    lineWidth?: number;
+    cornerRadius?: number;
+    cornerSplit?: number;
+}
+
+type PathsResult = ResultType & {
+    lines: Array<PolylineType>;
+}
+
+export function expandPaths(lines: Array<PolylineType>, options?: PathsOptions): PathsResult {
+    options = Object.assign({}, { lineWidth: 1, cornerRadius: 0, cornerSplit: 10 }, options);
+    const results = lines.map(line => {
+        const points = line2Vectors(line);
+        const pathPointList = new PathPointList();
+        //@ts-ignore
+        pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP);
+        const params = generatePathVertexData(pathPointList, options);
+
+        const result = {
+            position: new Float32Array(params.position),
+            indices: new Uint32Array(params.indices),
+            uv: new Float32Array(params.uv),
+            normal: new Float32Array(params.normal),
+            line,
+            count: params.count
+        }
+        return result;
+    });
+    const result = merge(results) as PathsResult;
+    result.lines = lines;
+    return result;
+}
+
+// Vertex Data Generate Functions
+// code copy from https://github.com/shawn0326/three.path/blob/master/src/PathGeometry.js
+function generatePathVertexData(pathPointList, options: PathsOptions) {
+    const width = options.lineWidth || 0.1;
+    const progress = 1;
+    const side = 'both';
+
+    const halfWidth = width / 2;
+    const sideWidth = (side !== 'both' ? width / 2 : width);
+    const totalDistance = pathPointList.distance();
+    const progressDistance = progress * totalDistance;
+
+    let count = 0;
+
+    // modify data
+    const position: number[] = [];
+    const normal: number[] = [];
+    const uv: number[] = [];
+    const indices: number[] = [];
+    let verticesCount = 0;
+
+    if (totalDistance === 0) {
+        return {
+            position: position,
+            normal,
+            uv: uv,
+            indices: indices,
+            count
+        }
+    }
+
+    const sharpUvOffset = halfWidth / sideWidth;
+    // const sharpUvOffset2 = halfWidth / totalDistance;
+
+
+    let pIndex = position.length - 1;
+    let nIndex = normal.length - 1;
+    let uIndex = uv.length - 1;
+    let iIndex = indices.length - 1;
+    function addVertices(pathPoint) {
+        const first = position.length === 0;
+        const sharpCorner = pathPoint.sharp && !first;
+
+        const uvDist = pathPoint.dist / sideWidth;
+        // const uvDist2 = pathPoint.dist / totalDistance;
+
+        const dir = pathPoint.dir;
+        const up = pathPoint.up;
+        const _right = pathPoint.right;
+
+        //@ts-ignore
+        if (side !== 'left') {
+            right.copy(_right).multiplyScalar(halfWidth * pathPoint.widthScale);
+        } else {
+            right.set(0, 0, 0);
+        }
+        //@ts-ignore
+        if (side !== 'right') {
+            left.copy(_right).multiplyScalar(-halfWidth * pathPoint.widthScale);
+        } else {
+            left.set(0, 0, 0);
+        }
+
+        right.add(pathPoint.pos);
+        left.add(pathPoint.pos);
+
+        if (sharpCorner) {
+            leftOffset.fromArray(position, position.length - 6).sub(left);
+            rightOffset.fromArray(position, position.length - 3).sub(right);
+
+            const leftDist = leftOffset.length();
+            const rightDist = rightOffset.length();
+
+            const sideOffset = leftDist - rightDist;
+            let longerOffset, longEdge;
+
+            if (sideOffset > 0) {
+                longerOffset = leftOffset;
+                longEdge = left;
+            } else {
+                longerOffset = rightOffset;
+                longEdge = right;
+            }
+
+            tempPoint1.copy(longerOffset).setLength(Math.abs(sideOffset)).add(longEdge);
+
+            // eslint-disable-next-line prefer-const
+            let _cos = tempPoint2.copy(longEdge).sub(tempPoint1).normalize().dot(dir);
+            // eslint-disable-next-line prefer-const
+            let _len = tempPoint2.copy(longEdge).sub(tempPoint1).length();
+            // eslint-disable-next-line prefer-const
+            let _dist = _cos * _len * 2;
+
+            tempPoint2.copy(dir).setLength(_dist).add(tempPoint1);
+
+            if (sideOffset > 0) {
+                position[++pIndex] = tempPoint1.x;
+                position[++pIndex] = tempPoint1.y;
+                position[++pIndex] = tempPoint1.z;
+                position[++pIndex] = right.x;
+                position[++pIndex] = right.y;
+                position[++pIndex] = right.z;
+                position[++pIndex] = left.x;
+                position[++pIndex] = left.y;
+                position[++pIndex] = left.z;
+                position[++pIndex] = right.x;
+                position[++pIndex] = right.y;
+                position[++pIndex] = right.z;
+                position[++pIndex] = tempPoint2.x;
+                position[++pIndex] = tempPoint2.y;
+                position[++pIndex] = tempPoint2.z;
+                position[++pIndex] = right.x;
+                position[++pIndex] = right.y;
+                position[++pIndex] = right.z;
+                // position.push(
+                //     tempPoint1.x, tempPoint1.y, tempPoint1.z, // 6
+                //     right.x, right.y, right.z, // 5
+                //     left.x, left.y, left.z, // 4
+                //     right.x, right.y, right.z, // 3
+                //     tempPoint2.x, tempPoint2.y, tempPoint2.z, // 2
+                //     right.x, right.y, right.z // 1
+                // );
+
+                verticesCount += 6;
+
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 8;
+                indices[++iIndex] = verticesCount - 7;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 7;
+                indices[++iIndex] = verticesCount - 5;
+                indices[++iIndex] = verticesCount - 4;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 5;
+                indices[++iIndex] = verticesCount - 2;
+                indices[++iIndex] = verticesCount - 4;
+                indices[++iIndex] = verticesCount - 1;
+
+                // indices.push(
+                //     verticesCount - 6, verticesCount - 8, verticesCount - 7,
+                //     verticesCount - 6, verticesCount - 7, verticesCount - 5,
+
+                //     verticesCount - 4, verticesCount - 6, verticesCount - 5,
+                //     verticesCount - 2, verticesCount - 4, verticesCount - 1
+                // );
+
+                count += 12;
+            } else {
+                position[++pIndex] = left.x;
+                position[++pIndex] = left.y;
+                position[++pIndex] = left.z;
+                position[++pIndex] = tempPoint1.x;
+                position[++pIndex] = tempPoint1.y;
+                position[++pIndex] = tempPoint1.z;
+                position[++pIndex] = left.x;
+                position[++pIndex] = left.y;
+                position[++pIndex] = left.z;
+                position[++pIndex] = right.x;
+                position[++pIndex] = right.y;
+                position[++pIndex] = right.z;
+                position[++pIndex] = left.x;
+                position[++pIndex] = left.y;
+                position[++pIndex] = left.z;
+                position[++pIndex] = tempPoint2.x;
+                position[++pIndex] = tempPoint2.y;
+                position[++pIndex] = tempPoint2.z;
+                // position.push(
+                //     left.x, left.y, left.z, // 6
+                //     tempPoint1.x, tempPoint1.y, tempPoint1.z, // 5
+                //     left.x, left.y, left.z, // 4
+                //     right.x, right.y, right.z, // 3
+                //     left.x, left.y, left.z, // 2
+                //     tempPoint2.x, tempPoint2.y, tempPoint2.z // 1
+                // );
+
+                verticesCount += 6;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 8;
+                indices[++iIndex] = verticesCount - 7;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 7;
+                indices[++iIndex] = verticesCount - 5;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 5;
+                indices[++iIndex] = verticesCount - 3;
+                indices[++iIndex] = verticesCount - 2;
+                indices[++iIndex] = verticesCount - 3;
+                indices[++iIndex] = verticesCount - 1;
+
+                // indices.push(
+                //     verticesCount - 6, verticesCount - 8, verticesCount - 7,
+                //     verticesCount - 6, verticesCount - 7, verticesCount - 5,
+
+                //     verticesCount - 6, verticesCount - 5, verticesCount - 3,
+                //     verticesCount - 2, verticesCount - 3, verticesCount - 1
+                // );
+
+                count += 12;
+            }
+            for (let i = 0; i < 6; i++) {
+                normal[++nIndex] = up.x;
+                normal[++nIndex] = up.y;
+                normal[++nIndex] = up.z;
+            }
+
+            // normal.push(
+            //     up.x, up.y, up.z,
+            //     up.x, up.y, up.z,
+            //     up.x, up.y, up.z,
+            //     up.x, up.y, up.z,
+            //     up.x, up.y, up.z,
+            //     up.x, up.y, up.z
+            // );
+
+            uv[++uIndex] = uvDist - sharpUvOffset;
+            uv[++uIndex] = 0;
+            uv[++uIndex] = uvDist - sharpUvOffset;
+            uv[++uIndex] = 1;
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = 0;
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = 1;
+            uv[++uIndex] = uvDist + sharpUvOffset;
+            uv[++uIndex] = 0;
+            uv[++uIndex] = uvDist + sharpUvOffset;
+            uv[++uIndex] = 1;
+            // uv.push(
+            //     uvDist - sharpUvOffset, 0,
+            //     uvDist - sharpUvOffset, 1,
+            //     uvDist, 0,
+            //     uvDist, 1,
+            //     uvDist + sharpUvOffset, 0,
+            //     uvDist + sharpUvOffset, 1
+            // );
+
+            // if (generateUv2) {
+            //     uv2.push(
+            //         uvDist2 - sharpUvOffset2, 0,
+            //         uvDist2 - sharpUvOffset2, 1,
+            //         uvDist2, 0,
+            //         uvDist2, 1,
+            //         uvDist2 + sharpUvOffset2, 0,
+            //         uvDist2 + sharpUvOffset2, 1
+            //     );
+            // }
+        } else {
+            position[++pIndex] = left.x;
+            position[++pIndex] = left.y;
+            position[++pIndex] = left.z;
+            position[++pIndex] = right.x;
+            position[++pIndex] = right.y;
+            position[++pIndex] = right.z;
+            // position.push(
+            //     left.x, left.y, left.z,
+            //     right.x, right.y, right.z
+            // );
+
+            normal[++nIndex] = up.x;
+            normal[++nIndex] = up.y;
+            normal[++nIndex] = up.z;
+            normal[++nIndex] = up.x;
+            normal[++nIndex] = up.y;
+            normal[++nIndex] = up.z;
+            // normal.push(
+            //     up.x, up.y, up.z,
+            //     up.x, up.y, up.z
+            // );
+
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = 0;
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = 1;
+            // uv.push(
+            //     uvDist, 0,
+            //     uvDist, 1
+            // );
+
+            // if (generateUv2) {
+            //     uv2.push(
+            //         uvDist2, 0,
+            //         uvDist2, 1
+            //     );
+            // }
+
+            verticesCount += 2;
+
+            if (!first) {
+                indices[++iIndex] = verticesCount - 2;
+                indices[++iIndex] = verticesCount - 4;
+                indices[++iIndex] = verticesCount - 3;
+                indices[++iIndex] = verticesCount - 2;
+                indices[++iIndex] = verticesCount - 3;
+                indices[++iIndex] = verticesCount - 1;
+                // indices.push(
+                //     verticesCount - 2, verticesCount - 4, verticesCount - 3,
+                //     verticesCount - 2, verticesCount - 3, verticesCount - 1
+                // );
+
+                count += 6;
+            }
+        }
+    }
+
+    let lastPoint;
+
+    if (progressDistance > 0) {
+        for (let i = 0; i < pathPointList.count; i++) {
+            const pathPoint = pathPointList.array[i];
+
+            if (pathPoint.dist > progressDistance) {
+                const prevPoint = pathPointList.array[i - 1];
+                lastPoint = new PathPoint();
+
+                // linear lerp for progress
+                const alpha = (progressDistance - prevPoint.dist) / (pathPoint.dist - prevPoint.dist);
+                lastPoint.lerpPathPoints(prevPoint, pathPoint, alpha);
+
+                addVertices(lastPoint);
+                break;
+            } else {
+                addVertices(pathPoint);
+            }
+        }
+    } else {
+        lastPoint = pathPointList.array[0];
+    }
+
+    return {
+        position: position,
+        normal,
+        uv: uv,
+        indices: indices,
+        count
+    };
+}

package/src/plane.ts

@@ -0,0 +1,60 @@
+import { ResultType } from "./type";
+
+export function plane(width: number, height: number, devideW: number, devideH: number): ResultType {
+    devideW = Math.max(1, devideW);
+    devideH = Math.max(1, devideH);
+    const dx = width / devideW, dy = height / devideH;
+    const minX = -width / 2, maxY = height / 2, minY = -height / 2;
+    const len = (devideW + 1) * (devideH + 1);
+    const position = new Float32Array(len * 3), uv = new Float32Array(len * 2), normal = new Float32Array(len * 3), indices = new Uint32Array(len * 10);
+    let index = 0, uIndex = 0, iIndex = 0;
+    for (let j = 0; j <= devideH; j++) {
+        for (let i = 0; i <= devideW; i++) {
+            const x = minX + dx * i;
+            const y = maxY - dy * j;
+            position[index] = x;
+            position[index + 1] = y;
+            position[index + 2] = 0;
+
+            normal[index] = 0;
+            normal[index + 1] = 0;
+            normal[index + 2] = 1;
+            // position.push(x, y, 0);
+            // normal.push(0, 0, 1);
+            const uvx = (x - minX) / width, uvy = (y - minY) / height;
+            // uv.push(uvx, uvy);
+            uv[uIndex] = uvx;
+            uv[uIndex + 1] = uvy;
+
+            index += 3;
+            uIndex += 2;
+            if (i < devideW && j < devideH) {
+                const a = j * (devideW + 1) + i, b = a + 1, c = (devideW + 1) * (j + 1) + i, d = c + 1;
+                indices[iIndex] = a;
+                indices[iIndex + 1] = c;
+                indices[iIndex + 2] = b;
+                indices[iIndex + 3] = c;
+                indices[iIndex + 4] = d;
+                indices[iIndex + 5] = b;
+                iIndex += 6;
+                // indexs.push(a, c, b, c, d, b);
+            }
+        }
+    }
+    const indexArray = new Uint32Array(iIndex);
+    for (let i = 0, len = indexArray.length; i < len; i++) {
+        indexArray[i] = indices[i];
+    }
+    // for (let j = 0; j < devideH; j++) {
+    //     for (let i = 0; i < devideW; i++) {
+    //         const a = j * (devideW + 1) + i, b = a + 1, c = (devideW + 1) * (j + 1) + i, d = c + 1;
+    //         indexs.push(a, c, b, c, d, b);
+    //     }
+    // }
+    return {
+        position,
+        uv,
+        normal,
+        indices: indexArray
+    };
+}

package/src/polygon.ts

@@ -0,0 +1,189 @@
+
+import earcut from 'earcut';
+import { generateNormal, generateSideWallUV, isClockwise, merge } from './util';
+import { PolylineType, PolygonType, ResultType } from './type';
+
+type PolygonsOptions = {
+    depth?: number
+}
+
+type PolygonsResult = ResultType & {
+    polygons: Array<PolygonType>;
+}
+
+
+export function extrudePolygons(polygons: Array<PolygonType>, options?: PolygonsOptions): PolygonsResult {
+    options = Object.assign({}, { depth: 2 }, 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);
+            }
+        }
+        const result = flatVertices(polygon, options) as Record<string, any>;
+        result.polygon = polygon;
+        const triangles = earcut(result.flatVertices, result.holes, 2);
+        generateTopAndBottom(result, triangles);
+        generateSides(result, options);
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
+        result.normal = generateNormal(result.indices, result.position);
+        return result;
+    });
+    const result = merge(results) as PolygonsResult;
+    result.polygons = polygons;
+    return result;
+
+}
+
+function generateTopAndBottom(result, triangles) {
+    const indices: number[] = [];
+    const { count } = result;
+    for (let i = 0, len = triangles.length; i < len; i += 3) {
+        // top
+        const a = triangles[i], b = triangles[i + 1], c = triangles[i + 2];
+        indices[i] = a;
+        indices[i + 1] = b;
+        indices[i + 2] = c;
+        // bottom
+        const idx = len + i;
+        const a1 = count + a, b1 = count + b, c1 = count + c;
+        indices[idx] = a1;
+        indices[idx + 1] = b1;
+        indices[idx + 2] = c1;
+    }
+    result.indices = indices;
+}
+
+function generateSides(result, options) {
+    const { points, indices, polygon, uv } = result;
+    const depth = options.depth;
+    let pIndex = points.length - 1;
+    let iIndex = indices.length - 1;
+    for (let i = 0, len = polygon.length; i < len; i++) {
+        const ring = polygon[i];
+        let j = 0;
+        const len1 = ring.length;
+        while (j < len1) {
+            const v1 = ring[j];
+            let v2 = ring[j + 1];
+            if (j === len1 - 1) {
+                v2 = ring[0];
+            }
+            const idx = points.length / 3;
+            const x1 = v1[0], y1 = v1[1], z1 = v1[2] || 0, x2 = v2[0], y2 = v2[1], z2 = v2[2] || 0;
+            points[++pIndex] = x1;
+            points[++pIndex] = y1;
+            points[++pIndex] = z1 + depth;
+            points[++pIndex] = x2;
+            points[++pIndex] = y2;
+            points[++pIndex] = z2 + depth;
+            points[++pIndex] = x1;
+            points[++pIndex] = y1;
+            points[++pIndex] = z1;
+            points[++pIndex] = x2;
+            points[++pIndex] = y2;
+            points[++pIndex] = z2;
+            // points.push(x1, y1, z, x2, y2, z, x1, y1, 0, x2, y2, 0);
+            const a = idx + 2, b = idx + 3, c = idx, d = idx + 1;
+            // points.push(p3, p4, p1, p2);
+            // index.push(a, c, b, c, d, b);
+            indices[++iIndex] = a;
+            indices[++iIndex] = c;
+            indices[++iIndex] = b;
+            indices[++iIndex] = c;
+            indices[++iIndex] = d;
+            indices[++iIndex] = b;
+            // index.push(c, d, b);
+
+            generateSideWallUV(uv, points, a, b, c, d);
+            j++;
+        }
+    }
+}
+
+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;
+    const holes: number[] = [], flatVertices = new Float32Array(count * 2), points: number[] = [], uv: number[] = [];
+    const pOffset = count * 3, uOffset = count * 2;
+    const depth = options.depth;
+
+    let idx0 = 0, idx1 = 0, idx2 = 0;
+    for (let i = 0; i < len; i++) {
+        const ring = polygon[i];
+        if (i > 0) {
+            holes.push(idx0 / 2);
+        }
+        let j = 0;
+        const len1 = ring.length;
+        while (j < len1) {
+            const c = ring[j];
+            const x = c[0], y = c[1], z = c[2] || 0;
+
+            flatVertices[idx0++] = x;
+            flatVertices[idx0++] = y;
+
+            // top vertices
+            points[idx1] = x;
+            points[idx1 + 1] = y;
+            points[idx1 + 2] = depth + z;
+
+            // bottom vertices
+            points[pOffset + idx1] = x;
+            points[pOffset + idx1 + 1] = y;
+            points[pOffset + idx1 + 2] = z;
+
+            uv[idx2] = x;
+            uv[idx2 + 1] = y;
+
+            uv[uOffset + idx2] = x;
+            uv[uOffset + idx2 + 1] = y;
+
+            idx1 += 3;
+            idx2 += 2;
+            j++;
+        }
+    }
+    return {
+        flatVertices,
+        holes,
+        points,
+        count,
+        uv
+    };
+
+}
+
+function validateRing(ring: PolylineType) {
+    if (!isClosedRing(ring)) {
+        ring.push(ring[0]);
+    }
+}
+
+function isClosedRing(ring: PolylineType) {
+    const len = ring.length;
+    const [x1, y1] = ring[0], [x2, y2] = ring[len - 1];
+    return (x1 === x2 && y1 === y2);
+}