matrix-engine-wgpu 1.1.1 → 1.2.0

package/src/physics/matrix-ammo.js

@@ -11,9 +11,9 @@ export default class MatrixAmmo {
       undefined,
       this.init,
     );
-
     this.lastRoll = '';
     this.presentScore = '';
+    this.speedUpSimulation = 1;
   }
 
   init = () => {
@@ -86,6 +86,8 @@ export default class MatrixAmmo {
       rbInfo = new Ammo.btRigidBodyConstructionInfo(mass, myMotionState, colShape, localInertia),
       body = new Ammo.btRigidBody(rbInfo);
 
+    console.log("TEST ADDING PHYSICS ");
+
     body.MEObject = MEObject;
     this.dynamicsWorld.addRigidBody(body);
     this.rigidBodies.push(body);
@@ -159,8 +161,6 @@ export default class MatrixAmmo {
     pos.setX(pos.x() + x)
     pos.setY(pos.y() + y)
     pos.setZ(pos.z() + z)
-    // console.log('position kinematic move : ', pos)
-    // console.log('position localRot  : ', localRot)
     localRot.setX(rx)
     localRot.setY(ry)
     localRot.setZ(rz)
@@ -168,14 +168,12 @@ export default class MatrixAmmo {
     let ms = physicsBody.getMotionState();
     if(ms) {
       var tmpTrans = new Ammo.btTransform();
-
       // quat.setValue(quat.x(), quat.y(), quat.z(), quat.w());
       tmpTrans.setIdentity();
       tmpTrans.setOrigin(pos);
       tmpTrans.setRotation(localRot);
       ms.setWorldTransform(tmpTrans);
     }
-    // console.log('body, ', body)
   }
 
   getBodyByName(name) {
@@ -266,28 +264,68 @@ export default class MatrixAmmo {
   }
 
   updatePhysics() {
-    // Step world
-    this.dynamicsWorld.stepSimulation(1 / 60, 10);
-    // Update rigid bodies
-    var trans = new Ammo.btTransform();
+    if(!Ammo) return;
+    const trans = new Ammo.btTransform();
+    const transform = new Ammo.btTransform();
+
     this.rigidBodies.forEach(function(body) {
-      if(body.getMotionState()) {
+      if(body.isKinematic) {
+        transform.setIdentity();
+        transform.setOrigin(new Ammo.btVector3(
+          body.MEObject.position.x,
+          body.MEObject.position.y,
+          body.MEObject.position.z
+        ));
+        const quat = new Ammo.btQuaternion();
+        quat.setRotation(
+          new Ammo.btVector3(
+            body.MEObject.rotation.axis.x,
+            body.MEObject.rotation.axis.y,
+            body.MEObject.rotation.axis.z
+          ),
+          degToRad(body.MEObject.rotation.angle)
+        );
+        transform.setRotation(quat);
+
+        body.setWorldTransform(transform);
+        const ms = body.getMotionState();
+        if(ms) ms.setWorldTransform(transform);
+      }
+    });
+
+    Ammo.destroy(transform);
+
+    // Step simulation AFTER setting kinematic transforms
+    const timeStep = 1 / 60;
+    const maxSubSteps = 10;
+
+    for(let i = 0;i < this.speedUpSimulation;i++) {
+      this.dynamicsWorld.stepSimulation(timeStep, maxSubSteps);
+    }
+
+    this.rigidBodies.forEach(function(body) {
+      if(!body.isKinematic && body.getMotionState()) {
         body.getMotionState().getWorldTransform(trans);
-        var _x = trans.getOrigin().x().toFixed(2);
-        var _y = trans.getOrigin().y().toFixed(2);
-        var _z = trans.getOrigin().z().toFixed(2);
-        body.MEObject.position.setPosition(_x, _y, _z)
-        var test = trans.getRotation();
-        var testAxis = test.getAxis();
-        test.normalize()
-        body.MEObject.rotation.axis.x = testAxis.x()
-        body.MEObject.rotation.axis.y = testAxis.y()
-        body.MEObject.rotation.axis.z = testAxis.z()
-        body.MEObject.rotation.matrixRotation = quaternion_rotation_matrix(test);
-        body.MEObject.rotation.angle = radToDeg(parseFloat(test.getAngle().toFixed(2)))
+
+        const _x = +trans.getOrigin().x().toFixed(2);
+        const _y = +trans.getOrigin().y().toFixed(2);
+        const _z = +trans.getOrigin().z().toFixed(2);
+
+        body.MEObject.position.setPosition(_x, _y, _z);
+
+        const rot = trans.getRotation();
+        const rotAxis = rot.getAxis();
+        rot.normalize();
+
+        body.MEObject.rotation.axis.x = rotAxis.x();
+        body.MEObject.rotation.axis.y = rotAxis.y();
+        body.MEObject.rotation.axis.z = rotAxis.z();
+        body.MEObject.rotation.matrixRotation = quaternion_rotation_matrix(rot);
+        body.MEObject.rotation.angle = radToDeg(parseFloat(rot.getAngle().toFixed(2)));
       }
-    })
-    // collision detect
-    this.detectCollision()
+    });
+
+    Ammo.destroy(trans);
+    this.detectCollision();
   }
-}
+}

package/src/sounds/sounds.js

@@ -1,14 +1,23 @@
-
 export class MatrixSounds {
 
   constructor() {
     this.volume = 0.5;
     this.audios = {};
+    this.enabled = true; // 🔇 global flag to mute/allow audio
+  }
+
+  muteAll() {
+    this.enabled = false;
+    Object.values(this.audios).forEach(audio => audio.pause());
+  }
+
+  unmuteAll() {
+    this.enabled = true;
   }
 
   createClones(c, name, path) {
-    for(var x = 1;x < c;x++) {
-      let a = new Audio(path);
+    for(let x = 1;x < c;x++) {
+      const a = new Audio(path);
       a.id = name + x;
       a.volume = this.volume;
       this.audios[name + x] = a;
@@ -17,7 +26,7 @@ export class MatrixSounds {
   }
 
   createAudio(name, path, useClones) {
-    let a = new Audio(path);
+    const a = new Audio(path);
     a.id = name;
     a.volume = this.volume;
     this.audios[name] = a;
@@ -28,20 +37,33 @@ export class MatrixSounds {
   }
 
   play(name) {
-    if(this.audios[name].paused == true) {
-      this.audios[name].play()
+    if(!this.enabled) return; // 🔇 prevent playing if muted
+
+    const audio = this.audios[name];
+    if(!audio) return;
+
+    if(audio.paused) {
+      audio.play().catch((e) => {
+        if(e.name !== 'NotAllowedError') console.warn("sounds error:", e);
+      });
     } else {
       this.tryClone(name);
     }
   }
 
   tryClone(name) {
-    var cc = 1;
+    if(!this.enabled) return; // 🔇 prevent playing clones
+
+    let cc = 1;
     try {
-      while(this.audios[name + cc].paused == false) {
+      while(this.audios[name + cc] && this.audios[name + cc].paused === false) {
         cc++;
       }
-      if (this.audios[name + cc]) this.audios[name + cc].play();
-    } catch(err) {}
+      if(this.audios[name + cc]) {
+        this.audios[name + cc].play();
+      }
+    } catch(err) {
+      console.warn("Clone play failed:", err);
+    }
   }
 }