|
|
|
@ -859,7 +859,7 @@ void UnloadMesh(Mesh mesh) |
|
|
|
{ |
|
|
|
// Unload rlgl mesh vboId data |
|
|
|
rlUnloadMesh(&mesh); |
|
|
|
|
|
|
|
|
|
|
|
RL_FREE(mesh.vertices); |
|
|
|
RL_FREE(mesh.texcoords); |
|
|
|
RL_FREE(mesh.normals); |
|
|
|
@ -1033,7 +1033,7 @@ ModelAnimation *LoadModelAnimations(const char *fileName, int *animCount) |
|
|
|
#if defined(SUPPORT_FILEFORMAT_GLTF) |
|
|
|
if (IsFileExtension(fileName, ".gltf;.glb")) animations = LoadGLTFModelAnimations(fileName, animCount); |
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
|
|
return animations; |
|
|
|
} |
|
|
|
|
|
|
|
@ -1093,7 +1093,7 @@ void UpdateModelAnimation(Model model, ModelAnimation anim, int frame) |
|
|
|
model.meshes[m].animNormals[vCounter + 1] = animNormal.y; |
|
|
|
model.meshes[m].animNormals[vCounter + 2] = animNormal.z; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
vCounter += 3; |
|
|
|
boneCounter += 4; |
|
|
|
} |
|
|
|
@ -3300,11 +3300,11 @@ static ModelAnimation* LoadIQMModelAnimations(const char* fileName, int* animCou |
|
|
|
{ |
|
|
|
#define IQM_MAGIC "INTERQUAKEMODEL" // IQM file magic number |
|
|
|
#define IQM_VERSION 2 // only IQM version 2 supported |
|
|
|
|
|
|
|
|
|
|
|
unsigned int fileSize = 0; |
|
|
|
unsigned char *fileData = LoadFileData(fileName, &fileSize); |
|
|
|
unsigned char *fileDataPtr = fileData; |
|
|
|
|
|
|
|
|
|
|
|
typedef struct IQMHeader { |
|
|
|
char magic[16]; |
|
|
|
unsigned int version; |
|
|
|
@ -3321,60 +3321,60 @@ static ModelAnimation* LoadIQMModelAnimations(const char* fileName, int* animCou |
|
|
|
unsigned int num_comment, ofs_comment; |
|
|
|
unsigned int num_extensions, ofs_extensions; |
|
|
|
} IQMHeader; |
|
|
|
|
|
|
|
|
|
|
|
typedef struct IQMPose { |
|
|
|
int parent; |
|
|
|
unsigned int mask; |
|
|
|
float channeloffset[10]; |
|
|
|
float channelscale[10]; |
|
|
|
} IQMPose; |
|
|
|
|
|
|
|
|
|
|
|
typedef struct IQMAnim { |
|
|
|
unsigned int name; |
|
|
|
unsigned int first_frame, num_frames; |
|
|
|
float framerate; |
|
|
|
unsigned int flags; |
|
|
|
} IQMAnim; |
|
|
|
|
|
|
|
|
|
|
|
// In case file can not be read, return an empty model |
|
|
|
if (fileDataPtr == NULL) return NULL; |
|
|
|
|
|
|
|
|
|
|
|
// Read IQM header |
|
|
|
IQMHeader *iqmHeader = (IQMHeader *)fileDataPtr; |
|
|
|
|
|
|
|
|
|
|
|
if (memcmp(iqmHeader->magic, IQM_MAGIC, sizeof(IQM_MAGIC)) != 0) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "MODEL: [%s] IQM file is not a valid model", fileName); |
|
|
|
return NULL; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
if (iqmHeader->version != IQM_VERSION) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "MODEL: [%s] IQM file version not supported (%i)", fileName, iqmHeader->version); |
|
|
|
return NULL; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// Get bones data |
|
|
|
IQMPose *poses = RL_MALLOC(iqmHeader->num_poses*sizeof(IQMPose)); |
|
|
|
//fseek(iqmFile, iqmHeader->ofs_poses, SEEK_SET); |
|
|
|
//fread(poses, iqmHeader->num_poses*sizeof(IQMPose), 1, iqmFile); |
|
|
|
memcpy(poses, fileDataPtr + iqmHeader->ofs_poses, iqmHeader->num_poses*sizeof(IQMPose)); |
|
|
|
|
|
|
|
|
|
|
|
// Get animations data |
|
|
|
*animCount = iqmHeader->num_anims; |
|
|
|
IQMAnim *anim = RL_MALLOC(iqmHeader->num_anims*sizeof(IQMAnim)); |
|
|
|
//fseek(iqmFile, iqmHeader->ofs_anims, SEEK_SET); |
|
|
|
//fread(anim, iqmHeader->num_anims*sizeof(IQMAnim), 1, iqmFile); |
|
|
|
memcpy(anim, fileDataPtr + iqmHeader->ofs_anims, iqmHeader->num_anims*sizeof(IQMAnim)); |
|
|
|
|
|
|
|
|
|
|
|
ModelAnimation *animations = RL_MALLOC(iqmHeader->num_anims*sizeof(ModelAnimation)); |
|
|
|
|
|
|
|
|
|
|
|
// frameposes |
|
|
|
unsigned short *framedata = RL_MALLOC(iqmHeader->num_frames*iqmHeader->num_framechannels*sizeof(unsigned short)); |
|
|
|
//fseek(iqmFile, iqmHeader->ofs_frames, SEEK_SET); |
|
|
|
//fread(framedata, iqmHeader->num_frames*iqmHeader->num_framechannels*sizeof(unsigned short), 1, iqmFile); |
|
|
|
memcpy(framedata, fileDataPtr + iqmHeader->ofs_frames, iqmHeader->num_frames*iqmHeader->num_framechannels*sizeof(unsigned short)); |
|
|
|
|
|
|
|
|
|
|
|
for (unsigned int a = 0; a < iqmHeader->num_anims; a++) |
|
|
|
{ |
|
|
|
animations[a].frameCount = anim[a].num_frames; |
|
|
|
@ -3382,105 +3382,105 @@ static ModelAnimation* LoadIQMModelAnimations(const char* fileName, int* animCou |
|
|
|
animations[a].bones = RL_MALLOC(iqmHeader->num_poses*sizeof(BoneInfo)); |
|
|
|
animations[a].framePoses = RL_MALLOC(anim[a].num_frames*sizeof(Transform *)); |
|
|
|
// animations[a].framerate = anim.framerate; // TODO: Use framerate? |
|
|
|
|
|
|
|
|
|
|
|
for (unsigned int j = 0; j < iqmHeader->num_poses; j++) |
|
|
|
{ |
|
|
|
strcpy(animations[a].bones[j].name, "ANIMJOINTNAME"); |
|
|
|
animations[a].bones[j].parent = poses[j].parent; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
for (unsigned int j = 0; j < anim[a].num_frames; j++) animations[a].framePoses[j] = RL_MALLOC(iqmHeader->num_poses*sizeof(Transform)); |
|
|
|
|
|
|
|
|
|
|
|
int dcounter = anim[a].first_frame*iqmHeader->num_framechannels; |
|
|
|
|
|
|
|
|
|
|
|
for (unsigned int frame = 0; frame < anim[a].num_frames; frame++) |
|
|
|
{ |
|
|
|
for (unsigned int i = 0; i < iqmHeader->num_poses; i++) |
|
|
|
{ |
|
|
|
animations[a].framePoses[frame][i].translation.x = poses[i].channeloffset[0]; |
|
|
|
|
|
|
|
|
|
|
|
if (poses[i].mask & 0x01) |
|
|
|
{ |
|
|
|
animations[a].framePoses[frame][i].translation.x += framedata[dcounter]*poses[i].channelscale[0]; |
|
|
|
dcounter++; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
animations[a].framePoses[frame][i].translation.y = poses[i].channeloffset[1]; |
|
|
|
|
|
|
|
|
|
|
|
if (poses[i].mask & 0x02) |
|
|
|
{ |
|
|
|
animations[a].framePoses[frame][i].translation.y += framedata[dcounter]*poses[i].channelscale[1]; |
|
|
|
dcounter++; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
animations[a].framePoses[frame][i].translation.z = poses[i].channeloffset[2]; |
|
|
|
|
|
|
|
|
|
|
|
if (poses[i].mask & 0x04) |
|
|
|
{ |
|
|
|
animations[a].framePoses[frame][i].translation.z += framedata[dcounter]*poses[i].channelscale[2]; |
|
|
|
dcounter++; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
animations[a].framePoses[frame][i].rotation.x = poses[i].channeloffset[3]; |
|
|
|
|
|
|
|
|
|
|
|
if (poses[i].mask & 0x08) |
|
|
|
{ |
|
|
|
animations[a].framePoses[frame][i].rotation.x += framedata[dcounter]*poses[i].channelscale[3]; |
|
|
|
dcounter++; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
animations[a].framePoses[frame][i].rotation.y = poses[i].channeloffset[4]; |
|
|
|
|
|
|
|
|
|
|
|
if (poses[i].mask & 0x10) |
|
|
|
{ |
|
|
|
animations[a].framePoses[frame][i].rotation.y += framedata[dcounter]*poses[i].channelscale[4]; |
|
|
|
dcounter++; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
animations[a].framePoses[frame][i].rotation.z = poses[i].channeloffset[5]; |
|
|
|
|
|
|
|
|
|
|
|
if (poses[i].mask & 0x20) |
|
|
|
{ |
|
|
|
animations[a].framePoses[frame][i].rotation.z += framedata[dcounter]*poses[i].channelscale[5]; |
|
|
|
dcounter++; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
animations[a].framePoses[frame][i].rotation.w = poses[i].channeloffset[6]; |
|
|
|
|
|
|
|
|
|
|
|
if (poses[i].mask & 0x40) |
|
|
|
{ |
|
|
|
animations[a].framePoses[frame][i].rotation.w += framedata[dcounter]*poses[i].channelscale[6]; |
|
|
|
dcounter++; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
animations[a].framePoses[frame][i].scale.x = poses[i].channeloffset[7]; |
|
|
|
|
|
|
|
|
|
|
|
if (poses[i].mask & 0x80) |
|
|
|
{ |
|
|
|
animations[a].framePoses[frame][i].scale.x += framedata[dcounter]*poses[i].channelscale[7]; |
|
|
|
dcounter++; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
animations[a].framePoses[frame][i].scale.y = poses[i].channeloffset[8]; |
|
|
|
|
|
|
|
|
|
|
|
if (poses[i].mask & 0x100) |
|
|
|
{ |
|
|
|
animations[a].framePoses[frame][i].scale.y += framedata[dcounter]*poses[i].channelscale[8]; |
|
|
|
dcounter++; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
animations[a].framePoses[frame][i].scale.z = poses[i].channeloffset[9]; |
|
|
|
|
|
|
|
|
|
|
|
if (poses[i].mask & 0x200) |
|
|
|
{ |
|
|
|
animations[a].framePoses[frame][i].scale.z += framedata[dcounter]*poses[i].channelscale[9]; |
|
|
|
dcounter++; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
animations[a].framePoses[frame][i].rotation = QuaternionNormalize(animations[a].framePoses[frame][i].rotation); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// Build frameposes |
|
|
|
for (unsigned int frame = 0; frame < anim[a].num_frames; frame++) |
|
|
|
{ |
|
|
|
@ -3496,13 +3496,13 @@ static ModelAnimation* LoadIQMModelAnimations(const char* fileName, int* animCou |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
RL_FREE(fileData); |
|
|
|
|
|
|
|
|
|
|
|
RL_FREE(framedata); |
|
|
|
RL_FREE(poses); |
|
|
|
RL_FREE(anim); |
|
|
|
|
|
|
|
|
|
|
|
return animations; |
|
|
|
} |
|
|
|
|
|
|
|
@ -3667,17 +3667,17 @@ static bool GLTFReadValue(cgltf_accessor* acc, unsigned int index, void* variabl |
|
|
|
{ |
|
|
|
return false; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
memcpy(variable, index == 0 ? acc->min : acc->max, elements * size); |
|
|
|
return true; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
unsigned int stride = size * elements; |
|
|
|
memset(variable, 0, stride); |
|
|
|
|
|
|
|
|
|
|
|
if(acc->buffer_view == NULL || acc->buffer_view->buffer == NULL || acc->buffer_view->buffer->data == NULL) |
|
|
|
return false; |
|
|
|
|
|
|
|
|
|
|
|
void* readPosition = ((char*)acc->buffer_view->buffer->data) + (index * stride) + acc->buffer_view->offset + acc->offset; |
|
|
|
memcpy(variable, readPosition, stride); |
|
|
|
return true; |
|
|
|
@ -3740,10 +3740,10 @@ static Model LoadGLTF(const char *fileName) |
|
|
|
model.boneCount = (int)data->nodes_count; |
|
|
|
model.bones = RL_CALLOC(model.boneCount, sizeof(BoneInfo)); |
|
|
|
model.bindPose = RL_CALLOC(model.boneCount, sizeof(Transform)); |
|
|
|
|
|
|
|
|
|
|
|
InitGLTFBones(&model, data); |
|
|
|
LoadGLTFMaterial(&model, fileName, data); |
|
|
|
|
|
|
|
|
|
|
|
int primitiveIndex = 0; |
|
|
|
|
|
|
|
for (unsigned int i = 0; i < data->meshes_count; i++) |
|
|
|
@ -3759,7 +3759,7 @@ static Model LoadGLTF(const char *fileName) |
|
|
|
int bufferSize = model.meshes[primitiveIndex].vertexCount * 3 * sizeof(float); |
|
|
|
model.meshes[primitiveIndex].vertices = RL_MALLOC(bufferSize); |
|
|
|
model.meshes[primitiveIndex].animVertices = RL_MALLOC(bufferSize); |
|
|
|
|
|
|
|
|
|
|
|
if(acc->component_type == cgltf_component_type_r_32f) |
|
|
|
{ |
|
|
|
for(int a = 0; a < acc->count; a++) |
|
|
|
@ -3783,17 +3783,17 @@ static Model LoadGLTF(const char *fileName) |
|
|
|
// TODO: Support normalized unsigned byte/unsigned short vertices |
|
|
|
TRACELOG(LOG_WARNING, "MODEL: [%s] glTF vertices must be float or int", fileName); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
memcpy(model.meshes[primitiveIndex].animVertices, model.meshes[primitiveIndex].vertices, bufferSize); |
|
|
|
} |
|
|
|
else if (data->meshes[i].primitives[p].attributes[j].type == cgltf_attribute_type_normal) |
|
|
|
{ |
|
|
|
cgltf_accessor *acc = data->meshes[i].primitives[p].attributes[j].data; |
|
|
|
|
|
|
|
|
|
|
|
int bufferSize = (int)(acc->count*3*sizeof(float)); |
|
|
|
model.meshes[primitiveIndex].normals = RL_MALLOC(bufferSize); |
|
|
|
model.meshes[primitiveIndex].animNormals = RL_MALLOC(bufferSize); |
|
|
|
|
|
|
|
|
|
|
|
if(acc->component_type == cgltf_component_type_r_32f) |
|
|
|
{ |
|
|
|
for(int a = 0; a < acc->count; a++) |
|
|
|
@ -3817,7 +3817,7 @@ static Model LoadGLTF(const char *fileName) |
|
|
|
// TODO: Support normalized unsigned byte/unsigned short normals |
|
|
|
TRACELOG(LOG_WARNING, "MODEL: [%s] glTF normals must be float or int", fileName); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
memcpy(model.meshes[primitiveIndex].animNormals, model.meshes[primitiveIndex].normals, bufferSize); |
|
|
|
} |
|
|
|
else if (data->meshes[i].primitives[p].attributes[j].type == cgltf_attribute_type_texcoord) |
|
|
|
@ -3827,7 +3827,7 @@ static Model LoadGLTF(const char *fileName) |
|
|
|
if (acc->component_type == cgltf_component_type_r_32f) |
|
|
|
{ |
|
|
|
model.meshes[primitiveIndex].texcoords = RL_MALLOC(acc->count*2*sizeof(float)); |
|
|
|
|
|
|
|
|
|
|
|
for(int a = 0; a < acc->count; a++) |
|
|
|
{ |
|
|
|
GLTFReadValue(acc, a, model.meshes[primitiveIndex].texcoords + (a * 2), 2, sizeof(float)); |
|
|
|
@ -3847,9 +3847,9 @@ static Model LoadGLTF(const char *fileName) |
|
|
|
else if (data->meshes[i].primitives[p].attributes[j].type == cgltf_attribute_type_weights) |
|
|
|
{ |
|
|
|
cgltf_accessor *acc = data->meshes[i].primitives[p].attributes[j].data; |
|
|
|
|
|
|
|
|
|
|
|
model.meshes[primitiveIndex].boneWeights = RL_MALLOC(acc->count*4*sizeof(float)); |
|
|
|
|
|
|
|
|
|
|
|
if(acc->component_type == cgltf_component_type_r_32f) |
|
|
|
{ |
|
|
|
for(int a = 0; a < acc->count; a++) |
|
|
|
@ -3879,7 +3879,7 @@ static Model LoadGLTF(const char *fileName) |
|
|
|
|
|
|
|
cgltf_accessor *acc = data->meshes[i].primitives[p].indices; |
|
|
|
LoadGLTFModelIndices(&model, acc, primitiveIndex); |
|
|
|
|
|
|
|
|
|
|
|
if (data->meshes[i].primitives[p].material) |
|
|
|
{ |
|
|
|
// Compute the offset |
|
|
|
@ -3889,14 +3889,14 @@ static Model LoadGLTF(const char *fileName) |
|
|
|
{ |
|
|
|
model.meshMaterial[primitiveIndex] = model.materialCount - 1; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
BindGLTFPrimitiveToBones(&model, data, primitiveIndex); |
|
|
|
|
|
|
|
|
|
|
|
primitiveIndex++; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
cgltf_free(data); |
|
|
|
} |
|
|
|
else TRACELOG(LOG_WARNING, "MODEL: [%s] Failed to load glTF data", fileName); |
|
|
|
@ -3913,7 +3913,7 @@ static void InitGLTFBones(Model* model, const cgltf_data* data) |
|
|
|
strcpy(model->bones[j].name, data->nodes[j].name == 0 ? "ANIMJOINT" : data->nodes[j].name); |
|
|
|
model->bones[j].parent = (data->nodes[j].parent != NULL) ? data->nodes[j].parent - data->nodes : -1; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
for (unsigned int i = 0; i < data->nodes_count; i++) |
|
|
|
{ |
|
|
|
if (data->nodes[i].has_translation) memcpy(&model->bindPose[i].translation, data->nodes[i].translation, 3 * sizeof(float)); |
|
|
|
@ -3923,11 +3923,11 @@ static void InitGLTFBones(Model* model, const cgltf_data* data) |
|
|
|
else model->bindPose[i].rotation = QuaternionIdentity(); |
|
|
|
|
|
|
|
model->bindPose[i].rotation = QuaternionNormalize(model->bindPose[i].rotation); |
|
|
|
|
|
|
|
|
|
|
|
if (data->nodes[i].has_scale) memcpy(&model->bindPose[i].scale, data->nodes[i].scale, 3 * sizeof(float)); |
|
|
|
else model->bindPose[i].scale = Vector3One(); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
{ |
|
|
|
bool* completedBones = RL_CALLOC(model->boneCount, sizeof(bool)); |
|
|
|
int numberCompletedBones = 0; |
|
|
|
@ -4032,7 +4032,7 @@ static void LoadGLTFMaterial(Model* model, const char* fileName, const cgltf_dat |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
model->materials[model->materialCount - 1] = LoadMaterialDefault(); |
|
|
|
} |
|
|
|
|
|
|
|
@ -4047,7 +4047,7 @@ static void LoadGLTFBoneAttribute(Model* model, cgltf_accessor* jointsAccessor, |
|
|
|
{ |
|
|
|
GLTFReadValue(jointsAccessor, a, bones + (a * 4), 4, sizeof(short)); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
for (unsigned int a = 0; a < jointsAccessor->count * 4; a++) |
|
|
|
{ |
|
|
|
cgltf_node* skinJoint = data->skins->joints[bones[a]]; |
|
|
|
@ -4072,11 +4072,11 @@ static void LoadGLTFBoneAttribute(Model* model, cgltf_accessor* jointsAccessor, |
|
|
|
{ |
|
|
|
GLTFReadValue(jointsAccessor, a, bones + (a * 4), 4, sizeof(unsigned char)); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
for (unsigned int a = 0; a < jointsAccessor->count * 4; a++) |
|
|
|
{ |
|
|
|
cgltf_node* skinJoint = data->skins->joints[bones[a]]; |
|
|
|
|
|
|
|
|
|
|
|
for (unsigned int k = 0; k < data->nodes_count; k++) |
|
|
|
{ |
|
|
|
if (&(data->nodes[k]) == skinJoint) |
|
|
|
@ -4118,7 +4118,7 @@ static void BindGLTFPrimitiveToBones(Model* model, const cgltf_data* data, int p |
|
|
|
model->meshes[primitiveIndex].boneIds[b] = 0; |
|
|
|
model->meshes[primitiveIndex].boneWeights[b] = 0.0f; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
Vector3 boundVertex = { 0 }; |
|
|
|
@ -4157,7 +4157,7 @@ static void BindGLTFPrimitiveToBones(Model* model, const cgltf_data* data, int p |
|
|
|
model->meshes[primitiveIndex].normals[vCounter + 1] = boundNormal.y; |
|
|
|
model->meshes[primitiveIndex].normals[vCounter + 2] = boundNormal.z; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
vCounter += 3; |
|
|
|
boneCounter += 4; |
|
|
|
} |
|
|
|
@ -4174,7 +4174,7 @@ static void LoadGLTFModelIndices(Model* model, cgltf_accessor* indexAccessor, in |
|
|
|
{ |
|
|
|
model->meshes[primitiveIndex].triangleCount = (int)indexAccessor->count / 3; |
|
|
|
model->meshes[primitiveIndex].indices = RL_MALLOC(model->meshes[primitiveIndex].triangleCount * 3 * sizeof(unsigned short)); |
|
|
|
|
|
|
|
|
|
|
|
unsigned short readValue = 0; |
|
|
|
for(int a = 0; a < indexAccessor->count; a++) |
|
|
|
{ |
|
|
|
@ -4186,7 +4186,7 @@ static void LoadGLTFModelIndices(Model* model, cgltf_accessor* indexAccessor, in |
|
|
|
{ |
|
|
|
model->meshes[primitiveIndex].triangleCount = (int)indexAccessor->count / 3; |
|
|
|
model->meshes[primitiveIndex].indices = RL_MALLOC(model->meshes[primitiveIndex].triangleCount * 3 * sizeof(unsigned short)); |
|
|
|
|
|
|
|
|
|
|
|
unsigned char readValue = 0; |
|
|
|
for(int a = 0; a < indexAccessor->count; a++) |
|
|
|
{ |
|
|
|
@ -4232,16 +4232,16 @@ static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCo |
|
|
|
// glTF file loading |
|
|
|
unsigned int dataSize = 0; |
|
|
|
unsigned char *fileData = LoadFileData(fileName, &dataSize); |
|
|
|
|
|
|
|
|
|
|
|
ModelAnimation *animations = NULL; |
|
|
|
|
|
|
|
|
|
|
|
if (fileData == NULL) return animations; |
|
|
|
|
|
|
|
|
|
|
|
// glTF data loading |
|
|
|
cgltf_options options = { 0 }; |
|
|
|
cgltf_data *data = NULL; |
|
|
|
cgltf_result result = cgltf_parse(&options, fileData, dataSize, &data); |
|
|
|
|
|
|
|
|
|
|
|
if (result == cgltf_result_success) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_INFO, "MODEL: [%s] glTF animations (%s) count: %i", fileName, (data->file_type == 2)? "glb" : |
|
|
|
@ -4263,34 +4263,34 @@ static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCo |
|
|
|
// - input - points in time this transformation happens |
|
|
|
// - output - the transformation amount at the given input points in time |
|
|
|
// - interpolation - the type of interpolation to use between the frames |
|
|
|
|
|
|
|
|
|
|
|
cgltf_animation *animation = data->animations + a; |
|
|
|
|
|
|
|
|
|
|
|
ModelAnimation *output = animations + a; |
|
|
|
|
|
|
|
|
|
|
|
// 30 frames sampled per second |
|
|
|
const float TIMESTEP = (1.0f / 30.0f); |
|
|
|
float animationDuration = 0.0f; |
|
|
|
|
|
|
|
|
|
|
|
// Getting the max animation time to consider for animation duration |
|
|
|
for (unsigned int i = 0; i < animation->channels_count; i++) |
|
|
|
{ |
|
|
|
cgltf_animation_channel* channel = animation->channels + i; |
|
|
|
int frameCounts = (int)channel->sampler->input->count; |
|
|
|
float lastFrameTime = 0.0f; |
|
|
|
|
|
|
|
|
|
|
|
if (GLTFReadValue(channel->sampler->input, frameCounts - 1, &lastFrameTime, 1, sizeof(float))) |
|
|
|
{ |
|
|
|
animationDuration = fmaxf(lastFrameTime, animationDuration); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
output->frameCount = (int)(animationDuration / TIMESTEP); |
|
|
|
output->boneCount = (int)data->nodes_count; |
|
|
|
output->bones = RL_MALLOC(output->boneCount*sizeof(BoneInfo)); |
|
|
|
output->framePoses = RL_MALLOC(output->frameCount*sizeof(Transform *)); |
|
|
|
// output->framerate = // TODO: Use framerate instead of const timestep |
|
|
|
|
|
|
|
|
|
|
|
// Name and parent bones |
|
|
|
for (unsigned int j = 0; j < data->nodes_count; j++) |
|
|
|
{ |
|
|
|
@ -4303,7 +4303,7 @@ static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCo |
|
|
|
for (int frame = 0; frame < output->frameCount; frame++) |
|
|
|
{ |
|
|
|
output->framePoses[frame] = RL_MALLOC(output->frameCount*data->nodes_count*sizeof(Transform)); |
|
|
|
|
|
|
|
|
|
|
|
for (unsigned int i = 0; i < data->nodes_count; i++) |
|
|
|
{ |
|
|
|
output->framePoses[frame][i].translation = Vector3Zero(); |
|
|
|
@ -4312,15 +4312,15 @@ static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCo |
|
|
|
output->framePoses[frame][i].scale = Vector3One(); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// for each single transformation type on single bone |
|
|
|
for (unsigned int channelId = 0; channelId < animation->channels_count; channelId++) |
|
|
|
{ |
|
|
|
cgltf_animation_channel* channel = animation->channels + channelId; |
|
|
|
cgltf_animation_sampler* sampler = channel->sampler; |
|
|
|
|
|
|
|
|
|
|
|
int boneId = (int)(channel->target_node - data->nodes); |
|
|
|
|
|
|
|
|
|
|
|
for (int frame = 0; frame < output->frameCount; frame++) |
|
|
|
{ |
|
|
|
bool shouldSkipFurtherTransformation = true; |
|
|
|
@ -4328,7 +4328,7 @@ static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCo |
|
|
|
int outputMax = 0; |
|
|
|
float frameTime = frame * TIMESTEP; |
|
|
|
float lerpPercent = 0.0f; |
|
|
|
|
|
|
|
|
|
|
|
// For this transformation: |
|
|
|
// getting between which input values the current frame time position |
|
|
|
// and also what is the percent to use in the linear interpolation later |
|
|
|
@ -4342,7 +4342,7 @@ static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCo |
|
|
|
shouldSkipFurtherTransformation = false; |
|
|
|
outputMin = (j == 0) ? 0 : j - 1; |
|
|
|
outputMax = j; |
|
|
|
|
|
|
|
|
|
|
|
float previousInputTime = 0.0f; |
|
|
|
if (GLTFReadValue(sampler->input, outputMin, &previousInputTime, 1, sizeof(float))) |
|
|
|
{ |
|
|
|
@ -4351,13 +4351,13 @@ static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCo |
|
|
|
lerpPercent = (frameTime - previousInputTime)/(inputFrameTime - previousInputTime); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
else break; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// If the current transformation has no information for the current frame time point |
|
|
|
if (shouldSkipFurtherTransformation) continue; |
|
|
|
|
|
|
|
@ -4365,20 +4365,20 @@ static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCo |
|
|
|
{ |
|
|
|
Vector3 translationStart; |
|
|
|
Vector3 translationEnd; |
|
|
|
|
|
|
|
|
|
|
|
bool success = GLTFReadValue(sampler->output, outputMin, &translationStart, 3, sizeof(float)); |
|
|
|
success = GLTFReadValue(sampler->output, outputMax, &translationEnd, 3, sizeof(float)) || success; |
|
|
|
|
|
|
|
|
|
|
|
if (success) output->framePoses[frame][boneId].translation = Vector3Lerp(translationStart, translationEnd, lerpPercent); |
|
|
|
} |
|
|
|
if (channel->target_path == cgltf_animation_path_type_rotation) |
|
|
|
{ |
|
|
|
Quaternion rotationStart; |
|
|
|
Quaternion rotationEnd; |
|
|
|
|
|
|
|
|
|
|
|
bool success = GLTFReadValue(sampler->output, outputMin, &rotationStart, 4, sizeof(float)); |
|
|
|
success = GLTFReadValue(sampler->output, outputMax, &rotationEnd, 4, sizeof(float)) || success; |
|
|
|
|
|
|
|
|
|
|
|
if (success) |
|
|
|
{ |
|
|
|
output->framePoses[frame][boneId].rotation = QuaternionLerp(rotationStart, rotationEnd, lerpPercent); |
|
|
|
@ -4389,15 +4389,15 @@ static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCo |
|
|
|
{ |
|
|
|
Vector3 scaleStart; |
|
|
|
Vector3 scaleEnd; |
|
|
|
|
|
|
|
|
|
|
|
bool success = GLTFReadValue(sampler->output, outputMin, &scaleStart, 3, sizeof(float)); |
|
|
|
success = GLTFReadValue(sampler->output, outputMax, &scaleEnd, 3, sizeof(float)) || success; |
|
|
|
|
|
|
|
|
|
|
|
if (success) output->framePoses[frame][boneId].scale = Vector3Lerp(scaleStart, scaleEnd, lerpPercent); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// Build frameposes |
|
|
|
for (int frame = 0; frame < output->frameCount; frame++) |
|
|
|
{ |
|
|
|
@ -4432,13 +4432,13 @@ static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCo |
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
cgltf_free(data); |
|
|
|
} |
|
|
|
else TRACELOG(LOG_WARNING, ": [%s] Failed to load glTF data", fileName); |
|
|
|
|
|
|
|
|
|
|
|
RL_FREE(fileData); |
|
|
|
|
|
|
|
|
|
|
|
return animations; |
|
|
|
} |
|
|
|
|
|
|
|
|
Ray
4 years ago