@forgeax/engine-physics-rapier3d 0.1.20 → 0.1.23

package/dist/index.mjs

@@ -1,11 +1,39 @@
 import { defineSystem, FixedTime, componentDefinition, Disabled, FixedUpdate } from '@forgeax/engine-ecs';
-import { createWorldProjection } from '@forgeax/engine-ecs/projection';
+import { componentId } from '@forgeax/engine-ecs/internal';
+import { readStructuralEvidence } from '@forgeax/engine-ecs/projection';
 import { vec3, quat, mat4 } from '@forgeax/engine-math';
 import { CollidingEntities, PhysicsError, PHYSICS_ERROR_HINTS, CharacterController, rigidBodyTypeFromF32, RigidBody, Collider, colliderShapeFromF32, RIGID_BODY_TYPE_STATIC, registerPhysicsComponents, PhysicsSet } from '@forgeax/engine-physics';
 import { ChildOf } from '@forgeax/engine-scene';
 import { PhysicsError as PhysicsError$1 } from '@forgeax/engine-types';
 
 // src/rapier-physics-world-3d.ts
+function createPhysicsChangeQueries(world, components) {
+  return components.map((component) => {
+    const result = world.query({ changed: [component] });
+    if (!result.ok) throw result.error;
+    return { component, query: result.value };
+  });
+}
+function drainPhysicsChangeQueries(queries) {
+  for (const entry of queries) {
+    for (const _span of entry.query.spans().unwrap()) {
+    }
+  }
+}
+function ensurePhysicsDelta(deltas, entity) {
+  let delta = deltas.get(entity);
+  if (delta === void 0) {
+    delta = {
+      transformChanged: false,
+      colliderChanged: false,
+      rigidBodyChanged: false,
+      characterControllerChanged: false,
+      characterControllerStructureChanged: false
+    };
+    deltas.set(entity, delta);
+  }
+  return delta;
+}
 var DEG_TO_RAD = Math.PI / 180;
 function applyKccTuning(ctrl, cc) {
   ctrl.setMaxSlopeClimbAngle(cc.maxSlopeClimbDeg * DEG_TO_RAD);
@@ -403,7 +431,11 @@ var RapierPhysicsWorld3D = class {
         if (physicsRowIsStatic(row)) transformlessStatic.add(row.entity);
         continue;
       }
-      const descriptor = readPhysicsSyncDescriptor(row, state.transformComponent);
+      const descriptor = readPhysicsSyncDescriptor(
+        row,
+        state.transformComponent,
+        state.globalTransformComponent
+      );
       if (descriptor !== void 0) descriptors.push(descriptor);
     }
     this.resetForFullReconcile(transformlessStatic);
@@ -415,6 +447,9 @@ var RapierPhysicsWorld3D = class {
         descriptor.collider
       );
     }
+    drainPhysicsChangeQueries(state.changeQueries);
+    state.structuralCursor = readStructuralEvidence(state.world, state.structuralCursor).cursor;
+    state.structureEpoch = state.world.getStructureEpoch();
     state.initialized = true;
   }
   reconcilePhysicsDelta(state, entity, delta) {
@@ -431,7 +466,11 @@ var RapierPhysicsWorld3D = class {
       this.reconcileTransformlessCompatibility(entity, physicsRowIsStatic(row));
       return;
     }
-    const descriptor = readPhysicsSyncDescriptor(row, state.transformComponent);
+    const descriptor = readPhysicsSyncDescriptor(
+      row,
+      state.transformComponent,
+      state.globalTransformComponent
+    );
     if (descriptor === void 0) {
       this.removeEntity(entity);
       return;
@@ -449,12 +488,14 @@ var RapierPhysicsWorld3D = class {
       const finalOffset = descriptor.characterControllerOffset;
       if (!descriptor.hasCharacterController) {
         this.removeKccController(entity);
-      } else if (hadCachedReceipt && (delta.characterControllerRemoved || finalOffset === void 0 || !Object.is(cachedOffset, finalOffset))) {
+      } else if (hadCachedReceipt && (finalOffset === void 0 || !Object.is(cachedOffset, finalOffset))) {
         this.removeKccController(entity);
         if (finalOffset !== void 0) this.ensureKcc(entity, finalOffset);
       }
     }
-    if (!delta.transformChanged && !delta.characterControllerRemoved) return;
+    if (!delta.transformChanged && !(delta.characterControllerStructureChanged && !descriptor.hasCharacterController)) {
+      return;
+    }
     const bodyType = rigidBodyTypeFromF32(descriptor.rigidBody.type);
     if (bodyType === "static") {
       this.syncAuthoredPose(entity, descriptor.transform, descriptor.collider, "static");
@@ -463,29 +504,37 @@ var RapierPhysicsWorld3D = class {
     }
   }
   /** @internal ECS system bridge; consumers should register PhysicsSyncBackend. */
-  _syncFromEcs(world, transformComponent) {
+  _syncFromEcs(world, transformComponent, globalTransformComponent = world.components.resolve("GlobalTransform")) {
     this.assertActive("syncFromEcs");
+    if (globalTransformComponent === void 0) return;
     let state = this.syncState;
-    if (state === void 0 || state.world !== world || state.transformComponent !== transformComponent) {
+    if (state === void 0 || state.world !== world || state.transformComponent !== transformComponent || state.globalTransformComponent !== globalTransformComponent) {
       const queryResult = world.query({
         read: [Collider],
-        optional: [transformComponent, RigidBody, CharacterController, ChildOf]
+        optional: [
+          transformComponent,
+          globalTransformComponent,
+          RigidBody,
+          CharacterController,
+          ChildOf
+        ]
       });
       if (!queryResult.ok) return;
       state = {
         world,
         transformComponent,
+        globalTransformComponent,
         query: queryResult.value,
-        projection: createWorldProjection(world, {
-          components: [
-            transformComponent,
-            Collider,
-            RigidBody,
-            CharacterController,
-            ChildOf,
-            Disabled
-          ]
-        }),
+        changeQueries: createPhysicsChangeQueries(world, [
+          transformComponent,
+          globalTransformComponent,
+          Collider,
+          RigidBody,
+          CharacterController,
+          ChildOf
+        ]),
+        structuralCursor: readStructuralEvidence(world, 0).cursor,
+        structureEpoch: world.getStructureEpoch(),
         initialized: false
       };
       this.syncState = state;
@@ -494,46 +543,64 @@ var RapierPhysicsWorld3D = class {
       this.fullReconcilePhysicsState(state);
       return;
     }
-    const evidence = state.projection.poll();
-    if (evidence.status === "rebuild") {
-      this.fullReconcilePhysicsState(state);
-      return;
-    }
-    if (evidence.changes.length === 0) return;
     const deltas = /* @__PURE__ */ new Map();
-    for (const change of evidence.changes) {
-      let delta = deltas.get(change.entity);
-      if (delta === void 0) {
-        delta = {
-          transformChanged: false,
-          colliderChanged: false,
-          rigidBodyChanged: false,
-          characterControllerChanged: false,
-          characterControllerRemoved: false
-        };
-        deltas.set(change.entity, delta);
-      }
-      if (change.kind === "entity-removed") continue;
-      if (change.component === void 0) {
+    if (state.structureEpoch !== world.getStructureEpoch()) {
+      const structural = readStructuralEvidence(world, state.structuralCursor);
+      state.structuralCursor = structural.cursor;
+      state.structureEpoch = world.getStructureEpoch();
+      if (structural.status === "overflow") {
         this.fullReconcilePhysicsState(state);
         return;
       }
-      if (change.component === transformComponent) {
-        delta.transformChanged = true;
-      } else if (change.component === Collider) {
-        delta.colliderChanged = true;
-      } else if (change.component === RigidBody) {
-        delta.rigidBodyChanged = true;
-      } else if (change.component === CharacterController) {
-        delta.characterControllerChanged = true;
-        if (change.kind === "component-removed") delta.characterControllerRemoved = true;
-      } else if (change.component === ChildOf) {
-        delta.transformChanged = true;
-      } else if (change.component !== Disabled) {
-        this.fullReconcilePhysicsState(state);
-        return;
+      const transformId = componentId(transformComponent);
+      const globalTransformId = componentId(globalTransformComponent);
+      const colliderId = componentId(Collider);
+      const rigidBodyId = componentId(RigidBody);
+      const characterControllerId = componentId(CharacterController);
+      const childOfId = componentId(ChildOf);
+      const disabledId = componentId(Disabled);
+      for (const evidence of structural.events) {
+        const id = evidence.componentId;
+        if (evidence.kind !== "spawn" && evidence.kind !== "despawn" && id !== transformId && id !== globalTransformId && id !== colliderId && id !== rigidBodyId && id !== characterControllerId && id !== childOfId && id !== disabledId) {
+          continue;
+        }
+        const delta = ensurePhysicsDelta(deltas, evidence.entity);
+        if (evidence.kind === "spawn" || evidence.kind === "despawn") {
+          delta.transformChanged = true;
+          delta.colliderChanged = true;
+          delta.rigidBodyChanged = true;
+          delta.characterControllerChanged = true;
+          delta.characterControllerStructureChanged = true;
+        } else if (id === transformId || id === globalTransformId || id === childOfId) {
+          delta.transformChanged = true;
+        } else if (id === colliderId || id === disabledId) {
+          delta.colliderChanged = true;
+        } else if (id === rigidBodyId) {
+          delta.rigidBodyChanged = true;
+        } else if (id === characterControllerId) {
+          delta.characterControllerChanged = true;
+          delta.characterControllerStructureChanged = true;
+        }
+      }
+    }
+    for (const entry of state.changeQueries) {
+      for (const span of entry.query.spans().unwrap()) {
+        for (const rawEntity of span.entities) {
+          const entity = rawEntity;
+          const delta = ensurePhysicsDelta(deltas, entity);
+          if (entry.component === transformComponent || entry.component === globalTransformComponent || entry.component === ChildOf) {
+            delta.transformChanged = true;
+          } else if (entry.component === Collider) {
+            delta.colliderChanged = true;
+          } else if (entry.component === RigidBody) {
+            delta.rigidBodyChanged = true;
+          } else if (entry.component === CharacterController) {
+            delta.characterControllerChanged = true;
+          }
+        }
       }
     }
+    if (deltas.size === 0) return;
     for (const [entity, delta] of deltas) this.reconcilePhysicsDelta(state, entity, delta);
   }
   /**
@@ -763,13 +830,14 @@ function physicsRowIsStatic(row) {
   const rigidBody = row.get(RigidBody);
   return rigidBody !== void 0 && rigidBodyTypeFromF32(rigidBody.type) === "static";
 }
-function readPhysicsSyncDescriptor(row, transformComponent) {
+function readPhysicsSyncDescriptor(row, transformComponent, globalTransformComponent) {
   const transformData = row.get(transformComponent);
+  const globalTransformData = row.get(globalTransformComponent);
   const colliderData = row.get(Collider);
   if (transformData === void 0 || colliderData === void 0) return void 0;
-  const useWorldPose = row.has(ChildOf) && hasReadableWorldPose(transformData.world);
+  const useWorldPose = row.has(ChildOf) && hasReadableWorldPose(globalTransformData?.world);
   if (useWorldPose) {
-    poseScratchWorld.set(transformData.world.subarray(0, 16));
+    poseScratchWorld.set(globalTransformData.world);
     mat4.decompose(poseScratchPosition, poseScratchRotation, poseScratchScale, poseScratchWorld);
   } else {
     poseScratchPosition[0] = transformData.pos[0] ?? 0;
@@ -853,7 +921,8 @@ var PhysicsSyncBackend = defineSystem({
   after: ["propagateTransformsFixed"],
   fn: (world) => {
     const transformComponent = resolveTransform(world);
-    if (transformComponent === void 0) return;
+    const globalTransformComponent = world.components.resolve("GlobalTransform");
+    if (transformComponent === void 0 || globalTransformComponent === void 0) return;
     let pw;
     try {
       pw = world.getResource("PhysicsWorld");
@@ -861,7 +930,7 @@ var PhysicsSyncBackend = defineSystem({
       return;
     }
     pw.applyPendingTeleports();
-    pw._syncFromEcs(world, transformComponent);
+    pw._syncFromEcs(world, transformComponent, globalTransformComponent);
   }
 });
 var PhysicsStepSimulation = defineSystem({