source-engine/hammer/texturesystem.h

376 lines
9.8 KiB
C
Raw Permalink Normal View History

2020-04-22 16:56:21 +00:00
//========= Copyright 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<IEditorTexture *> m_Textures;
CUtlDict<int,int> 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<CTextureGroup *> 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 );
// 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<CMaterialFileChangeWatcher*> 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<GRAPHICSFILESTRUCT> m_GraphicsFiles;
//
// Master array of textures.
//
CUtlVector<IEditorTexture *> 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<TextureContext_t> 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<const char *> 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