@loaders.gl/3d-tiles 4.0.0-alpha.7 → 4.0.0-alpha.9

package/dist/dist.min.js

@@ -6922,24 +6922,24 @@
   var TILE_REFINEMENT, TILE_TYPE, TILESET_TYPE, LOD_METRIC_TYPE;
   var init_constants3 = __esm({
     "../tiles/src/constants.ts"() {
-      TILE_REFINEMENT = {
-        ADD: 1,
-        REPLACE: 2
-      };
-      TILE_TYPE = {
-        EMPTY: "empty",
-        SCENEGRAPH: "scenegraph",
-        POINTCLOUD: "pointcloud",
-        MESH: "mesh"
-      };
-      TILESET_TYPE = {
-        I3S: "I3S",
-        TILES3D: "TILES3D"
-      };
-      LOD_METRIC_TYPE = {
-        GEOMETRIC_ERROR: "geometricError",
-        MAX_SCREEN_THRESHOLD: "maxScreenThreshold"
-      };
+      (function(TILE_REFINEMENT2) {
+        TILE_REFINEMENT2[TILE_REFINEMENT2["ADD"] = 1] = "ADD";
+        TILE_REFINEMENT2[TILE_REFINEMENT2["REPLACE"] = 2] = "REPLACE";
+      })(TILE_REFINEMENT || (TILE_REFINEMENT = {}));
+      (function(TILE_TYPE2) {
+        TILE_TYPE2["EMPTY"] = "empty";
+        TILE_TYPE2["SCENEGRAPH"] = "scenegraph";
+        TILE_TYPE2["POINTCLOUD"] = "pointcloud";
+        TILE_TYPE2["MESH"] = "mesh";
+      })(TILE_TYPE || (TILE_TYPE = {}));
+      (function(TILESET_TYPE2) {
+        TILESET_TYPE2["I3S"] = "I3S";
+        TILESET_TYPE2["TILES3D"] = "TILES3D";
+      })(TILESET_TYPE || (TILESET_TYPE = {}));
+      (function(LOD_METRIC_TYPE2) {
+        LOD_METRIC_TYPE2["GEOMETRIC_ERROR"] = "geometricError";
+        LOD_METRIC_TYPE2["MAX_SCREEN_THRESHOLD"] = "maxScreenThreshold";
+      })(LOD_METRIC_TYPE || (LOD_METRIC_TYPE = {}));
     }
   });
 
@@ -8453,26 +8453,26 @@
     return byteOffset;
   }
   function parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options) {
-    const { featureTableJsonByteLength, featureTableBinaryByteLength, batchLength } = tile.header;
+    const { featureTableJsonByteLength, featureTableBinaryByteLength, batchLength } = tile.header || {};
     tile.featureTableJson = {
       BATCH_LENGTH: batchLength || 0
     };
-    if (featureTableJsonByteLength > 0) {
+    if (featureTableJsonByteLength && featureTableJsonByteLength > 0) {
       const featureTableString = getStringFromArrayBuffer(arrayBuffer, byteOffset, featureTableJsonByteLength);
       tile.featureTableJson = JSON.parse(featureTableString);
     }
-    byteOffset += featureTableJsonByteLength;
+    byteOffset += featureTableJsonByteLength || 0;
     tile.featureTableBinary = new Uint8Array(arrayBuffer, byteOffset, featureTableBinaryByteLength);
-    byteOffset += featureTableBinaryByteLength;
+    byteOffset += featureTableBinaryByteLength || 0;
     return byteOffset;
   }
   function parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options) {
-    const { batchTableJsonByteLength, batchTableBinaryByteLength } = tile.header;
-    if (batchTableJsonByteLength > 0) {
+    const { batchTableJsonByteLength, batchTableBinaryByteLength } = tile.header || {};
+    if (batchTableJsonByteLength && batchTableJsonByteLength > 0) {
       const batchTableString = getStringFromArrayBuffer(arrayBuffer, byteOffset, batchTableJsonByteLength);
       tile.batchTableJson = JSON.parse(batchTableString);
       byteOffset += batchTableJsonByteLength;
-      if (batchTableBinaryByteLength > 0) {
+      if (batchTableBinaryByteLength && batchTableBinaryByteLength > 0) {
         tile.batchTableBinary = new Uint8Array(arrayBuffer, byteOffset, batchTableBinaryByteLength);
         tile.batchTableBinary = new Uint8Array(tile.batchTableBinary);
         byteOffset += batchTableBinaryByteLength;
@@ -8494,7 +8494,7 @@
     if (!colors && (!tile || !tile.batchIds || !batchTable)) {
       return null;
     }
-    const { batchIds, isRGB565, pointCount } = tile;
+    const { batchIds, isRGB565, pointCount = 0 } = tile;
     if (batchIds && batchTable) {
       const colorArray = new Uint8ClampedArray(pointCount * 3);
       for (let i2 = 0; i2 < pointCount; i2++) {
@@ -8512,7 +8512,7 @@
         normalized: true
       };
     }
-    if (isRGB565) {
+    if (colors && isRGB565) {
       const colorArray = new Uint8ClampedArray(pointCount * 3);
       for (let i2 = 0; i2 < pointCount; i2++) {
         const color = decodeRGB565(colors[i2]);
@@ -8537,7 +8537,7 @@
     }
     return {
       type: GL2.UNSIGNED_BYTE,
-      value: colors,
+      value: colors || new Uint8ClampedArray(),
       size: 4,
       normalized: true
     };
@@ -8554,8 +8554,8 @@
       return null;
     }
     if (tile.isOctEncoded16P) {
-      const decodedArray = new Float32Array(tile.pointsLength * 3);
-      for (let i2 = 0; i2 < tile.pointsLength; i2++) {
+      const decodedArray = new Float32Array((tile.pointsLength || 0) * 3);
+      for (let i2 = 0; i2 < (tile.pointsLength || 0); i2++) {
         octDecode(normals[i2 * 2], normals[i2 * 2 + 1], scratchNormal4);
         scratchNormal4.toArray(decodedArray, i2 * 3);
       }
@@ -8651,6 +8651,12 @@
     return { featureTable, batchTable };
   }
   function parsePositions(tile, featureTable, options) {
+    tile.attributes = tile.attributes || {
+      positions: null,
+      colors: null,
+      normals: null,
+      batchIds: null
+    };
     if (!tile.attributes.positions) {
       if (featureTable.hasProperty("POSITION")) {
         tile.attributes.positions = featureTable.getPropertyArray("POSITION", GL2.FLOAT, 3);
@@ -8674,6 +8680,12 @@
     }
   }
   function parseColors(tile, featureTable, batchTable) {
+    tile.attributes = tile.attributes || {
+      positions: null,
+      colors: null,
+      normals: null,
+      batchIds: null
+    };
     if (!tile.attributes.colors) {
       let colors = null;
       if (featureTable.hasProperty("RGBA")) {
@@ -8692,6 +8704,12 @@
     }
   }
   function parseNormals(tile, featureTable) {
+    tile.attributes = tile.attributes || {
+      positions: null,
+      colors: null,
+      normals: null,
+      batchIds: null
+    };
     if (!tile.attributes.normals) {
       let normals = null;
       if (featureTable.hasProperty("NORMAL")) {
@@ -8734,7 +8752,7 @@
       if (!dracoFeatureTableProperties || !Number.isFinite(dracoByteOffset) || !dracoByteLength) {
         throw new Error("Draco properties, byteOffset, and byteLength must be defined");
       }
-      dracoBuffer = tile.featureTableBinary.slice(dracoByteOffset, dracoByteOffset + dracoByteLength);
+      dracoBuffer = (tile.featureTableBinary || []).slice(dracoByteOffset, dracoByteOffset + dracoByteLength);
       tile.hasPositions = Number.isFinite(dracoFeatureTableProperties.POSITION);
       tile.hasColors = Number.isFinite(dracoFeatureTableProperties.RGB) || Number.isFinite(dracoFeatureTableProperties.RGBA);
       tile.hasNormals = Number.isFinite(dracoFeatureTableProperties.NORMAL);
@@ -8754,11 +8772,14 @@
     return await loadDraco(tile, dracoData, options, context);
   }
   async function loadDraco(tile, dracoData, options, context) {
+    if (!context) {
+      return;
+    }
     const { parse: parse5 } = context;
     const dracoOptions = {
       ...options,
       draco: {
-        ...options.draco,
+        ...options?.draco,
         extraAttributes: dracoData.batchTableProperties || {}
       }
     };
@@ -9328,6 +9349,7 @@
     "../images/src/index.ts"() {
       init_image_loader();
       init_binary_image_api();
+      init_parsed_image_api();
       init_image_format();
     }
   });
@@ -10061,7 +10083,8 @@
         constructor(gltf) {
           this.gltf = {
             json: gltf?.json || makeDefaultGLTFJson(),
-            buffers: gltf?.buffers || []
+            buffers: gltf?.buffers || [],
+            images: gltf?.images || []
           };
           this.sourceBuffers = [];
           this.byteLength = 0;
@@ -10317,14 +10340,14 @@
           this.json.images.push(glTFImage);
           return this.json.images.length - 1;
         }
-        addBufferView(buffer) {
+        addBufferView(buffer, bufferIndex = 0, byteOffset = this.byteLength) {
           const byteLength = buffer.byteLength;
           assert7(Number.isFinite(byteLength));
           this.sourceBuffers = this.sourceBuffers || [];
           this.sourceBuffers.push(buffer);
           const glTFBufferView = {
-            buffer: 0,
-            byteOffset: this.byteLength,
+            buffer: bufferIndex,
+            byteOffset,
             byteLength
           };
           this.byteLength += padToNBytes(byteLength, 4);
@@ -11280,18 +11303,16 @@
     decode: () => decode8,
     name: () => name9
   });
-  async function decode8(gltfData) {
+  async function decode8(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
-    decodeExtFeatureMetadata(scenegraph);
+    decodeExtFeatureMetadata(scenegraph, options);
   }
-  function decodeExtFeatureMetadata(scenegraph) {
+  function decodeExtFeatureMetadata(scenegraph, options) {
     const extension = scenegraph.getExtension(EXT_FEATURE_METADATA);
-    const schemaClasses = extension?.schema?.classes;
-    const featureTables = extension?.featureTables;
-    const featureTextures = extension?.featureTextures;
-    if (featureTextures) {
-      console.warn('featureTextures is not yet supported in the "EXT_feature_metadata" extension.');
-    }
+    if (!extension)
+      return;
+    const schemaClasses = extension.schema?.classes;
+    const { featureTables } = extension;
     if (schemaClasses && featureTables) {
       for (const schemaName in schemaClasses) {
         const schemaClass = schemaClasses[schemaName];
@@ -11301,6 +11322,16 @@
         }
       }
     }
+    const { featureTextures } = extension;
+    if (schemaClasses && featureTextures && options.gltf?.loadImages) {
+      for (const schemaName in schemaClasses) {
+        const schemaClass = schemaClasses[schemaName];
+        const featureTexture = findFeatureTextureByName(featureTextures, schemaName);
+        if (featureTexture) {
+          handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass);
+        }
+      }
+    }
   }
   function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
     for (const propertyName in schemaClass.properties) {
@@ -11313,19 +11344,128 @@
       }
     }
   }
+  function handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass) {
+    const attributeName = featureTexture.class;
+    for (const propertyName in schemaClass.properties) {
+      const featureTextureProperty = featureTexture?.properties?.[propertyName];
+      if (featureTextureProperty) {
+        const data = getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName);
+        featureTextureProperty.data = data;
+      }
+    }
+  }
   function getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
     const bufferView = featureTableProperty.bufferView;
-    let data = scenegraph.getTypedArrayForBufferView(bufferView);
+    const dataArray = scenegraph.getTypedArrayForBufferView(bufferView);
     switch (schemaProperty.type) {
       case "STRING": {
         const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView;
         const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
-        data = getStringAttributes(data, offsetsData, numberOfFeatures);
-        break;
+        return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
       }
       default:
     }
-    return data;
+    return dataArray;
+  }
+  function getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName) {
+    const json = scenegraph.gltf.json;
+    if (!json.meshes) {
+      return [];
+    }
+    const featureTextureTable = [];
+    for (const mesh of json.meshes) {
+      for (const primitive of mesh.primitives) {
+        processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive);
+      }
+    }
+    return featureTextureTable;
+  }
+  function processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive) {
+    const json = scenegraph.gltf.json;
+    const textureData = [];
+    const texCoordAccessorKey = `TEXCOORD_${featureTextureProperty.texture.texCoord}`;
+    const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
+    const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
+    const texCoordArray = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
+    const textureCoordinates = new Float32Array(texCoordArray.buffer, texCoordArray.byteOffset, texCoordArray.length / 4);
+    const textureIndex = featureTextureProperty.texture.index;
+    const texture = json.textures?.[textureIndex];
+    const imageIndex = texture?.source;
+    if (typeof imageIndex !== "undefined") {
+      const image = json.images?.[imageIndex];
+      const mimeType = image?.mimeType;
+      const parsedImage = scenegraph.gltf.images?.[imageIndex];
+      if (parsedImage) {
+        for (let index = 0; index < textureCoordinates.length; index += 2) {
+          const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, featureTextureProperty.channels);
+          textureData.push(value);
+        }
+      }
+    }
+    const featureIndices = [];
+    for (const texelData of textureData) {
+      let index = featureTextureTable.findIndex((item) => item === texelData);
+      if (index === -1) {
+        index = featureTextureTable.push(texelData) - 1;
+      }
+      featureIndices.push(index);
+    }
+    const typedArray = new Uint32Array(featureIndices);
+    const bufferIndex = scenegraph.gltf.buffers.push({
+      arrayBuffer: typedArray.buffer,
+      byteOffset: 0,
+      byteLength: typedArray.byteLength
+    }) - 1;
+    const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
+    const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
+      size: 1,
+      componentType: getComponentTypeFromArray(typedArray),
+      count: typedArray.length
+    });
+    primitive.attributes[attributeName] = accessorIndex;
+  }
+  function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels) {
+    const CHANNELS_MAP = {
+      r: { offset: 0, shift: 0 },
+      g: { offset: 1, shift: 8 },
+      b: { offset: 2, shift: 16 },
+      a: { offset: 3, shift: 24 }
+    };
+    const u = textureCoordinates[index];
+    const v = textureCoordinates[index + 1];
+    let components = 1;
+    if (mimeType && (mimeType.indexOf("image/jpeg") !== -1 || mimeType.indexOf("image/png") !== -1))
+      components = 4;
+    const offset = coordinatesToOffset(u, v, parsedImage, components);
+    let value = 0;
+    for (const c of channels) {
+      const map2 = CHANNELS_MAP[c];
+      const val = getVal(parsedImage, offset + map2.offset);
+      value |= val << map2.shift;
+    }
+    return value;
+  }
+  function getVal(parsedImage, offset) {
+    const imageData = getImageData(parsedImage);
+    if (imageData.data.length <= offset) {
+      throw new Error(`${imageData.data.length} <= ${offset}`);
+    }
+    return imageData.data[offset];
+  }
+  function coordinatesToOffset(u, v, parsedImage, componentsCount = 1) {
+    const w = parsedImage.width;
+    const iX = emod(u) * (w - 1);
+    const indX = Math.round(iX);
+    const h = parsedImage.height;
+    const iY = emod(v) * (h - 1);
+    const indY = Math.round(iY);
+    const components = parsedImage.components ? parsedImage.components : componentsCount;
+    const offset = (indY * w + indX) * components;
+    return offset;
+  }
+  function emod(n2) {
+    const a2 = (n2 % 1 + 1) % 1;
+    return a2;
   }
   function findFeatureTableByName(featureTables, schemaClassName) {
     for (const featureTableName in featureTables) {
@@ -11336,6 +11476,15 @@
     }
     return null;
   }
+  function findFeatureTextureByName(featureTextures, schemaClassName) {
+    for (const featureTexturesName in featureTextures) {
+      const featureTable = featureTextures[featureTexturesName];
+      if (featureTable.class === schemaClassName) {
+        return featureTable;
+      }
+    }
+    return null;
+  }
   function getStringAttributes(data, offsetsData, stringsCount) {
     const stringsArray = [];
     const textDecoder = new TextDecoder("utf8");
@@ -11354,6 +11503,8 @@
   var init_EXT_feature_metadata = __esm({
     "../gltf/src/lib/extensions/deprecated/EXT_feature_metadata.ts"() {
       init_gltf_scenegraph();
+      init_src8();
+      init_gltf_utils();
       EXT_FEATURE_METADATA = "EXT_feature_metadata";
       name9 = EXT_FEATURE_METADATA;
     }
@@ -11632,17 +11783,13 @@
     parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);
     normalizeGLTFV1(gltf, { normalize: options?.gltf?.normalize });
     preprocessExtensions(gltf, options, context);
-    const promises = [];
     if (options?.gltf?.loadBuffers && gltf.json.buffers) {
       await loadBuffers(gltf, options, context);
     }
     if (options?.gltf?.loadImages) {
-      const promise2 = loadImages(gltf, options, context);
-      promises.push(promise2);
+      await loadImages(gltf, options, context);
     }
-    const promise = decodeExtensions(gltf, options, context);
-    promises.push(promise);
-    await Promise.all(promises);
+    await decodeExtensions(gltf, options, context);
     return gltf;
   }
   function parseGLTFContainerSync(gltf, data, byteOffset, options) {
@@ -12197,11 +12344,11 @@
   // src/lib/parsers/helpers/parse-3d-tile-gltf-view.ts
   function parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options) {
     tile.rotateYtoZ = true;
-    const gltfByteLength = tile.byteOffset + tile.byteLength - byteOffset;
+    const gltfByteLength = (tile.byteOffset || 0) + (tile.byteLength || 0) - byteOffset;
     if (gltfByteLength === 0) {
       throw new Error("glTF byte length must be greater than 0.");
     }
-    tile.gltfUpAxis = options["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
+    tile.gltfUpAxis = options?.["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
     tile.gltfArrayBuffer = sliceArrayBuffer(arrayBuffer, byteOffset, gltfByteLength);
     tile.gltfByteOffset = 0;
     tile.gltfByteLength = gltfByteLength;
@@ -12209,15 +12356,19 @@
     } else {
       console.warn(`${tile.type}: embedded glb is not aligned to a 4-byte boundary.`);
     }
-    return tile.byteOffset + tile.byteLength;
+    return (tile.byteOffset || 0) + (tile.byteLength || 0);
   }
   async function extractGLTF(tile, gltfFormat, options, context) {
-    const tile3DOptions = options["3d-tiles"] || {};
+    const tile3DOptions = options?.["3d-tiles"] || {};
     extractGLTFBufferOrURL(tile, gltfFormat, options);
     if (tile3DOptions.loadGLTF) {
+      if (!context) {
+        return;
+      }
       const { parse: parse5, fetch: fetch2 } = context;
       if (tile.gltfUrl) {
-        tile.gltfArrayBuffer = await fetch2(tile.gltfUrl, options);
+        const response = await fetch2(tile.gltfUrl, options);
+        tile.gltfArrayBuffer = await response.arrayBuffer();
         tile.gltfByteOffset = 0;
       }
       if (tile.gltfArrayBuffer) {
@@ -12233,10 +12384,12 @@
   function extractGLTFBufferOrURL(tile, gltfFormat, options) {
     switch (gltfFormat) {
       case GLTF_FORMAT.URI:
-        const gltfUrlBytes = new Uint8Array(tile.gltfArrayBuffer, tile.gltfByteOffset);
-        const textDecoder = new TextDecoder();
-        const gltfUrl = textDecoder.decode(gltfUrlBytes);
-        tile.gltfUrl = gltfUrl.replace(/[\s\0]+$/, "");
+        if (tile.gltfArrayBuffer) {
+          const gltfUrlBytes = new Uint8Array(tile.gltfArrayBuffer, tile.gltfByteOffset);
+          const textDecoder = new TextDecoder();
+          const gltfUrl = textDecoder.decode(gltfUrlBytes);
+          tile.gltfUrl = gltfUrl.replace(/[\s\0]+$/, "");
+        }
         delete tile.gltfArrayBuffer;
         delete tile.gltfByteOffset;
         delete tile.gltfByteLength;
@@ -12291,7 +12444,7 @@
   // src/lib/parsers/parse-3d-tile-instanced-model.ts
   async function parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {
     byteOffset = parseInstancedModel(tile, arrayBuffer, byteOffset, options, context);
-    await extractGLTF(tile, tile.gltfFormat, options, context);
+    await extractGLTF(tile, tile.gltfFormat || 0, options, context);
     return byteOffset;
   }
   function parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {
@@ -12305,7 +12458,7 @@
     byteOffset += 4;
     byteOffset = parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options);
     byteOffset = parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options);
-    if (tile.featureTableJsonByteLength === 0) {
+    if (!tile?.header?.featureTableJsonByteLength || tile.header.featureTableJsonByteLength === 0) {
       throw new Error("i3dm parser: featureTableJsonByteLength is zero.");
     }
     const featureTable = new Tile3DFeatureTable(tile.featureTableJson, tile.featureTableBinary);
@@ -12321,17 +12474,7 @@
     return byteOffset;
   }
   function extractInstancedAttributes(tile, featureTable, batchTable, instancesLength) {
-    const collectionOptions = {
-      instances: new Array(instancesLength),
-      batchTable: tile._batchTable,
-      cull: false,
-      url: void 0,
-      gltf: void 0,
-      basePath: void 0,
-      incrementallyLoadTextures: false,
-      forwardAxis: [1, 0, 0]
-    };
-    const instances = collectionOptions.instances;
+    const instances = new Array(instancesLength);
     const instancePosition = new Vector3();
     const instanceNormalRight = new Vector3();
     const instanceNormalUp = new Vector3();
@@ -12343,19 +12486,19 @@
     const instanceTransform = new Matrix4();
     const scratch1 = [];
     const scratch2 = [];
-    const scratchVector12 = new Vector3();
-    const scratchVector26 = new Vector3();
+    const scratch3 = [];
+    const scratch4 = [];
     for (let i2 = 0; i2 < instancesLength; i2++) {
       let position;
       if (featureTable.hasProperty("POSITION")) {
         position = featureTable.getProperty("POSITION", GL2.FLOAT, 3, i2, instancePosition);
       } else if (featureTable.hasProperty("POSITION_QUANTIZED")) {
         position = featureTable.getProperty("POSITION_QUANTIZED", GL2.UNSIGNED_SHORT, 3, i2, instancePosition);
-        const quantizedVolumeOffset = featureTable.getGlobalProperty("QUANTIZED_VOLUME_OFFSET", GL2.FLOAT, 3, scratchVector12);
+        const quantizedVolumeOffset = featureTable.getGlobalProperty("QUANTIZED_VOLUME_OFFSET", GL2.FLOAT, 3);
         if (!quantizedVolumeOffset) {
           throw new Error("i3dm parser: QUANTIZED_VOLUME_OFFSET must be defined for quantized positions.");
         }
-        const quantizedVolumeScale = featureTable.getGlobalProperty("QUANTIZED_VOLUME_SCALE", GL2.FLOAT, 3, scratchVector26);
+        const quantizedVolumeScale = featureTable.getGlobalProperty("QUANTIZED_VOLUME_SCALE", GL2.FLOAT, 3);
         if (!quantizedVolumeScale) {
           throw new Error("i3dm parser: QUANTIZED_VOLUME_SCALE must be defined for quantized positions.");
         }
@@ -12378,8 +12521,8 @@
         }
         tile.hasCustomOrientation = true;
       } else {
-        tile.octNormalUp = featureTable.getProperty("NORMAL_UP_OCT32P", GL2.UNSIGNED_SHORT, 2, scratch1);
-        tile.octNormalRight = featureTable.getProperty("NORMAL_RIGHT_OCT32P", GL2.UNSIGNED_SHORT, 2, scratch2);
+        tile.octNormalUp = featureTable.getProperty("NORMAL_UP_OCT32P", GL2.UNSIGNED_SHORT, 2, i2, scratch1);
+        tile.octNormalRight = featureTable.getProperty("NORMAL_RIGHT_OCT32P", GL2.UNSIGNED_SHORT, 2, i2, scratch2);
         if (tile.octNormalUp) {
           if (!tile.octNormalRight) {
             throw new Error("i3dm: oct-encoded orientation requires NORMAL_UP_OCT32P and NORMAL_RIGHT_OCT32P");
@@ -12401,7 +12544,7 @@
       instanceQuaternion.fromMatrix3(instanceRotation);
       instanceTranslationRotationScale.rotation = instanceQuaternion;
       instanceScale.set(1, 1, 1);
-      const scale5 = featureTable.getProperty("SCALE", GL2.FLOAT, 1, i2);
+      const scale5 = featureTable.getProperty("SCALE", GL2.FLOAT, 1, i2, scratch3);
       if (Number.isFinite(scale5)) {
         instanceScale.multiplyByScalar(scale5);
       }
@@ -12410,7 +12553,7 @@
         instanceScale.scale(nonUniformScale);
       }
       instanceTranslationRotationScale.scale = instanceScale;
-      let batchId = featureTable.getProperty("BATCH_ID", GL2.UNSIGNED_SHORT, 1, i2);
+      let batchId = featureTable.getProperty("BATCH_ID", GL2.UNSIGNED_SHORT, 1, i2, scratch4);
       if (batchId === void 0) {
         batchId = i2;
       }
@@ -12447,7 +12590,7 @@
     tile.tilesLength = view.getUint32(byteOffset, true);
     byteOffset += 4;
     tile.tiles = [];
-    while (tile.tiles.length < tile.tilesLength && tile.byteLength - byteOffset > 12) {
+    while (tile.tiles.length < tile.tilesLength && (tile.byteLength || 0) - byteOffset > 12) {
       const subtile = {};
       tile.tiles.push(subtile);
       byteOffset = await parse3DTile2(arrayBuffer, byteOffset, options, context, subtile);
@@ -12463,11 +12606,18 @@
   // src/lib/parsers/parse-3d-tile-gltf.ts
   async function parseGltf3DTile(tile, arrayBuffer, options, context) {
     tile.rotateYtoZ = true;
-    tile.gltfUpAxis = options["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
-    const { parse: parse5 } = context;
-    const gltfWithBuffers = await parse5(arrayBuffer, GLTFLoader, options, context);
-    tile.gltf = postProcessGLTF(gltfWithBuffers);
-    tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
+    tile.gltfUpAxis = options?.["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
+    if (options?.["3d-tiles"]?.loadGLTF) {
+      if (!context) {
+        return;
+      }
+      const { parse: parse5 } = context;
+      const gltfWithBuffers = await parse5(arrayBuffer, GLTFLoader, options, context);
+      tile.gltf = postProcessGLTF(gltfWithBuffers);
+      tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
+    } else {
+      tile.gltfArrayBuffer = arrayBuffer;
+    }
   }
   var init_parse_3d_tile_gltf = __esm({
     "src/lib/parsers/parse-3d-tile-gltf.ts"() {
@@ -14044,11 +14194,11 @@
   });
 
   // src/lib/parsers/parse-3d-tile-header.ts
-  function getTileType(tile) {
-    if (!tile.contentUrl) {
+  function getTileType(tile, tileContentUrl = "") {
+    if (!tileContentUrl) {
       return TILE_TYPE.EMPTY;
     }
-    const contentUrl = tile.contentUrl.split("?")[0];
+    const contentUrl = tileContentUrl.split("?")[0];
     const fileExtension = contentUrl.split(".").pop();
     switch (fileExtension) {
       case "pnts":
@@ -14059,7 +14209,7 @@
       case "gltf":
         return TILE_TYPE.SCENEGRAPH;
       default:
-        return fileExtension;
+        return fileExtension || TILE_TYPE.EMPTY;
     }
   }
   function getRefine(refine) {
@@ -14074,7 +14224,7 @@
         return refine;
     }
   }
-  function resolveUri(uri, basePath) {
+  function resolveUri(uri = "", basePath) {
     const urlSchemeRegex = /^[a-z][0-9a-z+.-]*:/i;
     if (urlSchemeRegex.test(basePath)) {
       const url = new URL(uri, `${basePath}/`);
@@ -14084,50 +14234,59 @@
     }
     return `${basePath}/${uri}`;
   }
-  function normalizeTileData(tile, options) {
+  function normalizeTileData(tile, basePath) {
     if (!tile) {
       return null;
     }
+    let tileContentUrl;
     if (tile.content) {
-      const contentUri = tile.content.uri || tile.content.url;
-      tile.contentUrl = resolveUri(contentUri, options.basePath);
-    }
-    tile.id = tile.contentUrl;
-    tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-    tile.lodMetricValue = tile.geometricError;
-    tile.transformMatrix = tile.transform;
-    tile.type = getTileType(tile);
-    tile.refine = getRefine(tile.refine);
-    return tile;
+      const contentUri = tile.content.uri || tile.content?.url;
+      tileContentUrl = resolveUri(contentUri, basePath);
+    }
+    const tilePostprocessed = {
+      ...tile,
+      id: tileContentUrl,
+      contentUrl: tileContentUrl,
+      lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+      lodMetricValue: tile.geometricError,
+      transformMatrix: tile.transform,
+      type: getTileType(tile, tileContentUrl),
+      refine: getRefine(tile.refine)
+    };
+    return tilePostprocessed;
   }
-  async function normalizeTileHeaders(tileset, options) {
-    const basePath = tileset.basePath;
-    let root;
-    const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset?.root);
+  async function normalizeTileHeaders(tileset, basePath, options) {
+    let root = null;
+    const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset.root);
     if (rootImplicitTilingExtension && tileset.root) {
-      root = await normalizeImplicitTileHeaders(tileset.root, tileset, rootImplicitTilingExtension, options);
+      root = await normalizeImplicitTileHeaders(tileset.root, tileset, basePath, rootImplicitTilingExtension, options);
     } else {
-      root = normalizeTileData(tileset.root, tileset);
+      root = normalizeTileData(tileset.root, basePath);
     }
     const stack2 = [];
     stack2.push(root);
     while (stack2.length > 0) {
       const tile = stack2.pop() || {};
       const children = tile.children || [];
-      for (let childHeader of children) {
+      const childrenPostprocessed = [];
+      for (const childHeader of children) {
         const childImplicitTilingExtension = getImplicitTilingExtensionData(childHeader);
+        let childHeaderPostprocessed;
         if (childImplicitTilingExtension) {
-          childHeader = await normalizeImplicitTileHeaders(childHeader, tileset, childImplicitTilingExtension, options);
+          childHeaderPostprocessed = await normalizeImplicitTileHeaders(childHeader, tileset, basePath, childImplicitTilingExtension, options);
         } else {
-          normalizeTileData(childHeader, { basePath });
+          childHeaderPostprocessed = normalizeTileData(childHeader, basePath);
+        }
+        if (childHeaderPostprocessed) {
+          childrenPostprocessed.push(childHeaderPostprocessed);
+          stack2.push(childHeaderPostprocessed);
         }
-        stack2.push(childHeader);
       }
+      tile.children = childrenPostprocessed;
     }
     return root;
   }
-  async function normalizeImplicitTileHeaders(tile, tileset, implicitTilingExtension, options) {
-    const basePath = tileset.basePath;
+  async function normalizeImplicitTileHeaders(tile, tileset, basePath, implicitTilingExtension, options) {
     const {
       subdivisionScheme,
       maximumLevel,
@@ -14137,7 +14296,7 @@
     const replacedUrlTemplate = replaceContentUrlTemplate(subtreesUriTemplate, 0, 0, 0, 0);
     const subtreeUrl = resolveUri(replacedUrlTemplate, basePath);
     const subtree = await load(subtreeUrl, Tile3DSubtreeLoader, options);
-    const contentUrlTemplate = resolveUri(tile.content.uri, basePath);
+    const contentUrlTemplate = resolveUri(tile.content?.uri, basePath);
     const refine = tileset?.root?.refine;
     const rootLodMetricValue = tile.geometricError;
     const s2VolumeInfo = tile.boundingVolume.extensions?.["3DTILES_bounding_volume_S2"];
@@ -14161,29 +14320,35 @@
       getTileType,
       getRefine
     };
-    return await normalizeImplicitTileData(tile, subtree, implicitOptions);
+    return await normalizeImplicitTileData(tile, basePath, subtree, implicitOptions);
   }
-  async function normalizeImplicitTileData(tile, rootSubtree, options) {
+  async function normalizeImplicitTileData(tile, basePath, rootSubtree, options) {
     if (!tile) {
       return null;
     }
-    tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-    tile.lodMetricValue = tile.geometricError;
-    tile.transformMatrix = tile.transform;
     const { children, contentUrl } = await parseImplicitTiles({
       subtree: rootSubtree,
-      options,
-      s2VolumeBox: tile
+      options
     });
+    let tileContentUrl;
+    let tileContent = null;
     if (contentUrl) {
-      tile.contentUrl = contentUrl;
-      tile.content = { uri: contentUrl.replace(`${options.basePath}/`, "") };
+      tileContentUrl = contentUrl;
+      tileContent = { uri: contentUrl.replace(`${basePath}/`, "") };
     }
-    tile.refine = getRefine(tile.refine);
-    tile.type = getTileType(tile);
-    tile.children = children;
-    tile.id = tile.contentUrl;
-    return tile;
+    const tilePostprocessed = {
+      ...tile,
+      id: tileContentUrl,
+      contentUrl: tileContentUrl,
+      lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+      lodMetricValue: tile.geometricError,
+      transformMatrix: tile.transform,
+      type: getTileType(tile, tileContentUrl),
+      refine: getRefine(tile.refine),
+      content: tileContent || tile.content,
+      children
+    };
+    return tilePostprocessed;
   }
   function getImplicitTilingExtensionData(tile) {
     return tile?.extensions?.["3DTILES_implicit_tiling"] || tile?.implicitTiling;
@@ -14207,19 +14372,25 @@
     } else {
       isTileset = loaderOptions.isTileset;
     }
-    return await isTileset ? parseTileset(data, options, context) : parseTile(data, options, context);
+    return isTileset ? parseTileset(data, options, context) : parseTile(data, options, context);
   }
   async function parseTileset(data, options, context) {
     const tilesetJson = JSON.parse(new TextDecoder().decode(data));
-    tilesetJson.loader = options?.loader || Tiles3DLoader;
-    tilesetJson.url = context?.url || "";
-    tilesetJson.queryString = context?.queryString || "";
-    tilesetJson.basePath = getBaseUri(tilesetJson);
-    tilesetJson.root = await normalizeTileHeaders(tilesetJson, options || {});
-    tilesetJson.type = TILESET_TYPE.TILES3D;
-    tilesetJson.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-    tilesetJson.lodMetricValue = tilesetJson.root?.lodMetricValue || 0;
-    return tilesetJson;
+    const tilesetUrl = context?.url || "";
+    const basePath = getBaseUri(tilesetUrl);
+    const normalizedRoot = await normalizeTileHeaders(tilesetJson, basePath, options || {});
+    const tilesetJsonPostprocessed = {
+      ...tilesetJson,
+      loader: Tiles3DLoader,
+      url: tilesetUrl,
+      queryString: context?.queryString || "",
+      basePath,
+      root: normalizedRoot || tilesetJson.root,
+      type: TILESET_TYPE.TILES3D,
+      lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+      lodMetricValue: tilesetJson.root?.geometricError || 0
+    };
+    return tilesetJsonPostprocessed;
   }
   async function parseTile(arrayBuffer, options, context) {
     const tile = {
@@ -14231,8 +14402,8 @@
     await parse3DTile(arrayBuffer, byteOffset, options, context, tile.content);
     return tile.content;
   }
-  function getBaseUri(tileset) {
-    return path_exports.dirname(tileset.url);
+  function getBaseUri(tilesetUrl) {
+    return path_exports.dirname(tilesetUrl);
   }
   var Tiles3DLoader;
   var init_tiles_3d_loader = __esm({