@loaders.gl/gltf 4.0.0-alpha.6 → 4.0.0-alpha.8

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

@@ -11,7 +11,7 @@ var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/creat
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _assert = require("../utils/assert");
 var _gltfUtils = require("../gltf-utils/gltf-utils");
-var _DEFAULT_SAMPLER;
+var _DEFAULT_SAMPLER_PARA;
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 var COMPONENTS = {
@@ -46,7 +46,13 @@ var SAMPLER_PARAMETER_GLTF_TO_GL = {
   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_T, GL_SAMPLER.REPEAT), _DEFAULT_SAMPLER);
+var DEFAULT_SAMPLER_PARAMETERS = (_DEFAULT_SAMPLER_PARA = {}, (0, _defineProperty2.default)(_DEFAULT_SAMPLER_PARA, GL_SAMPLER.TEXTURE_MAG_FILTER, GL_SAMPLER.LINEAR), (0, _defineProperty2.default)(_DEFAULT_SAMPLER_PARA, GL_SAMPLER.TEXTURE_MIN_FILTER, GL_SAMPLER.NEAREST_MIPMAP_LINEAR), (0, _defineProperty2.default)(_DEFAULT_SAMPLER_PARA, GL_SAMPLER.TEXTURE_WRAP_S, GL_SAMPLER.REPEAT), (0, _defineProperty2.default)(_DEFAULT_SAMPLER_PARA, GL_SAMPLER.TEXTURE_WRAP_T, GL_SAMPLER.REPEAT), _DEFAULT_SAMPLER_PARA);
+function makeDefaultSampler() {
+  return {
+    id: 'default-sampler',
+    parameters: DEFAULT_SAMPLER_PARAMETERS
+  };
+}
 function getBytesFromComponentType(componentType) {
   return BYTES[componentType];
 }
@@ -57,7 +63,8 @@ var GLTFPostProcessor = function () {
   function GLTFPostProcessor() {
     (0, _classCallCheck2.default)(this, GLTFPostProcessor);
     (0, _defineProperty2.default)(this, "baseUri", '');
-    (0, _defineProperty2.default)(this, "json", {});
+    (0, _defineProperty2.default)(this, "jsonUnprocessed", void 0);
+    (0, _defineProperty2.default)(this, "json", void 0);
     (0, _defineProperty2.default)(this, "buffers", []);
     (0, _defineProperty2.default)(this, "images", []);
   }
@@ -69,135 +76,141 @@ var GLTFPostProcessor = function () {
         _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,
+        images = _gltf$images === void 0 ? [] : _gltf$images;
+      var _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);
+      this.jsonUnprocessed = json;
+      this.json = this._resolveTree(gltf.json, options);
       return this.json;
     }
   }, {
     key: "_resolveTree",
-    value: function _resolveTree(json) {
+    value: function _resolveTree(gltf) {
       var _this = this;
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      if (json.bufferViews) {
-        json.bufferViews = json.bufferViews.map(function (bufView, i) {
+      var json = _objectSpread({}, gltf);
+      this.json = json;
+      if (gltf.bufferViews) {
+        json.bufferViews = gltf.bufferViews.map(function (bufView, i) {
           return _this._resolveBufferView(bufView, i);
         });
       }
-      if (json.images) {
-        json.images = json.images.map(function (image, i) {
+      if (gltf.images) {
+        json.images = gltf.images.map(function (image, i) {
           return _this._resolveImage(image, i);
         });
       }
-      if (json.samplers) {
-        json.samplers = json.samplers.map(function (sampler, i) {
+      if (gltf.samplers) {
+        json.samplers = gltf.samplers.map(function (sampler, i) {
           return _this._resolveSampler(sampler, i);
         });
       }
-      if (json.textures) {
-        json.textures = json.textures.map(function (texture, i) {
+      if (gltf.textures) {
+        json.textures = gltf.textures.map(function (texture, i) {
           return _this._resolveTexture(texture, i);
         });
       }
-      if (json.accessors) {
-        json.accessors = json.accessors.map(function (accessor, i) {
+      if (gltf.accessors) {
+        json.accessors = gltf.accessors.map(function (accessor, i) {
           return _this._resolveAccessor(accessor, i);
         });
       }
-      if (json.materials) {
-        json.materials = json.materials.map(function (material, i) {
+      if (gltf.materials) {
+        json.materials = gltf.materials.map(function (material, i) {
           return _this._resolveMaterial(material, i);
         });
       }
-      if (json.meshes) {
-        json.meshes = json.meshes.map(function (mesh, i) {
+      if (gltf.meshes) {
+        json.meshes = gltf.meshes.map(function (mesh, i) {
           return _this._resolveMesh(mesh, i);
         });
       }
-      if (json.nodes) {
-        json.nodes = json.nodes.map(function (node, i) {
+      if (gltf.nodes) {
+        json.nodes = gltf.nodes.map(function (node, i) {
           return _this._resolveNode(node, i);
         });
+        json.nodes = json.nodes.map(function (node, i) {
+          return _this._resolveNodeChildren(node);
+        });
       }
-      if (json.skins) {
-        json.skins = json.skins.map(function (skin, i) {
+      if (gltf.skins) {
+        json.skins = gltf.skins.map(function (skin, i) {
           return _this._resolveSkin(skin, i);
         });
       }
-      if (json.scenes) {
-        json.scenes = json.scenes.map(function (scene, i) {
+      if (gltf.scenes) {
+        json.scenes = gltf.scenes.map(function (scene, i) {
           return _this._resolveScene(scene, i);
         });
       }
-      if (json.scene !== undefined) {
+      if (typeof this.json.scene === 'number' && json.scenes) {
         json.scene = json.scenes[this.json.scene];
       }
+      return json;
     }
   }, {
     key: "getScene",
     value: function getScene(index) {
-      return this._get('scenes', index);
+      return this._get(this.json.scenes, index);
     }
   }, {
     key: "getNode",
     value: function getNode(index) {
-      return this._get('nodes', index);
+      return this._get(this.json.nodes, index);
     }
   }, {
     key: "getSkin",
     value: function getSkin(index) {
-      return this._get('skins', index);
+      return this._get(this.json.skins, index);
     }
   }, {
     key: "getMesh",
     value: function getMesh(index) {
-      return this._get('meshes', index);
+      return this._get(this.json.meshes, index);
     }
   }, {
     key: "getMaterial",
     value: function getMaterial(index) {
-      return this._get('materials', index);
+      return this._get(this.json.materials, index);
     }
   }, {
     key: "getAccessor",
     value: function getAccessor(index) {
-      return this._get('accessors', index);
+      return this._get(this.json.accessors, index);
     }
   }, {
     key: "getCamera",
     value: function getCamera(index) {
-      return null;
+      return this._get(this.json.cameras, index);
     }
   }, {
     key: "getTexture",
     value: function getTexture(index) {
-      return this._get('textures', index);
+      return this._get(this.json.textures, index);
     }
   }, {
     key: "getSampler",
     value: function getSampler(index) {
-      return this._get('samplers', index);
+      return this._get(this.json.samplers, index);
     }
   }, {
     key: "getImage",
     value: function getImage(index) {
-      return this._get('images', index);
+      return this._get(this.json.images, index);
     }
   }, {
     key: "getBufferView",
     value: function getBufferView(index) {
-      return this._get('bufferViews', index);
+      return this._get(this.json.bufferViews, index);
     }
   }, {
     key: "getBuffer",
     value: function getBuffer(index) {
-      return this._get('buffers', index);
+      return this._get(this.json.buffers, index);
     }
   }, {
     key: "_get",
@@ -205,7 +218,7 @@ var GLTFPostProcessor = function () {
       if ((0, _typeof2.default)(index) === 'object') {
         return index;
       }
-      var object = this.json[array] && this.json[array][index];
+      var object = array && array[index];
       if (!object) {
         console.warn("glTF file error: Could not find ".concat(array, "[").concat(index, "]"));
       }
@@ -215,26 +228,31 @@ var GLTFPostProcessor = function () {
     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 _objectSpread(_objectSpread({}, scene), {}, {
+        id: scene.id || "scene-".concat(index),
+        nodes: (scene.nodes || []).map(function (node) {
+          return _this2.getNode(node);
+        })
       });
-      return scene;
     }
   }, {
     key: "_resolveNode",
-    value: function _resolveNode(node, index) {
+    value: function _resolveNode(gltfNode, index) {
       var _this3 = this;
-      node.id = node.id || "node-".concat(index);
-      if (node.children) {
-        node.children = node.children.map(function (child) {
-          return _this3.getNode(child);
-        });
+      var node = _objectSpread(_objectSpread({}, gltfNode), {}, {
+        id: (gltfNode === null || gltfNode === void 0 ? void 0 : gltfNode.id) || "node-".concat(index)
+      });
+      if (gltfNode.mesh !== undefined) {
+        node.mesh = this.getMesh(gltfNode.mesh);
+      }
+      if (gltfNode.camera !== undefined) {
+        node.camera = this.getCamera(gltfNode.camera);
       }
-      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) {
+      if (gltfNode.skin !== undefined) {
+        node.skin = this.getSkin(gltfNode.skin);
+      }
+      if (gltfNode.meshes !== undefined && gltfNode.meshes.length) {
+        node.mesh = gltfNode.meshes.reduce(function (accum, meshIndex) {
           var mesh = _this3.getMesh(meshIndex);
           accum.id = mesh.id;
           accum.primitives = accum.primitives.concat(mesh.primitives);
@@ -243,39 +261,52 @@ var GLTFPostProcessor = function () {
           primitives: []
         });
       }
-      if (node.camera !== undefined) {
-        node.camera = this.getCamera(node.camera);
-      }
-      if (node.skin !== undefined) {
-        node.skin = this.getSkin(node.skin);
+      return node;
+    }
+  }, {
+    key: "_resolveNodeChildren",
+    value: function _resolveNodeChildren(node) {
+      var _this4 = this;
+      if (node.children) {
+        node.children = node.children.map(function (child) {
+          return _this4.getNode(child);
+        });
       }
       return node;
     }
   }, {
     key: "_resolveSkin",
-    value: function _resolveSkin(skin, index) {
-      skin.id = skin.id || "skin-".concat(index);
-      skin.inverseBindMatrices = this.getAccessor(skin.inverseBindMatrices);
-      return skin;
+    value: function _resolveSkin(gltfSkin, index) {
+      var inverseBindMatrices = typeof gltfSkin.inverseBindMatrices === 'number' ? this.getAccessor(gltfSkin.inverseBindMatrices) : undefined;
+      return _objectSpread(_objectSpread({}, gltfSkin), {}, {
+        id: gltfSkin.id || "skin-".concat(index),
+        inverseBindMatrices: inverseBindMatrices
+      });
     }
   }, {
     key: "_resolveMesh",
-    value: function _resolveMesh(mesh, index) {
-      var _this4 = this;
-      mesh.id = mesh.id || "mesh-".concat(index);
-      if (mesh.primitives) {
-        mesh.primitives = mesh.primitives.map(function (primitive) {
-          primitive = _objectSpread({}, primitive);
-          var attributes = primitive.attributes;
-          primitive.attributes = {};
+    value: function _resolveMesh(gltfMesh, index) {
+      var _this5 = this;
+      var mesh = _objectSpread(_objectSpread({}, gltfMesh), {}, {
+        id: gltfMesh.id || "mesh-".concat(index),
+        primitives: []
+      });
+      if (gltfMesh.primitives) {
+        mesh.primitives = gltfMesh.primitives.map(function (gltfPrimitive) {
+          var primitive = _objectSpread(_objectSpread({}, gltfPrimitive), {}, {
+            attributes: {},
+            indices: undefined,
+            material: undefined
+          });
+          var attributes = gltfPrimitive.attributes;
           for (var attribute in attributes) {
-            primitive.attributes[attribute] = _this4.getAccessor(attributes[attribute]);
+            primitive.attributes[attribute] = _this5.getAccessor(attributes[attribute]);
           }
-          if (primitive.indices !== undefined) {
-            primitive.indices = _this4.getAccessor(primitive.indices);
+          if (gltfPrimitive.indices !== undefined) {
+            primitive.indices = _this5.getAccessor(gltfPrimitive.indices);
           }
-          if (primitive.material !== undefined) {
-            primitive.material = _this4.getMaterial(primitive.material);
+          if (gltfPrimitive.material !== undefined) {
+            primitive.material = _this5.getMaterial(gltfPrimitive.material);
           }
           return primitive;
         });
@@ -284,22 +315,24 @@ var GLTFPostProcessor = function () {
     }
   }, {
     key: "_resolveMaterial",
-    value: function _resolveMaterial(material, index) {
-      material.id = material.id || "material-".concat(index);
+    value: function _resolveMaterial(gltfMaterial, index) {
+      var material = _objectSpread(_objectSpread({}, gltfMaterial), {}, {
+        id: gltfMaterial.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 = _objectSpread({}, material.occlusionTexture);
         material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);
       }
       if (material.emissiveTexture) {
-        material.emmisiveTexture = _objectSpread({}, material.emmisiveTexture);
+        material.emissiveTexture = _objectSpread({}, material.emissiveTexture);
         material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);
       }
       if (!material.emissiveFactor) {
-        material.emissiveFactor = material.emmisiveTexture ? [1, 1, 1] : [0, 0, 0];
+        material.emissiveFactor = material.emissiveTexture ? [1, 1, 1] : [0, 0, 0];
       }
       if (material.pbrMetallicRoughness) {
         material.pbrMetallicRoughness = _objectSpread({}, material.pbrMetallicRoughness);
@@ -317,14 +350,22 @@ var GLTFPostProcessor = function () {
     }
   }, {
     key: "_resolveAccessor",
-    value: function _resolveAccessor(accessor, index) {
-      accessor.id = accessor.id || "accessor-".concat(index);
-      if (accessor.bufferView !== undefined) {
-        accessor.bufferView = this.getBufferView(accessor.bufferView);
+    value: function _resolveAccessor(gltfAccessor, index) {
+      var bytesPerComponent = getBytesFromComponentType(gltfAccessor.componentType);
+      var components = getSizeFromAccessorType(gltfAccessor.type);
+      var bytesPerElement = bytesPerComponent * components;
+      var accessor = _objectSpread(_objectSpread({}, gltfAccessor), {}, {
+        id: gltfAccessor.id || "accessor-".concat(index),
+        bytesPerComponent: bytesPerComponent,
+        components: components,
+        bytesPerElement: bytesPerElement,
+        value: undefined,
+        bufferView: undefined,
+        sparse: undefined
+      });
+      if (gltfAccessor.bufferView !== undefined) {
+        accessor.bufferView = this.getBufferView(gltfAccessor.bufferView);
       }
-      accessor.bytesPerComponent = getBytesFromComponentType(accessor.componentType);
-      accessor.components = getSizeFromAccessorType(accessor.type);
-      accessor.bytesPerElement = accessor.bytesPerComponent * accessor.components;
       if (accessor.bufferView) {
         var buffer = accessor.bufferView.buffer;
         var _getAccessorArrayType = (0, _gltfUtils.getAccessorArrayTypeAndLength)(accessor, accessor.bufferView),
@@ -351,17 +392,21 @@ var GLTFPostProcessor = function () {
     }
   }, {
     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;
+    value: function _resolveTexture(gltfTexture, index) {
+      return _objectSpread(_objectSpread({}, gltfTexture), {}, {
+        id: gltfTexture.id || "texture-".concat(index),
+        sampler: typeof gltfTexture.sampler === 'number' ? this.getSampler(gltfTexture.sampler) : makeDefaultSampler(),
+        source: typeof gltfTexture.source === 'number' ? this.getImage(gltfTexture.source) : undefined
+      });
     }
   }, {
     key: "_resolveSampler",
-    value: function _resolveSampler(sampler, index) {
-      sampler.id = sampler.id || "sampler-".concat(index);
-      sampler.parameters = {};
+    value: function _resolveSampler(gltfSampler, index) {
+      var sampler = _objectSpread(_objectSpread({
+        id: gltfSampler.id || "sampler-".concat(index)
+      }, gltfSampler), {}, {
+        parameters: {}
+      });
       for (var key in sampler) {
         var glEnum = this._enumSamplerParameter(key);
         if (glEnum !== undefined) {
@@ -377,11 +422,12 @@ var GLTFPostProcessor = function () {
     }
   }, {
     key: "_resolveImage",
-    value: function _resolveImage(image, index) {
-      image.id = image.id || "image-".concat(index);
-      if (image.bufferView !== undefined) {
-        image.bufferView = this.getBufferView(image.bufferView);
-      }
+    value: function _resolveImage(gltfImage, index) {
+      var image = _objectSpread(_objectSpread({}, gltfImage), {}, {
+        id: gltfImage.id || "image-".concat(index),
+        image: null,
+        bufferView: gltfImage.bufferView !== undefined ? this.getBufferView(gltfImage.bufferView) : undefined
+      });
       var preloadedImage = this.images[index];
       if (preloadedImage) {
         image.image = preloadedImage;
@@ -390,25 +436,27 @@ var GLTFPostProcessor = function () {
     }
   }, {
     key: "_resolveBufferView",
-    value: function _resolveBufferView(bufferView, index) {
-      var bufferIndex = bufferView.buffer;
-      var result = _objectSpread(_objectSpread({
-        id: "bufferView-".concat(index)
-      }, bufferView), {}, {
-        buffer: this.buffers[bufferIndex]
-      });
+    value: function _resolveBufferView(gltfBufferView, index) {
+      var bufferIndex = gltfBufferView.buffer;
       var arrayBuffer = this.buffers[bufferIndex].arrayBuffer;
       var byteOffset = this.buffers[bufferIndex].byteOffset || 0;
-      if ('byteOffset' in bufferView) {
-        byteOffset += bufferView.byteOffset;
+      if (gltfBufferView.byteOffset) {
+        byteOffset += gltfBufferView.byteOffset;
       }
-      result.data = new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
-      return result;
+      var bufferView = _objectSpread(_objectSpread({
+        id: "bufferView-".concat(index)
+      }, gltfBufferView), {}, {
+        buffer: this.buffers[bufferIndex],
+        data: new Uint8Array(arrayBuffer, byteOffset, gltfBufferView.byteLength)
+      });
+      return bufferView;
     }
   }, {
     key: "_resolveCamera",
-    value: function _resolveCamera(camera, index) {
-      camera.id = camera.id || "camera-".concat(index);
+    value: function _resolveCamera(gltfCamera, index) {
+      var camera = _objectSpread(_objectSpread({}, gltfCamera), {}, {
+        id: gltfCamera.id || "camera-".concat(index)
+      });
       if (camera.perspective) {}
       if (camera.orthographic) {}
       return camera;