Final push

src/Meshes/transformNode.ts

@@ -47,6 +47,7 @@ export class TransformNode extends Node {
     private _right = new Vector3(1, 0, 0);
     private _rightInverted = new Vector3(-1, 0, 0);
     private _tmpRotation = Quaternion.Zero();
+    private _tmpScaling = Vector3.Zero();
 
     // Properties
     @serializeAsVector3("position")
@@ -173,11 +174,6 @@ export class TransformNode extends Node {
         if (isPure) {
             this.getScene().addTransformNode(this);
         }
-
-        let bind = this._markAsDirty.bind(this);
-        this._position.onUpdateCallback = bind;        
-        this._rotation.onUpdateCallback = bind;
-        this._scaling.onUpdateCallback = bind;
     }
 
     /**
@@ -188,10 +184,6 @@ export class TransformNode extends Node {
         return "TransformNode";
     }
 
-    public _markAsDirty() {
-        this._isDirty = true;
-    }
-
     /**
       * Gets or set the node position (default is (0.0, 0.0, 0.0))
       */
@@ -200,12 +192,8 @@ export class TransformNode extends Node {
     }
 
     public set position(newPosition: Vector3) {
-        this._position.onUpdateCallback = null;
-
         this._position = newPosition;
         this._isDirty = true;
-
-        this._position.onUpdateCallback = this._markAsDirty.bind(this);
     }
 
     /**
@@ -216,14 +204,10 @@ export class TransformNode extends Node {
         return this._rotation;
     }
 
-    public set rotation(newRotation: Vector3) {        
-        this._rotation.onUpdateCallback = null;
-
+    public set rotation(newRotation: Vector3) {
         this._rotation = newRotation;
         this._rotationQuaternion = null;
         this._isDirty = true;
-
-        this._rotation.onUpdateCallback = this._markAsDirty.bind(this);
     }
 
     /**
@@ -234,12 +218,8 @@ export class TransformNode extends Node {
     }
 
     public set scaling(newScaling: Vector3) {
-        this._scaling.onUpdateCallback = null;
-
         this._scaling = newScaling;
         this._isDirty = true;
-        
-        this._scaling.onUpdateCallback = this._markAsDirty.bind(this);
     }
 
     /**
@@ -330,11 +310,17 @@ export class TransformNode extends Node {
             return false;
         }
 
-        // if (this._rotationQuaternion) {
-        //     if (!cache.rotationQuaternion.equals(this._rotationQuaternion)) {
-        //         return false;
-        //     }
-        // } 
+        if (this.position._isDirty) {
+            return false;
+        }
+
+        if (this.scaling._isDirty) {
+            return false;
+        }
+
+        if (this._rotationQuaternion && this._rotationQuaternion._isDirty || this.rotation._isDirty) {
+            return false;
+        }
 
         return true;
     }
@@ -345,7 +331,6 @@ export class TransformNode extends Node {
 
         let cache = this._cache;
         cache.localMatrixUpdated = false;
-       // cache.rotationQuaternion = new Quaternion(0, 0, 0, 0);
         cache.billboardMode = -1;
         cache.infiniteDistance = false;
     }
@@ -1010,19 +995,22 @@ export class TransformNode extends Node {
         }
 
         this._updateCache();
-        // let cache = this._cache;
-        // cache.pivotMatrixUpdated = false;
-        // cache.billboardMode = this.billboardMode;
-        // cache.infiniteDistance = this.infiniteDistance;
+        let cache = this._cache;
+        cache.pivotMatrixUpdated = false;
+        cache.billboardMode = this.billboardMode;
+        cache.infiniteDistance = this.infiniteDistance;
 
         this._currentRenderId = currentRenderId;
         this._childUpdateId++;
         this._isDirty = false;
+        this._position._isDirty = false;
+        this._rotation._isDirty = false;
+        this._scaling._isDirty = false;
         let parent = this._getEffectiveParent();
 
         // Scaling
-        let scaling: Vector3 = this.scaling;
-        let translation: Vector3 = this.position;
+        let scaling: Vector3 = this._tmpScaling;
+        let translation: Vector3 = this._position;
 
         // Translation
         if (this._infiniteDistance) {
@@ -1031,11 +1019,7 @@ export class TransformNode extends Node {
                 var cameraGlobalPosition = new Vector3(cameraWorldMatrix.m[12], cameraWorldMatrix.m[13], cameraWorldMatrix.m[14]);
 
                 translation.copyFromFloats(this._position.x + cameraGlobalPosition.x, this._position.y + cameraGlobalPosition.y, this._position.z + cameraGlobalPosition.z);
-            } else {
-                translation.copyFrom(this._position);
             }
-        } else {
-            translation.copyFrom(this._position);
         }
 
         // Scaling
@@ -1044,6 +1028,7 @@ export class TransformNode extends Node {
         // Rotation
         let rotation: Quaternion = this._tmpRotation;
         if (this._rotationQuaternion) {
+            this._rotationQuaternion._isDirty = false;
             if (this.reIntegrateRotationIntoRotationQuaternion) {
                 var len = this.rotation.lengthSquared();
                 if (len) {

src/XR/features/WebXRAnchorSystem.ts

@@ -152,7 +152,8 @@ export class WebXRAnchorSystem extends WebXRAbstractFeature {
         // convert to XR space (right handed) if needed
         this._populateTmpTransformation(position, rotationQuaternion);
         // the matrix that we'll use
-        const m = new XRRigidTransform({...this._tmpVector}, {...this._tmpQuaternion});
+        const m = new XRRigidTransform({x: this._tmpVector.x, y: this._tmpVector.y, z: this._tmpVector.z},
+                                       {x: this._tmpQuaternion.x, y: this._tmpQuaternion.y, z: this._tmpQuaternion.z, w: this._tmpQuaternion.w});
         if (!hitTestResult.xrHitResult.createAnchor) {
             throw new Error('Anchors not enabled in this browsed. Add "anchors" to optional features');
         } else {
@@ -181,7 +182,8 @@ export class WebXRAnchorSystem extends WebXRAbstractFeature {
         // convert to XR space (right handed) if needed
         this._populateTmpTransformation(position, rotationQuaternion);
         // the matrix that we'll use
-        const xrTransformation = new XRRigidTransform({...this._tmpVector}, {...this._tmpQuaternion});
+        const xrTransformation = new XRRigidTransform({x: this._tmpVector.x, y: this._tmpVector.y, z: this._tmpVector.z},
+                                                      {x: this._tmpQuaternion.x, y: this._tmpQuaternion.y, z: this._tmpQuaternion.z, w: this._tmpQuaternion.w});
         if (forceCreateInCurrentFrame && this.attached && this._xrSessionManager.currentFrame) {
             return this._createAnchorAtTransformation(xrTransformation, this._xrSessionManager.currentFrame);
         } else {

src/XR/webXRCamera.ts

@@ -275,8 +275,8 @@ export class WebXRCamera extends FreeCamera {
             this._xrInvPositionCache.y = 0;
         }
         const transform = new XRRigidTransform(
-            { ...this._xrInvPositionCache },
-            { ...this._xrInvQuaternionCache });
+            { x: this._xrInvPositionCache.x, y: this._xrInvPositionCache.y, z: this._xrInvPositionCache.z },
+            { x: this._xrInvQuaternionCache.x, y: this._xrInvQuaternionCache.y, z: this._xrInvQuaternionCache.z, w: this._xrInvQuaternionCache.w });
         // Update offset reference to use a new originOffset with the teleported
         // player position and orientation.
         // This new offset needs to be applied to the base ref space.
@@ -297,7 +297,7 @@ export class WebXRCamera extends FreeCamera {
             pos.negateInPlace();
 
             const transform2 = new XRRigidTransform(
-                { ...pos });
+                {  x: pos.x, y: pos.y, z: pos.z  });
             // Update offset reference to use a new originOffset with the teleported
             // player position and orientation.
             // This new offset needs to be applied to the base ref space.

tests/unit/babylon/src/Physics/babylon.physicsComponents.tests.ts

@@ -149,7 +149,7 @@ describe('Babylon physicsComponents', () => {
     // now test 'applyImpulse' which is an injected property of AbstractMesh
     describe('applyImpulse should move a mesh', function() {
 
-        it('should move if an impulse is applied', function() {
+        it('if an impulse is applied', function() {
 
             scene.enablePhysics(noGravityVector, physicsPlugin);   // NO gravity
             let getGravity = scene.getPhysicsEngine().gravity;
@@ -158,28 +158,28 @@ describe('Babylon physicsComponents', () => {
             let sphere = BABYLON.MeshBuilder.CreateSphere("mySphere", { diameter: 1 }, scene);  // use MeshBuilder instead of Mesh
             sphere.physicsImpostor = new BABYLON.PhysicsImpostor(sphere, BABYLON.PhysicsImpostor.SphereImpostor, { mass: 1, restitution: 0.9 }, scene);
 
-            let getPosition = sphere.position;
-            expect(getPosition).to.deep.equal(BABYLON.Vector3.Zero());
+            let getPosition = sphere.position.asArray();
+            expect(getPosition).to.deep.equal([0, 0, 0]);
 
-            let linearVelocity = sphere.physicsImpostor.getLinearVelocity();
-            expect(linearVelocity).to.deep.equal(BABYLON.Vector3.Zero());
+            let linearVelocity = sphere.physicsImpostor.getLinearVelocity().asArray();
+            expect(linearVelocity).to.deep.equal([0, 0, 0]);
 
-            let angularVelocity = sphere.physicsImpostor.getAngularVelocity();
-            expect(linearVelocity).to.deep.equal(BABYLON.Vector3.Zero());
+            let angularVelocity = sphere.physicsImpostor.getAngularVelocity().asArray();
+            expect(linearVelocity).to.deep.equal([0, 0, 0]);
 
             //////////////////////////////`/////////////////////
             // so far, so good.  let's run the physics engine.  nothing should change.
 
             scene.animate();
 
-            getPosition = sphere.position;
-            expect(getPosition).to.deep.equal(BABYLON.Vector3.Zero());
+            getPosition = sphere.position.asArray();
+            expect(getPosition).to.deep.equal([0, 0, 0]);
 
-            linearVelocity = sphere.physicsImpostor.getLinearVelocity();
-            expect(linearVelocity).to.deep.equal(BABYLON.Vector3.Zero());
+            linearVelocity = sphere.physicsImpostor.getLinearVelocity().asArray();
+            expect(linearVelocity).to.deep.equal([0, 0, 0]);
 
-            angularVelocity = sphere.physicsImpostor.getAngularVelocity();
-            expect(linearVelocity).to.deep.equal(BABYLON.Vector3.Zero());
+            angularVelocity = sphere.physicsImpostor.getAngularVelocity().asArray();
+            expect(linearVelocity).to.deep.equal([0, 0, 0]);
 
             ///////////////////////////////////////////////////
             // now give an impulse, and run the physics engine again.  the sphere should start moving.
@@ -189,20 +189,20 @@ describe('Babylon physicsComponents', () => {
             sphere.applyImpulse(force, contact);  // give the sphere its kick
             scene.animate();   // and run the physics engine
 
-            getPosition = sphere.position;
-            expect(getPosition.x).to.be.greaterThan(0);   // moved about 0.01, I'm clueless how that was calculated
-            expect(getPosition.y).to.be.equal(0);
-            expect(getPosition.z).to.be.equal(0);
+            var getPosition2 = sphere.position;
+            expect(getPosition2.x).to.be.greaterThan(0);   // moved about 0.01, I'm clueless how that was calculated
+            expect(getPosition2.y).to.be.equal(0);
+            expect(getPosition2.z).to.be.equal(0);
 
-            linearVelocity = sphere.physicsImpostor.getLinearVelocity();
-            expect(linearVelocity.x).to.be.closeTo(10, 0.001);      // mass of 1, whack of 10, sounds right
-            expect(linearVelocity.y).to.be.equal(0);
-            expect(linearVelocity.z).to.be.equal(0);
+            var linearVelocity2 = sphere.physicsImpostor.getLinearVelocity();
+            expect(linearVelocity2.x).to.be.closeTo(10, 0.001);      // mass of 1, whack of 10, sounds right
+            expect(linearVelocity2.y).to.be.equal(0);
+            expect(linearVelocity2.z).to.be.equal(0);
 
             // we whacked it right along the axis, so don't expect any angular velocity
-            angularVelocity = sphere.physicsImpostor.getAngularVelocity()
-            console.log(angularVelocity);
-            expect(angularVelocity).to.deep.equal(BABYLON.Vector3.Zero());
+            var angularVelocity2 = sphere.physicsImpostor.getAngularVelocity()
+            console.log(angularVelocity2);
+            expect(angularVelocity2.asArray()).to.deep.equal([0, 0, 0]);
 
         });
     });