自学教程：C++ Hunk_AllocName函数代码示例

/*===============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);}