team-fte
/
fteqw
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
fteqw/engine/gl/gl_hlmdl.c

2316 lines
71 KiB
C
Raw Blame History

#include "quakedef.h"
#ifdef HALFLIFEMODELS
#include "shader.h"
#include "com_mesh.h"
#ifdef MODELFMT_HL2
/*
Half-Life 2 / Source models store much of their data in other files.
I'm only going to try loading simple static models, so we don't need much data from the .mdl itself.
FIXME: multiple meshes are still buggy.
FIXME: materials are not loaded properly.
FIXME: no lod stuff.
*/
typedef struct
{
unsigned int magic;
unsigned int version;
unsigned int revisionid;
char name[64];
unsigned int filesize;
vec3_t _80;
vec3_t _92;
vec3_t mins;
vec3_t maxs;
vec3_t _128;
vec3_t _140;
unsigned int _152;
unsigned int _156;
unsigned int _160;
unsigned int _164;
unsigned int _168;
unsigned int _172;
unsigned int _176;
unsigned int _180;
unsigned int _184;
unsigned int _188;
unsigned int _192;
unsigned int _196;
unsigned int _200;
unsigned int tex_count;
unsigned int tex_ofs;
unsigned int texpath_count;
unsigned int texpath_ofs;
unsigned int texbind_count; //N slots per skin
unsigned int skin_count;
unsigned int texbind_offset;//provides skin|slot->texture mappings
unsigned int body_count;
unsigned int body_ofs;
//other stuff?
} hl2mdlheader_t;
typedef struct
{
unsigned int name_ofs;
unsigned int surf_count;
unsigned int base;
unsigned int surf_ofs;
} hl2mdlbody_t;
typedef struct
{
char name[64];
unsigned int type;
unsigned int radius;
unsigned int mesh_count;
unsigned int mesh_ofs;
unsigned int vertex_count;
unsigned int _84;
unsigned int _88;
unsigned int _92;
unsigned int _96;
unsigned int _100;
unsigned int _104;
unsigned int _108;
unsigned int _112;
unsigned int _116;
unsigned int _120;
unsigned int _124;
unsigned int _128;
unsigned int _132;
unsigned int _136;
unsigned int _140;
unsigned int _144;
} hl2mdlsurf_t;
typedef struct
{
unsigned int mat_idx;
unsigned int model_ofs;
unsigned int vert_count;
unsigned int vert_first;
unsigned int _16;
unsigned int _20;
unsigned int _24;
unsigned int _28;
unsigned int _32;
unsigned int _36;
unsigned int _40;
unsigned int _44;
unsigned int _48;
unsigned int _52;
unsigned int _56;
unsigned int _60;
unsigned int _64;
unsigned int _68;
unsigned int _72;
unsigned int _76;
unsigned int _80;
unsigned int _84;
unsigned int _88;
unsigned int _92;
unsigned int _96;
unsigned int _100;
unsigned int _104;
unsigned int _108;
unsigned int _112;
} hl2mdlmesh_t;
typedef struct
{
unsigned int nameofs;
unsigned int _4;
unsigned int _8;
unsigned int _12;
unsigned int _16;
unsigned int _20;
unsigned int _24;
unsigned int _28;
unsigned int _32;
unsigned int _36;
unsigned int _40;
unsigned int _44;
unsigned int _48;
unsigned int _52;
unsigned int _56;
unsigned int _60;
} hl2mdltexture_t;
typedef struct
{
unsigned int nameofs;
} hl2mdltexturepath_t;
#pragma pack(push,1) //urgh wtf is this bullshit
typedef struct
{
unsigned int numskins;
unsigned int offsetskin;
} hl2vtxskins_t;
typedef struct
{
unsigned short foo;
//no padding
unsigned int offsetskinname;
} hl2vtxskin_t;
typedef struct
{
unsigned int version;
unsigned int vertcachesize;
unsigned short bonesperstrip;
unsigned short bonespertri;
unsigned int bonespervert;
unsigned int revisionid;
unsigned int lod_count;
unsigned int texreplacements_offset;
unsigned int body_count;
unsigned int body_ofs;
} hl2vtxheader_t;
typedef struct
{
unsigned int surf_count;
unsigned int surf_ofs;
} hl2vtxbody_t;
typedef struct
{
unsigned int lod_count;
unsigned int lod_ofs;
} hl2vtxsurf_t;
typedef struct
{
unsigned int mesh_count;
unsigned int mesh_ofs;
float dist;
} hl2vtxlod_t;
typedef struct
{
unsigned int stripg_count;
unsigned int stripg_ofs;
unsigned char flags;
//no padding (3 bytes)
} hl2vtxmesh_t;
typedef struct
{
unsigned int vert_count;
unsigned int vert_ofs;
unsigned int idx_count;
unsigned int idx_ofs;
unsigned int strip_count;
unsigned int strip_ofs;
unsigned char flags;
//no padding (3 bytes)
} hl2vtxstripg_t;
typedef struct
{
unsigned int idx_num;
unsigned int idx_ofs;
unsigned int vert_count;
unsigned int vert_ofs;
unsigned short bone_count;
unsigned char flags;
//no padding (1 byte)
unsigned int bonestate_count;
unsigned int bonestate_ofs;
} hl2vtxstrip_t;
typedef struct
{
qbyte bone[3];
qbyte bone_count;
unsigned short vert;
qbyte boneID[3];
//no padding
} hl2vtxvert_t;
typedef struct
{
unsigned int magic;
unsigned int version;
unsigned int revisionid;
unsigned int lod_count;
unsigned int lodverts_count[8];
unsigned int fixups_count;
unsigned int fixups_offset;
unsigned int verts_offset;
unsigned int tangents_offset;
} hl2vvdheader_t;
typedef struct
{
unsigned int lod;
unsigned int sourcevert;
unsigned int numverts;
} hl2vvdfixup_t;
typedef struct
{
float weight[3];
qbyte bone[3];
qbyte numbones;
vec3_t xyz;
vec3_t norm;
vec2_t st;
} hl2vvdvert_t;
#pragma pack(pop)
/*seriously, how many structs do you need?*/
typedef struct
{
model_t *mod;
unsigned numverts;
vec2_t *ofs_st_array;
vecV_t *ofs_skel_xyz;
vec3_t *ofs_skel_norm;
vec3_t *ofs_skel_svect;
vec3_t *ofs_skel_tvect;
// byte_vec4_t *ofs_skel_idx;
// vec4_t *ofs_skel_weight;
struct
{
unsigned int numfixups;
index_t *fixup;
} lod[1]; //must remain at 1 (instead of 8) until fixups are handled.
} hl2parsecontext_t;
static index_t *Mod_HL2_LoadIndexes(hl2parsecontext_t *ctx, unsigned int *idxcount, const hl2vtxmesh_t *vmesh, unsigned int lod, index_t firstindex)
{
size_t numidx = 0, g;
const hl2vtxstripg_t *vg;
index_t *idx, *ret = NULL;
vg = (const void*)((const qbyte*)vmesh+vmesh->stripg_ofs);
for (g = 0; g < vmesh->stripg_count; g++, vg++)
{
if (vg->idx_count%3)
{
*idxcount = 0;
return NULL;
}
numidx += vg->idx_count;
}
ret = idx = ZG_Malloc(&ctx->mod->memgroup, sizeof(*idx)*numidx);
vg = (const void*)((const qbyte*)vmesh+vmesh->stripg_ofs);
for (g = 0; g < vmesh->stripg_count; g++, vg++)
{
const unsigned short *in = (const void*)((const qbyte*)vg+vg->idx_ofs);
const unsigned short *e = in+vg->idx_count;
const hl2vtxvert_t *v = (const void*)((const qbyte*)vg+vg->vert_ofs);
if (ctx->lod[lod].numfixups)
{
index_t *fixup = ctx->lod[lod].fixup;
for(;;)
{
if (in == e)
break;
*idx++ = fixup[v[*in++].vert+firstindex];
}
}
else
{
for(;;)
{
if (in == e)
break;
*idx++ = v[*in++].vert+firstindex;
}
}
}
*idxcount = idx-ret;
return ret;
}
static qboolean Mod_HL2_LoadVTX(hl2parsecontext_t *ctx, const void *buffer, size_t fsize, unsigned int rev, const hl2mdlheader_t *mdl)
{ //horribly overcomplicated way to express this stuff.
size_t totalsurfs = 0, b, s, l, m;
const hl2vtxheader_t *header = buffer;
const hl2vtxbody_t *vbody;
const hl2vtxsurf_t *vsurf;
const hl2vtxlod_t *vlod;
const hl2vtxmesh_t *vmesh;
// const hl2vtxskins_t *vskins;
// const hl2vtxskin_t *vskin;
const hl2mdlbody_t *mbody = (const hl2mdlbody_t*)((const qbyte*)mdl + mdl->body_ofs);
galiasinfo_t *surf=NULL;
#ifdef HAVE_CLIENT
size_t t;
const hl2mdltexture_t *mtex = (const hl2mdltexture_t*)((const qbyte*)mdl + mdl->tex_ofs);
const unsigned short *skinbind;
galiasskin_t *skin;
skinframe_t *skinframe;
#endif
size_t firstvert = 0;
if (fsize < sizeof(*header) || header->version != 7 || header->revisionid != rev || header->body_count == 0)
return false;
vbody = (const void*)((const qbyte*)header + header->body_ofs);
for (b = 0; b < header->body_count; b++, vbody++)
{
vsurf = (const void*)((const qbyte*)vbody + vbody->surf_ofs);
for (s = 0; s < vbody->surf_count; s++, vsurf++)
{
vlod = (const void*)((const qbyte*)vsurf + vsurf->lod_ofs);
for (l = 0; l < min(vsurf->lod_count, countof(ctx->lod)); l++, vlod++)
totalsurfs += vlod->mesh_count;
}
}
if (!totalsurfs)
return false;
ctx->mod->meshinfo = surf = ZG_Malloc(&ctx->mod->memgroup, sizeof(*surf)*totalsurfs);
#ifdef HAVE_CLIENT
t = mdl->skin_count*mdl->texbind_count;
skinbind = (const unsigned short*)((const qbyte*)mdl+mdl->texbind_offset);
skin = ZG_Malloc(&ctx->mod->memgroup, sizeof(*skin)*t + sizeof(*skinframe)*t);
skinframe = (skinframe_t*)(skin+t);
for (s = 0; s < mdl->skin_count; s++)
for (t = 0; t < mdl->texbind_count; t++)
{
galiasskin_t *ns = &skin[s + t*mdl->skin_count];
Q_snprintfz(ns->name, sizeof(ns->name), "skin%u %u", (unsigned)s, (unsigned)t);
m = *skinbind++;
if (mdl->texpath_count)
{
const hl2mdltexturepath_t *mpath = (const hl2mdltexturepath_t*)((const qbyte*)mdl + mdl->texpath_ofs);
Q_strncpyz(skinframe->shadername, (const char*)mdl+mpath->nameofs, sizeof(skinframe->shadername));
}
else
{
COM_StripExtension((const char*)ctx->mod->name, skinframe->shadername, sizeof(skinframe->shadername));
Q_strncatz(skinframe->shadername, "/", sizeof(skinframe->shadername));
}
Q_strncatz(skinframe->shadername, (const char*)&mtex[m]+mtex[m].nameofs, sizeof(skinframe->shadername));
Q_strncatz(skinframe->shadername, ".vmt", sizeof(skinframe->shadername));
ns->numframes = 1; //no skingroups... not that kind anyway.
ns->skinspeed = 10;
ns->frame = skinframe;
skinframe++;
}
#endif
vbody = (const void*)((const qbyte*)header + header->body_ofs);
for (b = 0; b < header->body_count; b++, vbody++, mbody++)
{
const hl2mdlsurf_t *msurf = (const hl2mdlsurf_t*)((const qbyte*)mbody + mbody->surf_ofs);
vsurf = (const void*)((const qbyte*)vbody + vbody->surf_ofs);
for (s = 0; s < vbody->surf_count; s++, vsurf++, msurf++)
{
vlod = (const void*)((const qbyte*)vsurf + vsurf->lod_ofs);
// vskins = (const hl2vtxskins_t*)((const qbyte*)header + header->texreplacements_offset);
for (l = 0; l < min(vsurf->lod_count, countof(ctx->lod)); l++, vlod++/*, vskins++*/)
{
const hl2mdlmesh_t *mmesh = (const hl2mdlmesh_t*)((const qbyte*)msurf + msurf->mesh_ofs);
vmesh = (const void*)((const qbyte*)vlod + vlod->mesh_ofs);
for (m = 0; m < vlod->mesh_count; m++, vmesh++, mmesh++)
{
Q_snprintfz(surf->surfacename, sizeof(surf->surfacename), "%s:%s:l%u:m%u", (const char*)mbody+mbody->name_ofs, msurf->name, (unsigned)l, (unsigned)m);
/*animation info*/
surf->shares_bones = 0;
surf->numbones = 0;
surf->ofsbones = NULL; //no support for animations...
surf->numanimations = 0;
surf->ofsanimations = NULL; //we have no animation data
#ifndef SERVERONLY
/*skin data*/
surf->numskins = mdl->skin_count;
surf->ofsskins = skin+mmesh->mat_idx*mdl->skin_count;
/*vertdata*/
surf->ofs_rgbaf = NULL;
surf->ofs_rgbaub = NULL;
surf->ofs_st_array = ctx->ofs_st_array;
#endif
surf->shares_verts = 0;
surf->numverts = ctx->numverts;
surf->ofs_skel_xyz = ctx->ofs_skel_xyz;
surf->ofs_skel_norm = ctx->ofs_skel_norm;
surf->ofs_skel_svect = ctx->ofs_skel_svect;
surf->ofs_skel_tvect = ctx->ofs_skel_tvect;
//surf->ofs_skel_idx = ctx->ofs_skel_idx;
//surf->ofs_skel_weight = ctx->ofs_skel_weight;
/*index data*/
if (mmesh->vert_first+mmesh->vert_count > surf->numverts)
surf->ofs_indexes = NULL, surf->numindexes = 0; //erk?
else
surf->ofs_indexes = Mod_HL2_LoadIndexes(ctx, &surf->numindexes, vmesh, l, firstvert+mmesh->vert_first);
/*misc data*/
surf->geomset = 0;
surf->geomid = 0;
surf->contents = FTECONTENTS_BODY;
surf->csurface.flags = 0;
surf->surfaceid = 0;
surf->mindist = 0;
surf->maxdist = 0;
if (surf != ctx->mod->meshinfo)
surf[-1].nextsurf = surf;
surf->nextsurf = NULL;
surf++;
}
}
firstvert += msurf->vertex_count;
}
}
if (surf == ctx->mod->meshinfo)
return false;
return true;
}
static qboolean Mod_HL2_LoadVVD(hl2parsecontext_t *ctx, const void *buffer, size_t fsize, unsigned int rev)
{
const hl2vvdheader_t *header = buffer;
size_t lod;
const hl2vvdvert_t *in;
const vec4_t *it;
if (fsize < sizeof(*header) || header->magic != (('I'<<0)|('D'<<8)|('S'<<16)|('V'<<24)) || header->version != 4 || header->revisionid != rev || header->lodverts_count[0] == 0)
return false;
{
size_t v, numverts = ctx->numverts = header->lodverts_count[0];
vec2_t *st = ctx->ofs_st_array = ZG_Malloc(&ctx->mod->memgroup, sizeof(*st)*numverts);
vecV_t *xyz = ctx->ofs_skel_xyz = ZG_Malloc(&ctx->mod->memgroup, sizeof(*xyz)*numverts);
vec3_t *norm = ctx->ofs_skel_norm = ZG_Malloc(&ctx->mod->memgroup, sizeof(*norm)*numverts);
vec3_t *sdir = ctx->ofs_skel_svect = ZG_Malloc(&ctx->mod->memgroup, sizeof(*sdir)*numverts);
vec3_t *tdir = ctx->ofs_skel_tvect = ZG_Malloc(&ctx->mod->memgroup, sizeof(*tdir)*numverts);
// byte_vec4_t *bone = ctx->lod[lod].ofs_skel_idx = ZG_Malloc(&ctx->mod->memgroup, sizeof(*bone)*numverts);
// vec4_t *weight = ctx->lod[lod].ofs_skel_weight = ZG_Malloc(&ctx->mod->memgroup, sizeof(*weight)*numverts);
in = (const void*)((const char*)buffer+header->verts_offset);
it = (const void*)((const char*)buffer+header->tangents_offset);
for(v = 0; v < numverts; v++, in++, it++)
{
Vector2Copy(in->st, st[v]);
VectorCopy(in->xyz, xyz[v]);
VectorCopy(in->norm, norm[v]);
// VectorCopy(in->bone, bone[v]);
// bone[v][3] = bone[v][2]; //make sure its valid, and in cache.
// VectorCopy(in->weight, weight[v]);
// weight[v][3] = 0; //missing influences cannot influence.
//tangents are compacted, and for some reason in a different part of the file.
VectorCopy((*it), sdir[v]);
CrossProduct(in->norm, (*it), tdir[v]);
VectorScale(tdir[v], (*it)[3], tdir[v]);
}
}
if (header->fixups_count)
{
size_t fixups = header->fixups_count, f, v;
const hl2vvdfixup_t *fixup = (const hl2vvdfixup_t*)((const qbyte*)header+header->fixups_offset);
for (lod = 0; lod < countof(ctx->lod) && lod < header->lod_count; lod++)
{
size_t numverts;
for (numverts=0, f = 0; f < fixups; f++)
{
if (fixup[f].lod >= lod)
numverts += fixup[f].numverts;
}
if (numverts != header->lodverts_count[lod])
continue;
ctx->lod[lod].numfixups = numverts;
ctx->lod[lod].fixup = ZG_Malloc(&ctx->mod->memgroup, sizeof(index_t)*numverts);
for (numverts=0, f = 0; f < fixups; f++)
{
if (fixup[f].lod >= lod)
for (v = 0; v < fixup[f].numverts; v++)
ctx->lod[lod].fixup[numverts++] = fixup[f].sourcevert+v;
}
}
}
return true;
}
qboolean QDECL Mod_LoadHL2Model (model_t *mod, const void *buffer, size_t fsize)
{
hl2parsecontext_t ctx = {mod};
const hl2mdlheader_t *header = buffer;
void *vtx = NULL, *vvd = NULL;
size_t vtxsize = 0, vvdsize = 0;
char base[MAX_QPATH];
qboolean result;
size_t i;
const char *vtxpostfixes[] = {
".dx90.vtx",
".dx80.vtx",
".vtx",
".sw.vtx"
};
const char *vvdpostfixes[] = {
".vvd"
};
for (i = 0; !vtx && i < countof(vtxpostfixes); i++)
{
COM_StripExtension(mod->name, base, sizeof(base));
Q_strncatz(base, vtxpostfixes[i], sizeof(base));
vtx = FS_LoadMallocFile(base, &vtxsize);
}
for (i = 0; !vvd && i < countof(vvdpostfixes); i++)
{
COM_StripExtension(mod->name, base, sizeof(base));
Q_strncatz(base, vvdpostfixes[i], sizeof(base));
vvd = FS_LoadMallocFile(base, &vvdsize);
}
result = Mod_HL2_LoadVVD(&ctx, vvd, vvdsize, header->revisionid);
result &= Mod_HL2_LoadVTX(&ctx, vtx, vtxsize, header->revisionid, header);
FS_FreeFile(vvd);
FS_FreeFile(vtx);
VectorCopy(header->mins, mod->mins);
VectorCopy(header->maxs, mod->maxs);
mod->radius = RadiusFromBounds(mod->mins, mod->maxs);
mod->type = mod_alias;
return result;
}
#endif
/*
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Half-Life Model Renderer (Experimental) Copyright (C) 2001 James 'Ender' Brown [ender@quakesrc.org] This program is
free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
details. You should have received a copy of the GNU General Public License along with this program; if not, write
to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. fromquake.h -
render.c - apart from calculations (mostly range checking or value conversion code is a mix of standard Quake 1
meshing, and vertex deforms. The rendering loop uses standard Quake 1 drawing, after SetupBones deforms the vertex.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Note: this code has since been greatly modified to fix skin, submodels, hitboxes, attachments, etc.
Also, please note that it won't do all hl models....
Nor will it work 100%
*/
qboolean HLMDL_Trace (struct model_s *model, int hulloverride, const framestate_t *framestate, const vec3_t axis[3], const vec3_t p1, const vec3_t p2, const vec3_t mins, const vec3_t maxs, qboolean capsule, unsigned int against, struct trace_s *trace);
unsigned int HLMDL_Contents (struct model_s *model, int hulloverride, const framestate_t *framestate, const vec3_t axis[3], const vec3_t p, const vec3_t mins, const vec3_t maxs);
void QuaternionGLMatrix(float x, float y, float z, float w, vec4_t *GLM)
{
GLM[0][0] = 1 - 2 * y * y - 2 * z * z;
GLM[1][0] = 2 * x * y + 2 * w * z;
GLM[2][0] = 2 * x * z - 2 * w * y;
GLM[0][1] = 2 * x * y - 2 * w * z;
GLM[1][1] = 1 - 2 * x * x - 2 * z * z;
GLM[2][1] = 2 * y * z + 2 * w * x;
GLM[0][2] = 2 * x * z + 2 * w * y;
GLM[1][2] = 2 * y * z - 2 * w * x;
GLM[2][2] = 1 - 2 * x * x - 2 * y * y;
}
/*
=======================================================================================================================
QuaternionGLAngle - Convert a GL angle to a quaternion matrix
=======================================================================================================================
*/
void QuaternionGLAngle(const vec3_t angles, vec4_t quaternion)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
float yaw = angles[2] * 0.5;
float pitch = angles[1] * 0.5;
float roll = angles[0] * 0.5;
float siny = sin(yaw);
float cosy = cos(yaw);
float sinp = sin(pitch);
float cosp = cos(pitch);
float sinr = sin(roll);
float cosr = cos(roll);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
quaternion[0] = sinr * cosp * cosy - cosr * sinp * siny;
quaternion[1] = cosr * sinp * cosy + sinr * cosp * siny;
quaternion[2] = cosr * cosp * siny - sinr * sinp * cosy;
quaternion[3] = cosr * cosp * cosy + sinr * sinp * siny;
}
matrix3x4 transform_matrix[MAX_BONES]; /* Vertex transformation matrix */
#ifndef SERVERONLY
void GL_Draw_HL_AliasFrame(short *order, vec3_t *transformed, float tex_w, float tex_h);
struct hlvremaps
{
unsigned short vertidx;
unsigned short normalidx;
unsigned short scoord;
unsigned short tcoord;
};
static index_t HLMDL_DeDupe(unsigned short *order, struct hlvremaps *rem, size_t *count, size_t first, size_t max)
{
size_t i;
for (i = *count; i-- > first;)
{
if (rem[i].vertidx == order[0] && rem[i].normalidx == order[1] && rem[i].scoord == order[2] && rem[i].tcoord == order[3])
return i;
}
i = *count;
if (i < max)
{
rem[i].vertidx = order[0];
rem[i].normalidx = order[1];
rem[i].scoord = order[2];
rem[i].tcoord = order[3];
}
*count += 1;
return i;
}
//parse the vertex info, pull out what we can
static void HLMDL_PrepareVerticies (model_t *mod, hlmodel_t *model)
{
struct hlvremaps *uvert;
size_t uvertcount=0, uvertstart;
unsigned short count;
int i;
size_t idx = 0, m, maxidx=65536*3;
size_t maxverts = 65536;
index_t *index;
mesh_t *mesh, *submesh;
int body;
uvert = malloc(sizeof(*uvert)*maxverts);
index = malloc(sizeof(byte_vec4_t)*maxidx);
model->numgeomsets = model->header->numbodyparts;
model->geomset = ZG_Malloc(&mod->memgroup, sizeof(*model->geomset) * model->numgeomsets);
for (body = 0; body < model->numgeomsets; body++)
{
hlmdl_bodypart_t *bodypart = (hlmdl_bodypart_t *) ((qbyte *) model->header + model->header->bodypartindex) + body;
int bodyindex;
model->geomset[body].numalternatives = bodypart->nummodels;
model->geomset[body].alternatives = ZG_Malloc(&mod->memgroup, sizeof(*model->geomset[body].alternatives) * bodypart->nummodels);
for (bodyindex = 0; bodyindex < bodypart->nummodels; bodyindex++)
{
hlmdl_submodel_t *amodel = (hlmdl_submodel_t *) ((qbyte *) model->header + bodypart->modelindex) + bodyindex;
struct hlalternative_s *submodel;
model->geomset[body].alternatives[bodyindex].numsubmeshes = amodel->nummesh;
model->geomset[body].alternatives[bodyindex].submesh = ZG_Malloc(&mod->memgroup, sizeof(*model->geomset[body].alternatives[bodyindex].submesh) * amodel->nummesh);
submodel = &model->geomset[body].alternatives[bodyindex];
for(m = 0; m < amodel->nummesh; m++)
{
hlmdl_mesh_t *inmesh = (hlmdl_mesh_t *) ((qbyte *) model->header + amodel->meshindex) + m;
unsigned short *order = (unsigned short *) ((qbyte *) model->header + inmesh->index);
uvertstart = uvertcount;
submodel->submesh[m].vbofirstvert = uvertstart;
submodel->submesh[m].vbofirstelement = idx;
submodel->submesh[m].numvertexes = 0;
submodel->submesh[m].numindexes = 0;
for(;;)
{
count = *order++; /* get the vertex count and primitive type */
if(!count) break; /* done */
if(count & 0x8000)
{ //fan
int first = HLMDL_DeDupe(order+0*4, uvert, &uvertcount, uvertstart, maxverts);
int prev = HLMDL_DeDupe(order+1*4, uvert, &uvertcount, uvertstart, maxverts);
count = (unsigned short)-(short)count;
if (idx + (count-2)*3 > maxidx)
break; //would overflow. fixme: extend
for (i = min(2,count); i < count; i++)
{
index[idx++] = first;
index[idx++] = prev;
index[idx++] = prev = HLMDL_DeDupe(order+i*4, uvert, &uvertcount, uvertstart, maxverts);
}
}
else
{
int v0 = HLMDL_DeDupe(order+0*4, uvert, &uvertcount, uvertstart, maxverts);
int v1 = HLMDL_DeDupe(order+1*4, uvert, &uvertcount, uvertstart, maxverts);
//emit (count-2)*3 indicies as a strip
//012 213, etc
if (idx + (count-2)*3 > maxidx)
break; //would overflow. fixme: extend
for (i = min(2,count); i < count; i++)
{
if (i & 1)
{
index[idx++] = v1;
index[idx++] = v0;
}
else
{
index[idx++] = v0;
index[idx++] = v1;
}
v0 = v1;
index[idx++] = v1 = HLMDL_DeDupe(order+i*4, uvert, &uvertcount, uvertstart, maxverts);
}
}
order += i*4;
}
if (uvertcount >= maxverts)
{
//if we're overflowing our verts, rewind, as we cannot generate this mesh. we'll just end up with a 0-index mesh, with no extra verts either
uvertcount = uvertstart;
idx = submodel->submesh[m].vbofirstelement;
}
submodel->submesh[m].numindexes = idx - submodel->submesh[m].vbofirstelement;
submodel->submesh[m].numvertexes = uvertcount - uvertstart;
}
}
}
mesh = &model->mesh;
mesh->indexes = ZG_Malloc(model->memgroup, sizeof(*mesh->indexes)*idx);
memcpy(mesh->indexes, index, sizeof(*index)*idx);
mesh->colors4b_array = ZG_Malloc(model->memgroup, sizeof(*mesh->colors4b_array)*uvertcount);
mesh->st_array = ZG_Malloc(model->memgroup, sizeof(*mesh->st_array)*uvertcount);
mesh->lmst_array[0] = ZG_Malloc(model->memgroup, sizeof(*mesh->lmst_array[0])*uvertcount);
mesh->xyz_array = ZG_Malloc(model->memgroup, sizeof(*mesh->xyz_array)*uvertcount);
mesh->normals_array = ZG_Malloc(model->memgroup, sizeof(*mesh->normals_array)*uvertcount);
mesh->bonenums = ZG_Malloc(model->memgroup, sizeof(*mesh->bonenums)*uvertcount);
mesh->boneweights = ZG_Malloc(model->memgroup, sizeof(*mesh->boneweights)*uvertcount);
#if defined(RTLIGHTS)
mesh->snormals_array = ZG_Malloc(model->memgroup, sizeof(*mesh->snormals_array)*uvertcount);
mesh->tnormals_array = ZG_Malloc(model->memgroup, sizeof(*mesh->tnormals_array)*uvertcount);
#endif
mesh->numindexes = idx;
mesh->numvertexes = uvertcount;
for (body = 0; body < model->numgeomsets; body++)
{
hlmdl_bodypart_t *bodypart = (hlmdl_bodypart_t *) ((qbyte *) model->header + model->header->bodypartindex) + body;
int bodyindex;
for (bodyindex = 0; bodyindex < bodypart->nummodels; bodyindex++)
{
hlmdl_submodel_t *amodel = (hlmdl_submodel_t *) ((qbyte *) model->header + bodypart->modelindex) + bodyindex;
vec3_t *verts = (vec3_t *) ((qbyte *) model->header + amodel->vertindex);
qbyte *bone = ((qbyte *) model->header + amodel->vertinfoindex);
vec3_t *norms = (vec3_t *) ((qbyte *) model->header + amodel->normindex);
size_t iv, ov;
struct hlalternative_s *submodel = &model->geomset[body].alternatives[bodyindex];
for(m = 0; m < amodel->nummesh; m++)
{
submesh = &submodel->submesh[m];
submesh->indexes = mesh->indexes + submesh->vbofirstelement;
submesh->colors4b_array = mesh->colors4b_array + submesh->vbofirstvert;
submesh->st_array = mesh->st_array + submesh->vbofirstvert;
submesh->lmst_array[0] = mesh->lmst_array[0] + submesh->vbofirstvert;
submesh->xyz_array = mesh->xyz_array + submesh->vbofirstvert;
submesh->normals_array = mesh->normals_array + submesh->vbofirstvert;
submesh->bonenums = mesh->bonenums + submesh->vbofirstvert;
submesh->boneweights = mesh->boneweights + submesh->vbofirstvert;
//prepare the verticies now that we have the mappings
for(ov = 0, iv = submesh->vbofirstvert; ov < submesh->numvertexes; ov++, iv++)
{
submesh->bonenums[ov][0] = submesh->bonenums[ov][1] = submesh->bonenums[ov][2] = submesh->bonenums[ov][3] = bone[uvert[iv].vertidx];
Vector4Set(submesh->boneweights[ov], 1, 0, 0, 0);
Vector4Set(submesh->colors4b_array[ov], 255, 255, 255, 255); //why bytes? why not?
submesh->lmst_array[0][ov][0] = uvert[iv].scoord;
submesh->lmst_array[0][ov][1] = uvert[iv].tcoord;
VectorCopy(verts[uvert[iv].vertidx], submesh->xyz_array[ov]);
//Warning: these models use different tables for vertex and normals.
//this means they might be transformed by different bones. we ignore that and just assume that the normals will want the same bone.
VectorCopy(norms[uvert[iv].normalidx], submesh->normals_array[ov]);
}
#if defined(RTLIGHTS)
//treat this as the base pose, and calculate the sdir+tdir for bumpmaps.
submesh->snormals_array = mesh->snormals_array + submesh->vbofirstvert;
submesh->tnormals_array = mesh->tnormals_array + submesh->vbofirstvert;
// R_Generate_Mesh_ST_Vectors(submesh);
#endif
}
}
}
//scratch space...
mesh->indexes = ZG_Malloc(model->memgroup, sizeof(*mesh->indexes)*idx);
//don't need that mapping any more
free(uvert);
free(index);
}
#endif
/*
=======================================================================================================================
Mod_LoadHLModel - read in the model's constituent parts
=======================================================================================================================
*/
qboolean QDECL Mod_LoadHLModel (model_t *mod, void *buffer, size_t fsize)
{
#ifndef SERVERONLY
int i, j;
struct hlmodelshaders_s *shaders;
hlmdl_tex_t *tex;
lmalloc_t atlas;
char texname[MAX_QPATH];
#endif
hlmodel_t *model;
hlmdl_header_t *header;
hlmdl_header_t *texheader;
hlmdl_bone_t *bones;
hlmdl_bonecontroller_t *bonectls;
void *texmem = NULL;
header = buffer;
if (fsize < 8)
{
Con_Printf(CON_ERROR "%s - file is truncated\n", mod->name);
return false;
}
#ifdef MODELFMT_HL2
if (header->version >= 44 && header->version <= 49)
return Mod_LoadHL2Model(mod, buffer, fsize);
#endif
//load the model into hunk
model = ZG_Malloc(&mod->memgroup, sizeof(hlmodel_t));
model->memgroup = &mod->memgroup;
header = ZG_Malloc(&mod->memgroup, fsize);
memcpy(header, buffer, fsize);
#if defined(HLSERVER) && (defined(__powerpc__) || defined(__ppc__))
//this is to let anyone who tries porting it know that there is a serious issue. And I'm lazy.
#ifdef warningmsg
#pragma warningmsg("-----------------------------------------")
#pragma warningmsg("FIXME: No byteswapping on halflife models") //hah, yeah, good luck with that, you'll need it.
#pragma warningmsg("-----------------------------------------")
#endif
#endif
if (header->version != 10)
{
Con_Printf(CON_ERROR "Cannot load halflife model %s - unknown version %i\n", mod->name, header->version);
return false;
}
if (header->numcontrollers > MAX_BONE_CONTROLLERS)
{
Con_Printf(CON_ERROR "Cannot load model %s - too many controllers %i\n", mod->name, header->numcontrollers);
return false;
}
if (header->numbones > MAX_BONES)
{
Con_Printf(CON_ERROR "Cannot load model %s - too many bones %i\n", mod->name, header->numbones);
return false;
}
texheader = NULL;
if (!header->numtextures)
{
size_t fz;
char texmodelname[MAX_QPATH];
COM_StripExtension(mod->name, texmodelname, sizeof(texmodelname));
Q_strncatz(texmodelname, "t.mdl", sizeof(texmodelname));
//no textures? eesh. They must be stored externally.
texheader = texmem = (hlmdl_header_t*)FS_LoadMallocFile(texmodelname, &fz);
if (texheader)
{
if (texheader->version != 10)
texheader = NULL;
}
}
if (!texheader)
texheader = header;
else
header->numtextures = texheader->numtextures;
bones = (hlmdl_bone_t *) ((qbyte *) header + header->boneindex);
bonectls = (hlmdl_bonecontroller_t *) ((qbyte *) header + header->controllerindex);
model->header = header;
model->bones = bones;
model->bonectls = bonectls;
#ifndef SERVERONLY
tex = (hlmdl_tex_t *) ((qbyte *) texheader + texheader->textures);
shaders = ZG_Malloc(&mod->memgroup, texheader->numtextures*sizeof(shader_t));
model->shaders = shaders;
for(i = 0; i < texheader->numtextures; i++)
{
Q_snprintfz(shaders[i].name, sizeof(shaders[i].name), "%s/%s", mod->name, COM_SkipPath(tex[i].name));
/* handle the special textures - eukara */
if (tex[i].flags)
{
char *shader;
if (tex[i].flags & HLMDLFL_FULLBRIGHT)
{
if (tex[i].flags & HLMDLFL_CHROME)
{
shader = HLSHADER_FULLBRIGHTCHROME;
Q_snprintfz(shaders[i].name, sizeof(shaders[i].name), "common/hlmodel_fullbrightchrome");
}
else
{
shader = HLSHADER_FULLBRIGHT;
Q_snprintfz(shaders[i].name, sizeof(shaders[i].name), "common/hlmodel_fullbright");
}
}
else if (tex[i].flags & HLMDLFL_CHROME)
{
shader = HLSHADER_CHROME;
Q_snprintfz(shaders[i].name, sizeof(shaders[i].name), "common/hlmodel_chrome");
}
else
{
shader = "";
Q_snprintfz(shaders[i].name, sizeof(shaders[i].name), "common/hlmodel_other");
}
shaders[i].defaultshadertext = shader;
}
else
{
shaders[i].defaultshadertext = NULL;
Q_snprintfz(shaders[i].name, sizeof(shaders[i].name), "common/hlmodel");
}
memset(&shaders[i].defaulttex, 0, sizeof(shaders[i].defaulttex));
}
//figure out the preferred atlas size. hopefully it'll fit well enough...
if (texheader->numtextures == 1)
Mod_LightmapAllocInit(&atlas, false, tex[0].w, tex[0].h, 0);
else
{
int sz = 1;
for(i = 0; i < texheader->numtextures; i++)
while (sz < tex[i].w || sz < tex[i].h)
sz <<= 1;
for (; sz < sh_config.texture2d_maxsize && sz <= LMBLOCK_SIZE_MAX; sz<<=1)
{
unsigned short x,y;
int atlasid;
Mod_LightmapAllocInit(&atlas, false, sz, sz, 0);
for(i = 0; i < texheader->numtextures; i++)
{
if ((tex[i].flags & HLMDLFL_CHROME) || !Q_strncasecmp(tex[i].name, "DM_Base", 7))
continue;
Mod_LightmapAllocBlock(&atlas, tex[i].w, tex[i].h, &x, &y, &atlasid);
}
if (i == texheader->numtextures && atlas.lmnum <= 0)
break; //okay, just go with it.
}
Mod_LightmapAllocInit(&atlas, false, sz, sz, 0);
}
for(i = 0; i < texheader->numtextures; i++)
{
if ((tex[i].flags & HLMDLFL_CHROME) || !Q_strncasecmp(tex[i].name, "DM_Base", 7))
{
shaders[i].x =
shaders[i].y = 0;
shaders[i].w = tex[i].w;
shaders[i].h = tex[i].h;
shaders[i].atlasid = -1;
continue;
}
shaders[i].w = tex[i].w;
shaders[i].h = tex[i].h;
Mod_LightmapAllocBlock(&atlas, shaders[i].w, shaders[i].h, &shaders[i].x, &shaders[i].y, &shaders[i].atlasid);
}
if (atlas.allocated[0])
atlas.lmnum++;
//now we know where the various textures will be, generate the atlas images.
for (j = 0; j < atlas.lmnum; j++)
{
texid_t basetex;
int y, x;
unsigned int *basepix = Z_Malloc(atlas.width * atlas.height * sizeof(*basepix));
for(i = 0; i < texheader->numtextures; i++)
{
if (shaders[i].atlasid == j)
{
unsigned *out = basepix + atlas.width*shaders[i].y + shaders[i].x;
qbyte *in = (qbyte *) texheader + tex[i].offset;
qbyte *pal = (qbyte *) texheader + tex[i].w * tex[i].h + tex[i].offset;
qbyte *rgb;
for(y = 0; y < tex[i].h; y++, out += atlas.width-shaders[i].w)
for(x = 0; x < tex[i].w; x++, in++)
{
rgb = pal + *in*3;
*out++ = 0xff000000 | (rgb[0]<<0) | (rgb[1]<<8) | (rgb[2]<<16);
}
}
}
Q_snprintfz(texname, sizeof(texname), "%s*%i", mod->name, j);
basetex = Image_GetTexture(texname, "", IF_NOALPHA|IF_NOREPLACE, basepix, NULL, atlas.width, atlas.height, PTI_RGBX8);
Z_Free(basepix);
for(i = 0; i < texheader->numtextures; i++)
{
if (shaders[i].atlasid == j)
shaders[i].defaulttex.base = basetex;
}
}
//and chrome textures need to preserve their texture coords to avoid weirdness.
for(i = 0; i < texheader->numtextures; i++)
{
if (!Q_strncasecmp(tex[i].name, "DM_Base", 7))
{
int y, x;
unsigned int *basepix = Z_Malloc(tex[i].w*tex[i].h*sizeof(*basepix) + tex[i].w*tex[i].h*2);
unsigned int *out = basepix;
qbyte *upper = (qbyte*)(basepix + tex[i].w * tex[i].h); //we use an L8 texture, because we can.
qbyte *lower = upper + tex[i].w * tex[i].h;
qbyte *in = (qbyte *) texheader + tex[i].offset;
qbyte *pal = (qbyte *) texheader + tex[i].w * tex[i].h + tex[i].offset;
qbyte *rgb;
for(y = 0; y < tex[i].h; y++)
for(x = 0; x < tex[i].w; x++, in++)
{
if (*in >= 256-96 && *in < 256-64)
{ //rows 11 and 12 are the player's upper colour (in the lower range)
*out++ = 0xff000000;
*upper++ = 255-(7+(*in-(256-96))*(256/32));
*lower++ = 0;
}
else if (*in >= 256-64 && *in < 256-32)
{ //rows 13 and 14 are the player's lower colour
*out++ = 0xff000000;
*upper++ = 0;
*lower++ = 255-(7+(*in-(256-64))*(256/32));
}
else
{ //regular and fullbright ranges... not that there is fullbrights on hlmdl
rgb = pal + *in*3;
*out++ = 0xff000000 | (rgb[0]<<0) | (rgb[1]<<8) | (rgb[2]<<16);
*upper++ = 0;
*lower++ = 0;
}
}
out = basepix;
upper = (qbyte*)(basepix + tex[i].w * tex[i].h); //we use an L8 texture, because we can.
lower = upper + tex[i].w * tex[i].h;
Q_snprintfz(texname, sizeof(texname), "%s*%s", mod->name, tex[i].name);
shaders[i].defaulttex.base = Image_GetTexture(texname, "", IF_NOALPHA|IF_NOREPLACE, out, NULL, tex[i].w, tex[i].h, PTI_RGBX8);
Q_snprintfz(texname, sizeof(texname), "%s*%s*upper", mod->name, tex[i].name);
shaders[i].defaulttex.upperoverlay = Image_GetTexture(texname, "", IF_NOALPHA|IF_NOREPLACE, upper, NULL, tex[i].w, tex[i].h, PTI_L8);
Q_snprintfz(texname, sizeof(texname), "%s*%s*lower", mod->name, tex[i].name);
shaders[i].defaulttex.loweroverlay = Image_GetTexture(texname, "", IF_NOALPHA|IF_NOREPLACE, lower, NULL, tex[i].w, tex[i].h, PTI_L8);
Z_Free(basepix);
}
else if (tex[i].flags & HLMDLFL_CHROME)
{
qbyte *in = (qbyte *) texheader + tex[i].offset;
qbyte *pal = (qbyte *) texheader + tex[i].w * tex[i].h + tex[i].offset;
shaders[i].atlasid = j++;
Q_snprintfz(texname, sizeof(texname), "%s*%i", mod->name, shaders[i].atlasid);
shaders[i].defaulttex.base = Image_GetTexture(texname, "", IF_NOALPHA|IF_NOREPLACE, in, pal, tex[i].w, tex[i].h, TF_8PAL24);
}
}
model->numskinrefs = texheader->skinrefs;
model->numskingroups = texheader->skingroups;
model->skinref = ZG_Malloc(&mod->memgroup, model->numskinrefs*model->numskingroups*sizeof(*model->skinref));
memcpy(model->skinref, (short *) ((qbyte *) texheader + texheader->skins), model->numskinrefs*model->numskingroups*sizeof(*model->skinref));
#endif
if (texmem)
Z_Free(texmem);
mod->funcs.NativeContents = HLMDL_Contents;
mod->funcs.NativeTrace = HLMDL_Trace;
mod->type = mod_halflife;
mod->numframes = model->header->numseq;
mod->meshinfo = model;
#ifndef SERVERONLY
model->numgeomsets = model->header->numbodyparts;
model->geomset = ZG_Malloc(&mod->memgroup, sizeof(*model->geomset) * model->numgeomsets);
HLMDL_PrepareVerticies(mod, model);
//FIXME: No VBOs used.
#endif
return true;
}
#ifdef HLSERVER
void *Mod_GetHalfLifeModelData(model_t *mod)
{
hlmodelcache_t *mc;
if (!mod || mod->type != mod_halflife)
return NULL; //halflife models only, please
mc = Mod_Extradata(mod);
return (void*)mc->header;
}
#endif
int HLMDL_FrameForName(model_t *mod, const char *name)
{
int i;
hlmdl_header_t *h;
hlmdl_sequencelist_t *seqs;
hlmodel_t *mc;
if (!mod || mod->type != mod_halflife)
return -1; //halflife models only, please
mc = Mod_Extradata(mod);
h = mc->header;
seqs = (hlmdl_sequencelist_t*)((char*)h+h->seqindex);
for (i = 0; i < h->numseq; i++)
{
if (!strcmp(seqs[i].name, name))
return i;
}
return -1;
}
qboolean HLMDL_GetModelEvent(model_t *model, int animation, int eventidx, float *timestamp, int *eventcode, char **eventdata)
{
hlmodel_t *mc = Mod_Extradata(model);
hlmdl_header_t *h = mc->header;
hlmdl_event_t *ev;
hlmdl_sequencelist_t *seq = animation + (hlmdl_sequencelist_t*)((char*)h+h->seqindex);
if (animation < 0 || animation >= h->numseq || eventidx < 0 || eventidx >= seq->num_events)
return false;
ev = eventidx + (hlmdl_event_t*)((char*)h+seq->ofs_events);
*timestamp = ev->pose / seq->timing;
*eventcode = ev->code;
*eventdata = ev->data;
return true;
}
int HLMDL_BoneForName(model_t *mod, const char *name)
{
int i;
hlmdl_header_t *h;
hlmdl_bone_t *bones;
hlmodel_t *mc;
if (!mod || mod->type != mod_halflife)
return -1; //halflife models only, please
mc = Mod_Extradata(mod);
h = mc->header;
bones = (hlmdl_bone_t*)((char*)h+h->boneindex);
for (i = 0; i < h->numbones; i++)
{
if (!strcmp(bones[i].name, name))
return i+1;
}
//FIXME: hlmdl has tags as well as bones.
return 0;
}
/*
=======================================================================================================================
HL_CalculateBones - calculate bone positions - quaternion+vector in one function
=======================================================================================================================
*/
void HL_CalculateBones
(
int frame,
vec4_t adjust,
hlmdl_bone_t *bone,
hlmdl_anim_t *animation,
float *organg
)
{
int i;
/* For each vector */
for(i = 0; i < 6; i++)
{
organg[i] = bone->value[i]; /* Take the bone value */
if(animation->offset[i] != 0)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
int tempframe;
hlmdl_animvalue_t *animvalue = (hlmdl_animvalue_t *) ((qbyte *) animation + animation->offset[i]);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
/* find values including the required frame */
tempframe = frame;
while(animvalue->num.total <= tempframe)
{
tempframe -= animvalue->num.total;
animvalue += animvalue->num.valid + 1;
}
if (tempframe >= animvalue->num.valid)
tempframe = animvalue->num.valid;
else
tempframe += 1;
organg[i] += animvalue[tempframe].value * bone->scale[i];
}
if(bone->bonecontroller[i] != -1)
{ /* Add the programmable offset. */
organg[i] += adjust[bone->bonecontroller[i]];
}
}
}
/*
=======================================================================================================================
HL_CalcBoneAdj - Calculate the adjustment values for the programmable controllers
=======================================================================================================================
*/
void HL_CalcBoneAdj(hlmodel_t *model)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
int i;
float value;
hlmdl_bonecontroller_t *control = (hlmdl_bonecontroller_t *)
((qbyte *) model->header + model->header->controllerindex);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
for(i = 0; i < model->header->numcontrollers; i++)
{
/*~~~~~~~~~~~~~~~~~~~~~*/
int j = control[i].index;
/*~~~~~~~~~~~~~~~~~~~~~*/
if(control[i].type & 0x8000)
{ //wraps normally
value = model->controller[j];// + control[i].start;
}
else
{
// value = (model->controller[j]+1)*0.5; //shifted to give a valid range between -1 and 1, with 0 being mid-range.
// if(value < 0)
// value = 0;
// else if(value > 1.0)
// value = 1.0;
// value = (1.0 - value) * control[i].start + value * control[i].end;
value = model->controller[j];
if (value < control[i].start)
value = control[i].start;
if (value > control[i].end)
value = control[i].end;
}
/* Rotational controllers need their values converted */
if(control[i].type >= 0x0008 && control[i].type <= 0x0020)
model->adjust[i] = M_PI * value / 180;
else
model->adjust[i] = value;
}
}
/*
=======================================================================================================================
HL_SetupBones - determine where vertex should be using bone movements
=======================================================================================================================
*/
void QuaternionSlerp( const vec4_t p, vec4_t q, float t, vec4_t qt );
void HL_SetupBones(hlmodel_t *model, int seqnum, int firstbone, int lastbone, float subblendfrac1, float subblendfrac2, float frametime, float *matrix)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
int i, j;
vec3_t organg1[2];
vec3_t organg2[2];
vec3_t organgb[2];
vec4_t quat1, quat2;
int frame1, frame2;
hlmdl_sequencelist_t *sequence = (hlmdl_sequencelist_t *) ((qbyte *) model->header + model->header->seqindex) +
((unsigned int)seqnum>=model->header->numseq?0:seqnum);
hlmdl_sequencedata_t *sequencedata = (hlmdl_sequencedata_t *)
((qbyte *) model->header + model->header->seqgroups) +
sequence->seqindex;
hlmdl_anim_t *animation;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
matrix += firstbone*12;
if (sequencedata->name[32])
{
size_t fz;
if (sequence->seqindex >= MAX_ANIM_GROUPS)
{
Sys_Error("Too many animation sequence cache groups\n");
return;
}
if (!model->animcache[sequence->seqindex])
model->animcache[sequence->seqindex] = FS_LoadMallocGroupFile(model->memgroup, sequencedata->name+32, &fz, true);
if (!model->animcache[sequence->seqindex] || model->animcache[sequence->seqindex]->magic != (('I'<<0)|('D'<<8)|('S'<<16)|('Q'<<24)) || model->animcache[sequence->seqindex]->version != 10)
{
Sys_Error("Unable to load %s\n", sequencedata->name+32);
return;
}
animation = (hlmdl_anim_t *)((qbyte*)model->animcache[sequence->seqindex] + sequence->index);
}
else
animation = (hlmdl_anim_t *) ((qbyte *) model->header + sequencedata->data + sequence->index);
frametime *= sequence->timing;
if (frametime < 0)
frametime = 0;
frame1 = (int)frametime;
frametime -= frame1;
frame2 = frame1+1;
if (!sequence->numframes)
return;
//halflife seems to dupe the last frame in looping animations, so don't use it.
if(frame1 >= sequence->numframes)
{
if (sequence->loop)
frame1 %= sequence->numframes;
else
frame1 = sequence->numframes-1;
}
if(frame2 >= sequence->numframes)
{
if (sequence->loop)
frame2 %= sequence->numframes;
else
frame2 = sequence->numframes-1;
}
if (frame2 < frame1)
{
i = frame2;
frame2 = frame1;
frame1 = i;
frametime = 1-frametime;
}
if (lastbone > model->header->numbones)
lastbone = model->header->numbones;
HL_CalcBoneAdj(model); /* Deal with programmable controllers */
/*FIXME:this is useless*/
/*
if(sequence->motiontype & 0x0001)
positions[sequence->motionbone][0] = 0.0;
if(sequence->motiontype & 0x0002)
positions[sequence->motionbone][1] = 0.0;
if(sequence->motiontype & 0x0004)
positions[sequence->motionbone][2] = 0.0;
*/
/*
this is hellish.
a hl model blends:
4 controllers (on a player, it seems each one of them twists a separate bone in the chest)
a mouth (not used on players)
its a sequence (to be smooth we need to blend between two frames in the sequence)
up to four source animations (ironically used to pitch up/down)
alternate sequence (walking+firing)
frame2 (quake expectations.)
this is madness, quite frankly.
luckily...
controllers and mouth control the entire thing. they should be interpolated outside, and have no affect on blending here
alternate sequences replace. we can just call this function twice (so long as bone ranges are incremental).
autoanimating sequence is handled inside HL_CalculateBones (sequences are weird and it has to be handled there anyway)
this means we only have sources and alternate frames left to cope with.
FIXME: we don't handle frame2.
*/
if (sequence->hasblendseq>1)
{
int bf0, bf1;
unsigned int bweights;
struct
{
int frame;
float weight;
hlmdl_anim_t *anim;
} blend[8];
//right, so, this stuff is annoying.
//we have two different blend factors.
//we have up to 9 blend weights. figure out which frames are what
switch(sequence->hasblendseq)
{
case 0: //erk?
return;
case 1: //no blending.
bf0 = bf1 = 1;
break;
default:
case 2: //mix(0, 1, weight0)
case 3: //mix(0, 1, 2, weight0);
case 8: //weight0 only...
bf0 = sequence->hasblendseq;
bf1 = 1;
break;
case 4: //mix(mix(0, 1, weight0), mix(2, 3, weight0), weight1)
bf0 = bf1 = 2;
break;
//case 6: //???
// bf[0] = 3; bf[1] = 2;
// break;
case 9: //mix(mix(0, 1, 2, weight0), mix(2, 3, 4, weight0), mix(5, 6, 7, weight0), weight1)
bf0 = bf1 = 3;
break;
}
subblendfrac1 = (subblendfrac1+1)/2;
subblendfrac2 = (subblendfrac2+1)/2;
bweights = 0;
if (bf0 > 1)
{
float frac = (bf0-1) * bound(0, subblendfrac1, 1);
int f1 = bound(0, frac, bf0-1);
int f2 = bound(0, f1+1, bf0-1);
frac = (frac-f1);
frac = bound(0, frac, 1);
if (bf1 > 1)
{
float frac2 = (bf1-1) * bound(0, subblendfrac2, 1);
int a1 = bound(0, frac2, bf1-1);
int a2 = bound(0, a1+1, bf1-1);
frac2 = (frac2-a1);
frac2 = bound(0, frac2, 1);
if (frac2)
{
if (frac)
{
blend[bweights].frame = frame1;
blend[bweights].anim = animation + model->header->numbones * (f2 + a2*bf0);
blend[bweights++].weight = frac*frac2;
}
if (1-frac)
{
blend[bweights].frame = frame1;
blend[bweights].anim = animation + model->header->numbones * (f1 + a2*bf0);
blend[bweights++].weight = (1-frac)*frac2;
}
}
if (1-frac2)
{
if (frac)
{
blend[bweights].frame = frame1;
blend[bweights].anim = animation + model->header->numbones * (f2 + a1*bf0);
blend[bweights++].weight = frac*(1-frac2);
}
if (1-frac)
{
blend[bweights].frame = frame1;
blend[bweights].anim = animation + model->header->numbones * (f1 + a1*bf0);
blend[bweights++].weight = (1-frac)*(1-frac2);
}
}
}
else
{
if (frac)
{
blend[bweights].frame = frame1;
blend[bweights].anim = animation + model->header->numbones * f1;
blend[bweights++].weight = frac;
}
if (1-frac)
{
blend[bweights].frame = frame1;
blend[bweights].anim = animation + model->header->numbones * f2;
blend[bweights++].weight = 1-frac;
}
}
}
else
{
blend[bweights].frame = frame1;
blend[bweights].anim = animation;
blend[bweights++].weight = 1;
}
if (frame1 != frame2)
{
//bweights can be 0-4 here..
for (i = 0; i < bweights; i++)
{
blend[bweights+i].frame = frame2;
blend[bweights+i].anim = blend[i].anim;
blend[bweights+i].weight = blend[i].weight;
blend[i].weight *= 1-frametime;
blend[bweights+i].weight *= frametime;
}
bweights *= 2;
}
for(i = firstbone; i < lastbone; i++, matrix+=12)
{
vec3_t t;
float len;
HL_CalculateBones(blend[0].frame, model->adjust, model->bones + i, blend[0].anim + i, organgb[0]);
QuaternionGLAngle(organgb[1], quat2);
Vector4Scale(quat2, blend[0].weight, quat1);
VectorScale(organgb[0], blend[0].weight, t);
for (j = 1; j < bweights; j++)
{
HL_CalculateBones(blend[j].frame, model->adjust, model->bones + i, blend[j].anim + i, organgb[0]);
QuaternionGLAngle(organgb[1], quat2);
if (DotProduct4(quat2, quat1) < 0) //negative quats are annoying
Vector4MA(quat1, -blend[j].weight, quat2, quat1);
else
Vector4MA(quat1, blend[j].weight, quat2, quat1);
VectorMA(t, blend[j].weight, organgb[0], t);
}
//we were lame and didn't use slerp. boo hiss. now we need to normalise the things and hope we didn't hit any singularities
len = sqrt(DotProduct4(quat1,quat1));
if (len && len != 1)
{
len = 1/len;
quat1[0] *= len;
quat1[1] *= len;
quat1[2] *= len;
quat1[3] *= len;
}
QuaternionGLMatrix(quat1[0], quat1[1], quat1[2], quat1[3], (vec4_t*)matrix);
matrix[0*4+3] = t[0];
matrix[1*4+3] = t[1];
matrix[2*4+3] = t[2];
}
}
else
{
for(i = firstbone; i < lastbone; i++, matrix+=12)
{
HL_CalculateBones(frame1, model->adjust, model->bones + i, animation + i, organg1[0]);
QuaternionGLAngle(organg1[1], quat1); /* A quaternion */
if (frame1 != frame2)
{
HL_CalculateBones(frame2, model->adjust, model->bones + i, animation + i, organg2[0]);
QuaternionGLAngle(organg2[1], quat2); /* A quaternion */
//lerp the quats properly rather than poorly lerping eular angles.
QuaternionSlerp(quat1, quat2, frametime, quat1);
VectorInterpolate(organg1[0], frametime, organg2[0], organg1[0]);
}
//figure out the relative bone matrix.
//we probably ought to keep them as quats or something.
QuaternionGLMatrix(quat1[0], quat1[1], quat1[2], quat1[3], (vec4_t*)matrix);
matrix[0*4+3] = organg1[0][0];
matrix[1*4+3] = organg1[0][1];
matrix[2*4+3] = organg1[0][2];
}
}
}
int HLMDL_GetNumBones(model_t *mod, qboolean tags)
{
hlmodel_t *mc;
if (!mod || mod->type != mod_halflife)
return -1; //halflife models only, please
mc = Mod_Extradata(mod);
if (tags)
return mc->header->numbones + mc->header->num_attachments;
return mc->header->numbones;
}
int HLMDL_GetBoneParent(model_t *mod, int bonenum)
{
hlmodel_t *model = Mod_Extradata(mod);
if (bonenum >= 0 && bonenum < model->header->numbones)
return model->bones[bonenum].parent;
bonenum -= model->header->numbones;
if (bonenum >= 0 && bonenum < model->header->num_attachments)
{
hlmdl_attachment_t *attachments = bonenum+(hlmdl_attachment_t*)((char*)model->header + model->header->ofs_attachments);
return attachments->bone;
}
return -1;
}
const char *HLMDL_GetBoneName(model_t *mod, int bonenum)
{
hlmodel_t *model = Mod_Extradata(mod);
if (bonenum >= 0 && bonenum < model->header->numbones)
return model->bones[bonenum].name;
bonenum -= model->header->numbones;
if (bonenum >= 0 && bonenum < model->header->num_attachments)
{
hlmdl_attachment_t *attachments = bonenum+(hlmdl_attachment_t*)((char*)model->header + model->header->ofs_attachments);
if (*attachments->name)
return attachments->name;
return "Unnamed Attachment";
}
return NULL;
}
int HLMDL_GetAttachment(model_t *mod, int tagnum, float *resultmatrix)
{
hlmodel_t *model = Mod_Extradata(mod);
if (tagnum >= 0 && tagnum < model->header->num_attachments)
{
hlmdl_attachment_t *attachments = tagnum+(hlmdl_attachment_t*)((char*)model->header + model->header->ofs_attachments);
resultmatrix[3] = attachments->org[0];
resultmatrix[7] = attachments->org[1];
resultmatrix[11] = attachments->org[2];
return attachments->bone;
}
return -1;
}
static int HLMDL_GetBoneData_Internal(hlmodel_t *model, int firstbone, int lastbone, const framestate_t *fstate, float *result)
{
int b, cbone, bgroup;
for (b = 0; b < MAX_BONE_CONTROLLERS; b++)
model->controller[b] = fstate->bonecontrols[b];
for (cbone = 0, bgroup = 0; bgroup < FS_COUNT; bgroup++)
{
lastbone = fstate->g[bgroup].endbone;
if (bgroup == FS_COUNT-1)
lastbone = model->header->numbones;
if (cbone >= lastbone)
continue;
HL_SetupBones(model, fstate->g[bgroup].frame[0], cbone, lastbone, fstate->g[bgroup].subblendfrac, fstate->g[bgroup].subblend2frac, fstate->g[bgroup].frametime[0], result); /* Setup the bones */
cbone = lastbone;
}
return cbone;
}
int HLMDL_GetBoneData(model_t *mod, int firstbone, int lastbone, const framestate_t *fstate, float *result)
{
return HLMDL_GetBoneData_Internal(Mod_Extradata(mod), firstbone, lastbone, fstate, result);
}
const char *HLMDL_FrameNameForNum(model_t *mod, int surfaceidx, int seqnum)
{
hlmodel_t *model = Mod_Extradata(mod);
hlmdl_sequencelist_t *sequence = (hlmdl_sequencelist_t *) ((qbyte *) model->header + model->header->seqindex) +
((unsigned int)seqnum>=model->header->numseq?0:seqnum);
return sequence->name;
}
qboolean HLMDL_FrameInfoForNum(model_t *mod, int surfaceidx, int seqnum, char **name, int *numframes, float *duration, qboolean *loop)
{
hlmodel_t *model = Mod_Extradata(mod);
hlmdl_sequencelist_t *sequence = (hlmdl_sequencelist_t *) ((qbyte *) model->header + model->header->seqindex) +
((unsigned int)seqnum>=model->header->numseq?0:seqnum);
*name = sequence->name;
*numframes = sequence->numframes;
*duration = (sequence->numframes-1)/sequence->timing;
*loop = sequence->loop;
return true;
}
qboolean HLMDL_Trace (model_t *model, int hulloverride, const framestate_t *framestate, const vec3_t axis[3], const vec3_t p1, const vec3_t p2, const vec3_t mins, const vec3_t maxs, qboolean capsule, unsigned int against, struct trace_s *trace)
{
hlmodel_t *hm = Mod_Extradata(model);
float *relbones;
float calcrelbones[MAX_BONES*12];
int bonecount;
int b, i;
vec3_t norm, p1l, p2l;
float inverse[12];
hlmdl_hitbox_t *hitbox = (hlmdl_hitbox_t*)((char*)hm->header+hm->header->ofs_hitboxes);
float dist, d1, d2, f, enterfrac, enterdist, exitfrac;
qboolean startout, endout;
int enterplane;
memset (trace, 0, sizeof(trace_t));
trace->fraction = trace->truefraction = 1;
if (!(against & FTECONTENTS_BODY) || !framestate)
return false;
if (framestate->bonestate && framestate->skeltype == SKEL_ABSOLUTE)
{
relbones = framestate->bonestate;
bonecount = framestate->bonecount;
if (axis)
{
for (b = 0; b < bonecount; b++)
R_ConcatTransformsAxis(axis, (void*)(relbones+b*12), transform_matrix[b]);
}
else
memcpy(transform_matrix, relbones, bonecount * 12 * sizeof(float));
}
else
{
//get relative bones from th emodel.
if (framestate->bonestate)
{
relbones = framestate->bonestate;
bonecount = framestate->bonecount;
}
else
{
relbones = calcrelbones;
bonecount = HLMDL_GetBoneData(model, 0, MAX_BONES, framestate, calcrelbones);
}
//convert relative to absolutes
for (b = 0; b < bonecount; b++)
{
/* If we have a parent, take the addition. Otherwise just copy the values */
if(hm->bones[b].parent>=0)
R_ConcatTransforms((void*)transform_matrix[hm->bones[b].parent], (void*)(relbones+b*12), transform_matrix[b]);
else if (axis)
R_ConcatTransformsAxis(axis, (void*)(relbones+b*12), transform_matrix[b]);
else
memcpy(transform_matrix[b], relbones+b*12, 12 * sizeof(float));
}
}
for (b = 0; b < hm->header->num_hitboxes; b++, hitbox++)
{
startout = false;
endout = false;
enterplane = 0;
enterfrac = -1;
exitfrac = 10;
enterdist = 0;
//fixme: would be nice to check if there's a possible collision a bit faster, without needing to do lots of excess maths.
//transform start+end into the bbox, so everything is axial and simple.
Matrix3x4_Invert_Simple((void*)transform_matrix[hitbox->bone], inverse);
Matrix3x4_RM_Transform3(inverse, p1, p1l);
Matrix3x4_RM_Transform3(inverse, p2, p2l);
//fixme: would it be faster to just generate the plane and transform that, colliding non-axially? would probably be better for sized impactors.
//clip against the 6 axial faces
for (i = 0; i < 6; i++)
{
if (i < 3)
{ //normal>0
dist = hitbox->maxs[i] - mins[i];
d1 = p1l[i] - dist;
d2 = p2l[i] - dist;
}
else
{//normal<0
dist = maxs[i-3] - hitbox->mins[i-3];
d1 = -p1l[i-3] - dist;
d2 = -p2l[i-3] - dist;
}
//FIXME: if the trace has size, we should insert 6 extra planes for the shape of the impactor
//FIXME: capsules
if (d1 >= 0)
startout = true;
if (d2 > 0)
endout = true;
//if we're fully outside any plane, then we cannot possibly enter the brush, skip to the next one
if (d1 > 0 && d2 >= 0)
goto nextbrush;
//if we're fully inside the plane, then whatever is happening is not relevent for this plane
if (d1 < 0 && d2 <= 0)
continue;
f = d1 / (d1-d2);
if (d1 > d2)
{
//entered the brush. favour the furthest fraction to avoid extended edges (yay for convex shapes)
if (enterfrac < f)
{
enterfrac = f;
enterplane = i;
enterdist = dist;
}
}
else
{
//left the brush, favour the nearest plane (smallest frac)
if (exitfrac > f)
{
exitfrac = f;
}
}
}
if (!startout)
{
trace->startsolid = true;
if (!endout)
trace->allsolid = true;
trace->contents = FTECONTENTS_BODY;
trace->brush_face = 0;
trace->bone_id = hitbox->bone+1;
trace->brush_id = b+1;
trace->surface_id = hitbox->body;
break;
}
if (enterfrac != -1 && enterfrac < exitfrac)
{
//impact!
if (enterfrac < trace->fraction)
{
trace->fraction = trace->truefraction = enterfrac;
trace->plane.dist = enterdist;
trace->contents = FTECONTENTS_BODY;
trace->brush_face = enterplane+1;
trace->bone_id = hitbox->bone+1;
trace->brush_id = b+1;
trace->surface_id = hitbox->body;
}
}
nextbrush:
;
}
if (trace->brush_face)
{
VectorClear(norm);
if (trace->brush_face < 4)
norm[trace->brush_face-1] = 1;
else
norm[trace->brush_face-4] = -1;
Matrix3x4_RM_Transform3x3((void*)transform_matrix[trace->bone_id-1], norm, trace->plane.normal);
}
else
VectorClear(trace->plane.normal);
VectorInterpolate(p1, trace->fraction, p2, trace->endpos);
return trace->truefraction != 1;
}
unsigned int HLMDL_Contents (model_t *model, int hulloverride, const framestate_t *framestate, const vec3_t axis[3], const vec3_t p, const vec3_t mins, const vec3_t maxs)
{
trace_t tr;
HLMDL_Trace(model, hulloverride, framestate, axis, p, p, mins, maxs, false, ~0, &tr);
return tr.contents;
}
#ifndef SERVERONLY
void R_HL_BuildFrame(hlmodel_t *model, int bodypart, int bodyidx, int meshidx, struct hlmodelshaders_s *texinfo, mesh_t *outmesh)
{
int v;
int w = texinfo->defaulttex.base->width;
int h = texinfo->defaulttex.base->height;
vec2_t texbase = {texinfo->x/(float)w, texinfo->y/(float)h};
vec2_t texscale = {1.0/w, 1.0/h};
mesh_t *srcmesh = &model->geomset[bodypart].alternatives[bodyidx].submesh[meshidx];
//copy out the indexes into the final mesh.
memcpy(outmesh->indexes+outmesh->numindexes, srcmesh->indexes, sizeof(index_t)*srcmesh->numindexes);
outmesh->numindexes += srcmesh->numindexes;
if (outmesh == &model->mesh)
{ //get the backend to do the skeletal stuff (read: glsl)
for(v = 0; v < srcmesh->numvertexes; v++)
{ //should really come up with a better way to deal with this, like rect textures.
srcmesh->st_array[v][0] = texbase[0] + srcmesh->lmst_array[0][v][0] * texscale[0];
srcmesh->st_array[v][1] = texbase[1] + srcmesh->lmst_array[0][v][1] * texscale[1];
}
}
else
{ //backend can't handle it, apparently. do it in software.
int fvert = srcmesh->vbofirstvert;
vecV_t *nxyz = outmesh->xyz_array+fvert;
vec3_t *nnorm = outmesh->normals_array+fvert;
for(v = 0; v < srcmesh->numvertexes; v++)
{ //should really come up with a better way to deal with this, like rect textures.
srcmesh->st_array[v][0] = texbase[0] + srcmesh->lmst_array[0][v][0] * texscale[0];
srcmesh->st_array[v][1] = texbase[1] + srcmesh->lmst_array[0][v][1] * texscale[1];
//transform to nxyz (a separate buffer from the srcmesh data)
VectorTransform(srcmesh->xyz_array[v], (void *)transform_matrix[srcmesh->bonenums[v][0]], nxyz[v]);
//transform to nnorm (a separate buffer from the srcmesh data)
nnorm[v][0] = DotProduct(srcmesh->normals_array[v], transform_matrix[srcmesh->bonenums[v][0]][0]);
nnorm[v][1] = DotProduct(srcmesh->normals_array[v], transform_matrix[srcmesh->bonenums[v][0]][1]);
nnorm[v][2] = DotProduct(srcmesh->normals_array[v], transform_matrix[srcmesh->bonenums[v][0]][2]);
//FIXME: svector, tvector!
}
}
}
static void R_HL_BuildMeshes(batch_t *b)
{
entity_t *rent = b->ent;
hlmodel_t *model = Mod_Extradata(rent->model);
int body, m;
static mesh_t *mptr[1], softbonemesh;
skinfile_t *sk = rent->customskin?Mod_LookupSkin(rent->customskin):NULL;
const unsigned int entity_body = 0/*rent->body*/;
int surf;
float *bones;
int numbones;
if (b->shader->prog && (b->shader->prog->supportedpermutations & PERMUTATION_SKELETAL) && model->header->numbones < sh_config.max_gpu_bones)
{ //okay, we can use gpu gones. yay.
b->mesh = mptr;
*b->mesh = &model->mesh;
}
else
{
static vecV_t nxyz_buffer[65536];
static vec3_t nnorm_buffer[65536];
//no gpu bone support. :(
softbonemesh = model->mesh;
b->mesh = mptr;
*b->mesh = &softbonemesh;
//this stuff will get recalculated
softbonemesh.xyz_array = nxyz_buffer;
softbonemesh.normals_array = nnorm_buffer;
//don't get confused.
softbonemesh.bonenums = NULL;
softbonemesh.boneweights = NULL;
softbonemesh.bones = NULL;
softbonemesh.numbones = 0;
}
(*b->mesh)->numindexes = 0;
//FIXME: cache this!
if (rent->framestate.bonecount >= model->header->numbones)
{ //skeletal object...
int b;
if (rent->framestate.skeltype == SKEL_RELATIVE)
{
numbones = model->header->numbones;
for (b = 0; b < numbones; b++)
{
/* If we have a parent, take the addition. Otherwise just copy the values */
if(model->bones[b].parent>=0)
{
R_ConcatTransforms((void*)transform_matrix[model->bones[b].parent], (void*)(rent->framestate.bonestate+b*12), transform_matrix[b]);
}
else
{
memcpy(transform_matrix[b], rent->framestate.bonestate+b*12, 12 * sizeof(float));
}
}
bones = transform_matrix[0][0];
}
else
{
bones = rent->framestate.bonestate;
numbones = rent->framestate.bonecount;
}
}
else
{ //lerp the bone data ourselves.
float relatives[12*MAX_BONES];
int cbone, b;
bones = transform_matrix[0][0];
numbones = model->header->numbones;
cbone = HLMDL_GetBoneData_Internal(model, 0, model->header->numbones, &rent->framestate, relatives);
//convert relative to absolutes
for (b = 0; b < cbone; b++)
{
/* If we have a parent, take the addition. Otherwise just copy the values */
if(model->bones[b].parent>=0)
{
R_ConcatTransforms((void*)transform_matrix[model->bones[b].parent], (void*)(relatives+b*12), transform_matrix[b]);
}
else
{
memcpy(transform_matrix[b], relatives+b*12, 12 * sizeof(float));
}
}
}
model->mesh.bones = bones;
model->mesh.numbones = numbones;
for (surf = 0; surf < b->meshes; surf++)
{
body = b->user.alias.surfrefs[surf] >> 8;
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
hlmdl_bodypart_t *bodypart = (hlmdl_bodypart_t *) ((qbyte *) model->header + model->header->bodypartindex) + body;
int bodyindex = ((sk && body < MAX_GEOMSETS && sk->geomset[body] >= 1)?sk->geomset[body]-1:(entity_body / bodypart->base)) % bodypart->nummodels;
hlmdl_submodel_t *amodel = (hlmdl_submodel_t *) ((qbyte *) model->header + bodypart->modelindex) + bodyindex;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
/* Draw each mesh */
m = b->user.alias.surfrefs[surf] & 0xff;
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
hlmdl_mesh_t *mesh = (hlmdl_mesh_t *) ((qbyte *) model->header + amodel->meshindex) + m;
struct hlmodelshaders_s *texinfo;
int skinidx = mesh->skinindex;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
if (rent->skinnum < model->numskingroups)
skinidx += rent->skinnum * model->numskinrefs;
texinfo = &model->shaders[model->skinref[skinidx]];
R_HL_BuildFrame(model, body, bodyindex, m, texinfo, *b->mesh);
}
}
}
b->meshes = 1;
}
qboolean R_CalcModelLighting(entity_t *e, model_t *clmodel);
void R_HalfLife_TouchTextures(model_t *mod)
{
hlmodel_t *model = Mod_Extradata(mod);
unsigned int t;
for (t = 0; t < model->header->numtextures; t++)
Shader_TouchTexnums(&model->shaders[t].defaulttex);
}
void R_HalfLife_GenerateBatches(entity_t *rent, batch_t **batches)
{
hlmodel_t *model = Mod_Extradata(rent->model);
int body, m;
skinfile_t *sk = rent->customskin?Mod_LookupSkin(rent->customskin):NULL;
const unsigned int entity_body = 0/*rent->body*/;
batch_t *b = NULL;
unsigned int surfidx = 0;
R_CalcModelLighting(rent, rent->model); //make sure the ent's lighting is right.
/*if (!model->vbobuilt)
{
mesh_t *mesh = &model->mesh;
vbo_t *vbo = &model->vbo;
vbobctx_t ctx;
model->vbobuilt = true;
BE_VBO_Begin(&ctx, (sizeof(*mesh->xyz_array)+
sizeof(*mesh->colors4b_array)+
sizeof(*mesh->st_array)+
sizeof(*mesh->lmst_array[0])+
sizeof(*mesh->normals_array)+
sizeof(*mesh->bonenums)+
sizeof(*mesh->boneweights)+
sizeof(*mesh->snormals_array)+
sizeof(*mesh->tnormals_array))*mesh->numvertexes);
BE_VBO_Data(&ctx, mesh->xyz_array, sizeof(*mesh->xyz_array)*mesh->numvertexes, &vbo->coord);
BE_VBO_Data(&ctx, mesh->colors4b_array, sizeof(*mesh->colors4b_array)*mesh->numvertexes, &vbo->colours[0]);vbo->colours_bytes = true;
BE_VBO_Data(&ctx, mesh->st_array, sizeof(*mesh->st_array)*mesh->numvertexes, &vbo->texcoord);
BE_VBO_Data(&ctx, mesh->lmst_array[0], sizeof(*mesh->lmst_array[0])*mesh->numvertexes, &vbo->lmcoord[0]);
BE_VBO_Data(&ctx, mesh->normals_array, sizeof(*mesh->normals_array)*mesh->numvertexes, &vbo->normals);
BE_VBO_Data(&ctx, mesh->bonenums, sizeof(*mesh->bonenums)*mesh->numvertexes, &vbo->bonenums);
BE_VBO_Data(&ctx, mesh->boneweights, sizeof(*mesh->boneweights)*mesh->numvertexes, &vbo->boneweights);
#if defined(RTLIGHTS)
BE_VBO_Data(&ctx, mesh->snormals_array, sizeof(*mesh->snormals_array)*mesh->numvertexes, &vbo->tvector);
BE_VBO_Data(&ctx, mesh->tnormals_array, sizeof(*mesh->tnormals_array)*mesh->numvertexes, &vbo->svector);
#endif
BE_VBO_Finish(&ctx, mesh->indexes, mesh->numindexes, &vbo->indicies, &vbo->vbomem, &vbo->ebomem);
}*/
for (body = 0; body < model->numgeomsets; body++)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
hlmdl_bodypart_t *bodypart = (hlmdl_bodypart_t *) ((qbyte *) model->header + model->header->bodypartindex) + body;
int bodyindex = ((sk && body < MAX_GEOMSETS && sk->geomset[body] >= 1)?sk->geomset[body]-1:(entity_body / bodypart->base)) % bodypart->nummodels;
hlmdl_submodel_t *amodel = (hlmdl_submodel_t *) ((qbyte *) model->header + bodypart->modelindex) + bodyindex;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
/* Draw each mesh */
for(m = 0; m < amodel->nummesh; m++, surfidx++)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
hlmdl_mesh_t *mesh = (hlmdl_mesh_t *) ((qbyte *) model->header + amodel->meshindex) + m;
struct hlmodelshaders_s *s;
int skinidx = mesh->skinindex;
texnums_t *skin;
shader_t *shader;
int sort, j;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
if (skinidx >= model->numskinrefs)
continue; //can happen from bad mesh/skin mixing
if (rent->skinnum < model->numskingroups)
skinidx += rent->skinnum * model->numskinrefs;
s = &model->shaders[model->skinref[skinidx]];
if (!s->shader)
{
if (s->defaultshadertext)
s->shader = R_RegisterShader(s->name, SUF_NONE, s->defaultshadertext);
else
s->shader = R_RegisterSkin(rent->model, s->name);
// R_BuildDefaultTexnums(&s->defaulttex, s->shader, 0);
}
skin = &s->defaulttex;
shader = s->shader;
if (sk)
{
int i;
for (i = 0; i < sk->nummappings; i++)
{
if (!strcmp(sk->mappings[i].surface, s->name))
{
skin = &sk->mappings[i].texnums;
shader = sk->mappings[i].shader;
break;
}
}
}
if ( rent->forcedshader ) {
shader = rent->forcedshader;
}
if (b && b->skin->base == skin->base && b->shader == shader && b->meshes < countof(b->user.alias.surfrefs))
; //merging it.
else
{
b = BE_GetTempBatch();
if (!b)
return;
b->skin = skin;
b->shader = shader;
b->buildmeshes = R_HL_BuildMeshes;
b->ent = rent;
b->mesh = NULL;
b->firstmesh = 0;
b->meshes = 0;
b->texture = NULL;
for (j = 0; j < MAXRLIGHTMAPS; j++)
{
b->lightmap[j] = -1;
b->lmlightstyle[j] = INVALID_LIGHTSTYLE;
}
b->flags = 0;
sort = shader->sort;
//fixme: we probably need to force some blend modes based on the surface flags.
if (rent->flags & RF_FORCECOLOURMOD)
b->flags |= BEF_FORCECOLOURMOD;
if (rent->flags & RF_ADDITIVE)
{
b->flags |= BEF_FORCEADDITIVE;
if (sort < SHADER_SORT_ADDITIVE)
sort = SHADER_SORT_ADDITIVE;
}
if (rent->flags & RF_TRANSLUCENT)
{
b->flags |= BEF_FORCETRANSPARENT;
if (SHADER_SORT_PORTAL < sort && sort < SHADER_SORT_BLEND)
sort = SHADER_SORT_BLEND;
}
if (rent->flags & RF_NODEPTHTEST)
{
b->flags |= BEF_FORCENODEPTH;
if (sort < SHADER_SORT_NEAREST)
sort = SHADER_SORT_NEAREST;
}
if (rent->flags & RF_NOSHADOW)
b->flags |= BEF_NOSHADOWS;
b->vbo = NULL;//&model->vbo;
b->next = batches[sort];
batches[sort] = b;
}
b->user.alias.surfrefs[b->meshes++] = (body<<8)|(m&0xff);
}
}
}
void HLMDL_DrawHitBoxes(entity_t *rent)
{
hlmodel_t *model = Mod_Extradata(rent->model);
hlmdl_hitbox_t *hitbox = (hlmdl_hitbox_t*)((char*)model->header+model->header->ofs_hitboxes);
matrix3x4 entitymatrix;
shader_t *shader = R_RegisterShader("hitbox_nodepth", SUF_NONE,
"{\n"
"polygonoffset\n"
"{\n"
"map $whiteimage\n"
"blendfunc gl_src_alpha gl_one\n"
"rgbgen vertex\n"
"alphagen vertex\n"
"nodepthtest\n"
"}\n"
"}\n");
float relbones[MAX_BONES*12];
int bonecount = HLMDL_GetBoneData(rent->model, 0, MAX_BONES, &rent->framestate, relbones);
int b;
entitymatrix[0][0] = rent->axis[0][0];
entitymatrix[0][1] = rent->axis[1][0];
entitymatrix[0][2] = rent->axis[2][0];
entitymatrix[1][0] = rent->axis[0][1];
entitymatrix[1][1] = rent->axis[1][1];
entitymatrix[1][2] = rent->axis[2][1];
entitymatrix[2][0] = rent->axis[0][2];
entitymatrix[2][1] = rent->axis[1][2];
entitymatrix[2][2] = rent->axis[2][2];
entitymatrix[0][3] = rent->origin[0];
entitymatrix[1][3] = rent->origin[1];
entitymatrix[2][3] = rent->origin[2];
//convert relative to absolutes
for (b = 0; b < bonecount; b++)
{
//If we have a parent, take the addition. Otherwise just copy the values
if(model->bones[b].parent>=0)
R_ConcatTransforms((void*)transform_matrix[model->bones[b].parent], (void*)(relbones+b*12), transform_matrix[b]);
else
R_ConcatTransforms((void*)entitymatrix, (void*)(relbones+b*12), transform_matrix[b]);
}
for (b = 0; b < model->header->num_hitboxes; b++, hitbox++)
CLQ1_AddOrientedCube(shader, hitbox->mins, hitbox->maxs, transform_matrix[hitbox->bone][0], 1, 1, 1, 0.2);
}
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink