@safe-engine/pixi 8.8.1 → 8.8.3

package/dist/dragonbones/dragonBones/armature/Surface.d.ts

@@ -0,0 +1,41 @@
+import { Matrix } from "../geom/Matrix";
+import { SurfaceData } from "../model/ArmatureData";
+import { Armature } from "./Armature";
+import { Bone } from "./Bone";
+/**
+ * @internal
+ */
+export declare class Surface extends Bone {
+    static toString(): string;
+    private _dX;
+    private _dY;
+    private _k;
+    private _kX;
+    private _kY;
+    readonly _vertices: Array<number>;
+    readonly _deformVertices: Array<number>;
+    /**
+     * - x1, y1, x2, y2, x3, y3, x4, y4, d1X, d1Y, d2X, d2Y
+     */
+    private readonly _hullCache;
+    /**
+     * - Inside [flag, a, b, c, d, tx, ty], Outside [flag, a, b, c, d, tx, ty]
+     */
+    private readonly _matrixCahce;
+    _bone: Bone | null;
+    protected _onClear(): void;
+    private _getAffineTransform;
+    private _updateVertices;
+    protected _updateGlobalTransformMatrix(isCache: boolean): void;
+    _getGlobalTransformMatrix(x: number, y: number): Matrix;
+    /**
+     * @internal
+     * @private
+     */
+    init(surfaceData: SurfaceData, armatureValue: Armature): void;
+    /**
+     * @internal
+     */
+    update(cacheFrameIndex: number): void;
+}
+//# sourceMappingURL=Surface.d.ts.map

package/dist/dragonbones/dragonBones/armature/Surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Surface.d.ts","sourceRoot":"","sources":["../../../../src/dragonbones/dragonBones/armature/Surface.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAExC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B;;GAEG;AACH,qBAAa,OAAQ,SAAQ,IAAI;WACjB,QAAQ,IAAI,MAAM;IAIhC,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,GAAG,CAAS;IAEpB,SAAgB,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAM;IAC9C,SAAgB,eAAe,EAAE,KAAK,CAAC,MAAM,CAAC,CAAM;IACpD;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;IAChD;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAE3C,KAAK,EAAE,IAAI,GAAG,IAAI,CAAC;IAE1B,SAAS,CAAC,QAAQ,IAAI,IAAI;IAe1B,OAAO,CAAC,mBAAmB;IAmC3B,OAAO,CAAC,eAAe;IAmDvB,SAAS,CAAC,4BAA4B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IA8CvD,yBAAyB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IA2U9D;;;OAGG;IACI,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,QAAQ,GAAG,IAAI;IAuCpE;;OAEG;IACI,MAAM,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI;CAyH7C"}

package/dist/dragonbones/dragonBones/armature/Surface.js

@@ -0,0 +1,463 @@
+import { Bone } from "./Bone";
+/**
+ * @internal
+ */
+export class Surface extends Bone {
+    constructor() {
+        super(...arguments);
+        this._vertices = [];
+        this._deformVertices = [];
+        /**
+         * - x1, y1, x2, y2, x3, y3, x4, y4, d1X, d1Y, d2X, d2Y
+         */
+        this._hullCache = [];
+        /**
+         * - Inside [flag, a, b, c, d, tx, ty], Outside [flag, a, b, c, d, tx, ty]
+         */
+        this._matrixCahce = [];
+    }
+    static toString() {
+        return "[class dragonBones.Surface]";
+    }
+    _onClear() {
+        super._onClear();
+        this._dX = 0.0;
+        this._dY = 0.0;
+        this._k = 0.0;
+        this._kX = 0.0;
+        this._kY = 0.0;
+        this._vertices.length = 0;
+        this._deformVertices.length = 0;
+        this._matrixCahce.length = 0;
+        this._hullCache.length = 0;
+        this._bone = null;
+    }
+    _getAffineTransform(x, y, lX, lY, aX, aY, bX, bY, cX, cY, transform, matrix, isDown) {
+        const dabX = bX - aX;
+        const dabY = bY - aY;
+        const dacX = cX - aX;
+        const dacY = cY - aY;
+        transform.rotation = Math.atan2(dabY, dabX);
+        transform.skew =
+            Math.atan2(dacY, dacX) - Math.PI * 0.5 - transform.rotation;
+        if (isDown) {
+            transform.rotation += Math.PI;
+        }
+        transform.scaleX = Math.sqrt(dabX * dabX + dabY * dabY) / lX;
+        transform.scaleY = Math.sqrt(dacX * dacX + dacY * dacY) / lY;
+        transform.toMatrix(matrix);
+        transform.x = matrix.tx = aX - (matrix.a * x + matrix.c * y);
+        transform.y = matrix.ty = aY - (matrix.b * x + matrix.d * y);
+    }
+    _updateVertices() {
+        const data = this._armature.armatureData.parent;
+        const geometry = this._boneData.geometry;
+        const intArray = data.intArray;
+        const floatArray = data.floatArray;
+        const vertexCount = intArray[geometry.offset + 0 /* BinaryOffset.GeometryVertexCount */];
+        const verticesOffset = intArray[geometry.offset + 2 /* BinaryOffset.GeometryFloatOffset */];
+        const vertices = this._vertices;
+        const animationVertices = this._deformVertices;
+        if (this._parent !== null) {
+            if (this._parent._boneData.type === 1 /* BoneType.Surface */) {
+                for (let i = 0, l = vertexCount; i < l; ++i) {
+                    const iD = i * 2;
+                    const x = floatArray[verticesOffset + iD] + animationVertices[iD];
+                    const y = floatArray[verticesOffset + iD + 1] + animationVertices[iD + 1];
+                    const matrix = this._parent._getGlobalTransformMatrix(x, y);
+                    //
+                    vertices[iD] = matrix.a * x + matrix.c * y + matrix.tx;
+                    vertices[iD + 1] = matrix.b * x + matrix.d * y + matrix.ty;
+                }
+            }
+            else {
+                const parentMatrix = this._parent.globalTransformMatrix;
+                for (let i = 0, l = vertexCount; i < l; ++i) {
+                    const iD = i * 2;
+                    const x = floatArray[verticesOffset + iD] + animationVertices[iD];
+                    const y = floatArray[verticesOffset + iD + 1] + animationVertices[iD + 1];
+                    //
+                    vertices[iD] =
+                        parentMatrix.a * x + parentMatrix.c * y + parentMatrix.tx;
+                    vertices[iD + 1] =
+                        parentMatrix.b * x + parentMatrix.d * y + parentMatrix.ty;
+                }
+            }
+        }
+        else {
+            for (let i = 0, l = vertexCount; i < l; ++i) {
+                const iD = i * 2;
+                vertices[iD] = floatArray[verticesOffset + iD] + animationVertices[iD];
+                vertices[iD + 1] =
+                    floatArray[verticesOffset + iD + 1] + animationVertices[iD + 1];
+            }
+        }
+    }
+    _updateGlobalTransformMatrix(isCache) {
+        // tslint:disable-next-line:no-unused-expression
+        isCache;
+        const segmentXD = this._boneData.segmentX * 2;
+        const lastIndex = this._vertices.length - 2;
+        const lA = 200.0;
+        //
+        const raX = this._vertices[0];
+        const raY = this._vertices[1];
+        const rbX = this._vertices[segmentXD];
+        const rbY = this._vertices[segmentXD + 1];
+        const rcX = this._vertices[lastIndex];
+        const rcY = this._vertices[lastIndex + 1];
+        const rdX = this._vertices[lastIndex - segmentXD];
+        const rdY = this._vertices[lastIndex - segmentXD + 1];
+        //
+        const dacX = raX + (rcX - raX) * 0.5;
+        const dacY = raY + (rcY - raY) * 0.5;
+        const dbdX = rbX + (rdX - rbX) * 0.5;
+        const dbdY = rbY + (rdY - rbY) * 0.5;
+        const aX = dacX + (dbdX - dacX) * 0.5;
+        const aY = dacY + (dbdY - dacY) * 0.5;
+        const bX = rbX + (rcX - rbX) * 0.5;
+        const bY = rbY + (rcY - rbY) * 0.5;
+        const cX = rdX + (rcX - rdX) * 0.5;
+        const cY = rdY + (rcY - rdY) * 0.5;
+        // TODO interpolation
+        this._getAffineTransform(0.0, 0.0, lA, lA, aX, aY, bX, bY, cX, cY, this.global, this.globalTransformMatrix, false);
+        this._globalDirty = false;
+    }
+    _getGlobalTransformMatrix(x, y) {
+        const lA = 200.0;
+        const lB = 1000.0;
+        if (x < -lB || lB < x || y < -lB || lB < y) {
+            return this.globalTransformMatrix;
+        }
+        let isDown = false;
+        const surfaceData = this._boneData;
+        const segmentX = surfaceData.segmentX;
+        const segmentY = surfaceData.segmentY;
+        const segmentXD = surfaceData.segmentX * 2;
+        const dX = this._dX;
+        const dY = this._dY;
+        const indexX = Math.floor((x + lA) / dX); // -1 ~ segmentX - 1
+        const indexY = Math.floor((y + lA) / dY); // -1 ~ segmentY - 1
+        let matrixIndex = 0;
+        let pX = indexX * dX - lA;
+        let pY = indexY * dY - lA;
+        //
+        const matrices = this._matrixCahce;
+        const helpMatrix = Surface._helpMatrix;
+        if (x < -lA) {
+            if (y < -lA || y >= lA) {
+                // Out.
+                return this.globalTransformMatrix;
+            }
+            // Left.
+            isDown = y > this._kX * (x + lA) + pY;
+            matrixIndex =
+                ((segmentX * segmentY + segmentX + segmentY + segmentY + indexY) * 2 +
+                    (isDown ? 1 : 0)) *
+                    7;
+            if (matrices[matrixIndex] > 0.0) {
+                helpMatrix.copyFromArray(matrices, matrixIndex + 1);
+            }
+            else {
+                const vertexIndex = indexY * (segmentXD + 2);
+                const ddX = this._hullCache[4];
+                const ddY = this._hullCache[5];
+                const sX = this._hullCache[2] - (segmentY - indexY) * ddX;
+                const sY = this._hullCache[3] - (segmentY - indexY) * ddY;
+                const vertices = this._vertices;
+                if (isDown) {
+                    this._getAffineTransform(-lA, pY + dY, lB - lA, dY, vertices[vertexIndex + segmentXD + 2], vertices[vertexIndex + segmentXD + 3], sX + ddX, sY + ddY, vertices[vertexIndex], vertices[vertexIndex + 1], Surface._helpTransform, helpMatrix, true);
+                }
+                else {
+                    this._getAffineTransform(-lB, pY, lB - lA, dY, sX, sY, vertices[vertexIndex], vertices[vertexIndex + 1], sX + ddX, sY + ddY, Surface._helpTransform, helpMatrix, false);
+                }
+                matrices[matrixIndex] = 1.0;
+                matrices[matrixIndex + 1] = helpMatrix.a;
+                matrices[matrixIndex + 2] = helpMatrix.b;
+                matrices[matrixIndex + 3] = helpMatrix.c;
+                matrices[matrixIndex + 4] = helpMatrix.d;
+                matrices[matrixIndex + 5] = helpMatrix.tx;
+                matrices[matrixIndex + 6] = helpMatrix.ty;
+            }
+        }
+        else if (x >= lA) {
+            if (y < -lA || y >= lA) {
+                // Out.
+                return this.globalTransformMatrix;
+            }
+            // Right.
+            isDown = y > this._kX * (x - lB) + pY;
+            matrixIndex =
+                ((segmentX * segmentY + segmentX + indexY) * 2 + (isDown ? 1 : 0)) * 7;
+            if (matrices[matrixIndex] > 0.0) {
+                helpMatrix.copyFromArray(matrices, matrixIndex + 1);
+            }
+            else {
+                const vertexIndex = (indexY + 1) * (segmentXD + 2) - 2;
+                const ddX = this._hullCache[4];
+                const ddY = this._hullCache[5];
+                const sX = this._hullCache[0] + indexY * ddX;
+                const sY = this._hullCache[1] + indexY * ddY;
+                const vertices = this._vertices;
+                if (isDown) {
+                    this._getAffineTransform(lB, pY + dY, lB - lA, dY, sX + ddX, sY + ddY, vertices[vertexIndex + segmentXD + 2], vertices[vertexIndex + segmentXD + 3], sX, sY, Surface._helpTransform, helpMatrix, true);
+                }
+                else {
+                    this._getAffineTransform(lA, pY, lB - lA, dY, vertices[vertexIndex], vertices[vertexIndex + 1], sX, sY, vertices[vertexIndex + segmentXD + 2], vertices[vertexIndex + segmentXD + 3], Surface._helpTransform, helpMatrix, false);
+                }
+                matrices[matrixIndex] = 1.0;
+                matrices[matrixIndex + 1] = helpMatrix.a;
+                matrices[matrixIndex + 2] = helpMatrix.b;
+                matrices[matrixIndex + 3] = helpMatrix.c;
+                matrices[matrixIndex + 4] = helpMatrix.d;
+                matrices[matrixIndex + 5] = helpMatrix.tx;
+                matrices[matrixIndex + 6] = helpMatrix.ty;
+            }
+        }
+        else if (y < -lA) {
+            if (x < -lA || x >= lA) {
+                // Out.
+                return this.globalTransformMatrix;
+            }
+            // Up.
+            isDown = y > this._kY * (x - pX - dX) - lB;
+            matrixIndex = ((segmentX * segmentY + indexX) * 2 + (isDown ? 1 : 0)) * 7;
+            if (matrices[matrixIndex] > 0.0) {
+                helpMatrix.copyFromArray(matrices, matrixIndex + 1);
+            }
+            else {
+                const vertexIndex = indexX * 2;
+                const ddX = this._hullCache[10];
+                const ddY = this._hullCache[11];
+                const sX = this._hullCache[8] + indexX * ddX;
+                const sY = this._hullCache[9] + indexX * ddY;
+                const vertices = this._vertices;
+                if (isDown) {
+                    this._getAffineTransform(pX + dX, -lA, dX, lB - lA, vertices[vertexIndex + 2], vertices[vertexIndex + 3], vertices[vertexIndex], vertices[vertexIndex + 1], sX + ddX, sY + ddY, Surface._helpTransform, helpMatrix, true);
+                }
+                else {
+                    this._getAffineTransform(pX, -lB, dX, lB - lA, sX, sY, sX + ddX, sY + ddY, vertices[vertexIndex], vertices[vertexIndex + 1], Surface._helpTransform, helpMatrix, false);
+                }
+                matrices[matrixIndex] = 1.0;
+                matrices[matrixIndex + 1] = helpMatrix.a;
+                matrices[matrixIndex + 2] = helpMatrix.b;
+                matrices[matrixIndex + 3] = helpMatrix.c;
+                matrices[matrixIndex + 4] = helpMatrix.d;
+                matrices[matrixIndex + 5] = helpMatrix.tx;
+                matrices[matrixIndex + 6] = helpMatrix.ty;
+            }
+        }
+        else if (y >= lA) {
+            if (x < -lA || x >= lA) {
+                //  Out.
+                return this.globalTransformMatrix;
+            }
+            // Down
+            isDown = y > this._kY * (x - pX - dX) + lA;
+            matrixIndex =
+                ((segmentX * segmentY + segmentX + segmentY + indexX) * 2 +
+                    (isDown ? 1 : 0)) *
+                    7;
+            if (matrices[matrixIndex] > 0.0) {
+                helpMatrix.copyFromArray(matrices, matrixIndex + 1);
+            }
+            else {
+                const vertexIndex = segmentY * (segmentXD + 2) + indexX * 2;
+                const ddX = this._hullCache[10];
+                const ddY = this._hullCache[11];
+                const sX = this._hullCache[6] - (segmentX - indexX) * ddX;
+                const sY = this._hullCache[7] - (segmentX - indexX) * ddY;
+                const vertices = this._vertices;
+                if (isDown) {
+                    this._getAffineTransform(pX + dX, lB, dX, lB - lA, sX + ddX, sY + ddY, sX, sY, vertices[vertexIndex + 2], vertices[vertexIndex + 3], Surface._helpTransform, helpMatrix, true);
+                }
+                else {
+                    this._getAffineTransform(pX, lA, dX, lB - lA, vertices[vertexIndex], vertices[vertexIndex + 1], vertices[vertexIndex + 2], vertices[vertexIndex + 3], sX, sY, Surface._helpTransform, helpMatrix, false);
+                }
+                matrices[matrixIndex] = 1.0;
+                matrices[matrixIndex + 1] = helpMatrix.a;
+                matrices[matrixIndex + 2] = helpMatrix.b;
+                matrices[matrixIndex + 3] = helpMatrix.c;
+                matrices[matrixIndex + 4] = helpMatrix.d;
+                matrices[matrixIndex + 5] = helpMatrix.tx;
+                matrices[matrixIndex + 6] = helpMatrix.ty;
+            }
+        }
+        else {
+            // Center.
+            isDown = y > this._k * (x - pX - dX) + pY;
+            matrixIndex = ((segmentX * indexY + indexX) * 2 + (isDown ? 1 : 0)) * 7;
+            if (matrices[matrixIndex] > 0.0) {
+                helpMatrix.copyFromArray(matrices, matrixIndex + 1);
+            }
+            else {
+                const vertexIndex = indexX * 2 + indexY * (segmentXD + 2);
+                const vertices = this._vertices;
+                if (isDown) {
+                    this._getAffineTransform(pX + dX, pY + dY, dX, dY, vertices[vertexIndex + segmentXD + 4], vertices[vertexIndex + segmentXD + 5], vertices[vertexIndex + segmentXD + 2], vertices[vertexIndex + segmentXD + 3], vertices[vertexIndex + 2], vertices[vertexIndex + 3], Surface._helpTransform, helpMatrix, true);
+                }
+                else {
+                    this._getAffineTransform(pX, pY, dX, dY, vertices[vertexIndex], vertices[vertexIndex + 1], vertices[vertexIndex + 2], vertices[vertexIndex + 3], vertices[vertexIndex + segmentXD + 2], vertices[vertexIndex + segmentXD + 3], Surface._helpTransform, helpMatrix, false);
+                }
+                matrices[matrixIndex] = 1.0;
+                matrices[matrixIndex + 1] = helpMatrix.a;
+                matrices[matrixIndex + 2] = helpMatrix.b;
+                matrices[matrixIndex + 3] = helpMatrix.c;
+                matrices[matrixIndex + 4] = helpMatrix.d;
+                matrices[matrixIndex + 5] = helpMatrix.tx;
+                matrices[matrixIndex + 6] = helpMatrix.ty;
+            }
+        }
+        return helpMatrix;
+    }
+    /**
+     * @internal
+     * @private
+     */
+    init(surfaceData, armatureValue) {
+        if (this._boneData !== null) {
+            return;
+        }
+        super.init(surfaceData, armatureValue);
+        const segmentX = surfaceData.segmentX;
+        const segmentY = surfaceData.segmentY;
+        const vertexCount = this._armature.armatureData.parent.intArray[surfaceData.geometry.offset + 0 /* BinaryOffset.GeometryVertexCount */];
+        const lB = 1000.0;
+        const lA = 200.0;
+        //
+        this._dX = (lA * 2.0) / segmentX;
+        this._dY = (lA * 2.0) / segmentY;
+        this._k = -this._dY / this._dX;
+        this._kX = -this._dY / (lB - lA);
+        this._kY = -(lB - lA) / this._dX;
+        this._vertices.length = vertexCount * 2;
+        this._deformVertices.length = vertexCount * 2;
+        this._matrixCahce.length =
+            (segmentX * segmentY + segmentX * 2 + segmentY * 2) * 2 * 7;
+        this._hullCache.length = 10;
+        for (let i = 0; i < vertexCount * 2; ++i) {
+            this._deformVertices[i] = 0.0;
+        }
+        if (this._parent !== null) {
+            if (this._parent.boneData.type === 0 /* BoneType.Bone */) {
+                this._bone = this._parent;
+            }
+            else {
+                this._bone = this._parent._bone;
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    update(cacheFrameIndex) {
+        if (cacheFrameIndex >= 0 && this._cachedFrameIndices !== null) {
+            const cachedFrameIndex = this._cachedFrameIndices[cacheFrameIndex];
+            if (cachedFrameIndex >= 0 &&
+                this._cachedFrameIndex === cachedFrameIndex) {
+                // Same cache.
+                this._transformDirty = false;
+            }
+            else if (cachedFrameIndex >= 0) {
+                // Has been Cached.
+                this._transformDirty = true;
+                this._cachedFrameIndex = cachedFrameIndex;
+            }
+            else {
+                if (this._hasConstraint) {
+                    // Update constraints.
+                    for (const constraint of this._armature._constraints) {
+                        if (constraint._root === this) {
+                            constraint.update();
+                        }
+                    }
+                }
+                if (this._transformDirty ||
+                    (this._parent !== null && this._parent._childrenTransformDirty)) {
+                    // Dirty.
+                    this._transformDirty = true;
+                    this._cachedFrameIndex = -1;
+                }
+                else if (this._cachedFrameIndex >= 0) {
+                    // Same cache, but not set index yet.
+                    this._transformDirty = false;
+                    this._cachedFrameIndices[cacheFrameIndex] = this._cachedFrameIndex;
+                }
+                else {
+                    // Dirty.
+                    this._transformDirty = true;
+                    this._cachedFrameIndex = -1;
+                }
+            }
+        }
+        else {
+            if (this._hasConstraint) {
+                // Update constraints.
+                for (const constraint of this._armature._constraints) {
+                    if (constraint._root === this) {
+                        constraint.update();
+                    }
+                }
+            }
+            if (this._transformDirty ||
+                (this._parent !== null && this._parent._childrenTransformDirty)) {
+                // Dirty.
+                cacheFrameIndex = -1;
+                this._transformDirty = true;
+                this._cachedFrameIndex = -1;
+            }
+        }
+        if (this._transformDirty) {
+            this._transformDirty = false;
+            this._childrenTransformDirty = true;
+            //
+            for (let i = 0, l = this._matrixCahce.length; i < l; i += 7) {
+                this._matrixCahce[i] = -1.0;
+            }
+            //
+            this._updateVertices();
+            //
+            if (this._cachedFrameIndex < 0) {
+                const isCache = cacheFrameIndex >= 0;
+                if (this._localDirty) {
+                    this._updateGlobalTransformMatrix(isCache);
+                }
+                if (isCache && this._cachedFrameIndices !== null) {
+                    this._cachedFrameIndex = this._cachedFrameIndices[cacheFrameIndex] =
+                        this._armature._armatureData.setCacheFrame(this.globalTransformMatrix, this.global);
+                }
+            }
+            else {
+                this._armature._armatureData.getCacheFrame(this.globalTransformMatrix, this.global, this._cachedFrameIndex);
+            }
+            // Update hull vertices.
+            const lB = 1000.0;
+            const lA = 200.0;
+            const ddX = 2 * this.global.x;
+            const ddY = 2 * this.global.y;
+            //
+            const helpPoint = Surface._helpPoint;
+            this.globalTransformMatrix.transformPoint(lB, -lA, helpPoint);
+            this._hullCache[0] = helpPoint.x;
+            this._hullCache[1] = helpPoint.y;
+            this._hullCache[2] = ddX - helpPoint.x;
+            this._hullCache[3] = ddY - helpPoint.y;
+            this.globalTransformMatrix.transformPoint(0.0, this._dY, helpPoint, true);
+            this._hullCache[4] = helpPoint.x;
+            this._hullCache[5] = helpPoint.y;
+            //
+            this.globalTransformMatrix.transformPoint(lA, lB, helpPoint);
+            this._hullCache[6] = helpPoint.x;
+            this._hullCache[7] = helpPoint.y;
+            this._hullCache[8] = ddX - helpPoint.x;
+            this._hullCache[9] = ddY - helpPoint.y;
+            this.globalTransformMatrix.transformPoint(this._dX, 0.0, helpPoint, true);
+            this._hullCache[10] = helpPoint.x;
+            this._hullCache[11] = helpPoint.y;
+        }
+        else if (this._childrenTransformDirty) {
+            this._childrenTransformDirty = false;
+        }
+        this._localDirty = true;
+    }
+}

package/dist/dragonbones/dragonBones/armature/TransformObject.d.ts

@@ -0,0 +1,80 @@
+import { BaseObject } from "../core/BaseObject";
+import { Matrix } from "../geom/Matrix";
+import { Point } from "../geom/Point";
+import { Transform } from "../geom/Transform";
+import { Armature } from "./Armature";
+/**
+ * - The base class of the transform object.
+ * @see dragonBones.Transform
+ * @version DragonBones 4.5
+ * @language en_US
+ */
+export declare abstract class TransformObject extends BaseObject {
+    protected static readonly _helpMatrix: Matrix;
+    protected static readonly _helpTransform: Transform;
+    protected static readonly _helpPoint: Point;
+    /**
+     * - A matrix relative to the armature coordinate system.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    readonly globalTransformMatrix: Matrix;
+    /**
+     * - A transform relative to the armature coordinate system.
+     * @see #updateGlobalTransform()
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    readonly global: Transform;
+    /**
+     * - The offset transform relative to the armature or the parent bone coordinate system.
+     * @see #dragonBones.Bone#invalidUpdate()
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    readonly offset: Transform;
+    /**
+     * @private
+     */
+    origin: Transform | null;
+    /**
+     * @private
+     */
+    userData: any;
+    protected _globalDirty: boolean;
+    /**
+     * @internal
+     */
+    _alpha: number;
+    /**
+     * @internal
+     */
+    _globalAlpha: number;
+    /**
+     * @internal
+     */
+    _armature: Armature;
+    /**
+     */
+    protected _onClear(): void;
+    /**
+     * - For performance considerations, rotation or scale in the {@link #global} attribute of the bone or slot is not always properly accessible,
+     * some engines do not rely on these attributes to update rendering, such as Egret.
+     * The use of this method ensures that the access to the {@link #global} property is correctly rotation or scale.
+     * @example
+     * <pre>
+     *     bone.updateGlobalTransform();
+     *     let rotation = bone.global.rotation;
+     * </pre>
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    updateGlobalTransform(): void;
+    /**
+     * - The armature to which it belongs.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    get armature(): Armature;
+}
+//# sourceMappingURL=TransformObject.d.ts.map

package/dist/dragonbones/dragonBones/armature/TransformObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformObject.d.ts","sourceRoot":"","sources":["../../../../src/dragonbones/dragonBones/armature/TransformObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC;;;;;GAKG;AACH,8BAAsB,eAAgB,SAAQ,UAAU;IACtD,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAgB;IAC7D,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,EAAE,SAAS,CAAmB;IACtE,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAe;IAC1D;;;;OAIG;IACH,SAAgB,qBAAqB,EAAE,MAAM,CAAgB;IAC7D;;;;;OAKG;IACH,SAAgB,MAAM,EAAE,SAAS,CAAmB;IACpD;;;;;OAKG;IACH,SAAgB,MAAM,EAAE,SAAS,CAAmB;IACpD;;OAEG;IACI,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IAChC;;OAEG;IACI,QAAQ,EAAE,GAAG,CAAC;IACrB,SAAS,CAAC,YAAY,EAAE,OAAO,CAAC;IAChC;;OAEG;IACI,MAAM,EAAE,MAAM,CAAC;IACtB;;OAEG;IACI,YAAY,EAAE,MAAM,CAAC;IAC5B;;OAEG;IACI,SAAS,EAAE,QAAQ,CAAC;IAC3B;OACG;IACH,SAAS,CAAC,QAAQ,IAAI,IAAI;IAY1B;;;;;;;;;;;OAWG;IACI,qBAAqB,IAAI,IAAI;IAMpC;;;;OAIG;IACH,IAAW,QAAQ,IAAI,QAAQ,CAE9B;CACF"}

package/dist/dragonbones/dragonBones/armature/TransformObject.js

@@ -0,0 +1,77 @@
+import { BaseObject } from "../core/BaseObject";
+import { Matrix } from "../geom/Matrix";
+import { Point } from "../geom/Point";
+import { Transform } from "../geom/Transform";
+/**
+ * - The base class of the transform object.
+ * @see dragonBones.Transform
+ * @version DragonBones 4.5
+ * @language en_US
+ */
+export class TransformObject extends BaseObject {
+    constructor() {
+        super(...arguments);
+        /**
+         * - A matrix relative to the armature coordinate system.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        this.globalTransformMatrix = new Matrix();
+        /**
+         * - A transform relative to the armature coordinate system.
+         * @see #updateGlobalTransform()
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        this.global = new Transform();
+        /**
+         * - The offset transform relative to the armature or the parent bone coordinate system.
+         * @see #dragonBones.Bone#invalidUpdate()
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        this.offset = new Transform();
+    }
+    /**
+     */
+    _onClear() {
+        this.globalTransformMatrix.identity();
+        this.global.identity();
+        this.offset.identity();
+        this.origin = null;
+        this.userData = null;
+        this._globalDirty = false;
+        this._alpha = 1.0;
+        this._globalAlpha = 1.0;
+        this._armature = null; //
+    }
+    /**
+     * - For performance considerations, rotation or scale in the {@link #global} attribute of the bone or slot is not always properly accessible,
+     * some engines do not rely on these attributes to update rendering, such as Egret.
+     * The use of this method ensures that the access to the {@link #global} property is correctly rotation or scale.
+     * @example
+     * <pre>
+     *     bone.updateGlobalTransform();
+     *     let rotation = bone.global.rotation;
+     * </pre>
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    updateGlobalTransform() {
+        if (this._globalDirty) {
+            this._globalDirty = false;
+            this.global.fromMatrix(this.globalTransformMatrix);
+        }
+    }
+    /**
+     * - The armature to which it belongs.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    get armature() {
+        return this._armature;
+    }
+}
+TransformObject._helpMatrix = new Matrix();
+TransformObject._helpTransform = new Transform();
+TransformObject._helpPoint = new Point();