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

35
common/model.c
View File

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

9
include/modelgen.h
View File

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