@esotericsoftware/spine-core 4.1.25 → 4.1.26

package/dist/SkeletonBounds.d.ts

@@ -0,0 +1,77 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated September 24, 2021. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2021, 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.
+ *
+ * THE SPINE RUNTIMES ARE 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
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { BoundingBoxAttachment } from "./attachments/BoundingBoxAttachment";
+import { Skeleton } from "./Skeleton";
+import { NumberArrayLike } from "./Utils";
+/** Collects each visible {@link BoundingBoxAttachment} and computes the world vertices for its polygon. The polygon vertices are
+ * provided along with convenience methods for doing hit detection. */
+export declare class SkeletonBounds {
+    /** The left edge of the axis aligned bounding box. */
+    minX: number;
+    /** The bottom edge of the axis aligned bounding box. */
+    minY: number;
+    /** The right edge of the axis aligned bounding box. */
+    maxX: number;
+    /** The top edge of the axis aligned bounding box. */
+    maxY: number;
+    /** The visible bounding boxes. */
+    boundingBoxes: BoundingBoxAttachment[];
+    /** The world vertices for the bounding box polygons. */
+    polygons: NumberArrayLike[];
+    private polygonPool;
+    /** Clears any previous polygons, finds all visible bounding box attachments, and computes the world vertices for each bounding
+     * box's polygon.
+     * @param updateAabb If true, the axis aligned bounding box containing all the polygons is computed. If false, the
+     *           SkeletonBounds AABB methods will always return true. */
+    update(skeleton: Skeleton, updateAabb: boolean): void;
+    aabbCompute(): void;
+    /** Returns true if the axis aligned bounding box contains the point. */
+    aabbContainsPoint(x: number, y: number): boolean;
+    /** Returns true if the axis aligned bounding box intersects the line segment. */
+    aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean;
+    /** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
+    aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean;
+    /** 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. */
+    containsPoint(x: number, y: number): BoundingBoxAttachment | null;
+    /** Returns true if the polygon contains the point. */
+    containsPointPolygon(polygon: NumberArrayLike, x: number, y: number): boolean;
+    /** 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()} returns
+     * true. */
+    intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment | null;
+    /** Returns true if the polygon contains any part of the line segment. */
+    intersectsSegmentPolygon(polygon: NumberArrayLike, x1: number, y1: number, x2: number, y2: number): boolean;
+    /** Returns the polygon for the specified bounding box, or null. */
+    getPolygon(boundingBox: BoundingBoxAttachment): NumberArrayLike | null;
+    /** The width of the axis aligned bounding box. */
+    getWidth(): number;
+    /** The height of the axis aligned bounding box. */
+    getHeight(): number;
+}

package/dist/SkeletonBounds.js

@@ -0,0 +1,219 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated September 24, 2021. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2021, 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.
+ *
+ * THE SPINE RUNTIMES ARE 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
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { BoundingBoxAttachment } from "./attachments/BoundingBoxAttachment";
+import { Pool, Utils } from "./Utils";
+/** Collects each visible {@link BoundingBoxAttachment} and computes the world vertices for its polygon. The polygon vertices are
+ * provided along with convenience methods for doing hit detection. */
+export class SkeletonBounds {
+    constructor() {
+        /** The left edge of the axis aligned bounding box. */
+        this.minX = 0;
+        /** The bottom edge of the axis aligned bounding box. */
+        this.minY = 0;
+        /** The right edge of the axis aligned bounding box. */
+        this.maxX = 0;
+        /** The top edge of the axis aligned bounding box. */
+        this.maxY = 0;
+        /** The visible bounding boxes. */
+        this.boundingBoxes = new Array();
+        /** The world vertices for the bounding box polygons. */
+        this.polygons = new Array();
+        this.polygonPool = new Pool(() => {
+            return Utils.newFloatArray(16);
+        });
+    }
+    /** Clears any previous polygons, finds all visible bounding box attachments, and computes the world vertices for each bounding
+     * box's polygon.
+     * @param updateAabb If true, the axis aligned bounding box containing all the polygons is computed. If false, the
+     *           SkeletonBounds AABB methods will always return true. */
+    update(skeleton, updateAabb) {
+        if (!skeleton)
+            throw new Error("skeleton cannot be null.");
+        let boundingBoxes = this.boundingBoxes;
+        let polygons = this.polygons;
+        let polygonPool = this.polygonPool;
+        let slots = skeleton.slots;
+        let slotCount = slots.length;
+        boundingBoxes.length = 0;
+        polygonPool.freeAll(polygons);
+        polygons.length = 0;
+        for (let i = 0; i < slotCount; i++) {
+            let slot = slots[i];
+            if (!slot.bone.active)
+                continue;
+            let attachment = slot.getAttachment();
+            if (attachment instanceof BoundingBoxAttachment) {
+                let boundingBox = attachment;
+                boundingBoxes.push(boundingBox);
+                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;
+        }
+    }
+    aabbCompute() {
+        let minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;
+        let polygons = this.polygons;
+        for (let i = 0, n = polygons.length; i < n; i++) {
+            let polygon = polygons[i];
+            let vertices = polygon;
+            for (let ii = 0, nn = polygon.length; ii < nn; ii += 2) {
+                let x = vertices[ii];
+                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. */
+    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. */
+    aabbIntersectsSegment(x1, y1, x2, y2) {
+        let minX = this.minX;
+        let minY = this.minY;
+        let maxX = this.maxX;
+        let maxY = this.maxY;
+        if ((x1 <= minX && x2 <= minX) || (y1 <= minY && y2 <= minY) || (x1 >= maxX && x2 >= maxX) || (y1 >= maxY && y2 >= maxY))
+            return false;
+        let m = (y2 - y1) / (x2 - x1);
+        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;
+        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. */
+    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. */
+    containsPoint(x, y) {
+        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. */
+    containsPointPolygon(polygon, x, y) {
+        let vertices = polygon;
+        let nn = polygon.length;
+        let prevIndex = nn - 2;
+        let inside = false;
+        for (let ii = 0; ii < nn; ii += 2) {
+            let vertexY = vertices[ii + 1];
+            let prevY = vertices[prevIndex + 1];
+            if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
+                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()} returns
+     * true. */
+    intersectsSegment(x1, y1, x2, y2) {
+        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. */
+    intersectsSegmentPolygon(polygon, x1, y1, x2, y2) {
+        let vertices = polygon;
+        let nn = polygon.length;
+        let width12 = x1 - x2, height12 = y1 - y2;
+        let det1 = x1 * y2 - y1 * x2;
+        let x3 = vertices[nn - 2], y3 = vertices[nn - 1];
+        for (let ii = 0; ii < nn; ii += 2) {
+            let x4 = vertices[ii], y4 = vertices[ii + 1];
+            let det2 = x3 * y4 - y3 * x4;
+            let width34 = x3 - x4, height34 = y3 - y4;
+            let det3 = width12 * height34 - height12 * width34;
+            let x = (det1 * width34 - width12 * det2) / det3;
+            if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) && ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) {
+                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. */
+    getPolygon(boundingBox) {
+        if (!boundingBox)
+            throw new Error("boundingBox cannot be null.");
+        let index = this.boundingBoxes.indexOf(boundingBox);
+        return index == -1 ? null : this.polygons[index];
+    }
+    /** The width of the axis aligned bounding box. */
+    getWidth() {
+        return this.maxX - this.minX;
+    }
+    /** The height of the axis aligned bounding box. */
+    getHeight() {
+        return this.maxY - this.minY;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SkeletonBounds.js","sourceRoot":"","sources":["../src/SkeletonBounds.ts"],"names":[],"mappings":"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"}

package/dist/SkeletonClipping.d.ts

@@ -0,0 +1,50 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated September 24, 2021. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2021, 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.
+ *
+ * THE SPINE RUNTIMES ARE 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
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { ClippingAttachment } from "./attachments/ClippingAttachment";
+import { Slot } from "./Slot";
+import { Color, NumberArrayLike } from "./Utils";
+export declare class SkeletonClipping {
+    private triangulator;
+    private clippingPolygon;
+    private clipOutput;
+    clippedVertices: number[];
+    clippedTriangles: number[];
+    private scratch;
+    private clipAttachment;
+    private clippingPolygons;
+    clipStart(slot: Slot, clip: ClippingAttachment): number;
+    clipEndWithSlot(slot: Slot): void;
+    clipEnd(): void;
+    isClipping(): boolean;
+    clipTriangles(vertices: NumberArrayLike, verticesLength: number, triangles: NumberArrayLike, trianglesLength: number, uvs: NumberArrayLike, light: Color, dark: Color, twoColor: boolean): void;
+    /** Clips the input triangle against the convex, clockwise clipping area. If the triangle lies entirely within the clipping
+     * area, false is returned. The clipping area must duplicate the first vertex at the end of the vertices list. */
+    clip(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, clippingArea: Array<number>, output: Array<number>): boolean;
+    static makeClockwise(polygon: NumberArrayLike): void;
+}