X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=contrib%2Fgtkgensurf%2Fdec.cpp;h=dda98a02581bffcf1089ff46f9d12cb54ce62406;hb=378c0a8dafe04a2e347fdca15c5e4b0754c14274;hp=f2daa816536652b82e6fa0c753aff87bef572a62;hpb=a06f65b0422c4333f3daba0bb9ef2236e2a06c14;p=xonotic%2Fnetradiant.git

diff --git a/contrib/gtkgensurf/dec.cpp b/contrib/gtkgensurf/dec.cpp
index f2daa816..dda98a02 100644
--- a/contrib/gtkgensurf/dec.cpp
+++ b/contrib/gtkgensurf/dec.cpp
@@ -1,21 +1,21 @@
 /*
-GenSurf plugin for GtkRadiant
-Copyright (C) 2001 David Hyde, Loki software and qeradiant.com
+   GenSurf plugin for GtkRadiant
+   Copyright (C) 2001 David Hyde, Loki software and qeradiant.com
 
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Lesser General Public
-License as published by the Free Software Foundation; either
-version 2.1 of the License, or (at your option) any later version.
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
 
-This library 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
-Lesser General Public License for more details.
+   This library 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
+   Lesser General Public License for more details.
 
-You should have received a copy of the GNU Lesser General Public
-License along with this library; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
 
 #define SINGLE
 #ifdef SINGLE
@@ -33,50 +33,51 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 typedef struct
 {
 	float error;
-	int   node;
+	int node;
 } TRITABLE;
 
 double dh, dv;
-int    NVP1;
-
-#define Absolute(a)  ((a) >= 0.0 ? (a) : -(a))
-
-void MakeDecimatedMap(int *NumNodes, int *NumTris, NODE **pNode, TRI **pTri)
-{
-	int  compare(TRITABLE *, TRITABLE *);
-	int Bisect(NODE *, int, int, int);
-	void CalcAngles(NODE *, int *, float *);
-	void EdgeOnSide(int *, int *, int *);
-	int tricall(int, NODE *, int *, TRI **, TRI **, char *);
-	int CheckBorders(int *,int,NODE *,int *,TRI **);
-
-	float       biggesterror;
-	int         i, j, N;
-	int         j0, j1, j2;
-	int         NumNodesToSave;
-	int         NumNodesUsed;
+int NVP1;
+
+#define Absolute( a )  ( ( a ) >= 0.0 ? ( a ) : -( a ) )
+
+void MakeDecimatedMap( int *NumNodes, int *NumTris, NODE **pNode, TRI **pTri ){
+	int compare( TRITABLE *, TRITABLE * );
+	int Bisect( NODE *, int, int, int );
+	void CalcAngles( NODE *, int *, float * );
+	void EdgeOnSide( int *, int *, int * );
+	int tricall( int, NODE *, int *, TRI * *, TRI * *, const char * );
+	int CheckBorders( int *,int,NODE *,int *,TRI * * );
+
+	float biggesterror;
+	int i, j, N;
+	int j0, j1, j2;
+	int NumNodesToSave;
+	int NumNodesUsed;
 	NODE        *Node;
 	TRI         *Tri;
 	TRITABLE    *TriTable;
 
-	if(Decimate <= 0) return;
-        /*
-	ghCursorCurrent = LoadCursor(NULL,IDC_WAIT);
-	SetCursor(ghCursorCurrent);
-        */
-	dh = (Hur-Hll)/NH;
-	dv = (Vur-Vll)/NV;
-	NVP1 = NV+1;
-
-	NumNodes[0] = (NH+1)*(NVP1);
-	*pNode = (NODE *) malloc(NumNodes[0] * sizeof(NODE));
+	if ( Decimate <= 0 ) {
+		return;
+	}
+	/*
+	   ghCursorCurrent = LoadCursor(NULL,IDC_WAIT);
+	   SetCursor(ghCursorCurrent);
+	 */
+	dh = ( Hur - Hll ) / NH;
+	dv = ( Vur - Vll ) / NV;
+	NVP1 = NV + 1;
+
+	NumNodes[0] = ( NH + 1 ) * ( NVP1 );
+	*pNode = (NODE *) malloc( NumNodes[0] * sizeof( NODE ) );
 	Node = *pNode;
-	memset(Node,0,NumNodes[0]*sizeof(NODE));
+	memset( Node,0,NumNodes[0] * sizeof( NODE ) );
 
 	// Copy [NH][NV] vertex array to our working node array
-	for(i=0,N=0; i<=NH; i++)
+	for ( i = 0,N = 0; i <= NH; i++ )
 	{
-		for(j=0; j<=NV; j++, N++)
+		for ( j = 0; j <= NV; j++, N++ )
 		{
 			Node[N].p[0]  = (float)xyz[i][j].p[0];
 			Node[N].p[1]  = (float)xyz[i][j].p[1];
@@ -87,14 +88,14 @@ void MakeDecimatedMap(int *NumNodes, int *NumTris, NODE **pNode, TRI **pTri)
 	// Start things off with the corner values
 	Node[ 0].used           = 1;
 	Node[NV].used           = 1;
-	Node[NH*NVP1].used    = 1;
-	Node[NH*NVP1+NV].used = 1;
+	Node[NH * NVP1].used    = 1;
+	Node[NH * NVP1 + NV].used = 1;
 	NumNodesUsed = 4;
-	tricall(NumNodes[0], Node, NumTris, NULL, pTri, "cnzBNPY");
+	tricall( NumNodes[0], Node, NumTris, NULL, pTri, "cnzBNPY" );
 	Tri = *pTri;
 
 	// Which coordinates are we triangulating on?
-	switch(Plane)
+	switch ( Plane )
 	{
 	case PLANE_XZ0:
 	case PLANE_XZ1:
@@ -116,161 +117,179 @@ void MakeDecimatedMap(int *NumNodes, int *NumTris, NODE **pNode, TRI **pTri)
 
 	// TriTable stores the largest error in a triangle and the node where that
 	// error occurs
-	TriTable = (TRITABLE *) malloc(NH*NV*2 * sizeof(TRITABLE));
-	NumNodesToSave = min(NumNodes[0], (int)(0.01*(100-Decimate)*(NumNodes[0]-NumNodesUsed)+NumNodesUsed));
+	TriTable = (TRITABLE *) malloc( NH * NV * 2 * sizeof( TRITABLE ) );
+	NumNodesToSave = min( NumNodes[0], (int)( 0.01 * ( 100 - Decimate ) * ( NumNodes[0] - NumNodesUsed ) + NumNodesUsed ) );
 
-	while(NumNodesUsed < NumNodesToSave)
+	while ( NumNodesUsed < NumNodesToSave )
 	{
-		for(i=0; i<NumTris[0]; i++)
+		for ( i = 0; i < NumTris[0]; i++ )
 			Tri[i].flag = 0;
 
 		// For every node that's not currently used, find what triangle it
 		// lies on, and the error at this node
-		for(i=0, biggesterror=0; i<NumNodes[0]; i++)
+		for ( i = 0, biggesterror = 0; i < NumNodes[0]; i++ )
 		{
-			if(Node[i].used) continue;
-			for(j=0, Node[i].tri=-1; (j<NumTris[0]) && (Node[i].tri==-1); j++)
+			if ( Node[i].used ) {
+				continue;
+			}
+			for ( j = 0, Node[i].tri = -1; ( j < NumTris[0] ) && ( Node[i].tri == -1 ); j++ )
 			{
-				if( side(Node[i].p[j1],          Node[i].p[j2],
-					     Node[Tri[j].v[0]].p[j1],Node[Tri[j].v[0]].p[j2],
-					     Node[Tri[j].v[1]].p[j1],Node[Tri[j].v[1]].p[j2]) < 0. ) continue;
-				if( side(Node[i].p[j1],          Node[i].p[j2],
-					     Node[Tri[j].v[1]].p[j1],Node[Tri[j].v[1]].p[j2],
-					     Node[Tri[j].v[2]].p[j1],Node[Tri[j].v[2]].p[j2]) < 0. ) continue;
-				if( side(Node[i].p[j1],          Node[i].p[j2],
-					     Node[Tri[j].v[2]].p[j1],Node[Tri[j].v[2]].p[j2],
-					     Node[Tri[j].v[0]].p[j1],Node[Tri[j].v[0]].p[j2]) < 0. ) continue;
+				if ( side( Node[i].p[j1],          Node[i].p[j2],
+						   Node[Tri[j].v[0]].p[j1],Node[Tri[j].v[0]].p[j2],
+						   Node[Tri[j].v[1]].p[j1],Node[Tri[j].v[1]].p[j2] ) < 0. ) {
+					continue;
+				}
+				if ( side( Node[i].p[j1],          Node[i].p[j2],
+						   Node[Tri[j].v[1]].p[j1],Node[Tri[j].v[1]].p[j2],
+						   Node[Tri[j].v[2]].p[j1],Node[Tri[j].v[2]].p[j2] ) < 0. ) {
+					continue;
+				}
+				if ( side( Node[i].p[j1],          Node[i].p[j2],
+						   Node[Tri[j].v[2]].p[j1],Node[Tri[j].v[2]].p[j2],
+						   Node[Tri[j].v[0]].p[j1],Node[Tri[j].v[0]].p[j2] ) < 0. ) {
+					continue;
+				}
 				Node[i].tri = j;
 			}
-			if(Node[i].tri < 0)
-			{
-                          /*
-				ghCursorCurrent = ghCursorDefault;
-				SetCursor(ghCursorCurrent);
-                          */
-				g_FuncTable.m_pfnMessageBox(g_pRadiantWnd,
-					"Error: Couldn't find the triangle bounding a point.",
-					"Decimation Error",MB_ICONEXCLAMATION, NULL);
+			if ( Node[i].tri < 0 ) {
+				/*
+				   ghCursorCurrent = ghCursorDefault;
+				   SetCursor(ghCursorCurrent);
+				 */
+				g_FuncTable.m_pfnMessageBox( g_pRadiantWnd,
+											 "Error: Couldn't find the triangle bounding a point.",
+											 "Decimation Error", eMB_OK, eMB_ICONWARNING );
 				return;
 			}
-			if(!Tri[Node[i].tri].flag)
-			{
-				PlaneFromPoints(Node[Tri[Node[i].tri].v[0]].p,
-				                Node[Tri[Node[i].tri].v[1]].p,
-				                Node[Tri[Node[i].tri].v[2]].p,
-								&Tri[Node[i].tri].plane);
+			if ( !Tri[Node[i].tri].flag ) {
+				PlaneFromPoints( Node[Tri[Node[i].tri].v[0]].p,
+								 Node[Tri[Node[i].tri].v[1]].p,
+								 Node[Tri[Node[i].tri].v[2]].p,
+								 &Tri[Node[i].tri].plane );
 				Tri[Node[i].tri].flag = 1;
 			}
 			Node[i].error =
-				Node[i].p[j0] - (Tri[Node[i].tri].plane.dist -
-							     Tri[Node[i].tri].plane.normal[j1]*Node[i].p[j1] -
-								 Tri[Node[i].tri].plane.normal[j2]*Node[i].p[j2]  )/
-								 Tri[Node[i].tri].plane.normal[j0];
-			biggesterror = max(biggesterror,Absolute(Node[i].error));
+				Node[i].p[j0] - ( Tri[Node[i].tri].plane.dist -
+								  Tri[Node[i].tri].plane.normal[j1] * Node[i].p[j1] -
+								  Tri[Node[i].tri].plane.normal[j2] * Node[i].p[j2]  ) /
+				Tri[Node[i].tri].plane.normal[j0];
+			biggesterror = max( biggesterror,Absolute( Node[i].error ) );
 		}
-		if(biggesterror == 0)
+		if ( biggesterror == 0 ) {
 			NumNodesToSave = NumNodesUsed;
+		}
 		else
 		{
 			// For all current triangles, build a list of worst-case nodes
-			memset(TriTable,0,NH*NV*2*sizeof(TRITABLE));
-			for(i=0; i<NumNodes[0]; i++)
+			memset( TriTable,0,NH * NV * 2 * sizeof( TRITABLE ) );
+			for ( i = 0; i < NumNodes[0]; i++ )
 			{
-				if(Node[i].used) continue;
-				if(Absolute(Node[i].error) > TriTable[Node[i].tri].error)
-				{
-					TriTable[Node[i].tri].error = (float)(Absolute(Node[i].error));
+				if ( Node[i].used ) {
+					continue;
+				}
+				if ( Absolute( Node[i].error ) > TriTable[Node[i].tri].error ) {
+					TriTable[Node[i].tri].error = (float)( Absolute( Node[i].error ) );
 					TriTable[Node[i].tri].node  = i;
 				}
 			}
-			qsort( (void *)TriTable, (size_t)(NumTris[0]), sizeof(TRITABLE), (int (*)(const void *, const void *))compare );
-			for(i=0; i<NumTris[0] && NumNodesUsed < NumNodesToSave && TriTable[i].error > 0.5*biggesterror; i++)
+			qsort( (void *)TriTable, (size_t)( NumTris[0] ), sizeof( TRITABLE ), ( int ( * )( const void *, const void * ) )compare );
+			for ( i = 0; i < NumTris[0] && NumNodesUsed < NumNodesToSave && TriTable[i].error > 0.5 * biggesterror; i++ )
 			{
-				if(Node[TriTable[i].node].used) continue;  // shouldn't happen
+				if ( Node[TriTable[i].node].used ) {
+					continue;                              // shouldn't happen
+				}
 				NumNodesUsed++;
 				Node[TriTable[i].node].used++;
 			}
-			free(Tri);
-			tricall(NumNodes[0], Node, NumTris, NULL, pTri, "cnzBNPY");
+			free( Tri );
+			tricall( NumNodes[0], Node, NumTris, NULL, pTri, "cnzBNPY" );
 			Tri = *pTri;
 			// Sliver-check along borders. Since borders are often linear, the errors
 			// along borders will often be zero, so no new points will be added. This
-			// tends to produce long, thin brushes. For all border triangles, check 
+			// tends to produce long, thin brushes. For all border triangles, check
 			// that minimum angle isn't less than SLIVER_ANGLE. If it is, add another
 			// vertex.
-			while(CheckBorders(&NumNodesUsed,NumNodes[0],Node,NumTris,pTri) > 0)
+			while ( CheckBorders( &NumNodesUsed,NumNodes[0],Node,NumTris,pTri ) > 0 )
 			{
 			}
 			Tri = *pTri;
 		}
 	}
-	free(TriTable);
+	free( TriTable );
 	// One last time (because we're pessimistic), check border triangles
-//	CheckBorders(&NumNodesUsed,NumNodes[0],Node,NumTris,pTri);
-//	Tri = *pTri;
 
 	// Check that all fixed points are exact. If not, add them to the mix.
 	// First check to see if we have any fixed points that aren't already used.
-	for(i=0, N=0; i<NumNodes[0] && !N; i++)
+	for ( i = 0, N = 0; i < NumNodes[0] && !N; i++ )
 	{
-		if(Node[i].used) continue;
-		if(Node[i].fixed) N++;
+		if ( Node[i].used ) {
+			continue;
+		}
+		if ( Node[i].fixed ) {
+			N++;
+		}
 	}
-	if(N)
-	{
+	if ( N ) {
 		// Zero out the flag member of all triangles, indicating that
 		// the plane equation has not been found.
-		for(i=0; i<NumTris[0]; i++)
+		for ( i = 0; i < NumTris[0]; i++ )
 			Tri[i].flag = 0;
 
-		for(i=0; i<NumNodes[0]; i++)
+		for ( i = 0; i < NumNodes[0]; i++ )
 		{
-			if(Node[i].used) continue;
-			if(!Node[i].fixed) continue;
+			if ( Node[i].used ) {
+				continue;
+			}
+			if ( !Node[i].fixed ) {
+				continue;
+			}
 			Node[i].tri = -1;
-			for(j=0; j<NumTris[0] && Node[i].tri==-1; j++)
+			for ( j = 0; j < NumTris[0] && Node[i].tri == -1; j++ )
 			{
-				if( side(Node[i].p[j1],          Node[i].p[j2],
-					Node[Tri[j].v[0]].p[j1],Node[Tri[j].v[0]].p[j2],
-					Node[Tri[j].v[1]].p[j1],Node[Tri[j].v[1]].p[j2]) < 0. ) continue;
-				if( side(Node[i].p[j1],          Node[i].p[j2],
-					Node[Tri[j].v[1]].p[j1],Node[Tri[j].v[1]].p[j2],
-					Node[Tri[j].v[2]].p[j1],Node[Tri[j].v[2]].p[j2]) < 0. ) continue;
-				if( side(Node[i].p[j1],          Node[i].p[j2],
-					Node[Tri[j].v[2]].p[j1],Node[Tri[j].v[2]].p[j2],
-					Node[Tri[j].v[0]].p[j1],Node[Tri[j].v[0]].p[j2]) < 0. ) continue;
+				if ( side( Node[i].p[j1],          Node[i].p[j2],
+						   Node[Tri[j].v[0]].p[j1],Node[Tri[j].v[0]].p[j2],
+						   Node[Tri[j].v[1]].p[j1],Node[Tri[j].v[1]].p[j2] ) < 0. ) {
+					continue;
+				}
+				if ( side( Node[i].p[j1],          Node[i].p[j2],
+						   Node[Tri[j].v[1]].p[j1],Node[Tri[j].v[1]].p[j2],
+						   Node[Tri[j].v[2]].p[j1],Node[Tri[j].v[2]].p[j2] ) < 0. ) {
+					continue;
+				}
+				if ( side( Node[i].p[j1],          Node[i].p[j2],
+						   Node[Tri[j].v[2]].p[j1],Node[Tri[j].v[2]].p[j2],
+						   Node[Tri[j].v[0]].p[j1],Node[Tri[j].v[0]].p[j2] ) < 0. ) {
+					continue;
+				}
 				Node[i].tri = j;
 			}
-			if(Node[i].tri < 0)
-			{
-                          /*
-				ghCursorCurrent = ghCursorDefault;
-				SetCursor(ghCursorCurrent);
-                          */
-				g_FuncTable.m_pfnMessageBox(g_pRadiantWnd,
-					"Error: Couldn't find the triangle bounding a point.",
-					"Decimation Error",MB_ICONEXCLAMATION, NULL);
+			if ( Node[i].tri < 0 ) {
+				/*
+				   ghCursorCurrent = ghCursorDefault;
+				   SetCursor(ghCursorCurrent);
+				 */
+				g_FuncTable.m_pfnMessageBox( g_pRadiantWnd,
+											 "Error: Couldn't find the triangle bounding a point.",
+											 "Decimation Error", eMB_OK, eMB_ICONWARNING );
 				return;
 			}
-			if(!Tri[Node[i].tri].flag)
-			{
-				PlaneFromPoints(Node[Tri[Node[i].tri].v[0]].p,
-					            Node[Tri[Node[i].tri].v[1]].p,
-				                Node[Tri[Node[i].tri].v[2]].p,
-				                &Tri[Node[i].tri].plane);
+			if ( !Tri[Node[i].tri].flag ) {
+				PlaneFromPoints( Node[Tri[Node[i].tri].v[0]].p,
+								 Node[Tri[Node[i].tri].v[1]].p,
+								 Node[Tri[Node[i].tri].v[2]].p,
+								 &Tri[Node[i].tri].plane );
 				Tri[Node[i].tri].flag = 1;
 			}
 			Node[i].error =
-				Node[i].p[j0] - (Tri[Node[i].tri].plane.dist -
-				Tri[Node[i].tri].plane.normal[j1]*Node[i].p[j1] -
-				Tri[Node[i].tri].plane.normal[j2]*Node[i].p[j2]  )/
+				Node[i].p[j0] - ( Tri[Node[i].tri].plane.dist -
+								  Tri[Node[i].tri].plane.normal[j1] * Node[i].p[j1] -
+								  Tri[Node[i].tri].plane.normal[j2] * Node[i].p[j2]  ) /
 				Tri[Node[i].tri].plane.normal[j0];
-			if(Absolute(Node[i].error) > 0.5)
-			{
+			if ( Absolute( Node[i].error ) > 0.5 ) {
 				NumNodesUsed++;
 				Node[i].used++;
-				free(Tri);
-				tricall(NumNodes[0], Node, NumTris, NULL, pTri, "cnzBNPY");
+				free( Tri );
+				tricall( NumNodes[0], Node, NumTris, NULL, pTri, "cnzBNPY" );
 				Tri = *pTri;
 			}
 		}
@@ -279,9 +298,8 @@ void MakeDecimatedMap(int *NumNodes, int *NumTris, NODE **pNode, TRI **pTri)
 	// Swap node orders for surfaces facing down, north or west so that
 	// they are counterclockwise when facing the surface
 
-	if((Plane == PLANE_XY1) || (Plane == PLANE_XZ0) || (Plane == PLANE_YZ1) )
-	{
-		for(i=0; i<NumTris[0]; i++)
+	if ( ( Plane == PLANE_XY1 ) || ( Plane == PLANE_XZ0 ) || ( Plane == PLANE_YZ1 ) ) {
+		for ( i = 0; i < NumTris[0]; i++ )
 		{
 			j = Tri[i].v[1];
 			Tri[i].v[1] = Tri[i].v[2];
@@ -290,31 +308,31 @@ void MakeDecimatedMap(int *NumNodes, int *NumTris, NODE **pNode, TRI **pTri)
 	}
 
 	// Store bounding box coords
-	for(i=0; i<NumTris[0]; i++)
+	for ( i = 0; i < NumTris[0]; i++ )
 	{
 		Tri[i].min[0] =                   Node[Tri[i].v[0]].p[0];
-		Tri[i].min[0] = min(Tri[i].min[0],Node[Tri[i].v[1]].p[0]);
-		Tri[i].min[0] = min(Tri[i].min[0],Node[Tri[i].v[2]].p[0]);
+		Tri[i].min[0] = min( Tri[i].min[0],Node[Tri[i].v[1]].p[0] );
+		Tri[i].min[0] = min( Tri[i].min[0],Node[Tri[i].v[2]].p[0] );
 		Tri[i].min[1] =                   Node[Tri[i].v[0]].p[1];
-		Tri[i].min[1] = min(Tri[i].min[1],Node[Tri[i].v[1]].p[1]);
-		Tri[i].min[1] = min(Tri[i].min[1],Node[Tri[i].v[2]].p[1]);
+		Tri[i].min[1] = min( Tri[i].min[1],Node[Tri[i].v[1]].p[1] );
+		Tri[i].min[1] = min( Tri[i].min[1],Node[Tri[i].v[2]].p[1] );
 		Tri[i].min[2] =                   Node[Tri[i].v[0]].p[2];
-		Tri[i].min[2] = min(Tri[i].min[2],Node[Tri[i].v[1]].p[2]);
-		Tri[i].min[2] = min(Tri[i].min[2],Node[Tri[i].v[2]].p[2]);
+		Tri[i].min[2] = min( Tri[i].min[2],Node[Tri[i].v[1]].p[2] );
+		Tri[i].min[2] = min( Tri[i].min[2],Node[Tri[i].v[2]].p[2] );
 		Tri[i].max[0] =                   Node[Tri[i].v[0]].p[0];
-		Tri[i].max[0] = max(Tri[i].max[0],Node[Tri[i].v[1]].p[0]);
-		Tri[i].max[0] = max(Tri[i].max[0],Node[Tri[i].v[2]].p[0]);
+		Tri[i].max[0] = max( Tri[i].max[0],Node[Tri[i].v[1]].p[0] );
+		Tri[i].max[0] = max( Tri[i].max[0],Node[Tri[i].v[2]].p[0] );
 		Tri[i].max[1] =                   Node[Tri[i].v[0]].p[1];
-		Tri[i].max[1] = max(Tri[i].max[1],Node[Tri[i].v[1]].p[1]);
-		Tri[i].max[1] = max(Tri[i].max[1],Node[Tri[i].v[2]].p[1]);
+		Tri[i].max[1] = max( Tri[i].max[1],Node[Tri[i].v[1]].p[1] );
+		Tri[i].max[1] = max( Tri[i].max[1],Node[Tri[i].v[2]].p[1] );
 		Tri[i].max[2] =                   Node[Tri[i].v[0]].p[2];
-		Tri[i].max[2] = max(Tri[i].max[2],Node[Tri[i].v[1]].p[2]);
-		Tri[i].max[2] = max(Tri[i].max[2],Node[Tri[i].v[2]].p[2]);
+		Tri[i].max[2] = max( Tri[i].max[2],Node[Tri[i].v[1]].p[2] );
+		Tri[i].max[2] = max( Tri[i].max[2],Node[Tri[i].v[2]].p[2] );
 	}
-        /*
-	ghCursorCurrent = ghCursorDefault;
-	SetCursor(ghCursorCurrent);
-        */
+	/*
+	   ghCursorCurrent = ghCursorDefault;
+	   SetCursor(ghCursorCurrent);
+	 */
 }
 /* end MakeDecimatedMap */
 
@@ -323,47 +341,46 @@ void MakeDecimatedMap(int *NumNodes, int *NumTris, NODE **pNode, TRI **pTri)
 /*  tricall Takes an array of nodes, spits out an array of triangles         */
 /*                                                                           */
 /*****************************************************************************/
-int tricall(int NumNodes, NODE *Node, int *NumTris, TRI **inTri, TRI **Tri, LPSTR Options)
-{
-
+int tricall( int NumNodes, NODE *Node, int *NumTris, TRI **inTri, TRI **Tri, const char *Options ){
 	struct triangulateio in, out;
-	int    i, N;
-	int    NumUsedNodes;
+	int i, N;
+	int NumUsedNodes;
 	int    *NodeTable;
 	TRI    *ptri;
 
 	/* Define input points. */
 
-	for(i=0,NumUsedNodes=0; i<NumNodes; i++)
-		if(Node[i].used) NumUsedNodes++;
+	for ( i = 0,NumUsedNodes = 0; i < NumNodes; i++ )
+		if ( Node[i].used ) {
+			NumUsedNodes++;
+		}
 
-	memset(&in, 0,sizeof(in));
-	memset(&out,0,sizeof(out));
+	memset( &in, 0,sizeof( in ) );
+	memset( &out,0,sizeof( out ) );
 
-	NodeTable = (int *) malloc(NumUsedNodes * sizeof(int));
+	NodeTable = (int *) malloc( NumUsedNodes * sizeof( int ) );
 
 	in.numberofpoints = NumUsedNodes;
 	in.numberofpointattributes = 0;
-	in.pointlist = (REAL *) malloc(in.numberofpoints * 2 * sizeof(REAL));
-	for(i=0,N=0; i<NumNodes; i++)
+	in.pointlist = (REAL *) malloc( in.numberofpoints * 2 * sizeof( REAL ) );
+	for ( i = 0,N = 0; i < NumNodes; i++ )
 	{
-		if(Node[i].used)
-		{
-			switch(Plane)
+		if ( Node[i].used ) {
+			switch ( Plane )
 			{
 			case PLANE_XZ0:
 			case PLANE_XZ1:
-				in.pointlist[N*2  ] = Node[i].p[0];
-				in.pointlist[N*2+1] = Node[i].p[2];
+				in.pointlist[N * 2  ] = Node[i].p[0];
+				in.pointlist[N * 2 + 1] = Node[i].p[2];
 				break;
 			case PLANE_YZ0:
 			case PLANE_YZ1:
-				in.pointlist[N*2  ] = Node[i].p[1];
-				in.pointlist[N*2+1] = Node[i].p[2];
+				in.pointlist[N * 2  ] = Node[i].p[1];
+				in.pointlist[N * 2 + 1] = Node[i].p[2];
 				break;
 			default:
-				in.pointlist[N*2  ] = Node[i].p[0];
-				in.pointlist[N*2+1] = Node[i].p[1];
+				in.pointlist[N * 2  ] = Node[i].p[0];
+				in.pointlist[N * 2 + 1] = Node[i].p[1];
 			}
 			NodeTable[N] = i;
 			N++;
@@ -372,14 +389,12 @@ int tricall(int NumNodes, NODE *Node, int *NumTris, TRI **inTri, TRI **Tri, LPST
 	in.pointattributelist = (REAL *) NULL;
 	in.pointmarkerlist    = (int *) NULL;
 
-	if(strstr(Options,"r"))
-	{
+	if ( strstr( Options,"r" ) ) {
 		int    *TriTable;
-		TriTable = (int *) malloc(NumNodes * sizeof(int));
-		for(i=0,N=0; i<NumNodes; i++)
+		TriTable = (int *) malloc( NumNodes * sizeof( int ) );
+		for ( i = 0,N = 0; i < NumNodes; i++ )
 		{
-			if(Node[i].used)
-			{
+			if ( Node[i].used ) {
 				TriTable[i] = N;
 				N++;
 			}
@@ -387,17 +402,17 @@ int tricall(int NumNodes, NODE *Node, int *NumTris, TRI **inTri, TRI **Tri, LPST
 		in.numberoftriangles          = NumTris[0];
 		in.numberofcorners            = 3;
 		in.numberoftriangleattributes = 0;
-		in.trianglelist               = (int *) malloc(in.numberofcorners * in.numberoftriangles * sizeof(int));
+		in.trianglelist               = (int *) malloc( in.numberofcorners * in.numberoftriangles * sizeof( int ) );
 		in.triangleattributelist      = (REAL *) NULL;
 		in.trianglearealist           = (REAL *) NULL;
 		ptri = *inTri;
-		for(i=0; i<in.numberoftriangles; i++)
+		for ( i = 0; i < in.numberoftriangles; i++ )
 		{
-			in.trianglelist[i*in.numberofcorners  ] = TriTable[ptri[i].v[0]];
-			in.trianglelist[i*in.numberofcorners+1] = TriTable[ptri[i].v[1]];
-			in.trianglelist[i*in.numberofcorners+2] = TriTable[ptri[i].v[2]];
+			in.trianglelist[i * in.numberofcorners  ] = TriTable[ptri[i].v[0]];
+			in.trianglelist[i * in.numberofcorners + 1] = TriTable[ptri[i].v[1]];
+			in.trianglelist[i * in.numberofcorners + 2] = TriTable[ptri[i].v[2]];
 		}
-		free(TriTable);
+		free( TriTable );
 	}
 	else
 	{
@@ -426,166 +441,226 @@ int tricall(int NumNodes, NODE *Node, int *NumTris, TRI **inTri, TRI **Tri, LPST
 
 	/* Make necessary initializations */
 	out.pointlist          = (REAL *) NULL;  /* Not needed if -N switch used. */
-	out.pointattributelist = (REAL *) NULL;  /* Not needed if -N switch used or 
+	out.pointattributelist = (REAL *) NULL;  /* Not needed if -N switch used or
 	                                            number of point attributes is zero: */
 	out.pointmarkerlist    = (int *) NULL;   /* Not needed if -N or -B switch used. */
 	out.trianglelist       = (int *) NULL;   /* Not needed if -E switch used. */
-	out.triangleattributelist = (REAL *) NULL;   /* Not needed if -E switch used or 
-	                                                number of triangle attributes is 
-                                                    zero: */
+	out.triangleattributelist = (REAL *) NULL;   /* Not needed if -E switch used or
+	                                                number of triangle attributes is
+	                                                zero: */
 	out.trianglearealist   = (REAL *) NULL;
 	out.neighborlist       = (int *) NULL;   /* Needed only if -n switch used. */
-	out.segmentlist        = (int *) NULL;   /* Needed only if segments are output 
+	out.segmentlist        = (int *) NULL;   /* Needed only if segments are output
 	                                            (-p or -c) and -P not used: */
-	out.segmentmarkerlist  = (int *) NULL;   /* Needed only if segments are output 
+	out.segmentmarkerlist  = (int *) NULL;   /* Needed only if segments are output
 	                                            (-p or -c) and -P and -B not used: */
 	out.edgelist           = (int *) NULL;   /* Needed only if -e switch used. */
 	out.edgemarkerlist     = (int *) NULL;   /* Needed if -e used and -B not used. */
 
-	triangulate(Options, &in, &out, NULL);
+	triangulate( Options, &in, &out, NULL );
 
 	NumTris[0] = out.numberoftriangles;
-	*Tri = (TRI *) malloc(NumTris[0] * sizeof(TRI));
+	*Tri = (TRI *) malloc( NumTris[0] * sizeof( TRI ) );
 	ptri = *Tri;
 
-	for(i=0; i<NumTris[0]; i++)
+	for ( i = 0; i < NumTris[0]; i++ )
 	{
-		ptri[i].v[0] = NodeTable[out.trianglelist[i*out.numberofcorners  ]];
-		ptri[i].v[1] = NodeTable[out.trianglelist[i*out.numberofcorners+1]];
-		ptri[i].v[2] = NodeTable[out.trianglelist[i*out.numberofcorners+2]];
-		ptri[i].n[0] = out.neighborlist[i*3  ];
-		ptri[i].n[1] = out.neighborlist[i*3+1];
-		ptri[i].n[2] = out.neighborlist[i*3+2];
+		ptri[i].v[0] = NodeTable[out.trianglelist[i * out.numberofcorners  ]];
+		ptri[i].v[1] = NodeTable[out.trianglelist[i * out.numberofcorners + 1]];
+		ptri[i].v[2] = NodeTable[out.trianglelist[i * out.numberofcorners + 2]];
+		ptri[i].n[0] = out.neighborlist[i * 3  ];
+		ptri[i].n[1] = out.neighborlist[i * 3 + 1];
+		ptri[i].n[2] = out.neighborlist[i * 3 + 2];
 	}
 
 	/* Free all allocated arrays, including those allocated by Triangle. */
-	if(in.pointlist)              free(in.pointlist);
-	if(in.pointattributelist)     free(in.pointattributelist);
-	if(in.pointmarkerlist)        free(in.pointmarkerlist);
-	if(in.trianglelist)           free(in.trianglelist);
-	if(in.triangleattributelist)  free(in.triangleattributelist);
-	if(in.trianglearealist)       free(in.trianglearealist);
-	if(in.neighborlist)           free(in.neighborlist);
-	if(in.segmentlist)            free(in.segmentlist);
-	if(in.segmentmarkerlist)      free(in.segmentmarkerlist);
-	if(in.holelist)               free(in.holelist);
-	if(in.regionlist)             free(in.regionlist);
-	if(in.edgelist)               free(in.edgelist);
-	if(in.edgemarkerlist)         free(in.edgemarkerlist);
-	if(in.normlist)               free(in.normlist);
-	if(out.pointlist)             free(out.pointlist);
-	if(out.pointattributelist)    free(out.pointattributelist);
-	if(out.pointmarkerlist)       free(out.pointmarkerlist);
-	if(out.trianglelist)          free(out.trianglelist);
-	if(out.triangleattributelist) free(out.triangleattributelist);
-	if(out.trianglearealist)      free(out.trianglearealist);
-	if(out.neighborlist)          free(out.neighborlist);
-	if(out.segmentlist)           free(out.segmentlist);
-	if(out.segmentmarkerlist)     free(out.segmentmarkerlist);
-	if(out.holelist)              free(out.holelist);
-	if(out.regionlist)            free(out.regionlist);
-	if(out.edgelist)              free(out.edgelist);
-	if(out.edgemarkerlist)        free(out.edgemarkerlist);
-	if(out.normlist)              free(out.normlist);
-
-	free(NodeTable);
+	if ( in.pointlist ) {
+		free( in.pointlist );
+	}
+	if ( in.pointattributelist ) {
+		free( in.pointattributelist );
+	}
+	if ( in.pointmarkerlist ) {
+		free( in.pointmarkerlist );
+	}
+	if ( in.trianglelist ) {
+		free( in.trianglelist );
+	}
+	if ( in.triangleattributelist ) {
+		free( in.triangleattributelist );
+	}
+	if ( in.trianglearealist ) {
+		free( in.trianglearealist );
+	}
+	if ( in.neighborlist ) {
+		free( in.neighborlist );
+	}
+	if ( in.segmentlist ) {
+		free( in.segmentlist );
+	}
+	if ( in.segmentmarkerlist ) {
+		free( in.segmentmarkerlist );
+	}
+	if ( in.holelist ) {
+		free( in.holelist );
+	}
+	if ( in.regionlist ) {
+		free( in.regionlist );
+	}
+	if ( in.edgelist ) {
+		free( in.edgelist );
+	}
+	if ( in.edgemarkerlist ) {
+		free( in.edgemarkerlist );
+	}
+	if ( in.normlist ) {
+		free( in.normlist );
+	}
+	if ( out.pointlist ) {
+		free( out.pointlist );
+	}
+	if ( out.pointattributelist ) {
+		free( out.pointattributelist );
+	}
+	if ( out.pointmarkerlist ) {
+		free( out.pointmarkerlist );
+	}
+	if ( out.trianglelist ) {
+		free( out.trianglelist );
+	}
+	if ( out.triangleattributelist ) {
+		free( out.triangleattributelist );
+	}
+	if ( out.trianglearealist ) {
+		free( out.trianglearealist );
+	}
+	if ( out.neighborlist ) {
+		free( out.neighborlist );
+	}
+	if ( out.segmentlist ) {
+		free( out.segmentlist );
+	}
+	if ( out.segmentmarkerlist ) {
+		free( out.segmentmarkerlist );
+	}
+	if ( out.holelist ) {
+		free( out.holelist );
+	}
+	if ( out.regionlist ) {
+		free( out.regionlist );
+	}
+	if ( out.edgelist ) {
+		free( out.edgelist );
+	}
+	if ( out.edgemarkerlist ) {
+		free( out.edgemarkerlist );
+	}
+	if ( out.normlist ) {
+		free( out.normlist );
+	}
+
+	free( NodeTable );
 	return 0;
 }
 
-void EdgeOnSide(int *v, int *edge, int *border)
-{
+void EdgeOnSide( int *v, int *edge, int *border ){
 	int R;
 	int k0, k1, N;
 	float Ndv;
 
 	border[0] = -1;
 
-	if( (v[0] <= NV) && (v[1] <= NV) )
-	{
+	if ( ( v[0] <= NV ) && ( v[1] <= NV ) ) {
 		edge[0]   = 0;
 		border[0] = 0;
 	}
-	if( (v[1] <= NV) && (v[2] <= NV) )
-	{
+	if ( ( v[1] <= NV ) && ( v[2] <= NV ) ) {
 		edge[0]   = 1;
 		border[0] = 0;
 	}
-	if( (v[2] <= NV) && (v[0] <= NV) )
-	{
+	if ( ( v[2] <= NV ) && ( v[0] <= NV ) ) {
 		edge[0]   = 2;
 		border[0] = 0;
 	}
 
-	R = NH*NVP1;
+	R = NH * NVP1;
 
-	if( (v[0] >= R) && (v[1] >= R) )
-	{
+	if ( ( v[0] >= R ) && ( v[1] >= R ) ) {
 		edge[0]   = 0;
 		border[0] = 1;
 	}
-	if( (v[1] >= R) && (v[2] >= R) )
-	{
+	if ( ( v[1] >= R ) && ( v[2] >= R ) ) {
 		edge[0]   = 1;
 		border[0] = 1;
 	}
-	if( (v[2] >= R) && (v[0] >= R) )
-	{
+	if ( ( v[2] >= R ) && ( v[0] >= R ) ) {
 		edge[0]   = 2;
 		border[0] = 1;
 	}
 
-	if(border[0] >= 0)
-	{
+	if ( border[0] >= 0 ) {
 		k0  = edge[0];
-		k1  = (k0+1) % 3;
-		N   = Absolute(v[k0] - v[k1]);
-		Ndv = (float)(N*dv);
+		k1  = ( k0 + 1 ) % 3;
+		N   = Absolute( v[k0] - v[k1] );
+		Ndv = (float)( N * dv );
 	}
-	if( ((v[0] % NVP1) == 0)  && ((v[1] % NVP1) == 0) )
-	{
-		if(border[0] >= 0)
-			if( Ndv > (Absolute(v[0] - v[1])*dh)) return;
+	if ( ( ( v[0] % NVP1 ) == 0 )  && ( ( v[1] % NVP1 ) == 0 ) ) {
+		if ( border[0] >= 0 ) {
+			if ( Ndv > ( Absolute( v[0] - v[1] ) * dh ) ) {
+				return;
+			}
+		}
 		edge[0]   = 0;
 		border[0] = 2;
 		return;
 	}
-	if( ((v[1] % NVP1) == 0)  && ((v[2] % NVP1) == 0) )
-	{
-		if(border[0] >= 0)
-			if( Ndv > (Absolute(v[1] - v[2])*dh)) return;
+	if ( ( ( v[1] % NVP1 ) == 0 )  && ( ( v[2] % NVP1 ) == 0 ) ) {
+		if ( border[0] >= 0 ) {
+			if ( Ndv > ( Absolute( v[1] - v[2] ) * dh ) ) {
+				return;
+			}
+		}
 		edge[0]   = 1;
 		border[0] = 2;
 		return;
 	}
-	if( ((v[2] % NVP1) == 0)  && ((v[0] % NVP1) == 0) )
-	{
-		if(border[0] >= 0)
-			if( Ndv > (Absolute(v[2] - v[0])*dh)) return;
+	if ( ( ( v[2] % NVP1 ) == 0 )  && ( ( v[0] % NVP1 ) == 0 ) ) {
+		if ( border[0] >= 0 ) {
+			if ( Ndv > ( Absolute( v[2] - v[0] ) * dh ) ) {
+				return;
+			}
+		}
 		edge[0]   = 2;
 		border[0] = 2;
 		return;
 	}
 
-	if( ((v[0] % NVP1) == NV) && ((v[1] % NVP1) == NV) )
-	{
-		if(border[0] >= 0)
-			if( Ndv > (Absolute(v[0] - v[1])*dh)) return;
+	if ( ( ( v[0] % NVP1 ) == NV ) && ( ( v[1] % NVP1 ) == NV ) ) {
+		if ( border[0] >= 0 ) {
+			if ( Ndv > ( Absolute( v[0] - v[1] ) * dh ) ) {
+				return;
+			}
+		}
 		edge[0]   = 0;
 		border[0] = 3;
 		return;
 	}
-	if( ((v[1] % NVP1) == NV) && ((v[2] % NVP1) == NV) )
-	{
-		if(border[0] >= 0)
-			if( Ndv > (Absolute(v[1] - v[2])*dh)) return;
+	if ( ( ( v[1] % NVP1 ) == NV ) && ( ( v[2] % NVP1 ) == NV ) ) {
+		if ( border[0] >= 0 ) {
+			if ( Ndv > ( Absolute( v[1] - v[2] ) * dh ) ) {
+				return;
+			}
+		}
 		edge[0]   = 1;
 		border[0] = 3;
 		return;
 	}
-	if( ((v[2] % NVP1) == NV) && ((v[0] % NVP1) == NV) )
-	{
-		if(border[0] >= 0)
-			if( Ndv > (Absolute(v[2] - v[0])*dh)) return;
+	if ( ( ( v[2] % NVP1 ) == NV ) && ( ( v[0] % NVP1 ) == NV ) ) {
+		if ( border[0] >= 0 ) {
+			if ( Ndv > ( Absolute( v[2] - v[0] ) * dh ) ) {
+				return;
+			}
+		}
 		edge[0]   = 2;
 		border[0] = 3;
 		return;
@@ -593,15 +668,14 @@ void EdgeOnSide(int *v, int *edge, int *border)
 	return;
 }
 
-void CalcAngles(NODE *node, int *v, float *angle)
-{
+void CalcAngles( NODE *node, int *v, float *angle ){
 	int i, j, k;
 	vec l;
 	vec x0, x1, x2, y0, y1, y2;
 	vec2 vv[3];
 	vec dot;
 
-	switch(Plane)
+	switch ( Plane )
 	{
 	case PLANE_XZ0:
 	case PLANE_XZ1:
@@ -624,100 +698,104 @@ void CalcAngles(NODE *node, int *v, float *angle)
 	y1 = node[v[1]].p[j];
 	y2 = node[v[2]].p[j];
 
-	vv[0][0] = x1-x0;
-	vv[0][1] = y1-y0;
-	vv[1][0] = x2-x1;
-	vv[1][1] = y2-y1;
-	vv[2][0] = x0-x2;
-	vv[2][1] = y0-y2;
+	vv[0][0] = x1 - x0;
+	vv[0][1] = y1 - y0;
+	vv[1][0] = x2 - x1;
+	vv[1][1] = y2 - y1;
+	vv[2][0] = x0 - x2;
+	vv[2][1] = y0 - y2;
 
-	for(k=0; k<3; k++)
+	for ( k = 0; k < 3; k++ )
 	{
-		l = (vec)(sqrt( vv[k][0]*vv[k][0] + vv[k][1]*vv[k][1] ));
-		if(l > 0.)
-		{
+		l = (vec)( sqrt( vv[k][0] * vv[k][0] + vv[k][1] * vv[k][1] ) );
+		if ( l > 0. ) {
 			vv[k][0] /= l;
 			vv[k][1] /= l;
 		}
 	}
 
-	dot = -(vv[0][0]*vv[2][0] + vv[0][1]*vv[2][1]);
-	angle[0] = (float)(acos(dot));
-	dot = -(vv[1][0]*vv[0][0] + vv[1][1]*vv[0][1]);
-	angle[1] = (float)(acos(dot));
-	dot = -(vv[2][0]*vv[1][0] + vv[2][1]*vv[1][1]);
-	angle[2] = (float)(acos(dot));
+	dot = -( vv[0][0] * vv[2][0] + vv[0][1] * vv[2][1] );
+	angle[0] = (float)( acos( dot ) );
+	dot = -( vv[1][0] * vv[0][0] + vv[1][1] * vv[0][1] );
+	angle[1] = (float)( acos( dot ) );
+	dot = -( vv[2][0] * vv[1][0] + vv[2][1] * vv[1][1] );
+	angle[2] = (float)( acos( dot ) );
 }
 //=================================================================
-int Bisect(NODE *node, int border, int j0, int j1)
-{
+int Bisect( NODE *node, int border, int j0, int j1 ){
 	int k;
 
-	switch(border)
+	switch ( border )
 	{
 	case 0:
-		k = (j0+j1)/2;
+		k = ( j0 + j1 ) / 2;
 		break;
 	case 1:
-		k = (j0+j1)/2;
+		k = ( j0 + j1 ) / 2;
 		break;
 	case 2:
-		k = (int)((j0+j1)/(2*NVP1)) * NVP1;
+		k = (int)( ( j0 + j1 ) / ( 2 * NVP1 ) ) * NVP1;
 		break;
 	case 3:
-		k = (int)((j0+j1+2)/(2*NVP1)) * NVP1 - 1;
+		k = (int)( ( j0 + j1 + 2 ) / ( 2 * NVP1 ) ) * NVP1 - 1;
 		break;
 	}
-	return( ((k != j0) && (k != j1)) ? k : 0 );
+	return( ( ( k != j0 ) && ( k != j1 ) ) ? k : 0 );
 }
 //=================================================================
-int compare(TRITABLE *t1, TRITABLE *t2)
-{
-	if(t1->error > t2->error) return -1;
-	if(t1->error < t2->error) return  1;
+int compare( TRITABLE *t1, TRITABLE *t2 ){
+	if ( t1->error > t2->error ) {
+		return -1;
+	}
+	if ( t1->error < t2->error ) {
+		return 1;
+	}
 	return 0;
 }
 
-void MakeBrushes(int NumTris, NODE *Node, TRI *Tri,bool surf,
-				 int offset,char *texture0, char *texture1, char *texture2)
-{
+void MakeBrushes( int NumTris, NODE *Node, TRI *Tri,bool surf,
+				  int offset,char *texture0, char *texture1, char *texture2 ){
 	extern double backface;
-	BRUSH	brush;
-	int		contents;
-	int		i, j;
-	float	Steep;
-	vec3_t	PlaneNormal,SurfNormal;
-	bool	CheckAngle;
-	vec3_t	t[2];
+	BRUSH brush;
+	int contents;
+	int i, j;
+	float Steep;
+	vec3_t PlaneNormal,SurfNormal;
+	bool CheckAngle;
+	vec3_t t[2];
 
 	// if texture2 is identical to texture0, there's no need to
 	// check surface angle
-	if(!g_strcasecmp(texture0,texture2) || !strlen(texture2))
+	if ( !g_strcasecmp( texture0,texture2 ) || !strlen( texture2 ) ) {
 		CheckAngle = FALSE;
+	}
 	else
 	{
 		CheckAngle = TRUE;
-		Steep = (float)cos((double)SlantAngle/57.2957795);
-		switch(Plane)
+		Steep = (float)cos( (double)SlantAngle / 57.2957795 );
+		switch ( Plane )
 		{
-		case PLANE_XY0: PlaneNormal[0]= 0.;PlaneNormal[1]= 0.;PlaneNormal[2]= 1.;break;
-		case PLANE_XY1: PlaneNormal[0]= 0.;PlaneNormal[1]= 0.;PlaneNormal[2]=-1.;break;
-		case PLANE_XZ0: PlaneNormal[0]= 0.;PlaneNormal[1]= 1.;PlaneNormal[2]= 1.;break;
-		case PLANE_XZ1: PlaneNormal[0]= 0.;PlaneNormal[1]=-1.;PlaneNormal[2]= 1.;break;
-		case PLANE_YZ0: PlaneNormal[0]= 1.;PlaneNormal[1]= 0.;PlaneNormal[2]= 1.;break;
-		case PLANE_YZ1: PlaneNormal[0]=-1.;PlaneNormal[1]= 0.;PlaneNormal[2]= 1.;break;
+		case PLANE_XY0: PlaneNormal[0] = 0.; PlaneNormal[1] = 0.; PlaneNormal[2] = 1.; break;
+		case PLANE_XY1: PlaneNormal[0] = 0.; PlaneNormal[1] = 0.; PlaneNormal[2] = -1.; break;
+		case PLANE_XZ0: PlaneNormal[0] = 0.; PlaneNormal[1] = 1.; PlaneNormal[2] = 1.; break;
+		case PLANE_XZ1: PlaneNormal[0] = 0.; PlaneNormal[1] = -1.; PlaneNormal[2] = 1.; break;
+		case PLANE_YZ0: PlaneNormal[0] = 1.; PlaneNormal[1] = 0.; PlaneNormal[2] = 1.; break;
+		case PLANE_YZ1: PlaneNormal[0] = -1.; PlaneNormal[1] = 0.; PlaneNormal[2] = 1.; break;
 		}
 	}
 
 	contents = 0;
-	if(surf)
-	{
-		if(UseDetail) contents += CONTENTS_DETAIL;
-		if(UseLadder) contents += CONTENTS_LADDER;
+	if ( surf ) {
+		if ( UseDetail ) {
+			contents += CONTENTS_DETAIL;
+		}
+		if ( UseLadder ) {
+			contents += CONTENTS_LADDER;
+		}
 	}
-	
+
 	OpenFuncGroup();
-	for(i=0; i<NumTris; i++)
+	for ( i = 0; i < NumTris; i++ )
 	{
 		brush.Number   = i;
 		brush.NumFaces = 5;
@@ -725,18 +803,17 @@ void MakeBrushes(int NumTris, NODE *Node, TRI *Tri,bool surf,
 		brush.face[0].v[0][0] = Node[Tri[i].v[0]].p[0];
 		brush.face[0].v[0][1] = Node[Tri[i].v[0]].p[1];
 		brush.face[0].v[0][2] = Node[Tri[i].v[0]].p[2];
-		
+
 		brush.face[0].v[1][0] = Node[Tri[i].v[2]].p[0];
 		brush.face[0].v[1][1] = Node[Tri[i].v[2]].p[1];
 		brush.face[0].v[1][2] = Node[Tri[i].v[2]].p[2];
-		
+
 		brush.face[0].v[2][0] = Node[Tri[i].v[1]].p[0];
 		brush.face[0].v[2][1] = Node[Tri[i].v[1]].p[1];
 		brush.face[0].v[2][2] = Node[Tri[i].v[1]].p[2];
 
-		if(offset != 0)
-		{
-			switch(Plane)
+		if ( offset != 0 ) {
+			switch ( Plane )
 			{
 			case PLANE_XY0:
 				brush.face[0].v[0][2] += offset;
@@ -770,7 +847,7 @@ void MakeBrushes(int NumTris, NODE *Node, TRI *Tri,bool surf,
 				break;
 			}
 		}
-		switch(Plane)
+		switch ( Plane )
 		{
 		case PLANE_XZ0:
 		case PLANE_XZ1:
@@ -778,50 +855,50 @@ void MakeBrushes(int NumTris, NODE *Node, TRI *Tri,bool surf,
 			brush.face[1].v[0][0] = Node[Tri[i].v[0]].p[0];
 			brush.face[1].v[0][1] = (float)backface;
 			brush.face[1].v[0][2] = Node[Tri[i].v[0]].p[2];
-			
+
 			brush.face[1].v[1][0] = Node[Tri[i].v[1]].p[0];
 			brush.face[1].v[1][1] = (float)backface;
 			brush.face[1].v[1][2] = Node[Tri[i].v[1]].p[2];
-			
+
 			brush.face[1].v[2][0] = Node[Tri[i].v[2]].p[0];
 			brush.face[1].v[2][1] = (float)backface;
 			brush.face[1].v[2][2] = Node[Tri[i].v[2]].p[2];
-			
+
 			// 0-1 side
 			brush.face[2].v[0][0] = Node[Tri[i].v[0]].p[0];
 			brush.face[2].v[0][1] = Node[Tri[i].v[0]].p[1];
 			brush.face[2].v[0][2] = Node[Tri[i].v[0]].p[2];
-			
+
 			brush.face[2].v[1][0] = Node[Tri[i].v[1]].p[0];
 			brush.face[2].v[1][1] = Node[Tri[i].v[1]].p[1];
 			brush.face[2].v[1][2] = Node[Tri[i].v[1]].p[2];
-			
+
 			brush.face[2].v[2][0] = Node[Tri[i].v[1]].p[0];
 			brush.face[2].v[2][1] = (float)backface;
 			brush.face[2].v[2][2] = Node[Tri[i].v[1]].p[2];
-			
+
 			// 1-2 side
 			brush.face[3].v[0][0] = Node[Tri[i].v[1]].p[0];
 			brush.face[3].v[0][1] = Node[Tri[i].v[1]].p[1];
 			brush.face[3].v[0][2] = Node[Tri[i].v[1]].p[2];
-			
+
 			brush.face[3].v[1][0] = Node[Tri[i].v[2]].p[0];
 			brush.face[3].v[1][1] = Node[Tri[i].v[2]].p[1];
 			brush.face[3].v[1][2] = Node[Tri[i].v[2]].p[2];
-			
+
 			brush.face[3].v[2][0] = Node[Tri[i].v[2]].p[0];
 			brush.face[3].v[2][1] = (float)backface;
 			brush.face[3].v[2][2] = Node[Tri[i].v[2]].p[2];
-			
+
 			// 2-0 side
 			brush.face[4].v[0][0] = Node[Tri[i].v[2]].p[0];
 			brush.face[4].v[0][1] = Node[Tri[i].v[2]].p[1];
 			brush.face[4].v[0][2] = Node[Tri[i].v[2]].p[2];
-			
+
 			brush.face[4].v[1][0] = Node[Tri[i].v[0]].p[0];
 			brush.face[4].v[1][1] = Node[Tri[i].v[0]].p[1];
 			brush.face[4].v[1][2] = Node[Tri[i].v[0]].p[2];
-			
+
 			brush.face[4].v[2][0] = Node[Tri[i].v[0]].p[0];
 			brush.face[4].v[2][1] = (float)backface;
 			brush.face[4].v[2][2] = Node[Tri[i].v[0]].p[2];
@@ -832,50 +909,50 @@ void MakeBrushes(int NumTris, NODE *Node, TRI *Tri,bool surf,
 			brush.face[1].v[0][0] = (float)backface;
 			brush.face[1].v[0][1] = Node[Tri[i].v[0]].p[1];
 			brush.face[1].v[0][2] = Node[Tri[i].v[0]].p[2];
-			
+
 			brush.face[1].v[1][0] = (float)backface;
 			brush.face[1].v[1][1] = Node[Tri[i].v[1]].p[1];
 			brush.face[1].v[1][2] = Node[Tri[i].v[1]].p[2];
-			
+
 			brush.face[1].v[2][0] = (float)backface;
 			brush.face[1].v[2][1] = Node[Tri[i].v[2]].p[1];
 			brush.face[1].v[2][2] = Node[Tri[i].v[2]].p[2];
-			
+
 			// 0-1 side
 			brush.face[2].v[0][0] = Node[Tri[i].v[0]].p[0];
 			brush.face[2].v[0][1] = Node[Tri[i].v[0]].p[1];
 			brush.face[2].v[0][2] = Node[Tri[i].v[0]].p[2];
-			
+
 			brush.face[2].v[1][0] = Node[Tri[i].v[1]].p[0];
 			brush.face[2].v[1][1] = Node[Tri[i].v[1]].p[1];
 			brush.face[2].v[1][2] = Node[Tri[i].v[1]].p[2];
-			
+
 			brush.face[2].v[2][0] = (float)backface;
 			brush.face[2].v[2][1] = Node[Tri[i].v[1]].p[1];
 			brush.face[2].v[2][2] = Node[Tri[i].v[1]].p[2];
-			
+
 			// 1-2 side
 			brush.face[3].v[0][0] = Node[Tri[i].v[1]].p[0];
 			brush.face[3].v[0][1] = Node[Tri[i].v[1]].p[1];
 			brush.face[3].v[0][2] = Node[Tri[i].v[1]].p[2];
-			
+
 			brush.face[3].v[1][0] = Node[Tri[i].v[2]].p[0];
 			brush.face[3].v[1][1] = Node[Tri[i].v[2]].p[1];
 			brush.face[3].v[1][2] = Node[Tri[i].v[2]].p[2];
-			
+
 			brush.face[3].v[2][0] = (float)backface;
 			brush.face[3].v[2][1] = Node[Tri[i].v[2]].p[1];
 			brush.face[3].v[2][2] = Node[Tri[i].v[2]].p[2];
-			
+
 			// 2-0 side
 			brush.face[4].v[0][0] = Node[Tri[i].v[2]].p[0];
 			brush.face[4].v[0][1] = Node[Tri[i].v[2]].p[1];
 			brush.face[4].v[0][2] = Node[Tri[i].v[2]].p[2];
-			
+
 			brush.face[4].v[1][0] = Node[Tri[i].v[0]].p[0];
 			brush.face[4].v[1][1] = Node[Tri[i].v[0]].p[1];
 			brush.face[4].v[1][2] = Node[Tri[i].v[0]].p[2];
-			
+
 			brush.face[4].v[2][0] = (float)backface;
 			brush.face[4].v[2][1] = Node[Tri[i].v[0]].p[1];
 			brush.face[4].v[2][2] = Node[Tri[i].v[0]].p[2];
@@ -885,178 +962,182 @@ void MakeBrushes(int NumTris, NODE *Node, TRI *Tri,bool surf,
 			brush.face[1].v[0][0] = Node[Tri[i].v[0]].p[0];
 			brush.face[1].v[0][1] = Node[Tri[i].v[0]].p[1];
 			brush.face[1].v[0][2] = (float)backface;
-			
+
 			brush.face[1].v[1][0] = Node[Tri[i].v[1]].p[0];
 			brush.face[1].v[1][1] = Node[Tri[i].v[1]].p[1];
 			brush.face[1].v[1][2] = (float)backface;
-			
+
 			brush.face[1].v[2][0] = Node[Tri[i].v[2]].p[0];
 			brush.face[1].v[2][1] = Node[Tri[i].v[2]].p[1];
 			brush.face[1].v[2][2] = (float)backface;
-			
+
 			// 0-1 side
 			brush.face[2].v[0][0] = Node[Tri[i].v[0]].p[0];
 			brush.face[2].v[0][1] = Node[Tri[i].v[0]].p[1];
 			brush.face[2].v[0][2] = Node[Tri[i].v[0]].p[2];
-			
+
 			brush.face[2].v[1][0] = Node[Tri[i].v[1]].p[0];
 			brush.face[2].v[1][1] = Node[Tri[i].v[1]].p[1];
 			brush.face[2].v[1][2] = Node[Tri[i].v[1]].p[2];
-			
+
 			brush.face[2].v[2][0] = Node[Tri[i].v[1]].p[0];
 			brush.face[2].v[2][1] = Node[Tri[i].v[1]].p[1];
 			brush.face[2].v[2][2] = (float)backface;
-			
+
 			// 1-2 side
 			brush.face[3].v[0][0] = Node[Tri[i].v[1]].p[0];
 			brush.face[3].v[0][1] = Node[Tri[i].v[1]].p[1];
 			brush.face[3].v[0][2] = Node[Tri[i].v[1]].p[2];
-			
+
 			brush.face[3].v[1][0] = Node[Tri[i].v[2]].p[0];
 			brush.face[3].v[1][1] = Node[Tri[i].v[2]].p[1];
 			brush.face[3].v[1][2] = Node[Tri[i].v[2]].p[2];
-			
+
 			brush.face[3].v[2][0] = Node[Tri[i].v[2]].p[0];
 			brush.face[3].v[2][1] = Node[Tri[i].v[2]].p[1];
 			brush.face[3].v[2][2] = (float)backface;
-			
+
 			// 2-0 side
 			brush.face[4].v[0][0] = Node[Tri[i].v[2]].p[0];
 			brush.face[4].v[0][1] = Node[Tri[i].v[2]].p[1];
 			brush.face[4].v[0][2] = Node[Tri[i].v[2]].p[2];
-			
+
 			brush.face[4].v[1][0] = Node[Tri[i].v[0]].p[0];
 			brush.face[4].v[1][1] = Node[Tri[i].v[0]].p[1];
 			brush.face[4].v[1][2] = Node[Tri[i].v[0]].p[2];
-			
+
 			brush.face[4].v[2][0] = Node[Tri[i].v[0]].p[0];
 			brush.face[4].v[2][1] = Node[Tri[i].v[0]].p[1];
 			brush.face[4].v[2][2] = (float)backface;
 		}
-		
-		for(j=0; j<5; j++)
+
+		for ( j = 0; j < 5; j++ )
 		{
-			strcpy(brush.face[j].texture,
-				(strlen(texture1) ? texture1 : texture0));
+			strcpy( brush.face[j].texture,
+					( strlen( texture1 ) ? texture1 : texture0 ) );
 			brush.face[j].Shift[0] = (float)TexOffset[0];
 			brush.face[j].Shift[1] = (float)TexOffset[1];
 			brush.face[j].Rotate   = 0.;
 			brush.face[j].Scale[0] = (float)TexScale[0];
 			brush.face[j].Scale[1] = (float)TexScale[1];
 			brush.face[j].Contents = contents;
-			if(surf)
+			if ( surf ) {
 				brush.face[j].Surface = 0;
-			else
+			}
+			else{
 				brush.face[j].Surface = SURF_HINT;
+			}
 			brush.face[j].Value    = 0;
 		}
 
-		if(CheckAngle)
-		{
-			XYZVectorSubtract(brush.face[0].v[2],brush.face[0].v[0],t[0]);
-			XYZVectorSubtract(brush.face[0].v[1],brush.face[0].v[2],t[1]);
-			CrossProduct(t[0],t[1],SurfNormal);
-			VectorNormalize(SurfNormal,SurfNormal);
-			if(DotProduct(SurfNormal,PlaneNormal) < Steep)
-				strcpy(brush.face[0].texture,texture2);
-			else
-				strcpy(brush.face[0].texture,texture0);
+		if ( CheckAngle ) {
+			XYZVectorSubtract( brush.face[0].v[2],brush.face[0].v[0],t[0] );
+			XYZVectorSubtract( brush.face[0].v[1],brush.face[0].v[2],t[1] );
+			CrossProduct( t[0],t[1],SurfNormal );
+			VectorNormalize( SurfNormal,SurfNormal );
+			if ( DotProduct( SurfNormal,PlaneNormal ) < Steep ) {
+				strcpy( brush.face[0].texture,texture2 );
+			}
+			else{
+				strcpy( brush.face[0].texture,texture0 );
+			}
+		}
+		else{
+			strcpy( brush.face[0].texture,texture0 );
 		}
-		else
-			strcpy(brush.face[0].texture,texture0);
 
-		if(surf) brush.face[0].Value    = ArghRad2;
-		MakeBrush(&brush);
+		if ( surf ) {
+			brush.face[0].Value    = ArghRad2;
+		}
+		MakeBrush( &brush );
 	}
 	CloseFuncGroup();
 
 } // end MakeBrushes
 //=================================================================
-void MapOut(int NumNodes,int NumTris, NODE *Node, TRI *Tri)
-{
-	extern	double backface;
-	extern	double xmin, xmax, ymin, ymax, zmin, zmax;
-	BRUSH	brush;
-	char	hint[32], skip[32];
-	int		i, j;
-	int		face;
-        /*
-	ghCursorCurrent = LoadCursor(NULL,IDC_WAIT);
-	SetCursor(ghCursorCurrent);
-        */
+void MapOut( int NumNodes,int NumTris, NODE *Node, TRI *Tri ){
+	extern double backface;
+	extern double xmin, xmax, ymin, ymax, zmin, zmax;
+	BRUSH brush;
+	char hint[32], skip[32];
+	int i, j;
+	int face;
+	/*
+	   ghCursorCurrent = LoadCursor(NULL,IDC_WAIT);
+	   SetCursor(ghCursorCurrent);
+	 */
 	UseDetail = 1; // this is temporary
-	MakeBrushes(NumTris,Node,Tri,TRUE,0,Texture[Game][0],Texture[Game][1],Texture[Game][2]);
+	MakeBrushes( NumTris,Node,Tri,TRUE,0,Texture[Game][0],Texture[Game][1],Texture[Game][2] );
 
-	if(AddHints || GimpHints)
-	{
-		switch(Game)
+	if ( AddHints || GimpHints ) {
+		switch ( Game )
 		{
 		case SIN:
-			strcpy(hint,"generic/misc/hint");
-			strcpy(skip,"generic/misc/skip");
+			strcpy( hint,"generic/misc/hint" );
+			strcpy( skip,"generic/misc/skip" );
 			break;
 		case HALFLIFE:
-			strcpy(hint,"HINT");
-			strcpy(skip,"HINT");
+			strcpy( hint,"HINT" );
+			strcpy( skip,"HINT" );
 			break;
 		case HERETIC2:
-			strcpy(hint,"general/hint");
-			strcpy(skip,"general/skip");
+			strcpy( hint,"general/hint" );
+			strcpy( skip,"general/skip" );
 			break;
 		case KINGPIN:
-			strcpy(hint,"common/0_hint");
-			strcpy(skip,"common/0_skip");
+			strcpy( hint,"common/0_hint" );
+			strcpy( skip,"common/0_skip" );
 			break;
 		case QUAKE3:
-			strcpy(hint,"common/hint");
-			strcpy(skip,"common/skip");
+			strcpy( hint,"common/hint" );
+			strcpy( skip,"common/skip" );
 			break;
 		default:
-			strcpy(hint,"e1u1/hint");
-			strcpy(skip,"e1u1/skip");
+			strcpy( hint,"e1u1/hint" );
+			strcpy( skip,"e1u1/skip" );
 		}
 	}
 
-	if( GimpHints )
-		MakeBrushes(NumTris,Node,Tri,FALSE,HINT_OFFSET,hint,hint,hint);
+	if ( GimpHints ) {
+		MakeBrushes( NumTris,Node,Tri,FALSE,HINT_OFFSET,hint,hint,hint );
+	}
 
-	if( AddHints==1 )
-	{
-		int   j0, j1, j2, k, k0, k1;
-		int   q[4];
-		int   w,h,h0,h1,t,OK;
+	if ( AddHints == 1 ) {
+		int j0, j1, j2, k, k0, k1;
+		int q[4];
+		int w,h,h0,h1,t,OK;
 		float s[3];
 		double front;
-		int   MaxHints; // We don't want a whole slew of hint brushes, which we'd get
+		int MaxHints;   // We don't want a whole slew of hint brushes, which we'd get
 		                // with low decimation values and our current placement scheme.
 		                // Limit number of hint brushes to number of undecimated grid
 		                // squares.
 
-		switch(Plane)
+		switch ( Plane )
 		{
 		case PLANE_XY1:
-			front  = LessThan(zmin,32.);
+			front  = LessThan( zmin,32. );
 			break;
 		case PLANE_XZ0:
-			front  = MoreThan(ymax,32.);
+			front  = MoreThan( ymax,32. );
 			break;
 		case PLANE_XZ1:
-			front  = LessThan(ymin,32.);
+			front  = LessThan( ymin,32. );
 			break;
 		case PLANE_YZ0:
-			front  = MoreThan(xmax,32.);
+			front  = MoreThan( xmax,32. );
 			break;
 		case PLANE_YZ1:
-			front  = LessThan(xmin,32.);
+			front  = LessThan( xmin,32. );
 			break;
 		default:
-			front  = MoreThan(zmax,32.);
+			front  = MoreThan( zmax,32. );
 		}
-		
-		for(i=0; i<NumTris; i++)
+
+		for ( i = 0; i < NumTris; i++ )
 			Tri[i].flag = 0;
-		
-		switch(Plane)
+
+		switch ( Plane )
 		{
 		case PLANE_XZ0:
 		case PLANE_XZ1:
@@ -1075,21 +1156,21 @@ void MapOut(int NumNodes,int NumTris, NODE *Node, TRI *Tri)
 			j1 = 0;
 			j2 = 1;
 		}
-		
+
 		brush.Number = 0;
 		brush.NumFaces = 6;
-		MaxHints = NH*NV-1;
-		for(w=1; w<min(16,NH) && brush.Number < MaxHints; w++)
+		MaxHints = NH * NV - 1;
+		for ( w = 1; w < min( 16,NH ) && brush.Number < MaxHints; w++ )
 		{
-			for(h=max(1,w/2); h<min(16,NV) && brush.Number < MaxHints; h++)
+			for ( h = max( 1,w / 2 ); h < min( 16,NV ) && brush.Number < MaxHints; h++ )
 			{
-				for(i=0; i<=NH-w && brush.Number < MaxHints; i++)
+				for ( i = 0; i <= NH - w && brush.Number < MaxHints; i++ )
 				{
-					for(j=0; j<=NV-h && brush.Number < MaxHints; j++)
+					for ( j = 0; j <= NV - h && brush.Number < MaxHints; j++ )
 					{
-						q[0] = i*NVP1+j;
-						q[2] = q[0] + w*NVP1 + h;
-						switch(Plane)
+						q[0] = i * NVP1 + j;
+						q[2] = q[0] + w * NVP1 + h;
+						switch ( Plane )
 						{
 						case PLANE_XY1:
 						case PLANE_XZ0:
@@ -1101,29 +1182,45 @@ void MapOut(int NumNodes,int NumTris, NODE *Node, TRI *Tri)
 							q[1] = q[2] - h;
 							q[3] = q[0] + h;
 						}
-						for(k=0, OK=1; k<NumTris && OK; k++)
+						for ( k = 0, OK = 1; k < NumTris && OK; k++ )
 						{
-							if(Tri[k].min[j1] >= max(Node[q[0]].p[j1],Node[q[2]].p[j1])) continue;
-							if(Tri[k].min[j2] >= max(Node[q[0]].p[j2],Node[q[2]].p[j2])) continue;
-							if(Tri[k].max[j1] <= min(Node[q[0]].p[j1],Node[q[2]].p[j1])) continue;
-							if(Tri[k].max[j2] <= min(Node[q[0]].p[j2],Node[q[2]].p[j2])) continue;
+							if ( Tri[k].min[j1] >= max( Node[q[0]].p[j1],Node[q[2]].p[j1] ) ) {
+								continue;
+							}
+							if ( Tri[k].min[j2] >= max( Node[q[0]].p[j2],Node[q[2]].p[j2] ) ) {
+								continue;
+							}
+							if ( Tri[k].max[j1] <= min( Node[q[0]].p[j1],Node[q[2]].p[j1] ) ) {
+								continue;
+							}
+							if ( Tri[k].max[j2] <= min( Node[q[0]].p[j2],Node[q[2]].p[j2] ) ) {
+								continue;
+							}
 
-							for(h0=0; h0<4 && OK; h0++)
+							for ( h0 = 0; h0 < 4 && OK; h0++ )
 							{
-								h1 = (h0+1)%4;
-								for(t=0; t<3 && OK; t++)
+								h1 = ( h0 + 1 ) % 4;
+								for ( t = 0; t < 3 && OK; t++ )
 								{
-									s[t] = side(Node[q[h0]].p[j1],Node[q[h0]].p[j2],
-										Node[q[h1]].p[j1],Node[q[h1]].p[j2],
-										Node[Tri[k].v[t]].p[j1],Node[Tri[k].v[t]].p[j2]);
+									s[t] = side( Node[q[h0]].p[j1],Node[q[h0]].p[j2],
+												 Node[q[h1]].p[j1],Node[q[h1]].p[j2],
+												 Node[Tri[k].v[t]].p[j1],Node[Tri[k].v[t]].p[j2] );
+								}
+								if ( ( s[1] > 0 || s[2] > 0 ) && s[0] < 0 ) {
+									OK = 0;
+								}
+								if ( ( s[2] > 0 || s[0] > 0 ) && s[1] < 0 ) {
+									OK = 0;
+								}
+								if ( ( s[0] > 0 || s[1] > 0 ) && s[2] < 0 ) {
+									OK = 0;
 								}
-								if((s[1] > 0 || s[2] > 0) && s[0] < 0) OK=0;
-								if((s[2] > 0 || s[0] > 0) && s[1] < 0) OK=0;
-								if((s[0] > 0 || s[1] > 0) && s[2] < 0) OK=0;
 							}
 						}
-						if(!OK) continue;
-						switch(Plane)
+						if ( !OK ) {
+							continue;
+						}
+						switch ( Plane )
 						{
 						case PLANE_XZ0:
 						case PLANE_XZ1:
@@ -1131,41 +1228,41 @@ void MapOut(int NumNodes,int NumTris, NODE *Node, TRI *Tri)
 							brush.face[0].v[0][0] = Node[q[2]].p[0];
 							brush.face[0].v[0][1] = (float)front;
 							brush.face[0].v[0][2] = Node[q[2]].p[2];
-							
+
 							brush.face[0].v[1][0] = Node[q[1]].p[0];
 							brush.face[0].v[1][1] = (float)front;
 							brush.face[0].v[1][2] = Node[q[1]].p[2];
-							
+
 							brush.face[0].v[2][0] = Node[q[0]].p[0];
 							brush.face[0].v[2][1] = (float)front;
 							brush.face[0].v[2][2] = Node[q[0]].p[2];
-							
+
 							// back
 							brush.face[1].v[0][0] = Node[q[0]].p[0];
 							brush.face[1].v[0][1] = (float)backface;
 							brush.face[1].v[0][2] = Node[q[0]].p[2];
-							
+
 							brush.face[1].v[1][0] = Node[q[1]].p[0];
 							brush.face[1].v[1][1] = (float)backface;
 							brush.face[1].v[1][2] = Node[q[1]].p[2];
-							
+
 							brush.face[1].v[2][0] = Node[q[2]].p[0];
 							brush.face[1].v[2][1] = (float)backface;
 							brush.face[1].v[2][2] = Node[q[2]].p[2];
-							
-							for(k0=0; k0<brush.NumFaces-2; k0++)
+
+							for ( k0 = 0; k0 < brush.NumFaces - 2; k0++ )
 							{
-								k =k0+2;
-								k1=(k0+1) % (brush.NumFaces-2);
-								
+								k = k0 + 2;
+								k1 = ( k0 + 1 ) % ( brush.NumFaces - 2 );
+
 								brush.face[k].v[0][0] = Node[q[k0]].p[0];
 								brush.face[k].v[0][1] = (float)front;
 								brush.face[k].v[0][2] = Node[q[k0]].p[2];
-								
+
 								brush.face[k].v[1][0] = Node[q[k1]].p[0];
 								brush.face[k].v[1][1] = (float)front;
 								brush.face[k].v[1][2] = Node[q[k1]].p[2];
-								
+
 								brush.face[k].v[2][0] = Node[q[k1]].p[0];
 								brush.face[k].v[2][1] = (float)backface;
 								brush.face[k].v[2][2] = Node[q[k1]].p[2];
@@ -1177,41 +1274,41 @@ void MapOut(int NumNodes,int NumTris, NODE *Node, TRI *Tri)
 							brush.face[0].v[0][0] = (float)front;
 							brush.face[0].v[0][1] = Node[q[2]].p[1];
 							brush.face[0].v[0][2] = Node[q[2]].p[2];
-							
+
 							brush.face[0].v[1][0] = (float)front;
 							brush.face[0].v[1][1] = Node[q[1]].p[1];
 							brush.face[0].v[1][2] = Node[q[1]].p[2];
-							
+
 							brush.face[0].v[2][0] = (float)front;
 							brush.face[0].v[2][1] = Node[q[0]].p[1];
 							brush.face[0].v[2][2] = Node[q[0]].p[2];
-							
+
 							// back
 							brush.face[1].v[0][0] = (float)backface;
 							brush.face[1].v[0][1] = Node[q[0]].p[1];
 							brush.face[1].v[0][2] = Node[q[0]].p[2];
-							
+
 							brush.face[1].v[1][0] = (float)backface;
 							brush.face[1].v[1][1] = Node[q[1]].p[1];
 							brush.face[1].v[1][2] = Node[q[1]].p[2];
-							
+
 							brush.face[1].v[2][0] = (float)backface;
 							brush.face[1].v[2][1] = Node[q[2]].p[1];
 							brush.face[1].v[2][2] = Node[q[2]].p[2];
-							
-							for(k0=0; k0<brush.NumFaces-2; k0++)
+
+							for ( k0 = 0; k0 < brush.NumFaces - 2; k0++ )
 							{
-								k =k0+2;
-								k1=(k0+1) % (brush.NumFaces-2);
-								
+								k = k0 + 2;
+								k1 = ( k0 + 1 ) % ( brush.NumFaces - 2 );
+
 								brush.face[k].v[0][0] = (float)front;
 								brush.face[k].v[0][1] = Node[q[k0]].p[1];
 								brush.face[k].v[0][2] = Node[q[k0]].p[2];
-								
+
 								brush.face[k].v[1][0] = (float)front;
 								brush.face[k].v[1][1] = Node[q[k1]].p[1];
 								brush.face[k].v[1][2] = Node[q[k1]].p[2];
-								
+
 								brush.face[k].v[2][0] = (float)backface;
 								brush.face[k].v[2][1] = Node[q[k1]].p[1];
 								brush.face[k].v[2][2] = Node[q[k1]].p[2];
@@ -1222,76 +1319,79 @@ void MapOut(int NumNodes,int NumTris, NODE *Node, TRI *Tri)
 							brush.face[0].v[0][0] = Node[q[2]].p[0];
 							brush.face[0].v[0][1] = Node[q[2]].p[1];
 							brush.face[0].v[0][2] = (float)front;
-							
+
 							brush.face[0].v[1][0] = Node[q[1]].p[0];
 							brush.face[0].v[1][1] = Node[q[1]].p[1];
 							brush.face[0].v[1][2] = (float)front;
-							
+
 							brush.face[0].v[2][0] = Node[q[0]].p[0];
 							brush.face[0].v[2][1] = Node[q[0]].p[1];
 							brush.face[0].v[2][2] = (float)front;
-							
+
 							// back
 							brush.face[1].v[0][0] = Node[q[0]].p[0];
 							brush.face[1].v[0][1] = Node[q[0]].p[1];
 							brush.face[1].v[0][2] = (float)backface;
-							
+
 							brush.face[1].v[1][0] = Node[q[1]].p[0];
 							brush.face[1].v[1][1] = Node[q[1]].p[1];
 							brush.face[1].v[1][2] = (float)backface;
-							
+
 							brush.face[1].v[2][0] = Node[q[2]].p[0];
 							brush.face[1].v[2][1] = Node[q[2]].p[1];
 							brush.face[1].v[2][2] = (float)backface;
-							
-							for(k0=0; k0<brush.NumFaces-2; k0++)
+
+							for ( k0 = 0; k0 < brush.NumFaces - 2; k0++ )
 							{
-								k =k0+2;
-								k1=(k0+1) % (brush.NumFaces-2);
-								
+								k = k0 + 2;
+								k1 = ( k0 + 1 ) % ( brush.NumFaces - 2 );
+
 								brush.face[k].v[0][0] = Node[q[k0]].p[0];
 								brush.face[k].v[0][1] = Node[q[k0]].p[1];
 								brush.face[k].v[0][2] = (float)front;
-								
+
 								brush.face[k].v[1][0] = Node[q[k1]].p[0];
 								brush.face[k].v[1][1] = Node[q[k1]].p[1];
 								brush.face[k].v[1][2] = (float)front;
-								
+
 								brush.face[k].v[2][0] = Node[q[k1]].p[0];
 								brush.face[k].v[2][1] = Node[q[k1]].p[1];
 								brush.face[k].v[2][2] = (float)backface;
 							}
 							break;
 						} // switch (Plane)
-						for(face=0; face<6; face++)
+						for ( face = 0; face < 6; face++ )
 						{
-							strcpy(brush.face[face].texture,(face<=1 ? skip : hint));
+							strcpy( brush.face[face].texture,( face <= 1 ? skip : hint ) );
 							brush.face[face].Shift[0] = 0;
 							brush.face[face].Shift[1] = 0;
 							brush.face[face].Rotate   = 0.;
 							brush.face[face].Scale[0] = 1;
 							brush.face[face].Scale[1] = 1;
 							brush.face[face].Contents = CONTENTS_DETAIL;
-							brush.face[face].Surface  = (face<=1 ? SURF_SKIP : SURF_HINT);
+							brush.face[face].Surface  = ( face <= 1 ? SURF_SKIP : SURF_HINT );
 							brush.face[face].Value    = 0;
 						}
-						if(!brush.Number) OpenFuncGroup();
-						MakeBrush(&brush);
+						if ( !brush.Number ) {
+							OpenFuncGroup();
+						}
+						MakeBrush( &brush );
 						brush.Number++;
 					} // for(j=
 				}     // for(i=
 			}         // for(h=
 		}             // for(w=
-		if(brush.Number) CloseFuncGroup();
+		if ( brush.Number ) {
+			CloseFuncGroup();
+		}
 	}
-        /*
-	ghCursorCurrent = ghCursorDefault;
-	SetCursor(ghCursorCurrent);
-        */
+	/*
+	   ghCursorCurrent = ghCursorDefault;
+	   SetCursor(ghCursorCurrent);
+	 */
 }
 //===========================================================================
-int CheckBorders(int *NumNodesUsed, int NumNodes, NODE *Node, int *NumTris, TRI **pTri)
-{
+int CheckBorders( int *NumNodesUsed, int NumNodes, NODE *Node, int *NumTris, TRI **pTri ){
 	int border;
 	int i, j, k0, k1, N;
 	float angle[3];
@@ -1299,30 +1399,28 @@ int CheckBorders(int *NumNodesUsed, int NumNodes, NODE *Node, int *NumTris, TRI
 
 	N = NumNodesUsed[0];
 	Tri = *pTri;
-	for(i=0; i<NumTris[0]; i++)
+	for ( i = 0; i < NumTris[0]; i++ )
 	{
-		EdgeOnSide(Tri[i].v,&k0,&border);
-		if(border < 0) continue;
-		CalcAngles(Node, Tri[i].v, angle);
-		k1 = (k0+1) % 3;
-		if((angle[k0] < SLIVER_ANGLE) || (angle[k1] < SLIVER_ANGLE))
-		{
-			j = Bisect(Node, border, Tri[i].v[k0], Tri[i].v[k1]);
-			if(j >= 0)
-			{
-				if(!Node[j].used)    // Shouldn't be used, but...
-				{
+		EdgeOnSide( Tri[i].v,&k0,&border );
+		if ( border < 0 ) {
+			continue;
+		}
+		CalcAngles( Node, Tri[i].v, angle );
+		k1 = ( k0 + 1 ) % 3;
+		if ( ( angle[k0] < SLIVER_ANGLE ) || ( angle[k1] < SLIVER_ANGLE ) ) {
+			j = Bisect( Node, border, Tri[i].v[k0], Tri[i].v[k1] );
+			if ( j >= 0 ) {
+				if ( !Node[j].used ) {  // Shouldn't be used, but...
 					NumNodesUsed[0]++;
 					Node[j].used++;
 				}
 			}
 		}
 	}
-	if(NumNodesUsed[0] > N)
-	{
-		free(*pTri);
-		tricall(NumNodes, Node, NumTris, NULL, pTri, "cnzBNPY");
+	if ( NumNodesUsed[0] > N ) {
+		free( *pTri );
+		tricall( NumNodes, Node, NumTris, NULL, pTri, "cnzBNPY" );
 		Tri = *pTri;
 	}
-	return (NumNodesUsed[0] - N);
+	return ( NumNodesUsed[0] - N );
 }