/*
===============
R_InitParticles
===============
*/
void R_InitParticles(void)
{
int i = COM_CheckParm("-particles");
if (i)
{
r_numparticles = (int)(Q_atoi(com_argv[i + 1]));
if (r_numparticles < ABSOLUTE_MIN_PARTICLES)
r_numparticles = ABSOLUTE_MIN_PARTICLES;
}
else
r_numparticles = MAX_PARTICLES;
particles = (particle_t *)
Hunk_AllocName(r_numparticles * sizeof(particle_t), "particles");
}
/*
================
Host_FindMaxClients
================
*/
void Host_FindMaxClients (void)
{
int i;
svs.maxclients = 1;
#if !defined (GLQUAKE)
i = COM_CheckParm ("-dedicated");
if (i)
{
cls.state = ca_dedicated;
if (i != (com_argc - 1))
{
svs.maxclients = Q_atoi (com_argv[i+1]);
}
else
svs.maxclients = 8;
}
else
#endif /* GLQUAKE */
cls.state = ca_disconnected;
i = COM_CheckParm ("-listen");
if (i)
{
if (cls.state == ca_dedicated)
Sys_Error ("Only one of -dedicated or -listen can be specified");
if (i != (com_argc - 1))
svs.maxclients = Q_atoi (com_argv[i+1]);
else
svs.maxclients = 8;
}
if (svs.maxclients < 1)
svs.maxclients = 8;
else if (svs.maxclients > MAX_SCOREBOARD)
svs.maxclients = MAX_SCOREBOARD;
svs.maxclientslimit = svs.maxclients;
if (svs.maxclientslimit < 4)
svs.maxclientslimit = 4;
svs.clients = Hunk_AllocName (svs.maxclientslimit*sizeof(client_t), "clients");
if (svs.maxclients > 1)
Cvar_SetValue ("deathmatch", 1.0);
else
Cvar_SetValue ("deathmatch", 0.0);
}
/*
=================
Mod_LoadNodes
=================
*/
void Mod_LoadNodes (lump_t *l)
{
int i, j, count, p;
dnode_t *in;
mnode_t *out;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
out = Hunk_AllocName ( count*sizeof(*out), loadname);
loadmodel->nodes = out;
loadmodel->numnodes = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
// for (j=0 ; j<3 ; j++) // l
{
out->minmaxs[0] = LittleShort (in->mins[0]);
out->minmaxs[3+0] = LittleShort (in->maxs[0]);
out->minmaxs[1] = LittleShort (in->mins[1]);
out->minmaxs[3+1] = LittleShort (in->maxs[1]);
out->minmaxs[2] = LittleShort (in->mins[2]);
out->minmaxs[3+2] = LittleShort (in->maxs[2]);
}
p = LittleLong(in->planenum);
out->plane = loadmodel->planes + p;
out->firstsurface = LittleShort (in->firstface);
out->numsurfaces = LittleShort (in->numfaces);
for (j=0 ; j<2 ; j++)
{
p = LittleShort (in->children[j]);
if (p >= 0)
out->children[j] = loadmodel->nodes + p;
else
out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));
}
}
Mod_SetParent (loadmodel->nodes, NULL); // sets nodes and leafs
}
/*
=================
Mod_LoadSurfedges
=================
*/
static void Mod_LoadSurfedges (lump_t *l)
{
int i, count;
int *in, *out;
in = (int *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
SV_Error ("%s: funny lump size in %s", __thisfunc__, loadmodel->name);
count = l->filelen / sizeof(*in);
out = (int *) Hunk_AllocName (count * sizeof(*out), "surfedges");
loadmodel->surfedges = out;
loadmodel->numsurfedges = count;
for (i = 0; i < count; i++)
out[i] = LittleLong (in[i]);
}
/*
=================
Mod_LoadClipnodes
=================
*/
void Mod_LoadClipnodes (lump_t *l)
{
dclipnode_t *in, *out;
int i, count;
hull_t *hull;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
out = Hunk_AllocName ( count*sizeof(*out), loadname);
loadmodel->clipnodes = out;
loadmodel->numclipnodes = count;
hull = &loadmodel->hulls[1];
hull->clipnodes = out;
hull->firstclipnode = 0;
hull->lastclipnode = count-1;
hull->planes = loadmodel->planes;
hull->clip_mins[0] = -16;
hull->clip_mins[1] = -16;
hull->clip_mins[2] = -24;
hull->clip_maxs[0] = 16;
hull->clip_maxs[1] = 16;
hull->clip_maxs[2] = 32;
hull = &loadmodel->hulls[2];
hull->clipnodes = out;
hull->firstclipnode = 0;
hull->lastclipnode = count-1;
hull->planes = loadmodel->planes;
hull->clip_mins[0] = -32;
hull->clip_mins[1] = -32;
hull->clip_mins[2] = -24;
hull->clip_maxs[0] = 32;
hull->clip_maxs[1] = 32;
hull->clip_maxs[2] = 64;
for (i=0 ; i<count ; i++, out++, in++)
{
out->planenum = LittleLong(in->planenum);
out->children[0] = LittleShort(in->children[0]);
out->children[1] = LittleShort(in->children[1]);
}
}
/*
=================
Mod_LoadSurfedges
=================
*/
void Mod_LoadSurfedges (lump_t *l)
{
int i, count;
int *in, *out;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
out = Hunk_AllocName ( count*sizeof(*out), loadname);
loadmodel->surfedges = out;
loadmodel->numsurfedges = count;
for ( i=0 ; i<count ; i++)
out[i] = LittleLong (in[i]);
}
/*
================
Host_FindMaxClients
================
*/
void Host_FindMaxClients (void)
{
int i;
svs.maxclients = 1;
i = COM_CheckParm ("-dedicated");
if (i)
{
cls.state = ca_dedicated;
if (i != (com_argc - 1))
{
svs.maxclients = Q_atoi (com_argv[i+1]);
}
else
svs.maxclients = 8;
}
else
cls.state = ca_disconnected;
i = COM_CheckParm ("-listen");
if (i)
{
if (cls.state == ca_dedicated)
Sys_Error ("Only one of -dedicated or -listen can be specified");
if (i != (com_argc - 1))
svs.maxclients = Q_atoi (com_argv[i+1]);
else
svs.maxclients = 8;
}
if (svs.maxclients < 1)
svs.maxclients = 8;
else if (svs.maxclients > MAX_SCOREBOARD)
svs.maxclients = MAX_SCOREBOARD;
svs.maxclientslimit = svs.maxclients;
if (svs.maxclientslimit < 4)
svs.maxclientslimit = 4;
svs.clients = (struct client_s *) Hunk_AllocName (svs.maxclientslimit*sizeof(client_t), "clients");
if (svs.maxclients > 1)
Cvar_SetQuick (&deathmatch, "1");
else
Cvar_SetQuick (&deathmatch, "0");
}
/*
=================
Mod_LoadTexinfo
=================
*/
void Mod_LoadTexinfo (lump_t *l)
{
texinfo_t *in;
mtexinfo_t *out;
int i, j, count, miptex;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error ("Mod_LoadTexinfo: funny lump size in %s", loadmodel->name); // was Sys_Error
count = l->filelen / sizeof(*in);
out = Hunk_AllocName (count * sizeof(*out), mod_loadname);
loadmodel->texinfo = out;
loadmodel->numtexinfo = count;
for (i=0 ; i<count ; i++, in++, out++)
{
for (j=0 ; j<4 ; j++) {
out->vecs[0][j] = LittleFloat (in->vecs[0][j]);
out->vecs[1][j] = LittleFloat (in->vecs[1][j]);
}
miptex = LittleLong (in->miptex);
out->flags = LittleLong (in->flags);
if (!loadmodel->textures)
{
out->texture = r_notexture_mip; // checkerboard texture
out->flags = 0;
}
else
{
if (miptex >= loadmodel->numtextures)
Host_Error ("Mod_LoadTexinfo: miptex >= loadmodel->numtextures"); // was Sys_Error
out->texture = loadmodel->textures[miptex];
if (!out->texture)
{
out->texture = r_notexture_mip; // texture not found
out->flags = 0;
}
}
}
}
/*
====================
SV_Init
====================
*/
void SV_Init (void)
{
Sys_Printf ("Host_Init\n");
Memory_Init (host_parms->membase, host_parms->memsize);
Cbuf_Init ();
Cmd_Init ();
COM_Init ();
FS_Init ();
PR_Init ();
Mod_Init ();
SV_InitNet ();
SV_InitLocal ();
Pmove_Init ();
Hunk_AllocName (0, "-HOST_HUNKLEVEL-");
host_hunklevel = Hunk_LowMark ();
Cbuf_InsertText ("exec server.cfg\n");
Cbuf_Execute ();
// unlock the early-set cvars after init
Cvar_UnlockAll ();
host_initialized = true;
Con_Printf ("Exe: "__TIME__" "__DATE__"\n");
Con_Printf ("%4.1f megabyte heap\n", host_parms->memsize/(1024*1024.0));
Con_Printf ("======== HexenWorld Initialized ========\n");
// process command line arguments
Cmd_StuffCmds_f ();
Cbuf_Execute ();
// if a map wasn't specified on the command line, spawn demo1.map
if (sv.state == ss_dead)
Cmd_ExecuteString ("map demo1", src_command);
if (sv.state == ss_dead)
SV_Error ("Couldn't spawn a server");
}
/*
===============
R_InitParticles
===============
*/
void R_InitParticles (void)
{
int i;
FILE *f;
i = COM_CheckParm ("-particles");
MyTable[0] = 254;
if (i)
{
r_numparticles = (int)(atoi(com_argv[i+1]));
if (r_numparticles < ABSOLUTE_MIN_PARTICLES)
r_numparticles = ABSOLUTE_MIN_PARTICLES;
}
else
{
r_numparticles = MAX_PARTICLES;
}
particles = (particle_t *)
Hunk_AllocName (r_numparticles * sizeof(particle_t), "particles");
Cvar_RegisterVariable (&leak_color);
//JFM: snow test
Cvar_RegisterVariable (&snow_flurry);
Cvar_RegisterVariable (&snow_active);
transTable = (byte *)malloc(65536);
if (!transTable)
Sys_Error ("Couldn't load gfx/tinttab.lmp");
COM_FOpenFile ("gfx/tinttab.lmp", &f, false);
if (f)
{
fread(transTable,1,65536,f);
fclose(f);
}
}
/*
=================
Mod_LoadExternalVisibility
=================
*/
void Mod_LoadExternalVisibility (int fhandle)
{
long filelen;
// get visibility data length
filelen = 0;
Sys_FileRead (fhandle, &filelen, 4);
filelen = LittleLong(filelen);
Con_Printf("...%i bytes visibility data\n", filelen);
// load visibility data
if (!filelen)
{
loadmodel->visdata = NULL;
return;
}
loadmodel->visdata = Hunk_AllocName ( filelen, "EXT_VIS");
Sys_FileRead (fhandle, loadmodel->visdata, filelen);
}
/*
=================
Mod_LoadAliasFrame
=================
*/
void * Mod_LoadAliasFrame (void * pin, int *pframeindex, int numv,
trivertx_t *pbboxmin, trivertx_t *pbboxmax, aliashdr_t *pheader, char *name)
{
trivertx_t *pframe, *pinframe;
int i, j;
daliasframe_t *pdaliasframe;
pdaliasframe = (daliasframe_t *)pin;
strcpy (name, pdaliasframe->name);
for (i=0 ; i<3 ; i++)
{
// these are byte values, so we don't have to worry about
// endianness
pbboxmin->v[i] = pdaliasframe->bboxmin.v[i];
pbboxmax->v[i] = pdaliasframe->bboxmax.v[i];
}
pinframe = (trivertx_t *)(pdaliasframe + 1);
pframe = Hunk_AllocName (numv * sizeof(*pframe), loadname);
*pframeindex = (byte *)pframe - (byte *)pheader;
for (j=0 ; j<numv ; 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 += numv;
return (void *)pinframe;
}
/*
=================
Mod_LoadLeafs
=================
*/
void Mod_LoadLeafs (lump_t *l)
{
dleaf_t *in;
mleaf_t *out;
int i, j, count, p;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
out = Hunk_AllocName ( count*sizeof(*out), loadname);
loadmodel->leafs = out;
loadmodel->numleafs = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
for (j=0 ; j<3 ; j++)
{
out->minmaxs[j] = LittleShort (in->mins[j]);
out->minmaxs[3+j] = LittleShort (in->maxs[j]);
}
p = LittleLong(in->contents);
out->contents = p;
out->firstmarksurface = loadmodel->marksurfaces +
LittleShort(in->firstmarksurface);
out->nummarksurfaces = LittleShort(in->nummarksurfaces);
p = LittleLong(in->visofs);
if (p == -1)
out->compressed_vis = NULL;
else
out->compressed_vis = loadmodel->visdata + p;
out->efrags = NULL;
for (j=0 ; j<4 ; j++)
out->ambient_sound_level[j] = in->ambient_level[j];
}
}
/*
=================
Mod_LoadEdges
=================
*/
void Mod_LoadEdges (lump_t *l)
{
dedge_t *in;
medge_t *out;
int i, count;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
out = Hunk_AllocName ( (count + 1) * sizeof(*out), loadname);
loadmodel->edges = out;
loadmodel->numedges = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
out->v[0] = (unsigned short)LittleShort(in->v[0]);
out->v[1] = (unsigned short)LittleShort(in->v[1]);
}
}
/*
=================
Mod_LoadSurfedges
=================
*/
void Mod_LoadSurfedges (lump_t *l)
{
int i, count, *in, *out;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error ("Mod_LoadSurfedges: funny lump size in %s", loadmodel->name); // was Sys_Error
count = l->filelen / sizeof(*in);
out = Hunk_AllocName (count * sizeof(*out), mod_loadname);
loadmodel->surfedges = out;
loadmodel->numsurfedges = count;
for (i=0 ; i<count ; i++)
{
out[i] = LittleLong (in[i]);
// assert (((out[i] < MAX_MAP_EDGES) && (out[i] > -MAX_MAP_EDGES)));
}
}
/*
=================
Mod_LoadEdges
=================
*/
static void Mod_LoadEdges (lump_t *l)
{
dedge_t *in;
medge_t *out;
int i, count;
in = (dedge_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
SV_Error ("%s: funny lump size in %s", __thisfunc__, loadmodel->name);
count = l->filelen / sizeof(*in);
out = (medge_t *) Hunk_AllocName ((count + 1) * sizeof(*out), "edges");
loadmodel->edges = out;
loadmodel->numedges = count;
for (i = 0; i < count; i++, in++, out++)
{
out->v[0] = (unsigned short)LittleShort(in->v[0]);
out->v[1] = (unsigned short)LittleShort(in->v[1]);
}
}
/*
=================
Mod_LoadSpriteFrame
=================
*/
static void * Mod_LoadSpriteFrame(void *pin, mspriteframe_t **ppframe, const char *loadname,
int framenum)
{
int origin[2];
dspriteframe_t *pinframe = (dspriteframe_t *)pin;
#ifdef MSB_FIRST
int width = LittleLong(pinframe->width);
int height = LittleLong(pinframe->height);
#else
int width = (pinframe->width);
int height = (pinframe->height);
#endif
int numpixels = width * height;
int size = sizeof(mspriteframe_t) + R_SpriteDataSize(numpixels);
mspriteframe_t *pspriteframe = (mspriteframe_t*)Hunk_AllocName(size, loadname);
memset(pspriteframe, 0, size);
*ppframe = pspriteframe;
pspriteframe->width = width;
pspriteframe->height = height;
#ifdef MSB_FIRST
origin[0] = LittleLong(pinframe->origin[0]);
origin[1] = LittleLong(pinframe->origin[1]);
#else
origin[0] = (pinframe->origin[0]);
origin[1] = (pinframe->origin[1]);
#endif
pspriteframe->up = origin[1];
pspriteframe->down = origin[1] - height;
pspriteframe->left = origin[0];
pspriteframe->right = width + origin[0];
/* Let the renderer process the pixel data as needed */
R_SpriteDataStore(pspriteframe, loadname, framenum, (byte *)(pinframe + 1));
return (byte *)pinframe + sizeof(dspriteframe_t) + numpixels;
}
void Host_FindMaxClients(void) {
svs.maxclients = 1;
int i = COM_CheckParm("-dedicated");
if (i) {
cls.state = ca_dedicated;
if (i != (com_argc - 1)) {
svs.maxclients = atoi(com_argv[i + 1]);
} else
svs.maxclients = 8;
} else
cls.state = ca_disconnected;
//qmb :64 clients
//various number changes including max_scoreboard
i = COM_CheckParm("-listen");
if (i) {
if (cls.state == ca_dedicated)
Sys_Error("Only one of -dedicated or -listen can be specified");
if (i != (com_argc - 1))
svs.maxclients = atoi(com_argv[i + 1]);
else
svs.maxclients = 32;
}
if (svs.maxclients < 1)
svs.maxclients = 32;
else if (svs.maxclients > MAX_SCOREBOARD)
svs.maxclients = MAX_SCOREBOARD;
svs.maxclientslimit = svs.maxclients;
if (svs.maxclientslimit < 32)
svs.maxclientslimit = 32;
svs.clients = (client_t *) Hunk_AllocName(svs.maxclientslimit * sizeof (client_t), "clients");
if (svs.maxclients > 1)
deathmatch.set(1.0f);
else
deathmatch.set(0.0f);
}
/*
========================
Memory_Init
========================
*/
void Memory_Init (void *buf, int size)
{
int p;
int zonesize = DYNAMIC_SIZE;
hunk_base = (byte *)buf;
hunk_size = size;
hunk_low_used = 0;
hunk_high_used = 0;
Cache_Init ();
p = COM_CheckParm ("-zone");
if (p)
{
if (p < com_argc-1)
zonesize = Q_atoi (com_argv[p+1]) * 1024;
else
Sys_Error ("Memory_Init: you must specify a size in KB after -zone");
}
mainzone = (memzone_t *)Hunk_AllocName (zonesize, "zone" );
Z_ClearZone (mainzone, zonesize);
}
int PR_AllocString (int size, char **ptr)
{
int i;
if (!size)
return 0;
for (i = 0; i < pr_numknownstrings; i++)
{
if (!pr_knownstrings[i])
break;
}
// if (i >= pr_numknownstrings)
// {
if (i >= pr_maxknownstrings)
PR_AllocStringSlots();
pr_numknownstrings++;
// }
pr_knownstrings[i] = (char *)Hunk_AllocName(size, "string");
if (ptr)
*ptr = (char *) pr_knownstrings[i];
return -1 - i;
}
/*
=================
Mod_LoadVertexes
=================
*/
void Mod_LoadVertexes (lump_t *l)
{
dvertex_t *in;
mvertex_t *out;
int i, count;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
out = Hunk_AllocName ( count*sizeof(*out), loadname);
loadmodel->vertexes = out;
loadmodel->numvertexes = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
out->position[0] = LittleFloat (in->point[0]);
out->position[1] = LittleFloat (in->point[1]);
out->position[2] = LittleFloat (in->point[2]);
}
}
/*
=================
Mod_LoadVertexes
=================
*/
static void Mod_LoadVertexes (lump_t *l)
{
dvertex_t *in;
mvertex_t *out;
int i, count;
in = (dvertex_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
SV_Error ("%s: funny lump size in %s", __thisfunc__, loadmodel->name);
count = l->filelen / sizeof(*in);
out = (mvertex_t *) Hunk_AllocName (count * sizeof(*out), "vertexes");
loadmodel->vertexes = out;
loadmodel->numvertexes = count;
for (i = 0; i < count; i++, in++, out++)
{
out->position[0] = LittleFloat (in->point[0]);
out->position[1] = LittleFloat (in->point[1]);
out->position[2] = LittleFloat (in->point[2]);
}
}
/*
=================
Mod_LoadSubmodels
=================
*/
void Mod_LoadSubmodels (lump_t *l)
{
dmodel_t *in;
dmodel_t *out;
int i, j, count;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
out = Hunk_AllocName ( count*sizeof(*out), loadname);
loadmodel->submodels = out;
loadmodel->numsubmodels = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
// leilei - unrolled
{ // spread the mins / maxs by a pixel
out->mins[0] = LittleFloat (in->mins[0]) - 1;
out->maxs[0] = LittleFloat (in->maxs[0]) + 1;
out->origin[0] = LittleFloat (in->origin[0]);
out->mins[1] = LittleFloat (in->mins[1]) - 1;
out->maxs[1] = LittleFloat (in->maxs[1]) + 1;
out->origin[1] = LittleFloat (in->origin[1]);
out->mins[2] = LittleFloat (in->mins[2]) - 1;
out->maxs[2] = LittleFloat (in->maxs[2]) + 1;
out->origin[2] = LittleFloat (in->origin[2]);
}
for (j=0 ; j<MAX_MAP_HULLS ; j++)
out->headnode[j] = LittleLong (in->headnode[j]);
out->visleafs = LittleLong (in->visleafs);
out->firstface = LittleLong (in->firstface);
out->numfaces = LittleLong (in->numfaces);
}
}
/*
=================
Mod_LoadMarksurfaces
=================
*/
void Mod_LoadMarksurfaces (lump_t *l)
{
int i, j, count;
short *in;
msurface_t **out;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
out = Hunk_AllocName ( count*sizeof(*out), loadname);
loadmodel->marksurfaces = out;
loadmodel->nummarksurfaces = count;
for ( i=0 ; i<count ; i++)
{
j = LittleShort(in[i]);
if (j >= loadmodel->numsurfaces)
Sys_Error ("Mod_ParseMarksurfaces: bad surface number");
out[i] = loadmodel->surfaces + j;
}
}
/*
=================
Mod_LoadMarksurfaces
=================
*/
static void Mod_LoadMarksurfaces (lump_t *l)
{
int i, j, count;
short *in;
msurface_t **out;
in = (short *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
SV_Error ("%s: funny lump size in %s", __thisfunc__, loadmodel->name);
count = l->filelen / sizeof(*in);
out = (msurface_t **) Hunk_AllocName (count * sizeof(*out), "marksurfaces");
loadmodel->marksurfaces = out;
loadmodel->nummarksurfaces = count;
for (i = 0; i < count; i++)
{
j = LittleShort(in[i]);
if (j >= loadmodel->numsurfaces)
SV_Error ("%s: bad surface number", __thisfunc__);
out[i] = loadmodel->surfaces + j;
}
}
/*
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);
}
/*
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++) { // byte values, don't 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;
}
/*
===============
R_InitParticles
===============
*/
void R_InitParticles (void)
{
int i;
i = COM_CheckParm ("-particles");
if (i && i < com_argc-1)
{
r_numparticles = atoi(com_argv[i+1]);
if (r_numparticles < ABSOLUTE_MIN_PARTICLES)
r_numparticles = ABSOLUTE_MIN_PARTICLES;
}
else
{
r_numparticles = MAX_PARTICLES;
}
particles = (particle_t *) Hunk_AllocName (r_numparticles * sizeof(particle_t), "particles");
Cvar_RegisterVariable (&leak_color);
//JFM: snow test
Cvar_RegisterVariable (&snow_flurry);
Cvar_RegisterVariable (&snow_active);
}
/*
=================
Mod_LoadMarksurfaces
=================
*/
void Mod_LoadMarksurfaces (lump_t *l)
{
int i, j, count;
unsigned short *in; // JDH: was signed short
msurface_t **out;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error ("Mod_LoadMarksurfaces: funny lump size in %s", loadmodel->name); // was Sys_Error
count = l->filelen / sizeof(*in);
out = Hunk_AllocName (count * sizeof(*out), mod_loadname);
loadmodel->marksurfaces = out;
loadmodel->nummarksurfaces = count;
for (i=0 ; i<count ; i++)
{
j = (unsigned short) LittleShort(in[i]);
if (j >= loadmodel->numsurfaces)
Host_Error ("Mod_LoadMarksurfaces: bad surface number"); // was Sys_Error
out[i] = loadmodel->surfaces + j;
}
}
/*
=================
Mod_LoadExternalLeafs
=================
*/
void Mod_LoadExternalLeafs (int fhandle)
{
dleaf_t *in;
long filelen;
// get leaf data length
filelen = 0;
Sys_FileRead (fhandle, &filelen, 4);
filelen = LittleLong(filelen);
Con_Printf("...%i bytes leaf data\n", filelen);
// load leaf data
if (!filelen)
{
loadmodel->leafs = NULL;
loadmodel->numleafs = 0;
return;
}
in = Hunk_AllocName (filelen, "EXT_LEAF");
Sys_FileRead (fhandle, in, filelen);
Mod_ProcessLeafs (in, filelen);
}
