1HEADmaster

1 files changed, 1023 insertions, 0 deletions

diff --git a/utils/matsys_regressiontest/matsys_regressiontest.cpp b/utils/matsys_regressiontest/matsys_regressiontest.cpp
new file mode 100644
index 0000000..d4b81d8
--- /dev/null
+++ b/utils/matsys_regressiontest/matsys_regressiontest.cpp
@@ -0,0 +1,1023 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//===========================================================================//
+
+#define PROTECTED_THINGS_DISABLE
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include "materialsystem/imaterialsystem.h"
+#include "materialsystem/IMaterialSystemHardwareConfig.h"
+#include "materialsystem/imaterialproxyfactory.h"
+#include "filesystem.h"
+#include "bitmap/imageformat.h"
+#include "materialsystem/MaterialSystem_Config.h"
+#include "tier0/icommandline.h"
+#include "tier1/strtools.h"
+#include "mathlib/mathlib.h"
+#include "materialsystem/imesh.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imaterialvar.h"
+#include "bitmap/tgawriter.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <direct.h>
+#include "vstdlib/cvar.h"
+#include "KeyValues.h"
+#include "tier1/utlbuffer.h"
+#include "tier2/tier2.h"
+
+#define CHECKERBOARD_DIMS 16
+
+IMaterial *g_pProceduralMaterial = NULL;
+
+static char g_pCommandLine[1024];
+static int g_ArgC = 0;
+static char* g_ppArgV[32];
+static HWND g_HWnd = 0;
+static CreateInterfaceFn g_MaterialsFactory;
+
+static CSysModule			*g_MaterialsDLL = NULL;
+
+static int g_RenderWidth = 640;
+static int g_RenderHeight = 480;
+static int g_RefreshRate = 60;
+
+static bool g_Exiting = false;
+
+void CreateLightmapPages( void );
+void RenderFrame( void );
+
+//-----------------------------------------------------------------------------
+// Command-line...
+//-----------------------------------------------------------------------------
+
+int FindCommand( const char *pCommand )
+{
+	for ( int i = 0; i < g_ArgC; i++ )
+	{
+		if ( !stricmp( pCommand, g_ppArgV[i] ) )
+			return i;
+	}
+	return -1;
+}
+
+const char* CommandArgument( const char *pCommand )
+{
+	int cmd = FindCommand( pCommand );
+	if ((cmd != -1) && (cmd < g_ArgC - 1))
+	{
+		return g_ppArgV[cmd+1];
+	}
+	return 0;
+}
+
+void SetupCommandLine( const char* pCommandLine )
+{
+	Q_strncpy( g_pCommandLine, pCommandLine, sizeof( g_pCommandLine ) );
+
+	g_ArgC = 0;
+
+	char* pStr = g_pCommandLine;
+	while ( *pStr )
+	{
+		pStr = strtok( pStr, " " );
+		if( !pStr )
+		{
+			break;
+		}
+		g_ppArgV[g_ArgC++] = pStr;
+		pStr += strlen(pStr) + 1;
+	}
+}
+//-----------------------------------------------------------------------------
+// DummyMaterialProxyFactory...
+//-----------------------------------------------------------------------------
+
+class DummyMaterialProxyFactory : public IMaterialProxyFactory
+{
+public:
+	virtual IMaterialProxy *CreateProxy( const char *proxyName )	{return NULL;}
+	virtual void DeleteProxy( IMaterialProxy *pProxy )				{}
+};
+static DummyMaterialProxyFactory	g_DummyMaterialProxyFactory;
+
+//-----------------------------------------------------------------------------
+// Spew function!
+//-----------------------------------------------------------------------------
+SpewRetval_t SpewFunc( SpewType_t spewType, char const *pMsg )
+{
+	OutputDebugString( pMsg );
+	switch( spewType )
+	{
+	case SPEW_MESSAGE:
+	case SPEW_WARNING:
+	case SPEW_LOG:
+		OutputDebugString( pMsg );
+		return SPEW_CONTINUE;
+
+	case SPEW_ASSERT:
+	case SPEW_ERROR:
+	default:
+		::MessageBox( NULL, pMsg, "Error!", MB_OK );
+		return SPEW_DEBUGGER;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Error...
+//-----------------------------------------------------------------------------
+
+void DisplayError( const char* pError, ... )
+{
+	va_list		argptr;
+	char		msg[1024];
+	
+	va_start( argptr, pError );
+	Q_vsnprintf( msg, sizeof( msg ), pError, argptr );
+	va_end( argptr );
+
+	MessageBox( 0, msg, 0, MB_OK );
+}
+
+
+
+IFileSystem *g_pFileSystem;
+static CSysModule *g_pFileSystemModule = NULL;
+static CreateInterfaceFn g_pFileSystemFactory = NULL;
+static bool FileSystem_LoadDLL( void )
+{
+	g_pFileSystemModule = Sys_LoadModule( "filesystem_stdio.dll" );
+	Assert( g_pFileSystemModule );
+	if( !g_pFileSystemModule )
+	{
+		return false;
+	}
+
+	g_pFileSystemFactory = Sys_GetFactory( g_pFileSystemModule );
+	if( !g_pFileSystemFactory )
+	{
+		return false;
+	}
+	g_pFileSystem = ( IFileSystem * )g_pFileSystemFactory( FILESYSTEM_INTERFACE_VERSION, NULL );
+	Assert( g_pFileSystem );
+	if( !g_pFileSystem )
+	{
+		return false;
+	}
+	return true;
+}
+
+void FileSystem_UnloadDLL( void )
+{
+	if ( !g_pFileSystemModule )
+		return;
+
+	Sys_UnloadModule( g_pFileSystemModule );
+	g_pFileSystemModule = 0;
+}
+
+void FileSystem_Init( )
+{
+	if( !FileSystem_LoadDLL() )
+	{
+		return;
+	}
+
+	g_pFileSystem->RemoveSearchPath( NULL, "GAME" );
+	g_pFileSystem->AddSearchPath( "hl2", "GAME", PATH_ADD_TO_HEAD );
+}
+
+void FileSystem_Shutdown( void )
+{
+	g_pFileSystem->Shutdown();
+
+	FileSystem_UnloadDLL();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Unloads the material system .dll
+//-----------------------------------------------------------------------------
+void UnloadMaterialSystem( void )
+{
+	if ( !g_MaterialsFactory )
+		return;
+
+	Sys_UnloadModule( g_MaterialsDLL );
+	g_MaterialsDLL = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Loads the material system dll
+//-----------------------------------------------------------------------------
+void LoadMaterialSystem( void )
+{
+	if( g_MaterialsFactory )
+	{
+		return;
+	}
+
+	Assert( !g_MaterialsDLL );
+
+	g_MaterialsDLL = Sys_LoadModule( "MaterialSystem.dll" );
+
+	g_MaterialsFactory = Sys_GetFactory( g_MaterialsDLL );
+	if ( !g_MaterialsFactory )
+	{
+		DisplayError( "LoadMaterialSystem:  Failed to load MaterialSystem.DLL\n" );
+		return;
+	}
+
+	if ( g_MaterialsFactory )
+	{
+		g_pMaterialSystem = (IMaterialSystem *)g_MaterialsFactory( MATERIAL_SYSTEM_INTERFACE_VERSION, NULL );
+		if ( !g_pMaterialSystem )
+		{
+			DisplayError( "Could not get the material system interface from materialsystem.dll (a)" );
+		}
+	}
+	else
+	{
+		DisplayError( "Could not find factory interface in library MaterialSystem.dll" );
+	}
+}
+
+void InitMaterialSystemConfig(MaterialSystem_Config_t *pConfig)
+{
+}
+
+CreateInterfaceFn g_MaterialSystemClientFactory;
+void Shader_Init( HWND mainWindow )
+{
+	LoadMaterialSystem();
+	Assert( g_pMaterialSystem );
+
+	// FIXME: Where do we put this?
+	const char* pDLLName;
+	pDLLName = "shaderapidx9";
+
+	// assume that IFileSystem paths have already been set via g_pFileSystem 
+	g_MaterialSystemClientFactory = g_pMaterialSystem->Init( 
+		pDLLName, &g_DummyMaterialProxyFactory, g_pFileSystemFactory, VStdLib_GetICVarFactory() );
+	if (!g_MaterialSystemClientFactory)
+	{
+		DisplayError( "Unable to init shader system\n" );
+	}
+
+	// Get the adapter from the command line....
+	MaterialVideoMode_t mode;
+	memset( &mode, 0, sizeof( mode ) );
+	mode.m_Width = g_RenderWidth;
+	mode.m_Height = g_RenderHeight;
+	mode.m_Format = IMAGE_FORMAT_BGRX8888;
+	mode.m_RefreshRate = g_RefreshRate;
+//	bool modeSet = g_pMaterialSystem->SetMode( (void*)mainWindow, mode, modeFlags );
+//	if (!modeSet)
+//	{
+//		DisplayError( "Unable to set mode\n" );
+//	}
+
+	g_pMaterialSystemHardwareConfig = (IMaterialSystemHardwareConfig*)
+		g_MaterialSystemClientFactory( MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION, 0 );
+	if ( !g_pMaterialSystemHardwareConfig )
+	{
+		DisplayError( "Could not get the material system hardware config interface!" );
+	}
+
+	MaterialSystem_Config_t config;
+	InitMaterialSystemConfig(&config);
+	g_pMaterialSystem->OverrideConfig( config, false );
+	if( FindCommand( "-stub" ) != -1 )
+	{
+		g_pMaterialSystem->SetInStubMode( true );
+	}
+}
+
+void Shader_Shutdown( HWND hwnd )
+{
+	// Recursive shutdown
+	if ( !g_pMaterialSystem )
+		return;
+
+	g_pMaterialSystem->Shutdown( );
+	g_pMaterialSystem = NULL;
+	UnloadMaterialSystem();
+}
+
+static void CalcWindowSize( int desiredRenderingWidth, int desiredRenderingHeight,
+							int *windowWidth, int *windowHeight )
+{
+    int     borderX, borderY;
+	borderX = (GetSystemMetrics(SM_CXFIXEDFRAME) + 1) * 2;
+	borderY = (GetSystemMetrics(SM_CYFIXEDFRAME) + 1) * 2 + GetSystemMetrics(SM_CYSIZE) + 1;
+	*windowWidth = desiredRenderingWidth + borderX;
+	*windowHeight = desiredRenderingHeight + borderY;
+}
+
+//-----------------------------------------------------------------------------
+// Window create, destroy...
+//-----------------------------------------------------------------------------
+LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
+{
+    switch( msg )
+    {
+	case WM_PAINT:
+		RenderFrame();
+		break;
+		// abort when ESC is hit
+	case WM_CHAR:
+		switch(wParam)
+		{
+		case VK_ESCAPE:
+			SendMessage( g_HWnd, WM_CLOSE, 0, 0 );
+			break;
+		}
+		break;
+		
+        case WM_DESTROY:
+			g_Exiting = true;
+            PostQuitMessage( 0 );
+            return 0;
+    }
+	
+    return DefWindowProc( hWnd, msg, wParam, lParam );
+}
+
+bool CreateAppWindow( const char* pAppName, int width, int height )
+{
+    // Register the window class
+	WNDCLASSEX windowClass = 
+	{ 
+		sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
+        GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
+        pAppName, NULL 
+	};
+
+    RegisterClassEx( &windowClass );
+
+    // Create the application's window
+    g_HWnd = CreateWindow( pAppName, pAppName,
+		WS_OVERLAPPEDWINDOW, 
+		0, 0, width, height,
+		GetDesktopWindow(), NULL, windowClass.hInstance, NULL );
+	
+    ShowWindow (g_HWnd, SW_SHOWDEFAULT);
+	
+	return (g_HWnd != 0);
+}
+
+void DestroyAppWindow()
+{
+	if (g_HWnd)
+		DestroyWindow( g_HWnd );
+}
+bool Init( const char* pCommands)
+{
+	// Store off the command line...
+	SetupCommandLine( pCommands );
+	FileSystem_Init( );
+
+	/* figure out g_Renderwidth and g_RenderHeight */
+	g_RenderWidth = -1;
+	g_RenderHeight = -1;
+
+	g_RenderWidth = 640;
+	g_RenderHeight = 480;
+
+	int windowWidth, windowHeight;
+	CalcWindowSize( g_RenderWidth, g_RenderHeight, &windowWidth, &windowHeight );
+
+	if( !CreateAppWindow( "matsys_regressiontest", windowWidth, windowHeight ) )
+	{
+		return false;
+	}
+
+	Shader_Init( g_HWnd );
+	g_pMaterialSystem->CacheUsedMaterials();
+	CreateLightmapPages();
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return the directory where this .exe is running from
+// Output : char
+//-----------------------------------------------------------------------------
+
+static char *GetBaseDir( const char *pszBuffer )
+{
+	static char	basedir[ MAX_PATH ];
+	char szBuffer[ MAX_PATH ];
+	int j;
+	char *pBuffer = NULL;
+
+	Q_strncpy( szBuffer, pszBuffer, sizeof( szBuffer ) );
+
+	pBuffer = strrchr( szBuffer,'\\' );
+	if ( pBuffer )
+	{
+		*(pBuffer+1) = '\0';
+	}
+
+	Q_strncpy( basedir, szBuffer, sizeof( basedir ) );
+
+	j = strlen( basedir );
+	if (j > 0)
+	{
+		if ( ( basedir[ j-1 ] == '\\' ) || 
+			 ( basedir[ j-1 ] == '/' ) )
+		{
+			basedir[ j-1 ] = 0;
+		}
+	}
+
+	return basedir;
+}
+
+//-----------------------------------------------------------------------------
+// Shutdown
+//-----------------------------------------------------------------------------
+
+void Shutdown()
+{
+	// Close the window
+	DestroyAppWindow();
+
+	Shader_Shutdown( g_HWnd );
+}
+
+//-----------------------------------------------------------------------------
+// Pump windows messages
+//-----------------------------------------------------------------------------
+
+void PumpWindowsMessages ()
+{
+	MSG msg;
+	while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) == TRUE) 
+	{
+		TranslateMessage(&msg);
+		DispatchMessage(&msg);
+	}
+	
+	InvalidateRect(g_HWnd, NULL, false);
+	UpdateWindow(g_HWnd);
+}
+
+MaterialSystem_SortInfo_t *g_pMaterialSortInfo = NULL;
+struct LightmapInfo_t
+{
+	int m_LightmapDims[2];
+	int m_LightmapPageDims[2];
+	int m_OffsetIntoLightmapPage[2];
+	int m_SortID;
+};
+
+LightmapInfo_t g_CheckerboardLightmapInfo;
+
+void AllocateLightmap( LightmapInfo_t& lightmapInfo, int width, int height )
+{
+	lightmapInfo.m_LightmapDims[0] = width;
+	lightmapInfo.m_LightmapDims[1] = height;
+	// HACK!  We don't ever use this material for anything. . just need it for allocating lightmaps.
+	CMatRenderContextPtr pRenderContext( materials );
+	IMaterial *pHackMaterial = g_pMaterialSystem->FindMaterial( "shadertest/lightmappedgeneric", TEXTURE_GROUP_OTHER );
+	pRenderContext->Bind( pHackMaterial );
+	lightmapInfo.m_SortID = 
+		g_pMaterialSystem->AllocateLightmap( 16, 16, lightmapInfo.m_OffsetIntoLightmapPage, pHackMaterial );
+}
+
+void Lightmap_PostAllocation( LightmapInfo_t& lightmapInfo )
+{
+	g_pMaterialSystem->GetLightmapPageSize( lightmapInfo.m_SortID,
+		&lightmapInfo.m_LightmapPageDims[0], &lightmapInfo.m_LightmapPageDims[1] );
+}
+
+void UpdateLightmap( LightmapInfo_t& lightmapInfo, float *data )
+{
+	g_pMaterialSystem->UpdateLightmap( g_pMaterialSortInfo[lightmapInfo.m_SortID].lightmapPageID,
+		lightmapInfo.m_LightmapDims, lightmapInfo.m_OffsetIntoLightmapPage, data, NULL, NULL, NULL );
+}
+
+void CreateLightmapPages( void )
+{
+	g_pMaterialSystem->BeginLightmapAllocation();
+
+	AllocateLightmap( g_CheckerboardLightmapInfo, CHECKERBOARD_DIMS, CHECKERBOARD_DIMS );
+
+	g_pMaterialSystem->EndLightmapAllocation();
+	int numSortIDs = g_pMaterialSystem->GetNumSortIDs();
+	g_pMaterialSortInfo = new MaterialSystem_SortInfo_t[numSortIDs];
+	g_pMaterialSystem->GetSortInfo( g_pMaterialSortInfo );
+
+	Lightmap_PostAllocation( g_CheckerboardLightmapInfo );
+
+	float checkerboardImage[CHECKERBOARD_DIMS*CHECKERBOARD_DIMS*4];
+	int x, y;
+	for( y = 0; y < CHECKERBOARD_DIMS; y++ )
+	{
+		for( x = 0; x < CHECKERBOARD_DIMS; x++ )
+		{
+			if( ( x + y ) & 1 )
+			{
+				checkerboardImage[(y*CHECKERBOARD_DIMS+x)*4+0] = 1.0f;
+				checkerboardImage[(y*CHECKERBOARD_DIMS+x)*4+1] = 1.0f;
+				checkerboardImage[(y*CHECKERBOARD_DIMS+x)*4+2] = 1.0f;
+				checkerboardImage[(y*CHECKERBOARD_DIMS+x)*4+3] = 1.0f;
+			}
+			else
+			{
+				checkerboardImage[(y*CHECKERBOARD_DIMS+x)*4+0] = 0.0f;
+				checkerboardImage[(y*CHECKERBOARD_DIMS+x)*4+1] = 0.0f;
+				checkerboardImage[(y*CHECKERBOARD_DIMS+x)*4+2] = 0.0f;
+				checkerboardImage[(y*CHECKERBOARD_DIMS+x)*4+3] = 1.0f;
+			}
+		}
+	}
+
+	UpdateLightmap( g_CheckerboardLightmapInfo, checkerboardImage );
+}
+
+void LightmapTexCoord( CMeshBuilder& meshBuilder, LightmapInfo_t lightmapInfo, float s, float t )
+{
+	// add a one texel border.
+	float newS = ( s * ( lightmapInfo.m_LightmapDims[0] - 2 ) ) + 1;
+	float newT = ( t * ( lightmapInfo.m_LightmapDims[1] - 2 ) ) + 1;
+	newS += lightmapInfo.m_OffsetIntoLightmapPage[0];
+	newT += lightmapInfo.m_OffsetIntoLightmapPage[1];
+	newS *= 1.0f / lightmapInfo.m_LightmapPageDims[0];
+	newT *= 1.0f / lightmapInfo.m_LightmapPageDims[1];
+	meshBuilder.TexCoord2f( 1, newS, newT );
+}
+
+//-----------------------------------------------------------------------------
+// Update
+//-----------------------------------------------------------------------------
+bool Update()
+{
+	PumpWindowsMessages();
+	return g_Exiting;
+}
+
+void ScreenShot( const char *pFilename )
+{
+	// bitmap bits
+	unsigned char *pImage = ( unsigned char * )malloc( g_RenderWidth * 3 * g_RenderHeight );
+
+	// Get Bits from the material system
+	CMatRenderContextPtr pRenderContext( materials );
+	pRenderContext->ReadPixels( 0, 0, g_RenderWidth, g_RenderHeight, pImage, IMAGE_FORMAT_RGB888 );
+
+	CUtlBuffer outBuf;
+	if( !TGAWriter::WriteToBuffer( pImage, outBuf, g_RenderWidth, g_RenderHeight, IMAGE_FORMAT_RGB888,
+		IMAGE_FORMAT_RGB888 ) )
+	{
+		Error( "Couldn't write %s\n", pFilename );
+	}
+	if ( !g_pFullFileSystem->WriteFile( pFilename, NULL, outBuf ) )
+	{
+		Error( "Couldn't write %s\n", pFilename );
+	}
+	
+	free( pImage );
+}
+
+void SetVar( const char *pVarName, const char *pStringValue )
+{
+	IMaterialVar *pVar = g_pProceduralMaterial->FindVar( pVarName, NULL );
+	if( pStringValue )
+	{
+		pVar->SetStringValue( pStringValue );
+	}
+	else
+	{
+		pVar->SetUndefined();
+	}
+}
+
+void SetVar( const char *pVarName, int val )
+{
+	IMaterialVar *pVar = g_pProceduralMaterial->FindVar( pVarName, NULL );
+	pVar->SetIntValue( val );
+}
+
+void SetFlag( MaterialVarFlags_t flag, int val )
+{
+	g_pProceduralMaterial->SetMaterialVarFlag( flag, val ? true : false );
+}
+
+void DrawBackground( void )
+{
+	CMatRenderContextPtr pRenderContext( materials );
+	IMaterial *pMaterial = g_pMaterialSystem->FindMaterial( "matsys_regressiontest/background", TEXTURE_GROUP_OTHER );
+	pRenderContext->Bind( pMaterial );
+
+	IMesh *pMesh = pRenderContext->GetDynamicMesh();
+	CMeshBuilder meshBuilder;
+	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
+	
+#define X 500.0f
+#define Y 500.0f
+#define Z -500.0f
+
+	meshBuilder.Position3f( -X, Y, Z );
+	meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Position3f( X, Y, Z );
+	meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Position3f( X, -Y, Z );
+	meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Position3f( -X, -Y, Z );
+	meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
+	meshBuilder.AdvanceVertex();
+	
+	meshBuilder.End();
+	pMesh->Draw();
+
+#undef X
+#undef Y
+#undef Z
+}
+
+void BeginFrame( void )
+{
+	g_pMaterialSystem->BeginFrame( 0 );
+
+	CMatRenderContextPtr pRenderContext( materials );
+	pRenderContext->ClearColor3ub( 255, 0, 0 );
+	pRenderContext->ClearBuffers( true, true );
+	pRenderContext->Viewport( 0, 0, g_RenderWidth, g_RenderHeight );
+
+	pRenderContext->MatrixMode( MATERIAL_PROJECTION );
+	pRenderContext->LoadIdentity();
+	pRenderContext->PerspectiveX( 90.0f, ( g_RenderWidth / g_RenderHeight), 1.0f, 500000.0f );
+
+	pRenderContext->MatrixMode( MATERIAL_VIEW );
+	pRenderContext->LoadIdentity();
+
+	pRenderContext->MatrixMode( MATERIAL_MODEL );
+	pRenderContext->LoadIdentity();
+}
+
+void EndFrame( void )
+{
+	g_pMaterialSystem->EndFrame();
+	g_pMaterialSystem->SwapBuffers();
+}
+
+void DrawQuad( const LightmapInfo_t& lightmapInfo )
+{
+	CMatRenderContextPtr pRenderContext( materials );
+	pRenderContext->BindLightmapPage( g_pMaterialSortInfo[lightmapInfo.m_SortID].lightmapPageID );
+	
+	pRenderContext->Bind( g_pProceduralMaterial );
+
+	IMesh *pMesh = pRenderContext->GetDynamicMesh();
+	CMeshBuilder meshBuilder;
+	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
+	
+#define X 350.0f
+#define Y (X*(4.0f/3.0f))
+#define Z -500.0f
+
+	meshBuilder.Position3f( -X, Y, Z );
+	meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
+	LightmapTexCoord( meshBuilder, lightmapInfo, 0.0f, 0.0f );
+	meshBuilder.Normal3f( 0.0f, 0.0f, 1.0f );
+	meshBuilder.Color4f( 1.0f, 0.0f, 0.0f, 1.0f );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Position3f( X, Y, Z );
+	meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
+	LightmapTexCoord( meshBuilder, lightmapInfo, 1.0f, 0.0f );
+	meshBuilder.Normal3f( 0.0f, 0.0f, 1.0f );
+	meshBuilder.Color4f( 1.0f, 1.0f, 0.0f, 1.0f );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Position3f( X, -Y, Z );
+	meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
+	LightmapTexCoord( meshBuilder, lightmapInfo, 1.0f, 1.0f );
+	meshBuilder.Normal3f( 0.0f, 0.0f, 1.0f );
+	meshBuilder.Color4f( 1.0f, 1.0f, 1.0f, 0.0f );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Position3f( -X, -Y, Z );
+	meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
+	LightmapTexCoord( meshBuilder, lightmapInfo, 0.0f, 1.0f );
+	meshBuilder.Normal3f( 0.0f, 0.0f, 1.0f );
+	meshBuilder.Color4f( 0.0f, 1.0f, 1.0f, 1.0f );
+	meshBuilder.AdvanceVertex();
+	
+	meshBuilder.End();
+	pMesh->Draw();
+
+#undef X
+#undef Y
+#undef Z
+}
+
+void TestLightmappedGeneric_dx80( void )
+{
+/*
+based on lightmappedgeneric_vs11.fxc:
+// STATIC: "DETAIL" "0..1"
+// STATIC: "ENVMAP" "0..1"
+// STATIC: "ENVMAPCAMERASPACE" "0..1"
+// STATIC: "ENVMAPSPHERE" "0..1"
+// STATIC: "VERTEXCOLOR" "0..1"
+// DYNAMIC: "FOGTYPE"				"0..1"
+
+// SKIP: $ENVMAPCAMERASPACE && $ENVMAPSPHERE
+// SKIP: !$ENVMAP && ( $ENVMAPCAMERASPACE || $ENVMAPSPHERE )
+
+based on lightmappedgeneric_ps11.fxc:
+// STATIC: "BASETEXTURE"			"0..1"
+// STATIC: "ENVMAP"					"0..1"
+// STATIC: "ENVMAPMASK"				"0..1"
+// STATIC: "SELFILLUM"				"0..1"
+// STATIC: "BASEALPHAENVMAPMASK"	"0..1"
+
+// SKIP: !$ENVMAP && ( $BASEALPHAENVMAPMASK || $ENVMAPMASK )
+// SKIP: !$BASETEXTURE && $BASEALPHAENVMAPMASK
+// SKIP: $BASEALPHAENVMAPMASK && $ENVMAPMASK
+// SKIP: !$BASETEXTURE && $BASEALPHAENVMAPMASK
+// SKIP: $SELFILLUM && $BASEALPHAENVMAPMASK
+// SKIP: !$BASETEXTURE && $SELFILLUM
+
+
+Versions with DETAIL aren't implemented yet in HLSL, but we'll go ahead and test those.
+*/  	
+	// The following are shader combos from lightmappedgeneric_ps20
+	for( int BUMPMAP = 0; BUMPMAP <= 1; BUMPMAP++ )
+	{
+		for( int NORMALMAPALPHAENVMAPMASK = 0; NORMALMAPALPHAENVMAPMASK <= 1; NORMALMAPALPHAENVMAPMASK++ )
+		{
+			// The following are shader combos from lightmappedgeneric_ps11 (that aren't in lightmappedgenerc_vs11)
+			for( int BASETEXTURE = 0; BASETEXTURE <= 1; BASETEXTURE++ )
+			{
+				for( int ENVMAPMASK = 0; ENVMAPMASK <= 1; ENVMAPMASK++ )
+				{
+					for( int SELFILLUM = 0; SELFILLUM <= 1; SELFILLUM++ )
+					{
+						for( int BASEALPHAENVMAPMASK = 0; BASEALPHAENVMAPMASK <= 1; BASEALPHAENVMAPMASK++ )
+						{
+							// The following are shader combos from lightmappedgeneric_vs11
+							for( int DETAIL = 0; DETAIL <= 1; DETAIL++ )
+							{
+								for( int ENVMAP = 0; ENVMAP <= 1; ENVMAP++ )
+								{
+									for( int ENVMAPCAMERASPACE = 0; ENVMAPCAMERASPACE <= 1; ENVMAPCAMERASPACE++ )
+									{
+										for( int ENVMAPSPHERE = 0; ENVMAPSPHERE <= 1; ENVMAPSPHERE++ )
+										{
+											for( int VERTEXCOLOR = 0; VERTEXCOLOR <= 1; VERTEXCOLOR++ )
+											{
+	//											for( int FOGTYPE = 0; FOGTYPE <= 1; FOGTYPE++ )
+												{
+													// conditional beneath here are flags, not shader combos
+													for( int ALPHATEST = 0; ALPHATEST <= 1; ALPHATEST++ )
+													{
+														for( int TRANSLUCENT = 0; TRANSLUCENT <= 1; TRANSLUCENT++ )
+														{
+															for( int COLORMODULATE = 0; COLORMODULATE <= 1; COLORMODULATE++ )
+															{
+																for( int ALPHAMODULATE = 0; ALPHAMODULATE <= 1; ALPHAMODULATE++ )
+																{
+#if 0
+																	BUMPMAP = 0;
+																	NORMALMAPALPHAENVMAPMASK = 0;
+																	BASETEXTURE = 1;
+																	ENVMAPMASK = 0;
+																	SELFILLUM = 0;
+																	BASEALPHAENVMAPMASK = 1;
+																	DETAIL = 0;
+																	ENVMAP = 1;
+																	ENVMAPCAMERASPACE = 0;
+																	ENVMAPSPHERE = 0;
+																	VERTEXCOLOR = 0;
+																	ALPHATEST = 0;
+																	TRANSLUCENT = 0;
+																	COLORMODULATE = 0;
+																	ALPHAMODULATE = 0;
+#endif
+																	// skip commands from shader lightmappedgeneric_vs11
+																	if( ENVMAPCAMERASPACE && ENVMAPSPHERE ) continue;
+																	if( !ENVMAP && ( ENVMAPCAMERASPACE || ENVMAPSPHERE ) ) continue;
+																	
+																	// skip commands from shader lihgtmappedgeneric_ps11
+																	if( !ENVMAP && ( BASEALPHAENVMAPMASK || ENVMAPMASK ) ) continue;
+																	if( !BASETEXTURE && BASEALPHAENVMAPMASK ) continue;
+																	if( BASEALPHAENVMAPMASK && ENVMAPMASK ) continue;
+																	if( !BASETEXTURE && BASEALPHAENVMAPMASK ) continue;
+																	if( SELFILLUM && BASEALPHAENVMAPMASK ) continue;
+																	if( !BASETEXTURE && SELFILLUM ) continue;
+																	
+																	// skip commands from shader lightmappedgeneric_ps20
+																	if( DETAIL && BUMPMAP ) continue;
+																	if( ENVMAPMASK && BUMPMAP ) continue;
+																	if( NORMALMAPALPHAENVMAPMASK && BASEALPHAENVMAPMASK ) continue;
+																	if( NORMALMAPALPHAENVMAPMASK && ENVMAPMASK ) continue;
+																	if( BASEALPHAENVMAPMASK && ENVMAPMASK ) continue;
+																	if( BASEALPHAENVMAPMASK && SELFILLUM ) continue;
+																	
+																	// skip commands from flags that don't make sense (or we don't want to test)
+																	if( !BASETEXTURE && ( ALPHATEST || TRANSLUCENT ) ) continue;
+																	if( TRANSLUCENT && ALPHATEST ) continue;
+																	
+																	KeyValues *pKeyValues = new KeyValues( "lightmappedgeneric" );
+																	if ( BASETEXTURE )
+																	{
+																		pKeyValues->SetString( "$basetexture", "matsys_regressiontest/basetexture" );
+																	}
+																	if ( ENVMAPMASK )
+																	{
+																		pKeyValues->SetString( "$envmapmask", "matsys_regressiontest/specularmask" );
+																	}
+																	if ( SELFILLUM )
+																	{
+																		pKeyValues->SetInt( "$selfillum", 1 );
+																	}
+																	if ( BASEALPHAENVMAPMASK )
+																	{
+																		pKeyValues->SetInt( "$basealphaenvmapmask", 1 );
+																	}
+																	if ( BUMPMAP )
+																	{
+																		pKeyValues->SetString( "$bumpmap", "matsys_regressiontest/normalmap_normal" );
+																	}
+																	if ( DETAIL )
+																	{
+																		pKeyValues->SetString( "$detail", "matsys_regressiontest/detail" );
+																		pKeyValues->SetFloat( "$detailscale", 0.5f );
+																	}
+																	if ( ENVMAP )
+																	{
+																		pKeyValues->SetString( "$envmap", "matsys_regressiontest/cubemap" );
+																	}
+																	if ( BASEALPHAENVMAPMASK )
+																	{
+																		pKeyValues->SetInt( "$basealphaenvmapmask", 1 );
+																	}
+																	if ( NORMALMAPALPHAENVMAPMASK )
+																	{
+																		pKeyValues->SetInt( "$normalmapalphaenvmapmask", 1 );
+																	}
+																	if ( TRANSLUCENT )
+																	{
+																		pKeyValues->SetInt( "$translucent", 1 );
+																	}
+																	if ( ENVMAPCAMERASPACE )
+																	{
+																		pKeyValues->SetInt( "$envmapcameraspace", 1 );
+																	}
+																	if ( ENVMAPSPHERE )
+																	{
+																		pKeyValues->SetInt( "$envmapsphere", 1 );
+																	}
+																	if ( VERTEXCOLOR )
+																	{
+																		pKeyValues->SetInt( "$vertexcolor", 1 );
+																	}
+																	if ( ALPHATEST )
+																	{
+																		pKeyValues->SetInt( "$alphatest", 1 );
+																	}
+																	if ( COLORMODULATE )
+																	{
+																		pKeyValues->SetString( "$color", "[1.0 0.8 0.5]" );
+																	}
+																	if ( ALPHAMODULATE )
+																	{
+																		pKeyValues->SetFloat( "$alpha", 0.6f );
+																	}
+
+																	// FIXME: ignoring fogtype for now.
+																	// hack hack - LEAK - need to figure out how to clear a material out.
+																	g_pProceduralMaterial = g_pMaterialSystem->CreateMaterial( "test", pKeyValues );
+																	g_pProceduralMaterial->Refresh();
+
+																	BeginFrame();
+																	DrawBackground();
+																	DrawQuad( g_CheckerboardLightmapInfo );
+																	EndFrame();
+																	char filename[MAX_PATH];
+																	sprintf( filename, "%s\\lightmappedgeneric_dx80", CommandLine()->ParmValue( "-targetdir" ) );
+																	
+																	if( BUMPMAP ) Q_strcat( filename, "_BUMPMAP", sizeof(filename) );
+																	if( NORMALMAPALPHAENVMAPMASK ) Q_strcat( filename, "_NORMALMAPALPHAENVMAPMASK", sizeof(filename) );
+
+																	if( BASETEXTURE ) Q_strcat( filename, "_BASE", sizeof(filename) );
+																	if( ENVMAPMASK ) Q_strcat( filename, "_ENVMAPMASK", sizeof(filename) );
+																	if( SELFILLUM ) Q_strcat( filename, "_SELFILLUM", sizeof(filename) );
+																	if( BASEALPHAENVMAPMASK ) Q_strcat( filename, "_BASEALPHAENVMAPMASK", sizeof(filename) );
+																	
+																	if( DETAIL ) Q_strcat( filename, "_DETAIL", sizeof(filename) );
+																	if( ENVMAP ) Q_strcat( filename, "_ENVMAP", sizeof(filename) );
+																	if( ENVMAPCAMERASPACE ) Q_strcat( filename, "_ENVMAPCAMERASPACE", sizeof(filename) );
+																	if( ENVMAPSPHERE ) Q_strcat( filename, "_ENVMAPSPHERE", sizeof(filename) );
+																	if( VERTEXCOLOR ) Q_strcat( filename, "_VERTEXCOLOR", sizeof(filename) );
+																	//							if( FOGTYPE ) Q_strcat( filename, "_FOGTYPE", sizeof(filename) );
+																	if( ALPHATEST ) Q_strcat( filename, "_ALPHATEST", sizeof(filename) );
+																	if( TRANSLUCENT ) Q_strcat( filename, "_TRANSLUCENT", sizeof(filename) );
+																	if( COLORMODULATE ) Q_strcat( filename, "_COLORMODULATE", sizeof(filename) );
+																	if( ALPHAMODULATE ) Q_strcat( filename, "_ALPHAMODULATE", sizeof(filename) );
+																	
+																	if( BUMPMAP ) Q_strcat( filename, "_BUMPMAP", sizeof(filename) );
+																	Q_strcat( filename, ".tga", sizeof(filename) );
+																	ScreenShot( filename );
+
+																	g_pProceduralMaterial->DecrementReferenceCount();
+																}
+															}
+														}
+													}
+												}
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Render a frame
+//-----------------------------------------------------------------------------
+
+void RenderFrame( void )
+{
+	TestLightmappedGeneric_dx80();
+}
+
+INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE hInstance, LPSTR pCommands, INT )
+{
+	SpewOutputFunc( SpewFunc );
+	CommandLine()->CreateCmdLine( ::GetCommandLine() );
+	InitDefaultFileSystem();
+
+	if( !CommandLine()->ParmValue( "-targetdir" ) )
+	{
+		Error( "Must specify -targetdir on command line!\n" );
+	}
+	
+	struct _stat statbuf;
+	if( 0 != _stat( CommandLine()->ParmValue( "-targetdir" ), &statbuf ) )
+	{
+		if( 0 != _mkdir( CommandLine()->ParmValue( "-targetdir" ) ) )
+		{
+			Error( "Couldn't create path %s\n", CommandLine()->ParmValue( "-targetdir" ) );
+		}
+	}
+
+	// Must add 'bin' to the path....
+	char* pPath = getenv("PATH");
+
+	// Use the .EXE name to determine the root directory
+	char moduleName[ MAX_PATH ];
+	char szBuffer[ 4096 ];
+	if ( !GetModuleFileName( hInstance, moduleName, MAX_PATH ) )
+	{
+		MessageBox( 0, "Failed calling GetModuleFileName", "Launcher Error", MB_OK );
+		return 0;
+	}
+
+	// Get the root directory the .exe is in
+	char* pRootDir = GetBaseDir( moduleName );
+
+#ifdef DBGFLAG_ASSERT
+	int len = 
+#endif
+
+	Q_snprintf( szBuffer, sizeof( szBuffer ), "PATH=%s;%s", pRootDir, pPath );
+	Assert( len < 4096 );
+	_putenv( szBuffer );
+		    
+	MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
+
+	if (!Init( pCommands ) )
+		return false;
+
+/*
+	bool done = false;
+	while( !done )
+	{
+		done = Update();
+	}
+	*/
+	RenderFrame();
+	Shutdown();
+
+    return 0;
+}
+