H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 22:27:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
9d77bb17c5
source-engine/hammer/texturesystem.cpp

1361 lines
35 KiB
C++
Raw Normal View History

1
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.
//
// There is one texture context per game configuration in GameCfg.ini.
//
//=============================================================================//
#include "stdafx.h"
#include <process.h>
#include <io.h>
#include <sys\stat.h>
#include <fcntl.h>
#include "DummyTexture.h" // Specific IEditorTexture implementation
#include "GlobalFunctions.h"
#include "MainFrm.h"
#include "MapDoc.h"
#include "Material.h" // Specific IEditorTexture implementation
#include "Options.h"
#include "TextureSystem.h"
#include "WADTexture.h" // Specific IEditorTexture implementation
#include "WADTypes.h"
#include "hammer.h"
#include "filesystem.h"
#include "materialsystem/itexture.h"
#include "tier1/utldict.h"
#include "FaceEditSheet.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
#pragma warning(disable:4244)
#define _GraphicCacheAllocate(n) malloc(n)
#define IsSortChr(ch) ((ch == '-') || (ch == '+'))
//-----------------------------------------------------------------------------
// Stuff for loading WAD3 files.
//-----------------------------------------------------------------------------
typedef struct
{
int filepos;
int disksize;
int size; // uncompressed
char type;
char compression;
char pad1, pad2;
char name[16]; // must be null terminated
} WAD3lumpinfo_t;
//-----------------------------------------------------------------------------
// List of global graphics
//-----------------------------------------------------------------------------
CTextureSystem g_Textures;
//-----------------------------------------------------------------------------
// CMaterialFileChangeWatcher implementation.
//-----------------------------------------------------------------------------
void CMaterialFileChangeWatcher::Init( CTextureSystem *pSystem, int context )
{
m_pTextureSystem = pSystem;
m_Context = context;
m_Watcher.Init( this );
char searchPaths[1024 * 16];
if ( g_pFullFileSystem->GetSearchPath( "GAME", false, searchPaths, sizeof( searchPaths ) ) > 0 )
{
CUtlVector<char*> searchPathList;
V_SplitString( searchPaths, ";", searchPathList );
for ( int i=0; i < searchPathList.Count(); i++ )
{
m_Watcher.AddDirectory( searchPathList[i], "materials", true );
}
searchPathList.PurgeAndDeleteElements();
}
else
{
Warning( "Error in GetSearchPath. Dynamic material list updating will not be available." );
}
}
void CMaterialFileChangeWatcher::OnFileChange( const char *pRelativeFilename, const char *pFullFilename )
{
//Msg( "OnNewFile: %s\n", pRelativeFilename );
CTextureSystem::EFileType eFileType;
if ( CTextureSystem::GetFileTypeFromFilename( pRelativeFilename, &eFileType ) )
m_pTextureSystem->OnFileChange( pRelativeFilename, m_Context, eFileType );
}
void CMaterialFileChangeWatcher::Update()
{
m_Watcher.Update();
}
//-----------------------------------------------------------------------------
// Purpose: Constructor. Creates the "All" group and sets it as the active group.
//-----------------------------------------------------------------------------
CTextureSystem::CTextureSystem(void)
{
m_pLastTex = NULL;
m_nLastIndex = 0;
m_pActiveContext = NULL;
m_pActiveGroup = NULL;
m_pCubemapTexture = NULL;
m_pNoDrawTexture = NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Destructor. Frees the list of groups and dummy textures.
//-----------------------------------------------------------------------------
CTextureSystem::~CTextureSystem(void)
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTextureSystem::FreeAllTextures()
{
if ( m_pCubemapTexture )
{
m_pCubemapTexture->DecrementReferenceCount();
m_pCubemapTexture = NULL;
}
int nContextCount = m_TextureContexts.Count();
for (int nContext = 0; nContext < nContextCount; nContext++)
{
TextureContext_t *pContext = &m_TextureContexts.Element(nContext);
//
// Delete all the texture groups for this context.
//
int nGroupCount = pContext->Groups.Count();
for (int nGroup = 0; nGroup < nGroupCount; nGroup++)
{
delete pContext->Groups.Element(nGroup);
}
//
// Delete dummy textures.
//
int nDummyCount = pContext->Dummies.Count();
for (int nDummy = 0; nDummy < nDummyCount; nDummy++)
{
IEditorTexture *pTex = pContext->Dummies.Element(nDummy);
delete pTex;
}
}
//
// Delete all the textures from the master list.
//
for (int i = 0; i < m_Textures.Count(); i++)
{
IEditorTexture *pTex = m_Textures[i];
delete pTex;
}
m_Textures.RemoveAll();
m_pLastTex = NULL;
m_nLastIndex = -1;
// Delete the keywords.
m_Keywords.PurgeAndDeleteElements();
m_ChangeWatchers.PurgeAndDeleteElements();
}
//-----------------------------------------------------------------------------
// Purpose: Adds a texture to the master list of textures.
// Input : pTexture - Pointer to texture to add.
// Output : Returns the index of the texture in the master texture list.
//-----------------------------------------------------------------------------
int CTextureSystem::AddTexture(IEditorTexture *pTexture)
{
return m_Textures.AddToTail(pTexture);
}
//-----------------------------------------------------------------------------
// Purpose: Begins iterating the list of texture/material keywords.
//-----------------------------------------------------------------------------
int CTextureSystem::GetNumKeywords(void)
{
return(m_Keywords.Count());
}
//-----------------------------------------------------------------------------
// Purpose: Continues iterating the list of texture/material keywords.
//-----------------------------------------------------------------------------
const char *CTextureSystem::GetKeyword(int pos)
{
return(m_Keywords.Element(pos));
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *piIndex -
// bUseMRU -
// Output :
//-----------------------------------------------------------------------------
IEditorTexture *CTextureSystem::EnumActiveTextures(int *piIndex, TEXTUREFORMAT eDesiredFormat) const
{
Assert(piIndex != NULL);
if (piIndex != NULL)
{
if (m_pActiveGroup != NULL)
{
IEditorTexture *pTex = NULL;
do
{
pTex = m_pActiveGroup->GetTexture(*piIndex);
if (pTex != NULL)
{
(*piIndex)++;
if ((eDesiredFormat == tfNone) || (pTex->GetTextureFormat() == eDesiredFormat))
{
return(pTex);
}
}
} while (pTex != NULL);
}
}
return(NULL);
}
//-----------------------------------------------------------------------------
// Purpose: Initializes the texture system.
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTextureSystem::Initialize(HWND hwnd)
{
bool bWAD = CWADTexture::Initialize();
bool bMaterial = CMaterial::Initialize(hwnd);
return(bWAD && bMaterial);
}
//-----------------------------------------------------------------------------
// Purpose: Shuts down the texture system.
//-----------------------------------------------------------------------------
void CTextureSystem::ShutDown(void)
{
CWADTexture::ShutDown();
CMaterial::ShutDown();
FreeAllTextures();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pszName -
// piIndex -
// bDummy -
// Output :
//-----------------------------------------------------------------------------
IEditorTexture *CTextureSystem::FindActiveTexture(LPCSTR pszInputName, int *piIndex, BOOL bDummy)
{
// The .vmf file format gets confused if there are backslashes in material names,
// so make sure they're all using forward slashes here.
char szName[MAX_PATH];
Q_StrSubst( pszInputName, "\\", "/", szName, sizeof( szName ) );
const char *pszName = szName;
IEditorTexture *pTex = NULL;
//
// Check the cache first.
//
if (m_pLastTex && !stricmp(pszName, m_pLastTex->GetName()))
{
if (piIndex)
{
*piIndex = m_nLastIndex;
}
return m_pLastTex;
}
int iIndex = 0;
// We're finding by name, so we don't care what the format is as long as the name matches.
if ( m_pActiveGroup )
{
pTex = m_pActiveGroup->FindTextureByName( pszName, &iIndex, tfNone );
if ( pTex )
{
if ( piIndex )
*piIndex = iIndex;
m_pLastTex = pTex;
m_nLastIndex = iIndex;
return pTex;
}
}
//
// Let's try again, this time with \textures\ decoration
// TODO: remove this?
//
{
iIndex = 0;
char szBuf[512];
sprintf(szBuf, "textures\\%s", pszName);
for (int i = strlen(szBuf) -1; i >= 0; i--)
{
if (szBuf[i] == '/')
szBuf[i] = '\\';
}
strlwr(szBuf);
if ( m_pActiveGroup )
{
pTex = m_pActiveGroup->FindTextureByName( szBuf, &iIndex, tfNone );
if ( pTex )
{
if ( piIndex )
*piIndex = iIndex;
m_pLastTex = pTex;
m_nLastIndex = iIndex;
return pTex;
}
}
}
//
// Caller doesn't want dummies.
//
if (!bDummy)
{
return(NULL);
}
Assert(!piIndex);
//
// Check the list of dummies for a texture with the same name and texture format.
//
if (m_pActiveContext)
{
int nDummyCount = m_pActiveContext->Dummies.Count();
for (int nDummy = 0; nDummy < nDummyCount; nDummy++)
{
IEditorTexture *pTexDummy = m_pActiveContext->Dummies.Element(nDummy);
if (!strcmpi(pszName, pTexDummy->GetName()))
{
m_pLastTex = pTexDummy;
m_nLastIndex = -1;
return(pTexDummy);
}
}
//
// Not found; add a dummy as a placeholder for the missing texture.
//
pTex = AddDummy(pszName, g_pGameConfig->GetTextureFormat());
}
if (pTex != NULL)
{
m_pLastTex = pTex;
m_nLastIndex = -1;
}
return(pTex);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pTex -
//-----------------------------------------------------------------------------
void CTextureSystem::AddMRU(IEditorTexture *pTex)
{
if (!m_pActiveContext)
return;
int nIndex = m_pActiveContext->MRU.Find(pTex);
if (nIndex != -1)
{
m_pActiveContext->MRU.Remove(nIndex);
}
else if (m_pActiveContext->MRU.Count() == 8)
{
m_pActiveContext->MRU.Remove(7);
}
m_pActiveContext->MRU.AddToHead(pTex);
}
//-----------------------------------------------------------------------------
// Purpose: Change palette on all textures.
// Input :
// dvs: need to handle a palette change for Quake support
//-----------------------------------------------------------------------------
void CTextureSystem::InformPaletteChanged()
{
// int nGraphics = GetCount();
//
// for (int i = 0; i < nGraphics; i++)
// {
// IEditorTexture *pTex = &GetAt(i);
// }
}
//-----------------------------------------------------------------------------
// Purpose: Returns the texture context that corresponds to the given game config.
//-----------------------------------------------------------------------------
TextureContext_t *CTextureSystem::FindTextureContextForConfig(CGameConfig *pConfig)
{
for (int i = 0; i < m_TextureContexts.Count(); i++)
{
if (m_TextureContexts.Element(i).pConfig == pConfig)
{
return &m_TextureContexts.Element(i);
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTextureSystem::SetActiveConfig(CGameConfig *pConfig)
{
TextureContext_t *pContext = FindTextureContextForConfig(pConfig);
if (pContext)
{
m_pActiveContext = pContext;
m_pActiveGroup = m_pActiveContext->pAllGroup;
}
else
{
m_pActiveContext = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : char *pcszName -
//-----------------------------------------------------------------------------
void CTextureSystem::SetActiveGroup(const char *pcszName)
{
if (!m_pActiveContext)
return;
char szBuf[MAX_PATH];
sprintf(szBuf, "textures\\%s", pcszName);
int iCount = m_pActiveContext->Groups.Count();
for (int i = 0; i < iCount; i++)
{
CTextureGroup *pGroup = m_pActiveContext->Groups.Element(i);
if (!strcmpi(pGroup->GetName(), pcszName))
{
m_pActiveGroup = pGroup;
return;
}
if (strstr(pGroup->GetName(), pcszName))
{
m_pActiveGroup = pGroup;
return;
}
}
TRACE0("No Group Found!");
}
void HammerFileSystem_ReportSearchPath( const char *szPathID )
{
char szSearchPath[ 4096 ];
g_pFullFileSystem->GetSearchPath( szPathID, true, szSearchPath, sizeof( szSearchPath ) );
Msg( mwStatus, "------------------------------------------------------------------" );
char *pszOnePath = strtok( szSearchPath, ";" );
while ( pszOnePath )
{
Msg( mwStatus, "Search Path (%s): %s", szPathID, pszOnePath );
pszOnePath = strtok( NULL, ";" );
}
}
//-----------------------------------------------------------------------------
// FIXME: Make this work correctly, using the version in filesystem_tools.cpp
// (it doesn't work currently owing to filesystem setup issues)
//-----------------------------------------------------------------------------
void HammerFileSystem_SetGame( const char *pExeDir, const char *pModDir )
{
static bool s_bOnce = false;
Assert( !s_bOnce );
s_bOnce = true;
char buf[MAX_PATH];
Q_snprintf( buf, MAX_PATH, "%s\\hl2", pExeDir );
g_pFullFileSystem->AddSearchPath( buf, "GAME", PATH_ADD_TO_HEAD );
if ( pModDir && *pModDir != '\0' )
{
g_pFullFileSystem->AddSearchPath( pModDir, "GAME", PATH_ADD_TO_HEAD );
}
HammerFileSystem_ReportSearchPath( "GAME" );
}
//-----------------------------------------------------------------------------
// Purpose: Loads textures from all texture files.
//-----------------------------------------------------------------------------
void CTextureSystem::LoadAllGraphicsFiles(void)
{
FreeAllTextures();
// For each game config...
// dvs: Disabled for single-config running.
//for (int nConfig = 0; nConfig < Options.configs.GetGameConfigCount(); nConfig++)
{
//CGameConfig *pConfig = Options.configs.GetGameConfig(nConfig);
CGameConfig *pConfig = g_pGameConfig;
// Create a new texture context with the WADs and materials for that config.
TextureContext_t *pContext = AddTextureContext();
// Bind it to this config.
pContext->pConfig = pConfig;
// Create a group to hold all the textures for this context.
pContext->pAllGroup = new CTextureGroup("All Textures");
pContext->Groups.AddToTail(pContext->pAllGroup);
HammerFileSystem_SetGame(pConfig->m_szGameExeDir, pConfig->m_szModDir);
// Set the new context as the active context.
m_pActiveContext = pContext;
// Load the textures for all WAD files set in this config.
// Only do this for configs that use WAD textures.
if (pConfig->GetTextureFormat() == tfWAD3)
{
LoadWADFiles(pConfig);
}
// Load the materials for this config.
// Do this unconditionally so that we get necessary editor materials.
LoadMaterials(pConfig);
m_pActiveContext->pAllGroup->Sort();
}
}
//-----------------------------------------------------------------------------
// Purpose: Loads all WAD files for the given game config.
//-----------------------------------------------------------------------------
void CTextureSystem::LoadWADFiles(CGameConfig *pConfig)
{
// dvs: FIXME: WADs are not currently per-config
for (int i = 0; i < Options.textures.nTextureFiles; i++)
{
LoadGraphicsFile(Options.textures.TextureFiles[i]);
}
}
//-----------------------------------------------------------------------------
// Purpose: Loads all the materials for the given game config.
//-----------------------------------------------------------------------------
void CTextureSystem::LoadMaterials(CGameConfig *pConfig)
{
CTextureGroup *pGroup = new CTextureGroup("Materials");
pGroup->SetTextureFormat(tfVMT);
m_pActiveContext->Groups.AddToTail(pGroup);
// Add all the materials to the group.
CMaterial::EnumerateMaterials( this, "materials", (int)pGroup, INCLUDE_WORLD_MATERIALS );
// Watch the materials directory recursively...
CMaterialFileChangeWatcher *pWatcher = new CMaterialFileChangeWatcher;
pWatcher->Init( this, (int)pGroup );
m_ChangeWatchers.AddToTail( pWatcher );
Assert( m_pCubemapTexture == NULL );
m_pCubemapTexture = MaterialSystemInterface()->FindTexture( "editor/cubemap", NULL, true );
if ( m_pCubemapTexture )
{
m_pCubemapTexture->IncrementReferenceCount();
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
pRenderContext->BindLocalCubemap( m_pCubemapTexture );
}
// Get the nodraw texture.
m_pNoDrawTexture = NULL;
for ( int i=0; i < m_Textures.Count(); i++ )
{
if ( V_stricmp( m_Textures[i]->GetName(), "tools/toolsnodraw" ) == 0 || V_stricmp( m_Textures[i]->GetName(), "tools/toolsnodraw" ) == 0 )
{
m_pNoDrawTexture = m_Textures[i];
break;
}
}
if ( !m_pNoDrawTexture )
m_pNoDrawTexture = CMaterial::CreateMaterial( "tools/toolsnodraw", true );
}
void CTextureSystem::RebindDefaultCubeMap()
{
// rebind with the default cubemap
if ( m_pCubemapTexture )
{
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
pRenderContext->BindLocalCubemap( m_pCubemapTexture );
}
}
void CTextureSystem::UpdateFileChangeWatchers()
{
for ( int i=0; i < m_ChangeWatchers.Count(); i++ )
m_ChangeWatchers[i]->Update();
}
void CTextureSystem::OnFileChange( const char *pFilename, int context, CTextureSystem::EFileType eFileType )
{
// It requires the forward slashes later...
char fixedSlashes[MAX_PATH];
V_StrSubst( pFilename, "\\", "/", fixedSlashes, sizeof( fixedSlashes ) );
// Get rid of the extension.
if ( V_strlen( fixedSlashes ) < 5 )
{
Assert( false );
return;
}
fixedSlashes[ V_strlen( fixedSlashes ) - 4 ] = 0;
// Handle it based on what type of file we've got.
if ( eFileType == k_eFileTypeVMT )
{
IEditorTexture *pTex = FindActiveTexture( fixedSlashes, NULL, FALSE );
if ( pTex )
{
pTex->Reload( true );
}
else
{
EnumMaterial( fixedSlashes, context );
IEditorTexture *pTexFixed = FindActiveTexture( fixedSlashes, NULL, FALSE );
if ( pTexFixed )
{
GetMainWnd()->m_TextureBar.NotifyNewMaterial( pTexFixed );
GetMainWnd()->GetFaceEditSheet()->NotifyNewMaterial( pTexFixed );
}
}
}
else if ( eFileType == k_eFileTypeVTF )
{
// Whether a VTF was added, removed, or modified, we do the same thing.. refresh it and any materials that reference it.
ITexture *pTexture = materials->FindTexture( fixedSlashes, TEXTURE_GROUP_UNACCOUNTED, false );
if ( pTexture )
{
pTexture->Download( NULL );
ReloadMaterialsUsingTexture( pTexture );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Load any materials that reference this texture. Used so we can refresh a
// material's preview image if a relevant .vtf changes.
//-----------------------------------------------------------------------------
void CTextureSystem::ReloadMaterialsUsingTexture( ITexture *pTestTexture )
{
for ( int i=0; i < m_Textures.Count(); i++ )
{
IEditorTexture *pEditorTex = m_Textures[i];
IMaterial *pMat = pEditorTex->GetMaterial( false );
if ( !pMat )
continue;
IMaterialVar **pParams = pMat->GetShaderParams();
int nParams = pMat->ShaderParamCount();
for ( int iParam=0; iParam < nParams; iParam++ )
{
if ( pParams[iParam]->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
continue;
ITexture *pTex = pParams[iParam]->GetTextureValue();
if ( !pTex )
continue;
if ( pTex == pTestTexture )
{
pEditorTex->Reload( true );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Figure out the file type from its extension. Returns false if we don't have an enum for that extension.
//-----------------------------------------------------------------------------
bool CTextureSystem::GetFileTypeFromFilename( const char *pFilename, CTextureSystem::EFileType *pFileType )
{
char strRight[16];
V_StrRight( pFilename, 4, strRight, sizeof( strRight ) );
if ( V_stricmp( strRight, ".vmt" ) == 0 )
{
*pFileType = CTextureSystem::k_eFileTypeVMT;
return true;
}
else if ( V_stricmp( strRight, ".vtf" ) == 0 )
{
*pFileType = CTextureSystem::k_eFileTypeVTF;
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Loads textures from all texture files.
//-----------------------------------------------------------------------------
void CTextureSystem::ReloadTextures( const char *pFilterName )
{
MaterialSystemInterface()->ReloadMaterials( pFilterName );
for ( int i = 0; i < m_Textures.Count(); i++ )
{
if ( !Q_stristr( pFilterName, m_Textures[i]->GetName() ) )
continue;
m_Textures[i]->Reload( false );
}
}
//-----------------------------------------------------------------------------
// Purpose: Adds a placeholder texture for a texture that exists in the map, but
// was not found on disk.
// Input : pszName - Name of missing texture.
// Output : Returns a pointer to the new dummy texture.
//-----------------------------------------------------------------------------
IEditorTexture *CTextureSystem::AddDummy(LPCTSTR pszName, TEXTUREFORMAT eFormat)
{
if (!m_pActiveContext)
return NULL;
IEditorTexture *pTex = new CDummyTexture(pszName, eFormat);
m_pActiveContext->Dummies.AddToTail(pTex);
return(pTex);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : elem1 -
// elem2 -
// Output : static int __cdecl
//-----------------------------------------------------------------------------
static int __cdecl SortTexturesProc(IEditorTexture * const *elem1, IEditorTexture * const *elem2)
{
IEditorTexture *pElem1 = *((IEditorTexture **)elem1);
IEditorTexture *pElem2 = *((IEditorTexture **)elem2);
Assert((pElem1 != NULL) && (pElem2 != NULL));
if ((pElem1 == NULL) || (pElem2 == NULL))
{
return(0);
}
const char *pszName1 = pElem1->GetName();
const char *pszName2 = pElem2->GetName();
char ch1 = pszName1[0];
char ch2 = pszName2[0];
if (IsSortChr(ch1) && !IsSortChr(ch2))
{
int iFamilyLen = strlen(pszName1+2);
int iFamily = strnicmp(pszName1+2, pszName2, iFamilyLen);
if (!iFamily)
{
return(-1); // same family - put elem1 before elem2
}
return(iFamily); // sort normally
}
else if (!IsSortChr(ch1) && IsSortChr(ch2))
{
int iFamilyLen = strlen(pszName2+2);
int iFamily = strnicmp(pszName1, pszName2+2, iFamilyLen);
if (!iFamily)
{
return(1); // same family - put elem2 before elem1
}
return(iFamily); // sort normally
}
else if (IsSortChr(ch1) && IsSortChr(ch2))
{
// do family name sorting
int iFamily = strcmpi(pszName1+2, pszName2+2);
if (!iFamily)
{
// same family - sort by number
return pszName1[1] - pszName2[1];
}
// different family
return(iFamily);
}
return(strcmpi(pszName1, pszName2));
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : sizeSrc -
// sizeDest -
// *src -
// *dest -
//-----------------------------------------------------------------------------
void ScaleBitmap(CSize sizeSrc, CSize sizeDest, char *src, char *dest)
{
int i;
int e_y = (sizeSrc.cy << 1) - sizeDest.cy;
int sizeDest2_y = (sizeDest.cy << 1);
int sizeSrc2_y = sizeSrc.cy << 1;
int srcline = 0, destline = 0;
char *srclinep, *destlinep;
int e_x = (sizeSrc.cx << 1) - sizeDest.cx;
int sizeDest2_x = (sizeDest.cx << 1);
int sizeSrc2_x = sizeSrc.cx << 1;
for( i = 0; i < sizeDest.cy; i++ )
{
// scale by X
{
srclinep = src + (srcline * sizeSrc.cx);
destlinep = dest + (destline * sizeDest.cx);
for( int j = 0; j < sizeDest.cx; j++ )
{
*destlinep = *srclinep;
while( e_x >= 0 )
{
++srclinep;
e_x -= sizeDest2_x;
}
++destlinep;
e_x += sizeSrc2_x;
}
}
while( e_y >= 0 )
{
++srcline;
e_y -= sizeDest2_y;
}
++destline;
e_y += sizeSrc2_y;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : id -
// *piIndex -
// Output : GRAPHICSFILESTRUCT *
//-----------------------------------------------------------------------------
bool CTextureSystem::FindGraphicsFile(GRAPHICSFILESTRUCT *pFileInfo, DWORD id, int *piIndex)
{
for (int i = 0; i < m_GraphicsFiles.Count(); i++)
{
if (m_GraphicsFiles[i].id == id)
{
if (piIndex)
{
piIndex[0] = i;
}
if (pFileInfo != NULL)
{
*pFileInfo = m_GraphicsFiles[i];
}
return(true);
}
}
return(false);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pFile -
// fd -
// pGroup -
//-----------------------------------------------------------------------------
void CTextureSystem::LoadGraphicsFileWAD3(GRAPHICSFILESTRUCT *pFile, int fd, CTextureGroup *pGroup)
{
// read wad header
wadinfo_t hdr;
_lseek(fd, 0, SEEK_SET);
_read(fd, (char*)&hdr, sizeof hdr);
_lseek(fd, hdr.infotableofs, SEEK_SET);
// allocate directory memory.
WAD3lumpinfo_t *dir = new WAD3lumpinfo_t[hdr.numlumps];
// read entries.
_read(fd, dir, sizeof(WAD3lumpinfo_t) * hdr.numlumps);
// load graphics!
for (int i = 0; i < hdr.numlumps; i++)
{
if (dir[i].type == TYP_MIPTEX)
{
_lseek(fd, dir[i].filepos, SEEK_SET);
CWADTexture *pNew = new CWADTexture;
if (pNew != NULL)
{
if (pNew->Init(fd, pFile->id, FALSE, dir[i].name))
{
pNew->SetTextureFormat(pFile->format);
//
// Add the texture to master list of textures.
//
AddTexture(pNew);
//
// Add the texture's index to the given group and to the "All" group.
//
pGroup->AddTexture(pNew);
if (pGroup != m_pActiveContext->pAllGroup)
{
m_pActiveContext->pAllGroup->AddTexture(pNew);
}
}
else
{
delete pNew;
}
}
}
}
// free memory
delete[] dir;
}
//-----------------------------------------------------------------------------
// Purpose: Loads all textures in a given graphics file and returns an ID for
// the file.
// Input : filename - Full path of graphics file to load.
// Output : Returns the file ID.
//-----------------------------------------------------------------------------
DWORD CTextureSystem::LoadGraphicsFile(const char *pFilename)
{
static DWORD __GraphFileID = 1; // must start at 1.
//
// Make sure it's not already there.
//
int i = m_GraphicsFiles.Count() - 1;
while (i > -1)
{
if (!strcmp(m_GraphicsFiles[i].filename, pFilename))
{
return(m_GraphicsFiles[i].id);
}
i--;
}
//
// Is this a WAD file?
//
DWORD dwAttrib = GetFileAttributes(pFilename);
if (dwAttrib == 0xFFFFFFFF)
{
return(0);
}
GRAPHICSFILESTRUCT gf;
if (!(dwAttrib & FILE_ATTRIBUTE_DIRECTORY))
{
// open the file, and add it to the GraphicFileList array
gf.fd = _open(pFilename, _O_BINARY | _O_RDONLY);
if (gf.fd == -1)
{
// todo: if errno is "out of handles", close some other
// graphics files.
// StatusMsg(IDS_ERROPENGRAPHFILE, errno);
return 0; // could not open
}
char buf[4];
_read(gf.fd, buf, 4);
//
// Make sure the file is in a format that we can read.
//
if (!memcmp(buf, "WAD3", 4))
{
gf.format = tfWAD3;
}
else
{
char str[MAX_PATH*2];
Q_snprintf( str, sizeof(str), "The file \"%s\" is not a valid WAD3 file and will not be used.", pFilename);
AfxMessageBox(str, MB_ICONEXCLAMATION | MB_OK);
_close(gf.fd);
return(0);
}
}
// got it -- setup the rest of the gf structure
gf.id = __GraphFileID++;
Q_strncpy( gf.filename, pFilename, sizeof(gf.filename) );
gf.bLoaded = FALSE;
//
// Add file to list of texture files.
//
m_GraphicsFiles.AddToTail(gf);
//
// Create a new texture group for the file.
//
CTextureGroup *pGroup = new CTextureGroup(pFilename);
pGroup->SetTextureFormat(gf.format);
m_pActiveContext->Groups.AddToTail(pGroup);
//
// Load the textures from the file and place them in the texture group.
//
LoadGraphicsFileWAD3(&gf, gf.fd, pGroup);
gf.bLoaded = TRUE;
//
// Sort this group's list
//
pGroup->Sort();
return(gf.id);
}
//-----------------------------------------------------------------------------
// Purpose: Determines whether or not there is at least one available texture
// group for a given texture format.
// Input : format - Texture format to look for.
// Output : Returns TRUE if textures of a given format are available, FALSE if not.
//-----------------------------------------------------------------------------
bool CTextureSystem::HasTexturesForConfig(CGameConfig *pConfig)
{
if (!pConfig)
return false;
TextureContext_t *pContext = FindTextureContextForConfig(pConfig);
if (!pContext)
return false;
int nCount = pContext->Groups.Count();
for (int i = 0; i < nCount; i++)
{
CTextureGroup *pGroup = pContext->Groups.Element(i);
if (pGroup->GetTextureFormat() == pConfig->GetTextureFormat())
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Used to add all the world materials into the material list
//-----------------------------------------------------------------------------
bool CTextureSystem::EnumMaterial( const char *pMaterialName, int nContext )
{
CTextureGroup *pGroup = (CTextureGroup *)nContext;
CMaterial *pMaterial = CMaterial::CreateMaterial(pMaterialName, false);
if (pMaterial != NULL)
{
// Add it to the master list of textures.
AddTexture(pMaterial);
// Add the texture's index to the given group and to the "All" group.
pGroup->AddTexture(pMaterial);
if (pGroup != m_pActiveContext->pAllGroup)
{
m_pActiveContext->pAllGroup->AddTexture(pMaterial);
}
}
return true;
}
//-----------------------------------------------------------------------------
// Registers the keywords as existing in a particular material
//-----------------------------------------------------------------------------
void CTextureSystem::RegisterTextureKeywords( IEditorTexture *pTexture )
{
//
// Add any new keywords from this material to the list of keywords.
//
char szKeywords[MAX_PATH];
pTexture->GetKeywords(szKeywords);
if (szKeywords[0] != '\0')
{
char *pch = strtok(szKeywords, " ,;");
while (pch != NULL)
{
// dvs: hide in a Find function
bool bFound = false;
for( int pos=0; pos < m_Keywords.Count(); pos++ )
{
const char *pszTest = m_Keywords.Element(pos);
if (!stricmp(pszTest, pch))
{
bFound = true;
break;
}
}
if (!bFound)
{
char *pszKeyword = new char[strlen(pch) + 1];
strcpy(pszKeyword, pch);
m_Keywords.AddToTail(pszKeyword);
}
pch = strtok(NULL, " ,;");
}
}
}
//-----------------------------------------------------------------------------
// Used to lazily load in all the textures
//-----------------------------------------------------------------------------
void CTextureSystem::LazyLoadTextures()
{
if ( m_pActiveContext && m_pActiveContext->pAllGroup && !IsRunningInEngine() )
{
m_pActiveContext->pAllGroup->LazyLoadTextures();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : TextureContext_t
//-----------------------------------------------------------------------------
TextureContext_t *CTextureSystem::AddTextureContext()
{
// Allocate a new texture context.
int nIndex = m_TextureContexts.AddToTail();
// Add the group to this config's list of texture groups.
TextureContext_t *pContext = &m_TextureContexts.Element(nIndex);
return pContext;
}
//-----------------------------------------------------------------------------
// Opens the source file associated with a material
//-----------------------------------------------------------------------------
void CTextureSystem::OpenSource( const char *pMaterialName )
{
if ( !pMaterialName )
return;
char pRelativePath[MAX_PATH];
Q_snprintf( pRelativePath, MAX_PATH, "materials/%s.vmt", pMaterialName );
char pFullPath[MAX_PATH];
if ( g_pFullFileSystem->GetLocalPath( pRelativePath, pFullPath, MAX_PATH ) )
{
ShellExecute( NULL, "open", pFullPath, NULL, NULL, SW_SHOWNORMAL );
}
}
//-----------------------------------------------------------------------------
// Purpose: Constructor.
// Input : pszName - Name of group, ie "Materials" or "u:\hl\tfc\tfc.wad".
//-----------------------------------------------------------------------------
CTextureGroup::CTextureGroup(const char *pszName)
{
strcpy(m_szName, pszName);
m_eTextureFormat = tfNone;
m_nTextureToLoad = 0;
}
//-----------------------------------------------------------------------------
// Purpose: Adds a texture to this group.
// Input : pTexture - Texture to add.
//-----------------------------------------------------------------------------
void CTextureGroup::AddTexture(IEditorTexture *pTexture)
{
int index = m_Textures.AddToTail(pTexture);
m_TextureNameMap.Insert( pTexture->GetName(), index );
}
//-----------------------------------------------------------------------------
// Purpose: Sorts the group.
//-----------------------------------------------------------------------------
void CTextureGroup::Sort(void)
{
m_Textures.Sort(SortTexturesProc);
// Redo the name map.
m_TextureNameMap.RemoveAll();
for ( int i=0; i < m_Textures.Count(); i++ )
{
IEditorTexture *pTex = m_Textures[i];
m_TextureNameMap.Insert( pTex->GetName(), i );
}
// Changing the order means we don't know where we should be loading from
m_nTextureToLoad = 0;
}
//-----------------------------------------------------------------------------
// Purpose: Retrieves a texture by index.
// Input : nIndex - Index of the texture in this group.
//-----------------------------------------------------------------------------
IEditorTexture *CTextureGroup::GetTexture(int nIndex)
{
if ((nIndex >= m_Textures.Count()) || (nIndex < 0))
{
return(NULL);
}
return(m_Textures[nIndex]);
}
//-----------------------------------------------------------------------------
// finds a texture by name
//-----------------------------------------------------------------------------
IEditorTexture *CTextureGroup::GetTexture( char const* pName )
{
for (int i = 0; i < m_Textures.Count(); i++)
{
if (!strcmp(pName, m_Textures[i]->GetName()))
return m_Textures[i];
}
return NULL;
}
//-----------------------------------------------------------------------------
// Quickly find a texture by name.
//-----------------------------------------------------------------------------
IEditorTexture* CTextureGroup::FindTextureByName( const char *pName, int *piIndex, TEXTUREFORMAT eDesiredFormat )
{
int iMapEntry = m_TextureNameMap.Find( pName );
if ( iMapEntry == m_TextureNameMap.InvalidIndex() )
{
return NULL;
}
else
{
IEditorTexture *pTex = m_Textures[ m_TextureNameMap[iMapEntry] ];
if ((eDesiredFormat == tfNone) || (pTex->GetTextureFormat() == eDesiredFormat))
return pTex;
else
return NULL;
}
}
//-----------------------------------------------------------------------------
// Used to lazily load in all the textures
//-----------------------------------------------------------------------------
void CTextureGroup::LazyLoadTextures()
{
// Load at most once per call
while (m_nTextureToLoad < m_Textures.Count())
{
if (!m_Textures[m_nTextureToLoad]->IsLoaded())
{
m_Textures[m_nTextureToLoad]->Load();
++m_nTextureToLoad;
return;
}
// This one was already loaded; skip it
++m_nTextureToLoad;
}
}
Reference in New Issue Copy Permalink