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 gtk_glwidget_create_font (m_pWidget);
67 // report OpenGL information
68 Sys_Printf ("GL_VENDOR: %s\n", qglGetString (GL_VENDOR));
69 Sys_Printf ("GL_RENDERER: %s\n", qglGetString (GL_RENDERER));
70 Sys_Printf ("GL_VERSION: %s\n", qglGetString (GL_VERSION));
71 Sys_Printf ("GL_EXTENSIONS: %s\n", qglGetString (GL_EXTENSIONS));
73 // Set off texture compression supported
74 g_qeglobals.bTextureCompressionSupported = 0;
76 // finalize OpenGL init
78 // why is this here? well .. the Gtk objects get constructed when you enter gtk_main
79 // and I wanted to have the extensions information in the editor startup console (avoid looking that up in the early console)
81 // I Split this up so as to add support for extension and user-friendly
82 // compression format selection.
83 // ADD new globals for your new format so as to minimise
84 // calls to Sys_QGL_ExtensionSupported
85 // NOTE TTimo: I don't really like this approach with globals. Frequent calls to Sys_QGL_ExtensionSupported don't sound like
86 // a problem to me. If there is some caching to be done, then I think it should be inside Sys_QGL_ExtensionSupported
87 ///////////////////////////////////////////
88 // Check for default OpenGL
89 if (Sys_QGL_ExtensionSupported ("GL_ARB_texture_compression"))
91 g_qeglobals.bTextureCompressionSupported = 1;
92 g_qeglobals.m_bOpenGLCompressionSupported = 1;
95 // INSERT PROPRIETARY EXTENSIONS HERE
96 // Check for S3 extensions
97 // create a bool global for extension supported
98 if (Sys_QGL_ExtensionSupported ("GL_EXT_texture_compression_s3tc"))
100 g_qeglobals.bTextureCompressionSupported = 1;
101 g_qeglobals.m_bS3CompressionSupported = 1;
104 g_qeglobals.m_bOpenGLReady = true;
106 g_PrefsDlg.UpdateTextureCompression();
109 g_PrefsDlg.UpdateATIHack();
112 g_qeglobals_gui.d_camera = m_pWidget;
115 void CamWnd::Cam_Init ()
117 m_Camera.timing = false;
118 m_Camera.origin[0] = 0.f;
119 m_Camera.origin[1] = 20.f;
120 m_Camera.origin[2] = 46.f;
121 m_Camera.color[0] = 0.3f;
122 m_Camera.color[1] = 0.3f;
123 m_Camera.color[2] = 0.3f;
124 m_nCambuttonstate = 0;
127 void CamWnd::OnSize(int cx, int cy)
130 m_Camera.height = cy;
131 gtk_widget_queue_draw(m_pWidget);
134 rectangle_t rectangle_from_area_cam()
136 const float left = MIN(g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaBR[0]);
137 const float top = MAX(g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[1]);
138 const float right = MAX(g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaBR[0]);
139 const float bottom = MIN(g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[1]);
140 return rectangle_t(left, bottom, right - left, top - bottom);
143 void update_xor_rectangle(XORRectangle& xor_rectangle)
145 rectangle_t rectangle;
146 if ((g_qeglobals.d_select_mode == sel_area))
147 rectangle = rectangle_from_area_cam();
148 xor_rectangle.set(rectangle);
151 void CamWnd::OnMouseMove(guint32 flags, int pointx, int pointy)
153 int height = m_pWidget->allocation.height;
154 // NOTE RR2DO2 this hasn't got any use anymore really. It is an old qeradiant feature
155 // that can be re-enabled by removing the checks for HasCapture and not shift/ctrl down
156 // but the scaling/rotating (unless done with the steps set in the surface inspector
157 // dialog) is way too sensitive to be of any use
158 if (HasCapture () && Sys_AltDown () &&
159 !((flags & MK_SHIFT) || (flags & MK_CONTROL)))
161 if (flags & MK_CONTROL)
162 Select_RotateTexture(pointy - m_ptLastCursorY);
164 if (flags & MK_SHIFT)
165 Select_ScaleTexture(pointx - m_ptLastCursorX, m_ptLastCursorY - pointy);
167 Select_ShiftTexture(pointx - m_ptLastCursorX, m_ptLastCursorY - pointy);
171 Cam_MouseMoved(pointx, height - 1 - pointy, flags);
173 m_ptLastCursorX = pointx;
174 m_ptLastCursorY = pointy;
176 update_xor_rectangle(m_XORRectangle);
179 void CamWnd::OnMouseWheel(bool bUp)
182 VectorMA (m_Camera.origin, g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);
184 VectorMA (m_Camera.origin, -g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);
186 int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);
187 Sys_UpdateWindows (nUpdate);
188 g_pParentWnd->OnTimer ();
191 void CamWnd::OnLButtonDown(guint32 nFlags, int pointx, int pointy)
193 m_ptLastCursorX = pointx;
194 m_ptLastCursorY = pointy;
195 OriginalMouseDown(nFlags, pointx, pointy);
198 void CamWnd::OnLButtonUp(guint32 nFlags, int pointx, int pointy)
200 OriginalMouseUp(nFlags, pointx, pointy);
203 void CamWnd::OnMButtonDown(guint32 nFlags, int pointx, int pointy)
205 OriginalMouseDown(nFlags, pointx, pointy);
208 void CamWnd::OnMButtonUp(guint32 nFlags, int pointx, int pointy)
210 OriginalMouseUp(nFlags, pointx, pointy);
213 void CamWnd::OnRButtonDown(guint32 nFlags, int pointx, int pointy)
215 OriginalMouseDown(nFlags, pointx, pointy);
218 void CamWnd::OnRButtonUp(guint32 nFlags, int pointx, int pointy)
220 OriginalMouseUp(nFlags, pointx, pointy);
223 void CamWnd::OriginalMouseUp(guint32 nFlags, int pointx, int pointy)
225 int height = m_pWidget->allocation.height;
227 if(g_qeglobals.d_select_mode == sel_facets_on || g_qeglobals.d_select_mode == sel_facets_off)
229 g_qeglobals.d_select_mode = sel_brush;
232 Cam_MouseUp(pointx, height - 1 - pointy, nFlags);
235 update_xor_rectangle(m_XORRectangle);
238 void CamWnd::OriginalMouseDown(guint32 nFlags, int pointx, int pointy)
240 int height = m_pWidget->allocation.height;
244 Cam_MouseDown (pointx, height - 1 - pointy, nFlags);
246 update_xor_rectangle(m_XORRectangle);
249 void CamWnd::Cam_BuildMatrix()
257 ya = m_Camera.angles[1]/180*Q_PI;
259 // the movement matrix is kept 2d
260 m_Camera.forward[0] = cos(ya);
261 m_Camera.forward[1] = sin(ya);
262 m_Camera.forward[2] = 0;
263 m_Camera.right[0] = m_Camera.forward[1];
264 m_Camera.right[1] = -m_Camera.forward[0];
268 AngleVectors( m_Camera.angles, m_Camera.forward, m_Camera.right, NULL );
269 m_Camera.forward[2] = -m_Camera.forward[2];
272 memcpy(matrix, m_Camera.projection, sizeof(m4x4_t));
273 m4x4_multiply_by_m4x4(&matrix[0][0], &m_Camera.modelview[0][0]);
275 //qglGetFloatv (GL_PROJECTION_MATRIX, &matrix[0][0]);
277 for (i=0 ; i<3 ; i++)
279 m_Camera.vright[i] = matrix[i][0];
280 m_Camera.vup[i] = matrix[i][1];
281 m_Camera.vpn[i] = matrix[i][2];
284 VectorNormalize (m_Camera.vright, m_Camera.vright);
285 VectorNormalize (m_Camera.vup, m_Camera.vup);
286 VectorNormalize (m_Camera.vpn, m_Camera.vpn);
289 void CamWnd::Cam_ChangeFloor (qboolean up)
292 float d, bestd, current;
295 start[0] = m_Camera.origin[0];
296 start[1] = m_Camera.origin[1];
297 start[2] = g_MaxWorldCoord;
301 current = g_MaxWorldCoord - (m_Camera.origin[2] - 48);
305 bestd = 2*g_MaxWorldCoord;
307 for (b=active_brushes.next ; b != &active_brushes ; b=b->next)
309 if (!Brush_Ray (start, dir, b, &d))
311 if (up && d < current && d > bestd)
313 if (!up && d > current && d < bestd)
317 if (bestd == 0 || bestd == 2*g_MaxWorldCoord)
320 m_Camera.origin[2] += current - bestd;
321 Sys_UpdateWindows (W_CAMERA|W_Z_OVERLAY);
324 void CamWnd::Cam_PositionDrag()
328 Sys_GetCursorPos (&x, &y);
329 if (x != m_ptCursorX || y != m_ptCursorY)
332 VectorMA (m_Camera.origin, x, m_Camera.vright, m_Camera.origin);
334 m_Camera.origin[2] -= y;
335 Sys_SetCursorPos(m_ptCursorX, m_ptCursorY);
336 Sys_UpdateWindows (W_CAMERA | W_XY_OVERLAY);
340 void CamWnd::Cam_MouseControl (float dtime)
342 Cam_KeyControl (dtime);
344 if( g_PrefsDlg.m_bCamFreeLook )
349 if( !m_bFreeMove || m_nCambuttonstate == MK_CONTROL )
353 Sys_GetCursorPos(&m_ptCursorX, &m_ptCursorY);
355 dx = m_ptLastCamCursorX - m_ptCursorX;
356 dy = m_ptLastCamCursorY - m_ptCursorY;
358 gdk_window_get_origin( m_pWidget->window, &x, &y);
360 m_ptLastCamCursorX = x + (m_Camera.width / 2);
361 m_ptLastCamCursorY = y + (m_Camera.height / 2);
363 Sys_SetCursorPos(m_ptLastCamCursorX, m_ptLastCamCursorY);
366 if(!g_PrefsDlg.m_bCamFreeLookStrafe) {
367 if (g_PrefsDlg.m_bCamInverseMouse)
368 m_Camera.angles[PITCH] -= dy * dtime * g_PrefsDlg.m_nAngleSpeed;
370 m_Camera.angles[PITCH] += dy * dtime * g_PrefsDlg.m_nAngleSpeed;
372 VectorMA (m_Camera.origin, dy * (float) (g_PrefsDlg.m_nMoveSpeed / 6.0f), m_Camera.forward, m_Camera.origin);
375 m_Camera.angles[YAW] += dx * dtime * g_PrefsDlg.m_nAngleSpeed;
377 if (m_Camera.angles[PITCH] > 90)
378 m_Camera.angles[PITCH] = 90;
379 else if (m_Camera.angles[PITCH] < -90)
380 m_Camera.angles[PITCH] = -90;
382 if (m_Camera.angles[YAW] >= 360)
383 m_Camera.angles[YAW] = 0;
384 else if (m_Camera.angles[YAW] <= -360)
385 m_Camera.angles[YAW] = 0;
387 if( dx || dy || m_Camera.movementflags )
389 int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);
390 Sys_UpdateWindows (nUpdate);
391 g_pParentWnd->OnTimer ();
400 if (g_PrefsDlg.m_nMouseButtons == 2)
402 if (m_nCambuttonstate != (MK_RBUTTON | MK_SHIFT))
407 if (m_nCambuttonstate != MK_RBUTTON)
411 xf = (float)(m_ptButtonX - m_Camera.width/2) / (m_Camera.width/2);
412 yf = (float)(m_ptButtonY - m_Camera.height/2) / (m_Camera.height/2);
414 xl = m_Camera.width/3;
416 yl = m_Camera.height/3;
419 xf *= 1.0 - fabs(yf);
433 VectorMA (m_Camera.origin, yf*dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);
434 m_Camera.angles[YAW] += xf*-dtime*g_PrefsDlg.m_nAngleSpeed;
436 int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);
437 Sys_UpdateWindows (nUpdate);
438 g_pParentWnd->OnTimer ();
442 void CamWnd::Cam_KeyControl (float dtime) {
445 if (m_Camera.movementflags & MOVE_ROTLEFT)
446 m_Camera.angles[YAW] += 15*dtime*g_PrefsDlg.m_nAngleSpeed;
447 if (m_Camera.movementflags & MOVE_ROTRIGHT)
448 m_Camera.angles[YAW] -= 15*dtime*g_PrefsDlg.m_nAngleSpeed;
451 if (m_Camera.movementflags & MOVE_FORWARD)
452 VectorMA (m_Camera.origin, dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);
453 if (m_Camera.movementflags & MOVE_BACK)
454 VectorMA (m_Camera.origin, -dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);
455 if (m_Camera.movementflags & MOVE_STRAFELEFT)
456 VectorMA (m_Camera.origin, -dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.right, m_Camera.origin);
457 if (m_Camera.movementflags & MOVE_STRAFERIGHT)
458 VectorMA (m_Camera.origin, dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.right, m_Camera.origin);
460 // Save a screen update (when m_bFreeMove is enabled, mousecontrol does the update)
461 if( !m_bFreeMove && m_Camera.movementflags )
463 int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);
464 Sys_UpdateWindows (nUpdate);
465 g_pParentWnd->OnTimer ();
469 // NOTE TTimo if there's an OS-level focus out of the application
470 // then we can release the camera cursor grab
471 static gint camwindow_focusout(GtkWidget* widget, GdkEventKey* event, gpointer data)
473 g_pParentWnd->GetCamWnd ()->ToggleFreeMove();
477 void CamWnd::ToggleFreeMove()
482 m_bFreeMove = !m_bFreeMove;
483 Camera()->movementflags = 0;
484 m_ptLastCamCursorX = m_ptCursorX;
485 m_ptLastCamCursorY = m_ptCursorY;
487 if (g_pParentWnd->CurrentStyle() == MainFrame::eFloating)
489 widget = g_pParentWnd->GetCamWnd ()->m_pParent;
490 window = widget->window;
494 widget = g_pParentWnd->m_pWidget;
495 window = widget->window;
507 char buffer [(32 * 32)/8];
508 memset (buffer, 0, (32 * 32)/8);
509 GdkColor white = {0, 0xffff, 0xffff, 0xffff};
510 GdkColor black = {0, 0x0000, 0x0000, 0x0000};
511 pixmap = gdk_bitmap_create_from_data (NULL, buffer, 32, 32);
512 mask = gdk_bitmap_create_from_data (NULL, buffer, 32, 32);
513 GdkCursor *cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &white, &black, 1, 1);
515 gdk_window_set_cursor (window, cursor);
516 gdk_cursor_unref (cursor);
517 gdk_drawable_unref (pixmap);
518 gdk_drawable_unref (mask);
521 // RR2DO2: FIXME why does this only work the 2nd and
522 // further times the event is called? (floating windows
523 // mode seems to work fine though...)
524 m_FocusOutHandler_id = gtk_signal_connect (GTK_OBJECT (widget), "focus_out_event",
525 GTK_SIGNAL_FUNC (camwindow_focusout), g_pParentWnd);
528 GdkEventMask mask = (GdkEventMask)(GDK_POINTER_MOTION_MASK
529 | GDK_POINTER_MOTION_HINT_MASK
530 | GDK_BUTTON_MOTION_MASK
531 | GDK_BUTTON1_MOTION_MASK
532 | GDK_BUTTON2_MOTION_MASK
533 | GDK_BUTTON3_MOTION_MASK
534 | GDK_BUTTON_PRESS_MASK
535 | GDK_BUTTON_RELEASE_MASK);
537 gdk_pointer_grab(widget->window, TRUE, mask, widget->window, NULL, GDK_CURRENT_TIME);
542 gdk_pointer_ungrab(GDK_CURRENT_TIME);
544 gtk_signal_disconnect (GTK_OBJECT (widget), m_FocusOutHandler_id);
546 GdkCursor *cursor = gdk_cursor_new (GDK_LEFT_PTR);
547 gdk_window_set_cursor (window, cursor);
548 gdk_cursor_unref (cursor);
553 int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);
554 Sys_UpdateWindows (nUpdate);
555 g_pParentWnd->OnTimer ();
558 void CamWnd::Cam_MouseDown(int x, int y, int buttons)
566 // calc ray direction
568 u = (float)( y - ( m_Camera.height * .5f ) ) / ( m_Camera.width * .5f );
569 r = (float)( x - ( m_Camera.width * .5f ) ) / ( m_Camera.width * .5f );
572 for (i=0 ; i<3 ; i++)
573 dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;
574 VectorNormalize (dir, dir);
576 Sys_GetCursorPos(&m_ptCursorX, &m_ptCursorY);
578 m_nCambuttonstate = buttons;
582 // LBUTTON = manipulate selection
583 // shift-LBUTTON = select
584 // middle button = grab texture
585 // ctrl-middle button = set entire brush to texture
586 // ctrl-shift-middle button = set single face to texture
587 int nMouseButton = g_PrefsDlg.m_nMouseButtons == 2 ? MK_RBUTTON : MK_MBUTTON;
588 if ((buttons == MK_LBUTTON)
589 || (buttons == (MK_LBUTTON | MK_SHIFT))
590 || (buttons == (MK_LBUTTON | MK_CONTROL))
591 || (buttons == (MK_LBUTTON | MK_CONTROL | MK_SHIFT))
592 || (buttons == nMouseButton)
593 || (buttons == (nMouseButton|MK_SHIFT))
594 || (buttons == (nMouseButton|MK_CONTROL))
595 || (buttons == (nMouseButton|MK_SHIFT|MK_CONTROL)))
597 if (g_PrefsDlg.m_nMouseButtons == 2 && (buttons == (MK_RBUTTON | MK_SHIFT)))
599 if (g_PrefsDlg.m_bCamFreeLook)
602 Cam_MouseControl (0.1f);
606 // something global needs to track which window is responsible for stuff
607 Patch_SetView(W_CAMERA);
608 Drag_Begin (x, y, buttons, m_Camera.vright, m_Camera.vup, m_Camera.origin, dir, true);
613 if (buttons == MK_RBUTTON)
615 if (g_PrefsDlg.m_bCamFreeLook)
618 Cam_MouseControl (0.1f);
623 void CamWnd::Cam_MouseUp (int x, int y, int buttons)
625 m_nCambuttonstate = 0;
626 Drag_MouseUp (buttons);
629 void CamWnd::Cam_MouseMoved (int x, int y, int buttons)
631 m_nCambuttonstate = buttons;
635 if( g_PrefsDlg.m_nCamDragMultiSelect )
637 if (g_qeglobals.d_select_mode == sel_brush_on || g_qeglobals.d_select_mode == sel_brush_off)
639 bool bDoDragMultiSelect = FALSE;
641 if( g_PrefsDlg.m_nCamDragMultiSelect == 1 && buttons == (MK_LBUTTON|MK_SHIFT) )
642 bDoDragMultiSelect = TRUE;
643 else if( g_PrefsDlg.m_nCamDragMultiSelect == 2 && buttons == (MK_LBUTTON|MK_CONTROL) && Sys_AltDown() )
644 bDoDragMultiSelect = TRUE;
646 if( bDoDragMultiSelect )
653 // calc ray direction
655 u = (float)( y - ( m_Camera.height * .5f ) ) / ( m_Camera.width * .5f );
656 r = (float)( x - ( m_Camera.width * .5f ) ) / ( m_Camera.width * .5f );
659 for (i=0 ; i<3 ; i++)
660 dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;
661 VectorNormalize (dir,dir);
663 switch( g_qeglobals.d_select_mode )
666 Select_Ray( m_Camera.origin, dir, (SF_DRAG_ON|SF_CAMERA) );
670 Select_Ray( m_Camera.origin, dir, (SF_DRAG_OFF|SF_CAMERA) );
679 else if (g_qeglobals.d_select_mode == sel_facets_on || g_qeglobals.d_select_mode == sel_facets_off)
681 if( buttons == (MK_LBUTTON|MK_CONTROL|MK_SHIFT) )
688 // calc ray direction
690 u = (float)( y - ( m_Camera.height * .5f ) ) / ( m_Camera.width * .5f );
691 r = (float)( x - ( m_Camera.width * .5f ) ) / ( m_Camera.width * .5f );
694 for (i=0 ; i<3 ; i++)
695 dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;
696 VectorNormalize (dir,dir);
698 switch( g_qeglobals.d_select_mode )
701 Select_Ray( m_Camera.origin, dir, (SF_SINGLEFACE|SF_DRAG_ON|SF_CAMERA) );
705 Select_Ray( m_Camera.origin, dir, (SF_SINGLEFACE|SF_DRAG_OFF|SF_CAMERA) );
719 if ( (m_bFreeMove && (buttons & MK_CONTROL) && !(buttons & MK_SHIFT)) || (!m_bFreeMove && (buttons == (MK_RBUTTON|MK_CONTROL))) )
722 Sys_UpdateWindows (W_XY|W_CAMERA|W_Z);
726 Sys_GetCursorPos(&m_ptCursorX, &m_ptCursorY);
728 if (buttons & (MK_LBUTTON | MK_MBUTTON) )
730 Drag_MouseMoved (x, y, buttons);
731 if(g_qeglobals.d_select_mode != sel_area)
732 Sys_UpdateWindows (W_XY|W_CAMERA|W_Z);
736 void CamWnd::InitCull()
740 VectorSubtract (m_Camera.vpn, m_Camera.vright, m_vCull1);
741 VectorAdd (m_Camera.vpn, m_Camera.vright, m_vCull2);
743 for (i=0 ; i<3 ; i++)
756 qboolean CamWnd::CullBrush (brush_t *b)
762 if (g_PrefsDlg.m_bCubicClipping)
764 float fLevel = g_PrefsDlg.m_nCubicScale * 64;
766 point[0] = m_Camera.origin[0] - fLevel;
767 point[1] = m_Camera.origin[1] - fLevel;
768 point[2] = m_Camera.origin[2] - fLevel;
771 if (b->mins[i] < point[i] && b->maxs[i] < point[i])
774 point[0] = m_Camera.origin[0] + fLevel;
775 point[1] = m_Camera.origin[1] + fLevel;
776 point[2] = m_Camera.origin[2] + fLevel;
779 if (b->mins[i] > point[i] && b->maxs[i] > point[i])
783 for (i=0 ; i<3 ; i++)
784 point[i] = b->mins[m_nCullv1[i]] - m_Camera.origin[i];
786 d = DotProduct (point, m_vCull1);
790 for (i=0 ; i<3 ; i++)
791 point[i] = b->mins[m_nCullv2[i]] - m_Camera.origin[i];
793 d = DotProduct (point, m_vCull2);
800 // project a 3D point onto the camera space
801 // we use the GL viewing matrixes
802 // this is the implementation of a glu function (I realized that afterwards): gluProject
803 void CamWnd::ProjectCamera(const vec3_t A, vec_t B[2])
806 vec_t P1[4],P2[4],P3[4];
807 VectorCopy(A,P1); P1[3] = 1;
809 GLMatMul(m_Camera.modelview , P1, P2);
810 GLMatMul(m_Camera.projection, P2, P3);
812 // we ASSUME that the view port is 0 0 m_Camera.width m_Camera.height (you can check in Cam_Draw)
813 B[0] = (float)m_Camera.width * ( P3[0] + 1.0 ) / 2.0;
814 B[1] = (float)m_Camera.height * ( P3[1] + 1.0 ) / 2.0;
818 // vec defines a direction in geometric space and P an origin point
819 // the user is interacting from the camera view
820 // (for example with texture adjustment shortcuts)
821 // and intuitively if he hits left / right / up / down
822 // what happens in geometric space should match the left/right/up/down move in camera space
823 // axis = 0: vec is along left/right
824 // axis = 1: vec is along up/down
825 // sgn = +1: same directions
826 // sgn = -1: opposite directions
828 // typical use case is giving a face center and a normalized vector
829 // 1) compute start and endpoint, project them in camera view, get the direction
830 // depending on the situation, we might bump into precision issues with that
831 // 2) possible to compute the projected direction independently?
832 // this solution would be better but right now I don't see how to do it..
833 void CamWnd::MatchViewAxes(const vec3_t P, const vec3_t vec, int &axis, float &sgn)
836 vec_t A[2],B[2],V[2];
841 // V is the vector projected in camera space
844 if (fabs(V[0])>fabs(V[1]))
846 // best match is against right
855 // best match is against up
865 void CamWnd::DrawLightRadius(brush_t* pBrush)
868 int nRadius = Brush_LightRadius(pBrush);
871 Brush_SetLightColor(pBrush);
872 qglEnable (GL_BLEND);
873 qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
874 qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
875 qglDisable (GL_TEXTURE_2D);
877 qglEnable(GL_TEXTURE_2D);
878 qglDisable(GL_BLEND);
879 qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
884 extern void DrawPatchMesh(patchMesh_t *pm);
885 extern void DrawPatchControls(patchMesh_t *pm);
886 extern void Brush_DrawFacingAngle (brush_t *b, entity_t *e);
887 extern void Brush_DrawModel(brush_t *b, bool bTextured = false);
888 extern void DrawModelOrigin(brush_t *b);
889 extern void DrawModelBBox(brush_t *b);
891 void CamWnd::Cam_DrawBrush(brush_t *b, int mode)
893 int nGLState = m_Camera.draw_glstate;
894 int nModelMode = g_PrefsDlg.m_nEntityShowState;
896 GLfloat material[4], identity[4];
897 VectorSet(identity, 0.8f, 0.8f, 0.8f);
901 if (b->owner->eclass->fixedsize && b->owner->eclass->nShowFlags & ECLASS_LIGHT && g_PrefsDlg.m_bNewLightDraw)
906 VectorCopy(b->owner->color, material);
907 VectorScale(material, 0.8f, material);
910 qglColor4fv(material);
912 if (g_PrefsDlg.m_bNewLightDraw)
913 DrawLight(b->owner, nGLState, (IsBrushSelected(b)) ? g_PrefsDlg.m_nLightRadiuses : 0, 0);
920 else if(b->owner->eclass->fixedsize && b->owner->model.pRender
921 && !(!IsBrushSelected(b) && (nModelMode & ENTITY_SELECTED_ONLY)))
926 if (!(nModelMode & ENTITY_WIREFRAME) && nModelMode != ENTITY_BOX)
928 VectorCopy(b->owner->eclass->color, material);
929 material[3] = identity[3] = 1.0f;
931 qglEnable(GL_CULL_FACE);
933 if(!(nGLState & DRAW_GL_TEXTURE_2D)) qglColor4fv(material);
934 else qglColor4fv(identity);
935 if(nGLState & DRAW_GL_LIGHTING) qglShadeModel(GL_SMOOTH);
937 b->owner->model.pRender->Draw(nGLState, DRAW_RF_CAM);
941 VectorCopy(b->owner->eclass->color, material);
943 qglColor4fv(material);
945 // model view mode "wireframe" or "selected wire"
946 if(nModelMode & ENTITY_WIREFRAME)
947 b->owner->model.pRender->Draw(nGLState, DRAW_RF_CAM);
949 // model view mode "skinned and boxed"
950 if(!(b->owner->eclass->nShowFlags & ECLASS_MISCMODEL) )
952 qglColor4fv(material);
953 aabb_draw(b->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);
955 else if(nModelMode & ENTITY_BOXED)
957 aabb_draw(b->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);
960 if(!(nModelMode & ENTITY_BOXED) && b->owner->eclass->nShowFlags & ECLASS_MISCMODEL)
967 else if (b->patchBrush)
969 bool bTrans = (b->pPatch->pShader->getTrans() < 1.0f);
973 if (!g_bPatchWireFrame && ((nGLState & DRAW_GL_BLEND && bTrans) || (!(nGLState & DRAW_GL_BLEND) && !bTrans)))
975 qglDisable(GL_CULL_FACE);
977 pShader = b->pPatch->pShader;
978 VectorCopy(pShader->getTexture()->color, material);
979 material[3] = identity[3] = pShader->getTrans();
981 if(nGLState & DRAW_GL_TEXTURE_2D) {
982 qglColor4fv(identity);
983 qglBindTexture(GL_TEXTURE_2D, pShader->getTexture()->texture_number);
986 qglColor4fv(material);
987 if(nGLState & DRAW_GL_LIGHTING) qglShadeModel(GL_SMOOTH);
989 DrawPatchMesh(b->pPatch);
993 if (g_bPatchWireFrame)
995 VectorCopy(b->pPatch->pShader->getTexture()->color, material);
997 qglColor4fv(material);
998 DrawPatchMesh(b->pPatch);
1000 if ( b->pPatch->bSelected && (g_qeglobals.d_select_mode == sel_curvepoint
1001 || g_qeglobals.d_select_mode == sel_area
1002 || g_bPatchBendMode))
1003 DrawPatchControls(b->pPatch);
1008 else if(b->owner->eclass->fixedsize)
1013 VectorCopy(b->owner->eclass->color, material);
1014 VectorScale(material, 0.8f, material);
1016 qglColor4fv(material);
1018 qglEnable(GL_CULL_FACE);
1019 qglShadeModel(GL_FLAT);
1023 if((g_qeglobals.d_savedinfo.include & INCLUDE_ANGLES)
1024 && (b->owner->eclass->nShowFlags & ECLASS_ANGLE))
1025 Brush_DrawFacingAngle(b, b->owner);
1035 qglEnable(GL_CULL_FACE);
1036 qglShadeModel(GL_FLAT);
1042 void CamWnd::Cam_DrawBrushes(int mode)
1045 brush_t *pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;
1047 for(b = active_brushes.next; b != &active_brushes; b=b->next)
1048 if (!b->bFiltered && !b->bCamCulled) Cam_DrawBrush(b, mode);
1049 for(b = pList->next; b != pList; b=b->next)
1050 if (!b->bFiltered && !b->bCamCulled) Cam_DrawBrush(b, mode);
1053 void CamWnd::Cam_DrawStuff()
1055 GLfloat identity[4];
1056 VectorSet(identity, 0.8f, 0.8f, 0.8f);
1059 for(b = active_brushes.next; b != &active_brushes; b=b->next)
1060 b->bCamCulled = CullBrush(b);
1062 for(b = selected_brushes.next; b != &selected_brushes; b=b->next)
1063 b->bCamCulled = CullBrush(b);
1065 switch (m_Camera.draw_mode)
1068 qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1069 qglDisable(GL_TEXTURE_2D);
1070 qglDisable(GL_TEXTURE_1D);
1071 qglDisable(GL_BLEND);
1072 qglEnable(GL_DEPTH_TEST);
1073 qglEnableClientState(GL_VERTEX_ARRAY);
1074 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
1075 qglShadeModel(GL_FLAT);
1076 if(g_PrefsDlg.m_bGLLighting) {
1077 qglDisable(GL_LIGHTING);
1078 qglDisable(GL_COLOR_MATERIAL);
1079 qglDisableClientState(GL_NORMAL_ARRAY);
1081 m_Camera.draw_glstate = DRAW_GL_WIRE;
1085 qglCullFace(GL_FRONT);
1086 qglEnable(GL_CULL_FACE);
1087 qglShadeModel (GL_FLAT);
1088 qglPolygonMode (GL_FRONT, GL_LINE);
1089 qglPolygonMode (GL_BACK, GL_FILL);
1090 qglDisable(GL_TEXTURE_2D);
1091 qglDisable(GL_BLEND);
1092 qglEnable(GL_DEPTH_TEST);
1093 qglEnableClientState(GL_VERTEX_ARRAY);
1094 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
1095 qglPolygonOffset(-1.0, 2);
1096 if(g_PrefsDlg.m_bGLLighting) {
1097 qglEnable(GL_LIGHTING);
1098 qglEnable(GL_COLOR_MATERIAL);
1099 // qglEnable(GL_RESCALE_NORMAL);
1100 qglEnableClientState(GL_NORMAL_ARRAY);
1102 m_Camera.draw_glstate = DRAW_GL_SOLID;
1106 qglCullFace(GL_FRONT);
1107 qglEnable(GL_CULL_FACE);
1108 qglShadeModel (GL_FLAT);
1109 qglPolygonMode (GL_FRONT, GL_LINE);
1110 qglPolygonMode (GL_BACK, GL_FILL);
1111 qglEnable(GL_TEXTURE_2D);
1112 qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1113 qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1114 qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
1115 qglDisable(GL_BLEND);
1116 qglEnable(GL_DEPTH_TEST);
1117 qglEnableClientState(GL_VERTEX_ARRAY);
1118 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
1119 if(g_PrefsDlg.m_bGLLighting) {
1120 qglEnable(GL_LIGHTING);
1121 qglDisable(GL_COLOR_MATERIAL);
1122 qglMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, identity);
1123 qglEnableClientState(GL_NORMAL_ARRAY);
1124 // qglEnable(GL_RESCALE_NORMAL);
1126 qglPolygonOffset(-1.0, 2);
1127 m_Camera.draw_glstate = DRAW_GL_TEXTURED;
1130 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1133 Cam_DrawBrushes(DRAW_TEXTURED);
1135 // setup for solid stuff
1136 switch(m_Camera.draw_mode)
1139 qglDisable(GL_TEXTURE_2D);
1140 m_Camera.draw_glstate &= ~DRAW_GL_TEXTURE_2D;
1141 if(g_PrefsDlg.m_bGLLighting)
1142 qglEnable(GL_COLOR_MATERIAL);
1143 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
1149 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1152 qglEnable(GL_CULL_FACE);
1153 qglShadeModel(GL_FLAT);
1154 Cam_DrawBrushes(DRAW_SOLID);
1156 // setup for wireframe stuff
1157 switch(m_Camera.draw_mode)
1160 if(g_PrefsDlg.m_bGLLighting) {
1161 qglDisable(GL_LIGHTING);
1162 qglDisable(GL_COLOR_MATERIAL);
1163 qglDisableClientState(GL_NORMAL_ARRAY);
1164 // qglDisable(GL_RESCALE_NORMAL);
1166 qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1169 if(g_PrefsDlg.m_bGLLighting) {
1170 qglDisable(GL_LIGHTING);
1171 qglDisable(GL_COLOR_MATERIAL);
1172 qglDisableClientState(GL_NORMAL_ARRAY);
1173 // qglDisable(GL_RESCALE_NORMAL);
1175 qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1179 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1182 qglDisable(GL_CULL_FACE);
1183 Cam_DrawBrushes(DRAW_WIRE);
1185 // setup for transparent texture stuff
1186 switch(m_Camera.draw_mode)
1189 qglPolygonMode (GL_FRONT, GL_LINE);
1190 qglPolygonMode (GL_BACK, GL_FILL);
1191 if(g_PrefsDlg.m_bGLLighting) {
1192 qglEnable(GL_COLOR_MATERIAL);
1193 qglEnableClientState(GL_NORMAL_ARRAY);
1194 qglMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, identity);
1196 qglEnable(GL_TEXTURE_2D);
1197 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
1198 m_Camera.draw_glstate = DRAW_GL_TEXTURED;
1201 qglPolygonMode (GL_FRONT, GL_LINE);
1202 qglPolygonMode (GL_BACK, GL_FILL);
1203 if(g_PrefsDlg.m_bGLLighting) {
1204 qglEnable(GL_LIGHTING);
1205 qglEnable(GL_COLOR_MATERIAL);
1206 qglEnableClientState(GL_NORMAL_ARRAY);
1207 // qglEnable(GL_RESCALE_NORMAL);
1209 m_Camera.draw_glstate = DRAW_GL_SOLID;
1212 m_Camera.draw_glstate = DRAW_GL_WIRE;
1214 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1218 qglEnable(GL_BLEND);
1219 m_Camera.draw_glstate |= DRAW_GL_BLEND;
1220 qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1221 // FIXME: some .TGA are buggy, have a completely empty alpha channel
1222 // if such brushes are rendered in this loop they would be totally transparent with GL_MODULATE
1223 // so I decided using GL_DECAL instead
1224 // if an empty-alpha-channel or nearly-empty texture is used. It will be blank-transparent.
1225 // this could get better if you can get qglTexEnviv (GL_TEXTURE_ENV, to work .. patches are welcome
1226 // Arnout: empty alpha channels are now always filled with data. Don't set this anymore (would cause problems with qer_alphafunc too)
1227 // qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
1229 Cam_DrawBrushes(DRAW_TEXTURED);
1231 // qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1232 qglDisable(GL_BLEND);
1234 // setup for wireframe stuff
1235 switch(m_Camera.draw_mode)
1238 if(g_PrefsDlg.m_bGLLighting) {
1239 qglDisable(GL_COLOR_MATERIAL);
1240 qglDisable(GL_LIGHTING);
1241 // qglDisable(GL_RESCALE_NORMAL);
1245 if(g_PrefsDlg.m_bGLLighting) {
1246 qglDisable(GL_COLOR_MATERIAL);
1247 qglDisable(GL_LIGHTING);
1248 // qglDisable(GL_RESCALE_NORMAL);
1253 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1267 void CamWnd::Cam_Draw()
1273 double start = 0.0, end;
1276 if (!active_brushes.next)
1277 return; // not valid yet
1279 if (m_Camera.timing)
1280 start = Sys_DoubleTime ();
1285 QE_CheckOpenGLForErrors();
1287 qglViewport(0, 0, m_Camera.width, m_Camera.height);
1288 qglClearColor (g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][0],
1289 g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][1],
1290 g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][2], 0);
1291 qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1298 qglMatrixMode(GL_PROJECTION);
1301 screenaspect = (float)m_Camera.width / m_Camera.height;
1302 yfov = 2*atan((float)m_Camera.height / m_Camera.width)*180/Q_PI;
1303 qgluPerspective (yfov, screenaspect, 8, 32768);
1305 // we're too lazy to calc projection matrix ourselves!!!
1306 qglGetFloatv (GL_PROJECTION_MATRIX, &m_Camera.projection[0][0]);
1310 m4x4_identity(&m_Camera.modelview[0][0]);
1311 VectorSet(vec, -90, 0, 0);
1312 m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);
1313 VectorSet(vec, 0, 0, 90);
1314 m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);
1315 VectorSet(vec, 0, m_Camera.angles[0], 0);
1316 m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);
1317 VectorSet(vec, 0, 0, -m_Camera.angles[1]);
1318 m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);
1319 VectorSet(vec, -m_Camera.origin[0], -m_Camera.origin[1], -m_Camera.origin[2]);
1320 m4x4_translate_by_vec3(&m_Camera.modelview[0][0], vec);
1324 qglMatrixMode(GL_MODELVIEW);
1327 qglMultMatrixf(&m_Camera.modelview[0][0]);
1329 // grab the GL_PROJECTION and GL_MODELVIEW matrixes
1330 // used in GetRelativeAxes
1331 //qglGetFloatv (GL_PROJECTION_MATRIX, &m_Camera.projection[0][0]);
1332 //qglGetFloatv (GL_MODELVIEW_MATRIX, &m_Camera.modelview[0][0]);
1335 // TTimo: this is not used, just for verification (0, 0, m_Camera.width, m_Camera.height)
1337 qglGetIntegerv (GL_VIEWPORT, viewprt);
1340 if (g_PrefsDlg.m_bGLLighting)
1342 GLfloat inverse_cam_dir[4], ambient[4], diffuse[4];//, material[4];
1344 ambient[0] = ambient[1] = ambient[2] = 0.6f;
1346 diffuse[0] = diffuse[1] = diffuse[2] = 0.4f;
1348 //material[0] = material[1] = material[2] = 0.8f;
1349 //material[3] = 1.0f;
1351 vec3_t vCam, vRotate;
1352 VectorSet(vCam, -1, 0, 0); //default cam pos
1353 VectorSet(vRotate, 0, -m_Camera.angles[0], 0);
1354 VectorRotate(vCam, vRotate, vCam);
1355 VectorSet(vRotate, 0, 0, m_Camera.angles[1]);
1356 VectorRotate(vCam, vRotate, vCam);
1358 inverse_cam_dir[0] = vCam[0];
1359 inverse_cam_dir[1] = vCam[1];
1360 inverse_cam_dir[2] = vCam[2];
1361 inverse_cam_dir[3] = 0;
1363 qglColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
1365 qglLightfv(GL_LIGHT0, GL_POSITION, inverse_cam_dir);
1367 qglLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
1368 qglLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
1370 qglEnable(GL_LIGHT0);
1381 qglEnableClientState(GL_VERTEX_ARRAY);
1382 qglDisableClientState(GL_NORMAL_ARRAY);
1383 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
1384 qglDisable (GL_TEXTURE_2D);
1385 qglDisable (GL_LIGHTING);
1386 qglDisable (GL_COLOR_MATERIAL);
1388 qglEnable (GL_CULL_FACE);
1390 brush_t* pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;
1392 if (g_qeglobals.d_savedinfo.iSelectedOutlinesStyle & OUTLINE_BSEL)
1394 qglColor4f(g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES3D][0], g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES3D][1], g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES3D][2], 0.3f);
1395 qglEnable (GL_BLEND);
1396 qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1397 qglDepthFunc (GL_LEQUAL);
1398 for (brush = pList->next ; brush != pList ; brush=brush->next)
1400 if (brush->bCamCulled) // draw selected faces of filtered brushes to remind that there is a selection
1403 if (brush->patchBrush && (g_qeglobals.d_select_mode == sel_curvepoint || g_qeglobals.d_select_mode == sel_area))
1406 if (!g_PrefsDlg.m_bPatchBBoxSelect && brush->patchBrush)
1408 DrawPatchMesh(brush->pPatch);
1410 else if(brush->owner->model.pRender && g_PrefsDlg.m_nEntityShowState != ENTITY_BOX)
1412 brush->owner->model.pRender->Draw(DRAW_GL_FLAT, (DRAW_RF_SEL_OUTLINE|DRAW_RF_CAM));
1416 for (face=brush->brush_faces ; face ; face=face->next)
1417 Brush_FaceDraw(face, DRAW_GL_FLAT);
1422 int nCount = g_ptrSelectedFaces.GetSize();
1425 for (int i = 0; i < nCount; i++)
1427 face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));
1428 Brush_FaceDraw(selFace, DRAW_GL_FLAT);
1432 qglDisableClientState(GL_NORMAL_ARRAY);
1433 qglDepthFunc (GL_LESS);
1436 if (g_qeglobals.d_savedinfo.iSelectedOutlinesStyle & OUTLINE_ZBUF)
1438 // non-zbuffered outline
1439 qglDisable (GL_BLEND);
1440 qglDisable (GL_DEPTH_TEST);
1441 qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1442 qglColor3f (1, 1, 1);
1443 for (brush = pList->next ; brush != pList ; brush=brush->next)
1445 if ((brush->patchBrush && (g_qeglobals.d_select_mode == sel_curvepoint || g_qeglobals.d_select_mode == sel_area)))
1448 if (!g_PrefsDlg.m_bPatchBBoxSelect && brush->patchBrush)
1450 DrawPatchMesh(brush->pPatch);
1452 else if(brush->owner->model.pRender && g_PrefsDlg.m_nEntityShowState != ENTITY_BOX)
1454 brush->owner->model.pRender->Draw(DRAW_GL_WIRE, (DRAW_RF_SEL_FILL|DRAW_RF_CAM));
1456 // Hydra : always draw bbox outline!
1457 aabb_draw(brush->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);
1461 for (face=brush->brush_faces ; face ; face=face->next)
1462 Brush_FaceDraw(face, DRAW_GL_WIRE);
1467 // edge / vertex flags
1468 if (g_qeglobals.d_select_mode == sel_vertex)
1470 // GL_POINTS on Kyro Workaround
1471 if(!g_PrefsDlg.m_bGlPtWorkaround)
1476 qglBegin (GL_POINTS);
1477 for (i=0 ; i<g_qeglobals.d_numpoints ; i++)
1478 qglVertex3fv (g_qeglobals.d_points[i]);
1481 if(g_qeglobals.d_num_move_points)
1483 // selected brush verts
1486 qglBegin (GL_POINTS);
1487 for(i = 0; i < g_qeglobals.d_num_move_points; i++)
1488 qglVertex3fv (g_qeglobals.d_move_points[i]);
1499 qglBegin (GL_LINES);
1500 for (i=0; i < g_qeglobals.d_numpoints; i++)
1501 DrawAlternatePoint(g_qeglobals.d_points[i], 1.5);
1504 if(g_qeglobals.d_num_move_points)
1506 // selected brush verts
1509 qglBegin (GL_LINES);
1510 for(i = 0; i < g_qeglobals.d_num_move_points; i++)
1511 qglVertex3fv (g_qeglobals.d_move_points[i]);
1517 else if (g_qeglobals.d_select_mode == sel_edge)
1520 // GL_POINTS on Kyro Workaround
1521 if(!g_PrefsDlg.m_bGlPtWorkaround)
1525 qglBegin (GL_POINTS);
1526 for (i=0 ; i<g_qeglobals.d_numedges ; i++)
1528 v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1];
1529 v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2];
1530 qglVertex3f ( (v1[0]+v2[0])*0.5,(v1[1]+v2[1])*0.5,(v1[2]+v2[2])*0.5);
1538 qglBegin (GL_LINES);
1539 for (i=0; i < g_qeglobals.d_numedges; i++)
1541 v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1];
1542 v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2];
1544 v3[0] = (v1[0]+v2[0])*0.5;
1545 v3[1] = (v1[1]+v2[1])*0.5;
1546 v3[2] = (v1[2]+v2[2])*0.5;
1547 DrawAlternatePoint(v3, 1.5);
1557 qglEnable(GL_DEPTH_TEST);
1560 if (g_qeglobals.d_pointfile_display_list)
1565 // call the drawing routine of plugin entities
1566 //++timo FIXME: we might need to hook in other places as well for transparency etc.
1567 //++timo FIXME: also needs a way to get some parameters about the view
1568 //++timo FIXME: maybe provide some culling API on Radiant side?
1569 Draw3DPluginEntities();
1571 // draw the crosshair
1574 // setup orthographic projection mode
1575 qglMatrixMode(GL_PROJECTION);
1578 qglDisable(GL_DEPTH_TEST);
1579 qglOrtho(0, (float)m_Camera.width, 0, (float)m_Camera.height, -100, 100);
1580 qglScalef(1, -1, 1);
1581 qglTranslatef(0, -(float)m_Camera.height, 0);
1582 qglMatrixMode(GL_MODELVIEW);
1587 qglColor3f( 1.f, 1.f, 1.f );
1588 qglBegin( GL_LINES );
1589 qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f + 6 );
1590 qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f + 2 );
1591 qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f - 6 );
1592 qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f - 2 );
1593 qglVertex2f( (float)m_Camera.width / 2.f + 6, (float)m_Camera.height / 2.f );
1594 qglVertex2f( (float)m_Camera.width / 2.f + 2, (float)m_Camera.height / 2.f );
1595 qglVertex2f( (float)m_Camera.width / 2.f - 6, (float)m_Camera.height / 2.f );
1596 qglVertex2f( (float)m_Camera.width / 2.f - 2, (float)m_Camera.height / 2.f );
1600 // reset perspective projection
1601 //qglMatrixMode(GL_PROJECTION);
1603 //qglMatrixMode(GL_MODELVIEW);
1607 if ((g_qeglobals.d_select_mode == sel_area) && (g_nPatchClickedView == W_CAMERA))
1609 // setup orthographic projection mode
1610 qglMatrixMode(GL_PROJECTION);
1613 qglDisable(GL_DEPTH_TEST);
1614 qglOrtho(0, (float)m_Camera.width, 0, (float)m_Camera.height, -100, 100);
1615 //qglScalef(1, -1, 1);
1616 //qglTranslatef(0, -(float)m_Camera.height, 0);
1617 qglMatrixMode(GL_MODELVIEW);
1619 // area selection hack
1621 qglDisable(GL_CULL_FACE);
1622 qglEnable (GL_BLEND);
1623 qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1624 qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1625 qglColor4f(0.0, 0.0, 1.0, 0.25);
1626 qglRectf(g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[0], g_qeglobals.d_vAreaBR[1]);
1627 qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1628 qglDisable (GL_BLEND);
1629 qglEnable (GL_CULL_FACE);
1633 // bind back to the default texture so that we don't have problems
1634 // elsewhere using/modifying texture maps between contexts
1635 qglBindTexture( GL_TEXTURE_2D, 0 );
1638 QE_CheckOpenGLForErrors();
1640 if (m_Camera.timing)
1642 end = Sys_DoubleTime ();
1643 Sys_Printf ("Camera: %i ms\n", (int)(1000*(end-start)));
1646 for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next)
1647 brush->bCamCulled = false;
1649 for (brush = pList->next ; brush != pList ; brush=brush->next)
1650 brush->bCamCulled = false;
1653 void CamWnd::OnExpose ()
1655 if (!MakeCurrent ())
1657 Sys_Printf("ERROR: glXMakeCurrent failed..\n ");
1658 Sys_Printf("Please restart Radiant if the camera view is not working\n");
1662 QE_CheckOpenGLForErrors();
1663 g_pSplitList = NULL;
1666 if (g_Clip1.Set() && g_Clip2.Set())
1668 g_pSplitList = (g_bSwitch) ?
1669 &g_brBackSplits : &g_brFrontSplits;
1673 Patch_LODMatchAll(); // spog
1676 QE_CheckOpenGLForErrors ();
1678 m_XORRectangle.set(rectangle_t());
1683 void CamWnd::BenchMark()
1685 if (!MakeCurrent ())
1686 Error ("glXMakeCurrent failed in Benchmark");
1688 qglDrawBuffer (GL_FRONT);
1689 double dStart = Sys_DoubleTime ();
1690 for (int i=0 ; i < 100 ; i++)
1692 m_Camera.angles[YAW] = i*4;
1696 qglDrawBuffer (GL_BACK);
1697 double dEnd = Sys_DoubleTime ();
1698 Sys_Printf ("%5.2f seconds\n", dEnd - dStart);