@loaders.gl/tile-converter 3.1.0-alpha.3 → 3.1.0-beta.2

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

@@ -0,0 +1,700 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = convertB3dmToI3sGeometry;
+
+var _core = require("@math.gl/core");
+
+var _geospatial = require("@math.gl/geospatial");
+
+var _draco = require("@loaders.gl/draco");
+
+var _core2 = require("@loaders.gl/core");
+
+var _loaderUtils = require("@loaders.gl/loader-utils");
+
+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'];
+
+async function convertB3dmToI3sGeometry(tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco) {
+  const materialAndTextureList = convertMaterials(tileContent);
+  const convertedAttributesMap = convertAttributes(tileContent);
+
+  if (convertedAttributesMap.has('default')) {
+    materialAndTextureList.push({
+      material: getDefaultMaterial()
+    });
+  }
+
+  const result = [];
+  let nodesCounter = nodeId;
+  let {
+    materials = []
+  } = tileContent.gltf;
+
+  if (!materials.length === 0) {
+    materials.push({
+      id: 'default'
+    });
+  }
+
+  for (let i = 0; i < materials.length; i++) {
+    const sourceMaterial = materials[i];
+
+    if (!convertedAttributesMap.has(sourceMaterial.id)) {
+      continue;
+    }
+
+    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++;
+  }
+
+  if (!result.length) {
+    return null;
+  }
+
+  return result;
+}
+
+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 (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
+  };
+}
+
+function convertAttributes(tileContent) {
+  var _tileContent$gltf$sce;
+
+  const attributesMap = new Map();
+
+  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: []
+    });
+  }
+
+  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);
+
+  for (const attrKey of attributesMap.keys()) {
+    const attributes = attributesMap.get(attrKey);
+
+    if (attributes.positions.length === 0) {
+      attributesMap.delete(attrKey);
+      continue;
+    }
+
+    attributes.featureIndices = attributes.featureIndices.reduce((acc, value) => acc.concat(value));
+  }
+
+  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])) {
+  if (nodes) {
+    for (const node of nodes) {
+      convertNode(node, tileContent, attributesMap, matrix);
+    }
+  }
+}
+
+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;
+
+  if (mesh) {
+    convertMesh(mesh, tileContent, attributesMap, compositeMatrix);
+  }
+
+  convertNodes(node.children, tileContent, attributesMap, 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;
+
+    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');
+    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));
+  }
+}
+
+function transformVertexArray(args) {
+  const {
+    vertices,
+    indices,
+    attributeSpecificTransformation
+  } = args;
+  const 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));
+    vertexVector = attributeSpecificTransformation(vertexVector, args);
+    newVertices[i * VALUES_PER_VERTEX] = vertexVector.x;
+    newVertices[i * VALUES_PER_VERTEX + 1] = vertexVector.y;
+    newVertices[i * VALUES_PER_VERTEX + 2] = vertexVector.z;
+  }
+
+  return newVertices;
+}
+
+function transformVertexPositions(vertexVector, calleeArgs) {
+  const {
+    cartesianModelMatrix,
+    cartographicOrigin,
+    nodeMatrix
+  } = calleeArgs;
+
+  if (nodeMatrix) {
+    vertexVector = vertexVector.transform(nodeMatrix);
+  }
+
+  vertexVector = vertexVector.transform(cartesianModelMatrix);
+
+  _geospatial.Ellipsoid.WGS84.cartesianToCartographic([vertexVector[0], vertexVector[1], vertexVector[2]], vertexVector);
+
+  vertexVector = vertexVector.subtract(cartographicOrigin);
+  return vertexVector;
+}
+
+function transformVertexNormals(vertexVector, calleeArgs) {
+  const {
+    cartesianModelMatrix,
+    nodeMatrix
+  } = calleeArgs;
+
+  if (nodeMatrix) {
+    vertexVector = vertexVector.transformAsVector(nodeMatrix);
+  }
+
+  vertexVector = vertexVector.transformAsVector(cartesianModelMatrix);
+  return vertexVector;
+}
+
+function flattenTexCoords(texCoords, indices) {
+  const 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);
+    newTexCoords[i * VALUES_PER_TEX_COORD] = texCoord[0];
+    newTexCoords[i * VALUES_PER_TEX_COORD + 1] = texCoord[1];
+  }
+
+  return newTexCoords;
+}
+
+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);
+
+  if (!colorsAttribute) {
+    newColors.fill(255);
+    return newColors;
+  }
+
+  const 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 (let j = 0; j < color.length; j++) {
+      colorUint8[j] = color[j] * 255;
+    }
+
+    newColors.set(colorUint8, i * components);
+  }
+
+  return newColors;
+}
+
+function flattenBatchIds(batchedIds, indices) {
+  if (!batchedIds.length || !indices.length) {
+    return [];
+  }
+
+  const newBatchIds = [];
+
+  for (let i = 0; i < indices.length; i++) {
+    const coordIndex = indices[i];
+    newBatchIds.push(batchedIds[coordIndex]);
+  }
+
+  return newBatchIds;
+}
+
+function getBatchIdsByAttributeName(attributes) {
+  let batchIds = [];
+
+  for (let index = 0; index < BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES.length; index++) {
+    const possibleBatchIdAttributeName = BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES[index];
+
+    if (attributes[possibleBatchIdAttributeName] && attributes[possibleBatchIdAttributeName].value) {
+      batchIds = attributes[possibleBatchIdAttributeName].value;
+      break;
+    }
+  }
+
+  return batchIds;
+}
+
+function convertMaterials(tileContent) {
+  const result = [];
+  const sourceMaterials = tileContent.gltf.materials || [];
+
+  for (const sourceMaterial of sourceMaterials) {
+    result.push(convertMaterial(sourceMaterial));
+  }
+
+  return result;
+}
+
+function convertMaterial(sourceMaterial) {
+  const material = {
+    doubleSided: sourceMaterial.doubleSided,
+    emissiveFactor: sourceMaterial.emissiveFactor.map(c => Math.round(c * 255)),
+    alphaMode: (sourceMaterial.alphaMode || 'OPAQUE').toLowerCase(),
+    pbrMetallicRoughness: {
+      roughnessFactor: sourceMaterial.pbrMetallicRoughness.roughnessFactor,
+      metallicFactor: sourceMaterial.pbrMetallicRoughness.metallicFactor
+    }
+  };
+  let texture;
+
+  if (sourceMaterial.pbrMetallicRoughness.baseColorTexture) {
+    texture = sourceMaterial.pbrMetallicRoughness.baseColorTexture.texture.source;
+    material.pbrMetallicRoughness.baseColorTexture = {
+      textureSetDefinitionId: 0
+    };
+  } else if (sourceMaterial.emissiveTexture) {
+    texture = sourceMaterial.emissiveTexture.texture.source;
+    material.pbrMetallicRoughness.baseColorTexture = {
+      textureSetDefinitionId: 0
+    };
+  }
+
+  if (!texture) {
+    const baseColorFactor = sourceMaterial.pbrMetallicRoughness.baseColorFactor;
+    material.pbrMetallicRoughness.baseColorFactor = baseColorFactor && baseColorFactor.map(c => Math.round(c * 255)) || undefined;
+  }
+
+  return {
+    material,
+    texture
+  };
+}
+
+function getDefaultMaterial() {
+  return {
+    alphaMode: 'opaque',
+    pbrMetallicRoughness: {}
+  };
+}
+
+function getSharedResources(tileContent, nodeId) {
+  const gltfMaterials = tileContent.gltf.materials;
+  const i3sResources = {};
+
+  if (!gltfMaterials || !gltfMaterials.length) {
+    return i3sResources;
+  }
+
+  i3sResources.materialDefinitionInfos = [];
+
+  for (const gltfMaterial of gltfMaterials) {
+    const {
+      materialDefinitionInfo,
+      textureDefinitionInfo
+    } = convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId);
+    i3sResources.materialDefinitionInfos.push(materialDefinitionInfo);
+
+    if (textureDefinitionInfo) {
+      i3sResources.textureDefinitionInfos = i3sResources.textureDefinitionInfos || [];
+      i3sResources.textureDefinitionInfos.push(textureDefinitionInfo);
+    }
+  }
+
+  return i3sResources;
+}
+
+function convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId) {
+  const texture = gltfMaterial.pbrMetallicRoughness.baseColorTexture || gltfMaterial.emissiveTexture;
+  let textureDefinitionInfo = null;
+
+  if (texture) {
+    textureDefinitionInfo = extractSharedResourcesTextureInfo(texture.texture, nodeId);
+  }
+
+  const {
+    baseColorFactor,
+    metallicFactor
+  } = gltfMaterial.pbrMetallicRoughness;
+  let colorFactor = baseColorFactor;
+
+  if ((!baseColorFactor || baseColorFactor[3] === 0) && gltfMaterial.emissiveFactor) {
+    colorFactor = gltfMaterial.emissiveFactor;
+    colorFactor[3] = colorFactor[3] || 1;
+  }
+
+  return {
+    materialDefinitionInfo: extractSharedResourcesMaterialInfo(colorFactor, metallicFactor),
+    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);
+  dielectricSpecular[3] = 1;
+  const specular = dielectricSpecular.lerp(dielectricSpecular, baseColorVector, metallicFactor);
+  return {
+    diffuse: diffuse.toArray(),
+    specular: specular.toArray()
+  };
+}
+
+function extractSharedResourcesTextureInfo(texture, nodeId) {
+  return {
+    encoding: [texture.source.mimeType],
+    images: [{
+      id: generateImageId(texture, nodeId),
+      size: texture.source.image.width,
+      length: [texture.source.image.data.length]
+    }]
+  };
+}
+
+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));
+  return imageId.toString();
+}
+
+function makeFeatureIdsUnique(featureIds, featureIndices, featuresHashArray, batchTable) {
+  const replaceMap = getFeaturesReplaceMap(featureIds, batchTable, featuresHashArray);
+  replaceIndicesByUnique(featureIndices, replaceMap);
+  replaceIndicesByUnique(featureIds, replaceMap);
+}
+
+function getFeaturesReplaceMap(featureIds, batchTable, featuresHashArray) {
+  const featureMap = {};
+
+  for (let index = 0; index < featureIds.length; index++) {
+    const oldFeatureId = featureIds[index];
+    const uniqueFeatureId = getOrCreateUniqueFeatureId(index, batchTable, featuresHashArray);
+    featureMap[oldFeatureId.toString()] = uniqueFeatureId;
+  }
+
+  return featureMap;
+}
+
+function generateStringFromBatchTableByIndex(batchTable, index) {
+  let str = '';
+
+  for (const key in batchTable) {
+    str += batchTable[key][index];
+  }
+
+  return str;
+}
+
+function getOrCreateUniqueFeatureId(index, batchTable, featuresHashArray) {
+  const batchTableStr = generateStringFromBatchTableByIndex(batchTable, index);
+  const hash = (0, _md.default)(batchTableStr);
+
+  if (featuresHashArray.includes(hash)) {
+    return featuresHashArray.indexOf(hash);
+  }
+
+  return featuresHashArray.push(hash) - 1;
+}
+
+function replaceIndicesByUnique(indicesArray, featureMap) {
+  for (let index = 0; index < indicesArray.length; index++) {
+    indicesArray[index] = featureMap[indicesArray[index]];
+  }
+}
+
+function convertBatchTableToAttributeBuffers(batchTable, featureIds, attributeStorageInfo) {
+  const attributeBuffers = [];
+
+  if (batchTable) {
+    const batchTableWithFeatureIds = {
+      OBJECTID: featureIds,
+      ...batchTable
+    };
+
+    for (const key in batchTableWithFeatureIds) {
+      const type = getAttributeType(key, attributeStorageInfo);
+      let attributeBuffer = null;
+
+      switch (type) {
+        case OBJECT_ID_TYPE:
+        case SHORT_INT_TYPE:
+          attributeBuffer = generateShortIntegerAttributeBuffer(batchTableWithFeatureIds[key]);
+          break;
+
+        case DOUBLE_TYPE:
+          attributeBuffer = generateDoubleAttributeBuffer(batchTableWithFeatureIds[key]);
+          break;
+
+        case STRING_TYPE:
+          attributeBuffer = generateStringAttributeBuffer(batchTableWithFeatureIds[key]);
+          break;
+
+        default:
+          attributeBuffer = generateStringAttributeBuffer(batchTableWithFeatureIds[key]);
+      }
+
+      attributeBuffers.push(attributeBuffer);
+    }
+  }
+
+  return attributeBuffers;
+}
+
+function getAttributeType(key, attributeStorageInfo) {
+  const attribute = attributeStorageInfo.find(attr => attr.name === key);
+  return attribute.attributeValues.valueType;
+}
+
+function generateShortIntegerAttributeBuffer(featureIds) {
+  const count = new Uint32Array([featureIds.length]);
+  const 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);
+  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;
+    totalNumberOfBytes += currentStringSize;
+    stringSizesArray[index] = currentStringSize;
+    stringBufferArray.push(currentStringBuffer);
+  }
+
+  const totalBytes = new Uint32Array([totalNumberOfBytes]);
+  return (0, _loaderUtils.concatenateArrayBuffers)(stringCountArray.buffer, totalBytes.buffer, stringSizesArray.buffer, ...stringBufferArray);
+}
+
+function generateBigUint64Array(featureIds) {
+  const typedFeatureIds = new BigUint64Array(featureIds.length);
+
+  for (let 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 generateFeatureIndexAttribute(featureIndex, faceRange) {
+  const orderedFeatureIndices = new Uint32Array(featureIndex.length);
+  let fillIndex = 0;
+  let startIndex = 0;
+
+  for (let index = 1; index < faceRange.length; index += 2) {
+    const endIndex = (faceRange[index] + 1) * VALUES_PER_VERTEX;
+    orderedFeatureIndices.fill(fillIndex, startIndex, endIndex);
+    fillIndex++;
+    startIndex = endIndex + 1;
+  }
+
+  return orderedFeatureIndices;
+}
+//# sourceMappingURL=geometry-converter.js.map