csgo/cstrike15_src/hammer/ToolCamera.cpp

//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

#include "stdafx.h"
#include "ToolCamera.h"
#include "SaveInfo.h"
#include "MainFrm.h"			// dvs: remove?
#include "MapDefs.h"
#include "MapDoc.h"
#include "MapView2D.h"
#include "MapView3D.h"
#include "Options.h"
#include "Render2D.h"
#include "StatusBarIDs.h"		// dvs: remove
#include "ToolManager.h"
#include "hammer_mathlib.h"
#include "vgui/Cursor.h"
#include "Selection.h"

// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>

#pragma warning(disable:4244)

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
Camera3D::Camera3D(void)
{
	Cameras.EnsureCapacity(16);
	SetEmpty();
}


//-----------------------------------------------------------------------------
// Purpose: Returns true if we are dragging a camera, false if not. // dvs: rename
//-----------------------------------------------------------------------------
bool Camera3D::IsEmpty(void)
{
	return (Cameras.Count() == 0);
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void Camera3D::SetEmpty(void)
{
	Cameras.RemoveAll();
	m_iActiveCamera = -1;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pt - 
//			BOOL - 
// Output : int
//-----------------------------------------------------------------------------
int Camera3D::HitTest(CMapView *pView, const Vector2D &ptClient, bool bTestHandles)
{
	for(int i = 0; i < Cameras.Count(); i++)
	{
		for ( int j=0; j<2; j++ )
		{
			if( HitRect( pView, ptClient, Cameras[i].position[j], HANDLE_RADIUS ) )
			{
				return MAKELONG(i+1, j);
			}
		}
	}

	return FALSE;
}

//-----------------------------------------------------------------------------
// Purpose: Get rid of extra cameras if we have too many.
//-----------------------------------------------------------------------------
void Camera3D::EnsureMaxCameras()
{
	int nMax = max( Options.general.nMaxCameras, 1 );
	
	int nToRemove = Cameras.Count() - nMax;
	if ( nToRemove > 0 )
	{
		m_iActiveCamera = max( m_iActiveCamera - nToRemove, 0 );
		
		while ( nToRemove-- )
			Cameras.Remove( 0 );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : bSave - 
//-----------------------------------------------------------------------------
void Camera3D::FinishTranslation(bool bSave)
{
	if (bSave)
	{
		if ( m_iActiveCamera == Cameras.Count() )
		{
			Cameras.AddToTail();
			EnsureMaxCameras();
		}

		Cameras[m_iActiveCamera] = m_MoveCamera;
	}

	Tool3D::FinishTranslation(bSave);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pt - 
//			uFlags - 
//			CSize& - 
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
bool Camera3D::UpdateTranslation(const Vector &vUpdate, UINT uFlags)
{
	Vector vCamDelta = m_MoveCamera.position[1] - m_MoveCamera.position[0];

	Vector vNewPos = m_vOrgPos + vUpdate;

	// snap point if need be
	if ( uFlags & constrainSnap )
		m_pDocument->Snap( vNewPos, uFlags );

	m_MoveCamera.position[m_nMovePositionIndex] = vNewPos;

	if(uFlags & constrainMoveAll)
	{
		m_MoveCamera.position[(m_nMovePositionIndex+1)%2] = vNewPos + vCamDelta;
	}

 	m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_TOOL );
		
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pCamPos - 
//			iCamera - 
//-----------------------------------------------------------------------------
void Camera3D::GetCameraPos(Vector &vViewPos, Vector &vLookAt)
{
	if(!inrange(m_iActiveCamera, 0, Cameras.Count()))
	{
		vViewPos.Init();
		vLookAt.Init();
		return;
	}

	vViewPos = Cameras[m_iActiveCamera].position[0];
	vLookAt = Cameras[m_iActiveCamera].position[1];
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pCamPos - 
//			iCamera - 
//-----------------------------------------------------------------------------
void Camera3D::AddCamera(CAMSTRUCT &camera)
{
	Cameras.AddToTail( camera );
	EnsureMaxCameras();
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pRender - 
//-----------------------------------------------------------------------------
void Camera3D::RenderTool2D(CRender2D *pRender)
{
	for (int i = 0; i < Cameras.Count(); i++)
	{
		CAMSTRUCT *pDrawCam = &Cameras[i];

		if (IsTranslating() && (i == m_iActiveCamera))
		{
			pDrawCam = &m_MoveCamera;
		}
 		
		//
		// Draw the line between.
		//
		if (i == m_iActiveCamera)
		{
			pRender->SetDrawColor( 255, 0, 0 );
		}
		else
		{
			pRender->SetDrawColor( 0, 255, 255 );
		}

		pRender->DrawLine( pDrawCam->position[MovePos], pDrawCam->position[MoveLook] );

		//
		// Draw camera handle.
		//
		pRender->SetHandleStyle(HANDLE_RADIUS, CRender::HANDLE_CIRCLE );
		pRender->SetHandleColor( 0, 255, 255 );
		pRender->DrawHandle( pDrawCam->position[MovePos] );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Handles key values being read from the MAP file.
// Input  : szKey - Key being loaded.
//			szValue - Value of the key being loaded.
//			pCam - Camera structure to place the values into.
// Output : Returns ChunkFile_Ok to indicate success.
//-----------------------------------------------------------------------------
ChunkFileResult_t Camera3D::LoadCameraKeyCallback(const char *szKey, const char *szValue, CAMSTRUCT *pCam)
{
	if (!stricmp(szKey, "look"))
	{
		CChunkFile::ReadKeyValueVector3(szValue, pCam->position[MoveLook]);
	}
	else if (!stricmp(szKey, "position"))
	{
		CChunkFile::ReadKeyValueVector3(szValue, pCam->position[MovePos]);
	}

	return(ChunkFile_Ok);
}


//-----------------------------------------------------------------------------
// Purpose: Handles key values being read from the MAP file.
// Input  : szKey - Key being loaded.
//			szValue - Value of the key being loaded.
//			pCam - Camera structure to place the values into.
// Output : Returns ChunkFile_Ok to indicate success.
//-----------------------------------------------------------------------------
ChunkFileResult_t Camera3D::LoadCamerasKeyCallback(const char *szKey, const char *szValue, Camera3D *pCameras)
{
	if (!stricmp(szKey, "activecamera"))
	{
		pCameras->m_iActiveCamera = atoi(szValue);
	}

	return(ChunkFile_Ok);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pLoadInfo - 
//			*pSolid - 
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t Camera3D::LoadCameraCallback(CChunkFile *pFile, Camera3D *pCameras)
{
	CAMSTRUCT Cam;
	memset(&Cam, 0, sizeof(Cam));

	ChunkFileResult_t eResult = pFile->ReadChunk((KeyHandler_t)LoadCameraKeyCallback, &Cam);

	if (eResult == ChunkFile_Ok)
	{
		pCameras->AddCamera( Cam );
	}

	return(eResult);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pFile - 
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t Camera3D::LoadVMF(CChunkFile *pFile)
{
	//
	// Set up handlers for the subchunks that we are interested in.
	//
	CChunkHandlerMap Handlers;
	Handlers.AddHandler("camera", (ChunkHandler_t)LoadCameraCallback, this);

	pFile->PushHandlers(&Handlers);
	ChunkFileResult_t eResult = pFile->ReadChunk((KeyHandler_t)LoadCamerasKeyCallback, this);
	pFile->PopHandlers();

	if (eResult == ChunkFile_Ok)
	{
		//
		// Make sure the active camera is legal.
		//
		if (Cameras.Count() == 0)
		{
			m_iActiveCamera = -1;
		}
		else if (!inrange(m_iActiveCamera, 0, Cameras.Count()))
		{
			m_iActiveCamera = 0;
		}
	}

	return(eResult);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &dir - 
//			&pos - 
//-----------------------------------------------------------------------------
void Camera3D::UpdateActiveCamera(Vector &vViewPos, Vector &vDir)
{
	if(!inrange(m_iActiveCamera, 0, Cameras.Count()))
		return;

	Vector& camPos	= Cameras[m_iActiveCamera].position[MovePos];
	Vector& lookPos	= Cameras[m_iActiveCamera].position[MoveLook];

	// get current length
	Vector delta;
	for(int i = 0; i < 3; i++)
		delta[i] = camPos[i] - lookPos[i];

	float length = VectorLength(delta);

	if ( length < 1 )
		length = 1;

	camPos = vViewPos;

	for(int i = 0; i < 3; i++)
		lookPos[i] = camPos[i] + vDir[i] * length;

	if ( IsActiveTool() )
	{
		if (Options.view2d.bCenteroncamera)
		{
			VIEW2DINFO vi;
			vi.wFlags = VI_CENTER;
			vi.ptCenter = vViewPos;
			m_pDocument->SetView2dInfo(vi);
		}

		m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_TOOL );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : type - 
//-----------------------------------------------------------------------------
void Camera3D::SetNextCamera(SNCTYPE type)
{
	if(Cameras.Count()==0)
	{
		m_iActiveCamera = -1;
		return;
	}
		
	switch(type)
	{
	case sncNext:
		++m_iActiveCamera;
		if(m_iActiveCamera >= Cameras.Count() )
			m_iActiveCamera = 0;
		break;
	case sncPrev:
		--m_iActiveCamera;
		if(m_iActiveCamera < 0)
			m_iActiveCamera = Cameras.Count()-1;
		break;
	case sncFirst:
		m_iActiveCamera = 0;
		break;
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void Camera3D::DeleteActiveCamera()
{
	if(!inrange(m_iActiveCamera, 0, Cameras.Count()))
		return;

	Cameras.Remove(m_iActiveCamera);
	
	if(m_iActiveCamera >= Cameras.Count() )
		m_iActiveCamera = Cameras.Count()-1;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : file - 
//			fIsStoring - 
//-----------------------------------------------------------------------------
void Camera3D::SerializeRMF(std::fstream& file, BOOL fIsStoring)
{
	float fVersion = 0.2f, fThisVersion;

	int nCameras = Cameras.Count();

	if(fIsStoring)
	{
		file.write((char*)&fVersion, sizeof(fVersion) );

		file.write((char*)&m_iActiveCamera, sizeof(m_iActiveCamera) );
		file.write((char*)&nCameras, sizeof(nCameras));
		for(int i = 0; i < nCameras; i++)
		{
			file.write((char*)&Cameras[i], sizeof(CAMSTRUCT));
		}
	}
	else
	{
		file.read((char*)&fThisVersion, sizeof(fThisVersion) );

		if(fThisVersion >= 0.2f)
		{
			file.read((char*)&m_iActiveCamera, sizeof(m_iActiveCamera));
		}

		file.read((char*)&nCameras, sizeof (nCameras) );

		Cameras.RemoveAll();
		Cameras.EnsureCapacity(nCameras);

		for(int i = 0; i < nCameras; i++)
		{
			CAMSTRUCT cam;
			file.read((char*)&cam, sizeof(CAMSTRUCT));
			Cameras.AddToTail( cam );
		}
		EnsureMaxCameras();

		Assert( Cameras.Count() == nCameras );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pFile - 
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t Camera3D::SaveVMF(CChunkFile *pFile, CSaveInfo *pSaveInfo)
{
	ChunkFileResult_t eResult = pFile->BeginChunk( GetVMFChunkName() );
	if (eResult == ChunkFile_Ok)
	{
		eResult = pFile->WriteKeyValueInt("activecamera", m_iActiveCamera);
	}
	
	if (eResult == ChunkFile_Ok)
	{
		for (int i = 0; i < Cameras.Count(); i++)
		{
			eResult = pFile->BeginChunk("camera");

			if (eResult == ChunkFile_Ok)
			{
				eResult = pFile->WriteKeyValueVector3("position", Cameras[i].position[MovePos]);
			}
			
			if (eResult == ChunkFile_Ok)
			{
				eResult = pFile->WriteKeyValueVector3("look", Cameras[i].position[MoveLook]);
			}

			if (eResult == ChunkFile_Ok)
			{
				eResult = pFile->EndChunk();
			}

			if (eResult != ChunkFile_Ok)
			{
				break;
			}
		}
	}
			
	if (eResult == ChunkFile_Ok)
	{
		eResult = pFile->EndChunk();
	}

	return(eResult);
}


//-----------------------------------------------------------------------------
// Purpose: Handles the key down event in the 2D view.
// Input  : Per CWnd::OnKeyDown.
// Output : Returns true if the message was handled, false if not.
//-----------------------------------------------------------------------------
bool Camera3D::OnKeyDown2D(CMapView2D *pView, UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	if (nChar == VK_DELETE || nChar == VK_NEXT || nChar == VK_PRIOR)
	{
		CMapDoc *pDoc = pView->GetMapDoc();

		if (nChar == VK_DELETE)
		{
			DeleteActiveCamera();
		}
		else if (nChar == VK_NEXT)
		{
			SetNextCamera(Camera3D::sncNext);
		}
		else
		{
			SetNextCamera(Camera3D::sncPrev);
		}
			
		Vector viewPos,lookAt;

		GetCameraPos( viewPos, lookAt );
		pDoc->UpdateAllCameras( &viewPos, &lookAt, NULL );

		return true;
	}
	else if (nChar == VK_ESCAPE)
	{
		OnEscape();
		return true;	
	}

	return false;
}


//-----------------------------------------------------------------------------
// Purpose: Handles the left mouse button down event in the 2D view.
// Input  : Per CWnd::OnLButtonDown.
// Output : Returns true if the message was handled, false if not.
//-----------------------------------------------------------------------------
bool Camera3D::OnLMouseDown2D(CMapView2D *pView, UINT nFlags, const Vector2D &vPoint) 
{
	CMapDoc *pDoc = pView->GetMapDoc();

	pView->SetCapture();

	//
	// If there are no cameras created yet or they are holding down
	// the SHIFT key, create a new camera now.
	//

	Vector vecWorld;
	pView->ClientToWorld( vecWorld, vPoint );

	if ( IsEmpty() || (nFlags & MK_SHIFT))
	{
		//
		// Build a point in world space to place the new camera.
		//
		
		if ( !pDoc->GetSelection()->IsEmpty() )
		{
			Vector vecCenter;
			pDoc->GetSelection()->GetBoundsCenter(vecCenter);
			vecWorld[pView->axThird] = vecCenter[pView->axThird];
		}
		else
		{
			vecWorld[pView->axThird] = COORD_NOTINIT;
			pDoc->GetBestVisiblePoint(vecWorld);
		}

		//
		// Create a new camera.
		//
		m_vOrgPos = vecWorld;
		m_MoveCamera.position[MovePos] = vecWorld;
		m_MoveCamera.position[MoveLook] = vecWorld;
		m_nMovePositionIndex = MoveLook;

		// set as active camera
		m_iActiveCamera = Cameras.AddToTail(m_MoveCamera);;
		EnsureMaxCameras();
		
		StartTranslation(pView, vPoint );
	}
	//
	// Otherwise, try to drag an existing camera handle.
	//
	else
	{
		int dwHit = HitTest( pView, vPoint );

		if ( dwHit )
		{
			m_iActiveCamera = LOWORD(dwHit)-1;
			m_MoveCamera = Cameras[m_iActiveCamera];
			m_nMovePositionIndex = HIWORD(dwHit);
			m_vOrgPos = m_MoveCamera.position[m_nMovePositionIndex];
			StartTranslation( pView, vPoint );
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Handles the left mouse button up event in the 2D view.
// Input  : Per CWnd::OnLButtonUp.
// Output : Returns true if the message was handled, false if not.
//-----------------------------------------------------------------------------
bool Camera3D::OnLMouseUp2D(CMapView2D *pView, UINT nFlags, const Vector2D &vPoint) 
{
	ReleaseCapture();

	if (IsTranslating())
	{
		FinishTranslation(true);

		Vector viewPos, lookAt;
		GetCameraPos( viewPos, lookAt );
		
		m_pDocument->UpdateAllCameras( &viewPos, &lookAt, NULL );
	}

	m_pDocument->UpdateStatusbar();
	
	return true;
}

unsigned int Camera3D::GetConstraints(unsigned int nKeyFlags)
{
	unsigned int uConstraints = Tool3D::GetConstraints( nKeyFlags );

	if(nKeyFlags & MK_CONTROL)
	{
		uConstraints |= constrainMoveAll;
	}

	return uConstraints;
}

//-----------------------------------------------------------------------------
// Purpose: Handles the mouse move event in the 2D view.
// Input  : Per CWnd::OnMouseMove.
// Output : Returns true if the message was handled, false if not.
//-----------------------------------------------------------------------------
bool Camera3D::OnMouseMove2D(CMapView2D *pView, UINT nFlags, const Vector2D &vPoint) 
{
	CMapDoc *pDoc = pView->GetMapDoc();
	if (!pDoc)
	{
		return true;
	}

	vgui::HCursor hCursor = vgui::dc_arrow;

	unsigned int uConstraints = GetConstraints( nFlags );

	// Make sure the point is visible.
	
	pView->ToolScrollToPoint( vPoint );

	//
	// Convert to world coords.
	//
	Vector vecWorld;
	pView->ClientToWorld(vecWorld, vPoint);

	//
	// Update status bar position display.
	//
	char szBuf[128];

	m_pDocument->Snap(vecWorld,uConstraints);

	sprintf(szBuf, " @%.0f, %.0f ", vecWorld[pView->axHorz], vecWorld[pView->axVert] );
	SetStatusText(SBI_COORDS, szBuf);
	
	if (IsTranslating())
	{
		Tool3D::UpdateTranslation(pView, vPoint, uConstraints );

		hCursor = vgui::dc_none;
	}
	else if ( !IsEmpty() )
	{
		//
		// If the cursor is on a handle, set it to a cross.
		//
		if ( HitTest( pView, vPoint, true) )
		{
			hCursor = vgui::dc_crosshair;
		}
	}

	if ( hCursor != vgui::dc_none )
		pView->SetCursor( hCursor );

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Handles the left mouse button down event in the 3D view.
// Input  : Per CWnd::OnLButtonDown.
// Output : Returns true if the message was handled, false if not.
//-----------------------------------------------------------------------------
bool Camera3D::OnLMouseDown3D(CMapView3D *pView, UINT nFlags, const Vector2D &vPoint)
{
	pView->EnableRotating(true);
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Handles the left mouse up down event in the 3D view.
// Input  : Per CWnd::OnLButtonUp.
// Output : Returns true if the message was handled, false if not.
//-----------------------------------------------------------------------------
bool Camera3D::OnLMouseUp3D(CMapView3D *pView, UINT nFlags, const Vector2D &vPoint)
{
	pView->EnableRotating(false);
	pView->UpdateCameraVariables();
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Handles the right mouse button down event in the 3D view.
// Input  : Per CWnd::OnRButtonDown.
// Output : Returns true if the message was handled, false if not.
//-----------------------------------------------------------------------------
bool Camera3D::OnRMouseDown3D(CMapView3D *pView, UINT nFlags, const Vector2D &vPoint)
{
	pView->EnableStrafing(true);
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Handles the right mouse button up event in the 3D view.
// Input  : Per CWnd::OnRButtonUp.
// Output : Returns true if the message was handled, false if not.
//-----------------------------------------------------------------------------
bool Camera3D::OnRMouseUp3D(CMapView3D *pView, UINT nFlags, const Vector2D &vPoint)
{
	pView->EnableStrafing(false);
	pView->UpdateCameraVariables();
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Handles the key down event in the 3D view.
// Input  : Per CWnd::OnKeyDown.
// Output : Returns true if the message was handled, false if not.
//-----------------------------------------------------------------------------
bool Camera3D::OnKeyDown3D(CMapView3D *pView, UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	if (nChar == VK_DELETE || nChar == VK_NEXT || nChar == VK_PRIOR)
	{
		CMapDoc *pDoc = pView->GetMapDoc();

		if (nChar == VK_DELETE)
		{
			DeleteActiveCamera();
		}
		else if (nChar == VK_NEXT)
		{
			SetNextCamera(Camera3D::sncNext);
		}
		else
		{
			SetNextCamera(Camera3D::sncPrev);
		}
		
		Vector viewPos, lookAt;
		GetCameraPos( viewPos, lookAt );

		pDoc->UpdateAllCameras( &viewPos, &lookAt, NULL );
		
		return true;
	}
	else if (nChar == VK_ESCAPE)
	{
		OnEscape();
		return true;	
	}

	return false;
}


//-----------------------------------------------------------------------------
// Purpose: Handles the escape key in the 2D or 3D views.
//-----------------------------------------------------------------------------
void Camera3D::OnEscape(void)
{
	//
	// Stop using the camera tool.
	//
	m_pDocument->GetTools()->SetTool(TOOL_POINTER);
}