diff options
Diffstat (limited to 'hammer/mapsweptplayerhull.cpp')
| -rw-r--r-- | hammer/mapsweptplayerhull.cpp | 538 |
1 files changed, 538 insertions, 0 deletions
diff --git a/hammer/mapsweptplayerhull.cpp b/hammer/mapsweptplayerhull.cpp new file mode 100644 index 0000000..2439f7b --- /dev/null +++ b/hammer/mapsweptplayerhull.cpp @@ -0,0 +1,538 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: A helper that repesents a player hull swept through space between a +// start and end point. It writes out both points as keyvalues to the entity. +// +//=============================================================================// + +#include "stdafx.h" +#include "Box3D.h" +#include "GlobalFunctions.h" +#include "fgdlib/HelperInfo.h" +#include "materialsystem/imaterialsystem.h" +#include "materialsystem/imesh.h" +#include "MainFrm.h" // For refreshing the object properties dialog +#include "MapDoc.h" +#include "MapSweptPlayerHull.h" +#include "MapPlayerHullHandle.h" +#include "MapPointHandle.h" +#include "MapView2D.h" +#include "Material.h" +#include "Options.h" +#include "ObjectProperties.h" // For refreshing the object properties dialog +#include "Render2D.h" +#include "Render3D.h" +#include "ToolManager.h" +#include "ToolSweptHull.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include <tier0/memdbgon.h> + + +IMPLEMENT_MAPCLASS(CMapSweptPlayerHull); + + +//----------------------------------------------------------------------------- +// Purpose: Factory function. Used for creating a CMapSweptPlayerHull from a set +// of string parameters from the FGD file. +// Input : pInfo - Pointer to helper info class which gives us information +// about how to create the class. +// Output : Returns a pointer to the class, NULL if an error occurs. +//----------------------------------------------------------------------------- +CMapClass *CMapSweptPlayerHull::Create(CHelperInfo *pHelperInfo, CMapEntity *pParent) +{ + CMapSweptPlayerHull *pBox = new CMapSweptPlayerHull; + pBox->SetRenderColor(255,255,255); + return(pBox); +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CMapSweptPlayerHull::CMapSweptPlayerHull(void) +{ + Initialize(); +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::Initialize(void) +{ + r = 255; + g = 255; + b = 255; + + m_Point[0] = new CMapPlayerHullHandle; + m_Point[0]->Attach(this); + + m_Point[1] = new CMapPlayerHullHandle; + m_Point[1]->Attach(this); +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CMapSweptPlayerHull::~CMapSweptPlayerHull(void) +{ +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : bFullUpdate - +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::CalcBounds(BOOL bFullUpdate) +{ + CMapClass::CalcBounds(bFullUpdate); + + Vector vecMins; + Vector vecMaxs; + + m_Render2DBox.ResetBounds(); + m_CullBox.ResetBounds(); + for (int i = 0; i < 2; i++) + { + m_Point[i]->CalcBounds(bFullUpdate); + m_Point[i]->GetCullBox(vecMins, vecMaxs); + + m_CullBox.UpdateBounds(vecMins, vecMaxs); + } + + m_BoundingBox = m_CullBox; + m_Render2DBox = m_CullBox; +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Output : CMapClass +//----------------------------------------------------------------------------- +CMapClass *CMapSweptPlayerHull::Copy(bool bUpdateDependencies) +{ + CMapSweptPlayerHull *pCopy = new CMapSweptPlayerHull; + + if (pCopy != NULL) + { + pCopy->CopyFrom(this, bUpdateDependencies); + } + + return(pCopy); +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : pObject - +// Output : CMapClass +//----------------------------------------------------------------------------- +CMapClass *CMapSweptPlayerHull::CopyFrom(CMapClass *pObject, bool bUpdateDependencies) +{ + Assert(pObject->IsMapClass(MAPCLASS_TYPE(CMapSweptPlayerHull))); + CMapSweptPlayerHull *pFrom = (CMapSweptPlayerHull *)pObject; + + CMapClass::CopyFrom(pObject, bUpdateDependencies); + + m_Point[0]->CopyFrom(pFrom->m_Point[0], bUpdateDependencies); + m_Point[1]->CopyFrom(pFrom->m_Point[1], bUpdateDependencies); + + return(this); +} + + +//----------------------------------------------------------------------------- +// Purpose: Gets the tool object for a given context data from HitTest2D. +//----------------------------------------------------------------------------- +CBaseTool *CMapSweptPlayerHull::GetToolObject(int nHitData, bool bAttachObject) +{ + // FIXME: ideally, we could use CToolPointHandle here, because all it does is move + // points around, but that would require some way for the CMapSweptPlayerHull to know + // when the CMapPointHandle's position changes. This way the CToolAxisHandle can + // handle the notification. In general, we need a better system for building complex + // objects from simple ones and handling changes to the simple objects in the complex one. + // + // If we DID use a CToolPointHandle, we'd need to reconcile the status bar updates that + // are done in OnMouseMove2D, because points and axes cause different status bar text + // to be displayed as they are dragged around. + CToolSweptPlayerHull *pTool = (CToolSweptPlayerHull *)ToolManager()->GetToolForID(TOOL_SWEPT_HULL); + + if ( bAttachObject ) + pTool->Attach(this, nHitData); + + return pTool; +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : pView - +// point - +// nData - +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool CMapSweptPlayerHull::HitTest2D(CMapView2D *pView, const Vector2D &point, HitInfo_t &HitData) +{ + if (IsVisible()) + { + for (unsigned int i = 0; i < 2; i++) + { + if ( m_Point[i]->HitTest2D(pView, point, HitData) ) + { + HitData.pObject = this; + HitData.uData = i; + HitData.nDepth = 0; + return true; + } + } + } + + return false; +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : pRender - +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::Render2D(CRender2D *pRender) +{ + SelectionState_t eState = GetSelectionState(); + + CMapView2D *pView = (CMapView2D*)pRender->GetView(); + + m_Point[0]->Render2D(pRender); + m_Point[1]->Render2D(pRender); + + Vector vecOrigin1; + Vector vecOrigin2; + m_Point[0]->GetOrigin(vecOrigin1); + m_Point[1]->GetOrigin(vecOrigin2); + + Vector mins1, maxs1; + Vector mins2, maxs2; + m_Point[0]->m_CullBox.GetBounds( mins1, maxs1 ); + m_Point[1]->m_CullBox.GetBounds( mins2, maxs2 ); + + // Draw swept volume + Vector dir = vecOrigin2 - vecOrigin1; + + int nHorz = pView->axHorz; + int nVert = pView->axVert; + int nThird = pView->axThird; + + dir[ nThird ] = 0; + + VectorNormalize( dir ); + + float dx = dir[ nHorz ]; + float dy = dir[ nVert ]; + + if ( dx == 0 && dy == 0 ) + return; + + if (eState == SELECT_MODIFY) + { + pRender->PushRenderMode( RENDER_MODE_DOTTED ); + pRender->SetDrawColor( GetRValue(Options.colors.clrSelection), GetGValue(Options.colors.clrSelection), GetBValue(Options.colors.clrSelection) ); + + } + else + { + pRender->PushRenderMode( RENDER_MODE_FLAT ); + pRender->SetDrawColor( GetRValue(Options.colors.clrToolHandle), GetGValue(Options.colors.clrToolHandle), GetBValue(Options.colors.clrToolHandle) ); + } + + Vector line1[2]; + Vector line2[2]; + + line1[0].Init(); + line1[1].Init(); + line2[0].Init(); + line2[1].Init(); + + if ( dx > 0 ) + { + if ( dy > 0 ) + { + line1[0][nHorz] = mins1[ nHorz ]; + line1[0][nVert] = maxs1[ nVert ]; + line1[1][nHorz] = mins2[ nHorz ]; + line1[1][nVert] = maxs2[ nVert ]; + + line2[0][nHorz] = maxs1[ nHorz ]; + line2[0][nVert] = mins1[ nVert ]; + line2[1][nHorz] = maxs2[ nHorz ]; + line2[1][nVert] = mins2[ nVert ]; + } + else + { + line1[0][nHorz] = maxs1[ nHorz ]; + line1[0][nVert] = maxs1[ nVert ]; + line1[1][nHorz] = maxs2[ nHorz ]; + line1[1][nVert] = maxs2[ nVert ]; + + line2[0][nHorz] = mins1[ nHorz ]; + line2[0][nVert] = mins1[ nVert ]; + line2[1][nHorz] = mins2[ nHorz ]; + line2[1][nVert] = mins2[ nVert ]; + } + } + else + { + if ( dy > 0 ) + { + line1[0][nHorz] = maxs1[ nHorz ]; + line1[0][nVert] = maxs1[ nVert ]; + line1[1][nHorz] = maxs2[ nHorz ]; + line1[1][nVert] = maxs2[ nVert ]; + + line2[0][nHorz] = mins1[ nHorz ]; + line2[0][nVert] = mins1[ nVert ]; + line2[1][nHorz] = mins2[ nHorz ]; + line2[1][nVert] = mins2[ nVert ]; + } + else + { + line1[0][nHorz] = mins1[ nHorz ]; + line1[0][nVert] = maxs1[ nVert ]; + line1[1][nHorz] = mins2[ nHorz ]; + line1[1][nVert] = maxs2[ nVert ]; + + line2[0][nHorz] = maxs1[ nHorz ]; + line2[0][nVert] = mins1[ nVert ]; + line2[1][nHorz] = maxs2[ nHorz ]; + line2[1][nVert] = mins2[ nVert ]; + } + } + + pRender->DrawLine( line1[0], line1[1] ); + pRender->DrawLine( line2[0], line2[1] ); + + pRender->PopRenderMode(); +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : pRender - +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::Render3D(CRender3D *pRender) +{ + for (int i = 0; i < 2; i++) + { + m_Point[i]->Render3D(pRender); + } + + if (GetSelectionState() == SELECT_NONE) + { + pRender->SetDrawColor( 200,180,0 ); + } + else + { + pRender->SetDrawColor( 255,0,0 ); + } + + Vector vec1; + Vector vec2; + m_Point[0]->GetOrigin(vec1); + m_Point[1]->GetOrigin(vec2); + + pRender->DrawLine(vec1, vec2); + +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CMapSweptPlayerHull::SerializeRMF(std::fstream &File, BOOL bRMF) +{ + return(0); +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CMapSweptPlayerHull::SerializeMAP(std::fstream &File, BOOL bRMF) +{ + return(0); +} + + +//----------------------------------------------------------------------------- +// Purpose: Overridden to chain down to our endpoints, which are not children. +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::SetOrigin(Vector &vecOrigin) +{ + BaseClass::SetOrigin(vecOrigin); + + m_Point[0]->SetOrigin(vecOrigin); + m_Point[1]->SetOrigin(vecOrigin); +} + + +//----------------------------------------------------------------------------- +// Purpose: Overridden to chain down to our endpoints, which are not children. +//----------------------------------------------------------------------------- +SelectionState_t CMapSweptPlayerHull::SetSelectionState(SelectionState_t eSelectionState) +{ + SelectionState_t eState = BaseClass::SetSelectionState(eSelectionState); + + m_Point[0]->SetSelectionState(eSelectionState); + m_Point[1]->SetSelectionState(eSelectionState); + + return eState; +} + + +//----------------------------------------------------------------------------- +// Purpose: Special version of set SelectionState to set the state in only one +// endpoint handle for dragging that handle. +//----------------------------------------------------------------------------- +SelectionState_t CMapSweptPlayerHull::SetSelectionState(SelectionState_t eSelectionState, int nHandle) +{ + SelectionState_t eState = BaseClass::SetSelectionState(eSelectionState); + m_Point[nHandle]->SetSelectionState(eSelectionState); + return eState; +} + + +//----------------------------------------------------------------------------- +// Purpose: Overridden because origin helpers don't take the color of their +// parent entity. +// Input : red, green, blue - +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::SetRenderColor(unsigned char red, unsigned char green, unsigned char blue) +{ +} + + +//----------------------------------------------------------------------------- +// Purpose: Overridden because origin helpers don't take the color of their +// parent entity. +// Input : red, green, blue - +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::SetRenderColor(color32 rgbColor) +{ +} + +static Vector playerFixup( 0, 0, 36 ); + +//----------------------------------------------------------------------------- +// Purpose: +// Input : szKey - +// szValue - +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::OnParentKeyChanged(const char *szKey, const char *szValue) +{ + if (!stricmp(szKey, "point0")) + { + Vector vecOrigin; + sscanf(szValue, "%f %f %f", &vecOrigin.x, &vecOrigin.y, &vecOrigin.z ); + + vecOrigin += playerFixup; + + m_Point[0]->SetOrigin(vecOrigin); + PostUpdate(Notify_Changed); + } + else if (!stricmp(szKey, "point1")) + { + Vector vecOrigin; + sscanf(szValue, "%f %f %f", &vecOrigin.x, &vecOrigin.y, &vecOrigin.z ); + + vecOrigin += playerFixup; + + m_Point[1]->SetOrigin(vecOrigin); + PostUpdate(Notify_Changed); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Called by the axis tool to update the position of the endpoint. +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::UpdateEndPoint(Vector &vecPos, int nPointIndex) +{ + m_Point[nPointIndex]->SetOrigin( vecPos ); + PostUpdate(Notify_Changed); + UpdateParentKey(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Overridden to transform our endpoints. +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::DoTransform(const VMatrix &matrix) +{ + BaseClass::DoTransform(matrix); + + m_Point[0]->Transform(matrix); + m_Point[1]->Transform(matrix); + + UpdateParentKey(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::UpdateParentKey(void) +{ + CMapEntity *pEntity = dynamic_cast <CMapEntity *> (m_pParent); + if (pEntity != NULL) + { + Vector vecOrigin1; + Vector vecOrigin2; + m_Point[0]->GetOrigin(vecOrigin1); + m_Point[1]->GetOrigin(vecOrigin2); + + vecOrigin1 -= playerFixup; + vecOrigin2 -= playerFixup; + + PostUpdate(Notify_Changed); + + char szValue[KEYVALUE_MAX_VALUE_LENGTH]; + sprintf(szValue, "%g %g %g", (double)vecOrigin1.x, (double)vecOrigin1.y, (double)vecOrigin1.z ); + pEntity->NotifyChildKeyChanged(this, "point0", szValue); + pEntity->NotifyChildKeyChanged(this, "origin", szValue); + + sprintf(szValue, "%g %g %g", (double)vecOrigin2.x, (double)vecOrigin2.y, (double)vecOrigin2.z); + pEntity->NotifyChildKeyChanged(this, "point1", szValue); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Sets the keyvalue in our parent when we are added to the world. +// Input : pWorld - +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::OnAddToWorld(CMapWorld *pWorld) +{ + BaseClass::OnAddToWorld(pWorld); + UpdateParentKey(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Sets the keyvalue in our parent after the map is loaded. +// Input : pWorld - +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::PostloadWorld(CMapWorld *pWorld) +{ + BaseClass::PostloadWorld(pWorld); + UpdateParentKey(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Returns the position of the given endpoint. +// Input : vecPos - Receives the position. +// nPointIndex - Endpoint index [0,1]. +//----------------------------------------------------------------------------- +void CMapSweptPlayerHull::GetEndPoint(Vector &vecPos, int nPointIndex) +{ + m_Point[nPointIndex]->GetOrigin(vecPos); +} |