//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: Defines a common class for all objects in the world object tree. // // Pointers to other objects in the object tree may be stored, but // they should be set via UpdateDependency rather than directly. This // insures proper linkage to the other object so that if it moves, is // removed from the world, or changes in any other way, the dependent // object is properly notified. // //=============================================================================// #ifndef MAPCLASS_H #define MAPCLASS_H #ifdef _WIN32 #pragma once #endif #include "tier0/basetypes.h" #pragma warning(push, 1) #pragma warning(disable:4701 4702 4530) #include #pragma warning(pop) #include "BoundBox.h" #include "MapPoint.h" #include "utlvector.h" #include "visgroup.h" #include "fgdlib/wckeyvalues.h" #include "tier1/smartptr.h" class Box3D; class CBaseTool; class CChunkFile; class GDclass; class CMapClass; class CMapEntity; class CMapSolid; class CMapView2D; class CMapViewLogical; class CMapWorld; class CPoint; class CRender3D; class CSaveInfo; class CSSolid; class CVisGroupList; class CMapFaceList; struct MapError; enum ChunkFileResult_t; struct MapObjectPair_t { CMapClass *pObject1; CMapClass *pObject2; }; //----------------------------------------------------------------------------- // Structure used for returning hits when calling ObjectsAt. //----------------------------------------------------------------------------- typedef struct HitInfo_s { CMapClass *pObject; // Pointer to the CMapAtom that was clicked on. unsigned int uData; // Additional data provided by the CMapAtom object. unsigned int nDepth; // Depth value of the object that was clicked on. VMatrix m_LocalMatrix; } HitInfo_t; // // Passed into PrepareSelection to control what gets selected. // enum SelectMode_t { selectGroups = 0, // select groups, ungrouped entities, and ungrouped solids selectObjects, // select entities and solids not in entities selectSolids, // select point entities, solids in entities, solids }; enum VisGroupSelection { AUTO = 0, USER }; // helper macro for linked lists as pointers #define FOR_EACH_OBJ( listName, iteratorName ) \ for( int iteratorName=0; iteratorName<(listName).Count(); iteratorName++) typedef const char * MAPCLASSTYPE; typedef BOOL (*ENUMMAPCHILDRENPROC)(CMapClass *, unsigned int dwParam); typedef CUtlVector CMapObjectList; #define MAX_ENUM_CHILD_DEPTH 16 struct EnumChildrenStackEntry_t { CMapClass *pParent; int pos; }; struct EnumChildrenPos_t { EnumChildrenStackEntry_t Stack[MAX_ENUM_CHILD_DEPTH]; int nDepth; }; typedef struct { MAPCLASSTYPE Type; CMapClass * (*pfnNew)(); } MCMSTRUCT; // This is a reference-counted class that holds a pointer to an object. // When the object goes away, it can set the pointer in here to NULL // and anyone else who holds a reference to this can know that the // object has gone away. It's similar to the EHANDLEs in the engine, // except there's no finite list of objects that's managed anywhere. template class CSafeObject { public: static CSmartPtr< CSafeObject< T > > Create( T *pObject ) { CSafeObject *pRet = new CSafeObject( pObject ); return CSmartPtr< CSafeObject< T> >( pRet ); } void AddRef() { ++m_RefCount; } void Release() { --m_RefCount; if ( m_RefCount <= 0 ) delete this; } int GetRefCount() const { return m_RefCount; } public: T *m_pObject; private: CSafeObject( T *pObject ) { m_RefCount = 0; m_pObject = pObject; } private: int m_RefCount; // This object goes away when all smart pointers to it go away. }; class CMapClass : public CMapPoint { public: // // Construction/destruction: // CMapClass(void); virtual ~CMapClass(void); const CSmartPtr< CSafeObject< CMapClass > >& GetSafeObjectSmartPtr(); inline int GetID(void); inline void SetID(int nID); virtual size_t GetSize(void); // // Can belong to one or more visgroups: // virtual void AddVisGroup(CVisGroup *pVisGroup); int GetVisGroupCount(void); CVisGroup *GetVisGroup(int nIndex); void RemoveAllVisGroups(void); void RemoveVisGroup(CVisGroup *pVisGroup); int IsInVisGroup(CVisGroup *pVisGroup); void SetColorVisGroup(CVisGroup *pVisGroup); virtual bool UpdateObjectColor(); // // Can be tracked in the Undo/Redo system: // inline void SetTemporary(bool bTemporary) { m_bTemporary = bTemporary; } inline bool IsTemporary(void) const { return m_bTemporary; } union { struct { unsigned ID : 28; unsigned Types : 4; // 0 - copy, 1 - relationship, 2 - delete } Kept; unsigned int dwKept; }; // // Has children: // virtual void AddChild(CMapClass *pChild); virtual void CopyChildrenFrom(CMapClass *pobj, bool bUpdateDependencies); virtual void RemoveAllChildren(void); virtual void RemoveChild(CMapClass *pChild, bool bUpdateBounds = true); virtual void UpdateChild(CMapClass *pChild); inline int GetChildCount(void) { return( m_Children.Count()); } inline const CMapObjectList *GetChildren() { return &m_Children; } CMapClass *GetFirstDescendent(EnumChildrenPos_t &pos); CMapClass *GetNextDescendent(EnumChildrenPos_t &pos); virtual CMapClass *GetParent(void) { Assert( (m_pParent == NULL) || (dynamic_cast(m_pParent) != NULL) ); return( (CMapClass*)m_pParent); } virtual void SetParent(CMapAtom *pParent) { Assert( (pParent == NULL) || (dynamic_cast(pParent) != NULL) ); UpdateParent((CMapClass*)pParent); } const CMapObjectList *GetDependents() { return &m_Dependents; } virtual void FindTargetNames( CUtlVector< const char * > &Names ) { } virtual void ReplaceTargetname(const char *szOldName, const char *szNewName); // // Notifications. // virtual void OnAddToWorld(CMapWorld *pWorld); 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 OnPrePaste(CMapClass *pCopy, CMapWorld *pSourceWorld, CMapWorld *pDestWorld, const CMapObjectList &OriginalList, CMapObjectList &NewList); virtual void OnPaste(CMapClass *pCopy, CMapWorld *pSourceWorld, CMapWorld *pDestWorld, const CMapObjectList &OriginalList, CMapObjectList &NewList); virtual void OnNotifyDependent(CMapClass *pObject, Notify_Dependent_t eNotifyType); virtual void OnParentKeyChanged(const char* key, const char* value) {} virtual void OnRemoveFromWorld(CMapWorld *pWorld, bool bNotifyChildren); virtual void OnUndoRedo(void) {} virtual bool OnApply( void ) { return true; } // // Bounds calculation and intersection functions. // virtual void CalcBounds(BOOL bFullUpdate = FALSE); void GetCullBox(Vector &mins, Vector &maxs); void SetCullBoxFromFaceList( CMapFaceList *pFaces ); void GetBoundingBox( Vector &mins, Vector &maxs ); void SetBoundingBoxFromFaceList( CMapFaceList *pFaces ); void GetRender2DBox(Vector &mins, Vector &maxs); // NOTE: Logical position is in global space virtual void SetLogicalPosition( const Vector2D &vecPosition ) {} virtual const Vector2D& GetLogicalPosition( ); // NOTE: Logical bounds is in global space virtual void GetRenderLogicalBox( Vector2D &mins, Vector2D &maxs ); // HACK: temp stuff to ease the transition to not inheriting from BoundBox void GetBoundsCenter(Vector &vecCenter) { m_Render2DBox.GetBoundsCenter(vecCenter); } void GetBoundsSize(Vector &vecSize) { m_Render2DBox.GetBoundsSize(vecSize); } inline bool IsInsideBox(Vector const &Mins, Vector const &Maxs) const { return(m_Render2DBox.IsInsideBox(Mins, Maxs)); } inline bool IsIntersectingBox(const Vector &vecMins, const Vector& vecMaxs) const { return(m_Render2DBox.IsIntersectingBox(vecMins, vecMaxs)); } virtual CMapClass *PrepareSelection(SelectMode_t eSelectMode); void PostUpdate(Notify_Dependent_t eNotifyType); static void UpdateAllDependencies(CMapClass *pObject); void SetOrigin(Vector& origin); // hierarchy virtual void UpdateAnimation( float animTime ) {} virtual bool GetTransformMatrix( VMatrix& matrix ); virtual MAPCLASSTYPE GetType(void) = 0; virtual BOOL IsMapClass(MAPCLASSTYPE Type) = 0; virtual bool IsWorld() { return false; } virtual CMapClass *Copy(bool bUpdateDependencies); virtual CMapClass *CopyFrom(CMapClass *pFrom, bool bUpdateDependencies); virtual bool HitTest2D(CMapView2D *pView, const Vector2D &point, HitInfo_t &HitData); virtual bool HitTestLogical(CMapViewLogical *pView, const Vector2D &point, HitInfo_t &HitData); // Objects that can be clicked on and activated as tools implement this and return a CBaseTool-derived object. virtual CBaseTool *GetToolObject(int nHitData, bool bAttachObject) { return NULL; } // // Can be serialized: // virtual ChunkFileResult_t SaveVMF(CChunkFile *pFile, CSaveInfo *pSaveInfo); virtual ChunkFileResult_t SaveEditorData(CChunkFile *pFile); virtual bool ShouldSerialize(void) { return true; } virtual int SerializeRMF(std::fstream &File, BOOL bRMF); virtual int SerializeMAP(std::fstream &File, BOOL bRMF); virtual void PostloadWorld(CMapWorld *pWorld); virtual void PresaveWorld(void) {} bool PostloadVisGroups( bool bIsLoading ); virtual bool IsGroup(void) { return false; } virtual bool IsScaleable(void) { return false; } virtual bool IsClutter(void) { return false; } // Whether this object should be hidden when the user hides helpers. virtual bool IsCulledByCordon(const Vector &vecMins, const Vector &vecMaxs); // Whether this object is hidden based on its own intersection with the cordon, independent of its parent's intersection. virtual bool IsEditable( void ); virtual bool ShouldSnapToHalfGrid() { return false; } virtual bool IsSolid( ) { return false; } // searching virtual CMapEntity *FindChildByKeyValue( const char* key, const char* value, bool *bIsInInstance = NULL, VMatrix *InstanceMatrix = NULL ); // HACK: get the world that this object is contained within. static CMapWorld *GetWorldObject(CMapAtom *pStart); virtual const char* GetDescription() { return ""; } BOOL EnumChildren(ENUMMAPCHILDRENPROC pfn, unsigned int dwParam = 0, MAPCLASSTYPE Type = NULL); BOOL EnumChildrenRecurseGroupsOnly(ENUMMAPCHILDRENPROC pfn, unsigned int dwParam, MAPCLASSTYPE Type = NULL); BOOL IsChildOf(CMapAtom *pObject); virtual bool ShouldAppearInLightingPreview(void) { return true; //false; } virtual bool ShouldAppearInRaytracedLightingPreview(void) { return false; } inline bool IsVisible(void) { return(m_bVisible); } void SetVisible(bool bVisible); inline bool IsVisGroupShown(void) { return m_bVisGroupShown && m_bVisGroupAutoShown; } void VisGroupShow(bool bShow, VisGroupSelection eVisGroup = USER); bool CheckVisibility(bool bIsLoading = false); // // Visible2D functions are used only for hiding solids being morphed. Remove? // bool IsVisible2D(void) { return m_bVisible2D; } void SetVisible2D(bool bVisible2D) { m_bVisible2D = bVisible2D; } // Is this class potentially visible in 2D visio view? virtual bool IsLogical(void) { return false; } // Is this class actually visible in 2D visio view? virtual bool IsVisibleLogical(void) { return false; } // // Overridden to set the render color of each of our children. // virtual void SetRenderColor(unsigned char red, unsigned char green, unsigned char blue); virtual void SetRenderColor(color32 rgbColor); // // Can be rendered: // virtual void Render2D(CRender2D *pRender); virtual void Render3D(CRender3D *pRender); virtual void RenderLogical( CRender2D *pRender ) {} virtual bool RenderPreload(CRender3D *pRender, bool bNewContext); inline int GetRenderFrame(void) { return(m_nRenderFrame); } inline void SetRenderFrame(int nRenderFrame) { m_nRenderFrame = nRenderFrame; } SelectionState_t SetSelectionState(SelectionState_t eSelectionState); // // Has a set of editor-specific properties that are loaded from the VMF file. // The keys are freed after being handled by the map post-load code. // int GetEditorKeyCount(void); const char *GetEditorKey(int nIndex); const char *GetEditorKeyValue(int nIndex); const char *GetEditorKeyValue(const char *szKey); void RemoveEditorKeys(void); void SetEditorKeyValue(const char *szKey, const char *szValue); virtual void InstanceMoved( void ); public: // Set to true while loading a VMF file so it can delay certain calls like UpdateBounds. // Drastically speeds up load times. static bool s_bLoadingVMF; protected: // // Implements CMapAtom transformation interface: // virtual void DoTransform(const VMatrix &matrix); // // Serialization callbacks. // static ChunkFileResult_t LoadEditorCallback(CChunkFile *pFile, CMapClass *pObject); static ChunkFileResult_t LoadEditorKeyCallback(const char *szKey, const char *szValue, CMapClass *pObject); // // Has a list of objects that must be notified if it changes size or position. // void AddDependent(CMapClass *pDependent); void NotifyDependents(Notify_Dependent_t eNotifyType); void RemoveDependent(CMapClass *pDependent); virtual void UpdateDependencies(CMapWorld *pWorld, CMapClass *pObject) {}; CMapClass *UpdateDependency(CMapClass *pOldAttached, CMapClass *pNewAttached); void UpdateParent(CMapClass *pNewParent); void SetBoxFromFaceList( CMapFaceList *pFaces, BoundBox &Box ); CSmartPtr< CSafeObject< CMapClass > > m_pSafeObject; BoundBox m_CullBox; // Our bounds for culling in the 3D views and intersecting with the cordon. BoundBox m_BoundingBox; // Our bounds for brushes / entities themselves. This size may be smaller than m_CullBox ( i.e. spheres are not included ) BoundBox m_Render2DBox; // Our bounds for rendering in the 2D views. CMapObjectList m_Children; // Each object can have many children. Children usually transform with their parents, etc. CMapObjectList m_Dependents; // Objects that this object should notify if it changes. int m_nID; // This object's unique ID. bool m_bTemporary; // Whether to track this object for Undo/Redo. int m_nRenderFrame; // Frame counter used to avoid rendering the same object twice in a 3D frame. bool m_bVisible2D; // Whether this object is visible in the 2D view. Currently only used for morphing. bool m_bVisible; // Whether this object is currently visible in the 2D and 3D views based on ALL factors: visgroups, cordon, etc. bool m_bVisGroupShown; // Whether this object is shown or hidden by user visgroups. Kept separate from m_bVisible so we can // reflect this state in the visgroups list independent of the cordon, hide entities state, etc. bool m_bVisGroupAutoShown; // Whether this object is shown or hidden by auto visgroups. CVisGroupList m_VisGroups; // Visgroups to which this object belongs, EMPTY if none. CVisGroup *m_pColorVisGroup; // The visgroup from which we get our color, NULL if none. WCKeyValuesT *m_pEditorKeys; // Temporary storage for keys loaded from the "editor" chunk of the VMF file, freed after loading. friend class CTrackEntry; // Friends with Undo/Redo system so that parentage can be changed. friend void FixHiddenObject(MapError *pError); // So that the Check for Problems dialog can fix visgroups problems. }; //----------------------------------------------------------------------------- // Purpose: Returns this object's unique ID. //----------------------------------------------------------------------------- int CMapClass::GetID(void) { return(m_nID); } //----------------------------------------------------------------------------- // Purpose: Sets this object's unique ID. //----------------------------------------------------------------------------- void CMapClass::SetID(int nID) { m_nID = nID; } class CMapClassManager { public: virtual ~CMapClassManager(); CMapClassManager(MAPCLASSTYPE Type, CMapClass * (*pfnNew)()); static CMapClass * CreateObject(MAPCLASSTYPE Type); }; #define MAPCLASS_TYPE(class_name) \ (class_name::__Type) #define IMPLEMENT_MAPCLASS(class_name) \ char * class_name::__Type = #class_name; \ MAPCLASSTYPE class_name::GetType() { return __Type; } \ BOOL class_name::IsMapClass(MAPCLASSTYPE Type) \ { return (Type == __Type) ? TRUE : FALSE; } \ CMapClass * class_name##_CreateObject() \ { return new class_name; } \ CMapClassManager mcm_##class_name(class_name::__Type, \ class_name##_CreateObject); #define DECLARE_MAPCLASS(class_name,class_base) \ typedef class_base BaseClass; \ static char * __Type; \ virtual MAPCLASSTYPE GetType(); \ virtual BOOL IsMapClass(MAPCLASSTYPE Type); class CCheckFaceInfo { public: CCheckFaceInfo() { iPoint = -1; } char szDescription[128]; int iPoint; }; #endif // MAPCLASS_H