1260 lines
46 KiB
C
1260 lines
46 KiB
C
/**********************************************************************************************
|
|
*
|
|
* riqm - InterQuake Model format (IQM) loader for animated meshes
|
|
*
|
|
* CONFIGURATION:
|
|
*
|
|
* #define RIQM_IMPLEMENTATION
|
|
* Generates the implementation of the library into the included file.
|
|
* If not defined, the library is in header only mode and can be included in other headers
|
|
* or source files without problems. But only ONE file should hold the implementation.
|
|
*
|
|
*
|
|
* LICENSE: zlib/libpng
|
|
*
|
|
* Copyright (c) 2018 Jonas Daeyaert (@culacant) and Ramon Santamaria (@raysan5)
|
|
*
|
|
* This software is provided "as-is", without any express or implied warranty. In no event
|
|
* will the authors be held liable for any damages arising from the use of this software.
|
|
*
|
|
* Permission is granted to anyone to use this software for any purpose, including commercial
|
|
* applications, and to alter it and redistribute it freely, subject to the following restrictions:
|
|
*
|
|
* 1. The origin of this software must not be misrepresented; you must not claim that you
|
|
* wrote the original software. If you use this software in a product, an acknowledgment
|
|
* in the product documentation would be appreciated but is not required.
|
|
*
|
|
* 2. Altered source versions must be plainly marked as such, and must not be misrepresented
|
|
* as being the original software.
|
|
*
|
|
* 3. This notice may not be removed or altered from any source distribution.
|
|
*
|
|
**********************************************************************************************/
|
|
|
|
#ifndef RIQM_H
|
|
#define RIQM_H
|
|
|
|
// TODO dont break everything
|
|
static bool vaoSupported = false;
|
|
static Matrix modelview;
|
|
static Matrix projection;
|
|
|
|
#include <stdio.h> // Required for: FILE
|
|
|
|
//#define RIQM_STATIC
|
|
#ifdef RIQM_STATIC
|
|
#define RIQMDEF static // Functions just visible to module including this file
|
|
#else
|
|
#ifdef __cplusplus
|
|
#define RIQMDEF extern "C" // Functions visible from other files (no name mangling of functions in C++)
|
|
#else
|
|
#define RIQMDEF extern // Functions visible from other files
|
|
#endif
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Types and Structures Definition
|
|
//----------------------------------------------------------------------------------
|
|
|
|
#define JOINT_NAME_LENGTH 32 // Joint name string length
|
|
#define MESH_NAME_LENGTH 32 // Mesh name string length
|
|
|
|
typedef struct Joint {
|
|
char name[JOINT_NAME_LENGTH];
|
|
int parent;
|
|
} Joint;
|
|
|
|
typedef struct Pose {
|
|
Vector3 translation;
|
|
Quaternion rotation;
|
|
Vector3 scale;
|
|
} Pose;
|
|
|
|
typedef struct Animation {
|
|
int jointCount;
|
|
Joint *joints; // NOTE: Joints in anims do not have names
|
|
|
|
int frameCount;
|
|
float framerate;
|
|
|
|
Pose **framepose;
|
|
} Animation;
|
|
|
|
typedef struct AnimatedMesh {
|
|
char name[MESH_NAME_LENGTH];
|
|
|
|
int vertexCount;
|
|
int triangleCount;
|
|
|
|
float *vertices;
|
|
float *normals;
|
|
float *texcoords;
|
|
float *animVertices;
|
|
float *animNormals;
|
|
unsigned short *triangles;
|
|
|
|
int *weightId;
|
|
float *weightBias;
|
|
|
|
unsigned int vaoId;
|
|
unsigned int vboId[7];
|
|
} AnimatedMesh;
|
|
|
|
typedef struct AnimatedModel {
|
|
int meshCount;
|
|
AnimatedMesh *mesh;
|
|
|
|
int materialCount;
|
|
int *meshMaterialId;
|
|
Material *materials;
|
|
|
|
int jointCount;
|
|
Joint *joints;
|
|
|
|
Pose *basepose;
|
|
Matrix transform;
|
|
} AnimatedModel;
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Module Functions Declaration
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Loading/Unloading functions
|
|
RIQMDEF AnimatedModel LoadAnimatedModel(const char *filename);
|
|
RIQMDEF void UnloadAnimatedModel(AnimatedModel model);
|
|
RIQMDEF Animation LoadAnimation(const char *filename);
|
|
RIQMDEF void UnloadAnimation(Animation anim);
|
|
|
|
RIQMDEF AnimatedModel AnimatedModelAddTexture(AnimatedModel model,const char *filename); // GENERIC!
|
|
RIQMDEF AnimatedModel SetMeshMaterial(AnimatedModel model,int meshid, int textureid); // GENERIC!
|
|
|
|
|
|
// Usage functionality
|
|
RIQMDEF bool CheckSkeletonsMatch(AnimatedModel model, Animation anim);
|
|
RIQMDEF void AnimateModel(AnimatedModel model, Animation anim, int frame);
|
|
RIQMDEF void DrawAnimatedModel(AnimatedModel model,Vector3 position,float scale,Color tint);
|
|
RIQMDEF void DrawAnimatedModelEx(AnimatedModel model,Vector3 position,Vector3 rotationAxis,float rotationAngle, Vector3 scale,Color tint);
|
|
|
|
#endif // RIQM_H
|
|
|
|
|
|
/***********************************************************************************
|
|
*
|
|
* RIQM IMPLEMENTATION
|
|
*
|
|
************************************************************************************/
|
|
|
|
#if defined(RIQM_IMPLEMENTATION)
|
|
|
|
//#include "utils.h" // Required for: fopen() Android mapping
|
|
|
|
#include <stdio.h> // Required for: FILE, fopen(), fclose(), feof(), fseek(), fread()
|
|
#include <stdlib.h> // Required for: malloc(), free()
|
|
#include <string.h> // Required for: strncmp(),strcpy()
|
|
|
|
#include "raymath.h" // Required for: Vector3, Quaternion functions
|
|
#include "rlgl.h" // raylib OpenGL abstraction layer to OpenGL 1.1, 2.1, 3.3+ or ES2
|
|
|
|
#include "glad.h"
|
|
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Defines and Macros
|
|
//----------------------------------------------------------------------------------
|
|
#define IQM_MAGIC "INTERQUAKEMODEL" // IQM file magic number
|
|
#define IQM_VERSION 2 // only IQM version 2 supported
|
|
#define ANIMJOINTNAME "ANIMJOINT" // default joint name (used in Animation)
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Types and Structures Definition
|
|
//----------------------------------------------------------------------------------
|
|
// iqm file structs
|
|
typedef struct IQMHeader {
|
|
char magic[16];
|
|
unsigned int version;
|
|
unsigned int filesize;
|
|
unsigned int flags;
|
|
unsigned int num_text, ofs_text;
|
|
unsigned int num_meshes, ofs_meshes;
|
|
unsigned int num_vertexarrays, num_vertexes, ofs_vertexarrays;
|
|
unsigned int num_triangles, ofs_triangles, ofs_adjacency;
|
|
unsigned int num_joints, ofs_joints;
|
|
unsigned int num_poses, ofs_poses;
|
|
unsigned int num_anims, ofs_anims;
|
|
unsigned int num_frames, num_framechannels, ofs_frames, ofs_bounds;
|
|
unsigned int num_comment, ofs_comment;
|
|
unsigned int num_extensions, ofs_extensions;
|
|
} IQMHeader;
|
|
|
|
typedef struct IQMMesh {
|
|
unsigned int name;
|
|
unsigned int material;
|
|
unsigned int first_vertex, num_vertexes;
|
|
unsigned int first_triangle, num_triangles;
|
|
} IQMMesh;
|
|
|
|
typedef enum {
|
|
IQM_POSITION = 0,
|
|
IQM_TEXCOORD = 1,
|
|
IQM_NORMAL = 2,
|
|
IQM_TANGENT = 3, // tangents unused by default
|
|
IQM_BLENDINDEXES = 4,
|
|
IQM_BLENDWEIGHTS = 5,
|
|
IQM_COLOR = 6, // vertex colors unused by default
|
|
IQM_CUSTOM = 0x10 // custom vertex values unused by default
|
|
} IQMVertexType;
|
|
|
|
typedef struct IQMTriangle {
|
|
unsigned int vertex[3];
|
|
} IQMTriangle;
|
|
|
|
typedef struct IQMAdjacency { // adjacency unused by default
|
|
unsigned int triangle[3];
|
|
} IQMAdjacency;
|
|
|
|
typedef struct IQMJoint {
|
|
unsigned int name;
|
|
int parent;
|
|
float translate[3], rotate[4], scale[3];
|
|
} IQMJoint;
|
|
|
|
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;
|
|
|
|
typedef struct IQMVertexArray {
|
|
unsigned int type;
|
|
unsigned int flags;
|
|
unsigned int format;
|
|
unsigned int size;
|
|
unsigned int offset;
|
|
} IQMVertexArray;
|
|
|
|
typedef struct IQMBounds { // bounds unused by default
|
|
float bbmin[3], bbmax[3];
|
|
float xyradius, radius;
|
|
} IQMBounds;
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Global Variables Definition
|
|
//----------------------------------------------------------------------------------
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Module specific Functions Declaration
|
|
//----------------------------------------------------------------------------------
|
|
void rlLoadAnimatedMesh(AnimatedMesh *amesh, bool dynamic);
|
|
void rlUnloadAnimatedMesh(AnimatedMesh *amesh);
|
|
void rlUpdateAnimatedMesh(AnimatedMesh *amesh);
|
|
void rlDrawAnimatedMesh(AnimatedMesh amesh, Material material, Matrix transform);
|
|
|
|
static AnimatedModel LoadIQM(const char *filename);
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Module Functions Definition
|
|
//----------------------------------------------------------------------------------
|
|
void rlLoadAnimatedMesh(AnimatedMesh *amesh, bool dynamic)
|
|
{
|
|
amesh->vaoId = 0; // Vertex Array Object
|
|
amesh->vboId[0] = 0; // Vertex positions VBO << these are the animated vertices in animVertices
|
|
amesh->vboId[1] = 0; // Vertex texcoords VBO
|
|
amesh->vboId[2] = 0; // Vertex normals VBO << these are the animated normals in animNormals
|
|
amesh->vboId[3] = 0; // Vertex colors VBO
|
|
amesh->vboId[4] = 0; // Vertex tangents VBO UNUSED
|
|
amesh->vboId[5] = 0; // Vertex texcoords2 VBO UNUSED
|
|
amesh->vboId[6] = 0; // Vertex indices VBO
|
|
|
|
#if defined(GRAPHICS_API_OPENGL_11)
|
|
TraceLog(LOG_WARNING, "OGL 11");
|
|
#endif
|
|
#if defined(GRAPHICS_API_OPENGL_21)
|
|
TraceLog(LOG_WARNING, "OGL 21");
|
|
#endif
|
|
#if defined(GRAPHICS_API_OPENGL_33)
|
|
TraceLog(LOG_WARNING, "OGL 33");
|
|
#endif
|
|
#if defined(GRAPHICS_API_OPENGL_ES2)
|
|
TraceLog(LOG_WARNING, "OGL ES2");
|
|
#endif
|
|
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
|
|
int drawHint = GL_STATIC_DRAW;
|
|
if (dynamic) drawHint = GL_DYNAMIC_DRAW;
|
|
|
|
if (vaoSupported)
|
|
{
|
|
// Initialize Quads VAO (Buffer A)
|
|
glGenVertexArrays(1, &amesh->vaoId);
|
|
glBindVertexArray(amesh->vaoId);
|
|
}
|
|
|
|
// NOTE: Attributes must be uploaded considering default locations points
|
|
|
|
// Enable vertex attributes: position (shader-location = 0)
|
|
glGenBuffers(1, &amesh->vboId[0]);
|
|
glBindBuffer(GL_ARRAY_BUFFER, amesh->vboId[0]);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*amesh->vertexCount, amesh->animVertices, drawHint);
|
|
glVertexAttribPointer(0, 3, GL_FLOAT, 0, 0, 0);
|
|
glEnableVertexAttribArray(0);
|
|
|
|
// Enable vertex attributes: texcoords (shader-location = 1)
|
|
glGenBuffers(1, &amesh->vboId[1]);
|
|
glBindBuffer(GL_ARRAY_BUFFER, amesh->vboId[1]);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*2*amesh->vertexCount, amesh->texcoords, drawHint);
|
|
glVertexAttribPointer(1, 2, GL_FLOAT, 0, 0, 0);
|
|
glEnableVertexAttribArray(1);
|
|
|
|
// Enable vertex attributes: normals (shader-location = 2)
|
|
if (amesh->animNormals != NULL)
|
|
{
|
|
glGenBuffers(1, &amesh->vboId[2]);
|
|
glBindBuffer(GL_ARRAY_BUFFER, amesh->vboId[2]);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*amesh->vertexCount, amesh->animNormals, drawHint);
|
|
glVertexAttribPointer(2, 3, GL_FLOAT, 0, 0, 0);
|
|
glEnableVertexAttribArray(2);
|
|
}
|
|
else
|
|
{
|
|
// Default color vertex attribute set to WHITE
|
|
glVertexAttrib3f(2, 1.0f, 1.0f, 1.0f);
|
|
glDisableVertexAttribArray(2);
|
|
}
|
|
// colors UNUSED
|
|
/*
|
|
// Default color vertex attribute (shader-location = 3)
|
|
if (mesh->colors != NULL)
|
|
{
|
|
glGenBuffers(1, &amesh->vboId[3]);
|
|
glBindBuffer(GL_ARRAY_BUFFER, amesh->vboId[3]);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(unsigned char)*4*mesh->vertexCount, mesh->colors, drawHint);
|
|
glVertexAttribPointer(3, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
|
|
glEnableVertexAttribArray(3);
|
|
}
|
|
else
|
|
{
|
|
// Default color vertex attribute set to WHITE
|
|
glVertexAttrib4f(3, 1.0f, 1.0f, 1.0f, 1.0f);
|
|
glDisableVertexAttribArray(3);
|
|
}
|
|
*/
|
|
// colors to default
|
|
glVertexAttrib4f(3, 1.0f, 1.0f, 1.0f, 1.0f);
|
|
glDisableVertexAttribArray(3);
|
|
|
|
// tangents UNUSED
|
|
/*
|
|
// Default tangent vertex attribute (shader-location = 4)
|
|
if (mesh->tangents != NULL)
|
|
{
|
|
glGenBuffers(1, &mesh->vboId[4]);
|
|
glBindBuffer(GL_ARRAY_BUFFER, mesh->vboId[4]);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*mesh->vertexCount, mesh->tangents, drawHint);
|
|
glVertexAttribPointer(4, 4, GL_FLOAT, 0, 0, 0);
|
|
glEnableVertexAttribArray(4);
|
|
}
|
|
else
|
|
{
|
|
// Default tangents vertex attribute
|
|
glVertexAttrib4f(4, 0.0f, 0.0f, 0.0f, 0.0f);
|
|
glDisableVertexAttribArray(4);
|
|
}
|
|
*/
|
|
// tangents to default
|
|
glVertexAttrib4f(4, 0.0f, 0.0f, 0.0f, 0.0f);
|
|
glDisableVertexAttribArray(4);
|
|
|
|
// texcoords2 UNUSED
|
|
/*
|
|
// Default texcoord2 vertex attribute (shader-location = 5)
|
|
if (mesh->texcoords2 != NULL)
|
|
{
|
|
glGenBuffers(1, &mesh->vboId[5]);
|
|
glBindBuffer(GL_ARRAY_BUFFER, mesh->vboId[5]);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*2*mesh->vertexCount, mesh->texcoords2, drawHint);
|
|
glVertexAttribPointer(5, 2, GL_FLOAT, 0, 0, 0);
|
|
glEnableVertexAttribArray(5);
|
|
}
|
|
else
|
|
{
|
|
// Default texcoord2 vertex attribute
|
|
glVertexAttrib2f(5, 0.0f, 0.0f);
|
|
glDisableVertexAttribArray(5);
|
|
}
|
|
*/
|
|
// texcoords2 to default
|
|
glVertexAttrib2f(5, 0.0f, 0.0f);
|
|
glDisableVertexAttribArray(5);
|
|
|
|
if (amesh->triangles != NULL)
|
|
{
|
|
glGenBuffers(1, &amesh->vboId[6]);
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, amesh->vboId[6]);
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned short)*amesh->triangleCount*3, amesh->triangles, GL_STATIC_DRAW);
|
|
}
|
|
|
|
if (vaoSupported)
|
|
{
|
|
if (amesh->vaoId > 0) TraceLog(LOG_INFO, "[VAO ID %i] Mesh uploaded successfully to VRAM (GPU)", amesh->vaoId);
|
|
else TraceLog(LOG_WARNING, "Mesh could not be uploaded to VRAM (GPU)");
|
|
}
|
|
else
|
|
{
|
|
TraceLog(LOG_INFO, "[VBOs] Mesh uploaded successfully to VRAM (GPU)");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// Unload mesh data from CPU and GPU
|
|
void rlUnloadAnimatedMesh(AnimatedMesh *amesh)
|
|
{
|
|
if (amesh->vertices != NULL) free(amesh->vertices);
|
|
if (amesh->animVertices != NULL) free(amesh->animVertices);
|
|
if (amesh->texcoords != NULL) free(amesh->texcoords);
|
|
if (amesh->normals != NULL) free(amesh->normals);
|
|
if (amesh->animNormals != NULL) free(amesh->animNormals);
|
|
// if (mesh->colors != NULL) free(mesh->colors);
|
|
// if (mesh->tangents != NULL) free(mesh->tangents);
|
|
// if (mesh->texcoords2 != NULL) free(mesh->texcoords2);
|
|
if (amesh->triangles != NULL) free(amesh->triangles);
|
|
if (amesh->weightId != NULL) free(amesh->weightId);
|
|
if (amesh->weightBias != NULL) free(amesh->weightBias);
|
|
|
|
rlDeleteBuffers(amesh->vboId[0]); // vertex
|
|
rlDeleteBuffers(amesh->vboId[1]); // texcoords
|
|
rlDeleteBuffers(amesh->vboId[2]); // normals
|
|
rlDeleteBuffers(amesh->vboId[3]); // colors
|
|
rlDeleteBuffers(amesh->vboId[4]); // tangents
|
|
rlDeleteBuffers(amesh->vboId[5]); // texcoords2
|
|
rlDeleteBuffers(amesh->vboId[6]); // indices
|
|
|
|
rlDeleteVertexArrays(amesh->vaoId);
|
|
}
|
|
|
|
// Update vertex and normal data into GPU
|
|
void rlUpdateAnimatedMesh(AnimatedMesh *amesh)
|
|
{
|
|
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
|
|
// Activate mesh VAO
|
|
if (vaoSupported) glBindVertexArray(amesh->vaoId);
|
|
|
|
// Update positions data
|
|
glBindBuffer(GL_ARRAY_BUFFER, amesh->vboId[0]);
|
|
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float)*3*amesh->vertexCount, amesh->animVertices);
|
|
|
|
// Update normals data
|
|
glBindBuffer(GL_ARRAY_BUFFER, amesh->vboId[2]);
|
|
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float)*3*amesh->vertexCount, amesh->animNormals);
|
|
|
|
// Unbind the current VAO
|
|
if (vaoSupported) glBindVertexArray(0);
|
|
|
|
//mesh.vertices = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
|
|
// Now we can modify vertices
|
|
//glUnmapBuffer(GL_ARRAY_BUFFER);
|
|
#endif
|
|
}
|
|
|
|
// Draw a 3d mesh with material and transform
|
|
void rlDrawAnimatedMesh(AnimatedMesh amesh, Material material, Matrix transform)
|
|
{
|
|
#if defined(GRAPHICS_API_OPENGL_11)
|
|
/*
|
|
glEnable(GL_TEXTURE_2D);
|
|
glBindTexture(GL_TEXTURE_2D, material.maps[MAP_DIFFUSE].texture.id);
|
|
|
|
// NOTE: On OpenGL 1.1 we use Vertex Arrays to draw model
|
|
glEnableClientState(GL_VERTEX_ARRAY); // Enable vertex array
|
|
glEnableClientState(GL_TEXTURE_COORD_ARRAY); // Enable texture coords array
|
|
|
|
//if (amesh.normals != NULL) glEnableClientState(GL_NORMAL_ARRAY); // Enable normals array
|
|
//if (amesh.colors != NULL) glEnableClientState(GL_COLOR_ARRAY); // Enable colors array
|
|
|
|
glVertexPointer(3, GL_FLOAT, 0, amesh.animVertices); // Pointer to vertex coords array
|
|
glTexCoordPointer(2, GL_FLOAT, 0, amesh.texcoords); // Pointer to texture coords array
|
|
if (amesh.animNormals != NULL) glNormalPointer(GL_FLOAT, 0, amesh.animNormals); // Pointer to normals array
|
|
//if (mesh.colors != NULL) glColorPointer(4, GL_UNSIGNED_BYTE, 0, mesh.colors); // Pointer to colors array
|
|
|
|
rlPushMatrix();
|
|
rlMultMatrixf(MatrixToFloat(transform));
|
|
rlColor4ub(material.maps[MAP_DIFFUSE].color.r, material.maps[MAP_DIFFUSE].color.g, material.maps[MAP_DIFFUSE].color.b, material.maps[MAP_DIFFUSE].color.a);
|
|
|
|
if (amesh.triangles != NULL) glDrawElements(GL_TRIANGLES, amesh.triangleCount*3, GL_UNSIGNED_SHORT, amesh.triangles);
|
|
else glDrawArrays(GL_TRIANGLES, 0, amesh.vertexCount);
|
|
rlPopMatrix();
|
|
|
|
glDisableClientState(GL_VERTEX_ARRAY); // Disable vertex array
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY); // Disable texture coords array
|
|
if (amesh.animNormals != NULL) glDisableClientState(GL_NORMAL_ARRAY); // Disable normals array
|
|
//if (mesh.colors != NULL) glDisableClientState(GL_NORMAL_ARRAY); // Disable colors array
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
*/
|
|
#endif
|
|
|
|
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
|
|
// Bind shader program
|
|
glUseProgram(material.shader.id);
|
|
|
|
// Matrices and other values required by shader
|
|
//-----------------------------------------------------
|
|
// Calculate and send to shader model matrix (used by PBR shader)
|
|
if (material.shader.locs[LOC_MATRIX_MODEL] != -1) SetShaderValueMatrix(material.shader, material.shader.locs[LOC_MATRIX_MODEL], transform);
|
|
|
|
// Upload to shader material.colDiffuse
|
|
if (material.shader.locs[LOC_COLOR_DIFFUSE] != -1)
|
|
glUniform4f(material.shader.locs[LOC_COLOR_DIFFUSE], (float)material.maps[MAP_DIFFUSE].color.r/255.0f,
|
|
(float)material.maps[MAP_DIFFUSE].color.g/255.0f,
|
|
(float)material.maps[MAP_DIFFUSE].color.b/255.0f,
|
|
(float)material.maps[MAP_DIFFUSE].color.a/255.0f);
|
|
|
|
// Upload to shader material.colSpecular (if available)
|
|
if (material.shader.locs[LOC_COLOR_SPECULAR] != -1)
|
|
glUniform4f(material.shader.locs[LOC_COLOR_SPECULAR], (float)material.maps[MAP_SPECULAR].color.r/255.0f,
|
|
(float)material.maps[MAP_SPECULAR].color.g/255.0f,
|
|
(float)material.maps[MAP_SPECULAR].color.b/255.0f,
|
|
(float)material.maps[MAP_SPECULAR].color.a/255.0f);
|
|
|
|
if (material.shader.locs[LOC_MATRIX_VIEW] != -1) SetShaderValueMatrix(material.shader, material.shader.locs[LOC_MATRIX_VIEW], modelview);
|
|
if (material.shader.locs[LOC_MATRIX_PROJECTION] != -1) SetShaderValueMatrix(material.shader, material.shader.locs[LOC_MATRIX_PROJECTION], projection);
|
|
|
|
// At this point the modelview matrix just contains the view matrix (camera)
|
|
// That's because BeginMode3D() sets it an no model-drawing function modifies it, all use rlPushMatrix() and rlPopMatrix()
|
|
Matrix matView = modelview; // View matrix (camera)
|
|
Matrix matProjection = projection; // Projection matrix (perspective)
|
|
|
|
// Calculate model-view matrix combining matModel and matView
|
|
Matrix matModelView = MatrixMultiply(transform, matView); // Transform to camera-space coordinates
|
|
//-----------------------------------------------------
|
|
|
|
// Bind active texture maps (if available)
|
|
for (int i = 0; i < MAX_MATERIAL_MAPS; i++)
|
|
{
|
|
if (material.maps[i].texture.id > 0)
|
|
{
|
|
glActiveTexture(GL_TEXTURE0 + i);
|
|
if ((i == MAP_IRRADIANCE) || (i == MAP_PREFILTER) || (i == MAP_CUBEMAP)) glBindTexture(GL_TEXTURE_CUBE_MAP, material.maps[i].texture.id);
|
|
else glBindTexture(GL_TEXTURE_2D, material.maps[i].texture.id);
|
|
|
|
glUniform1i(material.shader.locs[LOC_MAP_DIFFUSE + i], i);
|
|
}
|
|
}
|
|
|
|
// Bind vertex array objects (or VBOs)
|
|
if (vaoSupported) glBindVertexArray(amesh.vaoId);
|
|
else
|
|
{
|
|
// TODO: Simplify VBO binding into a for loop
|
|
|
|
// Bind mesh VBO data: vertex position (shader-location = 0)
|
|
glBindBuffer(GL_ARRAY_BUFFER, amesh.vboId[0]);
|
|
glVertexAttribPointer(material.shader.locs[LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0);
|
|
glEnableVertexAttribArray(material.shader.locs[LOC_VERTEX_POSITION]);
|
|
|
|
// Bind mesh VBO data: vertex texcoords (shader-location = 1)
|
|
glBindBuffer(GL_ARRAY_BUFFER, amesh.vboId[1]);
|
|
glVertexAttribPointer(material.shader.locs[LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0);
|
|
glEnableVertexAttribArray(material.shader.locs[LOC_VERTEX_TEXCOORD01]);
|
|
|
|
// Bind mesh VBO data: vertex normals (shader-location = 2, if available)
|
|
if (material.shader.locs[LOC_VERTEX_NORMAL] != -1)
|
|
{
|
|
glBindBuffer(GL_ARRAY_BUFFER, amesh.vboId[2]);
|
|
glVertexAttribPointer(material.shader.locs[LOC_VERTEX_NORMAL], 3, GL_FLOAT, 0, 0, 0);
|
|
glEnableVertexAttribArray(material.shader.locs[LOC_VERTEX_NORMAL]);
|
|
}
|
|
|
|
// Bind mesh VBO data: vertex colors (shader-location = 3, if available)
|
|
if (material.shader.locs[LOC_VERTEX_COLOR] != -1)
|
|
{
|
|
if (amesh.vboId[3] != 0)
|
|
{
|
|
glBindBuffer(GL_ARRAY_BUFFER, amesh.vboId[3]);
|
|
glVertexAttribPointer(material.shader.locs[LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
|
|
glEnableVertexAttribArray(material.shader.locs[LOC_VERTEX_COLOR]);
|
|
}
|
|
else
|
|
{
|
|
// Set default value for unused attribute
|
|
// NOTE: Required when using default shader and no VAO support
|
|
glVertexAttrib4f(material.shader.locs[LOC_VERTEX_COLOR], 1.0f, 1.0f, 1.0f, 1.0f);
|
|
glDisableVertexAttribArray(material.shader.locs[LOC_VERTEX_COLOR]);
|
|
}
|
|
}
|
|
|
|
// Bind mesh VBO data: vertex tangents (shader-location = 4, if available)
|
|
if (material.shader.locs[LOC_VERTEX_TANGENT] != -1)
|
|
{
|
|
glBindBuffer(GL_ARRAY_BUFFER, amesh.vboId[4]);
|
|
glVertexAttribPointer(material.shader.locs[LOC_VERTEX_TANGENT], 4, GL_FLOAT, 0, 0, 0);
|
|
glEnableVertexAttribArray(material.shader.locs[LOC_VERTEX_TANGENT]);
|
|
}
|
|
|
|
// Bind mesh VBO data: vertex texcoords2 (shader-location = 5, if available)
|
|
if (material.shader.locs[LOC_VERTEX_TEXCOORD02] != -1)
|
|
{
|
|
glBindBuffer(GL_ARRAY_BUFFER, amesh.vboId[5]);
|
|
glVertexAttribPointer(material.shader.locs[LOC_VERTEX_TEXCOORD02], 2, GL_FLOAT, 0, 0, 0);
|
|
glEnableVertexAttribArray(material.shader.locs[LOC_VERTEX_TEXCOORD02]);
|
|
}
|
|
|
|
if (amesh.triangles != NULL) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, amesh.vboId[6]);
|
|
}
|
|
|
|
int eyesCount = 1;
|
|
#if defined(SUPPORT_VR_SIMULATOR)
|
|
if (vrStereoRender) eyesCount = 2;
|
|
#endif
|
|
|
|
for (int eye = 0; eye < eyesCount; eye++)
|
|
{
|
|
if (eyesCount == 1) modelview = matModelView;
|
|
#if defined(SUPPORT_VR_SIMULATOR)
|
|
else SetStereoView(eye, matProjection, matModelView);
|
|
#endif
|
|
|
|
// Calculate model-view-projection matrix (MVP)
|
|
Matrix matMVP = MatrixMultiply(modelview, projection); // Transform to screen-space coordinates
|
|
|
|
// Send combined model-view-projection matrix to shader
|
|
glUniformMatrix4fv(material.shader.locs[LOC_MATRIX_MVP], 1, false, MatrixToFloat(matMVP));
|
|
|
|
// Draw call!
|
|
if (amesh.triangles != NULL) glDrawElements(GL_TRIANGLES, amesh.triangleCount*3, GL_UNSIGNED_SHORT, 0); // Indexed vertices draw
|
|
else glDrawArrays(GL_TRIANGLES, 0, amesh.vertexCount);
|
|
}
|
|
|
|
// Unbind all binded texture maps
|
|
for (int i = 0; i < MAX_MATERIAL_MAPS; i++)
|
|
{
|
|
glActiveTexture(GL_TEXTURE0 + i); // Set shader active texture
|
|
if ((i == MAP_IRRADIANCE) || (i == MAP_PREFILTER) || (i == MAP_CUBEMAP)) glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
|
|
else glBindTexture(GL_TEXTURE_2D, 0); // Unbind current active texture
|
|
}
|
|
|
|
// Unind vertex array objects (or VBOs)
|
|
if (vaoSupported) glBindVertexArray(0);
|
|
else
|
|
{
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
if (amesh.triangles != NULL) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
|
}
|
|
|
|
// Unbind shader program
|
|
glUseProgram(0);
|
|
|
|
// Restore projection/modelview matrices
|
|
// NOTE: In stereo rendering matrices are being modified to fit every eye
|
|
projection = matProjection;
|
|
modelview = matView;
|
|
#endif
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" { // Prevents name mangling of functions
|
|
#endif
|
|
|
|
// Load .iqm file and initialize animated model
|
|
AnimatedModel LoadAnimatedModel(const char *filename)
|
|
{
|
|
AnimatedModel out = LoadIQM(filename);
|
|
|
|
for (int i = 0; i < out.meshCount; i++) rlLoadAnimatedMesh(&out.mesh[i], false);
|
|
|
|
out.transform = MatrixIdentity();
|
|
out.meshMaterialId = malloc(sizeof(int)*out.meshCount);
|
|
out.materials = NULL;
|
|
out.materialCount = 0;
|
|
|
|
for (int i = 0; i < out.meshCount; i++) out.meshMaterialId[i] = -1;
|
|
|
|
return out;
|
|
}
|
|
|
|
// Add a texture to an animated model
|
|
AnimatedModel AnimatedModelAddTexture(AnimatedModel model, const char *filename)
|
|
{
|
|
Texture2D texture = LoadTexture(filename);
|
|
|
|
model.materials = realloc(model.materials, sizeof(Material)*(model.materialCount + 1));
|
|
model.materials[model.materialCount] = LoadMaterialDefault();
|
|
model.materials[model.materialCount].maps[MAP_DIFFUSE].texture = texture;
|
|
model.materialCount++;
|
|
|
|
return model;
|
|
}
|
|
|
|
// Set the material for a mesh
|
|
AnimatedModel SetMeshMaterial(AnimatedModel model, int meshid, int textureid)
|
|
{
|
|
if (meshid > model.meshCount)
|
|
{
|
|
TraceLog(LOG_WARNING, "MeshId greater than meshCount\n");
|
|
return model;
|
|
}
|
|
|
|
if (textureid > model.materialCount)
|
|
{
|
|
TraceLog(LOG_WARNING,"textureid greater than materialCount\n");
|
|
return model;
|
|
}
|
|
|
|
model.meshMaterialId[meshid] = textureid;
|
|
|
|
return model;
|
|
}
|
|
|
|
// Load animations from a .iqm file
|
|
Animation LoadAnimationFromIQM(const char *filename)
|
|
{
|
|
Animation animation = { 0 };
|
|
|
|
FILE *iqmFile;
|
|
IQMHeader iqm;
|
|
|
|
iqmFile = fopen(filename,"rb");
|
|
|
|
if (!iqmFile)
|
|
{
|
|
TraceLog(LOG_ERROR, "[%s] Unable to open file", filename);
|
|
return animation;
|
|
}
|
|
|
|
// header
|
|
fread(&iqm, sizeof(IQMHeader), 1, iqmFile);
|
|
|
|
if (strncmp(iqm.magic, IQM_MAGIC, sizeof(IQM_MAGIC)))
|
|
{
|
|
TraceLog(LOG_ERROR, "Magic Number \"%s\"does not match.", iqm.magic);
|
|
fclose(iqmFile);
|
|
return animation;
|
|
}
|
|
|
|
if (iqm.version != IQM_VERSION)
|
|
{
|
|
TraceLog(LOG_ERROR, "IQM version %i is incorrect.", iqm.version);
|
|
fclose(iqmFile);
|
|
return animation;
|
|
}
|
|
|
|
// header
|
|
if (iqm.num_anims > 1) TraceLog(LOG_WARNING, "More than 1 animation in file, only the first one will get loaded");
|
|
|
|
// joints
|
|
IQMPose *poses;
|
|
poses = malloc(sizeof(IQMPose)*iqm.num_poses);
|
|
fseek(iqmFile, iqm.ofs_poses, SEEK_SET);
|
|
fread(poses, sizeof(IQMPose)*iqm.num_poses, 1, iqmFile);
|
|
|
|
animation.jointCount = iqm.num_poses;
|
|
animation.joints = malloc(sizeof(Joint)*iqm.num_poses);
|
|
|
|
for (int j = 0; j < iqm.num_poses; j++)
|
|
{
|
|
strcpy(animation.joints[j].name, ANIMJOINTNAME);
|
|
animation.joints[j].parent = poses[j].parent;
|
|
}
|
|
|
|
// animations
|
|
IQMAnim anim = {0};
|
|
fseek(iqmFile, iqm.ofs_anims, SEEK_SET);
|
|
fread(&anim, sizeof(IQMAnim), 1, iqmFile);
|
|
|
|
animation.frameCount = anim.num_frames;
|
|
animation.framerate = anim.framerate;
|
|
|
|
// frameposes
|
|
unsigned short *framedata = malloc(sizeof(unsigned short)*iqm.num_frames*iqm.num_framechannels);
|
|
fseek(iqmFile, iqm.ofs_frames, SEEK_SET);
|
|
fread(framedata, sizeof(unsigned short)*iqm.num_frames*iqm.num_framechannels, 1, iqmFile);
|
|
|
|
animation.framepose = malloc(sizeof(Pose*)*anim.num_frames);
|
|
for (int j = 0; j < anim.num_frames; j++) animation.framepose[j] = malloc(sizeof(Pose)*iqm.num_poses);
|
|
|
|
int dcounter = anim.first_frame*iqm.num_framechannels;
|
|
|
|
for (int frame = 0; frame < anim.num_frames; frame++)
|
|
{
|
|
for (int i = 0; i < iqm.num_poses; i++)
|
|
{
|
|
animation.framepose[frame][i].translation.x = poses[i].channeloffset[0];
|
|
|
|
if (poses[i].mask & 0x01)
|
|
{
|
|
animation.framepose[frame][i].translation.x += framedata[dcounter]*poses[i].channelscale[0];
|
|
dcounter++;
|
|
}
|
|
|
|
animation.framepose[frame][i].translation.y = poses[i].channeloffset[1];
|
|
|
|
if (poses[i].mask & 0x02)
|
|
{
|
|
animation.framepose[frame][i].translation.y += framedata[dcounter]*poses[i].channelscale[1];
|
|
dcounter++;
|
|
}
|
|
|
|
animation.framepose[frame][i].translation.z = poses[i].channeloffset[2];
|
|
|
|
if (poses[i].mask & 0x04)
|
|
{
|
|
animation.framepose[frame][i].translation.z += framedata[dcounter]*poses[i].channelscale[2];
|
|
dcounter++;
|
|
}
|
|
|
|
animation.framepose[frame][i].rotation.x = poses[i].channeloffset[3];
|
|
|
|
if (poses[i].mask & 0x08)
|
|
{
|
|
animation.framepose[frame][i].rotation.x += framedata[dcounter]*poses[i].channelscale[3];
|
|
dcounter++;
|
|
}
|
|
|
|
animation.framepose[frame][i].rotation.y = poses[i].channeloffset[4];
|
|
|
|
if (poses[i].mask & 0x10)
|
|
{
|
|
animation.framepose[frame][i].rotation.y += framedata[dcounter]*poses[i].channelscale[4];
|
|
dcounter++;
|
|
}
|
|
|
|
animation.framepose[frame][i].rotation.z = poses[i].channeloffset[5];
|
|
|
|
if (poses[i].mask & 0x20)
|
|
{
|
|
animation.framepose[frame][i].rotation.z += framedata[dcounter]*poses[i].channelscale[5];
|
|
dcounter++;
|
|
}
|
|
|
|
animation.framepose[frame][i].rotation.w = poses[i].channeloffset[6];
|
|
|
|
if (poses[i].mask & 0x40)
|
|
{
|
|
animation.framepose[frame][i].rotation.w += framedata[dcounter]*poses[i].channelscale[6];
|
|
dcounter++;
|
|
}
|
|
|
|
animation.framepose[frame][i].scale.x = poses[i].channeloffset[7];
|
|
|
|
if (poses[i].mask & 0x80)
|
|
{
|
|
animation.framepose[frame][i].scale.x += framedata[dcounter]*poses[i].channelscale[7];
|
|
dcounter++;
|
|
}
|
|
|
|
animation.framepose[frame][i].scale.y = poses[i].channeloffset[8];
|
|
|
|
if (poses[i].mask & 0x100)
|
|
{
|
|
animation.framepose[frame][i].scale.y += framedata[dcounter]*poses[i].channelscale[8];
|
|
dcounter++;
|
|
}
|
|
|
|
animation.framepose[frame][i].scale.z = poses[i].channeloffset[9];
|
|
|
|
if (poses[i].mask & 0x200)
|
|
{
|
|
animation.framepose[frame][i].scale.z += framedata[dcounter]*poses[i].channelscale[9];
|
|
dcounter++;
|
|
}
|
|
|
|
animation.framepose[frame][i].rotation = QuaternionNormalize(animation.framepose[frame][i].rotation);
|
|
}
|
|
}
|
|
|
|
// Build frameposes
|
|
for (int frame = 0; frame < anim.num_frames; frame++)
|
|
{
|
|
for (int i = 0; i < animation.jointCount; i++)
|
|
{
|
|
if (animation.joints[i].parent >= 0)
|
|
{
|
|
animation.framepose[frame][i].rotation = QuaternionMultiply(animation.framepose[frame][animation.joints[i].parent].rotation, animation.framepose[frame][i].rotation);
|
|
animation.framepose[frame][i].translation = Vector3RotateByQuaternion(animation.framepose[frame][i].translation, animation.framepose[frame][animation.joints[i].parent].rotation);
|
|
animation.framepose[frame][i].translation = Vector3Add(animation.framepose[frame][i].translation, animation.framepose[frame][animation.joints[i].parent].translation);
|
|
animation.framepose[frame][i].scale = Vector3MultiplyV(animation.framepose[frame][i].scale, animation.framepose[frame][animation.joints[i].parent].scale);
|
|
}
|
|
}
|
|
}
|
|
|
|
free(framedata);
|
|
free(poses);
|
|
|
|
fclose(iqmFile);
|
|
|
|
return animation;
|
|
}
|
|
|
|
// Unload animated model
|
|
void UnloadAnimatedModel(AnimatedModel model)
|
|
{
|
|
free(model.materials);
|
|
free(model.meshMaterialId);
|
|
free(model.joints);
|
|
free(model.basepose);
|
|
|
|
for (int i = 0; i < model.meshCount; i++) rlUnloadAnimatedMesh(&model.mesh[i]);
|
|
|
|
free(model.mesh);
|
|
}
|
|
|
|
// Unload animation
|
|
void UnloadAnimation(Animation anim)
|
|
{
|
|
free(anim.joints);
|
|
free(anim.framepose);
|
|
|
|
for (int i = 0; i < anim.frameCount; i++) free(anim.framepose[i]);
|
|
}
|
|
|
|
// Check if skeletons match, only parents and jointCount are checked
|
|
bool CheckSkeletonsMatch(AnimatedModel model, Animation anim)
|
|
{
|
|
if (model.jointCount != anim.jointCount) return 0;
|
|
|
|
for (int i = 0; i < model.jointCount; i++)
|
|
{
|
|
if (model.joints[i].parent != anim.joints[i].parent) return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
// Calculate the animated vertex positions and normals based on an animation at a given frame
|
|
void AnimateModel(AnimatedModel model, Animation anim, int frame)
|
|
{
|
|
if (frame >= anim.frameCount) frame = frame%anim.frameCount;
|
|
|
|
for (int m = 0; m < model.meshCount; m++)
|
|
{
|
|
Vector3 outv = {0};
|
|
Vector3 outn = {0};
|
|
|
|
Vector3 baset = {0};
|
|
Quaternion baser = {0};
|
|
Vector3 bases = {0};
|
|
|
|
Vector3 outt = {0};
|
|
Quaternion outr = {0};
|
|
Vector3 outs = {0};
|
|
|
|
int vcounter = 0;
|
|
int wcounter = 0;
|
|
int weightId = 0;
|
|
|
|
for (int i = 0; i < model.mesh[m].vertexCount; i++)
|
|
{
|
|
weightId = model.mesh[m].weightId[wcounter];
|
|
baset = model.basepose[weightId].translation;
|
|
baser = model.basepose[weightId].rotation;
|
|
bases = model.basepose[weightId].scale;
|
|
outt = anim.framepose[frame][weightId].translation;
|
|
outr = anim.framepose[frame][weightId].rotation;
|
|
outs = anim.framepose[frame][weightId].scale;
|
|
|
|
// vertices
|
|
outv = (Vector3){model.mesh[m].vertices[vcounter],model.mesh[m].vertices[vcounter + 1],model.mesh[m].vertices[vcounter + 2]};
|
|
outv = Vector3MultiplyV(outv,outs);
|
|
outv = Vector3Subtract(outv,baset);
|
|
outv = Vector3RotateByQuaternion(outv,QuaternionMultiply(outr,QuaternionInvert(baser)));
|
|
outv = Vector3Add(outv,outt);
|
|
model.mesh[m].animVertices[vcounter] = outv.x;
|
|
model.mesh[m].animVertices[vcounter + 1] = outv.y;
|
|
model.mesh[m].animVertices[vcounter + 2] = outv.z;
|
|
|
|
// normals
|
|
outn = (Vector3){model.mesh[m].normals[vcounter],model.mesh[m].normals[vcounter + 1],model.mesh[m].normals[vcounter + 2]};
|
|
outn = Vector3RotateByQuaternion(outn,QuaternionMultiply(outr,QuaternionInvert(baser)));
|
|
model.mesh[m].animNormals[vcounter] = outn.x;
|
|
model.mesh[m].animNormals[vcounter + 1] = outn.y;
|
|
model.mesh[m].animNormals[vcounter + 2] = outn.z;
|
|
vcounter += 3;
|
|
wcounter += 4;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Draw an animated model
|
|
void DrawAnimatedModel(AnimatedModel model,Vector3 position,float scale,Color tint)
|
|
{
|
|
Vector3 vScale = { scale, scale, scale };
|
|
Vector3 rotationAxis = { 0.0f,0.0f,0.0f };
|
|
|
|
DrawAnimatedModelEx(model, position, rotationAxis, 0.0f, vScale, tint);
|
|
}
|
|
|
|
// Draw an animated model with extended parameters
|
|
void DrawAnimatedModelEx(AnimatedModel model,Vector3 position,Vector3 rotationAxis,float rotationAngle, Vector3 scale,Color tint)
|
|
{
|
|
if (model.materialCount == 0)
|
|
{
|
|
TraceLog(LOG_WARNING,"No materials set, can't draw animated mesh\n");
|
|
return;
|
|
}
|
|
|
|
Matrix matScale = MatrixScale(scale.x,scale.y,scale.z);
|
|
Matrix matRotation = MatrixRotate(rotationAxis,rotationAngle*DEG2RAD);
|
|
Matrix matTranslation = MatrixTranslate(position.x,position.y,position.z);
|
|
|
|
Matrix matTransform = MatrixMultiply(MatrixMultiply(matScale,matRotation),matTranslation);
|
|
model.transform = MatrixMultiply(model.transform,matTransform);
|
|
|
|
for (int i = 0; i < model.meshCount; i++)
|
|
{
|
|
rlUpdateAnimatedMesh(&model.mesh[i]);
|
|
rlDrawAnimatedMesh(model.mesh[i],model.materials[model.meshMaterialId[i]],MatrixIdentity());
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Load animated model meshes from IQM file
|
|
static AnimatedModel LoadIQM(const char *filename)
|
|
{
|
|
AnimatedModel model = { 0 };
|
|
|
|
FILE *iqmFile;
|
|
IQMHeader iqm;
|
|
|
|
IQMMesh *imesh;
|
|
IQMTriangle *tri;
|
|
IQMVertexArray *va;
|
|
IQMJoint *ijoint;
|
|
|
|
float *vertex;
|
|
float *normal;
|
|
float *text;
|
|
char *blendi;
|
|
unsigned char *blendw;
|
|
|
|
iqmFile = fopen(filename, "rb");
|
|
|
|
if (!iqmFile)
|
|
{
|
|
TraceLog(LOG_ERROR, "[%s] Unable to open file", filename);
|
|
return model;
|
|
}
|
|
|
|
// header
|
|
fread(&iqm,sizeof(IQMHeader), 1, iqmFile);
|
|
|
|
if (strncmp(iqm.magic, IQM_MAGIC, sizeof(IQM_MAGIC)))
|
|
{
|
|
TraceLog(LOG_ERROR, "Magic Number \"%s\"does not match.", iqm.magic);
|
|
fclose(iqmFile);
|
|
return model;
|
|
}
|
|
|
|
if(iqm.version != IQM_VERSION)
|
|
{
|
|
TraceLog(LOG_ERROR, "IQM version %i is incorrect.", iqm.version);
|
|
fclose(iqmFile);
|
|
return model;
|
|
}
|
|
|
|
// meshes
|
|
imesh = malloc(sizeof(IQMMesh)*iqm.num_meshes);
|
|
fseek(iqmFile, iqm.ofs_meshes, SEEK_SET);
|
|
fread(imesh, sizeof(IQMMesh)*iqm.num_meshes, 1, iqmFile);
|
|
|
|
model.meshCount = iqm.num_meshes;
|
|
model.mesh = malloc(sizeof(AnimatedMesh)*iqm.num_meshes);
|
|
|
|
for (int i = 0; i < iqm.num_meshes; i++)
|
|
{
|
|
fseek(iqmFile,iqm.ofs_text+imesh[i].name,SEEK_SET);
|
|
fread(model.mesh[i].name, sizeof(char)*MESH_NAME_LENGTH, 1, iqmFile);
|
|
model.mesh[i].vertexCount = imesh[i].num_vertexes;
|
|
model.mesh[i].vertices = malloc(sizeof(float)*imesh[i].num_vertexes*3);
|
|
model.mesh[i].normals = malloc(sizeof(float)*imesh[i].num_vertexes*3);
|
|
model.mesh[i].texcoords = malloc(sizeof(float)*imesh[i].num_vertexes*2);
|
|
model.mesh[i].weightId = malloc(sizeof(int)*imesh[i].num_vertexes*4);
|
|
model.mesh[i].weightBias = malloc(sizeof(float)*imesh[i].num_vertexes*4);
|
|
model.mesh[i].triangleCount = imesh[i].num_triangles;
|
|
model.mesh[i].triangles = malloc(sizeof(unsigned short)*imesh[i].num_triangles*3);
|
|
model.mesh[i].animVertices = malloc(sizeof(float)*imesh[i].num_vertexes*3);
|
|
model.mesh[i].animNormals = malloc(sizeof(float)*imesh[i].num_vertexes*3);
|
|
}
|
|
|
|
// tris
|
|
tri = malloc(sizeof(IQMTriangle)*iqm.num_triangles);
|
|
fseek(iqmFile, iqm.ofs_triangles, SEEK_SET);
|
|
fread(tri, sizeof(IQMTriangle)*iqm.num_triangles, 1, iqmFile);
|
|
|
|
for (int m = 0; m < iqm.num_meshes; m++)
|
|
{
|
|
int tcounter = 0;
|
|
|
|
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
|
|
model.mesh[m].triangles[tcounter+2] = tri[i].vertex[0] - imesh[m].first_vertex;
|
|
model.mesh[m].triangles[tcounter+1] = tri[i].vertex[1] - imesh[m].first_vertex;
|
|
model.mesh[m].triangles[tcounter] = tri[i].vertex[2] - imesh[m].first_vertex;
|
|
tcounter += 3;
|
|
}
|
|
}
|
|
|
|
// vertarrays
|
|
va = malloc(sizeof(IQMVertexArray)*iqm.num_vertexarrays);
|
|
fseek(iqmFile, iqm.ofs_vertexarrays, SEEK_SET);
|
|
fread(va, sizeof(IQMVertexArray)*iqm.num_vertexarrays, 1, iqmFile);
|
|
|
|
for (int i = 0; i < iqm.num_vertexarrays; i++)
|
|
{
|
|
switch (va[i].type)
|
|
{
|
|
case IQM_POSITION:
|
|
{
|
|
vertex = malloc(sizeof(float)*iqm.num_vertexes*3);
|
|
fseek(iqmFile, va[i].offset, SEEK_SET);
|
|
fread(vertex, sizeof(float)*iqm.num_vertexes*3, 1, iqmFile);
|
|
|
|
for (int m = 0; m < iqm.num_meshes; m++)
|
|
{
|
|
int vcounter = 0;
|
|
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.mesh[m].animVertices[vcounter] = vertex[i];
|
|
vcounter++;
|
|
}
|
|
}
|
|
} break;
|
|
case IQM_NORMAL:
|
|
{
|
|
normal = malloc(sizeof(float)*iqm.num_vertexes*3);
|
|
fseek(iqmFile, va[i].offset, SEEK_SET);
|
|
fread(normal, sizeof(float)*iqm.num_vertexes*3, 1, iqmFile);
|
|
|
|
for (int m = 0; m < iqm.num_meshes; m++)
|
|
{
|
|
int vcounter = 0;
|
|
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.mesh[m].animNormals[vcounter] = normal[i];
|
|
vcounter++;
|
|
}
|
|
}
|
|
} break;
|
|
case IQM_TEXCOORD:
|
|
{
|
|
text = malloc(sizeof(float)*iqm.num_vertexes*2);
|
|
fseek(iqmFile, va[i].offset, SEEK_SET);
|
|
fread(text, sizeof(float)*iqm.num_vertexes*2, 1, iqmFile);
|
|
|
|
for (int m = 0; m < iqm.num_meshes; m++)
|
|
{
|
|
int vcounter = 0;
|
|
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];
|
|
vcounter++;
|
|
}
|
|
}
|
|
} break;
|
|
case IQM_BLENDINDEXES:
|
|
{
|
|
blendi = malloc(sizeof(char)*iqm.num_vertexes*4);
|
|
fseek(iqmFile, va[i].offset, SEEK_SET);
|
|
fread(blendi, sizeof(char)*iqm.num_vertexes*4, 1, iqmFile);
|
|
|
|
for (int m = 0; m < iqm.num_meshes; m++)
|
|
{
|
|
int vcounter = 0;
|
|
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];
|
|
vcounter++;
|
|
}
|
|
}
|
|
} break;
|
|
case IQM_BLENDWEIGHTS:
|
|
{
|
|
blendw = malloc(sizeof(unsigned char)*iqm.num_vertexes*4);
|
|
fseek(iqmFile,va[i].offset,SEEK_SET);
|
|
fread(blendw,sizeof(unsigned char)*iqm.num_vertexes*4,1,iqmFile);
|
|
|
|
for (int m = 0; m < iqm.num_meshes; m++)
|
|
{
|
|
int vcounter = 0;
|
|
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;
|
|
vcounter++;
|
|
}
|
|
}
|
|
} break;
|
|
}
|
|
}
|
|
|
|
// joints, include base poses
|
|
ijoint = malloc(sizeof(IQMJoint)*iqm.num_joints);
|
|
fseek(iqmFile, iqm.ofs_joints, SEEK_SET);
|
|
fread(ijoint, sizeof(IQMJoint)*iqm.num_joints, 1, iqmFile);
|
|
|
|
model.jointCount = iqm.num_joints;
|
|
model.joints = malloc(sizeof(Joint)*iqm.num_joints);
|
|
model.basepose = malloc(sizeof(Pose)*iqm.num_joints);
|
|
|
|
for (int i = 0; i < iqm.num_joints; i++)
|
|
{
|
|
// joints
|
|
model.joints[i].parent = ijoint[i].parent;
|
|
fseek(iqmFile, iqm.ofs_text + ijoint[i].name, SEEK_SET);
|
|
fread(model.joints[i].name,sizeof(char)*JOINT_NAME_LENGTH, 1, iqmFile);
|
|
|
|
// basepose
|
|
model.basepose[i].translation.x = ijoint[i].translate[0];
|
|
model.basepose[i].translation.y = ijoint[i].translate[1];
|
|
model.basepose[i].translation.z = ijoint[i].translate[2];
|
|
|
|
model.basepose[i].rotation.x = ijoint[i].rotate[0];
|
|
model.basepose[i].rotation.y = ijoint[i].rotate[1];
|
|
model.basepose[i].rotation.z = ijoint[i].rotate[2];
|
|
model.basepose[i].rotation.w = ijoint[i].rotate[3];
|
|
|
|
model.basepose[i].scale.x = ijoint[i].scale[0];
|
|
model.basepose[i].scale.y = ijoint[i].scale[1];
|
|
model.basepose[i].scale.z = ijoint[i].scale[2];
|
|
}
|
|
|
|
// build base pose
|
|
for (int i = 0; i < model.jointCount; i++)
|
|
{
|
|
if (model.joints[i].parent >= 0)
|
|
{
|
|
model.basepose[i].rotation = QuaternionMultiply(model.basepose[model.joints[i].parent].rotation, model.basepose[i].rotation);
|
|
model.basepose[i].translation = Vector3RotateByQuaternion(model.basepose[i].translation, model.basepose[model.joints[i].parent].rotation);
|
|
model.basepose[i].translation = Vector3Add(model.basepose[i].translation, model.basepose[model.joints[i].parent].translation);
|
|
model.basepose[i].scale = Vector3MultiplyV(model.basepose[i].scale, model.basepose[model.joints[i].parent].scale);
|
|
}
|
|
}
|
|
|
|
fclose(iqmFile);
|
|
free(imesh);
|
|
free(tri);
|
|
free(va);
|
|
free(vertex);
|
|
free(normal);
|
|
free(text);
|
|
free(blendi);
|
|
free(blendw);
|
|
free(ijoint);
|
|
|
|
return model;
|
|
}
|
|
|
|
#endif
|