ngx-spine
Version:
[](https://travis-ci.org/PoiScript/ngx-spine)
359 lines • 35.2 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/******************************************************************************
* Spine Runtimes License Agreement
* Last updated May 1, 2019. Replaces all prior versions.
*
* Copyright (c) 2013-2019, Esoteric Software LLC
*
* Integration of the Spine Runtimes into software or otherwise creating
* derivative works of the Spine Runtimes is permitted under the terms and
* conditions of Section 2 of the Spine Editor License Agreement:
* http://esotericsoftware.com/spine-editor-license
*
* Otherwise, it is permitted to integrate the Spine Runtimes into software
* or otherwise create derivative works of the Spine Runtimes (collectively,
* "Products"), provided that each user of the Products must obtain their own
* Spine Editor license and redistribution of the Products in any form must
* include this license and copyright notice.
*
* THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE LLC "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 LLC 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.
*****************************************************************************/
import { Pool, Utils } from "./Utils";
import { BoundingBoxAttachment } from "./attachments/BoundingBoxAttachment";
export class SkeletonBounds {
constructor() {
this.minX = 0;
this.minY = 0;
this.maxX = 0;
this.maxY = 0;
this.boundingBoxes = new Array();
this.polygons = new Array();
this.polygonPool = new Pool((/**
* @return {?}
*/
() => {
return Utils.newFloatArray(16);
}));
}
/**
* @param {?} skeleton
* @param {?} updateAabb
* @return {?}
*/
update(skeleton, updateAabb) {
if (skeleton == null)
throw new Error("skeleton cannot be null.");
/** @type {?} */
let boundingBoxes = this.boundingBoxes;
/** @type {?} */
let polygons = this.polygons;
/** @type {?} */
let polygonPool = this.polygonPool;
/** @type {?} */
let slots = skeleton.slots;
/** @type {?} */
let slotCount = slots.length;
boundingBoxes.length = 0;
polygonPool.freeAll(polygons);
polygons.length = 0;
for (let i = 0; i < slotCount; i++) {
/** @type {?} */
let slot = slots[i];
if (!slot.bone.active)
continue;
/** @type {?} */
let attachment = slot.getAttachment();
if (attachment instanceof BoundingBoxAttachment) {
/** @type {?} */
let boundingBox = (/** @type {?} */ (attachment));
boundingBoxes.push(boundingBox);
/** @type {?} */
let polygon = polygonPool.obtain();
if (polygon.length != boundingBox.worldVerticesLength) {
polygon = Utils.newFloatArray(boundingBox.worldVerticesLength);
}
polygons.push(polygon);
boundingBox.computeWorldVertices(slot, 0, boundingBox.worldVerticesLength, polygon, 0, 2);
}
}
if (updateAabb) {
this.aabbCompute();
}
else {
this.minX = Number.POSITIVE_INFINITY;
this.minY = Number.POSITIVE_INFINITY;
this.maxX = Number.NEGATIVE_INFINITY;
this.maxY = Number.NEGATIVE_INFINITY;
}
}
/**
* @return {?}
*/
aabbCompute() {
/** @type {?} */
let minX = Number.POSITIVE_INFINITY;
/** @type {?} */
let minY = Number.POSITIVE_INFINITY;
/** @type {?} */
let maxX = Number.NEGATIVE_INFINITY;
/** @type {?} */
let maxY = Number.NEGATIVE_INFINITY;
/** @type {?} */
let polygons = this.polygons;
for (let i = 0, n = polygons.length; i < n; i++) {
/** @type {?} */
let polygon = polygons[i];
/** @type {?} */
let vertices = polygon;
for (let ii = 0, nn = polygon.length; ii < nn; ii += 2) {
/** @type {?} */
let x = vertices[ii];
/** @type {?} */
let y = vertices[ii + 1];
minX = Math.min(minX, x);
minY = Math.min(minY, y);
maxX = Math.max(maxX, x);
maxY = Math.max(maxY, y);
}
}
this.minX = minX;
this.minY = minY;
this.maxX = maxX;
this.maxY = maxY;
}
/**
* Returns true if the axis aligned bounding box contains the point.
* @param {?} x
* @param {?} y
* @return {?}
*/
aabbContainsPoint(x, y) {
return x >= this.minX && x <= this.maxX && y >= this.minY && y <= this.maxY;
}
/**
* Returns true if the axis aligned bounding box intersects the line segment.
* @param {?} x1
* @param {?} y1
* @param {?} x2
* @param {?} y2
* @return {?}
*/
aabbIntersectsSegment(x1, y1, x2, y2) {
/** @type {?} */
let minX = this.minX;
/** @type {?} */
let minY = this.minY;
/** @type {?} */
let maxX = this.maxX;
/** @type {?} */
let maxY = this.maxY;
if ((x1 <= minX && x2 <= minX) ||
(y1 <= minY && y2 <= minY) ||
(x1 >= maxX && x2 >= maxX) ||
(y1 >= maxY && y2 >= maxY))
return false;
/** @type {?} */
let m = (y2 - y1) / (x2 - x1);
/** @type {?} */
let y = m * (minX - x1) + y1;
if (y > minY && y < maxY)
return true;
y = m * (maxX - x1) + y1;
if (y > minY && y < maxY)
return true;
/** @type {?} */
let x = (minY - y1) / m + x1;
if (x > minX && x < maxX)
return true;
x = (maxY - y1) / m + x1;
if (x > minX && x < maxX)
return true;
return false;
}
/**
* Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds.
* @param {?} bounds
* @return {?}
*/
aabbIntersectsSkeleton(bounds) {
return (this.minX < bounds.maxX &&
this.maxX > bounds.minX &&
this.minY < bounds.maxY &&
this.maxY > bounds.minY);
}
/**
* Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
* efficient to only call this method if {\@link #aabbContainsPoint(float, float)} returns true.
* @param {?} x
* @param {?} y
* @return {?}
*/
containsPoint(x, y) {
/** @type {?} */
let polygons = this.polygons;
for (let i = 0, n = polygons.length; i < n; i++)
if (this.containsPointPolygon(polygons[i], x, y))
return this.boundingBoxes[i];
return null;
}
/**
* Returns true if the polygon contains the point.
* @param {?} polygon
* @param {?} x
* @param {?} y
* @return {?}
*/
containsPointPolygon(polygon, x, y) {
/** @type {?} */
let vertices = polygon;
/** @type {?} */
let nn = polygon.length;
/** @type {?} */
let prevIndex = nn - 2;
/** @type {?} */
let inside = false;
for (let ii = 0; ii < nn; ii += 2) {
/** @type {?} */
let vertexY = vertices[ii + 1];
/** @type {?} */
let prevY = vertices[prevIndex + 1];
if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
/** @type {?} */
let vertexX = vertices[ii];
if (vertexX +
((y - vertexY) / (prevY - vertexY)) *
(vertices[prevIndex] - vertexX) <
x)
inside = !inside;
}
prevIndex = ii;
}
return inside;
}
/**
* Returns the first bounding box attachment that contains any part of the line segment, or null. When doing many checks, it
* is usually more efficient to only call this method if {\@link #aabbIntersectsSegment(float, float, float, float)} returns
* true.
* @param {?} x1
* @param {?} y1
* @param {?} x2
* @param {?} y2
* @return {?}
*/
intersectsSegment(x1, y1, x2, y2) {
/** @type {?} */
let polygons = this.polygons;
for (let i = 0, n = polygons.length; i < n; i++)
if (this.intersectsSegmentPolygon(polygons[i], x1, y1, x2, y2))
return this.boundingBoxes[i];
return null;
}
/**
* Returns true if the polygon contains any part of the line segment.
* @param {?} polygon
* @param {?} x1
* @param {?} y1
* @param {?} x2
* @param {?} y2
* @return {?}
*/
intersectsSegmentPolygon(polygon, x1, y1, x2, y2) {
/** @type {?} */
let vertices = polygon;
/** @type {?} */
let nn = polygon.length;
/** @type {?} */
let width12 = x1 - x2;
/** @type {?} */
let height12 = y1 - y2;
/** @type {?} */
let det1 = x1 * y2 - y1 * x2;
/** @type {?} */
let x3 = vertices[nn - 2];
/** @type {?} */
let y3 = vertices[nn - 1];
for (let ii = 0; ii < nn; ii += 2) {
/** @type {?} */
let x4 = vertices[ii];
/** @type {?} */
let y4 = vertices[ii + 1];
/** @type {?} */
let det2 = x3 * y4 - y3 * x4;
/** @type {?} */
let width34 = x3 - x4;
/** @type {?} */
let height34 = y3 - y4;
/** @type {?} */
let det3 = width12 * height34 - height12 * width34;
/** @type {?} */
let x = (det1 * width34 - width12 * det2) / det3;
if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) &&
((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) {
/** @type {?} */
let y = (det1 * height34 - height12 * det2) / det3;
if (((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) &&
((y >= y1 && y <= y2) || (y >= y2 && y <= y1)))
return true;
}
x3 = x4;
y3 = y4;
}
return false;
}
/**
* Returns the polygon for the specified bounding box, or null.
* @param {?} boundingBox
* @return {?}
*/
getPolygon(boundingBox) {
if (boundingBox == null)
throw new Error("boundingBox cannot be null.");
/** @type {?} */
let index = this.boundingBoxes.indexOf(boundingBox);
return index == -1 ? null : this.polygons[index];
}
/**
* @return {?}
*/
getWidth() {
return this.maxX - this.minX;
}
/**
* @return {?}
*/
getHeight() {
return this.maxY - this.minY;
}
}
if (false) {
/** @type {?} */
SkeletonBounds.prototype.minX;
/** @type {?} */
SkeletonBounds.prototype.minY;
/** @type {?} */
SkeletonBounds.prototype.maxX;
/** @type {?} */
SkeletonBounds.prototype.maxY;
/** @type {?} */
SkeletonBounds.prototype.boundingBoxes;
/** @type {?} */
SkeletonBounds.prototype.polygons;
/**
* @type {?}
* @private
*/
SkeletonBounds.prototype.polygonPool;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SkeletonBounds.js","sourceRoot":"ng://ngx-spine/","sources":["lib/spine-ts/core/SkeletonBounds.ts"],"names":[],"mappings":"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","sourcesContent":["/******************************************************************************\r\n * Spine Runtimes License Agreement\r\n * Last updated May 1, 2019. Replaces all prior versions.\r\n *\r\n * Copyright (c) 2013-2019, Esoteric Software LLC\r\n *\r\n * Integration of the Spine Runtimes into software or otherwise creating\r\n * derivative works of the Spine Runtimes is permitted under the terms and\r\n * conditions of Section 2 of the Spine Editor License Agreement:\r\n * http://esotericsoftware.com/spine-editor-license\r\n *\r\n * Otherwise, it is permitted to integrate the Spine Runtimes into software\r\n * or otherwise create derivative works of the Spine Runtimes (collectively,\r\n * \"Products\"), provided that each user of the Products must obtain their own\r\n * Spine Editor license and redistribution of the Products in any form must\r\n * include this license and copyright notice.\r\n *\r\n * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE LLC \"AS IS\" AND ANY EXPRESS\r\n * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\r\n * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN\r\n * NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY DIRECT, INDIRECT,\r\n * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,\r\n * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, BUSINESS\r\n * INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND ON ANY\r\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\r\n * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,\r\n * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n *****************************************************************************/\r\n\r\nimport { Pool, Utils } from \"./Utils\";\r\nimport { BoundingBoxAttachment } from \"./attachments/BoundingBoxAttachment\";\r\nimport { Skeleton } from \"./Skeleton\";\r\n\r\nexport class SkeletonBounds {\r\n  minX = 0;\r\n  minY = 0;\r\n  maxX = 0;\r\n  maxY = 0;\r\n  boundingBoxes = new Array<BoundingBoxAttachment>();\r\n  polygons = new Array<ArrayLike<number>>();\r\n  private polygonPool = new Pool<ArrayLike<number>>(() => {\r\n    return Utils.newFloatArray(16);\r\n  });\r\n  update(skeleton: Skeleton, updateAabb: boolean) {\r\n    if (skeleton == null) throw new Error(\"skeleton cannot be null.\");\r\n    let boundingBoxes = this.boundingBoxes;\r\n    let polygons = this.polygons;\r\n    let polygonPool = this.polygonPool;\r\n    let slots = skeleton.slots;\r\n    let slotCount = slots.length;\r\n    boundingBoxes.length = 0;\r\n    polygonPool.freeAll(polygons);\r\n    polygons.length = 0;\r\n    for (let i = 0; i < slotCount; i++) {\r\n      let slot = slots[i];\r\n      if (!slot.bone.active) continue;\r\n      let attachment = slot.getAttachment();\r\n      if (attachment instanceof BoundingBoxAttachment) {\r\n        let boundingBox = attachment as BoundingBoxAttachment;\r\n        boundingBoxes.push(boundingBox);\r\n        let polygon = polygonPool.obtain();\r\n        if (polygon.length != boundingBox.worldVerticesLength) {\r\n          polygon = Utils.newFloatArray(boundingBox.worldVerticesLength);\r\n        }\r\n        polygons.push(polygon);\r\n        boundingBox.computeWorldVertices(\r\n          slot,\r\n          0,\r\n          boundingBox.worldVerticesLength,\r\n          polygon,\r\n          0,\r\n          2\r\n        );\r\n      }\r\n    }\r\n    if (updateAabb) {\r\n      this.aabbCompute();\r\n    } else {\r\n      this.minX = Number.POSITIVE_INFINITY;\r\n      this.minY = Number.POSITIVE_INFINITY;\r\n      this.maxX = Number.NEGATIVE_INFINITY;\r\n      this.maxY = Number.NEGATIVE_INFINITY;\r\n    }\r\n  }\r\n  aabbCompute() {\r\n    let minX = Number.POSITIVE_INFINITY,\r\n      minY = Number.POSITIVE_INFINITY,\r\n      maxX = Number.NEGATIVE_INFINITY,\r\n      maxY = Number.NEGATIVE_INFINITY;\r\n    let polygons = this.polygons;\r\n    for (let i = 0, n = polygons.length; i < n; i++) {\r\n      let polygon = polygons[i];\r\n      let vertices = polygon;\r\n      for (let ii = 0, nn = polygon.length; ii < nn; ii += 2) {\r\n        let x = vertices[ii];\r\n        let y = vertices[ii + 1];\r\n        minX = Math.min(minX, x);\r\n        minY = Math.min(minY, y);\r\n        maxX = Math.max(maxX, x);\r\n        maxY = Math.max(maxY, y);\r\n      }\r\n    }\r\n    this.minX = minX;\r\n    this.minY = minY;\r\n    this.maxX = maxX;\r\n    this.maxY = maxY;\r\n  }\r\n  /** Returns true if the axis aligned bounding box contains the point. */\r\n  aabbContainsPoint(x: number, y: number) {\r\n    return x >= this.minX && x <= this.maxX && y >= this.minY && y <= this.maxY;\r\n  }\r\n  /** Returns true if the axis aligned bounding box intersects the line segment. */\r\n  aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number) {\r\n    let minX = this.minX;\r\n    let minY = this.minY;\r\n    let maxX = this.maxX;\r\n    let maxY = this.maxY;\r\n    if (\r\n      (x1 <= minX && x2 <= minX) ||\r\n      (y1 <= minY && y2 <= minY) ||\r\n      (x1 >= maxX && x2 >= maxX) ||\r\n      (y1 >= maxY && y2 >= maxY)\r\n    )\r\n      return false;\r\n    let m = (y2 - y1) / (x2 - x1);\r\n    let y = m * (minX - x1) + y1;\r\n    if (y > minY && y < maxY) return true;\r\n    y = m * (maxX - x1) + y1;\r\n    if (y > minY && y < maxY) return true;\r\n    let x = (minY - y1) / m + x1;\r\n    if (x > minX && x < maxX) return true;\r\n    x = (maxY - y1) / m + x1;\r\n    if (x > minX && x < maxX) return true;\r\n    return false;\r\n  }\r\n  /** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */\r\n  aabbIntersectsSkeleton(bounds: SkeletonBounds) {\r\n    return (\r\n      this.minX < bounds.maxX &&\r\n      this.maxX > bounds.minX &&\r\n      this.minY < bounds.maxY &&\r\n      this.maxY > bounds.minY\r\n    );\r\n  }\r\n  /** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more\r\n   * efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */\r\n  containsPoint(x: number, y: number): BoundingBoxAttachment {\r\n    let polygons = this.polygons;\r\n    for (let i = 0, n = polygons.length; i < n; i++)\r\n      if (this.containsPointPolygon(polygons[i], x, y))\r\n        return this.boundingBoxes[i];\r\n    return null;\r\n  }\r\n  /** Returns true if the polygon contains the point. */\r\n  containsPointPolygon(polygon: ArrayLike<number>, x: number, y: number) {\r\n    let vertices = polygon;\r\n    let nn = polygon.length;\r\n    let prevIndex = nn - 2;\r\n    let inside = false;\r\n    for (let ii = 0; ii < nn; ii += 2) {\r\n      let vertexY = vertices[ii + 1];\r\n      let prevY = vertices[prevIndex + 1];\r\n      if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {\r\n        let vertexX = vertices[ii];\r\n        if (\r\n          vertexX +\r\n            ((y - vertexY) / (prevY - vertexY)) *\r\n              (vertices[prevIndex] - vertexX) <\r\n          x\r\n        )\r\n          inside = !inside;\r\n      }\r\n      prevIndex = ii;\r\n    }\r\n    return inside;\r\n  }\r\n  /** Returns the first bounding box attachment that contains any part of the line segment, or null. When doing many checks, it\r\n   * is usually more efficient to only call this method if {@link #aabbIntersectsSegment(float, float, float, float)} returns\r\n   * true. */\r\n  intersectsSegment(x1: number, y1: number, x2: number, y2: number) {\r\n    let polygons = this.polygons;\r\n    for (let i = 0, n = polygons.length; i < n; i++)\r\n      if (this.intersectsSegmentPolygon(polygons[i], x1, y1, x2, y2))\r\n        return this.boundingBoxes[i];\r\n    return null;\r\n  }\r\n  /** Returns true if the polygon contains any part of the line segment. */\r\n  intersectsSegmentPolygon(\r\n    polygon: ArrayLike<number>,\r\n    x1: number,\r\n    y1: number,\r\n    x2: number,\r\n    y2: number\r\n  ) {\r\n    let vertices = polygon;\r\n    let nn = polygon.length;\r\n    let width12 = x1 - x2,\r\n      height12 = y1 - y2;\r\n    let det1 = x1 * y2 - y1 * x2;\r\n    let x3 = vertices[nn - 2],\r\n      y3 = vertices[nn - 1];\r\n    for (let ii = 0; ii < nn; ii += 2) {\r\n      let x4 = vertices[ii],\r\n        y4 = vertices[ii + 1];\r\n      let det2 = x3 * y4 - y3 * x4;\r\n      let width34 = x3 - x4,\r\n        height34 = y3 - y4;\r\n      let det3 = width12 * height34 - height12 * width34;\r\n      let x = (det1 * width34 - width12 * det2) / det3;\r\n      if (\r\n        ((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) &&\r\n        ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))\r\n      ) {\r\n        let y = (det1 * height34 - height12 * det2) / det3;\r\n        if (\r\n          ((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) &&\r\n          ((y >= y1 && y <= y2) || (y >= y2 && y <= y1))\r\n        )\r\n          return true;\r\n      }\r\n      x3 = x4;\r\n      y3 = y4;\r\n    }\r\n    return false;\r\n  }\r\n  /** Returns the polygon for the specified bounding box, or null. */\r\n  getPolygon(boundingBox: BoundingBoxAttachment) {\r\n    if (boundingBox == null) throw new Error(\"boundingBox cannot be null.\");\r\n    let index = this.boundingBoxes.indexOf(boundingBox);\r\n    return index == -1 ? null : this.polygons[index];\r\n  }\r\n  getWidth() {\r\n    return this.maxX - this.minX;\r\n  }\r\n  getHeight() {\r\n    return this.maxY - this.minY;\r\n  }\r\n}\r\n"]}