janusweb 1.5.30 → 1.5.34

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) {
@@ -76,7 +97,6 @@ elation.require(['janusweb.janusbase', 'engine.things.leapmotion'], function() {
           size: .1,
           thickness: .03,
           align: 'center',
-          collidable: false,
           text: name,
           pos: this.userid_pos,
           pickable: false,
@@ -114,6 +134,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 +245,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 +278,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 +291,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 +513,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 +584,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 +632,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 +680,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 +709,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 +728,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 +779,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;

package/scripts/janusparagraph.js

@@ -13,7 +13,7 @@ elation.require(['janusweb.janusbase'], function() {
         depth_write: { type: 'boolean', default: true },
         depth_test: { type: 'boolean', default: true },
         collision_id: { type: 'string', default: 'cube' },
-        collision_scale: { type: 'vector3', default: V(1, 1, .02) },
+        collision_scale: { type: 'vector3', default: V(.5, .5, .02) },
         shadow: { type: 'boolean', default: true, set: this.updateMaterial },
         shadow_receive: { type: 'boolean', default: true, set: this.updateMaterial, comment: 'Receive shadows from self and other objects' },
         shadow_cast: { type: 'boolean', default: true, set: this.updateMaterial, comment: 'Cast shadows onto self and other objects' },
@@ -29,8 +29,10 @@ elation.require(['janusweb.janusbase'], function() {
       return mesh;
     }
     this.createForces = function() {
-      this.setCollider('box', { min: V(-1, -1, -.01), max: V(1, 1, .01) });
+      this.setCollider('box', { min: V(-.8, -.8, -.01), max: V(.8, .8, .01) });
+      //this.collision_id = 'cube';
     }
+    this.updateColliderFromGeometry = function() { }
     this.createMaterial = function() {
       var texture = this.createTexture();
       var sidemap = {
@@ -66,15 +68,15 @@ elation.require(['janusweb.janusbase'], function() {
       if (!this.canvas || !this.texture) return;
       var ctx = this.canvas.getContext('2d'),
           texture = this.texture;
-      this.canvas.width = 512;
-      this.canvas.height = 512;
+      this.canvas.width = 1024;
+      this.canvas.height = 1024;
       var text_col = '#' + this.text_col.getHexString(),
           back_col = 'rgba(' + (this.back_col.r * 255) + ', ' + (this.back_col.g * 255) + ', ' + (this.back_col.b * 255) + ', ' + this.back_alpha + ')';
       var basestyle = 'font-family: sans-serif;' +
                       'font-size: ' + this.font_size + 'px;' +
                       'color: ' + text_col + ';' +
                       'background: ' + back_col + ';' +
-                      'max-width: 502px;' +
+                      'max-width: 1014px;' +
                       'padding: 5px;';
 
       // We need to sanitize our HTML in case someone provides us with malformed markup.
@@ -115,7 +117,7 @@ elation.require(['janusweb.janusbase'], function() {
           texture.needsUpdate = true;
           this.refresh();
         }
-      }
+      };
       this.currentImage = img;
       img.src = url;
       this.refresh();

package/scripts/janusparticle.js

@@ -39,7 +39,6 @@ elation.require(['janusweb.janusbase'], function() {
         opacity: { type: 'float', default: 1.0, set: this.updateMaterial },
         fade_in: { type: 'float', default: 1.0 },
         fade_out: { type: 'float', default: 1.0 },
-        duration: { type: 'float', default: 1.0 },
         particle_scale: { type: 'vector3', default: [1, 1, 1], set: this.updateMaterial},
         particle_vel: { type: 'vector3', default: [0, 0, 0]},
         particle_accel: { type: 'vector3', default: [0, 0, 0]},
@@ -52,8 +51,8 @@ elation.require(['janusweb.janusbase'], function() {
         refreshrate: { type: 'int', default: 30 },
         blend_src: { type: 'string', default: 'src_alpha', set: this.updateMaterial },
         blend_dest: { type: 'string', default: 'one_minus_src_alpha', set: this.updateMaterial },
-        depthwrite: { type: 'bool', default: false },
-        depthtest: { type: 'bool', default: true },
+        depth_write: { type: 'bool', default: false },
+        depth_test: { type: 'bool', default: true },
       });
       this.particles = [];
       this.emitted = 0;
@@ -67,11 +66,12 @@ elation.require(['janusweb.janusbase'], function() {
       this.collidable = false;
       this.boundingRadiusSq = 0;
       this.boundingSphereWorld = new THREE.Sphere();
+      this.furthestPoint = new THREE.Vector3();
       this.lastrefresh = 0;
       this.updateParticles = elation.bind(this, this.updateParticles); // FIXME - hack, this should happen at the lower level of all components
     }
     this.createObject3D = function() {
-      var geo = this.geometry = new THREE.BufferGeometry()
+      var geo = this.geometry = new THREE.BufferGeometry();
 
       var texture = null,
           textureasset = null;
@@ -131,8 +131,8 @@ elation.require(['janusweb.janusbase'], function() {
         //blending: THREE.AdditiveBlending,
         transparent: true,
         alphaTest: .001,
-        depthWrite: this.depthwrite,
-        depthTest: this.depthtest,
+        depthWrite: this.depth_write,
+        depthTest: this.depth_test,
       } );
 
       this.material = mat;
@@ -289,8 +289,8 @@ elation.require(['janusweb.janusbase'], function() {
           elapsed = now - this.lasttime,
           endtime = now + this.duration * 1000,
           emitted = 0,
-          startpoint = this.currentpoint;
-          spawncount = this.rate * elapsed / 1000;
+          startpoint = this.currentpoint,
+          spawncount = this.rate * elapsed / 1000,
           count = this.count,
           loop = this.loop;
 
@@ -324,11 +324,19 @@ elation.require(['janusweb.janusbase'], function() {
       // We also rate limit here, so if nothing else in the scene is changing, we
       // render at a lower fps
       this.localToWorld(this.boundingSphereWorld.center.set(0,0,0));
-      if (!this.objects['3d'].geometry.boundingSphere) {
-        this.objects['3d'].geometry.computeBoundingSphere();
+      let geo = this.objects['3d'].geometry;
+      if (!geo.boundingSphere) {
+        geo.computeBoundingSphere();
+      } else {
+        let currentBoundingRadius = geo.boundingSphere.radius;
+        if (this.boundingRadiusSq > currentBoundingRadius * currentBoundingRadius) {
+           geo.boundingSphere.radius = Math.sqrt(this.boundingRadiusSq) + .1;
+        }
       }
-      this.boundingSphereWorld.radius = this.objects['3d'].geometry.boundingSphere.radius;
+
+      this.boundingSphereWorld.radius = geo.boundingSphere.radius;
       if (player.viewfrustum.intersectsSphere(this.boundingSphereWorld) && now - this.lastrefresh > (1000 / this.refreshrate)) {
+
         this.refresh();
         this.lastrefresh = now;
       }
@@ -341,11 +349,14 @@ elation.require(['janusweb.janusbase'], function() {
         var lengthSq = vec.lengthSq();
         if (lengthSq > this.boundingRadiusSq) {
           this.boundingRadiusSq = lengthSq;
+          this.furthestPoint.copy(vec);
+/*
           var geo = this.objects['3d'].geometry;
           if (!geo.boundingSphere) {
             geo.boundingSphere = new THREE.Sphere();
           }
           geo.boundingSphere.radius = Math.sqrt(lengthSq);
+*/
         }
       }
     }
@@ -396,7 +407,7 @@ elation.require(['janusweb.janusbase'], function() {
       var randomInRange = function(range) {
         //return (Math.random() - .5) * range;
         return Math.random() * range;
-      }
+      };
       let pointpos = point.pos;
       pointpos.set(randomInRange(rand_pos.x), randomInRange(rand_pos.y), randomInRange(rand_pos.z));
       if (this.emitpoints) {
@@ -461,8 +472,7 @@ elation.require(['janusweb.janusbase'], function() {
         mesh.traverse(function(n) {
           if (n && n.geometry) {
             var geo = n.geometry;
-            if (geo instanceof THREE.Geometry) {
-            } else if (geo instanceof THREE.BufferGeometry) {
+            if (geo instanceof THREE.BufferGeometry) {
               var positions = geo.attributes.position.array;
               for (var i = 0; i < positions.length; i += 3) {
                 vertices.push(new THREE.Vector3(positions[i] * scale.x, positions[i+1] * scale.y, positions[i+2] * scale.z));
@@ -521,8 +531,8 @@ elation.require(['janusweb.janusbase'], function() {
           count:  [ 'property', 'count'],
           duration:  [ 'property', 'duration'],
           opacity:  [ 'property', 'opacity'],
-          depthwrite:  [ 'property', 'depthwrite'],
-          depthtest:  [ 'property', 'depthtest'],
+          depth_write:  [ 'property', 'depth_write'],
+          depth_test:  [ 'property', 'depth_test'],
           play:  [ 'function', 'start'],
         };
       }