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

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

@@ -1,31 +1,15 @@
 "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");
 
-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 = {
+const COMPONENTS = {
   SCALAR: 1,
   VEC2: 2,
   VEC3: 3,
@@ -34,7 +18,7 @@ var COMPONENTS = {
   MAT3: 9,
   MAT4: 16
 };
-var BYTES = {
+const BYTES = {
   5120: 1,
   5121: 1,
   5122: 2,
@@ -42,7 +26,7 @@ var BYTES = {
   5125: 4,
   5126: 4
 };
-var GL_SAMPLER = {
+const GL_SAMPLER = {
   TEXTURE_MAG_FILTER: 0x2800,
   TEXTURE_MIN_FILTER: 0x2801,
   TEXTURE_WRAP_S: 0x2802,
@@ -51,13 +35,18 @@ var GL_SAMPLER = {
   LINEAR: 0x2601,
   NEAREST_MIPMAP_LINEAR: 0x2702
 };
-var SAMPLER_PARAMETER_GLTF_TO_GL = {
+const 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
 };
-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);
+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
+};
 
 function getBytesFromComponentType(componentType) {
   return BYTES[componentType];
@@ -67,408 +56,344 @@ function getSizeFromAccessorType(type) {
   return COMPONENTS[type];
 }
 
-var GLTFPostProcessor = function () {
-  function GLTFPostProcessor() {
-    (0, _classCallCheck2.default)(this, GLTFPostProcessor);
+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;
   }
 
-  (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;
+  _resolveTree(json, options = {}) {
+    if (json.bufferViews) {
+      json.bufferViews = json.bufferViews.map((bufView, i) => this._resolveBufferView(bufView, i));
     }
-  }, {
-    key: "_resolveTree",
-    value: function _resolveTree(json) {
-      var _this = this;
 
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    if (json.images) {
+      json.images = json.images.map((image, i) => this._resolveImage(image, i));
+    }
 
-      if (json.bufferViews) {
-        json.bufferViews = json.bufferViews.map(function (bufView, i) {
-          return _this._resolveBufferView(bufView, i);
-        });
-      }
+    if (json.samplers) {
+      json.samplers = json.samplers.map((sampler, i) => this._resolveSampler(sampler, i));
+    }
 
-      if (json.images) {
-        json.images = json.images.map(function (image, i) {
-          return _this._resolveImage(image, i);
-        });
-      }
+    if (json.textures) {
+      json.textures = json.textures.map((texture, i) => this._resolveTexture(texture, i));
+    }
 
-      if (json.samplers) {
-        json.samplers = json.samplers.map(function (sampler, i) {
-          return _this._resolveSampler(sampler, i);
-        });
-      }
+    if (json.accessors) {
+      json.accessors = json.accessors.map((accessor, i) => this._resolveAccessor(accessor, i));
+    }
 
-      if (json.textures) {
-        json.textures = json.textures.map(function (texture, i) {
-          return _this._resolveTexture(texture, i);
-        });
-      }
+    if (json.materials) {
+      json.materials = json.materials.map((material, i) => this._resolveMaterial(material, i));
+    }
 
-      if (json.accessors) {
-        json.accessors = json.accessors.map(function (accessor, i) {
-          return _this._resolveAccessor(accessor, i);
-        });
-      }
+    if (json.meshes) {
+      json.meshes = json.meshes.map((mesh, i) => this._resolveMesh(mesh, i));
+    }
 
-      if (json.materials) {
-        json.materials = json.materials.map(function (material, i) {
-          return _this._resolveMaterial(material, i);
-        });
-      }
+    if (json.nodes) {
+      json.nodes = json.nodes.map((node, i) => this._resolveNode(node, i));
+    }
 
-      if (json.meshes) {
-        json.meshes = json.meshes.map(function (mesh, i) {
-          return _this._resolveMesh(mesh, i);
-        });
-      }
+    if (json.skins) {
+      json.skins = json.skins.map((skin, i) => this._resolveSkin(skin, i));
+    }
 
-      if (json.nodes) {
-        json.nodes = json.nodes.map(function (node, i) {
-          return _this._resolveNode(node, i);
-        });
-      }
+    if (json.scenes) {
+      json.scenes = json.scenes.map((scene, i) => this._resolveScene(scene, i));
+    }
 
-      if (json.skins) {
-        json.skins = json.skins.map(function (skin, i) {
-          return _this._resolveSkin(skin, i);
-        });
-      }
+    if (json.scene !== undefined) {
+      json.scene = json.scenes[this.json.scene];
+    }
+  }
 
-      if (json.scenes) {
-        json.scenes = json.scenes.map(function (scene, i) {
-          return _this._resolveScene(scene, i);
-        });
-      }
+  getScene(index) {
+    return this._get('scenes', 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;
-      }
+  getNode(index) {
+    return this._get('nodes', index);
+  }
 
-      var object = this.json[array] && this.json[array][index];
+  getSkin(index) {
+    return this._get('skins', index);
+  }
 
-      if (!object) {
-        console.warn("glTF file error: Could not find ".concat(array, "[").concat(index, "]"));
-      }
+  getMesh(index) {
+    return this._get('meshes', index);
+  }
 
-      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;
+  getMaterial(index) {
+    return this._get('materials', index);
+  }
 
-      node.id = node.id || "node-".concat(index);
+  getAccessor(index) {
+    return this._get('accessors', index);
+  }
 
-      if (node.children) {
-        node.children = node.children.map(function (child) {
-          return _this3.getNode(child);
-        });
-      }
+  getCamera(index) {
+    return null;
+  }
 
-      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: []
-        });
-      }
+  getTexture(index) {
+    return this._get('textures', index);
+  }
 
-      if (node.camera !== undefined) {
-        node.camera = this.getCamera(node.camera);
-      }
+  getSampler(index) {
+    return this._get('samplers', index);
+  }
 
-      if (node.skin !== undefined) {
-        node.skin = this.getSkin(node.skin);
-      }
+  getImage(index) {
+    return this._get('images', index);
+  }
+
+  getBufferView(index) {
+    return this._get('bufferViews', index);
+  }
+
+  getBuffer(index) {
+    return this._get('buffers', index);
+  }
 
-      return node;
+  _get(array, index) {
+    if (typeof index === 'object') {
+      return index;
     }
-  }, {
-    key: "_resolveSkin",
-    value: function _resolveSkin(skin, index) {
-      skin.id = skin.id || "skin-".concat(index);
-      skin.inverseBindMatrices = this.getAccessor(skin.inverseBindMatrices);
-      return skin;
+
+    const object = this.json[array] && this.json[array][index];
+
+    if (!object) {
+      console.warn("glTF file error: Could not find ".concat(array, "[").concat(index, "]"));
     }
-  }, {
-    key: "_resolveMesh",
-    value: function _resolveMesh(mesh, index) {
-      var _this4 = this;
 
-      mesh.id = mesh.id || "mesh-".concat(index);
+    return object;
+  }
 
-      if (mesh.primitives) {
-        mesh.primitives = mesh.primitives.map(function (primitive) {
-          primitive = _objectSpread({}, primitive);
-          var attributes = primitive.attributes;
-          primitive.attributes = {};
+  _resolveScene(scene, index) {
+    scene.id = scene.id || "scene-".concat(index);
+    scene.nodes = (scene.nodes || []).map(node => this.getNode(node));
+    return scene;
+  }
 
-          for (var attribute in attributes) {
-            primitive.attributes[attribute] = _this4.getAccessor(attributes[attribute]);
-          }
+  _resolveNode(node, index) {
+    node.id = node.id || "node-".concat(index);
 
-          if (primitive.indices !== undefined) {
-            primitive.indices = _this4.getAccessor(primitive.indices);
-          }
+    if (node.children) {
+      node.children = node.children.map(child => this.getNode(child));
+    }
 
-          if (primitive.material !== undefined) {
-            primitive.material = _this4.getMaterial(primitive.material);
-          }
+    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: []
+      });
+    }
 
-          return primitive;
-        });
-      }
+    if (node.camera !== undefined) {
+      node.camera = this.getCamera(node.camera);
+    }
 
-      return mesh;
+    if (node.skin !== undefined) {
+      node.skin = this.getSkin(node.skin);
     }
-  }, {
-    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);
-      }
 
-      if (material.occlusionTexture) {
-        material.occlustionTexture = _objectSpread({}, material.occlustionTexture);
-        material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);
-      }
+    return node;
+  }
 
-      if (material.emissiveTexture) {
-        material.emmisiveTexture = _objectSpread({}, material.emmisiveTexture);
-        material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);
-      }
+  _resolveSkin(skin, index) {
+    skin.id = skin.id || "skin-".concat(index);
+    skin.inverseBindMatrices = this.getAccessor(skin.inverseBindMatrices);
+    return skin;
+  }
 
-      if (!material.emissiveFactor) {
-        material.emissiveFactor = material.emmisiveTexture ? [1, 1, 1] : [0, 0, 0];
-      }
+  _resolveMesh(mesh, index) {
+    mesh.id = mesh.id || "mesh-".concat(index);
 
-      if (material.pbrMetallicRoughness) {
-        material.pbrMetallicRoughness = _objectSpread({}, material.pbrMetallicRoughness);
-        var mr = material.pbrMetallicRoughness;
+    if (mesh.primitives) {
+      mesh.primitives = mesh.primitives.map(primitive => {
+        primitive = { ...primitive
+        };
+        const attributes = primitive.attributes;
+        primitive.attributes = {};
 
-        if (mr.baseColorTexture) {
-          mr.baseColorTexture = _objectSpread({}, mr.baseColorTexture);
-          mr.baseColorTexture.texture = this.getTexture(mr.baseColorTexture.index);
+        for (const attribute in attributes) {
+          primitive.attributes[attribute] = this.getAccessor(attributes[attribute]);
         }
 
-        if (mr.metallicRoughnessTexture) {
-          mr.metallicRoughnessTexture = _objectSpread({}, mr.metallicRoughnessTexture);
-          mr.metallicRoughnessTexture.texture = this.getTexture(mr.metallicRoughnessTexture.index);
+        if (primitive.indices !== undefined) {
+          primitive.indices = this.getAccessor(primitive.indices);
         }
-      }
 
-      return material;
-    }
-  }, {
-    key: "_resolveAccessor",
-    value: function _resolveAccessor(accessor, index) {
-      accessor.id = accessor.id || "accessor-".concat(index);
+        if (primitive.material !== undefined) {
+          primitive.material = this.getMaterial(primitive.material);
+        }
 
-      if (accessor.bufferView !== undefined) {
-        accessor.bufferView = this.getBufferView(accessor.bufferView);
-      }
+        return primitive;
+      });
+    }
 
-      accessor.bytesPerComponent = getBytesFromComponentType(accessor.componentType);
-      accessor.components = getSizeFromAccessorType(accessor.type);
-      accessor.bytesPerElement = accessor.bytesPerComponent * accessor.components;
+    return mesh;
+  }
 
-      if (accessor.bufferView) {
-        var buffer = accessor.bufferView.buffer;
+  _resolveMaterial(material, index) {
+    material.id = material.id || "material-".concat(index);
 
-        var _getAccessorArrayType = (0, _gltfUtils.getAccessorArrayTypeAndLength)(accessor, accessor.bufferView),
-            ArrayType = _getAccessorArrayType.ArrayType,
-            byteLength = _getAccessorArrayType.byteLength;
+    if (material.normalTexture) {
+      material.normalTexture = { ...material.normalTexture
+      };
+      material.normalTexture.texture = this.getTexture(material.normalTexture.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 (material.occlusionTexture) {
+      material.occlustionTexture = { ...material.occlustionTexture
+      };
+      material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);
+    }
 
-      return accessor;
+    if (material.emissiveTexture) {
+      material.emmisiveTexture = { ...material.emmisiveTexture
+      };
+      material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);
     }
-  }, {
-    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;
+
+    if (!material.emissiveFactor) {
+      material.emissiveFactor = material.emmisiveTexture ? [1, 1, 1] : [0, 0, 0];
     }
-  }, {
-    key: "_resolveSampler",
-    value: function _resolveSampler(sampler, index) {
-      sampler.id = sampler.id || "sampler-".concat(index);
-      sampler.parameters = {};
 
-      for (var key in sampler) {
-        var glEnum = this._enumSamplerParameter(key);
+    if (material.pbrMetallicRoughness) {
+      material.pbrMetallicRoughness = { ...material.pbrMetallicRoughness
+      };
+      const mr = material.pbrMetallicRoughness;
 
-        if (glEnum !== undefined) {
-          sampler.parameters[glEnum] = sampler[key];
-        }
+      if (mr.baseColorTexture) {
+        mr.baseColorTexture = { ...mr.baseColorTexture
+        };
+        mr.baseColorTexture.texture = this.getTexture(mr.baseColorTexture.index);
       }
 
-      return sampler;
+      if (mr.metallicRoughnessTexture) {
+        mr.metallicRoughnessTexture = { ...mr.metallicRoughnessTexture
+        };
+        mr.metallicRoughnessTexture.texture = this.getTexture(mr.metallicRoughnessTexture.index);
+      }
     }
-  }, {
-    key: "_enumSamplerParameter",
-    value: function _enumSamplerParameter(key) {
-      return SAMPLER_PARAMETER_GLTF_TO_GL[key];
+
+    return material;
+  }
+
+  _resolveAccessor(accessor, index) {
+    accessor.id = accessor.id || "accessor-".concat(index);
+
+    if (accessor.bufferView !== undefined) {
+      accessor.bufferView = this.getBufferView(accessor.bufferView);
     }
-  }, {
-    key: "_resolveImage",
-    value: function _resolveImage(image, index) {
-      image.id = image.id || "image-".concat(index);
 
-      if (image.bufferView !== undefined) {
-        image.bufferView = this.getBufferView(image.bufferView);
-      }
+    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);
+    }
 
-      var preloadedImage = this.images[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 = {};
 
-      if (preloadedImage) {
-        image.image = preloadedImage;
+    for (const key in sampler) {
+      const glEnum = this._enumSamplerParameter(key);
+
+      if (glEnum !== undefined) {
+        sampler.parameters[glEnum] = sampler[key];
       }
+    }
+
+    return sampler;
+  }
 
-      return image;
+  _enumSamplerParameter(key) {
+    return SAMPLER_PARAMETER_GLTF_TO_GL[key];
+  }
+
+  _resolveImage(image, index) {
+    image.id = image.id || "image-".concat(index);
+
+    if (image.bufferView !== undefined) {
+      image.bufferView = this.getBufferView(image.bufferView);
     }
-  }, {
-    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;
-      }
 
-      bufferView.data = new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
-      return bufferView;
+    const preloadedImage = this.images[index];
+
+    if (preloadedImage) {
+      image.image = preloadedImage;
     }
-  }, {
-    key: "_resolveCamera",
-    value: function _resolveCamera(camera, index) {
-      camera.id = camera.id || "camera-".concat(index);
 
-      if (camera.perspective) {}
+    return image;
+  }
 
-      if (camera.orthographic) {}
+  _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;
 
-      return camera;
+    if ('byteOffset' in bufferView) {
+      byteOffset += bufferView.byteOffset;
     }
-  }]);
-  return GLTFPostProcessor;
-}();
+
+    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;
+  }
+
+}
 
 function postProcessGLTF(gltf, options) {
   return new GLTFPostProcessor().postProcess(gltf, options);