@loaders.gl/gltf 3.0.13 → 3.0.14

package/dist/es5/lib/api/post-process-gltf.js

@@ -1,15 +1,31 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.postProcessGLTF = postProcessGLTF;
 
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _assert = require("../utils/assert");
 
 var _gltfUtils = require("../gltf-utils/gltf-utils");
 
-const COMPONENTS = {
+var _DEFAULT_SAMPLER;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var COMPONENTS = {
   SCALAR: 1,
   VEC2: 2,
   VEC3: 3,
@@ -18,7 +34,7 @@ const COMPONENTS = {
   MAT3: 9,
   MAT4: 16
 };
-const BYTES = {
+var BYTES = {
   5120: 1,
   5121: 1,
   5122: 2,
@@ -26,7 +42,7 @@ const BYTES = {
   5125: 4,
   5126: 4
 };
-const GL_SAMPLER = {
+var GL_SAMPLER = {
   TEXTURE_MAG_FILTER: 0x2800,
   TEXTURE_MIN_FILTER: 0x2801,
   TEXTURE_WRAP_S: 0x2802,
@@ -35,18 +51,13 @@ const GL_SAMPLER = {
   LINEAR: 0x2601,
   NEAREST_MIPMAP_LINEAR: 0x2702
 };
-const SAMPLER_PARAMETER_GLTF_TO_GL = {
+var SAMPLER_PARAMETER_GLTF_TO_GL = {
   magFilter: GL_SAMPLER.TEXTURE_MAG_FILTER,
   minFilter: GL_SAMPLER.TEXTURE_MIN_FILTER,
   wrapS: GL_SAMPLER.TEXTURE_WRAP_S,
   wrapT: GL_SAMPLER.TEXTURE_WRAP_T
 };
-const DEFAULT_SAMPLER = {
-  [GL_SAMPLER.TEXTURE_MAG_FILTER]: GL_SAMPLER.LINEAR,
-  [GL_SAMPLER.TEXTURE_MIN_FILTER]: GL_SAMPLER.NEAREST_MIPMAP_LINEAR,
-  [GL_SAMPLER.TEXTURE_WRAP_S]: GL_SAMPLER.REPEAT,
-  [GL_SAMPLER.TEXTURE_WRAP_]: GL_SAMPLER.REPEAT
-};
+var DEFAULT_SAMPLER = (_DEFAULT_SAMPLER = {}, (0, _defineProperty2.default)(_DEFAULT_SAMPLER, GL_SAMPLER.TEXTURE_MAG_FILTER, GL_SAMPLER.LINEAR), (0, _defineProperty2.default)(_DEFAULT_SAMPLER, GL_SAMPLER.TEXTURE_MIN_FILTER, GL_SAMPLER.NEAREST_MIPMAP_LINEAR), (0, _defineProperty2.default)(_DEFAULT_SAMPLER, GL_SAMPLER.TEXTURE_WRAP_S, GL_SAMPLER.REPEAT), (0, _defineProperty2.default)(_DEFAULT_SAMPLER, GL_SAMPLER.TEXTURE_WRAP_, GL_SAMPLER.REPEAT), _DEFAULT_SAMPLER);
 
 function getBytesFromComponentType(componentType) {
   return BYTES[componentType];
@@ -56,344 +67,408 @@ function getSizeFromAccessorType(type) {
   return COMPONENTS[type];
 }
 
-class GLTFPostProcessor {
-  postProcess(gltf, options = {}) {
-    const {
-      json,
-      buffers = [],
-      images = [],
-      baseUri = ''
-    } = gltf;
-    (0, _assert.assert)(json);
-    this.baseUri = baseUri;
-    this.json = json;
-    this.buffers = buffers;
-    this.images = images;
-
-    this._resolveTree(this.json, options);
-
-    return this.json;
+var GLTFPostProcessor = function () {
+  function GLTFPostProcessor() {
+    (0, _classCallCheck2.default)(this, GLTFPostProcessor);
   }
 
-  _resolveTree(json, options = {}) {
-    if (json.bufferViews) {
-      json.bufferViews = json.bufferViews.map((bufView, i) => this._resolveBufferView(bufView, i));
-    }
-
-    if (json.images) {
-      json.images = json.images.map((image, i) => this._resolveImage(image, i));
-    }
-
-    if (json.samplers) {
-      json.samplers = json.samplers.map((sampler, i) => this._resolveSampler(sampler, i));
+  (0, _createClass2.default)(GLTFPostProcessor, [{
+    key: "postProcess",
+    value: function postProcess(gltf) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var json = gltf.json,
+          _gltf$buffers = gltf.buffers,
+          buffers = _gltf$buffers === void 0 ? [] : _gltf$buffers,
+          _gltf$images = gltf.images,
+          images = _gltf$images === void 0 ? [] : _gltf$images,
+          _gltf$baseUri = gltf.baseUri,
+          baseUri = _gltf$baseUri === void 0 ? '' : _gltf$baseUri;
+      (0, _assert.assert)(json);
+      this.baseUri = baseUri;
+      this.json = json;
+      this.buffers = buffers;
+      this.images = images;
+
+      this._resolveTree(this.json, options);
+
+      return this.json;
     }
+  }, {
+    key: "_resolveTree",
+    value: function _resolveTree(json) {
+      var _this = this;
 
-    if (json.textures) {
-      json.textures = json.textures.map((texture, i) => this._resolveTexture(texture, i));
-    }
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
-    if (json.accessors) {
-      json.accessors = json.accessors.map((accessor, i) => this._resolveAccessor(accessor, i));
-    }
+      if (json.bufferViews) {
+        json.bufferViews = json.bufferViews.map(function (bufView, i) {
+          return _this._resolveBufferView(bufView, i);
+        });
+      }
 
-    if (json.materials) {
-      json.materials = json.materials.map((material, i) => this._resolveMaterial(material, i));
-    }
+      if (json.images) {
+        json.images = json.images.map(function (image, i) {
+          return _this._resolveImage(image, i);
+        });
+      }
 
-    if (json.meshes) {
-      json.meshes = json.meshes.map((mesh, i) => this._resolveMesh(mesh, i));
-    }
+      if (json.samplers) {
+        json.samplers = json.samplers.map(function (sampler, i) {
+          return _this._resolveSampler(sampler, i);
+        });
+      }
 
-    if (json.nodes) {
-      json.nodes = json.nodes.map((node, i) => this._resolveNode(node, i));
-    }
+      if (json.textures) {
+        json.textures = json.textures.map(function (texture, i) {
+          return _this._resolveTexture(texture, i);
+        });
+      }
 
-    if (json.skins) {
-      json.skins = json.skins.map((skin, i) => this._resolveSkin(skin, i));
-    }
+      if (json.accessors) {
+        json.accessors = json.accessors.map(function (accessor, i) {
+          return _this._resolveAccessor(accessor, i);
+        });
+      }
 
-    if (json.scenes) {
-      json.scenes = json.scenes.map((scene, i) => this._resolveScene(scene, i));
-    }
+      if (json.materials) {
+        json.materials = json.materials.map(function (material, i) {
+          return _this._resolveMaterial(material, i);
+        });
+      }
 
-    if (json.scene !== undefined) {
-      json.scene = json.scenes[this.json.scene];
-    }
-  }
+      if (json.meshes) {
+        json.meshes = json.meshes.map(function (mesh, i) {
+          return _this._resolveMesh(mesh, i);
+        });
+      }
 
-  getScene(index) {
-    return this._get('scenes', index);
-  }
+      if (json.nodes) {
+        json.nodes = json.nodes.map(function (node, i) {
+          return _this._resolveNode(node, i);
+        });
+      }
 
-  getNode(index) {
-    return this._get('nodes', index);
-  }
+      if (json.skins) {
+        json.skins = json.skins.map(function (skin, i) {
+          return _this._resolveSkin(skin, i);
+        });
+      }
 
-  getSkin(index) {
-    return this._get('skins', index);
-  }
+      if (json.scenes) {
+        json.scenes = json.scenes.map(function (scene, i) {
+          return _this._resolveScene(scene, i);
+        });
+      }
 
-  getMesh(index) {
-    return this._get('meshes', index);
-  }
+      if (json.scene !== undefined) {
+        json.scene = json.scenes[this.json.scene];
+      }
+    }
+  }, {
+    key: "getScene",
+    value: function getScene(index) {
+      return this._get('scenes', index);
+    }
+  }, {
+    key: "getNode",
+    value: function getNode(index) {
+      return this._get('nodes', index);
+    }
+  }, {
+    key: "getSkin",
+    value: function getSkin(index) {
+      return this._get('skins', index);
+    }
+  }, {
+    key: "getMesh",
+    value: function getMesh(index) {
+      return this._get('meshes', index);
+    }
+  }, {
+    key: "getMaterial",
+    value: function getMaterial(index) {
+      return this._get('materials', index);
+    }
+  }, {
+    key: "getAccessor",
+    value: function getAccessor(index) {
+      return this._get('accessors', index);
+    }
+  }, {
+    key: "getCamera",
+    value: function getCamera(index) {
+      return null;
+    }
+  }, {
+    key: "getTexture",
+    value: function getTexture(index) {
+      return this._get('textures', index);
+    }
+  }, {
+    key: "getSampler",
+    value: function getSampler(index) {
+      return this._get('samplers', index);
+    }
+  }, {
+    key: "getImage",
+    value: function getImage(index) {
+      return this._get('images', index);
+    }
+  }, {
+    key: "getBufferView",
+    value: function getBufferView(index) {
+      return this._get('bufferViews', index);
+    }
+  }, {
+    key: "getBuffer",
+    value: function getBuffer(index) {
+      return this._get('buffers', index);
+    }
+  }, {
+    key: "_get",
+    value: function _get(array, index) {
+      if ((0, _typeof2.default)(index) === 'object') {
+        return index;
+      }
 
-  getMaterial(index) {
-    return this._get('materials', index);
-  }
+      var object = this.json[array] && this.json[array][index];
 
-  getAccessor(index) {
-    return this._get('accessors', index);
-  }
+      if (!object) {
+        console.warn("glTF file error: Could not find ".concat(array, "[").concat(index, "]"));
+      }
 
-  getCamera(index) {
-    return null;
-  }
+      return object;
+    }
+  }, {
+    key: "_resolveScene",
+    value: function _resolveScene(scene, index) {
+      var _this2 = this;
+
+      scene.id = scene.id || "scene-".concat(index);
+      scene.nodes = (scene.nodes || []).map(function (node) {
+        return _this2.getNode(node);
+      });
+      return scene;
+    }
+  }, {
+    key: "_resolveNode",
+    value: function _resolveNode(node, index) {
+      var _this3 = this;
 
-  getTexture(index) {
-    return this._get('textures', index);
-  }
+      node.id = node.id || "node-".concat(index);
 
-  getSampler(index) {
-    return this._get('samplers', index);
-  }
+      if (node.children) {
+        node.children = node.children.map(function (child) {
+          return _this3.getNode(child);
+        });
+      }
 
-  getImage(index) {
-    return this._get('images', index);
-  }
+      if (node.mesh !== undefined) {
+        node.mesh = this.getMesh(node.mesh);
+      } else if (node.meshes !== undefined && node.meshes.length) {
+        node.mesh = node.meshes.reduce(function (accum, meshIndex) {
+          var mesh = _this3.getMesh(meshIndex);
+
+          accum.id = mesh.id;
+          accum.primitives = accum.primitives.concat(mesh.primitives);
+          return accum;
+        }, {
+          primitives: []
+        });
+      }
 
-  getBufferView(index) {
-    return this._get('bufferViews', index);
-  }
+      if (node.camera !== undefined) {
+        node.camera = this.getCamera(node.camera);
+      }
 
-  getBuffer(index) {
-    return this._get('buffers', index);
-  }
+      if (node.skin !== undefined) {
+        node.skin = this.getSkin(node.skin);
+      }
 
-  _get(array, index) {
-    if (typeof index === 'object') {
-      return index;
+      return node;
     }
-
-    const object = this.json[array] && this.json[array][index];
-
-    if (!object) {
-      console.warn("glTF file error: Could not find ".concat(array, "[").concat(index, "]"));
+  }, {
+    key: "_resolveSkin",
+    value: function _resolveSkin(skin, index) {
+      skin.id = skin.id || "skin-".concat(index);
+      skin.inverseBindMatrices = this.getAccessor(skin.inverseBindMatrices);
+      return skin;
     }
+  }, {
+    key: "_resolveMesh",
+    value: function _resolveMesh(mesh, index) {
+      var _this4 = this;
 
-    return object;
-  }
+      mesh.id = mesh.id || "mesh-".concat(index);
 
-  _resolveScene(scene, index) {
-    scene.id = scene.id || "scene-".concat(index);
-    scene.nodes = (scene.nodes || []).map(node => this.getNode(node));
-    return scene;
-  }
+      if (mesh.primitives) {
+        mesh.primitives = mesh.primitives.map(function (primitive) {
+          primitive = _objectSpread({}, primitive);
+          var attributes = primitive.attributes;
+          primitive.attributes = {};
 
-  _resolveNode(node, index) {
-    node.id = node.id || "node-".concat(index);
+          for (var attribute in attributes) {
+            primitive.attributes[attribute] = _this4.getAccessor(attributes[attribute]);
+          }
 
-    if (node.children) {
-      node.children = node.children.map(child => this.getNode(child));
-    }
+          if (primitive.indices !== undefined) {
+            primitive.indices = _this4.getAccessor(primitive.indices);
+          }
 
-    if (node.mesh !== undefined) {
-      node.mesh = this.getMesh(node.mesh);
-    } else if (node.meshes !== undefined && node.meshes.length) {
-      node.mesh = node.meshes.reduce((accum, meshIndex) => {
-        const mesh = this.getMesh(meshIndex);
-        accum.id = mesh.id;
-        accum.primitives = accum.primitives.concat(mesh.primitives);
-        return accum;
-      }, {
-        primitives: []
-      });
-    }
+          if (primitive.material !== undefined) {
+            primitive.material = _this4.getMaterial(primitive.material);
+          }
 
-    if (node.camera !== undefined) {
-      node.camera = this.getCamera(node.camera);
-    }
+          return primitive;
+        });
+      }
 
-    if (node.skin !== undefined) {
-      node.skin = this.getSkin(node.skin);
+      return mesh;
     }
+  }, {
+    key: "_resolveMaterial",
+    value: function _resolveMaterial(material, index) {
+      material.id = material.id || "material-".concat(index);
+
+      if (material.normalTexture) {
+        material.normalTexture = _objectSpread({}, material.normalTexture);
+        material.normalTexture.texture = this.getTexture(material.normalTexture.index);
+      }
 
-    return node;
-  }
-
-  _resolveSkin(skin, index) {
-    skin.id = skin.id || "skin-".concat(index);
-    skin.inverseBindMatrices = this.getAccessor(skin.inverseBindMatrices);
-    return skin;
-  }
+      if (material.occlusionTexture) {
+        material.occlustionTexture = _objectSpread({}, material.occlustionTexture);
+        material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);
+      }
 
-  _resolveMesh(mesh, index) {
-    mesh.id = mesh.id || "mesh-".concat(index);
+      if (material.emissiveTexture) {
+        material.emmisiveTexture = _objectSpread({}, material.emmisiveTexture);
+        material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);
+      }
 
-    if (mesh.primitives) {
-      mesh.primitives = mesh.primitives.map(primitive => {
-        primitive = { ...primitive
-        };
-        const attributes = primitive.attributes;
-        primitive.attributes = {};
+      if (!material.emissiveFactor) {
+        material.emissiveFactor = material.emmisiveTexture ? [1, 1, 1] : [0, 0, 0];
+      }
 
-        for (const attribute in attributes) {
-          primitive.attributes[attribute] = this.getAccessor(attributes[attribute]);
-        }
+      if (material.pbrMetallicRoughness) {
+        material.pbrMetallicRoughness = _objectSpread({}, material.pbrMetallicRoughness);
+        var mr = material.pbrMetallicRoughness;
 
-        if (primitive.indices !== undefined) {
-          primitive.indices = this.getAccessor(primitive.indices);
+        if (mr.baseColorTexture) {
+          mr.baseColorTexture = _objectSpread({}, mr.baseColorTexture);
+          mr.baseColorTexture.texture = this.getTexture(mr.baseColorTexture.index);
         }
 
-        if (primitive.material !== undefined) {
-          primitive.material = this.getMaterial(primitive.material);
+        if (mr.metallicRoughnessTexture) {
+          mr.metallicRoughnessTexture = _objectSpread({}, mr.metallicRoughnessTexture);
+          mr.metallicRoughnessTexture.texture = this.getTexture(mr.metallicRoughnessTexture.index);
         }
+      }
 
-        return primitive;
-      });
-    }
-
-    return mesh;
-  }
-
-  _resolveMaterial(material, index) {
-    material.id = material.id || "material-".concat(index);
-
-    if (material.normalTexture) {
-      material.normalTexture = { ...material.normalTexture
-      };
-      material.normalTexture.texture = this.getTexture(material.normalTexture.index);
+      return material;
     }
+  }, {
+    key: "_resolveAccessor",
+    value: function _resolveAccessor(accessor, index) {
+      accessor.id = accessor.id || "accessor-".concat(index);
 
-    if (material.occlusionTexture) {
-      material.occlustionTexture = { ...material.occlustionTexture
-      };
-      material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);
-    }
+      if (accessor.bufferView !== undefined) {
+        accessor.bufferView = this.getBufferView(accessor.bufferView);
+      }
 
-    if (material.emissiveTexture) {
-      material.emmisiveTexture = { ...material.emmisiveTexture
-      };
-      material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);
-    }
+      accessor.bytesPerComponent = getBytesFromComponentType(accessor.componentType);
+      accessor.components = getSizeFromAccessorType(accessor.type);
+      accessor.bytesPerElement = accessor.bytesPerComponent * accessor.components;
 
-    if (!material.emissiveFactor) {
-      material.emissiveFactor = material.emmisiveTexture ? [1, 1, 1] : [0, 0, 0];
-    }
+      if (accessor.bufferView) {
+        var buffer = accessor.bufferView.buffer;
 
-    if (material.pbrMetallicRoughness) {
-      material.pbrMetallicRoughness = { ...material.pbrMetallicRoughness
-      };
-      const mr = material.pbrMetallicRoughness;
+        var _getAccessorArrayType = (0, _gltfUtils.getAccessorArrayTypeAndLength)(accessor, accessor.bufferView),
+            ArrayType = _getAccessorArrayType.ArrayType,
+            byteLength = _getAccessorArrayType.byteLength;
 
-      if (mr.baseColorTexture) {
-        mr.baseColorTexture = { ...mr.baseColorTexture
-        };
-        mr.baseColorTexture.texture = this.getTexture(mr.baseColorTexture.index);
+        var byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
+        var cutBufffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
+        accessor.value = new ArrayType(cutBufffer);
       }
 
-      if (mr.metallicRoughnessTexture) {
-        mr.metallicRoughnessTexture = { ...mr.metallicRoughnessTexture
-        };
-        mr.metallicRoughnessTexture.texture = this.getTexture(mr.metallicRoughnessTexture.index);
-      }
+      return accessor;
+    }
+  }, {
+    key: "_resolveTexture",
+    value: function _resolveTexture(texture, index) {
+      texture.id = texture.id || "texture-".concat(index);
+      texture.sampler = 'sampler' in texture ? this.getSampler(texture.sampler) : DEFAULT_SAMPLER;
+      texture.source = this.getImage(texture.source);
+      return texture;
     }
+  }, {
+    key: "_resolveSampler",
+    value: function _resolveSampler(sampler, index) {
+      sampler.id = sampler.id || "sampler-".concat(index);
+      sampler.parameters = {};
 
-    return material;
-  }
+      for (var key in sampler) {
+        var glEnum = this._enumSamplerParameter(key);
 
-  _resolveAccessor(accessor, index) {
-    accessor.id = accessor.id || "accessor-".concat(index);
+        if (glEnum !== undefined) {
+          sampler.parameters[glEnum] = sampler[key];
+        }
+      }
 
-    if (accessor.bufferView !== undefined) {
-      accessor.bufferView = this.getBufferView(accessor.bufferView);
+      return sampler;
     }
-
-    accessor.bytesPerComponent = getBytesFromComponentType(accessor.componentType);
-    accessor.components = getSizeFromAccessorType(accessor.type);
-    accessor.bytesPerElement = accessor.bytesPerComponent * accessor.components;
-
-    if (accessor.bufferView) {
-      const buffer = accessor.bufferView.buffer;
-      const {
-        ArrayType,
-        byteLength
-      } = (0, _gltfUtils.getAccessorArrayTypeAndLength)(accessor, accessor.bufferView);
-      const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
-      const cutBufffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
-      accessor.value = new ArrayType(cutBufffer);
+  }, {
+    key: "_enumSamplerParameter",
+    value: function _enumSamplerParameter(key) {
+      return SAMPLER_PARAMETER_GLTF_TO_GL[key];
     }
+  }, {
+    key: "_resolveImage",
+    value: function _resolveImage(image, index) {
+      image.id = image.id || "image-".concat(index);
 
-    return accessor;
-  }
-
-  _resolveTexture(texture, index) {
-    texture.id = texture.id || "texture-".concat(index);
-    texture.sampler = 'sampler' in texture ? this.getSampler(texture.sampler) : DEFAULT_SAMPLER;
-    texture.source = this.getImage(texture.source);
-    return texture;
-  }
-
-  _resolveSampler(sampler, index) {
-    sampler.id = sampler.id || "sampler-".concat(index);
-    sampler.parameters = {};
-
-    for (const key in sampler) {
-      const glEnum = this._enumSamplerParameter(key);
-
-      if (glEnum !== undefined) {
-        sampler.parameters[glEnum] = sampler[key];
+      if (image.bufferView !== undefined) {
+        image.bufferView = this.getBufferView(image.bufferView);
       }
-    }
 
-    return sampler;
-  }
+      var preloadedImage = this.images[index];
 
-  _enumSamplerParameter(key) {
-    return SAMPLER_PARAMETER_GLTF_TO_GL[key];
-  }
-
-  _resolveImage(image, index) {
-    image.id = image.id || "image-".concat(index);
+      if (preloadedImage) {
+        image.image = preloadedImage;
+      }
 
-    if (image.bufferView !== undefined) {
-      image.bufferView = this.getBufferView(image.bufferView);
+      return image;
     }
+  }, {
+    key: "_resolveBufferView",
+    value: function _resolveBufferView(bufferView, index) {
+      bufferView.id = bufferView.id || "bufferView-".concat(index);
+      var bufferIndex = bufferView.buffer;
+      bufferView.buffer = this.buffers[bufferIndex];
+      var arrayBuffer = this.buffers[bufferIndex].arrayBuffer;
+      var byteOffset = this.buffers[bufferIndex].byteOffset || 0;
+
+      if ('byteOffset' in bufferView) {
+        byteOffset += bufferView.byteOffset;
+      }
 
-    const preloadedImage = this.images[index];
-
-    if (preloadedImage) {
-      image.image = preloadedImage;
+      bufferView.data = new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
+      return bufferView;
     }
+  }, {
+    key: "_resolveCamera",
+    value: function _resolveCamera(camera, index) {
+      camera.id = camera.id || "camera-".concat(index);
 
-    return image;
-  }
+      if (camera.perspective) {}
 
-  _resolveBufferView(bufferView, index) {
-    bufferView.id = bufferView.id || "bufferView-".concat(index);
-    const bufferIndex = bufferView.buffer;
-    bufferView.buffer = this.buffers[bufferIndex];
-    const arrayBuffer = this.buffers[bufferIndex].arrayBuffer;
-    let byteOffset = this.buffers[bufferIndex].byteOffset || 0;
+      if (camera.orthographic) {}
 
-    if ('byteOffset' in bufferView) {
-      byteOffset += bufferView.byteOffset;
+      return camera;
     }
-
-    bufferView.data = new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
-    return bufferView;
-  }
-
-  _resolveCamera(camera, index) {
-    camera.id = camera.id || "camera-".concat(index);
-
-    if (camera.perspective) {}
-
-    if (camera.orthographic) {}
-
-    return camera;
-  }
-
-}
+  }]);
+  return GLTFPostProcessor;
+}();
 
 function postProcessGLTF(gltf, options) {
   return new GLTFPostProcessor().postProcess(gltf, options);