map.c

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code 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.

Quake III Arena source code 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 Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
// map.c

#include "qbsp.h"


int         entitySourceBrushes;        // to track editor brush numbers

int         numMapPatches;

// undefine to make plane finding use linear sort
#define USE_HASHING
#define PLANE_HASHES    1024
plane_t     *planehash[PLANE_HASHES];

plane_t     mapplanes[MAX_MAP_PLANES];
int         nummapplanes;

// as brushes and patches are read in, the shaders are stored out in order
// here, so -onlytextures can just copy them out over the existing shaders
// in the drawSurfaces
char        mapIndexedShaders[MAX_MAP_BRUSHSIDES][MAX_QPATH];
int         numMapIndexedShaders;

vec3_t      map_mins, map_maxs;

entity_t    *mapent;



int     c_boxbevels;
int     c_edgebevels;

int     c_areaportals;
int     c_detail;
int     c_structural;

// brushes are parsed into a temporary array of sides,
// which will have the bevels added and duplicates
// removed before the final brush is allocated
bspbrush_t  *buildBrush;


void TestExpandBrushes (void);
void SetTerrainTextures( void );
void ParseTerrain( void );


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

PLANE FINDING

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


/*
================
PlaneEqual
================
*/
#define NORMAL_EPSILON  0.00001
#define DIST_EPSILON    0.01
qboolean    PlaneEqual (plane_t *p, vec3_t normal, vec_t dist)
{
#if 1
    if (
       fabs(p->normal[0] - normal[0]) < NORMAL_EPSILON
    && fabs(p->normal[1] - normal[1]) < NORMAL_EPSILON
    && fabs(p->normal[2] - normal[2]) < NORMAL_EPSILON
    && fabs(p->dist - dist) < DIST_EPSILON )
        return qtrue;
#else
    if (p->normal[0] == normal[0]
        && p->normal[1] == normal[1]
        && p->normal[2] == normal[2]
        && p->dist == dist)
        return qtrue;
#endif
    return qfalse;
}

/*
================
AddPlaneToHash
================
*/
void    AddPlaneToHash (plane_t *p)
{
    int     hash;

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

    p->hash_chain = planehash[hash];
    planehash[hash] = p;
}

/*
================
CreateNewFloatPlane
================
*/
int CreateNewFloatPlane (vec3_t normal, vec_t dist)
{
    plane_t *p, temp;

    if (VectorLength(normal) < 0.5)
    {
        _printf( "FloatPlane: bad normal\n");
        return -1;
    }

    // create a new plane
    if (nummapplanes+2 > MAX_MAP_PLANES)
        Error ("MAX_MAP_PLANES");

    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;
}

/*
==============
SnapVector
==============
*/
void    SnapVector (vec3_t normal)
{
    int     i;

    for (i=0 ; i<3 ; i++)
    {
        if ( fabs(normal[i] - 1) < NORMAL_EPSILON )
        {
            VectorClear (normal);
            normal[i] = 1;
            break;
        }
        if ( fabs(normal[i] - -1) < NORMAL_EPSILON )
        {
            VectorClear (normal);
            normal[i] = -1;
            break;
        }
    }
}

/*
==============
SnapPlane
==============
*/
void    SnapPlane (vec3_t normal, vec_t *dist)
{
    SnapVector (normal);

    if (fabs(*dist-Q_rint(*dist)) < DIST_EPSILON)
        *dist = Q_rint(*dist);
}

/*
=============
FindFloatPlane

=============
*/
#ifndef USE_HASHING
int     FindFloatPlane (vec3_t normal, vec_t dist)
{
    int     i;
    plane_t *p;

    SnapPlane (normal, &dist);
    for (i=0, p=mapplanes ; i<nummapplanes ; i++, p++)
    {
        if (PlaneEqual (p, normal, dist))
            return i;
    }

    return CreateNewFloatPlane (normal, dist);
}
#else
int     FindFloatPlane (vec3_t normal, vec_t dist)
{
    int     i;
    plane_t *p;
    int     hash, h;

    SnapPlane (normal, &dist);
    hash = (int)fabs(dist) / 8;
    hash &= (PLANE_HASHES-1);

    // search the border bins as well
    for (i=-1 ; i<=1 ; i++)
    {
        h = (hash+i)&(PLANE_HASHES-1);
        for (p = planehash[h] ; p ; p=p->hash_chain)
        {
            if (PlaneEqual (p, normal, dist))
                return p-mapplanes;
        }
    }

    return CreateNewFloatPlane (normal, dist);
}
#endif

/*
================
MapPlaneFromPoints
================
*/
int MapPlaneFromPoints (vec3_t p0, vec3_t p1, vec3_t p2) {
    vec3_t  t1, t2, normal;
    vec_t   dist;

    VectorSubtract (p0, p1, t1);
    VectorSubtract (p2, p1, t2);
    CrossProduct (t1, t2, normal);
    VectorNormalize (normal, normal);

    dist = DotProduct (p0, normal);

    return FindFloatPlane (normal, dist);
}


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

/*
===========
SetBrushContents

The contents on all sides of a brush should be the same
Sets contentsShader, contents, opaque, and detail
===========
*/
void SetBrushContents( bspbrush_t *b ) {
    int         contents, c2;
    side_t      *s;
    int         i;
    qboolean    mixed;
    int         allFlags;

    s = &b->sides[0];
    contents = s->contents;
    b->contentShader = s->shaderInfo;
    mixed = qfalse;

    allFlags = 0;

    for ( i=1 ; i<b->numsides ; i++, s++ ) {
        s = &b->sides[i];

        if ( !s->shaderInfo ) {
            continue;
        }

        c2 = s->contents;
        if (c2 != contents) {
            mixed = qtrue;
        }

        allFlags |= s->surfaceFlags;
    }

    if ( mixed ) {
        qprintf ("Entity %i, Brush %i: mixed face contents\n"
            , b->entitynum, b->brushnum);
    }

    if ( ( contents & CONTENTS_DETAIL ) && ( contents & CONTENTS_STRUCTURAL ) ) {
        _printf ("Entity %i, Brush %i: mixed CONTENTS_DETAIL and CONTENTS_STRUCTURAL\n"
            , num_entities-1, entitySourceBrushes );
        contents &= ~CONTENTS_DETAIL;
    }

    // the fulldetail flag will cause detail brushes to be
    // treated like normal brushes
    if ( fulldetail ) {
        contents &= ~CONTENTS_DETAIL;
    }

    // all translucent brushes that aren't specirically made structural will
    // be detail
    if ( ( contents & CONTENTS_TRANSLUCENT ) && !( contents & CONTENTS_STRUCTURAL ) ) {
        contents |= CONTENTS_DETAIL;
    }

    if ( contents & CONTENTS_DETAIL ) {
        c_detail++;
        b->detail = qtrue;
    } else {
        c_structural++;
        b->detail = qfalse;
    }

    if ( contents & CONTENTS_TRANSLUCENT ) {
        b->opaque = qfalse;
    } else {
        b->opaque = qtrue;
    }

    if ( contents & CONTENTS_AREAPORTAL ) {
        c_areaportals++;
    }

    b->contents = contents;
}


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

/*
=================
AddBrushBevels

Adds any additional planes necessary to allow the brush being
built to be expanded against axial bounding boxes
=================
*/
void AddBrushBevels( void ) {
    int     axis, dir;
    int     i, order;
    side_t  sidetemp;
    side_t  *s;
    vec3_t  normal;
    float   dist;

    //
    // 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++ ) {
                if (mapplanes[s->planenum].normal[axis] == dir)
                    break;
            }

            if (i == buildBrush->numsides )
            {   // add a new side
                if ( buildBrush->numsides == MAX_BUILD_SIDES ) {
                    Error( "MAX_BUILD_SIDES" );
                }
                memset( s, 0, sizeof( *s ) );
                buildBrush->numsides++;
                VectorClear (normal);
                normal[axis] = dir;
                if (dir == 1)
                    dist = buildBrush->maxs[axis];
                else
                    dist = -buildBrush->mins[axis];
                s->planenum = FindFloatPlane (normal, dist);
                s->contents = buildBrush->sides[0].contents;
                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
  } else {
      int           j, k, l;
      float     d;
      winding_t *w, *w2;
      side_t        *s2;
      vec3_t        vec, vec2;

      // test the non-axial plane edges
      // this code tends to cause some problems...
      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.5)
                  continue;
              SnapVector (vec);
              for (k=0 ; k<3 ; k++)
                  if ( vec[k] == -1 || vec[k] == 1)
                      break;    // axial
              if (k != 3)
                  continue; // only test non-axial edges

              // 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.5)
                          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;
                          for (l=0 ; l<w2->numpoints ; l++)
                          {
                              d = DotProduct (w2->p[l], normal) - dist;
                              if (d > 0.1)
                                  break;    // point in front
                          }
                          if (l != w2->numpoints)
                              break;
                      }

                      if (k != buildBrush->numsides)
                          continue; // wasn't part of the outer hull
                      // add this plane
                      if ( buildBrush->numsides == MAX_BUILD_SIDES ) {
                          Error( "MAX_BUILD_SIDES" );
                      }

                      s2 = &buildBrush->sides[buildBrush->numsides];
                      buildBrush->numsides++;
                      memset( s2, 0, sizeof( *s2 ) );

                      s2->planenum = FindFloatPlane (normal, dist);
                      s2->contents = buildBrush->sides[0].contents;
                      s2->bevel = qtrue;
                      c_edgebevels++;
                  }
              }
          }
      }
  }
}

/*
===============
AddBackSides

fog volumes need to have inside faces created
===============
*/
void AddBackSides( void ) {
/*
    bspbrush_t  *b;
    int         i, originalSides;
    side_t      *s;
    side_t      *newSide;

    b = buildBrush;
    originalSides = b->numsides;
    for ( i = 0 ; i < originalSides ; i++ ) {
        s = &b->sides[i];
        if ( !s->shaderInfo ) {
            continue;
        }
        if ( !(s->shaderInfo->contents & CONTENTS_FOG) ) {
            continue;
        }

        // duplicate the up-facing side
        if ( mapplanes[ s->planenum ].normal[2] == 1 ) {
            newSide = &b->sides[ b->numsides ];
            b->numsides++;

            *newSide = *s;
            newSide->backSide = qtrue;
            newSide->planenum = s->planenum ^ 1;    // opposite side
        }
    }
*/
}

/*
===============
FinishBrush

Produces a final brush based on the buildBrush->sides array
and links it to the current entity
===============
*/
bspbrush_t *FinishBrush( void ) {
    bspbrush_t  *b;

    // liquids may need to have extra sides created for back sides
    AddBackSides();

    // create windings for sides and bounds for brush
    if ( !CreateBrushWindings( buildBrush ) ) {
        // don't keep this brush
        return NULL;
    }

    // brushes that will not be visible at all are forced to be detail
    if ( buildBrush->contents & (CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP) )
    {
        buildBrush->detail = qtrue;
        c_detail++;
    }

    //
    // origin brushes are removed, but they set
    // the rotation origin for the rest of the brushes
    // in the entity.  After the entire entity is parsed,
    // the planenums and texinfos will be adjusted for
    // the origin brush
    //
    if ( buildBrush->contents & CONTENTS_ORIGIN )
    {
        char    string[32];
        vec3_t  origin;

        if (num_entities == 1) {
            _printf ("Entity %i, Brush %i: origin brushes not allowed in world\n"
                ,  num_entities - 1, entitySourceBrushes);
            return NULL;
        }

        VectorAdd (buildBrush->mins, buildBrush->maxs, origin);
        VectorScale (origin, 0.5, origin);

        sprintf (string, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2]);
        SetKeyValue (&entities[num_entities - 1], "origin", string);

        VectorCopy (origin, entities[num_entities - 1].origin);

        // don't keep this brush
        return NULL;
    }

    if ( buildBrush->contents & CONTENTS_AREAPORTAL ) {
        if (num_entities != 1) {
            _printf ("Entity %i, Brush %i: areaportals only allowed in world\n"
                ,  num_entities - 1, entitySourceBrushes);
            return NULL;
        }
    }

    AddBrushBevels ();

    // keep it
    b = CopyBrush( buildBrush );

    b->entitynum = num_entities-1;
    b->brushnum = entitySourceBrushes;

    b->original = b;

    b->next = mapent->brushes;
    mapent->brushes = b;

    return b;
}

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


/*
==================
textureAxisFromPlane
==================
*/
vec3_t  baseaxis[18] =
{
{0,0,1}, {1,0,0}, {0,-1,0},         // floor
{0,0,-1}, {1,0,0}, {0,-1,0},        // ceiling
{1,0,0}, {0,1,0}, {0,0,-1},         // west wall
{-1,0,0}, {0,1,0}, {0,0,-1},        // east wall
{0,1,0}, {1,0,0}, {0,0,-1},         // south wall
{0,-1,0}, {1,0,0}, {0,0,-1}         // north wall
};

void TextureAxisFromPlane(plane_t *pln, vec3_t xv, vec3_t yv)
{
    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)
        {
            best = dot;
            bestaxis = i;
        }
    }
    
    VectorCopy (baseaxis[bestaxis*3+1], xv);
    VectorCopy (baseaxis[bestaxis*3+2], yv);
}



/*
=================
QuakeTextureVecs

Creates world-to-texture mapping vecs for crappy quake plane arrangements
=================
*/
void QuakeTextureVecs(  plane_t *plane, vec_t shift[2], vec_t rotate, vec_t scale[2],
                      vec_t mappingVecs[2][4] ) {
 
    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];
}

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

/*
=================
ParseRawBrush

Just parses the sides into buildBrush->sides[], nothing else.
no validation, back plane removal, etc.

Timo - 08/26/99
added brush epairs parsing ( ignoring actually )
Timo - 08/04/99
added exclusive brush primitive parsing
Timo - 08/08/99
support for old brush format back in
NOTE : it would be "cleaner" to have seperate functions to parse between old and new brushes
=================
*/
void    ParseRawBrush( ) {
    side_t      *side;
    vec3_t      planepts[3];
    int         planenum;
    shaderInfo_t    *si;
    // old brushes
    vec_t       shift[2];
    vec_t       rotate;
    vec_t       scale[2];
    char        name[MAX_QPATH];
    char        shader[MAX_QPATH];
    int         flags;

    buildBrush->numsides = 0;
    buildBrush->detail = qfalse;

    if (g_bBrushPrimit==BPRIMIT_NEWBRUSHES)
        MatchToken( "{" );

    do
    {
        if (!GetToken (qtrue))
            break;
        if (!strcmp (token, "}") )
            break;
        //Timo : brush primitive : here we may have to jump over brush epairs ( only used in editor )
        if (g_bBrushPrimit==BPRIMIT_NEWBRUSHES)
        {
            do
            {
                if (strcmp (token, "(") )
                    GetToken( qfalse );
                else
                    break;
                GetToken( qtrue );
            } while (1);
        }
        UnGetToken();

        if ( buildBrush->numsides == MAX_BUILD_SIDES ) {
            Error( "MAX_BUILD_SIDES" );
        }

        side = &buildBrush->sides[ buildBrush->numsides ];
        memset( side, 0, sizeof( *side ) );
        buildBrush->numsides++;

        // read the three point plane definition
        Parse1DMatrix( 3, planepts[0] );
        Parse1DMatrix( 3, planepts[1] );
        Parse1DMatrix( 3, planepts[2] );

        if (g_bBrushPrimit==BPRIMIT_NEWBRUSHES)
            // read the texture matrix
            Parse2DMatrix( 2, 3, (float *)side->texMat );

        // read the texturedef
        GetToken (qfalse);
        strcpy (name, token);

        // save the shader name for retexturing
        if ( numMapIndexedShaders == MAX_MAP_BRUSHSIDES ) {
            Error( "MAX_MAP_BRUSHSIDES" );
        }
        strcpy( mapIndexedShaders[numMapIndexedShaders], name );
        numMapIndexedShaders++;

        if (g_bBrushPrimit==BPRIMIT_OLDBRUSHES)
        {
            GetToken (qfalse);
            shift[0] = atoi(token);
            GetToken (qfalse);
            shift[1] = atoi(token);
            GetToken (qfalse);
            rotate = atoi(token);   
            GetToken (qfalse);
            scale[0] = atof(token);
            GetToken (qfalse);
            scale[1] = atof(token);
        }

        // find default flags and values
        sprintf( shader, "textures/%s", name );
        si = ShaderInfoForShader( shader );
        side->shaderInfo = si;
        side->surfaceFlags = si->surfaceFlags;
        side->value = si->value;
        side->contents = si->contents;

        // allow override of default flags and values
        // in Q3, the only thing you can override is DETAIL
        if (TokenAvailable())
        {
            GetToken (qfalse);
//          side->contents = atoi(token);
            flags = atoi(token);
            if ( flags & CONTENTS_DETAIL ) {
                side->contents |= CONTENTS_DETAIL;
            }

            GetToken (qfalse);
//          td.flags = atoi(token);

            GetToken (qfalse);
//          td.value = atoi(token);
        }


        // find the plane number
        planenum = MapPlaneFromPoints (planepts[0], planepts[1], planepts[2]);
        side->planenum = planenum;

        if (g_bBrushPrimit==BPRIMIT_OLDBRUSHES)
            // get the texture mapping for this texturedef / plane combination
            QuakeTextureVecs( &mapplanes[planenum], shift, rotate, scale, side->vecs );

    } while (1);

    if (g_bBrushPrimit==BPRIMIT_NEWBRUSHES)
    {
        UnGetToken();
        MatchToken( "}" );
        MatchToken( "}" );
    }
}

/*
=================
RemoveDuplicateBrushPlanes

Returns false if the brush has a mirrored set of planes,
meaning it encloses no volume.
Also removes planes without any normal
=================
*/
qboolean RemoveDuplicateBrushPlanes( bspbrush_t * b ) {
    int         i, j, k;
    side_t      *sides;

    sides = b->sides;

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

        // check for a degenerate plane
        if ( sides[i].planenum == -1) {
            _printf ("Entity %i, Brush %i: degenerate plane\n"
                , b->entitynum, b->brushnum);
            // remove it
            for ( k = i + 1 ; k < b->numsides ; k++ ) {
                sides[k-1] = sides[k];
            }
            b->numsides--;
            i--;
            continue;
        }

        // check for duplication and mirroring
        for ( j = 0 ; j < i ; j++ ) {
            if ( sides[i].planenum == sides[j].planenum ) {
                _printf ("Entity %i, Brush %i: duplicate plane\n"
                    , b->entitynum, b->brushnum);
                // remove the second duplicate
                for ( k = i + 1 ; k < b->numsides ; k++ ) {
                    sides[k-1] = sides[k];
                }
                b->numsides--;
                i--;
                break;
            }

            if ( sides[i].planenum == (sides[j].planenum ^ 1) ) {
                // mirror plane, brush is invalid
                _printf ("Entity %i, Brush %i: mirrored plane\n"
                    , b->entitynum, b->brushnum);
                return qfalse;
            }
        }
    }
    return qtrue;
}


/*
=================
ParseBrush

  qboolean parameter to true -> parse new brush primitive format ( else use old format )
=================
*/
void ParseBrush (void) {
    bspbrush_t  *b;

    ParseRawBrush();

    buildBrush->portalareas[0] = -1;
    buildBrush->portalareas[1] = -1;
    buildBrush->entitynum = num_entities-1;
    buildBrush->brushnum = entitySourceBrushes;

    // if there are mirrored planes, the entire brush is invalid
    if ( !RemoveDuplicateBrushPlanes( buildBrush ) ) {
        return;
    }

    // get the content for the entire brush
    SetBrushContents( buildBrush );

    // allow detail brushes to be removed 
    if (nodetail && (buildBrush->contents & CONTENTS_DETAIL) ) {
        FreeBrush( buildBrush );
        return;
    }

    // allow water brushes to be removed
    if (nowater && (buildBrush->contents & (CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_WATER)) ) {
        FreeBrush( buildBrush );
        return;
    }

    b = FinishBrush( );
    if ( !b ) {
        return;
    }
}


/*
================
MoveBrushesToWorld

Takes all of the brushes from the current entity and
adds them to the world's brush list.

Used by func_group
================
*/
void MoveBrushesToWorld (entity_t *mapent) {
    bspbrush_t  *b, *next;
    parseMesh_t *pm;

    // move brushes
    for ( b = mapent->brushes ; b ; b = next ) {
        next = b->next;

        b->next = entities[0].brushes;
        entities[0].brushes = b;
    }
    mapent->brushes = NULL;

    // move patches
    if ( mapent->patches ) {

        for ( pm = mapent->patches ; pm->next ; pm = pm->next ) {
        }

        pm->next = entities[0].patches;
        entities[0].patches = mapent->patches;

        mapent->patches = NULL;
    }
}


/*
================
AdjustBrushesForOrigin
================
*/
void AdjustBrushesForOrigin( entity_t *ent ) {
    bspbrush_t  *b;
    int         i;
    side_t      *s;
    vec_t       newdist;
    parseMesh_t *p;

    for ( b = ent->brushes ; b ; b = b->next ) {
        for (i=0 ; i<b->numsides ; i++) {
            s = &b->sides[i];
            newdist = mapplanes[s->planenum].dist -
                DotProduct (mapplanes[s->planenum].normal, ent->origin);
            s->planenum = FindFloatPlane (mapplanes[s->planenum].normal, newdist);
        }
        CreateBrushWindings(b);
    }

    for ( p = ent->patches ; p ; p = p->next ) {
        for ( i = 0 ; i < p->mesh.width*p->mesh.height ; i++ ) {
            VectorSubtract( p->mesh.verts[i].xyz, ent->origin, p->mesh.verts[i].xyz );
        }
    }

}

/*
================
ParseMapEntity
================
*/
qboolean    ParseMapEntity (void) {
    epair_t     *e;

    if (!GetToken (qtrue))
        return qfalse;

    if (strcmp (token, "{") )
    {
        Error ("ParseEntity: { not found, found %s on line %d - last entity was at: <%4.2f, %4.2f, %4.2f>...", token, scriptline, entities[num_entities].origin[0], entities[num_entities].origin[1], entities[num_entities].origin[2]);
    }
    
    if (num_entities == MAX_MAP_ENTITIES)
        Error ("num_entities == MAX_MAP_ENTITIES");

    entitySourceBrushes = 0;

    mapent = &entities[num_entities];
    num_entities++;
    memset (mapent, 0, sizeof(*mapent));

    do
    {
        if (!GetToken (qtrue))
            Error ("ParseEntity: EOF without closing brace");
        if (!strcmp (token, "}") )
            break;

        if (!strcmp (token, "{") ) {
            // parse a brush or patch
            if (!GetToken (qtrue))
                break;
            if ( !strcmp( token, "patchDef2" ) ) {
                numMapPatches++;
                ParsePatch();
            } else if ( !strcmp( token, "terrainDef" ) ) {
                ParseTerrain();
            } else if ( !strcmp( token, "brushDef" ) ) {
                if (g_bBrushPrimit==BPRIMIT_OLDBRUSHES)
                    Error("old brush format not allowed in new brush format map");
                g_bBrushPrimit=BPRIMIT_NEWBRUSHES;
                // parse brush primitive
                ParseBrush();
            }
            else
            {
                if (g_bBrushPrimit==BPRIMIT_NEWBRUSHES)
                    Error("new brush format not allowed in old brush format map");
                g_bBrushPrimit=BPRIMIT_OLDBRUSHES;
                // parse old brush format
                UnGetToken();
                ParseBrush();
            }
            entitySourceBrushes++;
        }
        else
        {
            // parse a key / value pair
            e = ParseEpair ();
            e->next = mapent->epairs;
            mapent->epairs = e;
        }
    } while (1);

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

    //
    // if there was an origin brush, offset all of the planes and texinfo
    // for all the brushes in the entity
    if (mapent->origin[0] || mapent->origin[1] || mapent->origin[2]) {
        AdjustBrushesForOrigin( mapent );
    }

  // group_info entities are just for editor grouping
  // ignored
  // FIXME: leak!
  if (!strcmp("group_info", ValueForKey (mapent, "classname")))
  {
    num_entities--;
    return qtrue;
  }

    // group entities are just for editor convenience
    // toss all brushes into the world entity
    if (!strcmp ("func_group", ValueForKey (mapent, "classname")))
    {
        if ( !strcmp ("1", ValueForKey (mapent, "terrain"))) {
            SetTerrainTextures();
        }
        MoveBrushesToWorld (mapent);
        num_entities--;
        return qtrue;
    }

    return qtrue;
}

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


/*
================
LoadMapFile
================
*/
void LoadMapFile (char *filename) {     
    bspbrush_t  *b;

    qprintf ("--- LoadMapFile ---\n");
    _printf ("Loading map file %s\n", filename);

    LoadScriptFile (filename);

    num_entities = 0;
    numMapDrawSurfs = 0;
    c_detail = 0;

    g_bBrushPrimit = BPRIMIT_UNDEFINED;

    // allocate a very large temporary brush for building
    // the brushes as they are loaded
    buildBrush = AllocBrush( MAX_BUILD_SIDES );

    while (ParseMapEntity ())
    {
    }

    ClearBounds (map_mins, map_maxs);
    for ( b = entities[0].brushes ; b ; b=b->next ) {
        AddPointToBounds( b->mins, map_mins, map_maxs );
        AddPointToBounds( b->maxs, map_mins, map_maxs );
    }

    qprintf ("%5i total world brushes\n", CountBrushList( entities[0].brushes ) );
    qprintf ("%5i detail brushes\n", c_detail );
    qprintf ("%5i patches\n", numMapPatches);
    qprintf ("%5i boxbevels\n", c_boxbevels);
    qprintf ("%5i edgebevels\n", c_edgebevels);
    qprintf ("%5i entities\n", num_entities);
    qprintf ("%5i planes\n", nummapplanes);
    qprintf ("%5i areaportals\n", c_areaportals);
    qprintf ("size: %5.0f,%5.0f,%5.0f to %5.0f,%5.0f,%5.0f\n", map_mins[0],map_mins[1],map_mins[2],
        map_maxs[0],map_maxs[1],map_maxs[2]);

    if ( fakemap ) {
        WriteBspBrushMap ("fakemap.map", entities[0].brushes );
    }

    if ( testExpand ) {
        TestExpandBrushes ();
    }
}


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


/*
================
TestExpandBrushes

Expands all the brush planes and saves a new map out to
allow visual inspection of the clipping bevels
================
*/
void TestExpandBrushes( void ) {
    side_t  *s;
    int     i, j;
    bspbrush_t  *brush, *list, *copy;
    vec_t   dist;
    plane_t     *plane;

    list = NULL;

    for ( brush = entities[0].brushes ; brush ; brush = brush->next ) {
        copy = CopyBrush( brush );
        copy->next = list;
        list = copy;

        // expand all the planes
        for ( i=0 ; i<brush->numsides ; i++ ) {
            s = brush->sides + i;
            plane = &mapplanes[s->planenum];
            dist = plane->dist;
            for (j=0 ; j<3 ; j++) {
                dist += fabs( 16 * plane->normal[j] );
            }
            s->planenum = FindFloatPlane( plane->normal, dist );
        }

    }

    WriteBspBrushMap ( "expanded.map", entities[0].brushes );

    Error ("can't proceed after expanding brushes");
}

---