@playcraft/build 0.0.4 → 0.0.8

package/physics/cannon-rigidbody-adapter.js

@@ -0,0 +1,375 @@
+/**
+ * Cannon.js Rigidbody Adapter for PlayCanvas
+ * 
+ * This adapter creates a compatibility layer between PlayCanvas's native rigidbody API
+ * and Cannon.js physics engine. It allows existing PlayCanvas projects using
+ * Ammo.js to seamlessly switch to Cannon.js without code changes.
+ * 
+ * Usage: This script is automatically injected when using Cannon.js replacement.
+ */
+
+(function() {
+    'use strict';
+
+    // Wait for PlayCanvas to be ready
+    if (typeof pc === 'undefined' || typeof CANNON === 'undefined') {
+        console.error('[Cannon Adapter] PlayCanvas or Cannon.js not loaded');
+        return;
+    }
+
+    console.log('[Cannon Adapter] Initializing Cannon.js rigidbody adapter...');
+
+    // Store references
+    var cannonWorld = null;
+    var rigidBodyMap = []; // Array of { entity, body } pairs
+    var initialized = false;
+
+    /**
+     * Initialize Cannon World
+     */
+    function initCannonWorld(app) {
+        if (cannonWorld) return cannonWorld;
+
+        // Create Cannon world
+        var world = new CANNON.World();
+        
+        // Get gravity from settings or use default
+        var gravity = (window.SCENE_SETTINGS && window.SCENE_SETTINGS.physics && window.SCENE_SETTINGS.physics.gravity) 
+            || [0, -9.8, 0];
+        
+        world.gravity.set(gravity[0], gravity[1], gravity[2]);
+        
+        // Setup collision events
+        world.addEventListener('beginContact', function(event) {
+            var bodyA = event.bodyA;
+            var bodyB = event.bodyB;
+            
+            if (bodyA.entity && bodyB.entity) {
+                bodyA.entity.fire('collisionstart', { other: bodyB.entity });
+                bodyB.entity.fire('collisionstart', { other: bodyA.entity });
+            }
+        });
+        
+        world.addEventListener('endContact', function(event) {
+            var bodyA = event.bodyA;
+            var bodyB = event.bodyB;
+            
+            if (bodyA.entity && bodyB.entity) {
+                bodyA.entity.fire('collisionend', { other: bodyB.entity });
+                bodyB.entity.fire('collisionend', { other: bodyA.entity });
+            }
+        });
+
+        cannonWorld = world;
+        console.log('[Cannon Adapter] Cannon world created with gravity:', gravity);
+        return world;
+    }
+
+    /**
+     * Create Cannon shape from PlayCanvas collision component
+     */
+    function createCannonShape(entity) {
+        var collision = entity.collision;
+        if (!collision) return null;
+
+        var shape;
+        var type = collision.type;
+
+        if (type === 'box') {
+            var halfExtents = collision.halfExtents;
+            shape = new CANNON.Box(new CANNON.Vec3(
+                halfExtents.x,
+                halfExtents.y,
+                halfExtents.z
+            ));
+        } else if (type === 'sphere') {
+            shape = new CANNON.Sphere(collision.radius);
+        } else if (type === 'capsule') {
+            // Cannon doesn't have capsule, use cylinder
+            shape = new CANNON.Cylinder(
+                collision.radius,
+                collision.radius,
+                collision.height,
+                8
+            );
+        } else if (type === 'cylinder') {
+            shape = new CANNON.Cylinder(
+                collision.radius,
+                collision.radius,
+                collision.height,
+                8
+            );
+        } else {
+            console.warn('[Cannon Adapter] Unsupported collision type:', type);
+            // Default to box
+            shape = new CANNON.Box(new CANNON.Vec3(0.5, 0.5, 0.5));
+        }
+
+        return shape;
+    }
+
+    /**
+     * Create Cannon body from PlayCanvas rigidbody component
+     */
+    function createCannonBody(entity, world) {
+        if (!entity.rigidbody || !entity.collision) {
+            return null;
+        }
+
+        var rb = entity.rigidbody;
+        var shape = createCannonShape(entity);
+        if (!shape) return null;
+
+        var pos = entity.getPosition();
+        var rot = entity.getRotation();
+        
+        var mass = rb.mass || 0;
+        var bodyType = rb.type;
+        
+        // Map PlayCanvas body types to Cannon
+        // PlayCanvas: 'static' | 'dynamic' | 'kinematic'
+        if (bodyType === 'static') {
+            mass = 0;
+        }
+
+        var body = new CANNON.Body({
+            mass: mass,
+            position: new CANNON.Vec3(pos.x, pos.y, pos.z),
+            quaternion: new CANNON.Quaternion(rot.x, rot.y, rot.z, rot.w),
+            shape: shape
+        });
+
+        if (bodyType === 'kinematic') {
+            body.type = CANNON.Body.KINEMATIC;
+        }
+
+        // Store entity reference
+        body.entity = entity;
+        
+        // Store friction and restitution
+        if (rb.friction !== undefined) {
+            body.material = body.material || new CANNON.Material();
+            body.material.friction = rb.friction;
+        }
+        if (rb.restitution !== undefined) {
+            body.material = body.material || new CANNON.Material();
+            body.material.restitution = rb.restitution;
+        }
+
+        // Add to world
+        world.addBody(body);
+        rigidBodyMap.push({ entity: entity, body: body });
+
+        console.log('[Cannon Adapter] Created body for entity:', entity.name, 'type:', bodyType);
+        return body;
+    }
+
+    /**
+     * Create compatibility layer for rigidbody API
+     */
+    function wrapRigidbodyAPI(entity, cannonBody) {
+        var rb = entity.rigidbody;
+        if (!rb) return;
+
+        // Store original rigidbody component
+        var originalRb = {};
+        for (var key in rb) {
+            if (rb.hasOwnProperty(key)) {
+                originalRb[key] = rb[key];
+            }
+        }
+
+        // Override rigidbody methods to use Cannon.js
+        rb.applyForce = function(x, y, z, px, py, pz) {
+            var force = new CANNON.Vec3(x, y, z);
+            if (px !== undefined && py !== undefined && pz !== undefined) {
+                var point = new CANNON.Vec3(px, py, pz);
+                cannonBody.applyForce(force, point);
+            } else {
+                cannonBody.applyForce(force);
+            }
+        };
+
+        rb.applyImpulse = function(impulse, relativePoint) {
+            var cannonImpulse;
+            if (impulse.x !== undefined) {
+                cannonImpulse = new CANNON.Vec3(impulse.x, impulse.y, impulse.z);
+            } else {
+                cannonImpulse = new CANNON.Vec3(impulse, relativePoint || 0, arguments[2] || 0);
+            }
+            
+            if (relativePoint && relativePoint.x !== undefined) {
+                var point = new CANNON.Vec3(relativePoint.x, relativePoint.y, relativePoint.z);
+                cannonBody.applyImpulse(cannonImpulse, point);
+            } else {
+                cannonBody.applyImpulse(cannonImpulse);
+            }
+        };
+
+        rb.applyTorque = function(x, y, z) {
+            var torque = new CANNON.Vec3(x, y, z);
+            cannonBody.applyTorque(torque);
+        };
+
+        rb.applyTorqueImpulse = function(x, y, z) {
+            // Cannon doesn't have applyTorqueImpulse, use velocity directly
+            cannonBody.angularVelocity.x += x / cannonBody.mass;
+            cannonBody.angularVelocity.y += y / cannonBody.mass;
+            cannonBody.angularVelocity.z += z / cannonBody.mass;
+        };
+
+        rb.teleport = function(x, y, z, rx, ry, rz, rw) {
+            if (typeof x === 'object') {
+                // Called with Vec3
+                cannonBody.position.set(x.x, x.y, x.z);
+                if (y && y.x !== undefined) {
+                    // Second argument is rotation Quat
+                    cannonBody.quaternion.set(y.x, y.y, y.z, y.w);
+                }
+            } else {
+                cannonBody.position.set(x, y, z);
+                if (rx !== undefined) {
+                    cannonBody.quaternion.set(rx, ry, rz, rw);
+                }
+            }
+            cannonBody.velocity.set(0, 0, 0);
+            cannonBody.angularVelocity.set(0, 0, 0);
+        };
+
+        // Velocity properties
+        Object.defineProperty(rb, 'linearVelocity', {
+            get: function() {
+                return new pc.Vec3(
+                    cannonBody.velocity.x,
+                    cannonBody.velocity.y,
+                    cannonBody.velocity.z
+                );
+            },
+            set: function(v) {
+                cannonBody.velocity.set(v.x, v.y, v.z);
+            }
+        });
+
+        Object.defineProperty(rb, 'angularVelocity', {
+            get: function() {
+                return new pc.Vec3(
+                    cannonBody.angularVelocity.x,
+                    cannonBody.angularVelocity.y,
+                    cannonBody.angularVelocity.z
+                );
+            },
+            set: function(v) {
+                cannonBody.angularVelocity.set(v.x, v.y, v.z);
+            }
+        });
+
+        // Store cannon body reference
+        entity.cannonBody = cannonBody;
+    }
+
+    /**
+     * Sync Cannon bodies with PlayCanvas entities
+     */
+    function syncBodies() {
+        if (!cannonWorld) return;
+
+        for (var i = 0; i < rigidBodyMap.length; i++) {
+            var pair = rigidBodyMap[i];
+            var entity = pair.entity;
+            var cannonBody = pair.body;
+
+            if (cannonBody.type === CANNON.Body.STATIC) {
+                // Sync static bodies from entity to cannon
+                var pos = entity.getPosition();
+                var rot = entity.getRotation();
+                cannonBody.position.set(pos.x, pos.y, pos.z);
+                cannonBody.quaternion.set(rot.x, rot.y, rot.z, rot.w);
+            } else if (cannonBody.sleepState !== CANNON.Body.SLEEPING) {
+                // Sync dynamic/kinematic bodies from cannon to entity
+                entity.setPosition(
+                    cannonBody.position.x,
+                    cannonBody.position.y,
+                    cannonBody.position.z
+                );
+                entity.setRotation(
+                    cannonBody.quaternion.x,
+                    cannonBody.quaternion.y,
+                    cannonBody.quaternion.z,
+                    cannonBody.quaternion.w
+                );
+            }
+        }
+    }
+
+    /**
+     * Initialize all rigidbodies in the scene
+     */
+    function initializeRigidbodies(app) {
+        if (initialized) return;
+
+        console.log('[Cannon Adapter] Scanning for rigidbody components...');
+        
+        var world = initCannonWorld(app);
+        var count = 0;
+
+        // Find all entities with rigidbody component
+        function processEntity(entity) {
+            if (entity.rigidbody && entity.collision) {
+                var body = createCannonBody(entity, world);
+                if (body) {
+                    wrapRigidbodyAPI(entity, body);
+                    count++;
+                }
+            }
+
+            // Process children
+            var children = entity.children;
+            for (var i = 0; i < children.length; i++) {
+                processEntity(children[i]);
+            }
+        }
+
+        processEntity(app.root);
+        
+        console.log('[Cannon Adapter] Initialized', count, 'rigidbodies');
+        initialized = true;
+
+        // Hook into update loop
+        var fixedTimeStep = 1/60;
+        var maxSubSteps = 3;
+
+        app.on('update', function(dt) {
+            if (cannonWorld) {
+                cannonWorld.step(fixedTimeStep, dt, maxSubSteps);
+                syncBodies();
+            }
+        });
+
+        // Expose world on app for debugging
+        app.cannonWorld = cannonWorld;
+    }
+
+    /**
+     * Wait for app to be ready and initialize
+     */
+    function waitForApp() {
+        if (typeof pc !== 'undefined' && pc.Application && pc.Application.getApplication) {
+            var app = pc.Application.getApplication();
+            if (app) {
+                // Wait for first frame to ensure all scripts are loaded
+                setTimeout(function() {
+                    initializeRigidbodies(app);
+                }, 100);
+                return;
+            }
+        }
+        
+        // Retry after a short delay
+        setTimeout(waitForApp, 50);
+    }
+
+    // Start initialization
+    waitForApp();
+
+    console.log('[Cannon Adapter] Adapter loaded, waiting for app initialization...');
+})();