@esotericsoftware/spine-canvas 4.3.10 → 4.3.11

package/dist/esm/spine-canvas.mjs

@@ -12841,6 +12841,151 @@ function getValue(map, property, defaultValue) {
   return map[property] !== void 0 ? map[property] : defaultValue;
 }
 
+// spine-core/src/SkeletonPhysicsMovement.ts
+var SkeletonPhysicsMovement = class {
+  /**
+   * Creates a movement tracker for a skeleton displayed by a host runtime object.
+   * @param skeleton The skeleton whose physics constraints receive inherited movement.
+   * @param adapter Runtime-specific hooks used to read and convert the host object's transform.
+   * @param options Initial movement inheritance values.
+   */
+  constructor(skeleton, adapter, options = {}) {
+    this.skeleton = skeleton;
+    this.adapter = adapter;
+    this.positionInheritanceFactorX = options.positionInheritanceX ?? 0;
+    this.positionInheritanceFactorY = options.positionInheritanceY ?? 0;
+    this.rotationInheritanceFactor = options.rotationInheritance ?? 0;
+  }
+  positionInheritanceFactorX = 0;
+  positionInheritanceFactorY = 0;
+  rotationInheritanceFactor = 0;
+  hasLastTransform = false;
+  lastX = 0;
+  lastY = 0;
+  lastZ = 0;
+  lastRotation = 0;
+  currentTransform = { x: 0, y: 0, z: 0, rotation: 0 };
+  currentPosition = { x: 0, y: 0, z: 0 };
+  lastPosition = { x: 0, y: 0, z: 0 };
+  /** Horizontal position inheritance factor. `0` disables horizontal position inheritance. */
+  get positionInheritanceX() {
+    return this.positionInheritanceFactorX;
+  }
+  /** Vertical position inheritance factor. `0` disables vertical position inheritance. */
+  get positionInheritanceY() {
+    return this.positionInheritanceFactorY;
+  }
+  /**
+   * Sets how much host object translation is inherited by skeleton physics constraints.
+   * Use `(1, 1)` for normal inheritance, or `(0, 0)` to disable position inheritance.
+   * @param x The horizontal position inheritance factor.
+   * @param y The vertical position inheritance factor.
+   */
+  setPositionInheritance(x, y) {
+    const wasDisabled = this.positionInheritanceFactorX === 0 && this.positionInheritanceFactorY === 0;
+    const isEnabled = x !== 0 || y !== 0;
+    this.positionInheritanceFactorX = x;
+    this.positionInheritanceFactorY = y;
+    if (wasDisabled && isEnabled) this.resetPosition();
+  }
+  /** Rotation inheritance factor. `0` disables rotation inheritance. */
+  get rotationInheritance() {
+    return this.rotationInheritanceFactor;
+  }
+  /**
+   * Sets how much host object rotation is inherited by skeleton physics constraints.
+   * @param value The rotation inheritance factor.
+   */
+  set rotationInheritance(value) {
+    const wasDisabled = this.rotationInheritanceFactor === 0;
+    this.rotationInheritanceFactor = value;
+    if (wasDisabled && value !== 0) this.resetRotation();
+  }
+  /** Resets the previous position used to calculate inherited translation. */
+  resetPosition() {
+    const transform = this.currentTransform;
+    const readRotation = !this.hasLastTransform && this.rotationInheritanceFactor !== 0;
+    this.adapter.readTransform(transform, readRotation);
+    this.lastX = transform.x;
+    this.lastY = transform.y;
+    this.lastZ = transform.z;
+    if (readRotation) this.lastRotation = transform.rotation;
+    this.hasLastTransform = true;
+  }
+  /** Resets the previous rotation used to calculate inherited rotation. */
+  resetRotation() {
+    const transform = this.currentTransform;
+    this.adapter.readTransform(transform, true);
+    this.lastRotation = transform.rotation;
+    if (!this.hasLastTransform) {
+      this.lastX = transform.x;
+      this.lastY = transform.y;
+      this.lastZ = transform.z;
+    }
+    this.hasLastTransform = true;
+  }
+  /** Resets both previous position and previous rotation. */
+  resetTransform() {
+    const transform = this.currentTransform;
+    this.adapter.readTransform(transform, true);
+    this.setLastTransform(transform.x, transform.y, transform.z, transform.rotation);
+  }
+  /**
+   * Applies host object transform movement since the previous call to the skeleton's physics constraints.
+   *
+   * The first call records the current transform as the baseline and does not apply movement.
+   */
+  applyTransformMovement() {
+    const inheritPosition = this.positionInheritanceFactorX !== 0 || this.positionInheritanceFactorY !== 0;
+    const inheritRotation = this.rotationInheritanceFactor !== 0;
+    if (!inheritPosition && !inheritRotation) return;
+    const transform = this.currentTransform;
+    this.adapter.readTransform(transform, inheritRotation);
+    const { x, y, z } = transform;
+    const currentRotation = inheritRotation ? transform.rotation : this.lastRotation;
+    const positionChanged = x !== this.lastX || y !== this.lastY || z !== this.lastZ;
+    if (this.hasLastTransform) {
+      if (!positionChanged && currentRotation === this.lastRotation) return;
+      if (inheritPosition && positionChanged) this.applyPositionMovement(x, y, z);
+      if (inheritRotation && currentRotation !== this.lastRotation) this.applyRotationMovement(currentRotation);
+    }
+    this.setLastTransform(x, y, z, currentRotation);
+  }
+  applyPositionMovement(currentX, currentY, currentZ) {
+    const currentPosition = this.currentPosition;
+    currentPosition.x = currentX;
+    currentPosition.y = currentY;
+    currentPosition.z = currentZ;
+    this.adapter.worldToSkeleton(currentPosition);
+    const lastPosition = this.lastPosition;
+    lastPosition.x = this.lastX;
+    lastPosition.y = this.lastY;
+    lastPosition.z = this.lastZ;
+    this.adapter.worldToSkeleton(lastPosition);
+    this.skeleton.physicsTranslate(
+      (currentPosition.x - lastPosition.x) * this.positionInheritanceFactorX,
+      (currentPosition.y - lastPosition.y) * this.positionInheritanceFactorY
+    );
+  }
+  applyRotationMovement(currentRotation) {
+    const rotationFactor = this.rotationInheritanceFactor;
+    if (rotationFactor === 0) return;
+    this.skeleton.physicsRotate(0, 0, this.getRotationDelta(currentRotation, this.lastRotation) * rotationFactor);
+  }
+  setLastTransform(x, y, z, rotation) {
+    this.lastX = x;
+    this.lastY = y;
+    this.lastZ = z;
+    this.lastRotation = rotation;
+    this.hasLastTransform = true;
+  }
+  getRotationDelta(current, previous) {
+    let delta = current - previous;
+    delta = (delta + 180) % 360 - 180;
+    return delta < -180 ? delta + 360 : delta;
+  }
+};
+
 // spine-core/src/SkeletonRendererCore.ts
 var SkeletonRendererCore = class {
   commandPool = new CommandPool();
@@ -13495,6 +13640,7 @@ export {
   SkeletonClipping,
   SkeletonData,
   SkeletonJson,
+  SkeletonPhysicsMovement,
   SkeletonRenderer,
   SkeletonRendererCore,
   Skin,