@loaders.gl/tile-converter 3.1.0-beta.1 → 3.1.0

package/dist/es5/i3s-converter/helpers/geometry-converter.js

@@ -7,6 +7,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = convertB3dmToI3sGeometry;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _core = require("@math.gl/core");
 
 var _geospatial = require("@math.gl/geospatial");
@@ -21,245 +27,388 @@ var _md = _interopRequireDefault(require("md5"));
 
 var _geometryAttributes = require("./geometry-attributes");
 
-const VALUES_PER_VERTEX = 3;
-const VALUES_PER_TEX_COORD = 2;
-const VALUES_PER_COLOR_ELEMENT = 4;
-const STRING_TYPE = 'string';
-const SHORT_INT_TYPE = 'Int32';
-const DOUBLE_TYPE = 'Float64';
-const OBJECT_ID_TYPE = 'Oid32';
-const BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES = ['CUSTOM_ATTRIBUTE_2', '_BATCHID', 'BATCHID'];
+var _coordinateConverter = require("./coordinate-converter");
 
-async function convertB3dmToI3sGeometry(tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco) {
-  const materialAndTextureList = convertMaterials(tileContent);
-  const convertedAttributesMap = convertAttributes(tileContent);
+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; }
 
-  if (convertedAttributesMap.has('default')) {
-    materialAndTextureList.push({
-      material: getDefaultMaterial()
-    });
-  }
+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; }
 
-  const result = [];
-  let nodesCounter = nodeId;
-  let {
-    materials = []
-  } = tileContent.gltf;
+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); }
 
-  if (!materials.length === 0) {
-    materials.push({
-      id: 'default'
-    });
-  }
+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; }
 
-  for (let i = 0; i < materials.length; i++) {
-    const sourceMaterial = materials[i];
+var VALUES_PER_VERTEX = 3;
+var VALUES_PER_TEX_COORD = 2;
+var VALUES_PER_COLOR_ELEMENT = 4;
+var STRING_TYPE = 'string';
+var SHORT_INT_TYPE = 'Int32';
+var DOUBLE_TYPE = 'Float64';
+var OBJECT_ID_TYPE = 'Oid32';
+var BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES = ['CUSTOM_ATTRIBUTE_2', '_BATCHID', 'BATCHID'];
+var scratchVector = new _core.Vector3();
 
-    if (!convertedAttributesMap.has(sourceMaterial.id)) {
-      continue;
-    }
+function convertB3dmToI3sGeometry(_x, _x2, _x3, _x4, _x5, _x6, _x7) {
+  return _convertB3dmToI3sGeometry.apply(this, arguments);
+}
 
-    const convertedAttributes = convertedAttributesMap.get(sourceMaterial.id);
-    const {
-      material,
-      texture
-    } = materialAndTextureList[i];
-    result.push(await _makeNodeResources({
-      convertedAttributes,
-      material,
-      texture,
-      tileContent,
-      nodeId: nodesCounter,
-      featuresHashArray,
-      attributeStorageInfo,
-      draco
-    }));
-    nodesCounter++;
-  }
+function _convertB3dmToI3sGeometry() {
+  _convertB3dmToI3sGeometry = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, geoidHeightModel) {
+    var useCartesianPositions, materialAndTextureList, convertedAttributesMap, result, nodesCounter, _tileContent$gltf$mat, materials, i, sourceMaterial, convertedAttributes, _materialAndTextureLi, material, texture;
 
-  if (!result.length) {
-    return null;
-  }
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            useCartesianPositions = generateBoundingVolumes;
+            materialAndTextureList = convertMaterials(tileContent);
+            convertedAttributesMap = convertAttributes(tileContent, useCartesianPositions);
 
-  return result;
-}
+            if (generateBoundingVolumes) {
+              _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeightModel);
+            }
 
-async function _makeNodeResources({
-  convertedAttributes,
-  material,
-  texture,
-  tileContent,
-  nodeId,
-  featuresHashArray,
-  attributeStorageInfo,
-  draco
-}) {
-  const vertexCount = convertedAttributes.positions.length / VALUES_PER_VERTEX;
-  const triangleCount = vertexCount / 3;
-  const {
-    faceRange,
-    featureIds,
-    positions,
-    normals,
-    colors,
-    texCoords,
-    featureCount
-  } = (0, _geometryAttributes.generateAttributes)({
-    triangleCount,
-    ...convertedAttributes
-  });
+            if (convertedAttributesMap.has('default')) {
+              materialAndTextureList.push({
+                material: getDefaultMaterial()
+              });
+            }
 
-  if (tileContent.batchTableJson) {
-    makeFeatureIdsUnique(featureIds, convertedAttributes.featureIndices, featuresHashArray, tileContent.batchTableJson);
-  }
-
-  const header = new Uint32Array(2);
-  const typedFeatureIds = generateBigUint64Array(featureIds);
-  header.set([vertexCount, featureCount], 0);
-  const fileBuffer = new Uint8Array((0, _loaderUtils.concatenateArrayBuffers)(header.buffer, positions.buffer, normals.buffer, texture ? texCoords.buffer : new ArrayBuffer(0), colors.buffer, typedFeatureIds.buffer, faceRange.buffer));
-  const compressedGeometry = draco ? await generateCompressedGeometry(vertexCount, convertedAttributes, {
-    positions,
-    normals,
-    texCoords: texture ? texCoords : new Float32Array(0),
-    colors,
-    featureIds,
-    faceRange
-  }) : null;
-  const attributes = convertBatchTableToAttributeBuffers(tileContent.batchTableJson, featureIds, attributeStorageInfo);
-  return {
-    geometry: fileBuffer,
-    compressedGeometry,
-    texture,
-    sharedResources: getSharedResources(tileContent, nodeId),
-    meshMaterial: material,
-    vertexCount,
-    attributes,
-    featureCount
-  };
-}
+            result = [];
+            nodesCounter = nodeId;
+            _tileContent$gltf$mat = tileContent.gltf.materials, materials = _tileContent$gltf$mat === void 0 ? [] : _tileContent$gltf$mat;
 
-function convertAttributes(tileContent) {
-  var _tileContent$gltf$sce;
+            if (!(materials !== null && materials !== void 0 && materials.length)) {
+              materials.push({
+                id: 'default'
+              });
+            }
 
-  const attributesMap = new Map();
+            i = 0;
 
-  for (const material of tileContent.gltf.materials || [{
-    id: 'default'
-  }]) {
-    attributesMap.set(material.id, {
-      positions: new Float32Array(0),
-      normals: new Float32Array(0),
-      texCoords: new Float32Array(0),
-      colors: new Uint8Array(0),
-      featureIndices: []
-    });
-  }
+          case 10:
+            if (!(i < materials.length)) {
+              _context.next = 25;
+              break;
+            }
 
-  const nodes = (tileContent.gltf.scene || ((_tileContent$gltf$sce = tileContent.gltf.scenes) === null || _tileContent$gltf$sce === void 0 ? void 0 : _tileContent$gltf$sce[0]) || tileContent.gltf).nodes;
-  convertNodes(nodes, tileContent, attributesMap);
+            sourceMaterial = materials[i];
 
-  for (const attrKey of attributesMap.keys()) {
-    const attributes = attributesMap.get(attrKey);
+            if (convertedAttributesMap.has(sourceMaterial.id)) {
+              _context.next = 14;
+              break;
+            }
 
-    if (attributes.positions.length === 0) {
-      attributesMap.delete(attrKey);
-      continue;
-    }
+            return _context.abrupt("continue", 22);
+
+          case 14:
+            convertedAttributes = convertedAttributesMap.get(sourceMaterial.id);
+            _materialAndTextureLi = materialAndTextureList[i], material = _materialAndTextureLi.material, texture = _materialAndTextureLi.texture;
+            _context.t0 = result;
+            _context.next = 19;
+            return _makeNodeResources({
+              convertedAttributes: convertedAttributes,
+              material: material,
+              texture: texture,
+              tileContent: tileContent,
+              nodeId: nodesCounter,
+              featuresHashArray: featuresHashArray,
+              attributeStorageInfo: attributeStorageInfo,
+              draco: draco
+            });
+
+          case 19:
+            _context.t1 = _context.sent;
 
-    const vertexCount = attributes.positions.length / VALUES_PER_VERTEX;
+            _context.t0.push.call(_context.t0, _context.t1);
 
-    if (!attributes.colors.length) {
-      attributes.colors = new Uint8Array(vertexCount * VALUES_PER_COLOR_ELEMENT);
+            nodesCounter++;
 
-      for (let index = 0; index < attributes.colors.length; index += 4) {
-        attributes.colors.set([255, 255, 255, 255], index);
+          case 22:
+            i++;
+            _context.next = 10;
+            break;
+
+          case 25:
+            if (result.length) {
+              _context.next = 27;
+              break;
+            }
+
+            return _context.abrupt("return", null);
+
+          case 27:
+            return _context.abrupt("return", result);
+
+          case 28:
+          case "end":
+            return _context.stop();
+        }
       }
-    }
+    }, _callee);
+  }));
+  return _convertB3dmToI3sGeometry.apply(this, arguments);
+}
+
+function _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeightModel) {
+  var _iterator = _createForOfIteratorHelper(convertedAttributesMap.values()),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var attributes = _step.value;
+      var boundingVolumes = (0, _coordinateConverter.createBoundingVolumesFromGeometry)(attributes.positions, geoidHeightModel);
+      attributes.boundingVolumes = boundingVolumes;
+      var cartographicOrigin = boundingVolumes.obb.center;
+
+      for (var index = 0; index < attributes.positions.length; index += VALUES_PER_VERTEX) {
+        var vertex = attributes.positions.subarray(index, index + VALUES_PER_VERTEX);
 
-    if (!attributes.texCoords.length) {
-      attributes.texCoords = new Float32Array(vertexCount * VALUES_PER_TEX_COORD);
+        _geospatial.Ellipsoid.WGS84.cartesianToCartographic(Array.from(vertex), scratchVector);
 
-      for (let index = 0; index < attributes.texCoords.length; index += 2) {
-        attributes.texCoords.set([1, 1], index);
+        scratchVector[2] = scratchVector[2] - geoidHeightModel.getHeight(scratchVector[1], scratchVector[0]);
+        scratchVector = scratchVector.subtract(cartographicOrigin);
+        attributes.positions.set(scratchVector, index);
       }
     }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+
+function _makeNodeResources(_x8) {
+  return _makeNodeResources2.apply(this, arguments);
+}
+
+function _makeNodeResources2() {
+  _makeNodeResources2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(_ref) {
+    var convertedAttributes, material, texture, tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco, boundingVolumes, vertexCount, triangleCount, _generateAttributes, faceRange, featureIds, positions, normals, colors, texCoords, featureCount, header, typedFeatureIds, fileBuffer, compressedGeometry, attributes;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            convertedAttributes = _ref.convertedAttributes, material = _ref.material, texture = _ref.texture, tileContent = _ref.tileContent, nodeId = _ref.nodeId, featuresHashArray = _ref.featuresHashArray, attributeStorageInfo = _ref.attributeStorageInfo, draco = _ref.draco;
+            boundingVolumes = convertedAttributes.boundingVolumes;
+            vertexCount = convertedAttributes.positions.length / VALUES_PER_VERTEX;
+            triangleCount = vertexCount / 3;
+            _generateAttributes = (0, _geometryAttributes.generateAttributes)(_objectSpread({
+              triangleCount: triangleCount
+            }, convertedAttributes)), faceRange = _generateAttributes.faceRange, featureIds = _generateAttributes.featureIds, positions = _generateAttributes.positions, normals = _generateAttributes.normals, colors = _generateAttributes.colors, texCoords = _generateAttributes.texCoords, featureCount = _generateAttributes.featureCount;
+
+            if (tileContent.batchTableJson) {
+              makeFeatureIdsUnique(featureIds, convertedAttributes.featureIndices, featuresHashArray, tileContent.batchTableJson);
+            }
+
+            header = new Uint32Array(2);
+            typedFeatureIds = generateBigUint64Array(featureIds);
+            header.set([vertexCount, featureCount], 0);
+            fileBuffer = new Uint8Array((0, _loaderUtils.concatenateArrayBuffers)(header.buffer, positions.buffer, normals.buffer, texture ? texCoords.buffer : new ArrayBuffer(0), colors.buffer, typedFeatureIds.buffer, faceRange.buffer));
+
+            if (!draco) {
+              _context2.next = 16;
+              break;
+            }
+
+            _context2.next = 13;
+            return generateCompressedGeometry(vertexCount, convertedAttributes, {
+              positions: positions,
+              normals: normals,
+              texCoords: texture ? texCoords : new Float32Array(0),
+              colors: colors,
+              featureIds: featureIds,
+              faceRange: faceRange
+            });
+
+          case 13:
+            _context2.t0 = _context2.sent;
+            _context2.next = 17;
+            break;
+
+          case 16:
+            _context2.t0 = null;
+
+          case 17:
+            compressedGeometry = _context2.t0;
+            attributes = convertBatchTableToAttributeBuffers(tileContent.batchTableJson, featureIds, attributeStorageInfo);
+            return _context2.abrupt("return", {
+              geometry: fileBuffer,
+              compressedGeometry: compressedGeometry,
+              texture: texture,
+              sharedResources: getSharedResources(tileContent, nodeId),
+              meshMaterial: material,
+              vertexCount: vertexCount,
+              attributes: attributes,
+              featureCount: featureCount,
+              boundingVolumes: boundingVolumes
+            });
+
+          case 20:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _makeNodeResources2.apply(this, arguments);
+}
+
+function convertAttributes(tileContent, useCartesianPositions) {
+  var _tileContent$gltf$sce;
+
+  var attributesMap = new Map();
 
-    attributes.featureIndices = attributes.featureIndices.reduce((acc, value) => acc.concat(value));
+  var _iterator2 = _createForOfIteratorHelper(tileContent.gltf.materials || [{
+    id: 'default'
+  }]),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var material = _step2.value;
+      attributesMap.set(material.id, {
+        positions: new Float32Array(0),
+        normals: new Float32Array(0),
+        texCoords: new Float32Array(0),
+        colors: new Uint8Array(0),
+        featureIndices: [],
+        boundingVolumes: null
+      });
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  var nodes = (tileContent.gltf.scene || ((_tileContent$gltf$sce = tileContent.gltf.scenes) === null || _tileContent$gltf$sce === void 0 ? void 0 : _tileContent$gltf$sce[0]) || tileContent.gltf).nodes;
+  convertNodes(nodes, tileContent, attributesMap, useCartesianPositions);
+
+  var _iterator3 = _createForOfIteratorHelper(attributesMap.keys()),
+      _step3;
+
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var attrKey = _step3.value;
+      var attributes = attributesMap.get(attrKey);
+
+      if (attributes.positions.length === 0) {
+        attributesMap.delete(attrKey);
+        continue;
+      }
+
+      attributes.featureIndices = attributes.featureIndices.reduce(function (acc, value) {
+        return acc.concat(value);
+      });
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
   }
 
   return attributesMap;
 }
 
-function convertNodes(nodes, tileContent, attributesMap, matrix = new _core.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+function convertNodes(nodes, tileContent, attributesMap, useCartesianPositions) {
+  var matrix = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : new _core.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+
   if (nodes) {
-    for (const node of nodes) {
-      convertNode(node, tileContent, attributesMap, matrix);
+    var _iterator4 = _createForOfIteratorHelper(nodes),
+        _step4;
+
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var node = _step4.value;
+        convertNode(node, tileContent, attributesMap, useCartesianPositions, matrix);
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
     }
   }
 }
 
-function convertNode(node, tileContent, attributesMap, matrix = new _core.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
-  const nodeMatrix = node.matrix;
-  const compositeMatrix = nodeMatrix ? matrix.multiplyRight(nodeMatrix) : matrix;
-  const mesh = node.mesh;
+function convertNode(node, tileContent, attributesMap, useCartesianPositions) {
+  var matrix = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : new _core.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+  var nodeMatrix = node.matrix;
+  var compositeMatrix = nodeMatrix ? matrix.multiplyRight(nodeMatrix) : matrix;
+  var mesh = node.mesh;
 
   if (mesh) {
-    convertMesh(mesh, tileContent, attributesMap, compositeMatrix);
+    convertMesh(mesh, tileContent, attributesMap, useCartesianPositions, compositeMatrix);
   }
 
-  convertNodes(node.children, tileContent, attributesMap, compositeMatrix);
+  convertNodes(node.children, tileContent, attributesMap, useCartesianPositions, compositeMatrix);
 }
 
-function convertMesh(mesh, content, attributesMap, matrix = new _core.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
-  for (const primitive of mesh.primitives) {
-    let outputAttributes = null;
+function convertMesh(mesh, content, attributesMap) {
+  var useCartesianPositions = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var matrix = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : new _core.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
 
-    if (primitive.material) {
-      outputAttributes = attributesMap.get(primitive.material.id);
-    } else if (attributesMap.has('default')) {
-      outputAttributes = attributesMap.get('default');
-    }
+  var _iterator5 = _createForOfIteratorHelper(mesh.primitives),
+      _step5;
+
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var primitive = _step5.value;
+      var outputAttributes = null;
 
-    (0, _core2.assert)(outputAttributes !== null, 'Primitive - material mapping failed');
-    const attributes = primitive.attributes;
-    outputAttributes.positions = (0, _loaderUtils.concatenateTypedArrays)(outputAttributes.positions, transformVertexArray({
-      vertices: attributes.POSITION.value,
-      cartographicOrigin: content.cartographicOrigin,
-      cartesianModelMatrix: content.cartesianModelMatrix,
-      nodeMatrix: matrix,
-      indices: primitive.indices.value,
-      attributeSpecificTransformation: transformVertexPositions
-    }));
-    outputAttributes.normals = (0, _loaderUtils.concatenateTypedArrays)(outputAttributes.normals, transformVertexArray({
-      vertices: attributes.NORMAL && attributes.NORMAL.value,
-      cartographicOrigin: content.cartographicOrigin,
-      cartesianModelMatrix: content.cartesianModelMatrix,
-      nodeMatrix: matrix,
-      indices: primitive.indices.value,
-      attributeSpecificTransformation: transformVertexNormals
-    }));
-    outputAttributes.texCoords = (0, _loaderUtils.concatenateTypedArrays)(outputAttributes.texCoords, flattenTexCoords(attributes.TEXCOORD_0 && attributes.TEXCOORD_0.value, primitive.indices.value));
-    outputAttributes.colors = (0, _loaderUtils.concatenateTypedArrays)(outputAttributes.colors, flattenColors(attributes.COLOR_0, primitive.indices.value));
-    outputAttributes.featureIndices.push(flattenBatchIds(getBatchIdsByAttributeName(attributes), primitive.indices.value));
+      if (primitive.material) {
+        outputAttributes = attributesMap.get(primitive.material.id);
+      } else if (attributesMap.has('default')) {
+        outputAttributes = attributesMap.get('default');
+      }
+
+      (0, _core2.assert)(outputAttributes !== null, 'Primitive - material mapping failed');
+      var attributes = primitive.attributes;
+      outputAttributes.positions = (0, _loaderUtils.concatenateTypedArrays)(outputAttributes.positions, transformVertexArray({
+        vertices: attributes.POSITION.value,
+        cartographicOrigin: content.cartographicOrigin,
+        cartesianModelMatrix: content.cartesianModelMatrix,
+        nodeMatrix: matrix,
+        indices: primitive.indices.value,
+        attributeSpecificTransformation: transformVertexPositions,
+        useCartesianPositions: useCartesianPositions
+      }));
+      outputAttributes.normals = (0, _loaderUtils.concatenateTypedArrays)(outputAttributes.normals, transformVertexArray({
+        vertices: attributes.NORMAL && attributes.NORMAL.value,
+        cartographicOrigin: content.cartographicOrigin,
+        cartesianModelMatrix: content.cartesianModelMatrix,
+        nodeMatrix: matrix,
+        indices: primitive.indices.value,
+        attributeSpecificTransformation: transformVertexNormals,
+        useCartesianPositions: false
+      }));
+      outputAttributes.texCoords = (0, _loaderUtils.concatenateTypedArrays)(outputAttributes.texCoords, flattenTexCoords(attributes.TEXCOORD_0 && attributes.TEXCOORD_0.value, primitive.indices.value));
+      outputAttributes.colors = (0, _loaderUtils.concatenateTypedArrays)(outputAttributes.colors, flattenColors(attributes.COLOR_0, primitive.indices.value));
+      outputAttributes.featureIndices.push(flattenBatchIds(getBatchIdsByAttributeName(attributes), primitive.indices.value));
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
   }
 }
 
 function transformVertexArray(args) {
-  const {
-    vertices,
-    indices,
-    attributeSpecificTransformation
-  } = args;
-  const newVertices = new Float32Array(indices.length * VALUES_PER_VERTEX);
+  var vertices = args.vertices,
+      indices = args.indices,
+      attributeSpecificTransformation = args.attributeSpecificTransformation;
+  var newVertices = new Float32Array(indices.length * VALUES_PER_VERTEX);
 
   if (!vertices) {
     return newVertices;
   }
 
-  for (let i = 0; i < indices.length; i++) {
-    const coordIndex = indices[i] * VALUES_PER_VERTEX;
-    const vertex = vertices.subarray(coordIndex, coordIndex + VALUES_PER_VERTEX);
-    let vertexVector = new _core.Vector3(Array.from(vertex));
+  for (var i = 0; i < indices.length; i++) {
+    var coordIndex = indices[i] * VALUES_PER_VERTEX;
+    var vertex = vertices.subarray(coordIndex, coordIndex + VALUES_PER_VERTEX);
+    var vertexVector = new _core.Vector3(Array.from(vertex));
     vertexVector = attributeSpecificTransformation(vertexVector, args);
     newVertices[i * VALUES_PER_VERTEX] = vertexVector.x;
     newVertices[i * VALUES_PER_VERTEX + 1] = vertexVector.y;
@@ -270,11 +419,10 @@ function transformVertexArray(args) {
 }
 
 function transformVertexPositions(vertexVector, calleeArgs) {
-  const {
-    cartesianModelMatrix,
-    cartographicOrigin,
-    nodeMatrix
-  } = calleeArgs;
+  var cartesianModelMatrix = calleeArgs.cartesianModelMatrix,
+      cartographicOrigin = calleeArgs.cartographicOrigin,
+      nodeMatrix = calleeArgs.nodeMatrix,
+      useCartesianPositions = calleeArgs.useCartesianPositions;
 
   if (nodeMatrix) {
     vertexVector = vertexVector.transform(nodeMatrix);
@@ -282,6 +430,10 @@ function transformVertexPositions(vertexVector, calleeArgs) {
 
   vertexVector = vertexVector.transform(cartesianModelMatrix);
 
+  if (useCartesianPositions) {
+    return vertexVector;
+  }
+
   _geospatial.Ellipsoid.WGS84.cartesianToCartographic([vertexVector[0], vertexVector[1], vertexVector[2]], vertexVector);
 
   vertexVector = vertexVector.subtract(cartographicOrigin);
@@ -289,10 +441,8 @@ function transformVertexPositions(vertexVector, calleeArgs) {
 }
 
 function transformVertexNormals(vertexVector, calleeArgs) {
-  const {
-    cartesianModelMatrix,
-    nodeMatrix
-  } = calleeArgs;
+  var cartesianModelMatrix = calleeArgs.cartesianModelMatrix,
+      nodeMatrix = calleeArgs.nodeMatrix;
 
   if (nodeMatrix) {
     vertexVector = vertexVector.transformAsVector(nodeMatrix);
@@ -303,15 +453,16 @@ function transformVertexNormals(vertexVector, calleeArgs) {
 }
 
 function flattenTexCoords(texCoords, indices) {
-  const newTexCoords = new Float32Array(indices.length * VALUES_PER_TEX_COORD);
+  var newTexCoords = new Float32Array(indices.length * VALUES_PER_TEX_COORD);
 
   if (!texCoords) {
+    newTexCoords.fill(1);
     return newTexCoords;
   }
 
-  for (let i = 0; i < indices.length; i++) {
-    const coordIndex = indices[i] * VALUES_PER_TEX_COORD;
-    const texCoord = texCoords.subarray(coordIndex, coordIndex + VALUES_PER_TEX_COORD);
+  for (var i = 0; i < indices.length; i++) {
+    var coordIndex = indices[i] * VALUES_PER_TEX_COORD;
+    var texCoord = texCoords.subarray(coordIndex, coordIndex + VALUES_PER_TEX_COORD);
     newTexCoords[i * VALUES_PER_TEX_COORD] = texCoord[0];
     newTexCoords[i * VALUES_PER_TEX_COORD + 1] = texCoord[1];
   }
@@ -320,21 +471,22 @@ function flattenTexCoords(texCoords, indices) {
 }
 
 function flattenColors(colorsAttribute, indices) {
-  const components = (colorsAttribute === null || colorsAttribute === void 0 ? void 0 : colorsAttribute.components) || VALUES_PER_COLOR_ELEMENT;
-  const newColors = new Uint8Array(indices.length * components);
+  var components = (colorsAttribute === null || colorsAttribute === void 0 ? void 0 : colorsAttribute.components) || VALUES_PER_COLOR_ELEMENT;
+  var newColors = new Uint8Array(indices.length * components);
 
   if (!colorsAttribute) {
+    newColors.fill(255);
     return newColors;
   }
 
-  const colors = colorsAttribute.value;
+  var colors = colorsAttribute.value;
 
-  for (let i = 0; i < indices.length; i++) {
-    const colorIndex = indices[i] * components;
-    const color = colors.subarray(colorIndex, colorIndex + components);
-    const colorUint8 = new Uint8Array(components);
+  for (var i = 0; i < indices.length; i++) {
+    var colorIndex = indices[i] * components;
+    var color = colors.subarray(colorIndex, colorIndex + components);
+    var colorUint8 = new Uint8Array(components);
 
-    for (let j = 0; j < color.length; j++) {
+    for (var j = 0; j < color.length; j++) {
       colorUint8[j] = color[j] * 255;
     }
 
@@ -349,10 +501,10 @@ function flattenBatchIds(batchedIds, indices) {
     return [];
   }
 
-  const newBatchIds = [];
+  var newBatchIds = [];
 
-  for (let i = 0; i < indices.length; i++) {
-    const coordIndex = indices[i];
+  for (var i = 0; i < indices.length; i++) {
+    var coordIndex = indices[i];
     newBatchIds.push(batchedIds[coordIndex]);
   }
 
@@ -360,10 +512,10 @@ function flattenBatchIds(batchedIds, indices) {
 }
 
 function getBatchIdsByAttributeName(attributes) {
-  let batchIds = [];
+  var batchIds = [];
 
-  for (let index = 0; index < BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES.length; index++) {
-    const possibleBatchIdAttributeName = BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES[index];
+  for (var index = 0; index < BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES.length; index++) {
+    var possibleBatchIdAttributeName = BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES[index];
 
     if (attributes[possibleBatchIdAttributeName] && attributes[possibleBatchIdAttributeName].value) {
       batchIds = attributes[possibleBatchIdAttributeName].value;
@@ -375,27 +527,39 @@ function getBatchIdsByAttributeName(attributes) {
 }
 
 function convertMaterials(tileContent) {
-  const result = [];
-  const sourceMaterials = tileContent.gltf.materials || [];
+  var result = [];
+  var sourceMaterials = tileContent.gltf.materials || [];
+
+  var _iterator6 = _createForOfIteratorHelper(sourceMaterials),
+      _step6;
 
-  for (const sourceMaterial of sourceMaterials) {
-    result.push(convertMaterial(sourceMaterial));
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var sourceMaterial = _step6.value;
+      result.push(convertMaterial(sourceMaterial));
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
   }
 
   return result;
 }
 
 function convertMaterial(sourceMaterial) {
-  const material = {
+  var material = {
     doubleSided: sourceMaterial.doubleSided,
-    emissiveFactor: sourceMaterial.emissiveFactor.map(c => Math.round(c * 255)),
+    emissiveFactor: sourceMaterial.emissiveFactor.map(function (c) {
+      return Math.round(c * 255);
+    }),
     alphaMode: (sourceMaterial.alphaMode || 'OPAQUE').toLowerCase(),
     pbrMetallicRoughness: {
       roughnessFactor: sourceMaterial.pbrMetallicRoughness.roughnessFactor,
       metallicFactor: sourceMaterial.pbrMetallicRoughness.metallicFactor
     }
   };
-  let texture;
+  var texture;
 
   if (sourceMaterial.pbrMetallicRoughness.baseColorTexture) {
     texture = sourceMaterial.pbrMetallicRoughness.baseColorTexture.texture.source;
@@ -410,13 +574,15 @@ function convertMaterial(sourceMaterial) {
   }
 
   if (!texture) {
-    const baseColorFactor = sourceMaterial.pbrMetallicRoughness.baseColorFactor;
-    material.pbrMetallicRoughness.baseColorFactor = baseColorFactor && baseColorFactor.map(c => Math.round(c * 255)) || undefined;
+    var baseColorFactor = sourceMaterial.pbrMetallicRoughness.baseColorFactor;
+    material.pbrMetallicRoughness.baseColorFactor = baseColorFactor && baseColorFactor.map(function (c) {
+      return Math.round(c * 255);
+    }) || undefined;
   }
 
   return {
-    material,
-    texture
+    material: material,
+    texture: texture
   };
 }
 
@@ -428,8 +594,8 @@ function getDefaultMaterial() {
 }
 
 function getSharedResources(tileContent, nodeId) {
-  const gltfMaterials = tileContent.gltf.materials;
-  const i3sResources = {};
+  var gltfMaterials = tileContent.gltf.materials;
+  var i3sResources = {};
 
   if (!gltfMaterials || !gltfMaterials.length) {
     return i3sResources;
@@ -437,35 +603,45 @@ function getSharedResources(tileContent, nodeId) {
 
   i3sResources.materialDefinitionInfos = [];
 
-  for (const gltfMaterial of gltfMaterials) {
-    const {
-      materialDefinitionInfo,
-      textureDefinitionInfo
-    } = convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId);
-    i3sResources.materialDefinitionInfos.push(materialDefinitionInfo);
+  var _iterator7 = _createForOfIteratorHelper(gltfMaterials),
+      _step7;
+
+  try {
+    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+      var gltfMaterial = _step7.value;
+
+      var _convertGLTFMaterialT = convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId),
+          materialDefinitionInfo = _convertGLTFMaterialT.materialDefinitionInfo,
+          textureDefinitionInfo = _convertGLTFMaterialT.textureDefinitionInfo;
 
-    if (textureDefinitionInfo) {
-      i3sResources.textureDefinitionInfos = i3sResources.textureDefinitionInfos || [];
-      i3sResources.textureDefinitionInfos.push(textureDefinitionInfo);
+      i3sResources.materialDefinitionInfos.push(materialDefinitionInfo);
+
+      if (textureDefinitionInfo) {
+        i3sResources.textureDefinitionInfos = i3sResources.textureDefinitionInfos || [];
+        i3sResources.textureDefinitionInfos.push(textureDefinitionInfo);
+      }
     }
+  } catch (err) {
+    _iterator7.e(err);
+  } finally {
+    _iterator7.f();
   }
 
   return i3sResources;
 }
 
 function convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId) {
-  const texture = gltfMaterial.pbrMetallicRoughness.baseColorTexture || gltfMaterial.emissiveTexture;
-  let textureDefinitionInfo = null;
+  var texture = gltfMaterial.pbrMetallicRoughness.baseColorTexture || gltfMaterial.emissiveTexture;
+  var textureDefinitionInfo = null;
 
   if (texture) {
     textureDefinitionInfo = extractSharedResourcesTextureInfo(texture.texture, nodeId);
   }
 
-  const {
-    baseColorFactor,
-    metallicFactor
-  } = gltfMaterial.pbrMetallicRoughness;
-  let colorFactor = baseColorFactor;
+  var _gltfMaterial$pbrMeta = gltfMaterial.pbrMetallicRoughness,
+      baseColorFactor = _gltfMaterial$pbrMeta.baseColorFactor,
+      metallicFactor = _gltfMaterial$pbrMeta.metallicFactor;
+  var colorFactor = baseColorFactor;
 
   if ((!baseColorFactor || baseColorFactor[3] === 0) && gltfMaterial.emissiveFactor) {
     colorFactor = gltfMaterial.emissiveFactor;
@@ -474,20 +650,21 @@ function convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId) {
 
   return {
     materialDefinitionInfo: extractSharedResourcesMaterialInfo(colorFactor, metallicFactor),
-    textureDefinitionInfo
+    textureDefinitionInfo: textureDefinitionInfo
   };
 }
 
-function extractSharedResourcesMaterialInfo(baseColorFactor, metallicFactor = 0) {
-  const matDielectricColorComponent = 0.04 / 255;
-  const black = new _core.Vector4(0, 0, 0, 1);
-  const unitVector = new _core.Vector4(1, 1, 1, 1);
-  const dielectricSpecular = new _core.Vector4(matDielectricColorComponent, matDielectricColorComponent, matDielectricColorComponent, 0);
-  const baseColorVector = new _core.Vector4(baseColorFactor);
-  const firstOperand = unitVector.subtract(dielectricSpecular).multiply(baseColorVector);
-  const diffuse = firstOperand.lerp(firstOperand, black, metallicFactor);
+function extractSharedResourcesMaterialInfo(baseColorFactor) {
+  var metallicFactor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var matDielectricColorComponent = 0.04 / 255;
+  var black = new _core.Vector4(0, 0, 0, 1);
+  var unitVector = new _core.Vector4(1, 1, 1, 1);
+  var dielectricSpecular = new _core.Vector4(matDielectricColorComponent, matDielectricColorComponent, matDielectricColorComponent, 0);
+  var baseColorVector = new _core.Vector4(baseColorFactor);
+  var firstOperand = unitVector.subtract(dielectricSpecular).multiply(baseColorVector);
+  var diffuse = firstOperand.lerp(firstOperand, black, metallicFactor);
   dielectricSpecular[3] = 1;
-  const specular = dielectricSpecular.lerp(dielectricSpecular, baseColorVector, metallicFactor);
+  var specular = dielectricSpecular.lerp(dielectricSpecular, baseColorVector, metallicFactor);
   return {
     diffuse: diffuse.toArray(),
     specular: specular.toArray()
@@ -506,36 +683,35 @@ function extractSharedResourcesTextureInfo(texture, nodeId) {
 }
 
 function generateImageId(texture, nodeId) {
-  const {
-    width,
-    height
-  } = texture.source.image;
-  const levelCountOfTexture = 1;
-  const indexOfLevel = 0;
-  const indexOfTextureInStore = nodeId + 1;
-  const zerosCount = 32 - indexOfTextureInStore.toString(2).length;
-  const rightHalf = '0'.repeat(zerosCount).concat(indexOfTextureInStore.toString(2));
-  const shiftedLevelCountOfTexture = levelCountOfTexture << 28;
-  const shiftedIndexOfLevel = indexOfLevel << 24;
-  const shiftedWidth = width - 1 << 12;
-  const shiftedHeight = height - 1 << 0;
-  const leftHalf = shiftedLevelCountOfTexture + shiftedIndexOfLevel + shiftedWidth + shiftedHeight;
-  const imageId = BigInt("0b".concat(leftHalf.toString(2)).concat(rightHalf));
+  var _texture$source$image = texture.source.image,
+      width = _texture$source$image.width,
+      height = _texture$source$image.height;
+  var levelCountOfTexture = 1;
+  var indexOfLevel = 0;
+  var indexOfTextureInStore = nodeId + 1;
+  var zerosCount = 32 - indexOfTextureInStore.toString(2).length;
+  var rightHalf = '0'.repeat(zerosCount).concat(indexOfTextureInStore.toString(2));
+  var shiftedLevelCountOfTexture = levelCountOfTexture << 28;
+  var shiftedIndexOfLevel = indexOfLevel << 24;
+  var shiftedWidth = width - 1 << 12;
+  var shiftedHeight = height - 1 << 0;
+  var leftHalf = shiftedLevelCountOfTexture + shiftedIndexOfLevel + shiftedWidth + shiftedHeight;
+  var imageId = BigInt("0b".concat(leftHalf.toString(2)).concat(rightHalf));
   return imageId.toString();
 }
 
 function makeFeatureIdsUnique(featureIds, featureIndices, featuresHashArray, batchTable) {
-  const replaceMap = getFeaturesReplaceMap(featureIds, batchTable, featuresHashArray);
+  var replaceMap = getFeaturesReplaceMap(featureIds, batchTable, featuresHashArray);
   replaceIndicesByUnique(featureIndices, replaceMap);
   replaceIndicesByUnique(featureIds, replaceMap);
 }
 
 function getFeaturesReplaceMap(featureIds, batchTable, featuresHashArray) {
-  const featureMap = {};
+  var featureMap = {};
 
-  for (let index = 0; index < featureIds.length; index++) {
-    const oldFeatureId = featureIds[index];
-    const uniqueFeatureId = getOrCreateUniqueFeatureId(index, batchTable, featuresHashArray);
+  for (var index = 0; index < featureIds.length; index++) {
+    var oldFeatureId = featureIds[index];
+    var uniqueFeatureId = getOrCreateUniqueFeatureId(index, batchTable, featuresHashArray);
     featureMap[oldFeatureId.toString()] = uniqueFeatureId;
   }
 
@@ -543,9 +719,9 @@ function getFeaturesReplaceMap(featureIds, batchTable, featuresHashArray) {
 }
 
 function generateStringFromBatchTableByIndex(batchTable, index) {
-  let str = '';
+  var str = '';
 
-  for (const key in batchTable) {
+  for (var key in batchTable) {
     str += batchTable[key][index];
   }
 
@@ -553,8 +729,8 @@ function generateStringFromBatchTableByIndex(batchTable, index) {
 }
 
 function getOrCreateUniqueFeatureId(index, batchTable, featuresHashArray) {
-  const batchTableStr = generateStringFromBatchTableByIndex(batchTable, index);
-  const hash = (0, _md.default)(batchTableStr);
+  var batchTableStr = generateStringFromBatchTableByIndex(batchTable, index);
+  var hash = (0, _md.default)(batchTableStr);
 
   if (featuresHashArray.includes(hash)) {
     return featuresHashArray.indexOf(hash);
@@ -564,23 +740,22 @@ function getOrCreateUniqueFeatureId(index, batchTable, featuresHashArray) {
 }
 
 function replaceIndicesByUnique(indicesArray, featureMap) {
-  for (let index = 0; index < indicesArray.length; index++) {
+  for (var index = 0; index < indicesArray.length; index++) {
     indicesArray[index] = featureMap[indicesArray[index]];
   }
 }
 
 function convertBatchTableToAttributeBuffers(batchTable, featureIds, attributeStorageInfo) {
-  const attributeBuffers = [];
+  var attributeBuffers = [];
 
   if (batchTable) {
-    const batchTableWithFeatureIds = {
-      OBJECTID: featureIds,
-      ...batchTable
-    };
+    var batchTableWithFeatureIds = _objectSpread({
+      OBJECTID: featureIds
+    }, batchTable);
 
-    for (const key in batchTableWithFeatureIds) {
-      const type = getAttributeType(key, attributeStorageInfo);
-      let attributeBuffer = null;
+    for (var key in batchTableWithFeatureIds) {
+      var type = getAttributeType(key, attributeStorageInfo);
+      var attributeBuffer = null;
 
       switch (type) {
         case OBJECT_ID_TYPE:
@@ -608,104 +783,124 @@ function convertBatchTableToAttributeBuffers(batchTable, featureIds, attributeSt
 }
 
 function getAttributeType(key, attributeStorageInfo) {
-  const attribute = attributeStorageInfo.find(attr => attr.name === key);
+  var attribute = attributeStorageInfo.find(function (attr) {
+    return attr.name === key;
+  });
   return attribute.attributeValues.valueType;
 }
 
 function generateShortIntegerAttributeBuffer(featureIds) {
-  const count = new Uint32Array([featureIds.length]);
-  const valuesArray = new Uint32Array(featureIds);
+  var count = new Uint32Array([featureIds.length]);
+  var valuesArray = new Uint32Array(featureIds);
   return (0, _loaderUtils.concatenateArrayBuffers)(count.buffer, valuesArray.buffer);
 }
 
 function generateDoubleAttributeBuffer(featureIds) {
-  const count = new Uint32Array([featureIds.length]);
-  const padding = new Uint8Array(4);
-  const valuesArray = new Float64Array(featureIds);
+  var count = new Uint32Array([featureIds.length]);
+  var padding = new Uint8Array(4);
+  var valuesArray = new Float64Array(featureIds);
   return (0, _loaderUtils.concatenateArrayBuffers)(count.buffer, padding.buffer, valuesArray.buffer);
 }
 
 function generateStringAttributeBuffer(batchAttributes) {
-  const stringCountArray = new Uint32Array([batchAttributes.length]);
-  let totalNumberOfBytes = 0;
-  const stringSizesArray = new Uint32Array(batchAttributes.length);
-  const stringBufferArray = [];
-
-  for (let index = 0; index < batchAttributes.length; index++) {
-    const currentString = "".concat(String(batchAttributes[index]), "\0");
-    const currentStringBuffer = Buffer.from(currentString);
-    const currentStringSize = currentStringBuffer.length;
+  var stringCountArray = new Uint32Array([batchAttributes.length]);
+  var totalNumberOfBytes = 0;
+  var stringSizesArray = new Uint32Array(batchAttributes.length);
+  var stringBufferArray = [];
+
+  for (var index = 0; index < batchAttributes.length; index++) {
+    var currentString = "".concat(String(batchAttributes[index]), "\0");
+    var currentStringBuffer = Buffer.from(currentString);
+    var currentStringSize = currentStringBuffer.length;
     totalNumberOfBytes += currentStringSize;
     stringSizesArray[index] = currentStringSize;
     stringBufferArray.push(currentStringBuffer);
   }
 
-  const totalBytes = new Uint32Array([totalNumberOfBytes]);
-  return (0, _loaderUtils.concatenateArrayBuffers)(stringCountArray.buffer, totalBytes.buffer, stringSizesArray.buffer, ...stringBufferArray);
+  var totalBytes = new Uint32Array([totalNumberOfBytes]);
+  return _loaderUtils.concatenateArrayBuffers.apply(void 0, [stringCountArray.buffer, totalBytes.buffer, stringSizesArray.buffer].concat(stringBufferArray));
 }
 
 function generateBigUint64Array(featureIds) {
-  const typedFeatureIds = new BigUint64Array(featureIds.length);
+  var typedFeatureIds = new BigUint64Array(featureIds.length);
 
-  for (let index = 0; index < featureIds.length; index++) {
+  for (var index = 0; index < featureIds.length; index++) {
     typedFeatureIds[index] = BigInt(featureIds[index]);
   }
 
   return typedFeatureIds;
 }
 
-async function generateCompressedGeometry(vertexCount, convertedAttributes, attributes) {
-  const {
-    positions,
-    normals,
-    texCoords,
-    colors,
-    featureIds,
-    faceRange
-  } = attributes;
-  const indices = new Uint32Array(vertexCount);
-
-  for (let index = 0; index < indices.length; index++) {
-    indices.set([index], index);
-  }
-
-  const featureIndices = new Uint32Array(convertedAttributes.featureIndices.length ? convertedAttributes.featureIndices : vertexCount);
-  const featureIndex = generateFeatureIndexAttribute(featureIndices, faceRange);
-  const compressedAttributes = {
-    positions,
-    normals,
-    colors,
-    'feature-index': featureIndex
-  };
-
-  if (texCoords.length) {
-    compressedAttributes.texCoords = texCoords;
-  }
-
-  const attributesMetadata = {
-    'feature-index': {
-      'i3s-attribute-type': 'feature-index',
-      'i3s-feature-ids': new Int32Array(featureIds)
-    }
-  };
-  return new Uint8Array(await (0, _core2.encode)({
-    attributes: compressedAttributes,
-    indices
-  }, _draco.DracoWriter, {
-    draco: {
-      method: 'MESH_SEQUENTIAL_ENCODING',
-      attributesMetadata
-    }
+function generateCompressedGeometry(_x9, _x10, _x11) {
+  return _generateCompressedGeometry.apply(this, arguments);
+}
+
+function _generateCompressedGeometry() {
+  _generateCompressedGeometry = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(vertexCount, convertedAttributes, attributes) {
+    var positions, normals, texCoords, colors, featureIds, faceRange, indices, index, featureIndices, featureIndex, compressedAttributes, attributesMetadata;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            positions = attributes.positions, normals = attributes.normals, texCoords = attributes.texCoords, colors = attributes.colors, featureIds = attributes.featureIds, faceRange = attributes.faceRange;
+            indices = new Uint32Array(vertexCount);
+
+            for (index = 0; index < indices.length; index++) {
+              indices.set([index], index);
+            }
+
+            featureIndices = new Uint32Array(convertedAttributes.featureIndices.length ? convertedAttributes.featureIndices : vertexCount);
+            featureIndex = generateFeatureIndexAttribute(featureIndices, faceRange);
+            compressedAttributes = {
+              positions: positions,
+              normals: normals,
+              colors: colors,
+              'feature-index': featureIndex
+            };
+
+            if (texCoords.length) {
+              compressedAttributes.texCoords = texCoords;
+            }
+
+            attributesMetadata = {
+              'feature-index': {
+                'i3s-attribute-type': 'feature-index',
+                'i3s-feature-ids': new Int32Array(featureIds)
+              }
+            };
+            _context3.t0 = Uint8Array;
+            _context3.next = 11;
+            return (0, _core2.encode)({
+              attributes: compressedAttributes,
+              indices: indices
+            }, _draco.DracoWriter, {
+              draco: {
+                method: 'MESH_SEQUENTIAL_ENCODING',
+                attributesMetadata: attributesMetadata
+              }
+            });
+
+          case 11:
+            _context3.t1 = _context3.sent;
+            return _context3.abrupt("return", new _context3.t0(_context3.t1));
+
+          case 13:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
   }));
+  return _generateCompressedGeometry.apply(this, arguments);
 }
 
 function generateFeatureIndexAttribute(featureIndex, faceRange) {
-  const orderedFeatureIndices = new Uint32Array(featureIndex.length);
-  let fillIndex = 0;
-  let startIndex = 0;
+  var orderedFeatureIndices = new Uint32Array(featureIndex.length);
+  var fillIndex = 0;
+  var startIndex = 0;
 
-  for (let index = 1; index < faceRange.length; index += 2) {
-    const endIndex = (faceRange[index] + 1) * VALUES_PER_VERTEX;
+  for (var index = 1; index < faceRange.length; index += 2) {
+    var endIndex = (faceRange[index] + 1) * VALUES_PER_VERTEX;
     orderedFeatureIndices.fill(fillIndex, startIndex, endIndex);
     fillIndex++;
     startIndex = endIndex + 1;