@loaders.gl/gltf 3.1.0-alpha.5 → 3.1.0-beta.1

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

@@ -0,0 +1,295 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 && material.values.tex;
+            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.d.ts

@@ -1 +1,2 @@
-export function postProcessGLTF(gltf: any, options: any): any;
+export declare function postProcessGLTF(gltf: any, options: any): Record<string, any>;
+//# sourceMappingURL=post-process-gltf.d.ts.map

package/dist/lib/api/post-process-gltf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-process-gltf.d.ts","sourceRoot":"","sources":["../../../src/lib/api/post-process-gltf.ts"],"names":[],"mappings":"AAwYA,wBAAgB,eAAe,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,uBAE5C"}

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

@@ -0,0 +1,346 @@
+"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;
+            const cutBufffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
+            accessor.value = new ArrayType(cutBufffer);
+        }
+        return accessor;
+    }
+    _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};
+        bufferView.id = bufferView.id || `bufferView-${index}`;
+        const bufferIndex = bufferView.buffer;
+        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;
+        }
+        bufferView.data = new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
+        return bufferView;
+    }
+    _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;

package/dist/lib/encoders/encode-glb.d.ts

@@ -1 +1,2 @@
 export default function encodeGLBSync(glb: any, dataView: any, byteOffset?: number, options?: {}): number;
+//# sourceMappingURL=encode-glb.d.ts.map

package/dist/lib/encoders/encode-glb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-glb.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-glb.ts"],"names":[],"mappings":"AAeA,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,GAAG,KAAA,EAAE,QAAQ,KAAA,EAAE,UAAU,SAAI,EAAE,OAAO,KAAK,UA2DhF"}