@rapierphysicsplugin/client 1.0.0

package/src/rapier-shape-ops.ts

@@ -0,0 +1,369 @@
+import type RAPIER from '@dimforge/rapier3d-compat';
+import { Vector3, BoundingBox, PhysicsShapeType } from '@babylonjs/core';
+import type {
+  PhysicsBody,
+  PhysicsShape,
+  PhysicsShapeParameters,
+  PhysicsMaterial,
+  Nullable,
+  Quaternion,
+} from '@babylonjs/core';
+import type { RapierPluginState } from './rapier-types.js';
+
+export function initShape(state: RapierPluginState, shape: PhysicsShape, type: PhysicsShapeType, options: PhysicsShapeParameters): void {
+  let colliderDesc: RAPIER.ColliderDesc;
+
+  switch (type) {
+    case PhysicsShapeType.BOX: {
+      const ext = options.extents ?? new Vector3(1, 1, 1);
+      colliderDesc = state.rapier.ColliderDesc.cuboid(ext.x / 2, ext.y / 2, ext.z / 2);
+      break;
+    }
+    case PhysicsShapeType.SPHERE: {
+      const r = options.radius ?? 0.5;
+      colliderDesc = state.rapier.ColliderDesc.ball(r);
+      break;
+    }
+    case PhysicsShapeType.CAPSULE: {
+      const pointA = options.pointA ?? new Vector3(0, 0, 0);
+      const pointB = options.pointB ?? new Vector3(0, 1, 0);
+      const halfHeight = Vector3.Distance(pointA, pointB) / 2;
+      const radius = options.radius ?? 0.5;
+      colliderDesc = state.rapier.ColliderDesc.capsule(halfHeight, radius);
+      break;
+    }
+    case PhysicsShapeType.CYLINDER: {
+      const pointA = options.pointA ?? new Vector3(0, 0, 0);
+      const pointB = options.pointB ?? new Vector3(0, 1, 0);
+      const halfHeight = Vector3.Distance(pointA, pointB) / 2;
+      const radius = options.radius ?? 0.5;
+      colliderDesc = state.rapier.ColliderDesc.cylinder(halfHeight, radius);
+      break;
+    }
+    case PhysicsShapeType.MESH: {
+      const mesh = options.mesh;
+      if (mesh) {
+        const positions = mesh.getVerticesData('position');
+        const indices = mesh.getIndices();
+        if (positions && indices) {
+          colliderDesc = state.rapier.ColliderDesc.trimesh(
+            new Float32Array(positions),
+            new Uint32Array(indices)
+          );
+        } else {
+          colliderDesc = state.rapier.ColliderDesc.ball(0.5);
+        }
+      } else {
+        colliderDesc = state.rapier.ColliderDesc.ball(0.5);
+      }
+      break;
+    }
+    case PhysicsShapeType.CONVEX_HULL: {
+      const mesh = options.mesh;
+      if (mesh) {
+        const positions = mesh.getVerticesData('position');
+        if (positions) {
+          const desc = state.rapier.ColliderDesc.convexHull(new Float32Array(positions));
+          colliderDesc = desc ?? state.rapier.ColliderDesc.ball(0.5);
+        } else {
+          colliderDesc = state.rapier.ColliderDesc.ball(0.5);
+        }
+      } else {
+        colliderDesc = state.rapier.ColliderDesc.ball(0.5);
+      }
+      break;
+    }
+    case PhysicsShapeType.CONTAINER: {
+      colliderDesc = state.rapier.ColliderDesc.ball(0.001);
+      break;
+    }
+    case PhysicsShapeType.HEIGHTFIELD: {
+      const heights = options.heightFieldData;
+      const nrows = (options.numHeightFieldSamplesX ?? 2) - 1;
+      const ncols = (options.numHeightFieldSamplesZ ?? 2) - 1;
+      const sizeX = options.heightFieldSizeX ?? 1;
+      const sizeZ = options.heightFieldSizeZ ?? 1;
+      if (heights) {
+        colliderDesc = state.rapier.ColliderDesc.heightfield(
+          nrows,
+          ncols,
+          heights,
+          new state.rapier.Vector3(sizeX, 1, sizeZ)
+        );
+      } else {
+        colliderDesc = state.rapier.ColliderDesc.ball(0.5);
+      }
+      break;
+    }
+    default:
+      colliderDesc = state.rapier.ColliderDesc.ball(0.5);
+  }
+
+  state.shapeToColliderDesc.set(shape, colliderDesc);
+  state.shapeTypeMap.set(shape, type);
+}
+
+export function setShape(state: RapierPluginState, body: PhysicsBody, shape: Nullable<PhysicsShape>): void {
+  const rb = state.bodyToRigidBody.get(body);
+  if (!rb) return;
+
+  const oldShape = state.bodyToShape.get(body);
+  if (oldShape) {
+    state.shapeToBody.delete(oldShape);
+    state.bodyToShape.delete(body);
+  }
+
+  const existing = state.bodyToColliders.get(body) ?? [];
+  for (const col of existing) {
+    state.colliderHandleToBody.delete(col.handle);
+    state.world.removeCollider(col, false);
+  }
+
+  if (!shape) {
+    state.bodyToColliders.set(body, []);
+    return;
+  }
+
+  state.bodyToShape.set(body, shape);
+  state.shapeToBody.set(shape, body);
+
+  const shapeType = state.shapeTypeMap.get(shape);
+  if (shapeType === PhysicsShapeType.CONTAINER) {
+    rebuildCompoundColliders(state, body, shape);
+    return;
+  }
+
+  const desc = state.shapeToColliderDesc.get(shape);
+  if (!desc) return;
+
+  const collider = state.world.createCollider(desc, rb);
+  applyShapePropertiesToCollider(state, collider, shape);
+  state.colliderHandleToBody.set(collider.handle, body);
+  state.bodyToColliders.set(body, [collider]);
+}
+
+export function disposeShape(state: RapierPluginState, shape: PhysicsShape): void {
+  state.shapeToColliderDesc.delete(shape);
+  state.shapeTypeMap.delete(shape);
+  state.shapeMaterialMap.delete(shape);
+  state.shapeDensityMap.delete(shape);
+  state.shapeFilterMembership.delete(shape);
+  state.shapeFilterCollide.delete(shape);
+  state.triggerShapes.delete(shape);
+  state.compoundChildren.delete(shape);
+  state.shapeToBody.delete(shape);
+}
+
+export function setMaterial(state: RapierPluginState, shape: PhysicsShape, material: PhysicsMaterial): void {
+  state.shapeMaterialMap.set(shape, material);
+  for (const collider of getCollidersForShape(state, shape)) {
+    if (material.friction !== undefined) collider.setFriction(material.friction);
+    if (material.restitution !== undefined) collider.setRestitution(material.restitution);
+  }
+}
+
+export function getMaterial(state: RapierPluginState, shape: PhysicsShape): PhysicsMaterial {
+  return state.shapeMaterialMap.get(shape) ?? { friction: 0.5, restitution: 0 };
+}
+
+export function setDensity(state: RapierPluginState, shape: PhysicsShape, density: number): void {
+  state.shapeDensityMap.set(shape, density);
+  for (const collider of getCollidersForShape(state, shape)) {
+    collider.setDensity(density);
+  }
+}
+
+export function getDensity(state: RapierPluginState, shape: PhysicsShape): number {
+  return state.shapeDensityMap.get(shape) ?? 1.0;
+}
+
+export function setTrigger(state: RapierPluginState, shape: PhysicsShape, isTrigger: boolean): void {
+  if (isTrigger) {
+    state.triggerShapes.add(shape);
+  } else {
+    state.triggerShapes.delete(shape);
+  }
+  for (const collider of getCollidersForShape(state, shape)) {
+    collider.setSensor(isTrigger);
+  }
+}
+
+export function setShapeFilterMembershipMask(state: RapierPluginState, shape: PhysicsShape, membershipMask: number): void {
+  state.shapeFilterMembership.set(shape, membershipMask);
+  applyCollisionGroups(state, shape);
+}
+
+export function getShapeFilterMembershipMask(state: RapierPluginState, shape: PhysicsShape): number {
+  return state.shapeFilterMembership.get(shape) ?? 0xFFFFFFFF;
+}
+
+export function setShapeFilterCollideMask(state: RapierPluginState, shape: PhysicsShape, collideMask: number): void {
+  state.shapeFilterCollide.set(shape, collideMask);
+  applyCollisionGroups(state, shape);
+}
+
+export function getShapeFilterCollideMask(state: RapierPluginState, shape: PhysicsShape): number {
+  return state.shapeFilterCollide.get(shape) ?? 0xFFFFFFFF;
+}
+
+export function addChild(state: RapierPluginState, shape: PhysicsShape, newChild: PhysicsShape, translation?: Vector3, rotation?: Quaternion, scale?: Vector3): void {
+  let children = state.compoundChildren.get(shape);
+  if (!children) {
+    children = [];
+    state.compoundChildren.set(shape, children);
+  }
+  children.push({ child: newChild, translation, rotation, scale });
+
+  const body = state.shapeToBody.get(shape);
+  if (body) {
+    rebuildCompoundColliders(state, body, shape);
+  }
+}
+
+export function removeChild(state: RapierPluginState, shape: PhysicsShape, childIndex: number): void {
+  const children = state.compoundChildren.get(shape);
+  if (!children || childIndex < 0 || childIndex >= children.length) return;
+  children.splice(childIndex, 1);
+
+  const body = state.shapeToBody.get(shape);
+  if (body) {
+    rebuildCompoundColliders(state, body, shape);
+  }
+}
+
+export function getNumChildren(state: RapierPluginState, shape: PhysicsShape): number {
+  return state.compoundChildren.get(shape)?.length ?? 0;
+}
+
+export function getBoundingBox(state: RapierPluginState, shape: PhysicsShape): BoundingBox {
+  const colliders = getCollidersForShape(state, shape);
+  if (colliders.length === 0) {
+    return new BoundingBox(new Vector3(-0.5, -0.5, -0.5), new Vector3(0.5, 0.5, 0.5));
+  }
+  return computeColliderBoundingBox(state, colliders[0]);
+}
+
+export function getBodyBoundingBox(state: RapierPluginState, body: PhysicsBody): BoundingBox {
+  const colliders = state.bodyToColliders.get(body) ?? [];
+  if (colliders.length === 0) {
+    return new BoundingBox(new Vector3(-0.5, -0.5, -0.5), new Vector3(0.5, 0.5, 0.5));
+  }
+
+  let minX = Infinity, minY = Infinity, minZ = Infinity;
+  let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+
+  for (const collider of colliders) {
+    const bb = computeColliderBoundingBox(state, collider);
+    minX = Math.min(minX, bb.minimum.x);
+    minY = Math.min(minY, bb.minimum.y);
+    minZ = Math.min(minZ, bb.minimum.z);
+    maxX = Math.max(maxX, bb.maximum.x);
+    maxY = Math.max(maxY, bb.maximum.y);
+    maxZ = Math.max(maxZ, bb.maximum.z);
+  }
+
+  return new BoundingBox(new Vector3(minX, minY, minZ), new Vector3(maxX, maxY, maxZ));
+}
+
+function getCollidersForShape(state: RapierPluginState, shape: PhysicsShape): RAPIER.Collider[] {
+  const body = state.shapeToBody.get(shape);
+  if (!body) return [];
+  return state.bodyToColliders.get(body) ?? [];
+}
+
+function applyCollisionGroups(state: RapierPluginState, shape: PhysicsShape): void {
+  const membership = state.shapeFilterMembership.get(shape) ?? 0xFFFF;
+  const collide = state.shapeFilterCollide.get(shape) ?? 0xFFFF;
+  const groups = ((membership & 0xFFFF) << 16) | (collide & 0xFFFF);
+  for (const collider of getCollidersForShape(state, shape)) {
+    collider.setCollisionGroups(groups);
+  }
+}
+
+function applyShapePropertiesToCollider(state: RapierPluginState, collider: RAPIER.Collider, shape: PhysicsShape): void {
+  const material = state.shapeMaterialMap.get(shape);
+  if (material) {
+    if (material.friction !== undefined) collider.setFriction(material.friction);
+    if (material.restitution !== undefined) collider.setRestitution(material.restitution);
+  }
+  const density = state.shapeDensityMap.get(shape);
+  if (density !== undefined) collider.setDensity(density);
+  if (state.triggerShapes.has(shape)) collider.setSensor(true);
+  const membership = state.shapeFilterMembership.get(shape) ?? 0xFFFF;
+  const collide = state.shapeFilterCollide.get(shape) ?? 0xFFFF;
+  const groups = ((membership & 0xFFFF) << 16) | (collide & 0xFFFF);
+  collider.setCollisionGroups(groups);
+  collider.setActiveEvents(state.rapier.ActiveEvents.COLLISION_EVENTS);
+}
+
+function computeColliderBoundingBox(state: RapierPluginState, collider: RAPIER.Collider): BoundingBox {
+  const shapeType = collider.shapeType();
+  const RAPIER = state.rapier;
+  const t = collider.translation();
+
+  if (shapeType === RAPIER.ShapeType.Cuboid) {
+    const he = collider.halfExtents();
+    return new BoundingBox(
+      new Vector3(t.x - he.x, t.y - he.y, t.z - he.z),
+      new Vector3(t.x + he.x, t.y + he.y, t.z + he.z)
+    );
+  } else if (shapeType === RAPIER.ShapeType.Ball) {
+    const r = collider.radius();
+    return new BoundingBox(
+      new Vector3(t.x - r, t.y - r, t.z - r),
+      new Vector3(t.x + r, t.y + r, t.z + r)
+    );
+  } else if (shapeType === RAPIER.ShapeType.Capsule) {
+    const r = collider.radius();
+    const hh = collider.halfHeight();
+    return new BoundingBox(
+      new Vector3(t.x - r, t.y - hh - r, t.z - r),
+      new Vector3(t.x + r, t.y + hh + r, t.z + r)
+    );
+  } else if (shapeType === RAPIER.ShapeType.Cylinder) {
+    const r = collider.radius();
+    const hh = collider.halfHeight();
+    return new BoundingBox(
+      new Vector3(t.x - r, t.y - hh, t.z - r),
+      new Vector3(t.x + r, t.y + hh, t.z + r)
+    );
+  }
+
+  return new BoundingBox(
+    new Vector3(t.x - 0.5, t.y - 0.5, t.z - 0.5),
+    new Vector3(t.x + 0.5, t.y + 0.5, t.z + 0.5)
+  );
+}
+
+function rebuildCompoundColliders(state: RapierPluginState, body: PhysicsBody, shape: PhysicsShape): void {
+  const rb = state.bodyToRigidBody.get(body);
+  if (!rb) return;
+
+  const existing = state.bodyToColliders.get(body) ?? [];
+  for (const col of existing) {
+    state.colliderHandleToBody.delete(col.handle);
+    state.world.removeCollider(col, false);
+  }
+
+  const children = state.compoundChildren.get(shape) ?? [];
+  const newColliders: RAPIER.Collider[] = [];
+
+  for (const entry of children) {
+    const childDesc = state.shapeToColliderDesc.get(entry.child);
+    if (!childDesc) continue;
+
+    if (entry.translation) {
+      childDesc.setTranslation(entry.translation.x, entry.translation.y, entry.translation.z);
+    }
+    if (entry.rotation) {
+      childDesc.setRotation(new state.rapier.Quaternion(entry.rotation.x, entry.rotation.y, entry.rotation.z, entry.rotation.w));
+    }
+
+    const collider = state.world.createCollider(childDesc, rb);
+    applyShapePropertiesToCollider(state, collider, shape);
+    state.colliderHandleToBody.set(collider.handle, body);
+    newColliders.push(collider);
+  }
+
+  state.bodyToColliders.set(body, newColliders);
+}

package/src/rapier-types.ts

@@ -0,0 +1,60 @@
+import type RAPIER from '@dimforge/rapier3d-compat';
+import type {
+  Observable,
+  PhysicsBody,
+  PhysicsShape,
+  PhysicsConstraint,
+  PhysicsMaterial,
+  PhysicsShapeType,
+  IPhysicsCollisionEvent,
+  IBasePhysicsCollisionEvent,
+} from '@babylonjs/core';
+import type { Vector3, Quaternion } from '@babylonjs/core';
+import type { Vec3 } from '@rapierphysicsplugin/shared';
+import { PhysicsConstraintAxisLimitMode, PhysicsConstraintMotorType } from '@babylonjs/core';
+
+export interface AxisConfig {
+  mode?: PhysicsConstraintAxisLimitMode;
+  minLimit?: number;
+  maxLimit?: number;
+  friction?: number;
+  motorType?: PhysicsConstraintMotorType;
+  motorTarget?: number;
+  motorMaxForce?: number;
+}
+
+export function v3toVec(v: Vector3): Vec3 {
+  return { x: v.x, y: v.y, z: v.z };
+}
+
+export interface RapierPluginState {
+  rapier: typeof RAPIER;
+  world: RAPIER.World;
+  bodyToRigidBody: Map<PhysicsBody, RAPIER.RigidBody>;
+  bodyToColliders: Map<PhysicsBody, RAPIER.Collider[]>;
+  shapeToColliderDesc: Map<PhysicsShape, RAPIER.ColliderDesc>;
+  shapeTypeMap: Map<PhysicsShape, PhysicsShapeType>;
+  shapeMaterialMap: Map<PhysicsShape, PhysicsMaterial>;
+  shapeDensityMap: Map<PhysicsShape, number>;
+  shapeFilterMembership: Map<PhysicsShape, number>;
+  shapeFilterCollide: Map<PhysicsShape, number>;
+  bodyCollisionObservables: Map<PhysicsBody, Observable<IPhysicsCollisionEvent>>;
+  bodyCollisionEndedObservables: Map<PhysicsBody, Observable<IBasePhysicsCollisionEvent>>;
+  constraintToJoint: Map<PhysicsConstraint, RAPIER.ImpulseJoint>;
+  constraintBodies: Map<PhysicsConstraint, { body: PhysicsBody; childBody: PhysicsBody }>;
+  constraintAxisState: Map<PhysicsConstraint, Map<number, AxisConfig>>;
+  constraintEnabled: Map<PhysicsConstraint, boolean>;
+  constraintDescriptors: Map<PhysicsConstraint, { body: PhysicsBody; childBody: PhysicsBody }>;
+  collisionCallbackEnabled: Set<PhysicsBody>;
+  collisionEndedCallbackEnabled: Set<PhysicsBody>;
+  triggerShapes: Set<PhysicsShape>;
+  bodyIdToPhysicsBody: Map<string, PhysicsBody>;
+  bodyToShape: Map<PhysicsBody, PhysicsShape>;
+  shapeToBody: Map<PhysicsShape, PhysicsBody>;
+  compoundChildren: Map<PhysicsShape, Array<{ child: PhysicsShape; translation?: Vector3; rotation?: Quaternion; scale?: Vector3 }>>;
+  bodyEventMask: Map<PhysicsBody, number>;
+  colliderHandleToBody: Map<number, PhysicsBody>;
+  onCollisionObservable: Observable<IPhysicsCollisionEvent>;
+  onCollisionEndedObservable: Observable<IBasePhysicsCollisionEvent>;
+  onTriggerCollisionObservable: Observable<IBasePhysicsCollisionEvent>;
+}

package/src/state-reconciler.ts

@@ -0,0 +1,151 @@
+import type { BodyState, RoomSnapshot, ClientInput, Vec3, Quat } from '@rapierphysicsplugin/shared';
+import {
+  RECONCILIATION_THRESHOLD,
+  POSITION_LERP_SPEED,
+  ROTATION_SLERP_SPEED,
+} from '@rapierphysicsplugin/shared';
+import { Interpolator } from './interpolator.js';
+
+export interface ReconciliationResult {
+  /** Bodies that the local client controls — apply corrections */
+  localCorrections: Map<string, BodyState>;
+  /** Bodies controlled by remote players — use interpolated states */
+  remoteStates: Map<string, BodyState>;
+}
+
+export class StateReconciler {
+  private interpolator: Interpolator;
+  private localBodyIds: Set<string> = new Set();
+  private pendingInputs: ClientInput[] = [];
+  private lastServerTick = 0;
+
+  constructor(interpolator?: Interpolator) {
+    this.interpolator = interpolator ?? new Interpolator();
+  }
+
+  setLocalBodies(bodyIds: string[]): void {
+    this.localBodyIds = new Set(bodyIds);
+  }
+
+  addLocalBody(bodyId: string): void {
+    this.localBodyIds.add(bodyId);
+  }
+
+  removeLocalBody(bodyId: string): void {
+    this.localBodyIds.delete(bodyId);
+  }
+
+  addPendingInput(input: ClientInput): void {
+    this.pendingInputs.push(input);
+  }
+
+  processServerState(snapshot: RoomSnapshot): ReconciliationResult {
+    const result: ReconciliationResult = {
+      localCorrections: new Map(),
+      remoteStates: new Map(),
+    };
+
+    this.lastServerTick = snapshot.tick;
+
+    // Discard inputs that the server has already processed
+    this.pendingInputs = this.pendingInputs.filter(
+      input => input.tick > snapshot.tick
+    );
+
+    for (const body of snapshot.bodies) {
+      if (this.localBodyIds.has(body.id)) {
+        // Local body — check if correction needed
+        result.localCorrections.set(body.id, body);
+      } else {
+        // Remote body — feed to interpolator (render loop queries at proper render time)
+        this.interpolator.addSnapshot(body.id, body, snapshot.timestamp);
+      }
+    }
+
+    return result;
+  }
+
+  getInterpolatedRemoteState(bodyId: string, currentTime: number): BodyState | null {
+    return this.interpolator.getInterpolatedState(bodyId, currentTime);
+  }
+
+  getPendingInputs(): ClientInput[] {
+    return this.pendingInputs;
+  }
+
+  get lastProcessedServerTick(): number {
+    return this.lastServerTick;
+  }
+
+  getInterpolator(): Interpolator {
+    return this.interpolator;
+  }
+
+  clear(): void {
+    this.localBodyIds.clear();
+    this.pendingInputs = [];
+    this.interpolator.clear();
+    this.lastServerTick = 0;
+  }
+}
+
+export function needsCorrection(predicted: BodyState, authoritative: BodyState): boolean {
+  const dx = predicted.position.x - authoritative.position.x;
+  const dy = predicted.position.y - authoritative.position.y;
+  const dz = predicted.position.z - authoritative.position.z;
+  const distSq = dx * dx + dy * dy + dz * dz;
+  return distSq > RECONCILIATION_THRESHOLD * RECONCILIATION_THRESHOLD;
+}
+
+export function blendBodyState(current: BodyState, target: BodyState): BodyState {
+  return {
+    id: current.id,
+    position: lerpVec3(current.position, target.position, POSITION_LERP_SPEED),
+    rotation: slerpQuat(current.rotation, target.rotation, ROTATION_SLERP_SPEED),
+    linVel: target.linVel,
+    angVel: target.angVel,
+  };
+}
+
+function lerpVec3(a: Vec3, b: Vec3, t: number): Vec3 {
+  return {
+    x: a.x + (b.x - a.x) * t,
+    y: a.y + (b.y - a.y) * t,
+    z: a.z + (b.z - a.z) * t,
+  };
+}
+
+function slerpQuat(a: Quat, b: Quat, t: number): Quat {
+  let dot = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+  let bx = b.x, by = b.y, bz = b.z, bw = b.w;
+  if (dot < 0) {
+    dot = -dot;
+    bx = -bx; by = -by; bz = -bz; bw = -bw;
+  }
+  if (dot > 0.9995) {
+    const len = Math.sqrt(
+      (a.x + (bx - a.x) * t) ** 2 +
+      (a.y + (by - a.y) * t) ** 2 +
+      (a.z + (bz - a.z) * t) ** 2 +
+      (a.w + (bw - a.w) * t) ** 2
+    );
+    return {
+      x: (a.x + (bx - a.x) * t) / len,
+      y: (a.y + (by - a.y) * t) / len,
+      z: (a.z + (bz - a.z) * t) / len,
+      w: (a.w + (bw - a.w) * t) / len,
+    };
+  }
+  const theta0 = Math.acos(dot);
+  const theta = theta0 * t;
+  const sinTheta = Math.sin(theta);
+  const sinTheta0 = Math.sin(theta0);
+  const s0 = Math.cos(theta) - dot * sinTheta / sinTheta0;
+  const s1 = sinTheta / sinTheta0;
+  return {
+    x: s0 * a.x + s1 * bx,
+    y: s0 * a.y + s1 * by,
+    z: s0 * a.z + s1 * bz,
+    w: s0 * a.w + s1 * bw,
+  };
+}