1

public/fgdlib/gdclass.h

@@ -0,0 +1,260 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Defines the interface to a game class as defined by the game data
+//			file (FGD). Each class is type of entity that can be placed in
+//			the editor and has attributes such as: keys that may be set,
+//			the default size and color of the entity, inputs and outputs,
+//			and any default models that are created when the entity is placed.
+//
+//			The game classes support multiple inheritence through aggregation
+//			of properties.
+//
+//=============================================================================//
+
+#ifndef GDCLASS_H
+#define GDCLASS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "HelperInfo.h"
+#include "TokenReader.h"
+#include "GDVar.h"
+#include "InputOutput.h"
+#include "mathlib/vector.h"
+
+class CHelperInfo;
+class GameData;
+class GDinputvariable;
+
+const int GD_MAX_VARIABLES = 128;
+
+
+class GDclass
+{
+	public:
+
+		GDclass(void);
+		~GDclass(void);
+
+		//
+		// Interface to class information:
+		//
+		inline const char *GetName(void) { return(m_szName); }
+		inline const char *GetDescription(void);
+
+		//
+		// Reading a class from the game data file:
+		//
+		BOOL InitFromTokens(TokenReader& tr, GameData*);
+
+		//
+		// Interface to variable information (keys):
+		//
+		inline int GetVariableCount(void) { return(m_nVariables); }
+		GDinputvariable *GetVariableAt(int iIndex);
+		void GetHelperForGDVar( GDinputvariable *pVar, CUtlVector<const char *> *helperName );
+		GDinputvariable *VarForName(const char *pszName, int *piIndex = NULL);
+		BOOL AddVariable(GDinputvariable *pVar, GDclass *pBase, int iBaseIndex, int iVarIndex);
+		void AddBase(GDclass *pBase);
+
+		//
+		// Interface to input information:
+		//
+		inline void AddInput(CClassInput *pInput);
+		CClassInput *FindInput(const char *szName);
+		inline int GetInputCount(void) { return(m_Inputs.Count()); }
+		CClassInput *GetInput(int nIndex);
+
+		//
+		// Interface to output information:
+		//
+		inline void AddOutput(CClassOutput *pOutput);
+		CClassOutput *FindOutput(const char *szName);
+		inline int GetOutputCount(void) { return(m_Outputs.Count()); }
+		CClassOutput *GetOutput(int nIndex);
+
+		GameData *Parent;
+
+		//
+		// Interface to class attributes:
+		//
+		inline bool IsClass(const char *pszClass);
+		inline bool IsSolidClass(void) { return(m_bSolid); }
+		inline bool IsBaseClass(void) { return(m_bBase); }
+		inline bool IsMoveClass(void) { return(m_bMove); }
+		inline bool IsKeyFrameClass(void) { return(m_bKeyFrame); }
+		inline bool IsPointClass(void) { return(m_bPoint); }
+		inline bool IsNPCClass(void) { return(m_bNPC); }
+		inline bool IsFilterClass(void) { return(m_bFilter); }
+		inline bool IsNodeClass(void);
+		static inline bool IsNodeClass(const char *pszClassName);
+
+		inline bool ShouldSnapToHalfGrid() { return m_bHalfGridSnap; }
+
+		inline void SetNPCClass(bool bNPC) { m_bNPC = bNPC; }
+		inline void SetFilterClass(bool bFilter) { m_bFilter = bFilter; }
+		inline void SetPointClass(bool bPoint) { m_bPoint = bPoint; }
+		inline void SetSolidClass(bool bSolid) { m_bSolid = bSolid; }
+		inline void SetBaseClass(bool bBase) { m_bBase = bBase; }
+		inline void SetMoveClass(bool bMove) { m_bMove = bMove; }
+		inline void SetKeyFrameClass(bool bKeyFrame) { m_bKeyFrame = bKeyFrame; }
+
+		inline const Vector &GetMins(void) { return(m_bmins); }
+		inline const Vector &GetMaxs(void) { return(m_bmaxs); }
+		
+		BOOL GetBoundBox(Vector& pfMins, Vector& pfMaxs);
+		bool HasBoundBox() const { return m_bGotSize; }
+
+		inline color32 GetColor(void);
+
+		//
+		// Interface to helper information:
+		//
+		inline void AddHelper(CHelperInfo *pHelper);
+		inline int GetHelperCount(void) { return(m_Helpers.Count()); }
+		CHelperInfo *GetHelper(int nIndex);
+
+	protected:
+
+		//
+		// Parsing the game data file:
+		//
+		bool ParseInput(TokenReader &tr);
+		bool ParseInputOutput(TokenReader &tr, CClassInputOutputBase *pInputOutput);
+		bool ParseOutput(TokenReader &tr);
+		bool ParseVariable(TokenReader &tr);
+
+	private:
+
+		bool ParseBase(TokenReader &tr);
+		bool ParseColor(TokenReader &tr);
+		bool ParseHelper(TokenReader &tr, char *pszHelperName);
+		bool ParseSize(TokenReader &tr);
+		bool ParseSpecifiers(TokenReader &tr);
+		bool ParseVariables(TokenReader &tr);
+
+		color32 m_rgbColor;					// Color of entity.
+
+		bool m_bBase;						// Base only - not available to user.
+		bool m_bSolid;						// Tied to solids only.
+		bool m_bModel;						// Properties of a single model.
+		bool m_bMove;						// Animatable
+		bool m_bKeyFrame;					// Animation keyframe
+		bool m_bPoint;						// Point class, not tied to solids.
+		bool m_bNPC;						// NPC class - used for populating lists of NPC classes.
+		bool m_bFilter;						// filter class - used for populating lists of filters.
+		bool m_bHalfGridSnap;				// Snaps to a 1/2 grid so it can be centered on any geometry. Used for hinges, etc.
+
+		bool m_bGotSize;					// Just for loading.
+		bool m_bGotColor;
+
+		char m_szName[MAX_IDENT];			// Name of this class.
+		char *m_pszDescription;				// Description of this class, dynamically allocated.
+
+		CUtlVector<GDinputvariable *> m_Variables;		// Variables for this class.
+		int m_nVariables;								// Count of base & local variables combined.
+		CUtlVector<GDclass *> m_Bases;					// List of base classes this class inherits from.
+
+		CClassInputList m_Inputs;
+		CClassOutputList m_Outputs;
+
+		CHelperInfoList m_Helpers;			// Helpers for this class.
+
+		//
+		//	[0] = base number from Bases, or -1 if not in a base.
+		//	[1] = index into base's variables
+		//
+		signed short m_VariableMap[GD_MAX_VARIABLES][2];
+
+		Vector m_bmins;		// 3D minima of object (pointclass).
+		Vector m_bmaxs;		// 3D maxima of object (pointclass).
+};
+
+
+void GDclass::AddInput(CClassInput *pInput)
+{
+	Assert(pInput != NULL);
+	if (pInput != NULL)
+	{
+		m_Inputs.AddToTail(pInput);
+	}
+}
+
+
+inline void GDclass::AddOutput(CClassOutput *pOutput)
+{
+	Assert(pOutput != NULL);
+	if (pOutput != NULL)
+	{
+		m_Outputs.AddToTail(pOutput);
+	}
+}
+
+
+inline void GDclass::AddHelper(CHelperInfo *pHelper)
+{
+	Assert(pHelper != NULL);
+	if (pHelper != NULL)
+	{
+		m_Helpers.AddToTail(pHelper);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the render color of this entity class.
+//-----------------------------------------------------------------------------
+color32 GDclass::GetColor(void)
+{
+	return m_rgbColor;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns a description of this entity class, or the entity class name
+//			if no description exists.
+//-----------------------------------------------------------------------------
+const char *GDclass::GetDescription(void)
+{
+	if (m_pszDescription == NULL)
+	{
+		return(m_szName);
+	}
+
+	return(m_pszDescription);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pszClass - 
+//-----------------------------------------------------------------------------
+bool GDclass::IsClass(const char *pszClass)
+{
+	Assert(pszClass != NULL);
+	return(!stricmp(pszClass, m_szName));
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns true if the given classname represents an AI node class, false if not.
+//-----------------------------------------------------------------------------
+bool GDclass::IsNodeClass(const char *pszClassName)
+{
+	return((strnicmp(pszClassName, "info_node", 9) == 0) && (stricmp(pszClassName, "info_node_link") != 0));
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns true if this is an AI node class, false if not.
+//
+// HACK: if this is necessary, we should have a new @NodeClass FGD specifier (or something)
+//-----------------------------------------------------------------------------
+bool GDclass::IsNodeClass(void)
+{
+	return(IsNodeClass(m_szName));
+}
+
+
+#endif // GDCLASS_H