Merge animation changes from @BeardedGnome

loaders/src/glTF/2.0/babylon.glTFLoader.ts

@@ -21,6 +21,10 @@ module BABYLON.GLTF2 {
         }
     };
 
+    var createStringId = (index: number): string => {
+        return "node" + index;
+    };
+
     /**
     * Returns the animation path (glTF -> Babylon)
     */
@@ -45,7 +49,7 @@ module BABYLON.GLTF2 {
 
         for (var animationIndex = 0; animationIndex < animations.length; animationIndex++) {
             var animation = animations[animationIndex];
-            if (!animation || !animation.channels) {
+            if (!animation || !animation.channels || !animation.samplers) {
                 continue;
             }
 
@@ -68,8 +72,9 @@ module BABYLON.GLTF2 {
                 var bufferInput = GLTFUtils.GetBufferFromAccessor(runtime, runtime.gltf.accessors[inputData]);
                 var bufferOutput = GLTFUtils.GetBufferFromAccessor(runtime, runtime.gltf.accessors[outputData]);
 
-                var targetID = channel.target.id;
-                var targetNode: any = runtime.gltf.nodes[channel.target.id].babylonNode;
+                var targetID = channel.target.node;
+                var targetNode: any = runtime.babylonScene.getNodeByID(createStringId(targetID));
+
                 if (targetNode === null) {
                     Tools.Warn("Creating animation index " + animationIndex + " but cannot find node index " + targetID + " to attach to");
                     continue;
@@ -194,7 +199,7 @@ module BABYLON.GLTF2 {
             mat = Matrix.Compose(scale, rotation, position);
         }
         else {
-            mat = Matrix.FromArray(node.matrix);
+            mat = node.matrix ? Matrix.FromArray(node.matrix) : Matrix.Identity();
         }
 
         return mat;
@@ -203,41 +208,38 @@ module BABYLON.GLTF2 {
     /**
     * Returns the parent bone
     */
-    var getParentBone = (runtime: IGLTFRuntime, skin: IGLTFSkin, jointName: string, newSkeleton: Skeleton): Bone => {
-        // TODO: animation schema broken
-        /*
+    var getParentBone = (runtime: IGLTFRuntime, skin: IGLTFSkin, index: number, newSkeleton: Skeleton): Bone => {
         // Try to find
+        var nodeStringID = createStringId(index);
         for (var i = 0; i < newSkeleton.bones.length; i++) {
-            if (newSkeleton.bones[i].name === jointName) {
-                return newSkeleton.bones[i];
+            if (newSkeleton.bones[i].id === nodeStringID) {
+                return newSkeleton.bones[i].getParent();
             }
         }
 
         // Not found, search in gltf nodes
-        var nodes = runtime.gltf.nodes;
-        for (var nde in nodes) {
-            var node: IGLTFNode = nodes[nde];
-
-            if (!node.jointName) {
-                continue;
-            }
+        var joints = skin.joints;
+        for (var j = 0; j < joints.length; j++) {
+            var parentID = joints[j];
+            var parent = runtime.gltf.nodes[parentID];
 
-            var children = node.children;
+            var children = parent.children;
             for (var i = 0; i < children.length; i++) {
-                var child: IGLTFNode = runtime.gltf.nodes[children[i]];
-                if (!child.jointName) {
+                var childID = children[i];
+                var child = runtime.gltf.nodes[childID];
+                if (!nodeIsInJoints(skin, childID)) {
                     continue;
                 }
 
-                if (child.jointName === jointName) {
-                    var mat = configureBoneTransformation(node);
-                    var bone = new Bone(node.name, newSkeleton, getParentBone(runtime, skin, node.jointName, newSkeleton), mat);
-                    bone.id = nde;
+                if (childID === index)
+                {
+                    var mat = configureBoneTransformation(parent);
+                    var bone = new Bone(parent.name || createStringId(parentID), newSkeleton, getParentBone(runtime, skin, parentID, newSkeleton), mat);
+                    bone.id = createStringId(parentID);
                     return bone;
                 }
             }
         }
-        */
 
         return null;
     }
@@ -245,65 +247,47 @@ module BABYLON.GLTF2 {
     /**
     * Returns the appropriate root node
     */
-    var getNodeToRoot = (nodesToRoot: INodeToRoot[], id: string): Bone => {
-        // TODO: animation schema broken
-        /*
+    var getNodeToRoot = (nodesToRoot: INodeToRoot[], index: number): Bone => {
         for (var i = 0; i < nodesToRoot.length; i++) {
             var nodeToRoot = nodesToRoot[i];
 
-            for (var j = 0; j < nodeToRoot.node.children.length; j++) {
-                var child = nodeToRoot.node.children[j];
-                if (child === id) {
-                    return nodeToRoot.bone;
+            if (nodeToRoot.node.children) {
+                for (var j = 0; j < nodeToRoot.node.children.length; j++) {
+                    var child = nodeToRoot.node.children[j];
+                    if (child === index) {
+                        return nodeToRoot.bone;
+                    }
                 }
             }
         }
-        */
 
         return null;
     };
 
     /**
-    * Returns the node with the joint name
+    * Returns the node with the node index
     */
-    var getJointNode = (runtime: IGLTFRuntime, jointName: string): IJointNode => {
-        // TODO: animation schema broken
-        /*
-        var nodes = runtime.nodes;
-        var node: IGLTFNode = nodes[jointName];
+    var getJointNode = (runtime: IGLTFRuntime, index: number): IJointNode => {
+        var node = runtime.gltf.nodes[index];
         if (node) {
             return {
                 node: node,
-                id: jointName
+                index: index
             };
         }
 
-        for (var nde in nodes) {
-            node = nodes[nde];
-            if (node.jointName === jointName) {
-                return {
-                    node: node,
-                    id: nde
-                };
-            }
-        }
-        */
-
         return null;
     }
 
     /**
     * Checks if a nodes is in joints
     */
-    var nodeIsInJoints = (skin: IGLTFSkin, id: string): boolean => {
-        // TODO: animation schema broken
-        /*
-        for (var i = 0; i < skin.jointNames.length; i++) {
-            if (skin.jointNames[i] === id) {
+    var nodeIsInJoints = (skin: IGLTFSkin, index: number): boolean => {
+        for (var i = 0; i < skin.joints.length; i++) {
+            if (skin.joints[i] === index) {
                 return true;
             }
         }
-        */
 
         return false;
     }
@@ -312,22 +296,19 @@ module BABYLON.GLTF2 {
     * Fills the nodes to root for bones and builds hierarchy
     */
     var getNodesToRoot = (runtime: IGLTFRuntime, newSkeleton: Skeleton, skin: IGLTFSkin, nodesToRoot: INodeToRoot[]): void => {
-        // TODO: animation schema broken
-        /*
         // Creates nodes for root
-        for (var nde in runtime.nodes) {
-            var node: IGLTFNode = runtime.nodes[nde];
-            var id = nde;
+        for (var i = 0; i < runtime.gltf.nodes.length; i++) {
+            var node = runtime.gltf.nodes[i];
 
-            if (!node.jointName || nodeIsInJoints(skin, node.jointName)) {
+            if (nodeIsInJoints(skin, i)) {
                 continue;
             }
 
             // Create node to root bone
             var mat = configureBoneTransformation(node);
-            var bone = new Bone(node.name, newSkeleton, null, mat);
-            bone.id = id;
-            nodesToRoot.push({ bone: bone, node: node, id: id });
+            var bone = new Bone(node.name || createStringId(i), newSkeleton, null, mat);
+            bone.id = createStringId(i);
+            nodesToRoot.push({ bone: bone, node: node, index: i });
         }
 
         // Parenting
@@ -335,69 +316,69 @@ module BABYLON.GLTF2 {
             var nodeToRoot = nodesToRoot[i];
             var children = nodeToRoot.node.children;
 
-            for (var j = 0; j < children.length; j++) {
-                var child: INodeToRoot = null;
+            if (children) {
+                for (var j = 0; j < children.length; j++) {
+                    var child: INodeToRoot = null;
 
-                for (var k = 0; k < nodesToRoot.length; k++) {
-                    if (nodesToRoot[k].id === children[j]) {
-                        child = nodesToRoot[k];
-                        break;
+                    for (var k = 0; k < nodesToRoot.length; k++) {
+                        if (nodesToRoot[k].index === children[j]) {
+                            child = nodesToRoot[k];
+                            break;
+                        }
                     }
-                }
 
-                if (child) {
-                    (<any>child.bone)._parent = nodeToRoot.bone;
-                    nodeToRoot.bone.children.push(child.bone);
+                    if (child) {
+                        (<any>child.bone)._parent = nodeToRoot.bone;
+                        nodeToRoot.bone.children.push(child.bone);
+                    }
                 }
             }
         }
-        */
     };
 
     /**
     * Imports a skeleton
     */
-    var importSkeleton = (runtime: IGLTFRuntime, skin: IGLTFSkin, mesh: Mesh, newSkeleton: Skeleton, index: number): Skeleton => {
-        // TODO: animation schema broken
-        return null;
-        /*
-        if (!newSkeleton) {
-            newSkeleton = new Skeleton(skin.name, "", runtime.scene);
+    var importSkeleton = (runtime: IGLTFRuntime, skinNode: IGLTFNode, skin: IGLTFSkin): Skeleton => {
+        var name = skin.name || "skin" + skinNode.skin;
+
+        var babylonSkeleton = <Skeleton>skin.babylonSkeleton;
+        if (!babylonSkeleton) {
+            babylonSkeleton = new Skeleton(name, "skin" + skinNode.skin, runtime.babylonScene);
         }
 
         if (!skin.babylonSkeleton) {
-            return newSkeleton;
+            return babylonSkeleton;
         }
 
         // Matrices
-        var accessor = runtime.accessors[skin.inverseBindMatrices];
+        var accessor = runtime.gltf.accessors[skin.inverseBindMatrices];
         var buffer = GLTFUtils.GetBufferFromAccessor(runtime, accessor);
 
-        var bindShapeMatrix = Matrix.FromArray(skin.bindShapeMatrix);
-
         // Find the root bones
         var nodesToRoot: INodeToRoot[] = [];
         var nodesToRootToAdd: Bone[] = [];
 
-        getNodesToRoot(runtime, newSkeleton, skin, nodesToRoot);
-        newSkeleton.bones = [];
+        getNodesToRoot(runtime, babylonSkeleton, skin, nodesToRoot);
+        babylonSkeleton.bones = [];
 
         // Joints
-        for (var i = 0; i < skin.jointNames.length; i++) {
-            var jointNode = getJointNode(runtime, skin.jointNames[i]);
+        for (var i = 0; i < skin.joints.length; i++) {
+            var jointNode = getJointNode(runtime, skin.joints[i]);
             var node = jointNode.node;
 
             if (!node) {
-                Tools.Warn("Joint named " + skin.jointNames[i] + " does not exist");
+                Tools.Warn("Joint index " + skin.joints[i] + " does not exist");
                 continue;
             }
 
-            var id = jointNode.id;
+            var index = jointNode.index;
+            var stringID = createStringId(index);
 
             // Optimize, if the bone already exists...
-            var existingBone = runtime.scene.getBoneByID(id);
+            var existingBone = runtime.babylonScene.getBoneByID(stringID);
             if (existingBone) {
-                newSkeleton.bones.push(existingBone);
+                babylonSkeleton.bones.push(existingBone);
                 continue;
             }
 
@@ -406,10 +387,10 @@ module BABYLON.GLTF2 {
             var parentBone: Bone = null;
 
             for (var j = 0; j < i; j++) {
-                var joint: IGLTFNode = getJointNode(runtime, skin.jointNames[j]).node;
+                var joint: IGLTFNode = getJointNode(runtime, skin.joints[j]).node;
 
                 if (!joint) {
-                    Tools.Warn("Joint named " + skin.jointNames[j] + " does not exist when looking for parent");
+                    Tools.Warn("Joint index " + skin.joints[j] + " does not exist when looking for parent");
                     continue;
                 }
 
@@ -417,8 +398,8 @@ module BABYLON.GLTF2 {
                 foundBone = false;
 
                 for (var k = 0; k < children.length; k++) {
-                    if (children[k] === id) {
-                        parentBone = getParentBone(runtime, skin, skin.jointNames[j], newSkeleton);
+                    if (children[k] === index) {
+                        parentBone = getParentBone(runtime, skin, skin.joints[j], babylonSkeleton);
                         foundBone = true;
                         break;
                     }
@@ -433,7 +414,7 @@ module BABYLON.GLTF2 {
             var mat = configureBoneTransformation(node);
 
             if (!parentBone && nodesToRoot.length > 0) {
-                parentBone = getNodeToRoot(nodesToRoot, id);
+                parentBone = getNodeToRoot(nodesToRoot, index);
 
                 if (parentBone) {
                     if (nodesToRootToAdd.indexOf(parentBone) === -1) {
@@ -442,41 +423,64 @@ module BABYLON.GLTF2 {
                 }
             }
 
-            var bone = new Bone(node.jointName, newSkeleton, parentBone, mat);
-            bone.id = id;
+            var bone = new Bone(node.name || stringID, babylonSkeleton, parentBone, mat);
+            bone.id = stringID;
         }
 
         // Polish
-        var bones = newSkeleton.bones;
-        newSkeleton.bones = [];
+        var bones = babylonSkeleton.bones;
+        babylonSkeleton.bones = [];
         
-        for (var i = 0; i < skin.jointNames.length; i++) {
-            var jointNode: IJointNode = getJointNode(runtime, skin.jointNames[i]);
+        for (var i = 0; i < skin.joints.length; i++) {
+            var jointNode = getJointNode(runtime, skin.joints[i]);
 
             if (!jointNode) {
                 continue;
             }
 
+            var jointNodeStringId = createStringId(jointNode.index);
             for (var j = 0; j < bones.length; j++) {
-                if (bones[j].id === jointNode.id) {
-                    newSkeleton.bones.push(bones[j]);
+                if (bones[j].id === jointNodeStringId) {
+                    babylonSkeleton.bones.push(bones[j]);
                     break;
                 }
             }
         }
 
-        newSkeleton.prepare();
+        babylonSkeleton.prepare();
 
         // Finish
         for (var i = 0; i < nodesToRootToAdd.length; i++) {
-            newSkeleton.bones.push(nodesToRootToAdd[i]);
+            babylonSkeleton.bones.push(nodesToRootToAdd[i]);
         }
 
-        return newSkeleton;
-        */
+        return babylonSkeleton;
     };
 
     /**
+     * Gets a material
+     */
+    var getMaterial = (runtime: IGLTFRuntime, index?: number): PBRMaterial => {
+        if (index === undefined) {
+            return GLTFUtils.GetDefaultMaterial(runtime);
+        }
+
+        var materials = runtime.gltf.materials;
+        if (!materials || index < 0 || index >= materials.length) {
+            Tools.Error("Invalid material index");
+            return GLTFUtils.GetDefaultMaterial(runtime);
+        }
+
+        var material = runtime.gltf.materials[index].babylonMaterial;
+        if (!material)
+        {
+            return GLTFUtils.GetDefaultMaterial(runtime);
+        }
+
+        return material;
+    }
+
+    /**
     * Imports a mesh and its geometries
     */
     var importMesh = (runtime: IGLTFRuntime, node: IGLTFNode, mesh: IGLTFMesh): Mesh => {
@@ -600,8 +604,8 @@ module BABYLON.GLTF2 {
             tempVertexData = undefined;
 
             // Sub material
-            var material = runtime.gltf.materials[primitive.material].babylonMaterial;
-            multiMat.subMaterials.push(material === undefined ? GLTFUtils.GetDefaultMaterial(runtime.babylonScene) : material);
+            var material = getMaterial(runtime, primitive.material);
+            multiMat.subMaterials.push(material);
 
             // Update vertices start and index start
             verticesStarts.push(verticesStarts.length === 0 ? 0 : verticesStarts[verticesStarts.length - 1] + verticesCounts[verticesCounts.length - 2]);
@@ -675,25 +679,20 @@ module BABYLON.GLTF2 {
 
         // Meshes
         if (node.skin !== undefined) {
-            // TODO: animation schema broken
-            /*
-            if (node.mesh) {
-                var skin: IGLTFSkin = runtime.gltf.skins[node.skin];
-
-                var newMesh = importMesh(runtime, node);
-                newMesh.skeleton = runtime.babylonScene.getLastSkeletonByID(node.skin);
+            if (node.mesh !== undefined) {
+                var skin = runtime.gltf.skins[node.skin];
 
-                if (newMesh.skeleton === null) {
-                    newMesh.skeleton = importSkeleton(runtime, skin, newMesh, skin.babylonSkeleton, node.skin);
+                var newMesh = importMesh(runtime, node, runtime.gltf.meshes[node.mesh]);
+                var newSkeleton = importSkeleton(runtime, node, skin);
 
-                    if (!skin.babylonSkeleton) {
-                        skin.babylonSkeleton = newMesh.skeleton;
-                    }
+                if (newSkeleton)
+                {
+                    newMesh.skeleton = newSkeleton;
+                    skin.babylonSkeleton = newSkeleton;
                 }
 
-                lastNode = newMesh;
+                babylonNode = newMesh;
             }
-            */
         }
         else if (node.mesh !== undefined) {
             babylonNode = importMesh(runtime, node, runtime.gltf.meshes[node.mesh]);
@@ -702,12 +701,11 @@ module BABYLON.GLTF2 {
         else if (node.camera !== undefined && !node.babylonNode && !runtime.importOnlyMeshes) {
             var camera = runtime.gltf.cameras[node.camera];
 
-            if (camera) {
+            if (camera !== undefined) {
                 if (camera.type === "orthographic") {
                     var orthographicCamera = camera.orthographic;
                     var orthoCamera = new FreeCamera(node.name || "camera" + node.camera, Vector3.Zero(), runtime.babylonScene);
 
-                    orthoCamera.name = node.name;
                     orthoCamera.mode = Camera.ORTHOGRAPHIC_CAMERA;
                     orthoCamera.attachControl(runtime.babylonScene.getEngine().getRenderingCanvas());
 
@@ -717,7 +715,6 @@ module BABYLON.GLTF2 {
                     var perspectiveCamera = camera.perspective;
                     var persCamera = new FreeCamera(node.name || "camera" + node.camera, Vector3.Zero(), runtime.babylonScene);
 
-                    persCamera.name = node.name;
                     persCamera.attachControl(runtime.babylonScene.getEngine().getRenderingCanvas());
 
                     if (!perspectiveCamera.aspectRatio) {
@@ -735,15 +732,13 @@ module BABYLON.GLTF2 {
         }
 
         // Empty node
-        if (node.jointName === undefined) {
-            if (node.babylonNode) {
-                return node.babylonNode;
-            }
-            else if (babylonNode === null) {
-                var dummy = new Mesh(node.name, runtime.babylonScene);
-                node.babylonNode = dummy;
-                babylonNode = dummy;
-            }
+        if (node.babylonNode) {
+            return node.babylonNode;
+        }
+        else if (babylonNode === null) {
+            var dummy = new Mesh(node.name || "mesh" + node.mesh, runtime.babylonScene);
+            node.babylonNode = dummy;
+            babylonNode = dummy;
         }
 
         if (babylonNode !== null) {
@@ -759,7 +754,7 @@ module BABYLON.GLTF2 {
     * Traverses nodes and creates them
     */
     var traverseNodes = (runtime: IGLTFRuntime, index: number, parent: Node, meshIncluded?: boolean): void => {
-        var node: IGLTFNode = runtime.gltf.nodes[index];
+        var node = runtime.gltf.nodes[index];
         var newNode: Node = null;
 
         if (runtime.importOnlyMeshes && !meshIncluded) {
@@ -774,10 +769,11 @@ module BABYLON.GLTF2 {
             meshIncluded = true;
         }
 
-        if (node.jointName === undefined && meshIncluded) {
+        if (meshIncluded) {
             newNode = importNode(runtime, node);
 
             if (newNode !== null) {
+                newNode.id = createStringId(index);
                 newNode.parent = parent;
             }
         }
@@ -822,8 +818,10 @@ module BABYLON.GLTF2 {
     };
 
     var importMaterials = (runtime: IGLTFRuntime): void => {
-        for (var i = 0; i < runtime.gltf.materials.length; i++) {
-            GLTFLoaderExtension.LoadMaterial(runtime, i);
+        if (runtime.gltf.materials) {
+            for (var i = 0; i < runtime.gltf.materials.length; i++) {
+                GLTFLoaderExtension.LoadMaterial(runtime, i);
+            }
         }
     };
 
@@ -1074,16 +1072,16 @@ module BABYLON.GLTF2 {
             var skeletons = [];
 
             // Fill arrays of meshes and skeletons
-            for (var nde in runtime.gltf.nodes) {
-                var node: IGLTFNode = runtime.gltf.nodes[nde];
+            for (var i = 0; i < runtime.gltf.nodes.length; i++) {
+                var node = runtime.gltf.nodes[i];
 
                 if (node.babylonNode instanceof AbstractMesh) {
                     meshes.push(<AbstractMesh>node.babylonNode);
                 }
             }
 
-            for (var skl in runtime.gltf.skins) {
-                var skin: IGLTFSkin = runtime.gltf.skins[skl];
+            for (var i = 0; i < runtime.gltf.skins.length; i++) {
+                var skin = runtime.gltf.skins[i];
 
                 if (skin.babylonSkeleton instanceof Skeleton) {
                     skeletons.push(skin.babylonSkeleton);

loaders/src/glTF/2.0/babylon.glTFLoaderInterfaces.ts

@@ -102,37 +102,54 @@ module BABYLON.GLTF2 {
         name?: string;
     }
 
-    export interface IGLTFAccessor extends IGLTFChildRootProperty {
+    export interface IGLTFAccessorSparseIndices extends IGLTFProperty {
         bufferView: number;
-        byteOffset: number;
-        byteStride?: number;
+        byteOffset?: number;
+        componentType: EComponentType;
+    }
+
+    export interface IGLTFAccessorSparseValues extends IGLTFProperty {
+        bufferView: number;
+        byteOffset?: number;
+    }
+
+    export interface IGLTFAccessorSparse extends IGLTFProperty {
+        count: number;
+        indices: IGLTFAccessorSparseIndices;
+        values: IGLTFAccessorSparseValues;
+    }
+
+    export interface IGLTFAccessor extends IGLTFChildRootProperty {
+        bufferView?: number;
+        byteOffset?: number;
         componentType: EComponentType;
         normalized?: boolean;
         count: number;
         type: string;
         max: number[];
         min: number[];
+        sparse?: IGLTFAccessorSparse;
     }
 
-    export interface IGLTFAnimationChannel {
+    export interface IGLTFAnimationChannel extends IGLTFProperty {
         sampler: number;
         target: IGLTFAnimationChannelTarget;
     }
 
-    export interface IGLTFAnimationChannelTarget {
-        id: number;
+    export interface IGLTFAnimationChannelTarget extends IGLTFProperty {
+        node: number;
         path: string;
     }
 
-    export interface IGLTFAnimationSampler {
+    export interface IGLTFAnimationSampler extends IGLTFProperty {
         input: number;
         interpolation?: string;
         output: number;
     }
 
     export interface IGLTFAnimation extends IGLTFChildRootProperty {
-        channels?: IGLTFAnimationChannel[];
-        samplers?: IGLTFAnimationSampler[];
+        channels: IGLTFAnimationChannel[];
+        samplers: IGLTFAnimationSampler[];
     }
 
     export interface IGLTFAssetProfile extends IGLTFProperty {
@@ -159,17 +176,18 @@ module BABYLON.GLTF2 {
         buffer: number;
         byteOffset: number;
         byteLength: number;
+        byteStride?: number;
         target?: EBufferViewTarget;
     }
 
-    export interface IGLTFCameraOrthographic {
+    export interface IGLTFCameraOrthographic extends IGLTFProperty {
         xmag: number;
         ymag: number;
         zfar: number;
         znear: number;
     }
 
-    export interface IGLTFCameraPerspective {
+    export interface IGLTFCameraPerspective extends IGLTFProperty {
         aspectRatio: number;
         yfov: number;
         zfar: number;
@@ -223,23 +241,24 @@ module BABYLON.GLTF2 {
         indices?: number;
         material?: number;
         mode?: EMeshPrimitiveMode;
+        targets?: number[];
     }
 
     export interface IGLTFMesh extends IGLTFChildRootProperty {
         primitives: IGLTFMeshPrimitive[];
+        weights?: number[];
     }
 
     export interface IGLTFNode extends IGLTFChildRootProperty {
         camera?: number;
         children?: number[];
-        skeletons?: number[];
         skin?: number;
-        jointName?: number;
-        matrix: number[];
+        matrix?: number[];
         mesh?: number;
         rotation?: number[];
         scale?: number[];
         translation?: number[];
+        weights?: number[];
 
         // Babylon.js values (optimize)
         babylonNode?: Node;
@@ -257,10 +276,11 @@ module BABYLON.GLTF2 {
     }
 
     export interface IGLTFSkin extends IGLTFChildRootProperty {
-        bindShapeMatrix?: number[];
         inverseBindMatrices?: number;
-        jointNames: number[];
+        skeleton?: number;
+        joints: number[];
 
+        // Babylon.js values (optimize)
         babylonSkeleton?: Skeleton;
     }
 
@@ -310,6 +330,8 @@ module BABYLON.GLTF2 {
 
         importOnlyMeshes: boolean;
         importMeshesNames?: string[];
+
+        defaultMaterial?: PBRMaterial;
     }
 
     /**
@@ -318,11 +340,11 @@ module BABYLON.GLTF2 {
     export interface INodeToRoot {
         bone: Bone;
         node: IGLTFNode;
-        id: string;
+        index: number;
     }
 
     export interface IJointNode {
         node: IGLTFNode;
-        id: string;
+        index: number;
     }
 }

loaders/src/glTF/2.0/babylon.glTFLoaderUtils.ts

@@ -126,21 +126,16 @@ module BABYLON.GLTF2 {
          * Returns the default material of gltf.
          * @param scene: the Babylon.js scene
          */
-        public static GetDefaultMaterial(scene: Scene): PBRMaterial {
-            if (!GLTFUtils._DefaultMaterial) {
-                var material = new PBRMaterial("gltf_default", scene);
+        public static GetDefaultMaterial(runtime: IGLTFRuntime): PBRMaterial {
+            if (!runtime.defaultMaterial) {
+                var material = new PBRMaterial("gltf_default", runtime.babylonScene);
                 material.sideOrientation = Material.CounterClockWiseSideOrientation;
-                material.albedoColor = new Color3(0.5, 0.5, 0.5);
-                material.metallic = 0;
-                material.roughness = 0.5;
-
-                GLTFUtils._DefaultMaterial = material;
+                material.metallic = 1;
+                material.roughness = 1;
+                runtime.defaultMaterial = material;
             }
 
-            return GLTFUtils._DefaultMaterial;
+            return runtime.defaultMaterial;
         }
-
-        // The GLTF default material
-        private static _DefaultMaterial: PBRMaterial = null;
     }
 }