@playcraft/build 0.0.13 → 0.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/build",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,8 @@
     "lightningcss": "^1.31.1",
     "mime-types": "^2.1.35",
     "rollup-plugin-visualizer": "^6.0.5",
-    "sharp": "^0.33.5",
+    "sharp": "^0.34.5",
+    "javascript-obfuscator": "^5.3.0",
     "terser": "^5.46.0",
     "vite": "^6.4.1",
     "vite-plugin-singlefile": "^2.3.0"
@@ -48,6 +49,7 @@
     "@types/archiver": "^6.0.4",
     "@types/mime-types": "^2.1.4",
     "@types/node": "^22.19.8",
+    "fflate": "^0.8.2",
     "typescript": "^5.9.3"
   }
 }

package/physics/cannon-rigidbody-adapter.js

@@ -22,6 +22,7 @@
     // Store references
     var cannonWorld = null;
     var rigidBodyMap = []; // Array of { entity, body } pairs
+    var triggerBodyMap = []; // Array of { entity, body } pairs for trigger volumes
     var initialized = false;
 
     /**
@@ -44,6 +45,20 @@
             var bodyA = event.bodyA;
             var bodyB = event.bodyB;
             
+            // Check if either body is a trigger
+            if (bodyA.isTrigger || bodyB.isTrigger) {
+                var triggerBody = bodyA.isTrigger ? bodyA : bodyB;
+                var otherBody = bodyA.isTrigger ? bodyB : bodyA;
+                
+                if (triggerBody.entity && otherBody.entity) {
+                    // Fire triggerenter on the trigger entity's collision component
+                    if (triggerBody.entity.collision) {
+                        triggerBody.entity.collision.fire('triggerenter', otherBody.entity);
+                    }
+                }
+                return;
+            }
+            
             if (bodyA.entity && bodyB.entity) {
                 bodyA.entity.fire('collisionstart', { other: bodyB.entity });
                 bodyB.entity.fire('collisionstart', { other: bodyA.entity });
@@ -54,6 +69,19 @@
             var bodyA = event.bodyA;
             var bodyB = event.bodyB;
             
+            // Check if either body is a trigger
+            if (bodyA.isTrigger || bodyB.isTrigger) {
+                var triggerBody = bodyA.isTrigger ? bodyA : bodyB;
+                var otherBody = bodyA.isTrigger ? bodyB : bodyA;
+                
+                if (triggerBody.entity && otherBody.entity) {
+                    if (triggerBody.entity.collision) {
+                        triggerBody.entity.collision.fire('triggerleave', otherBody.entity);
+                    }
+                }
+                return;
+            }
+            
             if (bodyA.entity && bodyB.entity) {
                 bodyA.entity.fire('collisionend', { other: bodyB.entity });
                 bodyB.entity.fire('collisionend', { other: bodyA.entity });
@@ -61,10 +89,110 @@
         });
 
         cannonWorld = world;
+
+        // Set default contact material
+        world.defaultContactMaterial.friction = 0.5;
+        world.defaultContactMaterial.restitution = 0.3;
+
         console.log('[Cannon Adapter] Cannon world created with gravity:', gravity);
         return world;
     }
 
+    /**
+     * Create a collision shape for mesh type by extracting AABB from the render asset.
+     */
+    function createMeshShape(entity, onShapeReady) {
+        var collision = entity.collision;
+        var renderAssetId = collision.renderAsset;
+
+        if (renderAssetId) {
+            var app = pc.Application.getApplication();
+            if (app) {
+                var asset = app.assets.get(renderAssetId);
+
+                if (asset && !asset.resource) {
+                    // Asset exists but not yet loaded — defer shape creation
+                    asset.ready(function() {
+                        var shape = extractShapeFromAsset(asset, entity);
+                        if (shape && onShapeReady) {
+                            onShapeReady(shape);
+                        }
+                    });
+                    app.assets.load(asset);
+                    return null;
+                }
+
+                if (asset && asset.resource) {
+                    return extractShapeFromAsset(asset, entity);
+                }
+            }
+        }
+
+        // Fallback: try entity's own render/model component
+        return extractShapeFromMeshInstances(entity);
+    }
+
+    /**
+     * Extract a box shape from an asset's mesh instances AABB.
+     */
+    function extractShapeFromAsset(asset, entity) {
+        var meshInstances = null;
+
+        if (asset.resource.meshInstances) {
+            meshInstances = asset.resource.meshInstances;
+        } else if (asset.resource.renders && asset.resource.renders.length > 0) {
+            meshInstances = asset.resource.renders[0].meshInstances;
+        }
+
+        if (meshInstances && meshInstances.length > 0) {
+            return buildBoxFromMeshInstances(meshInstances, entity);
+        }
+        return null;
+    }
+
+    /**
+     * Extract a box shape from entity's own render/model mesh instances.
+     */
+    function extractShapeFromMeshInstances(entity) {
+        var mi = null;
+        if (entity.render && entity.render.meshInstances) {
+            mi = entity.render.meshInstances;
+        } else if (entity.model && entity.model.meshInstances) {
+            mi = entity.model.meshInstances;
+        }
+        if (mi && mi.length > 0) {
+            return buildBoxFromMeshInstances(mi, entity);
+        }
+        return null;
+    }
+
+    /**
+     * Build a CANNON.Box from merged AABB of mesh instances.
+     */
+    function buildBoxFromMeshInstances(meshInstances, entity) {
+        var mergedAabb = null;
+        for (var j = 0; j < meshInstances.length; j++) {
+            var instanceAabb = meshInstances[j].aabb;
+            if (instanceAabb) {
+                if (!mergedAabb) {
+                    mergedAabb = instanceAabb.clone();
+                } else {
+                    mergedAabb.add(instanceAabb);
+                }
+            }
+        }
+        if (mergedAabb) {
+            var he = mergedAabb.halfExtents;
+            var scale = entity.getLocalScale();
+            return new CANNON.Box(new CANNON.Vec3(
+                he.x * scale.x,
+                he.y * scale.y,
+                he.z * scale.z
+            ));
+        }
+        return null;
+    }
+
     /**
      * Create Cannon shape from PlayCanvas collision component
      */
@@ -99,9 +227,31 @@
                 collision.height,
                 8
             );
+        } else if (type === 'mesh') {
+            // Pass a deferred callback — if the asset isn't loaded yet, the shape
+            // will be swapped in once the asset finishes loading.
+            var deferredEntity = entity;
+            shape = createMeshShape(entity, function(loadedShape) {
+                // Find the body that was created for this entity and swap the shape
+                for (var idx = 0; idx < rigidBodyMap.length; idx++) {
+                    if (rigidBodyMap[idx].entity === deferredEntity) {
+                        var body = rigidBodyMap[idx].body;
+                        // Remove old shapes and add the loaded one
+                        while (body.shapes.length > 0) {
+                            body.removeShape(body.shapes[0]);
+                        }
+                        body.addShape(loadedShape);
+                        console.log('[Cannon Adapter] Deferred mesh shape loaded for:', deferredEntity.name);
+                        break;
+                    }
+                }
+            });
+            if (!shape) {
+                console.warn('[Cannon Adapter] Mesh collision: asset not ready, using temporary default box for:', entity.name);
+                shape = new CANNON.Box(new CANNON.Vec3(0.5, 0.5, 0.5));
+            }
         } 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));
         }
 
@@ -132,30 +282,39 @@
             mass = 0;
         }
 
+        var bodyMaterial = new CANNON.Material();
+        if (rb.friction !== undefined) bodyMaterial.friction = rb.friction;
+        if (rb.restitution !== undefined) bodyMaterial.restitution = rb.restitution;
+
         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
+            shape: shape,
+            material: bodyMaterial,
+            linearDamping: rb.linearDamping || 0,
+            angularDamping: rb.angularDamping || 0
         });
 
         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;
+        // Apply linearFactor and angularFactor
+        if (rb.linearFactor) {
+            var lf = rb.linearFactor;
+            if (Array.isArray(lf)) body.linearFactor.set(lf[0], lf[1], lf[2]);
+            else if (lf.x !== undefined) body.linearFactor.set(lf.x, lf.y, lf.z);
         }
-        if (rb.restitution !== undefined) {
-            body.material = body.material || new CANNON.Material();
-            body.material.restitution = rb.restitution;
+        if (rb.angularFactor) {
+            var af = rb.angularFactor;
+            if (Array.isArray(af)) body.angularFactor.set(af[0], af[1], af[2]);
+            else if (af.x !== undefined) body.angularFactor.set(af.x, af.y, af.z);
         }
 
+        // Store entity reference
+        body.entity = entity;
+
         // Add to world
         world.addBody(body);
         rigidBodyMap.push({ entity: entity, body: body });
@@ -164,6 +323,40 @@
         return body;
     }
 
+    /**
+     * Create a trigger body for entities with collision but no rigidbody
+     * In PlayCanvas, entities with collision but no rigidbody act as triggers
+     */
+    function createTriggerBody(entity, world) {
+        if (!entity.collision || entity.rigidbody) {
+            return null;
+        }
+
+        var shape = createCannonShape(entity);
+        if (!shape) return null;
+
+        var pos = entity.getPosition();
+        var rot = entity.getRotation();
+
+        var body = new CANNON.Body({
+            mass: 0,
+            position: new CANNON.Vec3(pos.x, pos.y, pos.z),
+            quaternion: new CANNON.Quaternion(rot.x, rot.y, rot.z, rot.w),
+            shape: shape,
+            collisionResponse: false  // Trigger bodies don't produce collision response
+        });
+
+        body.entity = entity;
+        body.isTrigger = true;
+
+        world.addBody(body);
+        triggerBodyMap.push({ entity: entity, body: body });
+        rigidBodyMap.push({ entity: entity, body: body });
+
+        console.log('[Cannon Adapter] Created trigger body for entity:', entity.name);
+        return body;
+    }
+
     /**
      * Create compatibility layer for rigidbody API
      */
@@ -180,10 +373,30 @@
         }
 
         // 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);
+        // applyForce supports two calling conventions:
+        //   1. applyForce(forceVec3, [pointVec3])       — two Vec3 objects
+        //   2. applyForce(fx, fy, fz, [px, py, pz])     — six numbers
+        rb.applyForce = function() {
+            var force, point;
+            var a = arguments;
+
+            if (a.length >= 1 && typeof a[0] === 'object' && a[0] !== null && a[0].x !== undefined) {
+                // Vec3 calling convention
+                force = new CANNON.Vec3(a[0].x, a[0].y, a[0].z);
+                if (a.length >= 2 && typeof a[1] === 'object' && a[1] !== null && a[1].x !== undefined) {
+                    point = new CANNON.Vec3(a[1].x, a[1].y, a[1].z);
+                }
+            } else if (a.length >= 3) {
+                // Number calling convention
+                force = new CANNON.Vec3(a[0], a[1], a[2]);
+                if (a.length >= 6) {
+                    point = new CANNON.Vec3(a[3], a[4], a[5]);
+                }
+            } else {
+                return;
+            }
+
+            if (point) {
                 cannonBody.applyForce(force, point);
             } else {
                 cannonBody.applyForce(force);
@@ -197,7 +410,7 @@
             } 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);
@@ -311,15 +524,23 @@
         
         var world = initCannonWorld(app);
         var count = 0;
+        var triggerCount = 0;
 
-        // Find all entities with rigidbody component
+        // Find all entities with rigidbody component or trigger collision
         function processEntity(entity) {
             if (entity.rigidbody && entity.collision) {
+                // Entity with both rigidbody and collision = physics body
                 var body = createCannonBody(entity, world);
                 if (body) {
                     wrapRigidbodyAPI(entity, body);
                     count++;
                 }
+            } else if (entity.collision && !entity.rigidbody) {
+                // Entity with collision but no rigidbody = trigger volume
+                var triggerBody = createTriggerBody(entity, world);
+                if (triggerBody) {
+                    triggerCount++;
+                }
             }
 
             // Process children
@@ -331,7 +552,7 @@
 
         processEntity(app.root);
         
-        console.log('[Cannon Adapter] Initialized', count, 'rigidbodies');
+        console.log('[Cannon Adapter] Initialized', count, 'rigidbodies and', triggerCount, 'triggers');
         initialized = true;
 
         // Hook into update loop
@@ -355,11 +576,11 @@
     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
+            if (app && app.root && app.root.children.length > 0) {
+                // Scene is loaded. Wait for assets (mesh colliders need render assets loaded)
                 setTimeout(function() {
                     initializeRigidbodies(app);
-                }, 100);
+                }, 200);
                 return;
             }
         }

package/templates/__loading__.js

@@ -21,10 +21,6 @@ pc.script.createLoadingScreen((app) => {
                 left: calc(50% - 132px);
             }
 
-            #application-splash img {
-                width: 100%;
-            }
-
             #progress-bar-container {
                 margin: 20px auto 0 auto;
                 height: 2px;
@@ -59,14 +55,6 @@ pc.script.createLoadingScreen((app) => {
         const splash = document.createElement('div');
         splash.id = 'application-splash';
         wrapper.appendChild(splash);
-        splash.style.display = 'none';
-
-        const logo = document.createElement('img');
-        logo.src = `${ASSET_PREFIX}logo.png`;
-        splash.appendChild(logo);
-        logo.onload = () => {
-            splash.style.display = 'block';
-        };
 
         const container = document.createElement('div');
         container.id = 'progress-bar-container';

package/templates/index.esm.mjs

@@ -426,10 +426,6 @@ pc.script.createLoadingScreen(app => {
                 left: calc(50% - 132px);
             }
 
-            #application-splash img {
-                width: 100%;
-            }
-
             #progress-bar-container {
                 margin: 20px auto 0 auto;
                 height: 2px;
@@ -462,13 +458,6 @@ pc.script.createLoadingScreen(app => {
         const splash = document.createElement('div');
         splash.id = 'application-splash';
         wrapper.appendChild(splash);
-        splash.style.display = 'none';
-        const logo = document.createElement('img');
-        logo.src = `${ASSET_PREFIX}logo.png`;
-        splash.appendChild(logo);
-        logo.onload = () => {
-            splash.style.display = 'block';
-        };
         const container = document.createElement('div');
         container.id = 'progress-bar-container';
         splash.appendChild(container);