@galacean/effects-plugin-spine 1.4.4 → 1.4.5-alpha.0

package/dist/index.js

@@ -3,7 +3,7 @@
  * Description: Galacean Effects player spine plugin
  * Author: Ant Group CO., Ltd.
  * Contributors: 十弦
- * Version: v1.4.4
+ * Version: v1.4.5-alpha.0
  */
 
 'use strict';
@@ -272,6 +272,10 @@ var Color = /** @class */ (function () {
         color.g = ((value & 0x0000ff00) >>> 8) / 255;
         color.b = ((value & 0x000000ff)) / 255;
     };
+    Color.prototype.toRgb888 = function () {
+        var hex = function (x) { return ("0" + (x * 255).toString(16)).slice(-2); };
+        return Number("0x" + hex(this.r) + hex(this.g) + hex(this.b));
+    };
     Color.fromString = function (hex) {
         return new Color().setFromString(hex);
     };
@@ -868,27 +872,28 @@ var Property = {
     scaleY: 4,
     shearX: 5,
     shearY: 6,
-    rgb: 7,
-    alpha: 8,
-    rgb2: 9,
-    attachment: 10,
-    deform: 11,
-    event: 12,
-    drawOrder: 13,
-    ikConstraint: 14,
-    transformConstraint: 15,
-    pathConstraintPosition: 16,
-    pathConstraintSpacing: 17,
-    pathConstraintMix: 18,
-    physicsConstraintInertia: 19,
-    physicsConstraintStrength: 20,
-    physicsConstraintDamping: 21,
-    physicsConstraintMass: 22,
-    physicsConstraintWind: 23,
-    physicsConstraintGravity: 24,
-    physicsConstraintMix: 25,
-    physicsConstraintReset: 26,
-    sequence: 27,
+    inherit: 7,
+    rgb: 8,
+    alpha: 9,
+    rgb2: 10,
+    attachment: 11,
+    deform: 12,
+    event: 13,
+    drawOrder: 14,
+    ikConstraint: 15,
+    transformConstraint: 16,
+    pathConstraintPosition: 17,
+    pathConstraintSpacing: 18,
+    pathConstraintMix: 19,
+    physicsConstraintInertia: 20,
+    physicsConstraintStrength: 21,
+    physicsConstraintDamping: 22,
+    physicsConstraintMass: 23,
+    physicsConstraintWind: 24,
+    physicsConstraintGravity: 25,
+    physicsConstraintMix: 26,
+    physicsConstraintReset: 27,
+    sequence: 28,
 };
 /** The interface for all timelines. */
 var Timeline = /** @class */ (function () {
@@ -1402,7 +1407,7 @@ var ScaleYTimeline = /** @class */ (function (_super) {
     ScaleYTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) {
         var bone = skeleton.bones[this.boneIndex];
         if (bone.active)
-            bone.scaleY = this.getScaleValue(time, alpha, blend, direction, bone.scaleX, bone.data.scaleY);
+            bone.scaleY = this.getScaleValue(time, alpha, blend, direction, bone.scaleY, bone.data.scaleY);
     };
     return ScaleYTimeline;
 }(CurveTimeline1));
@@ -1497,10 +1502,43 @@ var ShearYTimeline = /** @class */ (function (_super) {
     ShearYTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) {
         var bone = skeleton.bones[this.boneIndex];
         if (bone.active)
-            bone.shearY = this.getRelativeValue(time, alpha, blend, bone.shearX, bone.data.shearY);
+            bone.shearY = this.getRelativeValue(time, alpha, blend, bone.shearY, bone.data.shearY);
     };
     return ShearYTimeline;
 }(CurveTimeline1));
+var InheritTimeline = /** @class */ (function (_super) {
+    __extends(InheritTimeline, _super);
+    function InheritTimeline(frameCount, boneIndex) {
+        var _this = _super.call(this, frameCount, [Property.inherit + "|" + boneIndex]) || this;
+        _this.boneIndex = 0;
+        _this.boneIndex = boneIndex;
+        return _this;
+    }
+    InheritTimeline.prototype.getFrameEntries = function () {
+        return 2 /*ENTRIES*/;
+    };
+    /** Sets the transform mode for the specified frame.
+     * @param frame Between 0 and <code>frameCount</code>, inclusive.
+     * @param time The frame time in seconds. */
+    InheritTimeline.prototype.setFrame = function (frame, time, inherit) {
+        frame *= 2 /*ENTRIES*/;
+        this.frames[frame] = time;
+        this.frames[frame + 1 /*INHERIT*/] = inherit;
+    };
+    InheritTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) {
+        var bone = skeleton.bones[this.boneIndex];
+        if (!bone.active)
+            return;
+        var frames = this.frames;
+        if (time < frames[0]) {
+            if (blend == exports.MixBlend.setup || blend == exports.MixBlend.first)
+                bone.inherit = bone.data.inherit;
+            return;
+        }
+        bone.inherit = this.frames[Timeline.search(frames, time, 2 /*ENTRIES*/) + 1 /*INHERIT*/];
+    };
+    return InheritTimeline;
+}(Timeline));
 /** Changes a slot's {@link Slot#color}. */
 var RGBATimeline = /** @class */ (function (_super) {
     __extends(RGBATimeline, _super);
@@ -2327,7 +2365,7 @@ var IkConstraintTimeline = /** @class */ (function (_super) {
         var _this = _super.call(this, frameCount, bezierCount, [
             Property.ikConstraint + "|" + ikConstraintIndex
         ]) || this;
-        /** The index of the IK constraint in {@link Skeleton#getIkConstraints()} that will be changed when this timeline is */
+        /** The index of the IK constraint in {@link Skeleton#getIkConstraints()} that will be changed when this timeline is applied */
         _this.constraintIndex = 0;
         _this.constraintIndex = ikConstraintIndex;
         return _this;
@@ -3386,8 +3424,14 @@ var AnimationState = /** @class */ (function () {
         }
         // Queue complete if completed a loop iteration or the animation.
         var complete = false;
-        if (entry.loop)
-            complete = duration == 0 || trackLastWrapped > entry.trackTime % duration;
+        if (entry.loop) {
+            if (duration == 0)
+                complete = true;
+            else {
+                var cycles = Math.floor(entry.trackTime / duration);
+                complete = cycles > 0 && cycles > Math.floor(entry.trackLast / duration);
+            }
+        }
         else
             complete = animationTime >= animationEnd && entry.animationLast < animationEnd;
         if (complete)
@@ -3874,13 +3918,16 @@ var TrackEntry = /** @class */ (function () {
         },
         set: function (mixDuration) {
             this._mixDuration = mixDuration;
-            if (this.previous != null && this.delay <= 0)
-                this.delay += this.previous.getTrackComplete() - mixDuration;
-            this.delay = this.delay;
         },
         enumerable: false,
         configurable: true
     });
+    TrackEntry.prototype.setMixDurationWithDelay = function (mixDuration, delay) {
+        this._mixDuration = mixDuration;
+        if (this.previous != null && delay <= 0)
+            delay += this.previous.getTrackComplete() - mixDuration;
+        this.delay = delay;
+    };
     TrackEntry.prototype.reset = function () {
         this.next = null;
         this.previous = null;
@@ -5134,7 +5181,7 @@ var BoneData = /** @class */ (function () {
         /** The local shearX. */
         this.shearY = 0;
         /** The transform mode for how parent world transforms affect this bone. */
-        this.transformMode = exports.TransformMode.Normal;
+        this.inherit = exports.Inherit.Normal;
         /** When true, {@link Skeleton#updateWorldTransform()} only updates this bone if the {@link Skeleton#skin} contains this
           * bone.
           * @see Skin#bones */
@@ -5155,14 +5202,14 @@ var BoneData = /** @class */ (function () {
     return BoneData;
 }());
 /** Determines how a bone inherits world transforms from parent bones. */
-exports.TransformMode = void 0;
-(function (TransformMode) {
-    TransformMode[TransformMode["Normal"] = 0] = "Normal";
-    TransformMode[TransformMode["OnlyTranslation"] = 1] = "OnlyTranslation";
-    TransformMode[TransformMode["NoRotationOrReflection"] = 2] = "NoRotationOrReflection";
-    TransformMode[TransformMode["NoScale"] = 3] = "NoScale";
-    TransformMode[TransformMode["NoScaleOrReflection"] = 4] = "NoScaleOrReflection";
-})(exports.TransformMode || (exports.TransformMode = {}));
+exports.Inherit = void 0;
+(function (Inherit) {
+    Inherit[Inherit["Normal"] = 0] = "Normal";
+    Inherit[Inherit["OnlyTranslation"] = 1] = "OnlyTranslation";
+    Inherit[Inherit["NoRotationOrReflection"] = 2] = "NoRotationOrReflection";
+    Inherit[Inherit["NoScale"] = 3] = "NoScale";
+    Inherit[Inherit["NoScaleOrReflection"] = 4] = "NoScaleOrReflection";
+})(exports.Inherit || (exports.Inherit = {}));
 
 /******************************************************************************
  * Spine Runtimes License Agreement
@@ -5244,6 +5291,7 @@ var Bone = /** @class */ (function () {
         this.worldY = 0;
         /** The world Y position. If changed, {@link #updateAppliedTransform()} should be called. */
         this.worldX = 0;
+        this.inherit = exports.Inherit.Normal;
         this.sorted = false;
         this.active = false;
         if (!data)
@@ -5300,8 +5348,8 @@ var Bone = /** @class */ (function () {
         var pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;
         this.worldX = pa * x + pb * y + parent.worldX;
         this.worldY = pc * x + pd * y + parent.worldY;
-        switch (this.data.transformMode) {
-            case exports.TransformMode.Normal: {
+        switch (this.inherit) {
+            case exports.Inherit.Normal: {
                 var rx = (rotation + shearX) * MathUtils.degRad;
                 var ry = (rotation + 90 + shearY) * MathUtils.degRad;
                 var la = Math.cos(rx) * scaleX;
@@ -5314,7 +5362,7 @@ var Bone = /** @class */ (function () {
                 this.d = pc * lb + pd * ld;
                 return;
             }
-            case exports.TransformMode.OnlyTranslation: {
+            case exports.Inherit.OnlyTranslation: {
                 var rx = (rotation + shearX) * MathUtils.degRad;
                 var ry = (rotation + 90 + shearY) * MathUtils.degRad;
                 this.a = Math.cos(rx) * scaleX;
@@ -5323,7 +5371,7 @@ var Bone = /** @class */ (function () {
                 this.d = Math.sin(ry) * scaleY;
                 break;
             }
-            case exports.TransformMode.NoRotationOrReflection: {
+            case exports.Inherit.NoRotationOrReflection: {
                 var s = pa * pa + pc * pc;
                 var prx = 0;
                 if (s > 0.0001) {
@@ -5351,8 +5399,8 @@ var Bone = /** @class */ (function () {
                 this.d = pc * lb + pd * ld;
                 break;
             }
-            case exports.TransformMode.NoScale:
-            case exports.TransformMode.NoScaleOrReflection: {
+            case exports.Inherit.NoScale:
+            case exports.Inherit.NoScaleOrReflection: {
                 rotation *= MathUtils.degRad;
                 var cos = Math.cos(rotation), sin = Math.sin(rotation);
                 var za = (pa * cos + pb * sin) / this.skeleton.scaleX;
@@ -5363,7 +5411,7 @@ var Bone = /** @class */ (function () {
                 za *= s;
                 zc *= s;
                 s = Math.sqrt(za * za + zc * zc);
-                if (this.data.transformMode == exports.TransformMode.NoScale
+                if (this.inherit == exports.Inherit.NoScale
                     && (pa * pd - pb * pc < 0) != (this.skeleton.scaleX < 0 != this.skeleton.scaleY < 0))
                     s = -s;
                 rotation = Math.PI / 2 + Math.atan2(zc, za);
@@ -5397,6 +5445,7 @@ var Bone = /** @class */ (function () {
         this.scaleY = data.scaleY;
         this.shearX = data.shearX;
         this.shearY = data.shearY;
+        this.inherit = data.inherit;
     };
     /** Computes the applied transform values from the world transform.
      *
@@ -5425,15 +5474,15 @@ var Bone = /** @class */ (function () {
         this.ax = (dx * ia - dy * ib);
         this.ay = (dy * id - dx * ic);
         var ra, rb, rc, rd;
-        if (this.data.transformMode == exports.TransformMode.OnlyTranslation) {
+        if (this.inherit == exports.Inherit.OnlyTranslation) {
             ra = this.a;
             rb = this.b;
             rc = this.c;
             rd = this.d;
         }
         else {
-            switch (this.data.transformMode) {
-                case exports.TransformMode.NoRotationOrReflection: {
+            switch (this.inherit) {
+                case exports.Inherit.NoRotationOrReflection: {
                     var s_1 = Math.abs(pa * pd - pb * pc) / (pa * pa + pc * pc);
                     var sa = pa / this.skeleton.scaleX;
                     var sc = pc / this.skeleton.scaleY;
@@ -5444,8 +5493,8 @@ var Bone = /** @class */ (function () {
                     ib = pb * pid;
                     break;
                 }
-                case exports.TransformMode.NoScale:
-                case exports.TransformMode.NoScaleOrReflection:
+                case exports.Inherit.NoScale:
+                case exports.Inherit.NoScaleOrReflection:
                     var cos = MathUtils.cosDeg(this.rotation), sin = MathUtils.sinDeg(this.rotation);
                     pa = (pa * cos + pb * sin) / this.skeleton.scaleX;
                     pc = (pc * cos + pd * sin) / this.skeleton.scaleY;
@@ -5455,7 +5504,7 @@ var Bone = /** @class */ (function () {
                     pa *= s;
                     pc *= s;
                     s = Math.sqrt(pa * pa + pc * pc);
-                    if (this.data.transformMode == exports.TransformMode.NoScale && pid < 0 != (this.skeleton.scaleX < 0 != this.skeleton.scaleY < 0))
+                    if (this.inherit == exports.Inherit.NoScale && pid < 0 != (this.skeleton.scaleX < 0 != this.skeleton.scaleY < 0))
                         s = -s;
                     var r = MathUtils.PI / 2 + Math.atan2(pc, pa);
                     pb = Math.cos(r) * s;
@@ -6065,11 +6114,6 @@ var IkConstraint = /** @class */ (function () {
         if (!skeleton)
             throw new Error("skeleton cannot be null.");
         this.data = data;
-        this.mix = data.mix;
-        this.softness = data.softness;
-        this.bendDirection = data.bendDirection;
-        this.compress = data.compress;
-        this.stretch = data.stretch;
         this.bones = new Array();
         for (var i = 0; i < data.bones.length; i++) {
             var bone = skeleton.findBone(data.bones[i].name);
@@ -6081,6 +6125,11 @@ var IkConstraint = /** @class */ (function () {
         if (!target)
             throw new Error("Couldn't find bone ".concat(data.target.name));
         this.target = target;
+        this.mix = data.mix;
+        this.softness = data.softness;
+        this.bendDirection = data.bendDirection;
+        this.compress = data.compress;
+        this.stretch = data.stretch;
     }
     IkConstraint.prototype.isActive = function () {
         return this.active;
@@ -6114,12 +6163,12 @@ var IkConstraint = /** @class */ (function () {
             throw new Error("IK bone must have parent.");
         var pa = p.a, pb = p.b, pc = p.c, pd = p.d;
         var rotationIK = -bone.ashearX - bone.arotation, tx = 0, ty = 0;
-        switch (bone.data.transformMode) {
-            case exports.TransformMode.OnlyTranslation:
+        switch (bone.inherit) {
+            case exports.Inherit.OnlyTranslation:
                 tx = (targetX - bone.worldX) * MathUtils.signum(bone.skeleton.scaleX);
                 ty = (targetY - bone.worldY) * MathUtils.signum(bone.skeleton.scaleY);
                 break;
-            case exports.TransformMode.NoRotationOrReflection:
+            case exports.Inherit.NoRotationOrReflection:
                 var s = Math.abs(pa * pd - pb * pc) / Math.max(0.0001, pa * pa + pc * pc);
                 var sa = pa / bone.skeleton.scaleX;
                 var sc = pc / bone.skeleton.scaleY;
@@ -6148,9 +6197,9 @@ var IkConstraint = /** @class */ (function () {
             rotationIK += 360;
         var sx = bone.ascaleX, sy = bone.ascaleY;
         if (compress || stretch) {
-            switch (bone.data.transformMode) {
-                case exports.TransformMode.NoScale:
-                case exports.TransformMode.NoScaleOrReflection:
+            switch (bone.inherit) {
+                case exports.Inherit.NoScale:
+                case exports.Inherit.NoScaleOrReflection:
                     tx = targetX - bone.worldX;
                     ty = targetY - bone.worldY;
             }
@@ -6170,6 +6219,8 @@ var IkConstraint = /** @class */ (function () {
     /** Applies 2 bone IK. The target is specified in the world coordinate system.
      * @param child A direct descendant of the parent bone. */
     IkConstraint.prototype.apply2 = function (parent, child, targetX, targetY, bendDir, stretch, uniform, softness, alpha) {
+        if (parent.inherit != exports.Inherit.Normal || child.inherit != exports.Inherit.Normal)
+            return;
         var px = parent.ax, py = parent.ay, psx = parent.ascaleX, psy = parent.ascaleY, sx = psx, sy = psy, csx = child.ascaleX;
         var os1 = 0, os2 = 0, s2 = 0;
         if (psx < 0) {
@@ -6339,7 +6390,7 @@ var IkConstraintData = /** @class */ (function (_super) {
         /** The bone that is the IK target. */
         _this._target = null;
         /** Controls the bend direction of the IK bones, either 1 or -1. */
-        _this.bendDirection = 1;
+        _this.bendDirection = 0;
         /** When true and only a single bone is being constrained, if the target is too close, the bone is scaled to reach it. */
         _this.compress = false;
         /** When true, if the target is out of range, the parent bone is scaled to reach it. If more than one bone is being constrained
@@ -6349,7 +6400,7 @@ var IkConstraintData = /** @class */ (function (_super) {
          * is scaled on both the X and Y axes. */
         _this.uniform = false;
         /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
-        _this.mix = 1;
+        _this.mix = 0;
         /** For two bone IK, the distance from the maximum reach of the bones that rotation will slow. */
         _this.softness = 0;
         return _this;
@@ -7038,7 +7089,8 @@ var PhysicsConstraint = /** @class */ (function () {
                 this.reset();
             // Fall through.
             case exports.Physics.update:
-                this.remaining += Math.max(this.skeleton.time - this.lastTime, 0);
+                var delta = Math.max(this.skeleton.time - this.lastTime, 0);
+                this.remaining += delta;
                 this.lastTime = this.skeleton.time;
                 var bx = bone.worldX, by = bone.worldY;
                 if (this._reset) {
@@ -7047,32 +7099,34 @@ var PhysicsConstraint = /** @class */ (function () {
                     this.uy = by;
                 }
                 else {
-                    var remaining = this.remaining, i = this.inertia, step = this.data.step;
+                    var a = this.remaining, i = this.inertia, q = this.data.limit * delta, t = this.data.step, f = this.skeleton.data.referenceScale, d = -1;
                     if (x || y) {
                         if (x) {
-                            this.xOffset += (this.ux - bx) * i;
+                            var u = (this.ux - bx) * i;
+                            this.xOffset += u > q ? q : u < -q ? -q : u;
                             this.ux = bx;
                         }
                         if (y) {
-                            this.yOffset += (this.uy - by) * i;
+                            var u = (this.uy - by) * i;
+                            this.yOffset += u > q ? q : u < -q ? -q : u;
                             this.uy = by;
                         }
-                        if (remaining >= step) {
-                            var m = this.massInverse * step, e = this.strength, w = this.wind * 100, g = this.gravity * -100;
-                            var d = Math.pow(this.damping, 60 * step);
+                        if (a >= t) {
+                            d = Math.pow(this.damping, 60 * t);
+                            var m = this.massInverse * t, e = this.strength, w = this.wind * f, g = (Skeleton.yDown ? -this.gravity : this.gravity) * f;
                             do {
                                 if (x) {
                                     this.xVelocity += (w - this.xOffset * e) * m;
-                                    this.xOffset += this.xVelocity * step;
+                                    this.xOffset += this.xVelocity * t;
                                     this.xVelocity *= d;
                                 }
                                 if (y) {
-                                    this.yVelocity += (g - this.yOffset * e) * m;
-                                    this.yOffset += this.yVelocity * step;
+                                    this.yVelocity -= (g + this.yOffset * e) * m;
+                                    this.yOffset += this.yVelocity * t;
                                     this.yVelocity *= d;
                                 }
-                                remaining -= step;
-                            } while (remaining >= step);
+                                a -= t;
+                            } while (a >= t);
                         }
                         if (x)
                             bone.worldX += this.xOffset * mix * this.data.x;
@@ -7081,9 +7135,18 @@ var PhysicsConstraint = /** @class */ (function () {
                     }
                     if (rotateOrShearX || scaleX) {
                         var ca = Math.atan2(bone.c, bone.a), c = 0, s = 0, mr = 0;
+                        var dx = this.cx - bone.worldX, dy = this.cy - bone.worldY;
+                        if (dx > q)
+                            dx = q;
+                        else if (dx < -q) //
+                            dx = -q;
+                        if (dy > q)
+                            dy = q;
+                        else if (dy < -q) //
+                            dy = -q;
                         if (rotateOrShearX) {
                             mr = (this.data.rotate + this.data.shearX) * mix;
-                            var dx = this.cx - bone.worldX, dy = this.cy - bone.worldY, r = Math.atan2(dy + this.ty, dx + this.tx) - ca - this.rotateOffset * mr;
+                            var r = Math.atan2(dy + this.ty, dx + this.tx) - ca - this.rotateOffset * mr;
                             this.rotateOffset += (r - Math.ceil(r * MathUtils.invPI2 - 0.5) * MathUtils.PI2) * i;
                             r = this.rotateOffset * mr + ca;
                             c = Math.cos(r);
@@ -7099,35 +7162,36 @@ var PhysicsConstraint = /** @class */ (function () {
                             s = Math.sin(ca);
                             var r = l * bone.getWorldScaleX();
                             if (r > 0)
-                                this.scaleOffset += ((this.cx - bone.worldX) * c + (this.cy - bone.worldY) * s) * i / r;
+                                this.scaleOffset += (dx * c + dy * s) * i / r;
                         }
-                        remaining = this.remaining;
-                        if (remaining >= step) {
-                            var m = this.massInverse * step, e = this.strength, w = this.wind, g = this.gravity;
-                            var d = Math.pow(this.damping, 60 * step);
+                        a = this.remaining;
+                        if (a >= t) {
+                            if (d == -1)
+                                d = Math.pow(this.damping, 60 * t);
+                            var m = this.massInverse * t, e = this.strength, w = this.wind, g = (Skeleton.yDown ? -this.gravity : this.gravity), h = l / f;
                             while (true) {
-                                remaining -= step;
+                                a -= t;
                                 if (scaleX) {
                                     this.scaleVelocity += (w * c - g * s - this.scaleOffset * e) * m;
-                                    this.scaleOffset += this.scaleVelocity * step;
+                                    this.scaleOffset += this.scaleVelocity * t;
                                     this.scaleVelocity *= d;
                                 }
                                 if (rotateOrShearX) {
-                                    this.rotateVelocity += (-0.01 * l * (w * s + g * c) - this.rotateOffset * e) * m;
-                                    this.rotateOffset += this.rotateVelocity * step;
+                                    this.rotateVelocity -= ((w * s + g * c) * h + this.rotateOffset * e) * m;
+                                    this.rotateOffset += this.rotateVelocity * t;
                                     this.rotateVelocity *= d;
-                                    if (remaining < step)
+                                    if (a < t)
                                         break;
                                     var r = this.rotateOffset * mr + ca;
                                     c = Math.cos(r);
                                     s = Math.sin(r);
                                 }
-                                else if (remaining < step) //
+                                else if (a < t) //
                                     break;
                             }
                         }
                     }
-                    this.remaining = remaining;
+                    this.remaining = a;
                 }
                 this.cx = bone.worldX;
                 this.cy = bone.worldY;
@@ -7180,6 +7244,21 @@ var PhysicsConstraint = /** @class */ (function () {
         }
         bone.updateAppliedTransform();
     };
+    /** Translates the physics constraint so next {@link #update(Physics)} forces are applied as if the bone moved an additional
+     * amount in world space. */
+    PhysicsConstraint.prototype.translate = function (x, y) {
+        this.ux -= x;
+        this.uy -= y;
+        this.cx -= x;
+        this.cy -= y;
+    };
+    /** Rotates the physics constraint so next {@link #update(Physics)} forces are applied as if the bone rotated around the
+     * specified point in world space. */
+    PhysicsConstraint.prototype.rotate = function (x, y, degrees) {
+        var r = degrees * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r);
+        var dx = this.cx - x, dy = this.cy - y;
+        this.translate(dx * cos - dy * sin - dx, dx * sin + dy * cos - dy);
+    };
     return PhysicsConstraint;
 }());
 
@@ -7322,12 +7401,6 @@ var TransformConstraint = /** @class */ (function () {
         if (!skeleton)
             throw new Error("skeleton cannot be null.");
         this.data = data;
-        this.mixRotate = data.mixRotate;
-        this.mixX = data.mixX;
-        this.mixY = data.mixY;
-        this.mixScaleX = data.mixScaleX;
-        this.mixScaleY = data.mixScaleY;
-        this.mixShearY = data.mixShearY;
         this.bones = new Array();
         for (var i = 0; i < data.bones.length; i++) {
             var bone = skeleton.findBone(data.bones[i].name);
@@ -7339,6 +7412,12 @@ var TransformConstraint = /** @class */ (function () {
         if (!target)
             throw new Error("Couldn't find target bone ".concat(data.target.name, "."));
         this.target = target;
+        this.mixRotate = data.mixRotate;
+        this.mixX = data.mixX;
+        this.mixY = data.mixY;
+        this.mixScaleX = data.mixScaleX;
+        this.mixScaleY = data.mixScaleY;
+        this.mixShearY = data.mixShearY;
     }
     TransformConstraint.prototype.isActive = function () {
         return this.active;
@@ -7491,11 +7570,8 @@ var TransformConstraint = /** @class */ (function () {
         for (var i = 0, n = bones.length; i < n; i++) {
             var bone = bones[i];
             var rotation = bone.arotation;
-            if (mixRotate != 0) {
-                var r = target.arotation - rotation + this.data.offsetRotation;
-                r -= Math.ceil(r / 360 - 0.5) * 360;
-                rotation += r * mixRotate;
-            }
+            if (mixRotate != 0)
+                rotation += (target.arotation - rotation + this.data.offsetRotation) * mixRotate;
             var x = bone.ax, y = bone.ay;
             x += (target.ax - x + this.data.offsetX) * mixX;
             y += (target.ay - y + this.data.offsetY) * mixY;
@@ -7505,11 +7581,8 @@ var TransformConstraint = /** @class */ (function () {
             if (mixScaleY != 0 && scaleY != 0)
                 scaleY = (scaleY + (target.ascaleY - scaleY + this.data.offsetScaleY) * mixScaleY) / scaleY;
             var shearY = bone.ashearY;
-            if (mixShearY != 0) {
-                var r = target.ashearY - shearY + this.data.offsetShearY;
-                r -= Math.ceil(r / 360 - 0.5) * 360;
-                shearY += r * mixShearY;
-            }
+            if (mixShearY != 0)
+                shearY += (target.ashearY - shearY + this.data.offsetShearY) * mixShearY;
             bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
         }
     };
@@ -7806,7 +7879,7 @@ var Skeleton = /** @class */ (function () {
      * See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
      * Runtimes Guide. */
     Skeleton.prototype.updateWorldTransform = function (physics) {
-        if (!physics)
+        if (physics === undefined || physics === null)
             throw new Error("physics is undefined");
         var bones = this.bones;
         for (var i = 0, n = bones.length; i < n; i++) {
@@ -8099,9 +8172,11 @@ var Skeleton = /** @class */ (function () {
     /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the current pose.
      * @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.
      * @param size An output value, the width and height of the AABB.
-     * @param temp Working memory to temporarily store attachments' computed world vertices. */
-    Skeleton.prototype.getBounds = function (offset, size, temp) {
+     * @param temp Working memory to temporarily store attachments' computed world vertices.
+     * @param clipper {@link SkeletonClipping} to use. If <code>null</code>, no clipping is applied. */
+    Skeleton.prototype.getBounds = function (offset, size, temp, clipper) {
         if (temp === void 0) { temp = new Array(2); }
+        if (clipper === void 0) { clipper = null; }
         if (!offset)
             throw new Error("offset cannot be null.");
         if (!size)
@@ -8114,19 +8189,31 @@ var Skeleton = /** @class */ (function () {
                 continue;
             var verticesLength = 0;
             var vertices = null;
+            var triangles = null;
             var attachment = slot.getAttachment();
             if (attachment instanceof RegionAttachment) {
                 verticesLength = 8;
                 vertices = Utils.setArraySize(temp, verticesLength, 0);
                 attachment.computeWorldVertices(slot, vertices, 0, 2);
+                triangles = Skeleton.quadTriangles;
             }
             else if (attachment instanceof MeshAttachment) {
                 var mesh = attachment;
                 verticesLength = mesh.worldVerticesLength;
                 vertices = Utils.setArraySize(temp, verticesLength, 0);
                 mesh.computeWorldVertices(slot, 0, verticesLength, vertices, 0, 2);
+                triangles = mesh.triangles;
+            }
+            else if (attachment instanceof ClippingAttachment && clipper != null) {
+                clipper.clipStart(slot, attachment);
+                continue;
             }
-            if (vertices) {
+            if (vertices && triangles) {
+                if (clipper != null && clipper.isClipping()) {
+                    clipper.clipTriangles(vertices, verticesLength, triangles, triangles.length);
+                    vertices = clipper.clippedVertices;
+                    verticesLength = clipper.clippedVertices.length;
+                }
                 for (var ii = 0, nn = vertices.length; ii < nn; ii += 2) {
                     var x = vertices[ii], y = vertices[ii + 1];
                     minX = Math.min(minX, x);
@@ -8135,7 +8222,11 @@ var Skeleton = /** @class */ (function () {
                     maxY = Math.max(maxY, y);
                 }
             }
+            if (clipper != null)
+                clipper.clipEndWithSlot(slot);
         }
+        if (clipper != null)
+            clipper.clipEnd();
         offset.set(minX, minY);
         size.set(maxX - minX, maxY - minY);
     };
@@ -8143,6 +8234,18 @@ var Skeleton = /** @class */ (function () {
     Skeleton.prototype.update = function (delta) {
         this.time += delta;
     };
+    Skeleton.prototype.physicsTranslate = function (x, y) {
+        var physicsConstraints = this.physicsConstraints;
+        for (var i = 0, n = physicsConstraints.length; i < n; i++)
+            physicsConstraints[i].translate(x, y);
+    };
+    /** Calls {@link PhysicsConstraint#rotate(float, float, float)} for each physics constraint. */
+    Skeleton.prototype.physicsRotate = function (x, y, degrees) {
+        var physicsConstraints = this.physicsConstraints;
+        for (var i = 0, n = physicsConstraints.length; i < n; i++)
+            physicsConstraints[i].rotate(x, y, degrees);
+    };
+    Skeleton.quadTriangles = [0, 1, 2, 2, 3, 0];
     Skeleton.yDown = false;
     return Skeleton;
 }());
@@ -8172,6 +8275,7 @@ var PhysicsConstraintData = /** @class */ (function (_super) {
         _this.rotate = 0;
         _this.scaleX = 0;
         _this.shearX = 0;
+        _this.limit = 0;
         _this.step = 0;
         _this.inertia = 0;
         _this.strength = 0;
@@ -8243,7 +8347,7 @@ var SkeletonData = /** @class */ (function () {
         this.name = null;
         /** The skeleton's bones, sorted parent first. The root bone is always the first bone. */
         this.bones = new Array(); // Ordered parents first.
-        /** The skeleton's slots. */
+        /** The skeleton's slots in the setup pose draw order. */
         this.slots = new Array(); // Setup pose draw order.
         this.skins = new Array();
         /** The skeleton's default skin. By default this skin contains all attachments that were not in a skin in Spine.
@@ -8271,6 +8375,9 @@ var SkeletonData = /** @class */ (function () {
         this.width = 0;
         /** The height of the skeleton's axis aligned bounding box in the setup pose. */
         this.height = 0;
+        /** Baseline scale factor for applying distance-dependent effects on non-scalable properties, such as angle or scale. Default
+         * is 100. */
+        this.referenceScale = 100;
         /** The Spine version used to export the skeleton data, or null. */
         this.version = null;
         /** The skeleton data hash. This value will change if any of the skeleton data has changed. May be null. */
@@ -8787,6 +8894,7 @@ var SkeletonBinary = /** @class */ (function () {
         skeletonData.y = input.readFloat();
         skeletonData.width = input.readFloat();
         skeletonData.height = input.readFloat();
+        skeletonData.referenceScale = input.readFloat() * scale;
         var nonessential = input.readBoolean();
         if (nonessential) {
             skeletonData.fps = input.readFloat();
@@ -8818,7 +8926,7 @@ var SkeletonBinary = /** @class */ (function () {
             data.shearX = input.readFloat();
             data.shearY = input.readFloat();
             data.length = input.readFloat() * scale;
-            data.transformMode = input.readInt(true);
+            data.inherit = input.readByte();
             data.skinRequired = input.readBoolean();
             if (nonessential) {
                 Color.rgba8888ToColor(data.color, input.readInt32());
@@ -8857,14 +8965,16 @@ var SkeletonBinary = /** @class */ (function () {
             for (var ii = 0; ii < nn; ii++)
                 data.bones.push(skeletonData.bones[input.readInt(true)]);
             data.target = skeletonData.bones[input.readInt(true)];
-            data.mix = input.readFloat();
-            data.softness = input.readFloat() * scale;
             var flags = input.readByte();
             data.skinRequired = (flags & 1) != 0;
             data.bendDirection = (flags & 2) != 0 ? 1 : -1;
             data.compress = (flags & 4) != 0;
             data.stretch = (flags & 8) != 0;
             data.uniform = (flags & 16) != 0;
+            if ((flags & 32) != 0)
+                data.mix = (flags & 64) != 0 ? input.readFloat() : 1;
+            if ((flags & 128) != 0)
+                data.softness = input.readFloat() * scale;
             skeletonData.ikConstraints.push(data);
         }
         // Transform constraints.
@@ -8883,18 +8993,31 @@ var SkeletonBinary = /** @class */ (function () {
             data.skinRequired = (flags & 1) != 0;
             data.local = (flags & 2) != 0;
             data.relative = (flags & 4) != 0;
-            data.offsetRotation = input.readFloat();
-            data.offsetX = input.readFloat() * scale;
-            data.offsetY = input.readFloat() * scale;
-            data.offsetScaleX = input.readFloat();
-            data.offsetScaleY = input.readFloat();
-            data.offsetShearY = input.readFloat();
-            data.mixRotate = input.readFloat();
-            data.mixX = input.readFloat();
-            data.mixY = input.readFloat();
-            data.mixScaleX = input.readFloat();
-            data.mixScaleY = input.readFloat();
-            data.mixShearY = input.readFloat();
+            if ((flags & 8) != 0)
+                data.offsetRotation = input.readFloat();
+            if ((flags & 16) != 0)
+                data.offsetX = input.readFloat() * scale;
+            if ((flags & 32) != 0)
+                data.offsetY = input.readFloat() * scale;
+            if ((flags & 64) != 0)
+                data.offsetScaleX = input.readFloat();
+            if ((flags & 128) != 0)
+                data.offsetScaleY = input.readFloat();
+            flags = input.readByte();
+            if ((flags & 1) != 0)
+                data.offsetShearY = input.readFloat();
+            if ((flags & 2) != 0)
+                data.mixRotate = input.readFloat();
+            if ((flags & 4) != 0)
+                data.mixX = input.readFloat();
+            if ((flags & 8) != 0)
+                data.mixY = input.readFloat();
+            if ((flags & 16) != 0)
+                data.mixScaleX = input.readFloat();
+            if ((flags & 32) != 0)
+                data.mixScaleY = input.readFloat();
+            if ((flags & 64) != 0)
+                data.mixShearY = input.readFloat();
             skeletonData.transformConstraints.push(data);
         }
         // Path constraints.
@@ -8910,10 +9033,12 @@ var SkeletonBinary = /** @class */ (function () {
             for (var ii = 0; ii < nn; ii++)
                 data.bones.push(skeletonData.bones[input.readInt(true)]);
             data.target = skeletonData.slots[input.readInt(true)];
-            data.positionMode = input.readInt(true);
-            data.spacingMode = input.readInt(true);
-            data.rotateMode = input.readInt(true);
-            data.offsetRotation = input.readFloat();
+            var flags = input.readByte();
+            data.positionMode = flags & 1;
+            data.spacingMode = (flags >> 1) & 3;
+            data.rotateMode = (flags >> 3) & 3;
+            if ((flags & 128) != 0)
+                data.offsetRotation = input.readFloat();
             data.position = input.readFloat();
             if (data.positionMode == exports.PositionMode.Fixed)
                 data.position *= scale;
@@ -8946,14 +9071,14 @@ var SkeletonBinary = /** @class */ (function () {
                 data.scaleX = input.readFloat();
             if ((flags & 32) != 0)
                 data.shearX = input.readFloat();
-            data.step = 1 / input.readByte();
+            data.limit = ((flags & 64) != 0 ? input.readFloat() : 5000) * scale;
+            data.step = 1 / input.readUnsignedByte();
             data.inertia = input.readFloat();
             data.strength = input.readFloat();
             data.damping = input.readFloat();
-            data.massInverse = input.readFloat();
-            data.wind = input.readFloat() * scale;
-            data.gravity = input.readFloat() * scale;
-            data.mix = input.readFloat();
+            data.massInverse = (flags & 128) != 0 ? input.readFloat() : 1;
+            data.wind = input.readFloat();
+            data.gravity = input.readFloat();
             flags = input.readByte();
             if ((flags & 1) != 0)
                 data.inertiaGlobal = true;
@@ -8969,6 +9094,7 @@ var SkeletonBinary = /** @class */ (function () {
                 data.gravityGlobal = true;
             if ((flags & 64) != 0)
                 data.mixGlobal = true;
+            data.mix = (flags & 128) != 0 ? input.readFloat() : 1;
             skeletonData.physicsConstraints.push(data);
         }
         // Default skin.
@@ -9084,7 +9210,7 @@ var SkeletonBinary = /** @class */ (function () {
                 var path = (flags & 16) != 0 ? input.readStringRef() : null;
                 var color = (flags & 32) != 0 ? input.readInt32() : 0xffffffff;
                 var sequence = (flags & 64) != 0 ? this.readSequence(input) : null;
-                var rotation = input.readFloat();
+                var rotation = (flags & 128) != 0 ? input.readFloat() : 0;
                 var x = input.readFloat();
                 var y = input.readFloat();
                 var scaleX = input.readFloat();
@@ -9243,8 +9369,6 @@ var SkeletonBinary = /** @class */ (function () {
         return null;
     };
     SkeletonBinary.prototype.readSequence = function (input) {
-        if (!input.readBoolean())
-            return null;
         var sequence = new Sequence(input.readInt(true));
         sequence.start = input.readInt(true);
         sequence.digits = input.readInt(true);
@@ -9501,7 +9625,16 @@ var SkeletonBinary = /** @class */ (function () {
         for (var i = 0, n = input.readInt(true); i < n; i++) {
             var boneIndex = input.readInt(true);
             for (var ii = 0, nn = input.readInt(true); ii < nn; ii++) {
-                var type = input.readByte(), frameCount = input.readInt(true), bezierCount = input.readInt(true);
+                var type = input.readByte(), frameCount = input.readInt(true);
+                if (type == BONE_INHERIT) {
+                    var timeline = new InheritTimeline(frameCount, boneIndex);
+                    for (var frame = 0; frame < frameCount; frame++) {
+                        timeline.setFrame(frame, input.readFloat(), input.readByte());
+                    }
+                    timelines.push(timeline);
+                    continue;
+                }
+                var bezierCount = input.readInt(true);
                 switch (type) {
                     case BONE_ROTATE:
                         timelines.push(readTimeline1$1(input, new RotateTimeline(frameCount, bezierCount, boneIndex), 1));
@@ -9539,20 +9672,22 @@ var SkeletonBinary = /** @class */ (function () {
         for (var i = 0, n = input.readInt(true); i < n; i++) {
             var index = input.readInt(true), frameCount = input.readInt(true), frameLast = frameCount - 1;
             var timeline = new IkConstraintTimeline(frameCount, input.readInt(true), index);
-            var time = input.readFloat(), mix = input.readFloat(), softness = input.readFloat() * scale;
+            var flags = input.readByte();
+            var time = input.readFloat(), mix = (flags & 1) != 0 ? ((flags & 2) != 0 ? input.readFloat() : 1) : 0;
+            var softness = (flags & 4) != 0 ? input.readFloat() * scale : 0;
             for (var frame = 0, bezier = 0;; frame++) {
-                var flags = input.readByte();
-                timeline.setFrame(frame, time, mix, softness, input.readByte(), (flags & 1) != 0, (flags & 2) != 0);
+                timeline.setFrame(frame, time, mix, softness, (flags & 8) != 0 ? 1 : -1, (flags & 16) != 0, (flags & 32) != 0);
                 if (frame == frameLast)
                     break;
-                var time2 = input.readFloat(), mix2 = input.readFloat(), softness2 = input.readFloat() * scale;
-                switch (input.readByte()) {
-                    case CURVE_STEPPED:
-                        timeline.setStepped(frame);
-                        break;
-                    case CURVE_BEZIER:
-                        setBezier(input, timeline, bezier++, frame, 0, time, time2, mix, mix2, 1);
-                        setBezier(input, timeline, bezier++, frame, 1, time, time2, softness, softness2, scale);
+                flags = input.readByte();
+                var time2 = input.readFloat(), mix2 = (flags & 1) != 0 ? ((flags & 2) != 0 ? input.readFloat() : 1) : 0;
+                var softness2 = (flags & 4) != 0 ? input.readFloat() * scale : 0;
+                if ((flags & 64) != 0) {
+                    timeline.setStepped(frame);
+                }
+                else if ((flags & 128) != 0) {
+                    setBezier(input, timeline, bezier++, frame, 0, time, time2, mix, mix2, 1);
+                    setBezier(input, timeline, bezier++, frame, 1, time, time2, softness, softness2, scale);
                 }
                 time = time2;
                 mix = mix2;
@@ -9660,10 +9795,10 @@ var SkeletonBinary = /** @class */ (function () {
                         timelines.push(readTimeline1$1(input, new PhysicsConstraintMassTimeline(frameCount, bezierCount, index), 1));
                         break;
                     case PHYSICS_WIND:
-                        timelines.push(readTimeline1$1(input, new PhysicsConstraintWindTimeline(frameCount, bezierCount, index), scale));
+                        timelines.push(readTimeline1$1(input, new PhysicsConstraintWindTimeline(frameCount, bezierCount, index), 1));
                         break;
                     case PHYSICS_GRAVITY:
-                        timelines.push(readTimeline1$1(input, new PhysicsConstraintGravityTimeline(frameCount, bezierCount, index), scale));
+                        timelines.push(readTimeline1$1(input, new PhysicsConstraintGravityTimeline(frameCount, bezierCount, index), 1));
                         break;
                     case PHYSICS_MIX:
                         timelines.push(readTimeline1$1(input, new PhysicsConstraintMixTimeline(frameCount, bezierCount, index), 1));
@@ -9977,6 +10112,7 @@ var BONE_SCALEY = 6;
 var BONE_SHEAR = 7;
 var BONE_SHEARX = 8;
 var BONE_SHEARY = 9;
+var BONE_INHERIT = 10;
 var SLOT_ATTACHMENT = 0;
 var SLOT_RGBA = 1;
 var SLOT_RGB = 2;
@@ -10535,6 +10671,73 @@ var SkeletonClipping = /** @class */ (function () {
         return this.clipAttachment != null;
     };
     SkeletonClipping.prototype.clipTriangles = function (vertices, verticesLength, triangles, trianglesLength, uvs, light, dark, twoColor) {
+        if (uvs && light && dark && typeof twoColor === 'boolean')
+            this.clipTrianglesRender(vertices, verticesLength, triangles, trianglesLength, uvs, light, dark, twoColor);
+        else
+            this.clipTrianglesNoRender(vertices, verticesLength, triangles, trianglesLength);
+    };
+    SkeletonClipping.prototype.clipTrianglesNoRender = function (vertices, verticesLength, triangles, trianglesLength) {
+        var clipOutput = this.clipOutput, clippedVertices = this.clippedVertices;
+        var clippedTriangles = this.clippedTriangles;
+        var polygons = this.clippingPolygons;
+        var polygonsCount = polygons.length;
+        var vertexSize = 2;
+        var index = 0;
+        clippedVertices.length = 0;
+        clippedTriangles.length = 0;
+        outer: for (var i = 0; i < trianglesLength; i += 3) {
+            var vertexOffset = triangles[i] << 1;
+            var x1 = vertices[vertexOffset], y1 = vertices[vertexOffset + 1];
+            vertexOffset = triangles[i + 1] << 1;
+            var x2 = vertices[vertexOffset], y2 = vertices[vertexOffset + 1];
+            vertexOffset = triangles[i + 2] << 1;
+            var x3 = vertices[vertexOffset], y3 = vertices[vertexOffset + 1];
+            for (var p = 0; p < polygonsCount; p++) {
+                var s = clippedVertices.length;
+                if (this.clip(x1, y1, x2, y2, x3, y3, polygons[p], clipOutput)) {
+                    var clipOutputLength = clipOutput.length;
+                    if (clipOutputLength == 0)
+                        continue;
+                    var clipOutputCount = clipOutputLength >> 1;
+                    var clipOutputItems = this.clipOutput;
+                    var clippedVerticesItems = Utils.setArraySize(clippedVertices, s + clipOutputCount * vertexSize);
+                    for (var ii = 0; ii < clipOutputLength; ii += 2) {
+                        var x = clipOutputItems[ii], y = clipOutputItems[ii + 1];
+                        clippedVerticesItems[s] = x;
+                        clippedVerticesItems[s + 1] = y;
+                        s += 2;
+                    }
+                    s = clippedTriangles.length;
+                    var clippedTrianglesItems = Utils.setArraySize(clippedTriangles, s + 3 * (clipOutputCount - 2));
+                    clipOutputCount--;
+                    for (var ii = 1; ii < clipOutputCount; ii++) {
+                        clippedTrianglesItems[s] = index;
+                        clippedTrianglesItems[s + 1] = (index + ii);
+                        clippedTrianglesItems[s + 2] = (index + ii + 1);
+                        s += 3;
+                    }
+                    index += clipOutputCount + 1;
+                }
+                else {
+                    var clippedVerticesItems = Utils.setArraySize(clippedVertices, s + 3 * vertexSize);
+                    clippedVerticesItems[s] = x1;
+                    clippedVerticesItems[s + 1] = y1;
+                    clippedVerticesItems[s + 2] = x2;
+                    clippedVerticesItems[s + 3] = y2;
+                    clippedVerticesItems[s + 4] = x3;
+                    clippedVerticesItems[s + 5] = y3;
+                    s = clippedTriangles.length;
+                    var clippedTrianglesItems = Utils.setArraySize(clippedTriangles, s + 3);
+                    clippedTrianglesItems[s] = index;
+                    clippedTrianglesItems[s + 1] = (index + 1);
+                    clippedTrianglesItems[s + 2] = (index + 2);
+                    index += 3;
+                    continue outer;
+                }
+            }
+        }
+    };
+    SkeletonClipping.prototype.clipTrianglesRender = function (vertices, verticesLength, triangles, trianglesLength, uvs, light, dark, twoColor) {
         var clipOutput = this.clipOutput, clippedVertices = this.clippedVertices;
         var clippedTriangles = this.clippedTriangles;
         var polygons = this.clippingPolygons;
@@ -10830,6 +11033,7 @@ var SkeletonJson = /** @class */ (function () {
         this.attachmentLoader = attachmentLoader;
     }
     SkeletonJson.prototype.readSkeletonData = function (json) {
+        var _a, _b;
         var scale = this.scale;
         var skeletonData = new SkeletonData();
         var root = typeof (json) === "string" ? JSON.parse(json) : json;
@@ -10842,8 +11046,10 @@ var SkeletonJson = /** @class */ (function () {
             skeletonData.y = skeletonMap.y;
             skeletonData.width = skeletonMap.width;
             skeletonData.height = skeletonMap.height;
+            skeletonData.referenceScale = getValue(skeletonMap, "referenceScale", 100) * scale;
             skeletonData.fps = skeletonMap.fps;
-            skeletonData.imagesPath = skeletonMap.images;
+            skeletonData.imagesPath = (_a = skeletonMap.images) !== null && _a !== void 0 ? _a : null;
+            skeletonData.audioPath = (_b = skeletonMap.audio) !== null && _b !== void 0 ? _b : null;
         }
         // Bones
         if (root.bones) {
@@ -10862,7 +11068,7 @@ var SkeletonJson = /** @class */ (function () {
                 data.scaleY = getValue(boneMap, "scaleY", 1);
                 data.shearX = getValue(boneMap, "shearX", 0);
                 data.shearY = getValue(boneMap, "shearY", 0);
-                data.transformMode = Utils.enumValue(exports.TransformMode, getValue(boneMap, "transform", "Normal"));
+                data.inherit = Utils.enumValue(exports.Inherit, getValue(boneMap, "inherit", "Normal"));
                 data.skinRequired = getValue(boneMap, "skin", false);
                 var color = getValue(boneMap, "color", null);
                 if (color)
@@ -10874,10 +11080,11 @@ var SkeletonJson = /** @class */ (function () {
         if (root.slots) {
             for (var i = 0; i < root.slots.length; i++) {
                 var slotMap = root.slots[i];
+                var slotName = slotMap.name;
                 var boneData = skeletonData.findBone(slotMap.bone);
                 if (!boneData)
-                    throw new Error("Couldn't find bone ".concat(slotMap.bone, " for slot ").concat(slotMap.name));
-                var data = new SlotData(skeletonData.slots.length, slotMap.name, boneData);
+                    throw new Error("Couldn't find bone ".concat(slotMap.bone, " for slot ").concat(slotName));
+                var data = new SlotData(skeletonData.slots.length, slotName, boneData);
                 var color = getValue(slotMap, "color", null);
                 if (color)
                     data.color.setFromString(color);
@@ -10886,6 +11093,7 @@ var SkeletonJson = /** @class */ (function () {
                     data.darkColor = Color.fromString(dark);
                 data.attachmentName = getValue(slotMap, "attachment", null);
                 data.blendMode = Utils.enumValue(exports.BlendMode, getValue(slotMap, "blend", "normal"));
+                data.visible = getValue(slotMap, "visible", true);
                 skeletonData.slots.push(data);
             }
         }
@@ -10986,8 +11194,8 @@ var SkeletonJson = /** @class */ (function () {
                 skeletonData.pathConstraints.push(data);
             }
         }
+        // Physics constraints.
         if (root.physics) {
-            // Physics constraints.
             for (var i = 0; i < root.physics.length; i++) {
                 var constraintMap = root.physics[i];
                 var data = new PhysicsConstraintData(constraintMap.name);
@@ -11003,13 +11211,14 @@ var SkeletonJson = /** @class */ (function () {
                 data.rotate = getValue(constraintMap, "rotate", 0);
                 data.scaleX = getValue(constraintMap, "scaleX", 0);
                 data.shearX = getValue(constraintMap, "shearX", 0);
+                data.limit = getValue(constraintMap, "limit", 5000) * scale;
                 data.step = 1 / getValue(constraintMap, "fps", 60);
                 data.inertia = getValue(constraintMap, "inertia", 1);
                 data.strength = getValue(constraintMap, "strength", 100);
                 data.damping = getValue(constraintMap, "damping", 1);
                 data.massInverse = 1 / getValue(constraintMap, "mass", 1);
-                data.wind = getValue(constraintMap, "wind", 0) * scale;
-                data.gravity = getValue(constraintMap, "gravity", 0) * scale;
+                data.wind = getValue(constraintMap, "wind", 0);
+                data.gravity = getValue(constraintMap, "gravity", 0);
                 data.mix = getValue(constraintMap, "mix", 1);
                 data.inertiaGlobal = getValue(constraintMap, "inertiaGlobal", false);
                 data.strengthGlobal = getValue(constraintMap, "strengthGlobal", false);
@@ -11475,6 +11684,14 @@ var SkeletonJson = /** @class */ (function () {
                         var timeline = new ShearYTimeline(frames_2, frames_2, boneIndex);
                         timelines.push(readTimeline1(timelineMap, timeline, 0, 1));
                     }
+                    else if (timelineName === "inherit") {
+                        var timeline = new InheritTimeline(frames_2, bone.index);
+                        for (var frame = 0; frame < timelineMap.length; frame++) {
+                            var aFrame = timelineMap[frame];
+                            timeline.setFrame(frame, getValue(aFrame, "time", 0), Utils.enumValue(exports.Inherit, getValue(aFrame, "inherit", "Normal")));
+                        }
+                        timelines.push(timeline);
+                    }
                 }
             }
         }
@@ -11644,14 +11861,13 @@ var SkeletonJson = /** @class */ (function () {
                         continue;
                     var frames_4 = timelineMap.length;
                     if (timelineName == "reset") {
-                        var timeline_1 = new PhysicsConstraintResetTimeline(timelineMap.size, constraintIndex);
+                        var timeline_1 = new PhysicsConstraintResetTimeline(frames_4, constraintIndex);
                         for (var frame = 0; keyMap != null; keyMap = timelineMap[frame + 1], frame++)
                             timeline_1.setFrame(frame, getValue(keyMap, "time", 0));
                         timelines.push(timeline_1);
                         continue;
                     }
                     var timeline = void 0;
-                    var timelineScale = 1;
                     if (timelineName == "inertia")
                         timeline = new PhysicsConstraintInertiaTimeline(frames_4, frames_4, constraintIndex);
                     else if (timelineName == "strength")
@@ -11660,19 +11876,15 @@ var SkeletonJson = /** @class */ (function () {
                         timeline = new PhysicsConstraintDampingTimeline(frames_4, frames_4, constraintIndex);
                     else if (timelineName == "mass")
                         timeline = new PhysicsConstraintMassTimeline(frames_4, frames_4, constraintIndex);
-                    else if (timelineName == "wind") {
+                    else if (timelineName == "wind")
                         timeline = new PhysicsConstraintWindTimeline(frames_4, frames_4, constraintIndex);
-                        timelineScale = scale;
-                    }
-                    else if (timelineName == "gravity") {
+                    else if (timelineName == "gravity")
                         timeline = new PhysicsConstraintGravityTimeline(frames_4, frames_4, constraintIndex);
-                        timelineScale = scale;
-                    }
                     else if (timelineName == "mix") //
                         timeline = new PhysicsConstraintMixTimeline(frames_4, frames_4, constraintIndex);
                     else
                         continue;
-                    timelines.push(readTimeline1(timelineMap, timeline, 0, timelineScale));
+                    timelines.push(readTimeline1(timelineMap, timeline, 0, 1));
                 }
             }
         }
@@ -12507,6 +12719,7 @@ var SpineVFXItem = /** @class */ (function (_super) {
         this.skeleton = new Skeleton(this.skeletonData);
         this.setSkin(spineOptions.activeSkin || (skinList.length ? skinList[0] : 'default'));
         this.state = new AnimationState(this.animationStateData);
+        this.resizeRule = spineOptions.resizeRule;
         if (activeAnimation.length === 1) {
             // 兼容旧JSON，根据时长计算速度
             if (isNaN(spineOptions.speed)) {
@@ -12789,12 +13002,20 @@ var SpineVFXItem = /** @class */ (function (_super) {
     // 将缩放比例设置到当前scale
     SpineVFXItem.prototype.resize = function () {
         var res = this.getBounds();
-        if (!res) {
+        if (!res || !this.composition) {
             return;
         }
-        var width = res.width;
         var scale = this.transform.scale;
-        var scaleFactor = 1 / width;
+        var width = res.width;
+        var scaleFactor;
+        if (this.resizeRule) {
+            var z = this.transform.getWorldPosition().z;
+            var rx = this.composition.camera.getInverseVPRatio(z).x;
+            scaleFactor = rx / 1500;
+        }
+        else {
+            scaleFactor = 1 / width;
+        }
         this.scaleFactor = scaleFactor;
         this.transform.setScale(this.startSize * scaleFactor, this.startSize * scaleFactor, scale.z);
     };
@@ -12966,7 +13187,7 @@ var SpineLoader = /** @class */ (function (_super) {
 }(effects.AbstractPlugin));
 
 effects.registerPlugin('spine', SpineLoader, SpineVFXItem);
-var version = "1.4.4";
+var version = "1.4.5-alpha.0";
 effects.logger.info('plugin spine version: ' + version);
 
 exports.AlphaTimeline = AlphaTimeline;
@@ -13005,6 +13226,7 @@ exports.HOLD_SUBSEQUENT = HOLD_SUBSEQUENT;
 exports.IkConstraint = IkConstraint;
 exports.IkConstraintData = IkConstraintData;
 exports.IkConstraintTimeline = IkConstraintTimeline;
+exports.InheritTimeline = InheritTimeline;
 exports.IntSet = IntSet;
 exports.Interpolation = Interpolation;
 exports.MathUtils = MathUtils;