@rapierphysicsplugin/client 1.0.0

package/src/rapier-constraint-ops.ts

@@ -0,0 +1,327 @@
+import type RAPIER from '@dimforge/rapier3d-compat';
+import {
+  PhysicsConstraintType,
+  PhysicsConstraintAxis,
+  PhysicsConstraintMotorType,
+} from '@babylonjs/core';
+import type {
+  PhysicsBody,
+  PhysicsConstraint,
+  PhysicsConstraintAxisLimitMode,
+  ConstrainedBodyPair,
+  Nullable,
+} from '@babylonjs/core';
+import type { ConstraintDescriptor } from '@rapierphysicsplugin/shared';
+import { createJointData } from '@rapierphysicsplugin/shared';
+import type { RapierPluginState, AxisConfig } from './rapier-types.js';
+import { v3toVec } from './rapier-types.js';
+
+export function buildConstraintDescriptor(constraint: PhysicsConstraint): ConstraintDescriptor {
+  const opts = (constraint as any)._options ?? {};
+  const cType = (constraint as any)._type as PhysicsConstraintType;
+
+  let type: ConstraintDescriptor['type'];
+  switch (cType) {
+    case PhysicsConstraintType.BALL_AND_SOCKET: type = 'ball_and_socket'; break;
+    case PhysicsConstraintType.DISTANCE: type = 'distance'; break;
+    case PhysicsConstraintType.HINGE: type = 'hinge'; break;
+    case PhysicsConstraintType.SLIDER: type = 'slider'; break;
+    case PhysicsConstraintType.LOCK: type = 'lock'; break;
+    case PhysicsConstraintType.PRISMATIC: type = 'prismatic'; break;
+    case PhysicsConstraintType.SIX_DOF: type = 'six_dof'; break;
+    default: type = 'ball_and_socket';
+  }
+
+  const sixDofLimits = (constraint as any).limits as Array<{ axis: number; minLimit?: number; maxLimit?: number; stiffness?: number; damping?: number }> | undefined;
+  let isSpring = false;
+  if (type === 'six_dof' && sixDofLimits) {
+    isSpring = sixDofLimits.some(l => l.stiffness !== undefined && l.stiffness > 0);
+  }
+
+  const desc: ConstraintDescriptor = {
+    id: '',
+    bodyIdA: '',
+    bodyIdB: '',
+    type: isSpring ? 'spring' : type,
+    pivotA: opts.pivotA ? v3toVec(opts.pivotA) : undefined,
+    pivotB: opts.pivotB ? v3toVec(opts.pivotB) : undefined,
+    axisA: opts.axisA ? v3toVec(opts.axisA) : undefined,
+    axisB: opts.axisB ? v3toVec(opts.axisB) : undefined,
+    perpAxisA: opts.perpAxisA ? v3toVec(opts.perpAxisA) : undefined,
+    perpAxisB: opts.perpAxisB ? v3toVec(opts.perpAxisB) : undefined,
+    maxDistance: opts.maxDistance,
+    collision: opts.collision,
+  };
+
+  if (isSpring && sixDofLimits) {
+    const springLimit = sixDofLimits.find(l => l.stiffness !== undefined);
+    if (springLimit) {
+      desc.stiffness = springLimit.stiffness;
+      desc.damping = springLimit.damping;
+    }
+  }
+
+  if (type === 'six_dof' && !isSpring && sixDofLimits) {
+    desc.limits = sixDofLimits.map(l => ({
+      axis: l.axis,
+      minLimit: l.minLimit,
+      maxLimit: l.maxLimit,
+    }));
+  }
+
+  return desc;
+}
+
+export function createJointFromConstraint(
+  state: RapierPluginState,
+  constraint: PhysicsConstraint,
+  rbA: RAPIER.RigidBody,
+  rbB: RAPIER.RigidBody,
+): RAPIER.ImpulseJoint {
+  const desc = buildConstraintDescriptor(constraint);
+  const jointData = createJointData(state.rapier, desc);
+  return state.world.createImpulseJoint(jointData, rbA, rbB, true);
+}
+
+export function initConstraint(
+  state: RapierPluginState,
+  constraint: PhysicsConstraint,
+  body: PhysicsBody,
+  childBody: PhysicsBody,
+): void {
+  if (state.constraintToJoint.has(constraint)) return;
+
+  const rbA = state.bodyToRigidBody.get(body);
+  const rbB = state.bodyToRigidBody.get(childBody);
+  if (!rbA || !rbB) return;
+
+  const joint = createJointFromConstraint(state, constraint, rbA, rbB);
+  state.constraintToJoint.set(constraint, joint);
+  state.constraintBodies.set(constraint, { body, childBody });
+  state.constraintEnabled.set(constraint, true);
+
+  const opts = (constraint as any)._options;
+  if (opts?.collision === false) {
+    joint.setContactsEnabled(false);
+  }
+
+  applyInitialLimits(constraint, joint);
+}
+
+function applyInitialLimits(constraint: PhysicsConstraint, joint: RAPIER.ImpulseJoint): void {
+  const sixDofLimits = (constraint as any).limits as Array<{ axis: number; minLimit?: number; maxLimit?: number }> | undefined;
+  if (!sixDofLimits) return;
+
+  const cType = (constraint as any)._type as PhysicsConstraintType;
+  if (cType === PhysicsConstraintType.HINGE) {
+    const angLim = sixDofLimits.find(l => l.axis === PhysicsConstraintAxis.ANGULAR_X);
+    if (angLim && angLim.minLimit !== undefined && angLim.maxLimit !== undefined) {
+      (joint as any).setLimits?.(angLim.minLimit, angLim.maxLimit);
+    }
+  } else if (cType === PhysicsConstraintType.SLIDER || cType === PhysicsConstraintType.PRISMATIC) {
+    const linLim = sixDofLimits.find(l => l.axis === PhysicsConstraintAxis.LINEAR_X);
+    if (linLim && linLim.minLimit !== undefined && linLim.maxLimit !== undefined) {
+      (joint as any).setLimits?.(linLim.minLimit, linLim.maxLimit);
+    }
+  }
+}
+
+export function disposeConstraint(state: RapierPluginState, constraint: PhysicsConstraint): void {
+  const joint = state.constraintToJoint.get(constraint);
+  if (joint) {
+    state.world.removeImpulseJoint(joint, true);
+    state.constraintToJoint.delete(constraint);
+  }
+  state.constraintBodies.delete(constraint);
+  state.constraintAxisState.delete(constraint);
+  state.constraintEnabled.delete(constraint);
+  state.constraintDescriptors.delete(constraint);
+}
+
+export function setEnabled(state: RapierPluginState, constraint: PhysicsConstraint, isEnabled: boolean): void {
+  const currentlyEnabled = state.constraintEnabled.get(constraint) ?? true;
+  if (isEnabled === currentlyEnabled) return;
+
+  if (!isEnabled) {
+    const joint = state.constraintToJoint.get(constraint);
+    if (joint) {
+      state.world.removeImpulseJoint(joint, true);
+      state.constraintToJoint.delete(constraint);
+    }
+    state.constraintEnabled.set(constraint, false);
+  } else {
+    const pair = state.constraintBodies.get(constraint);
+    if (pair) {
+      const rbA = state.bodyToRigidBody.get(pair.body);
+      const rbB = state.bodyToRigidBody.get(pair.childBody);
+      if (rbA && rbB) {
+        const joint = createJointFromConstraint(state, constraint, rbA, rbB);
+        state.constraintToJoint.set(constraint, joint);
+
+        const opts = (constraint as any)._options;
+        if (opts?.collision === false) {
+          joint.setContactsEnabled(false);
+        }
+      }
+    }
+    state.constraintEnabled.set(constraint, true);
+  }
+}
+
+export function getEnabled(state: RapierPluginState, constraint: PhysicsConstraint): boolean {
+  return state.constraintEnabled.get(constraint) ?? true;
+}
+
+export function setCollisionsEnabled(state: RapierPluginState, constraint: PhysicsConstraint, isEnabled: boolean): void {
+  const joint = state.constraintToJoint.get(constraint);
+  if (joint) {
+    joint.setContactsEnabled(isEnabled);
+  }
+}
+
+export function getCollisionsEnabled(state: RapierPluginState, constraint: PhysicsConstraint): boolean {
+  const joint = state.constraintToJoint.get(constraint);
+  if (joint) {
+    return joint.contactsEnabled();
+  }
+  return true;
+}
+
+function ensureAxisConfig(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): AxisConfig {
+  let axisMap = state.constraintAxisState.get(constraint);
+  if (!axisMap) {
+    axisMap = new Map();
+    state.constraintAxisState.set(constraint, axisMap);
+  }
+  let config = axisMap.get(axis);
+  if (!config) {
+    config = {};
+    axisMap.set(axis, config);
+  }
+  return config;
+}
+
+function getAxisConfig(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): AxisConfig | undefined {
+  return state.constraintAxisState.get(constraint)?.get(axis);
+}
+
+export function setAxisFriction(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, friction: number): void {
+  ensureAxisConfig(state, constraint, axis).friction = friction;
+}
+
+export function getAxisFriction(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number> {
+  return getAxisConfig(state, constraint, axis)?.friction ?? null;
+}
+
+export function setAxisMode(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, limitMode: PhysicsConstraintAxisLimitMode): void {
+  ensureAxisConfig(state, constraint, axis).mode = limitMode;
+  applyAxisLimitsToJoint(state, constraint);
+}
+
+export function getAxisMode(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<PhysicsConstraintAxisLimitMode> {
+  return getAxisConfig(state, constraint, axis)?.mode ?? null;
+}
+
+export function setAxisMinLimit(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, minLimit: number): void {
+  ensureAxisConfig(state, constraint, axis).minLimit = minLimit;
+  applyAxisLimitsToJoint(state, constraint);
+}
+
+export function getAxisMinLimit(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number> {
+  return getAxisConfig(state, constraint, axis)?.minLimit ?? null;
+}
+
+export function setAxisMaxLimit(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, limit: number): void {
+  ensureAxisConfig(state, constraint, axis).maxLimit = limit;
+  applyAxisLimitsToJoint(state, constraint);
+}
+
+export function getAxisMaxLimit(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number> {
+  return getAxisConfig(state, constraint, axis)?.maxLimit ?? null;
+}
+
+function applyAxisLimitsToJoint(state: RapierPluginState, constraint: PhysicsConstraint): void {
+  const joint = state.constraintToJoint.get(constraint);
+  if (!joint) return;
+
+  const cType = (constraint as any)._type as PhysicsConstraintType;
+
+  if (cType === PhysicsConstraintType.HINGE) {
+    const angConfig = getAxisConfig(state, constraint, PhysicsConstraintAxis.ANGULAR_X);
+    if (angConfig?.minLimit !== undefined && angConfig?.maxLimit !== undefined) {
+      (joint as any).setLimits?.(angConfig.minLimit, angConfig.maxLimit);
+    }
+  } else if (cType === PhysicsConstraintType.SLIDER || cType === PhysicsConstraintType.PRISMATIC) {
+    const linConfig = getAxisConfig(state, constraint, PhysicsConstraintAxis.LINEAR_X);
+    if (linConfig?.minLimit !== undefined && linConfig?.maxLimit !== undefined) {
+      (joint as any).setLimits?.(linConfig.minLimit, linConfig.maxLimit);
+    }
+  }
+}
+
+export function setAxisMotorType(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, motorType: PhysicsConstraintMotorType): void {
+  ensureAxisConfig(state, constraint, axis).motorType = motorType;
+  applyMotorToJoint(state, constraint);
+}
+
+export function getAxisMotorType(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<PhysicsConstraintMotorType> {
+  return getAxisConfig(state, constraint, axis)?.motorType ?? null;
+}
+
+export function setAxisMotorTarget(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, target: number): void {
+  ensureAxisConfig(state, constraint, axis).motorTarget = target;
+  applyMotorToJoint(state, constraint);
+}
+
+export function getAxisMotorTarget(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number> {
+  return getAxisConfig(state, constraint, axis)?.motorTarget ?? null;
+}
+
+export function setAxisMotorMaxForce(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, maxForce: number): void {
+  ensureAxisConfig(state, constraint, axis).motorMaxForce = maxForce;
+  applyMotorToJoint(state, constraint);
+}
+
+export function getAxisMotorMaxForce(state: RapierPluginState, constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number> {
+  return getAxisConfig(state, constraint, axis)?.motorMaxForce ?? null;
+}
+
+function applyMotorToJoint(state: RapierPluginState, constraint: PhysicsConstraint): void {
+  const joint = state.constraintToJoint.get(constraint);
+  if (!joint) return;
+
+  const cType = (constraint as any)._type as PhysicsConstraintType;
+
+  if (cType === PhysicsConstraintType.HINGE) {
+    const config = getAxisConfig(state, constraint, PhysicsConstraintAxis.ANGULAR_X);
+    if (config?.motorTarget !== undefined) {
+      const maxForce = config.motorMaxForce ?? 1000;
+      if (config.motorType === PhysicsConstraintMotorType.VELOCITY) {
+        (joint as any).configureMotorVelocity?.(config.motorTarget, maxForce);
+      } else {
+        (joint as any).configureMotorPosition?.(config.motorTarget, maxForce, 0);
+      }
+    }
+  } else if (cType === PhysicsConstraintType.SLIDER || cType === PhysicsConstraintType.PRISMATIC) {
+    const config = getAxisConfig(state, constraint, PhysicsConstraintAxis.LINEAR_X);
+    if (config?.motorTarget !== undefined) {
+      const maxForce = config.motorMaxForce ?? 1000;
+      if (config.motorType === PhysicsConstraintMotorType.VELOCITY) {
+        (joint as any).configureMotorVelocity?.(config.motorTarget, maxForce);
+      } else {
+        (joint as any).configureMotorPosition?.(config.motorTarget, maxForce, 0);
+      }
+    }
+  }
+}
+
+export function getBodiesUsingConstraint(state: RapierPluginState, constraint: PhysicsConstraint): ConstrainedBodyPair[] {
+  const pair = state.constraintBodies.get(constraint);
+  if (!pair) return [];
+  return [{
+    parentBody: pair.body,
+    parentBodyIndex: 0,
+    childBody: pair.childBody,
+    childBodyIndex: 0,
+  }];
+}

package/src/rapier-plugin.ts

@@ -0,0 +1,364 @@
+import type RAPIER from '@dimforge/rapier3d-compat';
+import {
+  Vector3,
+  Quaternion,
+  Observable,
+} from '@babylonjs/core';
+import type {
+  IPhysicsEnginePluginV2,
+  PhysicsBody,
+  PhysicsShape,
+  PhysicsConstraint,
+  PhysicsMassProperties,
+  PhysicsMaterial,
+  PhysicsShapeParameters,
+  PhysicsRaycastResult,
+  IRaycastQuery,
+  IPhysicsCollisionEvent,
+  IBasePhysicsCollisionEvent,
+  ConstrainedBodyPair,
+  BoundingBox,
+} from '@babylonjs/core';
+import type {
+  PhysicsMotionType,
+  PhysicsShapeType,
+  PhysicsConstraintAxisLimitMode,
+  PhysicsConstraintMotorType,
+  PhysicsConstraintAxis,
+} from '@babylonjs/core';
+import type { Mesh, TransformNode, Nullable } from '@babylonjs/core';
+import type { CollisionEventData } from '@rapierphysicsplugin/shared';
+import type { AxisConfig } from './rapier-types.js';
+
+import { processCollisionEvents, injectCollisionEvents } from './rapier-collision-ops.js';
+import * as bodyOps from './rapier-body-ops.js';
+import * as shapeOps from './rapier-shape-ops.js';
+import * as constraintOps from './rapier-constraint-ops.js';
+
+export class RapierPlugin implements IPhysicsEnginePluginV2 {
+  public world: RAPIER.World;
+  public name = 'RapierPlugin';
+  public onCollisionObservable = new Observable<IPhysicsCollisionEvent>();
+  public onCollisionEndedObservable = new Observable<IBasePhysicsCollisionEvent>();
+  public onTriggerCollisionObservable = new Observable<IBasePhysicsCollisionEvent>();
+
+  public rapier: typeof RAPIER;
+  public bodyToRigidBody = new Map<PhysicsBody, RAPIER.RigidBody>();
+  public bodyToColliders = new Map<PhysicsBody, RAPIER.Collider[]>();
+  public shapeToColliderDesc = new Map<PhysicsShape, RAPIER.ColliderDesc>();
+  public shapeTypeMap = new Map<PhysicsShape, PhysicsShapeType>();
+  public shapeMaterialMap = new Map<PhysicsShape, PhysicsMaterial>();
+  public shapeDensityMap = new Map<PhysicsShape, number>();
+  public shapeFilterMembership = new Map<PhysicsShape, number>();
+  public shapeFilterCollide = new Map<PhysicsShape, number>();
+  public bodyCollisionObservables = new Map<PhysicsBody, Observable<IPhysicsCollisionEvent>>();
+  public bodyCollisionEndedObservables = new Map<PhysicsBody, Observable<IBasePhysicsCollisionEvent>>();
+  public constraintToJoint = new Map<PhysicsConstraint, RAPIER.ImpulseJoint>();
+  public constraintBodies = new Map<PhysicsConstraint, { body: PhysicsBody; childBody: PhysicsBody }>();
+  public constraintAxisState = new Map<PhysicsConstraint, Map<number, AxisConfig>>();
+  public constraintEnabled = new Map<PhysicsConstraint, boolean>();
+  public constraintDescriptors = new Map<PhysicsConstraint, { body: PhysicsBody; childBody: PhysicsBody }>();
+  public collisionCallbackEnabled = new Set<PhysicsBody>();
+  public collisionEndedCallbackEnabled = new Set<PhysicsBody>();
+  public triggerShapes = new Set<PhysicsShape>();
+  public bodyIdToPhysicsBody = new Map<string, PhysicsBody>();
+  private maxLinearVelocity = 200;
+  private maxAngularVelocity = 200;
+
+  public bodyToShape = new Map<PhysicsBody, PhysicsShape>();
+  public shapeToBody = new Map<PhysicsShape, PhysicsBody>();
+  public compoundChildren = new Map<PhysicsShape, Array<{ child: PhysicsShape; translation?: Vector3; rotation?: Quaternion; scale?: Vector3 }>>();
+  public bodyEventMask = new Map<PhysicsBody, number>();
+  public eventQueue!: RAPIER.EventQueue;
+  public colliderHandleToBody = new Map<number, PhysicsBody>();
+
+  constructor(rapier: typeof RAPIER, gravity?: Vector3) {
+    this.rapier = rapier;
+    const g = gravity ?? new Vector3(0, -9.81, 0);
+    this.world = new rapier.World(new rapier.Vector3(g.x, g.y, g.z));
+    this.eventQueue = new rapier.EventQueue(false);
+  }
+
+  // --- Core ---
+
+  getPluginVersion(): number { return 2; }
+
+  setGravity(gravity: Vector3): void {
+    this.world.gravity = new this.rapier.Vector3(gravity.x, gravity.y, gravity.z);
+  }
+
+  setTimeStep(timeStep: number): void { this.world.timestep = timeStep; }
+  getTimeStep(): number { return this.world.timestep; }
+
+  setVelocityLimits(maxLinearVelocity: number, maxAngularVelocity: number): void {
+    this.maxLinearVelocity = maxLinearVelocity;
+    this.maxAngularVelocity = maxAngularVelocity;
+  }
+
+  getMaxLinearVelocity(): number { return this.maxLinearVelocity; }
+  getMaxAngularVelocity(): number { return this.maxAngularVelocity; }
+
+  executeStep(_delta: number, bodies: Array<PhysicsBody>): void {
+    this.world.step(this.eventQueue);
+    processCollisionEvents(this, this.eventQueue);
+    for (const body of bodies) {
+      this.sync(body);
+    }
+  }
+
+  // --- Body lifecycle ---
+
+  initBody(body: PhysicsBody, motionType: PhysicsMotionType, position: Vector3, orientation: Quaternion): void {
+    bodyOps.initBody(this, body, motionType, position, orientation);
+  }
+
+  initBodyInstances(_body: PhysicsBody, _motionType: PhysicsMotionType, _mesh: Mesh): void {}
+  updateBodyInstances(_body: PhysicsBody, _mesh: Mesh): void {}
+
+  removeBody(body: PhysicsBody): void { this.disposeBody(body); }
+  disposeBody(body: PhysicsBody): void { bodyOps.disposeBody(this, body); }
+
+  sync(body: PhysicsBody): void { bodyOps.syncBody(this, body); }
+  syncTransform(body: PhysicsBody, transformNode: TransformNode): void { bodyOps.syncTransform(this, body, transformNode); }
+
+  // --- Shape management ---
+
+  initShape(shape: PhysicsShape, type: PhysicsShapeType, options: PhysicsShapeParameters): void {
+    shapeOps.initShape(this, shape, type, options);
+  }
+
+  setShape(body: PhysicsBody, shape: Nullable<PhysicsShape>): void { shapeOps.setShape(this, body, shape); }
+  getShape(body: PhysicsBody): Nullable<PhysicsShape> { return this.bodyToShape.get(body) ?? null; }
+  getShapeType(shape: PhysicsShape): PhysicsShapeType { return this.shapeTypeMap.get(shape) as PhysicsShapeType; }
+  disposeShape(shape: PhysicsShape): void { shapeOps.disposeShape(this, shape); }
+
+  // --- Shape filtering ---
+
+  setShapeFilterMembershipMask(shape: PhysicsShape, membershipMask: number): void { shapeOps.setShapeFilterMembershipMask(this, shape, membershipMask); }
+  getShapeFilterMembershipMask(shape: PhysicsShape): number { return shapeOps.getShapeFilterMembershipMask(this, shape); }
+  setShapeFilterCollideMask(shape: PhysicsShape, collideMask: number): void { shapeOps.setShapeFilterCollideMask(this, shape, collideMask); }
+  getShapeFilterCollideMask(shape: PhysicsShape): number { return shapeOps.getShapeFilterCollideMask(this, shape); }
+
+  // --- Shape material ---
+
+  setMaterial(shape: PhysicsShape, material: PhysicsMaterial): void { shapeOps.setMaterial(this, shape, material); }
+  getMaterial(shape: PhysicsShape): PhysicsMaterial { return shapeOps.getMaterial(this, shape); }
+  setDensity(shape: PhysicsShape, density: number): void { shapeOps.setDensity(this, shape, density); }
+  getDensity(shape: PhysicsShape): number { return shapeOps.getDensity(this, shape); }
+
+  // --- Compound shapes ---
+
+  addChild(shape: PhysicsShape, newChild: PhysicsShape, translation?: Vector3, rotation?: Quaternion, scale?: Vector3): void {
+    shapeOps.addChild(this, shape, newChild, translation, rotation, scale);
+  }
+  removeChild(shape: PhysicsShape, childIndex: number): void { shapeOps.removeChild(this, shape, childIndex); }
+  getNumChildren(shape: PhysicsShape): number { return shapeOps.getNumChildren(this, shape); }
+
+  // --- Bounding box ---
+
+  getBoundingBox(shape: PhysicsShape): BoundingBox { return shapeOps.getBoundingBox(this, shape); }
+  getBodyBoundingBox(body: PhysicsBody): BoundingBox { return shapeOps.getBodyBoundingBox(this, body); }
+
+  // --- Triggers & collision callbacks ---
+
+  setTrigger(shape: PhysicsShape, isTrigger: boolean): void { shapeOps.setTrigger(this, shape, isTrigger); }
+
+  setCollisionCallbackEnabled(body: PhysicsBody, enabled: boolean, _instanceIndex?: number): void {
+    if (enabled) { this.collisionCallbackEnabled.add(body); } else { this.collisionCallbackEnabled.delete(body); }
+  }
+
+  setCollisionEndedCallbackEnabled(body: PhysicsBody, enabled: boolean, _instanceIndex?: number): void {
+    if (enabled) { this.collisionEndedCallbackEnabled.add(body); } else { this.collisionEndedCallbackEnabled.delete(body); }
+  }
+
+  // --- Event mask ---
+
+  setEventMask(body: PhysicsBody, eventMask: number, _instanceIndex?: number): void { this.bodyEventMask.set(body, eventMask); }
+  getEventMask(body: PhysicsBody, _instanceIndex?: number): number { return this.bodyEventMask.get(body) ?? 0; }
+
+  // --- Motion type ---
+
+  setMotionType(body: PhysicsBody, motionType: PhysicsMotionType, _instanceIndex?: number): void { bodyOps.setMotionType(this, body, motionType); }
+  getMotionType(body: PhysicsBody, _instanceIndex?: number): PhysicsMotionType { return bodyOps.getMotionType(this, body); }
+
+  // --- Mass properties ---
+
+  computeMassProperties(body: PhysicsBody, _instanceIndex?: number): PhysicsMassProperties { return bodyOps.computeMassProperties(this, body); }
+  setMassProperties(body: PhysicsBody, massProps: PhysicsMassProperties, _instanceIndex?: number): void { bodyOps.setMassProperties(this, body, massProps); }
+  getMassProperties(body: PhysicsBody, _instanceIndex?: number): PhysicsMassProperties { return bodyOps.getMassProperties(this, body); }
+
+  // --- Damping ---
+
+  setLinearDamping(body: PhysicsBody, damping: number, _instanceIndex?: number): void { bodyOps.setLinearDamping(this, body, damping); }
+  getLinearDamping(body: PhysicsBody, _instanceIndex?: number): number { return bodyOps.getLinearDamping(this, body); }
+  setAngularDamping(body: PhysicsBody, damping: number, _instanceIndex?: number): void { bodyOps.setAngularDamping(this, body, damping); }
+  getAngularDamping(body: PhysicsBody, _instanceIndex?: number): number { return bodyOps.getAngularDamping(this, body); }
+
+  // --- Velocity ---
+
+  setLinearVelocity(body: PhysicsBody, linVel: Vector3, _instanceIndex?: number): void { bodyOps.setLinearVelocity(this, body, linVel); }
+  getLinearVelocityToRef(body: PhysicsBody, linVel: Vector3, _instanceIndex?: number): void { bodyOps.getLinearVelocityToRef(this, body, linVel); }
+  setAngularVelocity(body: PhysicsBody, angVel: Vector3, _instanceIndex?: number): void { bodyOps.setAngularVelocity(this, body, angVel); }
+  getAngularVelocityToRef(body: PhysicsBody, angVel: Vector3, _instanceIndex?: number): void { bodyOps.getAngularVelocityToRef(this, body, angVel); }
+
+  // --- Forces & impulses ---
+
+  applyImpulse(body: PhysicsBody, impulse: Vector3, location: Vector3, _instanceIndex?: number): void { bodyOps.applyImpulse(this, body, impulse, location); }
+  applyAngularImpulse(body: PhysicsBody, angularImpulse: Vector3, _instanceIndex?: number): void { bodyOps.applyAngularImpulse(this, body, angularImpulse); }
+  applyForce(body: PhysicsBody, force: Vector3, location: Vector3, _instanceIndex?: number): void { bodyOps.applyForce(this, body, force, location); }
+
+  // --- Gravity factor ---
+
+  setGravityFactor(body: PhysicsBody, factor: number, _instanceIndex?: number): void { bodyOps.setGravityFactor(this, body, factor); }
+  getGravityFactor(body: PhysicsBody, _instanceIndex?: number): number { return bodyOps.getGravityFactor(this, body); }
+
+  // --- Target transform (kinematic) ---
+
+  setTargetTransform(body: PhysicsBody, position: Vector3, rotation: Quaternion, _instanceIndex?: number): void {
+    bodyOps.setTargetTransform(this, body, position, rotation);
+  }
+
+  // --- Body geometry ---
+
+  getBodyGeometry(_body: PhysicsBody): {} { return {}; }
+
+  // --- Constraints ---
+
+  initConstraint(constraint: PhysicsConstraint, body: PhysicsBody, childBody: PhysicsBody): void {
+    constraintOps.initConstraint(this, constraint, body, childBody);
+  }
+
+  addConstraint(body: PhysicsBody, childBody: PhysicsBody, constraint: PhysicsConstraint, _instanceIndex?: number, _childInstanceIndex?: number): void {
+    if (!this.constraintToJoint.has(constraint)) {
+      this.initConstraint(constraint, body, childBody);
+    }
+  }
+
+  disposeConstraint(constraint: PhysicsConstraint): void { constraintOps.disposeConstraint(this, constraint); }
+  setEnabled(constraint: PhysicsConstraint, isEnabled: boolean): void { constraintOps.setEnabled(this, constraint, isEnabled); }
+  getEnabled(constraint: PhysicsConstraint): boolean { return constraintOps.getEnabled(this, constraint); }
+  setCollisionsEnabled(constraint: PhysicsConstraint, isEnabled: boolean): void { constraintOps.setCollisionsEnabled(this, constraint, isEnabled); }
+  getCollisionsEnabled(constraint: PhysicsConstraint): boolean { return constraintOps.getCollisionsEnabled(this, constraint); }
+
+  setAxisFriction(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, friction: number): void { constraintOps.setAxisFriction(this, constraint, axis, friction); }
+  getAxisFriction(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number> { return constraintOps.getAxisFriction(this, constraint, axis); }
+  setAxisMode(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, limitMode: PhysicsConstraintAxisLimitMode): void { constraintOps.setAxisMode(this, constraint, axis, limitMode); }
+  getAxisMode(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<PhysicsConstraintAxisLimitMode> { return constraintOps.getAxisMode(this, constraint, axis); }
+  setAxisMinLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, minLimit: number): void { constraintOps.setAxisMinLimit(this, constraint, axis, minLimit); }
+  getAxisMinLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number> { return constraintOps.getAxisMinLimit(this, constraint, axis); }
+  setAxisMaxLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, limit: number): void { constraintOps.setAxisMaxLimit(this, constraint, axis, limit); }
+  getAxisMaxLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number> { return constraintOps.getAxisMaxLimit(this, constraint, axis); }
+  setAxisMotorType(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, motorType: PhysicsConstraintMotorType): void { constraintOps.setAxisMotorType(this, constraint, axis, motorType); }
+  getAxisMotorType(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<PhysicsConstraintMotorType> { return constraintOps.getAxisMotorType(this, constraint, axis); }
+  setAxisMotorTarget(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, target: number): void { constraintOps.setAxisMotorTarget(this, constraint, axis, target); }
+  getAxisMotorTarget(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number> { return constraintOps.getAxisMotorTarget(this, constraint, axis); }
+  setAxisMotorMaxForce(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, maxForce: number): void { constraintOps.setAxisMotorMaxForce(this, constraint, axis, maxForce); }
+  getAxisMotorMaxForce(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number> { return constraintOps.getAxisMotorMaxForce(this, constraint, axis); }
+
+  getBodiesUsingConstraint(constraint: PhysicsConstraint): ConstrainedBodyPair[] { return constraintOps.getBodiesUsingConstraint(this, constraint); }
+
+  // --- Collision observables ---
+
+  getCollisionObservable(body: PhysicsBody, _instanceIndex?: number): Observable<IPhysicsCollisionEvent> {
+    let obs = this.bodyCollisionObservables.get(body);
+    if (!obs) {
+      obs = new Observable<IPhysicsCollisionEvent>();
+      this.bodyCollisionObservables.set(body, obs);
+    }
+    return obs;
+  }
+
+  getCollisionEndedObservable(body: PhysicsBody, _instanceIndex?: number): Observable<IBasePhysicsCollisionEvent> {
+    let obs = this.bodyCollisionEndedObservables.get(body);
+    if (!obs) {
+      obs = new Observable<IBasePhysicsCollisionEvent>();
+      this.bodyCollisionEndedObservables.set(body, obs);
+    }
+    return obs;
+  }
+
+  // --- Raycast ---
+
+  raycast(from: Vector3, to: Vector3, result: PhysicsRaycastResult, _query?: IRaycastQuery): void {
+    const dir = to.subtract(from);
+    const maxToi = dir.length();
+    const normalizedDir = dir.normalize();
+
+    const ray = new this.rapier.Ray(
+      new this.rapier.Vector3(from.x, from.y, from.z),
+      new this.rapier.Vector3(normalizedDir.x, normalizedDir.y, normalizedDir.z)
+    );
+
+    const hit = this.world.castRayAndGetNormal(ray, maxToi, true);
+    if (hit) {
+      const hitPoint = ray.pointAt(hit.timeOfImpact);
+      const hitNormal = hit.normal;
+      result.setHitData(
+        new Vector3(hitNormal.x, hitNormal.y, hitNormal.z),
+        new Vector3(hitPoint.x, hitPoint.y, hitPoint.z)
+      );
+      result.calculateHitDistance();
+    }
+  }
+
+  // --- Dispose ---
+
+  dispose(): void {
+    this.eventQueue.free();
+    this.world.free();
+    this.bodyToRigidBody.clear();
+    this.bodyToColliders.clear();
+    this.shapeToColliderDesc.clear();
+    this.shapeTypeMap.clear();
+    this.constraintToJoint.clear();
+    this.constraintBodies.clear();
+    this.constraintAxisState.clear();
+    this.constraintEnabled.clear();
+    this.constraintDescriptors.clear();
+    this.collisionCallbackEnabled.clear();
+    this.collisionEndedCallbackEnabled.clear();
+    this.triggerShapes.clear();
+    this.bodyIdToPhysicsBody.clear();
+    this.bodyToShape.clear();
+    this.shapeToBody.clear();
+    this.compoundChildren.clear();
+    this.bodyEventMask.clear();
+    this.colliderHandleToBody.clear();
+    this.shapeFilterMembership.clear();
+    this.shapeFilterCollide.clear();
+  }
+
+  // --- Rapier-specific helpers for sync module ---
+
+  getRigidBody(body: PhysicsBody): RAPIER.RigidBody | undefined {
+    return this.bodyToRigidBody.get(body);
+  }
+
+  setBodyTranslation(body: PhysicsBody, position: Vector3): void {
+    const rb = this.bodyToRigidBody.get(body);
+    if (rb) {
+      rb.setTranslation(new this.rapier.Vector3(position.x, position.y, position.z), true);
+    }
+  }
+
+  setBodyRotation(body: PhysicsBody, rotation: Quaternion): void {
+    const rb = this.bodyToRigidBody.get(body);
+    if (rb) {
+      rb.setRotation(new this.rapier.Quaternion(rotation.x, rotation.y, rotation.z, rotation.w), true);
+    }
+  }
+
+  // --- Server collision event injection ---
+
+  registerBodyId(bodyId: string, body: PhysicsBody): void {
+    this.bodyIdToPhysicsBody.set(bodyId, body);
+  }
+
+  unregisterBodyId(bodyId: string): void {
+    this.bodyIdToPhysicsBody.delete(bodyId);
+  }
+
+  injectCollisionEvents(events: CollisionEventData[]): void {
+    injectCollisionEvents(this, events);
+  }
+}