]> de.git.xonotic.org Git - xonotic/netradiant.git/blobdiff - radiant/z.cpp
uncrustify! now the code is only ugly on the *inside*
[xonotic/netradiant.git] / radiant / z.cpp
index dff40708f8b46b861bd20b750f46bc80fac1125a..90d373a2c271550ac41b3bc92ebe74026cb96337 100644 (file)
@@ -1,38 +1,37 @@
 /*
-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
+ */
 
 #include "stdafx.h"
 //#include "qe3.h"
 
-#define        PAGEFLIPS       2
+#define PAGEFLIPS   2
 
-z_t            z;
+z_t z;
 
 /*
-============
-Z_Init
-============
-*/
-void Z_Init (void)
-{
+   ============
+   Z_Init
+   ============
+ */
+void Z_Init( void ){
        z.origin[0] = 0;
        z.origin[1] = 20;
        z.origin[2] = 46;
@@ -43,37 +42,35 @@ void Z_Init (void)
 
 
 /*
-============================================================================
+   ============================================================================
 
-  MOUSE ACTIONS
+   MOUSE ACTIONS
 
-============================================================================
-*/
+   ============================================================================
+ */
 
-static int     cursorx, cursory;
+static int cursorx, cursory;
 
 /*
-==============
-Z_MouseDown
-==============
-*/
-void Z_MouseDown (int x, int y, int buttons)
-{
-       vec3_t  org, dir, vup, vright;
-       brush_t *b;
+   ==============
+   Z_MouseDown
+   ==============
+ */
+void Z_MouseDown( int x, int y, int buttons ){
+       vec3_t org, dir, vup, vright;
+       brush_t *b;
 
-       Sys_GetCursorPos (&cursorx, &cursory);
+       Sys_GetCursorPos( &cursorx, &cursory );
 
-       vup[0] = 0; vup[1] = 0; vup[2] = 1/z.scale;
+       vup[0] = 0; vup[1] = 0; vup[2] = 1 / z.scale;
 
-       VectorCopy (z.origin, org);
-       org[2] += (y - (z.height/2))/z.scale;
+       VectorCopy( z.origin, org );
+       org[2] += ( y - ( z.height / 2 ) ) / z.scale;
        org[1] = g_MinWorldCoord;
 
        b = selected_brushes.next;
-       if (b != &selected_brushes)
-       {
-               org[0] = (b->mins[0] + b->maxs[0])/2;
+       if ( b != &selected_brushes ) {
+               org[0] = ( b->mins[0] + b->maxs[0] ) / 2;
        }
 
        dir[0] = 0; dir[1] = 1; dir[2] = 0;
@@ -86,381 +83,373 @@ void Z_MouseDown (int x, int y, int buttons)
        // ctrl-middle button = set entire brush to texture
        // ctrl-shift-middle button = set single face to texture
 
-  int nMouseButton = g_PrefsDlg.m_nMouseButtons == 2 ? MK_RBUTTON : MK_MBUTTON;
-       if ( (buttons == MK_LBUTTON)
-               || (buttons == (MK_LBUTTON | MK_SHIFT))
-               || (buttons == MK_MBUTTON)
+       int nMouseButton = g_PrefsDlg.m_nMouseButtons == 2 ? MK_RBUTTON : MK_MBUTTON;
+       if ( ( buttons == MK_LBUTTON )
+                || ( buttons == ( MK_LBUTTON | MK_SHIFT ) )
+                || ( buttons == MK_MBUTTON )
 //             || (buttons == (MK_MBUTTON|MK_CONTROL))
-               || (buttons == (nMouseButton|MK_SHIFT|MK_CONTROL)) )
-       {
-               Drag_Begin (x, y, buttons,
-                       vright, vup,
-                       org, dir);
+                || ( buttons == ( nMouseButton | MK_SHIFT | MK_CONTROL ) ) ) {
+               Drag_Begin( x, y, buttons,
+                                       vright, vup,
+                                       org, dir );
                return;
        }
 
        // control mbutton = move camera
-       if ((buttons == (MK_CONTROL|nMouseButton) ) || (buttons == (MK_CONTROL|MK_LBUTTON)))
-       {       
+       if ( ( buttons == ( MK_CONTROL | nMouseButton ) ) || ( buttons == ( MK_CONTROL | MK_LBUTTON ) ) ) {
                g_pParentWnd->GetCamWnd()->Camera()->origin[2] = org[2] ;
-               Sys_UpdateWindows (W_CAMERA|W_XY_OVERLAY|W_Z);
+               Sys_UpdateWindows( W_CAMERA | W_XY_OVERLAY | W_Z );
        }
 
 
 }
 
 /*
-==============
-Z_MouseUp
-==============
-*/
-void Z_MouseUp (int x, int y, int buttons)
-{
-       Drag_MouseUp ();
+   ==============
+   Z_MouseUp
+   ==============
+ */
+void Z_MouseUp( int x, int y, int buttons ){
+       Drag_MouseUp();
 }
 
 /*
-==============
-Z_MouseMoved
-==============
-*/
-void Z_MouseMoved (int x, int y, int buttons)
-{
-       if (!buttons)
+   ==============
+   Z_MouseMoved
+   ==============
+ */
+void Z_MouseMoved( int x, int y, int buttons ){
+       if ( !buttons ) {
                return;
-       if (buttons == MK_LBUTTON)
-       {
-               Drag_MouseMoved (x, y, buttons);
-               Sys_UpdateWindows (W_Z|W_CAMERA_IFON|W_XY);
+       }
+       if ( buttons == MK_LBUTTON ) {
+               Drag_MouseMoved( x, y, buttons );
+               Sys_UpdateWindows( W_Z | W_CAMERA_IFON | W_XY );
                return;
        }
        // rbutton = drag z origin
-       if (buttons == MK_RBUTTON)
-       {
-               Sys_GetCursorPos (&x, &y);
-               if ( y != cursory)
-               {
-                       z.origin[2] += y-cursory;
-                       Sys_SetCursorPos (cursorx, cursory);
-                       Sys_UpdateWindows (W_Z);
+       if ( buttons == MK_RBUTTON ) {
+               Sys_GetCursorPos( &x, &y );
+               if ( y != cursory ) {
+                       z.origin[2] += y - cursory;
+                       Sys_SetCursorPos( cursorx, cursory );
+                       Sys_UpdateWindows( W_Z );
                }
                return;
        }
-               // control mbutton = move camera
-  int nMouseButton = g_PrefsDlg.m_nMouseButtons == 2 ? MK_RBUTTON : MK_MBUTTON;
-       if ((buttons == (MK_CONTROL|nMouseButton) ) || (buttons == (MK_CONTROL|MK_LBUTTON)))
-       {       
-               g_pParentWnd->GetCamWnd()->Camera()->origin[2] = (y - (z.height/2))/z.scale;
-               Sys_UpdateWindows (W_CAMERA|W_XY_OVERLAY|W_Z);
+       // control mbutton = move camera
+       int nMouseButton = g_PrefsDlg.m_nMouseButtons == 2 ? MK_RBUTTON : MK_MBUTTON;
+       if ( ( buttons == ( MK_CONTROL | nMouseButton ) ) || ( buttons == ( MK_CONTROL | MK_LBUTTON ) ) ) {
+               g_pParentWnd->GetCamWnd()->Camera()->origin[2] = ( y - ( z.height / 2 ) ) / z.scale;
+               Sys_UpdateWindows( W_CAMERA | W_XY_OVERLAY | W_Z );
        }
 
 }
 
 
 /*
-============================================================================
+   ============================================================================
 
-DRAWING
+   DRAWING
 
-============================================================================
-*/
+   ============================================================================
+ */
 
 
 /*
-==============
-Z_DrawGrid
-==============
-*/
-void Z_DrawGrid (void)
-{
-       float   zz, zb, ze;
-       float   w, h;
-       char    text[32];
-
-       w = (z.width/2 / z.scale);
-       h = (z.height/2 / z.scale);
+   ==============
+   Z_DrawGrid
+   ==============
+ */
+void Z_DrawGrid( void ){
+       float zz, zb, ze;
+       float w, h;
+       char text[32];
+
+       w = ( z.width / 2 / z.scale );
+       h = ( z.height / 2 / z.scale );
 
        zb = z.origin[2] - h;
-       if (zb < region_mins[2])
+       if ( zb < region_mins[2] ) {
                zb = region_mins[2];
-       zb = 64 * floor (zb/64);
+       }
+       zb = 64 * floor( zb / 64 );
 
        ze = z.origin[2] + h;
-       if (ze > region_maxs[2])
+       if ( ze > region_maxs[2] ) {
                ze = region_maxs[2];
-       ze = 64 * ceil (ze/64);
+       }
+       ze = 64 * ceil( ze / 64 );
 
        // draw major blocks
 
-       qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_GRIDMAJOR]);
+       qglColor3fv( g_qeglobals.d_savedinfo.colors[COLOR_GRIDMAJOR] );
 
-       if ( g_qeglobals.d_showgrid )
-       {
-         if (g_qeglobals.d_gridsize < 128)
-         {
-           qglBegin (GL_LINES);
-
-           qglVertex2f (0, zb);
-           qglVertex2f (0, ze);
-
-           for (zz=zb ; zz<ze ; zz+=64)
-           {
-             qglVertex2f (-w, zz);
-             qglVertex2f (w, zz);
-           }
-
-           qglEnd ();
-         }
-         else
-         {
-           qglBegin (GL_LINES);
-
-           qglVertex2f (0, zb);
-           qglVertex2f (0, ze);
-
-           for (zz=zb ; zz<ze ; zz+=64)
-           {
-        // d_gridsize >= 128 .. it's an int for sure
-             if ( ((int)zz & ((int)g_qeglobals.d_gridsize-1)) != 0 )
-               continue;
-
-             qglVertex2f (-w, zz);
-             qglVertex2f (w, zz);
-           }
-
-           qglEnd ();
-         }
+       if ( g_qeglobals.d_showgrid ) {
+               if ( g_qeglobals.d_gridsize < 128 ) {
+                       qglBegin( GL_LINES );
+
+                       qglVertex2f( 0, zb );
+                       qglVertex2f( 0, ze );
+
+                       for ( zz = zb ; zz < ze ; zz += 64 )
+                       {
+                               qglVertex2f( -w, zz );
+                               qglVertex2f( w, zz );
+                       }
+
+                       qglEnd();
+               }
+               else
+               {
+                       qglBegin( GL_LINES );
+
+                       qglVertex2f( 0, zb );
+                       qglVertex2f( 0, ze );
+
+                       for ( zz = zb ; zz < ze ; zz += 64 )
+                       {
+                               // d_gridsize >= 128 .. it's an int for sure
+                               if ( ( (int)zz & ( (int)g_qeglobals.d_gridsize - 1 ) ) != 0 ) {
+                                       continue;
+                               }
+
+                               qglVertex2f( -w, zz );
+                               qglVertex2f( w, zz );
+                       }
+
+                       qglEnd();
+               }
        }
 
        // draw minor blocks
-       if (g_qeglobals.d_showgrid && g_qeglobals.d_gridsize*z.scale >= 4 &&
-      g_qeglobals.d_savedinfo.colors[COLOR_GRIDMINOR] != g_qeglobals.d_savedinfo.colors[COLOR_GRIDBACK])
-       {
-               qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_GRIDMINOR]);
+       if ( g_qeglobals.d_showgrid && g_qeglobals.d_gridsize * z.scale >= 4 &&
+                g_qeglobals.d_savedinfo.colors[COLOR_GRIDMINOR] != g_qeglobals.d_savedinfo.colors[COLOR_GRIDBACK] ) {
+               qglColor3fv( g_qeglobals.d_savedinfo.colors[COLOR_GRIDMINOR] );
 
-               qglBegin (GL_LINES);
-               for (zz=zb ; zz<ze ; zz+=g_qeglobals.d_gridsize)
+               qglBegin( GL_LINES );
+               for ( zz = zb ; zz < ze ; zz += g_qeglobals.d_gridsize )
                {
-                       if ( ! ((int)zz & 63) )
+                       if ( !( (int)zz & 63 ) ) {
                                continue;
-                       qglVertex2f (-w, zz);
-                       qglVertex2f (w, zz);
+                       }
+                       qglVertex2f( -w, zz );
+                       qglVertex2f( w, zz );
                }
-               qglEnd ();
+               qglEnd();
        }
 
        // draw coordinate text if needed
 
-       if ( g_qeglobals.d_savedinfo.show_coordinates)
-       {
-               qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_GRIDTEXT]);
+       if ( g_qeglobals.d_savedinfo.show_coordinates ) {
+               qglColor3fv( g_qeglobals.d_savedinfo.colors[COLOR_GRIDTEXT] );
 
-               int step = (int)(g_qeglobals.d_gridsize > 64 ? g_qeglobals.d_gridsize : 64);
+               int step = (int)( g_qeglobals.d_gridsize > 64 ? g_qeglobals.d_gridsize : 64 );
                zb = z.origin[2] - h;
-               if (zb < region_mins[2])
+               if ( zb < region_mins[2] ) {
                        zb = region_mins[2];
-               zb = step * floor (zb/step);
+               }
+               zb = step * floor( zb / step );
 
-               for (zz=zb ; zz<ze ; zz+=step)
+               for ( zz = zb ; zz < ze ; zz += step )
                {
-                       qglRasterPos2f (-w+(1/z.scale), zz);
-                       sprintf (text, "%i",(int)zz);
-                       gtk_glwidget_print_string(text);
+                       qglRasterPos2f( -w + ( 1 / z.scale ), zz );
+                       sprintf( text, "%i",(int)zz );
+                       gtk_glwidget_print_string( text );
                }
        }
 }
 
-void ZDrawCameraIcon (void)
-{
-       float   x, y;
-       float   xCam = z.width/4/z.scale, gizmo = 8 / z.scale, height = 48 / z.scale;
+void ZDrawCameraIcon( void ){
+       float x, y;
+       float xCam = z.width / 4 / z.scale, gizmo = 8 / z.scale, height = 48 / z.scale;
 
        x = 0;
        y = g_pParentWnd->GetCamWnd()->Camera()->origin[2];
 
-       qglColor3f (0.0, 0.0, 1.0);
-       qglBegin(GL_LINE_STRIP);
-       qglVertex3f (x-xCam,y,0);
-       qglVertex3f (x,y+gizmo,0);
-       qglVertex3f (x+xCam,y,0);
-       qglVertex3f (x,y-gizmo,0);
-       qglVertex3f (x-xCam,y,0);
-       qglVertex3f (x+xCam,y,0);
-       qglVertex3f (x+xCam,y-height,0);
-       qglVertex3f (x-xCam,y-height,0);
-       qglVertex3f (x-xCam,y,0);
-       qglEnd ();
+       qglColor3f( 0.0, 0.0, 1.0 );
+       qglBegin( GL_LINE_STRIP );
+       qglVertex3f( x - xCam,y,0 );
+       qglVertex3f( x,y + gizmo,0 );
+       qglVertex3f( x + xCam,y,0 );
+       qglVertex3f( x,y - gizmo,0 );
+       qglVertex3f( x - xCam,y,0 );
+       qglVertex3f( x + xCam,y,0 );
+       qglVertex3f( x + xCam,y - height,0 );
+       qglVertex3f( x - xCam,y - height,0 );
+       qglVertex3f( x - xCam,y,0 );
+       qglEnd();
 
 }
 
 GLbitfield glbitClear = GL_COLOR_BUFFER_BIT; //HACK
 
 /*
-==============
-Z_Draw
-==============
-*/
-void Z_Draw (void)
-{
+   ==============
+   Z_Draw
+   ==============
+ */
+void Z_Draw( void ){
 #ifdef DBG_WINDOWPOS
-  CheckWatchit ("Z_Draw");
+       CheckWatchit( "Z_Draw" );
 #endif
-  brush_t      *brush;
-       float   w, h;
-       double  start, end;
-       qtexture_t      *q;
-       float   top, bottom;
-       vec3_t  org_top, org_bottom, dir_up, dir_down;
-       int xCam = z.width/3;
+       brush_t   *brush;
+       float w, h;
+       double start, end;
+       qtexture_t  *q;
+       float top, bottom;
+       vec3_t org_top, org_bottom, dir_up, dir_down;
+       int xCam = z.width / 3;
 
-       if (!active_brushes.next)
-               return; // not valid yet
+       if ( !active_brushes.next ) {
+               return; // not valid yet
 
-       if (z.timing)
-               start = Sys_DoubleTime ();
+       }
+       if ( z.timing ) {
+               start = Sys_DoubleTime();
+       }
 
        //
        // clear
        //
-       qglViewport(0, 0, z.width, z.height);
+       qglViewport( 0, 0, z.width, z.height );
 
-       qglClearColor (
+       qglClearColor(
                g_qeglobals.d_savedinfo.colors[COLOR_GRIDBACK][0],
                g_qeglobals.d_savedinfo.colors[COLOR_GRIDBACK][1],
                g_qeglobals.d_savedinfo.colors[COLOR_GRIDBACK][2],
-               0);
+               0 );
 
-    /* GL Bug */ 
-       /* When not using hw acceleration, gl will fault if we clear the depth 
-       buffer bit on the first pass. The hack fix is to set the GL_DEPTH_BUFFER_BIT
-       only after Z_Draw() has been called once. Yeah, right. */
-       qglClear(glbitClear); 
+       /* GL Bug */
+       /* When not using hw acceleration, gl will fault if we clear the depth
+          buffer bit on the first pass. The hack fix is to set the GL_DEPTH_BUFFER_BIT
+          only after Z_Draw() has been called once. Yeah, right. */
+       qglClear( glbitClear );
        glbitClear |= GL_DEPTH_BUFFER_BIT;
-       qglMatrixMode(GL_PROJECTION);
+       qglMatrixMode( GL_PROJECTION );
 
-  qglLoadIdentity ();
-       w = z.width/2 / z.scale;
-       h = z.height/2 / z.scale;
-       qglOrtho (-w, w, z.origin[2]-h, z.origin[2]+h, -8, 8);
+       qglLoadIdentity();
+       w = z.width / 2 / z.scale;
+       h = z.height / 2 / z.scale;
+       qglOrtho( -w, w, z.origin[2] - h, z.origin[2] + h, -8, 8 );
 
-       qglDisable(GL_TEXTURE_2D);
-       qglDisable(GL_TEXTURE_1D);
-       qglDisable(GL_DEPTH_TEST);
-       qglDisable(GL_BLEND);
+       qglDisable( GL_TEXTURE_2D );
+       qglDisable( GL_TEXTURE_1D );
+       qglDisable( GL_DEPTH_TEST );
+       qglDisable( GL_BLEND );
 
 
        //
        // now draw the grid
        //
-       Z_DrawGrid ();
+       Z_DrawGrid();
 
        //
        // draw stuff
        //
 
-       qglDisable(GL_CULL_FACE);
+       qglDisable( GL_CULL_FACE );
 
-       qglShadeModel (GL_FLAT);
+       qglShadeModel( GL_FLAT );
 
-       qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
+       qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
 
-       qglDisable(GL_TEXTURE_2D);
-       qglDisable(GL_BLEND);
-       qglDisable(GL_DEPTH_TEST);
+       qglDisable( GL_TEXTURE_2D );
+       qglDisable( GL_BLEND );
+       qglDisable( GL_DEPTH_TEST );
 
 
        // draw filled interiors and edges
        dir_up[0] = 0 ; dir_up[1] = 0; dir_up[2] = 1;
        dir_down[0] = 0 ; dir_down[1] = 0; dir_down[2] = -1;
-       VectorCopy (z.origin, org_top);
+       VectorCopy( z.origin, org_top );
        org_top[2] = g_MaxWorldCoord;
-       VectorCopy (z.origin, org_bottom);
+       VectorCopy( z.origin, org_bottom );
        org_bottom[2] = g_MinWorldCoord;
 
-       for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next)
+       for ( brush = active_brushes.next ; brush != &active_brushes ; brush = brush->next )
        {
-               if (brush->bFiltered)
+               if ( brush->bFiltered ) {
                        continue;
+               }
 
-               if (brush->mins[0] >= z.origin[0]
-                       || brush->maxs[0] <= z.origin[0]
-                       || brush->mins[1] >= z.origin[1]
-                       || brush->maxs[1] <= z.origin[1])
+               if ( brush->mins[0] >= z.origin[0]
+                        || brush->maxs[0] <= z.origin[0]
+                        || brush->mins[1] >= z.origin[1]
+                        || brush->maxs[1] <= z.origin[1] ) {
                        continue;
+               }
 
-               if (!Brush_Ray (org_top, dir_down, brush, &top))
+               if ( !Brush_Ray( org_top, dir_down, brush, &top ) ) {
                        continue;
+               }
                top = org_top[2] - top;
-               if (!Brush_Ray (org_bottom, dir_up, brush, &bottom))
+               if ( !Brush_Ray( org_bottom, dir_up, brush, &bottom ) ) {
                        continue;
+               }
                bottom = org_bottom[2] + bottom;
 
                q = brush->brush_faces->pShader->getTexture();
-               qglColor3f (q->color[0], q->color[1], q->color[2]);
-               qglBegin (GL_QUADS);
-               qglVertex2f (-xCam, bottom);
-               qglVertex2f (xCam, bottom);
-               qglVertex2f (xCam, top);
-               qglVertex2f (-xCam, top);
-               qglEnd ();
-
-               qglColor3f (1,1,1);
-               qglBegin (GL_LINE_LOOP);
-               qglVertex2f (-xCam, bottom);
-               qglVertex2f (xCam, bottom);
-               qglVertex2f (xCam, top);
-               qglVertex2f (-xCam, top);
-               qglEnd ();
+               qglColor3f( q->color[0], q->color[1], q->color[2] );
+               qglBegin( GL_QUADS );
+               qglVertex2f( -xCam, bottom );
+               qglVertex2f( xCam, bottom );
+               qglVertex2f( xCam, top );
+               qglVertex2f( -xCam, top );
+               qglEnd();
+
+               qglColor3f( 1,1,1 );
+               qglBegin( GL_LINE_LOOP );
+               qglVertex2f( -xCam, bottom );
+               qglVertex2f( xCam, bottom );
+               qglVertex2f( xCam, top );
+               qglVertex2f( -xCam, top );
+               qglEnd();
        }
 
        //
        // now draw selected brushes
        //
-       for (brush = selected_brushes.next ; brush != &selected_brushes ; brush=brush->next)
+       for ( brush = selected_brushes.next ; brush != &selected_brushes ; brush = brush->next )
        {
-               if ( !(brush->mins[0] >= z.origin[0]
-                       || brush->maxs[0] <= z.origin[0]
-                       || brush->mins[1] >= z.origin[1]
-                       || brush->maxs[1] <= z.origin[1]) )
-               {
-                       if (Brush_Ray (org_top, dir_down, brush, &top))
-                       {
+               if ( !( brush->mins[0] >= z.origin[0]
+                               || brush->maxs[0] <= z.origin[0]
+                               || brush->mins[1] >= z.origin[1]
+                               || brush->maxs[1] <= z.origin[1] ) ) {
+                       if ( Brush_Ray( org_top, dir_down, brush, &top ) ) {
                                top = org_top[2] - top;
-                               if (Brush_Ray (org_bottom, dir_up, brush, &bottom))
-                               {
+                               if ( Brush_Ray( org_bottom, dir_up, brush, &bottom ) ) {
                                        bottom = org_bottom[2] + bottom;
 
                                        q = brush->brush_faces->pShader->getTexture();
-                                       qglColor3f (q->color[0], q->color[1], q->color[2]);
-                                       qglBegin (GL_QUADS);
-                                       qglVertex2f (-xCam, bottom);
-                                       qglVertex2f (xCam, bottom);
-                                       qglVertex2f (xCam, top);
-                                       qglVertex2f (-xCam, top);
-                                       qglEnd ();
+                                       qglColor3f( q->color[0], q->color[1], q->color[2] );
+                                       qglBegin( GL_QUADS );
+                                       qglVertex2f( -xCam, bottom );
+                                       qglVertex2f( xCam, bottom );
+                                       qglVertex2f( xCam, top );
+                                       qglVertex2f( -xCam, top );
+                                       qglEnd();
                                }
                        }
                }
 
-         qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES]);
-               qglBegin (GL_LINE_LOOP);
-               qglVertex2f (-xCam, brush->mins[2]);
-               qglVertex2f (xCam, brush->mins[2]);
-               qglVertex2f (xCam, brush->maxs[2]);
-               qglVertex2f (-xCam, brush->maxs[2]);
-               qglEnd ();
+               qglColor3fv( g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES] );
+               qglBegin( GL_LINE_LOOP );
+               qglVertex2f( -xCam, brush->mins[2] );
+               qglVertex2f( xCam, brush->mins[2] );
+               qglVertex2f( xCam, brush->maxs[2] );
+               qglVertex2f( -xCam, brush->maxs[2] );
+               qglEnd();
        }
 
 
-       ZDrawCameraIcon ();
+       ZDrawCameraIcon();
 
-  qglFinish();
+       qglFinish();
        QE_CheckOpenGLForErrors();
 
-       if (z.timing)
-       {
-               end = Sys_DoubleTime ();
-               Sys_Printf ("z: %i ms\n", (int)(1000*(end-start)));
+       if ( z.timing ) {
+               end = Sys_DoubleTime();
+               Sys_Printf( "z: %i ms\n", (int)( 1000 * ( end - start ) ) );
        }
 }
-