int c = 0;

/* count brushes */

for ( ; brushes != NULL; brushes = brushes->next )

c++;

return c;

int i;

/* error check */

if ( *( (unsigned int*) b ) == 0xFEFEFEFE ) {

Sys_FPrintf( SYS_VRB, "WARNING: Attempt to free an already freed brush!\n" );

return;

}

/* free brush sides */

for ( i = 0; i < b->numsides; i++ )

if ( b->sides[i].winding != NULL ) {

FreeWinding( b->sides[ i ].winding );

}

/* ydnar: overwrite it */

memset( b, 0xFE, (size_t)&( ( (brush_t*) 0 )->sides[ b->numsides ] ) );

*( (unsigned int*) b ) = 0xFEFEFEFE;

/* free it */

free( b );

if ( numthreads == 1 ) {

numActiveBrushes--;

}

brush_t *next;

/* walk brush list */

for ( ; brushes != NULL; brushes = next )

{

next = brushes->next;

FreeBrush( brushes );

}

int i, j;

winding_t *w;

ClearBounds( brush->mins, brush->maxs );

for ( i = 0; i < brush->numsides; i++ )

{

w = brush->sides[ i ].winding;

if ( w == NULL ) {

continue;

}

for ( j = 0; j < w->numpoints; j++ )

AddPointToBounds( w->p[ j ], brush->mins, brush->maxs );

}

for ( i = 0; i < 3; i++ )

{

if ( brush->mins[ i ] < MIN_WORLD_COORD || brush->maxs[ i ] > MAX_WORLD_COORD || brush->mins[i] >= brush->maxs[ i ] ) {

return qfalse;

}

}

return qtrue;

int i;

vec_t ai, bi, outi;

/* dummy check */

if ( a == NULL || b == NULL || out == NULL ) {

return;

}

/* do each element */

for ( i = 0; i < 3; i++ )

{

/* round to integer */

ai = Q_rint( a[ i ] );

bi = Q_rint( b[ i ] );

/* prefer exact integer */

if ( ai == a[ i ] ) {

out[ i ] = a[ i ];

}

else if ( bi == b[ i ] ) {

out[ i ] = b[ i ];

}

/* use nearest */

else if ( fabs( ai - a[ i ] ) < fabs( bi - b[ i ] ) ) {

out[ i ] = a[ i ];

}

else{

out[ i ] = b[ i ];

}

/* snap */

outi = Q_rint( out[ i ] );

if ( fabs( outi - out[ i ] ) <= SNAP_EPSILON ) {

out[ i ] = outi;

}

}

// I'm just preserving what I think was the intended logic of the original

// SnapWeldVector(). I'm not actually sure where this function should even

// be used. I'd like to know which kinds of problems this function addresses.

// TODO: I thought we're snapping all coordinates to nearest 1/8 unit?

// So what is natural about snapping to the nearest integer? Maybe we should

// be snapping to the nearest 1/8 unit instead?

int i;

vec_accu_t ai, bi, ad, bd;

if ( a == NULL || b == NULL || out == NULL ) {

Error( "SnapWeldVectorAccu: NULL argument" );

}

for ( i = 0; i < 3; i++ )

{

ai = Q_rintAccu( a[i] );

bi = Q_rintAccu( b[i] );

ad = fabs( ai - a[i] );

bd = fabs( bi - b[i] );

if ( ad < bd ) {

if ( ad < SNAP_EPSILON ) {

out[i] = ai;

}

else{out[i] = a[i]; }

}

else

{

if ( bd < SNAP_EPSILON ) {

out[i] = bi;

}

else{out[i] = b[i]; }

}

}

qboolean valid = qtrue;

int i, j, k;

vec3_t vec;

float dist;

/* dummy check */

if ( !w ) {

return qfalse;

}

/* check all verts */

for ( i = 0; i < w->numpoints; i++ )

{

/* don't remove points if winding is a triangle */

if ( w->numpoints == 3 ) {

return valid;

}

/* get second point index */

j = ( i + 1 ) % w->numpoints;

/* degenerate edge? */

VectorSubtract( w->p[ i ], w->p[ j ], vec );

dist = VectorLength( vec );

if ( dist < DEGENERATE_EPSILON ) {

valid = qfalse;

//Sys_FPrintf( SYS_VRB, "WARNING: Degenerate winding edge found, fixing...\n" );

/* create an average point (ydnar 2002-01-26: using nearest-integer weld preference) */

SnapWeldVector( w->p[ i ], w->p[ j ], vec );

VectorCopy( vec, w->p[ i ] );

//VectorAdd( w->p[ i ], w->p[ j ], vec );

//VectorScale( vec, 0.5, w->p[ i ] );

/* move the remaining verts */

for ( k = i + 2; k < w->numpoints; k++ )

{

VectorCopy( w->p[ k ], w->p[ k - 1 ] );

}

w->numpoints--;

}

}

/* one last check and return */

if ( w->numpoints < 3 ) {

valid = qfalse;

}

return valid;

int i, j, k;

vec3_accu_t vec;

vec_accu_t dist;

qboolean done, altered;

if ( w == NULL ) {

Error( "FixWindingAccu: NULL argument" );

}

altered = qfalse;

while ( qtrue )

{

if ( w->numpoints < 2 ) {

break; // Don't remove the only remaining point.

}

done = qtrue;

for ( i = 0; i < w->numpoints; i++ )

{

j = ( ( ( i + 1 ) == w->numpoints ) ? 0 : ( i + 1 ) );

VectorSubtractAccu( w->p[i], w->p[j], vec );

dist = VectorLengthAccu( vec );

if ( dist < DEGENERATE_EPSILON ) {

// TODO: I think the "snap weld vector" was written before

// some of the math precision fixes, and its purpose was

// probably to address math accuracy issues. We can think

// about changing the logic here. Maybe once plane distance

// gets 64 bits, we can look at it then.

SnapWeldVectorAccu( w->p[i], w->p[j], vec );

VectorCopyAccu( vec, w->p[i] );

for ( k = j + 1; k < w->numpoints; k++ )

{

VectorCopyAccu( w->p[k], w->p[k - 1] );

}

w->numpoints--;

altered = qtrue;

// The only way to finish off fixing the winding consistently and

// accurately is by fixing the winding all over again. For example,

// the point at index i and the point at index i-1 could now be

// less than the epsilon distance apart. There are too many special

// case problems we'd need to handle if we didn't start from the

// beginning.

done = qfalse;

break; // This will cause us to return to the "while" loop.

}

}

if ( done ) {

break;

}

}

return altered;

int i, j;

#if Q3MAP2_EXPERIMENTAL_HIGH_PRECISION_MATH_FIXES

winding_accu_t *w;

#else

winding_t *w;

#endif

side_t *side;

plane_t *plane;

/* walk the list of brush sides */

for ( i = 0; i < brush->numsides; i++ )

{

/* get side and plane */

side = &brush->sides[ i ];

plane = &mapplanes[ side->planenum ];

/* make huge winding */

#if Q3MAP2_EXPERIMENTAL_HIGH_PRECISION_MATH_FIXES

w = BaseWindingForPlaneAccu( plane->normal, plane->dist );

#else

w = BaseWindingForPlane( plane->normal, plane->dist );

#endif

/* walk the list of brush sides */

for ( j = 0; j < brush->numsides && w != NULL; j++ )

{

if ( i == j ) {

continue;

}

if ( brush->sides[ j ].planenum == ( brush->sides[ i ].planenum ^ 1 ) ) {

continue; /* back side clipaway */

}

if ( brush->sides[ j ].bevel ) {

continue;

}

plane = &mapplanes[ brush->sides[ j ].planenum ^ 1 ];

#if Q3MAP2_EXPERIMENTAL_HIGH_PRECISION_MATH_FIXES

ChopWindingInPlaceAccu( &w, plane->normal, plane->dist, 0 );

#else

ChopWindingInPlace( &w, plane->normal, plane->dist, 0 ); // CLIP_EPSILON );

#endif

/* ydnar: fix broken windings that would generate trifans */

#if Q3MAP2_EXPERIMENTAL_HIGH_PRECISION_MATH_FIXES

// I think it's better to FixWindingAccu() once after we chop with all planes

// so that error isn't multiplied. There is nothing natural about welding

// the points unless they are the final endpoints. ChopWindingInPlaceAccu()

// is able to handle all kinds of degenerate windings.

#else

FixWinding( w );

#endif

}

/* set side winding */

#if Q3MAP2_EXPERIMENTAL_HIGH_PRECISION_MATH_FIXES

if ( w != NULL ) {

FixWindingAccu( w );

if ( w->numpoints < 3 ) {

FreeWindingAccu( w );

w = NULL;

}

}

side->winding = ( w ? CopyWindingAccuToRegular( w ) : NULL );

if ( w ) {

FreeWindingAccu( w );

}

#else

side->winding = w;

#endif

}

/* find brush bounds */

return BoundBrush( brush );

int i;

winding_t *w;

vec3_t corner;

vec_t d, area, volume;

plane_t *plane;

if ( !brush ) {

return 0;

}

// grab the first valid point as the corner

w = NULL;

for ( i = 0 ; i < brush->numsides ; i++ )

{

w = brush->sides[i].winding;

if ( w ) {

break;

}

}

if ( !w ) {

return 0;

}

VectorCopy( w->p[0], corner );

// make tetrahedrons to all other faces

volume = 0;

for ( ; i < brush->numsides ; i++ )

{

w = brush->sides[i].winding;

if ( !w ) {

continue;

}

plane = &mapplanes[brush->sides[i].planenum];

d = -( DotProduct( corner, plane->normal ) - plane->dist );

area = WindingArea( w );

volume += d * area;

}

volume /= 3;

return volume;

FILE *f;

side_t *s;

int i;

winding_t *w;

/* note it */

Sys_Printf( "Writing %s\n", name );

/* open the map file */

f = fopen( name, "wb" );

if ( f == NULL ) {

Error( "Can't write %s\b", name );

}

fprintf( f, "{\n\"classname\" \"worldspawn\"\n" );

for ( ; list ; list = list->next )

{

fprintf( f, "{\n" );

for ( i = 0,s = list->sides ; i < list->numsides ; i++,s++ )

{

// TODO: See if we can use a smaller winding to prevent resolution loss.

// Is WriteBSPBrushMap() used only to decompile maps?

w = BaseWindingForPlane( mapplanes[s->planenum].normal, mapplanes[s->planenum].dist );

fprintf( f,"( %i %i %i ) ", (int)w->p[0][0], (int)w->p[0][1], (int)w->p[0][2] );

fprintf( f,"( %i %i %i ) ", (int)w->p[1][0], (int)w->p[1][1], (int)w->p[1][2] );

fprintf( f,"( %i %i %i ) ", (int)w->p[2][0], (int)w->p[2][1], (int)w->p[2][2] );

fprintf( f, "notexture 0 0 0 1 1\n" );

FreeWinding( w );

}

fprintf( f, "}\n" );

}

fprintf( f, "}\n" );

fclose( f );

brush_t *front, *back;

int c;

/* dummy check */

if ( b == NULL ) {

return 0;

}

/* add it to the leaf list */

if ( node->planenum == PLANENUM_LEAF ) {

/* something somewhere is hammering brushlist */

b->next = node->brushlist;

node->brushlist = b;

/* classify the leaf by the structural brush */

if ( !b->detail ) {

if ( b->opaque ) {

node->opaque = qtrue;

node->areaportal = qfalse;

}

else if ( b->compileFlags & C_AREAPORTAL ) {

if ( !node->opaque ) {

node->areaportal = qtrue;

}

}

}

return 1;

}

/* split it by the node plane */

c = b->numsides;

SplitBrush( b, node->planenum, &front, &back );

FreeBrush( b );

c = 0;

c += FilterBrushIntoTree_r( front, node->children[ 0 ] );

c += FilterBrushIntoTree_r( back, node->children[ 1 ] );

return c;

brush_t *b, *newb;

int r;

int c_unique, c_clusters;

int i;

/* note it */

Sys_FPrintf( SYS_VRB, "--- FilterDetailBrushesIntoTree ---\n" );

/* walk the list of brushes */

c_unique = 0;

c_clusters = 0;

for ( b = e->brushes; b; b = b->next )

{

if ( !b->detail ) {

continue;

}

c_unique++;

newb = CopyBrush( b );

r = FilterBrushIntoTree_r( newb, tree->headnode );

c_clusters += r;

/* mark all sides as visible so drawsurfs are created */

if ( r ) {

for ( i = 0; i < b->numsides; i++ )

{

if ( b->sides[ i ].winding ) {

b->sides[ i ].visible = qtrue;

}

}

}

}

/* emit some statistics */

Sys_FPrintf( SYS_VRB, "%9d detail brushes\n", c_unique );

Sys_FPrintf( SYS_VRB, "%9d cluster references\n", c_clusters );

brush_t *b, *newb;

int r;

int c_unique, c_clusters;

int i;

Sys_FPrintf( SYS_VRB, "--- FilterStructuralBrushesIntoTree ---\n" );

c_unique = 0;

c_clusters = 0;

for ( b = e->brushes ; b ; b = b->next ) {

if ( b->detail ) {

continue;

}

c_unique++;

newb = CopyBrush( b );

r = FilterBrushIntoTree_r( newb, tree->headnode );

c_clusters += r;

// mark all sides as visible so drawsurfs are created

if ( r ) {

for ( i = 0 ; i < b->numsides ; i++ ) {

if ( b->sides[i].winding ) {

b->sides[i].visible = qtrue;

}

}

}

}

/* emit some statistics */

Sys_FPrintf( SYS_VRB, "%9d structural brushes\n", c_unique );

Sys_FPrintf( SYS_VRB, "%9d cluster references\n", c_clusters );

int i, j;

vec_t len;

vec3_t delta;

int edges;

edges = 0;

for ( i = 0 ; i < w->numpoints ; i++ )

{

j = i == w->numpoints - 1 ? 0 : i + 1;

VectorSubtract( w->p[j], w->p[i], delta );

len = VectorLength( delta );

if ( len > EDGE_LENGTH ) {

if ( ++edges == 3 ) {

return qfalse;

}

}

}

return qtrue;

int i, j;

for ( i = 0 ; i < w->numpoints ; i++ )

{

for ( j = 0 ; j < 3 ; j++ )

if ( w->p[i][j] <= MIN_WORLD_COORD || w->p[i][j] >= MAX_WORLD_COORD ) {

return qtrue;

}

}

return qfalse;

int i, j;

winding_t *w;

vec_t d, max;

int side;

max = 0;

side = PSIDE_FRONT;

for ( i = 0 ; i < brush->numsides ; i++ )

{

w = brush->sides[i].winding;

if ( !w ) {

continue;

}

for ( j = 0 ; j < w->numpoints ; j++ )

{

d = DotProduct( w->p[j], plane->normal ) - plane->dist;

if ( d > max ) {

max = d;

side = PSIDE_FRONT;

}

if ( -d > max ) {

max = -d;

side = PSIDE_BACK;

}

}

}

return side;

brush_t *b[2];

int i, j;

winding_t *w, *cw[2], *midwinding;

plane_t *plane, *plane2;

side_t *s, *cs;

float d, d_front, d_back;

*front = NULL;

*back = NULL;

plane = &mapplanes[planenum];

// check all points

d_front = d_back = 0;

for ( i = 0 ; i < brush->numsides ; i++ )

{

w = brush->sides[i].winding;

if ( !w ) {

continue;

}

for ( j = 0 ; j < w->numpoints ; j++ )

{

d = DotProduct( w->p[j], plane->normal ) - plane->dist;

if ( d > 0 && d > d_front ) {

d_front = d;

}

if ( d < 0 && d < d_back ) {

d_back = d;

}

}

}

if ( d_front < 0.1 ) { // PLANESIDE_EPSILON)

// only on back

*back = CopyBrush( brush );

return;

}

if ( d_back > -0.1 ) { // PLANESIDE_EPSILON)

// only on front

*front = CopyBrush( brush );

return;

}

// create a new winding from the split plane

w = BaseWindingForPlane( plane->normal, plane->dist );

for ( i = 0 ; i < brush->numsides && w ; i++ )

{