@esotericsoftware/spine-canvas 4.2.33 → 4.2.35

package/dist/iife/spine-canvas.js

@@ -8687,8 +8687,8 @@ var spine = (() => {
         data.strength = input.readFloat();
         data.damping = input.readFloat();
         data.massInverse = input.readFloat();
-        data.wind = input.readFloat();
-        data.gravity = input.readFloat();
+        data.wind = input.readFloat() * scale;
+        data.gravity = input.readFloat() * scale;
         data.mix = input.readFloat();
         flags = input.readByte();
         if ((flags & 1) != 0)
@@ -9389,10 +9389,10 @@ var spine = (() => {
               timelines.push(readTimeline1(input, new PhysicsConstraintMassTimeline(frameCount, bezierCount, index), 1));
               break;
             case PHYSICS_WIND:
-              timelines.push(readTimeline1(input, new PhysicsConstraintWindTimeline(frameCount, bezierCount, index), 1));
+              timelines.push(readTimeline1(input, new PhysicsConstraintWindTimeline(frameCount, bezierCount, index), scale));
               break;
             case PHYSICS_GRAVITY:
-              timelines.push(readTimeline1(input, new PhysicsConstraintGravityTimeline(frameCount, bezierCount, index), 1));
+              timelines.push(readTimeline1(input, new PhysicsConstraintGravityTimeline(frameCount, bezierCount, index), scale));
               break;
             case PHYSICS_MIX:
               timelines.push(readTimeline1(input, new PhysicsConstraintMixTimeline(frameCount, bezierCount, index), 1));
@@ -10572,6 +10572,40 @@ var spine = (() => {
           skeletonData.pathConstraints.push(data);
         }
       }
+      if (root.physics) {
+        for (let i = 0; i < root.physics.length; i++) {
+          const constraintMap = root.physics[i];
+          const data = new PhysicsConstraintData(constraintMap.name);
+          data.order = getValue(constraintMap, "order", 0);
+          data.skinRequired = getValue(constraintMap, "skin", false);
+          const boneName = constraintMap.bone;
+          const bone = skeletonData.findBone(boneName);
+          if (bone == null)
+            throw new Error("Physics bone not found: " + boneName);
+          data.bone = bone;
+          data.x = getValue(constraintMap, "x", 0);
+          data.y = getValue(constraintMap, "y", 0);
+          data.rotate = getValue(constraintMap, "rotate", 0);
+          data.scaleX = getValue(constraintMap, "scaleX", 0);
+          data.shearX = getValue(constraintMap, "shearX", 0);
+          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.mix = getValue(constraintMap, "mix", 1);
+          data.inertiaGlobal = getValue(constraintMap, "inertiaGlobal", false);
+          data.strengthGlobal = getValue(constraintMap, "strengthGlobal", false);
+          data.dampingGlobal = getValue(constraintMap, "dampingGlobal", false);
+          data.massGlobal = getValue(constraintMap, "massGlobal", false);
+          data.windGlobal = getValue(constraintMap, "windGlobal", false);
+          data.gravityGlobal = getValue(constraintMap, "gravityGlobal", false);
+          data.mixGlobal = getValue(constraintMap, "mixGlobal", false);
+          skeletonData.physicsConstraints.push(data);
+        }
+      }
       if (root.skins) {
         for (let i = 0; i < root.skins.length; i++) {
           let skinMap = root.skins[i];
@@ -10612,6 +10646,15 @@ var spine = (() => {
               skin.constraints.push(constraint);
             }
           }
+          if (skinMap.physics) {
+            for (let ii = 0; ii < skinMap.physics.length; ii++) {
+              let constraintName = skinMap.physics[ii];
+              let constraint = skeletonData.findPhysicsConstraint(constraintName);
+              if (!constraint)
+                throw new Error(`Couldn't find physics constraint ${constraintName} for skin ${skinMap.name}.`);
+              skin.constraints.push(constraint);
+            }
+          }
           for (let slotName in skinMap.attachments) {
             let slot = skeletonData.findSlot(slotName);
             if (!slot)
@@ -11143,6 +11186,53 @@ var spine = (() => {
           }
         }
       }
+      if (map.physics) {
+        for (let constraintName in map.physics) {
+          let constraintMap = map.physics[constraintName];
+          let constraintIndex = -1;
+          if (constraintName.length > 0) {
+            let constraint = skeletonData.findPhysicsConstraint(constraintName);
+            if (!constraint)
+              throw new Error("Physics constraint not found: " + constraintName);
+            constraintIndex = skeletonData.physicsConstraints.indexOf(constraint);
+          }
+          for (let timelineName in constraintMap) {
+            let timelineMap = constraintMap[timelineName];
+            let keyMap = timelineMap[0];
+            if (!keyMap)
+              continue;
+            let frames = timelineMap.length;
+            if (timelineName == "reset") {
+              const timeline2 = new PhysicsConstraintResetTimeline(timelineMap.size, constraintIndex);
+              for (let frame = 0; keyMap != null; keyMap = timelineMap[frame + 1], frame++)
+                timeline2.setFrame(frame, getValue(keyMap, "time", 0));
+              timelines.push(timeline2);
+              continue;
+            }
+            let timeline;
+            let timelineScale = 1;
+            if (timelineName == "inertia")
+              timeline = new PhysicsConstraintInertiaTimeline(frames, frames, constraintIndex);
+            else if (timelineName == "strength")
+              timeline = new PhysicsConstraintStrengthTimeline(frames, frames, constraintIndex);
+            else if (timelineName == "damping")
+              timeline = new PhysicsConstraintDampingTimeline(frames, frames, constraintIndex);
+            else if (timelineName == "mass")
+              timeline = new PhysicsConstraintMassTimeline(frames, frames, constraintIndex);
+            else if (timelineName == "wind") {
+              timeline = new PhysicsConstraintWindTimeline(frames, frames, constraintIndex);
+              timelineScale = scale;
+            } else if (timelineName == "gravity") {
+              timeline = new PhysicsConstraintGravityTimeline(frames, frames, constraintIndex);
+              timelineScale = scale;
+            } else if (timelineName == "mix")
+              timeline = new PhysicsConstraintMixTimeline(frames, frames, constraintIndex);
+            else
+              continue;
+            timelines.push(readTimeline12(timelineMap, timeline, 0, timelineScale));
+          }
+        }
+      }
       if (map.attachments) {
         for (let attachmentsName in map.attachments) {
           let attachmentsMap = map.attachments[attachmentsName];