finetune

doc/RFC_XR_Fragments.md

@@ -223,8 +223,8 @@ These are automatic fragment-to-metadata mappings, which only trigger if the 3D
 | `#<cameraname>`              | string   | `#cam01`          | set camera as active camera                                             |
 | `#<objectname_with_src=x,x,x`| vector3  | `#person=1,1,0`   | play src-metadata of object `person` using `#t=` timeline-value (see #t)|
 | `#<animname>=x,x,x`          | vector3  | `#myanim=1,1,0`   | play (non-global) animation ID                                          |
-| `#<materialname>=<x,x,x|objectname>`| string  | `horizon=fader`   | animate r/g/b/o(pacity) of material `horizon` with `fader` obj (xyzw=rgbo) |
-| `#<texturename>=<x,x,x|objectname>`| string   | `page=scroller`   | animate x/y/r(otation) of texture `page` with `scroller` object (xyz=xyr) |
+| `#<materialname>=<x,x,x|animationname>`| string  | `horizon=fader`   | animate o(pacity) of material `horizon` with `fader` obj (xyzw=o...) |
+| `#<texturename>=<x,x,x|animationname>`| string   | `page=scroller`   | animate x/y/r(otation) of texture `page` with `scroller` object (xyz=xyr) |
 | `#<varname>=<x,x,x|string>`   | string|vector3  | `myvar=fader`     | set/animate shaderuniform- or scene-specific vars with `fader` object (*) |
 
 # Spatial Referencing 3D 

src/3rd/js/pubsub.js

@@ -23,17 +23,13 @@ xrf.addEventListener = function(eventName, callback, scene) {
   if( scene ) callback.scene = scene
   // add the callback to the listeners array for this event name
   this._listeners[eventName].push(callback);
+  return () => {
+    console.log("size = "+this._listeners[eventName].length)
+    this._listeners[eventName] = this._listeners[eventName].filter( (c) => c != callback )
+    console.log("size = "+this._listeners[eventName].length)
+  }
 };
 
-xrf.removeEventListeners = function( everything ){
-  if( everything ) this._listeners = []
-  else{
-    for( let eventName in this._listener ){
-      this._listener[eventName] = this._listener[eventName].filter( (e) => e.callback ? null : e )
-    } 
-  }
-}
-
 xrf.emit = function(eventName, data){
   if( typeof data != 'object' ) throw 'emit() requires passing objects'
   return xrf.emit.promise(eventName,data)

src/3rd/js/three/index.js

@@ -19,7 +19,9 @@ xrf.patchRenderer = function(renderer){
   renderer.xr.addEventListener( 'sessionstart', () => xrf.baseReferenceSpace = renderer.xr.getReferenceSpace() );
   renderer.xr.enabled = true;
   renderer.render = ((render) => function(scene,camera){
+    // update clock
     let time = xrf.model && xrf.model.clock ? xrf.model.clock.getDelta() : 0
+    // allow entities to do stuff during render (onBeforeRender and onAfterRender don't always fire)
     xrf.emit('render',{scene,camera,time}) // allow fragments to do something at renderframe
     render(scene,camera)
   })(renderer.render.bind(renderer))
@@ -46,7 +48,14 @@ xrf.parseModel = function(model,url){
   let file               = xrf.getFile(url)
   model.file             = file
   // eval embedded XR fragments
-  model.scene.traverse( (mesh) => xrf.hashbus.pub.mesh(mesh,model) )
+  model.scene.traverse( (mesh) => {
+    xrf.hashbus.pub.mesh(mesh,model) 
+    let obj = [ `'${mesh.name}'` ]
+    if( mesh.material ) obj.push([`material:'${mesh.material.name}'`])
+    if( mesh.material && mesh.material.map ) obj.push([`texture: '${mesh.material.map.name}'`])
+    console.log("obj "+obj.join(" ") )
+  })
+  model.animations.map( (a) => console.log("anim: "+a.name) )
   xrf.emit('parseModel',{model,url,file})
 }
 

src/3rd/js/three/xrf/dynamic/texture.js

@@ -1,26 +1,30 @@
 xrf.addEventListener('dynamicKeyValue', (opts) => {
   let {scene,match,v} = opts
   let texture = v.fragment
+  let found = false
   scene.traverse( (mesh) => {
-    if( mesh.material){
+    if( mesh.material && !found ){
       if( mesh.material.map && mesh.material.map.name == texture ){
+        found = true
         let mat = mesh.material
-        delete mesh.onBeforeRender
-        delete mesh.driver
+        // remove render listener if any
+        if( mesh.material.map.removeListener ) mesh.material.map.removeListener()
+
         if( v.x != undefined ){
+          delete mesh.onBeforeRender
           mat.map.offset.x = v.x
           mat.map.offset.y = v.y
           mat.map.rotation = v.z
         }else{
-          mesh.driver = xrf.scene.getObjectByName(v.string)
+          mesh.driver = xrf.model.animations.find( (a) => a.name == v.string )
           if( !mesh.driver ) return 
-          mesh.onBeforeRender = function(){
-            let model = xrf.model
-            if( !model || !model.clock ) return
-            this.material.map.offset.x = this.driver.position.x
-            this.material.map.offset.y = this.driver.position.y
-            this.material.map.rotation = this.driver.position.z
+          let everyFrame = (mesh) => () => {
+            let value = mesh.driver.action._propertyBindings[0].binding.resolvedProperty
+            mesh.material.map.offset.x = value.x
+            mesh.material.map.offset.y = value.y
+            mesh.material.map.rotation = value.z
           }
+          mesh.material.map.removeListener = xrf.addEventListener('render', everyFrame(mesh) )
         }
       }
     }

src/3rd/js/three/xrf/t.js

@@ -14,22 +14,24 @@ xrf.frag.t = function(v, opts){
     mixer.setTime(time)
     mixer.time = Math.abs(mixer.time)
     mixer.update(0)      // (forgetting) this little buddy costed me lots of time :]
-    xrf.model.animations.map( (anim) => { 
-      anim.action.setLoop( v.z == 0 ? THREE.LoopOnce : THREE.LoopRepeat)
-    })
   }
 
   // play animations
   mixer.play( v.x == 1 )
 
   if( v.y > 0 || v.z > 0 ) updateTime( mixer.loop.timeStart )
+  if( v.y > 0 && v.z > 0 ){
+    xrf.model.animations.map( (anim) => { 
+      anim.action.setLoop( v.z == 0 ? THREE.LoopOnce : THREE.LoopRepeat, v.z == 0 ? 0 : 99999999)
+    })
+  }
 
   // update loop when needed 
   if( !mixer.update.patched ){
     let update = mixer.update
     mixer.update = function(time){
       mixer.time = Math.abs(mixer.time)
-      if( time == 0 ) return update.call(mixer,time)
+      if( time == 0 ) return update.call(this,time)
 
       if( mixer.loop.speed > 0.0 && mixer.time > mixer.loop.timeStop * mixer.loop.speedAbs ){ 
         setTimeout( (time) => updateTime(time),0,mixer.loop.timeStart) // prevent recursion