@loaders.gl/gltf 4.0.0-alpha.23 → 4.0.0-alpha.25

package/src/lib/extensions/deprecated/EXT_feature_metadata.ts

@@ -1,6 +1,6 @@
 /* eslint-disable camelcase */
+import type {GLTF} from '../../types/gltf-json-schema';
 import type {
-  GLTF,
   GLTF_EXT_feature_metadata_Class,
   GLTF_EXT_feature_metadata_ClassProperty,
   GLTF_EXT_feature_metadata_FeatureTable,
@@ -8,13 +8,16 @@ import type {
   GLTF_EXT_feature_metadata_FeatureTexture,
   GLTF_EXT_feature_metadata_GLTF,
   GLTF_EXT_feature_metadata_TextureAccessor
-} from '../../types/gltf-json-schema';
+} from '../../types/gltf-ext-feature-metadata-schema';
+import type {BigTypedArray, TypedArray} from '@loaders.gl/schema';
+import type {FeatureTableJson} from '../../types/gltf-types';
 import {GLTFScenegraph} from '../../api/gltf-scenegraph';
 import {getImageData} from '@loaders.gl/images';
 import {GLTFMeshPrimitive} from '../../types/gltf-json-schema';
-import {getComponentTypeFromArray} from '../../gltf-utils/gltf-utils';
+import {getComponentTypeFromArray, getFloat32ArrayForAccessor} from '../../gltf-utils/gltf-utils';
 import {GLTFLoaderOptions} from '../../../gltf-loader';
 import {emod} from '@loaders.gl/math';
+import {convertRawBufferToMetadataArray, getOffsetsForProperty} from '../utils/3d-tiles-utils';
 
 /** Extension name */
 const EXT_FEATURE_METADATA_NAME = 'EXT_feature_metadata';
@@ -25,6 +28,65 @@ export async function decode(gltfData: {json: GLTF}, options: GLTFLoaderOptions)
   decodeExtFeatureMetadata(scenegraph, options);
 }
 
+/**
+ * Handles EXT_feature_metadata to get property table.
+ * @param extension - Global level of EXT_FEATURE_METADATA extension.
+ * @param metadataClass - User selected feature metadata class name.
+ * @returns {FeatureTableJson | null} Property table or null if the extension can't be handled properly.
+ */
+export function getPropertyTableFromExtFeatureMetadata(
+  extension: GLTF_EXT_feature_metadata_GLTF,
+  metadataClass?: string
+): FeatureTableJson | null {
+  if (extension.featureTables) {
+    /**
+     * Take only first feature table to generate attributes storage info object.
+     * TODO: Think about getting data from all feature tables?
+     * It can be tricky just because 3dTiles is able to have multiple featureId attributes and multiple feature tables.
+     * In I3S we should decide which featureIds attribute will be passed to geometry data.
+     */
+    const firstFeatureTableName = Object.keys(extension.featureTables)?.[0];
+
+    if (firstFeatureTableName) {
+      const featureTable = extension.featureTables[firstFeatureTableName];
+      const propertyTable = {};
+
+      for (const propertyName in featureTable.properties) {
+        propertyTable[propertyName] = featureTable.properties[propertyName].data;
+      }
+
+      return propertyTable;
+    }
+  }
+
+  if (extension.featureTextures) {
+    let featureTexture: string | undefined;
+    for (const textureKey in extension.featureTextures) {
+      const texture = extension.featureTextures[textureKey];
+      if (texture.class === metadataClass) {
+        featureTexture = textureKey;
+      }
+    }
+
+    if (typeof featureTexture === 'string') {
+      const featureTable = extension.featureTextures[featureTexture];
+      const propertyTable = {};
+
+      for (const propertyName in featureTable.properties) {
+        propertyTable[propertyName] = featureTable.properties[propertyName].data;
+      }
+
+      return propertyTable;
+    }
+  }
+
+  // eslint-disable-next-line no-console
+  console.warn(
+    'Cannot get property table from EXT_feature_metadata extension. There is neither featureTables, nor featureTextures in the extension.'
+  );
+  return null;
+}
+
 /**
  * Decodes feature metadata from extension
  * @param scenegraph
@@ -125,24 +187,134 @@ function getPropertyDataFromBinarySource(
   schemaProperty: GLTF_EXT_feature_metadata_ClassProperty,
   numberOfFeatures: number,
   featureTableProperty: GLTF_EXT_feature_metadata_FeatureTableProperty
-): Uint8Array | string[] {
+): BigTypedArray | string[] {
   const bufferView = featureTableProperty.bufferView;
-  // TODO think maybe we shouldn't get data only in Uint8Array format.
   const dataArray: Uint8Array = scenegraph.getTypedArrayForBufferView(bufferView);
 
-  switch (schemaProperty.type) {
-    case 'STRING': {
-      // stringOffsetBufferView should be available for string type.
-      const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView!;
-      const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
-      return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
+  if (schemaProperty.type === 'STRING') {
+    const offsetsData = getStringOffsets(scenegraph, featureTableProperty, numberOfFeatures);
+    if (!offsetsData) {
+      return [];
     }
-    default:
+    return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
+  } else if (isNumericProperty(schemaProperty.type)) {
+    return getNumericAttributes(
+      dataArray,
+      schemaProperty.type as
+        | 'INT8'
+        | 'UINT8'
+        | 'INT16'
+        | 'UINT16'
+        | 'INT32'
+        | 'UINT32'
+        | 'INT64'
+        | 'UINT64'
+        | 'FLOAT32'
+        | 'FLOAT64',
+      numberOfFeatures
+    );
   }
 
   return dataArray;
 }
 
+/**
+ * Check if the feature table property is of numeric type
+ * @param schemaPropertyType - feature table property
+ * @returns true if property is numeric, else - false
+ */
+function isNumericProperty(
+  schemaPropertyType:
+    | 'INT8'
+    | 'UINT8'
+    | 'INT16'
+    | 'UINT16'
+    | 'INT32'
+    | 'UINT32'
+    | 'INT64'
+    | 'UINT64'
+    | 'FLOAT32'
+    | 'FLOAT64'
+    | 'BOOLEAN'
+    | 'STRING'
+    | 'ENUM'
+    | 'ARRAY'
+    | string
+): boolean {
+  return [
+    'UINT8',
+    'INT16',
+    'UINT16',
+    'INT32',
+    'UINT32',
+    'INT64',
+    'UINT64',
+    'FLOAT32',
+    'FLOAT64'
+  ].includes(schemaPropertyType);
+}
+
+/**
+ * Parse featureTable.property.stringOffsetBufferView.
+ * String offsets is an array of offsets of strings in the united array of charactersz
+ * @param scenegraph - Instance of the class for structured access to GLTF data
+ * @param propertyTableProperty - propertyTable's property metadata
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table
+ * @returns typed array with offset values
+ * @see https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/featureTable.property.schema.json#L50C10-L50C32
+ */
+function getStringOffsets(
+  scenegraph: GLTFScenegraph,
+  featureTableProperty: GLTF_EXT_feature_metadata_FeatureTableProperty,
+  numberOfElements: number
+): TypedArray | null {
+  if (typeof featureTableProperty.stringOffsetBufferView !== 'undefined') {
+    // Data are in a FIXED-length array
+    return getOffsetsForProperty(
+      scenegraph,
+      featureTableProperty.stringOffsetBufferView,
+      featureTableProperty.offsetType || 'UINT32', // UINT32 is the default by the spec
+      numberOfElements
+    );
+  }
+  return null;
+}
+
+/**
+ * Parse numeric property values
+ * @param valuesDataBytes - values data array
+ * @param propertyType - type of the property
+ * @param elementCount - number of rows in the featureTable
+ * @returns Number data in a typed array
+ */
+function getNumericAttributes(
+  valuesDataBytes: Uint8Array,
+  propertyType:
+    | 'INT8'
+    | 'UINT8'
+    | 'INT16'
+    | 'UINT16'
+    | 'INT32'
+    | 'UINT32'
+    | 'INT64'
+    | 'UINT64'
+    | 'FLOAT32'
+    | 'FLOAT64',
+  elementCount: number
+): BigTypedArray {
+  let valuesData = convertRawBufferToMetadataArray(
+    valuesDataBytes,
+    'SCALAR',
+    // The datatype of the element's components. Only applicable to `SCALAR`, `VECN`, and `MATN` types.
+    propertyType,
+    elementCount
+  );
+  if (!valuesData) {
+    valuesData = valuesDataBytes;
+  }
+  return valuesData;
+}
+
 /**
  * Get properties from texture associated with all mesh primitives.
  * @param scenegraph
@@ -208,16 +380,15 @@ function processPrimitiveTextures(
   const textureData: number[] = [];
   const texCoordAccessorKey = `TEXCOORD_${featureTextureProperty.texture.texCoord}`;
   const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
-  const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
-  const texCoordArray: Uint8Array = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
-
-  const textureCoordinates: Float32Array = new Float32Array(
-    texCoordArray.buffer,
-    texCoordArray.byteOffset,
-    texCoordArray.length / 4
-  );
   // textureCoordinates contains UV coordinates of the actual data stored in the texture
   // accessor.count is a number of UV pairs (they are stored as VEC2)
+  const textureCoordinates: Float32Array | null = getFloat32ArrayForAccessor(
+    scenegraph.gltf,
+    texCoordAccessorIndex
+  );
+  if (!textureCoordinates) {
+    return;
+  }
 
   const textureIndex = featureTextureProperty.texture.index;
   const texture = json.textures?.[textureIndex];
@@ -371,24 +542,16 @@ function findFeatureTextureByName(
  */
 function getStringAttributes(
   data: Uint8Array,
-  offsetsData: Uint8Array,
+  offsetsData: TypedArray,
   stringsCount: number
 ): string[] {
   const stringsArray: string[] = [];
   const textDecoder = new TextDecoder('utf8');
 
-  let stringOffset = 0;
-  const bytesPerStringSize = 4;
-
   for (let index = 0; index < stringsCount; index++) {
-    // TODO check if it is multiplication on bytesPerStringSize is valid operation?
-    const stringByteSize =
-      offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];
-    const stringData = data.subarray(stringOffset, stringByteSize + stringOffset);
+    const stringData = data.slice(offsetsData[index], offsetsData[index + 1]);
     const stringAttribute = textDecoder.decode(stringData);
-
     stringsArray.push(stringAttribute);
-    stringOffset += stringByteSize;
   }
 
   return stringsArray;

package/src/lib/extensions/{data-processing.ts → utils/3d-tiles-utils.ts}

@@ -1,12 +1,33 @@
-import type {GLTFTextureInfoMetadata, GLTFMeshPrimitive} from '../types/gltf-json-schema';
-import type {TypedArray} from '@loaders.gl/schema';
+/**
+ * loaders.gl, MIT license
+ *
+ * Shared code for 3DTiles extensions:
+ * * EXT_feature_metadata
+ * * EXT_mesh_features
+ * * EXT_structural_metadata
+ */
+
+import type {GLTFTextureInfoMetadata, GLTFMeshPrimitive} from '../../types/gltf-json-schema';
+import type {BigTypedArray, TypedArray} from '@loaders.gl/schema';
 import type {ImageType} from '@loaders.gl/images';
 
-import {GLTFScenegraph} from '../api/gltf-scenegraph';
-import {getComponentTypeFromArray} from '../gltf-utils/gltf-utils';
+import {GLTFScenegraph} from '../../api/gltf-scenegraph';
+import {getComponentTypeFromArray, getFloat32ArrayForAccessor} from '../../gltf-utils/gltf-utils';
 import {getImageData} from '@loaders.gl/images';
 import {emod} from '@loaders.gl/math';
 
+export type NumericComponentType =
+  | 'INT8'
+  | 'UINT8'
+  | 'INT16'
+  | 'UINT16'
+  | 'INT32'
+  | 'UINT32'
+  | 'INT64'
+  | 'UINT64'
+  | 'FLOAT32'
+  | 'FLOAT64';
+
 const ATTRIBUTE_TYPE_TO_COMPONENTS = {
   SCALAR: 1,
   VEC2: 2,
@@ -53,39 +74,79 @@ export function getArrayElementByteSize(attributeType, componentType): number {
   );
 }
 
+/**
+ * Gets offset array from `arrayOffsets` or `stringOffsets`.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param bufferViewIndex - Buffer view index
+ * @param offsetType - The type of values in `arrayOffsets` or `stringOffsets`.
+ * @param numberOfElements - The number of elements in each property array.
+ * @returns Array of values offsets. The number of offsets in the array is equal to `numberOfElements` plus one.
+ */
+export function getOffsetsForProperty(
+  scenegraph: GLTFScenegraph,
+  bufferViewIndex: number,
+  offsetType: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64' | string,
+  numberOfElements: number
+): TypedArray | null {
+  if (
+    offsetType !== 'UINT8' &&
+    offsetType !== 'UINT16' &&
+    offsetType !== 'UINT32' &&
+    offsetType !== 'UINT64'
+  ) {
+    return null;
+  }
+  const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(bufferViewIndex);
+  const arrayOffsets = convertRawBufferToMetadataArray(
+    arrayOffsetsBytes,
+    'SCALAR', // offsets consist of ONE component
+    offsetType,
+    numberOfElements + 1 // The number of offsets is equal to the property table `count` plus one.
+  );
+
+  // We don't support BigInt offsets at the moment. It requires additional logic and potential issues in Safari
+  if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {
+    return null;
+  }
+  return arrayOffsets;
+}
+
 /**
  * Converts raw bytes that are in the buffer to an array of the type defined by the schema.
- * @param {Uint8Array} typedArray - raw bytes in the buffer
- * @param {string} attributeType - SCALAR, VECN, MATN
- * @param {string} componentType - type of the component in elements, e.g. 'UINT8' or 'FLOAT32'
- * @param {number} elementCount - number of elements in the array. Default value is 1.
- * @returns {TypedArray} Data array
+ * @param data - Raw bytes in the buffer.
+ * @param attributeType - SCALAR, VECN, MATN.
+ * @param componentType - Type of the component in elements, e.g. 'UINT8' or 'FLOAT32'.
+ * @param elementCount - Number of elements in the array. Default value is 1.
+ * @returns Data array
  */
 export function convertRawBufferToMetadataArray(
-  typedArray: Uint8Array,
+  data: Uint8Array,
   attributeType: string,
-  componentType: string,
+  componentType: NumericComponentType,
   elementCount: number = 1
-): TypedArray {
+): BigTypedArray | null {
   const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType];
   const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[componentType];
-  const length = elementCount * numberOfComponents;
   const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType];
-  // the buffer view `byteOffset` must be aligned to a multiple of the `componentType` size.
-  const offset =
-    typedArray.byteOffset % size
-      ? Math.ceil(typedArray.byteOffset / size) * size
-      : typedArray.byteOffset;
-  return new ArrayType(typedArray.buffer, offset, length);
+  const length = elementCount * numberOfComponents;
+  const byteLength = length * size;
+  let buffer = data.buffer;
+  let offset = data.byteOffset;
+  if (offset % size !== 0) {
+    const bufferArray = new Uint8Array(buffer);
+    buffer = bufferArray.slice(offset, offset + byteLength).buffer;
+    offset = 0;
+  }
+  return new ArrayType(buffer, offset, length);
 }
 
 /**
  * Processes data encoded in the texture associated with the primitive.
  * If Ext_mesh_featues is combined with the Ext_structural_metadata, propertyTable will also be processed.
- * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
- * @param {GLTFTextureInfoMetadata} textureInfo - reference to the texture where extension data are stored.
- * @param {GLTFMeshPrimitive} primitive - primitive object in the mesh
- * @returns {number[] | null} Array of data taken. Null if data can't be taken from the texture.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param textureInfo - Reference to the texture where extension data are stored.
+ * @param primitive - Primitive object in the mesh.
+ * @returns Array of data taken. Null if data can't be taken from the texture.
  */
 export function getPrimitiveTextureData(
   scenegraph: GLTFScenegraph,
@@ -109,15 +170,14 @@ export function getPrimitiveTextureData(
 
   const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;
   const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
-  const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
-  const texCoordArray: Uint8Array = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
 
-  // textureCoordinates array contains UV coordinates of the actual data stored in the texture
-  const textureCoordinates: Float32Array = new Float32Array(
-    texCoordArray.buffer,
-    texCoordArray.byteOffset,
-    texCoordArray.length / 4
+  const textureCoordinates: Float32Array | null = getFloat32ArrayForAccessor(
+    scenegraph.gltf,
+    texCoordAccessorIndex
   );
+  if (!textureCoordinates) {
+    return null;
+  }
 
   const textureIndex: number = textureInfo.index;
   const imageIndex = json.textures?.[textureIndex]?.source;
@@ -147,11 +207,11 @@ export function getPrimitiveTextureData(
  * Puts property data to attributes.
  * It creates corresponding buffer, bufferView and accessor
  * so the data can be accessed like regular data stored in buffers.
- * @param {GLTFScenegraph} scenegraph - scenegraph object
- * @param {string} attributeName - name of the attribute
- * @param {number[]} propertyData - property data to store
- * @param {number[]} featureTable - an array where unique data from the property data are being stored
- * @param {GLTFMeshPrimitive} primitive - primitive object
+ * @param scenegraph - Scenegraph object.
+ * @param attributeName - Name of the attribute.
+ * @param propertyData - Property data to store.
+ * @param featureTable - Array where unique data from the property data are being stored.
+ * @param primitive - Primitive object.
  */
 export function primitivePropertyDataToAttributes(
   scenegraph: GLTFScenegraph,
@@ -160,7 +220,10 @@ export function primitivePropertyDataToAttributes(
   featureTable: number[],
   primitive: GLTFMeshPrimitive
 ): void {
-  if (propertyData === null) return;
+  // No reason to create an empty buffer if there is no property data to store.
+  if (!propertyData?.length) {
+    return;
+  }
   /*
     featureTable will contain unique values, e.g.
     propertyData = [24, 35, 28, 24]
@@ -194,26 +257,26 @@ export function primitivePropertyDataToAttributes(
 
 /**
  * Gets the value from the texture by coordinates provided.
- * @param {ImageType} parsedImage - image where the data are stored.
- * @param {string | undefined} mimeType - MIME type
- * @param {Float32Array} textureCoordinates - uv coordinates to access data in the image.
- * @param {number} index - index of uv coordinates in the array textureCoordinates
- * @param {channels} channels - image channels where data are stored. Channels of an RGBA texture are numbered 0..3 respectively.
- * @returns {number} Value taken from the image.
+ * @param parsedImage - Image where the data are stored.
+ * @param mimeType - MIME type.
+ * @param textureCoordinates - uv coordinates to access data in the image.
+ * @param index - Index of uv coordinates in the array textureCoordinates.
+ * @param channels - Image channels where data are stored. Channels of an RGBA texture are numbered 0..3 respectively.
+ * @returns Value taken from the image.
  */
 function getImageValueByCoordinates(
   parsedImage: ImageType,
   mimeType: string | undefined,
   textureCoordinates: Float32Array,
   index: number,
-  channels: number[] = [0]
+  channels: number[] | string = [0]
 ) {
-  const CHANNELS_MAP = [
-    {offset: 0, shift: 0},
-    {offset: 1, shift: 8},
-    {offset: 2, shift: 16},
-    {offset: 3, shift: 24}
-  ];
+  const CHANNELS_MAP = {
+    r: {offset: 0, shift: 0},
+    g: {offset: 1, shift: 8},
+    b: {offset: 2, shift: 16},
+    a: {offset: 3, shift: 24}
+  };
 
   const u = textureCoordinates[index];
   const v = textureCoordinates[index + 1];
@@ -224,7 +287,16 @@ function getImageValueByCoordinates(
   const offset = coordinatesToOffset(u, v, parsedImage, components);
   let value: number = 0;
   for (const c of channels) {
-    const map = CHANNELS_MAP[c];
+    /*
+    According to the EXT_feature_metadata extension specification:
+      Channels are labeled by rgba and are swizzled with a string of 1-4 characters.
+    According to the EXT_mesh_features extension specification:
+      The channels array contains non-negative integer values corresponding to channels of the source texture that the feature ID consists of.
+      Channels of an RGBA texture are numbered 0–3 respectively.
+    Function getImageValueByCoordinates is used to process both extensions. 
+    So, there should be possible to get the element of CHANNELS_MAP by either index (0, 1, 2, 3) or key (r, g, b, a).
+    */
+    const map = typeof c === 'number' ? Object.values(CHANNELS_MAP)[c] : CHANNELS_MAP[c];
     const imageOffset = offset + map.offset;
     const imageData = getImageData(parsedImage);
     if (imageData.data.length <= imageOffset) {
@@ -237,12 +309,12 @@ function getImageValueByCoordinates(
 }
 
 /**
- * Retrieves the offset in the image where the data are stored
- * @param u - u-coordinate
- * @param v - v-coordinate
- * @param parsedImage - image where the data are stored
- * @param componentsCount - number of components the data consists of.
- * @returns offset in the image where the data are stored
+ * Retrieves the offset in the image where the data are stored.
+ * @param u - u-coordinate.
+ * @param v - v-coordinate.
+ * @param parsedImage - Image where the data are stored.
+ * @param componentsCount - Number of components the data consists of.
+ * @returns Offset in the image where the data are stored.
  */
 function coordinatesToOffset(
   u: number,

package/src/lib/gltf-utils/gltf-utils.ts

@@ -1,5 +1,8 @@
 import {assert} from '../utils/assert';
+
+import type {GLTFWithBuffers} from '../types/gltf-types';
 import type {GLTFPostprocessed} from '../types/gltf-postprocessed-schema';
+import {BYTES, COMPONENTS} from '../gltf-utils/gltf-constants';
 
 /**
  * Memory needed to store texture and all mipmap levels 1 + 1/4 + 1/16 + 1/64 + ...
@@ -85,6 +88,41 @@ export function getAccessorArrayTypeAndLength(accessor, bufferView) {
   return {ArrayType, length, byteLength};
 }
 
+export function getFloat32ArrayForAccessor(
+  gltfData: GLTFWithBuffers,
+  texCoordAccessor: number
+): Float32Array | null {
+  const accessor = gltfData.json.accessors?.[texCoordAccessor];
+  if (accessor && typeof accessor.bufferView !== 'undefined') {
+    // Get `bufferView` of the `accessor`
+    const bufferView = gltfData.json.bufferViews?.[accessor.bufferView];
+    if (bufferView) {
+      // Get `arrayBuffer` the `bufferView` look at
+      const {arrayBuffer, byteOffset: bufferByteOffset} = gltfData.buffers[bufferView.buffer];
+      // Resulting byteOffset is sum of the buffer, accessor and bufferView byte offsets
+      const byteOffset =
+        (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);
+      // Deduce TypedArray type and its length from `accessor` and `bufferView` data
+      const {ArrayType, length} = getAccessorArrayTypeAndLength(accessor, bufferView);
+      // Number of bytes each component occupies
+      const bytes = BYTES[accessor.componentType];
+      // Number of components. For the `TEXCOORD_0` with `VEC2` type, it must return 2
+      const components = COMPONENTS[accessor.type];
+      // Multiplier to calculate the address of the `TEXCOORD_0` element in the arrayBuffer
+      const elementAddressScale = bufferView.byteStride || bytes * components;
+      // Data transform to Float32Array
+      const result = new Float32Array(length);
+      for (let i = 0; i < accessor.count; i++) {
+        // Take [u, v] couple from the arrayBuffer
+        const uv = new ArrayType(arrayBuffer, byteOffset + i * elementAddressScale, 2);
+        result.set(uv, i * components);
+      }
+      return result;
+    }
+  }
+  return null;
+}
+
 /**
  * Calculate the GPU memory used by a GLTF tile, for both buffer and texture memory
  * @param gltf - the gltf content of a GLTF tile