[ts] Ported ConvexDecomposer

spine-ts/core/src/ConvexDecomposer.ts

@@ -0,0 +1,259 @@
+/******************************************************************************
+ * Spine Runtimes Software License v2.5
+ *
+ * Copyright (c) 2013-2016, Esoteric Software
+ * All rights reserved.
+ *
+ * You are granted a perpetual, non-exclusive, non-sublicensable, and
+ * non-transferable license to use, install, execute, and perform the Spine
+ * Runtimes software and derivative works solely for personal or internal
+ * use. Without the written permission of Esoteric Software (see Section 2 of
+ * the Spine Software License Agreement), you may not (a) modify, translate,
+ * adapt, or develop new applications using the Spine Runtimes or otherwise
+ * create derivative works or improvements of the Spine Runtimes or (b) remove,
+ * delete, alter, or obscure any trademarks or any copyright, trademark, patent,
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "AS IS" AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, BUSINESS INTERRUPTION, OR LOSS OF
+ * USE, DATA, OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+ * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+
+module spine {
+	export class ConvexDecomposer {
+		private convexPolygons = new Array<Array<number>>();
+		private convexPolygonsIndices = new Array<Array<number>>();
+
+		private indicesArray = new Array<number>();
+		private isConcaveArray = new Array<boolean>();
+		private triangles = new Array<number>();
+
+		private polygonPool = new Pool<Array<number>>(() => {
+			return new Array<number>();
+		});
+
+		private polygonIndicesPool = new Pool<Array<number>>(() => {
+			return new Array<number>();
+		});
+
+		public decompose (input: ArrayLike<number>): Array<Array<number>> {
+			let vertices = input;
+			let vertexCount = input.length >> 1;
+
+			let indices = this.indicesArray;
+			indices.length = 0;
+			for (let i = 0; i < vertexCount; i++)
+				indices[i] = i;
+
+			let isConcave = this.isConcaveArray;
+			isConcave.length = 0;
+			for (let i = 0, n = vertexCount; i < n; ++i)
+				isConcave[i] = ConvexDecomposer.isConcave(i, vertexCount, vertices, indices);
+
+			let triangles = this.triangles;
+			triangles.length = 0;
+
+			while (vertexCount > 3) {
+				// Find ear tip.
+				let previous = vertexCount - 1, i = 0, next = 1;
+				while (true) {
+					outer:
+					if (!isConcave[i]) {
+						let p1 = indices[previous] << 1, p2 = indices[i] << 1, p3 = indices[next] << 1;
+						let p1x = vertices[p1], p1y = vertices[p1 + 1];
+						let p2x = vertices[p2], p2y = vertices[p2 + 1];
+						let p3x = vertices[p3], p3y = vertices[p3 + 1];
+						for (let ii = (next + 1) % vertexCount; ii != previous; ii = (ii + 1) % vertexCount) {
+							if (!isConcave[ii]) continue;
+							let v = indices[ii] << 1;
+							let vx = vertices[v], vy = vertices[v + 1];
+							if (ConvexDecomposer.positiveArea(p3x, p3y, p1x, p1y, vx, vy)) {
+								if (ConvexDecomposer.positiveArea(p1x, p1y, p2x, p2y, vx, vy)) {
+									if (ConvexDecomposer.positiveArea(p2x, p2y, p3x, p3y, vx, vy)) break outer;
+								}
+							}
+						}
+						break;
+					}
+
+					if (next == 0) {
+						do {
+							if (!isConcave[i]) break;
+							i--;
+						} while (i > 0);
+						break;
+					}
+
+					previous = i;
+					i = next;
+					next = (next + 1) % vertexCount;
+				}
+
+				// Cut ear tip.
+				triangles.push(indices[(vertexCount + i - 1) % vertexCount]);
+				triangles.push(indices[i]);
+				triangles.push(indices[(i + 1) % vertexCount]);
+				indices.splice(i, 1);
+				isConcave.splice(i, 1);
+				vertexCount--;
+
+				let previousIndex = (vertexCount + i - 1) % vertexCount;
+				let nextIndex = i == vertexCount ? 0 : i;
+				isConcave[previousIndex] = ConvexDecomposer.isConcave(previousIndex, vertexCount, vertices, indices);
+				isConcave[nextIndex] = ConvexDecomposer.isConcave(nextIndex, vertexCount, vertices, indices);
+			}
+
+			if (vertexCount == 3) {
+				triangles.push(indices[2]);
+				triangles.push(indices[0]);
+				triangles.push(indices[1]);
+			}
+
+			let convexPolygons = this.convexPolygons;
+			this.polygonPool.freeAll(convexPolygons);
+			convexPolygons.length = 0;
+
+			let convexPolygonsIndices = this.convexPolygonsIndices;
+			this.polygonIndicesPool.freeAll(convexPolygonsIndices);
+			convexPolygonsIndices.length = 0;
+
+			let polygonIndices = this.polygonIndicesPool.obtain();
+			polygonIndices.length = 0;
+
+			let polygon = this.polygonPool.obtain();
+			polygon.length = 0;
+
+			// Merge subsequent triangles if they form a triangle fan.
+			let fanBaseIndex = -1, lastWinding = 0;
+			for (let i = 0, n = triangles.length; i < n; i += 3) {
+				let t1 = triangles[i] << 1, t2 = triangles[i + 1] << 1, t3 = triangles[i + 2] << 1;
+				let x1 = vertices[t1], y1 = vertices[t1 + 1];
+				let x2 = vertices[t2], y2 = vertices[t2 + 1];
+				let x3 = vertices[t3], y3 = vertices[t3 + 1];
+
+				// If the base of the last triangle is the same as this triangle, check if they form a convex polygon (triangle fan).
+				let merged = false;
+				if (fanBaseIndex == t1) {
+					let o = polygon.length - 4;
+					let winding1 = ConvexDecomposer.winding(polygon[o], polygon[o + 1], polygon[o + 2], polygon[o + 3], x3, y3);
+					let winding2 = ConvexDecomposer.winding(x3, y3, polygon[0], polygon[1], polygon[2], polygon[3]);
+					if (winding1 == lastWinding && winding2 == lastWinding) {
+						polygon.push(x3);
+						polygon.push(y3);
+						polygonIndices.push(t3);
+						merged = true;
+					}
+				}
+
+				// Otherwise make this triangle the new base.
+				if (!merged) {
+					if (polygon.length > 0) {
+						convexPolygons.push(polygon);
+						convexPolygonsIndices.push(polygonIndices);
+					}
+					polygon = this.polygonPool.obtain();
+					polygon.length = 0;
+					polygon.push(x1);
+					polygon.push(y1);
+					polygon.push(x2);
+					polygon.push(y2);
+					polygon.push(x3);
+					polygon.push(y3);
+					polygonIndices = this.polygonIndicesPool.obtain();
+					polygonIndices.length = 0;
+					polygonIndices.push(t1);
+					polygonIndices.push(t2);
+					polygonIndices.push(t3);
+					lastWinding = ConvexDecomposer.winding(x1, y1, x2, y2, x3, y3);
+					fanBaseIndex = t1;
+				}
+			}
+
+			if (polygon.length > 0) {
+				convexPolygons.push(polygon);
+				convexPolygonsIndices.push(polygonIndices);
+			}
+
+			// Go through the list of polygons and try to merge the remaining triangles with the found triangle fans.
+			for (let i = 0, n = convexPolygons.length; i < n; i++) {
+				polygonIndices = convexPolygonsIndices[i];
+				if (polygonIndices.length == 0) continue;
+				let firstIndex = polygonIndices[0];
+				let lastIndex = polygonIndices[polygonIndices.length - 1];
+
+				polygon = convexPolygons[i];
+				let o = polygon.length - 4;
+				let prevPrevX = polygon[o], prevPrevY = polygon[o + 1];
+				let prevX = polygon[o + 2], prevY = polygon[o + 3];
+				let firstX = polygon[0], firstY = polygon[1];
+				let secondX = polygon[2], secondY = polygon[3];
+				let winding = ConvexDecomposer.winding(prevPrevX, prevPrevY, prevX, prevY, firstX, firstY);
+
+				for (let ii = 0; ii < n; ii++) {
+					if (ii == i) continue;
+					let otherIndices = convexPolygonsIndices[ii];
+					if (otherIndices.length != 3) continue;
+					let otherFirstIndex = otherIndices[0];
+					let otherSecondIndex = otherIndices[1];
+					let otherLastIndex = otherIndices[2];
+
+					let otherPoly = convexPolygons[ii];
+					let x3 = otherPoly[otherPoly.length - 2], y3 = otherPoly[otherPoly.length - 1];
+
+					if (otherFirstIndex != firstIndex || otherSecondIndex != lastIndex) continue;
+					let winding1 = ConvexDecomposer.winding(prevPrevX, prevPrevY, prevX, prevY, x3, y3);
+					let winding2 = ConvexDecomposer.winding(x3, y3, firstX, firstY, secondX, secondY);
+					if (winding1 == winding && winding2 == winding) {
+						otherPoly.length = 0;
+						otherIndices.length = 0;
+						polygon.push(x3);
+						polygon.push(y3);
+						polygonIndices.push(otherLastIndex);
+						prevPrevX = prevX;
+						prevPrevY = prevY;
+						prevX = x3;
+						prevY = y3;
+						ii = 0;
+					}
+				}
+			}
+
+			// Remove empty polygons that resulted from the merge step above.
+			for (let i = convexPolygons.length - 1; i >= 0; i--) {
+				polygon = convexPolygons[i];
+				if (polygon.length == 0) {
+					convexPolygons.splice(i, 1);
+					this.polygonPool.free(polygon);
+				}
+			}
+
+			return convexPolygons;
+		}
+
+		private static isConcave (index: number, vertexCount: number, vertices: ArrayLike<number>, indices: ArrayLike<number>): boolean {
+			let previous = indices[(vertexCount + index - 1) % vertexCount] << 1;
+			let current = indices[index] << 1;
+			let next = indices[(index + 1) % vertexCount] << 1;
+			return !this.positiveArea(vertices[previous], vertices[previous + 1], vertices[current], vertices[current + 1], vertices[next],
+				vertices[next + 1]);
+		}
+
+		private static positiveArea (p1x: number, p1y: number, p2x: number, p2y: number, p3x: number, p3y: number): boolean {
+			return p1x * (p3y - p2y) + p2x * (p1y - p3y) + p3x * (p2y - p1y) >= 0;
+		}
+
+		private static winding (p1x: number, p1y: number, p2x: number, p2y: number, p3x: number, p3y: number): number {
+			let px = p2x - p1x, py = p2y - p1y;
+			return p3x * py - p3y * px + px * p1y - p1x * py >= 0 ? 1 : -1;
+		}
+	}
+}

spine-ts/core/src/Utils.ts

@@ -196,6 +196,16 @@ module spine {
 			}
 		}
 
+		static newShortArray (size: number): ArrayLike<number> {
+			if (Utils.SUPPORTS_TYPED_ARRAYS) {
+				return new Int16Array(size)
+			} else {
+				 let array = new Array<number>(size);
+				 for (let i = 0; i < array.length; i++) array[i] = 0;
+				 return array;
+			}
+		}
+
 		static toFloatArray (array: Array<number>) {
 			return Utils.SUPPORTS_TYPED_ARRAYS ? new Float32Array(array) : array;
 		}