loadmap.c

著名物理引擎Hawk的源代码

/* loadmap.c, HAWK game engine
 *
 * Copyright 1997-1998 by Phil Frisbie, Jr.
 * for Hawk Software
 *
 */

#include "hardware.h"
#include "hawk.h"
#include "internal.h"
#include "endian.h"
#include "graphics.h"

byte		*pvs[MAX_MAP_LEAFS];
byte		*phs[MAX_MAP_LEAFS];
BSPFILE		BSP;

void decompressVis(byte *in, byte *decompressed)
{
	int		c;
	byte	*out;
	int		row;
	dvis_t	*dvis = (dvis_t *)BSP.dvisdata;

	row = (dvis->numclusters+7)>>3;	
	out = decompressed;

	do
	{
		if (*in)
		{
			*out++ = *in++;
			continue;
		}
	
		c = in[1];
		in += 2;
		while (c)
		{
			*out++ = 0;
			c--;
		}
	} while (out - decompressed < row);
}

void loadPrepareVis(void)
{
	int		i;
	dvis_t	*dvis = (dvis_t *)BSP.dvisdata;
	
	for(i=0;i<BSP.numleafs;i++)
	{
		dleaf_t leaf = BSP.dleafs[i];
		
		if (leaf.cluster == -1)
		{
			pvs[i] = NULL;
			phs[i] = NULL;
			continue;
		}
		pvs[i] = TagMalloc((BSP.numleafs +7) / 8, TAG_LEVEL);
		decompressVis(BSP.dvisdata + dvis->bitofs[leaf.cluster][DVIS_PVS], pvs[i]);
		phs[i] = TagMalloc((BSP.numleafs +7) / 8, TAG_LEVEL);
		decompressVis(BSP.dvisdata + dvis->bitofs[leaf.cluster][DVIS_PHS], phs[i]);
	}
}


void freeMap(void)
{
}

void swapBSPFile (void)
{
	int				i, j;
	dmodel_t		*d;
	dvis_t			*dvis = (dvis_t *)BSP.dvisdata;

	
/* models */
	for (i=0 ; i<BSP.nummodels ; i++)
	{
		d = &BSP.dmodels[i];

		d->firstface = littleLong (d->firstface);
		d->numfaces = littleLong (d->numfaces);
		d->headnode = littleLong (d->headnode);
		
		for (j=0 ; j<3 ; j++)
		{
			d->mins[j] = littleFloat(d->mins[j]);
			d->maxs[j] = littleFloat(d->maxs[j]);
			d->origin[j] = littleFloat(d->origin[j]);
		}
	}

/* vertexes */
	for (i=0 ; i<BSP.numvertexes ; i++)
	{
		for (j=0 ; j<3 ; j++)
			BSP.dvertexes[i].point[j] = littleFloat (BSP.dvertexes[i].point[j]);
	}
		
/* planes */
	for (i=0 ; i<BSP.numplanes ; i++)
	{
		for (j=0 ; j<3 ; j++)
			BSP.dplanes[i].normal[j] = littleFloat (BSP.dplanes[i].normal[j]);
		BSP.dplanes[i].dist = littleFloat (BSP.dplanes[i].dist);
		BSP.dplanes[i].type = littleLong (BSP.dplanes[i].type);
	}
	
/* texinfos */
	for (i=0 ; i<BSP.numtexinfo ; i++)
	{
		for (j=0 ; j<8 ; j++)
			BSP.texinfo[i].vecs[0][j] = littleFloat (BSP.texinfo[i].vecs[0][j]);
		BSP.texinfo[i].flags = littleLong (BSP.texinfo[i].flags);
		BSP.texinfo[i].value = littleLong (BSP.texinfo[i].value);
		BSP.texinfo[i].nexttexinfo = littleLong (BSP.texinfo[i].nexttexinfo);
	}
	
/* faces */
	for (i=0 ; i<BSP.numfaces ; i++)
	{
		BSP.dfaces[i].texinfo = littleShort (BSP.dfaces[i].texinfo);
		BSP.dfaces[i].planenum = littleShort (BSP.dfaces[i].planenum);
		BSP.dfaces[i].side = littleShort (BSP.dfaces[i].side);
		BSP.dfaces[i].lightofs = littleLong (BSP.dfaces[i].lightofs);
		BSP.dfaces[i].firstedge = littleLong (BSP.dfaces[i].firstedge);
		BSP.dfaces[i].numedges = littleShort (BSP.dfaces[i].numedges);
	}

/* nodes */
	for (i=0 ; i<BSP.numnodes ; i++)
	{
		BSP.dnodes[i].planenum = littleLong (BSP.dnodes[i].planenum);
		for (j=0 ; j<3 ; j++)
		{
			BSP.dnodes[i].mins[j] = littleShort (BSP.dnodes[i].mins[j]);
			BSP.dnodes[i].maxs[j] = littleShort (BSP.dnodes[i].maxs[j]);
		}
		BSP.dnodes[i].children[0] = littleLong (BSP.dnodes[i].children[0]);
		BSP.dnodes[i].children[1] = littleLong (BSP.dnodes[i].children[1]);
		BSP.dnodes[i].firstface = littleShort (BSP.dnodes[i].firstface);
		BSP.dnodes[i].numfaces = littleShort (BSP.dnodes[i].numfaces);
	}

/* leafs */
	for (i=0 ; i<BSP.numleafs ; i++)
	{
		BSP.dleafs[i].contents = littleLong (BSP.dleafs[i].contents);
		BSP.dleafs[i].cluster = littleShort (BSP.dleafs[i].cluster);
		BSP.dleafs[i].area = littleShort (BSP.dleafs[i].area);
		for (j=0 ; j<3 ; j++)
		{
			BSP.dleafs[i].mins[j] = littleShort (BSP.dleafs[i].mins[j]);
			BSP.dleafs[i].maxs[j] = littleShort (BSP.dleafs[i].maxs[j]);
		}

		BSP.dleafs[i].firstleafface = littleShort (BSP.dleafs[i].firstleafface);
		BSP.dleafs[i].numleaffaces = littleShort (BSP.dleafs[i].numleaffaces);
		BSP.dleafs[i].firstleafbrush = littleShort (BSP.dleafs[i].firstleafbrush);
		BSP.dleafs[i].numleafbrushes = littleShort (BSP.dleafs[i].numleafbrushes);
	}

/* leaffaces */
	for (i=0 ; i<BSP.numleaffaces ; i++)
		BSP.dleaffaces[i] = littleShort (BSP.dleaffaces[i]);

/* leafbrushes */
	for (i=0 ; i<BSP.numleafbrushes ; i++)
		BSP.dleafbrushes[i] = littleShort (BSP.dleafbrushes[i]);

/* surfedges */
	for (i=0 ; i<BSP.numsurfedges ; i++)
		BSP.dsurfedges[i] = littleLong (BSP.dsurfedges[i]);

/* edges */
	for (i=0 ; i<BSP.numedges ; i++)
	{
		BSP.dedges[i].v[0] = littleShort (BSP.dedges[i].v[0]);
		BSP.dedges[i].v[1] = littleShort (BSP.dedges[i].v[1]);
	}

/* brushes */
	for (i=0 ; i<BSP.numbrushes ; i++)
	{
		BSP.dbrushes[i].firstside = littleLong (BSP.dbrushes[i].firstside);
		BSP.dbrushes[i].numsides = littleLong (BSP.dbrushes[i].numsides);
		BSP.dbrushes[i].contents = littleLong (BSP.dbrushes[i].contents);
	}

/* areas */
	for (i=0 ; i<BSP.numareas ; i++)
	{
		BSP.dareas[i].numareaportals = littleLong (BSP.dareas[i].numareaportals);
		BSP.dareas[i].firstareaportal = littleLong (BSP.dareas[i].firstareaportal);
	}

/* areasportals */
	for (i=0 ; i<BSP.numareaportals ; i++)
	{
		BSP.dareaportals[i].portalnum = littleLong (BSP.dareaportals[i].portalnum);
		BSP.dareaportals[i].otherarea = littleLong (BSP.dareaportals[i].otherarea);
	}

/* brushsides */
	for (i=0 ; i<BSP.numbrushsides ; i++)
	{
		BSP.dbrushsides[i].planenum = littleShort (BSP.dbrushsides[i].planenum);
		BSP.dbrushsides[i].texinfo = littleShort (BSP.dbrushsides[i].texinfo);
	}

/* visibility */
	j = littleLong(dvis->numclusters);
	dvis->numclusters = littleLong (dvis->numclusters);
	for (i=0 ; i<j ; i++)
	{
		dvis->bitofs[i][0] = littleLong (dvis->bitofs[i][0]);
		dvis->bitofs[i][1] = littleLong (dvis->bitofs[i][1]);
	}
}


dheader_t	*header;

int lumpLength(int lump)
{
	return  header->lumps[lump].filelen;
}

int copyLump (int lump, void *dest, int size)
{
	int		length, ofs;

	length = header->lumps[lump].filelen;
	ofs = header->lumps[lump].fileofs;

	memcpy (dest, (byte *)header + ofs, length);

	return length / size;
}

/*
=============
LoadBSPFile
=============
*/
BOOL loadBSPFile (char *filename)
{
	int			i, size;

/* load the file header */
	size = fileSize(filename);
	if(size <= 0)
		return FALSE;
	header = (dheader_t *)TempMalloc(size);
	loadFile(filename, 0, size, header);

/* swap the header */
	for (i=0 ; i< sizeof(dheader_t)/4 ; i++)
		((int *)header)[i] = littleLong ( ((int *)header)[i]);

	if (header->ident != IDBSPHEADER)
		return FALSE;
	if (header->version != BSPVERSION)
		return FALSE;
	BSP.dmodels = TagMalloc(lumpLength(LUMP_MODELS), TAG_LEVEL);
	BSP.nummodels = copyLump (LUMP_MODELS, BSP.dmodels, sizeof(dmodel_t));

	BSP.dvertexes = TagMalloc(lumpLength(LUMP_VERTEXES), TAG_LEVEL);
	BSP.numvertexes = copyLump (LUMP_VERTEXES, BSP.dvertexes, sizeof(dvertex_t));

	BSP.dplanes = TagMalloc(lumpLength(LUMP_PLANES), TAG_LEVEL);
	BSP.numplanes = copyLump (LUMP_PLANES, BSP.dplanes, sizeof(dplane_t));

	BSP.dleafs = TagMalloc(lumpLength(LUMP_LEAFS), TAG_LEVEL);
	BSP.numleafs = copyLump (LUMP_LEAFS, BSP.dleafs, sizeof(dleaf_t));

	BSP.dnodes = TagMalloc(lumpLength(LUMP_NODES), TAG_LEVEL);
	BSP.numnodes = copyLump (LUMP_NODES, BSP.dnodes, sizeof(dnode_t));

	BSP.texinfo = TagMalloc(lumpLength(LUMP_TEXINFO), TAG_LEVEL);
	BSP.numtexinfo = copyLump (LUMP_TEXINFO, BSP.texinfo, sizeof(texinfo_t));

	BSP.dfaces = TagMalloc(lumpLength(LUMP_FACES), TAG_LEVEL);
	BSP.numfaces = copyLump (LUMP_FACES, BSP.dfaces, sizeof(dface_t));

	BSP.dleaffaces = TagMalloc(lumpLength(LUMP_LEAFFACES), TAG_LEVEL);
	BSP.numleaffaces = copyLump (LUMP_LEAFFACES, BSP.dleaffaces, sizeof(BSP.dleaffaces[0]));

	BSP.dleafbrushes = TagMalloc(lumpLength(LUMP_LEAFBRUSHES), TAG_LEVEL);
	BSP.numleafbrushes = copyLump (LUMP_LEAFBRUSHES, BSP.dleafbrushes, sizeof(BSP.dleafbrushes[0]));
	
	BSP.dsurfedges = TagMalloc(lumpLength(LUMP_SURFEDGES), TAG_LEVEL);
	BSP.numsurfedges = copyLump (LUMP_SURFEDGES, BSP.dsurfedges, sizeof(BSP.dsurfedges[0]));
	
	BSP.dedges = TagMalloc(lumpLength(LUMP_EDGES), TAG_LEVEL);
	BSP.numedges = copyLump (LUMP_EDGES, BSP.dedges, sizeof(dedge_t));
	
	BSP.dbrushes = TagMalloc(lumpLength(LUMP_BRUSHES), TAG_LEVEL);
	BSP.numbrushes = copyLump (LUMP_BRUSHES, BSP.dbrushes, sizeof(dbrush_t));
	
	BSP.dbrushsides = TagMalloc(lumpLength(LUMP_BRUSHSIDES), TAG_LEVEL);
	BSP.numbrushsides = copyLump (LUMP_BRUSHSIDES, BSP.dbrushsides, sizeof(dbrushside_t));