janusweb 1.5.41 → 1.5.43

package/media/lib/three-icosa/brushes/Wire-4391385a-cf83-4396-9e33-31e4e4930b27/Wire-4391385a-cf83-4396-9e33-31e4e4930b27-v10.0-vertex.glsl

@@ -0,0 +1,60 @@
+#version 300 es
+// Copyright 2020 The Tilt Brush Authors
+// Updated to OpenGL ES 3.0 by the Icosa Gallery Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Copyright 2020 The Tilt Brush Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// DefaultVS.glsl
+in vec4 a_position;
+in vec3 a_normal;
+in vec4 a_color;
+in vec2 a_texcoord0;
+
+out vec4 v_color;
+out vec3 v_normal;  // Camera-space normal.
+out vec3 v_position;  // Camera-space position.
+out vec2 v_texcoord0;
+out vec3 v_light_dir_0;  // Camera-space light direction, main light.
+out vec3 v_light_dir_1;  // Camera-space light direction, other light.
+out float f_fog_coord;
+
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+uniform mat3 normalMatrix;
+uniform mat4 u_SceneLight_0_matrix;
+uniform mat4 u_SceneLight_1_matrix;
+
+void main() {
+  gl_Position = projectionMatrix * modelViewMatrix * a_position;
+  f_fog_coord = gl_Position.z;
+  v_normal = normalMatrix * a_normal;
+  v_position = (modelViewMatrix * a_position).xyz;
+  v_light_dir_0 = mat3(u_SceneLight_0_matrix) * vec3(0, 0, 1);
+  v_light_dir_1 = mat3(u_SceneLight_1_matrix) * vec3(0, 0, 1);
+  v_color = a_color;
+  v_texcoord0 = a_texcoord0;
+}

package/media/manifest.json

@@ -5,7 +5,7 @@
   "theme_color": "#2f363b",
   "lang": "en-US",
   "orientation": "any",
-  "start_url": "https://web.janusxr.org/",
+  "start_url": "index.html",
   "description": "Webpages become 3D spaces interconnected by portals.  Explore, collaborate and build, with or without a headset.",
   "ovr_package_name": "web.JanusXR.org",
   "icons": [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "janusweb",
   "description": "Web client for JanusVR worlds",
-  "version": "1.5.41",
+  "version": "1.5.43",
   "main": "scripts/janusweb.js",
   "author": "James Baicoianu",
   "license": "MIT",
@@ -18,7 +18,7 @@
     "url": "https://github.com/jbaicoianu/janusweb"
   },
   "dependencies": {
-    "elation-engine": ">=0.9.73",
+    "elation-engine": ">=0.9.114",
     "uglify-es": "*"
   },
   "keywords": [

package/scripts/client.js

@@ -1,4 +1,4 @@
-elation.require(['elements.elements', 'elements', 'engine.engine', 'engine.assets', 'engine.things.light_ambient', 'engine.things.light_directional', 'engine.things.light_point', 'janusweb.janusweb', 'janusweb.chat', 'janusweb.janusplayer', 'janusweb.janusxrplayer', 'janusweb.external.document-register-element', 'janusweb.ui.main', 'elements.elements'], function() {
+elation.require(['elements.elements', 'elements', 'engine.engine', 'engine.assets', 'engine.things.light_ambient', 'engine.things.light_directional', 'engine.things.light_point', 'janusweb.janusweb', 'janusweb.janusplayer', 'janusweb.janusxrplayer', 'janusweb.ui.main'], function() {
   // If getCurrentScript returns non-null here, then it means we're in release mode
   var clientScript = elation.utils.getCurrentScript();
 
@@ -47,8 +47,12 @@ elation.require(['elements.elements', 'elements', 'engine.engine', 'engine.asset
     }
     elation.config.set('dependencies.path', fullpath);
 
-    var usetracking = elation.utils.any(args.tracking, elation.config.get('janusweb.tracking.enabled'), false);
+    var usetracking = elation.utils.any(args.tracking, elation.config.get('janusweb.tracking.enabled'), false),
+        trackingid = elation.utils.any(args.trackingid, elation.config.get('janusweb.tracking.clientid'), '');
     if (usetracking && usetracking != 'false') {
+      elation.config.set('janusweb.tracking.enabled', true);
+      elation.config.set('janusweb.tracking.clientid', trackingid);
+
       var tracking = elation.janusweb.tracking({});
     }
     var link = document.createElement('link');
@@ -76,6 +80,7 @@ elation.require(['elements.elements', 'elements', 'engine.engine', 'engine.asset
       useWebVRPolyfill: args.useWebVRPolyfill,
       server: args.server,
       tracking: usetracking,
+      trackingid: trackingid,
       avatarsrc: args.avatarsrc,
     });
     return new Promise(function(resolve, reject) {
@@ -191,6 +196,7 @@ elation.require(['elements.elements', 'elements', 'engine.engine', 'engine.asset
 
       elation.engine.assets.initTextureLoaders(this.engine.systems.render, elation.config.get('janusweb.datapath') + 'lib/basis/');
       elation.engine.assets.setDracoPath(elation.config.get('janusweb.datapath') + 'lib/draco/');
+      elation.engine.assets.icosapath = elation.config.get('janusweb.datapath') + 'lib/three-icosa/brushes/';
     }
     createUI() {
       if (!this.ui) {
@@ -305,7 +311,8 @@ elation.require(['elements.elements', 'elements', 'engine.engine', 'engine.asset
           homepage: { type: 'string' },
           width: { type: 'integer', default: 640 },
           height: { type: 'integer', default: 480 },
-          tracking: { type: 'boolean', default: true },
+          tracking: { type: 'boolean', default: false },
+          trackingid: { type: 'string'  },
           networking: { type: 'boolean', default: true },
           avatarsrc: { type: 'string', default: false },
           uiconfig: { type: 'string', default: false },
@@ -333,6 +340,7 @@ elation.require(['elements.elements', 'elements', 'engine.engine', 'engine.asset
           url: this.getRoomURL(),
           homepage: this.homepage || this.src,
           tracking: this.tracking,
+          trackingid: this.trackingid,
           networking: this.networking,
           corsproxy: this.corsproxy,
           //resolution: width + 'x' + height,
@@ -456,11 +464,20 @@ elation.require(['elements.elements', 'elements', 'engine.engine', 'engine.asset
       }
       show() {
         super.show();
+        if (this.oldparent && !this.parentNode) {
+          this.oldparent.appendChild(this);
+        }
         elation.events.fire({type: 'overlay_show', element: this});
       }
       hide() {
         super.hide();
         elation.events.fire({type: 'overlay_hide', element: this});
+        setTimeout(() => {
+          if (this.parentNode) {
+            this.oldparent = this.parentNode;
+            this.parentNode.removeChild(this);
+          }
+        }, 1000);
       }
     });
   }

package/scripts/elements/outliner.js

@@ -0,0 +1,182 @@
+elation.require(['janusweb.janusbase'], function() {
+  elation.component.add('janusweb.elements.outliner', {
+    create() {
+      this.defineProperties({
+        'target': { type: 'string', set: this.updateTarget },
+        'outline': { type: 'float', default: 2, set: this.updateOutlineSize },
+      });
+      this.meshes = [];
+      this.skinnedmeshes = [];
+      // Shader used to outline the selected object.  Based on https://www.videopoetics.com/tutorials/pixel-perfect-outline-shaders-unity/
+      // Thanks to @donrmccurdy for the example of how to include skinning in a custom shader https://github.com/mrdoob/three.js/issues/4800#issuecomment-580901344
+      this.outlinematerial = new THREE.ShaderMaterial({
+        vertexShader: `
+            uniform float offset;
+            uniform vec2 screenSize;
+
+            ${THREE.ShaderChunk.skinning_pars_vertex}
+
+            void main() {
+                mat4 modelViewProjectionMatrix = projectionMatrix * modelViewMatrix;
+
+                // If USE_SKINNING is set, this will transform our vertices by any skinned mesh attributes
+                // Otherwise, it'll just use our regular vertex positions
+                ${THREE.ShaderChunk.beginnormal_vertex}
+                ${THREE.ShaderChunk.skinbase_vertex}
+                ${THREE.ShaderChunk.skinnormal_vertex}
+                vec3 transformed = vec3( position );
+                ${THREE.ShaderChunk.skinning_vertex}
+
+                // Transform our new vertex position into clip space
+                vec4 pos = modelViewProjectionMatrix * vec4(transformed, 1.0);
+
+                // Offset our vertices along the normal direction, scaled to the specified pixel offset in screen space
+                vec3 clipNormal = mat3(projectionMatrix) * (mat3(modelViewMatrix) * normal);
+                pos.xy += normalize(clipNormal.xy) / screenSize * offset * pos.w * 2.0;
+                gl_Position = pos;
+            }
+        `,
+
+        fragmentShader: `
+            uniform vec3 color;
+            uniform float opacity;
+            void main(){
+                gl_FragColor = vec4( color, opacity );
+            }
+        `,
+
+        uniforms: {
+          offset: { type: "f", value: this.outline },
+          color: { value: this.col},
+          opacity: { value: this.opacity },
+          screenSize: { type: 'v2', value: new THREE.Vector2(window.innerWidth, window.innerHeight) },
+        },
+      });
+      this.col = '#00ff00';
+      this.outlinematerial.transparent = true;
+      this.outlinematerial.uniforms.color.value = this.col;
+      this.outlinematerial.depthWrite = false;
+      this.outlinematerial.side = THREE.BackSide;
+      //this.outlinematerial.blending = THREE.AdditiveBlending;
+
+      if (this.target) {
+        this.updateTarget();
+      } else {
+        setTimeout(() => {
+          this.select(this.children[0]);
+        }, 50);
+      }
+    },
+    select(object) {
+      this.selected = object;
+      let objmeshes = [], skinnedmeshes = [];
+      object.traverseObjects(n => {
+        if (n instanceof THREE.Mesh && n.material !== this.outlinematerial) {
+          if (n.isSkinnedMesh)
+            skinnedmeshes.push(n);
+          else
+            objmeshes.push(n);
+        }
+      });
+      // Create and update regular Meshes
+      let meshIdx = 0;
+      for (; meshIdx < objmeshes.length; meshIdx++) {
+        let n = objmeshes[meshIdx],
+            m = this.getMesh(n, this.meshes[meshIdx]);
+        this.meshes[meshIdx] = m;
+        n.parent.add(m);
+      }
+      // Hide all unused Meshes
+      if (meshIdx < this.meshes.length) {
+        for (; meshIdx < this.meshes.length; meshIdx++) {
+          this.meshes[meshIdx].geometry = null;
+          if (this.meshes[meshIdx].parent) {
+            this.meshes[meshIdx].parent.remove(this.meshes[meshIdx]);
+          }
+        }
+      }
+      // Create and update SkinnedMeshes
+      let skinnedMeshIdx = 0;
+      for (; skinnedMeshIdx < skinnedmeshes.length; skinnedMeshIdx++) {
+        let n = skinnedmeshes[skinnedMeshIdx],
+            m = this.getSkinnedMesh(n, this.skinnedmeshes[skinnedMeshIdx]);
+        this.skinnedmeshes[skinnedMeshIdx] = m;
+        n.parent.add(m);
+      }
+      // Hide all unused Meshes
+      if (skinnedMeshIdx < this.skinnedmeshes.length) {
+        for (; skinnedMeshIdx < this.skinnedmeshes.length; skinnedMeshIdx++) {
+          this.skinnedmeshes[skinnedMeshIdx].geometry = null;
+          if (this.skinnedmeshes[skinnedMeshIdx].parent) {
+            this.skinnedmeshes[skinnedMeshIdx].parent.remove(this.skinnedmeshes[skinnedMeshIdx]);
+          }
+        }
+      }
+      this.refresh();
+    },
+    deselect() {
+      for (let meshIdx = 0; meshIdx < this.meshes.length; meshIdx++) {
+        this.meshes[meshIdx].geometry = null;
+        if (this.meshes[meshIdx].parent) {
+          this.meshes[meshIdx].parent.remove(this.meshes[meshIdx]);
+        }
+      }
+      for (let skinnedMeshIdx = 0; skinnedMeshIdx < this.skinnedmeshes.length; skinnedMeshIdx++) {
+        this.skinnedmeshes[skinnedMeshIdx].geometry = null;
+        if (this.skinnedmeshes[skinnedMeshIdx].parent) {
+          this.skinnedmeshes[skinnedMeshIdx].parent.remove(this.skinnedmeshes[skinnedMeshIdx]);
+        }
+      }
+      this.refresh();
+    },
+    updateOutlineSize() {
+      if (this.outlinematerial) {
+        this.outlinematerial.uniforms.offset.value = this.outline;
+        this.refresh();
+      }
+    },
+    setOpacity() {
+      if (this.outlinematerial) {
+        this.outlinematerial.uniforms.opacity.value = this.opacity;
+        this.refresh();
+      }
+    },
+    updateTarget() {
+      if (this.target && this.outlinematerial) {
+        let obj = room.objects[this.target];
+        if (obj) {
+          this.select(obj);
+          if (!obj.loaded) {
+            obj.addEventListener('asset_load_complete', ev => this.select(obj));
+          }
+        } else if (!room.loaded) {
+          room.addEventListener('room_load_complete', ev => this.updateTarget());
+        }
+      }
+    },
+    getMesh(n, m) {
+      if (!m) {
+        m = new THREE.Mesh(n.geometry, this.outlinematerial);
+        m.matrixAutoUpdate = false;
+      } else {
+        m.geometry = n.geometry;
+        m.material = this.outlinematerial;
+      }
+      m.matrix.copy(n.matrix);
+      return m;
+    },
+    getSkinnedMesh(n, m) {
+      if (!m) {
+        m = new THREE.SkinnedMesh(n.geometry, this.outlinematerial);
+        m.skeleton = n.skeleton;
+        m.matrixAutoUpdate = false;
+      } else {
+        m.geometry = n.geometry;
+        m.material = this.outlinematerial;
+      }
+      m.matrix.copy(n.matrix);
+      return m;
+    }
+  }, elation.janusweb.janusbase);
+
+});

package/scripts/external/JanusClientConnection.js

@@ -329,9 +329,7 @@ JanusClientConnection.prototype.connect = function() {
     this.status = 2;
     this._useridSuffix = '';
     this.sendLogon();
-    while (this.msgQueue.length > 0) {
-      this.send(this.msgQueue.shift());
-    }
+    this.sendQueuedCommands()
     this.dispatchEvent({type: 'connect'});
   }.bind(this);
 
@@ -362,6 +360,15 @@ JanusClientConnection.prototype.disconnect = function() {
   this.dispatchEvent({type: 'disconnecting'});
   this._websocket.close();
 }
+JanusClientConnection.prototype.sendQueuedCommands = function() {
+  if (this._websocket.readyState > 0) {
+    while (this.msgQueue.length > 0) {
+      this.send(this.msgQueue.shift());
+    }
+  } else {
+    setTimeout(() => this.sendQueuedCommands(), 100);
+  }
+}
 
 JanusClientConnection.prototype.sendLogon = function() {
   var msgData = {
@@ -385,13 +392,12 @@ JanusClientConnection.prototype.setUserId = function(userId) {
 };
 
 JanusClientConnection.prototype.send = function(msg) {
-  if (this._websocket.readyState == 0) {
-    this.msgQueue.push(msg);
-  } else if (this._websocket.readyState == 1) {
+  try {
     this._websocket.send(JSON.stringify(msg) + '\r\n');
-  } else {
-    //this.reconnect();
+  } catch (e) {
+    this.msgQueue.push(msg);
   }
+  //this.reconnect();
 };
 
 JanusClientConnection.prototype.onMessage = function(msg) {

package/scripts/external/JanusFireboxParser.js

@@ -305,7 +305,7 @@ JanusFireboxParser.prototype.parseXML = function(imgxml, leaf, forceLower) {
       } else if (child.nodeName) {
         if (child.nodeName == "#text" || child.nodeName == "#cdata-section") {
           // this gets confused if you have multiple text/cdata nodes...
-          if (!child.nodeValue.match(/^[\s\n]*$/m)) {
+          if (!child.nodeValue.match(/^[\s\n]*$/s)) {
             parent._content = child.nodeValue;
           }
         } else {

package/scripts/image.js

@@ -37,7 +37,7 @@ elation.require(['janusweb.janusbase'], function() {
     this.createGeometry = function() {
       var aspect = this.getAspect(),
           thickness = 0.1; //Math.max(this.scale.x, this.scale.z) / (10 * this.scale.z);
-      var box = new THREE.BoxBufferGeometry(2, 2 * aspect, thickness);
+      var box = new THREE.BoxGeometry(2, 2 * aspect, thickness);
       box.applyMatrix4(new THREE.Matrix4().makeTranslation(0, 0, thickness / this.scale.z));
 
       // Flip the back face for images

package/scripts/janusbase.js

@@ -231,7 +231,7 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
       }
     }
     this.createForces = function() {
-      if (this.collidable && !this.collision_trigger) {
+      if (this.collidable || this.collision_trigger) {
         elation.events.add(this.objects.dynamics, 'physics_collide', elation.bind(this, this.handleCollision));
       }
       this.updateRotationSpeed();
@@ -383,8 +383,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'],
+          anim_id:              ['property', 'anim_id'],
+          anim_transition_time: ['property', 'anim_transition_time'],
+          activeanimation:      ['property', 'activeanimation'],
 
           fwd:      ['property', 'zdir'],
           xdir:     ['property', 'xdir'],
@@ -596,13 +597,16 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
             sbs3d: args.sbs3d,
             ou3d: args.ou3d,
             eac360: args.eac360,
+            vr180: args.vr180,
             hasalpha: args.hasalpha,
             auto_play: args.auto_play,
             type: args.type,
             format: args.format,
             hls: args.hls,
             preload: args.preload,
-            baseurl: this.baseurl
+            baseurl: this.baseurl,
+            proxy: args.proxy,
+            extratracks: args.extratracks,
           });
         } else if (args.video) {
           assetlist.push({
@@ -612,12 +616,15 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
             loop: args.loop,
             sbs3d: args.sbs3d,
             ou3d: args.ou3d,
+            vr180: args.vr180,
             hasalpha: args.hasalpha,
             auto_play: args.auto_play,
             type: args.type,
             format: args.format,
             hls: args.hls,
-            baseurl: this.baseurl
+            baseurl: this.baseurl,
+            proxy: args.proxy,
+            extratracks: args.extratracks,
           });
         }
       } else if (type == 'sound') {
@@ -795,7 +802,7 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
           }
           parent.worldToLocal(camera.getWorldPosition(playerpos)).sub(this.position);
           dir.copy(playerpos).normalize();
-          if (billboard == 'y') {
+          if (billboard == 'y' || billboard === true || billboard == 'true') {
             this.rotation.radians.set(0, Math.atan2(dir.x, dir.z), 0);
             this.frameupdates['rotation'] = true;
           }
@@ -817,10 +824,12 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
           this.refresh();
         }
 
+/*
         let pos = this.position;
         if (isNaN(pos.x)) pos.x = 0;
         if (isNaN(pos.y)) pos.y = 0;
         if (isNaN(pos.z)) pos.z = 0;
+*/
 
         if (this.properties.color === this.defaultcolor && (this.properties.color.r != 1 || this.properties.color.g != 1 || this.properties.color.b != 1)) {
           this.updateColor();
@@ -829,7 +838,7 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
         this.resetFrameUpdates();
         this.dispatchEvent({type: 'update', data: ev.data, bubbles: false});
         var proxy = this.getProxyObject();
-        if (typeof proxy.update == 'function' && this.created) {
+        if (this.created && typeof proxy.update == 'function') {
           proxy.update(ev.data);
         }
       }
@@ -978,13 +987,13 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
       if (other) {
         if (other.getProxyObject) {
           var proxy = other.getProxyObject();
-          //console.log('I collided', proxy, this);
+          //console.log('I collided', this.collision_trigger, other.collision_trigger, proxy, this);
 
-          if (this.collision_trigger || proxy.collision_trigger) {
+          if (this.collision_trigger || proxy.collision_trigger || other.collision_trigger) {
             this.dispatchEvent({type: 'trigger', data: { collision: ev.data, other: proxy }});
             ev.preventDefault();
             ev.stopPropagation();
-          } else if (this.collidable) {
+          } else if (this.collidable && other.collidable) {
             this.dispatchEvent({type: 'collision', data: { collision: ev.data, other: proxy }});
           } else {
             ev.preventDefault();
@@ -1030,7 +1039,7 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
     }
     this.updateAnimation = function() {
       // Triggered whenever this.anim_id changes
-      if (this.anim_id) {
+      if (this.anim_id || !this.activeanimation) {
         this.setAnimation(this.anim_id);
       } else if (this.activeanimation) {
         this.stopAnimation();
@@ -1051,7 +1060,7 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
           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;
+              oldaction.weight *= .9;
               if (oldaction.weight <= .001) {
                 oldaction.weight = 0;
                 oldaction.stop();
@@ -1087,10 +1096,12 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
       if (!event.target) {
         event.target = target || event.element;
       }
+/*
       var handlerfn = 'on' + event.type;
       if (handlerfn in this) {
         this.executeCallback(this[handlerfn], event);
       }
+*/
       // Bubble event up to parents, unless the event was thrown with bubbling disabled or an event handler called stopPropagation()
       let firedev = elation.events.fire(event);
       let returnValue = true;
@@ -1171,7 +1182,7 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
     this.raycast = (function() {
       var _pos = new THREE.Vector3(),
           _dir = new THREE.Vector3(0,0,-1);
-      return function(dir, offset, classname, maxdist) {
+      return function(dir, offset, classname, maxdist, colliderroot=null) {
         if (!this.room) return [];
         if (dir) {
           _dir.copy(dir);
@@ -1184,7 +1195,7 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
         }
         this.localToWorld(_pos);
         this.objects.dynamics.localToWorldDir(_dir);
-        return this.room.raycast(_dir, _pos, classname, maxdist);
+        return this.room.raycast(_dir, _pos, classname, maxdist, colliderroot);
       };
     })();
     this.getElementsByTagName = function(tagname, elements) {
@@ -1281,9 +1292,9 @@ console.log('its null', k, this[k], prop);
         // Special handling for 'rotation' and 'color'
         if (realkey == 'rotation') {
 /*
-          props['rotation'][0] *= THREE.Math.RAD2DEG;
-          props['rotation'][1] *= THREE.Math.RAD2DEG;
-          props['rotation'][2] *= THREE.Math.RAD2DEG;
+          props['rotation'][0] *= THREE.MathUtils.RAD2DEG;
+          props['rotation'][1] *= THREE.MathUtils.RAD2DEG;
+          props['rotation'][2] *= THREE.MathUtils.RAD2DEG;
 */
         } else if (realkey == 'color') {
           if (!this.colorIsDefault) {
@@ -1401,5 +1412,17 @@ console.log('clone', props);
       }
       return false;
     }
+    this.physics_collide = function(ev) {
+      let obj1 = ev.data.bodies[0].object, obj2 = ev.data.bodies[1].object,
+          other = (obj1 == this ? obj2 : obj1);
+
+      let events = elation.events.fire({type: 'collide', element: this, data: {
+        other: (typeof other.getProxyObject == 'function' ? other.getProxyObject() : other),
+        collision: ev.data
+      } });
+      if (elation.events.wasDefaultPrevented(events)) {
+        ev.preventDefault();
+      }
+    }
   }, elation.engine.things.generic);
 });

package/scripts/janusghost.js

@@ -33,8 +33,8 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
             diffuseColor.rgb *= vColor;
           #endif
           float dist = length(vViewPosition);
-          float mindist = .4;
-          float maxdist = .6;
+          float mindist = .2;
+          float maxdist = .4;
           if (dist < maxdist) {
             diffuseColor.a = clamp(((dist - mindist) / (maxdist - mindist)), 0., 1.);
           }
@@ -131,13 +131,11 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
         this.ghostassets = assets;
         this.assetpack = elation.engine.assets.loadJSON(assets.assetlist);
       } else {
-        console.log(this.ghostassets);
-        this.assetpack.loadJSON(assets.assetlist);
+        this.assetpack.loadJSON(assets.assetlist, true);
       }
 
       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
@@ -341,7 +339,7 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
             if (this.body.animationmixer) {
               this.cloneAnimations(animasset);
             }
-            //this.body.setAnimation('idle');
+            this.body.setAnimation('idle');
           }
         });
         animasset.load();
@@ -611,6 +609,15 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
           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);
         }
 
+        if (movedata.morphtargets) {
+          if (this.body) {
+            let morphtargets = movedata.morphtargets;
+            for (let target in morphtargets) {
+              this.body.setMorphTargetInfluence(target, morphtargets[target]);
+            }
+          }
+        }
+
         this.objects.dynamics.updateState();
         this.refresh();
       }
@@ -655,9 +662,13 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
         }
         if (ghostdef.head_id) {
           this.setHead(ghostdef.head_id, headpos, ghostdef.scale);
+        } else if (this.head) {
+          this.setHead(false);
         }
         if (ghostdef.body_id) {
           this.setBody(ghostdef.body_id, ghostdef.scale, ghostdef.pos);
+        } else if (this.body) {
+          this.setBody(false);
         }
         if (ghostdef._children) {
           for (var type in ghostdef._children) {