janusweb 1.5.29 → 1.5.33

package/scripts/janusbase.js

@@ -54,6 +54,7 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
         ongazeleave: { type: 'callback' },
         ongazeprogress: { type: 'callback' },
         ongazeactivate: { type: 'callback' },
+        oncollision: { type: 'callback' },
       });
       this.lastframevalues = {
         position: new THREE.Vector3(0,0,0),
@@ -129,7 +130,7 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
       this.removeCollider();
       if (!(this.collidable || this.pickable) || !this.objects['dynamics']) return;
       var collision_id = this.collision_id || this.collider_id;
-      var collision_scale = this.scale.clone();
+      var collision_scale = V().copy(this.scale);
       if (this.collision_scale) {
         collision_scale.multiply(this.collision_scale);
       }
@@ -154,7 +155,7 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
         } else if (collision_id == 'cylinder') {
           this.setCollider('cylinder', {height: 1, radius: .5, offset: new THREE.Vector3(0, 0.5, 0), trigger: this.collision_trigger});
         } else if (collision_id == 'capsule') {
-          this.setCollider('capsule', {height: 1, radius: .5, offset: new THREE.Vector3(0, 0.5, 0), trigger: this.collision_trigger});
+          this.setCollider('capsule', {length: 1, radius: .5, offset: new THREE.Vector3(0, 0, 0), trigger: this.collision_trigger});
         } else {
           var colliderasset = this.getAsset('model', collision_id);
           if (colliderasset) {
@@ -174,24 +175,25 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
               let remove = [];
               collider.traverse(n => {
                 // Ignore collider if it's too high-poly
-                if (n instanceof THREE.Mesh && !((n.geometry instanceof THREE.BufferGeometry && n.geometry.attributes.position.count <= 65536) ||
-                      (n.geometry instanceof THREE.Geometry && n.geometry.vertices.length <= 65536))) {
-                  console.warn('Collider mesh rejected, too many polys!', collision_id, this, n, collider);
-                  elation.events.fire({type: 'thing_collider_rejected', element: this, data: {root: collider, mesh: n}});
-                  remove.push(n);
-                } else {
-                  if (n.material) {
-                    n.material = new THREE.MeshPhongMaterial({
-                      color: collidercolor,
-                      opacity: .2,
-                      transparent: true,
-                      emissive: 0x444400,
-                      alphaTest: .01,
-                      depthTest: false,
-                      depthWrite: false
-                    });
+                if (n instanceof THREE.Mesh && n.geometry instanceof THREE.BufferGeometry) {
+                  if (n.geometry.attributes.position.count > 65536) {
+                    console.warn('Collider mesh rejected, too many polys!', collision_id, this, n, collider);
+                    elation.events.fire({type: 'thing_collider_rejected', element: this, data: {root: collider, mesh: n}});
+                    remove.push(n);
+                  } else {
+                    if (n.material) {
+                      n.material = new THREE.MeshPhongMaterial({
+                        color: collidercolor,
+                        opacity: .2,
+                        transparent: true,
+                        emissive: 0x444400,
+                        alphaTest: .01,
+                        depthTest: false,
+                        depthWrite: false
+                      });
+                    }
+                    n.userData.thing = this;
                   }
-                  n.userData.thing = this;
                 }
               });
               if (remove.length > 0) {
@@ -205,8 +207,12 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
               //this.colliders.add(collider);
               processMeshCollider(collider);
             } else {
+              let meshColliderLoaded = false;
               elation.events.add(collider, 'asset_load', elation.bind(this, function(ev) {
-                processMeshCollider(collider);
+                if (!meshColliderLoaded) {
+                  processMeshCollider(collider);
+                }
+                meshColliderLoaded = true;
               }) );
             }
           }
@@ -286,7 +292,7 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
             }
           } else if (val instanceof THREE.Color) {
             if (defaultval instanceof THREE.Color) defaultval = defaultval.toArray();
-            if (!('default' in propdef) || ('default' in propdef && !(val.r == defaultval[0] && val.g == defaultval[1] && val.b == defaultval[2]))) {
+            if (!('default' in propdef) || defaultval === null || ('default' in propdef && !(val.r == defaultval[0] && val.g == defaultval[1] && val.b == defaultval[2]))) {
               attrs[k] = val.toArray().map(n => Math.round(n * 10000) / 10000).join(' ');
             }
           } else if (val instanceof THREE.Euler) {
@@ -372,6 +378,9 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
           rotate_deg_per_sec:  [ 'property', 'rotate_deg_per_sec'],
           rotate_axis:  [ 'property', 'rotate_axis'],
 
+          anim_id:    ['property', 'anim_id'],
+          anim_transition_time:    ['property', 'anim_transition_time'],
+
           fwd:      ['property', 'zdir'],
           xdir:     ['property', 'xdir'],
           ydir:     ['property', 'ydir'],
@@ -739,7 +748,7 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
           dir = new THREE.Vector3(),
           up = new THREE.Vector3();
       return function(ev) {
-        let parent = this.parent;
+        let parent = this.properties.parent;
         let billboard = this.properties.billboard;
         if (billboard && parent) {
           //player.camera.localToWorld(playerpos.set(0,0,0));
@@ -896,7 +905,7 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
     }
 
     this.createObject = function(type, args, skipstart) {
-      return room.createObject(type, args, this, !this.started);
+      return this.room.createObject(type, args, this, !this.started);
     }
     this.appendChild = function(obj) {
       var proxyobj = obj
@@ -934,8 +943,8 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
           realobj.stop();
           this.remove(realobj);
           this.updateScriptChildren();
-          if (room.objects[obj.js_id]) {
-            delete room.objects[obj.js_id];
+          if (this.room.objects[obj.js_id]) {
+            delete this.room.objects[obj.js_id];
           }
         }
       }
@@ -1009,25 +1018,58 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
     }
     this.updateAnimation = function() {
       // Triggered whenever this.anim_id changes
-      this.setAnimation(this.anim_id);
+      if (this.anim_id) {
+        this.setAnimation(this.anim_id);
+      } else if (this.activeanimation) {
+        this.stopAnimation();
+      }
     }
     this.setAnimation = function(anim_id) {
-      if (!this.activeanimation || anim_id != this.anim_id) {
-        if (!this.animationmixer) return;
+      if (!this.started) return;
+      if (!this.activeanimation || anim_id != this.activeanimation._clip.name) {
+        if (!this.animationmixer) this.extractAnimations(this.objects['3d']);
         if (this.activeanimation) {
           //console.log('pause active animation', this.activeanimation);
           // TODO - interpolating between actions would make transitions smoother
-          this.activeanimation.stop();
+          //this.activeanimation.stop();
+          //this.activeanimation.fadeOut(.5);
+          let oldaction = this.activeanimation;
+          if (!this.fadetimers) this.fadetimers = {};
+          let clipname = oldaction._clip.name;
+          if (!this.fadetimers[clipname]) {
+            // FIXME - for some reason, THREE.AnimationAction.fadeIn() / fadeOut() / etc are just causing the animations to stop, so we'll handle fading ourselves
+            this.fadetimers[clipname] = setInterval(() => {
+              oldaction.weight *= .95;
+              if (oldaction.weight <= .001) {
+                oldaction.weight = 0;
+                oldaction.stop();
+                clearTimeout(this.fadetimers[clipname]);
+                this.fadetimers[clipname] = false;
+              }
+            }, 20);
+          }
         }
-        if (this.animationactions && this.animationactions[anim_id]) {
-          var action = this.animationactions[anim_id];
-          //console.log('found action!', anim_id, action);
+        if (this.animations && this.animations[anim_id]) {
+          var action = this.animations[anim_id];
+          let clipname = action._clip.name;
+          if (this.fadetimers && this.fadetimers[clipname]) {
+            clearTimeout(this.fadetimers[clipname]);
+            this.fadetimers[clipname] = false;
+          }
+          action.weight = 1;
+          action.reset();
           action.play();
           this.activeanimation = action;
         }
         this.anim_id = anim_id;
       }
     }
+    this.stopAnimation = function() {
+      if (this.activeanimation) {
+        this.activeanimation.stop();
+        this.activeanimation = false;
+      }
+    }
     this.dispatchEvent = function(event, target) {
       if (!event.element) event.element = target || this;
       if (!event.target) {
@@ -1315,9 +1357,10 @@ console.log('clone', props);
       }
     }
     this.setRoom = function(newroom, ischild) {
-      if (newroom._target) newroom = newroom._target; // If the proxy object is passed in, use its target instead
+      if (newroom && newroom._target) newroom = newroom._target; // If the proxy object is passed in, use its target instead
 
       if (this.room !== newroom) {
+        let oldroom = this.room;
         if (!ischild) {
           this.stop();
         }
@@ -1327,7 +1370,13 @@ console.log('clone', props);
             this.children[k].setRoom(newroom, true);
           }
         }
-        if (!ischild) {
+        if (newroom && !ischild) {
+          let roomproxy = (newroom._target ? newroom : newroom.getProxyObject()),
+              objproxy = (this._target ? this : this.getProxyObject());
+          if (!roomproxy.contains(objproxy)) {
+            //newroom.add(this);
+            roomproxy.appendChild(objproxy);
+          }
           this.start();
         }
       }

package/scripts/janusghost.js

@@ -1,4 +1,5 @@
 elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
+
   elation.component.add('engine.things.janusghost', function() {
     this.postinit = function() {
       elation.engine.things.janusghost.extendclass.postinit.call(this);
@@ -16,9 +17,29 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
         ghostassets: { type: 'object' },
         auto_play: { type: 'boolean', default: true },
         screen_name: { type: 'string' },
+        animation_extras: { type: 'string' },
+        bone_head: { type: 'string' },
+        morphtarget_mouth: { type: 'string' },
+        morphtarget_eyes: { type: 'string' },
       });
 
       this.frames = false;
+
+      if (!('project_vertex_discard_close' in THREE.ShaderChunk)) {
+        THREE.ShaderChunk['color_fragment_discard_close'] = `
+          #if defined( USE_COLOR_ALPHA )
+            diffuseColor *= vColor;
+          #elif defined( USE_COLOR )
+            diffuseColor.rgb *= vColor;
+          #endif
+          float dist = length(vViewPosition);
+          float mindist = .4;
+          float maxdist = .6;
+          if (dist < maxdist) {
+            diffuseColor.a = clamp(((dist - mindist) / (maxdist - mindist)), 0., 1.);
+          }
+        `;
+      }
     }
     this.createObject3D = function() {
       if (this.ghost_src) {
@@ -114,6 +135,45 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
         console.log(this.ghostassets);
         this.assetpack.loadJSON(assets.assetlist);
       }
+
+      let animnames = []; //'idle', 'walk', 'walk_left', 'walk_right', 'walk_back', 'run', 'jump', 'fly', 'speak', 'type', 'portal'];
+      let animassets = assets.assetlist.filter(asset => animnames.indexOf(asset.name) != -1);
+      console.log('some ghost animations', animassets, assets);
+
+      if (!this.animationmixer) {
+        // Set up our animation mixer with a simple bone mapper for our head.  We'll add more animations to this ass other assets load
+        // TODO - this is probably also where we'd map any other tracked objects (hands, hips, etc). and set up IK
+
+/*
+        let headtrack = new THREE.QuaternionKeyframeTrack('Neck.quaternion', [0], [0, 0, 0, 1]),
+            headclip = new THREE.AnimationClip('head_rotation', -1, [headtrack]);
+        this.headtrack = headtrack;
+
+        this.initAnimations([ headclip ]);
+        //this.animations['head_rotation'].play();
+*/
+        this.initAnimations([]);
+      }
+
+      animassets.forEach(anim => {
+        let asset = this.getAsset('model', anim.name);
+        console.log('try to load the animation', asset, anim);
+        if (asset) {
+          if (!asset.loaded) {
+            let model = asset.getInstance();
+            elation.events.add(asset, 'asset_load', ev => {
+              let clip = false;
+              model.traverse(n => { if (n.animations && n.animations.length > 0) clip = n.animations[0]; });
+              if (clip) {
+                if (this.animationmixer && !this.animations[anim.name]) {
+                  let action = this.animationmixer.clipAction(clip);
+                  this.animations[anim.name] = action;
+                }
+              }
+            });
+          }
+        }
+      });
     }
     this.getGhostObjects = function() {
       var objects = {};
@@ -186,6 +246,8 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
             this.head.appendChild(headid);
             this.face.start();
           }
+          this.head.pos = headpos.clone().multiplyScalar(this.scale.y);
+          this.face.applyPosition(headpos.negate());
           if (this.remotevideo) {
             this.updateVideoScreen();
             this.face.addEventListener('load', (ev) => {
@@ -217,6 +279,11 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
             //rotation: V(0, 180, 0),
             lighting: this.lighting,
             //cull_face: 'none'
+            opacity: 0.9999,
+            renderorder: this.renderorder || 100,
+            shader_chunk_replace: (this.lighting ? {
+              'color_fragment': 'color_fragment_discard_close',
+            } : {}),
           });
         } else {
           this.body = bodyid;
@@ -225,11 +292,169 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
         if (pos) this.body.pos = pos;
         this.body.start();
         if (scale && this.body) this.body.scale.fromArray(scale);
+
+        elation.events.add(this, 'load', ev => {
+          if (this.body.modelasset) {
+            if (this.body.modelasset.loaded) {
+              this.loadAnimations();
+              if (this.animation_extras) {
+                this.loadAnimationExtras();
+              }
+            } else {
+              elation.events.add(this.body.modelasset, 'asset_load_complete', () => {
+                this.loadAnimations();
+                if (this.animation_extras) {
+                  this.loadAnimationExtras();
+                }
+              });
+            }
+          }
+          // FIXME - this prevents avatars from being culled, which prevents our default mesh from disappearing but also means we lose out on possible performance optimizations in rooms with lots of avatars
+          this.objects['3d'].traverse(n => {
+            if (n instanceof THREE.Mesh) {
+              n.frustumCulled = false;
+            }
+          });
+        });
+      }
+    }
+    this.loadAnimations = function(assetid) {
+      if (!assetid) assetid = 'avatar_animations';
+      let animasset = this.getAsset('model', assetid);
+      if (!animasset.loaded) {
+        let animationsLoaded = false;
+        elation.events.add(animasset, 'asset_load_complete', ev => {
+          if (!animationsLoaded) {
+            animationsLoaded = true;
+            if (this.body.animationmixer) {
+              this.cloneAnimations(animasset);
+            }
+            this.body.setAnimation('idle');
+          }
+        });
+        animasset.load();
+      } else {
+        if (this.body.animationmixer) {
+          this.cloneAnimations(animasset);
+        }
+        this.body.setAnimation('idle');
       }
     }
+    this.cloneAnimations = function(animasset) {
+      let animations = animasset.animations;
+      //console.log('clone all the animations', animations, animasset._model);
+      if (this.body) {
+        if (this.bone_head) {
+          this.initHeadAnimation(animasset);
+        }
+
+        animations.forEach(clip => {
+          this.body.animations[clip.name] = this.body.animationmixer.clipAction(this.retargetAnimation(clip, animasset._model));
+          //console.log('new clip', clip.name, clip, this.body.animations[clip.name]);
+        });
+        //console.log('head rot', this.body.animations['head_rotation'], headclip, headaction);
+        //console.log(this.body.modelasset, this.body.modelasset.vrm);
+        if (this.body.modelasset && this.body.modelasset.vrm) {
+          let rename = {};
+          let bonemap = this.body.modelasset.vrm.humanoid.humanBones;
+          for (let k in bonemap) {
+            console.log(k, bonemap[k]);
+            if (bonemap[k].length > 0) {
+              rename[bonemap[k][0].node.name] = k;
+            }
+          }
+          let bones = [];
+          let meshes = [];
+          this.body.objects['3d'].traverse(n => { if (n instanceof THREE.Bone) bones.push(n); else if (n instanceof THREE.SkinnedMesh) meshes.push(n); });
+          /*
+          console.log('rename the bones!', rename);
+          THREE.SkeletonUtils.renameBones(bones, rename);
+          console.log('bones now', bones);
+          */
+          
+        }
+      }
+    }
+    this.retargetAnimation = function(clip, sourcecontainer) {
+      let newclip = clip.clone();
+      let sourcemesh = null,
+          destmesh = null;
+      if (sourcecontainer) {
+        sourcecontainer.traverse(n => { /*console.log(' - ', n); */ if (n instanceof THREE.SkinnedMesh && n.skeleton) sourcemesh = n; });
+      }
+      this.objects['3d'].traverse(n => { if (n instanceof THREE.SkinnedMesh && n.skeleton) destmesh = n; });
+      //console.log('RETARGET ANI*MATION', clip, sourcemesh, destmesh, sourcecontainer);
+      let remove = [];
+      if (this.body && this.body.modelasset && this.body.modelasset.vrm) {
+        let vrm = this.body.modelasset.vrm;
+        //console.log('RETARGET ANI*MATION', clip, this.body.modelasset.vrm, sourcemesh, destmesh);
+        newclip.tracks.forEach(track => {
+          let parts = track.name.split('.');
+          console.log(parts, track.name);
+          try {
+            let bone = vrm.humanoid.getBone(parts[0]);
+            if (bone) {
+              track.name = bone.node.name + '.' + parts[1];
+              let sourcebone = sourcemesh.skeleton.getBone(bone.node.name);
+              //console.log(track, bone);
+            } else {
+              //console.log('no bone!', parts, track);
+            }
+          } catch (e) {
+            console.log('omgwtf', e.message);
+            remove.push(track);
+          }
+        });
+        remove.forEach(track => {
+          let idx = newclip.tracks.indexOf(track);
+          if (idx != -1) {
+            newclip.tracks.splice(idx, 1);
+            //console.log('removed track', track);
+          }
+        });
+      } else if (destmesh && sourcemesh) {
+        // FIXME - silly hack to store skeleton, we should just be extracting it at load time
+        this.body.skeleton = destmesh.skeleton;
+        this.body.objects['3d'].skeleton = destmesh.skeleton;
+        //newclip = THREE.SkeletonUtils.retargetClip(destmesh, sourcemesh, newclip, {useFirstFramePosition: true});
+        //console.log('retarget it!', newclip, destmesh, sourcemesh);
+        newclip.tracks.forEach(track => {
+          let [name, property] = track.name.split('.');
+          let srcbone = sourcemesh.skeleton.getBoneByName(name);
+          let dstbone = destmesh.skeleton.getBoneByName(name);
+          //console.log(' - fix track', name, property, track, srcbone, dstbone);
+          if (dstbone) {
+            let scale = srcbone.position.length() / dstbone.position.length();
+            if (property == 'position') {
+              for (let i = 0; i < track.values.length; i++) {
+                track.values[i] /= scale;
+              }
+              //remove.push(track);
+            } else if (property == 'quaternion') {
+            }
+          } else {
+            //console.log('missing bone!', srcbone, track);
+            remove.push(track);
+          }
+        });
+      }
+      remove.forEach(track => {
+        let idx = newclip.tracks.indexOf(track);
+        if (idx != -1) {
+          newclip.tracks.splice(idx, 1);
+          //console.log('removed track', track);
+        }
+      });
+      //console.log('finished clip', newclip);
+      return newclip;
+    }
     this.rebindAnimations = function() {
       this.body.rebindAnimations();
     }
+    this.loadAnimationExtras = function() {
+      let animids = this.animation_extras.split(' ');
+      animids.forEach(animid => this.loadAnimations(animid));
+    }
 
     this.start = function() {
       elation.engine.things.janusghost.extendclass.start.call(this);
@@ -289,13 +514,16 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
 
             matrix.makeBasis(xdir, ydir, zdir);
             q1.setFromRotationMatrix(matrix);
-            this.head.properties.orientation.copy(this.orientation).inverse().multiply(q1);
+            this.head.properties.orientation.copy(this.orientation).invert().multiply(q1);
+            if (this.body && this.headaction) {
+              this.setHeadOrientation(this.head.orientation);
+            }
             if (movedata.head_pos && this.face) {
               var headpos = this.head.properties.position;
               var facepos = this.face.properties.position;
               var newpos = parser.getVectorValue(movedata.head_pos);
-              headpos.copy(this.head_pos);
-              facepos.fromArray(newpos).sub(headpos);
+              //headpos.copy(this.head_pos);
+              //facepos.fromArray(newpos).sub(headpos);
               if (this.body) {
                 if (this.head.parent != this.body) {
                   this.body.appendChild(this.head);
@@ -357,6 +585,20 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
         if (movedata.userid_pos) {
           this.userid_pos = movedata.userid_pos;
         }
+
+        // FIXME - workaround for null values
+        if (isNaN(this.position.x)) this.position.x = 0;
+        if (isNaN(this.position.y)) this.position.y = 0;
+        if (isNaN(this.position.z)) this.position.z = 0;
+        if (isNaN(this.orientation.x) || isNaN(this.orientation.y) || isNaN(this.orientation.z) || isNaN(this.orientation.w)) this.orientation.set(0,0,0,1);
+
+        if (this.head) {
+          if (isNaN(this.head.position.x)) this.head.position.x = 0;
+          if (isNaN(this.head.position.y)) this.head.position.y = 0;
+          if (isNaN(this.head.position.z)) this.head.position.z = 0;
+          if (isNaN(this.head.orientation.x) || isNaN(this.head.orientation.y) || isNaN(this.head.orientation.z) || isNaN(this.head.orientation.w)) this.head.orientation.set(0,0,0,1);
+        }
+
         this.objects.dynamics.updateState();
         this.refresh();
       }
@@ -391,6 +633,14 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
           this.screen_name = ghostdef.screen_name;
         }
         this.setGhostAssets(things.assets);
+        this.animation_extras = ghostdef.animation_extras;
+        this.bone_head = ghostdef.bone_head;
+        this.morphtarget_mouth = ghostdef.morphtarget_mouth;
+        this.morphtarget_eyes = ghostdef.morphtarget_eyes;
+        this.lighting = elation.utils.any(ghostdef.lighting, true);
+        if (ghostdef.morphtarget_eyes) {
+          this.blink();
+        }
         if (ghostdef.head_id) {
           this.setHead(ghostdef.head_id, headpos, ghostdef.scale);
         }
@@ -431,7 +681,7 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
       }
 
       var inverse = new THREE.Matrix4();
-      inverse.getInverse(this.objects['3d'].matrixWorld);
+      inverse.copy(this.objects['3d'].matrixWorld).invert();
       if (hand0 && hand0.state) {
         this.hands.left.show();
         this.hands.left.setState(hand0.state, inverse);
@@ -460,6 +710,7 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
       } 
     }
     this.updateTransparency = function() {
+return;
       var player = this.engine.client.player;
 
       var dist = player.distanceTo(this);
@@ -478,17 +729,6 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
         m.visible = (opacity > 0);
       });
     }
-    this.setRoom = function(room) {
-      if (room !== this.room) {
-        if (this.room) {
-          this.room.remove(this);
-        }
-        this.room = room;
-        if (room && this.parent != this.room) {
-          room.add(this);
-        }
-      }
-    }
     this.setRemoteVideo = function(video) {
       if (video) {
         this.remotevideo = video;
@@ -540,5 +780,64 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
         });
       }
     }
+    this.setAnimation = function(anim) {
+      if (this.body) this.body.anim_id = anim;
+    }
+    this.initHeadAnimation = function(animasset) {
+      let body = this.body || this._target.body,
+          head = this.head || this._target.head;
+      if (body && this.bone_head &&  !this.headaction) {
+        if (!body.animationmixer) {
+          body.initAnimations([]);
+        }
+        // Set up our animation mixer with a simple bone mapper for our head.  We'll add more animations to this as other assets load
+        // TODO - this is probably also where we'd map any other tracked objects (hands, hips, etc). and set up IK
+
+        let headtrack = new THREE.QuaternionKeyframeTrack(this.bone_head + '.quaternion', [0], [0, 0, 0, 1]),
+            headclip = new THREE.AnimationClip('head_rotation', -1, [headtrack]);
+        let headaction = body.animationmixer.clipAction(this.retargetAnimation(headclip, animasset._model));
+        headaction.weight = 5;
+        this.headaction = headaction;
+        headaction.play();
+      }
+    }
+    this.setHeadOrientation = function(orientation, invert) {
+      let headaction = this.headaction || this._target.headaction;
+      if (headaction && headaction._clip.tracks[0]) {
+        let track = headaction._clip.tracks[0];
+        track.values[0] = orientation.x * (invert ? -1 : 1);
+        track.values[1] = orientation.y * (invert ? -1 : 1);
+        track.values[2] = orientation.z * (invert ? -1 : 1);
+        track.values[3] = orientation.w; // * (invert ? -1 : 1);
+      }
+    }
+    this.blink = function() {
+      if (!this.blinktimer) {
+        if (this.body && this.morphtarget_eyes) {
+          this.body.setMorphTargetInfluence(this.morphtarget_eyes, 1);
+          setTimeout(() => {
+            this.body.setMorphTargetInfluence(this.morphtarget_eyes, 0);
+          }, 100);
+        }
+        this.blinktimer = setTimeout(() => {
+          this.blinktimer = false;
+          this.blink();
+        }, 2500 + Math.random() * 8500);
+      }
+    }
+    this.setSpeakingVolume = function(volume) {
+      if (this.body && this.morphtarget_mouth) {
+        this.body.setMorphTargetInfluence(this.morphtarget_mouth, volume);
+      }
+    }
+    this.getProxyObject = function(classdef) {
+      if (!this._proxyobject) {
+        this._proxyobject = elation.engine.things.janusghost.extendclass.getProxyObject.call(this, classdef);
+        this._proxyobject._proxydefs = {
+          body: [ 'property', 'body'],
+        };
+      }
+      return this._proxyobject;
+    }
   }, elation.engine.things.janusbase);
 });

package/scripts/januslight.js

@@ -18,6 +18,8 @@ elation.require(['janusweb.janusbase'], function() {
         light_shadow_bias: { type: 'float', default: .0001, set: this.updateLight },
         light_shadow_radius: { type: 'float', default: 2.5, set: this.updateLight },
         light_helper: { type: 'boolean', default: false, set: this.updateLightHelper },
+        light_style: { type: 'string', default: '' },
+        light_style_fps: { type: 'float', default: 10 },
         collision_id: { type: 'string', default: 'sphere', set: this.updateCollider },
         collision_trigger: { type: 'boolean', default: true, set: this.updateCollider },
       });
@@ -98,8 +100,14 @@ elation.require(['janusweb.janusbase'], function() {
         this.updateLightTarget();
       }
       if (this.light_directional || this.light_cone_angle == 1) {
-        this.light.position.subVectors(this.light.position, this.light.target.position).add(player.pos);
-        this.light.target.position.copy(player.pos);
+        //this.light.position.subVectors(this.light.position, this.light.target.position).add(player.pos).sub(this.pos);
+        this.light.position.subVectors(this.position, this.light.target.position).normalize().multiplyScalar(this.light_range / 2).add(player.pos).sub(this.pos);
+        this.light.target.position.copy(player.pos).sub(this.pos);
+      }
+      if (this.light_style != '') {
+        let idx = Math.floor(Date.now() / (1000 / this.light_style_fps)) % this.light_style.length;
+        let brightness = (this.light_style.charCodeAt(idx) - 97) / 13;
+        this.light.intensity = .1 * brightness;
       }
     }
     this.createLight = function() {
@@ -127,6 +135,7 @@ elation.require(['janusweb.janusbase'], function() {
         //this.light.intensity = this.light_intensity / 100;
         var avgscale = (this.scale.x + this.scale.y + this.scale.z) / 3;
         //this.light.intensity = this.light_intensity / 100;
+        let brightness = 1;
         this.light.intensity = .1;
         this.light.penumbra = this.light_penumbra;
         this.light.decay = this.light_decay;