Merge branch 'master' into divVerent/farplanedist-sky-fix

[xonotic/netradiant.git] / tools / quake3 / q3map2 / visflow.c
diff --git a/tools/quake3/q3map2/visflow.c b/tools/quake3/q3map2/visflow.c

index 672b91a5aa53ad277f517546e97bec4d4384a3ce..5a7ffd92de65c6ed8cc77889b3a22e07e76aa666 100644 (file)
--- a/tools/quake3/q3map2/visflow.c
+++ b/tools/quake3/q3map2/visflow.c
@@ -1,30 +1,30 @@
  /* -------------------------------------------------------------------------------
  
  /* -------------------------------------------------------------------------------
  
-Copyright (C) 1999-2007 id Software, Inc. and contributors.
-For a list of contributors, see the accompanying CONTRIBUTORS file.
+   Copyright (C) 1999-2007 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
  
  
-----------------------------------------------------------------------------------
+   ----------------------------------------------------------------------------------
  
  
-This code has been altered significantly from its original form, to support
-several games based on the Quake III Arena engine, in the form of "Q3Map2."
+   This code has been altered significantly from its original form, to support
+   several games based on the Quake III Arena engine, in the form of "Q3Map2."
  
  
-------------------------------------------------------------------------------- */
+   ------------------------------------------------------------------------------- */
  
  
  
  
  
  
@@ -41,122 +41,123 @@ several games based on the Quake III Arena engine, in the form of "Q3Map2."
  
  /*
  
  
  /*
  
-  each portal will have a list of all possible to see from first portal
+   each portal will have a list of all possible to see from first portal
  
  
-  if (!thread->portalmightsee[portalnum])
+   if (!thread->portalmightsee[portalnum])
  
  
-  portal mightsee
+   portal mightsee
  
  
-  for p2 = all other portals in leaf
-       get sperating planes
-       for all portals that might be seen by p2
-               mark as unseen if not present in seperating plane
-       flood fill a new mightsee
-       save as passagemightsee
+   for p2 = all other portals in leaf
+    get sperating planes
+    for all portals that might be seen by p2
+        mark as unseen if not present in seperating plane
+    flood fill a new mightsee
+    save as passagemightsee
  
  
  
  
-  void CalcMightSee (leaf_t *leaf, 
-*/
+   void CalcMightSee (leaf_t *leaf,
+ */
  
  
-int CountBits (byte *bits, int numbits)
-{
-       int             i;
-       int             c;
+int CountBits( byte *bits, int numbits ){
+       int i;
+       int c;
  
         c = 0;
  
         c = 0;
-       for (i=0 ; i<numbits ; i++)
-               if (bits[i>>3] & (1<<(i&7)) )
+       for ( i = 0 ; i < numbits ; i++ )
+               if ( bits[i >> 3] & ( 1 << ( i & 7 ) ) ) {
                         c++;
                         c++;
+               }
  
         return c;
  }
  
  
         return c;
  }
  
-int            c_fullskip;
-int            c_portalskip, c_leafskip;
-int            c_vistest, c_mighttest;
+int c_fullskip;
+int c_portalskip, c_leafskip;
+int c_vistest, c_mighttest;
  
  
-int            c_chop, c_nochop;
+int c_chop, c_nochop;
  
  
-int            active;
+int active;
  
  
-void CheckStack (leaf_t *leaf, threaddata_t *thread)
-{
-       pstack_t        *p, *p2;
+void CheckStack( leaf_t *leaf, threaddata_t *thread ){
+       pstack_t    *p, *p2;
  
  
-       for (p=thread->pstack_head.next ; p ; p=p->next)
+       for ( p = thread->pstack_head.next ; p ; p = p->next )
         {
  //             Sys_Printf ("=");
         {
  //             Sys_Printf ("=");
-               if (p->leaf == leaf)
-                       Error ("CheckStack: leaf recursion");
-               for (p2=thread->pstack_head.next ; p2 != p ; p2=p2->next)
-                       if (p2->leaf == p->leaf)
-                               Error ("CheckStack: late leaf recursion");
+               if ( p->leaf == leaf ) {
+                       Error( "CheckStack: leaf recursion" );
+               }
+               for ( p2 = thread->pstack_head.next ; p2 != p ; p2 = p2->next )
+                       if ( p2->leaf == p->leaf ) {
+                               Error( "CheckStack: late leaf recursion" );
+                       }
         }
  //     Sys_Printf ("\n");
  }
  
  
         }
  //     Sys_Printf ("\n");
  }
  
  
-fixedWinding_t *AllocStackWinding (pstack_t *stack)
-{
-       int             i;
+fixedWinding_t *AllocStackWinding( pstack_t *stack ){
+       int i;
  
  
-       for (i=0 ; i<3 ; i++)
+       for ( i = 0 ; i < 3 ; i++ )
         {
         {
-               if (stack->freewindings[i])
-               {
+               if ( stack->freewindings[i] ) {
                         stack->freewindings[i] = 0;
                         return &stack->windings[i];
                 }
         }
  
                         stack->freewindings[i] = 0;
                         return &stack->windings[i];
                 }
         }
  
-       Error ("AllocStackWinding: failed");
+       Error( "AllocStackWinding: failed" );
  
         return NULL;
  }
  
  
         return NULL;
  }
  
-void FreeStackWinding (fixedWinding_t *w, pstack_t *stack)
-{
-       int             i;
+void FreeStackWinding( fixedWinding_t *w, pstack_t *stack ){
+       int i;
  
         i = w - stack->windings;
  
  
         i = w - stack->windings;
  
-       if (i<0 || i>2)
-               return;         // not from local
+       if ( i < 0 || i > 2 ) {
+               return;     // not from local
  
  
-       if (stack->freewindings[i])
-               Error ("FreeStackWinding: allready free");
+       }
+       if ( stack->freewindings[i] ) {
+               Error( "FreeStackWinding: allready free" );
+       }
         stack->freewindings[i] = 1;
  }
  
  /*
         stack->freewindings[i] = 1;
  }
  
  /*
-==============
-VisChopWinding
-
-==============
-*/
-fixedWinding_t *VisChopWinding (fixedWinding_t *in, pstack_t *stack, visPlane_t *split)
-{
-       vec_t   dists[128];
-       int             sides[128];
-       int             counts[3];
-       vec_t   dot;
-       int             i, j;
-       vec_t   *p1, *p2;
-       vec3_t  mid;
-       fixedWinding_t  *neww;
+   ==============
+   VisChopWinding
+
+   ==============
+ */
+fixedWinding_t  *VisChopWinding( fixedWinding_t *in, pstack_t *stack, visPlane_t *split ){
+       vec_t dists[128];
+       int sides[128];
+       int counts[3];
+       vec_t dot;
+       int i, j;
+       vec_t   *p1, *p2;
+       vec3_t mid;
+       fixedWinding_t  *neww;
  
         counts[0] = counts[1] = counts[2] = 0;
  
         // determine sides for each point
  
         counts[0] = counts[1] = counts[2] = 0;
  
         // determine sides for each point
-       for (i=0 ; i<in->numpoints ; i++)
+       for ( i = 0 ; i < in->numpoints ; i++ )
         {
         {
-               dot = DotProduct (in->points[i], split->normal);
+               dot = DotProduct( in->points[i], split->normal );
                 dot -= split->dist;
                 dists[i] = dot;
                 dot -= split->dist;
                 dists[i] = dot;
-               if (dot > ON_EPSILON)
+               if ( dot > ON_EPSILON ) {
                         sides[i] = SIDE_FRONT;
                         sides[i] = SIDE_FRONT;
-               else if (dot < -ON_EPSILON)
+               }
+               else if ( dot < -ON_EPSILON ) {
                         sides[i] = SIDE_BACK;
                         sides[i] = SIDE_BACK;
+               }
                 else
                 {
                         sides[i] = SIDE_ON;
                 else
                 {
                         sides[i] = SIDE_ON;
@@ -164,137 +165,137 @@ fixedWinding_t  *VisChopWinding (fixedWinding_t *in, pstack_t *stack, visPlane_t
                 counts[sides[i]]++;
         }
  
                 counts[sides[i]]++;
         }
  
-       if (!counts[1])
-               return in;              // completely on front side
-       
-       if (!counts[0])
-       {
-               FreeStackWinding (in, stack);
+       if ( !counts[1] ) {
+               return in;      // completely on front side
+
+       }
+       if ( !counts[0] ) {
+               FreeStackWinding( in, stack );
                 return NULL;
         }
  
         sides[i] = sides[0];
         dists[i] = dists[0];
                 return NULL;
         }
  
         sides[i] = sides[0];
         dists[i] = dists[0];
-       
-       neww = AllocStackWinding (stack);
+
+       neww = AllocStackWinding( stack );
  
         neww->numpoints = 0;
  
  
         neww->numpoints = 0;
  
-       for (i=0 ; i<in->numpoints ; i++)
+       for ( i = 0 ; i < in->numpoints ; i++ )
         {
                 p1 = in->points[i];
  
         {
                 p1 = in->points[i];
  
-               if (neww->numpoints == MAX_POINTS_ON_FIXED_WINDING)
-               {
-                       FreeStackWinding (neww, stack);
-                       return in;              // can't chop -- fall back to original
+               if ( neww->numpoints == MAX_POINTS_ON_FIXED_WINDING ) {
+                       FreeStackWinding( neww, stack );
+                       return in;      // can't chop -- fall back to original
                 }
  
                 }
  
-               if (sides[i] == SIDE_ON)
-               {
-                       VectorCopy (p1, neww->points[neww->numpoints]);
+               if ( sides[i] == SIDE_ON ) {
+                       VectorCopy( p1, neww->points[neww->numpoints] );
                         neww->numpoints++;
                         continue;
                 }
                         neww->numpoints++;
                         continue;
                 }
-       
-               if (sides[i] == SIDE_FRONT)
-               {
-                       VectorCopy (p1, neww->points[neww->numpoints]);
+
+               if ( sides[i] == SIDE_FRONT ) {
+                       VectorCopy( p1, neww->points[neww->numpoints] );
                         neww->numpoints++;
                 }
                         neww->numpoints++;
                 }
-               
-               if (sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
+
+               if ( sides[i + 1] == SIDE_ON || sides[i + 1] == sides[i] ) {
                         continue;
                         continue;
-                       
-               if (neww->numpoints == MAX_POINTS_ON_FIXED_WINDING)
-               {
-                       FreeStackWinding (neww, stack);
-                       return in;              // can't chop -- fall back to original
+               }
+
+               if ( neww->numpoints == MAX_POINTS_ON_FIXED_WINDING ) {
+                       FreeStackWinding( neww, stack );
+                       return in;      // can't chop -- fall back to original
                 }
  
                 // generate a split point
                 }
  
                 // generate a split point
-               p2 = in->points[(i+1)%in->numpoints];
-               
-               dot = dists[i] / (dists[i]-dists[i+1]);
-               for (j=0 ; j<3 ; j++)
-               {       // avoid round off error when possible
-                       if (split->normal[j] == 1)
+               p2 = in->points[( i + 1 ) % in->numpoints];
+
+               dot = dists[i] / ( dists[i] - dists[i + 1] );
+               for ( j = 0 ; j < 3 ; j++ )
+               {   // avoid round off error when possible
+                       if ( split->normal[j] == 1 ) {
                                 mid[j] = split->dist;
                                 mid[j] = split->dist;
-                       else if (split->normal[j] == -1)
+                       }
+                       else if ( split->normal[j] == -1 ) {
                                 mid[j] = -split->dist;
                                 mid[j] = -split->dist;
-                       else
-                               mid[j] = p1[j] + dot*(p2[j]-p1[j]);
+                       }
+                       else{
+                               mid[j] = p1[j] + dot * ( p2[j] - p1[j] );
+                       }
                 }
                 }
-                       
-               VectorCopy (mid, neww->points[neww->numpoints]);
+
+               VectorCopy( mid, neww->points[neww->numpoints] );
                 neww->numpoints++;
         }
                 neww->numpoints++;
         }
-       
+
         // free the original winding
         // free the original winding
-       FreeStackWinding (in, stack);
-       
+       FreeStackWinding( in, stack );
+
         return neww;
  }
  
  /*
         return neww;
  }
  
  /*
-==============
-ClipToSeperators
-
-Source, pass, and target are an ordering of portals.
-
-Generates seperating planes canidates by taking two points from source and one
-point from pass, and clips target by them.
-
-If target is totally clipped away, that portal can not be seen through.
-
-Normal clip keeps target on the same side as pass, which is correct if the
-order goes source, pass, target.  If the order goes pass, source, target then
-flipclip should be set.
-==============
-*/
-fixedWinding_t *ClipToSeperators (fixedWinding_t *source, fixedWinding_t *pass, fixedWinding_t *target, qboolean flipclip, pstack_t *stack)
-{
-       int                     i, j, k, l;
-       visPlane_t              plane;
-       vec3_t          v1, v2;
-       float           d;
-       vec_t           length;
-       int                     counts[3];
-       qboolean                fliptest;
-
-       // check all combinations       
-       for (i=0 ; i<source->numpoints ; i++)
+   ==============
+   ClipToSeperators
+
+   Source, pass, and target are an ordering of portals.
+
+   Generates seperating planes canidates by taking two points from source and one
+   point from pass, and clips target by them.
+
+   If target is totally clipped away, that portal can not be seen through.
+
+   Normal clip keeps target on the same side as pass, which is correct if the
+   order goes source, pass, target.  If the order goes pass, source, target then
+   flipclip should be set.
+   ==============
+ */
+fixedWinding_t  *ClipToSeperators( fixedWinding_t *source, fixedWinding_t *pass, fixedWinding_t *target, qboolean flipclip, pstack_t *stack ){
+       int i, j, k, l;
+       visPlane_t plane;
+       vec3_t v1, v2;
+       float d;
+       vec_t length;
+       int counts[3];
+       qboolean fliptest;
+
+       // check all combinations
+       for ( i = 0 ; i < source->numpoints ; i++ )
         {
         {
-               l = (i+1)%source->numpoints;
-               VectorSubtract (source->points[l] , source->points[i], v1);
+               l = ( i + 1 ) % source->numpoints;
+               VectorSubtract( source->points[l], source->points[i], v1 );
  
                 // find a vertex of pass that makes a plane that puts all of the
                 // vertexes of pass on the front side and all of the vertexes of
                 // source on the back side
  
                 // find a vertex of pass that makes a plane that puts all of the
                 // vertexes of pass on the front side and all of the vertexes of
                 // source on the back side
-               for (j=0 ; j<pass->numpoints ; j++)
+               for ( j = 0 ; j < pass->numpoints ; j++ )
                 {
                 {
-                       VectorSubtract (pass->points[j], source->points[i], v2);
+                       VectorSubtract( pass->points[j], source->points[i], v2 );
+
+                       plane.normal[0] = v1[1] * v2[2] - v1[2] * v2[1];
+                       plane.normal[1] = v1[2] * v2[0] - v1[0] * v2[2];
+                       plane.normal[2] = v1[0] * v2[1] - v1[1] * v2[0];
  
  
-                       plane.normal[0] = v1[1]*v2[2] - v1[2]*v2[1];
-                       plane.normal[1] = v1[2]*v2[0] - v1[0]*v2[2];
-                       plane.normal[2] = v1[0]*v2[1] - v1[1]*v2[0];
-                       
                         // if points don't make a valid plane, skip it
  
                         length = plane.normal[0] * plane.normal[0]
                         // if points don't make a valid plane, skip it
  
                         length = plane.normal[0] * plane.normal[0]
-                       + plane.normal[1] * plane.normal[1]
-                       + plane.normal[2] * plane.normal[2];
-                       
-                       if (length < ON_EPSILON)
+                                        + plane.normal[1] * plane.normal[1]
+                                        + plane.normal[2] * plane.normal[2];
+
+                       if ( length < ON_EPSILON ) {
                                 continue;
                                 continue;
+                       }
+
+                       length = 1 / sqrt( length );
  
  
-                       length = 1/sqrt(length);
-                       
                         plane.normal[0] *= length;
                         plane.normal[1] *= length;
                         plane.normal[2] *= length;
  
                         plane.normal[0] *= length;
                         plane.normal[1] *= length;
                         plane.normal[2] *= length;
  
-                       plane.dist = DotProduct (pass->points[j], plane.normal);
+                       plane.dist = DotProduct( pass->points[j], plane.normal );
  
                         //
                         // find out which side of the generated seperating plane has the
  
                         //
                         // find out which side of the generated seperating plane has the
@@ -302,35 +303,34 @@ fixedWinding_t    *ClipToSeperators (fixedWinding_t *source, fixedWinding_t *pass,
                         //
  #if 1
                         fliptest = qfalse;
                         //
  #if 1
                         fliptest = qfalse;
-                       for (k=0 ; k<source->numpoints ; k++)
+                       for ( k = 0 ; k < source->numpoints ; k++ )
                         {
                         {
-                               if (k == i || k == l)
+                               if ( k == i || k == l ) {
                                         continue;
                                         continue;
-                               d = DotProduct (source->points[k], plane.normal) - plane.dist;
-                               if (d < -ON_EPSILON)
-                               {       // source is on the negative side, so we want all
-                                       // pass and target on the positive side
+                               }
+                               d = DotProduct( source->points[k], plane.normal ) - plane.dist;
+                               if ( d < -ON_EPSILON ) { // source is on the negative side, so we want all
+                                                           // pass and target on the positive side
                                         fliptest = qfalse;
                                         break;
                                 }
                                         fliptest = qfalse;
                                         break;
                                 }
-                               else if (d > ON_EPSILON)
-                               {       // source is on the positive side, so we want all
-                                       // pass and target on the negative side
+                               else if ( d > ON_EPSILON ) { // source is on the positive side, so we want all
+                                                               // pass and target on the negative side
                                         fliptest = qtrue;
                                         break;
                                 }
                         }
                                         fliptest = qtrue;
                                         break;
                                 }
                         }
-                       if (k == source->numpoints)
-                               continue;               // planar with source portal
+                       if ( k == source->numpoints ) {
+                               continue;       // planar with source portal
+                       }
  #else
                         fliptest = flipclip;
  #endif
                         //
                         // flip the normal if the source portal is backwards
                         //
  #else
                         fliptest = flipclip;
  #endif
                         //
                         // flip the normal if the source portal is backwards
                         //
-                       if (fliptest)
-                       {
-                               VectorSubtract (vec3_origin, plane.normal, plane.normal);
+                       if ( fliptest ) {
+                               VectorSubtract( vec3_origin, plane.normal, plane.normal );
                                 plane.dist = -plane.dist;
                         }
  #if 1
                                 plane.dist = -plane.dist;
                         }
  #if 1
@@ -339,87 +339,97 @@ fixedWinding_t    *ClipToSeperators (fixedWinding_t *source, fixedWinding_t *pass,
                         // this is the seperating plane
                         //
                         counts[0] = counts[1] = counts[2] = 0;
                         // this is the seperating plane
                         //
                         counts[0] = counts[1] = counts[2] = 0;
-                       for (k=0 ; k<pass->numpoints ; k++)
+                       for ( k = 0 ; k < pass->numpoints ; k++ )
                         {
                         {
-                               if (k==j)
+                               if ( k == j ) {
                                         continue;
                                         continue;
-                               d = DotProduct (pass->points[k], plane.normal) - plane.dist;
-                               if (d < -ON_EPSILON)
+                               }
+                               d = DotProduct( pass->points[k], plane.normal ) - plane.dist;
+                               if ( d < -ON_EPSILON ) {
                                         break;
                                         break;
-                               else if (d > ON_EPSILON)
+                               }
+                               else if ( d > ON_EPSILON ) {
                                         counts[0]++;
                                         counts[0]++;
-                               else
+                               }
+                               else{
                                         counts[2]++;
                                         counts[2]++;
+                               }
+                       }
+                       if ( k != pass->numpoints ) {
+                               continue;   // points on negative side, not a seperating plane
+
+                       }
+                       if ( !counts[0] ) {
+                               continue;   // planar with seperating plane
                         }
                         }
-                       if (k != pass->numpoints)
-                               continue;       // points on negative side, not a seperating plane
-                               
-                       if (!counts[0])
-                               continue;       // planar with seperating plane
  #else
  #else
-                       k = (j+1)%pass->numpoints;
-                       d = DotProduct (pass->points[k], plane.normal) - plane.dist;
-                       if (d < -ON_EPSILON)
+                       k = ( j + 1 ) % pass->numpoints;
+                       d = DotProduct( pass->points[k], plane.normal ) - plane.dist;
+                       if ( d < -ON_EPSILON ) {
                                 continue;
                                 continue;
-                       k = (j+pass->numpoints-1)%pass->numpoints;
-                       d = DotProduct (pass->points[k], plane.normal) - plane.dist;
-                       if (d < -ON_EPSILON)
-                               continue;                       
+                       }
+                       k = ( j + pass->numpoints - 1 ) % pass->numpoints;
+                       d = DotProduct( pass->points[k], plane.normal ) - plane.dist;
+                       if ( d < -ON_EPSILON ) {
+                               continue;
+                       }
  #endif
                         //
                         // flip the normal if we want the back side
                         //
  #endif
                         //
                         // flip the normal if we want the back side
                         //
-                       if (flipclip)
-                       {
-                               VectorSubtract (vec3_origin, plane.normal, plane.normal);
+                       if ( flipclip ) {
+                               VectorSubtract( vec3_origin, plane.normal, plane.normal );
                                 plane.dist = -plane.dist;
                         }
  
  #ifdef SEPERATORCACHE
                         stack->seperators[flipclip][stack->numseperators[flipclip]] = plane;
                                 plane.dist = -plane.dist;
                         }
  
  #ifdef SEPERATORCACHE
                         stack->seperators[flipclip][stack->numseperators[flipclip]] = plane;
-                       if (++stack->numseperators[flipclip] >= MAX_SEPERATORS)
-                               Error("MAX_SEPERATORS");
+                       if ( ++stack->numseperators[flipclip] >= MAX_SEPERATORS ) {
+                               Error( "MAX_SEPERATORS" );
+                       }
  #endif
                         //MrE: fast check first
  #endif
                         //MrE: fast check first
-                       d = DotProduct (stack->portal->origin, plane.normal) - plane.dist;
+                       d = DotProduct( stack->portal->origin, plane.normal ) - plane.dist;
                         //if completely at the back of the seperator plane
                         //if completely at the back of the seperator plane
-                       if (d < -stack->portal->radius)
+                       if ( d < -stack->portal->radius ) {
                                 return NULL;
                                 return NULL;
+                       }
                         //if completely on the front of the seperator plane
                         //if completely on the front of the seperator plane
-                       if (d > stack->portal->radius)
+                       if ( d > stack->portal->radius ) {
                                 break;
                                 break;
+                       }
  
                         //
                         // clip target by the seperating plane
                         //
  
                         //
                         // clip target by the seperating plane
                         //
-                       target = VisChopWinding (target, stack, &plane);
-                       if (!target)
-                               return NULL;            // target is not visible
+                       target = VisChopWinding( target, stack, &plane );
+                       if ( !target ) {
+                               return NULL;        // target is not visible
  
  
-                       break;          // optimization by Antony Suter
+                       }
+                       break;      // optimization by Antony Suter
                 }
         }
                 }
         }
-       
+
         return target;
  }
  
  /*
         return target;
  }
  
  /*
-==================
-RecursiveLeafFlow
-
-Flood fill through the leafs
-If src_portal is NULL, this is the originating leaf
-==================
-*/
-void RecursiveLeafFlow (int leafnum, threaddata_t *thread, pstack_t *prevstack)
-{
-       pstack_t        stack;
-       vportal_t       *p;
-       visPlane_t              backplane;
-       leaf_t          *leaf;
-       int                     i, j, n;
-       long            *test, *might, *prevmight, *vis, more;
-       int                     pnum;
+   ==================
+   RecursiveLeafFlow
+
+   Flood fill through the leafs
+   If src_portal is NULL, this is the originating leaf
+   ==================
+ */
+void RecursiveLeafFlow( int leafnum, threaddata_t *thread, pstack_t *prevstack ){
+       pstack_t stack;
+       vportal_t   *p;
+       visPlane_t backplane;
+       leaf_t      *leaf;
+       int i, j, n;
+       long        *test, *might, *prevmight, *vis, more;
+       int pnum;
  
         thread->c_chains++;
  
  
         thread->c_chains++;
  
@@ -440,42 +450,41 @@ void RecursiveLeafFlow (int leafnum, threaddata_t *thread, pstack_t *prevstack)
  
         might = (long *)stack.mightsee;
         vis = (long *)thread->base->portalvis;
  
         might = (long *)stack.mightsee;
         vis = (long *)thread->base->portalvis;
-       
-       // check all portals for flowing into other leafs       
-       for (i = 0; i < leaf->numportals; i++)
+
+       // check all portals for flowing into other leafs
+       for ( i = 0; i < leaf->numportals; i++ )
         {
                 p = leaf->portals[i];
         {
                 p = leaf->portals[i];
-               if (p->removed)
+               if ( p->removed ) {
                         continue;
                         continue;
+               }
                 pnum = p - portals;
  
                 /* MrE: portal trace debug code
                 pnum = p - portals;
  
                 /* MrE: portal trace debug code
-               {
-                       int portaltrace[] = {13, 16, 17, 37};
-                       pstack_t *s;
-
-                       s = &thread->pstack_head;
-                       for (j = 0; s->next && j < sizeof(portaltrace)/sizeof(int) - 1; j++, s = s->next)
-                       {
-                               if (s->portal->num != portaltrace[j])
-                                       break;
-                       }
-                       if (j >= sizeof(portaltrace)/sizeof(int) - 1)
-                       {
-                               if (p->num == portaltrace[j])
-                                       n = 0; //traced through all the portals
-                       }
-               }
-               */
-
-               if ( ! (prevstack->mightsee[pnum >> 3] & (1<<(pnum&7)) ) )
-               {
-                       continue;       // can't possibly see it
+                  {
+                   int portaltrace[] = {13, 16, 17, 37};
+                   pstack_t *s;
+
+                   s = &thread->pstack_head;
+                   for (j = 0; s->next && j < sizeof(portaltrace)/sizeof(int) - 1; j++, s = s->next)
+                   {
+                       if (s->portal->num != portaltrace[j])
+                           break;
+                   }
+                   if (j >= sizeof(portaltrace)/sizeof(int) - 1)
+                   {
+                       if (p->num == portaltrace[j])
+                           n = 0; //traced through all the portals
+                   }
+                  }
+                */
+
+               if ( !( prevstack->mightsee[pnum >> 3] & ( 1 << ( pnum & 7 ) ) ) ) {
+                       continue;   // can't possibly see it
                 }
  
                 // if the portal can't see anything we haven't allready seen, skip it
                 }
  
                 // if the portal can't see anything we haven't allready seen, skip it
-               if (p->status == stat_done)
-               {
+               if ( p->status == stat_done ) {
                         test = (long *)p->portalvis;
                 }
                 else
                         test = (long *)p->portalvis;
                 }
                 else
@@ -485,217 +494,215 @@ void RecursiveLeafFlow (int leafnum, threaddata_t *thread, pstack_t *prevstack)
  
                 more = 0;
                 prevmight = (long *)prevstack->mightsee;
  
                 more = 0;
                 prevmight = (long *)prevstack->mightsee;
-               for (j=0 ; j<portallongs ; j++)
+               for ( j = 0 ; j < portallongs ; j++ )
                 {
                         might[j] = prevmight[j] & test[j];
                 {
                         might[j] = prevmight[j] & test[j];
-                       more |= (might[j] & ~vis[j]);
+                       more |= ( might[j] & ~vis[j] );
                 }
                 }
-               
-               if (!more && 
-                       (thread->base->portalvis[pnum>>3] & (1<<(pnum&7))) )
-               {       // can't see anything new
+
+               if ( !more &&
+                        ( thread->base->portalvis[pnum >> 3] & ( 1 << ( pnum & 7 ) ) ) ) { // can't see anything new
                         continue;
                 }
  
                 // get plane of portal, point normal into the neighbor leaf
                 stack.portalplane = p->plane;
                         continue;
                 }
  
                 // get plane of portal, point normal into the neighbor leaf
                 stack.portalplane = p->plane;
-               VectorSubtract (vec3_origin, p->plane.normal, backplane.normal);
+               VectorSubtract( vec3_origin, p->plane.normal, backplane.normal );
                 backplane.dist = -p->plane.dist;
                 backplane.dist = -p->plane.dist;
-               
+
  //             c_portalcheck++;
  //             c_portalcheck++;
-               
+
                 stack.portal = p;
                 stack.next = NULL;
                 stack.freewindings[0] = 1;
                 stack.freewindings[1] = 1;
                 stack.freewindings[2] = 1;
                 stack.portal = p;
                 stack.next = NULL;
                 stack.freewindings[0] = 1;
                 stack.freewindings[1] = 1;
                 stack.freewindings[2] = 1;
-               
+
  #if 1
                 {
                         float d;
  
  #if 1
                 {
                         float d;
  
-                       d = DotProduct (p->origin, thread->pstack_head.portalplane.normal);
+                       d = DotProduct( p->origin, thread->pstack_head.portalplane.normal );
                         d -= thread->pstack_head.portalplane.dist;
                         d -= thread->pstack_head.portalplane.dist;
-                       if (d < -p->radius)
-                       {
+                       if ( d < -p->radius ) {
                                 continue;
                         }
                                 continue;
                         }
-                       else if (d > p->radius)
-                       {
+                       else if ( d > p->radius ) {
                                 stack.pass = p->winding;
                         }
                                 stack.pass = p->winding;
                         }
-                       else    
+                       else
                         {
                         {
-                               stack.pass = VisChopWinding (p->winding, &stack, &thread->pstack_head.portalplane);
-                               if (!stack.pass)
+                               stack.pass = VisChopWinding( p->winding, &stack, &thread->pstack_head.portalplane );
+                               if ( !stack.pass ) {
                                         continue;
                                         continue;
+                               }
                         }
                 }
  #else
                         }
                 }
  #else
-               stack.pass = VisChopWinding (p->winding, &stack, &thread->pstack_head.portalplane);
-               if (!stack.pass)
+               stack.pass = VisChopWinding( p->winding, &stack, &thread->pstack_head.portalplane );
+               if ( !stack.pass ) {
                         continue;
                         continue;
+               }
  #endif
  
  #endif
  
-       
+
  #if 1
                 {
                         float d;
  
  #if 1
                 {
                         float d;
  
-                       d = DotProduct (thread->base->origin, p->plane.normal);
+                       d = DotProduct( thread->base->origin, p->plane.normal );
                         d -= p->plane.dist;
                         //MrE: vis-bug fix
                         //if (d > p->radius)
                         d -= p->plane.dist;
                         //MrE: vis-bug fix
                         //if (d > p->radius)
-                       if (d > thread->base->radius)
-                       {
+                       if ( d > thread->base->radius ) {
                                 continue;
                         }
                         //MrE: vis-bug fix
                         //if (d < -p->radius)
                                 continue;
                         }
                         //MrE: vis-bug fix
                         //if (d < -p->radius)
-                       else if (d < -thread->base->radius)
-                       {
+                       else if ( d < -thread->base->radius ) {
                                 stack.source = prevstack->source;
                         }
                                 stack.source = prevstack->source;
                         }
-                       else    
+                       else
                         {
                         {
-                               stack.source = VisChopWinding (prevstack->source, &stack, &backplane);
+                               stack.source = VisChopWinding( prevstack->source, &stack, &backplane );
                                 //FIXME: shouldn't we create a new source origin and radius for fast checks?
                                 //FIXME: shouldn't we create a new source origin and radius for fast checks?
-                               if (!stack.source)
+                               if ( !stack.source ) {
                                         continue;
                                         continue;
+                               }
                         }
                 }
  #else
                         }
                 }
  #else
-               stack.source = VisChopWinding (prevstack->source, &stack, &backplane);
-               if (!stack.source)
+               stack.source = VisChopWinding( prevstack->source, &stack, &backplane );
+               if ( !stack.source ) {
                         continue;
                         continue;
+               }
  #endif
  
  #endif
  
-               if (!prevstack->pass)
-               {       // the second leaf can only be blocked if coplanar
+               if ( !prevstack->pass ) { // the second leaf can only be blocked if coplanar
  
                         // mark the portal as visible
  
                         // mark the portal as visible
-                       thread->base->portalvis[pnum>>3] |= (1<<(pnum&7));
+                       thread->base->portalvis[pnum >> 3] |= ( 1 << ( pnum & 7 ) );
  
  
-                       RecursiveLeafFlow (p->leaf, thread, &stack);
+                       RecursiveLeafFlow( p->leaf, thread, &stack );
                         continue;
                 }
  
  #ifdef SEPERATORCACHE
                         continue;
                 }
  
  #ifdef SEPERATORCACHE
-               if (stack.numseperators[0])
-               {
-                       for (n = 0; n < stack.numseperators[0]; n++)
+               if ( stack.numseperators[0] ) {
+                       for ( n = 0; n < stack.numseperators[0]; n++ )
                         {
                         {
-                               stack.pass = VisChopWinding (stack.pass, &stack, &stack.seperators[0][n]);
-                               if (!stack.pass)
-                                       break;          // target is not visible
+                               stack.pass = VisChopWinding( stack.pass, &stack, &stack.seperators[0][n] );
+                               if ( !stack.pass ) {
+                                       break;      // target is not visible
+                               }
                         }
                         }
-                       if (n < stack.numseperators[0])
+                       if ( n < stack.numseperators[0] ) {
                                 continue;
                                 continue;
+                       }
                 }
                 else
                 {
                 }
                 else
                 {
-                       stack.pass = ClipToSeperators (prevstack->source, prevstack->pass, stack.pass, qfalse, &stack);
+                       stack.pass = ClipToSeperators( prevstack->source, prevstack->pass, stack.pass, qfalse, &stack );
                 }
  #else
                 }
  #else
-               stack.pass = ClipToSeperators (stack.source, prevstack->pass, stack.pass, qfalse, &stack);
+               stack.pass = ClipToSeperators( stack.source, prevstack->pass, stack.pass, qfalse, &stack );
  #endif
  #endif
-               if (!stack.pass)
+               if ( !stack.pass ) {
                         continue;
                         continue;
+               }
  
  #ifdef SEPERATORCACHE
  
  #ifdef SEPERATORCACHE
-               if (stack.numseperators[1])
-               {
-                       for (n = 0; n < stack.numseperators[1]; n++)
+               if ( stack.numseperators[1] ) {
+                       for ( n = 0; n < stack.numseperators[1]; n++ )
                         {
                         {
-                               stack.pass = VisChopWinding (stack.pass, &stack, &stack.seperators[1][n]);
-                               if (!stack.pass)
-                                       break;          // target is not visible
+                               stack.pass = VisChopWinding( stack.pass, &stack, &stack.seperators[1][n] );
+                               if ( !stack.pass ) {
+                                       break;      // target is not visible
+                               }
                         }
                 }
                 else
                 {
                         }
                 }
                 else
                 {
-                       stack.pass = ClipToSeperators (prevstack->pass, prevstack->source, stack.pass, qtrue, &stack);
+                       stack.pass = ClipToSeperators( prevstack->pass, prevstack->source, stack.pass, qtrue, &stack );
                 }
  #else
                 }
  #else
-               stack.pass = ClipToSeperators (prevstack->pass, stack.source, stack.pass, qtrue, &stack);
+               stack.pass = ClipToSeperators( prevstack->pass, stack.source, stack.pass, qtrue, &stack );
  #endif
  #endif
-               if (!stack.pass)
+               if ( !stack.pass ) {
                         continue;
                         continue;
+               }
  
                 // mark the portal as visible
  
                 // mark the portal as visible
-               thread->base->portalvis[pnum>>3] |= (1<<(pnum&7));
+               thread->base->portalvis[pnum >> 3] |= ( 1 << ( pnum & 7 ) );
  
                 // flow through it for real
  
                 // flow through it for real
-               RecursiveLeafFlow (p->leaf, thread, &stack);
+               RecursiveLeafFlow( p->leaf, thread, &stack );
                 //
                 stack.next = NULL;
                 //
                 stack.next = NULL;
-       }       
+       }
  }
  
  /*
  }
  
  /*
-===============
-PortalFlow
-
-generates the portalvis bit vector
-===============
-*/
-void PortalFlow (int portalnum)
-{
-       threaddata_t    data;
-       int                             i;
-       vportal_t               *p;
-       int                             c_might, c_can;
+   ===============
+   PortalFlow
+
+   generates the portalvis bit vector
+   ===============
+ */
+void PortalFlow( int portalnum ){
+       threaddata_t data;
+       int i;
+       vportal_t       *p;
+       int c_might, c_can;
  
  #ifdef MREDEBUG
  
  #ifdef MREDEBUG
-       Sys_Printf("\r%6d", portalnum);
+       Sys_Printf( "\r%6d", portalnum );
  #endif
  
         p = sorted_portals[portalnum];
  
  #endif
  
         p = sorted_portals[portalnum];
  
-       if (p->removed)
-       {
+       if ( p->removed ) {
                 p->status = stat_done;
                 return;
         }
  
         p->status = stat_working;
  
                 p->status = stat_done;
                 return;
         }
  
         p->status = stat_working;
  
-       c_might = CountBits (p->portalflood, numportals*2);
+       c_might = CountBits( p->portalflood, numportals * 2 );
  
  
-       memset (&data, 0, sizeof(data));
+       memset( &data, 0, sizeof( data ) );
         data.base = p;
         data.base = p;
-       
+
         data.pstack_head.portal = p;
         data.pstack_head.source = p->winding;
         data.pstack_head.portalplane = p->plane;
         data.pstack_head.depth = 0;
         data.pstack_head.portal = p;
         data.pstack_head.source = p->winding;
         data.pstack_head.portalplane = p->plane;
         data.pstack_head.depth = 0;
-       for (i=0 ; i<portallongs ; i++)
-               ((long *)data.pstack_head.mightsee)[i] = ((long *)p->portalflood)[i];
+       for ( i = 0 ; i < portallongs ; i++ )
+               ( (long *)data.pstack_head.mightsee )[i] = ( (long *)p->portalflood )[i];
  
  
-       RecursiveLeafFlow (p->leaf, &data, &data.pstack_head);
+       RecursiveLeafFlow( p->leaf, &data, &data.pstack_head );
  
         p->status = stat_done;
  
  
         p->status = stat_done;
  
-       c_can = CountBits (p->portalvis, numportals*2);
+       c_can = CountBits( p->portalvis, numportals * 2 );
  
  
-       Sys_FPrintf (SYS_VRB,"portal:%4i  mightsee:%4i  cansee:%4i (%i chains)\n", 
-               (int)(p - portals),     c_might, c_can, data.c_chains);
+       Sys_FPrintf( SYS_VRB,"portal:%4i  mightsee:%4i  cansee:%4i (%i chains)\n",
+                                (int)( p - portals ), c_might, c_can, data.c_chains );
  }
  
  /*
  }
  
  /*
-==================
-RecursivePassageFlow
-==================
-*/
-void RecursivePassageFlow (vportal_t *portal, threaddata_t *thread, pstack_t *prevstack)
-{
-       pstack_t        stack;
-       vportal_t       *p;
-       leaf_t          *leaf;
-       passage_t       *passage, *nextpassage;
-       int                     i, j;
-       long            *might, *vis, *prevmight, *cansee, *portalvis, more;
-       int                     pnum;
+   ==================
+   RecursivePassageFlow
+   ==================
+ */
+void RecursivePassageFlow( vportal_t *portal, threaddata_t *thread, pstack_t *prevstack ){
+       pstack_t stack;
+       vportal_t   *p;
+       leaf_t      *leaf;
+       passage_t   *passage, *nextpassage;
+       int i, j;
+       long        *might, *vis, *prevmight, *cansee, *portalvis, more;
+       int pnum;
  
         leaf = &leafs[portal->leaf];
  
  
         leaf = &leafs[portal->leaf];
  
@@ -708,8 +715,8 @@ void RecursivePassageFlow (vportal_t *portal, threaddata_t *thread, pstack_t *pr
  
         passage = portal->passages;
         nextpassage = passage;
  
         passage = portal->passages;
         nextpassage = passage;
-       // check all portals for flowing into other leafs       
-       for (i = 0; i < leaf->numportals; i++, passage = nextpassage)
+       // check all portals for flowing into other leafs
+       for ( i = 0; i < leaf->numportals; i++, passage = nextpassage )
         {
                 p = leaf->portals[i];
                 if ( p->removed ) {
         {
                 p = leaf->portals[i];
                 if ( p->removed ) {
@@ -718,28 +725,29 @@ void RecursivePassageFlow (vportal_t *portal, threaddata_t *thread, pstack_t *pr
                 nextpassage = passage->next;
                 pnum = p - portals;
  
                 nextpassage = passage->next;
                 pnum = p - portals;
  
-               if ( ! (prevstack->mightsee[pnum >> 3] & (1<<(pnum&7)) ) ) {
-                       continue;       // can't possibly see it
+               if ( !( prevstack->mightsee[pnum >> 3] & ( 1 << ( pnum & 7 ) ) ) ) {
+                       continue;   // can't possibly see it
                 }
  
                 // mark the portal as visible
                 }
  
                 // mark the portal as visible
-               thread->base->portalvis[pnum>>3] |= (1<<(pnum&7));
+               thread->base->portalvis[pnum >> 3] |= ( 1 << ( pnum & 7 ) );
  
                 prevmight = (long *)prevstack->mightsee;
                 cansee = (long *)passage->cansee;
                 might = (long *)stack.mightsee;
  
                 prevmight = (long *)prevstack->mightsee;
                 cansee = (long *)passage->cansee;
                 might = (long *)stack.mightsee;
-               memcpy(might, prevmight, portalbytes);
-               if (p->status == stat_done)
+               memcpy( might, prevmight, portalbytes );
+               if ( p->status == stat_done ) {
                         portalvis = (long *) p->portalvis;
                         portalvis = (long *) p->portalvis;
-               else
+               }
+               else{
                         portalvis = (long *) p->portalflood;
                         portalvis = (long *) p->portalflood;
+               }
                 more = 0;
                 more = 0;
-               for (j = 0; j < portallongs; j++)
+               for ( j = 0; j < portallongs; j++ )
                 {
                 {
-                       if (*might)
-                       {
+                       if ( *might ) {
                                 *might &= *cansee++ & *portalvis++;
                                 *might &= *cansee++ & *portalvis++;
-                               more |= (*might & ~vis[j]);
+                               more |= ( *might & ~vis[j] );
                         }
                         else
                         {
                         }
                         else
                         {
@@ -755,32 +763,30 @@ void RecursivePassageFlow (vportal_t *portal, threaddata_t *thread, pstack_t *pr
                 }
  
                 // flow through it for real
                 }
  
                 // flow through it for real
-               RecursivePassageFlow(p, thread, &stack);
+               RecursivePassageFlow( p, thread, &stack );
  
                 stack.next = NULL;
         }
  }
  
  /*
  
                 stack.next = NULL;
         }
  }
  
  /*
-===============
-PassageFlow
-===============
-*/
-void PassageFlow (int portalnum)
-{
-       threaddata_t    data;
-       int                             i;
-       vportal_t               *p;
+   ===============
+   PassageFlow
+   ===============
+ */
+void PassageFlow( int portalnum ){
+       threaddata_t data;
+       int i;
+       vportal_t       *p;
  //     int                             c_might, c_can;
  
  #ifdef MREDEBUG
  //     int                             c_might, c_can;
  
  #ifdef MREDEBUG
-       Sys_Printf("\r%6d", portalnum);
+       Sys_Printf( "\r%6d", portalnum );
  #endif
  
         p = sorted_portals[portalnum];
  
  #endif
  
         p = sorted_portals[portalnum];
  
-       if (p->removed)
-       {
+       if ( p->removed ) {
                 p->status = stat_done;
                 return;
         }
                 p->status = stat_done;
                 return;
         }
@@ -789,43 +795,42 @@ void PassageFlow (int portalnum)
  
  //     c_might = CountBits (p->portalflood, numportals*2);
  
  
  //     c_might = CountBits (p->portalflood, numportals*2);
  
-       memset (&data, 0, sizeof(data));
+       memset( &data, 0, sizeof( data ) );
         data.base = p;
         data.base = p;
-       
+
         data.pstack_head.portal = p;
         data.pstack_head.source = p->winding;
         data.pstack_head.portalplane = p->plane;
         data.pstack_head.depth = 0;
         data.pstack_head.portal = p;
         data.pstack_head.source = p->winding;
         data.pstack_head.portalplane = p->plane;
         data.pstack_head.depth = 0;
-       for (i=0 ; i<portallongs ; i++)
-               ((long *)data.pstack_head.mightsee)[i] = ((long *)p->portalflood)[i];
+       for ( i = 0 ; i < portallongs ; i++ )
+               ( (long *)data.pstack_head.mightsee )[i] = ( (long *)p->portalflood )[i];
  
  
-       RecursivePassageFlow (p, &data, &data.pstack_head);
+       RecursivePassageFlow( p, &data, &data.pstack_head );
  
         p->status = stat_done;
  
         /*
  
         p->status = stat_done;
  
         /*
-       c_can = CountBits (p->portalvis, numportals*2);
+          c_can = CountBits (p->portalvis, numportals*2);
  
  
-       Sys_FPrintf (SYS_VRB,"portal:%4i  mightsee:%4i  cansee:%4i (%i chains)\n", 
-               (int)(p - portals),     c_might, c_can, data.c_chains);
-       */
+          Sys_FPrintf (SYS_VRB,"portal:%4i  mightsee:%4i  cansee:%4i (%i chains)\n",
+           (int)(p - portals), c_might, c_can, data.c_chains);
+        */
  }
  
  /*
  }
  
  /*
-==================
-RecursivePassagePortalFlow
-==================
-*/
-void RecursivePassagePortalFlow (vportal_t *portal, threaddata_t *thread, pstack_t *prevstack)
-{
-       pstack_t        stack;
-       vportal_t       *p;
-       leaf_t          *leaf;
-       visPlane_t              backplane;
-       passage_t       *passage, *nextpassage;
-       int                     i, j, n;
-       long            *might, *vis, *prevmight, *cansee, *portalvis, more;
-       int                     pnum;
+   ==================
+   RecursivePassagePortalFlow
+   ==================
+ */
+void RecursivePassagePortalFlow( vportal_t *portal, threaddata_t *thread, pstack_t *prevstack ){
+       pstack_t stack;
+       vportal_t   *p;
+       leaf_t      *leaf;
+       visPlane_t backplane;
+       passage_t   *passage, *nextpassage;
+       int i, j, n;
+       long        *might, *vis, *prevmight, *cansee, *portalvis, more;
+       int pnum;
  
  //     thread->c_chains++;
  
  
  //     thread->c_chains++;
  
@@ -848,33 +853,36 @@ void RecursivePassagePortalFlow (vportal_t *portal, threaddata_t *thread, pstack
  
         passage = portal->passages;
         nextpassage = passage;
  
         passage = portal->passages;
         nextpassage = passage;
-       // check all portals for flowing into other leafs       
-       for (i = 0; i < leaf->numportals; i++, passage = nextpassage)
+       // check all portals for flowing into other leafs
+       for ( i = 0; i < leaf->numportals; i++, passage = nextpassage )
         {
                 p = leaf->portals[i];
         {
                 p = leaf->portals[i];
-               if (p->removed)
+               if ( p->removed ) {
                         continue;
                         continue;
+               }
                 nextpassage = passage->next;
                 pnum = p - portals;
  
                 nextpassage = passage->next;
                 pnum = p - portals;
  
-               if ( ! (prevstack->mightsee[pnum >> 3] & (1<<(pnum&7)) ) )
-                       continue;       // can't possibly see it
+               if ( !( prevstack->mightsee[pnum >> 3] & ( 1 << ( pnum & 7 ) ) ) ) {
+                       continue;   // can't possibly see it
  
  
+               }
                 prevmight = (long *)prevstack->mightsee;
                 cansee = (long *)passage->cansee;
                 might = (long *)stack.mightsee;
                 prevmight = (long *)prevstack->mightsee;
                 cansee = (long *)passage->cansee;
                 might = (long *)stack.mightsee;
-               memcpy(might, prevmight, portalbytes);
-               if (p->status == stat_done)
+               memcpy( might, prevmight, portalbytes );
+               if ( p->status == stat_done ) {
                         portalvis = (long *) p->portalvis;
                         portalvis = (long *) p->portalvis;
-               else
+               }
+               else{
                         portalvis = (long *) p->portalflood;
                         portalvis = (long *) p->portalflood;
+               }
                 more = 0;
                 more = 0;
-               for (j = 0; j < portallongs; j++)
+               for ( j = 0; j < portallongs; j++ )
                 {
                 {
-                       if (*might)
-                       {
+                       if ( *might ) {
                                 *might &= *cansee++ & *portalvis++;
                                 *might &= *cansee++ & *portalvis++;
-                               more |= (*might & ~vis[j]);
+                               more |= ( *might & ~vis[j] );
                         }
                         else
                         {
                         }
                         else
                         {
@@ -884,18 +892,17 @@ void RecursivePassagePortalFlow (vportal_t *portal, threaddata_t *thread, pstack
                         might++;
                 }
  
                         might++;
                 }
  
-               if (!more && (thread->base->portalvis[pnum>>3] & (1<<(pnum&7))) )
-               {       // can't see anything new
+               if ( !more && ( thread->base->portalvis[pnum >> 3] & ( 1 << ( pnum & 7 ) ) ) ) { // can't see anything new
                         continue;
                 }
  
                 // get plane of portal, point normal into the neighbor leaf
                 stack.portalplane = p->plane;
                         continue;
                 }
  
                 // get plane of portal, point normal into the neighbor leaf
                 stack.portalplane = p->plane;
-               VectorSubtract (vec3_origin, p->plane.normal, backplane.normal);
+               VectorSubtract( vec3_origin, p->plane.normal, backplane.normal );
                 backplane.dist = -p->plane.dist;
                 backplane.dist = -p->plane.dist;
-               
+
  //             c_portalcheck++;
  //             c_portalcheck++;
-               
+
                 stack.portal = p;
                 stack.next = NULL;
                 stack.freewindings[0] = 1;
                 stack.portal = p;
                 stack.next = NULL;
                 stack.freewindings[0] = 1;
@@ -906,144 +913,144 @@ void RecursivePassagePortalFlow (vportal_t *portal, threaddata_t *thread, pstack
                 {
                         float d;
  
                 {
                         float d;
  
-                       d = DotProduct (p->origin, thread->pstack_head.portalplane.normal);
+                       d = DotProduct( p->origin, thread->pstack_head.portalplane.normal );
                         d -= thread->pstack_head.portalplane.dist;
                         d -= thread->pstack_head.portalplane.dist;
-                       if (d < -p->radius)
-                       {
+                       if ( d < -p->radius ) {
                                 continue;
                         }
                                 continue;
                         }
-                       else if (d > p->radius)
-                       {
+                       else if ( d > p->radius ) {
                                 stack.pass = p->winding;
                         }
                                 stack.pass = p->winding;
                         }
-                       else    
+                       else
                         {
                         {
-                               stack.pass = VisChopWinding (p->winding, &stack, &thread->pstack_head.portalplane);
-                               if (!stack.pass)
+                               stack.pass = VisChopWinding( p->winding, &stack, &thread->pstack_head.portalplane );
+                               if ( !stack.pass ) {
                                         continue;
                                         continue;
+                               }
                         }
                 }
  #else
                         }
                 }
  #else
-               stack.pass = VisChopWinding (p->winding, &stack, &thread->pstack_head.portalplane);
-               if (!stack.pass)
+               stack.pass = VisChopWinding( p->winding, &stack, &thread->pstack_head.portalplane );
+               if ( !stack.pass ) {
                         continue;
                         continue;
+               }
  #endif
  
  #endif
  
-       
+
  #if 1
                 {
                         float d;
  
  #if 1
                 {
                         float d;
  
-                       d = DotProduct (thread->base->origin, p->plane.normal);
+                       d = DotProduct( thread->base->origin, p->plane.normal );
                         d -= p->plane.dist;
                         //MrE: vis-bug fix
                         //if (d > p->radius)
                         d -= p->plane.dist;
                         //MrE: vis-bug fix
                         //if (d > p->radius)
-                       if (d > thread->base->radius)
-                       {
+                       if ( d > thread->base->radius ) {
                                 continue;
                         }
                         //MrE: vis-bug fix
                         //if (d < -p->radius)
                                 continue;
                         }
                         //MrE: vis-bug fix
                         //if (d < -p->radius)
-                       else if (d < -thread->base->radius)
-                       {
+                       else if ( d < -thread->base->radius ) {
                                 stack.source = prevstack->source;
                         }
                                 stack.source = prevstack->source;
                         }
-                       else    
+                       else
                         {
                         {
-                               stack.source = VisChopWinding (prevstack->source, &stack, &backplane);
+                               stack.source = VisChopWinding( prevstack->source, &stack, &backplane );
                                 //FIXME: shouldn't we create a new source origin and radius for fast checks?
                                 //FIXME: shouldn't we create a new source origin and radius for fast checks?
-                               if (!stack.source)
+                               if ( !stack.source ) {
                                         continue;
                                         continue;
+                               }
                         }
                 }
  #else
                         }
                 }
  #else
-               stack.source = VisChopWinding (prevstack->source, &stack, &backplane);
-               if (!stack.source)
+               stack.source = VisChopWinding( prevstack->source, &stack, &backplane );
+               if ( !stack.source ) {
                         continue;
                         continue;
+               }
  #endif
  
  #endif
  
-               if (!prevstack->pass)
-               {       // the second leaf can only be blocked if coplanar
+               if ( !prevstack->pass ) { // the second leaf can only be blocked if coplanar
  
                         // mark the portal as visible
  
                         // mark the portal as visible
-                       thread->base->portalvis[pnum>>3] |= (1<<(pnum&7));
+                       thread->base->portalvis[pnum >> 3] |= ( 1 << ( pnum & 7 ) );
  
  
-                       RecursivePassagePortalFlow (p, thread, &stack);
+                       RecursivePassagePortalFlow( p, thread, &stack );
                         continue;
                 }
  
  #ifdef SEPERATORCACHE
                         continue;
                 }
  
  #ifdef SEPERATORCACHE
-               if (stack.numseperators[0])
-               {
-                       for (n = 0; n < stack.numseperators[0]; n++)
+               if ( stack.numseperators[0] ) {
+                       for ( n = 0; n < stack.numseperators[0]; n++ )
                         {
                         {
-                               stack.pass = VisChopWinding (stack.pass, &stack, &stack.seperators[0][n]);
-                               if (!stack.pass)
-                                       break;          // target is not visible
+                               stack.pass = VisChopWinding( stack.pass, &stack, &stack.seperators[0][n] );
+                               if ( !stack.pass ) {
+                                       break;      // target is not visible
+                               }
                         }
                         }
-                       if (n < stack.numseperators[0])
+                       if ( n < stack.numseperators[0] ) {
                                 continue;
                                 continue;
+                       }
                 }
                 else
                 {
                 }
                 else
                 {
-                       stack.pass = ClipToSeperators (prevstack->source, prevstack->pass, stack.pass, qfalse, &stack);
+                       stack.pass = ClipToSeperators( prevstack->source, prevstack->pass, stack.pass, qfalse, &stack );
                 }
  #else
                 }
  #else
-               stack.pass = ClipToSeperators (stack.source, prevstack->pass, stack.pass, qfalse, &stack);
+               stack.pass = ClipToSeperators( stack.source, prevstack->pass, stack.pass, qfalse, &stack );
  #endif
  #endif
-               if (!stack.pass)
+               if ( !stack.pass ) {
                         continue;
                         continue;
+               }
  
  #ifdef SEPERATORCACHE
  
  #ifdef SEPERATORCACHE
-               if (stack.numseperators[1])
-               {
-                       for (n = 0; n < stack.numseperators[1]; n++)
+               if ( stack.numseperators[1] ) {
+                       for ( n = 0; n < stack.numseperators[1]; n++ )
                         {
                         {
-                               stack.pass = VisChopWinding (stack.pass, &stack, &stack.seperators[1][n]);
-                               if (!stack.pass)
-                                       break;          // target is not visible
+                               stack.pass = VisChopWinding( stack.pass, &stack, &stack.seperators[1][n] );
+                               if ( !stack.pass ) {
+                                       break;      // target is not visible
+                               }
                         }
                 }
                 else
                 {
                         }
                 }
                 else
                 {
-                       stack.pass = ClipToSeperators (prevstack->pass, prevstack->source, stack.pass, qtrue, &stack);
+                       stack.pass = ClipToSeperators( prevstack->pass, prevstack->source, stack.pass, qtrue, &stack );
                 }
  #else
                 }
  #else
-               stack.pass = ClipToSeperators (prevstack->pass, stack.source, stack.pass, qtrue, &stack);
+               stack.pass = ClipToSeperators( prevstack->pass, stack.source, stack.pass, qtrue, &stack );
  #endif
  #endif
-               if (!stack.pass)
+               if ( !stack.pass ) {
                         continue;
                         continue;
+               }
  
                 // mark the portal as visible
  
                 // mark the portal as visible
-               thread->base->portalvis[pnum>>3] |= (1<<(pnum&7));
+               thread->base->portalvis[pnum >> 3] |= ( 1 << ( pnum & 7 ) );
  
                 // flow through it for real
  
                 // flow through it for real
-               RecursivePassagePortalFlow(p, thread, &stack);
+               RecursivePassagePortalFlow( p, thread, &stack );
                 //
                 stack.next = NULL;
         }
  }
  
  /*
                 //
                 stack.next = NULL;
         }
  }
  
  /*
-===============
-PassagePortalFlow
-===============
-*/
-void PassagePortalFlow (int portalnum)
-{
-       threaddata_t    data;
-       int                             i;
-       vportal_t               *p;
+   ===============
+   PassagePortalFlow
+   ===============
+ */
+void PassagePortalFlow( int portalnum ){
+       threaddata_t data;
+       int i;
+       vportal_t       *p;
  //     int                             c_might, c_can;
  
  #ifdef MREDEBUG
  //     int                             c_might, c_can;
  
  #ifdef MREDEBUG
-       Sys_Printf("\r%6d", portalnum);
+       Sys_Printf( "\r%6d", portalnum );
  #endif
  
         p = sorted_portals[portalnum];
  
  #endif
  
         p = sorted_portals[portalnum];
  
-       if (p->removed)
-       {
+       if ( p->removed ) {
                 p->status = stat_done;
                 return;
         }
                 p->status = stat_done;
                 return;
         }
@@ -1052,51 +1059,52 @@ void PassagePortalFlow (int portalnum)
  
  //     c_might = CountBits (p->portalflood, numportals*2);
  
  
  //     c_might = CountBits (p->portalflood, numportals*2);
  
-       memset (&data, 0, sizeof(data));
+       memset( &data, 0, sizeof( data ) );
         data.base = p;
         data.base = p;
-       
+
         data.pstack_head.portal = p;
         data.pstack_head.source = p->winding;
         data.pstack_head.portalplane = p->plane;
         data.pstack_head.depth = 0;
         data.pstack_head.portal = p;
         data.pstack_head.source = p->winding;
         data.pstack_head.portalplane = p->plane;
         data.pstack_head.depth = 0;
-       for (i=0 ; i<portallongs ; i++)
-               ((long *)data.pstack_head.mightsee)[i] = ((long *)p->portalflood)[i];
+       for ( i = 0 ; i < portallongs ; i++ )
+               ( (long *)data.pstack_head.mightsee )[i] = ( (long *)p->portalflood )[i];
  
  
-       RecursivePassagePortalFlow (p, &data, &data.pstack_head);
+       RecursivePassagePortalFlow( p, &data, &data.pstack_head );
  
         p->status = stat_done;
  
         /*
  
         p->status = stat_done;
  
         /*
-       c_can = CountBits (p->portalvis, numportals*2);
+          c_can = CountBits (p->portalvis, numportals*2);
  
  
-       Sys_FPrintf (SYS_VRB,"portal:%4i  mightsee:%4i  cansee:%4i (%i chains)\n", 
-               (int)(p - portals),     c_might, c_can, data.c_chains);
-       */
+          Sys_FPrintf (SYS_VRB,"portal:%4i  mightsee:%4i  cansee:%4i (%i chains)\n",
+           (int)(p - portals), c_might, c_can, data.c_chains);
+        */
  }
  
  }
  
-fixedWinding_t *PassageChopWinding (fixedWinding_t *in, fixedWinding_t *out, visPlane_t *split)
-{
-       vec_t   dists[128];
-       int             sides[128];
-       int             counts[3];
-       vec_t   dot;
-       int             i, j;
-       vec_t   *p1, *p2;
-       vec3_t  mid;
-       fixedWinding_t  *neww;
+fixedWinding_t *PassageChopWinding( fixedWinding_t *in, fixedWinding_t *out, visPlane_t *split ){
+       vec_t dists[128];
+       int sides[128];
+       int counts[3];
+       vec_t dot;
+       int i, j;
+       vec_t   *p1, *p2;
+       vec3_t mid;
+       fixedWinding_t  *neww;
  
         counts[0] = counts[1] = counts[2] = 0;
  
         // determine sides for each point
  
         counts[0] = counts[1] = counts[2] = 0;
  
         // determine sides for each point
-       for (i=0 ; i<in->numpoints ; i++)
+       for ( i = 0 ; i < in->numpoints ; i++ )
         {
         {
-               dot = DotProduct (in->points[i], split->normal);
+               dot = DotProduct( in->points[i], split->normal );
                 dot -= split->dist;
                 dists[i] = dot;
                 dot -= split->dist;
                 dists[i] = dot;
-               if (dot > ON_EPSILON)
+               if ( dot > ON_EPSILON ) {
                         sides[i] = SIDE_FRONT;
                         sides[i] = SIDE_FRONT;
-               else if (dot < -ON_EPSILON)
+               }
+               else if ( dot < -ON_EPSILON ) {
                         sides[i] = SIDE_BACK;
                         sides[i] = SIDE_BACK;
+               }
                 else
                 {
                         sides[i] = SIDE_ON;
                 else
                 {
                         sides[i] = SIDE_ON;
@@ -1104,121 +1112,121 @@ fixedWinding_t *PassageChopWinding (fixedWinding_t *in, fixedWinding_t *out, vis
                 counts[sides[i]]++;
         }
  
                 counts[sides[i]]++;
         }
  
-       if (!counts[1])
-               return in;              // completely on front side
-       
-       if (!counts[0])
-       {
+       if ( !counts[1] ) {
+               return in;      // completely on front side
+
+       }
+       if ( !counts[0] ) {
                 return NULL;
         }
  
         sides[i] = sides[0];
         dists[i] = dists[0];
                 return NULL;
         }
  
         sides[i] = sides[0];
         dists[i] = dists[0];
-       
+
         neww = out;
  
         neww->numpoints = 0;
  
         neww = out;
  
         neww->numpoints = 0;
  
-       for (i=0 ; i<in->numpoints ; i++)
+       for ( i = 0 ; i < in->numpoints ; i++ )
         {
                 p1 = in->points[i];
  
         {
                 p1 = in->points[i];
  
-               if (neww->numpoints == MAX_POINTS_ON_FIXED_WINDING)
-               {
-                       return in;              // can't chop -- fall back to original
+               if ( neww->numpoints == MAX_POINTS_ON_FIXED_WINDING ) {
+                       return in;      // can't chop -- fall back to original
                 }
  
                 }
  
-               if (sides[i] == SIDE_ON)
-               {
-                       VectorCopy (p1, neww->points[neww->numpoints]);
+               if ( sides[i] == SIDE_ON ) {
+                       VectorCopy( p1, neww->points[neww->numpoints] );
                         neww->numpoints++;
                         continue;
                 }
                         neww->numpoints++;
                         continue;
                 }
-       
-               if (sides[i] == SIDE_FRONT)
-               {
-                       VectorCopy (p1, neww->points[neww->numpoints]);
+
+               if ( sides[i] == SIDE_FRONT ) {
+                       VectorCopy( p1, neww->points[neww->numpoints] );
                         neww->numpoints++;
                 }
                         neww->numpoints++;
                 }
-               
-               if (sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
+
+               if ( sides[i + 1] == SIDE_ON || sides[i + 1] == sides[i] ) {
                         continue;
                         continue;
-                       
-               if (neww->numpoints == MAX_POINTS_ON_FIXED_WINDING)
-               {
-                       return in;              // can't chop -- fall back to original
+               }
+
+               if ( neww->numpoints == MAX_POINTS_ON_FIXED_WINDING ) {
+                       return in;      // can't chop -- fall back to original
                 }
  
                 // generate a split point
                 }
  
                 // generate a split point
-               p2 = in->points[(i+1)%in->numpoints];
-               
-               dot = dists[i] / (dists[i]-dists[i+1]);
-               for (j=0 ; j<3 ; j++)
-               {       // avoid round off error when possible
-                       if (split->normal[j] == 1)
+               p2 = in->points[( i + 1 ) % in->numpoints];
+
+               dot = dists[i] / ( dists[i] - dists[i + 1] );
+               for ( j = 0 ; j < 3 ; j++ )
+               {   // avoid round off error when possible
+                       if ( split->normal[j] == 1 ) {
                                 mid[j] = split->dist;
                                 mid[j] = split->dist;
-                       else if (split->normal[j] == -1)
+                       }
+                       else if ( split->normal[j] == -1 ) {
                                 mid[j] = -split->dist;
                                 mid[j] = -split->dist;
-                       else
-                               mid[j] = p1[j] + dot*(p2[j]-p1[j]);
+                       }
+                       else{
+                               mid[j] = p1[j] + dot * ( p2[j] - p1[j] );
+                       }
                 }
                 }
-                       
-               VectorCopy (mid, neww->points[neww->numpoints]);
+
+               VectorCopy( mid, neww->points[neww->numpoints] );
                 neww->numpoints++;
         }
                 neww->numpoints++;
         }
-       
+
         return neww;
  }
  
  /*
         return neww;
  }
  
  /*
-===============
-AddSeperators
-===============
-*/
-int AddSeperators (fixedWinding_t *source, fixedWinding_t *pass, qboolean flipclip, visPlane_t *seperators, int maxseperators)
-{
-       int                     i, j, k, l;
-       visPlane_t              plane;
-       vec3_t          v1, v2;
-       float           d;
-       vec_t           length;
-       int                     counts[3], numseperators;
-       qboolean        fliptest;
+   ===============
+   AddSeperators
+   ===============
+ */
+int AddSeperators( fixedWinding_t *source, fixedWinding_t *pass, qboolean flipclip, visPlane_t *seperators, int maxseperators ){
+       int i, j, k, l;
+       visPlane_t plane;
+       vec3_t v1, v2;
+       float d;
+       vec_t length;
+       int counts[3], numseperators;
+       qboolean fliptest;
  
         numseperators = 0;
  
         numseperators = 0;
-       // check all combinations       
-       for (i=0 ; i<source->numpoints ; i++)
+       // check all combinations
+       for ( i = 0 ; i < source->numpoints ; i++ )
         {
         {
-               l = (i+1)%source->numpoints;
-               VectorSubtract (source->points[l] , source->points[i], v1);
+               l = ( i + 1 ) % source->numpoints;
+               VectorSubtract( source->points[l], source->points[i], v1 );
  
                 // find a vertex of pass that makes a plane that puts all of the
                 // vertexes of pass on the front side and all of the vertexes of
                 // source on the back side
  
                 // find a vertex of pass that makes a plane that puts all of the
                 // vertexes of pass on the front side and all of the vertexes of
                 // source on the back side
-               for (j=0 ; j<pass->numpoints ; j++)
+               for ( j = 0 ; j < pass->numpoints ; j++ )
                 {
                 {
-                       VectorSubtract (pass->points[j], source->points[i], v2);
+                       VectorSubtract( pass->points[j], source->points[i], v2 );
+
+                       plane.normal[0] = v1[1] * v2[2] - v1[2] * v2[1];
+                       plane.normal[1] = v1[2] * v2[0] - v1[0] * v2[2];
+                       plane.normal[2] = v1[0] * v2[1] - v1[1] * v2[0];
  
  
-                       plane.normal[0] = v1[1]*v2[2] - v1[2]*v2[1];
-                       plane.normal[1] = v1[2]*v2[0] - v1[0]*v2[2];
-                       plane.normal[2] = v1[0]*v2[1] - v1[1]*v2[0];
-                       
                         // if points don't make a valid plane, skip it
  
                         length = plane.normal[0] * plane.normal[0]
                         // if points don't make a valid plane, skip it
  
                         length = plane.normal[0] * plane.normal[0]
-                       + plane.normal[1] * plane.normal[1]
-                       + plane.normal[2] * plane.normal[2];
-                       
-                       if (length < ON_EPSILON)
+                                        + plane.normal[1] * plane.normal[1]
+                                        + plane.normal[2] * plane.normal[2];
+
+                       if ( length < ON_EPSILON ) {
                                 continue;
                                 continue;
+                       }
+
+                       length = 1 / sqrt( length );
  
  
-                       length = 1/sqrt(length);
-                       
                         plane.normal[0] *= length;
                         plane.normal[1] *= length;
                         plane.normal[2] *= length;
  
                         plane.normal[0] *= length;
                         plane.normal[1] *= length;
                         plane.normal[2] *= length;
  
-                       plane.dist = DotProduct (pass->points[j], plane.normal);
+                       plane.dist = DotProduct( pass->points[j], plane.normal );
  
                         //
                         // find out which side of the generated seperating plane has the
  
                         //
                         // find out which side of the generated seperating plane has the
@@ -1226,35 +1234,34 @@ int AddSeperators (fixedWinding_t *source, fixedWinding_t *pass, qboolean flipcl
                         //
  #if 1
                         fliptest = qfalse;
                         //
  #if 1
                         fliptest = qfalse;
-                       for (k=0 ; k<source->numpoints ; k++)
+                       for ( k = 0 ; k < source->numpoints ; k++ )
                         {
                         {
-                               if (k == i || k == l)
+                               if ( k == i || k == l ) {
                                         continue;
                                         continue;
-                               d = DotProduct (source->points[k], plane.normal) - plane.dist;
-                               if (d < -ON_EPSILON)
-                               {       // source is on the negative side, so we want all
-                                       // pass and target on the positive side
+                               }
+                               d = DotProduct( source->points[k], plane.normal ) - plane.dist;
+                               if ( d < -ON_EPSILON ) { // source is on the negative side, so we want all
+                                                           // pass and target on the positive side
                                         fliptest = qfalse;
                                         break;
                                 }
                                         fliptest = qfalse;
                                         break;
                                 }
-                               else if (d > ON_EPSILON)
-                               {       // source is on the positive side, so we want all
-                                       // pass and target on the negative side
+                               else if ( d > ON_EPSILON ) { // source is on the positive side, so we want all
+                                                               // pass and target on the negative side
                                         fliptest = qtrue;
                                         break;
                                 }
                         }
                                         fliptest = qtrue;
                                         break;
                                 }
                         }
-                       if (k == source->numpoints)
-                               continue;               // planar with source portal
+                       if ( k == source->numpoints ) {
+                               continue;       // planar with source portal
+                       }
  #else
                         fliptest = flipclip;
  #endif
                         //
                         // flip the normal if the source portal is backwards
                         //
  #else
                         fliptest = flipclip;
  #endif
                         //
                         // flip the normal if the source portal is backwards
                         //
-                       if (fliptest)
-                       {
-                               VectorSubtract (vec3_origin, plane.normal, plane.normal);
+                       if ( fliptest ) {
+                               VectorSubtract( vec3_origin, plane.normal, plane.normal );
                                 plane.dist = -plane.dist;
                         }
  #if 1
                                 plane.dist = -plane.dist;
                         }
  #if 1
@@ -1263,44 +1270,52 @@ int AddSeperators (fixedWinding_t *source, fixedWinding_t *pass, qboolean flipcl
                         // this is the seperating plane
                         //
                         counts[0] = counts[1] = counts[2] = 0;
                         // this is the seperating plane
                         //
                         counts[0] = counts[1] = counts[2] = 0;
-                       for (k=0 ; k<pass->numpoints ; k++)
+                       for ( k = 0 ; k < pass->numpoints ; k++ )
                         {
                         {
-                               if (k==j)
+                               if ( k == j ) {
                                         continue;
                                         continue;
-                               d = DotProduct (pass->points[k], plane.normal) - plane.dist;
-                               if (d < -ON_EPSILON)
+                               }
+                               d = DotProduct( pass->points[k], plane.normal ) - plane.dist;
+                               if ( d < -ON_EPSILON ) {
                                         break;
                                         break;
-                               else if (d > ON_EPSILON)
+                               }
+                               else if ( d > ON_EPSILON ) {
                                         counts[0]++;
                                         counts[0]++;
-                               else
+                               }
+                               else{
                                         counts[2]++;
                                         counts[2]++;
+                               }
+                       }
+                       if ( k != pass->numpoints ) {
+                               continue;   // points on negative side, not a seperating plane
+
+                       }
+                       if ( !counts[0] ) {
+                               continue;   // planar with seperating plane
                         }
                         }
-                       if (k != pass->numpoints)
-                               continue;       // points on negative side, not a seperating plane
-                               
-                       if (!counts[0])
-                               continue;       // planar with seperating plane
  #else
  #else
-                       k = (j+1)%pass->numpoints;
-                       d = DotProduct (pass->points[k], plane.normal) - plane.dist;
-                       if (d < -ON_EPSILON)
+                       k = ( j + 1 ) % pass->numpoints;
+                       d = DotProduct( pass->points[k], plane.normal ) - plane.dist;
+                       if ( d < -ON_EPSILON ) {
                                 continue;
                                 continue;
-                       k = (j+pass->numpoints-1)%pass->numpoints;
-                       d = DotProduct (pass->points[k], plane.normal) - plane.dist;
-                       if (d < -ON_EPSILON)
-                               continue;                       
+                       }
+                       k = ( j + pass->numpoints - 1 ) % pass->numpoints;
+                       d = DotProduct( pass->points[k], plane.normal ) - plane.dist;
+                       if ( d < -ON_EPSILON ) {
+                               continue;
+                       }
  #endif
                         //
                         // flip the normal if we want the back side
                         //
  #endif
                         //
                         // flip the normal if we want the back side
                         //
-                       if (flipclip)
-                       {
-                               VectorSubtract (vec3_origin, plane.normal, plane.normal);
+                       if ( flipclip ) {
+                               VectorSubtract( vec3_origin, plane.normal, plane.normal );
                                 plane.dist = -plane.dist;
                         }
  
                                 plane.dist = -plane.dist;
                         }
  
-                       if (numseperators >= maxseperators)
-                               Error("max seperators");
+                       if ( numseperators >= maxseperators ) {
+                               Error( "max seperators" );
+                       }
                         seperators[numseperators] = plane;
                         numseperators++;
                         break;
                         seperators[numseperators] = plane;
                         numseperators++;
                         break;
@@ -1310,316 +1325,336 @@ int AddSeperators (fixedWinding_t *source, fixedWinding_t *pass, qboolean flipcl
  }
  
  /*
  }
  
  /*
-===============
-CreatePassages
-
-MrE: create passages from one portal to all the portals in the leaf the portal leads to
-        every passage has a cansee bit string with all the portals that can be
-        seen through the passage
-===============
-*/
-void CreatePassages(int portalnum)
-{
-       int                             i, j, k, n, numseperators, numsee;
-       float                   d;
-       vportal_t               *portal, *p, *target;
-       leaf_t                  *leaf;
-       passage_t               *passage, *lastpassage;
-       visPlane_t              seperators[MAX_SEPERATORS*2];
-       fixedWinding_t  *w;
-       fixedWinding_t  in, out, *res;
-       
-       
+   ===============
+   CreatePassages
+
+   MrE: create passages from one portal to all the portals in the leaf the portal leads to
+     every passage has a cansee bit string with all the portals that can be
+     seen through the passage
+   ===============
+ */
+void CreatePassages( int portalnum ){
+       int i, j, k, n, numseperators, numsee;
+       float d;
+       vportal_t       *portal, *p, *target;
+       leaf_t          *leaf;
+       passage_t       *passage, *lastpassage;
+       visPlane_t seperators[MAX_SEPERATORS * 2];
+       fixedWinding_t  *w;
+       fixedWinding_t in, out, *res;
+
+
  #ifdef MREDEBUG
  #ifdef MREDEBUG
-       Sys_Printf("\r%6d", portalnum);
+       Sys_Printf( "\r%6d", portalnum );
  #endif
  
         portal = sorted_portals[portalnum];
  
  #endif
  
         portal = sorted_portals[portalnum];
  
-       if (portal->removed)
-       {
+       if ( portal->removed ) {
                 portal->status = stat_done;
                 return;
         }
  
         lastpassage = NULL;
         leaf = &leafs[portal->leaf];
                 portal->status = stat_done;
                 return;
         }
  
         lastpassage = NULL;
         leaf = &leafs[portal->leaf];
-       for (i = 0; i < leaf->numportals; i++)
+       for ( i = 0; i < leaf->numportals; i++ )
         {
                 target = leaf->portals[i];
         {
                 target = leaf->portals[i];
-               if (target->removed)
+               if ( target->removed ) {
                         continue;
                         continue;
+               }
  
  
-               passage = (passage_t *) safe_malloc(sizeof(passage_t) + portalbytes);
-               memset(passage, 0, sizeof(passage_t) + portalbytes);
-               numseperators = AddSeperators(portal->winding, target->winding, qfalse, seperators, MAX_SEPERATORS*2);
-               numseperators += AddSeperators(target->winding, portal->winding, qtrue, &seperators[numseperators], MAX_SEPERATORS*2-numseperators);
+               passage = (passage_t *) safe_malloc( sizeof( passage_t ) + portalbytes );
+               memset( passage, 0, sizeof( passage_t ) + portalbytes );
+               numseperators = AddSeperators( portal->winding, target->winding, qfalse, seperators, MAX_SEPERATORS * 2 );
+               numseperators += AddSeperators( target->winding, portal->winding, qtrue, &seperators[numseperators], MAX_SEPERATORS * 2 - numseperators );
  
                 passage->next = NULL;
  
                 passage->next = NULL;
-               if (lastpassage)
+               if ( lastpassage ) {
                         lastpassage->next = passage;
                         lastpassage->next = passage;
-               else
+               }
+               else{
                         portal->passages = passage;
                         portal->passages = passage;
+               }
                 lastpassage = passage;
  
                 numsee = 0;
                 //create the passage->cansee
                 lastpassage = passage;
  
                 numsee = 0;
                 //create the passage->cansee
-               for (j = 0; j < numportals * 2; j++)
+               for ( j = 0; j < numportals * 2; j++ )
                 {
                         p = &portals[j];
                 {
                         p = &portals[j];
-                       if (p->removed)
+                       if ( p->removed ) {
                                 continue;
                                 continue;
-                       if ( ! (target->portalflood[j >> 3] & (1<<(j&7)) ) )
+                       }
+                       if ( !( target->portalflood[j >> 3] & ( 1 << ( j & 7 ) ) ) ) {
                                 continue;
                                 continue;
-                       if ( ! (portal->portalflood[j >> 3] & (1<<(j&7)) ) )
+                       }
+                       if ( !( portal->portalflood[j >> 3] & ( 1 << ( j & 7 ) ) ) ) {
                                 continue;
                                 continue;
-                       for (k = 0; k < numseperators; k++)
+                       }
+                       for ( k = 0; k < numseperators; k++ )
                         {
                                 //
                         {
                                 //
-                               d = DotProduct (p->origin, seperators[k].normal) - seperators[k].dist;
+                               d = DotProduct( p->origin, seperators[k].normal ) - seperators[k].dist;
                                 //if completely at the back of the seperator plane
                                 //if completely at the back of the seperator plane
-                               if (d < -p->radius + ON_EPSILON)
+                               if ( d < -p->radius + ON_EPSILON ) {
                                         break;
                                         break;
+                               }
                                 w = p->winding;
                                 w = p->winding;
-                               for (n = 0; n < w->numpoints; n++)
+                               for ( n = 0; n < w->numpoints; n++ )
                                 {
                                 {
-                                       d = DotProduct (w->points[n], seperators[k].normal) - seperators[k].dist;
+                                       d = DotProduct( w->points[n], seperators[k].normal ) - seperators[k].dist;
                                         //if at the front of the seperator
                                         //if at the front of the seperator
-                                       if (d > ON_EPSILON)
+                                       if ( d > ON_EPSILON ) {
                                                 break;
                                                 break;
+                                       }
                                 }
                                 //if no points are at the front of the seperator
                                 }
                                 //if no points are at the front of the seperator
-                               if (n >= w->numpoints)
+                               if ( n >= w->numpoints ) {
                                         break;
                                         break;
+                               }
                         }
                         }
-                       if (k < numseperators)
+                       if ( k < numseperators ) {
                                 continue;
                                 continue;
-                       
+                       }
+
                         /* explitive deleted */
                         /* explitive deleted */
-                       
-                       
+
+
                         /* ydnar: prefer correctness to stack overflow  */
                         //% memcpy( &in, p->winding, (int)((fixedWinding_t *)0)->points[p->winding->numpoints] );
                         /* ydnar: prefer correctness to stack overflow  */
                         //% memcpy( &in, p->winding, (int)((fixedWinding_t *)0)->points[p->winding->numpoints] );
-                       if( p->winding->numpoints <= MAX_POINTS_ON_FIXED_WINDING )
-                               memcpy( &in, p->winding, (size_t) &(((fixedWinding_t*) 0)->points[ p->winding->numpoints ]) );
-                       else
+                       if ( p->winding->numpoints <= MAX_POINTS_ON_FIXED_WINDING ) {
+                               memcpy( &in, p->winding, (size_t) &( ( (fixedWinding_t*) 0 )->points[ p->winding->numpoints ] ) );
+                       }
+                       else{
                                 memcpy( &in, p->winding, sizeof( fixedWinding_t ) );
                                 memcpy( &in, p->winding, sizeof( fixedWinding_t ) );
-                       
-                       
-                       for( k = 0; k < numseperators; k++ )
+                       }
+
+
+                       for ( k = 0; k < numseperators; k++ )
                         {
                                 /* ydnar: this is a shitty crutch */
                         {
                                 /* ydnar: this is a shitty crutch */
-                               if( in.numpoints > MAX_POINTS_ON_FIXED_WINDING )
-                               {
+                               if ( in.numpoints > MAX_POINTS_ON_FIXED_WINDING ) {
                                         //% Sys_Printf( "[%d]", p->winding->numpoints );
                                         in.numpoints = MAX_POINTS_ON_FIXED_WINDING;
                                 }
                                         //% Sys_Printf( "[%d]", p->winding->numpoints );
                                         in.numpoints = MAX_POINTS_ON_FIXED_WINDING;
                                 }
-                               
+
                                 res = PassageChopWinding( &in, &out, &seperators[ k ] );
                                 res = PassageChopWinding( &in, &out, &seperators[ k ] );
-                               if( res == &out )
+                               if ( res == &out ) {
                                         memcpy( &in, &out, sizeof( fixedWinding_t ) );
                                         memcpy( &in, &out, sizeof( fixedWinding_t ) );
+                               }
  
  
-                       
-                               if( res == NULL )
+
+                               if ( res == NULL ) {
                                         break;
                                         break;
+                               }
                         }
                         }
-                       if (k < numseperators)
+                       if ( k < numseperators ) {
                                 continue;
                                 continue;
-                       passage->cansee[j >> 3] |= (1<<(j&7));
+                       }
+                       passage->cansee[j >> 3] |= ( 1 << ( j & 7 ) );
                         numsee++;
                 }
         }
  }
  
                         numsee++;
                 }
         }
  }
  
-void PassageMemory(void)
-{
+void PassageMemory( void ){
         int i, j, totalmem, totalportals;
         vportal_t *portal, *target;
         leaf_t *leaf;
  
         totalmem = 0;
         totalportals = 0;
         int i, j, totalmem, totalportals;
         vportal_t *portal, *target;
         leaf_t *leaf;
  
         totalmem = 0;
         totalportals = 0;
-       for (i = 0; i < numportals; i++)
+       for ( i = 0; i < numportals; i++ )
         {
                 portal = sorted_portals[i];
         {
                 portal = sorted_portals[i];
-               if (portal->removed)
+               if ( portal->removed ) {
                         continue;
                         continue;
+               }
                 leaf = &leafs[portal->leaf];
                 leaf = &leafs[portal->leaf];
-               for (j = 0; j < leaf->numportals; j++)
+               for ( j = 0; j < leaf->numportals; j++ )
                 {
                         target = leaf->portals[j];
                 {
                         target = leaf->portals[j];
-                       if (target->removed)
+                       if ( target->removed ) {
                                 continue;
                                 continue;
-                       totalmem += sizeof(passage_t) + portalbytes;
+                       }
+                       totalmem += sizeof( passage_t ) + portalbytes;
                         totalportals++;
                 }
         }
                         totalportals++;
                 }
         }
-       Sys_Printf("%7i average number of passages per leaf\n", totalportals / numportals);
-       Sys_Printf("%7i MB required passage memory\n", totalmem >> 10 >> 10);
+       Sys_Printf( "%7i average number of passages per leaf\n", totalportals / numportals );
+       Sys_Printf( "%7i MB required passage memory\n", totalmem >> 10 >> 10 );
  }
  
  /*
  }
  
  /*
-===============================================================================
+   ===============================================================================
  
  
-This is a rough first-order aproximation that is used to trivially reject some
-of the final calculations.
+   This is a rough first-order aproximation that is used to trivially reject some
+   of the final calculations.
  
  
  
  
-Calculates portalfront and portalflood bit vectors
+   Calculates portalfront and portalflood bit vectors
  
  
-thinking about:
+   thinking about:
  
  
-typedef struct passage_s
-{
-       struct passage_s        *next;
-       struct portal_s         *to;
-       stryct sep_s            *seperators;
-       byte                            *mightsee;
-} passage_t;
+   typedef struct passage_s
+   {
+    struct passage_s   *next;
+    struct portal_s            *to;
+    stryct sep_s               *seperators;
+    byte                               *mightsee;
+   } passage_t;
  
  
-typedef struct portal_s
-{
-       struct passage_s        *passages;
-       int                                     leaf;           // leaf portal faces into
-} portal_s;
+   typedef struct portal_s
+   {
+    struct passage_s   *passages;
+    int                                        leaf;           // leaf portal faces into
+   } portal_s;
  
  
-leaf = portal->leaf
-clear 
-for all portals
+   leaf = portal->leaf
+   clear
+   for all portals
  
  
  
  
-calc portal visibility
-       clear bit vector
-       for all passages
-               passage visibility
+   calc portal visibility
+    clear bit vector
+    for all passages
+        passage visibility
  
  
  
  
-for a portal to be visible to a passage, it must be on the front of
-all seperating planes, and both portals must be behind the new portal
+   for a portal to be visible to a passage, it must be on the front of
+   all seperating planes, and both portals must be behind the new portal
  
  
-===============================================================================
-*/
+   ===============================================================================
+ */
  
  
-int            c_flood, c_vis;
+int c_flood, c_vis;
  
  
  /*
  
  
  /*
-==================
-SimpleFlood
-
-==================
-*/
-void SimpleFlood (vportal_t *srcportal, int leafnum)
-{
-       int             i;
-       leaf_t  *leaf;
-       vportal_t       *p;
-       int             pnum;
+   ==================
+   SimpleFlood
+
+   ==================
+ */
+void SimpleFlood( vportal_t *srcportal, int leafnum ){
+       int i;
+       leaf_t  *leaf;
+       vportal_t   *p;
+       int pnum;
  
         leaf = &leafs[leafnum];
  
         leaf = &leafs[leafnum];
-       
-       for (i=0 ; i<leaf->numportals ; i++)
+
+       for ( i = 0 ; i < leaf->numportals ; i++ )
         {
                 p = leaf->portals[i];
         {
                 p = leaf->portals[i];
-               if (p->removed)
+               if ( p->removed ) {
                         continue;
                         continue;
+               }
                 pnum = p - portals;
                 pnum = p - portals;
-               if ( ! (srcportal->portalfront[pnum>>3] & (1<<(pnum&7)) ) )
+               if ( !( srcportal->portalfront[pnum >> 3] & ( 1 << ( pnum & 7 ) ) ) ) {
                         continue;
                         continue;
+               }
  
  
-               if (srcportal->portalflood[pnum>>3] & (1<<(pnum&7)) )
+               if ( srcportal->portalflood[pnum >> 3] & ( 1 << ( pnum & 7 ) ) ) {
                         continue;
                         continue;
+               }
  
  
-               srcportal->portalflood[pnum>>3] |= (1<<(pnum&7));
-               
-               SimpleFlood (srcportal, p->leaf);
+               srcportal->portalflood[pnum >> 3] |= ( 1 << ( pnum & 7 ) );
+
+               SimpleFlood( srcportal, p->leaf );
         }
  }
  
  /*
         }
  }
  
  /*
-==============
-BasePortalVis
-==============
-*/
-void BasePortalVis( int portalnum )
-{
-       int                     j, k;
-       vportal_t       *tp, *p;
-       float           d;
-       fixedWinding_t  *w;
-       vec3_t          dir;
-       
-
-       p = portals+portalnum;
-
-       if (p->removed)
+   ==============
+   BasePortalVis
+   ==============
+ */
+void BasePortalVis( int portalnum ){
+       int j, k;
+       vportal_t   *tp, *p;
+       float d;
+       fixedWinding_t  *w;
+       vec3_t dir;
+
+
+       p = portals + portalnum;
+
+       if ( p->removed ) {
                 return;
                 return;
+       }
+
+       p->portalfront = safe_malloc( portalbytes );
+       memset( p->portalfront, 0, portalbytes );
+
+       p->portalflood = safe_malloc( portalbytes );
+       memset( p->portalflood, 0, portalbytes );
  
  
-       p->portalfront = safe_malloc (portalbytes);
-       memset (p->portalfront, 0, portalbytes);
+       p->portalvis = safe_malloc( portalbytes );
+       memset( p->portalvis, 0, portalbytes );
  
  
-       p->portalflood = safe_malloc (portalbytes);
-       memset (p->portalflood, 0, portalbytes);
-       
-       p->portalvis = safe_malloc (portalbytes);
-       memset (p->portalvis, 0, portalbytes);
-       
-       for (j=0, tp = portals ; j<numportals*2 ; j++, tp++)
+       for ( j = 0, tp = portals ; j < numportals * 2 ; j++, tp++ )
         {
         {
-               if( j == portalnum )
+               if ( j == portalnum ) {
                         continue;
                         continue;
-               if( tp->removed )
+               }
+               if ( tp->removed ) {
                         continue;
                         continue;
+               }
  
                 /* ydnar: this is old farplane vis code from mre */
                 /*
  
                 /* ydnar: this is old farplane vis code from mre */
                 /*
-               if (farplanedist >= 0)
-               {
-                       vec3_t dir;
-                       VectorSubtract(p->origin, tp->origin, dir);
-                       if (VectorLength(dir) > farplanedist - p->radius - tp->radius)
-                               continue;
-               }
-               */
-               
+                  if (farplanedist >= 0)
+                  {
+                   vec3_t dir;
+                   VectorSubtract(p->origin, tp->origin, dir);
+                   if (VectorLength(dir) > farplanedist - p->radius - tp->radius)
+                       continue;
+                  }
+                */
+
                 /* ydnar: this is known-to-be-working farplane code */
                 /* ydnar: this is known-to-be-working farplane code */
-               if( !p->sky && !tp->sky )
-               if( farPlaneDist > 0.0f )
-               {
+               if ( !p->sky && !tp->sky && farPlaneDist > 0.0f ) {
                         VectorSubtract( p->origin, tp->origin, dir );
                         VectorSubtract( p->origin, tp->origin, dir );
-                       if( VectorLength( dir ) - p->radius - tp->radius > farPlaneDist )
+                       if ( VectorLength( dir ) - p->radius - tp->radius > farPlaneDist ) {
                                 continue;
                                 continue;
+                       }
                 }
                 }
-               
-               
+
+
                 w = tp->winding;
                 w = tp->winding;
-               for (k=0 ; k<w->numpoints ; k++)
+               for ( k = 0 ; k < w->numpoints ; k++ )
                 {
                 {
-                       d = DotProduct (w->points[k], p->plane.normal)
+                       d = DotProduct( w->points[k], p->plane.normal )
                                 - p->plane.dist;
                                 - p->plane.dist;
-                       if (d > ON_EPSILON)
+                       if ( d > ON_EPSILON ) {
                                 break;
                                 break;
+                       }
                 }
                 }
-               if (k == w->numpoints)
-                       continue;       // no points on front
+               if ( k == w->numpoints ) {
+                       continue;   // no points on front
  
  
+               }
                 w = p->winding;
                 w = p->winding;
-               for (k=0 ; k<w->numpoints ; k++)
+               for ( k = 0 ; k < w->numpoints ; k++ )
                 {
                 {
-                       d = DotProduct (w->points[k], tp->plane.normal)
+                       d = DotProduct( w->points[k], tp->plane.normal )
                                 - tp->plane.dist;
                                 - tp->plane.dist;
-                       if (d < -ON_EPSILON)
+                       if ( d < -ON_EPSILON ) {
                                 break;
                                 break;
+                       }
                 }
                 }
-               if (k == w->numpoints)
-                       continue;       // no points on front
+               if ( k == w->numpoints ) {
+                       continue;   // no points on front
  
  
-               p->portalfront[j>>3] |= (1<<(j&7));
+               }
+               p->portalfront[j >> 3] |= ( 1 << ( j & 7 ) );
         }
         }
-       
-       SimpleFlood (p, p->leaf);
  
  
-       p->nummightsee = CountBits (p->portalflood, numportals*2);
+       SimpleFlood( p, p->leaf );
+
+       p->nummightsee = CountBits( p->portalflood, numportals * 2 );
  //     Sys_Printf ("portal %i: %i mightsee\n", portalnum, p->nummightsee);
         c_flood += p->nummightsee;
  }
  //     Sys_Printf ("portal %i: %i mightsee\n", portalnum, p->nummightsee);
         c_flood += p->nummightsee;
  }
@@ -1629,83 +1664,83 @@ void BasePortalVis( int portalnum )
  
  
  /*
  
  
  /*
-===============================================================================
+   ===============================================================================
  
  
-This is a second order aproximation 
+   This is a second order aproximation
  
  
-Calculates portalvis bit vector
+   Calculates portalvis bit vector
  
  
-WAAAAAAY too slow.
+   WAAAAAAY too slow.
  
  
-===============================================================================
-*/
+   ===============================================================================
+ */
  
  /*
  
  /*
-==================
-RecursiveLeafBitFlow
-
-==================
-*/
-void RecursiveLeafBitFlow (int leafnum, byte *mightsee, byte *cansee)
-{
-       vportal_t       *p;
-       leaf_t          *leaf;
-       int                     i, j;
-       long            more;
-       int                     pnum;
-       byte            newmight[MAX_PORTALS/8];
+   ==================
+   RecursiveLeafBitFlow
+
+   ==================
+ */
+void RecursiveLeafBitFlow( int leafnum, byte *mightsee, byte *cansee ){
+       vportal_t   *p;
+       leaf_t      *leaf;
+       int i, j;
+       long more;
+       int pnum;
+       byte newmight[MAX_PORTALS / 8];
  
         leaf = &leafs[leafnum];
  
         leaf = &leafs[leafnum];
-       
+
         // check all portals for flowing into other leafs
         // check all portals for flowing into other leafs
-       for (i=0 ; i<leaf->numportals ; i++)
+       for ( i = 0 ; i < leaf->numportals ; i++ )
         {
                 p = leaf->portals[i];
         {
                 p = leaf->portals[i];
-               if (p->removed)
+               if ( p->removed ) {
                         continue;
                         continue;
+               }
                 pnum = p - portals;
  
                 // if some previous portal can't see it, skip
                 pnum = p - portals;
  
                 // if some previous portal can't see it, skip
-               if (! (mightsee[pnum>>3] & (1<<(pnum&7)) ) )
+               if ( !( mightsee[pnum >> 3] & ( 1 << ( pnum & 7 ) ) ) ) {
                         continue;
                         continue;
+               }
  
                 // if this portal can see some portals we mightsee, recurse
                 more = 0;
  
                 // if this portal can see some portals we mightsee, recurse
                 more = 0;
-               for (j=0 ; j<portallongs ; j++)
+               for ( j = 0 ; j < portallongs ; j++ )
                 {
                 {
-                       ((long *)newmight)[j] = ((long *)mightsee)[j] 
-                               & ((long *)p->portalflood)[j];
-                       more |= ((long *)newmight)[j] & ~((long *)cansee)[j];
+                       ( (long *)newmight )[j] = ( (long *)mightsee )[j]
+                                                                         & ( (long *)p->portalflood )[j];
+                       more |= ( (long *)newmight )[j] & ~( (long *)cansee )[j];
                 }
  
                 }
  
-               if (!more)
-                       continue;       // can't see anything new
+               if ( !more ) {
+                       continue;   // can't see anything new
  
  
-               cansee[pnum>>3] |= (1<<(pnum&7));
+               }
+               cansee[pnum >> 3] |= ( 1 << ( pnum & 7 ) );
  
  
-               RecursiveLeafBitFlow (p->leaf, newmight, cansee);
-       }       
+               RecursiveLeafBitFlow( p->leaf, newmight, cansee );
+       }
  }
  
  /*
  }
  
  /*
-==============
-BetterPortalVis
-==============
-*/
-void BetterPortalVis (int portalnum)
-{
-       vportal_t       *p;
+   ==============
+   BetterPortalVis
+   ==============
+ */
+void BetterPortalVis( int portalnum ){
+       vportal_t   *p;
  
  
-       p = portals+portalnum;
+       p = portals + portalnum;
  
  
-       if (p->removed)
+       if ( p->removed ) {
                 return;
                 return;
+       }
  
  
-       RecursiveLeafBitFlow (p->leaf, p->portalflood, p->portalvis);
+       RecursiveLeafBitFlow( p->leaf, p->portalflood, p->portalvis );
  
         // build leaf vis information
  
         // build leaf vis information
-       p->nummightsee = CountBits (p->portalvis, numportals*2);
+       p->nummightsee = CountBits( p->portalvis, numportals * 2 );
         c_vis += p->nummightsee;
  }
         c_vis += p->nummightsee;
  }
-
-