@rings-webgpu/core 1.0.2 → 1.0.3

package/dist/src/loader/parser/gltf/GLTFSubParserMesh.js

@@ -1,170 +0,0 @@
-import { VertexAttributeName } from "../../../core/geometry/VertexAttributeName";
-import { GLTFParser } from "./GLTFParser";
-import { GLTFType } from "./GLTFType";
-import { KHR_draco_mesh_compression } from "./extends/KHR_draco_mesh_compression";
-export class GLTFSubParserMesh {
-    constructor(subParser) {
-        this.gltf = subParser.gltf;
-        this.subParser = subParser;
-    }
-    async parse(meshId) {
-        const mesh = this.gltf.meshes[meshId];
-        if (!mesh)
-            return this.errorMiss("mesh", meshId);
-        if (mesh.isParsed)
-            return mesh.dprimitives;
-        const primitives = mesh.primitives;
-        const extras = mesh.extras;
-        const dprimitives = [];
-        for (let i = 0; i < primitives.length; i++) {
-            const primitive = primitives[i];
-            const { attributes, indices, material, mode, name, targets, morphTargetsRelative, extensions, } = primitive;
-            let tmpName = mesh.name;
-            for (let tn in attributes) {
-                tmpName += tn;
-            }
-            tmpName += `indices:${indices}`;
-            tmpName += `material:${material}`;
-            const dprimitive = {
-                attribArrays: { indices: [] },
-                weights: [],
-                defines: [],
-                material: null,
-                drawMode: null,
-                meshName: null,
-                modelName: null,
-                morphTargetsRelative: false,
-                targetNames: extras ? extras.targetNames : null,
-            };
-            let hasNormal = false;
-            let hasTangent = false;
-            let texCoordNum = 0;
-            let jointVec8 = false;
-            let vertexColor = 0;
-            let overlayAccessors;
-            if (extensions && extensions.KHR_draco_mesh_compression) {
-                overlayAccessors = await KHR_draco_mesh_compression.apply(this.subParser, primitive);
-            }
-            for (const attribute in attributes) {
-                const accessor = overlayAccessors
-                    ? overlayAccessors[attribute]
-                    : this.parseAccessor(attributes[attribute]);
-                if (accessor) {
-                    let attribName;
-                    switch (attribute) {
-                        case "POSITION":
-                            attribName = VertexAttributeName.position;
-                            break;
-                        case "NORMAL":
-                            attribName = VertexAttributeName.normal;
-                            hasNormal = true;
-                            break;
-                        case "TEXCOORD_0":
-                            attribName = VertexAttributeName.uv;
-                            texCoordNum++;
-                            break;
-                        case "JOINTS_0":
-                            attribName = VertexAttributeName.joints0;
-                            break;
-                        case "JOINTS_1":
-                            attribName = VertexAttributeName.joints1;
-                            jointVec8 = true;
-                            break;
-                        case "WEIGHTS_0":
-                            attribName = VertexAttributeName.weights0;
-                            break;
-                        case "WEIGHTS_1":
-                            attribName = VertexAttributeName.weights1;
-                            break;
-                        default:
-                            attribName = attribute;
-                    }
-                    dprimitive.attribArrays[attribName] = accessor;
-                }
-            }
-            if (hasNormal)
-                dprimitive.defines.push(GLTFParser.getHasNormalDefine());
-            if (hasTangent)
-                dprimitive.defines.push(GLTFParser.getHasTangentDefine());
-            if (texCoordNum)
-                dprimitive.defines.push(GLTFParser.getTexCoordDefine(texCoordNum));
-            if (jointVec8)
-                dprimitive.defines.push(GLTFParser.getJointVec8Define());
-            if (vertexColor)
-                dprimitive.defines.push(GLTFParser.getVertexColorDefine(vertexColor));
-            if (indices !== undefined) {
-                const accessor = overlayAccessors
-                    ? overlayAccessors["indices"]
-                    : this.parseAccessor(indices);
-                if (accessor)
-                    dprimitive.attribArrays.indices = accessor;
-            }
-            const dmaterial = await this.parseMaterial(material);
-            if (dmaterial) {
-                dprimitive.material = dmaterial;
-                dprimitive.defines = dprimitive.defines.concat(dmaterial.defines);
-            }
-            dprimitive.drawMode = mode === undefined ? 4 : mode;
-            dprimitive.meshName = () => {
-                return tmpName;
-            }; //|| GLTFParser.getMeshNameCounter();
-            dprimitive.modelName = mesh.name || GLTFParser.getModelNameCounter();
-            if (targets) {
-                dprimitive.defines.push(GLTFParser.getMorphTargetsDefine(targets.length));
-                dprimitive.morphTargetsRelative = true;
-                let hasPositions = false;
-                let hasNormals = false;
-                let hasTangents = false;
-                for (let j = 0; j < targets.length; j++) {
-                    const target = targets[j];
-                    Object.keys(target).forEach((attribute) => {
-                        const accessor = this.parseAccessor(target[attribute]);
-                        if (accessor) {
-                            let attribName;
-                            switch (attribute) {
-                                case "POSITION":
-                                    attribName = GLTFType.MORPH_POSITION_PREFIX + j;
-                                    hasPositions = true;
-                                    break;
-                                case "NORMAL":
-                                    attribName = GLTFType.MORPH_NORMAL_PREFIX + j;
-                                    hasNormals = true;
-                                    break;
-                                case "TANGENT":
-                                    attribName = GLTFType.MORPH_TANGENT_PREFIX + j;
-                                    hasTangents = true;
-                                    break;
-                                default:
-                                    attribName = false;
-                            }
-                            if (!attribName)
-                                console.error(`glTF has unsupported morph target attribute ${attribute}`);
-                            else
-                                dprimitive.attribArrays[attribName] = accessor;
-                        }
-                    });
-                }
-                if (hasPositions)
-                    dprimitive.defines.push(GLTFParser.getMorphtargetPositionDefine());
-                if (hasNormals)
-                    dprimitive.defines.push(GLTFParser.getMorphtargetNormalDefine());
-                if (hasTangents)
-                    dprimitive.defines.push(GLTFParser.getMorphtargetTangentDefine());
-                dprimitive.weights = mesh.weights || new Array(targets.length).fill(0);
-            }
-            dprimitives.push(dprimitive);
-        }
-        mesh.dprimitives = dprimitives;
-        mesh.isParsed = true;
-        return mesh.dprimitives;
-    }
-    parseAccessor(accessorId) {
-        return this.subParser.parseAccessor(accessorId);
-    }
-    parseMaterial(material) {
-        return this.subParser.parseMaterial(material);
-    }
-    errorMiss(e, info) {
-        throw new Error(e + info);
-    }
-}

package/dist/src/loader/parser/gltf/GLTFSubParserSkeleton.d.ts

@@ -1,15 +0,0 @@
-import { PrefabAvatarData, PropertyAnimationClip } from "../../..";
-import { Skeleton } from "../../../components/anim/skeletonAnim/Skeleton";
-import { SkeletonAnimationClip } from "../../../components/anim/skeletonAnim/SkeletonAnimationClip";
-import { GLTF_Info } from "./GLTFInfo";
-import { GLTFSubParser } from "./GLTFSubParser";
-export declare class GLTFSubParserSkeleton {
-    protected gltf: GLTF_Info;
-    protected subParser: GLTFSubParser;
-    constructor(subParser: GLTFSubParser);
-    parse(skeletonID: number): PrefabAvatarData;
-    parseSkeletonAnimation(avatarData: PrefabAvatarData, animation: any): PropertyAnimationClip;
-    parseSkeletonAnimationOld(skeleton: Skeleton, animation: any): SkeletonAnimationClip;
-    private buildSkeleton;
-    private buildSkeletonOld;
-}

package/dist/src/loader/parser/gltf/GLTFSubParserSkeleton.js

@@ -1,313 +0,0 @@
-import { AnimationCurveT, KeyframeT, PrefabAvatarData, PrefabBoneData, PropertyAnimationClip, Quaternion, ValueEnumType, Vector3, } from "../../..";
-import { Joint } from "../../../components/anim/skeletonAnim/Joint";
-import { SkeletonAnimationClip } from "../../../components/anim/skeletonAnim/SkeletonAnimationClip";
-export class GLTFSubParserSkeleton {
-    constructor(subParser) {
-        this.gltf = subParser.gltf;
-        this.subParser = subParser;
-    }
-    parse(skeletonID) {
-        let avatarData = new PrefabAvatarData();
-        avatarData.name = "Id:" + skeletonID;
-        avatarData.count = 0;
-        avatarData.boneData = [];
-        avatarData.boneMap = new Map();
-        this.buildSkeleton(avatarData, undefined, skeletonID);
-        return avatarData;
-    }
-    parseSkeletonAnimation(avatarData, animation) {
-        let result = new PropertyAnimationClip();
-        result.clipName = animation.name;
-        result.useSkeletonPos = false;
-        result.useSkeletonScale = false;
-        for (let channel of animation.channels) {
-            let sampler = animation.samplers[channel.sampler];
-            const inputAccessor = this.subParser.parseAccessor(sampler.input);
-            const outputAccessor = this.subParser.parseAccessor(sampler.output);
-            let nodeId = channel.target.node;
-            let property = channel.target.path;
-            let node = this.gltf.nodes[nodeId];
-            if (!node) {
-                continue;
-            }
-            if (!avatarData.boneMap.has(node.name)) {
-                continue;
-            }
-            let bone = avatarData.boneMap.get(node.name);
-            switch (property) {
-                case "scale":
-                    {
-                        let animationCurveT = new AnimationCurveT(outputAccessor.numComponents);
-                        animationCurveT.path = "";
-                        animationCurveT.attribute = "";
-                        animationCurveT.propertys = animationCurveT.attribute.split(".");
-                        animationCurveT.preInfinity = 0;
-                        animationCurveT.postInfinity = 0;
-                        animationCurveT.rotationOrder = 0;
-                        result.useSkeletonScale = true;
-                        result.scaleCurves.set(bone.bonePath, animationCurveT);
-                        for (let i = 0; i < inputAccessor.data.length; i++) {
-                            const t = inputAccessor.data[i];
-                            const offset = i * outputAccessor.numComponents;
-                            let keyframe = new KeyframeT(0);
-                            keyframe.time = t;
-                            const v = new Vector3().set(outputAccessor.data[offset + 0], outputAccessor.data[offset + 1], outputAccessor.data[offset + 2]);
-                            keyframe.split(ValueEnumType.vector3, v, "value");
-                            animationCurveT.addKeyFrame(keyframe);
-                        }
-                    }
-                    break;
-                case "rotation":
-                    {
-                        let animationCurveT = new AnimationCurveT(outputAccessor.numComponents);
-                        animationCurveT.path = "";
-                        animationCurveT.attribute = "";
-                        animationCurveT.propertys = animationCurveT.attribute.split(".");
-                        animationCurveT.preInfinity = 0;
-                        animationCurveT.postInfinity = 0;
-                        animationCurveT.rotationOrder = 0;
-                        result.rotationCurves.set(bone.bonePath, animationCurveT);
-                        for (let i = 0; i < inputAccessor.data.length; i++) {
-                            const t = inputAccessor.data[i];
-                            const offset = i * outputAccessor.numComponents;
-                            let keyframe = new KeyframeT(0);
-                            keyframe.time = t;
-                            const v = new Quaternion().set(outputAccessor.data[offset + 0], outputAccessor.data[offset + 1], outputAccessor.data[offset + 2], outputAccessor.data[offset + 3]);
-                            keyframe.split(ValueEnumType.quaternion, v, "value");
-                            animationCurveT.addKeyFrame(keyframe);
-                        }
-                    }
-                    break;
-                case "translation":
-                    {
-                        let animationCurveT = new AnimationCurveT(outputAccessor.numComponents);
-                        animationCurveT.path = "";
-                        animationCurveT.attribute = "";
-                        animationCurveT.propertys = animationCurveT.attribute.split(".");
-                        animationCurveT.preInfinity = 0;
-                        animationCurveT.postInfinity = 0;
-                        animationCurveT.rotationOrder = 0;
-                        result.useSkeletonPos = true;
-                        result.positionCurves.set(bone.bonePath, animationCurveT);
-                        for (let i = 0; i < inputAccessor.data.length; i++) {
-                            const t = inputAccessor.data[i];
-                            const offset = i * outputAccessor.numComponents;
-                            let keyframe = new KeyframeT(0);
-                            keyframe.time = t;
-                            const v = new Vector3().set(outputAccessor.data[offset + 0], outputAccessor.data[offset + 1], outputAccessor.data[offset + 2]);
-                            keyframe.split(ValueEnumType.vector3, v, "value");
-                            animationCurveT.addKeyFrame(keyframe);
-                        }
-                    }
-                    break;
-            }
-        }
-        return result;
-    }
-    parseSkeletonAnimationOld(skeleton, animation) {
-        let count = 0;
-        let inputAccessor = this.subParser.parseAccessor(animation.samplers[0].input);
-        let numFrame = inputAccessor.data.length;
-        let frameRate = inputAccessor.data[1] - inputAccessor.data[0];
-        let totalTime = inputAccessor.data[inputAccessor.data.length - 1];
-        let skeletonPoseLength = 12 * skeleton.numJoint;
-        let bufferData = new Float32Array(skeletonPoseLength * numFrame);
-        for (var index = 0; index < skeleton.numJoint; index++) {
-            for (var nFrame = 0; nFrame < numFrame; nFrame++) {
-                var dstOffset = skeletonPoseLength * nFrame + 12 * index;
-                bufferData[dstOffset + 0] = 1;
-                bufferData[dstOffset + 1] = 1;
-                bufferData[dstOffset + 2] = 1;
-                bufferData[dstOffset + 3] = 1;
-            }
-        }
-        for (let channel of animation.channels) {
-            let sampler = animation.samplers[channel.sampler];
-            const inputAccessor = this.subParser.parseAccessor(sampler.input);
-            const outputAccessor = this.subParser.parseAccessor(sampler.output);
-            let nodeId = channel.target.node;
-            let property = channel.target.path;
-            let node = this.gltf.nodes[nodeId];
-            if (!node) {
-                continue;
-            }
-            count++;
-            let joint = skeleton.getJointByName(node.name);
-            if (!joint) {
-                switch (property) {
-                    case "scale":
-                        break;
-                    case "rotation":
-                        break;
-                    case "translation":
-                        break;
-                }
-            }
-            else {
-                switch (property) {
-                    case "scale":
-                        if (numFrame * outputAccessor.numComponents ==
-                            outputAccessor.data.length) {
-                            for (var nFrame = 0; nFrame < numFrame; nFrame++) {
-                                var srcOffset = nFrame * outputAccessor.numComponents;
-                                var dstOffset = skeletonPoseLength * nFrame + 12 * joint.index;
-                                bufferData[dstOffset + 0] = outputAccessor.data[srcOffset + 0]; // x
-                                bufferData[dstOffset + 1] = outputAccessor.data[srcOffset + 1]; // y
-                                bufferData[dstOffset + 2] = outputAccessor.data[srcOffset + 2]; // z
-                                bufferData[dstOffset + 3] = 1;
-                            }
-                        }
-                        else if (inputAccessor.data.length == 2) {
-                            let time = 0;
-                            let t0 = inputAccessor.data[0];
-                            let t1 = inputAccessor.data[1];
-                            var srcOffsetA = 0 * outputAccessor.numComponents;
-                            Vector3.HELP_0.set(outputAccessor.data[srcOffsetA + 0], outputAccessor.data[srcOffsetA + 1], outputAccessor.data[srcOffsetA + 2]);
-                            var srcOffsetB = 1 * outputAccessor.numComponents;
-                            Vector3.HELP_1.set(outputAccessor.data[srcOffsetB + 0], outputAccessor.data[srcOffsetB + 1], outputAccessor.data[srcOffsetB + 2]);
-                            for (var nFrame = 0; nFrame < numFrame; nFrame++) {
-                                let t = time / t1;
-                                Vector3.HELP_2.lerp(Vector3.HELP_0, Vector3.HELP_1, t);
-                                var dstOffset = skeletonPoseLength * nFrame + 12 * joint.index;
-                                bufferData[dstOffset + 0] = Vector3.HELP_2.x;
-                                bufferData[dstOffset + 1] = Vector3.HELP_2.y;
-                                bufferData[dstOffset + 2] = Vector3.HELP_2.z;
-                                bufferData[dstOffset + 3] = 1;
-                                time += frameRate;
-                            }
-                        }
-                        else
-                            throw new Error("Unsupported animation sampler interpolation.");
-                        break;
-                    case "rotation":
-                        if (numFrame * outputAccessor.numComponents ==
-                            outputAccessor.data.length) {
-                            for (var nFrame = 0; nFrame < numFrame; nFrame++) {
-                                var srcOffset = nFrame * outputAccessor.numComponents;
-                                var dstOffset = skeletonPoseLength * nFrame + 12 * joint.index + 4;
-                                bufferData[dstOffset + 0] = outputAccessor.data[srcOffset + 0]; // x
-                                bufferData[dstOffset + 1] = outputAccessor.data[srcOffset + 1]; // y
-                                bufferData[dstOffset + 2] = outputAccessor.data[srcOffset + 2]; // z
-                                bufferData[dstOffset + 3] = outputAccessor.data[srcOffset + 3]; // w
-                            }
-                        }
-                        else if (inputAccessor.data.length == 2) {
-                            let time = 0;
-                            let t0 = inputAccessor.data[0];
-                            let t1 = inputAccessor.data[1];
-                            var srcOffsetA = 0 * outputAccessor.numComponents;
-                            Vector3.HELP_0.set(outputAccessor.data[srcOffsetA + 0], outputAccessor.data[srcOffsetA + 1], outputAccessor.data[srcOffsetA + 2], outputAccessor.data[srcOffsetA + 3]);
-                            var srcOffsetB = 1 * outputAccessor.numComponents;
-                            Vector3.HELP_1.set(outputAccessor.data[srcOffsetB + 0], outputAccessor.data[srcOffsetB + 1], outputAccessor.data[srcOffsetB + 2], outputAccessor.data[srcOffsetB + 3]);
-                            for (var nFrame = 0; nFrame < numFrame; nFrame++) {
-                                let t = time / t1;
-                                Vector3.HELP_2.lerp(Vector3.HELP_0, Vector3.HELP_1, t);
-                                var dstOffset = skeletonPoseLength * nFrame + 12 * joint.index + 4;
-                                bufferData[dstOffset + 0] = Vector3.HELP_2.x;
-                                bufferData[dstOffset + 1] = Vector3.HELP_2.y;
-                                bufferData[dstOffset + 2] = Vector3.HELP_2.z;
-                                bufferData[dstOffset + 3] = Vector3.HELP_2.w;
-                                time += frameRate;
-                            }
-                        }
-                        else
-                            throw new Error("Unsupported animation sampler interpolation.");
-                        break;
-                    case "translation":
-                        if (numFrame * outputAccessor.numComponents ==
-                            outputAccessor.data.length) {
-                            for (var nFrame = 0; nFrame < numFrame; nFrame++) {
-                                var srcOffset = nFrame * outputAccessor.numComponents;
-                                var dstOffset = skeletonPoseLength * nFrame + 12 * joint.index + 8;
-                                bufferData[dstOffset + 0] = outputAccessor.data[srcOffset + 0]; // x
-                                bufferData[dstOffset + 1] = outputAccessor.data[srcOffset + 1]; // y
-                                bufferData[dstOffset + 2] = outputAccessor.data[srcOffset + 2]; // z
-                                bufferData[dstOffset + 3] =
-                                    inputAccessor.data[nFrame * inputAccessor.numComponents];
-                            }
-                        }
-                        else if (inputAccessor.data.length == 2) {
-                            let time = 0;
-                            let t0 = inputAccessor.data[0];
-                            let t1 = inputAccessor.data[1];
-                            var srcOffsetA = 0 * outputAccessor.numComponents;
-                            Vector3.HELP_0.set(outputAccessor.data[srcOffsetA + 0], outputAccessor.data[srcOffsetA + 1], outputAccessor.data[srcOffsetA + 2]);
-                            var srcOffsetB = 1 * outputAccessor.numComponents;
-                            Vector3.HELP_1.set(outputAccessor.data[srcOffsetB + 0], outputAccessor.data[srcOffsetB + 1], outputAccessor.data[srcOffsetB + 2]);
-                            for (var nFrame = 0; nFrame < numFrame; nFrame++) {
-                                let t = time / t1;
-                                Vector3.HELP_2.lerp(Vector3.HELP_0, Vector3.HELP_1, t);
-                                var dstOffset = skeletonPoseLength * nFrame + 12 * joint.index + 8;
-                                bufferData[dstOffset + 0] = Vector3.HELP_2.x;
-                                bufferData[dstOffset + 1] = Vector3.HELP_2.y;
-                                bufferData[dstOffset + 2] = Vector3.HELP_2.z;
-                                bufferData[dstOffset + 3] = time;
-                                time += frameRate;
-                            }
-                        }
-                        else
-                            throw new Error("Unsupported animation sampler interpolation.");
-                        break;
-                }
-            }
-        }
-        let animationClip = new SkeletonAnimationClip(animation.name, skeleton, numFrame, bufferData);
-        return animationClip;
-    }
-    buildSkeleton(avatarData, parent, nodeId) {
-        let node = this.gltf.nodes[nodeId];
-        if (!node.name) {
-            node.name = "Bone" + avatarData.count;
-        }
-        let boneData = new PrefabBoneData();
-        boneData.boneName = node.name;
-        boneData.bonePath = parent ? parent.bonePath + "/" + node.name : node.name;
-        boneData.parentBoneName = parent ? parent.boneName : "";
-        boneData.boneID = avatarData.count++;
-        boneData.parentBoneID = parent ? parent.boneID : -1;
-        boneData.instanceID = "";
-        boneData.parentInstanceID = "";
-        boneData.s = new Vector3(1, 1, 1);
-        if (node.scale) {
-            boneData.s.set(node.scale[0], node.scale[1], node.scale[2]);
-        }
-        boneData.q = new Quaternion();
-        if (node.rotation) {
-            boneData.q.set(node.rotation[0], node.rotation[1], node.rotation[2], node.rotation[3]);
-        }
-        boneData.t = new Vector3();
-        if (node.translation) {
-            boneData.t.set(node.translation[0], node.translation[1], node.translation[2]);
-        }
-        avatarData.boneData.push(boneData);
-        avatarData.boneMap.set(boneData.boneName, boneData);
-        if (node.children) {
-            for (let children of node.children) {
-                this.buildSkeleton(avatarData, boneData, children);
-            }
-        }
-    }
-    buildSkeletonOld(skeleton, parent, nodeId, depth = 0) {
-        let node = this.gltf.nodes[nodeId];
-        if (!node.name) {
-            node.name = "Node_" + nodeId;
-        }
-        let joint = new Joint(node.name);
-        joint.parent = parent;
-        if (node.scale) {
-            joint.scale.set(node.scale[0], node.scale[1], node.scale[2]);
-        }
-        if (node.rotation) {
-            joint.rotation.set(node.rotation[0], node.rotation[1], node.rotation[2], node.rotation[3]);
-        }
-        if (node.translation) {
-            joint.translation.set(node.translation[0], node.translation[1], node.translation[2]);
-        }
-        skeleton.addJoint(joint);
-        if (node.children) {
-            for (let children of node.children) {
-                this.buildSkeletonOld(skeleton, joint, children, depth + 1);
-            }
-        }
-    }
-}

package/dist/src/loader/parser/gltf/GLTFSubParserSkin.d.ts

@@ -1,10 +0,0 @@
-import { GLTF_Info } from "./GLTFInfo";
-import { GLTFSubParser } from "./GLTFSubParser";
-export declare class GLTFSubParserSkin {
-    protected gltf: GLTF_Info;
-    protected subParser: GLTFSubParser;
-    constructor(subParser: GLTFSubParser);
-    parse(skinId: any): any;
-    private parseAccessor;
-    private errorMiss;
-}

package/dist/src/loader/parser/gltf/GLTFSubParserSkin.js

@@ -1,66 +0,0 @@
-import { GLTFParser } from "./GLTFParser";
-import { GLTFType } from "./GLTFType";
-export class GLTFSubParserSkin {
-    constructor(subParser) {
-        this.gltf = subParser.gltf;
-        this.subParser = subParser;
-    }
-    parse(skinId) {
-        const skin = this.gltf.skins[skinId];
-        if (!skin)
-            return this.errorMiss("skin", skinId);
-        if (skin.isParsed)
-            return skin.dskin;
-        const { name, joints, inverseBindMatrices, skeleton } = skin;
-        if (!joints)
-            return this.errorMiss("skin.joints", skinId);
-        skin.isParsed = true;
-        skin.dskin = false;
-        let dskin = {
-            name,
-            skeleton: null,
-            inverseBindMatrices: null,
-            joints,
-            defines: [GLTFParser.getJointsNumDefine(joints.length)],
-        };
-        if (skeleton) {
-            dskin.skeleton = skeleton;
-        }
-        else {
-            var rootNodeId = -1;
-            for (let i = 0; i < this.gltf.nodes.length; i++) {
-                const n = this.gltf.nodes[i];
-                if (n.name == "root") {
-                    rootNodeId = i;
-                    break;
-                }
-            }
-            if (rootNodeId == -1) {
-                let scene = this.gltf.scenes[this.gltf.scene];
-                rootNodeId = scene.nodes[scene.nodes.length - 1];
-            }
-            dskin.skeleton = rootNodeId;
-        }
-        dskin.inverseBindMatrices = GLTFType.IDENTITY_INVERSE_BIND_MATRICES;
-        if (inverseBindMatrices !== undefined) {
-            const accessor = this.parseAccessor(inverseBindMatrices);
-            if (accessor) {
-                const array = accessor.data;
-                const matrices = [];
-                for (let i = 0; i < array.length; i += 16)
-                    matrices.push(array.slice(i, i + 16));
-                dskin.inverseBindMatrices = matrices;
-            }
-            else
-                dskin = null;
-        }
-        skin.dskin = dskin;
-        return skin.dskin;
-    }
-    parseAccessor(accessorId) {
-        return this.subParser.parseAccessor(accessorId);
-    }
-    errorMiss(e, info) {
-        throw new Error(e + info);
-    }
-}

package/dist/src/loader/parser/gltf/GLTFType.d.ts

@@ -1,22 +0,0 @@
-export declare class GLTFType {
-    static readonly GLTF_NODE_INDEX_PROPERTY: "GLTF_NODE_INDEX";
-    static readonly BASE_COLOR_UNIFORM = "u_baseColorFactor";
-    static readonly BASE_COLOR_TEXTURE_UNIFORM = "u_baseColorSampler";
-    static readonly METALROUGHNESS_UNIFORM = "u_metallicRoughnessValues";
-    static readonly METALROUGHNESS_TEXTURE_UNIFORM = "u_metallicRoughnessSampler";
-    static readonly NORMAL_TEXTURE_UNIFORM = "u_normalSampler";
-    static readonly NORMAL_SCALE_UNIFORM = "u_normalScale";
-    static readonly EMISSIVE_TEXTURE_UNIFORM = "u_emissiveSampler";
-    static readonly EMISSIVE_FACTOR_UNIFORM = "u_emissiveFactor";
-    static readonly OCCLUSION_TEXTURE_UNIFORM = "u_occlusionSampler";
-    static readonly OCCLUSION_FACTOR_UNIFORM = "u_occlusionFactor";
-    static readonly MAX_MORPH_TARGETS = 8;
-    static readonly MORPH_POSITION_PREFIX = "a_morphPositions_";
-    static readonly MORPH_NORMAL_PREFIX = "a_morphNormals_";
-    static readonly MORPH_TANGENT_PREFIX = "a_morphTangents_";
-    static readonly MORPH_WEIGHT_UNIFORM = "u_morphWeights";
-    static readonly SCENE_ROOT_SKELETON = "SCENE_ROOT";
-    static readonly IDENTITY_INVERSE_BIND_MATRICES = "IDENTITY_IBM";
-    static readonly JOINT_MATRICES_UNIFORM = "u_jointMatrix";
-    static readonly ALPHA_CUTOFF_UNIFORM = "u_alphaCutoff";
-}

package/dist/src/loader/parser/gltf/GLTFType.js

@@ -1,21 +0,0 @@
-export class GLTFType {
-    static { this.BASE_COLOR_UNIFORM = "u_baseColorFactor"; }
-    static { this.BASE_COLOR_TEXTURE_UNIFORM = "u_baseColorSampler"; }
-    static { this.METALROUGHNESS_UNIFORM = "u_metallicRoughnessValues"; }
-    static { this.METALROUGHNESS_TEXTURE_UNIFORM = "u_metallicRoughnessSampler"; }
-    static { this.NORMAL_TEXTURE_UNIFORM = "u_normalSampler"; }
-    static { this.NORMAL_SCALE_UNIFORM = "u_normalScale"; }
-    static { this.EMISSIVE_TEXTURE_UNIFORM = "u_emissiveSampler"; }
-    static { this.EMISSIVE_FACTOR_UNIFORM = "u_emissiveFactor"; }
-    static { this.OCCLUSION_TEXTURE_UNIFORM = "u_occlusionSampler"; }
-    static { this.OCCLUSION_FACTOR_UNIFORM = "u_occlusionFactor"; }
-    static { this.MAX_MORPH_TARGETS = 8; }
-    static { this.MORPH_POSITION_PREFIX = "a_morphPositions_"; }
-    static { this.MORPH_NORMAL_PREFIX = "a_morphNormals_"; }
-    static { this.MORPH_TANGENT_PREFIX = "a_morphTangents_"; }
-    static { this.MORPH_WEIGHT_UNIFORM = "u_morphWeights"; }
-    static { this.SCENE_ROOT_SKELETON = "SCENE_ROOT"; }
-    static { this.IDENTITY_INVERSE_BIND_MATRICES = "IDENTITY_IBM"; }
-    static { this.JOINT_MATRICES_UNIFORM = "u_jointMatrix"; }
-    static { this.ALPHA_CUTOFF_UNIFORM = "u_alphaCutoff"; }
-}

package/dist/src/loader/parser/gltf/TypeArray.d.ts

@@ -1,4 +0,0 @@
-export declare function getGLTypeFromTypedArrayType(typedArrayType: any): 5120 | 5121 | 5122 | 5123 | 5124 | 5125 | 5126;
-export declare function getGLTypeFromTypedArray(typedArray: any): 5120 | 5121 | 5122 | 5123 | 5124 | 5125 | 5126;
-export declare function getTypedArrayTypeFromGLType(type: any): any;
-export declare function getTypedArray(array: any, Type?: Float32ArrayConstructor): any;