poly-extrude 0.6.0 → 0.8.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/polygon.js

@@ -57,7 +57,9 @@ function generateTopAndBottom(result, triangles) {
 
 function generateSides(result, options) {
     const { points, index, polygon, uvs } = result;
-    const z = options.depth;
+    const depth = options.depth;
+    let pIndex = points.length - 1;
+    let iIndex = index.length - 1;
     for (let i = 0, len = polygon.length; i < len; i++) {
         const ring = polygon[i];
         let j = 0;
@@ -69,11 +71,29 @@ function generateSides(result, options) {
                 v2 = ring[0];
             }
             const idx = points.length / 3;
-            const x1 = v1[0], y1 = v1[1], x2 = v2[0], y2 = v2[1];
-            points.push(x1, y1, z, x2, y2, z, x1, y1, 0, x2, y2, 0);
+            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);
+            // index.push(a, c, b, c, d, b);
+            index[++iIndex] = a;
+            index[++iIndex] = c;
+            index[++iIndex] = b;
+            index[++iIndex] = c;
+            index[++iIndex] = d;
+            index[++iIndex] = b;
             // index.push(c, d, b);
 
             generateSideWallUV(uvs, points, a, b, c, d);
@@ -98,7 +118,7 @@ function flatVertices(polygon, options) {
     const len = polygon.length;
     const holes = [], flatVertices = new Float32Array(count * 2), points = [], uvs = [];
     const pOffset = count * 3, uOffset = count * 2;
-    const z = options.depth;
+    const depth = options.depth;
 
     let idx0 = 0, idx1 = 0, idx2 = 0;
     for (let i = 0; i < len; i++) {
@@ -110,7 +130,7 @@ function flatVertices(polygon, options) {
         const len1 = ring.length;
         while (j < len1) {
             const c = ring[j];
-            const x = c[0], y = c[1];
+            const x = c[0], y = c[1], z = c[2] || 0;
 
             flatVertices[idx0++] = x;
             flatVertices[idx0++] = y;
@@ -118,12 +138,12 @@ function flatVertices(polygon, options) {
             // top vertices
             points[idx1] = x;
             points[idx1 + 1] = y;
-            points[idx1 + 2] = z;
+            points[idx1 + 2] = depth + z;
 
             // bottom vertices
             points[pOffset + idx1] = x;
             points[pOffset + idx1 + 1] = y;
-            points[pOffset + idx1 + 2] = 0;
+            points[pOffset + idx1 + 2] = z;
 
             uvs[idx2] = x;
             uvs[idx2 + 1] = y;

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
+    };
+}