//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============// // // Purpose: Texture management functions. Exposes a list of available textures, // texture groups, and Most Recently Used textures. // //=============================================================================// #ifndef TEXTURESYSTEM_H #define TEXTURESYSTEM_H #ifdef _WIN32 #pragma once #endif #include "IEditorTexture.h" #include "Material.h" #include "utlvector.h" #include "utldict.h" #include "FileChangeWatcher.h" class CGameConfig; class CTextureSystem; //----------------------------------------------------------------------------- // Purpose: Defines the interface to a set of textures of a given texture format. // The textures are stored as an index into the global array of textures. //----------------------------------------------------------------------------- class CTextureGroup { public: CTextureGroup(const char *pszName); inline const char *GetName() { return(m_szName); } inline int GetCount(void) { return m_Textures.Count(); } inline TEXTUREFORMAT GetTextureFormat(void) { return(m_eTextureFormat); } inline void SetTextureFormat(TEXTUREFORMAT eTextureFormat) { m_eTextureFormat = eTextureFormat; } void AddTexture(IEditorTexture *pTexture); void Sort(void); IEditorTexture *GetTexture(int nIndex); IEditorTexture* GetTexture( char const* pName ); // Fast find texture.. IEditorTexture* FindTextureByName( const char *pName, int *piIndex, TEXTUREFORMAT eDesiredFormat ); // Used to lazily load in all the textures void LazyLoadTextures(); protected: char m_szName[MAX_PATH]; TEXTUREFORMAT m_eTextureFormat; CUtlVector m_Textures; CUtlDict m_TextureNameMap; // Maps the texture name to an index into m_Textures (the key is IEditorTexture::GetName). // Used to lazily load the textures in the group int m_nTextureToLoad; }; typedef CUtlVector TextureGroupList_t; typedef struct tagGF { char filename[MAX_PATH]; DWORD id; int fd; TEXTUREFORMAT format; BOOL bLoaded; } GRAPHICSFILESTRUCT; // // When the user switches game configs, all the textures and materials are switched. // This structure holds all the context necessary to accomplish this. // struct TextureContext_t { CGameConfig *pConfig; // The game config that this texture context corresponds to. CTextureGroup *pAllGroup; TextureGroupList_t Groups; EditorTextureList_t MRU; // List of Most Recently Used textures, first is the most recent. EditorTextureList_t Dummies; // List of Dummy textures - textures that were created to hold the place of missing textures. }; class CMaterialFileChangeWatcher : private CFileChangeWatcher::ICallbacks { public: void Init( CTextureSystem *pSystem, int context ); void Update(); // Call this periodically to update. private: // CFileChangeWatcher::ICallbacks.. virtual void OnFileChange( const char *pRelativeFilename, const char *pFullFilename ); private: CFileChangeWatcher m_Watcher; CTextureSystem *m_pTextureSystem; int m_Context; }; class CTextureSystem : public IMaterialEnumerator { public: friend class CMaterialFileChangeWatcher; CTextureSystem(void); virtual ~CTextureSystem(void); bool Initialize(HWND hwnd); void ShutDown(void); void SetActiveConfig(CGameConfig *pConfig); // // Exposes a list of all texture (WAD) files. // inline int FilesGetCount(void) const; inline void FilesGetInfo(GRAPHICSFILESTRUCT *pFileInfo, int nIndex) const; bool FindGraphicsFile(GRAPHICSFILESTRUCT *pFileInfo, DWORD id, int *piIndex = NULL); // // Exposes a list of texture groups (sets of textures of a given format). // void SetActiveGroup(const char *pcszName); inline int GroupsGetCount() const; inline CTextureGroup *GroupsGet(int nIndex) const; // // Exposes a list of active textures based on the currently active texture group. // inline int GetActiveTextureCount(void) const; inline IEditorTexture *GetActiveTexture(int nIndex) const; IEditorTexture *EnumActiveTextures(int *piIndex, TEXTUREFORMAT eDesiredFormat) const; IEditorTexture *FindActiveTexture(LPCSTR pszName, int *piIndex = NULL, BOOL bDummy = TRUE); bool HasTexturesForConfig(CGameConfig *pConfig); // // Exposes a list of Most Recently Used textures. // void AddMRU(IEditorTexture *pTex); inline int MRUGetCount() const; inline IEditorTexture *MRUGet(int nIndex) const; // // Exposes a list of all unique keywords found in the master texture list. // int GetNumKeywords(); const char *GetKeyword(int index); // // Holds a list of placeholder textures used when a map refers to missing textures. // IEditorTexture *AddDummy(LPCTSTR pszName, TEXTUREFORMAT eFormat); // // Load graphics files from options list. // void LoadAllGraphicsFiles(void); void InformPaletteChanged(void); // IMaterialEnumerator interface, Used to add all the world materials into the material list. bool EnumMaterial( const char *pMaterialName, int nContext ); // Used to lazily load in all the textures during app idle. void LazyLoadTextures(); // Registers the keywords as existing in a particular material. void RegisterTextureKeywords( IEditorTexture *pTexture ); // Opens the source file associated with a material. void OpenSource( const char *pMaterialName ); // Opens explorer dialog and selects the source file void ExploreToSource( const char *pMaterialName ); // Reload individual textures. void ReloadTextures( const char *pFilterName ); // bind local cubemap again void RebindDefaultCubeMap(); void UpdateFileChangeWatchers(); // Gets tools/toolsnodraw IEditorTexture* GetNoDrawTexture() { return m_pNoDrawTexture; } int AddTexture( IEditorTexture *pTexture ); protected: // CMaterialFileChangeWatcher stuff - watches for changes to VMTs or VTFs and handles them. enum EFileType { k_eFileTypeVMT, k_eFileTypeVTF }; void OnFileChange( const char *pFilename, int context, EFileType eFileType ); void ReloadMaterialsUsingTexture( ITexture *pTestTexture ); static bool GetFileTypeFromFilename( const char *pFilename, CTextureSystem::EFileType *pFileType ); CUtlVector m_ChangeWatchers; // Internal stuff. void FreeAllTextures(); TextureContext_t *AddTextureContext(); TextureContext_t *FindTextureContextForConfig(CGameConfig *pConfig); void LoadMaterials(CGameConfig *pConfig); void LoadWADFiles(CGameConfig *pConfig); DWORD LoadGraphicsFile(const char *pFilename); void LoadGraphicsFileWAD3(GRAPHICSFILESTRUCT *pFile, int fd, CTextureGroup *pGroup); // // Array of open graphics files. // CUtlVector m_GraphicsFiles; // // Master array of textures. // CUtlVector m_Textures; IEditorTexture *m_pLastTex; int m_nLastIndex; // // List of groups (sets of textures of a given texture format). Only one // group can be active at a time, based on the game configuration. // CUtlVector m_TextureContexts; // One per game config. TextureContext_t *m_pActiveContext; // Points to the active entry in m_TextureContexts. CTextureGroup *m_pActiveGroup; // Points to the active entry in m_TextureContexts. // // List of keywords found in all textures. // CUtlVector m_Keywords; // default cubemap ITexture *m_pCubemapTexture; // tools/toolsnodraw IEditorTexture* m_pNoDrawTexture; }; //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- int CTextureSystem::FilesGetCount(void) const { return(m_GraphicsFiles.Count()); } //----------------------------------------------------------------------------- // Purpose: // Input : pFileInfo - // nIndex - //----------------------------------------------------------------------------- void CTextureSystem::FilesGetInfo(GRAPHICSFILESTRUCT *pFileInfo, int nIndex) const { if (pFileInfo != NULL) { *pFileInfo = m_GraphicsFiles[nIndex]; } } //----------------------------------------------------------------------------- // Purpose: Returns the number of textures in the active group. //----------------------------------------------------------------------------- int CTextureSystem::GetActiveTextureCount(void) const { if (m_pActiveGroup != NULL) { return m_pActiveGroup->GetCount(); } return(0); } IEditorTexture *CTextureSystem::GetActiveTexture(int nIndex) const { if (m_pActiveGroup != NULL) { return m_pActiveGroup->GetTexture(nIndex); } return NULL; } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- int CTextureSystem::GroupsGetCount() const { if (!m_pActiveContext) return 0; return m_pActiveContext->Groups.Count(); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- CTextureGroup *CTextureSystem::GroupsGet(int nIndex) const { if (!m_pActiveContext) return NULL; return m_pActiveContext->Groups.Element(nIndex); } //----------------------------------------------------------------------------- // Purpose: Initiates an iteration of the MRU list. //----------------------------------------------------------------------------- int CTextureSystem::MRUGetCount() const { if (!m_pActiveContext) return NULL; return m_pActiveContext->MRU.Count(); } //----------------------------------------------------------------------------- // Purpose: Returns the next texture in the MRU of the given format. // Input : pos - Iterator. // eDesiredFormat - Texture format to return. // Output : Pointer to the texture. //----------------------------------------------------------------------------- IEditorTexture *CTextureSystem::MRUGet(int nIndex) const { if (!m_pActiveContext) return NULL; return m_pActiveContext->MRU.Element(nIndex); } extern CTextureSystem g_Textures; #endif // TEXTURESYSTEM_H