source-engine/hammer/texturesystem.cpp

//========= 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;
	}
}