Gltf model and animations exploring problems (#1635)

* Added bone binding to whole mesh and not only set vertices.
+ Also added missed setting of the animation count.
+ Removed double ; on one line

* Added more of the gltf sample models

https://github.com/KhronosGroup/glTF-Sample-Models
We need to make it working for all of them.

* Binding to initial bind pose added.

* Fix cube disappearing bug because lerpPercent could be Inf.

* Fixed for rigged figure also

1 files changed, 73 insertions, 5 deletions

diff --git a/src/models.c b/src/models.c
index 00e4c1e3..eba6f4f6 100644
--- a/src/models.c
+++ b/src/models.c
@@ -754,7 +754,7 @@ Model LoadModel(const char *fileName)
 
         if (model.meshMaterial == NULL) model.meshMaterial = (int *)RL_CALLOC(model.meshCount, sizeof(int));
     }
-
+	
     return model;
 }
 
@@ -3979,10 +3979,75 @@ static Model LoadGLTF(const char *fileName)
                 }
                 else
                 {
-                    model.meshMaterial[primitiveIndex] = model.materialCount - 1;;
+                    model.meshMaterial[primitiveIndex] = model.materialCount - 1;
                 }
                 
 //                if (data->meshes[i].)
+
+                if (model.meshes[primitiveIndex].boneIds == NULL && data->nodes_count > 0)
+                {
+                    for (int nodeId = 0; nodeId < data->nodes_count; nodeId++)
+                    {
+                        if (data->nodes[nodeId].mesh == &(data->meshes[i]))
+                        {
+                            model.meshes[primitiveIndex].boneIds = RL_CALLOC(4 * model.meshes[primitiveIndex].vertexCount, sizeof(int));
+                            model.meshes[primitiveIndex].boneWeights = RL_CALLOC(4 * model.meshes[primitiveIndex].vertexCount, sizeof(float));
+
+                        	for (int b = 0; b < 4 * model.meshes[primitiveIndex].vertexCount; b++)
+                            {
+                        		if(b % 4 == 0)
+                        		{
+                                    model.meshes[primitiveIndex].boneIds[b] = nodeId;
+                                    model.meshes[primitiveIndex].boneWeights[b] = 1.0f;
+                        		}
+                        		else
+                        		{
+                                    model.meshes[primitiveIndex].boneIds[b] = 0;
+                                    model.meshes[primitiveIndex].boneWeights[b] = 0.0f;
+                        		}
+                            
+                            }
+    
+                            Vector3 boundVertex = { 0 };
+                            Vector3 boundNormal = { 0 };
+    
+                            Vector3 outTranslation = { 0 };
+                            Quaternion outRotation = { 0 };
+                            Vector3 outScale = { 0 };
+    
+                            int vCounter = 0;
+                            int boneCounter = 0;
+                            int boneId = 0;
+    
+                            for (int i = 0; i < model.meshes[primitiveIndex].vertexCount; i++)
+                            {
+                                boneId = model.meshes[primitiveIndex].boneIds[boneCounter];
+                                outTranslation = model.bindPose[boneId].translation;
+                                outRotation = model.bindPose[boneId].rotation;
+                                outScale = model.bindPose[boneId].scale;
+        
+                                // Vertices processing
+                                boundVertex = (Vector3){ model.meshes[primitiveIndex].vertices[vCounter], model.meshes[primitiveIndex].vertices[vCounter + 1], model.meshes[primitiveIndex].vertices[vCounter + 2] };
+                                boundVertex = Vector3Multiply(boundVertex, outScale);
+                                boundVertex = Vector3RotateByQuaternion(boundVertex, outRotation);
+                                boundVertex = Vector3Add(boundVertex, outTranslation);
+                                model.meshes[primitiveIndex].vertices[vCounter] = boundVertex.x;
+                                model.meshes[primitiveIndex].vertices[vCounter + 1] = boundVertex.y;
+                                model.meshes[primitiveIndex].vertices[vCounter + 2] = boundVertex.z;
+        
+                                // Normals processing
+                                boundNormal = (Vector3){ model.meshes[primitiveIndex].normals[vCounter], model.meshes[primitiveIndex].normals[vCounter + 1], model.meshes[primitiveIndex].normals[vCounter + 2] };
+                                boundNormal = Vector3RotateByQuaternion(boundNormal, outRotation);
+                                model.meshes[primitiveIndex].normals[vCounter] = boundNormal.x;
+                                model.meshes[primitiveIndex].normals[vCounter + 1] = boundNormal.y;
+                                model.meshes[primitiveIndex].normals[vCounter + 2] = boundNormal.z;
+                                vCounter += 3;
+        
+                                boneCounter += 4;
+                            }
+                        }
+                    }
+                }
                 
                 primitiveIndex++;
             }
@@ -4053,9 +4118,9 @@ static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCo
 
         result = cgltf_load_buffers(&options, data, fileName);
         if (result != cgltf_result_success) TRACELOG(LOG_WARNING, "MODEL: [%s] unable to load glTF animations data", fileName);
-        
         animations = RL_MALLOC(data->animations_count*sizeof(ModelAnimation));
-    
+        *animCount = data->animations_count;
+
         for (unsigned int a = 0; a < data->animations_count; a++)
         {
             // gltf animation consists of the following structures:
@@ -4150,7 +4215,10 @@ static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCo
                                 float previousInputTime = 0.0f;
                                 if (GltfReadFloat(sampler->input, outputMin, (float *)&previousInputTime, 1))
                                 {
-                                    lerpPercent = (frameTime - previousInputTime)/(inputFrameTime - previousInputTime);
+                                    if((inputFrameTime - previousInputTime) != 0)
+                                    {
+                                        lerpPercent = (frameTime - previousInputTime)/(inputFrameTime - previousInputTime);
+                                    }
                                 }
                                 
                                 break;