From cb11d66230c22613b7aee99324783b214b135513 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 28 Mar 2001 07:37:14 +0000 Subject: [PATCH] initial stab at the shared sprite model loader. The gl texture is NOT created but everything should be in a sane state to do so. --- libs/models/sprite/sprite.c | 206 ++++++++++++++++++++++++++++++++++++ 1 file changed, 206 insertions(+) create mode 100644 libs/models/sprite/sprite.c diff --git a/libs/models/sprite/sprite.c b/libs/models/sprite/sprite.c new file mode 100644 index 000000000..41d856e00 --- /dev/null +++ b/libs/models/sprite/sprite.c @@ -0,0 +1,206 @@ +/* + sprite.c + + sprite model loading + + Copyright (C) 1996-1997 Id Software, Inc. + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ + +// models are the only shared resource between a client and server running +// on the same machine. + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "compat.h" +#include "model.h" +#include "qendian.h" +#include "sys.h" +#include "texture.h" + +//extern model_t *loadmodel; +extern char loadname[]; + +/* + Mod_LoadSpriteFrame +*/ +void * +Mod_LoadSpriteFrame (void *pin, mspriteframe_t **ppframe, int framenum) +{ + dspriteframe_t *pinframe; + mspriteframe_t *pspriteframe; + int width, height, size, origin[2]; + int texsize; + + pinframe = (dspriteframe_t *) pin; + + width = LittleLong (pinframe->width); + height = LittleLong (pinframe->height); + size = width * height; + + pspriteframe = Hunk_AllocName (sizeof (mspriteframe_t), loadname); + + texsize = varsizeof (tex_t, data, size); + pspriteframe->texture = Hunk_AllocName (texsize, loadname); + pspriteframe->gl_texturenum = -1; + + *ppframe = pspriteframe; + + pspriteframe->texture->width = width; + pspriteframe->texture->height = height; + origin[0] = LittleLong (pinframe->origin[0]); + origin[1] = LittleLong (pinframe->origin[1]); + + pspriteframe->up = origin[1]; + pspriteframe->down = origin[1] - height; + pspriteframe->left = origin[0]; + pspriteframe->right = width + origin[0]; + + memcpy (pspriteframe->texture->data, (byte *) (pinframe + 1), size); + + return (void *) ((byte *) pinframe + sizeof (dspriteframe_t) + size); +} + +/* + Mod_LoadSpriteGroup +*/ +void * +Mod_LoadSpriteGroup (void *pin, mspriteframe_t **ppframe, int framenum) +{ + dspritegroup_t *pingroup; + mspritegroup_t *pspritegroup; + int i, numframes; + dspriteinterval_t *pin_intervals; + float *poutintervals; + void *ptemp; + + pingroup = (dspritegroup_t *) pin; + + numframes = LittleLong (pingroup->numframes); + + pspritegroup = Hunk_AllocName (sizeof (mspritegroup_t) + + (numframes - + 1) * sizeof (pspritegroup->frames[0]), + + loadname); + + pspritegroup->numframes = numframes; + + *ppframe = (mspriteframe_t *) pspritegroup; + + pin_intervals = (dspriteinterval_t *) (pingroup + 1); + + poutintervals = Hunk_AllocName (numframes * sizeof (float), loadname); + + pspritegroup->intervals = poutintervals; + + for (i = 0; i < numframes; i++) { + *poutintervals = LittleFloat (pin_intervals->interval); + if (*poutintervals <= 0.0) + Sys_Error ("Mod_LoadSpriteGroup: interval<=0"); + + poutintervals++; + pin_intervals++; + } + + ptemp = (void *) pin_intervals; + + for (i = 0; i < numframes; i++) { + ptemp = + Mod_LoadSpriteFrame (ptemp, &pspritegroup->frames[i], + framenum * 100 + i); + } + + return ptemp; +} + +/* + Mod_LoadSpriteModel +*/ +void +Mod_LoadSpriteModel (model_t *mod, void *buffer) +{ + int i; + int version; + dsprite_t *pin; + msprite_t *psprite; + int numframes; + int size; + dspriteframetype_t *pframetype; + + pin = (dsprite_t *) buffer; + + version = LittleLong (pin->version); + if (version != SPRITE_VERSION) + Sys_Error ("%s has wrong version number " + "(%i should be %i)", mod->name, version, SPRITE_VERSION); + + numframes = LittleLong (pin->numframes); + if (numframes < 1) + Sys_Error ("Mod_LoadSpriteModel: Invalid # of frames: %d\n", numframes); + + size = varsizeof (msprite_t, frames, numframes); + + psprite = Hunk_AllocName (size, loadname); + + mod->cache.data = psprite; + + psprite->type = LittleLong (pin->type); + psprite->maxwidth = LittleLong (pin->width); + psprite->maxheight = LittleLong (pin->height); + psprite->beamlength = LittleFloat (pin->beamlength); + mod->synctype = LittleLong (pin->synctype); + psprite->numframes = numframes; + + mod->mins[0] = mod->mins[1] = -psprite->maxwidth / 2; + mod->maxs[0] = mod->maxs[1] = psprite->maxwidth / 2; + mod->mins[2] = -psprite->maxheight / 2; + mod->maxs[2] = psprite->maxheight / 2; + +// +// load the frames +// + mod->numframes = numframes; + + pframetype = (dspriteframetype_t *) (pin + 1); + + for (i = 0; i < numframes; i++) { + spriteframetype_t frametype; + + frametype = LittleLong (pframetype->type); + psprite->frames[i].type = frametype; + + if (frametype == SPR_SINGLE) { + pframetype = (dspriteframetype_t *) + Mod_LoadSpriteFrame (pframetype + 1, + &psprite->frames[i].frameptr, i); + } else { + pframetype = (dspriteframetype_t *) + Mod_LoadSpriteGroup (pframetype + 1, + &psprite->frames[i].frameptr, i); + } + } + + mod->type = mod_sprite; +}