@loaders.gl/i3s 3.1.0-beta.7 → 3.1.0

package/dist/bundle.js

@@ -463,6 +463,9 @@
     const workerOptions = options[worker.id] || {};
     const workerFile = `${worker.id}-worker.js`;
     let url = workerOptions.workerUrl;
+    if (!url && worker.id === "compression") {
+      url = options.workerUrl;
+    }
     if (options._workerType === "test") {
       url = `modules/${worker.module}/dist/${workerFile}`;
     }
@@ -7479,7 +7482,7 @@
     }
   });
 
-  // ../textures/src/lib/parsers/parse-basis.js
+  // ../textures/src/lib/parsers/parse-basis.ts
   async function parseBasis(data, options) {
     if (options.basis.containerFormat === "auto") {
       if (isKTX(data)) {
@@ -7615,7 +7618,7 @@
   }
   var OutputFormat;
   var init_parse_basis = __esm({
-    "../textures/src/lib/parsers/parse-basis.js"() {
+    "../textures/src/lib/parsers/parse-basis.ts"() {
       init_basis_module_loader();
       init_gl_extensions();
       init_texture_formats();
@@ -8068,12 +8071,34 @@
     }
   });
 
+  // src/types.ts
+  var DATA_TYPE, HeaderAttributeProperty;
+  var init_types = __esm({
+    "src/types.ts"() {
+      (function(DATA_TYPE2) {
+        DATA_TYPE2["UInt8"] = "UInt8";
+        DATA_TYPE2["UInt16"] = "UInt16";
+        DATA_TYPE2["UInt32"] = "UInt32";
+        DATA_TYPE2["UInt64"] = "UInt64";
+        DATA_TYPE2["Int16"] = "Int16";
+        DATA_TYPE2["Int32"] = "Int32";
+        DATA_TYPE2["Int64"] = "Int64";
+        DATA_TYPE2["Float32"] = "Float32";
+        DATA_TYPE2["Float64"] = "Float64";
+      })(DATA_TYPE || (DATA_TYPE = {}));
+      (function(HeaderAttributeProperty2) {
+        HeaderAttributeProperty2["vertexCount"] = "vertexCount";
+        HeaderAttributeProperty2["featureCount"] = "featureCount";
+      })(HeaderAttributeProperty || (HeaderAttributeProperty = {}));
+    }
+  });
+
   // src/lib/utils/url-utils.ts
   function getUrlWithToken(url, token = null) {
     return token ? `${url}?token=${token}` : url;
   }
-  function generateTileAttributeUrls(tile) {
-    const { url, attributeData } = tile;
+  function generateTileAttributeUrls(url, tile) {
+    const { attributeData = [] } = tile;
     const attributeUrls = [];
     for (let index = 0; index < attributeData.length; index++) {
       const attributeUrl = attributeData[index].href.replace("./", "");
@@ -8718,24 +8743,6 @@
     }
   });
 
-  // src/types.ts
-  var DATA_TYPE;
-  var init_types = __esm({
-    "src/types.ts"() {
-      (function(DATA_TYPE2) {
-        DATA_TYPE2["UInt8"] = "UInt8";
-        DATA_TYPE2["UInt16"] = "UInt16";
-        DATA_TYPE2["UInt32"] = "UInt32";
-        DATA_TYPE2["UInt64"] = "UInt64";
-        DATA_TYPE2["Int16"] = "Int16";
-        DATA_TYPE2["Int32"] = "Int32";
-        DATA_TYPE2["Int64"] = "Int64";
-        DATA_TYPE2["Float32"] = "Float32";
-        DATA_TYPE2["Float64"] = "Float64";
-      })(DATA_TYPE || (DATA_TYPE = {}));
-    }
-  });
-
   // src/lib/parsers/constants.ts
   function getConstructorForDataFormat(dataType) {
     switch (dataType) {
@@ -8750,7 +8757,7 @@
       case DATA_TYPE.UInt64:
         return Float64Array;
       default:
-        return null;
+        throw new Error(`parse i3s tile content: unknown type of data: ${dataType}`);
     }
   }
   function sizeOf(dataType) {
@@ -8769,10 +8776,10 @@
       case DATA_TYPE.Float64:
         return 8;
       default:
-        return NaN;
+        throw new Error(`parse i3s tile content: unknown size of data: ${dataType}`);
     }
   }
-  var GL_TYPE_MAP, I3S_NAMED_VERTEX_ATTRIBUTES, I3S_NAMED_GEOMETRY_ATTRIBUTES, I3S_NAMED_HEADER_ATTRIBUTES, STRING_ATTRIBUTE_TYPE, OBJECT_ID_ATTRIBUTE_TYPE, FLOAT_64_TYPE, INT_16_ATTRIBUTE_TYPE, COORDINATE_SYSTEM;
+  var GL_TYPE_MAP, STRING_ATTRIBUTE_TYPE, OBJECT_ID_ATTRIBUTE_TYPE, FLOAT_64_TYPE, INT_16_ATTRIBUTE_TYPE, COORDINATE_SYSTEM;
   var init_constants2 = __esm({
     "src/lib/parsers/constants.ts"() {
       init_esm5();
@@ -8784,22 +8791,6 @@
         UInt32: esm_default2.UNSIGNED_INT,
         UInt64: esm_default2.DOUBLE
       };
-      I3S_NAMED_VERTEX_ATTRIBUTES = {
-        position: "position",
-        normal: "normal",
-        uv0: "uv0",
-        color: "color",
-        region: "region"
-      };
-      I3S_NAMED_GEOMETRY_ATTRIBUTES = {
-        vertexAttributes: "vertexAttributes",
-        featureAttributeOrder: "featureAttributeOrder",
-        featureAttributes: "featureAttributes"
-      };
-      I3S_NAMED_HEADER_ATTRIBUTES = {
-        vertexCount: "vertexCount",
-        featureCount: "featureCount"
-      };
       STRING_ATTRIBUTE_TYPE = "String";
       OBJECT_ID_ATTRIBUTE_TYPE = "Oid32";
       FLOAT_64_TYPE = "Float64";
@@ -8817,26 +8808,24 @@
   // src/lib/parsers/parse-i3s-tile-content.ts
   function getLoaderForTextureFormat(textureFormat) {
     switch (textureFormat) {
-      case "jpeg":
-      case "png":
-        return ImageLoader;
       case "ktx-etc2":
       case "dds":
         return CompressedTextureLoader;
       case "ktx2":
         return BasisLoader;
+      case "jpg":
+      case "png":
       default:
-        return null;
+        return ImageLoader;
     }
   }
   async function parseI3STileContent(arrayBuffer, tile, tileset, options, context) {
     tile.content = tile.content || {};
     tile.content.featureIds = tile.content.featureIds || null;
-    tile.content.featureData = constructFeatureDataStruct(tileset);
     tile.content.attributes = {};
     if (tile.textureUrl) {
       const url = getUrlWithToken(tile.textureUrl, options?.i3s?.token);
-      const loader = getLoaderForTextureFormat(tile.textureFormat) || ImageLoader;
+      const loader = getLoaderForTextureFormat(tile.textureFormat);
       const response = await fetch(url);
       const arrayBuffer2 = await response.arrayBuffer();
       if (options?.i3s.decodeTextures) {
@@ -8865,9 +8854,9 @@
     if (tile.content.material) {
       tile.content.texture = null;
     }
-    return await parseI3SNodeGeometry(arrayBuffer, tile, options);
+    return await parseI3SNodeGeometry(arrayBuffer, tile, tileset, options);
   }
-  async function parseI3SNodeGeometry(arrayBuffer, tile, options) {
+  async function parseI3SNodeGeometry(arrayBuffer, tile, tileset, options) {
     if (!tile.content) {
       return tile;
     }
@@ -8876,6 +8865,7 @@
     let vertexCount;
     let byteOffset = 0;
     let featureCount = 0;
+    let indices;
     if (tile.isDracoGeometry) {
       const decompressedGeometry = await parse(arrayBuffer, DracoLoader2, {
         draco: {
@@ -8883,7 +8873,7 @@
         }
       });
       vertexCount = decompressedGeometry.header.vertexCount;
-      const indices = decompressedGeometry.indices.value;
+      indices = decompressedGeometry.indices?.value;
       const {
         POSITION,
         NORMAL,
@@ -8898,8 +8888,7 @@
         color: COLOR_0,
         uv0: TEXCOORD_0,
         uvRegion,
-        id: featureIndex,
-        indices
+        id: featureIndex
       };
       updateAttributesMetadata(attributes, decompressedGeometry);
       const featureIds = getFeatureIdsFromFeatureIndexMetadata(featureIndex);
@@ -8907,8 +8896,13 @@
         flattenFeatureIdsByFeatureIndices(attributes, featureIds);
       }
     } else {
-      const { vertexAttributes, attributesOrder, featureAttributes, featureAttributeOrder } = content.featureData;
-      const headers = parseHeaders(content, arrayBuffer);
+      const {
+        vertexAttributes,
+        ordering: attributesOrder,
+        featureAttributes,
+        featureAttributeOrder
+      } = tileset.store.defaultGeometrySchema;
+      const headers = parseHeaders(tileset, arrayBuffer);
       byteOffset = headers.byteOffset;
       vertexCount = headers.vertexCount;
       featureCount = headers.featureCount;
@@ -8932,7 +8926,7 @@
       texCoords: attributes.uv0,
       uvRegions: normalizeAttribute(attributes.uvRegion)
     };
-    content.indices = attributes.indices || null;
+    content.indices = indices || null;
     if (attributes.id && attributes.id.value) {
       tile.content.featureIds = attributes.id.value;
     }
@@ -8970,41 +8964,25 @@
     attribute.normalized = true;
     return attribute;
   }
-  function constructFeatureDataStruct(tileset) {
-    const defaultGeometrySchema = tileset.store.defaultGeometrySchema;
-    const featureData = defaultGeometrySchema;
-    for (const geometryAttribute in I3S_NAMED_GEOMETRY_ATTRIBUTES) {
-      for (const namedAttribute in I3S_NAMED_VERTEX_ATTRIBUTES) {
-        const attribute = defaultGeometrySchema[geometryAttribute][namedAttribute];
-        if (attribute) {
-          const { byteOffset = 0, count = 0, valueType, valuesPerElement } = attribute;
-          featureData[geometryAttribute][namedAttribute] = {
-            valueType,
-            valuesPerElement,
-            byteOffset,
-            count
-          };
-        }
-      }
-    }
-    featureData.attributesOrder = defaultGeometrySchema.ordering;
-    return featureData;
-  }
-  function parseHeaders(content, arrayBuffer) {
+  function parseHeaders(tileset, arrayBuffer) {
     let byteOffset = 0;
     let vertexCount = 0;
     let featureCount = 0;
-    content.featureData.header.forEach(({ property, type }) => {
+    for (const { property, type } of tileset.store.defaultGeometrySchema.header) {
       const TypedArrayTypeHeader = getConstructorForDataFormat(type);
-      if (property === I3S_NAMED_HEADER_ATTRIBUTES.vertexCount) {
-        vertexCount = new TypedArrayTypeHeader(arrayBuffer, 0, 4)[0];
-        byteOffset += sizeOf(type);
-      }
-      if (property === I3S_NAMED_HEADER_ATTRIBUTES.featureCount) {
-        featureCount = new TypedArrayTypeHeader(arrayBuffer, 4, 4)[0];
-        byteOffset += sizeOf(type);
+      switch (property) {
+        case HeaderAttributeProperty.vertexCount:
+          vertexCount = new TypedArrayTypeHeader(arrayBuffer, 0, 4)[0];
+          byteOffset += sizeOf(type);
+          break;
+        case HeaderAttributeProperty.featureCount:
+          featureCount = new TypedArrayTypeHeader(arrayBuffer, 4, 4)[0];
+          byteOffset += sizeOf(type);
+          break;
+        default:
+          break;
       }
-    });
+    }
     return {
       vertexCount,
       featureCount,
@@ -9021,7 +8999,7 @@
           break;
         }
         const buffer = arrayBuffer.slice(byteOffset);
-        let value = [];
+        let value;
         if (valueType === "UInt64") {
           value = parseUint64Values(buffer, count * valuesPerElement, sizeOf(valueType));
         } else {
@@ -9058,7 +9036,7 @@
       values.push(value);
       offset += attributeSize;
     }
-    return values;
+    return new Uint32Array(values);
   }
   function parsePositions(attribute, tile) {
     const mbs = tile.mbs;
@@ -9125,7 +9103,9 @@
     if (pbrMaterial.pbrMetallicRoughness && pbrMaterial.pbrMetallicRoughness.baseColorFactor) {
       pbrMaterial.pbrMetallicRoughness.baseColorFactor = convertColorFormat(pbrMaterial.pbrMetallicRoughness.baseColorFactor);
     }
-    setMaterialTexture(pbrMaterial, texture);
+    if (texture) {
+      setMaterialTexture(pbrMaterial, texture);
+    }
     return pbrMaterial;
   }
   function convertColorFormat(colorFactor) {
@@ -9187,7 +9167,7 @@
     attributes.id.value = result;
   }
   function getFeatureIdsFromFeatureIndexMetadata(featureIndex) {
-    return featureIndex && featureIndex.metadata && featureIndex.metadata["i3s-feature-ids"] && featureIndex.metadata["i3s-feature-ids"].intArray;
+    return featureIndex?.metadata?.["i3s-feature-ids"]?.intArray;
   }
   var scratchVector5, I3S_ATTRIBUTE_TYPE;
   var init_parse_i3s_tile_content = __esm({
@@ -9198,6 +9178,7 @@
       init_src4();
       init_src6();
       init_src7();
+      init_types();
       init_url_utils();
       init_constants2();
       scratchVector5 = new Vector3([0, 0, 0]);
@@ -9775,8 +9756,8 @@
           this.textureDefinitionsSelectedFormats = [];
           this.textureLoaderOptions = {};
           this.tileset = { ...tileset };
-          this.nodesPerPage = tileset.nodePages.nodesPerPage;
-          this.lodSelectionMetricType = tileset.nodePages.lodSelectionMetricType;
+          this.nodesPerPage = tileset.nodePages?.nodesPerPage || 64;
+          this.lodSelectionMetricType = tileset.nodePages?.lodSelectionMetricType;
           this.options = options;
           this.initSelectedFormatsForTextureDefinitions(tileset);
         }
@@ -9803,21 +9784,21 @@
           for (const child of node2.children || []) {
             const childNode = await this.getNodeById(child);
             children.push({
-              id: child,
+              id: child.toString(),
               obb: childNode.obb
             });
           }
-          let contentUrl = null;
-          let textureUrl = null;
-          let materialDefinition = null;
-          let textureFormat = "jpeg";
+          let contentUrl;
+          let textureUrl;
+          let materialDefinition;
+          let textureFormat = "jpg";
           let attributeUrls = [];
           let isDracoGeometry = false;
           if (node2 && node2.mesh) {
-            const { url, isDracoGeometry: isDracoGeometryResult } = node2.mesh.geometry && this.getContentUrl(node2.mesh.geometry) || { url: null, isDracoGeometry: null };
+            const { url, isDracoGeometry: isDracoGeometryResult } = node2.mesh.geometry && this.getContentUrl(node2.mesh.geometry) || { isDracoGeometry: false };
             contentUrl = url;
             isDracoGeometry = isDracoGeometryResult;
-            const [textureData, nodeMaterialDefinition] = this.getInformationFromMaterial(node2.mesh.material);
+            const { textureData, materialDefinition: nodeMaterialDefinition } = this.getInformationFromMaterial(node2.mesh.material);
             materialDefinition = nodeMaterialDefinition;
             textureFormat = textureData.format || textureFormat;
             if (textureData.name) {
@@ -9829,7 +9810,7 @@
           }
           const lodSelection = this.getLodSelection(node2);
           return normalizeTileNonUrlData({
-            id,
+            id: id.toString(),
             lodSelection,
             obb: node2.obb,
             contentUrl,
@@ -9843,7 +9824,7 @@
           });
         }
         getContentUrl(meshGeometryData) {
-          let result = {};
+          let result = null;
           const geometryDefinition = this.tileset.geometryDefinitions[meshGeometryData.definition];
           let geometryIndex = -1;
           if (this.options.i3s && this.options.i3s.useDracoGeometry) {
@@ -9876,17 +9857,18 @@
           return lodSelection;
         }
         getInformationFromMaterial(material) {
-          const textureDataDefault = { name: null, format: null };
+          const informationFromMaterial = { textureData: { name: null } };
           if (material) {
-            const materialDefinition = this.tileset.materialDefinitions[material.definition];
-            const textureSetDefinitionIndex = materialDefinition && materialDefinition.pbrMetallicRoughness && materialDefinition.pbrMetallicRoughness.baseColorTexture && materialDefinition.pbrMetallicRoughness.baseColorTexture.textureSetDefinitionId;
-            if (textureSetDefinitionIndex || textureSetDefinitionIndex === 0) {
-              const textureData = this.textureDefinitionsSelectedFormats[textureSetDefinitionIndex] || textureDataDefault;
-              return [textureData, materialDefinition];
+            const materialDefinition = this.tileset.materialDefinitions?.[material.definition];
+            if (materialDefinition) {
+              informationFromMaterial.materialDefinition = materialDefinition;
+              const textureSetDefinitionIndex = materialDefinition?.pbrMetallicRoughness?.baseColorTexture?.textureSetDefinitionId;
+              if (typeof textureSetDefinitionIndex === "number") {
+                informationFromMaterial.textureData = this.textureDefinitionsSelectedFormats[textureSetDefinitionIndex] || informationFromMaterial.textureData;
+              }
             }
-            return [textureDataDefault, materialDefinition];
           }
-          return [textureDataDefault, null];
+          return informationFromMaterial;
         }
         initSelectedFormatsForTextureDefinitions(tileset) {
           this.textureDefinitionsSelectedFormats = [];
@@ -9934,49 +9916,54 @@
 
   // src/lib/parsers/parse-i3s.ts
   function normalizeTileData(tile, options, context) {
-    tile.url = context.url;
-    if (tile.featureData) {
-      tile.featureUrl = `${tile.url}/${tile.featureData[0].href}`;
-    }
+    const url = context.url || "";
+    let contentUrl;
     if (tile.geometryData) {
-      tile.contentUrl = `${tile.url}/${tile.geometryData[0].href}`;
+      contentUrl = `${url}/${tile.geometryData[0].href}`;
     }
+    let textureUrl;
     if (tile.textureData) {
-      tile.textureUrl = `${tile.url}/${tile.textureData[0].href}`;
+      textureUrl = `${url}/${tile.textureData[0].href}`;
     }
+    let attributeUrls;
     if (tile.attributeData) {
-      tile.attributeUrls = generateTileAttributeUrls(tile);
-    }
-    return normalizeTileNonUrlData(tile);
+      attributeUrls = generateTileAttributeUrls(url, tile);
+    }
+    return normalizeTileNonUrlData({
+      ...tile,
+      url,
+      contentUrl,
+      textureUrl,
+      attributeUrls,
+      isDracoGeometry: false
+    });
   }
   function normalizeTileNonUrlData(tile) {
-    const box = tile.obb ? [
-      ...Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center),
-      ...tile.obb.halfSize,
-      ...tile.obb.quaternion
-    ] : void 0;
-    let sphere;
+    const boundingVolume = {};
+    let mbs = [0, 0, 0, 1];
     if (tile.mbs) {
-      sphere = [
+      mbs = tile.mbs;
+      boundingVolume.sphere = [
         ...Ellipsoid.WGS84.cartographicToCartesian(tile.mbs.slice(0, 3)),
         tile.mbs[3]
       ];
-    } else if (box) {
-      const obb = new OrientedBoundingBox().fromCenterHalfSizeQuaternion(box.slice(0, 3), tile.obb.halfSize, tile.obb.quaternion);
+    } else if (tile.obb) {
+      boundingVolume.box = [
+        ...Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center),
+        ...tile.obb.halfSize,
+        ...tile.obb.quaternion
+      ];
+      const obb = new OrientedBoundingBox().fromCenterHalfSizeQuaternion(boundingVolume.box.slice(0, 3), tile.obb.halfSize, tile.obb.quaternion);
       const boundingSphere = obb.getBoundingSphere();
-      sphere = [...boundingSphere.center, boundingSphere.radius];
-      tile.mbs = [...tile.obb.center, boundingSphere.radius];
-    }
-    tile.boundingVolume = {
-      sphere,
-      box
-    };
-    tile.lodMetricType = tile.lodSelection[0].metricType;
-    tile.lodMetricValue = tile.lodSelection[0].maxError;
-    tile.transformMatrix = tile.transform;
-    tile.type = TILE_TYPE.MESH;
-    tile.refine = TILE_REFINEMENT.REPLACE;
-    return tile;
+      boundingVolume.sphere = [...boundingSphere.center, boundingSphere.radius];
+      mbs = [...tile.obb.center, boundingSphere.radius];
+    }
+    const lodMetricType = tile.lodSelection?.[0].metricType;
+    const lodMetricValue = tile.lodSelection?.[0].maxError;
+    const transformMatrix = tile.transform;
+    const type = TILE_TYPE.MESH;
+    const refine = TILE_REFINEMENT.REPLACE;
+    return { ...tile, mbs, boundingVolume, lodMetricType, lodMetricValue, transformMatrix, type, refine };
   }
   async function normalizeTilesetData(tileset, options, context) {
     tileset.url = context.url;

package/dist/es5/bundle.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const moduleExports = require('./index');
+var moduleExports = require('./index');
 
 globalThis.loaders = globalThis.loaders || {};
 module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/es5/bundle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}
+{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}