1HEADmaster

1 files changed, 510 insertions, 0 deletions

diff --git a/hammer/mapline.cpp b/hammer/mapline.cpp
new file mode 100644
index 0000000..429ba02
--- /dev/null
+++ b/hammer/mapline.cpp
@@ -0,0 +1,510 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: This helper is used for entities that represent a line between two
+//			entities. Examples of these are: beams and special node connections.
+//
+//			The helper factory parameters are:
+//
+//			<red> <green> <blue> <start key> <start key value> <end key> <end key value>
+//
+//			The line helper looks in the given keys in its parent entity and
+//			attaches itself to the entities with those key values. If only one
+//			endpoint entity is specified, the other end is assumed to be the parent
+//			entity.
+//
+//=============================================================================//
+
+#include "stdafx.h"
+#include "Box3D.h"
+#include "MapEntity.h"
+#include "MapLine.h"
+#include "MapWorld.h"
+#include "Render2D.h"
+#include "Render3D.h"
+#include "TextureSystem.h"
+#include "materialsystem/imesh.h"
+#include "Material.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include <tier0/memdbgon.h>
+
+IMPLEMENT_MAPCLASS(CMapLine);
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Factory function. Used for creating a CMapLine 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 *CMapLine::Create(CHelperInfo *pHelperInfo, CMapEntity *pParent)
+{
+	CMapLine *pLine = NULL;
+
+	//
+	// Extract the line color from the parameter list.
+	//
+	unsigned char chRed = 255;
+	unsigned char chGreen = 255;
+	unsigned char chBlue = 255;
+
+	const char *pszParam = pHelperInfo->GetParameter(0);
+	if (pszParam != NULL)
+	{
+		chRed = atoi(pszParam);
+	}
+
+	pszParam = pHelperInfo->GetParameter(1);
+	if (pszParam != NULL)
+	{
+		chGreen = atoi(pszParam);
+	}
+
+	pszParam = pHelperInfo->GetParameter(2);
+	if (pszParam != NULL)
+	{
+		chBlue = atoi(pszParam);
+	}
+
+	const char *pszStartKey = pHelperInfo->GetParameter(3);
+	const char *pszStartValueKey = pHelperInfo->GetParameter(4);
+
+	const char *pszEndKey = pHelperInfo->GetParameter(5);
+	const char *pszEndValueKey = pHelperInfo->GetParameter(6);
+
+	//
+	// Make sure we'll have at least one endpoint to work with.
+	//
+	if ((pszStartKey == NULL) || (pszStartValueKey == NULL))
+	{
+		return NULL;
+	}
+
+	pLine = new CMapLine(pszStartKey, pszStartValueKey, pszEndKey, pszEndValueKey);
+	pLine->SetRenderColor(chRed, chGreen, chBlue);
+
+	//
+	// If they only specified a start entity, use our parent as the end entity.
+	//
+	if ((pszEndKey == NULL) || (pszEndValueKey == NULL))
+	{
+		pLine->m_pEndEntity = pParent;
+	}
+
+	return(pLine);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CMapLine::CMapLine(void)
+{
+	Initialize();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor. Initializes data members.
+// Input  : pszStartKey - The key to search in other entities for a match against the value of pszStartValueKey, ex 'targetname'.
+//			pszStartValueKey - The key in our parent entity from which to get a search term for the start entity ex 'beamstart01'.
+//			pszEndKey - The key to search in other entities for a match against the value of pszEndValueKey ex 'targetname'.
+//			pszEndValueKey - The key in our parent entity from which to get a search term for the end entity ex 'beamend01'.
+//-----------------------------------------------------------------------------
+CMapLine::CMapLine(const char *pszStartKey, const char *pszStartValueKey, const char *pszEndKey, const char *pszEndValueKey)
+{	
+	Initialize();
+
+	strcpy(m_szStartKey, pszStartKey);
+	strcpy(m_szStartValueKey, pszStartValueKey);
+
+	if ((pszEndKey != NULL) && (pszEndValueKey != NULL))
+	{
+		strcpy(m_szEndKey, pszEndKey);
+		strcpy(m_szEndValueKey, pszEndValueKey);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets data members to initial values.
+//-----------------------------------------------------------------------------
+void CMapLine::Initialize(void)
+{
+	m_szStartKey[0] = '\0';
+	m_szStartValueKey[0] = '\0';
+
+	m_szEndKey[0] = '\0';
+	m_szEndValueKey[0] = '\0';
+
+	m_pStartEntity = NULL;
+	m_pEndEntity = NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor.
+//-----------------------------------------------------------------------------
+CMapLine::~CMapLine(void)
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Calculates the midpoint of the line and sets our origin there.
+//-----------------------------------------------------------------------------
+void CMapLine::BuildLine(void)
+{
+	if ((m_pStartEntity != NULL) && (m_pEndEntity != NULL))
+	{
+		//
+		// Set our origin to our midpoint. This moves our selection handle box to the
+		// midpoint.
+		//
+		Vector Start;
+		Vector End;
+
+		m_pStartEntity->GetOrigin(Start);
+		m_pEndEntity->GetOrigin(End);
+
+		SetOrigin((Start + End) / 2);
+	}
+
+	CalcBounds();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Recalculates our bounding box.
+// Input  : bFullUpdate - Whether to force our children to recalculate or not.
+//-----------------------------------------------------------------------------
+void CMapLine::CalcBounds(BOOL bFullUpdate)
+{
+	CMapClass::CalcBounds(bFullUpdate);
+	
+	//
+	// Don't calculate 2D bounds - we don't occupy any space in 2D. This keeps our
+	// parent entity's bounds from expanding to encompass our endpoints.
+	//
+
+	//
+	// Update our 3D culling box and possibly our origin.
+	//
+	// If our start and end entities are resolved, calcuate our bounds
+	// based on the positions of the start and end entities.
+	//
+	if (m_pStartEntity && m_pEndEntity)
+	{
+		//
+		// Update the 3D bounds.
+		//
+		Vector Start;
+		Vector End;
+
+		m_pStartEntity->GetOrigin(Start);
+		m_CullBox.UpdateBounds(Start);
+
+		m_pEndEntity->GetOrigin(End);
+		m_CullBox.UpdateBounds(End);
+	}
+
+	m_BoundingBox = m_CullBox;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : bUpdateDependencies - 
+// Output : CMapClass
+//-----------------------------------------------------------------------------
+CMapClass *CMapLine::Copy(bool bUpdateDependencies)
+{
+	CMapLine *pCopy = new CMapLine;
+
+	if (pCopy != NULL)
+	{
+		pCopy->CopyFrom(this, bUpdateDependencies);
+	}
+
+	return(pCopy);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Turns 'this' into an exact replica of 'pObject'.
+// Input  : pObject - Object to replicate.
+//			bUpdateDependencies - 
+// Output : 
+//-----------------------------------------------------------------------------
+CMapClass *CMapLine::CopyFrom(CMapClass *pObject, bool bUpdateDependencies)
+{
+	CMapLine *pFrom = dynamic_cast <CMapLine *>(pObject);
+
+	if (pFrom != NULL)
+	{
+		CMapClass::CopyFrom(pObject, bUpdateDependencies);
+
+		if (bUpdateDependencies)
+		{
+			m_pStartEntity = (CMapEntity *)UpdateDependency(m_pStartEntity, pFrom->m_pStartEntity);
+			m_pEndEntity = (CMapEntity *)UpdateDependency(m_pEndEntity, pFrom->m_pEndEntity);
+		}
+		else
+		{
+			m_pStartEntity = pFrom->m_pStartEntity;
+			m_pEndEntity = pFrom->m_pEndEntity;
+		}
+
+		strcpy(m_szStartValueKey, pFrom->m_szStartValueKey);
+		strcpy(m_szStartKey, pFrom->m_szStartKey);
+
+		strcpy(m_szEndValueKey, pFrom->m_szEndValueKey);
+		strcpy(m_szEndKey, pFrom->m_szEndKey);
+	}
+
+	return(this);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called after this object is added to the world.
+//
+//			NOTE: This function is NOT called during serialization. Use PostloadWorld
+//				  to do similar bookkeeping after map load.
+//
+// Input  : pWorld - The world that we have been added to.
+//-----------------------------------------------------------------------------
+void CMapLine::OnAddToWorld(CMapWorld *pWorld)
+{
+	CMapClass::OnAddToWorld(pWorld);
+
+	//
+	// Updates our start and end entity pointers since we are being added
+	// into the world.
+	//
+	UpdateDependencies(pWorld, NULL);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called just after this object has been removed from the world so
+//			that it can unlink itself from other objects in the world.
+// Input  : pWorld - The world that we were just removed from.
+//			bNotifyChildren - Whether we should forward notification to our children.
+//-----------------------------------------------------------------------------
+void CMapLine::OnRemoveFromWorld(CMapWorld *pWorld, bool bNotifyChildren)
+{
+	CMapClass::OnRemoveFromWorld(pWorld, bNotifyChildren);
+
+	//
+	// Detach ourselves from the endpoint entities.
+	//
+	m_pStartEntity = (CMapEntity *)UpdateDependency(m_pStartEntity, NULL);
+	m_pEndEntity = (CMapEntity *)UpdateDependency(m_pEndEntity, NULL);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Our start or end entity has changed; recalculate our bounds and midpoint.
+// Input  : pObject - Entity that changed.
+//-----------------------------------------------------------------------------
+void CMapLine::OnNotifyDependent(CMapClass *pObject, Notify_Dependent_t eNotifyType)
+{
+	CMapClass::OnNotifyDependent(pObject, eNotifyType);
+
+	CMapWorld *pWorld = (CMapWorld *)GetWorldObject(this);
+	UpdateDependencies(pWorld, NULL);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : key - 
+//			value - 
+//-----------------------------------------------------------------------------
+void CMapLine::OnParentKeyChanged( const char* key, const char* value )
+{
+	CMapWorld *pWorld = (CMapWorld *)GetWorldObject(this);
+	if (pWorld != NULL)
+	{
+		if (stricmp(key, m_szStartValueKey) == 0)
+		{
+			m_pStartEntity = (CMapEntity *)UpdateDependency(m_pStartEntity, pWorld->FindChildByKeyValue(m_szStartKey, value));
+			BuildLine();
+		}
+		else if (stricmp(key, m_szEndValueKey) == 0)
+		{
+			m_pEndEntity = (CMapEntity *)UpdateDependency(m_pEndEntity, pWorld->FindChildByKeyValue(m_szEndKey, value));
+			BuildLine();
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Renders the line helper in the 2D view.
+// Input  : pRender - 2D rendering interface.
+//-----------------------------------------------------------------------------
+void CMapLine::Render2D(CRender2D *pRender)
+{
+	if ((m_pStartEntity != NULL) && (m_pEndEntity != NULL))
+	{
+		Vector Start;
+		Vector End;
+
+		m_pStartEntity->GetOrigin(Start);
+		m_pEndEntity->GetOrigin(End);
+
+		if (IsSelected())
+		{
+			pRender->SetDrawColor( SELECT_FACE_RED, SELECT_FACE_GREEN, SELECT_FACE_BLUE );
+		}
+		else
+		{
+			pRender->SetDrawColor( r, g, b );
+		}
+
+		pRender->DrawLine(Start, End);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pRender - 
+//-----------------------------------------------------------------------------
+void CMapLine::Render3D(CRender3D *pRender)
+{
+	if ( (m_pStartEntity == NULL) || (m_pEndEntity == NULL) )
+		return;
+
+	pRender->BeginRenderHitTarget(this);
+	pRender->PushRenderMode(RENDER_MODE_WIREFRAME);
+	
+	Vector Start, End;
+	
+	m_pStartEntity->GetOrigin(Start);
+	m_pEndEntity->GetOrigin(End);
+
+
+
+	CMeshBuilder meshBuilder;
+	CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
+	IMesh* pMesh = pRenderContext->GetDynamicMesh();
+
+	// FIXME: Can't do this...! glLineWidth(2);
+
+	meshBuilder.Begin( pMesh, MATERIAL_LINES, 1 );
+
+	unsigned char color[3];
+	if (IsSelected())
+	{
+		color[0] = SELECT_EDGE_RED; 
+		color[1] = SELECT_EDGE_GREEN;
+		color[2] = SELECT_EDGE_BLUE;
+	}
+	else
+	{
+		color[0] = r;
+		color[1] = g; 
+		color[2] = b;
+	}
+
+	meshBuilder.Color3ubv( color );
+	meshBuilder.Position3f(Start.x, Start.y, Start.z);
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Color3ubv( color );
+	meshBuilder.Position3f(End.x, End.y, End.z);
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.End();
+	pMesh->Draw();
+
+	pRender->EndRenderHitTarget();
+	pRender->PopRenderMode();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : File - 
+//			bRMF - 
+// Output : int
+//-----------------------------------------------------------------------------
+int CMapLine::SerializeRMF(std::fstream &File, BOOL bRMF)
+{
+	return(0);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : File - 
+//			bRMF - 
+// Output : int
+//-----------------------------------------------------------------------------
+int CMapLine::SerializeMAP(std::fstream &File, BOOL bRMF)
+{
+	return(0);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pTransBox - 
+//-----------------------------------------------------------------------------
+void CMapLine::DoTransform(const VMatrix &matrix)
+{
+	BaseClass::DoTransform(matrix);
+	BuildLine();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates the cached pointers to our start and end entities by looking
+//			for them in the given world.
+// Input  : pWorld - World to search.
+//-----------------------------------------------------------------------------
+void CMapLine::UpdateDependencies(CMapWorld *pWorld, CMapClass *pObject)
+{
+	CMapClass::UpdateDependencies(pWorld, pObject);
+
+	if (pWorld == NULL)
+	{
+		return;
+	}
+
+	CMapEntity *pEntity = dynamic_cast <CMapEntity *> (m_pParent);
+	Assert(pEntity != NULL);
+
+	if (pEntity != NULL)
+	{
+		const char *pszValue = pEntity->GetKeyValue(m_szStartValueKey);
+		m_pStartEntity = (CMapEntity *)UpdateDependency(m_pStartEntity, pWorld->FindChildByKeyValue(m_szStartKey, pszValue));
+
+		if (m_szEndValueKey[0] != '\0')
+		{
+			pszValue = pEntity->GetKeyValue(m_szEndValueKey);
+			m_pEndEntity = (CMapEntity *)UpdateDependency(m_pEndEntity, pWorld->FindChildByKeyValue(m_szEndKey, pszValue));
+		}
+		else
+		{
+			// We don't have an end entity specified, use our parent as the end point.
+			m_pEndEntity = (CMapEntity *)UpdateDependency(m_pEndEntity, GetParent());
+		}
+
+		BuildLine();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Never select anything because of this helper.
+//-----------------------------------------------------------------------------
+CMapClass *CMapLine::PrepareSelection(SelectMode_t eSelectMode)
+{
+	return NULL;
+}
+
+