665 lines
17 KiB
C
665 lines
17 KiB
C
#ifndef GLQUAKE
|
|
#define GLQUAKE //this is shit.
|
|
#endif
|
|
#include "quakedef.h"
|
|
#include "../plugin.h"
|
|
#include "com_mesh.h"
|
|
extern plugmodfuncs_t *modfuncs;
|
|
extern plugfsfuncs_t *filefuncs;
|
|
|
|
#define IQM_MAGIC "INTERQUAKEMODEL"
|
|
#define IQM_VERSION2 2
|
|
|
|
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;
|
|
};
|
|
struct iqmmesh
|
|
{
|
|
unsigned int name;
|
|
unsigned int material;
|
|
unsigned int first_vertex, num_vertexes;
|
|
unsigned int first_triangle, num_triangles;
|
|
};
|
|
|
|
enum
|
|
{
|
|
IQM_POSITION = 0,
|
|
IQM_TEXCOORD = 1,
|
|
IQM_NORMAL = 2,
|
|
IQM_TANGENT = 3,
|
|
IQM_BLENDINDEXES = 4,
|
|
IQM_BLENDWEIGHTS = 5,
|
|
IQM_COLOR = 6,
|
|
IQM_CUSTOM = 0x10
|
|
};
|
|
|
|
enum
|
|
{
|
|
IQM_BYTE = 0,
|
|
IQM_UBYTE = 1,
|
|
IQM_SHORT = 2,
|
|
IQM_USHORT = 3,
|
|
IQM_INT = 4,
|
|
IQM_UINT = 5,
|
|
IQM_HALF = 6,
|
|
IQM_FLOAT = 7,
|
|
IQM_DOUBLE = 8,
|
|
};
|
|
|
|
struct iqmtriangle
|
|
{
|
|
unsigned int vertex[3];
|
|
};
|
|
|
|
struct iqmjoint2
|
|
{
|
|
unsigned int name;
|
|
int parent;
|
|
float translate[3], rotate[4], scale[3];
|
|
};
|
|
|
|
struct iqmpose2
|
|
{
|
|
int parent;
|
|
unsigned int mask;
|
|
float channeloffset[10];
|
|
float channelscale[10];
|
|
};
|
|
|
|
struct iqmanim
|
|
{
|
|
unsigned int name;
|
|
unsigned int first_frame, num_frames;
|
|
float framerate;
|
|
unsigned int flags;
|
|
};
|
|
|
|
enum
|
|
{
|
|
IQM_LOOP = 1<<0
|
|
};
|
|
|
|
struct iqmvertexarray
|
|
{
|
|
unsigned int type;
|
|
unsigned int flags;
|
|
unsigned int format;
|
|
unsigned int size;
|
|
unsigned int offset;
|
|
};
|
|
|
|
struct iqmbounds
|
|
{
|
|
float bbmin[3], bbmax[3];
|
|
float xyradius, radius;
|
|
};
|
|
|
|
struct iqmextension
|
|
{
|
|
unsigned int name;
|
|
unsigned int num_data, ofs_data;
|
|
unsigned int ofs_extensions; // pointer to next extension. wtf is up with this? how is this not redundant due to ofs_data?
|
|
};
|
|
|
|
|
|
struct iqmext_fte_mesh
|
|
{
|
|
unsigned int contents; //default CONTENTS_BODY
|
|
unsigned int surfaceflags; //propagates to trace_surfaceflags
|
|
unsigned int surfaceid; //the body reported to qc via trace_surface
|
|
unsigned int geomset;
|
|
unsigned int geomid;
|
|
float mindist;
|
|
float maxdist;
|
|
};
|
|
struct iqmext_fte_event
|
|
{
|
|
unsigned int anim;
|
|
float timestamp;
|
|
unsigned int evcode;
|
|
unsigned int evdata_str; //stringtable
|
|
};
|
|
static void CrossProduct_ (const vec3_t v1, const vec3_t v2, vec3_t cross)
|
|
{
|
|
cross[0] = v1[1]*v2[2] - v1[2]*v2[1];
|
|
cross[1] = v1[2]*v2[0] - v1[0]*v2[2];
|
|
cross[2] = v1[0]*v2[1] - v1[1]*v2[0];
|
|
}
|
|
static void Bone_To_PosQuat4(const float *matrix, float *pos, float *quat4, float *scale)
|
|
{ //I originally ripped this function out of DP. tweaked slightly.
|
|
//http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
|
|
float origininvscale = 1;
|
|
float origin[3];
|
|
float quat[4];
|
|
float quatscale;
|
|
|
|
float trace = matrix[0*4+0] + matrix[1*4+1] + matrix[2*4+2];
|
|
|
|
origin[0] = matrix[0*4+0];
|
|
origin[1] = matrix[1*4+0];
|
|
origin[2] = matrix[2*4+0];
|
|
scale [0] = sqrt(DotProduct(origin,origin));
|
|
origin[0] = matrix[0*4+1];
|
|
origin[1] = matrix[1*4+1];
|
|
origin[2] = matrix[2*4+1];
|
|
scale [1] = sqrt(DotProduct(origin,origin));
|
|
origin[1] = matrix[0*4+2];
|
|
origin[1] = matrix[1*4+2];
|
|
origin[2] = matrix[2*4+2];
|
|
scale [2] = sqrt(DotProduct(origin,origin));
|
|
|
|
origin[0] = matrix[0*4+3];
|
|
origin[1] = matrix[1*4+3];
|
|
origin[2] = matrix[2*4+3];
|
|
if(trace > 0)
|
|
{
|
|
float r = sqrt(1.0f + trace), inv = 0.5f / r;
|
|
quat[0] = (matrix[2*4+1] - matrix[1*4+2]) * inv;
|
|
quat[1] = (matrix[0*4+2] - matrix[2*4+0]) * inv;
|
|
quat[2] = (matrix[1*4+0] - matrix[0*4+1]) * inv;
|
|
quat[3] = 0.5f * r;
|
|
}
|
|
else if(matrix[0*4+0] > matrix[1*4+1] && matrix[0*4+0] > matrix[2*4+2])
|
|
{
|
|
float r = sqrt(1.0f + matrix[0*4+0] - matrix[1*4+1] - matrix[2*4+2]), inv = 0.5f / r;
|
|
quat[0] = 0.5f * r;
|
|
quat[1] = (matrix[1*4+0] + matrix[0*4+1]) * inv;
|
|
quat[2] = (matrix[0*4+2] + matrix[2*4+0]) * inv;
|
|
quat[3] = (matrix[2*4+1] - matrix[1*4+2]) * inv;
|
|
}
|
|
else if(matrix[1*4+1] > matrix[2*4+2])
|
|
{
|
|
float r = sqrt(1.0f + matrix[1*4+1] - matrix[0*4+0] - matrix[2*4+2]), inv = 0.5f / r;
|
|
quat[0] = (matrix[1*4+0] + matrix[0*4+1]) * inv;
|
|
quat[1] = 0.5f * r;
|
|
quat[2] = (matrix[2*4+1] + matrix[1*4+2]) * inv;
|
|
quat[3] = (matrix[0*4+2] - matrix[2*4+0]) * inv;
|
|
}
|
|
else
|
|
{
|
|
float r = sqrt(1.0f + matrix[2*4+2] - matrix[0*4+0] - matrix[1*4+1]), inv = 0.5f / r;
|
|
quat[0] = (matrix[0*4+2] + matrix[2*4+0]) * inv;
|
|
quat[1] = (matrix[2*4+1] + matrix[1*4+2]) * inv;
|
|
quat[2] = 0.5f * r;
|
|
quat[3] = (matrix[1*4+0] - matrix[0*4+1]) * inv;
|
|
}
|
|
// normalize quaternion so that it is unit length
|
|
quatscale = quat[0]*quat[0]+quat[1]*quat[1]+quat[2]*quat[2]+quat[3]*quat[3];
|
|
if (quatscale)
|
|
quatscale = (quat[3] >= 0 ? -1.0f : 1.0f) / sqrt(quatscale);
|
|
|
|
// use a negative scale on the quat because the above function produces a
|
|
// positive quat[3] and canonical quaternions have negative quat[3]
|
|
VectorScale(origin, origininvscale, pos);
|
|
Vector4Scale(quat, quatscale, quat4);
|
|
}
|
|
void Mod_ExportIQM(char *fname, int flags, galiasinfo_t *mesh)
|
|
{
|
|
int i, j, k;
|
|
vfsfile_t *f;
|
|
galiasinfo_t *m;
|
|
qbyte *data = NULL;
|
|
char *otext;
|
|
struct iqmvertexarray *ovarr;
|
|
struct iqmtriangle *otri;
|
|
struct iqmmesh *omesh;
|
|
struct iqmjoint2 *ojoint = NULL;
|
|
struct iqmanim *oanim = NULL;
|
|
struct iqmpose2 *opose = NULL;
|
|
struct
|
|
{
|
|
float min[10], max[10], scale[10];
|
|
int flags;
|
|
} *poseinfo = NULL, *pi; //per bone
|
|
struct
|
|
{ //pos3, quat4, scale3
|
|
float posquatscale[10]; //raw values, used to calibrate ranges
|
|
} *posedata = NULL, *pd; //per bone*joint
|
|
avec4_t *ivert;
|
|
vec2_t *ist;
|
|
vec3_t *overt;
|
|
vec3_t *onorm = NULL;
|
|
vec4_t *otang = NULL;
|
|
vec2_t *ost;
|
|
bone_vec4_t *oboneidx = NULL;
|
|
byte_vec4_t *oboneweight = NULL;
|
|
unsigned short *oposedata = NULL;
|
|
struct iqmheader hdr = {IQM_MAGIC, IQM_VERSION2}, *oh;
|
|
hdr.flags = flags;
|
|
hdr.num_vertexarrays = 4;
|
|
hdr.num_triangles = 0;
|
|
hdr.ofs_adjacency = 0; //noone actually uses this...
|
|
hdr.num_poses = 0;
|
|
// hdr.ofs_poses = 0;
|
|
hdr.num_anims = 0;
|
|
// hdr.ofs_anims = 0;
|
|
hdr.num_frames = 0;
|
|
hdr.num_framechannels = 0;
|
|
// hdr.ofs_frames = 0;
|
|
// hdr.ofs_bounds = 0;
|
|
hdr.num_comment = 0;
|
|
// hdr.ofs_comment = 0;
|
|
hdr.num_extensions = 0;
|
|
// hdr.ofs_extensions = 0;
|
|
|
|
|
|
hdr.num_joints = mesh->numbones;
|
|
if (hdr.num_joints)
|
|
{
|
|
float *matrix;
|
|
hdr.num_vertexarrays+= 2;
|
|
hdr.num_anims = mesh->numanimations;
|
|
for (i = 0; i < hdr.num_anims; i++)
|
|
{
|
|
hdr.num_text += strlen(mesh->ofsanimations[i].name)+1;
|
|
hdr.num_frames += mesh->ofsanimations[i].numposes;
|
|
}
|
|
if (hdr.num_frames)
|
|
{
|
|
poseinfo = malloc(sizeof(*poseinfo)*hdr.num_joints);
|
|
hdr.num_poses = hdr.num_joints;
|
|
posedata = malloc(sizeof(*posedata)*hdr.num_joints*hdr.num_poses);
|
|
//pull out the raw data and convert to the quats that we need
|
|
for (i = 0, pd = posedata; i < hdr.num_anims; i++)
|
|
for (j = 0, matrix = mesh->ofsanimations[i].boneofs; j < mesh->ofsanimations[i].numposes; j++)
|
|
for (k = 0; k < hdr.num_joints; k++)
|
|
{
|
|
Bone_To_PosQuat4(matrix, &pd->posquatscale[0], &pd->posquatscale[3], &pd->posquatscale[7]);
|
|
pd++;
|
|
matrix+=12;
|
|
}
|
|
//now figure out each poseinfo's min+max
|
|
for (i = 0, pi = poseinfo; i < hdr.num_joints; i++, pi++)
|
|
for (j = 0, pd = posedata+i; j < hdr.num_poses; j++, pd+=hdr.num_joints)
|
|
for (k = 0; k < 10; k++)
|
|
{
|
|
if (!i || pd->posquatscale[k] < pi->min[k])
|
|
pi->min[k] = pd->posquatscale[k];
|
|
if (!i || pi[i].max[k] < pd->posquatscale[k])
|
|
pi->max[k] = pd->posquatscale[k];
|
|
}
|
|
//figure out the offset+range+flags
|
|
for (i = 0, pi = poseinfo; i < hdr.num_joints; i++, pi++)
|
|
for (k = 0; k < 10; k++)
|
|
{
|
|
pi->scale[k] = pi->max[k]-pi->min[k];
|
|
if (pi->scale[k] < 1e-10f)
|
|
; //total range is tiny and won't make any real difference, drop this channel for a small saving.
|
|
else
|
|
{
|
|
pi->scale[k] /= 0xffffu; //compensate for the datatype's max
|
|
pi->flags |= 1u<<k;
|
|
hdr.num_framechannels++;
|
|
}
|
|
}
|
|
hdr.num_framechannels *= hdr.num_frames; //there'll be one for each pose*channel*frame
|
|
}
|
|
}
|
|
hdr.num_text += hdr.num_joints*32; //gah
|
|
|
|
//count needed data
|
|
for (m = mesh; m; m = m->nextsurf)
|
|
{
|
|
//can't handle the surface if its verts are weird.
|
|
if (m->shares_verts && m->shares_verts != hdr.num_meshes)
|
|
continue;
|
|
//can only handle one set of bones.
|
|
if (m->shares_bones != 0)
|
|
continue;
|
|
//and must have the same number of bones.
|
|
if (hdr.num_joints != m->numbones)
|
|
continue;
|
|
|
|
hdr.num_text += strlen(m->surfacename)+1;
|
|
if (m->ofsskins && m->ofsskins->frame)
|
|
hdr.num_text += strlen(m->ofsskins->frame->shadername)+1;
|
|
hdr.num_triangles += m->numindexes/3;
|
|
hdr.num_vertexes += m->numverts;
|
|
hdr.num_meshes++;
|
|
}
|
|
|
|
//allocate our output buffer
|
|
#define ALLOCSPACE hdr.filesize = 0; \
|
|
ALLOC(oh, sizeof(*oh)); \
|
|
ALLOC(otext, sizeof(*otext)*hdr.num_text); \
|
|
ALLOC(ovarr, sizeof(*ovarr)*hdr.num_vertexarrays); \
|
|
ALLOC(otri, sizeof(*otri)*hdr.num_triangles); \
|
|
ALLOC(overt, sizeof(*overt)*hdr.num_vertexes); \
|
|
ALLOC(ost, sizeof(*ost)*hdr.num_vertexes); \
|
|
if (mesh->ofs_skel_norm) {ALLOC(onorm, sizeof(*onorm)*hdr.num_vertexes);} \
|
|
if (mesh->ofs_skel_svect && mesh->ofs_skel_tvect) {ALLOC(otang, sizeof(*otang)*hdr.num_vertexes);} \
|
|
if (hdr.num_joints) {ALLOC(oboneweight, sizeof(*oboneweight)*hdr.num_vertexes);} \
|
|
if (hdr.num_joints) {ALLOC(oboneidx, sizeof(*oboneidx)*hdr.num_vertexes);} \
|
|
if (hdr.num_joints) {ALLOC(ojoint, sizeof(*ojoint)*hdr.num_joints);} \
|
|
if (hdr.num_anims) {ALLOC(oanim, sizeof(*oanim)*hdr.num_anims);} \
|
|
if (hdr.num_poses) {ALLOC(opose, sizeof(*opose)*hdr.num_poses);} \
|
|
if (hdr.num_framechannels) {ALLOC(oposedata, sizeof(*oposedata)*hdr.num_framechannels);} \
|
|
ALLOC(omesh, sizeof(*omesh)*hdr.num_meshes);
|
|
#define ALLOC(p,s) p=(void*)(data+hdr.filesize);hdr.filesize+=s;
|
|
ALLOCSPACE; //figure out how much space we need
|
|
data = malloc(hdr.filesize);
|
|
memset(data, 0xFE, hdr.filesize);
|
|
ALLOCSPACE; //and assign everything to the right offsets.
|
|
#undef ALLOC
|
|
#undef ALLOCSPACE
|
|
|
|
//copy over the preliminary header
|
|
*oh = hdr;
|
|
|
|
#define hdr hdr
|
|
|
|
if (omesh) oh->ofs_meshes = (qbyte*)omesh-data;
|
|
if (otext) oh->ofs_text = (qbyte*)otext-data;
|
|
if (ovarr) oh->ofs_vertexarrays = (qbyte*)ovarr-data;
|
|
if (otri) oh->ofs_triangles = (qbyte*)otri-data;
|
|
if (ojoint) oh->ofs_joints = (qbyte*)ojoint-data;
|
|
if (opose) oh->ofs_poses = (qbyte*)opose-data;
|
|
if (oposedata) oh->ofs_frames = (qbyte*)oposedata-data;
|
|
if (oanim) oh->ofs_anims = (qbyte*)oanim-data;
|
|
|
|
//set up vertex array data. we might add some padding here, in case the extra data isn't availble.
|
|
memset(ovarr, 0, sizeof(*ovarr)*oh->num_vertexarrays);
|
|
oh->num_vertexarrays=0;
|
|
ovarr->type = IQM_POSITION;
|
|
ovarr->flags = 0;
|
|
ovarr->format = IQM_FLOAT;
|
|
ovarr->size = 3;
|
|
ovarr->offset = (qbyte*)overt - data;
|
|
ovarr++;
|
|
oh->num_vertexarrays++;
|
|
|
|
ovarr->type = IQM_TEXCOORD;
|
|
ovarr->flags = 0;
|
|
ovarr->format = IQM_FLOAT;
|
|
ovarr->size = 2;
|
|
ovarr->offset = (qbyte*)ost - data;
|
|
ovarr++;
|
|
oh->num_vertexarrays++;
|
|
|
|
if (onorm)
|
|
{
|
|
ovarr->type = IQM_NORMAL;
|
|
ovarr->flags = 0;
|
|
ovarr->format = IQM_FLOAT;
|
|
ovarr->size = 3;
|
|
ovarr->offset = (qbyte*)onorm - data;
|
|
ovarr++;
|
|
oh->num_vertexarrays++;
|
|
}
|
|
if (otang)
|
|
{
|
|
ovarr->type = IQM_TANGENT;
|
|
ovarr->flags = 0;
|
|
ovarr->format = IQM_FLOAT;
|
|
ovarr->size = 4;
|
|
ovarr->offset = (qbyte*)otang - data;
|
|
ovarr++;
|
|
oh->num_vertexarrays++;
|
|
}
|
|
if (oboneidx)
|
|
{
|
|
ovarr->type = IQM_BLENDINDEXES;
|
|
ovarr->flags = 0;
|
|
ovarr->format = (MAX_BONES>65536)?IQM_UINT:((MAX_BONES>256)?IQM_USHORT:IQM_UBYTE);
|
|
ovarr->size = 4;
|
|
ovarr->offset = (qbyte*)oboneidx - data;
|
|
ovarr++;
|
|
oh->num_vertexarrays++;
|
|
}
|
|
if (oboneweight)
|
|
{
|
|
ovarr->type = IQM_BLENDWEIGHTS;
|
|
ovarr->flags = 0;
|
|
ovarr->format = IQM_BYTE;
|
|
ovarr->size = 4;
|
|
ovarr->offset = (qbyte*)oboneweight - data;
|
|
ovarr++;
|
|
oh->num_vertexarrays++;
|
|
}
|
|
/*if (orgba)
|
|
{
|
|
ovarr->type = IQM_COLOR;
|
|
ovarr->flags = 0;
|
|
ovarr->format = IQM_FLOAT;
|
|
ovarr->size = 4;
|
|
ovarr->offset = (qbyte*)orgba - data;
|
|
ovarr++;
|
|
oh->num_vertexarrays++;
|
|
}*/
|
|
|
|
if (ojoint)
|
|
{
|
|
for (i = 0; i < hdr.num_joints; i++)
|
|
{
|
|
ojoint[i].parent = mesh->ofsbones[i].parent;
|
|
ojoint[i].name = (qbyte*)otext-(data+oh->ofs_text);
|
|
strcpy(otext, mesh->ofsbones[i].name);
|
|
otext += strlen(otext)+1;
|
|
|
|
Bone_To_PosQuat4(mesh->ofsbones[i].inverse, ojoint[i].translate, ojoint[i].rotate, ojoint[i].scale);
|
|
}
|
|
}
|
|
if (opose)
|
|
{
|
|
int c;
|
|
for (i = 0, pi=poseinfo; i < hdr.num_joints; i++, pi++)
|
|
{
|
|
opose[i].parent = mesh->ofsbones[i].parent;
|
|
opose[i].mask = pi->flags;
|
|
for (k = 0; k < 10; k++)
|
|
{
|
|
opose[i].channeloffset[k] = pi->min[k];
|
|
opose[i].channelscale[k] = pi->scale[k];
|
|
}
|
|
|
|
for (j = 0, pd = posedata+i; j < hdr.num_frames; j++, pd+=hdr.num_joints)
|
|
{
|
|
for (k = 0; k < 10; k++)
|
|
{
|
|
if (opose[i].mask & (1<<k))
|
|
{
|
|
c = (pd->posquatscale[k]-pi->min[k])/pi->scale[k];
|
|
c = bound(0, c, 0xffff); //clamp it just in case (floats can be annoying)
|
|
*oposedata++ = c;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (oposedata)
|
|
{
|
|
for (i = 0; i < hdr.num_joints; i++)
|
|
{
|
|
opose[i].parent = mesh->ofsbones[i].parent;
|
|
opose[i].mask = poseinfo[i].flags;
|
|
for (k = 0; k < 10; k++)
|
|
{
|
|
opose[i].channeloffset[k] = poseinfo[i].min[k];
|
|
opose[i].channelscale[k] = poseinfo[i].scale[k];
|
|
}
|
|
}
|
|
}
|
|
|
|
hdr.num_frames = 0;
|
|
for (i = 0; i < hdr.num_anims; i++, oanim++)
|
|
{
|
|
oanim->first_frame = hdr.num_frames;
|
|
oanim->num_frames = mesh->ofsanimations[i].numposes;
|
|
oanim->framerate = mesh->ofsanimations[i].rate;
|
|
oanim->flags = mesh->ofsanimations[i].loop?IQM_LOOP:0;
|
|
oanim->name = (qbyte*)otext-(data+oh->ofs_text);
|
|
strcpy(otext, mesh->ofsanimations[i].name);
|
|
otext += strlen(otext)+1;
|
|
hdr.num_frames += mesh->ofsanimations[i].numposes;
|
|
}
|
|
oh->num_anims = i;
|
|
oh->num_frames = hdr.num_frames;
|
|
|
|
//count needed data
|
|
hdr.num_triangles = 0;
|
|
hdr.num_vertexes = 0;
|
|
for (m = mesh; m; m = m->nextsurf)
|
|
{
|
|
//can't handle the surface if its verts are weird.
|
|
if (m->shares_verts && m->shares_verts != hdr.num_meshes)
|
|
continue;
|
|
//can only handle one set of bones.
|
|
if (m->shares_bones != 0)
|
|
continue;
|
|
if (hdr.num_joints != m->numbones)
|
|
continue;
|
|
|
|
omesh->name = (qbyte*)otext-(data+oh->ofs_text);
|
|
strcpy(otext, m->surfacename);
|
|
otext += strlen(otext)+1;
|
|
|
|
omesh->material = (qbyte*)otext-(data+oh->ofs_text);
|
|
if (m->ofsskins && m->ofsskins->frame)
|
|
strcpy(otext, m->ofsskins->frame->shadername);
|
|
else
|
|
strcpy(otext, "");
|
|
otext += strlen(otext)+1;
|
|
|
|
omesh->first_vertex = hdr.num_vertexes;
|
|
omesh->num_vertexes = m->numverts;
|
|
omesh->first_triangle = hdr.num_triangles;
|
|
omesh->num_triangles = m->numindexes/3;
|
|
|
|
if (m->ofs_skel_xyz)
|
|
ivert = m->ofs_skel_xyz;
|
|
#ifdef NONSKELETALMODELS
|
|
else if (m->numanimations && m->ofsanimations->numposes)
|
|
ivert = m->ofsanimations->poseofs->ofsverts;
|
|
#endif
|
|
else
|
|
ivert = NULL;
|
|
if (ivert)
|
|
{
|
|
for (i = 0; i < omesh->num_vertexes; i++)
|
|
VectorCopy (ivert[i], overt[i]);
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < omesh->num_vertexes; i++)
|
|
VectorClear (overt[i]);
|
|
|
|
}
|
|
overt += i;
|
|
|
|
if (oboneidx)
|
|
{
|
|
bone_vec4_t *iidx = m->ofs_skel_idx;
|
|
vec4_t *iweight = m->ofs_skel_weight;
|
|
for (i = 0; i < omesh->num_vertexes; i++)
|
|
{
|
|
Vector4Copy(iidx[i], oboneidx[i]);
|
|
Vector4Scale(iweight[i], 255, oboneweight[i]);
|
|
}
|
|
oboneidx += i;
|
|
oboneweight += i;
|
|
}
|
|
|
|
if (ost)
|
|
{
|
|
ist = m->ofs_st_array;
|
|
for (i = 0; i < omesh->num_vertexes; i++)
|
|
Vector2Copy(ist[i], ost[i]);
|
|
ost += i;
|
|
}
|
|
|
|
if (onorm)
|
|
{
|
|
vec3_t *inorm, *isdir, *itdir, t;
|
|
if (m->ofs_skel_norm)
|
|
{
|
|
inorm = m->ofs_skel_norm;
|
|
isdir = m->ofs_skel_svect;
|
|
itdir = m->ofs_skel_tvect;
|
|
}
|
|
#ifdef NONSKELETALMODELS
|
|
else if (m->numanimations && m->ofsanimations->numposes)
|
|
{
|
|
inorm = m->ofsanimations->poseofs->ofsnormals;
|
|
isdir = m->ofsanimations->poseofs->ofssvector;
|
|
itdir = m->ofsanimations->poseofs->ofstvector;
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
inorm = NULL;
|
|
isdir = NULL;
|
|
itdir = NULL;
|
|
}
|
|
if (otang)
|
|
{
|
|
if (inorm && isdir && itdir)
|
|
{
|
|
for (i = 0; i < omesh->num_vertexes; i++)
|
|
{
|
|
VectorCopy (isdir[i], otang[i]);
|
|
CrossProduct_(isdir[i], inorm[i], t);
|
|
otang[i][3] = DotProduct(itdir[i], t)<0; //fourth part is simply a flag that says which direction the bitangent is in, should otherwise be a nice crossproduct result.
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < omesh->num_vertexes; i++)
|
|
{
|
|
VectorClear (otang[i]);
|
|
otang[i][3] = 0;
|
|
}
|
|
}
|
|
otang += i;
|
|
}
|
|
if (inorm)
|
|
{
|
|
for (i = 0; i < omesh->num_vertexes; i++)
|
|
VectorCopy (ivert[i], onorm[i]);
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < omesh->num_vertexes; i++)
|
|
VectorClear (onorm[i]);
|
|
}
|
|
otang += i;
|
|
onorm += i;
|
|
}
|
|
|
|
for (i = 0; i < omesh->num_triangles; i++)
|
|
{
|
|
otri[i].vertex[0] = m->ofs_indexes[i*3+0]+hdr.num_vertexes;
|
|
otri[i].vertex[1] = m->ofs_indexes[i*3+1]+hdr.num_vertexes;
|
|
otri[i].vertex[2] = m->ofs_indexes[i*3+2]+hdr.num_vertexes;
|
|
}
|
|
otri += i;
|
|
|
|
hdr.num_vertexes += omesh->num_vertexes;
|
|
hdr.num_triangles += omesh->num_triangles;
|
|
}
|
|
|
|
//and write it out
|
|
f = filefuncs->OpenVFS(fname, "wb", FS_GAMEONLY);
|
|
if (f)
|
|
{
|
|
VFS_WRITE(f, oh, oh->filesize);
|
|
VFS_CLOSE(f);
|
|
}
|
|
free(data);
|
|
free(poseinfo);
|
|
#undef hdr
|
|
}
|