mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2025-02-28 22:51:25 +00:00
1845 lines
32 KiB
C++
1845 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 "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( 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()
|
|
{
|
|
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()
|
|
{
|
|
if( winding )
|
|
{
|
|
delete winding;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushSide::Copy
|
|
============
|
|
*/
|
|
idBrushSide* idBrushSide::Copy() 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()
|
|
{
|
|
contents = flags = 0;
|
|
bounds.Clear();
|
|
sides.Clear();
|
|
windingsValid = false;
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idBrush::~idBrush
|
|
============
|
|
*/
|
|
idBrush::~idBrush()
|
|
{
|
|
for( int i = 0; i < sides.Num(); i++ )
|
|
{
|
|
delete sides[i];
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrush::RemoveSidesWithoutWinding
|
|
============
|
|
*/
|
|
bool idBrush::RemoveSidesWithoutWinding()
|
|
{
|
|
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()
|
|
{
|
|
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() 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()
|
|
{
|
|
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() 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()
|
|
{
|
|
numBrushes = numBrushSides = 0;
|
|
head = tail = NULL;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::~idBrushList
|
|
============
|
|
*/
|
|
idBrushList::~idBrushList()
|
|
{
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBrushList::GetBounds
|
|
============
|
|
*/
|
|
idBounds idBrushList::GetBounds() 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() 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()
|
|
{
|
|
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()
|
|
{
|
|
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 );
|
|
}
|
|
}
|