@loaders.gl/tile-converter 3.2.0-alpha.1 → 3.2.0-alpha.2

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = convertB3dmToI3sGeometry;
+exports.convertAttributes = convertAttributes;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
@@ -29,6 +30,8 @@ var _geometryAttributes = require("./geometry-attributes");
 
 var _coordinateConverter = require("./coordinate-converter");
 
+var _gltfAttributes = require("./gltf-attributes");
+
 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; }
@@ -51,21 +54,28 @@ var OBJECT_ID_TYPE = 'Oid32';
 var BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES = ['CUSTOM_ATTRIBUTE_2', '_BATCHID', 'BATCHID'];
 var scratchVector = new _core.Vector3();
 
-function convertB3dmToI3sGeometry(_x, _x2, _x3, _x4, _x5, _x6, _x7) {
+function convertB3dmToI3sGeometry(_x, _x2, _x3, _x4, _x5, _x6, _x7, _x8) {
   return _convertB3dmToI3sGeometry.apply(this, arguments);
 }
 
 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;
+  _convertB3dmToI3sGeometry = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, geoidHeightModel, workerSource) {
+    var _tileContent$gltf;
+
+    var useCartesianPositions, materialAndTextureList, dataForAttributesConversion, convertedAttributesMap, result, nodesCounter, _ref3, _ref3$materials, materials, i, sourceMaterial, convertedAttributes, _materialAndTextureLi, material, texture;
 
     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);
+            materialAndTextureList = convertMaterials((_tileContent$gltf = tileContent.gltf) === null || _tileContent$gltf === void 0 ? void 0 : _tileContent$gltf.materials);
+            dataForAttributesConversion = (0, _gltfAttributes.prepareDataForAttributesConversion)(tileContent);
+            _context.next = 5;
+            return convertAttributes(dataForAttributesConversion, useCartesianPositions);
+
+          case 5:
+            convertedAttributesMap = _context.sent;
 
             if (generateBoundingVolumes) {
               _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeightModel);
@@ -79,7 +89,9 @@ function _convertB3dmToI3sGeometry() {
 
             result = [];
             nodesCounter = nodeId;
-            _tileContent$gltf$mat = tileContent.gltf.materials, materials = _tileContent$gltf$mat === void 0 ? [] : _tileContent$gltf$mat;
+            _ref3 = tileContent.gltf || {
+              materials: []
+            }, _ref3$materials = _ref3.materials, materials = _ref3$materials === void 0 ? [] : _ref3$materials;
 
             if (!(materials !== null && materials !== void 0 && materials.length)) {
               materials.push({
@@ -89,26 +101,35 @@ function _convertB3dmToI3sGeometry() {
 
             i = 0;
 
-          case 10:
+          case 13:
             if (!(i < materials.length)) {
-              _context.next = 25;
+              _context.next = 30;
               break;
             }
 
             sourceMaterial = materials[i];
 
             if (convertedAttributesMap.has(sourceMaterial.id)) {
-              _context.next = 14;
+              _context.next = 17;
               break;
             }
 
-            return _context.abrupt("continue", 22);
+            return _context.abrupt("continue", 27);
 
-          case 14:
+          case 17:
             convertedAttributes = convertedAttributesMap.get(sourceMaterial.id);
+
+            if (convertedAttributes) {
+              _context.next = 20;
+              break;
+            }
+
+            return _context.abrupt("continue", 27);
+
+          case 20:
             _materialAndTextureLi = materialAndTextureList[i], material = _materialAndTextureLi.material, texture = _materialAndTextureLi.texture;
             _context.t0 = result;
-            _context.next = 19;
+            _context.next = 24;
             return _makeNodeResources({
               convertedAttributes: convertedAttributes,
               material: material,
@@ -117,33 +138,34 @@ function _convertB3dmToI3sGeometry() {
               nodeId: nodesCounter,
               featuresHashArray: featuresHashArray,
               attributeStorageInfo: attributeStorageInfo,
-              draco: draco
+              draco: draco,
+              workerSource: workerSource
             });
 
-          case 19:
+          case 24:
             _context.t1 = _context.sent;
 
             _context.t0.push.call(_context.t0, _context.t1);
 
             nodesCounter++;
 
-          case 22:
+          case 27:
             i++;
-            _context.next = 10;
+            _context.next = 13;
             break;
 
-          case 25:
+          case 30:
             if (result.length) {
-              _context.next = 27;
+              _context.next = 32;
               break;
             }
 
             return _context.abrupt("return", null);
 
-          case 27:
+          case 32:
             return _context.abrupt("return", result);
 
-          case 28:
+          case 33:
           case "end":
             return _context.stop();
         }
@@ -181,25 +203,24 @@ function _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeigh
   }
 }
 
-function _makeNodeResources(_x8) {
+function _makeNodeResources(_x9) {
   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;
+    var _tileContent$gltf2;
+
+    var convertedAttributes, material, texture, tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco, workerSource, boundingVolumes, vertexCount, _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;
+            convertedAttributes = _ref.convertedAttributes, material = _ref.material, texture = _ref.texture, tileContent = _ref.tileContent, nodeId = _ref.nodeId, featuresHashArray = _ref.featuresHashArray, attributeStorageInfo = _ref.attributeStorageInfo, draco = _ref.draco, workerSource = _ref.workerSource;
             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;
+            _generateAttributes = (0, _geometryAttributes.generateAttributes)(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);
@@ -209,38 +230,20 @@ function _makeNodeResources2() {
             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, {
+            compressedGeometry = draco ? 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;
+            }, workerSource.draco) : null;
             attributes = convertBatchTableToAttributeBuffers(tileContent.batchTableJson, featureIds, attributeStorageInfo);
             return _context2.abrupt("return", {
               geometry: fileBuffer,
               compressedGeometry: compressedGeometry,
               texture: texture,
-              sharedResources: getSharedResources(tileContent, nodeId),
+              sharedResources: getSharedResources(((_tileContent$gltf2 = tileContent.gltf) === null || _tileContent$gltf2 === void 0 ? void 0 : _tileContent$gltf2.materials) || [], nodeId),
               meshMaterial: material,
               vertexCount: vertexCount,
               attributes: attributes,
@@ -248,7 +251,7 @@ function _makeNodeResources2() {
               boundingVolumes: boundingVolumes
             });
 
-          case 20:
+          case 12:
           case "end":
             return _context2.stop();
         }
@@ -258,79 +261,132 @@ function _makeNodeResources2() {
   return _makeNodeResources2.apply(this, arguments);
 }
 
-function convertAttributes(tileContent, useCartesianPositions) {
-  var _tileContent$gltf$sce;
+function convertAttributes(_x10, _x11) {
+  return _convertAttributes.apply(this, arguments);
+}
+
+function _convertAttributes() {
+  _convertAttributes = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(attributesData, useCartesianPositions) {
+    var gltfMaterials, nodes, cartographicOrigin, cartesianModelMatrix, attributesMap, _iterator6, _step6, material, _iterator7, _step7, attrKey, attributes;
 
-  var attributesMap = new Map();
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            gltfMaterials = attributesData.gltfMaterials, nodes = attributesData.nodes, cartographicOrigin = attributesData.cartographicOrigin, cartesianModelMatrix = attributesData.cartesianModelMatrix;
+            attributesMap = new Map();
+            _iterator6 = _createForOfIteratorHelper(gltfMaterials || [{
+              id: 'default'
+            }]);
+
+            try {
+              for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+                material = _step6.value;
+                attributesMap.set(material.id, {
+                  positions: new Float32Array(0),
+                  normals: new Float32Array(0),
+                  texCoords: new Float32Array(0),
+                  colors: new Uint8Array(0),
+                  featureIndicesGroups: [],
+                  featureIndices: [],
+                  boundingVolumes: null
+                });
+              }
+            } catch (err) {
+              _iterator6.e(err);
+            } finally {
+              _iterator6.f();
+            }
 
-  var _iterator2 = _createForOfIteratorHelper(tileContent.gltf.materials || [{
-    id: 'default'
-  }]),
-      _step2;
+            convertNodes(nodes, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions);
+            _iterator7 = _createForOfIteratorHelper(attributesMap.keys());
+            _context3.prev = 6;
 
-  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();
-  }
+            _iterator7.s();
 
-  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);
+          case 8:
+            if ((_step7 = _iterator7.n()).done) {
+              _context3.next = 19;
+              break;
+            }
 
-  var _iterator3 = _createForOfIteratorHelper(attributesMap.keys()),
-      _step3;
+            attrKey = _step7.value;
+            attributes = attributesMap.get(attrKey);
 
-  try {
-    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-      var attrKey = _step3.value;
-      var attributes = attributesMap.get(attrKey);
+            if (attributes) {
+              _context3.next = 13;
+              break;
+            }
 
-      if (attributes.positions.length === 0) {
-        attributesMap.delete(attrKey);
-        continue;
-      }
+            return _context3.abrupt("continue", 17);
 
-      attributes.featureIndices = attributes.featureIndices.reduce(function (acc, value) {
-        return acc.concat(value);
-      });
-    }
-  } catch (err) {
-    _iterator3.e(err);
-  } finally {
-    _iterator3.f();
-  }
+          case 13:
+            if (!(attributes.positions.length === 0)) {
+              _context3.next = 16;
+              break;
+            }
 
-  return attributesMap;
+            attributesMap.delete(attrKey);
+            return _context3.abrupt("continue", 17);
+
+          case 16:
+            if (attributes.featureIndicesGroups) {
+              attributes.featureIndices = attributes.featureIndicesGroups.reduce(function (acc, value) {
+                return acc.concat(value);
+              });
+              delete attributes.featureIndicesGroups;
+            }
+
+          case 17:
+            _context3.next = 8;
+            break;
+
+          case 19:
+            _context3.next = 24;
+            break;
+
+          case 21:
+            _context3.prev = 21;
+            _context3.t0 = _context3["catch"](6);
+
+            _iterator7.e(_context3.t0);
+
+          case 24:
+            _context3.prev = 24;
+
+            _iterator7.f();
+
+            return _context3.finish(24);
+
+          case 27:
+            return _context3.abrupt("return", attributesMap);
+
+          case 28:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[6, 21, 24, 27]]);
+  }));
+  return _convertAttributes.apply(this, arguments);
 }
 
-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]);
+function convertNodes(nodes, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions) {
+  var matrix = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : new _core.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
 
   if (nodes) {
-    var _iterator4 = _createForOfIteratorHelper(nodes),
-        _step4;
+    var _iterator2 = _createForOfIteratorHelper(nodes),
+        _step2;
 
     try {
-      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-        var node = _step4.value;
-        convertNode(node, tileContent, attributesMap, useCartesianPositions, matrix);
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var node = _step2.value;
+        convertNode(node, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix);
       }
     } catch (err) {
-      _iterator4.e(err);
+      _iterator2.e(err);
     } finally {
-      _iterator4.f();
+      _iterator2.f();
     }
   }
 }
@@ -361,28 +417,30 @@ function getCompositeTransformationMatrix(node, matrix) {
   return transformationMatrix;
 }
 
-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]);
+function convertNode(node, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions) {
+  var matrix = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : new _core.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
   var transformationMatrix = getCompositeTransformationMatrix(node, matrix);
   var mesh = node.mesh;
 
   if (mesh) {
-    convertMesh(mesh, tileContent, attributesMap, useCartesianPositions, transformationMatrix);
+    convertMesh(mesh, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, transformationMatrix);
   }
 
-  convertNodes(node.children, tileContent, attributesMap, useCartesianPositions, transformationMatrix);
+  convertNodes(node.children || [], cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, transformationMatrix);
 }
 
-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]);
+function convertMesh(mesh, cartographicOrigin, cartesianModelMatrix, attributesMap) {
+  var useCartesianPositions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var matrix = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : new _core.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
 
-  var _iterator5 = _createForOfIteratorHelper(mesh.primitives),
-      _step5;
+  var _iterator3 = _createForOfIteratorHelper(mesh.primitives),
+      _step3;
 
   try {
-    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-      var primitive = _step5.value;
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _primitive$indices, _primitive$indices2, _primitive$indices3, _primitive$indices4, _primitive$indices5;
+
+      var primitive = _step3.value;
       var outputAttributes = null;
 
       if (primitive.material) {
@@ -393,32 +451,38 @@ function convertMesh(mesh, content, attributesMap) {
 
       (0, _core2.assert)(outputAttributes !== null, 'Primitive - material mapping failed');
       var attributes = primitive.attributes;
+
+      if (!outputAttributes) {
+        continue;
+      }
+
       outputAttributes.positions = (0, _loaderUtils.concatenateTypedArrays)(outputAttributes.positions, transformVertexArray({
         vertices: attributes.POSITION.value,
-        cartographicOrigin: content.cartographicOrigin,
-        cartesianModelMatrix: content.cartesianModelMatrix,
+        cartographicOrigin: cartographicOrigin,
+        cartesianModelMatrix: cartesianModelMatrix,
         nodeMatrix: matrix,
-        indices: primitive.indices.value,
+        indices: (_primitive$indices = primitive.indices) === null || _primitive$indices === void 0 ? void 0 : _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,
+        cartographicOrigin: cartographicOrigin,
+        cartesianModelMatrix: cartesianModelMatrix,
         nodeMatrix: matrix,
-        indices: primitive.indices.value,
+        indices: (_primitive$indices2 = primitive.indices) === null || _primitive$indices2 === void 0 ? void 0 : _primitive$indices2.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));
+      outputAttributes.texCoords = (0, _loaderUtils.concatenateTypedArrays)(outputAttributes.texCoords, flattenTexCoords(attributes.TEXCOORD_0 && attributes.TEXCOORD_0.value, (_primitive$indices3 = primitive.indices) === null || _primitive$indices3 === void 0 ? void 0 : _primitive$indices3.value));
+      outputAttributes.colors = (0, _loaderUtils.concatenateTypedArrays)(outputAttributes.colors, flattenColors(attributes.COLOR_0, (_primitive$indices4 = primitive.indices) === null || _primitive$indices4 === void 0 ? void 0 : _primitive$indices4.value));
+      outputAttributes.featureIndicesGroups = outputAttributes.featureIndicesGroups || [];
+      outputAttributes.featureIndicesGroups.push(flattenBatchIds(getBatchIdsByAttributeName(attributes), (_primitive$indices5 = primitive.indices) === null || _primitive$indices5 === void 0 ? void 0 : _primitive$indices5.value));
     }
   } catch (err) {
-    _iterator5.e(err);
+    _iterator3.e(err);
   } finally {
-    _iterator5.f();
+    _iterator3.f();
   }
 }
 
@@ -553,36 +617,36 @@ function getBatchIdsByAttributeName(attributes) {
   return batchIds;
 }
 
-function convertMaterials(tileContent) {
+function convertMaterials() {
+  var sourceMaterials = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   var result = [];
-  var sourceMaterials = tileContent.gltf.materials || [];
 
-  var _iterator6 = _createForOfIteratorHelper(sourceMaterials),
-      _step6;
+  var _iterator4 = _createForOfIteratorHelper(sourceMaterials),
+      _step4;
 
   try {
-    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-      var sourceMaterial = _step6.value;
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var sourceMaterial = _step4.value;
       result.push(convertMaterial(sourceMaterial));
     }
   } catch (err) {
-    _iterator6.e(err);
+    _iterator4.e(err);
   } finally {
-    _iterator6.f();
+    _iterator4.f();
   }
 
   return result;
 }
 
 function convertMaterial(sourceMaterial) {
-  var _sourceMaterial$pbrMe, _sourceMaterial$pbrMe2, _sourceMaterial$pbrMe3;
+  var _sourceMaterial$emiss, _sourceMaterial$pbrMe, _sourceMaterial$pbrMe2, _sourceMaterial$pbrMe3;
 
   var material = {
     doubleSided: sourceMaterial.doubleSided,
-    emissiveFactor: sourceMaterial.emissiveFactor.map(function (c) {
+    emissiveFactor: (_sourceMaterial$emiss = sourceMaterial.emissiveFactor) === null || _sourceMaterial$emiss === void 0 ? void 0 : _sourceMaterial$emiss.map(function (c) {
       return Math.round(c * 255);
     }),
-    alphaMode: (sourceMaterial.alphaMode || 'OPAQUE').toLowerCase(),
+    alphaMode: convertAlphaMode(sourceMaterial.alphaMode),
     pbrMetallicRoughness: {
       roughnessFactor: (sourceMaterial === null || sourceMaterial === void 0 ? void 0 : (_sourceMaterial$pbrMe = sourceMaterial.pbrMetallicRoughness) === null || _sourceMaterial$pbrMe === void 0 ? void 0 : _sourceMaterial$pbrMe.roughnessFactor) || DEFAULT_ROUGHNESS_FACTOR,
       metallicFactor: (sourceMaterial === null || sourceMaterial === void 0 ? void 0 : (_sourceMaterial$pbrMe2 = sourceMaterial.pbrMetallicRoughness) === null || _sourceMaterial$pbrMe2 === void 0 ? void 0 : _sourceMaterial$pbrMe2.metallicFactor) || DEFAULT_METALLIC_FACTOR
@@ -617,15 +681,33 @@ function convertMaterial(sourceMaterial) {
   };
 }
 
+function convertAlphaMode(gltfAlphaMode) {
+  switch (gltfAlphaMode) {
+    case 'OPAQUE':
+      return 'opaque';
+
+    case 'MASK':
+      return 'mask';
+
+    case 'BLEND':
+      return 'blend';
+
+    default:
+      return 'opaque';
+  }
+}
+
 function getDefaultMaterial() {
   return {
     alphaMode: 'opaque',
-    pbrMetallicRoughness: {}
+    pbrMetallicRoughness: {
+      metallicFactor: 1,
+      roughnessFactor: 1
+    }
   };
 }
 
-function getSharedResources(tileContent, nodeId) {
-  var gltfMaterials = tileContent.gltf.materials;
+function getSharedResources(gltfMaterials, nodeId) {
   var i3sResources = {};
 
   if (!gltfMaterials || !gltfMaterials.length) {
@@ -634,12 +716,12 @@ function getSharedResources(tileContent, nodeId) {
 
   i3sResources.materialDefinitionInfos = [];
 
-  var _iterator7 = _createForOfIteratorHelper(gltfMaterials),
-      _step7;
+  var _iterator5 = _createForOfIteratorHelper(gltfMaterials),
+      _step5;
 
   try {
-    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-      var gltfMaterial = _step7.value;
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var gltfMaterial = _step5.value;
 
       var _convertGLTFMaterialT = convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId),
           materialDefinitionInfo = _convertGLTFMaterialT.materialDefinitionInfo,
@@ -653,9 +735,9 @@ function getSharedResources(tileContent, nodeId) {
       }
     }
   } catch (err) {
-    _iterator7.e(err);
+    _iterator5.e(err);
   } finally {
-    _iterator7.f();
+    _iterator5.f();
   }
 
   return i3sResources;
@@ -683,7 +765,7 @@ function convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId) {
   }
 
   return {
-    materialDefinitionInfo: extractSharedResourcesMaterialInfo(colorFactor, metallicFactor),
+    materialDefinitionInfo: extractSharedResourcesMaterialInfo(colorFactor || [1, 1, 1, 1], metallicFactor),
     textureDefinitionInfo: textureDefinitionInfo
   };
 }
@@ -700,26 +782,34 @@ function extractSharedResourcesMaterialInfo(baseColorFactor) {
   dielectricSpecular[3] = 1;
   var specular = dielectricSpecular.lerp(dielectricSpecular, baseColorVector, metallicFactor);
   return {
-    diffuse: diffuse.toArray(),
-    specular: specular.toArray()
+    params: {
+      diffuse: diffuse.toArray(),
+      specular: specular.toArray(),
+      renderMode: 'solid'
+    }
   };
 }
 
 function extractSharedResourcesTextureInfo(texture, nodeId) {
+  var _texture$source, _texture$source2, _texture$source3;
+
   return {
-    encoding: [texture.source.mimeType],
+    encoding: texture !== null && texture !== void 0 && (_texture$source = texture.source) !== null && _texture$source !== void 0 && _texture$source.mimeType ? [texture.source.mimeType] : undefined,
     images: [{
       id: generateImageId(texture, nodeId),
-      size: texture.source.image.width,
-      length: [texture.source.image.data.length]
+      size: (_texture$source2 = texture.source) === null || _texture$source2 === void 0 ? void 0 : _texture$source2.image.width,
+      length: [(_texture$source3 = texture.source) === null || _texture$source3 === void 0 ? void 0 : _texture$source3.image.data.length]
     }]
   };
 }
 
 function generateImageId(texture, nodeId) {
-  var _texture$source$image = texture.source.image,
+  var _texture$source4;
+
+  var _texture$source$image = (_texture$source4 = texture.source) === null || _texture$source4 === void 0 ? void 0 : _texture$source4.image,
       width = _texture$source$image.width,
       height = _texture$source$image.height;
+
   var levelCountOfTexture = 1;
   var indexOfLevel = 0;
   var indexOfTextureInStore = nodeId + 1;
@@ -755,8 +845,8 @@ function getFeaturesReplaceMap(featureIds, batchTable, featuresHashArray) {
 function generateStringFromBatchTableByIndex(batchTable, index) {
   var str = '';
 
-  for (var key in batchTable) {
-    str += batchTable[key][index];
+  for (var _key in batchTable) {
+    str += batchTable[_key][index];
   }
 
   return str;
@@ -787,29 +877,31 @@ function convertBatchTableToAttributeBuffers(batchTable, featureIds, attributeSt
       OBJECTID: featureIds
     }, batchTable);
 
-    for (var key in batchTableWithFeatureIds) {
-      var type = getAttributeType(key, attributeStorageInfo);
+    for (var _key2 in batchTableWithFeatureIds) {
+      var type = getAttributeType(_key2, attributeStorageInfo);
       var attributeBuffer = null;
 
       switch (type) {
         case OBJECT_ID_TYPE:
         case SHORT_INT_TYPE:
-          attributeBuffer = generateShortIntegerAttributeBuffer(batchTableWithFeatureIds[key]);
+          attributeBuffer = generateShortIntegerAttributeBuffer(batchTableWithFeatureIds[_key2]);
           break;
 
         case DOUBLE_TYPE:
-          attributeBuffer = generateDoubleAttributeBuffer(batchTableWithFeatureIds[key]);
+          attributeBuffer = generateDoubleAttributeBuffer(batchTableWithFeatureIds[_key2]);
           break;
 
         case STRING_TYPE:
-          attributeBuffer = generateStringAttributeBuffer(batchTableWithFeatureIds[key]);
+          attributeBuffer = generateStringAttributeBuffer(batchTableWithFeatureIds[_key2]);
           break;
 
         default:
-          attributeBuffer = generateStringAttributeBuffer(batchTableWithFeatureIds[key]);
+          attributeBuffer = generateStringAttributeBuffer(batchTableWithFeatureIds[_key2]);
       }
 
-      attributeBuffers.push(attributeBuffer);
+      if (attributeBuffer) {
+        attributeBuffers.push(attributeBuffer);
+      }
     }
   }
 
@@ -865,16 +957,16 @@ function generateBigUint64Array(featureIds) {
   return typedFeatureIds;
 }
 
-function generateCompressedGeometry(_x9, _x10, _x11) {
+function generateCompressedGeometry(_x12, _x13, _x14, _x15) {
   return _generateCompressedGeometry.apply(this, arguments);
 }
 
 function _generateCompressedGeometry() {
-  _generateCompressedGeometry = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(vertexCount, convertedAttributes, attributes) {
+  _generateCompressedGeometry = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee4(vertexCount, convertedAttributes, attributes, dracoWorkerSoure) {
     var positions, normals, texCoords, colors, featureIds, faceRange, indices, index, featureIndices, featureIndex, compressedAttributes, attributesMetadata;
-    return _regenerator.default.wrap(function _callee3$(_context3) {
+    return _regenerator.default.wrap(function _callee4$(_context4) {
       while (1) {
-        switch (_context3.prev = _context3.next) {
+        switch (_context4.prev = _context4.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);
@@ -902,28 +994,25 @@ function _generateCompressedGeometry() {
                 'i3s-feature-ids': new Int32Array(featureIds)
               }
             };
-            _context3.t0 = Uint8Array;
-            _context3.next = 11;
-            return (0, _core2.encode)({
+            return _context4.abrupt("return", (0, _core2.encode)({
               attributes: compressedAttributes,
               indices: indices
-            }, _draco.DracoWriter, {
+            }, _draco.DracoWriterWorker, _objectSpread(_objectSpread({}, _draco.DracoWriterWorker.options), {}, {
+              source: dracoWorkerSoure,
+              reuseWorkers: true,
+              _nodeWorkers: true,
               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 9:
           case "end":
-            return _context3.stop();
+            return _context4.stop();
         }
       }
-    }, _callee3);
+    }, _callee4);
   }));
   return _generateCompressedGeometry.apply(this, arguments);
 }