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

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

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertAttributes = void 0;
 const core_1 = require("@math.gl/core");
 const geospatial_1 = require("@math.gl/geospatial");
 const draco_1 = require("@loaders.gl/draco");
@@ -11,6 +12,7 @@ const loader_utils_1 = require("@loaders.gl/loader-utils");
 const md5_1 = __importDefault(require("md5"));
 const geometry_attributes_1 = require("./geometry-attributes");
 const coordinate_converter_1 = require("./coordinate-converter");
+const gltf_attributes_1 = require("./gltf-attributes");
 // Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.7/pbrMetallicRoughness.cmn.md
 const DEFAULT_ROUGHNESS_FACTOR = 1;
 const DEFAULT_METALLIC_FACTOR = 1;
@@ -28,10 +30,31 @@ const OBJECT_ID_TYPE = 'Oid32';
  */
 const BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES = ['CUSTOM_ATTRIBUTE_2', '_BATCHID', 'BATCHID'];
 let scratchVector = new core_1.Vector3();
-async function convertB3dmToI3sGeometry(tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, geoidHeightModel) {
+/**
+ * Convert binary data from b3dm file to i3s resources
+ *
+ * @param tileContent - 3d tile content
+ * @param nodeId - target nodeId. If a few nodes will be created - ids will be nodeId+n where n - index in the resulting array
+ * @param featuresHashArray - hash array of features that is needed to not to mix up same features in parent and child nodes
+ * @param attributeStorageInfo - attributes metadata from 3DSceneLayer json
+ * @param draco - is converter should create draco compressed geometry
+ * @param generateBoundingVolumes - is converter should create accurate bounding voulmes from geometry attributes
+ * @param geoidHeightModel - model to convert elevation from elipsoidal to geoid
+ * @returns Array of node resources to create one or more i3s nodes
+ */
+async function convertB3dmToI3sGeometry(tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, geoidHeightModel, workerSource) {
     const useCartesianPositions = generateBoundingVolumes;
-    const materialAndTextureList = convertMaterials(tileContent);
-    const convertedAttributesMap = convertAttributes(tileContent, useCartesianPositions);
+    const materialAndTextureList = convertMaterials(tileContent.gltf?.materials);
+    const dataForAttributesConversion = (0, gltf_attributes_1.prepareDataForAttributesConversion)(tileContent);
+    const convertedAttributesMap = await convertAttributes(dataForAttributesConversion, useCartesianPositions);
+    // TODO uncomment it when worker will be published on CDN.
+    /*
+    const convertedAttributesMap: Map<string, ConvertedAttributes> =
+      await transformI3SAttributesOnWorker(dataForAttributesConversion, {
+        useCartesianPositions,
+        source: workerSource.I3SAttributes
+      });
+    */
     if (generateBoundingVolumes) {
         _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeightModel);
     }
@@ -42,7 +65,7 @@ async function convertB3dmToI3sGeometry(tileContent, nodeId, featuresHashArray,
     }
     const result = [];
     let nodesCounter = nodeId;
-    let { materials = [] } = tileContent.gltf;
+    let { materials = [] } = tileContent.gltf || { materials: [] };
     if (!materials?.length) {
         materials.push({ id: 'default' });
     }
@@ -52,6 +75,9 @@ async function convertB3dmToI3sGeometry(tileContent, nodeId, featuresHashArray,
             continue; // eslint-disable-line no-continue
         }
         const convertedAttributes = convertedAttributesMap.get(sourceMaterial.id);
+        if (!convertedAttributes) {
+            continue;
+        }
         const { material, texture } = materialAndTextureList[i];
         result.push(await _makeNodeResources({
             convertedAttributes,
@@ -61,7 +87,8 @@ async function convertB3dmToI3sGeometry(tileContent, nodeId, featuresHashArray,
             nodeId: nodesCounter,
             featuresHashArray,
             attributeStorageInfo,
-            draco
+            draco,
+            workerSource
         }));
         nodesCounter++;
     }
@@ -73,8 +100,8 @@ async function convertB3dmToI3sGeometry(tileContent, nodeId, featuresHashArray,
 exports.default = convertB3dmToI3sGeometry;
 /**
  * Create bounding volumes based on positions
- * @param convertedAttributesMap
- * @param geoidHeightModel
+ * @param convertedAttributesMap - geometry attributes map
+ * @param geoidHeightModel - geoid height model to convert elevation from elipsoidal to geoid
  */
 function _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeightModel) {
     for (const attributes of convertedAttributesMap.values()) {
@@ -91,11 +118,23 @@ function _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeigh
         }
     }
 }
-async function _makeNodeResources({ convertedAttributes, material, texture, tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco }) {
+/**
+ *
+ * @param params
+ * @param params.convertedAttributes - Converted geometry attributes
+ * @param params.material - I3S PBR-like material definition
+ * @param params.texture - texture content
+ * @param params.tileContent - B3DM decoded content
+ * @param params.nodeId - new node ID
+ * @param params.featuresHashArray - hash array of features that is needed to not to mix up same features in parent and child nodes
+ * @param params.attributesStorageInfo - attributes metadata from 3DSceneLayer json
+ * @param params.draco - is converter should create draco compressed geometry
+ * @returns Array of I3S node resources
+ */
+async function _makeNodeResources({ convertedAttributes, material, texture, tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco, workerSource }) {
     const boundingVolumes = convertedAttributes.boundingVolumes;
     const vertexCount = convertedAttributes.positions.length / VALUES_PER_VERTEX;
-    const triangleCount = vertexCount / 3;
-    const { faceRange, featureIds, positions, normals, colors, texCoords, featureCount } = (0, geometry_attributes_1.generateAttributes)({ triangleCount, ...convertedAttributes });
+    const { faceRange, featureIds, positions, normals, colors, texCoords, featureCount } = (0, geometry_attributes_1.generateAttributes)(convertedAttributes);
     if (tileContent.batchTableJson) {
         makeFeatureIdsUnique(featureIds, convertedAttributes.featureIndices, featuresHashArray, tileContent.batchTableJson);
     }
@@ -104,21 +143,21 @@ async function _makeNodeResources({ convertedAttributes, material, texture, tile
     header.set([vertexCount, featureCount], 0);
     const fileBuffer = new Uint8Array((0, loader_utils_1.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, {
+        ? generateCompressedGeometry(vertexCount, convertedAttributes, {
             positions,
             normals,
             texCoords: texture ? texCoords : new Float32Array(0),
             colors,
             featureIds,
             faceRange
-        })
+        }, workerSource.draco)
         : null;
     const attributes = convertBatchTableToAttributeBuffers(tileContent.batchTableJson, featureIds, attributeStorageInfo);
     return {
         geometry: fileBuffer,
         compressedGeometry,
         texture,
-        sharedResources: getSharedResources(tileContent, nodeId),
+        sharedResources: getSharedResources(tileContent.gltf?.materials || [], nodeId),
         meshMaterial: material,
         vertexCount,
         attributes,
@@ -128,54 +167,58 @@ async function _makeNodeResources({ convertedAttributes, material, texture, tile
 }
 /**
  * Convert attributes from the gltf nodes tree to i3s plain geometry
- * @param {Object} tileContent - 3d tile content
- * @returns {Map}
- * Map<{
- *   positions: Float32Array,
- *   normals: Float32Array,
- *   colors: Uint8Array,
- *   texCoords: Float32Array
- * }>
- * @todo implement colors support (if applicable for gltf format)
- */
-function convertAttributes(tileContent, useCartesianPositions) {
+ * @param tileContent - 3d tile content
+ * @param useCartesianPositions - convert positions to absolute cartesian coordinates instead of cartographic offsets.
+ * Cartesian coordinates will be required for creating bounding voulmest from geometry positions
+ * @returns map of converted geometry attributes
+ */
+async function convertAttributes(attributesData, useCartesianPositions) {
+    const { gltfMaterials, nodes, cartographicOrigin, cartesianModelMatrix } = attributesData;
     const attributesMap = new Map();
-    for (const material of tileContent.gltf.materials || [{ id: 'default' }]) {
+    for (const material of gltfMaterials || [{ id: 'default' }]) {
         attributesMap.set(material.id, {
             positions: new Float32Array(0),
             normals: new Float32Array(0),
             texCoords: new Float32Array(0),
             colors: new Uint8Array(0),
+            featureIndicesGroups: [],
             featureIndices: [],
             boundingVolumes: null
         });
     }
-    const nodes = (tileContent.gltf.scene || tileContent.gltf.scenes?.[0] || tileContent.gltf).nodes;
-    convertNodes(nodes, tileContent, attributesMap, useCartesianPositions);
+    convertNodes(nodes, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions);
     for (const attrKey of attributesMap.keys()) {
         const attributes = attributesMap.get(attrKey);
+        if (!attributes) {
+            continue;
+        }
         if (attributes.positions.length === 0) {
             attributesMap.delete(attrKey);
             continue; // eslint-disable-line no-continue
         }
-        attributes.featureIndices = attributes.featureIndices.reduce((acc, value) => acc.concat(value));
+        if (attributes.featureIndicesGroups) {
+            attributes.featureIndices = attributes.featureIndicesGroups.reduce((acc, value) => acc.concat(value));
+            delete attributes.featureIndicesGroups;
+        }
     }
     return attributesMap;
 }
+exports.convertAttributes = convertAttributes;
 /**
  * Gltf has hierarchical structure of nodes. This function converts nodes starting from those which are in gltf scene object.
  *   The goal is applying tranformation matrix for all children. Functions "convertNodes" and "convertNode" work together recursively.
- * @param {Object[]} nodes - gltf nodes array
- * @param {Object} tileContent - 3d tile content
- * @param {Map} attributesMap Map<{positions: Float32Array, normals: Float32Array, texCoords: Float32Array, colors: UInt8Array, featureIndices: Array}> - for recursive concatenation of
- *   attributes
- * @param {Matrix4} matrix - transformation matrix - cumulative transformation matrix formed from all parent node matrices
+ * @param nodes - gltf nodes array
+ * @param tileContent - 3d tile content
+ * @param attributesMap - for recursive concatenation of attributes
+ * @param useCartesianPositions - convert positions to absolute cartesian coordinates instead of cartographic offsets.
+ * Cartesian coordinates will be required for creating bounding voulmest from geometry positions
+ * @param matrix - transformation matrix - cumulative transformation matrix formed from all parent node matrices
  * @returns {void}
  */
-function convertNodes(nodes, tileContent, attributesMap, useCartesianPositions, matrix = new core_1.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+function convertNodes(nodes, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new core_1.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, useCartesianPositions, matrix);
+            convertNode(node, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix);
         }
     }
 }
@@ -191,44 +234,47 @@ function getCompositeTransformationMatrix(node, matrix) {
     if (nodeMatrix) {
         transformationMatrix = matrix.multiplyRight(nodeMatrix);
     }
+    if (translation) {
+        transformationMatrix = transformationMatrix.translate(translation);
+    }
     if (rotation) {
         transformationMatrix = transformationMatrix.rotateXYZ(rotation);
     }
     if (scale) {
         transformationMatrix = transformationMatrix.scale(scale);
     }
-    if (translation) {
-        transformationMatrix = transformationMatrix.translate(translation);
-    }
     return transformationMatrix;
 }
 /**
  * Convert all primitives of node and all children nodes
- * @param {Object} node - gltf node
+ * @param node - gltf node
  * @param {Object} tileContent - 3d tile content
  * @param {Map} attributesMap Map<{positions: Float32Array, normals: Float32Array, texCoords: Float32Array, colors: Uint8Array, featureIndices: Array}> - for recursive concatenation of
  *   attributes
+ * @param useCartesianPositions - convert positions to absolute cartesian coordinates instead of cartographic offsets.
+ * Cartesian coordinates will be required for creating bounding voulmest from geometry positions
  * @param {Matrix4} matrix - transformation matrix - cumulative transformation matrix formed from all parent node matrices
- * @todo: optimize arrays concatenation
  */
-function convertNode(node, tileContent, attributesMap, useCartesianPositions, matrix = new core_1.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+function convertNode(node, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new core_1.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
     const transformationMatrix = getCompositeTransformationMatrix(node, matrix);
     const 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);
 }
 /**
  * Convert all primitives of node and all children nodes
- * @param {Object} mesh - gltf node
- * @param {Object} content - 3d tile content
- * @param {Map} attributesMap Map<{positions: Float32Array, normals: Float32Array, texCoords: Float32Array, colors: Uint8Array, featureIndices: Array}> - for recursive concatenation of
+ * @param mesh - gltf node
+ * @param content - 3d tile content
+ * @param useCartesianPositions - convert positions to absolute cartesian coordinates instead of cartographic offsets.
+ * Cartesian coordinates will be required for creating bounding voulmest from geometry positions
+ * @param attributesMap Map<{positions: Float32Array, normals: Float32Array, texCoords: Float32Array, colors: Uint8Array, featureIndices: Array}> - for recursive concatenation of
  *   attributes
+ 
  * @param {Matrix4} matrix - transformation matrix - cumulative transformation matrix formed from all parent node matrices
- * @todo: optimize arrays concatenation
  */
-function convertMesh(mesh, content, attributesMap, useCartesianPositions = false, matrix = new core_1.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+function convertMesh(mesh, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions = false, matrix = new core_1.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;
         if (primitive.material) {
@@ -239,39 +285,43 @@ function convertMesh(mesh, content, attributesMap, useCartesianPositions = false
         }
         (0, core_2.assert)(outputAttributes !== null, 'Primitive - material mapping failed');
         const attributes = primitive.attributes;
+        if (!outputAttributes) {
+            continue;
+        }
         outputAttributes.positions = (0, loader_utils_1.concatenateTypedArrays)(outputAttributes.positions, transformVertexArray({
             vertices: attributes.POSITION.value,
-            cartographicOrigin: content.cartographicOrigin,
-            cartesianModelMatrix: content.cartesianModelMatrix,
+            cartographicOrigin,
+            cartesianModelMatrix,
             nodeMatrix: matrix,
-            indices: primitive.indices.value,
+            indices: primitive.indices?.value,
             attributeSpecificTransformation: transformVertexPositions,
             useCartesianPositions
         }));
         outputAttributes.normals = (0, loader_utils_1.concatenateTypedArrays)(outputAttributes.normals, transformVertexArray({
             vertices: attributes.NORMAL && attributes.NORMAL.value,
-            cartographicOrigin: content.cartographicOrigin,
-            cartesianModelMatrix: content.cartesianModelMatrix,
+            cartographicOrigin,
+            cartesianModelMatrix,
             nodeMatrix: matrix,
-            indices: primitive.indices.value,
+            indices: primitive.indices?.value,
             attributeSpecificTransformation: transformVertexNormals,
             useCartesianPositions: false
         }));
-        outputAttributes.texCoords = (0, loader_utils_1.concatenateTypedArrays)(outputAttributes.texCoords, flattenTexCoords(attributes.TEXCOORD_0 && attributes.TEXCOORD_0.value, primitive.indices.value));
-        outputAttributes.colors = (0, loader_utils_1.concatenateTypedArrays)(outputAttributes.colors, flattenColors(attributes.COLOR_0, primitive.indices.value));
-        outputAttributes.featureIndices.push(flattenBatchIds(getBatchIdsByAttributeName(attributes), primitive.indices.value));
+        outputAttributes.texCoords = (0, loader_utils_1.concatenateTypedArrays)(outputAttributes.texCoords, flattenTexCoords(attributes.TEXCOORD_0 && attributes.TEXCOORD_0.value, primitive.indices?.value));
+        outputAttributes.colors = (0, loader_utils_1.concatenateTypedArrays)(outputAttributes.colors, flattenColors(attributes.COLOR_0, primitive.indices?.value));
+        outputAttributes.featureIndicesGroups = outputAttributes.featureIndicesGroups || [];
+        outputAttributes.featureIndicesGroups.push(flattenBatchIds(getBatchIdsByAttributeName(attributes), primitive.indices?.value));
     }
 }
 /**
  * Convert vertices attributes (POSITIONS or NORMALS) to i3s compatible format
- * @param {object} args - source tile (3DTile)
- * @param {Float32Array} args.vertices - gltf primitive POSITION or NORMAL attribute
- * @param {Object} args.cartographicOrigin - cartographic origin coordinates
- * @param {Object} args.cartesianModelMatrix - a cartesian model matrix to transform coordnates from cartesian to cartographic format
- * @param {Matrix4} args.nodeMatrix - a gltf node transformation matrix - cumulative transformation matrix formed from all parent node matrices
- * @param {Uint8Array} args.indices - gltf primitive indices
- * @param {Function} args.attributeSpecificTransformation - function to do attribute - specific transformations
- * @param {Boolean} args.useCartesianPositions - use coordinates as it is.
+ * @param args
+ * @param args.vertices - gltf primitive POSITION or NORMAL attribute
+ * @param args.cartographicOrigin - cartographic origin coordinates
+ * @param args.cartesianModelMatrix - a cartesian model matrix to transform coordnates from cartesian to cartographic format
+ * @param args.nodeMatrix - a gltf node transformation matrix - cumulative transformation matrix formed from all parent node matrices
+ * @param args.indices - gltf primitive indices
+ * @param args.attributeSpecificTransformation - function to do attribute - specific transformations
+ * @param args.useCartesianPositions - use coordinates as it is.
  * @returns {Float32Array}
  */
 function transformVertexArray(args) {
@@ -291,6 +341,16 @@ function transformVertexArray(args) {
     }
     return newVertices;
 }
+/**
+ * Trasform positions vector with the attribute specific transformations
+ * @param vertexVector - source positions vector to transform
+ * @param calleeArgs
+ * @param calleeArgs.cartesianModelMatrix - a cartesian model matrix to transform coordnates from cartesian to cartographic format
+ * @param calleeArgs.cartographicOrigin - cartographic origin coordinates
+ * @param calleeArgs.nodeMatrix - a gltf node transformation matrix - cumulative transformation matrix formed from all parent node matrices
+ * @param calleeArgs.useCartesianPositions - use coordinates as it is.
+ * @returns transformed positions vector
+ */
 function transformVertexPositions(vertexVector, calleeArgs) {
     const { cartesianModelMatrix, cartographicOrigin, nodeMatrix, useCartesianPositions } = calleeArgs;
     if (nodeMatrix) {
@@ -304,6 +364,14 @@ function transformVertexPositions(vertexVector, calleeArgs) {
     vertexVector = vertexVector.subtract(cartographicOrigin);
     return vertexVector;
 }
+/**
+ * Trasform normals vector with the attribute specific transformations
+ * @param vertexVector - source normals vector to transform
+ * @param calleeArgs
+ * @param calleeArgs.cartesianModelMatrix - a cartesian model matrix to transform coordnates from cartesian to cartographic format
+ * @param calleeArgs.nodeMatrix - a gltf node transformation matrix - cumulative transformation matrix formed from all parent node matrices
+ * @returns transformed normals vector
+ */
 function transformVertexNormals(vertexVector, calleeArgs) {
     const { cartesianModelMatrix, nodeMatrix } = calleeArgs;
     if (nodeMatrix) {
@@ -314,9 +382,9 @@ function transformVertexNormals(vertexVector, calleeArgs) {
 }
 /**
  * Convert uv0 (texture coordinates) from coords based on indices to plain arrays, compatible with i3s
- * @param {Float32Array} texCoords - gltf primitive TEXCOORD_0 attribute
- * @param {Uint8Array} indices - gltf primitive indices
- * @returns {Float32Array}
+ * @param texCoords - gltf primitive TEXCOORD_0 attribute
+ * @param indices - gltf primitive indices
+ * @returns flattened texture coordinates
  */
 function flattenTexCoords(texCoords, indices) {
     const newTexCoords = new Float32Array(indices.length * VALUES_PER_TEX_COORD);
@@ -336,9 +404,9 @@ function flattenTexCoords(texCoords, indices) {
 }
 /**
  * Convert color from COLOR_0 based on indices to plain arrays, compatible with i3s
- * @param {object} colorsAttribute - gltf primitive COLOR_0 attribute
- * @param {Uint8Array} indices - gltf primitive indices
- * @returns {Uint8Array}
+ * @param colorsAttribute - gltf primitive COLOR_0 attribute
+ * @param indices - gltf primitive indices
+ * @returns flattened colors attribute
  */
 function flattenColors(colorsAttribute, indices) {
     const components = colorsAttribute?.components || VALUES_PER_COLOR_ELEMENT;
@@ -362,9 +430,9 @@ function flattenColors(colorsAttribute, indices) {
 }
 /**
  * Flatten batchedIds list based on indices to right ordered array, compatible with i3s
- * @param {Array} batchedIds - gltf primitive
- * @param {Uint8Array} indices - gltf primitive indices
- * @returns {Array}
+ * @param batchedIds - gltf primitive
+ * @param indices - gltf primitive indices
+ * @returns flattened batch ids
  */
 function flattenBatchIds(batchedIds, indices) {
     if (!batchedIds.length || !indices.length) {
@@ -379,8 +447,8 @@ function flattenBatchIds(batchedIds, indices) {
 }
 /**
  * Return batchIds based on possible attribute names for different kind of maps.
- * @param {Object} attributes {attributeName: Float32Array}
- * @returns {Array}
+ * @param attributes - the gltf primitive attributes
+ * @returns batch ids attribute
  */
 function getBatchIdsByAttributeName(attributes) {
     let batchIds = [];
@@ -394,9 +462,13 @@ function getBatchIdsByAttributeName(attributes) {
     }
     return batchIds;
 }
-function convertMaterials(tileContent) {
+/**
+ * Convert GLTF material to I3S material definitions and textures
+ * @param sourceMaterials Source GLTF materials
+ * @returns Array of Couples I3SMaterialDefinition + texture content
+ */
+function convertMaterials(sourceMaterials = []) {
     const result = [];
-    const sourceMaterials = tileContent.gltf.materials || [];
     for (const sourceMaterial of sourceMaterials) {
         result.push(convertMaterial(sourceMaterial));
     }
@@ -404,16 +476,16 @@ function convertMaterials(tileContent) {
 }
 /**
  * Convert texture and material from gltf 2.0 material object
- * @param {Object} sourceMaterial - material object
- * @returns {Object}
+ * @param sourceMaterial - material object
+ * @returns I3S material definition and texture
  */
 function convertMaterial(sourceMaterial) {
     const material = {
         doubleSided: sourceMaterial.doubleSided,
-        emissiveFactor: sourceMaterial.emissiveFactor.map((c) => Math.round(c * 255)),
+        emissiveFactor: sourceMaterial.emissiveFactor?.map((c) => Math.round(c * 255)),
         // It is in upper case in GLTF: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#alpha-coverage
         // But it is in lower case in I3S: https://github.com/Esri/i3s-spec/blob/master/docs/1.7/materialDefinitions.cmn.md
-        alphaMode: (sourceMaterial.alphaMode || 'OPAQUE').toLowerCase(),
+        alphaMode: convertAlphaMode(sourceMaterial.alphaMode),
         pbrMetallicRoughness: {
             roughnessFactor: sourceMaterial?.pbrMetallicRoughness?.roughnessFactor || DEFAULT_ROUGHNESS_FACTOR,
             metallicFactor: sourceMaterial?.pbrMetallicRoughness?.metallicFactor || DEFAULT_METALLIC_FACTOR
@@ -442,20 +514,44 @@ function convertMaterial(sourceMaterial) {
     }
     return { material, texture };
 }
+/**
+ * Converts from `alphaMode` material property from GLTF to I3S format
+ * @param gltfAlphaMode Gltf material `alphaMode` property
+ * @returns I3SMaterialDefinition.alphaMode property
+ */
+function convertAlphaMode(gltfAlphaMode) {
+    switch (gltfAlphaMode) {
+        case 'OPAQUE':
+            return 'opaque';
+        case 'MASK':
+            return 'mask';
+        case 'BLEND':
+            return 'blend';
+        default:
+            return 'opaque';
+    }
+}
+/**
+ * Form default I3SMaterialDefinition
+ * @returns I3S material definition
+ */
 function getDefaultMaterial() {
     return {
         alphaMode: 'opaque',
-        pbrMetallicRoughness: {}
+        pbrMetallicRoughness: {
+            metallicFactor: 1,
+            roughnessFactor: 1
+        }
     };
 }
 /**
  * Form "sharedResources" from gltf materials array
- * @param {Object} tileContent - 3d tile content
- * @returns {Object} {materialDefinitionInfos: Object[], textureDefinitionInfos: Object[]} -
+ * @param gltfMaterials - GLTF materials array
+ * @param nodeId - I3S node ID
+ * @returns {materialDefinitionInfos: Object[], textureDefinitionInfos: Object[]} -
  * 2 arrays in format of i3s sharedResources data https://github.com/Esri/i3s-spec/blob/master/docs/1.7/sharedResource.cmn.md
  */
-function getSharedResources(tileContent, nodeId) {
-    const gltfMaterials = tileContent.gltf.materials;
+function getSharedResources(gltfMaterials, nodeId) {
     const i3sResources = {};
     if (!gltfMaterials || !gltfMaterials.length) {
         return i3sResources;
@@ -473,8 +569,9 @@ function getSharedResources(tileContent, nodeId) {
 }
 /**
  * Convert gltf material into I3S sharedResources data
- * @param {Object} gltfMaterial - gltf material data
- * @returns {Object} - Couple {materialDefinitionInfo, textureDefinitionInfo} extracted from gltf material data
+ * @param gltfMaterial - gltf material data
+ * @param nodeId - I3S node ID
+ * @returns - Couple {materialDefinitionInfo, textureDefinitionInfo} extracted from gltf material data
  */
 function convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId) {
     const texture = gltfMaterial?.pbrMetallicRoughness?.baseColorTexture || gltfMaterial.emissiveTexture;
@@ -490,7 +587,7 @@ function convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId) {
         colorFactor[3] = colorFactor[3] || 1;
     }
     return {
-        materialDefinitionInfo: extractSharedResourcesMaterialInfo(colorFactor, metallicFactor),
+        materialDefinitionInfo: extractSharedResourcesMaterialInfo(colorFactor || [1, 1, 1, 1], metallicFactor),
         textureDefinitionInfo
     };
 }
@@ -505,9 +602,9 @@ function convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId) {
  *
  * Assumption: F0 - specular in i3s ("specular reflection" <-> "reflectance value at normal incidence")
  * cdiff - diffuse in i3s ("Diffuse color" <-> "'c' diffuse" (c means color?))
- * @param {number[]} baseColorFactor - RGBA color in 0..1 format
- * @param {number} metallicFactor - "metallicFactor" attribute of gltf material object
- * @returns {Object}
+ * @param baseColorFactor - RGBA color in 0..1 format
+ * @param metallicFactor - "metallicFactor" attribute of gltf material object
+ * @returns material definition info for I3S shared resource
  */
 function extractSharedResourcesMaterialInfo(baseColorFactor, metallicFactor = 1) {
     const matDielectricColorComponent = 0.04 / 255; // Color from rgb (255) to 0..1 resolution
@@ -523,37 +620,42 @@ function extractSharedResourcesMaterialInfo(baseColorFactor, metallicFactor = 1)
     dielectricSpecular[3] = 1;
     const specular = dielectricSpecular.lerp(dielectricSpecular, baseColorVector, metallicFactor);
     return {
-        diffuse: diffuse.toArray(),
-        specular: specular.toArray()
+        params: {
+            diffuse: diffuse.toArray(),
+            specular: specular.toArray(),
+            renderMode: 'solid'
+        }
     };
 }
 /**
  * Form "textureDefinition" which is part of "sharedResouces"
- * @param {Object} texture - texture image info
- * @returns {Object}
+ * @param texture - texture image info
+ * @param nodeId - I3S node ID
+ * @returns texture definition infor for shared resource
  */
 function extractSharedResourcesTextureInfo(texture, nodeId) {
     return {
-        encoding: [texture.source.mimeType],
+        encoding: texture?.source?.mimeType ? [texture.source.mimeType] : undefined,
         images: [
             {
                 // 'i3s' has just size which is width of the image. Images are supposed to be square.
                 // https://github.com/Esri/i3s-spec/blob/master/docs/1.7/image.cmn.md
                 id: generateImageId(texture, nodeId),
-                size: texture.source.image.width,
-                length: [texture.source.image.data.length]
+                size: texture.source?.image.width,
+                length: [texture.source?.image.data.length]
             }
         ]
     };
 }
-/*
+/**
  * Formula for counting imageId:
  * https://github.com/Esri/i3s-spec/blob/0a6366a9249b831db8436c322f8d27521e86cf07/format/Indexed%203d%20Scene%20Layer%20Format%20Specification.md#generating-image-ids
- * @param {Object} texture - texture image info
- * @returns {string}
+ * @param texture - texture image info
+ * @param nodeId - I3S node ID
+ * @returns calculate image ID according to the spec
  */
 function generateImageId(texture, nodeId) {
-    const { width, height } = texture.source.image;
+    const { width, height } = texture.source?.image;
     const levelCountOfTexture = 1;
     const indexOfLevel = 0;
     const indexOfTextureInStore = nodeId + 1;
@@ -569,10 +671,10 @@ function generateImageId(texture, nodeId) {
 }
 /**
  * Make all feature ids unique through all nodes in layout.
- * @param {Array} featureIds
- * @param {Array} featureIndices
- * @param {Array} featuresHashArray
- * @param {Object} batchTable
+ * @param featureIds
+ * @param featureIndices
+ * @param featuresHashArray
+ * @param batchTable
  * @returns {void}
  */
 function makeFeatureIdsUnique(featureIds, featureIndices, featuresHashArray, batchTable) {
@@ -666,7 +768,9 @@ function convertBatchTableToAttributeBuffers(batchTable, featureIds, attributeSt
                 default:
                     attributeBuffer = generateStringAttributeBuffer(batchTableWithFeatureIds[key]);
             }
-            attributeBuffers.push(attributeBuffer);
+            if (attributeBuffer) {
+                attributeBuffers.push(attributeBuffer);
+            }
         }
     }
     return attributeBuffers;
@@ -738,10 +842,12 @@ function generateBigUint64Array(featureIds) {
 /**
  * Generates draco compressed geometry
  * @param {Number} vertexCount
- * @param {Object} convertedAttributes
+ * @param {Object} convertedAttributes - get rid of this argument here
+ * @param {Object} attributes - geometry attributes to compress
+ * @param {string} dracoWorkerSoure - draco worker source code
  * @returns {Promise<object>} - COmpressed geometry.
  */
-async function generateCompressedGeometry(vertexCount, convertedAttributes, attributes) {
+async function generateCompressedGeometry(vertexCount, convertedAttributes, attributes, dracoWorkerSoure) {
     const { positions, normals, texCoords, colors, featureIds, faceRange } = attributes;
     const indices = new Uint32Array(vertexCount);
     for (let index = 0; index < indices.length; index++) {
@@ -764,12 +870,16 @@ async function generateCompressedGeometry(vertexCount, convertedAttributes, attr
             'i3s-feature-ids': new Int32Array(featureIds)
         }
     };
-    return new Uint8Array(await (0, core_2.encode)({ attributes: compressedAttributes, indices }, draco_1.DracoWriter, {
+    return (0, core_2.encode)({ attributes: compressedAttributes, indices }, draco_1.DracoWriterWorker, {
+        ...draco_1.DracoWriterWorker.options,
+        source: dracoWorkerSoure,
+        reuseWorkers: true,
+        _nodeWorkers: true,
         draco: {
             method: 'MESH_SEQUENTIAL_ENCODING',
             attributesMetadata
         }
-    }));
+    });
 }
 /**
  * Generates ordered feature indices based on face range