1HEADmaster

1 files changed, 1182 insertions, 0 deletions

diff --git a/utils/xwad/xwad.cpp b/utils/xwad/xwad.cpp
new file mode 100644
index 0000000..dce4b7f
--- /dev/null
+++ b/utils/xwad/xwad.cpp
@@ -0,0 +1,1182 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#include <windows.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <conio.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <io.h>
+#include <direct.h>
+#include <stdarg.h>
+
+#include "goldsrc_standin.h"
+
+#include "wadlib.h"
+#include "goldsrc_bspfile.h"
+
+
+extern FILE *wadhandle;
+
+
+#pragma pack( 1 )
+	struct TGAHeader_t
+	{
+		unsigned char 	id_length;
+		unsigned char	colormap_type;
+		unsigned char	image_type;
+		unsigned short	colormap_index;
+		unsigned short	colormap_length;
+		unsigned char	colormap_size;
+		unsigned short	x_origin;
+		unsigned short	y_origin;
+		unsigned short	width;
+		unsigned short	height;
+		unsigned char	pixel_size;
+		unsigned char	attributes;
+	};
+#pragma pack()
+
+
+typedef enum {ST_SYNC=0, ST_RAND } synctype_t;
+typedef enum { SPR_SINGLE=0, SPR_GROUP } spriteframetype_t;
+
+typedef struct {
+	int			ident;
+	int			version;
+	int			type;
+	int			texFormat;
+	float		boundingradius;
+	int			width;
+	int			height;
+	int			numframes;
+	float		beamlength;
+	synctype_t	synctype;
+} dsprite_t;
+
+typedef struct {
+	int			origin[2];
+	int			width;
+	int			height;
+} dspriteframe_t;
+
+
+class RGBAColor
+{
+public:
+	unsigned char r,g,b,a;
+};
+
+
+const char *g_pDefaultShader = "LightmappedGeneric";
+const char *g_pShader = g_pDefaultShader;
+bool g_bBMPAllowTranslucent = false;
+bool g_bDecal = false;
+bool g_bQuiet = false;
+
+#define MAX_VMT_PARAMS	16
+
+struct VTexVMTParam_t
+{
+	const char *m_szParam;
+	const char *m_szValue;
+};
+
+static VTexVMTParam_t g_VMTParams[MAX_VMT_PARAMS];
+
+static int g_NumVMTParams = 0;
+
+void PrintExitStuff()
+{
+	if ( !g_bQuiet )
+	{
+		printf( "Press a key to quit.\n" );
+		getch();
+	}
+}
+
+
+RGBAColor* ConvertToRGBUpsideDown( byte *pBits, int width, int height, byte *pPalette, bool *bTranslucent )
+{
+	RGBAColor *pRet = new RGBAColor[width*height];
+
+	byte newPalette[256][3];
+	for ( int i=0; i < 256; i++ )
+	{
+		newPalette[i][0] = pPalette[i*3+2];
+		newPalette[i][1] = pPalette[i*3+1];
+		newPalette[i][2] = pPalette[i*3+0];
+	}
+
+	// Write the lines upside-down.
+	for ( int y=0; y < height; y++ )
+	{
+		byte *pLine = &pBits[(height-y-1)*width];
+		for ( int x=0; x < width; x++ )
+		{
+			pRet[y*width+x].r = newPalette[pLine[x]][0];
+			pRet[y*width+x].g = newPalette[pLine[x]][1];
+			pRet[y*width+x].b = newPalette[pLine[x]][2];
+			if ( pLine[x] == 255 )
+			{
+				*bTranslucent = true;
+				pRet[y*width+x].a = 0;
+			}
+			else
+			{
+				pRet[y*width+x].a = 255;
+			}
+		}
+	}
+
+	return pRet;
+}
+
+
+void FloodSolidPixels( RGBAColor *pTexels, int width, int height )
+{
+	byte *pAlphaMap = new byte[width*height];
+	byte *pNewAlphaMap = new byte[width*height];
+
+	for ( int y=0; y < height; y++ )
+		for ( int x=0; x < width; x++ )
+			pAlphaMap[y*width+x] = pTexels[y*width+x].a;
+	
+	bool bHappy = false;
+	while ( !bHappy )
+	{
+		bHappy = true;
+	
+		memcpy( pNewAlphaMap, pAlphaMap, width * height );
+
+		for ( int y=0; y < height; y++ )
+		{
+			RGBAColor *pLine = &pTexels[y*width];
+
+			for ( int x=0; x < width; x++ )
+			{
+				if ( pAlphaMap[y*width+x] == 0 )
+				{
+					int nNeighbors = 0;
+					int neighborTotal[3] = {0,0,0};
+
+					// Blend all the neighboring solid pixels.
+					for ( int offsetX=-1; offsetX <= 1; offsetX++ )
+					{
+						for ( int offsetY=-1; offsetY <= 1; offsetY++ )
+						{
+							int testX = x + offsetX;
+							int testY = y + offsetY;
+							if ( testX >= 0 && testY >= 0 && testX < width && testY < height )
+							{
+								if ( pAlphaMap[testY*width+testX] )
+								{
+									RGBAColor *pNeighbor = &pTexels[testY*width+testX];
+									++nNeighbors;
+									neighborTotal[0] += pNeighbor->r;
+									neighborTotal[1] += pNeighbor->g;
+									neighborTotal[2] += pNeighbor->b;
+								}
+							}
+						}
+					}
+
+					if ( nNeighbors )
+					{
+						pNewAlphaMap[y*width+x] = 255;
+						bHappy = false;
+						pLine[x].r = (byte)( neighborTotal[0] / nNeighbors );
+						pLine[x].g = (byte)( neighborTotal[1] / nNeighbors );
+						pLine[x].b = (byte)( neighborTotal[2] / nNeighbors );
+					}
+				}
+			}
+		}
+
+		memcpy( pAlphaMap, pNewAlphaMap, width * height );
+	}
+
+	delete [] pAlphaMap;
+	delete [] pNewAlphaMap;
+}
+
+
+RGBAColor* ResampleImage( RGBAColor *pRGB, int width, int height, int newWidth, int newHeight )
+{
+	RGBAColor *pResampled = new RGBAColor[newWidth * newHeight];
+	for ( int y=0; y < newHeight; y++ )
+	{
+		float yPercent = (float)y / (newHeight - 1);
+		float flSrcY = yPercent * (height - 1.00001f);
+		int iSrcY = (int)flSrcY;
+		float flYFrac = flSrcY - iSrcY;
+
+		for ( int x=0; x < newWidth; x++ )
+		{
+			float xPercent = (float)x / (newWidth - 1);
+			float flSrcX = xPercent * (width - 1.00001f);
+			int iSrcX = (int)flSrcX;
+			float flXFrac = flSrcX - iSrcX;
+
+			byte *pSrc0 = ((byte*)&pRGB[iSrcY*width+iSrcX]);
+			byte *pSrc1 = ((byte*)&pRGB[iSrcY*width+iSrcX+1]);
+			byte *pSrc2 = ((byte*)&pRGB[(iSrcY+1)*width+iSrcX]);
+			byte *pSrc3 = ((byte*)&pRGB[(iSrcY+1)*width+iSrcX+1]);
+			byte *pDest = (byte*)&pResampled[y*newWidth+x];
+
+			// Now blend the nearest 4 source pixels.
+			for ( int i=0; i < 4; i++ )
+			{
+				//pDest[i] = pSrc0[i];
+				float topColor    = ( pSrc0[i]*(1-flXFrac) + pSrc1[i]*flXFrac );
+				float bottomColor = ( pSrc2[i]*(1-flXFrac) + pSrc3[i]*flXFrac );
+				pDest[i] = (byte)( topColor*(1-flYFrac) + bottomColor*flYFrac );
+			}
+		}
+	}
+	return pResampled;
+}
+
+
+bool WriteTGAFile( 
+	const char *pFilename, 
+	bool bAllowTranslucent,
+	byte *pBits, 
+	int width, 
+	int height, 
+	byte *pPalette,
+	bool bPowerOf2,
+	bool *bTranslucent, 
+	bool *bResized
+	)
+{
+	*bResized = *bTranslucent = false;
+
+	RGBAColor *pRGB = ConvertToRGBUpsideDown( pBits, width, height, pPalette, bTranslucent );
+
+	// Unless the filename starts with '{', we don't allow translucency.
+	if ( !bAllowTranslucent )
+		*bTranslucent = false;
+
+	// Flood the solid texel colors into the transparent texels.
+	// Since we turn on point sampling for these textures, this only matters if we're resizing the texture.
+	if ( *bTranslucent )
+	{
+		FloodSolidPixels( pRGB, width, height );
+	}
+
+	if ( bPowerOf2 )
+	{
+		// Is it not a power of 2?
+		if ( (width & (width - 1)) || (height & (height - 1)) )
+		{
+			// Ok, resize it to the next highest power of 2.
+			int newWidth = width;
+			while ( (newWidth & (newWidth - 1)) )
+				++newWidth;
+
+			int newHeight = height;
+			while ( (newHeight & (newHeight - 1)) )
+				++newHeight;
+
+			printf( "\t(%dx%d) -> (%dx%d)", width, height, newWidth, newHeight );
+
+			RGBAColor *pResampled = ResampleImage( pRGB, width, height, newWidth, newHeight );
+			delete [] pRGB;
+			pRGB = pResampled;
+			
+			width = newWidth;
+			height = newHeight;
+
+			*bResized = true;
+		}
+	}
+
+	// Write it..	
+	TGAHeader_t hdr;
+	memset( &hdr, 0, sizeof( hdr ) );
+
+	hdr.width = width;
+	hdr.height = height;
+	hdr.colormap_type = 0;	// no, no colormap please
+	hdr.image_type = 2;		// uncompressed, true-color
+	hdr.pixel_size = 32;	// 32 bits per pixel
+	
+	FILE *fp = fopen( pFilename, "wb" );
+	if ( !fp )
+		return false;
+
+	SafeWrite( fp, &hdr, sizeof( hdr ) );
+	SafeWrite( fp, pRGB, sizeof( RGBAColor ) * width * height );	
+	fclose( fp );
+
+	delete [] pRGB;
+	return true;
+}
+
+
+int PrintUsage( const char *pExtra, ... )
+{
+	va_list marker;
+	va_start( marker, pExtra );
+	vprintf( pExtra, marker );
+	va_end( marker );
+
+	printf( 
+		"%s \n"
+		"\t[-AutoDir]\n"
+			"\t\tAutomatically detects -basedir and -wadfile or -bmpfile based\n"
+			"\t\ton the last parameter (it must be a WAD file or a BMP file.\n"
+		"\t[-decal]\n"
+			"\t\tCreates VMTs for decals and creates VMTs for model decals.\n"
+		"\t[-onlytex <tex name>]\n"
+		"\t[-shader <shader name>]\n"
+			"\t\tSpecify the shader to use in the VMT file (default\n"
+			"\t\tis LightmappedGeneric.\n"
+		"\t[-vtex]\n"
+			"\t\tIf -vtex is specified, then it calls vtex on each newly-created\n"
+			"\t\t.TGA file.\n"
+		"\t[-vmtparam <ParamName> <ParamValue>]\n"
+			"\t\tif -vtex was specified, passes the parameters to that process.\n"
+			"\t\tUsed to add parameters to the generated .vmt file\n"
+		"\t-BaseDir <basedir>\n"
+		"\t-game <basedir>\n"
+			"\t\tSpecifies where the root mod directory is.\n"
+		"\t-WadFile <wildcard>\n"
+			"\t\t-wadfile will make (power-of-2) TGAs, VTFs, and VMTs for each\n"
+			"\t\ttexture in the WAD. It will also place them under a directory\n"
+			"\t\twith the name of the WAD. In addition, it will create\n"
+			"\t\t.resizeinfo files in the materials directory if it has to\n"
+			"\t\tresize the texture. Then Hammer's File->WAD To Material\n"
+			"\t\tcommand will use them to rescale texture coordinates.\n"
+		"\t-bmpfile <wildcard>\n"
+			"\t\t-bmpfile acts like -WadFile but for BMP files, and it'll place\n"
+			"\t\tthem in the root materials directory.\n"
+		"\t-sprfile <wildcard>\n"
+			"\t\tActs like -bmpfile, but ports a sprite.\n"
+		"\t-Transparent (BMP files only)\n"
+			"\t\tIf this is set, then it will treat palette index 255 as a\n"
+			"\t\ttransparent pixel."
+		"\t-SubDir <subdirectory>\n"
+			"\t\t-SubDir tells it what directory under materials to place the\n"
+			"\t\tfinal art. If using a WAD file, then it will automatically\n"
+			"\t\tuse the WAD filename if no -SubDir is specified.\n"
+		"\t-Quiet\n"
+			"\t\tDon't print out anything or wait for a keypress on exit.\n"
+		"\n"
+		, __argv[0] );
+	printf( "ex: %s -vtex -BaseDir c:\\hl2\\dod -WadFile c:\\hl1\\dod\\*.wad\n", __argv[0] );
+	printf( "ex: %s -vtex -BaseDir c:\\hl2\\dod -bmpfile test.bmp -SubDir models\\props\n", __argv[0] );
+	printf( "ex: %s -vtex -vmtparam $ignorez 1 -BaseDir c:\\hl2\\dod -sprfile test.spr -SubDir sprites\\props\n", __argv[0] );
+	
+	PrintExitStuff();
+	return 1;
+}
+
+
+// Take something like "c:/a/b/c/filename.ext" and return "filename".
+void GetBaseFilename( const char *pWadFilename, char wadBaseName[512] )
+{
+	const char *pBase = strrchr( pWadFilename, '\\' );
+	if ( strrchr( pWadFilename, '/' ) > pBase )
+		pBase = strrchr( pWadFilename, '/' );
+
+	if ( pBase )
+		strcpy( wadBaseName, pBase+1 );
+	else
+		strcpy( wadBaseName, pWadFilename );
+
+	char *pDot = strchr( wadBaseName, '.' );
+	if ( pDot )
+		*pDot = 0;
+}
+
+
+const char *LastSlash( const char *pSrc )
+{
+	const char *pRet = strrchr( pSrc, '/' );
+	const char *pRet2 = strrchr( pSrc, '\\' );
+	return (pRet > pRet2) ? pRet : pRet2;
+}
+
+
+void EnsureDirExists( const char *pDir )
+{
+	if ( _access( pDir, 0 ) != 0 )
+	{
+		// We use the shell's "md" command here instead of the _mkdir() function because 
+		// md will create all the subdirectories leading up to the bottom one and _mkdir() won't.
+		char cmd[1024];
+		_snprintf( cmd, sizeof( cmd ), "md \"%s\"", pDir );
+		system( cmd );
+
+		if ( _access( pDir, 0 ) != 0 )
+			Error( "\tCan't create directory: %s.\n", pDir );
+	}
+}
+
+
+void WriteVMTFile( const char *pBaseDir, const char *pSubDir, const char *pName, bool bTranslucent )
+{
+	char vmtFilename[512];
+	sprintf( vmtFilename, "%s\\materials\\%s\\%s.vmt", pBaseDir, pSubDir, pName );
+
+	FILE *fp = fopen( vmtFilename, "wt" );
+	if ( !fp )
+	{
+		Error( "\tWriteVMTFile failed to open %s for writing.\n", vmtFilename );
+		return;
+	}
+	
+	fprintf( fp, "\"%s\"\n{\n", g_pShader );
+	fprintf( fp, "\t\"$basetexture\"\t\"%s\\%s\"\n", pSubDir, pName );
+	
+	if ( bTranslucent || g_bDecal )
+	{
+		fprintf( fp, "\t\"$alphatest\"\t\"1\"\n" );
+		fprintf( fp, "\t\"$ALPHATESTREFERENCE\"\t\"0.5\"\n" );
+	}
+
+	if ( g_bDecal )
+	{
+		fprintf( fp, "\t\"$decal\"\t\t\"1\"\n" );
+		
+	}
+	
+	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, "}" );
+
+	fclose( fp );
+}
+
+
+void WriteTXTFile( const char *pBaseDir, const char *pSubDir, const char *pName )
+{
+	char filename[512];
+	sprintf( filename, "%s\\materialsrc\\%s\\%s.txt", pBaseDir, pSubDir, pName );
+
+	FILE *fp = fopen( filename, "wt" );
+	if ( !fp )
+		Error( "\tWriteTXTFile: can't open %s for writing.\n", filename );
+
+	fprintf( fp, "\"pointsample\" \"1\"\n" );
+	fclose( fp );
+}
+
+
+void WriteResizeInfoFile( const char *pBaseDir, const char *pSubDir, const char *pName, int width, int height )
+{
+	char filename[512];
+	sprintf( filename, "%s\\materials\\%s\\%s.resizeinfo", pBaseDir, pSubDir, pName );
+
+	FILE *fp = fopen( filename, "wt" );
+	if ( !fp )
+	{
+		Error( "\tWriteResizeInfoFile failed to open %s for writing.\n", filename );
+		return;
+	}
+	
+	fprintf( fp, "%d %d", width, height );
+	fclose( fp );
+}
+
+
+void RunVTexOnFile( const char *pBaseDir, const char *pFilename )
+{
+	char executableDir[MAX_PATH];
+	GetModuleFileName( NULL, executableDir, sizeof( executableDir ) );
+	
+	char *pLastSlash = max( strrchr( executableDir, '/' ), strrchr( executableDir, '\\' ) );
+	if ( !pLastSlash )
+		Error( "Can't find filename in '%s'.\n", executableDir );
+	
+	*pLastSlash = 0;
+
+	// Set the vproject environment variable (vtex doesn't allow game yet).
+	char envStr[MAX_PATH];
+	_snprintf( envStr, sizeof( envStr ), "vproject=%s", pBaseDir );
+	putenv( envStr );
+
+	// Call vtex on this texture now.
+	char vtexCommand[1024];
+	sprintf( vtexCommand, "%s\\vtex.exe -quiet -nopause \"%s\"", executableDir, pFilename );
+	if ( system( vtexCommand ) != 0 )
+	{
+		Error( "\tCommand '%s' failed!\n", vtexCommand );
+	}
+}
+
+
+void WriteOutputFiles(
+	const char *pBaseDir,
+	const char *pSubDir,
+	const char *pName,
+	bool bAllowTranslucent,
+	byte *buffer,
+	int width,
+	int height,
+	byte *pPalette,
+	bool bVTex
+)
+{
+	bool bTranslucent, bResized;
+	bool bPowerOf2 = true;
+
+	char tgaFilename[1024];
+	sprintf( tgaFilename, "%s\\materialsrc\\%s\\%s.tga", pBaseDir, pSubDir, pName );
+	if ( !WriteTGAFile( 
+		tgaFilename, 
+		bAllowTranslucent, 
+		buffer, 
+		width, 
+		height, 
+		pPalette, 
+		bPowerOf2, 
+		&bTranslucent, 
+		&bResized ) )
+	{
+		Error( "\tError writing %s.\n", tgaFilename );
+	}
+
+	// Write its .VMT file.
+	WriteVMTFile( pBaseDir, pSubDir, pName, bTranslucent );
+
+	// Write a text file for it if it's translucent so we can enable pointsample for vtex.
+//	if ( bTranslucent )
+//		WriteTXTFile( pBaseDir, pSubDir, pName );
+
+	// Write its .resizeinfo file.
+	if ( bResized )
+	{
+		WriteResizeInfoFile( pBaseDir, pSubDir, pName, width, height );
+	}
+
+	if ( bVTex )
+	{
+		RunVTexOnFile( pBaseDir, tgaFilename );
+	}
+}
+
+
+void EnsureDirectoriesExist( const char *pBaseDir, const char *pSubDir )
+{
+	char materialsrcDir[512], materialsDir[512];
+	sprintf( materialsrcDir, "%s\\materialsrc\\%s", pBaseDir, pSubDir );
+	sprintf( materialsDir, "%s\\materials\\%s", pBaseDir, pSubDir );
+	EnsureDirExists( materialsrcDir );
+	EnsureDirExists( materialsDir );
+}
+
+
+void ProcessWadFile( const char *pWadFilename, const char *pBaseDir, const char *pSubDir, const char *pOnlyTex, bool bVTex )
+{
+	if ( !g_bQuiet )
+		printf( "\n\n[WADFILE %s]\n\n", pWadFilename );
+
+	// If no -subdir was specified, then figure it out from the wad filename.
+	char wadBaseName[512];
+	if ( !pSubDir )
+	{
+		// Get the base wad filename.
+		GetBaseFilename( pWadFilename, wadBaseName );
+		pSubDir = wadBaseName;
+	}
+
+	EnsureDirectoriesExist( pBaseDir, pSubDir );
+		
+
+	// Now process all the images in the wad.
+	W_OpenWad( pWadFilename );
+
+	#define MAXLUMP (640*480*85/64)
+	byte inbuffer[MAXLUMP];
+
+	for (int i = 0; i < numlumps; i++) 
+	{
+		if ( pOnlyTex && stricmp( pOnlyTex, lumpinfo[i].name ) != 0 )
+			continue;
+
+		fseek( wadhandle, lumpinfo[i].filepos, SEEK_SET );
+		SafeRead ( wadhandle, inbuffer, lumpinfo[i].size );
+
+		miptex_t *qtex = (miptex_t *)inbuffer;
+		int width = LittleLong(qtex->width);
+		int height = LittleLong(qtex->height);
+
+		if ( width <= 0 || height <= 0 || width > 5000 || height > 5000 )
+		{
+			if ( !g_bQuiet )
+				printf("\tskipping %s @ %d  size %d (not an image?)\n", lumpinfo[i].name, lumpinfo[i].filepos, lumpinfo[i].size );
+			continue;
+		}
+		else
+		{
+			if ( !g_bQuiet )
+				printf( "\t%s", lumpinfo[i].name );
+		}
+
+		byte *pPalette = inbuffer + LittleLong( qtex->offsets[3] ) + width * height / 64 + 2;
+		byte *psrc, *pdest;
+
+		byte outbuffer[(640+320)*480];
+	
+		// The old xwad	put the mipmaps in there too, but we don't want that now (usually).
+		// copy in 0 image
+		psrc = inbuffer + LittleLong( qtex->offsets[0] );
+		pdest = outbuffer;
+		for (int t = 0; t < height; t++) 
+		{
+			memcpy( pdest + t * width, psrc + t * width, width );
+		}
+
+		
+		WriteOutputFiles( 
+			pBaseDir,				// base directory
+			pSubDir,				// subdir under materials
+			qtex->name,				// filename (w/o extension)
+			qtex->name[0] == '{',	// allow transparency?
+			outbuffer, 
+			width, 
+			height, 
+			pPalette,
+			bVTex
+			);
+
+		if ( !g_bQuiet )
+			printf( "\n" );
+	}
+}
+
+
+void ProcessBMPFile( const char *pBaseDir, const char *pSubDir, const char *pFilename, bool bVTex )
+{
+	if ( !g_bQuiet )
+		printf( "[%s]\n", pFilename );
+
+	if ( !pSubDir )
+		pSubDir = ".";
+
+	// First make directories under materialsrc and materials if they don't exist.
+	EnsureDirectoriesExist( pBaseDir, pSubDir );
+
+	// Read in the 8-bit BMP file.
+	FILE *fp = fopen( pFilename, "rb" );
+	if ( !fp )
+		Error( "ProcessBMPFile( %s ) can't open the file for reading.\n", pFilename );
+
+	BITMAPFILEHEADER bfh;
+	BITMAPINFOHEADER bih;
+	unsigned char pixelData[512*512];
+
+	SafeRead( fp, &bfh, sizeof( bfh ) );
+	SafeRead( fp, &bih, sizeof( bih ) );
+
+	// Make sure it's an 8-bit one like we want.
+	if ( bih.biSize != sizeof( bih ) || 
+		bih.biPlanes != 1 || 
+		bih.biBitCount != 8 || 
+		bih.biCompression != BI_RGB ||
+		bih.biHeight < 0 ||
+		bih.biWidth * bih.biHeight > sizeof( pixelData ) )
+	{
+		Error( "ProcessBMPFile( %s ) - invalid format.\n", pFilename );
+	}
+
+	int nColorsUsed = 256;
+	if ( bih.biClrUsed != 0 )
+	{
+		nColorsUsed = bih.biClrUsed;
+		if ( nColorsUsed > 256 )
+			Error( "ProcessBMPFile( %s ) - bih.biClrUsed = %d.\n", pFilename, bih.biClrUsed );
+	}
+
+	RGBQUAD quadPalette[256];
+	SafeRead( fp, quadPalette, sizeof( quadPalette[0] ) * nColorsUsed );
+
+	// Usually, bfOffBits is the same place we are at now, but sometimes it's a little different.
+	fseek( fp, bfh.bfOffBits, SEEK_SET );
+
+	// Now read the bitmap data.
+	SafeRead( fp, pixelData, bih.biWidth * bih.biHeight );
+	
+	fclose( fp );
+
+
+	// Convert the palette.
+	byte palette[256][3];
+	for ( int i=0; i < 256; i++ )
+	{
+		palette[i][0] = quadPalette[i].rgbRed;
+		palette[i][1] = quadPalette[i].rgbGreen;
+		palette[i][2] = quadPalette[i].rgbBlue;
+	}
+
+	// Unflip the pixel data.
+	for ( int y=0; y < bih.biHeight / 2; y++ )
+	{
+		byte tempLine[1024];
+		memcpy( tempLine, &pixelData[y*bih.biWidth], bih.biWidth );
+		memcpy( &pixelData[y*bih.biWidth], &pixelData[(bih.biHeight-y-1)*bih.biWidth], bih.biWidth );
+		memcpy( &pixelData[(bih.biHeight-y-1)*bih.biWidth], tempLine, bih.biWidth );
+	}
+
+
+	char baseFilename[512];
+	GetBaseFilename( pFilename, baseFilename );
+
+	// Save it out.
+	WriteOutputFiles( 
+		pBaseDir,		// base directory
+		pSubDir,		// subdir under materials
+		baseFilename,	// filename (w/o extension)
+		g_bBMPAllowTranslucent,	// allow transparency
+		pixelData, 
+		bih.biWidth, 
+		bih.biHeight, 
+		(byte*)palette,
+		bVTex
+		);
+}
+
+
+void ProcessSPRFile( const char *pBaseDir, const char *pSubDir, const char *pFilename, bool bVTex )
+{
+	if ( !g_bQuiet )
+		printf( "[%s]\n", pFilename );
+
+	if ( !pSubDir )
+		pSubDir = ".";
+
+	char baseFilename[512];
+	GetBaseFilename( pFilename, baseFilename );
+
+	// First make directories under materialsrc and materials if they don't exist.
+	EnsureDirectoriesExist( pBaseDir, pSubDir );
+
+	// Read in the SPR file.
+	FILE *fp = fopen( pFilename, "rb" );
+	if ( !fp )
+		Error( "ProcessSPRFile( %s ) can't open the file for reading.\n", pFilename );
+	
+	dsprite_t header;
+	SafeRead( fp, &header, sizeof( header ) );
+
+	// Make sure it's a sprite file.
+	if ( ((header.ident>>0) & 0xFF) != 'I' || 
+		((header.ident>>8) & 0xFF) != 'D' ||
+		((header.ident>>16) & 0xFF) != 'S' ||
+		((header.ident>>24) & 0xFF) != 'P' )
+	{
+		Warning( "WARNING: sprite %s is not a sprite file. Skipping.\n", pFilename );
+		fclose( fp );
+		return;
+	}
+
+	if ( header.version != 2 )
+	{
+		Warning( "WARNING: sprite %s is not a version 2 sprite file. Skipping.\n", pFilename );
+		fclose( fp );
+		return;
+	}
+
+	// Read the palette.
+	short cnt;
+	byte palette[768];
+	SafeRead( fp, &cnt, sizeof( cnt ) );
+	SafeRead( fp, palette, sizeof( palette ) );
+
+	// Read the frames.
+	int i;
+	for ( i=0; i < header.numframes; i++ )
+	{
+		spriteframetype_t type;
+		SafeRead( fp, &type, sizeof( type ) );
+		if ( type == SPR_SINGLE )
+		{
+			dspriteframe_t frame;
+			SafeRead( fp, &frame, sizeof( frame ) );
+			if ( frame.width > 5000 || frame.height > 5000 || frame.width < 1 || frame.height < 1 )
+			{
+				Warning( "WARNING: sprite %s has an invalid frame size (%d x %d) for frame %d.\n", pFilename, frame.width, frame.height, i );
+				fclose( fp );
+				return;
+			}
+				
+			byte *frameData = new byte[frame.width * frame.height];
+			SafeRead( fp, frameData, frame.width * frame.height );
+
+			Msg( "\tFrame %d   ", i );
+
+			// Write the TGA file for this frame.
+			bool bTranslucent, bResized;
+			char frameFilename[512];
+			_snprintf( frameFilename, sizeof( frameFilename ), "%s\\materialsrc\\%s\\%s%03d.tga", pBaseDir, pSubDir, baseFilename, i );
+			if ( !WriteTGAFile( 
+				frameFilename, 
+				g_bBMPAllowTranslucent, 
+				frameData, 
+				frame.width, 
+				frame.height, 
+				palette, 
+				true,			// allow power-of-2
+				&bTranslucent, 
+				&bResized ) )
+			{
+				Error( "\tError writing %s.\n", frameFilename );
+			}
+
+			if ( !g_bQuiet )
+				printf( "\n" );
+
+			delete [] frameData;
+		}
+		else if ( type == SPR_GROUP )
+		{
+			Error( "Sprite %s uses type SPR_GROUP. Get a programmer to add support for it.\n", pFilename );
+		}
+		else
+		{
+			Warning( "WARNING: sprite %s has an invalid frame type (%d) for frame %d.\n", pFilename, type, i );
+			fclose( fp );
+			return;
+		}
+	}
+		
+	fclose( fp );
+
+	//
+	// Generate a .txt file for the sprite.
+	//
+	char txtFilename[512];
+	sprintf( txtFilename, "%s\\materialsrc\\%s\\%s.txt", pBaseDir, pSubDir, baseFilename );
+
+	fp = fopen( txtFilename, "wt" );
+	if ( !fp )
+		Error( "\tProcessSPRFile: can't open %s for writing.\n", txtFilename );
+
+	fprintf( fp, "\"startframe\" \"0\"\n" );
+	fprintf( fp, "\"endframe\" \"%d\"\n", header.numframes-1 );
+	fprintf( fp, "\"nomip\" \"1\"\n" );
+	fprintf( fp, "\"nolod\" \"1\"\n" );
+	fclose( fp );
+
+	//
+	// Run VTEX on the .txt file?
+	//
+	if ( bVTex )
+	{
+		RunVTexOnFile( pBaseDir, txtFilename );
+	}
+
+	//
+	// Generate a .vmt file.
+	//
+	char vmtFilename[512];
+	_snprintf( vmtFilename, sizeof( vmtFilename ), "%s\\materials\\%s\\%s.vmt", pBaseDir, pSubDir, baseFilename );
+	fp = fopen( vmtFilename, "wt" );
+	if ( !fp )
+		Error( "\tProcessSPRFile: can't open %s for writing.\n", vmtFilename );
+
+	if ( g_pShader == g_pDefaultShader )
+		fprintf( fp, "\"UnlitGeneric\"\n" );
+	else
+		fprintf( fp, "\"%s\"\n", g_pShader );
+
+	fprintf( fp, "{\n" );
+	fprintf( fp, "\t\"$spriteorientation\" \"vp_parallel\"\n" );
+	fprintf( fp, "\t\"$spriteorigin\" \"[ 0.50 0.50 ]\"\n" );
+	fprintf( fp, "\t\"$basetexture\" \"%s/%s\"\n", pSubDir, baseFilename );
+
+	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, "}" );
+
+	fclose( fp );
+}
+
+
+void ExtractDirectory( const char *pFilename, char *prefix )
+{
+	const char *pSlash = strrchr( pFilename, '/' );
+	if ( strrchr( pFilename, '\\' ) > pSlash )
+		pSlash = strrchr( pFilename, '\\' );
+
+	if ( pSlash )
+	{
+		memcpy( prefix, pFilename, pSlash - pFilename );
+		prefix[ pSlash - pFilename ] = 0;
+	}
+	else
+	{
+		strcpy( prefix, ".\\" );
+	}
+}
+
+
+// This allows them to have a WAD or BMP under their materialsrc directory and it'll try to figure out
+// all the other parameters for them.
+bool DragAndDropCheck( 
+	const char **pBaseDir, 
+	const char **pSubDir, 
+	const char **pWadFilenames, 
+	const char **pBMPFilenames,
+	const char **pSPRFilenames,
+	bool *bVTex )
+{
+	const char *pLastParam = __argv[__argc-1];
+
+	// Get the first argument in upper case.
+	char arg1[512];
+	strncpy( arg1, pLastParam, sizeof( arg1 ) );
+	strupr( arg1 );
+
+	// Only handle it if there's a full path (with a colon).
+	if ( !strchr( arg1, ':' ) )
+		return false;
+
+	if ( strstr( arg1, ".WAD" ) )
+		*pWadFilenames = pLastParam;
+	else if ( strstr( arg1, ".BMP" ) )
+		*pBMPFilenames = pLastParam;
+	else if ( strstr( arg1, ".SPR" ) )
+		*pSPRFilenames = pLastParam;
+	else
+		return false;
+	
+	// Ok, we know that argv[1] has a valid filename. Is it under materialsrc?
+	char *pMatSrc = strstr( arg1, "MATERIALSRC" );
+	if ( !pMatSrc || pMatSrc == arg1 )
+		return false;
+
+	// The base directory is everything before materialsrc.
+	static char baseDir[512];
+	*pBaseDir = baseDir;
+	memcpy( baseDir, arg1, pMatSrc-arg1 );
+	baseDir[pMatSrc-arg1-1] = 0;
+
+	// The subdirectory is everything after materialsrc, minus the filename.
+	char *pSubDirSrc = pMatSrc + strlen( "MATERIALSRC" ) + 1;
+	char *pEnd = strrchr( pSubDirSrc, '\\' );
+	if ( strrchr( pSubDirSrc, '/' ) > pEnd )
+		pEnd = strrchr( pSubDirSrc, '/' );
+
+	if ( !pEnd )
+		return false;
+
+	static char subDir[512];
+	*pSubDir = subDir;
+	memcpy( subDir, pSubDirSrc, pEnd - pSubDirSrc );
+	subDir[pEnd-pSubDirSrc] = 0;
+
+	// Always use vtex in drag-and-drop mode.	
+	*bVTex = true;
+	return true;
+}
+
+
+int main (int argc, char **argv)
+{
+	if (argc < 2) 
+	{
+		return PrintUsage( "" );
+	}
+
+	bool bWriteTGA = true;
+	bool bWriteBMP = false;
+	bool bPowerOf2 = true;
+	bool bAutoDir = false;
+
+	bool bVTex = false;
+	const char *pBaseDir = NULL;
+	const char *pWadFilenames = NULL;
+	const char *pBMPFilenames = NULL;
+	const char *pSPRFilenames = NULL;
+	const char *pSubDir = NULL;
+	const char *pOnlyTex = NULL;
+
+	// Scan for options.
+	for ( int i=1; i < argc; i++ )
+	{
+		if ( (i+2) < argc )
+		{
+			if ( stricmp( argv[i], "-vmtparam" ) == 0 && g_NumVMTParams < MAX_VMT_PARAMS )
+			{
+				g_VMTParams[g_NumVMTParams].m_szParam = argv[i+1];
+				g_VMTParams[g_NumVMTParams].m_szValue = argv[i+2];
+
+				if( !g_bQuiet )
+				{
+					fprintf( stderr, "Adding .vmt parameter: \"%s\"\t\"%s\"\n", 
+								g_VMTParams[g_NumVMTParams].m_szParam,
+								g_VMTParams[g_NumVMTParams].m_szValue );
+				}
+
+				g_NumVMTParams++;
+
+				i += 2;
+			}
+		}
+
+		if ( (i+1) < argc )
+		{
+			if ( stricmp( argv[i], "-basedir" ) == 0 )
+			{
+				pBaseDir = argv[i+1];
+				++i;
+			}
+			else if ( stricmp( argv[i], "-wadfile" ) == 0 )
+			{
+				pWadFilenames = argv[i+1];
+				++i;
+			}
+			else if ( stricmp( argv[i], "-bmpfile" ) == 0 )
+			{
+				pBMPFilenames = argv[i+1];
+				++i;
+			}
+			else if ( stricmp( argv[i], "-sprfile" ) == 0 )
+			{
+				pSPRFilenames = argv[i+1];
+				++i;
+			}
+			else if ( stricmp( argv[i], "-OnlyTex" ) == 0 )
+			{
+				pOnlyTex = argv[i+1];
+				++i;
+			}
+			else if ( stricmp( argv[i], "-SubDir" ) == 0 )
+			{
+				pSubDir = argv[i+1];
+				++i;
+			}
+			else if ( stricmp( argv[i], "-shader" ) == 0 )
+			{
+				g_pShader = argv[i+1];
+				++i;
+			}
+		}
+		
+		if ( stricmp( argv[i], "-AutoDir" ) == 0 )
+		{
+			bAutoDir = true;
+		}
+		else if ( stricmp( argv[i], "-Transparent" ) == 0 )
+		{
+			g_bBMPAllowTranslucent = true;
+		}
+		else if ( stricmp( argv[i], "-Decal" ) == 0 )
+		{	
+			g_bDecal = true;
+			if ( g_pShader == g_pDefaultShader )
+				g_pShader = "DecalModulate";
+		}
+		else if ( stricmp( argv[i], "-quiet" ) == 0 )
+		{
+			g_bQuiet = true;
+		}
+		else if ( stricmp( argv[i], "-vtex" ) == 0 )
+		{
+			bVTex = true;
+		}
+	}
+	
+	if ( bAutoDir )
+	{
+		if ( !DragAndDropCheck( &pBaseDir, &pSubDir, &pWadFilenames, &pBMPFilenames, &pSPRFilenames, &bVTex ) )
+			return PrintUsage( "-AutoDir failed to setup directories." );
+	}
+
+	if ( !pBaseDir || (!pWadFilenames && !pBMPFilenames && !pSPRFilenames) )
+		return PrintUsage( "Missing a parameter.\n" );
+
+	char prefix[512];
+
+	// Scan through each wadfile.
+	if ( pWadFilenames )
+	{
+		ExtractDirectory( pWadFilenames, prefix );
+
+		_finddata_t findData;
+		long handle = _findfirst( pWadFilenames, &findData );
+		if ( handle != -1 )
+		{
+			do
+			{
+				if ( !(findData.attrib & _A_SUBDIR) )
+				{
+					char fullFilename[512];
+					sprintf( fullFilename, "%s\\%s", prefix, findData.name );
+					ProcessWadFile( fullFilename, pBaseDir, pSubDir, pOnlyTex, bVTex );
+				}
+			} while( _findnext( handle, &findData ) == 0 );
+
+			_findclose( handle );
+		}
+	}
+
+	// Process BMP files.
+	if ( pBMPFilenames )
+	{
+		ExtractDirectory( pBMPFilenames, prefix );
+
+		_finddata_t findData;
+		long handle = _findfirst( pBMPFilenames, &findData );
+		if ( handle != -1 )
+		{
+			do
+			{
+				if ( !(findData.attrib & _A_SUBDIR) )
+				{
+					char fullFilename[512];
+					sprintf( fullFilename, "%s\\%s", prefix, findData.name );
+					ProcessBMPFile( pBaseDir, pSubDir, fullFilename, bVTex );
+				}
+			} while( _findnext( handle, &findData ) == 0 );
+
+			_findclose( handle );
+		}
+	}
+
+	if ( pSPRFilenames )
+	{
+		ExtractDirectory( pSPRFilenames, prefix );
+
+		_finddata_t findData;
+		long handle = _findfirst( pSPRFilenames, &findData );
+		if ( handle != -1 )
+		{
+			do
+			{
+				if ( !(findData.attrib & _A_SUBDIR) )
+				{
+					char fullFilename[512];
+					sprintf( fullFilename, "%s\\%s", prefix, findData.name );
+					ProcessSPRFile( pBaseDir, pSubDir, fullFilename, bVTex );
+				}
+			} while( _findnext( handle, &findData ) == 0 );
+
+			_findclose( handle );
+		}
+	}
+
+	PrintExitStuff();
+	return 0;
+}	
+