radiant/camwindow.cpp

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