@vgai/engine 0.5.13 → 0.5.14

package/src/world3d-react/rapier-physics-bridge.tsx

@@ -61,12 +61,18 @@
 
 import { type RapierRigidBody, useRapier } from '@react-three/rapier';
 import { useEffect } from 'react';
-import type * as THREE from 'three';
+import * as THREE from 'three';
 import {
   createRapierBodyEditing,
   type RapierEditableBody,
 } from '../adapter/rapier-physics-adapter';
-import type { PhysicsAdapter } from '../adapter/system-adapter';
+import type {
+  PhysicsAdapter,
+  PhysicsColliderShape,
+  PhysicsColliderSnapshot,
+  PhysicsJointSnapshot,
+  PhysicsJointType,
+} from '../adapter/system-adapter';
 import { useGameContext } from './engine-bridge';
 
 export interface RapierPhysicsBridgeProps {
@@ -79,6 +85,38 @@ export interface RapierPhysicsBridgeProps {
   readonly onDebugChange: (debug: boolean) => void;
 }
 
+interface RapierBodyStateLike {
+  readonly object: THREE.Object3D;
+  readonly rigidBody: RapierRigidBody;
+}
+
+function lateEntityObject(
+  states: Iterable<RapierBodyStateLike>,
+  nodeId: string,
+): THREE.Object3D | undefined {
+  let found: THREE.Object3D | undefined;
+  for (const state of states) {
+    state.object.traverse((candidate) => {
+      if (!found && candidate.userData['entityId'] === nodeId) found = candidate;
+    });
+    if (found) return found;
+  }
+  return undefined;
+}
+
+function owningBody(
+  object: THREE.Object3D,
+  states: Iterable<RapierBodyStateLike>,
+): RapierRigidBody | undefined {
+  const byObject = new Map<THREE.Object3D, RapierRigidBody>();
+  for (const state of states) byObject.set(state.object, state.rigidBody);
+  for (let node: THREE.Object3D | null = object; node; node = node.parent) {
+    const body = byObject.get(node);
+    if (body) return body;
+  }
+  return undefined;
+}
+
 /**
  * Register this R3F world's `@react-three/rapier` physics as the game's
  * `SystemAdapters.physics`. Mount it once, INSIDE `<Physics>` (it reads
@@ -86,7 +124,7 @@ export interface RapierPhysicsBridgeProps {
  */
 export function RapierPhysicsBridge({ onDebugChange }: RapierPhysicsBridgeProps): null {
   const ctx = useGameContext();
-  const { rigidBodyStates } = useRapier();
+  const { colliderStates, rapier, rigidBodyStates, world } = useRapier();
   const registerSystemAdapter = ctx.registerSystemAdapter;
 
   useEffect(() => {
@@ -114,24 +152,224 @@ export function RapierPhysicsBridge({ onDebugChange }: RapierPhysicsBridgeProps)
      * `setSceneCamera`), so a destructured copy would be permanently absent.
      */
     const bodyFor = (nodeId: string): RapierEditableBody | undefined => {
-      const object = ctx.sceneIndex?.byEntityId(nodeId);
+      const indexed = ctx.sceneIndex?.byEntityId(nodeId);
+      const object = indexed ?? lateEntityObject(rigidBodyStates.values(), nodeId);
+      if (!indexed && object) {
+        // The editor assigns its stable authoring entity ids AFTER Fiber's
+        // first commit, while the root's SceneIndex is constructed during
+        // that commit. Resolve the one late id inside the library-owned body
+        // subtrees and immediately reindex it; subsequent gestures take the
+        // normal indexed path. This is the SceneIndex's documented escape
+        // hatch for a userData id written after construction, not a parallel
+        // scene mirror.
+        ctx.sceneIndex?.reindex(object);
+      }
       if (!object) return undefined;
-      const byObject = new Map<THREE.Object3D, RapierRigidBody>();
-      for (const state of rigidBodyStates.values()) byObject.set(state.object, state.rigidBody);
-      for (let node: THREE.Object3D | null = object; node; node = node.parent) {
-        const body = byObject.get(node);
-        if (body) return body;
+      return owningBody(object, rigidBodyStates.values());
+    };
+
+    const colliderShape = (collider: {
+      shapeType(): number;
+      halfExtents(): { x: number; y: number; z: number };
+      radius(): number;
+      halfHeight(): number;
+    }): PhysicsColliderShape | null => {
+      switch (collider.shapeType()) {
+        case rapier.ShapeType.Cuboid: {
+          const halfExtents = collider.halfExtents();
+          return { type: 'cuboid', halfExtents: [halfExtents.x, halfExtents.y, halfExtents.z] };
+        }
+        case rapier.ShapeType.Ball:
+          return { type: 'ball', radius: collider.radius() };
+        case rapier.ShapeType.Capsule:
+          return {
+            type: 'capsule',
+            halfHeight: collider.halfHeight(),
+            radius: collider.radius(),
+          };
+        default:
+          return null;
+      }
+    };
+
+    const colliders = (nodeId: string): PhysicsColliderSnapshot[] => {
+      const body = bodyFor(nodeId) as RapierRigidBody | undefined;
+      if (!body) return [];
+      const result: PhysicsColliderSnapshot[] = [];
+      for (const state of colliderStates.values()) {
+        if (state.collider.parent()?.handle !== body.handle) continue;
+        const shape = colliderShape(state.collider);
+        if (!shape) continue;
+        state.object.updateWorldMatrix(true, false);
+        const position = state.collider.translation();
+        const rotation = state.collider.rotation();
+        const scale = state.object.getWorldScale(new THREE.Vector3());
+        result.push({
+          id: String(state.collider.handle),
+          shape,
+          position: [position.x, position.y, position.z],
+          rotation: [rotation.x, rotation.y, rotation.z, rotation.w],
+          scale: [Math.abs(scale.x), Math.abs(scale.y), Math.abs(scale.z)],
+          sensor: state.collider.isSensor(),
+        });
+      }
+      return result.sort((a, b) => Number(a.id) - Number(b.id));
+    };
+
+    const previewCollider = (colliderId: string, shape: PhysicsColliderShape): void => {
+      const collider = [...colliderStates.values()].find(
+        (state) => String(state.collider.handle) === colliderId,
+      )?.collider;
+      if (!collider || colliderShape(collider)?.type !== shape.type) return;
+      switch (shape.type) {
+        case 'cuboid':
+          collider.setHalfExtents({
+            x: shape.halfExtents[0],
+            y: shape.halfExtents[1],
+            z: shape.halfExtents[2],
+          });
+          break;
+        case 'ball':
+          collider.setRadius(shape.radius);
+          break;
+        case 'capsule':
+          collider.setHalfHeight(shape.halfHeight);
+          collider.setRadius(shape.radius);
+          break;
       }
-      return undefined;
+    };
+
+    const jointType = (type: number): PhysicsJointType => {
+      switch (type) {
+        case rapier.JointType.Revolute:
+          return 'revolute';
+        case rapier.JointType.Fixed:
+          return 'fixed';
+        case rapier.JointType.Prismatic:
+          return 'prismatic';
+        case rapier.JointType.Rope:
+          return 'rope';
+        case rapier.JointType.Spring:
+          return 'spring';
+        case rapier.JointType.Spherical:
+          return 'spherical';
+        default:
+          return 'generic';
+      }
+    };
+
+    const tuple3 = (value: { x: number; y: number; z: number }): [number, number, number] => [
+      value.x,
+      value.y,
+      value.z,
+    ];
+    const tuple4 = (value: {
+      x: number;
+      y: number;
+      z: number;
+      w: number;
+    }): [number, number, number, number] => [value.x, value.y, value.z, value.w];
+    const worldAnchor = (
+      body: RapierRigidBody,
+      anchor: { x: number; y: number; z: number },
+    ): [number, number, number] => {
+      const point = new THREE.Vector3(anchor.x, anchor.y, anchor.z)
+        .applyQuaternion(new THREE.Quaternion(...tuple4(body.rotation())))
+        .add(new THREE.Vector3(...tuple3(body.translation())));
+      return tuple3(point);
+    };
+
+    type NativeImpulseJoint = ReturnType<typeof world.impulseJoints.getAll>[number];
+    const jointLimits = (
+      joint: NativeImpulseJoint,
+      type: PhysicsJointType,
+    ): Pick<PhysicsJointSnapshot, 'limits'> => {
+      if (type !== 'revolute' && type !== 'prismatic') return {};
+      const unit = joint as unknown as {
+        limitsEnabled(): boolean;
+        limitsMin(): number;
+        limitsMax(): number;
+      };
+      return unit.limitsEnabled()
+        ? { limits: { min: unit.limitsMin(), max: unit.limitsMax() } }
+        : {};
+    };
+
+    const jointAxis = (
+      joint: NativeImpulseJoint,
+      type: PhysicsJointType,
+      body: RapierRigidBody,
+    ): Pick<PhysicsJointSnapshot, 'axis' | 'worldAxis'> => {
+      if (type !== 'revolute' && type !== 'prismatic') return {};
+      const frame = joint.frameX1();
+      const axis = new THREE.Vector3(1, 0, 0).applyQuaternion(
+        new THREE.Quaternion(frame.x, frame.y, frame.z, frame.w),
+      );
+      const worldAxis = axis
+        .clone()
+        .applyQuaternion(new THREE.Quaternion(...tuple4(body.rotation())));
+      return { axis: tuple3(axis), worldAxis: tuple3(worldAxis) };
+    };
+
+    const jointSnapshot = (joint: NativeImpulseJoint): PhysicsJointSnapshot => {
+      const body1 = joint.body1();
+      const body2 = joint.body2();
+      const anchor1 = joint.anchor1();
+      const anchor2 = joint.anchor2();
+      const type = jointType(joint.type());
+      return {
+        id: String(joint.handle),
+        type,
+        body1: String(body1.handle),
+        body2: String(body2.handle),
+        anchor1: tuple3(anchor1),
+        anchor2: tuple3(anchor2),
+        worldAnchor1: worldAnchor(body1, anchor1),
+        worldAnchor2: worldAnchor(body2, anchor2),
+        body1Position: tuple3(body1.translation()),
+        body2Position: tuple3(body2.translation()),
+        body1Rotation: tuple4(body1.rotation()),
+        body2Rotation: tuple4(body2.rotation()),
+        ...jointAxis(joint, type, body1),
+        ...jointLimits(joint, type),
+        contactsEnabled: joint.contactsEnabled(),
+      };
+    };
+
+    const joints = (nodeId: string): PhysicsJointSnapshot[] => {
+      const body = bodyFor(nodeId) as RapierRigidBody | undefined;
+      if (!body) return [];
+      const result: PhysicsJointSnapshot[] = [];
+      world.impulseJoints.forEachJointHandleAttachedToRigidBody(body.handle, (handle) => {
+        const joint = world.impulseJoints.get(handle);
+        if (joint) result.push(jointSnapshot(joint));
+      });
+      return result.sort((a, b) => Number(a.id) - Number(b.id));
+    };
+
+    const previewJointAnchor = (
+      jointId: string,
+      endpoint: 0 | 1,
+      anchor: readonly [number, number, number],
+    ): void => {
+      const joint = world.impulseJoints.get(Number(jointId));
+      if (!joint) return;
+      const value = { x: anchor[0], y: anchor[1], z: anchor[2] };
+      if (endpoint === 0) joint.setAnchor1(value);
+      else joint.setAnchor2(value);
     };
 
     const adapter: PhysicsAdapter = {
       ...createRapierBodyEditing(bodyFor),
       setDebugDrawEnabled: (enabled) => onDebugChange(enabled),
+      colliders,
+      previewCollider,
+      joints,
+      previewJointAnchor,
     };
     registerSystemAdapter('physics', adapter);
     return () => registerSystemAdapter('physics', undefined);
-  }, [ctx, registerSystemAdapter, rigidBodyStates, onDebugChange]);
+  }, [colliderStates, ctx, onDebugChange, rapier, registerSystemAdapter, rigidBodyStates, world]);
 
   return null;
 }