janusweb 1.5.30 → 1.5.34

package/scripts/object.js

@@ -5,6 +5,36 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
       'front': THREE.BackSide,
       'none': THREE.DoubleSide
     };
+    this.depthFuncMap = {
+      'never': THREE.NeverDepth,
+      'always': THREE.AlwaysDepth,
+      'equal': THREE.EqualDepth,
+      'less': THREE.LessDepth,
+      'lessequal': THREE.LessEqualDepth,
+      'greaterequal': THREE.GreaterEqualDepth,
+      'greater': THREE.GreaterDepth,
+      'notequal': THREE.NotEqualDepth,
+    };
+    this.blendModeMap = {
+      'normal': THREE.NormalBlending,
+      'no': THREE.NoBlending,
+      'additive': THREE.AdditiveBlending,
+      'subtractive': THREE.SubtractiveBlending,
+      'multiply': THREE.MultiplyBlending,
+      'custom': THREE.CustomBlending,
+    };
+    this.blendFactorsMap = {
+      'zero': THREE.ZeroFactor,
+      'one': THREE.OneFactor,
+      'src_color': THREE.SrcColorFactor,
+      'dst_color': THREE.DstColorFactor,
+      'src_alpha': THREE.SrcAlphaFactor,
+      'dst_alpha': THREE.DstAlphaFactor,
+      'one_minus_src_color': THREE.OneMinusSrcColorFactor,
+      'one_minus_src_alpha': THREE.OneMinusSrcAlphaFactor,
+      'one_minus_dst_color': THREE.OneMinusDstColorFactor,
+      'one_minus_dst_alpha': THREE.OneMinusDstAlphaFactor,
+    };
     this.postinit = function() {
       elation.engine.things.janusobject.extendclass.postinit.call(this);
       this.defineProperties({
@@ -15,7 +45,7 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         video_id: { type: 'string', set: this.updateVideo, comment: 'Video texture ID' },
         shader_id: { type: 'string', set: this.updateMaterial, comment: 'Shader ID' },
         shader_chunk_replace: { type: 'object' },
-        url: { type: 'string' },
+        url: { type: 'string', set: this.updateWebsurfaceURL },
         loop: { type: 'boolean' },
         websurface_id: { type: 'string', set: this.updateWebsurface, comment: 'WebSurface ID' },
         shadow: { type: 'boolean', default: true, set: this.updateMaterial },
@@ -26,10 +56,14 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         lights: { type: 'boolean', default: false, comment: 'Load lights from model' },
         lighting: { type: 'boolean', default: true, set: this.updateMaterial, comment: 'Object reacts to scene lighting' },
         cull_face: { type: 'string', default: 'back', set: this.updateMaterial, comment: 'Hide face sides (back, front, or none)' },
-        blend_src: { type: 'string', default: 'src_alpha', set: this.updateMaterial, comment: 'Blend mode (source)' },
-        blend_dest: { type: 'string', default: 'one_minus_src_alpha', set: this.updateMaterial, comment: 'Blend mode (destination)' },
+        blend_src: { type: 'string', set: this.updateMaterial, comment: 'Blend mode (source)' },
+        blend_dest: { type: 'string', set: this.updateMaterial, comment: 'Blend mode (destination)' },
+        blend_mode: { type: 'string', default: 'normal', set: this.updateMaterial, comment: 'Blend mode' },
         depth_write: { type: 'boolean', default: null, set: this.updateMaterial },
         depth_test: { type: 'boolean', default: null, set: this.updateMaterial },
+        depth_offset: { type: 'float', default: null, set: this.updateMaterial },
+        depth_func: { type: 'string', default: null, set: this.updateMaterial },
+        color_write: { type: 'boolean', default: null, set: this.updateMaterial },
         envmap_id: { type: 'string', set: this.updateMaterial, comment: 'Environment map texture ID (overrides skybox reflections)' },
         normalmap_id: { type: 'string', set: this.updateMaterial, comment: 'Normal map texture ID' },
         bumpmap_id: { type: 'string', set: this.updateMaterial, comment: 'Bumpmap texture ID' },
@@ -111,6 +145,8 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
       //this.properties.collidable = false;
 
       //this.updateColliderFromGeometry(new THREE.BoxGeometry(1,1,1));
+
+      elation.events.add(this.room, 'skybox_update', ev => this.updateSkybox());
     }
     this.createForces = function() {
       elation.engine.things.janusobject.extendclass.createForces.call(this);
@@ -150,6 +186,13 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         }), 0);
         this.jsparts.updateParts();
         this.assetloaded = true;
+        if (this.modelasset) {
+          this.initAnimations(this.modelasset.animations);
+          if (this.animations && this.anim_id && this.animations[this.anim_id]) {
+            console.log('start animation', this);
+            this.animations[this.anim_id].play();
+          }
+        }
         if (this.loadingindicator) {
           this.loadingindicator.die();
         }
@@ -176,7 +219,7 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
       var videoasset = this.getAsset('video', videoid);
       if (videoasset) {
         this.videoasset = videoasset;
-        texture = videoasset.getInstance();
+        let texture = videoasset.getInstance();
         if (!texture.image) {
           videoasset.load();
         }
@@ -228,6 +271,8 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
             url = this.room.baseurl + url;
           }
           this.url = url;
+        } else {
+          this.url = this.websurface_id;
         }
 /*
         this.pickable = false;
@@ -265,6 +310,11 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         if (n.material) n.material = blankmaterial;
       });
     }
+    this.updateWebsurfaceURL = function() {
+      if (this.websurface) {
+        this.websurface.url = this.url;
+      }
+    }
     this.setTextureDirty = function() {
       this.textureNeedsUpdate = true;
     }
@@ -279,6 +329,11 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
           this.refresh();
         }
       }
+      if (this.animationmixer) {
+        //this.animationmixer.setTime(new Date().getTime() / 1000);
+        this.animationmixer.update(ev.data);
+        this.refresh();
+      }
     }
     this.assignTextures = function() {
       //console.log('assign textures', this.name, this.objects['3d']);
@@ -301,7 +356,11 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
           blend_src = false,
           blend_dest = false,
           side = this.sidemap[this.properties.cull_face],
-          textureasset;
+          textureasset,
+          lightmaptextureasset,
+          emissivetextureasset,
+          roughnesstextureasset,
+          metalnesstextureasset;
 
       this.textureNeedsUpdate = false;
 
@@ -319,6 +378,18 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         if (!modelasset || modelasset.name != this.janusid) {
           modelasset = this.getAsset('model', this.janusid, true);
           this.modelasset = modelasset;
+
+          if (modelasset.animations) {
+            this.initAnimations(modelasset.animations);
+            if (this.anim_id) {
+              if (modelasset && modelasset.loaded) {
+                this.setAnimation(this.anim_id);
+              } else {
+                elation.events.add(modelasset, 'asset_load', () => this.setAnimation(this.anim_id));
+              }
+            }
+          }
+
         }
         if (modelasset.tex) {
           image_id = modelasset.tex;
@@ -336,10 +407,10 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         if (textureasset) {
           texture = textureasset.getInstance();
           this.textureasset = textureasset;
-          if (!this.assetloadhandlers[image_id]) {
-            this.assetloadhandlers[image_id] = true;
+          if (!this.assetloadhandlers[texture.uuid]) {
+            this.assetloadhandlers[texture.uuid] = true;
             elation.events.add(textureasset, 'asset_load', this.refresh);
-            elation.events.add(texture, 'update', this.refresh);
+            elation.events.add(texture, 'asset_update', this.refresh);
           }
 
           //texture.offset.copy(this.texture_offset);
@@ -365,10 +436,10 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         let normaltextureasset = this.getAsset('image', normal_image_id, true);
         if (normaltextureasset) {
           textureNormal = normaltextureasset.getInstance();
-          if (!this.assetloadhandlers[normal_image_id]) {
-            this.assetloadhandlers[normal_image_id] = true;
+          if (!this.assetloadhandlers[textureNormal.uuid]) {
+            this.assetloadhandlers[textureNormal.uuid] = true;
             elation.events.add(textureNormal, 'asset_load', elation.bind(this, this.refresh));
-            elation.events.add(textureNormal, 'update', elation.bind(this, this.refresh));
+            elation.events.add(textureNormal, 'asset_update', elation.bind(this, this.refresh));
           }
 
           if (normaltextureasset.sbs3d) {
@@ -387,10 +458,10 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         let bumptextureasset = this.getAsset('image', bump_image_id, true);
         if (bumptextureasset) {
           textureBump = bumptextureasset.getInstance();
-          if (!this.assetloadhandlers[bump_image_id]) {
-            this.assetloadhandlers[bump_image_id] = true;
+          if (!this.assetloadhandlers[textureBump.uuid]) {
+            this.assetloadhandlers[textureBump.uuid] = true;
             elation.events.add(bumptextureasset, 'asset_load', elation.bind(this, this.refresh));
-            elation.events.add(textureBump, 'update', elation.bind(this, this.refresh));
+            elation.events.add(textureBump, 'asset_update', elation.bind(this, this.refresh));
           }
           if (bumptextureasset.sbs3d) {
             textureBump.repeat.set(0.5, 1);
@@ -408,10 +479,10 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         let alphatextureasset = this.getAsset('image', alpha_image_id, true);
         if (alphatextureasset) {
           textureAlpha = alphatextureasset.getInstance();
-          if (!this.assetloadhandlers[alpha_image_id]) {
-            this.assetloadhandlers[alpha_image_id] = true;
+          if (!this.assetloadhandlers[textureAlpha.uuid]) {
+            this.assetloadhandlers[textureAlpha.uuid] = true;
             elation.events.add(alphatextureasset, 'asset_load', elation.bind(this, this.refresh));
-            elation.events.add(textureAlpha, 'update', elation.bind(this, this.refresh));
+            elation.events.add(textureAlpha, 'asset_update', elation.bind(this, this.refresh));
           }
           if (alphatextureasset.sbs3d) {
             textureAlpha.repeat.set(0.5, 1);
@@ -429,10 +500,10 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         }
         if (displacementtextureasset) {
           textureDisplacement = displacementtextureasset.getInstance();
-          if (!this.assetloadhandlers[displacement_image_id]) {
-            this.assetloadhandlers[displacement_image_id] = true;
+          if (!this.assetloadhandlers[textureDisplacement.uuid]) {
+            this.assetloadhandlers[textureDisplacement.uuid] = true;
             elation.events.add(displacementtextureasset, 'asset_load', elation.bind(this, this.refresh));
-            elation.events.add(textureDisplacement, 'update', elation.bind(this, this.refresh));
+            elation.events.add(textureDisplacement, 'asset_update', elation.bind(this, this.refresh));
           }
           if (displacementtextureasset.sbs3d) {
             textureDisplacement.repeat.set(0.5, 1);
@@ -450,10 +521,10 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         lightmaptextureasset = this.getAsset('image', lightmap_image_id);
         if (lightmaptextureasset) {
           textureLightmap = lightmaptextureasset.getInstance();
-          if (!this.assetloadhandlers[lightmap_image_id]) {
-            this.assetloadhandlers[lightmap_image_id] = true;
+          if (!this.assetloadhandlers[textureLightmap.uuid]) {
+            this.assetloadhandlers[textureLightmap.uuid] = true;
             elation.events.add(lightmaptextureasset, 'asset_load', elation.bind(this, this.setTextureDirty));
-            elation.events.add(textureLightmap, 'update', elation.bind(this, this.refresh));
+            elation.events.add(textureLightmap, 'asset_update', elation.bind(this, this.refresh));
           }
 
           if (textureLightmap) {
@@ -468,10 +539,10 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         }
         if (emissivetextureasset) {
           textureEmissive = emissivetextureasset.getInstance();
-          if (!this.assetloadhandlers[emissive_image_id]) {
-            this.assetloadhandlers[emissive_image_id] = true;
+          if (!this.assetloadhandlers[textureEmissive.uuid]) {
+            this.assetloadhandlers[textureEmissive.uuid] = true;
             elation.events.add(emissivetextureasset, 'asset_load', elation.bind(this, this.setTextureDirty));
-            elation.events.add(textureEmissive, 'update', elation.bind(this, this.refresh));
+            elation.events.add(textureEmissive, 'asset_update', elation.bind(this, this.refresh));
           }
 
           if (textureEmissive) {
@@ -483,10 +554,10 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         roughnesstextureasset = this.getAsset('image', roughness_image_id);
         if (roughnesstextureasset) {
           textureRoughness = roughnesstextureasset.getInstance();
-          if (!this.assetloadhandlers[roughness_image_id]) {
-            this.assetloadhandlers[roughness_image_id] = true;
+          if (!this.assetloadhandlers[textureRoughness.uuid]) {
+            this.assetloadhandlers[textureRoughness.uuid] = true;
             elation.events.add(roughnesstextureasset, 'asset_load', elation.bind(this, this.setTextureDirty));
-            elation.events.add(textureRoughness, 'update', elation.bind(this, this.refresh));
+            elation.events.add(textureRoughness, 'asset_update', elation.bind(this, this.refresh));
           }
 
           if (textureRoughness) {
@@ -498,10 +569,10 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         metalnesstextureasset = this.getAsset('image', metalness_image_id);
         if (metalnesstextureasset) {
           textureMetalness = metalnesstextureasset.getInstance();
-          if (!this.assetloadhandlers[metalness_image_id]) {
-            this.assetloadhandlers[metalness_image_id] = true;
+          if (!this.assetloadhandlers[textureMetalness.uuid]) {
+            this.assetloadhandlers[textureMetalness.uuid] = true;
             elation.events.add(metalnesstextureasset, 'asset_load', elation.bind(this, this.setTextureDirty));
-            elation.events.add(textureMetalness, 'update', elation.bind(this, this.refresh));
+            elation.events.add(textureMetalness, 'asset_update', elation.bind(this, this.refresh));
           }
 
           if (textureMetalness) {
@@ -541,18 +612,7 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         //color.setRGB(col.x, col.y, col.z);
       }
 */
-      var srcfactors = {
-        'zero': THREE.ZeroFactor,
-        'one': THREE.OneFactor,
-        'src_color': THREE.SrcColorFactor,
-        'dst_color': THREE.DstColorFactor,
-        'src_alpha': THREE.SrcAlphaFactor,
-        'dst_alpha': THREE.DstAlphaFactor,
-        'one_minus_src_color': THREE.OneMinusSrcColorFactor,
-        'one_minus_src_alpha': THREE.OneMinusSrcAlphaFactor,
-        'one_minus_dst_color': THREE.OneMinusDstColorFactor,
-        'one_minus_dst_alpha': THREE.OneMinusDstAlphaFactor,
-      }
+      let srcfactors = this.blendFactorsMap;
       if (srcfactors[this.properties.blend_src]) {
         blend_src = srcfactors[this.properties.blend_src];
       }
@@ -560,8 +620,6 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         blend_dest = srcfactors[this.properties.blend_dest];
       }
 
-      this.extractAnimations(this.objects['3d']);
-
       var scene = this.engine.systems.world.scene['world-3d'];
       if (!this.hasalpha) this.hasalpha = {};
       var hasalpha = this.hasalpha;
@@ -595,6 +653,9 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
           if (this.depth_test !== null) {
             shadermaterial.depthTest = this.depth_test;
           }
+          if (this.color_write !== null) {
+            shadermaterial.colorWrite = this.color_write;
+          }
           this.traverseObjects((n) => {
             if (n.material) {
               if (Array.isArray(n.material)) {
@@ -661,13 +722,16 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
               //if (!color) m.color.setHex(0xffffff);
               m.map = texture;
               texture.encoding = THREE.sRGBEncoding;
-              elation.events.add(texture, 'asset_update', (ev) => {
-                m.map = ev.data;
-                this.updateTextureOffsets();
-                this.refresh();
-              });
+              if (false && !this.assetloadhandlers[texture.uuid]) {
+                this.assetloadhandlers[texture.uuid] = true;
+                elation.events.add(texture, 'asset_update', (ev) => {
+                  m.map = ev.data;
+                  this.updateTextureOffsets();
+                  this.refresh();
+                });
+              }
 
-              m.transparent = (textureasset && textureasset.hasalpha) || m.opacity < 1;
+              m.transparent = (this.transparent !== null ? this.transparent : (textureasset && textureasset.hasalpha) || m.opacity < 1);
             } else if (m.map && m.map.sourceFile) {
               var imagesrc = m.map.sourceFile;
               var asset = this.getAsset('image', imagesrc, true);
@@ -678,18 +742,21 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
                 }
                 m.map = asset.getInstance();
                 m.map.encoding = THREE.sRGBEncoding;
-                elation.events.add(m.map, 'asset_update', elation.bind(this, function(ev) {
-                  m.map = ev.data;
-                  this.updateTextureOffsets();
-                }));
-                elation.events.add(asset, 'asset_load', elation.bind(this, function(m, asset, ev) {
-                  if (asset.hasalpha && !m.transparent) {
-                    m.transparent = true;
-                    m.alphaTest = this.alphatest;
-                    //m.needsUpdate = true;
-                  }
-                  this.refresh();
-                }, m, asset));
+                if (!this.assetloadhandlers[m.map.uuid]) {
+                  this.assetloadhandlers[m.map.uuid] = true;
+                  elation.events.add(m.map, 'asset_update', elation.bind(this, function(ev) {
+                    m.map = ev.data;
+                    this.updateTextureOffsets();
+                  }));
+                  elation.events.add(asset, 'asset_load', elation.bind(this, function(m, asset, ev) {
+                    if (asset.hasalpha && !m.transparent) {
+                      m.transparent = true;
+                      m.alphaTest = this.alphatest;
+                      //m.needsUpdate = true;
+                    }
+                    this.refresh();
+                  }, m, asset));
+                }
               }
               if (m.map) {
                 this.assignTextureParameters(m.map, modelasset, asset);
@@ -701,11 +768,14 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
               if (asset) {
                 m.normalMap = asset.getInstance();
                 m.normalMap = asset.getInstance();
-                elation.events.add(m.normalMap, 'asset_update', elation.bind(this, function(ev) {
-                  m.normalMap = ev.data; this.refresh();
-                  this.updateTextureOffsets();
-                }));
-                elation.events.add(asset, 'asset_load', elation.bind(this, function(ev) { m.normalMap = ev.data; this.refresh(); }));
+                if (!this.assetloadhandlers[m.normalMap.uuid]) {
+                  this.assetloadhandlers[m.normalMap.uuid] = true;
+                  elation.events.add(m.normalMap, 'asset_update', elation.bind(this, function(ev) {
+                    m.normalMap = ev.data; this.refresh();
+                    this.updateTextureOffsets();
+                  }));
+                  elation.events.add(asset, 'asset_load', elation.bind(this, function(ev) { m.normalMap = ev.data; this.refresh(); }));
+                }
               }
             } else if (textureBump) {
               m.bumpMap = textureBump;
@@ -716,13 +786,16 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
               if (asset) {
                 m.normalMap = asset.getInstance();
                 m.normalMap = asset.getInstance();
-                elation.events.add(m.bumpMap, 'asset_update', elation.bind(this, function(ev) {
-                  m.normalMap = ev.data; this.refresh();
-                  m.normalMap.offset.copy(this.texture_offset);
-                  m.normalMap.repeat.copy(this.texture_repeat);
-                  m.normalMap.rotation = this.texture_rotation * THREE.Math.DEG2RAD;
-                }));
-                elation.events.add(asset, 'asset_load', elation.bind(this, function(ev) { m.normalMap = ev.data; this.refresh(); }));
+                if (!this.assetloadhandlers[m.normalMap.uuid]) {
+                  this.assetloadhandlers[m.normalMap.uuid] = true;
+                  elation.events.add(m.bumpMap, 'asset_update', elation.bind(this, function(ev) {
+                    m.normalMap = ev.data; this.refresh();
+                    m.normalMap.offset.copy(this.texture_offset);
+                    m.normalMap.repeat.copy(this.texture_repeat);
+                    m.normalMap.rotation = this.texture_rotation * THREE.Math.DEG2RAD;
+                  }));
+                  elation.events.add(asset, 'asset_load', elation.bind(this, function(ev) { m.normalMap = ev.data; this.refresh(); }));
+                }
               }
             }
             if (textureNormal) {
@@ -732,8 +805,11 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
               var asset = this.getAsset('image', imagesrc, {id: imagesrc, src: imagesrc, hasalpha: false});
               if (asset) {
                 m.normalMap = asset.getInstance();
-                elation.events.add(m.normalMap, 'asset_update', elation.bind(this, function(ev) { m.normalMap = ev.data; this.refresh(); }));
-                elation.events.add(asset, 'asset_load', elation.bind(this, function(ev) { m.normalMap = ev.data; this.refresh(); }));
+                if (!this.assetloadhandlers[m.normalMap.uuid]) {
+                  this.assetloadhandlers[m.normalMap.uuid] = true;
+                  elation.events.add(m.normalMap, 'asset_update', elation.bind(this, function(ev) { m.normalMap = ev.data; this.refresh(); }));
+                  elation.events.add(asset, 'asset_load', elation.bind(this, function(ev) { m.normalMap = ev.data; this.refresh(); }));
+                }
               }
             }
 
@@ -742,14 +818,20 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
                 m.lightMap = textureLightmap; 
               } else {
               }
-              elation.events.add(textureLightmap, 'asset_update', elation.bind(m, function(ev) { m.lightMap = ev.data; this.refresh(); }));
+              if (!this.assetloadhandlers[m.lightMap.uuid]) {
+                this.assetloadhandlers[m.lightMap.uuid] = true;
+                elation.events.add(textureLightmap, 'asset_update', elation.bind(m, function(ev) { m.lightMap = ev.data; this.refresh(); }));
+              }
             } else if (m.lightMap) {
               var imagesrc = m.lightMap.sourceFile;
-              var asset = this.getAsset('image', imagesrc, {id: imagesrc, src: imagesrc, hasalpha: false});
-              if (asset) {
-                m.lightMap = asset.getInstance();
-                elation.events.add(asset, 'asset_load', elation.bind(this, function(ev) { m.lightMap = ev.data; this.refresh();}));
-                elation.events.add(m.lightMap, 'asset_update', elation.bind(this, function(ev) { m.lightMap = ev.data; this.refresh(); }));
+              if (!this.assetloadhandlers[m.lightMap.uuid]) {
+                this.assetloadhandlers[m.lightMap.uuid] = true;
+                var asset = this.getAsset('image', imagesrc, {id: imagesrc, src: imagesrc, hasalpha: false});
+                if (asset) {
+                  m.lightMap = asset.getInstance();
+                  elation.events.add(asset, 'asset_load', elation.bind(this, function(ev) { m.lightMap = ev.data; this.refresh();}));
+                  elation.events.add(m.lightMap, 'asset_update', elation.bind(this, function(ev) { m.lightMap = ev.data; this.refresh(); }));
+                }
               }
             }
             if (textureDisplacement) {
@@ -807,6 +889,21 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
             if (this.depth_test !== null) {
               m.depthTest = this.depth_test;
             }
+            if (this.depth_func !== null) {
+              m.depthFunc = this.depthFuncMap[this.depth_func];
+            } else {
+              m.depthFunc = this.depthFuncMap['lessequal'];
+            }
+            if (this.depth_offset !== null) {
+              m.polygonOffset = true;
+              m.polygonOffsetUnits = 1;
+              m.polygonOffsetFactor = -this.depth_offset;
+            } else {
+              m.polygonOffset = false;
+            }
+            if (this.color_write !== null) {
+              m.colorWrite = this.color_write;
+            }
             // If our diffuse texture has an alpha channel, set up a customDepthMaterial / customDistanceMaterial to allow shadows to work
             if (m.map) { //this.shadow && m.transparent && m.map) {
               if (!n.customDepthMaterial) {
@@ -910,6 +1007,8 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         if (oldmat.color) {
           m.color.copy(oldmat.color);
         }
+        m.transmission = oldmat.transmission;
+        m.transmissionMap = oldmat.transmissionMap;
         m.transparent = m.opacity < 1;
         m.alphaTest = oldmat.alphaTest;
         m.skinning = oldmat.skinning;
@@ -918,10 +1017,18 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         if (oldmat.metalnessMap !== undefined) m.metalnessMap = oldmat.metalnessMap;
         if (oldmat.roughness !== undefined) m.roughness = oldmat.roughness;
         if (oldmat.roughnessMap !== undefined) m.roughnessMap = oldmat.roughnessMap;
-        if (oldmat.clearCoat !== undefined) m.clearCoat =  oldmat.clearCoar;
-        if (oldmat.clearCoatRoughness !== undefined) m.clearCoatRoughness = oldmat.clearCoatRoughness;
+        if (oldmat.clearcoat !== undefined) m.clearcoat =  oldmat.clearcoat;
+        if (oldmat.clearcoatMap !== undefined) m.clearcoatMap = oldmat.clearcoatMap;
+        if (oldmat.clearcoatRoughness !== undefined) m.clearcoatcoughness = oldmat.clearcoatRoughness;
+        if (oldmat.clearcoatRoughnessMap !== undefined) m.clearcoatRoughnessMap = oldmat.clearcoatRoughnessMap;
+        if (oldmat.clearcoatNormalMap !== undefined) m.clearcoatNormalMap = oldmat.clearcoatNormalMap;
+        if (oldmat.clearcoatNormalScale !== undefined) m.clearcoatNormalScale = oldmat.clearcoatNormalScale;
+        if (oldmat.attenuationTint !== undefined) m.attenuationTint = oldmat.attenuationTint;
+        if (oldmat.attenuationDistance !== undefined) m.attenuationDistance = oldmat.attenuationDistance;
+        if (oldmat.thickness !== undefined) m.thickness = oldmat.thickness;
+        if (oldmat.thicknessMap !== undefined) m.thicknessMap = oldmat.thicknessMap;
 
-        m.reflectivity = (oldmat.reflectivity !== undefined ? oldmat.reflectivity : .5);
+        //m.reflectivity = (oldmat.reflectivity !== undefined ? oldmat.reflectivity : .5);
 
         if (oldmat.roughnessMap !== undefined) {
           m.roughnessMap = oldmat.roughnessMap;
@@ -946,17 +1053,29 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         */
 
         if (this.shader_chunk_replace) {
-          let chunkreplace = this.shader_chunk_replace;
+          let chunkreplace = (elation.utils.isString(this.shader_chunk_replace) ? JSON.parse(this.shader_chunk_replace) : this.shader_chunk_replace);
           m.onBeforeCompile = function(shader) {
             for (let oldchunkname in chunkreplace) {
               let newchunkname = chunkreplace[oldchunkname];
               shader.vertexShader = shader.vertexShader.replace('#include <' + oldchunkname + '>', '#include <' + newchunkname + '>');
+              shader.fragmentShader = shader.fragmentShader.replace('#include <' + oldchunkname + '>', '#include <' + newchunkname + '>');
             }
           }
         }
       }
       return m;
     }
+    this.updateSkybox = function() {
+      let envMap = (this.isUsingPBR() ? this.getEnvmap() : null);
+      this.traverseObjects(n => {
+        if (n.material) {
+          let materials = (elation.utils.isArray(n.material) ? n.material : [n.material]);
+          materials.forEach(m => {
+            m.envMap = envMap;
+          });
+        }
+      });
+    }
     this.updateColor = function() {
       elation.engine.things.janusobject.extendclass.updateColor.call(this);
 
@@ -1253,6 +1372,41 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         this.video.volume = this.gain;
       }
     }
+    this.extractMorphTargets = function() {
+        this.objects['3d'].traverse(n => {
+          if (n.morphTargetDictionary && n.morphTargetInfluences && n.morphTargetInfluences.length > 0) {
+            this.morphtargets = n.morphTargetDictionary;
+            this.morphtargetInfluences = n.morphTargetInfluences;
+          }
+        });
+      }
+    this.setMorphTargetInfluence = function(name, value) {
+      if (typeof this.morphtargets == 'undefined') {
+        this.extractMorphTargets();
+      }
+
+      if (this.morphtargets && name in this.morphtargets) {
+        this.morphtargetInfluences[this.morphtargets[name]] = value;
+      }
+    }
+    this.applyPosition = function(pos) {
+      if (!this.modelasset) this.assignTextures();
+
+      let mat4 = new THREE.Matrix4().makeTranslation(+pos.x, +pos.y, +pos.z);
+      if (this.modelasset && this.modelasset.loaded) {
+        // FIXME - should we handle the case where the object is already loaded and we want to modify its origin?
+        //         Currently we do nothing, so we don't double-apply
+      } else {
+        elation.events.add(this.modelasset, 'asset_load', ev => {
+          this.objects['3d'].traverse(n => {
+            if (n instanceof THREE.Mesh) {
+              n.geometry.applyMatrix4(mat4);
+            }
+          });
+        });
+      }
+
+    }
     this.getProxyObject = function(classdef) {
       if (!this._proxyobject) {
         this._proxyobject = elation.engine.things.janusobject.extendclass.getProxyObject.call(this, classdef);
@@ -1280,8 +1434,12 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
           cull_face: [ 'property', 'cull_face' ],
           blend_src: [ 'property', 'blend_src' ],
           blend_dest: [ 'property', 'blend_dest' ],
+          blend_mode: [ 'property', 'blend_mode' ],
           depth_write: [ 'property', 'depth_write' ],
           depth_test: [ 'property', 'depth_test' ],
+          depth_offset: [ 'property', 'depth_offset' ],
+          depth_func: [ 'property', 'depth_func' ],
+          color_write: [ 'property', 'color_write' ],
 
           wireframe: [ 'property', 'wireframe'],
           fog: [ 'property', 'fog'],