qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-03-22 10:21:21 +00:00
Code Issues Projects Releases Packages Wiki Activity

[sprite] Clean up field names and casting

Browse source 
No wonder I hated the sprite code: I couldn't see the code for all the
casts (and hungarian warts).
This commit is contained in:
Bill Currie 2021-12-11 17:05:40 +09:00
parent 1df3c2eea0
commit 0a5981878b
7 changed files with 56 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
include/QF/model.h
View file

@ -297,16 +297,18 @@ typedef struct {
typedef struct {
spriteframetype_t type;
mspriteframe_t *frameptr;
union {
mspriteframe_t *frame;
mspritegroup_t *group;
};
} mspriteframedesc_t;
typedef struct {
int type;
int maxwidth;
int maxheight;
float beamlength;
int numframes;
float beamlength; // remove?
void *cachespot; // remove?
mspriteframedesc_t frames[1];
} msprite_t;

4
libs/models/sprite/glsl_model_sprite.c
View file

@ -58,10 +58,10 @@ glsl_sprite_clear (model_t *m, void *data)
m->cache.data = 0;
for (i = 0; i < sprite->numframes; i++) {
if (sprite->frames[i].type == SPR_SINGLE) {
frame = sprite->frames[i].frameptr;
frame = sprite->frames[i].frame;
GLSL_ReleaseTexture (frame->gl_texturenum);
} else {
group = (mspritegroup_t *) sprite->frames[i].frameptr;
group = sprite->frames[i].group;
for (j = 0; j < group->numframes; j++) {
frame = group->frames[j];
GLSL_ReleaseTexture (frame->gl_texturenum);

91
libs/models/sprite/model_sprite.c
View file

@ -42,90 +42,79 @@
#include "mod_internal.h"
static void *
Mod_LoadSpriteFrame (model_t *mod, void *pin, mspriteframe_t **ppframe,
Mod_LoadSpriteFrame (model_t *mod, void *pin, mspriteframe_t **frame,
int framenum)
{
dspriteframe_t *pinframe;
dspriteframe_t *in_frame;
int width, height, size, origin[2];
mspriteframe_t *pspriteframe;
pinframe = (dspriteframe_t *) pin;
in_frame = (dspriteframe_t *) pin;
width = LittleLong (pinframe->width);
height = LittleLong (pinframe->height);
width = LittleLong (in_frame->width);
height = LittleLong (in_frame->height);
size = width * height;
pspriteframe = Hunk_AllocName (0, sizeof (mspriteframe_t) + size,
mod->name);
*frame = Hunk_AllocName (0, sizeof (mspriteframe_t) + size, mod->name);
memset (pspriteframe, 0, sizeof (mspriteframe_t) + size);
(*frame)->width = width;
(*frame)->height = height;
origin[0] = LittleLong (in_frame->origin[0]);
origin[1] = LittleLong (in_frame->origin[1]);
*ppframe = pspriteframe;
(*frame)->up = origin[1];
(*frame)->down = origin[1] - height;
(*frame)->left = origin[0];
(*frame)->right = width + origin[0];
pspriteframe->width = width;
pspriteframe->height = height;
origin[0] = LittleLong (pinframe->origin[0]);
origin[1] = LittleLong (pinframe->origin[1]);
memcpy ((*frame)->pixels, (byte *) (in_frame + 1), size);
pspriteframe->up = origin[1];
pspriteframe->down = origin[1] - height;
pspriteframe->left = origin[0];
pspriteframe->right = width + origin[0];
m_funcs->Mod_SpriteLoadTexture (mod, *frame, framenum);
memcpy (pspriteframe->pixels, (byte *) (pinframe + 1), size);
m_funcs->Mod_SpriteLoadTexture (mod, pspriteframe, framenum);
return (void *) ((byte *) pinframe + sizeof (dspriteframe_t) + size);
return (void *) ((byte *) in_frame + sizeof (dspriteframe_t) + size);
}
static void *
Mod_LoadSpriteGroup (model_t *mod, void *pin, mspriteframe_t **ppframe,
Mod_LoadSpriteGroup (model_t *mod, void *pin, mspritegroup_t **group,
int framenum)
{
dspritegroup_t *pingroup;
dspriteinterval_t *pin_intervals;
float *poutintervals;
dspritegroup_t *in_group;
dspriteinterval_t *in_intervals;
float *intervals;
int numframes, i;
mspritegroup_t *pspritegroup;
void *ptemp;
void *temp;
pingroup = (dspritegroup_t *) pin;
in_group = (dspritegroup_t *) pin;
numframes = LittleLong (pingroup->numframes);
numframes = LittleLong (in_group->numframes);
pspritegroup = Hunk_AllocName (0, field_offset (mspritegroup_t,
frames[numframes]),
mod->name);
int size = field_offset (mspritegroup_t, frames[numframes]);
*group = Hunk_AllocName (0, size, mod->name);
pspritegroup->numframes = numframes;
(*group)->numframes = numframes;
*ppframe = (mspriteframe_t *) pspritegroup;
in_intervals = (dspriteinterval_t *) (in_group + 1);
pin_intervals = (dspriteinterval_t *) (pingroup + 1);
intervals = Hunk_AllocName (0, numframes * sizeof (float), mod->name);
poutintervals = Hunk_AllocName (0, numframes * sizeof (float), mod->name);
pspritegroup->intervals = poutintervals;
(*group)->intervals = intervals;
for (i = 0; i < numframes; i++) {
*poutintervals = LittleFloat (pin_intervals->interval);
if (*poutintervals <= 0.0)
*intervals = LittleFloat (in_intervals->interval);
if (*intervals <= 0.0)
Sys_Error ("Mod_LoadSpriteGroup: interval<=0");
poutintervals++;
pin_intervals++;
intervals++;
in_intervals++;
}
ptemp = (void *) pin_intervals;
temp = (void *) in_intervals;
for (i = 0; i < numframes; i++) {
ptemp =
Mod_LoadSpriteFrame (mod, ptemp, &pspritegroup->frames[i],
framenum * 100 + i);
temp = Mod_LoadSpriteFrame (mod, temp, &(*group)->frames[i],
framenum * 100 + i);
}
return ptemp;
return temp;
}
void
@ -180,11 +169,11 @@ Mod_LoadSpriteModel (model_t *mod, void *buffer)
if (frametype == SPR_SINGLE) {
pframetype = (dspriteframetype_t *)
Mod_LoadSpriteFrame (mod, pframetype + 1,
&psprite->frames[i].frameptr, i);
&psprite->frames[i].frame, i);
} else {
pframetype = (dspriteframetype_t *)
Mod_LoadSpriteGroup (mod, pframetype + 1,
&psprite->frames[i].frameptr, i);
&psprite->frames[i].group, i);
}
}

4
libs/video/renderer/gl/gl_mod_sprite.c
View file

@ -77,9 +77,9 @@ R_GetSpriteFrame (entity_t *ent)
}
if (psprite->frames[frame].type == SPR_SINGLE) {
pspriteframe = psprite->frames[frame].frameptr;
pspriteframe = psprite->frames[frame].frame;
} else {
pspritegroup = (mspritegroup_t *) psprite->frames[frame].frameptr;
pspritegroup = psprite->frames[frame].group;
pintervals = pspritegroup->intervals;
numframes = pspritegroup->numframes;
fullinterval = pintervals[numframes - 1];

6
libs/video/renderer/glsl/glsl_sprite.c
View file

@ -152,7 +152,7 @@ R_GetSpriteFrames (entity_t *ent, msprite_t *sprite, mspriteframe_t **frame1,
frame_interval = 0.1;
pose = framenum;
} else {
group = (mspritegroup_t *) framedesc->frameptr;
group = framedesc->group;
intervals = group->intervals;
numframes = group->numframes;
fullinterval = intervals[numframes - 1];
@ -177,8 +177,8 @@ R_GetSpriteFrames (entity_t *ent, msprite_t *sprite, mspriteframe_t **frame1,
*frame1 = group->frames[animation->pose1];
*frame2 = group->frames[animation->pose2];
} else {
*frame1 = sprite->frames[animation->pose1].frameptr;
*frame2 = sprite->frames[animation->pose2].frameptr;
*frame1 = sprite->frames[animation->pose1].frame;
*frame2 = sprite->frames[animation->pose2].frame;
}
}

4
libs/video/renderer/sw/sw_rsprite.c
View file

@ -256,9 +256,9 @@ R_GetSpriteframe (msprite_t *psprite)
}
if (psprite->frames[frame].type == SPR_SINGLE) {
pspriteframe = psprite->frames[frame].frameptr;
pspriteframe = psprite->frames[frame].frame;
} else {
pspritegroup = (mspritegroup_t *) psprite->frames[frame].frameptr;
pspritegroup = psprite->frames[frame].group;
pintervals = pspritegroup->intervals;
numframes = pspritegroup->numframes;
fullinterval = pintervals[numframes - 1];

4
libs/video/renderer/sw32/sw32_rsprite.c
View file

@ -252,9 +252,9 @@ R_GetSpriteframe (msprite_t *psprite)
}
if (psprite->frames[frame].type == SPR_SINGLE) {
pspriteframe = psprite->frames[frame].frameptr;
pspriteframe = psprite->frames[frame].frame;
} else {
pspritegroup = (mspritegroup_t *) psprite->frames[frame].frameptr;
pspritegroup = psprite->frames[frame].group;
pintervals = pspritegroup->intervals;
numframes = pspritegroup->numframes;
fullinterval = pintervals[numframes - 1];