/*
-Copyright (C) 1999-2006 Id Software, Inc. and contributors.
-For a list of contributors, see the accompanying CONTRIBUTORS file.
+ Copyright (C) 1999-2006 Id Software, Inc. and contributors.
+ For a list of contributors, see the accompanying CONTRIBUTORS file.
-This file is part of GtkRadiant.
+ This file is part of GtkRadiant.
-GtkRadiant 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.
+ GtkRadiant 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.
-GtkRadiant 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.
+ GtkRadiant 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 GtkRadiant; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-*/
+ You should have received a copy of the GNU General Public License
+ along with GtkRadiant; 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
+ 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
+ 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
+ the best split will be the one that minimizes the total split counts
+ of all remaining sides
-precalc side on plane table
+ 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++;
-}
+ 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);
+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
+ 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
+ ===============
+ SubtractBrush
-Returns a list of brushes that remain after B is subtracted from A.
-May by empty if A is contained inside B.
+ 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;
+ 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++)
+ 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
+ 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);
+ if ( in ) {
+ FreeBrush( in );
+ }
else
- { // didn't really intersect
- FreeBrushList (out);
+ { // didn't really intersect
+ FreeBrushList( out );
return a;
}
return out;
}
/*
-===============
-IntersectBrush
+ ===============
+ IntersectBrush
-Returns a single brush made up by the intersection of the
-two provided brushes, or NULL if they are disjoint.
+ 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;
+ 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++)
+ 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);
+ SplitBrush2( in, b->sides[i].planenum, &front, &back );
+ if ( in != a ) {
+ FreeBrush( in );
+ }
+ if ( front ) {
+ FreeBrush( front );
+ }
in = back;
}
- if (in == a)
+ if ( in == a ) {
return NULL;
+ }
in->next = NULL;
return in;
/*
-===============
-BrushesDisjoint
+ ===============
+ 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;
+ 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
+ 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 ( i = 0 ; i < a->numsides ; i++ )
{
- for (j=0 ; j<b->numsides ; j++)
+ for ( j = 0 ; j < b->numsides ; j++ )
{
- if (a->sides[i].planenum ==
- (b->sides[j].planenum^1) )
- return true; // opposite planes, so not touching
+ if ( a->sides[i].planenum ==
+ ( b->sides[j].planenum ^ 1 ) ) {
+ return true; // opposite planes, so not touching
+ }
}
}
- return false; // might intersect
+ return false; // might intersect
}
/*
-===============
-IntersectionContents
-
-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.
-===============
-*/
-int IntersectionContents (int c1, int c2)
-{
- int out;
+ ===============
+ IntersectionContents
+
+ 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.
+ ===============
+ */
+int IntersectionContents( int c1, int c2 ){
+ int out;
out = c1 | c2;
- if (out & CONTENTS_SOLID)
+ if ( out & CONTENTS_SOLID ) {
out = CONTENTS_SOLID;
+ }
return out;
}
-int minplanenums[3];
-int maxplanenums[3];
+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, vec3_t clipmins, vec3_t clipmaxs)
-{
- int i, j;
- bspbrush_t *front, *back;
- int p;
-
- for (j=0 ; j<2 ; j++)
+ ===============
+ ClipBrushToBox
+
+ Any planes shared with the box edge will be set to no texinfo
+ ===============
+ */
+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);
+ if ( brush->maxs[j] > clipmaxs[j] ) {
+ SplitBrush( brush, maxplanenums[j], &front, &back );
+ if ( front ) {
+ FreeBrush( front );
+ }
brush = back;
- if (!brush)
+ if ( !brush ) {
return NULL;
+ }
}
- if (brush->mins[j] < clipmins[j])
- {
- SplitBrush (brush, minplanenums[j], &front, &back);
- if (back)
- FreeBrush (back);
+ if ( brush->mins[j] < clipmins[j] ) {
+ SplitBrush( brush, minplanenums[j], &front, &back );
+ if ( back ) {
+ FreeBrush( back );
+ }
brush = front;
- if (!brush)
+ if ( !brush ) {
return NULL;
+ }
}
}
// remove any colinear faces
- for (i=0 ; i<brush->numsides ; i++)
+ 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])
- {
+ if ( p == maxplanenums[0] || p == maxplanenums[1]
+ || p == minplanenums[0] || p == minplanenums[1] ) {
brush->sides[i].texinfo = TEXINFO_NODE;
brush->sides[i].visible = false;
}
}
/*
-===============
-MakeBspBrushList
-===============
-*/
-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++)
+ ===============
+ MakeBspBrushList
+ ===============
+ */
+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);
+ VectorClear( normal );
normal[i] = 1;
dist = clipmaxs[i];
- maxplanenums[i] = FindFloatPlane (normal, dist);
+ maxplanenums[i] = FindFloatPlane( normal, dist );
dist = clipmins[i];
- minplanenums[i] = FindFloatPlane (normal, dist);
+ minplanenums[i] = FindFloatPlane( normal, dist );
}
brushlist = NULL;
c_faces = 0;
c_brushes = 0;
- for (i=startbrush ; i<endbrush ; i++)
+ for ( i = startbrush ; i < endbrush ; i++ )
{
mb = &mapbrushes[i];
numsides = mb->numsides;
- if (!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].visible && mb->original_sides[j].winding)
+ for ( j = 0 ; j < numsides ; j++ )
+ if ( mb->original_sides[j].visible && mb->original_sides[j].winding ) {
vis++;
+ }
#if 0
- if (!vis)
- continue; // no faces at all
+ 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)
+ 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 = 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++)
+ 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].visible = true; // hints are always visible
+ 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
+ }
}
- VectorCopy (mb->mins, newbrush->mins);
- VectorCopy (mb->maxs, newbrush->maxs);
+ VectorCopy( mb->mins, newbrush->mins );
+ VectorCopy( mb->maxs, newbrush->maxs );
//
// carve off anything outside the clip box
//
- newbrush = ClipBrushToBox (newbrush, clipmins, clipmaxs);
- if (!newbrush)
+ newbrush = ClipBrushToBox( newbrush, clipmins, clipmaxs );
+ if ( !newbrush ) {
continue;
+ }
c_faces += vis;
c_brushes++;
}
/*
-===============
-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
+ ===============
+ 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;
}
/*
-===========
-CullList
+ ===========
+ 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;
+ 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)
+ for ( ; list ; list = next )
{
next = list->next;
- if (list == skip1)
- {
- FreeBrush (list);
+ if ( list == skip1 ) {
+ FreeBrush( list );
continue;
}
list->next = newlist;
/*
-==================
-WriteBrushMap
-==================
-*/
-void WriteBrushMap (char *name, bspbrush_t *list)
-{
- FILE *f;
- side_t *s;
- int i;
- winding_t *w;
-
- Sys_Printf ("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 )
+ ==================
+ WriteBrushMap
+ ==================
+ */
+void WriteBrushMap( char *name, bspbrush_t *list ){
+ FILE *f;
+ side_t *s;
+ int i;
+ winding_t *w;
+
+ Sys_Printf( "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++)
+ fprintf( f, "{\n" );
+ for ( i = 0,s = list->sides ; i < list->numsides ; i++,s++ )
{
- w = BaseWindingForPlane (mapplanes[s->planenum].normal, mapplanes[s->planenum].dist);
+ 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,"( %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, "%s 0 0 0 1 1\n", texinfo[s->texinfo].texture );
+ FreeWinding( w );
}
- fprintf (f, "}\n");
+ fprintf( f, "}\n" );
}
- fprintf (f, "}\n");
+ fprintf( f, "}\n" );
- fclose (f);
+ fclose( f );
}
/*
-==================
-BrushGE
-
-Returns true if b1 is allowed to bite b2
-==================
-*/
-qboolean BrushGE (bspbrush_t *b1, bspbrush_t *b2)
-{
+ ==================
+ BrushGE
+
+ Returns true if b1 is allowed to bite b2
+ ==================
+ */
+qboolean BrushGE( bspbrush_t *b1, bspbrush_t *b2 ){
// detail brushes never bite structural brushes
- if ( (b1->original->contents & CONTENTS_DETAIL)
- && !(b2->original->contents & CONTENTS_DETAIL) )
+ if ( ( b1->original->contents & CONTENTS_DETAIL )
+ && !( b2->original->contents & CONTENTS_DETAIL ) ) {
return false;
- if (b1->original->contents & CONTENTS_SOLID)
+ }
+ if ( b1->original->contents & CONTENTS_SOLID ) {
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;
-
- Sys_FPrintf( SYS_VRB, "---- ChopBrushes ----\n");
- Sys_FPrintf( SYS_VRB, "original brushes: %i\n", CountBrushList (head));
+ =================
+ 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;
+
+ Sys_FPrintf( SYS_VRB, "---- ChopBrushes ----\n" );
+ Sys_FPrintf( SYS_VRB, "original brushes: %i\n", CountBrushList( head ) );
#if 0
- if (startbrush == 0)
- WriteBrushList ("before.gl", head, false);
+ if ( startbrush == 0 ) {
+ WriteBrushList( "before.gl", head, false );
+ }
#endif
keep = NULL;
newlist:
// find tail
- if (!head)
+ if ( !head ) {
return NULL;
- for (tail=head ; tail->next ; tail=tail->next)
- ;
+ }
+ for ( tail = head ; tail->next ; tail = tail->next )
+ ;
- for (b1=head ; b1 ; b1=next)
+ for ( b1 = head ; b1 ; b1 = next )
{
next = b1->next;
- for (b2=b1->next ; b2 ; b2 = b2->next)
+ for ( b2 = b1->next ; b2 ; b2 = b2->next )
{
- if (BrushesDisjoint (b1, b2))
+ 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
- if (!sub)
- { // b1 is swallowed by b2
- head = CullList (b1, b1);
+ if ( BrushGE( b2, b1 ) ) {
+ 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);
+ 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);
+ 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);
+ c2 = CountBrushList( sub2 );
}
- if (!sub && !sub2)
- continue; // neither one can bite
+ 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)
- {
- if (sub2)
- FreeBrushList (sub2);
- if (sub)
- FreeBrushList (sub);
+ 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);
+ 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);
+ 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
+ if ( !b2 ) { // b1 is no longer intersecting anything, so keep it
b1->next = keep;
keep = b1;
}
}
- Sys_FPrintf( SYS_VRB, "output brushes: %i\n", CountBrushList (keep));
+ Sys_FPrintf( SYS_VRB, "output brushes: %i\n", CountBrushList( keep ) );
#if 0
{
- WriteBrushList ("after.gl", keep, false);
- WriteBrushMap ("after.map", keep);
+ WriteBrushList( "after.gl", keep, false );
+ WriteBrushMap( "after.map", keep );
}
#endif
return keep;
/*
-=================
-InitialBrushList
-=================
-*/
-bspbrush_t *InitialBrushList (bspbrush_t *list)
-{
+ =================
+ InitialBrushList
+ =================
+ */
+bspbrush_t *InitialBrushList( bspbrush_t *list ){
bspbrush_t *b;
- bspbrush_t *out, *newb;
- int i;
+ bspbrush_t *out, *newb;
+ int i;
// only return brushes that have visible faces
out = NULL;
- for (b=list ; b ; b=b->next)
+ for ( b = list ; b ; b = b->next )
{
#if 0
- for (i=0 ; i<b->numsides ; i++)
- if (b->sides[i].visible)
+ for ( i = 0 ; i < b->numsides ; i++ )
+ if ( b->sides[i].visible ) {
break;
- if (i == b->numsides)
+ }
+ if ( i == b->numsides ) {
continue;
+ }
#endif
- newb = CopyBrush (b);
+ 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++)
+ for ( i = 0 ; i < b->numsides ; i++ )
{
newb->sides[i].original = &b->sides[i];
// newb->sides[i].visible = true;
}
/*
-=================
-OptimizedBrushList
-=================
-*/
-bspbrush_t *OptimizedBrushList (bspbrush_t *list)
-{
+ =================
+ OptimizedBrushList
+ =================
+ */
+bspbrush_t *OptimizedBrushList( bspbrush_t *list ){
bspbrush_t *b;
- bspbrush_t *out, *newb;
- int i;
+ bspbrush_t *out, *newb;
+ int i;
// only return brushes that have visible faces
out = NULL;
- for (b=list ; b ; b=b->next)
+ for ( b = list ; b ; b = b->next )
{
- for (i=0 ; i<b->numsides ; i++)
- if (b->sides[i].visible)
+ for ( i = 0 ; i < b->numsides ; i++ )
+ if ( b->sides[i].visible ) {
break;
- if (i == b->numsides)
+ }
+ if ( i == b->numsides ) {
continue;
- newb = CopyBrush (b);
+ }
+ newb = CopyBrush( b );
newb->next = out;
out = newb;
}
projects / xonotic / netradiant.git / blobdiff