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 nDrawMode = m_Camera.draw_mode;
895 int nModelMode = g_PrefsDlg.m_nEntityShowState;
897 GLfloat material[4], identity[4];
898 VectorSet(identity, 0.8f, 0.8f, 0.8f);
902 if (b->owner->eclass->fixedsize && b->owner->eclass->nShowFlags & ECLASS_LIGHT && g_PrefsDlg.m_bNewLightDraw)
907 VectorCopy(b->owner->color, material);
908 VectorScale(material, 0.8f, material);
911 qglColor4fv(material);
913 if (g_PrefsDlg.m_bNewLightDraw)
914 DrawLight(b->owner, nGLState, (IsBrushSelected(b)) ? g_PrefsDlg.m_nLightRadiuses : 0, 0);
921 else if(b->owner->eclass->fixedsize && b->owner->model.pRender
922 && !(!IsBrushSelected(b) && (nModelMode & ENTITY_SELECTED_ONLY)))
927 if (!(nModelMode & ENTITY_WIREFRAME) && nModelMode != ENTITY_BOX)
929 VectorCopy(b->owner->eclass->color, material);
930 material[3] = identity[3] = 1.0f;
932 qglEnable(GL_CULL_FACE);
934 if(!(nGLState & DRAW_GL_TEXTURE_2D)) qglColor4fv(material);
935 else qglColor4fv(identity);
936 if(nGLState & DRAW_GL_LIGHTING) qglShadeModel(GL_SMOOTH);
938 b->owner->model.pRender->Draw(nGLState, DRAW_RF_CAM);
942 VectorCopy(b->owner->eclass->color, material);
944 qglColor4fv(material);
946 // model view mode "wireframe" or "selected wire"
947 if(nModelMode & ENTITY_WIREFRAME)
948 b->owner->model.pRender->Draw(nGLState, DRAW_RF_CAM);
950 // model view mode "skinned and boxed"
951 if(!(b->owner->eclass->nShowFlags & ECLASS_MISCMODEL) )
953 qglColor4fv(material);
954 aabb_draw(b->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);
956 else if(nModelMode & ENTITY_BOXED)
958 aabb_draw(b->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);
961 if(!(nModelMode & ENTITY_BOXED) && b->owner->eclass->nShowFlags & ECLASS_MISCMODEL)
968 else if (b->patchBrush)
970 bool bTrans = (b->pPatch->pShader->getTrans() < 1.0f);
974 if (!g_bPatchWireFrame && ((nGLState & DRAW_GL_BLEND && bTrans) || (!(nGLState & DRAW_GL_BLEND) && !bTrans)))
976 qglDisable(GL_CULL_FACE);
978 pShader = b->pPatch->pShader;
979 VectorCopy(pShader->getTexture()->color, material);
980 material[3] = identity[3] = pShader->getTrans();
982 if(nGLState & DRAW_GL_TEXTURE_2D) {
983 qglColor4fv(identity);
984 qglBindTexture(GL_TEXTURE_2D, pShader->getTexture()->texture_number);
987 qglColor4fv(material);
988 if(nGLState & DRAW_GL_LIGHTING) qglShadeModel(GL_SMOOTH);
990 DrawPatchMesh(b->pPatch);
994 if (g_bPatchWireFrame)
996 VectorCopy(b->pPatch->pShader->getTexture()->color, material);
998 qglColor4fv(material);
999 DrawPatchMesh(b->pPatch);
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);
1009 else if(b->owner->eclass->fixedsize)
1014 VectorCopy(b->owner->eclass->color, material);
1015 VectorScale(material, 0.8f, material);
1017 qglColor4fv(material);
1019 qglEnable(GL_CULL_FACE);
1020 qglShadeModel(GL_FLAT);
1024 if((g_qeglobals.d_savedinfo.include & INCLUDE_ANGLES)
1025 && (b->owner->eclass->nShowFlags & ECLASS_ANGLE))
1026 Brush_DrawFacingAngle(b, b->owner);
1036 qglEnable(GL_CULL_FACE);
1037 qglShadeModel(GL_FLAT);
1043 void CamWnd::Cam_DrawBrushes(int mode)
1046 brush_t *pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;
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);
1054 void CamWnd::Cam_DrawStuff()
1056 GLfloat identity[4];
1057 VectorSet(identity, 0.8f, 0.8f, 0.8f);
1060 for(b = active_brushes.next; b != &active_brushes; b=b->next)
1061 b->bCamCulled = CullBrush(b);
1063 for(b = selected_brushes.next; b != &selected_brushes; b=b->next)
1064 b->bCamCulled = CullBrush(b);
1066 switch (m_Camera.draw_mode)
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);
1082 m_Camera.draw_glstate = DRAW_GL_WIRE;
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);
1103 m_Camera.draw_glstate = DRAW_GL_SOLID;
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);
1127 qglPolygonOffset(-1.0, 2);
1128 m_Camera.draw_glstate = DRAW_GL_TEXTURED;
1131 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1134 Cam_DrawBrushes(DRAW_TEXTURED);
1136 // setup for solid stuff
1137 switch(m_Camera.draw_mode)
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);
1150 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1153 qglEnable(GL_CULL_FACE);
1154 qglShadeModel(GL_FLAT);
1155 Cam_DrawBrushes(DRAW_SOLID);
1157 // setup for wireframe stuff
1158 switch(m_Camera.draw_mode)
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);
1167 qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
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);
1176 qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1180 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1183 qglDisable(GL_CULL_FACE);
1184 Cam_DrawBrushes(DRAW_WIRE);
1186 // setup for transparent texture stuff
1187 switch(m_Camera.draw_mode)
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);
1197 qglEnable(GL_TEXTURE_2D);
1198 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
1199 m_Camera.draw_glstate = DRAW_GL_TEXTURED;
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);
1210 m_Camera.draw_glstate = DRAW_GL_SOLID;
1213 m_Camera.draw_glstate = DRAW_GL_WIRE;
1215 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
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);
1230 Cam_DrawBrushes(DRAW_TEXTURED);
1232 // qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1233 qglDisable(GL_BLEND);
1235 // setup for wireframe stuff
1236 switch(m_Camera.draw_mode)
1239 if(g_PrefsDlg.m_bGLLighting) {
1240 qglDisable(GL_COLOR_MATERIAL);
1241 qglDisable(GL_LIGHTING);
1242 // qglDisable(GL_RESCALE_NORMAL);
1246 if(g_PrefsDlg.m_bGLLighting) {
1247 qglDisable(GL_COLOR_MATERIAL);
1248 qglDisable(GL_LIGHTING);
1249 // qglDisable(GL_RESCALE_NORMAL);
1254 default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");
1268 void CamWnd::Cam_Draw()
1277 if (!active_brushes.next)
1278 return; // not valid yet
1280 if (m_Camera.timing)
1281 start = Sys_DoubleTime ();
1286 QE_CheckOpenGLForErrors();
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);
1299 qglMatrixMode(GL_PROJECTION);
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);
1306 // we're too lazy to calc projection matrix ourselves!!!
1307 qglGetFloatv (GL_PROJECTION_MATRIX, &m_Camera.projection[0][0]);
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);
1325 qglMatrixMode(GL_MODELVIEW);
1328 qglMultMatrixf(&m_Camera.modelview[0][0]);
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]);
1336 // TTimo: this is not used, just for verification (0, 0, m_Camera.width, m_Camera.height)
1338 qglGetIntegerv (GL_VIEWPORT, viewprt);
1341 if (g_PrefsDlg.m_bGLLighting)
1343 GLfloat inverse_cam_dir[4], ambient[4], diffuse[4];//, material[4];
1345 ambient[0] = ambient[1] = ambient[2] = 0.6f;
1347 diffuse[0] = diffuse[1] = diffuse[2] = 0.4f;
1349 //material[0] = material[1] = material[2] = 0.8f;
1350 //material[3] = 1.0f;
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);
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;
1364 qglColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
1366 qglLightfv(GL_LIGHT0, GL_POSITION, inverse_cam_dir);
1368 qglLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
1369 qglLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
1371 qglEnable(GL_LIGHT0);
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);
1389 qglEnable (GL_CULL_FACE);
1391 brush_t* pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;
1393 if (g_qeglobals.d_savedinfo.iSelectedOutlinesStyle & OUTLINE_BSEL)
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)
1401 if (brush->bCamCulled) // draw selected faces of filtered brushes to remind that there is a selection
1404 if (brush->patchBrush && (g_qeglobals.d_select_mode == sel_curvepoint || g_qeglobals.d_select_mode == sel_area))
1407 if (!g_PrefsDlg.m_bPatchBBoxSelect && brush->patchBrush)
1409 DrawPatchMesh(brush->pPatch);
1411 else if(brush->owner->model.pRender && g_PrefsDlg.m_nEntityShowState != ENTITY_BOX)
1413 brush->owner->model.pRender->Draw(DRAW_GL_FLAT, (DRAW_RF_SEL_OUTLINE|DRAW_RF_CAM));
1417 for (face=brush->brush_faces ; face ; face=face->next)
1418 Brush_FaceDraw(face, DRAW_GL_FLAT);
1423 int nCount = g_ptrSelectedFaces.GetSize();
1426 for (int i = 0; i < nCount; i++)
1428 face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));
1429 Brush_FaceDraw(selFace, DRAW_GL_FLAT);
1433 qglDisableClientState(GL_NORMAL_ARRAY);
1434 qglDepthFunc (GL_LESS);
1437 if (g_qeglobals.d_savedinfo.iSelectedOutlinesStyle & OUTLINE_ZBUF)
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)
1446 if ((brush->patchBrush && (g_qeglobals.d_select_mode == sel_curvepoint || g_qeglobals.d_select_mode == sel_area)))
1449 if (!g_PrefsDlg.m_bPatchBBoxSelect && brush->patchBrush)
1451 DrawPatchMesh(brush->pPatch);
1453 else if(brush->owner->model.pRender && g_PrefsDlg.m_nEntityShowState != ENTITY_BOX)
1455 brush->owner->model.pRender->Draw(DRAW_GL_WIRE, (DRAW_RF_SEL_FILL|DRAW_RF_CAM));
1457 // Hydra : always draw bbox outline!
1458 aabb_draw(brush->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);
1462 for (face=brush->brush_faces ; face ; face=face->next)
1463 Brush_FaceDraw(face, DRAW_GL_WIRE);
1468 // edge / vertex flags
1469 if (g_qeglobals.d_select_mode == sel_vertex)
1471 // GL_POINTS on Kyro Workaround
1472 if(!g_PrefsDlg.m_bGlPtWorkaround)
1477 qglBegin (GL_POINTS);
1478 for (i=0 ; i<g_qeglobals.d_numpoints ; i++)
1479 qglVertex3fv (g_qeglobals.d_points[i]);
1482 if(g_qeglobals.d_num_move_points)
1484 // selected brush verts
1487 qglBegin (GL_POINTS);
1488 for(i = 0; i < g_qeglobals.d_num_move_points; i++)
1489 qglVertex3fv (g_qeglobals.d_move_points[i]);
1500 qglBegin (GL_LINES);
1501 for (i=0; i < g_qeglobals.d_numpoints; i++)
1502 DrawAlternatePoint(g_qeglobals.d_points[i], 1.5);
1505 if(g_qeglobals.d_num_move_points)
1507 // selected brush verts
1510 qglBegin (GL_LINES);
1511 for(i = 0; i < g_qeglobals.d_num_move_points; i++)
1512 qglVertex3fv (g_qeglobals.d_move_points[i]);
1518 else if (g_qeglobals.d_select_mode == sel_edge)
1521 // GL_POINTS on Kyro Workaround
1522 if(!g_PrefsDlg.m_bGlPtWorkaround)
1526 qglBegin (GL_POINTS);
1527 for (i=0 ; i<g_qeglobals.d_numedges ; i++)
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);
1539 qglBegin (GL_LINES);
1540 for (i=0; i < g_qeglobals.d_numedges; i++)
1542 v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1];
1543 v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2];
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);
1558 qglEnable(GL_DEPTH_TEST);
1561 if (g_qeglobals.d_pointfile_display_list)
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();
1572 // draw the crosshair
1575 // setup orthographic projection mode
1576 qglMatrixMode(GL_PROJECTION);
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);
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 );
1601 // reset perspective projection
1602 //qglMatrixMode(GL_PROJECTION);
1604 //qglMatrixMode(GL_MODELVIEW);
1608 if ((g_qeglobals.d_select_mode == sel_area) && (g_nPatchClickedView == W_CAMERA))
1610 // setup orthographic projection mode
1611 qglMatrixMode(GL_PROJECTION);
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);
1620 // area selection hack
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);
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 );
1639 QE_CheckOpenGLForErrors();
1641 if (m_Camera.timing)
1643 end = Sys_DoubleTime ();
1644 Sys_Printf ("Camera: %i ms\n", (int)(1000*(end-start)));
1647 for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next)
1648 brush->bCamCulled = false;
1650 for (brush = pList->next ; brush != pList ; brush=brush->next)
1651 brush->bCamCulled = false;
1654 void CamWnd::OnExpose ()
1656 if (!MakeCurrent ())
1658 Sys_Printf("ERROR: glXMakeCurrent failed..\n ");
1659 Sys_Printf("Please restart Radiant if the camera view is not working\n");
1663 QE_CheckOpenGLForErrors();
1664 g_pSplitList = NULL;
1667 if (g_Clip1.Set() && g_Clip2.Set())
1669 g_pSplitList = (g_bSwitch) ?
1670 &g_brBackSplits : &g_brFrontSplits;
1674 Patch_LODMatchAll(); // spog
1677 QE_CheckOpenGLForErrors ();
1679 m_XORRectangle.set(rectangle_t());
1684 void CamWnd::BenchMark()
1686 if (!MakeCurrent ())
1687 Error ("glXMakeCurrent failed in Benchmark");
1689 qglDrawBuffer (GL_FRONT);
1690 double dStart = Sys_DoubleTime ();
1691 for (int i=0 ; i < 100 ; i++)
1693 m_Camera.angles[YAW] = i*4;
1697 qglDrawBuffer (GL_BACK);
1698 double dEnd = Sys_DoubleTime ();
1699 Sys_Printf ("%5.2f seconds\n", dEnd - dStart);