x_ite 8.6.5 → 8.6.7

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),
@@ -690,8 +696,7 @@ GLTF2Parser .prototype = Object .assign (Object .create (X3DParser .prototype),
       if (name)
          scene .addNamedNode (scene .getUniqueName (name), textureNode);
 
-      textureNode ._url            = [image .uri];
-      textureNode ._flipVertically = true;
+      textureNode ._url = [image .uri];
 
       const sampler = this .samplers [texture .sampler];
 
@@ -921,14 +926,21 @@ 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);
+      const emissiveStrength = this .numberValue (KHR_materials_emissive_strength .emissiveStrength, 1);
+
+      // Will not always get the desired result, because colors are clamped values,
+      // especially if there is an emissiveTexture.
+
+      materialNode ._emissiveColor .r *= emissiveStrength;
+      materialNode ._emissiveColor .g *= emissiveStrength;
+      materialNode ._emissiveColor .b *= emissiveStrength;
    },
    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 +1021,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 +1030,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))