float ne, de;

/* get local copies */

ne = normalEpsilon;

de = distanceEpsilon;

/* compare */

// We check equality of each component since we're using '<', not '<='

// (the epsilons may be zero). We want to use '<' intead of '<=' to be

// consistent with the true meaning of "epsilon", and also because other

// parts of the code uses this inequality.

if ( ( p->dist == dist || fabs( p->dist - dist ) < de ) &&

( p->normal[0] == normal[0] || fabs( p->normal[0] - normal[0] ) < ne ) &&

( p->normal[1] == normal[1] || fabs( p->normal[1] - normal[1] ) < ne ) &&

( p->normal[2] == normal[2] || fabs( p->normal[2] - normal[2] ) < ne ) ) {

return qtrue;

}

/* different */

return qfalse;

int hash;

hash = ( PLANE_HASHES - 1 ) & (int) fabs( p->dist );

p->hash_chain = planehash[hash];

planehash[hash] = p - mapplanes + 1;

plane_t *p, temp;

if ( VectorLength( normal ) < 0.5 ) {

Sys_Printf( "FloatPlane: bad normal\n" );

return -1;

}

// create a new plane

AUTOEXPAND_BY_REALLOC( plane_t, mapplanes, nummapplanes + 1, allocatedmapplanes, 1024 );

p = &mapplanes[nummapplanes];

VectorCopy( normal, p->normal );

p->dist = dist;

p->type = ( p + 1 )->type = PlaneTypeForNormal( p->normal );

VectorSubtract( vec3_origin, normal, ( p + 1 )->normal );

( p + 1 )->dist = -dist;

nummapplanes += 2;

// allways put axial planes facing positive first

if ( p->type < 3 ) {

if ( p->normal[0] < 0 || p->normal[1] < 0 || p->normal[2] < 0 ) {

// flip order

temp = *p;

*p = *( p + 1 );

*( p + 1 ) = temp;

AddPlaneToHash( p );

AddPlaneToHash( p + 1 );

return nummapplanes - 1;

}

}

AddPlaneToHash( p );

AddPlaneToHash( p + 1 );

return nummapplanes - 2;

#if Q3MAP2_EXPERIMENTAL_SNAP_NORMAL_FIX

int i;

qboolean adjusted = qfalse;

// A change from the original SnapNormal() is that we snap each

// component that's close to 0. So for example if a normal is

// (0.707, 0.707, 0.0000001), it will get snapped to lie perfectly in the

// XY plane (its Z component will be set to 0 and its length will be

// normalized). The original SnapNormal() didn't snap such vectors - it

// only snapped vectors that were near a perfect axis.

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

{

if ( normal[i] != 0.0 && -normalEpsilon < normal[i] && normal[i] < normalEpsilon ) {

normal[i] = 0.0;

adjusted = qtrue;

}

}

if ( adjusted ) {

VectorNormalize( normal, normal );

return qtrue;

}

return qfalse;

#else

int i;

// I would suggest that you uncomment the following code and look at the

// results:

/*

// When the normalEpsilon is 0.00001, the loop will break out when normal is

// (0.999990 0.000000 0.004469). In other words, this is the vector closest

// to axial that will NOT be snapped. Anything closer will be snaped. Now,

// 0.004469 is close to 1/225. The length of a circular quarter-arc of radius

// 1 is PI/2, or about 1.57. And 0.004469/1.57 is about 0.0028, or about

// 1/350. Expressed a different way, 1/350 is also about 0.26/90.

// This means is that a normal with an angle that is within 1/4 of a degree

// from axial will be "snapped". My belief is that the person who wrote the

// code below did not intend it this way. I think the person intended that

// the epsilon be measured against the vector components close to 0, not 1.0.

// I think the logic should be: if 2 of the normal components are within

// epsilon of 0, then the vector can be snapped to be perfectly axial.

// We may consider adjusting the epsilon to a larger value when we make this

// code fix.

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

{

if ( fabs( normal[ i ] - 1 ) < normalEpsilon ) {

VectorClear( normal );

normal[ i ] = 1;

return qtrue;

}

if ( fabs( normal[ i ] - -1 ) < normalEpsilon ) {

VectorClear( normal );

normal[ i ] = -1;

return qtrue;

}

}

return qfalse;

#endif

SnapNormal( normal );

// TODO: Rambetter has some serious comments here as well. First off,

// in the case where a normal is non-axial, there is nothing special

// about integer distances. I would think that snapping a distance might

// make sense for axial normals, but I'm not so sure about snapping

// non-axial normals. A shift by 0.01 in a plane, multiplied by a clipping

// against another plane that is 5 degrees off, and we introduce 0.1 error

// easily. A 0.1 error in a vertex is where problems start to happen, such

// as disappearing triangles.

// Second, assuming we have snapped the normal above, let's say that the

// plane we just snapped was defined for some points that are actually

// quite far away from normal * dist. Well, snapping the normal in this

// case means that we've just moved those points by potentially many units!

// Therefore, if we are going to snap the normal, we need to know the

// points we're snapping for so that the plane snaps with those points in

// mind (points remain close to the plane).

// I would like to know exactly which problems SnapPlane() is trying to

// solve so that we can better engineer it (I'm not saying that SnapPlane()

// should be removed altogether). Fix all this snapping code at some point!

if ( fabs( *dist - Q_rint( *dist ) ) < distanceEpsilon ) {

*dist = Q_rint( *dist );

}

int i;

vec3_t center;

vec_t distNearestInt;

if ( SnapNormal( normal ) ) {

if ( numPoints > 0 ) {

// Adjust the dist so that the provided points don't drift away.

VectorClear( center );

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

{

VectorAdd( center, points[i], center );

}

for ( i = 0; i < 3; i++ ) { center[i] = center[i] / numPoints; }

*dist = DotProduct( normal, center );

}

}

if ( VectorIsOnAxis( normal ) ) {

// Only snap distance if the normal is an axis. Otherwise there

// is nothing "natural" about snapping the distance to an integer.

distNearestInt = Q_rint( *dist );

if ( -distanceEpsilon < *dist - distNearestInt && *dist - distNearestInt < distanceEpsilon ) {

*dist = distNearestInt;

}

}

#if Q3MAP2_EXPERIMENTAL_HIGH_PRECISION_MATH_FIXES

vec3_accu_t paccu[3];

vec3_accu_t t1, t2, normalAccu;

vec3_t normal;

vec_t dist;

VectorCopyRegularToAccu( p[0], paccu[0] );

VectorCopyRegularToAccu( p[1], paccu[1] );

VectorCopyRegularToAccu( p[2], paccu[2] );

VectorSubtractAccu( paccu[0], paccu[1], t1 );

VectorSubtractAccu( paccu[2], paccu[1], t2 );

CrossProductAccu( t1, t2, normalAccu );

VectorNormalizeAccu( normalAccu, normalAccu );

// TODO: A 32 bit float for the plane distance isn't enough resolution

// if the plane is 2^16 units away from the origin (the "epsilon" approaches

// 0.01 in that case).

dist = (vec_t) DotProductAccu( paccu[0], normalAccu );

VectorCopyAccuToRegular( normalAccu, normal );

return FindFloatPlane( normal, dist, 3, p );

#else

vec3_t t1, t2, normal;

vec_t dist;

/* calc plane normal */

VectorSubtract( p[ 0 ], p[ 1 ], t1 );

VectorSubtract( p[ 2 ], p[ 1 ], t2 );

CrossProduct( t1, t2, normal );

VectorNormalize( normal, normal );

/* calc plane distance */

dist = DotProduct( p[ 0 ], normal );

/* store the plane */

return FindFloatPlane( normal, dist, 3, p );

#endif

int contentFlags, compileFlags;

side_t *s;

int i;

//% qboolean mixed;

/* get initial compile flags from first side */

s = &b->sides[ 0 ];

contentFlags = s->contentFlags;

compileFlags = s->compileFlags;

b->contentShader = s->shaderInfo;

//% mixed = qfalse;

/* get the content/compile flags for every side in the brush */

for ( i = 1; i < b->numsides; i++, s++ )

{

s = &b->sides[ i ];

if ( s->shaderInfo == NULL ) {

continue;

}

//% if( s->contentFlags != contentFlags || s->compileFlags != compileFlags )

//% mixed = qtrue;

contentFlags |= s->contentFlags;

compileFlags |= s->compileFlags;

}

/* ydnar: getting rid of this stupid warning */

//% if( mixed )

//% Sys_FPrintf( SYS_VRB,"Entity %i, Brush %i: mixed face contentFlags\n", b->entitynum, b->brushnum );

/* check for detail & structural */

if ( ( compileFlags & C_DETAIL ) && ( compileFlags & C_STRUCTURAL ) ) {

xml_Select( "Mixed detail and structural (defaulting to structural)", mapEnt->mapEntityNum, entitySourceBrushes, qfalse );

compileFlags &= ~C_DETAIL;

}

/* the fulldetail flag will cause detail brushes to be treated like normal brushes */

if ( fulldetail ) {

compileFlags &= ~C_DETAIL;

}

/* all translucent brushes that aren't specifically made structural will be detail */

if ( ( compileFlags & C_TRANSLUCENT ) && !( compileFlags & C_STRUCTURAL ) ) {

compileFlags |= C_DETAIL;

}

/* detail? */

if ( compileFlags & C_DETAIL ) {

c_detail++;

b->detail = qtrue;

}

else

{

c_structural++;

b->detail = qfalse;

}

/* opaque? */

if ( compileFlags & C_TRANSLUCENT ) {

b->opaque = qfalse;

}

else{

b->opaque = qtrue;

}

/* areaportal? */

if ( compileFlags & C_AREAPORTAL ) {

c_areaportals++;

}

/* set brush flags */

b->contentFlags = contentFlags;

b->compileFlags = compileFlags;

int axis, dir;

int i, j, k, l, order;

side_t sidetemp;

side_t *s, *s2;

winding_t *w, *w2;

vec3_t normal;

float dist;

vec3_t vec, vec2;

float d, minBack;

//

// add the axial planes

//

order = 0;

for ( axis = 0; axis < 3; axis++ ) {

for ( dir = -1; dir <= 1; dir += 2, order++ ) {

// see if the plane is allready present

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

{

/* ydnar: testing disabling of mre code */

#if 0

if ( dir > 0 ) {

if ( mapplanes[s->planenum].normal[axis] >= 0.9999f ) {

break;

}

}

else {

if ( mapplanes[s->planenum].normal[axis] <= -0.9999f ) {

break;

}

}

#else

if ( ( dir > 0 && mapplanes[ s->planenum ].normal[ axis ] == 1.0f ) ||

( dir < 0 && mapplanes[ s->planenum ].normal[ axis ] == -1.0f ) ) {

break;

}

#endif

}

if ( i == buildBrush->numsides ) {

// add a new side

if ( buildBrush->numsides == MAX_BUILD_SIDES ) {

xml_Select( "MAX_BUILD_SIDES", buildBrush->entityNum, buildBrush->brushNum, qtrue );

}

memset( s, 0, sizeof( *s ) );

buildBrush->numsides++;

VectorClear( normal );

normal[axis] = dir;

if ( dir == 1 ) {

/* ydnar: adding bevel plane snapping for fewer bsp planes */

if ( bevelSnap > 0 ) {

dist = floor( buildBrush->maxs[ axis ] / bevelSnap ) * bevelSnap;

}

else{

dist = buildBrush->maxs[ axis ];

}

}

else

{

/* ydnar: adding bevel plane snapping for fewer bsp planes */

if ( bevelSnap > 0 ) {

dist = -ceil( buildBrush->mins[ axis ] / bevelSnap ) * bevelSnap;

}

else{

dist = -buildBrush->mins[ axis ];

}

}

s->planenum = FindFloatPlane( normal, dist, 0, NULL );

s->contentFlags = buildBrush->sides[ 0 ].contentFlags;

s->bevel = qtrue;

c_boxbevels++;

}

// if the plane is not in it canonical order, swap it

if ( i != order ) {

sidetemp = buildBrush->sides[order];

buildBrush->sides[order] = buildBrush->sides[i];

buildBrush->sides[i] = sidetemp;

}

}

}

//

// add the edge bevels

//

if ( buildBrush->numsides == 6 ) {

return; // pure axial

}

// test the non-axial plane edges

for ( i = 6; i < buildBrush->numsides; i++ ) {

s = buildBrush->sides + i;

w = s->winding;

if ( !w ) {

continue;

}

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

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

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

if ( VectorNormalize( vec, vec ) < 0.5f ) {

continue;

}

SnapNormal( vec );

for ( k = 0; k < 3; k++ ) {

if ( vec[k] == -1.0f || vec[k] == 1.0f || ( vec[k] == 0.0f && vec[( k + 1 ) % 3] == 0.0f ) ) {

break; // axial

}

}

if ( k != 3 ) {

continue; // only test non-axial edges

}

/* debug code */

//% Sys_Printf( "-------------\n" );

// try the six possible slanted axials from this edge

for ( axis = 0; axis < 3; axis++ ) {

for ( dir = -1; dir <= 1; dir += 2 ) {

// construct a plane

VectorClear( vec2 );

vec2[axis] = dir;

CrossProduct( vec, vec2, normal );

if ( VectorNormalize( normal, normal ) < 0.5f ) {

continue;

}

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

// if all the points on all the sides are

// behind this plane, it is a proper edge bevel

for ( k = 0; k < buildBrush->numsides; k++ ) {

// if this plane has allready been used, skip it

if ( PlaneEqual( &mapplanes[buildBrush->sides[k].planenum], normal, dist ) ) {

break;

}

w2 = buildBrush->sides[k].winding;

if ( !w2 ) {

continue;

}

minBack = 0.0f;

for ( l = 0; l < w2->numpoints; l++ ) {

d = DotProduct( w2->p[l], normal ) - dist;

if ( d > 0.1f ) {

break; // point in front

}

if ( d < minBack ) {

minBack = d;

}

}

// if some point was at the front

if ( l != w2->numpoints ) {

break;

}

// if no points at the back then the winding is on the bevel plane

if ( minBack > -0.1f ) {

//% Sys_Printf( "On bevel plane\n" );

break;

}

}

if ( k != buildBrush->numsides ) {

continue; // wasn't part of the outer hull

}

/* debug code */

//% Sys_Printf( "n = %f %f %f\n", normal[ 0 ], normal[ 1 ], normal[ 2 ] );

// add this plane

if ( buildBrush->numsides == MAX_BUILD_SIDES ) {

xml_Select( "MAX_BUILD_SIDES", buildBrush->entityNum, buildBrush->brushNum, qtrue );

}

s2 = &buildBrush->sides[buildBrush->numsides];

buildBrush->numsides++;

memset( s2, 0, sizeof( *s2 ) );

s2->planenum = FindFloatPlane( normal, dist, 1, &w->p[ j ] );

s2->contentFlags = buildBrush->sides[0].contentFlags;

s2->bevel = qtrue;

c_edgebevels++;

}

}

}

}

vec3_t adjustment;

char string[128];

/* we have not parsed the brush completely yet... */

GetVectorForKey( ent, "origin", ent->origin );

VectorMA( origin, -1, ent->originbrush_origin, adjustment );

VectorAdd( adjustment, ent->origin, ent->origin );

VectorCopy( origin, ent->originbrush_origin );

sprintf( string, "%f %f %f", ent->origin[0], ent->origin[1], ent->origin[2] );

SetKeyValue( ent, "origin", string );

int bestaxis;

vec_t dot,best;

int i;

best = 0;

bestaxis = 0;

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

{

dot = DotProduct( pln->normal, baseaxis[i * 3] );

if ( dot > best + 0.0001f ) { /* ydnar: bug 637 fix, suggested by jmonroe */

best = dot;

bestaxis = i;

}

}

VectorCopy( baseaxis[bestaxis * 3 + 1], xv );

VectorCopy( baseaxis[bestaxis * 3 + 2], yv );

vec3_t vecs[2];

int sv, tv;

vec_t ang, sinv, cosv;

vec_t ns, nt;

int i, j;

TextureAxisFromPlane( plane, vecs[0], vecs[1] );

if ( !scale[0] ) {

scale[0] = 1;

}

if ( !scale[1] ) {

scale[1] = 1;

}

// rotate axis

if ( rotate == 0 ) {

sinv = 0 ; cosv = 1;

}

else if ( rotate == 90 ) {

sinv = 1 ; cosv = 0;

}

else if ( rotate == 180 ) {

sinv = 0 ; cosv = -1;

}

else if ( rotate == 270 ) {

sinv = -1 ; cosv = 0;

}

else

{

ang = rotate / 180 * Q_PI;

sinv = sin( ang );

cosv = cos( ang );

}

if ( vecs[0][0] ) {

sv = 0;

}

else if ( vecs[0][1] ) {

sv = 1;

}

else{

sv = 2;

}

if ( vecs[1][0] ) {

tv = 0;

}

else if ( vecs[1][1] ) {

tv = 1;

}

else{

tv = 2;

}

for ( i = 0 ; i < 2 ; i++ ) {

ns = cosv * vecs[i][sv] - sinv * vecs[i][tv];

nt = sinv * vecs[i][sv] + cosv * vecs[i][tv];

vecs[i][sv] = ns;

vecs[i][tv] = nt;

}

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

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

mappingVecs[i][j] = vecs[i][j] / scale[i];

mappingVecs[0][3] = shift[0];

mappingVecs[1][3] = shift[1];

side_t *side;

vec3_t planePoints[ 3 ];

int planenum;

shaderInfo_t *si;

vec_t shift[ 2 ];

vec_t rotate = 0;

vec_t scale[ 2 ];