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.
551 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
source-engine/utils/matsys_regressiontest/matsys_regressiontest.cpp

1023 lines
30 KiB
Raw Permalink Blame History

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