gtkradiant/tools/quake3/q3map2/vis.c

/* -------------------------------------------------------------------------------

   Copyright (C) 1999-2007 id Software, Inc. and contributors.
   For a list of contributors, see the accompanying CONTRIBUTORS file.

   This file is part of GtkRadiant.

   GtkRadiant 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.

   GtkRadiant 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 GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

   ----------------------------------------------------------------------------------

   This code has been altered significantly from its original form, to support
   several games based on the Quake III Arena engine, in the form of "Q3Map2."

   ------------------------------------------------------------------------------- */



/* marker */
#define VIS_C



/* dependencies */
#include "q3map2.h"




void PlaneFromWinding( fixedWinding_t *w, visPlane_t *plane ){
	vec3_t v1, v2;

// calc plane
	VectorSubtract( w->points[2], w->points[1], v1 );
	VectorSubtract( w->points[0], w->points[1], v2 );
	CrossProduct( v2, v1, plane->normal );
	VectorNormalize( plane->normal, plane->normal );
	plane->dist = DotProduct( w->points[0], plane->normal );
}


/*
   NewFixedWinding()
   returns a new fixed winding
   ydnar: altered this a bit to reconcile multiply-defined winding_t
 */

fixedWinding_t *NewFixedWinding( int points ){
	fixedWinding_t  *w;
	int size;

	if ( points > MAX_POINTS_ON_WINDING ) {
		Error( "NewWinding: %i points", points );
	}

	size = (int)( (size_t)( (fixedWinding_t *)0 )->points[points] );
	w = safe_malloc( size );
	memset( w, 0, size );

	return w;
}



void prl( leaf_t *l ){
	int i;
	vportal_t   *p;
	visPlane_t pl;

	for ( i = 0 ; i < l->numportals ; i++ )
	{
		p = l->portals[i];
		pl = p->plane;
		Sys_Printf( "portal %4i to leaf %4i : %7.1f : (%4.1f, %4.1f, %4.1f)\n",(int)( p - portals ),p->leaf,pl.dist, pl.normal[0], pl.normal[1], pl.normal[2] );
	}
}


//=============================================================================

/*
   =============
   SortPortals

   Sorts the portals from the least complex, so the later ones can reuse
   the earlier information.
   =============
 */
int PComp( const void *a, const void *b ){
	if ( ( *(vportal_t **)a )->nummightsee == ( *(vportal_t **)b )->nummightsee ) {
		return 0;
	}
	if ( ( *(vportal_t **)a )->nummightsee < ( *(vportal_t **)b )->nummightsee ) {
		return -1;
	}
	return 1;
}
void SortPortals( void ){
	int i;

	for ( i = 0 ; i < numportals * 2 ; i++ )
		sorted_portals[i] = &portals[i];

	if ( nosort ) {
		return;
	}
	qsort( sorted_portals, numportals * 2, sizeof( sorted_portals[0] ), PComp );
}


/*
   ==============
   LeafVectorFromPortalVector
   ==============
 */
int LeafVectorFromPortalVector( byte *portalbits, byte *leafbits ){
	int i, j, leafnum;
	vportal_t   *p;
	int c_leafs;


	for ( i = 0 ; i < numportals * 2 ; i++ )
	{
		if ( portalbits[i >> 3] & ( 1 << ( i & 7 ) ) ) {
			p = portals + i;
			leafbits[p->leaf >> 3] |= ( 1 << ( p->leaf & 7 ) );
		}
	}

	for ( j = 0; j < portalclusters; j++ )
	{
		leafnum = j;
		while ( leafs[leafnum].merged >= 0 )
			leafnum = leafs[leafnum].merged;
		//if the merged leaf is visible then the original leaf is visible
		if ( leafbits[leafnum >> 3] & ( 1 << ( leafnum & 7 ) ) ) {
			leafbits[j >> 3] |= ( 1 << ( j & 7 ) );
		}
	}

	c_leafs = CountBits( leafbits, portalclusters );

	return c_leafs;
}


/*
   ===============
   ClusterMerge

   Merges the portal visibility for a leaf
   ===============
 */
void ClusterMerge( int leafnum ){
	leaf_t      *leaf;
	byte portalvector[MAX_PORTALS / 8];
	byte uncompressed[MAX_MAP_LEAFS / 8];
	int i, j;
	int numvis, mergedleafnum;
	vportal_t   *p;
	int pnum;

	// OR together all the portalvis bits

	mergedleafnum = leafnum;
	while ( leafs[mergedleafnum].merged >= 0 )
		mergedleafnum = leafs[mergedleafnum].merged;

	memset( portalvector, 0, portalbytes );
	leaf = &leafs[mergedleafnum];
	for ( i = 0; i < leaf->numportals; i++ )
	{
		p = leaf->portals[i];
		if ( p->removed ) {
			continue;
		}

		if ( p->status != stat_done ) {
			Error( "portal not done" );
		}
		for ( j = 0 ; j < portallongs ; j++ )
			( (long *)portalvector )[j] |= ( (long *)p->portalvis )[j];
		pnum = p - portals;
		portalvector[pnum >> 3] |= 1 << ( pnum & 7 );
	}

	memset( uncompressed, 0, leafbytes );

	uncompressed[mergedleafnum >> 3] |= ( 1 << ( mergedleafnum & 7 ) );
	// convert portal bits to leaf bits
	numvis = LeafVectorFromPortalVector( portalvector, uncompressed );

//	if (uncompressed[leafnum>>3] & (1<<(leafnum&7)))
//		Sys_Printf ("WARNING: Leaf portals saw into leaf\n");

//	uncompressed[leafnum>>3] |= (1<<(leafnum&7));

	numvis++;       // count the leaf itself

	totalvis += numvis;

	Sys_FPrintf( SYS_VRB,"cluster %4i : %4i visible\n", leafnum, numvis );

	memcpy( bspVisBytes + VIS_HEADER_SIZE + leafnum * leafbytes, uncompressed, leafbytes );
}

/*
   ==================
   CalcPortalVis
   ==================
 */
void CalcPortalVis( void ){
#ifdef MREDEBUG
	Sys_Printf( "%6d portals out of %d", 0, numportals * 2 );
	//get rid of the counter
	RunThreadsOnIndividual( numportals * 2, qfalse, PortalFlow );
#else
	RunThreadsOnIndividual( numportals * 2, qtrue, PortalFlow );
#endif

}

/*
   ==================
   CalcPassageVis
   ==================
 */
void CalcPassageVis( void ){
	PassageMemory();

#ifdef MREDEBUG
	_printf( "%6d portals out of %d", 0, numportals * 2 );
	RunThreadsOnIndividual( numportals * 2, qfalse, CreatePassages );
	_printf( "\n" );
	_printf( "%6d portals out of %d", 0, numportals * 2 );
	RunThreadsOnIndividual( numportals * 2, qfalse, PassageFlow );
	_printf( "\n" );
#else
	Sys_Printf( "\n--- CreatePassages (%d) ---\n", numportals * 2 );
	RunThreadsOnIndividual( numportals * 2, qtrue, CreatePassages );

	Sys_Printf( "\n--- PassageFlow (%d) ---\n", numportals * 2 );
	RunThreadsOnIndividual( numportals * 2, qtrue, PassageFlow );
#endif
}

/*
   ==================
   CalcPassagePortalVis
   ==================
 */
void CalcPassagePortalVis( void ){
	PassageMemory();

#ifdef MREDEBUG
	Sys_Printf( "%6d portals out of %d", 0, numportals * 2 );
	RunThreadsOnIndividual( numportals * 2, qfalse, CreatePassages );
	Sys_Printf( "\n" );
	Sys_Printf( "%6d portals out of %d", 0, numportals * 2 );
	RunThreadsOnIndividual( numportals * 2, qfalse, PassagePortalFlow );
	Sys_Printf( "\n" );
#else
	Sys_Printf( "\n--- CreatePassages (%d) ---\n", numportals * 2 );
	RunThreadsOnIndividual( numportals * 2, qtrue, CreatePassages );

	Sys_Printf( "\n--- PassagePortalFlow (%d) ---\n", numportals * 2 );
	RunThreadsOnIndividual( numportals * 2, qtrue, PassagePortalFlow );
#endif
}

/*
   ==================
   CalcFastVis
   ==================
 */
void CalcFastVis( void ){
	int i;

	// fastvis just uses mightsee for a very loose bound
	for ( i = 0 ; i < numportals * 2 ; i++ )
	{
		portals[i].portalvis = portals[i].portalflood;
		portals[i].status = stat_done;
	}
}

/*
   ==================
   CalcVis
   ==================
 */
void CalcVis( void ){
	int i;
	const char  *value;


	/* ydnar: rr2do2's farplane code */
	farPlaneDist = 0.0f;
	value = ValueForKey( &entities[ 0 ], "_farplanedist" );     /* proper '_' prefixed key */
	if ( value[ 0 ] == '\0' ) {
		value = ValueForKey( &entities[ 0 ], "fogclip" );       /* wolf compatibility */
	}
	if ( value[ 0 ] == '\0' ) {
		value = ValueForKey( &entities[ 0 ], "distancecull" );  /* sof2 compatibility */
	}
	if ( value[ 0 ] != '\0' ) {
		farPlaneDist = atof( value );
		if ( farPlaneDist > 0.0f ) {
			Sys_Printf( "farplane distance = %.1f\n", farPlaneDist );
		}
		else{
			farPlaneDist = 0.0f;
		}
	}



	Sys_Printf( "\n--- BasePortalVis (%d) ---\n", numportals * 2 );
	RunThreadsOnIndividual( numportals * 2, qtrue, BasePortalVis );

//	RunThreadsOnIndividual (numportals*2, qtrue, BetterPortalVis);

	SortPortals();

	if ( fastvis ) {
		CalcFastVis();
	}
	else if ( noPassageVis ) {
		CalcPortalVis();
	}
	else if ( passageVisOnly ) {
		CalcPassageVis();
	}
	else {
		CalcPassagePortalVis();
	}
	//
	// assemble the leaf vis lists by oring and compressing the portal lists
	//
	Sys_Printf( "creating leaf vis...\n" );
	for ( i = 0 ; i < portalclusters ; i++ )
		ClusterMerge( i );

	Sys_Printf( "Total visible clusters: %i\n", totalvis );
	Sys_Printf( "Average clusters visible: %i\n", totalvis / portalclusters );
}

/*
   ==================
   SetPortalSphere
   ==================
 */
void SetPortalSphere( vportal_t *p ){
	int i;
	vec3_t total, dist;
	fixedWinding_t  *w;
	float r, bestr;

	w = p->winding;
	VectorCopy( vec3_origin, total );
	for ( i = 0 ; i < w->numpoints ; i++ )
	{
		VectorAdd( total, w->points[i], total );
	}

	for ( i = 0 ; i < 3 ; i++ )
		total[i] /= w->numpoints;

	bestr = 0;
	for ( i = 0 ; i < w->numpoints ; i++ )
	{
		VectorSubtract( w->points[i], total, dist );
		r = VectorLength( dist );
		if ( r > bestr ) {
			bestr = r;
		}
	}
	VectorCopy( total, p->origin );
	p->radius = bestr;
}

/*
   =============
   Winding_PlanesConcave
   =============
 */
#define WCONVEX_EPSILON     0.2

int Winding_PlanesConcave( fixedWinding_t *w1, fixedWinding_t *w2,
						   vec3_t normal1, vec3_t normal2,
						   float dist1, float dist2 ){
	int i;

	if ( !w1 || !w2 ) {
		return qfalse;
	}

	// check if one of the points of winding 1 is at the front of the plane of winding 2
	for ( i = 0; i < w1->numpoints; i++ )
	{
		if ( DotProduct( normal2, w1->points[i] ) - dist2 > WCONVEX_EPSILON ) {
			return qtrue;
		}
	}
	// check if one of the points of winding 2 is at the front of the plane of winding 1
	for ( i = 0; i < w2->numpoints; i++ )
	{
		if ( DotProduct( normal1, w2->points[i] ) - dist1 > WCONVEX_EPSILON ) {
			return qtrue;
		}
	}

	return qfalse;
}

/*
   ============
   TryMergeLeaves
   ============
 */
int TryMergeLeaves( int l1num, int l2num ){
	int i, j, k, n, numportals;
	visPlane_t plane1, plane2;
	leaf_t *l1, *l2;
	vportal_t *p1, *p2;
	vportal_t *portals[MAX_PORTALS_ON_LEAF];

	for ( k = 0; k < 2; k++ )
	{
		if ( k ) {
			l1 = &leafs[l1num];
		}
		else{l1 = &faceleafs[l1num]; }
		for ( i = 0; i < l1->numportals; i++ )
		{
			p1 = l1->portals[i];
			if ( p1->leaf == l2num ) {
				continue;
			}
			for ( n = 0; n < 2; n++ )
			{
				if ( n ) {
					l2 = &leafs[l2num];
				}
				else{l2 = &faceleafs[l2num]; }
				for ( j = 0; j < l2->numportals; j++ )
				{
					p2 = l2->portals[j];
					if ( p2->leaf == l1num ) {
						continue;
					}
					//
					plane1 = p1->plane;
					plane2 = p2->plane;
					if ( Winding_PlanesConcave( p1->winding, p2->winding, plane1.normal, plane2.normal, plane1.dist, plane2.dist ) ) {
						return qfalse;
					}
				}
			}
		}
	}
	for ( k = 0; k < 2; k++ )
	{
		if ( k ) {
			l1 = &leafs[l1num];
			l2 = &leafs[l2num];
		}
		else
		{
			l1 = &faceleafs[l1num];
			l2 = &faceleafs[l2num];
		}
		numportals = 0;
		//the leaves can be merged now
		for ( i = 0; i < l1->numportals; i++ )
		{
			p1 = l1->portals[i];
			if ( p1->leaf == l2num ) {
				p1->removed = qtrue;
				continue;
			}
			portals[numportals++] = p1;
		}
		for ( j = 0; j < l2->numportals; j++ )
		{
			p2 = l2->portals[j];
			if ( p2->leaf == l1num ) {
				p2->removed = qtrue;
				continue;
			}
			portals[numportals++] = p2;
		}
		for ( i = 0; i < numportals; i++ )
		{
			l2->portals[i] = portals[i];
		}
		l2->numportals = numportals;
		l1->merged = l2num;
	}
	return qtrue;
}

/*
   ============
   UpdatePortals
   ============
 */
void UpdatePortals( void ){
	int i;
	vportal_t *p;

	for ( i = 0; i < numportals * 2; i++ )
	{
		p = &portals[i];
		if ( p->removed ) {
			continue;
		}
		while ( leafs[p->leaf].merged >= 0 )
			p->leaf = leafs[p->leaf].merged;
	}
}

/*
   ============
   MergeLeaves

   try to merge leaves but don't merge through hint splitters
   ============
 */
void MergeLeaves( void ){
	int i, j, nummerges, totalnummerges;
	leaf_t *leaf;
	vportal_t *p;

	totalnummerges = 0;
	do
	{
		nummerges = 0;
		for ( i = 0; i < portalclusters; i++ )
		{
			leaf = &leafs[i];
			//if this leaf is merged already

			/* ydnar: vmods: merge all non-hint portals */
			if ( leaf->merged >= 0 && hint == qfalse ) {
				continue;
			}


			for ( j = 0; j < leaf->numportals; j++ )
			{
				p = leaf->portals[j];
				//
				if ( p->removed ) {
					continue;
				}
				//never merge through hint portals
				if ( p->hint ) {
					continue;
				}
				if ( TryMergeLeaves( i, p->leaf ) ) {
					UpdatePortals();
					nummerges++;
					break;
				}
			}
		}
		totalnummerges += nummerges;
	} while ( nummerges );
	Sys_Printf( "%6d leaves merged\n", totalnummerges );
}

/*
   ============
   TryMergeWinding
   ============
 */
#define CONTINUOUS_EPSILON  0.005

fixedWinding_t *TryMergeWinding( fixedWinding_t *f1, fixedWinding_t *f2, vec3_t planenormal ){
	vec_t       *p1, *p2, *p3, *p4, *back;
	fixedWinding_t  *newf;
	int i, j, k, l;
	vec3_t normal, delta;
	vec_t dot;
	qboolean keep1, keep2;


	//
	// find a common edge
	//
	p1 = p2 = NULL; // stop compiler warning
	j = 0;          //

	for ( i = 0; i < f1->numpoints; i++ )
	{
		p1 = f1->points[i];
		p2 = f1->points[( i + 1 ) % f1->numpoints];
		for ( j = 0; j < f2->numpoints; j++ )
		{
			p3 = f2->points[j];
			p4 = f2->points[( j + 1 ) % f2->numpoints];
			for ( k = 0; k < 3; k++ )
			{
				if ( fabs( p1[k] - p4[k] ) > 0.1 ) { //EQUAL_EPSILON) //ME
					break;
				}
				if ( fabs( p2[k] - p3[k] ) > 0.1 ) { //EQUAL_EPSILON) //ME
					break;
				}
			} //end for
			if ( k == 3 ) {
				break;
			}
		} //end for
		if ( j < f2->numpoints ) {
			break;
		}
	} //end for

	if ( i == f1->numpoints ) {
		return NULL;            // no matching edges

	}
	//
	// check slope of connected lines
	// if the slopes are colinear, the point can be removed
	//
	back = f1->points[( i + f1->numpoints - 1 ) % f1->numpoints];
	VectorSubtract( p1, back, delta );
	CrossProduct( planenormal, delta, normal );
	VectorNormalize( normal, normal );

	back = f2->points[( j + 2 ) % f2->numpoints];
	VectorSubtract( back, p1, delta );
	dot = DotProduct( delta, normal );
	if ( dot > CONTINUOUS_EPSILON ) {
		return NULL;            // not a convex polygon
	}
	keep1 = (qboolean)( dot < -CONTINUOUS_EPSILON );

	back = f1->points[( i + 2 ) % f1->numpoints];
	VectorSubtract( back, p2, delta );
	CrossProduct( planenormal, delta, normal );
	VectorNormalize( normal, normal );

	back = f2->points[( j + f2->numpoints - 1 ) % f2->numpoints];
	VectorSubtract( back, p2, delta );
	dot = DotProduct( delta, normal );
	if ( dot > CONTINUOUS_EPSILON ) {
		return NULL;            // not a convex polygon
	}
	keep2 = (qboolean)( dot < -CONTINUOUS_EPSILON );

	//
	// build the new polygon
	//
	newf = NewFixedWinding( f1->numpoints + f2->numpoints );

	// copy first polygon
	for ( k = ( i + 1 ) % f1->numpoints ; k != i ; k = ( k + 1 ) % f1->numpoints )
	{
		if ( k == ( i + 1 ) % f1->numpoints && !keep2 ) {
			continue;
		}

		VectorCopy( f1->points[k], newf->points[newf->numpoints] );
		newf->numpoints++;
	}

	// copy second polygon
	for ( l = ( j + 1 ) % f2->numpoints ; l != j ; l = ( l + 1 ) % f2->numpoints )
	{
		if ( l == ( j + 1 ) % f2->numpoints && !keep1 ) {
			continue;
		}
		VectorCopy( f2->points[l], newf->points[newf->numpoints] );
		newf->numpoints++;
	}

	return newf;
}

/*
   ============
   MergeLeafPortals
   ============
 */
void MergeLeafPortals( void ){
	int i, j, k, nummerges, hintsmerged;
	leaf_t *leaf;
	vportal_t *p1, *p2;
	fixedWinding_t *w;

	nummerges = 0;
	hintsmerged = 0;
	for ( i = 0; i < portalclusters; i++ )
	{
		leaf = &leafs[i];
		if ( leaf->merged >= 0 ) {
			continue;
		}
		for ( j = 0; j < leaf->numportals; j++ )
		{
			p1 = leaf->portals[j];
			if ( p1->removed ) {
				continue;
			}
			for ( k = j + 1; k < leaf->numportals; k++ )
			{
				p2 = leaf->portals[k];
				if ( p2->removed ) {
					continue;
				}
				if ( p1->leaf == p2->leaf ) {
					w = TryMergeWinding( p1->winding, p2->winding, p1->plane.normal );
					if ( w ) {
						free( p1->winding );    //% FreeWinding(p1->winding);
						p1->winding = w;
						if ( p1->hint && p2->hint ) {
							hintsmerged++;
						}
						p1->hint |= p2->hint;
						SetPortalSphere( p1 );
						p2->removed = qtrue;
						nummerges++;
						i--;
						break;
					}
				}
			}
			if ( k < leaf->numportals ) {
				break;
			}
		}
	}
	Sys_Printf( "%6d portals merged\n", nummerges );
	Sys_Printf( "%6d hint portals merged\n", hintsmerged );
}


/*
   ============
   WritePortals
   ============
 */
int CountActivePortals( void ){
	int num, hints, j;
	vportal_t *p;

	num = 0;
	hints = 0;
	for ( j = 0; j < numportals * 2; j++ )
	{
		p = portals + j;
		if ( p->removed ) {
			continue;
		}
		if ( p->hint ) {
			hints++;
		}
		num++;
	}
	Sys_Printf( "%6d active portals\n", num );
	Sys_Printf( "%6d hint portals\n", hints );
	return num;
}

/*
   ============
   WritePortals
   ============
 */
void WriteFloat( FILE *f, vec_t v );

void WritePortals( char *filename ){
	int i, j, num;
	FILE *pf;
	vportal_t *p;
	fixedWinding_t *w;

	// write the file
	pf = fopen( filename, "w" );
	if ( !pf ) {
		Error( "Error opening %s", filename );
	}

	num = 0;
	for ( j = 0; j < numportals * 2; j++ )
	{
		p = portals + j;
		if ( p->removed ) {
			continue;
		}
//		if (!p->hint)
//			continue;
		num++;
	}

	fprintf( pf, "%s\n", PORTALFILE );
	fprintf( pf, "%i\n", 0 );
	fprintf( pf, "%i\n", num ); // + numfaces);
	fprintf( pf, "%i\n", 0 );

	for ( j = 0; j < numportals * 2; j++ )
	{
		p = portals + j;
		if ( p->removed ) {
			continue;
		}
//		if (!p->hint)
//			continue;
		w = p->winding;
		fprintf( pf,"%i %i %i ",w->numpoints, 0, 0 );
		fprintf( pf, "%d ", p->hint );
		for ( i = 0 ; i < w->numpoints ; i++ )
		{
			fprintf( pf,"(" );
			WriteFloat( pf, w->points[i][0] );
			WriteFloat( pf, w->points[i][1] );
			WriteFloat( pf, w->points[i][2] );
			fprintf( pf,") " );
		}
		fprintf( pf,"\n" );
	}

	/*
	   for (j = 0; j < numfaces; j++)
	   {
	    p = faces + j;
	    w = p->winding;
	    fprintf (pf,"%i %i %i ",w->numpoints, 0, 0);
	    fprintf (pf, "0 ");
	    for (i=0 ; i<w->numpoints ; i++)
	    {
	        fprintf (pf,"(");
	        WriteFloat (pf, w->points[i][0]);
	        WriteFloat (pf, w->points[i][1]);
	        WriteFloat (pf, w->points[i][2]);
	        fprintf (pf,") ");
	    }
	    fprintf (pf,"\n");
	   }*/

	fclose( pf );
}

/*
   ============
   LoadPortals
   ============
 */
void LoadPortals( char *name ){
	int i, j, hint;
	vportal_t   *p;
	leaf_t      *l;
	char magic[80];
	FILE        *f;
	int numpoints;
	fixedWinding_t  *w;
	int leafnums[2];
	visPlane_t plane;

	if ( !strcmp( name,"-" ) ) {
		f = stdin;
	}
	else
	{
		f = fopen( name, "r" );
		if ( !f ) {
			Error( "LoadPortals: couldn't read %s\n",name );
		}
	}

	if ( fscanf( f,"%79s\n%i\n%i\n%i\n",magic, &portalclusters, &numportals, &numfaces ) != 4 ) {
		Error( "LoadPortals: failed to read header" );
	}
	if ( strcmp( magic,PORTALFILE ) ) {
		Error( "LoadPortals: not a portal file" );
	}

	Sys_Printf( "%6i portalclusters\n", portalclusters );
	Sys_Printf( "%6i numportals\n", numportals );
	Sys_Printf( "%6i numfaces\n", numfaces );

	// these counts should take advantage of 64 bit systems automatically
	leafbytes = ( ( portalclusters + 63 ) & ~63 ) >> 3;
	leaflongs = leafbytes / sizeof( long );

	portalbytes = ( ( numportals * 2 + 63 ) & ~63 ) >> 3;
	portallongs = portalbytes / sizeof( long );

	// each file portal is split into two memory portals
	portals = safe_malloc( 2 * numportals * sizeof( vportal_t ) );
	memset( portals, 0, 2 * numportals * sizeof( vportal_t ) );

	leafs = safe_malloc( portalclusters * sizeof( leaf_t ) );
	memset( leafs, 0, portalclusters * sizeof( leaf_t ) );

	for ( i = 0; i < portalclusters; i++ )
		leafs[i].merged = -1;

	numBSPVisBytes = VIS_HEADER_SIZE + portalclusters * leafbytes;

	if ( numBSPVisBytes > MAX_MAP_VISIBILITY ) {
		Error( "MAX_MAP_VISIBILITY exceeded" );
	}

	( (int *)bspVisBytes )[0] = portalclusters;
	( (int *)bspVisBytes )[1] = leafbytes;

	for ( i = 0, p = portals ; i < numportals ; i++ )
	{
		if ( fscanf( f, "%i %i %i ", &numpoints, &leafnums[0], &leafnums[1] ) != 3 ) {
			Error( "LoadPortals: reading portal %i", i );
		}
		if ( numpoints > MAX_POINTS_ON_WINDING ) {
			Error( "LoadPortals: portal %i has too many points", i );
		}
		if ( (unsigned)leafnums[0] > portalclusters
			 || (unsigned)leafnums[1] > portalclusters ) {
			Error( "LoadPortals: reading portal %i", i );
		}
		if ( fscanf( f, "%i ", &hint ) != 1 ) {
			Error( "LoadPortals: reading hint state" );
		}

		w = p->winding = NewFixedWinding( numpoints );
		w->numpoints = numpoints;

		for ( j = 0 ; j < numpoints ; j++ )
		{
			double v[3];
			int k;

			// scanf into double, then assign to vec_t
			// so we don't care what size vec_t is
			if ( fscanf( f, "(%lf %lf %lf ) "
						 , &v[0], &v[1], &v[2] ) != 3 ) {
				Error( "LoadPortals: reading portal %i", i );
			}
			for ( k = 0 ; k < 3 ; k++ )
				w->points[j][k] = v[k];
		}
		fscanf( f, "\n" );

		// calc plane
		PlaneFromWinding( w, &plane );

		// create forward portal
		l = &leafs[leafnums[0]];
		if ( l->numportals == MAX_PORTALS_ON_LEAF ) {
			Error( "Leaf with too many portals" );
		}
		l->portals[l->numportals] = p;
		l->numportals++;

		p->num = i + 1;
		p->hint = hint;
		p->winding = w;
		VectorSubtract( vec3_origin, plane.normal, p->plane.normal );
		p->plane.dist = -plane.dist;
		p->leaf = leafnums[1];
		SetPortalSphere( p );
		p++;

		// create backwards portal
		l = &leafs[leafnums[1]];
		if ( l->numportals == MAX_PORTALS_ON_LEAF ) {
			Error( "Leaf with too many portals" );
		}
		l->portals[l->numportals] = p;
		l->numportals++;

		p->num = i + 1;
		p->hint = hint;
		p->winding = NewFixedWinding( w->numpoints );
		p->winding->numpoints = w->numpoints;
		for ( j = 0 ; j < w->numpoints ; j++ )
		{
			VectorCopy( w->points[w->numpoints - 1 - j], p->winding->points[j] );
		}

		p->plane = plane;
		p->leaf = leafnums[0];
		SetPortalSphere( p );
		p++;

	}

	faces = safe_malloc( 2 * numfaces * sizeof( vportal_t ) );
	memset( faces, 0, 2 * numfaces * sizeof( vportal_t ) );

	faceleafs = safe_malloc( portalclusters * sizeof( leaf_t ) );
	memset( faceleafs, 0, portalclusters * sizeof( leaf_t ) );

	for ( i = 0, p = faces; i < numfaces; i++ )
	{
		if ( fscanf( f, "%i %i ", &numpoints, &leafnums[0] ) != 2 ) {
			Error( "LoadPortals: reading portal %i", i );
		}

		w = p->winding = NewFixedWinding( numpoints );
		w->numpoints = numpoints;

		for ( j = 0 ; j < numpoints ; j++ )
		{
			double v[3];
			int k;

			// scanf into double, then assign to vec_t
			// so we don't care what size vec_t is
			if ( fscanf( f, "(%lf %lf %lf ) "
						 , &v[0], &v[1], &v[2] ) != 3 ) {
				Error( "LoadPortals: reading portal %i", i );
			}
			for ( k = 0 ; k < 3 ; k++ )
				w->points[j][k] = v[k];
		}
		fscanf( f, "\n" );

		// calc plane
		PlaneFromWinding( w, &plane );

		l = &faceleafs[leafnums[0]];
		l->merged = -1;
		if ( l->numportals == MAX_PORTALS_ON_LEAF ) {
			Error( "Leaf with too many faces" );
		}
		l->portals[l->numportals] = p;
		l->numportals++;

		p->num = i + 1;
		p->winding = w;
		// normal pointing out of the leaf
		VectorSubtract( vec3_origin, plane.normal, p->plane.normal );
		p->plane.dist = -plane.dist;
		p->leaf = -1;
		SetPortalSphere( p );
		p++;
	}

	fclose( f );
}



/*
   ===========
   VisMain
   ===========
 */
int VisMain( int argc, char **argv ){
	char portalfile[1024];
	int i;


	/* note it */
	Sys_Printf( "--- Vis ---\n" );

	/* process arguments */
	for ( i = 1 ; i < ( argc - 1 ) ; i++ )
	{
		if ( !strcmp( argv[i], "-fast" ) ) {
			Sys_Printf( "fastvis = true\n" );
			fastvis = qtrue;
		}
		else if ( !strcmp( argv[i], "-merge" ) ) {
			Sys_Printf( "merge = true\n" );
			mergevis = qtrue;
		}
		else if ( !strcmp( argv[i], "-nopassage" ) ) {
			Sys_Printf( "nopassage = true\n" );
			noPassageVis = qtrue;
		}
		else if ( !strcmp( argv[i], "-passageOnly" ) ) {
			Sys_Printf( "passageOnly = true\n" );
			passageVisOnly = qtrue;
		}
		else if ( !strcmp( argv[i],"-nosort" ) ) {
			Sys_Printf( "nosort = true\n" );
			nosort = qtrue;
		}
		else if ( !strcmp( argv[i],"-saveprt" ) ) {
			Sys_Printf( "saveprt = true\n" );
			saveprt = qtrue;
		}
		else if ( !strcmp( argv[i],"-tmpin" ) ) {
			strcpy( inbase, "/tmp" );
		}
		else if ( !strcmp( argv[i],"-tmpout" ) ) {
			strcpy( outbase, "/tmp" );
		}


		/* ydnar: -hint to merge all but hint portals */
		else if ( !strcmp( argv[ i ], "-hint" ) ) {
			Sys_Printf( "hint = true\n" );
			hint = qtrue;
			mergevis = qtrue;
		}

		else{
			Sys_Printf( "WARNING: Unknown option \"%s\"\n", argv[ i ] );
		}
	}

	if ( i != argc - 1 ) {
		Error( "usage: vis [-threads #] [-level 0-4] [-fast] [-v] bspfile" );
	}


	/* load the bsp */
	sprintf( source, "%s%s", inbase, ExpandArg( argv[ i ] ) );
	StripExtension( source );
	strcat( source, ".bsp" );
	Sys_Printf( "Loading %s\n", source );
	LoadBSPFile( source );

	/* load the portal file */
	sprintf( portalfile, "%s%s", inbase, ExpandArg( argv[ i ] ) );
	StripExtension( portalfile );
	strcat( portalfile, ".prt" );
	Sys_Printf( "Loading %s\n", portalfile );
	LoadPortals( portalfile );

	/* ydnar: exit if no portals, hence no vis */
	if ( numportals == 0 ) {
		Sys_Printf( "No portals means no vis, exiting.\n" );
		return 0;
	}

	/* ydnar: for getting far plane */
	ParseEntities();

	if ( mergevis ) {
		MergeLeaves();
		MergeLeafPortals();
	}

	CountActivePortals();
	/* WritePortals( "maps/hints.prs" );*/

	Sys_Printf( "visdatasize:%i\n", numBSPVisBytes );

	CalcVis();

	/* delete the prt file */
	if ( !saveprt ) {
		remove( portalfile );
	}

	/* write the bsp file */
	Sys_Printf( "Writing %s\n", source );
	WriteBSPFile( source );

	return 0;
}