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

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

@@ -1,141 +1,128 @@
-"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
+import { padToNBytes, assert } from '@loaders.gl/loader-utils';
+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_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_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
+const GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
 const GLB_V1_CONTENT_FORMAT_JSON = 0x0;
-const LE = true; // Binary GLTF is little endian.
+const LE = true;
+
 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))}`;
+  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)));
 }
-// 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 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;
 }
-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.`);
-    }
+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.default = parseGLBSync;
+
 function parseGLBV1(glb, dataView, 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;
+  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;
 }
+
 function parseGLBV2(glb, dataView, byteOffset, options) {
-    // 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;
+  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) {
-    // 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;
+  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);
         }
-        byteOffset += (0, loader_utils_1.padToNBytes)(chunkLength, 4);
+
+        break;
+
+      default:
+        break;
     }
-    return byteOffset;
+
+    byteOffset += padToNBytes(chunkLength, 4);
+  }
+
+  return byteOffset;
 }
-// Parse a GLB JSON chunk
+
 function parseJSONChunk(glb, dataView, byteOffset, chunkLength) {
-    // 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);
+  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);
 }
-// Parse a GLB BIN chunk
+
 function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
-    // 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);
+  glb.header.hasBinChunk = true;
+  glb.binChunks.push({
+    byteOffset,
+    byteLength: chunkLength,
+    arrayBuffer: dataView.buffer
+  });
+  return padToNBytes(chunkLength, 4);
 }
+//# sourceMappingURL=parse-glb.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/parsers/parse-glb.ts"],"names":["padToNBytes","assert","MAGIC_glTF","GLB_FILE_HEADER_SIZE","GLB_CHUNK_HEADER_SIZE","GLB_CHUNK_TYPE_JSON","GLB_CHUNK_TYPE_BIN","GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED","GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED","GLB_V1_CONTENT_FORMAT_JSON","LE","getMagicString","dataView","byteOffset","String","fromCharCode","getUint8","isGLB","arrayBuffer","options","DataView","magic","magic1","getUint32","parseGLBSync","glb","type","version","byteLength","Object","assign","header","hasBinChunk","json","binChunks","parseGLBV1","parseGLBV2","Error","contentLength","contentFormat","parseJSONChunk","parseBINChunk","parseGLBChunksSync","chunkLength","chunkFormat","strict","jsonChunk","Uint8Array","buffer","textDecoder","TextDecoder","jsonText","decode","JSON","parse","push"],"mappings":"AAIA,SAAQA,WAAR,EAAqBC,MAArB,QAAkC,0BAAlC;AAOA,MAAMC,UAAU,GAAG,UAAnB;AAEA,MAAMC,oBAAoB,GAAG,EAA7B;AACA,MAAMC,qBAAqB,GAAG,CAA9B;AAEA,MAAMC,mBAAmB,GAAG,UAA5B;AACA,MAAMC,kBAAkB,GAAG,UAA3B;AACA,MAAMC,mCAAmC,GAAG,CAA5C;AACA,MAAMC,kCAAkC,GAAG,CAA3C;AAEA,MAAMC,0BAA0B,GAAG,GAAnC;AAEA,MAAMC,EAAE,GAAG,IAAX;;AAEA,SAASC,cAAT,CAAwBC,QAAxB,EAAkCC,UAAU,GAAG,CAA/C,EAAkD;AAChD,mBACAC,MAAM,CAACC,YAAP,CAAoBH,QAAQ,CAACI,QAAT,CAAkBH,UAAU,GAAG,CAA/B,CAApB,CADA,SAEAC,MAAM,CAACC,YAAP,CAAoBH,QAAQ,CAACI,QAAT,CAAkBH,UAAU,GAAG,CAA/B,CAApB,CAFA,SAGAC,MAAM,CAACC,YAAP,CAAoBH,QAAQ,CAACI,QAAT,CAAkBH,UAAU,GAAG,CAA/B,CAApB,CAHA,SAIAC,MAAM,CAACC,YAAP,CAAoBH,QAAQ,CAACI,QAAT,CAAkBH,UAAU,GAAG,CAA/B,CAApB,CAJA;AAKD;;AAGD,OAAO,SAASI,KAAT,CACLC,WADK,EAELL,UAAkB,GAAG,CAFhB,EAGLM,OAAwB,GAAG,EAHtB,EAII;AACT,QAAMP,QAAQ,GAAG,IAAIQ,QAAJ,CAAaF,WAAb,CAAjB;AAEA,QAAM;AAACG,IAAAA,KAAK,GAAGnB;AAAT,MAAuBiB,OAA7B;AACA,QAAMG,MAAM,GAAGV,QAAQ,CAACW,SAAT,CAAmBV,UAAnB,EAA+B,KAA/B,CAAf;AACA,SAAOS,MAAM,KAAKD,KAAX,IAAoBC,MAAM,KAAKpB,UAAtC;AACD;AAED,eAAe,SAASsB,YAAT,CACbC,GADa,EAEbP,WAFa,EAGbL,UAAkB,GAAG,CAHR,EAIbM,OAAwB,GAAG,EAJd,EAKb;AAEA,QAAMP,QAAQ,GAAG,IAAIQ,QAAJ,CAAaF,WAAb,CAAjB;AAGA,QAAMQ,IAAI,GAAGf,cAAc,CAACC,QAAD,EAAWC,UAAU,GAAG,CAAxB,CAA3B;AACA,QAAMc,OAAO,GAAGf,QAAQ,CAACW,SAAT,CAAmBV,UAAU,GAAG,CAAhC,EAAmCH,EAAnC,CAAhB;AACA,QAAMkB,UAAU,GAAGhB,QAAQ,CAACW,SAAT,CAAmBV,UAAU,GAAG,CAAhC,EAAmCH,EAAnC,CAAnB;AAEAmB,EAAAA,MAAM,CAACC,MAAP,CAAcL,GAAd,EAAmB;AAEjBM,IAAAA,MAAM,EAAE;AACNlB,MAAAA,UADM;AAENe,MAAAA,UAFM;AAGNI,MAAAA,WAAW,EAAE;AAHP,KAFS;AAQjBN,IAAAA,IARiB;AASjBC,IAAAA,OATiB;AAWjBM,IAAAA,IAAI,EAAE,EAXW;AAYjBC,IAAAA,SAAS,EAAE;AAZM,GAAnB;AAeArB,EAAAA,UAAU,IAAIV,oBAAd;;AAEA,UAAQsB,GAAG,CAACE,OAAZ;AACE,SAAK,CAAL;AAEE,aAAOQ,UAAU,CAACV,GAAD,EAAMb,QAAN,EAAgBC,UAAhB,CAAjB;;AACF,SAAK,CAAL;AAEE,aAAOuB,UAAU,CAACX,GAAD,EAAMb,QAAN,EAAgBC,UAAhB,EAA6BM,OAAO,GAAG,EAAvC,CAAjB;;AACF;AACE,YAAM,IAAIkB,KAAJ,+BAAiCZ,GAAG,CAACE,OAArC,gCAAN;AARJ;AAUD;;AAED,SAASQ,UAAT,CAAoBV,GAApB,EAA8Bb,QAA9B,EAAkDC,UAAlD,EAA8E;AAE5EZ,EAAAA,MAAM,CAACwB,GAAG,CAACM,MAAJ,CAAWH,UAAX,GAAwBzB,oBAAoB,GAAGC,qBAAhD,CAAN;AAIA,QAAMkC,aAAa,GAAG1B,QAAQ,CAACW,SAAT,CAAmBV,UAAU,GAAG,CAAhC,EAAmCH,EAAnC,CAAtB;AACA,QAAM6B,aAAa,GAAG3B,QAAQ,CAACW,SAAT,CAAmBV,UAAU,GAAG,CAAhC,EAAmCH,EAAnC,CAAtB;AACAG,EAAAA,UAAU,IAAIT,qBAAd;AAGAH,EAAAA,MAAM,CAACsC,aAAa,KAAK9B,0BAAnB,CAAN;AAEA+B,EAAAA,cAAc,CAACf,GAAD,EAAMb,QAAN,EAAgBC,UAAhB,EAA4ByB,aAA5B,CAAd;AAEAzB,EAAAA,UAAU,IAAIyB,aAAd;AACAzB,EAAAA,UAAU,IAAI4B,aAAa,CAAChB,GAAD,EAAMb,QAAN,EAAgBC,UAAhB,EAA4BY,GAAG,CAACM,MAAJ,CAAWH,UAAvC,CAA3B;AAEA,SAAOf,UAAP;AACD;;AAED,SAASuB,UAAT,CACEX,GADF,EAEEb,QAFF,EAGEC,UAHF,EAIEM,OAJF,EAKU;AAERlB,EAAAA,MAAM,CAACwB,GAAG,CAACM,MAAJ,CAAWH,UAAX,GAAwBzB,oBAAoB,GAAGC,qBAAhD,CAAN;AAEAsC,EAAAA,kBAAkB,CAACjB,GAAD,EAAMb,QAAN,EAAgBC,UAAhB,EAA4BM,OAA5B,CAAlB;AAEA,SAAON,UAAU,GAAGY,GAAG,CAACM,MAAJ,CAAWH,UAA/B;AACD;;AAED,SAASc,kBAAT,CACEjB,GADF,EAEEb,QAFF,EAGEC,UAHF,EAIEM,OAJF,EAKE;AAGA,SAAON,UAAU,GAAG,CAAb,IAAkBY,GAAG,CAACM,MAAJ,CAAWH,UAApC,EAAgD;AAC9C,UAAMe,WAAW,GAAG/B,QAAQ,CAACW,SAAT,CAAmBV,UAAU,GAAG,CAAhC,EAAmCH,EAAnC,CAApB;AACA,UAAMkC,WAAW,GAAGhC,QAAQ,CAACW,SAAT,CAAmBV,UAAU,GAAG,CAAhC,EAAmCH,EAAnC,CAApB;AACAG,IAAAA,UAAU,IAAIT,qBAAd;;AAGA,YAAQwC,WAAR;AACE,WAAKvC,mBAAL;AACEmC,QAAAA,cAAc,CAACf,GAAD,EAAMb,QAAN,EAAgBC,UAAhB,EAA4B8B,WAA5B,CAAd;AACA;;AACF,WAAKrC,kBAAL;AACEmC,QAAAA,aAAa,CAAChB,GAAD,EAAMb,QAAN,EAAgBC,UAAhB,EAA4B8B,WAA5B,CAAb;AACA;;AAGF,WAAKpC,mCAAL;AACE,YAAI,CAACY,OAAO,CAAC0B,MAAb,EAAqB;AACnBL,UAAAA,cAAc,CAACf,GAAD,EAAMb,QAAN,EAAgBC,UAAhB,EAA4B8B,WAA5B,CAAd;AACD;;AACD;;AACF,WAAKnC,kCAAL;AACE,YAAI,CAACW,OAAO,CAAC0B,MAAb,EAAqB;AACnBJ,UAAAA,aAAa,CAAChB,GAAD,EAAMb,QAAN,EAAgBC,UAAhB,EAA4B8B,WAA5B,CAAb;AACD;;AACD;;AAEF;AAGE;AAvBJ;;AA0BA9B,IAAAA,UAAU,IAAIb,WAAW,CAAC2C,WAAD,EAAc,CAAd,CAAzB;AACD;;AAED,SAAO9B,UAAP;AACD;;AAGD,SAAS2B,cAAT,CAAwBf,GAAxB,EAAkCb,QAAlC,EAAsDC,UAAtD,EAA0E8B,WAA1E,EAA+F;AAE7F,QAAMG,SAAS,GAAG,IAAIC,UAAJ,CAAenC,QAAQ,CAACoC,MAAxB,EAAgCnC,UAAhC,EAA4C8B,WAA5C,CAAlB;AAGA,QAAMM,WAAW,GAAG,IAAIC,WAAJ,CAAgB,MAAhB,CAApB;AACA,QAAMC,QAAQ,GAAGF,WAAW,CAACG,MAAZ,CAAmBN,SAAnB,CAAjB;AAGArB,EAAAA,GAAG,CAACQ,IAAJ,GAAWoB,IAAI,CAACC,KAAL,CAAWH,QAAX,CAAX;AAEA,SAAOnD,WAAW,CAAC2C,WAAD,EAAc,CAAd,CAAlB;AACD;;AAGD,SAASF,aAAT,CAAuBhB,GAAvB,EAAiCb,QAAjC,EAA2CC,UAA3C,EAAuD8B,WAAvD,EAAoE;AAElElB,EAAAA,GAAG,CAACM,MAAJ,CAAWC,WAAX,GAAyB,IAAzB;AACAP,EAAAA,GAAG,CAACS,SAAJ,CAAcqB,IAAd,CAAmB;AACjB1C,IAAAA,UADiB;AAEjBe,IAAAA,UAAU,EAAEe,WAFK;AAGjBzB,IAAAA,WAAW,EAAEN,QAAQ,CAACoC;AAHL,GAAnB;AAOA,SAAOhD,WAAW,CAAC2C,WAAD,EAAc,CAAd,CAAlB;AACD","sourcesContent":["/* eslint-disable camelcase, max-statements */\n// https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#glb-file-format-specification\n// https://github.com/KhronosGroup/glTF/tree/master/extensions/1.0/Khronos/KHR_binary_glTF\nimport type {GLB} from '../types/glb-types';\nimport {padToNBytes, assert} from '@loaders.gl/loader-utils';\n\nexport type GLBParseOptions = {\n  magic?: number;\n  strict?: boolean;\n};\n\nconst MAGIC_glTF = 0x676c5446; // glTF in Big-Endian ASCII\n\nconst GLB_FILE_HEADER_SIZE = 12;\nconst GLB_CHUNK_HEADER_SIZE = 8;\n\nconst GLB_CHUNK_TYPE_JSON = 0x4e4f534a;\nconst GLB_CHUNK_TYPE_BIN = 0x004e4942;\nconst GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0; // DEPRECATED - Backward compatibility for old xviz files\nconst GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1; // DEPRECATED - Backward compatibility for old xviz files\n\nconst GLB_V1_CONTENT_FORMAT_JSON = 0x0;\n\nconst LE = true; // Binary GLTF is little endian.\n\nfunction getMagicString(dataView, byteOffset = 0) {\n  return `\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 0))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 1))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 2))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;\n}\n\n// Check if a data view is a GLB\nexport function isGLB(\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number = 0,\n  options: GLBParseOptions = {}\n): boolean {\n  const dataView = new DataView(arrayBuffer);\n  // Check that GLB Header starts with the magic number\n  const {magic = MAGIC_glTF} = options;\n  const magic1 = dataView.getUint32(byteOffset, false);\n  return magic1 === magic || magic1 === MAGIC_glTF;\n}\n\nexport default function parseGLBSync(\n  glb: GLB,\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number = 0,\n  options: GLBParseOptions = {}\n) {\n  // Check that GLB Header starts with the magic number\n  const dataView = new DataView(arrayBuffer);\n\n  // Compare format with GLBLoader documentation\n  const type = getMagicString(dataView, byteOffset + 0);\n  const version = dataView.getUint32(byteOffset + 4, LE); // Version 2 of binary glTF container format\n  const byteLength = dataView.getUint32(byteOffset + 8, LE); // Total byte length of binary file\n\n  Object.assign(glb, {\n    // Put less important stuff in a header, to avoid clutter\n    header: {\n      byteOffset, // Byte offset into the initial arrayBuffer\n      byteLength,\n      hasBinChunk: false\n    },\n\n    type,\n    version,\n\n    json: {},\n    binChunks: []\n  } as GLB);\n\n  byteOffset += GLB_FILE_HEADER_SIZE;\n\n  switch (glb.version) {\n    case 1:\n      // eslint-disable-next-line\n      return parseGLBV1(glb, dataView, byteOffset);\n    case 2:\n      // eslint-disable-next-line\n      return parseGLBV2(glb, dataView, byteOffset, (options = {}));\n    default:\n      throw new Error(`Invalid GLB version ${glb.version}. Only supports v1 and v2.`);\n  }\n}\n\nfunction parseGLBV1(glb: GLB, dataView: DataView, byteOffset: number): number {\n  // Sanity: ensure file is big enough to hold at least the headers\n  assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);\n\n  // Explanation of GLB structure:\n  // https://cloud.githubusercontent.com/assets/3479527/22600725/36b87122-ea55-11e6-9d40-6fd42819fcab.png\n  const contentLength = dataView.getUint32(byteOffset + 0, LE); // Byte length of chunk\n  const contentFormat = dataView.getUint32(byteOffset + 4, LE); // Chunk format as uint32\n  byteOffset += GLB_CHUNK_HEADER_SIZE;\n\n  // GLB v1 only supports a single chunk type\n  assert(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);\n\n  parseJSONChunk(glb, dataView, byteOffset, contentLength);\n  // No need to call the function padToBytes() from parseJSONChunk()\n  byteOffset += contentLength;\n  byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);\n\n  return byteOffset;\n}\n\nfunction parseGLBV2(\n  glb: GLB,\n  dataView: DataView,\n  byteOffset: number,\n  options: GLBParseOptions\n): number {\n  // Sanity: ensure file is big enough to hold at least the first chunk header\n  assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);\n\n  parseGLBChunksSync(glb, dataView, byteOffset, options);\n\n  return byteOffset + glb.header.byteLength;\n}\n\nfunction parseGLBChunksSync(\n  glb: GLB,\n  dataView: DataView,\n  byteOffset: number,\n  options: GLBParseOptions\n) {\n  // Per spec we must iterate over chunks, ignoring all except JSON and BIN\n  // Iterate as long as there is space left for another chunk header\n  while (byteOffset + 8 <= glb.header.byteLength) {\n    const chunkLength = dataView.getUint32(byteOffset + 0, LE); // Byte length of chunk\n    const chunkFormat = dataView.getUint32(byteOffset + 4, LE); // Chunk format as uint32\n    byteOffset += GLB_CHUNK_HEADER_SIZE;\n\n    // Per spec we must iterate over chunks, ignoring all except JSON and BIN\n    switch (chunkFormat) {\n      case GLB_CHUNK_TYPE_JSON:\n        parseJSONChunk(glb, dataView, byteOffset, chunkLength);\n        break;\n      case GLB_CHUNK_TYPE_BIN:\n        parseBINChunk(glb, dataView, byteOffset, chunkLength);\n        break;\n\n      // Backward compatibility for very old xviz files\n      case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:\n        if (!options.strict) {\n          parseJSONChunk(glb, dataView, byteOffset, chunkLength);\n        }\n        break;\n      case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:\n        if (!options.strict) {\n          parseBINChunk(glb, dataView, byteOffset, chunkLength);\n        }\n        break;\n\n      default:\n        // Ignore, per spec\n        // console.warn(`Unknown GLB chunk type`); // eslint-disable-line\n        break;\n    }\n\n    byteOffset += padToNBytes(chunkLength, 4);\n  }\n\n  return byteOffset;\n}\n\n// Parse a GLB JSON chunk\nfunction parseJSONChunk(glb: GLB, dataView: DataView, byteOffset: number, chunkLength: number) {\n  // 1. Create a \"view\" of the binary encoded JSON data inside the GLB\n  const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);\n\n  // 2. Decode the JSON binary array into clear text\n  const textDecoder = new TextDecoder('utf8');\n  const jsonText = textDecoder.decode(jsonChunk);\n\n  // 3. Parse the JSON text into a JavaScript data structure\n  glb.json = JSON.parse(jsonText);\n\n  return padToNBytes(chunkLength, 4);\n}\n\n// Parse a GLB BIN chunk\nfunction parseBINChunk(glb: GLB, dataView, byteOffset, chunkLength) {\n  // Note: BIN chunk can be optional\n  glb.header.hasBinChunk = true;\n  glb.binChunks.push({\n    byteOffset,\n    byteLength: chunkLength,\n    arrayBuffer: dataView.buffer\n    // TODO - copy, or create typed array view?\n  });\n\n  return padToNBytes(chunkLength, 4);\n}\n"],"file":"parse-glb.js"}

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

@@ -1,189 +1,170 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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);
+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);
 }
-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);
+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);
     promises.push(promise);
-    // 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;
+  }
+
+  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;
 }
-exports.parseGLTF = parseGLTF;
-// `data` - can be ArrayBuffer (GLB), ArrayBuffer (Binary JSON), String (JSON), or Object (parsed JSON)
+
 function parseGLTFContainerSync(gltf, data, byteOffset, options) {
-    // 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({});
+  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({});
 }
-/** 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) {
-    // 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;
-        }
+  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;
     }
+  }
 }
-/**
- * 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 = (0, resolve_url_1.resolveUrl)(image.uri, options);
-        const response = await fetch(uri);
-        arrayBuffer = await response.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
-        };
+  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()
     }
-    // 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;
+  }, 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;
 }
+//# sourceMappingURL=parse-gltf.js.map