@loaders.gl/i3s 3.1.0-beta.7 → 3.1.3

package/src/index.ts

@@ -15,13 +15,13 @@ export type {
   LodSelection,
   NodeReference,
   Resource,
-  I3SGeometry,
   MaxScreenThresholdSQ,
   NodeInPage,
   SharedResources,
-  TextureImage,
   Attribute,
   Extent,
-  FeatureAttribute
+  FeatureAttribute,
+  FieldInfo,
+  I3SMaterialDefinition
 } from './types';
 export {COORDINATE_SYSTEM} from './lib/parsers/constants';

package/src/lib/helpers/i3s-nodepages-tiles.ts

@@ -1,21 +1,33 @@
 import {load} from '@loaders.gl/core';
 import {getSupportedGPUTextureFormats, selectSupportedBasisFormat} from '@loaders.gl/textures';
-import {Tileset, NodePage} from '../../types';
 import {I3SNodePageLoader} from '../../i3s-node-page-loader';
 import {normalizeTileNonUrlData} from '../parsers/parse-i3s';
 import {getUrlWithToken, generateTilesetAttributeUrls} from '../utils/url-utils';
+import type {LoaderOptions} from '@loaders.gl/loader-utils';
+import {
+  I3STilesetHeader,
+  LodSelection,
+  NodePage,
+  NodeInPage,
+  Obb,
+  MeshMaterial,
+  I3SMaterialDefinition,
+  I3STextureFormat,
+  MeshGeometry,
+  I3STileHeader
+} from '../../types';
 
 /**
  * class I3SNodePagesTiles - loads nodePages and form i3s tiles from them
  */
 export default class I3SNodePagesTiles {
-  tileset: Tileset;
+  tileset: I3STilesetHeader;
   nodePages: NodePage[] = [];
   pendingNodePages: {promise: Promise<NodePage>; status: 'Pending' | 'Done'}[] = [];
   nodesPerPage: number;
-  options: {[key: string]: any};
-  lodSelectionMetricType: any;
-  textureDefinitionsSelectedFormats: any[] = [];
+  options: LoaderOptions;
+  lodSelectionMetricType?: string;
+  textureDefinitionsSelectedFormats: ({format: I3STextureFormat; name: string} | null)[] = [];
   private textureLoaderOptions: {[key: string]: any} = {};
 
   /**
@@ -24,10 +36,10 @@ export default class I3SNodePagesTiles {
    * @param tileset - i3s tileset header ('layers/0')
    * @param options - i3s loader options
    */
-  constructor(tileset: Tileset, options: object) {
+  constructor(tileset: I3STilesetHeader, options: LoaderOptions) {
     this.tileset = {...tileset}; // spread the tileset to avoid circular reference
-    this.nodesPerPage = tileset.nodePages.nodesPerPage;
-    this.lodSelectionMetricType = tileset.nodePages.lodSelectionMetricType;
+    this.nodesPerPage = tileset.nodePages?.nodesPerPage || 64;
+    this.lodSelectionMetricType = tileset.nodePages?.lodSelectionMetricType;
     this.options = options;
 
     this.initSelectedFormatsForTextureDefinitions(tileset);
@@ -37,7 +49,7 @@ export default class I3SNodePagesTiles {
    * Loads some nodePage and return a particular node from it
    * @param id - id of node through all node pages
    */
-  async getNodeById(id: number) {
+  async getNodeById(id: number): Promise<NodeInPage> {
     const pageIndex = Math.floor(id / this.nodesPerPage);
     if (!this.nodePages[pageIndex] && !this.pendingNodePages[pageIndex]) {
       const nodePageUrl = getUrlWithToken(
@@ -63,34 +75,33 @@ export default class I3SNodePagesTiles {
    * @param id - id of node through all node pages
    */
   // eslint-disable-next-line complexity
-  async formTileFromNodePages(id: number) {
-    const node = await this.getNodeById(id);
-    const children: any[] = [];
+  async formTileFromNodePages(id: number): Promise<I3STileHeader> {
+    const node: NodeInPage = await this.getNodeById(id);
+    const children: {id: string; obb: Obb}[] = [];
     for (const child of node.children || []) {
       const childNode = await this.getNodeById(child);
       children.push({
-        id: child,
+        id: child.toString(),
         obb: childNode.obb
       });
     }
 
-    let contentUrl = null;
-    let textureUrl: string | null = null;
-    let materialDefinition = null;
-    let textureFormat = 'jpeg';
+    let contentUrl: string | undefined;
+    let textureUrl: string | undefined;
+    let materialDefinition: I3SMaterialDefinition | undefined;
+    let textureFormat: I3STextureFormat = 'jpg';
     let attributeUrls: string[] = [];
-    let isDracoGeometry = false;
+    let isDracoGeometry: boolean = false;
 
     if (node && node.mesh) {
       // Get geometry resource URL and type (compressed / non-compressed)
       const {url, isDracoGeometry: isDracoGeometryResult} = (node.mesh.geometry &&
-        this.getContentUrl(node.mesh.geometry)) || {url: null, isDracoGeometry: null};
+        this.getContentUrl(node.mesh.geometry)) || {isDracoGeometry: false};
       contentUrl = url;
       isDracoGeometry = isDracoGeometryResult;
 
-      const [textureData, nodeMaterialDefinition] = this.getInformationFromMaterial(
-        node.mesh.material
-      );
+      const {textureData, materialDefinition: nodeMaterialDefinition} =
+        this.getInformationFromMaterial(node.mesh.material);
       materialDefinition = nodeMaterialDefinition;
       textureFormat = textureData.format || textureFormat;
       if (textureData.name) {
@@ -105,7 +116,7 @@ export default class I3SNodePagesTiles {
     const lodSelection = this.getLodSelection(node);
 
     return normalizeTileNonUrlData({
-      id,
+      id: id.toString(),
       lodSelection,
       obb: node.obb,
       contentUrl,
@@ -121,13 +132,14 @@ export default class I3SNodePagesTiles {
 
   /**
    * Forms url and type of geometry resource by nodepage's data and `geometryDefinitions` in the tileset
-   * @param {Object} meshGeometryData - data about the node's mesh from the nodepage
-   * @returns {Object} -
+   * @param - data about the node's mesh from the nodepage
+   * @returns -
    *   {string} url - url to the geometry resource
    *   {boolean} isDracoGeometry - whether the geometry resource contain DRACO compressed geometry
    */
-  private getContentUrl(meshGeometryData) {
-    let result = {};
+  private getContentUrl(meshGeometryData: MeshGeometry) {
+    let result: {url: string; isDracoGeometry: boolean} | null = null;
+    // @ts-ignore
     const geometryDefinition = this.tileset.geometryDefinitions[meshGeometryData.definition];
     let geometryIndex = -1;
     // Try to find DRACO geometryDefinition of `useDracoGeometry` option is set
@@ -156,21 +168,21 @@ export default class I3SNodePagesTiles {
 
   /**
    * Forms 1.6 compatible LOD selection object from a nodepage's node data
-   * @param {Object} node - a node from nodepage
-   * @returns {Object[]} - Array of object of following properties:
-   *   {string} metricType - the label of the LOD metric
-   *   {number} maxError - the value of the metric
+   * @param node - a node from nodepage
+   * @returns- Array of LodSelection
    */
-  private getLodSelection(node): object[] {
-    const lodSelection: object[] = [];
+  private getLodSelection(node: NodeInPage): LodSelection[] {
+    const lodSelection: LodSelection[] = [];
     if (this.lodSelectionMetricType === 'maxScreenThresholdSQ') {
       lodSelection.push({
         metricType: 'maxScreenThreshold',
+        // @ts-ignore
         maxError: Math.sqrt(node.lodThreshold / (Math.PI * 0.25))
       });
     }
     lodSelection.push({
       metricType: this.lodSelectionMetricType,
+      // @ts-ignore
       maxError: node.lodThreshold
     });
     return lodSelection;
@@ -178,43 +190,47 @@ export default class I3SNodePagesTiles {
 
   /**
    * Returns information about texture and material from `materialDefinitions`
-   * @param {Object} material - material data from nodepage
-   * @returns {Object[]} - Couple [textureData, materialDefinition]
+   * @param material - material data from nodepage
+   * @returns - Couple {textureData, materialDefinition}
    * {string} textureData.name - path name of the texture
    * {string} textureData.format - format of the texture
    * materialDefinition - PBR-like material definition from `materialDefinitions`
    */
-  private getInformationFromMaterial(material) {
-    const textureDataDefault = {name: null, format: null};
+  private getInformationFromMaterial(material: MeshMaterial) {
+    const informationFromMaterial: {
+      textureData: {name: string | null; format?: I3STextureFormat};
+      materialDefinition?: I3SMaterialDefinition;
+    } = {textureData: {name: null}};
+
     if (material) {
-      const materialDefinition = this.tileset.materialDefinitions[material.definition];
-      const textureSetDefinitionIndex =
-        materialDefinition &&
-        materialDefinition.pbrMetallicRoughness &&
-        materialDefinition.pbrMetallicRoughness.baseColorTexture &&
-        materialDefinition.pbrMetallicRoughness.baseColorTexture.textureSetDefinitionId;
-      if (textureSetDefinitionIndex || textureSetDefinitionIndex === 0) {
-        const textureData =
-          this.textureDefinitionsSelectedFormats[textureSetDefinitionIndex] || textureDataDefault;
-        return [textureData, materialDefinition];
+      const materialDefinition = this.tileset.materialDefinitions?.[material.definition];
+      if (materialDefinition) {
+        informationFromMaterial.materialDefinition = materialDefinition;
+        const textureSetDefinitionIndex =
+          materialDefinition?.pbrMetallicRoughness?.baseColorTexture?.textureSetDefinitionId;
+
+        if (typeof textureSetDefinitionIndex === 'number') {
+          informationFromMaterial.textureData =
+            this.textureDefinitionsSelectedFormats[textureSetDefinitionIndex] ||
+            informationFromMaterial.textureData;
+        }
       }
-      return [textureDataDefault, materialDefinition];
     }
-    return [textureDataDefault, null];
+    return informationFromMaterial;
   }
 
   /**
    * Sets preferable and supported format for each textureDefinition of the tileset
-   * @param {Object} tileset - I3S layer data
-   * @returns {void}
+   * @param tileset - I3S layer data
+   * @returns
    */
-  private initSelectedFormatsForTextureDefinitions(tileset) {
+  private initSelectedFormatsForTextureDefinitions(tileset: I3STilesetHeader): void {
     this.textureDefinitionsSelectedFormats = [];
     const possibleI3sFormats = this.getSupportedTextureFormats();
     const textureSetDefinitions = tileset.textureSetDefinitions || [];
     for (const textureSetDefinition of textureSetDefinitions) {
       const formats = (textureSetDefinition && textureSetDefinition.formats) || [];
-      let selectedFormat: {format: string; name: string} | null = null;
+      let selectedFormat: {name: string; format: I3STextureFormat} | null = null;
       for (const i3sFormat of possibleI3sFormats) {
         const format = formats.find((value) => value.format === i3sFormat);
         if (format) {
@@ -239,8 +255,8 @@ export default class I3SNodePagesTiles {
    * Returns the array of supported texture format
    * @returns list of format strings
    */
-  private getSupportedTextureFormats(): string[] {
-    const formats: string[] = [];
+  private getSupportedTextureFormats(): I3STextureFormat[] {
+    const formats: I3STextureFormat[] = [];
     if (!this.options.i3s || this.options.i3s.useCompressedTextures) {
       // I3S 1.7 selection
       const supportedCompressedFormats = getSupportedGPUTextureFormats();

package/src/lib/parsers/constants.ts

@@ -14,7 +14,7 @@ export function getConstructorForDataFormat(dataType: string) {
     case DATA_TYPE.UInt64:
       return Float64Array;
     default:
-      return null;
+      throw new Error(`parse i3s tile content: unknown type of data: ${dataType}`);
   }
 }
 
@@ -25,26 +25,6 @@ export const GL_TYPE_MAP: {[key: string]: number} = {
   UInt32: GL.UNSIGNED_INT,
   UInt64: GL.DOUBLE
 };
-
-export const I3S_NAMED_VERTEX_ATTRIBUTES = {
-  position: 'position',
-  normal: 'normal',
-  uv0: 'uv0',
-  color: 'color',
-  region: 'region'
-};
-
-export const I3S_NAMED_GEOMETRY_ATTRIBUTES = {
-  vertexAttributes: 'vertexAttributes',
-  featureAttributeOrder: 'featureAttributeOrder',
-  featureAttributes: 'featureAttributes'
-};
-// TODO Remove Named Attributes and replase with Typescipt types
-export const I3S_NAMED_HEADER_ATTRIBUTES = {
-  // header: 'header',
-  vertexCount: 'vertexCount',
-  featureCount: 'featureCount'
-};
 /**
  * Returns how many bytes a type occupies
  * @param dataType
@@ -66,7 +46,7 @@ export function sizeOf(dataType: string): number {
     case DATA_TYPE.Float64:
       return 8;
     default:
-      return NaN;
+      throw new Error(`parse i3s tile content: unknown size of data: ${dataType}`);
   }
 }
 

package/src/lib/parsers/parse-i3s-tile-content.ts

@@ -2,49 +2,39 @@ import type {TypedArray} from '@loaders.gl/schema';
 import {load, parse} from '@loaders.gl/core';
 import {Vector3, Matrix4} from '@math.gl/core';
 import {Ellipsoid} from '@math.gl/geospatial';
-
-import type {GLTFMaterial} from '@loaders.gl/gltf';
 import type {LoaderOptions, LoaderContext} from '@loaders.gl/loader-utils';
 import {ImageLoader} from '@loaders.gl/images';
-import {DracoLoader} from '@loaders.gl/draco';
+import {DracoLoader, DracoMesh} from '@loaders.gl/draco';
 import {BasisLoader, CompressedTextureLoader} from '@loaders.gl/textures';
 
-import type {
-  Tileset,
-  Tile,
+import {
+  I3STilesetHeader,
+  I3STileHeader,
   FeatureAttribute,
-  TileContent,
   VertexAttribute,
-  NormalizedAttribute,
-  NormalizedAttributes,
-  TileContentTexture
+  I3SMeshAttributes,
+  I3SMeshAttribute,
+  TileContentTexture,
+  HeaderAttributeProperty,
+  I3SMaterialDefinition
 } from '../../types';
 import {getUrlWithToken} from '../utils/url-utils';
 
-import {
-  GL_TYPE_MAP,
-  getConstructorForDataFormat,
-  sizeOf,
-  I3S_NAMED_HEADER_ATTRIBUTES,
-  I3S_NAMED_VERTEX_ATTRIBUTES,
-  I3S_NAMED_GEOMETRY_ATTRIBUTES,
-  COORDINATE_SYSTEM
-} from './constants';
+import {GL_TYPE_MAP, getConstructorForDataFormat, sizeOf, COORDINATE_SYSTEM} from './constants';
 
 const scratchVector = new Vector3([0, 0, 0]);
 
-function getLoaderForTextureFormat(textureFormat: 'jpeg' | 'png' | 'ktx-etc2' | 'dds' | 'ktx2') {
+function getLoaderForTextureFormat(textureFormat?: 'jpg' | 'png' | 'ktx-etc2' | 'dds' | 'ktx2') {
   switch (textureFormat) {
-    case 'jpeg':
-    case 'png':
-      return ImageLoader;
     case 'ktx-etc2':
     case 'dds':
       return CompressedTextureLoader;
     case 'ktx2':
       return BasisLoader;
+    case 'jpg':
+    case 'png':
     default:
-      return null;
+      return ImageLoader;
   }
 }
 
@@ -52,22 +42,19 @@ const I3S_ATTRIBUTE_TYPE = 'i3s-attribute-type';
 
 export async function parseI3STileContent(
   arrayBuffer: ArrayBuffer,
-  tile: Tile,
-  tileset: Tileset,
+  tile: I3STileHeader,
+  tileset: I3STilesetHeader,
   options?: LoaderOptions,
   context?: LoaderContext
 ) {
   tile.content = tile.content || {};
   tile.content.featureIds = tile.content.featureIds || null;
 
-  // construct featureData from defaultGeometrySchema;
-  tile.content.featureData = constructFeatureDataStruct(tileset);
   tile.content.attributes = {};
 
   if (tile.textureUrl) {
     const url = getUrlWithToken(tile.textureUrl, options?.i3s?.token);
-    const loader = getLoaderForTextureFormat(tile.textureFormat) || ImageLoader;
-    // @ts-ignore context must be defined
+    const loader = getLoaderForTextureFormat(tile.textureFormat);
     const response = await fetch(url);
     const arrayBuffer = await response.arrayBuffer();
 
@@ -104,30 +91,36 @@ export async function parseI3STileContent(
     tile.content.texture = null;
   }
 
-  return await parseI3SNodeGeometry(arrayBuffer, tile, options);
+  return await parseI3SNodeGeometry(arrayBuffer, tile, tileset, options);
 }
 
 /* eslint-disable max-statements */
-async function parseI3SNodeGeometry(arrayBuffer: ArrayBuffer, tile: Tile, options?: LoaderOptions) {
+async function parseI3SNodeGeometry(
+  arrayBuffer: ArrayBuffer,
+  tile: I3STileHeader,
+  tileset: I3STilesetHeader,
+  options?: LoaderOptions
+) {
   if (!tile.content) {
     return tile;
   }
 
   const content = tile.content;
-  let attributes: NormalizedAttributes;
+  let attributes: I3SMeshAttributes;
   let vertexCount: number;
   let byteOffset: number = 0;
   let featureCount: number = 0;
+  let indices: TypedArray | undefined;
 
   if (tile.isDracoGeometry) {
-    const decompressedGeometry = await parse(arrayBuffer, DracoLoader, {
+    const decompressedGeometry: DracoMesh = await parse(arrayBuffer, DracoLoader, {
       draco: {
         attributeNameEntry: I3S_ATTRIBUTE_TYPE
       }
     });
-
+    // @ts-expect-error
     vertexCount = decompressedGeometry.header.vertexCount;
-    const indices = decompressedGeometry.indices.value;
+    indices = decompressedGeometry.indices?.value;
     const {
       POSITION,
       NORMAL,
@@ -143,8 +136,7 @@ async function parseI3SNodeGeometry(arrayBuffer: ArrayBuffer, tile: Tile, option
       color: COLOR_0,
       uv0: TEXCOORD_0,
       uvRegion,
-      id: featureIndex,
-      indices
+      id: featureIndex
     };
 
     updateAttributesMetadata(attributes, decompressedGeometry);
@@ -155,10 +147,14 @@ async function parseI3SNodeGeometry(arrayBuffer: ArrayBuffer, tile: Tile, option
       flattenFeatureIdsByFeatureIndices(attributes, featureIds);
     }
   } else {
-    const {vertexAttributes, attributesOrder, featureAttributes, featureAttributeOrder} =
-      content.featureData;
+    const {
+      vertexAttributes,
+      ordering: attributesOrder,
+      featureAttributes,
+      featureAttributeOrder
+    } = tileset.store.defaultGeometrySchema;
     // First 8 bytes reserved for header (vertexCount and featureCount)
-    const headers = parseHeaders(content, arrayBuffer);
+    const headers = parseHeaders(tileset, arrayBuffer);
     byteOffset = headers.byteOffset;
     vertexCount = headers.vertexCount;
     featureCount = headers.featureCount;
@@ -168,7 +164,6 @@ async function parseI3SNodeGeometry(arrayBuffer: ArrayBuffer, tile: Tile, option
       byteOffset,
       vertexAttributes,
       vertexCount,
-      // @ts-expect-error
       attributesOrder
     );
 
@@ -204,7 +199,7 @@ async function parseI3SNodeGeometry(arrayBuffer: ArrayBuffer, tile: Tile, option
     texCoords: attributes.uv0,
     uvRegions: normalizeAttribute(attributes.uvRegion) // Normalize from UInt16
   };
-  content.indices = attributes.indices || null;
+  content.indices = indices || null;
 
   if (attributes.id && attributes.id.value) {
     tile.content.featureIds = attributes.id.value;
@@ -228,7 +223,10 @@ async function parseI3SNodeGeometry(arrayBuffer: ArrayBuffer, tile: Tile, option
  * @param decompressedGeometry
  * @param attributes
  */
-function updateAttributesMetadata(attributes: NormalizedAttributes, decompressedGeometry): void {
+function updateAttributesMetadata(
+  attributes: I3SMeshAttributes,
+  decompressedGeometry: DracoMesh
+): void {
   for (const key in decompressedGeometry.loaderData.attributes) {
     const dracoAttribute = decompressedGeometry.loaderData.attributes[key];
 
@@ -253,9 +251,9 @@ function updateAttributesMetadata(attributes: NormalizedAttributes, decompressed
  * @returns - result of attributes concatenation.
  */
 function concatAttributes(
-  normalizedVertexAttributes: NormalizedAttributes,
-  normalizedFeatureAttributes: NormalizedAttributes
-): NormalizedAttributes {
+  normalizedVertexAttributes: I3SMeshAttributes,
+  normalizedFeatureAttributes: I3SMeshAttributes
+): I3SMeshAttributes {
   return {...normalizedVertexAttributes, ...normalizedFeatureAttributes};
 }
 
@@ -264,7 +262,7 @@ function concatAttributes(
  * @param attribute - geometry attribute
  * @returns - geometry attribute in right format
  */
-function normalizeAttribute(attribute: NormalizedAttribute): NormalizedAttribute {
+function normalizeAttribute(attribute: I3SMeshAttribute): I3SMeshAttribute {
   if (!attribute) {
     return attribute;
   }
@@ -272,49 +270,26 @@ function normalizeAttribute(attribute: NormalizedAttribute): NormalizedAttribute
   return attribute;
 }
 
-function constructFeatureDataStruct(tileset: Tileset) {
-  // seed featureData from defaultGeometrySchema
-  const defaultGeometrySchema = tileset.store.defaultGeometrySchema;
-  const featureData = defaultGeometrySchema;
-  // populate the vertex attributes value types and values per element
-  for (const geometryAttribute in I3S_NAMED_GEOMETRY_ATTRIBUTES) {
-    for (const namedAttribute in I3S_NAMED_VERTEX_ATTRIBUTES) {
-      const attribute = defaultGeometrySchema[geometryAttribute][namedAttribute];
-      if (attribute) {
-        const {byteOffset = 0, count = 0, valueType, valuesPerElement} = attribute;
-
-        featureData[geometryAttribute][namedAttribute] = {
-          valueType,
-          valuesPerElement,
-          byteOffset,
-          count
-        };
-      }
-    }
-  }
-
-  featureData.attributesOrder = defaultGeometrySchema.ordering;
-  return featureData;
-}
-
-function parseHeaders(content: TileContent, arrayBuffer: ArrayBuffer) {
+function parseHeaders(tileset: I3STilesetHeader, arrayBuffer: ArrayBuffer) {
   let byteOffset = 0;
   // First 8 bytes reserved for header (vertexCount and featurecount)
   let vertexCount = 0;
   let featureCount = 0;
-  content.featureData.header.forEach(({property, type}) => {
+  for (const {property, type} of tileset.store.defaultGeometrySchema.header) {
     const TypedArrayTypeHeader = getConstructorForDataFormat(type);
-    if (property === I3S_NAMED_HEADER_ATTRIBUTES.vertexCount) {
-      // @ts-expect-error
-      vertexCount = new TypedArrayTypeHeader(arrayBuffer, 0, 4)[0];
-      byteOffset += sizeOf(type);
-    }
-    if (property === I3S_NAMED_HEADER_ATTRIBUTES.featureCount) {
-      // @ts-expect-error
-      featureCount = new TypedArrayTypeHeader(arrayBuffer, 4, 4)[0];
-      byteOffset += sizeOf(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,
@@ -332,7 +307,7 @@ function normalizeAttributes(
   vertexCount: number,
   attributesOrder: string[]
 ) {
-  const attributes: NormalizedAttributes = {};
+  const attributes: I3SMeshAttributes = {};
 
   // the order of attributes depend on the order being added to the vertexAttributes object
   for (const attribute of attributesOrder) {
@@ -351,13 +326,12 @@ function normalizeAttributes(
         break;
       }
       const buffer = arrayBuffer.slice(byteOffset);
-      let value: number[] | TypedArray = [];
+      let value: TypedArray;
 
       if (valueType === 'UInt64') {
         value = parseUint64Values(buffer, count * valuesPerElement, sizeOf(valueType));
       } else {
         const TypedArrayType = getConstructorForDataFormat(valueType);
-        // @ts-expect-error
         value = new TypedArrayType(buffer, 0, count * valuesPerElement);
       }
 
@@ -395,7 +369,7 @@ function parseUint64Values(
   buffer: ArrayBuffer,
   elementsCount: number,
   attributeSize: number
-): number[] {
+): Uint32Array {
   const values: number[] = [];
   const dataView = new DataView(buffer);
   let offset = 0;
@@ -411,10 +385,10 @@ function parseUint64Values(
     offset += attributeSize;
   }
 
-  return values;
+  return new Uint32Array(values);
 }
 
-function parsePositions(attribute: NormalizedAttribute, tile: Tile): Matrix4 {
+function parsePositions(attribute: I3SMeshAttribute, tile: I3STileHeader): Matrix4 {
   const mbs = tile.mbs;
   const value = attribute.value;
   const metadata = attribute.metadata;
@@ -466,7 +440,7 @@ function offsetsToCartesians(
  * @param positions positions attribute
  * @returns Matrix4 - model matrix for geometry transformation
  */
-function getModelMatrix(positions: NormalizedAttribute): Matrix4 {
+function getModelMatrix(positions: I3SMeshAttribute): Matrix4 {
   const metadata = positions.metadata;
   const scaleX: number = metadata?.['i3s-scale_x']?.double || 1;
   const scaleY: number = metadata?.['i3s-scale_y']?.double || 1;
@@ -483,7 +457,7 @@ function getModelMatrix(positions: NormalizedAttribute): Matrix4 {
  * @param texture - texture image
  * @returns {object}
  */
-function makePbrMaterial(materialDefinition: GLTFMaterial, texture: TileContentTexture) {
+function makePbrMaterial(materialDefinition?: I3SMaterialDefinition, texture?: TileContentTexture) {
   let pbrMaterial;
   if (materialDefinition) {
     pbrMaterial = {
@@ -521,7 +495,9 @@ function makePbrMaterial(materialDefinition: GLTFMaterial, texture: TileContentT
     );
   }
 
-  setMaterialTexture(pbrMaterial, texture);
+  if (texture) {
+    setMaterialTexture(pbrMaterial, texture);
+  }
 
   return pbrMaterial;
 }
@@ -576,7 +552,7 @@ function setMaterialTexture(material, image: TileContentTexture): void {
  * @param normalizedFeatureAttributes
  * @returns
  */
-function flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes: NormalizedAttributes): void {
+function flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes: I3SMeshAttributes): void {
   const {id, faceRange} = normalizedFeatureAttributes;
 
   if (!id || !faceRange) {
@@ -614,7 +590,7 @@ function flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes: NormalizedAt
  * @returns
  */
 function flattenFeatureIdsByFeatureIndices(
-  attributes: NormalizedAttributes,
+  attributes: I3SMeshAttributes,
   featureIds: Int32Array
 ): void {
   const featureIndices = attributes.id.value;
@@ -633,12 +609,7 @@ function flattenFeatureIdsByFeatureIndices(
  * @returns
  */
 function getFeatureIdsFromFeatureIndexMetadata(
-  featureIndex: NormalizedAttribute
+  featureIndex: I3SMeshAttribute
 ): Int32Array | undefined {
-  return (
-    featureIndex &&
-    featureIndex.metadata &&
-    featureIndex.metadata['i3s-feature-ids'] &&
-    featureIndex.metadata['i3s-feature-ids'].intArray
-  );
+  return featureIndex?.metadata?.['i3s-feature-ids']?.intArray;
 }