mirror of
https://git.code.sf.net/p/quake/newtree
synced 2024-11-14 16:40:47 +00:00
169 lines
4 KiB
C
169 lines
4 KiB
C
/*
|
|
gl_model.c
|
|
|
|
model loading and caching
|
|
|
|
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 "model.h"
|
|
#include "server.h"
|
|
#include "qendian.h"
|
|
|
|
extern model_t *loadmodel;
|
|
extern char loadname[];
|
|
|
|
void *Mod_LoadSpriteFrame (void *pin, mspriteframe_t **ppframe,
|
|
|
|
int framenum);
|
|
|
|
/*
|
|
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)
|
|
SV_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)
|
|
SV_Error ("%s has wrong version number "
|
|
"(%i should be %i)", mod->name, version, SPRITE_VERSION);
|
|
|
|
numframes = LittleLong (pin->numframes);
|
|
|
|
size = sizeof (msprite_t) + (numframes - 1) * sizeof (psprite->frames);
|
|
|
|
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
|
|
//
|
|
if (numframes < 1)
|
|
SV_Error ("Mod_LoadSpriteModel: Invalid # of frames: %d\n", numframes);
|
|
|
|
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;
|
|
}
|