@loaders.gl/i3s 3.3.0-alpha.1 → 3.3.0-alpha.10

package/dist/esm/lib/parsers/parse-i3s-tile-content.js

@@ -7,59 +7,58 @@ import { BasisLoader, CompressedTextureLoader } from '@loaders.gl/textures';
 import { HeaderAttributeProperty } from '../../types';
 import { getUrlWithToken } from '../utils/url-utils';
 import { GL_TYPE_MAP, getConstructorForDataFormat, sizeOf, COORDINATE_SYSTEM } from './constants';
+import { customizeColors } from '../utils/customizeColors';
 const scratchVector = new Vector3([0, 0, 0]);
-
 function getLoaderForTextureFormat(textureFormat) {
   switch (textureFormat) {
     case 'ktx-etc2':
     case 'dds':
       return CompressedTextureLoader;
-
     case 'ktx2':
       return BasisLoader;
-
     case 'jpg':
     case 'png':
     default:
       return ImageLoader;
   }
 }
-
 const I3S_ATTRIBUTE_TYPE = 'i3s-attribute-type';
-export async function parseI3STileContent(arrayBuffer, tile, tileset, options, context) {
-  tile.content = tile.content || {};
-  tile.content.featureIds = tile.content.featureIds || null;
-  tile.content.attributes = {};
-
-  if (tile.textureUrl) {
+export async function parseI3STileContent(arrayBuffer, tileOptions, tilesetOptions, options, context) {
+  const content = {
+    attributes: {},
+    indices: null,
+    featureIds: [],
+    vertexCount: 0,
+    modelMatrix: new Matrix4(),
+    coordinateSystem: 0,
+    byteLength: 0,
+    texture: null
+  };
+  if (tileOptions.textureUrl) {
     var _options$i3s;
-
-    const url = getUrlWithToken(tile.textureUrl, options === null || options === void 0 ? void 0 : (_options$i3s = options.i3s) === null || _options$i3s === void 0 ? void 0 : _options$i3s.token);
-    const loader = getLoaderForTextureFormat(tile.textureFormat);
+    const url = getUrlWithToken(tileOptions.textureUrl, options === null || options === void 0 ? void 0 : (_options$i3s = options.i3s) === null || _options$i3s === void 0 ? void 0 : _options$i3s.token);
+    const loader = getLoaderForTextureFormat(tileOptions.textureFormat);
     const response = await fetch(url, options === null || options === void 0 ? void 0 : options.fetch);
     const arrayBuffer = await response.arrayBuffer();
-
     if (options !== null && options !== void 0 && options.i3s.decodeTextures) {
       if (loader === ImageLoader) {
-        const options = { ...tile.textureLoaderOptions,
+        const options = {
+          ...tileOptions.textureLoaderOptions,
           image: {
             type: 'data'
           }
         };
-
         try {
-          tile.content.texture = await context.parse(arrayBuffer, options);
+          content.texture = await context.parse(arrayBuffer, options);
         } catch (e) {
-          tile.content.texture = await parse(arrayBuffer, loader, options);
+          content.texture = await parse(arrayBuffer, loader, options);
         }
       } else if (loader === CompressedTextureLoader || loader === BasisLoader) {
-        let texture = await load(arrayBuffer, loader, tile.textureLoaderOptions);
-
+        let texture = await load(arrayBuffer, loader, tileOptions.textureLoaderOptions);
         if (loader === BasisLoader) {
           texture = texture[0];
         }
-
-        tile.content.texture = {
+        content.texture = {
           compressed: true,
           mipmaps: false,
           width: texture[0].width,
@@ -68,37 +67,26 @@ export async function parseI3STileContent(arrayBuffer, tile, tileset, options, c
         };
       }
     } else {
-      tile.content.texture = arrayBuffer;
+      content.texture = arrayBuffer;
     }
   }
-
-  tile.content.material = makePbrMaterial(tile.materialDefinition, tile.content.texture);
-
-  if (tile.content.material) {
-    tile.content.texture = null;
+  content.material = makePbrMaterial(tileOptions.materialDefinition, content.texture);
+  if (content.material) {
+    content.texture = null;
   }
-
-  return await parseI3SNodeGeometry(arrayBuffer, tile, tileset, options);
+  return await parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOptions, options);
 }
 
-async function parseI3SNodeGeometry(arrayBuffer, tile, tileset, options) {
+async function parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOptions, options) {
   var _options$i3s2;
-
-  if (!tile.content) {
-    return tile;
-  }
-
-  const content = tile.content;
   const contentByteLength = arrayBuffer.byteLength;
   let attributes;
   let vertexCount;
   let byteOffset = 0;
   let featureCount = 0;
   let indices;
-
-  if (tile.isDracoGeometry) {
+  if (tileOptions.isDracoGeometry) {
     var _decompressedGeometry;
-
     const decompressedGeometry = await parse(arrayBuffer, DracoLoader, {
       draco: {
         attributeNameEntry: I3S_ATTRIBUTE_TYPE
@@ -124,7 +112,6 @@ async function parseI3SNodeGeometry(arrayBuffer, tile, tileset, options) {
     };
     updateAttributesMetadata(attributes, decompressedGeometry);
     const featureIds = getFeatureIdsFromFeatureIndexMetadata(featureIndex);
-
     if (featureIds) {
       flattenFeatureIdsByFeatureIndices(attributes, featureIds);
     }
@@ -134,8 +121,8 @@ async function parseI3SNodeGeometry(arrayBuffer, tile, tileset, options) {
       ordering: attributesOrder,
       featureAttributes,
       featureAttributeOrder
-    } = tileset.store.defaultGeometrySchema;
-    const headers = parseHeaders(tileset, arrayBuffer);
+    } = tilesetOptions.store.defaultGeometrySchema;
+    const headers = parseHeaders(arrayBuffer, tilesetOptions);
     byteOffset = headers.byteOffset;
     vertexCount = headers.vertexCount;
     featureCount = headers.featureCount;
@@ -143,33 +130,33 @@ async function parseI3SNodeGeometry(arrayBuffer, tile, tileset, options) {
       attributes: normalizedVertexAttributes,
       byteOffset: offset
     } = normalizeAttributes(arrayBuffer, byteOffset, vertexAttributes, vertexCount, attributesOrder);
+
     const {
       attributes: normalizedFeatureAttributes
     } = normalizeAttributes(arrayBuffer, offset, featureAttributes, featureCount, featureAttributeOrder);
     flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes);
     attributes = concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes);
   }
-
   if (!(options !== null && options !== void 0 && (_options$i3s2 = options.i3s) !== null && _options$i3s2 !== void 0 && _options$i3s2.coordinateSystem) || options.i3s.coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS) {
-    const enuMatrix = parsePositions(attributes.position, tile);
+    const enuMatrix = parsePositions(attributes.position, tileOptions);
     content.modelMatrix = enuMatrix.invert();
     content.coordinateSystem = COORDINATE_SYSTEM.METER_OFFSETS;
   } else {
     content.modelMatrix = getModelMatrix(attributes.position);
     content.coordinateSystem = COORDINATE_SYSTEM.LNGLAT_OFFSETS;
   }
-
+  attributes.color = await customizeColors(attributes.color, attributes.id, tileOptions, tilesetOptions, options);
   content.attributes = {
     positions: attributes.position,
     normals: attributes.normal,
     colors: normalizeAttribute(attributes.color),
     texCoords: attributes.uv0,
-    uvRegions: normalizeAttribute(attributes.uvRegion)
+    uvRegions: normalizeAttribute(attributes.uvRegion || attributes.region)
   };
-  content.indices = indices || null;
 
+  content.indices = indices || null;
   if (attributes.id && attributes.id.value) {
-    tile.content.featureIds = attributes.id.value;
+    content.featureIds = attributes.id.value;
   }
 
   for (const attributeIndex in content.attributes) {
@@ -177,25 +164,21 @@ async function parseI3SNodeGeometry(arrayBuffer, tile, tileset, options) {
       delete content.attributes[attributeIndex];
     }
   }
-
   content.vertexCount = vertexCount;
   content.byteLength = contentByteLength;
-  return tile;
+  return content;
 }
 
 function updateAttributesMetadata(attributes, decompressedGeometry) {
   for (const key in decompressedGeometry.loaderData.attributes) {
     const dracoAttribute = decompressedGeometry.loaderData.attributes[key];
-
     switch (dracoAttribute.name) {
       case 'POSITION':
         attributes.position.metadata = dracoAttribute.metadata;
         break;
-
       case 'feature-index':
         attributes.id.metadata = dracoAttribute.metadata;
         break;
-
       default:
         break;
     }
@@ -203,7 +186,8 @@ function updateAttributesMetadata(attributes, decompressedGeometry) {
 }
 
 function concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes) {
-  return { ...normalizedVertexAttributes,
+  return {
+    ...normalizedVertexAttributes,
     ...normalizedFeatureAttributes
   };
 }
@@ -212,38 +196,31 @@ function normalizeAttribute(attribute) {
   if (!attribute) {
     return attribute;
   }
-
   attribute.normalized = true;
   return attribute;
 }
-
-function parseHeaders(tileset, arrayBuffer) {
+function parseHeaders(arrayBuffer, options) {
   let byteOffset = 0;
   let vertexCount = 0;
   let featureCount = 0;
-
   for (const {
     property,
     type
-  } of tileset.store.defaultGeometrySchema.header) {
+  } of options.store.defaultGeometrySchema.header) {
     const TypedArrayTypeHeader = getConstructorForDataFormat(type);
-
     switch (property) {
       case HeaderAttributeProperty.vertexCount:
         vertexCount = new TypedArrayTypeHeader(arrayBuffer, 0, 4)[0];
         byteOffset += sizeOf(type);
         break;
-
       case HeaderAttributeProperty.featureCount:
         featureCount = new TypedArrayTypeHeader(arrayBuffer, 4, 4)[0];
         byteOffset += sizeOf(type);
         break;
-
       default:
         break;
     }
   }
-
   return {
     vertexCount,
     featureCount,
@@ -260,42 +237,35 @@ function normalizeAttributes(arrayBuffer, byteOffset, vertexAttributes, attribut
         valueType,
         valuesPerElement
       } = vertexAttributes[attribute];
-
       if (byteOffset + attributeCount * valuesPerElement * sizeOf(valueType) <= arrayBuffer.byteLength) {
         const buffer = arrayBuffer.slice(byteOffset);
         let value;
-
         if (valueType === 'UInt64') {
           value = parseUint64Values(buffer, attributeCount * valuesPerElement, sizeOf(valueType));
         } else {
           const TypedArrayType = getConstructorForDataFormat(valueType);
           value = new TypedArrayType(buffer, 0, attributeCount * valuesPerElement);
         }
-
         attributes[attribute] = {
           value,
           type: GL_TYPE_MAP[valueType],
           size: valuesPerElement
         };
-
         switch (attribute) {
           case 'color':
             attributes.color.normalized = true;
             break;
-
           case 'position':
           case 'region':
           case 'normal':
           default:
         }
-
         byteOffset = byteOffset + attributeCount * valuesPerElement * sizeOf(valueType);
       } else if (attribute !== 'uv0') {
         break;
       }
     }
   }
-
   return {
     attributes,
     byteOffset
@@ -306,7 +276,6 @@ function parseUint64Values(buffer, elementsCount, attributeSize) {
   const values = [];
   const dataView = new DataView(buffer);
   let offset = 0;
-
   for (let index = 0; index < elementsCount; index++) {
     const left = dataView.getUint32(offset, true);
     const right = dataView.getUint32(offset + 4, true);
@@ -314,12 +283,10 @@ function parseUint64Values(buffer, elementsCount, attributeSize) {
     values.push(value);
     offset += attributeSize;
   }
-
   return new Uint32Array(values);
 }
-
-function parsePositions(attribute, tile) {
-  const mbs = tile.mbs;
+function parsePositions(attribute, options) {
+  const mbs = options.mbs;
   const value = attribute.value;
   const metadata = attribute.metadata;
   const enuMatrix = new Matrix4();
@@ -331,30 +298,28 @@ function parsePositions(attribute, tile) {
   return enuMatrix;
 }
 
-function offsetsToCartesians(vertices, metadata = {}, cartographicOrigin) {
+function offsetsToCartesians(vertices) {
+  let metadata = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let cartographicOrigin = arguments.length > 2 ? arguments[2] : undefined;
   const positions = new Float64Array(vertices.length);
   const scaleX = metadata['i3s-scale_x'] && metadata['i3s-scale_x'].double || 1;
   const scaleY = metadata['i3s-scale_y'] && metadata['i3s-scale_y'].double || 1;
-
   for (let i = 0; i < positions.length; i += 3) {
     positions[i] = vertices[i] * scaleX + cartographicOrigin.x;
     positions[i + 1] = vertices[i + 1] * scaleY + cartographicOrigin.y;
     positions[i + 2] = vertices[i + 2] + cartographicOrigin.z;
   }
-
   for (let i = 0; i < positions.length; i += 3) {
     Ellipsoid.WGS84.cartographicToCartesian(positions.subarray(i, i + 3), scratchVector);
     positions[i] = scratchVector.x;
     positions[i + 1] = scratchVector.y;
     positions[i + 2] = scratchVector.z;
   }
-
   return positions;
 }
 
 function getModelMatrix(positions) {
   var _metadata$i3sScale_x, _metadata$i3sScale_y;
-
   const metadata = positions.metadata;
   const scaleX = (metadata === null || metadata === void 0 ? void 0 : (_metadata$i3sScale_x = metadata['i3s-scale_x']) === null || _metadata$i3sScale_x === void 0 ? void 0 : _metadata$i3sScale_x.double) || 1;
   const scaleY = (metadata === null || metadata === void 0 ? void 0 : (_metadata$i3sScale_y = metadata['i3s-scale_y']) === null || _metadata$i3sScale_y === void 0 ? void 0 : _metadata$i3sScale_y.double) || 1;
@@ -366,10 +331,11 @@ function getModelMatrix(positions) {
 
 function makePbrMaterial(materialDefinition, texture) {
   let pbrMaterial;
-
   if (materialDefinition) {
-    pbrMaterial = { ...materialDefinition,
-      pbrMetallicRoughness: materialDefinition.pbrMetallicRoughness ? { ...materialDefinition.pbrMetallicRoughness
+    pbrMaterial = {
+      ...materialDefinition,
+      pbrMetallicRoughness: materialDefinition.pbrMetallicRoughness ? {
+        ...materialDefinition.pbrMetallicRoughness
       } : {
         baseColorFactor: [255, 255, 255, 255]
       }
@@ -378,7 +344,6 @@ function makePbrMaterial(materialDefinition, texture) {
     pbrMaterial = {
       pbrMetallicRoughness: {}
     };
-
     if (texture) {
       pbrMaterial.pbrMetallicRoughness.baseColorTexture = {
         texCoord: 0
@@ -389,7 +354,6 @@ function makePbrMaterial(materialDefinition, texture) {
   }
 
   pbrMaterial.alphaCutoff = pbrMaterial.alphaCutoff || 0.25;
-
   if (pbrMaterial.alphaMode) {
     pbrMaterial.alphaMode = pbrMaterial.alphaMode.toUpperCase();
   }
@@ -397,25 +361,20 @@ function makePbrMaterial(materialDefinition, texture) {
   if (pbrMaterial.emissiveFactor) {
     pbrMaterial.emissiveFactor = convertColorFormat(pbrMaterial.emissiveFactor);
   }
-
   if (pbrMaterial.pbrMetallicRoughness && pbrMaterial.pbrMetallicRoughness.baseColorFactor) {
     pbrMaterial.pbrMetallicRoughness.baseColorFactor = convertColorFormat(pbrMaterial.pbrMetallicRoughness.baseColorFactor);
   }
-
   if (texture) {
     setMaterialTexture(pbrMaterial, texture);
   }
-
   return pbrMaterial;
 }
 
 function convertColorFormat(colorFactor) {
   const normalizedColor = [...colorFactor];
-
   for (let index = 0; index < colorFactor.length; index++) {
     normalizedColor[index] = colorFactor[index] / 255;
   }
-
   return normalizedColor;
 }
 
@@ -425,25 +384,29 @@ function setMaterialTexture(material, image) {
       image
     }
   };
-
   if (material.pbrMetallicRoughness && material.pbrMetallicRoughness.baseColorTexture) {
-    material.pbrMetallicRoughness.baseColorTexture = { ...material.pbrMetallicRoughness.baseColorTexture,
+    material.pbrMetallicRoughness.baseColorTexture = {
+      ...material.pbrMetallicRoughness.baseColorTexture,
       texture
     };
   } else if (material.emissiveTexture) {
-    material.emissiveTexture = { ...material.emissiveTexture,
+    material.emissiveTexture = {
+      ...material.emissiveTexture,
       texture
     };
   } else if (material.pbrMetallicRoughness && material.pbrMetallicRoughness.metallicRoughnessTexture) {
-    material.pbrMetallicRoughness.metallicRoughnessTexture = { ...material.pbrMetallicRoughness.metallicRoughnessTexture,
+    material.pbrMetallicRoughness.metallicRoughnessTexture = {
+      ...material.pbrMetallicRoughness.metallicRoughnessTexture,
       texture
     };
   } else if (material.normalTexture) {
-    material.normalTexture = { ...material.normalTexture,
+    material.normalTexture = {
+      ...material.normalTexture,
       texture
     };
   } else if (material.occlusionTexture) {
-    material.occlusionTexture = { ...material.occlusionTexture,
+    material.occlusionTexture = {
+      ...material.occlusionTexture,
       texture
     };
   }
@@ -454,18 +417,15 @@ function flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes) {
     id,
     faceRange
   } = normalizedFeatureAttributes;
-
   if (!id || !faceRange) {
     return;
   }
-
   const featureIds = id.value;
   const range = faceRange.value;
   const featureIdsLength = range[range.length - 1] + 1;
   const orderedFeatureIndices = new Uint32Array(featureIdsLength * 3);
   let featureIndex = 0;
   let startIndex = 0;
-
   for (let index = 1; index < range.length; index += 2) {
     const fillId = Number(featureIds[featureIndex]);
     const endValue = range[index];
@@ -476,24 +436,20 @@ function flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes) {
     featureIndex++;
     startIndex = endIndex;
   }
-
   normalizedFeatureAttributes.id.value = orderedFeatureIndices;
 }
 
 function flattenFeatureIdsByFeatureIndices(attributes, featureIds) {
   const featureIndices = attributes.id.value;
   const result = new Float32Array(featureIndices.length);
-
   for (let index = 0; index < featureIndices.length; index++) {
     result[index] = featureIds[featureIndices[index]];
   }
-
   attributes.id.value = result;
 }
 
 function getFeatureIdsFromFeatureIndexMetadata(featureIndex) {
   var _featureIndex$metadat, _featureIndex$metadat2;
-
   return featureIndex === null || featureIndex === void 0 ? void 0 : (_featureIndex$metadat = featureIndex.metadata) === null || _featureIndex$metadat === void 0 ? void 0 : (_featureIndex$metadat2 = _featureIndex$metadat['i3s-feature-ids']) === null || _featureIndex$metadat2 === void 0 ? void 0 : _featureIndex$metadat2.intArray;
 }
 //# sourceMappingURL=parse-i3s-tile-content.js.map