halflife25-sdk/utils/qrad/vismat.c

/***
*
*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
*	
*	This product contains software technology licensed from Id 
*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
*	All Rights Reserved.
*
****/

#include "qrad.h"

#define	HALFBIT

extern char		source[MAX_PATH];
extern char		vismatfile[_MAX_PATH];
extern char		incrementfile[_MAX_PATH];
extern qboolean	incremental;

/*
===================================================================

VISIBILITY MATRIX

Determine which patches can see each other
Use the PVS to accelerate if available
===================================================================
*/
byte	*vismatrix;

dleaf_t		*PointInLeaf (vec3_t point)
{
	int		nodenum;
	vec_t	dist;
	dnode_t	*node;
	dplane_t	*plane;

	nodenum = 0;
	while (nodenum >= 0)
	{
		node = &dnodes[nodenum];
		plane = &dplanes[node->planenum];
		dist = DotProduct (point, plane->normal) - plane->dist;
		if (dist > 0)
			nodenum = node->children[0];
		else
			nodenum = node->children[1];
	}

	return &dleafs[-nodenum - 1];
}


void PvsForOrigin (vec3_t org, byte *pvs)
{
	dleaf_t	*leaf;

	if (!visdatasize)
	{
		memset (pvs, 255, (numleafs+7)/8 );
		return;
	}

	leaf = PointInLeaf (org);
	if (leaf->visofs == -1)
		Error ("leaf->visofs == -1");

	DecompressVis (&dvisdata[leaf->visofs], pvs);
}


/*
==============
PatchPlaneDist

Fixes up patch planes for brush models with an origin brush
==============
*/
vec_t PatchPlaneDist( patch_t *patch )
{
	return patch->plane->dist + DotProduct( face_offset[ patch->faceNumber ], patch->normal );
}



/*
==============
TestPatchToFace

Sets vis bits for all patches in the face
==============
*/
void TestPatchToFace (unsigned patchnum, int facenum, int head, unsigned bitpos)
{
	patch_t		*patch = &patches[patchnum];
	patch_t		*patch2 = face_patches[facenum];

	// if emitter is behind that face plane, skip all patches

	if ( patch2 && DotProduct(patch->origin, patch2->normal) > PatchPlaneDist(patch2)+1.01 )
	{
		// we need to do a real test
		for ( ; patch2 ; patch2 = patch2->next)
		{
			unsigned m = patch2 - patches;

			// check vis between patch and patch2
			// if bit has not already been set
			//  && v2 is not behind light plane
			//  && v2 is visible from v1
			if ( m > patchnum
			  && DotProduct (patch2->origin, patch->normal) > PatchPlaneDist(patch)+1.01
		      && TestLine_r (head, patch->origin, patch2->origin) == CONTENTS_EMPTY )
			{
				// patchnum can see patch m
				int bitset = bitpos+m;
				vismatrix[ bitset>>3 ] |= 1 << (bitset&7);
			}
		}
	}
}

/*
==============
BuildVisRow

Calc vis bits from a single patch
==============
*/
void BuildVisRow (int patchnum, byte *pvs, int head, unsigned bitpos)
{
	int		j, k, l;
	patch_t	*patch;
	byte	face_tested[MAX_MAP_FACES];
	dleaf_t	*leaf;

	patch = &patches[patchnum];

	memset (face_tested, 0, numfaces);

	// leaf 0 is the solid leaf (skipped)
	for (j=1, leaf=dleafs+1 ; j<numleafs ; j++, leaf++)
	{
		if ( ! ( pvs[(j-1)>>3] & (1<<((j-1)&7)) ) )
			continue;		// not in pvs
		for (k=0 ; k<leaf->nummarksurfaces ; k++)
		{
			l = dmarksurfaces[leaf->firstmarksurface + k];

			// faces can be marksurfed by multiple leaves, but
			// don't bother testing again
			if (face_tested[l])
				continue;
			face_tested[l] = 1;

			TestPatchToFace (patchnum, l, head, bitpos);
		}
	}
}

/*
===========
BuildVisLeafs

  This is run by multiple threads
===========
*/
void BuildVisLeafs (int threadnum)
{
	int		i;
	int		lface, facenum, facenum2;
	byte	pvs[(MAX_MAP_LEAFS+7)/8];
	dleaf_t	*srcleaf, *leaf;
	patch_t	*patch;
	int		head;
	unsigned	bitpos;
	unsigned	patchnum;

	while (1)
	{
		//
		// build a minimal BSP tree that only
		// covers areas relevent to the PVS
		//
		i = GetThreadWork ();
		if (i == -1)
			break;
		i++;		// skip leaf 0
		srcleaf = &dleafs[i];
		DecompressVis (&dvisdata[srcleaf->visofs], pvs);
#if 0
	// is this valid multithreaded???
		memset (nodehit, 0, numnodes);
		for (j=1, leaf=dleafs+1 ; j<numleafs ; j++, leaf++)
		{
			if ( !( pvs[(j-1)>>3] & (1<<((j-1)&7)) ) )
				continue;
			n = leafparents[j];
			while (n != -1)
			{
				nodehit[n] = 1;
				n = nodeparents[n];
			}
		}

		head = PartialHead ();
#else
		head = 0;
#endif

		//
		// go through all the faces inside the
		// leaf, and process the patches that
		// actually have origins inside
		//
		for (lface = 0 ; lface < srcleaf->nummarksurfaces ; lface++)
		{
			facenum = dmarksurfaces[srcleaf->firstmarksurface + lface];
			for (patch = face_patches[facenum] ; patch ; patch=patch->next)
			{
				leaf = PointInLeaf (patch->origin);
				if (leaf != srcleaf)
					continue;

				patchnum = patch - patches;

			#ifdef HALFBIT
				bitpos = patchnum * num_patches - (patchnum*(patchnum+1))/2;
			#else
				bitpos = patchnum * num_patches;
			#endif
				// build to all other world leafs
				BuildVisRow (patchnum, pvs, head, bitpos);

				// build to bmodel faces
				if (nummodels < 2)
					continue;
				for (facenum2 = dmodels[1].firstface ; facenum2 < numfaces ; facenum2++)
					TestPatchToFace (patchnum, facenum2, head, bitpos);
			}
		}

	}
}

/*
==============
getfiletime
==============
*/

time_t
getfiletime(char *filename)
{
	time_t			filetime = 0;
	struct _stat	filestat;

	if ( _stat(filename, &filestat) == 0 )
		filetime = max( filestat.st_mtime, filestat.st_ctime );

	return filetime;
}

/*
==============
getfilesize
==============
*/

long
getfilesize(char *filename)
{
	long			size = 0;
	struct _stat	filestat;

	if ( _stat(filename, &filestat) == 0 )
		size = filestat.st_size;

	return size;
}

/*
==============
getfiledata
==============
*/

long
getfiledata(char *filename, char *buffer, int buffersize)
{
	long			size = 0;
	int				handle;
	long			start,end;
	time(&start);

	if ( (handle = _open( filename, _O_RDONLY | _O_BINARY )) != -1 )
	{
		int			bytesread;
		printf("%-20s Restoring [%-13s - ", "BuildVisMatrix:", filename );
		while( ( bytesread = _read( handle, buffer, min( 32*1024, buffersize - size ) ) ) > 0 )
		{
			size += bytesread;
			buffer += bytesread;
		}
		_close( handle );
		time(&end);
		printf("%10.3fMB] (%d)\n",size/(1024.0*1024.0), end-start);
	}

	if (buffersize != size)
	{
		printf( "Invalid file [%s] found.  File will be rebuilt!\n", filename );
		unlink(filename);
	}

	return size;
}

/*
==============
getfreespace
==============
*/

_int64
getfreespace(char *filename)
{
	_int64				freespace = 0;
	int					drive = 0;
	struct _diskfree_t	df;

	if ( filename[0] && filename[1] == ':' )
		drive = toupper(filename[0]) - 'A' + 1;
	else
		drive = _getdrive();

	if ( _getdiskfree(drive, &df) == 0 )
	{
		freespace = df.avail_clusters;
		freespace *= df.sectors_per_cluster;
		freespace *= df.bytes_per_sector;
	}

	return freespace;
}


/*
==============
putfiledata
==============
*/

long
putfiledata(char *filename, char *buffer, int buffersize)
{
	long			size = 0;
	int				handle;

	if ( getfreespace(filename) >= (_int64)(buffersize - getfilesize(filename)) )
	{
		if ( (handle = _open( filename, _O_WRONLY | _O_BINARY | _O_CREAT | _O_TRUNC, _S_IREAD | _S_IWRITE )) != -1 )
		{
			int			byteswritten;
			qprintf("Writing [%s] with new saved qrad data", filename );
			while( ( byteswritten = _write( handle, buffer, min( 32*1024, buffersize - size ) ) ) > 0 )
			{
				size += byteswritten;
				buffer += byteswritten;
				if ( size >= buffersize )
					break;
			}
			qprintf("(%d)\n", size );
			
			_close( handle );
		}
	}
	else
		printf("Insufficient disk space(%ld) for 'incremental QRAD save file'!\n",
				buffersize - getfilesize(filename) );

	return size;
}

/*
==============
IsIncremental
==============
*/

qboolean
IsIncremental(char *filename)
{
	qboolean		status = false;
	int				sum;
	int				handle;

	if ( (handle = _open( filename, _O_RDONLY | _O_BINARY )) != -1 )
	{
		if ( _read( handle, &sum, sizeof(sum) ) == sizeof(sum) && sum == dmodels_checksum
		  && _read( handle, &sum, sizeof(sum) ) == sizeof(sum) && sum == dvertexes_checksum
		  && _read( handle, &sum, sizeof(sum) ) == sizeof(sum) && sum == dplanes_checksum
		  && _read( handle, &sum, sizeof(sum) ) == sizeof(sum) && sum == dleafs_checksum
		  && _read( handle, &sum, sizeof(sum) ) == sizeof(sum) && sum == dnodes_checksum
		  && _read( handle, &sum, sizeof(sum) ) == sizeof(sum) && sum == texinfo_checksum
		  && _read( handle, &sum, sizeof(sum) ) == sizeof(sum) && sum == dclipnodes_checksum
		  && _read( handle, &sum, sizeof(sum) ) == sizeof(sum) && sum == dfaces_checksum
		  && _read( handle, &sum, sizeof(sum) ) == sizeof(sum) && sum == dmarksurfaces_checksum
		  && _read( handle, &sum, sizeof(sum) ) == sizeof(sum) && sum == dsurfedges_checksum
		  && _read( handle, &sum, sizeof(sum) ) == sizeof(sum) && sum == dedges_checksum
		  && _read( handle, &sum, sizeof(sum) ) == sizeof(sum) && sum == dtexdata_checksum
		  && _read( handle, &sum, sizeof(sum) ) == sizeof(sum) && sum == dvisdata_checksum )
			status = true;
		_close( handle );
	}

	return status;
}

/*
==============
SaveIncremental
==============
*/

int
SaveIncremental(char *filename)
{
	long			size = 0;
	int				handle;
	int				expected_size = 13*sizeof(int);

	if ( getfreespace(filename) >= expected_size )
	{
		if ( (handle = _open( filename, _O_WRONLY | _O_BINARY | _O_CREAT | _O_TRUNC, _S_IREAD | _S_IWRITE )) != -1 )
		{
			qprintf("Writing [%s] with new saved qrad data", filename );
			
			if ( _write( handle, &dmodels_checksum, sizeof(int) ) == sizeof(int) && (size += sizeof(int))
			  && _write( handle, &dvertexes_checksum, sizeof(int) ) == sizeof(int) && (size += sizeof(int))
			  && _write( handle, &dplanes_checksum, sizeof(int) ) == sizeof(int) && (size += sizeof(int))
			  && _write( handle, &dleafs_checksum, sizeof(int) ) == sizeof(int) && (size += sizeof(int))
			  && _write( handle, &dnodes_checksum, sizeof(int) ) == sizeof(int) && (size += sizeof(int))
			  && _write( handle, &texinfo_checksum, sizeof(int) ) == sizeof(int) && (size += sizeof(int))
			  && _write( handle, &dclipnodes_checksum, sizeof(int) ) == sizeof(int) && (size += sizeof(int))
			  && _write( handle, &dfaces_checksum, sizeof(int) ) == sizeof(int) && (size += sizeof(int))
			  && _write( handle, &dmarksurfaces_checksum, sizeof(int) ) == sizeof(int) && (size += sizeof(int))
			  && _write( handle, &dsurfedges_checksum, sizeof(int) ) == sizeof(int) && (size += sizeof(int))
			  && _write( handle, &dedges_checksum, sizeof(int) ) == sizeof(int) && (size += sizeof(int))
			  && _write( handle, &dtexdata_checksum, sizeof(int) ) == sizeof(int) && (size += sizeof(int))
			  && _write( handle, &dvisdata_checksum, sizeof(int) ) == sizeof(int) && (size += sizeof(int)) )
			{
				qprintf("(%d)\n", size );
			}
			else
			{
				qprintf("...failed!");
			}
			_close( handle );
		}
	}
	else
		printf("Insufficient disk space(%ld) for incremental file[%s]'!\n",
				expected_size, filename );

	return size;
}

/*
==============
BuildVisMatrix
==============
*/
void BuildVisMatrix (void)
{
	int		c;
    HANDLE h;

#ifdef HALFBIT
	c = ((num_patches+1)*(((num_patches+1)+15)/16));
#else
	c = num_patches*((num_patches+7)/8);
#endif

	qprintf ("visibility matrix: %5.1f megs\n", c/(1024*1024.0));

    if ( h = GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT, c ) )
		vismatrix = GlobalLock( h );
	else
		Error ("vismatrix too big");
	
	strcpy(vismatfile, source);
	StripExtension (vismatfile);
	DefaultExtension(vismatfile, ".r1");

	if ( !incremental
	  || !IsIncremental(incrementfile)
	  || getfilesize(vismatfile) != c
	  || getfiledata(vismatfile,vismatrix, c) != c )
	{
		// memset (vismatrix, 0, c);
		RunThreadsOn (numleafs-1, true, BuildVisLeafs);
	}
	// Get rid of any old _bogus_ r1 files; we never read them!
	unlink(vismatfile);
}

void FreeVisMatrix (void)
{
	if ( vismatrix )
	{
		HANDLE h = GlobalHandle(vismatrix);
		GlobalUnlock(h);
		GlobalFree(h);
		vismatrix = NULL;
	}
}

/*
==============
touchfile
=============
*/

void
TouchFile(char *filename)
{
	int handle;
	if ( (handle = _open( filename, _O_RDWR | _O_BINARY  )) != -1 )
	{
		char	bytebuffer;
		qprintf("Updating saved qrad data <%s> with current time.\n", filename);
		_read( handle, &bytebuffer, sizeof(bytebuffer));
		_lseek(handle,0,SEEK_SET);
		_write( handle, &bytebuffer, sizeof(bytebuffer));
		_close( handle );
	}
}


/*
==============
CheckVisBit
==============
*/
qboolean CheckVisBit (int p1, int p2)
{
	int		t;
	int		bitpos;

	if (p1 > p2)
	{
		t = p1;
		p1 = p2;
		p2 = t;
	}

#ifdef HALFBIT
	bitpos = p1 * num_patches - (p1*(p1+1))/2 + p2;
#else
	bitpos = p1 * num_patches + p2;
#endif

	if (vismatrix[bitpos>>3] & (1<<(bitpos&7)))
		return true;
	return false;
}