@loaders.gl/gltf 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/lib/gltf-utils/gltf-attribute-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf-attribute-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-attribute-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,2BAA2B,CAAC;AAO5D,wBAAgB,gBAAgB,CAAC,UAAU,KAAA,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAC,CAU1E;AAKD,wBAAgB,eAAe,CAAC,SAAS,KAAA,gBAmBxC"}
+{"version":3,"file":"gltf-attribute-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-attribute-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,YAAY,EAAC,qCAAkC;AAO5D,wBAAgB,gBAAgB,CAAC,UAAU,KAAA,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAC,CAU1E;AAKD,wBAAgB,eAAe,CAAC,SAAS,KAAA,gBAmBxC"}

package/dist/lib/gltf-utils/gltf-attribute-utils.js

@@ -1,62 +1,68 @@
+// TODO - remove
 import { getAccessorTypeFromSize, getComponentTypeFromArray } from "./gltf-utils.js";
+// 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) {
-  const accessors = {};
-  for (const name in attributes) {
-    const attribute = attributes[name];
-    if (name !== 'indices') {
-      const glTFAccessor = getGLTFAccessor(attribute);
-      accessors[name] = glTFAccessor;
+    const accessors = {};
+    for (const name in attributes) {
+        const attribute = attributes[name];
+        if (name !== 'indices') {
+            const glTFAccessor = getGLTFAccessor(attribute);
+            accessors[name] = glTFAccessor;
+        }
     }
-  }
-  return accessors;
+    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 = {
-    value: buffer,
-    size,
-    byteOffset: 0,
-    count,
-    type: getAccessorTypeFromSize(size),
-    componentType: getComponentTypeFromArray(buffer)
-  };
-  return glTFAccessor;
+    const { buffer, size, count } = getAccessorData(attribute);
+    const 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);
+    let buffer = attribute;
+    let size = 1;
+    let count = 0;
+    if (attribute && attribute.value) {
+        buffer = attribute.value;
+        size = attribute.size || 1;
     }
-    count = buffer.length / size;
-  }
-  return {
-    buffer,
-    size,
-    count
-  };
+    if (buffer) {
+        if (!ArrayBuffer.isView(buffer)) {
+            buffer = toTypedArray(buffer, Float32Array);
+        }
+        count = buffer.length / size;
+    }
+    return { buffer, size, count };
 }
-function toTypedArray(array, ArrayType) {
-  let convertTypedArrays = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  if (!array) {
-    return null;
-  }
-  if (Array.isArray(array)) {
-    return new ArrayType(array);
-  }
-  if (convertTypedArrays && !(array instanceof ArrayType)) {
-    return new ArrayType(array);
-  }
-  return array;
+// 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;
 }
-//# sourceMappingURL=gltf-attribute-utils.js.map

package/dist/lib/gltf-utils/gltf-constants.js

@@ -1,37 +1,37 @@
 export const COMPONENTS = {
-  SCALAR: 1,
-  VEC2: 2,
-  VEC3: 3,
-  VEC4: 4,
-  MAT2: 4,
-  MAT3: 9,
-  MAT4: 16
+    SCALAR: 1,
+    VEC2: 2,
+    VEC3: 3,
+    VEC4: 4,
+    MAT2: 4,
+    MAT3: 9,
+    MAT4: 16
 };
 export const BYTES = {
-  5120: 1,
-  5121: 1,
-  5122: 2,
-  5123: 2,
-  5125: 4,
-  5126: 4
+    5120: 1, // BYTE
+    5121: 1, // UNSIGNED_BYTE
+    5122: 2, // SHORT
+    5123: 2, // UNSIGNED_SHORT
+    5125: 4, // UNSIGNED_INT
+    5126: 4 // FLOAT
 };
+// ENUM LOOKUP
 export function getBytesFromComponentType(componentType) {
-  return BYTES[componentType];
+    return BYTES[componentType];
 }
 export function getSizeFromAccessorType(type) {
-  return COMPONENTS[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];
+    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];
 }
-//# sourceMappingURL=gltf-constants.js.map

package/dist/lib/gltf-utils/gltf-utils.d.ts

@@ -1,4 +1,4 @@
-import type { GLTFPostprocessed } from '../types/gltf-postprocessed-schema';
+import type { GLTFPostprocessed } from "../types/gltf-postprocessed-schema.js";
 export declare function getAccessorTypeFromSize(size: any): string;
 export declare function getComponentTypeFromArray(typedArray: any): number;
 export declare function getAccessorArrayTypeAndLength(accessor: any, bufferView: any): {

package/dist/lib/gltf-utils/gltf-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oCAAoC,CAAC;AA8D1E,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,UAG3C;AAED,wBAAgB,yBAAyB,CAAC,UAAU,KAAA,UAMnD;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,KAAA,EAAE,UAAU,KAAA;;;;;;EAUjE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAiBlE"}
+{"version":3,"file":"gltf-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,iBAAiB,EAAC,8CAA2C;AA8D1E,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,UAG3C;AAED,wBAAgB,yBAAyB,CAAC,UAAU,KAAA,UAMnD;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,KAAA,EAAE,UAAU,KAAA;;;;;;EAUjE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAiBlE"}

package/dist/lib/gltf-utils/gltf-utils.js

@@ -1,79 +1,86 @@
 import { assert } from "../utils/assert.js";
 import { BYTES, COMPONENTS } from "../gltf-utils/gltf-constants.js";
+/**
+ * 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'];
-const ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [[Int8Array, 5120], [Uint8Array, 5121], [Int16Array, 5122], [Uint16Array, 5123], [Uint32Array, 5125], [Float32Array, 5126], [Float64Array, 5130]];
+const ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
+    [Int8Array, 5120],
+    [Uint8Array, 5121],
+    [Int16Array, 5122],
+    [Uint16Array, 5123],
+    [Uint32Array, 5125],
+    [Float32Array, 5126],
+    [Float64Array, 5130]
+];
 const ARRAY_TO_COMPONENT_TYPE = new Map(ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT);
 const ATTRIBUTE_TYPE_TO_COMPONENTS = {
-  SCALAR: 1,
-  VEC2: 2,
-  VEC3: 3,
-  VEC4: 4,
-  MAT2: 4,
-  MAT3: 9,
-  MAT4: 16
+    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,
-  5125: 4,
-  5126: 4
+    5120: 1,
+    5121: 1,
+    5122: 2,
+    5123: 2,
+    5125: 4,
+    5126: 4
 };
 const ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
-  5120: Int8Array,
-  5121: Uint8Array,
-  5122: Int16Array,
-  5123: Uint16Array,
-  5125: Uint32Array,
-  5126: Float32Array
+    5120: Int8Array,
+    5121: Uint8Array,
+    5122: Int16Array,
+    5123: Uint16Array,
+    5125: Uint32Array,
+    5126: Float32Array
 };
 export function getAccessorTypeFromSize(size) {
-  const type = TYPES[size - 1];
-  return type || TYPES[0];
+    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;
+    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
-  };
+    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) {
-  let {
-    images,
-    bufferViews
-  } = gltf;
-  images = images || [];
-  bufferViews = bufferViews || [];
-  const imageBufferViews = images.map(i => i.bufferView);
-  bufferViews = bufferViews.filter(view => !imageBufferViews.includes(view));
-  const bufferMemory = bufferViews.reduce((acc, view) => acc + view.byteLength, 0);
-  const pixelCount = images.reduce((acc, image) => {
-    const {
-      width,
-      height
-    } = image.image;
-    return acc + width * height;
-  }, 0);
-  return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);
+    let { images, bufferViews } = gltf;
+    images = images || [];
+    bufferViews = bufferViews || [];
+    const imageBufferViews = images.map((i) => i.bufferView);
+    bufferViews = bufferViews.filter((view) => !imageBufferViews.includes(view));
+    const bufferMemory = bufferViews.reduce((acc, view) => acc + view.byteLength, 0);
+    // Assume each pixel of the texture is 4 channel with mimmaps (which add 33%)
+    // TODO correctly handle compressed textures
+    const pixelCount = images.reduce((acc, image) => {
+        // @ts-ignore
+        const { width, height } = image.image;
+        return acc + width * height;
+    }, 0);
+    return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);
 }
-//# sourceMappingURL=gltf-utils.js.map

package/dist/lib/gltf-utils/resolve-url.js

@@ -1,12 +1,14 @@
+// Resolves a relative url against a baseUrl
+// If url is absolute, return it unchanged
 export function resolveUrl(url, options) {
-  const absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');
-  if (absolute) {
-    return url;
-  }
-  const baseUrl = options.baseUri || options.uri;
-  if (!baseUrl) {
-    throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);
-  }
-  return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;
+    // 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;
+    if (!baseUrl) {
+        throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);
+    }
+    return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;
 }
-//# sourceMappingURL=resolve-url.js.map

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

@@ -1,4 +1,4 @@
-import type { GLB } from '../types/glb-types';
+import type { GLB } from "../types/glb-types.js";
 /** Options for parsing a GLB */
 export type ParseGLBOptions = {
     /** @deprecated This option was used by XVIZ protocol to define a non-standard magic number */

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

@@ -1 +1 @@
-{"version":3,"file":"parse-glb.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-glb.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oBAAoB,CAAC;AAG5C,gCAAgC;AAChC,MAAM,MAAM,eAAe,GAAG;IAC5B,8FAA8F;IAC9F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qFAAqF;IACrF,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AA0BF,yEAAyE;AACzE,wBAAgB,KAAK,CACnB,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,MAAU,EACtB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAMT;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,MAAU,EACtB,OAAO,GAAE,eAAoB,UAmC9B"}
+{"version":3,"file":"parse-glb.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-glb.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,GAAG,EAAC,8BAA2B;AAG5C,gCAAgC;AAChC,MAAM,MAAM,eAAe,GAAG;IAC5B,8FAA8F;IAC9F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qFAAqF;IACrF,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AA0BF,yEAAyE;AACzE,wBAAgB,KAAK,CACnB,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,MAAU,EACtB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAMT;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,MAAU,EACtB,OAAO,GAAE,eAAoB,UAmC9B"}

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

@@ -1,118 +1,161 @@
 import { padToNBytes, assert } from '@loaders.gl/loader-utils';
+/** Binary GLTF is little endian. */
 const LITTLE_ENDIAN = true;
+/** 'glTF' in Big-Endian ASCII */
 const MAGIC_glTF = 0x676c5446;
 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_V1_CONTENT_FORMAT_JSON = 0x0;
+/** @deprecated - Backward compatibility for old xviz files */
 const GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
+/** @deprecated - Backward compatibility for old xviz files */
 const GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
-function getMagicString(dataView) {
-  let byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  return `\
+function getMagicString(dataView, byteOffset = 0) {
+    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) {
-  let byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  const dataView = new DataView(arrayBuffer);
-  const {
-    magic = MAGIC_glTF
-  } = options;
-  const magic1 = dataView.getUint32(byteOffset, false);
-  return magic1 === magic || magic1 === MAGIC_glTF;
+/** Check if the contents of an array buffer contains GLB byte markers */
+export 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 function parseGLBSync(glb, arrayBuffer) {
-  let byteOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-  let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  const dataView = new DataView(arrayBuffer);
-  const type = getMagicString(dataView, byteOffset + 0);
-  const version = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN);
-  const byteLength = dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN);
-  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 ${glb.version}. Only supports version 1 and 2.`);
-  }
+/**
+ * Synchronously parse a GLB
+ * @param glb - Target, Output is stored there
+ * @param arrayBuffer - Input data
+ * @param byteOffset - Offset into arrayBuffer to start parsing from (for "embedded" GLBs, e.g. in 3D tiles)
+ * @param options
+ * @returns
+ */
+export 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, LITTLE_ENDIAN); // Version 2 of binary glTF container format
+    const byteLength = dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN); // Total byte length of binary file
+    Object.assign(glb, {
+        // Put less important stuff in a header, to avoid clutter
+        header: {
+            byteOffset, // Byte offset into the initial arrayBuffer
+            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 ${glb.version}. Only supports version 1 and 2.`);
+    }
 }
+/**
+ * Parse a V1 GLB
+ * @param glb - target, output is stored in this object
+ * @param dataView - Input, memory to be parsed
+ * @param byteOffset - Offset of first byte of GLB data in the data view
+ * @returns Number of bytes parsed (there could be additional non-GLB data after the GLB)
+ */
 function parseGLBV1(glb, dataView, byteOffset) {
-  assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
-  const contentLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN);
-  const contentFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN);
-  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
+    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, LITTLE_ENDIAN); // Byte length of chunk
+    const contentFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN); // Chunk format as uint32
+    byteOffset += GLB_CHUNK_HEADER_SIZE;
+    // GLB v1 only supports a single chunk type
+    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;
 }
+/**
+ * Parse a V2 GLB
+ * @param glb - target, output is stored in this object
+ * @param dataView - Input, memory to be parsed
+ * @param byteOffset - Offset of first byte of GLB data in the data view
+ * @returns Number of bytes parsed (there could be additional non-GLB data after the GLB)
+ */
 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
+    assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+    parseGLBChunksSync(glb, dataView, byteOffset, options);
+    return byteOffset + glb.header.byteLength;
 }
+/** Iterate over GLB chunks and parse them */
 function parseGLBChunksSync(glb, dataView, byteOffset, options) {
-  while (byteOffset + 8 <= glb.header.byteLength) {
-    const chunkLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN);
-    const chunkFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN);
-    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, LITTLE_ENDIAN); // Byte length of chunk
+        const chunkFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN); // 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 += 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 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 padToNBytes(chunkLength, 4);
 }
-//# sourceMappingURL=parse-glb.js.map