poly-extrude 0.13.0 → 0.15.0

package/src/tube.ts

@@ -0,0 +1,155 @@
+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 normalDir = new Vector3();
+
+type TubesOptions = {
+    radius?: number;
+    cornerSplit?: number;
+    radialSegments?: number;
+    startRad?: number;
+}
+
+type TubesResult = ResultType & {
+    lines: Array<PolylineType>;
+}
+
+export function expandTubes(lines: Array<PolylineType>, options?: TubesOptions) {
+    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);
+        const result = generateTubeVertexData(pathPointList, options) as Record<string, any>;
+        result.line = line;
+        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 as Array<ResultType>) as TubesResult;
+    result.lines = lines;
+    return result;
+}
+
+// Vertex Data Generate Functions
+// code copy from https://github.com/shawn0326/three.path/blob/master/src/PathGeometry.js
+function generateTubeVertexData(pathPointList, options) {
+    const radius = Math.max(options.radius || 1, 0.00000001);
+    const progress = options.progress !== undefined ? options.progress : 1;
+    const radialSegments = Math.max(3, options.radialSegments || 8);
+    const startRad = options.startRad || 0;
+
+    const circum = radius * 2 * Math.PI;
+    const totalDistance = pathPointList.distance();
+    const progressDistance = progress * totalDistance;
+    if (progressDistance === 0) {
+        return null;
+    }
+
+    let count = 0;
+
+    // modify data
+    const points: number[] = [];
+    const normal: number[] = [];
+    const uv: number[] = [];
+    // const uv2 = [];
+    const indices: number[] = [];
+    let verticesCount = 0;
+
+    let pIndex = -1;
+    let nIndex = -1;
+    let uIndex = -1;
+    let iIndex = -1;
+    function addVertices(pathPoint, radius, radialSegments) {
+        const first = points.length === 0;
+        const uvDist = pathPoint.dist / circum;
+        // const uvDist2 = pathPoint.dist / totalDistance;
+
+        for (let i = 0; i <= radialSegments; i++) {
+            let r = i;
+            if (r === radialSegments) {
+                r = 0;
+            }
+            normalDir.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;
+
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = i / radialSegments;
+
+            // uvs.push(uvDist, r / radialSegments);
+
+            // if (generateUv2) {
+            //     uv2.push(uvDist2, r / radialSegments);
+            // }
+
+            verticesCount++;
+        }
+
+        if (!first) {
+            const begin1 = verticesCount - (radialSegments + 1) * 2;
+            const begin2 = verticesCount - (radialSegments + 1);
+
+            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;
+                // index.push(
+                //     begin2 + i,
+                //     begin1 + i,
+                //     begin1 + i + 1,
+                //     begin2 + i,
+                //     begin1 + i + 1,
+                //     begin2 + i + 1
+                // );
+
+                count += 6;
+            }
+        }
+    }
+
+    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];
+                const lastPoint = new PathPoint();
+
+                // linear lerp for progress
+                const alpha = (progressDistance - prevPoint.dist) / (pathPoint.dist - prevPoint.dist);
+                lastPoint.lerpPathPoints(prevPoint, pathPoint, alpha);
+
+                addVertices(lastPoint, radius, radialSegments);
+                break;
+            } else {
+                addVertices(pathPoint, radius, radialSegments);
+            }
+        }
+    }
+
+    return {
+        points,
+        normal,
+        uv,
+        // uv2,
+        indices,
+        count
+    };
+}

package/src/type.ts

@@ -0,0 +1,9 @@
+export type PolylineType = Array<number[]>;
+export type PolygonType = Array<Array<number[]>>;
+export type ResultType = {
+    position: Float32Array;
+    normal: Float32Array;
+    uv: Float32Array;
+    indices: Uint32Array;
+    results?: Array<any>;
+}

package/src/util.ts

@@ -0,0 +1,243 @@
+import { Vector3 } from './math/Vector3';
+import { PolylineType, ResultType } from './type';
+
+/**
+ * https://github.com/Turfjs/turf/blob/master/packages/turf-boolean-clockwise/index.ts
+ * @param {*} ring
+ * @returns
+ */
+export function isClockwise(ring: PolylineType) {
+    let sum = 0;
+    let i = 1;
+    let prev;
+    let cur;
+    const len = ring.length;
+
+    while (i < len) {
+        prev = cur || ring[0];
+        cur = ring[i];
+        sum += (cur[0] - prev[0]) * (cur[1] + prev[1]);
+        i++;
+    }
+    return sum > 0;
+}
+
+function v3Sub(out, v1, v2) {
+    out[0] = v1[0] - v2[0];
+    out[1] = v1[1] - v2[1];
+    out[2] = v1[2] - v2[2];
+    return out;
+}
+
+function v3Normalize(out, v) {
+    const x = v[0];
+    const y = v[1];
+    const z = v[2];
+    const d = Math.sqrt(x * x + y * y + z * z) || 1;
+    out[0] = x / d;
+    out[1] = y / d;
+    out[2] = z / d;
+    return out;
+}
+
+function v3Cross(out, v1, v2) {
+    const ax = v1[0], ay = v1[1], az = v1[2],
+        bx = v2[0], by = v2[1], bz = v2[2];
+
+    out[0] = ay * bz - az * by;
+    out[1] = az * bx - ax * bz;
+    out[2] = ax * by - ay * bx;
+    return out;
+}
+
+export function generateNormal(indices, position) {
+
+    function v3Set(p, a, b, c) {
+        p[0] = a; p[1] = b; p[2] = c;
+    }
+
+    const p1 = [];
+    const p2 = [];
+    const p3 = [];
+
+    const v21 = [];
+    const v32 = [];
+
+    const n = [];
+
+    const len = indices.length;
+    const normals = new Float32Array(position.length);
+    let f = 0;
+    while (f < len) {
+
+        // const i1 = indices[f++] * 3;
+        // const i2 = indices[f++] * 3;
+        // const i3 = indices[f++] * 3;
+        // const i1 = indices[f];
+        // const i2 = indices[f + 1];
+        // const i3 = indices[f + 2];
+        const a = indices[f], b = indices[f + 1], c = indices[f + 2];
+        const i1 = a * 3, i2 = b * 3, i3 = c * 3;
+
+        v3Set(p1, position[i1], position[i1 + 1], position[i1 + 2]);
+        v3Set(p2, position[i2], position[i2 + 1], position[i2 + 2]);
+        v3Set(p3, position[i3], position[i3 + 1], position[i3 + 2]);
+
+        v3Sub(v32, p3, p2);
+        v3Sub(v21, p1, p2);
+        v3Cross(n, v32, v21);
+        // Already be weighted by the triangle area
+        for (let i = 0; i < 3; i++) {
+            normals[i1 + i] += n[i];
+            normals[i2 + i] += n[i];
+            normals[i3 + i] += n[i];
+        }
+        f += 3;
+    }
+
+    let i = 0;
+    const l = normals.length;
+    while (i < l) {
+        v3Set(n, normals[i], normals[i + 1], normals[i + 2]);
+        v3Normalize(n, n);
+        normals[i] = n[0] || 0;
+        normals[i + 1] = n[1] || 0;
+        normals[i + 2] = n[2] || 0;
+        i += 3;
+    }
+
+    return normals;
+}
+
+export function merge(results: Array<ResultType>) {
+    if (results.length === 1) {
+        const result = {
+            position: results[0].position,
+            normal: results[0].normal,
+            uv: results[0].uv,
+            indices: results[0].indices,
+            results
+        };
+        return result;
+    }
+    let plen = 0, ilen = 0;
+    for (let i = 0, len = results.length; i < len; i++) {
+        const { position, indices } = results[i];
+        plen += position.length;
+        ilen += indices.length;
+    }
+    const result = {
+        position: new Float32Array(plen),
+        normal: new Float32Array(plen),
+        uv: new Float32Array(plen / 3 * 2),
+        indices: new Uint32Array(ilen),
+        results
+    };
+    let pOffset = 0, pCount = 0, iIdx = 0, uvOffset = 0;
+    for (let i = 0, len = results.length; i < len; i++) {
+        const { position, indices, normal, uv } = results[i];
+        result.position.set(position, pOffset);
+        result.normal.set(normal, pOffset);
+        result.uv.set(uv, uvOffset);
+        let j = 0;
+        const len1 = indices.length;
+        while (j < len1) {
+            const pIndex = indices[j] + pCount;
+            result.indices[iIdx] = pIndex;
+            iIdx++;
+            j++;
+        }
+        uvOffset += uv.length;
+        pOffset += position.length;
+        pCount += position.length / 3;
+    }
+    return result;
+}
+
+export function radToDeg(rad) {
+    return rad * 180 / Math.PI;
+}
+
+export function degToRad(angle) {
+    return angle / 180 * Math.PI;
+}
+
+// https://github.com/mrdoob/three.js/blob/16f13e3b07e31d0e9a00df7c3366bbe0e464588c/src/geometries/ExtrudeGeometry.js?_pjax=%23js-repo-pjax-container#L736
+export function generateSideWallUV(uvs, vertices, indexA, indexB, indexC, indexD) {
+
+    const idx1 = indexA * 3, idx2 = indexB * 3, idx3 = indexC * 3, idx4 = indexD * 3;
+    const a_x = vertices[idx1];
+    const a_y = vertices[idx1 + 1];
+    const a_z = vertices[idx1 + 2];
+    const b_x = vertices[idx2];
+    const b_y = vertices[idx2 + 1];
+    const b_z = vertices[idx2 + 2];
+    const c_x = vertices[idx3];
+    const c_y = vertices[idx3 + 1];
+    const c_z = vertices[idx3 + 2];
+    const d_x = vertices[idx4];
+    const d_y = vertices[idx4 + 1];
+    const d_z = vertices[idx4 + 2];
+
+    let uIndex = uvs.length - 1;
+    if (Math.abs(a_y - b_y) < Math.abs(a_x - b_x)) {
+        uvs[++uIndex] = a_x;
+        uvs[++uIndex] = 1 - a_z;
+        uvs[++uIndex] = b_x;
+        uvs[++uIndex] = 1 - b_z;
+        uvs[++uIndex] = c_x;
+        uvs[++uIndex] = 1 - c_z;
+        uvs[++uIndex] = d_x;
+        uvs[++uIndex] = 1 - d_z;
+
+        // uvs.push(a_x, 1 - a_z);
+        // uvs.push(b_x, 1 - b_z);
+        // uvs.push(c_x, 1 - c_z);
+        // uvs.push(d_x, 1 - d_z);
+    } else {
+        uvs[++uIndex] = a_y;
+        uvs[++uIndex] = 1 - a_z;
+        uvs[++uIndex] = b_y;
+        uvs[++uIndex] = 1 - b_z;
+        uvs[++uIndex] = c_y;
+        uvs[++uIndex] = 1 - c_z;
+        uvs[++uIndex] = d_y;
+        uvs[++uIndex] = 1 - d_z;
+
+        // uvs.push(a_y, 1 - a_z);
+        // uvs.push(b_y, 1 - b_z);
+        // uvs.push(c_y, 1 - c_z);
+        // uvs.push(d_y, 1 - d_z);
+    }
+
+}
+
+export function line2Vectors(line) {
+    const points: Vector3[] = [];
+    for (let i = 0, len = line.length; i < len; i++) {
+        const p = line[i];
+        const [x, y, z] = p;
+        const v = new Vector3(x, y, z || 0);
+        points[i] = v;
+    }
+    return points;
+}
+
+export function calLineDistance(line) {
+    let distance = 0;
+    for (let i = 0, len = line.length; i < len; i++) {
+        const p1 = line[i], p2 = line[i + 1];
+        if (i === 0) {
+            p1.distance = 0;
+        }
+        if (p1 && p2) {
+            const [x1, y1, z1] = p1;
+            const [x2, y2, z2] = p2;
+            const dx = x1 - x2, dy = y1 - y2, dz = (z1 || 0) - (z2 || 0);
+            const dis = Math.sqrt(dx * dx + dy * dy + dz * dz);
+            distance += dis;
+            p2.distance = distance;
+        }
+    }
+    return distance;
+}

package/index.js

@@ -1,7 +0,0 @@
-import { extrudePolygons } from './src/polygon';
-import { extrudePolylines, expandLine, leftOnLine, extrudeSlopes } from './src/polyline';
-import { cylinder } from './src/cylinder';
-import { expandPaths } from './src/path';
-import { expandTubes } from './src/tube';
-import { plane } from './src/plane';
-export { extrudePolygons, extrudePolylines, extrudeSlopes, expandLine, leftOnLine, cylinder, expandPaths, expandTubes, plane };