1

utils/matsysapp/matsysapp.cpp

@@ -0,0 +1,960 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+/*
+
+  glapp.c - Simple OpenGL shell
+  
+	There are several options allowed on the command line.  They are:
+	-height : what window/screen height do you want to use?
+	-width  : what window/screen width do you want to use?
+	-bpp    : what color depth do you want to use?
+	-window : create a rendering window rather than full-screen
+	-fov    : use a field of view other than 90 degrees
+*/
+
+#include "stdafx.h"
+
+#pragma warning(disable:4305)
+#pragma warning(disable:4244)
+#include <windows.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <mmsystem.h>
+#include "matsysapp.h"
+#include "cmdlib.h"
+#include "mathlib/mathlib.h"
+#include "materialsystem/imaterialproxyfactory.h"
+#include "filesystem.h"
+#include "materialsystem/imaterialproxy.h"
+#include "materialsystem/MaterialSystem_Config.h"
+#include "tier0/icommandline.h"
+#include "filesystem_tools.h"
+#include "materialsystem/imesh.h"
+#include "vstdlib/cvar.h"
+
+
+static int g_nCapture = 0;
+
+
+#define OSR2_BUILD_NUMBER 1111
+#define M_PI		3.14159265358979323846	// matches value in gcc v2 math.h
+
+
+SpewRetval_t MatSysAppSpewFunc( SpewType_t type, char const *pMsg )
+{
+	printf( "%s", pMsg );
+	OutputDebugString( pMsg );
+
+	if( type == SPEW_ASSERT )
+		return SPEW_DEBUGGER;
+	else if( type == SPEW_ERROR )
+		return SPEW_ABORT;
+	else
+		return SPEW_CONTINUE;
+}
+
+
+class MatSysAppMaterialProxyFactory : public IMaterialProxyFactory
+{
+public:
+	virtual IMaterialProxy *CreateProxy( const char *proxyName )
+	{
+		CreateInterfaceFn clientFactory = Sys_GetFactoryThis();
+		if( !clientFactory )
+		{
+			return NULL;
+		}
+		// allocate exactly enough memory for the versioned name on the stack.
+		char proxyVersionedName[1024];
+		strcpy( proxyVersionedName, proxyName );
+		strcat( proxyVersionedName, IMATERIAL_PROXY_INTERFACE_VERSION );
+
+		IMaterialProxy *materialProxy;
+		materialProxy = ( IMaterialProxy * )clientFactory( proxyVersionedName, NULL );
+		if( !materialProxy )
+		{
+			return NULL;
+		}
+		
+		return materialProxy;
+	}
+
+	virtual void DeleteProxy( IMaterialProxy *pProxy )
+	{
+		if( pProxy )
+		{
+			pProxy->Release();
+		}
+	}
+};
+MatSysAppMaterialProxyFactory	g_MatSysAppMaterialProxyFactory;
+
+
+MaterialSystemApp	g_MaterialSystemApp;
+
+float       fAngle = 0.0f;
+
+char       *szFSDesc[] = { "Windowed", "Full Screen" };
+
+extern "C" unsigned int g_Time;
+unsigned int g_Time = 0;
+
+
+
+int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
+{
+	return g_MaterialSystemApp.WinMain(hInstance, hPrevInstance, szCmdLine, iCmdShow);
+}
+
+  
+
+BOOL isdigits( char *s )
+{
+   int i;
+   
+   for (i = 0; s[i]; i++)
+   {
+	   if ((s[i] > '9') || (s[i] < '0'))
+       {
+		   return FALSE;
+       }
+   }
+   return TRUE;
+}
+
+
+LRESULT CALLBACK WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
+{
+	return g_MaterialSystemApp.WndProc(hwnd, iMsg, wParam, lParam);
+}
+
+// This function builds a list the screen resolutions supported by the display driver
+static void BuildModeList(screen_res_t* &pResolutions, int &iResCount)
+{
+   DEVMODE  dm;
+   int      mode;
+   
+   mode = 0;
+   while(EnumDisplaySettings(NULL, mode, &dm))
+   {
+	   mode++;
+   }
+   
+   pResolutions = (screen_res_t *)malloc(sizeof(screen_res_t)*mode);
+   mode = 0;
+   while(EnumDisplaySettings(NULL, mode, &dm))
+   {
+	   pResolutions[mode].width = dm.dmPelsWidth;
+	   pResolutions[mode].height = dm.dmPelsHeight;
+	   pResolutions[mode].bpp = dm.dmBitsPerPel;
+	   pResolutions[mode].flags = dm.dmDisplayFlags;
+	   pResolutions[mode].frequency = dm.dmDisplayFrequency;
+	   mode++;
+   }
+   iResCount = mode;
+}
+
+
+bool Sys_Error(const char *pMsg, ...)
+{
+	va_list marker;
+	char msg[4096];
+	
+	va_start(marker, pMsg);
+	vsprintf(msg, pMsg, marker);
+	va_end(marker);
+
+	MessageBox(NULL, msg, "FATAL ERROR", MB_OK);
+
+	g_MaterialSystemApp.Term();
+	exit(1);
+	return false;
+}
+
+
+void con_Printf(const char *pMsg, ...)
+{
+	char msg[2048];
+	va_list marker;
+
+	va_start(marker, pMsg);
+	vsprintf(msg, pMsg, marker);
+	va_end(marker);
+
+	OutputDebugString(msg);
+}
+
+
+bool MSA_IsKeyDown(char key)
+{
+	return !!(GetAsyncKeyState(key) & 0x8000);
+}
+
+
+bool MSA_IsMouseButtonDown( int button )
+{
+	if( button == MSA_BUTTON_LEFT )
+		return !!(GetAsyncKeyState(VK_LBUTTON) & 0x8000);
+	else
+		return !!(GetAsyncKeyState(VK_RBUTTON) & 0x8000);
+}
+
+
+void MSA_Sleep(unsigned long count)
+{
+	if(count > 0)
+		Sleep(count);
+}
+
+
+static void MaterialSystem_Error( char *fmt, ... )
+{
+	char str[4096];
+	va_list marker;
+	
+	va_start(marker, fmt);
+	vsprintf(str, fmt, marker);
+	va_end(marker);
+	
+	Sys_Error(str);
+}
+
+
+static void MaterialSystem_Warning( char *fmt, ... )
+{
+}
+
+
+void InitMaterialSystemConfig(MaterialSystem_Config_t *pConfig)
+{
+	memset( pConfig, 0, sizeof(*pConfig) );
+//	pConfig->screenGamma = 2.2f;
+//	pConfig->texGamma = 2.2;
+//	pConfig->overbright = 2;
+	pConfig->bAllowCheats = false;
+//	pConfig->bLinearFrameBuffer = false;
+	pConfig->skipMipLevels = 0;
+//	pConfig->lightScale = 1.0f;
+	pConfig->bFilterLightmaps = true;
+	pConfig->bFilterTextures = true;
+	pConfig->bMipMapTextures = true;
+	pConfig->nShowMipLevels = 0;
+	pConfig->bReverseDepth = false;
+	pConfig->bCompressedTextures = true;
+//	pConfig->bBumpmap = true;
+	pConfig->bShowSpecular = true;
+	pConfig->bShowDiffuse = true;
+//	pConfig->maxFrameLatency = 1;
+	pConfig->bDrawFlat = false;
+//	pConfig->bLightingOnly = false;
+	pConfig->bSoftwareLighting = false;
+	pConfig->bEditMode = false;	// No, we're not in WorldCraft.
+//	pConfig->m_bForceTrilinear = false;
+	pConfig->m_nForceAnisotropicLevel = 0;
+//	pConfig->m_bForceBilinear = false;
+}
+
+
+/*
+====================
+CalcFov
+====================
+*/
+float CalcFov (float fov_x, float width, float height)
+{
+	float	a;
+	float	x;
+
+	if (fov_x < 1 || fov_x > 179)
+		fov_x = 90;	// error, set to 90
+
+	x = width/tan(fov_x/360*M_PI);
+
+	a = atan (height/x);
+
+	a = a*360/M_PI;
+
+	return a;
+}
+
+
+MaterialSystemApp::MaterialSystemApp()
+{
+	Clear();
+}
+
+MaterialSystemApp::~MaterialSystemApp()
+{
+	Term();
+}
+
+void MaterialSystemApp::Term()
+{
+   int i;
+
+   // Free the command line holder memory
+   if (m_argc > 0)
+   {
+	   // Free in reverse order of allocation
+	   for (i = (m_argc-1); i >= 0; i--)
+       {
+		   free(m_argv[i]);
+       }
+	   // Free the parameter "pockets"
+	   free(m_argv);
+   }
+	
+  
+   // Free the memory that holds the video resolution list
+   if (m_pResolutions)
+	   free(m_pResolutions);
+
+   if (m_hDC)
+   {
+	   if (!ReleaseDC((HWND)m_hWnd, (HDC)m_hDC))
+       {
+		   MessageBox(NULL, "ShutdownOpenGL - ReleaseDC failed\n", "ERROR", MB_OK);
+       }
+	   m_hDC   = NULL;
+   }
+   if (m_bFullScreen)
+   {
+	   ChangeDisplaySettings( 0, 0 );
+   }
+
+	Clear();
+}
+
+void MaterialSystemApp::Clear()
+{
+	m_pMaterialSystem = NULL;
+	m_hMaterialSystemInst = 0;
+	m_hInstance = 0;
+	m_iCmdShow = 0;
+	m_hWnd = 0;
+	m_hDC = 0;
+	m_bActive = false;
+	m_bFullScreen = false;
+	m_width = m_height = 0;
+	m_centerx = m_centery = 0;
+	m_bpp = 0;
+	m_bChangeBPP = false;
+	m_bAllowSoft = 0;
+	g_nCapture = 0;
+	m_szCmdLine = 0;
+	m_argc = 0;
+	m_argv = 0;
+	m_glnWidth = 0;
+	m_glnHeight = 0;
+	m_gldAspect = 0;
+	m_NearClip = m_FarClip = 0;
+	m_fov = 90;
+	m_pResolutions = 0;
+	m_iResCount = 0;
+	m_iVidMode = 0;
+}
+
+int MaterialSystemApp::WinMain(void *hInstance, void *hPrevInstance, char *szCmdLine, int iCmdShow)
+{
+	MSG         msg;
+    HDC         hdc;
+	memset(&msg,0,sizeof(msg));
+	CommandLine()->CreateCmdLine( Plat_GetCommandLine() );
+
+    // Not changable by user
+    m_hInstance    = hInstance;
+    m_iCmdShow     = iCmdShow;
+    m_pResolutions = 0;
+    m_NearClip     = 8.0f;
+    m_FarClip      = 28400.0f;
+	
+    // User definable
+    m_fov          = 90.0f;
+    m_bAllowSoft   = FALSE;
+    m_bFullScreen  = TRUE;
+	
+    // Get the current display device info
+    hdc = GetDC( NULL );
+    m_DevInfo.bpp    = GetDeviceCaps(hdc, BITSPIXEL);
+    m_DevInfo.width  = GetSystemMetrics(SM_CXSCREEN);
+    m_DevInfo.height = GetSystemMetrics(SM_CYSCREEN);
+    ReleaseDC(NULL, hdc);
+	
+    // Parse the command line if there is one
+    m_argc = 0;
+    if (strlen(szCmdLine) > 0)
+	{
+        m_szCmdLine = szCmdLine;
+        GetParameters();
+	}
+	
+    // Default to 640 pixels wide
+    m_width  = FindNumParameter("-width", 640);
+    m_height = FindNumParameter("-height", 480);
+    m_bpp    = FindNumParameter("-bpp", 32);
+    m_fov    = FindNumParameter("-fov", 90);
+	
+    // Check for windowed rendering
+    m_bFullScreen = FALSE;
+    if (FindParameter("-fullscreen"))
+	{
+        m_bFullScreen = TRUE;
+	}
+	
+    // Build up the video mode list
+    BuildModeList(m_pResolutions, m_iResCount);
+	
+    // Create the main program window, start up OpenGL and create our viewport
+    if (CreateMainWindow( m_width, m_height, m_bpp, m_bFullScreen) != TRUE)
+	{
+        ChangeDisplaySettings(0, 0);
+        MessageBox(NULL, "Unable to create main window.\nProgram will now end.", "FATAL ERROR", MB_OK);
+        Term();
+        return 0;
+	}
+
+    // Turn the cursor off for full-screen mode
+    if (m_bFullScreen == TRUE)
+	{ 
+		// Probably want to do this all the time anyway
+        ShowCursor(FALSE);
+	}
+
+    // We're live now
+    m_bActive = TRUE;
+	
+	// Define this funciton to init your app
+	AppInit();
+
+
+	RECT rect;
+	GetWindowRect( (HWND)m_hWnd, &rect );
+
+	m_centerx = ( rect.left + rect.right ) / 2;
+	m_centery = ( rect.top + rect.bottom ) / 2;
+
+
+    // Begin the main program loop
+    while (m_bActive == TRUE)
+	{
+        while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
+		{
+            TranslateMessage (&msg);
+            DispatchMessage (&msg);
+		}
+        
+		if (m_pMaterialSystem)
+		{
+            RenderScene();
+		}
+	}
+    if (m_bFullScreen == TRUE)
+	{
+        ShowCursor(TRUE);
+	}
+    
+	// Release the parameter and video resolution lists
+	Term();
+	
+	// Tell the app to cleanup.
+	AppExit();
+    return msg.wParam;
+}
+
+
+long MaterialSystemApp::WndProc(void *inhwnd, long iMsg, long wParam, long lParam)
+{
+	if(inhwnd != m_hWnd)
+	{
+		return DefWindowProc((HWND)inhwnd, iMsg, wParam, lParam);
+	}
+
+	HWND hwnd = (HWND)inhwnd;
+	
+	switch (iMsg)
+	{
+		case WM_CHAR:
+			switch(wParam)
+			{
+			case VK_ESCAPE:
+				SendMessage(hwnd, WM_CLOSE, 0, 0);
+				break;
+			}
+			AppChar( wParam );
+		break;
+
+		case WM_KEYDOWN:
+			AppKey( wParam, true );
+			break;
+		case WM_KEYUP:
+			AppKey( wParam, false );
+			break;
+
+		
+		case WM_ACTIVATE:
+			if ((LOWORD(wParam) != WA_INACTIVE) && ((HWND)lParam == NULL))
+			{
+				ShowWindow(hwnd, SW_RESTORE);
+				SetForegroundWindow(hwnd);
+			}
+			else
+			{
+				if (m_bFullScreen)
+				{
+					ShowWindow(hwnd, SW_MINIMIZE);
+				}
+			}
+			return 0;
+			
+		case WM_SETFOCUS:
+			if(g_bCaptureOnFocus)
+			{
+				MouseCapture();
+			}
+			break;
+
+		case WM_KILLFOCUS:
+			if(g_bCaptureOnFocus)
+			{
+				MouseRelease();
+			}
+			break;
+
+		case WM_LBUTTONDOWN:
+		case WM_RBUTTONDOWN:
+		{
+			if(!g_bCaptureOnFocus)
+			{
+				g_nCapture++;
+				MouseCapture();
+			}
+		}
+		break;
+
+		case WM_LBUTTONUP:
+		case WM_RBUTTONUP:
+		{
+			if(!g_bCaptureOnFocus)
+			{
+				g_nCapture--;
+				MouseRelease();
+			}
+		}
+		break;
+
+		case WM_CLOSE:
+			Term();
+			m_bActive = FALSE;
+			break;
+			
+		case WM_DESTROY:
+			PostQuitMessage (0);
+			return 0;
+	}
+   
+   return DefWindowProc (hwnd, iMsg, wParam, lParam);
+}
+
+
+bool MaterialSystemApp::InitMaterialSystem()
+{
+	RECT rect;
+
+	// Init libraries.
+	MathLib_Init( true, true, true, 2.2f, 2.2f, 0.0f, 2.0f );
+	SpewOutputFunc( MatSysAppSpewFunc );
+	
+	if ((m_hDC = GetDC((HWND)m_hWnd)) == NULL)
+	{
+		ChangeDisplaySettings(0, 0);
+		MessageBox(NULL, "GetDC on main window failed", "FATAL ERROR", MB_OK);
+		return FALSE;
+	}
+	
+	// Load the material system DLL and get its interface.
+	char *pDLLName = "MaterialSystem.dll";
+	m_hMaterialSystemInst = LoadLibrary( pDLLName );
+	if( !m_hMaterialSystemInst )
+	{
+		return Sys_Error( "Can't load MaterialSystem.dll\n" );
+	}
+
+	CreateInterfaceFn clientFactory = Sys_GetFactory( pDLLName );
+	if ( clientFactory )
+	{
+		m_pMaterialSystem = (IMaterialSystem *)clientFactory( MATERIAL_SYSTEM_INTERFACE_VERSION, NULL );
+		if ( !m_pMaterialSystem )
+		{
+			return Sys_Error( "Could not get the material system interface from materialsystem.dll" );
+		}
+	}
+	else
+	{
+		return Sys_Error( "Could not find factory interface in library MaterialSystem.dll" );
+	}
+
+	const char *pPath = CommandLine()->ParmValue("-game");
+	if(!pPath)
+	{
+		// If they didn't specify -game on the command line, use VPROJECT.
+		CmdLib_InitFileSystem( "." );
+		pPath = ".";
+	}
+	else
+	{
+		CmdLib_InitFileSystem( pPath );
+	}
+	// BUGBUG: Can't figure out why this is broken.  EXECUTABLE_PATH should already be there
+	// but it isn't so the shader system is computing texture memory on each run...
+	g_pFullFileSystem->AddSearchPath( "U:\\main\\game\\bin", "EXECUTABLE_PATH", PATH_ADD_TO_TAIL );
+
+	const char *pShaderDLL = FindParameterArg("-shaderdll");
+	char defaultShaderDLL[256];
+	if(!pShaderDLL)
+	{
+		strcpy(defaultShaderDLL, "shaderapidx9.dll");
+		pShaderDLL = defaultShaderDLL;
+	}
+
+	if(!m_pMaterialSystem->Init(pShaderDLL, &g_MatSysAppMaterialProxyFactory, CmdLib_GetFileSystemFactory()))
+		return Sys_Error("IMaterialSystem::Init failed");
+
+	MaterialSystem_Config_t config;
+	InitMaterialSystemConfig(&config);
+	config.SetFlag( MATSYS_VIDCFG_FLAGS_WINDOWED, true ); 
+	config.SetFlag( MATSYS_VIDCFG_FLAGS_RESIZING, true ); 
+
+	if(!m_pMaterialSystem->SetMode(m_hWnd, config))
+		return Sys_Error("IMaterialSystem::SetMode failed");
+
+	m_pMaterialSystem->OverrideConfig(config, false);
+	GetClientRect((HWND)m_hWnd, &rect);
+	m_glnWidth= rect.right;
+	m_glnHeight = rect.bottom;
+	m_gldAspect = (float)m_glnWidth / m_glnHeight;
+
+	GetWindowRect( (HWND)m_hWnd, &rect );
+	m_centerx = (rect.left + rect.right) / 2;
+	m_centery = (rect.top + rect.bottom) / 2;
+	
+	return true;
+}
+
+
+bool MaterialSystemApp::CreateMainWindow(int width, int height, int bpp, bool fullscreen)
+{
+   HWND        hwnd;
+   WNDCLASSEX  wndclass;
+   DWORD       dwStyle, dwExStyle;
+   int         x, y, sx, sy, ex, ey, ty;
+   
+   if ((hwnd = FindWindow(g_szAppName, g_szAppName)) != NULL)
+   {
+	   SetForegroundWindow(hwnd);
+	   return 0;
+   }
+   
+   wndclass.cbSize        = sizeof (wndclass);
+   wndclass.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
+   wndclass.lpfnWndProc   = ::WndProc;
+   wndclass.cbClsExtra    = 0;
+   wndclass.cbWndExtra    = 0;
+   wndclass.hInstance     = (HINSTANCE)m_hInstance;
+   wndclass.hIcon         = 0;
+   wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
+   wndclass.hbrBackground = (HBRUSH)COLOR_GRAYTEXT;
+   wndclass.lpszMenuName  = NULL;
+   wndclass.lpszClassName = g_szAppName;
+   wndclass.hIconSm       = 0;
+   
+   
+   if (!RegisterClassEx (&wndclass))
+   {
+	   MessageBox(NULL, "Window class registration failed.", "FATAL ERROR", MB_OK);
+	   return FALSE;
+   }
+   
+   if (fullscreen)
+   {
+	   dwExStyle = WS_EX_TOPMOST;
+	   dwStyle = WS_POPUP | WS_VISIBLE;
+	   x = y = 0;
+	   sx = m_width;
+	   sy = m_height;
+   }
+   else
+   {
+	   dwExStyle = 0;
+	   //dwStyle = WS_CAPTION | WS_SYSMENU | WS_THICKFRAME;  // Use this if you want a "normal" window
+	   dwStyle = WS_CAPTION;
+	   ex = GetSystemMetrics(SM_CXEDGE);
+	   ey = GetSystemMetrics(SM_CYEDGE);
+	   ty = GetSystemMetrics(SM_CYSIZE);
+	   // Center the window on the screen
+	   x = (m_DevInfo.width / 2) - ((m_width+(2*ex)) / 2);
+	   y = (m_DevInfo.height / 2) - ((m_height+(2*ey)+ty) / 2);
+	   sx = m_width+(2*ex);
+	   sy = m_height+(2*ey)+ty;
+	   /*
+       Check to be sure the requested window size fits on the screen and
+       adjust each dimension to fit if the requested size does not fit.
+	   */
+	   if (sx >= m_DevInfo.width)
+       {
+		   x = 0;
+		   sx = m_DevInfo.width-(2*ex);
+       }
+	   if (sy >= m_DevInfo.height)
+       {
+		   y = 0;
+		   sy = m_DevInfo.height-((2*ey)+ty);
+       }
+   }
+   
+   if ((hwnd = CreateWindowEx (dwExStyle,
+	   g_szAppName,               // window class name
+	   g_szAppName,                // window caption
+	   dwStyle | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, // window style
+	   x,           // initial x position
+	   y,           // initial y position
+	   sx,           // initial x size
+	   sy,           // initial y size
+	   NULL,                    // parent window handle
+	   NULL,                    // window menu handle
+	   (HINSTANCE)m_hInstance,       // program instance handle
+	   NULL))                   // creation parameters
+	   == NULL)
+   {
+	   ChangeDisplaySettings(0, 0);
+	   MessageBox(NULL, "Window creation failed.", "FATAL ERROR", MB_OK);
+	   return FALSE;
+   }
+   
+   m_hWnd = hwnd;
+   
+   if (!InitMaterialSystem())
+   {
+	   m_hWnd = NULL;
+	   return FALSE;
+   }
+   
+   ShowWindow((HWND)m_hWnd, m_iCmdShow);
+   UpdateWindow((HWND)m_hWnd);
+   
+   SetForegroundWindow((HWND)m_hWnd);
+   SetFocus((HWND)m_hWnd);
+   
+   return TRUE;
+}
+
+
+void MaterialSystemApp::RenderScene()
+{
+	if(!m_pMaterialSystem)
+		return;
+
+	static DWORD lastTime = 0;
+	POINT cursorPoint;
+	float deltax = 0, deltay = 0, frametime;
+
+	DWORD newTime = GetTickCount();
+	DWORD deltaTime = newTime - lastTime;
+
+	if ( deltaTime > 1000 )
+		deltaTime = 0;
+	
+	lastTime = newTime;
+	frametime = (float) ((double)deltaTime * 0.001);
+	g_Time = newTime;
+
+	if ( g_nCapture )
+	{
+		GetCursorPos( &cursorPoint );
+		SetCursorPos( m_centerx, m_centery );
+
+		deltax = (cursorPoint.x - m_centerx) * 0.1f;
+		deltay = (cursorPoint.y - m_centery) * -0.1f;
+	}
+	else
+	{
+		deltax = deltay = 0;
+	}
+
+	CMatRenderContextPtr pRenderContext(m_pMaterialSystem);
+	m_pMaterialSystem->BeginFrame(deltaTime);
+
+	pRenderContext->ClearBuffers(true, true);
+	pRenderContext->Viewport( 0, 0, m_width, m_height );
+	pRenderContext->MatrixMode(MATERIAL_PROJECTION);
+	pRenderContext->LoadIdentity();
+	pRenderContext->PerspectiveX(m_fov, m_gldAspect, m_NearClip, m_FarClip);
+
+	pRenderContext->MatrixMode(MATERIAL_VIEW);
+	pRenderContext->LoadIdentity();
+
+	pRenderContext->MatrixMode(MATERIAL_MODEL);
+	pRenderContext->LoadIdentity();
+
+	AppRender( frametime, deltax, deltay );
+
+    m_pMaterialSystem->SwapBuffers();
+
+	m_pMaterialSystem->EndFrame();
+}
+
+
+void MaterialSystemApp::MouseCapture()
+{
+	SetCapture( (HWND)m_hWnd );
+    ShowCursor(FALSE);
+	SetCursorPos( m_centerx, m_centery );
+}
+
+
+void MaterialSystemApp::MouseRelease()
+{
+    ShowCursor(TRUE);
+	ReleaseCapture();
+	
+	SetCursorPos( m_centerx, m_centery );
+}
+
+
+void MaterialSystemApp::GetParameters()
+{
+   int   count;
+   char *s, *tstring;
+   
+   // Make a copy of the command line to count the parameters - strtok is destructive
+   tstring = (char *)malloc(sizeof(char)*(strlen(m_szCmdLine)+1));
+   strcpy(tstring, m_szCmdLine);
+   
+   // Count the parameters
+   s = strtok(tstring, " ");
+   count = 1;
+   while (strtok(NULL, " ") != NULL)
+   {
+	   count++;
+   }
+   free(tstring);
+   
+   // Allocate "pockets" for the parameters
+   m_argv = (char **)malloc(sizeof(char*)*(count+1));
+   
+   // Copy first parameter into the "pockets"
+   m_argc = 0;
+   s = strtok(m_szCmdLine, " ");
+   m_argv[m_argc] = (char *)malloc(sizeof(char)*(strlen(s)+1));
+   strcpy(m_argv[m_argc], s);
+   m_argc++;
+   
+   // Copy the rest of the parameters
+   do
+   {
+	   // get the next token
+	   s = strtok(NULL, " ");
+	   if (s != NULL)
+       { 
+		   // add it to the list
+		   m_argv[m_argc] = (char *)malloc(sizeof(char)*(strlen(s)+1));
+		   strcpy(m_argv[m_argc], s);
+		   m_argc++;
+       }
+   }
+   while (s != NULL);
+}
+
+
+int MaterialSystemApp::FindNumParameter(const char *s, int defaultVal)
+{
+   int i;
+   
+   for (i = 0; i < (m_argc-1); i++)
+   {
+	   if (stricmp(m_argv[i], s) == 0)
+       {
+		   if (isdigits(m_argv[i+1]))
+           {
+			   return(atoi(m_argv[i+1]));
+           }
+		   else
+           {
+			   return defaultVal;
+           }
+       }
+   }
+   return defaultVal;
+}
+
+
+bool MaterialSystemApp::FindParameter(const char *s)
+{
+   int i;
+   
+   for (i = 0; i < m_argc; i++)
+   {
+	   if (stricmp(m_argv[i], s) == 0)
+       {
+		   return true;
+       }
+   }
+   return false;
+}
+
+
+const char *MaterialSystemApp::FindParameterArg( const char *s )
+{
+   int i;
+   
+   for (i = 0; i < m_argc; i++)
+   {
+	   if (stricmp(m_argv[i], s) == 0)
+       {
+		   if( (i+1) < m_argc )
+			   return m_argv[i+1];
+			else
+				return "";
+       }
+   }
+   return NULL;
+}
+
+
+void MaterialSystemApp::SetTitleText(const char *fmt, ...)
+{
+	char str[4096];
+	va_list marker;
+
+	va_start(marker, fmt);
+	vsprintf(str, fmt, marker);
+	va_end(marker);
+
+	::SetWindowText((HWND)m_hWnd, str);
+}
+
+
+void MaterialSystemApp::MakeWindowTopmost()
+{
+	::SetWindowPos((HWND)m_hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
+}
+
+
+void MaterialSystemApp::AppShutdown()
+{
+	SendMessage( (HWND)m_hWnd, WM_CLOSE, 0, 0 );
+}
+
+
+void MaterialSystemApp::QuitNextFrame()
+{
+	PostMessage( (HWND)m_hWnd, WM_CLOSE, 0, 0 );
+}
+
+

utils/matsysapp/matsysapp.h

@@ -0,0 +1,171 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef GLAPP_H
+#define GLAPP_H
+#pragma once
+
+
+class CSysModule;
+
+
+// Mouse button identifiers.
+#define MSA_BUTTON_LEFT		0
+#define MSA_BUTTON_RIGHT	1
+
+
+typedef struct
+{
+    int   width;
+    int   height;
+    int   bpp;
+    int   flags;
+    int   frequency;
+} screen_res_t;
+
+
+
+typedef struct
+{
+    int  width;
+    int  height;
+    int  bpp;
+} devinfo_t;
+
+
+
+class MaterialSystemApp
+{
+public:
+
+					MaterialSystemApp();
+					~MaterialSystemApp();
+
+	void			Term();
+	void			QuitNextFrame();
+
+	// Post a message to shutdown the app.
+	void			AppShutdown();
+
+	int				WinMain(void *hInstance, void *hPrevInstance, char *szCmdLine, int iCmdShow);
+	long			WndProc(void *hwnd, long iMsg, long wParam, long lParam);
+
+	int				FindNumParameter(const char *s, int defaultVal=-1);
+	bool			FindParameter(const char *s);
+	const char*		FindParameterArg(const char *s);
+
+	void			SetTitleText(PRINTF_FORMAT_STRING const char *fmt, ...);
+
+	// Make the matsysapp window the top window.
+	void			MakeWindowTopmost();
+
+	void			MouseCapture();
+	void			MouseRelease();
+
+
+private:
+
+	bool			InitMaterialSystem();
+	void			Clear();
+
+	bool			CreateMainWindow(int width, int height, int bpp, bool fullscreen);
+
+	void			RenderScene();
+
+	void			GetParameters();
+
+
+public:
+    IMaterialSystem	*m_pMaterialSystem;
+	void			*m_hMaterialSystemInst;
+
+	devinfo_t		m_DevInfo;
+
+	void			*m_hInstance;
+    int				m_iCmdShow;
+    void			*m_hWnd;
+	void			*m_hDC;
+    bool			m_bActive;
+    bool             m_bFullScreen;
+    int              m_width;
+    int              m_height;
+	int				 m_centerx;		// for mouse offset calculations
+	int				 m_centery;
+    int              m_bpp;
+    bool             m_bChangeBPP;
+    bool             m_bAllowSoft;
+    char            *m_szCmdLine;
+    int              m_argc;
+    char           **m_argv;
+    int              m_glnWidth;
+    int              m_glnHeight;
+    float            m_gldAspect;
+    float            m_NearClip;
+    float            m_FarClip;
+    float            m_fov;
+    
+    screen_res_t    *m_pResolutions;
+	int              m_iResCount;
+
+    int              m_iVidMode;
+};
+
+
+// ---------------------------------------------------------------------------------------- //
+// The app needs to define these symbols.
+// ---------------------------------------------------------------------------------------- //
+// g_szAppName[]			-- char array applicaton name
+// void AppInit( void )		-- Called at init time
+// void AppRender( void )	-- Called each frame (as often as possible)
+// void AppExit( void )		-- Called to shut down
+// void AppKey( int key, int down ); -- called on each key up/down
+// void AppChar( int key ); -- key was pressed & released
+extern "C" char g_szAppName[];
+extern "C" void AppInit( void );
+extern "C" void AppRender( float frametime, float mouseDeltaX, float mouseDeltaY );
+extern "C" void AppExit( void );
+extern "C" void AppKey( int key, int down );
+extern "C" void AppChar( int key );
+extern bool g_bCaptureOnFocus;	// The app needs to define this to control how matsysapp handles mouse cursor hiding.
+								// If it's set to true, the mouse is captured and hidden when the app gets focus.
+								// If false, the mouse is only captured and hidden while the left button is down.
+
+
+// ---------------------------------------------------------------------------------------- //
+// Global functions (MSA stands for Material System App)..
+// ---------------------------------------------------------------------------------------- //
+
+// Show an error dialog and quit.
+bool Sys_Error(PRINTF_FORMAT_STRING const char *pMsg, ...);
+
+// Print to the trace window.
+void con_Printf(PRINTF_FORMAT_STRING const char *pMsg, ...);
+
+// Returns true if the key is down.
+bool MSA_IsKeyDown(char key);
+
+// Sleep for the specified number of milliseconds... passing 0 does nothing.
+void MSA_Sleep(unsigned long countMS);
+
+// Returns true if the specified button is down.
+// button should be one of the MSA_BUTTON identifiers.
+bool MSA_IsMouseButtonDown( int button );
+
+
+extern MaterialSystemApp	g_MaterialSystemApp;
+
+
+extern unsigned int g_Time;
+
+
+#endif // GLAPP_H