Quake-III-Arena

CamWnd.cpp (27714B)

---

 /*
 ===========================================================================
 Copyright (C) 1999-2005 Id Software, Inc.
 
 This file is part of Quake III Arena source code.
 
 Quake III Arena source code 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.
 
 Quake III Arena source code 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 Foobar; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 // CamWnd.cpp : implementation file
 //
 
 #include "stdafx.h"
 #include "Radiant.h"
 #include "XYWnd.h"
 #include "CamWnd.h"
 #include "qe3.h"
 #include "splines/splines.h"
 
 #ifdef _DEBUG
 #define new DEBUG_NEW
 #undef THIS_FILE
 static char THIS_FILE[] = __FILE__;
 #endif
 
 extern void DrawPathLines();
 
 int g_nAngleSpeed = 300;
 int g_nMoveSpeed = 400;
 
 
 /////////////////////////////////////////////////////////////////////////////
 // CCamWnd
 IMPLEMENT_DYNCREATE(CCamWnd, CWnd);
 
 CCamWnd::CCamWnd()
 {
   m_pXYFriend = NULL;
   m_nNumTransBrushes = 0;
   memset(&m_Camera, 0, sizeof(camera_t));
   m_pSide_select = NULL;
   m_bClipMode = false;
   Cam_Init();
 }
 
 CCamWnd::~CCamWnd()
 {
 }
 
 
 BEGIN_MESSAGE_MAP(CCamWnd, CWnd)
 	//{{AFX_MSG_MAP(CCamWnd)
 	ON_WM_KEYDOWN()
 	ON_WM_PAINT()
 	ON_WM_DESTROY()
 	ON_WM_CLOSE()
 	ON_WM_MOUSEMOVE()
 	ON_WM_LBUTTONDOWN()
 	ON_WM_LBUTTONUP()
 	ON_WM_MBUTTONDOWN()
 	ON_WM_MBUTTONUP()
 	ON_WM_RBUTTONDOWN()
 	ON_WM_RBUTTONUP()
 	ON_WM_CREATE()
 	ON_WM_SIZE()
 	ON_WM_NCCALCSIZE()
 	ON_WM_KILLFOCUS()
 	ON_WM_SETFOCUS()
 	ON_WM_KEYUP()
 	//}}AFX_MSG_MAP
 END_MESSAGE_MAP()
 
 
 LONG WINAPI CamWndProc (
     HWND    hWnd,
     UINT    uMsg,
     WPARAM  wParam,
     LPARAM  lParam)
 {
     RECT	rect;
 
     GetClientRect(hWnd, &rect);
 
     switch (uMsg)
     {
 	case WM_KILLFOCUS:
 	case WM_SETFOCUS:
 		SendMessage( hWnd, WM_NCACTIVATE, uMsg == WM_SETFOCUS, 0 );
 		return 0;
 
 	case WM_NCCALCSIZE:// don't let windows copy pixels
 		DefWindowProc (hWnd, uMsg, wParam, lParam);
 		return WVR_REDRAW;
 
     }
 
 	return DefWindowProc( hWnd, uMsg, wParam, lParam );
 }
 
 
 /////////////////////////////////////////////////////////////////////////////
 // CCamWnd message handlers
 
 BOOL CCamWnd::PreCreateWindow(CREATESTRUCT& cs) 
 {
   WNDCLASS wc;
   HINSTANCE hInstance = AfxGetInstanceHandle();
   if (::GetClassInfo(hInstance, CAMERA_WINDOW_CLASS, &wc) == FALSE)
   {
     // Register a new class
   	memset (&wc, 0, sizeof(wc));
     wc.style         = CS_NOCLOSE | CS_OWNDC;
     wc.lpszClassName = CAMERA_WINDOW_CLASS;
     wc.hCursor       = LoadCursor (NULL,IDC_ARROW);
     wc.lpfnWndProc   = CamWndProc;
     if (AfxRegisterClass(&wc) == FALSE)
       Error ("CCamWnd RegisterClass: failed");
   }
 
   cs.lpszClass = CAMERA_WINDOW_CLASS;
   cs.lpszName = "CAM";
   if (cs.style != QE3_CHILDSTYLE)
     cs.style = QE3_SPLITTER_STYLE;
 
 	BOOL bResult = CWnd::PreCreateWindow(cs);
 
   // See if the class already exists and if not then we need
   // to register our new window class.
   return bResult;
 	
 }
 
 
 void CCamWnd::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
 {
   g_pParentWnd->HandleKey(nChar, nRepCnt, nFlags);
 }
 
 
 brush_t* g_pSplitList = NULL;
 
 void CCamWnd::OnPaint() 
 {
 	CPaintDC dc(this); // device context for painting
   bool bPaint = true;
   if (!qwglMakeCurrent( dc.m_hDC, g_qeglobals.d_hglrcBase ))
   {
     Sys_Printf("ERROR: wglMakeCurrent failed..\n ");
     Sys_Printf("Please restart Q3Radiant if the camera view is not working\n");
   }
   else
   {
     QE_CheckOpenGLForErrors();
     g_pSplitList = NULL;
     if (g_bClipMode)
     {
       if (g_Clip1.Set() && g_Clip2.Set())
       {
         g_pSplitList = ( (g_pParentWnd->ActiveXY()->GetViewType() == XZ) ? !g_bSwitch : g_bSwitch) ? &g_brBackSplits : &g_brFrontSplits;
       }
     }
 		Cam_Draw ();
 		QE_CheckOpenGLForErrors();
 		qwglSwapBuffers(dc.m_hDC);
   }
 }
 
 
 void CCamWnd::SetXYFriend(CXYWnd * pWnd)
 {
   m_pXYFriend = pWnd;
 }
 
 void CCamWnd::OnDestroy() 
 {
 	QEW_StopGL(GetSafeHwnd(), g_qeglobals.d_hglrcBase, g_qeglobals.d_hdcBase );
 	CWnd::OnDestroy();
 }
 
 void CCamWnd::OnClose() 
 {
 	CWnd::OnClose();
 }
 
 extern void Select_ShiftTexture(int x, int y);
 extern void Select_RotateTexture(int amt);
 extern void Select_ScaleTexture(int x, int y);
 void CCamWnd::OnMouseMove(UINT nFlags, CPoint point) 
 {
   CRect r;
   GetClientRect(r);
   if (GetCapture() == this && (GetKeyState(VK_MENU) & 0x8000) && !((GetKeyState(VK_SHIFT) & 0x8000) || (GetKeyState(VK_CONTROL) & 0x8000)))
   {
     if (GetKeyState(VK_CONTROL) & 0x8000)
       Select_RotateTexture(point.y - m_ptLastCursor.y);
     else
     if (GetKeyState(VK_SHIFT) & 0x8000)
       Select_ScaleTexture(point.x - m_ptLastCursor.x, m_ptLastCursor.y - point.y);
     else
       Select_ShiftTexture(point.x - m_ptLastCursor.x, m_ptLastCursor.y - point.y);
   }
   else
   {
     Cam_MouseMoved(point.x, r.bottom - 1 - point.y, nFlags);
   }
   m_ptLastCursor = point;
 }
 
 void CCamWnd::OnLButtonDown(UINT nFlags, CPoint point) 
 {
   m_ptLastCursor = point;
   OriginalMouseDown(nFlags, point);
 }
 
 void CCamWnd::OnLButtonUp(UINT nFlags, CPoint point) 
 {
   OriginalMouseUp(nFlags, point);
 }
 
 void CCamWnd::OnMButtonDown(UINT nFlags, CPoint point) 
 {
   OriginalMouseDown(nFlags, point);
 }
 
 void CCamWnd::OnMButtonUp(UINT nFlags, CPoint point) 
 {
   OriginalMouseUp(nFlags, point);
 }
 
 void CCamWnd::OnRButtonDown(UINT nFlags, CPoint point) 
 {
   OriginalMouseDown(nFlags, point);
 }
 
 void CCamWnd::OnRButtonUp(UINT nFlags, CPoint point) 
 {
   OriginalMouseUp(nFlags, point);
 }
 
 int CCamWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) 
 {
   if (CWnd::OnCreate(lpCreateStruct) == -1)
 		return -1;
 
 	g_qeglobals.d_hdcBase = GetDC()->m_hDC;
 	QEW_SetupPixelFormat(g_qeglobals.d_hdcBase, true);
 
   if ((g_qeglobals.d_hglrcBase = qwglCreateContext(g_qeglobals.d_hdcBase)) == 0)
 	  Error("wglCreateContext failed");
   
   if (!qwglMakeCurrent(g_qeglobals.d_hdcBase, g_qeglobals.d_hglrcBase))
 	  Error ("wglMakeCurrent failed");
 
 
 	//
 	// create GL font
 	//
   HFONT hfont = ::CreateFont(
 	  12,	// logical height of font 
 		 6,	// logical average character width 
 		 0,	// angle of escapement 
 		 0,	// base-line orientation angle 
 		 0,	// font weight 
 		 0,	// italic attribute flag 
 		 0,	// underline attribute flag 
 		 0,	// strikeout attribute flag 
 		 0,	// character set identifier 
 		 0,	// output precision 
 		 0,	// clipping precision 
 		 0,	// output quality 
 		 0,	// pitch and family 
 		 "system font" // pointer to typeface name string 
 		 	);
 
 	if (!hfont)
 	  Error( "couldn't create font" );
 
   ::SelectObject(g_qeglobals.d_hdcBase, hfont);
 
 	if ((g_qeglobals.d_font_list = qglGenLists (256)) == 0)
 	  Error( "couldn't create font dlists" );
 			
 	// create the bitmap display lists
 	// we're making images of glyphs 0 thru 255
   
   if (g_PrefsDlg.m_bBuggyICD)
   {
 	  if ( !qwglUseFontBitmaps (g_qeglobals.d_hdcBase, 1, 255, g_qeglobals.d_font_list-1) )
 	    Error( "wglUseFontBitmaps faileD" );
   }
   else
   {
 	  if ( !qwglUseFontBitmaps (g_qeglobals.d_hdcBase, 1, 255, g_qeglobals.d_font_list) )
 	    Error( "wglUseFontBitmaps faileD" );
   }
 	
 	// indicate start of glyph display lists
 	qglListBase (g_qeglobals.d_font_list);
 
 	// report OpenGL information
 	Sys_Printf ("GL_VENDOR: %s\n", qglGetString (GL_VENDOR));
 	Sys_Printf ("GL_RENDERER: %s\n", qglGetString (GL_RENDERER));
 	Sys_Printf ("GL_VERSION: %s\n", qglGetString (GL_VERSION));
 	Sys_Printf ("GL_EXTENSIONS: %s\n", qglGetString (GL_EXTENSIONS));
 
   g_qeglobals.d_hwndCamera = GetSafeHwnd();
 
 	return 0;
 }
 
 void CCamWnd::OriginalMouseUp(UINT nFlags, CPoint point)
 {
   CRect r;
   GetClientRect(r);
   Cam_MouseUp(point.x, r.bottom - 1 - point.y, nFlags);
 	if (!(nFlags & (MK_LBUTTON|MK_RBUTTON|MK_MBUTTON)))
   	ReleaseCapture ();
 }
 
 void CCamWnd::OriginalMouseDown(UINT nFlags, CPoint point)
 {
   //if (GetTopWindow()->GetSafeHwnd() != GetSafeHwnd())
   //  BringWindowToTop();
   CRect r;
   GetClientRect(r);
   SetFocus();
 	SetCapture();
   //if (!(GetKeyState(VK_MENU) & 0x8000))
 	  Cam_MouseDown (point.x, r.bottom - 1 - point.y, nFlags);
 }
 
 void CCamWnd::Cam_Init()
 {
 	//m_Camera.draw_mode = cd_texture;
 	m_Camera.timing = false;
 	m_Camera.origin[0] = 0;
 	m_Camera.origin[1] = 20;
 	m_Camera.origin[2] = 46;
 	m_Camera.color[0] = 0.3;
 	m_Camera.color[1] = 0.3;
 	m_Camera.color[2] = 0.3;
 }
 
 void CCamWnd::Cam_BuildMatrix()
 {
 	float	xa, ya;
 	float	matrix[4][4];
 	int		i;
 
 	xa = m_Camera.angles[0]/180*Q_PI;
 	ya = m_Camera.angles[1]/180*Q_PI;
 
 	// the movement matrix is kept 2d
 
   m_Camera.forward[0] = cos(ya);
   m_Camera.forward[1] = sin(ya);
   m_Camera.right[0] = m_Camera.forward[1];
   m_Camera.right[1] = -m_Camera.forward[0];
 
 	qglGetFloatv (GL_PROJECTION_MATRIX, &matrix[0][0]);
 
 	for (i=0 ; i<3 ; i++)
 	{
 		m_Camera.vright[i] = matrix[i][0];
 		m_Camera.vup[i] = matrix[i][1];
 		m_Camera.vpn[i] = matrix[i][2];
 	}
 
 	VectorNormalize (m_Camera.vright);
 	VectorNormalize (m_Camera.vup);
 	VectorNormalize (m_Camera.vpn);
 }
 
 
 
 void CCamWnd::Cam_ChangeFloor (qboolean up)
 {
 	brush_t	*b;
 	float	d, bestd, current;
 	vec3_t	start, dir;
 
 	start[0] = m_Camera.origin[0];
 	start[1] = m_Camera.origin[1];
 	start[2] = 8192;
 	dir[0] = dir[1] = 0;
 	dir[2] = -1;
 
 	current = 8192 - (m_Camera.origin[2] - 48);
 	if (up)
 		bestd = 0;
 	else
 		bestd = 16384;
 
 	for (b=active_brushes.next ; b != &active_brushes ; b=b->next)
 	{
 		if ( b->pTerrain && !Terrain_Ray( start, dir, b, &d ) )
 			continue;
 		if ( !b->pTerrain && !Brush_Ray (start, dir, b, &d) )
 			continue;
 		if (up && d < current && d > bestd)
 			bestd = d;
 		if (!up && d > current && d < bestd)
 			bestd = d;
 	}
 
 	if (bestd == 0 || bestd == 16384)
 		return;
 
 	m_Camera.origin[2] += current - bestd;
 	Sys_UpdateWindows (W_CAMERA|W_Z_OVERLAY);
 }
 
 
 void CCamWnd::Cam_PositionDrag()
 {
 	int	x, y;
 	Sys_GetCursorPos (&x, &y);
 	if (x != m_ptCursor.x || y != m_ptCursor.y)
 	{
 		x -= m_ptCursor.x;
 		VectorMA (m_Camera.origin, x, m_Camera.vright, m_Camera.origin);
 		y -= m_ptCursor.y;
 		m_Camera.origin[2] -= y;
     SetCursorPos(m_ptCursor.x, m_ptCursor.y);
 		Sys_UpdateWindows (W_CAMERA | W_XY_OVERLAY);
 	}
 }
 
 
 void CCamWnd::Cam_MouseControl (float dtime)
 {
 	int		xl, xh;
 	int		yl, yh;
 	float	xf, yf;
   if (g_PrefsDlg.m_nMouseButtons == 2)
   {
     if (m_nCambuttonstate != (MK_RBUTTON | MK_SHIFT))
       return;
   }
   else
   {
 	  if (m_nCambuttonstate != MK_RBUTTON)
       return;
   }
 
 	xf = (float)(m_ptButton.x - m_Camera.width/2) / (m_Camera.width/2);
 	yf = (float)(m_ptButton.y - m_Camera.height/2) / (m_Camera.height/2);
 
 
 	xl = m_Camera.width/3;
 	xh = xl*2;
 	yl = m_Camera.height/3;
 	yh = yl*2;
 
   //Sys_Printf("xf-%f  yf-%f  xl-%i  xh-i%  yl-i%  yh-i%\n",xf,yf,xl,xh,yl,yh);
 #if 0
 	// strafe
 	if (buttony < yl && (buttonx < xl || buttonx > xh))
 		VectorMA (camera.origin, xf*dtime*g_nMoveSpeed, camera.right, camera.origin);
 	else
 #endif
 	{
 		xf *= 1.0 - fabs(yf);
 		if (xf < 0)
 		{
 			xf += 0.1;
 			if (xf > 0)
 				xf = 0;
 		}
 		else
 		{
 			xf -= 0.1;
 			if (xf < 0)
 				xf = 0;
 		}
 		
 		VectorMA (m_Camera.origin, yf*dtime*g_nMoveSpeed, m_Camera.forward, m_Camera.origin);
 		m_Camera.angles[YAW] += xf*-dtime*g_nAngleSpeed;
 	}
 
 #if 0
   if (g_PrefsDlg.m_bQE4Painting)
   {
     MSG msg;
     if (::PeekMessage( &msg, NULL, 0, 0, PM_REMOVE )) 
     { 
       TranslateMessage(&msg);
       DispatchMessage(&msg);
     }
   }
 #endif
 
   int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY) : (W_CAMERA);
 	Sys_UpdateWindows (nUpdate);
   g_pParentWnd->PostMessage(WM_TIMER, 0, 0);
 
 }
 
 
 
 void CCamWnd::Cam_MouseDown(int x, int y, int buttons)
 {
 	vec3_t		dir;
 	float		f, r, u;
 	int			i;
 
 	//
 	// calc ray direction
 	//
 	u = (float)(y - m_Camera.height/2) / (m_Camera.width/2);
 	r = (float)(x - m_Camera.width/2) / (m_Camera.width/2);
 	f = 1;
 
 	for (i=0 ; i<3 ; i++)
 		dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;
 	VectorNormalize (dir);
 
 	GetCursorPos(&m_ptCursor);
 
 	m_nCambuttonstate = buttons;
 	m_ptButton.x = x;
 	m_ptButton.y = y;
 
 	// LBUTTON = manipulate selection
 	// shift-LBUTTON = select
 	// middle button = grab texture
 	// ctrl-middle button = set entire brush to texture
 	// ctrl-shift-middle button = set single face to texture
 	int nMouseButton = g_PrefsDlg.m_nMouseButtons == 2 ? MK_RBUTTON : MK_MBUTTON;
 	if ((buttons == MK_LBUTTON)
 		        || (buttons == (MK_LBUTTON | MK_SHIFT))
 		        || (buttons == (MK_LBUTTON | MK_CONTROL))
 		        || (buttons == (MK_LBUTTON | MK_CONTROL | MK_SHIFT))
 		        || (buttons == nMouseButton)
 		        || (buttons == (nMouseButton|MK_SHIFT))
 		        || (buttons == (nMouseButton|MK_CONTROL))
 		        || (buttons == (nMouseButton|MK_SHIFT|MK_CONTROL)))
 	{
 
     if (g_PrefsDlg.m_nMouseButtons == 2 && (buttons == (MK_RBUTTON | MK_SHIFT)))
 		  Cam_MouseControl (0.1);
     else
     {
       // something global needs to track which window is responsible for stuff
       Patch_SetView(W_CAMERA);
 		  Drag_Begin (x, y, buttons, m_Camera.vright, m_Camera.vup,	m_Camera.origin, dir);
     }
     return;
 	}
 
 	if (buttons == MK_RBUTTON)
 	{
 		Cam_MouseControl (0.1);
 		return;
 	}
 }
 
 
 void CCamWnd::Cam_MouseUp (int x, int y, int buttons)
 {
 	m_nCambuttonstate = 0;
 	Drag_MouseUp (buttons);
 }
 
 
 void CCamWnd::Cam_MouseMoved (int x, int y, int buttons)
 {
 	m_nCambuttonstate = buttons;
 	if (!buttons) {
 		if ( ( g_qeglobals.d_select_mode == sel_terrainpoint ) || ( g_qeglobals.d_select_mode == sel_terraintexture ) ) {
 			vec3_t		dir;
 			float		f, r, u;
 			int			i;
 
 			//
 			// calc ray direction
 			//
 			u = (float)(y - m_Camera.height/2) / (m_Camera.width/2);
 			r = (float)(x - m_Camera.width/2) / (m_Camera.width/2);
 			f = 1;
 
 			for (i=0 ; i<3 ; i++)
 				dir[i] = m_Camera.vpn[i] * f + m_Camera.vright[i] * r + m_Camera.vup[i] * u;
 			VectorNormalize (dir);
 
 			m_ptButton.x = x;
 			m_ptButton.y = y;
 
 			Terrain_SelectPointByRay( m_Camera.origin, dir, buttons );
 
 			Sys_UpdateWindows(W_CAMERA);
 		}
 
 		return;
 	}
 	m_ptButton.x = x;
 	m_ptButton.y = y;
 
 	if (buttons == (MK_RBUTTON|MK_CONTROL) )
 	{
 		Cam_PositionDrag ();
 		Sys_UpdateWindows (W_XY|W_CAMERA|W_Z);
 		return;
 	}
 
 	GetCursorPos(&m_ptCursor);
 
 	if (buttons & (MK_LBUTTON | MK_MBUTTON) )
 	{
 		Drag_MouseMoved (x, y, buttons);
 		Sys_UpdateWindows (W_XY|W_CAMERA|W_Z);
 	}
 }
 
 
 void CCamWnd::InitCull()
 {
 	int		i;
 
 	VectorSubtract (m_Camera.vpn, m_Camera.vright, m_vCull1);
 	VectorAdd (m_Camera.vpn, m_Camera.vright, m_vCull2);
 
 	for (i=0 ; i<3 ; i++)
 	{
 		if (m_vCull1[i] > 0)
 			m_nCullv1[i] = 3+i;
 		else
 			m_nCullv1[i] = i;
 		if (m_vCull2[i] > 0)
 			m_nCullv2[i] = 3+i;
 		else
 			m_nCullv2[i] = i;
 	}
 }
 
 qboolean CCamWnd::CullBrush (brush_t *b)
 {
 	int		i;
 	vec3_t	point;
 	float	d;
 
 	if (g_PrefsDlg.m_bCubicClipping)
 	{
 		float fLevel = g_PrefsDlg.m_nCubicScale * 64;
 
 		point[0] = m_Camera.origin[0] - fLevel;
 		point[1] = m_Camera.origin[1] - fLevel;
 		point[2] = m_Camera.origin[2] - fLevel;
 
 		for (i=0; i<3; i++)
 			if (b->mins[i] < point[i] && b->maxs[i] < point[i])
 				return true;
 
 		point[0] = m_Camera.origin[0] + fLevel;
 		point[1] = m_Camera.origin[1] + fLevel;
 		point[2] = m_Camera.origin[2] + fLevel;
 	
 		for (i=0; i<3; i++)
 			if (b->mins[i] > point[i] && b->maxs[i] > point[i])
 				return true;
 	}
 
 
 	for (i=0 ; i<3 ; i++)
 		point[i] = b->mins[m_nCullv1[i]] - m_Camera.origin[i];
 
 	d = DotProduct (point, m_vCull1);
 	if (d < -1)
 		return true;
 
 	for (i=0 ; i<3 ; i++)
 		point[i] = b->mins[m_nCullv2[i]] - m_Camera.origin[i];
 
 	d = DotProduct (point, m_vCull2);
 	if (d < -1)
 		return true;
 
 	return false;
 }
 
 #if 0
 void CCamWnd::DrawLightRadius(brush_t* pBrush)
 {
   // if lighting
   int nRadius = Brush_LightRadius(pBrush);
   if (nRadius > 0)
   {
     Brush_SetLightColor(pBrush);
 	  qglEnable (GL_BLEND);
 	  qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
 	  qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	  qglDisable (GL_TEXTURE_2D);
 
     qglEnable(GL_TEXTURE_2D);
     qglDisable(GL_BLEND);
     qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
   }
 }
 #endif
 
 /*
 ==============
 Cam_Draw
 ==============
 */
 
 void CCamWnd::Cam_Draw()
 {
 	brush_t	*brush;
 	face_t	*face;
 	float	screenaspect;
 	float	yfov;
 	double	start, end;
 	int		i;
 
 	/*
   FILE *f = fopen("g:/nardo/raduffy/editorhack.dat", "w");
   if (f != NULL) {
     fwrite(&m_Camera.origin[0], sizeof(float), 1, f);
     fwrite(&m_Camera.origin[1], sizeof(float), 1, f);
     fwrite(&m_Camera.origin[2], sizeof(float), 1, f);
 		fwrite(&m_Camera.angles[PITCH], sizeof(float), 1, f);
 		fwrite(&m_Camera.angles[YAW], sizeof(float), 1, f);
     fclose(f);
   }
 	*/
 	
 	if (!active_brushes.next)
 		return;	// not valid yet
 	
 	if (m_Camera.timing)
 		start = Sys_DoubleTime ();
 	
 	//
 	// clear
 	//
 	QE_CheckOpenGLForErrors();
 	
 	qglViewport(0, 0, m_Camera.width, m_Camera.height);
 	qglScissor(0, 0, m_Camera.width, m_Camera.height);
 	qglClearColor (g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][0],
 		g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][1],
 		g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][2], 0);
 	qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 	
 	//
 	// set up viewpoint
 	//
 	vec5_t lightPos;
 	
 	if (g_PrefsDlg.m_bGLLighting)
 	{
 		qglEnable(GL_LIGHTING);
 		//qglEnable(GL_LIGHT0);
 		
 		lightPos[0] = lightPos[1] = lightPos[2] = 3.5;
 		lightPos[3] = 1.0;
 		qglLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightPos);
 		//qglLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
 		//lightPos[0] = lightPos[1] = lightPos[2] = 3.5;
     //qglLightfv(GL_LIGHT0, GL_AMBIENT, lightPos);
 	}
 	else
 	{
 		qglDisable(GL_LIGHTING);
 	}
 	
 	qglMatrixMode(GL_PROJECTION);
 	qglLoadIdentity ();
 	
 	screenaspect = (float)m_Camera.width / m_Camera.height;
 	yfov = 2*atan((float)m_Camera.height / m_Camera.width)*180/Q_PI;
 	qgluPerspective (yfov,  screenaspect,  2,  8192);
 	
 	qglRotatef (-90,  1, 0, 0);	    // put Z going up
 	qglRotatef (90,  0, 0, 1);	    // put Z going up
 	qglRotatef (m_Camera.angles[0],  0, 1, 0);
 	qglRotatef (-m_Camera.angles[1],  0, 0, 1);
 	qglTranslatef (-m_Camera.origin[0],  -m_Camera.origin[1],  -m_Camera.origin[2]);
 	
 	Cam_BuildMatrix ();
 	
 	
 	//if (m_Camera.draw_mode == cd_light)
 	//{
 //	if (g_PrefsDlg.m_bGLLighting)
 //	{
 //		VectorCopy(m_Camera.origin, lightPos);
 //		lightPos[3] = 1;
 //		qglLightfv(GL_LIGHT0, GL_POSITION, lightPos);
 //	}
 	//}
 	
 	InitCull ();
 	
 	//
 	// draw stuff
 	//
 	GLfloat lAmbient[] = {1.0, 1.0, 1.0, 1.0};
 	
 	switch (m_Camera.draw_mode)
 	{
 	case cd_wire:
 		qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
 		qglDisable(GL_TEXTURE_2D);
 		qglDisable(GL_TEXTURE_1D);
 		qglDisable(GL_BLEND);
 		qglDisable(GL_DEPTH_TEST);
 		qglColor3f(1.0, 1.0, 1.0);
 		//		qglEnable (GL_LINE_SMOOTH);
 		break;
 		
 	case cd_solid:
 		qglCullFace(GL_FRONT);
 		qglEnable(GL_CULL_FACE);
 		qglShadeModel (GL_FLAT);
 		qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
 		qglDisable(GL_TEXTURE_2D);
 		qglDisable(GL_BLEND);
 		qglEnable(GL_DEPTH_TEST);
 		qglDepthFunc (GL_LEQUAL);
 		break;
 		
 	case cd_texture:
 		qglCullFace(GL_FRONT);
 		qglEnable(GL_CULL_FACE);
 		qglShadeModel (GL_FLAT);
 		qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
 		qglEnable(GL_TEXTURE_2D);
 		qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 		qglDisable(GL_BLEND);
 		qglEnable(GL_DEPTH_TEST);
 		qglDepthFunc (GL_LEQUAL);
 		break;
 		
 	case cd_blend:
 		qglCullFace(GL_FRONT);
 		qglEnable(GL_CULL_FACE);
 		qglShadeModel (GL_FLAT);
 		qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
 		qglEnable(GL_TEXTURE_2D);
 		qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 		qglDisable(GL_DEPTH_TEST);
 		qglEnable (GL_BLEND);
 		qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 		break;
 	}
 	
 	qglMatrixMode(GL_TEXTURE);
 	
 	m_nNumTransBrushes = 0;
 	
 	for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next)
 	{
 		//DrawLightRadius(brush);
 		
 		if (CullBrush (brush))
 			continue;
 		
 		if (FilterBrush (brush))
 			continue;
 		
 		if ((brush->brush_faces->texdef.flags & (SURF_TRANS33 | SURF_TRANS66)) || (brush->brush_faces->d_texture->bFromShader && brush->brush_faces->d_texture->fTrans != 1.0))
 		{
 			m_TransBrushes [ m_nNumTransBrushes++ ] = brush;
 		} 
 		else 
 		{
 			//--      if (brush->patchBrush)
 			//--			  m_TransBrushes [ m_nNumTransBrushes++ ] = brush;
 			//--      else
 			Brush_Draw(brush);
 		}
 		
 		
 	}
 	
 	if (g_PrefsDlg.m_bGLLighting)
 	{
 		qglDisable (GL_LIGHTING);
 	}
 	
 	//
 	//qglDepthMask ( 0 ); // Don't write to depth buffer
 	qglEnable ( GL_BLEND );
 	qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	for ( i = 0; i < m_nNumTransBrushes; i++ ) 
 		Brush_Draw (m_TransBrushes[i]);
 	
 	//qglDepthMask ( 1 ); // Ok, write now
 	
 	qglMatrixMode(GL_PROJECTION);
 	
 	//
 	// now draw selected brushes
 	//
 	
 	if (g_PrefsDlg.m_bGLLighting)
 	{
 		qglEnable (GL_LIGHTING);
 	}
 	
 	qglTranslatef (g_qeglobals.d_select_translate[0], g_qeglobals.d_select_translate[1], g_qeglobals.d_select_translate[2]);
 	qglMatrixMode(GL_TEXTURE);
 	
 	brush_t* pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;
 	// draw normally
 	for (brush = pList->next ; brush != pList ; brush=brush->next)
 	{
 		//DrawLightRadius(brush);
 		//if (brush->patchBrush && g_qeglobals.d_select_mode == sel_curvepoint)
 		//  continue;
 		
 		Brush_Draw(brush);
 	}
 	
 	// blend on top
 	qglMatrixMode(GL_PROJECTION);
 	
 	
 	qglDisable (GL_LIGHTING);
 	qglColor4f(1.0, 0.0, 0.0, 0.3);
 	qglEnable (GL_BLEND);
 	qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
 	qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	qglDisable (GL_TEXTURE_2D);
 	for (brush = pList->next ; brush != pList ; brush=brush->next)
 	{
 		if ( (brush->patchBrush && g_qeglobals.d_select_mode == sel_curvepoint) || 
 			(brush->terrainBrush && g_qeglobals.d_select_mode == sel_terrainpoint) )
 			continue;
 		
 		for (face=brush->brush_faces ; face ; face=face->next)
 			Face_Draw( face );
 	}
 	
  
   int nCount = g_ptrSelectedFaces.GetSize();
 	if (nCount > 0)
   {
     for (int i = 0; i < nCount; i++)
     {
       face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));
 		  Face_Draw(selFace);
     }
   }
 		
 	// non-zbuffered outline
 	
 	qglDisable (GL_BLEND);
 	qglDisable (GL_DEPTH_TEST);
 	qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
 	qglColor3f (1, 1, 1);
 	for (brush = pList->next ; brush != pList ; brush=brush->next)
 	{
 		if (g_qeglobals.dontDrawSelectedOutlines || (brush->patchBrush && g_qeglobals.d_select_mode == sel_curvepoint) ||
 			(brush->terrainBrush && g_qeglobals.d_select_mode == sel_terrainpoint))
 			continue;
 		
 		for (face=brush->brush_faces ; face ; face=face->next)
 			Face_Draw( face );
 	}
 	
 	
 	// edge / vertex flags
 	
 	if (g_qeglobals.d_select_mode == sel_vertex)
 	{
 		qglPointSize (4);
 		qglColor3f (0,1,0);
 		qglBegin (GL_POINTS);
 		for (i=0 ; i<g_qeglobals.d_numpoints ; i++)
 			qglVertex3fv (g_qeglobals.d_points[i]);
 		qglEnd ();
 		qglPointSize (1);
 	}
 	else if (g_qeglobals.d_select_mode == sel_edge)
 	{
 		float	*v1, *v2;
 		
 		qglPointSize (4);
 		qglColor3f (0,0,1);
 		qglBegin (GL_POINTS);
 		for (i=0 ; i<g_qeglobals.d_numedges ; i++)
 		{
 			v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1];
 			v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2];
 			qglVertex3f ( (v1[0]+v2[0])*0.5,(v1[1]+v2[1])*0.5,(v1[2]+v2[2])*0.5);
 		}
 		qglEnd ();
 		qglPointSize (1);
 	}
 	
 	
 	g_splineList->draw(static_cast<qboolean>(g_qeglobals.d_select_mode == sel_addpoint || g_qeglobals.d_select_mode == sel_editpoint));
 	if (g_qeglobals.selectObject && (g_qeglobals.d_select_mode == sel_addpoint || g_qeglobals.d_select_mode == sel_editpoint)) {
 		g_qeglobals.selectObject->drawSelection();
 	}
 
 	//
 	// draw pointfile
 	//
 
 	qglEnable(GL_DEPTH_TEST);
 	
 
 	DrawPathLines ();
 	
 	
 	
 	if (g_qeglobals.d_pointfile_display_list)
 	{
 		Pointfile_Draw();
 		//		glCallList (g_qeglobals.d_pointfile_display_list);
 	}
 	
 	// bind back to the default texture so that we don't have problems
 	// elsewhere using/modifying texture maps between contexts
 	qglBindTexture( GL_TEXTURE_2D, 0 );
 	
 #if 0
 	// area selection hack
 	if (g_qeglobals.d_select_mode == sel_area)
 	{
 		qglEnable (GL_BLEND);
 		qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 		qglColor4f(0.0, 0.0, 1.0, 0.25);
 		qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
 		qglRectfv(g_qeglobals.d_vAreaTL, g_qeglobals.d_vAreaBR);
 		qglDisable (GL_BLEND);
 	}
 #endif
 	
 	qglFinish();
 	QE_CheckOpenGLForErrors();
 	//	Sys_EndWait();
 	if (m_Camera.timing)
 	{
 		end = Sys_DoubleTime ();
 		Sys_Printf ("Camera: %i ms\n", (int)(1000*(end-start)));
 	}
 }
 
 
 void CCamWnd::OnSize(UINT nType, int cx, int cy) 
 {
 	CWnd::OnSize(nType, cx, cy);
   CRect rect;
   GetClientRect(rect);
 	m_Camera.width = rect.right;
 	m_Camera.height = rect.bottom;
 	InvalidateRect(NULL, false);
 }
 
 void CCamWnd::BenchMark()
 {
 	PAINTSTRUCT	ps;
   CRect rct;
   GetWindowRect(rct);
   long lStyle = ::GetWindowLong(GetSafeHwnd(), GWL_STYLE);
   ::SetWindowLong(GetSafeHwnd(), GWL_STYLE, QE3_CHILDSTYLE);
   CWnd* pParent = GetParent();
   SetParent(g_pParentWnd);
   MoveWindow(CRect(30, 30, 400, 400), TRUE);
 
   BeginPaint(&ps);
   if (!qwglMakeCurrent(ps.hdc, g_qeglobals.d_hglrcBase))
 		Error ("wglMakeCurrent failed in Benchmark");
   
 	qglDrawBuffer (GL_FRONT);
 	double dStart = Sys_DoubleTime ();
 	for (int i=0 ; i < 100 ; i++)
 	{
 		m_Camera.angles[YAW] = i*4;
 		Cam_Draw();
 	}
 	qwglSwapBuffers(ps.hdc);
 	qglDrawBuffer (GL_BACK);
 	double dEnd = Sys_DoubleTime ();
 	EndPaint(&ps);
 	Sys_Printf ("%5.2f seconds\n", dEnd - dStart);
   ::SetWindowLong(GetSafeHwnd(), GWL_STYLE, lStyle);
   SetParent(pParent);
   MoveWindow(rct, TRUE);
 }
 
 void CCamWnd::ReInitGL()
 {
 
   qwglMakeCurrent(0,0);
 	QEW_SetupPixelFormat(GetDC()->m_hDC, true);
   if (!qwglMakeCurrent(g_qeglobals.d_hdcBase, g_qeglobals.d_hglrcBase))
 	  Error ("wglMakeCurrent failed");
 
   return;
 
   long lStyle = ::GetWindowLong(GetSafeHwnd(), GWL_STYLE);
   int nID = ::GetWindowLong(GetSafeHwnd(), GWL_ID);
   CWnd* pParent = GetParent();
   CRect rctClient;
   GetClientRect(rctClient);
   DestroyWindow();
   Create(CAMERA_WINDOW_CLASS, "", lStyle, rctClient, pParent, nID);
 }
 
 void CCamWnd::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) 
 {
   g_pParentWnd->HandleKey(nChar, nRepCnt, nFlags, false);
 }
 
 // Timo
 // brush primitive texture shifting, using camera view to select translations :
 void CCamWnd::ShiftTexture_BrushPrimit(face_t *f, int x, int y)
 {
 	vec3_t texS,texT;
 	vec3_t viewX,viewY;
 	int XS,XT,YS,YT;
 	int outS,outT;
 #ifdef _DEBUG
 	if (!g_qeglobals.m_bBrushPrimitMode)
 	{
 		Sys_Printf("Warning : unexpected call to CCamWnd::ShiftTexture_BrushPrimit with brush primitive mode disbaled\n");
 		return;
 	}
 #endif
 	// compute face axis base
 	ComputeAxisBase( f->plane.normal, texS, texT );
 	// compute camera view vectors
 	VectorCopy( m_Camera.vup, viewY );
 	VectorCopy( m_Camera.vright, viewX );
 	// compute best vectors
 	ComputeBest2DVector( viewX, texS, texT, XS, XT );
 	ComputeBest2DVector( viewY, texS, texT, YS, YT );
 	// check this is not a degenerate case
 	if ( ( XS == YS ) && ( XT == YT ) )
 	{
 #ifdef _DEBUG
 		Sys_Printf("Warning : degenerate best vectors axis base in CCamWnd::ShiftTexture_BrushPrimit\n");
 #endif
 		// forget it
 		Select_ShiftTexture_BrushPrimit( f, x, y );
 		return;
 	}
 	// compute best fitted translation in face axis base
 	outS = XS*x + YS*y;
 	outT = XT*x + YT*y;
 	// call actual texture shifting code
 	Select_ShiftTexture_BrushPrimit( f, outS, outT );
 }