1HEADmaster

1 files changed, 233 insertions, 0 deletions

diff --git a/hammer/mapworld.h b/hammer/mapworld.h
new file mode 100644
index 0000000..0b4f285
--- /dev/null
+++ b/hammer/mapworld.h
@@ -0,0 +1,233 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef MAPWORLD_H
+#define MAPWORLD_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "MapEntity.h"
+#include "EditGameClass.h"
+#include "MapClass.h"
+#include "MapPath.h"
+
+// Flags for SaveVMF.
+#define SAVEFLAGS_LIGHTSONLY	(1<<0)
+#define SAVEFLAGS_AUTOSAVE		(1<<1)
+
+
+#define MAX_VISIBLE_OBJECTS		10000
+
+#define NUM_HASHED_ENTITY_BUCKETS	200
+
+
+class BoundBox;
+class CChunkFile;
+class CVisGroup;
+class CCullTreeNode;
+class IEditorTexture;
+class CMapGroup;
+class CMapDoc;
+class CMapInstance;
+
+struct SaveLists_t;
+
+
+struct UsedTexture_t
+{
+	IEditorTexture *pTex;
+	int nUsageCount;
+};
+
+
+class CUsedTextureList : public CUtlVector<UsedTexture_t>
+{
+public:
+
+	inline int Find(IEditorTexture *pTex)
+	{
+		for (int i = 0; i < Count(); i++)
+		{
+			if (Element(i).pTex == pTex)
+			{
+				return i;
+			}
+		}
+		
+		return -1;	
+	}
+};
+
+
+class CMapWorld : public CMapClass, public CEditGameClass
+{
+	public:
+
+		DECLARE_MAPCLASS(CMapWorld,CMapClass)
+
+		CMapWorld( void );
+		CMapWorld( CMapDoc *pOwningDocument );
+		~CMapWorld(void);
+
+		CMapDoc *GetOwningDocument( void ) { return m_pOwningDocument; }
+
+		//
+		// Public interface to the culling tree.
+		//
+		void CullTree_Build(void);
+		inline CCullTreeNode *CullTree_GetCullTree(void) { return(m_pCullTree); }
+
+		//
+		// CMapClass virtual overrides.
+		//
+		virtual void AddChild(CMapClass *pChild);
+		virtual CMapClass *Copy(bool bUpdateDependencies);
+		virtual CMapClass *CopyFrom(CMapClass *pFrom, bool bUpdateDependencies);
+		virtual void PresaveWorld(void);
+		virtual void RemoveChild(CMapClass *pChild, bool bUpdateBounds = true);
+		virtual bool IsWorld() { return true; }
+
+		virtual CMapEntity *FindChildByKeyValue( const char* key, const char* value, bool *bIsInInstance = NULL, VMatrix *InstanceMatrix = NULL );
+
+		void AddObjectToWorld(CMapClass *pObject, CMapClass *pParent = NULL);
+		void RemoveObjectFromWorld(CMapClass *pObject, bool bRemoveChildren);
+
+		// Groups have to be treated as logical because they potentially have logical children
+		virtual bool IsLogical(void) { return true; }
+		virtual bool IsVisibleLogical(void) { return IsVisible(); }
+		virtual bool IsEditable( void );
+
+		//
+		// Serialization.
+		//
+		ChunkFileResult_t LoadVMF(CChunkFile *pFile);
+		void PostloadWorld(void);
+		void PostloadVisGroups(void);
+		
+		// saveFlags is a combination of SAVEFLAGS_ defines.
+		ChunkFileResult_t SaveSolids(CChunkFile *pFile, CSaveInfo *pSaveInfo, int saveFlags);
+		ChunkFileResult_t SaveVMF(CChunkFile *pFile, CSaveInfo *pSaveInfo, int saveFlags);
+		
+		virtual int SerializeRMF(std::fstream &file, BOOL fIsStoring);
+		virtual int SerializeMAP(std::fstream &file, BOOL fIsStoring, BoundBox *pIntersecting = NULL);
+
+		virtual void UpdateChild(CMapClass *pChild);
+
+		void UpdateAllDependencies( CMapClass *pObject );
+
+		//
+		// Face ID management.
+		//
+		inline int FaceID_GetNext(void);
+		inline void FaceID_SetNext(int nNextFaceID);
+		CMapFace *FaceID_FaceForID(int nFaceID);
+		void FaceID_StringToFaceIDLists(CMapFaceIDList *pFullFaceList, CMapFaceIDList *pPartialFaceList, const char *pszValue);
+		void FaceID_StringToFaceLists(CMapFaceList *pFullFaceList, CMapFaceList *pPartialFaceList, const char *pszValue);
+		static bool FaceID_FaceIDListsToString(char *pszList, int nSize, CMapFaceIDList *pFullFaceIDList, CMapFaceIDList *pPartialFaceIDList);
+		static bool FaceID_FaceListsToString(char *pszValue, int nSize, CMapFaceList *pFullFaceList, CMapFaceList *pPartialFaceList);
+
+		void GetUsedTextures(CUsedTextureList &List);
+		void Subtract(CMapObjectList &Results, CMapClass *pSubtractWith, CMapClass *pSubtractFrom);
+
+		CUtlVector<CMapPath*> m_Paths;
+
+		// Interface to list of all the entities in the world:
+		const CMapEntityList *EntityList_GetList(void) { return(&m_EntityList); }
+		inline int EntityList_GetCount();
+		inline CMapEntity *EntityList_GetEntity( int nIndex );
+
+		CMapEntity *FindEntityByName( const char *pszName, bool bVisiblesOnly = false, bool bSearchInstanceParms = false );
+		bool FindEntitiesByKeyValue(CMapEntityList &Found, const char *szKey, const char *szValue, bool bVisiblesOnly);
+		bool FindEntitiesByName(CMapEntityList &Found, const char *szName, bool bVisiblesOnly);
+		bool FindEntitiesByClassName(CMapEntityList &Found, const char *szClassName, bool bVisiblesOnly);
+		bool FindEntitiesByNameOrClassName(CMapEntityList &Found, const char *pszName, bool bVisiblesOnly);
+		
+		bool GenerateNewTargetname( const char *startName, char *newName, int newNameBufferSize, bool bMakeUnique, const char *szPrefix, CMapClass *pRoot = NULL );
+
+		// displacement management
+		inline IWorldEditDispMgr *GetWorldEditDispManager( void ) { return m_pWorldDispMgr; }
+
+		int GetGroupList(CUtlVector<CMapGroup *> &GroupList);
+
+	protected:
+
+		//
+		// Protected entity list functions.
+		//
+		void AddEntity( CMapEntity *pEntity );
+		void EntityList_Add(CMapClass *pObject);
+		void EntityList_Remove(CMapClass *pObject, bool bRemoveChildren);
+
+		int FindEntityBucket( CMapEntity *pEntity, int *pnIndex );
+
+		//
+		// Serialization.
+		//
+		static ChunkFileResult_t LoadKeyCallback(const char *szKey, const char *szValue, CMapWorld *pWorld);
+		static ChunkFileResult_t LoadGroupCallback(CChunkFile *pFile, CMapWorld *pWorld);
+		static ChunkFileResult_t LoadHiddenCallback(CChunkFile *pFile, CMapWorld *pWorld);
+		static ChunkFileResult_t LoadHiddenSolidCallback(CChunkFile *pFile, CMapWorld *pWorld);
+		static ChunkFileResult_t LoadSolidCallback(CChunkFile *pFile, CMapWorld *pWorld);
+
+		ChunkFileResult_t LoadSolid(CChunkFile *pFile, bool bVisible);
+
+		static BOOL BuildSaveListsCallback(CMapClass *pObject, SaveLists_t *pSaveLists);
+		ChunkFileResult_t SaveObjectListVMF(CChunkFile *pFile, CSaveInfo *pSaveInfo, const CMapObjectList *pList, int saveFlags);
+
+		//
+		// Culling tree operations.
+		//
+		void CullTree_SplitNode(CCullTreeNode *pNode);
+		void CullTree_DumpNode(CCullTreeNode *pNode, int nDepth);
+		void CullTree_FreeNode(CCullTreeNode *pNode);
+		void CullTree_Free(void);
+
+		CCullTreeNode *m_pCullTree;		// This world's objects stored in a spatial hierarchy for culling.
+		
+		CMapEntityList m_EntityList;									// A flat list of all the entities in this world.
+		CMapEntityList m_EntityListByName[NUM_HASHED_ENTITY_BUCKETS];	// A list of all the entities in the world, hashed by name checksum.
+
+		int m_nNextFaceID;						// Used for assigning unique IDs to every solid face in this world.
+
+		IWorldEditDispMgr	*m_pWorldDispMgr;	// world editable displacement manager
+
+		CMapDoc				*m_pOwningDocument;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the next unique face ID for this world.
+//-----------------------------------------------------------------------------
+inline int CMapWorld::FaceID_GetNext(void)
+{
+	return(m_nNextFaceID++);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets the unique face ID to assign to the next face that is added
+//			to this world.
+//-----------------------------------------------------------------------------
+inline void CMapWorld::FaceID_SetNext(int nNextFaceID)
+{
+	m_nNextFaceID = nNextFaceID;
+}
+
+
+inline int CMapWorld::EntityList_GetCount()
+{
+	return m_EntityList.Count();
+}
+
+
+inline CMapEntity *CMapWorld::EntityList_GetEntity( int nIndex )
+{
+	return m_EntityList.Element( nIndex );
+}
+
+
+#endif // MAPWORLD_H