janusweb 1.5.41 → 1.5.42

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.42",
   "main": "scripts/janusweb.js",
   "author": "James Baicoianu",
   "license": "MIT",

package/scripts/client.js

@@ -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,176 @@
+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();
+    },
+    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/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/janusbase.js

@@ -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'],

package/scripts/janusghost.js

@@ -611,6 +611,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();
       }

package/scripts/janusparticle.js

@@ -256,7 +256,7 @@ elation.require(['janusweb.janusbase'], function() {
       geo.setAttribute('size', new THREE.BufferAttribute(size, 1));
 
       this.created = true;
-      this.emitted = 0;
+      this.spawncount = 0;
       this.currentpoint = 0;
       this.lasttime = performance.now();
 
@@ -282,6 +282,7 @@ elation.require(['janusweb.janusbase'], function() {
         color[i*4+2] = point.color.b;
         color[i*4+3] = point.opacity;
       }
+      this.emitted = 0;
     }
     this.updateParticles = function(ev) {
       if (!this.loaded || !this.started || !this.parent) return;
@@ -290,7 +291,7 @@ elation.require(['janusweb.janusbase'], function() {
           endtime = now + this.duration * 1000,
           emitted = 0,
           startpoint = this.currentpoint,
-          spawncount = this.rate * elapsed / 1000,
+          spawncount = this.spawncount + this.rate * elapsed / 1000,
           count = this.count,
           loop = this.loop;
 
@@ -315,10 +316,12 @@ elation.require(['janusweb.janusbase'], function() {
             p.endtime = (this.duration > 0 ? endtime : Infinity);
             p.active = 1;
             emitted++;
+            spawncount--;
             this.currentpoint = (this.currentpoint + 1) % count;
           }
         } 
       }
+      this.spawncount = spawncount;
       this.lasttime = now;
       // Notify the renderer of our changes, but only if we're visible to the player
       // We also rate limit here, so if nothing else in the scene is changing, we

package/scripts/janusplayer.js

@@ -18,7 +18,11 @@ elation.require(['engine.things.player', 'janusweb.external.JanusVOIP', 'ui.butt
     this.postinit = function() {
       elation.engine.things.janusplayer.extendclass.postinit.call(this);
 
-      this.settings = elation.collection.localindexed({storagekey: 'janusweb.player.settings', index: 'key'});
+      try {
+        this.settings = elation.collection.localindexed({storagekey: 'janusweb.player.settings', index: 'key'});
+      } catch (e) {
+        this.settings = elation.collection.indexed({storagekey: 'janusweb.player.settings', index: 'key'});
+      }
 
       this.defineProperties({
         janus: {type: 'object' },
@@ -127,6 +131,7 @@ elation.require(['engine.things.player', 'janusweb.external.JanusVOIP', 'ui.butt
       this.party_mode = this.getSetting('partymode.enabled', false);
       this.currentavatar = '';
       this.getAvatarData().then(d => this.currentavatar = d);
+      this.morphtargetchanges = {};
     }
     this.createChildren = function() {
       elation.engine.things.janusplayer.extendclass.createChildren.call(this);
@@ -541,81 +546,83 @@ elation.require(['engine.things.player', 'janusweb.external.JanusVOIP', 'ui.butt
     this.stop = function() {
     }
     this.getProxyObject = function() {
-      var proxy = new elation.proxy(this, {
-        parent:        ['accessor', 'parent.getProxyObject'],
-        room:          ['property', 'room'],
-        pos:           ['property', 'position'],
-        vel:           ['property', 'velocity'],
-        accel:         ['property', 'acceleration'],
-        eye_pos:       ['property', 'vectors.eye_pos'],
-        head_pos:      ['property', 'vectors.head_pos'],
-        cursor_pos:    ['property', 'vectors.cursor_pos'],
-        cursor_xdir:   ['property', 'vectors.cursor_xdir'],
-        cursor_ydir:   ['property', 'vectors.cursor_ydir'],
-        cursor_zdir:   ['property', 'vectors.cursor_zdir'],
-        view_dir:      ['property', 'vectors.view_zdir'],
-        dir:           ['property', 'vectors.zdir'],
-        up_dir:        ['property', 'vectors.ydir'],
-        userid:        ['property', 'janus.userId'],
-        enabled:       ['property', 'enabled'],
-        flying:        ['property', 'flying'],
-        walking:       ['property', 'walking'],
-        running:       ['property', 'running'],
-        //url:           ['property', 'currenturl'],
-        //hmd_enabled:   ['property', 'hmd_enabled'],
-        cursor_active: ['property', 'cursor_active'],
-        cursor_visible: ['property', 'cursor_visible'],
-        cursor_opacity: ['property', 'cursor_opacity'],
-        cursor_style: ['property', 'cursor_style'],
-        cursor_object: ['property', 'cursor_object'],
-        lookat_object: ['property', 'lookat_object'],
-        lookat_pos:    ['property', 'vectors.lookat_pos'],
-        //lookat_xdir:   ['property', 'properties.lookat_xdir'],
-        //lookat_ydir:   ['property', 'properties.lookat_ydir'],
-        //lookat_zdir:   ['property', 'properties.lookat_zdir'],
-        hand0_active:  ['property', 'hands.left.isactive'],
-        hand0_pos:     ['property', 'hands.left.handpos'],
-        hand0_xdir:    ['property', 'hands.left.xdir'],
-        hand0_ydir:    ['property', 'hands.left.ydir'],
-        hand0_zdir:    ['property', 'hands.left.zdir'],
-        hand0_p0:      ['property', 'hands.left.p0'],
-        hand0_p1:      ['property', 'hands.left.p1'],
-        hand0_p2:      ['property', 'hands.left.p2'],
-        hand0_p3:      ['property', 'hands.left.p3'],
-        hand0_p4:      ['property', 'hands.left.p4'],
+      if (!this._proxyobject) {
+        this._proxyobject = new elation.proxy(this, {
+          parent:        ['accessor', 'parent.getProxyObject'],
+          room:          ['property', 'room'],
+          pos:           ['property', 'position'],
+          vel:           ['property', 'velocity'],
+          accel:         ['property', 'acceleration'],
+          eye_pos:       ['property', 'vectors.eye_pos'],
+          head_pos:      ['property', 'vectors.head_pos'],
+          cursor_pos:    ['property', 'vectors.cursor_pos'],
+          cursor_xdir:   ['property', 'vectors.cursor_xdir'],
+          cursor_ydir:   ['property', 'vectors.cursor_ydir'],
+          cursor_zdir:   ['property', 'vectors.cursor_zdir'],
+          view_dir:      ['property', 'vectors.view_zdir'],
+          dir:           ['property', 'vectors.zdir'],
+          up_dir:        ['property', 'vectors.ydir'],
+          userid:        ['property', 'janus.userId'],
+          enabled:       ['property', 'enabled'],
+          flying:        ['property', 'flying'],
+          walking:       ['property', 'walking'],
+          running:       ['property', 'running'],
+          //url:           ['property', 'currenturl'],
+          //hmd_enabled:   ['property', 'hmd_enabled'],
+          cursor_active: ['property', 'cursor_active'],
+          cursor_visible: ['property', 'cursor_visible'],
+          cursor_opacity: ['property', 'cursor_opacity'],
+          cursor_style: ['property', 'cursor_style'],
+          cursor_object: ['property', 'cursor_object'],
+          lookat_object: ['property', 'lookat_object'],
+          lookat_pos:    ['property', 'vectors.lookat_pos'],
+          //lookat_xdir:   ['property', 'properties.lookat_xdir'],
+          //lookat_ydir:   ['property', 'properties.lookat_ydir'],
+          //lookat_zdir:   ['property', 'properties.lookat_zdir'],
+          hand0_active:  ['property', 'hands.left.isactive'],
+          hand0_pos:     ['property', 'hands.left.handpos'],
+          hand0_xdir:    ['property', 'hands.left.xdir'],
+          hand0_ydir:    ['property', 'hands.left.ydir'],
+          hand0_zdir:    ['property', 'hands.left.zdir'],
+          hand0_p0:      ['property', 'hands.left.p0'],
+          hand0_p1:      ['property', 'hands.left.p1'],
+          hand0_p2:      ['property', 'hands.left.p2'],
+          hand0_p3:      ['property', 'hands.left.p3'],
+          hand0_p4:      ['property', 'hands.left.p4'],
 
-        hand1_active:  ['property', 'hands.right.isactive'],
-        hand1_pos:     ['property', 'hands.right.handpos'],
-        hand1_xdir:    ['property', 'hands.right.xdir'],
-        hand1_ydir:    ['property', 'hands.right.ydir'],
-        hand1_zdir:    ['property', 'hands.right.zdir'],
-        hand1_p0:      ['property', 'hands.right.p0'],
-        hand1_p1:      ['property', 'hands.right.p1'],
-        hand1_p2:      ['property', 'hands.right.p2'],
-        hand1_p3:      ['property', 'hands.right.p3'],
-        hand1_p4:      ['property', 'hands.right.p4'],
-        url:           ['property', 'parent.currentroom.url'],
+          hand1_active:  ['property', 'hands.right.isactive'],
+          hand1_pos:     ['property', 'hands.right.handpos'],
+          hand1_xdir:    ['property', 'hands.right.xdir'],
+          hand1_ydir:    ['property', 'hands.right.ydir'],
+          hand1_zdir:    ['property', 'hands.right.zdir'],
+          hand1_p0:      ['property', 'hands.right.p0'],
+          hand1_p1:      ['property', 'hands.right.p1'],
+          hand1_p2:      ['property', 'hands.right.p2'],
+          hand1_p3:      ['property', 'hands.right.p3'],
+          hand1_p4:      ['property', 'hands.right.p4'],
+          url:           ['property', 'parent.currentroom.url'],
 
-        collision_radius: ['property', 'collision_radius'],
+          collision_radius: ['property', 'collision_radius'],
 
-        currentavatar: ['property', 'currentavatar'],
-        defaultanimation: ['property', 'defaultanimation'],
+          currentavatar: ['property', 'currentavatar'],
+          defaultanimation: ['property', 'defaultanimation'],
 
-        localToWorld:  ['function', 'localToWorld'],
-        worldToLocal:  ['function', 'worldToLocal'],
-        appendChild:   ['function', 'appendChild'],
-        removeChild:   ['function', 'removeChild'],
-        addForce:      ['function', 'addForce'],
-        removeForce:   ['function', 'removeForce'],
-        raycast:       ['function', 'raycast'],
-        getViewFrustum:['function', 'getViewFrustum'],
-        getUsername:   ['function', 'getUsername'],
-        setUsername:   ['function', 'setUsername'],
-        getSetting:   ['function', 'getSetting'],
-        setSetting:   ['function', 'setSetting'],
-        setAvatar:    ['function', 'setAvatar'],
-      });
-      return proxy;
+          localToWorld:  ['function', 'localToWorld'],
+          worldToLocal:  ['function', 'worldToLocal'],
+          appendChild:   ['function', 'appendChild'],
+          removeChild:   ['function', 'removeChild'],
+          addForce:      ['function', 'addForce'],
+          removeForce:   ['function', 'removeForce'],
+          raycast:       ['function', 'raycast'],
+          getViewFrustum:['function', 'getViewFrustum'],
+          getUsername:   ['function', 'getUsername'],
+          setUsername:   ['function', 'setUsername'],
+          getSetting:   ['function', 'getSetting'],
+          setSetting:   ['function', 'setSetting'],
+          setAvatar:    ['function', 'setAvatar'],
+        });
+      }
+      return this._proxyobject;
     }
     this.getAvatarData = function() {
       return new Promise((resolve, reject) => {
@@ -725,6 +732,29 @@ elation.require(['engine.things.player', 'janusweb.external.JanusVOIP', 'ui.butt
       } 
       return handData;
     }
+    this.hasMorphTargetData = function() {
+      return Object.keys(this.morphtargetchanges).length > 0;
+    }
+    this.setMorphTargetInfluence = function(morphtarget, value) {
+      if (this.ghost && this.ghost.body) {
+        this.ghost.body.setMorphTargetInfluence(morphtarget, value);
+        //if (this.morphtargetchanges.indexOf(morphtarget) == -1) {
+        this.morphtargetchanges[morphtarget] = value;
+        //}
+      }
+    }
+    this.getMorphTargetData = function() {
+      if (this.hasMorphTargetData()) {
+        let data = {};
+        let body = this.ghost.body;
+        for (let morphtarget in this.morphtargetchanges) {
+          data[morphtarget] = this.morphtargetchanges[morphtarget];
+          delete this.morphtargetchanges[morphtarget];
+        }
+        return data;
+      }
+      return false;
+    }
     this.getRandomUsername = function() {
       var adjectives = [
 				"Adorable", "Beautiful", "Clean", "Drab", "Elegant", "Fancy", "Glamorous", "Handsome", "Long", "Magnificent",
@@ -999,16 +1029,23 @@ elation.require(['engine.things.player', 'janusweb.external.JanusVOIP', 'ui.butt
       return function(newscale, scaletime, scalecurve) {
         if (newscale != this.scale) {
           startscale.copy(this.properties.scale);
-          let start = performance.now();
-          let timer = setInterval(() => {
-            let n = (performance.now() - start) / scaletime;
+          if (scaletime) {
+            let start = performance.now();
+            let timer = setInterval(() => {
+              let n = (performance.now() - start) / scaletime;
 
-            this.scale = tmpvec.set(newscale, newscale, newscale).sub(startscale).multiplyScalar(n).add(startscale);
+              this.scale = tmpvec.set(newscale, newscale, newscale).sub(startscale).multiplyScalar(n).add(startscale);
+              this.camera.scale = camscale.set(1 / this.scale.x, 1 / this.scale.y, 1 / this.scale.z);
+              if (n >= 1) {
+                clearInterval(timer);
+                this.scale.set(newscale, newscale, newscale);
+                this.camera.scale = camscale.set(1 / this.scale.x, 1 / this.scale.y, 1 / this.scale.z);
+              }
+            }, 16);
+          } else {
+            this.scale.set(newscale, newscale, newscale);
             this.camera.scale = camscale.set(1 / this.scale.x, 1 / this.scale.y, 1 / this.scale.z);
-            if (n >= 1) {
-              clearInterval(timer);
-            }
-          }, 16);
+          }
         }
       };
     })();