@zephyr3d/scene 0.9.1 → 0.9.3

package/dist/src/asset/loaders/gltf/gltf_loader.js

@@ -0,0 +1,1265 @@
+import { Matrix4x4, Vector3, Quaternion, Interpolator, DRef, Vector4 } from '@zephyr3d/base';
+import { SharedModel, AssetScene, AssetSkeleton } from '../../model.js';
+import { BoundingBox } from '../../../utility/bounding_volume.js';
+import { Primitive } from '../../../render/primitive.js';
+import '../../../material/shader/helper.js';
+import '../../../material/lambert.js';
+import '../../../material/blinn.js';
+import { UnlitMaterial } from '../../../material/unlit.js';
+import '../../../material/particle.js';
+import '@zephyr3d/device';
+import { MORPH_TARGET_POSITION, MORPH_TARGET_NORMAL, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_TARGET_COLOR } from '../../../values.js';
+import { Application } from '../../../app/app.js';
+import '../../../material/meshmaterial.js';
+import '../../../material/grassmaterial.js';
+import '../../../material/terrainmaterial.js';
+import '../../../material/terrain-cm.js';
+import { PBRMetallicRoughnessMaterial } from '../../../material/pbrmr.js';
+import { PBRSpecularGlossinessMaterial } from '../../../material/pbrsg.js';
+import { GLTFAccessor, ComponentType } from './helpers.js';
+import { AbstractModelLoader } from '../loader.js';
+import { DracoMeshDecoder } from '../../../utility/draco/decoder.js';
+
+/**
+ * The GLTF/GLB model loader
+ * @internal
+ */ class GLTFLoader extends AbstractModelLoader {
+    supportMIMEType(mimeType) {
+        return mimeType === 'model/gltf+json' || mimeType === 'model/gltf-binary';
+    }
+    async load(assetManager, url, mimeType, data, decoderModule) {
+        const buffer = await data.arrayBuffer();
+        if (this.isGLB(buffer)) {
+            return this.loadBinary(assetManager, url, buffer, assetManager.vfs, decoderModule);
+        }
+        const gltf = await new Response(data).json();
+        gltf._manager = assetManager;
+        gltf._device = Application.instance.device;
+        gltf._vfs = assetManager.vfs;
+        gltf._loadedBuffers = null;
+        return this.loadJson(url, gltf, decoderModule);
+    }
+    async loadBinary(assetManager, url, buffer, vfs, decoderModule) {
+        const jsonChunkType = 0x4e4f534a;
+        const binaryChunkType = 0x004e4942;
+        let gltf = null;
+        const buffers = [];
+        const chunkInfos = this.getGLBChunkInfos(buffer);
+        for (const info of chunkInfos){
+            if (info.type === jsonChunkType && !gltf) {
+                const jsonSlice = new Uint8Array(buffer, 20, info.length);
+                const stringBuffer = new TextDecoder('utf-8').decode(jsonSlice);
+                gltf = JSON.parse(stringBuffer);
+            } else if (info.type === binaryChunkType) {
+                buffers.push(buffer.slice(info.start, info.start + info.length));
+            }
+        }
+        if (gltf) {
+            gltf._manager = assetManager;
+            gltf._device = Application.instance.device;
+            gltf._vfs = vfs;
+            gltf._loadedBuffers = buffers;
+            return this.loadJson(url, gltf, decoderModule);
+        }
+        return null;
+    }
+    async loadJson(url, gltf, dracoDecoderModule) {
+        // check extensions
+        if (!dracoDecoderModule && gltf.extensionsRequired && gltf.extensionsRequired.indexOf('KHR_draco_mesh_compression') >= 0) {
+            console.error('Draco3d is required for loading model');
+            return null;
+        }
+        gltf._dracoModule = dracoDecoderModule;
+        gltf._accessors = [];
+        gltf._bufferCache = {};
+        gltf._textureCache = {};
+        gltf._materialCache = {};
+        gltf._nodes = [];
+        gltf._meshes = [];
+        // check asset property
+        const asset = gltf.asset;
+        if (asset) {
+            const gltfVersion = asset.version;
+            if (gltfVersion !== '2.0') {
+                console.error(`Invalid GLTF version: ${gltfVersion}`);
+                return null;
+            }
+        }
+        gltf._baseURI = url.substring(0, url.lastIndexOf('/') + 1);
+        if (!gltf._loadedBuffers) {
+            gltf._loadedBuffers = [];
+            const buffers = gltf.buffers;
+            if (buffers) {
+                for (const buffer of buffers){
+                    const uri = this._normalizeURI(gltf._baseURI, buffer.uri);
+                    const buf = await gltf._manager.fetchBinaryData(uri, null);
+                    if (buffer.byteLength !== buf.byteLength) {
+                        console.error(`Invalid GLTF: buffer byte length error.`);
+                        return null;
+                    }
+                    gltf._loadedBuffers.push(buf);
+                }
+            }
+        }
+        const accessors = gltf.accessors;
+        if (accessors) {
+            for (const accessor of gltf.accessors){
+                gltf._accessors.push(new GLTFAccessor(accessor));
+            }
+        }
+        const scenes = gltf.scenes;
+        if (scenes) {
+            const sharedModel = new SharedModel();
+            await this._loadMeshes(gltf);
+            this._loadNodes(gltf, sharedModel);
+            this._loadSkins(gltf, sharedModel);
+            for(let i = 0; i < gltf.nodes?.length; i++){
+                if (typeof gltf.nodes[i].skin === 'number' && gltf.nodes[i].skin >= 0) {
+                    gltf._nodes[i].skeleton = sharedModel.skeletons[gltf.nodes[i].skin];
+                }
+            }
+            this._loadAnimations(gltf, sharedModel);
+            for (const scene of scenes){
+                const assetScene = new AssetScene(scene.name);
+                for (const node of scene.nodes){
+                    assetScene.rootNodes.push(gltf._nodes[node]);
+                }
+                sharedModel.scenes.push(assetScene);
+            }
+            if (typeof gltf.scene === 'number') {
+                sharedModel.activeScene = gltf.scene;
+            }
+            return sharedModel;
+        }
+        return null;
+    }
+    /** @internal */ _normalizeURI(baseURI, uri) {
+        const s = uri.toLowerCase();
+        if (s.startsWith('http://') || s.startsWith('https://') || s.startsWith('blob:') || s.startsWith('data:')) {
+            // absolute path
+            return encodeURI(uri);
+        }
+        uri = uri.replace(/\.\//g, '');
+        uri = decodeURIComponent(uri);
+        if (uri[0] === '/') {
+            uri = uri.slice(1);
+        }
+        uri = uri.split('/').map((val)=>encodeURIComponent(val)).join('/');
+        return baseURI + uri;
+    }
+    /** @internal */ _loadNodes(gltf, model) {
+        if (gltf.nodes) {
+            for(let i = 0; i < gltf.nodes.length; i++){
+                this._loadNode(gltf, i, null, model);
+            }
+            for (const node of gltf._nodes){
+                if (!node.parent) {
+                    node.computeTransforms(null);
+                }
+            }
+        }
+    }
+    /** @internal */ _loadSkins(gltf, model) {
+        if (gltf.skins) {
+            for(let i = 0; i < gltf.skins.length; i++){
+                const skinInfo = gltf.skins[i];
+                const skeleton = new AssetSkeleton(skinInfo.name);
+                if (typeof skinInfo.skeleton === 'number') {
+                    skeleton.pivot = gltf._nodes[skinInfo.skeleton];
+                }
+                const accessor = gltf._accessors[skinInfo.inverseBindMatrices];
+                if (!accessor || accessor.type !== 'MAT4' || accessor.componentType !== ComponentType.FLOAT) {
+                    throw new Error('Invalid GLTF inverse bind matricies accessor');
+                }
+                const matrices = typeof skinInfo.inverseBindMatrices === 'number' ? accessor.getDeinterlacedView(gltf) : null;
+                skinInfo.joints.forEach((joint, index)=>{
+                    const m = index * 16;
+                    skeleton.addJoint(gltf._nodes[joint], matrices ? new Matrix4x4(matrices.subarray(m, m + 16)) : Matrix4x4.identity());
+                });
+                model.addSkeleton(skeleton);
+            }
+        }
+    }
+    /** @internal */ _loadAnimations(gltf, model) {
+        if (gltf.animations) {
+            for(let i = 0; i < gltf.animations.length; i++){
+                const animation = this._loadAnimation(gltf, i);
+                model.addAnimation(animation);
+            }
+        }
+    }
+    /** @internal */ collectNodes(gltf) {
+        const collect = new Map();
+        for (const node of gltf._nodes){
+            collect.set(node, {
+                translate: node.position || Vector3.zero(),
+                rotation: node.rotation || Quaternion.identity(),
+                scale: node.scaling || Vector3.one(),
+                worldTransform: null
+            });
+        }
+        return collect;
+    }
+    /** @internal */ getAnimationInfo(gltf, index) {
+        const animationInfo = gltf.animations[index];
+        const name = animationInfo.name || null;
+        const channels = animationInfo.channels;
+        const samplers = animationInfo.samplers;
+        const interpolators = [];
+        const interpolatorTypes = [];
+        const nodes = this.collectNodes(gltf);
+        let maxTime = 0;
+        for(let i = 0; i < channels.length; i++){
+            const channel = channels[i];
+            const sampler = samplers[channel.sampler];
+            const input = gltf._accessors[sampler.input].getNormalizedDeinterlacedView(gltf);
+            const output = gltf._accessors[sampler.output].getNormalizedDeinterlacedView(gltf);
+            if (!(input instanceof Float32Array) || !(output instanceof Float32Array)) {
+                console.error('Input/output channel of animation must be Float32Array');
+                continue;
+            }
+            const mode = sampler.interpolation === 'STEP' ? 'step' : sampler.interpolation === 'CUBICSPLINE' ? 'cubicspline' : 'linear';
+            if (channel.target.path === 'rotation') {
+                interpolators.push(new Interpolator(mode, 'quat', input, output));
+                interpolatorTypes.push('rotation');
+            } else if (channel.target.path === 'translation') {
+                interpolators.push(new Interpolator(mode, 'vec3', input, output));
+                interpolatorTypes.push('translation');
+            } else if (channel.target.path === 'scale') {
+                interpolators.push(new Interpolator(mode, 'vec3', input, output));
+                interpolatorTypes.push('scale');
+            } else if (channel.target.path === 'weights') {
+                interpolators.push(new Interpolator(mode, null, input, output));
+                interpolatorTypes.push('weights');
+            } else {
+                continue;
+            }
+            const max = input[input.length - 1];
+            if (max > maxTime) {
+                maxTime = max;
+            }
+        }
+        return {
+            name,
+            channels,
+            samplers,
+            interpolators,
+            interpolatorTypes,
+            maxTime,
+            nodes
+        };
+    }
+    /** @internal */ _loadAnimation(gltf, index) {
+        const animationInfo = this.getAnimationInfo(gltf, index);
+        const animationData = {
+            name: animationInfo.name,
+            tracks: [],
+            skeletons: [],
+            nodes: []
+        };
+        for(let i = 0; i < animationInfo.channels.length; i++){
+            const targetNode = gltf._nodes[animationInfo.channels[i].target.node];
+            const track = {
+                node: targetNode,
+                type: animationInfo.interpolatorTypes[i],
+                interpolator: animationInfo.interpolators[i]
+            };
+            if (track.type === 'weights') {
+                track.defaultMorphWeights = targetNode.weights;
+            }
+            animationData.tracks.push(track);
+            if (animationData.nodes.indexOf(targetNode) < 0) {
+                animationData.nodes.push(targetNode);
+            }
+            if (targetNode.skeletonAttached) {
+                for (const skeleton of targetNode.skeletonAttached){
+                    if (animationData.skeletons.indexOf(skeleton) < 0) {
+                        animationData.skeletons.push(skeleton);
+                    }
+                }
+            }
+        }
+        return animationData;
+    }
+    /** @internal */ _loadNode(gltf, nodeIndex, parent, model) {
+        let node = gltf._nodes[nodeIndex];
+        if (node) {
+            if (parent) {
+                if (node.parent) {
+                    throw new Error('invalid node hierarchy');
+                }
+                parent.addChild(node);
+            }
+            return node;
+        }
+        const nodeInfo = gltf.nodes?.[nodeIndex];
+        if (nodeInfo) {
+            node = model.addNode(parent, nodeIndex, nodeInfo.name);
+            if (typeof nodeInfo.mesh === 'number') {
+                node.mesh = gltf._meshes[nodeInfo.mesh];
+                if (node.weights) {
+                    node.mesh.morphWeights = node.weights;
+                }
+                const instancing = nodeInfo.extensions?.['EXT_mesh_gpu_instancing'];
+                if (instancing) {
+                    const attributes = instancing.attributes;
+                    if (attributes) {
+                        const accessorTranslation = typeof attributes.TRANSLATION === 'number' ? gltf._accessors[attributes.TRANSLATION] : null;
+                        const accessorScale = typeof attributes.SCALE === 'number' ? gltf._accessors[attributes.SCALE] : null;
+                        const accessorRotation = typeof attributes.ROTATION === 'number' ? gltf._accessors[attributes.ROTATION] : null;
+                        const count = accessorTranslation?.count ?? accessorScale?.count ?? accessorRotation.count ?? 0;
+                        const translationValues = accessorTranslation?.getNormalizedDeinterlacedView(gltf);
+                        const scaleValues = accessorScale?.getNormalizedDeinterlacedView(gltf);
+                        const rotationValues = accessorRotation?.getNormalizedDeinterlacedView(gltf);
+                        for(let i = 0; i < count; i++){
+                            const t = translationValues ? new Vector3(translationValues[i * 3], translationValues[i * 3 + 1], translationValues[i * 3 + 2]) : Vector3.zero();
+                            const s = scaleValues ? new Vector3(scaleValues[i * 3], scaleValues[i * 3 + 1], scaleValues[i * 3 + 2]) : Vector3.one();
+                            const r = rotationValues ? new Quaternion(rotationValues[i * 4], rotationValues[i * 4 + 1], rotationValues[i * 4 + 2], rotationValues[i * 4 + 3]) : Quaternion.identity();
+                            node.instances.push({
+                                t,
+                                s,
+                                r
+                            });
+                        }
+                    }
+                } else {
+                    node.instances.push({
+                        t: Vector3.zero(),
+                        s: Vector3.one(),
+                        r: Quaternion.identity()
+                    });
+                }
+            }
+            if (!(typeof nodeInfo.skin === 'number') || nodeInfo.skin < 0) {
+                // GLTF spec: Only the joint transforms are applied to the skinned mesh; the transform of the skinned mesh node MUST be ignored.
+                if (nodeInfo.matrix) {
+                    const matrix = new Matrix4x4(nodeInfo.matrix);
+                    matrix.decompose(node.scaling, node.rotation, node.position);
+                } else {
+                    if (nodeInfo.rotation) {
+                        node.rotation.set(nodeInfo.rotation);
+                    }
+                    if (nodeInfo.scale) {
+                        node.scaling.set(nodeInfo.scale);
+                    }
+                    if (nodeInfo.translation) {
+                        node.position.set(nodeInfo.translation);
+                    }
+                }
+            }
+            gltf._nodes[nodeIndex] = node;
+            if (nodeInfo.children) {
+                for (const childIndex of nodeInfo.children){
+                    this._loadNode(gltf, childIndex, node, model);
+                }
+            }
+        } else {
+            throw new Error(`invalid GLTF node: ${nodeIndex}`);
+        }
+        return node;
+    }
+    /** @internal */ async _loadMeshes(gltf) {
+        if (gltf.meshes) {
+            for(let i = 0; i < gltf.meshes.length; i++){
+                gltf._meshes[i] = await this._loadMesh(gltf, i);
+            }
+        }
+    }
+    /** @internal */ async _loadMesh(gltf, meshIndex) {
+        const meshInfo = gltf.meshes && gltf.meshes[meshIndex];
+        let mesh = null;
+        if (meshInfo) {
+            mesh = {
+                morphWeights: meshInfo.weights ?? null,
+                subMeshes: []
+            };
+            const primitives = meshInfo.primitives;
+            const meshName = meshInfo.name || null;
+            if (primitives) {
+                for(let i = 0; i < primitives.length; i++){
+                    const p = primitives[i];
+                    const subMeshData = {
+                        name: `${meshName}-${i}`,
+                        primitive: new DRef(),
+                        material: new DRef(),
+                        rawPositions: null,
+                        rawBlendIndices: null,
+                        rawJointWeights: null,
+                        numTargets: 0
+                    };
+                    const primitive = new Primitive();
+                    const attributes = p.attributes;
+                    const dracoExtension = gltf._dracoModule ? p.extensions?.['KHR_draco_mesh_compression'] : null;
+                    let dracoMeshDecoder = null;
+                    if (dracoExtension) {
+                        const bufferView = gltf.bufferViews && gltf.bufferViews[dracoExtension.bufferView];
+                        if (!bufferView) {
+                            throw new Error('Draco buffer view not set');
+                        }
+                        const arrayBuffer = gltf._loadedBuffers && gltf._loadedBuffers[bufferView.buffer];
+                        if (!arrayBuffer) {
+                            throw new Error('Draco buffer view does not point to a valid ArrayBuffer');
+                        }
+                        dracoMeshDecoder = new DracoMeshDecoder(new Int8Array(arrayBuffer, bufferView.byteOffset ?? 0, bufferView.byteLength), gltf._dracoModule);
+                    }
+                    for(const attrib in attributes){
+                        this._loadVertexBuffer(gltf, attrib, attributes[attrib], primitive, subMeshData, dracoExtension, dracoMeshDecoder);
+                    }
+                    if (p.targets) {
+                        if (Application.instance.device.type === 'webgl') {
+                            // Emulate vertexID for WebGL1 device
+                            if (attributes['TEXCOORD_7'] !== undefined) {
+                                console.error(`Could not load morph target animation`);
+                                p.targets = null;
+                            } else {
+                                const vertexIndices = new Float32Array(primitive.getNumVertices());
+                                for(let i = 0; i < vertexIndices.length; i++){
+                                    vertexIndices[i] = i;
+                                }
+                                primitive.createAndSetVertexBuffer('tex7_f32', vertexIndices);
+                            }
+                        }
+                    }
+                    if (p.targets) {
+                        const targets = {};
+                        const targetBox = [];
+                        const targetMap = {
+                            POSITION: MORPH_TARGET_POSITION,
+                            NORMAL: MORPH_TARGET_NORMAL,
+                            TANGENT: MORPH_TARGET_TANGENT,
+                            TEXCOORD_0: MORPH_TARGET_TEX0,
+                            TEXCOORD_1: MORPH_TARGET_TEX1,
+                            TEXCOORD_2: MORPH_TARGET_TEX2,
+                            TEXCOORD_3: MORPH_TARGET_TEX3,
+                            COLOR_0: MORPH_TARGET_COLOR
+                        };
+                        const morphAttribSet = new Set();
+                        for (const target of p.targets){
+                            for(const k in target){
+                                const t = targetMap[k];
+                                if (t !== undefined) {
+                                    targets[t] = targets[t] ?? {
+                                        numComponents: 0,
+                                        data: []
+                                    };
+                                    const accessorIndex = target[k];
+                                    const accessor = gltf._accessors[accessorIndex];
+                                    targets[t].numComponents = accessor.getComponentCount(accessor.type);
+                                    targets[t].data.push(accessor.getNormalizedDeinterlacedView(gltf));
+                                    if (k === 'POSITION') {
+                                        const min = accessor.min ? new Vector3(accessor.min[0], accessor.min[1], accessor.min[2]) : Vector3.zero();
+                                        const max = accessor.max ? new Vector3(accessor.max[0], accessor.max[1], accessor.max[2]) : Vector3.zero();
+                                        targetBox.push(new BoundingBox(min, max));
+                                    }
+                                    morphAttribSet.add(t);
+                                }
+                            }
+                        }
+                        subMeshData.numTargets = p.targets.length;
+                        subMeshData.targets = targets;
+                        subMeshData.targetBox = targetBox;
+                        subMeshData.morphAttribCount = morphAttribSet.size;
+                    }
+                    const indices = p.indices;
+                    if (typeof indices === 'number') {
+                        this._loadIndexBuffer(gltf, indices, primitive, subMeshData, dracoExtension, dracoMeshDecoder);
+                    }
+                    let primitiveType = p.mode;
+                    if (typeof primitiveType !== 'number') {
+                        primitiveType = 4;
+                    }
+                    primitive.primitiveType = this._primitiveType(primitiveType);
+                    const hasVertexNormal = !!primitive.getVertexBuffer('normal');
+                    const hasVertexColor = !!primitive.getVertexBuffer('diffuse');
+                    const hasVertexTangent = !!primitive.getVertexBuffer('tangent');
+                    const materialHash = `${p.material}.${Number(hasVertexNormal)}.${Number(hasVertexColor)}.${Number(hasVertexTangent)}`;
+                    let material = gltf._materialCache[materialHash];
+                    if (!material) {
+                        const materialInfo = p.material !== undefined ? gltf.materials[p.material] : null;
+                        material = await this._loadMaterial(gltf, materialInfo, hasVertexColor, hasVertexNormal, hasVertexTangent);
+                        gltf._materialCache[materialHash] = material;
+                    }
+                    subMeshData.primitive.set(primitive);
+                    subMeshData.material.set(material);
+                    mesh.subMeshes.push(subMeshData);
+                }
+            }
+        }
+        return mesh;
+    }
+    async _createMaterial(assetMaterial) {
+        if (assetMaterial.type === 'unlit') {
+            const unlitAssetMaterial = assetMaterial;
+            const unlitMaterial = new UnlitMaterial();
+            unlitMaterial.albedoColor = unlitAssetMaterial.diffuse ?? Vector4.one();
+            if (unlitAssetMaterial.diffuseMap) {
+                unlitMaterial.albedoTexture = unlitAssetMaterial.diffuseMap.texture;
+                unlitMaterial.albedoTextureSampler = unlitAssetMaterial.diffuseMap.sampler;
+                unlitMaterial.albedoTexCoordIndex = unlitAssetMaterial.diffuseMap.texCoord;
+                unlitMaterial.albedoTexCoordMatrix = unlitAssetMaterial.diffuseMap.transform;
+            }
+            unlitMaterial.vertexColor = unlitAssetMaterial.common.vertexColor;
+            if (assetMaterial.common.alphaMode === 'blend') {
+                unlitMaterial.blendMode = 'blend';
+            } else if (assetMaterial.common.alphaMode === 'mask') {
+                unlitMaterial.alphaCutoff = assetMaterial.common.alphaCutoff;
+            }
+            if (assetMaterial.common.doubleSided) {
+                unlitMaterial.cullMode = 'none';
+            }
+            return unlitMaterial;
+        } else if (assetMaterial.type === 'pbrSpecularGlossiness') {
+            const assetPBRMaterial = assetMaterial;
+            const pbrMaterial = new PBRSpecularGlossinessMaterial();
+            pbrMaterial.ior = assetPBRMaterial.ior;
+            pbrMaterial.albedoColor = assetPBRMaterial.diffuse;
+            pbrMaterial.specularFactor = new Vector3(assetPBRMaterial.specular.x, assetPBRMaterial.specular.y, assetPBRMaterial.specular.z);
+            pbrMaterial.glossinessFactor = assetPBRMaterial.glossness;
+            if (assetPBRMaterial.diffuseMap) {
+                pbrMaterial.albedoTexture = assetPBRMaterial.diffuseMap.texture;
+                pbrMaterial.albedoTextureSampler = assetPBRMaterial.diffuseMap.sampler;
+                pbrMaterial.albedoTexCoordIndex = assetPBRMaterial.diffuseMap.texCoord;
+                pbrMaterial.albedoTexCoordMatrix = assetPBRMaterial.diffuseMap.transform;
+            }
+            if (assetPBRMaterial.common.normalMap) {
+                pbrMaterial.normalTexture = assetPBRMaterial.common.normalMap.texture;
+                pbrMaterial.normalTextureSampler = assetPBRMaterial.common.normalMap.sampler;
+                pbrMaterial.normalTexCoordIndex = assetPBRMaterial.common.normalMap.texCoord;
+                pbrMaterial.normalTexCoordMatrix = assetPBRMaterial.common.normalMap.transform;
+            }
+            pbrMaterial.normalScale = assetPBRMaterial.common.bumpScale;
+            if (assetPBRMaterial.common.emissiveMap) {
+                pbrMaterial.emissiveTexture = assetPBRMaterial.common.emissiveMap.texture;
+                pbrMaterial.emissiveTextureSampler = assetPBRMaterial.common.emissiveMap.sampler;
+                pbrMaterial.emissiveTexCoordIndex = assetPBRMaterial.common.emissiveMap.texCoord;
+                pbrMaterial.emissiveTexCoordMatrix = assetPBRMaterial.common.emissiveMap.transform;
+            }
+            pbrMaterial.emissiveColor = assetPBRMaterial.common.emissiveColor;
+            pbrMaterial.emissiveStrength = assetPBRMaterial.common.emissiveStrength;
+            if (assetPBRMaterial.common.occlusionMap) {
+                pbrMaterial.occlusionTexture = assetPBRMaterial.common.occlusionMap.texture;
+                pbrMaterial.occlusionTextureSampler = assetPBRMaterial.common.occlusionMap.sampler;
+                pbrMaterial.occlusionTexCoordIndex = assetPBRMaterial.common.occlusionMap.texCoord;
+                pbrMaterial.occlusionTexCoordMatrix = assetPBRMaterial.common.occlusionMap.transform;
+            }
+            pbrMaterial.occlusionStrength = assetPBRMaterial.common.occlusionStrength;
+            if (assetPBRMaterial.specularGlossnessMap) {
+                pbrMaterial.specularTexture = assetPBRMaterial.specularGlossnessMap.texture;
+                pbrMaterial.specularTextureSampler = assetPBRMaterial.specularGlossnessMap.sampler;
+                pbrMaterial.specularTexCoordIndex = assetPBRMaterial.specularGlossnessMap.texCoord;
+                pbrMaterial.specularTexCoordMatrix = assetPBRMaterial.specularGlossnessMap.transform;
+            }
+            pbrMaterial.vertexTangent = assetPBRMaterial.common.useTangent;
+            pbrMaterial.vertexColor = assetPBRMaterial.common.vertexColor;
+            if (assetPBRMaterial.common.alphaMode === 'blend') {
+                pbrMaterial.blendMode = 'blend';
+            } else if (assetPBRMaterial.common.alphaMode === 'mask') {
+                pbrMaterial.alphaCutoff = assetPBRMaterial.common.alphaCutoff;
+            }
+            if (assetPBRMaterial.common.doubleSided) {
+                pbrMaterial.cullMode = 'none';
+            }
+            pbrMaterial.vertexNormal = !!assetMaterial.common.vertexNormal;
+            return pbrMaterial;
+        } else if (assetMaterial.type === 'pbrMetallicRoughness') {
+            const assetPBRMaterial = assetMaterial;
+            const pbrMaterial = new PBRMetallicRoughnessMaterial();
+            pbrMaterial.ior = assetPBRMaterial.ior;
+            pbrMaterial.albedoColor = assetPBRMaterial.diffuse;
+            pbrMaterial.metallic = assetPBRMaterial.metallic;
+            pbrMaterial.roughness = assetPBRMaterial.roughness;
+            if (assetPBRMaterial.diffuseMap) {
+                pbrMaterial.albedoTexture = assetPBRMaterial.diffuseMap.texture;
+                pbrMaterial.albedoTextureSampler = assetPBRMaterial.diffuseMap.sampler;
+                pbrMaterial.albedoTexCoordIndex = assetPBRMaterial.diffuseMap.texCoord;
+                pbrMaterial.albedoTexCoordMatrix = assetPBRMaterial.diffuseMap.transform;
+            }
+            if (assetPBRMaterial.common.normalMap) {
+                pbrMaterial.normalTexture = assetPBRMaterial.common.normalMap.texture;
+                pbrMaterial.normalTextureSampler = assetPBRMaterial.common.normalMap.sampler;
+                pbrMaterial.normalTexCoordIndex = assetPBRMaterial.common.normalMap.texCoord;
+                pbrMaterial.normalTexCoordMatrix = assetPBRMaterial.common.normalMap.transform;
+            }
+            pbrMaterial.normalScale = assetPBRMaterial.common.bumpScale;
+            if (assetPBRMaterial.common.emissiveMap) {
+                pbrMaterial.emissiveTexture = assetPBRMaterial.common.emissiveMap.texture;
+                pbrMaterial.emissiveTextureSampler = assetPBRMaterial.common.emissiveMap.sampler;
+                pbrMaterial.emissiveTexCoordIndex = assetPBRMaterial.common.emissiveMap.texCoord;
+                pbrMaterial.emissiveTexCoordMatrix = assetPBRMaterial.common.emissiveMap.transform;
+            }
+            pbrMaterial.emissiveColor = assetPBRMaterial.common.emissiveColor;
+            pbrMaterial.emissiveStrength = assetPBRMaterial.common.emissiveStrength;
+            if (assetPBRMaterial.common.occlusionMap) {
+                pbrMaterial.occlusionTexture = assetPBRMaterial.common.occlusionMap.texture;
+                pbrMaterial.occlusionTextureSampler = assetPBRMaterial.common.occlusionMap.sampler;
+                pbrMaterial.occlusionTexCoordIndex = assetPBRMaterial.common.occlusionMap.texCoord;
+                pbrMaterial.occlusionTexCoordMatrix = assetPBRMaterial.common.occlusionMap.transform;
+                pbrMaterial.occlusionStrength = assetPBRMaterial.common.occlusionStrength;
+            }
+            if (assetPBRMaterial.metallicMap) {
+                pbrMaterial.metallicRoughnessTexture = assetPBRMaterial.metallicMap.texture;
+                pbrMaterial.metallicRoughnessTextureSampler = assetPBRMaterial.metallicMap.sampler;
+                pbrMaterial.metallicRoughnessTexCoordIndex = assetPBRMaterial.metallicMap.texCoord;
+                pbrMaterial.metallicRoughnessTexCoordMatrix = assetPBRMaterial.metallicMap.transform;
+            }
+            pbrMaterial.specularFactor = assetPBRMaterial.specularFactor;
+            if (assetPBRMaterial.specularMap) {
+                pbrMaterial.specularTexture = assetPBRMaterial.specularMap.texture;
+                pbrMaterial.specularTextureSampler = assetPBRMaterial.specularMap.sampler;
+                pbrMaterial.specularTexCoordIndex = assetPBRMaterial.specularMap.texCoord;
+                pbrMaterial.specularTexCoordMatrix = assetPBRMaterial.specularMap.transform;
+            }
+            if (assetPBRMaterial.specularColorMap) {
+                pbrMaterial.specularColorTexture = assetPBRMaterial.specularColorMap.texture;
+                pbrMaterial.specularColorTextureSampler = assetPBRMaterial.specularColorMap.sampler;
+                pbrMaterial.specularColorTexCoordIndex = assetPBRMaterial.specularColorMap.texCoord;
+                pbrMaterial.specularColorTexCoordMatrix = assetPBRMaterial.specularColorMap.transform;
+            }
+            if (assetPBRMaterial.sheen) {
+                const sheen = assetPBRMaterial.sheen;
+                pbrMaterial.sheen = true;
+                pbrMaterial.sheenColorFactor = sheen.sheenColorFactor;
+                pbrMaterial.sheenRoughnessFactor = sheen.sheenRoughnessFactor;
+                if (sheen.sheenColorMap) {
+                    pbrMaterial.sheenColorTexture = sheen.sheenColorMap.texture;
+                    pbrMaterial.sheenColorTextureSampler = sheen.sheenColorMap.sampler;
+                    pbrMaterial.sheenColorTexCoordIndex = sheen.sheenColorMap.texCoord;
+                    pbrMaterial.sheenColorTexCoordMatrix = sheen.sheenColorMap.transform;
+                }
+                if (sheen.sheenRoughnessMap) {
+                    pbrMaterial.sheenRoughnessTexture = sheen.sheenRoughnessMap.texture;
+                    pbrMaterial.sheenRoughnessTextureSampler = sheen.sheenRoughnessMap.sampler;
+                    pbrMaterial.sheenRoughnessTexCoordIndex = sheen.sheenRoughnessMap.texCoord;
+                    pbrMaterial.sheenRoughnessTexCoordMatrix = sheen.sheenRoughnessMap.transform;
+                }
+            }
+            if (assetPBRMaterial.iridescence) {
+                const iridescence = assetPBRMaterial.iridescence;
+                pbrMaterial.iridescence = true;
+                pbrMaterial.iridescenceFactor = iridescence.iridescenceFactor;
+                pbrMaterial.iridescenceIor = iridescence.iridescenceIor;
+                if (iridescence.iridescenceMap) {
+                    pbrMaterial.iridescenceTexture = iridescence.iridescenceMap.texture;
+                    pbrMaterial.iridescenceTextureSampler = iridescence.iridescenceMap.sampler;
+                    pbrMaterial.iridescenceTexCoordIndex = iridescence.iridescenceMap.texCoord;
+                    pbrMaterial.iridescenceTexCoordMatrix = iridescence.iridescenceMap.transform;
+                }
+                pbrMaterial.iridescenceThicknessMin = iridescence.iridescenceThicknessMinimum;
+                pbrMaterial.iridescenceThicknessMax = iridescence.iridescenceThicknessMaximum;
+                if (iridescence.iridescenceThicknessMap) {
+                    pbrMaterial.iridescenceThicknessTexture = iridescence.iridescenceThicknessMap.texture;
+                    pbrMaterial.iridescenceThicknessTextureSampler = iridescence.iridescenceThicknessMap.sampler;
+                    pbrMaterial.iridescenceThicknessTexCoordIndex = iridescence.iridescenceThicknessMap.texCoord;
+                    pbrMaterial.iridescenceThicknessTexCoordMatrix = iridescence.iridescenceThicknessMap.transform;
+                }
+            }
+            if (assetPBRMaterial.transmission) {
+                const transmission = assetPBRMaterial.transmission;
+                pbrMaterial.transmission = true;
+                pbrMaterial.transmissionFactor = transmission.transmissionFactor;
+                if (transmission.transmissionMap) {
+                    pbrMaterial.transmissionTexture = transmission.transmissionMap.texture;
+                    pbrMaterial.transmissionTextureSampler = transmission.transmissionMap.sampler;
+                    pbrMaterial.transmissionTexCoordIndex = transmission.transmissionMap.texCoord;
+                    pbrMaterial.transmissionTexCoordMatrix = transmission.transmissionMap.transform;
+                }
+                pbrMaterial.thicknessFactor = transmission.thicknessFactor;
+                if (transmission.thicknessMap) {
+                    pbrMaterial.thicknessTexture = transmission.thicknessMap.texture;
+                    pbrMaterial.thicknessTextureSampler = transmission.thicknessMap.sampler;
+                    pbrMaterial.thicknessTexCoordIndex = transmission.thicknessMap.texCoord;
+                    pbrMaterial.thicknessTexCoordMatrix = transmission.thicknessMap.transform;
+                }
+                pbrMaterial.attenuationDistance = transmission.attenuationDistance;
+                pbrMaterial.attenuationColor = transmission.attenuationColor;
+            }
+            if (assetPBRMaterial.clearcoat) {
+                const cc = assetPBRMaterial.clearcoat;
+                pbrMaterial.clearcoat = true;
+                pbrMaterial.clearcoatIntensity = cc.clearCoatFactor;
+                pbrMaterial.clearcoatRoughnessFactor = cc.clearCoatRoughnessFactor;
+                if (cc.clearCoatIntensityMap) {
+                    pbrMaterial.clearcoatIntensityTexture = cc.clearCoatIntensityMap.texture;
+                    pbrMaterial.clearcoatIntensityTextureSampler = cc.clearCoatIntensityMap.sampler;
+                    pbrMaterial.clearcoatIntensityTexCoordIndex = cc.clearCoatIntensityMap.texCoord;
+                    pbrMaterial.clearcoatIntensityTexCoordMatrix = cc.clearCoatIntensityMap.transform;
+                }
+                if (cc.clearCoatRoughnessMap) {
+                    pbrMaterial.clearcoatRoughnessTexture = cc.clearCoatRoughnessMap.texture;
+                    pbrMaterial.clearcoatRoughnessTextureSampler = cc.clearCoatRoughnessMap.sampler;
+                    pbrMaterial.clearcoatRoughnessTexCoordIndex = cc.clearCoatRoughnessMap.texCoord;
+                    pbrMaterial.clearcoatRoughnessTexCoordMatrix = cc.clearCoatRoughnessMap.transform;
+                }
+                if (cc.clearCoatNormalMap) {
+                    pbrMaterial.clearcoatNormalTexture = cc.clearCoatNormalMap.texture;
+                    pbrMaterial.clearcoatNormalTextureSampler = cc.clearCoatNormalMap.sampler;
+                    pbrMaterial.clearcoatNormalTexCoordIndex = cc.clearCoatNormalMap.texCoord;
+                    pbrMaterial.clearcoatNormalTexCoordMatrix = cc.clearCoatNormalMap.transform;
+                }
+            }
+            pbrMaterial.vertexTangent = assetPBRMaterial.common.useTangent;
+            pbrMaterial.vertexColor = assetPBRMaterial.common.vertexColor;
+            if (assetPBRMaterial.common.alphaMode === 'blend') {
+                pbrMaterial.blendMode = 'blend';
+            } else if (assetPBRMaterial.common.alphaMode === 'mask') {
+                pbrMaterial.alphaCutoff = assetPBRMaterial.common.alphaCutoff;
+            }
+            if (assetPBRMaterial.common.doubleSided) {
+                pbrMaterial.cullMode = 'none';
+            }
+            pbrMaterial.vertexNormal = !!assetMaterial.common.vertexNormal;
+            return pbrMaterial;
+        }
+    }
+    /** @internal */ async _loadMaterial(gltf, materialInfo, vertexColor, vertexNormal, useTangent) {
+        let assetMaterial = null;
+        let pbrMetallicRoughness = null;
+        let pbrSpecularGlossness = null;
+        const pbrCommon = {
+            useTangent,
+            vertexColor,
+            vertexNormal,
+            bumpScale: 1,
+            emissiveColor: Vector3.zero(),
+            emissiveStrength: 1,
+            occlusionStrength: 1
+        };
+        switch(materialInfo?.alphaMode){
+            case 'BLEND':
+                {
+                    pbrCommon.alphaMode = 'blend';
+                    break;
+                }
+            case 'MASK':
+                {
+                    pbrCommon.alphaMode = 'mask';
+                    pbrCommon.alphaCutoff = materialInfo.alphaCutoff ?? 0.5;
+                    break;
+                }
+        }
+        if (materialInfo?.doubleSided) {
+            pbrCommon.doubleSided = true;
+        }
+        if (materialInfo?.pbrMetallicRoughness || materialInfo?.extensions?.KHR_materials_pbrSpecularGlossiness) {
+            pbrCommon.normalMap = materialInfo.normalTexture ? await this._loadTexture(gltf, materialInfo.normalTexture, false) : null;
+            pbrCommon.bumpScale = materialInfo.normalTexture?.scale ?? 1;
+            pbrCommon.occlusionMap = materialInfo.occlusionTexture ? await this._loadTexture(gltf, materialInfo.occlusionTexture, false) : null;
+            pbrCommon.occlusionStrength = materialInfo.occlusionTexture?.strength ?? 1;
+            pbrCommon.emissiveMap = materialInfo.emissiveTexture ? await this._loadTexture(gltf, materialInfo.emissiveTexture, false) : null;
+            pbrCommon.emissiveStrength = materialInfo?.extensions?.KHR_materials_emissive_strength?.emissiveStrength ?? 1;
+            pbrCommon.emissiveColor = materialInfo.emissiveFactor ? new Vector3(materialInfo.emissiveFactor) : Vector3.zero();
+        }
+        if (materialInfo?.pbrMetallicRoughness) {
+            pbrMetallicRoughness = {
+                type: 'pbrMetallicRoughness',
+                ior: 1.5,
+                common: pbrCommon
+            };
+            pbrMetallicRoughness.diffuse = new Vector4(materialInfo.pbrMetallicRoughness.baseColorFactor ?? [
+                1,
+                1,
+                1,
+                1
+            ]);
+            pbrMetallicRoughness.metallic = materialInfo.pbrMetallicRoughness.metallicFactor ?? 1;
+            pbrMetallicRoughness.roughness = materialInfo.pbrMetallicRoughness.roughnessFactor ?? 1;
+            pbrMetallicRoughness.diffuseMap = materialInfo.pbrMetallicRoughness.baseColorTexture ? await this._loadTexture(gltf, materialInfo.pbrMetallicRoughness.baseColorTexture, true) : null;
+            pbrMetallicRoughness.metallicMap = materialInfo.pbrMetallicRoughness.metallicRoughnessTexture ? await this._loadTexture(gltf, materialInfo.pbrMetallicRoughness.metallicRoughnessTexture, false) : null;
+            pbrMetallicRoughness.metallicIndex = 2;
+            pbrMetallicRoughness.roughnessIndex = 1;
+        }
+        if (materialInfo?.extensions?.KHR_materials_pbrSpecularGlossiness) {
+            const sg = materialInfo.extensions?.KHR_materials_pbrSpecularGlossiness;
+            pbrSpecularGlossness = {
+                type: 'pbrSpecularGlossiness',
+                ior: 1.5,
+                common: pbrCommon
+            };
+            pbrSpecularGlossness.diffuse = new Vector4(sg.diffuseFactor ?? [
+                1,
+                1,
+                1,
+                1
+            ]);
+            pbrSpecularGlossness.specular = new Vector3(sg.specularFactor ?? [
+                1,
+                1,
+                1
+            ]);
+            pbrSpecularGlossness.glossness = sg.glossnessFactor ?? 1;
+            pbrSpecularGlossness.diffuseMap = sg.diffuseTexture ? await this._loadTexture(gltf, sg.diffuseTexture, true) : null;
+            pbrSpecularGlossness.specularGlossnessMap = sg.specularGlossinessTexture ? await this._loadTexture(gltf, sg.specularGlossinessTexture, true) : null;
+        }
+        assetMaterial = pbrSpecularGlossness || pbrMetallicRoughness;
+        if (!assetMaterial || materialInfo?.extensions?.KHR_materials_unlit) {
+            if (materialInfo?.extensions?.KHR_materials_unlit) {
+                assetMaterial = {
+                    type: 'unlit',
+                    common: pbrCommon,
+                    diffuse: pbrMetallicRoughness?.diffuse ?? Vector4.one(),
+                    diffuseMap: pbrMetallicRoughness?.diffuseMap ?? null
+                };
+            } else {
+                assetMaterial = {
+                    type: 'pbrMetallicRoughness',
+                    common: pbrCommon,
+                    diffuse: Vector4.one(),
+                    metallic: 1,
+                    roughness: 1,
+                    diffuseMap: null,
+                    metallicMap: null,
+                    metallicIndex: 2,
+                    roughnessIndex: 1
+                };
+            }
+        }
+        if (assetMaterial.type !== 'unlit' && materialInfo?.extensions?.KHR_materials_ior) {
+            assetMaterial.ior = materialInfo.extensions.KHR_materials_ior.ior ?? 1.5;
+        }
+        if (assetMaterial.type === 'pbrMetallicRoughness') {
+            pbrMetallicRoughness = assetMaterial;
+            // KHR_materials_specular extension
+            const specularColorFactor = materialInfo?.extensions?.KHR_materials_specular?.specularColorFactor ?? [
+                1,
+                1,
+                1
+            ];
+            pbrMetallicRoughness.specularFactor = new Vector4(...specularColorFactor, materialInfo?.extensions?.KHR_materials_specular?.specularFactor ?? 1);
+            pbrMetallicRoughness.specularMap = materialInfo?.extensions?.KHR_materials_specular?.specularTexture ? await this._loadTexture(gltf, materialInfo.extensions.KHR_materials_specular.specularTexture, false) : null;
+            pbrMetallicRoughness.specularColorMap = materialInfo?.extensions?.KHR_materials_specular?.specularColorTexture ? await this._loadTexture(gltf, materialInfo.extensions.KHR_materials_specular.specularColorTexture, true) : null;
+            // KHR_materials_iridescence
+            const iridescence = materialInfo?.extensions?.KHR_materials_iridescence;
+            if (iridescence) {
+                pbrMetallicRoughness.iridescence = {
+                    iridescenceFactor: iridescence.iridescenceFactor ?? 0,
+                    iridescenceMap: iridescence.iridescenceTexture ? await this._loadTexture(gltf, iridescence.iridescenceTexture, false) : null,
+                    iridescenceIor: iridescence.iridescenceIor ?? 1.3,
+                    iridescenceThicknessMinimum: iridescence.iridescenceThicknessMinimum ?? 100,
+                    iridescenceThicknessMaximum: iridescence.iridescenceThicknessMaximum ?? 400,
+                    iridescenceThicknessMap: iridescence.iridescenceThicknessTexture ? await this._loadTexture(gltf, iridescence.iridescenceThicknessTexture, false) : null
+                };
+            }
+            // KHR_materials_transmission
+            const transmission = materialInfo?.extensions?.KHR_materials_transmission;
+            if (transmission) {
+                pbrMetallicRoughness.transmission = {
+                    transmissionFactor: transmission.transmissionFactor ?? 0,
+                    transmissionMap: transmission.transmissionTexture ? await this._loadTexture(gltf, transmission.transmissionTexture, false) : null,
+                    thicknessFactor: 0,
+                    thicknessMap: null,
+                    attenuationDistance: 99999,
+                    attenuationColor: Vector3.one()
+                };
+                const volume = materialInfo?.extensions?.KHR_materials_volume;
+                if (volume) {
+                    pbrMetallicRoughness.transmission.thicknessFactor = volume.thicknessFactor ?? 0;
+                    pbrMetallicRoughness.transmission.thicknessMap = volume.thicknessTexture ? await this._loadTexture(gltf, volume.thicknessTexture, false) : null;
+                    pbrMetallicRoughness.transmission.attenuationDistance = volume.attenuationDistance ?? 99999;
+                    const attenuationColor = volume.attenuationColor ?? [
+                        1,
+                        1,
+                        1
+                    ];
+                    pbrMetallicRoughness.transmission.attenuationColor = new Vector3(...attenuationColor);
+                }
+            }
+            // KHR_materials_sheen
+            const sheen = materialInfo?.extensions?.KHR_materials_sheen;
+            if (sheen) {
+                pbrMetallicRoughness.sheen = {
+                    sheenColorFactor: new Vector3(sheen.sheenColorFactor ?? [
+                        0,
+                        0,
+                        0
+                    ]),
+                    sheenColorMap: sheen.sheenColorTexture ? await this._loadTexture(gltf, sheen.sheenColorTexture, true) : null,
+                    sheenRoughnessFactor: sheen.sheenRoughnessFactor ?? 0,
+                    sheenRoughnessMap: sheen.sheenRoughnessTexture ? await this._loadTexture(gltf, sheen.sheenRoughnessTexture, true) : null
+                };
+            }
+            // KHR_materials_clearcoat
+            const cc = materialInfo?.extensions?.KHR_materials_clearcoat;
+            if (cc) {
+                pbrMetallicRoughness.clearcoat = {
+                    clearCoatFactor: cc.clearcoatFactor ?? 0,
+                    clearCoatIntensityMap: cc.clearcoatTexture ? await this._loadTexture(gltf, cc.clearcoatTexture, false) : null,
+                    clearCoatRoughnessFactor: cc.clearcoatRoughnessFactor ?? 0,
+                    clearCoatRoughnessMap: cc.clearcoatRoughnessTexture ? await this._loadTexture(gltf, cc.clearcoatRoughnessTexture, false) : null,
+                    clearCoatNormalMap: cc.clearcoatNormalTexture ? await this._loadTexture(gltf, cc.clearcoatNormalTexture, false) : null
+                };
+            }
+        }
+        return await this._createMaterial(assetMaterial);
+    }
+    /** @internal */ async _loadTexture(gltf, info, sRGB) {
+        const mt = {
+            texture: null,
+            sampler: null,
+            texCoord: info.texCoord ?? 0,
+            transform: null
+        };
+        const textureInfo = gltf.textures[info.index];
+        if (textureInfo) {
+            if (info.extensions?.KHR_texture_transform) {
+                const uvTransform = info.extensions.KHR_texture_transform;
+                if (uvTransform.texCoord !== undefined) {
+                    mt.texCoord = uvTransform.texCoord;
+                }
+                const rotation = uvTransform.rotation !== undefined ? Matrix4x4.rotationZ(-uvTransform.rotation) : Matrix4x4.identity();
+                const scale = uvTransform.scale !== undefined ? new Vector3(uvTransform.scale[0], uvTransform.scale[1], 1) : Vector3.one();
+                const translation = uvTransform.offset !== undefined ? new Vector3(uvTransform.offset[0], uvTransform.offset[1], 0) : Vector3.zero();
+                mt.transform = Matrix4x4.scaling(scale).multiplyLeft(rotation).translateLeft(translation);
+            }
+            let wrapS = 'repeat';
+            let wrapT = 'repeat';
+            let magFilter = 'linear';
+            let minFilter = 'linear';
+            let mipFilter = 'linear';
+            const samplerIndex = textureInfo.sampler;
+            const sampler = gltf.samplers && gltf.samplers[samplerIndex];
+            if (sampler) {
+                switch(sampler.wrapS){
+                    case 0x2901:
+                        wrapS = 'repeat';
+                        break;
+                    case 0x8370:
+                        wrapS = 'mirrored-repeat';
+                        break;
+                    case 0x812f:
+                        wrapS = 'clamp';
+                        break;
+                }
+                switch(sampler.wrapT){
+                    case 0x2901:
+                        wrapT = 'repeat';
+                        break;
+                    case 0x8370:
+                        wrapT = 'mirrored-repeat';
+                        break;
+                    case 0x812f:
+                        wrapT = 'clamp';
+                        break;
+                }
+                switch(sampler.magFilter){
+                    case 0x2600:
+                        magFilter = 'nearest';
+                        break;
+                    case 0x2601:
+                        magFilter = 'linear';
+                        break;
+                }
+                switch(sampler.minFilter){
+                    case 0x2600:
+                        minFilter = 'nearest';
+                        mipFilter = 'none';
+                        break;
+                    case 0x2601:
+                        minFilter = 'linear';
+                        mipFilter = 'none';
+                        break;
+                    case 0x2700:
+                        minFilter = 'nearest';
+                        mipFilter = 'nearest';
+                        break;
+                    case 0x2701:
+                        minFilter = 'linear';
+                        mipFilter = 'nearest';
+                        break;
+                    case 0x2702:
+                        minFilter = 'nearest';
+                        mipFilter = 'linear';
+                        break;
+                    case 0x2703:
+                        minFilter = 'linear';
+                        mipFilter = 'linear';
+                        break;
+                }
+            }
+            const imageIndex = textureInfo.source;
+            const hash = `${imageIndex}:${!!sRGB}:${wrapS}:${wrapT}:${minFilter}:${magFilter}:${mipFilter}`;
+            mt.texture = gltf._textureCache[hash];
+            if (!mt.texture) {
+                const image = gltf.images[imageIndex];
+                if (image) {
+                    if (image.uri) {
+                        const imageUrl = this._normalizeURI(gltf._baseURI, image.uri);
+                        mt.texture = await gltf._manager.fetchTexture(imageUrl, {
+                            linearColorSpace: !sRGB
+                        });
+                        mt.texture.name = imageUrl;
+                    } else if (typeof image.bufferView === 'number' && image.mimeType) {
+                        const bufferView = gltf.bufferViews && gltf.bufferViews[image.bufferView];
+                        if (bufferView) {
+                            const arrayBuffer = gltf._loadedBuffers && gltf._loadedBuffers[bufferView.buffer];
+                            if (arrayBuffer) {
+                                const view = new Uint8Array(arrayBuffer, bufferView.byteOffset || 0, bufferView.byteLength);
+                                const mimeType = image.mimeType;
+                                mt.texture = await gltf._manager.loadTextureFromBuffer(view, mimeType, sRGB);
+                            }
+                        }
+                    }
+                }
+                if (mt.texture) {
+                    gltf._textureCache[hash] = mt.texture;
+                }
+            }
+            if (mt.texture) {
+                mt.sampler = Application.instance.device.createSampler({
+                    addressU: wrapS,
+                    addressV: wrapT,
+                    magFilter: magFilter,
+                    minFilter: minFilter,
+                    mipFilter: mipFilter
+                });
+            }
+        }
+        return mt;
+    }
+    /** @internal */ _primitiveType(type) {
+        switch(type){
+            case 0:
+                return 'point-list';
+            case 1:
+                return 'line-list';
+            /* FIXME:
+      case 2: // GL_LINE_LOOP
+        return PrimitiveType.LineLoop;
+      */ case 3:
+                return 'line-strip';
+            case 4:
+                return 'triangle-list';
+            case 5:
+                return 'triangle-strip';
+            case 6:
+                return 'triangle-fan';
+            default:
+                return null;
+        }
+    }
+    /** @internal */ _loadIndexBuffer(gltf, accessorIndex, primitive, meshData, dracoExtension, dracoMeshDecoder) {
+        const accessor = gltf._accessors[accessorIndex];
+        if (dracoMeshDecoder) {
+            const indices = dracoMeshDecoder.getIndexBuffer();
+            if (!indices || indices.length !== accessor.count) {
+                throw new Error(`Decode index buffer failed`);
+            }
+            if (indices.length !== accessor.count) {
+                throw new Error(`Decode index buffer failed`);
+            }
+            gltf._loadedBuffers.push(indices.buffer);
+            if (!gltf.bufferViews) {
+                gltf.bufferViews = [];
+            }
+            gltf.bufferViews.push({
+                buffer: gltf._loadedBuffers.length - 1,
+                byteOffset: 0,
+                byteLength: indices.byteLength
+            });
+            accessor.componentType = ComponentType.UINT;
+            accessor.bufferView = gltf.bufferViews.length - 1;
+        }
+        this._setBuffer(gltf, accessorIndex, primitive, null, meshData);
+    }
+    /** @internal */ _loadVertexBuffer(gltf, attribName, accessorIndex, primitive, subMeshData, dracoExtension, dracoMeshDecoder) {
+        const dracoId = dracoExtension?.attributes?.[attribName];
+        if (dracoId !== undefined) {
+            const accessor = gltf._accessors[accessorIndex];
+            let buffer = null;
+            const numElements = accessor.count * accessor.getComponentCount(accessor.type);
+            switch(accessor.componentType){
+                case ComponentType.FLOAT:
+                    buffer = new Float32Array(numElements);
+                    break;
+                case ComponentType.BYTE:
+                    buffer = new Int8Array(numElements);
+                    break;
+                case ComponentType.SHORT:
+                    buffer = new Int16Array(numElements);
+                    break;
+                case ComponentType.INT:
+                    buffer = new Int32Array(numElements);
+                    break;
+                case ComponentType.UBYTE:
+                    buffer = new Uint8Array(numElements);
+                    break;
+                case ComponentType.USHORT:
+                    buffer = new Uint16Array(numElements);
+                    break;
+                case ComponentType.UINT:
+                    buffer = new Uint32Array(numElements);
+                    break;
+                default:
+                    throw new Error(`Invalid component type: ${accessor.componentType}`);
+            }
+            if (!dracoMeshDecoder.getAttributeBuffer(dracoId, buffer)) {
+                throw new Error(`Decode draco mesh failed`);
+            }
+            gltf._loadedBuffers.push(buffer.buffer);
+            if (!gltf.bufferViews) {
+                gltf.bufferViews = [];
+            }
+            gltf.bufferViews.push({
+                buffer: gltf._loadedBuffers.length - 1,
+                byteOffset: 0,
+                byteLength: buffer.byteLength
+            });
+            accessor.bufferView = gltf.bufferViews.length - 1;
+        }
+        let semantic = null;
+        switch(attribName){
+            case 'POSITION':
+                semantic = 'position';
+                break;
+            case 'NORMAL':
+                semantic = 'normal';
+                break;
+            case 'TANGENT':
+                semantic = 'tangent';
+                break;
+            case 'TEXCOORD_0':
+                semantic = 'texCoord0';
+                break;
+            case 'TEXCOORD_1':
+                semantic = 'texCoord1';
+                break;
+            case 'TEXCOORD_2':
+                semantic = 'texCoord2';
+                break;
+            case 'TEXCOORD_3':
+                semantic = 'texCoord3';
+                break;
+            case 'TEXCOORD_4':
+                semantic = 'texCoord4';
+                break;
+            case 'TEXCOORD_5':
+                semantic = 'texCoord5';
+                break;
+            case 'TEXCOORD_6':
+                semantic = 'texCoord6';
+                break;
+            case 'TEXCOORD_7':
+                semantic = 'texCoord7';
+                break;
+            case 'COLOR_0':
+                semantic = 'diffuse';
+                break;
+            case 'JOINTS_0':
+                semantic = 'blendIndices';
+                break;
+            case 'WEIGHTS_0':
+                semantic = 'blendWeights';
+                break;
+            default:
+                return;
+        }
+        this._setBuffer(gltf, accessorIndex, primitive, semantic, subMeshData);
+    }
+    /** @internal */ _setBuffer(gltf, accessorIndex, primitive, semantic, subMeshData) {
+        const device = Application.instance.device;
+        const accessor = gltf._accessors[accessorIndex];
+        const componentCount = accessor.getComponentCount(accessor.type);
+        const normalized = !!accessor.normalized;
+        const hash = `${accessorIndex}:${semantic || ''}:${Number(normalized)}`;
+        let buffer = gltf._bufferCache[hash];
+        if (!buffer) {
+            let data = accessor.getNormalizedDeinterlacedView(gltf);
+            if (semantic && !(data instanceof Float32Array)) {
+                const floatData = new Float32Array(data.length);
+                floatData.set(data);
+                data = floatData;
+            }
+            if (!semantic) {
+                if (!(data instanceof Uint8Array) && !(data instanceof Uint16Array) && !(data instanceof Uint32Array)) {
+                    console.error('Invalid index buffer component type');
+                    return;
+                }
+                if (data instanceof Uint32Array && !device.getDeviceCaps().miscCaps.support32BitIndex) {
+                    console.error('Device does not support 32bit vertex index');
+                    return;
+                }
+                if (data instanceof Uint8Array) {
+                    const uint16Data = new Uint16Array(data.length);
+                    uint16Data.set(data);
+                    data = uint16Data;
+                }
+            }
+            if (!semantic) {
+                buffer = gltf._device.createIndexBuffer(data, {
+                    managed: true
+                });
+            } else {
+                const attribFormat = device.getVertexAttribFormat(semantic, 'f32', componentCount);
+                buffer = gltf._device.createVertexBuffer(attribFormat, data);
+            }
+            gltf._bufferCache[hash] = buffer;
+        }
+        if (buffer) {
+            if (!semantic) {
+                primitive.setIndexBuffer(buffer);
+                primitive.indexCount = buffer.length;
+            } else {
+                primitive.setVertexBuffer(buffer);
+                if (semantic === 'position') {
+                    if (!primitive.getIndexBuffer()) {
+                        primitive.indexCount = Math.floor(buffer.byteLength / 12);
+                    }
+                    const data = accessor.getNormalizedDeinterlacedView(gltf);
+                    subMeshData.rawPositions = data;
+                    const min = accessor.min;
+                    const max = accessor.max;
+                    if (min && max) {
+                        primitive.setBoundingVolume(new BoundingBox(new Vector3(min), new Vector3(max)));
+                    } else {
+                        const bbox = new BoundingBox();
+                        bbox.beginExtend();
+                        for(let i = 0; i < data.length; i++){
+                            const v = new Vector3(data[i * componentCount], data[i * componentCount + 1], data[i * componentCount + 2]);
+                            bbox.extend(v);
+                        }
+                        if (bbox.isValid()) {
+                            primitive.setBoundingVolume(bbox);
+                        }
+                    }
+                } else if (semantic === 'blendIndices') {
+                    subMeshData.rawBlendIndices = accessor.getNormalizedDeinterlacedView(gltf);
+                } else if (semantic === 'blendWeights') {
+                    subMeshData.rawJointWeights = accessor.getNormalizedDeinterlacedView(gltf);
+                }
+            }
+        }
+        return buffer;
+    }
+    /** @internal */ isGLB(data) {
+        if (data.byteLength > 12) {
+            const p = new Uint32Array(data, 0, 3);
+            if (p[0] === 0x46546c67 && p[1] === 2 && p[2] === data.byteLength) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** @internal */ getGLBChunkInfo(data, offset) {
+        const header = new Uint32Array(data, offset, 2);
+        const start = offset + 8;
+        const length = header[0];
+        const type = header[1];
+        return {
+            start,
+            length,
+            type
+        };
+    }
+    /** @internal */ getGLBChunkInfos(data) {
+        const infos = [];
+        let offset = 12;
+        while(offset < data.byteLength){
+            const info = this.getGLBChunkInfo(data, offset);
+            infos.push(info);
+            offset += info.length + 8;
+        }
+        return infos;
+    }
+}
+
+export { GLTFLoader };
+//# sourceMappingURL=gltf_loader.js.map