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

package/dist/lib/extensions/KHR_draco_mesh_compression.js

@@ -1,137 +0,0 @@
-"use strict";
-// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression
-// Only TRIANGLES: 0x0004 and TRIANGLE_STRIP: 0x0005 are supported
-/* eslint-disable camelcase */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encode = exports.decode = exports.preprocess = exports.name = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const draco_1 = require("@loaders.gl/draco");
-const gltf_scenegraph_1 = require("../api/gltf-scenegraph");
-const gltf_attribute_utils_1 = require("../gltf-utils/gltf-attribute-utils");
-const KHR_DRACO_MESH_COMPRESSION = 'KHR_draco_mesh_compression';
-/** Extension name */
-exports.name = KHR_DRACO_MESH_COMPRESSION;
-function preprocess(gltfData, options, context) {
-    const scenegraph = new gltf_scenegraph_1.GLTFScenegraph(gltfData);
-    for (const primitive of makeMeshPrimitiveIterator(scenegraph)) {
-        if (scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION)) {
-            // TODO - Remove fallback accessors to make sure we don't load unnecessary buffers
-        }
-    }
-}
-exports.preprocess = preprocess;
-async function decode(gltfData, options, context) {
-    if (!options?.gltf?.decompressMeshes) {
-        return;
-    }
-    const scenegraph = new gltf_scenegraph_1.GLTFScenegraph(gltfData);
-    const promises = [];
-    for (const primitive of makeMeshPrimitiveIterator(scenegraph)) {
-        if (scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION)) {
-            promises.push(decompressPrimitive(scenegraph, primitive, options, context));
-        }
-    }
-    // Decompress meshes in parallel
-    await Promise.all(promises);
-    // We have now decompressed all primitives, so remove the top-level extension
-    scenegraph.removeExtension(KHR_DRACO_MESH_COMPRESSION);
-}
-exports.decode = decode;
-function encode(gltfData, options = {}) {
-    const scenegraph = new gltf_scenegraph_1.GLTFScenegraph(gltfData);
-    for (const mesh of scenegraph.json.meshes || []) {
-        // eslint-disable-next-line camelcase
-        // @ts-ignore
-        compressMesh(mesh, options);
-        // NOTE: Only add the extension if something was actually compressed
-        scenegraph.addRequiredExtension(KHR_DRACO_MESH_COMPRESSION);
-    }
-}
-exports.encode = encode;
-// DECODE
-// Unpacks one mesh primitive and removes the extension from the primitive
-// DracoDecoder needs to be imported and registered by app
-// Returns: Promise that resolves when all pending draco decoder jobs for this mesh complete
-// TODO - Implement fallback behavior per KHR_DRACO_MESH_COMPRESSION spec
-async function decompressPrimitive(scenegraph, primitive, options, context) {
-    const dracoExtension = scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION);
-    if (!dracoExtension) {
-        return;
-    }
-    const buffer = scenegraph.getTypedArrayForBufferView(dracoExtension.bufferView);
-    // TODO - parse does not yet deal well with byte offsets embedded in typed arrays. Copy buffer
-    // TODO - remove when `parse` is fixed to handle `byteOffset`s
-    const bufferCopy = (0, loader_utils_1.sliceArrayBuffer)(buffer.buffer, buffer.byteOffset); // , buffer.byteLength);
-    const dracoOptions = { ...options };
-    // TODO - remove hack: The entire tileset might be included, too expensive to serialize
-    delete dracoOptions['3d-tiles'];
-    const decodedData = await (0, loader_utils_1.parseFromContext)(bufferCopy, draco_1.DracoLoader, dracoOptions, context);
-    const decodedAttributes = (0, gltf_attribute_utils_1.getGLTFAccessors)(decodedData.attributes);
-    // Restore min/max values
-    for (const [attributeName, decodedAttribute] of Object.entries(decodedAttributes)) {
-        if (attributeName in primitive.attributes) {
-            const accessorIndex = primitive.attributes[attributeName];
-            const accessor = scenegraph.getAccessor(accessorIndex);
-            if (accessor?.min && accessor?.max) {
-                decodedAttribute.min = accessor.min;
-                decodedAttribute.max = accessor.max;
-            }
-        }
-    }
-    // @ts-ignore
-    primitive.attributes = decodedAttributes;
-    if (decodedData.indices) {
-        // @ts-ignore
-        primitive.indices = (0, gltf_attribute_utils_1.getGLTFAccessor)(decodedData.indices);
-    }
-    // Extension has been processed, delete it
-    scenegraph.removeObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION);
-    checkPrimitive(primitive);
-}
-// ENCODE
-// eslint-disable-next-line max-len
-// Only TRIANGLES: 0x0004 and TRIANGLE_STRIP: 0x0005 are supported
-function compressMesh(attributes, indices, mode = 4, options, context) {
-    if (!options.DracoWriter) {
-        throw new Error('options.gltf.DracoWriter not provided');
-    }
-    // TODO - use DracoWriter using encode w/ registered DracoWriter...
-    const compressedData = options.DracoWriter.encodeSync({ attributes });
-    // Draco compression may change the order and number of vertices in a mesh.
-    // To satisfy the requirement that accessors properties be correct for both
-    // compressed and uncompressed data, generators should create uncompressed
-    // attributes and indices using data that has been decompressed from the Draco buffer,
-    // rather than the original source data.
-    // @ts-ignore TODO this needs to be fixed
-    const decodedData = context?.parseSync?.({ attributes });
-    const fauxAccessors = options._addFauxAttributes(decodedData.attributes);
-    const bufferViewIndex = options.addBufferView(compressedData);
-    const glTFMesh = {
-        primitives: [
-            {
-                attributes: fauxAccessors,
-                mode,
-                extensions: {
-                    [KHR_DRACO_MESH_COMPRESSION]: {
-                        bufferView: bufferViewIndex,
-                        attributes: fauxAccessors // TODO - verify with spec
-                    }
-                }
-            }
-        ]
-    };
-    return glTFMesh;
-}
-// UTILS
-function checkPrimitive(primitive) {
-    if (!primitive.attributes && Object.keys(primitive.attributes).length > 0) {
-        throw new Error('glTF: Empty primitive detected: Draco decompression failure?');
-    }
-}
-function* makeMeshPrimitiveIterator(scenegraph) {
-    for (const mesh of scenegraph.json.meshes || []) {
-        for (const primitive of mesh.primitives) {
-            yield primitive;
-        }
-    }
-}

package/dist/lib/extensions/KHR_texture_basisu.js

@@ -1,29 +0,0 @@
-"use strict";
-// GLTF EXTENSION: KHR_texture_basisu
-// https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_texture_basisu
-/* eslint-disable camelcase */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preprocess = exports.name = void 0;
-const gltf_scenegraph_1 = require("../api/gltf-scenegraph");
-const KHR_TEXTURE_BASISU = 'KHR_texture_basisu';
-/** Extension name */
-exports.name = KHR_TEXTURE_BASISU;
-/**
- * Replaces a texture source reference with the extension texture
- * Done in preprocess() to prevent load of default image
- */
-function preprocess(gltfData, options) {
-    const scene = new gltf_scenegraph_1.GLTFScenegraph(gltfData);
-    const { json } = scene;
-    for (const texture of json.textures || []) {
-        const extension = scene.getObjectExtension(texture, KHR_TEXTURE_BASISU);
-        if (extension) {
-            // TODO - if multiple texture extensions are present which one wins?
-            texture.source = extension.source;
-            scene.removeObjectExtension(texture, KHR_TEXTURE_BASISU);
-        }
-    }
-    // Remove the top-level extension
-    scene.removeExtension(KHR_TEXTURE_BASISU);
-}
-exports.preprocess = preprocess;

package/dist/lib/extensions/KHR_texture_transform.js

@@ -1,227 +0,0 @@
-"use strict";
-/**
- * https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_texture_transform/README.md
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decode = exports.name = void 0;
-const core_1 = require("@math.gl/core");
-const gltf_utils_1 = require("../gltf-utils/gltf-utils");
-const gltf_constants_1 = require("../gltf-utils/gltf-constants");
-const gltf_scenegraph_1 = require("../api/gltf-scenegraph");
-/** Extension name */
-const EXT_MESHOPT_TRANSFORM = 'KHR_texture_transform';
-exports.name = EXT_MESHOPT_TRANSFORM;
-const scratchVector = new core_1.Vector3();
-const scratchRotationMatrix = new core_1.Matrix3();
-const scratchScaleMatrix = new core_1.Matrix3();
-/**
- * The extension entry to process the transformation
- * @param gltfData gltf buffers and json
- * @param options GLTFLoader options
- */
-async function decode(gltfData, options) {
-    const gltfScenegraph = new gltf_scenegraph_1.GLTFScenegraph(gltfData);
-    const hasExtension = gltfScenegraph.hasExtension(EXT_MESHOPT_TRANSFORM);
-    if (!hasExtension || !options.gltf?.loadBuffers) {
-        return;
-    }
-    const materials = gltfData.json.materials || [];
-    for (let i = 0; i < materials.length; i++) {
-        transformTexCoords(i, gltfData);
-    }
-}
-exports.decode = decode;
-/**
- * Transform TEXCOORD by material
- * @param materialIndex processing material index
- * @param gltfData gltf buffers and json
- */
-function transformTexCoords(materialIndex, gltfData) {
-    // Save processed texCoords in order no to process the same twice
-    const processedTexCoords = [];
-    const material = gltfData.json.materials?.[materialIndex];
-    const baseColorTexture = material?.pbrMetallicRoughness?.baseColorTexture;
-    if (baseColorTexture) {
-        transformPrimitives(gltfData, materialIndex, baseColorTexture, processedTexCoords);
-    }
-    const emisiveTexture = material?.emissiveTexture;
-    if (emisiveTexture) {
-        transformPrimitives(gltfData, materialIndex, emisiveTexture, processedTexCoords);
-    }
-    const normalTexture = material?.normalTexture;
-    if (normalTexture) {
-        transformPrimitives(gltfData, materialIndex, normalTexture, processedTexCoords);
-    }
-    const occlusionTexture = material?.occlusionTexture;
-    if (occlusionTexture) {
-        transformPrimitives(gltfData, materialIndex, occlusionTexture, processedTexCoords);
-    }
-    const metallicRoughnessTexture = material?.pbrMetallicRoughness?.metallicRoughnessTexture;
-    if (metallicRoughnessTexture) {
-        transformPrimitives(gltfData, materialIndex, metallicRoughnessTexture, processedTexCoords);
-    }
-}
-/**
- * Transform primitives of the particular material
- * @param gltfData gltf data
- * @param materialIndex primitives with this material will be transformed
- * @param texture texture object
- * @param processedTexCoords storage to save already processed texCoords
- */
-function transformPrimitives(gltfData, materialIndex, texture, processedTexCoords) {
-    const transformParameters = getTransformParameters(texture, processedTexCoords);
-    if (!transformParameters) {
-        return;
-    }
-    const meshes = gltfData.json.meshes || [];
-    for (const mesh of meshes) {
-        for (const primitive of mesh.primitives) {
-            const material = primitive.material;
-            if (Number.isFinite(material) && materialIndex === material) {
-                transformPrimitive(gltfData, primitive, transformParameters);
-            }
-        }
-    }
-}
-/**
- * Get parameters for TEXCOORD transformation
- * @param texture texture object
- * @param processedTexCoords storage to save already processed texCoords
- * @returns texCoord couple and transformation matrix
- */
-function getTransformParameters(texture, processedTexCoords) {
-    const textureInfo = texture.extensions?.[EXT_MESHOPT_TRANSFORM];
-    const { texCoord: originalTexCoord = 0 } = texture;
-    // If texCoord is not set in the extension, original attribute data will be replaced
-    const { texCoord = originalTexCoord } = textureInfo;
-    // Make sure that couple [originalTexCoord, extensionTexCoord] is not processed twice
-    const isProcessed = processedTexCoords.findIndex(([original, newTexCoord]) => original === originalTexCoord && newTexCoord === texCoord) !== -1;
-    if (!isProcessed) {
-        const matrix = makeTransformationMatrix(textureInfo);
-        if (originalTexCoord !== texCoord) {
-            texture.texCoord = texCoord;
-        }
-        processedTexCoords.push([originalTexCoord, texCoord]);
-        return { originalTexCoord, texCoord, matrix };
-    }
-    return null;
-}
-/**
- * Transform `TEXCOORD_0` attribute in the primitive
- * @param gltfData gltf data
- * @param primitive primitive object
- * @param transformParameters texCoord couple and transformation matrix
- */
-function transformPrimitive(gltfData, primitive, transformParameters) {
-    const { originalTexCoord, texCoord, matrix } = transformParameters;
-    const texCoordAccessor = primitive.attributes[`TEXCOORD_${originalTexCoord}`];
-    if (Number.isFinite(texCoordAccessor)) {
-        // Get accessor of the `TEXCOORD_0` attribute
-        const accessor = gltfData.json.accessors?.[texCoordAccessor];
-        if (accessor && accessor.bufferView) {
-            // 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 } = (0, gltf_utils_1.getAccessorArrayTypeAndLength)(accessor, bufferView);
-                // Number of bytes each component occupies
-                const bytes = gltf_constants_1.BYTES[accessor.componentType];
-                // Number of components. For the `TEXCOORD_0` with `VEC2` type, it must return 2
-                const components = gltf_constants_1.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);
-                    // Set and transform Vector3 per https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_texture_transform#overview
-                    scratchVector.set(uv[0], uv[1], 1);
-                    scratchVector.transformByMatrix3(matrix);
-                    // Save result in Float32Array
-                    result.set([scratchVector[0], scratchVector[1]], i * components);
-                }
-                // If texCoord the same, replace gltf structural data
-                if (originalTexCoord === texCoord) {
-                    updateGltf(accessor, bufferView, gltfData.buffers, result);
-                }
-                else {
-                    // If texCoord change, create new attribute
-                    createAttribute(texCoord, accessor, primitive, gltfData, result);
-                }
-            }
-        }
-    }
-}
-/**
- * Update GLTF structural objects with new data as we create new `Float32Array` for `TEXCOORD_0`.
- * @param accessor accessor to change
- * @param bufferView bufferView to change
- * @param buffers binary buffers
- * @param newTexcoordArray typed array with data after transformation
- */
-function updateGltf(accessor, bufferView, buffers, newTexCoordArray) {
-    accessor.componentType = 5126;
-    buffers.push({
-        arrayBuffer: newTexCoordArray.buffer,
-        byteOffset: 0,
-        byteLength: newTexCoordArray.buffer.byteLength
-    });
-    bufferView.buffer = buffers.length - 1;
-    bufferView.byteLength = newTexCoordArray.buffer.byteLength;
-    bufferView.byteOffset = 0;
-    delete bufferView.byteStride;
-}
-/**
- *
- * @param newTexCoord new `texCoord` value
- * @param originalAccessor original accessor object, that store data before transformation
- * @param primitive primitive object
- * @param gltfData gltf data
- * @param newTexCoordArray typed array with data after transformation
- * @returns
- */
-function createAttribute(newTexCoord, originalAccessor, primitive, gltfData, newTexCoordArray) {
-    gltfData.buffers.push({
-        arrayBuffer: newTexCoordArray.buffer,
-        byteOffset: 0,
-        byteLength: newTexCoordArray.buffer.byteLength
-    });
-    const bufferViews = gltfData.json.bufferViews;
-    if (!bufferViews) {
-        return;
-    }
-    bufferViews.push({
-        buffer: gltfData.buffers.length - 1,
-        byteLength: newTexCoordArray.buffer.byteLength,
-        byteOffset: 0
-    });
-    const accessors = gltfData.json.accessors;
-    if (!accessors) {
-        return;
-    }
-    accessors.push({
-        bufferView: bufferViews?.length - 1,
-        byteOffset: 0,
-        componentType: 5126,
-        count: originalAccessor.count,
-        type: 'VEC2'
-    });
-    primitive.attributes[`TEXCOORD_${newTexCoord}`] = accessors.length - 1;
-}
-/**
- * Construct transformation matrix from the extension data (transition, rotation, scale)
- * @param extensionData extension data
- * @returns transformation matrix
- */
-function makeTransformationMatrix(extensionData) {
-    const { offset = [0, 0], rotation = 0, scale = [1, 1] } = extensionData;
-    const translationMatrix = new core_1.Matrix3().set(1, 0, 0, 0, 1, 0, offset[0], offset[1], 1);
-    const rotationMatrix = scratchRotationMatrix.set(Math.cos(rotation), Math.sin(rotation), 0, -Math.sin(rotation), Math.cos(rotation), 0, 0, 0, 1);
-    const scaleMatrix = scratchScaleMatrix.set(scale[0], 0, 0, 0, scale[1], 0, 0, 0, 1);
-    return translationMatrix.multiplyRight(rotationMatrix).multiplyRight(scaleMatrix);
-}

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

@@ -1,34 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}

package/dist/lib/extensions/data-processing.js

@@ -1,212 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.primitivePropertyDataToAttributes = exports.getPrimitiveTextureData = exports.convertRawBufferToMetadataArray = exports.getArrayElementByteSize = void 0;
-const gltf_utils_1 = require("../gltf-utils/gltf-utils");
-const images_1 = require("@loaders.gl/images");
-const math_1 = require("@loaders.gl/math");
-const ATTRIBUTE_TYPE_TO_COMPONENTS = {
-    SCALAR: 1,
-    VEC2: 2,
-    VEC3: 3,
-    VEC4: 4,
-    MAT2: 4,
-    MAT3: 9,
-    MAT4: 16,
-    BOOLEAN: 1,
-    STRING: 1,
-    ENUM: 1
-};
-const ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
-    INT8: Int8Array,
-    UINT8: Uint8Array,
-    INT16: Int16Array,
-    UINT16: Uint16Array,
-    INT32: Int32Array,
-    UINT32: Uint32Array,
-    INT64: BigInt64Array,
-    UINT64: BigUint64Array,
-    FLOAT32: Float32Array,
-    FLOAT64: Float64Array
-};
-const ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
-    INT8: 1,
-    UINT8: 1,
-    INT16: 2,
-    UINT16: 2,
-    INT32: 4,
-    UINT32: 4,
-    INT64: 8,
-    UINT64: 8,
-    FLOAT32: 4,
-    FLOAT64: 8
-};
-function getArrayElementByteSize(attributeType, componentType) {
-    return (ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType] *
-        ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType]);
-}
-exports.getArrayElementByteSize = getArrayElementByteSize;
-/**
- * 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
- */
-function convertRawBufferToMetadataArray(typedArray, attributeType, componentType, elementCount = 1) {
-    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);
-}
-exports.convertRawBufferToMetadataArray = convertRawBufferToMetadataArray;
-/**
- * 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.
- */
-function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
-    /*
-      texture.index is an index for the "textures" array.
-      The texture object referenced by this index looks like this:
-      {
-      "sampler": 0,
-      "source": 0
-      }
-      "sampler" is an index for the "samplers" array
-      "source" is an index for the "images" array that contains data. These data are stored in rgba channels of the image.
-  
-      texture.texCoord is a number-suffix (like 1) for an attribute like "TEXCOORD_1" in meshes.primitives
-      The value of "TEXCOORD_1" is an accessor that is used to get coordinates. These coordinates are being used to get data from the image.
-    */
-    const json = scenegraph.gltf.json;
-    const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;
-    const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
-    const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
-    const texCoordArray = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
-    // textureCoordinates array contains UV coordinates of the actual data stored in the texture
-    const textureCoordinates = new Float32Array(texCoordArray.buffer, texCoordArray.byteOffset, texCoordArray.length / 4);
-    const textureIndex = textureInfo.index;
-    const imageIndex = json.textures?.[textureIndex]?.source;
-    if (typeof imageIndex !== 'undefined') {
-        const mimeType = json.images?.[imageIndex]?.mimeType;
-        const parsedImage = scenegraph.gltf.images?.[imageIndex];
-        // Checking for width is to prevent handling Un-processed images (e.g. [analyze] stage, where loadImages option is set to false)
-        if (parsedImage && typeof parsedImage.width !== 'undefined') {
-            const textureData = [];
-            for (let index = 0; index < textureCoordinates.length; index += 2) {
-                const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, textureInfo.channels);
-                textureData.push(value);
-            }
-            return textureData;
-        }
-    }
-    return null;
-}
-exports.getPrimitiveTextureData = 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
- */
-function primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTable, primitive) {
-    if (propertyData === null)
-        return;
-    /*
-      featureTable will contain unique values, e.g.
-      propertyData = [24, 35, 28, 24]
-      featureTable = [24, 35, 28]
-      featureIndices will contain indices that refer featureTextureTable, e.g.
-      featureIndices = [0, 1, 2, 0]
-    */
-    const featureIndices = [];
-    for (const texelData of propertyData) {
-        let index = featureTable.findIndex((item) => item === texelData);
-        if (index === -1) {
-            index = featureTable.push(texelData) - 1;
-        }
-        featureIndices.push(index);
-    }
-    const typedArray = new Uint32Array(featureIndices);
-    const bufferIndex = scenegraph.gltf.buffers.push({
-        arrayBuffer: typedArray.buffer,
-        byteOffset: typedArray.byteOffset,
-        byteLength: typedArray.byteLength
-    }) - 1;
-    const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
-    const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
-        size: 1,
-        componentType: (0, gltf_utils_1.getComponentTypeFromArray)(typedArray),
-        count: typedArray.length
-    });
-    primitive.attributes[attributeName] = accessorIndex;
-}
-exports.primitivePropertyDataToAttributes = 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.
- */
-function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels = [0]) {
-    const CHANNELS_MAP = [
-        { offset: 0, shift: 0 },
-        { offset: 1, shift: 8 },
-        { offset: 2, shift: 16 },
-        { offset: 3, shift: 24 }
-    ];
-    const u = textureCoordinates[index];
-    const v = textureCoordinates[index + 1];
-    let components = 1;
-    if (mimeType && (mimeType.indexOf('image/jpeg') !== -1 || mimeType.indexOf('image/png') !== -1))
-        components = 4;
-    const offset = coordinatesToOffset(u, v, parsedImage, components);
-    let value = 0;
-    for (const c of channels) {
-        const map = CHANNELS_MAP[c];
-        const imageOffset = offset + map.offset;
-        const imageData = (0, images_1.getImageData)(parsedImage);
-        if (imageData.data.length <= imageOffset) {
-            throw new Error(`${imageData.data.length} <= ${imageOffset}`);
-        }
-        const imageValue = imageData.data[imageOffset];
-        value |= imageValue << map.shift;
-    }
-    return value;
-}
-/**
- * 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, v, parsedImage, componentsCount = 1) {
-    const w = parsedImage.width;
-    const iX = (0, math_1.emod)(u) * (w - 1);
-    const indX = Math.round(iX);
-    const h = parsedImage.height;
-    const iY = (0, math_1.emod)(v) * (h - 1);
-    const indY = Math.round(iY);
-    const components = parsedImage.components ? parsedImage.components : componentsCount;
-    // components is a number of channels in the image
-    const offset = (indY * w + indX) * components;
-    return offset;
-}