//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include "tier1/strtools.h"
#include <sys/stat.h>
#include "bitmap/bitmap.h"
#include "bitmap/tgaloader.h"
#include "bitmap/psd.h"
#include "bitmap/float_bm.h"
#include "bitmap/imageformat.h"
#include "mathlib/mathlib.h"

#ifdef POSIX
#include <sys/stat.h>
#define _stat stat
#endif

#ifdef WIN32
#include "conio.h"
#include <direct.h>
#include <io.h>
#endif

#include "vtf/vtf.h"
#include "utlbuffer.h"
#include "tier0/dbg.h"
#include "cmdlib.h"
#include "tier0/icommandline.h"
#ifdef WIN32
#include "windows.h"
#endif
#include "ilaunchabledll.h"
#include "ivtex.h"
#include "appframework/IAppSystemGroup.h"

#include "tier2/tier2.h"
#include "tier2/p4helpers.h"
#include "p4lib/ip4.h"

#include "tier1/checksum_crc.h"

#define FF_TRYAGAIN 1
#define FF_DONTPROCESS 2

#define LOWRESIMAGE_DIM 16

#ifdef POSIX
#define LOWRES_IMAGE_FORMAT IMAGE_FORMAT_RGBA8888
#else
#define LOWRES_IMAGE_FORMAT IMAGE_FORMAT_DXT1
#endif

//#define DEBUG_NO_COMPRESSION
static bool g_NoPause = false;
static bool g_Quiet = false;
static const char *g_ShaderName = NULL;
static bool g_CreateDir = true;
static bool g_UseGameDir = true;

static bool g_bUseStandardError = false;
static bool g_bWarningsAsErrors = false;

static bool g_bUsedAsLaunchableDLL = false;

static bool g_bNoTga = false;
static bool g_bNoPsd = false;

static char g_ForcedOutputDir[MAX_PATH];


#define MAX_VMT_PARAMS	16

struct VTexVMTParam_t
{
	const char *m_szParam;
	const char *m_szValue;
};

class SmartIVtfTexture
{
public:
	explicit SmartIVtfTexture( IVTFTexture *pVtf ) : m_p( pVtf ) {}
	~SmartIVtfTexture() { if ( m_p ) DestroyVTFTexture( m_p ); }

private:
	SmartIVtfTexture( SmartIVtfTexture const &x );
	SmartIVtfTexture & operator = ( SmartIVtfTexture const &x );

private:
	SmartIVtfTexture & operator = ( IVTFTexture *pVtf ) { m_p = pVtf; return *this; }
	operator IVTFTexture * () const { return m_p; }

public:
	IVTFTexture * Assign( IVTFTexture *pVtfNew ) { IVTFTexture *pOld = m_p; m_p = pVtfNew; return pOld; }
	IVTFTexture * Get() const { return m_p; }
	IVTFTexture * operator->() const { return m_p; }

protected:
	IVTFTexture *m_p;
};

static VTexVMTParam_t g_VMTParams[MAX_VMT_PARAMS];

static int g_NumVMTParams = 0;
static enum Mode { eModePSD, eModeTGA, eModePFM } g_eMode = eModePSD;

// NOTE: these must stay in the same order as CubeMapFaceIndex_t.
static const char *g_CubemapFacingNames[7] = { "rt", "lf", "bk", "ft", "up", "dn", "sph" };

static void Pause( void )
{
	if( !g_NoPause )
	{
		printf( "Hit a key to continue\n" );
#ifdef WIN32
		getch();
#endif	
	}
}

static bool VTexErrorAborts()
{
	if ( CommandLine()->FindParm( "-crcvalidate" ) )
		return false;

	return true;
}


static void VTexError( const char *pFormat, ... )
{
	char str[4096];
	va_list marker;
	va_start( marker, pFormat );
	Q_vsnprintf( str, sizeof( str ), pFormat, marker );
	va_end( marker );

	if ( !VTexErrorAborts() )
	{
		fprintf( stderr, "ERROR: %s", str );
		return;
	}

	if ( g_bUseStandardError )
	{
		Error( "ERROR: %s", str );
	}
	else
	{
		fprintf( stderr, "ERROR: %s", str );
		Pause();
		exit( 1 );
	}	
}


static void VTexWarning( const char *pFormat, ... )
{
	char str[4096];
	va_list marker;
	va_start( marker, pFormat );
	Q_vsnprintf( str, sizeof( str ), pFormat, marker );
	va_end( marker );

	if ( g_bWarningsAsErrors )
	{
		VTexError( "%s", str );
	}
	else
	{
		fprintf( stderr, "WARN: %s", str );
		Pause();
	}	
}



struct VTexConfigInfo_t
{
	int m_nStartFrame;
	int m_nEndFrame;
	unsigned int m_nFlags;
	float m_flBumpScale;
	LookDir_t m_LookDir;
	bool m_bNormalToDuDv;
	bool m_bAlphaToLuminance;
	bool m_bDuDv;
	float m_flAlphaThreshhold;
	float m_flAlphaHiFreqThreshhold;
	bool m_bSkyBox;
	int m_nVolumeTextureDepth;
	float m_pfmscale;
	bool m_bStripAlphaChannel;
	bool m_bStripColorChannel;
	bool m_bIsCubeMap;


	// scaling parameters
	int m_nReduceX;
	int m_nReduceY;

	int m_nMaxDimensionX, m_nMaxDimensionX_360;
	int m_nMaxDimensionY, m_nMaxDimensionY_360;

	// may restrict the texture to reading only 3 channels
	int m_numChannelsMax;

	bool m_bAlphaToDistance;
	float m_flDistanceSpread;					 // how far to stretch out distance range in pixels

	CRC32_t m_uiInputHash;	// Sources hash

	TextureSettingsEx_t m_exSettings0;
	VtfProcessingOptions m_vtfProcOptions;

	enum
	{
		// CRC of input files:
		//  txt + tga/pfm
		// or
		//  psd
		VTF_INPUTSRC_CRC = MK_VTF_RSRC_ID( 'C','R','C' )
	};

	char m_SrcName[MAX_PATH];

	VTexConfigInfo_t( void )
	{
		m_nStartFrame = -1;
		m_nEndFrame = -1;
		m_nFlags = 0;
		m_bNormalToDuDv = false;
		m_bAlphaToLuminance = false;
		m_flBumpScale = 1.0f;
		m_bDuDv = false;
		m_flAlphaThreshhold = -1.0f;
		m_flAlphaHiFreqThreshhold = -1.0f;
		m_bSkyBox = false;
		m_nVolumeTextureDepth = 1;
		m_pfmscale=1.0;
		m_bStripAlphaChannel = false;
		m_bStripColorChannel = false;
		m_bIsCubeMap = false;
		m_nReduceX = 1;
		m_nReduceY = 1;
		m_SrcName[0]=0;
		m_numChannelsMax = 4;
		m_bAlphaToDistance = 0;
		m_flDistanceSpread = 1.0;
		m_nMaxDimensionX = -1;
		m_nMaxDimensionX_360 = -1;
		m_nMaxDimensionY = -1;
		m_nMaxDimensionY_360 = -1;

		memset( &m_exSettings0, 0, sizeof( m_exSettings0 ) );

		memset( &m_vtfProcOptions, 0, sizeof( m_vtfProcOptions ) );
		m_vtfProcOptions.cbSize = sizeof( m_vtfProcOptions );
		
		m_vtfProcOptions.flags0 |= VtfProcessingOptions::OPT_FILTER_NICE;

		CRC32_Init( &m_uiInputHash );
	}

	bool IsSettings0Valid( void ) const
	{
		TextureSettingsEx_t exSettingsEmpty;
		memset( &exSettingsEmpty, 0, sizeof( exSettingsEmpty ) );
		Assert( sizeof( m_exSettings0 ) == sizeof( exSettingsEmpty ) );
		return !!memcmp( &m_exSettings0, &exSettingsEmpty, sizeof( m_exSettings0 ) );
	}

	// returns false if unrecognized option
	void ParseOptionKey( const char *pKeyName,  const char *pKeyValue );

};

template < typename T >
static inline T& SetFlagValueT( T &field, T const &flag, int bSetFlag )
{
	if ( bSetFlag )
		field |= flag;
	else
		field &=~flag;

	return field;
}

static inline uint32& SetFlagValue( uint32 &field, uint32 const &flag, int bSetFlag )
{
	return SetFlagValueT<uint32>( field, flag, bSetFlag );
}

void VTexConfigInfo_t::ParseOptionKey( const char *pKeyName,  const char *pKeyValue )
{
	int iValue = atoi( pKeyValue ); // To properly have "clamps 0" and not enable the clamping

	if ( !stricmp( pKeyName, "skybox" ) )
	{
		// We're going to treat it like a cubemap until the very end, so it'll load the other skybox faces and
		// match their edges with the texture compression and mipmapping.
		m_bSkyBox = iValue ? true : false;
		m_bIsCubeMap = iValue ? true : false;
		if ( !g_Quiet && iValue )
			Msg( "'skybox' detected. Treating skybox like a cubemap for edge-matching purposes.\n" );
	}
	else if( !stricmp( pKeyName, "startframe" ) )
	{
		m_nStartFrame = atoi( pKeyValue );
	}
	else if( !stricmp( pKeyName, "endframe" ) )
	{
		m_nEndFrame = atoi( pKeyValue );
	}
	else if( !stricmp( pKeyName, "volumetexture" ) )
	{
		m_nVolumeTextureDepth = atoi( pKeyValue );

		// FIXME: Volume textures don't currently support DXT compression
		m_vtfProcOptions.flags0 |= VtfProcessingOptions::OPT_NOCOMPRESS;

		// FIXME: Volume textures don't currently support NICE filtering
		m_vtfProcOptions.flags0 &= ~VtfProcessingOptions::OPT_FILTER_NICE;
	}
	else if( !stricmp( pKeyName, "spheremap_x" ) )
	{
		if ( iValue )
			m_LookDir = LOOK_DOWN_X;
	}
	else if( !stricmp( pKeyName, "spheremap_negx" ) )
	{
		if ( iValue )
			m_LookDir = LOOK_DOWN_NEGX;
	}
	else if( !stricmp( pKeyName, "spheremap_y" ) )
	{
		if ( iValue )
			m_LookDir = LOOK_DOWN_Y;
	}
	else if( !stricmp( pKeyName, "spheremap_negy" ) )
	{
		if ( iValue )
			m_LookDir = LOOK_DOWN_NEGY;
	}
	else if( !stricmp( pKeyName, "spheremap_z" ) )
	{
		if ( iValue )
			m_LookDir = LOOK_DOWN_Z;
	}
	else if( !stricmp( pKeyName, "spheremap_negz" ) )
	{
		if ( iValue )
			m_LookDir = LOOK_DOWN_NEGZ;
	}
	else if( !stricmp( pKeyName, "bumpscale" ) )
	{
		m_flBumpScale = atof( pKeyValue );
	}
	else if( !stricmp( pKeyName, "pointsample" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_POINTSAMPLE, iValue );
	}
	else if( !stricmp( pKeyName, "trilinear" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_TRILINEAR, iValue );
	}
	else if( !stricmp( pKeyName, "clamps" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_CLAMPS, iValue );
	}
	else if( !stricmp( pKeyName, "clampt" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_CLAMPT, iValue );
	}
	else if( !stricmp( pKeyName, "clampu" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_CLAMPU, iValue );
	}
	else if( !stricmp( pKeyName, "border" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_BORDER, iValue );
		// Gets applied to s, t and u   We currently assume black border color
	}
	else if( !stricmp( pKeyName, "anisotropic" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_ANISOTROPIC, iValue );
	}
	else if( !stricmp( pKeyName, "dxt5" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_HINT_DXT5, iValue );
	}
	else if( !stricmp( pKeyName, "nocompress" ) )
	{
		SetFlagValue( m_vtfProcOptions.flags0, VtfProcessingOptions::OPT_NOCOMPRESS, iValue );
	}
	else if( !stricmp( pKeyName, "normal" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_NORMAL, iValue );
	}
	else if( !stricmp( pKeyName, "ssbump" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_SSBUMP, iValue );
	}
	else if( !stricmp( pKeyName, "nomip" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_NOMIP, iValue );
	}
	else if( !stricmp( pKeyName, "allmips" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_ALL_MIPS, iValue );
	}
	else if( !stricmp( pKeyName, "nonice" ) )
	{
		SetFlagValue( m_vtfProcOptions.flags0, VtfProcessingOptions::OPT_FILTER_NICE, !iValue );
	}
	else if( !stricmp( pKeyName, "nolod" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_NOLOD, iValue );
	}
	else if( !stricmp( pKeyName, "procedural" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_PROCEDURAL, iValue );
	}
	else if( !stricmp( pKeyName, "alphatest" ) )
	{
		SetFlagValue( m_vtfProcOptions.flags0, VtfProcessingOptions::OPT_MIP_ALPHATEST, iValue );
	}
	else if( !stricmp( pKeyName, "alphatest_threshhold" ) )
	{
		m_flAlphaThreshhold = atof( pKeyValue );
	}
	else if( !stricmp( pKeyName, "alphatest_hifreq_threshhold" ) )
	{
		m_flAlphaHiFreqThreshhold = atof( pKeyValue );
	}
	else if( !stricmp( pKeyName, "rendertarget" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_RENDERTARGET, iValue );
	}
	else if ( !stricmp( pKeyName, "numchannels" ) )
	{
		m_numChannelsMax = atoi( pKeyValue );
	}
	else if ( !stricmp( pKeyName, "nodebug" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_NODEBUGOVERRIDE, iValue );
	}
	else if ( !stricmp( pKeyName, "singlecopy" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_SINGLECOPY, iValue );
	}
	else if( !stricmp( pKeyName, "oneovermiplevelinalpha" ) )
	{
		SetFlagValue( m_vtfProcOptions.flags0, VtfProcessingOptions::OPT_SET_ALPHA_ONEOVERMIP, iValue );
	}
	else if( !stricmp( pKeyName, "premultcolorbyoneovermiplevel" ) )
	{
		SetFlagValue( m_vtfProcOptions.flags0, VtfProcessingOptions::OPT_PREMULT_COLOR_ONEOVERMIP, iValue );
	}
	else if ( !stricmp( pKeyName, "normaltodudv" ) )
	{
		m_bNormalToDuDv = iValue ? true : false;
		SetFlagValue( m_vtfProcOptions.flags0, VtfProcessingOptions::OPT_NORMAL_DUDV, iValue );
	}
	else if ( !stricmp( pKeyName, "stripalphachannel" ) )
	{
		m_bStripAlphaChannel = iValue ? true : false;
	}
	else if ( !stricmp( pKeyName, "stripcolorchannel" ) )
	{
		m_bStripColorChannel = iValue ? true : false;
	}
	else if ( !stricmp( pKeyName, "normalalphatodudvluminance" ) )
	{
		m_bAlphaToLuminance = iValue ? true : false;
	}
	else if ( !stricmp( pKeyName, "dudv" ) )
	{
		m_bDuDv = iValue ? true : false;
	}
	else if( !stricmp( pKeyName, "reduce" ) )
	{
		m_nReduceX = atoi(pKeyValue);
		m_nReduceY = m_nReduceX;
	}
	else if( !stricmp( pKeyName, "reducex" ) )
	{
		m_nReduceX = atoi(pKeyValue);
	}
	else if( !stricmp( pKeyName, "reducey" ) )
	{
		m_nReduceY = atoi(pKeyValue);
	}
	else if( !stricmp( pKeyName, "maxwidth" ) )
	{
		m_nMaxDimensionX = atoi(pKeyValue);
	}
	else if( !stricmp( pKeyName, "maxwidth_360" ) )
	{
		m_nMaxDimensionX_360 = atoi(pKeyValue);
	}
	else if( !stricmp( pKeyName, "maxheight" ) )
	{
		m_nMaxDimensionY = atoi(pKeyValue);
	}
	else if( !stricmp( pKeyName, "maxheight_360" ) )
	{
		m_nMaxDimensionY_360 = atoi(pKeyValue);
	}
	else if( !stricmp( pKeyName, "alphatodistance" ) )
	{
		m_bAlphaToDistance = iValue ? true : false;
	}
	else if( !stricmp( pKeyName, "distancespread" ) )
	{
		m_flDistanceSpread = atof(pKeyValue);
	}
	else if( !stricmp( pKeyName, "pfmscale" ) )
	{
		m_pfmscale=atof(pKeyValue);
		printf("******pfm scale=%f\n",m_pfmscale);
	}
	else if ( !stricmp( pKeyName, "pfm" ) )
	{
		if ( iValue )
			g_eMode = eModePFM;
	}
	else if ( !stricmp( pKeyName, "specvar" ) )
	{
		int iDecayChannel = -1;

		if ( !stricmp( pKeyValue, "red" ) || !stricmp( pKeyValue, "r" ) )
			iDecayChannel = 0;
		if ( !stricmp( pKeyValue, "green" ) || !stricmp( pKeyValue, "g" ) )
			iDecayChannel = 1;
		if ( !stricmp( pKeyValue, "blue" ) || !stricmp( pKeyValue, "b" ) )
			iDecayChannel = 2;
		if ( !stricmp( pKeyValue, "alpha" ) || !stricmp( pKeyValue, "a" ) )
			iDecayChannel = 3;

		if ( iDecayChannel >= 0 && iDecayChannel < 4 )
		{
			m_vtfProcOptions.flags0 |= ( VtfProcessingOptions::OPT_DECAY_R | VtfProcessingOptions::OPT_DECAY_EXP_R ) << iDecayChannel;
			m_vtfProcOptions.numNotDecayMips[iDecayChannel] = 0;
			m_vtfProcOptions.clrDecayGoal[iDecayChannel] = 0;
			m_vtfProcOptions.fDecayExponentBase[iDecayChannel] = 0.75;
			SetFlagValue( m_nFlags, TEXTUREFLAGS_ALL_MIPS, 1 );
		}
	}
	else if ( !stricmp( pKeyName, "mipblend" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_ALL_MIPS, 1 );

		// Possible values
		if ( !stricmp( pKeyValue, "detail" ) ) // Skip 2 mips and fade to gray -> (128, 128, 128, -)
		{
			for( int ch = 0; ch < 3; ++ ch )
			{
				m_vtfProcOptions.flags0 |= VtfProcessingOptions::OPT_DECAY_R << ch;
				// m_vtfProcOptions.flags0 &= ~(VtfProcessingOptions::OPT_DECAY_EXP_R << ch);
				m_vtfProcOptions.numNotDecayMips[ch] = 2;
				m_vtfProcOptions.clrDecayGoal[ch] = 128;
			}
		}
		/*
		else if ( !stricmp( pKeyValue, "additive" ) ) // Skip 2 mips and fade to black -> (0, 0, 0, -)
		{
			for( int ch = 0; ch < 3; ++ ch )
			{
				m_vtfProcOptions.flags0 |= VtfProcessingOptions::OPT_DECAY_R << ch;
				m_vtfProcOptions.flags0 &= ~(VtfProcessingOptions::OPT_DECAY_EXP_R << ch);
				m_vtfProcOptions.numDecayMips[ch] = 2;
				m_vtfProcOptions.clrDecayGoal[ch] = 0;
			}
		}
		else if ( !stricmp( pKeyValue, "alphablended" ) ) // Skip 2 mips and fade out alpha to 0
		{
			for( int ch = 3; ch < 4; ++ ch )
			{
				m_vtfProcOptions.flags0 |= VtfProcessingOptions::OPT_DECAY_R << ch;
				m_vtfProcOptions.flags0 &= ~(VtfProcessingOptions::OPT_DECAY_EXP_R << ch);
				m_vtfProcOptions.numDecayMips[ch] = 2;
				m_vtfProcOptions.clrDecayGoal[ch] = 0;
			}
		}
		*/
		else
		{
			// Parse the given value:
			// skip=3:r=255:g=255:b=255:a=255  - linear decay
			// r=0e.75 - exponential decay targeting 0 with exponent base 0.75

			int nSteps = 0; // default
			
			for ( char const *szParse = pKeyValue; szParse; szParse = strchr( szParse, ':' ), szParse ? ++ szParse : 0 )
			{
				if ( char const *sz = StringAfterPrefix( szParse, "skip=" ) )
				{
					szParse = sz;
					nSteps = atoi(sz);
				}
				else if ( StringHasPrefix( szParse, "r=" ) ||
					      StringHasPrefix( szParse, "g=" ) ||
						  StringHasPrefix( szParse, "b=" ) ||
						  StringHasPrefix( szParse, "a=" ) )
				{
					int ch = 0;
					switch ( *szParse )
					{
					case 'g': case 'G': ch = 1; break;
					case 'b': case 'B': ch = 2; break;
					case 'a': case 'A': ch = 3; break;
					}
					
					szParse += 2;
					m_vtfProcOptions.flags0 |= VtfProcessingOptions::OPT_DECAY_R << ch;
					m_vtfProcOptions.flags0 &= ~(VtfProcessingOptions::OPT_DECAY_EXP_R << ch);
					m_vtfProcOptions.numNotDecayMips[ch] = nSteps;
					m_vtfProcOptions.clrDecayGoal[ch] = atoi( szParse );
					
					while ( isdigit( *szParse ) )
						++ szParse;

					// Exponential decay
					if ( ( *szParse == 'e' || *szParse == 'E' ) && ( szParse[1] == '.' ) )
					{
						m_vtfProcOptions.flags0 |= VtfProcessingOptions::OPT_DECAY_EXP_R << ch;
						m_vtfProcOptions.fDecayExponentBase[ch] = ( float ) atof( szParse + 1 );
					}
				}
				else
				{
					printf( "Warning: invalid mipblend setting \"%s\"\n", pKeyValue );
				}
			}
		}
	}
	else if( !stricmp( pKeyName, "srgb" ) )
	{
		SetFlagValue( m_nFlags, TEXTUREFLAGS_SRGB, iValue );
	}
	else
	{
		VTexError("unrecognized option in text file - %s\n", pKeyName );
	}
}




static const char *GetSourceExtension( void )
{
	switch ( g_eMode )
	{
	case eModePSD:
		return ".psd";
	case eModeTGA:
		return ".tga";
	case eModePFM:
		return ".pfm";
	default:
		return ".tga";
	}
}


//-----------------------------------------------------------------------------
// Computes the desired texture format based on flags
//-----------------------------------------------------------------------------
static ImageFormat ComputeDesiredImageFormat( IVTFTexture *pTexture, VTexConfigInfo_t &info )
{
	bool bDUDVTarget = info.m_bNormalToDuDv || info.m_bDuDv;
	bool bCopyAlphaToLuminance = info.m_bNormalToDuDv && info.m_bAlphaToLuminance;

	ImageFormat targetFormat;

	int nFlags = pTexture->Flags();
	if ( info.m_bStripAlphaChannel )
	{
		nFlags &= ~( TEXTUREFLAGS_ONEBITALPHA | TEXTUREFLAGS_EIGHTBITALPHA );
	}

	// HDRFIXME: Need to figure out what format to use here.
	if ( pTexture->Format() == IMAGE_FORMAT_RGB323232F )
	{
#ifndef DEBUG_NO_COMPRESSION
		if ( g_bUsedAsLaunchableDLL && !( info.m_vtfProcOptions.flags0 & VtfProcessingOptions::OPT_NOCOMPRESS ) )
		{
			return IMAGE_FORMAT_BGRA8888;
		}
		else
#endif // #ifndef DEBUG_NO_COMPRESSION
		{
			return IMAGE_FORMAT_RGBA16161616F;
		}
	}

	if ( bDUDVTarget )
	{
		if ( bCopyAlphaToLuminance && ( nFlags & ( TEXTUREFLAGS_ONEBITALPHA | TEXTUREFLAGS_EIGHTBITALPHA ) ) )
			return IMAGE_FORMAT_UVLX8888;
		return IMAGE_FORMAT_UV88;
	}

	if ( info.m_bStripColorChannel )
	{
		return IMAGE_FORMAT_A8;
	}

	// can't compress textures that are smaller than 4x4
	if( (nFlags & TEXTUREFLAGS_PROCEDURAL) ||
		(info.m_vtfProcOptions.flags0 & VtfProcessingOptions::OPT_NOCOMPRESS) ||
		(pTexture->Width() < 4) || (pTexture->Height() < 4) )
	{
		if ( nFlags & ( TEXTUREFLAGS_ONEBITALPHA | TEXTUREFLAGS_EIGHTBITALPHA ) )
		{
			targetFormat = IMAGE_FORMAT_BGRA8888;
		}
		else
		{
			targetFormat = IMAGE_FORMAT_BGR888;
		}
	}
	else if( nFlags & TEXTUREFLAGS_HINT_DXT5 )
	{
#ifdef DEBUG_NO_COMPRESSION
		targetFormat = IMAGE_FORMAT_BGRA8888;
#else
		targetFormat = IsPosix() ? IMAGE_FORMAT_BGRA8888 : IMAGE_FORMAT_DXT5; // No DXT compressor on Posix
#endif
	}
	else if( nFlags & TEXTUREFLAGS_EIGHTBITALPHA )
	{
		// compressed with alpha blending
#ifdef DEBUG_NO_COMPRESSION
		targetFormat = IMAGE_FORMAT_BGRA8888;
#else
		targetFormat = IsPosix() ? IMAGE_FORMAT_BGRA8888 : IMAGE_FORMAT_DXT5; // No DXT compressor on Posix
#endif
	}
	else if ( nFlags & TEXTUREFLAGS_ONEBITALPHA )
	{
		// garymcthack - fixme IMAGE_FORMAT_DXT1_ONEBITALPHA doesn't work yet.
#ifdef DEBUG_NO_COMPRESSION
		targetFormat = IMAGE_FORMAT_BGRA8888;
#else
		//		targetFormat = IMAGE_FORMAT_DXT1_ONEBITALPHA;
		targetFormat = IsPosix() ? IMAGE_FORMAT_BGRA8888 : IMAGE_FORMAT_DXT5; // No DXT compressor on Posix
#endif
	}
	else
	{
#ifdef DEBUG_NO_COMPRESSION
		targetFormat = IMAGE_FORMAT_BGR888;
#else
		targetFormat = IsPosix() ? IMAGE_FORMAT_BGR888 : IMAGE_FORMAT_DXT1; // No DXT compressor on Posix
#endif
	}
	return targetFormat;
} 


//-----------------------------------------------------------------------------
// Computes the low res image size
//-----------------------------------------------------------------------------
void VTFGetLowResImageInfo( int cacheWidth, int cacheHeight, int *lowResImageWidth, int *lowResImageHeight,
						   ImageFormat *imageFormat )
{
	if (cacheWidth > cacheHeight)
	{
		int factor = cacheWidth / LOWRESIMAGE_DIM;
		if (factor > 0)
		{
			*lowResImageWidth = LOWRESIMAGE_DIM;
			*lowResImageHeight = cacheHeight / factor;
		}
		else
		{
			*lowResImageWidth = cacheWidth;
			*lowResImageHeight = cacheHeight;
		}
	}
	else
	{
		int factor = cacheHeight / LOWRESIMAGE_DIM;
		if (factor > 0)
		{
			*lowResImageHeight = LOWRESIMAGE_DIM;
			*lowResImageWidth = cacheWidth / factor;
		}
		else
		{
			*lowResImageWidth = cacheWidth;
			*lowResImageHeight = cacheHeight;
		}
	}

	// Can end up with a dimension of zero for high aspect ration images.
	if( *lowResImageWidth < 1 )
	{
		*lowResImageWidth = 1;
	}
	if( *lowResImageHeight < 1 )
	{
		*lowResImageHeight = 1;
	}
	*imageFormat = LOWRES_IMAGE_FORMAT;
}


//-----------------------------------------------------------------------------
// This method creates the low-res image and hooks it into the VTF Texture
//-----------------------------------------------------------------------------
static void CreateLowResImage( IVTFTexture *pVTFTexture )
{
	int iWidth, iHeight;
	ImageFormat imageFormat;
	VTFGetLowResImageInfo( pVTFTexture->Width(), pVTFTexture->Height(), &iWidth, &iHeight, &imageFormat );

	// Allocate the low-res image data
	pVTFTexture->InitLowResImage( iWidth, iHeight, imageFormat );

	// Generate the low-res image bits
	if (!pVTFTexture->ConstructLowResImage())
	{
		VTexError( "Can't convert image from %s to %s in CalcLowResImage\n",
			ImageLoader::GetName(IMAGE_FORMAT_RGBA8888), ImageLoader::GetName(imageFormat) );
	}
}


//-----------------------------------------------------------------------------
// Computes the source file name
//-----------------------------------------------------------------------------
void MakeSrcFileName( char *pSrcName, unsigned int flags, const char *pFullNameWithoutExtension, int frameID, 
					 int faceID, int z, bool isCubeMap, int startFrame, int endFrame, bool bNormalToDUDV )
{
	bool bAnimated = !( startFrame == -1 || endFrame == -1 );

	char tempBuf[512];
	if( bNormalToDUDV )
	{
		char *pNormalString = Q_stristr( ( char * )pFullNameWithoutExtension, "_dudv" );
		if( pNormalString )
		{
			Q_strncpy( tempBuf, pFullNameWithoutExtension, sizeof(tempBuf) );
			char *pNormalString = Q_stristr( tempBuf, "_dudv" );
			Q_strcpy( pNormalString, "_normal" );
			pFullNameWithoutExtension = tempBuf;
		}
		else
		{
			Assert( Q_stristr( ( char * )pFullNameWithoutExtension, "_dudv" ) );
		}
	}

	if( bAnimated )
	{
		if( isCubeMap )
		{
			Assert( z == -1 );
			sprintf( pSrcName, "%s%s%03d%s", pFullNameWithoutExtension, g_CubemapFacingNames[faceID], frameID + startFrame, GetSourceExtension() );
		}
		else
		{
			if ( z == -1 )
			{
				sprintf( pSrcName, "%s%03d%s", pFullNameWithoutExtension, frameID + startFrame, GetSourceExtension() );
			}
			else
			{
				sprintf( pSrcName, "%s%03d_z%03d%s", pFullNameWithoutExtension, z, frameID + startFrame, GetSourceExtension() );
			}
		}
	}
	else
	{
		if( isCubeMap )
		{
			Assert( z == -1 );
			sprintf( pSrcName, "%s%s%s", pFullNameWithoutExtension, g_CubemapFacingNames[faceID], GetSourceExtension() );
		}
		else
		{
			if ( z == -1 )
			{
				sprintf( pSrcName, "%s%s", pFullNameWithoutExtension, GetSourceExtension() );
			}
			else
			{
				sprintf( pSrcName, "%s_z%03d%s", pFullNameWithoutExtension, z, GetSourceExtension() );
			}
		}
	}
}

static void ComputeBufferHash( void const *pvBuffer, size_t numBytes, CRC32_t &uiHashUpdate )
{
	CRC32_ProcessBuffer( &uiHashUpdate, pvBuffer, numBytes );
}

//-----------------------------------------------------------------------------
// Loads a file into a UTLBuffer,
// also computes the hash of the buffer.
//-----------------------------------------------------------------------------
static bool LoadFile( const char *pFileName, CUtlBuffer &buf, bool bFailOnError, CRC32_t *puiHash )
{
	FILE *fp = fopen( pFileName, "rb" );
	if (!fp)
	{
		if ( bFailOnError )
			VTexError( "Can't open: \"%s\"\n", pFileName );

		return false;
	}

	fseek( fp, 0, SEEK_END );
	int nFileLength = ftell( fp );
	fseek( fp, 0, SEEK_SET );

	buf.EnsureCapacity( nFileLength );
	int nBytesRead = fread( buf.Base(), 1, nFileLength, fp );
	fclose( fp );

	buf.SeekPut( CUtlBuffer::SEEK_HEAD, nBytesRead );

	{ CP4AutoAddFile autop4( pFileName ); /* add loaded file to P4 */ }

	// Auto-compute buffer hash if necessary
	if ( puiHash )
		ComputeBufferHash( buf.Base(), nBytesRead, *puiHash );

	return true;
}


//-----------------------------------------------------------------------------
// Creates a texture the size of the PSD image stored in the buffer
//-----------------------------------------------------------------------------
static void InitializeSrcTexture_PSD( IVTFTexture *pTexture, const char *pInputFileName,
									  CUtlBuffer &psdBuffer, int nDepth, int nFrameCount,
									  const VTexConfigInfo_t &info )
{
	int nWidth, nHeight;
	ImageFormat imageFormat;
	float flSrcGamma; 
	bool ok = PSDGetInfo( psdBuffer, &nWidth, &nHeight, &imageFormat, &flSrcGamma );
	if (!ok)
	{
		Error( "PSD %s is bogus!\n", pInputFileName );
	}
	nWidth /= info.m_nReduceX;
	nHeight /= info.m_nReduceY;


	if (!pTexture->Init( nWidth, nHeight, nDepth, IMAGE_FORMAT_DEFAULT, info.m_nFlags, nFrameCount ))
	{
		Error( "Error initializing texture %s\n", pInputFileName );
	}
}

//-----------------------------------------------------------------------------
// Creates a texture the size of the TGA image stored in the buffer
//-----------------------------------------------------------------------------
static void InitializeSrcTexture_TGA( IVTFTexture *pTexture, const char *pInputFileName,
									  CUtlBuffer &tgaBuffer, int nDepth, int nFrameCount,
									  const VTexConfigInfo_t &info )
{
	int nWidth, nHeight;
	ImageFormat imageFormat;
	float flSrcGamma; 
	bool ok = TGALoader::GetInfo( tgaBuffer, &nWidth, &nHeight, &imageFormat, &flSrcGamma );
	if (!ok)
	{
		Error( "TGA %s is bogus!\n", pInputFileName );
	}
	nWidth /= info.m_nReduceX;
	nHeight /= info.m_nReduceY;

	if (!pTexture->Init( nWidth, nHeight, nDepth, IMAGE_FORMAT_DEFAULT, info.m_nFlags, nFrameCount ))
	{
		Error( "Error initializing texture %s\n", pInputFileName );
	}
}


// HDRFIXME: Put this somewhere better than this.
// This reads an integer from a binary CUtlBuffer.
static int ReadIntFromUtlBuffer( CUtlBuffer &buf )
{
	int val = 0;
	int c;
	while( buf.IsValid() )
	{
		c = buf.GetChar();
		if( c >= '0' && c <= '9' )
		{
			val = val * 10 + ( c - '0' );
		}
		else
		{
			buf.SeekGet( CUtlBuffer::SEEK_CURRENT, -1 );
			break;
		}
	}
	return val;
}

static inline bool IsWhitespace( char c )
{
	return c == ' ' || c == '\t' || c == 10;
}

static void EatWhiteSpace( CUtlBuffer &buf )
{
	while( buf.IsValid() )
	{
		int	c = buf.GetChar();
		if( !IsWhitespace( c ) )
		{
			buf.SeekGet( CUtlBuffer::SEEK_CURRENT, -1 );
			return;
		}
	}
	return;
}

//-----------------------------------------------------------------------------
// Creates a texture the size of the PFM image stored in the buffer
//-----------------------------------------------------------------------------
static void InitializeSrcTexture_PFM( IVTFTexture *pTexture, const char *pInputFileName,
									  CUtlBuffer &fileBuffer, int nDepth, int nFrameCount, 
									  const VTexConfigInfo_t &info )
{
	fileBuffer.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
	if( fileBuffer.GetChar() != 'P' )
	{
		Assert( 0 );
		return;
	}
	if( fileBuffer.GetChar() != 'F' )
	{
		Assert( 0 );
		return;
	}
	if( fileBuffer.GetChar() != 0xa )
	{
		Assert( 0 );
		return;
	}
	int nWidth, nHeight;
	nWidth = ReadIntFromUtlBuffer( fileBuffer );
	EatWhiteSpace( fileBuffer );
	nHeight = ReadIntFromUtlBuffer( fileBuffer );

	//	// eat crap until the next newline
	//	while( fileBuffer.GetChar() != 0xa )
	//	{
	//	}

	nWidth /= info.m_nReduceX;

	nHeight /= info.m_nReduceY;


	if (!pTexture->Init( nWidth, nHeight, nDepth, IMAGE_FORMAT_RGB323232F, info.m_nFlags, nFrameCount ))
	{
		Error( "Error initializing texture %s\n", pInputFileName );
	}
}

static void InitializeSrcTexture( IVTFTexture *pTexture, const char *pInputFileName,
								  CUtlBuffer &tgaBuffer, int nDepth, int nFrameCount,
								  const VTexConfigInfo_t &info )
{
	switch ( g_eMode )
	{
	case eModePSD:
		InitializeSrcTexture_PSD( pTexture, pInputFileName, tgaBuffer, nDepth, nFrameCount, info );
		break;
	case eModeTGA:
		InitializeSrcTexture_TGA( pTexture, pInputFileName, tgaBuffer, nDepth, nFrameCount, info );
		break;
	case eModePFM:
		InitializeSrcTexture_PFM( pTexture, pInputFileName, tgaBuffer, nDepth, nFrameCount, info );
		break;
	}
}

#define DISTANCE_CODE_ALPHA_INOUT_THRESHOLD 10


//-----------------------------------------------------------------------------
// Loads a face from a PSD image
//-----------------------------------------------------------------------------
static bool LoadFaceFromPSD( IVTFTexture *pTexture, CUtlBuffer &psdBuffer, int z, int nFrame, int nFace, float flGamma, const VTexConfigInfo_t &info )
{
	// NOTE: This only works because all mip levels are stored sequentially
	// in memory, starting with the highest mip level. It also only works
	// because the VTF Texture store *all* mip levels down to 1x1

	// Get the information from the file...
	int nWidth, nHeight;
	ImageFormat imageFormat;
	float flSrcGamma;
	bool ok = PSDGetInfo( psdBuffer, &nWidth, &nHeight, &imageFormat, &flSrcGamma );
	if (!ok)
		return false;

	// Seek back so PSDLoader can see the psd header...
	psdBuffer.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );

	// Load the psd and create all mipmap levels
	unsigned char *pDestBits = pTexture->ImageData( nFrame, nFace, 0, 0, 0, z );

	if ( ( info.m_bAlphaToDistance ) || 
		( nWidth != pTexture->Width() ) ||
		( nHeight != pTexture->Height() ) )
	{
		// Load into temp
		Bitmap_t bmPsdData;
		ok = PSDReadFileRGBA8888( psdBuffer, bmPsdData );
		if ( !ok )
			return false;

		CUtlMemory<uint8> tmpDest( 0, pTexture->Width() * pTexture->Height() * 4 );

		ImageLoader::ResampleInfo_t resInfo;
		resInfo.m_pSrc = bmPsdData.GetBits();
		resInfo.m_pDest = tmpDest.Base();
		resInfo.m_nSrcWidth = nWidth;
		resInfo.m_nSrcHeight = nHeight;
		resInfo.m_nDestWidth = pTexture->Width();
		resInfo.m_nDestHeight = pTexture->Height();
		resInfo.m_flSrcGamma = flGamma;
		resInfo.m_flDestGamma = flGamma;
		if (info.m_vtfProcOptions.flags0 & VtfProcessingOptions::OPT_FILTER_NICE )
		{
			resInfo.m_nFlags |= ImageLoader::RESAMPLE_NICE_FILTER;
		}

		ResampleRGBA8888( resInfo );

		if ( info.m_bAlphaToDistance )
		{
			float flMaxRad=info.m_flDistanceSpread*2.0*max(info.m_nReduceX,info.m_nReduceY);
			int nSearchRad=ceil(flMaxRad);
			bool bWarnEdges = false;
			// now, do alpha to distance coded stuff
			ImageFormatInfo_t fmtInfo=ImageLoader::ImageFormatInfo( pTexture->Format() );
			if ( fmtInfo.m_NumAlphaBits == 0 )
			{
				VTexWarning( "%s: alpha to distance asked for but no alpha channel.\n", info.m_SrcName );
			}
			else
			{
				for(int x=0; x < pTexture->Width(); x++ )
				{
					for(int y=0; y < pTexture->Height(); y++ )
					{
						// map to original image coords
						int nOrig_x=FLerp(0,nWidth-1,0,pTexture->Width()-1,x);
						int nOrig_y=FLerp(0,nHeight-1,0,pTexture->Height()-1,y);

						uint8 nOrigAlpha = bmPsdData.GetColor(nOrig_x, nOrig_y).a();
						bool bInOrOut=nOrigAlpha > DISTANCE_CODE_ALPHA_INOUT_THRESHOLD;

						float flClosest_Dist=1.0e23;
						for(int iy=-nSearchRad; iy <= nSearchRad; iy++ )
						{
							for(int ix=-nSearchRad; ix <= nSearchRad; ix++ )
							{
								int cx=max( 0, min( nWidth-1, ix + nOrig_x ) );
								int cy=max( 0, min( nHeight-1, iy + nOrig_y ) );

								uint8 alphaValue = bmPsdData.GetColor(cx, cy).a();
								bool bIn =( alphaValue > DISTANCE_CODE_ALPHA_INOUT_THRESHOLD );
								if ( bInOrOut != bIn )		// transition?
								{
									float flTryDist = sqrt( (float) (ix*ix+iy*iy) );
									flClosest_Dist = min( flClosest_Dist, flTryDist );
								}
							}
						}

						// now, map signed distance to alpha value
						float flOutDist = min( 0.5f, FLerp( 0, .5, 0, flMaxRad, flClosest_Dist ) );
						if ( ! bInOrOut )
						{
							// negative distance
							flOutDist = -flOutDist;
						}
						uint8 &nOutAlpha= tmpDest[3+4*(x+pTexture->Width()*y )];
						nOutAlpha = min( 255.0, 255.0*( 0.5+flOutDist ) );
						if ( ( nOutAlpha != 0 ) && 
							(
							( x == 0 ) ||
							( y == 0 ) ||
							( x == pTexture->Width()-1 ) ||
							( y == pTexture->Height()-1 ) ) )
						{
							bWarnEdges = true;
							nOutAlpha = 0;					// force it.
						}
					}
				}
			}

			if ( bWarnEdges )
			{
				VTexWarning( "%s: There are non-zero distance pixels along the image edge. You may need"
					" to reduce your distance spread or reduce the image less"
					" or add a border to the image.\n",
					info.m_SrcName );
			}
		}


		// now, store in dest
		ImageLoader::ConvertImageFormat( tmpDest.Base(), IMAGE_FORMAT_RGBA8888, pDestBits,
			pTexture->Format(), pTexture->Width(), pTexture->Height(), 
			0, 0 );
		return true;

	}
	else
	{
		// Read the PSD file into a bitmap
		Bitmap_t bmPsdData;
		ok = PSDReadFileRGBA8888( psdBuffer, bmPsdData );
		if ( ok )
		{
			memcpy( pDestBits, bmPsdData.GetBits(), bmPsdData.Height() * bmPsdData.Stride() );
		}
		return ok;
	}
}


//-----------------------------------------------------------------------------
// Loads a face from a TGA image
//-----------------------------------------------------------------------------
static bool LoadFaceFromTGA( IVTFTexture *pTexture, CUtlBuffer &tgaBuffer, int z, int nFrame, int nFace, float flGamma, const VTexConfigInfo_t &info )
{
	// NOTE: This only works because all mip levels are stored sequentially
	// in memory, starting with the highest mip level. It also only works
	// because the VTF Texture store *all* mip levels down to 1x1

	// Get the information from the file...
	int nWidth, nHeight;
	ImageFormat imageFormat;
	float flSrcGamma;
	bool ok = TGALoader::GetInfo( tgaBuffer, &nWidth, &nHeight, &imageFormat, &flSrcGamma );
	if (!ok)
		return false;

	// Seek back so TGALoader::Load can see the tga header...
	tgaBuffer.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
	
	// Load the tga and create all mipmap levels
	unsigned char *pDestBits = pTexture->ImageData( nFrame, nFace, 0, 0, 0, z );

	if ( ( info.m_bAlphaToDistance ) || 
		 ( nWidth != pTexture->Width() ) ||
		 ( nHeight != pTexture->Height() ) )
	{
		// load into temp and resample
		CUtlMemory<uint8> tmpImage( 0, nWidth*nHeight*4 );
		if ( ! TGALoader::Load( tmpImage.Base(), tgaBuffer, nWidth, 
								nHeight, IMAGE_FORMAT_RGBA8888, flGamma, false ) )
		{
			return false;
		}

		CUtlMemory<uint8> tmpDest( 0, pTexture->Width() * pTexture->Height() *4 );

		ImageLoader::ResampleInfo_t resInfo;
		resInfo.m_pSrc = tmpImage.Base();
		resInfo.m_pDest = tmpDest.Base();
		resInfo.m_nSrcWidth = nWidth;
		resInfo.m_nSrcHeight = nHeight;
		resInfo.m_nDestWidth = pTexture->Width();
		resInfo.m_nDestHeight = pTexture->Height();
		resInfo.m_flSrcGamma = flGamma;
		resInfo.m_flDestGamma = flGamma;
		if (info.m_vtfProcOptions.flags0 & VtfProcessingOptions::OPT_FILTER_NICE )
		{
			resInfo.m_nFlags |= ImageLoader::RESAMPLE_NICE_FILTER;
		}

		ResampleRGBA8888( resInfo );

		if ( info.m_bAlphaToDistance )
		{
			float flMaxRad=info.m_flDistanceSpread*2.0*max(info.m_nReduceX,info.m_nReduceY);
			int nSearchRad=ceil(flMaxRad);
			bool bWarnEdges = false;
			// now, do alpha to distance coded stuff
			ImageFormatInfo_t fmtInfo=ImageLoader::ImageFormatInfo( pTexture->Format() );
			if ( fmtInfo.m_NumAlphaBits == 0 )
			{
				VTexWarning( "%s: alpha to distance asked for but no alpha channel.\n", info.m_SrcName );
			}
			else
			{
				for(int x=0; x < pTexture->Width(); x++ )
				{
					for(int y=0; y < pTexture->Height(); y++ )
					{
						// map to original image coords
						int nOrig_x=FLerp(0,nWidth-1,0,pTexture->Width()-1,x);
						int nOrig_y=FLerp(0,nHeight-1,0,pTexture->Height()-1,y);
						
						uint8 nOrigAlpha=tmpImage[3+4*(nOrig_x+nWidth*nOrig_y)];
						bool bInOrOut=nOrigAlpha > DISTANCE_CODE_ALPHA_INOUT_THRESHOLD;

						float flClosest_Dist=1.0e23;
						for(int iy=-nSearchRad; iy <= nSearchRad; iy++ )
						{
							for(int ix=-nSearchRad; ix <= nSearchRad; ix++ )
							{
								int cx=max( 0, min( nWidth-1, ix + nOrig_x ) );
								int cy=max( 0, min( nHeight-1, iy + nOrig_y ) );

								int nOffset = 3+ 4 * ( cx + cy * nWidth );
								uint8 alphaValue = tmpImage[nOffset];
								bool bIn =( alphaValue > DISTANCE_CODE_ALPHA_INOUT_THRESHOLD );
								if ( bInOrOut != bIn )		// transition?
								{
									float flTryDist = sqrt( (float) (ix*ix+iy*iy) );
									flClosest_Dist = min( flClosest_Dist, flTryDist );
								}
							}
						}

						// now, map signed distance to alpha value
						float flOutDist = min( 0.5f, FLerp( 0, .5, 0, flMaxRad, flClosest_Dist ) );
						if ( ! bInOrOut )
						{
							// negative distance
							flOutDist = -flOutDist;
						}
						uint8 &nOutAlpha= tmpDest[3+4*(x+pTexture->Width()*y )];
						nOutAlpha = min( 255.0, 255.0*( 0.5+flOutDist ) );
						if ( ( nOutAlpha != 0 ) && 
							 (
								 ( x == 0 ) ||
								 ( y == 0 ) ||
								 ( x == pTexture->Width()-1 ) ||
								 ( y == pTexture->Height()-1 ) ) )
						{
							bWarnEdges = true;
							nOutAlpha = 0;					// force it.
						}
					}
				}
			}

			if ( bWarnEdges )
			{
				VTexWarning( "%s: There are non-zero distance pixels along the image edge. You may need"
							 " to reduce your distance spread or reduce the image less"
							 " or add a border to the image.\n",
							 info.m_SrcName );
			}
		}
		
		
		// now, store in dest
		ImageLoader::ConvertImageFormat( tmpDest.Base(), IMAGE_FORMAT_RGBA8888, pDestBits,
										 pTexture->Format(), pTexture->Width(), pTexture->Height(), 
										 0, 0 );
		return true;
		
	}
	else
	{
		return TGALoader::Load( pDestBits, tgaBuffer, pTexture->Width(), 
			pTexture->Height(), pTexture->Format(), flGamma, false );
	}
}

//-----------------------------------------------------------------------------
// Loads a face from a PFM image
//-----------------------------------------------------------------------------
// HDRFIXME: How is this different from InitializeSrcTexture_PFM?
static bool LoadFaceFromPFM( IVTFTexture *pTexture, CUtlBuffer &fileBuffer, int z, int nFrame,
							int nFace, float flGamma, const VTexConfigInfo_t &info )
{
	fileBuffer.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
	if( fileBuffer.GetChar() != 'P' )
	{
		Assert( 0 );
		return false;
	}
	if( fileBuffer.GetChar() != 'F' )
	{
		Assert( 0 );
		return false;
	}
	if( fileBuffer.GetChar() != 0xa )
	{
		Assert( 0 );
		return false;
	}
	int nWidth, nHeight;
	nWidth = ReadIntFromUtlBuffer( fileBuffer );
	EatWhiteSpace( fileBuffer );
	nHeight = ReadIntFromUtlBuffer( fileBuffer );

	// eat crap until the next newline
	while( fileBuffer.IsValid() && fileBuffer.GetChar() != 0xa )
	{
	}
	// eat crap until the next newline
	while( fileBuffer.IsValid() && fileBuffer.GetChar() != 0xa )
	{
	}
	Assert( ImageLoader::SizeInBytes( pTexture->Format() ) == 3 * sizeof( float ) );

	// Load the pfm and create all mipmap levels
	float *pDestBits = ( float * )pTexture->ImageData( nFrame, nFace, 0, 0, 0, z );

	int y;
	for( y = nHeight-1; y >= 0; y-- )
	{
		Assert( fileBuffer.IsValid() );
		fileBuffer.Get( pDestBits + y * nWidth * 3, nWidth * 3 * sizeof( float ) );
		for(int x=0;x<nWidth*3;x++)
			pDestBits[x+y*nWidth*3]*=info.m_pfmscale;
	}
	return true;
}

static bool LoadFaceFromX( IVTFTexture *pTexture, CUtlBuffer &tgaBuffer, int z, int nFrame, int nFace, 
						   float flGamma, const VTexConfigInfo_t &info )
{
	switch ( g_eMode )
	{
	case eModePSD:
		return LoadFaceFromPSD( pTexture, tgaBuffer, z, nFrame, nFace, flGamma, info );
		break;
	case eModeTGA:
		return LoadFaceFromTGA( pTexture, tgaBuffer, z, nFrame, nFace, flGamma, info );
		break;
	case eModePFM:
		return LoadFaceFromPFM( pTexture, tgaBuffer, z, nFrame, nFace, flGamma, info );
		break;
	default:
		return false;
	}
}

static bool LoadFace( IVTFTexture *pTexture, CUtlBuffer &tgaBuffer, int z, int nFrame, int nFace, 
					  float flGamma, const VTexConfigInfo_t &info )
{
	if ( !LoadFaceFromX( pTexture, tgaBuffer, z, nFrame, nFace, flGamma, info ) )
		return false;

	// Restricting number of channels by painting white into the rest
	if ( info.m_numChannelsMax < 1 || info.m_numChannelsMax > 4 )
	{
		VTexWarning( "%s: Invalid setting restricting number of channels to %d, discarded!\n", info.m_SrcName, info.m_numChannelsMax );
	}
	else if ( info.m_numChannelsMax < 4 )
	{
		if ( 4 != ImageLoader::SizeInBytes( pTexture->Format() ) )
		{
			VTexWarning( "%s: Channels restricted to %d, but cannot fill white"
				" because pixel format is %d (size in bytes %d)!"
				" Proceeding with unmodified channels.\n",
				info.m_SrcName,
				info.m_numChannelsMax, pTexture->Format(), ImageLoader::SizeInBytes( pTexture->Format() ) );
			Assert( 0 );
		}
		else
		{
			// Fill other channels with white

			unsigned char *pDestBits = pTexture->ImageData( nFrame, nFace, 0, 0, 0, z );
			int nWidth = pTexture->Width();
			int nHeight = pTexture->Height();
			
			int nPaintOff = info.m_numChannelsMax;
			int nPaintBytes = 4 - nPaintOff;
			
			pDestBits += nPaintOff;

			for( int j = 0; j < nHeight; ++ j )
			{
				for ( int k = 0; k < nWidth; ++ k, pDestBits += 4 )
				{
					memset( pDestBits, 0xFF, nPaintBytes );
				}
			}
		}
	}

	return true;
}

//-----------------------------------------------------------------------------
// Loads source image data 
//-----------------------------------------------------------------------------
static bool LoadSourceImages( IVTFTexture *pTexture, const char *pFullNameWithoutExtension,
							  bool *pbGenerateSphereMaps,
							  VTexConfigInfo_t &info )
{
	static char pSrcName[1024];

	bool bGenerateSpheremaps = false;

	// The input file name here is simply for error reporting
	char *pInputFileName = ( char * )stackalloc( strlen( pFullNameWithoutExtension ) + strlen( GetSourceExtension() ) + 1 );
	strcpy( pInputFileName, pFullNameWithoutExtension );
	strcat( pInputFileName, GetSourceExtension() );

	int nFrameCount;
	bool bAnimated = !( info.m_nStartFrame == -1 || info.m_nEndFrame == -1 );
	if( !bAnimated )
	{
		nFrameCount = 1;
	}
	else
	{
		nFrameCount = info.m_nEndFrame - info.m_nStartFrame + 1;
	}

	bool bIsCubeMap = (info.m_nFlags & TEXTUREFLAGS_ENVMAP) != 0;
	bool bIsVolumeTexture = ( info.m_nVolumeTextureDepth > 1 );

	// Iterate over all faces of all frames
	int nFaceCount = bIsCubeMap ? CUBEMAP_FACE_COUNT : 1;
	for( int iFrame = 0; iFrame < nFrameCount; ++iFrame )
	{
		for( int iFace = 0; iFace < nFaceCount; ++iFace )
		{
			for ( int z = 0; z < info.m_nVolumeTextureDepth; ++z )
			{
				// Generate the filename to load....
				MakeSrcFileName( pSrcName, info.m_nFlags, pFullNameWithoutExtension, 
					iFrame, iFace, bIsVolumeTexture ? z : -1, bIsCubeMap, info.m_nStartFrame, info.m_nEndFrame, info.m_bNormalToDuDv );

				// Don't fail if the 7th iFace of a cubemap isn't loaded...
				// that just means that we're gonna have to build the spheremap ourself.
				bool bFailOnError = !bIsCubeMap || (iFace != CUBEMAP_FACE_SPHEREMAP);

				// Load the TGA from disk...
				CUtlBuffer tgaBuffer;
				if ( !LoadFile( pSrcName, tgaBuffer, bFailOnError,
					( g_eMode != eModePSD ) ? &info.m_uiInputHash : NULL ) )
				{
					// If we want to fail on error and VTexError didn't abort then
					// simply notify the caller that we failed
					if ( bFailOnError )
						return false;

					// The only other way we can get here is if LoadFile tried to load a spheremap and failed
					bGenerateSpheremaps = true;
					continue;
				}

				// Initialize the VTF Texture here if we haven't already....
				// Note that we have to do it here because we have to get the width + height from the file
				if (!pTexture->ImageData())
				{
					InitializeSrcTexture( pTexture, pSrcName, tgaBuffer, info.m_nVolumeTextureDepth, nFrameCount, info );

					// Re-seek back to the front of the buffer so LoadFaceFromTGA works
					tgaBuffer.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
				}

				strcpy( info.m_SrcName, pSrcName );
				// NOTE: This here will generate all mip levels of the source image
				if (!LoadFace( pTexture, tgaBuffer, z, iFrame, iFace, 2.2, info ))
				{
					Error( "Error loading texture %s\n", pInputFileName );
				}
			}
		}
	}

	if ( pbGenerateSphereMaps )
	{
		*pbGenerateSphereMaps = bGenerateSpheremaps;
	}

	return true;
}


void PreprocessSkyBox( char *pFullNameWithoutExtension, int *iSkyboxFace )
{
	// When we get here, it means that we're processing one face of a skybox, but we're going to 
	// load all the faces and treat it as a cubemap so we can do the edge matching.

	// Since they passed in only one face of the skybox, there's a 2 letter extension we want to get rid of.
	int len = strlen( pFullNameWithoutExtension );
	if ( len >= 3 )
	{
		// Make sure there really is a 2 letter extension.
		char *pEnd = &pFullNameWithoutExtension[ len - 2 ];
		*iSkyboxFace = -1;
		for ( int i=0; i < ARRAYSIZE( g_CubemapFacingNames ); i++ )
		{
			if ( stricmp( pEnd, g_CubemapFacingNames[i] ) == 0 )
			{
				*iSkyboxFace = i;
				break;
			}
		}

		// Cut off the 2 letter extension.
		if ( *iSkyboxFace != -1 )
		{
			pEnd[0] = 0;
			return;
		}
	}

	Error( "PreprocessSkyBox: filename %s doesn't have a proper extension (bk, dn, rt, etc..)\n", pFullNameWithoutExtension );
}


// Right now, we've got a full cubemap, and we want to return the one face of the
// skybox that we're supposed to be processing.
IVTFTexture* PostProcessSkyBox( IVTFTexture *pTexture, int iSkyboxFace )
{
	int nFlags = pTexture->Flags();
	Assert( nFlags & TEXTUREFLAGS_ENVMAP );	// Should have been treated as an envmap till now.
	nFlags &= ~TEXTUREFLAGS_ENVMAP;			// But it ends now!

	IVTFTexture *pRet = CreateVTFTexture();
	if ( !pRet->Init( pTexture->Width(), pTexture->Height(), 1, pTexture->Format(), nFlags, pTexture->FrameCount() ) )
		Error( "PostProcessSkyBox: IVTFTexture::Init() failed.\n" );

	// Now just dump the data for the face we want to keep.
	int nMips = min( pTexture->MipCount(), pRet->MipCount() );
	for ( int iMip=0; iMip < nMips; iMip++ )
	{
		int mipSize = pTexture->ComputeMipSize( iMip );
		if ( pRet->ComputeMipSize( iMip ) != mipSize )
		{
			Error( "PostProcessSkyBox: ComputeMipSize differs (src=%d, dest=%d)\n", mipSize, pRet->ComputeMipSize( iMip ) );
		}

		for ( int iFrame=0; iFrame < pTexture->FrameCount(); iFrame++ )
		{
			unsigned char *pDest = pRet->ImageData( iFrame, 0, iMip );
			const unsigned char *pSrc = pTexture->ImageData( iFrame, iSkyboxFace, iMip );
			memcpy( pDest, pSrc, mipSize );
		}
	}

	// Note: there are a few things that don't get copied here, like alpha test threshold
	// and bumpscale, but we shouldn't need those for skyboxes anyway.

	// Get rid of the full cubemap one and return the single-face one.
	DestroyVTFTexture( pTexture );
	return pRet;
}


void MakeDirHier( const char *pPath )
{
#ifdef POSIX
#define mkdir(s) mkdir(s, S_IRWXU | S_IRWXG | S_IRWXO )
#endif
	char temp[1024];
	Q_strncpy( temp, pPath, 1024 );
	int i;
	for( i = 0; i < strlen( temp ); i++ )
	{
		if( temp[i] == '/' || temp[i] == '\\' )
		{
			temp[i] = '\0';
			//			DebugOut( "mkdir( %s )\n", temp );
			mkdir( temp );
			temp[i] = CORRECT_PATH_SEPARATOR;
		}
	}
	//	DebugOut( "mkdir( %s )\n", temp );
	mkdir( temp );
}


static uint8 GetClampingValue( int nClampSize )
{
	if ( nClampSize <= 0 )
		return 30;											// ~1 billion
	int nRet = 0;
	while ( nClampSize > 1 )
	{
		nClampSize >>= 1;
		nRet++;
	}
	return nRet;
}

static void SetTextureLodData( IVTFTexture *pTexture, VTexConfigInfo_t const &info )
{
	if (
		( info.m_nMaxDimensionX > 0 && info.m_nMaxDimensionX < pTexture->Width() ) ||
		( info.m_nMaxDimensionY > 0 && info.m_nMaxDimensionY < pTexture->Height() ) ||
		( info.m_nMaxDimensionX_360 > 0 && info.m_nMaxDimensionX_360 < pTexture->Width() ) ||
		( info.m_nMaxDimensionY_360 > 0 && info.m_nMaxDimensionY_360 < pTexture->Height() )
		)
	{
		TextureLODControlSettings_t lodChunk;
		memset( &lodChunk, 0, sizeof( lodChunk ) );
		lodChunk.m_ResolutionClampX = GetClampingValue( info.m_nMaxDimensionX );
		lodChunk.m_ResolutionClampY = GetClampingValue( info.m_nMaxDimensionY );
		lodChunk.m_ResolutionClampX_360 = GetClampingValue( info.m_nMaxDimensionX_360 );
		lodChunk.m_ResolutionClampY_360 = GetClampingValue( info.m_nMaxDimensionY_360 );
		pTexture->SetResourceData( VTF_RSRC_TEXTURE_LOD_SETTINGS, &lodChunk, sizeof( lodChunk ) );
	}
}


static void AttachShtFile( const char *pFullNameWithoutExtension, IVTFTexture *pTexture, CRC32_t *puiHash )
{
	char shtName[MAX_PATH];
	Q_strncpy( shtName, pFullNameWithoutExtension, sizeof(shtName) );
	Q_SetExtension( shtName, ".sht", sizeof(shtName) );

	struct	_stat statBuf;
	if( _stat( shtName, &statBuf ) == -1 )
		return;

	printf( "Attaching .sht file %s.\n", shtName );

	// Ok, the file exists. Read it.
	CUtlBuffer buf;
	if ( !LoadFile( shtName, buf, false, puiHash ) )
		return;

	pTexture->SetResourceData( VTF_RSRC_SHEET, buf.Base(), buf.TellPut() );
}


//-----------------------------------------------------------------------------
// Does the dirty deed and generates a VTF file
//-----------------------------------------------------------------------------
bool ProcessFiles( const char *pFullNameWithoutExtension, 
				  const char *pOutputDir, const char *pBaseName, 
				  bool isCubeMap, VTexConfigInfo_t &info )
{
	// force clamps/clampt for cube maps
	if( isCubeMap )
	{
		info.m_nFlags |= TEXTUREFLAGS_ENVMAP;
		info.m_nFlags |= TEXTUREFLAGS_CLAMPS;
		info.m_nFlags |= TEXTUREFLAGS_CLAMPT;
	}

	// Create the texture we're gonna store out
	SmartIVtfTexture pVTFTexture( CreateVTFTexture() );

	int iSkyboxFace = 0;
	char fullNameTemp[512];
	if ( info.m_bSkyBox )
	{
		Q_strncpy( fullNameTemp, pFullNameWithoutExtension, sizeof( fullNameTemp ) );
		pFullNameWithoutExtension = fullNameTemp;
		PreprocessSkyBox( fullNameTemp, &iSkyboxFace );
	}

	// Load the source images into the texture
	bool bGenerateSpheremaps = false;
	bool bLoadedSourceImages = LoadSourceImages( pVTFTexture.Get(), 
		pFullNameWithoutExtension, &bGenerateSpheremaps, info );
	if ( !bLoadedSourceImages )
	{
		VTexError( "Can't load source images for \"%s\"\n", pFullNameWithoutExtension );
		return false;
	}

	// Attach a sheet file if present
	AttachShtFile( pFullNameWithoutExtension, pVTFTexture.Get(), &info.m_uiInputHash );

	// No more file loads, finalize the sources hash
	CRC32_Final( &info.m_uiInputHash );
	pVTFTexture->SetResourceData( VTexConfigInfo_t::VTF_INPUTSRC_CRC, &info.m_uiInputHash, sizeof( info.m_uiInputHash ) );
	CRC32_t crcWritten = info.m_uiInputHash;

	// Name of the destination file
	char dstFileName[1024];
	sprintf( dstFileName, "%s/%s%s.vtf", pOutputDir, pBaseName, ( ( eModePFM == g_eMode ) && isCubeMap ) ? ".hdr" : "" );

	// Now if we are only validating the CRC
	if( CommandLine()->FindParm( "-crcvalidate" ) )
	{
		CUtlBuffer bufFile;
		bool bLoad = LoadFile( dstFileName, bufFile, false, NULL );
		if ( !bLoad )
		{
			fprintf( stderr, "LOAD ERROR: %s\n", dstFileName );
			return false;
		}

		SmartIVtfTexture spExistingVtf( CreateVTFTexture() );
		bLoad = spExistingVtf->Unserialize( bufFile );
		if ( !bLoad )
		{
			fprintf( stderr, "UNSERIALIZE ERROR: %s\n", dstFileName );
			return false;
		}

		size_t numDataBytes;
		void *pCrcData = spExistingVtf->GetResourceData( VTexConfigInfo_t::VTF_INPUTSRC_CRC, &numDataBytes );
		if ( !pCrcData || numDataBytes != sizeof( CRC32_t ) )
		{
			fprintf( stderr, "OLD TEXTURE FORMAT: %s\n", dstFileName );
			return false;
		}

		CRC32_t crcFile = * reinterpret_cast< CRC32_t const * >( pCrcData );
		if ( crcFile != crcWritten )
		{
			fprintf( stderr, "CRC MISMATCH: %s\n", dstFileName );
			return false;
		}

		fprintf( stderr, "OK: %s\n", dstFileName );
		return true;
	}

	// Now if we are not forcing the CRC
	if( !CommandLine()->FindParm( "-crcforce" ) )
	{
		CUtlBuffer bufFile;
		if ( LoadFile( dstFileName, bufFile, false, NULL ) )
		{
			SmartIVtfTexture spExistingVtf( CreateVTFTexture() );
			if ( spExistingVtf->Unserialize( bufFile ) )
			{
				size_t numDataBytes;
				void *pCrcData = spExistingVtf->GetResourceData( VTexConfigInfo_t::VTF_INPUTSRC_CRC, &numDataBytes );
				if ( pCrcData && numDataBytes == sizeof( CRC32_t ) )
				{
					CRC32_t crcFile = * reinterpret_cast< CRC32_t const * >( pCrcData );
					if ( crcFile == crcWritten )
					{
						if( !g_Quiet )
							printf( "SUCCESS: %s is up-to-date\n", dstFileName );

						if( !CommandLine()->FindParm( "-crcforce" ) )
							return true;
					}
				}
			}
		}
	}

	// Bumpmap scale..
	pVTFTexture->SetBumpScale( info.m_flBumpScale );

	// Alphatest threshhold
	pVTFTexture->SetAlphaTestThreshholds( info.m_flAlphaThreshhold, info.m_flAlphaHiFreqThreshhold );

	// Set texture lod data
	SetTextureLodData( pVTFTexture.Get(), info );

	// Get the texture all internally consistent and happy
	bool bAllowFixCubemapOrientation = !info.m_bSkyBox;	// Don't let it rotate our pseudo-cubemap faces around if it's a skybox.
	pVTFTexture->SetPostProcessingSettings( &info.m_vtfProcOptions );
	pVTFTexture->PostProcess( bGenerateSpheremaps, info.m_LookDir, bAllowFixCubemapOrientation );

	// Compute the preferred image format
	ImageFormat vtfImageFormat = ComputeDesiredImageFormat( pVTFTexture.Get(), info );

	// Set up the low-res image
	if (pVTFTexture->IsCubeMap())
	{
		// "Stage 1" of matching cubemap borders. Sometimes, it has to store off the original image.
		pVTFTexture->MatchCubeMapBorders( 1, vtfImageFormat, info.m_bSkyBox );
	}
	else
	{
		CreateLowResImage( pVTFTexture.Get() );
	}

	// Convert to the final format
	pVTFTexture->ConvertImageFormat( vtfImageFormat, info.m_bNormalToDuDv );

	// Stage 2 of matching cubemap borders.
	pVTFTexture->MatchCubeMapBorders( 2, vtfImageFormat, info.m_bSkyBox );

	if ( info.m_bSkyBox )
	{
		pVTFTexture.Assign( PostProcessSkyBox( pVTFTexture.Get(), iSkyboxFace ) );
	}

	if ( info.IsSettings0Valid() )
	{
		pVTFTexture->SetResourceData( VTF_RSRC_TEXTURE_SETTINGS_EX, &info.m_exSettings0, sizeof( info.m_exSettings0 ) );
	}

	// Write it!
	if ( g_CreateDir == true )
		MakeDirHier( pOutputDir ); //It'll create it if it doesn't exist.

	// Make sure the CRC hasn't been modified since finalized
	Assert( crcWritten == info.m_uiInputHash );

	CUtlBuffer outputBuf;
	if (!pVTFTexture->Serialize( outputBuf ))
	{
		VTexError( "ERROR: \"%s\": Unable to serialize the VTF file!\n", dstFileName );
	}

	{
		CP4AutoEditAddFile autop4( dstFileName );
		FILE *fp = fopen( dstFileName, "wb" );
		if( !fp )
		{
			VTexError( "Can't open: %s\n", dstFileName );
		}
		fwrite( outputBuf.Base(), 1, outputBuf.TellPut(), fp );
		fclose( fp );
	}

	printf("SUCCESS: Vtf file created\n");
	return true;
}

const char *GetPossiblyQuotedWord( const char *pInBuf, char *pOutbuf )
{
	pInBuf += strspn( pInBuf, " \t" );						// skip whitespace

	const char *pWordEnd;
	bool bQuote = false;
	if (pInBuf[0]=='"')
	{
		pInBuf++;
		pWordEnd=strchr(pInBuf,'"');
		bQuote = true;
	}
	else
	{
		pWordEnd=strchr(pInBuf,' ');
		if (! pWordEnd )
			pWordEnd = strchr(pInBuf,'\t' );
		if (! pWordEnd )
			pWordEnd = pInBuf+strlen(pInBuf);
	}
	if ((! pWordEnd ) || (pWordEnd == pInBuf ) )
		return NULL;										// no word found
	memcpy( pOutbuf, pInBuf, pWordEnd-pInBuf );
	pOutbuf[pWordEnd-pInBuf]=0;

	pInBuf = pWordEnd;
	if ( bQuote )
		pInBuf++;
	return pInBuf;
}

// GetKeyValueFromBuffer:
//		fills in "key" and "val" respectively and returns "true" if succeeds.
//		returns false if:
//			a) end-of-buffer is reached (then "val" is empty)
//			b) error occurs (then "val" is the error message)
//
static bool GetKeyValueFromBuffer( CUtlBuffer &buffer, char *key, char *val )
{
	char buf[2048];

	while( buffer.GetBytesRemaining() )
	{
		buffer.GetLine( buf, sizeof( buf ) );

		// Scanning algorithm
		char *pComment = strpbrk( buf, "#\n\r" );
		if ( pComment )
			*pComment = 0;

		pComment = strstr( buf, "//" );
		if ( pComment)
			*pComment = 0;

		const char *scan = buf;
		scan=GetPossiblyQuotedWord( scan, key );
		if ( scan )
		{
			scan=GetPossiblyQuotedWord( scan, val );
			if ( scan )
				return true;
			else
			{
				sprintf( val, "parameter %s has no value", key );
				return false;
			}
		}
	}

	val[0] = 0;
	return false;
}


//-----------------------------------------------------------------------------
// Loads the .psd file or .txt file associated with the .tga and gets out various data
//-----------------------------------------------------------------------------
static bool LoadConfigFile( const char *pFileBaseName, VTexConfigInfo_t &info, bool *isCubeMap )
{
	// Tries to load .txt, then .psd

	int lenBaseName = strlen( pFileBaseName );
	char *pFileName = ( char * )stackalloc( lenBaseName + strlen( ".tga" ) + 1 );
	strcpy( pFileName, pFileBaseName );
	strcat( pFileName, ".tga" );

	bool bOK = false;

	info.m_LookDir = LOOK_DOWN_Z;

	
	// Try TGA file with config
	memcpy( pFileName + lenBaseName, ".tga", 4 );
	if ( !bOK && !g_bNoTga && ( 00 == access( pFileName, 00 ) ) ) // TGA file exists
	{
		g_eMode = eModeTGA;

		memcpy( pFileName + lenBaseName, ".txt", 4 );
		CUtlBuffer bufFile( 0, 0, CUtlBuffer::TEXT_BUFFER );
		bOK = LoadFile( pFileName, bufFile, false, &info.m_uiInputHash );
		if ( bOK )
		{
			printf("config file %s\n",pFileName);

			{
				char key[2048];
				char val[2048];
				while( GetKeyValueFromBuffer( bufFile, key, val ) )
				{
					info.ParseOptionKey( key, val );
				}

				if ( val[0] )
				{
					VTexError( "%s: %s\n", pFileName, val );
					return false;
				}
			}
		}
		else
		{
			memcpy( pFileName + lenBaseName, ".tga", 4 );
			printf("no config file for %s\n",pFileName);
			bOK = true;
		}
	}
	memcpy( pFileName + lenBaseName, ".tga", 4 );
	if ( g_bNoTga && ( 00 == access( pFileName, 00 ) ) )
	{
		printf( "Warning: -notga disables \"%s\"\n", pFileName );
	}

	// PSD file attempt
	memcpy( pFileName + lenBaseName, ".psd", 4 );
	if ( !bOK && !g_bNoPsd ) // If PSD mode was not disabled
	{
		g_eMode = eModePSD;

		CUtlBuffer bufFile;
		bOK = LoadFile( pFileName, bufFile, false, &info.m_uiInputHash );
		if ( bOK )
		{
			printf("config file %s\n", pFileName);
			bOK = IsPSDFile( bufFile );
			if ( !bOK )
			{
				VTexError( "%s is not a valid PSD file!\n", pFileName );
				return false;
			}

			PSDImageResources imgres = PSDGetImageResources( bufFile );
			PSDResFileInfo resFileInfo( imgres.FindElement( PSDImageResources::eResFileInfo ) );
			PSDResFileInfo::ResFileInfoElement descr = resFileInfo.FindElement( PSDResFileInfo::eDescription );
			if ( descr.m_pvData )
			{
				CUtlBuffer bufDescr( 0, 0, CUtlBuffer::TEXT_BUFFER );
				bufDescr.EnsureCapacity( descr.m_numBytes );
				bufDescr.Put( descr.m_pvData, descr.m_numBytes );

				{
					char key[2048];
					char val[2048];
					while( GetKeyValueFromBuffer( bufDescr, key, val ) )
					{
						info.ParseOptionKey( key, val );
					}

					if ( val[0] )
					{
						VTexError( "%s: %s\n", pFileName, val );
						return false;
					}
				}
			}
		}
	}
	else if ( 00 == access( pFileName, 00 ) )
	{
		if ( !bOK )
			printf( "Warning: -nopsd disables \"%s\"\n", pFileName );
		else
			printf( "Warning: psd file \"%s\" exists, but not used, delete tga and txt files to use psd file directly\n", pFileName );
	}

	// Try TXT file as config again for TGA cubemap / PFM
	memcpy( pFileName + lenBaseName, ".txt", 4 );
	if ( !bOK )
	{
		g_eMode = eModeTGA;

		CUtlBuffer bufFile( 0, 0, CUtlBuffer::TEXT_BUFFER );
		bOK = LoadFile( pFileName, bufFile, false, &info.m_uiInputHash );
		if ( bOK )
		{
			printf("config file %s\n",pFileName);

			{
				char key[2048];
				char val[2048];
				while( GetKeyValueFromBuffer( bufFile, key, val ) )
				{
					info.ParseOptionKey( key, val );
				}

				if ( val[0] )
				{
					VTexError( "%s: %s\n", pFileName, val );
					return false;
				}
			}

			if ( g_eMode == eModePFM )
			{
				if ( g_bUsedAsLaunchableDLL && !( info.m_vtfProcOptions.flags0 & VtfProcessingOptions::OPT_NOCOMPRESS ) )
				{
					info.m_nFlags |= TEXTUREFLAGS_NOMIP;
				}
			}
		}
	}

	if ( !bOK )
	{
		VTexError( "\"%s\" does not specify valid %s%sPFM+TXT files!\n",
			pFileBaseName,
			g_bNoPsd ? "" : "PSD or ",
			g_bNoTga ? "" : "TGA or "
			);
		return false;
	}

	if ( info.m_bIsCubeMap )
		*isCubeMap = true;

	if( ( info.m_bNormalToDuDv || ( info.m_vtfProcOptions.flags0 & VtfProcessingOptions::OPT_NORMAL_DUDV ) ) &&
		!( info.m_vtfProcOptions.flags0 & VtfProcessingOptions::OPT_PREMULT_COLOR_ONEOVERMIP ) )
	{
		printf( "Implicitly setting premultcolorbyoneovermiplevel since you are generating a dudv map\n" );
		info.m_vtfProcOptions.flags0 |= VtfProcessingOptions::OPT_PREMULT_COLOR_ONEOVERMIP;
	}

	if( ( info.m_bNormalToDuDv || ( info.m_vtfProcOptions.flags0 & VtfProcessingOptions::OPT_NORMAL_DUDV ) ) )
	{
		printf( "Implicitly setting trilinear since you are generating a dudv map\n" );
		info.m_nFlags |= TEXTUREFLAGS_TRILINEAR;
	}

	if( Q_stristr( pFileBaseName, "_normal" ) )
	{
		if( !( info.m_nFlags & TEXTUREFLAGS_NORMAL ) )
		{
			if( !g_Quiet )
			{
				fprintf( stderr, "implicitly setting:\n" );
				fprintf( stderr, "\t\"normal\" \"1\"\n" );
				fprintf( stderr, "since filename ends in \"_normal\"\n" );
			}
			info.m_nFlags |= TEXTUREFLAGS_NORMAL;
		}
	}

	if( Q_stristr( pFileBaseName, "ssbump" ) )
	{
		if( !( info.m_nFlags & TEXTUREFLAGS_SSBUMP ) )
		{
			if( !g_Quiet )
			{
				fprintf( stderr, "implicitly setting:\n" );
				fprintf( stderr, "\t\"ssbump\" \"1\"\n" );
				fprintf( stderr, "since filename includes \"ssbump\"\n" );
			}
			info.m_nFlags |= TEXTUREFLAGS_SSBUMP;
		}
	}

	if( Q_stristr( pFileBaseName, "_dudv" ) )
	{
		if( !info.m_bNormalToDuDv && !info.m_bDuDv )
		{
			if( !g_Quiet )
			{
				fprintf( stderr, "Implicitly setting:\n" );
				fprintf( stderr, "\t\"dudv\" \"1\"\n" );
				fprintf( stderr, "since filename ends in \"_dudv\"\n" );
				fprintf( stderr, "If you are trying to convert from a normal map to a dudv map, put \"normaltodudv\" \"1\" in description.\n" );
			}
			info.m_bDuDv = true;
		}
	}

	// turn off nice filtering if we are a cube map (takes too long with buildcubemaps) or
	// if we are a normal map (looks like terd.)
	if( ( info.m_nFlags & TEXTUREFLAGS_NORMAL ) || *isCubeMap )
	{
		if (info.m_vtfProcOptions.flags0 & VtfProcessingOptions::OPT_FILTER_NICE )
		{
			if ( !g_Quiet )
			{
				fprintf( stderr, "implicity disabling nice filtering\n" );
			}
		}
		info.m_vtfProcOptions.flags0 &= ~VtfProcessingOptions::OPT_FILTER_NICE;
	}

	return true;
}

void Usage( void )
{
	VTexError( 
		"Usage: vtex [-outdir dir] [-quiet] [-nopause] [-mkdir] [-shader ShaderName] [-vmtparam Param Value] tex1.txt tex2.txt . . .\n"
		"-quiet            : don't print anything out, don't pause for input\n"
		"-warningsaserrors : treat warnings as errors\n"
		"-nopause          : don't pause for input\n"
		"-nomkdir          : don't create destination folder if it doesn't exist\n"
		"-vmtparam         : adds parameter and value to the .vmt file\n"
		"-outdir <dir>     : write output to the specified dir regardless of source filename and vproject\n"
		"-deducepath       : deduce path of sources by target file names\n"
		"-quickconvert     : use with \"-nop4 -dontusegamedir -quickconvert\" to upgrade old .vmt files\n"
		"-crcvalidate      : validate .vmt against the sources\n"
		"-crcforce         : generate a new .vmt even if sources crc matches\n"
		"\teg: -vmtparam $ignorez 1 -vmtparam $translucent 1\n"
		"Note that you can use wildcards and that you can also chain them\n"
		"e.g. materialsrc/monster1/*.tga materialsrc/monster2/*.tga\n" );
}

bool GetOutputDir( const char *inputName, char *outputDir )
{
	if ( g_ForcedOutputDir[0] )
	{
		strcpy( outputDir, g_ForcedOutputDir );
	}
	else
	{
		// Is inputName a relative path?
		char buf[MAX_PATH];
		Q_MakeAbsolutePath( buf, sizeof( buf ), inputName, NULL );
		Q_FixSlashes( buf );

		char szSearch[MAX_PATH] = { 0 };
		V_snprintf( szSearch, sizeof( szSearch ), "materialsrc%c", CORRECT_PATH_SEPARATOR );
		const char *pTmp = Q_stristr( buf, szSearch );
		if( !pTmp )
		{
			return false;
		}
		pTmp += strlen( "materialsrc/" );
		strcpy( outputDir, gamedir );
		strcat( outputDir, "materials/" );
		strcat( outputDir, pTmp );
		Q_StripFilename( outputDir );
	}
	if( !g_Quiet )
	{
		printf( "output directory: %s\n", outputDir );
	}
	return true;
}

bool IsCube( const char *inputName )
{
	char tgaName[MAX_PATH];
	// Do Strcmp for ".hdr" to make sure we aren't ripping too much stuff off.
	Q_StripExtension( inputName, tgaName, MAX_PATH );
	const char *pInputExtension = inputName + Q_strlen( tgaName );
	Q_strncat( tgaName, "rt", MAX_PATH, COPY_ALL_CHARACTERS );
	Q_strncat( tgaName, pInputExtension, MAX_PATH, COPY_ALL_CHARACTERS );
	Q_strncat( tgaName, GetSourceExtension(), MAX_PATH, COPY_ALL_CHARACTERS );
	struct	_stat buf;
	if( _stat( tgaName, &buf ) != -1 )
	{
		return true;
	}
	else
	{
		return false;
	}
}

#ifdef WIN32
int Find_Files( WIN32_FIND_DATA &wfd, HANDLE &hResult, const char *basedir, const char *extension )
{
	char	filename[MAX_PATH] = {0};

	BOOL bMoreFiles = FindNextFile( hResult, &wfd);

	if ( bMoreFiles )
	{
		// Skip . and ..
		if ( wfd.cFileName[0] == '.' )
		{
			return FF_TRYAGAIN;
		}

		// If it's a subdirectory, just recurse down it
		if ( (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) )
		{
			char	subdir[MAX_PATH];
			sprintf( subdir, "%s\\%s", basedir, wfd.cFileName );

			// Recurse
			Find_Files( wfd, hResult, basedir, extension );
			return FF_TRYAGAIN;
		}

		// Check that it's a tga
		//

		char fname[_MAX_FNAME] = {0};
		char ext[_MAX_EXT] = {0};

		_splitpath( wfd.cFileName, NULL, NULL, fname, ext );

		// Not the type we want.
		if ( stricmp( ext, extension ) )
			return FF_DONTPROCESS;

		// Check for .vmt
		sprintf( filename, "%s\\%s.vmt", basedir, fname );
		// Exists, so don't overwrite it
		if ( access( filename, 0 ) != -1 )
			return FF_TRYAGAIN;

		char texturename[ _MAX_PATH ] = {0};
		char *p = ( char * )basedir;

		// Skip over the base path to get a material system relative path
		// p += strlen( wfd.cFileName ) + 1;

		// Construct texture name
		sprintf( texturename, "%s\\%s", p, fname );

		// Convert all to lower case
		strlwr( texturename );
		strlwr( filename );
	}

	return bMoreFiles;
}
#endif

bool Process_File( char *pInputBaseName, int maxlen )
{
	char outputDir[1024];
	Q_FixSlashes( pInputBaseName, '/' );
	Q_StripExtension( pInputBaseName, pInputBaseName, maxlen );

	if ( CommandLine()->FindParm( "-deducepath" ) )
	{
		strcpy( outputDir, pInputBaseName );

		// If it is not a full path, try making it a full path
		if ( pInputBaseName[0] != '/' &&
			 pInputBaseName[1] != ':' )
		{
			// Convert to full path
			getcwd( outputDir, sizeof( outputDir ) );
			Q_FixSlashes( outputDir, '/' );
			Q_strncat( outputDir, "/", sizeof( outputDir ) );
			Q_strncat( outputDir, pInputBaseName, sizeof( outputDir ) );
		}

		// If it is pointing inside "/materials/" make it go for "/materialsrc/"
		char *pGame = strstr( outputDir, "/game/" );
		char *pMaterials = strstr( outputDir, "/materials/" );
		if ( pGame && pMaterials && ( pGame < pMaterials ) )
		{
			// "u:/data/game/tf/materials/"  ->  "u:/data/content/tf/materialsrc/"
			int numExtraBytes = strlen( "/content/.../materialsrc/" ) - strlen( "/game/.../materials/" );
			int numConvertBytes = pMaterials + strlen( "/materials/" ) - outputDir;
			memmove( outputDir + numConvertBytes + numExtraBytes, outputDir + numConvertBytes, strlen( outputDir ) - numConvertBytes + 1 );
			
			int numMidBytes = pMaterials - pGame - strlen( "/game" );
			memmove( pGame + strlen( "/content" ), pGame + strlen( "/game" ), numMidBytes );

			memmove( pGame, "/content", strlen( "/content" ) );
			memmove( pGame + strlen( "/content" ) + numMidBytes, "/materialsrc/", strlen( "/materialsrc/" ) );
		}

		Q_strncpy( pInputBaseName, outputDir, maxlen );
	}

	if( !g_Quiet )
	{
		printf( "input file: %s\n", pInputBaseName );
	}

	if(g_UseGameDir && !GetOutputDir( pInputBaseName, outputDir ) )
	{
		VTexError( "Problem figuring out outputdir for %s\n", pInputBaseName );
		return FALSE;
	}
	else if (!g_UseGameDir)
	{
		strcpy(outputDir, pInputBaseName);
		Q_StripFilename(outputDir);
	}

	// Usage:
	//			vtex -nop4 -dontusegamedir -quickconvert u:\data\game\tf\texture.vtf
	// Will read the old texture format and write the new texture format
	//
	if ( CommandLine()->FindParm( "-quickconvert" ) )
	{
		printf( "Quick convert of '%s'...\n", pInputBaseName );

		char chFileNameConvert[ 512 ];
		sprintf( chFileNameConvert, "%s.vtf", pInputBaseName );

		IVTFTexture *pVtf = CreateVTFTexture();
		CUtlBuffer bufFile;
		LoadFile( chFileNameConvert, bufFile, true, NULL );
		bool bRes = pVtf->Unserialize( bufFile );
		if ( !bRes )
			VTexError( "Failed to read '%s'!\n", chFileNameConvert );

		// Determine the CRC if it was there
		// CRC32_t uiDataHash = 0;
		// CRC32_t *puiDataHash = &uiDataHash;
		// Assert( sizeof( uiDataHash ) == sizeof( int ) );
		// if ( !pVtf->GetResourceData( VTexConfigInfo_t::VTF_INPUTSRC_CRC, ... ) )

		AttachShtFile( pInputBaseName, pVtf, NULL );

		// Update the CRC
		// if ( puiDataHash )
		// {
		//	pVtf->InitResourceDataSection( VTexConfigInfo_t::VTF_INPUTSRC_CRC, *puiDataHash );
		// }
		// Remove the CRC when quick-converting
		pVtf->SetResourceData( VTexConfigInfo_t::VTF_INPUTSRC_CRC, NULL, 0 );

		bufFile.Clear();
		bRes = pVtf->Serialize( bufFile );
		if ( !bRes )
			VTexError( "Failed to write '%s'!\n", chFileNameConvert );

		DestroyVTFTexture( pVtf );

		if ( FILE *fw = fopen( chFileNameConvert, "wb" ) )
		{
			fwrite( bufFile.Base(), 1, bufFile.TellPut(), fw );
			fclose( fw );
		}
		else
			VTexError( "Failed to open '%s' for writing!\n", chFileNameConvert );

		printf( "... succeeded.\n" );

		return TRUE;
	}

	VTexConfigInfo_t info;
	bool isCubeMap = false;
	if ( !LoadConfigFile( pInputBaseName, info, &isCubeMap ) )
		return FALSE;

	if( !isCubeMap )
	{
		isCubeMap = IsCube( pInputBaseName );
	}

	if( ( info.m_nStartFrame == -1 && info.m_nEndFrame != -1 ) ||
		( info.m_nStartFrame != -1 && info.m_nEndFrame == -1 ) )
	{
		VTexError( "%s: If you use startframe, you must use endframe, and vice versa.\n", pInputBaseName );
		return FALSE;
	}

	const char *pBaseName = &pInputBaseName[strlen( pInputBaseName ) - 1];
	while( (pBaseName >= pInputBaseName) && *pBaseName != '\\' && *pBaseName != '/' )
	{
		pBaseName--;
	}
	pBaseName++;

	bool bProcessedFilesOK = ProcessFiles( pInputBaseName, outputDir, pBaseName, isCubeMap, info );
	if ( !bProcessedFilesOK )
		return FALSE;

	// create vmts if necessary
	if( g_ShaderName )
	{
		char buf[1024];
		sprintf( buf, "%s/%s.vmt", outputDir, pBaseName );
		const char *tmp = Q_stristr( outputDir, "materials" );
		FILE *fp;
		if( tmp )
		{
			// check if the file already exists.
			fp = fopen( buf, "r" );
			if( fp )
			{
				if ( !g_Quiet )
					fprintf( stderr, "vmt file \"%s\" already exists\n", buf );

				fclose( fp );
			}
			else
			{
				fp = fopen( buf, "w" );
				if( fp )
				{
					if ( !g_Quiet )
						fprintf( stderr, "Creating vmt file: %s/%s\n", tmp, pBaseName );
					tmp += strlen( "materials/" );
					fprintf( fp, "\"%s\"\n", g_ShaderName );
					fprintf( fp, "{\n" );
					fprintf( fp, "\t\"$baseTexture\" \"%s/%s\"\n", tmp, pBaseName );

					int i;
					for( i=0;i<g_NumVMTParams;i++ )
					{
						fprintf( fp, "\t\"%s\" \"%s\"\n", g_VMTParams[i].m_szParam, g_VMTParams[i].m_szValue );
					}

					fprintf( fp, "}\n" );
					fclose( fp );

					CP4AutoAddFile autop4( buf );
				}
				else
				{
					VTexWarning( "Couldn't open \"%s\" for writing\n", buf );
				}
			}

		}
		else
		{
			VTexWarning( "Couldn't find \"materials/\" in output path\n", buf );
		}
	}

	return TRUE;
}

static SpewRetval_t VTexOutputFunc( SpewType_t spewType, char const *pMsg )
{
	printf( "%s", pMsg );
	if (spewType == SPEW_ERROR)
	{
		Pause();
		return SPEW_ABORT;
	}
	return (spewType == SPEW_ASSERT) ? SPEW_DEBUGGER : SPEW_CONTINUE; 
}


class CVTex : public CTier2AppSystem< IVTex >, public ILaunchableDLL
{
public:
	int VTex( int argc, char **argv );

	// ILaunchableDLL, used by vtex.exe.
	virtual int main( int argc, char **argv )
	{
		g_bUsedAsLaunchableDLL = true;

		// Being used as a launchable DLL, we don't want to blow away the host app's command line
		CUtlString strOrigCmdLine( CommandLine()->GetCmdLine() );

		// Run the vtex logic
		int iResult = VTex( argc, argv );

		// Restore command line
		CommandLine()->CreateCmdLine( strOrigCmdLine.Get() );

		return iResult;
	}

	virtual int VTex( CreateInterfaceFn fsFactory, const char *pGameDir, int argc, char **argv )
	{
		g_pFileSystem = g_pFullFileSystem = (IFileSystem*)fsFactory( FILESYSTEM_INTERFACE_VERSION, NULL );
		if ( !g_pFileSystem )
		{
			Error( "IVTex3::VTex - fsFactory can't get '%s' interface.", FILESYSTEM_INTERFACE_VERSION );
			return 0;
		}

		Q_strncpy( gamedir, pGameDir, sizeof( gamedir ) );
		Q_AppendSlash( gamedir, sizeof( gamedir ) );

		// When being used embedded in a host app, we don't want to blow away the host app's command line
		CUtlString strOrigCmdLine( CommandLine()->GetCmdLine() );

		int iResult = VTex( argc, argv );

		// Restore command line
		CommandLine()->CreateCmdLine( strOrigCmdLine.Get() );

		return iResult;
	}
};

static class CSuggestGameDirHelper
{
public:
	static bool SuggestFn( CFSSteamSetupInfo const *pFsSteamSetupInfo, char *pchPathBuffer, int nBufferLength, bool *pbBubbleDirectories );
	bool MySuggestFn( CFSSteamSetupInfo const *pFsSteamSetupInfo, char *pchPathBuffer, int nBufferLength, bool *pbBubbleDirectories );

public:
	CSuggestGameDirHelper() : m_pszInputFiles( NULL ), m_numInputFiles( 0 ) {}

public:
	char const * const *m_pszInputFiles;
	size_t m_numInputFiles;
} g_suggestGameDirHelper;

bool CSuggestGameDirHelper::SuggestFn( CFSSteamSetupInfo const *pFsSteamSetupInfo, char *pchPathBuffer, int nBufferLength, bool *pbBubbleDirectories )
{
	return g_suggestGameDirHelper.MySuggestFn( pFsSteamSetupInfo, pchPathBuffer, nBufferLength, pbBubbleDirectories );
}

bool CSuggestGameDirHelper::MySuggestFn( CFSSteamSetupInfo const *pFsSteamSetupInfo, char *pchPathBuffer, int nBufferLength, bool *pbBubbleDirectories )
{
	if ( !m_numInputFiles || !m_pszInputFiles )
		return false;

	if ( pbBubbleDirectories )
		*pbBubbleDirectories = true;

	for ( int k = 0; k < m_numInputFiles; ++ k )
	{
		Q_MakeAbsolutePath( pchPathBuffer, nBufferLength, m_pszInputFiles[ k ] );
		return true;
	}

	return false;
}

int CVTex::VTex( int argc, char **argv )
{
	CommandLine()->CreateCmdLine( argc, argv );

	if ( g_bUsedAsLaunchableDLL )
	{
		SpewOutputFunc( VTexOutputFunc );
	}

	MathLib_Init(  2.2f, 2.2f, 0.0f, 1.0f, false, false, false, false );
	if( argc < 2 )
	{
		Usage();
		return -1;
	}

	g_UseGameDir = true; // make sure this is initialized to true.
	const char *p4ChangelistLabel = "VTex Auto Checkout";
	bool bCreatedFilesystem = false;

	int i;
	i = 1;
	while( i < argc )
	{
		if( stricmp( argv[i], "-quiet" ) == 0 )
		{
			i++;
			g_Quiet = true;
			g_NoPause = true; // no point in pausing if we aren't going to print anything out.
		}
		else if( stricmp( argv[i], "-nopause" ) == 0 )
		{
			i++;
			g_NoPause = true;
		}
		else if ( stricmp( argv[i], "-WarningsAsErrors" ) == 0 )
		{
			i++;
			g_bWarningsAsErrors = true;
		}
		else if ( stricmp( argv[i], "-UseStandardError" ) == 0 )
		{
			i++;
			g_bUseStandardError = true;
		}
		else if ( stricmp( argv[i], "-nopsd" ) == 0 ) 
		{
			i++;
			g_bNoPsd = true;
		}
		else if ( stricmp( argv[i], "-notga" ) == 0 ) 
		{
			i++;
			g_bNoTga = true;
		}
		else if ( stricmp( argv[i], "-nomkdir" ) == 0 ) 
		{
			i++;
			g_CreateDir = false;
		}
		else if ( stricmp( argv[i], "-mkdir" ) == 0 ) 
		{
			i++;
			g_CreateDir = true;
		}
		else if ( stricmp( argv[i], "-game" ) == 0 )
		{
			i += 2;
		}
		else if ( stricmp( argv[i], "-outdir" ) == 0 )
		{
			V_strcpy_safe( g_ForcedOutputDir, argv[i+1] );
			i += 2;
		}
		else if ( stricmp( argv[i], "-p4changelistlabel" ) == 0 )
		{
			p4ChangelistLabel = argv[i+1];
			i += 2;
		}
		else if ( stricmp( argv[i], "-p4skipchangelistlabel" ) == 0 )
		{
			p4ChangelistLabel = NULL;
			i++;
		}
		else if ( stricmp( argv[i], "-dontusegamedir" ) == 0)
		{
			++i;
			g_UseGameDir = false;
		}
		else if( stricmp( argv[i], "-shader" ) == 0 )
		{
			i++;
			if( i < argc )
			{
				g_ShaderName = argv[i];
				i++;
			}
		}
		else if( stricmp( argv[i], "-vproject" ) == 0 )
		{
			// skip this one. . we dont' use it internally.
			i += 2;
		}
		else if( stricmp( argv[i], "-allowdebug" ) == 0 )
		{
			// skip this one. . we dont' use it internally.
			i++;
		}
		else if( stricmp( argv[i], "-vmtparam" ) == 0 )
		{
			if( g_NumVMTParams < MAX_VMT_PARAMS )
			{
				i++;
				if( i < argc - 1 )
				{
					g_VMTParams[g_NumVMTParams].m_szParam = argv[i];
					i++;

					if( i < argc - 1 )
					{
						g_VMTParams[g_NumVMTParams].m_szValue = argv[i];
						i++;
					}
					else
					{
						g_VMTParams[g_NumVMTParams].m_szValue = "";
					}

					if( !g_Quiet )
					{
						fprintf( stderr, "Adding .vmt parameter: \"%s\"\t\"%s\"\n", 
							g_VMTParams[g_NumVMTParams].m_szParam,
							g_VMTParams[g_NumVMTParams].m_szValue );
					}

					g_NumVMTParams++;
				}
			}
			else
			{
				fprintf( stderr, "Exceeded max number of vmt parameters, extra ignored ( max %d )\n", MAX_VMT_PARAMS );
			}
		}
		else if( stricmp( argv[i], "-nop4" ) == 0 )
		{
			// Just here to signify that -nop4 is a valid flag
			++ i;
		}
		else if( stricmp( argv[i], "-deducepath" ) == 0 )
		{
			// Just here to signify that -deducepath is a valid flag
			++ i;
		}
		else if( stricmp( argv[i], "-quickconvert" ) == 0 )
		{
			// Just here to signify that -quickconvert is a valid flag
			++ i;
		}
		else if( stricmp( argv[i], "-crcvalidate" ) == 0 )
		{
			// Just here to signify that -crcvalidate is a valid flag
			++ i;
		}
		else if( stricmp( argv[i], "-crcforce" ) == 0 )
		{
			// Just here to signify that -crcforce is a valid flag
			++ i;
		}
		else if( stricmp( argv[i], "-p4skip" ) == 0 )
		{
			// Just here to signify that -p4skip is a valid flag
			++ i;
		}
		else
		{
			break;
		}
	}

	// Set the suggest game info directory helper
	g_suggestGameDirHelper.m_pszInputFiles = argv + i;
	g_suggestGameDirHelper.m_numInputFiles = argc - i;
	SetSuggestGameInfoDirFn( CSuggestGameDirHelper::SuggestFn );

	// g_pFileSystem may have been inherited with -inherit_filesystem.
	if (g_UseGameDir && !g_pFileSystem)
	{
		FileSystem_Init( argv[i] );
		bCreatedFilesystem = true;

		Q_FixSlashes( gamedir, '/' );
	}

	if ( !CommandLine()->FindParm( "-p4skip" ) )
	{
		// Initialize P4
		bool bP4DLLExists = false;
		if ( g_pFullFileSystem )
		{
			bP4DLLExists = g_pFullFileSystem->FileExists( "p4lib.dll", "EXECUTABLE_PATH" );
		}

		if ( g_bUsedAsLaunchableDLL && !CommandLine()->FindParm( "-nop4" ) && bP4DLLExists )
		{
			const char *pModuleName = "p4lib.dll";
			CSysModule *pModule = Sys_LoadModule( pModuleName );
			if ( !pModule )
			{
				printf( "Can't load %s.\n", pModuleName );
				return -1;
			}
			CreateInterfaceFn fn = Sys_GetFactory( pModule );
			if ( !fn )
			{
				printf( "Can't get factory from %s.\n", pModuleName );
				Sys_UnloadModule( pModule );
				return -1;
			}
			p4 = (IP4 *)fn( P4_INTERFACE_VERSION, NULL );
			if ( !p4 )
			{
				printf( "Can't get IP4 interface from %s, proceeding with -nop4.\n", pModuleName );
				g_p4factory->SetDummyMode( true );
			}
			else
			{
				p4->Connect( FileSystem_GetFactory() );
				p4->Init();
			}
		}
		else
		{
			g_p4factory->SetDummyMode( true );
		}

		// Setup p4 factory
		if ( p4ChangelistLabel && p4ChangelistLabel[0] != '\000' )
		{
			// Set the named changelist
			g_p4factory->SetOpenFileChangeList( p4ChangelistLabel );
		}
	}

	// Parse args
	for( ; i < argc; i++ )
	{
		if ( argv[i][0] == '-' )
			continue; // Assuming flags

		char pInputBaseName[MAX_PATH];
		Q_strncpy( pInputBaseName, argv[i], sizeof(pInputBaseName) );
		// int maxlen = Q_strlen( pInputBaseName ) + 1;

		if ( !Q_strstr( pInputBaseName, "*." ) )
		{
			Process_File( pInputBaseName, sizeof(pInputBaseName) );
			continue;
		}

#ifdef WIN32
		char	search[ 128 ];
		char	basedir[MAX_PATH];
		char	ext[_MAX_EXT];
		char    filename[_MAX_FNAME];

		_splitpath( pInputBaseName, NULL, NULL, NULL, ext ); //find extension wanted

		if ( !Q_ExtractFilePath ( pInputBaseName, basedir, sizeof( basedir ) ) )
			strcpy( basedir, ".\\" );

		sprintf( search, "%s\\*.*", basedir );

		WIN32_FIND_DATA wfd;
		HANDLE hResult;
		memset(&wfd, 0, sizeof(WIN32_FIND_DATA));

		hResult = FindFirstFile( search, &wfd );

		if ( hResult != INVALID_HANDLE_VALUE )
		{
			sprintf( filename, "%s%s", basedir, wfd.cFileName );

			if ( wfd.cFileName[0] != '.' ) 
				Process_File( filename, sizeof( filename ) );

			int iFFType = Find_Files( wfd, hResult, basedir, ext );

			while ( iFFType )
			{
				sprintf( filename, "%s%s", basedir, wfd.cFileName );

				if ( wfd.cFileName[0] != '.' && iFFType != FF_DONTPROCESS ) 
					Process_File( filename, sizeof( filename ) );

				iFFType = Find_Files( wfd, hResult, basedir, ext );
			}

			if ( iFFType == 0 )
			{
				FindClose( hResult );
			}
		}
#endif

	}
	
	// Shutdown P4
	if ( g_bUsedAsLaunchableDLL && p4 && !CommandLine()->FindParm( "-p4skip" ) )
	{
		p4->Shutdown();
		p4->Disconnect();
	}

	if ( bCreatedFilesystem )
	{
		FileSystem_Term();
	}

	if ( g_bUsedAsLaunchableDLL )
	{
		// Make sure any further spew doesn't call the function in this module (which will be unloaded shortly)
		SpewOutputFunc( NULL );
	}

	Pause();
	return 0;
}

CVTex g_VTex;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CVTex, IVTex, IVTEX_VERSION_STRING, g_VTex );
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CVTex, ILaunchableDLL, LAUNCHABLE_DLL_INTERFACE_VERSION, g_VTex );