2 Copyright (C) 1999-2007 id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
5 This file is part of GtkRadiant.
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.
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.
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
25 // Leonardo Zide (leo@lokigames.com)
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);
38 extern int g_nPatchClickedView;
40 brush_t* g_pSplitList = NULL;
42 // =============================================================================
46 : GLWindow (TRUE), m_XORRectangle(m_pWidget)
48 m_nNumTransBrushes = 0;
49 memset(&m_Camera, 0, sizeof(camera_t));
50 m_pSide_select = NULL;
60 void CamWnd::OnCreate ()
63 Error ("glMakeCurrent failed");
65 // report OpenGL information
66 Sys_Printf ("GL_VENDOR: %s\n", qglGetString (GL_VENDOR));
67 Sys_Printf ("GL_RENDERER: %s\n", qglGetString (GL_RENDERER));
68 Sys_Printf ("GL_VERSION: %s\n", qglGetString (GL_VERSION));
69 Sys_Printf ("GL_EXTENSIONS: %s\n", qglGetString (GL_EXTENSIONS));
71 // Set off texture compression supported
72 g_qeglobals.bTextureCompressionSupported = 0;
74 // finalize OpenGL init
76 // why is this here? well .. the Gtk objects get constructed when you enter gtk_main
77 // and I wanted to have the extensions information in the editor startup console (avoid looking that up in the early console)
79 // I Split this up so as to add support for extension and user-friendly
80 // compression format selection.
81 // ADD new globals for your new format so as to minimise
82 // calls to Sys_QGL_ExtensionSupported
83 // NOTE TTimo: I don't really like this approach with globals. Frequent calls to Sys_QGL_ExtensionSupported don't sound like
84 // a problem to me. If there is some caching to be done, then I think it should be inside Sys_QGL_ExtensionSupported
85 ///////////////////////////////////////////
86 // Check for default OpenGL
87 if (Sys_QGL_ExtensionSupported ("GL_ARB_texture_compression"))
89 g_qeglobals.bTextureCompressionSupported = 1;
90 g_qeglobals.m_bOpenGLCompressionSupported = 1;
93 // INSERT PROPRIETARY EXTENSIONS HERE
94 // Check for S3 extensions
95 // create a bool global for extension supported
96 if (Sys_QGL_ExtensionSupported ("GL_EXT_texture_compression_s3tc"))
98 g_qeglobals.bTextureCompressionSupported = 1;
99 g_qeglobals.m_bS3CompressionSupported = 1;
102 g_qeglobals.m_bOpenGLReady = true;
104 g_PrefsDlg.UpdateTextureCompression();
107 g_PrefsDlg.UpdateATIHack();
110 g_qeglobals_gui.d_camera = m_pWidget;
113 void CamWnd::Cam_Init ()
115 m_Camera.timing = false;
116 m_Camera.origin[0] = 0.f;
117 m_Camera.origin[1] = 20.f;
118 m_Camera.origin[2] = 46.f;
119 m_Camera.color[0] = 0.3f;
120 m_Camera.color[1] = 0.3f;
121 m_Camera.color[2] = 0.3f;
122 m_nCambuttonstate = 0;
125 void CamWnd::OnSize(int cx, int cy)
128 m_Camera.height = cy;
129 gtk_widget_queue_draw(m_pWidget);
132 rectangle_t rectangle_from_area_cam()
134 const float left = MIN(g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaBR[0]);
135 const float top = MAX(g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[1]);
136 const float right = MAX(g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaBR[0]);
137 const float bottom = MIN(g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[1]);
138 return rectangle_t(left, bottom, right - left, top - bottom);
141 void update_xor_rectangle(XORRectangle& xor_rectangle)
143 rectangle_t rectangle;
144 if ((g_qeglobals.d_select_mode == sel_area))
145 rectangle = rectangle_from_area_cam();
146 xor_rectangle.set(rectangle);
149 void CamWnd::OnMouseMove(guint32 flags, int pointx, int pointy)
151 int height = m_pWidget->allocation.height;
152 // NOTE RR2DO2 this hasn't got any use anymore really. It is an old qeradiant feature
153 // that can be re-enabled by removing the checks for HasCapture and not shift/ctrl down
154 // but the scaling/rotating (unless done with the steps set in the surface inspector
155 // dialog) is way too sensitive to be of any use
156 if (HasCapture () && Sys_AltDown () &&
157 !((flags & MK_SHIFT) || (flags & MK_CONTROL)))
159 if (flags & MK_CONTROL)
160 Select_RotateTexture(pointy - m_ptLastCursorY);
162 if (flags & MK_SHIFT)
163 Select_ScaleTexture(pointx - m_ptLastCursorX, m_ptLastCursorY - pointy);
165 Select_ShiftTexture(pointx - m_ptLastCursorX, m_ptLastCursorY - pointy);
169 Cam_MouseMoved(pointx, height - 1 - pointy, flags);
171 m_ptLastCursorX = pointx;
172 m_ptLastCursorY = pointy;
174 update_xor_rectangle(m_XORRectangle);
177 void CamWnd::OnMouseWheel(bool bUp)
180 VectorMA (m_Camera.origin, g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);
182 VectorMA (m_Camera.origin, -g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);
184 int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);
185 Sys_UpdateWindows (nUpdate);
186 g_pParentWnd->OnTimer ();
189 void CamWnd::OnLButtonDown(guint32 nFlags, int pointx, int pointy)
191 m_ptLastCursorX = pointx;
192 m_ptLastCursorY = pointy;
193 OriginalMouseDown(nFlags, pointx, pointy);
196 void CamWnd::OnLButtonUp(guint32 nFlags, int pointx, int pointy)
198 OriginalMouseUp(nFlags, pointx, pointy);
201 void CamWnd::OnMButtonDown(guint32 nFlags, int pointx, int pointy)
203 OriginalMouseDown(nFlags, pointx, pointy);
206 void CamWnd::OnMButtonUp(guint32 nFlags, int pointx, int pointy)
208 OriginalMouseUp(nFlags, pointx, pointy);
211 void CamWnd::OnRButtonDown(guint32 nFlags, int pointx, int pointy)
213 OriginalMouseDown(nFlags, pointx, pointy);
216 void CamWnd::OnRButtonUp(guint32 nFlags, int pointx, int pointy)
218 OriginalMouseUp(nFlags, pointx, pointy);
221 void CamWnd::OriginalMouseUp(guint32 nFlags, int pointx, int pointy)
223 int height = m_pWidget->allocation.height;
225 if(g_qeglobals.d_select_mode == sel_facets_on || g_qeglobals.d_select_mode == sel_facets_off)
227 g_qeglobals.d_select_mode = sel_brush;
230 Cam_MouseUp(pointx, height - 1 - pointy, nFlags);
233 update_xor_rectangle(m_XORRectangle);
236 void CamWnd::OriginalMouseDown(guint32 nFlags, int pointx, int pointy)
238 int height = m_pWidget->allocation.height;
242 Cam_MouseDown (pointx, height - 1 - pointy, nFlags);
244 update_xor_rectangle(m_XORRectangle);
247 void CamWnd::Cam_BuildMatrix()
255 ya = m_Camera.angles[1]/180*Q_PI;
257 // the movement matrix is kept 2d
258 m_Camera.forward[0] = cos(ya);
259 m_Camera.forward[1] = sin(ya);
260 m_Camera.forward[2] = 0;
261 m_Camera.right[0] = m_Camera.forward[1];
262 m_Camera.right[1] = -m_Camera.forward[0];
266 AngleVectors( m_Camera.angles, m_Camera.forward, m_Camera.right, NULL );
267 m_Camera.forward[2] = -m_Camera.forward[2];
270 memcpy(matrix, m_Camera.projection, sizeof(m4x4_t));
271 m4x4_multiply_by_m4x4(&matrix[0][0], &m_Camera.modelview[0][0]);
273 //qglGetFloatv (GL_PROJECTION_MATRIX, &matrix[0][0]);
275 for (i=0 ; i<3 ; i++)
277 m_Camera.vright[i] = matrix[i][0];
278 m_Camera.vup[i] = matrix[i][1];
279 m_Camera.vpn[i] = matrix[i][2];
282 VectorNormalize (m_Camera.vright, m_Camera.vright);
283 VectorNormalize (m_Camera.vup, m_Camera.vup);
284 VectorNormalize (m_Camera.vpn, m_Camera.vpn);
287 void CamWnd::Cam_ChangeFloor (qboolean up)
290 float d, bestd, current;
293 start[0] = m_Camera.origin[0];
294 start[1] = m_Camera.origin[1];
295 start[2] = g_MaxWorldCoord;
299 current = g_MaxWorldCoord - (m_Camera.origin[2] - 48);
303 bestd = 2*g_MaxWorldCoord;
305 for (b=active_brushes.next ; b != &active_brushes ; b=b->next)
307 if (!Brush_Ray (start, dir, b, &d))
309 if (up && d < current && d > bestd)
311 if (!up && d > current && d < bestd)
315 if (bestd == 0 || bestd == 2*g_MaxWorldCoord)
318 m_Camera.origin[2] += current - bestd;
319 Sys_UpdateWindows (W_CAMERA|W_Z_OVERLAY);
322 void CamWnd::Cam_PositionDrag()
326 Sys_GetCursorPos (&x, &y);
327 if (x != m_ptCursorX || y != m_ptCursorY)
330 VectorMA (m_Camera.origin, x, m_Camera.vright, m_Camera.origin);
332 m_Camera.origin[2] -= y;
333 Sys_SetCursorPos(m_ptCursorX, m_ptCursorY);
334 Sys_UpdateWindows (W_CAMERA | W_XY_OVERLAY);
338 void CamWnd::Cam_MouseControl (float dtime)
340 Cam_KeyControl (dtime);
342 if( g_PrefsDlg.m_bCamFreeLook )
347 if( !m_bFreeMove || m_nCambuttonstate == MK_CONTROL )
351 Sys_GetCursorPos(&m_ptCursorX, &m_ptCursorY);
353 dx = m_ptLastCamCursorX - m_ptCursorX;
354 dy = m_ptLastCamCursorY - m_ptCursorY;
356 gdk_window_get_origin( m_pWidget->window, &x, &y);
358 m_ptLastCamCursorX = x + (m_Camera.width / 2);
359 m_ptLastCamCursorY = y + (m_Camera.height / 2);
361 Sys_SetCursorPos(m_ptLastCamCursorX, m_ptLastCamCursorY);
364 if(!g_PrefsDlg.m_bCamFreeLookStrafe) {
365 if (g_PrefsDlg.m_bCamInverseMouse)
366 m_Camera.angles[PITCH] -= dy * dtime * g_PrefsDlg.m_nAngleSpeed;
368 m_Camera.angles[PITCH] += dy * dtime * g_PrefsDlg.m_nAngleSpeed;
370 VectorMA (m_Camera.origin, dy * (float) (g_PrefsDlg.m_nMoveSpeed / 6.0f), m_Camera.forward, m_Camera.origin);
373 m_Camera.angles[YAW] += dx * dtime * g_PrefsDlg.m_nAngleSpeed;
375 if (m_Camera.angles[PITCH] > 90)
376 m_Camera.angles[PITCH] = 90;
377 else if (m_Camera.angles[PITCH] < -90)
378 m_Camera.angles[PITCH] = -90;
380 if (m_Camera.angles[YAW] >= 360)
381 m_Camera.angles[YAW] = 0;
382 else if (m_Camera.angles[YAW] <= -360)
383 m_Camera.angles[YAW] = 0;
385 if( dx || dy || m_Camera.movementflags )
387 int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);
388 Sys_UpdateWindows (nUpdate);
389 g_pParentWnd->OnTimer ();
398 if (g_PrefsDlg.m_nMouseButtons == 2)
400 if (m_nCambuttonstate != (MK_RBUTTON | MK_SHIFT))
405 if (m_nCambuttonstate != MK_RBUTTON)
409 xf = (float)(m_ptButtonX - m_Camera.width/2) / (m_Camera.width/2);
410 yf = (float)(m_ptButtonY - m_Camera.height/2) / (m_Camera.height/2);
412 xl = m_Camera.width/3;
414 yl = m_Camera.height/3;
417 xf *= 1.0 - fabs(yf);
431 VectorMA (m_Camera.origin, yf*dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);
432 m_Camera.angles[YAW] += xf*-dtime*g_PrefsDlg.m_nAngleSpeed;
434 int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);
435 Sys_UpdateWindows (nUpdate);
436 g_pParentWnd->OnTimer ();
440 void CamWnd::Cam_KeyControl (float dtime) {
443 if (m_Camera.movementflags & MOVE_ROTLEFT)
444 m_Camera.angles[YAW] += 15*dtime*g_PrefsDlg.m_nAngleSpeed;
445 if (m_Camera.movementflags & MOVE_ROTRIGHT)
446 m_Camera.angles[YAW] -= 15*dtime*g_PrefsDlg.m_nAngleSpeed;
449 if (m_Camera.movementflags & MOVE_FORWARD)
450 VectorMA (m_Camera.origin, dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);
451 if (m_Camera.movementflags & MOVE_BACK)
452 VectorMA (m_Camera.origin, -dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);
453 if (m_Camera.movementflags & MOVE_STRAFELEFT)
454 VectorMA (m_Camera.origin, -dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.right, m_Camera.origin);
455 if (m_Camera.movementflags & MOVE_STRAFERIGHT)
456 VectorMA (m_Camera.origin, dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.right, m_Camera.origin);
458 // Save a screen update (when m_bFreeMove is enabled, mousecontrol does the update)
459 if( !m_bFreeMove && m_Camera.movementflags )
461 int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);
462 Sys_UpdateWindows (nUpdate);
463 g_pParentWnd->OnTimer ();
467 // NOTE TTimo if there's an OS-level focus out of the application
468 // then we can release the camera cursor grab
469 static gint camwindow_focusout(GtkWidget* widget, GdkEventKey* event, gpointer data)
471 g_pParentWnd->GetCamWnd ()->ToggleFreeMove();
475 void CamWnd::ToggleFreeMove()
480 m_bFreeMove = !m_bFreeMove;
481 Camera()->movementflags = 0;
482 m_ptLastCamCursorX = m_ptCursorX;
483 m_ptLastCamCursorY = m_ptCursorY;
485 if (g_pParentWnd->CurrentStyle() == MainFrame::eFloating)
487 widget = g_pParentWnd->GetCamWnd ()->m_pParent;
488 window = widget->window;
492 widget = g_pParentWnd->m_pWidget;
493 window = widget->window;
505 char buffer [(32 * 32)/8];
506 memset (buffer, 0, (32 * 32)/8);
507 GdkColor white = {0, 0xffff, 0xffff, 0xffff};
508 GdkColor black = {0, 0x0000, 0x0000, 0x0000};
509 pixmap = gdk_bitmap_create_from_data (NULL, buffer, 32, 32);
510 mask = gdk_bitmap_create_from_data (NULL, buffer, 32, 32);
511 GdkCursor *cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &white, &black, 1, 1);
513 gdk_window_set_cursor (window, cursor);
514 gdk_cursor_unref (cursor);
515 gdk_drawable_unref (pixmap);
516 gdk_drawable_unref (mask);
519 // RR2DO2: FIXME why does this only work the 2nd and
520 // further times the event is called? (floating windows
521 // mode seems to work fine though...)
522 m_FocusOutHandler_id = gtk_signal_connect (GTK_OBJECT (widget), "focus_out_event",
523 GTK_SIGNAL_FUNC (camwindow_focusout), g_pParentWnd);
526 GdkEventMask mask = (GdkEventMask)(GDK_POINTER_MOTION_MASK
527 | GDK_POINTER_MOTION_HINT_MASK
528 | GDK_BUTTON_MOTION_MASK
529 | GDK_BUTTON1_MOTION_MASK
530 | GDK_BUTTON2_MOTION_MASK
531 | GDK_BUTTON3_MOTION_MASK
532 | GDK_BUTTON_PRESS_MASK
533 | GDK_BUTTON_RELEASE_MASK);
535 gdk_pointer_grab(widget->window, TRUE, mask, widget->window, NULL, GDK_CURRENT_TIME);
540 gdk_pointer_ungrab(GDK_CURRENT_TIME);
542 gtk_signal_disconnect (GTK_OBJECT (widget), m_FocusOutHandler_id);
544 GdkCursor *cursor = gdk_cursor_new (GDK_LEFT_PTR);
545 gdk_window_set_cursor (window, cursor);
546 gdk_cursor_unref (cursor);
551 int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);
552 Sys_UpdateWindows (nUpdate);
553 g_pParentWnd->OnTimer ();
556 void CamWnd::Cam_MouseDown(int x, int y, int buttons)
564 // calc ray direction
566 u = (float)( y - ( m_Camera.height * .5f ) ) / ( m_Camera.width * .5f );
567 r = (float)( x - ( m_Camera.width * .5f ) ) / ( m_Camera.width * .5f );
570 for (i=0 ; i<3 ; i++)
571 dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;
572 VectorNormalize (dir, dir);
574 Sys_GetCursorPos(&m_ptCursorX, &m_ptCursorY);
576 m_nCambuttonstate = buttons;
580 // LBUTTON = manipulate selection
581 // shift-LBUTTON = select
582 // middle button = grab texture
583 // ctrl-middle button = set entire brush to texture
584 // ctrl-shift-middle button = set single face to texture
585 int nMouseButton = g_PrefsDlg.m_nMouseButtons == 2 ? MK_RBUTTON : MK_MBUTTON;
586 if ((buttons == MK_LBUTTON)
587 || (buttons == (MK_LBUTTON | MK_SHIFT))
588 || (buttons == (MK_LBUTTON | MK_CONTROL))
589 || (buttons == (MK_LBUTTON | MK_CONTROL | MK_SHIFT))
590 || (buttons == nMouseButton)
591 || (buttons == (nMouseButton|MK_SHIFT))
592 || (buttons == (nMouseButton|MK_CONTROL))
593 || (buttons == (nMouseButton|MK_SHIFT|MK_CONTROL)))
595 if (g_PrefsDlg.m_nMouseButtons == 2 && (buttons == (MK_RBUTTON | MK_SHIFT)))
597 if (g_PrefsDlg.m_bCamFreeLook)
600 Cam_MouseControl (0.1f);
604 // something global needs to track which window is responsible for stuff
605 Patch_SetView(W_CAMERA);
606 Drag_Begin (x, y, buttons, m_Camera.vright, m_Camera.vup, m_Camera.origin, dir, true);
611 if (buttons == MK_RBUTTON)
613 if (g_PrefsDlg.m_bCamFreeLook)
616 Cam_MouseControl (0.1f);
621 void CamWnd::Cam_MouseUp (int x, int y, int buttons)
623 m_nCambuttonstate = 0;
624 Drag_MouseUp (buttons);
627 void CamWnd::Cam_MouseMoved (int x, int y, int buttons)
629 m_nCambuttonstate = buttons;
633 if( g_PrefsDlg.m_nCamDragMultiSelect )
635 if (g_qeglobals.d_select_mode == sel_brush_on || g_qeglobals.d_select_mode == sel_brush_off)
637 bool bDoDragMultiSelect = FALSE;
639 if( g_PrefsDlg.m_nCamDragMultiSelect == 1 && buttons == (MK_LBUTTON|MK_SHIFT) )
640 bDoDragMultiSelect = TRUE;
641 else if( g_PrefsDlg.m_nCamDragMultiSelect == 2 && buttons == (MK_LBUTTON|MK_CONTROL) && Sys_AltDown() )
642 bDoDragMultiSelect = TRUE;
644 if( bDoDragMultiSelect )
651 // calc ray direction
653 u = (float)( y - ( m_Camera.height * .5f ) ) / ( m_Camera.width * .5f );
654 r = (float)( x - ( m_Camera.width * .5f ) ) / ( m_Camera.width * .5f );
657 for (i=0 ; i<3 ; i++)
658 dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;
659 VectorNormalize (dir,dir);
661 switch( g_qeglobals.d_select_mode )
664 Select_Ray( m_Camera.origin, dir, (SF_DRAG_ON|SF_CAMERA) );
668 Select_Ray( m_Camera.origin, dir, (SF_DRAG_OFF|SF_CAMERA) );
677 else if (g_qeglobals.d_select_mode == sel_facets_on || g_qeglobals.d_select_mode == sel_facets_off)
679 if( buttons == (MK_LBUTTON|MK_CONTROL|MK_SHIFT) )
686 // calc ray direction
688 u = (float)( y - ( m_Camera.height * .5f ) ) / ( m_Camera.width * .5f );
689 r = (float)( x - ( m_Camera.width * .5f ) ) / ( m_Camera.width * .5f );
692 for (i=0 ; i<3 ; i++)
693 dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;
694 VectorNormalize (dir,dir);
696 switch( g_qeglobals.d_select_mode )
699 Select_Ray( m_Camera.origin, dir, (SF_SINGLEFACE|SF_DRAG_ON|SF_CAMERA) );
703 Select_Ray( m_Camera.origin, dir, (SF_SINGLEFACE|SF_DRAG_OFF|SF_CAMERA) );
717 if ( (m_bFreeMove && (buttons & MK_CONTROL) && !(buttons & MK_SHIFT)) || (!m_bFreeMove && (buttons == (MK_RBUTTON|MK_CONTROL))) )
720 Sys_UpdateWindows (W_XY|W_CAMERA|W_Z);
724 Sys_GetCursorPos(&m_ptCursorX, &m_ptCursorY);
726 if (buttons & (MK_LBUTTON | MK_MBUTTON) )
728 Drag_MouseMoved (x, y, buttons);
729 if(g_qeglobals.d_select_mode != sel_area)
730 Sys_UpdateWindows (W_XY|W_CAMERA|W_Z);
734 void CamWnd::InitCull()
738 VectorSubtract (m_Camera.vpn, m_Camera.vright, m_vCull1);
739 VectorAdd (m_Camera.vpn, m_Camera.vright, m_vCull2);
741 for (i=0 ; i<3 ; i++)
754 qboolean CamWnd::CullBrush (brush_t *b)
760 if (g_PrefsDlg.m_bCubicClipping)
762 float fLevel = g_PrefsDlg.m_nCubicScale * 64;
764 point[0] = m_Camera.origin[0] - fLevel;
765 point[1] = m_Camera.origin[1] - fLevel;
766 point[2] = m_Camera.origin[2] - fLevel;
769 if (b->mins[i] < point[i] && b->maxs[i] < point[i])
772 point[0] = m_Camera.origin[0] + fLevel;
773 point[1] = m_Camera.origin[1] + fLevel;
774 point[2] = m_Camera.origin[2] + fLevel;
777 if (b->mins[i] > point[i] && b->maxs[i] > point[i])
781 for (i=0 ; i<3 ; i++)
782 point[i] = b->mins[m_nCullv1[i]] - m_Camera.origin[i];
784 d = DotProduct (point, m_vCull1);
788 for (i=0 ; i<3 ; i++)
789 point[i] = b->mins[m_nCullv2[i]] - m_Camera.origin[i];
791 d = DotProduct (point, m_vCull2);
798 // project a 3D point onto the camera space
799 // we use the GL viewing matrixes
800 // this is the implementation of a glu function (I realized that afterwards): gluProject
801 void CamWnd::ProjectCamera(const vec3_t A, vec_t B[2])
804 vec_t P1[4],P2[4],P3[4];
805 VectorCopy(A,P1); P1[3] = 1;
807 GLMatMul(m_Camera.modelview , P1, P2);
808 GLMatMul(m_Camera.projection, P2, P3);
810 // we ASSUME that the view port is 0 0 m_Camera.width m_Camera.height (you can check in Cam_Draw)
811 B[0] = (float)m_Camera.width * ( P3[0] + 1.0 ) / 2.0;
812 B[1] = (float)m_Camera.height * ( P3[1] + 1.0 ) / 2.0;
816 // vec defines a direction in geometric space and P an origin point
817 // the user is interacting from the camera view
818 // (for example with texture adjustment shortcuts)
819 // and intuitively if he hits left / right / up / down
820 // what happens in geometric space should match the left/right/up/down move in camera space
821 // axis = 0: vec is along left/right
822 // axis = 1: vec is along up/down
823 // sgn = +1: same directions
824 // sgn = -1: opposite directions
826 // typical use case is giving a face center and a normalized vector
827 // 1) compute start and endpoint, project them in camera view, get the direction
828 // depending on the situation, we might bump into precision issues with that
829 // 2) possible to compute the projected direction independently?
830 // this solution would be better but right now I don't see how to do it..
831 void CamWnd::MatchViewAxes(const vec3_t P, const vec3_t vec, int &axis, float &sgn)
834 vec_t A[2],B[2],V[2];
839 // V is the vector projected in camera space
842 if (fabs(V[0])>fabs(V[1]))
844 // best match is against right
853 // best match is against up
863 void CamWnd::DrawLightRadius(brush_t* pBrush)
866 int nRadius = Brush_LightRadius(pBrush);
869 Brush_SetLightColor(pBrush);
870 qglEnable (GL_BLEND);
871 qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
872 qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
873 qglDisable (GL_TEXTURE_2D);
875 qglEnable(GL_TEXTURE_2D);
876 qglDisable(GL_BLEND);
877 qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
882 extern void DrawPatchMesh(patchMesh_t *pm);
883 extern void DrawPatchControls(patchMesh_t *pm);
884 extern void Brush_DrawFacingAngle (brush_t *b, entity_t *e);
885 extern void Brush_DrawModel(brush_t *b, bool bTextured = false);
886 extern void DrawModelOrigin(brush_t *b);
887 extern void DrawModelBBox(brush_t *b);
889 void CamWnd::Cam_DrawBrush(brush_t *b, int mode)
891 int nGLState = m_Camera.draw_glstate;
892 int nModelMode = g_PrefsDlg.m_nEntityShowState;
894 GLfloat material[4], identity[4];
895 VectorSet(identity, 0.8f, 0.8f, 0.8f);
899 if (b->owner->eclass->fixedsize && b->owner->eclass->nShowFlags & ECLASS_LIGHT && g_PrefsDlg.m_bNewLightDraw)
904 VectorCopy(b->owner->color, material);
905 VectorScale(material, 0.8f, material);
908 qglColor4fv(material);
910 if (g_PrefsDlg.m_bNewLightDraw)
911 DrawLight(b->owner, nGLState, (IsBrushSelected(b)) ? g_PrefsDlg.m_nLightRadiuses : 0, 0);
918 else if(b->owner->eclass->fixedsize && b->owner->model.pRender
919 && !(!IsBrushSelected(b) && (nModelMode & ENTITY_SELECTED_ONLY)))
924 if (!(nModelMode & ENTITY_WIREFRAME) && nModelMode != ENTITY_BOX)
926 VectorCopy(b->owner->eclass->color, material);
927 material[3] = identity[3] = 1.0f;
929 qglEnable(GL_CULL_FACE);
931 if(!(nGLState & DRAW_GL_TEXTURE_2D)) qglColor4fv(material);
932 else qglColor4fv(identity);
933 if(nGLState & DRAW_GL_LIGHTING) qglShadeModel(GL_SMOOTH);
935 b->owner->model.pRender->Draw(nGLState, DRAW_RF_CAM);
939 VectorCopy(b->owner->eclass->color, material);
941 qglColor4fv(material);
943 // model view mode "wireframe" or "selected wire"
944 if(nModelMode & ENTITY_WIREFRAME)
945 b->owner->model.pRender->Draw(nGLState, DRAW_RF_CAM);
947 // model view mode "skinned and boxed"
948 if(!(b->owner->eclass->nShowFlags & ECLASS_MISCMODEL) )
950 qglColor4fv(material);
951 aabb_draw(b->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);
953 else if(nModelMode & ENTITY_BOXED)
955 aabb_draw(b->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);
958 if(!(nModelMode & ENTITY_BOXED) && b->owner->eclass->nShowFlags & ECLASS_MISCMODEL)
965 else if (b->patchBrush)
967 bool bTrans = (b->pPatch->pShader->getTrans() < 1.0f);
971 if (!g_bPatchWireFrame && ((nGLState & DRAW_GL_BLEND && bTrans) || (!(nGLState & DRAW_GL_BLEND) && !bTrans)))
973 qglDisable(GL_CULL_FACE);
975 pShader = b->pPatch->pShader;
976 VectorCopy(pShader->getTexture()->color, material);
977 material[3] = identity[3] = pShader->getTrans();
979 if(nGLState & DRAW_GL_TEXTURE_2D) {
980 qglColor4fv(identity);
981 qglBindTexture(GL_TEXTURE_2D, pShader->getTexture()->texture_number);
984 qglColor4fv(material);
985 if(nGLState & DRAW_GL_LIGHTING) qglShadeModel(GL_SMOOTH);
987 DrawPatchMesh(b->pPatch);
991 if (g_bPatchWireFrame)
993 VectorCopy(b->pPatch->pShader->getTexture()->color, material);
995 qglColor4fv(material);
996 DrawPatchMesh(b->pPatch);
998 if ( b->pPatch->bSelected && (g_qeglobals.d_select_mode == sel_curvepoint
999 || g_qeglobals.d_select_mode == sel_area
1000 || g_bPatchBendMode))
1001 DrawPatchControls(b->pPatch);
1006 else if(b->owner->eclass->fixedsize)
1011 VectorCopy(b->owner->eclass->color, material);
1012 VectorScale(material, 0.8f, material);
1014 qglColor4fv(material);
1016 qglEnable(GL_CULL_FACE);
1017 qglShadeModel(GL_FLAT);
1021 if((g_qeglobals.d_savedinfo.include & INCLUDE_ANGLES)
1022 && (b->owner->eclass->nShowFlags & ECLASS_ANGLE))
1023 Brush_DrawFacingAngle(b, b->owner);
1033 qglEnable(GL_CULL_FACE);
1034 qglShadeModel(GL_FLAT);
1040 void CamWnd::Cam_DrawBrushes(int mode)
1043 brush_t *pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;
1045 for(b = active_brushes.next; b != &active_brushes; b=b->next)
1046 if (!b->bFiltered && !b->bCamCulled) Cam_DrawBrush(b, mode);
1047 for(b = pList->next; b != pList; b=b->next)
1048 if (!b->bFiltered && !b->bCamCulled) Cam_DrawBrush(b, mode);
1051 void CamWnd::Cam_DrawStuff()
1053 GLfloat identity[4];
1054 VectorSet(identity, 0.8f, 0.8f, 0.8f);
1057 for(b = active_brushes.next; b != &active_brushes; b=b->next)
1058 b->bCamCulled = CullBrush(b);
1060 for(b = selected_brushes.next; b != &selected_brushes; b=b->next)
1061 b->bCamCulled = CullBrush(b);
1063 switch (m_Camera.draw_mode)
1066 qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1067 qglDisable(GL_TEXTURE_2D);
1068 qglDisable(GL_TEXTURE_1D);
1069 qglDisable(GL_BLEND);
1070 qglEnable(GL_DEPTH_TEST);
1071 qglEnableClientState(GL_VERTEX_ARRAY);
1072 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
1073 qglShadeModel(GL_FLAT);
1074 if(g_PrefsDlg.m_bGLLighting) {
1075 qglDisable(GL_LIGHTING);
1076 qglDisable(GL_COLOR_MATERIAL);
1077 qglDisableClientState(GL_NORMAL_ARRAY);
1079 m_Camera.draw_glstate = DRAW_GL_WIRE;
1083 qglCullFace(GL_FRONT);
1084 qglEnable(GL_CULL_FACE);
1085 qglShadeModel (GL_FLAT);
1086 qglPolygonMode (GL_FRONT, GL_LINE);
1087 qglPolygonMode (GL_BACK, GL_FILL);
1088 qglDisable(GL_TEXTURE_2D);
1089 qglDisable(GL_BLEND);
1090 qglEnable(GL_DEPTH_TEST);
1091 qglEnableClientState(GL_VERTEX_ARRAY);
1092 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
1093 qglPolygonOffset(-1.0, 2);
1094 if(g_PrefsDlg.m_bGLLighting) {
1095 qglEnable(GL_LIGHTING);
1096 qglEnable(GL_COLOR_MATERIAL);
1097 // qglEnable(GL_RESCALE_NORMAL);
1098 qglEnableClientState(GL_NORMAL_ARRAY);
1100 m_Camera.draw_glstate = DRAW_GL_SOLID;
1104 qglCullFace(GL_FRONT);
1105 qglEnable(GL_CULL_FACE);
1106 qglShadeModel (GL_FLAT);
1107 qglPolygonMode (GL_FRONT, GL_LINE);
1108 qglPolygonMode (GL_BACK, GL_FILL);
1109 qglEnable(GL_TEXTURE_2D);
1110 qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1111 qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1112 qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
1113 qglDisable(GL_BLEND);
1114 qglEnable(GL_DEPTH_TEST);
1115 qglEnableClientState(GL_VERTEX_ARRAY);
1116 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
1117 if(g_PrefsDlg.m_bGLLighting) {
1118 qglEnable(GL_LIGHTING);
1119 qglDisable(GL_COLOR_MATERIAL);
1120 qglMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, identity);
1121 qglEnableClientState(GL_NORMAL_ARRAY);
1122 // qglEnable(GL_RESCALE_NORMAL);
1124 qglPolygonOffset(-1.0, 2);
1125 m_Camera.draw_glstate = DRAW_GL_TEXTURED;
1128 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1131 Cam_DrawBrushes(DRAW_TEXTURED);
1133 // setup for solid stuff
1134 switch(m_Camera.draw_mode)
1137 qglDisable(GL_TEXTURE_2D);
1138 m_Camera.draw_glstate &= ~DRAW_GL_TEXTURE_2D;
1139 if(g_PrefsDlg.m_bGLLighting)
1140 qglEnable(GL_COLOR_MATERIAL);
1141 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
1147 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1150 qglEnable(GL_CULL_FACE);
1151 qglShadeModel(GL_FLAT);
1152 Cam_DrawBrushes(DRAW_SOLID);
1154 // setup for wireframe stuff
1155 switch(m_Camera.draw_mode)
1158 if(g_PrefsDlg.m_bGLLighting) {
1159 qglDisable(GL_LIGHTING);
1160 qglDisable(GL_COLOR_MATERIAL);
1161 qglDisableClientState(GL_NORMAL_ARRAY);
1162 // qglDisable(GL_RESCALE_NORMAL);
1164 qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1167 if(g_PrefsDlg.m_bGLLighting) {
1168 qglDisable(GL_LIGHTING);
1169 qglDisable(GL_COLOR_MATERIAL);
1170 qglDisableClientState(GL_NORMAL_ARRAY);
1171 // qglDisable(GL_RESCALE_NORMAL);
1173 qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1177 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1180 qglDisable(GL_CULL_FACE);
1181 Cam_DrawBrushes(DRAW_WIRE);
1183 // setup for transparent texture stuff
1184 switch(m_Camera.draw_mode)
1187 qglPolygonMode (GL_FRONT, GL_LINE);
1188 qglPolygonMode (GL_BACK, GL_FILL);
1189 if(g_PrefsDlg.m_bGLLighting) {
1190 qglEnable(GL_COLOR_MATERIAL);
1191 qglEnableClientState(GL_NORMAL_ARRAY);
1192 qglMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, identity);
1194 qglEnable(GL_TEXTURE_2D);
1195 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
1196 m_Camera.draw_glstate = DRAW_GL_TEXTURED;
1199 qglPolygonMode (GL_FRONT, GL_LINE);
1200 qglPolygonMode (GL_BACK, GL_FILL);
1201 if(g_PrefsDlg.m_bGLLighting) {
1202 qglEnable(GL_LIGHTING);
1203 qglEnable(GL_COLOR_MATERIAL);
1204 qglEnableClientState(GL_NORMAL_ARRAY);
1205 // qglEnable(GL_RESCALE_NORMAL);
1207 m_Camera.draw_glstate = DRAW_GL_SOLID;
1210 m_Camera.draw_glstate = DRAW_GL_WIRE;
1212 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1216 qglEnable(GL_BLEND);
1217 m_Camera.draw_glstate |= DRAW_GL_BLEND;
1218 qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1219 // FIXME: some .TGA are buggy, have a completely empty alpha channel
1220 // if such brushes are rendered in this loop they would be totally transparent with GL_MODULATE
1221 // so I decided using GL_DECAL instead
1222 // if an empty-alpha-channel or nearly-empty texture is used. It will be blank-transparent.
1223 // this could get better if you can get qglTexEnviv (GL_TEXTURE_ENV, to work .. patches are welcome
1224 // Arnout: empty alpha channels are now always filled with data. Don't set this anymore (would cause problems with qer_alphafunc too)
1225 // qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
1227 Cam_DrawBrushes(DRAW_TEXTURED);
1229 // qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1230 qglDisable(GL_BLEND);
1232 // setup for wireframe stuff
1233 switch(m_Camera.draw_mode)
1236 if(g_PrefsDlg.m_bGLLighting) {
1237 qglDisable(GL_COLOR_MATERIAL);
1238 qglDisable(GL_LIGHTING);
1239 // qglDisable(GL_RESCALE_NORMAL);
1243 if(g_PrefsDlg.m_bGLLighting) {
1244 qglDisable(GL_COLOR_MATERIAL);
1245 qglDisable(GL_LIGHTING);
1246 // qglDisable(GL_RESCALE_NORMAL);
1251 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1265 void CamWnd::Cam_Draw()
1271 double start = 0.0, end;
1274 if (!active_brushes.next)
1275 return; // not valid yet
1277 if (m_Camera.timing)
1278 start = Sys_DoubleTime ();
1283 QE_CheckOpenGLForErrors();
1285 qglViewport(0, 0, m_Camera.width, m_Camera.height);
1286 qglClearColor (g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][0],
1287 g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][1],
1288 g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][2], 0);
1289 qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1296 qglMatrixMode(GL_PROJECTION);
1299 screenaspect = (float)m_Camera.width / m_Camera.height;
1300 yfov = 2*atan((float)m_Camera.height / m_Camera.width)*180/Q_PI;
1301 qgluPerspective (yfov, screenaspect, 8, 32768);
1303 // we're too lazy to calc projection matrix ourselves!!!
1304 qglGetFloatv (GL_PROJECTION_MATRIX, &m_Camera.projection[0][0]);
1308 m4x4_identity(&m_Camera.modelview[0][0]);
1309 VectorSet(vec, -90, 0, 0);
1310 m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);
1311 VectorSet(vec, 0, 0, 90);
1312 m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);
1313 VectorSet(vec, 0, m_Camera.angles[0], 0);
1314 m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);
1315 VectorSet(vec, 0, 0, -m_Camera.angles[1]);
1316 m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);
1317 VectorSet(vec, -m_Camera.origin[0], -m_Camera.origin[1], -m_Camera.origin[2]);
1318 m4x4_translate_by_vec3(&m_Camera.modelview[0][0], vec);
1322 qglMatrixMode(GL_MODELVIEW);
1325 qglMultMatrixf(&m_Camera.modelview[0][0]);
1327 // grab the GL_PROJECTION and GL_MODELVIEW matrixes
1328 // used in GetRelativeAxes
1329 //qglGetFloatv (GL_PROJECTION_MATRIX, &m_Camera.projection[0][0]);
1330 //qglGetFloatv (GL_MODELVIEW_MATRIX, &m_Camera.modelview[0][0]);
1333 // TTimo: this is not used, just for verification (0, 0, m_Camera.width, m_Camera.height)
1335 qglGetIntegerv (GL_VIEWPORT, viewprt);
1338 if (g_PrefsDlg.m_bGLLighting)
1340 GLfloat inverse_cam_dir[4], ambient[4], diffuse[4];//, material[4];
1342 ambient[0] = ambient[1] = ambient[2] = 0.6f;
1344 diffuse[0] = diffuse[1] = diffuse[2] = 0.4f;
1346 //material[0] = material[1] = material[2] = 0.8f;
1347 //material[3] = 1.0f;
1349 vec3_t vCam, vRotate;
1350 VectorSet(vCam, -1, 0, 0); //default cam pos
1351 VectorSet(vRotate, 0, -m_Camera.angles[0], 0);
1352 VectorRotate(vCam, vRotate, vCam);
1353 VectorSet(vRotate, 0, 0, m_Camera.angles[1]);
1354 VectorRotate(vCam, vRotate, vCam);
1356 inverse_cam_dir[0] = vCam[0];
1357 inverse_cam_dir[1] = vCam[1];
1358 inverse_cam_dir[2] = vCam[2];
1359 inverse_cam_dir[3] = 0;
1361 qglColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
1363 qglLightfv(GL_LIGHT0, GL_POSITION, inverse_cam_dir);
1365 qglLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
1366 qglLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
1368 qglEnable(GL_LIGHT0);
1379 qglEnableClientState(GL_VERTEX_ARRAY);
1380 qglDisableClientState(GL_NORMAL_ARRAY);
1381 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
1382 qglDisable (GL_TEXTURE_2D);
1383 qglDisable (GL_LIGHTING);
1384 qglDisable (GL_COLOR_MATERIAL);
1386 qglEnable (GL_CULL_FACE);
1388 brush_t* pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;
1390 if (g_qeglobals.d_savedinfo.iSelectedOutlinesStyle & OUTLINE_BSEL)
1392 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);
1393 qglEnable (GL_BLEND);
1394 qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1395 qglDepthFunc (GL_LEQUAL);
1396 for (brush = pList->next ; brush != pList ; brush=brush->next)
1398 if (brush->bCamCulled) // draw selected faces of filtered brushes to remind that there is a selection
1401 if (brush->patchBrush && (g_qeglobals.d_select_mode == sel_curvepoint || g_qeglobals.d_select_mode == sel_area))
1404 if (!g_PrefsDlg.m_bPatchBBoxSelect && brush->patchBrush)
1406 DrawPatchMesh(brush->pPatch);
1408 else if(brush->owner->model.pRender && g_PrefsDlg.m_nEntityShowState != ENTITY_BOX)
1410 brush->owner->model.pRender->Draw(DRAW_GL_FLAT, (DRAW_RF_SEL_OUTLINE|DRAW_RF_CAM));
1414 for (face=brush->brush_faces ; face ; face=face->next)
1415 Brush_FaceDraw(face, DRAW_GL_FLAT);
1420 int nCount = g_ptrSelectedFaces.GetSize();
1423 for (int i = 0; i < nCount; i++)
1425 face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));
1426 Brush_FaceDraw(selFace, DRAW_GL_FLAT);
1430 qglDisableClientState(GL_NORMAL_ARRAY);
1431 qglDepthFunc (GL_LESS);
1434 if (g_qeglobals.d_savedinfo.iSelectedOutlinesStyle & OUTLINE_ZBUF)
1436 // non-zbuffered outline
1437 qglDisable (GL_BLEND);
1438 qglDisable (GL_DEPTH_TEST);
1439 qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1440 qglColor3f (1, 1, 1);
1441 for (brush = pList->next ; brush != pList ; brush=brush->next)
1443 if ((brush->patchBrush && (g_qeglobals.d_select_mode == sel_curvepoint || g_qeglobals.d_select_mode == sel_area)))
1446 if (!g_PrefsDlg.m_bPatchBBoxSelect && brush->patchBrush)
1448 DrawPatchMesh(brush->pPatch);
1450 else if(brush->owner->model.pRender && g_PrefsDlg.m_nEntityShowState != ENTITY_BOX)
1452 brush->owner->model.pRender->Draw(DRAW_GL_WIRE, (DRAW_RF_SEL_FILL|DRAW_RF_CAM));
1454 // Hydra : always draw bbox outline!
1455 aabb_draw(brush->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);
1459 for (face=brush->brush_faces ; face ; face=face->next)
1460 Brush_FaceDraw(face, DRAW_GL_WIRE);
1465 // edge / vertex flags
1466 if (g_qeglobals.d_select_mode == sel_vertex)
1468 // GL_POINTS on Kyro Workaround
1469 if(!g_PrefsDlg.m_bGlPtWorkaround)
1474 qglBegin (GL_POINTS);
1475 for (i=0 ; i<g_qeglobals.d_numpoints ; i++)
1476 qglVertex3fv (g_qeglobals.d_points[i]);
1479 if(g_qeglobals.d_num_move_points)
1481 // selected brush verts
1484 qglBegin (GL_POINTS);
1485 for(i = 0; i < g_qeglobals.d_num_move_points; i++)
1486 qglVertex3fv (g_qeglobals.d_move_points[i]);
1497 qglBegin (GL_LINES);
1498 for (i=0; i < g_qeglobals.d_numpoints; i++)
1499 DrawAlternatePoint(g_qeglobals.d_points[i], 1.5);
1502 if(g_qeglobals.d_num_move_points)
1504 // selected brush verts
1507 qglBegin (GL_LINES);
1508 for(i = 0; i < g_qeglobals.d_num_move_points; i++)
1509 qglVertex3fv (g_qeglobals.d_move_points[i]);
1515 else if (g_qeglobals.d_select_mode == sel_edge)
1518 // GL_POINTS on Kyro Workaround
1519 if(!g_PrefsDlg.m_bGlPtWorkaround)
1523 qglBegin (GL_POINTS);
1524 for (i=0 ; i<g_qeglobals.d_numedges ; i++)
1526 v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1];
1527 v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2];
1528 qglVertex3f ( (v1[0]+v2[0])*0.5,(v1[1]+v2[1])*0.5,(v1[2]+v2[2])*0.5);
1536 qglBegin (GL_LINES);
1537 for (i=0; i < g_qeglobals.d_numedges; i++)
1539 v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1];
1540 v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2];
1542 v3[0] = (v1[0]+v2[0])*0.5;
1543 v3[1] = (v1[1]+v2[1])*0.5;
1544 v3[2] = (v1[2]+v2[2])*0.5;
1545 DrawAlternatePoint(v3, 1.5);
1555 qglEnable(GL_DEPTH_TEST);
1558 if (g_qeglobals.d_pointfile_display_list)
1563 // call the drawing routine of plugin entities
1564 //++timo FIXME: we might need to hook in other places as well for transparency etc.
1565 //++timo FIXME: also needs a way to get some parameters about the view
1566 //++timo FIXME: maybe provide some culling API on Radiant side?
1567 Draw3DPluginEntities();
1569 // draw the crosshair
1572 // setup orthographic projection mode
1573 qglMatrixMode(GL_PROJECTION);
1576 qglDisable(GL_DEPTH_TEST);
1577 qglOrtho(0, (float)m_Camera.width, 0, (float)m_Camera.height, -100, 100);
1578 qglScalef(1, -1, 1);
1579 qglTranslatef(0, -(float)m_Camera.height, 0);
1580 qglMatrixMode(GL_MODELVIEW);
1585 qglColor3f( 1.f, 1.f, 1.f );
1586 qglBegin( GL_LINES );
1587 qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f + 6 );
1588 qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f + 2 );
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 + 6, (float)m_Camera.height / 2.f );
1592 qglVertex2f( (float)m_Camera.width / 2.f + 2, (float)m_Camera.height / 2.f );
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 );
1598 // reset perspective projection
1599 //qglMatrixMode(GL_PROJECTION);
1601 //qglMatrixMode(GL_MODELVIEW);
1605 if ((g_qeglobals.d_select_mode == sel_area) && (g_nPatchClickedView == W_CAMERA))
1607 // setup orthographic projection mode
1608 qglMatrixMode(GL_PROJECTION);
1611 qglDisable(GL_DEPTH_TEST);
1612 qglOrtho(0, (float)m_Camera.width, 0, (float)m_Camera.height, -100, 100);
1613 //qglScalef(1, -1, 1);
1614 //qglTranslatef(0, -(float)m_Camera.height, 0);
1615 qglMatrixMode(GL_MODELVIEW);
1617 // area selection hack
1619 qglDisable(GL_CULL_FACE);
1620 qglEnable (GL_BLEND);
1621 qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1622 qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1623 qglColor4f(0.0, 0.0, 1.0, 0.25);
1624 qglRectf(g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[0], g_qeglobals.d_vAreaBR[1]);
1625 qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1626 qglDisable (GL_BLEND);
1627 qglEnable (GL_CULL_FACE);
1631 // bind back to the default texture so that we don't have problems
1632 // elsewhere using/modifying texture maps between contexts
1633 qglBindTexture( GL_TEXTURE_2D, 0 );
1636 QE_CheckOpenGLForErrors();
1638 if (m_Camera.timing)
1640 end = Sys_DoubleTime ();
1641 Sys_Printf ("Camera: %i ms\n", (int)(1000*(end-start)));
1644 for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next)
1645 brush->bCamCulled = false;
1647 for (brush = pList->next ; brush != pList ; brush=brush->next)
1648 brush->bCamCulled = false;
1651 void CamWnd::OnExpose ()
1653 if (!MakeCurrent ())
1655 Sys_Printf("ERROR: glXMakeCurrent failed..\n ");
1656 Sys_Printf("Please restart Radiant if the camera view is not working\n");
1660 QE_CheckOpenGLForErrors();
1661 g_pSplitList = NULL;
1664 if (g_Clip1.Set() && g_Clip2.Set())
1666 g_pSplitList = (g_bSwitch) ?
1667 &g_brBackSplits : &g_brFrontSplits;
1671 Patch_LODMatchAll(); // spog
1674 QE_CheckOpenGLForErrors ();
1676 m_XORRectangle.set(rectangle_t());
1681 void CamWnd::BenchMark()
1683 if (!MakeCurrent ())
1684 Error ("glXMakeCurrent failed in Benchmark");
1686 qglDrawBuffer (GL_FRONT);
1687 double dStart = Sys_DoubleTime ();
1688 for (int i=0 ; i < 100 ; i++)
1690 m_Camera.angles[YAW] = i*4;
1694 qglDrawBuffer (GL_BACK);
1695 double dEnd = Sys_DoubleTime ();
1696 Sys_Printf ("%5.2f seconds\n", dEnd - dStart);