radiant/camwindow.cpp

   1 /*\r
   2 Copyright (C) 1999-2007 id Software, Inc. and contributors.\r
   3 For a list of contributors, see the accompanying CONTRIBUTORS file.\r
   4 \r
   5 This file is part of GtkRadiant.\r
   6 \r
   7 GtkRadiant is free software; you can redistribute it and/or modify\r
   8 it under the terms of the GNU General Public License as published by\r
   9 the Free Software Foundation; either version 2 of the License, or\r
  10 (at your option) any later version.\r
  11 \r
  12 GtkRadiant is distributed in the hope that it will be useful,\r
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  15 GNU General Public License for more details.\r
  16 \r
  17 You should have received a copy of the GNU General Public License\r
  18 along with GtkRadiant; if not, write to the Free Software\r
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\r
  20 */\r
  21 \r
  22 //\r
  23 // Camera Window\r
  24 //\r
  25 // Leonardo Zide (leo@lokigames.com)\r
  26 //\r
  27 \r
  28 #include "stdafx.h"\r
  29 #include <gtk/gtk.h>\r
  30 #include <GL/gl.h>\r
  31 \r
  32 extern void DrawPathLines();\r
  33 extern void Select_ShiftTexture(int x, int y);\r
  34 extern void Select_RotateTexture(int amt);\r
  35 extern void DrawAlternatePoint(vec3_t v, float scale);\r
  36 //extern void Select_ScaleTexture(int x, int y);\r
  37 \r
  38 extern int g_nPatchClickedView;\r
  39 \r
  40 brush_t* g_pSplitList = NULL;\r
  41 \r
  42 // =============================================================================\r
  43 // CamWnd class\r
  44 \r
  45 CamWnd::CamWnd ()\r
  46   : GLWindow (TRUE), m_XORRectangle(m_pWidget)\r
  47 {\r
  48   m_nNumTransBrushes = 0;\r
  49   memset(&m_Camera, 0, sizeof(camera_t));\r
  50   m_pSide_select = NULL;\r
  51   m_bClipMode = false;\r
  52   m_bFreeMove = false;\r
  53   Cam_Init();\r
  54 }\r
  55 \r
  56 CamWnd::~CamWnd ()\r
  57 {\r
  58 }\r
  59 \r
  60 void CamWnd::OnCreate ()\r
  61 {\r
  62   if (!MakeCurrent ())\r
  63     Error ("glMakeCurrent failed");\r
  64 \r
  65   gtk_glwidget_create_font (m_pWidget);\r
  66 \r
  67   // report OpenGL information\r
  68   Sys_Printf ("GL_VENDOR: %s\n", qglGetString (GL_VENDOR));\r
  69   Sys_Printf ("GL_RENDERER: %s\n", qglGetString (GL_RENDERER));\r
  70   Sys_Printf ("GL_VERSION: %s\n", qglGetString (GL_VERSION));\r
  71   Sys_Printf ("GL_EXTENSIONS: %s\n", qglGetString (GL_EXTENSIONS));\r
  72 \r
  73   // Set off texture compression supported\r
  74   g_qeglobals.bTextureCompressionSupported = 0;\r
  75 \r
  76   // finalize OpenGL init\r
  77   // NOTE\r
  78   // why is this here? well .. the Gtk objects get constructed when you enter gtk_main\r
  79   // and I wanted to have the extensions information in the editor startup console (avoid looking that up in the early console)\r
  80   // RIANT\r
  81   // I Split this up so as to add support for extension and user-friendly\r
  82   // compression format selection.\r
  83   // ADD new globals for your new format so as to minimise\r
  84   // calls to Sys_QGL_ExtensionSupported \r
  85   // NOTE TTimo: I don't really like this approach with globals. Frequent calls to Sys_QGL_ExtensionSupported don't sound like\r
  86   //   a problem to me. If there is some caching to be done, then I think it should be inside Sys_QGL_ExtensionSupported\r
  87   ///////////////////////////////////////////\r
  88   // Check for default OpenGL \r
  89   if (Sys_QGL_ExtensionSupported ("GL_ARB_texture_compression"))\r
  90   {\r
  91     g_qeglobals.bTextureCompressionSupported = 1;\r
  92     g_qeglobals.m_bOpenGLCompressionSupported = 1;\r
  93   }\r
  94 \r
  95   // INSERT PROPRIETARY EXTENSIONS HERE\r
  96   // Check for S3 extensions\r
  97   // create a bool global for extension supported\r
  98   if (Sys_QGL_ExtensionSupported ("GL_EXT_texture_compression_s3tc"))\r
  99   {\r
 100     g_qeglobals.bTextureCompressionSupported = 1;\r
 101     g_qeglobals.m_bS3CompressionSupported = 1;\r
 102   }\r
 103   \r
 104   g_qeglobals.m_bOpenGLReady = true;\r
 105   \r
 106   g_PrefsDlg.UpdateTextureCompression();\r
 107 \r
 108 #ifdef ATIHACK_812\r
 109   g_PrefsDlg.UpdateATIHack();\r
 110 #endif\r
 111 \r
 112   g_qeglobals_gui.d_camera = m_pWidget;\r
 113 }\r
 114 \r
 115 void CamWnd::Cam_Init ()\r
 116 {\r
 117   m_Camera.timing = false;\r
 118   m_Camera.origin[0] = 0.f;\r
 119   m_Camera.origin[1] = 20.f;\r
 120   m_Camera.origin[2] = 46.f;\r
 121   m_Camera.color[0] = 0.3f;\r
 122   m_Camera.color[1] = 0.3f;\r
 123   m_Camera.color[2] = 0.3f;\r
 124   m_nCambuttonstate = 0;\r
 125 }\r
 126 \r
 127 void CamWnd::OnSize(int cx, int cy) \r
 128 {\r
 129   m_Camera.width = cx;\r
 130   m_Camera.height = cy;\r
 131   gtk_widget_queue_draw(m_pWidget);\r
 132 }\r
 133 \r
 134 rectangle_t rectangle_from_area_cam()\r
 135 {\r
 136   const float left = MIN(g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaBR[0]);\r
 137   const float top = MAX(g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[1]);\r
 138   const float right = MAX(g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaBR[0]);\r
 139   const float bottom = MIN(g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[1]);\r
 140   return rectangle_t(left, bottom, right - left, top - bottom);\r
 141 }\r
 142 \r
 143 void update_xor_rectangle(XORRectangle& xor_rectangle)\r
 144 {\r
 145   rectangle_t rectangle;\r
 146         if ((g_qeglobals.d_select_mode == sel_area))\r
 147     rectangle = rectangle_from_area_cam();\r
 148   xor_rectangle.set(rectangle);\r
 149 }\r
 150 \r
 151 void CamWnd::OnMouseMove(guint32 flags, int pointx, int pointy) \r
 152 {\r
 153   int height = m_pWidget->allocation.height;\r
 154   // NOTE RR2DO2 this hasn't got any use anymore really. It is an old qeradiant feature\r
 155   // that can be re-enabled by removing the checks for HasCapture and not shift/ctrl down\r
 156   // but the scaling/rotating (unless done with the steps set in the surface inspector\r
 157   // dialog) is way too sensitive to be of any use\r
 158   if (HasCapture () && Sys_AltDown () &&\r
 159       !((flags & MK_SHIFT) || (flags & MK_CONTROL)))\r
 160   {\r
 161     if (flags & MK_CONTROL)\r
 162       Select_RotateTexture(pointy - m_ptLastCursorY);\r
 163     else\r
 164     if (flags & MK_SHIFT)\r
 165       Select_ScaleTexture(pointx - m_ptLastCursorX, m_ptLastCursorY - pointy);\r
 166     else\r
 167       Select_ShiftTexture(pointx - m_ptLastCursorX, m_ptLastCursorY - pointy);\r
 168   }\r
 169   else\r
 170   {\r
 171     Cam_MouseMoved(pointx, height - 1 - pointy, flags);\r
 172   }\r
 173   m_ptLastCursorX = pointx;\r
 174   m_ptLastCursorY = pointy;\r
 175 \r
 176   update_xor_rectangle(m_XORRectangle);\r
 177 }\r
 178 \r
 179 void CamWnd::OnMouseWheel(bool bUp)\r
 180 {\r
 181   if (bUp)\r
 182     VectorMA (m_Camera.origin, g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);\r
 183   else\r
 184     VectorMA (m_Camera.origin, -g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);\r
 185 \r
 186   int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);\r
 187   Sys_UpdateWindows (nUpdate);\r
 188   g_pParentWnd->OnTimer ();\r
 189 }\r
 190 \r
 191 void CamWnd::OnLButtonDown(guint32 nFlags, int pointx, int pointy) \r
 192 {\r
 193   m_ptLastCursorX = pointx;\r
 194   m_ptLastCursorY = pointy;\r
 195   OriginalMouseDown(nFlags, pointx, pointy);\r
 196 }\r
 197 \r
 198 void CamWnd::OnLButtonUp(guint32 nFlags, int pointx, int pointy) \r
 199 {\r
 200   OriginalMouseUp(nFlags, pointx, pointy);\r
 201 }\r
 202 \r
 203 void CamWnd::OnMButtonDown(guint32 nFlags, int pointx, int pointy) \r
 204 {\r
 205   OriginalMouseDown(nFlags, pointx, pointy);\r
 206 }\r
 207 \r
 208 void CamWnd::OnMButtonUp(guint32 nFlags, int pointx, int pointy) \r
 209 {\r
 210   OriginalMouseUp(nFlags, pointx, pointy);\r
 211 }\r
 212 \r
 213 void CamWnd::OnRButtonDown(guint32 nFlags, int pointx, int pointy) \r
 214 {\r
 215   OriginalMouseDown(nFlags, pointx, pointy);\r
 216 }\r
 217 \r
 218 void CamWnd::OnRButtonUp(guint32 nFlags, int pointx, int pointy) \r
 219 {\r
 220   OriginalMouseUp(nFlags, pointx, pointy);\r
 221 }\r
 222 \r
 223 void CamWnd::OriginalMouseUp(guint32 nFlags, int pointx, int pointy)\r
 224 {\r
 225   int height = m_pWidget->allocation.height;\r
 226 \r
 227   if(g_qeglobals.d_select_mode == sel_facets_on || g_qeglobals.d_select_mode == sel_facets_off)\r
 228   {\r
 229     g_qeglobals.d_select_mode = sel_brush;\r
 230   }\r
 231 \r
 232   Cam_MouseUp(pointx, height - 1 - pointy, nFlags);\r
 233   ReleaseCapture ();\r
 234 \r
 235   update_xor_rectangle(m_XORRectangle);\r
 236 }\r
 237 \r
 238 void CamWnd::OriginalMouseDown(guint32 nFlags, int pointx, int pointy)\r
 239 {\r
 240   int height = m_pWidget->allocation.height;\r
 241 \r
 242   SetFocus();\r
 243   SetCapture();\r
 244   Cam_MouseDown (pointx, height - 1 - pointy, nFlags);\r
 245 \r
 246   update_xor_rectangle(m_XORRectangle);\r
 247 }\r
 248 \r
 249 void CamWnd::Cam_BuildMatrix()\r
 250 {\r
 251   float ya;\r
 252   float matrix[4][4];\r
 253   int           i;\r
 254 \r
 255   if (!m_bFreeMove)\r
 256   {\r
 257     ya = m_Camera.angles[1]/180*Q_PI;\r
 258 \r
 259     // the movement matrix is kept 2d\r
 260     m_Camera.forward[0] = cos(ya);\r
 261     m_Camera.forward[1] = sin(ya);\r
 262     m_Camera.forward[2] = 0;\r
 263     m_Camera.right[0] = m_Camera.forward[1];\r
 264     m_Camera.right[1] = -m_Camera.forward[0];\r
 265   }\r
 266   else\r
 267   {\r
 268     AngleVectors( m_Camera.angles, m_Camera.forward, m_Camera.right, NULL );\r
 269     m_Camera.forward[2] = -m_Camera.forward[2];\r
 270   }\r
 271 \r
 272   memcpy(matrix, m_Camera.projection, sizeof(m4x4_t));\r
 273   m4x4_multiply_by_m4x4(&matrix[0][0], &m_Camera.modelview[0][0]);\r
 274 \r
 275   //qglGetFloatv (GL_PROJECTION_MATRIX, &matrix[0][0]);\r
 276 \r
 277   for (i=0 ; i<3 ; i++)\r
 278   {\r
 279     m_Camera.vright[i] = matrix[i][0];\r
 280     m_Camera.vup[i] = matrix[i][1];\r
 281     m_Camera.vpn[i] = matrix[i][2];\r
 282   }\r
 283 \r
 284   VectorNormalize (m_Camera.vright, m_Camera.vright);\r
 285   VectorNormalize (m_Camera.vup, m_Camera.vup);\r
 286   VectorNormalize (m_Camera.vpn, m_Camera.vpn);\r
 287 }\r
 288 \r
 289 void CamWnd::Cam_ChangeFloor (qboolean up)\r
 290 {\r
 291   brush_t       *b;\r
 292   float d, bestd, current;\r
 293   vec3_t        start, dir;\r
 294 \r
 295   start[0] = m_Camera.origin[0];\r
 296   start[1] = m_Camera.origin[1];\r
 297   start[2] = g_MaxWorldCoord;\r
 298   dir[0] = dir[1] = 0;\r
 299   dir[2] = -1;\r
 300 \r
 301   current = g_MaxWorldCoord - (m_Camera.origin[2] - 48);\r
 302   if (up)\r
 303     bestd = 0;\r
 304   else\r
 305     bestd = 2*g_MaxWorldCoord;\r
 306 \r
 307   for (b=active_brushes.next ; b != &active_brushes ; b=b->next)\r
 308   {\r
 309     if (!Brush_Ray (start, dir, b, &d))\r
 310       continue;\r
 311     if (up && d < current && d > bestd)\r
 312       bestd = d;\r
 313     if (!up && d > current && d < bestd)\r
 314       bestd = d;\r
 315   }\r
 316 \r
 317   if (bestd == 0 || bestd == 2*g_MaxWorldCoord)\r
 318     return;\r
 319 \r
 320   m_Camera.origin[2] += current - bestd;\r
 321   Sys_UpdateWindows (W_CAMERA|W_Z_OVERLAY);\r
 322 }\r
 323 \r
 324 void CamWnd::Cam_PositionDrag()\r
 325 {\r
 326   int x, y;\r
 327 \r
 328   Sys_GetCursorPos (&x, &y);\r
 329   if (x != m_ptCursorX || y != m_ptCursorY)\r
 330   {\r
 331     x -= m_ptCursorX;\r
 332     VectorMA (m_Camera.origin, x, m_Camera.vright, m_Camera.origin);\r
 333     y -= m_ptCursorY;\r
 334     m_Camera.origin[2] -= y;\r
 335     Sys_SetCursorPos(m_ptCursorX, m_ptCursorY);\r
 336     Sys_UpdateWindows (W_CAMERA | W_XY_OVERLAY);\r
 337   }\r
 338 }\r
 339 \r
 340 void CamWnd::Cam_MouseControl (float dtime)\r
 341 {\r
 342   Cam_KeyControl (dtime);\r
 343 \r
 344   if( g_PrefsDlg.m_bCamFreeLook )\r
 345   {\r
 346     int dx, dy;\r
 347     gint x, y;\r
 348 \r
 349     if( !m_bFreeMove || m_nCambuttonstate == MK_CONTROL )\r
 350       return;\r
 351 \r
 352     // Update angles\r
 353     Sys_GetCursorPos(&m_ptCursorX, &m_ptCursorY);\r
 354 \r
 355     dx = m_ptLastCamCursorX - m_ptCursorX;\r
 356     dy = m_ptLastCamCursorY - m_ptCursorY;\r
 357 \r
 358     gdk_window_get_origin( m_pWidget->window, &x, &y);\r
 359 \r
 360     m_ptLastCamCursorX = x + (m_Camera.width / 2);\r
 361     m_ptLastCamCursorY = y + (m_Camera.height / 2);\r
 362 \r
 363     Sys_SetCursorPos(m_ptLastCamCursorX, m_ptLastCamCursorY);\r
 364 \r
 365     // Don't use pitch \r
 366     if(!g_PrefsDlg.m_bCamFreeLookStrafe) {\r
 367       if (g_PrefsDlg.m_bCamInverseMouse)\r
 368             m_Camera.angles[PITCH] -= dy * dtime * g_PrefsDlg.m_nAngleSpeed;\r
 369       else\r
 370             m_Camera.angles[PITCH] += dy * dtime * g_PrefsDlg.m_nAngleSpeed;\r
 371     } else {\r
 372       VectorMA (m_Camera.origin, dy * (float) (g_PrefsDlg.m_nMoveSpeed / 6.0f), m_Camera.forward, m_Camera.origin);\r
 373     }\r
 374 \r
 375     m_Camera.angles[YAW] += dx * dtime * g_PrefsDlg.m_nAngleSpeed;\r
 376 \r
 377     if (m_Camera.angles[PITCH] > 90)\r
 378       m_Camera.angles[PITCH] = 90;\r
 379     else if (m_Camera.angles[PITCH] < -90)\r
 380       m_Camera.angles[PITCH] = -90;\r
 381 \r
 382     if (m_Camera.angles[YAW] >= 360)\r
 383       m_Camera.angles[YAW] = 0;\r
 384     else if (m_Camera.angles[YAW] <= -360)\r
 385       m_Camera.angles[YAW] = 0;\r
 386 \r
 387     if( dx || dy || m_Camera.movementflags )\r
 388     {\r
 389       int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);\r
 390       Sys_UpdateWindows (nUpdate);\r
 391       g_pParentWnd->OnTimer ();\r
 392     }\r
 393   }\r
 394   else\r
 395   {\r
 396     int   xl, xh;\r
 397     int yl, yh;\r
 398     float       xf, yf;\r
 399 \r
 400     if (g_PrefsDlg.m_nMouseButtons == 2)\r
 401     {\r
 402       if (m_nCambuttonstate != (MK_RBUTTON | MK_SHIFT))\r
 403         return;\r
 404     }\r
 405     else\r
 406     {\r
 407       if (m_nCambuttonstate != MK_RBUTTON)\r
 408         return;\r
 409     }\r
 410 \r
 411     xf = (float)(m_ptButtonX - m_Camera.width/2) / (m_Camera.width/2);\r
 412     yf = (float)(m_ptButtonY - m_Camera.height/2) / (m_Camera.height/2);\r
 413 \r
 414     xl = m_Camera.width/3;\r
 415     xh = xl*2;\r
 416     yl = m_Camera.height/3;\r
 417     yh = yl*2;\r
 418   \r
 419     xf *= 1.0 - fabs(yf);\r
 420     if (xf < 0)\r
 421     {\r
 422       xf += 0.1f;\r
 423       if (xf > 0)\r
 424         xf = 0;\r
 425     }\r
 426     else\r
 427     {\r
 428       xf -= 0.1f;\r
 429       if (xf < 0)\r
 430         xf = 0;\r
 431     }\r
 432   \r
 433     VectorMA (m_Camera.origin, yf*dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);\r
 434     m_Camera.angles[YAW] += xf*-dtime*g_PrefsDlg.m_nAngleSpeed;\r
 435   \r
 436     int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);\r
 437     Sys_UpdateWindows (nUpdate);\r
 438     g_pParentWnd->OnTimer ();\r
 439   }\r
 440 }\r
 441 \r
 442 void CamWnd::Cam_KeyControl (float dtime) {\r
 443 \r
 444   // Update angles\r
 445   if (m_Camera.movementflags & MOVE_ROTLEFT)\r
 446     m_Camera.angles[YAW] += 15*dtime*g_PrefsDlg.m_nAngleSpeed;\r
 447   if (m_Camera.movementflags & MOVE_ROTRIGHT)\r
 448     m_Camera.angles[YAW] -= 15*dtime*g_PrefsDlg.m_nAngleSpeed;\r
 449 \r
 450   // Update position\r
 451   if (m_Camera.movementflags & MOVE_FORWARD)\r
 452     VectorMA (m_Camera.origin, dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);\r
 453   if (m_Camera.movementflags & MOVE_BACK)\r
 454     VectorMA (m_Camera.origin, -dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);\r
 455   if (m_Camera.movementflags & MOVE_STRAFELEFT)\r
 456     VectorMA (m_Camera.origin, -dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.right, m_Camera.origin);\r
 457   if (m_Camera.movementflags & MOVE_STRAFERIGHT)\r
 458     VectorMA (m_Camera.origin, dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.right, m_Camera.origin);\r
 459 \r
 460   // Save a screen update (when m_bFreeMove is enabled, mousecontrol does the update)\r
 461   if( !m_bFreeMove && m_Camera.movementflags )\r
 462   {\r
 463      int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);\r
 464      Sys_UpdateWindows (nUpdate);\r
 465      g_pParentWnd->OnTimer ();\r
 466   }\r
 467 }\r
 468 \r
 469 // NOTE TTimo if there's an OS-level focus out of the application\r
 470 //   then we can release the camera cursor grab\r
 471 static gint camwindow_focusout(GtkWidget* widget, GdkEventKey* event, gpointer data)\r
 472 {\r
 473   g_pParentWnd->GetCamWnd ()->ToggleFreeMove();\r
 474   return FALSE;\r
 475 }\r
 476 \r
 477 void CamWnd::ToggleFreeMove()\r
 478 {\r
 479   GdkWindow *window;\r
 480   GtkWidget *widget;\r
 481 \r
 482   m_bFreeMove = !m_bFreeMove;\r
 483   Camera()->movementflags = 0;\r
 484   m_ptLastCamCursorX = m_ptCursorX;\r
 485   m_ptLastCamCursorY = m_ptCursorY;\r
 486 \r
 487   if (g_pParentWnd->CurrentStyle() == MainFrame::eFloating)\r
 488   {\r
 489     widget = g_pParentWnd->GetCamWnd ()->m_pParent;\r
 490     window = widget->window;\r
 491   }\r
 492   else\r
 493   {\r
 494     widget = g_pParentWnd->m_pWidget;\r
 495     window = widget->window;\r
 496   }\r
 497   \r
 498   if (m_bFreeMove)\r
 499   {\r
 500 \r
 501     SetFocus();\r
 502     SetCapture();\r
 503 \r
 504     {\r
 505       GdkPixmap *pixmap;\r
 506       GdkBitmap *mask;\r
 507       char buffer [(32 * 32)/8];\r
 508       memset (buffer, 0, (32 * 32)/8);\r
 509       GdkColor white = {0, 0xffff, 0xffff, 0xffff};\r
 510       GdkColor black = {0, 0x0000, 0x0000, 0x0000};\r
 511       pixmap = gdk_bitmap_create_from_data (NULL, buffer, 32, 32);\r
 512       mask   = gdk_bitmap_create_from_data (NULL, buffer, 32, 32);\r
 513       GdkCursor *cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &white, &black, 1, 1);\r
 514   \r
 515       gdk_window_set_cursor (window, cursor);\r
 516       gdk_cursor_unref (cursor);\r
 517       gdk_drawable_unref (pixmap);\r
 518       gdk_drawable_unref (mask);\r
 519     }\r
 520 \r
 521     // RR2DO2: FIXME why does this only work the 2nd and\r
 522     // further times the event is called? (floating windows\r
 523     // mode seems to work fine though...)\r
 524     m_FocusOutHandler_id = gtk_signal_connect (GTK_OBJECT (widget), "focus_out_event",\r
 525                       GTK_SIGNAL_FUNC (camwindow_focusout), g_pParentWnd);\r
 526     \r
 527     {\r
 528       GdkEventMask mask = (GdkEventMask)(GDK_POINTER_MOTION_MASK\r
 529       | GDK_POINTER_MOTION_HINT_MASK\r
 530       | GDK_BUTTON_MOTION_MASK\r
 531       | GDK_BUTTON1_MOTION_MASK\r
 532       | GDK_BUTTON2_MOTION_MASK\r
 533       | GDK_BUTTON3_MOTION_MASK\r
 534       | GDK_BUTTON_PRESS_MASK\r
 535       | GDK_BUTTON_RELEASE_MASK);\r
 536   \r
 537       gdk_pointer_grab(widget->window, TRUE, mask, widget->window, NULL, GDK_CURRENT_TIME);\r
 538     }\r
 539   }\r
 540   else\r
 541   {\r
 542     gdk_pointer_ungrab(GDK_CURRENT_TIME);\r
 543 \r
 544     gtk_signal_disconnect (GTK_OBJECT (widget), m_FocusOutHandler_id);\r
 545 \r
 546     GdkCursor *cursor = gdk_cursor_new (GDK_LEFT_PTR);\r
 547     gdk_window_set_cursor (window, cursor);\r
 548     gdk_cursor_unref (cursor);\r
 549 \r
 550     ReleaseCapture();\r
 551   }\r
 552 \r
 553   int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);\r
 554   Sys_UpdateWindows (nUpdate);\r
 555   g_pParentWnd->OnTimer ();\r
 556 }\r
 557 \r
 558 void CamWnd::Cam_MouseDown(int x, int y, int buttons)\r
 559 {\r
 560   vec3_t  dir;\r
 561   float   f, r, u;\r
 562   int     i;\r
 563 \r
 564 \r
 565   //\r
 566   // calc ray direction\r
 567   //\r
 568   u = (float)( y - ( m_Camera.height * .5f ) ) / ( m_Camera.width * .5f );\r
 569   r = (float)( x - ( m_Camera.width * .5f ) ) / ( m_Camera.width * .5f );\r
 570   f = 1;\r
 571 \r
 572   for (i=0 ; i<3 ; i++)\r
 573     dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;\r
 574   VectorNormalize (dir, dir);\r
 575 \r
 576   Sys_GetCursorPos(&m_ptCursorX, &m_ptCursorY);\r
 577 \r
 578   m_nCambuttonstate = buttons;\r
 579   m_ptButtonX = x;\r
 580   m_ptButtonY = y;\r
 581 \r
 582   // LBUTTON = manipulate selection\r
 583   // shift-LBUTTON = select\r
 584   // middle button = grab texture\r
 585   // ctrl-middle button = set entire brush to texture\r
 586   // ctrl-shift-middle button = set single face to texture\r
 587   int nMouseButton = g_PrefsDlg.m_nMouseButtons == 2 ? MK_RBUTTON : MK_MBUTTON;\r
 588   if ((buttons == MK_LBUTTON)\r
 589       || (buttons == (MK_LBUTTON | MK_SHIFT))\r
 590       || (buttons == (MK_LBUTTON | MK_CONTROL))\r
 591       || (buttons == (MK_LBUTTON | MK_CONTROL | MK_SHIFT))\r
 592       || (buttons == nMouseButton)\r
 593       || (buttons == (nMouseButton|MK_SHIFT))\r
 594       || (buttons == (nMouseButton|MK_CONTROL))\r
 595       || (buttons == (nMouseButton|MK_SHIFT|MK_CONTROL)))\r
 596   {\r
 597     if (g_PrefsDlg.m_nMouseButtons == 2 && (buttons == (MK_RBUTTON | MK_SHIFT)))\r
 598     {\r
 599       if (g_PrefsDlg.m_bCamFreeLook)\r
 600         ToggleFreeMove();\r
 601       else\r
 602         Cam_MouseControl (0.1f);\r
 603     }\r
 604     else\r
 605     {\r
 606       // something global needs to track which window is responsible for stuff\r
 607       Patch_SetView(W_CAMERA);\r
 608       Drag_Begin (x, y, buttons, m_Camera.vright, m_Camera.vup, m_Camera.origin, dir, true);\r
 609     }\r
 610     return;\r
 611   }\r
 612 \r
 613   if (buttons == MK_RBUTTON)\r
 614   {\r
 615     if (g_PrefsDlg.m_bCamFreeLook)\r
 616       ToggleFreeMove();\r
 617     else\r
 618       Cam_MouseControl (0.1f);\r
 619     return;\r
 620   }\r
 621 }\r
 622 \r
 623 void CamWnd::Cam_MouseUp (int x, int y, int buttons)\r
 624 {\r
 625   m_nCambuttonstate = 0;\r
 626   Drag_MouseUp (buttons);\r
 627 }\r
 628 \r
 629 void CamWnd::Cam_MouseMoved (int x, int y, int buttons)\r
 630 {\r
 631   m_nCambuttonstate = buttons;\r
 632   if (!buttons)\r
 633     return;\r
 634 \r
 635   if( g_PrefsDlg.m_nCamDragMultiSelect )\r
 636   {\r
 637     if (g_qeglobals.d_select_mode == sel_brush_on  || g_qeglobals.d_select_mode == sel_brush_off)\r
 638     {\r
 639       bool bDoDragMultiSelect = FALSE;\r
 640 \r
 641       if( g_PrefsDlg.m_nCamDragMultiSelect == 1 && buttons == (MK_LBUTTON|MK_SHIFT) )\r
 642         bDoDragMultiSelect = TRUE;\r
 643       else if( g_PrefsDlg.m_nCamDragMultiSelect == 2 && buttons == (MK_LBUTTON|MK_CONTROL) && Sys_AltDown() )\r
 644         bDoDragMultiSelect = TRUE;\r
 645 \r
 646       if( bDoDragMultiSelect )\r
 647       {\r
 648         vec3_t  dir;\r
 649         float   f, r, u;\r
 650         int     i;\r
 651 \r
 652         //\r
 653         // calc ray direction\r
 654         //\r
 655         u = (float)( y - ( m_Camera.height * .5f ) ) / ( m_Camera.width * .5f );\r
 656         r = (float)( x - ( m_Camera.width * .5f ) ) / ( m_Camera.width * .5f );\r
 657         f = 1;\r
 658 \r
 659         for (i=0 ; i<3 ; i++)\r
 660           dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;\r
 661         VectorNormalize (dir,dir);\r
 662 \r
 663         switch( g_qeglobals.d_select_mode )\r
 664         {\r
 665         case sel_brush_on:\r
 666           Select_Ray( m_Camera.origin, dir, (SF_DRAG_ON|SF_CAMERA) );\r
 667           break;\r
 668         \r
 669         case sel_brush_off:\r
 670           Select_Ray( m_Camera.origin, dir, (SF_DRAG_OFF|SF_CAMERA) );\r
 671           break;\r
 672 \r
 673         default:\r
 674           break;\r
 675         }\r
 676         return;\r
 677       }\r
 678     }\r
 679     else if (g_qeglobals.d_select_mode == sel_facets_on || g_qeglobals.d_select_mode == sel_facets_off)\r
 680     {\r
 681       if( buttons == (MK_LBUTTON|MK_CONTROL|MK_SHIFT) )\r
 682       {\r
 683         vec3_t dir;\r
 684         float           f, r, u;\r
 685         int                     i;\r
 686 \r
 687         //\r
 688         // calc ray direction\r
 689         //\r
 690         u = (float)( y - ( m_Camera.height * .5f ) ) / ( m_Camera.width * .5f );\r
 691         r = (float)( x - ( m_Camera.width * .5f ) ) / ( m_Camera.width * .5f );\r
 692         f = 1;\r
 693 \r
 694         for (i=0 ; i<3 ; i++)\r
 695           dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;\r
 696         VectorNormalize (dir,dir);\r
 697 \r
 698         switch( g_qeglobals.d_select_mode )\r
 699         {\r
 700         case sel_facets_on:\r
 701           Select_Ray( m_Camera.origin, dir, (SF_SINGLEFACE|SF_DRAG_ON|SF_CAMERA) );\r
 702           break;\r
 703 \r
 704         case sel_facets_off:\r
 705           Select_Ray( m_Camera.origin, dir, (SF_SINGLEFACE|SF_DRAG_OFF|SF_CAMERA) );\r
 706           break;\r
 707 \r
 708         default:\r
 709           break;\r
 710         }\r
 711         return;\r
 712       }\r
 713     }\r
 714   }\r
 715 \r
 716   m_ptButtonX = x;\r
 717   m_ptButtonY = y;\r
 718 \r
 719   if ( (m_bFreeMove && (buttons & MK_CONTROL) && !(buttons & MK_SHIFT)) || (!m_bFreeMove && (buttons == (MK_RBUTTON|MK_CONTROL))) )\r
 720   {\r
 721     Cam_PositionDrag ();\r
 722     Sys_UpdateWindows (W_XY|W_CAMERA|W_Z);\r
 723     return;\r
 724   }\r
 725 \r
 726   Sys_GetCursorPos(&m_ptCursorX, &m_ptCursorY);\r
 727 \r
 728   if (buttons & (MK_LBUTTON | MK_MBUTTON) )\r
 729   {\r
 730     Drag_MouseMoved (x, y, buttons);\r
 731     if(g_qeglobals.d_select_mode != sel_area)\r
 732       Sys_UpdateWindows (W_XY|W_CAMERA|W_Z);\r
 733   }\r
 734 }\r
 735 \r
 736 void CamWnd::InitCull()\r
 737 {\r
 738   int i;\r
 739 \r
 740   VectorSubtract (m_Camera.vpn, m_Camera.vright, m_vCull1);\r
 741   VectorAdd (m_Camera.vpn, m_Camera.vright, m_vCull2);\r
 742 \r
 743   for (i=0 ; i<3 ; i++)\r
 744   {\r
 745     if (m_vCull1[i] > 0)\r
 746       m_nCullv1[i] = 3+i;\r
 747     else\r
 748       m_nCullv1[i] = i;\r
 749     if (m_vCull2[i] > 0)\r
 750       m_nCullv2[i] = 3+i;\r
 751     else\r
 752       m_nCullv2[i] = i;\r
 753   }\r
 754 }\r
 755 \r
 756 qboolean CamWnd::CullBrush (brush_t *b)\r
 757 {\r
 758   int    i;\r
 759   vec3_t point;\r
 760   float  d;\r
 761 \r
 762   if (g_PrefsDlg.m_bCubicClipping)\r
 763   {\r
 764     float fLevel = g_PrefsDlg.m_nCubicScale * 64;\r
 765 \r
 766     point[0] = m_Camera.origin[0] - fLevel;\r
 767     point[1] = m_Camera.origin[1] - fLevel;\r
 768     point[2] = m_Camera.origin[2] - fLevel;\r
 769 \r
 770     for (i=0; i<3; i++)\r
 771       if (b->mins[i] < point[i] && b->maxs[i] < point[i])\r
 772         return true;\r
 773 \r
 774     point[0] = m_Camera.origin[0] + fLevel;\r
 775     point[1] = m_Camera.origin[1] + fLevel;\r
 776     point[2] = m_Camera.origin[2] + fLevel;\r
 777 \r
 778     for (i=0; i<3; i++)\r
 779       if (b->mins[i] > point[i] && b->maxs[i] > point[i])\r
 780         return true;\r
 781   }\r
 782 \r
 783   for (i=0 ; i<3 ; i++)\r
 784     point[i] = b->mins[m_nCullv1[i]] - m_Camera.origin[i];\r
 785 \r
 786   d = DotProduct (point, m_vCull1);\r
 787   if (d < -1)\r
 788     return true;\r
 789 \r
 790   for (i=0 ; i<3 ; i++)\r
 791     point[i] = b->mins[m_nCullv2[i]] - m_Camera.origin[i];\r
 792 \r
 793   d = DotProduct (point, m_vCull2);\r
 794   if (d < -1)\r
 795     return true;\r
 796 \r
 797   return false;\r
 798 }\r
 799 \r
 800 // project a 3D point onto the camera space\r
 801 // we use the GL viewing matrixes\r
 802 // this is the implementation of a glu function (I realized that afterwards): gluProject\r
 803 void CamWnd::ProjectCamera(const vec3_t A, vec_t B[2])\r
 804 {\r
 805 \r
 806   vec_t P1[4],P2[4],P3[4];\r
 807   VectorCopy(A,P1); P1[3] = 1;\r
 808 \r
 809   GLMatMul(m_Camera.modelview , P1, P2);\r
 810   GLMatMul(m_Camera.projection, P2, P3);\r
 811 \r
 812   // we ASSUME that the view port is 0 0 m_Camera.width m_Camera.height (you can check in Cam_Draw)\r
 813   B[0] = (float)m_Camera.width  * ( P3[0] + 1.0 ) / 2.0;\r
 814   B[1] = (float)m_Camera.height * ( P3[1] + 1.0 ) / 2.0;\r
 815 \r
 816 }\r
 817 \r
 818 // vec defines a direction in geometric space and P an origin point\r
 819 // the user is interacting from the camera view\r
 820 // (for example with texture adjustment shortcuts)\r
 821 // and intuitively if he hits left / right / up / down \r
 822 //   what happens in geometric space should match the left/right/up/down move in camera space\r
 823 // axis = 0: vec is along left/right\r
 824 // axis = 1: vec is along up/down\r
 825 // sgn = +1: same directions\r
 826 // sgn = -1: opposite directions\r
 827 // Implementation:\r
 828 //   typical use case is giving a face center and a normalized vector\r
 829 //   1) compute start and endpoint, project them in camera view, get the direction\r
 830 //     depending on the situation, we might bump into precision issues with that\r
 831 //   2) possible to compute the projected direction independently?\r
 832 //     this solution would be better but right now I don't see how to do it..\r
 833 void CamWnd::MatchViewAxes(const vec3_t P, const vec3_t vec, int &axis, float &sgn)\r
 834 {\r
 835 \r
 836   vec_t A[2],B[2],V[2];\r
 837   ProjectCamera(P,A);\r
 838   vec3_t Q;\r
 839   VectorAdd(P,vec,Q);\r
 840   ProjectCamera(Q,B);\r
 841   // V is the vector projected in camera space\r
 842   V[0] = B[0] - A[0];\r
 843   V[1] = B[1] - A[1];\r
 844   if (fabs(V[0])>fabs(V[1]))\r
 845   {\r
 846     // best match is against right\r
 847     axis = 0;\r
 848     if (V[0]>0)\r
 849       sgn = +1;\r
 850     else\r
 851       sgn = -1;\r
 852   }\r
 853   else\r
 854   {\r
 855     // best match is against up\r
 856     axis = 1;\r
 857     if (V[1]>0)\r
 858       sgn = +1;\r
 859     else\r
 860       sgn = -1;\r
 861   }\r
 862 }\r
 863 \r
 864 #if 0\r
 865 void CamWnd::DrawLightRadius(brush_t* pBrush)\r
 866 {\r
 867   // if lighting\r
 868   int nRadius = Brush_LightRadius(pBrush);\r
 869   if (nRadius > 0)\r
 870   {\r
 871     Brush_SetLightColor(pBrush);\r
 872           qglEnable (GL_BLEND);\r
 873           qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);\r
 874           qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
 875           qglDisable (GL_TEXTURE_2D);\r
 876 \r
 877     qglEnable(GL_TEXTURE_2D);\r
 878     qglDisable(GL_BLEND);\r
 879     qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);\r
 880   }\r
 881 }\r
 882 #endif\r
 883 \r
 884 extern void DrawPatchMesh(patchMesh_t *pm);\r
 885 extern void DrawPatchControls(patchMesh_t *pm);\r
 886 extern void Brush_DrawFacingAngle (brush_t *b, entity_t *e);\r
 887 extern void Brush_DrawModel(brush_t *b, bool bTextured = false);\r
 888 extern void DrawModelOrigin(brush_t *b);\r
 889 extern void DrawModelBBox(brush_t *b);\r
 890 \r
 891 void CamWnd::Cam_DrawBrush(brush_t *b, int mode)\r
 892 {\r
 893   int nGLState = m_Camera.draw_glstate;\r
 894   int nDrawMode = m_Camera.draw_mode;\r
 895   int nModelMode = g_PrefsDlg.m_nEntityShowState;\r
 896 \r
 897         GLfloat material[4], identity[4];\r
 898         VectorSet(identity, 0.8f, 0.8f, 0.8f);\r
 899         IShader *pShader;\r
 900 \r
 901   // lights\r
 902   if (b->owner->eclass->fixedsize && b->owner->eclass->nShowFlags & ECLASS_LIGHT && g_PrefsDlg.m_bNewLightDraw)\r
 903   {\r
 904                 switch (mode)\r
 905                 {\r
 906                 case DRAW_SOLID:\r
 907                   VectorCopy(b->owner->color, material);\r
 908                         VectorScale(material, 0.8f, material);\r
 909       material[3] = 1.0f;\r
 910 \r
 911       qglColor4fv(material);\r
 912                                 \r
 913       if (g_PrefsDlg.m_bNewLightDraw)\r
 914         DrawLight(b->owner, nGLState, (IsBrushSelected(b)) ? g_PrefsDlg.m_nLightRadiuses : 0, 0);\r
 915 \r
 916                         break;\r
 917                 }\r
 918   }\r
 919 \r
 920   // models\r
 921   else if(b->owner->eclass->fixedsize && b->owner->model.pRender\r
 922     && !(!IsBrushSelected(b) && (nModelMode & ENTITY_SELECTED_ONLY)))\r
 923   {\r
 924     switch (mode)\r
 925                 {\r
 926                 case DRAW_TEXTURED:\r
 927                         if (!(nModelMode & ENTITY_WIREFRAME) && nModelMode != ENTITY_BOX)\r
 928                         {\r
 929                                 VectorCopy(b->owner->eclass->color, material);\r
 930                                 material[3] = identity[3] = 1.0f;\r
 931 \r
 932                                 qglEnable(GL_CULL_FACE);\r
 933 \r
 934                                 if(!(nGLState & DRAW_GL_TEXTURE_2D)) qglColor4fv(material);\r
 935         else qglColor4fv(identity);\r
 936                                 if(nGLState & DRAW_GL_LIGHTING) qglShadeModel(GL_SMOOTH);\r
 937                                 \r
 938                                 b->owner->model.pRender->Draw(nGLState, DRAW_RF_CAM);\r
 939                         }\r
 940                         break;\r
 941                 case DRAW_WIRE:\r
 942       VectorCopy(b->owner->eclass->color, material);\r
 943                   material[3] = 1.0f;\r
 944                   qglColor4fv(material);\r
 945 \r
 946                         // model view mode "wireframe" or "selected wire"\r
 947                         if(nModelMode & ENTITY_WIREFRAME)\r
 948                                 b->owner->model.pRender->Draw(nGLState, DRAW_RF_CAM);\r
 949 \r
 950                         // model view mode "skinned and boxed"\r
 951       if(!(b->owner->eclass->nShowFlags & ECLASS_MISCMODEL) )\r
 952       {\r
 953                     qglColor4fv(material);\r
 954         aabb_draw(b->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);\r
 955       }\r
 956       else if(nModelMode & ENTITY_BOXED)\r
 957       {\r
 958                                 aabb_draw(b->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);\r
 959       }\r
 960 /*\r
 961       if(!(nModelMode & ENTITY_BOXED) && b->owner->eclass->nShowFlags & ECLASS_MISCMODEL)\r
 962                           DrawModelOrigin(b);\r
 963 */\r
 964                 }\r
 965   }\r
 966 \r
 967   // patches\r
 968   else if (b->patchBrush)\r
 969   {\r
 970                 bool bTrans = (b->pPatch->pShader->getTrans() < 1.0f);\r
 971                 switch(mode)\r
 972                 {\r
 973                 case DRAW_TEXTURED:\r
 974                         if (!g_bPatchWireFrame && ((nGLState & DRAW_GL_BLEND && bTrans) || (!(nGLState & DRAW_GL_BLEND) && !bTrans)))\r
 975                         {\r
 976                                 qglDisable(GL_CULL_FACE);\r
 977 \r
 978                                 pShader = b->pPatch->pShader;\r
 979         VectorCopy(pShader->getTexture()->color, material);\r
 980                                 material[3] = identity[3] = pShader->getTrans();\r
 981 \r
 982         if(nGLState & DRAW_GL_TEXTURE_2D) {\r
 983           qglColor4fv(identity);\r
 984                                         qglBindTexture(GL_TEXTURE_2D, pShader->getTexture()->texture_number);\r
 985         }\r
 986                                 else\r
 987                                         qglColor4fv(material);\r
 988                                 if(nGLState & DRAW_GL_LIGHTING) qglShadeModel(GL_SMOOTH);\r
 989 \r
 990                                 DrawPatchMesh(b->pPatch);\r
 991                         }\r
 992                         break;\r
 993                 case DRAW_WIRE:\r
 994       if (g_bPatchWireFrame)\r
 995       {\r
 996         VectorCopy(b->pPatch->pShader->getTexture()->color, material);\r
 997                                 material[3] = 1.0;\r
 998         qglColor4fv(material);\r
 999         DrawPatchMesh(b->pPatch);\r
1000       }\r
1001       if ( b->pPatch->bSelected && (g_qeglobals.d_select_mode == sel_curvepoint\r
1002         || g_qeglobals.d_select_mode == sel_area\r
1003         || g_bPatchBendMode))\r
1004         DrawPatchControls(b->pPatch);\r
1005     }\r
1006   }\r
1007 \r
1008   // brushes\r
1009   else if(b->owner->eclass->fixedsize)\r
1010   {\r
1011                 switch(mode)\r
1012                 {\r
1013     case DRAW_SOLID:\r
1014                         VectorCopy(b->owner->eclass->color, material);\r
1015                         VectorScale(material, 0.8f, material);\r
1016       material[3] = 1.0f;\r
1017       qglColor4fv(material);\r
1018 \r
1019                         qglEnable(GL_CULL_FACE);\r
1020                         qglShadeModel(GL_FLAT);\r
1021       Brush_Draw(b);\r
1022       break;\r
1023     case DRAW_WIRE:\r
1024                         if((g_qeglobals.d_savedinfo.include & INCLUDE_ANGLES)\r
1025       && (b->owner->eclass->nShowFlags & ECLASS_ANGLE))\r
1026                                 Brush_DrawFacingAngle(b, b->owner);\r
1027     }\r
1028   } \r
1029 \r
1030   // brushes\r
1031   else\r
1032   {\r
1033                 switch(mode)\r
1034                 {\r
1035                 case DRAW_TEXTURED:\r
1036                         qglEnable(GL_CULL_FACE);\r
1037                         qglShadeModel(GL_FLAT);\r
1038       Brush_Draw(b);\r
1039     }\r
1040   } \r
1041 }\r
1042 \r
1043 void CamWnd::Cam_DrawBrushes(int mode)\r
1044 {\r
1045   brush_t *b;\r
1046   brush_t *pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;\r
1047   \r
1048   for(b = active_brushes.next; b != &active_brushes; b=b->next)\r
1049     if (!b->bFiltered && !b->bCamCulled) Cam_DrawBrush(b, mode);\r
1050   for(b = pList->next; b != pList; b=b->next)\r
1051     if (!b->bFiltered && !b->bCamCulled) Cam_DrawBrush(b, mode);\r
1052 }\r
1053 \r
1054 void CamWnd::Cam_DrawStuff()\r
1055 {\r
1056         GLfloat identity[4];\r
1057         VectorSet(identity, 0.8f, 0.8f, 0.8f);\r
1058         brush_t *b;\r
1059 \r
1060   for(b = active_brushes.next; b != &active_brushes; b=b->next)\r
1061     b->bCamCulled = CullBrush(b);\r
1062 \r
1063         for(b = selected_brushes.next; b != &selected_brushes; b=b->next)\r
1064     b->bCamCulled = CullBrush(b);\r
1065 \r
1066         switch (m_Camera.draw_mode)\r
1067   {\r
1068   case cd_wire:\r
1069     qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);\r
1070     qglDisable(GL_TEXTURE_2D);\r
1071     qglDisable(GL_TEXTURE_1D);\r
1072     qglDisable(GL_BLEND);\r
1073     qglEnable(GL_DEPTH_TEST);\r
1074                 qglEnableClientState(GL_VERTEX_ARRAY);\r
1075                 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);\r
1076                 qglShadeModel(GL_FLAT);\r
1077                 if(g_PrefsDlg.m_bGLLighting) {\r
1078       qglDisable(GL_LIGHTING);\r
1079                   qglDisable(GL_COLOR_MATERIAL);\r
1080                 qglDisableClientState(GL_NORMAL_ARRAY);\r
1081     }\r
1082                 m_Camera.draw_glstate = DRAW_GL_WIRE;\r
1083     break;\r
1084 \r
1085   case cd_solid:\r
1086     qglCullFace(GL_FRONT);\r
1087     qglEnable(GL_CULL_FACE);\r
1088     qglShadeModel (GL_FLAT);\r
1089     qglPolygonMode (GL_FRONT, GL_LINE);\r
1090     qglPolygonMode (GL_BACK, GL_FILL);\r
1091     qglDisable(GL_TEXTURE_2D);\r
1092     qglDisable(GL_BLEND);\r
1093     qglEnable(GL_DEPTH_TEST);\r
1094                 qglEnableClientState(GL_VERTEX_ARRAY);\r
1095                 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);\r
1096                 qglPolygonOffset(-1.0, 2);\r
1097                 if(g_PrefsDlg.m_bGLLighting) {\r
1098       qglEnable(GL_LIGHTING);\r
1099                   qglEnable(GL_COLOR_MATERIAL);\r
1100 //    qglEnable(GL_RESCALE_NORMAL);\r
1101                   qglEnableClientState(GL_NORMAL_ARRAY);\r
1102     }\r
1103                 m_Camera.draw_glstate = DRAW_GL_SOLID;\r
1104     break;\r
1105 \r
1106   case cd_texture:\r
1107     qglCullFace(GL_FRONT);\r
1108     qglEnable(GL_CULL_FACE);\r
1109     qglShadeModel (GL_FLAT);\r
1110     qglPolygonMode (GL_FRONT, GL_LINE);\r
1111     qglPolygonMode (GL_BACK, GL_FILL);\r
1112     qglEnable(GL_TEXTURE_2D);\r
1113     qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
1114     qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);\r
1115     qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);\r
1116     qglDisable(GL_BLEND);\r
1117     qglEnable(GL_DEPTH_TEST);\r
1118                 qglEnableClientState(GL_VERTEX_ARRAY);\r
1119                 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);\r
1120                 if(g_PrefsDlg.m_bGLLighting) {\r
1121       qglEnable(GL_LIGHTING);\r
1122                   qglDisable(GL_COLOR_MATERIAL);\r
1123                   qglMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, identity);\r
1124                   qglEnableClientState(GL_NORMAL_ARRAY);\r
1125 //    qglEnable(GL_RESCALE_NORMAL);\r
1126     }\r
1127                 qglPolygonOffset(-1.0, 2);\r
1128                 m_Camera.draw_glstate = DRAW_GL_TEXTURED;\r
1129     break;\r
1130 \r
1131         default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");\r
1132   }\r
1133 \r
1134   Cam_DrawBrushes(DRAW_TEXTURED);\r
1135 \r
1136         // setup for solid stuff\r
1137         switch(m_Camera.draw_mode)\r
1138         {\r
1139                 case cd_texture:\r
1140                         qglDisable(GL_TEXTURE_2D);\r
1141                         m_Camera.draw_glstate &= ~DRAW_GL_TEXTURE_2D;\r
1142                   if(g_PrefsDlg.m_bGLLighting)\r
1143                           qglEnable(GL_COLOR_MATERIAL);\r
1144                         qglDisableClientState(GL_TEXTURE_COORD_ARRAY);\r
1145                         break;\r
1146                 case cd_solid:\r
1147                         break;\r
1148                 case cd_wire:\r
1149                         break;\r
1150                 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");\r
1151         }\r
1152 \r
1153         qglEnable(GL_CULL_FACE);\r
1154         qglShadeModel(GL_FLAT);\r
1155         Cam_DrawBrushes(DRAW_SOLID);\r
1156 \r
1157         // setup for wireframe stuff\r
1158         switch(m_Camera.draw_mode)\r
1159         {\r
1160                 case cd_texture:\r
1161       if(g_PrefsDlg.m_bGLLighting) {\r
1162                           qglDisable(GL_LIGHTING);\r
1163         qglDisable(GL_COLOR_MATERIAL);\r
1164                           qglDisableClientState(GL_NORMAL_ARRAY);\r
1165 //      qglDisable(GL_RESCALE_NORMAL);\r
1166       }\r
1167                         qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);\r
1168                         break;\r
1169                 case cd_solid:\r
1170       if(g_PrefsDlg.m_bGLLighting) {\r
1171         qglDisable(GL_LIGHTING);\r
1172                           qglDisable(GL_COLOR_MATERIAL);\r
1173                           qglDisableClientState(GL_NORMAL_ARRAY);\r
1174 //      qglDisable(GL_RESCALE_NORMAL);\r
1175       }\r
1176                         qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);\r
1177                         break;\r
1178                 case cd_wire:\r
1179                         break;\r
1180                 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");\r
1181         }\r
1182         \r
1183   qglDisable(GL_CULL_FACE);\r
1184   Cam_DrawBrushes(DRAW_WIRE);\r
1185 \r
1186         // setup for transparent texture stuff\r
1187         switch(m_Camera.draw_mode)\r
1188         {\r
1189                 case cd_texture:\r
1190                         qglPolygonMode (GL_FRONT, GL_LINE);\r
1191                         qglPolygonMode (GL_BACK, GL_FILL);\r
1192       if(g_PrefsDlg.m_bGLLighting) {\r
1193                           qglEnable(GL_COLOR_MATERIAL);\r
1194                           qglEnableClientState(GL_NORMAL_ARRAY);\r
1195                           qglMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, identity);\r
1196       }\r
1197                         qglEnable(GL_TEXTURE_2D);\r
1198                         qglEnableClientState(GL_TEXTURE_COORD_ARRAY);\r
1199                         m_Camera.draw_glstate = DRAW_GL_TEXTURED;\r
1200                         break;\r
1201                 case cd_solid:\r
1202                         qglPolygonMode (GL_FRONT, GL_LINE);\r
1203                         qglPolygonMode (GL_BACK, GL_FILL);\r
1204       if(g_PrefsDlg.m_bGLLighting) {\r
1205                           qglEnable(GL_LIGHTING);\r
1206                           qglEnable(GL_COLOR_MATERIAL);\r
1207                           qglEnableClientState(GL_NORMAL_ARRAY);\r
1208 //      qglEnable(GL_RESCALE_NORMAL);\r
1209       }\r
1210                         m_Camera.draw_glstate = DRAW_GL_SOLID;\r
1211                         break;\r
1212                 case cd_wire:\r
1213                         m_Camera.draw_glstate = DRAW_GL_WIRE;\r
1214                         break;\r
1215                 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");\r
1216         }       \r
1217 \r
1218 \r
1219         qglEnable(GL_BLEND);\r
1220         m_Camera.draw_glstate |= DRAW_GL_BLEND;\r
1221   qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
1222   // FIXME: some .TGA are buggy, have a completely empty alpha channel\r
1223   // if such brushes are rendered in this loop they would be totally transparent with GL_MODULATE\r
1224   // so I decided using GL_DECAL instead\r
1225   // if an empty-alpha-channel or nearly-empty texture is used. It will be blank-transparent.\r
1226   // this could get better if you can get qglTexEnviv (GL_TEXTURE_ENV, to work .. patches are welcome\r
1227   // Arnout: empty alpha channels are now always filled with data. Don't set this anymore (would cause problems with qer_alphafunc too)\r
1228 //  qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);\r
1229 \r
1230         Cam_DrawBrushes(DRAW_TEXTURED);\r
1231 \r
1232 //  qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
1233   qglDisable(GL_BLEND);\r
1234 \r
1235         // setup for wireframe stuff\r
1236         switch(m_Camera.draw_mode)\r
1237         {\r
1238                 case cd_texture:\r
1239       if(g_PrefsDlg.m_bGLLighting) {\r
1240                           qglDisable(GL_COLOR_MATERIAL);\r
1241         qglDisable(GL_LIGHTING);\r
1242 //      qglDisable(GL_RESCALE_NORMAL);\r
1243       }\r
1244                         break;\r
1245                 case cd_solid:\r
1246       if(g_PrefsDlg.m_bGLLighting) {\r
1247                           qglDisable(GL_COLOR_MATERIAL);\r
1248         qglDisable(GL_LIGHTING);\r
1249 //      qglDisable(GL_RESCALE_NORMAL);\r
1250       }\r
1251                         break;\r
1252                 case cd_wire:\r
1253                         break;\r
1254                 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");\r
1255         }\r
1256 \r
1257 }\r
1258 \r
1259 /*\r
1260 ==============\r
1261 Cam_Draw\r
1262 ==============\r
1263 */\r
1264 \r
1265 void QueueClear ();\r
1266 void QueueDraw ();\r
1267 \r
1268 void CamWnd::Cam_Draw()\r
1269 {\r
1270   brush_t       *brush;\r
1271   face_t        *face;\r
1272   float screenaspect;\r
1273   float yfov;\r
1274   double        start, end;\r
1275   int           i;\r
1276 \r
1277   if (!active_brushes.next)\r
1278     return;     // not valid yet\r
1279 \r
1280   if (m_Camera.timing)\r
1281     start = Sys_DoubleTime ();\r
1282 \r
1283   //\r
1284   // clear\r
1285   //\r
1286   QE_CheckOpenGLForErrors();\r
1287 \r
1288   qglViewport(0, 0, m_Camera.width, m_Camera.height);\r
1289   qglClearColor (g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][0],\r
1290                  g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][1],\r
1291                  g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][2], 0);\r
1292   qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);\r
1293 \r
1294   //\r
1295   // set up viewpoint\r
1296   //\r
1297   \r
1298 \r
1299   qglMatrixMode(GL_PROJECTION);\r
1300   qglLoadIdentity ();\r
1301 \r
1302   screenaspect = (float)m_Camera.width / m_Camera.height;\r
1303   yfov = 2*atan((float)m_Camera.height / m_Camera.width)*180/Q_PI;\r
1304   qgluPerspective (yfov,  screenaspect,  8,  32768);\r
1305 \r
1306   // we're too lazy to calc projection matrix ourselves!!!\r
1307   qglGetFloatv (GL_PROJECTION_MATRIX, &m_Camera.projection[0][0]);\r
1308 \r
1309   vec3_t vec;\r
1310 \r
1311   m4x4_identity(&m_Camera.modelview[0][0]);\r
1312   VectorSet(vec, -90, 0, 0);\r
1313   m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);\r
1314   VectorSet(vec, 0, 0, 90);\r
1315   m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);\r
1316   VectorSet(vec, 0, m_Camera.angles[0], 0);\r
1317   m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);\r
1318   VectorSet(vec, 0, 0, -m_Camera.angles[1]);\r
1319   m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);\r
1320   VectorSet(vec, -m_Camera.origin[0],  -m_Camera.origin[1],  -m_Camera.origin[2]);\r
1321   m4x4_translate_by_vec3(&m_Camera.modelview[0][0], vec);\r
1322 \r
1323   Cam_BuildMatrix ();\r
1324 \r
1325   qglMatrixMode(GL_MODELVIEW);\r
1326   qglLoadIdentity();\r
1327 \r
1328   qglMultMatrixf(&m_Camera.modelview[0][0]);\r
1329         \r
1330   // grab the GL_PROJECTION and GL_MODELVIEW matrixes\r
1331   //   used in GetRelativeAxes\r
1332   //qglGetFloatv (GL_PROJECTION_MATRIX, &m_Camera.projection[0][0]);\r
1333   //qglGetFloatv (GL_MODELVIEW_MATRIX, &m_Camera.modelview[0][0]);\r
1334 \r
1335 #if 0\r
1336   // TTimo: this is not used, just for verification (0, 0, m_Camera.width, m_Camera.height)\r
1337   GLint viewprt[4];\r
1338   qglGetIntegerv (GL_VIEWPORT, viewprt);\r
1339 #endif\r
1340 \r
1341   if (g_PrefsDlg.m_bGLLighting)\r
1342   {\r
1343     GLfloat inverse_cam_dir[4], ambient[4], diffuse[4];//, material[4];\r
1344 \r
1345     ambient[0] = ambient[1] = ambient[2] = 0.6f;\r
1346     ambient[3] = 1.0f;\r
1347     diffuse[0] = diffuse[1] = diffuse[2] = 0.4f;\r
1348     diffuse[3] = 1.0f;\r
1349     //material[0] = material[1] = material[2] = 0.8f;\r
1350     //material[3] = 1.0f;\r
1351     \r
1352     vec3_t vCam, vRotate;\r
1353     VectorSet(vCam, -1, 0, 0); //default cam pos\r
1354     VectorSet(vRotate, 0, -m_Camera.angles[0], 0);\r
1355     VectorRotate(vCam, vRotate, vCam);\r
1356     VectorSet(vRotate, 0, 0, m_Camera.angles[1]);\r
1357     VectorRotate(vCam, vRotate, vCam);\r
1358     \r
1359     inverse_cam_dir[0] = vCam[0];\r
1360     inverse_cam_dir[1] = vCam[1];\r
1361     inverse_cam_dir[2] = vCam[2];\r
1362     inverse_cam_dir[3] = 0;\r
1363 \r
1364     qglColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);\r
1365 \r
1366     qglLightfv(GL_LIGHT0, GL_POSITION, inverse_cam_dir);\r
1367 \r
1368     qglLightfv(GL_LIGHT0, GL_AMBIENT, ambient);\r
1369     qglLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);\r
1370 \r
1371     qglEnable(GL_LIGHT0);\r
1372   }\r
1373 \r
1374   InitCull ();\r
1375 \r
1376   //\r
1377   // draw stuff\r
1378   //\r
1379 \r
1380         Cam_DrawStuff();\r
1381   \r
1382         qglEnableClientState(GL_VERTEX_ARRAY);\r
1383         qglDisableClientState(GL_NORMAL_ARRAY);\r
1384         qglDisableClientState(GL_TEXTURE_COORD_ARRAY);\r
1385         qglDisable (GL_TEXTURE_2D);\r
1386         qglDisable (GL_LIGHTING);\r
1387         qglDisable (GL_COLOR_MATERIAL);\r
1388 \r
1389   qglEnable (GL_CULL_FACE);\r
1390 \r
1391   brush_t* pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;\r
1392 \r
1393   if (g_qeglobals.d_savedinfo.iSelectedOutlinesStyle & OUTLINE_BSEL)\r
1394   {\r
1395     qglColor4f(g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES3D][0], g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES3D][1], g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES3D][2], 0.3f);\r
1396     qglEnable (GL_BLEND);\r
1397     qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
1398     qglDepthFunc (GL_LEQUAL);\r
1399     for (brush = pList->next ; brush != pList ; brush=brush->next)\r
1400     {\r
1401       if (brush->bCamCulled) // draw selected faces of filtered brushes to remind that there is a selection\r
1402         continue;\r
1403 \r
1404       if (brush->patchBrush && (g_qeglobals.d_select_mode == sel_curvepoint || g_qeglobals.d_select_mode == sel_area))\r
1405         continue;\r
1406 \r
1407       if (!g_PrefsDlg.m_bPatchBBoxSelect && brush->patchBrush)\r
1408       {\r
1409         DrawPatchMesh(brush->pPatch);\r
1410       }\r
1411       else if(brush->owner->model.pRender && g_PrefsDlg.m_nEntityShowState != ENTITY_BOX)\r
1412       {\r
1413         brush->owner->model.pRender->Draw(DRAW_GL_FLAT, (DRAW_RF_SEL_OUTLINE|DRAW_RF_CAM));\r
1414       }\r
1415       else\r
1416       {\r
1417         for (face=brush->brush_faces ; face ; face=face->next)\r
1418           Brush_FaceDraw(face, DRAW_GL_FLAT);\r
1419       }\r
1420     }\r
1421     \r
1422 \r
1423     int nCount = g_ptrSelectedFaces.GetSize();\r
1424     if (nCount > 0)\r
1425     {\r
1426       for (int i = 0; i < nCount; i++)\r
1427       {\r
1428         face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));\r
1429         Brush_FaceDraw(selFace, DRAW_GL_FLAT);\r
1430       }\r
1431     }\r
1432 \r
1433     qglDisableClientState(GL_NORMAL_ARRAY);\r
1434           qglDepthFunc (GL_LESS);\r
1435   }\r
1436   \r
1437   if (g_qeglobals.d_savedinfo.iSelectedOutlinesStyle & OUTLINE_ZBUF)\r
1438   {\r
1439     // non-zbuffered outline\r
1440     qglDisable (GL_BLEND);\r
1441     qglDisable (GL_DEPTH_TEST);\r
1442     qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);\r
1443     qglColor3f (1, 1, 1);\r
1444     for (brush = pList->next ; brush != pList ; brush=brush->next)\r
1445     {\r
1446       if ((brush->patchBrush && (g_qeglobals.d_select_mode == sel_curvepoint || g_qeglobals.d_select_mode == sel_area)))\r
1447         continue;\r
1448 \r
1449       if (!g_PrefsDlg.m_bPatchBBoxSelect && brush->patchBrush)\r
1450       {\r
1451         DrawPatchMesh(brush->pPatch);\r
1452       }\r
1453       else if(brush->owner->model.pRender && g_PrefsDlg.m_nEntityShowState != ENTITY_BOX)\r
1454       {\r
1455         brush->owner->model.pRender->Draw(DRAW_GL_WIRE, (DRAW_RF_SEL_FILL|DRAW_RF_CAM));\r
1456 \r
1457         // Hydra : always draw bbox outline!\r
1458         aabb_draw(brush->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);\r
1459       }\r
1460       else\r
1461       {\r
1462         for (face=brush->brush_faces ; face ; face=face->next)\r
1463           Brush_FaceDraw(face, DRAW_GL_WIRE);\r
1464       }\r
1465     }\r
1466   }\r
1467 \r
1468   // edge / vertex flags\r
1469   if (g_qeglobals.d_select_mode == sel_vertex)\r
1470   {\r
1471     // GL_POINTS on Kyro Workaround\r
1472     if(!g_PrefsDlg.m_bGlPtWorkaround) \r
1473     {\r
1474       // brush verts\r
1475       qglPointSize (4);\r
1476                 qglColor3f (0,1,0);\r
1477       qglBegin (GL_POINTS);\r
1478         for (i=0 ; i<g_qeglobals.d_numpoints ; i++)\r
1479           qglVertex3fv (g_qeglobals.d_points[i]);\r
1480       qglEnd ();\r
1481      \r
1482       if(g_qeglobals.d_num_move_points)\r
1483       {\r
1484         // selected brush verts\r
1485         qglPointSize (5);\r
1486         qglColor3f (0,0,1);\r
1487         qglBegin (GL_POINTS);\r
1488           for(i = 0; i < g_qeglobals.d_num_move_points; i++)\r
1489             qglVertex3fv (g_qeglobals.d_move_points[i]);\r
1490         qglEnd();\r
1491       }\r
1492         \r
1493       qglPointSize (1);\r
1494     }\r
1495     else\r
1496     {\r
1497       // brush verts\r
1498       qglColor3f (0,1,0);\r
1499       qglLineWidth(2.0);\r
1500       qglBegin (GL_LINES);\r
1501         for (i=0; i < g_qeglobals.d_numpoints; i++)\r
1502           DrawAlternatePoint(g_qeglobals.d_points[i], 1.5);\r
1503       qglEnd();\r
1504       \r
1505       if(g_qeglobals.d_num_move_points)\r
1506       {\r
1507         // selected brush verts\r
1508         qglColor3f (0,0,1);\r
1509         qglLineWidth (3.0);\r
1510         qglBegin (GL_LINES);\r
1511           for(i = 0; i < g_qeglobals.d_num_move_points; i++)\r
1512             qglVertex3fv (g_qeglobals.d_move_points[i]);\r
1513         qglEnd();\r
1514       }\r
1515       qglLineWidth(1.0);\r
1516     }\r
1517   }\r
1518   else if (g_qeglobals.d_select_mode == sel_edge)\r
1519   {\r
1520     float       *v1, *v2;\r
1521     // GL_POINTS on Kyro Workaround\r
1522     if(!g_PrefsDlg.m_bGlPtWorkaround) \r
1523     {\r
1524       qglPointSize (4);\r
1525       qglColor3f (0,0,1);\r
1526       qglBegin (GL_POINTS);\r
1527       for (i=0 ; i<g_qeglobals.d_numedges ; i++)\r
1528       {\r
1529         v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1];\r
1530         v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2];\r
1531         qglVertex3f ( (v1[0]+v2[0])*0.5,(v1[1]+v2[1])*0.5,(v1[2]+v2[2])*0.5);\r
1532       }\r
1533       qglEnd ();\r
1534       qglPointSize (1);\r
1535     }\r
1536     else {\r
1537       qglColor3f (0,0,1);\r
1538       qglLineWidth(2.0);\r
1539       qglBegin (GL_LINES);\r
1540       for (i=0; i < g_qeglobals.d_numedges; i++)\r
1541       {\r
1542         v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1];\r
1543         v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2];\r
1544         vec3_t v3;\r
1545         v3[0] = (v1[0]+v2[0])*0.5;\r
1546         v3[1] = (v1[1]+v2[1])*0.5;\r
1547         v3[2] = (v1[2]+v2[2])*0.5;\r
1548         DrawAlternatePoint(v3, 1.5);\r
1549       }\r
1550       qglEnd();\r
1551       qglLineWidth(1.0);\r
1552     }\r
1553   }\r
1554 \r
1555   //\r
1556   // draw pointfile\r
1557   //\r
1558   qglEnable(GL_DEPTH_TEST);\r
1559   DrawPathLines();\r
1560 \r
1561   if (g_qeglobals.d_pointfile_display_list)\r
1562   {\r
1563     Pointfile_Draw();\r
1564   }\r
1565 \r
1566   // call the drawing routine of plugin entities\r
1567   //++timo FIXME: we might need to hook in other places as well for transparency etc.\r
1568   //++timo FIXME: also needs a way to get some parameters about the view\r
1569   //++timo FIXME: maybe provide some culling API on Radiant side?\r
1570   Draw3DPluginEntities();\r
1571 \r
1572   // draw the crosshair\r
1573   if (m_bFreeMove)\r
1574   {\r
1575     // setup orthographic projection mode\r
1576     qglMatrixMode(GL_PROJECTION);\r
1577     //qglPushMatrix();\r
1578     qglLoadIdentity();\r
1579     qglDisable(GL_DEPTH_TEST);\r
1580     qglOrtho(0, (float)m_Camera.width, 0, (float)m_Camera.height, -100, 100);\r
1581     qglScalef(1, -1, 1);\r
1582           qglTranslatef(0, -(float)m_Camera.height, 0);\r
1583           qglMatrixMode(GL_MODELVIEW);\r
1584 \r
1585     // draw crosshair\r
1586     //qglPushMatrix();\r
1587           qglLoadIdentity();\r
1588     qglColor3f( 1.f, 1.f, 1.f );\r
1589     qglBegin( GL_LINES );\r
1590     qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f + 6 );\r
1591     qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f + 2 );\r
1592     qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f - 6 );\r
1593     qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f - 2 );\r
1594     qglVertex2f( (float)m_Camera.width / 2.f + 6, (float)m_Camera.height / 2.f );\r
1595     qglVertex2f( (float)m_Camera.width / 2.f + 2, (float)m_Camera.height / 2.f );\r
1596     qglVertex2f( (float)m_Camera.width / 2.f - 6, (float)m_Camera.height / 2.f );\r
1597     qglVertex2f( (float)m_Camera.width / 2.f - 2, (float)m_Camera.height / 2.f );\r
1598     qglEnd();\r
1599     //qglPopMatrix();\r
1600 \r
1601     // reset perspective projection\r
1602           //qglMatrixMode(GL_PROJECTION);\r
1603           //qglPopMatrix();\r
1604           //qglMatrixMode(GL_MODELVIEW);\r
1605   }\r
1606 \r
1607 #if 0\r
1608         if ((g_qeglobals.d_select_mode == sel_area) && (g_nPatchClickedView == W_CAMERA))\r
1609         {\r
1610                 // setup orthographic projection mode\r
1611                 qglMatrixMode(GL_PROJECTION);\r
1612                 //qglPushMatrix();\r
1613                 qglLoadIdentity();\r
1614                 qglDisable(GL_DEPTH_TEST);\r
1615                 qglOrtho(0, (float)m_Camera.width, 0, (float)m_Camera.height, -100, 100);\r
1616                 //qglScalef(1, -1, 1);\r
1617                 //qglTranslatef(0, -(float)m_Camera.height, 0);\r
1618                 qglMatrixMode(GL_MODELVIEW);\r
1619 \r
1620         // area selection hack\r
1621                 qglLoadIdentity();\r
1622                 qglDisable(GL_CULL_FACE);\r
1623                 qglEnable (GL_BLEND);\r
1624                 qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);\r
1625                 qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
1626                 qglColor4f(0.0, 0.0, 1.0, 0.25);\r
1627                 qglRectf(g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[0], g_qeglobals.d_vAreaBR[1]);\r
1628                 qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);\r
1629                 qglDisable (GL_BLEND);\r
1630                 qglEnable (GL_CULL_FACE);\r
1631         }\r
1632 #endif\r
1633 \r
1634   // bind back to the default texture so that we don't have problems\r
1635   // elsewhere using/modifying texture maps between contexts\r
1636   qglBindTexture( GL_TEXTURE_2D, 0 );\r
1637 \r
1638   qglFinish();\r
1639   QE_CheckOpenGLForErrors();\r
1640   //    Sys_EndWait();\r
1641   if (m_Camera.timing)\r
1642   {\r
1643     end = Sys_DoubleTime ();\r
1644     Sys_Printf ("Camera: %i ms\n", (int)(1000*(end-start)));\r
1645   }\r
1646 \r
1647   for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next)\r
1648     brush->bCamCulled = false;\r
1649 \r
1650   for (brush = pList->next ; brush != pList ; brush=brush->next)\r
1651     brush->bCamCulled = false;\r
1652 }\r
1653 \r
1654 void CamWnd::OnExpose () \r
1655 {\r
1656   if (!MakeCurrent ())\r
1657   {\r
1658     Sys_Printf("ERROR: glXMakeCurrent failed..\n ");\r
1659     Sys_Printf("Please restart Radiant if the camera view is not working\n");\r
1660   }\r
1661   else\r
1662   {\r
1663     QE_CheckOpenGLForErrors();\r
1664     g_pSplitList = NULL;\r
1665     if (g_bClipMode)\r
1666     {\r
1667       if (g_Clip1.Set() && g_Clip2.Set())\r
1668       {\r
1669         g_pSplitList = (g_bSwitch) ? \r
1670           &g_brBackSplits : &g_brFrontSplits;\r
1671       }\r
1672     }\r
1673 \r
1674     Patch_LODMatchAll(); // spog  \r
1675 \r
1676     Cam_Draw ();\r
1677     QE_CheckOpenGLForErrors ();\r
1678 \r
1679     m_XORRectangle.set(rectangle_t());\r
1680     SwapBuffers ();\r
1681   }\r
1682 }\r
1683 \r
1684 void CamWnd::BenchMark()\r
1685 {\r
1686   if (!MakeCurrent ())\r
1687     Error ("glXMakeCurrent failed in Benchmark");\r
1688   \r
1689   qglDrawBuffer (GL_FRONT);\r
1690   double dStart = Sys_DoubleTime ();\r
1691   for (int i=0 ; i < 100 ; i++)\r
1692   {\r
1693     m_Camera.angles[YAW] = i*4;\r
1694     Cam_Draw();\r
1695   }\r
1696   SwapBuffers ();\r
1697   qglDrawBuffer (GL_BACK);\r
1698   double dEnd = Sys_DoubleTime ();\r
1699   Sys_Printf ("%5.2f seconds\n", dEnd - dStart);\r
1700 }\r