dhewm3/neo/tools/radiant/CamWnd.cpp

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 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 3 of the License, or
(at your option) any later version.

Doom 3 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 Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "../../idlib/precompiled.h"
#pragma hdrstop

#include "qe3.h"
#include "Radiant.h"
#include "XYWnd.h"
#include "CamWnd.h"
#include "splines.h"
#include <GL/glu.h>

#include "../../renderer/tr_local.h"
#include "../../renderer/model_local.h"	// for idRenderModelMD5

#ifdef _DEBUG
	#define new DEBUG_NEW
	#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
extern void DrawPathLines();

int g_axialAnchor = -1;
int g_axialDest = -1;
bool g_bAxialMode = false;

void ValidateAxialPoints() {
	int faceCount = g_ptrSelectedFaces.GetSize();
	if (faceCount > 0) {
		face_t	*selFace = reinterpret_cast < face_t * > (g_ptrSelectedFaces.GetAt(0));
		if (g_axialAnchor >= selFace->face_winding->GetNumPoints()) {
			g_axialAnchor = 0;
		}
		if (g_axialDest >= selFace->face_winding->GetNumPoints()) {
			g_axialDest = 0;
		}
	} else {
		g_axialDest = 0;
		g_axialAnchor = 0;
	}
}

// CCamWnd
IMPLEMENT_DYNCREATE(CCamWnd, CWnd);

/*
 =======================================================================================================================
 =======================================================================================================================
 */
CCamWnd::CCamWnd() {
	m_pXYFriend = NULL;
	memset(&m_Camera, 0, sizeof(camera_t));
	m_pSide_select = NULL;
	m_bClipMode = false;
	worldDirty = true;
	worldModel = NULL;
	renderMode = false;
	rebuildMode = false;
	entityMode = false;
	animationMode = false;
	selectMode = false;
	soundMode = false;
	saveValid = 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_KEYUP()
	ON_WM_NCCALCSIZE()
	ON_WM_KILLFOCUS()
	ON_WM_SETFOCUS()
	ON_WM_TIMER()
	//}}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.style = CS_NOCLOSE;
		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, win32.hGLRC)) {
		common->Printf("ERROR: wglMakeCurrent failed..\n ");
		common->Printf("Please restart " EDITOR_WINDOWTEXT " 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() {
	CWnd::OnDestroy();
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
void CCamWnd::OnClose() {
	CWnd::OnClose();
}

extern void Select_RotateTexture(float amt, bool absolute);

/*
 =======================================================================================================================
 =======================================================================================================================
 */
void CCamWnd::OnMouseMove(UINT nFlags, CPoint point) {
	CRect	r;
	GetClientRect(r);
	if	(GetCapture() == this && (GetAsyncKeyState(VK_MENU) & 0x8000) && !((GetAsyncKeyState(VK_SHIFT) & 0x8000) || (GetAsyncKeyState(VK_CONTROL) & 0x8000))) {
		if (GetAsyncKeyState(VK_CONTROL) & 0x8000) {
			Select_RotateTexture((float)point.y - m_ptLastCursor.y);
		}
		else if (GetAsyncKeyState(VK_SHIFT) & 0x8000) {
			Select_ScaleTexture((float)point.x - m_ptLastCursor.x, (float)m_ptLastCursor.y - point.y);
		}
		else {
			Select_ShiftTexture((float)point.x - m_ptLastCursor.x, (float)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;
	}

	CDC *pDC = GetDC();
	HDC hDC = pDC->GetSafeHdc();

	QEW_SetupPixelFormat(hDC, true);

	HFONT hfont = CreateFont(
				12,	// logical height of font 
				0,	// 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 
				FIXED_PITCH | FF_MODERN,	// pitch and family 
				"Lucida Console" 	// pointer to typeface name string 
				);

	if (!hfont) {
		Error("couldn't create font");
	}

	HFONT hOldFont = (HFONT)SelectObject(hDC, hfont);

	wglMakeCurrent (hDC, win32.hGLRC);

	if ((g_qeglobals.d_font_list = qglGenLists(256)) == 0) {
		common->Warning( "couldn't create font dlists" );
	}

	// create the bitmap display lists we're making images of glyphs 0 thru 255
	if ( !qwglUseFontBitmaps(hDC, 0, 255, g_qeglobals.d_font_list) ) {
		common->Warning( "wglUseFontBitmaps failed (%d).  Trying again.", GetLastError() );

		// FIXME: This is really wacky, sometimes the first call fails, but calling it again makes it work
		//		This probably indicates there's something wrong somewhere else in the code, but I'm not sure what
		if ( !qwglUseFontBitmaps(hDC, 0, 255, g_qeglobals.d_font_list) ) {
			common->Warning( "wglUseFontBitmaps failed again (%d).  Trying outlines.", GetLastError() );

			if (!qwglUseFontOutlines(hDC, 0, 255, g_qeglobals.d_font_list, 0.0f, 0.1f, WGL_FONT_LINES, NULL)) {
				common->Warning( "wglUseFontOutlines also failed (%d), no coordinate text will be visible.", GetLastError() );
			}
		}
	}

	SelectObject(hDC, hOldFont);
	ReleaseDC(pDC);

	// indicate start of glyph display lists
	qglListBase(g_qeglobals.d_font_list);

	// report OpenGL information
	common->Printf("GL_VENDOR: %s\n", qglGetString(GL_VENDOR));
	common->Printf("GL_RENDERER: %s\n", qglGetString(GL_RENDERER));
	common->Printf("GL_VERSION: %s\n", qglGetString(GL_VERSION));
	common->Printf("GL_EXTENSIONS: %s\n", qglGetString(GL_EXTENSIONS));

	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 (!(GetAsyncKeyState(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.origin[0] = 0.0f;
	m_Camera.origin[1] = 20.0f;
	m_Camera.origin[2] = 72.0f;
	m_Camera.color[0] = 0.3f;
	m_Camera.color[1] = 0.3f;
	m_Camera.color[2] = 0.3f;
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
void CCamWnd::Cam_BuildMatrix() {
	float	xa, ya;
	float	matrix[4][4];
	int		i;

	xa = ((renderMode) ? -m_Camera.angles[PITCH] : m_Camera.angles[PITCH]) * idMath::M_DEG2RAD;
	ya = m_Camera.angles[YAW] * idMath::M_DEG2RAD;

	// 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];
	}

	m_Camera.vright.Normalize();
	m_Camera.vup.Normalize();
	m_Camera.vpn.Normalize();
	InitCull();
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */

void CCamWnd::Cam_ChangeFloor(bool up) {
	brush_t *b;
	float	d, bestd, current;
	idVec3	start, dir;

	start[0] = m_Camera.origin[0];
	start[1] = m_Camera.origin[1];
	start[2] = HUGE_DISTANCE;
	dir[0] = dir[1] = 0;
	dir[2] = -1;

	current = HUGE_DISTANCE - (m_Camera.origin[2] - 72);
	if (up) {
		bestd = 0;
	}
	else {
		bestd = HUGE_DISTANCE*2;
	}

	for (b = active_brushes.next; b != &active_brushes; b = b->next) {
		if (!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 == HUGE_DISTANCE*2) {
		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_MouseLook() {
	CPoint current;

	GetCursorPos(&current);
	if (current.x != m_ptCursor.x || current.y != m_ptCursor.y) {

		current.x -= m_ptCursor.x;
		current.y -= m_ptCursor.y;

		m_Camera.angles[PITCH] -= (float)((float)current.y * 0.25f);
		m_Camera.angles[YAW] -= (float)((float)current.x * 0.25f);

		SetCursorPos(m_ptCursor.x, m_ptCursor.y);

		Cam_BuildMatrix();
	}
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
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;

	// common->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.0f - idMath::Fabs(yf);
		if ( xf < 0.0f ) {
			xf += 0.1f;
			if ( xf > 0.0f ) {
				xf = 0.0f;
			}
		}
		else {
			xf -= 0.1f;
			if ( xf < 0.0f ) {
				xf = 0.0f;
			}
		}

		VectorMA(m_Camera.origin, yf * dtime * g_PrefsDlg.m_nMoveSpeed, m_Camera.forward, m_Camera.origin);
		m_Camera.angles[YAW] += xf * -dtime * g_PrefsDlg.m_nAngleSpeed;
	}

	Cam_BuildMatrix();
	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) {
	idVec3	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;
	}

	dir.Normalize();

	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.1f );
		}
		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.1f );
		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) {
		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;
	}
	else if ( buttons == (MK_RBUTTON | MK_CONTROL | MK_SHIFT) ) {
		Cam_MouseLook();
		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;
		}
	}
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
bool CCamWnd::CullBrush(brush_t *b, bool cubicOnly) {
	int		i;
	idVec3	point;
	float	d;

	if ( b->forceVisibile ) {
		return false;
	}

	if (g_PrefsDlg.m_bCubicClipping) {
		
		float distance = g_PrefsDlg.m_nCubicScale * 64;

		idVec3 mid;
		for (int i = 0; i < 3; i++) {
			mid[i] = (b->mins[i] + ((b->maxs[i] - b->mins[i]) / 2));
		}

		point = mid - m_Camera.origin;
		if (point.Length() > distance) {
			return true;
		}

	}

	if (cubicOnly) {
		return false;
	}

	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_BLEND);
		qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	}
}
#endif

/*
 =======================================================================================================================
 =======================================================================================================================
 */
void setGLMode(int mode) {
	switch (mode)
	{
		case cd_wire:
			qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
			globalImages->BindNull();
			qglDisable(GL_BLEND);
			qglDisable(GL_DEPTH_TEST);
			qglColor3f( 1.0f, 1.0f, 1.0f );
			break;

		case cd_solid:
			qglCullFace(GL_FRONT);
			qglEnable(GL_CULL_FACE);
			qglShadeModel(GL_FLAT);
			qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
			globalImages->BindNull();
			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);
			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);
			qglDisable(GL_DEPTH_TEST);
			qglEnable(GL_BLEND);
			qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
			break;
	}
}


extern void glLabeledPoint(idVec4 &color, idVec3 &point, float size, const char *label);
void DrawAxial(face_t *selFace) {
	if (g_bAxialMode) {
		idVec3 points[4];
	
		for (int j = 0; j < selFace->face_winding->GetNumPoints(); j++) {
			glLabeledPoint(idVec4(1, 1, 1, 1), (*selFace->face_winding)[j].ToVec3(), 3, va("%i", j));
		}
		
		ValidateAxialPoints();
		points[0] = (*selFace->face_winding)[g_axialAnchor].ToVec3();
		VectorMA (points[0], 1, selFace->plane, points[0]);
		VectorMA (points[0], 4, selFace->plane, points[1]);
		points[3] = (*selFace->face_winding)[g_axialDest].ToVec3();
		VectorMA (points[3], 1, selFace->plane, points[3]);
		VectorMA (points[3], 4, selFace->plane, points[2]);
		glLabeledPoint(idVec4(1, 0, 0, 1), points[1], 3, "Anchor");
		glLabeledPoint(idVec4(1, 1, 0, 1), points[2], 3, "Dest");
		qglBegin (GL_LINE_STRIP);
		qglVertex3fv( points[0].ToFloatPtr() );
		qglVertex3fv( points[1].ToFloatPtr() );
		qglVertex3fv( points[2].ToFloatPtr() );
		qglVertex3fv( points[3].ToFloatPtr() );
		qglEnd();
	}
}


/*
 =======================================================================================================================
    Cam_Draw
 =======================================================================================================================
 */
void CCamWnd::SetProjectionMatrix() {
	float xfov = 90;
	float yfov = 2 * atan((float)m_Camera.height / m_Camera.width) * idMath::M_RAD2DEG;
#if 0
	float screenaspect = (float)m_Camera.width / m_Camera.height;
	qglLoadIdentity();
	gluPerspective(yfov, screenaspect, 2, 8192);
#else
	float	xmin, xmax, ymin, ymax;
	float	width, height;
	float	zNear;
	float	projectionMatrix[16];

	//
	// set up projection matrix
	//
	zNear	= r_znear.GetFloat();

	ymax = zNear * tan( yfov * idMath::PI / 360.0f );
	ymin = -ymax;

	xmax = zNear * tan( xfov * idMath::PI / 360.0f );
	xmin = -xmax;

	width = xmax - xmin;
	height = ymax - ymin;

	projectionMatrix[0] = 2 * zNear / width;
	projectionMatrix[4] = 0;
	projectionMatrix[8] = ( xmax + xmin ) / width;	// normally 0
	projectionMatrix[12] = 0;

	projectionMatrix[1] = 0;
	projectionMatrix[5] = 2 * zNear / height;
	projectionMatrix[9] = ( ymax + ymin ) / height;	// normally 0
	projectionMatrix[13] = 0;

	// this is the far-plane-at-infinity formulation
	projectionMatrix[2] = 0;
	projectionMatrix[6] = 0;
	projectionMatrix[10] = -1;
	projectionMatrix[14] = -2 * zNear;

	projectionMatrix[3] = 0;
	projectionMatrix[7] = 0;
	projectionMatrix[11] = -1;
	projectionMatrix[15] = 0;

	qglLoadMatrixf( projectionMatrix );
#endif
}

void CCamWnd::Cam_Draw() {
	brush_t *brush;
	face_t	*face;

	// float yfov;
	int		i;

	if (!active_brushes.next) {
		return;					// not valid yet
	}

	// set the sound origin for both simple draw and rendered mode
	// the editor uses opposite pitch convention
	idMat3	axis = idAngles( -m_Camera.angles.pitch, m_Camera.angles.yaw, m_Camera.angles.roll ).ToMat3();
	g_qeglobals.sw->PlaceListener( m_Camera.origin, axis, 0, Sys_Milliseconds(), "Undefined" );

	if (renderMode) {
		Cam_Render();
	}

	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);

	if (!renderMode) {
		qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	}

	qglDisable(GL_LIGHTING);
	qglMatrixMode(GL_PROJECTION);

	SetProjectionMatrix();

	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();
   
	for (brush = active_brushes.next; brush != &active_brushes; brush = brush->next) {

		if ( CullBrush(brush, false) ) {
			continue;
		}

		if ( FilterBrush(brush) ) {
			continue;
		}

		if (renderMode) {
			if (!(entityMode && brush->owner->eclass->fixedsize)) {
				continue;
			}
		}

		setGLMode(m_Camera.draw_mode);
		Brush_Draw(brush);
	}


	//qglDepthMask ( 1 ); // Ok, write now
	qglMatrixMode(GL_PROJECTION);

	qglTranslatef(g_qeglobals.d_select_translate[0],g_qeglobals.d_select_translate[1],g_qeglobals.d_select_translate[2]);

	brush_t *pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;

	if (!renderMode) {
		// draw normally
		for (brush = pList->next; brush != pList; brush = brush->next) {
			if (brush->pPatch) {
				continue;
			}
			setGLMode(m_Camera.draw_mode);
			Brush_Draw(brush, true);
		}
	}

	// blend on top

	setGLMode(m_Camera.draw_mode);
	qglDisable(GL_LIGHTING);
	qglColor4f( g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][0],g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][1],g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][2], 0.25f );
	qglEnable(GL_BLEND);
	qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	globalImages->BindNull();
	for (brush = pList->next; brush != pList; brush = brush->next) {
		if (brush->pPatch || brush->modelHandle > 0) {
			Brush_Draw(brush, true);

			// DHM - Nerve:: patch display lists/models mess with the state
			qglEnable(GL_BLEND);
			qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
			qglColor4f( g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][0],g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][1],g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][2], 0.25f );
			globalImages->BindNull();
			continue;
		}

        if ( brush->owner->eclass->entityModel ) {
            continue;
        }

		for (face = brush->brush_faces; face; face = face->next) {
			Face_Draw(face);
		}
	}

	int nCount = g_ptrSelectedFaces.GetSize();

	if (!renderMode) {
		for (int i = 0; i < nCount; i++) {
			face_t	*selFace = reinterpret_cast < face_t * > (g_ptrSelectedFaces.GetAt(i));
			Face_Draw(selFace);
			DrawAxial(selFace);
		}
	} 

	// non-zbuffered outline
	qglDisable(GL_BLEND);
	qglDisable(GL_DEPTH_TEST);
	qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

	if (renderMode) {
		qglColor3f(1, 0, 0);
		for (int i = 0; i < nCount; i++) {
			face_t	*selFace = reinterpret_cast < face_t * > (g_ptrSelectedFaces.GetAt(i));
			Face_Draw(selFace);
		}
	}

	qglColor3f(1, 1, 1);
	for (brush = pList->next; brush != pList; brush = brush->next) {
		if (brush->pPatch || brush->modelHandle > 0) {
			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].ToFloatPtr() );
		}

		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].ToFloatPtr();
			v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2].ToFloatPtr();
			qglVertex3f( (v1[0] + v2[0]) * 0.5f, (v1[1] + v2[1]) * 0.5f, (v1[2] + v2[2]) * 0.5f );
		}

		qglEnd();
		qglPointSize(1);
	}

	g_splineList->draw (static_cast<bool>(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();
	}

	//
	// bind back to the default texture so that we don't have problems elsewhere
	// using/modifying texture maps between contexts
	//
	globalImages->BindNull();

	qglFinish();
	QE_CheckOpenGLForErrors();

	if (!renderMode) {
		// clean up any deffered tri's
		R_ToggleSmpFrame();
	}
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
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::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) {
/*
	idVec3	texS, texT;
	idVec3	viewX, viewY;
	int		XS, XT, YS, YT;
	int		outS, outT;
#ifdef _DEBUG
	if (!g_qeglobals.m_bBrushPrimitMode) {
		common->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
		common->Printf("Warning : degenerate best vectors axis base in CCamWnd::ShiftTexture_BrushPrimit\n");
#endif
		// forget it
		Select_ShiftTexture_BrushPrimit(f, x, y, false);
		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, false);
*/
}


bool IsBModel(brush_t *b) {
	const char *v = ValueForKey( b->owner, "model" );
	if (v && *v) {
		const char *n = ValueForKey( b->owner, "name");
		return (stricmp( n, v ) == 0);
	}
	return false;
}

/*
================
BuildEntityRenderState

Creates or updates modelDef and lightDef for an entity
================
*/
int Brush_ToTris(brush_t *brush, idTriList *tris, idMatList *mats, bool models, bool bmodel);

void CCamWnd::BuildEntityRenderState( entity_t *ent, bool update) {
	const char	*v;
	idDict		spawnArgs;
	const char	*name = NULL;

	Entity_UpdateSoundEmitter( ent );

	// delete the existing def if we aren't creating a brand new world
	if ( !update ) {
		if ( ent->lightDef >= 0 ) {
			g_qeglobals.rw->FreeLightDef( ent->lightDef );
			ent->lightDef = -1;
		}

		if ( ent->modelDef >= 0 ) {
			g_qeglobals.rw->FreeEntityDef( ent->modelDef );
			ent->modelDef = -1;
		}
	}

	// if an entity doesn't have any brushes at all, don't do anything
	if ( ent->brushes.onext == &ent->brushes ) {
		return;
	}

	// if the brush isn't displayed (filtered or culled), don't do anything
	if (FilterBrush(ent->brushes.onext)) {
		return;
	}

	spawnArgs = ent->epairs;
	if (ent->eclass->defArgs.FindKey("model")) {
		spawnArgs.Set("model", ent->eclass->defArgs.GetString("model"));
	}

	// any entity can have a model
	name = ValueForKey( ent, "name" );
	v = spawnArgs.GetString("model");
	if ( v && *v ) {
		renderEntity_t	refent;

		refent.referenceSound = ent->soundEmitter;

		if ( !stricmp( name, v ) ) {
			// build the model from brushes
			idTriList tris(1024);
			idMatList mats(1024);

			for (brush_t *b = ent->brushes.onext; b != &ent->brushes; b = b->onext) {
				Brush_ToTris( b, &tris, &mats, false, true);
			}

			if ( ent->modelDef >= 0 ) {
				g_qeglobals.rw->FreeEntityDef( ent->modelDef );
				ent->modelDef = -1;
			}

			idRenderModel *bmodel = renderModelManager->FindModel( name );

			if ( bmodel ) {
				renderModelManager->RemoveModel( bmodel );
				renderModelManager->FreeModel( bmodel );
			}

			bmodel = renderModelManager->AllocModel();

			bmodel->InitEmpty( name );

			// add the surfaces to the renderModel
			modelSurface_t	surf;
			for ( int i = 0 ; i < tris.Num() ; i++ ) {
				surf.geometry = tris[i];
				surf.shader = mats[i];
				bmodel->AddSurface( surf );
			}

			bmodel->FinishSurfaces();

			renderModelManager->AddModel( bmodel );

			// FIXME: brush entities
			gameEdit->ParseSpawnArgsToRenderEntity( &spawnArgs, &refent );

			ent->modelDef = g_qeglobals.rw->AddEntityDef( &refent );

		} else {
			// use the game's epair parsing code so
			// we can use the same renderEntity generation
			gameEdit->ParseSpawnArgsToRenderEntity( &spawnArgs, &refent );
			idRenderModelMD5 *md5 = dynamic_cast<idRenderModelMD5 *>( refent.hModel );
			if (md5) {
				idStr str;
				spawnArgs.GetString("anim", "idle", str);
				refent.numJoints = md5->NumJoints();
				if ( update && refent.joints ) {
					Mem_Free16( refent.joints );
				}
				refent.joints = ( idJointMat * )Mem_Alloc16( refent.numJoints * sizeof( *refent.joints ) );
				const idMD5Anim *anim = gameEdit->ANIM_GetAnimFromEntityDef(spawnArgs.GetString("classname"), str);
				int frame = spawnArgs.GetInt("frame") + 1;
				if ( frame < 1 ) {
					frame = 1;
				}
				const idVec3 &offset = gameEdit->ANIM_GetModelOffsetFromEntityDef( spawnArgs.GetString("classname") );
				gameEdit->ANIM_CreateAnimFrame( md5, anim, refent.numJoints, refent.joints, ( frame * 1000 ) / 24, offset, false );
			}
			if (ent->modelDef >= 0) {
				g_qeglobals.rw->FreeEntityDef( ent->modelDef );
			}
			ent->modelDef = g_qeglobals.rw->AddEntityDef( &refent );
		}
	}

	// check for lightdefs
	if (!(ent->eclass->nShowFlags & ECLASS_LIGHT)) {
		return;
	}

	if ( spawnArgs.GetBool( "start_off" ) ) {
		return;
	}
	// use the game's epair parsing code so
	// we can use the same renderLight generation

	renderLight_t	lightParms;

	gameEdit->ParseSpawnArgsToRenderLight( &spawnArgs, &lightParms );
	lightParms.referenceSound = ent->soundEmitter;

	if (update && ent->lightDef >= 0) {
		g_qeglobals.rw->UpdateLightDef( ent->lightDef, &lightParms );
	} else {
		if (ent->lightDef >= 0) {
			g_qeglobals.rw->FreeLightDef(ent->lightDef);
		}
		ent->lightDef = g_qeglobals.rw->AddLightDef( &lightParms );
	}

}

void Tris_ToOBJ(const char *outFile, idTriList *tris, idMatList *mats) {
	idFile *f = fileSystem->OpenExplicitFileWrite( outFile );
	if ( f ) {
		char out[1024];
		strcpy(out, outFile);
		StripExtension(out);

		idList<idStr*> matNames;
		int i, j, k;
		int indexBase = 1;
		idStr lastMaterial("");
		int matCount = 0;
		//idStr basePath = cvarSystem->GetCVarString( "fs_savepath" );
		f->Printf( "mtllib %s.mtl\n", out );
		for (i = 0; i < tris->Num(); i++) {
			srfTriangles_t *tri = (*tris)[i];
			for (j = 0; j < tri->numVerts; j++) {
				f->Printf( "v %f %f %f\n", tri->verts[j].xyz.x, tri->verts[j].xyz.z, -tri->verts[j].xyz.y );
			}
			for (j = 0; j < tri->numVerts; j++) {
				f->Printf( "vt %f %f\n", tri->verts[j].st.x, 1.0f - tri->verts[j].st.y );
			}
			for (j = 0; j < tri->numVerts; j++) {
				f->Printf( "vn %f %f %f\n", tri->verts[j].normal.x, tri->verts[j].normal.y, tri->verts[j].normal.z );
			}

			if (stricmp( (*mats)[i]->GetName(), lastMaterial)) {
				lastMaterial = (*mats)[i]->GetName();

				bool found = false;
				for (k = 0; k < matNames.Num(); k++) {
					if ( idStr::Icmp(matNames[k]->c_str(), lastMaterial.c_str()) == 0 ) {
						found = true;
						// f->Printf( "usemtl m%i\n", k );
						f->Printf( "usemtl %s\n", lastMaterial.c_str() );
						break;
					}
				}

				if (!found) {
					// f->Printf( "usemtl m%i\n", matCount++ );
					f->Printf( "usemtl %s\n", lastMaterial.c_str() );
					matNames.Append(new idStr(lastMaterial));
				}
			}

			for (int j = 0; j < tri->numIndexes; j += 3) {
				int i1, i2, i3;
				i1 = tri->indexes[j+2] + indexBase;
				i2 = tri->indexes[j+1] + indexBase;
				i3 = tri->indexes[j] + indexBase; 
				f->Printf( "f %i/%i/%i %i/%i/%i %i/%i/%i\n", i1,i1,i1, i2,i2,i2, i3,i3,i3 );
			}

			indexBase += tri->numVerts;

		}
		fileSystem->CloseFile( f );

		strcat(out, ".mtl");
		f = fileSystem->OpenExplicitFileWrite( out );
		if (f) {
			for (k = 0; k < matNames.Num(); k++) {
				// This presumes the diffuse tga name matches the material name
				f->Printf( "newmtl %s\n\tNs 0\n\td 1\n\tillum 2\n\tKd 0 0 0 \n\tKs 0.22 0.22 0.22 \n\tKa 0 0 0 \n\tmap_Kd %s/base/%s.tga\n\n\n", matNames[k]->c_str(), "z:/d3xp", matNames[k]->c_str() );
			}
			fileSystem->CloseFile( f );
		}

	}
}

int Brush_TransformModel(brush_t *brush, idTriList *tris, idMatList *mats) {
	int ret = 0;
	if (brush->modelHandle > 0 ) {
		idRenderModel *model = brush->modelHandle;
		if (model) {
			float	a = FloatForKey(brush->owner, "angle");
			float	s, c;
			//FIXME: support full rotation matrix
			bool matrix = false;
			if (a) {
				s = sin( DEG2RAD(a) );
				c = cos( DEG2RAD(a) );
			}
			idMat3 mat;
			if (GetMatrixForKey(brush->owner, "rotation", mat)) {
				matrix = true;
			}


			for (int i = 0; i < model->NumSurfaces() ; i++) {
				const modelSurface_t	*surf = model->Surface( i );
				srfTriangles_t	*tri = surf->geometry;
				srfTriangles_t *tri2 = R_CopyStaticTriSurf(tri);
				for (int j = 0; j < tri2->numVerts; j++) {
					idVec3	v;
					if (matrix) {
						v = tri2->verts[j].xyz * brush->owner->rotation + brush->owner->origin;
					} else {
						v = tri2->verts[j].xyz;
						VectorAdd(v, brush->owner->origin, v);
						float x = v[0];
						float y = v[1];
						if (a) {
							float	x2 = (((x - brush->owner->origin[0]) * c) - ((y - brush->owner->origin[1]) * s)) + brush->owner->origin[0];
							float	y2 = (((x - brush->owner->origin[0]) * s) + ((y - brush->owner->origin[1]) * c)) + brush->owner->origin[1];
							x = x2;
							y = y2;
						}
						v[0] = x;
						v[1] = y;
					}
					tri2->verts[j].xyz = v;
				}
				tris->Append(tri2);
				mats->Append( surf->shader );
			}
			return model->NumSurfaces();
		}
	}
	return ret;
}


#define	MAX_TRI_SURFACES	16384
int Brush_ToTris(brush_t *brush, idTriList *tris, idMatList *mats, bool models, bool bmodel) {
	int i, j;
	srfTriangles_t	*tri;
	//
	// patches
	//
	if (brush->modelHandle > 0 ) {
		if (!models) {
			return 0;
		} else {
			return Brush_TransformModel(brush, tris, mats);
		}
	}

	int numSurfaces = 0;

	if ( brush->owner->eclass->fixedsize && !brush->entityModel) {
		return NULL;
	}

	if ( brush->pPatch ) {
		patchMesh_t *pm;
		int			width, height;

		pm = brush->pPatch;

		// build a patch mesh
		idSurface_Patch *cp = new idSurface_Patch( pm->width * 6, pm->height * 6 );
		cp->SetSize( pm->width, pm->height );
		for ( i = 0; i < pm->width; i++ ) {
			for ( j = 0; j < pm->height; j++ ) {
				(*cp)[j*cp->GetWidth()+i].xyz =  pm->ctrl(i, j).xyz;
				(*cp)[j*cp->GetWidth()+i].st = pm->ctrl(i, j).st;
			}
		}

		// subdivide it
		if ( pm->explicitSubdivisions ) {
			cp->SubdivideExplicit( pm->horzSubdivisions, pm->vertSubdivisions, true );
		} else {
			cp->Subdivide( DEFAULT_CURVE_MAX_ERROR, DEFAULT_CURVE_MAX_ERROR, DEFAULT_CURVE_MAX_LENGTH, true );
		}
		width = cp->GetWidth();
		height = cp->GetHeight();

		// convert to srfTriangles
		tri = R_AllocStaticTriSurf();
		tri->numVerts = width * height;
		tri->numIndexes = 6 * ( width - 1 ) * ( height - 1 );
		R_AllocStaticTriSurfVerts( tri, tri->numVerts );
		R_AllocStaticTriSurfIndexes( tri, tri->numIndexes );
		for ( i = 0 ; i < tri->numVerts ; i++ ) {
			tri->verts[i] = (*cp)[i];
			if (bmodel) {
				tri->verts[i].xyz -= brush->owner->origin;
			}
		}

		tri->numIndexes = 0;
		for ( i = 1 ; i < width ; i++ ) {
			for ( j = 1 ; j < height ; j++ ) {
				tri->indexes[tri->numIndexes++] = ( j - 1 ) * width + i;
				tri->indexes[tri->numIndexes++] = ( j - 1 ) * width + i - 1;
				tri->indexes[tri->numIndexes++] = j * width + i - 1;

				tri->indexes[tri->numIndexes++] = j * width + i;
				tri->indexes[tri->numIndexes++] = ( j - 1 ) * width + i;
				tri->indexes[tri->numIndexes++] = j * width + i - 1;
			}
		}

		delete cp;

		tris->Append(tri);
		mats->Append(pm->d_texture);
		//surfaces[numSurfaces] = tri;
		//materials[numSurfaces] = pm->d_texture;
		return 1;
	}

	//
	// normal brush
	//
	for ( face_t *face = brush->brush_faces ; face; face = face->next ) {
		idWinding *w;

		w = face->face_winding;
		if (!w) {
			continue;	// freed or degenerate face
		}

		tri = R_AllocStaticTriSurf();
		tri->numVerts = w->GetNumPoints();
		tri->numIndexes = ( w->GetNumPoints() - 2 ) * 3;
		R_AllocStaticTriSurfVerts( tri, tri->numVerts );
		R_AllocStaticTriSurfIndexes( tri, tri->numIndexes );

		for ( i = 0 ; i < tri->numVerts ; i++ ) {

			tri->verts[i].Clear();

			tri->verts[i].xyz[0] = (*w)[i][0];
			tri->verts[i].xyz[1] = (*w)[i][1];
			tri->verts[i].xyz[2] = (*w)[i][2];

			if ( bmodel ) {
				tri->verts[i].xyz -= brush->owner->origin;
			}

			tri->verts[i].st[0] = (*w)[i][3];
			tri->verts[i].st[1] = (*w)[i][4];

			tri->verts[i].normal = face->plane.Normal();
		}

		tri->numIndexes = 0;
		for ( i = 2 ; i < w->GetNumPoints() ; i++ ) {
			tri->indexes[tri->numIndexes++] = 0;
			tri->indexes[tri->numIndexes++] = i-1;
			tri->indexes[tri->numIndexes++] = i;
		}

		tris->Append(tri);
		mats->Append(face->d_texture);
		numSurfaces++;
	}
	
	return numSurfaces;
}

void Select_ToOBJ() {
	int i;
	CFileDialog dlgFile(FALSE, "obj", NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, "Wavefront object files (*.obj)|*.obj||", g_pParentWnd);
	if (dlgFile.DoModal() == IDOK) {
		idTriList tris(1024);
		idMatList mats(1024);

		for (brush_t *b = selected_brushes.next; b != &selected_brushes; b = b->next) {

			if ( b->hiddenBrush ) {
				continue;
			}

			if (FilterBrush(b)) {
				continue;
			}

			Brush_ToTris(b, &tris, &mats, true, false);
		}

		Tris_ToOBJ(dlgFile.GetPathName().GetBuffer(0), &tris, &mats);

		for( i = 0; i < tris.Num(); i++ ) {
			R_FreeStaticTriSurf( tris[i] );
		}
		tris.Clear();
	}
}

void Select_ToCM() {
	CFileDialog dlgFile( FALSE, "lwo, ase", NULL, 0, "(*.lwo)|*.lwo|(*.ase)|*.ase|(*.ma)|*.ma||", g_pParentWnd );

	if ( dlgFile.DoModal() == IDOK ) {
		idMapEntity *mapEnt;
		idMapPrimitive *p;
		idStr name;

		name = fileSystem->OSPathToRelativePath( dlgFile.GetPathName() );
		name.BackSlashesToSlashes();

		mapEnt = new idMapEntity();
		mapEnt->epairs.Set( "name", name.c_str() );

		for ( brush_t *b = selected_brushes.next; b != &selected_brushes; b = b->next ) {

			if ( b->hiddenBrush ) {
				continue;
			}

			if ( FilterBrush( b ) ) {
				continue;
			}

			p = BrushToMapPrimitive( b, b->owner->origin );
			if ( p ) {
				mapEnt->AddPrimitive( p );
			}
		}

		collisionModelManager->WriteCollisionModelForMapEntity( mapEnt, name.c_str() );

		delete mapEnt;
	}
}


/*
=================
BuildRendererState

Builds models, lightdefs, and modeldefs for the current editor data
so it can be rendered by the game renderSystem
=================
*/
void CCamWnd::BuildRendererState() {
	renderEntity_t	worldEntity;
	entity_t	*ent;
	brush_t		*brush;

	FreeRendererState();

	// the renderWorld holds all the references and defs
	g_qeglobals.rw->InitFromMap( NULL );

	// create the raw model for all the brushes
	int numBrushes = 0;
	int numSurfaces = 0;

	// the renderModel for the world holds all the geometry that isn't in an entity
	worldModel = renderModelManager->AllocModel();
	worldModel->InitEmpty( "EditorWorldModel" );

	for ( brush_t *brushList = &active_brushes ; brushList ; 
		brushList = (brushList == &active_brushes) ? &selected_brushes : NULL ) {

		for (brush = brushList->next; brush != brushList; brush = brush->next) {

			if ( brush->hiddenBrush ) {
				continue;
			}

			if (FilterBrush(brush)) {
				continue;
			}

			if (CullBrush(brush, true)) {
				continue;
			}

			idTriList tris(1024);
			idMatList mats(1024);
			
			if (!IsBModel(brush)) {
				numSurfaces += Brush_ToTris( brush, &tris, &mats, false, false );
			}

			// add the surfaces to the renderModel
			modelSurface_t	surf;
			for ( int i = 0 ; i < tris.Num() ; i++ ) {
				surf.geometry = tris[i];
				surf.shader = mats[i];
				worldModel->AddSurface( surf );
			}

			numBrushes++;
		}
	}

	// bound and clean the triangles
	worldModel->FinishSurfaces();

	// the worldEntity just has the handle for the worldModel
	memset( &worldEntity, 0, sizeof( worldEntity ) );
	worldEntity.hModel = worldModel;
	worldEntity.axis = mat3_default;
	worldEntity.shaderParms[0] = 1;
	worldEntity.shaderParms[1] = 1;
	worldEntity.shaderParms[2] = 1;
	worldEntity.shaderParms[3] = 1;

	worldModelDef = g_qeglobals.rw->AddEntityDef( &worldEntity );

	// create the light and model entities exactly the way the game code would
	for ( ent = entities.next ; ent != &entities ; ent = ent->next ) {
		if ( ent->brushes.onext == &ent->brushes ) {
			continue;
		}

		if (CullBrush(ent->brushes.onext, true)) {
			continue;
		}

		if (Map_IsBrushFiltered(ent->brushes.onext)) {
			continue;
		}

		BuildEntityRenderState( ent, false );
	}

	//common->Printf("Render data used %d brushes\n", numBrushes);
	worldDirty = false;
	UpdateCaption();
}

/*
===============================
CCamWnd::UpdateRenderEntities

  Creates a new entity state list
  returns true if a repaint is needed
===============================
*/
bool CCamWnd::UpdateRenderEntities() {

	if (rebuildMode) {
		return false;
	}

	bool ret = false;
	for ( entity_t *ent = entities.next ; ent != &entities ; ent = ent->next ) {
		BuildEntityRenderState( ent, (ent->lightDef != -1 || ent->modelDef != -1 || ent->soundEmitter ) ? true : false );
		if (ret == false && ent->modelDef || ent->lightDef) {
			ret = true;
		}
	}
	return ret;
}

/*
============================
CCamWnd::FreeRendererState

  Frees the render state data
============================
*/
void CCamWnd::FreeRendererState() {

	for ( entity_t *ent = entities.next ; ent != &entities ; ent = ent->next ) {
		if (ent->lightDef >= 0) {
			g_qeglobals.rw->FreeLightDef( ent->lightDef );
			ent->lightDef = -1;
		}

		if (ent->modelDef >= 0) {
			renderEntity_t *refent = const_cast<renderEntity_t *>(g_qeglobals.rw->GetRenderEntity( ent->modelDef ));
			if ( refent ) {
				if ( refent->callbackData ) {
					Mem_Free( refent->callbackData );
					refent->callbackData = NULL;
				}
				if ( refent->joints ) {
					Mem_Free16(refent->joints);
					refent->joints = NULL;
				}
			}
			g_qeglobals.rw->FreeEntityDef( ent->modelDef );
			ent->modelDef = -1;
		}
	}

	if ( worldModel ) {
		renderModelManager->FreeModel( worldModel );
		worldModel = NULL;
	}

}


/*
========================
CCamWnd::UpdateCaption

  updates the caption based on rendermode and whether the render mode needs updated
========================
*/
void CCamWnd::UpdateCaption() {
	
	idStr strCaption;

	if (worldDirty) {
		strCaption = "*";
	}
	// FIXME: 	
	strCaption += (renderMode) ? "RENDER" : "CAM";
	if (renderMode) {
		strCaption += (rebuildMode) ? " (Realtime)" : "";
		strCaption += (entityMode) ? " +lights" : "";
		strCaption += (selectMode) ? " +selected" : "";
		strCaption += (animationMode) ? " +anim" : "";
	}
	strCaption += (soundMode) ? " +snd" : "";
	SetWindowText(strCaption);
}

/*
===========================
CCamWnd::ToggleRenderMode

	Toggles the render mode
===========================
*/
void CCamWnd::ToggleRenderMode() {
	renderMode ^= 1;
	UpdateCaption();
}

/*
===========================
CCamWnd::ToggleRebuildMode

	Toggles the rebuild mode
===========================
*/
void CCamWnd::ToggleRebuildMode() {
	rebuildMode ^= 1;
	UpdateCaption();
}

/*
===========================
CCamWnd::ToggleEntityMode

	Toggles the entity mode
===========================
*/
void CCamWnd::ToggleEntityMode() {
	entityMode ^= 1;
	UpdateCaption();
}


/*
===========================
CCamWnd::ToggleRenderMode

	Toggles the render mode
===========================
*/
void CCamWnd::ToggleAnimationMode() {
	animationMode ^= 1;
	if (animationMode)  {
		SetTimer(0, 10, NULL);
	} else {
		KillTimer(0);
	}
	UpdateCaption();
}

/*
===========================
CCamWnd::ToggleSoundMode

	Toggles the sound mode
===========================
*/
void CCamWnd::ToggleSoundMode() {
	soundMode ^= 1;

	UpdateCaption();

	for ( entity_t *ent = entities.next ; ent != &entities ; ent = ent->next ) {
		Entity_UpdateSoundEmitter( ent );
	}
}

/*
===========================
CCamWnd::ToggleRenderMode

	Toggles the render mode
===========================
*/
void CCamWnd::ToggleSelectMode() {
	selectMode ^= 1;
	UpdateCaption();
}

/*
=========================
CCamWnd::MarkWorldDirty

  marks the render world as dirty
=========================
*/
void CCamWnd::MarkWorldDirty() {
	worldDirty = true;
	UpdateCaption();
}


/*
=========================
CCamWnd::DrawEntityData

  Draws entity data ( experimental )
=========================
*/
extern void glBox(idVec4 &color, idVec3 &point, float size);

void CCamWnd::DrawEntityData() {

	qglMatrixMode( GL_MODELVIEW );
	qglLoadIdentity();
	qglMatrixMode( GL_PROJECTION );
	qglLoadIdentity();

	SetProjectionMatrix();

	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 (!(entityMode || selectMode)) {
		return;
	}

	qglDisable(GL_BLEND);
	qglDisable(GL_DEPTH_TEST);
	qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	globalImages->BindNull();
	idVec3 color(0, 1, 0);
	qglColor3fv( color.ToFloatPtr() );

	brush_t *brushList = &active_brushes;
	int pass = 0;
	while (brushList) {
		for (brush_t *brush = brushList->next; brush != brushList; brush = brush->next) {

			if (CullBrush(brush, true)) {
				continue;
			}

			if (FilterBrush(brush)) {
				continue;
			}

			if ((pass == 1 && selectMode) || (entityMode && pass == 0 && brush->owner->lightDef >= 0)) {
				Brush_DrawXY(brush, 0, true, true);
			}

		}
		brushList = (brushList == &active_brushes) ? &selected_brushes : NULL;
		color.x = 1;
		color.y = 0;
		pass++;
		qglColor3fv( color.ToFloatPtr() );
	}

}


/*
 =======================================================================================================================
    Cam_Render

	This used the renderSystem to draw a fully lit view of the world
 =======================================================================================================================
 */
void CCamWnd::Cam_Render() {

	renderView_t	refdef;
	CPaintDC	dc(this);	// device context for painting


	if (!active_brushes.next) {
		return;					// not valid yet
	}

	if (!qwglMakeCurrent(dc.m_hDC, win32.hGLRC)) {
		common->Printf("ERROR: wglMakeCurrent failed..\n ");
		common->Printf("Please restart " EDITOR_WINDOWTEXT " if the camera view is not working\n");
		return;
	}

	// save the editor state
	//qglPushAttrib( GL_ALL_ATTRIB_BITS );
	qglClearColor( 0.1f, 0.1f, 0.1f, 0.0f );
	qglScissor( 0, 0, m_Camera.width, m_Camera.height );
	qglClear( GL_COLOR_BUFFER_BIT );

	//	qwglSwapBuffers(dc.m_hDC);

	// create the model, using explicit normals
	if ( rebuildMode && worldDirty ) {
		BuildRendererState();
	}

	// render it
	renderSystem->BeginFrame( m_Camera.width, m_Camera.height );

	memset( &refdef, 0, sizeof( refdef ) );
	refdef.vieworg = m_Camera.origin;

	// the editor uses opposite pitch convention
	refdef.viewaxis = idAngles( -m_Camera.angles.pitch, m_Camera.angles.yaw, m_Camera.angles.roll ).ToMat3();
	
	refdef.width = SCREEN_WIDTH;
	refdef.height = SCREEN_HEIGHT;
	refdef.fov_x = 90;
	refdef.fov_y = 2 * atan((float)m_Camera.height / m_Camera.width) * idMath::M_RAD2DEG;

	// only set in animation mode to give a consistent look 
	if (animationMode) {
		refdef.time = eventLoop->Milliseconds();
	}

	g_qeglobals.rw->RenderScene( &refdef );

	int	frontEnd, backEnd;

	renderSystem->EndFrame( &frontEnd, &backEnd );
//common->Printf( "front:%i back:%i\n", frontEnd, backEnd );

	//qglPopAttrib();
	//DrawEntityData();

	//qwglSwapBuffers(dc.m_hDC);
	// get back to the editor state
	qglMatrixMode( GL_MODELVIEW );
	qglLoadIdentity();
	Cam_BuildMatrix();
}


void CCamWnd::OnTimer(UINT nIDEvent) 
{
	if (animationMode || nIDEvent == 1) {
		Sys_UpdateWindows(W_CAMERA);
	}
	if (nIDEvent == 1) {
		KillTimer(1);
	}

	if (!animationMode ) {
		KillTimer(0);
	}
}


void CCamWnd::UpdateCameraView() {
	if (QE_SingleBrush(true, true)) {
		brush_t *b = selected_brushes.next;
		if (b->owner->eclass->nShowFlags & ECLASS_CAMERAVIEW) {
			// find the entity that targets this
			const char *name = ValueForKey(b->owner, "name");
			entity_t *ent = FindEntity("target", name);
			if (ent) {
				if (!saveValid) {
					saveOrg = m_Camera.origin;
					saveAng = m_Camera.angles;
					saveValid = true;
				}
				idVec3 v = b->owner->origin - ent->origin;
				v.Normalize();
				idAngles ang = v.ToMat3().ToAngles();
				ang.pitch = -ang.pitch;
				ang.roll = 0.0f;
                SetView( ent->origin, ang );
				Cam_BuildMatrix();
				Sys_UpdateWindows( W_CAMERA );
				return;
			}
		}
	}
	if (saveValid) {
		SetView(saveOrg, saveAng);
		Cam_BuildMatrix();
		Sys_UpdateWindows(W_CAMERA);
		saveValid = false;
	}
}