tick/tock

public/vwf/model/aframe.js

@@ -357,9 +357,9 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
 
                         case "position":
 
-                        var position = goog.vec.Vec3.createFromArray( propertyValue || [] );
-                            node.transform.position = position;
-                            value = propertyValue;
+                        var position = translationFromValue(propertyValue || []); //goog.vec.Vec3.createFromArray( propertyValue || [] );
+                            node.transform.position = goog.vec.Vec3.clone(position);
+                            //value = propertyValue;
                             node.storedTransformDirty = true; 
                             //setTransformsDirty( threeObject );
                             //this.state.setAFrameProperty('position', propertyValue, aframeObject);
@@ -839,12 +839,15 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
                             //     value = pos//[pos.x, pos.y, pos.z]//AFRAME.utils.coordinates.stringify(pos);
                             // }
 
+                            if (node.transform.position) {
+
                             if ( node.storedTransformDirty ) {
                                 updateStoredTransform( node );
                             }
 
-                            //value = goog.vec.Vec3.clone(node.transform.position);
-                            value =  node.transform.position;
+                            value = goog.vec.Vec3.clone(node.transform.position);
+                            //value =  node.transform.position;
+                        }
                             break;
 
                         case "scale":
@@ -1337,6 +1340,21 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
     }
 
 
+    function translationFromValue ( propertyValue ) {
+
+        var value = goog.vec.Vec3.create();
+      if (propertyValue.hasOwnProperty('x')) {
+          value = goog.vec.Vec3.createFromValues(propertyValue.x, propertyValue.y,  propertyValue.z)
+      } 
+      else if (Array.isArray(propertyValue) || propertyValue instanceof Float32Array ) {
+          value = goog.vec.Vec3.createFromArray(propertyValue);}
+      else if (typeof propertyValue === 'string') {
+          let val = AFRAME.utils.coordinates.parse(propertyValue);
+          value = goog.vec.Vec3.createFromValues(val.x, val.y, val.z)
+          }
+  
+      return value
+        }
 
     function updateStoredTransform( node ) {
         
@@ -1346,7 +1364,8 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
             // didn't need to load a model
             node.transform = {};
 
-            let pos = node.aframeObj.object3D.position;
+            //let pos = node.aframeObj.object3D.position;
+            let pos = (new THREE.Vector3()).copy(node.aframeObj.object3D.position);
             node.transform.position = goog.vec.Vec3.createFromValues(pos.x, pos.y, pos.z);
 
             //node.transform.position = AFRAME.utils.coordinates.stringify(node.aframeObj.object3D.position);

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

@@ -69,6 +69,15 @@ AFRAME.registerComponent('interpolation', {
 
   },
 
+  tock: function(t, dt){
+    if (this.node) {
+      if (this.enabled && this.node.interpolate) {
+        this.restoreTransforms();
+      }
+
+    }
+  },
+
   matCmp: function (a,b,delta) {
     for(var i =0; i < 2; i++) {
         if(Math.abs(a[i] - b[i]) > delta)
@@ -125,12 +134,18 @@ AFRAME.registerComponent('interpolation', {
 
     var step = (this.node.tickTime) / (this.node.realTickDif);
     step = Math.min(step, 1);
+    //step = Math.min(1, .2 * (deltaTime / 16.6)) //Math.min(step, 1);
     deltaTime = Math.min(deltaTime, this.node.realTickDif)
     this.node.tickTime += deltaTime || 0;
 
+    
     this.interpolatePosition(step);
     //this.interpolateRotation(step);
 
+    // if (this.node.tickTime == 0){
+    //   this.restoreTransforms();
+    // }
+
   },
   radians: function (degrees) {
     // return degrees * Math.PI / 180.0;
@@ -191,6 +206,8 @@ AFRAME.registerComponent('interpolation', {
           goog.vec.Vec3.create()
         );
 
+        console.log(this.node.id);
+        console.log(step + ' : ' + interp);
 
         // var lastV = (new THREE.Vector3()).copy(last);
         // var nowV = (new THREE.Vector3()).copy(now);
@@ -208,9 +225,9 @@ AFRAME.registerComponent('interpolation', {
     }
   },
 
-  setTransform: function (vec) {
-    let interp = goog.vec.Vec3.clone(vec);
-    this.el.object3D.position.set(interp[0], interp[1], interp[2]);
+  setTransform: function (interp) {
+    let vec = goog.vec.Vec3.clone(interp);
+    this.el.object3D.position.set(vec[0], vec[1], vec[2]);
 },
 
   pause: function () { },

public/vwf/view/aframe.js

@@ -488,7 +488,10 @@ define(["module", "vwf/view"], function (module, view) {
             node.ignoreNextTransformUpdate = false;
         } else {
            // adoptTransform( node, transformMatrix );
-           setAFrameProperty ('position', propertyValue, node.aframeObj)
+           var pos = goog.vec.Vec3.clone( propertyValue );
+           node.aframeObj.object3D.position.set(pos[0], pos[1], pos[2]);
+           
+           //setAFrameProperty ('position', propertyValue, node.aframeObj)
         }
 
 

public/vwf/view/aframeComponent.js

@@ -146,6 +146,12 @@ define(["module", "vwf/view"], function (module, view) {
 
         },
 
+        tocked: function (vwfTime) {
+
+           // lerpTock ();
+
+        },
+
 
         gotProperty: function (nodeId, propertyName, propertyValue) {
             var selfs = this;
@@ -205,6 +211,35 @@ define(["module", "vwf/view"], function (module, view) {
 
     });
 
+    function lerpTock () {
+
+       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] ) {    
+
+            if(self.nodes[nodeID].interpolate)
+            {
+                let positionModel = self.nodes[nodeID].interpolate.positionModel;
+
+                if (positionModel) {
+                    let currentPosition = getPosition(nodeID);
+                    if ( !goog.vec.Vec3.equals( currentPosition, positionModel) ){
+                        self.state.nodes[nodeID].aframeObj.el.object3D.position.set(positionModel[0], positionModel[1], positionModel[2]);
+                        
+                    }
+                }
+               
+            }
+
+        }
+       })
+
+    }
+
+
     function lerpTick () {
         // var now = performance.now();
         // self.realTickDif = now - self.lastRealTick;
@@ -238,6 +273,7 @@ define(["module", "vwf/view"], function (module, view) {
                     'rotation': {}
                 }
             }
+
             self.nodes[nodeID].interpolate.position.lastTick = (self.nodes[nodeID].interpolate.position.selfTick);
             self.nodes[nodeID].interpolate.position.selfTick = getPosition(nodeID);
 
@@ -272,7 +308,7 @@ 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 = self.state.nodes[id].aframeObj.el.object3D.position;
+        let p = (new THREE.Vector3()).copy(self.state.nodes[id].aframeObj.el.object3D.position);
         let pos =  goog.vec.Vec3.createFromValues(p.x, p.y, p.z)