-/*\r
-Copyright (C) 1999-2007 id Software, Inc. and contributors.\r
-For a list of contributors, see the accompanying CONTRIBUTORS file.\r
-\r
-This file is part of GtkRadiant.\r
-\r
-GtkRadiant is free software; you can redistribute it and/or modify\r
-it under the terms of the GNU General Public License as published by\r
-the Free Software Foundation; either version 2 of the License, or\r
-(at your option) any later version.\r
-\r
-GtkRadiant is distributed in the hope that it will be useful,\r
-but WITHOUT ANY WARRANTY; without even the implied warranty of\r
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
-GNU General Public License for more details.\r
-\r
-You should have received a copy of the GNU General Public License\r
-along with GtkRadiant; if not, write to the Free Software\r
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\r
-*/\r
-\r
-//\r
-// Camera Window\r
-//\r
-// Leonardo Zide (leo@lokigames.com)\r
-//\r
-\r
-#include "stdafx.h"\r
-#include <gtk/gtk.h>\r
-#include <GL/gl.h>\r
-\r
-extern void DrawPathLines();\r
-extern void Select_ShiftTexture(int x, int y);\r
-extern void Select_RotateTexture(int amt);\r
-extern void DrawAlternatePoint(vec3_t v, float scale);\r
-//extern void Select_ScaleTexture(int x, int y);\r
-\r
-extern int g_nPatchClickedView;\r
-\r
-brush_t* g_pSplitList = NULL;\r
-\r
-// =============================================================================\r
-// CamWnd class\r
-\r
-CamWnd::CamWnd ()\r
- : GLWindow (TRUE), m_XORRectangle(m_pWidget)\r
-{\r
- m_nNumTransBrushes = 0;\r
- memset(&m_Camera, 0, sizeof(camera_t));\r
- m_pSide_select = NULL;\r
- m_bClipMode = false;\r
- m_bFreeMove = false;\r
- Cam_Init();\r
-}\r
-\r
-CamWnd::~CamWnd ()\r
-{\r
-}\r
-\r
-void CamWnd::OnCreate ()\r
-{\r
- if (!MakeCurrent ())\r
- Error ("glMakeCurrent failed");\r
-\r
- gtk_glwidget_create_font (m_pWidget);\r
-\r
- // report OpenGL information\r
- Sys_Printf ("GL_VENDOR: %s\n", qglGetString (GL_VENDOR));\r
- Sys_Printf ("GL_RENDERER: %s\n", qglGetString (GL_RENDERER));\r
- Sys_Printf ("GL_VERSION: %s\n", qglGetString (GL_VERSION));\r
- Sys_Printf ("GL_EXTENSIONS: %s\n", qglGetString (GL_EXTENSIONS));\r
-\r
- // Set off texture compression supported\r
- g_qeglobals.bTextureCompressionSupported = 0;\r
-\r
- // finalize OpenGL init\r
- // NOTE\r
- // why is this here? well .. the Gtk objects get constructed when you enter gtk_main\r
- // and I wanted to have the extensions information in the editor startup console (avoid looking that up in the early console)\r
- // RIANT\r
- // I Split this up so as to add support for extension and user-friendly\r
- // compression format selection.\r
- // ADD new globals for your new format so as to minimise\r
- // calls to Sys_QGL_ExtensionSupported \r
- // NOTE TTimo: I don't really like this approach with globals. Frequent calls to Sys_QGL_ExtensionSupported don't sound like\r
- // a problem to me. If there is some caching to be done, then I think it should be inside Sys_QGL_ExtensionSupported\r
- ///////////////////////////////////////////\r
- // Check for default OpenGL \r
- if (Sys_QGL_ExtensionSupported ("GL_ARB_texture_compression"))\r
- {\r
- g_qeglobals.bTextureCompressionSupported = 1;\r
- g_qeglobals.m_bOpenGLCompressionSupported = 1;\r
- }\r
-\r
- // INSERT PROPRIETARY EXTENSIONS HERE\r
- // Check for S3 extensions\r
- // create a bool global for extension supported\r
- if (Sys_QGL_ExtensionSupported ("GL_EXT_texture_compression_s3tc"))\r
- {\r
- g_qeglobals.bTextureCompressionSupported = 1;\r
- g_qeglobals.m_bS3CompressionSupported = 1;\r
- }\r
- \r
- g_qeglobals.m_bOpenGLReady = true;\r
- \r
- g_PrefsDlg.UpdateTextureCompression();\r
-\r
-#ifdef ATIHACK_812\r
- g_PrefsDlg.UpdateATIHack();\r
-#endif\r
-\r
- g_qeglobals_gui.d_camera = m_pWidget;\r
-}\r
-\r
-void CamWnd::Cam_Init ()\r
-{\r
- m_Camera.timing = false;\r
- m_Camera.origin[0] = 0.f;\r
- m_Camera.origin[1] = 20.f;\r
- m_Camera.origin[2] = 46.f;\r
- m_Camera.color[0] = 0.3f;\r
- m_Camera.color[1] = 0.3f;\r
- m_Camera.color[2] = 0.3f;\r
- m_nCambuttonstate = 0;\r
-}\r
-\r
-void CamWnd::OnSize(int cx, int cy) \r
-{\r
- m_Camera.width = cx;\r
- m_Camera.height = cy;\r
- gtk_widget_queue_draw(m_pWidget);\r
-}\r
-\r
-rectangle_t rectangle_from_area_cam()\r
-{\r
- const float left = MIN(g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaBR[0]);\r
- const float top = MAX(g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[1]);\r
- const float right = MAX(g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaBR[0]);\r
- const float bottom = MIN(g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[1]);\r
- return rectangle_t(left, bottom, right - left, top - bottom);\r
-}\r
-\r
-void update_xor_rectangle(XORRectangle& xor_rectangle)\r
-{\r
- rectangle_t rectangle;\r
- if ((g_qeglobals.d_select_mode == sel_area))\r
- rectangle = rectangle_from_area_cam();\r
- xor_rectangle.set(rectangle);\r
-}\r
-\r
-void CamWnd::OnMouseMove(guint32 flags, int pointx, int pointy) \r
-{\r
- int height = m_pWidget->allocation.height;\r
- // NOTE RR2DO2 this hasn't got any use anymore really. It is an old qeradiant feature\r
- // that can be re-enabled by removing the checks for HasCapture and not shift/ctrl down\r
- // but the scaling/rotating (unless done with the steps set in the surface inspector\r
- // dialog) is way too sensitive to be of any use\r
- if (HasCapture () && Sys_AltDown () &&\r
- !((flags & MK_SHIFT) || (flags & MK_CONTROL)))\r
- {\r
- if (flags & MK_CONTROL)\r
- Select_RotateTexture(pointy - m_ptLastCursorY);\r
- else\r
- if (flags & MK_SHIFT)\r
- Select_ScaleTexture(pointx - m_ptLastCursorX, m_ptLastCursorY - pointy);\r
- else\r
- Select_ShiftTexture(pointx - m_ptLastCursorX, m_ptLastCursorY - pointy);\r
- }\r
- else\r
- {\r
- Cam_MouseMoved(pointx, height - 1 - pointy, flags);\r
- }\r
- m_ptLastCursorX = pointx;\r
- m_ptLastCursorY = pointy;\r
-\r
- update_xor_rectangle(m_XORRectangle);\r
-}\r
-\r
-void CamWnd::OnMouseWheel(bool bUp)\r
-{\r
- if (bUp)\r
- VectorMA (m_Camera.origin, g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);\r
- else\r
- VectorMA (m_Camera.origin, -g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);\r
-\r
- int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);\r
- Sys_UpdateWindows (nUpdate);\r
- g_pParentWnd->OnTimer ();\r
-}\r
-\r
-void CamWnd::OnLButtonDown(guint32 nFlags, int pointx, int pointy) \r
-{\r
- m_ptLastCursorX = pointx;\r
- m_ptLastCursorY = pointy;\r
- OriginalMouseDown(nFlags, pointx, pointy);\r
-}\r
-\r
-void CamWnd::OnLButtonUp(guint32 nFlags, int pointx, int pointy) \r
-{\r
- OriginalMouseUp(nFlags, pointx, pointy);\r
-}\r
-\r
-void CamWnd::OnMButtonDown(guint32 nFlags, int pointx, int pointy) \r
-{\r
- OriginalMouseDown(nFlags, pointx, pointy);\r
-}\r
-\r
-void CamWnd::OnMButtonUp(guint32 nFlags, int pointx, int pointy) \r
-{\r
- OriginalMouseUp(nFlags, pointx, pointy);\r
-}\r
-\r
-void CamWnd::OnRButtonDown(guint32 nFlags, int pointx, int pointy) \r
-{\r
- OriginalMouseDown(nFlags, pointx, pointy);\r
-}\r
-\r
-void CamWnd::OnRButtonUp(guint32 nFlags, int pointx, int pointy) \r
-{\r
- OriginalMouseUp(nFlags, pointx, pointy);\r
-}\r
-\r
-void CamWnd::OriginalMouseUp(guint32 nFlags, int pointx, int pointy)\r
-{\r
- int height = m_pWidget->allocation.height;\r
-\r
- if(g_qeglobals.d_select_mode == sel_facets_on || g_qeglobals.d_select_mode == sel_facets_off)\r
- {\r
- g_qeglobals.d_select_mode = sel_brush;\r
- }\r
-\r
- Cam_MouseUp(pointx, height - 1 - pointy, nFlags);\r
- ReleaseCapture ();\r
-\r
- update_xor_rectangle(m_XORRectangle);\r
-}\r
-\r
-void CamWnd::OriginalMouseDown(guint32 nFlags, int pointx, int pointy)\r
-{\r
- int height = m_pWidget->allocation.height;\r
-\r
- SetFocus();\r
- SetCapture();\r
- Cam_MouseDown (pointx, height - 1 - pointy, nFlags);\r
-\r
- update_xor_rectangle(m_XORRectangle);\r
-}\r
-\r
-void CamWnd::Cam_BuildMatrix()\r
-{\r
- float ya;\r
- float matrix[4][4];\r
- int i;\r
-\r
- if (!m_bFreeMove)\r
- {\r
- ya = m_Camera.angles[1]/180*Q_PI;\r
-\r
- // the movement matrix is kept 2d\r
- m_Camera.forward[0] = cos(ya);\r
- m_Camera.forward[1] = sin(ya);\r
- m_Camera.forward[2] = 0;\r
- m_Camera.right[0] = m_Camera.forward[1];\r
- m_Camera.right[1] = -m_Camera.forward[0];\r
- }\r
- else\r
- {\r
- AngleVectors( m_Camera.angles, m_Camera.forward, m_Camera.right, NULL );\r
- m_Camera.forward[2] = -m_Camera.forward[2];\r
- }\r
-\r
- memcpy(matrix, m_Camera.projection, sizeof(m4x4_t));\r
- m4x4_multiply_by_m4x4(&matrix[0][0], &m_Camera.modelview[0][0]);\r
-\r
- //qglGetFloatv (GL_PROJECTION_MATRIX, &matrix[0][0]);\r
-\r
- for (i=0 ; i<3 ; i++)\r
- {\r
- m_Camera.vright[i] = matrix[i][0];\r
- m_Camera.vup[i] = matrix[i][1];\r
- m_Camera.vpn[i] = matrix[i][2];\r
- }\r
-\r
- VectorNormalize (m_Camera.vright, m_Camera.vright);\r
- VectorNormalize (m_Camera.vup, m_Camera.vup);\r
- VectorNormalize (m_Camera.vpn, m_Camera.vpn);\r
-}\r
-\r
-void CamWnd::Cam_ChangeFloor (qboolean up)\r
-{\r
- brush_t *b;\r
- float d, bestd, current;\r
- vec3_t start, dir;\r
-\r
- start[0] = m_Camera.origin[0];\r
- start[1] = m_Camera.origin[1];\r
- start[2] = g_MaxWorldCoord;\r
- dir[0] = dir[1] = 0;\r
- dir[2] = -1;\r
-\r
- current = g_MaxWorldCoord - (m_Camera.origin[2] - 48);\r
- if (up)\r
- bestd = 0;\r
- else\r
- bestd = 2*g_MaxWorldCoord;\r
-\r
- for (b=active_brushes.next ; b != &active_brushes ; b=b->next)\r
- {\r
- if (!Brush_Ray (start, dir, b, &d))\r
- continue;\r
- if (up && d < current && d > bestd)\r
- bestd = d;\r
- if (!up && d > current && d < bestd)\r
- bestd = d;\r
- }\r
-\r
- if (bestd == 0 || bestd == 2*g_MaxWorldCoord)\r
- return;\r
-\r
- m_Camera.origin[2] += current - bestd;\r
- Sys_UpdateWindows (W_CAMERA|W_Z_OVERLAY);\r
-}\r
-\r
-void CamWnd::Cam_PositionDrag()\r
-{\r
- int x, y;\r
-\r
- Sys_GetCursorPos (&x, &y);\r
- if (x != m_ptCursorX || y != m_ptCursorY)\r
- {\r
- x -= m_ptCursorX;\r
- VectorMA (m_Camera.origin, x, m_Camera.vright, m_Camera.origin);\r
- y -= m_ptCursorY;\r
- m_Camera.origin[2] -= y;\r
- Sys_SetCursorPos(m_ptCursorX, m_ptCursorY);\r
- Sys_UpdateWindows (W_CAMERA | W_XY_OVERLAY);\r
- }\r
-}\r
-\r
-void CamWnd::Cam_MouseControl (float dtime)\r
-{\r
- Cam_KeyControl (dtime);\r
-\r
- if( g_PrefsDlg.m_bCamFreeLook )\r
- {\r
- int dx, dy;\r
- gint x, y;\r
-\r
- if( !m_bFreeMove || m_nCambuttonstate == MK_CONTROL )\r
- return;\r
-\r
- // Update angles\r
- Sys_GetCursorPos(&m_ptCursorX, &m_ptCursorY);\r
-\r
- dx = m_ptLastCamCursorX - m_ptCursorX;\r
- dy = m_ptLastCamCursorY - m_ptCursorY;\r
-\r
- gdk_window_get_origin( m_pWidget->window, &x, &y);\r
-\r
- m_ptLastCamCursorX = x + (m_Camera.width / 2);\r
- m_ptLastCamCursorY = y + (m_Camera.height / 2);\r
-\r
- Sys_SetCursorPos(m_ptLastCamCursorX, m_ptLastCamCursorY);\r
-\r
- // Don't use pitch \r
- if(!g_PrefsDlg.m_bCamFreeLookStrafe) {\r
- if (g_PrefsDlg.m_bCamInverseMouse)\r
- m_Camera.angles[PITCH] -= dy * dtime * g_PrefsDlg.m_nAngleSpeed;\r
- else\r
- m_Camera.angles[PITCH] += dy * dtime * g_PrefsDlg.m_nAngleSpeed;\r
- } else {\r
- VectorMA (m_Camera.origin, dy * (float) (g_PrefsDlg.m_nMoveSpeed / 6.0f), m_Camera.forward, m_Camera.origin);\r
- }\r
-\r
- m_Camera.angles[YAW] += dx * dtime * g_PrefsDlg.m_nAngleSpeed;\r
-\r
- if (m_Camera.angles[PITCH] > 90)\r
- m_Camera.angles[PITCH] = 90;\r
- else if (m_Camera.angles[PITCH] < -90)\r
- m_Camera.angles[PITCH] = -90;\r
-\r
- if (m_Camera.angles[YAW] >= 360)\r
- m_Camera.angles[YAW] = 0;\r
- else if (m_Camera.angles[YAW] <= -360)\r
- m_Camera.angles[YAW] = 0;\r
-\r
- if( dx || dy || m_Camera.movementflags )\r
- {\r
- int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);\r
- Sys_UpdateWindows (nUpdate);\r
- g_pParentWnd->OnTimer ();\r
- }\r
- }\r
- else\r
- {\r
- int xl, xh;\r
- int yl, yh;\r
- float xf, yf;\r
-\r
- if (g_PrefsDlg.m_nMouseButtons == 2)\r
- {\r
- if (m_nCambuttonstate != (MK_RBUTTON | MK_SHIFT))\r
- return;\r
- }\r
- else\r
- {\r
- if (m_nCambuttonstate != MK_RBUTTON)\r
- return;\r
- }\r
-\r
- xf = (float)(m_ptButtonX - m_Camera.width/2) / (m_Camera.width/2);\r
- yf = (float)(m_ptButtonY - m_Camera.height/2) / (m_Camera.height/2);\r
-\r
- xl = m_Camera.width/3;\r
- xh = xl*2;\r
- yl = m_Camera.height/3;\r
- yh = yl*2;\r
- \r
- xf *= 1.0 - fabs(yf);\r
- if (xf < 0)\r
- {\r
- xf += 0.1f;\r
- if (xf > 0)\r
- xf = 0;\r
- }\r
- else\r
- {\r
- xf -= 0.1f;\r
- if (xf < 0)\r
- xf = 0;\r
- }\r
- \r
- VectorMA (m_Camera.origin, yf*dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);\r
- m_Camera.angles[YAW] += xf*-dtime*g_PrefsDlg.m_nAngleSpeed;\r
- \r
- int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);\r
- Sys_UpdateWindows (nUpdate);\r
- g_pParentWnd->OnTimer ();\r
- }\r
-}\r
-\r
-void CamWnd::Cam_KeyControl (float dtime) {\r
-\r
- // Update angles\r
- if (m_Camera.movementflags & MOVE_ROTLEFT)\r
- m_Camera.angles[YAW] += 15*dtime*g_PrefsDlg.m_nAngleSpeed;\r
- if (m_Camera.movementflags & MOVE_ROTRIGHT)\r
- m_Camera.angles[YAW] -= 15*dtime*g_PrefsDlg.m_nAngleSpeed;\r
-\r
- // Update position\r
- if (m_Camera.movementflags & MOVE_FORWARD)\r
- VectorMA (m_Camera.origin, dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);\r
- if (m_Camera.movementflags & MOVE_BACK)\r
- VectorMA (m_Camera.origin, -dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);\r
- if (m_Camera.movementflags & MOVE_STRAFELEFT)\r
- VectorMA (m_Camera.origin, -dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.right, m_Camera.origin);\r
- if (m_Camera.movementflags & MOVE_STRAFERIGHT)\r
- VectorMA (m_Camera.origin, dtime*g_PrefsDlg.m_nMoveSpeed, m_Camera.right, m_Camera.origin);\r
-\r
- // Save a screen update (when m_bFreeMove is enabled, mousecontrol does the update)\r
- if( !m_bFreeMove && m_Camera.movementflags )\r
- {\r
- int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);\r
- Sys_UpdateWindows (nUpdate);\r
- g_pParentWnd->OnTimer ();\r
- }\r
-}\r
-\r
-// NOTE TTimo if there's an OS-level focus out of the application\r
-// then we can release the camera cursor grab\r
-static gint camwindow_focusout(GtkWidget* widget, GdkEventKey* event, gpointer data)\r
-{\r
- g_pParentWnd->GetCamWnd ()->ToggleFreeMove();\r
- return FALSE;\r
-}\r
-\r
-void CamWnd::ToggleFreeMove()\r
-{\r
- GdkWindow *window;\r
- GtkWidget *widget;\r
-\r
- m_bFreeMove = !m_bFreeMove;\r
- Camera()->movementflags = 0;\r
- m_ptLastCamCursorX = m_ptCursorX;\r
- m_ptLastCamCursorY = m_ptCursorY;\r
-\r
- if (g_pParentWnd->CurrentStyle() == MainFrame::eFloating)\r
- {\r
- widget = g_pParentWnd->GetCamWnd ()->m_pParent;\r
- window = widget->window;\r
- }\r
- else\r
- {\r
- widget = g_pParentWnd->m_pWidget;\r
- window = widget->window;\r
- }\r
- \r
- if (m_bFreeMove)\r
- {\r
-\r
- SetFocus();\r
- SetCapture();\r
-\r
- {\r
- GdkPixmap *pixmap;\r
- GdkBitmap *mask;\r
- char buffer [(32 * 32)/8];\r
- memset (buffer, 0, (32 * 32)/8);\r
- GdkColor white = {0, 0xffff, 0xffff, 0xffff};\r
- GdkColor black = {0, 0x0000, 0x0000, 0x0000};\r
- pixmap = gdk_bitmap_create_from_data (NULL, buffer, 32, 32);\r
- mask = gdk_bitmap_create_from_data (NULL, buffer, 32, 32);\r
- GdkCursor *cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &white, &black, 1, 1);\r
- \r
- gdk_window_set_cursor (window, cursor);\r
- gdk_cursor_unref (cursor);\r
- gdk_drawable_unref (pixmap);\r
- gdk_drawable_unref (mask);\r
- }\r
-\r
- // RR2DO2: FIXME why does this only work the 2nd and\r
- // further times the event is called? (floating windows\r
- // mode seems to work fine though...)\r
- m_FocusOutHandler_id = gtk_signal_connect (GTK_OBJECT (widget), "focus_out_event",\r
- GTK_SIGNAL_FUNC (camwindow_focusout), g_pParentWnd);\r
- \r
- {\r
- GdkEventMask mask = (GdkEventMask)(GDK_POINTER_MOTION_MASK\r
- | GDK_POINTER_MOTION_HINT_MASK\r
- | GDK_BUTTON_MOTION_MASK\r
- | GDK_BUTTON1_MOTION_MASK\r
- | GDK_BUTTON2_MOTION_MASK\r
- | GDK_BUTTON3_MOTION_MASK\r
- | GDK_BUTTON_PRESS_MASK\r
- | GDK_BUTTON_RELEASE_MASK);\r
- \r
- gdk_pointer_grab(widget->window, TRUE, mask, widget->window, NULL, GDK_CURRENT_TIME);\r
- }\r
- }\r
- else\r
- {\r
- gdk_pointer_ungrab(GDK_CURRENT_TIME);\r
-\r
- gtk_signal_disconnect (GTK_OBJECT (widget), m_FocusOutHandler_id);\r
-\r
- GdkCursor *cursor = gdk_cursor_new (GDK_LEFT_PTR);\r
- gdk_window_set_cursor (window, cursor);\r
- gdk_cursor_unref (cursor);\r
-\r
- ReleaseCapture();\r
- }\r
-\r
- int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);\r
- Sys_UpdateWindows (nUpdate);\r
- g_pParentWnd->OnTimer ();\r
-}\r
-\r
-void CamWnd::Cam_MouseDown(int x, int y, int buttons)\r
-{\r
- vec3_t dir;\r
- float f, r, u;\r
- int i;\r
-\r
-\r
- //\r
- // calc ray direction\r
- //\r
- u = (float)( y - ( m_Camera.height * .5f ) ) / ( m_Camera.width * .5f );\r
- r = (float)( x - ( m_Camera.width * .5f ) ) / ( m_Camera.width * .5f );\r
- f = 1;\r
-\r
- for (i=0 ; i<3 ; i++)\r
- dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;\r
- VectorNormalize (dir, dir);\r
-\r
- Sys_GetCursorPos(&m_ptCursorX, &m_ptCursorY);\r
-\r
- m_nCambuttonstate = buttons;\r
- m_ptButtonX = x;\r
- m_ptButtonY = y;\r
-\r
- // LBUTTON = manipulate selection\r
- // shift-LBUTTON = select\r
- // middle button = grab texture\r
- // ctrl-middle button = set entire brush to texture\r
- // ctrl-shift-middle button = set single face to texture\r
- int nMouseButton = g_PrefsDlg.m_nMouseButtons == 2 ? MK_RBUTTON : MK_MBUTTON;\r
- if ((buttons == MK_LBUTTON)\r
- || (buttons == (MK_LBUTTON | MK_SHIFT))\r
- || (buttons == (MK_LBUTTON | MK_CONTROL))\r
- || (buttons == (MK_LBUTTON | MK_CONTROL | MK_SHIFT))\r
- || (buttons == nMouseButton)\r
- || (buttons == (nMouseButton|MK_SHIFT))\r
- || (buttons == (nMouseButton|MK_CONTROL))\r
- || (buttons == (nMouseButton|MK_SHIFT|MK_CONTROL)))\r
- {\r
- if (g_PrefsDlg.m_nMouseButtons == 2 && (buttons == (MK_RBUTTON | MK_SHIFT)))\r
- {\r
- if (g_PrefsDlg.m_bCamFreeLook)\r
- ToggleFreeMove();\r
- else\r
- Cam_MouseControl (0.1f);\r
- }\r
- else\r
- {\r
- // something global needs to track which window is responsible for stuff\r
- Patch_SetView(W_CAMERA);\r
- Drag_Begin (x, y, buttons, m_Camera.vright, m_Camera.vup, m_Camera.origin, dir, true);\r
- }\r
- return;\r
- }\r
-\r
- if (buttons == MK_RBUTTON)\r
- {\r
- if (g_PrefsDlg.m_bCamFreeLook)\r
- ToggleFreeMove();\r
- else\r
- Cam_MouseControl (0.1f);\r
- return;\r
- }\r
-}\r
-\r
-void CamWnd::Cam_MouseUp (int x, int y, int buttons)\r
-{\r
- m_nCambuttonstate = 0;\r
- Drag_MouseUp (buttons);\r
-}\r
-\r
-void CamWnd::Cam_MouseMoved (int x, int y, int buttons)\r
-{\r
- m_nCambuttonstate = buttons;\r
- if (!buttons)\r
- return;\r
-\r
- if( g_PrefsDlg.m_nCamDragMultiSelect )\r
- {\r
- if (g_qeglobals.d_select_mode == sel_brush_on || g_qeglobals.d_select_mode == sel_brush_off)\r
- {\r
- bool bDoDragMultiSelect = FALSE;\r
-\r
- if( g_PrefsDlg.m_nCamDragMultiSelect == 1 && buttons == (MK_LBUTTON|MK_SHIFT) )\r
- bDoDragMultiSelect = TRUE;\r
- else if( g_PrefsDlg.m_nCamDragMultiSelect == 2 && buttons == (MK_LBUTTON|MK_CONTROL) && Sys_AltDown() )\r
- bDoDragMultiSelect = TRUE;\r
-\r
- if( bDoDragMultiSelect )\r
- {\r
- vec3_t dir;\r
- float f, r, u;\r
- int i;\r
-\r
- //\r
- // calc ray direction\r
- //\r
- u = (float)( y - ( m_Camera.height * .5f ) ) / ( m_Camera.width * .5f );\r
- r = (float)( x - ( m_Camera.width * .5f ) ) / ( m_Camera.width * .5f );\r
- f = 1;\r
-\r
- for (i=0 ; i<3 ; i++)\r
- dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;\r
- VectorNormalize (dir,dir);\r
-\r
- switch( g_qeglobals.d_select_mode )\r
- {\r
- case sel_brush_on:\r
- Select_Ray( m_Camera.origin, dir, (SF_DRAG_ON|SF_CAMERA) );\r
- break;\r
- \r
- case sel_brush_off:\r
- Select_Ray( m_Camera.origin, dir, (SF_DRAG_OFF|SF_CAMERA) );\r
- break;\r
-\r
- default:\r
- break;\r
- }\r
- return;\r
- }\r
- }\r
- else if (g_qeglobals.d_select_mode == sel_facets_on || g_qeglobals.d_select_mode == sel_facets_off)\r
- {\r
- if( buttons == (MK_LBUTTON|MK_CONTROL|MK_SHIFT) )\r
- {\r
- vec3_t dir;\r
- float f, r, u;\r
- int i;\r
-\r
- //\r
- // calc ray direction\r
- //\r
- u = (float)( y - ( m_Camera.height * .5f ) ) / ( m_Camera.width * .5f );\r
- r = (float)( x - ( m_Camera.width * .5f ) ) / ( m_Camera.width * .5f );\r
- f = 1;\r
-\r
- for (i=0 ; i<3 ; i++)\r
- dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;\r
- VectorNormalize (dir,dir);\r
-\r
- switch( g_qeglobals.d_select_mode )\r
- {\r
- case sel_facets_on:\r
- Select_Ray( m_Camera.origin, dir, (SF_SINGLEFACE|SF_DRAG_ON|SF_CAMERA) );\r
- break;\r
-\r
- case sel_facets_off:\r
- Select_Ray( m_Camera.origin, dir, (SF_SINGLEFACE|SF_DRAG_OFF|SF_CAMERA) );\r
- break;\r
-\r
- default:\r
- break;\r
- }\r
- return;\r
- }\r
- }\r
- }\r
-\r
- m_ptButtonX = x;\r
- m_ptButtonY = y;\r
-\r
- if ( (m_bFreeMove && (buttons & MK_CONTROL) && !(buttons & MK_SHIFT)) || (!m_bFreeMove && (buttons == (MK_RBUTTON|MK_CONTROL))) )\r
- {\r
- Cam_PositionDrag ();\r
- Sys_UpdateWindows (W_XY|W_CAMERA|W_Z);\r
- return;\r
- }\r
-\r
- Sys_GetCursorPos(&m_ptCursorX, &m_ptCursorY);\r
-\r
- if (buttons & (MK_LBUTTON | MK_MBUTTON) )\r
- {\r
- Drag_MouseMoved (x, y, buttons);\r
- if(g_qeglobals.d_select_mode != sel_area)\r
- Sys_UpdateWindows (W_XY|W_CAMERA|W_Z);\r
- }\r
-}\r
-\r
-void CamWnd::InitCull()\r
-{\r
- int i;\r
-\r
- VectorSubtract (m_Camera.vpn, m_Camera.vright, m_vCull1);\r
- VectorAdd (m_Camera.vpn, m_Camera.vright, m_vCull2);\r
-\r
- for (i=0 ; i<3 ; i++)\r
- {\r
- if (m_vCull1[i] > 0)\r
- m_nCullv1[i] = 3+i;\r
- else\r
- m_nCullv1[i] = i;\r
- if (m_vCull2[i] > 0)\r
- m_nCullv2[i] = 3+i;\r
- else\r
- m_nCullv2[i] = i;\r
- }\r
-}\r
-\r
-qboolean CamWnd::CullBrush (brush_t *b)\r
-{\r
- int i;\r
- vec3_t point;\r
- float d;\r
-\r
- if (g_PrefsDlg.m_bCubicClipping)\r
- {\r
- float fLevel = g_PrefsDlg.m_nCubicScale * 64;\r
-\r
- point[0] = m_Camera.origin[0] - fLevel;\r
- point[1] = m_Camera.origin[1] - fLevel;\r
- point[2] = m_Camera.origin[2] - fLevel;\r
-\r
- for (i=0; i<3; i++)\r
- if (b->mins[i] < point[i] && b->maxs[i] < point[i])\r
- return true;\r
-\r
- point[0] = m_Camera.origin[0] + fLevel;\r
- point[1] = m_Camera.origin[1] + fLevel;\r
- point[2] = m_Camera.origin[2] + fLevel;\r
-\r
- for (i=0; i<3; i++)\r
- if (b->mins[i] > point[i] && b->maxs[i] > point[i])\r
- return true;\r
- }\r
-\r
- for (i=0 ; i<3 ; i++)\r
- point[i] = b->mins[m_nCullv1[i]] - m_Camera.origin[i];\r
-\r
- d = DotProduct (point, m_vCull1);\r
- if (d < -1)\r
- return true;\r
-\r
- for (i=0 ; i<3 ; i++)\r
- point[i] = b->mins[m_nCullv2[i]] - m_Camera.origin[i];\r
-\r
- d = DotProduct (point, m_vCull2);\r
- if (d < -1)\r
- return true;\r
-\r
- return false;\r
-}\r
-\r
-// project a 3D point onto the camera space\r
-// we use the GL viewing matrixes\r
-// this is the implementation of a glu function (I realized that afterwards): gluProject\r
-void CamWnd::ProjectCamera(const vec3_t A, vec_t B[2])\r
-{\r
-\r
- vec_t P1[4],P2[4],P3[4];\r
- VectorCopy(A,P1); P1[3] = 1;\r
-\r
- GLMatMul(m_Camera.modelview , P1, P2);\r
- GLMatMul(m_Camera.projection, P2, P3);\r
-\r
- // we ASSUME that the view port is 0 0 m_Camera.width m_Camera.height (you can check in Cam_Draw)\r
- B[0] = (float)m_Camera.width * ( P3[0] + 1.0 ) / 2.0;\r
- B[1] = (float)m_Camera.height * ( P3[1] + 1.0 ) / 2.0;\r
-\r
-}\r
-\r
-// vec defines a direction in geometric space and P an origin point\r
-// the user is interacting from the camera view\r
-// (for example with texture adjustment shortcuts)\r
-// and intuitively if he hits left / right / up / down \r
-// what happens in geometric space should match the left/right/up/down move in camera space\r
-// axis = 0: vec is along left/right\r
-// axis = 1: vec is along up/down\r
-// sgn = +1: same directions\r
-// sgn = -1: opposite directions\r
-// Implementation:\r
-// typical use case is giving a face center and a normalized vector\r
-// 1) compute start and endpoint, project them in camera view, get the direction\r
-// depending on the situation, we might bump into precision issues with that\r
-// 2) possible to compute the projected direction independently?\r
-// this solution would be better but right now I don't see how to do it..\r
-void CamWnd::MatchViewAxes(const vec3_t P, const vec3_t vec, int &axis, float &sgn)\r
-{\r
-\r
- vec_t A[2],B[2],V[2];\r
- ProjectCamera(P,A);\r
- vec3_t Q;\r
- VectorAdd(P,vec,Q);\r
- ProjectCamera(Q,B);\r
- // V is the vector projected in camera space\r
- V[0] = B[0] - A[0];\r
- V[1] = B[1] - A[1];\r
- if (fabs(V[0])>fabs(V[1]))\r
- {\r
- // best match is against right\r
- axis = 0;\r
- if (V[0]>0)\r
- sgn = +1;\r
- else\r
- sgn = -1;\r
- }\r
- else\r
- {\r
- // best match is against up\r
- axis = 1;\r
- if (V[1]>0)\r
- sgn = +1;\r
- else\r
- sgn = -1;\r
- }\r
-}\r
-\r
-#if 0\r
-void CamWnd::DrawLightRadius(brush_t* pBrush)\r
-{\r
- // if lighting\r
- int nRadius = Brush_LightRadius(pBrush);\r
- if (nRadius > 0)\r
- {\r
- Brush_SetLightColor(pBrush);\r
- qglEnable (GL_BLEND);\r
- qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);\r
- qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
- qglDisable (GL_TEXTURE_2D);\r
-\r
- qglEnable(GL_TEXTURE_2D);\r
- qglDisable(GL_BLEND);\r
- qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);\r
- }\r
-}\r
-#endif\r
-\r
-extern void DrawPatchMesh(patchMesh_t *pm);\r
-extern void DrawPatchControls(patchMesh_t *pm);\r
-extern void Brush_DrawFacingAngle (brush_t *b, entity_t *e);\r
-extern void Brush_DrawModel(brush_t *b, bool bTextured = false);\r
-extern void DrawModelOrigin(brush_t *b);\r
-extern void DrawModelBBox(brush_t *b);\r
-\r
-void CamWnd::Cam_DrawBrush(brush_t *b, int mode)\r
-{\r
- int nGLState = m_Camera.draw_glstate;\r
- int nDrawMode = m_Camera.draw_mode;\r
- int nModelMode = g_PrefsDlg.m_nEntityShowState;\r
-\r
- GLfloat material[4], identity[4];\r
- VectorSet(identity, 0.8f, 0.8f, 0.8f);\r
- IShader *pShader;\r
-\r
- // lights\r
- if (b->owner->eclass->fixedsize && b->owner->eclass->nShowFlags & ECLASS_LIGHT && g_PrefsDlg.m_bNewLightDraw)\r
- {\r
- switch (mode)\r
- {\r
- case DRAW_SOLID:\r
- VectorCopy(b->owner->color, material);\r
- VectorScale(material, 0.8f, material);\r
- material[3] = 1.0f;\r
-\r
- qglColor4fv(material);\r
- \r
- if (g_PrefsDlg.m_bNewLightDraw)\r
- DrawLight(b->owner, nGLState, (IsBrushSelected(b)) ? g_PrefsDlg.m_nLightRadiuses : 0, 0);\r
-\r
- break;\r
- }\r
- }\r
-\r
- // models\r
- else if(b->owner->eclass->fixedsize && b->owner->model.pRender\r
- && !(!IsBrushSelected(b) && (nModelMode & ENTITY_SELECTED_ONLY)))\r
- {\r
- switch (mode)\r
- {\r
- case DRAW_TEXTURED:\r
- if (!(nModelMode & ENTITY_WIREFRAME) && nModelMode != ENTITY_BOX)\r
- {\r
- VectorCopy(b->owner->eclass->color, material);\r
- material[3] = identity[3] = 1.0f;\r
-\r
- qglEnable(GL_CULL_FACE);\r
-\r
- if(!(nGLState & DRAW_GL_TEXTURE_2D)) qglColor4fv(material);\r
- else qglColor4fv(identity);\r
- if(nGLState & DRAW_GL_LIGHTING) qglShadeModel(GL_SMOOTH);\r
- \r
- b->owner->model.pRender->Draw(nGLState, DRAW_RF_CAM);\r
- }\r
- break;\r
- case DRAW_WIRE:\r
- VectorCopy(b->owner->eclass->color, material);\r
- material[3] = 1.0f;\r
- qglColor4fv(material);\r
-\r
- // model view mode "wireframe" or "selected wire"\r
- if(nModelMode & ENTITY_WIREFRAME)\r
- b->owner->model.pRender->Draw(nGLState, DRAW_RF_CAM);\r
-\r
- // model view mode "skinned and boxed"\r
- if(!(b->owner->eclass->nShowFlags & ECLASS_MISCMODEL) )\r
- {\r
- qglColor4fv(material);\r
- aabb_draw(b->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);\r
- }\r
- else if(nModelMode & ENTITY_BOXED)\r
- {\r
- aabb_draw(b->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);\r
- }\r
-/*\r
- if(!(nModelMode & ENTITY_BOXED) && b->owner->eclass->nShowFlags & ECLASS_MISCMODEL)\r
- DrawModelOrigin(b);\r
-*/\r
- }\r
- }\r
-\r
- // patches\r
- else if (b->patchBrush)\r
- {\r
- bool bTrans = (b->pPatch->pShader->getTrans() < 1.0f);\r
- switch(mode)\r
- {\r
- case DRAW_TEXTURED:\r
- if (!g_bPatchWireFrame && ((nGLState & DRAW_GL_BLEND && bTrans) || (!(nGLState & DRAW_GL_BLEND) && !bTrans)))\r
- {\r
- qglDisable(GL_CULL_FACE);\r
-\r
- pShader = b->pPatch->pShader;\r
- VectorCopy(pShader->getTexture()->color, material);\r
- material[3] = identity[3] = pShader->getTrans();\r
-\r
- if(nGLState & DRAW_GL_TEXTURE_2D) {\r
- qglColor4fv(identity);\r
- qglBindTexture(GL_TEXTURE_2D, pShader->getTexture()->texture_number);\r
- }\r
- else\r
- qglColor4fv(material);\r
- if(nGLState & DRAW_GL_LIGHTING) qglShadeModel(GL_SMOOTH);\r
-\r
- DrawPatchMesh(b->pPatch);\r
- }\r
- break;\r
- case DRAW_WIRE:\r
- if (g_bPatchWireFrame)\r
- {\r
- VectorCopy(b->pPatch->pShader->getTexture()->color, material);\r
- material[3] = 1.0;\r
- qglColor4fv(material);\r
- DrawPatchMesh(b->pPatch);\r
- }\r
- if ( b->pPatch->bSelected && (g_qeglobals.d_select_mode == sel_curvepoint\r
- || g_qeglobals.d_select_mode == sel_area\r
- || g_bPatchBendMode))\r
- DrawPatchControls(b->pPatch);\r
- }\r
- }\r
-\r
- // brushes\r
- else if(b->owner->eclass->fixedsize)\r
- {\r
- switch(mode)\r
- {\r
- case DRAW_SOLID:\r
- VectorCopy(b->owner->eclass->color, material);\r
- VectorScale(material, 0.8f, material);\r
- material[3] = 1.0f;\r
- qglColor4fv(material);\r
-\r
- qglEnable(GL_CULL_FACE);\r
- qglShadeModel(GL_FLAT);\r
- Brush_Draw(b);\r
- break;\r
- case DRAW_WIRE:\r
- if((g_qeglobals.d_savedinfo.include & INCLUDE_ANGLES)\r
- && (b->owner->eclass->nShowFlags & ECLASS_ANGLE))\r
- Brush_DrawFacingAngle(b, b->owner);\r
- }\r
- } \r
-\r
- // brushes\r
- else\r
- {\r
- switch(mode)\r
- {\r
- case DRAW_TEXTURED:\r
- qglEnable(GL_CULL_FACE);\r
- qglShadeModel(GL_FLAT);\r
- Brush_Draw(b);\r
- }\r
- } \r
-}\r
-\r
-void CamWnd::Cam_DrawBrushes(int mode)\r
-{\r
- brush_t *b;\r
- brush_t *pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;\r
- \r
- for(b = active_brushes.next; b != &active_brushes; b=b->next)\r
- if (!b->bFiltered && !b->bCamCulled) Cam_DrawBrush(b, mode);\r
- for(b = pList->next; b != pList; b=b->next)\r
- if (!b->bFiltered && !b->bCamCulled) Cam_DrawBrush(b, mode);\r
-}\r
-\r
-void CamWnd::Cam_DrawStuff()\r
-{\r
- GLfloat identity[4];\r
- VectorSet(identity, 0.8f, 0.8f, 0.8f);\r
- brush_t *b;\r
-\r
- for(b = active_brushes.next; b != &active_brushes; b=b->next)\r
- b->bCamCulled = CullBrush(b);\r
-\r
- for(b = selected_brushes.next; b != &selected_brushes; b=b->next)\r
- b->bCamCulled = CullBrush(b);\r
-\r
- switch (m_Camera.draw_mode)\r
- {\r
- case cd_wire:\r
- qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);\r
- qglDisable(GL_TEXTURE_2D);\r
- qglDisable(GL_TEXTURE_1D);\r
- qglDisable(GL_BLEND);\r
- qglEnable(GL_DEPTH_TEST);\r
- qglEnableClientState(GL_VERTEX_ARRAY);\r
- qglDisableClientState(GL_TEXTURE_COORD_ARRAY);\r
- qglShadeModel(GL_FLAT);\r
- if(g_PrefsDlg.m_bGLLighting) {\r
- qglDisable(GL_LIGHTING);\r
- qglDisable(GL_COLOR_MATERIAL);\r
- qglDisableClientState(GL_NORMAL_ARRAY);\r
- }\r
- m_Camera.draw_glstate = DRAW_GL_WIRE;\r
- break;\r
-\r
- case cd_solid:\r
- qglCullFace(GL_FRONT);\r
- qglEnable(GL_CULL_FACE);\r
- qglShadeModel (GL_FLAT);\r
- qglPolygonMode (GL_FRONT, GL_LINE);\r
- qglPolygonMode (GL_BACK, GL_FILL);\r
- qglDisable(GL_TEXTURE_2D);\r
- qglDisable(GL_BLEND);\r
- qglEnable(GL_DEPTH_TEST);\r
- qglEnableClientState(GL_VERTEX_ARRAY);\r
- qglDisableClientState(GL_TEXTURE_COORD_ARRAY);\r
- qglPolygonOffset(-1.0, 2);\r
- if(g_PrefsDlg.m_bGLLighting) {\r
- qglEnable(GL_LIGHTING);\r
- qglEnable(GL_COLOR_MATERIAL);\r
-// qglEnable(GL_RESCALE_NORMAL);\r
- qglEnableClientState(GL_NORMAL_ARRAY);\r
- }\r
- m_Camera.draw_glstate = DRAW_GL_SOLID;\r
- break;\r
-\r
- case cd_texture:\r
- qglCullFace(GL_FRONT);\r
- qglEnable(GL_CULL_FACE);\r
- qglShadeModel (GL_FLAT);\r
- qglPolygonMode (GL_FRONT, GL_LINE);\r
- qglPolygonMode (GL_BACK, GL_FILL);\r
- qglEnable(GL_TEXTURE_2D);\r
- qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
- qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);\r
- qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);\r
- qglDisable(GL_BLEND);\r
- qglEnable(GL_DEPTH_TEST);\r
- qglEnableClientState(GL_VERTEX_ARRAY);\r
- qglEnableClientState(GL_TEXTURE_COORD_ARRAY);\r
- if(g_PrefsDlg.m_bGLLighting) {\r
- qglEnable(GL_LIGHTING);\r
- qglDisable(GL_COLOR_MATERIAL);\r
- qglMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, identity);\r
- qglEnableClientState(GL_NORMAL_ARRAY);\r
-// qglEnable(GL_RESCALE_NORMAL);\r
- }\r
- qglPolygonOffset(-1.0, 2);\r
- m_Camera.draw_glstate = DRAW_GL_TEXTURED;\r
- break;\r
-\r
- default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");\r
- }\r
-\r
- Cam_DrawBrushes(DRAW_TEXTURED);\r
-\r
- // setup for solid stuff\r
- switch(m_Camera.draw_mode)\r
- {\r
- case cd_texture:\r
- qglDisable(GL_TEXTURE_2D);\r
- m_Camera.draw_glstate &= ~DRAW_GL_TEXTURE_2D;\r
- if(g_PrefsDlg.m_bGLLighting)\r
- qglEnable(GL_COLOR_MATERIAL);\r
- qglDisableClientState(GL_TEXTURE_COORD_ARRAY);\r
- break;\r
- case cd_solid:\r
- break;\r
- case cd_wire:\r
- break;\r
- default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");\r
- }\r
-\r
- qglEnable(GL_CULL_FACE);\r
- qglShadeModel(GL_FLAT);\r
- Cam_DrawBrushes(DRAW_SOLID);\r
-\r
- // setup for wireframe stuff\r
- switch(m_Camera.draw_mode)\r
- {\r
- case cd_texture:\r
- if(g_PrefsDlg.m_bGLLighting) {\r
- qglDisable(GL_LIGHTING);\r
- qglDisable(GL_COLOR_MATERIAL);\r
- qglDisableClientState(GL_NORMAL_ARRAY);\r
-// qglDisable(GL_RESCALE_NORMAL);\r
- }\r
- qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);\r
- break;\r
- case cd_solid:\r
- if(g_PrefsDlg.m_bGLLighting) {\r
- qglDisable(GL_LIGHTING);\r
- qglDisable(GL_COLOR_MATERIAL);\r
- qglDisableClientState(GL_NORMAL_ARRAY);\r
-// qglDisable(GL_RESCALE_NORMAL);\r
- }\r
- qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);\r
- break;\r
- case cd_wire:\r
- break;\r
- default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");\r
- }\r
- \r
- qglDisable(GL_CULL_FACE);\r
- Cam_DrawBrushes(DRAW_WIRE);\r
-\r
- // setup for transparent texture stuff\r
- switch(m_Camera.draw_mode)\r
- {\r
- case cd_texture:\r
- qglPolygonMode (GL_FRONT, GL_LINE);\r
- qglPolygonMode (GL_BACK, GL_FILL);\r
- if(g_PrefsDlg.m_bGLLighting) {\r
- qglEnable(GL_COLOR_MATERIAL);\r
- qglEnableClientState(GL_NORMAL_ARRAY);\r
- qglMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, identity);\r
- }\r
- qglEnable(GL_TEXTURE_2D);\r
- qglEnableClientState(GL_TEXTURE_COORD_ARRAY);\r
- m_Camera.draw_glstate = DRAW_GL_TEXTURED;\r
- break;\r
- case cd_solid:\r
- qglPolygonMode (GL_FRONT, GL_LINE);\r
- qglPolygonMode (GL_BACK, GL_FILL);\r
- if(g_PrefsDlg.m_bGLLighting) {\r
- qglEnable(GL_LIGHTING);\r
- qglEnable(GL_COLOR_MATERIAL);\r
- qglEnableClientState(GL_NORMAL_ARRAY);\r
-// qglEnable(GL_RESCALE_NORMAL);\r
- }\r
- m_Camera.draw_glstate = DRAW_GL_SOLID;\r
- break;\r
- case cd_wire:\r
- m_Camera.draw_glstate = DRAW_GL_WIRE;\r
- break;\r
- default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");\r
- } \r
-\r
-\r
- qglEnable(GL_BLEND);\r
- m_Camera.draw_glstate |= DRAW_GL_BLEND;\r
- qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
- // FIXME: some .TGA are buggy, have a completely empty alpha channel\r
- // if such brushes are rendered in this loop they would be totally transparent with GL_MODULATE\r
- // so I decided using GL_DECAL instead\r
- // if an empty-alpha-channel or nearly-empty texture is used. It will be blank-transparent.\r
- // this could get better if you can get qglTexEnviv (GL_TEXTURE_ENV, to work .. patches are welcome\r
- // Arnout: empty alpha channels are now always filled with data. Don't set this anymore (would cause problems with qer_alphafunc too)\r
-// qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);\r
-\r
- Cam_DrawBrushes(DRAW_TEXTURED);\r
-\r
-// qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
- qglDisable(GL_BLEND);\r
-\r
- // setup for wireframe stuff\r
- switch(m_Camera.draw_mode)\r
- {\r
- case cd_texture:\r
- if(g_PrefsDlg.m_bGLLighting) {\r
- qglDisable(GL_COLOR_MATERIAL);\r
- qglDisable(GL_LIGHTING);\r
-// qglDisable(GL_RESCALE_NORMAL);\r
- }\r
- break;\r
- case cd_solid:\r
- if(g_PrefsDlg.m_bGLLighting) {\r
- qglDisable(GL_COLOR_MATERIAL);\r
- qglDisable(GL_LIGHTING);\r
-// qglDisable(GL_RESCALE_NORMAL);\r
- }\r
- break;\r
- case cd_wire:\r
- break;\r
- default: Sys_Printf("CamWnd::Cam_DrawStuff:invalid render mode\n");\r
- }\r
-\r
-}\r
-\r
-/*\r
-==============\r
-Cam_Draw\r
-==============\r
-*/\r
-\r
-void QueueClear ();\r
-void QueueDraw ();\r
-\r
-void CamWnd::Cam_Draw()\r
-{\r
- brush_t *brush;\r
- face_t *face;\r
- float screenaspect;\r
- float yfov;\r
- double start, end;\r
- int i;\r
-\r
- if (!active_brushes.next)\r
- return; // not valid yet\r
-\r
- if (m_Camera.timing)\r
- start = Sys_DoubleTime ();\r
-\r
- //\r
- // clear\r
- //\r
- QE_CheckOpenGLForErrors();\r
-\r
- qglViewport(0, 0, m_Camera.width, m_Camera.height);\r
- qglClearColor (g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][0],\r
- g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][1],\r
- g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][2], 0);\r
- qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);\r
-\r
- //\r
- // set up viewpoint\r
- //\r
- \r
-\r
- qglMatrixMode(GL_PROJECTION);\r
- qglLoadIdentity ();\r
-\r
- screenaspect = (float)m_Camera.width / m_Camera.height;\r
- yfov = 2*atan((float)m_Camera.height / m_Camera.width)*180/Q_PI;\r
- qgluPerspective (yfov, screenaspect, 8, 32768);\r
-\r
- // we're too lazy to calc projection matrix ourselves!!!\r
- qglGetFloatv (GL_PROJECTION_MATRIX, &m_Camera.projection[0][0]);\r
-\r
- vec3_t vec;\r
-\r
- m4x4_identity(&m_Camera.modelview[0][0]);\r
- VectorSet(vec, -90, 0, 0);\r
- m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);\r
- VectorSet(vec, 0, 0, 90);\r
- m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);\r
- VectorSet(vec, 0, m_Camera.angles[0], 0);\r
- m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);\r
- VectorSet(vec, 0, 0, -m_Camera.angles[1]);\r
- m4x4_rotate_by_vec3(&m_Camera.modelview[0][0], vec, eXYZ);\r
- VectorSet(vec, -m_Camera.origin[0], -m_Camera.origin[1], -m_Camera.origin[2]);\r
- m4x4_translate_by_vec3(&m_Camera.modelview[0][0], vec);\r
-\r
- Cam_BuildMatrix ();\r
-\r
- qglMatrixMode(GL_MODELVIEW);\r
- qglLoadIdentity();\r
-\r
- qglMultMatrixf(&m_Camera.modelview[0][0]);\r
- \r
- // grab the GL_PROJECTION and GL_MODELVIEW matrixes\r
- // used in GetRelativeAxes\r
- //qglGetFloatv (GL_PROJECTION_MATRIX, &m_Camera.projection[0][0]);\r
- //qglGetFloatv (GL_MODELVIEW_MATRIX, &m_Camera.modelview[0][0]);\r
-\r
-#if 0\r
- // TTimo: this is not used, just for verification (0, 0, m_Camera.width, m_Camera.height)\r
- GLint viewprt[4];\r
- qglGetIntegerv (GL_VIEWPORT, viewprt);\r
-#endif\r
-\r
- if (g_PrefsDlg.m_bGLLighting)\r
- {\r
- GLfloat inverse_cam_dir[4], ambient[4], diffuse[4];//, material[4];\r
-\r
- ambient[0] = ambient[1] = ambient[2] = 0.6f;\r
- ambient[3] = 1.0f;\r
- diffuse[0] = diffuse[1] = diffuse[2] = 0.4f;\r
- diffuse[3] = 1.0f;\r
- //material[0] = material[1] = material[2] = 0.8f;\r
- //material[3] = 1.0f;\r
- \r
- vec3_t vCam, vRotate;\r
- VectorSet(vCam, -1, 0, 0); //default cam pos\r
- VectorSet(vRotate, 0, -m_Camera.angles[0], 0);\r
- VectorRotate(vCam, vRotate, vCam);\r
- VectorSet(vRotate, 0, 0, m_Camera.angles[1]);\r
- VectorRotate(vCam, vRotate, vCam);\r
- \r
- inverse_cam_dir[0] = vCam[0];\r
- inverse_cam_dir[1] = vCam[1];\r
- inverse_cam_dir[2] = vCam[2];\r
- inverse_cam_dir[3] = 0;\r
-\r
- qglColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);\r
-\r
- qglLightfv(GL_LIGHT0, GL_POSITION, inverse_cam_dir);\r
-\r
- qglLightfv(GL_LIGHT0, GL_AMBIENT, ambient);\r
- qglLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);\r
-\r
- qglEnable(GL_LIGHT0);\r
- }\r
-\r
- InitCull ();\r
-\r
- //\r
- // draw stuff\r
- //\r
-\r
- Cam_DrawStuff();\r
- \r
- qglEnableClientState(GL_VERTEX_ARRAY);\r
- qglDisableClientState(GL_NORMAL_ARRAY);\r
- qglDisableClientState(GL_TEXTURE_COORD_ARRAY);\r
- qglDisable (GL_TEXTURE_2D);\r
- qglDisable (GL_LIGHTING);\r
- qglDisable (GL_COLOR_MATERIAL);\r
-\r
- qglEnable (GL_CULL_FACE);\r
-\r
- brush_t* pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;\r
-\r
- if (g_qeglobals.d_savedinfo.iSelectedOutlinesStyle & OUTLINE_BSEL)\r
- {\r
- 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);\r
- qglEnable (GL_BLEND);\r
- qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
- qglDepthFunc (GL_LEQUAL);\r
- for (brush = pList->next ; brush != pList ; brush=brush->next)\r
- {\r
- if (brush->bCamCulled) // draw selected faces of filtered brushes to remind that there is a selection\r
- continue;\r
-\r
- if (brush->patchBrush && (g_qeglobals.d_select_mode == sel_curvepoint || g_qeglobals.d_select_mode == sel_area))\r
- continue;\r
-\r
- if (!g_PrefsDlg.m_bPatchBBoxSelect && brush->patchBrush)\r
- {\r
- DrawPatchMesh(brush->pPatch);\r
- }\r
- else if(brush->owner->model.pRender && g_PrefsDlg.m_nEntityShowState != ENTITY_BOX)\r
- {\r
- brush->owner->model.pRender->Draw(DRAW_GL_FLAT, (DRAW_RF_SEL_OUTLINE|DRAW_RF_CAM));\r
- }\r
- else\r
- {\r
- for (face=brush->brush_faces ; face ; face=face->next)\r
- Brush_FaceDraw(face, DRAW_GL_FLAT);\r
- }\r
- }\r
- \r
-\r
- int nCount = g_ptrSelectedFaces.GetSize();\r
- if (nCount > 0)\r
- {\r
- for (int i = 0; i < nCount; i++)\r
- {\r
- face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));\r
- Brush_FaceDraw(selFace, DRAW_GL_FLAT);\r
- }\r
- }\r
-\r
- qglDisableClientState(GL_NORMAL_ARRAY);\r
- qglDepthFunc (GL_LESS);\r
- }\r
- \r
- if (g_qeglobals.d_savedinfo.iSelectedOutlinesStyle & OUTLINE_ZBUF)\r
- {\r
- // non-zbuffered outline\r
- qglDisable (GL_BLEND);\r
- qglDisable (GL_DEPTH_TEST);\r
- qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);\r
- qglColor3f (1, 1, 1);\r
- for (brush = pList->next ; brush != pList ; brush=brush->next)\r
- {\r
- if ((brush->patchBrush && (g_qeglobals.d_select_mode == sel_curvepoint || g_qeglobals.d_select_mode == sel_area)))\r
- continue;\r
-\r
- if (!g_PrefsDlg.m_bPatchBBoxSelect && brush->patchBrush)\r
- {\r
- DrawPatchMesh(brush->pPatch);\r
- }\r
- else if(brush->owner->model.pRender && g_PrefsDlg.m_nEntityShowState != ENTITY_BOX)\r
- {\r
- brush->owner->model.pRender->Draw(DRAW_GL_WIRE, (DRAW_RF_SEL_FILL|DRAW_RF_CAM));\r
-\r
- // Hydra : always draw bbox outline!\r
- aabb_draw(brush->owner->model.pRender->GetAABB(), DRAW_GL_WIRE);\r
- }\r
- else\r
- {\r
- for (face=brush->brush_faces ; face ; face=face->next)\r
- Brush_FaceDraw(face, DRAW_GL_WIRE);\r
- }\r
- }\r
- }\r
-\r
- // edge / vertex flags\r
- if (g_qeglobals.d_select_mode == sel_vertex)\r
- {\r
- // GL_POINTS on Kyro Workaround\r
- if(!g_PrefsDlg.m_bGlPtWorkaround) \r
- {\r
- // brush verts\r
- qglPointSize (4);\r
- qglColor3f (0,1,0);\r
- qglBegin (GL_POINTS);\r
- for (i=0 ; i<g_qeglobals.d_numpoints ; i++)\r
- qglVertex3fv (g_qeglobals.d_points[i]);\r
- qglEnd ();\r
- \r
- if(g_qeglobals.d_num_move_points)\r
- {\r
- // selected brush verts\r
- qglPointSize (5);\r
- qglColor3f (0,0,1);\r
- qglBegin (GL_POINTS);\r
- for(i = 0; i < g_qeglobals.d_num_move_points; i++)\r
- qglVertex3fv (g_qeglobals.d_move_points[i]);\r
- qglEnd();\r
- }\r
- \r
- qglPointSize (1);\r
- }\r
- else\r
- {\r
- // brush verts\r
- qglColor3f (0,1,0);\r
- qglLineWidth(2.0);\r
- qglBegin (GL_LINES);\r
- for (i=0; i < g_qeglobals.d_numpoints; i++)\r
- DrawAlternatePoint(g_qeglobals.d_points[i], 1.5);\r
- qglEnd();\r
- \r
- if(g_qeglobals.d_num_move_points)\r
- {\r
- // selected brush verts\r
- qglColor3f (0,0,1);\r
- qglLineWidth (3.0);\r
- qglBegin (GL_LINES);\r
- for(i = 0; i < g_qeglobals.d_num_move_points; i++)\r
- qglVertex3fv (g_qeglobals.d_move_points[i]);\r
- qglEnd();\r
- }\r
- qglLineWidth(1.0);\r
- }\r
- }\r
- else if (g_qeglobals.d_select_mode == sel_edge)\r
- {\r
- float *v1, *v2;\r
- // GL_POINTS on Kyro Workaround\r
- if(!g_PrefsDlg.m_bGlPtWorkaround) \r
- {\r
- qglPointSize (4);\r
- qglColor3f (0,0,1);\r
- qglBegin (GL_POINTS);\r
- for (i=0 ; i<g_qeglobals.d_numedges ; i++)\r
- {\r
- v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1];\r
- v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2];\r
- qglVertex3f ( (v1[0]+v2[0])*0.5,(v1[1]+v2[1])*0.5,(v1[2]+v2[2])*0.5);\r
- }\r
- qglEnd ();\r
- qglPointSize (1);\r
- }\r
- else {\r
- qglColor3f (0,0,1);\r
- qglLineWidth(2.0);\r
- qglBegin (GL_LINES);\r
- for (i=0; i < g_qeglobals.d_numedges; i++)\r
- {\r
- v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1];\r
- v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2];\r
- vec3_t v3;\r
- v3[0] = (v1[0]+v2[0])*0.5;\r
- v3[1] = (v1[1]+v2[1])*0.5;\r
- v3[2] = (v1[2]+v2[2])*0.5;\r
- DrawAlternatePoint(v3, 1.5);\r
- }\r
- qglEnd();\r
- qglLineWidth(1.0);\r
- }\r
- }\r
-\r
- //\r
- // draw pointfile\r
- //\r
- qglEnable(GL_DEPTH_TEST);\r
- DrawPathLines();\r
-\r
- if (g_qeglobals.d_pointfile_display_list)\r
- {\r
- Pointfile_Draw();\r
- }\r
-\r
- // call the drawing routine of plugin entities\r
- //++timo FIXME: we might need to hook in other places as well for transparency etc.\r
- //++timo FIXME: also needs a way to get some parameters about the view\r
- //++timo FIXME: maybe provide some culling API on Radiant side?\r
- Draw3DPluginEntities();\r
-\r
- // draw the crosshair\r
- if (m_bFreeMove)\r
- {\r
- // setup orthographic projection mode\r
- qglMatrixMode(GL_PROJECTION);\r
- //qglPushMatrix();\r
- qglLoadIdentity();\r
- qglDisable(GL_DEPTH_TEST);\r
- qglOrtho(0, (float)m_Camera.width, 0, (float)m_Camera.height, -100, 100);\r
- qglScalef(1, -1, 1);\r
- qglTranslatef(0, -(float)m_Camera.height, 0);\r
- qglMatrixMode(GL_MODELVIEW);\r
-\r
- // draw crosshair\r
- //qglPushMatrix();\r
- qglLoadIdentity();\r
- qglColor3f( 1.f, 1.f, 1.f );\r
- qglBegin( GL_LINES );\r
- qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f + 6 );\r
- qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f + 2 );\r
- qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f - 6 );\r
- qglVertex2f( (float)m_Camera.width / 2.f, (float)m_Camera.height / 2.f - 2 );\r
- qglVertex2f( (float)m_Camera.width / 2.f + 6, (float)m_Camera.height / 2.f );\r
- qglVertex2f( (float)m_Camera.width / 2.f + 2, (float)m_Camera.height / 2.f );\r
- qglVertex2f( (float)m_Camera.width / 2.f - 6, (float)m_Camera.height / 2.f );\r
- qglVertex2f( (float)m_Camera.width / 2.f - 2, (float)m_Camera.height / 2.f );\r
- qglEnd();\r
- //qglPopMatrix();\r
-\r
- // reset perspective projection\r
- //qglMatrixMode(GL_PROJECTION);\r
- //qglPopMatrix();\r
- //qglMatrixMode(GL_MODELVIEW);\r
- }\r
-\r
-#if 0\r
- if ((g_qeglobals.d_select_mode == sel_area) && (g_nPatchClickedView == W_CAMERA))\r
- {\r
- // setup orthographic projection mode\r
- qglMatrixMode(GL_PROJECTION);\r
- //qglPushMatrix();\r
- qglLoadIdentity();\r
- qglDisable(GL_DEPTH_TEST);\r
- qglOrtho(0, (float)m_Camera.width, 0, (float)m_Camera.height, -100, 100);\r
- //qglScalef(1, -1, 1);\r
- //qglTranslatef(0, -(float)m_Camera.height, 0);\r
- qglMatrixMode(GL_MODELVIEW);\r
-\r
- // area selection hack\r
- qglLoadIdentity();\r
- qglDisable(GL_CULL_FACE);\r
- qglEnable (GL_BLEND);\r
- qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);\r
- qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
- qglColor4f(0.0, 0.0, 1.0, 0.25);\r
- qglRectf(g_qeglobals.d_vAreaTL[0], g_qeglobals.d_vAreaTL[1], g_qeglobals.d_vAreaBR[0], g_qeglobals.d_vAreaBR[1]);\r
- qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);\r
- qglDisable (GL_BLEND);\r
- qglEnable (GL_CULL_FACE);\r
- }\r
-#endif\r
-\r
- // bind back to the default texture so that we don't have problems\r
- // elsewhere using/modifying texture maps between contexts\r
- qglBindTexture( GL_TEXTURE_2D, 0 );\r
-\r
- qglFinish();\r
- QE_CheckOpenGLForErrors();\r
- // Sys_EndWait();\r
- if (m_Camera.timing)\r
- {\r
- end = Sys_DoubleTime ();\r
- Sys_Printf ("Camera: %i ms\n", (int)(1000*(end-start)));\r
- }\r
-\r
- for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next)\r
- brush->bCamCulled = false;\r
-\r
- for (brush = pList->next ; brush != pList ; brush=brush->next)\r
- brush->bCamCulled = false;\r
-}\r
-\r
-void CamWnd::OnExpose () \r
-{\r
- if (!MakeCurrent ())\r
- {\r
- Sys_Printf("ERROR: glXMakeCurrent failed..\n ");\r
- Sys_Printf("Please restart Radiant if the camera view is not working\n");\r
- }\r
- else\r
- {\r
- QE_CheckOpenGLForErrors();\r
- g_pSplitList = NULL;\r
- if (g_bClipMode)\r
- {\r
- if (g_Clip1.Set() && g_Clip2.Set())\r
- {\r
- g_pSplitList = (g_bSwitch) ? \r
- &g_brBackSplits : &g_brFrontSplits;\r
- }\r
- }\r
-\r
- Patch_LODMatchAll(); // spog \r
-\r
- Cam_Draw ();\r
- QE_CheckOpenGLForErrors ();\r
-\r
- m_XORRectangle.set(rectangle_t());\r
- SwapBuffers ();\r
- }\r
-}\r
-\r
-void CamWnd::BenchMark()\r
-{\r
- if (!MakeCurrent ())\r
- Error ("glXMakeCurrent failed in Benchmark");\r
- \r
- qglDrawBuffer (GL_FRONT);\r
- double dStart = Sys_DoubleTime ();\r
- for (int i=0 ; i < 100 ; i++)\r
- {\r
- m_Camera.angles[YAW] = i*4;\r
- Cam_Draw();\r
- }\r
- SwapBuffers ();\r
- qglDrawBuffer (GL_BACK);\r
- double dEnd = Sys_DoubleTime ();\r
- Sys_Printf ("%5.2f seconds\n", dEnd - dStart);\r
-}\r
+/*
+ Copyright (C) 1999-2006 Id Software, Inc. and contributors.
+ For a list of contributors, see the accompanying CONTRIBUTORS file.
+
+ This file is part of GtkRadiant.
+
+ GtkRadiant is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ GtkRadiant is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GtkRadiant; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+//
+// Camera Window
+//
+// Leonardo Zide (leo@lokigames.com)
+//
+
+#include "camwindow.h"
+
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+
+#include "debugging/debugging.h"
+
+#include "iscenegraph.h"
+#include "irender.h"
+#include "igl.h"
+#include "icamera.h"
+#include "cullable.h"
+#include "renderable.h"
+#include "preferencesystem.h"
+
+#include "signal/signal.h"
+#include "container/array.h"
+#include "scenelib.h"
+#include "render.h"
+#include "cmdlib.h"
+#include "math/frustum.h"
+
+#include "gtkutil/widget.h"
+#include "gtkutil/button.h"
+#include "gtkutil/toolbar.h"
+#include "gtkutil/glwidget.h"
+#include "gtkutil/xorrectangle.h"
+#include "gtkmisc.h"
+#include "selection.h"
+#include "mainframe.h"
+#include "preferences.h"
+#include "commands.h"
+#include "xywindow.h"
+#include "windowobservers.h"
+#include "renderstate.h"
+
+#include "timer.h"
+
+Signal0 g_cameraMoved_callbacks;
+
+void AddCameraMovedCallback(const SignalHandler &handler)
+{
+ g_cameraMoved_callbacks.connectLast(handler);
+}
+
+void CameraMovedNotify()
+{
+ g_cameraMoved_callbacks();
+}
+
+
+struct camwindow_globals_private_t {
+ int m_nMoveSpeed;
+ bool m_bCamLinkSpeed;
+ int m_nAngleSpeed;
+ bool m_bCamInverseMouse;
+ bool m_bCamDiscrete;
+ bool m_bCubicClipping;
+ bool m_showStats;
+ int m_nStrafeMode;
+
+ camwindow_globals_private_t() :
+ m_nMoveSpeed(100),
+ m_bCamLinkSpeed(true),
+ m_nAngleSpeed(3),
+ m_bCamInverseMouse(false),
+ m_bCamDiscrete(true),
+ m_bCubicClipping(true),
+ m_showStats(true),
+ m_nStrafeMode(0)
+ {
+ }
+
+};
+
+camwindow_globals_private_t g_camwindow_globals_private;
+
+
+const Matrix4 g_opengl2radiant(
+ 0, 0, -1, 0,
+ -1, 0, 0, 0,
+ 0, 1, 0, 0,
+ 0, 0, 0, 1
+);
+
+const Matrix4 g_radiant2opengl(
+ 0, -1, 0, 0,
+ 0, 0, 1, 0,
+ -1, 0, 0, 0,
+ 0, 0, 0, 1
+);
+
+struct camera_t;
+
+void Camera_mouseMove(camera_t &camera, int x, int y);
+
+enum camera_draw_mode {
+ cd_wire,
+ cd_solid,
+ cd_texture,
+ cd_lighting
+};
+
+struct camera_t {
+ int width, height;
+
+ bool timing;
+
+ Vector3 origin;
+ Vector3 angles;
+
+ Vector3 color; // background
+
+ Vector3 forward, right; // move matrix (TTimo: used to have up but it was not updated)
+ Vector3 vup, vpn, vright; // view matrix (taken from the modelview matrix)
+
+ Matrix4 projection;
+ Matrix4 modelview;
+
+ bool m_strafe; // true when in strafemode toggled by the ctrl-key
+ bool m_strafe_forward; // true when in strafemode by ctrl-key and shift is pressed for forward strafing
+
+ unsigned int movementflags; // movement flags
+ Timer m_keycontrol_timer;
+ guint m_keymove_handler;
+
+
+ float fieldOfView;
+
+ DeferredMotionDelta m_mouseMove;
+
+ static void motionDelta(int x, int y, void *data)
+ {
+ Camera_mouseMove(*reinterpret_cast<camera_t *>( data ), x, y);
+ }
+
+ View *m_view;
+ Callback<void()> m_update;
+
+ static camera_draw_mode draw_mode;
+
+ camera_t(View *view, const Callback<void()> &update)
+ : width(0),
+ height(0),
+ timing(false),
+ origin(0, 0, 0),
+ angles(0, 0, 0),
+ color(0, 0, 0),
+ movementflags(0),
+ m_keymove_handler(0),
+ fieldOfView(90.0f),
+ m_mouseMove(motionDelta, this),
+ m_view(view),
+ m_update(update)
+ {
+ }
+};
+
+camera_draw_mode camera_t::draw_mode = cd_texture;
+
+inline Matrix4 projection_for_camera(float near_z, float far_z, float fieldOfView, int width, int height)
+{
+ const float half_width = static_cast<float>( near_z * tan(degrees_to_radians(fieldOfView * 0.5)));
+ const float half_height = half_width * (static_cast<float>( height ) / static_cast<float>( width ));
+
+ return matrix4_frustum(
+ -half_width,
+ half_width,
+ -half_height,
+ half_height,
+ near_z,
+ far_z
+ );
+}
+
+float Camera_getFarClipPlane(camera_t &camera)
+{
+ return (g_camwindow_globals_private.m_bCubicClipping) ? pow(2.0, (g_camwindow_globals.m_nCubicScale + 7) / 2.0)
+ : 32768.0f;
+}
+
+void Camera_updateProjection(camera_t &camera)
+{
+ float farClip = Camera_getFarClipPlane(camera);
+ camera.projection = projection_for_camera(farClip / 4096.0f, farClip, camera.fieldOfView, camera.width,
+ camera.height);
+
+ camera.m_view->Construct(camera.projection, camera.modelview, camera.width, camera.height);
+}
+
+void Camera_updateVectors(camera_t &camera)
+{
+ for (int i = 0; i < 3; i++) {
+ camera.vright[i] = camera.modelview[(i << 2) + 0];
+ camera.vup[i] = camera.modelview[(i << 2) + 1];
+ camera.vpn[i] = camera.modelview[(i << 2) + 2];
+ }
+}
+
+void Camera_updateModelview(camera_t &camera)
+{
+ camera.modelview = g_matrix4_identity;
+
+ // roll, pitch, yaw
+ Vector3 radiant_eulerXYZ(0, -camera.angles[CAMERA_PITCH], camera.angles[CAMERA_YAW]);
+
+ matrix4_translate_by_vec3(camera.modelview, camera.origin);
+ matrix4_rotate_by_euler_xyz_degrees(camera.modelview, radiant_eulerXYZ);
+ matrix4_multiply_by_matrix4(camera.modelview, g_radiant2opengl);
+ matrix4_affine_invert(camera.modelview);
+
+ Camera_updateVectors(camera);
+
+ camera.m_view->Construct(camera.projection, camera.modelview, camera.width, camera.height);
+}
+
+
+void Camera_Move_updateAxes(camera_t &camera)
+{
+ double ya = degrees_to_radians(camera.angles[CAMERA_YAW]);
+
+ // the movement matrix is kept 2d
+ camera.forward[0] = static_cast<float>( cos(ya));
+ camera.forward[1] = static_cast<float>( sin(ya));
+ camera.forward[2] = 0;
+ camera.right[0] = camera.forward[1];
+ camera.right[1] = -camera.forward[0];
+}
+
+void Camera_Freemove_updateAxes(camera_t &camera)
+{
+ camera.right = camera.vright;
+ camera.forward = vector3_negated(camera.vpn);
+}
+
+const Vector3 &Camera_getOrigin(camera_t &camera)
+{
+ return camera.origin;
+}
+
+void Camera_setOrigin(camera_t &camera, const Vector3 &origin)
+{
+ camera.origin = origin;
+ Camera_updateModelview(camera);
+ camera.m_update();
+ CameraMovedNotify();
+}
+
+const Vector3 &Camera_getAngles(camera_t &camera)
+{
+ return camera.angles;
+}
+
+void Camera_setAngles(camera_t &camera, const Vector3 &angles)
+{
+ camera.angles = angles;
+ Camera_updateModelview(camera);
+ camera.m_update();
+ CameraMovedNotify();
+}
+
+
+void Camera_FreeMove(camera_t &camera, int dx, int dy)
+{
+ // free strafe mode, toggled by the ctrl key with optional shift for forward movement
+ if (camera.m_strafe) {
+ float strafespeed = 0.65f;
+
+ if (g_camwindow_globals_private.m_bCamLinkSpeed) {
+ strafespeed = (float) g_camwindow_globals_private.m_nMoveSpeed / 100;
+ }
+
+ camera.origin -= camera.vright * strafespeed * dx;
+ if (camera.m_strafe_forward) {
+ camera.origin += camera.vpn * strafespeed * dy;
+ } else {
+ camera.origin += camera.vup * strafespeed * dy;
+ }
+ } else // free rotation
+ {
+ const float dtime = 0.1f;
+
+ if (g_camwindow_globals_private.m_bCamInverseMouse) {
+ camera.angles[CAMERA_PITCH] -= dy * dtime * g_camwindow_globals_private.m_nAngleSpeed;
+ } else {
+ camera.angles[CAMERA_PITCH] += dy * dtime * g_camwindow_globals_private.m_nAngleSpeed;
+ }
+
+ camera.angles[CAMERA_YAW] += dx * dtime * g_camwindow_globals_private.m_nAngleSpeed;
+
+ if (camera.angles[CAMERA_PITCH] > 90) {
+ camera.angles[CAMERA_PITCH] = 90;
+ } else if (camera.angles[CAMERA_PITCH] < -90) {
+ camera.angles[CAMERA_PITCH] = -90;
+ }
+
+ if (camera.angles[CAMERA_YAW] >= 360) {
+ camera.angles[CAMERA_YAW] -= 360;
+ } else if (camera.angles[CAMERA_YAW] <= 0) {
+ camera.angles[CAMERA_YAW] += 360;
+ }
+ }
+
+ Camera_updateModelview(camera);
+ Camera_Freemove_updateAxes(camera);
+}
+
+void Cam_MouseControl(camera_t &camera, int x, int y)
+{
+ float xf = (float) (x - camera.width / 2) / (camera.width / 2);
+ float yf = (float) (y - camera.height / 2) / (camera.height / 2);
+
+ xf *= 1.0f - fabsf(yf);
+ if (xf < 0) {
+ xf += 0.1f;
+ if (xf > 0) {
+ xf = 0;
+ }
+ } else {
+ xf -= 0.1f;
+ if (xf < 0) {
+ xf = 0;
+ }
+ }
+
+ vector3_add(camera.origin, vector3_scaled(camera.forward, yf * 0.1f * g_camwindow_globals_private.m_nMoveSpeed));
+ camera.angles[CAMERA_YAW] += xf * -0.1f * g_camwindow_globals_private.m_nAngleSpeed;
+
+ Camera_updateModelview(camera);
+}
+
+void Camera_mouseMove(camera_t &camera, int x, int y)
+{
+ //globalOutputStream() << "mousemove... ";
+ Camera_FreeMove(camera, -x, -y);
+ camera.m_update();
+ CameraMovedNotify();
+}
+
+const unsigned int MOVE_NONE = 0;
+const unsigned int MOVE_FORWARD = 1 << 0;
+const unsigned int MOVE_BACK = 1 << 1;
+const unsigned int MOVE_ROTRIGHT = 1 << 2;
+const unsigned int MOVE_ROTLEFT = 1 << 3;
+const unsigned int MOVE_STRAFERIGHT = 1 << 4;
+const unsigned int MOVE_STRAFELEFT = 1 << 5;
+const unsigned int MOVE_UP = 1 << 6;
+const unsigned int MOVE_DOWN = 1 << 7;
+const unsigned int MOVE_PITCHUP = 1 << 8;
+const unsigned int MOVE_PITCHDOWN = 1 << 9;
+const unsigned int MOVE_ALL =
+ MOVE_FORWARD | MOVE_BACK | MOVE_ROTRIGHT | MOVE_ROTLEFT | MOVE_STRAFERIGHT | MOVE_STRAFELEFT | MOVE_UP |
+ MOVE_DOWN | MOVE_PITCHUP | MOVE_PITCHDOWN;
+
+void Cam_KeyControl(camera_t &camera, float dtime)
+{
+ // Update angles
+ if (camera.movementflags & MOVE_ROTLEFT) {
+ camera.angles[CAMERA_YAW] += 15 * dtime * g_camwindow_globals_private.m_nAngleSpeed;
+ }
+ if (camera.movementflags & MOVE_ROTRIGHT) {
+ camera.angles[CAMERA_YAW] -= 15 * dtime * g_camwindow_globals_private.m_nAngleSpeed;
+ }
+ if (camera.movementflags & MOVE_PITCHUP) {
+ camera.angles[CAMERA_PITCH] += 15 * dtime * g_camwindow_globals_private.m_nAngleSpeed;
+ if (camera.angles[CAMERA_PITCH] > 90) {
+ camera.angles[CAMERA_PITCH] = 90;
+ }
+ }
+ if (camera.movementflags & MOVE_PITCHDOWN) {
+ camera.angles[CAMERA_PITCH] -= 15 * dtime * g_camwindow_globals_private.m_nAngleSpeed;
+ if (camera.angles[CAMERA_PITCH] < -90) {
+ camera.angles[CAMERA_PITCH] = -90;
+ }
+ }
+
+ Camera_updateModelview(camera);
+ Camera_Freemove_updateAxes(camera);
+
+ // Update position
+ if (camera.movementflags & MOVE_FORWARD) {
+ vector3_add(camera.origin, vector3_scaled(camera.forward, dtime * g_camwindow_globals_private.m_nMoveSpeed));
+ }
+ if (camera.movementflags & MOVE_BACK) {
+ vector3_add(camera.origin, vector3_scaled(camera.forward, -dtime * g_camwindow_globals_private.m_nMoveSpeed));
+ }
+ if (camera.movementflags & MOVE_STRAFELEFT) {
+ vector3_add(camera.origin, vector3_scaled(camera.right, -dtime * g_camwindow_globals_private.m_nMoveSpeed));
+ }
+ if (camera.movementflags & MOVE_STRAFERIGHT) {
+ vector3_add(camera.origin, vector3_scaled(camera.right, dtime * g_camwindow_globals_private.m_nMoveSpeed));
+ }
+ if (camera.movementflags & MOVE_UP) {
+ vector3_add(camera.origin, vector3_scaled(g_vector3_axis_z, dtime * g_camwindow_globals_private.m_nMoveSpeed));
+ }
+ if (camera.movementflags & MOVE_DOWN) {
+ vector3_add(camera.origin, vector3_scaled(g_vector3_axis_z, -dtime * g_camwindow_globals_private.m_nMoveSpeed));
+ }
+
+ Camera_updateModelview(camera);
+}
+
+void Camera_keyMove(camera_t &camera)
+{
+ camera.m_mouseMove.flush();
+
+ //globalOutputStream() << "keymove... ";
+ float time_seconds = camera.m_keycontrol_timer.elapsed_msec() / static_cast<float>( msec_per_sec );
+ camera.m_keycontrol_timer.start();
+ if (time_seconds > 0.05f) {
+ time_seconds = 0.05f; // 20fps
+ }
+ Cam_KeyControl(camera, time_seconds * 5.0f);
+
+ camera.m_update();
+ CameraMovedNotify();
+}
+
+gboolean camera_keymove(gpointer data)
+{
+ Camera_keyMove(*reinterpret_cast<camera_t *>( data ));
+ return TRUE;
+}
+
+void Camera_setMovementFlags(camera_t &camera, unsigned int mask)
+{
+ if ((~camera.movementflags & mask) != 0 && camera.movementflags == 0) {
+ camera.m_keymove_handler = g_idle_add(camera_keymove, &camera);
+ }
+ camera.movementflags |= mask;
+}
+
+void Camera_clearMovementFlags(camera_t &camera, unsigned int mask)
+{
+ if ((camera.movementflags & ~mask) == 0 && camera.movementflags != 0) {
+ g_source_remove(camera.m_keymove_handler);
+ camera.m_keymove_handler = 0;
+ }
+ camera.movementflags &= ~mask;
+}
+
+void Camera_MoveForward_KeyDown(camera_t &camera)
+{
+ Camera_setMovementFlags(camera, MOVE_FORWARD);
+}
+
+void Camera_MoveForward_KeyUp(camera_t &camera)
+{
+ Camera_clearMovementFlags(camera, MOVE_FORWARD);
+}
+
+void Camera_MoveBack_KeyDown(camera_t &camera)
+{
+ Camera_setMovementFlags(camera, MOVE_BACK);
+}
+
+void Camera_MoveBack_KeyUp(camera_t &camera)
+{
+ Camera_clearMovementFlags(camera, MOVE_BACK);
+}
+
+void Camera_MoveLeft_KeyDown(camera_t &camera)
+{
+ Camera_setMovementFlags(camera, MOVE_STRAFELEFT);
+}
+
+void Camera_MoveLeft_KeyUp(camera_t &camera)
+{
+ Camera_clearMovementFlags(camera, MOVE_STRAFELEFT);
+}
+
+void Camera_MoveRight_KeyDown(camera_t &camera)
+{
+ Camera_setMovementFlags(camera, MOVE_STRAFERIGHT);
+}
+
+void Camera_MoveRight_KeyUp(camera_t &camera)
+{
+ Camera_clearMovementFlags(camera, MOVE_STRAFERIGHT);
+}
+
+void Camera_MoveUp_KeyDown(camera_t &camera)
+{
+ Camera_setMovementFlags(camera, MOVE_UP);
+}
+
+void Camera_MoveUp_KeyUp(camera_t &camera)
+{
+ Camera_clearMovementFlags(camera, MOVE_UP);
+}
+
+void Camera_MoveDown_KeyDown(camera_t &camera)
+{
+ Camera_setMovementFlags(camera, MOVE_DOWN);
+}
+
+void Camera_MoveDown_KeyUp(camera_t &camera)
+{
+ Camera_clearMovementFlags(camera, MOVE_DOWN);
+}
+
+void Camera_RotateLeft_KeyDown(camera_t &camera)
+{
+ Camera_setMovementFlags(camera, MOVE_ROTLEFT);
+}
+
+void Camera_RotateLeft_KeyUp(camera_t &camera)
+{
+ Camera_clearMovementFlags(camera, MOVE_ROTLEFT);
+}
+
+void Camera_RotateRight_KeyDown(camera_t &camera)
+{
+ Camera_setMovementFlags(camera, MOVE_ROTRIGHT);
+}
+
+void Camera_RotateRight_KeyUp(camera_t &camera)
+{
+ Camera_clearMovementFlags(camera, MOVE_ROTRIGHT);
+}
+
+void Camera_PitchUp_KeyDown(camera_t &camera)
+{
+ Camera_setMovementFlags(camera, MOVE_PITCHUP);
+}
+
+void Camera_PitchUp_KeyUp(camera_t &camera)
+{
+ Camera_clearMovementFlags(camera, MOVE_PITCHUP);
+}
+
+void Camera_PitchDown_KeyDown(camera_t &camera)
+{
+ Camera_setMovementFlags(camera, MOVE_PITCHDOWN);
+}
+
+void Camera_PitchDown_KeyUp(camera_t &camera)
+{
+ Camera_clearMovementFlags(camera, MOVE_PITCHDOWN);
+}
+
+
+typedef ReferenceCaller<camera_t, void(), &Camera_MoveForward_KeyDown> FreeMoveCameraMoveForwardKeyDownCaller;
+typedef ReferenceCaller<camera_t, void(), &Camera_MoveForward_KeyUp> FreeMoveCameraMoveForwardKeyUpCaller;
+typedef ReferenceCaller<camera_t, void(), &Camera_MoveBack_KeyDown> FreeMoveCameraMoveBackKeyDownCaller;
+typedef ReferenceCaller<camera_t, void(), &Camera_MoveBack_KeyUp> FreeMoveCameraMoveBackKeyUpCaller;
+typedef ReferenceCaller<camera_t, void(), &Camera_MoveLeft_KeyDown> FreeMoveCameraMoveLeftKeyDownCaller;
+typedef ReferenceCaller<camera_t, void(), &Camera_MoveLeft_KeyUp> FreeMoveCameraMoveLeftKeyUpCaller;
+typedef ReferenceCaller<camera_t, void(), &Camera_MoveRight_KeyDown> FreeMoveCameraMoveRightKeyDownCaller;
+typedef ReferenceCaller<camera_t, void(), &Camera_MoveRight_KeyUp> FreeMoveCameraMoveRightKeyUpCaller;
+typedef ReferenceCaller<camera_t, void(), &Camera_MoveUp_KeyDown> FreeMoveCameraMoveUpKeyDownCaller;
+typedef ReferenceCaller<camera_t, void(), &Camera_MoveUp_KeyUp> FreeMoveCameraMoveUpKeyUpCaller;
+typedef ReferenceCaller<camera_t, void(), &Camera_MoveDown_KeyDown> FreeMoveCameraMoveDownKeyDownCaller;
+typedef ReferenceCaller<camera_t, void(), &Camera_MoveDown_KeyUp> FreeMoveCameraMoveDownKeyUpCaller;
+
+
+const float SPEED_MOVE = 32;
+const float SPEED_TURN = 22.5;
+const float MIN_CAM_SPEED = 10;
+const float MAX_CAM_SPEED = 610;
+const float CAM_SPEED_STEP = 50;
+
+void Camera_MoveForward_Discrete(camera_t &camera)
+{
+ Camera_Move_updateAxes(camera);
+ Camera_setOrigin(camera, vector3_added(Camera_getOrigin(camera), vector3_scaled(camera.forward, SPEED_MOVE)));
+}
+
+void Camera_MoveBack_Discrete(camera_t &camera)
+{
+ Camera_Move_updateAxes(camera);
+ Camera_setOrigin(camera, vector3_added(Camera_getOrigin(camera), vector3_scaled(camera.forward, -SPEED_MOVE)));
+}
+
+void Camera_MoveUp_Discrete(camera_t &camera)
+{
+ Vector3 origin(Camera_getOrigin(camera));
+ origin[2] += SPEED_MOVE;
+ Camera_setOrigin(camera, origin);
+}
+
+void Camera_MoveDown_Discrete(camera_t &camera)
+{
+ Vector3 origin(Camera_getOrigin(camera));
+ origin[2] -= SPEED_MOVE;
+ Camera_setOrigin(camera, origin);
+}
+
+void Camera_MoveLeft_Discrete(camera_t &camera)
+{
+ Camera_Move_updateAxes(camera);
+ Camera_setOrigin(camera, vector3_added(Camera_getOrigin(camera), vector3_scaled(camera.right, -SPEED_MOVE)));
+}
+
+void Camera_MoveRight_Discrete(camera_t &camera)
+{
+ Camera_Move_updateAxes(camera);
+ Camera_setOrigin(camera, vector3_added(Camera_getOrigin(camera), vector3_scaled(camera.right, SPEED_MOVE)));
+}
+
+void Camera_RotateLeft_Discrete(camera_t &camera)
+{
+ Vector3 angles(Camera_getAngles(camera));
+ angles[CAMERA_YAW] += SPEED_TURN;
+ Camera_setAngles(camera, angles);
+}
+
+void Camera_RotateRight_Discrete(camera_t &camera)
+{
+ Vector3 angles(Camera_getAngles(camera));
+ angles[CAMERA_YAW] -= SPEED_TURN;
+ Camera_setAngles(camera, angles);
+}
+
+void Camera_PitchUp_Discrete(camera_t &camera)
+{
+ Vector3 angles(Camera_getAngles(camera));
+ angles[CAMERA_PITCH] += SPEED_TURN;
+ if (angles[CAMERA_PITCH] > 90) {
+ angles[CAMERA_PITCH] = 90;
+ }
+ Camera_setAngles(camera, angles);
+}
+
+void Camera_PitchDown_Discrete(camera_t &camera)
+{
+ Vector3 angles(Camera_getAngles(camera));
+ angles[CAMERA_PITCH] -= SPEED_TURN;
+ if (angles[CAMERA_PITCH] < -90) {
+ angles[CAMERA_PITCH] = -90;
+ }
+ Camera_setAngles(camera, angles);
+}
+
+
+class RadiantCameraView : public CameraView {
+ camera_t &m_camera;
+ View *m_view;
+ Callback<void()> m_update;
+public:
+ RadiantCameraView(camera_t &camera, View *view, const Callback<void()> &update) : m_camera(camera), m_view(view),
+ m_update(update)
+ {
+ }
+
+ void update()
+ {
+ m_view->Construct(m_camera.projection, m_camera.modelview, m_camera.width, m_camera.height);
+ m_update();
+ }
+
+ void setModelview(const Matrix4 &modelview)
+ {
+ m_camera.modelview = modelview;
+ matrix4_multiply_by_matrix4(m_camera.modelview, g_radiant2opengl);
+ matrix4_affine_invert(m_camera.modelview);
+ Camera_updateVectors(m_camera);
+ update();
+ }
+
+ void setFieldOfView(float fieldOfView)
+ {
+ float farClip = Camera_getFarClipPlane(m_camera);
+ m_camera.projection = projection_for_camera(farClip / 4096.0f, farClip, fieldOfView, m_camera.width,
+ m_camera.height);
+ update();
+ }
+};
+
+
+void Camera_motionDelta(int x, int y, unsigned int state, void *data)
+{
+ camera_t *cam = reinterpret_cast<camera_t *>( data );
+
+ cam->m_mouseMove.motion_delta(x, y, state);
+
+ switch (g_camwindow_globals_private.m_nStrafeMode) {
+ case 0:
+ cam->m_strafe = (state & GDK_CONTROL_MASK) != 0;
+ if (cam->m_strafe) {
+ cam->m_strafe_forward = (state & GDK_SHIFT_MASK) != 0;
+ } else {
+ cam->m_strafe_forward = false;
+ }
+ break;
+ case 1:
+ cam->m_strafe = (state & GDK_CONTROL_MASK) != 0 && (state & GDK_SHIFT_MASK) == 0;
+ cam->m_strafe_forward = false;
+ break;
+ case 2:
+ cam->m_strafe = (state & GDK_CONTROL_MASK) != 0 && (state & GDK_SHIFT_MASK) == 0;
+ cam->m_strafe_forward = cam->m_strafe;
+ break;
+ }
+}
+
+class CamWnd {
+ View m_view;
+ camera_t m_Camera;
+ RadiantCameraView m_cameraview;
+#if 0
+ int m_PositionDragCursorX;
+int m_PositionDragCursorY;
+#endif
+
+ guint m_freemove_handle_focusout;
+
+ static Shader *m_state_select1;
+ static Shader *m_state_select2;
+
+ FreezePointer m_freezePointer;
+
+public:
+ ui::GLArea m_gl_widget;
+ ui::Window m_parent{ui::null};
+
+ SelectionSystemWindowObserver *m_window_observer;
+ XORRectangle m_XORRectangle;
+
+ DeferredDraw m_deferredDraw;
+ DeferredMotion m_deferred_motion;
+
+ guint m_selection_button_press_handler;
+ guint m_selection_button_release_handler;
+ guint m_selection_motion_handler;
+
+ guint m_freelook_button_press_handler;
+
+ guint m_sizeHandler;
+ guint m_exposeHandler;
+
+ CamWnd();
+
+ ~CamWnd();
+
+ bool m_drawing;
+
+ void queue_draw()
+ {
+ //ASSERT_MESSAGE(!m_drawing, "CamWnd::queue_draw(): called while draw is already in progress");
+ if (m_drawing) {
+ return;
+ }
+ //globalOutputStream() << "queue... ";
+ m_deferredDraw.draw();
+ }
+
+ void draw();
+
+ static void captureStates()
+ {
+ m_state_select1 = GlobalShaderCache().capture("$CAM_HIGHLIGHT");
+ m_state_select2 = GlobalShaderCache().capture("$CAM_OVERLAY");
+ }
+
+ static void releaseStates()
+ {
+ GlobalShaderCache().release("$CAM_HIGHLIGHT");
+ GlobalShaderCache().release("$CAM_OVERLAY");
+ }
+
+ camera_t &getCamera()
+ {
+ return m_Camera;
+ };
+
+ void BenchMark();
+
+ void Cam_ChangeFloor(bool up);
+
+ void DisableFreeMove();
+
+ void EnableFreeMove();
+
+ bool m_bFreeMove;
+
+ CameraView &getCameraView()
+ {
+ return m_cameraview;
+ }
+
+private:
+ void Cam_Draw();
+};
+
+typedef MemberCaller<CamWnd, void(), &CamWnd::queue_draw> CamWndQueueDraw;
+
+Shader *CamWnd::m_state_select1 = 0;
+Shader *CamWnd::m_state_select2 = 0;
+
+CamWnd *NewCamWnd()
+{
+ return new CamWnd;
+}
+
+void DeleteCamWnd(CamWnd *camwnd)
+{
+ delete camwnd;
+}
+
+void CamWnd_constructStatic()
+{
+ CamWnd::captureStates();
+}
+
+void CamWnd_destroyStatic()
+{
+ CamWnd::releaseStates();
+}
+
+static CamWnd *g_camwnd = 0;
+
+void GlobalCamera_setCamWnd(CamWnd &camwnd)
+{
+ g_camwnd = &camwnd;
+}
+
+
+ui::GLArea CamWnd_getWidget(CamWnd &camwnd)
+{
+ return camwnd.m_gl_widget;
+}
+
+ui::Window CamWnd_getParent(CamWnd &camwnd)
+{
+ return camwnd.m_parent;
+}
+
+ToggleShown g_camera_shown(true);
+
+void CamWnd_setParent(CamWnd &camwnd, ui::Window parent)
+{
+ camwnd.m_parent = parent;
+ g_camera_shown.connect(camwnd.m_parent);
+}
+
+void CamWnd_Update(CamWnd &camwnd)
+{
+ camwnd.queue_draw();
+}
+
+
+camwindow_globals_t g_camwindow_globals;
+
+const Vector3 &Camera_getOrigin(CamWnd &camwnd)
+{
+ return Camera_getOrigin(camwnd.getCamera());
+}
+
+void Camera_setOrigin(CamWnd &camwnd, const Vector3 &origin)
+{
+ Camera_setOrigin(camwnd.getCamera(), origin);
+}
+
+const Vector3 &Camera_getAngles(CamWnd &camwnd)
+{
+ return Camera_getAngles(camwnd.getCamera());
+}
+
+void Camera_setAngles(CamWnd &camwnd, const Vector3 &angles)
+{
+ Camera_setAngles(camwnd.getCamera(), angles);
+}
+
+
+// =============================================================================
+// CamWnd class
+
+gboolean enable_freelook_button_press(ui::Widget widget, GdkEventButton *event, CamWnd *camwnd)
+{
+ if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
+ camwnd->EnableFreeMove();
+ return TRUE;
+ }
+ return FALSE;
+}
+
+gboolean disable_freelook_button_press(ui::Widget widget, GdkEventButton *event, CamWnd *camwnd)
+{
+ if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
+ camwnd->DisableFreeMove();
+ return TRUE;
+ }
+ return FALSE;
+}
+
+#if 0
+ gboolean mousecontrol_button_press( ui::Widget widget, GdkEventButton* event, CamWnd* camwnd ){
+ if ( event->type == GDK_BUTTON_PRESS && event->button == 3 ) {
+ Cam_MouseControl( camwnd->getCamera(), event->x, widget->allocation.height - 1 - event->y );
+ }
+ return FALSE;
+}
+#endif
+
+void camwnd_update_xor_rectangle(CamWnd &self, rect_t area)
+{
+ if (self.m_gl_widget.visible()) {
+ self.m_XORRectangle.set(
+ rectangle_from_area(area.min, area.max, self.getCamera().width, self.getCamera().height));
+ }
+}
+
+
+gboolean selection_button_press(ui::Widget widget, GdkEventButton *event, WindowObserver *observer)
+{
+ if (event->type == GDK_BUTTON_PRESS) {
+ observer->onMouseDown(WindowVector_forDouble(event->x, event->y), button_for_button(event->button),
+ modifiers_for_state(event->state));
+ }
+ return FALSE;
+}
+
+gboolean selection_button_release(ui::Widget widget, GdkEventButton *event, WindowObserver *observer)
+{
+ if (event->type == GDK_BUTTON_RELEASE) {
+ observer->onMouseUp(WindowVector_forDouble(event->x, event->y), button_for_button(event->button),
+ modifiers_for_state(event->state));
+ }
+ return FALSE;
+}
+
+void selection_motion(gdouble x, gdouble y, guint state, void *data)
+{
+ //globalOutputStream() << "motion... ";
+ reinterpret_cast<WindowObserver *>( data )->onMouseMotion(WindowVector_forDouble(x, y), modifiers_for_state(state));
+}
+
+inline WindowVector windowvector_for_widget_centre(ui::Widget widget)
+{
+ auto allocation = widget.dimensions();
+ return WindowVector(static_cast<float>( allocation.width / 2 ), static_cast<float>(allocation.height / 2 ));
+}
+
+gboolean selection_button_press_freemove(ui::Widget widget, GdkEventButton *event, WindowObserver *observer)
+{
+ if (event->type == GDK_BUTTON_PRESS) {
+ observer->onMouseDown(windowvector_for_widget_centre(widget), button_for_button(event->button),
+ modifiers_for_state(event->state));
+ }
+ return FALSE;
+}
+
+gboolean selection_button_release_freemove(ui::Widget widget, GdkEventButton *event, WindowObserver *observer)
+{
+ if (event->type == GDK_BUTTON_RELEASE) {
+ observer->onMouseUp(windowvector_for_widget_centre(widget), button_for_button(event->button),
+ modifiers_for_state(event->state));
+ }
+ return FALSE;
+}
+
+gboolean selection_motion_freemove(ui::Widget widget, GdkEventMotion *event, WindowObserver *observer)
+{
+ observer->onMouseMotion(windowvector_for_widget_centre(widget), modifiers_for_state(event->state));
+ return FALSE;
+}
+
+gboolean wheelmove_scroll(ui::Widget widget, GdkEventScroll *event, CamWnd *camwnd)
+{
+ if (event->direction == GDK_SCROLL_UP) {
+ Camera_Freemove_updateAxes(camwnd->getCamera());
+ Camera_setOrigin(*camwnd, vector3_added(Camera_getOrigin(*camwnd), vector3_scaled(camwnd->getCamera().forward,
+ static_cast<float>( g_camwindow_globals_private.m_nMoveSpeed ))));
+ } else if (event->direction == GDK_SCROLL_DOWN) {
+ Camera_Freemove_updateAxes(camwnd->getCamera());
+ Camera_setOrigin(*camwnd, vector3_added(Camera_getOrigin(*camwnd), vector3_scaled(camwnd->getCamera().forward,
+ -static_cast<float>( g_camwindow_globals_private.m_nMoveSpeed ))));
+ }
+
+ return FALSE;
+}
+
+gboolean camera_size_allocate(ui::Widget widget, GtkAllocation *allocation, CamWnd *camwnd)
+{
+ camwnd->getCamera().width = allocation->width;
+ camwnd->getCamera().height = allocation->height;
+ Camera_updateProjection(camwnd->getCamera());
+ camwnd->m_window_observer->onSizeChanged(camwnd->getCamera().width, camwnd->getCamera().height);
+ camwnd->queue_draw();
+ return FALSE;
+}
+
+gboolean camera_expose(ui::Widget widget, GdkEventExpose *event, gpointer data)
+{
+ reinterpret_cast<CamWnd *>( data )->draw();
+ return FALSE;
+}
+
+void KeyEvent_connect(const char *name)
+{
+ const KeyEvent &keyEvent = GlobalKeyEvents_find(name);
+ keydown_accelerators_add(keyEvent.m_accelerator, keyEvent.m_keyDown);
+ keyup_accelerators_add(keyEvent.m_accelerator, keyEvent.m_keyUp);
+}
+
+void KeyEvent_disconnect(const char *name)
+{
+ const KeyEvent &keyEvent = GlobalKeyEvents_find(name);
+ keydown_accelerators_remove(keyEvent.m_accelerator);
+ keyup_accelerators_remove(keyEvent.m_accelerator);
+}
+
+void CamWnd_registerCommands(CamWnd &camwnd)
+{
+ GlobalKeyEvents_insert("CameraForward", Accelerator(GDK_KEY_Up),
+ ReferenceCaller<camera_t, void(), Camera_MoveForward_KeyDown>(camwnd.getCamera()),
+ ReferenceCaller<camera_t, void(), Camera_MoveForward_KeyUp>(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraBack", Accelerator(GDK_KEY_Down),
+ ReferenceCaller<camera_t, void(), Camera_MoveBack_KeyDown>(camwnd.getCamera()),
+ ReferenceCaller<camera_t, void(), Camera_MoveBack_KeyUp>(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraLeft", Accelerator(GDK_KEY_Left),
+ ReferenceCaller<camera_t, void(), Camera_RotateLeft_KeyDown>(camwnd.getCamera()),
+ ReferenceCaller<camera_t, void(), Camera_RotateLeft_KeyUp>(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraRight", Accelerator(GDK_KEY_Right),
+ ReferenceCaller<camera_t, void(), Camera_RotateRight_KeyDown>(camwnd.getCamera()),
+ ReferenceCaller<camera_t, void(), Camera_RotateRight_KeyUp>(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraStrafeRight", Accelerator(GDK_KEY_period),
+ ReferenceCaller<camera_t, void(), Camera_MoveRight_KeyDown>(camwnd.getCamera()),
+ ReferenceCaller<camera_t, void(), Camera_MoveRight_KeyUp>(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraStrafeLeft", Accelerator(GDK_KEY_comma),
+ ReferenceCaller<camera_t, void(), Camera_MoveLeft_KeyDown>(camwnd.getCamera()),
+ ReferenceCaller<camera_t, void(), Camera_MoveLeft_KeyUp>(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraUp", Accelerator('D'),
+ ReferenceCaller<camera_t, void(), Camera_MoveUp_KeyDown>(camwnd.getCamera()),
+ ReferenceCaller<camera_t, void(), Camera_MoveUp_KeyUp>(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraDown", Accelerator('C'),
+ ReferenceCaller<camera_t, void(), Camera_MoveDown_KeyDown>(camwnd.getCamera()),
+ ReferenceCaller<camera_t, void(), Camera_MoveDown_KeyUp>(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraAngleDown", Accelerator('A'),
+ ReferenceCaller<camera_t, void(), Camera_PitchDown_KeyDown>(camwnd.getCamera()),
+ ReferenceCaller<camera_t, void(), Camera_PitchDown_KeyUp>(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraAngleUp", Accelerator('Z'),
+ ReferenceCaller<camera_t, void(), Camera_PitchUp_KeyDown>(camwnd.getCamera()),
+ ReferenceCaller<camera_t, void(), Camera_PitchUp_KeyUp>(camwnd.getCamera())
+ );
+
+ GlobalKeyEvents_insert("CameraFreeMoveForward", Accelerator(GDK_KEY_Up),
+ FreeMoveCameraMoveForwardKeyDownCaller(camwnd.getCamera()),
+ FreeMoveCameraMoveForwardKeyUpCaller(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraFreeMoveBack", Accelerator(GDK_KEY_Down),
+ FreeMoveCameraMoveBackKeyDownCaller(camwnd.getCamera()),
+ FreeMoveCameraMoveBackKeyUpCaller(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraFreeMoveLeft", Accelerator(GDK_KEY_Left),
+ FreeMoveCameraMoveLeftKeyDownCaller(camwnd.getCamera()),
+ FreeMoveCameraMoveLeftKeyUpCaller(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraFreeMoveRight", Accelerator(GDK_KEY_Right),
+ FreeMoveCameraMoveRightKeyDownCaller(camwnd.getCamera()),
+ FreeMoveCameraMoveRightKeyUpCaller(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraFreeMoveUp", Accelerator('D'),
+ FreeMoveCameraMoveUpKeyDownCaller(camwnd.getCamera()),
+ FreeMoveCameraMoveUpKeyUpCaller(camwnd.getCamera())
+ );
+ GlobalKeyEvents_insert("CameraFreeMoveDown", Accelerator('C'),
+ FreeMoveCameraMoveDownKeyDownCaller(camwnd.getCamera()),
+ FreeMoveCameraMoveDownKeyUpCaller(camwnd.getCamera())
+ );
+
+ GlobalCommands_insert("CameraForward",
+ ReferenceCaller<camera_t, void(), Camera_MoveForward_Discrete>(camwnd.getCamera()),
+ Accelerator(GDK_KEY_Up));
+ GlobalCommands_insert("CameraBack", ReferenceCaller<camera_t, void(), Camera_MoveBack_Discrete>(camwnd.getCamera()),
+ Accelerator(GDK_KEY_Down));
+ GlobalCommands_insert("CameraLeft",
+ ReferenceCaller<camera_t, void(), Camera_RotateLeft_Discrete>(camwnd.getCamera()),
+ Accelerator(GDK_KEY_Left));
+ GlobalCommands_insert("CameraRight",
+ ReferenceCaller<camera_t, void(), Camera_RotateRight_Discrete>(camwnd.getCamera()),
+ Accelerator(GDK_KEY_Right));
+ GlobalCommands_insert("CameraStrafeRight",
+ ReferenceCaller<camera_t, void(), Camera_MoveRight_Discrete>(camwnd.getCamera()),
+ Accelerator(GDK_KEY_period));
+ GlobalCommands_insert("CameraStrafeLeft",
+ ReferenceCaller<camera_t, void(), Camera_MoveLeft_Discrete>(camwnd.getCamera()),
+ Accelerator(GDK_KEY_comma));
+
+ GlobalCommands_insert("CameraUp", ReferenceCaller<camera_t, void(), Camera_MoveUp_Discrete>(camwnd.getCamera()),
+ Accelerator('D'));
+ GlobalCommands_insert("CameraDown", ReferenceCaller<camera_t, void(), Camera_MoveDown_Discrete>(camwnd.getCamera()),
+ Accelerator('C'));
+ GlobalCommands_insert("CameraAngleUp",
+ ReferenceCaller<camera_t, void(), Camera_PitchUp_Discrete>(camwnd.getCamera()),
+ Accelerator('A'));
+ GlobalCommands_insert("CameraAngleDown",
+ ReferenceCaller<camera_t, void(), Camera_PitchDown_Discrete>(camwnd.getCamera()),
+ Accelerator('Z'));
+}
+
+void CamWnd_Move_Enable(CamWnd &camwnd)
+{
+ KeyEvent_connect("CameraForward");
+ KeyEvent_connect("CameraBack");
+ KeyEvent_connect("CameraLeft");
+ KeyEvent_connect("CameraRight");
+ KeyEvent_connect("CameraStrafeRight");
+ KeyEvent_connect("CameraStrafeLeft");
+ KeyEvent_connect("CameraUp");
+ KeyEvent_connect("CameraDown");
+ KeyEvent_connect("CameraAngleUp");
+ KeyEvent_connect("CameraAngleDown");
+}
+
+void CamWnd_Move_Disable(CamWnd &camwnd)
+{
+ KeyEvent_disconnect("CameraForward");
+ KeyEvent_disconnect("CameraBack");
+ KeyEvent_disconnect("CameraLeft");
+ KeyEvent_disconnect("CameraRight");
+ KeyEvent_disconnect("CameraStrafeRight");
+ KeyEvent_disconnect("CameraStrafeLeft");
+ KeyEvent_disconnect("CameraUp");
+ KeyEvent_disconnect("CameraDown");
+ KeyEvent_disconnect("CameraAngleUp");
+ KeyEvent_disconnect("CameraAngleDown");
+}
+
+void CamWnd_Move_Discrete_Enable(CamWnd &camwnd)
+{
+ command_connect_accelerator("CameraForward");
+ command_connect_accelerator("CameraBack");
+ command_connect_accelerator("CameraLeft");
+ command_connect_accelerator("CameraRight");
+ command_connect_accelerator("CameraStrafeRight");
+ command_connect_accelerator("CameraStrafeLeft");
+ command_connect_accelerator("CameraUp");
+ command_connect_accelerator("CameraDown");
+ command_connect_accelerator("CameraAngleUp");
+ command_connect_accelerator("CameraAngleDown");
+}
+
+void CamWnd_Move_Discrete_Disable(CamWnd &camwnd)
+{
+ command_disconnect_accelerator("CameraForward");
+ command_disconnect_accelerator("CameraBack");
+ command_disconnect_accelerator("CameraLeft");
+ command_disconnect_accelerator("CameraRight");
+ command_disconnect_accelerator("CameraStrafeRight");
+ command_disconnect_accelerator("CameraStrafeLeft");
+ command_disconnect_accelerator("CameraUp");
+ command_disconnect_accelerator("CameraDown");
+ command_disconnect_accelerator("CameraAngleUp");
+ command_disconnect_accelerator("CameraAngleDown");
+}
+
+struct CamWnd_Move_Discrete {
+ static void Export(const Callback<void(bool)> &returnz)
+ {
+ returnz(g_camwindow_globals_private.m_bCamDiscrete);
+ }
+
+ static void Import(bool value)
+ {
+ if (g_camwnd) {
+ Import_(*g_camwnd, value);
+ } else {
+ g_camwindow_globals_private.m_bCamDiscrete = value;
+ }
+ }
+
+ static void Import_(CamWnd &camwnd, bool value)
+ {
+ if (g_camwindow_globals_private.m_bCamDiscrete) {
+ CamWnd_Move_Discrete_Disable(camwnd);
+ } else {
+ CamWnd_Move_Disable(camwnd);
+ }
+
+ g_camwindow_globals_private.m_bCamDiscrete = value;
+
+ if (g_camwindow_globals_private.m_bCamDiscrete) {
+ CamWnd_Move_Discrete_Enable(camwnd);
+ } else {
+ CamWnd_Move_Enable(camwnd);
+ }
+ }
+};
+
+
+void CamWnd_Add_Handlers_Move(CamWnd &camwnd)
+{
+ camwnd.m_selection_button_press_handler = camwnd.m_gl_widget.connect("button_press_event",
+ G_CALLBACK(selection_button_press),
+ camwnd.m_window_observer);
+ camwnd.m_selection_button_release_handler = camwnd.m_gl_widget.connect("button_release_event",
+ G_CALLBACK(selection_button_release),
+ camwnd.m_window_observer);
+ camwnd.m_selection_motion_handler = camwnd.m_gl_widget.connect("motion_notify_event",
+ G_CALLBACK(DeferredMotion::gtk_motion),
+ &camwnd.m_deferred_motion);
+
+ camwnd.m_freelook_button_press_handler = camwnd.m_gl_widget.connect("button_press_event",
+ G_CALLBACK(enable_freelook_button_press),
+ &camwnd);
+
+ if (g_camwindow_globals_private.m_bCamDiscrete) {
+ CamWnd_Move_Discrete_Enable(camwnd);
+ } else {
+ CamWnd_Move_Enable(camwnd);
+ }
+}
+
+void CamWnd_Remove_Handlers_Move(CamWnd &camwnd)
+{
+ g_signal_handler_disconnect(G_OBJECT(camwnd.m_gl_widget), camwnd.m_selection_button_press_handler);
+ g_signal_handler_disconnect(G_OBJECT(camwnd.m_gl_widget), camwnd.m_selection_button_release_handler);
+ g_signal_handler_disconnect(G_OBJECT(camwnd.m_gl_widget), camwnd.m_selection_motion_handler);
+
+ g_signal_handler_disconnect(G_OBJECT(camwnd.m_gl_widget), camwnd.m_freelook_button_press_handler);
+
+ if (g_camwindow_globals_private.m_bCamDiscrete) {
+ CamWnd_Move_Discrete_Disable(camwnd);
+ } else {
+ CamWnd_Move_Disable(camwnd);
+ }
+}
+
+void CamWnd_Add_Handlers_FreeMove(CamWnd &camwnd)
+{
+ camwnd.m_selection_button_press_handler = camwnd.m_gl_widget.connect("button_press_event",
+ G_CALLBACK(selection_button_press_freemove),
+ camwnd.m_window_observer);
+ camwnd.m_selection_button_release_handler = camwnd.m_gl_widget.connect("button_release_event", G_CALLBACK(
+ selection_button_release_freemove), camwnd.m_window_observer);
+ camwnd.m_selection_motion_handler = camwnd.m_gl_widget.connect("motion_notify_event",
+ G_CALLBACK(selection_motion_freemove),
+ camwnd.m_window_observer);
+
+ camwnd.m_freelook_button_press_handler = camwnd.m_gl_widget.connect("button_press_event",
+ G_CALLBACK(disable_freelook_button_press),
+ &camwnd);
+
+ KeyEvent_connect("CameraFreeMoveForward");
+ KeyEvent_connect("CameraFreeMoveBack");
+ KeyEvent_connect("CameraFreeMoveLeft");
+ KeyEvent_connect("CameraFreeMoveRight");
+ KeyEvent_connect("CameraFreeMoveUp");
+ KeyEvent_connect("CameraFreeMoveDown");
+}
+
+void CamWnd_Remove_Handlers_FreeMove(CamWnd &camwnd)
+{
+ KeyEvent_disconnect("CameraFreeMoveForward");
+ KeyEvent_disconnect("CameraFreeMoveBack");
+ KeyEvent_disconnect("CameraFreeMoveLeft");
+ KeyEvent_disconnect("CameraFreeMoveRight");
+ KeyEvent_disconnect("CameraFreeMoveUp");
+ KeyEvent_disconnect("CameraFreeMoveDown");
+
+ g_signal_handler_disconnect(G_OBJECT(camwnd.m_gl_widget), camwnd.m_selection_button_press_handler);
+ g_signal_handler_disconnect(G_OBJECT(camwnd.m_gl_widget), camwnd.m_selection_button_release_handler);
+ g_signal_handler_disconnect(G_OBJECT(camwnd.m_gl_widget), camwnd.m_selection_motion_handler);
+
+ g_signal_handler_disconnect(G_OBJECT(camwnd.m_gl_widget), camwnd.m_freelook_button_press_handler);
+}
+
+CamWnd::CamWnd() :
+ m_view(true),
+ m_Camera(&m_view, CamWndQueueDraw(*this)),
+ m_cameraview(m_Camera, &m_view, ReferenceCaller<CamWnd, void(), CamWnd_Update>(*this)),
+ m_gl_widget(glwidget_new(TRUE)),
+ m_window_observer(NewWindowObserver()),
+ m_XORRectangle(m_gl_widget),
+ m_deferredDraw(WidgetQueueDrawCaller(m_gl_widget)),
+ m_deferred_motion(selection_motion, m_window_observer),
+ m_selection_button_press_handler(0),
+ m_selection_button_release_handler(0),
+ m_selection_motion_handler(0),
+ m_freelook_button_press_handler(0),
+ m_drawing(false)
+{
+ m_bFreeMove = false;
+
+ GlobalWindowObservers_add(m_window_observer);
+ GlobalWindowObservers_connectWidget(m_gl_widget);
+
+ m_window_observer->setRectangleDrawCallback(
+ ReferenceCaller<CamWnd, void(rect_t), camwnd_update_xor_rectangle>(*this));
+ m_window_observer->setView(m_view);
+
+ g_object_ref(m_gl_widget._handle);
+
+ gtk_widget_set_events(m_gl_widget,
+ GDK_DESTROY | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
+ GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK);
+ gtk_widget_set_can_focus(m_gl_widget, true);
+
+ m_sizeHandler = m_gl_widget.connect("size_allocate", G_CALLBACK(camera_size_allocate), this);
+ m_exposeHandler = m_gl_widget.on_render(G_CALLBACK(camera_expose), this);
+
+ Map_addValidCallback(g_map, DeferredDrawOnMapValidChangedCaller(m_deferredDraw));
+
+ CamWnd_registerCommands(*this);
+
+ CamWnd_Add_Handlers_Move(*this);
+
+ m_gl_widget.connect("scroll_event", G_CALLBACK(wheelmove_scroll), this);
+
+ AddSceneChangeCallback(ReferenceCaller<CamWnd, void(), CamWnd_Update>(*this));
+
+ PressedButtons_connect(g_pressedButtons, m_gl_widget);
+}
+
+CamWnd::~CamWnd()
+{
+ if (m_bFreeMove) {
+ DisableFreeMove();
+ }
+
+ CamWnd_Remove_Handlers_Move(*this);
+
+ g_signal_handler_disconnect(G_OBJECT(m_gl_widget), m_sizeHandler);
+ g_signal_handler_disconnect(G_OBJECT(m_gl_widget), m_exposeHandler);
+
+ m_gl_widget.unref();
+
+ m_window_observer->release();
+}
+
+class FloorHeightWalker : public scene::Graph::Walker {
+ float m_current;
+ float &m_bestUp;
+ float &m_bestDown;
+public:
+ FloorHeightWalker(float current, float &bestUp, float &bestDown) :
+ m_current(current), m_bestUp(bestUp), m_bestDown(bestDown)
+ {
+ bestUp = g_MaxWorldCoord;
+ bestDown = -g_MaxWorldCoord;
+ }
+
+ bool pre(const scene::Path &path, scene::Instance &instance) const
+ {
+ if (path.top().get().visible()
+ && Node_isBrush(path.top())) { // this node is a floor
+ const AABB &aabb = instance.worldAABB();
+ float floorHeight = aabb.origin.z() + aabb.extents.z();
+ if (floorHeight > m_current && floorHeight < m_bestUp) {
+ m_bestUp = floorHeight;
+ }
+ if (floorHeight < m_current && floorHeight > m_bestDown) {
+ m_bestDown = floorHeight;
+ }
+ }
+ return true;
+ }
+};
+
+void CamWnd::Cam_ChangeFloor(bool up)
+{
+ float current = m_Camera.origin[2] - 48;
+ float bestUp;
+ float bestDown;
+ GlobalSceneGraph().traverse(FloorHeightWalker(current, bestUp, bestDown));
+
+ if (up && bestUp != g_MaxWorldCoord) {
+ current = bestUp;
+ }
+ if (!up && bestDown != -g_MaxWorldCoord) {
+ current = bestDown;
+ }
+
+ m_Camera.origin[2] = current + 48;
+ Camera_updateModelview(getCamera());
+ CamWnd_Update(*this);
+ CameraMovedNotify();
+}
+
+
+#if 0
+
+ // button_press
+Sys_GetCursorPos( &m_PositionDragCursorX, &m_PositionDragCursorY );
+
+// motion
+if ( ( m_bFreeMove && ( buttons == ( RAD_CONTROL | RAD_SHIFT ) ) )
+ || ( !m_bFreeMove && ( buttons == ( RAD_RBUTTON | RAD_CONTROL ) ) ) ) {
+ Cam_PositionDrag();
+ CamWnd_Update( camwnd );
+ CameraMovedNotify();
+ return;
+}
+
+void CamWnd::Cam_PositionDrag(){
+ int x, y;
+
+ Sys_GetCursorPos( m_gl_widget, &x, &y );
+ if ( x != m_PositionDragCursorX || y != m_PositionDragCursorY ) {
+ x -= m_PositionDragCursorX;
+ vector3_add( m_Camera.origin, vector3_scaled( m_Camera.vright, x ) );
+ y -= m_PositionDragCursorY;
+ m_Camera.origin[2] -= y;
+ Camera_updateModelview();
+ CamWnd_Update( camwnd );
+ CameraMovedNotify();
+
+ Sys_SetCursorPos( m_parent, m_PositionDragCursorX, m_PositionDragCursorY );
+ }
+}
+#endif
+
+
+// NOTE TTimo if there's an OS-level focus out of the application
+// then we can release the camera cursor grab
+static gboolean camwindow_freemove_focusout(ui::Widget widget, GdkEventFocus *event, gpointer data)
+{
+ reinterpret_cast<CamWnd *>( data )->DisableFreeMove();
+ return FALSE;
+}
+
+void CamWnd::EnableFreeMove()
+{
+ //globalOutputStream() << "EnableFreeMove\n";
+
+ ASSERT_MESSAGE(!m_bFreeMove, "EnableFreeMove: free-move was already enabled");
+ m_bFreeMove = true;
+ Camera_clearMovementFlags(getCamera(), MOVE_ALL);
+
+ CamWnd_Remove_Handlers_Move(*this);
+ CamWnd_Add_Handlers_FreeMove(*this);
+
+ gtk_window_set_focus(m_parent, m_gl_widget);
+ m_freemove_handle_focusout = m_gl_widget.connect("focus_out_event", G_CALLBACK(camwindow_freemove_focusout), this);
+ m_freezePointer.freeze_pointer(m_parent, Camera_motionDelta, &m_Camera);
+
+ CamWnd_Update(*this);
+}
+
+void CamWnd::DisableFreeMove()
+{
+ //globalOutputStream() << "DisableFreeMove\n";
+
+ ASSERT_MESSAGE(m_bFreeMove, "DisableFreeMove: free-move was not enabled");
+ m_bFreeMove = false;
+ Camera_clearMovementFlags(getCamera(), MOVE_ALL);
+
+ CamWnd_Remove_Handlers_FreeMove(*this);
+ CamWnd_Add_Handlers_Move(*this);
+
+ m_freezePointer.unfreeze_pointer(m_parent);
+ g_signal_handler_disconnect(G_OBJECT(m_gl_widget), m_freemove_handle_focusout);
+
+ CamWnd_Update(*this);
+}
+
+
+#include "renderer.h"
+
+class CamRenderer : public Renderer {
+ struct state_type {
+ state_type() : m_highlight(0), m_state(0), m_lights(0)
+ {
+ }
+
+ unsigned int m_highlight;
+ Shader *m_state;
+ const LightList *m_lights;
+ };
+
+ std::vector<state_type> m_state_stack;
+ RenderStateFlags m_globalstate;
+ Shader *m_state_select0;
+ Shader *m_state_select1;
+ const Vector3 &m_viewer;
+
+public:
+ CamRenderer(RenderStateFlags globalstate, Shader *select0, Shader *select1, const Vector3 &viewer) :
+ m_globalstate(globalstate),
+ m_state_select0(select0),
+ m_state_select1(select1),
+ m_viewer(viewer)
+ {
+ ASSERT_NOTNULL(select0);
+ ASSERT_NOTNULL(select1);
+ m_state_stack.push_back(state_type());
+ }
+
+ void SetState(Shader *state, EStyle style)
+ {
+ ASSERT_NOTNULL(state);
+ if (style == eFullMaterials) {
+ m_state_stack.back().m_state = state;
+ }
+ }
+
+ EStyle getStyle() const
+ {
+ return eFullMaterials;
+ }
+
+ void PushState()
+ {
+ m_state_stack.push_back(m_state_stack.back());
+ }
+
+ void PopState()
+ {
+ ASSERT_MESSAGE(!m_state_stack.empty(), "popping empty stack");
+ m_state_stack.pop_back();
+ }
+
+ void Highlight(EHighlightMode mode, bool bEnable = true)
+ {
+ (bEnable)
+ ? m_state_stack.back().m_highlight |= mode
+ : m_state_stack.back().m_highlight &= ~mode;
+ }
+
+ void setLights(const LightList &lights)
+ {
+ m_state_stack.back().m_lights = &lights;
+ }
+
+ void addRenderable(const OpenGLRenderable &renderable, const Matrix4 &world)
+ {
+ if (m_state_stack.back().m_highlight & ePrimitive) {
+ m_state_select0->addRenderable(renderable, world, m_state_stack.back().m_lights);
+ }
+ if (m_state_stack.back().m_highlight & eFace) {
+ m_state_select1->addRenderable(renderable, world, m_state_stack.back().m_lights);
+ }
+
+ m_state_stack.back().m_state->addRenderable(renderable, world, m_state_stack.back().m_lights);
+ }
+
+ void render(const Matrix4 &modelview, const Matrix4 &projection)
+ {
+ GlobalShaderCache().render(m_globalstate, modelview, projection, m_viewer);
+ }
+};
+
+/*
+ ==============
+ Cam_Draw
+ ==============
+ */
+
+void ShowStatsToggle()
+{
+ g_camwindow_globals_private.m_showStats ^= 1;
+}
+
+void ShowStatsExport(const Callback<void(bool)> &importer)
+{
+ importer(g_camwindow_globals_private.m_showStats);
+}
+
+FreeCaller<void(const Callback<void(bool)> &), ShowStatsExport> g_show_stats_caller;
+Callback<void(const Callback<void(bool)> &)> g_show_stats_callback(g_show_stats_caller);
+ToggleItem g_show_stats(g_show_stats_callback);
+
+void CamWnd::Cam_Draw()
+{
+ glViewport(0, 0, m_Camera.width, m_Camera.height);
+#if 0
+ GLint viewprt[4];
+ glGetIntegerv( GL_VIEWPORT, viewprt );
+#endif
+
+ // enable depth buffer writes
+ glDepthMask(GL_TRUE);
+ glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+
+ Vector3 clearColour(0, 0, 0);
+ if (m_Camera.draw_mode != cd_lighting) {
+ clearColour = g_camwindow_globals.color_cameraback;
+ }
+
+ glClearColor(clearColour[0], clearColour[1], clearColour[2], 0);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ extern void Renderer_ResetStats();
+ Renderer_ResetStats();
+ extern void Cull_ResetStats();
+ Cull_ResetStats();
+
+ glMatrixMode(GL_PROJECTION);
+ glLoadMatrixf(reinterpret_cast<const float *>( &m_Camera.projection ));
+
+ glMatrixMode(GL_MODELVIEW);
+ glLoadMatrixf(reinterpret_cast<const float *>( &m_Camera.modelview ));
+
+
+ // one directional light source directly behind the viewer
+ {
+ GLfloat inverse_cam_dir[4], ambient[4], diffuse[4]; //, material[4];
+
+ ambient[0] = ambient[1] = ambient[2] = 0.4f;
+ ambient[3] = 1.0f;
+ diffuse[0] = diffuse[1] = diffuse[2] = 0.4f;
+ diffuse[3] = 1.0f;
+ //material[0] = material[1] = material[2] = 0.8f;
+ //material[3] = 1.0f;
+
+ inverse_cam_dir[0] = m_Camera.vpn[0];
+ inverse_cam_dir[1] = m_Camera.vpn[1];
+ inverse_cam_dir[2] = m_Camera.vpn[2];
+ inverse_cam_dir[3] = 0;
+
+ glLightfv(GL_LIGHT0, GL_POSITION, inverse_cam_dir);
+
+ glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
+ glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
+
+ glEnable(GL_LIGHT0);
+ }
+
+
+ unsigned int globalstate =
+ RENDER_DEPTHTEST | RENDER_COLOURWRITE | RENDER_DEPTHWRITE | RENDER_ALPHATEST | RENDER_BLEND |
+ RENDER_CULLFACE | RENDER_COLOURARRAY | RENDER_OFFSETLINE | RENDER_POLYGONSMOOTH | RENDER_LINESMOOTH |
+ RENDER_FOG | RENDER_COLOURCHANGE;
+ switch (m_Camera.draw_mode) {
+ case cd_wire:
+ break;
+ case cd_solid:
+ globalstate |= RENDER_FILL
+ | RENDER_LIGHTING
+ | RENDER_SMOOTH
+ | RENDER_SCALED;
+ break;
+ case cd_texture:
+ globalstate |= RENDER_FILL
+ | RENDER_LIGHTING
+ | RENDER_TEXTURE
+ | RENDER_SMOOTH
+ | RENDER_SCALED;
+ break;
+ case cd_lighting:
+ globalstate |= RENDER_FILL
+ | RENDER_LIGHTING
+ | RENDER_TEXTURE
+ | RENDER_SMOOTH
+ | RENDER_SCALED
+ | RENDER_BUMP
+ | RENDER_PROGRAM
+ | RENDER_SCREEN;
+ break;
+ default:
+ globalstate = 0;
+ break;
+ }
+
+ if (!g_xywindow_globals.m_bNoStipple) {
+ globalstate |= RENDER_LINESTIPPLE | RENDER_POLYGONSTIPPLE;
+ }
+
+ {
+ CamRenderer renderer(globalstate, m_state_select2, m_state_select1, m_view.getViewer());
+
+ Scene_Render(renderer, m_view);
+
+ renderer.render(m_Camera.modelview, m_Camera.projection);
+ }
+
+ // prepare for 2d stuff
+ glColor4f(1, 1, 1, 1);
+ glDisable(GL_BLEND);
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ glOrtho(0, (float) m_Camera.width, 0, (float) m_Camera.height, -100, 100);
+ glScalef(1, -1, 1);
+ glTranslatef(0, -(float) m_Camera.height, 0);
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+
+ if (GlobalOpenGL().GL_1_3()) {
+ glClientActiveTexture(GL_TEXTURE0);
+ glActiveTexture(GL_TEXTURE0);
+ }
+
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
+ glDisableClientState(GL_COLOR_ARRAY);
+
+ glDisable(GL_TEXTURE_2D);
+ glDisable(GL_LIGHTING);
+ glDisable(GL_COLOR_MATERIAL);
+ glDisable(GL_DEPTH_TEST);
+ glColor3f(1.f, 1.f, 1.f);
+ glLineWidth(1);
+
+ // draw the crosshair
+ if (m_bFreeMove) {
+ glBegin(GL_LINES);
+ glVertex2f((float) m_Camera.width / 2.f, (float) m_Camera.height / 2.f + 6);
+ glVertex2f((float) m_Camera.width / 2.f, (float) m_Camera.height / 2.f + 2);
+ glVertex2f((float) m_Camera.width / 2.f, (float) m_Camera.height / 2.f - 6);
+ glVertex2f((float) m_Camera.width / 2.f, (float) m_Camera.height / 2.f - 2);
+ glVertex2f((float) m_Camera.width / 2.f + 6, (float) m_Camera.height / 2.f);
+ glVertex2f((float) m_Camera.width / 2.f + 2, (float) m_Camera.height / 2.f);
+ glVertex2f((float) m_Camera.width / 2.f - 6, (float) m_Camera.height / 2.f);
+ glVertex2f((float) m_Camera.width / 2.f - 2, (float) m_Camera.height / 2.f);
+ glEnd();
+ }
+
+ if (g_camwindow_globals_private.m_showStats) {
+ glRasterPos3f(1.0f, static_cast<float>( m_Camera.height ) - GlobalOpenGL().m_font->getPixelDescent(), 0.0f);
+ extern const char *Renderer_GetStats();
+ GlobalOpenGL().drawString(Renderer_GetStats());
+
+ glRasterPos3f(1.0f, static_cast<float>( m_Camera.height ) - GlobalOpenGL().m_font->getPixelDescent() -
+ GlobalOpenGL().m_font->getPixelHeight(), 0.0f);
+ extern const char *Cull_GetStats();
+ GlobalOpenGL().drawString(Cull_GetStats());
+ }
+
+ // bind back to the default texture so that we don't have problems
+ // elsewhere using/modifying texture maps between contexts
+ glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+void CamWnd::draw()
+{
+ m_drawing = true;
+
+ //globalOutputStream() << "draw...\n";
+ if (glwidget_make_current(m_gl_widget) != FALSE) {
+ if (Map_Valid(g_map) && ScreenUpdates_Enabled()) {
+ GlobalOpenGL_debugAssertNoErrors();
+ Cam_Draw();
+ GlobalOpenGL_debugAssertNoErrors();
+ //qglFinish();
+
+ m_XORRectangle.set(rectangle_t());
+ }
+
+ glwidget_swap_buffers(m_gl_widget);
+ }
+
+ m_drawing = false;
+}
+
+void CamWnd::BenchMark()
+{
+ double dStart = Sys_DoubleTime();
+ for (int i = 0; i < 100; i++) {
+ Vector3 angles;
+ angles[CAMERA_ROLL] = 0;
+ angles[CAMERA_PITCH] = 0;
+ angles[CAMERA_YAW] = static_cast<float>( i * (360.0 / 100.0));
+ Camera_setAngles(*this, angles);
+ }
+ double dEnd = Sys_DoubleTime();
+ globalOutputStream() << FloatFormat(dEnd - dStart, 5, 2) << " seconds\n";
+}
+
+
+void fill_view_camera_menu(ui::Menu menu)
+{
+ create_check_menu_item_with_mnemonic(menu, "Camera View", "ToggleCamera");
+}
+
+void GlobalCamera_ResetAngles()
+{
+ CamWnd &camwnd = *g_camwnd;
+ Vector3 angles;
+ angles[CAMERA_ROLL] = angles[CAMERA_PITCH] = 0;
+ angles[CAMERA_YAW] = static_cast<float>( 22.5 * floor((Camera_getAngles(camwnd)[CAMERA_YAW] + 11) / 22.5));
+ Camera_setAngles(camwnd, angles);
+}
+
+void Camera_ChangeFloorUp()
+{
+ CamWnd &camwnd = *g_camwnd;
+ camwnd.Cam_ChangeFloor(true);
+}
+
+void Camera_ChangeFloorDown()
+{
+ CamWnd &camwnd = *g_camwnd;
+ camwnd.Cam_ChangeFloor(false);
+}
+
+void Camera_CubeIn()
+{
+ CamWnd &camwnd = *g_camwnd;
+ g_camwindow_globals.m_nCubicScale--;
+ if (g_camwindow_globals.m_nCubicScale < 1) {
+ g_camwindow_globals.m_nCubicScale = 1;
+ }
+ Camera_updateProjection(camwnd.getCamera());
+ CamWnd_Update(camwnd);
+ g_pParentWnd->SetGridStatus();
+}
+
+void Camera_CubeOut()
+{
+ CamWnd &camwnd = *g_camwnd;
+ g_camwindow_globals.m_nCubicScale++;
+ if (g_camwindow_globals.m_nCubicScale > 23) {
+ g_camwindow_globals.m_nCubicScale = 23;
+ }
+ Camera_updateProjection(camwnd.getCamera());
+ CamWnd_Update(camwnd);
+ g_pParentWnd->SetGridStatus();
+}
+
+bool Camera_GetFarClip()
+{
+ return g_camwindow_globals_private.m_bCubicClipping;
+}
+
+ConstReferenceCaller<bool, void(const Callback<void(bool)> &), PropertyImpl<bool>::Export> g_getfarclip_caller(
+ g_camwindow_globals_private.m_bCubicClipping);
+ToggleItem g_getfarclip_item(g_getfarclip_caller);
+
+void Camera_SetFarClip(bool value)
+{
+ CamWnd &camwnd = *g_camwnd;
+ g_camwindow_globals_private.m_bCubicClipping = value;
+ g_getfarclip_item.update();
+ Camera_updateProjection(camwnd.getCamera());
+ CamWnd_Update(camwnd);
+}
+
+struct Camera_FarClip {
+ static void Export(const Callback<void(bool)> &returnz)
+ {
+ returnz(g_camwindow_globals_private.m_bCubicClipping);
+ }
+
+ static void Import(bool value)
+ {
+ Camera_SetFarClip(value);
+ }
+};
+
+void Camera_ToggleFarClip()
+{
+ Camera_SetFarClip(!Camera_GetFarClip());
+}
+
+
+void CamWnd_constructToolbar(ui::Toolbar toolbar)
+{
+ toolbar_append_toggle_button(toolbar, "Cubic clip the camera view (\\)", "view_cubicclipping.png",
+ "ToggleCubicClip");
+}
+
+void CamWnd_registerShortcuts()
+{
+ toggle_add_accelerator("ToggleCubicClip");
+
+ if (g_pGameDescription->mGameType == "doom3") {
+ command_connect_accelerator("TogglePreview");
+ }
+
+ command_connect_accelerator("CameraSpeedInc");
+ command_connect_accelerator("CameraSpeedDec");
+}
+
+
+void GlobalCamera_Benchmark()
+{
+ CamWnd &camwnd = *g_camwnd;
+ camwnd.BenchMark();
+}
+
+void GlobalCamera_Update()
+{
+ CamWnd &camwnd = *g_camwnd;
+ CamWnd_Update(camwnd);
+}
+
+camera_draw_mode CamWnd_GetMode()
+{
+ return camera_t::draw_mode;
+}
+
+void CamWnd_SetMode(camera_draw_mode mode)
+{
+ ShaderCache_setBumpEnabled(mode == cd_lighting);
+ camera_t::draw_mode = mode;
+ if (g_camwnd != 0) {
+ CamWnd_Update(*g_camwnd);
+ }
+}
+
+void CamWnd_TogglePreview(void)
+{
+ // gametype must be doom3 for this function to work
+ // if the gametype is not doom3 something is wrong with the
+ // global command list or somebody else calls this function.
+ ASSERT_MESSAGE(g_pGameDescription->mGameType == "doom3",
+ "CamWnd_TogglePreview called although mGameType is not doom3 compatible");
+
+ // switch between textured and lighting mode
+ CamWnd_SetMode((CamWnd_GetMode() == cd_lighting) ? cd_texture : cd_lighting);
+}
+
+
+CameraModel *g_camera_model = 0;
+
+void CamWnd_LookThroughCamera(CamWnd &camwnd)
+{
+ if (g_camera_model != 0) {
+ CamWnd_Add_Handlers_Move(camwnd);
+ g_camera_model->setCameraView(0, Callback<void()>());
+ g_camera_model = 0;
+ Camera_updateModelview(camwnd.getCamera());
+ Camera_updateProjection(camwnd.getCamera());
+ CamWnd_Update(camwnd);
+ }
+}
+
+inline CameraModel *Instance_getCameraModel(scene::Instance &instance)
+{
+ return InstanceTypeCast<CameraModel>::cast(instance);
+}
+
+void CamWnd_LookThroughSelected(CamWnd &camwnd)
+{
+ if (g_camera_model != 0) {
+ CamWnd_LookThroughCamera(camwnd);
+ }
+
+ if (GlobalSelectionSystem().countSelected() != 0) {
+ scene::Instance &instance = GlobalSelectionSystem().ultimateSelected();
+ CameraModel *cameraModel = Instance_getCameraModel(instance);
+ if (cameraModel != 0) {
+ CamWnd_Remove_Handlers_Move(camwnd);
+ g_camera_model = cameraModel;
+ g_camera_model->setCameraView(&camwnd.getCameraView(),
+ ReferenceCaller<CamWnd, void(), CamWnd_LookThroughCamera>(camwnd));
+ }
+ }
+}
+
+void GlobalCamera_LookThroughSelected()
+{
+ CamWnd_LookThroughSelected(*g_camwnd);
+}
+
+void GlobalCamera_LookThroughCamera()
+{
+ CamWnd_LookThroughCamera(*g_camwnd);
+}
+
+struct RenderMode {
+ static void Export(const Callback<void(int)> &returnz)
+ {
+ switch (CamWnd_GetMode()) {
+ case cd_wire:
+ returnz(0);
+ break;
+ case cd_solid:
+ returnz(1);
+ break;
+ case cd_texture:
+ returnz(2);
+ break;
+ case cd_lighting:
+ returnz(3);
+ break;
+ }
+ }
+
+ static void Import(int value)
+ {
+ switch (value) {
+ case 0:
+ CamWnd_SetMode(cd_wire);
+ break;
+ case 1:
+ CamWnd_SetMode(cd_solid);
+ break;
+ case 2:
+ CamWnd_SetMode(cd_texture);
+ break;
+ case 3:
+ CamWnd_SetMode(cd_lighting);
+ break;
+ default:
+ CamWnd_SetMode(cd_texture);
+ }
+ }
+};
+
+void Camera_constructPreferences(PreferencesPage &page)
+{
+ page.appendSlider("Movement Speed", g_camwindow_globals_private.m_nMoveSpeed, TRUE, 0, 0, 100, MIN_CAM_SPEED,
+ MAX_CAM_SPEED, 1, 10);
+ page.appendCheckBox("", "Link strafe speed to movement speed", g_camwindow_globals_private.m_bCamLinkSpeed);
+ page.appendSlider("Rotation Speed", g_camwindow_globals_private.m_nAngleSpeed, TRUE, 0, 0, 3, 1, 180, 1, 10);
+ page.appendCheckBox("", "Invert mouse vertical axis", g_camwindow_globals_private.m_bCamInverseMouse);
+ page.appendCheckBox(
+ "", "Discrete movement",
+ make_property<CamWnd_Move_Discrete>()
+ );
+ page.appendCheckBox(
+ "", "Enable far-clip plane",
+ make_property<Camera_FarClip>()
+ );
+
+ if (g_pGameDescription->mGameType == "doom3") {
+ const char *render_mode[] = {"Wireframe", "Flatshade", "Textured", "Lighting"};
+
+ page.appendCombo(
+ "Render Mode",
+ STRING_ARRAY_RANGE(render_mode),
+ make_property<RenderMode>()
+ );
+ } else {
+ const char *render_mode[] = {"Wireframe", "Flatshade", "Textured"};
+
+ page.appendCombo(
+ "Render Mode",
+ STRING_ARRAY_RANGE(render_mode),
+ make_property<RenderMode>()
+ );
+ }
+
+ const char *strafe_mode[] = {"Both", "Forward", "Up"};
+
+ page.appendCombo(
+ "Strafe Mode",
+ g_camwindow_globals_private.m_nStrafeMode,
+ STRING_ARRAY_RANGE(strafe_mode)
+ );
+}
+
+void Camera_constructPage(PreferenceGroup &group)
+{
+ PreferencesPage page(group.createPage("Camera", "Camera View Preferences"));
+ Camera_constructPreferences(page);
+}
+
+void Camera_registerPreferencesPage()
+{
+ PreferencesDialog_addSettingsPage(makeCallbackF(Camera_constructPage));
+}
+
+#include "preferencesystem.h"
+#include "stringio.h"
+#include "dialog.h"
+
+void CameraSpeed_increase()
+{
+ if (g_camwindow_globals_private.m_nMoveSpeed <= (MAX_CAM_SPEED - CAM_SPEED_STEP - 10)) {
+ g_camwindow_globals_private.m_nMoveSpeed += CAM_SPEED_STEP;
+ } else {
+ g_camwindow_globals_private.m_nMoveSpeed = MAX_CAM_SPEED - 10;
+ }
+}
+
+void CameraSpeed_decrease()
+{
+ if (g_camwindow_globals_private.m_nMoveSpeed >= (MIN_CAM_SPEED + CAM_SPEED_STEP)) {
+ g_camwindow_globals_private.m_nMoveSpeed -= CAM_SPEED_STEP;
+ } else {
+ g_camwindow_globals_private.m_nMoveSpeed = MIN_CAM_SPEED;
+ }
+}
+
+/// \brief Initialisation for things that have the same lifespan as this module.
+void CamWnd_Construct()
+{
+ GlobalCommands_insert("CenterView", makeCallbackF(GlobalCamera_ResetAngles), Accelerator(GDK_KEY_End));
+
+ GlobalToggles_insert("ToggleCubicClip", makeCallbackF(Camera_ToggleFarClip),
+ ToggleItem::AddCallbackCaller(g_getfarclip_item),
+ Accelerator('\\', (GdkModifierType) GDK_CONTROL_MASK));
+ GlobalCommands_insert("CubicClipZoomIn", makeCallbackF(Camera_CubeIn),
+ Accelerator('[', (GdkModifierType) GDK_CONTROL_MASK));
+ GlobalCommands_insert("CubicClipZoomOut", makeCallbackF(Camera_CubeOut),
+ Accelerator(']', (GdkModifierType) GDK_CONTROL_MASK));
+
+ GlobalCommands_insert("UpFloor", makeCallbackF(Camera_ChangeFloorUp), Accelerator(GDK_KEY_Prior));
+ GlobalCommands_insert("DownFloor", makeCallbackF(Camera_ChangeFloorDown), Accelerator(GDK_KEY_Next));
+
+ GlobalToggles_insert("ToggleCamera", ToggleShown::ToggleCaller(g_camera_shown),
+ ToggleItem::AddCallbackCaller(g_camera_shown.m_item),
+ Accelerator('C', (GdkModifierType) (GDK_SHIFT_MASK | GDK_CONTROL_MASK)));
+ GlobalCommands_insert("LookThroughSelected", makeCallbackF(GlobalCamera_LookThroughSelected));
+ GlobalCommands_insert("LookThroughCamera", makeCallbackF(GlobalCamera_LookThroughCamera));
+
+ if (g_pGameDescription->mGameType == "doom3") {
+ GlobalCommands_insert("TogglePreview", makeCallbackF(CamWnd_TogglePreview), Accelerator(GDK_KEY_F3));
+ }
+
+ GlobalCommands_insert("CameraSpeedInc", makeCallbackF(CameraSpeed_increase),
+ Accelerator(GDK_KEY_KP_Add, (GdkModifierType) GDK_SHIFT_MASK));
+ GlobalCommands_insert("CameraSpeedDec", makeCallbackF(CameraSpeed_decrease),
+ Accelerator(GDK_KEY_KP_Subtract, (GdkModifierType) GDK_SHIFT_MASK));
+
+ GlobalShortcuts_insert("CameraForward", Accelerator(GDK_KEY_Up));
+ GlobalShortcuts_insert("CameraBack", Accelerator(GDK_KEY_Down));
+ GlobalShortcuts_insert("CameraLeft", Accelerator(GDK_KEY_Left));
+ GlobalShortcuts_insert("CameraRight", Accelerator(GDK_KEY_Right));
+ GlobalShortcuts_insert("CameraStrafeRight", Accelerator(GDK_KEY_period));
+ GlobalShortcuts_insert("CameraStrafeLeft", Accelerator(GDK_KEY_comma));
+
+ GlobalShortcuts_insert("CameraUp", Accelerator('D'));
+ GlobalShortcuts_insert("CameraDown", Accelerator('C'));
+ GlobalShortcuts_insert("CameraAngleUp", Accelerator('A'));
+ GlobalShortcuts_insert("CameraAngleDown", Accelerator('Z'));
+
+ GlobalShortcuts_insert("CameraFreeMoveForward", Accelerator(GDK_KEY_Up));
+ GlobalShortcuts_insert("CameraFreeMoveBack", Accelerator(GDK_KEY_Down));
+ GlobalShortcuts_insert("CameraFreeMoveLeft", Accelerator(GDK_KEY_Left));
+ GlobalShortcuts_insert("CameraFreeMoveRight", Accelerator(GDK_KEY_Right));
+
+ GlobalToggles_insert("ShowStats", makeCallbackF(ShowStatsToggle), ToggleItem::AddCallbackCaller(g_show_stats));
+
+ GlobalPreferenceSystem().registerPreference("ShowStats",
+ make_property_string(g_camwindow_globals_private.m_showStats));
+ GlobalPreferenceSystem().registerPreference("MoveSpeed",
+ make_property_string(g_camwindow_globals_private.m_nMoveSpeed));
+ GlobalPreferenceSystem().registerPreference("CamLinkSpeed",
+ make_property_string(g_camwindow_globals_private.m_bCamLinkSpeed));
+ GlobalPreferenceSystem().registerPreference("AngleSpeed",
+ make_property_string(g_camwindow_globals_private.m_nAngleSpeed));
+ GlobalPreferenceSystem().registerPreference("CamInverseMouse",
+ make_property_string(g_camwindow_globals_private.m_bCamInverseMouse));
+ GlobalPreferenceSystem().registerPreference("CamDiscrete", make_property_string<CamWnd_Move_Discrete>());
+ GlobalPreferenceSystem().registerPreference("CubicClipping",
+ make_property_string(g_camwindow_globals_private.m_bCubicClipping));
+ GlobalPreferenceSystem().registerPreference("CubicScale", make_property_string(g_camwindow_globals.m_nCubicScale));
+ GlobalPreferenceSystem().registerPreference("SI_Colors4",
+ make_property_string(g_camwindow_globals.color_cameraback));
+ GlobalPreferenceSystem().registerPreference("SI_Colors12",
+ make_property_string(g_camwindow_globals.color_selbrushes3d));
+ GlobalPreferenceSystem().registerPreference("CameraRenderMode", make_property_string<RenderMode>());
+ GlobalPreferenceSystem().registerPreference("StrafeMode",
+ make_property_string(g_camwindow_globals_private.m_nStrafeMode));
+
+ CamWnd_constructStatic();
+
+ Camera_registerPreferencesPage();
+}
+
+void CamWnd_Destroy()
+{
+ CamWnd_destroyStatic();
+}
projects / xonotic / netradiant.git / blobdiff