Merge branch 'master' into divVerent/farplanedist-sky-fix
authorRudolf Polzer <divverent@xonotic.org>
Tue, 15 May 2012 09:56:17 +0000 (11:56 +0200)
committerRudolf Polzer <divverent@xonotic.org>
Tue, 15 May 2012 09:58:06 +0000 (11:58 +0200)
Conflicts:
tools/quake3/q3map2/prtfile.c
tools/quake3/q3map2/vis.c
tools/quake3/q3map2/visflow.c

1  2 
tools/quake3/q3map2/prtfile.c
tools/quake3/q3map2/q3map2.h
tools/quake3/q3map2/vis.c
tools/quake3/q3map2/visflow.c

index e3759c0cd0a3cb06bdfe41d0b2e54bd81f768065,b5c09484156c3290bfc749a378a512ca0b624f23..514d255f7b556ba2ce35597a04a1feb874f35f38
@@@ -1,30 -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."
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
  
  
  
  
  /*
- ==============================================================================
   ==============================================================================
  
- PORTAL FILE GENERATION
   PORTAL FILE GENERATION
  
- Save out name.prt for qvis to read
- ==============================================================================
- */
   Save out name.prt for qvis to read
   ==============================================================================
 */
  
  
- #define       PORTALFILE      "PRT1"
+ #define PORTALFILE  "PRT1"
  
- FILE  *pf;
- int           num_visclusters;                                // clusters the player can be in
- int           num_visportals;
- int           num_solidfaces;
+ FILE    *pf;
+ int num_visclusters;                    // clusters the player can be in
+ int num_visportals;
+ int num_solidfaces;
  
- void WriteFloat (FILE *f, vec_t v)
- {
-       if ( fabs(v - Q_rint(v)) < 0.001 )
-               fprintf (f,"%i ",(int)Q_rint(v));
-       else
-               fprintf (f,"%f ",v);
+ void WriteFloat( FILE *f, vec_t v ){
+       if ( fabs( v - Q_rint( v ) ) < 0.001 ) {
+               fprintf( f,"%i ",(int)Q_rint( v ) );
+       }
+       else{
+               fprintf( f,"%f ",v );
+       }
  }
  
- void CountVisportals_r(node_t *node)
- {
-       int                     s;      
-       portal_t        *p;
-       winding_t       *w;
+ void CountVisportals_r( node_t *node ){
+       int s;
+       portal_t    *p;
+       winding_t   *w;
  
        // decision node
-       if (node->planenum != PLANENUM_LEAF) {
-               CountVisportals_r (node->children[0]);
-               CountVisportals_r (node->children[1]);
+       if ( node->planenum != PLANENUM_LEAF ) {
+               CountVisportals_r( node->children[0] );
+               CountVisportals_r( node->children[1] );
                return;
        }
-       
-       if (node->opaque) {
+       if ( node->opaque ) {
                return;
        }
  
-       for (p = node->portals ; p ; p=p->next[s])
+       for ( p = node->portals ; p ; p = p->next[s] )
        {
                w = p->winding;
-               s = (p->nodes[1] == node);
-               if (w && p->nodes[0] == node)
-               {
-                       if (!PortalPassable(p))
+               s = ( p->nodes[1] == node );
+               if ( w && p->nodes[0] == node ) {
+                       if ( !PortalPassable( p ) ) {
                                continue;
-                       if(p->nodes[0]->cluster == p->nodes[1]->cluster)
+                       }
+                       if ( p->nodes[0]->cluster == p->nodes[1]->cluster ) {
                                continue;
+                       }
                        ++num_visportals;
                }
        }
  }
  
  /*
- =================
- WritePortalFile_r
- =================
- */
- void WritePortalFile_r (node_t *node)
- {
-       int                     i, s, flags;
-       portal_t        *p;
-       winding_t       *w;
-       vec3_t          normal;
-       vec_t           dist;
+    =================
+    WritePortalFile_r
+    =================
+  */
+ void WritePortalFile_r( node_t *node ){
 -      int i, s;
++      int i, s, flags;
+       portal_t    *p;
+       winding_t   *w;
+       vec3_t normal;
+       vec_t dist;
  
        // decision node
-       if (node->planenum != PLANENUM_LEAF) {
-               WritePortalFile_r (node->children[0]);
-               WritePortalFile_r (node->children[1]);
+       if ( node->planenum != PLANENUM_LEAF ) {
+               WritePortalFile_r( node->children[0] );
+               WritePortalFile_r( node->children[1] );
                return;
        }
-       
-       if (node->opaque) {
+       if ( node->opaque ) {
                return;
        }
  
-       for (p = node->portals ; p ; p=p->next[s])
+       for ( p = node->portals ; p ; p = p->next[s] )
        {
                w = p->winding;
-               s = (p->nodes[1] == node);
-               if (w && p->nodes[0] == node)
-               {
-                       if (!PortalPassable(p))
+               s = ( p->nodes[1] == node );
+               if ( w && p->nodes[0] == node ) {
+                       if ( !PortalPassable( p ) ) {
                                continue;
-                       if(p->nodes[0]->cluster == p->nodes[1]->cluster)
+                       }
+                       if ( p->nodes[0]->cluster == p->nodes[1]->cluster ) {
                                continue;
+                       }
                        --num_visportals;
                        // write out to the file
-                       
                        // sometimes planes get turned around when they are very near
                        // the changeover point between different axis.  interpret the
                        // plane the same way vis will, and flip the side orders if needed
                        // FIXME: is this still relevent?
-                       WindingPlane (w, normal, &dist);
+                       WindingPlane( w, normal, &dist );
  
-                       if ( DotProduct (p->plane.normal, normal) < 0.99 )
-                       {       // backwards...
-                               fprintf (pf,"%i %i %i ",w->numpoints, p->nodes[1]->cluster, p->nodes[0]->cluster);
+                       if ( DotProduct( p->plane.normal, normal ) < 0.99 ) { // backwards...
+                               fprintf( pf,"%i %i %i ",w->numpoints, p->nodes[1]->cluster, p->nodes[0]->cluster );
+                       }
+                       else{
+                               fprintf( pf,"%i %i %i ",w->numpoints, p->nodes[0]->cluster, p->nodes[1]->cluster );
                        }
-                       else
-                               fprintf (pf,"%i %i %i ",w->numpoints, p->nodes[0]->cluster, p->nodes[1]->cluster);
  
-                       
 +                      flags = 0;
++
                        /* ydnar: added this change to make antiportals work */
-                       if( p->compileFlags & C_HINT )
 -                      if ( p->compileFlags & C_HINT ) {
 -                              fprintf( pf, "1 " );
++                      if( p->compileFlags & C_HINT ) {
 +                              flags |= 1;
+                       }
 -                      else{
 -                              fprintf( pf, "0 " );
 +
 +                      /* divVerent: I want farplanedist to not kill skybox. So... */
-                       if( p->compileFlags & C_SKY )
++                      if( p->compileFlags & C_SKY ) {
 +                              flags |= 2;
+                       }
  
-                       
 +                      fprintf( pf, "%d ", flags );
++
                        /* write the winding */
-                       for (i=0 ; i<w->numpoints ; i++)
+                       for ( i = 0 ; i < w->numpoints ; i++ )
                        {
-                               fprintf (pf,"(");
-                               WriteFloat (pf, w->p[i][0]);
-                               WriteFloat (pf, w->p[i][1]);
-                               WriteFloat (pf, w->p[i][2]);
-                               fprintf (pf,") ");
+                               fprintf( pf,"(" );
+                               WriteFloat( pf, w->p[i][0] );
+                               WriteFloat( pf, w->p[i][1] );
+                               WriteFloat( pf, w->p[i][2] );
+                               fprintf( pf,") " );
                        }
-                       fprintf (pf,"\n");
+                       fprintf( pf,"\n" );
                }
        }
  
  }
  
- void CountSolidFaces_r (node_t *node)
- {
-       int                     s;      
-       portal_t        *p;
-       winding_t       *w;
+ void CountSolidFaces_r( node_t *node ){
+       int s;
+       portal_t    *p;
+       winding_t   *w;
  
        // decision node
-       if (node->planenum != PLANENUM_LEAF) {
-               CountSolidFaces_r (node->children[0]);
-               CountSolidFaces_r (node->children[1]);
+       if ( node->planenum != PLANENUM_LEAF ) {
+               CountSolidFaces_r( node->children[0] );
+               CountSolidFaces_r( node->children[1] );
                return;
        }
-       
-       if (node->opaque) {
+       if ( node->opaque ) {
                return;
        }
  
-       for (p = node->portals ; p ; p=p->next[s])
+       for ( p = node->portals ; p ; p = p->next[s] )
        {
                w = p->winding;
-               s = (p->nodes[1] == node);
-               if (w)
-               {
-                       if (PortalPassable(p))
+               s = ( p->nodes[1] == node );
+               if ( w ) {
+                       if ( PortalPassable( p ) ) {
                                continue;
-                       if(p->nodes[0]->cluster == p->nodes[1]->cluster)
+                       }
+                       if ( p->nodes[0]->cluster == p->nodes[1]->cluster ) {
                                continue;
+                       }
                        // write out to the file
  
                        ++num_solidfaces;
  }
  
  /*
- =================
- WriteFaceFile_r
- =================
- */
- void WriteFaceFile_r (node_t *node)
- {
-       int                     i, s;   
-       portal_t        *p;
-       winding_t       *w;
+    =================
+    WriteFaceFile_r
+    =================
+  */
+ void WriteFaceFile_r( node_t *node ){
+       int i, s;
+       portal_t    *p;
+       winding_t   *w;
  
        // decision node
-       if (node->planenum != PLANENUM_LEAF) {
-               WriteFaceFile_r (node->children[0]);
-               WriteFaceFile_r (node->children[1]);
+       if ( node->planenum != PLANENUM_LEAF ) {
+               WriteFaceFile_r( node->children[0] );
+               WriteFaceFile_r( node->children[1] );
                return;
        }
-       
-       if (node->opaque) {
+       if ( node->opaque ) {
                return;
        }
  
-       for (p = node->portals ; p ; p=p->next[s])
+       for ( p = node->portals ; p ; p = p->next[s] )
        {
                w = p->winding;
-               s = (p->nodes[1] == node);
-               if (w)
-               {
-                       if (PortalPassable(p))
+               s = ( p->nodes[1] == node );
+               if ( w ) {
+                       if ( PortalPassable( p ) ) {
                                continue;
-                       if(p->nodes[0]->cluster == p->nodes[1]->cluster)
+                       }
+                       if ( p->nodes[0]->cluster == p->nodes[1]->cluster ) {
                                continue;
+                       }
                        // write out to the file
  
-                       if (p->nodes[0] == node)
-                       {
-                               fprintf (pf,"%i %i ",w->numpoints, p->nodes[0]->cluster);
-                               for (i=0 ; i<w->numpoints ; i++)
+                       if ( p->nodes[0] == node ) {
+                               fprintf( pf,"%i %i ",w->numpoints, p->nodes[0]->cluster );
+                               for ( i = 0 ; i < w->numpoints ; i++ )
                                {
-                                       fprintf (pf,"(");
-                                       WriteFloat (pf, w->p[i][0]);
-                                       WriteFloat (pf, w->p[i][1]);
-                                       WriteFloat (pf, w->p[i][2]);
-                                       fprintf (pf,") ");
+                                       fprintf( pf,"(" );
+                                       WriteFloat( pf, w->p[i][0] );
+                                       WriteFloat( pf, w->p[i][1] );
+                                       WriteFloat( pf, w->p[i][2] );
+                                       fprintf( pf,") " );
                                }
-                               fprintf (pf,"\n");
+                               fprintf( pf,"\n" );
                        }
                        else
                        {
-                               fprintf (pf,"%i %i ",w->numpoints, p->nodes[1]->cluster);
-                               for (i = w->numpoints-1; i >= 0; i--)
+                               fprintf( pf,"%i %i ",w->numpoints, p->nodes[1]->cluster );
+                               for ( i = w->numpoints - 1; i >= 0; i-- )
                                {
-                                       fprintf (pf,"(");
-                                       WriteFloat (pf, w->p[i][0]);
-                                       WriteFloat (pf, w->p[i][1]);
-                                       WriteFloat (pf, w->p[i][2]);
-                                       fprintf (pf,") ");
+                                       fprintf( pf,"(" );
+                                       WriteFloat( pf, w->p[i][0] );
+                                       WriteFloat( pf, w->p[i][1] );
+                                       WriteFloat( pf, w->p[i][2] );
+                                       fprintf( pf,") " );
                                }
-                               fprintf (pf,"\n");
+                               fprintf( pf,"\n" );
                        }
                }
        }
  }
  
  /*
- ================
- NumberLeafs_r
- ================
- */
- void NumberLeafs_r (node_t *node, int c)
- {
+    ================
+    NumberLeafs_r
+    ================
+  */
+ void NumberLeafs_r( node_t *node, int c ){
  #if 0
-       portal_t        *p;
+       portal_t    *p;
  #endif
        if ( node->planenum != PLANENUM_LEAF ) {
                // decision node
                node->cluster = -99;
  
-               if(node->has_structural_children)
-               {
+               if ( node->has_structural_children ) {
  #if 0
-                       if(c >= 0)
-                               Sys_FPrintf (SYS_ERR,"THIS CANNOT HAPPEN\n");
+                       if ( c >= 0 ) {
+                               Sys_FPrintf( SYS_ERR,"THIS CANNOT HAPPEN\n" );
+                       }
  #endif
-                       NumberLeafs_r (node->children[0], c);
-                       NumberLeafs_r (node->children[1], c);
+                       NumberLeafs_r( node->children[0], c );
+                       NumberLeafs_r( node->children[1], c );
                }
                else
                {
-                       if(c < 0)
+                       if ( c < 0 ) {
                                c = num_visclusters++;
-                       NumberLeafs_r (node->children[0], c);
-                       NumberLeafs_r (node->children[1], c);
+                       }
+                       NumberLeafs_r( node->children[0], c );
+                       NumberLeafs_r( node->children[1], c );
                }
                return;
        }
-       
        node->area = -1;
  
        if ( node->opaque ) {
                return;
        }
  
-       if(c < 0)
+       if ( c < 0 ) {
                c = num_visclusters++;
-       
+       }
        node->cluster = c;
  
  #if 0
        // count the portals
-       for (p = node->portals ; p ; )
+       for ( p = node->portals ; p ; )
        {
-               if (p->nodes[0] == node)                // only write out from first leaf
-               {
-                       if (PortalPassable(p))
+               if ( p->nodes[0] == node ) {      // only write out from first leaf
+                       if ( PortalPassable( p ) ) {
                                num_visportals++;
-                       else
+                       }
+                       else{
                                num_solidfaces++;
+                       }
                        p = p->next[0];
                }
                else
                {
-                       if (!PortalPassable(p))
+                       if ( !PortalPassable( p ) ) {
                                num_solidfaces++;
-                       p = p->next[1];         
+                       }
+                       p = p->next[1];
                }
        }
  #endif
  
  
  /*
- ================
- NumberClusters
- ================
- */
- void NumberClusters(tree_t *tree) {
   ================
   NumberClusters
   ================
 */
+ void NumberClusters( tree_t *tree ) {
        num_visclusters = 0;
        num_visportals = 0;
        num_solidfaces = 0;
  
-       Sys_FPrintf (SYS_VRB,"--- NumberClusters ---\n");
-       
+       Sys_FPrintf( SYS_VRB,"--- NumberClusters ---\n" );
        // set the cluster field in every leaf and count the total number of portals
-       NumberLeafs_r (tree->headnode, -1);
-       CountVisportals_r (tree->headnode);
-       CountSolidFaces_r (tree->headnode);
+       NumberLeafs_r( tree->headnode, -1 );
+       CountVisportals_r( tree->headnode );
+       CountSolidFaces_r( tree->headnode );
  
        Sys_FPrintf( SYS_VRB, "%9d visclusters\n", num_visclusters );
        Sys_FPrintf( SYS_VRB, "%9d visportals\n", num_visportals );
  }
  
  /*
- ================
- WritePortalFile
- ================
- */
- void WritePortalFile (tree_t *tree)
- {
-       char    filename[1024];
-       Sys_FPrintf (SYS_VRB,"--- WritePortalFile ---\n");
-       
+    ================
+    WritePortalFile
+    ================
+  */
+ void WritePortalFile( tree_t *tree ){
+       char filename[1024];
+       Sys_FPrintf( SYS_VRB,"--- WritePortalFile ---\n" );
        // write the file
-       sprintf (filename, "%s.prt", source);
-       Sys_Printf ("writing %s\n", filename);
-       pf = fopen (filename, "w");
-       if (!pf)
-               Error ("Error opening %s", filename);
-               
-       fprintf (pf, "%s\n", PORTALFILE);
-       fprintf (pf, "%i\n", num_visclusters);
-       fprintf (pf, "%i\n", num_visportals);
-       fprintf (pf, "%i\n", num_solidfaces);
-       WritePortalFile_r(tree->headnode);
-       WriteFaceFile_r(tree->headnode);
-       fclose (pf);
- }
+       sprintf( filename, "%s.prt", source );
+       Sys_Printf( "writing %s\n", filename );
+       pf = fopen( filename, "w" );
+       if ( !pf ) {
+               Error( "Error opening %s", filename );
+       }
  
+       fprintf( pf, "%s\n", PORTALFILE );
+       fprintf( pf, "%i\n", num_visclusters );
+       fprintf( pf, "%i\n", num_visportals );
+       fprintf( pf, "%i\n", num_solidfaces );
+       WritePortalFile_r( tree->headnode );
+       WriteFaceFile_r( tree->headnode );
+       fclose( pf );
+ }
index 427c0279b95b4b0d808c2f19ab8d74d06ac9af31,bbb3e76e73518d27b8bc12ef7a42ca46f51b2188..2a938822620529ed8e6521b939884cab0b0aa2be
@@@ -1,30 -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."
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
  
  
  #ifndef Q3MAP_VERSION
  #error no Q3MAP_VERSION defined
  #endif
- #define Q3MAP_MOTD            "Your map saw the pretty lights from q3map2's BFG"
+ #define Q3MAP_MOTD      "Your map saw the pretty lights from q3map2's BFG"
  
  
  
  
  /* -------------------------------------------------------------------------------
  
- dependencies
   dependencies
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
  /* platform-specific */
  #if defined( __linux__ ) || defined( __APPLE__ )
@@@ -66,7 -66,7 +66,7 @@@
  
  
  /* general */
- #include "version.h"                  /* ttimo: might want to guard that if built outside of the GtkRadiant tree */
+ #include "version.h"            /* ttimo: might want to guard that if built outside of the GtkRadiant tree */
  
  #include "cmdlib.h"
  #include "mathlib.h"
  #include "vfs.h"
  #include "png.h"
  #include "md4.h"
- #include "radiant_jpeglib.h"
  #include <stdlib.h>
  
+ #define MIN(a, b) ((a) < (b) ? (a) : (b))
+ #define MAX(a, b) ((a) > (b) ? (a) : (b))
  
  
  /* -------------------------------------------------------------------------------
  
- port-related hacks
   port-related hacks
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
- #define MAC_STATIC_HACK                       0
- #if defined( __APPLE__ ) && MAC_STATIC_HACK 
-       #define MAC_STATIC                      static
+ #define MAC_STATIC_HACK         0
+ #if defined( __APPLE__ ) && MAC_STATIC_HACK
+       #define MAC_STATIC          static
  #else
-       #define MAC_STATIC                      
+       #define MAC_STATIC
  #endif
  
  #if 1
        #ifdef WIN32
-               #define Q_stricmp                       stricmp
-               #define Q_strncasecmp           strnicmp
+               #define Q_stricmp           stricmp
+               #define Q_strncasecmp       strnicmp
        #else
-               #define Q_stricmp                       strcasecmp
-               #define Q_strncasecmp           strncasecmp
+               #define Q_stricmp           strcasecmp
+               #define Q_strncasecmp       strncasecmp
        #endif
  #endif
  
  /* macro version */
- #define VectorMA( a, s, b, c )        ((c)[ 0 ] = (a)[ 0 ] + (s) * (b)[ 0 ], (c)[ 1 ] = (a)[ 1 ] + (s) * (b)[ 1 ], (c)[ 2 ] = (a)[ 2 ] + (s) * (b)[ 2 ])
+ #define VectorMA( a, s, b, c )  ( ( c )[ 0 ] = ( a )[ 0 ] + ( s ) * ( b )[ 0 ], ( c )[ 1 ] = ( a )[ 1 ] + ( s ) * ( b )[ 1 ], ( c )[ 2 ] = ( a )[ 2 ] + ( s ) * ( b )[ 2 ] )
  
  
  
  /* -------------------------------------------------------------------------------
  
- constants
   constants
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
  /* temporary hacks and tests (please keep off in SVN to prevent anyone's legacy map from screwing up) */
  /* 2011-01-10 TTimo says we should turn these on in SVN, so turning on now */
- #define Q3MAP2_EXPERIMENTAL_HIGH_PRECISION_MATH_FIXES 1
- #define Q3MAP2_EXPERIMENTAL_SNAP_NORMAL_FIX           1
- #define Q3MAP2_EXPERIMENTAL_SNAP_PLANE_FIX            1
+ #define Q3MAP2_EXPERIMENTAL_HIGH_PRECISION_MATH_FIXES   1
+ #define Q3MAP2_EXPERIMENTAL_SNAP_NORMAL_FIX     1
+ #define Q3MAP2_EXPERIMENTAL_SNAP_PLANE_FIX      1
  
  /* general */
- #define MAX_QPATH                             64
+ #define MAX_QPATH               64
  
- #define MAX_IMAGES                            512
- #define DEFAULT_IMAGE                 "*default"
+ #define MAX_IMAGES              512
+ #define DEFAULT_IMAGE           "*default"
  
- #define MAX_MODELS                            512
+ #define MAX_MODELS              512
  
- #define       DEF_BACKSPLASH_FRACTION 0.05f   /* 5% backsplash by default */
- #define       DEF_BACKSPLASH_DISTANCE 23
+ #define DEF_BACKSPLASH_FRACTION 0.05f   /* 5% backsplash by default */
+ #define DEF_BACKSPLASH_DISTANCE 23
  
- #define DEF_RADIOSITY_BOUNCE  1.0f    /* ydnar: default to 100% re-emitted light */
+ #define DEF_RADIOSITY_BOUNCE    1.0f    /* ydnar: default to 100% re-emitted light */
  
- #define       MAX_SHADER_INFO                 8192
- #define MAX_CUST_SURFACEPARMS 64
+ #define MAX_SHADER_INFO         8192
+ #define MAX_CUST_SURFACEPARMS   256
  
- #define       SHADER_MAX_VERTEXES             1000
- #define       SHADER_MAX_INDEXES              (6 * SHADER_MAX_VERTEXES)
+ #define SHADER_MAX_VERTEXES     1000
+ #define SHADER_MAX_INDEXES      ( 6 * SHADER_MAX_VERTEXES )
  
- #define MAX_JITTERS                           256
+ #define MAX_JITTERS             256
  
  
  /* epair parsing (note case-sensitivity directive) */
- #define CASE_INSENSITIVE_EPAIRS       1
+ #define CASE_INSENSITIVE_EPAIRS 1
  
  #if CASE_INSENSITIVE_EPAIRS
-       #define EPAIR_STRCMP            Q_stricmp
+       #define EPAIR_STRCMP        Q_stricmp
  #else
-       #define EPAIR_STRCMP            strcmp
+       #define EPAIR_STRCMP        strcmp
  #endif
  
  
  /* ydnar: compiler flags, because games have widely varying content/surface flags */
- #define C_SOLID                                       0x00000001
- #define C_TRANSLUCENT                 0x00000002
- #define C_STRUCTURAL                  0x00000004
- #define C_HINT                                        0x00000008
- #define C_NODRAW                              0x00000010
- #define C_LIGHTGRID                           0x00000020
- #define C_ALPHASHADOW                 0x00000040
- #define C_LIGHTFILTER                 0x00000080
- #define C_VERTEXLIT                           0x00000100
- #define C_LIQUID                              0x00000200
- #define C_FOG                                 0x00000400
- #define C_SKY                                 0x00000800
- #define C_ORIGIN                              0x00001000
- #define C_AREAPORTAL                  0x00002000
- #define C_ANTIPORTAL                  0x00004000      /* like hint, but doesn't generate portals */
- #define C_SKIP                                        0x00008000      /* like hint, but skips this face (doesn't split bsp) */
- #define C_NOMARKS                             0x00010000      /* no decals */
- #define C_DETAIL                              0x08000000      /* THIS MUST BE THE SAME AS IN RADIANT! */
+ #define C_SOLID                 0x00000001
+ #define C_TRANSLUCENT           0x00000002
+ #define C_STRUCTURAL            0x00000004
+ #define C_HINT                  0x00000008
+ #define C_NODRAW                0x00000010
+ #define C_LIGHTGRID             0x00000020
+ #define C_ALPHASHADOW           0x00000040
+ #define C_LIGHTFILTER           0x00000080
+ #define C_VERTEXLIT             0x00000100
+ #define C_LIQUID                0x00000200
+ #define C_FOG                   0x00000400
+ #define C_SKY                   0x00000800
+ #define C_ORIGIN                0x00001000
+ #define C_AREAPORTAL            0x00002000
+ #define C_ANTIPORTAL            0x00004000  /* like hint, but doesn't generate portals */
+ #define C_SKIP                  0x00008000  /* like hint, but skips this face (doesn't split bsp) */
+ #define C_NOMARKS               0x00010000  /* no decals */
+ #define C_DETAIL                0x08000000  /* THIS MUST BE THE SAME AS IN RADIANT! */
  
  
  /* shadow flags */
- #define WORLDSPAWN_CAST_SHADOWS       1
- #define WORLDSPAWN_RECV_SHADOWS       1
- #define ENTITY_CAST_SHADOWS           0
- #define ENTITY_RECV_SHADOWS           1
+ #define WORLDSPAWN_CAST_SHADOWS 1
+ #define WORLDSPAWN_RECV_SHADOWS 1
+ #define ENTITY_CAST_SHADOWS     0
+ #define ENTITY_RECV_SHADOWS     1
  
  
  /* bsp */
- #define       MAX_PATCH_SIZE                  32
- #define       MAX_BRUSH_SIDES                 1024
- #define MAX_BUILD_SIDES                       1024
+ #define MAX_PATCH_SIZE          32
+ #define MAX_BRUSH_SIDES         1024
+ #define MAX_BUILD_SIDES         1024
  
- #define       MAX_EXPANDED_AXIS               128
+ #define MAX_EXPANDED_AXIS       128
  
- #define       CLIP_EPSILON                    0.1f
- #define       PLANESIDE_EPSILON               0.001f
- #define       PLANENUM_LEAF                   -1
+ #define CLIP_EPSILON            0.1f
+ #define PLANESIDE_EPSILON       0.001f
+ #define PLANENUM_LEAF           -1
  
- #define       HINT_PRIORITY                   1000            /* ydnar: force hint splits first and antiportal/areaportal splits last */
- #define ANTIPORTAL_PRIORITY           -1000
- #define AREAPORTAL_PRIORITY           -1000
- #define DETAIL_PRIORITY               -3000
+ #define HINT_PRIORITY           1000        /* ydnar: force hint splits first and antiportal/areaportal splits last */
+ #define ANTIPORTAL_PRIORITY     -1000
+ #define AREAPORTAL_PRIORITY     -1000
+ #define DETAIL_PRIORITY     -3000
  
- #define       PSIDE_FRONT                             1
- #define       PSIDE_BACK                              2
- #define       PSIDE_BOTH                              (PSIDE_FRONT | PSIDE_BACK)
- #define       PSIDE_FACING                    4
+ #define PSIDE_FRONT             1
+ #define PSIDE_BACK              2
+ #define PSIDE_BOTH              ( PSIDE_FRONT | PSIDE_BACK )
+ #define PSIDE_FACING            4
  
- #define BPRIMIT_UNDEFINED             0
- #define BPRIMIT_OLDBRUSHES            1
- #define BPRIMIT_NEWBRUSHES            2
+ #define BPRIMIT_UNDEFINED       0
+ #define BPRIMIT_OLDBRUSHES      1
+ #define BPRIMIT_NEWBRUSHES      2
  
  
  /* vis */
- #define       VIS_HEADER_SIZE                 8
+ #define VIS_HEADER_SIZE         8
  
- #define SEPERATORCACHE                        /* seperator caching helps a bit */
+ #define SEPERATORCACHE          /* seperator caching helps a bit */
  
- #define       PORTALFILE                              "PRT1"
+ #define PORTALFILE              "PRT1"
  
- #define       MAX_PORTALS                             0x20000 /* same as MAX_MAP_PORTALS */
- #define MAX_SEPERATORS                        MAX_POINTS_ON_WINDING
- #define       MAX_POINTS_ON_FIXED_WINDING     24      /* ydnar: increased this from 12 at the expense of more memory */
- #define       MAX_PORTALS_ON_LEAF             1024
+ #define MAX_PORTALS             0x20000 /* same as MAX_MAP_PORTALS */
+ #define MAX_SEPERATORS          MAX_POINTS_ON_WINDING
+ #define MAX_POINTS_ON_FIXED_WINDING 24  /* ydnar: increased this from 12 at the expense of more memory */
+ #define MAX_PORTALS_ON_LEAF     1024
  
  
  /* light */
- #define EMIT_POINT                            0
- #define EMIT_AREA                             1
- #define EMIT_SPOT                             2
- #define EMIT_SUN                              3
- #define LIGHT_ATTEN_LINEAR            1
- #define LIGHT_ATTEN_ANGLE             2
- #define LIGHT_ATTEN_DISTANCE  4
- #define LIGHT_TWOSIDED                        8
- #define LIGHT_GRID                            16
- #define LIGHT_SURFACES                        32
- #define LIGHT_DARK                            64              /* probably never use this */
- #define LIGHT_FAST                            256
- #define LIGHT_FAST_TEMP                       512
- #define LIGHT_FAST_ACTUAL             (LIGHT_FAST | LIGHT_FAST_TEMP)
- #define LIGHT_NEGATIVE                        1024
- #define LIGHT_UNNORMALIZED            2048    /* vortex: do not normalize _color */
- #define LIGHT_SUN_DEFAULT             (LIGHT_ATTEN_ANGLE | LIGHT_GRID | LIGHT_SURFACES)
- #define LIGHT_AREA_DEFAULT            (LIGHT_ATTEN_ANGLE | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES)        /* q3a and wolf are the same */
- #define LIGHT_Q3A_DEFAULT             (LIGHT_ATTEN_ANGLE | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES | LIGHT_FAST)
- #define LIGHT_WOLF_DEFAULT            (LIGHT_ATTEN_LINEAR | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES | LIGHT_FAST)
- #define MAX_TRACE_TEST_NODES  256
- #define DEFAULT_INHIBIT_RADIUS        1.5f
- #define LUXEL_EPSILON                 0.125f
- #define VERTEX_EPSILON                        -0.125f
- #define GRID_EPSILON                  0.0f
- #define DEFAULT_LIGHTMAP_SAMPLE_SIZE  16
- #define DEFAULT_LIGHTMAP_MIN_SAMPLE_SIZE      0
- #define DEFAULT_LIGHTMAP_SAMPLE_OFFSET        1.0f
- #define DEFAULT_SUBDIVIDE_THRESHOLD           1.0f
- #define       EXTRA_SCALE                             2       /* -extrawide = -super 2 */
- #define       EXTRAWIDE_SCALE                 2       /* -extrawide = -super 2 -filter */
- #define CLUSTER_UNMAPPED              -1
- #define CLUSTER_OCCLUDED              -2
- #define CLUSTER_FLOODED                       -3
- #define VERTEX_LUXEL_SIZE             3
- #define BSP_LUXEL_SIZE                        3
- #define RAD_LUXEL_SIZE                        3
- #define SUPER_LUXEL_SIZE              4
- #define SUPER_FLAG_SIZE                       4
+ #define EMIT_POINT              0
+ #define EMIT_AREA               1
+ #define EMIT_SPOT               2
+ #define EMIT_SUN                3
+ #define LIGHT_ATTEN_LINEAR      1
+ #define LIGHT_ATTEN_ANGLE       2
+ #define LIGHT_ATTEN_DISTANCE    4
+ #define LIGHT_TWOSIDED          8
+ #define LIGHT_GRID              16
+ #define LIGHT_SURFACES          32
+ #define LIGHT_DARK              64      /* probably never use this */
+ #define LIGHT_FAST              256
+ #define LIGHT_FAST_TEMP         512
+ #define LIGHT_FAST_ACTUAL       ( LIGHT_FAST | LIGHT_FAST_TEMP )
+ #define LIGHT_NEGATIVE          1024
+ #define LIGHT_UNNORMALIZED      2048    /* vortex: do not normalize _color */
+ #define LIGHT_SUN_DEFAULT       ( LIGHT_ATTEN_ANGLE | LIGHT_GRID | LIGHT_SURFACES )
+ #define LIGHT_AREA_DEFAULT      ( LIGHT_ATTEN_ANGLE | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES )    /* q3a and wolf are the same */
+ #define LIGHT_Q3A_DEFAULT       ( LIGHT_ATTEN_ANGLE | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES | LIGHT_FAST )
+ #define LIGHT_WOLF_DEFAULT      ( LIGHT_ATTEN_LINEAR | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES | LIGHT_FAST )
+ #define MAX_TRACE_TEST_NODES    256
+ #define DEFAULT_INHIBIT_RADIUS  1.5f
+ #define LUXEL_EPSILON           0.125f
+ #define VERTEX_EPSILON          -0.125f
+ #define GRID_EPSILON            0.0f
+ #define DEFAULT_LIGHTMAP_SAMPLE_SIZE    16
+ #define DEFAULT_LIGHTMAP_MIN_SAMPLE_SIZE    0
+ #define DEFAULT_LIGHTMAP_SAMPLE_OFFSET  1.0f
+ #define DEFAULT_SUBDIVIDE_THRESHOLD     1.0f
+ #define EXTRA_SCALE             2   /* -extrawide = -super 2 */
+ #define EXTRAWIDE_SCALE         2   /* -extrawide = -super 2 -filter */
+ #define CLUSTER_UNMAPPED        -1
+ #define CLUSTER_OCCLUDED        -2
+ #define CLUSTER_FLOODED         -3
+ #define VERTEX_LUXEL_SIZE       3
+ #define BSP_LUXEL_SIZE          3
+ #define RAD_LUXEL_SIZE          3
+ #define SUPER_LUXEL_SIZE        4
+ #define SUPER_FLAG_SIZE         4
  #define FLAG_FORCE_SUBSAMPLING 1
  #define FLAG_ALREADY_SUBSAMPLED 2
- #define SUPER_ORIGIN_SIZE             3
- #define SUPER_NORMAL_SIZE             4
- #define SUPER_DELUXEL_SIZE            3
- #define BSP_DELUXEL_SIZE              3
- #define SUPER_FLOODLIGHT_SIZE 4
- #define VERTEX_LUXEL( s, v )  (vertexLuxels[ s ] + ((v) * VERTEX_LUXEL_SIZE))
- #define RAD_VERTEX_LUXEL( s, v )(radVertexLuxels[ s ] + ((v) * VERTEX_LUXEL_SIZE))
- #define BSP_LUXEL( s, x, y )  (lm->bspLuxels[ s ] + ((((y) * lm->w) + (x)) * BSP_LUXEL_SIZE))
- #define RAD_LUXEL( s, x, y )  (lm->radLuxels[ s ] + ((((y) * lm->w) + (x)) * RAD_LUXEL_SIZE))
- #define SUPER_LUXEL( s, x, y )        (lm->superLuxels[ s ] + ((((y) * lm->sw) + (x)) * SUPER_LUXEL_SIZE))
- #define SUPER_FLAG( x, y )    (lm->superFlags + ((((y) * lm->sw) + (x)) * SUPER_FLAG_SIZE))
- #define SUPER_DELUXEL( x, y ) (lm->superDeluxels + ((((y) * lm->sw) + (x)) * SUPER_DELUXEL_SIZE))
- #define BSP_DELUXEL( x, y )           (lm->bspDeluxels + ((((y) * lm->w) + (x)) * BSP_DELUXEL_SIZE))
- #define SUPER_CLUSTER( x, y ) (lm->superClusters + (((y) * lm->sw) + (x)))
- #define SUPER_ORIGIN( x, y )  (lm->superOrigins + ((((y) * lm->sw) + (x)) * SUPER_ORIGIN_SIZE))
- #define SUPER_NORMAL( x, y )  (lm->superNormals + ((((y) * lm->sw) + (x)) * SUPER_NORMAL_SIZE))
- #define SUPER_DIRT( x, y )            (lm->superNormals + ((((y) * lm->sw) + (x)) * SUPER_NORMAL_SIZE) + 3)   /* stash dirtyness in normal[ 3 ] */
- #define SUPER_FLOODLIGHT( x, y )      (lm->superFloodLight + ((((y) * lm->sw) + (x)) * SUPER_FLOODLIGHT_SIZE) )
+ #define SUPER_ORIGIN_SIZE       3
+ #define SUPER_NORMAL_SIZE       4
+ #define SUPER_DELUXEL_SIZE      3
+ #define BSP_DELUXEL_SIZE        3
+ #define SUPER_FLOODLIGHT_SIZE   4
+ #define VERTEX_LUXEL( s, v )    ( vertexLuxels[ s ] + ( ( v ) * VERTEX_LUXEL_SIZE ) )
+ #define RAD_VERTEX_LUXEL( s, v )( radVertexLuxels[ s ] + ( ( v ) * VERTEX_LUXEL_SIZE ) )
+ #define BSP_LUXEL( s, x, y )    ( lm->bspLuxels[ s ] + ( ( ( ( y ) * lm->w ) + ( x ) ) * BSP_LUXEL_SIZE ) )
+ #define RAD_LUXEL( s, x, y )    ( lm->radLuxels[ s ] + ( ( ( ( y ) * lm->w ) + ( x ) ) * RAD_LUXEL_SIZE ) )
+ #define SUPER_LUXEL( s, x, y )  ( lm->superLuxels[ s ] + ( ( ( ( y ) * lm->sw ) + ( x ) ) * SUPER_LUXEL_SIZE ) )
+ #define SUPER_FLAG( x, y )  ( lm->superFlags + ( ( ( ( y ) * lm->sw ) + ( x ) ) * SUPER_FLAG_SIZE ) )
+ #define SUPER_DELUXEL( x, y )   ( lm->superDeluxels + ( ( ( ( y ) * lm->sw ) + ( x ) ) * SUPER_DELUXEL_SIZE ) )
+ #define BSP_DELUXEL( x, y )     ( lm->bspDeluxels + ( ( ( ( y ) * lm->w ) + ( x ) ) * BSP_DELUXEL_SIZE ) )
+ #define SUPER_CLUSTER( x, y )   ( lm->superClusters + ( ( ( y ) * lm->sw ) + ( x ) ) )
+ #define SUPER_ORIGIN( x, y )    ( lm->superOrigins + ( ( ( ( y ) * lm->sw ) + ( x ) ) * SUPER_ORIGIN_SIZE ) )
+ #define SUPER_NORMAL( x, y )    ( lm->superNormals + ( ( ( ( y ) * lm->sw ) + ( x ) ) * SUPER_NORMAL_SIZE ) )
+ #define SUPER_DIRT( x, y )      ( lm->superNormals + ( ( ( ( y ) * lm->sw ) + ( x ) ) * SUPER_NORMAL_SIZE ) + 3 )   /* stash dirtyness in normal[ 3 ] */
+ #define SUPER_FLOODLIGHT( x, y )    ( lm->superFloodLight + ( ( ( ( y ) * lm->sw ) + ( x ) ) * SUPER_FLOODLIGHT_SIZE ) )
  
  
  
  /* -------------------------------------------------------------------------------
  
- abstracted bsp file
   abstracted bsp file
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
- #define EXTERNAL_LIGHTMAP             "lm_%04d.tga"
+ #define EXTERNAL_LIGHTMAP       "lm_%04d.tga"
  
- #define MAX_LIGHTMAPS                 4                       /* RBSP */
- #define MAX_LIGHT_STYLES              64
- #define       MAX_SWITCHED_LIGHTS             32
- #define LS_NORMAL                             0x00
- #define LS_UNUSED                             0xFE
- #define       LS_NONE                                 0xFF
+ #define MAX_LIGHTMAPS           4           /* RBSP */
+ #define MAX_LIGHT_STYLES        64
+ #define MAX_SWITCHED_LIGHTS     32
+ #define LS_NORMAL               0x00
+ #define LS_UNUSED               0xFE
+ #define LS_NONE                 0xFF
  
- #define MAX_LIGHTMAP_SHADERS  256
+ #define MAX_LIGHTMAP_SHADERS    256
  
  /* ok to increase these at the expense of more memory */
- #define       MAX_MAP_AREAS                   0x100           /* MAX_MAP_AREA_BYTES in q_shared must match! */
- #define       MAX_MAP_FOGS                    30                      //& 0x100       /* RBSP (32 - world fog - goggles) */
- #define       MAX_MAP_LEAFS                   0x20000
- #define       MAX_MAP_PORTALS                 0x20000
- #define       MAX_MAP_LIGHTING                0x800000
- #define       MAX_MAP_LIGHTGRID               0x100000        //%     0x800000 /* ydnar: set to points, not bytes */
+ #define MAX_MAP_AREAS           0x100       /* MAX_MAP_AREA_BYTES in q_shared must match! */
+ #define MAX_MAP_FOGS            30          //& 0x100 /* RBSP (32 - world fog - goggles) */
+ #define MAX_MAP_LEAFS           0x20000
+ #define MAX_MAP_PORTALS         0x20000
+ #define MAX_MAP_LIGHTING        0x800000
+ #define MAX_MAP_LIGHTGRID       0x100000    //%       0x800000 /* ydnar: set to points, not bytes */
  #define MAX_MAP_VISCLUSTERS     0x4000 // <= MAX_MAP_LEAFS
- #define       MAX_MAP_VISIBILITY              (VIS_HEADER_SIZE + MAX_MAP_VISCLUSTERS * (((MAX_MAP_VISCLUSTERS + 63) & ~63) >> 3))
+ #define MAX_MAP_VISIBILITY      ( VIS_HEADER_SIZE + MAX_MAP_VISCLUSTERS * ( ( ( MAX_MAP_VISCLUSTERS + 63 ) & ~63 ) >> 3 ) )
  
- #define       MAX_MAP_DRAW_SURFS              0x20000
- #define       MAX_MAP_DRAW_INDEXES    0x80000
+ #define MAX_MAP_DRAW_SURFS      0x20000
  
- #define MAX_MAP_ADVERTISEMENTS        30
+ #define MAX_MAP_ADVERTISEMENTS  30
  
  /* key / value pair sizes in the entities lump */
- #define       MAX_KEY                                 32
- #define       MAX_VALUE                               1024
+ #define MAX_KEY                 32
+ #define MAX_VALUE               1024
  
  /* the editor uses these predefined yaw angles to orient entities up or down */
- #define       ANGLE_UP                                -1
- #define       ANGLE_DOWN                              -2
+ #define ANGLE_UP                -1
+ #define ANGLE_DOWN              -2
  
- #define       LIGHTMAP_WIDTH                  128
- #define       LIGHTMAP_HEIGHT                 128
+ #define LIGHTMAP_WIDTH          128
+ #define LIGHTMAP_HEIGHT         128
  
- #define MIN_WORLD_COORD                       (-65536)
- #define       MAX_WORLD_COORD                 (65536)
- #define WORLD_SIZE                            (MAX_WORLD_COORD - MIN_WORLD_COORD)
+ #define MIN_WORLD_COORD         ( -65536 )
+ #define MAX_WORLD_COORD         ( 65536 )
+ #define WORLD_SIZE              ( MAX_WORLD_COORD - MIN_WORLD_COORD )
  
  
- typedef void                                  (*bspFunc)( const char * );
+ typedef void ( *bspFunc )( const char * );
  
  
  typedef struct
  {
-       int                     offset, length;
+       int offset, length;
  }
  bspLump_t;
  
  
  typedef struct
  {
-       char            ident[ 4 ];
-       int                     version;
-       
-       bspLump_t       lumps[ 100 ];   /* theoretical maximum # of bsp lumps */
+       char ident[ 4 ];
+       int version;
+       bspLump_t lumps[ 100 ];     /* theoretical maximum # of bsp lumps */
  }
  bspHeader_t;
  
  
  typedef struct
  {
-       float           mins[ 3 ], maxs[ 3 ];
-       int                     firstBSPSurface, numBSPSurfaces;
-       int                     firstBSPBrush, numBSPBrushes;
+       float mins[ 3 ], maxs[ 3 ];
+       int firstBSPSurface, numBSPSurfaces;
+       int firstBSPBrush, numBSPBrushes;
  }
  bspModel_t;
  
  
  typedef struct
  {
-       char            shader[ MAX_QPATH ];
-       int                     surfaceFlags;
-       int                     contentFlags;
+       char shader[ MAX_QPATH ];
+       int surfaceFlags;
+       int contentFlags;
  }
  bspShader_t;
  
  
  typedef struct
  {
-       float           normal[ 3 ];
-       float           dist;
+       float normal[ 3 ];
+       float dist;
  }
  bspPlane_t;
  
  
  typedef struct
  {
-       int                     planeNum;
-       int                     children[ 2 ];          /* negative numbers are -(leafs+1), not nodes */
-       int                     mins[ 3 ];                      /* for frustom culling */
-       int                     maxs[ 3 ];
+       int planeNum;
+       int children[ 2 ];              /* negative numbers are -(leafs+1), not nodes */
+       int mins[ 3 ];                  /* for frustom culling */
+       int maxs[ 3 ];
  }
  bspNode_t;
  
  
  typedef struct
  {
-       int                     cluster;                        /* -1 = opaque cluster (do I still store these?) */
-       int                     area;
-       
-       int                     mins[ 3 ];                      /* for frustum culling */
-       int                     maxs[ 3 ];
-       
-       int                     firstBSPLeafSurface;
-       int                     numBSPLeafSurfaces;
-       
-       int                     firstBSPLeafBrush;
-       int                     numBSPLeafBrushes;
+       int cluster;                    /* -1 = opaque cluster (do I still store these?) */
+       int area;
+       int mins[ 3 ];                  /* for frustum culling */
+       int maxs[ 3 ];
+       int firstBSPLeafSurface;
+       int numBSPLeafSurfaces;
+       int firstBSPLeafBrush;
+       int numBSPLeafBrushes;
  }
  bspLeaf_t;
  
  
  typedef struct
  {
-       int                     planeNum;                       /* positive plane side faces out of the leaf */
-       int                     shaderNum;
-       int                     surfaceNum;                     /* RBSP */
+       int planeNum;                   /* positive plane side faces out of the leaf */
+       int shaderNum;
+       int surfaceNum;                 /* RBSP */
  }
  bspBrushSide_t;
  
  
  typedef struct
  {
-       int                     firstSide;
-       int                     numSides;
-       int                     shaderNum;                      /* the shader that determines the content flags */
+       int firstSide;
+       int numSides;
+       int shaderNum;                  /* the shader that determines the content flags */
  }
  bspBrush_t;
  
  
  typedef struct
  {
-       char            shader[ MAX_QPATH ];
-       int                     brushNum;
-       int                     visibleSide;            /* the brush side that ray tests need to clip against (-1 == none) */
+       char shader[ MAX_QPATH ];
+       int brushNum;
+       int visibleSide;                /* the brush side that ray tests need to clip against (-1 == none) */
  }
  bspFog_t;
  
  
  typedef struct
  {
-       vec3_t          xyz;
-       float           st[ 2 ];
-       float           lightmap[ MAX_LIGHTMAPS ][ 2 ]; /* RBSP */
-       vec3_t          normal;
-       byte            color[ MAX_LIGHTMAPS ][ 4 ];    /* RBSP */
+       vec3_t xyz;
+       float st[ 2 ];
+       float lightmap[ MAX_LIGHTMAPS ][ 2 ];       /* RBSP */
+       vec3_t normal;
+       byte color[ MAX_LIGHTMAPS ][ 4 ];           /* RBSP */
  }
  bspDrawVert_t;
  
@@@ -474,71 -474,71 +474,71 @@@ bspSurfaceType_t
  
  typedef struct bspGridPoint_s
  {
-       byte            ambient[ MAX_LIGHTMAPS ][ 3 ];
-       byte            directed[ MAX_LIGHTMAPS ][ 3 ];
-       byte            styles[ MAX_LIGHTMAPS ];
-       byte            latLong[ 2 ];
+       byte ambient[ MAX_LIGHTMAPS ][ 3 ];
+       byte directed[ MAX_LIGHTMAPS ][ 3 ];
+       byte styles[ MAX_LIGHTMAPS ];
+       byte latLong[ 2 ];
  }
  bspGridPoint_t;
  
  
  typedef struct
  {
-       int                     shaderNum;
-       int                     fogNum;
-       int                     surfaceType;
-       
-       int                     firstVert;
-       int                     numVerts;
-       
-       int                     firstIndex;
-       int                     numIndexes;
-       
-       byte            lightmapStyles[ MAX_LIGHTMAPS ];                                                /* RBSP */
-       byte            vertexStyles[ MAX_LIGHTMAPS ];                                                  /* RBSP */
-       int                     lightmapNum[ MAX_LIGHTMAPS ];                                                   /* RBSP */
-       int                     lightmapX[ MAX_LIGHTMAPS ], lightmapY[ MAX_LIGHTMAPS ]; /* RBSP */
-       int                     lightmapWidth, lightmapHeight;
-       
-       vec3_t          lightmapOrigin;
-       vec3_t          lightmapVecs[ 3 ];      /* on patches, [ 0 ] and [ 1 ] are lodbounds */
-       
-       int                     patchWidth;
-       int                     patchHeight;
+       int shaderNum;
+       int fogNum;
+       int surfaceType;
+       int firstVert;
+       int numVerts;
+       int firstIndex;
+       int numIndexes;
+       byte lightmapStyles[ MAX_LIGHTMAPS ];                               /* RBSP */
+       byte vertexStyles[ MAX_LIGHTMAPS ];                                 /* RBSP */
+       int lightmapNum[ MAX_LIGHTMAPS ];                                   /* RBSP */
+       int lightmapX[ MAX_LIGHTMAPS ], lightmapY[ MAX_LIGHTMAPS ];         /* RBSP */
+       int lightmapWidth, lightmapHeight;
+       vec3_t lightmapOrigin;
+       vec3_t lightmapVecs[ 3 ];       /* on patches, [ 0 ] and [ 1 ] are lodbounds */
+       int patchWidth;
+       int patchHeight;
  }
  bspDrawSurface_t;
  
  
  /* advertisements */
  typedef struct {
-       int                     cellId;
-       vec3_t          normal;
-       vec3_t          rect[4];
-       char            model[ MAX_QPATH ];
+       int cellId;
+       vec3_t normal;
+       vec3_t rect[4];
+       char model[ MAX_QPATH ];
  } bspAdvertisement_t;
  
  
  /* -------------------------------------------------------------------------------
  
- general types
   general types
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
  /* ydnar: for smaller structs */
- typedef unsigned char qb_t;
+ typedef unsigned char qb_t;
  
  
  /* ydnar: for q3map_tcMod */
- typedef float tcMod_t[ 3 ][ 3 ];
+ typedef float tcMod_t[ 3 ][ 3 ];
  
  
  /* ydnar: for multiple game support */
  typedef struct surfaceParm_s
  {
-       char            *name;
-       int                     contentFlags, contentFlagsClear;
-       int                     surfaceFlags, surfaceFlagsClear;
-       int                     compileFlags, compileFlagsClear;
+       char        *name;
+       int contentFlags, contentFlagsClear;
+       int surfaceFlags, surfaceFlagsClear;
+       int compileFlags, compileFlagsClear;
  }
  surfaceParm_t;
  
@@@ -552,109 -552,110 +552,110 @@@ miniMapMode_t
  
  typedef struct game_s
  {
-       char                            *arg;                                                   /* -game matches this */
-       char                            *gamePath;                                              /* main game data dir */
-       char                            *homeBasePath;                                  /* home sub-dir on unix */
-       char                            *magic;                                                 /* magic word for figuring out base path */
-       char                            *shaderPath;                                    /* shader directory */
-       int                                     maxLMSurfaceVerts;                              /* default maximum meta surface verts */
-       int                                     maxSurfaceVerts;                                /* default maximum surface verts */
-       int                                     maxSurfaceIndexes;                              /* default maximum surface indexes (tris * 3) */
-       qboolean                        emitFlares;                                             /* when true, emit flare surfaces */
-       char                            *flareShader;                                   /* default flare shader (MUST BE SET) */
-       qboolean                        wolfLight;                                              /* when true, lights work like wolf q3map  */
-       int                                     lightmapSize;                                   /* bsp lightmap width/height */
-       float                           lightmapGamma;                                  /* default lightmap gamma */
-       qboolean                        lightmapsRGB;                                   /* default lightmap sRGB mode */
-       qboolean                        texturesRGB;                                    /* default texture sRGB mode */
-       float                           lightmapExposure;                               /* default lightmap exposure */
-       float                           lightmapCompensate;                             /* default lightmap compensate value */
-       float                           gridScale;                                              /* vortex: default lightgrid scale (affects both directional and ambient spectres) */
-       float                           gridAmbientScale;                               /* vortex: default lightgrid ambient spectre scale */
-       qboolean                        lightAngleHL;                                   /* jal: use half-lambert curve for light angle attenuation */
-       qboolean                        noStyles;                                               /* use lightstyles hack or not */
-       qboolean                        keepLights;                                             /* keep light entities on bsp */
-       int                                     patchSubdivisions;                              /* default patch subdivisions tolerance */
-       qboolean                        patchShadows;                                   /* patch casting enabled */
-       qboolean                        deluxeMap;                                              /* compile deluxemaps */
-       int                                     deluxeMode;                                             /* deluxemap mode (0 - modelspace, 1 - tangentspace with renormalization, 2 - tangentspace without renormalization) */
-       int                 miniMapSize;                    /* minimap size */
-       float               miniMapSharpen;                 /* minimap sharpening coefficient */
-       float               miniMapBorder;                  /* minimap border amount */
-       qboolean            miniMapKeepAspect;              /* minimap keep aspect ratio by letterboxing */
-       miniMapMode_t       miniMapMode;                    /* minimap mode */
+       char                *arg;                           /* -game matches this */
+       char                *gamePath;                      /* main game data dir */
+       char                *homeBasePath;                  /* home sub-dir on unix */
+       char                *magic;                         /* magic word for figuring out base path */
+       char                *shaderPath;                    /* shader directory */
+       int maxLMSurfaceVerts;                              /* default maximum meta surface verts */
+       int maxSurfaceVerts;                                /* default maximum surface verts */
+       int maxSurfaceIndexes;                              /* default maximum surface indexes (tris * 3) */
+       qboolean emitFlares;                                /* when true, emit flare surfaces */
+       char                *flareShader;                   /* default flare shader (MUST BE SET) */
+       qboolean wolfLight;                                 /* when true, lights work like wolf q3map  */
+       int lightmapSize;                                   /* bsp lightmap width/height */
+       float lightmapGamma;                                /* default lightmap gamma */
+       qboolean lightmapsRGB;                              /* default lightmap sRGB mode */
+       qboolean texturesRGB;                               /* default texture sRGB mode */
+       qboolean colorsRGB;                             /* default color sRGB mode */
+       float lightmapExposure;                             /* default lightmap exposure */
+       float lightmapCompensate;                           /* default lightmap compensate value */
+       float gridScale;                                    /* vortex: default lightgrid scale (affects both directional and ambient spectres) */
+       float gridAmbientScale;                             /* vortex: default lightgrid ambient spectre scale */
+       qboolean lightAngleHL;                              /* jal: use half-lambert curve for light angle attenuation */
+       qboolean noStyles;                                  /* use lightstyles hack or not */
+       qboolean keepLights;                                /* keep light entities on bsp */
+       int patchSubdivisions;                              /* default patch subdivisions tolerance */
+       qboolean patchShadows;                              /* patch casting enabled */
+       qboolean deluxeMap;                                 /* compile deluxemaps */
+       int deluxeMode;                                     /* deluxemap mode (0 - modelspace, 1 - tangentspace with renormalization, 2 - tangentspace without renormalization) */
+       int miniMapSize;                                    /* minimap size */
+       float miniMapSharpen;                               /* minimap sharpening coefficient */
+       float miniMapBorder;                                /* minimap border amount */
+       qboolean miniMapKeepAspect;                         /* minimap keep aspect ratio by letterboxing */
+       miniMapMode_t miniMapMode;                          /* minimap mode */
        char                *miniMapNameFormat;             /* minimap name format */
-       char                            *bspIdent;                                              /* 4-letter bsp file prefix */
-       int                                     bspVersion;                                             /* bsp version to use */
-       qboolean                        lumpSwap;                                               /* cod-style len/ofs order */
-       bspFunc                         load, write;                                    /* load/write function pointers */
-       surfaceParm_t           surfaceParms[ 128 ];                    /* surfaceparm array */
+       char                *bspIdent;                      /* 4-letter bsp file prefix */
+       int bspVersion;                                     /* bsp version to use */
+       qboolean lumpSwap;                                  /* cod-style len/ofs order */
+       bspFunc load, write;                                /* load/write function pointers */
+       surfaceParm_t surfaceParms[ 128 ];                  /* surfaceparm array */
  }
  game_t;
  
  
  typedef struct image_s
  {
-       char                            *name, *filename;
-       int                                     refCount;
-       int                                     width, height;
-       byte                            *pixels;
+       char                *name, *filename;
+       int refCount;
+       int width, height;
+       byte                *pixels;
  }
  image_t;
  
  
  typedef struct sun_s
  {
-       struct sun_s            *next;
-       vec3_t                          direction, color;
-       float                           photons, deviance, filterRadius;
-       int                                     numSamples, style;
+       struct sun_s        *next;
+       vec3_t direction, color;
+       float photons, deviance, filterRadius;
+       int numSamples, style;
  }
  sun_t;
  
  
- typedef struct surfaceModel_s 
+ typedef struct surfaceModel_s
  {
-       struct surfaceModel_s   *next;
-       char                            model[ MAX_QPATH ];
-       float                           density, odds;
-       float                           minScale, maxScale;
-       float                           minAngle, maxAngle;
-       qboolean                        oriented;
+       struct surfaceModel_s   *next;
+       char model[ MAX_QPATH ];
+       float density, odds;
+       float minScale, maxScale;
+       float minAngle, maxAngle;
+       qboolean oriented;
  }
  surfaceModel_t;
  
  
  /* ydnar/sd: foliage stuff for wolf et (engine-supported optimization of the above) */
- typedef struct foliage_s 
+ typedef struct foliage_s
  {
-       struct foliage_s        *next;
-       char                            model[ MAX_QPATH ];
-       float                           scale, density, odds;
-       qboolean                        inverseAlpha;
+       struct foliage_s    *next;
+       char model[ MAX_QPATH ];
+       float scale, density, odds;
+       qboolean inverseAlpha;
  }
  foliage_t;
  
  typedef struct foliageInstance_s
  {
-       vec3_t                          xyz, normal;
+       vec3_t xyz, normal;
  }
  foliageInstance_t;
  
  
  typedef struct remap_s
  {
-       struct remap_s          *next;
-       char                            from[ 1024 ];
-       char                            to[ MAX_QPATH ];
+       struct remap_s      *next;
+       char from[ 1024 ];
+       char to[ MAX_QPATH ];
  }
  remap_t;
  
  typedef struct skinfile_s
  {
-       struct skinfile_s       *next;
-       char                            name[ 1024 ];
-       char                            to[ MAX_QPATH ];
+       struct skinfile_s   *next;
+       char name[ 1024 ];
+       char to[ MAX_QPATH ];
  }
  skinfile_t;
  
@@@ -684,9 -685,9 +685,9 @@@ colorModType_t
  
  typedef struct colorMod_s
  {
-       struct colorMod_s       *next;
-       colorModType_t          type;
-       vec_t                           data[ 16 ];
+       struct colorMod_s   *next;
+       colorModType_t type;
+       vec_t data[ 16 ];
  }
  colorMod_t;
  
@@@ -703,115 -704,115 +704,115 @@@ implicitMap_t
  
  typedef struct shaderInfo_s
  {
-       char                            shader[ MAX_QPATH ];
-       int                                     surfaceFlags;
-       int                                     contentFlags;
-       int                                     compileFlags;
-       float                           value;                                                  /* light value */
-       
-       char                            *flareShader;                                   /* for light flares */
-       char                            *damageShader;                                  /* ydnar: sof2 damage shader name */
-       char                            *backShader;                                    /* for surfaces that generate different front and back passes */
-       char                            *cloneShader;                                   /* ydnar: for cloning of a surface */
-       char                            *remapShader;                                   /* ydnar: remap a shader in final stage */
-       char                            *deprecateShader;                               /* vortex: shader is deprecated and replaced by this on use */
-       surfaceModel_t          *surfaceModel;                                  /* ydnar: for distribution of models */
-       foliage_t                       *foliage;                                               /* ydnar/splash damage: wolf et foliage */
-       
-       float                           subdivisions;                                   /* from a "tesssize xxx" */
-       float                           backsplashFraction;                             /* floating point value, usually 0.05 */
-       float                           backsplashDistance;                             /* default 16 */
-       float                           lightSubdivide;                                 /* default 999 */
-       float                           lightFilterRadius;                              /* ydnar: lightmap filtering/blurring radius for lights created by this shader (default: 0) */
-       
-       int                                     lightmapSampleSize;                             /* lightmap sample size */
-       float                           lightmapSampleOffset;                   /* ydnar: lightmap sample offset (default: 1.0) */
-       
-       float                           bounceScale;                                    /* ydnar: radiosity re-emission [0,1.0+] */
-       float                           offset;                                                 /* ydnar: offset in units */
-       float                           shadeAngleDegrees;                              /* ydnar: breaking angle for smooth shading (degrees) */
-       
-       vec3_t                          mins, maxs;                                             /* ydnar: for particle studio vertexDeform move support */
-       
-       qb_t                            legacyTerrain;                                  /* ydnar: enable legacy terrain crutches */
-       qb_t                            indexed;                                                /* ydnar: attempt to use indexmap (terrain alphamap style) */
-       qb_t                            forceMeta;                                              /* ydnar: force metasurface path */
-       qb_t                            noClip;                                                 /* ydnar: don't clip into bsp, preserve original face winding */
-       qb_t                            noFast;                                                 /* ydnar: supress fast lighting for surfaces with this shader */
-       qb_t                            invert;                                                 /* ydnar: reverse facing */
-       qb_t                            nonplanar;                                              /* ydnar: for nonplanar meta surface merging */
-       qb_t                            tcGen;                                                  /* ydnar: has explicit texcoord generation */
-       vec3_t                          vecs[ 2 ];                                              /* ydnar: explicit texture vectors for [0,1] texture space */
-       tcMod_t                         mod;                                                    /* ydnar: q3map_tcMod matrix for djbob :) */
-       vec3_t                          lightmapAxis;                                   /* ydnar: explicit lightmap axis projection */
-       colorMod_t                      *colorMod;                                              /* ydnar: q3map_rgb/color/alpha/Set/Mod support */
-       
-       int                                     furNumLayers;                                   /* ydnar: number of fur layers */
-       float                           furOffset;                                              /* ydnar: offset of each layer */
-       float                           furFade;                                                /* ydnar: alpha fade amount per layer */
-       qb_t                            splotchFix;                                             /* ydnar: filter splotches on lightmaps */
-       
-       qb_t                            hasPasses;                                              /* false if the shader doesn't define any rendering passes */
-       qb_t                            globalTexture;                                  /* don't normalize texture repeats */
-       qb_t                            twoSided;                                               /* cull none */
-       qb_t                            autosprite;                                             /* autosprite shaders will become point lights instead of area lights */
-       qb_t                            polygonOffset;                                  /* ydnar: don't face cull this or against this */
-       qb_t                            patchShadows;                                   /* have patches casting shadows when using -light for this surface */
-       qb_t                            vertexShadows;                                  /* shadows will be casted at this surface even when vertex lit */
-       qb_t                            forceSunlight;                                  /* force sun light at this surface even tho we might not calculate shadows in vertex lighting */
-       qb_t                            notjunc;                                                /* don't use this surface for tjunction fixing */
-       qb_t                            fogParms;                                               /* ydnar: has fogparms */
-       qb_t                            noFog;                                                  /* ydnar: supress fogging */
-       qb_t                            clipModel;                                              /* ydnar: solid model hack */
-       qb_t                            noVertexLight;                                  /* ydnar: leave vertex color alone */
-       qb_t                            noDirty;                                                /* jal: do not apply the dirty pass to this surface */
-       byte                            styleMarker;                                    /* ydnar: light styles hack */
-       
-       float                           vertexScale;                                    /* vertex light scale */
-       
-       char                            skyParmsImageBase[ MAX_QPATH ]; /* ydnar: for skies */
-       
-       char                            editorImagePath[ MAX_QPATH ];   /* use this image to generate texture coordinates */
-       char                            lightImagePath[ MAX_QPATH ];    /* use this image to generate color / averageColor */
-       char                            normalImagePath[ MAX_QPATH ];   /* ydnar: normalmap image for bumpmapping */
-       
-       implicitMap_t           implicitMap;                                    /* ydnar: enemy territory implicit shaders */
-       char                            implicitImagePath[ MAX_QPATH ];
-       
-       image_t                         *shaderImage;
-       image_t                         *lightImage;
-       image_t                         *normalImage;
-       
-       float                           skyLightValue;                                  /* ydnar */
-       int                                     skyLightIterations;                             /* ydnar */
-       sun_t                           *sun;                                                   /* ydnar */
-       
-       vec3_t                          color;                                                  /* normalized color */
-       vec3_t                          averageColor;
-       byte                            lightStyle;                                     
+       char shader[ MAX_QPATH ];
+       int surfaceFlags;
+       int contentFlags;
+       int compileFlags;
+       float value;                                        /* light value */
+       char                *flareShader;                   /* for light flares */
+       char                *damageShader;                  /* ydnar: sof2 damage shader name */
+       char                *backShader;                    /* for surfaces that generate different front and back passes */
+       char                *cloneShader;                   /* ydnar: for cloning of a surface */
+       char                *remapShader;                   /* ydnar: remap a shader in final stage */
+       char                *deprecateShader;               /* vortex: shader is deprecated and replaced by this on use */
+       surfaceModel_t      *surfaceModel;                  /* ydnar: for distribution of models */
+       foliage_t           *foliage;                       /* ydnar/splash damage: wolf et foliage */
+       float subdivisions;                                 /* from a "tesssize xxx" */
+       float backsplashFraction;                           /* floating point value, usually 0.05 */
+       float backsplashDistance;                           /* default 16 */
+       float lightSubdivide;                               /* default 999 */
+       float lightFilterRadius;                            /* ydnar: lightmap filtering/blurring radius for lights created by this shader (default: 0) */
+       int lightmapSampleSize;                             /* lightmap sample size */
+       float lightmapSampleOffset;                         /* ydnar: lightmap sample offset (default: 1.0) */
+       float bounceScale;                                  /* ydnar: radiosity re-emission [0,1.0+] */
+       float offset;                                       /* ydnar: offset in units */
+       float shadeAngleDegrees;                            /* ydnar: breaking angle for smooth shading (degrees) */
+       vec3_t mins, maxs;                                  /* ydnar: for particle studio vertexDeform move support */
+       qb_t legacyTerrain;                                 /* ydnar: enable legacy terrain crutches */
+       qb_t indexed;                                       /* ydnar: attempt to use indexmap (terrain alphamap style) */
+       qb_t forceMeta;                                     /* ydnar: force metasurface path */
+       qb_t noClip;                                        /* ydnar: don't clip into bsp, preserve original face winding */
+       qb_t noFast;                                        /* ydnar: supress fast lighting for surfaces with this shader */
+       qb_t invert;                                        /* ydnar: reverse facing */
+       qb_t nonplanar;                                     /* ydnar: for nonplanar meta surface merging */
+       qb_t tcGen;                                         /* ydnar: has explicit texcoord generation */
+       vec3_t vecs[ 2 ];                                   /* ydnar: explicit texture vectors for [0,1] texture space */
+       tcMod_t mod;                                        /* ydnar: q3map_tcMod matrix for djbob :) */
+       vec3_t lightmapAxis;                                /* ydnar: explicit lightmap axis projection */
+       colorMod_t          *colorMod;                      /* ydnar: q3map_rgb/color/alpha/Set/Mod support */
+       int furNumLayers;                                   /* ydnar: number of fur layers */
+       float furOffset;                                    /* ydnar: offset of each layer */
+       float furFade;                                      /* ydnar: alpha fade amount per layer */
+       qb_t splotchFix;                                    /* ydnar: filter splotches on lightmaps */
+       qb_t hasPasses;                                     /* false if the shader doesn't define any rendering passes */
+       qb_t globalTexture;                                 /* don't normalize texture repeats */
+       qb_t twoSided;                                      /* cull none */
+       qb_t autosprite;                                    /* autosprite shaders will become point lights instead of area lights */
+       qb_t polygonOffset;                                 /* ydnar: don't face cull this or against this */
+       qb_t patchShadows;                                  /* have patches casting shadows when using -light for this surface */
+       qb_t vertexShadows;                                 /* shadows will be casted at this surface even when vertex lit */
+       qb_t forceSunlight;                                 /* force sun light at this surface even tho we might not calculate shadows in vertex lighting */
+       qb_t notjunc;                                       /* don't use this surface for tjunction fixing */
+       qb_t fogParms;                                      /* ydnar: has fogparms */
+       qb_t noFog;                                         /* ydnar: supress fogging */
+       qb_t clipModel;                                     /* ydnar: solid model hack */
+       qb_t noVertexLight;                                 /* ydnar: leave vertex color alone */
+       qb_t noDirty;                                       /* jal: do not apply the dirty pass to this surface */
+       byte styleMarker;                                   /* ydnar: light styles hack */
+       float vertexScale;                                  /* vertex light scale */
+       char skyParmsImageBase[ MAX_QPATH ];                /* ydnar: for skies */
+       char editorImagePath[ MAX_QPATH ];                  /* use this image to generate texture coordinates */
+       char lightImagePath[ MAX_QPATH ];                   /* use this image to generate color / averageColor */
+       char normalImagePath[ MAX_QPATH ];                  /* ydnar: normalmap image for bumpmapping */
+       implicitMap_t implicitMap;                          /* ydnar: enemy territory implicit shaders */
+       char implicitImagePath[ MAX_QPATH ];
+       image_t             *shaderImage;
+       image_t             *lightImage;
+       image_t             *normalImage;
+       float skyLightValue;                                /* ydnar */
+       int skyLightIterations;                             /* ydnar */
+       sun_t               *sun;                           /* ydnar */
+       vec3_t color;                                       /* normalized color */
+       vec3_t averageColor;
+       byte lightStyle;
  
        /* vortex: per-surface floodlight */
-       float                           floodlightDirectionScale;
-       vec3_t                          floodlightRGB; 
-       float                           floodlightIntensity;
-       float                           floodlightDistance;
-       
-       qb_t                            lmMergable;                                             /* ydnar */
-       int                                     lmCustomWidth, lmCustomHeight;  /* ydnar */
-       float                           lmBrightness;                                   /* ydnar */
-       float                           lmFilterRadius;                                 /* ydnar: lightmap filtering/blurring radius for this shader (default: 0) */
-       
-       int                                     shaderWidth, shaderHeight;              /* ydnar */
-       float                           stFlat[ 2 ];
-       
-       vec3_t                          fogDir;                                                 /* ydnar */
-       
-       char                            *shaderText;                                    /* ydnar */
-       qb_t                            custom;
-       qb_t                            finished;
+       float floodlightDirectionScale;
+       vec3_t floodlightRGB;
+       float floodlightIntensity;
+       float floodlightDistance;
+       qb_t lmMergable;                                    /* ydnar */
+       int lmCustomWidth, lmCustomHeight;                  /* ydnar */
+       float lmBrightness;                                 /* ydnar */
+       float lmFilterRadius;                               /* ydnar: lightmap filtering/blurring radius for this shader (default: 0) */
+       int shaderWidth, shaderHeight;                      /* ydnar */
+       float stFlat[ 2 ];
+       vec3_t fogDir;                                      /* ydnar */
+       char                *shaderText;                    /* ydnar */
+       qb_t custom;
+       qb_t finished;
  }
  shaderInfo_t;
  
  
  /* -------------------------------------------------------------------------------
  
- bsp structures
   bsp structures
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
  typedef struct face_s
  {
-       struct face_s           *next;
-       int                                     planenum;
-       int                                     priority;
+       struct face_s       *next;
+       int planenum;
+       int priority;
        //qboolean                      checked;
-       int                                     compileFlags;
-       winding_t                       *w;
+       int compileFlags;
+       winding_t           *w;
  }
  face_t;
  
  
  typedef struct plane_s
  {
-       vec3_t                          normal;
-       vec_t                           dist;
-       int                                     type;
-       int                 counter;
-       int                                     hash_chain;
+       vec3_t normal;
+       vec_t dist;
+       int type;
+       int counter;
+       int hash_chain;
  }
  plane_t;
  
  
  typedef struct side_s
  {
-       int                                     planenum;
-       
-       int                                     outputNum;                      /* set when the side is written to the file list */
-       
-       float                           texMat[ 2 ][ 3 ];       /* brush primitive texture matrix */
-       float                           vecs[ 2 ][ 4 ];         /* old-style texture coordinate mapping */
-       winding_t                       *winding;
-       winding_t                       *visibleHull;           /* convex hull of all visible fragments */
-       shaderInfo_t            *shaderInfo;
-       int                                     contentFlags;           /* from shaderInfo */
-       int                                     surfaceFlags;           /* from shaderInfo */
-       int                                     compileFlags;           /* from shaderInfo */
-       int                                     value;                          /* from shaderInfo */
-       qboolean                        visible;                        /* choose visble planes first */
-       qboolean                        bevel;                          /* don't ever use for bsp splitting, and don't bother making windings for it */
-       qboolean                        culled;                         /* ydnar: face culling */
+       int planenum;
+       int outputNum;                          /* set when the side is written to the file list */
+       float texMat[ 2 ][ 3 ];                 /* brush primitive texture matrix */
+       float vecs[ 2 ][ 4 ];                   /* old-style texture coordinate mapping */
+       winding_t           *winding;
+       winding_t           *visibleHull;       /* convex hull of all visible fragments */
+       shaderInfo_t        *shaderInfo;
+       int contentFlags;                       /* from shaderInfo */
+       int surfaceFlags;                       /* from shaderInfo */
+       int compileFlags;                       /* from shaderInfo */
+       int value;                              /* from shaderInfo */
+       qboolean visible;                       /* choose visble planes first */
+       qboolean bevel;                         /* don't ever use for bsp splitting, and don't bother making windings for it */
+       qboolean culled;                        /* ydnar: face culling */
  }
  side_t;
  
  
  typedef struct sideRef_s
  {
-       struct sideRef_s        *next;
-       side_t                          *side;
+       struct sideRef_s    *next;
+       side_t              *side;
  }
  sideRef_t;
  
  /* ydnar: generic index mapping for entities (natural extension of terrain texturing) */
  typedef struct indexMap_s
  {
-       int                                     w, h, numLayers;
-       char                            name[ MAX_QPATH ], shader[ MAX_QPATH ];
-       float                           offsets[ 256 ];
-       byte                            *pixels;
+       int w, h, numLayers;
+       char name[ MAX_QPATH ], shader[ MAX_QPATH ];
+       float offsets[ 256 ];
+       byte                *pixels;
  }
  indexMap_t;
  
  
  typedef struct brush_s
  {
-       struct brush_s          *next;
-       struct brush_s          *nextColorModBrush;     /* ydnar: colorMod volume brushes go here */
-       struct brush_s          *original;                      /* chopped up brushes will reference the originals */
-       
-       int                                     entityNum, brushNum;/* editor numbering */
-       int                                     outputNum;                      /* set when the brush is written to the file list */
-       
+       struct brush_s      *next;
+       struct brush_s      *nextColorModBrush; /* ydnar: colorMod volume brushes go here */
+       struct brush_s      *original;          /* chopped up brushes will reference the originals */
+       int entityNum, brushNum;                /* editor numbering */
+       int outputNum;                          /* set when the brush is written to the file list */
        /* ydnar: for shadowcasting entities */
-       int                                     castShadows;
-       int                                     recvShadows;
-       
-       shaderInfo_t            *contentShader;
-       shaderInfo_t            *celShader;                     /* :) */
-       
+       int castShadows;
+       int recvShadows;
+       shaderInfo_t        *contentShader;
+       shaderInfo_t        *celShader;         /* :) */
        /* ydnar: gs mods */
-       int                                     lightmapSampleSize; /* jal : entity based _lightmapsamplesize */
-       float                           lightmapScale;
-       float                           shadeAngleDegrees; /* jal : entity based _shadeangle */
-       vec3_t                          eMins, eMaxs;
-       indexMap_t                      *im;
-       int                                     contentFlags;
-       int                                     compileFlags;           /* ydnar */
-       qboolean                        detail;
-       qboolean                        opaque;
-       int                                     portalareas[ 2 ];
-       vec3_t                          mins, maxs;
-       int                                     numsides;
-       
-       side_t                          sides[ 6 ];                     /* variably sized */
+       int lightmapSampleSize;                 /* jal : entity based _lightmapsamplesize */
+       float lightmapScale;
+       float shadeAngleDegrees;               /* jal : entity based _shadeangle */
+       vec3_t eMins, eMaxs;
+       indexMap_t          *im;
+       int contentFlags;
+       int compileFlags;                       /* ydnar */
+       qboolean detail;
+       qboolean opaque;
+       int portalareas[ 2 ];
+       vec3_t mins, maxs;
+       int numsides;
+       side_t sides[ 6 ];                      /* variably sized */
  }
  brush_t;
  
  
  typedef struct fog_s
  {
-       shaderInfo_t            *si;
-       brush_t                         *brush;
-       int                                     visibleSide;            /* the brush side that ray tests need to clip against (-1 == none) */
+       shaderInfo_t        *si;
+       brush_t             *brush;
+       int visibleSide;                        /* the brush side that ray tests need to clip against (-1 == none) */
  }
  fog_t;
  
  
  typedef struct
  {
-       int                                     width, height;
-       bspDrawVert_t           *verts;
+       int width, height;
+       bspDrawVert_t       *verts;
  }
  mesh_t;
  
  
  typedef struct parseMesh_s
  {
-       struct parseMesh_s      *next;
-       
-       int                                     entityNum, brushNum;    /* ydnar: editor numbering */
-       
+       struct parseMesh_s  *next;
+       int entityNum, brushNum;                    /* ydnar: editor numbering */
        /* ydnar: for shadowcasting entities */
-       int                                     castShadows;
-       int                                     recvShadows;
-       
-       mesh_t                          mesh;
-       shaderInfo_t            *shaderInfo;
-       shaderInfo_t            *celShader;                             /* :) */
-       
+       int castShadows;
+       int recvShadows;
+       mesh_t mesh;
+       shaderInfo_t        *shaderInfo;
+       shaderInfo_t        *celShader;             /* :) */
        /* ydnar: gs mods */
-       int                                     lightmapSampleSize;             /* jal : entity based _lightmapsamplesize */
-       float                           lightmapScale;
-       vec3_t                          eMins, eMaxs;
-       indexMap_t                      *im;
-       
+       int lightmapSampleSize;                     /* jal : entity based _lightmapsamplesize */
+       float lightmapScale;
+       vec3_t eMins, eMaxs;
+       indexMap_t          *im;
        /* grouping */
-       qboolean                        grouped;
-       float                           longestCurve;
-       int                                     maxIterations;
+       qboolean grouped;
+       float longestCurve;
+       int maxIterations;
  }
  parseMesh_t;
  
  
  /*
-       ydnar: the drawsurf struct was extended to allow for:
-       - non-convex planar surfaces
-       - non-planar brushface surfaces
-       - lightmapped terrain
-       - planar patches
- */
+     ydnar: the drawsurf struct was extended to allow for:
+     - non-convex planar surfaces
+     - non-planar brushface surfaces
+     - lightmapped terrain
+     - planar patches
 */
  
  typedef enum
  {
        SURFACE_PATCH,
        SURFACE_TRIANGLES,
        SURFACE_FLARE,
-       SURFACE_FOLIAGE,        /* wolf et */
-       
+       SURFACE_FOLIAGE,    /* wolf et */
        /* ydnar: compiler-relevant surface types */
        SURFACE_FORCED_META,
        SURFACE_META,
        SURFACE_FOGHULL,
        SURFACE_DECAL,
        SURFACE_SHADER,
-       
        NUM_SURFACE_TYPES
  }
  surfaceType_t;
  
- char                  *surfaceTypes[ NUM_SURFACE_TYPES ]
+ char            *surfaceTypes[ NUM_SURFACE_TYPES ]
  #ifndef MAIN_C
                              ;
+ ;
  #else
-                               =
-                               {
-                                       "SURFACE_BAD",
-                                       "SURFACE_FACE",
-                                       "SURFACE_PATCH",
-                                       "SURFACE_TRIANGLES",
-                                       "SURFACE_FLARE",
-                                       "SURFACE_FOLIAGE",
-                                       "SURFACE_FORCED_META",
-                                       "SURFACE_META",
-                                       "SURFACE_FOGHULL",
-                                       "SURFACE_DECAL",
-                                       "SURFACE_SHADER"
-                               };
+       =
+       {
+       "SURFACE_BAD",
+       "SURFACE_FACE",
+       "SURFACE_PATCH",
+       "SURFACE_TRIANGLES",
+       "SURFACE_FLARE",
+       "SURFACE_FOLIAGE",
+       "SURFACE_FORCED_META",
+       "SURFACE_META",
+       "SURFACE_FOGHULL",
+       "SURFACE_DECAL",
+       "SURFACE_SHADER"
+       };
  #endif
  
  
  /* ydnar: this struct needs an overhaul (again, heh) */
  typedef struct mapDrawSurface_s
  {
-       surfaceType_t           type;
-       qboolean                        planar;
-       int                                     outputNum;                      /* ydnar: to match this sort of thing up */
-       
-       qboolean                        fur;                            /* ydnar: this is kind of a hack, but hey... */
-       qboolean                        skybox;                         /* ydnar: yet another fun hack */
-       qboolean                        backSide;                       /* ydnar: q3map_backShader support */
-       
-       struct mapDrawSurface_s *parent;                /* ydnar: for cloned (skybox) surfaces to share lighting data */
-       struct mapDrawSurface_s *clone;                 /* ydnar: for cloned surfaces */
-       struct mapDrawSurface_s *cel;                   /* ydnar: for cloned cel surfaces */
-       
-       shaderInfo_t            *shaderInfo;
-       shaderInfo_t            *celShader;
-       brush_t                         *mapBrush;
-       parseMesh_t                     *mapMesh;
-       sideRef_t                       *sideRef;
-       
-       int                                     fogNum;
-       
-       int                                     numVerts;                       /* vertexes and triangles */
-       bspDrawVert_t           *verts;
-       int                                     numIndexes;
-       int                                     *indexes;
-       
-       int                                     planeNum;
-       vec3_t                          lightmapOrigin;         /* also used for flares */
-       vec3_t                          lightmapVecs[ 3 ];      /* also used for flares */
-       int                                     lightStyle;                     /* used for flares */
-       
+       surfaceType_t type;
+       qboolean planar;
+       int outputNum;                          /* ydnar: to match this sort of thing up */
+       qboolean fur;                           /* ydnar: this is kind of a hack, but hey... */
+       qboolean skybox;                        /* ydnar: yet another fun hack */
+       qboolean backSide;                      /* ydnar: q3map_backShader support */
+       struct mapDrawSurface_s *parent;        /* ydnar: for cloned (skybox) surfaces to share lighting data */
+       struct mapDrawSurface_s *clone;         /* ydnar: for cloned surfaces */
+       struct mapDrawSurface_s *cel;           /* ydnar: for cloned cel surfaces */
+       shaderInfo_t        *shaderInfo;
+       shaderInfo_t        *celShader;
+       brush_t             *mapBrush;
+       parseMesh_t         *mapMesh;
+       sideRef_t           *sideRef;
+       int fogNum;
+       int numVerts;                           /* vertexes and triangles */
+       bspDrawVert_t       *verts;
+       int numIndexes;
+       int                 *indexes;
+       int planeNum;
+       vec3_t lightmapOrigin;                  /* also used for flares */
+       vec3_t lightmapVecs[ 3 ];               /* also used for flares */
+       int lightStyle;                         /* used for flares */
        /* ydnar: per-surface (per-entity, actually) lightmap sample size scaling */
-       float                           lightmapScale;
+       float lightmapScale;
  
        /* jal: per-surface (per-entity, actually) shadeangle */
-       float                           shadeAngleDegrees;
-       
+       float shadeAngleDegrees;
        /* ydnar: surface classification */
-       vec3_t                          mins, maxs;
-       vec3_t                          lightmapAxis;
-       int                                     sampleSize;
-       
+       vec3_t mins, maxs;
+       vec3_t lightmapAxis;
+       int sampleSize;
        /* ydnar: shadow group support */
-       int                                     castShadows, recvShadows;
-       
+       int castShadows, recvShadows;
        /* ydnar: texture coordinate range monitoring for hardware with limited texcoord precision (in texel space) */
-       float                           bias[ 2 ];
-       int                                     texMins[ 2 ], texMaxs[ 2 ], texRange[ 2 ];
-               
+       float bias[ 2 ];
+       int texMins[ 2 ], texMaxs[ 2 ], texRange[ 2 ];
        /* ydnar: for patches */
-       float                           longestCurve;
-       int                                     maxIterations;
-       int                                     patchWidth, patchHeight;
-       vec3_t                          bounds[ 2 ];
+       float longestCurve;
+       int maxIterations;
+       int patchWidth, patchHeight;
+       vec3_t bounds[ 2 ];
  
        /* ydnar/sd: for foliage */
-       int                                     numFoliageInstances;
-       
+       int numFoliageInstances;
        /* ydnar: editor/useful numbering */
-       int                                     entityNum;
-       int                                     surfaceNum;
+       int entityNum;
+       int surfaceNum;
  }
  mapDrawSurface_t;
  
  
  typedef struct drawSurfRef_s
  {
-       struct drawSurfRef_s    *nextRef;
-       int                                     outputNum;
+       struct drawSurfRef_s    *nextRef;
+       int outputNum;
  }
  drawSurfRef_t;
  
  /* ydnar: metasurfaces are constructed from lists of metatriangles so they can be merged in the best way */
  typedef struct metaTriangle_s
  {
-       shaderInfo_t            *si;
-       side_t                          *side;
-       int                                     entityNum, surfaceNum, planeNum, fogNum, sampleSize, castShadows, recvShadows;
-       float                           shadeAngleDegrees;
-       vec4_t                          plane;
-       vec3_t                          lightmapAxis;
-       int                                     indexes[ 3 ];
+       shaderInfo_t        *si;
+       side_t              *side;
+       int entityNum, surfaceNum, planeNum, fogNum, sampleSize, castShadows, recvShadows;
+       float shadeAngleDegrees;
+       vec4_t plane;
+       vec3_t lightmapAxis;
+       int indexes[ 3 ];
  }
  metaTriangle_t;
  
  
  typedef struct epair_s
  {
-       struct epair_s          *next;
-       char                            *key, *value;
+       struct epair_s      *next;
+       char                *key, *value;
  }
  epair_t;
  
  
  typedef struct
  {
-       vec3_t                          origin;
-       brush_t                         *brushes, *lastBrush, *colorModBrushes;
-       parseMesh_t                     *patches;
-       int                                     mapEntityNum, firstDrawSurf;
-       int                                     firstBrush, numBrushes;         /* only valid during BSP compile */
-       epair_t                         *epairs;
-       vec3_t                          originbrush_origin;
+       vec3_t origin;
+       brush_t             *brushes, *lastBrush, *colorModBrushes;
+       parseMesh_t         *patches;
+       int mapEntityNum, firstDrawSurf;
+       int firstBrush, numBrushes;                     /* only valid during BSP compile */
+       epair_t             *epairs;
+       vec3_t originbrush_origin;
  }
  entity_t;
  
  typedef struct node_s
  {
        /* both leafs and nodes */
-       int                                     planenum;               /* -1 = leaf node */
-       struct node_s           *parent;
-       vec3_t                          mins, maxs;             /* valid after portalization */
-       brush_t                         *volume;                /* one for each leaf/node */
+       int planenum;                       /* -1 = leaf node */
+       struct node_s       *parent;
+       vec3_t mins, maxs;                  /* valid after portalization */
+       brush_t             *volume;        /* one for each leaf/node */
  
        /* nodes only */
-       side_t                          *side;                  /* the side that created the node */
-       struct node_s           *children[ 2 ];
-       int                                     compileFlags;   /* ydnar: hint, antiportal */
-       int                                     tinyportals;
-       vec3_t                          referencepoint;
+       side_t              *side;          /* the side that created the node */
+       struct node_s       *children[ 2 ];
+       int compileFlags;                   /* ydnar: hint, antiportal */
+       int tinyportals;
+       vec3_t referencepoint;
  
        /* leafs only */
-       qboolean                        opaque;                 /* view can never be inside */
-       qboolean                        areaportal;
-       qboolean                        skybox;                 /* ydnar: a skybox leaf */
-       qboolean                        sky;                    /* ydnar: a sky leaf */
-       int                                     cluster;                /* for portalfile writing */
-       int                                     area;                   /* for areaportals */
-       brush_t                         *brushlist;             /* fragments of all brushes in this leaf */
-       drawSurfRef_t           *drawSurfReferences;
+       qboolean opaque;                    /* view can never be inside */
+       qboolean areaportal;
+       qboolean skybox;                    /* ydnar: a skybox leaf */
+       qboolean sky;                       /* ydnar: a sky leaf */
+       int cluster;                        /* for portalfile writing */
+       int area;                           /* for areaportals */
+       brush_t             *brushlist;     /* fragments of all brushes in this leaf */
+       drawSurfRef_t       *drawSurfReferences;
  
-       int                                     occupied;               /* 1 or greater can reach entity */
-       entity_t                        *occupant;              /* for leak file testing */
+       int occupied;                       /* 1 or greater can reach entity */
+       entity_t            *occupant;      /* for leak file testing */
  
-       struct portal_s         *portals;               /* also on nodes during construction */
+       struct portal_s     *portals;       /* also on nodes during construction */
  
-       qboolean            has_structural_children;
+       qboolean has_structural_children;
  }
  node_t;
  
  
  typedef struct portal_s
  {
-       plane_t                         plane;
-       node_t                          *onnode;                /* NULL = outside box */
-       node_t                          *nodes[ 2 ];    /* [ 0 ] = front side of plane */
-       struct portal_s         *next[ 2 ];
-       winding_t                       *winding;
-       qboolean                        sidefound;              /* false if ->side hasn't been checked */
-       int                                     compileFlags;   /* from original face that caused the split */
-       side_t                          *side;                  /* NULL = non-visible */
+       plane_t plane;
+       node_t              *onnode;        /* NULL = outside box */
+       node_t              *nodes[ 2 ];    /* [ 0 ] = front side of plane */
+       struct portal_s     *next[ 2 ];
+       winding_t           *winding;
+       qboolean sidefound;                 /* false if ->side hasn't been checked */
+       int compileFlags;                   /* from original face that caused the split */
+       side_t              *side;          /* NULL = non-visible */
  }
  portal_t;
  
  
  typedef struct
  {
-       node_t                          *headnode;
-       node_t                          outside_node;
-       vec3_t                          mins, maxs;
+       node_t              *headnode;
+       node_t outside_node;
+       vec3_t mins, maxs;
  }
  tree_t;
  
  
  /* -------------------------------------------------------------------------------
  
- vis structures
   vis structures
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
  typedef struct
  {
-       vec3_t                          normal;
-       float                           dist;
+       vec3_t normal;
+       float dist;
  }
  visPlane_t;
  
  
  typedef struct
  {
-       int                                     numpoints;
-       vec3_t                          points[ MAX_POINTS_ON_FIXED_WINDING     ];              /* variable sized */
- } 
+       int numpoints;
+       vec3_t points[ MAX_POINTS_ON_FIXED_WINDING ];                   /* variable sized */
+ }
  fixedWinding_t;
  
  
  typedef struct passage_s
  {
-       struct passage_s        *next;
-       byte                            cansee[ 1 ];    /* all portals that can be seen through this passage */
+       struct passage_s    *next;
+       byte cansee[ 1 ];                   /* all portals that can be seen through this passage */
  } passage_t;
  
  
@@@ -1234,55 -1235,54 +1235,55 @@@ vstatus_t
  
  typedef struct
  {
-       int                                     num;
-       qboolean                        hint;                   /* true if this portal was created from a hint splitter */
-       qboolean                        sky;                    /* true if this portal belongs to a sky leaf */
-       qboolean                        removed;
-       visPlane_t                      plane;                  /* normal pointing into neighbor */
-       int                                     leaf;                   /* neighbor */
-       
-       vec3_t                          origin;                 /* for fast clip testing */
-       float                           radius;
-       fixedWinding_t          *winding;
-       vstatus_t                       status;
-       byte                            *portalfront;   /* [portals], preliminary */
-       byte                            *portalflood;   /* [portals], intermediate */
-       byte                            *portalvis;             /* [portals], final */
-       int                                     nummightsee;    /* bit count on portalflood for sort */
-       passage_t                       *passages;              /* there are just as many passages as there */
-                                                                               /* are portals in the leaf this portal leads */
+       int num;
+       qboolean hint;                      /* true if this portal was created from a hint splitter */
++      qboolean sky;                       /* true if this portal belongs to a sky leaf */
+       qboolean removed;
+       visPlane_t plane;                   /* normal pointing into neighbor */
+       int leaf;                           /* neighbor */
+       vec3_t origin;                      /* for fast clip testing */
+       float radius;
+       fixedWinding_t      *winding;
+       vstatus_t status;
+       byte                *portalfront;   /* [portals], preliminary */
+       byte                *portalflood;   /* [portals], intermediate */
+       byte                *portalvis;     /* [portals], final */
+       int nummightsee;                    /* bit count on portalflood for sort */
+       passage_t           *passages;      /* there are just as many passages as there */
+                                           /* are portals in the leaf this portal leads */
  }
  vportal_t;
  
  
  typedef struct leaf_s
  {
-       int                                     numportals;
-       int                                     merged;
-       vportal_t                       *portals[MAX_PORTALS_ON_LEAF];
+       int numportals;
+       int merged;
+       vportal_t           *portals[MAX_PORTALS_ON_LEAF];
  }
  leaf_t;
  
-       
  typedef struct pstack_s
  {
-       byte                            mightsee[ MAX_PORTALS / 8 ];
-       struct pstack_s         *next;
-       leaf_t                          *leaf;
-       vportal_t                       *portal;                /* portal exiting */
-       fixedWinding_t          *source;
-       fixedWinding_t          *pass;
+       byte mightsee[ MAX_PORTALS / 8 ];
+       struct pstack_s     *next;
+       leaf_t              *leaf;
+       vportal_t           *portal;        /* portal exiting */
+       fixedWinding_t      *source;
+       fixedWinding_t      *pass;
  
-       fixedWinding_t          windings[ 3 ];  /* source, pass, temp in any order */
-       int                                     freewindings[ 3 ];
+       fixedWinding_t windings[ 3 ];       /* source, pass, temp in any order */
+       int freewindings[ 3 ];
  
-       visPlane_t                      portalplane;
+       visPlane_t portalplane;
        int depth;
  #ifdef SEPERATORCACHE
-       visPlane_t                      seperators[ 2 ][ MAX_SEPERATORS ];
-       int                                     numseperators[ 2 ];
+       visPlane_t seperators[ 2 ][ MAX_SEPERATORS ];
+       int numseperators[ 2 ];
  #endif
  }
  pstack_t;
  
  typedef struct
  {
-       vportal_t                       *base;
-       int                                     c_chains;
-       pstack_t                        pstack_head;
+       vportal_t           *base;
+       int c_chains;
+       pstack_t pstack_head;
  }
  threaddata_t;
  
  
  /* -------------------------------------------------------------------------------
  
- light structures
   light structures
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
  /* ydnar: new light struct with flags */
  typedef struct light_s
  {
-       struct light_s          *next;
-       
-       int                                     type;
-       int                                     flags;                  /* ydnar: condensed all the booleans into one flags int */
-       shaderInfo_t            *si;
-       
-       vec3_t                          origin;
-       vec3_t                          normal;                 /* for surfaces, spotlights, and suns */
-       float                           dist;                   /* plane location along normal */
-       
-       float                           photons;
-       int                                     style;
-       vec3_t                          color;
-       float                           radiusByDist;   /* for spotlights */
-       float                           fade;                   /* ydnar: from wolf, for linear lights */
-       float                           angleScale;             /* ydnar: stolen from vlight for K */
-       float                           extraDist;              /* "extra dimension" distance of the light, to kill hot spots */
-       float                           add;                    /* ydnar: used for area lights */
-       float                           envelope;               /* ydnar: units until falloff < tolerance */
-       float                           envelope2;              /* ydnar: envelope squared (tiny optimization) */
-       vec3_t                          mins, maxs;             /* ydnar: pvs envelope */
-       int                                     cluster;                /* ydnar: cluster light falls into */
-       
-       winding_t                       *w;
-       vec3_t                          emitColor;              /* full out-of-gamut value */
-       
-       float                           falloffTolerance;       /* ydnar: minimum attenuation threshold */
-       float                           filterRadius;   /* ydnar: lightmap filter radius in world units, 0 == default */
+       struct light_s      *next;
+       int type;
+       int flags;                          /* ydnar: condensed all the booleans into one flags int */
+       shaderInfo_t        *si;
+       vec3_t origin;
+       vec3_t normal;                      /* for surfaces, spotlights, and suns */
+       float dist;                         /* plane location along normal */
+       float photons;
+       int style;
+       vec3_t color;
+       float radiusByDist;                 /* for spotlights */
+       float fade;                         /* ydnar: from wolf, for linear lights */
+       float angleScale;                   /* ydnar: stolen from vlight for K */
+       float extraDist;                    /* "extra dimension" distance of the light, to kill hot spots */
+       float add;                          /* ydnar: used for area lights */
+       float envelope;                     /* ydnar: units until falloff < tolerance */
+       float envelope2;                    /* ydnar: envelope squared (tiny optimization) */
+       vec3_t mins, maxs;                  /* ydnar: pvs envelope */
+       int cluster;                        /* ydnar: cluster light falls into */
+       winding_t           *w;
+       vec3_t emitColor;                   /* full out-of-gamut value */
+       float falloffTolerance;                 /* ydnar: minimum attenuation threshold */
+       float filterRadius;                 /* ydnar: lightmap filter radius in world units, 0 == default */
  }
  light_t;
  
  typedef struct
  {
        /* constant input */
-       qboolean                        testOcclusion, forceSunlight, testAll;
-       int                                     recvShadows;
-       
-       int                                     numSurfaces;
-       int                                     *surfaces;
-       
-       int                                     numLights;
-       light_t                         **lights;
-       
-       qboolean                        twoSided;
-       
+       qboolean testOcclusion, forceSunlight, testAll;
+       int recvShadows;
+       int numSurfaces;
+       int                 *surfaces;
+       int numLights;
+       light_t             **lights;
+       qboolean twoSided;
        /* per-sample input */
-       int                                     cluster;
-       vec3_t                          origin, normal;
-       vec_t                           inhibitRadius;  /* sphere in which occluding geometry is ignored */
-       
+       int cluster;
+       vec3_t origin, normal;
+       vec_t inhibitRadius;                /* sphere in which occluding geometry is ignored */
        /* per-light input */
-       light_t                         *light;
-       vec3_t                          end;
-       
+       light_t             *light;
+       vec3_t end;
        /* calculated input */
-       vec3_t                          displacement, direction;
-       vec_t                           distance;
-       
+       vec3_t displacement, direction;
+       vec_t distance;
        /* input and output */
-       vec3_t                          color;                  /* starts out at full color, may be reduced if transparent surfaces are crossed */
-       vec3_t                          colorNoShadow;  /* result color with no shadow casting */
-       vec3_t                          directionContribution; /* result contribution to the deluxe map */
+       vec3_t color;                       /* starts out at full color, may be reduced if transparent surfaces are crossed */
+       vec3_t colorNoShadow;               /* result color with no shadow casting */
+       vec3_t directionContribution;              /* result contribution to the deluxe map */
  
        /* output */
-       vec3_t                          hit;
-       int                                     compileFlags;   /* for determining surface compile flags traced through */
-       qboolean                        passSolid;
-       qboolean                        opaque;
-       vec_t                   forceSubsampling; /* needs subsampling (alphashadow), value = max color contribution possible from it */
-       
+       vec3_t hit;
+       int compileFlags;                   /* for determining surface compile flags traced through */
+       qboolean passSolid;
+       qboolean opaque;
+       vec_t forceSubsampling;           /* needs subsampling (alphashadow), value = max color contribution possible from it */
        /* working data */
-       int                                     numTestNodes;
-       int                                     testNodes[ MAX_TRACE_TEST_NODES ]; 
+       int numTestNodes;
+       int testNodes[ MAX_TRACE_TEST_NODES ];
  }
  trace_t;
  
  /* must be identical to bspDrawVert_t except for float color! */
  typedef struct
  {
-       vec3_t                          xyz;
-       float                           st[ 2 ];
-       float                           lightmap[ MAX_LIGHTMAPS ][ 2 ];
-       vec3_t                          normal;
-       float                           color[ MAX_LIGHTMAPS ][ 4 ];
+       vec3_t xyz;
+       float st[ 2 ];
+       float lightmap[ MAX_LIGHTMAPS ][ 2 ];
+       vec3_t normal;
+       float color[ MAX_LIGHTMAPS ][ 4 ];
  }
  radVert_t;
  
  
  typedef struct
  {
-       int                                     numVerts;
-       radVert_t                       verts[ MAX_POINTS_ON_WINDING ];
+       int numVerts;
+       radVert_t verts[ MAX_POINTS_ON_WINDING ];
  }
  radWinding_t;
  
  /* crutch for poor local allocations in win32 smp */
  typedef struct
  {
-       vec_t                           dists[ MAX_POINTS_ON_WINDING + 4 ];
-       int                                     sides[ MAX_POINTS_ON_WINDING + 4 ];
+       vec_t dists[ MAX_POINTS_ON_WINDING + 4 ];
+       int sides[ MAX_POINTS_ON_WINDING + 4 ];
  }
  clipWork_t;
  
  /* ydnar: new lightmap handling code */
  typedef struct outLightmap_s
  {
-       int                                     lightmapNum, extLightmapNum;
-       int                                     customWidth, customHeight;
-       int                                     numLightmaps;
-       int                                     freeLuxels;
-       int                                     numShaders;
-       shaderInfo_t            *shaders[ MAX_LIGHTMAP_SHADERS ];
-       byte                            *lightBits;
-       byte                            *bspLightBytes;
-       byte                            *bspDirBytes;
+       int lightmapNum, extLightmapNum;
+       int customWidth, customHeight;
+       int numLightmaps;
+       int freeLuxels;
+       int numShaders;
+       shaderInfo_t        *shaders[ MAX_LIGHTMAP_SHADERS ];
+       byte                *lightBits;
+       byte                *bspLightBytes;
+       byte                *bspDirBytes;
  }
  outLightmap_t;
  
  
  typedef struct rawLightmap_s
  {
-       qboolean                                finished, splotchFix, wrap[ 2 ];
-       int                                             customWidth, customHeight;
-       float                                   brightness;
-       float                                   filterRadius;
-       
-       int                                             firstLightSurface, numLightSurfaces;    /* index into lightSurfaces */
-       int                                             numLightClusters, *lightClusters;
-       
-       int                                             sampleSize, actualSampleSize, axisNum;
+       qboolean finished, splotchFix, wrap[ 2 ];
+       int customWidth, customHeight;
+       float brightness;
+       float filterRadius;
+       int firstLightSurface, numLightSurfaces;                        /* index into lightSurfaces */
+       int numLightClusters, *lightClusters;
+       int sampleSize, actualSampleSize, axisNum;
  
        /* vortex: per-surface floodlight */
-       float                                   floodlightDirectionScale;
-       vec3_t                                  floodlightRGB; 
-       float                                   floodlightIntensity;
-       float                                   floodlightDistance;
-       int                                             entityNum;
-       int                                             recvShadows;
-       vec3_t                                  mins, maxs, axis, origin, *vecs;
-       float                                   *plane;
-       int                                             w, h, sw, sh, used;
-       
-       qboolean                                solid[ MAX_LIGHTMAPS ];
-       vec3_t                                  solidColor[ MAX_LIGHTMAPS ];
-       
-       int                                             numStyledTwins;
-       struct rawLightmap_s    *twins[ MAX_LIGHTMAPS ];
-       int                                             outLightmapNums[ MAX_LIGHTMAPS ];
-       int                                             twinNums[ MAX_LIGHTMAPS ];
-       int                                             lightmapX[ MAX_LIGHTMAPS ], lightmapY[ MAX_LIGHTMAPS ];
-       byte                                    styles[ MAX_LIGHTMAPS ];
-       float                                   *bspLuxels[ MAX_LIGHTMAPS ];
-       float                                   *radLuxels[ MAX_LIGHTMAPS ];
-       float                                   *superLuxels[ MAX_LIGHTMAPS ];
-       unsigned char                           *superFlags;
-       float                                   *superOrigins;
-       float                                   *superNormals;
-       int                                             *superClusters;
-       
-       float                                   *superDeluxels; /* average light direction */
-       float                                   *bspDeluxels;
-       float                                   *superFloodLight;
+       float floodlightDirectionScale;
+       vec3_t floodlightRGB;
+       float floodlightIntensity;
+       float floodlightDistance;
+       int entityNum;
+       int recvShadows;
+       vec3_t mins, maxs, axis, origin, *vecs;
+       float                   *plane;
+       int w, h, sw, sh, used;
+       qboolean solid[ MAX_LIGHTMAPS ];
+       vec3_t solidColor[ MAX_LIGHTMAPS ];
+       int numStyledTwins;
+       struct rawLightmap_s    *twins[ MAX_LIGHTMAPS ];
+       int outLightmapNums[ MAX_LIGHTMAPS ];
+       int twinNums[ MAX_LIGHTMAPS ];
+       int lightmapX[ MAX_LIGHTMAPS ], lightmapY[ MAX_LIGHTMAPS ];
+       byte styles[ MAX_LIGHTMAPS ];
+       float                   *bspLuxels[ MAX_LIGHTMAPS ];
+       float                   *radLuxels[ MAX_LIGHTMAPS ];
+       float                   *superLuxels[ MAX_LIGHTMAPS ];
+       unsigned char               *superFlags;
+       float                   *superOrigins;
+       float                   *superNormals;
+       int                     *superClusters;
+       float                   *superDeluxels; /* average light direction */
+       float                   *bspDeluxels;
+       float                   *superFloodLight;
  }
  rawLightmap_t;
  
  
  typedef struct rawGridPoint_s
  {
-       vec3_t                          ambient[ MAX_LIGHTMAPS ];
-       vec3_t                          directed[ MAX_LIGHTMAPS ];
-       vec3_t                          dir;
-       byte                            styles[ MAX_LIGHTMAPS ];
+       vec3_t ambient[ MAX_LIGHTMAPS ];
+       vec3_t directed[ MAX_LIGHTMAPS ];
+       vec3_t dir;
+       byte styles[ MAX_LIGHTMAPS ];
  }
  rawGridPoint_t;
  
  
  typedef struct surfaceInfo_s
  {
-       int                                     modelindex;
-       shaderInfo_t            *si;
-       rawLightmap_t           *lm;
-       int                                     parentSurfaceNum, childSurfaceNum;
-       int                                     entityNum, castShadows, recvShadows, sampleSize, patchIterations;
-       float                           longestCurve;
-       float                           *plane;
-       vec3_t                          axis, mins, maxs;
-       qboolean                        hasLightmap, approximated;
-       int                                     firstSurfaceCluster, numSurfaceClusters;
+       int modelindex;
+       shaderInfo_t        *si;
+       rawLightmap_t       *lm;
+       int parentSurfaceNum, childSurfaceNum;
+       int entityNum, castShadows, recvShadows, sampleSize, patchIterations;
+       float longestCurve;
+       float               *plane;
+       vec3_t axis, mins, maxs;
+       qboolean hasLightmap, approximated;
+       int firstSurfaceCluster, numSurfaceClusters;
  }
  surfaceInfo_t;
  
  /* -------------------------------------------------------------------------------
  
- prototypes
   prototypes
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
  /* main.c */
- vec_t                                         Random( void );
- int                                                   BSPInfo( int count, char **fileNames );
- int                                                   ScaleBSPMain( int argc, char **argv );
- int                                                   ConvertMain( int argc, char **argv );
+ vec_t                       Random( void );
+ char                        *Q_strncpyz( char *dst, const char *src, size_t len );
+ char                        *Q_strcat( char *dst, size_t dlen, const char *src );
+ char                        *Q_strncat( char *dst, size_t dlen, const char *src, size_t slen );
+ int                         BSPInfo( int count, char **fileNames );
+ int                         ScaleBSPMain( int argc, char **argv );
+ int                         ConvertMain( int argc, char **argv );
  
  
  /* path_init.c */
- game_t                                                *GetGame( char *arg );
- void                                          InitPaths( int *argc, char **argv );
+ game_t                      *GetGame( char *arg );
+ void                        InitPaths( int *argc, char **argv );
  
  
  /* bsp.c */
- int                                                   BSPMain( int argc, char **argv );
+ int                         BSPMain( int argc, char **argv );
  
  
  /* convert_map.c */
- int                                                   ConvertBSPToMap( char *bspName );
- int                                                   ConvertBSPToMap_BP( char *bspName );
+ int                         ConvertBSPToMap( char *bspName );
+ int                         ConvertBSPToMap_BP( char *bspName );
  
  
  /* convert_ase.c */
- int                                                   ConvertBSPToASE( char *bspName );
+ int                         ConvertBSPToASE( char *bspName );
  
  /* convert_obj.c */
- int                                                   ConvertBSPToOBJ( char *bspName );
+ int                         ConvertBSPToOBJ( char *bspName );
  
  
  /* brush.c */
- sideRef_t                                     *AllocSideRef( side_t *side, sideRef_t *next );
- int                                                   CountBrushList( brush_t *brushes );
- brush_t                                               *AllocBrush( int numsides );
- void                                          FreeBrush( brush_t *brushes );
- void                                          FreeBrushList( brush_t *brushes );
- brush_t                                               *CopyBrush( brush_t *brush );
- qboolean                                      BoundBrush( brush_t *brush );
- qboolean                                      CreateBrushWindings( brush_t *brush );
- brush_t                                               *BrushFromBounds( vec3_t mins, vec3_t maxs );
- vec_t                                         BrushVolume( brush_t *brush );
- void                                          WriteBSPBrushMap( char *name, brush_t *list );
+ sideRef_t                   *AllocSideRef( side_t *side, sideRef_t *next );
+ int                         CountBrushList( brush_t *brushes );
+ brush_t                     *AllocBrush( int numsides );
+ void                        FreeBrush( brush_t *brushes );
+ void                        FreeBrushList( brush_t *brushes );
+ brush_t                     *CopyBrush( brush_t *brush );
+ qboolean                    BoundBrush( brush_t *brush );
+ qboolean                    CreateBrushWindings( brush_t *brush );
+ brush_t                     *BrushFromBounds( vec3_t mins, vec3_t maxs );
+ vec_t                       BrushVolume( brush_t *brush );
+ void                        WriteBSPBrushMap( char *name, brush_t *list );
  
- void                                          FilterDetailBrushesIntoTree( entity_t *e, tree_t *tree );
- void                                          FilterStructuralBrushesIntoTree( entity_t *e, tree_t *tree );
+ void                        FilterDetailBrushesIntoTree( entity_t *e, tree_t *tree );
+ void                        FilterStructuralBrushesIntoTree( entity_t *e, tree_t *tree );
  
- int                                                   BoxOnPlaneSide( vec3_t mins, vec3_t maxs, plane_t *plane );
- qboolean                                      WindingIsTiny( winding_t *w );
+ int                         BoxOnPlaneSide( vec3_t mins, vec3_t maxs, plane_t *plane );
+ qboolean                    WindingIsTiny( winding_t *w );
  
- void                                          SplitBrush( brush_t *brush, int planenum, brush_t **front, brush_t **back);
+ void                        SplitBrush( brush_t *brush, int planenum, brush_t **front, brush_t **back );
  
- tree_t                                                *AllocTree( void );
- node_t                                                *AllocNode( void );
+ tree_t                      *AllocTree( void );
+ node_t                      *AllocNode( void );
  
  
  /* mesh.c */
- void                                          LerpDrawVert( bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *out );
- void                                          LerpDrawVertAmount( bspDrawVert_t *a, bspDrawVert_t *b, float amount, bspDrawVert_t *out );
- void                                          FreeMesh( mesh_t *m );
- mesh_t                                                *CopyMesh( mesh_t *mesh );
- void                                          PrintMesh( mesh_t *m );
- mesh_t                                                *TransposeMesh( mesh_t *in );
- void                                          InvertMesh( mesh_t *m );
- mesh_t                                                *SubdivideMesh( mesh_t in, float maxError, float minLength );
- int                                                   IterationsForCurve( float len, int subdivisions );
- mesh_t                                                *SubdivideMesh2( mesh_t in, int iterations );
- mesh_t                                                *SubdivideMeshQuads( mesh_t *in, float minLength, int maxsize, int *widthtable, int *heighttable );
- mesh_t                                                *RemoveLinearMeshColumnsRows( mesh_t *in );
- void                                          MakeMeshNormals( mesh_t in );
- void                                          PutMeshOnCurve( mesh_t in );
- void                                          MakeNormalVectors( vec3_t forward, vec3_t right, vec3_t up );
+ void                        LerpDrawVert( bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *out );
+ void                        LerpDrawVertAmount( bspDrawVert_t *a, bspDrawVert_t *b, float amount, bspDrawVert_t *out );
+ void                        FreeMesh( mesh_t *m );
+ mesh_t                      *CopyMesh( mesh_t *mesh );
+ void                        PrintMesh( mesh_t *m );
+ mesh_t                      *TransposeMesh( mesh_t *in );
+ void                        InvertMesh( mesh_t *m );
+ mesh_t                      *SubdivideMesh( mesh_t in, float maxError, float minLength );
+ int                         IterationsForCurve( float len, int subdivisions );
+ mesh_t                      *SubdivideMesh2( mesh_t in, int iterations );
+ mesh_t                      *SubdivideMeshQuads( mesh_t *in, float minLength, int maxsize, int *widthtable, int *heighttable );
+ mesh_t                      *RemoveLinearMeshColumnsRows( mesh_t *in );
+ void                        MakeMeshNormals( mesh_t in );
+ void                        PutMeshOnCurve( mesh_t in );
+ void                        MakeNormalVectors( vec3_t forward, vec3_t right, vec3_t up );
  
  
  /* map.c */
- void                                          LoadMapFile( char *filename, qboolean onlyLights, qboolean noCollapseGroups );
- int                                                   FindFloatPlane( vec3_t normal, vec_t dist, int numPoints, vec3_t *points );
- int                                                   PlaneTypeForNormal( vec3_t normal );
- void                                          AddBrushBevels( void );
- brush_t                                               *FinishBrush(qboolean noCollapseGroups);
+ void                        LoadMapFile( char *filename, qboolean onlyLights, qboolean noCollapseGroups );
+ int                         FindFloatPlane( vec3_t normal, vec_t dist, int numPoints, vec3_t *points );
+ int                         PlaneTypeForNormal( vec3_t normal );
+ void                        AddBrushBevels( void );
+ brush_t                     *FinishBrush( qboolean noCollapseGroups );
  
  
  /* portals.c */
- void                                          MakeHeadnodePortals( tree_t *tree );
- void                                          MakeNodePortal( node_t *node );
- void                                          SplitNodePortals( node_t *node );
+ void                        MakeHeadnodePortals( tree_t *tree );
+ void                        MakeNodePortal( node_t *node );
+ void                        SplitNodePortals( node_t *node );
  
- qboolean                                      PortalPassable( portal_t *p );
+ qboolean                    PortalPassable( portal_t *p );
  
- qboolean                                      FloodEntities( tree_t *tree );
- void                                          FillOutside( node_t *headnode);
- void                                          FloodAreas( tree_t *tree);
- face_t                                                *VisibleFaces( entity_t *e, tree_t *tree );
- void                                          FreePortal( portal_t *p );
+ #define FLOODENTITIES_LEAKED 1
+ #define FLOODENTITIES_GOOD 0
+ #define FLOODENTITIES_EMPTY -1
+ int                     FloodEntities( tree_t *tree );
+ void                        FillOutside( node_t *headnode );
+ void                        FloodAreas( tree_t *tree );
+ face_t                      *VisibleFaces( entity_t *e, tree_t *tree );
+ void                        FreePortal( portal_t *p );
  
- void                                          MakeTreePortals( tree_t *tree );
+ void                        MakeTreePortals( tree_t *tree );
  
  
  /* leakfile.c */
- xmlNodePtr                                    LeakFile( tree_t *tree );
+ xmlNodePtr                  LeakFile( tree_t *tree );
  
  
  /* prtfile.c */
- void                                          NumberClusters( tree_t *tree );
- void                                          WritePortalFile( tree_t *tree );
+ void                        NumberClusters( tree_t *tree );
+ void                        WritePortalFile( tree_t *tree );
  
  
  /* writebsp.c */
- void                                          SetModelNumbers( void );
- void                                          SetLightStyles( void );
+ void                        SetModelNumbers( void );
+ void                        SetLightStyles( void );
  
- int                                                   EmitShader( const char *shader, int *contentFlags, int *surfaceFlags );
+ int                         EmitShader( const char *shader, int *contentFlags, int *surfaceFlags );
  
- void                                          BeginBSPFile( void );
- void                                          EndBSPFile( qboolean do_write );
- void                                          EmitBrushes( brush_t *brushes, int *firstBrush, int *numBrushes );
- void                                          EmitFogs( void );
+ void                        BeginBSPFile( void );
+ void                        EndBSPFile( qboolean do_write );
+ void                        EmitBrushes( brush_t *brushes, int *firstBrush, int *numBrushes );
+ void                        EmitFogs( void );
  
- void                                          BeginModel( void );
- void                                          EndModel( entity_t *e, node_t *headnode );
+ void                        BeginModel( void );
+ void                        EndModel( entity_t *e, node_t *headnode );
  
  
  /* tree.c */
- void                                          FreeTree( tree_t *tree );
- void                                          FreeTree_r( node_t *node );
- void                                          PrintTree_r( node_t *node, int depth );
- void                                          FreeTreePortals_r( node_t *node );
+ void                        FreeTree( tree_t *tree );
+ void                        FreeTree_r( node_t *node );
+ void                        PrintTree_r( node_t *node, int depth );
+ void                        FreeTreePortals_r( node_t *node );
  
  
  /* patch.c */
- void                                          ParsePatch( qboolean onlyLights );
- mesh_t                                                *SubdivideMesh( mesh_t in, float maxError, float minLength );
- void                                          PatchMapDrawSurfs( entity_t *e );
- void                                          TriangulatePatchSurface( entity_t *e , mapDrawSurface_t *ds );
+ void                        ParsePatch( qboolean onlyLights );
+ mesh_t                      *SubdivideMesh( mesh_t in, float maxError, float minLength );
+ void                        PatchMapDrawSurfs( entity_t *e );
+ void                        TriangulatePatchSurface( entity_t *e, mapDrawSurface_t *ds );
  
  
  /* tjunction.c */
- void                                          FixTJunctions( entity_t *e );
+ void                        FixTJunctions( entity_t *e );
  
  
  /* fog.c */
- winding_t                                     *WindingFromDrawSurf( mapDrawSurface_t *ds );
- void                                          FogDrawSurfaces( entity_t *e );
- int                                                   FogForPoint( vec3_t point, float epsilon );
- int                                                   FogForBounds( vec3_t mins, vec3_t maxs, float epsilon );
- void                                          CreateMapFogs( void );
+ winding_t                   *WindingFromDrawSurf( mapDrawSurface_t *ds );
+ void                        FogDrawSurfaces( entity_t *e );
+ int                         FogForPoint( vec3_t point, float epsilon );
+ int                         FogForBounds( vec3_t mins, vec3_t maxs, float epsilon );
+ void                        CreateMapFogs( void );
  
  
  /* facebsp.c */
- face_t                                                *MakeStructuralBSPFaceList( brush_t *list );
- face_t                                                *MakeVisibleBSPFaceList( brush_t *list );
- tree_t                                                *FaceBSP( face_t *list );
+ face_t                      *MakeStructuralBSPFaceList( brush_t *list );
+ face_t                      *MakeVisibleBSPFaceList( brush_t *list );
+ tree_t                      *FaceBSP( face_t *list );
  
  
  /* model.c */
- void                                          PicoPrintFunc( int level, const char *str );
- void                                          PicoLoadFileFunc( const char *name, byte **buffer, int *bufSize );
- picoModel_t                                   *FindModel( const char *name, int frame );
- picoModel_t                                   *LoadModel( const char *name, int frame );
- void                                          InsertModel( const char *name, int skin, int frame, m4x4_t transform, remap_t *remap, shaderInfo_t *celShader, int eNum, int castShadows, int recvShadows, int spawnFlags, float lightmapScale, int lightmapSampleSize, float shadeAngle );
- void                                          AddTriangleModels( entity_t *e );
+ void                        PicoPrintFunc( int level, const char *str );
+ void                        PicoLoadFileFunc( const char *name, byte **buffer, int *bufSize );
+ picoModel_t                 *FindModel( const char *name, int frame );
+ picoModel_t                 *LoadModel( const char *name, int frame );
+ void                        InsertModel( const char *name, int skin, int frame, m4x4_t transform, remap_t *remap, shaderInfo_t *celShader, int eNum, int castShadows, int recvShadows, int spawnFlags, float lightmapScale, int lightmapSampleSize, float shadeAngle );
+ void                        AddTriangleModels( entity_t *e );
  
  
  /* surface.c */
- mapDrawSurface_t                      *AllocDrawSurface( surfaceType_t type );
- void                                          FinishSurface( mapDrawSurface_t *ds );
- void                                          StripFaceSurface( mapDrawSurface_t *ds );
- void                                          MaxAreaFaceSurface( mapDrawSurface_t *ds );
- qboolean                                      CalcSurfaceTextureRange( mapDrawSurface_t *ds );
- qboolean                                      CalcLightmapAxis( vec3_t normal, vec3_t axis );
- void                                          ClassifySurfaces( int numSurfs, mapDrawSurface_t *ds );
- void                                          ClassifyEntitySurfaces( entity_t *e );
- void                                          TidyEntitySurfaces( entity_t *e );
- mapDrawSurface_t                      *CloneSurface( mapDrawSurface_t *src, shaderInfo_t *si );
- mapDrawSurface_t                      *MakeCelSurface( mapDrawSurface_t *src, shaderInfo_t *si );
- qboolean                                      IsTriangleDegenerate( bspDrawVert_t *points, int a, int b, int c );
- void                                          ClearSurface( mapDrawSurface_t *ds );
- void                                          AddEntitySurfaceModels( entity_t *e );
- mapDrawSurface_t                      *DrawSurfaceForSide( entity_t *e, brush_t *b, side_t *s, winding_t *w );
- mapDrawSurface_t                      *DrawSurfaceForMesh( entity_t *e, parseMesh_t *p, mesh_t *mesh );
- mapDrawSurface_t                      *DrawSurfaceForFlare( int entNum, vec3_t origin, vec3_t normal, vec3_t color, const char *flareShader, int lightStyle );
- mapDrawSurface_t                      *DrawSurfaceForShader( char *shader );
- void                                          ClipSidesIntoTree( entity_t *e, tree_t *tree );
- void                                          MakeDebugPortalSurfs( tree_t *tree );
- void                                          MakeFogHullSurfs( entity_t *e, tree_t *tree, char *shader );
- void                                          SubdivideFaceSurfaces( entity_t *e, tree_t *tree );
- void                                          AddEntitySurfaceModels( entity_t *e );
- int                                                   AddSurfaceModels( mapDrawSurface_t *ds );
- void                                          FilterDrawsurfsIntoTree( entity_t *e, tree_t *tree );
- void                                          EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds );
- void                                          EmitTriangleSurface( mapDrawSurface_t *ds );
+ mapDrawSurface_t            *AllocDrawSurface( surfaceType_t type );
+ void                        FinishSurface( mapDrawSurface_t *ds );
+ void                        StripFaceSurface( mapDrawSurface_t *ds );
+ void                        MaxAreaFaceSurface( mapDrawSurface_t *ds );
+ qboolean                    CalcSurfaceTextureRange( mapDrawSurface_t *ds );
+ qboolean                    CalcLightmapAxis( vec3_t normal, vec3_t axis );
+ void                        ClassifySurfaces( int numSurfs, mapDrawSurface_t *ds );
+ void                        ClassifyEntitySurfaces( entity_t *e );
+ void                        TidyEntitySurfaces( entity_t *e );
+ mapDrawSurface_t            *CloneSurface( mapDrawSurface_t *src, shaderInfo_t *si );
+ mapDrawSurface_t            *MakeCelSurface( mapDrawSurface_t *src, shaderInfo_t *si );
+ qboolean                    IsTriangleDegenerate( bspDrawVert_t *points, int a, int b, int c );
+ void                        ClearSurface( mapDrawSurface_t *ds );
+ void                        AddEntitySurfaceModels( entity_t *e );
+ mapDrawSurface_t            *DrawSurfaceForSide( entity_t *e, brush_t *b, side_t *s, winding_t *w );
+ mapDrawSurface_t            *DrawSurfaceForMesh( entity_t *e, parseMesh_t *p, mesh_t *mesh );
+ mapDrawSurface_t            *DrawSurfaceForFlare( int entNum, vec3_t origin, vec3_t normal, vec3_t color, const char *flareShader, int lightStyle );
+ mapDrawSurface_t            *DrawSurfaceForShader( char *shader );
+ void                        ClipSidesIntoTree( entity_t *e, tree_t *tree );
+ void                        MakeDebugPortalSurfs( tree_t *tree );
+ void                        MakeFogHullSurfs( entity_t *e, tree_t *tree, char *shader );
+ void                        SubdivideFaceSurfaces( entity_t *e, tree_t *tree );
+ void                        AddEntitySurfaceModels( entity_t *e );
+ int                         AddSurfaceModels( mapDrawSurface_t *ds );
+ void                        FilterDrawsurfsIntoTree( entity_t *e, tree_t *tree );
+ void                        EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds );
+ void                        EmitTriangleSurface( mapDrawSurface_t *ds );
  
  
  /* surface_fur.c */
- void                                          Fur( mapDrawSurface_t *src );
+ void                        Fur( mapDrawSurface_t *src );
  
  
  /* surface_foliage.c */
- void                                          Foliage( mapDrawSurface_t *src );
+ void                        Foliage( mapDrawSurface_t *src );
  
  
  /* ydnar: surface_meta.c */
- void                                          ClearMetaTriangles( void );
- int                                                   FindMetaTriangle( metaTriangle_t *src, bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *c, int planeNum );
- void                                          MakeEntityMetaTriangles( entity_t *e );
- void                                          FixMetaTJunctions( void );
- void                                          SmoothMetaTriangles( void );
- void                                          MergeMetaTriangles( void );
- void                                          EmitMetaStats(); // vortex: print meta statistics even in no-verbose mode
+ void                        ClearMetaTriangles( void );
+ int                         FindMetaTriangle( metaTriangle_t *src, bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *c, int planeNum );
+ void                        MakeEntityMetaTriangles( entity_t *e );
+ void                        FixMetaTJunctions( void );
+ void                        SmoothMetaTriangles( void );
+ void                        MergeMetaTriangles( void );
+ void                        EmitMetaStats(); // vortex: print meta statistics even in no-verbose mode
  
  
  /* surface_extra.c */
- void                                          SetDefaultSampleSize( int sampleSize );
+ void                        SetDefaultSampleSize( int sampleSize );
  
- void                                          SetSurfaceExtra( mapDrawSurface_t *ds, int num );
+ void                        SetSurfaceExtra( mapDrawSurface_t *ds, int num );
  
- shaderInfo_t                          *GetSurfaceExtraShaderInfo( int num );
- int                                                   GetSurfaceExtraParentSurfaceNum( int num );
- int                                                   GetSurfaceExtraEntityNum( int num );
- int                                                   GetSurfaceExtraCastShadows( int num );
- int                                                   GetSurfaceExtraRecvShadows( int num );
- int                                                   GetSurfaceExtraSampleSize( int num );
- int                                                   GetSurfaceExtraMinSampleSize( int num );
- float                                         GetSurfaceExtraLongestCurve( int num );
- void                                          GetSurfaceExtraLightmapAxis( int num, vec3_t lightmapAxis );
+ shaderInfo_t                *GetSurfaceExtraShaderInfo( int num );
+ int                         GetSurfaceExtraParentSurfaceNum( int num );
+ int                         GetSurfaceExtraEntityNum( int num );
+ int                         GetSurfaceExtraCastShadows( int num );
+ int                         GetSurfaceExtraRecvShadows( int num );
+ int                         GetSurfaceExtraSampleSize( int num );
+ int                         GetSurfaceExtraMinSampleSize( int num );
+ float                       GetSurfaceExtraLongestCurve( int num );
+ void                        GetSurfaceExtraLightmapAxis( int num, vec3_t lightmapAxis );
  
- void                                          WriteSurfaceExtraFile( const char *path );
- void                                          LoadSurfaceExtraFile( const char *path );
+ void                        WriteSurfaceExtraFile( const char *path );
+ void                        LoadSurfaceExtraFile( const char *path );
  
  
  /* decals.c */
- void                                          ProcessDecals( void );
- void                                          MakeEntityDecals( entity_t *e );
+ void                        ProcessDecals( void );
+ void                        MakeEntityDecals( entity_t *e );
  
  /* map.c */
- void                                          TextureAxisFromPlane( plane_t *pln, vec3_t xv, vec3_t yv );
+ void                        TextureAxisFromPlane( plane_t *pln, vec3_t xv, vec3_t yv );
  
  /* brush_primit.c */
- void                                          ComputeAxisBase( vec3_t normal, vec3_t texX, vec3_t texY);
+ void                        ComputeAxisBase( vec3_t normal, vec3_t texX, vec3_t texY );
  
  
  /* vis.c */
- fixedWinding_t                                *NewFixedWinding( int points );
- int                                                   VisMain( int argc, char **argv );
+ fixedWinding_t              *NewFixedWinding( int points );
+ int                         VisMain( int argc, char **argv );
  
  /* visflow.c */
- int                                                   CountBits( byte *bits, int numbits );
- void                                          PassageFlow( int portalnum );
- void                                          CreatePassages( int portalnum );
- void                                          PassageMemory( void );
- void                                          BasePortalVis( int portalnum );
- void                                          BetterPortalVis( int portalnum );
- void                                          PortalFlow( int portalnum );
- void                                          PassagePortalFlow( int portalnum );
+ int                         CountBits( byte *bits, int numbits );
+ void                        PassageFlow( int portalnum );
+ void                        CreatePassages( int portalnum );
+ void                        PassageMemory( void );
+ void                        BasePortalVis( int portalnum );
+ void                        BetterPortalVis( int portalnum );
+ void                        PortalFlow( int portalnum );
+ void                        PassagePortalFlow( int portalnum );
  
  
  
  /* light.c  */
- float                                         PointToPolygonFormFactor( const vec3_t point, const vec3_t normal, const winding_t *w );
- int                                                   LightContributionToSample( trace_t *trace );
- void                                          LightingAtSample( trace_t *trace, byte styles[ MAX_LIGHTMAPS ], vec3_t colors[ MAX_LIGHTMAPS ] );
- int                                                   LightContributionToPoint( trace_t *trace );
- int                                                   LightMain( int argc, char **argv );
+ float                       PointToPolygonFormFactor( const vec3_t point, const vec3_t normal, const winding_t *w );
+ int                         LightContributionToSample( trace_t *trace );
+ void LightingAtSample( trace_t * trace, byte styles[ MAX_LIGHTMAPS ], vec3_t colors[ MAX_LIGHTMAPS ] );
+ int                         LightContributionToPoint( trace_t *trace );
+ int                         LightMain( int argc, char **argv );
  
  
  /* light_trace.c */
- void                                          SetupTraceNodes( void );
- void                                          TraceLine( trace_t *trace );
- float                                         SetupTrace( trace_t *trace );
+ void                        SetupTraceNodes( void );
+ void                        TraceLine( trace_t *trace );
+ float                       SetupTrace( trace_t *trace );
  
  
  /* light_bounce.c */
- qboolean                                      RadSampleImage( byte *pixels, int width, int height, float st[ 2 ], float color[ 4 ] );
- void                                          RadLightForTriangles( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw );
- void                                          RadLightForPatch( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw );
- void                                          RadCreateDiffuseLights( void );
- void                                          RadFreeLights();
+ qboolean RadSampleImage( byte * pixels, int width, int height, float st[ 2 ], float color[ 4 ] );
+ void                        RadLightForTriangles( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw );
+ void                        RadLightForPatch( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw );
+ void                        RadCreateDiffuseLights( void );
+ void                        RadFreeLights();
  
  
  /* light_ydnar.c */
- void                                          ColorToBytes( const float *color, byte *colorBytes, float scale );
- void                                          SmoothNormals( void );
- void                                          MapRawLightmap( int num );
- void                                          SetupDirt();
- float                                         DirtForSample( trace_t *trace );
- void                                          DirtyRawLightmap( int num );
- void                                          SetupFloodLight();
- void                                          FloodlightRawLightmaps();
- void                                          FloodlightIlluminateLightmap( rawLightmap_t *lm );
- float                                         FloodLightForSample( trace_t *trace , float floodLightDistance, qboolean floodLightLowQuality);
- void                                          FloodLightRawLightmap( int num );
- void                                          IlluminateRawLightmap( int num );
- void                                          IlluminateVertexes( int num );
- void                                          SetupBrushes( void );
- void                                          SetupClusters( void );
- qboolean                                      ClusterVisible( int a, int b );
- qboolean                                      ClusterVisibleToPoint( vec3_t point, int cluster );
- int                                                   ClusterForPoint( vec3_t point );
- int                                                   ClusterForPointExt( vec3_t point, float epsilon );
- int                                                   ClusterForPointExtFilter( vec3_t point, float epsilon, int numClusters, int *clusters );
- int                                                   ShaderForPointInLeaf( vec3_t point, int leafNum, float epsilon, int wantContentFlags, int wantSurfaceFlags, int *contentFlags, int *surfaceFlags );
- void                                          SetupEnvelopes( qboolean forGrid, qboolean fastFlag );
- void                                          FreeTraceLights( trace_t *trace );
- void                                          CreateTraceLightsForBounds( vec3_t mins, vec3_t maxs, vec3_t normal, int numClusters, int *clusters, int flags, trace_t *trace );
- void                                          CreateTraceLightsForSurface( int num, trace_t *trace );
+ void                        ColorToBytes( const float *color, byte *colorBytes, float scale );
+ void                        SmoothNormals( void );
+ void                        MapRawLightmap( int num );
+ void                        SetupDirt();
+ float                       DirtForSample( trace_t *trace );
+ void                        DirtyRawLightmap( int num );
+ void                        SetupFloodLight();
+ void                        FloodlightRawLightmaps();
+ void                        FloodlightIlluminateLightmap( rawLightmap_t *lm );
+ float                       FloodLightForSample( trace_t *trace, float floodLightDistance, qboolean floodLightLowQuality );
+ void                        FloodLightRawLightmap( int num );
+ void                        IlluminateRawLightmap( int num );
+ void                        IlluminateVertexes( int num );
+ void                        SetupBrushesFlags( int mask_any, int test_any, int mask_all, int test_all );
+ void                        SetupBrushes( void );
+ void                        SetupClusters( void );
+ qboolean                    ClusterVisible( int a, int b );
+ qboolean                    ClusterVisibleToPoint( vec3_t point, int cluster );
+ int                         ClusterForPoint( vec3_t point );
+ int                         ClusterForPointExt( vec3_t point, float epsilon );
+ int                         ClusterForPointExtFilter( vec3_t point, float epsilon, int numClusters, int *clusters );
+ int                         ShaderForPointInLeaf( vec3_t point, int leafNum, float epsilon, int wantContentFlags, int wantSurfaceFlags, int *contentFlags, int *surfaceFlags );
+ void                        SetupEnvelopes( qboolean forGrid, qboolean fastFlag );
+ void                        FreeTraceLights( trace_t *trace );
+ void                        CreateTraceLightsForBounds( vec3_t mins, vec3_t maxs, vec3_t normal, int numClusters, int *clusters, int flags, trace_t *trace );
+ void                        CreateTraceLightsForSurface( int num, trace_t *trace );
  
  
  /* lightmaps_ydnar.c */
- void                                          ExportLightmaps( void );
+ void                        ExportLightmaps( void );
  
- int                                                   ExportLightmapsMain( int argc, char **argv );
- int                                                   ImportLightmapsMain( int argc, char **argv );
+ int                         ExportLightmapsMain( int argc, char **argv );
+ int                         ImportLightmapsMain( int argc, char **argv );
  
- void                                          SetupSurfaceLightmaps( void );
- void                                          StitchSurfaceLightmaps( void );
- void                                          StoreSurfaceLightmaps( void );
+ void                        SetupSurfaceLightmaps( void );
+ void                        StitchSurfaceLightmaps( void );
+ void                        StoreSurfaceLightmaps( void );
  
  
  /* image.c */
- void                                          ImageFree( image_t *image );
- image_t                                               *ImageFind( const char *filename );
- image_t                                               *ImageLoad( const char *filename );
+ void                        ImageFree( image_t *image );
+ image_t                     *ImageFind( const char *filename );
+ image_t                     *ImageLoad( const char *filename );
  
  
  /* shaders.c */
- void                                          ColorMod( colorMod_t *am, int numVerts, bspDrawVert_t *drawVerts );
+ void                        ColorMod( colorMod_t *am, int numVerts, bspDrawVert_t *drawVerts );
  
- void                                          TCMod( tcMod_t mod, float st[ 2 ] );
- void                                          TCModIdentity( tcMod_t mod );
- void                                          TCModMultiply( tcMod_t a, tcMod_t b, tcMod_t out );
- void                                          TCModTranslate( tcMod_t mod, float s, float t );
- void                                          TCModScale( tcMod_t mod, float s, float t );
- void                                          TCModRotate( tcMod_t mod, float euler );
+ void TCMod( tcMod_t mod, float st[ 2 ] );
+ void                        TCModIdentity( tcMod_t mod );
+ void                        TCModMultiply( tcMod_t a, tcMod_t b, tcMod_t out );
+ void                        TCModTranslate( tcMod_t mod, float s, float t );
+ void                        TCModScale( tcMod_t mod, float s, float t );
+ void                        TCModRotate( tcMod_t mod, float euler );
  
- qboolean                                      ApplySurfaceParm( char *name, int *contentFlags, int *surfaceFlags, int *compileFlags );
+ qboolean                    ApplySurfaceParm( char *name, int *contentFlags, int *surfaceFlags, int *compileFlags );
  
- void                                          BeginMapShaderFile( const char *mapFile );
- void                                          WriteMapShaderFile( void );
- shaderInfo_t                          *CustomShader( shaderInfo_t *si, char *find, char *replace );
- void                                          EmitVertexRemapShader( char *from, char *to );
+ void                        BeginMapShaderFile( const char *mapFile );
+ void                        WriteMapShaderFile( void );
+ shaderInfo_t                *CustomShader( shaderInfo_t *si, char *find, char *replace );
+ void                        EmitVertexRemapShader( char *from, char *to );
  
- void                                          LoadShaderInfo( void );
- shaderInfo_t                          *ShaderInfoForShader( const char *shader );
+ void                        LoadShaderInfo( void );
+ shaderInfo_t                *ShaderInfoForShader( const char *shader );
+ shaderInfo_t                *ShaderInfoForShaderNull( const char *shader );
  
  
  /* bspfile_abstract.c */
- void                                          SetGridPoints( int n );
- void                                          SetDrawVerts( int n );
- void                                          IncDrawVerts();
- void                                          SetDrawSurfaces(int n);
- void                                          SetDrawSurfacesBuffer();
- void                                          BSPFilesCleanup();
- void                                          SwapBlock( int *block, int size );
- int                                                   GetLumpElements( bspHeader_t *header, int lump, int size );
- void                                          *GetLump( bspHeader_t *header, int lump );
- int                                                   CopyLump( bspHeader_t *header, int lump, void *dest, int size );
- int                                                   CopyLump_Allocate( bspHeader_t *header, int lump, void **dest, int size, int *allocationVariable );
- void                                          AddLump( FILE *file, bspHeader_t *header, int lumpNum, const void *data, int length );
- void                                          LoadBSPFile( const char *filename );
- void                                          WriteBSPFile( const char *filename );
- void                                          PrintBSPFileSizes( void );
- epair_t                                               *ParseEPair( void );
- void                                          ParseEntities( void );
- void                                          UnparseEntities( void );
- void                                          PrintEntity( const entity_t *ent );
- void                                          SetKeyValue( entity_t *ent, const char *key, const char *value );
- qboolean                                      KeyExists( const entity_t *ent, const char *key ); /* VorteX: check if key exists */
- const char                                    *ValueForKey( const entity_t *ent, const char *key );
- int                                                   IntForKey( const entity_t *ent, const char *key );
- vec_t                                         FloatForKey( const entity_t *ent, const char *key );
- void                                          GetVectorForKey( const entity_t *ent, const char *key, vec3_t vec );
- entity_t                                      *FindTargetEntity( const char *target );
- void                                          GetEntityShadowFlags( const entity_t *ent, const entity_t *ent2, int *castShadows, int *recvShadows );
- void InjectCommandLine(char **argv, int beginArgs, int endArgs);
-               
+ void                        SetGridPoints( int n );
+ void                        SetDrawVerts( int n );
+ void                        IncDrawVerts();
+ void                        SetDrawSurfaces( int n );
+ void                        SetDrawSurfacesBuffer();
+ void                        BSPFilesCleanup();
+ void                        SwapBlock( int *block, int size );
+ int                         GetLumpElements( bspHeader_t *header, int lump, int size );
+ void                        *GetLump( bspHeader_t *header, int lump );
+ int                         CopyLump( bspHeader_t *header, int lump, void *dest, int size );
+ int                         CopyLump_Allocate( bspHeader_t *header, int lump, void **dest, int size, int *allocationVariable );
+ void                        AddLump( FILE *file, bspHeader_t *header, int lumpNum, const void *data, int length );
+ void                        LoadBSPFile( const char *filename );
+ void                        WriteBSPFile( const char *filename );
+ void                        PrintBSPFileSizes( void );
+ epair_t                     *ParseEPair( void );
+ void                        ParseEntities( void );
+ void                        UnparseEntities( void );
+ void                        PrintEntity( const entity_t *ent );
+ void                        SetKeyValue( entity_t *ent, const char *key, const char *value );
+ qboolean                    KeyExists( const entity_t *ent, const char *key ); /* VorteX: check if key exists */
+ const char                  *ValueForKey( const entity_t *ent, const char *key );
+ int                         IntForKey( const entity_t *ent, const char *key );
+ vec_t                       FloatForKey( const entity_t *ent, const char *key );
+ void                        GetVectorForKey( const entity_t *ent, const char *key, vec3_t vec );
+ entity_t                    *FindTargetEntity( const char *target );
+ void                        GetEntityShadowFlags( const entity_t *ent, const entity_t *ent2, int *castShadows, int *recvShadows );
+ void InjectCommandLine( char **argv, int beginArgs, int endArgs );
  
  
  /* bspfile_ibsp.c */
- void                                          LoadIBSPFile( const char *filename );
- void                                          WriteIBSPFile( const char *filename );
+ void                        LoadIBSPFile( const char *filename );
+ void                        WriteIBSPFile( const char *filename );
  
  
  /* bspfile_rbsp.c */
- void                                          LoadRBSPFile( const char *filename );
- void                                          WriteRBSPFile( const char *filename );
+ void                        LoadRBSPFile( const char *filename );
+ void                        WriteRBSPFile( const char *filename );
  
  
  
  /* -------------------------------------------------------------------------------
  
- bsp/general global variables
   bsp/general global variables
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
  #ifdef MAIN_C
        #define Q_EXTERN
-       #define Q_ASSIGN( a )   = a
+       #define Q_ASSIGN( a )   = a
  #else
        #define Q_EXTERN extern
-       #define Q_ASSIGN( a )   
+       #define Q_ASSIGN( a )
  #endif
  
  /* game support */
- Q_EXTERN game_t                               games[]
+ Q_EXTERN game_t games[]
  #ifndef MAIN_C
                                                      ;
+ ;
  #else
-                                                       =
-                                                       {
+       =
+       {
                                                                #include "game_quake3.h"
-                                                               ,
-                                                               #include "game_quakelive.h"/* most be after game_quake3.h as they share defines! */
-                                                               ,
-                                                               #include "game_nexuiz.h"/* most be after game_quake3.h as they share defines! */
-                                                               ,
-                                                               #include "game_xonotic.h"/* most be after game_quake3.h as they share defines! */
-                                                               ,
+       ,
+                                                               #include "game_quakelive.h" /* most be after game_quake3.h as they share defines! */
+       ,
+                                                               #include "game_nexuiz.h" /* most be after game_quake3.h as they share defines! */
+       ,
+                                                               #include "game_xonotic.h" /* most be after game_quake3.h as they share defines! */
+       ,
                                                                #include "game_tremulous.h" /*LinuxManMikeC: must be after game_quake3.h, depends on #define's set in it */
-                                                               ,
+       ,
                                                                #include "game_tenebrae.h"
-                                                               ,
+       ,
                                                                #include "game_wolf.h"
-                                                               ,
-                                                               #include "game_wolfet.h"/* most be after game_wolf.h as they share defines! */
-                                                               ,
+       ,
+                                                               #include "game_wolfet.h" /* most be after game_wolf.h as they share defines! */
+       ,
                                                                #include "game_etut.h"
-                                                               ,
+       ,
                                                                #include "game_ef.h"
-                                                               ,
+       ,
                                                                #include "game_sof2.h"
-                                                               ,
-                                                               #include "game_jk2.h"   /* most be after game_sof2.h as they share defines! */
-                                                               ,
-                                                               #include "game_ja.h"    /* most be after game_jk2.h as they share defines! */
-                                                               ,
-                                                               #include "game_qfusion.h"       /* qfusion game */
-                                                               ,
+       ,
+                                                               #include "game_jk2.h"   /* most be after game_sof2.h as they share defines! */
+       ,
+                                                               #include "game_ja.h"    /* most be after game_jk2.h as they share defines! */
+       ,
+                                                               #include "game_qfusion.h"   /* qfusion game */
+       ,
                                                                #include "game_reaction.h" /* must be after game_quake3.h */
-                                                               ,
-                                                               #include "game_darkplaces.h"    /* vortex: darkplaces q1 engine */
-                                                               ,
-                                                               #include "game_dq.h"    /* vortex: deluxe quake game ( darkplaces q1 engine) */
-                                                               ,
-                                                               #include "game_prophecy.h"      /* vortex: prophecy game ( darkplaces q1 engine) */
-                                                               ,
-                                                               #include "game__null.h" /* null game (must be last item) */
-                                                       };
+       ,
+                                                               #include "game_darkplaces.h"    /* vortex: darkplaces q1 engine */
+       ,
+                                                               #include "game_dq.h"    /* vortex: deluxe quake game ( darkplaces q1 engine) */
+       ,
+                                                               #include "game_prophecy.h"  /* vortex: prophecy game ( darkplaces q1 engine) */
+       ,
+                                                               #include "game__null.h" /* null game (must be last item) */
+       };
  #endif
- Q_EXTERN game_t                               *game Q_ASSIGN( &games[ 0 ] );
+ Q_EXTERN game_t             *game Q_ASSIGN( &games[ 0 ] );
  
  
  /* general */
- Q_EXTERN int                          numImages Q_ASSIGN( 0 );
- Q_EXTERN image_t                      images[ MAX_IMAGES ];
+ Q_EXTERN int numImages Q_ASSIGN( 0 );
+ Q_EXTERN image_t images[ MAX_IMAGES ];
  
- Q_EXTERN int                          numPicoModels Q_ASSIGN( 0 );
- Q_EXTERN picoModel_t          *picoModels[ MAX_MODELS ];
+ Q_EXTERN int numPicoModels Q_ASSIGN( 0 );
+ Q_EXTERN picoModel_t        *picoModels[ MAX_MODELS ];
  
- Q_EXTERN shaderInfo_t         *shaderInfo Q_ASSIGN( NULL );
- Q_EXTERN int                          numShaderInfo Q_ASSIGN( 0 );
- Q_EXTERN int                          numVertexRemaps Q_ASSIGN( 0 );
+ Q_EXTERN shaderInfo_t       *shaderInfo Q_ASSIGN( NULL );
+ Q_EXTERN int numShaderInfo Q_ASSIGN( 0 );
+ Q_EXTERN int numVertexRemaps Q_ASSIGN( 0 );
  
- Q_EXTERN surfaceParm_t                custSurfaceParms[ MAX_CUST_SURFACEPARMS ];
- Q_EXTERN int                          numCustSurfaceParms Q_ASSIGN( 0 );
+ Q_EXTERN surfaceParm_t custSurfaceParms[ MAX_CUST_SURFACEPARMS ];
+ Q_EXTERN int numCustSurfaceParms Q_ASSIGN( 0 );
  
- Q_EXTERN char                         mapName[ MAX_QPATH ];   /* ydnar: per-map custom shaders for larger lightmaps */
- Q_EXTERN char                         mapShaderFile[ 1024 ];
- Q_EXTERN qboolean                     warnImage Q_ASSIGN( qtrue );
+ Q_EXTERN char mapName[ MAX_QPATH ];                 /* ydnar: per-map custom shaders for larger lightmaps */
+ Q_EXTERN char mapShaderFile[ 1024 ];
+ Q_EXTERN qboolean warnImage Q_ASSIGN( qtrue );
  
  /* ydnar: sinusoid samples */
- Q_EXTERN float                                jitters[ MAX_JITTERS ];
+ Q_EXTERN float jitters[ MAX_JITTERS ];
  
  
  /* commandline arguments */
- Q_EXTERN qboolean                     verbose;
- Q_EXTERN qboolean                     verboseEntities Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     force Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     infoMode Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     useCustomInfoParms Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     noprune Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     leaktest Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     nodetail Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     nosubdivide Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     notjunc Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     fulldetail Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     nowater Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     noCurveBrushes Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     fakemap Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     coplanar Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     nofog Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     noHint Q_ASSIGN( qfalse );                              /* ydnar */
- Q_EXTERN qboolean                     renameModelShaders Q_ASSIGN( qfalse );  /* ydnar */
- Q_EXTERN qboolean                     skyFixHack Q_ASSIGN( qfalse );                  /* ydnar */
- Q_EXTERN qboolean                     bspAlternateSplitWeights Q_ASSIGN( qfalse );                    /* 27 */
- Q_EXTERN qboolean                     deepBSP Q_ASSIGN( qfalse );                     /* div0 */
- Q_EXTERN qboolean                     maxAreaFaceSurface Q_ASSIGN( qfalse );                  /* divVerent */
- Q_EXTERN int                          patchSubdivisions Q_ASSIGN( 8 );                /* ydnar: -patchmeta subdivisions */
- Q_EXTERN int                          maxLMSurfaceVerts Q_ASSIGN( 64 );               /* ydnar */
- Q_EXTERN int                          maxSurfaceVerts Q_ASSIGN( 999 );                /* ydnar */
- Q_EXTERN int                          maxSurfaceIndexes Q_ASSIGN( 6000 );             /* ydnar */
- Q_EXTERN float                                npDegrees Q_ASSIGN( 0.0f );                             /* ydnar: nonplanar degrees */
- Q_EXTERN int                          bevelSnap Q_ASSIGN( 0 );                                /* ydnar: bevel plane snap */
- Q_EXTERN int                          texRange Q_ASSIGN( 0 );
- Q_EXTERN qboolean                     flat Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     meta Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     patchMeta Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     emitFlares Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     debugSurfaces Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     debugInset Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     debugPortals Q_ASSIGN( qfalse );
- Q_EXTERN qboolean           lightmapTriangleCheck Q_ASSIGN(qfalse);
- Q_EXTERN qboolean           lightmapExtraVisClusterNudge Q_ASSIGN(qfalse);
- Q_EXTERN qboolean           lightmapFill Q_ASSIGN(qfalse);
- Q_EXTERN int                          metaAdequateScore Q_ASSIGN( -1 );
- Q_EXTERN int                          metaGoodScore Q_ASSIGN( -1 );
- Q_EXTERN float                                metaMaxBBoxDistance Q_ASSIGN( -1 );
+ Q_EXTERN qboolean verbose;
+ Q_EXTERN qboolean verboseEntities Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean force Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean infoMode Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean useCustomInfoParms Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean noprune Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean leaktest Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean nodetail Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean nosubdivide Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean notjunc Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean fulldetail Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean nowater Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean noCurveBrushes Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean fakemap Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean coplanar Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean nofog Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean noHint Q_ASSIGN( qfalse );                        /* ydnar */
+ Q_EXTERN qboolean renameModelShaders Q_ASSIGN( qfalse );            /* ydnar */
+ Q_EXTERN qboolean skyFixHack Q_ASSIGN( qfalse );                    /* ydnar */
+ Q_EXTERN qboolean bspAlternateSplitWeights Q_ASSIGN( qfalse );                      /* 27 */
+ Q_EXTERN qboolean deepBSP Q_ASSIGN( qfalse );                   /* div0 */
+ Q_EXTERN qboolean maxAreaFaceSurface Q_ASSIGN( qfalse );                    /* divVerent */
+ Q_EXTERN int patchSubdivisions Q_ASSIGN( 8 );                       /* ydnar: -patchmeta subdivisions */
+ Q_EXTERN int maxLMSurfaceVerts Q_ASSIGN( 64 );                      /* ydnar */
+ Q_EXTERN int maxSurfaceVerts Q_ASSIGN( 999 );                       /* ydnar */
+ Q_EXTERN int maxSurfaceIndexes Q_ASSIGN( 6000 );                    /* ydnar */
+ Q_EXTERN float npDegrees Q_ASSIGN( 0.0f );                          /* ydnar: nonplanar degrees */
+ Q_EXTERN int bevelSnap Q_ASSIGN( 0 );                               /* ydnar: bevel plane snap */
+ Q_EXTERN int texRange Q_ASSIGN( 0 );
+ Q_EXTERN qboolean flat Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean meta Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean patchMeta Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean emitFlares Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean debugSurfaces Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean debugInset Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean debugPortals Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean lightmapTriangleCheck Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean lightmapExtraVisClusterNudge Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean lightmapFill Q_ASSIGN( qfalse );
+ Q_EXTERN int metaAdequateScore Q_ASSIGN( -1 );
+ Q_EXTERN int metaGoodScore Q_ASSIGN( -1 );
+ Q_EXTERN float metaMaxBBoxDistance Q_ASSIGN( -1 );
  
  #if Q3MAP2_EXPERIMENTAL_SNAP_NORMAL_FIX
  // Increasing the normalEpsilon to compensate for new logic in SnapNormal(), where
  // components.  Unfortunately, normalEpsilon is also used in PlaneEqual().  So changing
  // this will affect anything that calls PlaneEqual() as well (which are, at the time
  // of this writing, FindFloatPlane() and AddBrushBevels()).
- Q_EXTERN double                               normalEpsilon Q_ASSIGN(0.00005);
+ Q_EXTERN double normalEpsilon Q_ASSIGN( 0.00005 );
  #else
- Q_EXTERN double                               normalEpsilon Q_ASSIGN( 0.00001 );
+ Q_EXTERN double normalEpsilon Q_ASSIGN( 0.00001 );
  #endif
  
  #if Q3MAP2_EXPERIMENTAL_HIGH_PRECISION_MATH_FIXES
  // opinion.  The real fix for this problem is to have 64 bit distances and then make
  // this epsilon even smaller, or to constrain world coordinates to plus minus 2^15
  // (or even 2^14).
- Q_EXTERN double                               distanceEpsilon Q_ASSIGN(0.005);
+ Q_EXTERN double distanceEpsilon Q_ASSIGN( 0.005 );
  #else
- Q_EXTERN double                               distanceEpsilon Q_ASSIGN( 0.01 );
+ Q_EXTERN double distanceEpsilon Q_ASSIGN( 0.01 );
  #endif
  
  
  /* bsp */
- Q_EXTERN int                          numMapEntities Q_ASSIGN( 0 );
+ Q_EXTERN int numMapEntities Q_ASSIGN( 0 );
  
- Q_EXTERN int                          blockSize[ 3 ]                                  /* should be the same as in radiant */
+ Q_EXTERN int blockSize[ 3 ]                                 /* should be the same as in radiant */
  #ifndef MAIN_C
                                                      ;
+ ;
  #else
-                                                       = { 1024, 1024, 1024 };
+       = { 1024, 1024, 1024 };
  #endif
  
- Q_EXTERN char                         name[ 1024 ];
- Q_EXTERN char                         source[ 1024 ];
- Q_EXTERN char                         outbase[ 32 ];
+ Q_EXTERN char name[ 1024 ];
+ Q_EXTERN char source[ 1024 ];
+ Q_EXTERN char outbase[ 32 ];
  
- Q_EXTERN int                          sampleSize;                                             /* lightmap sample size in units */
- Q_EXTERN int                          minSampleSize;                  /* minimum sample size to use at all */
- Q_EXTERN int                          sampleScale;                                    /* vortex: lightmap sample scale (ie quality)*/
+ Q_EXTERN int sampleSize;                                    /* lightmap sample size in units */
+ Q_EXTERN int minSampleSize;                                 /* minimum sample size to use at all */
+ Q_EXTERN int sampleScale;                                   /* vortex: lightmap sample scale (ie quality)*/
  
- Q_EXTERN int                          mapEntityNum Q_ASSIGN( 0 );
+ Q_EXTERN int mapEntityNum Q_ASSIGN( 0 );
  
- Q_EXTERN int                          entitySourceBrushes;
+ Q_EXTERN int entitySourceBrushes;
  
- Q_EXTERN plane_t                      *mapplanes Q_ASSIGN(NULL);      /* mapplanes[ num ^ 1 ] will always be the mirror or mapplanes[ num ] */
- Q_EXTERN int                          nummapplanes Q_ASSIGN(0);               /* nummapplanes will always be even */
- Q_EXTERN int                          allocatedmapplanes Q_ASSIGN(0);
- Q_EXTERN int                          numMapPatches;
- Q_EXTERN vec3_t                               mapMins, mapMaxs;
+ Q_EXTERN plane_t            *mapplanes Q_ASSIGN( NULL );  /* mapplanes[ num ^ 1 ] will always be the mirror or mapplanes[ num ] */
+ Q_EXTERN int nummapplanes Q_ASSIGN( 0 );                    /* nummapplanes will always be even */
+ Q_EXTERN int allocatedmapplanes Q_ASSIGN( 0 );
+ Q_EXTERN int numMapPatches;
+ Q_EXTERN vec3_t mapMins, mapMaxs;
  
- Q_EXTERN int                          defaultFogNum Q_ASSIGN( -1 );   /* ydnar: cleaner fog handling */
- Q_EXTERN int                          numMapFogs Q_ASSIGN( 0 );
- Q_EXTERN fog_t                                mapFogs[ MAX_MAP_FOGS ];
+ Q_EXTERN int defaultFogNum Q_ASSIGN( -1 );                  /* ydnar: cleaner fog handling */
+ Q_EXTERN int numMapFogs Q_ASSIGN( 0 );
+ Q_EXTERN fog_t mapFogs[ MAX_MAP_FOGS ];
  
- Q_EXTERN entity_t                     *mapEnt;
- Q_EXTERN brush_t                      *buildBrush;
- Q_EXTERN int                          numActiveBrushes;
- Q_EXTERN int                          g_bBrushPrimit;
+ Q_EXTERN entity_t           *mapEnt;
+ Q_EXTERN brush_t            *buildBrush;
+ Q_EXTERN int numActiveBrushes;
+ Q_EXTERN int g_bBrushPrimit;
  
- Q_EXTERN int                          numStrippedLights Q_ASSIGN( 0 );
+ Q_EXTERN int numStrippedLights Q_ASSIGN( 0 );
  
  
  /* surface stuff */
- Q_EXTERN mapDrawSurface_t     *mapDrawSurfs Q_ASSIGN( NULL );
- Q_EXTERN int                          numMapDrawSurfs;
+ Q_EXTERN mapDrawSurface_t   *mapDrawSurfs Q_ASSIGN( NULL );
+ Q_EXTERN int numMapDrawSurfs;
  
- Q_EXTERN int                          numSurfacesByType[ NUM_SURFACE_TYPES ];
- Q_EXTERN int                          numClearedSurfaces;
- Q_EXTERN int                          numStripSurfaces;
- Q_EXTERN int                          numMaxAreaSurfaces;
- Q_EXTERN int                          numFanSurfaces;
- Q_EXTERN int                          numMergedSurfaces;
- Q_EXTERN int                          numMergedVerts;
+ Q_EXTERN int numSurfacesByType[ NUM_SURFACE_TYPES ];
+ Q_EXTERN int numClearedSurfaces;
+ Q_EXTERN int numStripSurfaces;
+ Q_EXTERN int numMaxAreaSurfaces;
+ Q_EXTERN int numFanSurfaces;
+ Q_EXTERN int numMergedSurfaces;
+ Q_EXTERN int numMergedVerts;
  
- Q_EXTERN int                          numRedundantIndexes;
+ Q_EXTERN int numRedundantIndexes;
  
- Q_EXTERN int                          numSurfaceModels Q_ASSIGN( 0 );
+ Q_EXTERN int numSurfaceModels Q_ASSIGN( 0 );
  
- Q_EXTERN byte                         debugColors[ 12 ][ 3 ]
+ Q_EXTERN byte debugColors[ 12 ][ 3 ]
  #ifndef MAIN_C
                                                      ;
+ ;
  #else
-                                                       =
-                                                       {
-                                                               { 255, 0, 0 },
-                                                               { 192, 128, 128 },
-                                                               { 255, 255, 0 },
-                                                               { 192, 192, 128 },
-                                                               { 0, 255, 255 },
-                                                               { 128, 192, 192 },
-                                                               { 0, 0, 255 },
-                                                               { 128, 128, 192 },
-                                                               { 255, 0, 255 },
-                                                               { 192, 128, 192 },
-                                                               { 0, 255, 0 },
-                                                               { 128, 192, 128 }
-                                                       };
+       =
+       {
+       { 255, 0, 0 },
+       { 192, 128, 128 },
+       { 255, 255, 0 },
+       { 192, 192, 128 },
+       { 0, 255, 255 },
+       { 128, 192, 192 },
+       { 0, 0, 255 },
+       { 128, 128, 192 },
+       { 255, 0, 255 },
+       { 192, 128, 192 },
+       { 0, 255, 0 },
+       { 128, 192, 128 }
+       };
  #endif
  
- Q_EXTERN qboolean                     skyboxPresent Q_ASSIGN( qfalse );
- Q_EXTERN int                          skyboxArea Q_ASSIGN( -1 );
- Q_EXTERN m4x4_t                               skyboxTransform;
+ Q_EXTERN qboolean skyboxPresent Q_ASSIGN( qfalse );
+ Q_EXTERN int skyboxArea Q_ASSIGN( -1 );
+ Q_EXTERN m4x4_t skyboxTransform;
  
  
  
  /* -------------------------------------------------------------------------------
  
- vis global variables
   vis global variables
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
  /* commandline arguments */
- Q_EXTERN qboolean                     fastvis;
- Q_EXTERN qboolean                     noPassageVis;
- Q_EXTERN qboolean                     passageVisOnly;
- Q_EXTERN qboolean                     mergevis;
- Q_EXTERN qboolean                     mergevisportals;
- Q_EXTERN qboolean                     nosort;
- Q_EXTERN qboolean                     saveprt;
- Q_EXTERN qboolean                     hint;   /* ydnar */
- Q_EXTERN char                         inbase[ MAX_QPATH ];
- Q_EXTERN char                         globalCelShader[ MAX_QPATH ];
+ Q_EXTERN qboolean fastvis;
+ Q_EXTERN qboolean noPassageVis;
+ Q_EXTERN qboolean passageVisOnly;
+ Q_EXTERN qboolean mergevis;
+ Q_EXTERN qboolean mergevisportals;
+ Q_EXTERN qboolean nosort;
+ Q_EXTERN qboolean saveprt;
+ Q_EXTERN qboolean hint;             /* ydnar */
+ Q_EXTERN char inbase[ MAX_QPATH ];
+ Q_EXTERN char globalCelShader[ MAX_QPATH ];
  
- Q_EXTERN float                                farPlaneDist;   /* rr2do2, rf, mre, ydnar all contributed to this one... */
+ Q_EXTERN float farPlaneDist;                /* rr2do2, rf, mre, ydnar all contributed to this one... */
  
- Q_EXTERN int                          numportals;
- Q_EXTERN int                          portalclusters;
+ Q_EXTERN int numportals;
+ Q_EXTERN int portalclusters;
  
- Q_EXTERN vportal_t                    *portals;
- Q_EXTERN leaf_t                               *leafs;
+ Q_EXTERN vportal_t          *portals;
+ Q_EXTERN leaf_t             *leafs;
  
- Q_EXTERN vportal_t                    *faces;
- Q_EXTERN leaf_t                               *faceleafs;
+ Q_EXTERN vportal_t          *faces;
+ Q_EXTERN leaf_t             *faceleafs;
  
- Q_EXTERN int                          numfaces;
+ Q_EXTERN int numfaces;
  
- Q_EXTERN int                          c_portaltest, c_portalpass, c_portalcheck;
- Q_EXTERN int                          c_portalskip, c_leafskip;
- Q_EXTERN int                          c_vistest, c_mighttest;
- Q_EXTERN int                          c_chains;
+ Q_EXTERN int c_portaltest, c_portalpass, c_portalcheck;
+ Q_EXTERN int c_portalskip, c_leafskip;
+ Q_EXTERN int c_vistest, c_mighttest;
+ Q_EXTERN int c_chains;
  
- Q_EXTERN byte                         *vismap, *vismap_p, *vismap_end;
+ Q_EXTERN byte               *vismap, *vismap_p, *vismap_end;
  
- Q_EXTERN int                          testlevel;
+ Q_EXTERN int testlevel;
  
- Q_EXTERN byte                         *uncompressed;
+ Q_EXTERN byte               *uncompressed;
  
- Q_EXTERN int                          leafbytes, leaflongs;
- Q_EXTERN int                          portalbytes, portallongs;
+ Q_EXTERN int leafbytes, leaflongs;
+ Q_EXTERN int portalbytes, portallongs;
  
- Q_EXTERN vportal_t                    *sorted_portals[ MAX_MAP_PORTALS * 2 ];
+ Q_EXTERN vportal_t          *sorted_portals[ MAX_MAP_PORTALS * 2 ];
  
  
  
  /* -------------------------------------------------------------------------------
  
- light global variables
   light global variables
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
  /* commandline arguments */
- Q_EXTERN qboolean                     wolfLight Q_ASSIGN( qfalse );
- Q_EXTERN float                                extraDist Q_ASSIGN( 0.0f );
- Q_EXTERN qboolean                     loMem Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     noStyles Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     keepLights Q_ASSIGN( qfalse );
- Q_EXTERN int                          sampleSize Q_ASSIGN( DEFAULT_LIGHTMAP_SAMPLE_SIZE );
- Q_EXTERN int                          minSampleSize Q_ASSIGN( DEFAULT_LIGHTMAP_MIN_SAMPLE_SIZE );
- Q_EXTERN qboolean                     noVertexLighting Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     noGridLighting Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     noTrace Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     noSurfaces Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     patchShadows Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     cpmaHack Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     deluxemap Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     debugDeluxemap Q_ASSIGN( qfalse );
- Q_EXTERN int                          deluxemode Q_ASSIGN( 0 );       /* deluxemap format (0 - modelspace, 1 - tangentspace with renormalization, 2 - tangentspace without renormalization) */
- Q_EXTERN qboolean                     fast Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     faster Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     fastgrid Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     fastbounce Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     cheap Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     cheapgrid Q_ASSIGN( qfalse );
- Q_EXTERN int                          bounce Q_ASSIGN( 0 );
- Q_EXTERN qboolean                     bounceOnly Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     bouncing Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     bouncegrid Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     normalmap Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     trisoup Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     shade Q_ASSIGN( qfalse );
- Q_EXTERN float                                shadeAngleDegrees Q_ASSIGN( 0.0f );
- Q_EXTERN int                          superSample Q_ASSIGN( 0 );
- Q_EXTERN int                          lightSamples Q_ASSIGN( 1 );
- Q_EXTERN qboolean                     lightRandomSamples Q_ASSIGN( qfalse );
- Q_EXTERN int                          lightSamplesSearchBoxSize Q_ASSIGN( 1 );
- Q_EXTERN qboolean                     filter Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     dark Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     sunOnly Q_ASSIGN( qfalse );
- Q_EXTERN int                          approximateTolerance Q_ASSIGN( 0 );
- Q_EXTERN qboolean                     noCollapse Q_ASSIGN( qfalse );
- Q_EXTERN int                          lightmapSearchBlockSize Q_ASSIGN( 0 );
- Q_EXTERN qboolean                     exportLightmaps Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     externalLightmaps Q_ASSIGN( qfalse );
- Q_EXTERN int                          lmCustomSize Q_ASSIGN( LIGHTMAP_WIDTH );
- Q_EXTERN char *                               lmCustomDir Q_ASSIGN( NULL );
- Q_EXTERN int                          lmLimitSize Q_ASSIGN( 0 );
- Q_EXTERN qboolean                     dirty Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     dirtDebug Q_ASSIGN( qfalse );
- Q_EXTERN int                          dirtMode Q_ASSIGN( 0 );
- Q_EXTERN float                                dirtDepth Q_ASSIGN( 128.0f );
- Q_EXTERN float                                dirtScale Q_ASSIGN( 1.0f );
- Q_EXTERN float                                dirtGain Q_ASSIGN( 1.0f );
+ Q_EXTERN qboolean wolfLight Q_ASSIGN( qfalse );
+ Q_EXTERN float extraDist Q_ASSIGN( 0.0f );
+ Q_EXTERN qboolean loMem Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean noStyles Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean keepLights Q_ASSIGN( qfalse );
+ Q_EXTERN int sampleSize Q_ASSIGN( DEFAULT_LIGHTMAP_SAMPLE_SIZE );
+ Q_EXTERN int minSampleSize Q_ASSIGN( DEFAULT_LIGHTMAP_MIN_SAMPLE_SIZE );
+ Q_EXTERN qboolean noVertexLighting Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean noGridLighting Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean noTrace Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean noSurfaces Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean patchShadows Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean cpmaHack Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean deluxemap Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean debugDeluxemap Q_ASSIGN( qfalse );
+ Q_EXTERN int deluxemode Q_ASSIGN( 0 );                  /* deluxemap format (0 - modelspace, 1 - tangentspace with renormalization, 2 - tangentspace without renormalization) */
+ Q_EXTERN qboolean fast Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean fastpoint Q_ASSIGN( qtrue );
+ Q_EXTERN qboolean faster Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean fastgrid Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean fastbounce Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean cheap Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean cheapgrid Q_ASSIGN( qfalse );
+ Q_EXTERN int bounce Q_ASSIGN( 0 );
+ Q_EXTERN qboolean bounceOnly Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean bouncing Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean bouncegrid Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean normalmap Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean trisoup Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean shade Q_ASSIGN( qfalse );
+ Q_EXTERN float shadeAngleDegrees Q_ASSIGN( 0.0f );
+ Q_EXTERN int superSample Q_ASSIGN( 0 );
+ Q_EXTERN int lightSamples Q_ASSIGN( 1 );
+ Q_EXTERN qboolean lightRandomSamples Q_ASSIGN( qfalse );
+ Q_EXTERN int lightSamplesSearchBoxSize Q_ASSIGN( 1 );
+ Q_EXTERN qboolean filter Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean dark Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean sunOnly Q_ASSIGN( qfalse );
+ Q_EXTERN int approximateTolerance Q_ASSIGN( 0 );
+ Q_EXTERN qboolean noCollapse Q_ASSIGN( qfalse );
+ Q_EXTERN int lightmapSearchBlockSize Q_ASSIGN( 0 );
+ Q_EXTERN qboolean exportLightmaps Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean externalLightmaps Q_ASSIGN( qfalse );
+ Q_EXTERN int lmCustomSize Q_ASSIGN( LIGHTMAP_WIDTH );
+ Q_EXTERN char *             lmCustomDir Q_ASSIGN( NULL );
+ Q_EXTERN int lmLimitSize Q_ASSIGN( 0 );
+ Q_EXTERN qboolean dirty Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean dirtDebug Q_ASSIGN( qfalse );
+ Q_EXTERN int dirtMode Q_ASSIGN( 0 );
+ Q_EXTERN float dirtDepth Q_ASSIGN( 128.0f );
+ Q_EXTERN float dirtScale Q_ASSIGN( 1.0f );
+ Q_EXTERN float dirtGain Q_ASSIGN( 1.0f );
  
  /* 27: floodlighting */
- Q_EXTERN qboolean                                     debugnormals Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                                     floodlighty Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                                     floodlight_lowquality Q_ASSIGN( qfalse );
- Q_EXTERN vec3_t                                               floodlightRGB;
- Q_EXTERN float                                                floodlightIntensity Q_ASSIGN( 512.0f );
- Q_EXTERN float                                                floodlightDistance Q_ASSIGN( 1024.0f );
- Q_EXTERN float                                                floodlightDirectionScale Q_ASSIGN( 1.0f );
- Q_EXTERN qboolean                     dump Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     debug Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     debugUnused Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     debugAxis Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     debugCluster Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     debugOrigin Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     lightmapBorder Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean debugnormals Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean floodlighty Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean floodlight_lowquality Q_ASSIGN( qfalse );
+ Q_EXTERN vec3_t floodlightRGB;
+ Q_EXTERN float floodlightIntensity Q_ASSIGN( 512.0f );
+ Q_EXTERN float floodlightDistance Q_ASSIGN( 1024.0f );
+ Q_EXTERN float floodlightDirectionScale Q_ASSIGN( 1.0f );
+ Q_EXTERN qboolean dump Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean debug Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean debugUnused Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean debugAxis Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean debugCluster Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean debugOrigin Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean lightmapBorder Q_ASSIGN( qfalse );
  
  /* longest distance across the map */
- Q_EXTERN float                                maxMapDistance Q_ASSIGN( 0 );
+ Q_EXTERN float maxMapDistance Q_ASSIGN( 0 );
  
  /* for run time tweaking of light sources */
- Q_EXTERN float                                pointScale Q_ASSIGN( 7500.0f );
- Q_EXTERN float                                spotScale Q_ASSIGN( 7500.0f );
- Q_EXTERN float                                areaScale Q_ASSIGN( 0.25f );
- Q_EXTERN float                                skyScale Q_ASSIGN( 1.0f );
- Q_EXTERN float                                bounceScale Q_ASSIGN( 0.25f );
+ Q_EXTERN float pointScale Q_ASSIGN( 7500.0f );
+ Q_EXTERN float spotScale Q_ASSIGN( 7500.0f );
+ Q_EXTERN float areaScale Q_ASSIGN( 0.25f );
+ Q_EXTERN float skyScale Q_ASSIGN( 1.0f );
+ Q_EXTERN float bounceScale Q_ASSIGN( 0.25f );
  
  /* jal: alternative angle attenuation curve */
- Q_EXTERN qboolean                     lightAngleHL Q_ASSIGN( qfalse );
-  
+ Q_EXTERN qboolean lightAngleHL Q_ASSIGN( qfalse );
  /* vortex: gridscale and gridambientscale */
- Q_EXTERN float                                gridScale Q_ASSIGN( 1.0f );
- Q_EXTERN float                                gridAmbientScale Q_ASSIGN( 1.0f );
- Q_EXTERN float                                gridDirectionality Q_ASSIGN( 1.0f );
- Q_EXTERN float                                gridAmbientDirectionality Q_ASSIGN( 0.0f );
- Q_EXTERN qboolean                     inGrid Q_ASSIGN(0);
+ Q_EXTERN float gridScale Q_ASSIGN( 1.0f );
+ Q_EXTERN float gridAmbientScale Q_ASSIGN( 1.0f );
+ Q_EXTERN float gridDirectionality Q_ASSIGN( 1.0f );
+ Q_EXTERN float gridAmbientDirectionality Q_ASSIGN( 0.0f );
+ Q_EXTERN qboolean inGrid Q_ASSIGN( 0 );
  
  /* ydnar: lightmap gamma/compensation */
- Q_EXTERN float                                lightmapGamma Q_ASSIGN( 1.0f );
- Q_EXTERN float                                lightmapsRGB Q_ASSIGN( qfalse );
- Q_EXTERN float                                texturesRGB Q_ASSIGN( qfalse );
- Q_EXTERN float                                lightmapExposure Q_ASSIGN( 1.0f );
- Q_EXTERN float                                lightmapCompensate Q_ASSIGN( 1.0f );
+ Q_EXTERN float lightmapGamma Q_ASSIGN( 1.0f );
+ Q_EXTERN float lightmapsRGB Q_ASSIGN( qfalse );
+ Q_EXTERN float texturesRGB Q_ASSIGN( qfalse );
+ Q_EXTERN float colorsRGB Q_ASSIGN( qfalse );
+ Q_EXTERN float lightmapExposure Q_ASSIGN( 0.0f );
+ Q_EXTERN float lightmapCompensate Q_ASSIGN( 1.0f );
  
  /* ydnar: for runtime tweaking of falloff tolerance */
- Q_EXTERN float                                falloffTolerance Q_ASSIGN( 1.0f );
- Q_EXTERN qboolean                     exactPointToPolygon Q_ASSIGN( qtrue );
- Q_EXTERN float                                formFactorValueScale Q_ASSIGN( 3.0f );
- Q_EXTERN float                                linearScale Q_ASSIGN( 1.0f / 8000.0f );
+ Q_EXTERN float falloffTolerance Q_ASSIGN( 1.0f );
+ Q_EXTERN qboolean exactPointToPolygon Q_ASSIGN( qtrue );
+ Q_EXTERN float formFactorValueScale Q_ASSIGN( 3.0f );
+ Q_EXTERN float linearScale Q_ASSIGN( 1.0f / 8000.0f );
  
  // for .ase conversion
- Q_EXTERN qboolean                     shadersAsBitmap Q_ASSIGN( qfalse );
- Q_EXTERN qboolean                     lightmapsAsTexcoord Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean shadersAsBitmap Q_ASSIGN( qfalse );
+ Q_EXTERN qboolean lightmapsAsTexcoord Q_ASSIGN( qfalse );
  
- Q_EXTERN light_t                      *lights;
- Q_EXTERN int                          numPointLights;
- Q_EXTERN int                          numSpotLights;
- Q_EXTERN int                          numSunLights;
- Q_EXTERN int                          numAreaLights;
+ Q_EXTERN light_t            *lights;
+ Q_EXTERN int numPointLights;
+ Q_EXTERN int numSpotLights;
+ Q_EXTERN int numSunLights;
+ Q_EXTERN int numAreaLights;
  
  /* ydnar: for luxel placement */
- Q_EXTERN int                          numSurfaceClusters, maxSurfaceClusters;
- Q_EXTERN int                          *surfaceClusters;
+ Q_EXTERN int numSurfaceClusters, maxSurfaceClusters;
+ Q_EXTERN int                *surfaceClusters;
  
  /* ydnar: for radiosity */
- Q_EXTERN int                          numDiffuseLights;
- Q_EXTERN int                          numBrushDiffuseLights;
- Q_EXTERN int                          numTriangleDiffuseLights;
- Q_EXTERN int                          numPatchDiffuseLights;
+ Q_EXTERN int numDiffuseLights;
+ Q_EXTERN int numBrushDiffuseLights;
+ Q_EXTERN int numTriangleDiffuseLights;
+ Q_EXTERN int numPatchDiffuseLights;
  
  /* ydnar: general purpose extra copy of drawvert list */
- Q_EXTERN bspDrawVert_t                *yDrawVerts;
+ Q_EXTERN bspDrawVert_t      *yDrawVerts;
  
  /* ydnar: for tracing statistics */
- Q_EXTERN int                          minSurfacesTested;
- Q_EXTERN int                          maxSurfacesTested;
- Q_EXTERN int                          totalSurfacesTested;
- Q_EXTERN int                          totalTraces;
+ Q_EXTERN int minSurfacesTested;
+ Q_EXTERN int maxSurfacesTested;
+ Q_EXTERN int totalSurfacesTested;
+ Q_EXTERN int totalTraces;
  
- Q_EXTERN FILE                         *dumpFile;
+ Q_EXTERN FILE               *dumpFile;
  
- Q_EXTERN int                          c_visible, c_occluded;
- Q_EXTERN int                          c_subsampled;   /* ydnar */
+ Q_EXTERN int c_visible, c_occluded;
+ Q_EXTERN int c_subsampled;                  /* ydnar */
  
- Q_EXTERN int                          defaultLightSubdivide Q_ASSIGN( 999 );
+ Q_EXTERN int defaultLightSubdivide Q_ASSIGN( 999 );
  
- Q_EXTERN vec3_t                               ambientColor;
- Q_EXTERN vec3_t                               minLight, minVertexLight, minGridLight;
+ Q_EXTERN vec3_t ambientColor;
+ Q_EXTERN vec3_t minLight, minVertexLight, minGridLight;
  
- Q_EXTERN int                          *entitySurface;
- Q_EXTERN vec3_t                               *surfaceOrigin;
+ Q_EXTERN int                *entitySurface;
+ Q_EXTERN vec3_t             *surfaceOrigin;
  
- Q_EXTERN vec3_t                               sunDirection;
- Q_EXTERN vec3_t                               sunLight;
+ Q_EXTERN vec3_t sunDirection;
+ Q_EXTERN vec3_t sunLight;
  
  /* tracing */
- Q_EXTERN int                          c_totalTrace;
- Q_EXTERN int                          c_cullTrace, c_testTrace;
- Q_EXTERN int                          c_testFacets;
+ Q_EXTERN int c_totalTrace;
+ Q_EXTERN int c_cullTrace, c_testTrace;
+ Q_EXTERN int c_testFacets;
  
  /* ydnar: light optimization */
- Q_EXTERN float                                subdivideThreshold Q_ASSIGN( DEFAULT_SUBDIVIDE_THRESHOLD );
+ Q_EXTERN float subdivideThreshold Q_ASSIGN( DEFAULT_SUBDIVIDE_THRESHOLD );
  
- Q_EXTERN int                          numOpaqueBrushes, maxOpaqueBrush;
- Q_EXTERN byte                         *opaqueBrushes;
+ Q_EXTERN int numOpaqueBrushes, maxOpaqueBrush;
+ Q_EXTERN byte               *opaqueBrushes;
  
- Q_EXTERN int                          numLights;
- Q_EXTERN int                          numCulledLights;
+ Q_EXTERN int numLights;
+ Q_EXTERN int numCulledLights;
  
- Q_EXTERN int                          gridBoundsCulled;
- Q_EXTERN int                          gridEnvelopeCulled;
+ Q_EXTERN int gridBoundsCulled;
+ Q_EXTERN int gridEnvelopeCulled;
  
- Q_EXTERN int                          lightsBoundsCulled;
- Q_EXTERN int                          lightsEnvelopeCulled;
- Q_EXTERN int                          lightsPlaneCulled;
- Q_EXTERN int                          lightsClusterCulled;
+ Q_EXTERN int lightsBoundsCulled;
+ Q_EXTERN int lightsEnvelopeCulled;
+ Q_EXTERN int lightsPlaneCulled;
+ Q_EXTERN int lightsClusterCulled;
  
  /* ydnar: radiosity */
- Q_EXTERN float                                diffuseSubdivide Q_ASSIGN( 256.0f );
- Q_EXTERN float                                minDiffuseSubdivide Q_ASSIGN( 64.0f );
- Q_EXTERN int                          numDiffuseSurfaces Q_ASSIGN( 0 );
+ Q_EXTERN float diffuseSubdivide Q_ASSIGN( 256.0f );
+ Q_EXTERN float minDiffuseSubdivide Q_ASSIGN( 64.0f );
+ Q_EXTERN int numDiffuseSurfaces Q_ASSIGN( 0 );
  
  /* ydnar: list of surface information necessary for lightmap calculation */
- Q_EXTERN surfaceInfo_t                *surfaceInfos Q_ASSIGN( NULL );
+ Q_EXTERN surfaceInfo_t      *surfaceInfos Q_ASSIGN( NULL );
  
  /* ydnar: sorted list of surfaces */
- Q_EXTERN int                          *sortSurfaces Q_ASSIGN( NULL );
+ Q_EXTERN int                *sortSurfaces Q_ASSIGN( NULL );
  
  /* clumps of surfaces that share a raw lightmap */
- Q_EXTERN int                          numLightSurfaces Q_ASSIGN( 0 );
- Q_EXTERN int                          *lightSurfaces Q_ASSIGN( NULL );
+ Q_EXTERN int numLightSurfaces Q_ASSIGN( 0 );
+ Q_EXTERN int                *lightSurfaces Q_ASSIGN( NULL );
  
  /* raw lightmaps */
- Q_EXTERN int                          numRawSuperLuxels Q_ASSIGN( 0 );
- Q_EXTERN int                          numRawLightmaps Q_ASSIGN( 0 );
- Q_EXTERN rawLightmap_t                *rawLightmaps Q_ASSIGN( NULL );
- Q_EXTERN int                          *sortLightmaps Q_ASSIGN( NULL );
+ Q_EXTERN int numRawSuperLuxels Q_ASSIGN( 0 );
+ Q_EXTERN int numRawLightmaps Q_ASSIGN( 0 );
+ Q_EXTERN rawLightmap_t      *rawLightmaps Q_ASSIGN( NULL );
+ Q_EXTERN int                *sortLightmaps Q_ASSIGN( NULL );
  
  /* vertex luxels */
- Q_EXTERN float                                *vertexLuxels[ MAX_LIGHTMAPS ];
- Q_EXTERN float                                *radVertexLuxels[ MAX_LIGHTMAPS ];
+ Q_EXTERN float              *vertexLuxels[ MAX_LIGHTMAPS ];
+ Q_EXTERN float              *radVertexLuxels[ MAX_LIGHTMAPS ];
  
  /* bsp lightmaps */
- Q_EXTERN int                          numLightmapShaders Q_ASSIGN( 0 );
- Q_EXTERN int                          numSolidLightmaps Q_ASSIGN( 0 );
- Q_EXTERN int                          numOutLightmaps Q_ASSIGN( 0 );
- Q_EXTERN int                          numBSPLightmaps Q_ASSIGN( 0 );
- Q_EXTERN int                          numExtLightmaps Q_ASSIGN( 0 );
- Q_EXTERN outLightmap_t                *outLightmaps Q_ASSIGN( NULL );
+ Q_EXTERN int numLightmapShaders Q_ASSIGN( 0 );
+ Q_EXTERN int numSolidLightmaps Q_ASSIGN( 0 );
+ Q_EXTERN int numOutLightmaps Q_ASSIGN( 0 );
+ Q_EXTERN int numBSPLightmaps Q_ASSIGN( 0 );
+ Q_EXTERN int numExtLightmaps Q_ASSIGN( 0 );
+ Q_EXTERN outLightmap_t      *outLightmaps Q_ASSIGN( NULL );
  
  /* vortex: per surface floodlight statictics */
- Q_EXTERN int                          numSurfacesFloodlighten Q_ASSIGN( 0 );
+ Q_EXTERN int numSurfacesFloodlighten Q_ASSIGN( 0 );
  
  /* grid points */
- Q_EXTERN int                          numRawGridPoints Q_ASSIGN( 0 );
- Q_EXTERN rawGridPoint_t               *rawGridPoints Q_ASSIGN( NULL );
- Q_EXTERN int                          numSurfsVertexLit Q_ASSIGN( 0 );
- Q_EXTERN int                          numSurfsVertexForced Q_ASSIGN( 0 );
- Q_EXTERN int                          numSurfsVertexApproximated Q_ASSIGN( 0 );
- Q_EXTERN int                          numSurfsLightmapped Q_ASSIGN( 0 );
- Q_EXTERN int                          numPlanarsLightmapped Q_ASSIGN( 0 );
- Q_EXTERN int                          numNonPlanarsLightmapped Q_ASSIGN( 0 );
- Q_EXTERN int                          numPatchesLightmapped Q_ASSIGN( 0 );
- Q_EXTERN int                          numPlanarPatchesLightmapped Q_ASSIGN( 0 );
- Q_EXTERN int                          numLuxels Q_ASSIGN( 0 );
- Q_EXTERN int                          numLuxelsMapped Q_ASSIGN( 0 );
- Q_EXTERN int                          numLuxelsOccluded Q_ASSIGN( 0 );
- Q_EXTERN int                          numLuxelsIlluminated Q_ASSIGN( 0 );
- Q_EXTERN int                          numVertsIlluminated Q_ASSIGN( 0 );
+ Q_EXTERN int numRawGridPoints Q_ASSIGN( 0 );
+ Q_EXTERN rawGridPoint_t     *rawGridPoints Q_ASSIGN( NULL );
+ Q_EXTERN int numSurfsVertexLit Q_ASSIGN( 0 );
+ Q_EXTERN int numSurfsVertexForced Q_ASSIGN( 0 );
+ Q_EXTERN int numSurfsVertexApproximated Q_ASSIGN( 0 );
+ Q_EXTERN int numSurfsLightmapped Q_ASSIGN( 0 );
+ Q_EXTERN int numPlanarsLightmapped Q_ASSIGN( 0 );
+ Q_EXTERN int numNonPlanarsLightmapped Q_ASSIGN( 0 );
+ Q_EXTERN int numPatchesLightmapped Q_ASSIGN( 0 );
+ Q_EXTERN int numPlanarPatchesLightmapped Q_ASSIGN( 0 );
+ Q_EXTERN int numLuxels Q_ASSIGN( 0 );
+ Q_EXTERN int numLuxelsMapped Q_ASSIGN( 0 );
+ Q_EXTERN int numLuxelsOccluded Q_ASSIGN( 0 );
+ Q_EXTERN int numLuxelsIlluminated Q_ASSIGN( 0 );
+ Q_EXTERN int numVertsIlluminated Q_ASSIGN( 0 );
  
  /* lightgrid */
- Q_EXTERN vec3_t                               gridMins;
- Q_EXTERN int                          gridBounds[ 3 ];
- Q_EXTERN vec3_t                               gridSize
+ Q_EXTERN vec3_t gridMins;
+ Q_EXTERN int gridBounds[ 3 ];
+ Q_EXTERN vec3_t gridSize
  #ifndef MAIN_C
                                                      ;
+ ;
  #else
-                                                       = { 64, 64, 128 };
+       = { 64, 64, 128 };
  #endif
  
  
  
  /* -------------------------------------------------------------------------------
  
- abstracted bsp globals
   abstracted bsp globals
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
- Q_EXTERN int                          numEntities Q_ASSIGN( 0 );
- Q_EXTERN int                          numBSPEntities Q_ASSIGN( 0 );
- Q_EXTERN int                          allocatedEntities Q_ASSIGN( 0 );
- Q_EXTERN entity_t*                    entities Q_ASSIGN(NULL);
+ Q_EXTERN int numEntities Q_ASSIGN( 0 );
+ Q_EXTERN int numBSPEntities Q_ASSIGN( 0 );
+ Q_EXTERN int allocatedEntities Q_ASSIGN( 0 );
+ Q_EXTERN entity_t*          entities Q_ASSIGN( NULL );
  
- Q_EXTERN int                          numBSPModels Q_ASSIGN( 0 );
- Q_EXTERN int                          allocatedBSPModels Q_ASSIGN( 0 );
- Q_EXTERN bspModel_t*          bspModels Q_ASSIGN(NULL);
+ Q_EXTERN int numBSPModels Q_ASSIGN( 0 );
+ Q_EXTERN int allocatedBSPModels Q_ASSIGN( 0 );
+ Q_EXTERN bspModel_t*        bspModels Q_ASSIGN( NULL );
  
- Q_EXTERN int                          numBSPShaders Q_ASSIGN( 0 );
- Q_EXTERN int                          allocatedBSPShaders Q_ASSIGN( 0 );
- Q_EXTERN bspShader_t*         bspShaders Q_ASSIGN(0);
+ Q_EXTERN int numBSPShaders Q_ASSIGN( 0 );
+ Q_EXTERN int allocatedBSPShaders Q_ASSIGN( 0 );
+ Q_EXTERN bspShader_t*       bspShaders Q_ASSIGN( 0 );
  
- Q_EXTERN int                          bspEntDataSize Q_ASSIGN( 0 );
- Q_EXTERN int                          allocatedBSPEntData Q_ASSIGN( 0 );
- Q_EXTERN char                         *bspEntData Q_ASSIGN(0);
+ Q_EXTERN int bspEntDataSize Q_ASSIGN( 0 );
+ Q_EXTERN int allocatedBSPEntData Q_ASSIGN( 0 );
+ Q_EXTERN char               *bspEntData Q_ASSIGN( 0 );
  
- Q_EXTERN int                          numBSPLeafs Q_ASSIGN( 0 );
- Q_EXTERN bspLeaf_t                    bspLeafs[ MAX_MAP_LEAFS ];
+ Q_EXTERN int numBSPLeafs Q_ASSIGN( 0 );
+ Q_EXTERN bspLeaf_t bspLeafs[ MAX_MAP_LEAFS ];
  
- Q_EXTERN int                          numBSPPlanes Q_ASSIGN( 0 );
- Q_EXTERN int                          allocatedBSPPlanes Q_ASSIGN(0);
- Q_EXTERN bspPlane_t                   *bspPlanes;
+ Q_EXTERN int numBSPPlanes Q_ASSIGN( 0 );
+ Q_EXTERN int allocatedBSPPlanes Q_ASSIGN( 0 );
+ Q_EXTERN bspPlane_t         *bspPlanes;
  
- Q_EXTERN int                          numBSPNodes Q_ASSIGN( 0 );
- Q_EXTERN int                          allocatedBSPNodes Q_ASSIGN( 0 );
- Q_EXTERN bspNode_t*                   bspNodes Q_ASSIGN(NULL);
+ Q_EXTERN int numBSPNodes Q_ASSIGN( 0 );
+ Q_EXTERN int allocatedBSPNodes Q_ASSIGN( 0 );
+ Q_EXTERN bspNode_t*         bspNodes Q_ASSIGN( NULL );
  
- Q_EXTERN int                          numBSPLeafSurfaces Q_ASSIGN( 0 );
- Q_EXTERN int                          allocatedBSPLeafSurfaces Q_ASSIGN( 0 );
- Q_EXTERN int*                         bspLeafSurfaces Q_ASSIGN(NULL);
+ Q_EXTERN int numBSPLeafSurfaces Q_ASSIGN( 0 );
+ Q_EXTERN int allocatedBSPLeafSurfaces Q_ASSIGN( 0 );
+ Q_EXTERN int*               bspLeafSurfaces Q_ASSIGN( NULL );
  
- Q_EXTERN int                          numBSPLeafBrushes Q_ASSIGN( 0 );
- Q_EXTERN int                          allocatedBSPLeafBrushes Q_ASSIGN( 0 );
- Q_EXTERN int*                         bspLeafBrushes Q_ASSIGN(NULL);
+ Q_EXTERN int numBSPLeafBrushes Q_ASSIGN( 0 );
+ Q_EXTERN int allocatedBSPLeafBrushes Q_ASSIGN( 0 );
+ Q_EXTERN int*               bspLeafBrushes Q_ASSIGN( NULL );
  
- Q_EXTERN int                          numBSPBrushes Q_ASSIGN( 0 );
- Q_EXTERN int                          allocatedBSPBrushes Q_ASSIGN( 0 );
- Q_EXTERN bspBrush_t*          bspBrushes Q_ASSIGN(NULL);
+ Q_EXTERN int numBSPBrushes Q_ASSIGN( 0 );
+ Q_EXTERN int allocatedBSPBrushes Q_ASSIGN( 0 );
+ Q_EXTERN bspBrush_t*        bspBrushes Q_ASSIGN( NULL );
  
- Q_EXTERN int                          numBSPBrushSides Q_ASSIGN( 0 );
- Q_EXTERN int                          allocatedBSPBrushSides Q_ASSIGN( 0 );
- Q_EXTERN bspBrushSide_t*      bspBrushSides Q_ASSIGN(NULL);
+ Q_EXTERN int numBSPBrushSides Q_ASSIGN( 0 );
+ Q_EXTERN int allocatedBSPBrushSides Q_ASSIGN( 0 );
+ Q_EXTERN bspBrushSide_t*    bspBrushSides Q_ASSIGN( NULL );
  
- Q_EXTERN int                          numBSPLightBytes Q_ASSIGN( 0 );
- Q_EXTERN byte                         *bspLightBytes Q_ASSIGN( NULL );
+ Q_EXTERN int numBSPLightBytes Q_ASSIGN( 0 );
+ Q_EXTERN byte               *bspLightBytes Q_ASSIGN( NULL );
  
  //%   Q_EXTERN int                            numBSPGridPoints Q_ASSIGN( 0 );
  //%   Q_EXTERN byte                           *bspGridPoints Q_ASSIGN( NULL );
  
- Q_EXTERN int                          numBSPGridPoints Q_ASSIGN( 0 );
- Q_EXTERN bspGridPoint_t               *bspGridPoints Q_ASSIGN( NULL );
+ Q_EXTERN int numBSPGridPoints Q_ASSIGN( 0 );
+ Q_EXTERN bspGridPoint_t     *bspGridPoints Q_ASSIGN( NULL );
  
- Q_EXTERN int                          numBSPVisBytes Q_ASSIGN( 0 );
- Q_EXTERN byte                         bspVisBytes[ MAX_MAP_VISIBILITY ];
+ Q_EXTERN int numBSPVisBytes Q_ASSIGN( 0 );
+ Q_EXTERN byte bspVisBytes[ MAX_MAP_VISIBILITY ];
  
- Q_EXTERN int                          numBSPDrawVerts Q_ASSIGN( 0 );
- Q_EXTERN bspDrawVert_t                *bspDrawVerts Q_ASSIGN( NULL );
+ Q_EXTERN int numBSPDrawVerts Q_ASSIGN( 0 );
+ Q_EXTERN bspDrawVert_t          *bspDrawVerts Q_ASSIGN( NULL );
  
- Q_EXTERN int                          numBSPDrawIndexes Q_ASSIGN( 0 );
- Q_EXTERN int                          bspDrawIndexes[ MAX_MAP_DRAW_INDEXES ];
+ Q_EXTERN int numBSPDrawIndexes Q_ASSIGN( 0 );
+ Q_EXTERN int allocatedBSPDrawIndexes Q_ASSIGN( 0 );
+ Q_EXTERN int                *bspDrawIndexes Q_ASSIGN( NULL );
  
- Q_EXTERN int                          numBSPDrawSurfaces Q_ASSIGN( 0 );
- Q_EXTERN bspDrawSurface_t     *bspDrawSurfaces Q_ASSIGN( NULL );
+ Q_EXTERN int numBSPDrawSurfaces Q_ASSIGN( 0 );
+ Q_EXTERN bspDrawSurface_t   *bspDrawSurfaces Q_ASSIGN( NULL );
  
- Q_EXTERN int                          numBSPFogs Q_ASSIGN( 0 );
- Q_EXTERN bspFog_t                     bspFogs[ MAX_MAP_FOGS ];
+ Q_EXTERN int numBSPFogs Q_ASSIGN( 0 );
+ Q_EXTERN bspFog_t bspFogs[ MAX_MAP_FOGS ];
  
- Q_EXTERN int                          numBSPAds Q_ASSIGN( 0 );
- Q_EXTERN bspAdvertisement_t   bspAds[ MAX_MAP_ADVERTISEMENTS ];
+ Q_EXTERN int numBSPAds Q_ASSIGN( 0 );
+ Q_EXTERN bspAdvertisement_t bspAds[ MAX_MAP_ADVERTISEMENTS ];
  
- #define AUTOEXPAND_BY_REALLOC(ptr, reqitem, allocated, def) \
+ #define AUTOEXPAND_BY_REALLOC( ptr, reqitem, allocated, def ) \
        do \
        { \
-               if(reqitem >= allocated) \
+               if ( reqitem >= allocated )     \
                { \
-                       if(allocated == 0) \
-                               allocated = def; \
-                       while(reqitem >= allocated && allocated) \
-                               allocated *= 2; \
-                       if(!allocated || allocated > 2147483647 / (int)sizeof(*ptr)) \
+                       if ( allocated == 0 ) { \
+                               allocated = def; \
+                       while ( reqitem >= allocated && allocated )     \
+                               allocated *= 2; \
+                       if ( !allocated || allocated > 2147483647 / (int)sizeof( *ptr ) ) \
                        { \
-                               Error(#ptr " over 2 GB"); \
+                               Error( # ptr " over 2 GB" ); \
                        } \
-                       ptr = realloc(ptr, sizeof(*ptr) * allocated); \
-                       if(!ptr) \
-                               Error(#ptr " out of memory"); \
+                       ptr = realloc( ptr, sizeof( *ptr ) * allocated ); \
+                       if ( !ptr ) { \
+                               Error( # ptr " out of memory" ); } \
                } \
        } \
-       while(0)
+       while ( 0 )
  
- #define AUTOEXPAND_BY_REALLOC_BSP(suffix, def) AUTOEXPAND_BY_REALLOC(bsp##suffix, numBSP##suffix, allocatedBSP##suffix, def)
+ #define AUTOEXPAND_BY_REALLOC_BSP( suffix, def ) AUTOEXPAND_BY_REALLOC( bsp ## suffix, numBSP ## suffix, allocatedBSP ## suffix, def )
  
- #define Image_LinearFloatFromsRGBFloat(c) (((c) <= 0.04045f) ? (c) * (1.0f / 12.92f) : (float)pow(((c) + 0.055f)*(1.0f/1.055f), 2.4f))
- #define Image_sRGBFloatFromLinearFloat(c) (((c) < 0.0031308f) ? (c) * 12.92f : 1.055f * (float)pow((c), 1.0f/2.4f) - 0.055f)
+ #define Image_LinearFloatFromsRGBFloat( c ) ( ( ( c ) <= 0.04045f ) ? ( c ) * ( 1.0f / 12.92f ) : (float)pow( ( ( c ) + 0.055f ) * ( 1.0f / 1.055f ), 2.4f ) )
+ #define Image_sRGBFloatFromLinearFloat( c ) ( ( ( c ) < 0.0031308f ) ? ( c ) * 12.92f : 1.055f * (float)pow( ( c ), 1.0f / 2.4f ) - 0.055f )
  
  /* end marker */
  #endif
index 87fb3a3122fefc9d876358dcd3eceab83bc9fc76,fb560d511311c911499c1719e50ed63376cb1757..b166c91fc4f576f46a1f964dad2c98b31d83e820
@@@ -1,30 -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."
  
- ------------------------------------------------------------------------------- */
   ------------------------------------------------------------------------------- */
  
  
  
  
  
  
- void PlaneFromWinding (fixedWinding_t *w, visPlane_t *plane)
- {
-       vec3_t          v1, v2;
+ void PlaneFromWinding( fixedWinding_t *w, visPlane_t *plane ){
+       vec3_t v1, v2;
  
  // calc plane
-       VectorSubtract (w->points[2], w->points[1], v1);
-       VectorSubtract (w->points[0], w->points[1], v2);
-       CrossProduct (v2, v1, plane->normal);
-       VectorNormalize (plane->normal, plane->normal);
-       plane->dist = DotProduct (w->points[0], plane->normal);
+       VectorSubtract( w->points[2], w->points[1], v1 );
+       VectorSubtract( w->points[0], w->points[1], v2 );
+       CrossProduct( v2, v1, plane->normal );
+       VectorNormalize( plane->normal, plane->normal );
+       plane->dist = DotProduct( w->points[0], plane->normal );
  }
  
  
  /*
- NewFixedWinding()
- returns a new fixed winding
- ydnar: altered this a bit to reconcile multiply-defined winding_t
- */
- fixedWinding_t *NewFixedWinding( int points )
- {
-       fixedWinding_t  *w;
-       int                     size;
-       
-       if (points > MAX_POINTS_ON_WINDING)
-               Error ("NewWinding: %i points", points);
-       
-       size = (int)((size_t)((fixedWinding_t *)0)->points[points]);
-       w = safe_malloc (size);
-       memset (w, 0, size);
-       
   NewFixedWinding()
   returns a new fixed winding
   ydnar: altered this a bit to reconcile multiply-defined winding_t
 */
+ fixedWinding_t *NewFixedWinding( int points ){
+       fixedWinding_t  *w;
+       int size;
+       if ( points > MAX_POINTS_ON_WINDING ) {
+               Error( "NewWinding: %i points", points );
+       }
+       size = (int)( (size_t)( (fixedWinding_t *)0 )->points[points] );
+       w = safe_malloc( size );
+       memset( w, 0, size );
        return w;
  }
  
  
  
- void prl(leaf_t *l)
- {
-       int                     i;
-       vportal_t       *p;
-       visPlane_t      pl;
-       
-       for (i=0 ; i<l->numportals ; i++)
+ void prl( leaf_t *l ){
+       int i;
+       vportal_t   *p;
+       visPlane_t pl;
+       for ( i = 0 ; i < l->numportals ; i++ )
        {
                p = l->portals[i];
                pl = p->plane;
-               Sys_Printf ("portal %4i to leaf %4i : %7.1f : (%4.1f, %4.1f, %4.1f)\n",(int)(p-portals),p->leaf,pl.dist, pl.normal[0], pl.normal[1], pl.normal[2]);
+               Sys_Printf( "portal %4i to leaf %4i : %7.1f : (%4.1f, %4.1f, %4.1f)\n",(int)( p - portals ),p->leaf,pl.dist, pl.normal[0], pl.normal[1], pl.normal[2] );
        }
  }
  
  //=============================================================================
  
  /*
- =============
- SortPortals
- Sorts the portals from the least complex, so the later ones can reuse
- the earlier information.
- =============
- */
- int PComp (const void *a, const void *b)
- {
-       if ( (*(const vportal_t *const *)a)->nummightsee == (*(const vportal_t *const *)b)->nummightsee)
+    =============
+    SortPortals
+    Sorts the portals from the least complex, so the later ones can reuse
+    the earlier information.
+    =============
+  */
+ int PComp( const void *a, const void *b ){
+       if ( ( *(const vportal_t *const *)a )->nummightsee == ( *(const vportal_t *const *)b )->nummightsee ) {
                return 0;
-       if ( (*(const vportal_t *const *)a)->nummightsee < (*(const vportal_t *const *)b)->nummightsee)
+       }
+       if ( ( *(const vportal_t *const *)a )->nummightsee < ( *(const vportal_t *const *)b )->nummightsee ) {
                return -1;
+       }
        return 1;
  }
- void SortPortals (void)
- {
-       int             i;
-       
-       for (i=0 ; i<numportals*2 ; i++)
+ void SortPortals( void ){
+       int i;
+       for ( i = 0 ; i < numportals * 2 ; i++ )
                sorted_portals[i] = &portals[i];
  
-       if (nosort)
+       if ( nosort ) {
                return;
-       qsort (sorted_portals, numportals*2, sizeof(sorted_portals[0]), PComp);
+       }
+       qsort( sorted_portals, numportals * 2, sizeof( sorted_portals[0] ), PComp );
  }
  
  
  /*
- ==============
- LeafVectorFromPortalVector
- ==============
- */
- int LeafVectorFromPortalVector (byte *portalbits, byte *leafbits)
- {
-       int                     i, j, leafnum;
-       vportal_t       *p;
-       int                     c_leafs;
-       for (i=0 ; i<numportals*2 ; i++)
+    ==============
+    LeafVectorFromPortalVector
+    ==============
+  */
+ int LeafVectorFromPortalVector( byte *portalbits, byte *leafbits ){
+       int i, j, leafnum;
+       vportal_t   *p;
+       int c_leafs;
+       for ( i = 0 ; i < numportals * 2 ; i++ )
        {
-               if (portalbits[i>>3] & (1<<(i&7)) )
-               {
-                       p = portals+i;
-                       leafbits[p->leaf>>3] |= (1<<(p->leaf&7));
+               if ( portalbits[i >> 3] & ( 1 << ( i & 7 ) ) ) {
+                       p = portals + i;
+                       leafbits[p->leaf >> 3] |= ( 1 << ( p->leaf & 7 ) );
                }
        }
  
-       for (j = 0; j < portalclusters; j++)
+       for ( j = 0; j < portalclusters; j++ )
        {
                leafnum = j;
-               while (leafs[leafnum].merged >= 0)
+               while ( leafs[leafnum].merged >= 0 )
                        leafnum = leafs[leafnum].merged;
                //if the merged leaf is visible then the original leaf is visible
-               if (leafbits[leafnum>>3] & (1<<(leafnum&7)))
-               {
-                       leafbits[j>>3] |= (1<<(j&7));
+               if ( leafbits[leafnum >> 3] & ( 1 << ( leafnum & 7 ) ) ) {
+                       leafbits[j >> 3] |= ( 1 << ( j & 7 ) );
                }
        }
  
-       c_leafs = CountBits (leafbits, portalclusters);
+       c_leafs = CountBits( leafbits, portalclusters );
  
        return c_leafs;
  }
  
  
  /*
- ===============
- ClusterMerge
   ===============
   ClusterMerge
  
- Merges the portal visibility for a leaf
- ===============
- */
   Merges the portal visibility for a leaf
   ===============
 */
  static int clustersizehistogram[MAX_MAP_LEAFS] = {0};
- void ClusterMerge (int leafnum)
- {
-       leaf_t          *leaf;
-       byte            portalvector[MAX_PORTALS/8];
-       byte            uncompressed[MAX_MAP_LEAFS/8];
-       int                     i, j;
-       int                     numvis, mergedleafnum;
-       vportal_t       *p;
-       int                     pnum;
+ void ClusterMerge( int leafnum ){
+       leaf_t      *leaf;
+       byte portalvector[MAX_PORTALS / 8];
+       byte uncompressed[MAX_MAP_LEAFS / 8];
+       int i, j;
+       int numvis, mergedleafnum;
+       vportal_t   *p;
+       int pnum;
  
        // OR together all the portalvis bits
  
        mergedleafnum = leafnum;
-       while(leafs[mergedleafnum].merged >= 0)
+       while ( leafs[mergedleafnum].merged >= 0 )
                mergedleafnum = leafs[mergedleafnum].merged;
  
-       memset (portalvector, 0, portalbytes);
+       memset( portalvector, 0, portalbytes );
        leaf = &leafs[mergedleafnum];
-       for (i = 0; i < leaf->numportals; i++)
+       for ( i = 0; i < leaf->numportals; i++ )
        {
                p = leaf->portals[i];
-               if (p->removed)
+               if ( p->removed ) {
                        continue;
+               }
  
-               if (p->status != stat_done)
-                       Error ("portal not done");
-               for (j=0 ; j<portallongs ; j++)
-                       ((long *)portalvector)[j] |= ((long *)p->portalvis)[j];
+               if ( p->status != stat_done ) {
+                       Error( "portal not done" );
+               }
+               for ( j = 0 ; j < portallongs ; j++ )
+                       ( (long *)portalvector )[j] |= ( (long *)p->portalvis )[j];
                pnum = p - portals;
-               portalvector[pnum>>3] |= 1<<(pnum&7);
+               portalvector[pnum >> 3] |= 1 << ( pnum & 7 );
        }
  
-       memset (uncompressed, 0, leafbytes);
+       memset( uncompressed, 0, leafbytes );
  
-       uncompressed[mergedleafnum>>3] |= (1<<(mergedleafnum&7));
+       uncompressed[mergedleafnum >> 3] |= ( 1 << ( mergedleafnum & 7 ) );
        // convert portal bits to leaf bits
-       numvis = LeafVectorFromPortalVector (portalvector, uncompressed);
+       numvis = LeafVectorFromPortalVector( portalvector, uncompressed );
  
  //    if (uncompressed[leafnum>>3] & (1<<(leafnum&7)))
  //            Sys_Printf ("WARNING: Leaf portals saw into leaf\n");
-               
  //    uncompressed[leafnum>>3] |= (1<<(leafnum&7));
  
-       numvis++;               // count the leaf itself
+       numvis++;       // count the leaf itself
  
        //Sys_FPrintf (SYS_VRB,"cluster %4i : %4i visible\n", leafnum, numvis);
        ++clustersizehistogram[numvis];
  
-       memcpy (bspVisBytes + VIS_HEADER_SIZE + leafnum*leafbytes, uncompressed, leafbytes);
+       memcpy( bspVisBytes + VIS_HEADER_SIZE + leafnum * leafbytes, uncompressed, leafbytes );
  }
  
  /*
- ==================
- CalcPortalVis
- ==================
- */
- void CalcPortalVis (void)
- {
+    ==================
+    CalcPortalVis
+    ==================
+  */
+ void CalcPortalVis( void ){
  #ifdef MREDEBUG
-       Sys_Printf("%6d portals out of %d", 0, numportals*2);
+       Sys_Printf( "%6d portals out of %d", 0, numportals * 2 );
        //get rid of the counter
-       RunThreadsOnIndividual (numportals*2, qfalse, PortalFlow);
+       RunThreadsOnIndividual( numportals * 2, qfalse, PortalFlow );
  #else
-       RunThreadsOnIndividual (numportals*2, qtrue, PortalFlow);
+       RunThreadsOnIndividual( numportals * 2, qtrue, PortalFlow );
  #endif
  
  }
  
  /*
- ==================
- CalcPassageVis
- ==================
- */
- void CalcPassageVis(void)
- {
+    ==================
+    CalcPassageVis
+    ==================
+  */
+ void CalcPassageVis( void ){
        PassageMemory();
  
  #ifdef MREDEBUG
-       _printf("%6d portals out of %d", 0, numportals*2);
-       RunThreadsOnIndividual (numportals*2, qfalse, CreatePassages);
-       _printf("\n");
-       _printf("%6d portals out of %d", 0, numportals*2);
-       RunThreadsOnIndividual (numportals*2, qfalse, PassageFlow);
-       _printf("\n");
+       _printf( "%6d portals out of %d", 0, numportals * 2 );
+       RunThreadsOnIndividual( numportals * 2, qfalse, CreatePassages );
+       _printf( "\n" );
+       _printf( "%6d portals out of %d", 0, numportals * 2 );
+       RunThreadsOnIndividual( numportals * 2, qfalse, PassageFlow );
+       _printf( "\n" );
  #else
        Sys_Printf( "\n--- CreatePassages (%d) ---\n", numportals * 2 );
-       RunThreadsOnIndividual( numportals*2, qtrue, CreatePassages );
-       
+       RunThreadsOnIndividual( numportals * 2, qtrue, CreatePassages );
        Sys_Printf( "\n--- PassageFlow (%d) ---\n", numportals * 2 );
        RunThreadsOnIndividual( numportals * 2, qtrue, PassageFlow );
  #endif
  }
  
  /*
- ==================
- CalcPassagePortalVis
- ==================
- */
- void CalcPassagePortalVis(void)
- {
+    ==================
+    CalcPassagePortalVis
+    ==================
+  */
+ void CalcPassagePortalVis( void ){
        PassageMemory();
  
  #ifdef MREDEBUG
-       Sys_Printf("%6d portals out of %d", 0, numportals*2);
-       RunThreadsOnIndividual (numportals*2, qfalse, CreatePassages);
-       Sys_Printf("\n");
-       Sys_Printf("%6d portals out of %d", 0, numportals*2);
-       RunThreadsOnIndividual (numportals*2, qfalse, PassagePortalFlow);
-       Sys_Printf("\n");
+       Sys_Printf( "%6d portals out of %d", 0, numportals * 2 );
+       RunThreadsOnIndividual( numportals * 2, qfalse, CreatePassages );
+       Sys_Printf( "\n" );
+       Sys_Printf( "%6d portals out of %d", 0, numportals * 2 );
+       RunThreadsOnIndividual( numportals * 2, qfalse, PassagePortalFlow );
+       Sys_Printf( "\n" );
  #else
        Sys_Printf( "\n--- CreatePassages (%d) ---\n", numportals * 2 );
-       RunThreadsOnIndividual( numportals * 2, qtrue, CreatePassages);
-       
+       RunThreadsOnIndividual( numportals * 2, qtrue, CreatePassages );
        Sys_Printf( "\n--- PassagePortalFlow (%d) ---\n", numportals * 2 );
        RunThreadsOnIndividual( numportals * 2, qtrue, PassagePortalFlow );
  #endif
  }
  
  /*
- ==================
- CalcFastVis
- ==================
- */
- void CalcFastVis(void)
- {
-       int             i;
+    ==================
+    CalcFastVis
+    ==================
+  */
+ void CalcFastVis( void ){
+       int i;
  
        // fastvis just uses mightsee for a very loose bound
-       for (i=0 ; i<numportals*2 ; i++)
+       for ( i = 0 ; i < numportals * 2 ; i++ )
        {
                portals[i].portalvis = portals[i].portalflood;
                portals[i].status = stat_done;
  }
  
  /*
- ==================
- CalcVis
- ==================
- */
- void CalcVis (void)
- {
-       int                     i, minvis, maxvis;
-       const char      *value;
+    ==================
+    CalcVis
+    ==================
+  */
+ void CalcVis( void ){
+       int i, minvis, maxvis;
+       const char  *value;
        double mu, sigma, totalvis, totalvis2;
-       
-       
        /* ydnar: rr2do2's farplane code */
        farPlaneDist = 0.0f;
-       value = ValueForKey( &entities[ 0 ], "_farplanedist" );         /* proper '_' prefixed key */
-       if( value[ 0 ] == '\0' )
-               value = ValueForKey( &entities[ 0 ], "fogclip" );               /* wolf compatibility */
-       if( value[ 0 ] == '\0' )
-               value = ValueForKey( &entities[ 0 ], "distancecull" );  /* sof2 compatibility */
-       if( value[ 0 ] != '\0' )
-       {
+       value = ValueForKey( &entities[ 0 ], "_farplanedist" );     /* proper '_' prefixed key */
+       if ( value[ 0 ] == '\0' ) {
+               value = ValueForKey( &entities[ 0 ], "fogclip" );       /* wolf compatibility */
+       }
+       if ( value[ 0 ] == '\0' ) {
+               value = ValueForKey( &entities[ 0 ], "distancecull" );  /* sof2 compatibility */
+       }
+       if ( value[ 0 ] != '\0' ) {
                farPlaneDist = atof( value );
-               if( farPlaneDist > 0.0f )
+               if ( farPlaneDist > 0.0f ) {
                        Sys_Printf( "farplane distance = %.1f\n", farPlaneDist );
-               else
+               }
+               else{
                        farPlaneDist = 0.0f;
+               }
        }
-       
-       
-       
        Sys_Printf( "\n--- BasePortalVis (%d) ---\n", numportals * 2 );
        RunThreadsOnIndividual( numportals * 2, qtrue, BasePortalVis );
-       
  //    RunThreadsOnIndividual (numportals*2, qtrue, BetterPortalVis);
  
-       SortPortals ();
-   if (fastvis) {
-     CalcFastVis();
-   }
-   else if ( noPassageVis ) {
-     CalcPortalVis();
-   }
-   else if ( passageVisOnly ) {
-     CalcPassageVis();
-   }
-   else {
-     CalcPassagePortalVis();
-   }
+       SortPortals();
+       if ( fastvis ) {
+               CalcFastVis();
+       }
+       else if ( noPassageVis ) {
+               CalcPortalVis();
+       }
+       else if ( passageVisOnly ) {
+               CalcPassageVis();
+       }
+       else {
+               CalcPassagePortalVis();
+       }
        //
        // assemble the leaf vis lists by oring and compressing the portal lists
        //
-       Sys_Printf("creating leaf vis...\n");
-       for (i=0 ; i<portalclusters ; i++)
-               ClusterMerge (i);
-       
+       Sys_Printf( "creating leaf vis...\n" );
+       for ( i = 0 ; i < portalclusters ; i++ )
+               ClusterMerge( i );
        totalvis = 0;
        totalvis2 = 0;
        minvis = -1;
        maxvis = -1;
-       for(i = 0; i < MAX_MAP_LEAFS; ++i)
-               if(clustersizehistogram[i])
-               {
-                       if(debugCluster)
-                               Sys_FPrintf(SYS_VRB, "%4i clusters have exactly %4i visible clusters\n", clustersizehistogram[i], i);
+       for ( i = 0; i < MAX_MAP_LEAFS; ++i )
+               if ( clustersizehistogram[i] ) {
+                       if ( debugCluster ) {
+                               Sys_FPrintf( SYS_VRB, "%4i clusters have exactly %4i visible clusters\n", clustersizehistogram[i], i );
+                       }
                        /* cast is to prevent integer overflow */
-                       totalvis  += ((double) i)                * ((double) clustersizehistogram[i]);
-                       totalvis2 += ((double) i) * ((double) i) * ((double) clustersizehistogram[i]);
+                       totalvis  += ( (double) i )                * ( (double) clustersizehistogram[i] );
+                       totalvis2 += ( (double) i ) * ( (double) i ) * ( (double) clustersizehistogram[i] );
  
-                       if(minvis < 0)
+                       if ( minvis < 0 ) {
                                minvis = i;
+                       }
                        maxvis = i;
                }
-       
        mu = totalvis / portalclusters;
-       sigma = sqrt(totalvis2 / portalclusters - mu * mu);
-       
-   Sys_Printf( "Total clusters: %i\n", portalclusters );
-   Sys_Printf( "Total visible clusters: %.0f\n", totalvis );
-   Sys_Printf( "Average clusters visible: %.2f (%.3f%%/total)\n", mu, mu / portalclusters * 100.0);
-   Sys_Printf( "  Standard deviation: %.2f (%.3f%%/total, %.3f%%/avg)\n", sigma, sigma / portalclusters * 100.0, sigma / mu * 100.0);
-   Sys_Printf( "  Minimum: %i (%.3f%%/total, %.3f%%/avg)\n", minvis, minvis / (double) portalclusters * 100.0, minvis / mu * 100.0);
-   Sys_Printf( "  Maximum: %i (%.3f%%/total, %.3f%%/avg)\n", maxvis, maxvis / (double) portalclusters * 100.0, maxvis / mu * 100.0);
+       sigma = sqrt( totalvis2 / portalclusters - mu * mu );
+       Sys_Printf( "Total clusters: %i\n", portalclusters );
+       Sys_Printf( "Total visible clusters: %.0f\n", totalvis );
+       Sys_Printf( "Average clusters visible: %.2f (%.3f%%/total)\n", mu, mu / portalclusters * 100.0 );
+       Sys_Printf( "  Standard deviation: %.2f (%.3f%%/total, %.3f%%/avg)\n", sigma, sigma / portalclusters * 100.0, sigma / mu * 100.0 );
+       Sys_Printf( "  Minimum: %i (%.3f%%/total, %.3f%%/avg)\n", minvis, minvis / (double) portalclusters * 100.0, minvis / mu * 100.0 );
+       Sys_Printf( "  Maximum: %i (%.3f%%/total, %.3f%%/avg)\n", maxvis, maxvis / (double) portalclusters * 100.0, maxvis / mu * 100.0 );
  }
  
  /*
- ==================
- SetPortalSphere
- ==================
- */
- void SetPortalSphere (vportal_t *p)
- {
-       int             i;
-       vec3_t  total, dist;
-       fixedWinding_t  *w;
-       float   r, bestr;
+    ==================
+    SetPortalSphere
+    ==================
+  */
+ void SetPortalSphere( vportal_t *p ){
+       int i;
+       vec3_t total, dist;
+       fixedWinding_t  *w;
+       float r, bestr;
  
        w = p->winding;
-       VectorCopy (vec3_origin, total);
-       for (i=0 ; i<w->numpoints ; i++)
+       VectorCopy( vec3_origin, total );
+       for ( i = 0 ; i < w->numpoints ; i++ )
        {
-               VectorAdd (total, w->points[i], total);
+               VectorAdd( total, w->points[i], total );
        }
-       
-       for (i=0 ; i<3 ; i++)
+       for ( i = 0 ; i < 3 ; i++ )
                total[i] /= w->numpoints;
  
-       bestr = 0;              
-       for (i=0 ; i<w->numpoints ; i++)
+       bestr = 0;
+       for ( i = 0 ; i < w->numpoints ; i++ )
        {
-               VectorSubtract (w->points[i], total, dist);
-               r = VectorLength (dist);
-               if (r > bestr)
+               VectorSubtract( w->points[i], total, dist );
+               r = VectorLength( dist );
+               if ( r > bestr ) {
                        bestr = r;
+               }
        }
-       VectorCopy (total, p->origin);
+       VectorCopy( total, p->origin );
        p->radius = bestr;
  }
  
  /*
- =============
- Winding_PlanesConcave
- =============
- */
- #define WCONVEX_EPSILON               0.2
- int Winding_PlanesConcave(fixedWinding_t *w1, fixedWinding_t *w2,
-                                                        vec3_t normal1, vec3_t normal2,
-                                                        float dist1, float dist2)
- {
+    =============
+    Winding_PlanesConcave
+    =============
+  */
+ #define WCONVEX_EPSILON     0.2
+ int Winding_PlanesConcave( fixedWinding_t *w1, fixedWinding_t *w2,
+                                                  vec3_t normal1, vec3_t normal2,
+                                                  float dist1, float dist2 ){
        int i;
  
-       if (!w1 || !w2) return qfalse;
+       if ( !w1 || !w2 ) {
+               return qfalse;
+       }
  
        // check if one of the points of winding 1 is at the front of the plane of winding 2
-       for (i = 0; i < w1->numpoints; i++)
+       for ( i = 0; i < w1->numpoints; i++ )
        {
-               if (DotProduct(normal2, w1->points[i]) - dist2 > WCONVEX_EPSILON) return qtrue;
+               if ( DotProduct( normal2, w1->points[i] ) - dist2 > WCONVEX_EPSILON ) {
+                       return qtrue;
+               }
        }
        // check if one of the points of winding 2 is at the front of the plane of winding 1
-       for (i = 0; i < w2->numpoints; i++)
+       for ( i = 0; i < w2->numpoints; i++ )
        {
-               if (DotProduct(normal1, w2->points[i]) - dist1 > WCONVEX_EPSILON) return qtrue;
+               if ( DotProduct( normal1, w2->points[i] ) - dist1 > WCONVEX_EPSILON ) {
+                       return qtrue;
+               }
        }
  
        return qfalse;
  }
  
  /*
- ============
- TryMergeLeaves
- ============
- */
- int TryMergeLeaves(int l1num, int l2num)
- {
+    ============
+    TryMergeLeaves
+    ============
+  */
+ int TryMergeLeaves( int l1num, int l2num ){
        int i, j, k, n, numportals;
        visPlane_t plane1, plane2;
        leaf_t *l1, *l2;
        vportal_t *p1, *p2;
        vportal_t *portals[MAX_PORTALS_ON_LEAF];
  
-       for (k = 0; k < 2; k++)
+       for ( k = 0; k < 2; k++ )
        {
-               if (k) l1 = &leafs[l1num];
-               else l1 = &faceleafs[l1num];
-               for (i = 0; i < l1->numportals; i++)
+               if ( k ) {
+                       l1 = &leafs[l1num];
+               }
+               else{l1 = &faceleafs[l1num]; }
+               for ( i = 0; i < l1->numportals; i++ )
                {
                        p1 = l1->portals[i];
-                       if (p1->leaf == l2num) continue;
-                       for (n = 0; n < 2; n++)
+                       if ( p1->leaf == l2num ) {
+                               continue;
+                       }
+                       for ( n = 0; n < 2; n++ )
                        {
-                               if (n) l2 = &leafs[l2num];
-                               else l2 = &faceleafs[l2num];
-                               for (j = 0; j < l2->numportals; j++)
+                               if ( n ) {
+                                       l2 = &leafs[l2num];
+                               }
+                               else{l2 = &faceleafs[l2num]; }
+                               for ( j = 0; j < l2->numportals; j++ )
                                {
                                        p2 = l2->portals[j];
-                                       if (p2->leaf == l1num) continue;
+                                       if ( p2->leaf == l1num ) {
+                                               continue;
+                                       }
                                        //
                                        plane1 = p1->plane;
                                        plane2 = p2->plane;
-                                       if (Winding_PlanesConcave(p1->winding, p2->winding, plane1.normal, plane2.normal, plane1.dist, plane2.dist))
+                                       if ( Winding_PlanesConcave( p1->winding, p2->winding, plane1.normal, plane2.normal, plane1.dist, plane2.dist ) ) {
                                                return qfalse;
+                                       }
                                }
                        }
                }
        }
-       for (k = 0; k < 2; k++)
+       for ( k = 0; k < 2; k++ )
        {
-               if (k)
-               {
+               if ( k ) {
                        l1 = &leafs[l1num];
                        l2 = &leafs[l2num];
                }
                }
                numportals = 0;
                //the leaves can be merged now
-               for (i = 0; i < l1->numportals; i++)
+               for ( i = 0; i < l1->numportals; i++ )
                {
                        p1 = l1->portals[i];
-                       if (p1->leaf == l2num)
-                       {
+                       if ( p1->leaf == l2num ) {
                                p1->removed = qtrue;
                                continue;
                        }
                        portals[numportals++] = p1;
                }
-               for (j = 0; j < l2->numportals; j++)
+               for ( j = 0; j < l2->numportals; j++ )
                {
                        p2 = l2->portals[j];
-                       if (p2->leaf == l1num)
-                       {
+                       if ( p2->leaf == l1num ) {
                                p2->removed = qtrue;
                                continue;
                        }
                        portals[numportals++] = p2;
                }
-               for (i = 0; i < numportals; i++)
+               for ( i = 0; i < numportals; i++ )
                {
                        l2->portals[i] = portals[i];
                }
  }
  
  /*
- ============
- UpdatePortals
- ============
- */
- void UpdatePortals(void)
- {
+    ============
+    UpdatePortals
+    ============
+  */
+ void UpdatePortals( void ){
        int i;
        vportal_t *p;
  
-       for (i = 0; i < numportals * 2; i++)
+       for ( i = 0; i < numportals * 2; i++ )
        {
                p = &portals[i];
-               if (p->removed)
+               if ( p->removed ) {
                        continue;
-               while(leafs[p->leaf].merged >= 0)
+               }
+               while ( leafs[p->leaf].merged >= 0 )
                        p->leaf = leafs[p->leaf].merged;
        }
  }
  
  /*
- ============
- MergeLeaves
- try to merge leaves but don't merge through hint splitters
- ============
- */
- void MergeLeaves(void)
- {
+    ============
+    MergeLeaves
+    try to merge leaves but don't merge through hint splitters
+    ============
+  */
+ void MergeLeaves( void ){
        int i, j, nummerges, totalnummerges;
        leaf_t *leaf;
        vportal_t *p;
        do
        {
                nummerges = 0;
-               for (i = 0; i < portalclusters; i++)
+               for ( i = 0; i < portalclusters; i++ )
                {
                        leaf = &leafs[i];
                        //if this leaf is merged already
  
                        /* ydnar: vmods: merge all non-hint portals */
-                       if( leaf->merged >= 0 && hint == qfalse )
+                       if ( leaf->merged >= 0 && hint == qfalse ) {
                                continue;
+                       }
  
  
-                       for (j = 0; j < leaf->numportals; j++)
+                       for ( j = 0; j < leaf->numportals; j++ )
                        {
                                p = leaf->portals[j];
                                //
-                               if (p->removed)
+                               if ( p->removed ) {
                                        continue;
+                               }
                                //never merge through hint portals
-                               if (p->hint)
+                               if ( p->hint ) {
                                        continue;
-                               if (TryMergeLeaves(i, p->leaf))
-                               {
+                               }
+                               if ( TryMergeLeaves( i, p->leaf ) ) {
                                        UpdatePortals();
                                        nummerges++;
                                        break;
                        }
                }
                totalnummerges += nummerges;
-       } while (nummerges);
-       Sys_Printf("%6d leaves merged\n", totalnummerges);
+       } while ( nummerges );
+       Sys_Printf( "%6d leaves merged\n", totalnummerges );
  }
  
  /*
- ============
- TryMergeWinding
- ============
- */
- #define       CONTINUOUS_EPSILON      0.005
- fixedWinding_t *TryMergeWinding (fixedWinding_t *f1, fixedWinding_t *f2, vec3_t planenormal)
- {
-       vec_t           *p1, *p2, *p3, *p4, *back;
-       fixedWinding_t  *newf;
-       int                     i, j, k, l;
-       vec3_t          normal, delta;
-       vec_t           dot;
-       qboolean        keep1, keep2;
-       
+    ============
+    TryMergeWinding
+    ============
+  */
+ #define CONTINUOUS_EPSILON  0.005
+ fixedWinding_t *TryMergeWinding( fixedWinding_t *f1, fixedWinding_t *f2, vec3_t planenormal ){
+       vec_t       *p1, *p2, *p3, *p4, *back;
+       fixedWinding_t  *newf;
+       int i, j, k, l;
+       vec3_t normal, delta;
+       vec_t dot;
+       qboolean keep1, keep2;
  
        //
        // find a common edge
-       //      
-       p1 = p2 = NULL; // stop compiler warning
-       j = 0;                  // 
-       
-       for (i = 0; i < f1->numpoints; i++)
+       //
+  &nbs