Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

817 lines
20 KiB

5 years ago
//========= Copyright 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);
}