@frsource/babylon-box3d 1.0.0

package/dist/index.js

@@ -0,0 +1,1243 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  Box3DPlugin: () => Box3DPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// box3dPlugin.ts
+var import_core = require("@babylonjs/core");
+var DEFAULT_SUB_STEP_COUNT = 4;
+function toB3Vec(v) {
+  return { x: v.x, y: v.y, z: v.z };
+}
+function fromB3Vec(v, out) {
+  if (out) {
+    out.set(v.x, v.y, v.z);
+    return out;
+  }
+  return new import_core.Vector3(v.x, v.y, v.z);
+}
+function toB3Quat(q) {
+  return { x: q.x, y: q.y, z: q.z, w: q.w };
+}
+function fromB3Quat(q, out) {
+  if (out) {
+    out.set(q.x, q.y, q.z, q.w);
+    return out;
+  }
+  return new import_core.Quaternion(q.x, q.y, q.z, q.w);
+}
+function quaternionFromXAxis(axis) {
+  const from = import_core.Vector3.Right();
+  const to = axis.normalizeToNew();
+  const dot = import_core.Vector3.Dot(from, to);
+  if (dot > 1 - 1e-6) {
+    return import_core.Quaternion.Identity();
+  }
+  if (dot < -1 + 1e-6) {
+    const perp = Math.abs(from.y) < 0.99 ? import_core.Vector3.Up() : import_core.Vector3.Forward();
+    const axisOfRotation2 = import_core.Vector3.Cross(from, perp).normalize();
+    return import_core.Quaternion.RotationAxis(axisOfRotation2, Math.PI);
+  }
+  const axisOfRotation = import_core.Vector3.Cross(from, to);
+  const s = Math.sqrt((1 + dot) * 2);
+  const invS = 1 / s;
+  return new import_core.Quaternion(
+    axisOfRotation.x * invS,
+    axisOfRotation.y * invS,
+    axisOfRotation.z * invS,
+    s * 0.5
+  ).normalize();
+}
+var Box3DBodyPluginData = class {
+  constructor(native) {
+    this.native = native;
+    this.shape = null;
+    this.attachments = [];
+    this.motionType = import_core.PhysicsMotionType.STATIC;
+    this.eventMask = 0;
+    this.collisionCBEnabled = false;
+    this.collisionEndedCBEnabled = false;
+    this.onCollisionObservable = new import_core.Observable();
+    this.onCollisionEndedObservable = new import_core.Observable();
+  }
+};
+var Box3DShapeDescriptor = class {
+  constructor(type, parameters) {
+    this.type = type;
+    this.parameters = parameters;
+    this.filterMembershipMask = 1;
+    this.filterCollideMask = 4294967295;
+    this.material = { friction: 0.5, restitution: 0 };
+    this.density = 1;
+    this.isTrigger = false;
+    this.children = [];
+  }
+};
+var Box3DConstraintPluginData = class {
+  constructor(type, bodyPair, buildJoint) {
+    this.type = type;
+    this.bodyPair = bodyPair;
+    this.buildJoint = buildJoint;
+    this.native = null;
+    this.enabled = true;
+    this.collideConnected = false;
+    this.axisMotorType = /* @__PURE__ */ new Map();
+    this.axisMotorTarget = /* @__PURE__ */ new Map();
+    this.axisMotorMaxForce = /* @__PURE__ */ new Map();
+    this.axisLimitMode = /* @__PURE__ */ new Map();
+    this.axisMinLimit = /* @__PURE__ */ new Map();
+    this.axisMaxLimit = /* @__PURE__ */ new Map();
+    this.axisFriction = /* @__PURE__ */ new Map();
+  }
+  rebuild() {
+    if (this.native && this.native.isValid()) {
+      this.native.destroy(true);
+    }
+    this.native = this.enabled ? this.buildJoint(this) : null;
+  }
+};
+var Box3DPlugin = class {
+  /**
+   * @param box3d - The resolved box3d-wasm module, e.g. `await Box3D()`.
+   * @param worldOptions - Forwarded to box3d-wasm's `World` constructor (gravity, sleep, continuous collision, thread count, ...).
+   */
+  constructor(box3d, worldOptions) {
+    this.name = "Box3D";
+    this.onCollisionObservable = new import_core.Observable();
+    this.onCollisionEndedObservable = new import_core.Observable();
+    this.onTriggerCollisionObservable = new import_core.Observable();
+    this._timeStep = 1 / 60;
+    this._subStepCount = DEFAULT_SUB_STEP_COUNT;
+    this._maxLinearVelocity = Infinity;
+    this._maxAngularVelocity = Infinity;
+    this._bodies = /* @__PURE__ */ new Map();
+    this._shapeOwners = /* @__PURE__ */ new Map();
+    this._warnedAboutInstancing = false;
+    this.world = new box3d.World(worldOptions);
+  }
+  setGravity(gravity) {
+    this.world.setGravity(toB3Vec(gravity));
+  }
+  setTimeStep(timeStep) {
+    this._timeStep = timeStep;
+  }
+  getTimeStep() {
+    return this._timeStep;
+  }
+  /** Number of box3d solver sub-steps per `executeStep` call. Defaults to 4, matching box3d's own samples. */
+  setSubStepCount(subStepCount) {
+    this._subStepCount = subStepCount;
+  }
+  getPluginVersion() {
+    return 2;
+  }
+  setVelocityLimits(maxLinearVelocity, maxAngularVelocity) {
+    this._maxLinearVelocity = maxLinearVelocity;
+    this._maxAngularVelocity = maxAngularVelocity;
+  }
+  getMaxLinearVelocity() {
+    return this._maxLinearVelocity;
+  }
+  getMaxAngularVelocity() {
+    return this._maxAngularVelocity;
+  }
+  executeStep(delta, bodies) {
+    for (const body of bodies) {
+      if (!body.disablePreStep) {
+        this._prestep(body);
+      }
+    }
+    this.world.step(delta, this._subStepCount);
+    if (Number.isFinite(this._maxLinearVelocity)) {
+      this._clampLinearVelocities(bodies);
+    }
+    for (const body of bodies) {
+      if (!body.disableSync) {
+        this.sync(body);
+      }
+    }
+    this._dispatchEvents();
+  }
+  _clampLinearVelocities(bodies) {
+    const max = this._maxLinearVelocity;
+    for (const body of bodies) {
+      const data = this._getPluginData(body);
+      const v = data.native.getLinearVelocity();
+      const speed = Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+      if (speed > max && speed > 0) {
+        const scale = max / speed;
+        data.native.setLinearVelocity({
+          x: v.x * scale,
+          y: v.y * scale,
+          z: v.z * scale
+        });
+      }
+    }
+  }
+  /** Pushes kinematic/animated transform-node motion into box3d before stepping. Dynamic bodies are driven by the solver and skip this. */
+  _prestep(body) {
+    const data = body._pluginData;
+    if (!data || data.motionType === import_core.PhysicsMotionType.DYNAMIC) {
+      return;
+    }
+    const node = body.transformNode;
+    const position = node.position;
+    const rotation = node.rotationQuaternion ?? import_core.Quaternion.FromEulerVector(node.rotation);
+    data.native.setTargetTransform(
+      { position: toB3Vec(position), rotation: toB3Quat(rotation) },
+      this._timeStep,
+      true
+    );
+  }
+  // -------------------------------------------------------------------
+  // Body
+  // -------------------------------------------------------------------
+  initBody(body, motionType, position, orientation) {
+    const native = this.world.createBody({
+      type: toBox3DBodyType(motionType),
+      position: toB3Vec(position),
+      rotation: toB3Quat(orientation),
+      isAwake: !body.startAsleep
+    });
+    const data = new Box3DBodyPluginData(native);
+    data.motionType = motionType;
+    body._pluginData = data;
+    this._bodies.set(body, data);
+  }
+  initBodyInstances(body, motionType, mesh) {
+    if (!this._warnedAboutInstancing) {
+      this._warnedAboutInstancing = true;
+      console.warn(
+        "Box3DPlugin: box3d-wasm has no batched rigid body instancing; only the master mesh transform is simulated."
+      );
+    }
+    const position = mesh.position.clone();
+    const rotation = mesh.rotationQuaternion?.clone() ?? import_core.Quaternion.FromEulerVector(mesh.rotation);
+    this.initBody(body, motionType, position, rotation);
+  }
+  updateBodyInstances(_body, _mesh) {
+  }
+  removeBody(body) {
+    const data = this._bodies.get(body);
+    if (!data) {
+      return;
+    }
+    this._destroyAttachments(data);
+    if (data.native.isValid()) {
+      data.native.destroy();
+    }
+    this._bodies.delete(body);
+  }
+  sync(body) {
+    this.syncTransform(body, body.transformNode);
+  }
+  syncTransform(body, transformNode) {
+    const data = body._pluginData;
+    if (!data || data.motionType !== import_core.PhysicsMotionType.DYNAMIC) {
+      return;
+    }
+    fromB3Vec(data.native.getPosition(), transformNode.position);
+    transformNode.rotationQuaternion = fromB3Quat(
+      data.native.getRotation(),
+      transformNode.rotationQuaternion ?? new import_core.Quaternion()
+    );
+  }
+  setShape(body, shape) {
+    const data = this._getPluginData(body);
+    this._destroyAttachments(data);
+    data.shape = shape;
+    if (shape) {
+      this._attachShape(
+        body,
+        data,
+        shape,
+        import_core.Vector3.Zero(),
+        import_core.Quaternion.Identity(),
+        import_core.Vector3.One()
+      );
+      data.native.applyMassFromShapes();
+    }
+  }
+  getShape(body) {
+    return this._getPluginData(body).shape;
+  }
+  getShapeType(shape) {
+    return this._getShapeData(shape).type;
+  }
+  setEventMask(body, eventMask) {
+    this._getPluginData(body).eventMask = eventMask;
+  }
+  getEventMask(body) {
+    return this._getPluginData(body).eventMask;
+  }
+  setMotionType(body, motionType) {
+    const data = this._getPluginData(body);
+    data.motionType = motionType;
+    data.native.setType(toBox3DBodyType(motionType));
+  }
+  getMotionType(body) {
+    return this._getPluginData(body).motionType;
+  }
+  computeMassProperties(body) {
+    const data = this._getPluginData(body);
+    data.native.applyMassFromShapes();
+    return {
+      mass: data.native.getMass(),
+      centerOfMass: fromB3Vec(data.native.getLocalCenterOfMass())
+    };
+  }
+  setMassProperties(body, massProps) {
+    const data = this._getPluginData(body);
+    if (massProps.inertia || massProps.inertiaOrientation || massProps.centerOfMass) {
+      console.warn(
+        "Box3DPlugin: box3d-wasm derives inertia and center of mass from shape density; only `mass` can be overridden."
+      );
+    }
+    if (massProps.mass === void 0) {
+      return;
+    }
+    data.native.applyMassFromShapes();
+    const currentMass = data.native.getMass();
+    if (currentMass <= 0 || data.attachments.length === 0) {
+      return;
+    }
+    const scale = massProps.mass / currentMass;
+    for (const attachment of data.attachments) {
+      attachment.native.setDensity(
+        attachment.native.getDensity() * scale,
+        false
+      );
+    }
+    data.native.applyMassFromShapes();
+  }
+  getMassProperties(body) {
+    const data = this._getPluginData(body);
+    return {
+      mass: data.native.getMass(),
+      centerOfMass: fromB3Vec(data.native.getLocalCenterOfMass())
+    };
+  }
+  setLinearDamping(body, damping) {
+    this._getPluginData(body).native.setLinearDamping(damping);
+  }
+  getLinearDamping(body) {
+    return this._getPluginData(body).native.getLinearDamping();
+  }
+  setAngularDamping(body, damping) {
+    this._getPluginData(body).native.setAngularDamping(damping);
+  }
+  getAngularDamping(body) {
+    return this._getPluginData(body).native.getAngularDamping();
+  }
+  setLinearVelocity(body, linVel) {
+    this._getPluginData(body).native.setLinearVelocity(toB3Vec(linVel));
+  }
+  getLinearVelocityToRef(body, linVel) {
+    fromB3Vec(this._getPluginData(body).native.getLinearVelocity(), linVel);
+  }
+  applyImpulse(body, impulse, location) {
+    this._getPluginData(body).native.applyLinearImpulse(
+      toB3Vec(impulse),
+      toB3Vec(location),
+      true
+    );
+  }
+  applyAngularImpulse(body, angularImpulse) {
+    this._getPluginData(body).native.applyAngularImpulse(
+      toB3Vec(angularImpulse),
+      true
+    );
+  }
+  applyForce(body, force, location) {
+    this._getPluginData(body).native.applyForce(
+      toB3Vec(force),
+      toB3Vec(location),
+      true
+    );
+  }
+  applyTorque(body, torque) {
+    this._getPluginData(body).native.applyTorque(toB3Vec(torque), true);
+  }
+  setAngularVelocity(body, angVel) {
+    this._getPluginData(body).native.setAngularVelocity(toB3Vec(angVel));
+  }
+  getAngularVelocityToRef(body, angVel) {
+    fromB3Vec(this._getPluginData(body).native.getAngularVelocity(), angVel);
+  }
+  getBodyGeometry(_body) {
+    return {};
+  }
+  disposeBody(body) {
+    const data = this._bodies.get(body);
+    if (!data) {
+      return;
+    }
+    data.onCollisionObservable.clear();
+    data.onCollisionEndedObservable.clear();
+    this.removeBody(body);
+    body._pluginData = null;
+  }
+  setCollisionCallbackEnabled(body, enabled) {
+    const data = this._getPluginData(body);
+    data.collisionCBEnabled = enabled;
+  }
+  setCollisionEndedCallbackEnabled(body, enabled) {
+    const data = this._getPluginData(body);
+    data.collisionEndedCBEnabled = enabled;
+  }
+  addConstraint(body, childBody, constraint) {
+    this.initConstraint(constraint, body, childBody);
+  }
+  getCollisionObservable(body) {
+    return this._getPluginData(body).onCollisionObservable;
+  }
+  getCollisionEndedObservable(body) {
+    return this._getPluginData(body).onCollisionEndedObservable;
+  }
+  setGravityFactor(body, factor) {
+    this._getPluginData(body).native.setGravityScale(factor);
+  }
+  getGravityFactor(body) {
+    return this._getPluginData(body).native.getGravityScale();
+  }
+  setTargetTransform(body, position, rotation) {
+    this._getPluginData(body).native.setTargetTransform(
+      { position: toB3Vec(position), rotation: toB3Quat(rotation) },
+      this._timeStep,
+      true
+    );
+  }
+  _getPluginData(body) {
+    const data = body._pluginData;
+    if (!data) {
+      throw new Error(
+        "Box3DPlugin: PhysicsBody has not been initialized by this plugin."
+      );
+    }
+    return data;
+  }
+  _destroyAttachments(data) {
+    for (const attachment of data.attachments) {
+      this._shapeOwners.delete(attachment.native.getUserData());
+      if (attachment.native.isValid()) {
+        attachment.native.destroy(false);
+      }
+    }
+    data.attachments = [];
+  }
+  // -------------------------------------------------------------------
+  // Shape
+  // -------------------------------------------------------------------
+  initShape(shape, type, options) {
+    if (type === import_core.PhysicsShapeType.MESH || type === import_core.PhysicsShapeType.HEIGHTFIELD || type === import_core.PhysicsShapeType.CYLINDER) {
+      throw new Error(
+        `Box3DPlugin: shape type ${import_core.PhysicsShapeType[type]} is not supported by box3d-wasm.`
+      );
+    }
+    shape._pluginData = new Box3DShapeDescriptor(type, options);
+  }
+  setShapeFilterMembershipMask(shape, membershipMask) {
+    this._getShapeData(shape).filterMembershipMask = membershipMask;
+    this._refreshShapeFilters(shape);
+  }
+  getShapeFilterMembershipMask(shape) {
+    return this._getShapeData(shape).filterMembershipMask;
+  }
+  setShapeFilterCollideMask(shape, collideMask) {
+    this._getShapeData(shape).filterCollideMask = collideMask;
+    this._refreshShapeFilters(shape);
+  }
+  getShapeFilterCollideMask(shape) {
+    return this._getShapeData(shape).filterCollideMask;
+  }
+  setMaterial(shape, material) {
+    const data = this._getShapeData(shape);
+    data.material = material;
+    for (const native of this._nativeShapesOf(shape)) {
+      native.setFriction(material.friction ?? 0.5);
+      native.setRestitution(material.restitution ?? 0);
+    }
+  }
+  getMaterial(shape) {
+    return this._getShapeData(shape).material;
+  }
+  setDensity(shape, density) {
+    const data = this._getShapeData(shape);
+    data.density = density;
+    for (const native of this._nativeShapesOf(shape)) {
+      native.setDensity(density, true);
+    }
+  }
+  getDensity(shape) {
+    return this._getShapeData(shape).density;
+  }
+  addChild(shape, newChild, translation, rotation, scale) {
+    const data = this._getShapeData(shape);
+    data.children.push({
+      shape: newChild,
+      translation: translation?.clone() ?? import_core.Vector3.Zero(),
+      rotation: rotation?.clone() ?? import_core.Quaternion.Identity(),
+      scale: scale?.clone() ?? import_core.Vector3.One()
+    });
+    this._reattachOwners(shape);
+  }
+  removeChild(shape, childIndex) {
+    this._getShapeData(shape).children.splice(childIndex, 1);
+    this._reattachOwners(shape);
+  }
+  getNumChildren(shape) {
+    return this._getShapeData(shape).children.length;
+  }
+  getBoundingBox(shape) {
+    const { min, max } = computeLocalBounds(this._getShapeData(shape));
+    return new import_core.BoundingBox(min, max);
+  }
+  getBodyBoundingBox(body) {
+    const aabb = this._getPluginData(body).native.computeAABB();
+    return new import_core.BoundingBox(
+      fromB3Vec(aabb.lowerBound),
+      fromB3Vec(aabb.upperBound)
+    );
+  }
+  disposeShape(shape) {
+    for (const [owner] of this._ownersOfShape(shape)) {
+      const attachmentIndex = owner.attachments.findIndex(
+        (a) => a.shape === shape
+      );
+      if (attachmentIndex < 0) {
+        continue;
+      }
+      const attachment = owner.attachments.splice(attachmentIndex, 1)[0];
+      if (!attachment) {
+        continue;
+      }
+      this._shapeOwners.delete(attachment.native.getUserData());
+      if (attachment.native.isValid()) {
+        attachment.native.destroy(true);
+      }
+    }
+    shape._pluginData = null;
+  }
+  setTrigger(shape, isTrigger) {
+    const data = this._getShapeData(shape);
+    data.isTrigger = isTrigger;
+    this._reattachOwners(shape);
+  }
+  _getShapeData(shape) {
+    const data = shape._pluginData;
+    if (!data) {
+      throw new Error(
+        "Box3DPlugin: PhysicsShape has not been initialized by this plugin."
+      );
+    }
+    return data;
+  }
+  _nativeShapesOf(shape) {
+    const result = [];
+    for (const data of this._bodies.values()) {
+      for (const attachment of data.attachments) {
+        if (attachment.shape === shape) {
+          result.push(attachment.native);
+        }
+      }
+    }
+    return result;
+  }
+  *_ownersOfShape(shape) {
+    for (const [body, data] of this._bodies.entries()) {
+      if (data.attachments.some((a) => a.shape === shape)) {
+        yield [data, body];
+      }
+    }
+  }
+  /** Re-creates every body's attachment tree that (transitively) references `shape`, e.g. after `addChild`/`removeChild`/`setTrigger`. */
+  _reattachOwners(shape) {
+    for (const [body, data] of this._bodies.entries()) {
+      if (data.shape && shapeTreeContains(data.shape, shape)) {
+        this._destroyAttachments(data);
+        this._attachShape(
+          body,
+          data,
+          data.shape,
+          import_core.Vector3.Zero(),
+          import_core.Quaternion.Identity(),
+          import_core.Vector3.One()
+        );
+        data.native.applyMassFromShapes();
+      }
+    }
+  }
+  _refreshShapeFilters(shape) {
+    const data = this._getShapeData(shape);
+    for (const native of this._nativeShapesOf(shape)) {
+      native.setFilter({
+        categoryBits: data.filterMembershipMask,
+        maskBits: data.filterCollideMask
+      });
+    }
+  }
+  /** Recursively creates native box3d shapes for `shape` (and, for CONTAINER shapes, its children) on `bodyData.native`, composing local transforms along the way. */
+  _attachShape(owner, bodyData, shape, parentT, parentR, parentS) {
+    const data = this._getShapeData(shape);
+    if (data.type !== import_core.PhysicsShapeType.CONTAINER) {
+      const native = createNativeShape(
+        bodyData.native,
+        data,
+        parentT,
+        parentR,
+        parentS
+      );
+      native.setUserData(nextShapeTag());
+      native.enableContactEvents(true);
+      native.enableHitEvents(true);
+      native.enableSensorEvents(true);
+      native.setFilter({
+        categoryBits: data.filterMembershipMask,
+        maskBits: data.filterCollideMask
+      });
+      bodyData.attachments.push({ shape, native });
+      this._shapeOwners.set(native.getUserData(), { body: owner, shape });
+    }
+    for (const child of data.children) {
+      const t = parentT.add(
+        import_core.Vector3.TransformCoordinates(
+          child.translation.multiply(parentS),
+          Matrix_fromQuaternion(parentR)
+        )
+      );
+      const r = parentR.multiply(child.rotation);
+      const s = parentS.multiply(child.scale);
+      this._attachShape(owner, bodyData, child.shape, t, r, s);
+    }
+  }
+  // -------------------------------------------------------------------
+  // Constraint
+  // -------------------------------------------------------------------
+  initConstraint(constraint, body, childBody) {
+    const bodyDataA = this._getPluginData(body);
+    const bodyDataB = this._getPluginData(childBody);
+    const options = constraint.options;
+    const bodyPair = {
+      parentBody: body,
+      parentBodyIndex: 0,
+      childBody,
+      childBodyIndex: 0
+    };
+    const buildJoint = createJointFactory(
+      this.world,
+      bodyDataA.native,
+      bodyDataB.native,
+      constraint.type,
+      options
+    );
+    const pluginData = new Box3DConstraintPluginData(
+      constraint.type,
+      bodyPair,
+      buildJoint
+    );
+    pluginData.collideConnected = options.collision ?? false;
+    constraint._pluginData = pluginData;
+    pluginData.rebuild();
+  }
+  setEnabled(constraint, isEnabled) {
+    const data = this._getConstraintData(constraint);
+    data.enabled = isEnabled;
+    data.rebuild();
+  }
+  getEnabled(constraint) {
+    return this._getConstraintData(constraint).enabled;
+  }
+  setCollisionsEnabled(constraint, isEnabled) {
+    const data = this._getConstraintData(constraint);
+    data.collideConnected = isEnabled;
+    data.native?.setCollideConnected(isEnabled);
+  }
+  getCollisionsEnabled(constraint) {
+    return this._getConstraintData(constraint).collideConnected;
+  }
+  setAxisFriction(constraint, axis, friction) {
+    const data = this._getConstraintData(constraint);
+    data.axisFriction.set(axis, friction);
+    data.rebuild();
+  }
+  getAxisFriction(constraint, axis) {
+    return this._getConstraintData(constraint).axisFriction.get(axis) ?? null;
+  }
+  setAxisMode(constraint, axis, limitMode) {
+    const data = this._getConstraintData(constraint);
+    data.axisLimitMode.set(axis, limitMode);
+    data.rebuild();
+  }
+  getAxisMode(constraint, axis) {
+    return this._getConstraintData(constraint).axisLimitMode.get(axis) ?? null;
+  }
+  setAxisMinLimit(constraint, axis, minLimit) {
+    const data = this._getConstraintData(constraint);
+    data.axisMinLimit.set(axis, minLimit);
+    data.rebuild();
+  }
+  getAxisMinLimit(constraint, axis) {
+    return this._getConstraintData(constraint).axisMinLimit.get(axis) ?? null;
+  }
+  setAxisMaxLimit(constraint, axis, limit) {
+    const data = this._getConstraintData(constraint);
+    data.axisMaxLimit.set(axis, limit);
+    data.rebuild();
+  }
+  getAxisMaxLimit(constraint, axis) {
+    return this._getConstraintData(constraint).axisMaxLimit.get(axis) ?? null;
+  }
+  setAxisMotorType(constraint, axis, motorType) {
+    const data = this._getConstraintData(constraint);
+    data.axisMotorType.set(axis, motorType);
+    data.rebuild();
+  }
+  getAxisMotorType(constraint, axis) {
+    return this._getConstraintData(constraint).axisMotorType.get(axis) ?? null;
+  }
+  setAxisMotorTarget(constraint, axis, target) {
+    const data = this._getConstraintData(constraint);
+    data.axisMotorTarget.set(axis, target);
+    data.rebuild();
+  }
+  getAxisMotorTarget(constraint, axis) {
+    return this._getConstraintData(constraint).axisMotorTarget.get(axis) ?? null;
+  }
+  setAxisMotorMaxForce(constraint, axis, maxForce) {
+    const data = this._getConstraintData(constraint);
+    data.axisMotorMaxForce.set(axis, maxForce);
+    data.rebuild();
+  }
+  getAxisMotorMaxForce(constraint, axis) {
+    return this._getConstraintData(constraint).axisMotorMaxForce.get(axis) ?? null;
+  }
+  disposeConstraint(constraint) {
+    const data = this._getConstraintData(constraint);
+    if (data.native?.isValid()) {
+      data.native.destroy(true);
+    }
+    constraint._pluginData = null;
+  }
+  getBodiesUsingConstraint(constraint) {
+    return [this._getConstraintData(constraint).bodyPair];
+  }
+  _getConstraintData(constraint) {
+    const data = constraint._pluginData;
+    if (!data) {
+      throw new Error(
+        "Box3DPlugin: PhysicsConstraint has not been initialized by this plugin."
+      );
+    }
+    return data;
+  }
+  // -------------------------------------------------------------------
+  // Raycast
+  // -------------------------------------------------------------------
+  raycast(from, to, result, query) {
+    const target = Array.isArray(result) ? result[0] : result;
+    if (!target) {
+      return;
+    }
+    target.reset(from, to);
+    const translation = to.subtract(from);
+    const hit = this.world.castRayClosest(toB3Vec(from), toB3Vec(translation), {
+      categoryBits: query?.membership,
+      maskBits: query?.collideWith
+    });
+    if (!hit.hit || hit.shapeUserData === void 0) {
+      return;
+    }
+    const owner = this._shapeOwners.get(hit.shapeUserData);
+    if (query?.ignoreBody && owner?.body === query.ignoreBody) {
+      return;
+    }
+    target.body = owner?.body;
+    target.shape = owner?.shape;
+    if (hit.normal && hit.point) {
+      target.setHitData(hit.normal, hit.point);
+    }
+    if (hit.fraction !== void 0) {
+      target.setHitDistance(hit.fraction * translation.length());
+    }
+  }
+  dispose() {
+    for (const body of [...this._bodies.keys()]) {
+      this.disposeBody(body);
+    }
+    this._shapeOwners.clear();
+    this.onCollisionObservable.clear();
+    this.onCollisionEndedObservable.clear();
+    this.onTriggerCollisionObservable.clear();
+    if (this.world.isValid()) {
+      this.world.destroy();
+    }
+  }
+  // -------------------------------------------------------------------
+  // Event dispatch
+  // -------------------------------------------------------------------
+  _dispatchEvents() {
+    const contacts = this.world.getContactEvents();
+    for (const begin of contacts.begin) {
+      this._notifyCollision(
+        begin.shapeUserDataA,
+        begin.shapeUserDataB,
+        import_core.PhysicsEventType.COLLISION_STARTED,
+        null,
+        null,
+        0
+      );
+    }
+    for (const end of contacts.end) {
+      if (end.shapeUserDataA === null || end.shapeUserDataB === null) {
+        continue;
+      }
+      this._notifyCollisionEnded(end.shapeUserDataA, end.shapeUserDataB);
+    }
+    for (const hit of contacts.hit) {
+      this._notifyCollision(
+        hit.shapeUserDataA,
+        hit.shapeUserDataB,
+        import_core.PhysicsEventType.COLLISION_CONTINUED,
+        fromB3Vec(hit.point),
+        fromB3Vec(hit.normal),
+        hit.approachSpeed
+      );
+    }
+    const sensors = this.world.getSensorEvents();
+    for (const begin of sensors.begin) {
+      this._notifyTrigger(
+        begin.sensorUserData,
+        begin.visitorUserData,
+        import_core.PhysicsEventType.TRIGGER_ENTERED
+      );
+    }
+    for (const end of sensors.end) {
+      if (end.sensorUserData === null || end.visitorUserData === null) {
+        continue;
+      }
+      this._notifyTrigger(
+        end.sensorUserData,
+        end.visitorUserData,
+        import_core.PhysicsEventType.TRIGGER_EXITED
+      );
+    }
+  }
+  _notifyCollision(tagA, tagB, type, point, normal, impulse) {
+    const ownerA = this._shapeOwners.get(tagA);
+    const ownerB = this._shapeOwners.get(tagB);
+    if (!ownerA || !ownerB) {
+      return;
+    }
+    const dataA = this._bodies.get(ownerA.body);
+    const dataB = this._bodies.get(ownerB.body);
+    const event = {
+      collider: ownerA.body,
+      collidedAgainst: ownerB.body,
+      colliderIndex: 0,
+      collidedAgainstIndex: 0,
+      type,
+      point,
+      normal,
+      distance: 0,
+      impulse
+    };
+    if (dataA?.collisionCBEnabled) {
+      dataA.onCollisionObservable.notifyObservers(event);
+    }
+    if (dataB?.collisionCBEnabled) {
+      dataB.onCollisionObservable.notifyObservers({
+        ...event,
+        collider: ownerB.body,
+        collidedAgainst: ownerA.body
+      });
+    }
+    this.onCollisionObservable.notifyObservers(event);
+  }
+  _notifyCollisionEnded(tagA, tagB) {
+    const ownerA = this._shapeOwners.get(tagA);
+    const ownerB = this._shapeOwners.get(tagB);
+    if (!ownerA || !ownerB) {
+      return;
+    }
+    const dataA = this._bodies.get(ownerA.body);
+    const dataB = this._bodies.get(ownerB.body);
+    const event = {
+      collider: ownerA.body,
+      collidedAgainst: ownerB.body,
+      colliderIndex: 0,
+      collidedAgainstIndex: 0,
+      type: import_core.PhysicsEventType.COLLISION_FINISHED
+    };
+    if (dataA?.collisionEndedCBEnabled) {
+      dataA.onCollisionEndedObservable.notifyObservers(event);
+    }
+    if (dataB?.collisionEndedCBEnabled) {
+      dataB.onCollisionEndedObservable.notifyObservers({
+        ...event,
+        collider: ownerB.body,
+        collidedAgainst: ownerA.body
+      });
+    }
+    this.onCollisionEndedObservable.notifyObservers(event);
+  }
+  _notifyTrigger(sensorTag, visitorTag, type) {
+    const sensorOwner = this._shapeOwners.get(sensorTag);
+    const visitorOwner = this._shapeOwners.get(visitorTag);
+    if (!sensorOwner || !visitorOwner) {
+      return;
+    }
+    this.onTriggerCollisionObservable.notifyObservers({
+      collider: sensorOwner.body,
+      collidedAgainst: visitorOwner.body,
+      colliderIndex: 0,
+      collidedAgainstIndex: 0,
+      type
+    });
+  }
+};
+function toBox3DBodyType(motionType) {
+  switch (motionType) {
+    case import_core.PhysicsMotionType.DYNAMIC:
+      return "dynamic";
+    case import_core.PhysicsMotionType.ANIMATED:
+      return "kinematic";
+    case import_core.PhysicsMotionType.STATIC:
+    default:
+      return "static";
+  }
+}
+var _nextShapeTag = 1;
+function nextShapeTag() {
+  return _nextShapeTag++;
+}
+function Matrix_fromQuaternion(q) {
+  return q.toRotationMatrix(new import_core.Matrix());
+}
+function shapeTreeContains(root, target) {
+  if (root === target) {
+    return true;
+  }
+  const data = root._pluginData;
+  if (!data) {
+    return false;
+  }
+  return data.children.some(
+    (child) => shapeTreeContains(child.shape, target)
+  );
+}
+function computeLocalBounds(descriptor) {
+  const p = descriptor.parameters;
+  switch (descriptor.type) {
+    case import_core.PhysicsShapeType.BOX: {
+      const extents = p.extents ?? new import_core.Vector3(1, 1, 1);
+      const center = p.center ?? import_core.Vector3.Zero();
+      const half = extents.scale(0.5);
+      return { min: center.subtract(half), max: center.add(half) };
+    }
+    case import_core.PhysicsShapeType.SPHERE: {
+      const radius = p.radius ?? 0.5;
+      const center = p.center ?? import_core.Vector3.Zero();
+      const r = new import_core.Vector3(radius, radius, radius);
+      return { min: center.subtract(r), max: center.add(r) };
+    }
+    case import_core.PhysicsShapeType.CAPSULE: {
+      const radius = p.radius ?? 0.5;
+      const a = p.pointA ?? new import_core.Vector3(0, -0.5, 0);
+      const b = p.pointB ?? new import_core.Vector3(0, 0.5, 0);
+      const min = import_core.Vector3.Minimize(a, b).subtractFromFloats(
+        radius,
+        radius,
+        radius
+      );
+      const max = import_core.Vector3.Maximize(a, b).addInPlaceFromFloats(
+        radius,
+        radius,
+        radius
+      );
+      return { min, max };
+    }
+    case import_core.PhysicsShapeType.CONVEX_HULL: {
+      const points = extractHullPoints(p);
+      let min = points[0]?.clone() ?? import_core.Vector3.Zero();
+      let max = points[0]?.clone() ?? import_core.Vector3.Zero();
+      for (const point of points) {
+        min = import_core.Vector3.Minimize(min, point);
+        max = import_core.Vector3.Maximize(max, point);
+      }
+      return { min, max };
+    }
+    case import_core.PhysicsShapeType.CONTAINER: {
+      let min = new import_core.Vector3(Infinity, Infinity, Infinity);
+      let max = new import_core.Vector3(-Infinity, -Infinity, -Infinity);
+      for (const child of descriptor.children) {
+        const childData = child.shape._pluginData;
+        if (!childData) {
+          continue;
+        }
+        const childBounds = computeLocalBounds(childData);
+        const worldMin = import_core.Vector3.TransformCoordinates(
+          childBounds.min.multiply(child.scale),
+          Matrix_fromQuaternion(child.rotation)
+        ).add(child.translation);
+        const worldMax = import_core.Vector3.TransformCoordinates(
+          childBounds.max.multiply(child.scale),
+          Matrix_fromQuaternion(child.rotation)
+        ).add(child.translation);
+        min = import_core.Vector3.Minimize(min, import_core.Vector3.Minimize(worldMin, worldMax));
+        max = import_core.Vector3.Maximize(max, import_core.Vector3.Maximize(worldMin, worldMax));
+      }
+      return { min, max };
+    }
+    default:
+      return { min: import_core.Vector3.Zero(), max: import_core.Vector3.Zero() };
+  }
+}
+function extractHullPoints(parameters) {
+  if (!parameters.mesh) {
+    return [];
+  }
+  const positions = parameters.mesh.getVerticesData(import_core.VertexBuffer.PositionKind);
+  if (!positions) {
+    return [];
+  }
+  const points = [];
+  for (let i = 0; i < positions.length; i += 3) {
+    points.push(
+      new import_core.Vector3(
+        positions[i] ?? 0,
+        positions[i + 1] ?? 0,
+        positions[i + 2] ?? 0
+      )
+    );
+  }
+  return points;
+}
+function createNativeShape(nativeBody, descriptor, t, r, s) {
+  const p = descriptor.parameters;
+  const shared = {
+    density: descriptor.density,
+    friction: descriptor.material.friction ?? 0.5,
+    restitution: descriptor.material.restitution ?? 0,
+    isSensor: descriptor.isTrigger,
+    filter: {
+      categoryBits: descriptor.filterMembershipMask,
+      maskBits: descriptor.filterCollideMask
+    }
+  };
+  if (Math.abs(s.x - s.y) > 1e-4 || Math.abs(s.y - s.z) > 1e-4) {
+    console.warn(
+      "Box3DPlugin: non-uniform shape scaling is not supported; using the average scale factor."
+    );
+  }
+  const uniformScale = (s.x + s.y + s.z) / 3;
+  switch (descriptor.type) {
+    case import_core.PhysicsShapeType.BOX: {
+      const extents = (p.extents ?? new import_core.Vector3(1, 1, 1)).scale(uniformScale);
+      const center = (p.center ?? import_core.Vector3.Zero()).multiply(s);
+      const localT = t.add(
+        import_core.Vector3.TransformCoordinates(center, Matrix_fromQuaternion(r))
+      );
+      const localR = r.multiply(p.rotation ?? import_core.Quaternion.Identity());
+      return nativeBody.createBox({
+        ...shared,
+        halfExtents: toB3Vec(extents.scale(0.5)),
+        offset: toB3Vec(localT),
+        rotation: toB3Quat(localR)
+      });
+    }
+    case import_core.PhysicsShapeType.SPHERE: {
+      const center = (p.center ?? import_core.Vector3.Zero()).multiply(s);
+      const localT = t.add(
+        import_core.Vector3.TransformCoordinates(center, Matrix_fromQuaternion(r))
+      );
+      return nativeBody.createSphere({
+        ...shared,
+        radius: (p.radius ?? 0.5) * uniformScale,
+        center: toB3Vec(localT)
+      });
+    }
+    case import_core.PhysicsShapeType.CAPSULE: {
+      const a = (p.pointA ?? new import_core.Vector3(0, -0.5, 0)).multiply(s);
+      const b = (p.pointB ?? new import_core.Vector3(0, 0.5, 0)).multiply(s);
+      const worldA = t.add(
+        import_core.Vector3.TransformCoordinates(a, Matrix_fromQuaternion(r))
+      );
+      const worldB = t.add(
+        import_core.Vector3.TransformCoordinates(b, Matrix_fromQuaternion(r))
+      );
+      return nativeBody.createCapsule({
+        ...shared,
+        radius: (p.radius ?? 0.5) * uniformScale,
+        center1: toB3Vec(worldA),
+        center2: toB3Vec(worldB)
+      });
+    }
+    case import_core.PhysicsShapeType.CONVEX_HULL: {
+      const localPoints = extractHullPoints(p);
+      const worldPoints = localPoints.map(
+        (point) => t.add(
+          import_core.Vector3.TransformCoordinates(
+            point.multiply(s),
+            Matrix_fromQuaternion(r)
+          )
+        )
+      );
+      return nativeBody.createHull({
+        ...shared,
+        points: worldPoints.map(toB3Vec)
+      });
+    }
+    default:
+      throw new Error(
+        `Box3DPlugin: shape type ${import_core.PhysicsShapeType[descriptor.type]} is not supported by box3d-wasm.`
+      );
+  }
+}
+function createJointFactory(world, bodyA, bodyB, type, options) {
+  const anchorA = options.pivotA ? toB3Vec(options.pivotA) : void 0;
+  const anchorB = options.pivotB ? toB3Vec(options.pivotB) : void 0;
+  return (data) => {
+    const base = { anchorA, anchorB, collideConnected: data.collideConnected };
+    switch (type) {
+      case import_core.PhysicsConstraintType.BALL_AND_SOCKET: {
+        const twist = readLimit(data, import_core.PhysicsConstraintAxis.ANGULAR_X);
+        const motorSpeed = data.axisMotorTarget.get(
+          import_core.PhysicsConstraintAxis.ANGULAR_X
+        );
+        return world.createSphericalJoint(bodyA, bodyB, {
+          ...base,
+          enableTwistLimit: twist !== null,
+          lowerTwistAngle: twist?.min,
+          upperTwistAngle: twist?.max,
+          enableMotor: motorSpeed !== void 0,
+          motorVelocity: motorSpeed !== void 0 ? { x: motorSpeed, y: 0, z: 0 } : void 0,
+          maxMotorTorque: data.axisMotorMaxForce.get(
+            import_core.PhysicsConstraintAxis.ANGULAR_X
+          )
+        });
+      }
+      case import_core.PhysicsConstraintType.DISTANCE: {
+        const limit = readLimit(data, import_core.PhysicsConstraintAxis.LINEAR_DISTANCE);
+        const maxDistance = options.maxDistance ?? limit?.max ?? 0;
+        return world.createDistanceJoint(bodyA, bodyB, {
+          ...base,
+          length: maxDistance,
+          enableLimit: true,
+          minLength: limit?.min ?? 0,
+          maxLength: maxDistance,
+          enableMotor: data.axisMotorType.get(import_core.PhysicsConstraintAxis.LINEAR_DISTANCE) !== void 0,
+          motorSpeed: data.axisMotorTarget.get(
+            import_core.PhysicsConstraintAxis.LINEAR_DISTANCE
+          ),
+          maxMotorForce: data.axisMotorMaxForce.get(
+            import_core.PhysicsConstraintAxis.LINEAR_DISTANCE
+          )
+        });
+      }
+      case import_core.PhysicsConstraintType.HINGE: {
+        const localFrameA = {
+          rotation: toB3Quat(
+            quaternionFromXAxis(options.axisA ?? import_core.Vector3.Right())
+          )
+        };
+        const localFrameB = {
+          rotation: toB3Quat(
+            quaternionFromXAxis(options.axisB ?? import_core.Vector3.Right())
+          )
+        };
+        const limit = readLimit(data, import_core.PhysicsConstraintAxis.ANGULAR_X);
+        const motorType = data.axisMotorType.get(
+          import_core.PhysicsConstraintAxis.ANGULAR_X
+        );
+        const friction = data.axisFriction.get(import_core.PhysicsConstraintAxis.ANGULAR_X);
+        const useFrictionAsMotor = !motorType && friction !== void 0;
+        return world.createRevoluteJoint(bodyA, bodyB, {
+          ...base,
+          localFrameA,
+          localFrameB,
+          enableLimit: limit !== null,
+          lowerAngle: limit?.min,
+          upperAngle: limit?.max,
+          enableMotor: motorType !== void 0 || useFrictionAsMotor,
+          motorSpeed: useFrictionAsMotor ? 0 : data.axisMotorTarget.get(import_core.PhysicsConstraintAxis.ANGULAR_X),
+          maxMotorTorque: useFrictionAsMotor ? friction : data.axisMotorMaxForce.get(import_core.PhysicsConstraintAxis.ANGULAR_X)
+        });
+      }
+      case import_core.PhysicsConstraintType.SLIDER:
+      case import_core.PhysicsConstraintType.PRISMATIC: {
+        const localFrameA = {
+          rotation: toB3Quat(
+            quaternionFromXAxis(options.axisA ?? import_core.Vector3.Right())
+          )
+        };
+        const localFrameB = {
+          rotation: toB3Quat(
+            quaternionFromXAxis(options.axisB ?? import_core.Vector3.Right())
+          )
+        };
+        const limit = readLimit(data, import_core.PhysicsConstraintAxis.LINEAR_X);
+        return world.createPrismaticJoint(bodyA, bodyB, {
+          ...base,
+          localFrameA,
+          localFrameB,
+          enableLimit: limit !== null,
+          lowerTranslation: limit?.min,
+          upperTranslation: limit?.max,
+          enableMotor: data.axisMotorType.get(import_core.PhysicsConstraintAxis.LINEAR_X) !== void 0,
+          motorSpeed: data.axisMotorTarget.get(import_core.PhysicsConstraintAxis.LINEAR_X),
+          maxMotorForce: data.axisMotorMaxForce.get(
+            import_core.PhysicsConstraintAxis.LINEAR_X
+          )
+        });
+      }
+      case import_core.PhysicsConstraintType.LOCK:
+      case import_core.PhysicsConstraintType.SIX_DOF: {
+        if (type === import_core.PhysicsConstraintType.SIX_DOF) {
+          console.warn(
+            "Box3DPlugin: SIX_DOF constraints are approximated with a weld joint; per-axis limits/motors are tracked but not enforced."
+          );
+        }
+        return world.createWeldJoint(bodyA, bodyB, base);
+      }
+      default:
+        throw new Error(
+          `Box3DPlugin: constraint type ${import_core.PhysicsConstraintType[type]} is not supported.`
+        );
+    }
+  };
+}
+function readLimit(data, axis) {
+  const mode = data.axisLimitMode.get(axis);
+  if (mode === void 0 || mode === import_core.PhysicsConstraintAxisLimitMode.FREE) {
+    return null;
+  }
+  if (mode === import_core.PhysicsConstraintAxisLimitMode.LOCKED) {
+    return { min: 0, max: 0 };
+  }
+  return { min: data.axisMinLimit.get(axis), max: data.axisMaxLimit.get(axis) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Box3DPlugin
+});