@safe-engine/pixi 8.8.1 → 8.8.3

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

@@ -0,0 +1,123 @@
+import { OffsetMode } from "../core/DragonBones";
+import { Transform } from "../geom/Transform";
+import { BoneData } from "../model/ArmatureData";
+import { Armature } from "./Armature";
+import { TransformObject } from "./TransformObject";
+/**
+ * - Bone is one of the most important logical units in the armature animation system,
+ * and is responsible for the realization of translate, rotation, scaling in the animations.
+ * A armature can contain multiple bones.
+ * @see dragonBones.BoneData
+ * @see dragonBones.Armature
+ * @see dragonBones.Slot
+ * @version DragonBones 3.0
+ * @language en_US
+ */
+export declare class Bone extends TransformObject {
+    static toString(): string;
+    /**
+     * - The offset mode.
+     * @see #offset
+     * @version DragonBones 5.5
+     * @language en_US
+     */
+    offsetMode: OffsetMode;
+    /**
+     * @internal
+     */
+    readonly animationPose: Transform;
+    /**
+     * @internal
+     */
+    _transformDirty: boolean;
+    /**
+     * @internal
+     */
+    _childrenTransformDirty: boolean;
+    protected _localDirty: boolean;
+    /**
+     * @internal
+     */
+    _hasConstraint: boolean;
+    protected _visible: boolean;
+    protected _cachedFrameIndex: number;
+    /**
+     * @internal
+     */
+    _boneData: BoneData;
+    /**
+     * @private
+     */
+    protected _parent: Bone | null;
+    /**
+     * @internal
+     */
+    _cachedFrameIndices: Array<number> | null;
+    protected _onClear(): void;
+    protected _updateGlobalTransformMatrix(isCache: boolean): void;
+    /**
+     * @internal
+     */
+    _updateAlpha(): void;
+    /**
+     * @internal
+     */
+    init(boneData: BoneData, armatureValue: Armature): void;
+    /**
+     * @internal
+     */
+    update(cacheFrameIndex: number): void;
+    /**
+     * @internal
+     */
+    updateByConstraint(): void;
+    /**
+     * - Forces the bone to update the transform in the next frame.
+     * When the bone is not animated or its animation state is finished, the bone will not continue to update,
+     * and when the skeleton must be updated for some reason, the method needs to be called explicitly.
+     * @example
+     * <pre>
+     *     let bone = armature.getBone("arm");
+     *     bone.offset.scaleX = 2.0;
+     *     bone.invalidUpdate();
+     * </pre>
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    invalidUpdate(): void;
+    /**
+     * - Check whether the bone contains a specific bone.
+     * @see dragonBones.Bone
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    contains(value: Bone): boolean;
+    /**
+     * - The bone data.
+     * @version DragonBones 4.5
+     * @language en_US
+     */
+    get boneData(): BoneData;
+    /**
+     * - The visible of all slots in the bone.
+     * @default true
+     * @see dragonBones.Slot#visible
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    get visible(): boolean;
+    set visible(value: boolean);
+    /**
+     * - The bone name.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    get name(): string;
+    /**
+     * - The parent bone to which it belongs.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    get parent(): Bone | null;
+}
+//# sourceMappingURL=Bone.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Bone.d.ts","sourceRoot":"","sources":["../../../../src/dragonbones/dragonBones/armature/Bone.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAyB,MAAM,qBAAqB,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;GASG;AACH,qBAAa,IAAK,SAAQ,eAAe;WACzB,QAAQ,IAAI,MAAM;IAGhC;;;;;OAKG;IACI,UAAU,EAAE,UAAU,CAAC;IAC9B;;OAEG;IACH,SAAgB,aAAa,EAAE,SAAS,CAAmB;IAC3D;;OAEG;IACI,eAAe,EAAE,OAAO,CAAC;IAChC;;OAEG;IACI,uBAAuB,EAAE,OAAO,CAAC;IACxC,SAAS,CAAC,WAAW,EAAE,OAAO,CAAC;IAC/B;;OAEG;IACI,cAAc,EAAE,OAAO,CAAC;IAC/B,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC5B,SAAS,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACpC;;OAEG;IACI,SAAS,EAAE,QAAQ,CAAC;IAC3B;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,CAAC;IAC/B;;OAEG;IACI,mBAAmB,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IAEjD,SAAS,CAAC,QAAQ,IAAI,IAAI;IAiB1B,SAAS,CAAC,4BAA4B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAgN9D;;OAEG;IACI,YAAY;IAOnB;;OAEG;IACI,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,QAAQ,GAAG,IAAI;IAiB9D;;OAEG;IACI,MAAM,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI;IA4F5C;;OAEG;IACI,kBAAkB,IAAI,IAAI;IAcjC;;;;;;;;;;;;OAYG;IACI,aAAa,IAAI,IAAI;IAG5B;;;;;OAKG;IACI,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO;IAYrC;;;;OAIG;IACH,IAAW,QAAQ,IAAI,QAAQ,CAE9B;IACD;;;;;;OAMG;IACH,IAAW,OAAO,IAAI,OAAO,CAE5B;IACD,IAAW,OAAO,CAAC,KAAK,EAAE,OAAO,EAYhC;IACD;;;;OAIG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IACD;;;;OAIG;IACH,IAAW,MAAM,IAAI,IAAI,GAAG,IAAI,CAE/B;CACF"}

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

@@ -0,0 +1,438 @@
+import { DragonBones } from "../core/DragonBones";
+import { Transform } from "../geom/Transform";
+import { TransformObject } from "./TransformObject";
+/**
+ * - Bone is one of the most important logical units in the armature animation system,
+ * and is responsible for the realization of translate, rotation, scaling in the animations.
+ * A armature can contain multiple bones.
+ * @see dragonBones.BoneData
+ * @see dragonBones.Armature
+ * @see dragonBones.Slot
+ * @version DragonBones 3.0
+ * @language en_US
+ */
+export class Bone extends TransformObject {
+    constructor() {
+        super(...arguments);
+        /**
+         * @internal
+         */
+        this.animationPose = new Transform();
+    }
+    static toString() {
+        return "[class dragonBones.Bone]";
+    }
+    _onClear() {
+        super._onClear();
+        this.offsetMode = 1 /* OffsetMode.Additive */;
+        this.animationPose.identity();
+        this._transformDirty = false;
+        this._childrenTransformDirty = false;
+        this._localDirty = true;
+        this._hasConstraint = false;
+        this._visible = true;
+        this._cachedFrameIndex = -1;
+        this._boneData = null; //
+        this._parent = null; //
+        this._cachedFrameIndices = null;
+    }
+    _updateGlobalTransformMatrix(isCache) {
+        // For typescript.
+        const boneData = this._boneData;
+        const global = this.global;
+        const globalTransformMatrix = this.globalTransformMatrix;
+        const origin = this.origin;
+        const offset = this.offset;
+        const animationPose = this.animationPose;
+        const parent = this._parent; //
+        const flipX = this._armature.flipX;
+        const flipY = this._armature.flipY === DragonBones.yDown;
+        let inherit = parent !== null;
+        let rotation = 0.0;
+        if (this.offsetMode === 1 /* OffsetMode.Additive */) {
+            if (origin !== null) {
+                // global.copyFrom(this.origin).add(this.offset).add(this.animationPose);
+                global.x = origin.x + offset.x + animationPose.x;
+                global.scaleX = origin.scaleX * offset.scaleX * animationPose.scaleX;
+                global.scaleY = origin.scaleY * offset.scaleY * animationPose.scaleY;
+                if (DragonBones.yDown) {
+                    global.y = origin.y + offset.y + animationPose.y;
+                    global.skew = origin.skew + offset.skew + animationPose.skew;
+                    global.rotation =
+                        origin.rotation + offset.rotation + animationPose.rotation;
+                }
+                else {
+                    global.y = origin.y - offset.y + animationPose.y;
+                    global.skew = origin.skew - offset.skew + animationPose.skew;
+                    global.rotation =
+                        origin.rotation - offset.rotation + animationPose.rotation;
+                }
+            }
+            else {
+                global.copyFrom(offset);
+                if (!DragonBones.yDown) {
+                    global.y = -global.y;
+                    global.skew = -global.skew;
+                    global.rotation = -global.rotation;
+                }
+                global.add(animationPose);
+            }
+        }
+        else if (this.offsetMode === 0 /* OffsetMode.None */) {
+            if (origin !== null) {
+                global.copyFrom(origin).add(animationPose);
+            }
+            else {
+                global.copyFrom(animationPose);
+            }
+        }
+        else {
+            inherit = false;
+            global.copyFrom(offset);
+            if (!DragonBones.yDown) {
+                global.y = -global.y;
+                global.skew = -global.skew;
+                global.rotation = -global.rotation;
+            }
+        }
+        if (inherit) {
+            const isSurface = parent._boneData.type === 1 /* BoneType.Surface */;
+            const surfaceBone = isSurface ? parent._bone : null;
+            const parentMatrix = isSurface
+                ? parent._getGlobalTransformMatrix(global.x, global.y)
+                : parent.globalTransformMatrix;
+            if (boneData.inheritScale && (!isSurface || surfaceBone !== null)) {
+                if (isSurface) {
+                    if (boneData.inheritRotation) {
+                        global.rotation += parent.global.rotation;
+                    }
+                    surfaceBone.updateGlobalTransform();
+                    global.scaleX *= surfaceBone.global.scaleX;
+                    global.scaleY *= surfaceBone.global.scaleY;
+                    parentMatrix.transformPoint(global.x, global.y, global);
+                    global.toMatrix(globalTransformMatrix);
+                    if (boneData.inheritTranslation) {
+                        global.x = globalTransformMatrix.tx;
+                        global.y = globalTransformMatrix.ty;
+                    }
+                    else {
+                        globalTransformMatrix.tx = global.x;
+                        globalTransformMatrix.ty = global.y;
+                    }
+                }
+                else {
+                    if (!boneData.inheritRotation) {
+                        parent.updateGlobalTransform();
+                        if (flipX && flipY) {
+                            rotation = global.rotation - (parent.global.rotation + Math.PI);
+                        }
+                        else if (flipX) {
+                            rotation = global.rotation + parent.global.rotation + Math.PI;
+                        }
+                        else if (flipY) {
+                            rotation = global.rotation + parent.global.rotation;
+                        }
+                        else {
+                            rotation = global.rotation - parent.global.rotation;
+                        }
+                        global.rotation = rotation;
+                    }
+                    global.toMatrix(globalTransformMatrix);
+                    globalTransformMatrix.concat(parentMatrix);
+                    if (boneData.inheritTranslation) {
+                        global.x = globalTransformMatrix.tx;
+                        global.y = globalTransformMatrix.ty;
+                    }
+                    else {
+                        globalTransformMatrix.tx = global.x;
+                        globalTransformMatrix.ty = global.y;
+                    }
+                    if (isCache) {
+                        global.fromMatrix(globalTransformMatrix);
+                    }
+                    else {
+                        this._globalDirty = true;
+                    }
+                }
+            }
+            else {
+                if (boneData.inheritTranslation) {
+                    const x = global.x;
+                    const y = global.y;
+                    global.x = parentMatrix.a * x + parentMatrix.c * y + parentMatrix.tx;
+                    global.y = parentMatrix.b * x + parentMatrix.d * y + parentMatrix.ty;
+                }
+                else {
+                    if (flipX) {
+                        global.x = -global.x;
+                    }
+                    if (flipY) {
+                        global.y = -global.y;
+                    }
+                }
+                if (boneData.inheritRotation) {
+                    parent.updateGlobalTransform();
+                    if (parent.global.scaleX < 0.0) {
+                        rotation = global.rotation + parent.global.rotation + Math.PI;
+                    }
+                    else {
+                        rotation = global.rotation + parent.global.rotation;
+                    }
+                    if (parentMatrix.a * parentMatrix.d - parentMatrix.b * parentMatrix.c <
+                        0.0) {
+                        rotation -= global.rotation * 2.0;
+                        if (flipX !== flipY || boneData.inheritReflection) {
+                            global.skew += Math.PI;
+                        }
+                        if (!DragonBones.yDown) {
+                            global.skew = -global.skew;
+                        }
+                    }
+                    global.rotation = rotation;
+                }
+                else if (flipX || flipY) {
+                    if (flipX && flipY) {
+                        rotation = global.rotation + Math.PI;
+                    }
+                    else {
+                        if (flipX) {
+                            rotation = Math.PI - global.rotation;
+                        }
+                        else {
+                            rotation = -global.rotation;
+                        }
+                        global.skew += Math.PI;
+                    }
+                    global.rotation = rotation;
+                }
+                global.toMatrix(globalTransformMatrix);
+            }
+        }
+        else {
+            if (flipX || flipY) {
+                if (flipX) {
+                    global.x = -global.x;
+                }
+                if (flipY) {
+                    global.y = -global.y;
+                }
+                if (flipX && flipY) {
+                    rotation = global.rotation + Math.PI;
+                }
+                else {
+                    if (flipX) {
+                        rotation = Math.PI - global.rotation;
+                    }
+                    else {
+                        rotation = -global.rotation;
+                    }
+                    global.skew += Math.PI;
+                }
+                global.rotation = rotation;
+            }
+            global.toMatrix(globalTransformMatrix);
+        }
+    }
+    /**
+     * @internal
+     */
+    _updateAlpha() {
+        if (this._parent !== null) {
+            this._globalAlpha = this._alpha * this._parent._globalAlpha;
+        }
+        else {
+            this._globalAlpha = this._alpha * this._armature._globalAlpha;
+        }
+    }
+    /**
+     * @internal
+     */
+    init(boneData, armatureValue) {
+        if (this._boneData !== null) {
+            return;
+        }
+        this._boneData = boneData;
+        this._armature = armatureValue;
+        this._alpha = this._boneData.alpha;
+        if (this._boneData.parent !== null) {
+            this._parent = this._armature.getBone(this._boneData.parent.name);
+        }
+        this._armature._addBone(this);
+        //
+        this.origin = this._boneData.transform;
+    }
+    /**
+     * @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;
+            //
+            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);
+            }
+            //
+        }
+        else if (this._childrenTransformDirty) {
+            this._childrenTransformDirty = false;
+        }
+        this._localDirty = true;
+    }
+    /**
+     * @internal
+     */
+    updateByConstraint() {
+        if (this._localDirty) {
+            this._localDirty = false;
+            if (this._transformDirty ||
+                (this._parent !== null && this._parent._childrenTransformDirty)) {
+                this._updateGlobalTransformMatrix(true);
+            }
+            this._transformDirty = true;
+        }
+    }
+    /**
+     * - Forces the bone to update the transform in the next frame.
+     * When the bone is not animated or its animation state is finished, the bone will not continue to update,
+     * and when the skeleton must be updated for some reason, the method needs to be called explicitly.
+     * @example
+     * <pre>
+     *     let bone = armature.getBone("arm");
+     *     bone.offset.scaleX = 2.0;
+     *     bone.invalidUpdate();
+     * </pre>
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    invalidUpdate() {
+        this._transformDirty = true;
+    }
+    /**
+     * - Check whether the bone contains a specific bone.
+     * @see dragonBones.Bone
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    contains(value) {
+        if (value === this) {
+            return false;
+        }
+        let ancestor = value;
+        while (ancestor !== this && ancestor !== null) {
+            ancestor = ancestor.parent;
+        }
+        return ancestor === this;
+    }
+    /**
+     * - The bone data.
+     * @version DragonBones 4.5
+     * @language en_US
+     */
+    get boneData() {
+        return this._boneData;
+    }
+    /**
+     * - The visible of all slots in the bone.
+     * @default true
+     * @see dragonBones.Slot#visible
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    get visible() {
+        return this._visible;
+    }
+    set visible(value) {
+        if (this._visible === value) {
+            return;
+        }
+        this._visible = value;
+        for (const slot of this._armature.getSlots()) {
+            if (slot.parent === this) {
+                slot._updateVisible();
+            }
+        }
+    }
+    /**
+     * - The bone name.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    get name() {
+        return this._boneData.name;
+    }
+    /**
+     * - The parent bone to which it belongs.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    get parent() {
+        return this._parent;
+    }
+}

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

@@ -0,0 +1,99 @@
+import { BaseObject } from "../core/BaseObject";
+import { Matrix } from "../geom/Matrix";
+import { Point } from "../geom/Point";
+import { Transform } from "../geom/Transform";
+import { ConstraintData } from "../model/ConstraintData";
+import { GeometryData, PathDisplayData } from "../model/DisplayData";
+import { Armature } from "./Armature";
+import { Bone } from "./Bone";
+/**
+ * - The base class of the constraint.
+ * A constraint is used to control the movement of a bone or a slot.
+ * @internal
+ */
+export declare abstract class Constraint extends BaseObject {
+    protected static readonly _helpMatrix: Matrix;
+    protected static readonly _helpTransform: Transform;
+    protected static readonly _helpPoint: Point;
+    /**
+     * - For timeline state.
+     * @internal
+     */
+    _constraintData: ConstraintData;
+    protected _armature: Armature;
+    /**
+     * - For sort bones.
+     * @internal
+     */
+    _target: Bone;
+    /**
+     * - For sort bones.
+     * @internal
+     */
+    _root: Bone;
+    protected _bone: Bone | null;
+    protected _onClear(): void;
+    abstract init(constraintData: ConstraintData, armature: Armature): void;
+    abstract update(): void;
+    abstract invalidUpdate(): void;
+    get name(): string;
+}
+/**
+ * - The inverse kinematics constraint.
+ * @internal
+ */
+export declare class IKConstraint extends Constraint {
+    static toString(): string;
+    private _scaleEnabled;
+    /**
+     * - For timeline state.
+     * @internal
+     */
+    _bendPositive: boolean;
+    /**
+     * - For timeline state.
+     * @internal
+     */
+    _weight: number;
+    protected _onClear(): void;
+    private _computeA;
+    private _computeB;
+    init(constraintData: ConstraintData, armature: Armature): void;
+    /**
+     * - Update the constraint.
+     */
+    update(): void;
+    invalidUpdate(): void;
+}
+/**
+ * - The path constraint.
+ * The path constraint is used to control the movement of a bone or a slot along a path.
+ * @internal
+ */
+export declare class PathConstraint extends Constraint {
+    dirty: boolean;
+    pathOffset: number;
+    position: number;
+    spacing: number;
+    rotateOffset: number;
+    rotateMix: number;
+    translateMix: number;
+    private _pathSlot;
+    private _bones;
+    private _spaces;
+    private _positions;
+    private _curves;
+    private _boneLengths;
+    private _pathGlobalVertices;
+    private _segments;
+    static toString(): string;
+    protected _onClear(): void;
+    protected _updatePathVertices(verticesData: GeometryData): void;
+    protected _computeVertices(start: number, count: number, offset: number, out: Array<number>): void;
+    protected _computeBezierCurve(pathDisplayDta: PathDisplayData, spaceCount: number, tangents: boolean, percentPosition: boolean, percentSpacing: boolean): void;
+    private addCurvePosition;
+    init(constraintData: ConstraintData, armature: Armature): void;
+    update(): void;
+    invalidUpdate(): void;
+}
+//# sourceMappingURL=Constraint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Constraint.d.ts","sourceRoot":"","sources":["../../../../src/dragonbones/dragonBones/armature/Constraint.ts"],"names":[],"mappings":"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"}