x_ite 8.6.6 → 8.6.8

package/src/assets/shaders/webgl2/include/Particle.glsl.js

@@ -1,11 +1,11 @@
 export default /* glsl */ `
 #if defined (X3D_PARTICLE_SYSTEM)
-
-in vec4 x3d_Particle;
-in mat4 x3d_ParticleMatrix;
+#if defined (X3D_TEX_COORD_RAMP)
 
 uniform sampler2D x3d_TexCoordRamp;
 
+in vec4 x3d_Particle;
+
 vec4
 texelFetch (const in sampler2D sampler, const in int index, const in int lod)
 {
@@ -16,7 +16,6 @@ texelFetch (const in sampler2D sampler, const in int index, const in int lod)
    return t;
 }
 
-#if defined (X3D_TEX_COORD_RAMP)
 vec4
 getTexCoord (const in vec4 texCoord)
 {
@@ -27,9 +26,11 @@ getTexCoord (const in vec4 texCoord)
    return texelFetch (x3d_TexCoordRamp, index0 + map [gl_VertexID % 6], 0);
 }
 #else
-   #define getTexCoord(texCoord) texCoord
+   #define getTexCoord(texCoord) (texCoord)
 #endif
 
+in mat4 x3d_ParticleMatrix;
+
 vec4
 getVertex (const in vec4 vertex)
 {
@@ -37,9 +38,7 @@ getVertex (const in vec4 vertex)
 }
 
 #else
-
-#define getVertex(vertex) (vertex)
-#define getTexCoord(texCoord) (texCoord)
-
+   #define getVertex(vertex) (vertex)
+   #define getTexCoord(texCoord) (texCoord)
 #endif
 `;

package/src/standard/Math/Numbers/Color3.js

@@ -47,7 +47,7 @@
 
 import Algorithm from "../Algorithm.js";
 
-const clamp = Algorithm .clamp;
+const { clamp, interval, degrees } = Algorithm;
 
 const
    _r = Symbol .for ("X_ITE.Color3.r"),
@@ -157,7 +157,7 @@ Color3 .prototype =
       }
       else
       {
-         const w = Algorithm .degrees (Algorithm .interval (h, 0, Math .PI * 2)) / 60;     // sector 0 to 5
+         const w = degrees (interval (h, 0, Math .PI * 2)) / 60;     // sector 0 to 5
 
          const i = Math .floor (w);
          const f = w - i;                      // factorial part of h

package/src/standard/Math/Numbers/Color4.js

@@ -48,7 +48,7 @@
 import Color3    from "./Color3.js";
 import Algorithm from "../Algorithm.js";
 
-const clamp = Algorithm .clamp;
+const { clamp } = Algorithm;
 
 const
    _r = Symbol .for ("X_ITE.Color3.r"),

package/src/standard/Utility/ObjectCache.js

@@ -47,27 +47,26 @@
 
 function ObjectCache (Type)
 {
-   const stack = [ ];
-
-   return {
-      size: 0,
+   return Object .assign ([ ],
+   {
+      top: 0,
       pop: function ()
       {
-         if (this .size !== 0)
-            return stack [-- this .size];
+         if (this .top !== 0)
+            return this [-- this .top];
 
          return new Type ();
       },
       push: function (object)
       {
-         stack [this .size ++] = object;
+         this [this .top ++] = object;
       },
       clear: function ()
       {
-         stack .length = 0;
-         this .size    = 0;
+         this .length = 0;
+         this .top    = 0;
       },
-   };
+   });
 }
 
 export default ObjectCache;

package/src/x_ite/Browser/Networking/URLs.js

@@ -86,6 +86,10 @@ const URLs = {
    {
       return new URL ("assets/hatching/" + index + ".png", this .getScriptUrl ()) .href;
    },
+   getLibUrl: function (file)
+   {
+      return new URL ("assets/lib/" + file, this .getScriptUrl ()) .href;
+   },
 };
 
 export default URLs;

package/src/x_ite/Browser/Picking/X3DPickingContext.js

@@ -111,7 +111,7 @@ X3DPickingContext .prototype =
    {
       this [_pickingTime] .start ();
 
-      this .getWorld () .traverse (TraverseType .PICKING, null);
+      this .getWorld () .traverse (TraverseType .PICKING);
 
       for (const transformSensorNode of this [_transformSensorNodes])
       {

package/src/x_ite/Browser/PointingDeviceSensor/X3DPointingDeviceSensorContext.js

@@ -220,7 +220,7 @@ X3DPointingDeviceSensorContext .prototype =
       this [_pointer] .set (x, y);
       this [_pointingBuffer] .bind ();
 
-      this .getWorld () .traverse (TraverseType .POINTER, null);
+      this .getWorld () .traverse (TraverseType .POINTER);
 
       this [_pointingBuffer] .getHit (hit);
       this [_pointingBuffer] .unbind ();

package/src/x_ite/Browser/VERSION.js

@@ -45,4 +45,4 @@
  *
  ******************************************************************************/
 
-export default "8.6.6";
+export default "8.6.8";

package/src/x_ite/Browser/X3DBrowser.js

@@ -871,6 +871,13 @@ Object .defineProperty (X3DBrowser .prototype, "version",
    configurable: false
 });
 
+Object .defineProperty (X3DBrowser .prototype, "providerUrl",
+{
+   get: function () { return this .getProviderUrl (); },
+   enumerable: true,
+   configurable: false
+});
+
 Object .defineProperty (X3DBrowser .prototype, "currentFrameRate",
 {
    get: function () { return this .getCurrentFrameRate (); },

package/src/x_ite/Browser/X3DBrowserContext.js

@@ -276,7 +276,7 @@ X3DBrowserContext .prototype = Object .assign (Object .create (X3DBaseNode .prot
       // Camera
 
       this [_cameraTime] .start ();
-      this [_world] .traverse (TraverseType .CAMERA, null);
+      this [_world] .traverse (TraverseType .CAMERA);
       this [_cameraTime] .stop ();
 
       // Collision
@@ -284,7 +284,7 @@ X3DBrowserContext .prototype = Object .assign (Object .create (X3DBaseNode .prot
       this [_collisionTime] .start ();
 
       if (this .getCollisionCount ())
-         this [_world] .traverse (TraverseType .COLLISION, null);
+         this [_world] .traverse (TraverseType .COLLISION);
 
       this [_collisionTime] .stop ();
 
@@ -304,7 +304,7 @@ X3DBrowserContext .prototype = Object .assign (Object .create (X3DBaseNode .prot
       gl .clearColor (0, 0, 0, 0);
       gl .clear (gl .COLOR_BUFFER_BIT);
 
-      this [_world] .traverse (TraverseType .DISPLAY, null);
+      this [_world] .traverse (TraverseType .DISPLAY);
 
       this .getFrameBuffer () .blit ();
 

package/src/x_ite/Components/Interpolation/SquadOrientationInterpolator.js

@@ -68,13 +68,12 @@ SquadOrientationInterpolator .prototype = Object .assign (Object .create (X3DInt
 {
    constructor: SquadOrientationInterpolator,
    [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",          new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOnly,   "set_fraction",      new Fields .SFFloat ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "closed",            new Fields .SFBool ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "key",               new Fields .MFFloat ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "keyValue",          new Fields .MFRotation ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "normalizeVelocity", new Fields .SFBool ()),
-      new X3DFieldDefinition (X3DConstants .outputOnly,  "value_changed",     new Fields .SFRotation ()),
+      new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",      new Fields .SFNode ()),
+      new X3DFieldDefinition (X3DConstants .inputOnly,   "set_fraction",  new Fields .SFFloat ()),
+      new X3DFieldDefinition (X3DConstants .inputOutput, "closed",        new Fields .SFBool ()),
+      new X3DFieldDefinition (X3DConstants .inputOutput, "key",           new Fields .MFFloat ()),
+      new X3DFieldDefinition (X3DConstants .inputOutput, "keyValue",      new Fields .MFRotation ()),
+      new X3DFieldDefinition (X3DConstants .outputOnly,  "value_changed", new Fields .SFRotation ()),
    ]),
    getTypeName: function ()
    {

package/src/x_ite/Components/Layering/X3DLayerNode.js

@@ -258,10 +258,8 @@ X3DLayerNode .prototype = Object .assign (Object .create (X3DNode .prototype),
       if (viewpointNode ._viewAll .getValue ())
          viewpointNode .viewAll (this .getBBox (new Box3 ()));
    },
-   traverse: function (type, renderObject)
+   traverse: function (type, renderObject = this)
    {
-      renderObject = renderObject || this;
-
       const viewpointNode = this .getViewpoint ();
 
       this .getProjectionMatrix ()  .pushMatrix (viewpointNode .getProjectionMatrix (this));

package/src/x_ite/Components/Navigation/OrthoViewpoint.js

@@ -248,7 +248,7 @@ OrthoViewpoint .prototype = Object .assign (Object .create (X3DViewpointNode .pr
    },
    getMaxFarValue: function ()
    {
-      return 1e5;
+      return 1e4;
    },
    getScreenScale: function (point, viewport, screenScale)
    {

package/src/x_ite/Parser/GLTF2Parser.js

@@ -47,15 +47,14 @@
 
 import X3DParser    from "./X3DParser.js";
 import X3DOptimizer from "./X3DOptimizer.js";
+import URLs         from "../Browser/Networking/URLs.js";
 import Vector2      from "../../standard/Math/Numbers/Vector2.js";
 import Vector3      from "../../standard/Math/Numbers/Vector3.js";
 import Quaternion   from "../../standard/Math/Numbers/Quaternion.js";
 import Rotation4    from "../../standard/Math/Numbers/Rotation4.js";
-import Matrix3      from "../../standard/Math/Numbers/Matrix3.js";
 import Matrix4      from "../../standard/Math/Numbers/Matrix4.js";
 import Color3       from "../../standard/Math/Numbers/Color3.js";
 import Color4       from "../../standard/Math/Numbers/Color4.js";
-import Box3         from "../../standard/Math/Geometry/Box3.js";
 import Algorithm    from "../../standard/Math/Algorithm.js";
 import DEBUG        from "../DEBUG.js"
 
@@ -79,7 +78,7 @@ function GLTF2Parser (scene)
 
    // Globals
 
-   this .extensionsUsed        = new Set ();
+   this .extensions            = new Set ();
    this .lights                = [ ];
    this .usedLights            = 0;
    this .buffers               = [ ];
@@ -182,13 +181,17 @@ GLTF2Parser .prototype = Object .assign (Object .create (X3DParser .prototype),
 
       // Parse root objects.
 
-      this .assetObject          (glTF .asset);
-      this .extensionsUsedObject (glTF .extensionsUsed);
-      this .extensionsObject     (glTF .extensions);
+      this .assetObject      (glTF .asset);
+      this .extensionsArray  (glTF .extensionsUsed, this .extensions);
+      this .extensionsArray  (glTF .extensionsRequired, this .extensions);
+      this .extensionsObject (glTF .extensions);
 
       await this .loadComponents ();
       await this .buffersArray (glTF .buffers);
 
+      if (this .extensions .has ("KHR_draco_mesh_compression"))
+         this .draco = await this .createDraco ();
+
       this .bufferViewsArray (glTF .bufferViews);
       this .accessorsArray   (glTF .accessors);
       this .samplersArray    (glTF .samplers);
@@ -249,19 +252,19 @@ GLTF2Parser .prototype = Object .assign (Object .create (X3DParser .prototype),
 
       scene .getRootNodes () .push (worldInfoNode);
    },
-   extensionsUsedObject: function (extensionsUsed)
+   extensionsArray: function (extensions, set)
    {
-      if (!(extensionsUsed instanceof Array))
+      if (!(extensions instanceof Array))
          return;
 
       const
          browser = this .getBrowser (),
          scene   = this .getExecutionContext ();
 
-      this .extensionsUsed = new Set (extensionsUsed);
-
-      for (const extension of extensionsUsed)
+      for (const extension of extensions)
       {
+         set .add (extension);
+
          switch (extension)
          {
             case "KHR_texture_transform":
@@ -312,8 +315,10 @@ GLTF2Parser .prototype = Object .assign (Object .create (X3DParser .prototype),
          scene = this .getExecutionContext (),
          name  = this .sanitizeName (light .name);
 
-      if (light .color instanceof Array)
-         lightNode ._color = new Color3 (... light .color);
+      const color = new Color3 (1, 1, 1);
+
+      if (this .vectorValue (light .color, color))
+         lightNode ._color = color;
 
       lightNode ._intensity = this .numberValue (light .intensity, 1);
 
@@ -375,20 +380,21 @@ GLTF2Parser .prototype = Object .assign (Object .create (X3DParser .prototype),
 
       this .buffers = await Promise .all (buffers .map ((buffer, i) => this .bufferObject (buffer, i)));
    },
-   bufferObject: function (buffer, i)
+   bufferObject: async function (buffer, i)
    {
       if (!(buffer instanceof Object))
          return;
 
       if (!buffer .uri)
-         return Promise .resolve (this .buffers [i]);
+         return this .buffers [i];
 
-      const url = new URL (buffer .uri, this .getExecutionContext () .getWorldURL ());
+      const
+         url         = new URL (buffer .uri, this .getExecutionContext () .getWorldURL ()),
+         response    = await fetch (url),
+         blob        = await response .blob (),
+         arrayBuffer = await blob .arrayBuffer ();
 
-      return fetch (url)
-         .then (response => response .blob ())
-         .then (blob => blob .arrayBuffer ())
-         .then (arrayBuffer => $.ungzip (arrayBuffer));
+      return $.ungzip (arrayBuffer);
    },
    bufferViewsArray: function (bufferViews)
    {
@@ -459,7 +465,7 @@ GLTF2Parser .prototype = Object .assign (Object .create (X3DParser .prototype),
             {
                const
                   TypedArray = TypedArrays .get (accessor .componentType),
-                  bufferView = this .bufferViews [accessor .bufferView],
+                  bufferView = this .bufferViews [accessor .bufferView || 0],
                   byteOffset = accessor .byteOffset || 0,
                   byteStride = bufferView .byteStride || 0,
                   components = Components .get (accessor .type),
@@ -921,14 +927,14 @@ GLTF2Parser .prototype = Object .assign (Object .create (X3DParser .prototype),
       if (!(KHR_materials_emissive_strength instanceof Object))
          return;
 
-      materialNode ._emissiveStrength = this .numberValue( KHR_materials_emissive_strength .emissiveStrength, 1);
+      materialNode ._emissiveStrength = this .numberValue (KHR_materials_emissive_strength .emissiveStrength, 1);
    },
    textureTransformObject: function (KHR_texture_transform, mapping)
    {
       if (!(KHR_texture_transform instanceof Object))
          return;
 
-      if (!this .extensionsUsed .has ("KHR_texture_transform"))
+      if (!this .extensions .has ("KHR_texture_transform"))
          return;
 
       const
@@ -1009,6 +1015,8 @@ GLTF2Parser .prototype = Object .assign (Object .create (X3DParser .prototype),
       primitive .indices  = this .accessors [primitive .indices];
       primitive .material = this .materials [primitive .material];
 
+      this .primitiveExtensionsObject (primitive .extensions, primitive)
+
       shapeNodes .push (this .createShape (primitive));
    },
    attributesObject: function (attributes)
@@ -1016,32 +1024,176 @@ GLTF2Parser .prototype = Object .assign (Object .create (X3DParser .prototype),
       if (!(attributes instanceof Object))
          return;
 
-      attributes .TANGENT  = this .accessors [attributes .TANGENT];
-      attributes .NORMAL   = this .accessors [attributes .NORMAL];
-      attributes .POSITION = this .accessors [attributes .POSITION];
+      for (const key in attributes)
+         attributes [key] = this .accessors [attributes [key]];
 
       attributes .TEXCOORD = [ ];
       attributes .COLOR    = [ ];
       attributes .JOINTS   = [ ];
       attributes .WEIGHTS  = [ ];
 
-      for (let i = 0; Number .isInteger (attributes ["TEXCOORD_" + i]); ++ i)
-         attributes .TEXCOORD .push (this .accessors [attributes ["TEXCOORD_" + i]]);
+      for (let i = 0; attributes ["TEXCOORD_" + i]; ++ i)
+         attributes .TEXCOORD .push (attributes ["TEXCOORD_" + i]);
 
-      for (let i = 0; Number .isInteger (attributes ["COLOR_" + i]); ++ i)
-         attributes .COLOR .push (this .accessors [attributes ["COLOR_" + i]]);
+      for (let i = 0; attributes ["COLOR_" + i]; ++ i)
+         attributes .COLOR .push (attributes ["COLOR_" + i]);
 
-      for (let i = 0; Number .isInteger (attributes ["JOINTS_" + i]); ++ i)
-         attributes .JOINTS .push (this .accessors [attributes ["JOINTS_" + i]]);
+      for (let i = 0; attributes ["JOINTS_" + i]; ++ i)
+         attributes .JOINTS .push (attributes ["JOINTS_" + i]);
 
-      for (let i = 0; Number .isInteger (attributes ["WEIGHTS_" + i]); ++ i)
-         attributes .WEIGHTS .push (this .accessors [attributes ["WEIGHTS_" + i]]);
+      for (let i = 0; attributes ["WEIGHTS_" + i]; ++ i)
+         attributes .WEIGHTS .push (attributes ["WEIGHTS_" + i]);
    },
    targetsArray: function (targets)
    {
       if (!(targets instanceof Array))
          return;
    },
+   primitiveExtensionsObject: function (extensions, primitive)
+   {
+      if (!(extensions instanceof Object))
+         return;
+
+      for (const [key, value] of Object .entries (extensions))
+      {
+         switch (key)
+         {
+            case "KHR_draco_mesh_compression":
+               return this .khrDracoMeshCompressionObject (value, primitive);
+         }
+      }
+   },
+   khrDracoMeshCompressionObject: function (draco, primitive)
+   {
+      if (!(draco instanceof Object))
+         return;
+
+      if (!this .draco)
+         return;
+
+      function indicesCallback (array)
+      {
+         Object .defineProperty (primitive .indices, "array", { value: array });
+      }
+
+      function attributeCallback (key, array)
+      {
+         if (attributes [key])
+            Object .defineProperty (attributes [key], "array", { value: array });
+      }
+
+      const
+         attributes = primitive .attributes,
+         dataView   = new Uint8Array (this .bufferViews [draco .bufferView] .buffer);
+
+      this .dracoDecodeMesh (this .draco, dataView, draco .attributes, indicesCallback, attributeCallback);
+   },
+   dracoDecodeMesh: function (draco, dataView, attributes, indicesCallback, attributeCallback)
+   {
+      const
+         buffer  = new draco .DecoderBuffer (),
+         decoder = new draco .Decoder ();
+
+      buffer .Init (dataView, dataView .byteLength);
+
+      let geometry, status;
+
+      try
+      {
+         const type = decoder .GetEncodedGeometryType (buffer);
+
+         switch (type)
+         {
+            case draco .TRIANGULAR_MESH:
+               geometry = new draco .Mesh ();
+               status   = decoder .DecodeBufferToMesh (buffer, geometry);
+               break;
+            case draco .POINT_CLOUD:
+               geometry = new draco .PointCloud ();
+               status   = decoder .DecodeBufferToPointCloud (buffer, geometry);
+               break;
+            default:
+               throw new Error (`Invalid geometry type ${type}.`);
+         }
+
+         if (!status .ok () || !geometry .ptr)
+            throw new Error (status .error_msg ());
+
+         if (type === draco .TRIANGULAR_MESH)
+         {
+            const
+               numFaces   = geometry .num_faces (),
+               numIndices = numFaces * 3,
+               byteLength = numIndices * 4,
+               ptr        = draco ._malloc (byteLength);
+
+            try
+            {
+               const indices = new Uint32Array (numIndices);
+
+               decoder .GetTrianglesUInt32Array (geometry, byteLength, ptr);
+
+               indices .set (new Uint32Array (draco .HEAPF32 .buffer, ptr, numIndices));
+
+               indicesCallback (indices);
+            }
+            finally
+            {
+               draco ._free (ptr);
+            }
+         }
+
+         for (const [key, id] of Object .entries (attributes))
+         {
+            const
+               attribute     = decoder .GetAttributeByUniqueId (geometry, id),
+               numComponents = attribute .num_components (),
+               numPoints     = geometry .num_points (),
+               numValues     = numPoints * numComponents,
+               byteLength    = numValues * Float32Array .BYTES_PER_ELEMENT,
+               ptr           = draco ._malloc (byteLength);
+
+            try
+            {
+               const array = new Float32Array (numValues);
+
+               decoder .GetAttributeDataArrayForAllPoints (geometry, attribute, draco .DT_FLOAT32, byteLength, ptr);
+
+               array .set (new Float32Array (draco .HEAPF32 .buffer, ptr, numValues));
+
+               attributeCallback (key, array);
+            }
+            finally
+            {
+               draco ._free (ptr);
+            }
+         }
+      }
+      finally
+      {
+         if (geometry)
+            draco .destroy (geometry);
+
+         draco .destroy (decoder);
+         draco .destroy (buffer);
+      }
+   },
+   createDraco: async function ()
+   {
+      if (this .constructor .draco)
+      {
+         return this .constructor .draco;
+      }
+      else
+      {
+         const
+            response = await fetch (URLs .getLibUrl ("draco_decoder_gltf.js")),
+            text     = await response .text (),
+            draco    = await new Function (text) () ();
+
+         return this .constructor .draco = draco;
+      }
+   },
    camerasArray: function (cameras)
    {
       if (!(cameras instanceof Array))

package/src/x_ite/Parser/OBJParser.js

@@ -275,15 +275,12 @@ OBJParser .prototype = Object .assign (Object .create (X3DParser .prototype),
       try
       {
          const
-            scene = this .getExecutionContext (),
-            url   = new URL (path, scene .getWorldURL ());
-
-         const input = await fetch (url)
-            .then (response => response .arrayBuffer ())
-            .then (arrayBuffer => $.decodeText ($.ungzip (arrayBuffer)))
-            .catch (Function .prototype);
-
-         const parser = new MaterialParser (scene, input);
+            scene       = this .getExecutionContext (),
+            url         = new URL (path, scene .getWorldURL ()),
+            response    = await fetch (url),
+            arrayBuffer = await response .arrayBuffer (),
+            input       = $.decodeText ($.ungzip (arrayBuffer)),
+            parser      = new MaterialParser (scene, input);
 
          parser .parse ();
 

package/src/x_ite/Parser/SVGParser.js

@@ -950,7 +950,7 @@ SVGParser .prototype = Object .assign (Object .create (X3DParser .prototype),
             shapeNode .geometry    = geometryNode;
             geometryNode .solid    = this .solid;
             geometryNode .index    = this .triangulatePolygon (contours, coordinateNode);
-            geometryNode .texCoord = this .createTextureCoordinate (coordinateNode, bbox);
+            geometryNode .texCoord = this .createTextureCoordinate (coordinateNode, bbox, shapeNode .appearance);
             geometryNode .coord    = coordinateNode;
          }
       }
@@ -2678,8 +2678,11 @@ SVGParser .prototype = Object .assign (Object .create (X3DParser .prototype),
 
       return texturePropertiesNode;
    },
-   createTextureCoordinate: function (coordinateNode, bbox)
+   createTextureCoordinate: function (coordinateNode, bbox, appearance)
    {
+      if (!appearance || !appearance .texture)
+         return null;
+
       const
          scene        = this .getExecutionContext (),
          texCoordNode = scene .createNode ("TextureCoordinate"),

package/src/x_ite/Rendering/X3DRenderObject.js

@@ -61,8 +61,6 @@ import StopWatch     from "../../standard/Time/StopWatch.js";
 
 const DEPTH_BUFFER_SIZE = 16;
 
-function compareDistance (lhs, rhs) { return lhs .distance < rhs .distance; }
-
 function X3DRenderObject (executionContext)
 {
    this .viewVolumes              = [ ];
@@ -98,7 +96,7 @@ function X3DRenderObject (executionContext)
    this .shadowShapes             = [ ];
    this .opaqueShapes             = [ ];
    this .transparentShapes        = [ ];
-   this .transparencySorter       = new MergeSort (this .transparentShapes, compareDistance);
+   this .transparencySorter       = new MergeSort (this .transparentShapes, (a, b) => a .distance < b .distance);
    this .speed                    = 0;
 
    try
@@ -636,6 +634,8 @@ X3DRenderObject .prototype =
                   this .transparentShapes .push (this .createRenderContext (true));
 
                var renderContext = this .transparentShapes [num];
+
+               renderContext .distance = bboxCenter .z;
             }
             else
             {
@@ -653,7 +653,6 @@ X3DRenderObject .prototype =
             renderContext .fogNode         = this .localFogs .at (-1);
             renderContext .shapeNode       = shapeNode;
             renderContext .appearanceNode  = shapeNode .getAppearance ();
-            renderContext .distance        = bboxCenter .z;
 
             // Clip planes and local lights
 

package/webpack.config.js

@@ -148,6 +148,8 @@ export default __default__;`;
       resolve: {
          fallback: {
             process: false,
+            path: false,
+            fs: false,
          },
       },
       stats: "errors-warnings",