@forgeax/engine-physics-rapier3d 0.1.32 → 0.1.34

package/dist/__tests__/state-reconcile.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state-reconcile.unit.test.d.ts.map

package/dist/__tests__/state-reconcile.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-reconcile.unit.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/state-reconcile.unit.test.ts"],"names":[],"mappings":""}

package/dist/index.mjs

@@ -1,38 +1,19 @@
 import { defineSystem, FixedTime, componentDefinition, Disabled, FixedUpdate } from '@forgeax/engine-ecs';
-import { componentId } from '@forgeax/engine-ecs/internal';
-import { readStructuralEvidence } from '@forgeax/engine-ecs/projection';
+import { createStateProjection } from '@forgeax/engine-ecs/projection';
 import { vec3, quat, mat4 } from '@forgeax/engine-math';
 import { CollidingEntities, DerivedPhysicsError, cloneDerivedPhysicsInput, validateMassProperties, DERIVED_PHYSICS_LIMITS, estimateDerivedPhysicsInputBytes, preserveCenterOfMassVelocity, 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 { err, ok, 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;
+function samePhysicsValue(left, right) {
+  if (Object.is(left, right)) return true;
+  if (left === void 0 || right === void 0 || left === null || right === null || typeof left !== "object" || typeof right !== "object")
+    return false;
+  const a = left;
+  const b = right;
+  const keys = Object.keys(a);
+  return keys.length === Object.keys(b).length && keys.every((key) => samePhysicsValue(a[key], b[key]));
 }
 var DEG_TO_RAD = Math.PI / 180;
 function applyKccTuning(ctrl, cc) {
@@ -2038,61 +2019,6 @@ var RapierPhysicsWorld3D = class {
     }
     this.removeKccController(entity);
   }
-  resetForFullReconcile(transformlessStatic) {
-    for (const entity of [...this.entityMap.keys()]) {
-      if (transformlessStatic.has(entity) && this.isCommittedFixedBody(entity)) {
-        this.removeKccController(entity);
-        continue;
-      }
-      this.removeEntity(entity);
-    }
-  }
-  fullReconcilePhysicsState(state) {
-    const descriptors = [];
-    const transformlessStatic = /* @__PURE__ */ new Set();
-    const committedDerived = this.derivedBodies.size > 0 ? this.captureDerivedPhysicsState() : void 0;
-    for (const query of state.queries)
-      for (const row of query) {
-        if (!row.has(state.transformComponent)) {
-          if (physicsRowIsStatic(row)) transformlessStatic.add(row.entity);
-          continue;
-        }
-        const descriptor = readPhysicsSyncDescriptor(
-          row,
-          state.transformComponent,
-          state.globalTransformComponent
-        );
-        if (descriptor !== void 0) descriptors.push(descriptor);
-      }
-    this.resetForFullReconcile(transformlessStatic);
-    for (const descriptor of descriptors) {
-      this.ensureBody(
-        descriptor.entity,
-        descriptor.transform,
-        descriptor.rigidBody,
-        descriptor.collider
-      );
-    }
-    if (committedDerived !== void 0) {
-      const restorableBodies = committedDerived.bodies.filter(
-        (body) => this.entityMap.has(body.entity) && !this.derivedBodies.has(body.entity)
-      );
-      if (restorableBodies.length > 0) {
-        const restorable = Object.freeze({
-          ...committedDerived,
-          bodies: Object.freeze(restorableBodies)
-        });
-        const restored = this.restoreDerivedPhysicsState(restorable);
-        if (!restored.ok) {
-          this.invalidateDerivedShapeCandidates("full-reconcile-restore-failed");
-        }
-      }
-    }
-    drainPhysicsChangeQueries(state.changeQueries);
-    state.structuralCursor = readStructuralEvidence(state.world, state.structuralCursor).cursor;
-    state.structureEpoch = state.world.getStructureEpoch();
-    state.initialized = true;
-  }
   reconcilePhysicsDelta(state, entity, delta) {
     const row = state.queries.map((query) => query.at(entity)).find((entry) => entry !== void 0);
     if (row === void 0) {
@@ -2218,83 +2144,64 @@ var RapierPhysicsWorld3D = class {
         transformComponent,
         globalTransformComponent,
         queries: [queryResult.value, bodyQuery.value],
-        changeQueries: createPhysicsChangeQueries(world, [
-          transformComponent,
-          globalTransformComponent,
-          Collider,
-          RigidBody,
-          CharacterController,
-          ChildOf
-        ]),
-        structuralCursor: readStructuralEvidence(world, 0).cursor,
-        structureEpoch: world.getStructureEpoch(),
-        initialized: false
+        projection: createStateProjection(
+          world,
+          [
+            transformComponent,
+            globalTransformComponent,
+            Collider,
+            RigidBody,
+            CharacterController,
+            ChildOf,
+            Disabled
+          ],
+          [Collider, RigidBody]
+        ),
+        accepted: /* @__PURE__ */ new Map()
       };
       this.syncState = state;
     }
-    if (!state.initialized) {
-      this.fullReconcilePhysicsState(state);
-      return;
-    }
-    const deltas = /* @__PURE__ */ new Map();
-    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;
+    const batch = state.projection.read();
+    const updates = [];
+    for (const index of batch.indices) {
+      const entity = state.projection.entity(index);
+      const previous = state.accepted.get(index);
+      if (previous !== void 0 && previous.entity !== entity) this.removeEntity(previous.entity);
+      if (entity === void 0) {
+        updates.push({ index, descriptor: void 0 });
+        continue;
       }
-      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;
-        }
+      let row;
+      for (const query of state.queries) {
+        row = query.at(entity);
+        if (row !== void 0) break;
       }
-    }
-    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 (row === void 0) {
+        this.removeEntity(entity);
+        updates.push({ index, descriptor: void 0 });
+        continue;
       }
+      const descriptor = readPhysicsSyncDescriptor(
+        row,
+        transformComponent,
+        globalTransformComponent
+      );
+      const prior = previous?.entity === entity ? previous : void 0;
+      const delta = {
+        transformChanged: !samePhysicsValue(prior?.transform, descriptor?.transform),
+        colliderChanged: descriptor === void 0 ? state.projection.changed(entity, Collider) : !samePhysicsValue(prior?.collider, descriptor.collider),
+        rigidBodyChanged: descriptor === void 0 ? state.projection.changed(entity, RigidBody) : !samePhysicsValue(prior?.rigidBody, descriptor.rigidBody),
+        characterControllerChanged: prior?.characterControllerOffset !== descriptor?.characterControllerOffset || prior?.hasCharacterController !== descriptor?.hasCharacterController,
+        characterControllerStructureChanged: prior?.hasCharacterController !== descriptor?.hasCharacterController
+      };
+      this.reconcilePhysicsDelta(state, entity, delta);
+      updates.push({ index, descriptor: descriptor ?? (this.hasBody(entity) ? prior : void 0) });
+    }
+    batch.accept();
+    for (const { index, descriptor } of updates) {
+      if (descriptor === void 0) state.accepted.delete(index);
+      else state.accepted.set(index, descriptor);
     }
-    if (deltas.size === 0) return;
-    for (const [entity, delta] of deltas) this.reconcilePhysicsDelta(state, entity, delta);
   }
   /**
    * Remove an entity's cached KCC and unregister it from the Rapier world