summaryrefslogtreecommitdiff
path: root/utils/vtex/vtex.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'utils/vtex/vtex.cpp')
-rw-r--r--utils/vtex/vtex.cpp2996
1 files changed, 2996 insertions, 0 deletions
diff --git a/utils/vtex/vtex.cpp b/utils/vtex/vtex.cpp
new file mode 100644
index 0000000..7a43b3f
--- /dev/null
+++ b/utils/vtex/vtex.cpp
@@ -0,0 +1,2996 @@
+//========= 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 );
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-07 07:54:42 +0000