poly-extrude 0.17.1 → 0.18.0

package/src/polygon.ts

@@ -13,10 +13,10 @@ type PolygonsResult = ResultType & {
 }
 
 
-export function extrudePolygons(polygons: Array<PolygonType>, options?: PolygonsOptions): PolygonsResult {
-    options = Object.assign({}, { depth: 2, top: true }, options);
+export function extrudePolygons(polygons: Array<PolygonType>, opts?: PolygonsOptions): PolygonsResult {
+    const options = Object.assign({}, { depth: 2, top: true }, opts);
     const results = polygons.map(polygon => {
-        validatePolygon(polygon);
+        validatePolygon(polygon, true);
         const result = flatVertices(polygon, options) as Record<string, any>;
         result.polygon = polygon;
         const triangles = earcut(result.flatVertices, result.holes, 2);
@@ -28,7 +28,7 @@ export function extrudePolygons(polygons: Array<PolygonType>, options?: Polygons
         result.normal = generateNormal(result.indices, result.position);
         return result;
     });
-    const result = merge(results as Array<ResultType>) as PolygonsResult;
+    const result = merge<PolygonsResult>(results as Array<ResultType>);
     result.polygons = polygons;
     return result;
 
@@ -193,9 +193,10 @@ function simplePolygon(polygon, options = {}) {
     }
 }
 
-export function polygons(polygons, options = {}): PolygonsResult {
+export function polygons(polygons, opts = {}): PolygonsResult {
+    const options = Object.assign({}, opts);
     const results = polygons.map(polygon => {
-        validatePolygon(polygon);
+        validatePolygon(polygon, true);
 
         const result = simplePolygon(polygon, options) as Record<string, any>;
         result.polygon = polygon;
@@ -205,7 +206,7 @@ export function polygons(polygons, options = {}): PolygonsResult {
         result.normal = new Float32Array(result.normal);
         return result;
     });
-    const result = merge(results as Array<ResultType>) as PolygonsResult;
+    const result = merge<PolygonsResult>(results as Array<ResultType>);
     result.polygons = polygons;
     return result;
 

package/src/polygonpath.ts

@@ -1,8 +1,8 @@
 import { Vector3 } from './math/Vector3';
-import { PathPoint } from './path/PathPoint';
+// import { PathPoint } from './path/PathPoint';
 import { PathPointList } from './path/PathPointList';
 import { PolygonType, PolylineType, ResultType } from './type';
-import { generateNormal, isClockwise, line2Vectors, merge, validateRing, isClosedRing, calPolygonPointsCount, getPolygonsBBOX, mergeArray } from './util';
+import { generateNormal, line2Vectors, merge, isClosedRing, calPolygonPointsCount, getPolygonsBBOX, mergeArray, validatePolygon } from './util';
 import earcut from 'earcut';
 const UP = new Vector3(0, 0, 1);
 const normalDir = new Vector3();
@@ -11,18 +11,23 @@ type PolygonsOnPathOptions = {
     extrudePath: PolylineType;
     openEnd?: boolean;
     openEndUV?: boolean;
+    polygonRotation?: number;
 
 }
 
+type PrivatePolygonsOnPathOptions = PolygonsOnPathOptions & {
+    center: Point;
+    bbox: [number, number, number, number]
+}
+
 type PolygonsOnPathResult = ResultType & {
     polygons: Array<PolygonType>;
 }
 
-
 type Point = [number, number];
 
-export function extrudePolygonsOnPath(polygons: Array<PolygonType>, options?: PolygonsOnPathOptions) {
-    options = Object.assign({}, { openEnd: false, openEndUV: true }, options);
+export function extrudePolygonsOnPath(polygons: Array<PolygonType>, opts?: PolygonsOnPathOptions) {
+    const options = (Object.assign({}, { openEnd: false, openEndUV: true, polygonRotation: 0 }, opts)) as PrivatePolygonsOnPathOptions;
     const { extrudePath, openEnd } = options;
     if (!extrudePath || !Array.isArray(extrudePath) || extrudePath.length < 2) {
         console.error('extrudePath is error:', extrudePath);
@@ -31,6 +36,8 @@ export function extrudePolygonsOnPath(polygons: Array<PolygonType>, options?: Po
     const bbox = getPolygonsBBOX(polygons);
     const [minx, miny, maxx, maxy] = bbox;
     const center = [(minx + maxx) / 2, (miny + maxy) / 2] as Point;
+    options.center = center;
+    options.bbox = bbox;
 
     const points = line2Vectors(extrudePath);
     const pathPointList = new PathPointList();
@@ -38,19 +45,8 @@ export function extrudePolygonsOnPath(polygons: Array<PolygonType>, options?: Po
     pathPointList.set(points, 0, options.cornerSplit, UP);
 
     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();
-            }
-        }
-
-        const result = generatePolygonOnPathVertexData(pathPointList, polygon, center) as Record<string, any>;
+        validatePolygon(polygon, false);
+        const result = generatePolygonOnPathVertexData(pathPointList, polygon, options as PrivatePolygonsOnPathOptions) as Record<string, any>;
         if (!openEnd) {
             generateStartAndEnd(result, polygon, options);
         }
@@ -61,7 +57,7 @@ export function extrudePolygonsOnPath(polygons: Array<PolygonType>, options?: Po
         result.normal = new Float32Array(result.normal);
         return result;
     });
-    const result = merge(results as Array<ResultType>) as PolygonsOnPathResult;
+    const result = merge<PolygonsOnPathResult>(results as Array<ResultType>);
     result.polygons = polygons;
     return result;
 }
@@ -76,7 +72,8 @@ function getAngle(c1: Point, c2: Point) {
 }
 
 
-function transformPolygon(polygon: PolygonType, center: Point) {
+function transformPolygon(polygon: PolygonType, options: PrivatePolygonsOnPathOptions) {
+    const { center, polygonRotation } = options;
     const [cx, cy] = center;
     const list = [];
     polygon.forEach((ring, rIndex) => {
@@ -100,7 +97,7 @@ function transformPolygon(polygon: PolygonType, center: Point) {
                 // dz: 0,
                 distance,
                 radius: Math.sqrt(offsetx * offsetx + offsety * offsety),
-                angle: -getAngle(center, p as Point)
+                angle: -getAngle(center, p as Point) + polygonRotation
             }
             tempPoint = p;
         }
@@ -115,8 +112,8 @@ function transformPolygon(polygon: PolygonType, center: Point) {
 const TEMP_VECTOR3 = new Vector3(0, 0, 0);
 // Vertex Data Generate Functions
 // code copy from https://github.com/shawn0326/three.path/blob/master/src/PathGeometry.js
-function generatePolygonOnPathVertexData(pathPointList, polygon: PolygonType, center: Point) {
-    const tpolygon = transformPolygon(polygon, center);
+function generatePolygonOnPathVertexData(pathPointList, polygon: PolygonType, options: PrivatePolygonsOnPathOptions) {
+    const tpolygon = transformPolygon(polygon, options);
     // let count = 0;
     // modify data
     const points: number[] = [];
@@ -154,9 +151,13 @@ function generatePolygonOnPathVertexData(pathPointList, polygon: PolygonType, ce
             v.y *= radius;
             v.z *= radius;
 
-            points[++pIndex] = pathPoint.pos.x + v.x;
-            points[++pIndex] = pathPoint.pos.y + v.y;
-            points[++pIndex] = pathPoint.pos.z + v.z;
+            const x = pathPoint.pos.x + v.x;
+            const y = pathPoint.pos.y + v.y;
+            const z = pathPoint.pos.z + v.z;
+
+            points[++pIndex] = x;
+            points[++pIndex] = y;
+            points[++pIndex] = z;
 
             // if (i === 0 || i === radialSegments - 1) {
             //     console.log(i, radialSegments, v.x, v.y, v.z);
@@ -174,15 +175,15 @@ function generatePolygonOnPathVertexData(pathPointList, polygon: PolygonType, ce
 
             if (first && !isLast) {
                 let index = startPoints.length - 1;
-                startPoints[++index] = pathPoint.pos.x + v.x;
-                startPoints[++index] = pathPoint.pos.y + v.y;
-                startPoints[++index] = pathPoint.pos.z + v.z;
+                startPoints[++index] = x;
+                startPoints[++index] = y;
+                startPoints[++index] = z;
             }
             if (end && !isLast) {
                 let index = endPoints.length - 1;
-                endPoints[++index] = pathPoint.pos.x + v.x;
-                endPoints[++index] = pathPoint.pos.y + v.y;
-                endPoints[++index] = pathPoint.pos.z + v.z;
+                endPoints[++index] = x;
+                endPoints[++index] = y;
+                endPoints[++index] = z;
             }
         }
 

package/src/polyline.ts

@@ -18,8 +18,8 @@ type PolylinesResult = ResultType & {
     lines: Array<PolylineType>;
 }
 
-export function extrudePolylines(lines: Array<PolylineType>, options?: PolylinesOptions): PolylinesResult {
-    options = Object.assign({}, { depth: 2, lineWidth: 1, bottomStickGround: false, pathUV: false }, options);
+export function extrudePolylines(lines: Array<PolylineType>, opts?: PolylinesOptions): PolylinesResult {
+    const options = Object.assign({}, { depth: 2, lineWidth: 1, bottomStickGround: false, pathUV: false }, opts);
     checkOptions(options);
     const results = lines.map(line => {
         const result = expandLine(line, options) as Record<string, any>;
@@ -32,7 +32,7 @@ export function extrudePolylines(lines: Array<PolylineType>, options?: Polylines
         result.normal = generateNormal(result.indices, result.position);
         return result;
     });
-    const result = merge(results as Array<ResultType>) as PolylinesResult;
+    const result = merge<PolylinesResult>(results as Array<ResultType>);
     result.lines = lines;
     return result;
 }
@@ -42,8 +42,8 @@ type SlopesOptions = PolylinesOptions & {
     sideDepth?: number
 }
 
-export function extrudeSlopes(lines: Array<PolylineType>, options?: SlopesOptions): PolylinesResult {
-    options = Object.assign({}, { depth: 2, lineWidth: 1, side: 'left', sideDepth: 0, bottomStickGround: false, pathUV: false, isSlope: true }, options);
+export function extrudeSlopes(lines: Array<PolylineType>, opts?: SlopesOptions): PolylinesResult {
+    const options = Object.assign({}, { depth: 2, lineWidth: 1, side: 'left', sideDepth: 0, bottomStickGround: false, pathUV: false, isSlope: true }, opts);
     checkOptions(options);
     const { depth, side, sideDepth } = options;
     const results = lines.map(line => {
@@ -73,7 +73,7 @@ export function extrudeSlopes(lines: Array<PolylineType>, options?: SlopesOption
         result.normal = generateNormal(result.indices, result.position);
         return result;
     });
-    const result = merge(results as Array<ResultType>) as PolylinesResult;
+    const result = merge<PolylinesResult>(results as Array<ResultType>);
     result.lines = lines;
     return result;
 }

package/src/tube.ts

@@ -17,8 +17,8 @@ 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);
+export function expandTubes(lines: Array<PolylineType>, opts?: TubesOptions) {
+    const options = Object.assign({}, { radius: 1, cornerSplit: 0, radialSegments: 8, startRad: -Math.PI / 4 }, opts);
     const results = lines.map(line => {
         const points = line2Vectors(line);
         const pathPointList = new PathPointList();
@@ -32,7 +32,7 @@ export function expandTubes(lines: Array<PolylineType>, options?: TubesOptions)
         result.normal = new Float32Array(result.normal);
         return result;
     });
-    const result = merge(results as Array<ResultType>) as TubesResult;
+    const result = merge<TubesResult>(results as Array<ResultType>);
     result.lines = lines;
     return result;
 }

package/src/util.ts

@@ -72,7 +72,7 @@ export function getPolygonsBBOX(polygons, bbox?) {
     return bbox;
 }
 
-export function validatePolygon(polygon: PolygonType) {
+export function validatePolygon(polygon: PolygonType, ignoreEndPoint: boolean) {
     for (let i = 0, len = polygon.length; i < len; i++) {
         const ring = polygon[i];
         validateRing(ring);
@@ -83,8 +83,10 @@ export function validatePolygon(polygon: PolygonType) {
         } else if (isClockwise(ring)) {
             polygon[i] = ring.reverse();
         }
-        if (isClosedRing(ring)) {
-            ring.splice(ring.length - 1, 1);
+        if (ignoreEndPoint) {
+            if (isClosedRing(ring)) {
+                ring.splice(ring.length - 1, 1);
+            }
         }
     }
 }
@@ -176,7 +178,7 @@ export function generateNormal(indices, position) {
     return normals;
 }
 
-export function merge(results: Array<ResultType>) {
+export function merge<T extends ResultType>(results: Array<ResultType>): T {
     if (results.length === 1) {
         const result = {
             position: results[0].position,
@@ -185,7 +187,7 @@ export function merge(results: Array<ResultType>) {
             indices: results[0].indices,
             results
         };
-        return result;
+        return result as T;
     }
     let plen = 0, ilen = 0;
     for (let i = 0, len = results.length; i < len; i++) {
@@ -218,14 +220,14 @@ export function merge(results: Array<ResultType>) {
         pOffset += position.length;
         pCount += position.length / 3;
     }
-    return result;
+    return result as T;
 }
 
-export function radToDeg(rad) {
+export function radToDeg(rad: number) {
     return rad * 180 / Math.PI;
 }
 
-export function degToRad(angle) {
+export function degToRad(angle: number) {
     return angle / 180 * Math.PI;
 }
 
@@ -279,7 +281,7 @@ export function generateSideWallUV(uvs, vertices, indexA, indexB, indexC, indexD
 
 }
 
-export function line2Vectors(line) {
+export function line2Vectors(line: PolylineType) {
     const points: Vector3[] = [];
     for (let i = 0, len = line.length; i < len; i++) {
         const p = line[i];