@combos-fun/plugin-cannon 0.0.42 → 0.0.45

package/dist/plugin-cannon.esm.js

@@ -1,6 +1,9 @@
 import { __decorate } from 'tslib';
 import { Component, System, OBSERVER_TYPE, decorators } from '@combos-fun/engine';
 import * as CANNON from 'cannon-es';
+import { Vector3, Quaternion, Euler, Box3 } from 'three';
+import { Renderer3DSystem } from '@combos-fun/plugin-renderer-3d';
+import { ConvexGeometry } from 'three/addons/geometries/ConvexGeometry.js';
 
 var Physics3DType;
 (function (Physics3DType) {
@@ -8,6 +11,10 @@ var Physics3DType;
     Physics3DType["SPHERE"] = "sphere";
     Physics3DType["CYLINDER"] = "cylinder";
     Physics3DType["PLANE"] = "plane";
+    Physics3DType["CONE"] = "cone";
+    Physics3DType["TORUS"] = "torus";
+    Physics3DType["CAPSULE"] = "capsule";
+    Physics3DType["COMPOUND"] = "compound";
 })(Physics3DType || (Physics3DType = {}));
 class Physics3D extends Component {
     constructor() {
@@ -20,10 +27,14 @@ class Physics3D extends Component {
         this.rotationY = 0;
         this.rotationZ = 0;
         this._euler = new CANNON.Vec3();
+        this._worldPos = new Vector3();
+        this._worldQuat = new Quaternion();
+        this._bodyQuat = new Quaternion();
+        this._localEuler = new Euler();
     }
     static { this.componentName = 'Physics3D'; }
     init(params) {
-        this.bodyParams = params;
+        this.bodyParams = params || {};
     }
     update() {
         if (this.body && this.gameObject) {
@@ -38,7 +49,8 @@ class Physics3D extends Component {
                 this.rotationY = this._euler.y;
                 this.rotationZ = this._euler.z;
             }
-            // Auto-sync to sibling 3D render components on the same GameObject
+            this._worldPoseToLocalIfParented();
+            // Auto-sync to sibling Transform3D / visual components on the same GameObject
             this._syncToSiblings();
         }
     }
@@ -47,6 +59,28 @@ class Physics3D extends Component {
             this.world.removeBody(this.body);
         }
     }
+    _worldPoseToLocalIfParented() {
+        const renderer = this.game?.getSystem(Renderer3DSystem);
+        const node = renderer?.threeContext?.object3DFor(this.gameObject.id);
+        const scene = renderer?.threeContext?.scene;
+        if (!node?.parent || node.parent === scene)
+            return;
+        node.parent.updateWorldMatrix(true, false);
+        this._worldPos.set(this.positionX, this.positionY, this.positionZ);
+        node.parent.worldToLocal(this._worldPos);
+        this.positionX = this._worldPos.x;
+        this.positionY = this._worldPos.y;
+        this.positionZ = this._worldPos.z;
+        if (!this.bodyParams.stopRotation) {
+            node.parent.getWorldQuaternion(this._worldQuat).invert();
+            this._bodyQuat.set(this.body.quaternion.x, this.body.quaternion.y, this.body.quaternion.z, this.body.quaternion.w);
+            this._bodyQuat.premultiply(this._worldQuat);
+            this._localEuler.setFromQuaternion(this._bodyQuat);
+            this.rotationX = this._localEuler.x;
+            this.rotationY = this._localEuler.y;
+            this.rotationZ = this._localEuler.z;
+        }
+    }
     _syncToSiblings() {
         const components = this.gameObject.components;
         if (!components)
@@ -69,74 +103,385 @@ class Physics3D extends Component {
     }
 }
 
-class BodiesFactory {
-    create(component) {
-        const { bodyParams } = component;
-        const type = bodyParams.type ?? Physics3DType.BOX;
-        const mass = bodyParams.mass ?? 1;
-        const options = bodyParams.bodyOptions ?? {};
-        // Create shape
-        let shape;
-        switch (type) {
-            case Physics3DType.SPHERE: {
-                const radius = bodyParams.radius ?? 0.5;
-                shape = new CANNON.Sphere(radius);
-                break;
+const TYPE_BY_SHAPE = {
+    box: Physics3DType.BOX,
+    sphere: Physics3DType.SPHERE,
+    cylinder: Physics3DType.CYLINDER,
+    plane: Physics3DType.PLANE,
+    cone: Physics3DType.CONE,
+    torus: Physics3DType.TORUS,
+    capsule: Physics3DType.CAPSULE,
+    compound: Physics3DType.COMPOUND,
+};
+function normalizeType(type) {
+    if (!type)
+        return Physics3DType.BOX;
+    return TYPE_BY_SHAPE[type] ?? type;
+}
+function torusTube(radius, tube) {
+    return tube && tube > 0 ? tube : radius * 0.4;
+}
+function dimsFromParams(params, fallback) {
+    const radius = params.radius ?? fallback?.radius ?? 0.5;
+    return {
+        width: params.width ?? fallback?.width ?? 1,
+        height: params.height ?? fallback?.height ?? 1,
+        depth: params.depth ?? fallback?.depth ?? 1,
+        radius,
+        radiusTop: params.radiusTop ?? radius,
+        radiusBottom: params.radiusBottom ?? radius,
+        segments: Math.max(6, Math.round(params.segments ?? fallback?.segments ?? 12)),
+        tube: torusTube(radius, params.tube ?? fallback?.tube),
+        finite: params.finite ?? fallback?.finite,
+    };
+}
+function offsetFromPart(part) {
+    return new CANNON.Vec3(part.positionX ?? part.position?.x ?? 0, part.positionY ?? part.position?.y ?? 0, part.positionZ ?? part.position?.z ?? 0);
+}
+function quaternionFromPart(part) {
+    const x = part.rotationX ?? part.rotation?.x ?? 0;
+    const y = part.rotationY ?? part.rotation?.y ?? 0;
+    const z = part.rotationZ ?? part.rotation?.z ?? 0;
+    if (!x && !y && !z)
+        return undefined;
+    const q = new CANNON.Quaternion();
+    q.setFromEuler(x, y, z);
+    return q;
+}
+function placedShapesForType(type, dims) {
+    const kind = normalizeType(type);
+    switch (kind) {
+        case Physics3DType.SPHERE:
+            return [{ shape: new CANNON.Sphere(dims.radius) }];
+        case Physics3DType.CYLINDER:
+            return [{
+                    shape: new CANNON.Cylinder(dims.radiusTop, dims.radiusBottom, dims.height, dims.segments),
+                }];
+        case Physics3DType.CONE:
+            return [{
+                    shape: new CANNON.Cylinder(0.001, dims.radius, dims.height, dims.segments),
+                }];
+        case Physics3DType.PLANE:
+            if (dims.finite) {
+                return [{ shape: new CANNON.Box(new CANNON.Vec3(dims.width / 2, dims.height / 2, 0.01)) }];
             }
-            case Physics3DType.CYLINDER: {
-                const radiusTop = bodyParams.radiusTop ?? bodyParams.radius ?? 0.5;
-                const radiusBottom = bodyParams.radiusBottom ?? bodyParams.radius ?? 0.5;
-                const height = bodyParams.height ?? 1;
-                const segments = bodyParams.segments ?? 16;
-                shape = new CANNON.Cylinder(radiusTop, radiusBottom, height, segments);
-                break;
+            return [{ shape: new CANNON.Plane() }];
+        case Physics3DType.TORUS:
+            return torusShapes(dims);
+        case Physics3DType.CAPSULE:
+            return capsuleShapes(dims);
+        case Physics3DType.BOX:
+        default:
+            return [{
+                    shape: new CANNON.Box(new CANNON.Vec3(dims.width / 2, dims.height / 2, dims.depth / 2)),
+                }];
+    }
+}
+function torusShapes(dims) {
+    const n = Math.max(8, Math.min(12, dims.segments));
+    const placed = [];
+    for (let i = 0; i < n; i++) {
+        const angle = (i / n) * Math.PI * 2;
+        placed.push({
+            shape: new CANNON.Sphere(dims.tube),
+            offset: new CANNON.Vec3(Math.cos(angle) * dims.radius, 0, Math.sin(angle) * dims.radius),
+        });
+    }
+    return placed;
+}
+function capsuleShapes(dims) {
+    const cyl = Math.max(0, dims.height - 2 * dims.radius);
+    const placed = [];
+    if (cyl > 0.001) {
+        placed.push({
+            shape: new CANNON.Cylinder(dims.radius, dims.radius, cyl, dims.segments),
+        });
+    }
+    placed.push({
+        shape: new CANNON.Sphere(dims.radius),
+        offset: new CANNON.Vec3(0, cyl / 2, 0),
+    });
+    placed.push({
+        shape: new CANNON.Sphere(dims.radius),
+        offset: new CANNON.Vec3(0, -cyl / 2, 0),
+    });
+    return placed;
+}
+
+const _box = new Box3();
+const _size = new Vector3();
+const _center = new Vector3();
+const _vertex = new Vector3();
+function withIdentityPose(root, fn) {
+    const px = root.position.x;
+    const py = root.position.y;
+    const pz = root.position.z;
+    const rx = root.rotation.x;
+    const ry = root.rotation.y;
+    const rz = root.rotation.z;
+    root.position.set(0, 0, 0);
+    root.rotation.set(0, 0, 0);
+    root.updateMatrixWorld(true);
+    try {
+        return fn();
+    }
+    finally {
+        root.position.set(px, py, pz);
+        root.rotation.set(rx, ry, rz);
+        root.updateMatrixWorld(true);
+    }
+}
+function addModelCollider(body, root, collider) {
+    return withIdentityPose(root, () => {
+        if (collider === 'trimesh') {
+            return addTrimesh(body, root);
+        }
+        if (collider === 'hull') {
+            return addHull(body, root);
+        }
+        return addAabb(body, root);
+    });
+}
+function addAabb(body, root) {
+    _box.setFromObject(root);
+    if (_box.isEmpty())
+        return false;
+    _box.getSize(_size);
+    _box.getCenter(_center);
+    if (_size.x <= 0 && _size.y <= 0 && _size.z <= 0)
+        return false;
+    body.addShape(new CANNON.Box(new CANNON.Vec3(Math.max(_size.x / 2, 0.01), Math.max(_size.y / 2, 0.01), Math.max(_size.z / 2, 0.01))), new CANNON.Vec3(_center.x, _center.y, _center.z));
+    return true;
+}
+function addTrimesh(body, root) {
+    let added = false;
+    root.traverse((child) => {
+        const mesh = child;
+        const geometry = mesh.geometry;
+        const position = geometry?.attributes?.position;
+        if (!position)
+            return;
+        const vertices = [];
+        for (let i = 0; i < position.count; i++) {
+            _vertex.fromBufferAttribute(position, i).applyMatrix4(mesh.matrixWorld);
+            vertices.push(_vertex.x, _vertex.y, _vertex.z);
+        }
+        const indices = [];
+        if (geometry.index) {
+            const array = geometry.index.array;
+            for (let i = 0; i < array.length; i++) {
+                indices.push(array[i]);
             }
-            case Physics3DType.PLANE: {
-                shape = new CANNON.Plane();
-                break;
+        }
+        else {
+            for (let i = 0; i < position.count; i++) {
+                indices.push(i);
             }
-            case Physics3DType.BOX:
-            default: {
-                const w = bodyParams.width ?? 1;
-                const h = bodyParams.height ?? 1;
-                const d = bodyParams.depth ?? 1;
-                shape = new CANNON.Box(new CANNON.Vec3(w / 2, h / 2, d / 2));
-                break;
+        }
+        if (indices.length < 3)
+            return;
+        body.addShape(new CANNON.Trimesh(vertices, indices));
+        added = true;
+    });
+    return added;
+}
+function addHull(body, root) {
+    const points = [];
+    root.traverse((child) => {
+        const mesh = child;
+        const position = mesh.geometry?.attributes?.position;
+        if (!position)
+            return;
+        const stride = position.count > 128 ? Math.ceil(position.count / 128) : 1;
+        for (let i = 0; i < position.count; i += stride) {
+            points.push(_vertex.fromBufferAttribute(position, i).applyMatrix4(mesh.matrixWorld).clone());
+        }
+    });
+    if (points.length < 4) {
+        return addAabb(body, root);
+    }
+    try {
+        const geometry = new ConvexGeometry(points);
+        const pos = geometry.attributes.position;
+        const vertices = [];
+        const indexOf = new Map();
+        const add = (x, y, z) => {
+            const key = `${x.toFixed(5)},${y.toFixed(5)},${z.toFixed(5)}`;
+            const existing = indexOf.get(key);
+            if (existing != null)
+                return existing;
+            const i = vertices.length;
+            vertices.push(new CANNON.Vec3(x, y, z));
+            indexOf.set(key, i);
+            return i;
+        };
+        const faces = [];
+        if (geometry.index) {
+            const array = geometry.index.array;
+            for (let i = 0; i + 2 < array.length; i += 3) {
+                faces.push([
+                    add(pos.getX(array[i]), pos.getY(array[i]), pos.getZ(array[i])),
+                    add(pos.getX(array[i + 1]), pos.getY(array[i + 1]), pos.getZ(array[i + 1])),
+                    add(pos.getX(array[i + 2]), pos.getY(array[i + 2]), pos.getZ(array[i + 2])),
+                ]);
             }
         }
-        // Create body
-        const body = new CANNON.Body({
-            mass: type === Physics3DType.PLANE ? 0 : mass,
-            shape,
+        else {
+            for (let i = 0; i + 2 < pos.count; i += 3) {
+                faces.push([
+                    add(pos.getX(i), pos.getY(i), pos.getZ(i)),
+                    add(pos.getX(i + 1), pos.getY(i + 1), pos.getZ(i + 1)),
+                    add(pos.getX(i + 2), pos.getY(i + 2), pos.getZ(i + 2)),
+                ]);
+            }
+        }
+        geometry.dispose();
+        if (vertices.length < 4 || faces.length < 4) {
+            return addAabb(body, root);
+        }
+        body.addShape(new CANNON.ConvexPolyhedron({ vertices, faces }));
+        return true;
+    }
+    catch {
+        return addAabb(body, root);
+    }
+}
+
+function resolveCollider(params, model) {
+    if (params.collider)
+        return params.collider;
+    if (params.type || (params.parts && params.parts.length > 0))
+        return 'manual';
+    return model ? 'aabb' : 'manual';
+}
+function resolveType(params, graphics) {
+    if (params.type)
+        return normalizeType(params.type);
+    if ((params.parts && params.parts.length > 0) || (graphics?.parts && graphics.parts.length > 0)) {
+        return Physics3DType.COMPOUND;
+    }
+    if (graphics?.shape)
+        return normalizeType(graphics.shape);
+    return Physics3DType.BOX;
+}
+function meshColliderFingerprint(collider, model) {
+    if (!model || collider === 'manual')
+        return undefined;
+    return `${collider}:${model.resource}:${model.scaleX}:${model.scaleY}:${model.scaleZ}`;
+}
+
+function applyBodyOptions(body, options) {
+    if (!options)
+        return;
+    if (options.friction !== undefined) {
+        body.material = new CANNON.Material({
+            friction: options.friction,
+            restitution: options.restitution ?? 0.3,
+        });
+    }
+    if (options.restitution !== undefined && !body.material) {
+        body.material = new CANNON.Material({ friction: 0.3, restitution: options.restitution });
+    }
+    if (options.linearDamping !== undefined)
+        body.linearDamping = options.linearDamping;
+    if (options.angularDamping !== undefined)
+        body.angularDamping = options.angularDamping;
+    if (options.fixedRotation !== undefined)
+        body.fixedRotation = options.fixedRotation;
+    body.updateMassProperties();
+}
+function addPlaced(body, type, dims, part) {
+    const placed = placedShapesForType(type, dims);
+    const extraOffset = part ? offsetFromPart(part) : new CANNON.Vec3();
+    const extraQuat = part ? quaternionFromPart(part) : undefined;
+    for (const item of placed) {
+        const local = (item.offset ? item.offset.clone() : new CANNON.Vec3());
+        if (extraQuat)
+            extraQuat.vmult(local, local);
+        const offset = extraOffset.vadd(local);
+        const quat = extraQuat && item.quaternion
+            ? extraQuat.mult(item.quaternion)
+            : (extraQuat || item.quaternion);
+        body.addShape(item.shape, offset, quat);
+    }
+}
+class BodiesFactory {
+    create(component, context = {}) {
+        const { bodyParams } = component;
+        const graphics = context.graphics;
+        const model = context.model;
+        const collider = resolveCollider(bodyParams, model);
+        if (collider !== 'manual') {
+            if (!context.modelGroup)
+                return null;
+            let mass = bodyParams.mass ?? 1;
+            if (collider === 'trimesh' && mass !== 0) {
+                mass = 0;
+            }
+            const body = this.createBodyShell(component, mass, context.pose || graphics);
+            const ok = addModelCollider(body, context.modelGroup, collider);
+            if (!ok)
+                return null;
+            applyBodyOptions(body, bodyParams.bodyOptions);
+            component.meshColliderKey = meshColliderFingerprint(collider, model);
+            return body;
+        }
+        const type = resolveType(bodyParams, graphics);
+        const dims = dimsFromParams(bodyParams, {
+            width: graphics?.width,
+            height: graphics?.height,
+            depth: graphics?.depth,
+            radius: graphics?.radius,
+            segments: graphics?.segments,
+            tube: graphics?.tube,
+            finite: bodyParams.finite,
         });
-        // Set position
-        const pos = bodyParams.position;
-        if (pos) {
-            body.position.set(pos.x ?? 0, pos.y ?? 0, pos.z ?? 0);
-        }
-        // Set rotation (Euler to quaternion)
-        const rot = bodyParams.rotation;
-        if (rot) {
-            body.quaternion.setFromEuler(rot.x ?? 0, rot.y ?? 0, rot.z ?? 0);
-        }
-        // Apply body options
-        if (options.friction !== undefined)
-            body.material = new CANNON.Material({ friction: options.friction, restitution: options.restitution ?? 0.3 });
-        if (options.restitution !== undefined && !body.material)
-            body.material = new CANNON.Material({ friction: 0.3, restitution: options.restitution });
-        if (options.linearDamping !== undefined)
-            body.linearDamping = options.linearDamping;
-        if (options.angularDamping !== undefined)
-            body.angularDamping = options.angularDamping;
-        if (options.fixedRotation !== undefined)
-            body.fixedRotation = options.fixedRotation;
-        body.updateMassProperties();
+        const infinitePlane = type === Physics3DType.PLANE && !dims.finite;
+        const mass = infinitePlane ? 0 : (bodyParams.mass ?? 1);
+        const body = this.createBodyShell(component, mass, context.pose || graphics);
+        if (type === Physics3DType.COMPOUND) {
+            const parts = bodyParams.parts?.length ? bodyParams.parts : (graphics?.parts || []);
+            if (!parts.length) {
+                addPlaced(body, Physics3DType.BOX, dims);
+            }
+            else {
+                for (const part of parts) {
+                    const partType = part.type || part.shape || Physics3DType.BOX;
+                    if (normalizeType(partType) === Physics3DType.COMPOUND)
+                        continue;
+                    const partDims = dimsFromParams(part, dims);
+                    addPlaced(body, partType, partDims, part);
+                }
+            }
+        }
+        else {
+            addPlaced(body, type, dims);
+        }
+        applyBodyOptions(body, bodyParams.bodyOptions);
+        component.meshColliderKey = undefined;
+        return body;
+    }
+    createBodyShell(component, mass, graphics) {
+        const body = new CANNON.Body({ mass });
+        const pos = component.bodyParams.position;
+        body.position.set(pos?.x ?? graphics?.positionX ?? 0, pos?.y ?? graphics?.positionY ?? 0, pos?.z ?? graphics?.positionZ ?? 0);
+        const rot = component.bodyParams.rotation;
+        const rx = rot?.x ?? graphics?.rotationX ?? 0;
+        const ry = rot?.y ?? graphics?.rotationY ?? 0;
+        const rz = rot?.z ?? graphics?.rotationZ ?? 0;
+        if (rx || ry || rz) {
+            body.quaternion.setFromEuler(rx, ry, rz);
+        }
         return body;
     }
 }
 
 class Physics3DEngine {
     constructor(game, options) {
+        this.pending = new Set();
+        this.pendingConstraints = new Set();
+        this.constraints = new Set();
+        this.contactPairs = new Map();
         this.enabled = false;
         this.game = game;
         this.options = options ?? {};
@@ -144,10 +489,8 @@ class Physics3DEngine {
     }
     start() {
         this.world = new CANNON.World();
-        // Set gravity
         const gravity = this.options.gravity ?? { x: 0, y: -9.82, z: 0 };
         this.world.gravity.set(gravity.x, gravity.y, gravity.z);
-        // Configure solver
         if (this.options.solver) {
             const solver = this.world.solver;
             if (this.options.solver.iterations !== undefined) {
@@ -165,10 +508,14 @@ class Physics3DEngine {
     update(e) {
         if (!this.world || !this.enabled)
             return;
+        this.flushPending();
+        this.rebuildStaleMeshColliders();
         const fixedTimeStep = this.options.fixedTimeStep ?? 1 / 60;
         const maxSubSteps = this.options.maxSubSteps ?? 3;
         const dt = (e.deltaTime || 16.67) / 1000;
+        this.flushConstraints();
         this.world.step(fixedTimeStep, dt, maxSubSteps);
+        this.emitCollisionActive();
     }
     stop() {
         this.enabled = false;
@@ -177,8 +524,16 @@ class Physics3DEngine {
         this.enabled = true;
     }
     destroy() {
+        this.pending.clear();
+        this.pendingConstraints.clear();
+        this.contactPairs.clear();
         if (this.world) {
-            // Remove all bodies
+            for (const constraint of this.constraints) {
+                if (constraint.constraint)
+                    this.world.removeConstraint(constraint.constraint);
+                constraint.constraint = undefined;
+            }
+            this.constraints.clear();
             while (this.world.bodies.length > 0) {
                 this.world.removeBody(this.world.bodies[0]);
             }
@@ -186,32 +541,131 @@ class Physics3DEngine {
         }
     }
     add(component) {
-        const body = this.bodiesFactory.create(component);
-        this.world.addBody(body);
-        // Inject references into component
-        component.body = body;
-        component.world = this.world;
-        // Back-link for collision event lookup
-        body.component = component;
+        const body = this.tryCreate(component);
+        if (!body) {
+            this.pending.add(component);
+            return;
+        }
+        this.attach(component, body);
     }
     change(component) {
-        // Remove old body, create and add new one
+        this.detachConstraintsFor(component);
+        this.clearContactsFor(component);
         if (component.body) {
             this.world.removeBody(component.body);
+            component.body = undefined;
         }
-        const newBody = this.bodiesFactory.create(component);
-        this.world.addBody(newBody);
-        component.body = newBody;
-        newBody.component = component;
+        this.pending.delete(component);
+        this.add(component);
     }
     remove(component) {
+        this.detachConstraintsFor(component);
+        this.clearContactsFor(component);
+        this.pending.delete(component);
         if (component.body) {
             this.world.removeBody(component.body);
             component.body = undefined;
         }
+        component.meshColliderKey = undefined;
+    }
+    addConstraint(component) {
+        this.removeConstraint(component);
+        this.pendingConstraints.add(component);
+        this.flushConstraints();
+    }
+    removeConstraint(component) {
+        this.pendingConstraints.delete(component);
+        this.constraints.delete(component);
+        if (component.constraint && this.world) {
+            this.world.removeConstraint(component.constraint);
+        }
+        component.constraint = undefined;
+    }
+    flushConstraints() {
+        if (!this.world)
+            return;
+        for (const component of [...this.pendingConstraints]) {
+            if (!component.gameObject) {
+                this.pendingConstraints.delete(component);
+                continue;
+            }
+            if (this.tryAttachConstraint(component)) {
+                this.pendingConstraints.delete(component);
+            }
+        }
+    }
+    tryCreate(component) {
+        const context = this.contextFor(component);
+        return this.bodiesFactory.create(component, context);
+    }
+    attach(component, body) {
+        this.world.addBody(body);
+        component.body = body;
+        component.world = this.world;
+        body.component = component;
+    }
+    contextFor(component) {
+        const gameObject = component.gameObject;
+        const graphics = gameObject?.getComponent('Graphics3D');
+        const model = gameObject?.getComponent('Model3D');
+        const transform3d = gameObject?.getComponent('Transform3D');
+        const renderer = this.game.getSystem(Renderer3DSystem);
+        const modelGroup = gameObject ? renderer?.threeContext?.models.get(gameObject.id) : undefined;
+        const node = gameObject ? renderer?.threeContext?.object3DFor(gameObject.id) : undefined;
+        const scene = renderer?.threeContext?.scene;
+        let worldPose;
+        if (node?.parent && node.parent !== scene) {
+            node.updateWorldMatrix(true, false);
+            const position = new Vector3();
+            const euler = new Euler();
+            node.getWorldPosition(position);
+            euler.setFromRotationMatrix(node.matrixWorld);
+            worldPose = {
+                positionX: position.x,
+                positionY: position.y,
+                positionZ: position.z,
+                rotationX: euler.x,
+                rotationY: euler.y,
+                rotationZ: euler.z,
+            };
+        }
+        return { graphics, model, modelGroup, pose: worldPose || transform3d || graphics };
+    }
+    flushPending() {
+        if (!this.pending.size)
+            return;
+        for (const component of [...this.pending]) {
+            if (!component.gameObject) {
+                this.pending.delete(component);
+                continue;
+            }
+            const body = this.tryCreate(component);
+            if (body) {
+                this.attach(component, body);
+                this.pending.delete(component);
+            }
+        }
+    }
+    rebuildStaleMeshColliders() {
+        if (!this.world)
+            return;
+        const stale = [];
+        for (const body of this.world.bodies) {
+            const component = body.component;
+            if (!component?.gameObject)
+                continue;
+            const model = component.gameObject.getComponent('Model3D');
+            const collider = resolveCollider(component.bodyParams, model);
+            const key = meshColliderFingerprint(collider, model);
+            if (!key || key === component.meshColliderKey)
+                continue;
+            stale.push(component);
+        }
+        for (const component of stale) {
+            this.change(component);
+        }
     }
     initCollisionEvents() {
-        // beginContact: emitted when two bodies start touching
         this.world.addEventListener('beginContact', (event) => {
             const bodyA = event.bodyA;
             const bodyB = event.bodyB;
@@ -220,9 +674,10 @@ class Physics3DEngine {
             if (componentA && componentB) {
                 componentA.emit('collisionStart', componentB.gameObject, componentA.gameObject);
                 componentB.emit('collisionStart', componentA.gameObject, componentB.gameObject);
+                const pair = this.pairKey(bodyA, bodyB);
+                this.contactPairs.set(pair, [bodyA.component, bodyB.component]);
             }
         });
-        // endContact: emitted when two bodies stop touching
         this.world.addEventListener('endContact', (event) => {
             const bodyA = event.bodyA;
             const bodyB = event.bodyB;
@@ -232,8 +687,82 @@ class Physics3DEngine {
                 componentA.emit('collisionEnd', componentB.gameObject, componentA.gameObject);
                 componentB.emit('collisionEnd', componentA.gameObject, componentB.gameObject);
             }
+            this.contactPairs.delete(this.pairKey(bodyA, bodyB));
         });
     }
+    emitCollisionActive() {
+        for (const [componentA, componentB] of this.contactPairs.values()) {
+            if (!componentA?.gameObject || !componentB?.gameObject)
+                continue;
+            componentA.emit('collisionActive', componentB.gameObject, componentA.gameObject);
+            componentB.emit('collisionActive', componentA.gameObject, componentB.gameObject);
+        }
+    }
+    pairKey(bodyA, bodyB) {
+        return bodyA.id < bodyB.id ? `${bodyA.id}:${bodyB.id}` : `${bodyB.id}:${bodyA.id}`;
+    }
+    clearContactsFor(component) {
+        for (const [key, pair] of this.contactPairs) {
+            if (pair[0] === component || pair[1] === component) {
+                this.contactPairs.delete(key);
+            }
+        }
+    }
+    tryAttachConstraint(component) {
+        const physicsA = component.gameObject?.getComponent('Physics3D');
+        const target = this.game.gameObjects.find((go) => go.name === component.target);
+        const physicsB = target?.getComponent('Physics3D');
+        if (!physicsA?.body || !physicsB?.body || physicsA.body === physicsB.body)
+            return false;
+        const constraint = this.createConstraint(component, physicsA.body, physicsB.body);
+        constraint.collideConnected = component.collideConnected;
+        this.world.addConstraint(constraint);
+        component.constraint = constraint;
+        this.constraints.add(component);
+        return true;
+    }
+    createConstraint(component, bodyA, bodyB) {
+        const maxForce = component.maxForce;
+        const pivotA = new CANNON.Vec3(component.pivotAX, component.pivotAY, component.pivotAZ);
+        const pivotB = new CANNON.Vec3(component.pivotBX, component.pivotBY, component.pivotBZ);
+        const axisA = new CANNON.Vec3(component.axisAX, component.axisAY, component.axisAZ);
+        const axisB = new CANNON.Vec3(component.axisBX, component.axisBY, component.axisBZ);
+        switch (component.type) {
+            case 'point':
+                return new CANNON.PointToPointConstraint(bodyA, pivotA, bodyB, pivotB, maxForce);
+            case 'lock':
+                return new CANNON.LockConstraint(bodyA, bodyB, { maxForce });
+            case 'distance':
+                return new CANNON.DistanceConstraint(bodyA, bodyB, component.distance, maxForce);
+            case 'hinge':
+            default: {
+                const hinge = new CANNON.HingeConstraint(bodyA, bodyB, {
+                    pivotA,
+                    pivotB,
+                    axisA,
+                    axisB,
+                    maxForce,
+                    collideConnected: component.collideConnected,
+                });
+                if (component.motor) {
+                    hinge.enableMotor();
+                    hinge.setMotorSpeed(component.motorSpeed);
+                }
+                return hinge;
+            }
+        }
+    }
+    detachConstraintsFor(physics) {
+        for (const constraint of [...this.constraints]) {
+            const physicsA = constraint.gameObject?.getComponent('Physics3D');
+            const target = this.game.gameObjects.find((go) => go.name === constraint.target);
+            const physicsB = target?.getComponent('Physics3D');
+            if (physicsA === physics || physicsB === physics) {
+                this.removeConstraint(constraint);
+                this.pendingConstraints.add(constraint);
+            }
+        }
+    }
 }
 
 let Physics3DSystem = class Physics3DSystem extends System {
@@ -268,6 +797,7 @@ let Physics3DSystem = class Physics3DSystem extends System {
                     break;
                 }
                 case OBSERVER_TYPE.REMOVE: {
+                    this.engine.remove(changed.component);
                     break;
                 }
             }
@@ -311,11 +841,97 @@ Physics3DSystem = __decorate([
 ], Physics3DSystem);
 var Physics3DSystem$1 = Physics3DSystem;
 
+let Physics3DConstraintSystem = class Physics3DConstraintSystem extends System {
+    constructor() {
+        super(...arguments);
+        this.name = 'Physics3DConstraintSystem';
+    }
+    static { this.systemName = 'Physics3DConstraintSystem'; }
+    init() {
+        const physics = this.game.getSystem(Physics3DSystem$1);
+        if (!physics) {
+            console.warn('Physics3DConstraintSystem requires Physics3DSystem');
+        }
+    }
+    update() {
+        const engine = this.engine();
+        const changes = this.componentObserver.clear();
+        for (const changed of changes) {
+            this.componentChanged(changed);
+        }
+        engine?.flushConstraints();
+    }
+    componentChanged(changed) {
+        if (changed.componentName !== 'Physics3DConstraint')
+            return;
+        const engine = this.engine();
+        if (!engine)
+            return;
+        const component = changed.component;
+        if (changed.type === OBSERVER_TYPE.REMOVE) {
+            engine.removeConstraint(component);
+            return;
+        }
+        engine.addConstraint(component);
+    }
+    engine() {
+        return this.game.getSystem(Physics3DSystem$1)?.engine;
+    }
+};
+Physics3DConstraintSystem = __decorate([
+    decorators.componentObserver({
+        Physics3DConstraint: [
+            'type', 'target',
+            'pivotAX', 'pivotAY', 'pivotAZ',
+            'pivotBX', 'pivotBY', 'pivotBZ',
+            'axisAX', 'axisAY', 'axisAZ',
+            'axisBX', 'axisBY', 'axisBZ',
+            'distance', 'maxForce', 'collideConnected',
+            'motor', 'motorSpeed',
+        ],
+    })
+], Physics3DConstraintSystem);
+var Physics3DConstraintSystem$1 = Physics3DConstraintSystem;
+
 /** Auto-generated by scripts/build-package.mjs — do not edit. */
+Object.assign(Physics3DConstraintSystem$1, {
+    packageName: "@combos-fun/plugin-cannon",
+    packageVersion: "0.0.45",
+});
 Object.assign(Physics3DSystem$1, {
     packageName: "@combos-fun/plugin-cannon",
-    packageVersion: "0.0.42",
+    packageVersion: "0.0.45",
 });
 
-export { Physics3D, Physics3DSystem$1 as Physics3DSystem, Physics3DType };
+class Physics3DConstraint extends Component {
+    constructor() {
+        super(...arguments);
+        this.type = 'hinge';
+        this.target = '';
+        this.pivotAX = 0;
+        this.pivotAY = 0;
+        this.pivotAZ = 0;
+        this.pivotBX = 0;
+        this.pivotBY = 0;
+        this.pivotBZ = 0;
+        this.axisAX = 0;
+        this.axisAY = 1;
+        this.axisAZ = 0;
+        this.axisBX = 0;
+        this.axisBY = 1;
+        this.axisBZ = 0;
+        this.distance = 1;
+        this.maxForce = 1e6;
+        this.collideConnected = true;
+        this.motor = false;
+        this.motorSpeed = 0;
+    }
+    static { this.componentName = 'Physics3DConstraint'; }
+    init(obj) {
+        if (obj)
+            Object.assign(this, obj);
+    }
+}
+
+export { Physics3D, Physics3DConstraint, Physics3DConstraintSystem$1 as Physics3DConstraintSystem, Physics3DSystem$1 as Physics3DSystem, Physics3DType };
 //# sourceMappingURL=plugin-cannon.esm.js.map