poly-extrude 0.8.0 → 0.10.0

package/src/polyline.js

@@ -15,8 +15,8 @@ export function extrudePolylines(lines, options) {
         generateTopAndBottom(result, options);
         generateSides(result, options);
         result.position = new Float32Array(result.points);
-        result.indices = new Uint32Array(result.index);
-        result.uv = new Float32Array(result.uvs);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
         result.normal = generateNormal(result.indices, result.position);
         return result;
     });
@@ -51,8 +51,8 @@ export function extrudeSlopes(lines, options) {
         generateTopAndBottom(result, options);
         generateSides(result, options);
         result.position = new Float32Array(result.points);
-        result.indices = new Uint32Array(result.index);
-        result.uv = new Float32Array(result.uvs);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
         result.normal = generateNormal(result.indices, result.position);
         return result;
     });
@@ -70,7 +70,7 @@ function generateTopAndBottom(result, options) {
         lz = depths[0];
         rz = depths[1];
     }
-    const points = [], index = [], uvs = [];
+    const points = [], indices = [], uv = [];
     const { leftPoints, rightPoints } = result;
     let i = 0, len = leftPoints.length;
     while (i < len) {
@@ -110,31 +110,47 @@ function generateTopAndBottom(result, options) {
     }
     i = 0;
     len = points.length;
+    let uIndex = uv.length - 1;
     while (i < len) {
         const x = points[i], y = points[i + 1];
-        uvs.push(x, y);
+        uv[++uIndex] = x;
+        uv[++uIndex] = y;
+        // uvs.push(x, y);
         i += 3;
     }
     i = 0;
     len = leftPoints.length;
+    let iIndex = indices.length - 1;
     while (i < len - 1) {
         // top
         // left1 left2 right1,right2
         const a1 = i, b1 = i + 1, c1 = a1 + len, d1 = b1 + len;
-        index.push(a1, c1, b1);
-        index.push(c1, d1, b1);
+        indices[++iIndex] = a1;
+        indices[++iIndex] = c1;
+        indices[++iIndex] = b1;
+        indices[++iIndex] = c1;
+        indices[++iIndex] = d1;
+        indices[++iIndex] = b1;
+        // index.push(a1, c1, b1);
+        // index.push(c1, d1, b1);
 
         // bottom
         // left1 left2 right1,right2
         const len2 = len * 2;
         const a2 = i + len2, b2 = a2 + 1, c2 = a2 + len, d2 = b2 + len;
-        index.push(a2, c2, b2);
-        index.push(c2, d2, b2);
+        indices[++iIndex] = a2;
+        indices[++iIndex] = c2;
+        indices[++iIndex] = b2;
+        indices[++iIndex] = c2;
+        indices[++iIndex] = d2;
+        indices[++iIndex] = b2;
+        // index.push(a2, c2, b2);
+        // index.push(c2, d2, b2);
         i++;
     }
-    result.index = index;
+    result.indices = indices;
     result.points = points;
-    result.uvs = uvs;
+    result.uv = uv;
     if (depths) {
         len = leftPoints.length;
         i = 0;
@@ -147,15 +163,17 @@ function generateTopAndBottom(result, options) {
 }
 
 function generateSides(result, options) {
-    const { points, index, leftPoints, rightPoints, uvs } = result;
+    const { points, indices, leftPoints, rightPoints, uv } = result;
     const z = options.depth;
     const bottomStickGround = options.bottomStickGround;
     const rings = [leftPoints, rightPoints];
     const depthsEnable = result.depths;
 
+    let pIndex = points.length - 1;
+    let iIndex = indices.length - 1;
     function addOneSideIndex(v1, v2) {
         const idx = points.length / 3;
-        let pIndex = points.length - 1;
+        // let pIndex = points.length - 1;
 
         // top
         points[++pIndex] = v1[0];
@@ -181,8 +199,14 @@ function generateSides(result, options) {
         // 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);
+        indices[++iIndex] = a;
+        indices[++iIndex] = c;
+        indices[++iIndex] = b;
+        indices[++iIndex] = c;
+        indices[++iIndex] = d;
+        indices[++iIndex] = b;
+        // index.push(a, c, b, c, d, b);
+        generateSideWallUV(uv, points, a, b, c, d);
     }
 
     for (let i = 0, len = rings.length; i < len; i++) {

package/src/tube.js

@@ -1,23 +1,21 @@
 import { Vector3 } from './math/Vector3';
 import { PathPoint } from './path/PathPoint';
 import { PathPointList } from './path/PathPointList';
-import { merge } from './util';
+import { line2Vectors, merge } from './util';
 const UP = new Vector3(0, 0, 1);
+const normalDir = new Vector3();
 
 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 points = line2Vectors(line);
         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.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
         result.normal = new Float32Array(result.normal);
         return result;
     });
@@ -46,13 +44,11 @@ function generateTubeVertexData(pathPointList, options) {
     // modify data
     const points = [];
     const normal = [];
-    const uvs = [];
+    const uv = [];
     // const uv2 = [];
-    const index = [];
+    const indices = [];
     let verticesCount = 0;
 
-    const normalDir = new Vector3();
-
     let pIndex = -1;
     let nIndex = -1;
     let uIndex = -1;
@@ -78,8 +74,8 @@ function generateTubeVertexData(pathPointList, options) {
             normal[++nIndex] = normalDir.y;
             normal[++nIndex] = normalDir.z;
 
-            uvs[++uIndex] = uvDist;
-            uvs[++uIndex] = i / radialSegments;
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = i / radialSegments;
 
             // uvs.push(uvDist, r / radialSegments);
 
@@ -95,12 +91,12 @@ function generateTubeVertexData(pathPointList, options) {
             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;
+                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,
@@ -138,9 +134,9 @@ function generateTubeVertexData(pathPointList, options) {
     return {
         points,
         normal,
-        uvs,
+        uv,
         // uv2,
-        index,
+        indices,
         count
     };
 }

package/src/util.js

@@ -1,3 +1,5 @@
+import { Vector3 } from './math/Vector3';
+
 /**
  * https://github.com/Turfjs/turf/blob/master/packages/turf-boolean-clockwise/index.ts
  * @param {*} ring
@@ -176,17 +178,46 @@ export function generateSideWallUV(uvs, vertices, indexA, indexB, indexC, indexD
     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.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);
+        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.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);
+        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 = [];
+    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;
+}