@nice2dev/game-engine 1.3.15 → 1.3.16

package/dist/esm/systems/PhysicsDebugSystem.js

@@ -1,1218 +1,1156 @@
-/**
- * @file PhysicsDebugSystem.ts
- * @description Advanced Physics Debug Visualization System
- * PRO-1.4: Professional Editor Features
- *
- * Features:
- * - Collider visualization (all shapes)
- * - Contact point visualization
- * - Force/velocity vectors
- * - Physics stats overlay
- * - Joint visualization
- * - Collision layers matrix
- * - Performance profiling
- * - Configurable visualizations
- */
 const DEFAULT_DEBUG_COLORS = {
-    staticCollider: { r: 0.5, g: 0.5, b: 0.5, a: 0.5 },
-    kinematicCollider: { r: 0.8, g: 0.5, b: 0.2, a: 0.5 },
-    dynamicCollider: { r: 0.2, g: 0.8, b: 0.2, a: 0.5 },
-    triggerCollider: { r: 0.2, g: 0.8, b: 0.8, a: 0.3 },
-    sleepingCollider: { r: 0.4, g: 0.4, b: 0.6, a: 0.3 },
-    activeBody: { r: 0.2, g: 1.0, b: 0.2, a: 0.8 },
-    sleepingBody: { r: 0.5, g: 0.5, b: 0.8, a: 0.5 },
-    contactPoint: { r: 1.0, g: 0.5, b: 0.0, a: 1.0 },
-    contactNormal: { r: 0.0, g: 1.0, b: 1.0, a: 0.8 },
-    contactImpulse: { r: 1.0, g: 0.0, b: 0.0, a: 0.8 },
-    velocity: { r: 0.0, g: 1.0, b: 0.0, a: 0.8 },
-    angularVelocity: { r: 1.0, g: 1.0, b: 0.0, a: 0.8 },
-    force: { r: 1.0, g: 0.0, b: 0.5, a: 0.8 },
-    torque: { r: 0.5, g: 0.0, b: 1.0, a: 0.8 },
-    jointActive: { r: 0.0, g: 0.8, b: 0.0, a: 0.8 },
-    jointBroken: { r: 1.0, g: 0.0, b: 0.0, a: 0.8 },
-    jointLimit: { r: 1.0, g: 0.5, b: 0.0, a: 0.6 },
-    jointMotor: { r: 0.0, g: 0.5, b: 1.0, a: 0.8 },
-    raycastHit: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 },
-    raycastMiss: { r: 0.5, g: 0.5, b: 0.5, a: 0.5 },
-    aabbOverlap: { r: 1.0, g: 1.0, b: 0.0, a: 0.3 },
-    layerColors: [
-        { r: 1.0, g: 0.0, b: 0.0, a: 0.5 },
-        { r: 0.0, g: 1.0, b: 0.0, a: 0.5 },
-        { r: 0.0, g: 0.0, b: 1.0, a: 0.5 },
-        { r: 1.0, g: 1.0, b: 0.0, a: 0.5 },
-        { r: 1.0, g: 0.0, b: 1.0, a: 0.5 },
-        { r: 0.0, g: 1.0, b: 1.0, a: 0.5 },
-        { r: 1.0, g: 0.5, b: 0.0, a: 0.5 },
-        { r: 0.5, g: 0.0, b: 1.0, a: 0.5 },
-    ],
+  staticCollider: { r: 0.5, g: 0.5, b: 0.5, a: 0.5 },
+  kinematicCollider: { r: 0.8, g: 0.5, b: 0.2, a: 0.5 },
+  dynamicCollider: { r: 0.2, g: 0.8, b: 0.2, a: 0.5 },
+  triggerCollider: { r: 0.2, g: 0.8, b: 0.8, a: 0.3 },
+  sleepingCollider: { r: 0.4, g: 0.4, b: 0.6, a: 0.3 },
+  activeBody: { r: 0.2, g: 1, b: 0.2, a: 0.8 },
+  sleepingBody: { r: 0.5, g: 0.5, b: 0.8, a: 0.5 },
+  contactPoint: { r: 1, g: 0.5, b: 0, a: 1 },
+  contactNormal: { r: 0, g: 1, b: 1, a: 0.8 },
+  contactImpulse: { r: 1, g: 0, b: 0, a: 0.8 },
+  velocity: { r: 0, g: 1, b: 0, a: 0.8 },
+  angularVelocity: { r: 1, g: 1, b: 0, a: 0.8 },
+  force: { r: 1, g: 0, b: 0.5, a: 0.8 },
+  torque: { r: 0.5, g: 0, b: 1, a: 0.8 },
+  jointActive: { r: 0, g: 0.8, b: 0, a: 0.8 },
+  jointBroken: { r: 1, g: 0, b: 0, a: 0.8 },
+  jointLimit: { r: 1, g: 0.5, b: 0, a: 0.6 },
+  jointMotor: { r: 0, g: 0.5, b: 1, a: 0.8 },
+  raycastHit: { r: 1, g: 0, b: 0, a: 1 },
+  raycastMiss: { r: 0.5, g: 0.5, b: 0.5, a: 0.5 },
+  aabbOverlap: { r: 1, g: 1, b: 0, a: 0.3 },
+  layerColors: [
+    { r: 1, g: 0, b: 0, a: 0.5 },
+    { r: 0, g: 1, b: 0, a: 0.5 },
+    { r: 0, g: 0, b: 1, a: 0.5 },
+    { r: 1, g: 1, b: 0, a: 0.5 },
+    { r: 1, g: 0, b: 1, a: 0.5 },
+    { r: 0, g: 1, b: 1, a: 0.5 },
+    { r: 1, g: 0.5, b: 0, a: 0.5 },
+    { r: 0.5, g: 0, b: 1, a: 0.5 }
+  ]
 };
 const DEFAULT_DEBUG_OPTIONS = {
-    enabled: true,
-    showColliders: true,
-    showTriggers: true,
-    showContactPoints: true,
-    showContactNormals: true,
-    showContactImpulse: false,
-    showVelocities: true,
-    showAngularVelocities: false,
-    showForces: false,
-    showJoints: true,
-    showJointLimits: true,
-    showCenterOfMass: true,
-    showAABB: false,
-    showSleepState: true,
-    showLayerColors: false,
-    showRaycasts: true,
-    filterByLayer: null,
-    filterByBodyType: null,
-    filterByEntity: null,
-    hideStaticColliders: false,
-    hideSleepingBodies: false,
-    velocityScale: 1,
-    forceScale: 0.1,
-    normalScale: 1,
-    impulseScale: 0.01,
-    colliderLineWidth: 2,
-    vectorLineWidth: 2,
-    jointLineWidth: 3,
-    contactHistoryDuration: 500,
-    maxContactHistory: 100,
-    showStatsOverlay: true,
-    statsPosition: 'top-left',
-    colors: DEFAULT_DEBUG_COLORS,
+  enabled: true,
+  showColliders: true,
+  showTriggers: true,
+  showContactPoints: true,
+  showContactNormals: true,
+  showContactImpulse: false,
+  showVelocities: true,
+  showAngularVelocities: false,
+  showForces: false,
+  showJoints: true,
+  showJointLimits: true,
+  showCenterOfMass: true,
+  showAABB: false,
+  showSleepState: true,
+  showLayerColors: false,
+  showRaycasts: true,
+  filterByLayer: null,
+  filterByBodyType: null,
+  filterByEntity: null,
+  hideStaticColliders: false,
+  hideSleepingBodies: false,
+  velocityScale: 1,
+  forceScale: 0.1,
+  normalScale: 1,
+  impulseScale: 0.01,
+  colliderLineWidth: 2,
+  vectorLineWidth: 2,
+  jointLineWidth: 3,
+  contactHistoryDuration: 500,
+  maxContactHistory: 100,
+  showStatsOverlay: true,
+  statsPosition: "top-left",
+  colors: DEFAULT_DEBUG_COLORS
 };
-// ============================================================
-// Physics Debug System
-// ============================================================
 class PhysicsDebugSystem {
-    constructor() {
-        this.options = { ...DEFAULT_DEBUG_OPTIONS };
-        this.drawCommands = [];
-        this.contactHistory = [];
-        // Data caches (updated by physics engine)
-        this.colliders2D = new Map();
-        this.colliders3D = new Map();
-        this.bodies2D = new Map();
-        this.bodies3D = new Map();
-        this.joints2D = new Map();
-        this.joints3D = new Map();
-        this.transforms2D = new Map();
-        this.transforms3D = new Map();
-        this.collisionPairs = [];
-        this.raycasts = [];
-        this.is3D = false;
-        this.stats = this.createEmptyStats();
+  constructor() {
+    this.options = { ...DEFAULT_DEBUG_OPTIONS };
+    this.drawCommands = [];
+    this.contactHistory = [];
+    this.colliders2D = /* @__PURE__ */ new Map();
+    this.colliders3D = /* @__PURE__ */ new Map();
+    this.bodies2D = /* @__PURE__ */ new Map();
+    this.bodies3D = /* @__PURE__ */ new Map();
+    this.joints2D = /* @__PURE__ */ new Map();
+    this.joints3D = /* @__PURE__ */ new Map();
+    this.transforms2D = /* @__PURE__ */ new Map();
+    this.transforms3D = /* @__PURE__ */ new Map();
+    this.collisionPairs = [];
+    this.raycasts = [];
+    this.is3D = false;
+    this.stats = this.createEmptyStats();
+  }
+  createEmptyStats() {
+    return {
+      totalBodies: 0,
+      dynamicBodies: 0,
+      kinematicBodies: 0,
+      staticBodies: 0,
+      awakeBodies: 0,
+      sleepingBodies: 0,
+      totalColliders: 0,
+      activeColliders: 0,
+      triggers: 0,
+      collisionPairs: 0,
+      contactPoints: 0,
+      islandCount: 0,
+      stepTime: 0,
+      broadphaseTime: 0,
+      narrowphaseTime: 0,
+      solverTime: 0,
+      integrationTime: 0,
+      bodyMemory: 0,
+      colliderMemory: 0,
+      contactMemory: 0,
+      totalJoints: 0,
+      activeJoints: 0,
+      brokenJoints: 0,
+      raycastsThisFrame: 0,
+      overlapTestsThisFrame: 0
+    };
+  }
+  // ─── Configuration ─────────────────────────────────────
+  setOptions(options) {
+    this.options = { ...this.options, ...options };
+  }
+  getOptions() {
+    return { ...this.options };
+  }
+  setEnabled(enabled) {
+    this.options.enabled = enabled;
+  }
+  isEnabled() {
+    return this.options.enabled;
+  }
+  set3DMode(is3D) {
+    this.is3D = is3D;
+  }
+  // ─── Data Update (called by physics engine) ────────────
+  updateCollider2D(collider) {
+    this.colliders2D.set(collider.id, collider);
+  }
+  removeCollider2D(colliderId) {
+    this.colliders2D.delete(colliderId);
+  }
+  updateCollider3D(collider) {
+    this.colliders3D.set(collider.id, collider);
+  }
+  removeCollider3D(colliderId) {
+    this.colliders3D.delete(colliderId);
+  }
+  updateBody2D(body) {
+    this.bodies2D.set(body.id, body);
+  }
+  removeBody2D(bodyId) {
+    this.bodies2D.delete(bodyId);
+  }
+  updateBody3D(body) {
+    this.bodies3D.set(body.id, body);
+  }
+  removeBody3D(bodyId) {
+    this.bodies3D.delete(bodyId);
+  }
+  updateTransform2D(entityId, transform) {
+    this.transforms2D.set(entityId, transform);
+  }
+  updateTransform3D(entityId, transform) {
+    this.transforms3D.set(entityId, transform);
+  }
+  updateJoint2D(joint) {
+    this.joints2D.set(joint.id, joint);
+  }
+  removeJoint2D(jointId) {
+    this.joints2D.delete(jointId);
+  }
+  updateJoint3D(joint) {
+    this.joints3D.set(joint.id, joint);
+  }
+  removeJoint3D(jointId) {
+    this.joints3D.delete(jointId);
+  }
+  setCollisionPairs(pairs) {
+    this.collisionPairs = pairs;
+    const now = Date.now();
+    for (const pair of pairs) {
+      for (const contact of pair.contacts) {
+        if (this.contactHistory.length >= this.options.maxContactHistory) {
+          this.contactHistory.shift();
+        }
+        "z" in contact.point;
+        this.contactHistory.push({
+          timestamp: now,
+          point: contact.point,
+          normal: contact.normal,
+          impulse: contact.impulse,
+          idA: pair.idA,
+          idB: pair.idB
+        });
+      }
+    }
+    const cutoff = now - this.options.contactHistoryDuration;
+    this.contactHistory = this.contactHistory.filter((c) => c.timestamp > cutoff);
+  }
+  addRaycast(origin, direction, maxDistance, hit) {
+    this.raycasts.push({ origin, direction, maxDistance, hit });
+  }
+  updateStats(stats) {
+    Object.assign(this.stats, stats);
+  }
+  // ─── Generate Draw Commands ────────────────────────────
+  generateDrawCommands() {
+    this.drawCommands = [];
+    if (!this.options.enabled) {
+      return this.drawCommands;
+    }
+    this.calculateStats();
+    if (this.is3D) {
+      this.generateDrawCommands3D();
+    } else {
+      this.generateDrawCommands2D();
+    }
+    this.drawCommands.sort((a, b) => a.zOrder - b.zOrder);
+    return this.drawCommands;
+  }
+  generateDrawCommands2D() {
+    const opts = this.options;
+    const colors = opts.colors;
+    if (opts.showColliders || opts.showTriggers) {
+      for (const [_id, collider] of this.colliders2D) {
+        if (!this.shouldDrawCollider2D(collider)) {
+          continue;
+        }
+        const transform = this.transforms2D.get(collider.entityId);
+        if (!transform) {
+          continue;
+        }
+        const body = this.findBody2DForEntity(collider.entityId);
+        const color = this.getColliderColor2D(collider, body);
+        this.drawCollider2D(collider, transform, color);
+      }
+    }
+    if (opts.showVelocities) {
+      for (const [_id, body] of this.bodies2D) {
+        if (body.bodyType === "static") {
+          continue;
+        }
+        if (opts.hideSleepingBodies && body.isSleeping) {
+          continue;
+        }
+        const transform = this.transforms2D.get(body.entityId);
+        if (!transform) {
+          continue;
+        }
+        const endX = transform.position.x + body.linearVelocity.x * opts.velocityScale;
+        const endY = transform.position.y + body.linearVelocity.y * opts.velocityScale;
+        this.drawCommands.push({
+          type: "arrow",
+          color: colors.velocity,
+          zOrder: 10,
+          points: [transform.position, { x: endX, y: endY }],
+          lineWidth: opts.vectorLineWidth
+        });
+      }
+    }
+    if (opts.showAngularVelocities) {
+      for (const [_id, body] of this.bodies2D) {
+        if (body.bodyType === "static") {
+          continue;
+        }
+        const transform = this.transforms2D.get(body.entityId);
+        if (!transform) {
+          continue;
+        }
+        const radius = Math.abs(body.angularVelocity) * opts.velocityScale * 0.5;
+        this.drawCommands.push({
+          type: "arc",
+          color: colors.angularVelocity,
+          zOrder: 10,
+          position: transform.position,
+          radius: Math.max(radius, 0.2),
+          startAngle: 0,
+          endAngle: body.angularVelocity > 0 ? Math.PI : -Math.PI,
+          lineWidth: opts.vectorLineWidth
+        });
+      }
+    }
+    if (opts.showForces) {
+      for (const [_id, body] of this.bodies2D) {
+        const transform = this.transforms2D.get(body.entityId);
+        if (!transform) {
+          continue;
+        }
+        if (body.forceAccumulator.x !== 0 || body.forceAccumulator.y !== 0) {
+          const endX = transform.position.x + body.forceAccumulator.x * opts.forceScale;
+          const endY = transform.position.y + body.forceAccumulator.y * opts.forceScale;
+          this.drawCommands.push({
+            type: "arrow",
+            color: colors.force,
+            zOrder: 11,
+            points: [transform.position, { x: endX, y: endY }],
+            lineWidth: opts.vectorLineWidth
+          });
+        }
+      }
+    }
+    if (opts.showJoints) {
+      for (const [_id, joint] of this.joints2D) {
+        this.drawJoint2D(joint);
+      }
+    }
+    if (opts.showContactPoints || opts.showContactNormals || opts.showContactImpulse) {
+      this.drawContacts2D();
+    }
+    if (opts.showRaycasts) {
+      this.drawRaycasts2D();
+    }
+    if (opts.showCenterOfMass) {
+      for (const [_id, body] of this.bodies2D) {
+        if (body.bodyType === "static") {
+          continue;
+        }
+        const transform = this.transforms2D.get(body.entityId);
+        if (!transform) {
+          continue;
+        }
+        this.drawCommands.push({
+          type: "cross",
+          color: colors.activeBody,
+          zOrder: 12,
+          position: transform.position,
+          size: { x: 0.3, y: 0.3 },
+          lineWidth: 2
+        });
+      }
     }
-    createEmptyStats() {
-        return {
-            totalBodies: 0,
-            dynamicBodies: 0,
-            kinematicBodies: 0,
-            staticBodies: 0,
-            awakeBodies: 0,
-            sleepingBodies: 0,
-            totalColliders: 0,
-            activeColliders: 0,
-            triggers: 0,
-            collisionPairs: 0,
-            contactPoints: 0,
-            islandCount: 0,
-            stepTime: 0,
-            broadphaseTime: 0,
-            narrowphaseTime: 0,
-            solverTime: 0,
-            integrationTime: 0,
-            bodyMemory: 0,
-            colliderMemory: 0,
-            contactMemory: 0,
-            totalJoints: 0,
-            activeJoints: 0,
-            brokenJoints: 0,
-            raycastsThisFrame: 0,
-            overlapTestsThisFrame: 0,
+  }
+  generateDrawCommands3D() {
+    const opts = this.options;
+    const colors = opts.colors;
+    if (opts.showColliders || opts.showTriggers) {
+      for (const [_id, collider] of this.colliders3D) {
+        if (!this.shouldDrawCollider3D(collider)) {
+          continue;
+        }
+        const transform = this.transforms3D.get(collider.entityId);
+        if (!transform) {
+          continue;
+        }
+        const body = this.findBody3DForEntity(collider.entityId);
+        const color = this.getColliderColor3D(collider, body);
+        this.drawCollider3D(collider, transform, color);
+      }
+    }
+    if (opts.showVelocities) {
+      for (const [_id, body] of this.bodies3D) {
+        if (body.bodyType === "static") {
+          continue;
+        }
+        if (opts.hideSleepingBodies && body.isSleeping) {
+          continue;
+        }
+        const transform = this.transforms3D.get(body.entityId);
+        if (!transform) {
+          continue;
+        }
+        const end = {
+          x: transform.position.x + body.linearVelocity.x * opts.velocityScale,
+          y: transform.position.y + body.linearVelocity.y * opts.velocityScale,
+          z: transform.position.z + body.linearVelocity.z * opts.velocityScale
         };
+        this.drawCommands.push({
+          type: "arrow",
+          color: colors.velocity,
+          zOrder: 10,
+          points: [transform.position, end],
+          lineWidth: opts.vectorLineWidth
+        });
+      }
     }
-    // ─── Configuration ─────────────────────────────────────
-    setOptions(options) {
-        this.options = { ...this.options, ...options };
+    if (opts.showJoints) {
+      for (const [_id, joint] of this.joints3D) {
+        this.drawJoint3D(joint);
+      }
     }
-    getOptions() {
-        return { ...this.options };
+    if (opts.showContactPoints || opts.showContactNormals) {
+      this.drawContacts3D();
     }
-    setEnabled(enabled) {
-        this.options.enabled = enabled;
+    if (opts.showRaycasts) {
+      this.drawRaycasts3D();
     }
-    isEnabled() {
-        return this.options.enabled;
+  }
+  shouldDrawCollider2D(collider) {
+    const opts = this.options;
+    if (collider.isTrigger && !opts.showTriggers) {
+      return false;
     }
-    set3DMode(is3D) {
-        this.is3D = is3D;
+    if (!collider.isTrigger && !opts.showColliders) {
+      return false;
     }
-    // ─── Data Update (called by physics engine) ────────────
-    updateCollider2D(collider) {
-        this.colliders2D.set(collider.id, collider);
+    if (opts.filterByLayer !== null && collider.layer !== opts.filterByLayer) {
+      return false;
     }
-    removeCollider2D(colliderId) {
-        this.colliders2D.delete(colliderId);
+    if (opts.filterByEntity !== null && !opts.filterByEntity.includes(collider.entityId)) {
+      return false;
     }
-    updateCollider3D(collider) {
-        this.colliders3D.set(collider.id, collider);
+    const body = this.findBody2DForEntity(collider.entityId);
+    if (body) {
+      if (opts.filterByBodyType !== null && body.bodyType !== opts.filterByBodyType) {
+        return false;
+      }
+      if (opts.hideStaticColliders && body.bodyType === "static") {
+        return false;
+      }
+      if (opts.hideSleepingBodies && body.isSleeping) {
+        return false;
+      }
     }
-    removeCollider3D(colliderId) {
-        this.colliders3D.delete(colliderId);
+    return true;
+  }
+  shouldDrawCollider3D(collider) {
+    const opts = this.options;
+    if (collider.isTrigger && !opts.showTriggers) {
+      return false;
     }
-    updateBody2D(body) {
-        this.bodies2D.set(body.id, body);
+    if (!collider.isTrigger && !opts.showColliders) {
+      return false;
     }
-    removeBody2D(bodyId) {
-        this.bodies2D.delete(bodyId);
+    if (opts.filterByLayer !== null && collider.layer !== opts.filterByLayer) {
+      return false;
     }
-    updateBody3D(body) {
-        this.bodies3D.set(body.id, body);
+    if (opts.filterByEntity !== null && !opts.filterByEntity.includes(collider.entityId)) {
+      return false;
     }
-    removeBody3D(bodyId) {
-        this.bodies3D.delete(bodyId);
+    const body = this.findBody3DForEntity(collider.entityId);
+    if (body) {
+      if (opts.filterByBodyType !== null && body.bodyType !== opts.filterByBodyType) {
+        return false;
+      }
+      if (opts.hideStaticColliders && body.bodyType === "static") {
+        return false;
+      }
+      if (opts.hideSleepingBodies && body.isSleeping) {
+        return false;
+      }
     }
-    updateTransform2D(entityId, transform) {
-        this.transforms2D.set(entityId, transform);
+    return true;
+  }
+  findBody2DForEntity(entityId) {
+    for (const body of this.bodies2D.values()) {
+      if (body.entityId === entityId) {
+        return body;
+      }
     }
-    updateTransform3D(entityId, transform) {
-        this.transforms3D.set(entityId, transform);
+    return void 0;
+  }
+  findBody3DForEntity(entityId) {
+    for (const body of this.bodies3D.values()) {
+      if (body.entityId === entityId) {
+        return body;
+      }
     }
-    updateJoint2D(joint) {
-        this.joints2D.set(joint.id, joint);
+    return void 0;
+  }
+  getColliderColor2D(collider, body) {
+    const colors = this.options.colors;
+    if (this.options.showLayerColors && collider.layer < colors.layerColors.length) {
+      return colors.layerColors[collider.layer];
     }
-    removeJoint2D(jointId) {
-        this.joints2D.delete(jointId);
+    if (collider.isTrigger) {
+      return colors.triggerCollider;
     }
-    updateJoint3D(joint) {
-        this.joints3D.set(joint.id, joint);
+    if (!body) {
+      return colors.staticCollider;
     }
-    removeJoint3D(jointId) {
-        this.joints3D.delete(jointId);
+    if (body.isSleeping) {
+      return colors.sleepingCollider;
     }
-    setCollisionPairs(pairs) {
-        this.collisionPairs = pairs;
-        // Add to contact history
-        const now = Date.now();
-        for (const pair of pairs) {
-            for (const contact of pair.contacts) {
-                if (this.contactHistory.length >= this.options.maxContactHistory) {
-                    this.contactHistory.shift();
-                }
-                'z' in contact.point;
-                this.contactHistory.push({
-                    timestamp: now,
-                    point: contact.point,
-                    normal: contact.normal,
-                    impulse: contact.impulse,
-                    idA: pair.idA,
-                    idB: pair.idB,
-                });
-            }
-        }
-        // Prune old history
-        const cutoff = now - this.options.contactHistoryDuration;
-        this.contactHistory = this.contactHistory.filter((c) => c.timestamp > cutoff);
+    switch (body.bodyType) {
+      case "static":
+        return colors.staticCollider;
+      case "kinematic":
+        return colors.kinematicCollider;
+      case "dynamic":
+        return colors.dynamicCollider;
     }
-    addRaycast(origin, direction, maxDistance, hit) {
-        this.raycasts.push({ origin, direction, maxDistance, hit });
+  }
+  getColliderColor3D(collider, body) {
+    const colors = this.options.colors;
+    if (this.options.showLayerColors && collider.layer < colors.layerColors.length) {
+      return colors.layerColors[collider.layer];
     }
-    updateStats(stats) {
-        Object.assign(this.stats, stats);
+    if (collider.isTrigger) {
+      return colors.triggerCollider;
     }
-    // ─── Generate Draw Commands ────────────────────────────
-    generateDrawCommands() {
-        this.drawCommands = [];
-        if (!this.options.enabled) {
-            return this.drawCommands;
-        }
-        // Calculate stats
-        this.calculateStats();
-        if (this.is3D) {
-            this.generateDrawCommands3D();
-        }
-        else {
-            this.generateDrawCommands2D();
-        }
-        // Sort by zOrder
-        this.drawCommands.sort((a, b) => a.zOrder - b.zOrder);
-        return this.drawCommands;
+    if (!body) {
+      return colors.staticCollider;
     }
-    generateDrawCommands2D() {
-        const opts = this.options;
-        const colors = opts.colors;
-        // Draw colliders
-        if (opts.showColliders || opts.showTriggers) {
-            for (const [_id, collider] of this.colliders2D) {
-                if (!this.shouldDrawCollider2D(collider)) {
-                    continue;
-                }
-                const transform = this.transforms2D.get(collider.entityId);
-                if (!transform) {
-                    continue;
-                }
-                const body = this.findBody2DForEntity(collider.entityId);
-                const color = this.getColliderColor2D(collider, body);
-                this.drawCollider2D(collider, transform, color);
-            }
-        }
-        // Draw velocities
-        if (opts.showVelocities) {
-            for (const [_id, body] of this.bodies2D) {
-                if (body.bodyType === 'static') {
-                    continue;
-                }
-                if (opts.hideSleepingBodies && body.isSleeping) {
-                    continue;
-                }
-                const transform = this.transforms2D.get(body.entityId);
-                if (!transform) {
-                    continue;
-                }
-                const endX = transform.position.x + body.linearVelocity.x * opts.velocityScale;
-                const endY = transform.position.y + body.linearVelocity.y * opts.velocityScale;
-                this.drawCommands.push({
-                    type: 'arrow',
-                    color: colors.velocity,
-                    zOrder: 10,
-                    points: [transform.position, { x: endX, y: endY }],
-                    lineWidth: opts.vectorLineWidth,
-                });
-            }
-        }
-        // Draw angular velocities
-        if (opts.showAngularVelocities) {
-            for (const [_id, body] of this.bodies2D) {
-                if (body.bodyType === 'static') {
-                    continue;
-                }
-                const transform = this.transforms2D.get(body.entityId);
-                if (!transform) {
-                    continue;
-                }
-                const radius = Math.abs(body.angularVelocity) * opts.velocityScale * 0.5;
-                this.drawCommands.push({
-                    type: 'arc',
-                    color: colors.angularVelocity,
-                    zOrder: 10,
-                    position: transform.position,
-                    radius: Math.max(radius, 0.2),
-                    startAngle: 0,
-                    endAngle: body.angularVelocity > 0 ? Math.PI : -Math.PI,
-                    lineWidth: opts.vectorLineWidth,
-                });
-            }
-        }
-        // Draw forces
-        if (opts.showForces) {
-            for (const [_id, body] of this.bodies2D) {
-                const transform = this.transforms2D.get(body.entityId);
-                if (!transform) {
-                    continue;
-                }
-                if (body.forceAccumulator.x !== 0 || body.forceAccumulator.y !== 0) {
-                    const endX = transform.position.x + body.forceAccumulator.x * opts.forceScale;
-                    const endY = transform.position.y + body.forceAccumulator.y * opts.forceScale;
-                    this.drawCommands.push({
-                        type: 'arrow',
-                        color: colors.force,
-                        zOrder: 11,
-                        points: [transform.position, { x: endX, y: endY }],
-                        lineWidth: opts.vectorLineWidth,
-                    });
-                }
-            }
-        }
-        // Draw joints
-        if (opts.showJoints) {
-            for (const [_id, joint] of this.joints2D) {
-                this.drawJoint2D(joint);
-            }
-        }
-        // Draw contact points
-        if (opts.showContactPoints || opts.showContactNormals || opts.showContactImpulse) {
-            this.drawContacts2D();
-        }
-        // Draw raycasts
-        if (opts.showRaycasts) {
-            this.drawRaycasts2D();
-        }
-        // Draw center of mass
-        if (opts.showCenterOfMass) {
-            for (const [_id, body] of this.bodies2D) {
-                if (body.bodyType === 'static') {
-                    continue;
-                }
-                const transform = this.transforms2D.get(body.entityId);
-                if (!transform) {
-                    continue;
-                }
-                this.drawCommands.push({
-                    type: 'cross',
-                    color: colors.activeBody,
-                    zOrder: 12,
-                    position: transform.position,
-                    size: { x: 0.3, y: 0.3 },
-                    lineWidth: 2,
-                });
-            }
-        }
+    if (body.isSleeping) {
+      return colors.sleepingCollider;
     }
-    generateDrawCommands3D() {
-        const opts = this.options;
-        const colors = opts.colors;
-        // Draw colliders
-        if (opts.showColliders || opts.showTriggers) {
-            for (const [_id, collider] of this.colliders3D) {
-                if (!this.shouldDrawCollider3D(collider)) {
-                    continue;
-                }
-                const transform = this.transforms3D.get(collider.entityId);
-                if (!transform) {
-                    continue;
-                }
-                const body = this.findBody3DForEntity(collider.entityId);
-                const color = this.getColliderColor3D(collider, body);
-                this.drawCollider3D(collider, transform, color);
-            }
-        }
-        // Draw velocities
-        if (opts.showVelocities) {
-            for (const [_id, body] of this.bodies3D) {
-                if (body.bodyType === 'static') {
-                    continue;
-                }
-                if (opts.hideSleepingBodies && body.isSleeping) {
-                    continue;
-                }
-                const transform = this.transforms3D.get(body.entityId);
-                if (!transform) {
-                    continue;
-                }
-                const end = {
-                    x: transform.position.x + body.linearVelocity.x * opts.velocityScale,
-                    y: transform.position.y + body.linearVelocity.y * opts.velocityScale,
-                    z: transform.position.z + body.linearVelocity.z * opts.velocityScale,
-                };
-                this.drawCommands.push({
-                    type: 'arrow',
-                    color: colors.velocity,
-                    zOrder: 10,
-                    points: [transform.position, end],
-                    lineWidth: opts.vectorLineWidth,
-                });
-            }
-        }
-        // Draw joints
-        if (opts.showJoints) {
-            for (const [_id, joint] of this.joints3D) {
-                this.drawJoint3D(joint);
-            }
-        }
-        // Draw contact points
-        if (opts.showContactPoints || opts.showContactNormals) {
-            this.drawContacts3D();
-        }
-        // Draw raycasts
-        if (opts.showRaycasts) {
-            this.drawRaycasts3D();
-        }
+    switch (body.bodyType) {
+      case "static":
+        return colors.staticCollider;
+      case "kinematic":
+        return colors.kinematicCollider;
+      case "dynamic":
+        return colors.dynamicCollider;
     }
-    shouldDrawCollider2D(collider) {
-        const opts = this.options;
-        if (collider.isTrigger && !opts.showTriggers) {
-            return false;
-        }
-        if (!collider.isTrigger && !opts.showColliders) {
-            return false;
-        }
-        if (opts.filterByLayer !== null && collider.layer !== opts.filterByLayer) {
-            return false;
+  }
+  drawCollider2D(collider, transform, color) {
+    const pos = {
+      x: transform.position.x + collider.offset.x,
+      y: transform.position.y + collider.offset.y
+    };
+    const rotation = transform.rotation + collider.rotation;
+    switch (collider.type) {
+      case "circle":
+        this.drawCommands.push({
+          type: "circle",
+          color,
+          zOrder: 1,
+          position: pos,
+          radius: collider.radius ?? 1,
+          lineWidth: this.options.colliderLineWidth
+        });
+        break;
+      case "box":
+        this.drawCommands.push({
+          type: "rect",
+          color,
+          zOrder: 1,
+          position: pos,
+          size: collider.halfExtents ? { x: collider.halfExtents.x * 2, y: collider.halfExtents.y * 2 } : { x: 1, y: 1 },
+          rotation,
+          lineWidth: this.options.colliderLineWidth
+        });
+        break;
+      case "polygon":
+        if (collider.vertices && collider.vertices.length >= 3) {
+          const transformedVerts = collider.vertices.map((v) => {
+            const cos = Math.cos(rotation);
+            const sin = Math.sin(rotation);
+            return {
+              x: pos.x + v.x * cos - v.y * sin,
+              y: pos.y + v.x * sin + v.y * cos
+            };
+          });
+          this.drawCommands.push({
+            type: "polygon",
+            color,
+            zOrder: 1,
+            points: transformedVerts,
+            lineWidth: this.options.colliderLineWidth
+          });
         }
-        if (opts.filterByEntity !== null && !opts.filterByEntity.includes(collider.entityId)) {
-            return false;
+        break;
+      case "edge":
+        if (collider.edgeStart && collider.edgeEnd) {
+          this.drawCommands.push({
+            type: "line",
+            color,
+            zOrder: 1,
+            points: [
+              { x: pos.x + collider.edgeStart.x, y: pos.y + collider.edgeStart.y },
+              { x: pos.x + collider.edgeEnd.x, y: pos.y + collider.edgeEnd.y }
+            ],
+            lineWidth: this.options.colliderLineWidth
+          });
         }
-        const body = this.findBody2DForEntity(collider.entityId);
-        if (body) {
-            if (opts.filterByBodyType !== null && body.bodyType !== opts.filterByBodyType) {
-                return false;
-            }
-            if (opts.hideStaticColliders && body.bodyType === 'static') {
-                return false;
-            }
-            if (opts.hideSleepingBodies && body.isSleeping) {
-                return false;
-            }
+        break;
+      case "chain":
+        if (collider.chainVertices && collider.chainVertices.length >= 2) {
+          const transformedVerts = collider.chainVertices.map((v) => ({
+            x: pos.x + v.x,
+            y: pos.y + v.y
+          }));
+          for (let i = 0; i < transformedVerts.length - 1; i++) {
+            this.drawCommands.push({
+              type: "line",
+              color,
+              zOrder: 1,
+              points: [transformedVerts[i], transformedVerts[i + 1]],
+              lineWidth: this.options.colliderLineWidth
+            });
+          }
         }
-        return true;
+        break;
+      case "capsule":
+        this.drawCommands.push({
+          type: "capsule",
+          color,
+          zOrder: 1,
+          position: pos,
+          radius: collider.radius ?? 0.5,
+          size: { x: collider.capsuleHeight ?? 2, y: 0 },
+          rotation,
+          lineWidth: this.options.colliderLineWidth
+        });
+        break;
     }
-    shouldDrawCollider3D(collider) {
-        const opts = this.options;
-        if (collider.isTrigger && !opts.showTriggers) {
-            return false;
-        }
-        if (!collider.isTrigger && !opts.showColliders) {
-            return false;
-        }
-        if (opts.filterByLayer !== null && collider.layer !== opts.filterByLayer) {
-            return false;
-        }
-        if (opts.filterByEntity !== null && !opts.filterByEntity.includes(collider.entityId)) {
-            return false;
-        }
-        const body = this.findBody3DForEntity(collider.entityId);
-        if (body) {
-            if (opts.filterByBodyType !== null && body.bodyType !== opts.filterByBodyType) {
-                return false;
-            }
-            if (opts.hideStaticColliders && body.bodyType === 'static') {
-                return false;
-            }
-            if (opts.hideSleepingBodies && body.isSleeping) {
-                return false;
-            }
-        }
-        return true;
+  }
+  drawCollider3D(collider, transform, color) {
+    const pos = {
+      x: transform.position.x + collider.offset.x,
+      y: transform.position.y + collider.offset.y,
+      z: transform.position.z + collider.offset.z
+    };
+    switch (collider.type) {
+      case "sphere":
+        this.drawCommands.push({
+          type: "sphere",
+          color,
+          zOrder: 1,
+          position: pos,
+          radius: collider.radius ?? 1,
+          lineWidth: this.options.colliderLineWidth
+        });
+        break;
+      case "box":
+        this.drawCommands.push({
+          type: "box3d",
+          color,
+          zOrder: 1,
+          position: pos,
+          size: collider.halfExtents ? {
+            x: collider.halfExtents.x * 2,
+            y: collider.halfExtents.y * 2,
+            z: collider.halfExtents.z * 2
+          } : { x: 1, y: 1, z: 1 },
+          rotation: collider.rotation,
+          lineWidth: this.options.colliderLineWidth
+        });
+        break;
+      case "capsule":
+        this.drawCommands.push({
+          type: "capsule",
+          color,
+          zOrder: 1,
+          position: pos,
+          radius: collider.capsuleRadius ?? 0.5,
+          size: { x: 0, y: collider.capsuleHeight ?? 2, z: 0 },
+          rotation: collider.rotation,
+          lineWidth: this.options.colliderLineWidth
+        });
+        break;
     }
-    findBody2DForEntity(entityId) {
-        for (const body of this.bodies2D.values()) {
-            if (body.entityId === entityId) {
-                return body;
-            }
-        }
-        return undefined;
+  }
+  drawJoint2D(joint) {
+    const colors = this.options.colors;
+    const bodyA = this.bodies2D.get(joint.bodyA);
+    const bodyB = this.bodies2D.get(joint.bodyB);
+    if (!bodyA || !bodyB) {
+      return;
     }
-    findBody3DForEntity(entityId) {
-        for (const body of this.bodies3D.values()) {
-            if (body.entityId === entityId) {
-                return body;
-            }
-        }
-        return undefined;
+    const transformA = this.transforms2D.get(bodyA.entityId);
+    const transformB = this.transforms2D.get(bodyB.entityId);
+    if (!transformA || !transformB) {
+      return;
     }
-    getColliderColor2D(collider, body) {
-        const colors = this.options.colors;
-        if (this.options.showLayerColors && collider.layer < colors.layerColors.length) {
-            return colors.layerColors[collider.layer];
-        }
-        if (collider.isTrigger) {
-            return colors.triggerCollider;
-        }
-        if (!body) {
-            return colors.staticCollider;
-        }
-        if (body.isSleeping) {
-            return colors.sleepingCollider;
-        }
-        switch (body.bodyType) {
-            case 'static':
-                return colors.staticCollider;
-            case 'kinematic':
-                return colors.kinematicCollider;
-            case 'dynamic':
-                return colors.dynamicCollider;
-        }
+    const anchorA = {
+      x: transformA.position.x + joint.anchorA.x,
+      y: transformA.position.y + joint.anchorA.y
+    };
+    const anchorB = {
+      x: transformB.position.x + joint.anchorB.x,
+      y: transformB.position.y + joint.anchorB.y
+    };
+    this.drawCommands.push({
+      type: "line",
+      color: colors.jointActive,
+      zOrder: 5,
+      points: [anchorA, anchorB],
+      lineWidth: this.options.jointLineWidth
+    });
+    this.drawCommands.push({
+      type: "filledCircle",
+      color: colors.jointActive,
+      zOrder: 6,
+      position: anchorA,
+      radius: 0.1
+    });
+    this.drawCommands.push({
+      type: "filledCircle",
+      color: colors.jointActive,
+      zOrder: 6,
+      position: anchorB,
+      radius: 0.1
+    });
+    if (this.options.showJointLimits && joint.useLimits) {
+      if (joint.type === "hinge" && joint.minAngle !== void 0 && joint.maxAngle !== void 0) {
+        this.drawCommands.push({
+          type: "arc",
+          color: colors.jointLimit,
+          zOrder: 4,
+          position: anchorA,
+          radius: 0.5,
+          startAngle: joint.minAngle,
+          endAngle: joint.maxAngle,
+          lineWidth: 2
+        });
+      }
     }
-    getColliderColor3D(collider, body) {
-        const colors = this.options.colors;
-        if (this.options.showLayerColors && collider.layer < colors.layerColors.length) {
-            return colors.layerColors[collider.layer];
-        }
-        if (collider.isTrigger) {
-            return colors.triggerCollider;
-        }
-        if (!body) {
-            return colors.staticCollider;
-        }
-        if (body.isSleeping) {
-            return colors.sleepingCollider;
+  }
+  drawJoint3D(joint) {
+    const colors = this.options.colors;
+    const bodyA = this.bodies3D.get(joint.bodyA);
+    const bodyB = this.bodies3D.get(joint.bodyB);
+    if (!bodyA || !bodyB) {
+      return;
+    }
+    const transformA = this.transforms3D.get(bodyA.entityId);
+    const transformB = this.transforms3D.get(bodyB.entityId);
+    if (!transformA || !transformB) {
+      return;
+    }
+    const anchorA = {
+      x: transformA.position.x + joint.anchor.x,
+      y: transformA.position.y + joint.anchor.y,
+      z: transformA.position.z + joint.anchor.z
+    };
+    const anchorB = {
+      x: transformB.position.x + joint.connectedAnchor.x,
+      y: transformB.position.y + joint.connectedAnchor.y,
+      z: transformB.position.z + joint.connectedAnchor.z
+    };
+    this.drawCommands.push({
+      type: "line",
+      color: colors.jointActive,
+      zOrder: 5,
+      points: [anchorA, anchorB],
+      lineWidth: this.options.jointLineWidth
+    });
+  }
+  drawContacts2D() {
+    const opts = this.options;
+    const colors = opts.colors;
+    for (const pair of this.collisionPairs) {
+      for (const contact of pair.contacts) {
+        const point = contact.point;
+        const normal = contact.normal;
+        if (opts.showContactPoints) {
+          this.drawCommands.push({
+            type: "filledCircle",
+            color: colors.contactPoint,
+            zOrder: 20,
+            position: point,
+            radius: 0.08
+          });
         }
-        switch (body.bodyType) {
-            case 'static':
-                return colors.staticCollider;
-            case 'kinematic':
-                return colors.kinematicCollider;
-            case 'dynamic':
-                return colors.dynamicCollider;
+        if (opts.showContactNormals) {
+          const end = {
+            x: point.x + normal.x * opts.normalScale,
+            y: point.y + normal.y * opts.normalScale
+          };
+          this.drawCommands.push({
+            type: "arrow",
+            color: colors.contactNormal,
+            zOrder: 21,
+            points: [point, end],
+            lineWidth: opts.vectorLineWidth
+          });
         }
-    }
-    drawCollider2D(collider, transform, color) {
-        const pos = {
-            x: transform.position.x + collider.offset.x,
-            y: transform.position.y + collider.offset.y,
-        };
-        const rotation = transform.rotation + collider.rotation;
-        switch (collider.type) {
-            case 'circle':
-                this.drawCommands.push({
-                    type: 'circle',
-                    color,
-                    zOrder: 1,
-                    position: pos,
-                    radius: collider.radius ?? 1,
-                    lineWidth: this.options.colliderLineWidth,
-                });
-                break;
-            case 'box':
-                this.drawCommands.push({
-                    type: 'rect',
-                    color,
-                    zOrder: 1,
-                    position: pos,
-                    size: collider.halfExtents
-                        ? { x: collider.halfExtents.x * 2, y: collider.halfExtents.y * 2 }
-                        : { x: 1, y: 1 },
-                    rotation,
-                    lineWidth: this.options.colliderLineWidth,
-                });
-                break;
-            case 'polygon':
-                if (collider.vertices && collider.vertices.length >= 3) {
-                    const transformedVerts = collider.vertices.map((v) => {
-                        const cos = Math.cos(rotation);
-                        const sin = Math.sin(rotation);
-                        return {
-                            x: pos.x + v.x * cos - v.y * sin,
-                            y: pos.y + v.x * sin + v.y * cos,
-                        };
-                    });
-                    this.drawCommands.push({
-                        type: 'polygon',
-                        color,
-                        zOrder: 1,
-                        points: transformedVerts,
-                        lineWidth: this.options.colliderLineWidth,
-                    });
-                }
-                break;
-            case 'edge':
-                if (collider.edgeStart && collider.edgeEnd) {
-                    this.drawCommands.push({
-                        type: 'line',
-                        color,
-                        zOrder: 1,
-                        points: [
-                            { x: pos.x + collider.edgeStart.x, y: pos.y + collider.edgeStart.y },
-                            { x: pos.x + collider.edgeEnd.x, y: pos.y + collider.edgeEnd.y },
-                        ],
-                        lineWidth: this.options.colliderLineWidth,
-                    });
-                }
-                break;
-            case 'chain':
-                if (collider.chainVertices && collider.chainVertices.length >= 2) {
-                    const transformedVerts = collider.chainVertices.map((v) => ({
-                        x: pos.x + v.x,
-                        y: pos.y + v.y,
-                    }));
-                    for (let i = 0; i < transformedVerts.length - 1; i++) {
-                        this.drawCommands.push({
-                            type: 'line',
-                            color,
-                            zOrder: 1,
-                            points: [transformedVerts[i], transformedVerts[i + 1]],
-                            lineWidth: this.options.colliderLineWidth,
-                        });
-                    }
-                }
-                break;
-            case 'capsule':
-                this.drawCommands.push({
-                    type: 'capsule',
-                    color,
-                    zOrder: 1,
-                    position: pos,
-                    radius: collider.radius ?? 0.5,
-                    size: { x: collider.capsuleHeight ?? 2, y: 0 },
-                    rotation,
-                    lineWidth: this.options.colliderLineWidth,
-                });
-                break;
+        if (opts.showContactImpulse && contact.impulse > 0) {
+          const impulseLength = contact.impulse * opts.impulseScale;
+          const end = {
+            x: point.x + normal.x * impulseLength,
+            y: point.y + normal.y * impulseLength
+          };
+          this.drawCommands.push({
+            type: "arrow",
+            color: colors.contactImpulse,
+            zOrder: 22,
+            points: [point, end],
+            lineWidth: opts.vectorLineWidth * 1.5
+          });
         }
+      }
     }
-    drawCollider3D(collider, transform, color) {
-        const pos = {
-            x: transform.position.x + collider.offset.x,
-            y: transform.position.y + collider.offset.y,
-            z: transform.position.z + collider.offset.z,
-        };
-        switch (collider.type) {
-            case 'sphere':
-                this.drawCommands.push({
-                    type: 'sphere',
-                    color,
-                    zOrder: 1,
-                    position: pos,
-                    radius: collider.radius ?? 1,
-                    lineWidth: this.options.colliderLineWidth,
-                });
-                break;
-            case 'box':
-                this.drawCommands.push({
-                    type: 'box3d',
-                    color,
-                    zOrder: 1,
-                    position: pos,
-                    size: collider.halfExtents
-                        ? {
-                            x: collider.halfExtents.x * 2,
-                            y: collider.halfExtents.y * 2,
-                            z: collider.halfExtents.z * 2,
-                        }
-                        : { x: 1, y: 1, z: 1 },
-                    rotation: collider.rotation,
-                    lineWidth: this.options.colliderLineWidth,
-                });
-                break;
-            case 'capsule':
-                this.drawCommands.push({
-                    type: 'capsule',
-                    color,
-                    zOrder: 1,
-                    position: pos,
-                    radius: collider.capsuleRadius ?? 0.5,
-                    size: { x: 0, y: collider.capsuleHeight ?? 2, z: 0 },
-                    rotation: collider.rotation,
-                    lineWidth: this.options.colliderLineWidth,
-                });
-                break;
-            // Additional shapes would be drawn similarly
-        }
+    const now = Date.now();
+    for (const entry of this.contactHistory) {
+      const age = now - entry.timestamp;
+      const alpha = 1 - age / opts.contactHistoryDuration;
+      if (alpha <= 0) {
+        continue;
+      }
+      const point = entry.point;
+      const fadedColor = {
+        ...colors.contactPoint,
+        a: colors.contactPoint.a * alpha * 0.5
+      };
+      this.drawCommands.push({
+        type: "filledCircle",
+        color: fadedColor,
+        zOrder: 19,
+        position: point,
+        radius: 0.05
+      });
     }
-    drawJoint2D(joint) {
-        const colors = this.options.colors;
-        const bodyA = this.bodies2D.get(joint.bodyA);
-        const bodyB = this.bodies2D.get(joint.bodyB);
-        if (!bodyA || !bodyB) {
-            return;
+  }
+  drawContacts3D() {
+    const opts = this.options;
+    const colors = opts.colors;
+    for (const pair of this.collisionPairs) {
+      for (const contact of pair.contacts) {
+        const point = contact.point;
+        const normal = contact.normal;
+        if (opts.showContactPoints) {
+          this.drawCommands.push({
+            type: "sphere",
+            color: colors.contactPoint,
+            zOrder: 20,
+            position: point,
+            radius: 0.05
+          });
         }
-        const transformA = this.transforms2D.get(bodyA.entityId);
-        const transformB = this.transforms2D.get(bodyB.entityId);
-        if (!transformA || !transformB) {
-            return;
+        if (opts.showContactNormals) {
+          const end = {
+            x: point.x + normal.x * opts.normalScale,
+            y: point.y + normal.y * opts.normalScale,
+            z: point.z + normal.z * opts.normalScale
+          };
+          this.drawCommands.push({
+            type: "arrow",
+            color: colors.contactNormal,
+            zOrder: 21,
+            points: [point, end],
+            lineWidth: opts.vectorLineWidth
+          });
         }
-        const anchorA = {
-            x: transformA.position.x + joint.anchorA.x,
-            y: transformA.position.y + joint.anchorA.y,
+      }
+    }
+  }
+  drawRaycasts2D() {
+    const colors = this.options.colors;
+    for (const raycast of this.raycasts) {
+      const origin = raycast.origin;
+      const direction = raycast.direction;
+      if (raycast.hit) {
+        const hit = raycast.hit;
+        this.drawCommands.push({
+          type: "line",
+          color: colors.raycastHit,
+          zOrder: 15,
+          points: [origin, hit.point],
+          lineWidth: 1
+        });
+        this.drawCommands.push({
+          type: "cross",
+          color: colors.raycastHit,
+          zOrder: 16,
+          position: hit.point,
+          size: { x: 0.2, y: 0.2 },
+          lineWidth: 2
+        });
+        const normalEnd = {
+          x: hit.point.x + hit.normal.x * 0.5,
+          y: hit.point.y + hit.normal.y * 0.5
         };
-        const anchorB = {
-            x: transformB.position.x + joint.anchorB.x,
-            y: transformB.position.y + joint.anchorB.y,
+        this.drawCommands.push({
+          type: "arrow",
+          color: colors.contactNormal,
+          zOrder: 17,
+          points: [hit.point, normalEnd],
+          lineWidth: 1
+        });
+      } else {
+        const end = {
+          x: origin.x + direction.x * raycast.maxDistance,
+          y: origin.y + direction.y * raycast.maxDistance
         };
-        // Draw joint connection line
         this.drawCommands.push({
-            type: 'line',
-            color: colors.jointActive,
-            zOrder: 5,
-            points: [anchorA, anchorB],
-            lineWidth: this.options.jointLineWidth,
+          type: "line",
+          color: colors.raycastMiss,
+          zOrder: 15,
+          points: [origin, end],
+          lineWidth: 1
         });
-        // Draw anchors
+      }
+    }
+    this.raycasts = [];
+  }
+  drawRaycasts3D() {
+    const colors = this.options.colors;
+    for (const raycast of this.raycasts) {
+      const origin = raycast.origin;
+      const direction = raycast.direction;
+      if (raycast.hit) {
+        const hit = raycast.hit;
         this.drawCommands.push({
-            type: 'filledCircle',
-            color: colors.jointActive,
-            zOrder: 6,
-            position: anchorA,
-            radius: 0.1,
+          type: "line",
+          color: colors.raycastHit,
+          zOrder: 15,
+          points: [origin, hit.point],
+          lineWidth: 1
         });
         this.drawCommands.push({
-            type: 'filledCircle',
-            color: colors.jointActive,
-            zOrder: 6,
-            position: anchorB,
-            radius: 0.1,
+          type: "sphere",
+          color: colors.raycastHit,
+          zOrder: 16,
+          position: hit.point,
+          radius: 0.05
         });
-        // Draw limits if applicable
-        if (this.options.showJointLimits && joint.useLimits) {
-            if (joint.type === 'hinge' && joint.minAngle !== undefined && joint.maxAngle !== undefined) {
-                this.drawCommands.push({
-                    type: 'arc',
-                    color: colors.jointLimit,
-                    zOrder: 4,
-                    position: anchorA,
-                    radius: 0.5,
-                    startAngle: joint.minAngle,
-                    endAngle: joint.maxAngle,
-                    lineWidth: 2,
-                });
-            }
-        }
-    }
-    drawJoint3D(joint) {
-        const colors = this.options.colors;
-        const bodyA = this.bodies3D.get(joint.bodyA);
-        const bodyB = this.bodies3D.get(joint.bodyB);
-        if (!bodyA || !bodyB) {
-            return;
-        }
-        const transformA = this.transforms3D.get(bodyA.entityId);
-        const transformB = this.transforms3D.get(bodyB.entityId);
-        if (!transformA || !transformB) {
-            return;
-        }
-        const anchorA = {
-            x: transformA.position.x + joint.anchor.x,
-            y: transformA.position.y + joint.anchor.y,
-            z: transformA.position.z + joint.anchor.z,
-        };
-        const anchorB = {
-            x: transformB.position.x + joint.connectedAnchor.x,
-            y: transformB.position.y + joint.connectedAnchor.y,
-            z: transformB.position.z + joint.connectedAnchor.z,
+      } else {
+        const end = {
+          x: origin.x + direction.x * raycast.maxDistance,
+          y: origin.y + direction.y * raycast.maxDistance,
+          z: origin.z + direction.z * raycast.maxDistance
         };
         this.drawCommands.push({
-            type: 'line',
-            color: colors.jointActive,
-            zOrder: 5,
-            points: [anchorA, anchorB],
-            lineWidth: this.options.jointLineWidth,
+          type: "line",
+          color: colors.raycastMiss,
+          zOrder: 15,
+          points: [origin, end],
+          lineWidth: 1
         });
+      }
     }
-    drawContacts2D() {
-        const opts = this.options;
-        const colors = opts.colors;
-        // Draw current contacts
-        for (const pair of this.collisionPairs) {
-            for (const contact of pair.contacts) {
-                const point = contact.point;
-                const normal = contact.normal;
-                if (opts.showContactPoints) {
-                    this.drawCommands.push({
-                        type: 'filledCircle',
-                        color: colors.contactPoint,
-                        zOrder: 20,
-                        position: point,
-                        radius: 0.08,
-                    });
-                }
-                if (opts.showContactNormals) {
-                    const end = {
-                        x: point.x + normal.x * opts.normalScale,
-                        y: point.y + normal.y * opts.normalScale,
-                    };
-                    this.drawCommands.push({
-                        type: 'arrow',
-                        color: colors.contactNormal,
-                        zOrder: 21,
-                        points: [point, end],
-                        lineWidth: opts.vectorLineWidth,
-                    });
-                }
-                if (opts.showContactImpulse && contact.impulse > 0) {
-                    const impulseLength = contact.impulse * opts.impulseScale;
-                    const end = {
-                        x: point.x + normal.x * impulseLength,
-                        y: point.y + normal.y * impulseLength,
-                    };
-                    this.drawCommands.push({
-                        type: 'arrow',
-                        color: colors.contactImpulse,
-                        zOrder: 22,
-                        points: [point, end],
-                        lineWidth: opts.vectorLineWidth * 1.5,
-                    });
-                }
-            }
-        }
-        // Draw contact history with fading
-        const now = Date.now();
-        for (const entry of this.contactHistory) {
-            const age = now - entry.timestamp;
-            const alpha = 1 - age / opts.contactHistoryDuration;
-            if (alpha <= 0) {
-                continue;
-            }
-            const point = entry.point;
-            const fadedColor = {
-                ...colors.contactPoint,
-                a: colors.contactPoint.a * alpha * 0.5,
-            };
-            this.drawCommands.push({
-                type: 'filledCircle',
-                color: fadedColor,
-                zOrder: 19,
-                position: point,
-                radius: 0.05,
-            });
-        }
+    this.raycasts = [];
+  }
+  // ─── Stats ─────────────────────────────────────────────
+  calculateStats() {
+    this.stats.totalBodies = this.bodies2D.size + this.bodies3D.size;
+    this.stats.dynamicBodies = 0;
+    this.stats.kinematicBodies = 0;
+    this.stats.staticBodies = 0;
+    this.stats.awakeBodies = 0;
+    this.stats.sleepingBodies = 0;
+    for (const body of this.bodies2D.values()) {
+      if (body.bodyType === "dynamic") {
+        this.stats.dynamicBodies++;
+      } else if (body.bodyType === "kinematic") {
+        this.stats.kinematicBodies++;
+      } else {
+        this.stats.staticBodies++;
+      }
+      if (body.isSleeping) {
+        this.stats.sleepingBodies++;
+      } else {
+        this.stats.awakeBodies++;
+      }
     }
-    drawContacts3D() {
-        const opts = this.options;
-        const colors = opts.colors;
-        for (const pair of this.collisionPairs) {
-            for (const contact of pair.contacts) {
-                const point = contact.point;
-                const normal = contact.normal;
-                if (opts.showContactPoints) {
-                    this.drawCommands.push({
-                        type: 'sphere',
-                        color: colors.contactPoint,
-                        zOrder: 20,
-                        position: point,
-                        radius: 0.05,
-                    });
-                }
-                if (opts.showContactNormals) {
-                    const end = {
-                        x: point.x + normal.x * opts.normalScale,
-                        y: point.y + normal.y * opts.normalScale,
-                        z: point.z + normal.z * opts.normalScale,
-                    };
-                    this.drawCommands.push({
-                        type: 'arrow',
-                        color: colors.contactNormal,
-                        zOrder: 21,
-                        points: [point, end],
-                        lineWidth: opts.vectorLineWidth,
-                    });
-                }
-            }
-        }
+    for (const body of this.bodies3D.values()) {
+      if (body.bodyType === "dynamic") {
+        this.stats.dynamicBodies++;
+      } else if (body.bodyType === "kinematic") {
+        this.stats.kinematicBodies++;
+      } else {
+        this.stats.staticBodies++;
+      }
+      if (body.isSleeping) {
+        this.stats.sleepingBodies++;
+      } else {
+        this.stats.awakeBodies++;
+      }
     }
-    drawRaycasts2D() {
-        const colors = this.options.colors;
-        for (const raycast of this.raycasts) {
-            const origin = raycast.origin;
-            const direction = raycast.direction;
-            if (raycast.hit) {
-                const hit = raycast.hit;
-                // Draw ray to hit point
-                this.drawCommands.push({
-                    type: 'line',
-                    color: colors.raycastHit,
-                    zOrder: 15,
-                    points: [origin, hit.point],
-                    lineWidth: 1,
-                });
-                // Draw hit point
-                this.drawCommands.push({
-                    type: 'cross',
-                    color: colors.raycastHit,
-                    zOrder: 16,
-                    position: hit.point,
-                    size: { x: 0.2, y: 0.2 },
-                    lineWidth: 2,
-                });
-                // Draw hit normal
-                const normalEnd = {
-                    x: hit.point.x + hit.normal.x * 0.5,
-                    y: hit.point.y + hit.normal.y * 0.5,
-                };
-                this.drawCommands.push({
-                    type: 'arrow',
-                    color: colors.contactNormal,
-                    zOrder: 17,
-                    points: [hit.point, normalEnd],
-                    lineWidth: 1,
-                });
-            }
-            else {
-                // Draw full ray (miss)
-                const end = {
-                    x: origin.x + direction.x * raycast.maxDistance,
-                    y: origin.y + direction.y * raycast.maxDistance,
-                };
-                this.drawCommands.push({
-                    type: 'line',
-                    color: colors.raycastMiss,
-                    zOrder: 15,
-                    points: [origin, end],
-                    lineWidth: 1,
-                });
-            }
-        }
-        // Clear raycasts for next frame
-        this.raycasts = [];
+    this.stats.totalColliders = this.colliders2D.size + this.colliders3D.size;
+    this.stats.activeColliders = this.stats.totalColliders;
+    this.stats.triggers = 0;
+    for (const collider of this.colliders2D.values()) {
+      if (collider.isTrigger) {
+        this.stats.triggers++;
+      }
     }
-    drawRaycasts3D() {
-        const colors = this.options.colors;
-        for (const raycast of this.raycasts) {
-            const origin = raycast.origin;
-            const direction = raycast.direction;
-            if (raycast.hit) {
-                const hit = raycast.hit;
-                this.drawCommands.push({
-                    type: 'line',
-                    color: colors.raycastHit,
-                    zOrder: 15,
-                    points: [origin, hit.point],
-                    lineWidth: 1,
-                });
-                this.drawCommands.push({
-                    type: 'sphere',
-                    color: colors.raycastHit,
-                    zOrder: 16,
-                    position: hit.point,
-                    radius: 0.05,
-                });
-            }
-            else {
-                const end = {
-                    x: origin.x + direction.x * raycast.maxDistance,
-                    y: origin.y + direction.y * raycast.maxDistance,
-                    z: origin.z + direction.z * raycast.maxDistance,
-                };
-                this.drawCommands.push({
-                    type: 'line',
-                    color: colors.raycastMiss,
-                    zOrder: 15,
-                    points: [origin, end],
-                    lineWidth: 1,
-                });
-            }
-        }
-        this.raycasts = [];
+    for (const collider of this.colliders3D.values()) {
+      if (collider.isTrigger) {
+        this.stats.triggers++;
+      }
     }
-    // ─── Stats ─────────────────────────────────────────────
-    calculateStats() {
-        // Bodies
-        this.stats.totalBodies = this.bodies2D.size + this.bodies3D.size;
-        this.stats.dynamicBodies = 0;
-        this.stats.kinematicBodies = 0;
-        this.stats.staticBodies = 0;
-        this.stats.awakeBodies = 0;
-        this.stats.sleepingBodies = 0;
-        for (const body of this.bodies2D.values()) {
-            if (body.bodyType === 'dynamic') {
-                this.stats.dynamicBodies++;
-            }
-            else if (body.bodyType === 'kinematic') {
-                this.stats.kinematicBodies++;
-            }
-            else {
-                this.stats.staticBodies++;
-            }
-            if (body.isSleeping) {
-                this.stats.sleepingBodies++;
-            }
-            else {
-                this.stats.awakeBodies++;
-            }
-        }
-        for (const body of this.bodies3D.values()) {
-            if (body.bodyType === 'dynamic') {
-                this.stats.dynamicBodies++;
-            }
-            else if (body.bodyType === 'kinematic') {
-                this.stats.kinematicBodies++;
-            }
-            else {
-                this.stats.staticBodies++;
-            }
-            if (body.isSleeping) {
-                this.stats.sleepingBodies++;
-            }
-            else {
-                this.stats.awakeBodies++;
-            }
-        }
-        // Colliders
-        this.stats.totalColliders = this.colliders2D.size + this.colliders3D.size;
-        this.stats.activeColliders = this.stats.totalColliders;
-        this.stats.triggers = 0;
+    this.stats.collisionPairs = this.collisionPairs.length;
+    this.stats.contactPoints = 0;
+    for (const pair of this.collisionPairs) {
+      this.stats.contactPoints += pair.contacts.length;
+    }
+    this.stats.totalJoints = this.joints2D.size + this.joints3D.size;
+    this.stats.activeJoints = this.stats.totalJoints;
+    this.stats.brokenJoints = 0;
+    this.stats.bodyMemory = this.stats.totalBodies * 256;
+    this.stats.colliderMemory = this.stats.totalColliders * 128;
+    this.stats.contactMemory = this.stats.contactPoints * 64;
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  // ─── Stats Overlay Text ────────────────────────────────
+  generateStatsOverlayText() {
+    const s = this.stats;
+    return [
+      "=== Physics Debug ===",
+      "",
+      "--- Bodies ---",
+      `Total: ${s.totalBodies}`,
+      `  Dynamic: ${s.dynamicBodies}`,
+      `  Kinematic: ${s.kinematicBodies}`,
+      `  Static: ${s.staticBodies}`,
+      `Awake: ${s.awakeBodies} / Sleeping: ${s.sleepingBodies}`,
+      "",
+      "--- Colliders ---",
+      `Total: ${s.totalColliders}`,
+      `Active: ${s.activeColliders}`,
+      `Triggers: ${s.triggers}`,
+      "",
+      "--- Simulation ---",
+      `Collision Pairs: ${s.collisionPairs}`,
+      `Contact Points: ${s.contactPoints}`,
+      `Islands: ${s.islandCount}`,
+      "",
+      "--- Timing (ms) ---",
+      `Step: ${s.stepTime.toFixed(2)}`,
+      `  Broadphase: ${s.broadphaseTime.toFixed(2)}`,
+      `  Narrowphase: ${s.narrowphaseTime.toFixed(2)}`,
+      `  Solver: ${s.solverTime.toFixed(2)}`,
+      `  Integration: ${s.integrationTime.toFixed(2)}`,
+      "",
+      "--- Memory (KB) ---",
+      `Bodies: ${(s.bodyMemory / 1024).toFixed(1)}`,
+      `Colliders: ${(s.colliderMemory / 1024).toFixed(1)}`,
+      `Contacts: ${(s.contactMemory / 1024).toFixed(1)}`,
+      "",
+      "--- Joints ---",
+      `Total: ${s.totalJoints}`,
+      `Active: ${s.activeJoints}`,
+      `Broken: ${s.brokenJoints}`,
+      "",
+      "--- Queries/Frame ---",
+      `Raycasts: ${s.raycastsThisFrame}`,
+      `Overlaps: ${s.overlapTestsThisFrame}`
+    ];
+  }
+  // ─── Collision Layer Matrix ────────────────────────────
+  generateLayerMatrix(layerCount = 32) {
+    const matrix = [];
+    for (let i = 0; i < layerCount; i++) {
+      matrix[i] = [];
+      for (let j = 0; j < layerCount; j++) {
+        let canCollide = false;
         for (const collider of this.colliders2D.values()) {
-            if (collider.isTrigger) {
-                this.stats.triggers++;
-            }
+          if (collider.layer === i && (collider.mask & 1 << j) !== 0) {
+            canCollide = true;
+            break;
+          }
         }
-        for (const collider of this.colliders3D.values()) {
-            if (collider.isTrigger) {
-                this.stats.triggers++;
-            }
-        }
-        // Collision pairs and contacts
-        this.stats.collisionPairs = this.collisionPairs.length;
-        this.stats.contactPoints = 0;
-        for (const pair of this.collisionPairs) {
-            this.stats.contactPoints += pair.contacts.length;
-        }
-        // Joints
-        this.stats.totalJoints = this.joints2D.size + this.joints3D.size;
-        this.stats.activeJoints = this.stats.totalJoints;
-        this.stats.brokenJoints = 0;
-        // Memory estimates
-        this.stats.bodyMemory = this.stats.totalBodies * 256; // Rough estimate
-        this.stats.colliderMemory = this.stats.totalColliders * 128;
-        this.stats.contactMemory = this.stats.contactPoints * 64;
-    }
-    getStats() {
-        return { ...this.stats };
-    }
-    // ─── Stats Overlay Text ────────────────────────────────
-    generateStatsOverlayText() {
-        const s = this.stats;
-        return [
-            '=== Physics Debug ===',
-            '',
-            '--- Bodies ---',
-            `Total: ${s.totalBodies}`,
-            `  Dynamic: ${s.dynamicBodies}`,
-            `  Kinematic: ${s.kinematicBodies}`,
-            `  Static: ${s.staticBodies}`,
-            `Awake: ${s.awakeBodies} / Sleeping: ${s.sleepingBodies}`,
-            '',
-            '--- Colliders ---',
-            `Total: ${s.totalColliders}`,
-            `Active: ${s.activeColliders}`,
-            `Triggers: ${s.triggers}`,
-            '',
-            '--- Simulation ---',
-            `Collision Pairs: ${s.collisionPairs}`,
-            `Contact Points: ${s.contactPoints}`,
-            `Islands: ${s.islandCount}`,
-            '',
-            '--- Timing (ms) ---',
-            `Step: ${s.stepTime.toFixed(2)}`,
-            `  Broadphase: ${s.broadphaseTime.toFixed(2)}`,
-            `  Narrowphase: ${s.narrowphaseTime.toFixed(2)}`,
-            `  Solver: ${s.solverTime.toFixed(2)}`,
-            `  Integration: ${s.integrationTime.toFixed(2)}`,
-            '',
-            '--- Memory (KB) ---',
-            `Bodies: ${(s.bodyMemory / 1024).toFixed(1)}`,
-            `Colliders: ${(s.colliderMemory / 1024).toFixed(1)}`,
-            `Contacts: ${(s.contactMemory / 1024).toFixed(1)}`,
-            '',
-            '--- Joints ---',
-            `Total: ${s.totalJoints}`,
-            `Active: ${s.activeJoints}`,
-            `Broken: ${s.brokenJoints}`,
-            '',
-            '--- Queries/Frame ---',
-            `Raycasts: ${s.raycastsThisFrame}`,
-            `Overlaps: ${s.overlapTestsThisFrame}`,
-        ];
-    }
-    // ─── Collision Layer Matrix ────────────────────────────
-    generateLayerMatrix(layerCount = 32) {
-        // Generate a collision layer matrix based on mask settings
-        const matrix = [];
-        for (let i = 0; i < layerCount; i++) {
-            matrix[i] = [];
-            for (let j = 0; j < layerCount; j++) {
-                // Check if any collider on layer i can collide with layer j
-                let canCollide = false;
-                for (const collider of this.colliders2D.values()) {
-                    if (collider.layer === i && (collider.mask & (1 << j)) !== 0) {
-                        canCollide = true;
-                        break;
-                    }
-                }
-                if (!canCollide) {
-                    for (const collider of this.colliders3D.values()) {
-                        if (collider.layer === i && (collider.mask & (1 << j)) !== 0) {
-                            canCollide = true;
-                            break;
-                        }
-                    }
-                }
-                matrix[i][j] = canCollide;
+        if (!canCollide) {
+          for (const collider of this.colliders3D.values()) {
+            if (collider.layer === i && (collider.mask & 1 << j) !== 0) {
+              canCollide = true;
+              break;
             }
+          }
         }
-        return matrix;
-    }
-    // ─── Clear ─────────────────────────────────────────────
-    clear() {
-        this.colliders2D.clear();
-        this.colliders3D.clear();
-        this.bodies2D.clear();
-        this.bodies3D.clear();
-        this.joints2D.clear();
-        this.joints3D.clear();
-        this.transforms2D.clear();
-        this.transforms3D.clear();
-        this.collisionPairs = [];
-        this.raycasts = [];
-        this.contactHistory = [];
-        this.drawCommands = [];
-        this.stats = this.createEmptyStats();
+        matrix[i][j] = canCollide;
+      }
     }
+    return matrix;
+  }
+  // ─── Clear ─────────────────────────────────────────────
+  clear() {
+    this.colliders2D.clear();
+    this.colliders3D.clear();
+    this.bodies2D.clear();
+    this.bodies3D.clear();
+    this.joints2D.clear();
+    this.joints3D.clear();
+    this.transforms2D.clear();
+    this.transforms3D.clear();
+    this.collisionPairs = [];
+    this.raycasts = [];
+    this.contactHistory = [];
+    this.drawCommands = [];
+    this.stats = this.createEmptyStats();
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createPhysicsDebugSystem() {
-    return new PhysicsDebugSystem();
+  return new PhysicsDebugSystem();
 }
 function createCollider2D(type, entityId) {
-    return {
-        id: `col2d_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-        entityId,
-        type,
-        offset: { x: 0, y: 0 },
-        rotation: 0,
-        isTrigger: false,
-        layer: 0,
-        mask: 0xffffffff,
-        radius: type === 'circle' || type === 'capsule' ? 0.5 : undefined,
-        halfExtents: type === 'box' ? { x: 0.5, y: 0.5 } : undefined,
-        capsuleHeight: type === 'capsule' ? 1 : undefined,
-    };
+  return {
+    id: `col2d_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+    entityId,
+    type,
+    offset: { x: 0, y: 0 },
+    rotation: 0,
+    isTrigger: false,
+    layer: 0,
+    mask: 4294967295,
+    radius: type === "circle" || type === "capsule" ? 0.5 : void 0,
+    halfExtents: type === "box" ? { x: 0.5, y: 0.5 } : void 0,
+    capsuleHeight: type === "capsule" ? 1 : void 0
+  };
 }
 function createCollider3D(type, entityId) {
-    return {
-        id: `col3d_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-        entityId,
-        type,
-        offset: { x: 0, y: 0, z: 0 },
-        rotation: { x: 0, y: 0, z: 0 },
-        isTrigger: false,
-        layer: 0,
-        mask: 0xffffffff,
-        radius: type === 'sphere' ? 0.5 : undefined,
-        halfExtents: type === 'box' ? { x: 0.5, y: 0.5, z: 0.5 } : undefined,
-        capsuleRadius: type === 'capsule' ? 0.5 : undefined,
-        capsuleHeight: type === 'capsule' ? 1 : undefined,
-        cylinderRadius: type === 'cylinder' ? 0.5 : undefined,
-        cylinderHeight: type === 'cylinder' ? 1 : undefined,
-    };
+  return {
+    id: `col3d_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+    entityId,
+    type,
+    offset: { x: 0, y: 0, z: 0 },
+    rotation: { x: 0, y: 0, z: 0 },
+    isTrigger: false,
+    layer: 0,
+    mask: 4294967295,
+    radius: type === "sphere" ? 0.5 : void 0,
+    halfExtents: type === "box" ? { x: 0.5, y: 0.5, z: 0.5 } : void 0,
+    capsuleRadius: type === "capsule" ? 0.5 : void 0,
+    capsuleHeight: type === "capsule" ? 1 : void 0,
+    cylinderRadius: type === "cylinder" ? 0.5 : void 0,
+    cylinderHeight: type === "cylinder" ? 1 : void 0
+  };
 }
-function createRigidbody2D(entityId, bodyType = 'dynamic') {
-    return {
-        id: `rb2d_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-        entityId,
-        bodyType,
-        mass: 1,
-        linearDamping: 0,
-        angularDamping: 0.05,
-        gravityScale: 1,
-        fixedRotation: false,
-        isBullet: false,
-        isAwake: true,
-        isSleeping: false,
-        linearVelocity: { x: 0, y: 0 },
-        angularVelocity: 0,
-        forceAccumulator: { x: 0, y: 0 },
-        torqueAccumulator: 0,
-    };
+function createRigidbody2D(entityId, bodyType = "dynamic") {
+  return {
+    id: `rb2d_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+    entityId,
+    bodyType,
+    mass: 1,
+    linearDamping: 0,
+    angularDamping: 0.05,
+    gravityScale: 1,
+    fixedRotation: false,
+    isBullet: false,
+    isAwake: true,
+    isSleeping: false,
+    linearVelocity: { x: 0, y: 0 },
+    angularVelocity: 0,
+    forceAccumulator: { x: 0, y: 0 },
+    torqueAccumulator: 0
+  };
 }
-function createRigidbody3D(entityId, bodyType = 'dynamic') {
-    return {
-        id: `rb3d_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-        entityId,
-        bodyType,
-        mass: 1,
-        linearDamping: 0,
-        angularDamping: 0.05,
-        useGravity: true,
-        constraints: {
-            freezePositionX: false,
-            freezePositionY: false,
-            freezePositionZ: false,
-            freezeRotationX: false,
-            freezeRotationY: false,
-            freezeRotationZ: false,
-        },
-        interpolation: 'none',
-        collisionDetection: 'discrete',
-        isAwake: true,
-        isSleeping: false,
-        linearVelocity: { x: 0, y: 0, z: 0 },
-        angularVelocity: { x: 0, y: 0, z: 0 },
-        forceAccumulator: { x: 0, y: 0, z: 0 },
-        torqueAccumulator: { x: 0, y: 0, z: 0 },
-    };
+function createRigidbody3D(entityId, bodyType = "dynamic") {
+  return {
+    id: `rb3d_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+    entityId,
+    bodyType,
+    mass: 1,
+    linearDamping: 0,
+    angularDamping: 0.05,
+    useGravity: true,
+    constraints: {
+      freezePositionX: false,
+      freezePositionY: false,
+      freezePositionZ: false,
+      freezeRotationX: false,
+      freezeRotationY: false,
+      freezeRotationZ: false
+    },
+    interpolation: "none",
+    collisionDetection: "discrete",
+    isAwake: true,
+    isSleeping: false,
+    linearVelocity: { x: 0, y: 0, z: 0 },
+    angularVelocity: { x: 0, y: 0, z: 0 },
+    forceAccumulator: { x: 0, y: 0, z: 0 },
+    torqueAccumulator: { x: 0, y: 0, z: 0 }
+  };
 }
-
-export { DEFAULT_DEBUG_COLORS, DEFAULT_DEBUG_OPTIONS, PhysicsDebugSystem, createCollider2D, createCollider3D, createPhysicsDebugSystem, createRigidbody2D, createRigidbody3D };
+export {
+  DEFAULT_DEBUG_COLORS,
+  DEFAULT_DEBUG_OPTIONS,
+  PhysicsDebugSystem,
+  createCollider2D,
+  createCollider3D,
+  createPhysicsDebugSystem,
+  createRigidbody2D,
+  createRigidbody3D
+};