@downdraft/engine 0.0.0 → 0.1.0

package/core/src/physics/ragdoll-presets.ts

@@ -0,0 +1,272 @@
+import type { Skeleton } from "../animation";
+import type { RagdollBoneConfig, RagdollConfig, RagdollJointConfig } from "./ragdoll";
+
+interface BoneMatch {
+  names: string[];
+  shape: "capsule" | "sphere" | "box";
+  radius: number;
+  halfHeight: number;
+  halfExtents: [number, number, number];
+  offset: [number, number, number];
+  mass: number;
+  linearDamping: number;
+  angularDamping: number;
+}
+
+const BONE_MATCHES: BoneMatch[] = [
+  {
+    names: ["Hips", "pelvis", "mixamorig:Hips", "Pelvis"],
+    shape: "box",
+    radius: 0,
+    halfHeight: 0,
+    halfExtents: [0.18, 0.12, 0.12],
+    offset: [0, 0, 0],
+    mass: 8,
+    linearDamping: 0.5,
+    angularDamping: 0.5,
+  },
+  {
+    names: ["Spine", "spine_01", "mixamorig:Spine", "Spine_01"],
+    shape: "box",
+    radius: 0,
+    halfHeight: 0,
+    halfExtents: [0.16, 0.12, 0.10],
+    offset: [0, 0.12, 0],
+    mass: 6,
+    linearDamping: 0.5,
+    angularDamping: 0.5,
+  },
+  {
+    names: ["Head", "head", "mixamorig:Head"],
+    shape: "sphere",
+    radius: 0.12,
+    halfHeight: 0,
+    halfExtents: [0, 0, 0],
+    offset: [0, 0.1, 0],
+    mass: 3,
+    linearDamping: 0.3,
+    angularDamping: 0.3,
+  },
+  {
+    names: ["UpperArm_Left", "upperarm_l", "mixamorig:LeftArm", "ArmUp_Left"],
+    shape: "capsule",
+    radius: 0.06,
+    halfHeight: 0.12,
+    halfExtents: [0, 0, 0],
+    offset: [0, -0.12, 0],
+    mass: 2,
+    linearDamping: 0.3,
+    angularDamping: 0.3,
+  },
+  {
+    names: ["UpperArm_Right", "upperarm_r", "mixamorig:RightArm", "ArmUp_Right"],
+    shape: "capsule",
+    radius: 0.06,
+    halfHeight: 0.12,
+    halfExtents: [0, 0, 0],
+    offset: [0, -0.12, 0],
+    mass: 2,
+    linearDamping: 0.3,
+    angularDamping: 0.3,
+  },
+  {
+    names: ["LowerArm_Left", "lowerarm_l", "mixamorig:LeftForeArm", "ArmDown_Left"],
+    shape: "capsule",
+    radius: 0.05,
+    halfHeight: 0.12,
+    halfExtents: [0, 0, 0],
+    offset: [0, -0.12, 0],
+    mass: 1.5,
+    linearDamping: 0.3,
+    angularDamping: 0.3,
+  },
+  {
+    names: ["LowerArm_Right", "lowerarm_r", "mixamorig:RightForeArm", "ArmDown_Right"],
+    shape: "capsule",
+    radius: 0.05,
+    halfHeight: 0.12,
+    halfExtents: [0, 0, 0],
+    offset: [0, -0.12, 0],
+    mass: 1.5,
+    linearDamping: 0.3,
+    angularDamping: 0.3,
+  },
+  {
+    names: ["UpperLeg_Left", "thigh_l", "mixamorig:LeftUpLeg", "LegUp_Left"],
+    shape: "capsule",
+    radius: 0.08,
+    halfHeight: 0.22,
+    halfExtents: [0, 0, 0],
+    offset: [0, -0.22, 0],
+    mass: 4,
+    linearDamping: 0.3,
+    angularDamping: 0.3,
+  },
+  {
+    names: ["UpperLeg_Right", "thigh_r", "mixamorig:RightUpLeg", "LegUp_Right"],
+    shape: "capsule",
+    radius: 0.08,
+    halfHeight: 0.22,
+    halfExtents: [0, 0, 0],
+    offset: [0, -0.22, 0],
+    mass: 4,
+    linearDamping: 0.3,
+    angularDamping: 0.3,
+  },
+  {
+    names: ["LowerLeg_Left", "calf_l", "mixamorig:LeftLeg", "LegDown_Left"],
+    shape: "capsule",
+    radius: 0.06,
+    halfHeight: 0.22,
+    halfExtents: [0, 0, 0],
+    offset: [0, -0.22, 0],
+    mass: 3,
+    linearDamping: 0.3,
+    angularDamping: 0.3,
+  },
+  {
+    names: ["LowerLeg_Right", "calf_r", "mixamorig:RightLeg", "LegDown_Right"],
+    shape: "capsule",
+    radius: 0.06,
+    halfHeight: 0.22,
+    halfExtents: [0, 0, 0],
+    offset: [0, -0.22, 0],
+    mass: 3,
+    linearDamping: 0.3,
+    angularDamping: 0.3,
+  },
+];
+
+interface JointMatch {
+  parent: string[];
+  child: string[];
+  anchor: [number, number, number];
+  coneAngle: number;
+  twistAngle: number;
+}
+
+const JOINT_MATCHES: JointMatch[] = [
+  {
+    parent: ["Hips", "pelvis", "mixamorig:Hips", "Pelvis"],
+    child: ["Spine", "spine_01", "mixamorig:Spine", "Spine_01"],
+    anchor: [0, 0.12, 0],
+    coneAngle: Math.PI / 6,
+    twistAngle: Math.PI / 8,
+  },
+  {
+    parent: ["Spine", "spine_01", "mixamorig:Spine", "Spine_01"],
+    child: ["Head", "head", "mixamorig:Head"],
+    anchor: [0, 0.1, 0],
+    coneAngle: Math.PI / 4,
+    twistAngle: Math.PI / 6,
+  },
+  {
+    parent: ["Spine", "spine_01", "mixamorig:Spine", "Spine_01"],
+    child: ["UpperArm_Left", "upperarm_l", "mixamorig:LeftArm", "ArmUp_Left"],
+    anchor: [0.18, 0.05, 0],
+    coneAngle: Math.PI / 2,
+    twistAngle: Math.PI / 4,
+  },
+  {
+    parent: ["Spine", "spine_01", "mixamorig:Spine", "Spine_01"],
+    child: ["UpperArm_Right", "upperarm_r", "mixamorig:RightArm", "ArmUp_Right"],
+    anchor: [-0.18, 0.05, 0],
+    coneAngle: Math.PI / 2,
+    twistAngle: Math.PI / 4,
+  },
+  {
+    parent: ["UpperArm_Left", "upperarm_l", "mixamorig:LeftArm", "ArmUp_Left"],
+    child: ["LowerArm_Left", "lowerarm_l", "mixamorig:LeftForeArm", "ArmDown_Left"],
+    anchor: [0, -0.12, 0],
+    coneAngle: Math.PI / 2,
+    twistAngle: 0,
+  },
+  {
+    parent: ["UpperArm_Right", "upperarm_r", "mixamorig:RightArm", "ArmUp_Right"],
+    child: ["LowerArm_Right", "lowerarm_r", "mixamorig:RightForeArm", "ArmDown_Right"],
+    anchor: [0, -0.12, 0],
+    coneAngle: Math.PI / 2,
+    twistAngle: 0,
+  },
+  {
+    parent: ["Hips", "pelvis", "mixamorig:Hips", "Pelvis"],
+    child: ["UpperLeg_Left", "thigh_l", "mixamorig:LeftUpLeg", "LegUp_Left"],
+    anchor: [0.1, -0.1, 0],
+    coneAngle: Math.PI / 4,
+    twistAngle: Math.PI / 8,
+  },
+  {
+    parent: ["Hips", "pelvis", "mixamorig:Hips", "Pelvis"],
+    child: ["UpperLeg_Right", "thigh_r", "mixamorig:RightUpLeg", "LegUp_Right"],
+    anchor: [-0.1, -0.1, 0],
+    coneAngle: Math.PI / 4,
+    twistAngle: Math.PI / 8,
+  },
+  {
+    parent: ["UpperLeg_Left", "thigh_l", "mixamorig:LeftUpLeg", "LegUp_Left"],
+    child: ["LowerLeg_Left", "calf_l", "mixamorig:LeftLeg", "LegDown_Left"],
+    anchor: [0, -0.22, 0],
+    coneAngle: 0,
+    twistAngle: Math.PI / 2,
+  },
+  {
+    parent: ["UpperLeg_Right", "thigh_r", "mixamorig:RightUpLeg", "LegUp_Right"],
+    child: ["LowerLeg_Right", "calf_r", "mixamorig:RightLeg", "LegDown_Right"],
+    anchor: [0, -0.22, 0],
+    coneAngle: 0,
+    twistAngle: Math.PI / 2,
+  },
+];
+
+function findBoneInSkeleton(skeleton: Skeleton, names: string[]): string | null {
+  for (let _i = 0, _it = names, _n = _it.length; _i < _n; _i++) { const name = _it[_i];
+    if (skeleton.getBoneIndex(name) >= 0) return name;
+  }
+  return null;
+}
+
+export function humanoidRagdoll(skeleton: Skeleton): RagdollConfig {
+  const bones: RagdollBoneConfig[] = [];
+  const boneNameMap = new Map<string, string>();
+
+  for (let _i = 0, _it = BONE_MATCHES, _n = _it.length; _i < _n; _i++) { const match = _it[_i];
+    const foundName = findBoneInSkeleton(skeleton, match.names);
+    if (!foundName) continue;
+
+    let shape;
+    if (match.shape === "sphere") {
+      shape = { type: "sphere", radius: match.radius } as const;
+    } else if (match.shape === "capsule") {
+      shape = { type: "capsule", radius: match.radius, halfHeight: match.halfHeight } as const;
+    } else {
+      shape = { type: "box", halfExtents: match.halfExtents } as const;
+    }
+
+    bones.push({
+      boneName: foundName,
+      shape,
+      boneToColliderOffset: match.offset,
+      mass: match.mass,
+      linearDamping: match.linearDamping,
+      angularDamping: match.angularDamping,
+    });
+    boneNameMap.set(match.names[0], foundName);
+  }
+
+  const joints: RagdollJointConfig[] = [];
+  for (let _i = 0, _it = JOINT_MATCHES, _n = _it.length; _i < _n; _i++) { const jmatch = _it[_i];
+    const parentName = findBoneInSkeleton(skeleton, jmatch.parent);
+    const childName = findBoneInSkeleton(skeleton, jmatch.child);
+    if (!parentName || !childName) continue;
+
+    joints.push({
+      parentBone: parentName,
+      childBone: childName,
+      anchor: jmatch.anchor,
+      coneAngle: jmatch.coneAngle,
+      twistAngle: jmatch.twistAngle,
+    });
+  }
+
+  return { bones, joints };
+}

package/core/src/physics/ragdoll-system.ts

@@ -0,0 +1,220 @@
+import type { Skeleton, SkeletonAnimator } from "../animation";
+import type { Entity } from "../ecs/entity";
+import type { Query } from "../ecs/query";
+import { Stage, system } from "../ecs/system";
+import type { World } from "../ecs/world";
+import type { RagdollData } from "./ragdoll";
+import { Ragdoll } from "./ragdoll";
+import type { PhysicsRealm } from "./realm";
+
+export class RagdollSystem {
+  private realm: PhysicsRealm;
+  private animator: SkeletonAnimator | null = null;
+  private skeleton: Skeleton | null = null;
+  private query: Query | null = null;
+  private world: World | null = null;
+  private activationRequests: Map<number, { entity: Entity; blendSpeed: number }> = new Map();
+  private deactivationRequests: Set<number> = new Set();
+
+  constructor(realm: PhysicsRealm) {
+    this.realm = realm;
+  }
+
+  setAnimator(animator: SkeletonAnimator): void {
+    this.animator = animator;
+    this.skeleton = animator.getSkeleton();
+  }
+
+  activateRagdoll(entity: Entity, blendSpeed: number = 2): void {
+    this.activationRequests.set(entity.index, { entity, blendSpeed });
+  }
+
+  deactivateRagdoll(entity: Entity): void {
+    this.deactivationRequests.add(entity.index);
+  }
+
+  register(world: World, query: Query): void {
+    this.world = world;
+    this.query = query;
+    const self = this;
+    const ragdollSystem = system(
+      "ragdoll-blend",
+      Stage.Physics,
+      (ctx) => {
+        if (!self.query) return;
+        self.query.iterate(ctx.tick, (entity, components) => {
+          const ragdoll = components[0] as RagdollData;
+          self.update(entity, ragdoll, ctx.dt);
+        });
+        self.processRequests();
+      },
+      { queries: [query] },
+    );
+    world.schedule.add(ragdollSystem);
+  }
+
+  private update(entity: Entity, ragdoll: RagdollData, dt: number): void {
+    if (ragdoll.bodyHandles.length === 0) return;
+
+    if (ragdoll.targetBlendWeight > ragdoll.blendWeight) {
+      ragdoll.blendWeight = Math.min(
+        ragdoll.targetBlendWeight,
+        ragdoll.blendWeight + ragdoll.blendSpeed * dt,
+      );
+    } else if (ragdoll.targetBlendWeight < ragdoll.blendWeight) {
+      ragdoll.blendWeight = Math.max(
+        ragdoll.targetBlendWeight,
+        ragdoll.blendWeight - ragdoll.blendSpeed * dt,
+      );
+    }
+
+    if (ragdoll.blendWeight < 1.0) {
+      this.driveFromAnimation(ragdoll);
+    } else {
+      this.driveFromPhysics(ragdoll);
+    }
+  }
+
+  private driveFromAnimation(ragdoll: RagdollData): void {
+    if (!this.animator || !this.skeleton) return;
+
+    const boneTransforms = this.animator.getLocalPosFlat();
+    const boneRotations = this.animator.getLocalRotFlat();
+    const boneScales = this.animator.getLocalScaleFlat();
+    const parentIndices = this.animator.getParentIndices();
+
+    const boneCount = this.skeleton.getBoneCount();
+    const worldPositions: [number, number, number][] = new Array(boneCount);
+    const worldRotations: [number, number, number, number][] = new Array(boneCount);
+
+    for (let i = 0; i < boneCount; i++) {
+      const px = boneTransforms[i * 4];
+      const py = boneTransforms[i * 4 + 1];
+      const pz = boneTransforms[i * 4 + 2];
+      const qx = boneRotations[i * 4];
+      const qy = boneRotations[i * 4 + 1];
+      const qz = boneRotations[i * 4 + 2];
+      const qw = boneRotations[i * 4 + 3];
+      const sx = boneScales[i * 4];
+      const sy = boneScales[i * 4 + 1];
+      const sz = boneScales[i * 4 + 2];
+
+      const parentIdx = parentIndices[i];
+      if (parentIdx >= 0 && worldPositions[parentIdx]) {
+        const wp = worldPositions[parentIdx];
+        const wr = worldRotations[parentIdx];
+        worldPositions[i] = [
+          wp[0] + px * sx,
+          wp[1] + py * sy,
+          wp[2] + pz * sz,
+        ];
+        worldRotations[i] = [
+          wr[0] * qw + wr[1] * qz - wr[2] * qy + wr[3] * qx,
+          -wr[0] * qz + wr[1] * qw + wr[2] * qx + wr[3] * qy,
+          wr[0] * qy - wr[1] * qx + wr[2] * qw + wr[3] * qz,
+          -wr[0] * qx - wr[1] * qy - wr[2] * qz + wr[3] * qw,
+        ];
+      } else {
+        worldPositions[i] = [px, py, pz];
+        worldRotations[i] = [qx, qy, qz, qw];
+      }
+    }
+
+    for (let i = 0; i < ragdoll.boneNames.length; i++) {
+      const boneName = ragdoll.boneNames[i];
+      const handle = ragdoll.bodyHandles[i];
+      if (handle.id < 0) continue;
+
+      const boneIdx = this.skeleton.getBoneIndex(boneName);
+      if (boneIdx < 0) continue;
+
+      const config = ragdoll.config;
+      if (!config) continue;
+      const boneCfg = config.bones[i];
+      if (!boneCfg) continue;
+
+      const worldPos = worldPositions[boneIdx];
+      this.realm.setPosition(handle, [
+        worldPos[0] + boneCfg.boneToColliderOffset[0],
+        worldPos[1] + boneCfg.boneToColliderOffset[1],
+        worldPos[2] + boneCfg.boneToColliderOffset[2],
+      ]);
+      this.realm.setRotation(handle, worldRotations[boneIdx]);
+      this.realm.setBodyType(handle, "kinematic");
+    }
+  }
+
+  private driveFromPhysics(ragdoll: RagdollData): void {
+    if (!this.skeleton) return;
+
+    for (let i = 0; i < ragdoll.bodyHandles.length; i++) {
+      const handle = ragdoll.bodyHandles[i];
+      if (handle.id < 0) continue;
+      this.realm.setBodyType(handle, "dynamic");
+    }
+
+    if (this.animator && ragdoll.blendWeight >= 1.0) {
+      const boneCount = this.skeleton.getBoneCount();
+      const localPos = this.animator.getLocalPosFlat();
+      const localRot = this.animator.getLocalRotFlat();
+      const parentIndices = this.animator.getParentIndices();
+
+      const worldPositions: [number, number, number][] = new Array(boneCount);
+      const worldRotations: [number, number, number, number][] = new Array(boneCount);
+
+      for (let i = 0; i < boneCount; i++) {
+        const parentIdx = parentIndices[i];
+        if (parentIdx >= 0 && worldPositions[parentIdx]) {
+          const wp = worldPositions[parentIdx];
+          const lp = [localPos[i * 4], localPos[i * 4 + 1], localPos[i * 4 + 2]];
+          worldPositions[i] = [wp[0] + lp[0], wp[1] + lp[1], wp[2] + lp[2]];
+          worldRotations[i] = [
+            localRot[i * 4],
+            localRot[i * 4 + 1],
+            localRot[i * 4 + 2],
+            localRot[i * 4 + 3],
+          ];
+        } else {
+          worldPositions[i] = [localPos[i * 4], localPos[i * 4 + 1], localPos[i * 4 + 2]];
+          worldRotations[i] = [localRot[i * 4], localRot[i * 4 + 1], localRot[i * 4 + 2], localRot[i * 4 + 3]];
+        }
+      }
+
+      for (let i = 0; i < ragdoll.boneNames.length; i++) {
+        const boneName = ragdoll.boneNames[i];
+        const handle = ragdoll.bodyHandles[i];
+        if (handle.id < 0) continue;
+
+        const boneIdx = this.skeleton.getBoneIndex(boneName);
+        if (boneIdx < 0) continue;
+
+        const config = ragdoll.config;
+        if (!config) continue;
+      }
+    }
+  }
+
+  private processRequests(): void {
+    for (const [entityIdx, req] of this.activationRequests.entries()) {
+      if (!this.world) continue;
+      const ragdoll = this.world.getComponent<RagdollData>(req.entity, Ragdoll.id);
+      if (ragdoll) {
+        ragdoll.active = true;
+        ragdoll.targetBlendWeight = 1.0;
+        ragdoll.blendSpeed = req.blendSpeed;
+      }
+    }
+    this.activationRequests.clear();
+
+    for (const entityIdx of this.deactivationRequests.values()) {
+      if (!this.world) continue;
+      const entity = { index: entityIdx, generation: 0 };
+      const ragdoll = this.world.getComponent<RagdollData>(entity, Ragdoll.id);
+      if (ragdoll) {
+        ragdoll.active = false;
+        ragdoll.targetBlendWeight = 0.0;
+      }
+    }
+    this.deactivationRequests.clear();
+  }
+}

package/core/src/physics/ragdoll.ts

@@ -0,0 +1,182 @@
+import type { Skeleton } from "../animation";
+import type { ComponentDefinition } from "../ecs/component";
+import { Component } from "../ecs/component";
+import type { Entity } from "../ecs/entity";
+import type { ColliderShape, JointDesc, PhysicsBody } from "./interface";
+import type { PhysicsRealm } from "./realm";
+
+// ── Config interfaces ──
+
+export interface RagdollBoneConfig {
+  boneName: string;
+  shape: ColliderShape;
+  boneToColliderOffset: [number, number, number];
+  mass: number;
+  linearDamping: number;
+  angularDamping: number;
+}
+
+export interface RagdollJointConfig {
+  parentBone: string;
+  childBone: string;
+  anchor: [number, number, number];
+  coneAngle: number;
+  twistAngle: number;
+}
+
+export interface RagdollConfig {
+  bones: RagdollBoneConfig[];
+  joints: RagdollJointConfig[];
+}
+
+// ── ECS component ──
+
+export interface RagdollData {
+  [key: string]: unknown;
+  config: RagdollConfig | null;
+  bodyHandles: PhysicsBody[];
+  jointIds: number[];
+  boneNames: string[];
+  blendWeight: number;
+  targetBlendWeight: number;
+  blendSpeed: number;
+  active: boolean;
+  realmId: number;
+}
+
+export const Ragdoll: ComponentDefinition<RagdollData> = Component.register<RagdollData>("Ragdoll", {
+  config: null,
+  bodyHandles: [],
+  jointIds: [],
+  boneNames: [],
+  blendWeight: 0,
+  targetBlendWeight: 0,
+  blendSpeed: 2,
+  active: false,
+  realmId: -1,
+});
+
+// ── Factory ──
+
+export function createRagdoll(
+  realm: PhysicsRealm,
+  skeleton: Skeleton,
+  config: RagdollConfig,
+  entity: Entity,
+): RagdollData {
+  const bodyHandles: PhysicsBody[] = [];
+  const jointIds: number[] = [];
+  const boneNames: string[] = [];
+
+  for (let _i = 0, _it = config.bones, _n = _it.length; _i < _n; _i++) { const boneCfg = _it[_i];
+    const boneIdx = skeleton.getBoneIndex(boneCfg.boneName);
+    if (boneIdx < 0) {
+      bodyHandles.push({ realmId: realm.id, id: -1, entity });
+      boneNames.push(boneCfg.boneName);
+      continue;
+    }
+
+    const bone = skeleton.data.bones[boneIdx];
+    const worldPos = computeBoneWorldPosition(skeleton, boneIdx);
+
+    const handle = realm.createBody(
+      {
+        type: "dynamic",
+        position: [
+          worldPos[0] + boneCfg.boneToColliderOffset[0],
+          worldPos[1] + boneCfg.boneToColliderOffset[1],
+          worldPos[2] + boneCfg.boneToColliderOffset[2],
+        ],
+        rotation: bone.bindRotation,
+        mass: boneCfg.mass,
+        linearDamping: boneCfg.linearDamping,
+        angularDamping: boneCfg.angularDamping,
+      },
+      entity,
+    );
+
+    realm.addCollider(handle, { shape: boneCfg.shape });
+    bodyHandles.push(handle);
+    boneNames.push(boneCfg.boneName);
+  }
+
+  for (let _i = 0, _it = config.joints, _n = _it.length; _i < _n; _i++) { const jointCfg = _it[_i];
+    const parentIdx = boneNames.indexOf(jointCfg.parentBone);
+    const childIdx = boneNames.indexOf(jointCfg.childBone);
+    if (parentIdx < 0 || childIdx < 0) {
+      jointIds.push(-1);
+      continue;
+    }
+
+    const parentHandle = bodyHandles[parentIdx];
+    const childHandle = bodyHandles[childIdx];
+    if (parentHandle.id < 0 || childHandle.id < 0) {
+      jointIds.push(-1);
+      continue;
+    }
+
+    const jointDesc: JointDesc = {
+      type: "cone-twist",
+      anchorA: jointCfg.anchor,
+      anchorB: [0, 0, 0],
+      coneAngle: jointCfg.coneAngle,
+      twistAngle: jointCfg.twistAngle,
+    };
+
+    const jointId = realm.createJoint(parentHandle, childHandle, jointDesc);
+    jointIds.push(jointId);
+  }
+
+  return {
+    config,
+    bodyHandles,
+    jointIds,
+    boneNames,
+    blendWeight: 0,
+    targetBlendWeight: 0,
+    blendSpeed: 2,
+    active: false,
+    realmId: realm.id,
+    __componentId: Ragdoll.id,
+  };
+}
+
+export function destroyRagdoll(realm: PhysicsRealm, ragdoll: RagdollData): void {
+  ragdoll.jointIds.forEach((jointId) => {
+    if (jointId >= 0) {
+      realm.destroyJoint(jointId);
+    }
+  });
+  ragdoll.bodyHandles.forEach((handle) => {
+    if (handle.id >= 0) {
+      realm.destroyBody(handle);
+    }
+  });
+  ragdoll.jointIds = [];
+  ragdoll.bodyHandles = [];
+  ragdoll.active = false;
+  ragdoll.blendWeight = 0;
+  ragdoll.targetBlendWeight = 0;
+}
+
+// ── Helpers ──
+
+function computeBoneWorldPosition(skeleton: Skeleton, boneIdx: number): [number, number, number] {
+  const bones = skeleton.data.bones;
+  let pos: [number, number, number] = [0, 0, 0];
+  let idx = boneIdx;
+  const chain: number[] = [];
+  while (idx >= 0) {
+    chain.unshift(idx);
+    idx = bones[idx].parentIndex;
+  }
+  chain.forEach((bi) => {
+    const bone = bones[bi];
+    pos = [
+      pos[0] + bone.bindPosition[0],
+      pos[1] + bone.bindPosition[1],
+      pos[2] + bone.bindPosition[2],
+    ];
+  });
+  return pos;
+}