1HEADmaster

1 files changed, 664 insertions, 0 deletions

diff --git a/materialsystem/checkmaterials.cpp b/materialsystem/checkmaterials.cpp
new file mode 100644
index 0000000..30432f8
--- /dev/null
+++ b/materialsystem/checkmaterials.cpp
@@ -0,0 +1,664 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================
+
+#include "pch_materialsystem.h"
+
+// NOTE: currently this file is marked as "exclude from build"
+
+//#define _CHECK_MATERIALS_FOR_PROBLEMS 1
+#ifdef _CHECK_MATERIALS_FOR_PROBLEMS
+#include "vtf/vtf.h"
+#include "tier1/utlbuffer.h"
+#include "tier1/utlstring.h"
+void CheckMateralsInDirectoryRecursive( const char *pRoot, const char *pDirectory );
+#endif
+
+#ifdef _CHECK_MATERIALS_FOR_PROBLEMS
+
+//-----------------------------------------------------------------------------
+// Does a texture have alpha?
+//-----------------------------------------------------------------------------
+static bool DoesTextureUseAlpha( const char *pTextureName, const char *pMaterialName )
+{
+	if ( IsX360() )
+	{
+		// not supporting
+		return false;
+	}
+
+	// Special textures start with '_'..
+	if ( pTextureName[0] == '_' )
+		return false;
+
+	// The texture name doubles as the relative file name
+	// It's assumed to have already been set by this point	
+	// Compute the cache name
+	char pCacheFileName[MATERIAL_MAX_PATH];
+	Q_snprintf( pCacheFileName, sizeof( pCacheFileName ), "materials/%s.vtf", pTextureName );
+
+	CUtlBuffer buf;
+	FileHandle_t fileHandle = g_pFullFileSystem->Open( pCacheFileName, "rb" );
+	if ( fileHandle == FILESYSTEM_INVALID_HANDLE)
+	{
+		Warning( "Material \"%s\": can't open texture \"%s\"\n", pMaterialName, pCacheFileName );
+		return false;
+	}
+
+	// Check the .vtf for an alpha channel
+	IVTFTexture *pVTFTexture = CreateVTFTexture();
+
+	int nHeaderSize = VTFFileHeaderSize( VTF_MAJOR_VERSION );
+	buf.EnsureCapacity( nHeaderSize );
+
+	// read the header first.. it's faster!!
+	g_pFullFileSystem->Read( buf.Base(), nHeaderSize, fileHandle );
+	buf.SeekPut( CUtlBuffer::SEEK_HEAD, nHeaderSize );
+
+	// Unserialize the header
+	bool bUsesAlpha = false;
+
+	if (!pVTFTexture->Unserialize( buf, true ))
+	{
+		Warning( "Error reading material \"%s\"\n", pCacheFileName );
+		g_pFullFileSystem->Close(fileHandle);
+	}
+	else
+	{
+		if ( pVTFTexture->Flags() & (TEXTUREFLAGS_ONEBITALPHA | TEXTUREFLAGS_EIGHTBITALPHA) )
+		{
+			bUsesAlpha = true;
+		}
+	}
+
+	DestroyVTFTexture( pVTFTexture );
+	g_pFullFileSystem->Close( fileHandle );
+	return bUsesAlpha;
+}
+
+
+//-----------------------------------------------------------------------------
+// Does a texture have alpha?
+//-----------------------------------------------------------------------------
+static bool DoesTextureUseNormal( const char *pTextureName, const char *pMaterialName, bool &bUsesAlpha, bool &bIsCompressed, int &nSizeInBytes )
+{
+	nSizeInBytes = 0;
+	bUsesAlpha = false;
+
+	if ( IsX360() )
+	{
+		// not supporting
+		return false;
+	}
+
+	// Special textures start with '_'..
+	if ( !pTextureName || ( pTextureName[0] == '_' ) || ( pTextureName[0] == 0 ) )
+		return false;
+
+	// The texture name doubles as the relative file name
+	// It's assumed to have already been set by this point	
+	// Compute the cache name
+	char pCacheFileName[MATERIAL_MAX_PATH];
+	Q_snprintf( pCacheFileName, sizeof( pCacheFileName ), "materials/%s.vtf", pTextureName );
+
+	CUtlBuffer buf;
+	FileHandle_t fileHandle = g_pFullFileSystem->Open( pCacheFileName, "rb" );
+	if ( fileHandle == FILESYSTEM_INVALID_HANDLE)
+	{
+//		Warning( "Material \"%s\": can't open texture \"%s\"\n", pMaterialName, pCacheFileName );
+		return false;
+	}
+
+	// Check the .vtf for an alpha channel
+	IVTFTexture *pVTFTexture = CreateVTFTexture();
+
+	int nHeaderSize = VTFFileHeaderSize( VTF_MAJOR_VERSION );
+	buf.EnsureCapacity( nHeaderSize );
+
+	// read the header first.. it's faster!!
+	g_pFullFileSystem->Read( buf.Base(), nHeaderSize, fileHandle );
+	buf.SeekPut( CUtlBuffer::SEEK_HEAD, nHeaderSize );
+
+	// Unserialize the header
+	bool bUsesNormal = false;
+	if ( !pVTFTexture->Unserialize( buf, true ) )
+	{
+		Warning( "Error reading material \"%s\"\n", pCacheFileName );
+	}
+	else
+	{
+		if ( pVTFTexture->Flags() & TEXTUREFLAGS_NORMAL )
+		{
+			bUsesAlpha = false;
+			bUsesNormal = true;
+			bIsCompressed = ImageLoader::IsCompressed( pVTFTexture->Format() ) || ( pVTFTexture->Format() == IMAGE_FORMAT_A8 );
+			nSizeInBytes = pVTFTexture->ComputeTotalSize();
+			if ( pVTFTexture->Flags() & (TEXTUREFLAGS_ONEBITALPHA | TEXTUREFLAGS_EIGHTBITALPHA) )
+			{
+				bUsesAlpha = true;
+			}
+		}
+	}
+
+	DestroyVTFTexture( pVTFTexture );
+	g_pFullFileSystem->Close( fileHandle );
+	return bUsesNormal;
+}
+
+
+//-----------------------------------------------------------------------------
+// Is this a real texture
+//-----------------------------------------------------------------------------
+static bool IsTexture( const char *pTextureName )
+{
+	// Special textures start with '_'..
+	if ( pTextureName[0] == '_' )
+		return false;
+
+	// The texture name doubles as the relative file name
+	// It's assumed to have already been set by this point	
+	// Compute the cache name
+	char pCacheFileName[MATERIAL_MAX_PATH];
+	Q_snprintf( pCacheFileName, sizeof( pCacheFileName ), "materials/%s.vtf", pTextureName );
+
+	FileHandle_t fileHandle = g_pFullFileSystem->Open( pCacheFileName, "rb" );
+	if ( fileHandle == FILESYSTEM_INVALID_HANDLE)
+		return false;
+
+	g_pFullFileSystem->Close( fileHandle );
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Scan material + all subsections for key
+//-----------------------------------------------------------------------------
+static float MaterialFloatKeyValue( KeyValues *pKeyValues, const char *pKeyName, float flDefault )
+{
+	float flValue = pKeyValues->GetFloat( pKeyName, flDefault );
+	if ( flValue != flDefault )
+		return flValue;
+
+	for( KeyValues *pSubKey = pKeyValues->GetFirstTrueSubKey(); pSubKey; pSubKey = pSubKey->GetNextTrueSubKey() )
+	{
+		float flValue = MaterialFloatKeyValue( pSubKey, pKeyName, flDefault );
+		if ( flValue != flDefault )
+			return flValue;
+	}
+	
+	return flDefault;
+}
+
+int ParseVectorFromKeyValueString( KeyValues *pKeyValue, const char *pMaterialName, float vecVal[4] );
+
+static bool AsVectorsEqual( int nDim1, float *pVector1, int nDim2, float *pVector2 )
+{
+	if ( nDim1 != nDim2 )
+		return false;
+
+	for ( int i = 0; i < nDim1; ++i )
+	{
+		if ( fabs( pVector1[i] - pVector2[i] ) > 1e-3 )
+			return false;
+	}
+
+	return true;
+}
+
+static bool MaterialVectorKeyValue( KeyValues *pKeyValues, const char *pKeyName, int nDefaultDim, float *pDefault, int *pDim, float *pVector )
+{
+	int nDim;
+	float retVal[4];
+
+	KeyValues *pValue = pKeyValues->FindKey( pKeyName );
+	if ( pValue )
+	{
+		switch( pValue->GetDataType() )
+		{
+		case KeyValues::TYPE_INT:
+			{
+				int nInt = pValue->GetInt();
+				for ( int i = 0; i < 4; ++i )
+				{
+					retVal[i] = nInt;
+				}
+				if ( !AsVectorsEqual( nDefaultDim, pDefault, nDefaultDim, retVal ) )
+				{
+					*pDim = nDefaultDim;
+					memcpy( pVector, retVal, nDefaultDim * sizeof(float) );
+					return true;
+				}
+			}
+			break;
+
+		case KeyValues::TYPE_FLOAT:
+			{
+				float flFloat = pValue->GetFloat();
+				for ( int i = 0; i < 4; ++i )
+				{
+					retVal[i] = flFloat;
+				}
+				if ( !AsVectorsEqual( nDefaultDim, pDefault, nDefaultDim, retVal ) )
+				{
+					*pDim = nDefaultDim;
+					memcpy( pVector, retVal, nDefaultDim * sizeof(float) );
+					return true;
+				}
+			}
+			break;
+
+		case KeyValues::TYPE_STRING:
+			{
+				nDim = ParseVectorFromKeyValueString( pValue, "", retVal );
+				if ( !AsVectorsEqual( nDefaultDim, pDefault, nDim, retVal ) )
+				{
+					*pDim = nDim;
+					memcpy( pVector, retVal, nDim * sizeof(float) );
+					return true;
+				}
+			}
+			break;
+		}
+	}
+
+	for( KeyValues *pSubKey = pKeyValues->GetFirstTrueSubKey(); pSubKey; pSubKey = pSubKey->GetNextTrueSubKey() )
+	{
+		if ( MaterialVectorKeyValue( pSubKey, pKeyName, nDefaultDim, pDefault, &nDim, retVal ) )
+		{
+			*pDim = nDim;
+			memcpy( pVector, retVal, nDim * sizeof(float) );
+			return true;
+		}
+	}
+	
+	*pDim = nDefaultDim;
+	memcpy( pVector, pDefault, nDefaultDim * sizeof(float) );
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Scan material + all subsections for key
+//-----------------------------------------------------------------------------
+static bool DoesMaterialHaveKey( KeyValues *pKeyValues, const char *pKeyName )
+{
+	if ( pKeyValues->GetString( pKeyName, NULL ) != NULL )
+		return true;
+
+	for( KeyValues *pSubKey = pKeyValues->GetFirstTrueSubKey(); pSubKey; pSubKey = pSubKey->GetNextTrueSubKey() )
+	{
+		if ( DoesMaterialHaveKey( pSubKey, pKeyName ) )
+			return true;
+	}
+	
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Scan all materials for errors
+//-----------------------------------------------------------------------------
+static int s_nNormalBytes;
+static int s_nNormalCompressedBytes;
+static int s_nNormalPalettizedBytes;
+static int s_nNormalWithAlphaBytes;
+static int s_nNormalWithAlphaCompressedBytes;
+
+struct VTFInfo_t
+{
+	CUtlString m_VTFName;
+	bool m_bFoundInVMT;
+};
+
+void CheckKeyValues( KeyValues *pKeyValues, CUtlVector<VTFInfo_t> &vtf )
+{
+	for ( KeyValues *pSubKey = pKeyValues->GetFirstValue(); pSubKey; pSubKey = pSubKey->GetNextValue() )
+	{
+		if ( pSubKey->GetDataType() != KeyValues::TYPE_STRING )
+			continue;
+		
+		if ( IsTexture( pSubKey->GetString() ) )
+		{
+			int nLen = Q_strlen( pSubKey->GetString() ) + 1;
+			char *pTemp = (char*)_alloca( nLen );
+			memcpy( pTemp, pSubKey->GetString(), nLen ); 
+			Q_FixSlashes( pTemp );
+
+			int nCount = vtf.Count();
+			for ( int i = 0; i < nCount; ++i )
+			{
+				if ( Q_stricmp( vtf[i].m_VTFName, pTemp ) )
+					continue;
+				vtf[i].m_bFoundInVMT = true;
+				break;
+			}
+		}
+	}
+
+	for ( KeyValues *pSubKey = pKeyValues->GetFirstTrueSubKey(); pSubKey; pSubKey = pSubKey->GetNextTrueSubKey() )
+	{
+		CheckKeyValues( pSubKey, vtf );
+	}
+}
+
+void CheckMaterial( KeyValues *pKeyValues, const char *pRoot, const char *pFileName, CUtlVector<VTFInfo_t> &vtf )
+{
+	const char *pShaderName = pKeyValues->GetName();
+/*
+	if ( Q_stristr( pShaderName, "Water" ) ||
+		Q_stristr( pShaderName, "Eyeball" ) ||
+		Q_stristr( pShaderName, "Shadow" ) ||
+		Q_stristr( pShaderName, "Refract" ) ||
+		Q_stristr( pShaderName, "Predator" ) ||
+		Q_stristr( pShaderName, "ParticleSphere" ) ||
+		Q_stristr( pShaderName, "DebugLuxels" ) ||
+		Q_stristr( pShaderName, "GooInGlass" ) ||
+		Q_stristr( pShaderName, "Modulate" ) ||
+		Q_stristr( pShaderName, "UnlitTwoTexture" ) ||
+		Q_stristr( pShaderName, "Cloud" ) ||
+		Q_stristr( pShaderName, "WorldVertexTransition" ) ||
+		Q_stristr( pShaderName, "DecalModulate" ) ||
+		Q_stristr( pShaderName, "DecalBaseTimesLightmapAlphaBlendSelfIllum" ) ||
+		Q_stristr( pShaderName, "Sprite" ) )
+	{
+		return;
+	}
+
+	// Check for alpha channels
+	const char *pBaseTextureName = pKeyValues->GetString( "$basetexture", NULL );
+	if ( pBaseTextureName != NULL )
+	{
+		if ( DoesTextureUseAlpha( pBaseTextureName, pFileName ) )
+		{
+			float flAlpha = MaterialFloatKeyValue( pKeyValues, "$alpha", 1.0f );
+			bool bHasVertexAlpha = DoesMaterialHaveKey( pKeyValues, "$vertexalpha" );	// Modulation always happens here whether we want it to or not
+			bool bHasAlphaTest = DoesMaterialHaveKey( pKeyValues, "$alphatest" );
+			bool bHasTranslucent = DoesMaterialHaveKey( pKeyValues, "$translucent" );
+			bool bHasSelfIllum = DoesMaterialHaveKey( pKeyValues, "$selfillum" );
+			bool bHasBaseAlphaEnvMapMask = DoesMaterialHaveKey( pKeyValues, "$basealphaenvmapmask" );
+			if ( (flAlpha == 1.0f) && !bHasVertexAlpha && !bHasAlphaTest && !bHasTranslucent && !bHasSelfIllum && !bHasBaseAlphaEnvMapMask )
+			{
+				Warning("Material \"%s\": BASETEXTURE \"%s\"\n", pFileName, pBaseTextureName ); 
+			}
+		}
+	}
+*/
+
+/*
+// Check for bump, spec, and no normalmapalphaenvmapmask
+	const char *pBumpmapName = pKeyValues->GetString( "$bumpmap", NULL );
+	if ( pBumpmapName != NULL )
+	{
+		if ( DoesTextureUseAlpha( pBumpmapName, pFileName ) )
+		{
+			bool bHasEnvmap = DoesMaterialHaveKey( pKeyValues, "$envmap" );
+			bool bHasNormalMapAlphaEnvMapMask = DoesMaterialHaveKey( pKeyValues, "$normalmapalphaenvmapmask" );
+			if ( !bHasEnvmap || !bHasNormalMapAlphaEnvMapMask )
+			{
+				Warning("Material \"%s\": BUMPMAP \"%s\"\n", pFileName, pBumpmapName ); 
+			}
+		}
+	}
+*/
+
+/*
+	if ( !Q_stristr( pShaderName, "LightmappedGeneric" ) &&
+		!Q_stristr( pShaderName, "VertexLitGeneric" ) )
+	{
+		return;
+	}
+
+	if ( DoesMaterialHaveKey( pKeyValues, "$envmap" ) && DoesMaterialHaveKey( pKeyValues, "$bumpmap" ) )
+	{
+		int nDim;
+		float retVal[4];
+		float defaultVal[4] = { 1, 1, 1, 1 };
+		
+		if ( MaterialVectorKeyValue( pKeyValues, "$envmaptint", 3, defaultVal, &nDim, retVal ) )
+		{
+			Warning("ENVMAP + ENVMAPTINT : Material \"%s\"\n", pFileName ); 
+		}
+//		else
+//		{
+//			Warning("ENVMAP only: Material \"%s\"\n", pFileName ); 
+//		}
+	}
+	*/
+
+/*
+	if ( !Q_stristr( pShaderName, "Refract" ) )
+	{
+		return;
+	}
+
+	if ( !DoesMaterialHaveKey( pKeyValues, "$envmap" ) )
+	{
+		bool bUsesAlpha, bIsCompressed, bIsPalettized;
+		int nSizeInBytes;
+		if ( DoesTextureUseNormal( pKeyValues->GetString( "$normalmap" ), 
+			pFileName, bUsesAlpha, bIsCompressed, bIsPalettized, nSizeInBytes ) )
+		{
+			if ( bIsCompressed )
+			{
+				Warning("Bad : Material compressed \"%s\"\n", pFileName ); 
+			}
+			else
+			{
+				Warning("Bad : Material \"%s\"\n", pFileName ); 
+			}
+		}
+	}
+*/
+
+/*
+	if ( !Q_stristr( pShaderName, "WorldTwoTextureBlend" ) )
+	{
+		return;
+	}
+
+	if ( DoesMaterialHaveKey( pKeyValues, "$envmap" ) || 
+		DoesMaterialHaveKey( pKeyValues, "$parallaxmap" ) ||
+		DoesMaterialHaveKey( pKeyValues, "$bumpmap" ) ||
+		DoesMaterialHaveKey( pKeyValues, "$vertexcolor" ) || 
+		DoesMaterialHaveKey( pKeyValues, "$basetexture2" )
+		)
+	{
+		Warning("Bad : Material \"%s\"\n", pFileName ); 
+	}
+*/
+
+	for ( KeyValues *pSubKey = pKeyValues->GetFirstValue(); pSubKey; pSubKey = pSubKey->GetNextValue() )
+	{
+//		Msg( " Checking %s\n", pSubKey->GetString() );
+		if ( pSubKey->GetDataType() != KeyValues::TYPE_STRING )
+			continue;
+		
+		bool bUsesAlpha, bIsCompressed;
+		int nSizeInBytes;
+		if ( DoesTextureUseNormal( pSubKey->GetString(), pFileName, bUsesAlpha, bIsCompressed, nSizeInBytes ) )
+		{
+			if ( bUsesAlpha )
+			{
+				if ( bIsCompressed )
+				{
+					s_nNormalWithAlphaCompressedBytes += nSizeInBytes;
+				}
+				else
+				{
+					s_nNormalWithAlphaBytes += nSizeInBytes;
+					Msg( "Normal texture w alpha uncompressed %s\n", pSubKey->GetString() );
+				}
+			}
+			else
+			{
+				if ( bIsCompressed )
+				{
+					s_nNormalCompressedBytes += nSizeInBytes;
+				}
+				else
+				{
+					s_nNormalBytes += nSizeInBytes;
+				}
+			}
+		}
+	}	
+
+/*
+	if ( !Q_stristr( pShaderName, "VertexLitGeneric" ) )
+		return;
+
+	if ( !DoesMaterialHaveKey( pKeyValues, "$envmap" ) && DoesMaterialHaveKey( pKeyValues, "$bumpmap" ) )
+	{
+		Warning("BUMPMAP + no ENVMAP : Material \"%s\"\n", pFileName ); 
+	}
+*/
+
+//	CheckKeyValues( pKeyValues, vtf );
+}
+
+//-----------------------------------------------------------------------------
+// Build list of all VTFs
+//-----------------------------------------------------------------------------
+void CheckVTFInDirectoryRecursive( const char *pRoot, const char *pDirectory, CUtlVector< VTFInfo_t > &vtf )
+{
+#define BUF_SIZE 1024
+	char buf[BUF_SIZE];
+	WIN32_FIND_DATA wfd;
+	HANDLE findHandle;
+	
+	sprintf( buf, "%s/%s/*.vtf", pRoot, pDirectory );
+
+	findHandle = FindFirstFile( buf, &wfd );
+	if ( findHandle != INVALID_HANDLE_VALUE ) 
+	{ 
+		do 
+		{
+			int i = vtf.AddToTail( );
+
+			char buf[MAX_PATH];
+			char buf2[MAX_PATH];
+			Q_snprintf( buf, MAX_PATH, "%s/%s", pDirectory, wfd.cFileName );
+			Q_FixSlashes( buf );
+
+			Q_StripExtension( buf, buf2, sizeof(buf2) );
+			Assert( !Q_strnicmp( buf2, "materials\\", 10 ) );
+
+			vtf[i].m_VTFName = &buf2[10];
+			vtf[i].m_bFoundInVMT = false;
+
+		} while ( FindNextFile ( findHandle, &wfd ) ); 
+		
+		FindClose ( findHandle ); 
+	}
+
+	// do subdirectories
+	sprintf( buf, "%s/%s/*.*", pRoot, pDirectory );
+	findHandle = FindFirstFile( buf, &wfd );
+	if ( findHandle != INVALID_HANDLE_VALUE ) 
+	{ 
+		do 
+		{ 
+			if( wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
+			{
+				if( ( strcmp( wfd.cFileName, ".." ) == 0 ) || 
+					( strcmp( wfd.cFileName, "." ) == 0 ) )
+				{
+					continue;
+				}
+
+				char buf[MAX_PATH];
+				Q_snprintf( buf, MAX_PATH, "%s/%s", pDirectory, wfd.cFileName );
+				CheckVTFInDirectoryRecursive( pRoot, buf, vtf );
+			}
+		} while ( FindNextFile ( findHandle, &wfd ) ); 
+		FindClose ( findHandle ); 
+	}
+
+#undef BUF_SIZE
+}
+
+
+//-----------------------------------------------------------------------------
+// Scan all materials for errors
+//-----------------------------------------------------------------------------
+void _CheckMateralsInDirectoryRecursive( const char *pRoot, const char *pDirectory, CUtlVector< VTFInfo_t > &vtf )
+{
+#define BUF_SIZE 1024
+	char buf[BUF_SIZE];
+	WIN32_FIND_DATA wfd;
+	HANDLE findHandle;
+	
+	sprintf( buf, "%s/%s/*.vmt", pRoot, pDirectory );
+	findHandle = FindFirstFile( buf, &wfd );
+	if ( findHandle != INVALID_HANDLE_VALUE ) 
+	{ 
+		do 
+		{
+			KeyValues * vmtKeyValues = new KeyValues("vmt");
+
+			char pFileName[MAX_PATH];
+			Q_snprintf( pFileName, sizeof( pFileName ), "%s/%s", pDirectory, wfd.cFileName );
+			if ( !vmtKeyValues->LoadFromFile( g_pFullFileSystem, pFileName, "GAME" ) )
+			{
+				Warning( "CheckMateralsInDirectoryRecursive: can't open \"%s\"\n", pFileName );
+				continue;
+			}
+
+			CheckMaterial( vmtKeyValues, pRoot, pFileName, vtf );
+
+			vmtKeyValues->deleteThis();
+
+		} while ( FindNextFile ( findHandle, &wfd ) ); 
+		
+		FindClose ( findHandle ); 
+	}
+
+	// do subdirectories
+	sprintf( buf, "%s/%s/*.*", pRoot, pDirectory );
+	findHandle = FindFirstFile( buf, &wfd );
+	if ( findHandle != INVALID_HANDLE_VALUE ) 
+	{ 
+		do 
+		{ 
+			if( wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
+			{
+				if( ( strcmp( wfd.cFileName, ".." ) == 0 ) || 
+					( strcmp( wfd.cFileName, "." ) == 0 ) )
+				{
+					continue;
+				}
+
+				char buf[MAX_PATH];
+				Q_snprintf( buf, MAX_PATH, "%s/%s", pDirectory, wfd.cFileName );
+				_CheckMateralsInDirectoryRecursive( pRoot, buf, vtf );
+			}
+		} while ( FindNextFile ( findHandle, &wfd ) ); 
+		FindClose ( findHandle ); 
+	}
+
+//	Msg( "Normal only %d/%d/%d Normal w alpha %d/%d\n", s_nNormalBytes, s_nNormalPalettizedBytes, s_nNormalCompressedBytes, s_nNormalWithAlphaBytes, s_nNormalWithAlphaCompressedBytes );
+#undef BUF_SIZE
+}
+
+void CheckMateralsInDirectoryRecursive( const char *pRoot, const char *pDirectory )
+{
+	CUtlVector< VTFInfo_t > vtfNames;
+//	CheckVTFInDirectoryRecursive( pRoot, pDirectory, vtfNames );
+	_CheckMateralsInDirectoryRecursive( pRoot, pDirectory, vtfNames );
+
+	/*
+	int nCount = vtfNames.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		if ( !vtfNames[i].m_bFoundInVMT )
+		{
+			Msg( "Unused VTF %s\n", vtfNames[i].m_VTFName );
+		}
+	}
+	*/
+}
+
+#endif // _CHECK_MATERIALS_FOR_PROBLEMS
+