@loaders.gl/scene 5.0.0-alpha.9 → 5.0.0-beta.2

package/src/gltf/lib/gltf-utils/get-typed-array.ts

@@ -0,0 +1,215 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// TODO - GLTFScenegraph should use these
+import {assert} from '../utils/assert';
+import {padToNBytes} from '@loaders.gl/core/loader-utils';
+import type {BigTypedArray} from '@loaders.gl/core/schema';
+import type {GLTF, GLTFExternalBuffer, GLTFAccessor} from '../types/gltf-types';
+import {getAccessorArrayTypeAndLength} from './gltf-utils';
+
+// accepts buffer view index or buffer view object
+// returns a `Uint8Array`
+export function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {
+  const bufferView =
+    typeof bufferViewIndex === 'number' ? json.bufferViews[bufferViewIndex] : bufferViewIndex;
+  assert(bufferView);
+
+  // Get hold of the arrayBuffer
+  const bufferIndex = bufferView.buffer;
+  const binChunk = buffers[bufferIndex];
+  assert(binChunk);
+
+  assert((bufferView.byteOffset || 0) >= 0 && bufferView.byteLength >= 0);
+  assert((bufferView.byteOffset || 0) + bufferView.byteLength <= binChunk.byteLength);
+  assert(
+    binChunk.byteOffset >= 0 &&
+      binChunk.byteOffset + binChunk.byteLength <= binChunk.arrayBuffer.byteLength
+  );
+  const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
+  return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
+}
+
+// accepts accessor index or accessor object
+// returns a `Uint8Array`
+export function getTypedArrayForImageData(json, buffers, imageIndex) {
+  const image = json.images[imageIndex];
+  return getTypedArrayForBufferView(json, buffers, image.bufferView);
+}
+
+/**
+ * Gets data pointed by the accessor.
+ * @param json - json part of gltf content of a GLTF tile.
+ * @param buffers - Array containing buffers of data.
+ * @param accessor - accepts accessor index or accessor object.
+ * @returns Typed array with type matching the accessor component type.
+ */
+// eslint-disable-next-line complexity
+export function getTypedArrayForAccessor(
+  json: GLTF,
+  buffers: GLTFExternalBuffer[],
+  accessor: GLTFAccessor | number
+): BigTypedArray {
+  const gltfAccessor = typeof accessor === 'number' ? json.accessors?.[accessor] : accessor;
+  if (!gltfAccessor) {
+    throw new Error(`No gltf accessor ${JSON.stringify(accessor)}`);
+  }
+  assert(Number.isSafeInteger(gltfAccessor.count) && gltfAccessor.count >= 0);
+  const {ArrayType, length, numberOfComponentsInElement} = getAccessorArrayTypeAndLength(
+    gltfAccessor,
+    {byteLength: Infinity}
+  );
+  const decodedValue = (gltfAccessor as GLTFAccessor & {value?: BigTypedArray}).value;
+  let result: BigTypedArray;
+  if (ArrayBuffer.isView(decodedValue)) {
+    assert(decodedValue.length === length);
+    result = decodedValue;
+  } else if (gltfAccessor.bufferView === undefined) {
+    result = new ArrayType(length);
+  } else {
+    result = readAccessorValues(json, buffers, gltfAccessor);
+  }
+  const sparse = gltfAccessor.sparse;
+  if (!sparse) return result;
+  // Sparse substitutions must never mutate borrowed buffers or decoder-owned arrays.
+  const copiedValue: BigTypedArray = new ArrayType(length);
+  new Uint8Array(copiedValue.buffer).set(
+    new Uint8Array(result.buffer, result.byteOffset, result.byteLength)
+  );
+  assert(sparse.count >= 0 && sparse.count <= gltfAccessor.count);
+  assert([5121, 5123, 5125].includes(sparse.indices.componentType));
+  const indices = readAccessorValues(json, buffers, {
+    bufferView: sparse.indices.bufferView,
+    byteOffset: sparse.indices.byteOffset,
+    componentType: sparse.indices.componentType,
+    count: sparse.count,
+    type: 'SCALAR'
+  });
+  const values = readAccessorValues(json, buffers, {
+    bufferView: sparse.values.bufferView,
+    byteOffset: sparse.values.byteOffset,
+    componentType: gltfAccessor.componentType,
+    count: sparse.count,
+    type: gltfAccessor.type
+  });
+  let previousIndex = -1;
+  const copiedBytes = new Uint8Array(copiedValue.buffer);
+  const elementByteLength = numberOfComponentsInElement * ArrayType.BYTES_PER_ELEMENT;
+  const valueBytes = new Uint8Array(values.buffer, values.byteOffset, values.byteLength);
+  for (let sparseIndex = 0; sparseIndex < sparse.count; sparseIndex++) {
+    const index = Number(indices[sparseIndex]);
+    assert(index > previousIndex && index < gltfAccessor.count);
+    copiedBytes.set(
+      valueBytes.subarray(sparseIndex * elementByteLength, (sparseIndex + 1) * elementByteLength),
+      index * elementByteLength
+    );
+    previousIndex = index;
+  }
+  return copiedValue;
+}
+
+/** Read dense values, respecting buffer-view ranges, interleaving and matrix column padding. */
+function readAccessorValues(
+  json: GLTF,
+  buffers: GLTFExternalBuffer[],
+  gltfAccessor: GLTFAccessor
+): BigTypedArray {
+  const bufferView = json.bufferViews?.[gltfAccessor.bufferView!];
+  if (!bufferView) {
+    throw new Error(`No gltf buffer view for accessor ${bufferView}`);
+  }
+  // Get `arrayBuffer` the `bufferView` looks at
+  const externalBuffer = buffers[bufferView.buffer];
+  assert(externalBuffer);
+  const {arrayBuffer, byteOffset: bufferByteOffset} = externalBuffer;
+  assert((bufferView.byteOffset || 0) >= 0 && bufferView.byteLength >= 0);
+  assert((bufferView.byteOffset || 0) + bufferView.byteLength <= externalBuffer.byteLength);
+  assert(
+    bufferByteOffset >= 0 && bufferByteOffset + externalBuffer.byteLength <= arrayBuffer.byteLength
+  );
+  assert((gltfAccessor.byteOffset || 0) >= 0);
+  // Resulting byteOffset is sum of the buffer, accessor and bufferView byte offsets
+  const byteOffset =
+    (bufferByteOffset || 0) + (gltfAccessor.byteOffset || 0) + (bufferView.byteOffset || 0);
+  // Deduce TypedArray type and its length from `accessor` and `bufferView` data
+  const {ArrayType, length, componentByteSize, numberOfComponentsInElement} =
+    getAccessorArrayTypeAndLength(gltfAccessor, bufferView);
+  // 'length' is a whole number of components of all elements in the buffer pointed by the accessor
+  // Multiplier to calculate the address of the element in the arrayBuffer
+  const elementByteSize = componentByteSize * numberOfComponentsInElement;
+  const matrixColumns = gltfAccessor.type.startsWith('MAT')
+    ? Number(gltfAccessor.type.slice(3))
+    : 1;
+  const matrixColumnByteSize = padToNBytes(matrixColumns * componentByteSize, 4);
+  const packedElementByteSize =
+    matrixColumns > 1 ? matrixColumns * matrixColumnByteSize : elementByteSize;
+  const elementStride = bufferView.byteStride ?? packedElementByteSize;
+  const lastElementByteSize =
+    matrixColumns > 1
+      ? (matrixColumns - 1) * matrixColumnByteSize + matrixColumns * componentByteSize
+      : elementByteSize;
+  assert(elementStride >= packedElementByteSize);
+  assert(
+    (gltfAccessor.byteOffset || 0) +
+      (gltfAccessor.count === 0
+        ? 0
+        : (gltfAccessor.count - 1) * elementStride + lastElementByteSize) <=
+      bufferView.byteLength
+  );
+  if (gltfAccessor.count === 0) return new ArrayType(0);
+  if (matrixColumns > 1 && matrixColumnByteSize !== matrixColumns * componentByteSize) {
+    const elementStride = bufferView.byteStride ?? matrixColumns * matrixColumnByteSize;
+    const lastElementSize =
+      (matrixColumns - 1) * matrixColumnByteSize + matrixColumns * componentByteSize;
+    assert(
+      (gltfAccessor.byteOffset || 0) + (gltfAccessor.count - 1) * elementStride + lastElementSize <=
+        bufferView.byteLength
+    );
+    const result: BigTypedArray = new ArrayType(length);
+    const outputBytes = new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+    for (let elementIndex = 0; elementIndex < gltfAccessor.count; elementIndex++) {
+      for (let columnIndex = 0; columnIndex < matrixColumns; columnIndex++) {
+        const columnBytes = new Uint8Array(
+          arrayBuffer,
+          byteOffset + elementIndex * elementStride + columnIndex * matrixColumnByteSize,
+          matrixColumns * componentByteSize
+        );
+        outputBytes.set(
+          columnBytes,
+          elementIndex * elementByteSize + columnIndex * matrixColumns * componentByteSize
+        );
+      }
+    }
+    return result;
+  }
+  const elementAddressScale = bufferView.byteStride || elementByteSize;
+  // Creare an array of component's type where all components (not just elements) will reside
+  if (typeof bufferView.byteStride === 'undefined' || bufferView.byteStride === elementByteSize) {
+    // No iterleaving
+    if (byteOffset % componentByteSize !== 0) {
+      const bytes = new Uint8Array(arrayBuffer, byteOffset, length * componentByteSize);
+      const alignedBytes = new Uint8Array(bytes.byteLength);
+      alignedBytes.set(bytes);
+      return new ArrayType(alignedBytes.buffer, 0, length);
+    }
+    const result: BigTypedArray = new ArrayType(arrayBuffer, byteOffset, length);
+    return result;
+  }
+  // Iterleaving
+  const result: BigTypedArray = new ArrayType(length);
+  for (let i = 0; i < gltfAccessor.count; i++) {
+    const elementByteOffset = byteOffset + i * elementAddressScale;
+    let values: any;
+    if (elementByteOffset % componentByteSize !== 0) {
+      const bytes = new Uint8Array(arrayBuffer, elementByteOffset, elementByteSize);
+      const alignedBytes = new Uint8Array(elementByteSize);
+      alignedBytes.set(bytes);
+      values = new ArrayType(alignedBytes.buffer, 0, numberOfComponentsInElement);
+    } else {
+      values = new ArrayType(arrayBuffer, elementByteOffset, numberOfComponentsInElement);
+    }
+    result.set(values, i * numberOfComponentsInElement);
+  }
+  return result;
+}

package/src/gltf/lib/gltf-utils/gltf-attribute-utils.ts

@@ -0,0 +1,85 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// import type {TypedArray} from '../types/loader-utils';
+import type {GLTFAccessor} from '../types/gltf-json-schema';
+// TODO - remove
+import {getAccessorTypeFromSize, getComponentTypeFromArray} from './gltf-utils';
+
+// Returns a fresh attributes object with glTF-standardized attributes names
+// Attributes that cannot be identified will not be included
+// Removes `indices` if present, as it should be stored separately from the attributes
+export function getGLTFAccessors(attributes): {[key: string]: GLTFAccessor} {
+  const accessors = {};
+  for (const name in attributes) {
+    const attribute = attributes[name];
+    if (name !== 'indices') {
+      const glTFAccessor = getGLTFAccessor(attribute);
+      accessors[name] = glTFAccessor;
+    }
+  }
+  return accessors;
+}
+
+// Fix up a single accessor.
+// Input: typed array or a partial accessor object
+// Return: accessor object
+export function getGLTFAccessor(attribute) {
+  const {buffer, size, count} = getAccessorData(attribute);
+
+  const glTFAccessor: GLTFAccessor = {
+    // glTF Accessor values
+    // TODO: Instead of a bufferView index we could have an actual buffer (typed array)
+    // bufferView: null,
+    // TODO: Deprecate `value` in favor of bufferView?
+    // @ts-ignore
+    value: buffer,
+    size, // Decoded `type` (e.g. SCALAR)
+
+    byteOffset: 0,
+    count,
+    type: getAccessorTypeFromSize(size),
+    componentType: getComponentTypeFromArray(buffer)
+  };
+
+  return glTFAccessor;
+}
+
+// export function getGLTFAttribute(data, gltfAttributeName): GLTFAccessor {
+//   return data.attributes[data.glTFAttributeMap[gltfAttributeName]];
+// }
+
+function getAccessorData(attribute) {
+  let buffer = attribute;
+  let size = 1;
+  let count = 0;
+
+  if (attribute && attribute.value) {
+    buffer = attribute.value;
+    size = attribute.size || 1;
+  }
+
+  if (buffer) {
+    if (!ArrayBuffer.isView(buffer)) {
+      buffer = toTypedArray(buffer, Float32Array);
+    }
+    count = buffer.length / size;
+  }
+
+  return {buffer, size, count};
+}
+
+// Convert non-typed arrays to arrays of specified format
+function toTypedArray(array, ArrayType, convertTypedArrays = false) {
+  if (!array) {
+    return null;
+  }
+  if (Array.isArray(array)) {
+    return new ArrayType(array);
+  }
+  if (convertTypedArrays && !(array instanceof ArrayType)) {
+    return new ArrayType(array);
+  }
+  return array;
+}

package/src/gltf/lib/gltf-utils/gltf-constants.ts

@@ -0,0 +1,53 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export const COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+
+export const BYTES = {
+  5120: 1, // BYTE
+  5121: 1, // UNSIGNED_BYTE
+  5122: 2, // SHORT
+  5123: 2, // UNSIGNED_SHORT
+  5124: 4, // INT
+  5125: 4, // UNSIGNED_INT
+  5126: 4, // FLOAT
+  5130: 8, // DOUBLE
+  5131: 2, // HALF_FLOAT
+  5134: 8, // INT64
+  5135: 8 // UNSIGNED_INT64
+};
+
+// ENUM LOOKUP
+
+export function getBytesFromComponentType(componentType) {
+  return BYTES[componentType];
+}
+
+export function getSizeFromAccessorType(type) {
+  return COMPONENTS[type];
+}
+
+export function getGLEnumFromSamplerParameter(parameter) {
+  const GL_TEXTURE_MAG_FILTER = 0x2800;
+  const GL_TEXTURE_MIN_FILTER = 0x2801;
+  const GL_TEXTURE_WRAP_S = 0x2802;
+  const GL_TEXTURE_WRAP_T = 0x2803;
+
+  const PARAMETER_MAP = {
+    magFilter: GL_TEXTURE_MAG_FILTER,
+    minFilter: GL_TEXTURE_MIN_FILTER,
+    wrapS: GL_TEXTURE_WRAP_S,
+    wrapT: GL_TEXTURE_WRAP_T
+  };
+
+  return PARAMETER_MAP[parameter];
+}

package/src/gltf/lib/gltf-utils/gltf-utils.ts

@@ -0,0 +1,162 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {assert} from '../utils/assert';
+
+import type {GLTFWithBuffers, GLTFAccessor} from '../types/gltf-types';
+import {BYTES, COMPONENTS} from './gltf-constants';
+
+/**
+ * Memory needed to store texture and all mipmap levels 1 + 1/4 + 1/16 + 1/64 + ...
+ * Minimum 1.33, but due to GPU layout may be 1.5
+ */
+const MIPMAP_FACTOR = 1.33;
+
+const TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];
+
+type TypedArrayConstructor =
+  | Int8ArrayConstructor
+  | Uint8ArrayConstructor
+  | Int16ArrayConstructor
+  | Uint16ArrayConstructor
+  | Int32ArrayConstructor
+  | Uint32ArrayConstructor
+  | Float32ArrayConstructor
+  | Float64ArrayConstructor
+  | BigInt64ArrayConstructor
+  | BigUint64ArrayConstructor;
+
+const ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT: [TypedArrayConstructor, number][] = [
+  [Int8Array, 5120],
+  [Uint8Array, 5121],
+  [Int16Array, 5122],
+  [Uint16Array, 5123],
+  [Int32Array, 5124],
+  [Uint32Array, 5125],
+  [Float32Array, 5126],
+  [Float64Array, 5130],
+  [BigInt64Array, 5134],
+  [BigUint64Array, 5135]
+];
+const ARRAY_TO_COMPONENT_TYPE = new Map<TypedArrayConstructor, number>(
+  ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT
+);
+
+const ATTRIBUTE_TYPE_TO_COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+
+const ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
+  5120: 1,
+  5121: 1,
+  5122: 2,
+  5123: 2,
+  5124: 4,
+  5125: 4,
+  5126: 4,
+  5130: 8,
+  5131: 2,
+  5134: 8,
+  5135: 8
+};
+
+const ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5124: Int32Array,
+  5125: Uint32Array,
+  5126: Float32Array,
+  5130: Float64Array,
+  // JavaScript does not yet provide Float16Array across supported runtimes.
+  // Preserve binary16 payloads in Uint16Array while componentType retains their semantics.
+  5131: Uint16Array,
+  5134: BigInt64Array,
+  5135: BigUint64Array
+};
+
+export function getAccessorTypeFromSize(size) {
+  const type = TYPES[size - 1];
+  return type || TYPES[0];
+}
+
+export function getComponentTypeFromArray(typedArray) {
+  const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);
+  if (!componentType) {
+    throw new Error('Illegal typed array');
+  }
+  return componentType;
+}
+
+export function getAccessorArrayTypeAndLength(accessor, bufferView) {
+  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
+  const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
+  const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
+  const length = accessor.count * components;
+  const byteLength = accessor.count * components * bytesPerComponent;
+  assert(byteLength >= 0 && byteLength <= bufferView.byteLength);
+  const componentByteSize = BYTES[accessor.componentType];
+  const numberOfComponentsInElement = COMPONENTS[accessor.type];
+  return {ArrayType, length, byteLength, componentByteSize, numberOfComponentsInElement};
+}
+
+/**
+ * Calculate the GPU memory used by a GLTF tile, for both buffer and texture memory
+ * @param gltf - the gltf content of a GLTF tile
+ * @returns - total memory usage in bytes
+ */
+export function getMemoryUsageGLTF(gltf: GLTFWithBuffers): number {
+  const imageBufferViews = new Set((gltf.json.images || []).map(image => image.bufferView));
+  const liveBufferViews = new Set<number>();
+  const decodedValues = new Set<ArrayBufferView>();
+  const accessors = new Set<GLTFAccessor>();
+  let materializedMemory = 0;
+  /** Count current accessor storage without reading or allocating its values. */
+  const addAccessorStorage = (reference: number | GLTFAccessor | undefined): void => {
+    const accessor = typeof reference === 'number' ? gltf.json.accessors?.[reference] : reference;
+    if (!accessor || accessors.has(accessor)) return;
+    accessors.add(accessor);
+    const value = (accessor as GLTFAccessor & {value?: ArrayBufferView}).value;
+    if (ArrayBuffer.isView(value)) {
+      if (!decodedValues.has(value)) materializedMemory += value.byteLength;
+      decodedValues.add(value);
+    } else if (accessor.sparse || accessor.bufferView === undefined) {
+      materializedMemory +=
+        accessor.count * BYTES[accessor.componentType] * COMPONENTS[accessor.type];
+    } else {
+      liveBufferViews.add(accessor.bufferView);
+    }
+  };
+  for (const accessor of gltf.json.accessors || []) {
+    // Unused Draco declarations can lack storage after decoding into inline accessors.
+    if (accessor.bufferView !== undefined || accessor.sparse || 'value' in accessor)
+      addAccessorStorage(accessor);
+  }
+  for (const mesh of gltf.json.meshes || []) {
+    for (const primitive of mesh.primitives) {
+      addAccessorStorage(primitive.indices);
+      for (const reference of Object.values(primitive.attributes)) addAccessorStorage(reference);
+      for (const target of primitive.targets || []) {
+        for (const reference of Object.values(target)) addAccessorStorage(reference);
+      }
+    }
+  }
+  const bufferMemory = [...liveBufferViews].reduce(
+    (total, index) =>
+      total + (imageBufferViews.has(index) ? 0 : gltf.json.bufferViews?.[index]?.byteLength || 0),
+    materializedMemory
+  );
+  const pixelCount = (gltf.images || []).reduce(
+    (total, image) => total + ((image as any)?.width || 0) * ((image as any)?.height || 0),
+    0
+  );
+  return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);
+}

package/src/gltf/lib/gltf-utils/resolve-gltf-file.ts

@@ -0,0 +1,95 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderContext, StrictLoaderOptions} from '@loaders.gl/core/loader-utils';
+import type {GLTFExternalFile, GLTFWithBuffers} from '../types/gltf-types';
+import {getTypedArrayForBufferView} from './get-typed-array';
+import {resolveUrl} from './resolve-url';
+import {assert} from '../utils/assert';
+
+/**
+ * Find a draft glTF 2.1 file definition by package name or original URI.
+ * @param gltf - Parsed glTF container.
+ * @param reference - Package-relative file reference.
+ * @returns File index, or `-1` when no definition matches.
+ */
+export function findGLTFFileIndex(gltf: GLTFWithBuffers, reference: string): number {
+  const files = gltf.json.files || [];
+  const matches: number[] = [];
+
+  for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
+    const file = files[fileIndex];
+    if (file.name === reference || file.uri === reference) {
+      matches.push(fileIndex);
+    }
+  }
+
+  assert(matches.length <= 1, `glTF package file reference ${reference} is ambiguous.`);
+  return matches[0] ?? -1;
+}
+
+/**
+ * Resolve a draft glTF 2.1 file from a URI or embedded buffer view.
+ * String references are matched against `files[*].name` and `files[*].uri`, enabling this
+ * function to serve as the virtual file-system lookup for packaged assets.
+ * @param gltf - Parsed glTF container with buffers loaded when embedded files are used.
+ * @param fileReference - File array index, package name, or original URI.
+ * @param options - Loader options used for relative URL resolution.
+ * @param context - Loader context supplying base URL and fetch implementation.
+ * @returns Resolved file bytes and metadata.
+ */
+export async function resolveGLTFFile(
+  gltf: GLTFWithBuffers,
+  fileReference: number | string,
+  options: StrictLoaderOptions,
+  context: LoaderContext
+): Promise<GLTFExternalFile> {
+  const files = gltf.json.files || [];
+  const fileIndex =
+    typeof fileReference === 'number' ? fileReference : findGLTFFileIndex(gltf, fileReference);
+  assert(Number.isInteger(fileIndex) && fileIndex >= 0 && fileIndex < files.length);
+
+  gltf.files = gltf.files || new Array(files.length).fill(null);
+  const loadedFile = gltf.files[fileIndex];
+  if (loadedFile) {
+    return loadedFile;
+  }
+
+  const file = files[fileIndex];
+  assert(file.mimeType, `glTF file ${fileIndex} must define mimeType.`);
+  const hasUri = file.uri !== undefined;
+  const hasBufferView = file.bufferView !== undefined;
+  assert(
+    hasUri !== hasBufferView,
+    `glTF file ${fileIndex} must define exactly one of uri or bufferView.`
+  );
+
+  let resolvedFile: GLTFExternalFile;
+  if (file.uri !== undefined) {
+    const url = resolveUrl(file.uri, options, context);
+    const response = await context.fetch(url);
+    assert(response?.ok, `Failed to fetch glTF file ${file.uri}: HTTP ${response?.status}.`);
+    const arrayBuffer = await response.arrayBuffer();
+    resolvedFile = {
+      arrayBuffer,
+      byteOffset: 0,
+      byteLength: arrayBuffer.byteLength,
+      mimeType: file.mimeType,
+      name: file.name,
+      url
+    };
+  } else {
+    const data = getTypedArrayForBufferView(gltf.json, gltf.buffers, file.bufferView);
+    resolvedFile = {
+      arrayBuffer: data.buffer as ArrayBuffer,
+      byteOffset: data.byteOffset,
+      byteLength: data.byteLength,
+      mimeType: file.mimeType,
+      name: file.name
+    };
+  }
+
+  gltf.files[fileIndex] = resolvedFile;
+  return resolvedFile;
+}

package/src/gltf/lib/gltf-utils/resolve-url.ts

@@ -0,0 +1,48 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderContext, StrictLoaderOptions} from '@loaders.gl/core/loader-utils';
+
+// Resolves a relative url against a baseUrl
+// If url is absolute, return it unchanged
+export function resolveUrl(url: string, options?: StrictLoaderOptions, context?: LoaderContext) {
+  // TODO: Use better logic to handle all protocols plus not delay on data
+  const absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');
+  if (absolute) {
+    return canonicalizeUrl(url);
+  }
+  const baseUrl = context?.baseUrl || getResolveBaseUrl(options?.core?.baseUrl);
+  if (!baseUrl) {
+    throw new Error(`'baseUrl' must be provided to resolve relative url ${url}`);
+  }
+  const resolvedUrl = baseUrl.endsWith('/') ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
+  return canonicalizeUrl(resolvedUrl);
+}
+
+/**
+ * Normalize equivalent absolute URLs for cache and cycle-detection keys.
+ * Non-URL paths are returned unchanged so local and virtual file-system resolution remains intact.
+ * @param url - URL to normalize.
+ * @returns Canonical URL when the input has a supported absolute scheme.
+ */
+export function canonicalizeUrl(url: string): string {
+  try {
+    return new URL(url).href;
+  } catch {
+    return url;
+  }
+}
+
+function getResolveBaseUrl(baseUrl?: string): string | undefined {
+  if (!baseUrl) {
+    return undefined;
+  }
+
+  if (baseUrl.endsWith('/')) {
+    return baseUrl;
+  }
+
+  const slashIndex = baseUrl.lastIndexOf('/');
+  return slashIndex >= 0 ? baseUrl.slice(0, slashIndex + 1) : '';
+}