@rings-webgpu/core 1.0.0 → 1.0.2

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

@@ -0,0 +1,170 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,313 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,4 @@
+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;