d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 84a698de7b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '84a698de7b'
${ noResults }
source-engine/utils/vtex/vtex.cpp

2996 lines
80 KiB
Raw Blame History

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