ubergames/ioef
0
0
Fork 0
mirror of https://github.com/UberGames/ioef.git synced 2024-11-24 13:11:30 +00:00
Code Issues Projects Releases Packages Wiki Activity
ioef/code/bspc/csg.c
Ludwig Nussel 5ae70d54b0 remove svn:executable property
2005-08-28 17:54:51 +00:00

1005 lines
25 KiB
C
Raw Blame History

/*
===========================================================================
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
===========================================================================
*/
#include "qbsp.h"
/*
tag all brushes with original contents
brushes may contain multiple contents
there will be no brush overlap after csg phase
*/
int minplanenums[3];
int maxplanenums[3];
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void CheckBSPBrush(bspbrush_t *brush)
{
int i, j;
plane_t *plane1, *plane2;
//check if the brush is convex... flipped planes make a brush non-convex
for (i = 0; i < brush->numsides; i++)
{
for (j = 0; j < brush->numsides; j++)
{
if (i == j) continue;
plane1 = &mapplanes[brush->sides[i].planenum];
plane2 = &mapplanes[brush->sides[j].planenum];
//
if (WindingsNonConvex(brush->sides[i].winding,
brush->sides[j].winding,
plane1->normal, plane2->normal,
plane1->dist, plane2->dist))
{
Log_Print("non convex brush");
break;
} //end if
} //end for
} //end for
BoundBrush(brush);
//check for out of bound brushes
for (i = 0; i < 3; i++)
{
if (brush->mins[i] < -MAX_MAP_BOUNDS || brush->maxs[i] > MAX_MAP_BOUNDS)
{
Log_Print("brush: bounds out of range\n");
Log_Print("ob->mins[%d] = %f, ob->maxs[%d] = %f\n", i, brush->mins[i], i, brush->maxs[i]);
break;
} //end if
if (brush->mins[i] > MAX_MAP_BOUNDS || brush->maxs[i] < -MAX_MAP_BOUNDS)
{
Log_Print("brush: no visible sides on brush\n");
Log_Print("ob->mins[%d] = %f, ob->maxs[%d] = %f\n", i, brush->mins[i], i, brush->maxs[i]);
break;
} //end if
} //end for
} //end of the function CheckBSPBrush
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void BSPBrushWindings(bspbrush_t *brush)
{
int i, j;
winding_t *w;
plane_t *plane;
for (i = 0; i < brush->numsides; i++)
{
plane = &mapplanes[brush->sides[i].planenum];
w = BaseWindingForPlane(plane->normal, plane->dist);
for (j = 0; j < brush->numsides && w; j++)
{
if (i == j) continue;
plane = &mapplanes[brush->sides[j].planenum^1];
ChopWindingInPlace(&w, plane->normal, plane->dist, 0); //CLIP_EPSILON);
} //end for
brush->sides[i].winding = w;
} //end for
} //end of the function BSPBrushWindings
//===========================================================================
// NOTE: can't keep brush->original intact
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bspbrush_t *TryMergeBrushes(bspbrush_t *brush1, bspbrush_t *brush2)
{
int i, j, k, n, shared;
side_t *side1, *side2, *cs;
plane_t *plane1, *plane2;
bspbrush_t *newbrush;
//check for bounding box overlapp
for (i = 0; i < 3; i++)
{
if (brush1->mins[i] > brush2->maxs[i] + 2
|| brush1->maxs[i] < brush2->mins[i] - 2)
{
return NULL;
} //end if
} //end for
//
shared = 0;
//check if the brush is convex... flipped planes make a brush non-convex
for (i = 0; i < brush1->numsides; i++)
{
side1 = &brush1->sides[i];
//don't check the "shared" sides
for (k = 0; k < brush2->numsides; k++)
{
side2 = &brush2->sides[k];
if (side1->planenum == (side2->planenum^1))
{
shared++;
//there may only be ONE shared side
if (shared > 1) return NULL;
break;
} //end if
} //end for
if (k < brush2->numsides) continue;
//
for (j = 0; j < brush2->numsides; j++)
{
side2 = &brush2->sides[j];
//don't check the "shared" sides
for (n = 0; n < brush1->numsides; n++)
{
side1 = &brush1->sides[n];
if (side1->planenum == (side2->planenum^1)) break;
} //end for
if (n < brush1->numsides) continue;
//
side1 = &brush1->sides[i];
//if the side is in the same plane
//*
if (side1->planenum == side2->planenum)
{
if (side1->texinfo != TEXINFO_NODE &&
side2->texinfo != TEXINFO_NODE &&
side1->texinfo != side2->texinfo) return NULL;
continue;
} //end if
//
plane1 = &mapplanes[side1->planenum];
plane2 = &mapplanes[side2->planenum];
//
if (WindingsNonConvex(side1->winding, side2->winding,
plane1->normal, plane2->normal,
plane1->dist, plane2->dist))
{
return NULL;
} //end if
} //end for
} //end for
newbrush = AllocBrush(brush1->numsides + brush2->numsides);
newbrush->original = brush1->original;
newbrush->numsides = 0;
//newbrush->side = brush1->side; //brush contents
//fix texinfos for sides lying in the same plane
for (i = 0; i < brush1->numsides; i++)
{
side1 = &brush1->sides[i];
//
for (n = 0; n < brush2->numsides; n++)
{
side2 = &brush2->sides[n];
//if both sides are in the same plane get the texinfo right
if (side1->planenum == side2->planenum)
{
if (side1->texinfo == TEXINFO_NODE) side1->texinfo = side2->texinfo;
if (side2->texinfo == TEXINFO_NODE) side2->texinfo = side1->texinfo;
} //end if
} //end for
} //end for
//
for (i = 0; i < brush1->numsides; i++)
{
side1 = &brush1->sides[i];
//don't add the "shared" sides
for (n = 0; n < brush2->numsides; n++)
{
side2 = &brush2->sides[n];
if (side1->planenum == (side2->planenum ^ 1)) break;
} //end for
if (n < brush2->numsides) continue;
//
for (n = 0; n < newbrush->numsides; n++)
{
cs = &newbrush->sides[n];
if (cs->planenum == side1->planenum)
{
Log_Print("brush duplicate plane\n");
break;
} //end if
} //end if
if (n < newbrush->numsides) continue;
//add this side
cs = &newbrush->sides[newbrush->numsides];
newbrush->numsides++;
*cs = *side1;
} //end for
for (j = 0; j < brush2->numsides; j++)
{
side2 = &brush2->sides[j];
for (n = 0; n < brush1->numsides; n++)
{
side1 = &brush1->sides[n];
//if the side is in the same plane
if (side2->planenum == side1->planenum) break;
//don't add the "shared" sides
if (side2->planenum == (side1->planenum ^ 1)) break;
} //end for
if (n < brush1->numsides) continue;
//
for (n = 0; n < newbrush->numsides; n++)
{
cs = &newbrush->sides[n];
if (cs->planenum == side2->planenum)
{
Log_Print("brush duplicate plane\n");
break;
} //end if
} //end if
if (n < newbrush->numsides) continue;
//add this side
cs = &newbrush->sides[newbrush->numsides];
newbrush->numsides++;
*cs = *side2;
} //end for
BSPBrushWindings(newbrush);
BoundBrush(newbrush);
CheckBSPBrush(newbrush);
return newbrush;
} //end of the function TryMergeBrushes
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bspbrush_t *MergeBrushes(bspbrush_t *brushlist)
{
int nummerges, merged;
bspbrush_t *b1, *b2, *tail, *newbrush, *newbrushlist;
bspbrush_t *lastb2;
if (!brushlist) return NULL;
qprintf("%5d brushes merged", nummerges = 0);
do
{
for (tail = brushlist; tail; tail = tail->next)
{
if (!tail->next) break;
} //end for
merged = 0;
newbrushlist = NULL;
for (b1 = brushlist; b1; b1 = brushlist)
{
lastb2 = b1;
for (b2 = b1->next; b2; b2 = b2->next)
{
//if the brushes don't have the same contents
if (b1->original->contents != b2->original->contents ||
b1->original->expansionbbox != b2->original->expansionbbox) newbrush = NULL;
else newbrush = TryMergeBrushes(b1, b2);
if (newbrush)
{
tail->next = newbrush;
lastb2->next = b2->next;
brushlist = brushlist->next;
FreeBrush(b1);
FreeBrush(b2);
for (tail = brushlist; tail; tail = tail->next)
{
if (!tail->next) break;
} //end for
merged++;
qprintf("\r%5d", nummerges++);
break;
} //end if
lastb2 = b2;
} //end for
//if b1 can't be merged with any of the other brushes
if (!b2)
{
brushlist = brushlist->next;
//keep b1
b1->next = newbrushlist;
newbrushlist = b1;
} //end else
} //end for
brushlist = newbrushlist;
} while(merged);
qprintf("\n");
return newbrushlist;
} //end of the function MergeBrushes
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
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
} //end of the function SplitBrush2
//===========================================================================
// 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.
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
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;
} //end if
in = back;
} //end for
if (in)
{
FreeBrush (in);
} //end if
else
{ // didn't really intersect
FreeBrushList (out);
return a;
} //end else
return out;
} //end of the function SubtractBrush
//===========================================================================
// Returns a single brush made up by the intersection of the
// two provided brushes, or NULL if they are disjoint.
//
// The originals are undisturbed.
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
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;
} //end for
if (in == a) return NULL;
in->next = NULL;
return in;
} //end of the function IntersectBrush
//===========================================================================
// Returns true if the two brushes definately do not intersect.
// There will be false negatives for some non-axial combinations.
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
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
} //end of the function BrushesDisjoint
//===========================================================================
// Returns a content word for the intersection of two brushes.
// Some combinations will generate a combination (water + clip),
// but most will be the stronger of the two contents.
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int IntersectionContents (int c1, int c2)
{
int out;
out = c1 | c2;
if (out & CONTENTS_SOLID) out = CONTENTS_SOLID;
return out;
} //end of the function IntersectionContents
//===========================================================================
// Any planes shared with the box edge will be set to no texinfo
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bspbrush_t *ClipBrushToBox(bspbrush_t *brush, vec3_t clipmins, vec3_t 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].flags &= ~SFL_VISIBLE;
}
}
return brush;
} //end of the function ClipBrushToBox
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bspbrush_t *MakeBspBrushList(int startbrush, int endbrush,
vec3_t clipmins, vec3_t clipmaxs)
{
mapbrush_t *mb;
bspbrush_t *brushlist, *newbrush;
int i, j;
int c_faces;
int c_brushes;
int numsides;
int vis;
vec3_t normal;
float dist;
for (i=0 ; i<2 ; i++)
{
VectorClear (normal);
normal[i] = 1;
dist = clipmaxs[i];
maxplanenums[i] = FindFloatPlane(normal, dist);
dist = clipmins[i];
minplanenums[i] = FindFloatPlane(normal, dist);
}
brushlist = NULL;
c_faces = 0;
c_brushes = 0;
for (i=startbrush ; i<endbrush ; i++)
{
mb = &mapbrushes[i];
numsides = mb->numsides;
if (!numsides)
continue;
// make sure the brush has at least one face showing
vis = 0;
for (j=0 ; j<numsides ; j++)
if ((mb->original_sides[j].flags & SFL_VISIBLE) && mb->original_sides[j].winding)
vis++;
#if 0
if (!vis)
continue; // no faces at all
#endif
// if the brush is outside the clip area, skip it
for (j=0 ; j<3 ; j++)
if (mb->mins[j] >= clipmaxs[j]
|| mb->maxs[j] <= clipmins[j])
break;
if (j != 3)
continue;
//
// make a copy of the brush
//
newbrush = AllocBrush (mb->numsides);
newbrush->original = mb;
newbrush->numsides = mb->numsides;
memcpy (newbrush->sides, mb->original_sides, numsides*sizeof(side_t));
for (j=0 ; j<numsides ; 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].flags |= SFL_VISIBLE; // hints are always visible
}
VectorCopy (mb->mins, newbrush->mins);
VectorCopy (mb->maxs, newbrush->maxs);
//
// carve off anything outside the clip box
//
newbrush = ClipBrushToBox (newbrush, clipmins, clipmaxs);
if (!newbrush)
continue;
c_faces += vis;
c_brushes++;
newbrush->next = brushlist;
brushlist = newbrush;
}
return brushlist;
} //end of the function MakeBspBrushList
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
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;
} //end for
return tail;
} //end of the function AddBrushListToTail
//===========================================================================
// Builds a new list that doesn't hold the given brush
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
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;
} //end of the function CullList
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
/*
void WriteBrushMap(char *name, bspbrush_t *list)
{
FILE *f;
side_t *s;
int i;
winding_t *w;
Log_Print("writing %s\n", name);
f = fopen (name, "wb");
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 (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, "%s 0 0 0 1 1\n", texinfo[s->texinfo].texture);
FreeWinding (w);
}
fprintf (f, "}\n");
}
fprintf (f, "}\n");
fclose (f);
} //end of the function WriteBrushMap
*/
//===========================================================================
// Returns true if b1 is allowed to bite b2
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
qboolean BrushGE (bspbrush_t *b1, bspbrush_t *b2)
{
#ifdef ME
if (create_aas)
{
if (b1->original->expansionbbox != b2->original->expansionbbox)
{
return false;
} //end if
//never have something else bite a ladder brush
//never have a ladder brush bite something else
if ( (b1->original->contents & CONTENTS_LADDER)
&& !(b2->original->contents & CONTENTS_LADDER))
{
return false;
} //end if
} //end if
#endif //ME
// detail brushes never bite structural brushes
if ( (b1->original->contents & CONTENTS_DETAIL)
&& !(b2->original->contents & CONTENTS_DETAIL) )
{
return false;
} //end if
if (b1->original->contents & CONTENTS_SOLID)
{
return true;
} //end if
return false;
} //end of the function BrushGE
//===========================================================================
// Carves any intersecting solid brushes into the minimum number
// of non-intersecting brushes.
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bspbrush_t *ChopBrushes (bspbrush_t *head)
{
bspbrush_t *b1, *b2, *next;
bspbrush_t *tail;
bspbrush_t *keep;
bspbrush_t *sub, *sub2;
int c1, c2;
int num_csg_iterations;
Log_Print("-------- Brush CSG ---------\n");
Log_Print("%6d original brushes\n", CountBrushList (head));
num_csg_iterations = 0;
qprintf("%6d output brushes", num_csg_iterations);
#if 0
if (startbrush == 0)
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;
//if the conversion is cancelled
if (cancelconversion)
{
b1->next = keep;
keep = b1;
continue;
} //end if
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))
{
sub = SubtractBrush (b1, b2);
if (sub == b1)
{
continue; // didn't really intersect
} //end if
if (!sub)
{ // b1 is swallowed by b2
head = CullList (b1, b1);
goto newlist;
}
c1 = CountBrushList (sub);
}
if ( BrushGE (b1, b2) )
{
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
// (commenting this out allows full fragmentation)
if (c1 > 1 && c2 > 1)
{
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;
} //end if
else
{
if (sub) FreeBrushList (sub);
tail = AddBrushListToTail (sub2, tail);
head = CullList (b1, b2);
goto newlist;
} //end else
} //end for
if (!b2)
{ // b1 is no longer intersecting anything, so keep it
b1->next = keep;
keep = b1;
} //end if
num_csg_iterations++;
qprintf("\r%6d", num_csg_iterations);
} //end for
if (cancelconversion) return keep;
//
qprintf("\n");
Log_Write("%6d output brushes\r\n", num_csg_iterations);
#if 0
{
WriteBrushList ("after.gl", keep, false);
WriteBrushMap ("after.map", keep);
}
#endif
return keep;
} //end of the function ChopBrushes
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bspbrush_t *InitialBrushList (bspbrush_t *list)
{
bspbrush_t *b;
bspbrush_t *out, *newb;
int i;
// only return brushes that have visible faces
out = NULL;
for (b=list ; b ; b=b->next)
{
#if 0
for (i=0 ; i<b->numsides ; i++)
if (b->sides[i].flags & SFL_VISIBLE)
break;
if (i == b->numsides)
continue;
#endif
newb = CopyBrush (b);
newb->next = out;
out = newb;
// clear visible, so it must be set by MarkVisibleFaces_r
// to be used in the optimized list
for (i=0 ; i<b->numsides ; i++)
{
newb->sides[i].original = &b->sides[i];
// newb->sides[i].visible = true;
b->sides[i].flags &= ~SFL_VISIBLE;
}
}
return out;
} //end of the function InitialBrushList
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bspbrush_t *OptimizedBrushList (bspbrush_t *list)
{
bspbrush_t *b;
bspbrush_t *out, *newb;
int i;
// only return brushes that have visible faces
out = NULL;
for (b=list ; b ; b=b->next)
{
for (i=0 ; i<b->numsides ; i++)
if (b->sides[i].flags & SFL_VISIBLE)
break;
if (i == b->numsides)
continue;
newb = CopyBrush (b);
newb->next = out;
out = newb;
} //end for
// WriteBrushList ("vis.gl", out, true);
return out;
} //end of the function OptimizeBrushList
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
tree_t *ProcessWorldBrushes(int brush_start, int brush_end)
{
bspbrush_t *brushes;
tree_t *tree;
node_t *node;
vec3_t mins, maxs;
//take the whole world
mins[0] = map_mins[0] - 8;
mins[1] = map_mins[1] - 8;
mins[2] = map_mins[2] - 8;
maxs[0] = map_maxs[0] + 8;
maxs[1] = map_maxs[1] + 8;
maxs[2] = map_maxs[2] + 8;
//reset the brush bsp
ResetBrushBSP();
// the makelist and chopbrushes could be cached between the passes...
//create a list with brushes that are within the given mins/maxs
//some brushes will be cut and only the part that falls within the
//mins/maxs will be in the bush list
brushes = MakeBspBrushList(brush_start, brush_end, mins, maxs);
//
if (!brushes)
{
node = AllocNode ();
node->planenum = PLANENUM_LEAF;
node->contents = CONTENTS_SOLID;
tree = Tree_Alloc();
tree->headnode = node;
VectorCopy(mins, tree->mins);
VectorCopy(maxs, tree->maxs);
} //end if
else
{
//Carves any intersecting solid brushes into the minimum number
//of non-intersecting brushes.
if (!nocsg)
{
brushes = ChopBrushes(brushes);
/*
if (create_aas)
{
brushes = MergeBrushes(brushes);
} //end if*/
} //end if
//if the conversion is cancelled
if (cancelconversion)
{
FreeBrushList(brushes);
return NULL;
} //end if
//create the actual bsp tree
tree = BrushBSP(brushes, mins, maxs);
} //end else
//return the tree
return tree;
} //end of the function ProcessWorldBrushes
Reference in a new issue View git blame Copy permalink