poly-extrude 0.5.0 → 0.7.0

package/src/math/Vector3.js

@@ -1,6 +1,10 @@
 // import * as MathUtils from './MathUtils.js';
 // code copy from https://github.com/mrdoob/three.js/blob/dev/src/math/Vector3.js
 
+import { Quaternion } from './Quaternion';
+
+const _quaternion = new Quaternion();
+
 class Vector3 {
 
     constructor(x = 0, y = 0, z = 0) {
@@ -206,11 +210,11 @@ class Vector3 {
 
     // }
 
-    // applyAxisAngle(axis, angle) {
+    applyAxisAngle(axis, angle) {
 
-    //     return this.applyQuaternion(_quaternion.setFromAxisAngle(axis, angle));
+        return this.applyQuaternion(_quaternion.setFromAxisAngle(axis, angle));
 
-    // }
+    }
 
     // applyMatrix3(m) {
 
@@ -246,27 +250,27 @@ class Vector3 {
 
     }
 
-    // applyQuaternion(q) {
+    applyQuaternion(q) {
 
-    //     const x = this.x, y = this.y, z = this.z;
-    //     const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
+        const x = this.x, y = this.y, z = this.z;
+        const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
 
-    //     // calculate quat * vector
+        // calculate quat * vector
 
-    //     const ix = qw * x + qy * z - qz * y;
-    //     const iy = qw * y + qz * x - qx * z;
-    //     const iz = qw * z + qx * y - qy * x;
-    //     const iw = - qx * x - qy * y - qz * z;
+        const ix = qw * x + qy * z - qz * y;
+        const iy = qw * y + qz * x - qx * z;
+        const iz = qw * z + qx * y - qy * x;
+        const iw = -qx * x - qy * y - qz * z;
 
-    //     // calculate result * inverse quat
+        // calculate result * inverse quat
 
-    //     this.x = ix * qw + iw * - qx + iy * - qz - iz * - qy;
-    //     this.y = iy * qw + iw * - qy + iz * - qx - ix * - qz;
-    //     this.z = iz * qw + iw * - qz + ix * - qy - iy * - qx;
+        this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+        this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+        this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
 
-    //     return this;
+        return this;
 
-    // }
+    }
 
     // project(camera) {
 

package/src/polyline.js

@@ -1,7 +1,14 @@
 import { degToRad, generateNormal, generateSideWallUV, merge, radToDeg } from './util';
 
+function checkOptions(options) {
+    options.lineWidth = Math.max(0, options.lineWidth);
+    options.depth = Math.max(0, options.depth);
+    options.sideDepth = Math.max(0, options.sideDepth);
+}
+
 export function extrudePolylines(lines, options) {
-    options = Object.assign({}, { depth: 2, lineWidth: 1 }, options);
+    options = Object.assign({}, { depth: 2, lineWidth: 1, bottomStickGround: false }, options);
+    checkOptions(options);
     const results = lines.map(line => {
         const result = expandLine(line, options);
         result.line = line;
@@ -19,7 +26,8 @@ export function extrudePolylines(lines, options) {
 }
 
 export function extrudeSlopes(lines, options) {
-    options = Object.assign({}, { depth: 2, lineWidth: 1, side: 'left', sideDepth: 0 }, options);
+    options = Object.assign({}, { depth: 2, lineWidth: 1, side: 'left', sideDepth: 0, bottomStickGround: false }, options);
+    checkOptions(options);
     const { depth, side, sideDepth } = options;
     const results = lines.map(line => {
         const tempResult = expandLine(line, options);
@@ -54,6 +62,7 @@ export function extrudeSlopes(lines, options) {
 }
 
 function generateTopAndBottom(result, options) {
+    const bottomStickGround = options.bottomStickGround;
     const z = options.depth;
     const depths = result.depths;
     let lz = z, rz = z;
@@ -84,12 +93,18 @@ function generateTopAndBottom(result, options) {
         points[idx2] = x1;
         points[idx2 + 1] = y1;
         points[idx2 + 2] = z1;
+        if (bottomStickGround) {
+            points[idx2 + 2] = 0;
+        }
 
         // bottom right
         const idx3 = (len * 2) * 3 + len * 3 + idx0;
         points[idx3] = x2;
         points[idx3 + 1] = y2;
         points[idx3 + 2] = z2;
+        if (bottomStickGround) {
+            points[idx3 + 2] = 0;
+        }
 
         i++;
     }
@@ -134,12 +149,37 @@ function generateTopAndBottom(result, options) {
 function generateSides(result, options) {
     const { points, index, leftPoints, rightPoints, uvs } = result;
     const z = options.depth;
+    const bottomStickGround = options.bottomStickGround;
     const rings = [leftPoints, rightPoints];
     const depthsEnable = result.depths;
 
     function addOneSideIndex(v1, v2) {
         const idx = points.length / 3;
-        points.push(v1[0], v1[1], (depthsEnable ? v1.depth : z) + v1[2], v2[0], v2[1], (depthsEnable ? v2.depth : z) + v2[2], v1[0], v1[1], v1[2], v2[0], v2[1], v2[2]);
+        let pIndex = points.length - 1;
+
+        // top
+        points[++pIndex] = v1[0];
+        points[++pIndex] = v1[1];
+        points[++pIndex] = (depthsEnable ? v1.depth : z) + v1[2];
+
+        points[++pIndex] = v2[0];
+        points[++pIndex] = v2[1];
+        points[++pIndex] = (depthsEnable ? v2.depth : z) + v2[2];
+
+        // points.push(v1[0], v1[1], (depthsEnable ? v1.depth : z) + v1[2], v2[0], v2[1], (depthsEnable ? v2.depth : z) + v2[2]);
+
+        // bottom
+
+        points[++pIndex] = v1[0];
+        points[++pIndex] = v1[1];
+        points[++pIndex] = bottomStickGround ? 0 : v1[2];
+
+        points[++pIndex] = v2[0];
+        points[++pIndex] = v2[1];
+        points[++pIndex] = bottomStickGround ? 0 : v2[2];
+
+        // points.push(v1[0], v1[1], v1[2], v2[0], v2[1], v2[2]);
+
         const a = idx + 2, b = idx + 3, c = idx, d = idx + 1;
         index.push(a, c, b, c, d, b);
         generateSideWallUV(uvs, points, a, b, c, d);

package/src/tube.js

@@ -0,0 +1,146 @@
+import { Vector3 } from './math/Vector3';
+import { PathPoint } from './path/PathPoint';
+import { PathPointList } from './path/PathPointList';
+import { merge } from './util';
+const UP = new Vector3(0, 0, 1);
+
+export 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 = line.map(p => {
+            const [x, y, z] = p;
+            return new Vector3(x, y, z || 0);
+        });
+        const pathPointList = new PathPointList();
+        pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP);
+        const result = generateTubeVertexData(pathPointList, options);
+        result.line = line;
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.index);
+        result.uv = new Float32Array(result.uvs);
+        result.normal = new Float32Array(result.normal);
+        return result;
+    });
+    const result = merge(results);
+    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 = [];
+    const normal = [];
+    const uvs = [];
+    // const uv2 = [];
+    const index = [];
+    let verticesCount = 0;
+
+    const normalDir = new Vector3();
+
+    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;
+
+            uvs[++uIndex] = uvDist;
+            uvs[++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++) {
+                index[++iIndex] = begin2 + i;
+                index[++iIndex] = begin1 + i;
+                index[++iIndex] = begin1 + i + 1;
+                index[++iIndex] = begin2 + i;
+                index[++iIndex] = begin1 + i + 1;
+                index[++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,
+        uvs,
+        // uv2,
+        index,
+        count
+    };
+}