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

package/dist/lib/extensions/EXT_mesh_features.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.name = void 0;
+const gltf_scenegraph_1 = require("../api/gltf-scenegraph");
+const data_processing_1 = require("./data-processing");
+const EXT_structural_metadata_1 = require("./EXT_structural_metadata");
+const EXT_MESH_FEATURES_NAME = 'EXT_mesh_features';
+exports.name = EXT_MESH_FEATURES_NAME;
+async function decode(gltfData, options) {
+    const scenegraph = new gltf_scenegraph_1.GLTFScenegraph(gltfData);
+    decodeExtMeshFeatures(scenegraph, options);
+}
+exports.decode = decode;
+/**
+ * Decodes feature metadata from extension
+ * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
+ * @param {GLTFLoaderOptions} options - loader options.
+ */
+function decodeExtMeshFeatures(scenegraph, options) {
+    const json = scenegraph.gltf.json;
+    if (!json.meshes) {
+        return;
+    }
+    // Iterate through all meshes/primitives.
+    for (const mesh of json.meshes) {
+        for (const primitive of mesh.primitives) {
+            processMeshPrimitiveFeatures(scenegraph, primitive, options);
+        }
+    }
+}
+/**
+ * Takes data from EXT_mesh_features and store it in 'data' property of featureIds.
+ * If combined with EXT_structural_metadata, corresponding data are taken from the property tables of that extension.
+ * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
+ * @param {GLTFMeshPrimitive} primitive - primitive that contains extensions.
+ * @param {GLTFLoaderOptions} options - loader options.
+ */
+function processMeshPrimitiveFeatures(scenegraph, primitive, options) {
+    const extension = primitive.extensions?.[EXT_MESH_FEATURES_NAME];
+    const featureIds = extension?.featureIds;
+    if (!featureIds)
+        return;
+    if (!extension.dataAttributeNames) {
+        extension.dataAttributeNames = [];
+    }
+    let featureIdCount = 0; // It can be used to name the feature if neither label nor property table name is provided.
+    for (const featureId of featureIds) {
+        /*
+          When combined with the EXT_structural_metadata extension, feature ID sets can be associated with property tables.
+          A property table maps each feature ID to a set of values that are associated with the respective feature.
+          The feature ID in this case serves as an index for the row of the table.
+          The index of the property table that a certain set of feature IDs is associated with is stored in the propertyTable of the feature ID set definition.
+        */
+        let propertyTable = null;
+        if (typeof featureId.propertyTable === 'number') {
+            propertyTable = (0, EXT_structural_metadata_1.getPropertyTablePopulated)(scenegraph, featureId.propertyTable);
+        }
+        let propertyData = null;
+        // Process "Feature ID by Vertex"
+        if (typeof featureId.attribute !== 'undefined') {
+            const accessorKey = `_FEATURE_ID_${featureId.attribute}`;
+            const accessorIndex = primitive.attributes[accessorKey];
+            const propertyDataTypedArray = scenegraph.getTypedArrayForAccessor(accessorIndex);
+            propertyData = Array.prototype.slice.call(propertyDataTypedArray);
+        }
+        // Process "Feature ID by Texture Coordinates"
+        else if (typeof featureId.texture !== 'undefined' && options?.gltf?.loadImages) {
+            propertyData = (0, data_processing_1.getPrimitiveTextureData)(scenegraph, featureId.texture, primitive);
+        }
+        // Process "Feature ID by Index"
+        else {
+            /*
+            When both featureId.attribute and featureId.texture are undefined,
+            then the feature ID value for each vertex is given implicitly, via the index of the vertex.
+            In this case, the featureCount must match the number of vertices of the mesh primitive.
+            */
+            // TODO: At the moment of writing we don't have a tileset with the data of that kind. Implement it later.
+        }
+        const attributeName = featureId.label || propertyTable?.name || `featureAttribute${featureIdCount}`;
+        // featureTable - an array where unique data from the property data are being stored
+        const featureTable = [];
+        if (propertyData) {
+            (0, data_processing_1.primitivePropertyDataToAttributes)(scenegraph, attributeName, propertyData, featureTable, primitive);
+        }
+        extension.dataAttributeNames.push(attributeName);
+        featureId.data = featureTable;
+        featureIdCount++;
+    }
+}

package/dist/lib/extensions/EXT_structural_metadata.d.ts

@@ -0,0 +1,17 @@
+import type { GLTF } from '../types/gltf-json-schema';
+import type { GLTF_EXT_structural_metadata_PropertyTable } from '../types/gltf-ext-structural-metadata-schema';
+import type { GLTFLoaderOptions } from '../../gltf-loader';
+import { GLTFScenegraph } from '../api/gltf-scenegraph';
+export declare const name = "EXT_structural_metadata";
+export declare function decode(gltfData: {
+    json: GLTF;
+}, options: GLTFLoaderOptions): Promise<void>;
+/**
+ * Returns the property table populated with the data taken according to the extension schema.
+ * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
+ * @param {number} propertyTableIndex - Index of the property table to locate.
+ * @returns {GLTF_EXT_structural_metadata_PropertyTable} Property table populated with the data.
+ * Throws an exception if no property table was found for propertyTableIndex provided.
+ */
+export declare function getPropertyTablePopulated(scenegraph: GLTFScenegraph, propertyTableIndex: number): GLTF_EXT_structural_metadata_PropertyTable;
+//# sourceMappingURL=EXT_structural_metadata.d.ts.map

package/dist/lib/extensions/EXT_structural_metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EXT_structural_metadata.d.ts","sourceRoot":"","sources":["../../../src/lib/extensions/EXT_structural_metadata.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,IAAI,EAA6C,MAAM,2BAA2B,CAAC;AAChG,OAAO,KAAK,EAKV,0CAA0C,EAK3C,MAAM,8CAA8C,CAAC;AAGtD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAC,cAAc,EAAC,MAAM,wBAAwB,CAAC;AAStD,eAAO,MAAM,IAAI,4BAA+B,CAAC;AAEjD,wBAAsB,MAAM,CAAC,QAAQ,EAAE;IAAC,IAAI,EAAE,IAAI,CAAA;CAAC,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAG9F;AA2DD;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,cAAc,EAC1B,kBAAkB,EAAE,MAAM,GACzB,0CAA0C,CAY5C"}

package/dist/lib/extensions/EXT_structural_metadata.js

@@ -0,0 +1,504 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropertyTablePopulated = exports.decode = exports.name = void 0;
+const gltf_scenegraph_1 = require("../api/gltf-scenegraph");
+const data_processing_1 = require("./data-processing");
+const EXT_STRUCTURAL_METADATA_NAME = 'EXT_structural_metadata';
+exports.name = EXT_STRUCTURAL_METADATA_NAME;
+async function decode(gltfData, options) {
+    const scenegraph = new gltf_scenegraph_1.GLTFScenegraph(gltfData);
+    decodeExtStructuralMetadata(scenegraph, options);
+}
+exports.decode = decode;
+/*
+// Example of the extension.
+// See more info at https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata
+const extensions = {
+  "extensions": {
+    "EXT_structural_metadata": {
+      "schema": {
+        "classes": {
+          "tree": {
+            "name": "Tree",
+            "description": "Woody, perennial plant.",
+            "properties": {
+              "species": {
+                "description": "Type of tree.",
+                "type": "ENUM",
+                "enumType": "speciesEnum",
+                "required": true
+              },
+              "age": {
+                "description": "The age of the tree, in years",
+                "type": "SCALAR",
+                "componentType": "UINT8",
+                "required": true
+              }
+            }
+          }
+        },
+        "enums": {
+          "speciesEnum": {
+            "name": "Species",
+            "description": "An example enum for tree species.",
+            // valueType is not defined here. Default is "UINT16"
+            "values": [
+              { "name": "Unspecified", "value": 0 },
+              { "name": "Oak", "value": 1 }
+            ]
+          }
+        }
+      },
+      "propertyTables": [{
+        "name": "tree_survey_2021-09-29",
+        "class": "tree",
+        "count": 10,  // The number of elements in each property array (in `species`, in `age`).
+        "properties": {
+          "species": {
+            "values": 0, // It's an index of the buffer view containing property values.
+          },
+          "age": {
+            "values": 1
+          }
+        }
+      }]
+    }
+  }
+}
+*/
+/**
+ * Returns the property table populated with the data taken according to the extension schema.
+ * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
+ * @param {number} propertyTableIndex - Index of the property table to locate.
+ * @returns {GLTF_EXT_structural_metadata_PropertyTable} Property table populated with the data.
+ * Throws an exception if no property table was found for propertyTableIndex provided.
+ */
+function getPropertyTablePopulated(scenegraph, propertyTableIndex) {
+    const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
+    const propertyTable = extension?.propertyTables?.[propertyTableIndex];
+    if (extension?.schema && propertyTable) {
+        processPropertyTable(scenegraph, extension.schema, propertyTable);
+        return propertyTable;
+    }
+    throw new Error(`Incorrect data in the EXT_structural_metadata extension: no property table with index ${propertyTableIndex}`);
+}
+exports.getPropertyTablePopulated = getPropertyTablePopulated;
+/**
+ * Decodes feature metadata from extension
+ * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
+ * @param {GLTFLoaderOptions} options - loader options.
+ */
+function decodeExtStructuralMetadata(scenegraph, options) {
+    const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
+    if (!extension?.schema) {
+        return;
+    }
+    const propertyTextures = extension.propertyTextures;
+    const json = scenegraph.gltf.json;
+    if (propertyTextures && json.meshes && options?.gltf?.loadImages) {
+        // Iterate through all meshes/primitives.
+        for (const mesh of json.meshes) {
+            for (const primitive of mesh.primitives) {
+                processPrimitivePropertyTextures(scenegraph, propertyTextures, primitive, extension);
+            }
+        }
+    }
+    const schemaClasses = extension.schema.classes;
+    const propertyTables = extension.propertyTables;
+    if (schemaClasses && propertyTables) {
+        for (const schemaName in schemaClasses) {
+            const propertyTable = findPropertyTableByClass(propertyTables, schemaName);
+            if (propertyTable) {
+                processPropertyTable(scenegraph, extension.schema, propertyTable);
+            }
+        }
+    }
+}
+/**
+ * Takes data from property textures reffered by the primitive
+ * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
+ * @param {GLTF_EXT_structural_metadata_PropertyTexture[]} propertyTextures - propertyTexture definition taken from the top-level extention
+ * @param {GLTFMeshPrimitive} primitive - Primitive object
+ * @param {GLTF_EXT_structural_metadata} extension - top-level extension
+ */
+function processPrimitivePropertyTextures(scenegraph, propertyTextures, primitive, extension) {
+    if (!propertyTextures) {
+        return;
+    }
+    const primitiveExtension = primitive.extensions?.[EXT_STRUCTURAL_METADATA_NAME];
+    const primitivePropertyTextureIndices = primitiveExtension?.propertyTextures;
+    if (!primitivePropertyTextureIndices) {
+        return;
+    }
+    for (const primitivePropertyTextureIndex of primitivePropertyTextureIndices) {
+        const propertyTexture = propertyTextures[primitivePropertyTextureIndex];
+        processPrimitivePropertyTexture(scenegraph, propertyTexture, primitive, extension);
+    }
+}
+/**
+ * Takes property data from the texture pointed by the primitive and appends them to `exension.data`
+ * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
+ * @param {GLTF_EXT_structural_metadata_PropertyTexture} propertyTexture - propertyTexture definition taken from the top-level extension.
+ * @param {GLTFMeshPrimitive} primitive - Primitive object
+ * @param {GLTF_EXT_structural_metadata} extension - top-level extension
+ */
+function processPrimitivePropertyTexture(scenegraph, propertyTexture, primitive, extension) {
+    if (!propertyTexture.properties) {
+        return;
+    }
+    if (!extension.dataAttributeNames) {
+        extension.dataAttributeNames = [];
+    }
+    /* Iterate through all properties defined in propertyTexture, e.g. "speed" and "direction":
+      {
+        "class": "wind",
+        "properties": {
+          "speed": {
+            "index": 0,
+            "texCoord": 0,
+            "channels": [0]
+          },
+          "direction": {
+            "index": 0,
+            "texCoord": 0,
+            "channels": [1, 2]
+          }
+        }
+      }
+    */
+    const className = propertyTexture.class;
+    for (const propName in propertyTexture.properties) {
+        // propName has values like "speed", "direction"
+        // Make attributeName as a combination of the class name and the propertyName like "wind_speed" or "wind_direction"
+        const attributeName = `${className}_${propName}`;
+        const textureInfoTopLevel = propertyTexture.properties?.[propName];
+        if (!textureInfoTopLevel) {
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        // The data taken from all meshes/primitives (the same property, e.g. "speed" or "direction") will be combined into one array and saved in textureInfoTopLevel.data
+        // Initially textureInfoTopLevel.data will be initialized with an empty array.
+        if (!textureInfoTopLevel.data) {
+            textureInfoTopLevel.data = [];
+        }
+        const featureTextureTable = textureInfoTopLevel.data;
+        const propertyData = (0, data_processing_1.getPrimitiveTextureData)(scenegraph, textureInfoTopLevel, primitive);
+        if (propertyData === null) {
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        (0, data_processing_1.primitivePropertyDataToAttributes)(scenegraph, attributeName, propertyData, featureTextureTable, primitive);
+        textureInfoTopLevel.data = featureTextureTable;
+        extension.dataAttributeNames.push(attributeName);
+    }
+}
+/**
+ * Navigates through all properies in the property table, gets properties data,
+ * and put the data to `propertyTable.data` as an array.
+ * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
+ * @param {GLTF_EXT_structural_metadata_Schema} schema - schema object
+ * @param {GLTF_EXT_structural_metadata_PropertyTable} propertyTable - propertyTable definition taken from the top-level extension
+ */
+function processPropertyTable(scenegraph, schema, propertyTable) {
+    const schemaClass = schema.classes?.[propertyTable.class];
+    if (!schemaClass) {
+        throw new Error(`Incorrect data in the EXT_structural_metadata extension: no schema class with name ${propertyTable.class}`);
+    }
+    const numberOfElements = propertyTable.count; // `propertyTable.count` is a number of elements in each property array.
+    for (const propertyName in schemaClass.properties) {
+        const classProperty = schemaClass.properties[propertyName];
+        const propertyTableProperty = propertyTable.properties?.[propertyName];
+        if (propertyTableProperty) {
+            // Getting all elements (`numberOfElements`) of the array in the `propertyTableProperty`
+            const data = getPropertyDataFromBinarySource(scenegraph, schema, classProperty, numberOfElements, propertyTableProperty);
+            propertyTableProperty.data = data;
+        }
+    }
+}
+/**
+ * Decodes properties from binary sourse based on property type.
+ * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
+ * @param {GLTF_EXT_structural_metadata_Schema} schema - Schema object
+ * @param {GLTF_EXT_structural_metadata_ClassProperty} classProperty - class property object
+ * @param {GLTF_EXT_structural_metadata_PropertyTable_Property} propertyTableProperty
+ * @param {number} numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @returns {string[] | number[] | string[][] | number[][]}
+ */
+/* eslint complexity: ["error", 17]*/
+function getPropertyDataFromBinarySource(scenegraph, schema, classProperty, numberOfElements, propertyTableProperty) {
+    let data = [];
+    const valuesBufferView = propertyTableProperty.values;
+    const valuesDataBytes = scenegraph.getTypedArrayForBufferView(valuesBufferView);
+    let arrayOffsets = null;
+    if (classProperty.array &&
+        // `count` is a number of array elements. May only be defined when `array` is true.
+        typeof classProperty.count === 'undefined' && // If `count` is NOT defined, it's a VARIABLE-length array
+        typeof propertyTableProperty.arrayOffsets !== 'undefined' && // `arrayOffsets` is an index of the buffer view containing offsets for variable-length arrays.
+        typeof propertyTableProperty.arrayOffsetType !== 'undefined') {
+        // Data are in a VARIABLE-length array
+        arrayOffsets = getOffsetArray(scenegraph, propertyTableProperty.arrayOffsets, propertyTableProperty.arrayOffsetType, numberOfElements);
+    }
+    let stringOffsets = null;
+    if (typeof propertyTableProperty.stringOffsets !== 'undefined' && // `stringOffsets` is an index of the buffer view containing offsets for strings.
+        typeof propertyTableProperty.stringOffsetType !== 'undefined') {
+        // Data are in a FIXED-length array
+        stringOffsets = getOffsetArray(scenegraph, propertyTableProperty.stringOffsets, propertyTableProperty.stringOffsetType, numberOfElements);
+    }
+    switch (classProperty.type) {
+        case 'SCALAR':
+        case 'VEC2':
+        case 'VEC3':
+        case 'VEC4':
+        case 'MAT2':
+        case 'MAT3':
+        case 'MAT4': {
+            data = getPropertyDataNumeric(classProperty, numberOfElements, valuesDataBytes, arrayOffsets);
+            break;
+        }
+        case 'BOOLEAN': {
+            // TODO: implement it as soon as we have the corresponding tileset
+            throw new Error(`Not implemented - classProperty.type=${classProperty.type}`);
+        }
+        case 'STRING': {
+            data = getPropertyDataString(classProperty, numberOfElements, valuesDataBytes, arrayOffsets, stringOffsets);
+            break;
+        }
+        case 'ENUM': {
+            data = getPropertyDataENUM(schema, classProperty, numberOfElements, valuesDataBytes, arrayOffsets);
+            break;
+        }
+        default:
+            throw new Error(`Unknown classProperty type ${classProperty.type}`);
+    }
+    return data;
+}
+/**
+ * Gets offset array from `arrayOffsets` or `stringOffsets`.
+ * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
+ * @param {number} offsets - Buffer view index
+ * @param offsetType - The type of values in `arrayOffsets` or `stringOffsets`.
+ * @param {number} numberOfElements - The number of elements in each property array.
+ * @returns {TypedArray}
+ */
+function getOffsetArray(scenegraph, offsets, offsetType, numberOfElements) {
+    const arrayOffsetsBufferView = offsets;
+    const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(arrayOffsetsBufferView);
+    const arrayOffsets = (0, data_processing_1.convertRawBufferToMetadataArray)(arrayOffsetsBytes, 'SCALAR', // offsets consist of ONE component
+    offsetType, numberOfElements + 1 // The number of offsets is equal to the property table `count` plus one.
+    );
+    return arrayOffsets;
+}
+/**
+ * Decodes properties of SCALAR, VEC-N, MAT-N types from binary sourse.
+ * @param {GLTF_EXT_structural_metadata_ClassProperty} classProperty - class property object
+ * @param {number} numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @param {Uint8Array} valuesDataBytes - data taken from values property of the property table property.
+ * @param {TypedArray | null} arrayOffsets - offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.
+ * @returns {number[] | number[][]}
+ */
+function getPropertyDataNumeric(classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
+    const isArray = classProperty.array;
+    const arrayCount = classProperty.count;
+    const elementSize = (0, data_processing_1.getArrayElementByteSize)(classProperty.type, classProperty.componentType);
+    const elementCount = valuesDataBytes.byteLength / elementSize;
+    let valuesData;
+    if (classProperty.componentType) {
+        valuesData = (0, data_processing_1.convertRawBufferToMetadataArray)(valuesDataBytes, classProperty.type, classProperty.componentType, // The datatype of the element's components. Only applicable to `SCALAR`, `VECN`, and `MATN` types.
+        elementCount);
+    }
+    else {
+        // The spec doesn't provide any info what to do if componentType is not set.
+        valuesData = valuesDataBytes;
+    }
+    if (isArray) {
+        if (arrayOffsets) {
+            // VARIABLE-length array
+            return handleVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
+        }
+        if (arrayCount) {
+            // FIXED-length array
+            return handleFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
+        }
+        return [];
+    }
+    // Single value (not an array)
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+        const value = valuesData[index];
+        attributeValueArray.push(value);
+    }
+    return attributeValueArray;
+}
+function handleVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, elementSize) {
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+        const array = [];
+        const arrayOffset = arrayOffsets[index];
+        const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
+        if (arrayByteSize + arrayOffset <= valuesDataBytesLength) {
+            const typedArrayOffset = arrayOffset / elementSize;
+            const elementCount = arrayByteSize / elementSize;
+            for (let i = 0; i < elementCount; i++) {
+                const value = valuesData[typedArrayOffset + i];
+                array.push(value);
+            }
+        }
+        attributeValueArray.push(array);
+    }
+    return attributeValueArray;
+}
+function handleFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount) {
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+        const array = [];
+        for (let i = 0; i < arrayCount; i++) {
+            const value = valuesData[i];
+            array.push(value);
+        }
+        attributeValueArray.push(array);
+    }
+    return attributeValueArray;
+}
+/**
+ * Decodes properties of string type from binary sourse.
+ * @param {GLTF_EXT_structural_metadata_ClassProperty} classProperty - class property object
+ * @param {number} numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @param {Uint8Array} valuesDataBytes - data taken from values property of the property table property.
+ * @param {TypedArray | null} arrayOffsets - offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.
+ * @param {TypedArray | null} stringOffsets - index of the buffer view containing offsets for strings. It should be available for string type.
+ * @returns {string[] | string[][]}
+ */
+function getPropertyDataString(classProperty, numberOfElements, valuesDataBytes, arrayOffsets, stringOffsets) {
+    if (arrayOffsets) {
+        // TODO: implement it as soon as we have the corresponding tileset
+        throw new Error(`Not implemented - classProperty.type=${classProperty.type}`);
+    }
+    if (stringOffsets) {
+        const stringsArray = [];
+        const textDecoder = new TextDecoder('utf8');
+        let stringOffset = 0;
+        for (let index = 0; index < numberOfElements; index++) {
+            const stringByteSize = stringOffsets[index + 1] - stringOffsets[index];
+            if (stringByteSize + stringOffset <= valuesDataBytes.length) {
+                const stringData = valuesDataBytes.subarray(stringOffset, stringByteSize + stringOffset);
+                const stringAttribute = textDecoder.decode(stringData);
+                stringsArray.push(stringAttribute);
+                stringOffset += stringByteSize;
+            }
+        }
+        return stringsArray;
+    }
+    return [];
+}
+/**
+ * Decodes properties of enum type from binary sourse.
+ * @param {GLTF_EXT_structural_metadata_Schema} schema - schema object
+ * @param {GLTF_EXT_structural_metadata_ClassProperty} classProperty - class property object
+ * @param {number} numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @param {Uint8Array} valuesDataBytes - data taken from values property of the property table property.
+ * @param {TypedArray | null} arrayOffsets - offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.
+ * @returns {string[] | string[][]}
+ */
+function getPropertyDataENUM(schema, classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
+    const data = [];
+    const isArray = classProperty.array;
+    const arrayCount = classProperty.count;
+    const enumType = classProperty.enumType;
+    // Enum ID as declared in the `enums` dictionary. Required when `type` is `ENUM`.
+    if (!enumType) {
+        throw new Error('Incorrect data in the EXT_structural_metadata extension: classProperty.enumType is not set for type ENUM');
+    }
+    const enumEntry = schema.enums?.[enumType];
+    if (!enumEntry) {
+        throw new Error(`Incorrect data in the EXT_structural_metadata extension: schema.enums does't contain ${enumType}`);
+    }
+    const enumValueType = enumEntry.valueType || 'UINT16';
+    const elementSize = (0, data_processing_1.getArrayElementByteSize)(classProperty.type, enumValueType);
+    const elementCount = valuesDataBytes.byteLength / elementSize;
+    const valuesData = (0, data_processing_1.convertRawBufferToMetadataArray)(valuesDataBytes, classProperty.type, enumValueType, elementCount);
+    if (isArray) {
+        if (arrayOffsets) {
+            // VARIABLE-length array
+            return handleVariableLengthArrayENUM(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize, enumEntry);
+        }
+        if (arrayCount) {
+            // FIXED-length array
+            return handleFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry);
+        }
+        return [];
+    }
+    // Single value (not an array)
+    for (let index = 0; index < numberOfElements; index++) {
+        const enumValue = valuesData[index];
+        const enumObject = getEnumByValue(enumEntry, enumValue);
+        if (enumObject) {
+            data.push(enumObject.name);
+        }
+    }
+    return data;
+}
+/* eslint max-params: ["error", 6]*/
+function handleVariableLengthArrayENUM(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, elementSize, enumEntry) {
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+        const array = [];
+        const arrayOffset = arrayOffsets[index];
+        const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
+        if (arrayByteSize + arrayOffset <= valuesDataBytesLength) {
+            const typedArrayOffset = arrayOffset / elementSize;
+            const elementCount = arrayByteSize / elementSize;
+            for (let i = 0; i < elementCount; i++) {
+                const value = valuesData[typedArrayOffset + i];
+                const enumObject = getEnumByValue(enumEntry, value);
+                if (enumObject) {
+                    array.push(enumObject.name);
+                }
+            }
+        }
+        attributeValueArray.push(array);
+    }
+    return attributeValueArray;
+}
+function handleFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry) {
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+        const array = [];
+        for (let i = 0; i < arrayCount; i++) {
+            const value = valuesData[i];
+            const enumObject = getEnumByValue(enumEntry, value);
+            if (enumObject) {
+                array.push(enumObject.name);
+            }
+        }
+        attributeValueArray.push(array);
+    }
+    return attributeValueArray;
+}
+/**
+ * Find the property table by class name.
+ * @param {GLTF_EXT_structural_metadata_PropertyTable[]} propertyTables
+ * @param {string} schemaClassName
+ */
+function findPropertyTableByClass(propertyTables, schemaClassName) {
+    for (let i = 0, len = propertyTables.length; i < len; i++) {
+        const propertyTable = propertyTables[i];
+        if (propertyTable.class === schemaClassName) {
+            return propertyTable;
+        }
+    }
+    return null;
+}
+/**
+ * Looks up ENUM whose `value` property matches the specified number in the parameter `value`.
+ * @param {GLTF_EXT_structural_metadata_Enum} enumEntry - ENUM entry containing the array of possible enums.
+ * @param {number} value - the value of the ENUM to locate.
+ * @returns {GLTF_EXT_structural_metadata_EnumValue | null} ENUM matcihng the specified value or null of no ENUM object was found.
+ */
+function getEnumByValue(enumEntry, value) {
+    for (const enumValue of enumEntry.values) {
+        if (enumValue.value === value) {
+            return enumValue;
+        }
+    }
+    return null;
+}

package/dist/lib/extensions/data-processing.d.ts

@@ -0,0 +1,34 @@
+import type { GLTFTextureInfoMetadata, GLTFMeshPrimitive } from '../types/gltf-json-schema';
+import type { TypedArray } from '@loaders.gl/schema';
+import { GLTFScenegraph } from '../api/gltf-scenegraph';
+export declare function getArrayElementByteSize(attributeType: any, componentType: any): number;
+/**
+ * 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
+ */
+export declare function convertRawBufferToMetadataArray(typedArray: Uint8Array, attributeType: string, componentType: string, elementCount?: number): TypedArray;
+/**
+ * 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.
+ */
+export declare function getPrimitiveTextureData(scenegraph: GLTFScenegraph, textureInfo: GLTFTextureInfoMetadata, primitive: GLTFMeshPrimitive): number[] | null;
+/**
+ * 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
+ */
+export declare function primitivePropertyDataToAttributes(scenegraph: GLTFScenegraph, attributeName: string, propertyData: number[], featureTable: number[], primitive: GLTFMeshPrimitive): void;
+//# sourceMappingURL=data-processing.d.ts.map

package/dist/lib/extensions/data-processing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-processing.d.ts","sourceRoot":"","sources":["../../../src/lib/extensions/data-processing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,uBAAuB,EAAE,iBAAiB,EAAC,MAAM,2BAA2B,CAAC;AAC1F,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAGnD,OAAO,EAAC,cAAc,EAAC,MAAM,wBAAwB,CAAC;AA4CtD,wBAAgB,uBAAuB,CAAC,aAAa,KAAA,EAAE,aAAa,KAAA,GAAG,MAAM,CAK5E;AAED;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,EACrB,YAAY,GAAE,MAAU,GACvB,UAAU,CAWZ;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,cAAc,EAC1B,WAAW,EAAE,uBAAuB,EACpC,SAAS,EAAE,iBAAiB,GAC3B,MAAM,EAAE,GAAG,IAAI,CAkDjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EAAE,EACtB,YAAY,EAAE,MAAM,EAAE,EACtB,SAAS,EAAE,iBAAiB,GAC3B,IAAI,CA+BN"}