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

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

@@ -1,128 +1,141 @@
-import { padToNBytes, assert } from '@loaders.gl/loader-utils';
-const MAGIC_glTF = 0x676c5446;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGLB = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const MAGIC_glTF = 0x676c5446; // glTF in Big-Endian ASCII
 const GLB_FILE_HEADER_SIZE = 12;
 const GLB_CHUNK_HEADER_SIZE = 8;
 const GLB_CHUNK_TYPE_JSON = 0x4e4f534a;
 const GLB_CHUNK_TYPE_BIN = 0x004e4942;
-const GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
-const GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
+const GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0; // DEPRECATED - Backward compatibility for old xviz files
+const GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1; // DEPRECATED - Backward compatibility for old xviz files
 const GLB_V1_CONTENT_FORMAT_JSON = 0x0;
-const LE = true;
-
+const LE = true; // Binary GLTF is little endian.
 function getMagicString(dataView, byteOffset = 0) {
-  return "".concat(String.fromCharCode(dataView.getUint8(byteOffset + 0))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 1))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 2))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 3)));
+    return `\
+${String.fromCharCode(dataView.getUint8(byteOffset + 0))}\
+${String.fromCharCode(dataView.getUint8(byteOffset + 1))}\
+${String.fromCharCode(dataView.getUint8(byteOffset + 2))}\
+${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;
 }
-
-export function isGLB(arrayBuffer, byteOffset = 0, options = {}) {
-  const dataView = new DataView(arrayBuffer);
-  const {
-    magic = MAGIC_glTF
-  } = options;
-  const magic1 = dataView.getUint32(byteOffset, false);
-  return magic1 === magic || magic1 === MAGIC_glTF;
+// Check if a data view is a GLB
+function isGLB(arrayBuffer, byteOffset = 0, options = {}) {
+    const dataView = new DataView(arrayBuffer);
+    // Check that GLB Header starts with the magic number
+    const { magic = MAGIC_glTF } = options;
+    const magic1 = dataView.getUint32(byteOffset, false);
+    return magic1 === magic || magic1 === MAGIC_glTF;
 }
-export default function parseGLBSync(glb, arrayBuffer, byteOffset = 0, options = {}) {
-  const dataView = new DataView(arrayBuffer);
-  const type = getMagicString(dataView, byteOffset + 0);
-  const version = dataView.getUint32(byteOffset + 4, LE);
-  const byteLength = dataView.getUint32(byteOffset + 8, LE);
-  Object.assign(glb, {
-    header: {
-      byteOffset,
-      byteLength,
-      hasBinChunk: false
-    },
-    type,
-    version,
-    json: {},
-    binChunks: []
-  });
-  byteOffset += GLB_FILE_HEADER_SIZE;
-
-  switch (glb.version) {
-    case 1:
-      return parseGLBV1(glb, dataView, byteOffset);
-
-    case 2:
-      return parseGLBV2(glb, dataView, byteOffset, options = {});
-
-    default:
-      throw new Error("Invalid GLB version ".concat(glb.version, ". Only supports v1 and v2."));
-  }
+exports.isGLB = isGLB;
+function parseGLBSync(glb, arrayBuffer, byteOffset = 0, options = {}) {
+    // Check that GLB Header starts with the magic number
+    const dataView = new DataView(arrayBuffer);
+    // Compare format with GLBLoader documentation
+    const type = getMagicString(dataView, byteOffset + 0);
+    const version = dataView.getUint32(byteOffset + 4, LE); // Version 2 of binary glTF container format
+    const byteLength = dataView.getUint32(byteOffset + 8, LE); // Total byte length of binary file
+    Object.assign(glb, {
+        // Put less important stuff in a header, to avoid clutter
+        header: {
+            byteOffset,
+            byteLength,
+            hasBinChunk: false
+        },
+        type,
+        version,
+        json: {},
+        binChunks: []
+    });
+    byteOffset += GLB_FILE_HEADER_SIZE;
+    switch (glb.version) {
+        case 1:
+            // eslint-disable-next-line
+            return parseGLBV1(glb, dataView, byteOffset);
+        case 2:
+            // eslint-disable-next-line
+            return parseGLBV2(glb, dataView, byteOffset, (options = {}));
+        default:
+            throw new Error(`Invalid GLB version ${glb.version}. Only supports v1 and v2.`);
+    }
 }
-
+exports.default = parseGLBSync;
 function parseGLBV1(glb, dataView, byteOffset) {
-  assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
-  const contentLength = dataView.getUint32(byteOffset + 0, LE);
-  const contentFormat = dataView.getUint32(byteOffset + 4, LE);
-  byteOffset += GLB_CHUNK_HEADER_SIZE;
-  assert(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);
-  parseJSONChunk(glb, dataView, byteOffset, contentLength);
-  byteOffset += contentLength;
-  byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);
-  return byteOffset;
+    // Sanity: ensure file is big enough to hold at least the headers
+    (0, loader_utils_1.assert)(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+    // Explanation of GLB structure:
+    // https://cloud.githubusercontent.com/assets/3479527/22600725/36b87122-ea55-11e6-9d40-6fd42819fcab.png
+    const contentLength = dataView.getUint32(byteOffset + 0, LE); // Byte length of chunk
+    const contentFormat = dataView.getUint32(byteOffset + 4, LE); // Chunk format as uint32
+    byteOffset += GLB_CHUNK_HEADER_SIZE;
+    // GLB v1 only supports a single chunk type
+    (0, loader_utils_1.assert)(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);
+    parseJSONChunk(glb, dataView, byteOffset, contentLength);
+    // No need to call the function padToBytes() from parseJSONChunk()
+    byteOffset += contentLength;
+    byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);
+    return byteOffset;
 }
-
 function parseGLBV2(glb, dataView, byteOffset, options) {
-  assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
-  parseGLBChunksSync(glb, dataView, byteOffset, options);
-  return byteOffset + glb.header.byteLength;
+    // Sanity: ensure file is big enough to hold at least the first chunk header
+    (0, loader_utils_1.assert)(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+    parseGLBChunksSync(glb, dataView, byteOffset, options);
+    return byteOffset + glb.header.byteLength;
 }
-
 function parseGLBChunksSync(glb, dataView, byteOffset, options) {
-  while (byteOffset + 8 <= glb.header.byteLength) {
-    const chunkLength = dataView.getUint32(byteOffset + 0, LE);
-    const chunkFormat = dataView.getUint32(byteOffset + 4, LE);
-    byteOffset += GLB_CHUNK_HEADER_SIZE;
-
-    switch (chunkFormat) {
-      case GLB_CHUNK_TYPE_JSON:
-        parseJSONChunk(glb, dataView, byteOffset, chunkLength);
-        break;
-
-      case GLB_CHUNK_TYPE_BIN:
-        parseBINChunk(glb, dataView, byteOffset, chunkLength);
-        break;
-
-      case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:
-        if (!options.strict) {
-          parseJSONChunk(glb, dataView, byteOffset, chunkLength);
-        }
-
-        break;
-
-      case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:
-        if (!options.strict) {
-          parseBINChunk(glb, dataView, byteOffset, chunkLength);
+    // Per spec we must iterate over chunks, ignoring all except JSON and BIN
+    // Iterate as long as there is space left for another chunk header
+    while (byteOffset + 8 <= glb.header.byteLength) {
+        const chunkLength = dataView.getUint32(byteOffset + 0, LE); // Byte length of chunk
+        const chunkFormat = dataView.getUint32(byteOffset + 4, LE); // Chunk format as uint32
+        byteOffset += GLB_CHUNK_HEADER_SIZE;
+        // Per spec we must iterate over chunks, ignoring all except JSON and BIN
+        switch (chunkFormat) {
+            case GLB_CHUNK_TYPE_JSON:
+                parseJSONChunk(glb, dataView, byteOffset, chunkLength);
+                break;
+            case GLB_CHUNK_TYPE_BIN:
+                parseBINChunk(glb, dataView, byteOffset, chunkLength);
+                break;
+            // Backward compatibility for very old xviz files
+            case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:
+                if (!options.strict) {
+                    parseJSONChunk(glb, dataView, byteOffset, chunkLength);
+                }
+                break;
+            case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:
+                if (!options.strict) {
+                    parseBINChunk(glb, dataView, byteOffset, chunkLength);
+                }
+                break;
+            default:
+                // Ignore, per spec
+                // console.warn(`Unknown GLB chunk type`); // eslint-disable-line
+                break;
         }
-
-        break;
-
-      default:
-        break;
+        byteOffset += (0, loader_utils_1.padToNBytes)(chunkLength, 4);
     }
-
-    byteOffset += padToNBytes(chunkLength, 4);
-  }
-
-  return byteOffset;
+    return byteOffset;
 }
-
+// Parse a GLB JSON chunk
 function parseJSONChunk(glb, dataView, byteOffset, chunkLength) {
-  const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);
-  const textDecoder = new TextDecoder('utf8');
-  const jsonText = textDecoder.decode(jsonChunk);
-  glb.json = JSON.parse(jsonText);
-  return padToNBytes(chunkLength, 4);
+    // 1. Create a "view" of the binary encoded JSON data inside the GLB
+    const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);
+    // 2. Decode the JSON binary array into clear text
+    const textDecoder = new TextDecoder('utf8');
+    const jsonText = textDecoder.decode(jsonChunk);
+    // 3. Parse the JSON text into a JavaScript data structure
+    glb.json = JSON.parse(jsonText);
+    return (0, loader_utils_1.padToNBytes)(chunkLength, 4);
 }
-
+// Parse a GLB BIN chunk
 function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
-  glb.header.hasBinChunk = true;
-  glb.binChunks.push({
-    byteOffset,
-    byteLength: chunkLength,
-    arrayBuffer: dataView.buffer
-  });
-  return padToNBytes(chunkLength, 4);
+    // Note: BIN chunk can be optional
+    glb.header.hasBinChunk = true;
+    glb.binChunks.push({
+        byteOffset,
+        byteLength: chunkLength,
+        arrayBuffer: dataView.buffer
+        // TODO - copy, or create typed array view?
+    });
+    return (0, loader_utils_1.padToNBytes)(chunkLength, 4);
 }
-//# sourceMappingURL=parse-glb.js.map

package/dist/lib/parsers/parse-gltf.d.ts

@@ -0,0 +1,14 @@
+import type { LoaderContext } from '@loaders.gl/loader-utils';
+import type { GLTFLoaderOptions } from '../../gltf-loader';
+import type { GLTFWithBuffers } from '../types/gltf-types';
+export type GLTFParseOptions = {
+    normalize?: boolean;
+    loadImages?: boolean;
+    loadBuffers?: boolean;
+    decompressMeshes?: boolean;
+    postProcess?: boolean;
+    excludeExtensions?: string[];
+};
+export declare function isGLTF(arrayBuffer: any, options?: any): boolean;
+export declare function parseGLTF(gltf: GLTFWithBuffers, arrayBufferOrString: any, byteOffset: number | undefined, options: GLTFLoaderOptions, context: LoaderContext): Promise<Record<string, any> | GLTFWithBuffers>;
+//# sourceMappingURL=parse-gltf.d.ts.map

package/dist/lib/parsers/parse-gltf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-gltf.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-gltf.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE5D,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAEzD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,qBAAqB,CAAC;AAYzD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAMF,wBAAgB,MAAM,CAAC,WAAW,KAAA,EAAE,OAAO,CAAC,KAAA,GAAG,OAAO,CAGrD;AAED,wBAAsB,SAAS,CAC7B,IAAI,EAAE,eAAe,EACrB,mBAAmB,KAAA,EACnB,UAAU,oBAAI,EACd,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,aAAa,kDA4BvB"}

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: {
-      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
-    };
-  }
-
-  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