@nice2dev/game-engine 1.0.4 → 1.0.10

package/dist/cjs/systems/PhysicsDebugSystem.js

@@ -0,0 +1,1228 @@
+'use strict';
+
+/**
+ * @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 },
+    ],
+};
+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,
+};
+// ============================================================
+// 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();
+    }
+    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;
+        // 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);
+    }
+    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;
+        }
+        // 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;
+    }
+    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,
+                });
+            }
+        }
+    }
+    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();
+        }
+    }
+    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;
+        }
+        if (opts.filterByEntity !== null && !opts.filterByEntity.includes(collider.entityId)) {
+            return false;
+        }
+        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;
+            }
+        }
+        return true;
+    }
+    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;
+    }
+    findBody2DForEntity(entityId) {
+        for (const body of this.bodies2D.values()) {
+            if (body.entityId === entityId) {
+                return body;
+            }
+        }
+        return undefined;
+    }
+    findBody3DForEntity(entityId) {
+        for (const body of this.bodies3D.values()) {
+            if (body.entityId === entityId) {
+                return body;
+            }
+        }
+        return undefined;
+    }
+    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;
+        }
+    }
+    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;
+        }
+        switch (body.bodyType) {
+            case 'static':
+                return colors.staticCollider;
+            case 'kinematic':
+                return colors.kinematicCollider;
+            case 'dynamic':
+                return colors.dynamicCollider;
+        }
+    }
+    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;
+        }
+    }
+    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
+        }
+    }
+    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;
+        }
+        const transformA = this.transforms2D.get(bodyA.entityId);
+        const transformB = this.transforms2D.get(bodyB.entityId);
+        if (!transformA || !transformB) {
+            return;
+        }
+        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,
+        };
+        // Draw joint connection line
+        this.drawCommands.push({
+            type: 'line',
+            color: colors.jointActive,
+            zOrder: 5,
+            points: [anchorA, anchorB],
+            lineWidth: this.options.jointLineWidth,
+        });
+        // Draw anchors
+        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,
+        });
+        // 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,
+        };
+        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;
+        // 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,
+            });
+        }
+    }
+    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,
+                    });
+                }
+            }
+        }
+    }
+    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 = [];
+    }
+    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 = [];
+    }
+    // ─── 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;
+        for (const collider of this.colliders2D.values()) {
+            if (collider.isTrigger) {
+                this.stats.triggers++;
+            }
+        }
+        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;
+            }
+        }
+        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();
+}
+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,
+    };
+}
+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,
+    };
+}
+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 },
+    };
+}
+
+exports.DEFAULT_DEBUG_COLORS = DEFAULT_DEBUG_COLORS;
+exports.DEFAULT_DEBUG_OPTIONS = DEFAULT_DEBUG_OPTIONS;
+exports.PhysicsDebugSystem = PhysicsDebugSystem;
+exports.createCollider2D = createCollider2D;
+exports.createCollider3D = createCollider3D;
+exports.createPhysicsDebugSystem = createPhysicsDebugSystem;
+exports.createRigidbody2D = createRigidbody2D;
+exports.createRigidbody3D = createRigidbody3D;
+//# sourceMappingURL=PhysicsDebugSystem.js.map