@loaders.gl/gltf 3.4.11 → 3.4.12

package/dist/lib/api/normalize-gltf-v1.js

@@ -1,299 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeGLTFV1 = void 0;
-/* eslint-disable camelcase */
-const KHR_binary_glTF = __importStar(require("../extensions/KHR_binary_gltf"));
-// Binary format changes (mainly implemented by GLBLoader)
-// https://github.com/KhronosGroup/glTF/tree/master/extensions/1.0/Khronos/KHR_binary_glTF
-// JSON format changes:
-// https://github.com/khronosgroup/gltf/issues/605
-// - [x] Top-level JSON objects are arrays now
-// - [ ] Removed indirection from animation: sampler now refers directly to accessors, #712
-// - [ ] material.parameter.value and technique.parameter.value must be an array, #690
-// - [ ] Node can have only one mesh #821
-// - [ ] Added reqs on JSON encoding
-// - [ ] Added reqs on binary data alignment #802 (comment)
-// Additions:
-// - [ ] Added accessor.normalized, #691, #706
-// - [ ] Added glExtensionsUsed property and 5125 (UNSIGNED_INT) accessor.componentType value, #619
-// - [ ] Added extensionsRequired property, #720, #721
-// - [ ] Added "STEP" as valid animation.sampler.interpolation value, #712
-// Removals:
-// - [x] Removed buffer.type, #786, #629
-// - [ ] Removed revision number from profile.version, #709
-// - [ ] Removed technique.functions.scissor and removed 3089 (SCISSOR_TEST) as a valid value for technique.states.enable, #681
-// - [ ] Techniques, programs, and shaders were moved out to KHR_technique_webgl extension.
-// Other edits:
-// - [x] asset is now required, #642
-// - [ ] buffer.byteLength and bufferView.byteLength are now required, #560.
-// - [ ] accessor.min and accessor.max are now required, #593, and clarified that the JSON value and binary data must be the same, #628.
-// - [ ] Clarified animation.sampler and animation.channel restrictions, #712
-// - [ ] skin.inverseBindMatrices is now optional, #461.
-// - [ ] Attribute parameters can't have a value defined in the technique or parameter, #563 (comment).
-// - [ ] Only TEXCOORD and COLOR attribute semantics can be written in the form [semantic]_[set_index], #563 (comment).
-// - [ ] TEXCOORD and COLOR attribute semantics must be written in the form [semantic]_[set_index], e.g., just TEXCOORD should be TEXCOORD_0, and just COLOR should be COLOR_0, #649
-// - [ ] camera.perspective.aspectRatio and camera.perspective.yfov must now be > 0, not >= 0, #563 (comment).
-// - [ ] Application-specific parameter semantics must start with an underscore, e.g., _TEMPERATURE and _SIMULATION_TIME, #563 (comment).
-// - [ ] Properties in technique.parameters must be defined in technique.uniforms or technique.attributes,
-// #563 (comment).
-// - [ ] technique.parameter.count can only be defined when the semantic is JOINTMATRIX or an application-specific semantic is used. It can never be defined for attribute parameters; only uniforms, d2f6945
-// - [ ] technique.parameter.semantic is required when the parameter is an attribute, 28e113d
-// - [ ] Mesh-only models are allowed, e.g., without materials, #642
-// - [ ] Skeleton hierarchies (nodes containing jointName) must be separated from non-skeleton hierarchies., #647
-// - [ ] technique.states.functions.blendColor and technique.states.functions.depthRange parameters now must match WebGL function min/max, #707
-const GLTF_ARRAYS = {
-    accessors: 'accessor',
-    animations: 'animation',
-    buffers: 'buffer',
-    bufferViews: 'bufferView',
-    images: 'image',
-    materials: 'material',
-    meshes: 'mesh',
-    nodes: 'node',
-    samplers: 'sampler',
-    scenes: 'scene',
-    skins: 'skin',
-    textures: 'texture'
-};
-const GLTF_KEYS = {
-    accessor: 'accessors',
-    animations: 'animation',
-    buffer: 'buffers',
-    bufferView: 'bufferViews',
-    image: 'images',
-    material: 'materials',
-    mesh: 'meshes',
-    node: 'nodes',
-    sampler: 'samplers',
-    scene: 'scenes',
-    skin: 'skins',
-    texture: 'textures'
-};
-/**
- * Converts (normalizes) glTF v1 to v2
- */
-class GLTFV1Normalizer {
-    constructor() {
-        this.idToIndexMap = {
-            animations: {},
-            accessors: {},
-            buffers: {},
-            bufferViews: {},
-            images: {},
-            materials: {},
-            meshes: {},
-            nodes: {},
-            samplers: {},
-            scenes: {},
-            skins: {},
-            textures: {}
-        };
-    }
-    // constructor() {}
-    /**
-     * Convert (normalize) glTF < 2.0 to glTF 2.0
-     * @param gltf - object with json and binChunks
-     * @param options
-     * @param options normalize Whether to actually normalize
-     */
-    normalize(gltf, options) {
-        this.json = gltf.json;
-        const json = gltf.json;
-        // Check version
-        switch (json.asset && json.asset.version) {
-            // We are converting to v2 format. Return if there is nothing to do
-            case '2.0':
-                return;
-            // This class is written to convert 1.0
-            case undefined:
-            case '1.0':
-                break;
-            default:
-                // eslint-disable-next-line no-undef, no-console
-                console.warn(`glTF: Unknown version ${json.asset.version}`);
-                return;
-        }
-        if (!options.normalize) {
-            // We are still missing a few conversion tricks, remove once addressed
-            throw new Error('glTF v1 is not supported.');
-        }
-        // eslint-disable-next-line no-undef, no-console
-        console.warn('Converting glTF v1 to glTF v2 format. This is experimental and may fail.');
-        this._addAsset(json);
-        // In glTF2 top-level fields are Arrays not Object maps
-        this._convertTopLevelObjectsToArrays(json);
-        // Extract bufferView indices for images
-        // (this extension needs to be invoked early in the normalization process)
-        // TODO can this be handled by standard extension processing instead of called explicitly?
-        KHR_binary_glTF.preprocess(gltf);
-        // Convert object references from ids to indices
-        this._convertObjectIdsToArrayIndices(json);
-        this._updateObjects(json);
-        this._updateMaterial(json);
-    }
-    // asset is now required, #642 https://github.com/KhronosGroup/glTF/issues/639
-    _addAsset(json) {
-        json.asset = json.asset || {};
-        // We are normalizing to glTF v2, so change version to "2.0"
-        json.asset.version = '2.0';
-        json.asset.generator = json.asset.generator || 'Normalized to glTF 2.0 by loaders.gl';
-    }
-    _convertTopLevelObjectsToArrays(json) {
-        // TODO check that all arrays are covered
-        for (const arrayName in GLTF_ARRAYS) {
-            this._convertTopLevelObjectToArray(json, arrayName);
-        }
-    }
-    /** Convert one top level object to array */
-    _convertTopLevelObjectToArray(json, mapName) {
-        const objectMap = json[mapName];
-        if (!objectMap || Array.isArray(objectMap)) {
-            return;
-        }
-        // Rewrite the top-level field as an array
-        json[mapName] = [];
-        // Copy the map key into object.id
-        for (const id in objectMap) {
-            const object = objectMap[id];
-            object.id = object.id || id; // Mutates the loaded object
-            const index = json[mapName].length;
-            json[mapName].push(object);
-            this.idToIndexMap[mapName][id] = index;
-        }
-    }
-    /** Go through all objects in all top-level arrays and replace ids with indices */
-    _convertObjectIdsToArrayIndices(json) {
-        for (const arrayName in GLTF_ARRAYS) {
-            this._convertIdsToIndices(json, arrayName);
-        }
-        if ('scene' in json) {
-            json.scene = this._convertIdToIndex(json.scene, 'scene');
-        }
-        // Convert any index references that are not using array names
-        // texture.source (image)
-        for (const texture of json.textures) {
-            this._convertTextureIds(texture);
-        }
-        for (const mesh of json.meshes) {
-            this._convertMeshIds(mesh);
-        }
-        for (const node of json.nodes) {
-            this._convertNodeIds(node);
-        }
-        for (const node of json.scenes) {
-            this._convertSceneIds(node);
-        }
-    }
-    _convertTextureIds(texture) {
-        if (texture.source) {
-            texture.source = this._convertIdToIndex(texture.source, 'image');
-        }
-    }
-    _convertMeshIds(mesh) {
-        for (const primitive of mesh.primitives) {
-            const { attributes, indices, material } = primitive;
-            for (const attributeName in attributes) {
-                attributes[attributeName] = this._convertIdToIndex(attributes[attributeName], 'accessor');
-            }
-            if (indices) {
-                primitive.indices = this._convertIdToIndex(indices, 'accessor');
-            }
-            if (material) {
-                primitive.material = this._convertIdToIndex(material, 'material');
-            }
-        }
-    }
-    _convertNodeIds(node) {
-        if (node.children) {
-            node.children = node.children.map((child) => this._convertIdToIndex(child, 'node'));
-        }
-        if (node.meshes) {
-            node.meshes = node.meshes.map((mesh) => this._convertIdToIndex(mesh, 'mesh'));
-        }
-    }
-    _convertSceneIds(scene) {
-        if (scene.nodes) {
-            scene.nodes = scene.nodes.map((node) => this._convertIdToIndex(node, 'node'));
-        }
-    }
-    /** Go through all objects in a top-level array and replace ids with indices */
-    _convertIdsToIndices(json, topLevelArrayName) {
-        if (!json[topLevelArrayName]) {
-            console.warn(`gltf v1: json doesn't contain attribute ${topLevelArrayName}`); // eslint-disable-line no-console, no-undef
-            json[topLevelArrayName] = [];
-        }
-        for (const object of json[topLevelArrayName]) {
-            for (const key in object) {
-                const id = object[key];
-                const index = this._convertIdToIndex(id, key);
-                object[key] = index;
-            }
-        }
-    }
-    _convertIdToIndex(id, key) {
-        const arrayName = GLTF_KEYS[key];
-        if (arrayName in this.idToIndexMap) {
-            const index = this.idToIndexMap[arrayName][id];
-            if (!Number.isFinite(index)) {
-                throw new Error(`gltf v1: failed to resolve ${key} with id ${id}`);
-            }
-            return index;
-        }
-        return id;
-    }
-    /**
-     *
-     * @param {*} json
-     */
-    _updateObjects(json) {
-        for (const buffer of this.json.buffers) {
-            // - [x] Removed buffer.type, #786, #629
-            delete buffer.type;
-        }
-    }
-    /**
-     * Update material (set pbrMetallicRoughness)
-     * @param {*} json
-     */
-    _updateMaterial(json) {
-        for (const material of json.materials) {
-            material.pbrMetallicRoughness = {
-                baseColorFactor: [1, 1, 1, 1],
-                metallicFactor: 1,
-                roughnessFactor: 1
-            };
-            const textureId = material.values?.tex || material.values?.texture2d_0 || material.values?.diffuseTex;
-            const textureIndex = json.textures.findIndex((texture) => texture.id === textureId);
-            if (textureIndex !== -1) {
-                material.pbrMetallicRoughness.baseColorTexture = { index: textureIndex };
-            }
-        }
-    }
-}
-function normalizeGLTFV1(gltf, options = {}) {
-    return new GLTFV1Normalizer().normalize(gltf, options);
-}
-exports.normalizeGLTFV1 = normalizeGLTFV1;

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

@@ -1,370 +0,0 @@
-"use strict";
-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 = {
-    [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 getBytesFromComponentType(componentType) {
-    return BYTES[componentType];
-}
-function getSizeFromAccessorType(type) {
-    return COMPONENTS[type];
-}
-class GLTFPostProcessor {
-    constructor() {
-        this.baseUri = '';
-        this.json = {};
-        this.buffers = [];
-        this.images = [];
-    }
-    postProcess(gltf, options = {}) {
-        const { json, buffers = [], images = [], baseUri = '' } = gltf;
-        (0, assert_1.assert)(json);
-        this.baseUri = baseUri;
-        this.json = json;
-        this.buffers = buffers;
-        this.images = images;
-        this._resolveTree(this.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
-    _resolveTree(json, options = {}) {
-        if (json.bufferViews) {
-            json.bufferViews = json.bufferViews.map((bufView, i) => this._resolveBufferView(bufView, i));
-        }
-        if (json.images) {
-            json.images = json.images.map((image, i) => this._resolveImage(image, i));
-        }
-        if (json.samplers) {
-            json.samplers = json.samplers.map((sampler, i) => this._resolveSampler(sampler, i));
-        }
-        if (json.textures) {
-            json.textures = json.textures.map((texture, i) => this._resolveTexture(texture, i));
-        }
-        if (json.accessors) {
-            json.accessors = json.accessors.map((accessor, i) => this._resolveAccessor(accessor, i));
-        }
-        if (json.materials) {
-            json.materials = json.materials.map((material, i) => this._resolveMaterial(material, i));
-        }
-        if (json.meshes) {
-            json.meshes = json.meshes.map((mesh, i) => this._resolveMesh(mesh, i));
-        }
-        if (json.nodes) {
-            json.nodes = json.nodes.map((node, i) => this._resolveNode(node, i));
-        }
-        if (json.skins) {
-            json.skins = json.skins.map((skin, i) => this._resolveSkin(skin, i));
-        }
-        if (json.scenes) {
-            json.scenes = json.scenes.map((scene, i) => this._resolveScene(scene, i));
-        }
-        if (json.scene !== undefined) {
-            json.scene = json.scenes[this.json.scene];
-        }
-    }
-    getScene(index) {
-        return this._get('scenes', index);
-    }
-    getNode(index) {
-        return this._get('nodes', index);
-    }
-    getSkin(index) {
-        return this._get('skins', index);
-    }
-    getMesh(index) {
-        return this._get('meshes', index);
-    }
-    getMaterial(index) {
-        return this._get('materials', index);
-    }
-    getAccessor(index) {
-        return this._get('accessors', index);
-    }
-    getCamera(index) {
-        return null; // TODO: fix this
-    }
-    getTexture(index) {
-        return this._get('textures', index);
-    }
-    getSampler(index) {
-        return this._get('samplers', index);
-    }
-    getImage(index) {
-        return this._get('images', index);
-    }
-    getBufferView(index) {
-        return this._get('bufferViews', index);
-    }
-    getBuffer(index) {
-        return this._get('buffers', index);
-    }
-    _get(array, index) {
-        // check if already resolved
-        if (typeof index === 'object') {
-            return index;
-        }
-        const object = this.json[array] && this.json[array][index];
-        if (!object) {
-            console.warn(`glTF file error: Could not find ${array}[${index}]`); // eslint-disable-line
-        }
-        return object;
-    }
-    // PARSING HELPERS
-    _resolveScene(scene, index) {
-        // scene = {...scene};
-        scene.id = scene.id || `scene-${index}`;
-        scene.nodes = (scene.nodes || []).map((node) => this.getNode(node));
-        return scene;
-    }
-    _resolveNode(node, index) {
-        // node = {...node};
-        node.id = node.id || `node-${index}`;
-        if (node.children) {
-            node.children = node.children.map((child) => this.getNode(child));
-        }
-        if (node.mesh !== undefined) {
-            node.mesh = this.getMesh(node.mesh);
-        }
-        else if (node.meshes !== undefined && node.meshes.length) {
-            node.mesh = node.meshes.reduce((accum, meshIndex) => {
-                const mesh = this.getMesh(meshIndex);
-                accum.id = mesh.id;
-                accum.primitives = accum.primitives.concat(mesh.primitives);
-                return accum;
-            }, { primitives: [] });
-        }
-        if (node.camera !== undefined) {
-            node.camera = this.getCamera(node.camera);
-        }
-        if (node.skin !== undefined) {
-            node.skin = this.getSkin(node.skin);
-        }
-        return node;
-    }
-    _resolveSkin(skin, index) {
-        // skin = {...skin};
-        skin.id = skin.id || `skin-${index}`;
-        skin.inverseBindMatrices = this.getAccessor(skin.inverseBindMatrices);
-        return skin;
-    }
-    _resolveMesh(mesh, index) {
-        // mesh = {...mesh};
-        mesh.id = mesh.id || `mesh-${index}`;
-        if (mesh.primitives) {
-            mesh.primitives = mesh.primitives.map((primitive) => {
-                primitive = { ...primitive };
-                const attributes = primitive.attributes;
-                primitive.attributes = {};
-                for (const attribute in attributes) {
-                    primitive.attributes[attribute] = this.getAccessor(attributes[attribute]);
-                }
-                if (primitive.indices !== undefined) {
-                    primitive.indices = this.getAccessor(primitive.indices);
-                }
-                if (primitive.material !== undefined) {
-                    primitive.material = this.getMaterial(primitive.material);
-                }
-                return primitive;
-            });
-        }
-        return mesh;
-    }
-    _resolveMaterial(material, index) {
-        // material = {...material};
-        material.id = material.id || `material-${index}`;
-        if (material.normalTexture) {
-            material.normalTexture = { ...material.normalTexture };
-            material.normalTexture.texture = this.getTexture(material.normalTexture.index);
-        }
-        if (material.occlusionTexture) {
-            material.occlustionTexture = { ...material.occlustionTexture };
-            material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);
-        }
-        if (material.emissiveTexture) {
-            material.emmisiveTexture = { ...material.emmisiveTexture };
-            material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);
-        }
-        if (!material.emissiveFactor) {
-            material.emissiveFactor = material.emmisiveTexture ? [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(accessor, index) {
-        // accessor = {...accessor};
-        accessor.id = accessor.id || `accessor-${index}`;
-        if (accessor.bufferView !== undefined) {
-            // Draco encoded meshes don't have bufferView
-            accessor.bufferView = this.getBufferView(accessor.bufferView);
-        }
-        // Look up enums
-        accessor.bytesPerComponent = getBytesFromComponentType(accessor.componentType);
-        accessor.components = getSizeFromAccessorType(accessor.type);
-        accessor.bytesPerElement = accessor.bytesPerComponent * accessor.components;
-        // 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(texture, index) {
-        // texture = {...texture};
-        texture.id = texture.id || `texture-${index}`;
-        texture.sampler = 'sampler' in texture ? this.getSampler(texture.sampler) : DEFAULT_SAMPLER;
-        texture.source = this.getImage(texture.source);
-        return texture;
-    }
-    _resolveSampler(sampler, index) {
-        // sampler = {...sampler};
-        sampler.id = sampler.id || `sampler-${index}`;
-        // Map textual parameters to GL parameter values
-        sampler.parameters = {};
-        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(image, index) {
-        // image = {...image};
-        image.id = image.id || `image-${index}`;
-        if (image.bufferView !== undefined) {
-            image.bufferView = this.getBufferView(image.bufferView);
-        }
-        // 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(bufferView, index) {
-        // bufferView = {...bufferView};
-        const bufferIndex = bufferView.buffer;
-        const result = {
-            id: `bufferView-${index}`,
-            ...bufferView,
-            buffer: this.buffers[bufferIndex]
-        };
-        // @ts-expect-error
-        const arrayBuffer = this.buffers[bufferIndex].arrayBuffer;
-        // @ts-expect-error
-        let byteOffset = this.buffers[bufferIndex].byteOffset || 0;
-        if ('byteOffset' in bufferView) {
-            byteOffset += bufferView.byteOffset;
-        }
-        result.data = new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
-        return result;
-    }
-    _resolveCamera(camera, index) {
-        camera.id = camera.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;