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

package/dist/lib/api/post-process-gltf.js

@@ -1,433 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.postProcessGLTF = void 0;
-const assert_1 = require("../utils/assert");
-const gltf_utils_1 = require("../gltf-utils/gltf-utils");
-// This is a post processor for loaded glTF files
-// The goal is to make the loaded data easier to use in WebGL applications
-//
-// Functions:
-// * Resolve indexed arrays structure of glTF into a linked tree.
-// * Translate stringified enum keys and values into WebGL constants.
-// * Load images (optional)
-// ENUM LOOKUP
-const COMPONENTS = {
-    SCALAR: 1,
-    VEC2: 2,
-    VEC3: 3,
-    VEC4: 4,
-    MAT2: 4,
-    MAT3: 9,
-    MAT4: 16
-};
-const BYTES = {
-    5120: 1,
-    5121: 1,
-    5122: 2,
-    5123: 2,
-    5125: 4,
-    5126: 4 // FLOAT
-};
-const GL_SAMPLER = {
-    // Sampler parameters
-    TEXTURE_MAG_FILTER: 0x2800,
-    TEXTURE_MIN_FILTER: 0x2801,
-    TEXTURE_WRAP_S: 0x2802,
-    TEXTURE_WRAP_T: 0x2803,
-    // Sampler default values
-    REPEAT: 0x2901,
-    LINEAR: 0x2601,
-    NEAREST_MIPMAP_LINEAR: 0x2702
-};
-const SAMPLER_PARAMETER_GLTF_TO_GL = {
-    magFilter: GL_SAMPLER.TEXTURE_MAG_FILTER,
-    minFilter: GL_SAMPLER.TEXTURE_MIN_FILTER,
-    wrapS: GL_SAMPLER.TEXTURE_WRAP_S,
-    wrapT: GL_SAMPLER.TEXTURE_WRAP_T
-};
-// When undefined, a sampler with repeat wrapping and auto filtering should be used.
-// https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#texture
-const DEFAULT_SAMPLER_PARAMETERS = {
-    [GL_SAMPLER.TEXTURE_MAG_FILTER]: GL_SAMPLER.LINEAR,
-    [GL_SAMPLER.TEXTURE_MIN_FILTER]: GL_SAMPLER.NEAREST_MIPMAP_LINEAR,
-    [GL_SAMPLER.TEXTURE_WRAP_S]: GL_SAMPLER.REPEAT,
-    [GL_SAMPLER.TEXTURE_WRAP_T]: GL_SAMPLER.REPEAT
-};
-function makeDefaultSampler() {
-    return {
-        id: 'default-sampler',
-        parameters: DEFAULT_SAMPLER_PARAMETERS
-    };
-}
-function getBytesFromComponentType(componentType) {
-    return BYTES[componentType];
-}
-function getSizeFromAccessorType(type) {
-    return COMPONENTS[type];
-}
-class GLTFPostProcessor {
-    constructor() {
-        this.baseUri = '';
-        this.buffers = [];
-        this.images = [];
-    }
-    postProcess(gltf, options = {}) {
-        const { json, buffers = [], images = [] } = gltf;
-        // @ts-expect-error
-        const { baseUri = '' } = gltf;
-        (0, assert_1.assert)(json);
-        this.baseUri = baseUri;
-        this.buffers = buffers;
-        this.images = images;
-        this.jsonUnprocessed = json;
-        this.json = this._resolveTree(gltf.json, options);
-        return this.json;
-    }
-    // Convert indexed glTF structure into tree structure
-    // cross-link index resolution, enum lookup, convenience calculations
-    // eslint-disable-next-line complexity, max-statements
-    _resolveTree(gltf, options = {}) {
-        // @ts-expect-error
-        const json = { ...gltf };
-        this.json = json;
-        if (gltf.bufferViews) {
-            json.bufferViews = gltf.bufferViews.map((bufView, i) => this._resolveBufferView(bufView, i));
-        }
-        if (gltf.images) {
-            json.images = gltf.images.map((image, i) => this._resolveImage(image, i));
-        }
-        if (gltf.samplers) {
-            json.samplers = gltf.samplers.map((sampler, i) => this._resolveSampler(sampler, i));
-        }
-        if (gltf.textures) {
-            json.textures = gltf.textures.map((texture, i) => this._resolveTexture(texture, i));
-        }
-        if (gltf.accessors) {
-            json.accessors = gltf.accessors.map((accessor, i) => this._resolveAccessor(accessor, i));
-        }
-        if (gltf.materials) {
-            json.materials = gltf.materials.map((material, i) => this._resolveMaterial(material, i));
-        }
-        if (gltf.meshes) {
-            json.meshes = gltf.meshes.map((mesh, i) => this._resolveMesh(mesh, i));
-        }
-        if (gltf.nodes) {
-            json.nodes = gltf.nodes.map((node, i) => this._resolveNode(node, i));
-            json.nodes = json.nodes.map((node, i) => this._resolveNodeChildren(node));
-        }
-        if (gltf.skins) {
-            json.skins = gltf.skins.map((skin, i) => this._resolveSkin(skin, i));
-        }
-        if (gltf.scenes) {
-            json.scenes = gltf.scenes.map((scene, i) => this._resolveScene(scene, i));
-        }
-        if (typeof this.json.scene === 'number' && json.scenes) {
-            json.scene = json.scenes[this.json.scene];
-        }
-        return json;
-    }
-    getScene(index) {
-        return this._get(this.json.scenes, index);
-    }
-    getNode(index) {
-        return this._get(this.json.nodes, index);
-    }
-    getSkin(index) {
-        return this._get(this.json.skins, index);
-    }
-    getMesh(index) {
-        return this._get(this.json.meshes, index);
-    }
-    getMaterial(index) {
-        return this._get(this.json.materials, index);
-    }
-    getAccessor(index) {
-        return this._get(this.json.accessors, index);
-    }
-    getCamera(index) {
-        return this._get(this.json.cameras, index);
-    }
-    getTexture(index) {
-        return this._get(this.json.textures, index);
-    }
-    getSampler(index) {
-        return this._get(this.json.samplers, index);
-    }
-    getImage(index) {
-        return this._get(this.json.images, index);
-    }
-    getBufferView(index) {
-        return this._get(this.json.bufferViews, index);
-    }
-    getBuffer(index) {
-        return this._get(this.json.buffers, index);
-    }
-    _get(array, index) {
-        // check if already resolved
-        if (typeof index === 'object') {
-            return index;
-        }
-        const object = array && array[index];
-        if (!object) {
-            console.warn(`glTF file error: Could not find ${array}[${index}]`); // eslint-disable-line
-        }
-        return object;
-    }
-    // PARSING HELPERS
-    _resolveScene(scene, index) {
-        return {
-            ...scene,
-            // @ts-ignore
-            id: scene.id || `scene-${index}`,
-            nodes: (scene.nodes || []).map((node) => this.getNode(node))
-        };
-    }
-    _resolveNode(gltfNode, index) {
-        // @ts-expect-error
-        const node = {
-            ...gltfNode,
-            // @ts-expect-error id could already be present, glTF standard does not prevent it
-            id: gltfNode?.id || `node-${index}`
-        };
-        if (gltfNode.mesh !== undefined) {
-            node.mesh = this.getMesh(gltfNode.mesh);
-        }
-        if (gltfNode.camera !== undefined) {
-            node.camera = this.getCamera(gltfNode.camera);
-        }
-        if (gltfNode.skin !== undefined) {
-            node.skin = this.getSkin(gltfNode.skin);
-        }
-        // TODO deprecated - Delete in v4.0?
-        // @ts-expect-error node.meshes does not seem to be part of the GLTF standard
-        if (gltfNode.meshes !== undefined && gltfNode.meshes.length) {
-            // @ts-expect-error
-            node.mesh = gltfNode.meshes.reduce((accum, meshIndex) => {
-                const mesh = this.getMesh(meshIndex);
-                accum.id = mesh.id;
-                accum.primitives = accum.primitives.concat(mesh.primitives);
-                return accum;
-            }, { primitives: [] });
-        }
-        return node;
-    }
-    _resolveNodeChildren(node) {
-        if (node.children) {
-            // @ts-expect-error node.children are numbers at this stage
-            node.children = node.children.map((child) => this.getNode(child));
-        }
-        return node;
-    }
-    _resolveSkin(gltfSkin, index) {
-        const inverseBindMatrices = typeof gltfSkin.inverseBindMatrices === 'number'
-            ? this.getAccessor(gltfSkin.inverseBindMatrices)
-            : undefined;
-        return {
-            ...gltfSkin,
-            id: gltfSkin.id || `skin-${index}`,
-            inverseBindMatrices
-        };
-    }
-    _resolveMesh(gltfMesh, index) {
-        const mesh = {
-            ...gltfMesh,
-            id: gltfMesh.id || `mesh-${index}`,
-            primitives: []
-        };
-        if (gltfMesh.primitives) {
-            mesh.primitives = gltfMesh.primitives.map((gltfPrimitive) => {
-                const primitive = {
-                    ...gltfPrimitive,
-                    attributes: {},
-                    indices: undefined,
-                    material: undefined
-                };
-                const attributes = gltfPrimitive.attributes;
-                for (const attribute in attributes) {
-                    primitive.attributes[attribute] = this.getAccessor(attributes[attribute]);
-                }
-                if (gltfPrimitive.indices !== undefined) {
-                    primitive.indices = this.getAccessor(gltfPrimitive.indices);
-                }
-                if (gltfPrimitive.material !== undefined) {
-                    primitive.material = this.getMaterial(gltfPrimitive.material);
-                }
-                return primitive;
-            });
-        }
-        return mesh;
-    }
-    _resolveMaterial(gltfMaterial, index) {
-        // @ts-expect-error
-        const material = {
-            ...gltfMaterial,
-            // @ts-expect-error
-            id: gltfMaterial.id || `material-${index}`
-        };
-        if (material.normalTexture) {
-            material.normalTexture = { ...material.normalTexture };
-            material.normalTexture.texture = this.getTexture(material.normalTexture.index);
-        }
-        if (material.occlusionTexture) {
-            material.occlusionTexture = { ...material.occlusionTexture };
-            material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);
-        }
-        if (material.emissiveTexture) {
-            material.emissiveTexture = { ...material.emissiveTexture };
-            material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);
-        }
-        if (!material.emissiveFactor) {
-            material.emissiveFactor = material.emissiveTexture ? [1, 1, 1] : [0, 0, 0];
-        }
-        if (material.pbrMetallicRoughness) {
-            material.pbrMetallicRoughness = { ...material.pbrMetallicRoughness };
-            const mr = material.pbrMetallicRoughness;
-            if (mr.baseColorTexture) {
-                mr.baseColorTexture = { ...mr.baseColorTexture };
-                mr.baseColorTexture.texture = this.getTexture(mr.baseColorTexture.index);
-            }
-            if (mr.metallicRoughnessTexture) {
-                mr.metallicRoughnessTexture = { ...mr.metallicRoughnessTexture };
-                mr.metallicRoughnessTexture.texture = this.getTexture(mr.metallicRoughnessTexture.index);
-            }
-        }
-        return material;
-    }
-    _resolveAccessor(gltfAccessor, index) {
-        // Look up enums
-        const bytesPerComponent = getBytesFromComponentType(gltfAccessor.componentType);
-        const components = getSizeFromAccessorType(gltfAccessor.type);
-        const bytesPerElement = bytesPerComponent * components;
-        const accessor = {
-            ...gltfAccessor,
-            // @ts-expect-error
-            id: gltfAccessor.id || `accessor-${index}`,
-            bytesPerComponent,
-            components,
-            bytesPerElement,
-            value: undefined,
-            bufferView: undefined,
-            sparse: undefined
-        };
-        if (gltfAccessor.bufferView !== undefined) {
-            // Draco encoded meshes don't have bufferView
-            accessor.bufferView = this.getBufferView(gltfAccessor.bufferView);
-        }
-        // Create TypedArray for the accessor
-        // Note: The canonical way to instantiate is to ignore this array and create
-        // WebGLBuffer's using the bufferViews.
-        if (accessor.bufferView) {
-            const buffer = accessor.bufferView.buffer;
-            const { ArrayType, byteLength } = (0, gltf_utils_1.getAccessorArrayTypeAndLength)(accessor, accessor.bufferView);
-            const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
-            let cutBuffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
-            if (accessor.bufferView.byteStride) {
-                cutBuffer = this._getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
-            }
-            accessor.value = new ArrayType(cutBuffer);
-        }
-        return accessor;
-    }
-    /**
-     * Take values of particular accessor from interleaved buffer
-     * various parts of the buffer
-     * @param buffer
-     * @param byteOffset
-     * @param byteStride
-     * @param bytesPerElement
-     * @param count
-     * @returns
-     */
-    _getValueFromInterleavedBuffer(buffer, byteOffset, byteStride, bytesPerElement, count) {
-        const result = new Uint8Array(count * bytesPerElement);
-        for (let i = 0; i < count; i++) {
-            const elementOffset = byteOffset + i * byteStride;
-            result.set(new Uint8Array(buffer.arrayBuffer.slice(elementOffset, elementOffset + bytesPerElement)), i * bytesPerElement);
-        }
-        return result.buffer;
-    }
-    _resolveTexture(gltfTexture, index) {
-        return {
-            ...gltfTexture,
-            // @ts-expect-error id could already be present, glTF standard does not prevent it
-            id: gltfTexture.id || `texture-${index}`,
-            sampler: typeof gltfTexture.sampler === 'number'
-                ? this.getSampler(gltfTexture.sampler)
-                : makeDefaultSampler(),
-            source: typeof gltfTexture.source === 'number' ? this.getImage(gltfTexture.source) : undefined
-        };
-    }
-    _resolveSampler(gltfSampler, index) {
-        const sampler = {
-            // @ts-expect-error id could already be present, glTF standard does not prevent it
-            id: gltfSampler.id || `sampler-${index}`,
-            ...gltfSampler,
-            parameters: {}
-        };
-        // Map textual parameters to GL parameter values
-        for (const key in sampler) {
-            const glEnum = this._enumSamplerParameter(key);
-            if (glEnum !== undefined) {
-                sampler.parameters[glEnum] = sampler[key];
-            }
-        }
-        return sampler;
-    }
-    _enumSamplerParameter(key) {
-        return SAMPLER_PARAMETER_GLTF_TO_GL[key];
-    }
-    _resolveImage(gltfImage, index) {
-        const image = {
-            ...gltfImage,
-            // @ts-expect-error id could already be present, glTF standard does not prevent it
-            id: gltfImage.id || `image-${index}`,
-            image: null,
-            bufferView: gltfImage.bufferView !== undefined ? this.getBufferView(gltfImage.bufferView) : undefined
-        };
-        // Check if image has been preloaded by the GLTFLoader
-        // If so, link it into the JSON and drop the URI
-        const preloadedImage = this.images[index];
-        if (preloadedImage) {
-            image.image = preloadedImage;
-        }
-        return image;
-    }
-    _resolveBufferView(gltfBufferView, index) {
-        const bufferIndex = gltfBufferView.buffer;
-        const arrayBuffer = this.buffers[bufferIndex].arrayBuffer;
-        // Add offset of buffer, then offset of buffer view
-        let byteOffset = this.buffers[bufferIndex].byteOffset || 0;
-        if (gltfBufferView.byteOffset) {
-            byteOffset += gltfBufferView.byteOffset;
-        }
-        const bufferView = {
-            // // @ts-expect-error id could already be present, glTF standard does not prevent it
-            id: `bufferView-${index}`,
-            ...gltfBufferView,
-            // ...this.buffers[bufferIndex],
-            buffer: this.buffers[bufferIndex],
-            data: new Uint8Array(arrayBuffer, byteOffset, gltfBufferView.byteLength)
-        };
-        return bufferView;
-    }
-    _resolveCamera(gltfCamera, index) {
-        const camera = {
-            ...gltfCamera,
-            // @ts-expect-error id could already be present, glTF standard does not prevent it
-            id: gltfCamera.id || `camera-${index}`
-        };
-        // TODO - create 4x4 matrices
-        if (camera.perspective) {
-            // camera.matrix = createPerspectiveMatrix(camera.perspective);
-        }
-        if (camera.orthographic) {
-            // camera.matrix = createOrthographicMatrix(camera.orthographic);
-        }
-        return camera;
-    }
-}
-function postProcessGLTF(gltf, options) {
-    return new GLTFPostProcessor().postProcess(gltf, options);
-}
-exports.postProcessGLTF = postProcessGLTF;

package/dist/lib/encoders/encode-glb.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeGLBSync = void 0;
-/* eslint-disable camelcase, max-statements */
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-// import type {GLB} from '../types/glb-types';
-const MAGIC_glTF = 0x46546c67; // glTF in ASCII
-const MAGIC_JSON = 0x4e4f534a; // JSON in ASCII
-const MAGIC_BIN = 0x004e4942; // BIN\0 in ASCII
-const LE = true; // Binary GLTF is little endian.
-/**
- * Encode the full GLB buffer with header etc
- *
- * @param glb
- * @param dataView - if `null`, does not encode but just calculates length
- * @param byteOffset
- * @param options
- * @returns
- *
- * @see https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#glb-file-format-specification
- * @todo type GLB argument
- */
-function encodeGLBSync(glb, dataView, byteOffset = 0, options = {}) {
-    const { magic = MAGIC_glTF, version = 2, json = {}, binary } = glb;
-    const byteOffsetStart = byteOffset;
-    // Write GLB Header
-    if (dataView) {
-        dataView.setUint32(byteOffset + 0, magic, LE); // Magic number (the ASCII string 'glTF').
-        dataView.setUint32(byteOffset + 4, version, LE); // Version 2 of binary glTF container format uint32
-        dataView.setUint32(byteOffset + 8, 0, LE); // Total byte length of generated file (uint32), will be set last
-    }
-    const byteOffsetFileLength = byteOffset + 8;
-    byteOffset += 12; // GLB_FILE_HEADER_SIZE
-    // Write the JSON chunk header
-    const byteOffsetJsonHeader = byteOffset;
-    if (dataView) {
-        dataView.setUint32(byteOffset + 0, 0, LE); // Byte length of json chunk (will be written later)
-        dataView.setUint32(byteOffset + 4, MAGIC_JSON, LE); // Chunk type
-    }
-    byteOffset += 8; // GLB_CHUNK_HEADER_SIZE
-    // Write the JSON chunk
-    const jsonString = JSON.stringify(json);
-    byteOffset = (0, loader_utils_1.copyPaddedStringToDataView)(dataView, byteOffset, jsonString, 4);
-    // Now we know the JSON chunk length so we can write it.
-    if (dataView) {
-        const jsonByteLength = byteOffset - byteOffsetJsonHeader - 8; // GLB_CHUNK_HEADER_SIZE
-        dataView.setUint32(byteOffsetJsonHeader + 0, jsonByteLength, LE); // Byte length of json chunk (uint32)
-    }
-    // Write the BIN chunk if present. The BIN chunk is optional.
-    if (binary) {
-        const byteOffsetBinHeader = byteOffset;
-        // Write the BIN chunk header
-        if (dataView) {
-            dataView.setUint32(byteOffset + 0, 0, LE); // Byte length BIN (uint32)
-            dataView.setUint32(byteOffset + 4, MAGIC_BIN, LE); // Chunk type
-        }
-        byteOffset += 8; // GLB_CHUNK_HEADER_SIZE
-        byteOffset = (0, loader_utils_1.copyPaddedArrayBufferToDataView)(dataView, byteOffset, binary, 4);
-        // Now we know the BIN chunk length so we can write it.
-        if (dataView) {
-            const binByteLength = byteOffset - byteOffsetBinHeader - 8; // GLB_CHUNK_HEADER_SIZE
-            dataView.setUint32(byteOffsetBinHeader + 0, binByteLength, LE); // Byte length BIN (uint32)
-        }
-    }
-    // Now we know the glb file length so we can write it.
-    if (dataView) {
-        const fileByteLength = byteOffset - byteOffsetStart;
-        dataView.setUint32(byteOffsetFileLength, fileByteLength, LE); // Total byte length of generated file (uint32)
-    }
-    return byteOffset;
-}
-exports.encodeGLBSync = encodeGLBSync;

package/dist/lib/encoders/encode-gltf.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeGLTFSync = void 0;
-const encode_glb_1 = require("./encode-glb");
-/**
- * Encode the full glTF file as a binary GLB file
- * Returns an ArrayBuffer that represents the complete GLB image that can be saved to file
- *
- * @todo - Does not support encoding to non-GLB versions of glTF format. Other formats
- * - Encode as a textual JSON file with binary data in base64 data URLs.
- * - Encode as a JSON with all images (and buffers?) in separate binary files
- *
- * glb-file-format-specification
- * @see https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#
- *
- * @param gltf
- * @param arrayBuffer
- * @param byteOffset
- * @param options
- * @returns
- */
-function encodeGLTFSync(gltf, arrayBuffer, byteOffset, options) {
-    convertBuffersToBase64(gltf);
-    // TODO: Copy buffers to binary
-    return (0, encode_glb_1.encodeGLBSync)(gltf, arrayBuffer, byteOffset, options);
-}
-exports.encodeGLTFSync = encodeGLTFSync;
-function convertBuffersToBase64(gltf, { firstBuffer = 0 } = {}) {
-    if (gltf.buffers && gltf.buffers.length > firstBuffer) {
-        throw new Error('encodeGLTF: multiple buffers not yet implemented');
-    }
-}

package/dist/lib/extensions/EXT_mesh_features.js

@@ -1,89 +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 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_meshopt_compression.js

@@ -1,41 +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 meshopt_decoder_1 = require("../../meshopt/meshopt-decoder");
-// @ts-ignore
-// eslint-disable-next-line
-const DEFAULT_MESHOPT_OPTIONS = {
-    byteOffset: 0,
-    filter: 'NONE'
-};
-/** Extension name */
-const EXT_MESHOPT_COMPRESSION = 'EXT_meshopt_compression';
-exports.name = EXT_MESHOPT_COMPRESSION;
-async function decode(gltfData, options) {
-    const scenegraph = new gltf_scenegraph_1.GLTFScenegraph(gltfData);
-    if (!options?.gltf?.decompressMeshes || !options.gltf?.loadBuffers) {
-        return;
-    }
-    const promises = [];
-    for (const bufferViewIndex of gltfData.json.bufferViews || []) {
-        promises.push(decodeMeshoptBufferView(scenegraph, bufferViewIndex));
-    }
-    // Decompress meshes in parallel
-    await Promise.all(promises);
-    // We have now decompressed all primitives, so remove the top-level extension
-    scenegraph.removeExtension(EXT_MESHOPT_COMPRESSION);
-}
-exports.decode = decode;
-/** Decode one meshopt buffer view */
-async function decodeMeshoptBufferView(scenegraph, bufferView) {
-    const meshoptExtension = scenegraph.getObjectExtension(bufferView, EXT_MESHOPT_COMPRESSION);
-    if (meshoptExtension) {
-        const { byteOffset = 0, byteLength = 0, byteStride, count, mode, filter = 'NONE', buffer: bufferIndex } = meshoptExtension;
-        const buffer = scenegraph.gltf.buffers[bufferIndex];
-        const source = new Uint8Array(buffer.arrayBuffer, buffer.byteOffset + byteOffset, byteLength);
-        const result = new Uint8Array(scenegraph.gltf.buffers[bufferView.buffer].arrayBuffer, bufferView.byteOffset, bufferView.byteLength);
-        await (0, meshopt_decoder_1.meshoptDecodeGltfBuffer)(result, count, byteStride, source, mode, filter);
-        scenegraph.removeObjectExtension(bufferView, EXT_MESHOPT_COMPRESSION);
-    }
-}