libretro/libretro-tyrquake
1
0
Fork 0
mirror of https://github.com/libretro/libretro-tyrquake.git synced 2025-02-12 03:31:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

model: make intervals part of daliasgroup_t struct

Browse Source 
The frame intervals always follow the daliasgroup_t structure on disk, so
attach them to the structure as a variable sized array. Pass the correct
types in to Mod_LoadAliasGroup and avoid passing around (void *) pointers.

Signed-off-by: Kevin Shanahan <kmshanah@disenchant.net>
This commit is contained in:
Kevin Shanahan 2012-10-29 13:37:03 +10:30
parent f1ac2404a2
commit d5d9c82ced
3 changed files with 43 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
common/gl_model.c
View File

@ -1318,46 +1318,40 @@ Mod_LoadAliasFrame(const daliasframe_t *in, maliasframedesc_t *frame)
/* /*
================= =================
Mod_LoadAliasGroup Mod_LoadAliasGroup
returns a pointer to the memory location following this frame group
================= =================
*/ */
static void * static daliasframetype_t *
Mod_LoadAliasGroup(void *pin, maliasframedesc_t *frame) Mod_LoadAliasGroup(const daliasgroup_t *in, maliasframedesc_t *frame)
{ {
daliasgroup_t *pingroup;
int i, numframes; int i, numframes;
daliasinterval_t *pin_intervals; daliasframe_t *dframe;
void *ptemp;
pingroup = (daliasgroup_t *)pin;
numframes = LittleLong(pingroup->numframes);
numframes = LittleLong(in->numframes);
frame->firstpose = posenum; frame->firstpose = posenum;
frame->numposes = numframes; frame->numposes = numframes;
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
// these are byte values, so we don't have to worry about endianness // these are byte values, so we don't have to worry about endianness
frame->bboxmin.v[i] = pingroup->bboxmin.v[i]; frame->bboxmin.v[i] = in->bboxmin.v[i];
frame->bboxmin.v[i] = pingroup->bboxmax.v[i]; frame->bboxmin.v[i] = in->bboxmax.v[i];
} }
pin_intervals = (daliasinterval_t *)(pingroup + 1); /*
* FIXME: the on-disk format allows for one interval per frame, but here
frame->interval = LittleFloat(pin_intervals->interval); * the entire frame group gets just one interval. Probably all the
* original quake art assets just use a constant interval.
pin_intervals += numframes; */
frame->interval = LittleFloat(in->intervals[0].interval);
ptemp = (void *)pin_intervals; dframe = (daliasframe_t *)&in->intervals[numframes];
for (i = 0; i < numframes; i++) { for (i = 0; i < numframes; i++) {
poseverts[posenum] = (trivertx_t *)((daliasframe_t *)ptemp + 1); poseverts[posenum] = dframe->verts;
posenum++; posenum++;
dframe = (daliasframe_t *)&dframe->verts[pheader->numverts];
ptemp =
(trivertx_t *)((daliasframe_t *)ptemp + 1) + pheader->numverts;
} }
return ptemp; return (daliasframetype_t *)dframe;
} }
//========================================================= //=========================================================
@ -1545,6 +1539,7 @@ Mod_LoadAliasModel(model_t *mod, void *buffer)
int size; int size;
daliasframetype_t *pframetype; daliasframetype_t *pframetype;
daliasframe_t *frame; daliasframe_t *frame;
daliasgroup_t *group;
daliasskintype_t *pskintype; daliasskintype_t *pskintype;
int start, end, total; int start, end, total;
@ -1685,8 +1680,8 @@ Mod_LoadAliasModel(model_t *mod, void *buffer)
Mod_LoadAliasFrame(frame, &pheader->frames[i]); Mod_LoadAliasFrame(frame, &pheader->frames[i]);
pframetype = (daliasframetype_t *)&frame->verts[pheader->numverts]; pframetype = (daliasframetype_t *)&frame->verts[pheader->numverts];
} else { } else {
pframetype = (daliasframetype_t *) group = (daliasgroup_t *)(pframetype + 1);
Mod_LoadAliasGroup(pframetype + 1, &pheader->frames[i]); pframetype = Mod_LoadAliasGroup(group, &pheader->frames[i]);
} }
} }

43
common/model.c
View File

@ -1280,54 +1280,45 @@ Mod_LoadAliasFrame(const daliasframe_t *in, int *pframeindex, int numv,
/* /*
================= =================
Mod_LoadAliasGroup Mod_LoadAliasGroup
returns a pointer to the memory location following this frame group
================= =================
*/ */
static void * static daliasframetype_t *
Mod_LoadAliasGroup(void *pin, int *pframeindex, int numv, Mod_LoadAliasGroup(const daliasgroup_t *in, int *pframeindex, int numv,
trivertx_t *pbboxmin, trivertx_t *pbboxmax, trivertx_t *pbboxmin, trivertx_t *pbboxmax,
char *name) char *name)
{ {
daliasgroup_t *pingroup;
maliasgroup_t *paliasgroup; maliasgroup_t *paliasgroup;
int i, numframes; int i, numframes;
daliasinterval_t *pin_intervals;
float *poutintervals; float *poutintervals;
daliasframe_t *frame; daliasframe_t *frame;
pingroup = (daliasgroup_t *)pin; numframes = LittleLong(in->numframes);
numframes = LittleLong(pingroup->numframes);
paliasgroup = Hunk_AllocName(sizeof(maliasgroup_t) + paliasgroup = Hunk_AllocName(sizeof(maliasgroup_t) +
numframes * sizeof(paliasgroup->frames[0]), numframes * sizeof(paliasgroup->frames[0]),
loadname); loadname);
paliasgroup->numframes = numframes; paliasgroup->numframes = numframes;
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
// these are byte values, so we don't have to worry about endianness // these are byte values, so we don't have to worry about endianness
pbboxmin->v[i] = pingroup->bboxmin.v[i]; pbboxmin->v[i] = in->bboxmin.v[i];
pbboxmax->v[i] = pingroup->bboxmax.v[i]; pbboxmax->v[i] = in->bboxmax.v[i];
} }
*pframeindex = (byte *)paliasgroup - (byte *)pheader; *pframeindex = (byte *)paliasgroup - (byte *)pheader;
pin_intervals = (daliasinterval_t *)(pingroup + 1);
poutintervals = Hunk_AllocName(numframes * sizeof(float), loadname); poutintervals = Hunk_AllocName(numframes * sizeof(float), loadname);
paliasgroup->intervals = (byte *)poutintervals - (byte *)pheader; paliasgroup->intervals = (byte *)poutintervals - (byte *)pheader;
for (i = 0; i < numframes; i++) { for (i = 0; i < numframes; i++) {
*poutintervals = LittleFloat(pin_intervals->interval); *poutintervals = LittleFloat(in->intervals[i].interval);
if (*poutintervals <= 0.0) if (*poutintervals <= 0.0)
Sys_Error("%s: interval <= 0", __func__); Sys_Error("%s: interval <= 0", __func__);
poutintervals++; poutintervals++;
pin_intervals++;
} }
frame = (daliasframe_t *)pin_intervals; frame = (daliasframe_t *)&in->intervals[numframes];
for (i = 0; i < numframes; i++) { for (i = 0; i < numframes; i++) {
Mod_LoadAliasFrame(frame, &paliasgroup->frames[i].frame, numv, Mod_LoadAliasFrame(frame, &paliasgroup->frames[i].frame, numv,
&paliasgroup->frames[i].bboxmin, &paliasgroup->frames[i].bboxmin,
@ -1335,7 +1326,7 @@ Mod_LoadAliasGroup(void *pin, int *pframeindex, int numv,
frame = (daliasframe_t *)&frame->verts[numv]; frame = (daliasframe_t *)&frame->verts[numv];
} }
return frame; return (daliasframetype_t *)frame;
} }
@ -1442,6 +1433,7 @@ Mod_LoadAliasModel(model_t *mod, void *buffer)
int size; int size;
daliasframetype_t *pframetype; daliasframetype_t *pframetype;
daliasframe_t *frame; daliasframe_t *frame;
daliasgroup_t *group;
daliasskintype_t *pskintype; daliasskintype_t *pskintype;
maliasskindesc_t *pskindesc; maliasskindesc_t *pskindesc;
int skinsize; int skinsize;
@ -1630,13 +1622,12 @@ Mod_LoadAliasModel(model_t *mod, void *buffer)
pheader->frames[i].name); pheader->frames[i].name);
pframetype = (daliasframetype_t *)&frame->verts[pmodel->numverts]; pframetype = (daliasframetype_t *)&frame->verts[pmodel->numverts];
} else { } else {
pframetype = (daliasframetype_t *) group = (daliasgroup_t *)(pframetype + 1);
Mod_LoadAliasGroup(pframetype + 1, pframetype = Mod_LoadAliasGroup(group, &pheader->frames[i].frame,
&pheader->frames[i].frame, pmodel->numverts,
pmodel->numverts, &pheader->frames[i].bboxmin,
&pheader->frames[i].bboxmin, &pheader->frames[i].bboxmax,
&pheader->frames[i].bboxmax, pheader->frames[i].name);
pheader->frames[i].name);
} }
} }

9
include/modelgen.h
View File

@ -95,20 +95,21 @@ typedef struct {
trivertx_t verts[0]; // frame verticies (mdl_t->numverts) trivertx_t verts[0]; // frame verticies (mdl_t->numverts)
} daliasframe_t; } daliasframe_t;
typedef struct {
float interval;
} daliasinterval_t;
typedef struct { typedef struct {
int numframes; int numframes;
trivertx_t bboxmin; // lightnormal isn't used trivertx_t bboxmin; // lightnormal isn't used
trivertx_t bboxmax; // lightnormal isn't used trivertx_t bboxmax; // lightnormal isn't used
daliasinterval_t intervals[0]; // daliasgroup_t->numframes
} daliasgroup_t; } daliasgroup_t;
typedef struct { typedef struct {
int numskins; int numskins;
} daliasskingroup_t; } daliasskingroup_t;
typedef struct {
float interval;
} daliasinterval_t;
typedef struct { typedef struct {
float interval; float interval;
} daliasskininterval_t; } daliasskininterval_t;