qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-01-18 06:51:47 +00:00
Code Issues Projects Releases Packages Wiki Activity

don't need these any more

Browse source
This commit is contained in:
Bill Currie 2001-05-10 15:30:23 +00:00
parent d3d3a1c451
commit 77eed96c91
11 changed files with 0 additions and 2739 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

323
nq/source/gl_model_alias.c
View file

@ -1,323 +0,0 @@
/*
gl_model_alias.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 "r_local.h"
#include "QF/sys.h"
#include "QF/compat.h"
#include "QF/console.h"
#include "QF/qendian.h"
#include "QF/checksum.h"
#include "glquake.h"
extern char loadname[];
extern model_t *loadmodel;
/*
==============================================================================
ALIAS MODELS
==============================================================================
*/
extern aliashdr_t *pheader;
extern stvert_t stverts[MAXALIASVERTS];
extern mtriangle_t triangles[MAXALIASTRIS];
// a pose is a single set of vertexes. a frame may be
// an animating sequence of poses
extern trivertx_t *poseverts[MAXALIASFRAMES];
extern int posenum;
/*
=================
Mod_FloodFillSkin
Fill background pixels so mipmapping doesn't have haloes - Ed
=================
*/
typedef struct {
short x, y;
} floodfill_t;
extern unsigned d_8to24table[];
// must be a power of 2
#define FLOODFILL_FIFO_SIZE 0x1000
#define FLOODFILL_FIFO_MASK (FLOODFILL_FIFO_SIZE - 1)
#define FLOODFILL_STEP( off, dx, dy ) \
{ \
if (pos[off] == fillcolor) \
{ \
pos[off] = 255; \
fifo[inpt].x = x + (dx), fifo[inpt].y = y + (dy); \
inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; \
} \
else if (pos[off] != 255) fdc = pos[off]; \
}
void
Mod_FloodFillSkin (byte * skin, int skinwidth, int skinheight)
{
byte fillcolor = *skin; // assume this is the pixel to fill
floodfill_t fifo[FLOODFILL_FIFO_SIZE];
int inpt = 0, outpt = 0;
int filledcolor = -1;
int i;
if (filledcolor == -1) {
filledcolor = 0;
// attempt to find opaque black
for (i = 0; i < 256; ++i)
if (d_8to24table[i] == (255 << 0)) // alpha 1.0
{
filledcolor = i;
break;
}
}
// can't fill to filled color or to transparent color (used as visited
// marker)
if ((fillcolor == filledcolor) || (fillcolor == 255)) {
// printf( "not filling skin from %d to %d\n", fillcolor, filledcolor
//
//
// );
return;
}
fifo[inpt].x = 0, fifo[inpt].y = 0;
inpt = (inpt + 1) & FLOODFILL_FIFO_MASK;
while (outpt != inpt) {
int x = fifo[outpt].x, y = fifo[outpt].y;
int fdc = filledcolor;
byte *pos = &skin[x + skinwidth * y];
outpt = (outpt + 1) & FLOODFILL_FIFO_MASK;
if (x > 0)
FLOODFILL_STEP (-1, -1, 0);
if (x < skinwidth - 1)
FLOODFILL_STEP (1, 1, 0);
if (y > 0)
FLOODFILL_STEP (-skinwidth, 0, -1);
if (y < skinheight - 1)
FLOODFILL_STEP (skinwidth, 0, 1);
skin[x + skinwidth * y] = fdc;
}
}
int Mod_Fullbright (byte * skin, int width, int height, char *name);
void *
Mod_LoadSkin (byte * skin, int skinsize, int snum, int gnum, qboolean group)
{
char name[32];
int fbtexnum;
Mod_FloodFillSkin (skin, pheader->mdl.skinwidth, pheader->mdl.skinheight);
// save 8 bit texels for the player model to remap
if (!strcmp (loadmodel->name, "progs/player.mdl")) {
byte *texels = Hunk_AllocName (skinsize, loadname);
pheader->texels[snum] = texels - (byte *) pheader;
memcpy (texels, skin, skinsize);
}
if (group) {
snprintf (name, sizeof (name), "fb_%s_%i_%i", loadmodel->name, snum,
gnum);
} else {
snprintf (name, sizeof (name), "fb_%s_%i", loadmodel->name, snum);
}
fbtexnum =
Mod_Fullbright (skin + 1, pheader->mdl.skinwidth,
pheader->mdl.skinheight, name);
if ((loadmodel->hasfullbrights = (fbtexnum))) {
pheader->gl_fb_texturenum[snum][gnum] = fbtexnum;
}
if (group) {
snprintf (name, sizeof (name), "%s_%i_%i", loadmodel->name, snum, gnum);
} else {
snprintf (name, sizeof (name), "%s_%i", loadmodel->name, snum);
}
pheader->gl_texturenum[snum][gnum] =
GL_LoadTexture (name, pheader->mdl.skinwidth,
pheader->mdl.skinheight, skin, true, false, 1);
// alpha param was true for non group skins
return skin + skinsize;
}
/*
===============
Mod_LoadAllSkins
===============
*/
void *
Mod_LoadAllSkins (int numskins, daliasskintype_t *pskintype, int *pskinindex)
{
int i, j, k;
int skinsize;
byte *skin;
daliasskingroup_t *pinskingroup;
int groupskins;
daliasskininterval_t *pinskinintervals;
if (numskins < 1 || numskins > MAX_SKINS)
Sys_Error ("Mod_LoadAliasModel: Invalid # of skins: %d\n", numskins);
skinsize = pheader->mdl.skinwidth * pheader->mdl.skinheight;
for (i = 0; i < numskins; i++) {
if (pskintype->type == ALIAS_SKIN_SINGLE) {
skin = (byte *) (pskintype + 1);
skin = Mod_LoadSkin (skin, skinsize, i, 0, false);
for (j = 1; j < 4; j++) {
pheader->gl_texturenum[i][j] = pheader->gl_texturenum[i][j - 1];
pheader->gl_fb_texturenum[i][j] =
pheader->gl_fb_texturenum[i][j - 1];
}
} else {
// animating skin group. yuck.
// Con_Printf("Animating Skin Group, if you get this message
// please notify warp@debian.org\n");
pskintype++;
pinskingroup = (daliasskingroup_t *) pskintype;
groupskins = LittleLong (pinskingroup->numskins);
pinskinintervals = (daliasskininterval_t *) (pinskingroup + 1);
pskintype = (void *) (pinskinintervals + groupskins);
skin = (byte *) pskintype;
for (j = 0; j < groupskins; j++) {
skin = Mod_LoadSkin (skin, skinsize, i, j & 3, true);
}
k = j;
for ( /* */ ; j < 4; j++) {
pheader->gl_texturenum[i][j] = pheader->gl_texturenum[i][j - k];
pheader->gl_fb_texturenum[i][j] =
pheader->gl_fb_texturenum[i][j - k];
}
}
pskintype = (daliasskintype_t *) skin;
}
return pskintype;
}
/*
=================
Mod_LoadAliasFrame
=================
*/
void *
Mod_LoadAliasFrame (void *pin, maliasframedesc_t *frame)
{
trivertx_t *pinframe;
int i;
daliasframe_t *pdaliasframe;
pdaliasframe = (daliasframe_t *) pin;
strcpy (frame->name, pdaliasframe->name);
frame->firstpose = posenum;
frame->numposes = 1;
for (i = 0; i < 3; i++) {
// these are byte values, so we don't have to worry about
// endianness
frame->bboxmin.v[i] = pdaliasframe->bboxmin.v[i];
frame->bboxmax.v[i] = pdaliasframe->bboxmax.v[i];
}
pinframe = (trivertx_t *) (pdaliasframe + 1);
poseverts[posenum] = pinframe;
posenum++;
pinframe += pheader->mdl.numverts;
return (void *) pinframe;
}
/*
=================
Mod_LoadAliasGroup
=================
*/
void *
Mod_LoadAliasGroup (void *pin, maliasframedesc_t *frame)
{
daliasgroup_t *pingroup;
int i, numframes;
daliasinterval_t *pin_intervals;
void *ptemp;
pingroup = (daliasgroup_t *) pin;
numframes = LittleLong (pingroup->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->bboxmax.v[i] = pingroup->bboxmax.v[i];
}
pin_intervals = (daliasinterval_t *) (pingroup + 1);
frame->interval = LittleFloat (pin_intervals->interval);
pin_intervals += numframes;
ptemp = (void *) pin_intervals;
for (i = 0; i < numframes; i++) {
poseverts[posenum] = (trivertx_t *) ((daliasframe_t *) ptemp + 1);
posenum++;
ptemp =
(trivertx_t *) ((daliasframe_t *) ptemp + 1) +
pheader->mdl.numverts;
}
return ptemp;
}

105
nq/source/gl_model_brush.c
View file

@ -1,105 +0,0 @@
/*
gl_model_brush.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 "r_local.h"
#include "QF/sys.h"
#include "QF/compat.h"
#include "QF/console.h"
#include "QF/qendian.h"
#include "QF/checksum.h"
#include "glquake.h"
extern char loadname[];
extern model_t *loadmodel;
extern byte mod_novis[];
extern byte *mod_base;
int Mod_Fullbright (byte * skin, int width, int height, char *name);
const int mod_lightmap_bytes = 3;
void
Mod_ProcessTexture (miptex_t *mt, texture_t *tx)
{
char name[32];
snprintf (name, sizeof (name), "fb_%s", mt->name);
tx->gl_fb_texturenum =
Mod_Fullbright ((byte *) (tx + 1), tx->width, tx->height, name);
tx->gl_texturenum =
GL_LoadTexture (mt->name, tx->width, tx->height, (byte *) (tx + 1),
true, false, 1);
}
/*
=================
Mod_LoadLighting
=================
*/
void
Mod_LoadLighting (lump_t *l)
{
int i;
byte *in, *out;
byte d;
char litfilename[1024];
if (!l->filelen) {
loadmodel->lightdata = NULL;
return;
}
strcpy (litfilename, loadmodel->name);
COM_StripExtension (litfilename, litfilename);
strcat (litfilename, ".lit");
loadmodel->lightdata = (byte *) COM_LoadHunkFile (litfilename);
if (!loadmodel->lightdata) // expand the white lighting data
{
loadmodel->lightdata = Hunk_AllocName (l->filelen * 3, litfilename);
in = loadmodel->lightdata + l->filelen * 2; // place the file at the
// end, so it will not be
// overwritten until the
// very last write
out = loadmodel->lightdata;
memcpy (in, mod_base + l->fileofs, l->filelen);
for (i = 0; i < l->filelen; i++) {
d = *in++;
*out++ = d;
*out++ = d;
*out++ = d;
}
}
}

80
nq/source/gl_model_fullbright.c
View file

@ -1,80 +0,0 @@
/*
gl_model_fullbright.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 "r_local.h"
#include "QF/sys.h"
#include "QF/console.h"
#include "QF/qendian.h"
#include "QF/checksum.h"
#include "glquake.h"
int
Mod_Fullbright (byte * skin, int width, int height, char *name)
{
int j;
int pixels;
qboolean hasfullbrights = false;
int texnum;
// Check for fullbright pixels..
pixels = width * height;
for (j = 0; j < pixels; j++) {
if (skin[j] >= 256 - 32) {
hasfullbrights = true;
break;
}
}
if (hasfullbrights) {
byte *ptexels;
// ptexels = Hunk_Alloc(s);
ptexels = malloc (pixels);
Con_DPrintf ("FB Model ID: '%s'\n", name);
for (j = 0; j < pixels; j++) {
if (skin[j] >= 256 - 32) {
ptexels[j] = skin[j];
} else {
ptexels[j] = 255;
}
}
texnum = GL_LoadTexture (name, width, height, ptexels, true, true, 1);
free (ptexels);
return texnum;
}
return 0;
}

85
nq/source/gl_model_sprite.c
View file

@ -1,85 +0,0 @@
/*
gl_model_sprite.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$
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "r_local.h"
#include "QF/sys.h"
#include "QF/compat.h"
#include "QF/console.h"
#include "QF/qendian.h"
#include "QF/checksum.h"
#include "glquake.h"
extern char loadname[];
extern model_t *loadmodel;
/*
=================
Mod_LoadSpriteFrame
=================
*/
void *
Mod_LoadSpriteFrame (void *pin, mspriteframe_t **ppframe, int framenum)
{
dspriteframe_t *pinframe;
mspriteframe_t *pspriteframe;
int width, height, size, origin[2];
char name[64];
pinframe = (dspriteframe_t *) pin;
width = LittleLong (pinframe->width);
height = LittleLong (pinframe->height);
size = width * height;
pspriteframe = Hunk_AllocName (sizeof (mspriteframe_t), loadname);
memset (pspriteframe, 0, sizeof (mspriteframe_t));
*ppframe = pspriteframe;
pspriteframe->width = width;
pspriteframe->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];
snprintf (name, sizeof (name), "%s_%i", loadmodel->name, framenum);
pspriteframe->gl_texturenum =
GL_LoadTexture (name, width, height, (byte *) (pinframe + 1), true,
true, 1);
return (void *) ((byte *) pinframe + sizeof (dspriteframe_t) + size);
}

260
nq/source/model.c
View file

@ -1,260 +0,0 @@
/*
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 "r_local.h"
#include "QF/sys.h"
#include "QF/console.h"
#include "QF/qendian.h"
#include "QF/checksum.h"
model_t *loadmodel;
char loadname[32]; // for hunk tags
void Mod_LoadSpriteModel (model_t *mod, void *buffer);
void Mod_LoadBrushModel (model_t *mod, void *buffer);
void Mod_LoadAliasModel (model_t *mod, void *buffer);
model_t *Mod_LoadModel (model_t *mod, qboolean crash);
byte mod_novis[MAX_MAP_LEAFS / 8];
#define MAX_MOD_KNOWN 512
model_t mod_known[MAX_MOD_KNOWN];
int mod_numknown;
unsigned *model_checksum;
texture_t *r_notexture_mip;
cvar_t *gl_subdivide_size;
/*
===============
Mod_Init
===============
*/
void
Mod_Init (void)
{
gl_subdivide_size =
Cvar_Get ("gl_subdivide_size", "128", CVAR_ARCHIVE, NULL, "None");
memset (mod_novis, 0xff, sizeof (mod_novis));
}
/*
===================
Mod_ClearAll
===================
*/
void
Mod_ClearAll (void)
{
int i;
model_t *mod;
for (i = 0, mod = mod_known; i < mod_numknown; i++, mod++)
if (mod->type != mod_alias)
mod->needload = true;
}
/*
==================
Mod_FindName
==================
*/
model_t *
Mod_FindName (char *name)
{
int i;
model_t *mod;
if (!name[0])
Sys_Error ("Mod_FindName: NULL name");
//
// search the currently loaded models
//
for (i = 0, mod = mod_known; i < mod_numknown; i++, mod++)
if (!strcmp (mod->name, name))
break;
if (i == mod_numknown) {
if (mod_numknown == MAX_MOD_KNOWN)
Sys_Error ("mod_numknown == MAX_MOD_KNOWN");
strcpy (mod->name, name);
mod->needload = true;
mod_numknown++;
}
return mod;
}
/*
==================
Mod_LoadModel
Loads a model into the cache
==================
*/
model_t *
Mod_LoadModel (model_t *mod, qboolean crash)
{
void *d;
unsigned *buf;
byte stackbuf[1024]; // avoid dirtying the cache heap
if (!mod->needload) {
if (mod->type == mod_alias) {
d = Cache_Check (&mod->cache);
if (d)
return mod;
} else
return mod; // not cached at all
}
//
// load the file
//
buf =
(unsigned *) COM_LoadStackFile (mod->name, stackbuf, sizeof (stackbuf));
if (!buf) {
if (crash)
Sys_Error ("Mod_LoadModel: %s not found", mod->name);
return NULL;
}
//
// allocate a new model
//
COM_FileBase (mod->name, loadname);
loadmodel = mod;
//
// fill it in
//
// call the apropriate loader
mod->needload = false;
mod->hasfullbrights = false;
switch (LittleLong (*(unsigned *) buf)) {
case IDPOLYHEADER:
Mod_LoadAliasModel (mod, buf);
break;
case IDSPRITEHEADER:
Mod_LoadSpriteModel (mod, buf);
break;
default:
Mod_LoadBrushModel (mod, buf);
break;
}
return mod;
}
/*
==================
Mod_ForName
Loads in a model for the given name
==================
*/
model_t *
Mod_ForName (char *name, qboolean crash)
{
model_t *mod;
mod = Mod_FindName (name);
return Mod_LoadModel (mod, crash);
}
/*
===============
Mod_Extradata
Caches the data if needed
===============
*/
void *
Mod_Extradata (model_t *mod)
{
void *r;
r = Cache_Check (&mod->cache);
if (r)
return r;
Mod_LoadModel (mod, true);
if (!mod->cache.data)
Sys_Error ("Mod_Extradata: caching failed");
return mod->cache.data;
}
/*
==================
Mod_TouchModel
==================
*/
void
Mod_TouchModel (char *name)
{
model_t *mod;
mod = Mod_FindName (name);
if (!mod->needload) {
if (mod->type == mod_alias)
Cache_Check (&mod->cache);
}
}
/*
================
Mod_Print
================
*/
void
Mod_Print (void)
{
int i;
model_t *mod;
Con_Printf ("Cached models:\n");
for (i = 0, mod = mod_known; i < mod_numknown; i++, mod++) {
Con_Printf ("%8p : %s\n", mod->cache.data, mod->name);
}
}

232
nq/source/model_alias.c
View file

@ -1,232 +0,0 @@
/*
model_alias.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 "r_local.h"
#include "QF/sys.h"
#include "QF/console.h"
#include "QF/qendian.h"
#include "QF/checksum.h"
extern char loadname[];
extern model_t *loadmodel;
void *Mod_LoadAllSkins (int numskins, daliasskintype_t *pskintype,
int *pskinindex);
void GL_MakeAliasModelDisplayLists (model_t *m, aliashdr_t *hdr,
void *model, int size);
/*
==============================================================================
ALIAS MODELS
==============================================================================
*/
aliashdr_t *pheader;
stvert_t stverts[MAXALIASVERTS];
mtriangle_t triangles[MAXALIASTRIS];
// a pose is a single set of vertexes. a frame may be
// an animating sequence of poses
trivertx_t *poseverts[MAXALIASFRAMES];
int posenum;
void *Mod_LoadAliasFrame (void *pin, maliasframedesc_t *frame);
void *Mod_LoadAliasGroup (void *pin, maliasframedesc_t *frame);
//=========================================================================
/*
=================
Mod_LoadAliasModel
=================
*/
void
Mod_LoadAliasModel (model_t *mod, void *buffer)
{
int i, j;
mdl_t *pinmodel, *pmodel;
stvert_t *pinstverts;
dtriangle_t *pintriangles;
int version, numframes;
int size;
daliasframetype_t *pframetype;
daliasskintype_t *pskintype;
int start, end, total;
start = Hunk_LowMark ();
pinmodel = (mdl_t *) buffer;
version = LittleLong (pinmodel->version);
if (version != ALIAS_VERSION)
Sys_Error ("%s has wrong version number (%i should be %i)",
mod->name, version, ALIAS_VERSION);
//
// allocate space for a working header, plus all the data except the frames,
// skin and group info
//
size = (int) &((aliashdr_t *) 0)->frames[LittleLong (pinmodel->numframes)];
pheader = Hunk_AllocName (size, loadname);
memset (pheader, 0, size);
pmodel = &pheader->mdl;
pheader->model = (byte *) pmodel - (byte *) pheader;
mod->flags = LittleLong (pinmodel->flags);
//
// endian-adjust and copy the data, starting with the alias model header
//
pmodel->boundingradius = LittleFloat (pinmodel->boundingradius);
pmodel->numskins = LittleLong (pinmodel->numskins);
pmodel->skinwidth = LittleLong (pinmodel->skinwidth);
pmodel->skinheight = LittleLong (pinmodel->skinheight);
if (pmodel->skinheight > MAX_LBM_HEIGHT)
Sys_Error ("model %s has a skin taller than %d", mod->name,
MAX_LBM_HEIGHT);
pmodel->numverts = LittleLong (pinmodel->numverts);
if (pmodel->numverts <= 0)
Sys_Error ("model %s has no vertices", mod->name);
if (pmodel->numverts > MAXALIASVERTS)
Sys_Error ("model %s has too many vertices", mod->name);
pmodel->numtris = LittleLong (pinmodel->numtris);
if (pmodel->numtris <= 0)
Sys_Error ("model %s has no triangles", mod->name);
pmodel->numframes = LittleLong (pinmodel->numframes);
numframes = pmodel->numframes;
if (numframes < 1)
Sys_Error ("Mod_LoadAliasModel: Invalid # of frames: %d\n", numframes);
pmodel->size = LittleFloat (pinmodel->size) * ALIAS_BASE_SIZE_RATIO;
mod->synctype = LittleLong (pinmodel->synctype);
mod->numframes = pmodel->numframes;
for (i = 0; i < 3; i++) {
pmodel->scale[i] = LittleFloat (pinmodel->scale[i]);
pmodel->scale_origin[i] = LittleFloat (pinmodel->scale_origin[i]);
pmodel->eyeposition[i] = LittleFloat (pinmodel->eyeposition[i]);
}
//
// load the skins
//
pskintype = (daliasskintype_t *) &pinmodel[1];
pskintype =
Mod_LoadAllSkins (pheader->mdl.numskins, pskintype, &pheader->skindesc);
//
// load base s and t vertices
//
pinstverts = (stvert_t *) pskintype;
for (i = 0; i < pheader->mdl.numverts; i++) {
stverts[i].onseam = LittleLong (pinstverts[i].onseam);
stverts[i].s = LittleLong (pinstverts[i].s);
stverts[i].t = LittleLong (pinstverts[i].t);
}
//
// load triangle lists
//
pintriangles = (dtriangle_t *) &pinstverts[pheader->mdl.numverts];
for (i = 0; i < pheader->mdl.numtris; i++) {
triangles[i].facesfront = LittleLong (pintriangles[i].facesfront);
for (j = 0; j < 3; j++) {
triangles[i].vertindex[j] =
LittleLong (pintriangles[i].vertindex[j]);
}
}
//
// load the frames
//
posenum = 0;
pframetype = (daliasframetype_t *) &pintriangles[pheader->mdl.numtris];
for (i = 0; i < numframes; i++) {
aliasframetype_t frametype;
frametype = LittleLong (pframetype->type);
pheader->frames[i].type = frametype;
if (frametype == ALIAS_SINGLE) {
pframetype = (daliasframetype_t *)
Mod_LoadAliasFrame (pframetype + 1, &pheader->frames[i]);
} else {
pframetype = (daliasframetype_t *)
Mod_LoadAliasGroup (pframetype + 1, &pheader->frames[i]);
}
}
pheader->numposes = posenum;
mod->type = mod_alias;
// FIXME: do this right
mod->mins[0] = mod->mins[1] = mod->mins[2] = -16;
mod->maxs[0] = mod->maxs[1] = mod->maxs[2] = 16;
//
// build the draw lists
//
GL_MakeAliasModelDisplayLists (mod, pheader, buffer, com_filesize);
//
// move the complete, relocatable alias model to the cache
//
end = Hunk_LowMark ();
total = end - start;
Cache_Alloc (&mod->cache, total, loadname);
if (!mod->cache.data)
return;
memcpy (mod->cache.data, pheader, total);
Hunk_FreeToLowMark (start);
}

1014
nq/source/model_brush.c
View file

File diff suppressed because it is too large Load diff

177
nq/source/model_sprite.c
View file

@ -1,177 +0,0 @@
/*
model_sprite.c
sprite 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 "r_local.h"
#include "QF/sys.h"
#include "QF/console.h"
#include "QF/qendian.h"
#include "QF/checksum.h"
extern char loadname[];
extern model_t *loadmodel;
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)
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);
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)
Sys_Error ("Mod_LoadSpriteModel: Invalid # of frames: %d\n", numframes);
mod->numframes = numframes;
mod->flags = 0;
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;
}

300
nq/source/sw_model_alias.c
View file

@ -1,300 +0,0 @@
/*
sw_model_alias.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 "r_local.h"
#include "QF/sys.h"
#include "QF/console.h"
#include "QF/qendian.h"
#include "QF/checksum.h"
extern char loadname[];
extern model_t *loadmodel;
/*
==============================================================================
ALIAS MODELS
==============================================================================
*/
extern aliashdr_t *pheader;
extern stvert_t stverts[MAXALIASVERTS];
extern mtriangle_t triangles[MAXALIASTRIS];
// a pose is a single set of vertexes. a frame may be
// an animating sequence of poses
extern trivertx_t *poseverts[MAXALIASFRAMES];
extern int posenum;
void *
Mod_LoadSkin (byte * skin, int skinsize, int *pskinindex, int snum, int gnum)
{
byte *pskin;
unsigned short *pusskin;
int i;
pskin = Hunk_AllocName (skinsize * r_pixbytes, loadname);
*pskinindex = (byte *) pskin - (byte *) pheader;
switch (r_pixbytes) {
case 1:
memcpy (pskin, skin, skinsize);
break;
case 2:
pusskin = (unsigned short *) skin;
for (i = 0; i < skinsize; i++)
pusskin[i] = d_8to16table[skin[i]];
break;
default:
Sys_Error ("Mod_LoadAliasSkin: driver set invalid r_pixbytes: %d\n",
r_pixbytes);
break;
}
return skin + skinsize;
}
/*
===============
Mod_LoadAllSkins
===============
*/
void *
Mod_LoadAllSkins (int numskins, daliasskintype_t *pskintype, int *pskinindex)
{
int snum, gnum, t;
int skinsize;
byte *skin;
int groupskins;
daliasskingroup_t *pinskingroup;
daliasskininterval_t *pinskinintervals;
maliasskindesc_t *pskindesc;
maliasskingroup_t *paliasskingroup;
float *poutskinintervals;
if (numskins < 1 || numskins > MAX_SKINS)
Sys_Error ("Mod_LoadAliasModel: Invalid # of skins: %d\n", numskins);
skinsize = pheader->mdl.skinwidth * pheader->mdl.skinheight;
pskindesc = Hunk_AllocName (numskins * sizeof (maliasskindesc_t), loadname);
pheader->skindesc = (byte *) pskindesc - (byte *) pheader;
for (snum = 0; snum < numskins; snum++) {
if (pskintype->type == ALIAS_SKIN_SINGLE) {
skin = (byte *) (pskintype + 1);
skin =
Mod_LoadSkin (skin, skinsize, &pskindesc[snum].skin, snum, 0);
} else {
pskintype++;
pinskingroup = (daliasskingroup_t *) pskintype;
groupskins = LittleLong (pinskingroup->numskins);
t = (int) &((maliasskingroup_t *) 0)->skindescs[groupskins];
paliasskingroup = Hunk_AllocName (t, loadname);
paliasskingroup->numskins = groupskins;
*pskinindex = (byte *) paliasskingroup - (byte *) pheader;
pinskinintervals = (daliasskininterval_t *) (pinskingroup + 1);
poutskinintervals =
Hunk_AllocName (groupskins * sizeof (float), loadname);
paliasskingroup->intervals =
(byte *) poutskinintervals - (byte *) pheader;
for (gnum = 0; gnum < groupskins; gnum++) {
*poutskinintervals = LittleFloat (pinskinintervals->interval);
if (*poutskinintervals <= 0)
Sys_Error ("Mod_LoadAliasSkinGroup: interval<=0");
poutskinintervals++;
pinskinintervals++;
}
pskintype = (void *) pinskinintervals;
skin = (byte *) pskintype;
for (gnum = 0; gnum < groupskins; gnum++) {
skin =
Mod_LoadSkin (skin, skinsize,
&paliasskingroup->skindescs[snum].skin, snum,
gnum);
}
}
pskintype = (daliasskintype_t *) skin;
}
return pskintype;
}
void
GL_MakeAliasModelDisplayLists (model_t *m, aliashdr_t *hdr, void *_m, int _s)
{
int i, j;
stvert_t *pstverts;
mtriangle_t *ptri;
int numv = hdr->mdl.numverts;
int numt = hdr->mdl.numtris;
pstverts = (stvert_t *) Hunk_AllocName (numv * sizeof (stvert_t), loadname);
ptri =
(mtriangle_t *) Hunk_AllocName (numt * sizeof (mtriangle_t), loadname);
hdr->stverts = (byte *) pstverts - (byte *) hdr;
hdr->triangles = (byte *) ptri - (byte *) hdr;
for (i = 0; i < numv; i++) {
pstverts[i].onseam = stverts[i].onseam;
pstverts[i].s = stverts[i].s << 16;
pstverts[i].t = stverts[i].t << 16;
}
for (i = 0; i < numt; i++) {
ptri[i].facesfront = triangles[i].facesfront;
for (j = 0; j < 3; j++) {
ptri[i].vertindex[j] = triangles[i].vertindex[j];
}
}
}
/*
=================
Mod_LoadAliasFrame
=================
*/
void *
Mod_LoadAliasFrame (void *pin, maliasframedesc_t *frame)
{
trivertx_t *pframe, *pinframe;
int i, j;
daliasframe_t *pdaliasframe;
pdaliasframe = (daliasframe_t *) pin;
strcpy (frame->name, pdaliasframe->name);
for (i = 0; i < 3; i++) {
// these are byte values, so we don't have to worry about
// endianness
frame->bboxmin.v[i] = pdaliasframe->bboxmin.v[i];
frame->bboxmax.v[i] = pdaliasframe->bboxmax.v[i];
}
pinframe = (trivertx_t *) (pdaliasframe + 1);
pframe =
Hunk_AllocName (pheader->mdl.numverts * sizeof (*pframe), loadname);
frame->frame = (byte *) pframe - (byte *) pheader;
for (j = 0; j < pheader->mdl.numverts; j++) {
int k;
// these are all byte values, so no need to deal with endianness
pframe[j].lightnormalindex = pinframe[j].lightnormalindex;
for (k = 0; k < 3; k++) {
pframe[j].v[k] = pinframe[j].v[k];
}
}
pinframe += pheader->mdl.numverts;
return (void *) pinframe;
}
/*
=================
Mod_LoadAliasGroup
=================
*/
void *
Mod_LoadAliasGroup (void *pin, maliasframedesc_t *frame)
{
daliasgroup_t *pingroup;
maliasgroup_t *paliasgroup;
int i, numframes;
daliasinterval_t *pin_intervals;
float *poutintervals;
void *ptemp;
pingroup = (daliasgroup_t *) pin;
numframes = LittleLong (pingroup->numframes);
paliasgroup = Hunk_AllocName (sizeof (maliasgroup_t) +
(numframes -
1) * 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
frame->bboxmin.v[i] = pingroup->bboxmin.v[i];
frame->bboxmax.v[i] = pingroup->bboxmax.v[i];
}
frame->frame = (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);
if (*poutintervals <= 0.0)
Sys_Error ("Mod_LoadAliasGroup: interval<=0");
poutintervals++;
pin_intervals++;
}
ptemp = (void *) pin_intervals;
for (i = 0; i < numframes; i++) {
maliasframedesc_t temp_frame;
ptemp = Mod_LoadAliasFrame (ptemp, &temp_frame);
memcpy (&paliasgroup->frames[i], &temp_frame,
sizeof (paliasgroup->frames[i]));
}
return ptemp;
}

70
nq/source/sw_model_brush.c
View file

@ -1,70 +0,0 @@
/*
sw_model_brush.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$
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "r_local.h"
#include "QF/sys.h"
#include "QF/console.h"
#include "QF/qendian.h"
#include "QF/checksum.h"
extern char loadname[];
extern model_t *loadmodel;
extern byte mod_novis[];
extern byte *mod_base;
const int mod_lightmap_bytes = 1;
void
GL_SubdivideSurface (msurface_t *fa)
{
}
void
Mod_ProcessTexture (miptex_t *mt, texture_t *tx)
{
}
/*
=================
Mod_LoadLighting
=================
*/
void
Mod_LoadLighting (lump_t *l)
{
if (!l->filelen) {
loadmodel->lightdata = NULL;
return;
}
loadmodel->lightdata = Hunk_AllocName (l->filelen, loadname);
memcpy (loadmodel->lightdata, mod_base + l->fileofs, l->filelen);
}

93
nq/source/sw_model_sprite.c
View file

@ -1,93 +0,0 @@
/*
sw_model_sprite.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$
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "r_local.h"
#include "QF/sys.h"
#include "QF/console.h"
#include "QF/qendian.h"
#include "QF/checksum.h"
extern char loadname[];
/*
=================
Mod_LoadSpriteFrame
=================
*/
void *
Mod_LoadSpriteFrame (void *pin, mspriteframe_t **ppframe, int framenum)
{
dspriteframe_t *pinframe;
mspriteframe_t *pspriteframe;
int i, width, height, size, origin[2];
unsigned short *ppixout;
byte *ppixin;
pinframe = (dspriteframe_t *) pin;
width = LittleLong (pinframe->width);
height = LittleLong (pinframe->height);
size = width * height;
pspriteframe = Hunk_AllocName (sizeof (mspriteframe_t) + size * r_pixbytes,
loadname);
memset (pspriteframe, 0, sizeof (mspriteframe_t) + size);
*ppframe = pspriteframe;
pspriteframe->width = width;
pspriteframe->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];
if (r_pixbytes == 1) {
memcpy (&pspriteframe->pixels[0], (byte *) (pinframe + 1), size);
} else if (r_pixbytes == 2) {
ppixin = (byte *) (pinframe + 1);
ppixout = (unsigned short *) &pspriteframe->pixels[0];
for (i = 0; i < size; i++)
ppixout[i] = d_8to16table[ppixin[i]];
} else {
Sys_Error ("Mod_LoadSpriteFrame: driver set invalid r_pixbytes: %d\n",
r_pixbytes);
}
return (void *) ((byte *) pinframe + sizeof (dspriteframe_t) + size);
}