@loaders.gl/gltf 3.1.0-alpha.3 → 3.1.0-alpha.4

package/dist/es5/lib/gltf-utils/get-typed-array.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/gltf-utils/get-typed-array.ts"],"names":["getTypedArrayForBufferView","json","buffers","bufferViewIndex","bufferView","bufferViews","bufferIndex","buffer","binChunk","byteOffset","Uint8Array","arrayBuffer","byteLength","getTypedArrayForImageData","imageIndex","image","images"],"mappings":";;;;;;;;AACA;;AAIO,SAASA,0BAAT,CAAoCC,IAApC,EAA0CC,OAA1C,EAAmDC,eAAnD,EAAoE;AACzE,MAAMC,UAAU,GAAGH,IAAI,CAACI,WAAL,CAAiBF,eAAjB,CAAnB;AACA,sBAAOC,UAAP;AAGA,MAAME,WAAW,GAAGF,UAAU,CAACG,MAA/B;AACA,MAAMC,QAAQ,GAAGN,OAAO,CAACI,WAAD,CAAxB;AACA,sBAAOE,QAAP;AAEA,MAAMC,UAAU,GAAG,CAACL,UAAU,CAACK,UAAX,IAAyB,CAA1B,IAA+BD,QAAQ,CAACC,UAA3D;AACA,SAAO,IAAIC,UAAJ,CAAeF,QAAQ,CAACG,WAAxB,EAAqCF,UAArC,EAAiDL,UAAU,CAACQ,UAA5D,CAAP;AACD;;AAIM,SAASC,yBAAT,CAAmCZ,IAAnC,EAAyCC,OAAzC,EAAkDY,UAAlD,EAA8D;AACnE,MAAMC,KAAK,GAAGd,IAAI,CAACe,MAAL,CAAYF,UAAZ,CAAd;AACA,MAAMX,eAAe,GAAGF,IAAI,CAACI,WAAL,CAAiBU,KAAK,CAACX,UAAvB,CAAxB;AACA,SAAOJ,0BAA0B,CAACC,IAAD,EAAOC,OAAP,EAAgBC,eAAhB,CAAjC;AACD","sourcesContent":["// TODO - GLTFScenegraph should use these\nimport {assert} from '../utils/assert';\n\n// accepts buffer view index or buffer view object\n// returns a `Uint8Array`\nexport function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {\n  const bufferView = json.bufferViews[bufferViewIndex];\n  assert(bufferView);\n\n  // Get hold of the arrayBuffer\n  const bufferIndex = bufferView.buffer;\n  const binChunk = buffers[bufferIndex];\n  assert(binChunk);\n\n  const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;\n  return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);\n}\n\n// accepts accessor index or accessor object\n// returns a `Uint8Array`\nexport function getTypedArrayForImageData(json, buffers, imageIndex) {\n  const image = json.images[imageIndex];\n  const bufferViewIndex = json.bufferViews[image.bufferView];\n  return getTypedArrayForBufferView(json, buffers, bufferViewIndex);\n}\n\n/*\n// accepts accessor index or accessor object\n// returns a typed array with type that matches the types\nexport function getTypedArrayForAccessor(accessor) {\n  accessor = this.getAccessor(accessor);\n  const bufferView = this.getBufferView(accessor.bufferView);\n  const buffer = this.getBuffer(bufferView.buffer);\n  const arrayBuffer = buffer.data;\n\n  // Create a new typed array as a view into the combined buffer\n  const {ArrayType, length} = getAccessorArrayTypeAndLength(accessor, bufferView);\n  const byteOffset = bufferView.byteOffset + accessor.byteOffset;\n  return new ArrayType(arrayBuffer, byteOffset, length);\n}\n*/\n"],"file":"get-typed-array.js"}

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

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getGLTFAccessors = getGLTFAccessors;
+exports.getGLTFAccessor = getGLTFAccessor;
+
+var _gltfUtils = require("./gltf-utils");
+
+function getGLTFAccessors(attributes) {
+  var accessors = {};
+
+  for (var name in attributes) {
+    var attribute = attributes[name];
+
+    if (name !== 'indices') {
+      var glTFAccessor = getGLTFAccessor(attribute);
+      accessors[name] = glTFAccessor;
+    }
+  }
+
+  return accessors;
+}
+
+function getGLTFAccessor(attribute) {
+  var _getAccessorData = getAccessorData(attribute),
+      buffer = _getAccessorData.buffer,
+      size = _getAccessorData.size,
+      count = _getAccessorData.count;
+
+  var glTFAccessor = {
+    value: buffer,
+    size: size,
+    byteOffset: 0,
+    count: count,
+    type: (0, _gltfUtils.getAccessorTypeFromSize)(size),
+    componentType: (0, _gltfUtils.getComponentTypeFromArray)(buffer)
+  };
+  return glTFAccessor;
+}
+
+function getAccessorData(attribute) {
+  var buffer = attribute;
+  var size = 1;
+  var count = 0;
+
+  if (attribute && attribute.value) {
+    buffer = attribute.value;
+    size = attribute.size || 1;
+  }
+
+  if (buffer) {
+    if (!ArrayBuffer.isView(buffer)) {
+      buffer = toTypedArray(buffer, Float32Array);
+    }
+
+    count = buffer.length / size;
+  }
+
+  return {
+    buffer: buffer,
+    size: size,
+    count: count
+  };
+}
+
+function toTypedArray(array, ArrayType) {
+  var 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;
+}
+//# sourceMappingURL=gltf-attribute-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/gltf-utils/gltf-attribute-utils.ts"],"names":["getGLTFAccessors","attributes","accessors","name","attribute","glTFAccessor","getGLTFAccessor","getAccessorData","buffer","size","count","value","byteOffset","type","componentType","ArrayBuffer","isView","toTypedArray","Float32Array","length","array","ArrayType","convertTypedArrays","Array","isArray"],"mappings":";;;;;;;;AAGA;;AAKO,SAASA,gBAAT,CAA0BC,UAA1B,EAAqE;AAC1E,MAAMC,SAAS,GAAG,EAAlB;;AACA,OAAK,IAAMC,IAAX,IAAmBF,UAAnB,EAA+B;AAC7B,QAAMG,SAAS,GAAGH,UAAU,CAACE,IAAD,CAA5B;;AACA,QAAIA,IAAI,KAAK,SAAb,EAAwB;AACtB,UAAME,YAAY,GAAGC,eAAe,CAACF,SAAD,CAApC;AACAF,MAAAA,SAAS,CAACC,IAAD,CAAT,GAAkBE,YAAlB;AACD;AACF;;AACD,SAAOH,SAAP;AACD;;AAKM,SAASI,eAAT,CAAyBF,SAAzB,EAAoC;AACzC,yBAA8BG,eAAe,CAACH,SAAD,CAA7C;AAAA,MAAOI,MAAP,oBAAOA,MAAP;AAAA,MAAeC,IAAf,oBAAeA,IAAf;AAAA,MAAqBC,KAArB,oBAAqBA,KAArB;;AAEA,MAAML,YAA0B,GAAG;AAMjCM,IAAAA,KAAK,EAAEH,MAN0B;AAOjCC,IAAAA,IAAI,EAAJA,IAPiC;AASjCG,IAAAA,UAAU,EAAE,CATqB;AAUjCF,IAAAA,KAAK,EAALA,KAViC;AAWjCG,IAAAA,IAAI,EAAE,wCAAwBJ,IAAxB,CAX2B;AAYjCK,IAAAA,aAAa,EAAE,0CAA0BN,MAA1B;AAZkB,GAAnC;AAeA,SAAOH,YAAP;AACD;;AAMD,SAASE,eAAT,CAAyBH,SAAzB,EAAoC;AAClC,MAAII,MAAM,GAAGJ,SAAb;AACA,MAAIK,IAAI,GAAG,CAAX;AACA,MAAIC,KAAK,GAAG,CAAZ;;AAEA,MAAIN,SAAS,IAAIA,SAAS,CAACO,KAA3B,EAAkC;AAChCH,IAAAA,MAAM,GAAGJ,SAAS,CAACO,KAAnB;AACAF,IAAAA,IAAI,GAAGL,SAAS,CAACK,IAAV,IAAkB,CAAzB;AACD;;AAED,MAAID,MAAJ,EAAY;AACV,QAAI,CAACO,WAAW,CAACC,MAAZ,CAAmBR,MAAnB,CAAL,EAAiC;AAC/BA,MAAAA,MAAM,GAAGS,YAAY,CAACT,MAAD,EAASU,YAAT,CAArB;AACD;;AACDR,IAAAA,KAAK,GAAGF,MAAM,CAACW,MAAP,GAAgBV,IAAxB;AACD;;AAED,SAAO;AAACD,IAAAA,MAAM,EAANA,MAAD;AAASC,IAAAA,IAAI,EAAJA,IAAT;AAAeC,IAAAA,KAAK,EAALA;AAAf,GAAP;AACD;;AAGD,SAASO,YAAT,CAAsBG,KAAtB,EAA6BC,SAA7B,EAAoE;AAAA,MAA5BC,kBAA4B,uEAAP,KAAO;;AAClE,MAAI,CAACF,KAAL,EAAY;AACV,WAAO,IAAP;AACD;;AACD,MAAIG,KAAK,CAACC,OAAN,CAAcJ,KAAd,CAAJ,EAA0B;AACxB,WAAO,IAAIC,SAAJ,CAAcD,KAAd,CAAP;AACD;;AACD,MAAIE,kBAAkB,IAAI,EAAEF,KAAK,YAAYC,SAAnB,CAA1B,EAAyD;AACvD,WAAO,IAAIA,SAAJ,CAAcD,KAAd,CAAP;AACD;;AACD,SAAOA,KAAP;AACD","sourcesContent":["// import type {TypedArray} from '../types/loader-utils';\nimport type {GLTFAccessor} from '../types/gltf-types';\n// TODO - remove\nimport {getAccessorTypeFromSize, getComponentTypeFromArray} from './gltf-utils';\n\n// Returns a fresh attributes object with glTF-standardized attributes names\n// Attributes that cannot be identified will not be included\n// Removes `indices` if present, as it should be stored separately from the attributes\nexport function getGLTFAccessors(attributes): {[key: string]: GLTFAccessor} {\n  const accessors = {};\n  for (const name in attributes) {\n    const attribute = attributes[name];\n    if (name !== 'indices') {\n      const glTFAccessor = getGLTFAccessor(attribute);\n      accessors[name] = glTFAccessor;\n    }\n  }\n  return accessors;\n}\n\n// Fix up a single accessor.\n// Input: typed array or a partial accessor object\n// Return: accessor object\nexport function getGLTFAccessor(attribute) {\n  const {buffer, size, count} = getAccessorData(attribute);\n\n  const glTFAccessor: GLTFAccessor = {\n    // glTF Accessor values\n    // TODO: Instead of a bufferView index we could have an actual buffer (typed array)\n    // bufferView: null,\n    // TODO: Deprecate `value` in favor of bufferView?\n    // @ts-ignore\n    value: buffer,\n    size, // Decoded `type` (e.g. SCALAR)\n\n    byteOffset: 0,\n    count,\n    type: getAccessorTypeFromSize(size),\n    componentType: getComponentTypeFromArray(buffer)\n  };\n\n  return glTFAccessor;\n}\n\n// export function getGLTFAttribute(data, gltfAttributeName): GLTFAccessor {\n//   return data.attributes[data.glTFAttributeMap[gltfAttributeName]];\n// }\n\nfunction getAccessorData(attribute) {\n  let buffer = attribute;\n  let size = 1;\n  let count = 0;\n\n  if (attribute && attribute.value) {\n    buffer = attribute.value;\n    size = attribute.size || 1;\n  }\n\n  if (buffer) {\n    if (!ArrayBuffer.isView(buffer)) {\n      buffer = toTypedArray(buffer, Float32Array);\n    }\n    count = buffer.length / size;\n  }\n\n  return {buffer, size, count};\n}\n\n// Convert non-typed arrays to arrays of specified format\nfunction toTypedArray(array, ArrayType, convertTypedArrays = false) {\n  if (!array) {\n    return null;\n  }\n  if (Array.isArray(array)) {\n    return new ArrayType(array);\n  }\n  if (convertTypedArrays && !(array instanceof ArrayType)) {\n    return new ArrayType(array);\n  }\n  return array;\n}\n"],"file":"gltf-attribute-utils.js"}

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

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBytesFromComponentType = getBytesFromComponentType;
+exports.getSizeFromAccessorType = getSizeFromAccessorType;
+exports.getGLEnumFromSamplerParameter = getGLEnumFromSamplerParameter;
+var COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+var BYTES = {
+  5120: 1,
+  5121: 1,
+  5122: 2,
+  5123: 2,
+  5125: 4,
+  5126: 4
+};
+
+function getBytesFromComponentType(componentType) {
+  return BYTES[componentType];
+}
+
+function getSizeFromAccessorType(type) {
+  return COMPONENTS[type];
+}
+
+function getGLEnumFromSamplerParameter(parameter) {
+  var GL_TEXTURE_MAG_FILTER = 0x2800;
+  var GL_TEXTURE_MIN_FILTER = 0x2801;
+  var GL_TEXTURE_WRAP_S = 0x2802;
+  var GL_TEXTURE_WRAP_T = 0x2803;
+  var 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/es5/lib/gltf-utils/gltf-constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/gltf-utils/gltf-constants.ts"],"names":["COMPONENTS","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","BYTES","getBytesFromComponentType","componentType","getSizeFromAccessorType","type","getGLEnumFromSamplerParameter","parameter","GL_TEXTURE_MAG_FILTER","GL_TEXTURE_MIN_FILTER","GL_TEXTURE_WRAP_S","GL_TEXTURE_WRAP_T","PARAMETER_MAP","magFilter","minFilter","wrapS","wrapT"],"mappings":";;;;;;;;AAAA,IAAMA,UAAU,GAAG;AACjBC,EAAAA,MAAM,EAAE,CADS;AAEjBC,EAAAA,IAAI,EAAE,CAFW;AAGjBC,EAAAA,IAAI,EAAE,CAHW;AAIjBC,EAAAA,IAAI,EAAE,CAJW;AAKjBC,EAAAA,IAAI,EAAE,CALW;AAMjBC,EAAAA,IAAI,EAAE,CANW;AAOjBC,EAAAA,IAAI,EAAE;AAPW,CAAnB;AAUA,IAAMC,KAAK,GAAG;AACZ,QAAM,CADM;AAEZ,QAAM,CAFM;AAGZ,QAAM,CAHM;AAIZ,QAAM,CAJM;AAKZ,QAAM,CALM;AAMZ,QAAM;AANM,CAAd;;AAWO,SAASC,yBAAT,CAAmCC,aAAnC,EAAkD;AACvD,SAAOF,KAAK,CAACE,aAAD,CAAZ;AACD;;AAEM,SAASC,uBAAT,CAAiCC,IAAjC,EAAuC;AAC5C,SAAOZ,UAAU,CAACY,IAAD,CAAjB;AACD;;AAEM,SAASC,6BAAT,CAAuCC,SAAvC,EAAkD;AACvD,MAAMC,qBAAqB,GAAG,MAA9B;AACA,MAAMC,qBAAqB,GAAG,MAA9B;AACA,MAAMC,iBAAiB,GAAG,MAA1B;AACA,MAAMC,iBAAiB,GAAG,MAA1B;AAEA,MAAMC,aAAa,GAAG;AACpBC,IAAAA,SAAS,EAAEL,qBADS;AAEpBM,IAAAA,SAAS,EAAEL,qBAFS;AAGpBM,IAAAA,KAAK,EAAEL,iBAHa;AAIpBM,IAAAA,KAAK,EAAEL;AAJa,GAAtB;AAOA,SAAOC,aAAa,CAACL,SAAD,CAApB;AACD","sourcesContent":["const COMPONENTS = {\n  SCALAR: 1,\n  VEC2: 2,\n  VEC3: 3,\n  VEC4: 4,\n  MAT2: 4,\n  MAT3: 9,\n  MAT4: 16\n};\n\nconst BYTES = {\n  5120: 1, // BYTE\n  5121: 1, // UNSIGNED_BYTE\n  5122: 2, // SHORT\n  5123: 2, // UNSIGNED_SHORT\n  5125: 4, // UNSIGNED_INT\n  5126: 4 // FLOAT\n};\n\n// ENUM LOOKUP\n\nexport function getBytesFromComponentType(componentType) {\n  return BYTES[componentType];\n}\n\nexport function getSizeFromAccessorType(type) {\n  return COMPONENTS[type];\n}\n\nexport function getGLEnumFromSamplerParameter(parameter) {\n  const GL_TEXTURE_MAG_FILTER = 0x2800;\n  const GL_TEXTURE_MIN_FILTER = 0x2801;\n  const GL_TEXTURE_WRAP_S = 0x2802;\n  const GL_TEXTURE_WRAP_T = 0x2803;\n\n  const PARAMETER_MAP = {\n    magFilter: GL_TEXTURE_MAG_FILTER,\n    minFilter: GL_TEXTURE_MIN_FILTER,\n    wrapS: GL_TEXTURE_WRAP_S,\n    wrapT: GL_TEXTURE_WRAP_T\n  };\n\n  return PARAMETER_MAP[parameter];\n}\n"],"file":"gltf-constants.js"}

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

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAccessorTypeFromSize = getAccessorTypeFromSize;
+exports.getComponentTypeFromArray = getComponentTypeFromArray;
+exports.getAccessorArrayTypeAndLength = getAccessorArrayTypeAndLength;
+
+var _assert = require("../utils/assert");
+
+var TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];
+var ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [[Int8Array, 5120], [Uint8Array, 5121], [Int16Array, 5122], [Uint16Array, 5123], [Uint32Array, 5125], [Float32Array, 5126], [Float64Array, 5130]];
+var ARRAY_TO_COMPONENT_TYPE = new Map(ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT);
+var ATTRIBUTE_TYPE_TO_COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+var ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
+  5120: 1,
+  5121: 1,
+  5122: 2,
+  5123: 2,
+  5125: 4,
+  5126: 4
+};
+var ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+};
+
+function getAccessorTypeFromSize(size) {
+  var type = TYPES[size - 1];
+  return type || TYPES[0];
+}
+
+function getComponentTypeFromArray(typedArray) {
+  var componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);
+
+  if (!componentType) {
+    throw new Error('Illegal typed array');
+  }
+
+  return componentType;
+}
+
+function getAccessorArrayTypeAndLength(accessor, bufferView) {
+  var ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
+  var components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
+  var bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
+  var length = accessor.count * components;
+  var byteLength = accessor.count * components * bytesPerComponent;
+  (0, _assert.assert)(byteLength >= 0 && byteLength <= bufferView.byteLength);
+  return {
+    ArrayType: ArrayType,
+    length: length,
+    byteLength: byteLength
+  };
+}
+//# sourceMappingURL=gltf-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/gltf-utils/gltf-utils.ts"],"names":["TYPES","ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT","Int8Array","Uint8Array","Int16Array","Uint16Array","Uint32Array","Float32Array","Float64Array","ARRAY_TO_COMPONENT_TYPE","Map","ATTRIBUTE_TYPE_TO_COMPONENTS","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE","ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY","getAccessorTypeFromSize","size","type","getComponentTypeFromArray","typedArray","componentType","get","constructor","Error","getAccessorArrayTypeAndLength","accessor","bufferView","ArrayType","components","bytesPerComponent","length","count","byteLength"],"mappings":";;;;;;;;;AAAA;;AAEA,IAAMA,KAAK,GAAG,CAAC,QAAD,EAAW,MAAX,EAAmB,MAAnB,EAA2B,MAA3B,CAAd;AAcA,IAAMC,mCAAsE,GAAG,CAC7E,CAACC,SAAD,EAAY,IAAZ,CAD6E,EAE7E,CAACC,UAAD,EAAa,IAAb,CAF6E,EAG7E,CAACC,UAAD,EAAa,IAAb,CAH6E,EAI7E,CAACC,WAAD,EAAc,IAAd,CAJ6E,EAK7E,CAACC,WAAD,EAAc,IAAd,CAL6E,EAM7E,CAACC,YAAD,EAAe,IAAf,CAN6E,EAO7E,CAACC,YAAD,EAAe,IAAf,CAP6E,CAA/E;AASA,IAAMC,uBAAuB,GAAG,IAAIC,GAAJ,CAC9BT,mCAD8B,CAAhC;AAIA,IAAMU,4BAA4B,GAAG;AACnCC,EAAAA,MAAM,EAAE,CAD2B;AAEnCC,EAAAA,IAAI,EAAE,CAF6B;AAGnCC,EAAAA,IAAI,EAAE,CAH6B;AAInCC,EAAAA,IAAI,EAAE,CAJ6B;AAKnCC,EAAAA,IAAI,EAAE,CAL6B;AAMnCC,EAAAA,IAAI,EAAE,CAN6B;AAOnCC,EAAAA,IAAI,EAAE;AAP6B,CAArC;AAUA,IAAMC,qCAAqC,GAAG;AAC5C,QAAM,CADsC;AAE5C,QAAM,CAFsC;AAG5C,QAAM,CAHsC;AAI5C,QAAM,CAJsC;AAK5C,QAAM,CALsC;AAM5C,QAAM;AANsC,CAA9C;AASA,IAAMC,iCAAiC,GAAG;AACxC,QAAMlB,SADkC;AAExC,QAAMC,UAFkC;AAGxC,QAAMC,UAHkC;AAIxC,QAAMC,WAJkC;AAKxC,QAAMC,WALkC;AAMxC,QAAMC;AANkC,CAA1C;;AASO,SAASc,uBAAT,CAAiCC,IAAjC,EAAuC;AAC5C,MAAMC,IAAI,GAAGvB,KAAK,CAACsB,IAAI,GAAG,CAAR,CAAlB;AACA,SAAOC,IAAI,IAAIvB,KAAK,CAAC,CAAD,CAApB;AACD;;AAEM,SAASwB,yBAAT,CAAmCC,UAAnC,EAA+C;AACpD,MAAMC,aAAa,GAAGjB,uBAAuB,CAACkB,GAAxB,CAA4BF,UAAU,CAACG,WAAvC,CAAtB;;AACA,MAAI,CAACF,aAAL,EAAoB;AAClB,UAAM,IAAIG,KAAJ,CAAU,qBAAV,CAAN;AACD;;AACD,SAAOH,aAAP;AACD;;AAEM,SAASI,6BAAT,CAAuCC,QAAvC,EAAiDC,UAAjD,EAA6D;AAClE,MAAMC,SAAS,GAAGb,iCAAiC,CAACW,QAAQ,CAACL,aAAV,CAAnD;AACA,MAAMQ,UAAU,GAAGvB,4BAA4B,CAACoB,QAAQ,CAACR,IAAV,CAA/C;AACA,MAAMY,iBAAiB,GAAGhB,qCAAqC,CAACY,QAAQ,CAACL,aAAV,CAA/D;AACA,MAAMU,MAAM,GAAGL,QAAQ,CAACM,KAAT,GAAiBH,UAAhC;AACA,MAAMI,UAAU,GAAGP,QAAQ,CAACM,KAAT,GAAiBH,UAAjB,GAA8BC,iBAAjD;AACA,sBAAOG,UAAU,IAAI,CAAd,IAAmBA,UAAU,IAAIN,UAAU,CAACM,UAAnD;AACA,SAAO;AAACL,IAAAA,SAAS,EAATA,SAAD;AAAYG,IAAAA,MAAM,EAANA,MAAZ;AAAoBE,IAAAA,UAAU,EAAVA;AAApB,GAAP;AACD","sourcesContent":["import {assert} from '../utils/assert';\n\nconst TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];\n\ntype TypedArrayConstructor =\n  | Int8ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int16ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Float32ArrayConstructor\n  | Float64ArrayConstructor;\n\nconst ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT: [TypedArrayConstructor, number][] = [\n  [Int8Array, 5120],\n  [Uint8Array, 5121],\n  [Int16Array, 5122],\n  [Uint16Array, 5123],\n  [Uint32Array, 5125],\n  [Float32Array, 5126],\n  [Float64Array, 5130]\n];\nconst ARRAY_TO_COMPONENT_TYPE = new Map<TypedArrayConstructor, number>(\n  ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT\n);\n\nconst ATTRIBUTE_TYPE_TO_COMPONENTS = {\n  SCALAR: 1,\n  VEC2: 2,\n  VEC3: 3,\n  VEC4: 4,\n  MAT2: 4,\n  MAT3: 9,\n  MAT4: 16\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {\n  5120: 1,\n  5121: 1,\n  5122: 2,\n  5123: 2,\n  5125: 4,\n  5126: 4\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {\n  5120: Int8Array,\n  5121: Uint8Array,\n  5122: Int16Array,\n  5123: Uint16Array,\n  5125: Uint32Array,\n  5126: Float32Array\n};\n\nexport function getAccessorTypeFromSize(size) {\n  const type = TYPES[size - 1];\n  return type || TYPES[0];\n}\n\nexport function getComponentTypeFromArray(typedArray) {\n  const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);\n  if (!componentType) {\n    throw new Error('Illegal typed array');\n  }\n  return componentType;\n}\n\nexport function getAccessorArrayTypeAndLength(accessor, bufferView) {\n  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];\n  const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];\n  const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];\n  const length = accessor.count * components;\n  const byteLength = accessor.count * components * bytesPerComponent;\n  assert(byteLength >= 0 && byteLength <= bufferView.byteLength);\n  return {ArrayType, length, byteLength};\n}\n"],"file":"gltf-utils.js"}

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveUrl = resolveUrl;
+
+function resolveUrl(url, options) {
+  var absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');
+
+  if (absolute) {
+    return url;
+  }
+
+  var baseUrl = options.baseUri || options.uri;
+
+  if (!baseUrl) {
+    throw new Error("'baseUri' must be provided to resolve relative url ".concat(url));
+  }
+
+  return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;
+}
+//# sourceMappingURL=resolve-url.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/gltf-utils/resolve-url.ts"],"names":["resolveUrl","url","options","absolute","startsWith","baseUrl","baseUri","uri","Error","substr","lastIndexOf"],"mappings":";;;;;;;AAEO,SAASA,UAAT,CAAoBC,GAApB,EAAyBC,OAAzB,EAAkC;AAEvC,MAAMC,QAAQ,GAAGF,GAAG,CAACG,UAAJ,CAAe,OAAf,KAA2BH,GAAG,CAACG,UAAJ,CAAe,OAAf,CAA3B,IAAsDH,GAAG,CAACG,UAAJ,CAAe,QAAf,CAAvE;;AACA,MAAID,QAAJ,EAAc;AACZ,WAAOF,GAAP;AACD;;AACD,MAAMI,OAAO,GAAGH,OAAO,CAACI,OAAR,IAAmBJ,OAAO,CAACK,GAA3C;;AACA,MAAI,CAACF,OAAL,EAAc;AACZ,UAAM,IAAIG,KAAJ,8DAAgEP,GAAhE,EAAN;AACD;;AACD,SAAOI,OAAO,CAACI,MAAR,CAAe,CAAf,EAAkBJ,OAAO,CAACK,WAAR,CAAoB,GAApB,IAA2B,CAA7C,IAAkDT,GAAzD;AACD","sourcesContent":["// Resolves a relative url against a baseUrl\n// If url is absolute, return it unchanged\nexport function resolveUrl(url, options) {\n  // TODO: Use better logic to handle all protocols plus not delay on data\n  const absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');\n  if (absolute) {\n    return url;\n  }\n  const baseUrl = options.baseUri || options.uri;\n  if (!baseUrl) {\n    throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);\n  }\n  return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;\n}\n"],"file":"resolve-url.js"}

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

@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isGLB = isGLB;
+exports.default = parseGLBSync;
+
+var _loaderUtils = require("@loaders.gl/loader-utils");
+
+var MAGIC_glTF = 0x676c5446;
+var GLB_FILE_HEADER_SIZE = 12;
+var GLB_CHUNK_HEADER_SIZE = 8;
+var GLB_CHUNK_TYPE_JSON = 0x4e4f534a;
+var GLB_CHUNK_TYPE_BIN = 0x004e4942;
+var GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
+var GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
+var GLB_V1_CONTENT_FORMAT_JSON = 0x0;
+var LE = true;
+
+function getMagicString(dataView) {
+  var byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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)));
+}
+
+function isGLB(arrayBuffer) {
+  var byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var dataView = new DataView(arrayBuffer);
+  var _options$magic = options.magic,
+      magic = _options$magic === void 0 ? MAGIC_glTF : _options$magic;
+  var magic1 = dataView.getUint32(byteOffset, false);
+  return magic1 === magic || magic1 === MAGIC_glTF;
+}
+
+function parseGLBSync(glb, arrayBuffer) {
+  var byteOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  var dataView = new DataView(arrayBuffer);
+  var type = getMagicString(dataView, byteOffset + 0);
+  var version = dataView.getUint32(byteOffset + 4, LE);
+  var byteLength = dataView.getUint32(byteOffset + 8, LE);
+  Object.assign(glb, {
+    header: {
+      byteOffset: byteOffset,
+      byteLength: byteLength,
+      hasBinChunk: false
+    },
+    type: type,
+    version: 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."));
+  }
+}
+
+function parseGLBV1(glb, dataView, byteOffset) {
+  (0, _loaderUtils.assert)(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+  var contentLength = dataView.getUint32(byteOffset + 0, LE);
+  var contentFormat = dataView.getUint32(byteOffset + 4, LE);
+  byteOffset += GLB_CHUNK_HEADER_SIZE;
+  (0, _loaderUtils.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) {
+  (0, _loaderUtils.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) {
+    var chunkLength = dataView.getUint32(byteOffset + 0, LE);
+    var 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);
+        }
+
+        break;
+
+      default:
+        break;
+    }
+
+    byteOffset += (0, _loaderUtils.padToNBytes)(chunkLength, 4);
+  }
+
+  return byteOffset;
+}
+
+function parseJSONChunk(glb, dataView, byteOffset, chunkLength) {
+  var jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);
+  var textDecoder = new TextDecoder('utf8');
+  var jsonText = textDecoder.decode(jsonChunk);
+  glb.json = JSON.parse(jsonText);
+  return (0, _loaderUtils.padToNBytes)(chunkLength, 4);
+}
+
+function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
+  glb.header.hasBinChunk = true;
+  glb.binChunks.push({
+    byteOffset: byteOffset,
+    byteLength: chunkLength,
+    arrayBuffer: dataView.buffer
+  });
+  return (0, _loaderUtils.padToNBytes)(chunkLength, 4);
+}
+//# sourceMappingURL=parse-glb.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/parsers/parse-glb.ts"],"names":["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":"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","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/es5/lib/parsers/parse-gltf.js

@@ -0,0 +1,335 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isGLTF = isGLTF;
+exports.parseGLTF = parseGLTF;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _images = require("@loaders.gl/images");
+
+var _loaderUtils = require("@loaders.gl/loader-utils");
+
+var _assert = require("../utils/assert");
+
+var _resolveUrl = require("../gltf-utils/resolve-url");
+
+var _getTypedArray = require("../gltf-utils/get-typed-array");
+
+var _gltfExtensions = require("../api/gltf-extensions");
+
+var _normalizeGltfV = require("../api/normalize-gltf-v1");
+
+var _postProcessGltf = require("../api/post-process-gltf");
+
+var _parseGlb = _interopRequireWildcard(require("./parse-glb"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function isGLTF(arrayBuffer, options) {
+  var byteOffset = 0;
+  return (0, _parseGlb.isGLB)(arrayBuffer, byteOffset, options);
+}
+
+function parseGLTF(_x, _x2) {
+  return _parseGLTF.apply(this, arguments);
+}
+
+function _parseGLTF() {
+  _parseGLTF = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(gltf, arrayBufferOrString) {
+    var _options$gltf, _options$gltf2, _options$gltf3, _options$gltf4;
+
+    var byteOffset,
+        options,
+        context,
+        promises,
+        _promise,
+        promise,
+        _args = arguments;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            byteOffset = _args.length > 2 && _args[2] !== undefined ? _args[2] : 0;
+            options = _args.length > 3 ? _args[3] : undefined;
+            context = _args.length > 4 ? _args[4] : undefined;
+            parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);
+            (0, _normalizeGltfV.normalizeGLTFV1)(gltf, {
+              normalize: options === null || options === void 0 ? void 0 : (_options$gltf = options.gltf) === null || _options$gltf === void 0 ? void 0 : _options$gltf.normalize
+            });
+            (0, _gltfExtensions.preprocessExtensions)(gltf, options, context);
+            promises = [];
+
+            if (!(options !== null && options !== void 0 && (_options$gltf2 = options.gltf) !== null && _options$gltf2 !== void 0 && _options$gltf2.loadBuffers && gltf.json.buffers)) {
+              _context.next = 10;
+              break;
+            }
+
+            _context.next = 10;
+            return loadBuffers(gltf, options, context);
+
+          case 10:
+            if (options !== null && options !== void 0 && (_options$gltf3 = options.gltf) !== null && _options$gltf3 !== void 0 && _options$gltf3.loadImages) {
+              _promise = loadImages(gltf, options, context);
+              promises.push(_promise);
+            }
+
+            promise = (0, _gltfExtensions.decodeExtensions)(gltf, options, context);
+            promises.push(promise);
+            _context.next = 15;
+            return Promise.all(promises);
+
+          case 15:
+            return _context.abrupt("return", options !== null && options !== void 0 && (_options$gltf4 = options.gltf) !== null && _options$gltf4 !== void 0 && _options$gltf4.postProcess ? (0, _postProcessGltf.postProcessGLTF)(gltf, options) : gltf);
+
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _parseGLTF.apply(this, arguments);
+}
+
+function parseGLTFContainerSync(gltf, data, byteOffset, options) {
+  if (options.uri) {
+    gltf.baseUri = options.uri;
+  }
+
+  if (data instanceof ArrayBuffer && !(0, _parseGlb.isGLB)(data, byteOffset, options)) {
+    var textDecoder = new TextDecoder();
+    data = textDecoder.decode(data);
+  }
+
+  if (typeof data === 'string') {
+    gltf.json = (0, _loaderUtils.parseJSON)(data);
+  } else if (data instanceof ArrayBuffer) {
+    var glb = {};
+    byteOffset = (0, _parseGlb.default)(glb, data, byteOffset, options.glb);
+    (0, _assert.assert)(glb.type === 'glTF', "Invalid GLB magic string ".concat(glb.type));
+    gltf._glb = glb;
+    gltf.json = glb.json;
+  } else {
+    (0, _assert.assert)(false, 'GLTF: must be ArrayBuffer or string');
+  }
+
+  var buffers = gltf.json.buffers || [];
+  gltf.buffers = new Array(buffers.length).fill(null);
+
+  if (gltf._glb && gltf._glb.header.hasBinChunk) {
+    var binChunks = gltf._glb.binChunks;
+    gltf.buffers[0] = {
+      arrayBuffer: binChunks[0].arrayBuffer,
+      byteOffset: binChunks[0].byteOffset,
+      byteLength: binChunks[0].byteLength
+    };
+  }
+
+  var images = gltf.json.images || [];
+  gltf.images = new Array(images.length).fill({});
+}
+
+function loadBuffers(_x3, _x4, _x5) {
+  return _loadBuffers.apply(this, arguments);
+}
+
+function _loadBuffers() {
+  _loadBuffers = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(gltf, options, context) {
+    var buffers, i, buffer, _context$fetch, _response$arrayBuffer, fetch, uri, response, arrayBuffer;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            buffers = gltf.json.buffers || [];
+            i = 0;
+
+          case 2:
+            if (!(i < buffers.length)) {
+              _context2.next = 19;
+              break;
+            }
+
+            buffer = buffers[i];
+
+            if (!buffer.uri) {
+              _context2.next = 16;
+              break;
+            }
+
+            fetch = context.fetch;
+            (0, _assert.assert)(fetch);
+            uri = (0, _resolveUrl.resolveUrl)(buffer.uri, options);
+            _context2.next = 10;
+            return context === null || context === void 0 ? void 0 : (_context$fetch = context.fetch) === null || _context$fetch === void 0 ? void 0 : _context$fetch.call(context, uri);
+
+          case 10:
+            response = _context2.sent;
+            _context2.next = 13;
+            return response === null || response === void 0 ? void 0 : (_response$arrayBuffer = response.arrayBuffer) === null || _response$arrayBuffer === void 0 ? void 0 : _response$arrayBuffer.call(response);
+
+          case 13:
+            arrayBuffer = _context2.sent;
+            gltf.buffers[i] = {
+              arrayBuffer: arrayBuffer,
+              byteOffset: 0,
+              byteLength: arrayBuffer.byteLength
+            };
+            delete buffer.uri;
+
+          case 16:
+            ++i;
+            _context2.next = 2;
+            break;
+
+          case 19:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _loadBuffers.apply(this, arguments);
+}
+
+function loadImages(_x6, _x7, _x8) {
+  return _loadImages.apply(this, arguments);
+}
+
+function _loadImages() {
+  _loadImages = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(gltf, options, context) {
+    var imageIndices, images, promises, _iterator2, _step2, imageIndex;
+
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            imageIndices = getReferencesImageIndices(gltf);
+            images = gltf.json.images || [];
+            promises = [];
+            _iterator2 = _createForOfIteratorHelper(imageIndices);
+
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                imageIndex = _step2.value;
+                promises.push(loadImage(gltf, images[imageIndex], imageIndex, options, context));
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+
+            _context3.next = 7;
+            return Promise.all(promises);
+
+          case 7:
+            return _context3.abrupt("return", _context3.sent);
+
+          case 8:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _loadImages.apply(this, arguments);
+}
+
+function getReferencesImageIndices(gltf) {
+  var imageIndices = new Set();
+  var textures = gltf.json.textures || [];
+
+  var _iterator = _createForOfIteratorHelper(textures),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var texture = _step.value;
+
+      if (texture.source !== undefined) {
+        imageIndices.add(texture.source);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return Array.from(imageIndices).sort();
+}
+
+function loadImage(_x9, _x10, _x11, _x12, _x13) {
+  return _loadImage.apply(this, arguments);
+}
+
+function _loadImage() {
+  _loadImage = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee4(gltf, image, index, options, context) {
+    var fetch, parse, arrayBuffer, uri, response, array, parsedImage;
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            fetch = context.fetch, parse = context.parse;
+
+            if (!image.uri) {
+              _context4.next = 9;
+              break;
+            }
+
+            uri = (0, _resolveUrl.resolveUrl)(image.uri, options);
+            _context4.next = 5;
+            return fetch(uri);
+
+          case 5:
+            response = _context4.sent;
+            _context4.next = 8;
+            return response.arrayBuffer();
+
+          case 8:
+            arrayBuffer = _context4.sent;
+
+          case 9:
+            if (Number.isFinite(image.bufferView)) {
+              array = (0, _getTypedArray.getTypedArrayForBufferView)(gltf.json, gltf.buffers, image.bufferView);
+              arrayBuffer = (0, _loaderUtils.sliceArrayBuffer)(array.buffer, array.byteOffset, array.byteLength);
+            }
+
+            (0, _assert.assert)(arrayBuffer, 'glTF image has no data');
+            _context4.next = 13;
+            return parse(arrayBuffer, _images.ImageLoader, {}, context);
+
+          case 13:
+            parsedImage = _context4.sent;
+            gltf.images = gltf.images || [];
+            gltf.images[index] = parsedImage;
+
+          case 16:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _loadImage.apply(this, arguments);
+}
+//# sourceMappingURL=parse-gltf.js.map