mirrors/raylib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Reviewed AnimatedModel struct

Browse Source 
Just reviewing for a possible adaptation of AnimatedModel to default raylib Model...
This commit is contained in:
Ray 2018-08-07 11:31:32 +02:00
parent b042fe12e6
commit 06be400ca3
1 changed files with 60 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
examples/others/iqm_loader/riqm.h
View File

@ -64,29 +64,32 @@ typedef struct Pose {
} Pose; } Pose;
typedef struct Animation { typedef struct Animation {
int jointCount; int jointCount; // Number of joints (bones)
Joint *joints; // NOTE: Joints in anims do not have names Joint *joints; // Joints array
// NOTE: Joints in anims do not have names
int frameCount; int frameCount; // Number of animation frames
float framerate; float framerate; // Frame change speed
Pose **framepose; Pose **framepose; // Poses array by frame (and one pose by joint)
} Animation; } Animation;
// Animated Model type // Animated Model type
typedef struct AnimatedModel { typedef struct AnimatedModel {
int meshCount; Matrix transform; // Local transform matrix
Mesh *mesh;
int materialCount; int meshCount; // Number of meshes
int *meshMaterialId; Mesh *meshes; // Meshes array
Material *materials;
int jointCount; int materialCount; // Number of materials
Joint *joints; Material *materials; // Materials array
Pose *basepose; int *meshMaterialId; // Mesh materials ids
Matrix transform;
// Animation required data
int jointCount; // Number of joints (and keyposes)
Joint *joints; // Mesh joints (bones)
Pose *basepose; // Mesh base-poses by joint
} AnimatedModel; } AnimatedModel;
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -233,7 +236,7 @@ AnimatedModel LoadAnimatedModel(const char *filename)
{ {
AnimatedModel out = LoadIQM(filename); AnimatedModel out = LoadIQM(filename);
for (int i = 0; i < out.meshCount; i++) rlLoadMesh(&out.mesh[i], false); for (int i = 0; i < out.meshCount; i++) rlLoadMesh(&out.meshes[i], false);
out.transform = MatrixIdentity(); out.transform = MatrixIdentity();
out.meshMaterialId = malloc(sizeof(int)*out.meshCount); out.meshMaterialId = malloc(sizeof(int)*out.meshCount);
@ -258,7 +261,7 @@ AnimatedModel AnimatedModelAddTexture(AnimatedModel model, const char *filename)
return model; return model;
} }
// Set the material for a mesh // Set the material for a meshes
AnimatedModel SetMeshMaterial(AnimatedModel model, int meshid, int textureid) AnimatedModel SetMeshMaterial(AnimatedModel model, int meshid, int textureid)
{ {
if (meshid > model.meshCount) if (meshid > model.meshCount)
@ -466,9 +469,9 @@ void UnloadAnimatedModel(AnimatedModel model)
free(model.joints); free(model.joints);
free(model.basepose); free(model.basepose);
for (int i = 0; i < model.meshCount; i++) rlUnloadMesh(&model.mesh[i]); for (int i = 0; i < model.meshCount; i++) rlUnloadMesh(&model.meshes[i]);
free(model.mesh); free(model.meshes);
} }
// Unload animation // Unload animation
@ -515,9 +518,9 @@ void AnimateModel(AnimatedModel model, Animation anim, int frame)
int wcounter = 0; int wcounter = 0;
int weightId = 0; int weightId = 0;
for (int i = 0; i < model.mesh[m].vertexCount; i++) for (int i = 0; i < model.meshes[m].vertexCount; i++)
{ {
weightId = model.mesh[m].weightId[wcounter]; weightId = model.meshes[m].weightId[wcounter];
baset = model.basepose[weightId].translation; baset = model.basepose[weightId].translation;
baser = model.basepose[weightId].rotation; baser = model.basepose[weightId].rotation;
bases = model.basepose[weightId].scale; bases = model.basepose[weightId].scale;
@ -526,23 +529,23 @@ void AnimateModel(AnimatedModel model, Animation anim, int frame)
outs = anim.framepose[frame][weightId].scale; outs = anim.framepose[frame][weightId].scale;
// vertices // vertices
// NOTE: We use mesh.baseVertices (default position) to calculate mesh.vertices (animated position) // NOTE: We use meshes.baseVertices (default position) to calculate meshes.vertices (animated position)
outv = (Vector3){ model.mesh[m].baseVertices[vcounter], model.mesh[m].baseVertices[vcounter + 1], model.mesh[m].baseVertices[vcounter + 2] }; outv = (Vector3){ model.meshes[m].baseVertices[vcounter], model.meshes[m].baseVertices[vcounter + 1], model.meshes[m].baseVertices[vcounter + 2] };
outv = Vector3MultiplyV(outv, outs); outv = Vector3MultiplyV(outv, outs);
outv = Vector3Subtract(outv, baset); outv = Vector3Subtract(outv, baset);
outv = Vector3RotateByQuaternion(outv, QuaternionMultiply(outr, QuaternionInvert(baser))); outv = Vector3RotateByQuaternion(outv, QuaternionMultiply(outr, QuaternionInvert(baser)));
outv = Vector3Add(outv, outt); outv = Vector3Add(outv, outt);
model.mesh[m].vertices[vcounter] = outv.x; model.meshes[m].vertices[vcounter] = outv.x;
model.mesh[m].vertices[vcounter + 1] = outv.y; model.meshes[m].vertices[vcounter + 1] = outv.y;
model.mesh[m].vertices[vcounter + 2] = outv.z; model.meshes[m].vertices[vcounter + 2] = outv.z;
// normals // normals
// NOTE: We use mesh.baseNormals (default normal) to calculate mesh.normals (animated normals) // NOTE: We use meshes.baseNormals (default normal) to calculate meshes.normals (animated normals)
outn = (Vector3){ model.mesh[m].baseNormals[vcounter], model.mesh[m].baseNormals[vcounter + 1], model.mesh[m].baseNormals[vcounter + 2] }; outn = (Vector3){ model.meshes[m].baseNormals[vcounter], model.meshes[m].baseNormals[vcounter + 1], model.meshes[m].baseNormals[vcounter + 2] };
outn = Vector3RotateByQuaternion(outn, QuaternionMultiply(outr, QuaternionInvert(baser))); outn = Vector3RotateByQuaternion(outn, QuaternionMultiply(outr, QuaternionInvert(baser)));
model.mesh[m].normals[vcounter] = outn.x; model.meshes[m].normals[vcounter] = outn.x;
model.mesh[m].normals[vcounter + 1] = outn.y; model.meshes[m].normals[vcounter + 1] = outn.y;
model.mesh[m].normals[vcounter + 2] = outn.z; model.meshes[m].normals[vcounter + 2] = outn.z;
vcounter += 3; vcounter += 3;
wcounter += 4; wcounter += 4;
} }
@ -563,7 +566,7 @@ void DrawAnimatedModelEx(AnimatedModel model, Vector3 position, Vector3 rotation
{ {
if (model.materialCount == 0) if (model.materialCount == 0)
{ {
TraceLog(LOG_WARNING,"No materials set, can't draw animated mesh\n"); TraceLog(LOG_WARNING,"No materials set, can't draw animated meshes\n");
return; return;
} }
@ -576,9 +579,9 @@ void DrawAnimatedModelEx(AnimatedModel model, Vector3 position, Vector3 rotation
for (int i = 0; i < model.meshCount; i++) for (int i = 0; i < model.meshCount; i++)
{ {
rlUpdateMesh(model.mesh[i], 0, model.mesh[i].vertexCount); // Update vertex position rlUpdateMesh(model.meshes[i], 0, model.meshes[i].vertexCount); // Update vertex position
rlUpdateMesh(model.mesh[i], 2, model.mesh[i].vertexCount); // Update vertex normals rlUpdateMesh(model.meshes[i], 2, model.meshes[i].vertexCount); // Update vertex normals
rlDrawMesh(model.mesh[i], model.materials[model.meshMaterialId[i]], model.transform); // Draw mesh rlDrawMesh(model.meshes[i], model.materials[model.meshMaterialId[i]], model.transform); // Draw meshes
} }
} }
@ -632,7 +635,7 @@ static AnimatedModel LoadIQM(const char *filename)
fread(imesh, sizeof(IQMMesh)*iqm.num_meshes, 1, iqmFile); fread(imesh, sizeof(IQMMesh)*iqm.num_meshes, 1, iqmFile);
model.meshCount = iqm.num_meshes; model.meshCount = iqm.num_meshes;
model.mesh = malloc(sizeof(Mesh)*iqm.num_meshes); model.meshes = malloc(sizeof(Mesh)*iqm.num_meshes);
char name[MESH_NAME_LENGTH]; char name[MESH_NAME_LENGTH];
@ -640,21 +643,21 @@ static AnimatedModel LoadIQM(const char *filename)
{ {
fseek(iqmFile,iqm.ofs_text+imesh[i].name,SEEK_SET); fseek(iqmFile,iqm.ofs_text+imesh[i].name,SEEK_SET);
fread(name, sizeof(char)*MESH_NAME_LENGTH, 1, iqmFile); // Mesh name not used... fread(name, sizeof(char)*MESH_NAME_LENGTH, 1, iqmFile); // Mesh name not used...
model.mesh[i].vertexCount = imesh[i].num_vertexes; model.meshes[i].vertexCount = imesh[i].num_vertexes;
model.mesh[i].baseVertices = malloc(sizeof(float)*imesh[i].num_vertexes*3); // Default IQM base position model.meshes[i].baseVertices = malloc(sizeof(float)*imesh[i].num_vertexes*3); // Default IQM base position
model.mesh[i].baseNormals = malloc(sizeof(float)*imesh[i].num_vertexes*3); // Default IQM base normal model.meshes[i].baseNormals = malloc(sizeof(float)*imesh[i].num_vertexes*3); // Default IQM base normal
model.mesh[i].texcoords = malloc(sizeof(float)*imesh[i].num_vertexes*2); model.meshes[i].texcoords = malloc(sizeof(float)*imesh[i].num_vertexes*2);
model.mesh[i].weightId = malloc(sizeof(int)*imesh[i].num_vertexes*4); model.meshes[i].weightId = malloc(sizeof(int)*imesh[i].num_vertexes*4);
model.mesh[i].weightBias = malloc(sizeof(float)*imesh[i].num_vertexes*4); model.meshes[i].weightBias = malloc(sizeof(float)*imesh[i].num_vertexes*4);
model.mesh[i].triangleCount = imesh[i].num_triangles; model.meshes[i].triangleCount = imesh[i].num_triangles;
model.mesh[i].indices = malloc(sizeof(unsigned short)*imesh[i].num_triangles*3); model.meshes[i].indices = malloc(sizeof(unsigned short)*imesh[i].num_triangles*3);
// What we actually process for rendering, should be updated transforming mesh.vertices and mesh.normals // What we actually process for rendering, should be updated transforming meshes.vertices and meshes.normals
model.mesh[i].vertices = malloc(sizeof(float)*imesh[i].num_vertexes*3); model.meshes[i].vertices = malloc(sizeof(float)*imesh[i].num_vertexes*3);
model.mesh[i].normals = malloc(sizeof(float)*imesh[i].num_vertexes*3); model.meshes[i].normals = malloc(sizeof(float)*imesh[i].num_vertexes*3);
} }
// tris // tris
@ -669,9 +672,9 @@ static AnimatedModel LoadIQM(const char *filename)
for (int i = imesh[m].first_triangle; i < imesh[m].first_triangle+imesh[m].num_triangles; i++) for (int i = imesh[m].first_triangle; i < imesh[m].first_triangle+imesh[m].num_triangles; i++)
{ {
// IQM triangles are stored counter clockwise, but raylib sets opengl to clockwise drawing, so we swap them around // IQM triangles are stored counter clockwise, but raylib sets opengl to clockwise drawing, so we swap them around
model.mesh[m].indices[tcounter+2] = tri[i].vertex[0] - imesh[m].first_vertex; model.meshes[m].indices[tcounter+2] = tri[i].vertex[0] - imesh[m].first_vertex;
model.mesh[m].indices[tcounter+1] = tri[i].vertex[1] - imesh[m].first_vertex; model.meshes[m].indices[tcounter+1] = tri[i].vertex[1] - imesh[m].first_vertex;
model.mesh[m].indices[tcounter] = tri[i].vertex[2] - imesh[m].first_vertex; model.meshes[m].indices[tcounter] = tri[i].vertex[2] - imesh[m].first_vertex;
tcounter += 3; tcounter += 3;
} }
} }
@ -696,8 +699,8 @@ static AnimatedModel LoadIQM(const char *filename)
int vcounter = 0; int vcounter = 0;
for (int i = imesh[m].first_vertex*3; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*3; i++) for (int i = imesh[m].first_vertex*3; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*3; i++)
{ {
model.mesh[m].vertices[vcounter] = vertex[i]; model.meshes[m].vertices[vcounter] = vertex[i];
model.mesh[m].baseVertices[vcounter] = vertex[i]; model.meshes[m].baseVertices[vcounter] = vertex[i];
vcounter++; vcounter++;
} }
} }
@ -713,8 +716,8 @@ static AnimatedModel LoadIQM(const char *filename)
int vcounter = 0; int vcounter = 0;
for (int i = imesh[m].first_vertex*3; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*3; i++) for (int i = imesh[m].first_vertex*3; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*3; i++)
{ {
model.mesh[m].normals[vcounter] = normal[i]; model.meshes[m].normals[vcounter] = normal[i];
model.mesh[m].baseNormals[vcounter] = normal[i]; model.meshes[m].baseNormals[vcounter] = normal[i];
vcounter++; vcounter++;
} }
} }
@ -730,7 +733,7 @@ static AnimatedModel LoadIQM(const char *filename)
int vcounter = 0; int vcounter = 0;
for (int i = imesh[m].first_vertex*2; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*2; i++) for (int i = imesh[m].first_vertex*2; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*2; i++)
{ {
model.mesh[m].texcoords[vcounter] = text[i]; model.meshes[m].texcoords[vcounter] = text[i];
vcounter++; vcounter++;
} }
} }
@ -746,7 +749,7 @@ static AnimatedModel LoadIQM(const char *filename)
int vcounter = 0; int vcounter = 0;
for (int i = imesh[m].first_vertex*4; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*4; i++) for (int i = imesh[m].first_vertex*4; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*4; i++)
{ {
model.mesh[m].weightId[vcounter] = blendi[i]; model.meshes[m].weightId[vcounter] = blendi[i];
vcounter++; vcounter++;
} }
} }
@ -762,7 +765,7 @@ static AnimatedModel LoadIQM(const char *filename)
int vcounter = 0; int vcounter = 0;
for (int i = imesh[m].first_vertex*4; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*4; i++) for (int i = imesh[m].first_vertex*4; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*4; i++)
{ {
model.mesh[m].weightBias[vcounter] = blendw[i]/255.0f; model.meshes[m].weightBias[vcounter] = blendw[i]/255.0f;
vcounter++; vcounter++;
} }
} }