mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-24 05:11:21 +00:00
1582 lines
32 KiB
C++
1582 lines
32 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 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 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 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 Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "../../../idlib/precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "Brush.h"
|
|
|
|
#define BRUSH_EPSILON 0.1f
|
|
#define BRUSH_PLANE_NORMAL_EPSILON 0.00001f
|
|
#define BRUSH_PLANE_DIST_EPSILON 0.01f
|
|
|
|
#define OUTPUT_UPDATE_TIME 500 // update every 500 msec
|
|
|
|
//#define OUTPUT_CHOP_STATS
|
|
|
|
/*
|
|
============
|
|
DisplayRealTimeString
|
|
============
|
|
*/
|
|
void DisplayRealTimeString( const char *string, ... ) {
|
|
va_list argPtr;
|
|
char buf[MAX_STRING_CHARS];
|
|
static int lastUpdateTime;
|
|
int time;
|
|
|
|
time = Sys_Milliseconds();
|
|
if ( time > lastUpdateTime + OUTPUT_UPDATE_TIME ) {
|
|
va_start( argPtr, string );
|
|
vsprintf( buf, string, argPtr );
|
|
va_end( argPtr );
|
|
common->Printf( buf );
|
|
lastUpdateTime = time;
|
|
}
|
|
}
|
|
|
|
|
|
//===============================================================
|
|
//
|
|
// idBrushSide
|
|
//
|
|
//===============================================================
|
|
|
|
/*
|
|
============
|
|
idBrushSide::idBrushSide
|
|
============
|
|
*/
|
|
idBrushSide::idBrushSide( void ) {
|
|
flags = 0;
|
|
planeNum = -1;
|
|
winding = NULL;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushSide::idBrushSide
|
|
============
|
|
*/
|
|
idBrushSide::idBrushSide( const idPlane &plane, int planeNum ) {
|
|
this->flags = 0;
|
|
this->plane = plane;
|
|
this->planeNum = planeNum;
|
|
this->winding = NULL;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushSide::~idBrushSide
|
|
============
|
|
*/
|
|
idBrushSide::~idBrushSide( void ) {
|
|
if ( winding ) {
|
|
delete winding;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushSide::Copy
|
|
============
|
|
*/
|
|
idBrushSide *idBrushSide::Copy( void ) const {
|
|
idBrushSide *side;
|
|
|
|
side = new idBrushSide( plane, planeNum );
|
|
side->flags = flags;
|
|
if ( winding ) {
|
|
side->winding = winding->Copy();
|
|
}
|
|
else {
|
|
side->winding = NULL;
|
|
}
|
|
return side;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushSide::Split
|
|
============
|
|
*/
|
|
int idBrushSide::Split( const idPlane &splitPlane, idBrushSide **front, idBrushSide **back ) const {
|
|
idWinding *frontWinding, *backWinding;
|
|
|
|
assert( winding );
|
|
|
|
*front = *back = NULL;
|
|
|
|
winding->Split( splitPlane, 0.0f, &frontWinding, &backWinding );
|
|
|
|
if ( frontWinding ) {
|
|
(*front) = new idBrushSide( plane, planeNum );
|
|
(*front)->winding = frontWinding;
|
|
(*front)->flags = flags;
|
|
}
|
|
|
|
if ( backWinding ) {
|
|
(*back) = new idBrushSide( plane, planeNum );
|
|
(*back)->winding = backWinding;
|
|
(*back)->flags = flags;
|
|
}
|
|
|
|
if ( frontWinding && backWinding ) {
|
|
return PLANESIDE_CROSS;
|
|
}
|
|
else if ( frontWinding ) {
|
|
return PLANESIDE_FRONT;
|
|
}
|
|
else {
|
|
return PLANESIDE_BACK;
|
|
}
|
|
}
|
|
|
|
|
|
//===============================================================
|
|
//
|
|
// idBrushSide
|
|
//
|
|
//===============================================================
|
|
|
|
/*
|
|
============
|
|
idBrush::idBrush
|
|
============
|
|
*/
|
|
idBrush::idBrush( void ) {
|
|
contents = flags = 0;
|
|
bounds.Clear();
|
|
sides.Clear();
|
|
windingsValid = false;
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idBrush::~idBrush
|
|
============
|
|
*/
|
|
idBrush::~idBrush( void ) {
|
|
for ( int i = 0; i < sides.Num(); i++ ) {
|
|
delete sides[i];
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::RemoveSidesWithoutWinding
|
|
============
|
|
*/
|
|
bool idBrush::RemoveSidesWithoutWinding( void ) {
|
|
int i;
|
|
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
|
|
if ( sides[i]->winding ) {
|
|
continue;
|
|
}
|
|
|
|
sides.RemoveIndex( i );
|
|
i--;
|
|
}
|
|
|
|
return ( sides.Num() >= 4 );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::CreateWindings
|
|
============
|
|
*/
|
|
bool idBrush::CreateWindings( void ) {
|
|
int i, j;
|
|
idBrushSide *side;
|
|
|
|
bounds.Clear();
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
side = sides[i];
|
|
|
|
if ( side->winding ) {
|
|
delete side->winding;
|
|
}
|
|
|
|
side->winding = new idWinding( side->plane.Normal(), side->plane.Dist() );
|
|
|
|
for ( j = 0; j < sides.Num() && side->winding; j++ ) {
|
|
if ( i == j ) {
|
|
continue;
|
|
}
|
|
// keep the winding if on the clip plane
|
|
side->winding = side->winding->Clip( -sides[j]->plane, BRUSH_EPSILON, true );
|
|
}
|
|
|
|
if ( side->winding ) {
|
|
for ( j = 0; j < side->winding->GetNumPoints(); j++ ) {
|
|
bounds.AddPoint( (*side->winding)[j].ToVec3() );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bounds[0][0] > bounds[1][0] ) {
|
|
return false;
|
|
}
|
|
for ( i = 0; i < 3; i++ ) {
|
|
if ( bounds[0][i] < MIN_WORLD_COORD || bounds[1][i] > MAX_WORLD_COORD ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
windingsValid = true;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::BoundBrush
|
|
============
|
|
*/
|
|
void idBrush::BoundBrush( const idBrush *original ) {
|
|
int i, j;
|
|
idBrushSide *side;
|
|
idWinding *w;
|
|
|
|
assert( windingsValid );
|
|
|
|
bounds.Clear();
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
side = sides[i];
|
|
|
|
w = side->winding;
|
|
|
|
if ( !w ) {
|
|
continue;
|
|
}
|
|
|
|
for ( j = 0; j < w->GetNumPoints(); j++ ) {
|
|
bounds.AddPoint( (*w)[j].ToVec3() );
|
|
}
|
|
}
|
|
|
|
if ( bounds[0][0] > bounds[1][0] ) {
|
|
if ( original ) {
|
|
idBrushMap *bm = new idBrushMap( "error_brush", "_original" );
|
|
bm->WriteBrush( original );
|
|
delete bm;
|
|
}
|
|
common->Error( "idBrush::BoundBrush: brush %d on entity %d without windings", primitiveNum, entityNum );
|
|
}
|
|
|
|
for ( i = 0; i < 3; i++ ) {
|
|
if ( bounds[0][i] < MIN_WORLD_COORD || bounds[1][i] > MAX_WORLD_COORD ) {
|
|
if ( original ) {
|
|
idBrushMap *bm = new idBrushMap( "error_brush", "_original" );
|
|
bm->WriteBrush( original );
|
|
delete bm;
|
|
}
|
|
common->Error( "idBrush::BoundBrush: brush %d on entity %d is unbounded", primitiveNum, entityNum );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::FromSides
|
|
============
|
|
*/
|
|
bool idBrush::FromSides( idList<idBrushSide *> &sideList ) {
|
|
int i;
|
|
|
|
for ( i = 0; i < sideList.Num(); i++ ) {
|
|
sides.Append( sideList[i] );
|
|
}
|
|
|
|
sideList.Clear();
|
|
|
|
return CreateWindings();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::FromWinding
|
|
============
|
|
*/
|
|
bool idBrush::FromWinding( const idWinding &w, const idPlane &windingPlane ) {
|
|
int i, j, bestAxis;
|
|
idPlane plane;
|
|
idVec3 normal, axialNormal;
|
|
|
|
sides.Append( new idBrushSide( windingPlane, -1 ) );
|
|
sides.Append( new idBrushSide( -windingPlane, -1 ) );
|
|
|
|
bestAxis = 0;
|
|
for ( i = 1; i < 3; i++ ) {
|
|
if ( idMath::Fabs( windingPlane.Normal()[i] ) > idMath::Fabs( windingPlane.Normal()[bestAxis] ) ) {
|
|
bestAxis = i;
|
|
}
|
|
}
|
|
axialNormal = vec3_origin;
|
|
if ( windingPlane.Normal()[bestAxis] > 0.0f ) {
|
|
axialNormal[bestAxis] = 1.0f;
|
|
}
|
|
else {
|
|
axialNormal[bestAxis] = -1.0f;
|
|
}
|
|
|
|
for ( i = 0; i < w.GetNumPoints(); i++ ) {
|
|
j = (i+1) % w.GetNumPoints();
|
|
normal = ( w[j].ToVec3() - w[i].ToVec3() ).Cross( axialNormal );
|
|
if ( normal.Normalize() < 0.5f ) {
|
|
continue;
|
|
}
|
|
plane.SetNormal( normal );
|
|
plane.FitThroughPoint( w[j].ToVec3() );
|
|
sides.Append( new idBrushSide( plane, -1 ) );
|
|
}
|
|
|
|
if ( sides.Num() < 4 ) {
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
delete sides[i];
|
|
}
|
|
sides.Clear();
|
|
return false;
|
|
}
|
|
|
|
sides[0]->winding = w.Copy();
|
|
windingsValid = true;
|
|
BoundBrush();
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::FromBounds
|
|
============
|
|
*/
|
|
bool idBrush::FromBounds( const idBounds &bounds ) {
|
|
int axis, dir;
|
|
idVec3 normal;
|
|
idPlane plane;
|
|
|
|
for ( axis = 0; axis < 3; axis++ ) {
|
|
for ( dir = -1; dir <= 1; dir += 2 ) {
|
|
normal = vec3_origin;
|
|
normal[axis] = dir;
|
|
plane.SetNormal( normal );
|
|
plane.SetDist( dir * bounds[(dir == 1)][axis] );
|
|
sides.Append( new idBrushSide( plane, -1 ) );
|
|
}
|
|
}
|
|
|
|
return CreateWindings();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::Transform
|
|
============
|
|
*/
|
|
void idBrush::Transform( const idVec3 &origin, const idMat3 &axis ) {
|
|
int i;
|
|
bool transformed = false;
|
|
|
|
if ( axis.IsRotated() ) {
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
sides[i]->plane.RotateSelf( vec3_origin, axis );
|
|
}
|
|
transformed = true;
|
|
}
|
|
if ( origin != vec3_origin ) {
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
sides[i]->plane.TranslateSelf( origin );
|
|
}
|
|
transformed = true;
|
|
}
|
|
if ( transformed ) {
|
|
CreateWindings();
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::GetVolume
|
|
============
|
|
*/
|
|
float idBrush::GetVolume( void ) const {
|
|
int i;
|
|
idWinding *w;
|
|
idVec3 corner;
|
|
float d, area, volume;
|
|
|
|
// grab the first valid point as a corner
|
|
w = NULL;
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
w = sides[i]->winding;
|
|
if ( w ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( !w ) {
|
|
return 0.0f;
|
|
}
|
|
corner = (*w)[0].ToVec3();
|
|
|
|
// create tetrahedrons to all other sides
|
|
volume = 0.0f;
|
|
for ( ; i < sides.Num(); i++) {
|
|
w = sides[i]->winding;
|
|
if ( !w ) {
|
|
continue;
|
|
}
|
|
d = -( corner * sides[i]->plane.Normal() - sides[i]->plane.Dist() );
|
|
area = w->GetArea();
|
|
volume += d * area;
|
|
}
|
|
|
|
return ( volume * ( 1.0f / 3.0f ) );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::Subtract
|
|
============
|
|
*/
|
|
bool idBrush::Subtract( const idBrush *b, idBrushList &list ) const {
|
|
int i;
|
|
idBrush *front, *back;
|
|
const idBrush *in;
|
|
|
|
list.Clear();
|
|
in = this;
|
|
for ( i = 0; i < b->sides.Num() && in; i++ ) {
|
|
|
|
in->Split( b->sides[i]->plane, b->sides[i]->planeNum, &front, &back );
|
|
|
|
if ( in != this ) {
|
|
delete in;
|
|
}
|
|
if ( front ) {
|
|
list.AddToTail( front );
|
|
}
|
|
in = back;
|
|
}
|
|
// if didn't really intersect
|
|
if ( !in ) {
|
|
list.Free();
|
|
return false;
|
|
}
|
|
|
|
delete in;
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::TryMerge
|
|
============
|
|
*/
|
|
bool idBrush::TryMerge( const idBrush *brush, const idPlaneSet &planeList ) {
|
|
int i, j, k, l, m, seperatingPlane;
|
|
const idBrush *brushes[2];
|
|
const idWinding *w;
|
|
const idPlane *plane;
|
|
|
|
// brush bounds should overlap
|
|
for ( i = 0; i < 3; i++ ) {
|
|
if ( bounds[0][i] > brush->bounds[1][i] + 0.1f ) {
|
|
return false;
|
|
}
|
|
if ( bounds[1][i] < brush->bounds[0][i] - 0.1f ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// the brushes should share an opposite plane
|
|
seperatingPlane = -1;
|
|
for ( i = 0; i < GetNumSides(); i++ ) {
|
|
for ( j = 0; j < brush->GetNumSides(); j++ ) {
|
|
if ( GetSide(i)->GetPlaneNum() == (brush->GetSide(j)->GetPlaneNum() ^ 1) ) {
|
|
// may only have one seperating plane
|
|
if ( seperatingPlane != -1 ) {
|
|
return false;
|
|
}
|
|
seperatingPlane = GetSide(i)->GetPlaneNum();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if ( seperatingPlane == -1 ) {
|
|
return false;
|
|
}
|
|
|
|
brushes[0] = this;
|
|
brushes[1] = brush;
|
|
|
|
for ( i = 0; i < 2; i++ ) {
|
|
|
|
j = !i;
|
|
|
|
for ( k = 0; k < brushes[i]->GetNumSides(); k++ ) {
|
|
|
|
// if the brush side plane is the seprating plane
|
|
if ( !( ( brushes[i]->GetSide(k)->GetPlaneNum() ^ seperatingPlane ) >> 1 ) ) {
|
|
continue;
|
|
}
|
|
|
|
plane = &brushes[i]->GetSide(k)->GetPlane();
|
|
|
|
// all the non seperating brush sides of the other brush should be at the back or on the plane
|
|
for ( l = 0; l < brushes[j]->GetNumSides(); l++ ) {
|
|
|
|
w = brushes[j]->GetSide(l)->GetWinding();
|
|
if ( !w ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !( ( brushes[j]->GetSide(l)->GetPlaneNum() ^ seperatingPlane ) >> 1 ) ) {
|
|
continue;
|
|
}
|
|
|
|
for ( m = 0; m < w->GetNumPoints(); m++ ) {
|
|
if ( plane->Distance( (*w)[m].ToVec3() ) > 0.1f ) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// add any sides from the other brush to this brush
|
|
for ( i = 0; i < brush->GetNumSides(); i++ ) {
|
|
for ( j = 0; j < GetNumSides(); j++ ) {
|
|
if ( !( ( brush->GetSide(i)->GetPlaneNum() ^ GetSide(j)->GetPlaneNum() ) >> 1 ) ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( j < GetNumSides() ) {
|
|
sides[j]->flags &= brush->GetSide(i)->GetFlags();
|
|
continue;
|
|
}
|
|
sides.Append( brush->GetSide(i)->Copy() );
|
|
}
|
|
|
|
// remove any side from this brush that is the opposite of a side of the other brush
|
|
for ( i = 0; i < GetNumSides(); i++ ) {
|
|
for ( j = 0; j < brush->GetNumSides(); j++ ) {
|
|
if ( GetSide(i)->GetPlaneNum() == ( brush->GetSide(j)->GetPlaneNum() ^ 1 ) ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( j < brush->GetNumSides() ) {
|
|
delete sides[i];
|
|
sides.RemoveIndex(i);
|
|
i--;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
contents |= brush->contents;
|
|
|
|
CreateWindings();
|
|
BoundBrush();
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::Split
|
|
============
|
|
*/
|
|
int idBrush::Split( const idPlane &plane, int planeNum, idBrush **front, idBrush **back ) const {
|
|
int res, i, j;
|
|
idBrushSide *side, *frontSide, *backSide;
|
|
float dist, maxBack, maxFront, *maxBackWinding, *maxFrontWinding;
|
|
idWinding *w, *mid;
|
|
|
|
assert( windingsValid );
|
|
|
|
if ( front ) {
|
|
*front = NULL;
|
|
}
|
|
if ( back ) {
|
|
*back = NULL;
|
|
}
|
|
|
|
res = bounds.PlaneSide( plane, -BRUSH_EPSILON );
|
|
if ( res == PLANESIDE_FRONT ) {
|
|
if ( front ) {
|
|
*front = Copy();
|
|
}
|
|
return res;
|
|
}
|
|
if ( res == PLANESIDE_BACK ) {
|
|
if ( back ) {
|
|
*back = Copy();
|
|
}
|
|
return res;
|
|
}
|
|
|
|
maxBackWinding = (float *) _alloca16( sides.Num() * sizeof(float) );
|
|
maxFrontWinding = (float *) _alloca16( sides.Num() * sizeof(float) );
|
|
|
|
maxFront = maxBack = 0.0f;
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
side = sides[i];
|
|
|
|
w = side->winding;
|
|
|
|
if ( !w ) {
|
|
continue;
|
|
}
|
|
|
|
maxBackWinding[i] = 10.0f;
|
|
maxFrontWinding[i] = -10.0f;
|
|
|
|
for ( j = 0; j < w->GetNumPoints(); j++ ) {
|
|
|
|
dist = plane.Distance( (*w)[j].ToVec3() );
|
|
if ( dist > maxFrontWinding[i] ) {
|
|
maxFrontWinding[i] = dist;
|
|
}
|
|
if ( dist < maxBackWinding[i] ) {
|
|
maxBackWinding[i] = dist;
|
|
}
|
|
}
|
|
|
|
if ( maxFrontWinding[i] > maxFront ) {
|
|
maxFront = maxFrontWinding[i];
|
|
}
|
|
if ( maxBackWinding[i] < maxBack ) {
|
|
maxBack = maxBackWinding[i];
|
|
}
|
|
}
|
|
|
|
if ( maxFront < BRUSH_EPSILON ) {
|
|
if ( back ) {
|
|
*back = Copy();
|
|
}
|
|
return PLANESIDE_BACK;
|
|
}
|
|
|
|
if ( maxBack > -BRUSH_EPSILON ) {
|
|
if ( front ) {
|
|
*front = Copy();
|
|
}
|
|
return PLANESIDE_FRONT;
|
|
}
|
|
|
|
mid = new idWinding( plane.Normal(), plane.Dist() );
|
|
|
|
for ( i = 0; i < sides.Num() && mid; i++ ) {
|
|
mid = mid->Clip( -sides[i]->plane, BRUSH_EPSILON, false );
|
|
}
|
|
|
|
if ( mid ) {
|
|
if ( mid->IsTiny() ) {
|
|
delete mid;
|
|
mid = NULL;
|
|
}
|
|
else if ( mid->IsHuge() ) {
|
|
// if the winding is huge then the brush is unbounded
|
|
common->Warning( "brush %d on entity %d is unbounded"
|
|
"( %1.2f %1.2f %1.2f )-( %1.2f %1.2f %1.2f )-( %1.2f %1.2f %1.2f )", primitiveNum, entityNum,
|
|
bounds[0][0], bounds[0][1], bounds[0][2], bounds[1][0], bounds[1][1], bounds[1][2],
|
|
bounds[1][0]-bounds[0][0], bounds[1][1]-bounds[0][1], bounds[1][2]-bounds[0][2] );
|
|
delete mid;
|
|
mid = NULL;
|
|
}
|
|
}
|
|
|
|
if ( !mid ) {
|
|
if ( maxFront > - maxBack ) {
|
|
if ( front ) {
|
|
*front = Copy();
|
|
}
|
|
return PLANESIDE_FRONT;
|
|
}
|
|
else {
|
|
if ( back ) {
|
|
*back = Copy();
|
|
}
|
|
return PLANESIDE_BACK;
|
|
}
|
|
}
|
|
|
|
if ( !front && !back ) {
|
|
delete mid;
|
|
return PLANESIDE_CROSS;
|
|
}
|
|
|
|
*front = new idBrush();
|
|
(*front)->SetContents( contents );
|
|
(*front)->SetEntityNum( entityNum );
|
|
(*front)->SetPrimitiveNum( primitiveNum );
|
|
*back = new idBrush();
|
|
(*back)->SetContents( contents );
|
|
(*back)->SetEntityNum( entityNum );
|
|
(*back)->SetPrimitiveNum( primitiveNum );
|
|
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
side = sides[i];
|
|
|
|
if ( !side->winding ) {
|
|
continue;
|
|
}
|
|
|
|
// if completely at the front
|
|
if ( maxBackWinding[i] >= BRUSH_EPSILON ) {
|
|
(*front)->sides.Append( side->Copy() );
|
|
}
|
|
// if completely at the back
|
|
else if ( maxFrontWinding[i] <= -BRUSH_EPSILON ) {
|
|
(*back)->sides.Append( side->Copy() );
|
|
}
|
|
else {
|
|
// split the side
|
|
side->Split( plane, &frontSide, &backSide );
|
|
if ( frontSide ) {
|
|
(*front)->sides.Append( frontSide );
|
|
}
|
|
else if ( maxFrontWinding[i] > -BRUSH_EPSILON ) {
|
|
// favor an overconstrained brush
|
|
side = side->Copy();
|
|
side->winding = side->winding->Clip( idPlane( plane.Normal(), (plane.Dist() - (BRUSH_EPSILON+0.02f)) ), 0.01f, true );
|
|
assert( side->winding );
|
|
(*front)->sides.Append( side );
|
|
}
|
|
if ( backSide ) {
|
|
(*back)->sides.Append( backSide );
|
|
}
|
|
else if ( maxBackWinding[i] < BRUSH_EPSILON ) {
|
|
// favor an overconstrained brush
|
|
side = side->Copy();
|
|
side->winding = side->winding->Clip( idPlane( -plane.Normal(), -(plane.Dist() + (BRUSH_EPSILON+0.02f)) ), 0.01f, true );
|
|
assert( side->winding );
|
|
(*back)->sides.Append( side );
|
|
}
|
|
}
|
|
}
|
|
|
|
side = new idBrushSide( -plane, planeNum^1 );
|
|
side->winding = mid->Reverse();
|
|
side->flags |= SFL_SPLIT;
|
|
(*front)->sides.Append( side );
|
|
(*front)->windingsValid = true;
|
|
(*front)->BoundBrush( this );
|
|
|
|
side = new idBrushSide( plane, planeNum );
|
|
side->winding = mid;
|
|
side->flags |= SFL_SPLIT;
|
|
(*back)->sides.Append( side );
|
|
(*back)->windingsValid = true;
|
|
(*back)->BoundBrush( this );
|
|
|
|
return PLANESIDE_CROSS;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::AddBevelsForAxialBox
|
|
============
|
|
*/
|
|
#define BRUSH_BEVEL_EPSILON 0.1f
|
|
|
|
void idBrush::AddBevelsForAxialBox( void ) {
|
|
int axis, dir, i, j, k, l, order;
|
|
idBrushSide *side, *newSide;
|
|
idPlane plane;
|
|
idVec3 normal, vec;
|
|
idWinding *w, *w2;
|
|
float d, minBack;
|
|
|
|
assert( windingsValid );
|
|
|
|
// 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 already present
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
if ( dir > 0 ) {
|
|
if ( sides[i]->plane.Normal()[axis] >= 0.9999f ) {
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
if ( sides[i]->plane.Normal()[axis] <= -0.9999f ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( i >= sides.Num() ) {
|
|
normal = vec3_origin;
|
|
normal[axis] = dir;
|
|
plane.SetNormal( normal );
|
|
plane.SetDist( dir * bounds[(dir == 1)][axis] );
|
|
newSide = new idBrushSide( plane, -1 );
|
|
newSide->SetFlag( SFL_BEVEL );
|
|
sides.Append( newSide );
|
|
}
|
|
}
|
|
}
|
|
|
|
// if the brush is pure axial we're done
|
|
if ( sides.Num() == 6 ) {
|
|
return;
|
|
}
|
|
|
|
// test the non-axial plane edges
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
side = sides[i];
|
|
w = side->winding;
|
|
if ( !w ) {
|
|
continue;
|
|
}
|
|
|
|
for ( j = 0; j < w->GetNumPoints(); j++) {
|
|
k = (j+1) % w->GetNumPoints();
|
|
vec = (*w)[j].ToVec3() - (*w)[k].ToVec3();
|
|
if ( vec.Normalize() < 0.5f ) {
|
|
continue;
|
|
}
|
|
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
|
|
}
|
|
|
|
// 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
|
|
normal = vec3_origin;
|
|
normal[axis] = dir;
|
|
normal = vec.Cross( normal );
|
|
if ( normal.Normalize() < 0.5f ) {
|
|
continue;
|
|
}
|
|
plane.SetNormal( normal );
|
|
plane.FitThroughPoint( (*w)[j].ToVec3() );
|
|
|
|
// if all the points on all the sides are
|
|
// behind this plane, it is a proper edge bevel
|
|
for ( k = 0; k < sides.Num(); k++ ) {
|
|
|
|
// if this plane has allready been used, skip it
|
|
if ( plane.Compare( sides[k]->plane, 0.001f, 0.1f ) ) {
|
|
break;
|
|
}
|
|
|
|
w2 = sides[k]->winding;
|
|
if ( !w2 ) {
|
|
continue;
|
|
}
|
|
minBack = 0.0f;
|
|
for ( l = 0; l < w2->GetNumPoints(); l++ ) {
|
|
d = plane.Distance( (*w2)[l].ToVec3() );
|
|
if ( d > BRUSH_BEVEL_EPSILON ) {
|
|
break; // point at the front
|
|
}
|
|
if ( d < minBack ) {
|
|
minBack = d;
|
|
}
|
|
}
|
|
// if some point was at the front
|
|
if ( l < w2->GetNumPoints() ) {
|
|
break;
|
|
}
|
|
// if no points at the back then the winding is on the bevel plane
|
|
if ( minBack > -BRUSH_BEVEL_EPSILON ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( k < sides.Num() ) {
|
|
continue; // wasn't part of the outer hull
|
|
}
|
|
|
|
// add this plane
|
|
newSide = new idBrushSide( plane, -1 );
|
|
newSide->SetFlag( SFL_BEVEL );
|
|
sides.Append( newSide );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::ExpandForAxialBox
|
|
============
|
|
*/
|
|
void idBrush::ExpandForAxialBox( const idBounds &bounds ) {
|
|
int i, j;
|
|
idBrushSide *side;
|
|
idVec3 v;
|
|
|
|
AddBevelsForAxialBox();
|
|
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
side = sides[i];
|
|
|
|
for ( j = 0; j < 3; j++ ) {
|
|
if ( side->plane.Normal()[j] > 0.0f ) {
|
|
v[j] = bounds[0][j];
|
|
}
|
|
else {
|
|
v[j] = bounds[1][j];
|
|
}
|
|
}
|
|
|
|
side->plane.SetDist( side->plane.Dist() + v * -side->plane.Normal() );
|
|
}
|
|
|
|
if ( !CreateWindings() ) {
|
|
common->Error( "idBrush::ExpandForAxialBox: brush %d on entity %d imploded", primitiveNum, entityNum );
|
|
}
|
|
|
|
/*
|
|
// after expansion at least all non bevel sides should have a winding
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
side = sides[i];
|
|
if ( !side->winding ) {
|
|
if ( !( side->flags & SFL_BEVEL ) ) {
|
|
int shit = 1;
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::Copy
|
|
============
|
|
*/
|
|
idBrush *idBrush::Copy( void ) const {
|
|
int i;
|
|
idBrush *b;
|
|
|
|
b = new idBrush();
|
|
b->entityNum = entityNum;
|
|
b->primitiveNum = primitiveNum;
|
|
b->contents = contents;
|
|
b->windingsValid = windingsValid;
|
|
b->bounds = bounds;
|
|
for ( i = 0; i < sides.Num(); i++ ) {
|
|
b->sides.Append( sides[i]->Copy() );
|
|
}
|
|
return b;
|
|
}
|
|
|
|
|
|
//===============================================================
|
|
//
|
|
// idBrushList
|
|
//
|
|
//===============================================================
|
|
|
|
/*
|
|
============
|
|
idBrushList::idBrushList
|
|
============
|
|
*/
|
|
idBrushList::idBrushList( void ) {
|
|
numBrushes = numBrushSides = 0;
|
|
head = tail = NULL;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::~idBrushList
|
|
============
|
|
*/
|
|
idBrushList::~idBrushList( void ) {
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::GetBounds
|
|
============
|
|
*/
|
|
idBounds idBrushList::GetBounds( void ) const {
|
|
idBounds bounds;
|
|
idBrush *b;
|
|
|
|
bounds.Clear();
|
|
for ( b = Head(); b; b = b->Next() ) {
|
|
bounds += b->GetBounds();
|
|
}
|
|
return bounds;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::AddToTail
|
|
============
|
|
*/
|
|
void idBrushList::AddToTail( idBrush *brush ) {
|
|
brush->next = NULL;
|
|
if ( tail ) {
|
|
tail->next = brush;
|
|
}
|
|
tail = brush;
|
|
if ( !head ) {
|
|
head = brush;
|
|
}
|
|
numBrushes++;
|
|
numBrushSides += brush->sides.Num();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::AddToTail
|
|
============
|
|
*/
|
|
void idBrushList::AddToTail( idBrushList &list ) {
|
|
idBrush *brush, *next;
|
|
|
|
for ( brush = list.head; brush; brush = next ) {
|
|
next = brush->next;
|
|
brush->next = NULL;
|
|
if ( tail ) {
|
|
tail->next = brush;
|
|
}
|
|
tail = brush;
|
|
if ( !head ) {
|
|
head = brush;
|
|
}
|
|
numBrushes++;
|
|
numBrushSides += brush->sides.Num();
|
|
}
|
|
list.head = list.tail = NULL;
|
|
list.numBrushes = 0;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::AddToFront
|
|
============
|
|
*/
|
|
void idBrushList::AddToFront( idBrush *brush ) {
|
|
brush->next = head;
|
|
head = brush;
|
|
if ( !tail ) {
|
|
tail = brush;
|
|
}
|
|
numBrushes++;
|
|
numBrushSides += brush->sides.Num();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::AddToFront
|
|
============
|
|
*/
|
|
void idBrushList::AddToFront( idBrushList &list ) {
|
|
idBrush *brush, *next;
|
|
|
|
for ( brush = list.head; brush; brush = next ) {
|
|
next = brush->next;
|
|
brush->next = head;
|
|
head = brush;
|
|
if ( !tail ) {
|
|
tail = brush;
|
|
}
|
|
numBrushes++;
|
|
numBrushSides += brush->sides.Num();
|
|
}
|
|
list.head = list.tail = NULL;
|
|
list.numBrushes = 0;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::Remove
|
|
============
|
|
*/
|
|
void idBrushList::Remove( idBrush *brush ) {
|
|
idBrush *b, *last;
|
|
|
|
last = NULL;
|
|
for ( b = head; b; b = b->next ) {
|
|
if ( b == brush ) {
|
|
if ( last ) {
|
|
last->next = b->next;
|
|
}
|
|
else {
|
|
head = b->next;
|
|
}
|
|
if ( b == tail ) {
|
|
tail = last;
|
|
}
|
|
numBrushes--;
|
|
numBrushSides -= brush->sides.Num();
|
|
return;
|
|
}
|
|
last = b;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::Delete
|
|
============
|
|
*/
|
|
void idBrushList::Delete( idBrush *brush ) {
|
|
idBrush *b, *last;
|
|
|
|
last = NULL;
|
|
for ( b = head; b; b = b->next ) {
|
|
if ( b == brush ) {
|
|
if ( last ) {
|
|
last->next = b->next;
|
|
}
|
|
else {
|
|
head = b->next;
|
|
}
|
|
if ( b == tail ) {
|
|
tail = last;
|
|
}
|
|
numBrushes--;
|
|
numBrushSides -= b->sides.Num();
|
|
delete b;
|
|
return;
|
|
}
|
|
last = b;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::Copy
|
|
============
|
|
*/
|
|
idBrushList *idBrushList::Copy( void ) const {
|
|
idBrush *brush;
|
|
idBrushList *list;
|
|
|
|
list = new idBrushList;
|
|
|
|
for ( brush = head; brush; brush = brush->next ) {
|
|
list->AddToTail( brush->Copy() );
|
|
}
|
|
return list;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::Free
|
|
============
|
|
*/
|
|
void idBrushList::Free( void ) {
|
|
idBrush *brush, *next;
|
|
|
|
for ( brush = head; brush; brush = next ) {
|
|
next = brush->next;
|
|
delete brush;
|
|
}
|
|
head = tail = NULL;
|
|
numBrushes = numBrushSides = 0;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::Split
|
|
============
|
|
*/
|
|
void idBrushList::Split( const idPlane &plane, int planeNum, idBrushList &frontList, idBrushList &backList, bool useBrushSavedPlaneSide ) {
|
|
idBrush *b, *front, *back;
|
|
|
|
frontList.Clear();
|
|
backList.Clear();
|
|
|
|
if ( !useBrushSavedPlaneSide ) {
|
|
for ( b = head; b; b = b->next ) {
|
|
b->Split( plane, planeNum, &front, &back );
|
|
if ( front ) {
|
|
frontList.AddToTail( front );
|
|
}
|
|
if ( back ) {
|
|
backList.AddToTail( back );
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
for ( b = head; b; b = b->next ) {
|
|
if ( b->savedPlaneSide & BRUSH_PLANESIDE_BOTH ) {
|
|
b->Split( plane, planeNum, &front, &back );
|
|
if ( front ) {
|
|
frontList.AddToTail( front );
|
|
}
|
|
if ( back ) {
|
|
backList.AddToTail( back );
|
|
}
|
|
}
|
|
else if ( b->savedPlaneSide & BRUSH_PLANESIDE_FRONT ) {
|
|
frontList.AddToTail( b->Copy() );
|
|
}
|
|
else {
|
|
backList.AddToTail( b->Copy() );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::Chop
|
|
============
|
|
*/
|
|
void idBrushList::Chop( bool (*ChopAllowed)( idBrush *b1, idBrush *b2 ) ) {
|
|
idBrush *b1, *b2, *next;
|
|
idBrushList sub1, sub2, keep;
|
|
int i, j, c1, c2;
|
|
idPlaneSet planeList;
|
|
|
|
#ifdef OUTPUT_CHOP_STATS
|
|
common->Printf( "[Brush CSG]\n");
|
|
common->Printf( "%6d original brushes\n", this->Num() );
|
|
#endif
|
|
|
|
CreatePlaneList( planeList );
|
|
|
|
for ( b1 = this->Head(); b1; b1 = this->Head() ) {
|
|
|
|
for ( b2 = b1->next; b2; b2 = next ) {
|
|
|
|
next = b2->next;
|
|
|
|
for ( i = 0; i < 3; i++ ) {
|
|
if ( b1->bounds[0][i] >= b2->bounds[1][i] ) {
|
|
break;
|
|
}
|
|
if ( b1->bounds[1][i] <= b2->bounds[0][i] ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( i < 3 ) {
|
|
continue;
|
|
}
|
|
|
|
for ( i = 0; i < b1->GetNumSides(); i++ ) {
|
|
for ( j = 0; j < b2->GetNumSides(); j++ ) {
|
|
if ( b1->GetSide(i)->GetPlaneNum() == ( b2->GetSide(j)->GetPlaneNum() ^ 1 ) ) {
|
|
// opposite planes, so not touching
|
|
break;
|
|
}
|
|
}
|
|
if ( j < b2->GetNumSides() ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( i < b1->GetNumSides() ) {
|
|
continue;
|
|
}
|
|
|
|
sub1.Clear();
|
|
sub2.Clear();
|
|
|
|
c1 = 999999;
|
|
c2 = 999999;
|
|
|
|
// if b2 may chop up b1
|
|
if ( !ChopAllowed || ChopAllowed( b2, b1 ) ) {
|
|
if ( !b1->Subtract( b2, sub1 ) ) {
|
|
// didn't really intersect
|
|
continue;
|
|
}
|
|
if ( sub1.IsEmpty() ) {
|
|
// b1 is swallowed by b2
|
|
this->Delete( b1 );
|
|
break;
|
|
}
|
|
c1 = sub1.Num();
|
|
}
|
|
|
|
// if b1 may chop up b2
|
|
if ( !ChopAllowed || ChopAllowed( b1, b2 ) ) {
|
|
if ( !b2->Subtract( b1, sub2 ) ) {
|
|
// didn't really intersect
|
|
continue;
|
|
}
|
|
if ( sub2.IsEmpty() ) {
|
|
// b2 is swallowed by b1
|
|
sub1.Free();
|
|
this->Delete( b2 );
|
|
continue;
|
|
}
|
|
c2 = sub2.Num();
|
|
}
|
|
|
|
if ( sub1.IsEmpty() && sub2.IsEmpty() ) {
|
|
continue;
|
|
}
|
|
|
|
// don't allow too much fragmentation
|
|
if ( c1 > 2 && c2 > 2 ) {
|
|
sub1.Free();
|
|
sub2.Free();
|
|
continue;
|
|
}
|
|
|
|
if ( c1 < c2 ) {
|
|
sub2.Free();
|
|
this->AddToTail( sub1 );
|
|
this->Delete( b1 );
|
|
break;
|
|
}
|
|
else {
|
|
sub1.Free();
|
|
this->AddToTail( sub2 );
|
|
this->Delete( b2 );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( !b2 ) {
|
|
// b1 is no longer intersecting anything, so keep it
|
|
this->Remove( b1 );
|
|
keep.AddToTail( b1 );
|
|
#ifdef OUTPUT_CHOP_STATS
|
|
DisplayRealTimeString( "\r%6d", keep.numBrushes );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
*this = keep;
|
|
|
|
#ifdef OUTPUT_CHOP_STATS
|
|
common->Printf( "\r%6d output brushes\n", Num() );
|
|
#endif
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idBrushList::Merge
|
|
============
|
|
*/
|
|
void idBrushList::Merge( bool (*MergeAllowed)( idBrush *b1, idBrush *b2 ) ) {
|
|
idPlaneSet planeList;
|
|
idBrush *b1, *b2, *nextb2;
|
|
int numMerges;
|
|
|
|
common->Printf( "[Brush Merge]\n");
|
|
common->Printf( "%6d original brushes\n", Num() );
|
|
|
|
CreatePlaneList( planeList );
|
|
|
|
numMerges = 0;
|
|
for ( b1 = Head(); b1; b1 = b1->next ) {
|
|
|
|
for ( b2 = Head(); b2; b2 = nextb2 ) {
|
|
nextb2 = b2->Next();
|
|
|
|
if ( b2 == b1 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( MergeAllowed && !MergeAllowed( b1, b2 ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( b1->TryMerge( b2, planeList ) ) {
|
|
Delete( b2 );
|
|
DisplayRealTimeString( "\r%6d", ++numMerges );
|
|
nextb2 = Head();
|
|
}
|
|
}
|
|
}
|
|
|
|
common->Printf( "\r%6d brushes merged\n", numMerges );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::SetFlagOnFacingBrushSides
|
|
============
|
|
*/
|
|
void idBrushList::SetFlagOnFacingBrushSides( const idPlane &plane, int flag ) {
|
|
int i;
|
|
idBrush *b;
|
|
const idWinding *w;
|
|
|
|
for ( b = head; b; b = b->next ) {
|
|
if ( idMath::Fabs( b->GetBounds().PlaneDistance( plane ) ) > 0.1f ) {
|
|
continue;
|
|
}
|
|
for ( i = 0; i < b->GetNumSides(); i++ ) {
|
|
w = b->GetSide(i)->GetWinding();
|
|
if ( !w ) {
|
|
if ( b->GetSide(i)->GetPlane().Compare( plane, BRUSH_PLANE_NORMAL_EPSILON, BRUSH_PLANE_DIST_EPSILON ) ) {
|
|
b->GetSide(i)->SetFlag( flag );
|
|
}
|
|
continue;
|
|
}
|
|
if ( w->PlaneSide( plane ) == SIDE_ON ) {
|
|
b->GetSide(i)->SetFlag( flag );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::CreatePlaneList
|
|
============
|
|
*/
|
|
void idBrushList::CreatePlaneList( idPlaneSet &planeList ) const {
|
|
int i;
|
|
idBrush *b;
|
|
idBrushSide *side;
|
|
|
|
planeList.Resize( 512, 128 );
|
|
for ( b = Head(); b; b = b->Next() ) {
|
|
for ( i = 0; i < b->GetNumSides(); i++ ) {
|
|
side = b->GetSide( i );
|
|
side->SetPlaneNum( planeList.FindPlane( side->GetPlane(), BRUSH_PLANE_NORMAL_EPSILON, BRUSH_PLANE_DIST_EPSILON ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::CreatePlaneList
|
|
============
|
|
*/
|
|
void idBrushList::WriteBrushMap( const idStr &fileName, const idStr &ext ) const {
|
|
idBrushMap *map;
|
|
|
|
map = new idBrushMap( fileName, ext );
|
|
map->WriteBrushList( *this );
|
|
delete map;
|
|
}
|
|
|
|
|
|
//===============================================================
|
|
//
|
|
// idBrushMap
|
|
//
|
|
//===============================================================
|
|
|
|
/*
|
|
============
|
|
idBrushMap::idBrushMap
|
|
============
|
|
*/
|
|
idBrushMap::idBrushMap( const idStr &fileName, const idStr &ext ) {
|
|
idStr qpath;
|
|
|
|
qpath = fileName;
|
|
qpath.StripFileExtension();
|
|
qpath += ext;
|
|
qpath.SetFileExtension( "map" );
|
|
|
|
common->Printf( "writing %s...\n", qpath.c_str() );
|
|
|
|
fp = fileSystem->OpenFileWrite( qpath, "fs_devpath" );
|
|
if ( !fp ) {
|
|
common->Error( "Couldn't open %s\n", qpath.c_str() );
|
|
return;
|
|
}
|
|
|
|
texture = "textures/washroom/btile01";
|
|
|
|
fp->WriteFloatString( "Version %1.2f\n", (float) CURRENT_MAP_VERSION );
|
|
fp->WriteFloatString( "{\n" );
|
|
fp->WriteFloatString( "\"classname\" \"worldspawn\"\n" );
|
|
|
|
brushCount = 0;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushMap::~idBrushMap
|
|
============
|
|
*/
|
|
idBrushMap::~idBrushMap( void ) {
|
|
if ( !fp ) {
|
|
return;
|
|
}
|
|
fp->WriteFloatString( "}\n" );
|
|
fileSystem->CloseFile( fp );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushMap::WriteBrush
|
|
============
|
|
*/
|
|
void idBrushMap::WriteBrush( const idBrush *brush ) {
|
|
int i;
|
|
idBrushSide *side;
|
|
|
|
if ( !fp ) {
|
|
return;
|
|
}
|
|
|
|
fp->WriteFloatString( "// primitive %d\n{\nbrushDef3\n{\n", brushCount++ );
|
|
|
|
for ( i = 0; i < brush->GetNumSides(); i++ ) {
|
|
side = brush->GetSide( i );
|
|
fp->WriteFloatString( " ( %f %f %f %f ) ", side->GetPlane()[0], side->GetPlane()[1], side->GetPlane()[2], -side->GetPlane().Dist() );
|
|
fp->WriteFloatString( "( ( 0.031250 0 0 ) ( 0 0.031250 0 ) ) %s 0 0 0\n", texture.c_str() );
|
|
|
|
}
|
|
fp->WriteFloatString( "}\n}\n" );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushMap::WriteBrushList
|
|
============
|
|
*/
|
|
void idBrushMap::WriteBrushList( const idBrushList &brushList ) {
|
|
idBrush *b;
|
|
|
|
if ( !fp ) {
|
|
return;
|
|
}
|
|
|
|
for ( b = brushList.Head(); b; b = b->Next() ) {
|
|
WriteBrush( b );
|
|
}
|
|
}
|