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