@loaders.gl/gltf 4.0.0-alpha.9 → 4.0.0-beta.2

package/dist/lib/extensions/KHR_draco_mesh_compression.js

@@ -1,138 +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 draco_1 = require("@loaders.gl/draco");
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-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 { parse } = context;
-    const dracoOptions = { ...options };
-    // TODO - remove hack: The entire tileset might be included, too expensive to serialize
-    delete dracoOptions['3d-tiles'];
-    const decodedData = (await parse(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) {
-        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/deprecated/EXT_feature_metadata.js

@@ -1,290 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decode = exports.name = void 0;
-const gltf_scenegraph_1 = require("../../api/gltf-scenegraph");
-const images_1 = require("@loaders.gl/images");
-const gltf_utils_1 = require("../../gltf-utils/gltf-utils");
-/** Extension name */
-const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
-exports.name = EXT_FEATURE_METADATA;
-async function decode(gltfData, options) {
-    const scenegraph = new gltf_scenegraph_1.GLTFScenegraph(gltfData);
-    decodeExtFeatureMetadata(scenegraph, options);
-}
-exports.decode = decode;
-/**
- * Decodes feature metadata from extension
- * @param scenegraph
- */
-function decodeExtFeatureMetadata(scenegraph, options) {
-    const extension = scenegraph.getExtension(EXT_FEATURE_METADATA);
-    if (!extension)
-        return;
-    const schemaClasses = extension.schema?.classes;
-    const { featureTables } = extension;
-    if (schemaClasses && featureTables) {
-        for (const schemaName in schemaClasses) {
-            const schemaClass = schemaClasses[schemaName];
-            const featureTable = findFeatureTableByName(featureTables, schemaName);
-            if (featureTable) {
-                handleFeatureTableProperties(scenegraph, featureTable, schemaClass);
-            }
-        }
-    }
-    const { featureTextures } = extension;
-    if (schemaClasses && featureTextures && options.gltf?.loadImages) {
-        for (const schemaName in schemaClasses) {
-            const schemaClass = schemaClasses[schemaName];
-            const featureTexture = findFeatureTextureByName(featureTextures, schemaName);
-            if (featureTexture) {
-                handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass);
-            }
-        }
-    }
-}
-/**
- * Navigate throw all properies in feature table and gets properties data.
- * @param scenegraph
- * @param featureTable
- * @param schemaClass
- */
-function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
-    for (const propertyName in schemaClass.properties) {
-        const schemaProperty = schemaClass.properties[propertyName];
-        const featureTableProperty = featureTable?.properties?.[propertyName];
-        const numberOfFeatures = featureTable.count;
-        if (featureTableProperty) {
-            const data = getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty);
-            featureTableProperty.data = data;
-        }
-    }
-}
-/**
- * Navigate throw all properies in feature texture and gets properties data.
- * Data will be stored in featureTexture.properties[propertyName].data
- * @param scenegraph
- * @param featureTexture
- * @param schemaClass
- */
-function handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass) {
-    const attributeName = featureTexture.class;
-    for (const propertyName in schemaClass.properties) {
-        const featureTextureProperty = featureTexture?.properties?.[propertyName];
-        if (featureTextureProperty) {
-            const data = getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName);
-            featureTextureProperty.data = data;
-        }
-    }
-}
-/**
- * Decode properties from binary sourse based on property type.
- * @param scenegraph
- * @param schemaProperty
- * @param numberOfFeatures
- * @param featureTableProperty
- */
-function getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
-    const bufferView = featureTableProperty.bufferView;
-    // TODO think maybe we shouldn't get data only in Uint8Array format.
-    const dataArray = 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);
-        }
-        default:
-    }
-    return dataArray;
-}
-/**
- * Get properties from texture associated with all mesh primitives.
- * @param scenegraph
- * @param featureTextureProperty
- * @param attributeName
- * @returns Feature texture data
- */
-function getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName) {
-    const json = scenegraph.gltf.json;
-    if (!json.meshes) {
-        return [];
-    }
-    const featureTextureTable = [];
-    for (const mesh of json.meshes) {
-        for (const primitive of mesh.primitives) {
-            processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive);
-        }
-    }
-    return featureTextureTable;
-}
-// eslint-disable-next-line max-statements
-/**
- * Processes data encoded in the texture associated with the primitive. This data will be accessible through the attributes.
- * @param scenegraph
- * @param attributeName
- * @param featureTextureProperty
- * @param featureTextureTable
- * @param primitive
- */
-function processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, 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 ared used to get data from the image.
-    */
-    const json = scenegraph.gltf.json;
-    const textureData = [];
-    const texCoordAccessorKey = `TEXCOORD_${featureTextureProperty.texture.texCoord}`;
-    const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
-    const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
-    const texCoordArray = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
-    const textureCoordinates = 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 textureIndex = featureTextureProperty.texture.index;
-    const texture = json.textures?.[textureIndex];
-    const imageIndex = texture?.source;
-    if (typeof imageIndex !== 'undefined') {
-        const image = json.images?.[imageIndex];
-        const mimeType = image?.mimeType;
-        const parsedImage = scenegraph.gltf.images?.[imageIndex];
-        if (parsedImage) {
-            for (let index = 0; index < textureCoordinates.length; index += 2) {
-                const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, featureTextureProperty.channels);
-                textureData.push(value);
-            }
-        }
-    }
-    /*
-      featureTextureTable will contain unique values, e.g.
-        textureData = [24, 35, 28, 24]
-        featureTextureTable = [24, 35, 28]
-      featureIndices will contain indices hat refer featureTextureTable, e.g.
-        featureIndices = [0, 1, 2, 0]
-    */
-    const featureIndices = [];
-    for (const texelData of textureData) {
-        let index = featureTextureTable.findIndex((item) => item === texelData);
-        if (index === -1) {
-            index = featureTextureTable.push(texelData) - 1;
-        }
-        featureIndices.push(index);
-    }
-    const typedArray = new Uint32Array(featureIndices);
-    const bufferIndex = scenegraph.gltf.buffers.push({
-        arrayBuffer: typedArray.buffer,
-        byteOffset: 0,
-        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;
-}
-function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels) {
-    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];
-    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 val = getVal(parsedImage, offset + map.offset);
-        value |= val << map.shift;
-    }
-    return value;
-}
-function getVal(parsedImage, offset) {
-    const imageData = (0, images_1.getImageData)(parsedImage);
-    if (imageData.data.length <= offset) {
-        throw new Error(`${imageData.data.length} <= ${offset}`);
-    }
-    return imageData.data[offset];
-}
-function coordinatesToOffset(u, v, parsedImage, componentsCount = 1) {
-    const w = parsedImage.width;
-    const iX = emod(u) * (w - 1);
-    const indX = Math.round(iX);
-    const h = parsedImage.height;
-    const iY = 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;
-}
-// The following is taken from tile-converter\src\i3s-converter\helpers\batch-ids-extensions.ts
-/**
- * Handle UVs if they are out of range [0,1].
- * @param n
- * @param m
- */
-function emod(n) {
-    const a = ((n % 1) + 1) % 1;
-    return a;
-}
-/**
- * Find the feature table by class name.
- * @param featureTables
- * @param schemaClassName
- */
-function findFeatureTableByName(featureTables, schemaClassName) {
-    for (const featureTableName in featureTables) {
-        const featureTable = featureTables[featureTableName];
-        if (featureTable.class === schemaClassName) {
-            return featureTable;
-        }
-    }
-    return null;
-}
-function findFeatureTextureByName(featureTextures, schemaClassName) {
-    for (const featureTexturesName in featureTextures) {
-        const featureTable = featureTextures[featureTexturesName];
-        if (featureTable.class === schemaClassName) {
-            return featureTable;
-        }
-    }
-    return null;
-}
-/**
- * Getting string attributes from binary data.
- * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata#strings
- * @param data
- * @param offsetsData
- * @param stringsCount
- */
-function getStringAttributes(data, offsetsData, stringsCount) {
-    const stringsArray = [];
-    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 stringAttribute = textDecoder.decode(stringData);
-        stringsArray.push(stringAttribute);
-        stringOffset += stringByteSize;
-    }
-    return stringsArray;
-}