//========= Copyright © 1996-2005, 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\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 )
{
	// Call vtex on this texture now.
	char vtexCommand[1024];
	sprintf( vtexCommand, "%s\\..\\bin\\vtex.exe -quiet -nopause \"%s\"", pBaseDir, 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;
}	

