@pibbl/core 0.0.1

package/dist/features/physics/lib/2d/world/integrator.js

@@ -0,0 +1,99 @@
+const BODY_TYPE_DYNAMIC_2D = 1 << 0;
+const BODY_TYPE_KINEMATIC_2D = 1 << 1;
+const BODY_FIXED_ROTATION_2D = 1 << 2;
+const BODY_TYPE_MASK_2D = BODY_TYPE_DYNAMIC_2D | BODY_TYPE_KINEMATIC_2D;
+function applyForceAtPointToCandidateBody2D(bodies, bodyIndex, bodyGeneration, forceX, forceY, pointX, pointY) {
+  if (!bodies.has(bodyIndex, bodyGeneration)) return false;
+  if (!isDynamicBody(bodies, bodyIndex)) return true;
+  bodies.forceX[bodyIndex] += forceX;
+  bodies.forceY[bodyIndex] += forceY;
+  if (!isFixedRotation(bodies, bodyIndex)) {
+    bodies.torque[bodyIndex] += (pointX - bodies.positionX[bodyIndex]) * forceY - (pointY - bodies.positionY[bodyIndex]) * forceX;
+  }
+  return true;
+}
+function applyTorqueToCandidateBody2D(bodies, bodyIndex, bodyGeneration, torque) {
+  if (!bodies.has(bodyIndex, bodyGeneration)) return false;
+  if (isDynamicBody(bodies, bodyIndex) && !isFixedRotation(bodies, bodyIndex)) {
+    bodies.torque[bodyIndex] += torque;
+  }
+  return true;
+}
+function applyImpulseAtPointToCandidateBody2D(bodies, bodyIndex, bodyGeneration, impulseX, impulseY, pointX, pointY) {
+  if (!bodies.has(bodyIndex, bodyGeneration)) return false;
+  if (!isDynamicBody(bodies, bodyIndex)) return true;
+  const inverseMass = bodies.inverseMass[bodyIndex];
+  bodies.linearVelocityX[bodyIndex] += impulseX * inverseMass;
+  bodies.linearVelocityY[bodyIndex] += impulseY * inverseMass;
+  if (!isFixedRotation(bodies, bodyIndex)) {
+    bodies.angularVelocity[bodyIndex] += ((pointX - bodies.positionX[bodyIndex]) * impulseY - (pointY - bodies.positionY[bodyIndex]) * impulseX) * bodies.inverseInertia[bodyIndex];
+  }
+  return true;
+}
+function integrateCandidateBodies2D(bodies, bodyIndices, bodyCount, gravityX, gravityY, dt) {
+  for (let offset = 0; offset < bodyCount; offset += 1) {
+    const bodyIndex = bodyIndices[offset];
+    const type = bodies.flags[bodyIndex] & BODY_TYPE_MASK_2D;
+    if (type === BODY_TYPE_DYNAMIC_2D) {
+      integrateDynamicVelocity(bodies, bodyIndex, gravityX, gravityY, dt);
+      integratePose(bodies, bodyIndex, dt);
+    } else if (type === BODY_TYPE_KINEMATIC_2D) {
+      integratePose(bodies, bodyIndex, dt);
+    }
+    bodies.forceX[bodyIndex] = 0;
+    bodies.forceY[bodyIndex] = 0;
+    bodies.torque[bodyIndex] = 0;
+  }
+}
+function integrateCandidateVelocities2D(bodies, bodyIndices, bodyCount, gravityX, gravityY, dt) {
+  for (let offset = 0; offset < bodyCount; offset += 1) {
+    const body = bodyIndices[offset];
+    if (isDynamicBody(bodies, body))
+      integrateDynamicVelocity(bodies, body, gravityX, gravityY, dt);
+    bodies.forceX[body] = 0;
+    bodies.forceY[body] = 0;
+    bodies.torque[body] = 0;
+  }
+}
+function integrateCandidatePoses2D(bodies, bodyIndices, bodyCount, dt) {
+  for (let offset = 0; offset < bodyCount; offset += 1) {
+    const body = bodyIndices[offset];
+    if ((bodies.flags[body] & BODY_TYPE_MASK_2D) !== 0)
+      integratePose(bodies, body, dt);
+  }
+}
+function integrateDynamicVelocity(bodies, bodyIndex, gravityX, gravityY, dt) {
+  const inverseMass = bodies.inverseMass[bodyIndex];
+  const gravityScale = bodies.gravityScale[bodyIndex];
+  bodies.linearVelocityX[bodyIndex] = (bodies.linearVelocityX[bodyIndex] + dt * (gravityX * gravityScale + bodies.forceX[bodyIndex] * inverseMass)) / (1 + bodies.linearDamping[bodyIndex] * dt);
+  bodies.linearVelocityY[bodyIndex] = (bodies.linearVelocityY[bodyIndex] + dt * (gravityY * gravityScale + bodies.forceY[bodyIndex] * inverseMass)) / (1 + bodies.linearDamping[bodyIndex] * dt);
+  if (isFixedRotation(bodies, bodyIndex)) {
+    bodies.inverseInertia[bodyIndex] = 0;
+    bodies.angularVelocity[bodyIndex] = 0;
+  } else {
+    bodies.angularVelocity[bodyIndex] = (bodies.angularVelocity[bodyIndex] + dt * bodies.torque[bodyIndex] * bodies.inverseInertia[bodyIndex]) / (1 + bodies.angularDamping[bodyIndex] * dt);
+  }
+}
+function integratePose(bodies, bodyIndex, dt) {
+  bodies.positionX[bodyIndex] += bodies.linearVelocityX[bodyIndex] * dt;
+  bodies.positionY[bodyIndex] += bodies.linearVelocityY[bodyIndex] * dt;
+  bodies.rotationRadians[bodyIndex] += bodies.angularVelocity[bodyIndex] * dt;
+}
+function isDynamicBody(bodies, bodyIndex) {
+  return (bodies.flags[bodyIndex] & BODY_TYPE_MASK_2D) === BODY_TYPE_DYNAMIC_2D && bodies.inverseMass[bodyIndex] > 0;
+}
+function isFixedRotation(bodies, bodyIndex) {
+  return (bodies.flags[bodyIndex] & BODY_FIXED_ROTATION_2D) !== 0;
+}
+export {
+  BODY_FIXED_ROTATION_2D,
+  BODY_TYPE_DYNAMIC_2D,
+  BODY_TYPE_KINEMATIC_2D,
+  applyForceAtPointToCandidateBody2D,
+  applyImpulseAtPointToCandidateBody2D,
+  applyTorqueToCandidateBody2D,
+  integrateCandidateBodies2D,
+  integrateCandidatePoses2D,
+  integrateCandidateVelocities2D
+};
+//# sourceMappingURL=integrator.js.map

package/dist/features/physics/lib/2d/world/integrator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/world/integrator.ts"],
+  "sourcesContent": ["import type { BodyStore2D } from \"./storage.js\";\n\nexport const BODY_TYPE_DYNAMIC_2D = 1 << 0;\nexport const BODY_TYPE_KINEMATIC_2D = 1 << 1;\nexport const BODY_FIXED_ROTATION_2D = 1 << 2;\n\nconst BODY_TYPE_MASK_2D = BODY_TYPE_DYNAMIC_2D | BODY_TYPE_KINEMATIC_2D;\n\nexport function applyForceAtPointToCandidateBody2D(\n  bodies: BodyStore2D,\n  bodyIndex: number,\n  bodyGeneration: number,\n  forceX: number,\n  forceY: number,\n  pointX: number,\n  pointY: number,\n): boolean {\n  if (!bodies.has(bodyIndex, bodyGeneration)) return false;\n  if (!isDynamicBody(bodies, bodyIndex)) return true;\n  bodies.forceX[bodyIndex] += forceX;\n  bodies.forceY[bodyIndex] += forceY;\n  if (!isFixedRotation(bodies, bodyIndex)) {\n    bodies.torque[bodyIndex] +=\n      (pointX - bodies.positionX[bodyIndex]!) * forceY -\n      (pointY - bodies.positionY[bodyIndex]!) * forceX;\n  }\n  return true;\n}\n\nexport function applyTorqueToCandidateBody2D(\n  bodies: BodyStore2D,\n  bodyIndex: number,\n  bodyGeneration: number,\n  torque: number,\n): boolean {\n  if (!bodies.has(bodyIndex, bodyGeneration)) return false;\n  if (isDynamicBody(bodies, bodyIndex) && !isFixedRotation(bodies, bodyIndex)) {\n    bodies.torque[bodyIndex] += torque;\n  }\n  return true;\n}\n\nexport function applyImpulseAtPointToCandidateBody2D(\n  bodies: BodyStore2D,\n  bodyIndex: number,\n  bodyGeneration: number,\n  impulseX: number,\n  impulseY: number,\n  pointX: number,\n  pointY: number,\n): boolean {\n  if (!bodies.has(bodyIndex, bodyGeneration)) return false;\n  if (!isDynamicBody(bodies, bodyIndex)) return true;\n  const inverseMass = bodies.inverseMass[bodyIndex]!;\n  bodies.linearVelocityX[bodyIndex] += impulseX * inverseMass;\n  bodies.linearVelocityY[bodyIndex] += impulseY * inverseMass;\n  if (!isFixedRotation(bodies, bodyIndex)) {\n    bodies.angularVelocity[bodyIndex] +=\n      ((pointX - bodies.positionX[bodyIndex]!) * impulseY -\n        (pointY - bodies.positionY[bodyIndex]!) * impulseX) *\n      bodies.inverseInertia[bodyIndex]!;\n  }\n  return true;\n}\n\nexport function integrateCandidateBodies2D(\n  bodies: BodyStore2D,\n  bodyIndices: Int32Array,\n  bodyCount: number,\n  gravityX: number,\n  gravityY: number,\n  dt: number,\n): void {\n  for (let offset = 0; offset < bodyCount; offset += 1) {\n    const bodyIndex = bodyIndices[offset]!;\n    const type = bodies.flags[bodyIndex]! & BODY_TYPE_MASK_2D;\n    if (type === BODY_TYPE_DYNAMIC_2D) {\n      integrateDynamicVelocity(bodies, bodyIndex, gravityX, gravityY, dt);\n      integratePose(bodies, bodyIndex, dt);\n    } else if (type === BODY_TYPE_KINEMATIC_2D) {\n      integratePose(bodies, bodyIndex, dt);\n    }\n    bodies.forceX[bodyIndex] = 0;\n    bodies.forceY[bodyIndex] = 0;\n    bodies.torque[bodyIndex] = 0;\n  }\n}\n\n/** Integrate acceleration separately so resting constraints act before position drift. */\nexport function integrateCandidateVelocities2D(\n  bodies: BodyStore2D,\n  bodyIndices: Int32Array,\n  bodyCount: number,\n  gravityX: number,\n  gravityY: number,\n  dt: number,\n): void {\n  for (let offset = 0; offset < bodyCount; offset += 1) {\n    const body = bodyIndices[offset]!;\n    if (isDynamicBody(bodies, body))\n      integrateDynamicVelocity(bodies, body, gravityX, gravityY, dt);\n    bodies.forceX[body] = 0;\n    bodies.forceY[body] = 0;\n    bodies.torque[body] = 0;\n  }\n}\n\nexport function integrateCandidatePoses2D(\n  bodies: BodyStore2D,\n  bodyIndices: Int32Array,\n  bodyCount: number,\n  dt: number,\n): void {\n  for (let offset = 0; offset < bodyCount; offset += 1) {\n    const body = bodyIndices[offset]!;\n    if ((bodies.flags[body]! & BODY_TYPE_MASK_2D) !== 0)\n      integratePose(bodies, body, dt);\n  }\n}\n\nfunction integrateDynamicVelocity(\n  bodies: BodyStore2D,\n  bodyIndex: number,\n  gravityX: number,\n  gravityY: number,\n  dt: number,\n): void {\n  const inverseMass = bodies.inverseMass[bodyIndex]!;\n  const gravityScale = bodies.gravityScale[bodyIndex]!;\n  bodies.linearVelocityX[bodyIndex] =\n    (bodies.linearVelocityX[bodyIndex]! +\n      dt *\n        (gravityX * gravityScale + bodies.forceX[bodyIndex]! * inverseMass)) /\n    (1 + bodies.linearDamping[bodyIndex]! * dt);\n  bodies.linearVelocityY[bodyIndex] =\n    (bodies.linearVelocityY[bodyIndex]! +\n      dt *\n        (gravityY * gravityScale + bodies.forceY[bodyIndex]! * inverseMass)) /\n    (1 + bodies.linearDamping[bodyIndex]! * dt);\n\n  if (isFixedRotation(bodies, bodyIndex)) {\n    bodies.inverseInertia[bodyIndex] = 0;\n    bodies.angularVelocity[bodyIndex] = 0;\n  } else {\n    bodies.angularVelocity[bodyIndex] =\n      (bodies.angularVelocity[bodyIndex]! +\n        dt * bodies.torque[bodyIndex]! * bodies.inverseInertia[bodyIndex]!) /\n      (1 + bodies.angularDamping[bodyIndex]! * dt);\n  }\n}\n\nfunction integratePose(\n  bodies: BodyStore2D,\n  bodyIndex: number,\n  dt: number,\n): void {\n  bodies.positionX[bodyIndex] += bodies.linearVelocityX[bodyIndex]! * dt;\n  bodies.positionY[bodyIndex] += bodies.linearVelocityY[bodyIndex]! * dt;\n  bodies.rotationRadians[bodyIndex] += bodies.angularVelocity[bodyIndex]! * dt;\n}\n\nfunction isDynamicBody(bodies: BodyStore2D, bodyIndex: number): boolean {\n  return (\n    (bodies.flags[bodyIndex]! & BODY_TYPE_MASK_2D) === BODY_TYPE_DYNAMIC_2D &&\n    bodies.inverseMass[bodyIndex]! > 0\n  );\n}\n\nfunction isFixedRotation(bodies: BodyStore2D, bodyIndex: number): boolean {\n  return (bodies.flags[bodyIndex]! & BODY_FIXED_ROTATION_2D) !== 0;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/physics/lib/2d/world/queries.d.ts

@@ -0,0 +1,62 @@
+import { type PibblPhysicsAabb2D, type PibblPhysicsPose2D, type PibblPhysicsRay2D, type PibblPhysicsShape2D, type PibblPhysicsVector2 } from "../../../2d-geometry.js";
+import type { PibblPhysicsBodyHandle2D, PibblPhysicsColliderHandle2D, PibblPhysicsQueryHit2D, PibblPhysicsQueryMatch2D, PibblPhysicsQueryMode, PibblPhysicsQueryOptions2D, PibblPhysicsQueryResult2D } from "../types.js";
+import type { DynamicAabbBroadPhase2D } from "./broad-phase.js";
+import type { BodyStore2D, ColliderStore2D } from "./storage.js";
+interface HandleIdentity2D {
+    readonly index: number;
+    readonly generation: number;
+}
+export interface CommittedWorldQueriesOptions2D {
+    readonly generation: number;
+    readonly bodies: BodyStore2D;
+    readonly colliders: ColliderStore2D;
+    readonly broadPhase: DynamicAabbBroadPhase2D;
+    readonly materializeBody: (index: number, generation: number) => PibblPhysicsBodyHandle2D;
+    readonly materializeCollider: (index: number, generation: number) => PibblPhysicsColliderHandle2D;
+    readonly resolveBody: (handle: PibblPhysicsBodyHandle2D) => HandleIdentity2D | null;
+    readonly resolveCollider: (handle: PibblPhysicsColliderHandle2D) => HandleIdentity2D | null;
+}
+export declare class CommittedWorldQueries2D {
+    private readonly options;
+    private active;
+    private candidateProxies;
+    private hitColliderIndices;
+    private hitColliderGenerations;
+    private hitBodyIndices;
+    private hitBodyGenerations;
+    private hitPointX;
+    private hitPointY;
+    private hitNormalX;
+    private hitNormalY;
+    private hitDistances;
+    private hitTimes;
+    private hitCount;
+    private readonly shapeShells;
+    constructor(options: CommittedWorldQueriesOptions2D);
+    invalidate(): void;
+    raycast<Mode extends PibblPhysicsQueryMode = "closest">(worldGeneration: number, ray: PibblPhysicsRay2D, queryOptions?: PibblPhysicsQueryOptions2D<Mode>): PibblPhysicsQueryResult2D<Mode, PibblPhysicsQueryHit2D>;
+    shapeCast<Mode extends PibblPhysicsQueryMode = "closest">(worldGeneration: number, shape: PibblPhysicsShape2D, from: PibblPhysicsPose2D, translation: PibblPhysicsVector2, queryOptions?: PibblPhysicsQueryOptions2D<Mode>): PibblPhysicsQueryResult2D<Mode, PibblPhysicsQueryHit2D>;
+    overlapShape<Mode extends PibblPhysicsQueryMode = "closest">(worldGeneration: number, shape: PibblPhysicsShape2D, pose: PibblPhysicsPose2D, queryOptions?: PibblPhysicsQueryOptions2D<Mode>): PibblPhysicsQueryResult2D<Mode, PibblPhysicsQueryMatch2D>;
+    queryAabb<Mode extends PibblPhysicsQueryMode = "closest">(worldGeneration: number, bounds: PibblPhysicsAabb2D, queryOptions?: PibblPhysicsQueryOptions2D<Mode>): PibblPhysicsQueryResult2D<Mode, PibblPhysicsQueryMatch2D>;
+    queryPoint<Mode extends PibblPhysicsQueryMode = "closest">(worldGeneration: number, point: PibblPhysicsVector2, queryOptions?: PibblPhysicsQueryOptions2D<Mode>): PibblPhysicsQueryResult2D<Mode, PibblPhysicsQueryMatch2D>;
+    private runMatchQuery;
+    private prepareOptions;
+    private isUsable;
+    private isGenerationLive;
+    private beginQuery;
+    private queryCandidates;
+    private semanticColliderAt;
+    private appendHit;
+    private appendMatch;
+    private writeIdentity;
+    private finishHits;
+    private finishMatches;
+    private materializeHit;
+    private materializeMatch;
+    private sortHits;
+    private compareHits;
+    private swapHits;
+    private shapeShell;
+    private ensureCapacity;
+}
+export {};

package/dist/features/physics/lib/2d/world/queries.js

@@ -0,0 +1,424 @@
+import {
+  boundsOfShape2D
+} from "../../../2d-geometry.js";
+import { copyFiniteVector2, requireNonnegativeNumber } from "../../shared/validation.js";
+import { containsPointInShape2D, overlapPreparedShapes2D } from "../collision/pairs.js";
+import { raycastShape2D, shapeCastAgainstShape2D } from "../collision/casts.js";
+import { RADIANS_TO_DEGREES } from "../numeric-policy.js";
+import { createShape2D } from "../shape-records.js";
+import { collisionFiltersAllow2D } from "./ccd.js";
+import { COLLIDER_SENSOR_2D } from "./contact-cache.js";
+class CommittedWorldQueries2D {
+  constructor(options) {
+    this.options = options;
+    const capacity = normalizedCapacity(options.broadPhase.proxyCapacity);
+    this.candidateProxies = new Int32Array(capacity);
+    this.hitColliderIndices = new Int32Array(capacity);
+    this.hitColliderGenerations = new Uint32Array(capacity);
+    this.hitBodyIndices = new Int32Array(capacity);
+    this.hitBodyGenerations = new Uint32Array(capacity);
+    this.hitPointX = new Float64Array(capacity);
+    this.hitPointY = new Float64Array(capacity);
+    this.hitNormalX = new Float64Array(capacity);
+    this.hitNormalY = new Float64Array(capacity);
+    this.hitDistances = new Float64Array(capacity);
+    this.hitTimes = new Float64Array(capacity);
+  }
+  options;
+  active = true;
+  candidateProxies;
+  hitColliderIndices;
+  hitColliderGenerations;
+  hitBodyIndices;
+  hitBodyGenerations;
+  hitPointX;
+  hitPointY;
+  hitNormalX;
+  hitNormalY;
+  hitDistances;
+  hitTimes;
+  hitCount = 0;
+  shapeShells = /* @__PURE__ */ new WeakMap();
+  invalidate() {
+    this.active = false;
+    this.hitCount = 0;
+  }
+  raycast(worldGeneration, ray, queryOptions) {
+    const prepared = this.prepareOptions(queryOptions);
+    if (!this.isUsable(worldGeneration, prepared)) return emptyResult(prepared.mode);
+    const origin = copyFiniteVector2(ray.origin, "ray.origin");
+    const direction = copyFiniteVector2(ray.direction, "ray.direction");
+    const directionLength = Math.hypot(direction[0], direction[1]);
+    if (directionLength === 0) throw new RangeError("ray.direction must be non-zero.");
+    const maxDistance = requireNonnegativeNumber(ray.maxDistance, "ray.maxDistance");
+    const endX = origin[0] + direction[0] / directionLength * maxDistance;
+    const endY = origin[1] + direction[1] / directionLength * maxDistance;
+    this.beginQuery();
+    const candidateCount = this.queryCandidates(
+      Math.min(origin[0], endX),
+      Math.min(origin[1], endY),
+      Math.max(origin[0], endX),
+      Math.max(origin[1], endY)
+    );
+    for (let candidate = 0; candidate < candidateCount; candidate += 1) {
+      const collider = this.semanticColliderAt(candidate, prepared);
+      if (collider === null) continue;
+      const hit = raycastShape2D(collider.shape, collider.pose, ray);
+      if (hit === null) continue;
+      if (prepared.mode === "any") return true;
+      this.appendHit(collider, hit.point, hit.normal, hit.distance, hit.timeOfImpact);
+    }
+    return this.finishHits(prepared.mode);
+  }
+  shapeCast(worldGeneration, shape, from, translation, queryOptions) {
+    const prepared = this.prepareOptions(queryOptions);
+    if (!this.isUsable(worldGeneration, prepared)) return emptyResult(prepared.mode);
+    const copiedTranslation = copyFiniteVector2(translation, "translation");
+    const start = boundsOfShape2D(shape, from);
+    const end = boundsOfShape2D(shape, {
+      position: [from.position[0] + copiedTranslation[0], from.position[1] + copiedTranslation[1]],
+      rotationDegrees: from.rotationDegrees
+    });
+    this.beginQuery();
+    const candidateCount = this.queryCandidates(
+      Math.min(start.min[0], end.min[0]),
+      Math.min(start.min[1], end.min[1]),
+      Math.max(start.max[0], end.max[0]),
+      Math.max(start.max[1], end.max[1])
+    );
+    for (let candidate = 0; candidate < candidateCount; candidate += 1) {
+      const collider = this.semanticColliderAt(candidate, prepared);
+      if (collider === null) continue;
+      const hit = shapeCastAgainstShape2D(shape, from, copiedTranslation, collider.shape, collider.pose);
+      if (hit === null) continue;
+      if (prepared.mode === "any") return true;
+      this.appendHit(collider, hit.point, hit.normal, hit.distance, hit.timeOfImpact);
+    }
+    return this.finishHits(prepared.mode);
+  }
+  overlapShape(worldGeneration, shape, pose, queryOptions) {
+    const bounds = this.isGenerationLive(worldGeneration) ? boundsOfShape2D(shape, pose) : null;
+    return this.runMatchQuery(
+      worldGeneration,
+      bounds,
+      queryOptions,
+      (collider) => overlapPreparedShapes2D(shape, pose, collider.shape, collider.pose)
+    );
+  }
+  queryAabb(worldGeneration, bounds, queryOptions) {
+    if (!this.isGenerationLive(worldGeneration)) {
+      return emptyResult(modeOf(queryOptions));
+    }
+    const copied = copyAabb(bounds);
+    return this.runMatchQuery(worldGeneration, copied, queryOptions, (collider) => {
+      const colliderBounds = boundsOfShape2D(collider.shape, collider.pose);
+      return aabbsOverlap(copied, colliderBounds);
+    });
+  }
+  queryPoint(worldGeneration, point, queryOptions) {
+    if (!this.isGenerationLive(worldGeneration)) {
+      return emptyResult(modeOf(queryOptions));
+    }
+    const copied = copyFiniteVector2(point, "point");
+    const bounds = Object.freeze({ min: copied, max: copied });
+    return this.runMatchQuery(
+      worldGeneration,
+      bounds,
+      queryOptions,
+      (collider) => containsPointInShape2D(collider.shape, collider.pose, copied)
+    );
+  }
+  runMatchQuery(worldGeneration, bounds, queryOptions, matches) {
+    const prepared = this.prepareOptions(queryOptions);
+    if (bounds === null || !this.isUsable(worldGeneration, prepared)) {
+      return emptyResult(prepared.mode);
+    }
+    this.beginQuery();
+    const candidateCount = this.queryCandidates(bounds.min[0], bounds.min[1], bounds.max[0], bounds.max[1]);
+    for (let candidate = 0; candidate < candidateCount; candidate += 1) {
+      const collider = this.semanticColliderAt(candidate, prepared);
+      if (collider === null || !matches(collider)) continue;
+      if (prepared.mode === "any") {
+        return true;
+      }
+      this.appendMatch(collider);
+    }
+    return this.finishMatches(prepared.mode);
+  }
+  prepareOptions(queryOptions) {
+    const mode = modeOf(queryOptions);
+    const sensors = queryOptions?.sensors ?? "include";
+    if (sensors !== "include" && sensors !== "exclude" && sensors !== "only") {
+      throw new RangeError("query sensors must be include, exclude, or only.");
+    }
+    const excludeBody = queryOptions?.excludeBody === void 0 ? null : this.options.resolveBody(queryOptions.excludeBody);
+    const excludeCollider = queryOptions?.excludeCollider === void 0 ? null : this.options.resolveCollider(queryOptions.excludeCollider);
+    const validBody = queryOptions?.excludeBody === void 0 || excludeBody !== null && this.options.bodies.has(excludeBody.index, excludeBody.generation);
+    const validCollider = queryOptions?.excludeCollider === void 0 || excludeCollider !== null && this.options.colliders.has(excludeCollider.index, excludeCollider.generation);
+    return {
+      mode,
+      sensors,
+      collisionFilter: queryOptions?.collisionFilter ?? null,
+      excludeBody,
+      excludeCollider,
+      valid: validBody && validCollider
+    };
+  }
+  isUsable(worldGeneration, prepared) {
+    return this.isGenerationLive(worldGeneration) && prepared.valid;
+  }
+  isGenerationLive(worldGeneration) {
+    return this.active && worldGeneration === this.options.generation;
+  }
+  beginQuery() {
+    this.hitCount = 0;
+    this.ensureCapacity(this.options.broadPhase.proxyCapacity);
+  }
+  queryCandidates(minX, minY, maxX, maxY) {
+    return this.options.broadPhase.queryAabbInto(
+      minX,
+      minY,
+      maxX,
+      maxY,
+      this.candidateProxies,
+      0,
+      this.candidateProxies.length
+    );
+  }
+  semanticColliderAt(candidate, prepared) {
+    const proxy = this.candidateProxies[candidate];
+    const colliderIndex = this.options.broadPhase.proxyColliderIndices[proxy];
+    const colliderGeneration = this.options.broadPhase.proxyColliderGenerations[proxy];
+    const { colliders, bodies } = this.options;
+    if (!colliders.has(colliderIndex, colliderGeneration)) return null;
+    const bodyIndex = colliders.bodyIndices[colliderIndex];
+    const bodyGeneration = colliders.bodyGenerations[colliderIndex];
+    if (!bodies.has(bodyIndex, bodyGeneration)) return null;
+    if (sameIdentity(prepared.excludeBody, bodyIndex, bodyGeneration)) return null;
+    if (sameIdentity(prepared.excludeCollider, colliderIndex, colliderGeneration)) return null;
+    const sensor = (colliders.flags[colliderIndex] & COLLIDER_SENSOR_2D) !== 0;
+    if (prepared.sensors === "exclude" && sensor) return null;
+    if (prepared.sensors === "only" && !sensor) return null;
+    if (prepared.collisionFilter !== null && !collisionFiltersAllow2D(prepared.collisionFilter, colliders.filters[colliderIndex]))
+      return null;
+    const record = colliders.shapes[colliderIndex];
+    if (record === null) return null;
+    return {
+      colliderIndex,
+      colliderGeneration,
+      bodyIndex,
+      bodyGeneration,
+      shape: this.shapeShell(record),
+      pose: publicBodyOriginPose(bodies, bodyIndex)
+    };
+  }
+  appendHit(collider, point, normal, distance, time) {
+    const target = this.hitCount;
+    this.writeIdentity(target, collider);
+    this.hitPointX[target] = point[0];
+    this.hitPointY[target] = point[1];
+    this.hitNormalX[target] = normal[0];
+    this.hitNormalY[target] = normal[1];
+    this.hitDistances[target] = distance;
+    this.hitTimes[target] = time;
+    this.hitCount += 1;
+  }
+  appendMatch(collider) {
+    this.writeIdentity(this.hitCount, collider);
+    this.hitCount += 1;
+  }
+  writeIdentity(target, collider) {
+    this.hitColliderIndices[target] = collider.colliderIndex;
+    this.hitColliderGenerations[target] = collider.colliderGeneration;
+    this.hitBodyIndices[target] = collider.bodyIndex;
+    this.hitBodyGenerations[target] = collider.bodyGeneration;
+  }
+  finishHits(mode) {
+    this.sortHits(true);
+    if (mode === "any") {
+      return false;
+    }
+    if (mode === "closest") {
+      return this.hitCount === 0 ? null : this.materializeHit(0);
+    }
+    const results = [];
+    for (let index = 0; index < this.hitCount; index += 1) {
+      results.push(this.materializeHit(index));
+    }
+    return Object.freeze(results);
+  }
+  finishMatches(mode) {
+    this.sortHits(false);
+    if (mode === "any") {
+      return false;
+    }
+    if (mode === "closest") {
+      return this.hitCount === 0 ? null : this.materializeMatch(0);
+    }
+    const results = [];
+    for (let index = 0; index < this.hitCount; index += 1) {
+      results.push(this.materializeMatch(index));
+    }
+    return Object.freeze(results);
+  }
+  materializeHit(index) {
+    return Object.freeze({
+      ...this.materializeMatch(index),
+      point: freezeVector(this.hitPointX[index], this.hitPointY[index]),
+      normal: freezeVector(this.hitNormalX[index], this.hitNormalY[index]),
+      distance: this.hitDistances[index],
+      timeOfImpact: this.hitTimes[index]
+    });
+  }
+  materializeMatch(index) {
+    const bodyIndex = this.hitBodyIndices[index];
+    const bodyGeneration = this.hitBodyGenerations[index];
+    const colliderIndex = this.hitColliderIndices[index];
+    const colliderGeneration = this.hitColliderGenerations[index];
+    return Object.freeze({
+      body: this.options.materializeBody(bodyIndex, bodyGeneration),
+      collider: this.options.materializeCollider(colliderIndex, colliderGeneration),
+      bodyGeneration,
+      colliderGeneration,
+      tag: this.options.colliders.tags[colliderIndex]
+    });
+  }
+  sortHits(withDistance) {
+    for (let index = 1; index < this.hitCount; index += 1) {
+      let current = index;
+      while (current > 0 && this.compareHits(current, current - 1, withDistance) < 0) {
+        this.swapHits(current, current - 1, withDistance);
+        current -= 1;
+      }
+    }
+  }
+  compareHits(first, second, withDistance) {
+    if (withDistance) {
+      const time = this.hitTimes[first] - this.hitTimes[second];
+      if (time !== 0) return time;
+      const distance = this.hitDistances[first] - this.hitDistances[second];
+      if (distance !== 0) return distance;
+    }
+    return this.hitColliderIndices[first] - this.hitColliderIndices[second] || this.hitColliderGenerations[first] - this.hitColliderGenerations[second];
+  }
+  swapHits(first, second, withDistance) {
+    swapInt32(this.hitColliderIndices, first, second);
+    swapUint32(this.hitColliderGenerations, first, second);
+    swapInt32(this.hitBodyIndices, first, second);
+    swapUint32(this.hitBodyGenerations, first, second);
+    if (!withDistance) return;
+    swapFloat64(this.hitPointX, first, second);
+    swapFloat64(this.hitPointY, first, second);
+    swapFloat64(this.hitNormalX, first, second);
+    swapFloat64(this.hitNormalY, first, second);
+    swapFloat64(this.hitDistances, first, second);
+    swapFloat64(this.hitTimes, first, second);
+  }
+  shapeShell(record) {
+    let shell = this.shapeShells.get(record);
+    if (shell === void 0) {
+      shell = createShape2D(record);
+      this.shapeShells.set(record, shell);
+    }
+    return shell;
+  }
+  ensureCapacity(required) {
+    if (required <= this.candidateProxies.length) return;
+    const capacity = normalizedCapacity(required);
+    this.candidateProxies = growInt32(this.candidateProxies, capacity);
+    this.hitColliderIndices = growInt32(this.hitColliderIndices, capacity);
+    this.hitColliderGenerations = growUint32(this.hitColliderGenerations, capacity);
+    this.hitBodyIndices = growInt32(this.hitBodyIndices, capacity);
+    this.hitBodyGenerations = growUint32(this.hitBodyGenerations, capacity);
+    this.hitPointX = growFloat64(this.hitPointX, capacity);
+    this.hitPointY = growFloat64(this.hitPointY, capacity);
+    this.hitNormalX = growFloat64(this.hitNormalX, capacity);
+    this.hitNormalY = growFloat64(this.hitNormalY, capacity);
+    this.hitDistances = growFloat64(this.hitDistances, capacity);
+    this.hitTimes = growFloat64(this.hitTimes, capacity);
+  }
+}
+function modeOf(options) {
+  const mode = options?.mode ?? "closest";
+  if (mode !== "closest" && mode !== "any" && mode !== "all") {
+    throw new RangeError("query mode must be closest, any, or all.");
+  }
+  return mode;
+}
+function emptyResult(mode) {
+  return mode === "any" ? false : mode === "all" ? Object.freeze([]) : null;
+}
+function sameIdentity(identity, index, generation) {
+  return identity !== null && identity.index === index && identity.generation === generation;
+}
+function publicPose(x, y, rotationRadians) {
+  return {
+    position: [x, y],
+    rotationDegrees: rotationRadians * RADIANS_TO_DEGREES
+  };
+}
+function publicBodyOriginPose(bodies, index) {
+  const rotationRadians = bodies.rotationRadians[index];
+  const cosine = Math.cos(rotationRadians);
+  const sine = Math.sin(rotationRadians);
+  const localCenterX = bodies.localCenterX[index];
+  const localCenterY = bodies.localCenterY[index];
+  return publicPose(
+    bodies.positionX[index] - cosine * localCenterX + sine * localCenterY,
+    bodies.positionY[index] - sine * localCenterX - cosine * localCenterY,
+    rotationRadians
+  );
+}
+function copyAabb(bounds) {
+  const min = copyFiniteVector2(bounds.min, "bounds.min");
+  const max = copyFiniteVector2(bounds.max, "bounds.max");
+  if (min[0] > max[0] || min[1] > max[1]) {
+    throw new RangeError("bounds.min must not exceed bounds.max.");
+  }
+  return Object.freeze({ min, max });
+}
+function aabbsOverlap(first, second) {
+  return first.min[0] <= second.max[0] && first.max[0] >= second.min[0] && first.min[1] <= second.max[1] && first.max[1] >= second.min[1];
+}
+function freezeVector(x, y) {
+  return Object.freeze([x, y]);
+}
+function normalizedCapacity(required) {
+  let capacity = 1;
+  while (capacity < required) capacity *= 2;
+  return capacity;
+}
+function growInt32(source, capacity) {
+  const result = new Int32Array(capacity);
+  result.set(source);
+  return result;
+}
+function growUint32(source, capacity) {
+  const result = new Uint32Array(capacity);
+  result.set(source);
+  return result;
+}
+function growFloat64(source, capacity) {
+  const result = new Float64Array(capacity);
+  result.set(source);
+  return result;
+}
+function swapInt32(values, first, second) {
+  const value = values[first];
+  values[first] = values[second];
+  values[second] = value;
+}
+function swapUint32(values, first, second) {
+  const value = values[first];
+  values[first] = values[second];
+  values[second] = value;
+}
+function swapFloat64(values, first, second) {
+  const value = values[first];
+  values[first] = values[second];
+  values[second] = value;
+}
+export {
+  CommittedWorldQueries2D
+};
+//# sourceMappingURL=queries.js.map