@loaders.gl/gltf 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/lib/parsers/parse-gltf.js

@@ -1,170 +1,203 @@
-import { BasisLoader, selectSupportedBasisFormat } from '@loaders.gl/textures';
-import { ImageLoader } from '@loaders.gl/images';
-import { parseJSON, sliceArrayBuffer } from '@loaders.gl/loader-utils';
-import { assert } from '../utils/assert';
-import { resolveUrl } from '../gltf-utils/resolve-url';
-import { getTypedArrayForBufferView } from '../gltf-utils/get-typed-array';
-import { preprocessExtensions, decodeExtensions } from '../api/gltf-extensions';
-import { normalizeGLTFV1 } from '../api/normalize-gltf-v1';
-import { postProcessGLTF } from '../api/post-process-gltf';
-import parseGLBSync, { isGLB } from './parse-glb';
-export function isGLTF(arrayBuffer, options) {
-  const byteOffset = 0;
-  return isGLB(arrayBuffer, byteOffset, options);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGLTF = exports.isGLTF = void 0;
+const textures_1 = require("@loaders.gl/textures");
+const images_1 = require("@loaders.gl/images");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const assert_1 = require("../utils/assert");
+const resolve_url_1 = require("../gltf-utils/resolve-url");
+const get_typed_array_1 = require("../gltf-utils/get-typed-array");
+const gltf_extensions_1 = require("../api/gltf-extensions");
+const normalize_gltf_v1_1 = require("../api/normalize-gltf-v1");
+const post_process_gltf_1 = require("../api/post-process-gltf");
+const parse_glb_1 = __importStar(require("./parse-glb"));
+// export type GLTFOptions = {
+//   gltf?: GLTFParseOptions;
+// };
+function isGLTF(arrayBuffer, options) {
+    const byteOffset = 0;
+    return (0, parse_glb_1.isGLB)(arrayBuffer, byteOffset, options);
 }
-export async function parseGLTF(gltf, arrayBufferOrString, byteOffset = 0, options, context) {
-  var _options$gltf, _options$gltf2, _options$gltf3, _options$gltf4;
-
-  parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);
-  normalizeGLTFV1(gltf, {
-    normalize: options === null || options === void 0 ? void 0 : (_options$gltf = options.gltf) === null || _options$gltf === void 0 ? void 0 : _options$gltf.normalize
-  });
-  preprocessExtensions(gltf, options, context);
-  const promises = [];
-
-  if (options !== null && options !== void 0 && (_options$gltf2 = options.gltf) !== null && _options$gltf2 !== void 0 && _options$gltf2.loadBuffers && gltf.json.buffers) {
-    await loadBuffers(gltf, options, context);
-  }
-
-  if (options !== null && options !== void 0 && (_options$gltf3 = options.gltf) !== null && _options$gltf3 !== void 0 && _options$gltf3.loadImages) {
-    const promise = loadImages(gltf, options, context);
+exports.isGLTF = isGLTF;
+async function parseGLTF(gltf, arrayBufferOrString, byteOffset = 0, options, context) {
+    parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);
+    (0, normalize_gltf_v1_1.normalizeGLTFV1)(gltf, { normalize: options?.gltf?.normalize });
+    (0, gltf_extensions_1.preprocessExtensions)(gltf, options, context);
+    const promises = [];
+    // Load linked buffers asynchronously and decodes base64 buffers in parallel
+    if (options?.gltf?.loadBuffers && gltf.json.buffers) {
+        await loadBuffers(gltf, options, context);
+    }
+    if (options?.gltf?.loadImages) {
+        const promise = loadImages(gltf, options, context);
+        promises.push(promise);
+    }
+    const promise = (0, gltf_extensions_1.decodeExtensions)(gltf, options, context);
     promises.push(promise);
-  }
-
-  const promise = decodeExtensions(gltf, options, context);
-  promises.push(promise);
-  await Promise.all(promises);
-  return options !== null && options !== void 0 && (_options$gltf4 = options.gltf) !== null && _options$gltf4 !== void 0 && _options$gltf4.postProcess ? postProcessGLTF(gltf, options) : gltf;
+    // Parallelize image loading and buffer loading/extension decoding
+    await Promise.all(promises);
+    // Post processing resolves indices to objects, buffers
+    return options?.gltf?.postProcess ? (0, post_process_gltf_1.postProcessGLTF)(gltf, options) : gltf;
 }
-
+exports.parseGLTF = parseGLTF;
+// `data` - can be ArrayBuffer (GLB), ArrayBuffer (Binary JSON), String (JSON), or Object (parsed JSON)
 function parseGLTFContainerSync(gltf, data, byteOffset, options) {
-  if (options.uri) {
-    gltf.baseUri = options.uri;
-  }
-
-  if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options)) {
-    const textDecoder = new TextDecoder();
-    data = textDecoder.decode(data);
-  }
-
-  if (typeof data === 'string') {
-    gltf.json = parseJSON(data);
-  } else if (data instanceof ArrayBuffer) {
-    const glb = {};
-    byteOffset = parseGLBSync(glb, data, byteOffset, options.glb);
-    assert(glb.type === 'glTF', "Invalid GLB magic string ".concat(glb.type));
-    gltf._glb = glb;
-    gltf.json = glb.json;
-  } else {
-    assert(false, 'GLTF: must be ArrayBuffer or string');
-  }
-
-  const buffers = gltf.json.buffers || [];
-  gltf.buffers = new Array(buffers.length).fill(null);
-
-  if (gltf._glb && gltf._glb.header.hasBinChunk) {
-    const {
-      binChunks
-    } = gltf._glb;
-    gltf.buffers[0] = {
-      arrayBuffer: binChunks[0].arrayBuffer,
-      byteOffset: binChunks[0].byteOffset,
-      byteLength: binChunks[0].byteLength
-    };
-  }
-
-  const images = gltf.json.images || [];
-  gltf.images = new Array(images.length).fill({});
+    // Initialize gltf container
+    if (options.uri) {
+        gltf.baseUri = options.uri;
+    }
+    // If data is binary and starting with magic bytes, assume binary JSON text, convert to string
+    if (data instanceof ArrayBuffer && !(0, parse_glb_1.isGLB)(data, byteOffset, options)) {
+        const textDecoder = new TextDecoder();
+        data = textDecoder.decode(data);
+    }
+    if (typeof data === 'string') {
+        // If string, try to parse as JSON
+        gltf.json = (0, loader_utils_1.parseJSON)(data);
+    }
+    else if (data instanceof ArrayBuffer) {
+        // If still ArrayBuffer, parse as GLB container
+        const glb = {};
+        byteOffset = (0, parse_glb_1.default)(glb, data, byteOffset, options.glb);
+        (0, assert_1.assert)(glb.type === 'glTF', `Invalid GLB magic string ${glb.type}`);
+        gltf._glb = glb;
+        gltf.json = glb.json;
+    }
+    else {
+        (0, assert_1.assert)(false, 'GLTF: must be ArrayBuffer or string');
+    }
+    // Populate buffers
+    // Create an external buffers array to hold binary data
+    const buffers = gltf.json.buffers || [];
+    gltf.buffers = new Array(buffers.length).fill(null);
+    // Populates JSON and some bin chunk info
+    if (gltf._glb && gltf._glb.header.hasBinChunk) {
+        const { binChunks } = gltf._glb;
+        gltf.buffers[0] = {
+            arrayBuffer: binChunks[0].arrayBuffer,
+            byteOffset: binChunks[0].byteOffset,
+            byteLength: binChunks[0].byteLength
+        };
+        // TODO - this modifies JSON and is a post processing thing
+        // gltf.json.buffers[0].data = gltf.buffers[0].arrayBuffer;
+        // gltf.json.buffers[0].byteOffset = gltf.buffers[0].byteOffset;
+    }
+    // Populate images
+    const images = gltf.json.images || [];
+    gltf.images = new Array(images.length).fill({});
 }
-
+/** Asynchronously fetch and parse buffers, store in buffers array outside of json
+ * TODO - traverse gltf and determine which buffers are actually needed
+ */
 async function loadBuffers(gltf, options, context) {
-  const buffers = gltf.json.buffers || [];
-
-  for (let i = 0; i < buffers.length; ++i) {
-    const buffer = buffers[i];
-
-    if (buffer.uri) {
-      var _context$fetch, _response$arrayBuffer;
-
-      const {
-        fetch
-      } = context;
-      assert(fetch);
-      const uri = resolveUrl(buffer.uri, options);
-      const response = await (context === null || context === void 0 ? void 0 : (_context$fetch = context.fetch) === null || _context$fetch === void 0 ? void 0 : _context$fetch.call(context, uri));
-      const arrayBuffer = await (response === null || response === void 0 ? void 0 : (_response$arrayBuffer = response.arrayBuffer) === null || _response$arrayBuffer === void 0 ? void 0 : _response$arrayBuffer.call(response));
-      gltf.buffers[i] = {
-        arrayBuffer,
-        byteOffset: 0,
-        byteLength: arrayBuffer.byteLength
-      };
-      delete buffer.uri;
+    // TODO
+    const buffers = gltf.json.buffers || [];
+    for (let i = 0; i < buffers.length; ++i) {
+        const buffer = buffers[i];
+        if (buffer.uri) {
+            const { fetch } = context;
+            (0, assert_1.assert)(fetch);
+            const uri = (0, resolve_url_1.resolveUrl)(buffer.uri, options);
+            const response = await context?.fetch?.(uri);
+            const arrayBuffer = await response?.arrayBuffer?.();
+            gltf.buffers[i] = {
+                arrayBuffer,
+                byteOffset: 0,
+                byteLength: arrayBuffer.byteLength
+            };
+            delete buffer.uri;
+        }
+        else if (gltf.buffers[i] === null) {
+            gltf.buffers[i] = {
+                arrayBuffer: new ArrayBuffer(buffer.byteLength),
+                byteOffset: 0,
+                byteLength: buffer.byteLength
+            };
+        }
     }
-  }
 }
-
+/**
+ * Loads all images
+ * TODO - traverse gltf and determine which images are actually needed
+ * @param gltf
+ * @param options
+ * @param context
+ * @returns
+ */
 async function loadImages(gltf, options, context) {
-  const imageIndices = getReferencesImageIndices(gltf);
-  const images = gltf.json.images || [];
-  const promises = [];
-
-  for (const imageIndex of imageIndices) {
-    promises.push(loadImage(gltf, images[imageIndex], imageIndex, options, context));
-  }
-
-  return await Promise.all(promises);
+    const imageIndices = getReferencesImageIndices(gltf);
+    const images = gltf.json.images || [];
+    const promises = [];
+    for (const imageIndex of imageIndices) {
+        promises.push(loadImage(gltf, images[imageIndex], imageIndex, options, context));
+    }
+    return await Promise.all(promises);
 }
-
+/** Make sure we only load images that are actually referenced by textures */
 function getReferencesImageIndices(gltf) {
-  const imageIndices = new Set();
-  const textures = gltf.json.textures || [];
-
-  for (const texture of textures) {
-    if (texture.source !== undefined) {
-      imageIndices.add(texture.source);
+    const imageIndices = new Set();
+    const textures = gltf.json.textures || [];
+    for (const texture of textures) {
+        if (texture.source !== undefined) {
+            imageIndices.add(texture.source);
+        }
     }
-  }
-
-  return Array.from(imageIndices).sort();
+    return Array.from(imageIndices).sort();
 }
-
+/** Asynchronously fetches and parses one image, store in images array outside of json */
 async function loadImage(gltf, image, index, options, context) {
-  const {
-    fetch,
-    parse
-  } = context;
-  let arrayBuffer;
-
-  if (image.uri) {
-    const uri = resolveUrl(image.uri, options);
-    const response = await fetch(uri);
-    arrayBuffer = await response.arrayBuffer();
-  }
-
-  if (Number.isFinite(image.bufferView)) {
-    const array = getTypedArrayForBufferView(gltf.json, gltf.buffers, image.bufferView);
-    arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);
-  }
-
-  assert(arrayBuffer, 'glTF image has no data');
-  let parsedImage = await parse(arrayBuffer, [ImageLoader, BasisLoader], {
-    mimeType: image.mimeType,
-    basis: options.basis || {
-      format: selectSupportedBasisFormat()
+    const { fetch, parse } = context;
+    let arrayBuffer;
+    if (image.uri && !image.hasOwnProperty('bufferView')) {
+        const uri = (0, resolve_url_1.resolveUrl)(image.uri, options);
+        const response = await fetch(uri);
+        arrayBuffer = await response.arrayBuffer();
+        image.bufferView = {
+            data: arrayBuffer
+        };
+    }
+    if (Number.isFinite(image.bufferView)) {
+        const array = (0, get_typed_array_1.getTypedArrayForBufferView)(gltf.json, gltf.buffers, image.bufferView);
+        arrayBuffer = (0, loader_utils_1.sliceArrayBuffer)(array.buffer, array.byteOffset, array.byteLength);
+    }
+    (0, assert_1.assert)(arrayBuffer, 'glTF image has no data');
+    // Call `parse`
+    let parsedImage = await parse(arrayBuffer, [images_1.ImageLoader, textures_1.BasisLoader], { mimeType: image.mimeType, basis: options.basis || { format: (0, textures_1.selectSupportedBasisFormat)() } }, context);
+    if (parsedImage && parsedImage[0]) {
+        parsedImage = {
+            compressed: true,
+            mipmaps: false,
+            width: parsedImage[0].width,
+            height: parsedImage[0].height,
+            data: parsedImage[0]
+        };
     }
-  }, context);
-
-  if (parsedImage && parsedImage[0]) {
-    parsedImage = {
-      compressed: true,
-      mipmaps: false,
-      width: parsedImage[0].width,
-      height: parsedImage[0].height,
-      data: parsedImage[0]
-    };
-  }
-
-  gltf.images = gltf.images || [];
-  gltf.images[index] = parsedImage;
+    // TODO making sure ImageLoader is overridable by using array of loaders
+    // const parsedImage = await parse(arrayBuffer, [ImageLoader]);
+    // Store the loaded image
+    gltf.images = gltf.images || [];
+    gltf.images[index] = parsedImage;
 }
-//# sourceMappingURL=parse-gltf.js.map

package/dist/lib/types/glb-types.d.ts

@@ -1,9 +1,9 @@
-export declare type GLBBinChunk = {
+export type GLBBinChunk = {
     byteOffset: number;
     byteLength: number;
     arrayBuffer: ArrayBuffer;
 };
-export declare type GLB = {
+export type GLB = {
     type: string;
     version: number;
     header: {
@@ -11,7 +11,7 @@ export declare type GLB = {
         byteLength: number;
         hasBinChunk: boolean;
     };
-    json: {};
+    json: Record<string, any>;
     binChunks: GLBBinChunk[];
 };
 //# sourceMappingURL=glb-types.d.ts.map

package/dist/lib/types/glb-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glb-types.d.ts","sourceRoot":"","sources":["../../../src/lib/types/glb-types.ts"],"names":[],"mappings":"AAAA,oBAAY,WAAW,GAAG;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AAEF,oBAAY,GAAG,GAAG;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAGhB,MAAM,EAAE;QACN,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,OAAO,CAAC;KACtB,CAAC;IAGF,IAAI,EAAE,EAAE,CAAC;IACT,SAAS,EAAE,WAAW,EAAE,CAAC;CAC1B,CAAC"}
+{"version":3,"file":"glb-types.d.ts","sourceRoot":"","sources":["../../../src/lib/types/glb-types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,GAAG,GAAG;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAGhB,MAAM,EAAE;QACN,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,OAAO,CAAC;KACtB,CAAC;IAGF,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1B,SAAS,EAAE,WAAW,EAAE,CAAC;CAC1B,CAAC"}

package/dist/lib/types/glb-types.js

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=glb-types.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });