csgo/cstrike15_src/hammer/mapview3d.cpp

//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: Implements the 3D view message handling. This class is responsible
//			for 3D camera control, activating tools in the 3D view, calling
//			into the renderer when necessary, and synchronizing the 2D camera
//			information with the 3D camera.
//
//=============================================================================//

#include "stdafx.h"
#include <oleauto.h>
#include <oaidl.h>
#if _MSC_VER < 1300
#include <afxpriv.h>
#endif
#include <mmsystem.h>
#include "Camera.h"
#include "GlobalFunctions.h"
#include "Gizmo.h"
#include "History.h"
#include "Keyboard.h"
#include "MainFrm.h"
#include "MapDoc.h"
#include "MapDecal.h"
#include "MapEntity.h"
#include "MapSolid.h"
#include "MapStudioModel.h"
#include "MapWorld.h"
#include "MapView3D.h"
#include "MapView2D.h"
#include "ObjectBar.h"
#include "Options.h"
#include "StatusBarIDs.h"
#include "TitleWnd.h"
#include "ToolManager.h"
#include "hammer.h"
#include "mathlib/vector.h"
#include "MapOverlay.h"
#include "engine_launcher_api.h"
#include "vgui/Cursor.h"
#include "ToolCamera.h"
#include "HammerVGui.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>

#pragma warning(disable:4244 4305)


typedef struct
{
	CMapObjectList *pList;
	POINT pt;
	CMapWorld *pWorld;
} SELECT3DINFO;


int g_nClipPoints = 0;
Vector g_ClipPoints[4];


//
// Defines the logical keys.
//
#define LOGICAL_KEY_FORWARD			0
#define LOGICAL_KEY_BACK			1
#define LOGICAL_KEY_LEFT			2
#define LOGICAL_KEY_RIGHT			3
#define LOGICAL_KEY_UP				4
#define LOGICAL_KEY_DOWN			5
#define LOGICAL_KEY_PITCH_UP		6
#define LOGICAL_KEY_PITCH_DOWN		7
#define LOGICAL_KEY_YAW_LEFT		8
#define LOGICAL_KEY_YAW_RIGHT		9

//
// Rotation speeds, in degrees per second.
//
#define YAW_SPEED					180
#define PITCH_SPEED					180
#define ROLL_SPEED					180


IMPLEMENT_DYNCREATE(CMapView3D, CView)


BEGIN_MESSAGE_MAP(CMapView3D, CView)
	//{{AFX_MSG_MAP(CMapView3D)
	ON_WM_KILLFOCUS()
	ON_WM_TIMER()
	ON_WM_KEYDOWN()
	ON_WM_KEYUP()
	ON_WM_SIZE()
	ON_WM_CONTEXTMENU()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_LBUTTONDBLCLK()
	ON_WM_RBUTTONDOWN()
	ON_WM_MOUSEMOVE()
	ON_WM_MOUSEWHEEL()
	ON_WM_RBUTTONUP()
	ON_WM_CHAR()
	ON_WM_SETFOCUS()
	ON_WM_NCPAINT()
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
	ON_COMMAND(ID_VIEW_3DWIREFRAME, OnView3dWireframe)
	ON_COMMAND(ID_VIEW_3DPOLYGON, OnView3dPolygon)
	ON_COMMAND(ID_VIEW_3DTEXTURED, OnView3dTextured)
	ON_COMMAND(ID_VIEW_3DLIGHTMAP_GRID, OnView3dLightmapGrid)
	ON_COMMAND(ID_VIEW_LIGHTINGPREVIEW, OnView3dLightingPreview)
	ON_COMMAND(ID_VIEW_LIGHTINGPREVIEW_RAYTRACED, OnView3dLightingPreviewRayTraced)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


//-----------------------------------------------------------------------------
// Purpose: Constructor. Initializes data members to default values.
//-----------------------------------------------------------------------------
CMapView3D::CMapView3D(void)
{
	m_eDrawType = VIEW3D_WIREFRAME;
	m_pRender = NULL;
	m_pCamera = NULL;

	m_dwTimeLastInputSample = 0;

	m_fForwardSpeed = 0;
	m_fStrafeSpeed = 0;
	m_fVerticalSpeed = 0;

	m_pwndTitle = NULL;
	m_bLightingPreview = false;

	m_bMouseLook = false;
	m_bStrafing = false;
	m_bRotating = false;

	m_ptLastMouseMovement.x = 0;
	m_ptLastMouseMovement.y = 0;

	m_nLastRaytracedBitmapRenderTimeStamp = -1;

	m_bCameraPosChanged = false;
	m_bClippingChanged = false;
}


//-----------------------------------------------------------------------------
// Purpose: Destructor. Releases dynamically allocated resources.
//-----------------------------------------------------------------------------
CMapView3D::~CMapView3D(void)
{
	if (m_pCamera != NULL)
	{
		delete m_pCamera;
	}

	if (m_pRender != NULL)
	{
		m_pRender->ShutDown();
		delete m_pRender;
	}

	if (m_pwndTitle != NULL)
	{
		delete m_pwndTitle;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : cs - 
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
BOOL CMapView3D::PreCreateWindow(CREATESTRUCT& cs)
{
	static CString className;
	
	if(className.IsEmpty())
	{
		//
		// We need the CS_OWNDC bit so that we don't need to call GetDC every time we render. That fixes the flicker under Win98.
		//
		className = AfxRegisterWndClass(CS_BYTEALIGNCLIENT | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW | CS_OWNDC, NULL, HBRUSH(GetStockObject(BLACK_BRUSH)));
	}

	cs.lpszClass = className;

	return CView::PreCreateWindow(cs);
}


//-----------------------------------------------------------------------------
// Purpose: Disables mouselook when the view loses focus. This ensures that the
//			cursor is shown and not locked in the center of the 3D view.
// Input  : pNewWnd - The window getting focus.
//-----------------------------------------------------------------------------
void CMapView3D::OnKillFocus(CWnd *pNewWnd)
{
	EnableMouseLook(false);
	EnableRotating(false);
	EnableStrafing(false);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nDrawType - 
//-----------------------------------------------------------------------------
void CMapView3D::SetDrawType(DrawType_t eDrawType)
{
	EditorRenderMode_t eRenderMode;

	// Turn off the dialog.
	if ( m_eDrawType == VIEW3D_SMOOTHING_GROUP )
	{
		CMainFrame *pMainFrame = GetMainWnd();
		if ( pMainFrame )
		{		
			CFaceSmoothingVisualDlg *pSmoothDlg = pMainFrame->GetSmoothingGroupDialog();
			pSmoothDlg->ShowWindow( SW_HIDE );
		}
	}

	if (m_pwndTitle != NULL)
	{
		m_pwndTitle->SetTitle("camera");
	}

	m_bLightingPreview = false;
	switch (eDrawType)
	{
		case VIEW3D_WIREFRAME:
		{
			eRenderMode = RENDER_MODE_WIREFRAME;
			break;
		}

		case VIEW3D_POLYGON:
		{
			eRenderMode = RENDER_MODE_FLAT;
			break;
		}

		case VIEW3D_TEXTURED:
		{
			eRenderMode = RENDER_MODE_TEXTURED;
			break;
		}

		case VIEW3D_TEXTURED_SHADED:
		{
			eRenderMode = RENDER_MODE_TEXTURED_SHADED;
			break;
		}
		case VIEW3D_LIGHTMAP_GRID:
		{
			eRenderMode = RENDER_MODE_LIGHTMAP_GRID;
			break;
		}

		case VIEW3D_LIGHTING_PREVIEW2:
		{
			eRenderMode = RENDER_MODE_LIGHT_PREVIEW2;
			break;
		}
		
		case VIEW3D_LIGHTING_PREVIEW_RAYTRACED:
		{
			eRenderMode = RENDER_MODE_LIGHT_PREVIEW_RAYTRACED;
			break;
		}

		case VIEW3D_SMOOTHING_GROUP:
		{
			CMainFrame *pMainFrame = GetMainWnd();
			if ( pMainFrame )
			{		
				CFaceSmoothingVisualDlg *pSmoothDlg = pMainFrame->GetSmoothingGroupDialog();
				pSmoothDlg->ShowWindow( SW_SHOW );
			}

			// Always set the initial group to visualize (zero).
			CMapDoc *pDoc = GetMapDoc();
			pDoc->SetSmoothingGroupVisual( 0 );

			eRenderMode = RENDER_MODE_SMOOTHING_GROUP;
			break;
		}

		//case VIEW3D_ENGINE:
		//{
		//	eRenderMode = RENDER_MODE_TEXTURED;
		//	if ( IsRunningInEngine() )
		//	{
		//		CMapDoc *pMapDoc = CMapDoc::GetActiveMapDoc();
		//		if ( pMapDoc )
		//		{
		//			const char *pFullPathName = pMapDoc->GetPathName();
		//			if ( pFullPathName && pFullPathName[0] )
		//			{
		//				char buf[MAX_PATH];
		//				Q_FileBase( pFullPathName, buf,	MAX_PATH );
		//	
		//				// Don't do it if we're untitled
		//				//if ( !Q_stristr( buf, "untitled" ) )
		//				{
		//					g_pEngineAPI->SetEngineWindow( m_hWnd );
		//					//g_pEngineAPI->SetMap( buf );
		//					g_pEngineAPI->ActivateSimulation( true );
		//				}
		//			}
		//		}
		//	}
		//	if (m_pwndTitle != NULL)
		//	{
		//		m_pwndTitle->SetTitle("engine");
		//	}
		//	break;
		//}

		default:
		{
			Assert(FALSE);
			eDrawType = VIEW3D_WIREFRAME;
			eRenderMode = RENDER_MODE_WIREFRAME;
			break;
		}
	}

	m_eDrawType = eDrawType;

	//
	// Set renderer to use the new rendering mode.
	//
	if (m_pRender != NULL)
	{
		m_pRender->SetDefaultRenderMode(eRenderMode);
		m_pRender->SetInLightingPreview( m_bLightingPreview );

		// Somehow, this drop down box screws up MFC's notion
		// of what we're supposed to be updating. This is a workaround.
		m_pRender->ResetFocus();
	}
}


//-----------------------------------------------------------------------------
// Purpose: Sets the position and direction of the camera for this view.
//-----------------------------------------------------------------------------
void CMapView3D::SetCamera(const Vector &vecPos, const Vector &vecLookAt)
{
	m_pCamera->SetViewPoint(vecPos);
	m_pCamera->SetViewTarget(vecLookAt);
}

//-----------------------------------------------------------------------------
// Purpose: Prepares to print.
// Input  : Per CView::OnPreparePrinting.
// Output : Returns nonzero to begin printing, zero to cancel printing.
//-----------------------------------------------------------------------------
BOOL CMapView3D::OnPreparePrinting(CPrintInfo* pInfo)
{
	return(DoPreparePrinting(pInfo));
}


//-----------------------------------------------------------------------------
// Purpose: Debugging functions.
//-----------------------------------------------------------------------------
#ifdef _DEBUG
void CMapView3D::AssertValid() const
{
	CView::AssertValid();
}

void CMapView3D::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}
#endif //_DEBUG
 

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nIDEvent - 
//-----------------------------------------------------------------------------
void CMapView3D::OnTimer(UINT nIDEvent) 
{
	static bool s_bPicking = false; // picking mutex

	switch (nIDEvent)
	{
		case MVTIMER_PICKNEXT:
		{
			if ( !s_bPicking ) 
			{
				s_bPicking = true;
				// set current document hit
				GetMapDoc()->GetSelection()->SetCurrentHit(hitNext);
				s_bPicking = false;
			}
			break;
		}
	}

	CView::OnTimer(nIDEvent);
}


//-----------------------------------------------------------------------------
// Purpose: Called just before we are destroyed.
//-----------------------------------------------------------------------------
BOOL CMapView3D::DestroyWindow() 
{
	KillTimer(MVTIMER_PICKNEXT);
	return CView::DestroyWindow();
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMapView3D::UpdateStatusBar(void)
{
	if (!IsWindow(m_hWnd))
	{
		return;
	}

	SetStatusText(SBI_GRIDZOOM, "");
	SetStatusText(SBI_COORDS, "");
}


//-----------------------------------------------------------------------------
// Purpose: Sets up key bindings for the 3D view.
//-----------------------------------------------------------------------------
void CMapView3D::InitializeKeyMap(void)
{
	m_Keyboard.RemoveAllKeyMaps();

	if (!Options.view2d.bNudge)
	{
		m_Keyboard.AddKeyMap(VK_LEFT, 0, LOGICAL_KEY_YAW_LEFT);
		m_Keyboard.AddKeyMap(VK_RIGHT, 0, LOGICAL_KEY_YAW_RIGHT);
		m_Keyboard.AddKeyMap(VK_DOWN, 0, LOGICAL_KEY_PITCH_DOWN);
		m_Keyboard.AddKeyMap(VK_UP, 0, LOGICAL_KEY_PITCH_UP);

		m_Keyboard.AddKeyMap(VK_LEFT, KEY_MOD_SHIFT, LOGICAL_KEY_LEFT);
		m_Keyboard.AddKeyMap(VK_RIGHT, KEY_MOD_SHIFT, LOGICAL_KEY_RIGHT);
		m_Keyboard.AddKeyMap(VK_DOWN, KEY_MOD_SHIFT, LOGICAL_KEY_DOWN);
		m_Keyboard.AddKeyMap(VK_UP, KEY_MOD_SHIFT, LOGICAL_KEY_UP);
	}

	if (Options.view3d.bUseMouseLook)
	{
		m_Keyboard.AddKeyMap('W', 0, LOGICAL_KEY_FORWARD);
		m_Keyboard.AddKeyMap('A', 0, LOGICAL_KEY_LEFT);
		m_Keyboard.AddKeyMap('D', 0, LOGICAL_KEY_RIGHT);
		m_Keyboard.AddKeyMap('S', 0, LOGICAL_KEY_BACK);
	}
	else
	{
		m_Keyboard.AddKeyMap('D', 0, LOGICAL_KEY_FORWARD);
		m_Keyboard.AddKeyMap('C', 0, LOGICAL_KEY_BACK);
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pWnd - 
//			point - 
//-----------------------------------------------------------------------------
void CMapView3D::OnContextMenu(CWnd *pWnd, CPoint point)
{
    // Pass the message to the active tool.
	if ( !m_pToolManager ) 
		return;

	CBaseTool *pTool = m_pToolManager->GetActiveTool();
	if (pTool)
	{
		if ( pTool->OnContextMenu3D(this, 0, Vector2D(point.x, point.y) ) )
		{
			return;
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Handles the key down event.
// Input  : Per CWnd::OnKeyDown.
//-----------------------------------------------------------------------------
void CMapView3D::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	CMapDoc *pDoc = GetMapDoc();
	if (pDoc == NULL)
	{
		return;
	}

	//
	// 'z' toggles mouselook.
	//
	if (((char)tolower(nChar) == 'z') && !(nFlags & 0x4000) && (Options.view3d.bUseMouseLook))
	{
		CMapDoc *pDoc = GetMapDoc();
		if (pDoc != NULL)
		{
			EnableMouseLook(!m_bMouseLook);

			//
			// If we just stopped mouse looking, update the camera variables.
			//
			if (!m_bMouseLook)
			{
				UpdateCameraVariables();
			}
		}
		
		return;
	}

    // Got to check for m_pToolManager here because otherwise it can crash on startup if they have keys pressed.
    if ( m_pToolManager )
    {
		//
		// Pass the message to the active tool.
		//
		CBaseTool *pTool = m_pToolManager->GetActiveTool();
		if (pTool)
		{
			if (pTool->OnKeyDown3D(this, nChar, nRepCnt, nFlags))
			{
				return;
			}
		}
	}

	m_Keyboard.OnKeyDown(nChar, nRepCnt, nFlags);

	switch (nChar)
	{
		case VK_DELETE:
		{
			pDoc->OnCmdMsg(ID_EDIT_DELETE, CN_COMMAND, NULL, NULL);
			break;
		}

		case VK_NEXT:
		{
			pDoc->OnCmdMsg(ID_EDIT_SELNEXT, CN_COMMAND, NULL, NULL);
			break;
		}

		case VK_PRIOR:
		{
			pDoc->OnCmdMsg(ID_EDIT_SELPREV, CN_COMMAND, NULL, NULL);
			break;
		}

		//
		// Move the back clipping plane closer in.
		//
		case '1':
		{
			float fBack = m_pCamera->GetFarClip();
			if (fBack >= 2000)
			{
				m_pCamera->SetFarClip(fBack - 1000);
				Options.view3d.iBackPlane = fBack;
			}
			else if (fBack > 500)
			{
				m_pCamera->SetFarClip(fBack - 250);
				Options.view3d.iBackPlane = fBack;
			}
			m_bUpdateView = true;
			m_bClippingChanged = true;
			break;
		}

		//
		// Move the back clipping plane farther away.
		//
		case '2':
		{
			float fBack = m_pCamera->GetFarClip();
			if ((fBack <= 9000) && (fBack > 1000))
			{
				m_pCamera->SetFarClip(fBack + 1000);
				Options.view3d.iBackPlane = fBack;
			}
			else if (fBack < 10000)
			{
				m_pCamera->SetFarClip(fBack + 250);
				Options.view3d.iBackPlane = fBack;
			}
			m_bUpdateView = true;
			m_bClippingChanged = true;
			break;
		}

		case 'O':
		case 'o':
		{
			m_pRender->DebugHook1();
			break;
		}

		case 'I':
		case 'i':
		{
			m_pRender->DebugHook2();
			break;
		}

		case 'P':
		case 'p':
		{
			pDoc->OnToggle3DGrid();
			break;
		}

		default:
		{
			break;
		}
	}

	CView::OnKeyDown(nChar, nRepCnt, nFlags);
}


//-----------------------------------------------------------------------------
// Purpose: Handles key release events.
// Input  : Per CWnd::OnKeyup
//-----------------------------------------------------------------------------
void CMapView3D::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
    // Got to check for m_pToolManager here because otherwise it can crash on startup if they have keys pressed.
    if ( m_pToolManager )
    {
   		// Pass the message to the active tool.
		CBaseTool *pTool = m_pToolManager->GetActiveTool();
		if (pTool)
		{
			if (pTool->OnKeyUp3D(this, nChar, nRepCnt, nFlags))
			{
				return;
			}
		}

		m_Keyboard.OnKeyUp(nChar, nRepCnt, nFlags);

		UpdateCameraVariables();
	}
	
	CView::OnKeyUp(nChar, nRepCnt, nFlags);
}


//-----------------------------------------------------------------------------
// Purpose: Called when the view is resized.
// Input  : nType - 
//			cx - 
//			cy - 
//-----------------------------------------------------------------------------
void CMapView3D::OnSize(UINT nType, int cx, int cy) 
{
	if ( m_pCamera )
	{
		m_pCamera->SetViewPort( cx, cy );
	}

	CView::OnSize(nType, cx, cy);
}


//-----------------------------------------------------------------------------
// Purpose: Finds the axis that is most closely aligned with the given vector.
// Input  : Vector - Vector to find closest axis to.
// Output : Returns an axis index as follows:
//				0 - Positive X axis.
//				1 - Positive Y axis.
//				2 - Positive Z axis.
//				3 - Negative X axis.
//				4 - Negative Y axis.
//				5 - Negative Z axis.
//-----------------------------------------------------------------------------
const Vector&ClosestAxis(const Vector& v)
{
    static Vector vBestAxis;
	float fBestDot = -1;
	Vector vNormal = v;

	VectorNormalize( vNormal );
	vBestAxis.Init();
	
	for (int i = 0; i < 6; i++)
	{
		Vector vTestAxis(0,0,0);

		vTestAxis[i%3] = (i>=3)?-1:1;

		float fTestDot = DotProduct(v, vTestAxis);
		if (fTestDot > fBestDot)
		{
			fBestDot = fTestDot;
			vBestAxis = vTestAxis;
		}
	}

	return vBestAxis;
}

void CMapView3D::GetBestTransformPlane( Vector &horzAxis, Vector &vertAxis, Vector &thirdAxis)
{
	Vector vAxis;

 	m_pCamera->GetViewRight( vAxis );
	horzAxis = ClosestAxis( vAxis );
	
	m_pCamera->GetViewUp( vAxis );
	vertAxis = ClosestAxis( vAxis );

	m_pCamera->GetViewForward( vAxis );
	thirdAxis = ClosestAxis( vAxis );
}


//-----------------------------------------------------------------------------
// Purpose: Synchronizes the 2D camera information with the 3D view.
//-----------------------------------------------------------------------------
void CMapView3D::UpdateCameraVariables(void)
{
	Camera3D *pCamTool = dynamic_cast<Camera3D*>(m_pToolManager->GetToolForID( TOOL_CAMERA ));

	if (!m_pCamera || !pCamTool )
		return;
	
	Vector viewPoint,viewForward;
	
	m_pCamera->GetViewPoint(viewPoint);
	m_pCamera->GetViewForward(viewForward);

	// tell camera tool to update active camera
	pCamTool->UpdateActiveCamera( viewPoint, viewForward );
}


//-----------------------------------------------------------------------------
// Purpose: Handles the left mouse button double click event.
//-----------------------------------------------------------------------------
void CMapView3D::OnLButtonDblClk(UINT nFlags, CPoint point)
{
	//
	// Don't forward message if we are controlling the camera.
	//
	if ((GetAsyncKeyState(VK_SPACE) & 0x8000) != 0)
	{
		return;
	}

	//
	// Pass the message to the active tool.
	//
	if ( !m_pToolManager ) 
		return;
	CBaseTool *pTool = m_pToolManager->GetActiveTool(); 
	if (pTool != NULL)
	{
		Vector2D vPoint( point.x,point.y);
		if (pTool->OnLMouseDblClk3D( this, nFlags, vPoint ))
		{
			return;
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Handles the left mouse button down event.
//-----------------------------------------------------------------------------
void CMapView3D::OnLButtonDown(UINT nFlags, CPoint point) 
{
	if ((GetAsyncKeyState(VK_SPACE) & 0x8000) != 0)
	{
		EnableRotating(true);
		return;
	}

    //
	// Pass the message to the active tool.
    //
	if ( m_pToolManager != NULL )
	{
		CBaseTool *pTool = m_pToolManager->GetActiveTool();
		if (pTool != NULL)
		{
			Vector2D vPoint( point.x,point.y);
			if (pTool->OnLMouseDown3D(this, nFlags, vPoint))
			{
				return;
			}
		}
	}

	CView::OnLButtonDown(nFlags, point);
}


//-----------------------------------------------------------------------------
// Purpose: Called by the selection tool to begin timed selection by depth.
//-----------------------------------------------------------------------------
void CMapView3D::BeginPick(void)
{
	SetTimer(MVTIMER_PICKNEXT, 500, NULL);
}


//-----------------------------------------------------------------------------
// Purpose: Called by the selection tool to end timed selection by depth.
//-----------------------------------------------------------------------------
void CMapView3D::EndPick(void)
{
	//
	// Kill pick timer.
	//
	KillTimer(MVTIMER_PICKNEXT);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nFlags - 
//			point - 
//-----------------------------------------------------------------------------
void CMapView3D::OnLButtonUp(UINT nFlags, CPoint point) 
{
	if (m_bRotating)
	{
		EnableRotating(false);
		UpdateCameraVariables();
		return;
	}

	//
	// Pass the message to the active tool.
	//
	if ( m_pToolManager != NULL )
	{
		CBaseTool *pTool = m_pToolManager->GetActiveTool();
		if (pTool != NULL)
		{
			Vector2D vPoint( point.x,point.y);
			if (pTool->OnLMouseUp3D(this, nFlags, vPoint))
			{
				return;
			}
		}
	}

	CView::OnLButtonUp(nFlags, point);
}


//-----------------------------------------------------------------------------
// Purpose: Creates the renderer and the camera and initializes them.
//-----------------------------------------------------------------------------
void CMapView3D::OnInitialUpdate(void)
{
	InitializeKeyMap();

	//
	// Create a title window.
	//
	m_pwndTitle = CTitleWnd::CreateTitleWnd(this, ID_2DTITLEWND);
	Assert(m_pwndTitle != NULL);
	if (m_pwndTitle != NULL)
	{
		m_pwndTitle->SetTitle("camera");
	}

	//
	// CMainFrame::LoadWindowStates calls InitialUpdateFrame which causes us to get two
	// OnInitialUpdate messages! Check for a NULL renderer to avoid processing twice.
	//
	if (m_pRender != NULL)
	{
		return;
	}

	//
	// Create and initialize the renderer.
	//
	m_pRender = new CRender3D();
	
	CMapDoc *pDoc = GetMapDoc();
	if (pDoc == NULL)
	{
		Assert(pDoc != NULL);
		return;
	}

	m_pRender->SetView( this );

	m_pToolManager = pDoc->GetTools();

	SetDrawType(m_eDrawType);

	
	//
	// Create and initialize the camera.
	//
	m_pCamera = new CCamera();
	Assert(m_pCamera != NULL);
	if (m_pCamera == NULL)
	{
		return;
	}

	CRect rect;
	GetClientRect( rect );
	m_pCamera->SetViewPort( rect.Width(), rect.Height() );

	m_fForwardSpeedMax = Options.view3d.nForwardSpeedMax;
	m_fStrafeSpeedMax = Options.view3d.nForwardSpeedMax * 0.75f;
	m_fVerticalSpeedMax = Options.view3d.nForwardSpeedMax * 0.5f;

	//
	// Calculate the acceleration based on max speed and the time to max speed.
	//
	if (Options.view3d.nTimeToMaxSpeed != 0)
	{
		m_fForwardAcceleration = m_fForwardSpeedMax / (Options.view3d.nTimeToMaxSpeed / 1000.0f);
		m_fStrafeAcceleration = m_fStrafeSpeedMax / (Options.view3d.nTimeToMaxSpeed / 1000.0f);
		m_fVerticalAcceleration = m_fVerticalSpeedMax / (Options.view3d.nTimeToMaxSpeed / 1000.0f);
	}
	else
	{
		m_fForwardAcceleration = 0;
		m_fStrafeAcceleration = 0;
		m_fVerticalAcceleration = 0;
	}

	//
	// Set up the frustum. We set the vertical FOV to zero because the renderer
	// only uses the horizontal FOV.
	//
	m_pCamera->SetPerspective( CMapEntity::GetShowDotACamera() ? 65.0f : Options.view3d.fFOV, CAMERA_FRONT_PLANE_DISTANCE, Options.view3d.iBackPlane);

	//
	// Set the distance at which studio models become bounding boxes.
	//
	CMapStudioModel::SetRenderDistance(Options.view3d.nModelDistance);
	CMapStudioModel::EnableAnimation(Options.view3d.bAnimateModels);

	//
	// Enable or disable reverse selection.
	//
	m_pRender->RenderEnable(RENDER_REVERSE_SELECTION, (Options.view3d.bReverseSelection == TRUE));

	//
	// Enable or disable the 3D grid.
	//
	m_pRender->RenderEnable(RENDER_GRID, pDoc->Is3DGridEnabled());

	//
	// Enable or disable texture filtering.
	//
	m_pRender->RenderEnable(RENDER_FILTER_TEXTURES, (Options.view3d.bFilterTextures == TRUE));

	// Get the initial viewpoint and view direction from the default camera in the document.

	Camera3D *pCamTool = dynamic_cast<Camera3D*>(m_pToolManager->GetToolForID( TOOL_CAMERA ));
	if ( pCamTool )
	{
		Vector vecPos,vecLookAt;
		pCamTool->GetCameraPos( vecPos,vecLookAt );
		SetCamera(vecPos, vecLookAt);
	}

	CView::OnInitialUpdate();
}


//-----------------------------------------------------------------------------
// Purpose: Turns on wireframe mode from the floating "Camera" menu.
//-----------------------------------------------------------------------------
void CMapView3D::OnView3dWireframe(void)
{
	SetDrawType(VIEW3D_WIREFRAME);
}


//-----------------------------------------------------------------------------
// Purpose: Turns on flat shaded mode from the floating "Camera" menu.
//-----------------------------------------------------------------------------
void CMapView3D::OnView3dPolygon(void)
{
	SetDrawType(VIEW3D_POLYGON);
}


//-----------------------------------------------------------------------------
// Purpose: Turns on textured mode from the floating "Camera" menu.
//-----------------------------------------------------------------------------
void CMapView3D::OnView3dTextured(void)
{
	SetDrawType(VIEW3D_TEXTURED);
}


//-----------------------------------------------------------------------------
// Purpose: Turns on lightmap grid mode from the floating "Camera" menu.
//-----------------------------------------------------------------------------
void CMapView3D::OnView3dLightmapGrid(void)
{
	SetDrawType(VIEW3D_LIGHTMAP_GRID);
}


//-----------------------------------------------------------------------------
// Purpose: Turns on lighting preview mode from the floating "Camera" menu.
//-----------------------------------------------------------------------------
void CMapView3D::OnView3dLightingPreview(void)
{
	SetDrawType(VIEW3D_LIGHTING_PREVIEW2);
}

void CMapView3D::OnView3dLightingPreviewRayTraced(void)
{
	SetDrawType(VIEW3D_LIGHTING_PREVIEW_RAYTRACED);
}

//-----------------------------------------------------------------------------
// Purpose: Turns on engine mode from the floating "Camera" menu.
//-----------------------------------------------------------------------------
//void CMapView3D::OnView3dEngine(void)
//{
//	SetDrawType(VIEW3D_ENGINE);
//}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : bActivate - 
//			pActivateView - 
//			pDeactiveView - 
//-----------------------------------------------------------------------------
void CMapView3D::ActivateView(bool bActivate)
{
	CMapView::ActivateView(bActivate);

	if (bActivate)
	{
		CMapDoc *pDoc = GetMapDoc();
		CMapDoc::SetActiveMapDoc(pDoc);
		
		UpdateStatusBar();

		// tell doc to update title
		pDoc->UpdateTitle(this);

		m_Keyboard.ClearKeyStates();

		//
		// Reset the last input sample time.
		//
		m_dwTimeLastInputSample = 0;
	}
}

void CMapView3D::OnDraw(CDC *pDC)
{
	CWnd *focusWnd = GetForegroundWindow();

	if ( focusWnd && focusWnd->ContinueModal() )
	{
		// render the view now since were not running the main loop
		RenderView();
	}
	else
	{
		// just flag view to be update with next main loop
		m_bUpdateView = true;
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapView3D::RenderView()
{
	RenderView2( false );
}


void CMapView3D::RenderView2( bool bRenderingOverEngine )
{
	Render( bRenderingOverEngine );
	m_bUpdateView = false;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CMapView3D::ShouldRender()
{
	if ( m_eDrawType == VIEW3D_LIGHTING_PREVIEW_RAYTRACED )
	{
		// check if we have new results from lpreview thread
// 		if ( m_nLastRaytracedBitmapRenderTimeStamp != 
// 			 GetUpdateCounter( EVTYPE_BITMAP_RECEIVED_FROM_LPREVIEW ) )
// 			return true;
	}
	else
	{
		// don't animate ray traced displays
		if ( Options.view3d.bAnimateModels )
		{
			DWORD dwTimeElapsed = timeGetTime() - m_dwTimeLastRender;
			
			if ( (dwTimeElapsed/1000.0f) > 1.0f/20.0f)
			{
				m_bUpdateView = true;
			}
		}
	}
	return CMapView::ShouldRender();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pDC - 
//-----------------------------------------------------------------------------
void CMapView3D::OnSetFocus(CWnd *pOldWnd)
{
	// Make sure the whole window region is marked as invalid 
	m_bUpdateView = true;
}


//-----------------------------------------------------------------------------
// Purpose: Called to paint the non client area of the window.
//-----------------------------------------------------------------------------
void CMapView3D::OnNcPaint(void)
{
	// Make sure the whole window region is marked as invalid 
	m_bUpdateView = true;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pSender - 
//			lHint - 
//			pHint - 
//-----------------------------------------------------------------------------
void CMapView3D::UpdateView(int nFlags)
{
	if ( !m_pRender )
		return;

	if (nFlags & ( MAPVIEW_UPDATE_ONLY_2D | MAPVIEW_UPDATE_ONLY_LOGICAL ) )
		return;
	
	//
	// One of the options in the 3D options page is changing.
	//
	if (nFlags & MAPVIEW_OPTIONS_CHANGED)
	{
		InitializeKeyMap();

		CMapStudioModel::SetRenderDistance(Options.view3d.nModelDistance);
		CMapStudioModel::EnableAnimation(Options.view3d.bAnimateModels);

		m_pRender->RenderEnable(RENDER_REVERSE_SELECTION, (Options.view3d.bReverseSelection == TRUE));

		m_fForwardSpeedMax = Options.view3d.nForwardSpeedMax;
		m_fStrafeSpeedMax = Options.view3d.nForwardSpeedMax * 0.75f;
		m_fVerticalSpeedMax = Options.view3d.nForwardSpeedMax * 0.5f;

		//
		// Calculate the acceleration based on max speed and the time to max speed.
		//
		if (Options.view3d.nTimeToMaxSpeed != 0)
		{
			m_fForwardAcceleration = m_fForwardSpeedMax / (Options.view3d.nTimeToMaxSpeed / 1000.0f);
			m_fStrafeAcceleration = m_fStrafeSpeedMax / (Options.view3d.nTimeToMaxSpeed / 1000.0f);
			m_fVerticalAcceleration = m_fVerticalSpeedMax / (Options.view3d.nTimeToMaxSpeed / 1000.0f);
		}
		else
		{
			m_fForwardAcceleration = 0;
			m_fStrafeAcceleration = 0;
			m_fVerticalAcceleration = 0;
		}

		m_pCamera->SetPerspective( CMapEntity::GetShowDotACamera() ? 65.0f : Options.view3d.fFOV, CAMERA_FRONT_PLANE_DISTANCE, Options.view3d.iBackPlane);
		
		CMapDoc *pDoc = GetMapDoc();
		if ((pDoc != NULL) && (m_pRender != NULL))
		{
			m_pRender->RenderEnable(RENDER_GRID, pDoc->Is3DGridEnabled());
			m_pRender->RenderEnable(RENDER_FILTER_TEXTURES, (Options.view3d.bFilterTextures == TRUE));
		}
	}

	if (nFlags & MAPVIEW_UPDATE_OBJECTS)
	{
		// dvs: could use this hint to update the octree
	}

	CMapView::UpdateView( nFlags );
}


//-----------------------------------------------------------------------------
// Purpose: Determines the object at the point (point.x, point.y) in the 3D view.
// Input  : point - Point to use for hit test.
//			ulFace - Index of face in object that was hit.
// Output : Returns a pointer to the CMapClass object at the coordinates, NULL if none.
//-----------------------------------------------------------------------------
CMapClass *CMapView3D::NearestObjectAt( const Vector2D &vPoint, ULONG &ulFace, unsigned int nFlags, VMatrix *pLocalMatrix )
{
	ulFace = 0;
	if (m_pRender == NULL)
	{
		return(NULL);
	}

	HitInfo_t Hits;

	if (m_pRender->ObjectsAt( vPoint.x, vPoint.y, 1, 1, &Hits, 1, nFlags ) != 0)
	{
		//
		// If they clicked on a solid, the index of the face they clicked on is stored
		// in array index [1].
		//
		CMapAtom *pObject = (CMapAtom *)Hits.pObject;
		CMapSolid *pSolid = dynamic_cast<CMapSolid *>(pObject);
		if ( pLocalMatrix != NULL )
		{
			*pLocalMatrix = Hits.m_LocalMatrix;
		}
		if (pSolid != NULL)
		{
			ulFace = Hits.uData;
			return(pSolid);
		}

		return((CMapClass *)pObject);
	}

	return(NULL);
}


//-----------------------------------------------------------------------------
// Purpose: Casts a ray from the viewpoint through the given plane and determines
//			the point of intersection of the ray on the plane.
// Input  : point - Point in client screen coordinates.
//			plane - Plane being 'clicked' on.
//			pos - Returns the point on the plane that projects to the given point.
//-----------------------------------------------------------------------------
void CMapView3D::GetHitPos(const Vector2D &point, PLANE &plane, Vector &pos)
{
	//
	// Find the point they clicked on in world coordinates. It lies on the near
	// clipping plane.
	//
	Vector ClickPoint;

	ClientToWorld( ClickPoint, point );
	
	//
	// Build a ray from the viewpoint through the point on the near clipping plane.
	//
	Vector ViewPoint;
	Vector Ray;
	m_pCamera->GetViewPoint(ViewPoint);
	VectorSubtract(ClickPoint, ViewPoint, Ray);

	//
	// Find the point of intersection of the ray with the given plane.
	//
	float t = DotProduct(plane.normal, ViewPoint) - plane.dist;
	t = t / -DotProduct(plane.normal, Ray);
	
	pos = ViewPoint + t * Ray;
}

bool CMapView3D::HitTest( const Vector2D &vPoint, const Vector& mins, const Vector& maxs)
{
	Vector vStart, vEnd;
	int nFace;
	BuildRay( vPoint, vStart, vEnd );
	return IntersectionLineAABBox( mins, maxs, vStart, vEnd, nFace ) >= 0.0f;
}

//-----------------------------------------------------------------------------
// Purpose: Finds all objects under the given rectangular region in the view.
// Input  : x - Client x coordinate.
//			y - Client y coordinate.
//			fWidth - Width of region in client pixels.
//			fHeight - Height of region in client pixels.
//			pObjects - Receives objects in the given region.
//			nMaxObjects - Size of the array pointed to by pObjects.
// Output : Returns the number of objects in the given region.
//-----------------------------------------------------------------------------
int CMapView3D::ObjectsAt( const Vector2D &vPoint, HitInfo_t *pObjects, int nMaxObjects, unsigned int nFlags )
{
	if (m_pRender != NULL)
	{
		return m_pRender->ObjectsAt( vPoint.x, vPoint.y, 1, 1, pObjects, nMaxObjects, nFlags );
	}

	return 0;
}


//-----------------------------------------------------------------------------
// Purpose: Makes sure that this view has focus if the mouse moves over it.
//-----------------------------------------------------------------------------
void CMapView3D::OnMouseMove(UINT nFlags, CPoint point)
{
	//
	// Make sure we are the active view.
	//
	if (!IsActive())
	{
		CMapDoc *pDoc = GetMapDoc();
		pDoc->SetActiveView(this);
	}

	//
	// If we are the active application, make sure this view has the input focus.
	//	
	if (APP()->IsActiveApp())
	{
		if (GetFocus() != this)
		{
			SetFocus();
		}
	}


	CView::OnMouseMove(nFlags, point);
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMapView3D::ProcessInput(void)
{
	if (m_dwTimeLastInputSample == 0)
	{
		m_dwTimeLastInputSample = timeGetTime();
	}

	DWORD dwTimeNow = timeGetTime();

	float fElapsedTime = (float)(dwTimeNow - m_dwTimeLastInputSample) / 1000.0f;

	m_dwTimeLastInputSample = dwTimeNow;

	// Clamp (can get really big when we cache textures in )
	if (fElapsedTime > 0.3f)
	{
		fElapsedTime = 0.3f;
	}
	else if ( fElapsedTime <=0 )
	{
		return; // dont process input
	}

	ProcessKeys( fElapsedTime );

	ProcessMouse();

	if ( Options.general.bRadiusCulling )
	{
		ProcessCulling();
	}
}


//-----------------------------------------------------------------------------
// Purpose: Applies an acceleration to a velocity, allowing instantaneous direction
//			change and zeroing the velocity in the absence of acceleration.
// Input  : fVelocity - Current velocity.
//			fAccel - Amount of acceleration to apply.
//			fTimeScale - The time for which the acceleration should be applied.
//			fMaxVelocity - The maximum velocity to allow.
// Output : Returns the new velocity.
//-----------------------------------------------------------------------------
static float Accelerate(float fVelocity, float fAccel, float fAccelScale, float fTimeScale, float fVelocityMax)
{
	//
	// If we have a finite acceleration in this direction, apply it to the velocity.
	//
	if ((fAccel != 0) && (fAccelScale != 0))
	{
		//
		// Check for direction reversal - zero velocity when reversing.
		//
		if (fAccelScale > 0)
		{
			if (fVelocity < 0)
			{
				fVelocity = 0;
			}
		}
		else if (fAccelScale < 0)
		{
			if (fVelocity > 0)
			{
				fVelocity = 0;
			}
		}

		//
		// Apply the acceleration.
		//
		fVelocity += fAccel * fAccelScale * fTimeScale;
		if (fVelocity > fVelocityMax)
		{
			fVelocity = fVelocityMax;
		}
		else if (fVelocity < -fVelocityMax)
		{
			fVelocity = -fVelocityMax;
		}

	}
	//
	// If we have infinite acceleration, go straight to maximum velocity.
	//
	else if (fAccelScale != 0)
	{
		fVelocity = fVelocityMax * fAccelScale;
	}
	//
	// Else no velocity in this direction at all.
	//
	else
	{
		fVelocity = 0;
	}

	return(fVelocity);
}


//-----------------------------------------------------------------------------
// Purpose: Moves the camera based on the keyboard state.
//-----------------------------------------------------------------------------
void CMapView3D::ProcessMovementKeys(float fElapsedTime)
{
	//
	// Read the state of the camera movement keys.
	//
	float fBack = m_Keyboard.GetKeyScale(LOGICAL_KEY_BACK);
	float fMoveForward = m_Keyboard.GetKeyScale(LOGICAL_KEY_FORWARD) - fBack;

	float fLeft = m_Keyboard.GetKeyScale(LOGICAL_KEY_LEFT);
	float fMoveRight = m_Keyboard.GetKeyScale(LOGICAL_KEY_RIGHT) - fLeft;

	float fDown = m_Keyboard.GetKeyScale(LOGICAL_KEY_DOWN);
	float fMoveUp = m_Keyboard.GetKeyScale(LOGICAL_KEY_UP) - fDown;

	float fPitchUp = m_Keyboard.GetKeyScale(LOGICAL_KEY_PITCH_UP);
	float fPitchDown = m_Keyboard.GetKeyScale(LOGICAL_KEY_PITCH_DOWN);

	float fYawLeft = m_Keyboard.GetKeyScale(LOGICAL_KEY_YAW_LEFT);
	float fYawRight = m_Keyboard.GetKeyScale(LOGICAL_KEY_YAW_RIGHT);

	//
	// Apply pitch and yaw if they are nonzero.
	//
	if ((fPitchDown - fPitchUp) != 0)
	{
		m_pCamera->Pitch((fPitchDown - fPitchUp) * fElapsedTime * PITCH_SPEED);
		m_bUpdateView = true;
	}

	if ((fYawRight - fYawLeft) != 0)
	{
		m_pCamera->Yaw((fYawRight - fYawLeft) * fElapsedTime * YAW_SPEED);
		m_bUpdateView = true;
	}

	//
	// Apply the accelerations to the forward, strafe, and vertical speeds. They are actually
	// velocities because they are signed values.
	//
	m_fForwardSpeed = Accelerate(m_fForwardSpeed, m_fForwardAcceleration, fMoveForward, fElapsedTime, m_fForwardSpeedMax);
	m_fStrafeSpeed = Accelerate(m_fStrafeSpeed, m_fStrafeAcceleration, fMoveRight, fElapsedTime, m_fStrafeSpeedMax);
	m_fVerticalSpeed = Accelerate(m_fVerticalSpeed, m_fVerticalAcceleration, fMoveUp, fElapsedTime, m_fVerticalSpeedMax);

	if ( CMapEntity::GetShowDotACamera() )
	{
		CMapDoc *pDoc = (CMapDoc *)GetDocument();

		Vector vForward;
		m_pCamera->GetViewForward( vForward );

		Vector vViewpoint;
		m_pCamera->GetViewPoint( vViewpoint );

		Vector vHitLoc;
		bool bHit = pDoc->PickTrace( vViewpoint, vForward, &vHitLoc );

		if ( !bHit )
		{
			vHitLoc = vViewpoint + ( vForward * 1500.0f );
		}

		Vector vDirection = vHitLoc - vViewpoint;
		VectorNormalize( vDirection );

		Vector vNewViewpoint = vHitLoc - vDirection * 1500.0f;

		m_fForwardSpeed *= 2.0f;
		m_fStrafeSpeed *= 2.0f;

		m_pCamera->SetPitch( 65.0f );
		m_pCamera->SetRoll( 0.0f );
		m_pCamera->SetYaw( 0.0f );
		m_pCamera->Move( Vector( m_fStrafeSpeed * fElapsedTime + ( vNewViewpoint.x - vViewpoint.x ), m_fForwardSpeed * fElapsedTime + ( vNewViewpoint.y - vViewpoint.y ), vNewViewpoint.z - vViewpoint.z ) );
		m_bUpdateView = true;
		m_bCameraPosChanged = true;
	}
	else
	{
		//
		// Move the camera if any of the speeds are nonzero.
		//
		if (m_fForwardSpeed != 0)
		{
			m_pCamera->MoveForward(m_fForwardSpeed * fElapsedTime);
			m_bUpdateView = true;
			m_bCameraPosChanged = true;
		}

		if (m_fStrafeSpeed != 0)
		{
			m_pCamera->MoveRight(m_fStrafeSpeed * fElapsedTime);
			m_bUpdateView = true;
			m_bCameraPosChanged = true;
		}

		if (m_fVerticalSpeed != 0)
		{
			m_pCamera->MoveUp(m_fVerticalSpeed * fElapsedTime);
			m_bUpdateView = true;
			m_bCameraPosChanged = true;
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMapView3D::ProcessKeys(float fElapsedTime)
{
	ProcessMovementKeys(fElapsedTime);

	m_Keyboard.ClearImpulseFlags();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMapView3D::ProcessCulling( void )
{
	if ( m_bCameraPosChanged || m_bClippingChanged )
	{
		CMapDoc *pDoc = GetMapDoc();
		pDoc->UpdateVisibilityAll();

		m_bClippingChanged = false;
		m_bCameraPosChanged = false;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CMapView3D::ControlCamera(const CPoint &point)
{
	if (!m_bStrafing && !m_bRotating && !m_bMouseLook)
	{
		return false;
	}

	bool bShift = ((GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0);

	CRect rect;
	GetClientRect(&rect);
	// get mouse distance to client window center
	CPoint WindowCenter = rect.CenterPoint();
	CSize MouseLookDelta = point - WindowCenter;

	// camera look is on, but no mouse changes
	if ( MouseLookDelta.cx == 0 && MouseLookDelta.cy == 0 )
		true;
	
	//
	// If strafing, left-right movement moves the camera from side to side.
	// Up-down movement either moves the camera forward and back if the SHIFT
	// key is held down, or up and down if the SHIFT key is not held down.
	// If rotating and strafing simultaneously, the behavior is as if SHIFT is
	// held down.
	//
	if (m_bStrafing)
	{
		if (bShift || m_bRotating)
		{
			MoveForward(-MouseLookDelta.cy * 2);
		}
		else
		{
			MoveUp(-MouseLookDelta.cy * 2);
		}

		MoveRight(MouseLookDelta.cx * 2);

		m_bCameraPosChanged = true;
	}
	//
	// If mouse looking, left-right movement controls yaw, and up-down
	// movement controls pitch.
	//
	else
	{
		//
		// Up-down mouse movement changes the camera pitch.
		//
		if (MouseLookDelta.cy)
		{
			float fTheta = MouseLookDelta.cy * 0.4;
			if (Options.view3d.bReverseY)
			{
				fTheta = -fTheta;
			}

			Pitch(fTheta);
		}
	
		//
		// Left-right mouse movement changes the camera yaw.
		//
		if (MouseLookDelta.cx)
		{
			float fTheta = MouseLookDelta.cx * 0.4;
			Yaw(fTheta);
		}
	}

	// move mouse back to center
	CWnd::ClientToScreen(&WindowCenter);
	SetCursorPos(WindowCenter.x, WindowCenter.y);
	m_bUpdateView = true;

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Called by RunFrame to tell this view to process mouse input. This
//			function samples the cursor position and takes the appropriate
//			action based on the current mode (camera, morphing).
//-----------------------------------------------------------------------------
void CMapView3D::ProcessMouse(void)
{
	//
	// Get the cursor position in client coordinates.
	//

	CPoint point;
	GetCursorPos(&point);
	ScreenToClient(&point);

	if ( point == m_ptLastMouseMovement )
		return;

	m_ptLastMouseMovement = point;

	if ( ControlCamera( point ) )
	{
		return;
	}

	// If not in mouselook mode, only process mouse messages if there
	// is an active tool.
	//
	CBaseTool *pTool = m_pToolManager->GetActiveTool();
	if (pTool != NULL)
	{
		//
		// Pass the message to the tool.
		//

		int nFlags = 0;

		if ((GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0)
		{
			nFlags |= MK_CONTROL;
		}

		if ((GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0)
		{
			nFlags |= MK_SHIFT;
		}

		Vector2D vPoint( point.x,point.y);
		pTool->OnMouseMove3D(this, nFlags, vPoint);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Handles mouse wheel events. The mouse wheel is used in camera mode
//			to dolly the camera forward and back.
// Input  : Per CWnd::OnMouseWheel.
//-----------------------------------------------------------------------------
BOOL CMapView3D::OnMouseWheel(UINT nFlags, short zDelta, CPoint point)
{
    //
	// Pass the message to the active tool.
    //
	if ( m_pToolManager != NULL )
	{
		CBaseTool *pTool = m_pToolManager->GetActiveTool();
		if (pTool != NULL)
		{
			Vector2D vPoint( point.x,point.y);
			if (pTool->OnMouseWheel3D(this, nFlags, zDelta, vPoint))
			{
				return(TRUE);
			}
		}
	}

	m_pCamera->MoveForward(zDelta / 2);
	
	//
	// Render now to avoid an ugly lag between the 2D views and the 3D view
	// when "center 2D views on camera" is enabled.
	//
	m_bUpdateView = true;
	m_bCameraPosChanged = true;

	UpdateCameraVariables();

	return CView::OnMouseWheel(nFlags, zDelta, point);
}


//-----------------------------------------------------------------------------
// Purpose: Handles right mouse button down events.
// Input  : Per CWnd::OnRButtonDown.
//-----------------------------------------------------------------------------
void CMapView3D::OnRButtonDown(UINT nFlags, CPoint point) 
{
	if ((GetAsyncKeyState(VK_SPACE) & 0x8000) != 0)
	{
		EnableStrafing(true);
		return;
	}

	//
	// Pass the message to the active tool.
	//
	if ( m_pToolManager != NULL )
	{
		CBaseTool *pTool = m_pToolManager->GetActiveTool();
		if (pTool != NULL)
		{
			Vector2D vPoint( point.x,point.y);
			if (pTool->OnRMouseDown3D( this, nFlags, vPoint ))
			{
				return;
			}
		}
	}

	CView::OnRButtonDown(nFlags, point);
}


//-----------------------------------------------------------------------------
// Purpose: Handles right mouse button up events.
// Input  : Per CWnd::OnRButtonUp.
//-----------------------------------------------------------------------------
void CMapView3D::OnRButtonUp(UINT nFlags, CPoint point)
{
	if (m_bStrafing)
	{
		//
		// Turn off strafing and update the 2D views.
		//
		EnableStrafing(false);
		UpdateCameraVariables();
		return;
	}

	//
	// Pass the message to the active tool.
	//
	if ( m_pToolManager != NULL )
	{
		CBaseTool *pTool = m_pToolManager->GetActiveTool();
		if (pTool != NULL)
		{
			Vector2D vPoint( point.x,point.y);
			if (pTool->OnRMouseUp3D( this, nFlags, vPoint ))
			{
				return;
			}
		}
	}

	CView::OnRButtonUp(nFlags, point);
}


//-----------------------------------------------------------------------------
// Purpose: Handles character events.
// Input  : Per CWnd::OnChar.
//-----------------------------------------------------------------------------
void CMapView3D::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
    // Got to check for m_pToolManager here because otherwise it can crash on startup if they have keys pressed.
    if ( m_pToolManager )
    {
		//
		// Pass the message to the active tool.
		//
		CBaseTool *pTool = m_pToolManager->GetActiveTool();
		if (pTool != NULL)
		{
			if (pTool->OnChar3D(this, nChar, nRepCnt, nFlags))
			{
				return;
			}
		}
	}

	CView::OnChar(nChar, nRepCnt, nFlags);
}


//-----------------------------------------------------------------------------
// Purpose: Called when mouselook is enabled. The cursor is moved to the center
//			of the screen and hidden.
// Input  : bEnable - true to lock and hide the cursor, false to unlock and show it.
//-----------------------------------------------------------------------------
void CMapView3D::EnableCrosshair(bool bEnable)
{
	CRect Rect;
	CPoint Point;

	GetClientRect(&Rect);
	CWnd::ClientToScreen(&Rect);
	Point = Rect.CenterPoint();
	SetCursorPos(Point.x, Point.y);

	if (bEnable)
	{
		ClipCursor(&Rect);
	}
	else
	{
		ClipCursor(NULL);
	}

	ShowCursor(bEnable ? FALSE : TRUE);
	m_pRender->RenderEnable(RENDER_CENTER_CROSSHAIR, bEnable);
}


//-----------------------------------------------------------------------------
// Purpose: Enables or disables mouselook. When mouselooking, the cursor is hidden
//			and a crosshair is rendered in the center of the view.
// Input  : bEnable - TRUE to enable, FALSE to disable mouselook.
//-----------------------------------------------------------------------------
//void CMapView3D::EnableMouseLook(bool bEnable)
//{
//	if (m_bMouseLook != bEnable)
//	{
//		CMapDoc *pDoc = GetDocument();
//		if (pDoc != NULL)
//		{
//			EnableCrosshair(bEnable);
//			m_bMouseLook = bEnable;
//		}
//	}
//}


//-----------------------------------------------------------------------------
// Purpose: Enables or disables mouselook. When mouselooking, the cursor is hidden
//			and a crosshair is rendered in the center of the view.
//-----------------------------------------------------------------------------
void CMapView3D::EnableMouseLook(bool bEnable)
{
	if (m_bMouseLook != bEnable)
	{
		if (!(m_bStrafing || m_bRotating))
		{
			EnableCrosshair(bEnable);
		}

		m_bMouseLook = bEnable;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Enables or disables camera rotating. When rotating, the cursor is hidden
//			and a crosshair is rendered in the center of the view.
//-----------------------------------------------------------------------------
void CMapView3D::EnableRotating(bool bEnable)
{
	if (m_bRotating != bEnable)
	{
		if (!(m_bStrafing || m_bMouseLook))
		{
			EnableCrosshair(bEnable);
		}

		m_bRotating = bEnable;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Enables or disables camera strafing. When strafing, the cursor is hidden
//			and a crosshair is rendered in the center of the view.
//-----------------------------------------------------------------------------
void CMapView3D::EnableStrafing(bool bEnable)
{
	if (m_bStrafing != bEnable)
	{
		if (!(m_bMouseLook || m_bRotating))
		{
			EnableCrosshair(bEnable);
		}

		m_bStrafing = bEnable;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Actually renders the 3D view. Called from the frame loop and from
//			some mouse messages when timely updating is important.
//-----------------------------------------------------------------------------
void CMapView3D::Render( bool bRenderingOverEngine )
{
	if ( m_pRender != NULL )
	{
		m_pRender->Render( bRenderingOverEngine );
	}

	if (m_pwndTitle != NULL)
	{
		m_pwndTitle->BringWindowToTop();
		m_pwndTitle->Invalidate();
		m_pwndTitle->UpdateWindow();
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pObject - 
//-----------------------------------------------------------------------------
void CMapView3D::RenderPreloadObject(CMapAtom *pObject)
{
	if ((pObject != NULL) && (m_pRender != NULL))
	{
		pObject->RenderPreload(m_pRender, false);
	}
}


//-----------------------------------------------------------------------------
// Release all video memory.
//-----------------------------------------------------------------------------
void CMapView3D::ReleaseVideoMemory(void)
{
	m_pRender->UncacheAllTextures();
}


void CMapView3D::Foundry_OnLButtonDown( int x, int y )
{
	OnLButtonDown( 0, CPoint( x, y ) );
}


//-----------------------------------------------------------------------------
// Purpose: Moves the camera forward by flDistance units. Negative units move back.
//-----------------------------------------------------------------------------
void CMapView3D::MoveForward(float flDistance)
{
	if (m_pCamera != NULL)
	{
		m_pCamera->MoveForward(flDistance);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Moves the camera up by flDistance units. Negative units move down.
//-----------------------------------------------------------------------------
void CMapView3D::MoveUp(float flDistance)
{
	if (m_pCamera != NULL)
	{
		m_pCamera->MoveUp(flDistance);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Moves the camera right by flDistance units. Negative units move left.
//-----------------------------------------------------------------------------
void CMapView3D::MoveRight(float flDistance)
{
	if (m_pCamera != NULL)
	{
		m_pCamera->MoveRight(flDistance);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Pitches the camera forward by flDegrees degrees. Negative units pitch back.
//-----------------------------------------------------------------------------
void CMapView3D::Pitch(float flDegrees)
{
	if (m_pCamera != NULL)
	{
		m_pCamera->Pitch(flDegrees);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Yaws the camera left by flDegrees degrees. Negative units yaw right.
//-----------------------------------------------------------------------------
void CMapView3D::Yaw(float flDegrees)
{
	if (m_pCamera != NULL)
	{
		m_pCamera->Yaw(flDegrees);
	}
}



void CMapView3D::WorldToClient(Vector2D &vClient, const Vector &vWorld)
{
	m_pCamera->WorldToView( vWorld, vClient );
}

void CMapView3D::ClientToWorld(Vector &vWorld, const Vector2D &vClient)
{
	m_pCamera->ViewToWorld( vClient, vWorld );
}

void CMapView3D::SetCursor( vgui::HCursor hCursor )
{
	// translate VGUI -> GDI cursors
    switch( hCursor )
	{
		case vgui::dc_arrow :		::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW)); break;
		case vgui::dc_sizenwse :	::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZENWSE)); break;
		case vgui::dc_sizenesw :	::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZENESW)); break;
		case vgui::dc_sizewe :		::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEWE)); break;
		case vgui::dc_sizens :		::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZENS)); break;
		case vgui::dc_sizeall :		::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEALL)); break;
		case vgui::dc_crosshair :	::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_CROSS)); break;
		default :					::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW)); break;
	}
}


LRESULT CMapView3D::WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
{
	switch ( message )
	{
	case WM_KILLFOCUS:
		m_Keyboard.ClearKeyStates();
//		Msg( mwStatus, "debug: lost focus, clearing key states\n");
		break;
	}

	return CView::WindowProc( message, wParam, lParam ) ;
}