Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

784 lines
19 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
#include "vbsp.h"
/*
tag all brushes with original contents
brushes may contain multiple contents
there will be no brush overlap after csg phase
each side has a count of the other sides it splits
the best split will be the one that minimizes the total split counts
of all remaining sides
precalc side on plane table
evaluate split side
{
cost = 0
for all sides
for all sides
get
if side splits side and splitside is on same child
cost++;
}
*/
void SplitBrush2( bspbrush_t *brush, int planenum, bspbrush_t **front, bspbrush_t **back )
{
SplitBrush( brush, planenum, front, back );
#if 0
if (*front && (*front)->sides[(*front)->numsides-1].texinfo == -1)
(*front)->sides[(*front)->numsides-1].texinfo = (*front)->sides[0].texinfo; // not -1
if (*back && (*back)->sides[(*back)->numsides-1].texinfo == -1)
(*back)->sides[(*back)->numsides-1].texinfo = (*back)->sides[0].texinfo; // not -1
#endif
}
/*
===============
SubtractBrush
Returns a list of brushes that remain after B is subtracted from A.
May by empty if A is contained inside B.
The originals are undisturbed.
===============
*/
bspbrush_t *SubtractBrush (bspbrush_t *a, bspbrush_t *b)
{ // a - b = out (list)
int i;
bspbrush_t *front, *back;
bspbrush_t *out, *in;
in = a;
out = NULL;
for (i=0 ; i<b->numsides && in ; i++)
{
SplitBrush2 (in, b->sides[i].planenum, &front, &back);
if (in != a)
FreeBrush (in);
if (front)
{ // add to list
front->next = out;
out = front;
}
in = back;
}
if (in)
FreeBrush (in);
else
{ // didn't really intersect
FreeBrushList (out);
return a;
}
return out;
}
/*
===============
IntersectBrush
Returns a single brush made up by the intersection of the
two provided brushes, or NULL if they are disjoint.
The originals are undisturbed.
===============
*/
bspbrush_t *IntersectBrush (bspbrush_t *a, bspbrush_t *b)
{
int i;
bspbrush_t *front, *back;
bspbrush_t *in;
in = a;
for (i=0 ; i<b->numsides && in ; i++)
{
SplitBrush2 (in, b->sides[i].planenum, &front, &back);
if (in != a)
FreeBrush (in);
if (front)
FreeBrush (front);
in = back;
}
if (in == a || !in)
return NULL;
in->next = NULL;
return in;
}
/*
===============
BrushesDisjoint
Returns true if the two brushes definately do not intersect.
There will be false negatives for some non-axial combinations.
===============
*/
qboolean BrushesDisjoint (bspbrush_t *a, bspbrush_t *b)
{
int i, j;
// check bounding boxes
for (i=0 ; i<3 ; i++)
if (a->mins[i] >= b->maxs[i]
|| a->maxs[i] <= b->mins[i])
return true; // bounding boxes don't overlap
// check for opposing planes
for (i=0 ; i<a->numsides ; i++)
{
for (j=0 ; j<b->numsides ; j++)
{
if (a->sides[i].planenum ==
(b->sides[j].planenum^1) )
return true; // opposite planes, so not touching
}
}
return false; // might intersect
}
int minplanenums[3];
int maxplanenums[3];
/*
===============
ClipBrushToBox
Any planes shared with the box edge will be set to no texinfo
===============
*/
bspbrush_t *ClipBrushToBox (bspbrush_t *brush, const Vector& clipmins, const Vector& clipmaxs)
{
int i, j;
bspbrush_t *front, *back;
int p;
for (j=0 ; j<2 ; j++)
{
if (brush->maxs[j] > clipmaxs[j])
{
SplitBrush (brush, maxplanenums[j], &front, &back);
if (front)
FreeBrush (front);
brush = back;
if (!brush)
return NULL;
}
if (brush->mins[j] < clipmins[j])
{
SplitBrush (brush, minplanenums[j], &front, &back);
if (back)
FreeBrush (back);
brush = front;
if (!brush)
return NULL;
}
}
// remove any colinear faces
for (i=0 ; i<brush->numsides ; i++)
{
p = brush->sides[i].planenum & ~1;
if (p == maxplanenums[0] || p == maxplanenums[1]
|| p == minplanenums[0] || p == minplanenums[1])
{
brush->sides[i].texinfo = TEXINFO_NODE;
brush->sides[i].visible = false;
}
}
return brush;
}
//-----------------------------------------------------------------------------
// Creates a clipped brush from a map brush
//-----------------------------------------------------------------------------
static bspbrush_t *CreateClippedBrush( mapbrush_t *mb, const Vector& clipmins, const Vector& clipmaxs )
{
int nNumSides = mb->numsides;
if (!nNumSides)
return NULL;
// if the brush is outside the clip area, skip it
for (int j=0 ; j<3 ; j++)
{
if (mb->mins[j] >= clipmaxs[j] || mb->maxs[j] <= clipmins[j])
{
return NULL;
}
}
// make a copy of the brush
bspbrush_t *newbrush = AllocBrush( nNumSides );
newbrush->original = mb;
newbrush->numsides = nNumSides;
memcpy (newbrush->sides, mb->original_sides, nNumSides*sizeof(side_t));
for (int j=0 ; j<nNumSides; j++)
{
if (newbrush->sides[j].winding)
{
newbrush->sides[j].winding = CopyWinding (newbrush->sides[j].winding);
}
if (newbrush->sides[j].surf & SURF_HINT)
{
newbrush->sides[j].visible = true; // hints are always visible
}
// keep a pointer to the original map brush side -- use to create the original face later!!
//newbrush->sides[j].original = &mb->original_sides[j];
}
VectorCopy (mb->mins, newbrush->mins);
VectorCopy (mb->maxs, newbrush->maxs);
// carve off anything outside the clip box
newbrush = ClipBrushToBox (newbrush, clipmins, clipmaxs);
return newbrush;
}
//-----------------------------------------------------------------------------
// Creates a clipped brush from a map brush
//-----------------------------------------------------------------------------
static void ComputeBoundingPlanes( const Vector& clipmins, const Vector& clipmaxs )
{
Vector normal;
float dist;
for (int i=0 ; i<2 ; i++)
{
VectorClear (normal);
normal[i] = 1;
dist = clipmaxs[i];
maxplanenums[i] = g_MainMap->FindFloatPlane (normal, dist);
dist = clipmins[i];
minplanenums[i] = g_MainMap->FindFloatPlane (normal, dist);
}
}
//-----------------------------------------------------------------------------
// This forces copies of texinfo data for matching sides of a brush
//-----------------------------------------------------------------------------
void CopyMatchingTexinfos( side_t *pDestSides, int numDestSides, const bspbrush_t *pSource )
{
for ( int i = 0; i < numDestSides; i++ )
{
side_t *pSide = &pDestSides[i];
plane_t *pPlane = &g_MainMap->mapplanes[pSide->planenum];
// We have to use the *original sides* because MapBSPBrushList could have generated
// splits when cutting the original brush to the block being processed. This
// will generate faces that use TEXINFO_NODE, which is definitely *not* what we want.
// If we end up with faces using TEXINFO_NODE here, the area portal will flood into
// the entire water volume intersecting the areaportal.
mapbrush_t *pSourceBrush = pSource->original;
Assert( pSourceBrush );
const side_t *pSourceSide = pSourceBrush->original_sides;
const side_t *pBestSide = NULL;
float flBestDot = -1.0f;
for ( int j = 0; j < pSourceBrush->numsides; ++j, ++pSourceSide )
{
if ( pSourceSide->texinfo == TEXINFO_NODE )
continue;
plane_t *pSourcePlane = &g_MainMap->mapplanes[pSourceSide->planenum];
float flDot = DotProduct( pPlane->normal, pSourcePlane->normal );
if ( flDot == 1.0f || pSide->planenum == pSourceSide->planenum )
{
pBestSide = pSourceSide;
break;
}
else if ( flDot > flBestDot )
{
pBestSide = pSourceSide;
flBestDot = flDot;
}
}
if ( pBestSide )
{
pSide->texinfo = pBestSide->texinfo;
if ( pSide->original )
{
pSide->original->texinfo = pSide->texinfo;
}
}
else
{
texinfo_t *pTexInfo = &texinfo[pSide->texinfo];
dtexdata_t *pTexData = GetTexData( pTexInfo->texdata );
Msg("Found no matching plane for %s\n", TexDataStringTable_GetString( pTexData->nameStringTableID ) );
}
}
}
// This is a hack to allow areaportals to work in water
// It was done this way for ease of implementation.
// This searches a brush list to find intersecting areaportals and water
// If an areaportal is found inside water, then the water contents and
// texture information is copied over to the areaportal so that the
// resulting space has the same properties as the water (normal areaportals assume "empty" surroundings)
void FixupAreaportalWaterBrushes( bspbrush_t *pList )
{
for ( bspbrush_t *pAreaportal = pList; pAreaportal; pAreaportal = pAreaportal->next )
{
if ( !(pAreaportal->original->contents & CONTENTS_AREAPORTAL) )
continue;
for ( bspbrush_t *pWater = pList; pWater; pWater = pWater->next )
{
// avoid using areaportal/water combo brushes that have already been fixed up
if ( pWater->original->contents & CONTENTS_AREAPORTAL )
continue;
if ( !(pWater->original->contents & MASK_SPLITAREAPORTAL) )
continue;
if ( BrushesDisjoint( pAreaportal, pWater ) )
continue;
bspbrush_t *pIntersect = IntersectBrush( pAreaportal, pWater );
if ( !pIntersect )
continue;
FreeBrush( pIntersect );
pAreaportal->original->contents |= pWater->original->contents;
// HACKHACK: Ideally, this should have been done before the bspbrush_t was
// created from the map brush. But since it hasn't been, retexture the original map
// brush's sides
CopyMatchingTexinfos( pAreaportal->sides, pAreaportal->numsides, pWater );
CopyMatchingTexinfos( pAreaportal->original->original_sides, pAreaportal->original->numsides, pWater );
}
}
}
//-----------------------------------------------------------------------------
// MakeBspBrushList
//-----------------------------------------------------------------------------
// UNDONE: Put detail brushes in a separate brush array and pass that instead of "onlyDetail" ?
bspbrush_t *MakeBspBrushList (int startbrush, int endbrush, const Vector& clipmins, const Vector& clipmaxs, int detailScreen)
{
ComputeBoundingPlanes( clipmins, clipmaxs );
bspbrush_t *pBrushList = NULL;
int i;
for (i=startbrush ; i<endbrush ; i++)
{
mapbrush_t *mb = &g_MainMap->mapbrushes[i];
if ( detailScreen != FULL_DETAIL )
{
bool onlyDetail = (detailScreen == ONLY_DETAIL);
bool detail = (mb->contents & CONTENTS_DETAIL) != 0;
if ( onlyDetail ^ detail )
{
// both of these must have the same value or we're not interested in this brush
continue;
}
}
bspbrush_t *pNewBrush = CreateClippedBrush( mb, clipmins, clipmaxs );
if ( pNewBrush )
{
pNewBrush->next = pBrushList;
pBrushList = pNewBrush;
}
}
return pBrushList;
}
//-----------------------------------------------------------------------------
// A version which uses a passed-in list of brushes
//-----------------------------------------------------------------------------
bspbrush_t *MakeBspBrushList (mapbrush_t **pBrushes, int nBrushCount, const Vector& clipmins, const Vector& clipmaxs)
{
ComputeBoundingPlanes( clipmins, clipmaxs );
bspbrush_t *pBrushList = NULL;
for ( int i=0; i < nBrushCount; ++i )
{
bspbrush_t *pNewBrush = CreateClippedBrush( pBrushes[i], clipmins, clipmaxs );
if ( pNewBrush )
{
pNewBrush->next = pBrushList;
pBrushList = pNewBrush;
}
}
return pBrushList;
}
/*
===============
AddBspBrushListToTail
===============
*/
bspbrush_t *AddBrushListToTail (bspbrush_t *list, bspbrush_t *tail)
{
bspbrush_t *walk, *next;
for (walk=list ; walk ; walk=next)
{ // add to end of list
next = walk->next;
walk->next = NULL;
tail->next = walk;
tail = walk;
}
return tail;
}
/*
===========
CullList
Builds a new list that doesn't hold the given brush
===========
*/
bspbrush_t *CullList (bspbrush_t *list, bspbrush_t *skip1)
{
bspbrush_t *newlist;
bspbrush_t *next;
newlist = NULL;
for ( ; list ; list = next)
{
next = list->next;
if (list == skip1)
{
FreeBrush (list);
continue;
}
list->next = newlist;
newlist = list;
}
return newlist;
}
/*
==================
WriteBrushMap
==================
*/
void WriteBrushMap (char *name, bspbrush_t *list)
{
FILE *f;
side_t *s;
int i;
winding_t *w;
Msg("writing %s\n", name);
f = fopen (name, "w");
if (!f)
Error ("Can't write %s\b", name);
fprintf (f, "{\n\"classname\" \"worldspawn\"\n");
for ( ; list ; list=list->next )
{
fprintf (f, "{\n");
for (i=0,s=list->sides ; i<list->numsides ; i++,s++)
{
w = BaseWindingForPlane (g_MainMap->mapplanes[s->planenum].normal, g_MainMap->mapplanes[s->planenum].dist);
fprintf (f,"( %i %i %i ) ", (int)w->p[0][0], (int)w->p[0][1], (int)w->p[0][2]);
fprintf (f,"( %i %i %i ) ", (int)w->p[1][0], (int)w->p[1][1], (int)w->p[1][2]);
fprintf (f,"( %i %i %i ) ", (int)w->p[2][0], (int)w->p[2][1], (int)w->p[2][2]);
fprintf (f, "%s 0 0 0 1 1\n", TexDataStringTable_GetString( GetTexData( texinfo[s->texinfo].texdata )->nameStringTableID ) );
FreeWinding (w);
}
fprintf (f, "}\n");
}
fprintf (f, "}\n");
fclose (f);
}
// UNDONE: This isn't quite working yet
#if 0
void WriteBrushVMF(char *name, bspbrush_t *list)
{
FILE *f;
side_t *s;
int i;
winding_t *w;
Vector u, v;
Msg("writing %s\n", name);
f = fopen (name, "w");
if (!f)
Error ("Can't write %s\b", name);
fprintf (f, "world\n{\n\"classname\" \"worldspawn\"\n");
for ( ; list ; list=list->next )
{
fprintf (f, "\tsolid\n\t{\n");
for (i=0,s=list->sides ; i<list->numsides ; i++,s++)
{
fprintf( f, "\t\tside\n\t\t{\n" );
fprintf( f, "\t\t\t\"plane\" \"" );
w = BaseWindingForPlane (mapplanes[s->planenum].normal, mapplanes[s->planenum].dist);
fprintf (f,"(%i %i %i) ", (int)w->p[0][0], (int)w->p[0][1], (int)w->p[0][2]);
fprintf (f,"(%i %i %i) ", (int)w->p[1][0], (int)w->p[1][1], (int)w->p[1][2]);
fprintf (f,"(%i %i %i)", (int)w->p[2][0], (int)w->p[2][1], (int)w->p[2][2]);
fprintf( f, "\"\n" );
fprintf( f, "\t\t\t\"material\" \"%s\"\n", GetTexData( texinfo[s->texinfo].texdata )->name );
// UNDONE: recreate correct texture axes
BasisForPlane( mapplanes[s->planenum].normal, u, v );
fprintf( f, "\t\t\t\"uaxis\" \"[%.3f %.3f %.3f 0] 1.0\"\n", u[0], u[1], u[2] );
fprintf( f, "\t\t\t\"vaxis\" \"[%.3f %.3f %.3f 0] 1.0\"\n", v[0], v[1], v[2] );
fprintf( f, "\t\t\t\"rotation\" \"0.0\"\n" );
fprintf( f, "\t\t\t\"lightmapscale\" \"16.0\"\n" );
FreeWinding (w);
fprintf (f, "\t\t}\n");
}
fprintf (f, "\t}\n");
}
fprintf (f, "}\n");
fclose (f);
}
#endif
void PrintBrushContentsToString( int contents, char *pOut, int nMaxChars )
{
#define ADD_CONTENTS( flag ) \
if ( contents & flag ) \
Q_strncat( pOut, #flag " ", nMaxChars, COPY_ALL_CHARACTERS );
pOut[0] = 0;
ADD_CONTENTS(CONTENTS_SOLID)
ADD_CONTENTS(CONTENTS_WINDOW)
ADD_CONTENTS(CONTENTS_AUX)
ADD_CONTENTS(CONTENTS_GRATE)
ADD_CONTENTS(CONTENTS_SLIME)
ADD_CONTENTS(CONTENTS_WATER)
ADD_CONTENTS(CONTENTS_BLOCKLOS)
ADD_CONTENTS(CONTENTS_OPAQUE)
ADD_CONTENTS(CONTENTS_TESTFOGVOLUME)
ADD_CONTENTS(CONTENTS_MOVEABLE)
ADD_CONTENTS(CONTENTS_AREAPORTAL)
ADD_CONTENTS(CONTENTS_PLAYERCLIP)
ADD_CONTENTS(CONTENTS_MONSTERCLIP)
ADD_CONTENTS(CONTENTS_CURRENT_0)
ADD_CONTENTS(CONTENTS_CURRENT_90)
ADD_CONTENTS(CONTENTS_CURRENT_180)
ADD_CONTENTS(CONTENTS_CURRENT_270)
ADD_CONTENTS(CONTENTS_CURRENT_UP)
ADD_CONTENTS(CONTENTS_CURRENT_DOWN)
ADD_CONTENTS(CONTENTS_ORIGIN)
ADD_CONTENTS(CONTENTS_MONSTER)
ADD_CONTENTS(CONTENTS_DEBRIS)
ADD_CONTENTS(CONTENTS_DETAIL)
ADD_CONTENTS(CONTENTS_TRANSLUCENT)
ADD_CONTENTS(CONTENTS_LADDER)
ADD_CONTENTS(CONTENTS_HITBOX)
}
void PrintBrushContents( int contents )
{
char str[1024];
PrintBrushContentsToString( contents, str, sizeof( str ) );
Msg( "%s", str );
}
/*
==================
BrushGE
Returns true if b1 is allowed to bite b2
==================
*/
qboolean BrushGE (bspbrush_t *b1, bspbrush_t *b2)
{
// Areaportals are allowed to bite water + slime
// NOTE: This brush combo should have been fixed up
// in a first pass (FixupAreaportalWaterBrushes)
if( (b2->original->contents & MASK_SPLITAREAPORTAL) &&
(b1->original->contents & CONTENTS_AREAPORTAL) )
{
return true;
}
// detail brushes never bite structural brushes
if ( (b1->original->contents & CONTENTS_DETAIL)
&& !(b2->original->contents & CONTENTS_DETAIL) )
return false;
if (b1->original->contents & CONTENTS_SOLID)
return true;
// Transparent brushes are not marked as detail anymore, so let them cut each other.
if ( (b1->original->contents & TRANSPARENT_CONTENTS) && (b2->original->contents & TRANSPARENT_CONTENTS) )
return true;
return false;
}
/*
=================
ChopBrushes
Carves any intersecting solid brushes into the minimum number
of non-intersecting brushes.
=================
*/
bspbrush_t *ChopBrushes (bspbrush_t *head)
{
bspbrush_t *b1, *b2, *next;
bspbrush_t *tail;
bspbrush_t *keep;
bspbrush_t *sub, *sub2;
int c1, c2;
qprintf ("---- ChopBrushes ----\n");
qprintf ("original brushes: %i\n", CountBrushList (head));
#if DEBUG_BRUSHMODEL
if (entity_num == DEBUG_BRUSHMODEL)
WriteBrushList ("before.gl", head, false);
#endif
keep = NULL;
newlist:
// find tail
if (!head)
return NULL;
for (tail=head ; tail->next ; tail=tail->next)
;
for (b1=head ; b1 ; b1=next)
{
next = b1->next;
for (b2=b1->next ; b2 ; b2 = b2->next)
{
if (BrushesDisjoint (b1, b2))
continue;
sub = NULL;
sub2 = NULL;
c1 = 999999;
c2 = 999999;
if ( BrushGE (b2, b1) )
{
// printf( "b2 bites b1\n" );
sub = SubtractBrush (b1, b2);
if (sub == b1)
continue; // didn't really intersect
if (!sub)
{ // b1 is swallowed by b2
head = CullList (b1, b1);
goto newlist;
}
c1 = CountBrushList (sub);
}
if ( BrushGE (b1, b2) )
{
// printf( "b1 bites b2\n" );
sub2 = SubtractBrush (b2, b1);
if (sub2 == b2)
continue; // didn't really intersect
if (!sub2)
{ // b2 is swallowed by b1
FreeBrushList (sub);
head = CullList (b1, b2);
goto newlist;
}
c2 = CountBrushList (sub2);
}
if (!sub && !sub2)
continue; // neither one can bite
// only accept if it didn't fragment
// (commening this out allows full fragmentation)
if (c1 > 1 && c2 > 1)
{
const int contents1 = b1->original->contents;
const int contents2 = b2->original->contents;
// if both detail, allow fragmentation
if ( !((contents1&contents2) & CONTENTS_DETAIL) && !((contents1|contents2) & CONTENTS_AREAPORTAL) )
{
if (sub2)
FreeBrushList (sub2);
if (sub)
FreeBrushList (sub);
continue;
}
}
if (c1 < c2)
{
if (sub2)
FreeBrushList (sub2);
tail = AddBrushListToTail (sub, tail);
head = CullList (b1, b1);
goto newlist;
}
else
{
if (sub)
FreeBrushList (sub);
tail = AddBrushListToTail (sub2, tail);
head = CullList (b1, b2);
goto newlist;
}
}
if (!b2)
{ // b1 is no longer intersecting anything, so keep it
b1->next = keep;
keep = b1;
}
}
qprintf ("output brushes: %i\n", CountBrushList (keep));
#if DEBUG_BRUSHMODEL
if ( entity_num == DEBUG_BRUSHMODEL )
{
WriteBrushList ("after.gl", keep, false);
WriteBrushMap ("after.map", keep);
}
#endif
return keep;
}