@loaders.gl/gltf 4.4.0-alpha.2 → 4.4.0

package/src/lib/extensions/utils/3d-tiles-utils.ts

@@ -14,6 +14,7 @@ import type {ImageType} from '@loaders.gl/images';
 import {GLTFScenegraph} from '../../api/gltf-scenegraph';
 import {getComponentTypeFromArray} from '../../gltf-utils/gltf-utils';
 import {getImageData} from '@loaders.gl/images';
+import {ensureArrayBuffer} from '@loaders.gl/loader-utils';
 
 function emod(n: number): number {
   return ((n % 1) + 1) % 1;
@@ -140,7 +141,7 @@ export function convertRawBufferToMetadataArray(
     buffer = bufferArray.slice(offset, offset + byteLength).buffer;
     offset = 0;
   }
-  return new ArrayType(buffer, offset, length);
+  return new ArrayType(ensureArrayBuffer(buffer), offset, length);
 }
 
 /**

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

@@ -1,14 +1,29 @@
+import type {LoaderContext, StrictLoaderOptions} from '@loaders.gl/loader-utils';
+
 // Resolves a relative url against a baseUrl
 // If url is absolute, return it unchanged
-export function resolveUrl(url, options) {
+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 url;
   }
-  const baseUrl = options.baseUri || options.uri;
+  const baseUrl = context?.baseUrl || getResolveBaseUrl(options?.core?.baseUrl);
   if (!baseUrl) {
-    throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);
+    throw new Error(`'baseUrl' must be provided to resolve relative url ${url}`);
   }
-  return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;
+  return baseUrl.endsWith('/') ? `${baseUrl}${url}` : `${baseUrl}/${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) : '';
 }

package/src/lib/parsers/parse-gltf.ts

@@ -1,5 +1,5 @@
 /* eslint-disable camelcase, max-statements, no-restricted-globals */
-import type {LoaderContext} from '@loaders.gl/loader-utils';
+import type {LoaderContext, StrictLoaderOptions} from '@loaders.gl/loader-utils';
 import type {GLTFLoaderOptions} from '../../gltf-loader';
 import type {GLTFWithBuffers} from '../types/gltf-types';
 import type {GLB} from '../types/glb-types';
@@ -8,7 +8,7 @@ import type {ParseGLBOptions} from './parse-glb';
 import type {ImageType, TextureLevel} from '@loaders.gl/schema';
 import {parseJSON, sliceArrayBuffer, parseFromContext} from '@loaders.gl/loader-utils';
 import {ImageLoader} from '@loaders.gl/images';
-import {BasisLoader, selectSupportedBasisFormat} from '@loaders.gl/textures';
+import {BasisLoader} from '@loaders.gl/textures';
 
 import {assert} from '../utils/assert';
 import {isGLB, parseGLBSync} from './parse-glb';
@@ -70,14 +70,14 @@ export async function parseGLTF(
  * @param byteOffset
  * @param options
  */
-function parseGLTFContainerSync(gltf, data, byteOffset, options) {
+function parseGLTFContainerSync(gltf, data, byteOffset, options: GLTFLoaderOptions) {
   // Initialize gltf container
-  if (options.uri) {
-    gltf.baseUri = options.uri;
+  if (options.core?.baseUrl) {
+    gltf.baseUri = options.core?.baseUrl;
   }
 
   // If data is binary and starting with magic bytes, assume binary JSON text, convert to string
-  if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options)) {
+  if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options.glb)) {
     const textDecoder = new TextDecoder();
     data = textDecoder.decode(data);
   }
@@ -134,7 +134,7 @@ async function loadBuffers(gltf: GLTFWithBuffers, options, context: LoaderContex
       const {fetch} = context;
       assert(fetch);
 
-      const uri = resolveUrl(buffer.uri, options);
+      const uri = resolveUrl(buffer.uri, options, context);
       const response = await context?.fetch?.(uri);
       const arrayBuffer = await response?.arrayBuffer?.();
 
@@ -201,7 +201,7 @@ async function loadImage(
   let arrayBuffer;
 
   if (image.uri && !image.hasOwnProperty('bufferView')) {
-    const uri = resolveUrl(image.uri, options);
+    const uri = resolveUrl(image.uri, options, context);
 
     const {fetch} = context;
     const response = await fetch(uri);
@@ -219,15 +219,18 @@ async function loadImage(
 
   assert(arrayBuffer, 'glTF image has no data');
 
+  const strictOptions = options;
+
+  const gltfOptions = {
+    ...strictOptions,
+    core: {...strictOptions?.core, mimeType: image.mimeType}
+  } satisfies StrictLoaderOptions;
+
   // Call `parse`
   let parsedImage = (await parseFromContext(
     arrayBuffer,
     [ImageLoader, BasisLoader],
-    {
-      ...options,
-      mimeType: image.mimeType,
-      basis: options.basis || {format: selectSupportedBasisFormat()}
-    },
+    gltfOptions,
     context
   )) as ImageType | TextureLevel[][];