janusweb 1.7.1 → 1.7.3

package/scripts/janusbase.js

@@ -278,6 +278,9 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
       this.refresh();
     } 
     this.summarizeXML = function() {
+      // Without a tag there's no valid element to emit; returning markup here
+      // would produce a malformed nameless tag (e.g. "< />").
+      if (!this.tag) return '';
       let proxy = this.getProxyObject(),
 
           propdefs = this._thingdef.properties,
@@ -287,7 +290,9 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
       for (let k in proxydefs) {
         let proxydef = proxydefs[k],
             propdef = elation.utils.arrayget(propdefs, proxydef[1]);
-        if ( k != 'room' && k != 'tagName' && k != 'classList' && proxydef[0] == 'property' && propdef) {
+        // jsid / classname are read-aliases of js_id / class; emitting them too
+        // would duplicate the attribute on every element.
+        if ( k != 'room' && k != 'tagName' && k != 'classList' && k != 'jsid' && k != 'classname' && proxydef[0] == 'property' && propdef) {
           let val = elation.utils.arrayget(this.properties, proxydef[1]);
           let defaultval = propdef.default;
           if (val instanceof THREE.Vector2) {
@@ -320,7 +325,16 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
           }
         }
       }
-      let xml = '<' + this.tag.toLowerCase();
+      let tagname = this.tag.toLowerCase();
+      // A property whose name matches the tag is the element's content, not an
+      // attribute (<text>foo</text>, never <text text="foo" />). This mirrors the
+      // network serializer (getChanges) so source, save, and wire formats agree.
+      let content = null;
+      if (tagname in attrs) {
+        content = attrs[tagname];
+        delete attrs[tagname];
+      }
+      let xml = '<' + tagname;
       for (let k in attrs) {
         xml += ' ' + k + '="' + attrs[k] + '"';
       }
@@ -330,13 +344,17 @@ elation.require(['engine.things.generic', 'utils.template', 'janusweb.parts'], f
           children.push(k);
         }
       }
+      let hascontent = (content !== null && content !== '');
       if (children.length > 0) {
         xml += '>\n';
+        if (hascontent) xml += '  ' + content + '\n';
         for (let i = 0; i < children.length; i++) {
           let k = children[i];
           xml += '  ' + this.children[k].summarizeXML().replace(/\n/g, '\n  ').replace(/\s*$/, '\n');
         }
-        xml += '</' + this.tag.toLowerCase() + '>\n';
+        xml += '</' + tagname + '>\n';
+      } else if (hascontent) {
+        xml += '>' + content + '</' + tagname + '>\n';
       } else {
         xml += ' />\n';
       }

package/scripts/janusweb.js

@@ -61,7 +61,7 @@ elation.require([
       this.defineProperties({
         url:            { type: 'string', default: false },
         homepage:       { type: 'string', default: "" },
-        corsproxy:      { type: 'string', default: '' },
+        corsproxy:      { type: 'string', default: false },
         showui:         { type: 'boolean', default: true },
         shownavigation: { type: 'boolean', default: true },
         showchat:       { type: 'boolean', default: true },
@@ -81,8 +81,19 @@ elation.require([
         this.bookmarks = elation.collection.indexed({index: 'url', storagekey: 'janusweb.bookmarks'});
       }
 
-      if (this.corsproxy != '') {
-        elation.engine.assets.setCORSProxy(this.corsproxy);
+      if (this.corsproxy !== false && this.corsproxy !== null && typeof this.corsproxy != 'undefined') {
+        // An explicit corsproxy attribute defines the full proxy set: a
+        // space-separated list becomes the rotation array, and the singular
+        // corsproxy is its first entry. The set is closed - the built-in
+        // proxy availability checks won't extend it. An empty or "false"
+        // value disables proxying entirely; omitting the attribute keeps
+        // the built-in defaults.
+        let corsproxies = (this.corsproxy === '' || this.corsproxy == 'false')
+          ? []
+          : String(this.corsproxy).split(' ').filter(url => url);
+        corsproxies.explicit = true;
+        elation.config.set('engine.assets.corsproxies', corsproxies);
+        elation.engine.assets.setCORSProxy(corsproxies[0] || '');
       }
       this.assetpack = elation.engine.assets.loadAssetPack(this.properties.datapath + 'assets.json', this.properties.datapath);
       this.parser = new JanusFireboxParser();
@@ -346,6 +357,16 @@ elation.require([
       return this.load(dataurl, makeactive, baseurl)
     }
     this.setActiveRoom = function(url, referrer, skipURLUpdate) {
+      // skip sameroom urls (otherwise it restarts audio when 
+      // activating portals to internal/sameroom objects like '#locationB' e.g.)
+      if( room && url.replace(/#.*/,'') == room.url ){ 
+        // XR Fragments spec (Level1: URL) https://xrfragment.org/#teleport%20camera
+        // update hash or assume 'spawn' as default spawn objectlocation
+        room.urlhash = url.match('#') ? url.replace(/.*#/,'') : 'spawn'
+        room.setPlayerPosition()
+        return 
+      }
+
       var oldroom = this.currentroom;
 
       var room = false;

package/scripts/object.js

@@ -83,6 +83,9 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         emissive_intensity: { type: 'float', default: 1, set: this.updateMaterial, comment: 'Intensity of material emissive color' },
         roughness: { type: 'float', default: null, min: 0, max: 1, set: this.updateMaterial, comment: 'Material roughness value' },
         metalness: { type: 'float', default: null, set: this.updateMaterial, comment: 'Material metalness value' },
+        sheen: { type: 'float', default: null, min: 0, max: 1, set: this.updateMaterial, comment: 'Sheen intensity (velvet/fabric); MeshPhysicalMaterial only' },
+        sheen_color: { type: 'color', default: null, set: this.updateMaterial, comment: 'Sheen tint colour' },
+        sheen_roughness: { type: 'float', default: null, min: 0, max: 1, set: this.updateMaterial, comment: 'Sheen roughness' },
         transmission: { type: 'float', default: 0, set: this.updateMaterial, comment: 'Material transmission value' },
         usevertexcolors: { type: 'boolean', default: true, set: this.updateMaterial },
         gain: { type: 'float', default: 1.0, set: this.updateAudioNodes },
@@ -901,6 +904,17 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
             if (this.transmission !== null) {
               m.transmission = this.transmission;
             }
+            // Sheen (velvet/fabric). MeshPhysicalMaterial only; m.sheen is undefined on other
+            // material types, so these are no-ops there. Attributes default to null (unset).
+            if (this.sheen !== null && m.sheen !== undefined) {
+              m.sheen = this.sheen;
+            }
+            if (this.sheen_roughness !== null && m.sheenRoughness !== undefined) {
+              m.sheenRoughness = this.sheen_roughness;
+            }
+            if (this.sheen_color && m.sheenColor) {
+              m.sheenColor.copy(this.sheen_color);
+            }
 
             if (this.isUsingPBR() && !this.isUsingToonShader()) {
               m.envMap = this.getEnvmap();
@@ -969,7 +983,9 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
             } else {
               m.vertexColors = false
             }
-            m.fog = this.fog;
+            if (!(m instanceof THREE.ShaderMaterial)) {
+              m.fog = this.fog;
+            }
             m.wireframe = this.wireframe;
           }
         } else if (n instanceof THREE.Light && !this.lights) {
@@ -1103,19 +1119,63 @@ elation.require(['janusweb.janusbase', 'janusweb.websurface'], function() {
         }
         */
 
-        if (this.shader_chunk_replace) {
-          let chunkreplace = (elation.utils.isString(this.shader_chunk_replace) ? JSON.parse(this.shader_chunk_replace) : this.shader_chunk_replace);
+        let chunkreplace = (this.shader_chunk_replace ? (elation.utils.isString(this.shader_chunk_replace) ? JSON.parse(this.shader_chunk_replace) : this.shader_chunk_replace) : null);
+        // Parallax-corrected (box-projected) envmap reflections: opt-in per room via
+        // envmap_parallax + envmap_box_center/size. Anchors reflections to a box (e.g.
+        // the box bottom = floor) rather than the default infinite/camera-centered
+        // projection, so a reflective floor mirrors the walls at the right world
+        // position. Box uniforms are shared per-room objects, so live edits to the box
+        // update every reflection without a recompile. Default off => stock behavior.
+        let parallax = (this.isUsingPBR() && this.room && this.room.envmap_parallax) ? this.room.getEnvmapParallaxUniforms() : null;
+        if (parallax) this.registerParallaxChunk();
+        if (chunkreplace || parallax) {
           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 + '>');
+            if (chunkreplace) {
+              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 + '>');
+              }
+            }
+            if (parallax) {
+              shader.uniforms.boxProjMin = parallax.boxProjMin;
+              shader.uniforms.boxProjMax = parallax.boxProjMax;
+              shader.uniforms.boxProjCenter = parallax.boxProjCenter;
+              shader.vertexShader = 'varying vec3 vParallaxWorldPos;\n' + shader.vertexShader.replace(
+                '#include <project_vertex>',
+                '#include <project_vertex>\n\tvParallaxWorldPos = ( modelMatrix * vec4( transformed, 1.0 ) ).xyz;'
+              );
+              shader.fragmentShader = shader.fragmentShader.replace(
+                '#include <envmap_physical_pars_fragment>',
+                '#include <envmap_physical_pars_fragment_parallax>'
+              );
             }
           };
         }
       }
       return m;
     }
+    this.registerParallaxChunk = function() {
+      // A box-projected variant of three's envmap_physical_pars_fragment: after the
+      // reflection vector is put into world space it's intersected with the box
+      // (boxProjMin..boxProjMax) and re-based on boxProjCenter, so the CubeUV/PMREM
+      // sample is parallax-corrected. Built by patching the stock chunk so it tracks
+      // the exact r150 source; if the source ever changes and the anchor line isn't
+      // found, this degrades to the stock (infinite) chunk rather than breaking.
+      if (THREE.ShaderChunk['envmap_physical_pars_fragment_parallax']) return;
+      let anchor = 'reflectVec = inverseTransformDirection( reflectVec, viewMatrix );';
+      let patched = THREE.ShaderChunk['envmap_physical_pars_fragment']
+        .replace('#if defined( USE_ENVMAP )',
+          '#if defined( USE_ENVMAP )\n\tuniform vec3 boxProjMin;\n\tuniform vec3 boxProjMax;\n\tuniform vec3 boxProjCenter;\n\tvarying vec3 vParallaxWorldPos;')
+        .replace(anchor, anchor +
+          '\n\t\t\t{ vec3 nrd = normalize( reflectVec );' +
+          '\n\t\t\t  vec3 rbmax = ( boxProjMax - vParallaxWorldPos ) / nrd;' +
+          '\n\t\t\t  vec3 rbmin = ( boxProjMin - vParallaxWorldPos ) / nrd;' +
+          '\n\t\t\t  vec3 rbmm = vec3( ( nrd.x > 0.0 ) ? rbmax.x : rbmin.x, ( nrd.y > 0.0 ) ? rbmax.y : rbmin.y, ( nrd.z > 0.0 ) ? rbmax.z : rbmin.z );' +
+          '\n\t\t\t  float fa = min( min( rbmm.x, rbmm.y ), rbmm.z );' +
+          '\n\t\t\t  reflectVec = ( vParallaxWorldPos + nrd * fa ) - boxProjCenter; }');
+      THREE.ShaderChunk['envmap_physical_pars_fragment_parallax'] = patched;
+    }
     this.updateSkybox = function() {
       let envMap = (this.isUsingPBR() ? this.getEnvmap() : null);
       this.traverseObjects(n => {

package/scripts/room.js

@@ -55,6 +55,13 @@ elation.require([
         'skybox_back_id': { type: 'string', set: this.setSkybox },
         'cubemap_irradiance_id': { type: 'string' },
         'cubemap_radiance_id': { type: 'string' },
+        // Envmap reflection projection. Default off = infinite (camera-centered)
+        // projection. When on, reflections are box-projected (parallax-corrected) to
+        // the box defined by envmap_box_center/size -- put the box bottom at the floor
+        // for clean floor reflections of the walls.
+        'envmap_parallax': { type: 'boolean', default: false, set: this.updateParallax },
+        'envmap_box_center': { type: 'vector3', default: new THREE.Vector3(0, 0, 0), set: this.updateParallax },
+        'envmap_box_size': { type: 'vector3', default: new THREE.Vector3(10, 10, 10), set: this.updateParallax },
         'fog': { type: 'boolean', default: false, set: this.setFog },
         'fog_mode': { type: 'string', default: 'exp', set: this.setFog },
         'fog_density': { type: 'float', default: 1.0, set: this.setFog },
@@ -326,6 +333,35 @@ elation.require([
       }
       return spawnpoint;
     }
+    // Shared box-projection uniforms for parallax-corrected envmap reflections. One
+    // set of THREE uniform objects per room; every PBR material's parallax shader
+    // references these same objects, so live edits to envmap_box_center/size update
+    // all reflections in place (no material recompile). See object.registerParallaxChunk.
+    this.getEnvmapParallaxUniforms = function() {
+      if (!this._parallaxUniforms) {
+        this._parallaxUniforms = {
+          boxProjMin: { value: new THREE.Vector3() },
+          boxProjMax: { value: new THREE.Vector3() },
+          boxProjCenter: { value: new THREE.Vector3() },
+        };
+      }
+      this.updateParallaxUniforms();
+      return this._parallaxUniforms;
+    }
+    this.updateParallaxUniforms = function() {
+      if (!this._parallaxUniforms) return;
+      let c = this.envmap_box_center || new THREE.Vector3();
+      let s = this.envmap_box_size || new THREE.Vector3(10, 10, 10);
+      this._parallaxUniforms.boxProjCenter.value.copy(c);
+      this._parallaxUniforms.boxProjMin.value.set(c.x - s.x / 2, c.y - s.y / 2, c.z - s.z / 2);
+      this._parallaxUniforms.boxProjMax.value.set(c.x + s.x / 2, c.y + s.y / 2, c.z + s.z / 2);
+    }
+    this.updateParallax = function() {
+      // Live box edits mutate the shared uniforms in place -> all reflections follow
+      // without a recompile. (Enabling/disabling envmap_parallax itself is applied at
+      // material-build time / room load.)
+      this.updateParallaxUniforms();
+    }
     this.setSkybox = function() {
       if (!this.loaded) return;
 
@@ -818,24 +854,48 @@ elation.require([
             room[k] = val;
           }
         }
-        if (roomdata.object) {
-          for (let i = 0; i < roomdata.object.length; i++) {
-            let objdata = roomdata.object[i];
+        // Apply edits to every element type, not just <Object>. The parser groups
+        // <text>, <image>, <link>, etc. under their own keys, so iterating only
+        // `roomdata.object` silently dropped source edits to all other elements.
+        var skiptypes = ['assets', 'room', 'source'];
+        for (let type in roomdata) {
+          if (skiptypes.indexOf(type) != -1) continue;
+          let objs = roomdata[type];
+          if (!elation.utils.isArray(objs)) objs = [objs];
+          for (let i = 0; i < objs.length; i++) {
+            let objdata = objs[i];
             let roomobj = room.objects[objdata.js_id];
             if (roomobj) {
               for (let k in objdata) {
+                // `orientation` is derived by the parser from xdir/ydir/zdir and
+                // defaults to identity when only `rotation` is authored, so it
+                // disagrees with `rotation`. Applying both fights; the authored
+                // rotation / direction attributes are what drive orientation.
+                if (k === 'orientation' || k === '_content') continue;
                 let val = objdata[k];
-                if (roomobj[k] != objdata[k] && val !== null) {
+                if (roomobj[k] != val && val !== null) {
+                  // Flag dirty so source edits broadcast to other clients; set
+                  // per change because onThingChange clears sync once tracked.
+                  roomobj.sync = true;
                   roomobj[k] = val;
                 }
               }
+              // Elements that carry their value as tag content (<text>foo</text>)
+              // parse to `_content`; the receiving property is named after the tag.
+              if (objdata._content != null && roomobj[type] != objdata._content) {
+                roomobj.sync = true;
+                roomobj[type] = objdata._content;
+              }
             } else {
               objdata.persist = true;
-              this.createObject('object', objdata);
+              if (objdata._content != null && objdata[type] == null) objdata[type] = objdata._content;
+              this.createObject(type, objdata);
             }
           }
         }
       }
+      // Editor surfaces (scene tree, inspector, source view) refresh from this.
+      this.notifySceneChanged();
     }
 
     this.loadRoomAssets = function(roomdata) {
@@ -988,7 +1048,11 @@ elation.require([
 
         if (room.cubemap_radiance_id) this.properties.cubemap_radiance_id = room.cubemap_radiance_id;
         if (room.cubemap_irradiance_id) this.properties.cubemap_irradiance_id = room.cubemap_irradiance_id;
-    
+
+        if (typeof room.envmap_parallax != 'undefined') this.envmap_parallax = room.envmap_parallax;
+        if (room.envmap_box_center) this.envmap_box_center = room.envmap_box_center;
+        if (room.envmap_box_size) this.envmap_box_size = room.envmap_box_size;
+
         this.setSkybox();
 
         if (room.server) this.properties.server = room.server;
@@ -1282,6 +1346,9 @@ elation.require([
       this.applyingEdits = false;
       this.appliedchanges = {};
 
+      // Editor surfaces reflect remote edits (onThingChange is gated out while
+      // applyingEdits, so signal here instead).
+      this.notifySceneChanged();
     }
     this.applyDeleteXML = function(deletexml) {
       var del = elation.utils.parseXML(deletexml);
@@ -1913,6 +1980,18 @@ elation.require([
         soundsystem.enableSound();
       }
     }
+    // Room-level "scene changed" signal that editor surfaces subscribe to
+    // (source-view auto-refresh, scene-tree/inspector reflect). Trailing-
+    // debounced so a gizmo drag or burst of edits coalesces into one fire on
+    // settle. Only the edit paths call it, so animation/physics ticks never
+    // reach here; structural changes are signalled via thing_add/thing_remove.
+    this.notifySceneChanged = function() {
+      clearTimeout(this._sceneChangedTimer);
+      this._sceneChangedTimer = setTimeout(elation.bind(this, function() {
+        // Fire on the proxy (window.room) since editor surfaces listen there.
+        elation.events.fire({type: 'scene_changed', element: this.getProxyObject()});
+      }), 150);
+    }
     this.onThingChange = function(ev) {
       if (this.applyingEdits) return;
 
@@ -1928,6 +2007,7 @@ elation.require([
             this.changes[js_id] = proxy;
           }
           thing.properties.sync = proxy.autosync;
+          this.notifySceneChanged();  // a real edit (sync set) -> refresh editor surfaces
         }
       }
     }
@@ -1945,6 +2025,7 @@ elation.require([
       if (this.jsobjects[thing.js_id]) {
         delete this.jsobjects[thing.js_id];
       }
+      this.notifySceneChanged();
     }
     this.onRoomEdit = function(ev) {
       var thing = ev.data;
@@ -2184,6 +2265,9 @@ elation.require([
           skybox_down_id: ['property', 'skybox_down_id'],
           skybox_front_id:['property', 'skybox_front_id'],
           skybox_back_id: ['property', 'skybox_back_id'],
+          envmap_parallax: ['property', 'envmap_parallax'],
+          envmap_box_center: ['property', 'envmap_box_center'],
+          envmap_box_size: ['property', 'envmap_box_size'],
 
           pendingScripts: ['property', 'pendingScripts'],
           pendingCustomElements: ['property', 'pendingCustomElements'],
@@ -2590,7 +2674,11 @@ elation.require([
       //for (var k in this.jsobjects) {
       for (let k in this.children) {
         var object = this.children[k];
-        if (object.janus && typeof object.summarizeXML == 'function') {
+        // Only persistent room objects belong in the source. Transient children
+        // (the local player, remote-player ghosts, cursors) are not part of the
+        // room markup and have no JanusML tag, so serializing them would emit
+        // malformed nameless tags.
+        if (object.persist && object.janus && typeof object.summarizeXML == 'function') {
           var markup = '    ' + object.summarizeXML().replace(/\n/g, '\n    ').replace(/\s*$/, '\n');
           objectsrc += markup;
         }
@@ -2603,6 +2691,24 @@ elation.require([
 
       return roomsrc;
     }
+    // Per-object serialization of the persistent top-level objects, for editors
+    // that reconcile an authored source against the live scene without
+    // regenerating the whole document.
+    this.getObjectSummaries = function() {
+      var out = [];
+      for (let k in this.children) {
+        var object = this.children[k];
+        if (object.persist && object.janus && typeof object.summarizeXML == 'function' && object.tag) {
+          out.push({
+            js_id: object.js_id,
+            id: object.id,
+            name: String(object.tag).toLowerCase(),
+            xml: object.summarizeXML().replace(/\s+$/, '')
+          });
+        }
+      }
+      return out;
+    }
 
     // FIXME - room should inherit from janusbase and get this automatically
     this.addEventListenerProxy = function(name, handler, bubble) {

package/media/assets/webui/apps/xrfragment/patch/metaquest-fix-flickering.js

@@ -1,15 +0,0 @@
-// Meta Quest 2 results in rapid flickering when loading a new room
-// therefore we show the shroud while loading
-setActiveRoom = room.janus.setActiveRoom.bind(room.janus)
-room.janus.setActiveRoom = function(url,referer,skipURL){
-  if( url.replace(/#.*/,'') != room.url ){
-    room.fadeAudioOut()
-    setTimeout( function(){ 
-      setActiveRoom.apply(room.janus, [url, referer, skipURL])
-    }, 500)
-  }else{ 
-    room.urlhash = url.match('#') ? url.replace(/.*#/,'') : 'spawn'
-    room.setPlayerPosition()
-    // ignore same-room setActiveRoom-calls (it restarts audio when clicking internal hyperlinks)
-  }
-}