next

public/vwf/model/aframe.js

@@ -373,6 +373,11 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
                         this.state.setAFrameProperty('scale', propertyValue, aframeObject);
                             break;
 
+
+                        case "animationTimeUpdated":
+                                node.storedTransformDirty = true; 
+                        break;
+
                         case "clickable":
                             if (propertyValue) {
                                 aframeObject.setAttribute('class', 'intersectable');

public/vwf/model/aframe/addon/aframe-interpolation.js

@@ -44,6 +44,12 @@ AFRAME.registerComponent('interpolation', {
    */
   tick: function (t, dt) {
 
+
+    var now = performance.now();
+    var timepassed = now - this.lastTime;
+
+    //console.log(timepassed);
+
     if (!this.node) {
       let interNode = Object.entries(this.driver.state.nodes).find(el => 
         el[1].parentID == this.el.id && el[1].extendsID == "http://vwf.example.com/aframe/interpolation-component.vwf"
@@ -53,17 +59,29 @@ AFRAME.registerComponent('interpolation', {
     }
 
     if (this.enabled && this.node && this.node.interpolate) {
-
-      this.setInterpolatedTransforms(dt);
-      this.restoreTransforms();
+      this.setInterpolatedTransforms(timepassed);
+      //this.restoreTransforms();
 
     }
+    this.lastTime = now;
+
+    
 
   },
 
+  matCmp: function (a,b,delta) {
+    for(var i =0; i < 2; i++) {
+        if(Math.abs(a[i] - b[i]) > delta)
+            return false;
+    }
+    
+    return true;
+},
+
   vecCmp: function (a, b, delta) {
 
-    let distance = a.distanceTo(b);
+   // let distance = a.distanceTo(b);
+   let distance = goog.vec.Vec3.distance(a,b);
     if (distance > delta) {
       return false;
     }
@@ -73,15 +91,26 @@ AFRAME.registerComponent('interpolation', {
 
   restoreTransforms: function () {
 
-    let r = new THREE.Vector3();
-    let rot = r.copy(this.node.interpolate.position.selfTick);
+    var now = this.node.interpolate.position.selfTick;
 
-    if (rot && this.node.needTransformRestore) {
-      this.el.object3D.position.set(rot.x, rot.y, rot.z)
+    if (now && this.node.needTransformRestore) {
+      let pos = goog.vec.Vec3.clone(now);
+      this.el.object3D.position.set(pos[0], pos[1], pos[2]);
       this.node.needTransformRestore = false;
     }
 
 
+
+
+    // let r = new THREE.Vector3();
+    // let rot = r.copy(this.node.interpolate.position.selfTick);
+
+    // if (rot && this.node.needTransformRestore) {
+    //   this.el.object3D.position.set(rot.x, rot.y, rot.z)
+    //   this.node.needTransformRestore = false;
+    // }
+
+
     // let r = new THREE.Euler();
     // let rot = r.copy(this.node.interpolate.rotation.selfTick);
 
@@ -94,10 +123,10 @@ AFRAME.registerComponent('interpolation', {
 
   setInterpolatedTransforms: function (deltaTime) {
 
-    var step = (this.driver.tickTime) / (this.driver.realTickDif);
+    var step = (this.node.tickTime) / (this.node.realTickDif);
     step = Math.min(step, 1);
-    deltaTime = Math.min(deltaTime, this.driver.realTickDif)
-    this.driver.tickTime += deltaTime || 0;
+    deltaTime = Math.min(deltaTime, this.node.realTickDif)
+    this.node.tickTime += deltaTime || 0;
 
     this.interpolatePosition(step);
     //this.interpolateRotation(step);
@@ -152,21 +181,38 @@ AFRAME.registerComponent('interpolation', {
 
     if (last && now) {
 
-      let comp = this.vecCmp(last, now, this.deltaPos);
+      let comp = this.matCmp(last, now, this.deltaPos);
 
       if (!comp) {
 
-        var lastV = (new THREE.Vector3()).copy(last);
-        var nowV = (new THREE.Vector3()).copy(now);
+       var interp = goog.vec.Vec3.lerp(
+          last, now,
+          step || 0,
+          goog.vec.Vec3.create()
+        );
+
+
+        // var lastV = (new THREE.Vector3()).copy(last);
+        // var nowV = (new THREE.Vector3()).copy(now);
+
+        // var interp = lastV.lerp(nowV, step || 0);
 
-        var interp = lastV.lerp(nowV, step || 0);
         //this.el.setAttribute('position',interp);
 
-        this.el.object3D.position.set(interp.x, interp.y, interp.z);
+        //this.el.object3D.position.set(interp.x, interp.y, interp.z);
+       
+        this.setTransform(interp);
+        
         this.node.needTransformRestore = true;
       }
     }
   },
+
+  setTransform: function (vec) {
+    let interp = goog.vec.Vec3.clone(vec);
+    this.el.object3D.position.set(interp[0], interp[1], interp[2]);
+},
+
   pause: function () { },
   play: function () { }
 });

public/vwf/view/aframeComponent.js

@@ -206,21 +206,31 @@ define(["module", "vwf/view"], function (module, view) {
     });
 
     function lerpTick () {
-        var now = performance.now();
-        self.realTickDif = now - self.lastRealTick;
+        // var now = performance.now();
+        // self.realTickDif = now - self.lastRealTick;
 
-        self.lastRealTick = now;
+        // self.lastRealTick = now;
  
         //reset - loading can cause us to get behind and always but up against the max prediction value
-        self.tickTime = 0;
+       // self.tickTime = 0;
 
        let interNodes = Object.entries(self.nodes).filter(node => 
         node[1].extends == 'http://vwf.example.com/aframe/interpolation-component.vwf');
 
        interNodes.forEach(node => {
            let nodeID = node[0];
-        if ( self.state.nodes[nodeID] ) {      
-           // self.nodes[nodeID].tickTime = 0;
+        if ( self.state.nodes[nodeID] ) {    
+            
+            if(!self.nodes[nodeID].lastRealTick)
+                self.nodes[nodeID].lastRealTick = performance.now();
+
+            var now = performance.now();
+            self.nodes[nodeID].realTickDif = now - self.nodes[nodeID].lastRealTick;
+            self.nodes[nodeID].lastRealTick = now;
+     
+            self.nodes[nodeID].tickTime = 0;
+            //console.log(self.nodes[nodeID].realTickDif);
+
             if(!self.nodes[nodeID].interpolate)
             {
                 self.nodes[nodeID].interpolate = {
@@ -260,8 +270,12 @@ define(["module", "vwf/view"], function (module, view) {
     }
 
     function getPosition(id) {
-        let p = new THREE.Vector3();
-        let pos = p.copy(self.state.nodes[id].aframeObj.el.object3D.position);
+        // let p = new THREE.Vector3();
+        // let pos = p.copy(self.state.nodes[id].aframeObj.el.object3D.position);
+        let p = self.state.nodes[id].aframeObj.el.object3D.position;
+        let pos =  goog.vec.Vec3.createFromValues(p.x, p.y, p.z)
+
+
         //let pos = self.state.nodes[id].aframeObj.el.getAttribute('position');
         //let interp = (new THREE.Vector3()).fromArray(Object.values(pos))//goog.vec.Mat4.clone(self.state.nodes[id].threeObject.matrix.elements);