source-engine/hammer/mapentity.h

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//===========================================================================//

#ifndef MAPENTITY_H
#define MAPENTITY_H
#pragma once

#include "MapClass.h"
#include "MapFace.h"			// FIXME: For PLANE definition.
#include "EditGameClass.h"


class CMapAnimator;
class CRender2D;
class CManifest;

enum LogicalConnection_t
{
	LOGICAL_CONNECTION_INPUT = 0,
	LOGICAL_CONNECTION_OUTPUT,
};

int CompareEntityNames(const char *szName1, const char *szName2);

#define ENTITY_FLAG_IS_LIGHT			1
#define ENTITY_FLAG_SHOW_IN_LPREVIEW2	2
#define ENTITY_FLAG_IS_INSTANCE			4


class CMapEntity : public CMapClass, public CEditGameClass
{
	friend CManifest;

public:

	DECLARE_MAPCLASS(CMapEntity,CMapClass);

	CMapEntity(); 
	~CMapEntity();

	void Debug(void);

	size_t GetSize();

	int m_EntityTypeFlags;									// for fast checks w/o using class name
	
	//
	// For flags field.
	//
	enum
	{
		flagPlaceholder = 0x01,	// No solids - just a point entity
	};

	enum alignType_e
	{
		ALIGN_TOP,
		ALIGN_BOTTOM,
	};

	bool NameMatches(const char *szName);
	bool ClassNameMatches(const char *szName);

	virtual bool ShouldAppearInRaytracedLightingPreview(void)
	{
		return ( m_EntityTypeFlags & ENTITY_FLAG_SHOW_IN_LPREVIEW2 ) != 0;
	}

	static inline void ShowEntityNames(bool bShow) { s_bShowEntityNames = bShow; }
	static inline bool GetShowEntityNames(void) { return s_bShowEntityNames; }

	static inline void ShowEntityConnections(bool bShow) { s_bShowEntityConnections = bShow; }
	static inline bool GetShowEntityConnections(void) { return s_bShowEntityConnections; }

	static inline void ShowUnconnectedEntities(bool bShow) { s_bShowUnconnectedEntities = bShow; }
	static inline bool GetShowUnconnectedEntities(void) { return s_bShowUnconnectedEntities; }

	void ReplaceTargetname(const char *szOldName, const char *szNewName);

	void CalculateTypeFlags( void );

	virtual void SignalChanged(void );								// object has changed

	inline void SetPlaceholder(BOOL bSet)
	{
		if (bSet)
		{
			flags |= flagPlaceholder;
		}
		else
		{
			flags &= ~flagPlaceholder;
		}
	}

	inline BOOL IsPlaceholder(void)
	{
		return((flags & flagPlaceholder) ? TRUE : FALSE);
	}

	bool UpdateObjectColor();

	//
	// CMapClass overrides.
	//
	bool IsCulledByCordon(const Vector &vecMins, const Vector &vecMaxs);

	//
	// Serialization.
	//
	ChunkFileResult_t LoadVMF(CChunkFile *pFile);
	ChunkFileResult_t SaveVMF(CChunkFile *pFile, CSaveInfo *pSaveInfo);
	int SerializeRMF(std::fstream&, BOOL);
	int SerializeMAP(std::fstream&, BOOL);
	virtual void PostloadWorld(CMapWorld *pWorld);
	virtual ChunkFileResult_t SaveEditorData(CChunkFile *pFile);

	//
	// Rendering.
	//
	virtual void Render2D(CRender2D *pRender);
	virtual void RenderLogical( CRender2D *pRender );
	virtual bool IsLogical();
	virtual bool IsVisibleLogical(void);
	virtual void SetLogicalPosition( const Vector2D &vecPosition );
	virtual const Vector2D& GetLogicalPosition( );
	virtual void GetRenderLogicalBox( Vector2D &mins, Vector2D &maxs );
	void GetLogicalConnectionPosition( LogicalConnection_t i, Vector2D &vecPosition );

	virtual bool ShouldSnapToHalfGrid();

	virtual void SetOrigin(Vector& o);
	virtual void CalcBounds(BOOL bFullUpdate = FALSE);
	inline void SetClass(GDclass *pClass) { CEditGameClass::SetClass(pClass); } // Works around a namespace issue.
	virtual void SetClass(LPCTSTR pszClassname, bool bLoading = false);
	virtual void AlignOnPlane( Vector& pos, PLANE *plane, alignType_e align );

	//
	// Hit testing/selection.
	//
	virtual CMapClass *PrepareSelection(SelectMode_t eSelectMode);
	virtual bool HitTest2D(CMapView2D *pView, const Vector2D &point, HitInfo_t &HitData);
	virtual bool HitTestLogical(CMapViewLogical *pView, const Vector2D &point, HitInfo_t &nHitData);

	//
	// Notifications.
	//
	virtual void OnClone(CMapClass *pClone, CMapWorld *pWorld, const CMapObjectList &OriginalList, CMapObjectList &NewList);
	virtual void OnPreClone(CMapClass *pClone, CMapWorld *pWorld, const CMapObjectList &OriginalList, CMapObjectList &NewList);
	virtual void OnAddToWorld(CMapWorld *pWorld);
	virtual void OnRemoveFromWorld(CMapWorld *pWorld, bool bNotifyChildren );
	virtual void OnNotifyDependent(CMapClass *pObject, Notify_Dependent_t eNotifyType);
	virtual void OnPrePaste( CMapClass *pCopy, CMapWorld *pSourceWorld, CMapWorld *pDestWorld, const CMapObjectList &OriginalList, CMapObjectList &NewList );
	virtual void OnPaste( CMapClass *pCopyObject, CMapWorld *pSourceWorld, CMapWorld *pDestWorld, const CMapObjectList &OriginalList, CMapObjectList &NewList );

	virtual void UpdateDependencies(CMapWorld *pWorld, CMapClass *pObject);

	virtual bool OnApply( void );

	//
	// Keyvalue access. We need to know any time one of our keyvalues changes.
	//
	virtual void SetKeyValue(LPCSTR pszKey, LPCSTR pszValue);
	virtual void DeleteKeyValue(LPCTSTR pszKey);

	int GetNodeID(void);
	int SetNodeID(int nNodeID);

	void NotifyChildKeyChanged(CMapClass *pChild, const char *szKey, const char *szValue);

	virtual CMapEntity *FindChildByKeyValue( LPCSTR key, LPCSTR value, bool *bIsInInstance = NULL, VMatrix *InstanceMatrix = NULL );

	virtual CMapClass *Copy(bool bUpdateDependencies);
	virtual CMapClass *CopyFrom(CMapClass *pFrom, bool bUpdateDependencies);

	virtual void AddChild(CMapClass *pChild);

	bool HasSolidChildren(void);

	void AssignNodeID(void);

	const char* GetDescription();
	bool IsScaleable() { return !IsPlaceholder(); }

	// animation
	bool GetTransformMatrix( VMatrix& matrix );
	BOOL IsAnimationController( void ) { return IsMoveClass(); }

	//-----------------------------------------------------------------------------
	// Purpose: If the first child of this entity is of type MapClass, this function
	//			returns a pointer to that child.
	// Output : Returns a pointer to the MapClass that is a child of this
	//			entity, NULL if the first child of this entity is not MapClass.
	//-----------------------------------------------------------------------------
	template< class MapClass >
	MapClass *GetChildOfType( MapClass *null )
	{
		FOR_EACH_OBJ( m_Children, pos )
		{
			MapClass *pChild = dynamic_cast<MapClass*>( m_Children.Element(pos) );
			if ( pChild != NULL )
			{
				return pChild;
			}
		}

		return NULL;
	}

	//
	// CMapAtom implementation.
	//
	virtual void GetRenderColor( CRender2D *pRender, unsigned char &red, unsigned char &green, unsigned char &blue);
	virtual color32 GetRenderColor( CRender2D *pRender );

// 	char const* GetKeyValue( char *symbol )
// 	{
// 		return m_KeyValues.GetValue(symbol );
// 	}

private:

	void EnsureUniqueNodeID(CMapWorld *pWorld);
	void OnKeyValueChanged(const char *pszKey, const char *pszOldValue, const char *pszValue);

	//
	// Each CMapEntity may have one or more helpers as its children, depending
	// on its class definition in the FGD file.
	//
	void AddBoundBoxForClass(GDclass *pClass, bool bLoading);
	void AddHelper(CMapClass *pHelper, bool bLoading);
	void AddHelpersForClass(GDclass *pClass, bool bLoading);
	void RemoveHelpers(bool bRemoveSolids);
	void UpdateHelpers(bool bLoading);

	// Safely sets the move parent. Will assert and not set it if pEnt is equal to this ent,
	// or if this ent is already a parent of pEnt.
	void SetMoveParent( CMapEntity *pEnt );

	//
	// Chunk and key value handlers for loading.
	//
	static ChunkFileResult_t LoadSolidCallback(CChunkFile *pFile, CMapEntity *pEntity);
	static ChunkFileResult_t LoadEditorCallback(CChunkFile *pFile, CMapEntity *pEntity);
	static ChunkFileResult_t LoadHiddenCallback(CChunkFile *pFile, CMapEntity *pEntity);
	static ChunkFileResult_t LoadKeyCallback(const char *szKey, const char *szValue, CMapEntity *pEntity);
	static ChunkFileResult_t LoadEditorKeyCallback(const char *szKey, const char *szValue, CMapEntity *pEntity);

	static bool s_bShowEntityNames;			// Whether to render entity names in the 2D views.
	static bool s_bShowEntityConnections;	// Whether to render lines indicating entity connections in the 2D views.
	static bool s_bShowUnconnectedEntities;	// Whether to render unconnected entities in logical views

	WORD flags;							// flagPlaceholder
	CMapEntity *m_pMoveParent;			// for entity movement hierarchy
	CMapAnimator *m_pAnimatorChild;
	Vector2D m_vecLogicalPosition;	// Position in logical space
};


typedef CUtlVector<CMapEntity*> CMapEntityList;

bool MapEntityList_HasInput(const CMapEntityList *pList, const char *szInput, InputOutputType_t eType = iotInvalid);

#endif // MAPENTITY_H