Updated the SDK with the latest code from the TF and HL2 branches.HEADmaster

124 files changed, 3633 insertions, 7159 deletions

diff --git a/mp/src/public/SoundEmitterSystem/isoundemittersystembase.h b/mp/src/public/SoundEmitterSystem/isoundemittersystembase.h
index 9cb6ee6a..77fbf0da 100644
--- a/mp/src/public/SoundEmitterSystem/isoundemittersystembase.h
+++ b/mp/src/public/SoundEmitterSystem/isoundemittersystembase.h
@@ -264,6 +264,9 @@ public:
 	virtual soundlevel_t	LookupSoundLevelByHandle( char const *soundname, HSOUNDSCRIPTHANDLE& handle ) = 0;
 
 	virtual void			ReloadSoundEntriesInList( IFileList *pFilesToReload ) = 0;
+
+	// Called by either client or server to force ModShutdown and ModInit
+	virtual void			Flush() = 0;
 };
 
 #endif // ISOUNDEMITTERSYSTEMBASE_H
diff --git a/mp/src/public/UtlCachedFileData.h b/mp/src/public/UtlCachedFileData.h
index d7b0bc46..4420c21b 100644
--- a/mp/src/public/UtlCachedFileData.h
+++ b/mp/src/public/UtlCachedFileData.h
@@ -461,7 +461,7 @@ void CUtlCachedFileData<T>::InitSmallBuffer( FileHandle_t& fh, int fileSize, boo
 
 					// Read the element name
 					char elementFileName[ 512 ];
-					buf.GetString( elementFileName, sizeof( elementFileName ) );
+					buf.GetString( elementFileName );
 
 					// Now read the element
 					int slot = GetIndex( elementFileName );
@@ -561,7 +561,7 @@ void CUtlCachedFileData<T>::InitLargeBuffer( FileHandle_t& fh, bool& deleteFile
 
 					// Read the element name
 					char elementFileName[ 512 ];
-					buf.GetString( elementFileName, sizeof( elementFileName ) );
+					buf.GetString( elementFileName );
 
 					// Now read the element
 					int slot = GetIndex( elementFileName );
@@ -682,7 +682,7 @@ void CUtlCachedFileData<T>::Save()
 	fh = g_pFullFileSystem->Open( m_sRepositoryFileName, "wb" );
 	if ( FILESYSTEM_INVALID_HANDLE == fh )
 	{
-		Warning( "Unable to persist cache '%s', check file permissions\n", m_sRepositoryFileName.String() );
+		ExecuteNTimes( 25, Warning( "Unable to persist cache '%s', check file permissions\n", m_sRepositoryFileName.String() ) );
 	}
 	else
 	{
diff --git a/mp/src/public/VGuiMatSurface/IMatSystemSurface.h b/mp/src/public/VGuiMatSurface/IMatSystemSurface.h
index 7e9d90fe..8d76b805 100644
--- a/mp/src/public/VGuiMatSurface/IMatSystemSurface.h
+++ b/mp/src/public/VGuiMatSurface/IMatSystemSurface.h
@@ -108,6 +108,13 @@ public:
 
 	virtual void GetFullscreenViewportAndRenderTarget( int & x, int & y, int & w, int & h, ITexture **ppRenderTarget ) = 0;
 	virtual void SetFullscreenViewportAndRenderTarget( int x, int y, int w, int h, ITexture *pRenderTarget ) = 0;
+
+	// get texture id for a texture
+	virtual int  DrawGetTextureId( ITexture *pTexture ) = 0;
+
+	// begin and end skin composition painting
+	virtual void BeginSkinCompositionPainting() = 0;
+	virtual void EndSkinCompositionPainting() = 0;
 };
 
 
diff --git a/mp/src/public/appframework/ilaunchermgr.h b/mp/src/public/appframework/ilaunchermgr.h
index 2498ab36..4b433ad8 100644
--- a/mp/src/public/appframework/ilaunchermgr.h
+++ b/mp/src/public/appframework/ilaunchermgr.h
@@ -16,13 +16,8 @@
 #include "appframework/IAppSystem.h"
 
 #if defined( DX_TO_GL_ABSTRACTION )
-	#if defined( LINUX ) || defined( _WIN32 )
-		#include "togl/linuxwin/glmgrbasics.h"
-		#include "togl/linuxwin/glmdisplay.h"
-	#elif defined( OSX )
-		#include "togl/osx/glmgrbasics.h"
-		#include "togl/osx/glmdisplay.h"
-	#endif
+#include "togl/linuxwin/glmgrbasics.h"
+#include "togl/linuxwin/glmdisplay.h"
 
 class GLMDisplayDB;
 class CShowPixelsParams;
diff --git a/mp/src/public/bitmap/imageformat.h b/mp/src/public/bitmap/imageformat.h
index 1a35cab1..3e8f7b13 100644
--- a/mp/src/public/bitmap/imageformat.h
+++ b/mp/src/public/bitmap/imageformat.h
@@ -100,6 +100,9 @@ enum ImageFormat
 	IMAGE_FORMAT_LE_BGRA8888,
 #endif
 
+	IMAGE_FORMAT_DXT1_RUNTIME,
+	IMAGE_FORMAT_DXT5_RUNTIME,
+
 	NUM_IMAGE_FORMATS
 };
 
@@ -448,6 +451,9 @@ namespace ImageLoader
 							   int height,	int depth, ImageFormat imageFormat, float srcGamma, float dstGamma, 
 							   int numLevels = 0 );
 
+	// Low quality mipmap generation, but way faster. 
+	void GenerateMipmapLevelsLQ( unsigned char* pSrc, unsigned char* pDst, int width, int height, 
+		                         ImageFormat imageFormat, int numLevels );
 
 	//-----------------------------------------------------------------------------
 	// operations on square images (src and dst can be the same)
@@ -511,6 +517,10 @@ namespace ImageLoader
 		return ( info.m_NumRedBits > 8 || info.m_NumGreeBits > 8 || info.m_NumBlueBits > 8 || info.m_NumAlphaBits > 8 );
 	}
 
+	inline bool IsRuntimeCompressed( ImageFormat fmt )
+	{
+		return ( fmt == IMAGE_FORMAT_DXT1_RUNTIME ) || ( fmt == IMAGE_FORMAT_DXT5_RUNTIME );
+	}
 
 } // end namespace ImageLoader
 
diff --git a/mp/src/public/bspfile.h b/mp/src/public/bspfile.h
index 21d9f375..d4c3a059 100644
--- a/mp/src/public/bspfile.h
+++ b/mp/src/public/bspfile.h
@@ -376,7 +376,9 @@ struct lump_t
 	DECLARE_BYTESWAP_DATADESC();
 	int		fileofs, filelen;
 	int		version;		// default to zero
-	char	fourCC[4];		// default to ( char )0, ( char )0, ( char )0, ( char )0
+	// this field was char fourCC[4] previously, but was unused, favoring the LUMP IDs above instead. It has been
+	// repurposed for compression.  0 implies the lump is not compressed.
+	int		uncompressedSize; // default to zero
 };
 
 
@@ -384,7 +386,7 @@ struct dheader_t
 {
 	DECLARE_BYTESWAP_DATADESC();
 	int			ident;
-	int			version;	
+	int			version;
 	lump_t		lumps[HEADER_LUMPS];
 	int			mapRevision;				// the map's revision (iteration, version) number (added BSPVERSION 6)
 };
@@ -419,7 +421,7 @@ struct dgamelumpheader_t
 // This is expected to be a four-CC code ('lump')
 typedef int GameLumpId_t;
 
-// 360 only: game lump is compressed, filelen reflects original size
+// game lump is compressed, filelen reflects original size
 // use next entry fileofs to determine actual disk lump compressed size
 // compression stage ensures a terminal null dictionary entry
 #define GAMELUMPFLAG_COMPRESSED	0x0001
diff --git a/mp/src/public/cdll_int.h b/mp/src/public/cdll_int.h
index dd3e1e90..3a1d763e 100644
--- a/mp/src/public/cdll_int.h
+++ b/mp/src/public/cdll_int.h
@@ -548,6 +548,9 @@ public:
 	//  returns the string name of the key to which this string is bound. Returns NULL if no such binding exists
 	// Unlike Key_LookupBinding, leading '+' characters are not stripped from bindings.
 	virtual	const char			*Key_LookupBindingExact( const char *pBinding ) = 0;
+	
+	virtual void				AddPhonemeFile( const char *pszPhonemeFile ) = 0;
+
 };
 
 abstract_class IVEngineClient : public IVEngineClient013
diff --git a/mp/src/public/collisionutils.cpp b/mp/src/public/collisionutils.cpp
index d26db4ab..2549a569 100644
--- a/mp/src/public/collisionutils.cpp
+++ b/mp/src/public/collisionutils.cpp
@@ -228,7 +228,7 @@ int IntersectTriangleWithPlaneBarycentric( const Vector& org, const Vector& edge
 	{
 		pIntersection[ptIdx].x = - ( orgDotNormal - plane.w + edgeVDotNormal) / 
 			( edgeUDotNormal - edgeVDotNormal);
-		pIntersection[ptIdx].y = 1.0f - pIntersection[ptIdx].x;;
+		pIntersection[ptIdx].y = 1.0f - pIntersection[ptIdx].x;
 		if ((pIntersection[ptIdx].x >= 0.0f) && (pIntersection[ptIdx].x <= 1.0f) &&
 			 (pIntersection[ptIdx].y >= 0.0f) && (pIntersection[ptIdx].y <= 1.0f))
 			++ptIdx;
diff --git a/mp/src/public/const.h b/mp/src/public/const.h
index 98293c08..0ed97e9e 100644
--- a/mp/src/public/const.h
+++ b/mp/src/public/const.h
@@ -46,7 +46,15 @@
 #define MAX_PLAYERS_PER_CLIENT		1	// One player per PC
 #endif
 
-#define MAX_MAP_NAME				32	
+// Max decorated map name, with things like workshop/cp_foo.ugc123456
+#define MAX_MAP_NAME				96
+
+// Max name used in save files. Needs to be left at 32 for SourceSDK compatibility.
+#define MAX_MAP_NAME_SAVE			32
+
+// Max non-decorated map name for e.g. server browser (just cp_foo)
+#define MAX_DISPLAY_MAP_NAME		32
+
 #define	MAX_NETWORKID_LENGTH		64  // num chars for a network (i.e steam) ID
 
 // BUGBUG: Reconcile with or derive this from the engine's internal definition!
diff --git a/mp/src/public/eiface.h b/mp/src/public/eiface.h
index 0311ee8b..c7ca17c6 100644
--- a/mp/src/public/eiface.h
+++ b/mp/src/public/eiface.h
@@ -74,8 +74,9 @@ typedef struct player_info_s player_info_t;
 #endif
 
 #define INTERFACEVERSION_VENGINESERVER_VERSION_21	"VEngineServer021"
-#define INTERFACEVERSION_VENGINESERVER				"VEngineServer022"
-#define INTERFACEVERSION_VENGINESERVER_INT			22
+#define INTERFACEVERSION_VENGINESERVER_VERSION_22	"VEngineServer022"
+#define INTERFACEVERSION_VENGINESERVER				"VEngineServer023"
+#define INTERFACEVERSION_VENGINESERVER_INT			23
 
 struct bbox_t
 {
@@ -91,16 +92,16 @@ abstract_class IVEngineServer
 public:
 	// Tell engine to change level ( "changelevel s1\n" or "changelevel2 s1 s2\n" )
 	virtual void		ChangeLevel( const char *s1, const char *s2 ) = 0;
-	
+
 	// Ask engine whether the specified map is a valid map file (exists and has valid version number).
 	virtual int			IsMapValid( const char *filename ) = 0;
-	
+
 	// Is this a dedicated server?
 	virtual bool		IsDedicatedServer( void ) = 0;
-	
+
 	// Is in Hammer editing mode?
 	virtual int			IsInEditMode( void ) = 0;
-	
+
 	// Add to the server/client lookup/precache table, the specified string is given a unique index
 	// NOTE: The indices for PrecacheModel are 1 based
 	//  a 0 returned from those methods indicates the model or sound was not correctly precached
@@ -416,14 +417,43 @@ public:
 
 	// Exposed for server plugin authors
 	virtual IServer *GetIServer() = 0;
+
+	virtual bool IsPlayerNameLocked( const edict_t *pEdict ) = 0;
+	virtual bool CanPlayerChangeName( const edict_t *pEdict ) = 0;
+
+	// Find the canonical name of a map, given a partial or non-canonical map name.
+	// Except in the case of an exact match, pMapName is updated to the canonical name of the match.
+	// NOTE That this is subject to the same limitation as ServerGameDLL::CanProvideLevel -- This is non-blocking, so it
+	//      is possible that blocking ServerGameDLL::PrepareLevelResources call may be able to pull a better match than
+	//      is immediately available to this call (e.g. blocking lookups of cloud maps)
+	enum eFindMapResult {
+		// A direct match for this name was found
+		eFindMap_Found,
+		// No match for this map name could be found.
+		eFindMap_NotFound,
+		// A fuzzy match for this mapname was found and pMapName was updated to the full name.
+		// Ex: cp_dust -> cp_dustbowl
+		eFindMap_FuzzyMatch,
+		// A match for this map name was found, and the map name was updated to the canonical version of the
+		// name.
+		// Ex: workshop/1234 -> workshop/cp_qualified_name.ugc1234
+		eFindMap_NonCanonical,
+		// No currently available match for this map name could be found, but it may be possible to load ( see caveat
+		// about PrepareLevelResources above )
+		eFindMap_PossiblyAvailable
+	};
+	virtual eFindMapResult FindMap( /* in/out */ char *pMapName, int nMapNameMax ) = 0;
 };
 
+// These only differ in new items added to the end
 typedef IVEngineServer IVEngineServer021;
+typedef IVEngineServer IVEngineServer022;
 
 
 #define INTERFACEVERSION_SERVERGAMEDLL_VERSION_8	"ServerGameDLL008"
-#define INTERFACEVERSION_SERVERGAMEDLL				"ServerGameDLL009"
-#define INTERFACEVERSION_SERVERGAMEDLL_INT			9
+#define INTERFACEVERSION_SERVERGAMEDLL_VERSION_9	"ServerGameDLL009"
+#define INTERFACEVERSION_SERVERGAMEDLL				"ServerGameDLL010"
+#define INTERFACEVERSION_SERVERGAMEDLL_INT			10
 
 class IServerGCLobby;
 
@@ -554,6 +584,51 @@ public:
 
 	// Called to add output to the status command
 	virtual void 			Status( void (*print) (const char *fmt, ...) ) = 0;
+
+	// Informs the game we would like to load this level, giving it a chance to prepare dynamic resources.
+	//
+	// - pszMapName is the name of the map we're looking for, and may be overridden to e.g. the canonical name of the
+	//   map.
+	//
+	// - pszMapFile is the file we intend to use for this map ( e.g. maps/<mapname>.bsp ), and may be overridden to the
+	//   file representing this map name. ( e.g. /path/to/steamapps/workshop/cp_mymap.ugc12345.bsp )
+	//
+	// This call is blocking, and may block for extended periods. See AsyncPrepareLevelResources below.
+	virtual void PrepareLevelResources( /* in/out */ char *pszMapName, size_t nMapNameSize,
+	                                    /* in/out */ char *pszMapFile, size_t nMapFileSize ) = 0;
+
+	// Asynchronous version of PrepareLevelResources. Returns preparation status of map when called.
+	// If passed, flProgress is filled with the current progress percentage [ 0.f to 1.f ] for the InProgress
+	// result
+	enum ePrepareLevelResourcesResult
+	{
+		// Good to go
+		ePrepareLevelResources_Prepared,
+		// Game DLL is async preparing (e.g. streaming resources). flProgress will be filled if passed.
+		ePrepareLevelResources_InProgress
+	};
+	virtual ePrepareLevelResourcesResult AsyncPrepareLevelResources( /* in/out */ char *pszMapName, size_t nMapNameSize,
+	                                                                 /* in/out */ char *pszMapFile, size_t nMapFileSize,
+	                                                                 float *flProgress = NULL ) = 0;
+
+	// Ask the game DLL to evaluate what it would do with this map name were it passed to PrepareLevelResources.
+	// NOTE That this is this is syncronous and non-blocking, so it is possible that async PrepareLevelResources call
+	//      may be able to pull a better match than is immediately available to this call (e.g. blocking lookups of
+	//      cloud maps)
+	enum eCanProvideLevelResult {
+		// Have no knowledge of this level name, it will be up to the engine to provide. (e.g. as maps/levelname.bsp)
+		eCanProvideLevel_CannotProvide,
+		// Can provide resources for this level, and pMapName has been updated to the canonical name we would provide it
+		// under (as with PrepareLevelResources)
+		eCanProvideLevel_CanProvide,
+		// We recognize this level name as something we might be able to prepare, but without a blocking/async call to
+		// PrepareLevelResources, it is not possible to say whether it is available.
+		eCanProvideLevel_Possibly
+	};
+	virtual eCanProvideLevelResult CanProvideLevel( /* in/out */ char *pMapName, int nMapNameMax ) = 0;
+
+	// Called to see if the game server is okay with a manual changelevel or map command
+	virtual bool			IsManualMapChangeOkay( const char **pszReason ) = 0;
 };
 
 typedef IServerGameDLL IServerGameDLL008;
diff --git a/mp/src/public/filesystem_init.cpp b/mp/src/public/filesystem_init.cpp
index 4b2799fe..c1bcf3e1 100644
--- a/mp/src/public/filesystem_init.cpp
+++ b/mp/src/public/filesystem_init.cpp
@@ -982,77 +982,6 @@ bool DoesPathExistAlready( const char *pPathEnvVar, const char *pTestPath )
 	}
 }
 
-FSReturnCode_t SetSteamInstallPath( char *steamInstallPath, int steamInstallPathLen, CSteamEnvVars &steamEnvVars, bool bErrorsAsWarnings )
-{
-	if ( IsConsole() )
-	{
-		// consoles don't use steam
-		return FS_MISSING_STEAM_DLL;
-	}
-
-	if ( IsPosix() )
-		return FS_OK; // under posix the content does not live with steam.dll up the path, rely on the environment already being set by steam
-	
-	// Start at our bin directory and move up until we find a directory with steam.dll in it.
-	char executablePath[MAX_PATH];
-	if ( !FileSystem_GetExecutableDir( executablePath, sizeof( executablePath ) )	)
-	{
-		if ( bErrorsAsWarnings )
-		{
-			Warning( "SetSteamInstallPath: FileSystem_GetExecutableDir failed.\n" );
-			return FS_INVALID_PARAMETERS;
-		}
-		else
-		{
-			return SetupFileSystemError( false, FS_INVALID_PARAMETERS, "FileSystem_GetExecutableDir failed." );
-		}
-	}
-
-	Q_strncpy( steamInstallPath, executablePath, steamInstallPathLen );
-#ifdef WIN32
-	const char *pchSteamDLL = "steam" DLL_EXT_STRING;
-#elif defined(POSIX)
-	// under osx the bin lives in the bin/ folder, so step back one
-	Q_StripLastDir( steamInstallPath, steamInstallPathLen );
-	const char *pchSteamDLL = "libsteam" DLL_EXT_STRING;	
-#else
-	#error
-#endif
-	while ( 1 )
-	{
-		// Ignore steamapp.cfg here in case they're debugging. We still need to know the real steam path so we can find their username.
-		// find 
-		if ( DoesFileExistIn( steamInstallPath, pchSteamDLL ) && !DoesFileExistIn( steamInstallPath, "steamapp.cfg" ) )
-			break;
-	
-		if ( !Q_StripLastDir( steamInstallPath, steamInstallPathLen ) )
-		{
-			if ( bErrorsAsWarnings )
-			{
-				Warning( "Can't find %s relative to executable path: %s.\n", pchSteamDLL, executablePath );
-				return FS_MISSING_STEAM_DLL;
-			}
-			else
-			{
-				return SetupFileSystemError( false, FS_MISSING_STEAM_DLL, "Can't find %s relative to executable path: %s.", pchSteamDLL, executablePath );
-			}
-		}			
-	}
-
-	// Also, add the install path to their PATH environment variable, so filesystem_steam.dll can get to steam.dll.
-	char szPath[ 8192 ];
-	steamEnvVars.m_Path.GetValue( szPath, sizeof( szPath ) );
-	if ( !DoesPathExistAlready( szPath, steamInstallPath ) )
-	{
-#ifdef WIN32
-#define PATH_SEP ";"
-#else
-#define PATH_SEP ":"
-#endif	
-		steamEnvVars.m_Path.SetValue( "%s%s%s", szPath, PATH_SEP, steamInstallPath );
-	}
-	return FS_OK;
-}
 
 FSReturnCode_t GetSteamCfgPath( char *steamCfgPath, int steamCfgPathLen )
 {
@@ -1132,29 +1061,6 @@ void SetSteamUserPassphrase( KeyValues *pSteamInfo, CSteamEnvVars &steamEnvVars
 	}
 }
 
-FSReturnCode_t SetupSteamStartupEnvironment( KeyValues *pFileSystemInfo, const char *pGameInfoDirectory, CSteamEnvVars &steamEnvVars )
-{
-	// Ok, we're going to run Steam. See if they have SteamInfo.txt. If not, we'll try to deduce what we can.
-	char steamInfoFile[MAX_PATH];
-	Q_strncpy( steamInfoFile, pGameInfoDirectory, sizeof( steamInfoFile ) );
-	Q_AppendSlash( steamInfoFile, sizeof( steamInfoFile ) );
-	Q_strncat( steamInfoFile, "steaminfo.txt", sizeof( steamInfoFile ), COPY_ALL_CHARACTERS );
-	KeyValues *pSteamInfo = ReadKeyValuesFile( steamInfoFile );
-
-	char steamInstallPath[MAX_PATH];
-	FSReturnCode_t ret = SetSteamInstallPath( steamInstallPath, sizeof( steamInstallPath ), steamEnvVars, false );
-	if ( ret != FS_OK )
-		return ret;
-
-	SetSteamAppUser( pSteamInfo, steamInstallPath, steamEnvVars );
-	SetSteamUserPassphrase( pSteamInfo, steamEnvVars );
-
-	if ( pSteamInfo )
-		pSteamInfo->deleteThis();
-
-	return FS_OK;
-}
-
 FSReturnCode_t FileSystem_SetBasePaths( IFileSystem *pFileSystem )
 {
 	pFileSystem->RemoveSearchPaths( "EXECUTABLE_PATH" );
@@ -1210,18 +1116,6 @@ FSReturnCode_t FileSystem_GetFileSystemDLLName( char *pFileSystemDLL, int nMaxLe
 	return FS_OK;
 }
 
-//-----------------------------------------------------------------------------
-// Sets up the steam.dll install path in our PATH env var (so you can then just 
-// LoadLibrary() on filesystem_steam.dll without having to copy steam.dll anywhere special )
-//-----------------------------------------------------------------------------
-FSReturnCode_t FileSystem_SetupSteamInstallPath()
-{
-	CSteamEnvVars steamEnvVars;
-	char steamInstallPath[MAX_PATH];
-	FSReturnCode_t ret = SetSteamInstallPath( steamInstallPath, sizeof( steamInstallPath ), steamEnvVars, true );
-	steamEnvVars.m_Path.SetRestoreOriginalValue( false ); // We want to keep the change to the path going forward.
-	return ret;
-}
 
 //-----------------------------------------------------------------------------
 // Sets up the steam environment + gets back the gameinfo.txt path
@@ -1241,42 +1135,6 @@ FSReturnCode_t FileSystem_SetupSteamEnvironment( CFSSteamSetupInfo &fsInfo )
 #else
 	setenv( GAMEDIR_TOKEN, fsInfo.m_GameInfoPath, 1 );
 #endif
-	
-	CSteamEnvVars steamEnvVars;
-	if ( fsInfo.m_bSteam )
-	{
-		if ( fsInfo.m_bToolsMode )
-		{
-			// Now, load gameinfo.txt (to make sure it's there)
-			KeyValues *pMainFile, *pFileSystemInfo, *pSearchPaths;
-			ret = LoadGameInfoFile( fsInfo.m_GameInfoPath, pMainFile, pFileSystemInfo, pSearchPaths );
-			if ( ret != FS_OK )
-				return ret;
-
-			// If filesystem_stdio.dll is missing or -steam is specified, then load filesystem_steam.dll.
-			// There are two command line parameters for Steam:
-			//		1) -steam (runs Steam in remote filesystem mode; requires Steam backend)
-			//		2) -steamlocal (runs Steam in local filesystem mode (all content off HDD)
-
-			// Setup all the environment variables related to Steam so filesystem_steam.dll knows how to initialize Steam.
-			ret = SetupSteamStartupEnvironment( pFileSystemInfo, fsInfo.m_GameInfoPath, steamEnvVars );
-			if ( ret != FS_OK )
-				return ret;
-
-			steamEnvVars.m_SteamAppId.SetRestoreOriginalValue( false ); // We want to keep the change to the path going forward.
-
-			// We're done with main file
-			pMainFile->deleteThis();
-		}
-		else if ( fsInfo.m_bSetSteamDLLPath )
-		{
-			// This is used by the engine to automatically set the path to their steam.dll when running the engine,
-			// so they can debug it without having to copy steam.dll up into their hl2.exe folder.
-			char steamInstallPath[MAX_PATH];
-			ret = SetSteamInstallPath( steamInstallPath, sizeof( steamInstallPath ), steamEnvVars, true );
-			steamEnvVars.m_Path.SetRestoreOriginalValue( false ); // We want to keep the change to the path going forward.
-		}
-	}
 
 	return FS_OK;
 }
diff --git a/mp/src/public/filesystem_init.h b/mp/src/public/filesystem_init.h
index d95e7c3a..9274a5cb 100644
--- a/mp/src/public/filesystem_init.h
+++ b/mp/src/public/filesystem_init.h
@@ -209,11 +209,6 @@ void FileSystem_ClearSteamEnvVars();
 // Find the steam.cfg above you for optional stuff
 FSReturnCode_t GetSteamCfgPath( char *steamCfgPath, int steamCfgPathLen );
 
-// Setup the Steam.dll path without needing all the extra gameinfo stuff first
-// used by the CSteamApplication::Create() code to LoadModule() on the filesystem
-// before the underlying apps know specific details about the environment to load
-FSReturnCode_t FileSystem_SetupSteamInstallPath();
-
 // Returns the last error.
 const char *FileSystem_GetLastErrorString();
 
diff --git a/mp/src/public/gamebspfile.h b/mp/src/public/gamebspfile.h
index 0b34c122..d9b1d2ac 100644
--- a/mp/src/public/gamebspfile.h
+++ b/mp/src/public/gamebspfile.h
@@ -36,7 +36,7 @@ enum
 {
 	GAMELUMP_DETAIL_PROPS_VERSION = 4,
 	GAMELUMP_DETAIL_PROP_LIGHTING_VERSION = 0,
-	GAMELUMP_STATIC_PROPS_VERSION = 7,
+	GAMELUMP_STATIC_PROPS_VERSION = 10,
 	GAMELUMP_STATIC_PROP_LIGHTING_VERSION = 0,
 	GAMELUMP_DETAIL_PROP_LIGHTING_HDR_VERSION = 0,
 };
diff --git a/mp/src/public/ibsppack.h b/mp/src/public/ibsppack.h
index 7ecaa780..3f115d78 100644
--- a/mp/src/public/ibsppack.h
+++ b/mp/src/public/ibsppack.h
@@ -28,6 +28,13 @@ public:
 	virtual void SetHDRMode( bool bHDR ) = 0;
 	virtual bool SwapBSPFile( IFileSystem *pFileSystem, const char *filename, const char *swapFilename, bool bSwapOnLoad, VTFConvertFunc_t pVTFConvertFunc, VHVFixupFunc_t pVHVFixupFunc, CompressFunc_t pCompressFunc ) = 0;
 
+	enum eRepackBSPFlags
+	{
+		eRepackBSP_CompressLumps    = 1 << 0,
+		eRepackBSP_CompressPackfile = 1 << 1
+	};
+	virtual bool RepackBSP( CUtlBuffer &inputBuffer, CUtlBuffer &outputBuffer, eRepackBSPFlags repackFlags ) = 0;
+
 	// used to get/set the pak file from a BSP
 	virtual bool GetPakFileLump( IFileSystem *pFileSystem, const char *pBSPFilename, void **pPakData, int *pPakSize ) = 0;
 	virtual bool SetPakFileLump( IFileSystem *pFileSystem, const char *pBSPFilename, const char *pNewFilename, void *pPakData, int pakSize ) = 0;
@@ -36,6 +43,6 @@ public:
 	virtual bool GetBSPDependants( IFileSystem *pFileSystem, const char *pBSPFilename, CUtlVector< CUtlString > *pList ) = 0;
 };
 
-#define IBSPPACK_VERSION_STRING "IBSPPACK003"
+#define IBSPPACK_VERSION_STRING "IBSPPACK004"
 
 #endif // IBSPPACK_H
diff --git a/mp/src/public/ispatialpartition.h b/mp/src/public/ispatialpartition.h
index 6b6678f7..ff9bd7da 100644
--- a/mp/src/public/ispatialpartition.h
+++ b/mp/src/public/ispatialpartition.h
@@ -83,6 +83,9 @@ class IPartitionEnumerator
 {
 public:
 	virtual IterationRetval_t EnumElement( IHandleEntity *pHandleEntity ) = 0;
+	// XXX(johns): This should have a virtual destructor, but would be ABI breaking (non-versioned interface implemented
+	//             by the game)
+	// virtual ~IPartitionEnumerator(){}
 };
 
 
diff --git a/mp/src/public/jigglebones.cpp b/mp/src/public/jigglebones.cpp
index 10038e58..29b8647d 100644
--- a/mp/src/public/jigglebones.cpp
+++ b/mp/src/public/jigglebones.cpp
@@ -23,7 +23,7 @@ ConVar cl_jiggle_bone_debug_yaw_constraints( "cl_jiggle_bone_debug_yaw_constrain
 ConVar cl_jiggle_bone_debug_pitch_constraints( "cl_jiggle_bone_debug_pitch_constraints", "0", FCVAR_CHEAT, "Display physics-based 'jiggle bone' debugging information" );
 #endif // CLIENT_DLL
 
-ConVar cl_jiggle_bone_framerate_cutoff( "cl_jiggle_bone_framerate_cutoff", "45", 0, "Skip jiggle bone simulation if framerate drops below this value (frames/second)" );
+ConVar cl_jiggle_bone_framerate_cutoff( "cl_jiggle_bone_framerate_cutoff", "20", 0, "Skip jiggle bone simulation if framerate drops below this value (frames/second)" );
 
 
 //-----------------------------------------------------------------------------
@@ -40,6 +40,10 @@ JiggleData * CJiggleBones::GetJiggleData( int bone, float currenttime, const Vec
 	JiggleData data;
 	data.Init( bone, currenttime, initBasePos, initTipPos );
 
+	// Start out using jiggle bones for at least 16 frames.
+	data.useGoalMatrixCount = 0;
+	data.useJiggleBoneCount = 16;
+
 	int idx = m_jiggleBoneState.AddToHead( data );
 	if ( idx == m_jiggleBoneState.InvalidIndex() )
 		return NULL;
@@ -96,11 +100,40 @@ void CJiggleBones::BuildJiggleTransformations( int boneIndex, float currenttime,
 	float deltaT = currenttime - data->lastUpdate;
 
 	const float thousandHZ = 0.001f;
-	if ( deltaT < thousandHZ )
+	bool bMaxDeltaT = deltaT < thousandHZ;
+	bool bUseGoalMatrix = cl_jiggle_bone_framerate_cutoff.GetFloat() <= 0.0f || deltaT > ( 1.0f / cl_jiggle_bone_framerate_cutoff.GetFloat() );
+
+	if ( bUseGoalMatrix )
+	{
+		// We hit the jiggle bone framerate cutoff. Reset the useGoalMatrixCount so we
+		//  use the goal matrix at least 32 frames and don't flash back and forth.
+		data->useGoalMatrixCount = 32;
+	}
+	else if ( data->useGoalMatrixCount > 0 )
+	{
+		// Below the cutoff, but still need to use the goal matrix a few more times.
+		bUseGoalMatrix = true;
+		data->useGoalMatrixCount--;
+	}
+	else
+	{
+		// Use real jiggle bones. Woot!
+		data->useJiggleBoneCount = 32;
+	}
+
+	if ( data->useJiggleBoneCount > 0 )
+	{
+		// Make sure we draw at least runs of 32 frames with real jiggle bones.
+		data->useJiggleBoneCount--;
+		data->useGoalMatrixCount = 0;
+		bUseGoalMatrix = false;
+	}
+
+	if ( bMaxDeltaT )
 	{
 		deltaT = thousandHZ;
 	}
-	else if ( cl_jiggle_bone_framerate_cutoff.GetFloat() <= 0.0f || deltaT > ( 1.0f / cl_jiggle_bone_framerate_cutoff.GetFloat() ) )
+	else if ( bUseGoalMatrix )
 	{
 		// disable jigglebone - just use goal matrix
 		boneMX = goalMX;
diff --git a/mp/src/public/jigglebones.h b/mp/src/public/jigglebones.h
index 57afdaa7..037a4866 100644
--- a/mp/src/public/jigglebones.h
+++ b/mp/src/public/jigglebones.h
@@ -65,6 +65,9 @@ struct JiggleData
 	Vector boingVelDir;		// current estimation of jiggle bone unit velocity vector for boing effect
 	float boingSpeed;		// current estimation of jiggle bone speed for boing effect
 	float boingTime;
+	
+	int useGoalMatrixCount;	// Count of times we need to fast draw using goal matrix.
+	int useJiggleBoneCount; // Count of times we need to draw using real jiggly bones.
 };
 
 class CJiggleBones
diff --git a/mp/src/public/loadcmdline.cpp b/mp/src/public/loadcmdline.cpp
index 1df30efb..30c616f3 100644
--- a/mp/src/public/loadcmdline.cpp
+++ b/mp/src/public/loadcmdline.cpp
@@ -22,8 +22,7 @@ static void AddArguments( int &argc, char **&argv, const char *str )
 	char   *argList	 = 0;
 	int		argCt	 = argc;
 
-	argList = new char[ Q_strlen( str ) + 1 ];
-	Q_strcpy( argList, str );
+	argList = V_strdup( str );
 
 	// Parse the arguments out of the string
 	char *token = strtok( argList, " " );
@@ -45,8 +44,7 @@ static void AddArguments( int &argc, char **&argv, const char *str )
 		int i;
 		for( i = 0; i < argc - 1; ++i )
 		{
-			args[ i ] = new char[ Q_strlen( argv[ i ] ) + 1 ];
-			Q_strcpy( args[ i ], argv[ i ] );
+			args[ i ] = V_strdup( argv[ i ] );
 		}
 
 		// copy new arguments
@@ -54,14 +52,12 @@ static void AddArguments( int &argc, char **&argv, const char *str )
 		token = strtok( argList, " " );
 		for( ; i < argCt - 1; ++i )
 		{
-			args[ i ] = new char[ Q_strlen( token ) + 1 ];
-			Q_strcpy( args[ i ], token );
+			args[ i ] = V_strdup( token );
 			token = strtok( NULL, " " );
 		}
 
 		// Copy the last original argument
-		args[ i ] = new char[ Q_strlen( argv[ argc - 1 ] ) + 1 ];
-		Q_strcpy( args[ i ], argv[ argc - 1 ] );
+		args[ i ] = V_strdup( argv[ argc - 1 ] );
 
 		argc = argCt;
 		argv = args;
@@ -120,4 +116,4 @@ void DeleteCmdLine( int argc, char **argv )
 		delete [] argv[i];
 	}
 	delete [] argv;
-}
\ No newline at end of file
+}
diff --git a/mp/src/public/materialsystem/IShader.h b/mp/src/public/materialsystem/IShader.h
index 27bf91e3..7815e8aa 100644
--- a/mp/src/public/materialsystem/IShader.h
+++ b/mp/src/public/materialsystem/IShader.h
@@ -21,8 +21,9 @@
 // it's not 256, because you can't use all 256 slots in 10.5.x.
 // use this constant everywhere you might normally use "256" in reference to a parameter array size.
 // The highest shader constant is c218, plus we allocate c219 and c220 for two clip planes
-#define	DXABSTRACT_VS_PARAM_SLOTS	219
+#define DXABSTRACT_VS_PARAM_SLOTS   228
 #define DXABSTRACT_VS_FIRST_BONE_SLOT VERTEX_SHADER_MODEL
+#define DXABSTRACT_VS_LAST_BONE_SLOT (VERTEX_SHADER_SHADER_SPECIFIC_CONST_13-1)
 
 // user clip plane 0 goes in DXABSTRACT_VS_CLIP_PLANE_BASE... plane 1 goes in the slot after that
 // dxabstract uses these constants to check plane index limit and to deliver planes to shader for DP4 -> oCLP[n]
@@ -33,6 +34,8 @@
 
 #include "materialsystem/imaterialsystem.h"
 #include "materialsystem/ishaderapi.h"
+#include "materialsystem/ishadersystem_declarations.h"
+
 
 //-----------------------------------------------------------------------------
 // forward declarations
@@ -44,24 +47,6 @@ class IShaderInit;
 class CBasePerMaterialContextData;
 
 //-----------------------------------------------------------------------------
-// Shader flags
-//-----------------------------------------------------------------------------
-enum ShaderFlags_t
-{
-	SHADER_NOT_EDITABLE = 0x1
-};
-
-
-//-----------------------------------------------------------------------------
-// Shader parameter flags
-//-----------------------------------------------------------------------------
-enum ShaderParamFlags_t
-{
-	SHADER_PARAM_NOT_EDITABLE = 0x1
-};
-
-
-//-----------------------------------------------------------------------------
 // Information about each shader parameter
 //-----------------------------------------------------------------------------
 struct ShaderParamInfo_t
@@ -74,72 +59,10 @@ struct ShaderParamInfo_t
 };
 
 
-//-----------------------------------------------------------------------------
-// Standard vertex shader constants
-//-----------------------------------------------------------------------------
-enum
-{
-	// Standard vertex shader constants
-	VERTEX_SHADER_MATH_CONSTANTS0 = 0,
-	VERTEX_SHADER_MATH_CONSTANTS1 = 1,
-	VERTEX_SHADER_CAMERA_POS = 2,
-	VERTEX_SHADER_FLEXSCALE = 3,		// used by DX9 only!
-	VERTEX_SHADER_LIGHT_INDEX = 3,		// used by DX8 only!
-	VERTEX_SHADER_MODELVIEWPROJ = 4,
-	VERTEX_SHADER_VIEWPROJ = 8,
-	VERTEX_SHADER_MODELVIEWPROJ_THIRD_ROW = 12,
-	VERTEX_SHADER_VIEWPROJ_THIRD_ROW = 13,
-	VERTEX_SHADER_SHADER_SPECIFIC_CONST_10 = 14,
-	VERTEX_SHADER_SHADER_SPECIFIC_CONST_11 = 15,
-	VERTEX_SHADER_FOG_PARAMS = 16,
-	VERTEX_SHADER_VIEWMODEL = 17,
-	VERTEX_SHADER_AMBIENT_LIGHT = 21,
-	VERTEX_SHADER_LIGHTS = 27,
-	VERTEX_SHADER_LIGHT0_POSITION = 29,
-	VERTEX_SHADER_MODULATION_COLOR = 47,
-	VERTEX_SHADER_SHADER_SPECIFIC_CONST_0 = 48,
-	VERTEX_SHADER_SHADER_SPECIFIC_CONST_1 = 49,
-	VERTEX_SHADER_SHADER_SPECIFIC_CONST_2 = 50,
-	VERTEX_SHADER_SHADER_SPECIFIC_CONST_3 = 51,
-	VERTEX_SHADER_SHADER_SPECIFIC_CONST_4 = 52,
-	VERTEX_SHADER_SHADER_SPECIFIC_CONST_5 = 53,
-	VERTEX_SHADER_SHADER_SPECIFIC_CONST_6 = 54,
-	VERTEX_SHADER_SHADER_SPECIFIC_CONST_7 = 55,
-	VERTEX_SHADER_SHADER_SPECIFIC_CONST_8 = 56,
-	VERTEX_SHADER_SHADER_SPECIFIC_CONST_9 = 57,
-	VERTEX_SHADER_MODEL = 58,
-
-	//
-	// We reserve up through 216 for the 53 bones
-	//
-
-	// 219		ClipPlane0				|------ OpenGL will jam clip planes into these two
-	// 220		ClipPlane1				|	
-
-	VERTEX_SHADER_FLEX_WEIGHTS = 1024,
-	VERTEX_SHADER_MAX_FLEX_WEIGHT_COUNT = 512,
-};
 
 #define VERTEX_SHADER_BONE_TRANSFORM( k )	( VERTEX_SHADER_MODEL + 3 * (k) )
 
-//-----------------------------------------------------------------------------
-// Standard vertex shader constants
-//-----------------------------------------------------------------------------
-enum
-{
-	// Standard vertex shader constants
-	VERTEX_SHADER_LIGHT_ENABLE_BOOL_CONST = 0,
-	VERTEX_SHADER_LIGHT_ENABLE_BOOL_CONST_COUNT = 4,
-
-	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_0 = 4,
-	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_1 = 5,
-	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_2 = 6,
-	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_3 = 7,
-	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_4 = 8,
-	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_5 = 9,
-	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_6 = 10,
-	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_7 = 11,
-};
+
 // The public methods exposed by each shader
 //-----------------------------------------------------------------------------
 abstract_class IShader
@@ -179,27 +102,4 @@ public:
 //	virtual const ShaderParamInfo_t& GetParamInfo( int paramIndex ) const = 0;
 };
 
-
-//-----------------------------------------------------------------------------
-// Shader dictionaries defined in DLLs
-//-----------------------------------------------------------------------------
-enum PrecompiledShaderType_t
-{
-	PRECOMPILED_VERTEX_SHADER = 0,
-	PRECOMPILED_PIXEL_SHADER,
-
-	PRECOMPILED_SHADER_TYPE_COUNT,
-};
-
-
-//-----------------------------------------------------------------------------
-// Flags field of PrecompiledShader_t
-//-----------------------------------------------------------------------------
-enum
-{
-	// runtime flags
-	SHADER_DYNAMIC_COMPILE_IS_HLSL = 0x1,
-	SHADER_FAILED_LOAD = 0x2,
-};
-
 #endif // ISHADER_H
diff --git a/mp/src/public/materialsystem/combineoperations.h b/mp/src/public/materialsystem/combineoperations.h
new file mode 100644
index 00000000..195f19f4
--- /dev/null
+++ b/mp/src/public/materialsystem/combineoperations.h
@@ -0,0 +1,29 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef COMBINEOPERATIONS_H
+#define COMBINEOPERATIONS_H
+#pragma once
+
+// New combines can be written in the middle (and generally should be written before Error).
+// Keep these in sync with cCombineMaterialName in ctexturecompositor.cpp
+enum ECombineOperation
+{
+	ECO_Multiply = 0,
+	ECO_Add,
+	ECO_Lerp,
+
+	ECO_Select,
+
+	ECO_Legacy_Lerp_FirstPass,
+	ECO_Legacy_Lerp_SecondPass,
+
+	ECO_Error,
+	ECO_COUNT
+};
+
+#endif /* COMBINEOPERATIONS_H */
diff --git a/mp/src/public/materialsystem/imaterialsystem.h b/mp/src/public/materialsystem/imaterialsystem.h
index 3f3563b6..bf896579 100644
--- a/mp/src/public/materialsystem/imaterialsystem.h
+++ b/mp/src/public/materialsystem/imaterialsystem.h
@@ -43,6 +43,7 @@ struct MaterialSystem_Config_t;
 class VMatrix;
 struct matrix3x4_t;
 class ITexture;
+class ITextureCompositor;
 struct MaterialSystemHardwareIdentifier_t;
 class KeyValues;
 class IShader;
@@ -88,6 +89,7 @@ enum ShaderParamType_t
 	SHADER_PARAM_TYPE_MATRIX,
 	SHADER_PARAM_TYPE_MATERIAL,
 	SHADER_PARAM_TYPE_STRING,
+	SHADER_PARAM_TYPE_MATRIX4X2
 };
 
 enum MaterialMatrixMode_t
@@ -289,7 +291,6 @@ private:
 #define CREATERENDERTARGETFLAGS_NOEDRAM			0x00000008 // inhibit allocation in 360 EDRAM
 #define CREATERENDERTARGETFLAGS_TEMP			0x00000010 // only allocates memory upon first resolve, destroyed at level end
 
-
 //-----------------------------------------------------------------------------
 // allowed stencil operations. These match the d3d operations
 //-----------------------------------------------------------------------------
@@ -478,6 +479,21 @@ private:
 	int m_nBottom;
 };
 
+// Passed as the callback object to Async functions in the material system
+// so that callers don't have to worry about memory going out of scope before the 
+// results return.
+abstract_class IAsyncTextureOperationReceiver : public IRefCounted
+{
+public:
+	virtual void OnAsyncCreateComplete( ITexture* pTex, void* pExtraArgs ) = 0;
+	virtual void OnAsyncFindComplete( ITexture* pTex, void* pExtraArgs ) = 0;
+	virtual void OnAsyncMapComplete( ITexture* pTex, void* pExtraArgs, void* pMemory, int nPitch ) = 0;
+	virtual void OnAsyncReadbackBegin( ITexture* pDst, ITexture* pSrc, void* pExtraArgs ) = 0;
+
+	virtual int GetRefCount() const = 0;
+};
+
+
 //-----------------------------------------------------------------------------
 // Flags to be used with the Init call
 //-----------------------------------------------------------------------------
@@ -525,7 +541,9 @@ enum RenderTargetSizeMode_t
 	RT_SIZE_OFFSCREEN=5,			// Target of specified size, don't mess with dimensions
 	RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP=6, // Same size as the frame buffer, rounded up if necessary for systems that can't do non-power of two textures.
 	RT_SIZE_REPLAY_SCREENSHOT = 7,	// Rounded down to power of 2, essentially...
-	RT_SIZE_LITERAL = 8				// Use the size passed in. Don't clamp it to the frame buffer size. Really.
+	RT_SIZE_LITERAL = 8,			// Use the size passed in. Don't clamp it to the frame buffer size. Really.
+	RT_SIZE_LITERAL_PICMIP = 9		// Use the size passed in, don't clamp to the frame buffer size, but do apply picmip restrictions.
+
 };
 
 typedef void (*MaterialBufferReleaseFunc_t)( );
@@ -1043,6 +1061,23 @@ public:
 	// creates a texture suitable for use with materials from a raw stream of bits.
 	// The bits will be retained by the material system and can be freed upon return.
 	virtual ITexture*			CreateTextureFromBits(int w, int h, int mips, ImageFormat fmt, int srcBufferSize, byte* srcBits) = 0;
+
+	// Lie to the material system to pretend to be in render target allocation mode at the beginning of time.
+	// This was a thing that mattered a lot to old hardware, but doesn't matter at all to new hardware,
+	// where new is defined to be "anything from the last decade." However, we want to preserve legacy behavior
+	// for the old games because it's easier than testing them.
+	virtual void				OverrideRenderTargetAllocation( bool rtAlloc ) = 0;
+
+	// creates a texture compositor that will attempt to composite a new textuer from the steps of the specified KeyValues.
+	virtual ITextureCompositor*	NewTextureCompositor( int w, int h, const char* pCompositeName, int nTeamNum, uint64 randomSeed, KeyValues* stageDesc, uint32 texCompositeCreateFlags = 0 ) = 0;
+
+	// Loads the texture with the specified name, calls pRecipient->OnAsyncFindComplete with the result from the main thread.
+	// once the texture load is complete. If the texture cannot be found, the returned texture will return true for IsError().
+	virtual void AsyncFindTexture( const char* pFilename, const char *pTextureGroupName, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs, bool bComplain = true, int nAdditionalCreationFlags = 0 ) = 0;
+
+	// creates a texture suitable for use with materials from a raw stream of bits.
+	// The bits will be retained by the material system and can be freed upon return.
+	virtual ITexture*			CreateNamedTextureFromBitsEx( const char* pName, const char *pTextureGroupName, int w, int h, int mips, ImageFormat fmt, int srcBufferSize, byte* srcBits, int nFlags ) = 0;
 };
 
 
@@ -1504,6 +1539,11 @@ public:
 	virtual void OverrideColorWriteEnable( bool bOverrideEnable, bool bColorWriteEnable ) = 0;
 
 	virtual void ClearBuffersObeyStencilEx( bool bClearColor, bool bClearAlpha, bool bClearDepth ) = 0;
+
+	// Create a texture from the specified src render target, then call pRecipient->OnAsyncCreateComplete from the main thread.
+	// The texture will be created using the destination format, and will optionally have mipmaps generated.
+	// In case of error, the provided callback function will be called with the error texture.
+	virtual void AsyncCreateTextureFromRenderTarget( ITexture* pSrcRt, const char* pDstName, ImageFormat dstFmt, bool bGenMips, int nAdditionalCreationFlags, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs ) = 0;
 };
 
 template< class E > inline E* IMatRenderContext::LockRenderDataTyped( int nCount, const E* pSrcData )
diff --git a/mp/src/public/materialsystem/ishadersystem_declarations.h b/mp/src/public/materialsystem/ishadersystem_declarations.h
new file mode 100644
index 00000000..3c54edca
--- /dev/null
+++ b/mp/src/public/materialsystem/ishadersystem_declarations.h
@@ -0,0 +1,131 @@
+//===== Copyright � Valve Corporation, All rights reserved. ======//
+#ifndef ISHADER_DECLARATIONS_HDR
+#define ISHADER_DECLARATIONS_HDR
+
+//-----------------------------------------------------------------------------
+// Standard vertex shader constants
+//-----------------------------------------------------------------------------
+enum
+{
+	// Standard vertex shader constants
+	VERTEX_SHADER_MATH_CONSTANTS0 = 0,
+	VERTEX_SHADER_MATH_CONSTANTS1 = 1,
+	VERTEX_SHADER_CAMERA_POS = 2,
+	VERTEX_SHADER_FLEXSCALE = 3,   // DX9 only
+	VERTEX_SHADER_LIGHT_INDEX = 3, // DX8 only
+	VERTEX_SHADER_MODELVIEWPROJ = 4,
+	VERTEX_SHADER_VIEWPROJ = 8,
+	VERTEX_SHADER_MODELVIEWPROJ_THIRD_ROW = 12,
+	VERTEX_SHADER_VIEWPROJ_THIRD_ROW = 13,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_10 = 14,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_11 = 15,
+	VERTEX_SHADER_FOG_PARAMS = 16,
+	VERTEX_SHADER_VIEWMODEL = 17,
+	VERTEX_SHADER_AMBIENT_LIGHT = 21,
+	VERTEX_SHADER_LIGHTS = 27,
+	VERTEX_SHADER_LIGHT0_POSITION = 29,
+	VERTEX_SHADER_MODULATION_COLOR = 47,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_0 = 48,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_1 = 49,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_2 = 50,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_3 = 51,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_4 = 52,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_5 = 53,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_6 = 54,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_7 = 55,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_8 = 56,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_9 = 57,
+	VERTEX_SHADER_MODEL = 58,
+	//
+	// We reserve up through 216 for the 53 bones supported on DX9
+	//
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_13 = 217,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_14 = 218,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_15 = 219,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_16 = 220,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_17 = 221,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_18 = 222,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_19 = 223,
+	VERTEX_SHADER_SHADER_SPECIFIC_CONST_12 = 224,
+
+	// 226		ClipPlane0				|------ OpenGL will jam clip planes into these two
+	// 227		ClipPlane1				|
+
+
+	VERTEX_SHADER_FLEX_WEIGHTS = 1024,
+	VERTEX_SHADER_MAX_FLEX_WEIGHT_COUNT = 512,
+};
+
+//-----------------------------------------------------------------------------
+// forward declarations
+//-----------------------------------------------------------------------------
+class IMaterialVar;
+class IShaderShadow;
+class IShaderDynamicAPI;
+class IShaderInit;
+class CBasePerMaterialContextData;
+
+
+//-----------------------------------------------------------------------------
+// Shader flags
+//-----------------------------------------------------------------------------
+enum ShaderFlags_t
+{
+	SHADER_NOT_EDITABLE = 0x1
+};
+
+
+//-----------------------------------------------------------------------------
+// Shader parameter flags
+//-----------------------------------------------------------------------------
+enum ShaderParamFlags_t
+{
+	SHADER_PARAM_NOT_EDITABLE = 0x1
+};
+
+
+
+//-----------------------------------------------------------------------------
+// Standard vertex shader constants
+//-----------------------------------------------------------------------------
+enum
+{
+	// Standard vertex shader constants
+	VERTEX_SHADER_LIGHT_ENABLE_BOOL_CONST = 0,
+	VERTEX_SHADER_LIGHT_ENABLE_BOOL_CONST_COUNT = 4,
+
+	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_0 = 4,
+	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_1 = 5,
+	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_2 = 6,
+	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_3 = 7,
+	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_4 = 8,
+	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_5 = 9,
+	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_6 = 10,
+	VERTEX_SHADER_SHADER_SPECIFIC_BOOL_CONST_7 = 11,
+};
+
+
+//-----------------------------------------------------------------------------
+// Shader dictionaries defined in DLLs
+//-----------------------------------------------------------------------------
+enum PrecompiledShaderType_t
+{
+	PRECOMPILED_VERTEX_SHADER = 0,
+	PRECOMPILED_PIXEL_SHADER,
+
+	PRECOMPILED_SHADER_TYPE_COUNT,
+};
+
+
+//-----------------------------------------------------------------------------
+// Flags field of PrecompiledShader_t
+//-----------------------------------------------------------------------------
+enum
+{
+	// runtime flags
+	SHADER_IS_ASM = 0x1,
+	SHADER_FAILED_LOAD = 0x2,
+};
+
+
+#endif
\ No newline at end of file
diff --git a/mp/src/public/materialsystem/itexture.h b/mp/src/public/materialsystem/itexture.h
index a5aa20fd..0e315447 100644
--- a/mp/src/public/materialsystem/itexture.h
+++ b/mp/src/public/materialsystem/itexture.h
@@ -39,6 +39,10 @@ public:
 	// This will be called when the regenerator needs to be deleted
 	// which will happen when the texture is destroyed
 	virtual void Release() = 0;
+
+	// (erics): This should have a virtual destructor, but would be ABI breaking (non-versioned interface implemented
+	//          by the game)
+//	virtual ~ITextureRegenerator(){}
 };
 
 abstract_class ITexture
@@ -120,6 +124,13 @@ public:
 
 	// Save texture to a file.
 	virtual bool SaveToFile( const char *fileName ) = 0;
+
+	// Copy this texture, which must be a render target or a renderable texture, to the destination texture, 
+	// which must have been created with the STAGING bit.
+	virtual void CopyToStagingTexture( ITexture* pDstTex ) = 0;
+
+	// Set that this texture should return true for the call "IsError"
+	virtual void SetErrorTexture( bool bIsErrorTexture ) = 0;
 };
 
 
diff --git a/mp/src/public/materialsystem/itexturecompositor.h b/mp/src/public/materialsystem/itexturecompositor.h
new file mode 100644
index 00000000..a158d36c
--- /dev/null
+++ b/mp/src/public/materialsystem/itexturecompositor.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ================================== //
+//
+// Purpose: Defines a texture compositor infterface which uses simple operations and shaders to 
+// create complex procedural textures. 
+//
+//============================================================================================== //
+
+#ifndef ITEXTURECOMPOSITOR_H
+#define ITEXTURECOMPOSITOR_H
+#pragma once
+
+#include "interface.h"
+#include "itexture.h"
+
+#define ITEXTURE_COMPOSITOR_INTERFACE_VERSION "_ITextureCompositor000"
+
+enum ECompositeResolveStatus
+{
+	ECRS_Idle,
+	ECRS_Scheduled,
+	ECRS_PendingTextureLoads,
+	ECRS_PendingComposites,
+	ECRS_Error,
+	ECRS_Complete
+};
+
+enum TextureCompositeCreateFlags_t
+{
+	TEX_COMPOSITE_CREATE_FLAGS_FORCE			= 0x00000001,
+	TEX_COMPOSITE_CREATE_FLAGS_NO_COMPRESSION	= 0x00000002,
+	TEX_COMPOSITE_CREATE_FLAGS_NO_MIPMAPS		= 0x00000004,
+};
+
+abstract_class ITextureCompositor
+{
+public:
+	virtual int AddRef() = 0;
+	virtual int Release() = 0;
+	virtual int GetRefCount() const = 0;
+
+	virtual void Update() = 0;
+	virtual ITexture* GetResultTexture() const = 0;
+	virtual ECompositeResolveStatus GetResolveStatus() const = 0;
+	virtual void ScheduleResolve() = 0;
+protected:
+	virtual ~ITextureCompositor() {}
+};
+
+
+#endif /* ITEXTURECOMPOSITOR_H */
diff --git a/mp/src/public/mathlib/mathlib.h b/mp/src/public/mathlib/mathlib.h
index bd6f3027..05df16d5 100644
--- a/mp/src/public/mathlib/mathlib.h
+++ b/mp/src/public/mathlib/mathlib.h
@@ -1203,7 +1203,7 @@ inline float SimpleSplineRemapValClamped( float val, float A, float B, float C,
 
 FORCEINLINE int RoundFloatToInt(float f)
 {
-#if defined(__i386__) || defined(_M_IX86) || defined( PLATFORM_WINDOWS_PC64 )
+#if defined(__i386__) || defined(_M_IX86) || defined( PLATFORM_WINDOWS_PC64 ) || defined(__x86_64__)
 	return _mm_cvtss_si32(_mm_load_ss(&f));
 #elif defined( _X360 )
 #ifdef Assert
diff --git a/mp/src/public/matsys_controls/QCGenerator.h b/mp/src/public/matsys_controls/QCGenerator.h
index d9978f88..d6b69d21 100644
--- a/mp/src/public/matsys_controls/QCGenerator.h
+++ b/mp/src/public/matsys_controls/QCGenerator.h
@@ -79,9 +79,9 @@ struct QCInfo
 	{
 		pQCGenerator = pPanel;
 
-		Q_strcpy( pszSMDPath, "" );
-		Q_strcpy( pszCollisionPath, "" );
-		Q_strcpy( pszSurfaceProperty, "default" );
+		V_strcpy_safe( pszSMDPath, "" );
+		V_strcpy_safe( pszCollisionPath, "" );
+		V_strcpy_safe( pszSurfaceProperty, "default" );
 		bStaticProp = false;
 		bMostlyOpaque = false;
 		bDisableCollision = false;
diff --git a/mp/src/public/matsys_controls/manipulator.h b/mp/src/public/matsys_controls/manipulator.h
index a08426ef..f030509a 100644
--- a/mp/src/public/matsys_controls/manipulator.h
+++ b/mp/src/public/matsys_controls/manipulator.h
@@ -19,6 +19,7 @@
 class IManipulator
 {
 public:
+	virtual ~IManipulator(){}
 	virtual void OnBeginManipulation( void ) = 0;
 	virtual void OnAcceptManipulation( void ) = 0;
 	virtual void OnCancelManipulation( void ) = 0;
diff --git a/mp/src/public/matsys_controls/mdlpanel.h b/mp/src/public/matsys_controls/mdlpanel.h
index 070fb973..60068567 100644
--- a/mp/src/public/matsys_controls/mdlpanel.h
+++ b/mp/src/public/matsys_controls/mdlpanel.h
@@ -64,7 +64,7 @@ public:
 	void SetLOD( int nLOD );
 
 	// Sets the current sequence
-	void SetSequence( int nSequence );
+	void SetSequence( int nSequence, bool bResetSequence = false );
 
 	// Set the pose parameters
 	void SetPoseParameters( const float *pPoseParameters, int nCount );
@@ -113,6 +113,7 @@ protected:
 		CMDL		m_MDL;
 		matrix3x4_t	m_MDLToWorld;
 		bool		m_bDisabled;
+		float		m_flCycleStartTime;
 	};
 
 	MDLData_t				m_RootMDL;
diff --git a/mp/src/public/matsys_controls/potterywheelpanel.h b/mp/src/public/matsys_controls/potterywheelpanel.h
index 47125a3f..5da55e48 100644
--- a/mp/src/public/matsys_controls/potterywheelpanel.h
+++ b/mp/src/public/matsys_controls/potterywheelpanel.h
@@ -45,6 +45,7 @@ public:
 	virtual ~CPotteryWheelPanel();
 
 	// Overriden methods of vgui::Panel
+	virtual void ApplySettings( KeyValues *inResourceData );
 	virtual void Init( int x, int y, int wide, int tall );
 	virtual void Paint();
 
@@ -117,6 +118,7 @@ protected:
 	bool WarpMouse( int &x, int &y );
 	IManipulator		*m_pCurrentManip;
 	int m_nManipStartX, m_nManipStartY;
+	int m_nClickStartX, m_nClickStartY;
 
 	// Re-apply the manipulators on a new model
 	void ApplyManipulation();
@@ -136,6 +138,7 @@ protected:
 private:
 	void CreateDefaultLights();
 	void DestroyLights();
+	void ParseLightsFromKV( KeyValues *pLightsKV );
 
 	CMaterialReference m_LightProbeBackground;
 	CMaterialReference m_LightProbeHDRBackground;
diff --git a/mp/src/public/particles/particles.h b/mp/src/public/particles/particles.h
index 16b48e74..4066d85e 100644
--- a/mp/src/public/particles/particles.h
+++ b/mp/src/public/particles/particles.h
@@ -154,6 +154,7 @@ enum ParticleFunctionType_t
 
 struct CParticleVisibilityInputs
 {
+	float	m_flCameraBias;
 	float	m_flInputMin;
 	float	m_flInputMax;
 	float	m_flAlphaScaleMin;
@@ -668,7 +669,7 @@ public:
 	}
 	
 	// should the constraint be run only once after all other constraints?
-	virtual bool IsFinalConstaint( void ) const
+	virtual bool IsFinalConstraint( void ) const
 	{
 		return false;
 	}
@@ -720,6 +721,12 @@ public:
 		return false;
 	}
 
+	// Does this operator require that particles remain in the order they were emitted?
+	virtual bool RequiresOrderInvariance( void ) const
+	{
+		return false;
+	}
+
 	// Called when the SFM wants to skip forward in time
 	virtual void SkipToTime( float flTime, CParticleCollection *pParticles, void *pContext ) const {}
 
@@ -881,7 +888,9 @@ private:
 	DMXELEMENT_UNPACK_FIELD( "Visibility Alpha Scale minimum","0", float, VisibilityInputs.m_flAlphaScaleMin )		\
 	DMXELEMENT_UNPACK_FIELD( "Visibility Alpha Scale maximum","1", float, VisibilityInputs.m_flAlphaScaleMax )		\
 	DMXELEMENT_UNPACK_FIELD( "Visibility Radius Scale minimum","1", float, VisibilityInputs.m_flRadiusScaleMin )		\
-	DMXELEMENT_UNPACK_FIELD( "Visibility Radius Scale maximum","1", float, VisibilityInputs.m_flRadiusScaleMax )
+	DMXELEMENT_UNPACK_FIELD( "Visibility Radius Scale maximum","1", float, VisibilityInputs.m_flRadiusScaleMax )	\
+	DMXELEMENT_UNPACK_FIELD( "Visibility Camera Depth Bias", "0", float, VisibilityInputs.m_flCameraBias )
+
 //	DMXELEMENT_UNPACK_FIELD( "Visibility Use Bounding Box for Proxy", "0", bool, VisibilityInputs.m_bUseBBox )		
 //	DMXELEMENT_UNPACK_FIELD( "Visibility Bounding Box Scale", "1.0", float, VisibilityInputs.m_flBBoxScale )		
 
@@ -961,6 +970,7 @@ struct CParticleVisibilityData
 {
 	float	m_flAlphaVisibility;
 	float	m_flRadiusVisibility;
+	float	m_flCameraBias;
 	bool	m_bUseVisibility;
 };
 
@@ -1062,7 +1072,7 @@ public:
 	float *GetInitialFloatAttributePtrForWrite( int nAttribute, int nParticleNumber );
 	fltx4 *GetInitialM128AttributePtrForWrite( int nAttribute, size_t *pStrideOut );
 
-	void Simulate( float dt );
+	void Simulate( float dt, bool updateBboxOnly );
 	void SkipToTime( float t );
 
 	// the camera objetc may be compared for equality against control point objects
@@ -1094,14 +1104,17 @@ public:
 
 	// Used to retrieve the position of a control point
 	// somewhere between m_fCurTime and m_fCurTime - m_fPreviousDT
-	void GetControlPointAtTime( int nControlPoint, float flTime, Vector *pControlPoint );
-	void GetControlPointAtPrevTime( int nControlPoint, Vector *pControlPoint );
+	void GetControlPointAtTime( int nControlPoint, float flTime, Vector *pControlPoint ) const;
+	void GetControlPointAtPrevTime( int nControlPoint, Vector *pControlPoint ) const;
 	void GetControlPointOrientationAtTime( int nControlPoint, float flTime, Vector *pForward, Vector *pRight, Vector *pUp );
 	void GetControlPointTransformAtTime( int nControlPoint, float flTime, matrix3x4_t *pMat );
 	void GetControlPointTransformAtTime( int nControlPoint, float flTime, VMatrix *pMat );
 	void GetControlPointTransformAtTime( int nControlPoint, float flTime, CParticleSIMDTransformation *pXForm );
 	int GetHighestControlPoint( void ) const;
 
+	// Has this particle moved recently (since the last simulation?)
+	bool HasMoved() const;
+
 	// Control point accessed:
 	// NOTE: Unlike the definition's version of these methods,
 	// these OR-in the masks of their children.
@@ -1249,6 +1262,7 @@ private:
 	bool ComputeIsTranslucent();
 	bool ComputeIsTwoPass();
 	bool ComputeIsBatchable();
+	bool ComputeRequiresOrderInvariance();
 
 	void LabelTextureUsage( void );
 
@@ -1270,6 +1284,7 @@ public:
 	int m_nMaxAllowedParticles;
 	bool m_bDormant;
 	bool m_bEmissionStopped;
+	bool m_bRequiresOrderInvariance;
 
 	int m_LocalLightingCP;
 	Color m_LocalLighting;
@@ -1337,6 +1352,7 @@ private:
 	
 	// How many frames have we drawn?
 	int m_nDrawnFrames;
+	int m_nSimulatedFrames;
 
 	Vector m_Center;										// average of particle centers
 
@@ -1805,9 +1821,12 @@ inline fltx4 *CParticleCollection::GetM128AttributePtrForWrite( int nAttribute,
 {
 	// NOTE: If you hit this assertion, it means your particle operator isn't returning
 	// the appropriate fields in the RequiredAttributesMask call
-	Assert( !m_bIsRunningInitializers || ( m_nPerParticleInitializedAttributeMask & (1 << nAttribute) ) );
-	Assert( !m_bIsRunningOperators || ( m_nPerParticleUpdatedAttributeMask & (1 << nAttribute) ) );
-	Assert( m_nParticleFloatStrides[nAttribute] != 0 );
+	if ( !HushAsserts() )
+	{
+		Assert( !m_bIsRunningInitializers || ( m_nPerParticleInitializedAttributeMask & (1 << nAttribute) ) );
+		Assert( !m_bIsRunningOperators || ( m_nPerParticleUpdatedAttributeMask & (1 << nAttribute) ) );
+		Assert( m_nParticleFloatStrides[nAttribute] != 0 );
+	}
 
 	*(pStrideOut) = m_nParticleFloatStrides[ nAttribute ]/4;
 	return reinterpret_cast<fltx4 *>( m_pParticleAttributes[ nAttribute ] );
diff --git a/mp/src/public/saverestoretypes.h b/mp/src/public/saverestoretypes.h
index 08a35361..7868e2fb 100644
--- a/mp/src/public/saverestoretypes.h
+++ b/mp/src/public/saverestoretypes.h
@@ -93,7 +93,7 @@ struct levellist_t
 {
 	DECLARE_SIMPLE_DATADESC();
 
-	char	mapName[ MAX_MAP_NAME ];
+	char	mapName[ MAX_MAP_NAME_SAVE ];
 	char	landmarkName[ 32 ];
 	edict_t	*pentLandmark;
 	Vector	vecLandmarkOrigin;
@@ -171,7 +171,7 @@ struct saverestorelevelinfo_t
 	char		szLandmarkName[20];	// landmark we'll spawn near in next level
 	Vector		vecLandmarkOffset;	// for landmark transitions
 	float		time;
-	char		szCurrentMapName[MAX_MAP_NAME];	// To check global entities
+	char		szCurrentMapName[MAX_MAP_NAME_SAVE];	// To check global entities
 	int			mapVersion;
 };
 
diff --git a/mp/src/public/sentence.cpp b/mp/src/public/sentence.cpp
index 1afba9b9..bb7ade5e 100644
--- a/mp/src/public/sentence.cpp
+++ b/mp/src/public/sentence.cpp
@@ -671,6 +671,10 @@ void CSentence::ParseDataVersionOnePointZero( CUtlBuffer& buf )
 		buf.GetString( token );
 		if ( strlen( token ) <= 0 )
 			break;
+		
+		// end of block, return
+		if ( !V_strcmp( token, "}" ) )
+			break;
 
 		char section[ 256 ];
 		Q_strncpy( section, token, sizeof( section ) );
diff --git a/mp/src/public/shaderapi/ishaderapi.h b/mp/src/public/shaderapi/ishaderapi.h
index 367cd0e9..1a90caee 100644
--- a/mp/src/public/shaderapi/ishaderapi.h
+++ b/mp/src/public/shaderapi/ishaderapi.h
@@ -82,7 +82,7 @@ enum CreateTextureFlags_t
 	TEXTURE_CREATE_VERTEXTEXTURE       = 0x0040,	// for internal use only	
 	TEXTURE_CREATE_FALLBACK            = 0x0080,	// 360 only
 	TEXTURE_CREATE_NOD3DMEMORY         = 0x0100,	// 360 only
-	TEXTURE_CREATE_UNUSED3             = 0x0200,	// Dead
+	TEXTURE_CREATE_SYSMEM              = 0x0200,	// This texture should be alloc'd in the sysmem pool
 	TEXTURE_CREATE_UNUSED4             = 0x0400,	// Dead
 	TEXTURE_CREATE_UNUSED5		       = 0x0800,	// Dead
 	TEXTURE_CREATE_UNFILTERABLE_OK     = 0x1000,
@@ -611,6 +611,13 @@ public:
 
 	//extended clear buffers function with alpha independent from color
 	virtual void ClearBuffersObeyStencilEx( bool bClearColor, bool bClearAlpha, bool bClearDepth ) = 0;
+
+	// Allows copying a render target to another texture by specifying them both.
+	virtual void CopyRenderTargetToScratchTexture( ShaderAPITextureHandle_t srcRt, ShaderAPITextureHandle_t dstTex, Rect_t *pSrcRect = NULL, Rect_t *pDstRect = NULL ) = 0;
+
+	// Allows locking and unlocking of very specific surface types.
+	virtual void LockRect( void** pOutBits, int* pOutPitch, ShaderAPITextureHandle_t texHandle, int mipmap, int x, int y, int w, int h, bool bWrite, bool bRead ) = 0;
+	virtual void UnlockRect( ShaderAPITextureHandle_t texHandle, int mipmap ) = 0;
 };
 
 
diff --git a/mp/src/public/steam/isteamapps.h b/mp/src/public/steam/isteamapps.h
index 7070e2e9..07005836 100644
--- a/mp/src/public/steam/isteamapps.h
+++ b/mp/src/public/steam/isteamapps.h
@@ -49,7 +49,7 @@ public:
 	// Install/Uninstall control for optional DLC
 	virtual void InstallDLC( AppId_t nAppID ) = 0;
 	virtual void UninstallDLC( AppId_t nAppID ) = 0;
-
+	
 	// Request cd-key for yourself or owned DLC. If you are interested in this
 	// data then make sure you provide us with a list of valid keys to be distributed
 	// to users when they purchase the game, before the game ships.
@@ -73,13 +73,18 @@ public:
 	// but it is advised that you not param names beginning with an underscore for your own features.
 	virtual const char *GetLaunchQueryParam( const char *pchKey ) = 0;
 
+	// get download progress for optional DLC
+	virtual bool GetDlcDownloadProgress( AppId_t nAppID, uint64 *punBytesDownloaded, uint64 *punBytesTotal ) = 0; 
+
+	// return the buildid of this app, may change at any time based on backend updates to the game
+	virtual int GetAppBuildId() = 0;
 #ifdef _PS3
 	// Result returned in a RegisterActivationCodeResponse_t callresult
 	virtual SteamAPICall_t RegisterActivationCode( const char *pchActivationCode ) = 0;
 #endif
 };
 
-#define STEAMAPPS_INTERFACE_VERSION "STEAMAPPS_INTERFACE_VERSION006"
+#define STEAMAPPS_INTERFACE_VERSION "STEAMAPPS_INTERFACE_VERSION007"
 
 // callbacks
 #if defined( VALVE_CALLBACK_PACK_SMALL )
diff --git a/mp/src/public/steam/isteamclient.h b/mp/src/public/steam/isteamclient.h
index 44c1df66..796d72d6 100644
--- a/mp/src/public/steam/isteamclient.h
+++ b/mp/src/public/steam/isteamclient.h
@@ -1,4 +1,4 @@
-//====== Copyright � 1996-2008, Valve Corporation, All rights reserved. =======
+//====== Copyright � 1996-2008, Valve Corporation, All rights reserved. =======
 //
 // Purpose: Main interface for loading and accessing Steamworks API's from the 
 //			Steam client.
@@ -40,7 +40,7 @@
 #error ???
 #endif 
 
-typedef struct
+typedef struct ValvePackingSentinel_t
 {
     uint32 m_u32;
     uint64 m_u64;
@@ -98,6 +98,8 @@ class ISteamController;
 class ISteamUGC;
 class ISteamAppList;
 class ISteamHTMLSurface;
+class ISteamInventory;
+class ISteamVideo;
 
 //-----------------------------------------------------------------------------
 // Purpose: Interface to creating a new steam instance, or to
@@ -221,9 +223,16 @@ public:
 	virtual void Set_SteamAPI_CPostAPIResultInProcess( SteamAPI_PostAPIResultInProcess_t func ) = 0;
 	virtual void Remove_SteamAPI_CPostAPIResultInProcess( SteamAPI_PostAPIResultInProcess_t func ) = 0;
 	virtual void Set_SteamAPI_CCheckCallbackRegisteredInProcess( SteamAPI_CheckCallbackRegistered_t func ) = 0;
+
+	// inventory
+	virtual ISteamInventory *GetISteamInventory( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+	// Video
+	virtual ISteamVideo *GetISteamVideo( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
 };
 
-#define STEAMCLIENT_INTERFACE_VERSION		"SteamClient016"
+
+#define STEAMCLIENT_INTERFACE_VERSION		"SteamClient017"
 
 //-----------------------------------------------------------------------------
 // Purpose: Base values for callback identifiers, each callback must
@@ -275,6 +284,7 @@ enum { k_iClientReservedCallbacks = 4300 };
 enum { k_iSteamReservedCallbacks = 4400 };
 enum { k_iSteamHTMLSurfaceCallbacks = 4500 };
 enum { k_iClientVideoCallbacks = 4600 };
+enum { k_iClientInventoryCallbacks = 4700 };
 
 //-----------------------------------------------------------------------------
 // The CALLBACK macros are for client side callback logging enabled with
diff --git a/mp/src/public/steam/isteamcontroller.h b/mp/src/public/steam/isteamcontroller.h
index 6a97a6fc..5c3d01ab 100644
--- a/mp/src/public/steam/isteamcontroller.h
+++ b/mp/src/public/steam/isteamcontroller.h
@@ -11,7 +11,6 @@
 #endif
 
 #include "isteamclient.h"
-#include "steamcontrollerpublic.h"
 
 // callbacks
 #if defined( VALVE_CALLBACK_PACK_SMALL )
@@ -26,13 +25,61 @@
 
 #pragma pack( pop )
 
+#define STEAM_RIGHT_TRIGGER_MASK            0x0000001
+#define STEAM_LEFT_TRIGGER_MASK             0x0000002
+#define STEAM_RIGHT_BUMPER_MASK             0x0000004
+#define STEAM_LEFT_BUMPER_MASK              0x0000008
+#define STEAM_BUTTON_0_MASK                 0x0000010
+#define STEAM_BUTTON_1_MASK                 0x0000020
+#define STEAM_BUTTON_2_MASK                 0x0000040
+#define STEAM_BUTTON_3_MASK                 0x0000080
+#define STEAM_TOUCH_0_MASK                  0x0000100
+#define STEAM_TOUCH_1_MASK                  0x0000200
+#define STEAM_TOUCH_2_MASK                  0x0000400
+#define STEAM_TOUCH_3_MASK                  0x0000800
+#define STEAM_BUTTON_MENU_MASK              0x0001000
+#define STEAM_BUTTON_STEAM_MASK             0x0002000
+#define STEAM_BUTTON_ESCAPE_MASK            0x0004000
+#define STEAM_BUTTON_BACK_LEFT_MASK         0x0008000
+#define STEAM_BUTTON_BACK_RIGHT_MASK        0x0010000
+#define STEAM_BUTTON_LEFTPAD_CLICKED_MASK   0x0020000
+#define STEAM_BUTTON_RIGHTPAD_CLICKED_MASK  0x0040000
+#define STEAM_LEFTPAD_FINGERDOWN_MASK       0x0080000
+#define STEAM_RIGHTPAD_FINGERDOWN_MASK      0x0100000
+#define STEAM_JOYSTICK_BUTTON_MASK			0x0400000
+
+
+#pragma pack( push, 1 )
+
+struct SteamControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since 
+	// your last call and there is no need to process it
+	uint32 unPacketNum;
+	
+	// bit flags for each of the buttons
+	uint64 ulButtons;
+	
+	// Left pad coordinates
+	short sLeftPadX;
+	short sLeftPadY;
+	
+	// Right pad coordinates
+	short sRightPadX;
+	short sRightPadY;
+	
+};
+
+#pragma pack( pop )
+
+#define SteamControllerState_t SteamControllerState001_t
+
 enum ESteamControllerPad
 {
 	k_ESteamControllerPad_Left,
 	k_ESteamControllerPad_Right
 };
 
-
 //-----------------------------------------------------------------------------
 // Purpose: Native Steam controller support API
 //-----------------------------------------------------------------------------
diff --git a/mp/src/public/steam/isteamfriends.h b/mp/src/public/steam/isteamfriends.h
index 16a2aa5a..60526edd 100644
--- a/mp/src/public/steam/isteamfriends.h
+++ b/mp/src/public/steam/isteamfriends.h
@@ -20,11 +20,11 @@
 enum EFriendRelationship
 {
 	k_EFriendRelationshipNone = 0,
-	k_EFriendRelationshipBlocked = 1,
+	k_EFriendRelationshipBlocked = 1,			// this doesn't get stored; the user has just done an Ignore on an friendship invite
 	k_EFriendRelationshipRequestRecipient = 2,
 	k_EFriendRelationshipFriend = 3,
 	k_EFriendRelationshipRequestInitiator = 4,
-	k_EFriendRelationshipIgnored = 5,
+	k_EFriendRelationshipIgnored = 5,			// this is stored; the user has explicit blocked this other user from comments/chat/etc
 	k_EFriendRelationshipIgnoredFriend = 6,
 	k_EFriendRelationshipSuggested = 7,
 
@@ -38,6 +38,12 @@ const int k_cchMaxFriendsGroupName = 64;
 // maximum number of groups a single user is allowed
 const int k_cFriendsGroupLimit = 100;
 
+// friends group identifier type
+typedef int16 FriendsGroupID_t;
+
+// invalid friends group identifier constant
+const FriendsGroupID_t k_FriendsGroupID_Invalid = -1;
+
 const int k_cEnumerateFollowersMax = 50;
 
 
@@ -199,13 +205,27 @@ public:
 	virtual const char *GetFriendPersonaName( CSteamID steamIDFriend ) = 0;
 
 	// returns true if the friend is actually in a game, and fills in pFriendGameInfo with an extra details 
-	virtual bool GetFriendGamePlayed( CSteamID steamIDFriend, FriendGameInfo_t *pFriendGameInfo ) = 0;
+	virtual bool GetFriendGamePlayed( CSteamID steamIDFriend, OUT_STRUCT() FriendGameInfo_t *pFriendGameInfo ) = 0;
 	// accesses old friends names - returns an empty string when their are no more items in the history
 	virtual const char *GetFriendPersonaNameHistory( CSteamID steamIDFriend, int iPersonaName ) = 0;
+	// friends steam level
+	virtual int GetFriendSteamLevel( CSteamID steamIDFriend ) = 0;
 
 	// Returns nickname the current user has set for the specified player. Returns NULL if the no nickname has been set for that player.
 	virtual const char *GetPlayerNickname( CSteamID steamIDPlayer ) = 0;
 
+	// friend grouping (tag) apis
+	// returns the number of friends groups
+	virtual int GetFriendsGroupCount() = 0;
+	// returns the friends group ID for the given index (invalid indices return k_FriendsGroupID_Invalid)
+	virtual FriendsGroupID_t GetFriendsGroupIDByIndex( int iFG ) = 0;
+	// returns the name for the given friends group (NULL in the case of invalid friends group IDs)
+	virtual const char *GetFriendsGroupName( FriendsGroupID_t friendsGroupID ) = 0;
+	// returns the number of members in a given friends group
+	virtual int GetFriendsGroupMembersCount( FriendsGroupID_t friendsGroupID ) = 0;
+	// gets up to nMembersCount members of the given friends group, if fewer exist than requested those positions' SteamIDs will be invalid
+	virtual void GetFriendsGroupMembersList( FriendsGroupID_t friendsGroupID, OUT_ARRAY_CALL(nMembersCount, GetFriendsGroupMembersCount, friendsGroupID ) CSteamID *pOutSteamIDMembers, int nMembersCount ) = 0;
+
 	// returns true if the specified user meets any of the criteria specified in iFriendFlags
 	// iFriendFlags can be the union (binary or, |) of one or more k_EFriendFlags values
 	virtual bool HasFriend( CSteamID steamIDFriend, int iFriendFlags ) = 0;
@@ -218,7 +238,7 @@ public:
 	// returns the most recent information we have about what's happening in a clan
 	virtual bool GetClanActivityCounts( CSteamID steamIDClan, int *pnOnline, int *pnInGame, int *pnChatting ) = 0;
 	// for clans a user is a member of, they will have reasonably up-to-date information, but for others you'll have to download the info to have the latest
-	virtual SteamAPICall_t DownloadClanActivityCounts( CSteamID *psteamIDClans, int cClansToRequest ) = 0;
+	virtual SteamAPICall_t DownloadClanActivityCounts( ARRAY_COUNT(cClansToRequest) CSteamID *psteamIDClans, int cClansToRequest ) = 0;
 
 	// iterators for getting users in a chat room, lobby, game server or clan
 	// note that large clans that cannot be iterated by the local user
@@ -343,7 +363,7 @@ public:
 	virtual int GetClanChatMemberCount( CSteamID steamIDClan ) = 0;
 	virtual CSteamID GetChatMemberByIndex( CSteamID steamIDClan, int iUser ) = 0;
 	virtual bool SendClanChatMessage( CSteamID steamIDClanChat, const char *pchText ) = 0;
-	virtual int GetClanChatMessage( CSteamID steamIDClanChat, int iMessage, void *prgchText, int cchTextMax, EChatEntryType *peChatEntryType, CSteamID *psteamidChatter ) = 0;
+	virtual int GetClanChatMessage( CSteamID steamIDClanChat, int iMessage, void *prgchText, int cchTextMax, EChatEntryType *peChatEntryType, OUT_STRUCT() CSteamID *psteamidChatter ) = 0;
 	virtual bool IsClanChatAdmin( CSteamID steamIDClanChat, CSteamID steamIDUser ) = 0;
 
 	// interact with the Steam (game overlay / desktop)
@@ -363,7 +383,7 @@ public:
 	virtual SteamAPICall_t EnumerateFollowingList( uint32 unStartIndex ) = 0;
 };
 
-#define STEAMFRIENDS_INTERFACE_VERSION "SteamFriends014"
+#define STEAMFRIENDS_INTERFACE_VERSION "SteamFriends015"
 
 // callbacks
 #if defined( VALVE_CALLBACK_PACK_SMALL )
diff --git a/mp/src/public/steam/isteamhtmlsurface.h b/mp/src/public/steam/isteamhtmlsurface.h
index 80216fc9..c257164a 100644
--- a/mp/src/public/steam/isteamhtmlsurface.h
+++ b/mp/src/public/steam/isteamhtmlsurface.h
@@ -13,7 +13,7 @@
 #include "isteamclient.h"
 
 typedef uint32 HHTMLBrowser;
-const uint32 INVALID_HTTMLBROWSER = 0;
+const uint32 INVALID_HTMLBROWSER = 0;
 
 //-----------------------------------------------------------------------------
 // Purpose: Functions for displaying HTML pages and interacting with them
@@ -123,10 +123,10 @@ public:
 
 	enum EHTMLKeyModifiers
 	{
-		eHTMLKeyModifier_None = 0,
-		eHTMLKeyModifier_AltDown = 1 << 0,
-		eHTMLKeyModifier_CrtlDown = 1 << 1,
-		eHTMLKeyModifier_ShiftDown = 1 << 2,
+		k_eHTMLKeyModifier_None = 0,
+		k_eHTMLKeyModifier_AltDown = 1 << 0,
+		k_eHTMLKeyModifier_CtrlDown = 1 << 1,
+		k_eHTMLKeyModifier_ShiftDown = 1 << 2,
 	};
 
 	// keyboard interactions, native keycode is the virtual key code value from your OS
@@ -160,9 +160,15 @@ public:
 	// set a webcookie for the hostname in question
 	virtual void SetCookie( const char *pchHostname, const char *pchKey, const char *pchValue, const char *pchPath = "/", RTime32 nExpires = 0, bool bSecure = false, bool bHTTPOnly = false ) = 0;
 
-	// Zoom the current page by flZoom ( from 0.0 to 4.0, so to zoom to 120% use 1.2 ), zooming around point X,Y in the page (use 0,0 if you don't care)
+	// Zoom the current page by flZoom ( from 0.0 to 2.0, so to zoom to 120% use 1.2 ), zooming around point X,Y in the page (use 0,0 if you don't care)
 	virtual void SetPageScaleFactor( HHTMLBrowser unBrowserHandle, float flZoom, int nPointX, int nPointY ) = 0;
 
+	// Enable/disable low-resource background mode, where javascript and repaint timers are throttled, resources are
+	// more aggressively purged from memory, and audio/video elements are paused. When background mode is enabled,
+	// all HTML5 video and audio objects will execute ".pause()" and gain the property "._steam_background_paused = 1".
+	// When background mode is disabled, any video or audio objects with that property will resume with ".play()".
+	virtual void SetBackgroundMode( HHTMLBrowser unBrowserHandle, bool bBackgroundMode ) = 0;
+
 	// CALLBACKS
 	//
 	//  These set of functions are used as responses to callback requests
@@ -182,7 +188,7 @@ public:
 	virtual void FileLoadDialogResponse( HHTMLBrowser unBrowserHandle, const char **pchSelectedFiles ) = 0;
 };
 
-#define STEAMHTMLSURFACE_INTERFACE_VERSION "STEAMHTMLSURFACE_INTERFACE_VERSION_002"
+#define STEAMHTMLSURFACE_INTERFACE_VERSION "STEAMHTMLSURFACE_INTERFACE_VERSION_003"
 
 // callbacks
 #if defined( VALVE_CALLBACK_PACK_SMALL )
@@ -334,8 +340,8 @@ END_DEFINE_CALLBACK_6()
 //-----------------------------------------------------------------------------
 DEFINE_CALLBACK( HTML_LinkAtPosition_t, k_iSteamHTMLSurfaceCallbacks + 13 )
 CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface 
-CALLBACK_MEMBER( 1, uint32, x ) // 
-CALLBACK_MEMBER( 2, uint32, y ) // 
+CALLBACK_MEMBER( 1, uint32, x ) // NOTE - Not currently set
+CALLBACK_MEMBER( 2, uint32, y ) // NOTE - Not currently set
 CALLBACK_MEMBER( 3, const char *, pchURL ) // 
 CALLBACK_MEMBER( 4, bool, bInput ) // 
 CALLBACK_MEMBER( 5, bool, bLiveLink ) // 
@@ -364,8 +370,8 @@ END_DEFINE_CALLBACK_2()
 
 
 //-----------------------------------------------------------------------------
-// Purpose: show a Javascript confirmation dialog, call JSDialogResponse 
-//   when the user dismisses this dialog (or right away to ignore it)
+// Purpose: when received show a file open dialog
+//   then call FileLoadDialogResponse with the file(s) the user selected.
 //-----------------------------------------------------------------------------
 DEFINE_CALLBACK( HTML_FileOpenDialog_t, k_iSteamHTMLSurfaceCallbacks + 16 )
 CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface 
@@ -375,55 +381,17 @@ END_DEFINE_CALLBACK_3()
 
 
 //-----------------------------------------------------------------------------
-// Purpose: a popup item (i.e combo box) on the page needs rendering
-//-----------------------------------------------------------------------------
-DEFINE_CALLBACK( HTML_ComboNeedsPaint_t, k_iSteamHTMLSurfaceCallbacks + 17 )
-CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface 
-CALLBACK_MEMBER( 1, const char *, pBGRA ) // a pointer to the B8G8R8A8 data for this surface, valid until SteamAPI_RunCallbacks is next called
-CALLBACK_MEMBER( 2, uint32, unWide ) // the total width of the pBGRA texture
-CALLBACK_MEMBER( 3, uint32, unTall ) // the total height of the pBGRA texture
-END_DEFINE_CALLBACK_4()
-
-
-//-----------------------------------------------------------------------------
-// Purpose: a popup (i.e combo box) wants to display
-//-----------------------------------------------------------------------------
-DEFINE_CALLBACK( HTML_ShowPopup_t, k_iSteamHTMLSurfaceCallbacks + 18 )
-CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface 
-END_DEFINE_CALLBACK_1()
-
-
-//-----------------------------------------------------------------------------
-// Purpose: a popup (i.e combo box) wants to hide
-//-----------------------------------------------------------------------------
-DEFINE_CALLBACK( HTML_HidePopup_t, k_iSteamHTMLSurfaceCallbacks + 19 )
-CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface 
-END_DEFINE_CALLBACK_1()
-
-
-//-----------------------------------------------------------------------------
-// Purpose: a popup (i.e combo box) wants to hide
-//-----------------------------------------------------------------------------
-DEFINE_CALLBACK( HTML_SizePopup_t, k_iSteamHTMLSurfaceCallbacks + 20 )
-CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface 
-CALLBACK_MEMBER( 1, uint32, unX ) // the x pos into the page to display the popup
-CALLBACK_MEMBER( 2, uint32, unY ) // the y pos into the page to display the popup
-CALLBACK_MEMBER( 3, uint32, unWide ) // the total width of the pBGRA texture
-CALLBACK_MEMBER( 4, uint32, unTall ) // the total height of the pBGRA texture
-END_DEFINE_CALLBACK_5()
-
-
-//-----------------------------------------------------------------------------
 // Purpose: a new html window has been created 
 //-----------------------------------------------------------------------------
 DEFINE_CALLBACK( HTML_NewWindow_t, k_iSteamHTMLSurfaceCallbacks + 21 )
-CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface 
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the current surface 
 CALLBACK_MEMBER( 1, const char *, pchURL ) // the page to load
 CALLBACK_MEMBER( 2, uint32, unX ) // the x pos into the page to display the popup
 CALLBACK_MEMBER( 3, uint32, unY ) // the y pos into the page to display the popup
 CALLBACK_MEMBER( 4, uint32, unWide ) // the total width of the pBGRA texture
 CALLBACK_MEMBER( 5, uint32, unTall ) // the total height of the pBGRA texture
-END_DEFINE_CALLBACK_6()
+CALLBACK_MEMBER( 6, HHTMLBrowser, unNewWindow_BrowserHandle ) // the handle of the new window surface 
+END_DEFINE_CALLBACK_7()
 
 
 //-----------------------------------------------------------------------------
diff --git a/mp/src/public/steam/isteamhttp.h b/mp/src/public/steam/isteamhttp.h
index d68335d0..8fab537d 100644
--- a/mp/src/public/steam/isteamhttp.h
+++ b/mp/src/public/steam/isteamhttp.h
@@ -1,4 +1,4 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
+//====== Copyright © 1996-2009, Valve Corporation, All rights reserved. =======
 //
 // Purpose: interface to http client 
 //
@@ -17,6 +17,9 @@
 typedef uint32 HTTPRequestHandle;
 #define INVALID_HTTPREQUEST_HANDLE		0
 
+typedef uint32 HTTPCookieContainerHandle;
+#define INVALID_HTTPCOOKIE_HANDLE		0
+
 //-----------------------------------------------------------------------------
 // Purpose: interface to http client
 //-----------------------------------------------------------------------------
@@ -25,8 +28,8 @@ class ISteamHTTP
 public:
 
 	// Initializes a new HTTP request, returning a handle to use in further operations on it.  Requires
-	// the method (GET or POST) and the absolute URL for the request.  Only http requests (ie, not https) are
-	// currently supported, so this string must start with http:// or https:// and should look like http://store.steampowered.com/app/250/ 
+	// the method (GET or POST) and the absolute URL for the request.  Both http and https are supported,
+	// so this string must start with http:// or https:// and should look like http://store.steampowered.com/app/250/ 
 	// or such.
 	virtual HTTPRequestHandle CreateHTTPRequest( EHTTPMethod eHTTPRequestMethod, const char *pchAbsoluteURL ) = 0;
 
@@ -105,6 +108,35 @@ public:
 	// have already been set for the request.  Setting this raw body makes it the only contents for the post, the pchContentType
 	// parameter will set the content-type header for the request so the server may know how to interpret the body.
 	virtual bool SetHTTPRequestRawPostBody( HTTPRequestHandle hRequest, const char *pchContentType, uint8 *pubBody, uint32 unBodyLen ) = 0;
+
+	// Creates a cookie container handle which you must later free with ReleaseCookieContainer().  If bAllowResponsesToModify=true
+	// than any response to your requests using this cookie container may add new cookies which may be transmitted with
+	// future requests.  If bAllowResponsesToModify=false than only cookies you explicitly set will be sent.  This API is just for
+	// during process lifetime, after steam restarts no cookies are persisted and you have no way to access the cookie container across
+	// repeat executions of your process.
+	virtual HTTPCookieContainerHandle CreateCookieContainer( bool bAllowResponsesToModify ) = 0;
+
+	// Release a cookie container you are finished using, freeing it's memory
+	virtual bool ReleaseCookieContainer( HTTPCookieContainerHandle hCookieContainer ) = 0;
+
+	// Adds a cookie to the specified cookie container that will be used with future requests.
+	virtual bool SetCookie( HTTPCookieContainerHandle hCookieContainer, const char *pchHost, const char *pchUrl, const char *pchCookie ) = 0;
+
+	// Set the cookie container to use for a HTTP request
+	virtual bool SetHTTPRequestCookieContainer( HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer ) = 0;
+
+	// Set the extra user agent info for a request, this doesn't clobber the normal user agent, it just adds the extra info on the end
+	virtual bool SetHTTPRequestUserAgentInfo( HTTPRequestHandle hRequest, const char *pchUserAgentInfo ) = 0;
+
+	// Set that https request should require verified SSL certificate via machines certificate trust store
+	virtual bool SetHTTPRequestRequiresVerifiedCertificate( HTTPRequestHandle hRequest, bool bRequireVerifiedCertificate ) = 0;
+
+	// Set an absolute timeout on the HTTP request, this is just a total time timeout different than the network activity timeout
+	// which can bump everytime we get more data
+	virtual bool SetHTTPRequestAbsoluteTimeoutMS( HTTPRequestHandle hRequest, uint32 unMilliseconds ) = 0;
+
+	// Check if the reason the request failed was because we timed it out (rather than some harder failure)
+	virtual bool GetHTTPRequestWasTimedOut( HTTPRequestHandle hRequest, bool *pbWasTimedOut ) = 0;
 };
 
 #define STEAMHTTP_INTERFACE_VERSION "STEAMHTTP_INTERFACE_VERSION002"
@@ -136,6 +168,8 @@ struct HTTPRequestCompleted_t
 	// Will be the HTTP status code value returned by the server, k_EHTTPStatusCode200OK is the normal
 	// OK response, if you get something else you probably need to treat it as a failure.
 	EHTTPStatusCode m_eStatusCode;
+
+	uint32 m_unBodySize; // Same as GetHTTPResponseBodySize()
 };
 
 
diff --git a/mp/src/public/steam/isteammatchmaking.h b/mp/src/public/steam/isteammatchmaking.h
index d6380076..e3be340d 100644
--- a/mp/src/public/steam/isteammatchmaking.h
+++ b/mp/src/public/steam/isteammatchmaking.h
@@ -201,7 +201,7 @@ public:
 	// *pSteamIDUser is filled in with the CSteamID of the member
 	// *pvData is filled in with the message itself
 	// return value is the number of bytes written into the buffer
-	virtual int GetLobbyChatEntry( CSteamID steamIDLobby, int iChatID, CSteamID *pSteamIDUser, void *pvData, int cubData, EChatEntryType *peChatEntryType ) = 0;
+	virtual int GetLobbyChatEntry( CSteamID steamIDLobby, int iChatID, OUT_STRUCT() CSteamID *pSteamIDUser, void *pvData, int cubData, EChatEntryType *peChatEntryType ) = 0;
 
 	// Refreshes metadata for a lobby you're not necessarily in right now
 	// you never do this for lobbies you're a member of, only if your
@@ -217,7 +217,7 @@ public:
 	// either the IP/Port or the steamID of the game server has to be valid, depending on how you want the clients to be able to connect
 	virtual void SetLobbyGameServer( CSteamID steamIDLobby, uint32 unGameServerIP, uint16 unGameServerPort, CSteamID steamIDGameServer ) = 0;
 	// returns the details of a game server set in a lobby - returns false if there is no game server set, or that lobby doesn't exist
-	virtual bool GetLobbyGameServer( CSteamID steamIDLobby, uint32 *punGameServerIP, uint16 *punGameServerPort, CSteamID *psteamIDGameServer ) = 0;
+	virtual bool GetLobbyGameServer( CSteamID steamIDLobby, uint32 *punGameServerIP, uint16 *punGameServerPort, OUT_STRUCT() CSteamID *psteamIDGameServer ) = 0;
 
 	// set the limit on the # of users who can join the lobby
 	virtual bool SetLobbyMemberLimit( CSteamID steamIDLobby, int cMaxMembers ) = 0;
@@ -387,12 +387,12 @@ public:
 	// Request a new list of servers of a particular type.  These calls each correspond to one of the EMatchMakingType values.
 	// Each call allocates a new asynchronous request object.
 	// Request object must be released by calling ReleaseRequest( hServerListRequest )
-	virtual HServerListRequest RequestInternetServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+	virtual HServerListRequest RequestInternetServerList( AppId_t iApp, ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
 	virtual HServerListRequest RequestLANServerList( AppId_t iApp, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
-	virtual HServerListRequest RequestFriendsServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
-	virtual HServerListRequest RequestFavoritesServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
-	virtual HServerListRequest RequestHistoryServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
-	virtual HServerListRequest RequestSpectatorServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+	virtual HServerListRequest RequestFriendsServerList( AppId_t iApp, ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+	virtual HServerListRequest RequestFavoritesServerList( AppId_t iApp, ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+	virtual HServerListRequest RequestHistoryServerList( AppId_t iApp, ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+	virtual HServerListRequest RequestSpectatorServerList( AppId_t iApp, ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
 
 	// Releases the asynchronous request object and cancels any pending query on it if there's a pending query in progress.
 	// RefreshComplete callback is not posted when request is released.
diff --git a/mp/src/public/steam/isteammusicremote.h b/mp/src/public/steam/isteammusicremote.h
index fe083da5..ea29a7de 100644
--- a/mp/src/public/steam/isteammusicremote.h
+++ b/mp/src/public/steam/isteammusicremote.h
@@ -118,6 +118,9 @@ DEFINE_CALLBACK( MusicPlayerSelectsPlaylistEntry_t, k_iSteamMusicCallbacks + 13
 	CALLBACK_MEMBER(0, int, nID )
 END_DEFINE_CALLBACK_1()
 
+DEFINE_CALLBACK( MusicPlayerWantsPlayingRepeatStatus_t, k_iSteamMusicRemoteCallbacks + 14 )
+	CALLBACK_MEMBER(0, int, m_nPlayingRepeatStatus )
+END_DEFINE_CALLBACK_1()
 
 #pragma pack( pop )
 
diff --git a/mp/src/public/steam/isteamremotestorage.h b/mp/src/public/steam/isteamremotestorage.h
index c5a005f3..6853cd6f 100644
--- a/mp/src/public/steam/isteamremotestorage.h
+++ b/mp/src/public/steam/isteamremotestorage.h
@@ -88,24 +88,25 @@ enum EWorkshopFileType
 {
 	k_EWorkshopFileTypeFirst = 0,
 
-	k_EWorkshopFileTypeCommunity			  = 0,
-	k_EWorkshopFileTypeMicrotransaction		  = 1,
-	k_EWorkshopFileTypeCollection			  = 2,
-	k_EWorkshopFileTypeArt					  = 3,
-	k_EWorkshopFileTypeVideo				  = 4,
-	k_EWorkshopFileTypeScreenshot			  = 5,
-	k_EWorkshopFileTypeGame					  = 6,
-	k_EWorkshopFileTypeSoftware				  = 7,
-	k_EWorkshopFileTypeConcept				  = 8,
-	k_EWorkshopFileTypeWebGuide				  = 9,
-	k_EWorkshopFileTypeIntegratedGuide		  = 10,
-	k_EWorkshopFileTypeMerch				  = 11,
-	k_EWorkshopFileTypeControllerBinding	  = 12,
-	k_EWorkshopFileTypeSteamworksAccessInvite = 13,
-	k_EWorkshopFileTypeSteamVideo			  = 14,
+	k_EWorkshopFileTypeCommunity			  = 0,		// normal Workshop item that can be subscribed to
+	k_EWorkshopFileTypeMicrotransaction		  = 1,		// Workshop item that is meant to be voted on for the purpose of selling in-game
+	k_EWorkshopFileTypeCollection			  = 2,		// a collection of Workshop or Greenlight items
+	k_EWorkshopFileTypeArt					  = 3,		// artwork
+	k_EWorkshopFileTypeVideo				  = 4,		// external video
+	k_EWorkshopFileTypeScreenshot			  = 5,		// screenshot
+	k_EWorkshopFileTypeGame					  = 6,		// Greenlight game entry
+	k_EWorkshopFileTypeSoftware				  = 7,		// Greenlight software entry
+	k_EWorkshopFileTypeConcept				  = 8,		// Greenlight concept
+	k_EWorkshopFileTypeWebGuide				  = 9,		// Steam web guide
+	k_EWorkshopFileTypeIntegratedGuide		  = 10,		// application integrated guide
+	k_EWorkshopFileTypeMerch				  = 11,		// Workshop merchandise meant to be voted on for the purpose of being sold
+	k_EWorkshopFileTypeControllerBinding	  = 12,		// Steam Controller bindings
+	k_EWorkshopFileTypeSteamworksAccessInvite = 13,		// internal
+	k_EWorkshopFileTypeSteamVideo			  = 14,		// Steam video
+	k_EWorkshopFileTypeGameManagedItem		  = 15,		// managed completely by the game, not the user, and not shown on the web
 
 	// Update k_EWorkshopFileTypeMax if you add values.
-	k_EWorkshopFileTypeMax = 15
+	k_EWorkshopFileTypeMax = 16
 	
 };
 
@@ -114,6 +115,7 @@ enum EWorkshopVote
 	k_EWorkshopVoteUnvoted = 0,
 	k_EWorkshopVoteFor = 1,
 	k_EWorkshopVoteAgainst = 2,
+	k_EWorkshopVoteLater = 3,
 };
 
 enum EWorkshopFileAction
@@ -214,7 +216,7 @@ class ISteamRemoteStorage
 		virtual bool	GetUGCDownloadProgress( UGCHandle_t hContent, int32 *pnBytesDownloaded, int32 *pnBytesExpected ) = 0;
 
 		// Gets metadata for a file after it has been downloaded. This is the same metadata given in the RemoteStorageDownloadUGCResult_t call result
-		virtual bool	GetUGCDetails( UGCHandle_t hContent, AppId_t *pnAppID, char **ppchName, int32 *pnFileSizeInBytes, CSteamID *pSteamIDOwner ) = 0;
+		virtual bool	GetUGCDetails( UGCHandle_t hContent, AppId_t *pnAppID, char **ppchName, int32 *pnFileSizeInBytes, OUT_STRUCT() CSteamID *pSteamIDOwner ) = 0;
 
 		// After download, gets the content of the file.  
 		// Small files can be read all at once by calling this function with an offset of 0 and cubDataToRead equal to the size of the file.
diff --git a/mp/src/public/steam/isteamugc.h b/mp/src/public/steam/isteamugc.h
index 4bab58d6..6ac2a555 100644
--- a/mp/src/public/steam/isteamugc.h
+++ b/mp/src/public/steam/isteamugc.h
@@ -45,6 +45,7 @@ enum EUGCMatchingUGCType
 	k_EUGCMatchingUGCType_IntegratedGuides	 = 9,
 	k_EUGCMatchingUGCType_UsableInGame		 = 10,		// ready-to-use items and integrated guides
 	k_EUGCMatchingUGCType_ControllerBindings = 11,
+	k_EUGCMatchingUGCType_GameManagedItems	 = 12,		// game managed items (not managed by users)
 };
 
 // Different lists of published UGC for a user.
@@ -89,6 +90,7 @@ enum EUGCQuery
 	k_EUGCQuery_RankedByTotalVotesAsc						  = 9,
 	k_EUGCQuery_RankedByVotesUp								  = 10,
 	k_EUGCQuery_RankedByTextSearch							  = 11,
+	k_EUGCQuery_RankedByTotalUniqueSubscriptions			  = 12,
 };
 
 enum EItemUpdateStatus
@@ -101,8 +103,31 @@ enum EItemUpdateStatus
 	k_EItemUpdateStatusCommittingChanges	= 5  // The item update is committing all changes
 };
 
+enum EItemState
+{
+	k_EItemStateNone			= 0,	// item not tracked on client
+	k_EItemStateSubscribed		= 1,	// current user is subscribed to this item. Not just cached.
+	k_EItemStateLegacyItem		= 2,	// item was created with ISteamRemoteStorage
+	k_EItemStateInstalled		= 4,	// item is installed and usable (but maybe out of date)
+	k_EItemStateNeedsUpdate		= 8,	// items needs an update. Either because it's not installed yet or creator updated content
+	k_EItemStateDownloading		= 16,	// item update is currently downloading
+	k_EItemStateDownloadPending	= 32,	// DownloadItem() was called for this item, content isn't available until DownloadItemResult_t is fired
+};
+
+enum EItemStatistic
+{
+	k_EItemStatistic_NumSubscriptions		= 0,
+	k_EItemStatistic_NumFavorites			= 1,
+	k_EItemStatistic_NumFollowers			= 2,
+	k_EItemStatistic_NumUniqueSubscriptions = 3,
+	k_EItemStatistic_NumUniqueFavorites		= 4,
+	k_EItemStatistic_NumUniqueFollowers		= 5,
+	k_EItemStatistic_NumUniqueWebsiteViews	= 6,
+	k_EItemStatistic_ReportScore			= 7,
+};
 
 const uint32 kNumUGCResultsPerPage = 50;
+const uint32 k_cchDeveloperMetadataMax = 5000;
 
 // Details for a single published file/UGC
 struct SteamUGCDetails_t
@@ -134,7 +159,8 @@ struct SteamUGCDetails_t
 	uint32 m_unVotesUp;												// number of votes up
 	uint32 m_unVotesDown;											// number of votes down
 	float m_flScore;												// calculated score
-	uint32 m_unNumChildren;											// if m_eFileType == k_EWorkshopFileTypeCollection, then this number will be the number of children contained within the collection
+	// collection details
+	uint32 m_unNumChildren;							
 };
 
 //-----------------------------------------------------------------------------
@@ -150,11 +176,22 @@ public:
 	// Query for all matching UGC. Creator app id or consumer app id must be valid and be set to the current running app. unPage should start at 1.
 	virtual UGCQueryHandle_t CreateQueryAllUGCRequest( EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ) = 0;
 
+	// Query for the details of the given published file ids (the RequestUGCDetails call is deprecated and replaced with this)
+	virtual UGCQueryHandle_t CreateQueryUGCDetailsRequest( PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs ) = 0;
+
 	// Send the query to Steam
 	virtual SteamAPICall_t SendQueryUGCRequest( UGCQueryHandle_t handle ) = 0;
 
 	// Retrieve an individual result after receiving the callback for querying UGC
 	virtual bool GetQueryUGCResult( UGCQueryHandle_t handle, uint32 index, SteamUGCDetails_t *pDetails ) = 0;
+	virtual bool GetQueryUGCPreviewURL( UGCQueryHandle_t handle, uint32 index, char *pchURL, uint32 cchURLSize ) = 0;
+	virtual bool GetQueryUGCMetadata( UGCQueryHandle_t handle, uint32 index, char *pchMetadata, uint32 cchMetadatasize ) = 0;
+	virtual bool GetQueryUGCChildren( UGCQueryHandle_t handle, uint32 index, PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries ) = 0;
+	virtual bool GetQueryUGCStatistic( UGCQueryHandle_t handle, uint32 index, EItemStatistic eStatType, uint32 *pStatValue ) = 0;
+	virtual uint32 GetQueryUGCNumAdditionalPreviews( UGCQueryHandle_t handle, uint32 index ) = 0;
+	virtual bool GetQueryUGCAdditionalPreview( UGCQueryHandle_t handle, uint32 index, uint32 previewIndex, char *pchURLOrVideoID, uint32 cchURLSize, bool *pbIsImage ) = 0;
+	virtual uint32 GetQueryUGCNumKeyValueTags( UGCQueryHandle_t handle, uint32 index ) = 0;
+	virtual bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint32 index, uint32 keyValueTagIndex, char *pchKey, uint32 cchKeySize, char *pchValue, uint32 cchValueSize ) = 0;
 
 	// Release the request to free up memory, after retrieving results
 	virtual bool ReleaseQueryUGCRequest( UGCQueryHandle_t handle ) = 0;
@@ -162,8 +199,13 @@ public:
 	// Options to set for querying UGC
 	virtual bool AddRequiredTag( UGCQueryHandle_t handle, const char *pTagName ) = 0;
 	virtual bool AddExcludedTag( UGCQueryHandle_t handle, const char *pTagName ) = 0;
+	virtual bool SetReturnKeyValueTags( UGCQueryHandle_t handle, bool bReturnKeyValueTags ) = 0;
 	virtual bool SetReturnLongDescription( UGCQueryHandle_t handle, bool bReturnLongDescription ) = 0;
+	virtual bool SetReturnMetadata( UGCQueryHandle_t handle, bool bReturnMetadata ) = 0;
+	virtual bool SetReturnChildren( UGCQueryHandle_t handle, bool bReturnChildren ) = 0;
+	virtual bool SetReturnAdditionalPreviews( UGCQueryHandle_t handle, bool bReturnAdditionalPreviews ) = 0;
 	virtual bool SetReturnTotalOnly( UGCQueryHandle_t handle, bool bReturnTotalOnly ) = 0;
+	virtual bool SetLanguage( UGCQueryHandle_t handle, const char *pchLanguage ) = 0;
 	virtual bool SetAllowCachedResponse( UGCQueryHandle_t handle, uint32 unMaxAgeSeconds ) = 0;
 
 	// Options only for querying user UGC
@@ -173,8 +215,9 @@ public:
 	virtual bool SetMatchAnyTag( UGCQueryHandle_t handle, bool bMatchAnyTag ) = 0;
 	virtual bool SetSearchText( UGCQueryHandle_t handle, const char *pSearchText ) = 0;
 	virtual bool SetRankedByTrendDays( UGCQueryHandle_t handle, uint32 unDays ) = 0;
+	virtual bool AddRequiredKeyValueTag( UGCQueryHandle_t handle, const char *pKey, const char *pValue ) = 0;
 
-	// Request full details for one piece of UGC
+	// DEPRECATED - Use CreateQueryUGCDetailsRequest call above instead!
 	virtual SteamAPICall_t RequestUGCDetails( PublishedFileId_t nPublishedFileID, uint32 unMaxAgeSeconds ) = 0;
 
 	// Steam Workshop Creator API
@@ -184,27 +227,49 @@ public:
 
 	virtual bool SetItemTitle( UGCUpdateHandle_t handle, const char *pchTitle ) = 0; // change the title of an UGC item
 	virtual bool SetItemDescription( UGCUpdateHandle_t handle, const char *pchDescription ) = 0; // change the description of an UGC item
+	virtual bool SetItemUpdateLanguage( UGCUpdateHandle_t handle, const char *pchLanguage ) = 0; // specify the language of the title or description that will be set
+	virtual bool SetItemMetadata( UGCUpdateHandle_t handle, const char *pchMetaData ) = 0; // change the metadata of an UGC item (max = k_cchDeveloperMetadataMax)
 	virtual bool SetItemVisibility( UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility ) = 0; // change the visibility of an UGC item
 	virtual bool SetItemTags( UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t *pTags ) = 0; // change the tags of an UGC item
 	virtual bool SetItemContent( UGCUpdateHandle_t handle, const char *pszContentFolder ) = 0; // update item content from this local folder
-	virtual bool SetItemPreview( UGCUpdateHandle_t handle, const char *pszPreviewFile ) = 0; //  change preview image file for this item. pszPreviewFile points to local image file 
+	virtual bool SetItemPreview( UGCUpdateHandle_t handle, const char *pszPreviewFile ) = 0; //  change preview image file for this item. pszPreviewFile points to local image file, which must be under 1MB in size
+	virtual bool RemoveItemKeyValueTags( UGCUpdateHandle_t handle, const char *pchKey ) = 0; // remove any existing key-value tags with the specified key
+	virtual bool AddItemKeyValueTag( UGCUpdateHandle_t handle, const char *pchKey, const char *pchValue ) = 0; // add new key-value tags for the item. Note that there can be multiple values for a tag.
 
 	virtual SteamAPICall_t SubmitItemUpdate( UGCUpdateHandle_t handle, const char *pchChangeNote ) = 0; // commit update process started with StartItemUpdate()
 	virtual EItemUpdateStatus GetItemUpdateProgress( UGCUpdateHandle_t handle, uint64 *punBytesProcessed, uint64* punBytesTotal ) = 0;
 
 	// Steam Workshop Consumer API
-	virtual SteamAPICall_t SubscribeItem( PublishedFileId_t nPublishedFileID ) = 0; // subscript to this item, will be installed ASAP
+	virtual SteamAPICall_t SetUserItemVote( PublishedFileId_t nPublishedFileID, bool bVoteUp ) = 0;
+	virtual SteamAPICall_t GetUserItemVote( PublishedFileId_t nPublishedFileID ) = 0;
+	virtual SteamAPICall_t AddItemToFavorites( AppId_t nAppId, PublishedFileId_t nPublishedFileID ) = 0;
+	virtual SteamAPICall_t RemoveItemFromFavorites( AppId_t nAppId, PublishedFileId_t nPublishedFileID ) = 0;
+	virtual SteamAPICall_t SubscribeItem( PublishedFileId_t nPublishedFileID ) = 0; // subscribe to this item, will be installed ASAP
 	virtual SteamAPICall_t UnsubscribeItem( PublishedFileId_t nPublishedFileID ) = 0; // unsubscribe from this item, will be uninstalled after game quits
 	virtual uint32 GetNumSubscribedItems() = 0; // number of subscribed items 
 	virtual uint32 GetSubscribedItems( PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries ) = 0; // all subscribed item PublishFileIDs
 
-	// Get info about the item on disk.  If you are supporting items published through the legacy RemoteStorage APIs then *pbLegacyItem will be set to true
-	// and pchFolder will contain the full path to the file rather than the containing folder.
-	virtual bool GetItemInstallInfo( PublishedFileId_t nPublishedFileID, uint64 *punSizeOnDisk, char *pchFolder, uint32 cchFolderSize, bool *pbLegacyItem ) = 0; // returns true if item is installed
-	virtual bool GetItemUpdateInfo( PublishedFileId_t nPublishedFileID, bool *pbNeedsUpdate, bool *pbIsDownloading, uint64 *punBytesDownloaded, uint64 *punBytesTotal ) = 0;
+	// get EItemState flags about item on this client
+	virtual uint32 GetItemState( PublishedFileId_t nPublishedFileID ) = 0;
+
+	// get info about currently installed content on disc for items that have k_EItemStateInstalled set
+	// if k_EItemStateLegacyItem is set, pchFolder contains the path to the legacy file itself (not a folder)
+	virtual bool GetItemInstallInfo( PublishedFileId_t nPublishedFileID, uint64 *punSizeOnDisk, char *pchFolder, uint32 cchFolderSize, uint32 *punTimeStamp ) = 0;
+
+	// get info about pending update for items that have k_EItemStateNeedsUpdate set. punBytesTotal will be valid after download started once
+	virtual bool GetItemDownloadInfo( PublishedFileId_t nPublishedFileID, uint64 *punBytesDownloaded, uint64 *punBytesTotal ) = 0;
+		
+	// download new or update already installed item. If function returns true, wait for DownloadItemResult_t. If the item is already installed,
+	// then files on disk should not be used until callback received. If item is not subscribed to, it will be cached for some time.
+	// If bHighPriority is set, any other item download will be suspended and this item downloaded ASAP.
+	virtual bool DownloadItem( PublishedFileId_t nPublishedFileID, bool bHighPriority ) = 0;
+
+	// game servers can set a specific workshop folder before issuing any UGC commands.
+	// This is helpful if you want to support multiple game servers running out of the same install folder
+	virtual bool BInitWorkshopForGameServer( DepotId_t unWorkshopDepotID, const char *pszFolder ) = 0;
 };
 
-#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION003"
+#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION007"
 
 //-----------------------------------------------------------------------------
 // Purpose: Callback for querying UGC
@@ -255,7 +320,7 @@ struct SubmitItemUpdateResult_t
 
 
 //-----------------------------------------------------------------------------
-// Purpose: a new Workshop item has been installed 
+// Purpose: a Workshop item has been installed or updated
 //-----------------------------------------------------------------------------
 struct ItemInstalled_t
 {
@@ -265,6 +330,52 @@ struct ItemInstalled_t
 };
 
 
+//-----------------------------------------------------------------------------
+// Purpose: result of DownloadItem(), existing item files can be accessed again
+//-----------------------------------------------------------------------------
+struct DownloadItemResult_t
+{
+	enum { k_iCallback = k_iClientUGCCallbacks + 6 };
+	AppId_t m_unAppID;
+	PublishedFileId_t m_nPublishedFileId;
+	EResult m_eResult;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: result of AddItemToFavorites() or RemoveItemFromFavorites()
+//-----------------------------------------------------------------------------
+struct UserFavoriteItemsListChanged_t
+{
+	enum { k_iCallback = k_iClientUGCCallbacks + 7 };
+	PublishedFileId_t m_nPublishedFileId;
+	EResult m_eResult;
+	bool m_bWasAddRequest;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to SetUserItemVote()
+//-----------------------------------------------------------------------------
+struct SetUserItemVoteResult_t
+{
+	enum { k_iCallback = k_iClientUGCCallbacks + 8 };
+	PublishedFileId_t m_nPublishedFileId;
+	EResult m_eResult;
+	bool m_bVoteUp;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to GetUserItemVote()
+//-----------------------------------------------------------------------------
+struct GetUserItemVoteResult_t
+{
+	enum { k_iCallback = k_iClientUGCCallbacks + 9 };
+	PublishedFileId_t m_nPublishedFileId;
+	EResult m_eResult;
+	bool m_bVotedUp;
+	bool m_bVotedDown;
+	bool m_bVoteSkipped;
+};
+
 #pragma pack( pop )
 
 #endif // ISTEAMUGC_H
diff --git a/mp/src/public/steam/isteamuser.h b/mp/src/public/steam/isteamuser.h
index a670849e..989b88e7 100644
--- a/mp/src/public/steam/isteamuser.h
+++ b/mp/src/public/steam/isteamuser.h
@@ -166,6 +166,18 @@ public:
 	// gets the Steam Level of the user, as shown on their profile
 	virtual int GetPlayerSteamLevel() = 0;
 
+	// Requests a URL which authenticates an in-game browser for store check-out,
+	// and then redirects to the specified URL. As long as the in-game browser
+	// accepts and handles session cookies, Steam microtransaction checkout pages
+	// will automatically recognize the user instead of presenting a login page.
+	// The result of this API call will be a StoreAuthURLResponse_t callback.
+	// NOTE: The URL has a very short lifetime to prevent history-snooping attacks,
+	// so you should only call this API when you are about to launch the browser,
+	// or else immediately navigate to the result URL using a hidden browser window.
+	// NOTE 2: The resulting authorization cookie has an expiration time of one day,
+	// so it would be a good idea to request and visit a new auth URL every 12 hours.
+	virtual SteamAPICall_t RequestStoreAuthURL( const char *pchRedirectURL ) = 0;
+
 #ifdef _PS3
 	// Initiates PS3 Logon request using just PSN ticket.  
 	//
@@ -205,7 +217,7 @@ public:
 
 };
 
-#define STEAMUSER_INTERFACE_VERSION "SteamUser017"
+#define STEAMUSER_INTERFACE_VERSION "SteamUser018"
 
 
 // callbacks
@@ -288,6 +300,15 @@ struct IPCFailure_t
 
 
 //-----------------------------------------------------------------------------
+// Purpose: Signaled whenever licenses change
+//-----------------------------------------------------------------------------
+struct LicensesUpdated_t
+{
+	enum { k_iCallback = k_iSteamUserCallbacks + 25 };
+};
+
+
+//-----------------------------------------------------------------------------
 // callback for BeginAuthSession
 //-----------------------------------------------------------------------------
 struct ValidateAuthTicketResponse_t
@@ -342,6 +363,16 @@ struct GameWebCallback_t
 	char m_szURL[256];
 };
 
+//-----------------------------------------------------------------------------
+// Purpose: sent to your game in response to ISteamUser::RequestStoreAuthURL
+//-----------------------------------------------------------------------------
+struct StoreAuthURLResponse_t
+{
+	enum { k_iCallback = k_iSteamUserCallbacks + 65 };
+	char m_szURL[512];
+};
+
+
 
 #pragma pack( pop )
 
diff --git a/mp/src/public/steam/isteamuserstats.h b/mp/src/public/steam/isteamuserstats.h
index c5847cf6..3a65691c 100644
--- a/mp/src/public/steam/isteamuserstats.h
+++ b/mp/src/public/steam/isteamuserstats.h
@@ -1,4 +1,4 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
+//====== Copyright � 1996-2009, Valve Corporation, All rights reserved. =======
 //
 // Purpose: interface to stats, achievements, and leaderboards 
 //
@@ -194,7 +194,9 @@ public:
 	// as above, but downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers
 	// if a user doesn't have a leaderboard entry, they won't be included in the result
 	// a max of 100 users can be downloaded at a time, with only one outstanding call at a time
-	virtual SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard, CSteamID *prgUsers, int cUsers ) = 0;
+	METHOD_DESC(Downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers)
+	virtual SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard,
+															   ARRAY_COUNT_D(cUsers, Array of users to retrieve) CSteamID *prgUsers, int cUsers ) = 0;
 
 	// Returns data about a single leaderboard entry
 	// use a for loop from 0 to LeaderboardScoresDownloaded_t::m_cEntryCount to get all the downloaded entries
@@ -259,8 +261,8 @@ public:
 	// So when called, pData[0] will be today, pData[1] will be yesterday, and pData[2] will be two days ago, 
 	// etc. cubData is the size in bytes of the pubData buffer. Returns the number of 
 	// elements actually set.
-	virtual int32 GetGlobalStatHistory( const char *pchStatName, int64 *pData, uint32 cubData ) = 0;
-	virtual int32 GetGlobalStatHistory( const char *pchStatName, double *pData, uint32 cubData ) = 0;
+	virtual int32 GetGlobalStatHistory( const char *pchStatName, ARRAY_COUNT(cubData) int64 *pData, uint32 cubData ) = 0;
+	virtual int32 GetGlobalStatHistory( const char *pchStatName, ARRAY_COUNT(cubData) double *pData, uint32 cubData ) = 0;
 
 #ifdef _PS3
 	// Call to kick off installation of the PS3 trophies. This call is asynchronous, and the results will be returned in a PS3TrophiesInstalled_t
diff --git a/mp/src/public/steam/isteamutils.h b/mp/src/public/steam/isteamutils.h
index 7f8d6bf0..54777d33 100644
--- a/mp/src/public/steam/isteamutils.h
+++ b/mp/src/public/steam/isteamutils.h
@@ -160,6 +160,9 @@ public:
 
 	// returns true if Steam itself is running in VR mode
 	virtual bool IsSteamRunningInVR() = 0;
+	
+	// Sets the inset of the overlay notification from the corner specified by SetOverlayNotificationPosition.
+	virtual void SetOverlayNotificationInset( int nHorizontalInset, int nVerticalInset ) = 0;
 };
 
 #define STEAMUTILS_INTERFACE_VERSION "SteamUtils007"
diff --git a/mp/src/public/steam/matchmakingtypes.h b/mp/src/public/steam/matchmakingtypes.h
index df6a2d4f..08d5a966 100644
--- a/mp/src/public/steam/matchmakingtypes.h
+++ b/mp/src/public/steam/matchmakingtypes.h
@@ -64,6 +64,8 @@ enum EMatchMakingServerResponse
 class servernetadr_t 
 {
 public:
+
+	servernetadr_t() : m_usConnectionPort( 0 ), m_usQueryPort( 0 ), m_unIP( 0 ) {}
 	
 	void	Init( unsigned int ip, uint16 usQueryPort, uint16 usConnectionPort );
 #ifdef NETADR_H
@@ -154,9 +156,9 @@ inline const char *servernetadr_t::ToString( uint32 unIP, uint16 usPort ) const
 	static int nBuf = 0;
 	unsigned char *ipByte = (unsigned char *)&unIP;
 #ifdef VALVE_BIG_ENDIAN
-	Q_snprintf (s[nBuf], sizeof( s[nBuf] ), "%u.%u.%u.%u:%i", (int)(ipByte[0]), (int)(ipByte[1]), (int)(ipByte[2]), (int)(ipByte[3]), usPort );
+	V_snprintf (s[nBuf], sizeof( s[nBuf] ), "%u.%u.%u.%u:%i", (int)(ipByte[0]), (int)(ipByte[1]), (int)(ipByte[2]), (int)(ipByte[3]), usPort );
 #else
-	Q_snprintf (s[nBuf], sizeof( s[nBuf] ), "%u.%u.%u.%u:%i", (int)(ipByte[3]), (int)(ipByte[2]), (int)(ipByte[1]), (int)(ipByte[0]), usPort );
+	V_snprintf (s[nBuf], sizeof( s[nBuf] ), "%u.%u.%u.%u:%i", (int)(ipByte[3]), (int)(ipByte[2]), (int)(ipByte[1]), (int)(ipByte[0]), usPort );
 #endif
 	const char *pchRet = s[nBuf];
 	++nBuf;
diff --git a/mp/src/public/steam/steam_api.h b/mp/src/public/steam/steam_api.h
index 9850cd7b..b6ab4edf 100644
--- a/mp/src/public/steam/steam_api.h
+++ b/mp/src/public/steam/steam_api.h
@@ -133,31 +133,56 @@ S_API ISteamPS3OverlayRender *S_CALLTYPE SteamPS3OverlayRender();
 #endif
 #endif // VERSION_SAFE_STEAM_API_INTERFACES
 
+
 //----------------------------------------------------------------------------------------------------------------------------------------------------------//
-//	steam callback helper functions
+//	steam callback and call-result helpers
+//
+//	The following macros and classes are used to register your application for
+//	callbacks and call-results, which are delivered in a predictable manner.
+//
+//	STEAM_CALLBACK macros are meant for use inside of a C++ class definition.
+//	They map a Steam notification callback directly to a class member function
+//	which is automatically prototyped as "void func( callback_type *pParam )".
 //
-//	The following classes/macros are used to be able to easily multiplex callbacks 
-//	from the Steam API into various objects in the app in a thread-safe manner
+//	CCallResult is used with specific Steam APIs that return "result handles".
+//	The handle can be passed to a CCallResult object's Set function, along with
+//	an object pointer and member-function pointer. The member function will
+//	be executed once the results of the Steam API call are available.
 //
-//	These functors are triggered via the SteamAPI_RunCallbacks() function, mapping the callback
-//  to as many functions/objects as are registered to it
+//	CCallback and CCallbackManual classes can be used instead of STEAM_CALLBACK
+//	macros if you require finer control over registration and unregistration.
+//
+//	Callbacks and call-results are queued automatically and are only
+//	delivered/executed when your application calls SteamAPI_RunCallbacks().
 //----------------------------------------------------------------------------------------------------------------------------------------------------------//
 
 S_API void S_CALLTYPE SteamAPI_RunCallbacks();
 
 
 
-// functions used by the utility CCallback objects to receive callbacks
+// Declares a callback member function plus a helper member variable which
+// registers the callback on object creation and unregisters on destruction.
+// The optional fourth 'var' param exists only for backwards-compatibility
+// and can be ignored.
+#define STEAM_CALLBACK( thisclass, func, .../*callback_type, [deprecated] var*/ ) \
+	_STEAM_CALLBACK_SELECT( ( __VA_ARGS__, 4, 3 ), ( /**/, thisclass, func, __VA_ARGS__ ) )
+
+// Declares a callback function and a named CCallbackManual variable which
+// has Register and Unregister functions instead of automatic registration.
+#define STEAM_CALLBACK_MANUAL( thisclass, func, callback_type, var )	\
+	CCallbackManual< thisclass, callback_type > var; void func( callback_type *pParam )
+
+
+// Internal functions used by the utility CCallback objects to receive callbacks
 S_API void S_CALLTYPE SteamAPI_RegisterCallback( class CCallbackBase *pCallback, int iCallback );
 S_API void S_CALLTYPE SteamAPI_UnregisterCallback( class CCallbackBase *pCallback );
-// functions used by the utility CCallResult objects to receive async call results
+// Internal functions used by the utility CCallResult objects to receive async call results
 S_API void S_CALLTYPE SteamAPI_RegisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall );
 S_API void S_CALLTYPE SteamAPI_UnregisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall );
 
 
 //-----------------------------------------------------------------------------
-// Purpose: base for callbacks, 
-//			used only by CCallback, shouldn't be used directly
+// Purpose: base for callbacks and call results - internal implementation detail
 //-----------------------------------------------------------------------------
 class CCallbackBase
 {
@@ -174,6 +199,26 @@ protected:
 	uint8 m_nCallbackFlags;
 	int m_iCallback;
 	friend class CCallbackMgr;
+
+private:
+	CCallbackBase( const CCallbackBase& );
+	CCallbackBase& operator=( const CCallbackBase& );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: templated base for callbacks - internal implementation detail
+//-----------------------------------------------------------------------------
+template< int sizeof_P >
+class CCallbackImpl : protected CCallbackBase
+{
+public:
+	~CCallbackImpl() { if ( m_nCallbackFlags & k_ECallbackFlagsRegistered ) SteamAPI_UnregisterCallback( this ); }
+	void SetGameserverFlag() { m_nCallbackFlags |= k_ECallbackFlagsGameServer; }
+
+protected:
+	virtual void Run( void *pvParam ) = 0;
+	virtual void Run( void *pvParam, bool /*bIOFailure*/, SteamAPICall_t /*hSteamAPICall*/ ) { Run( pvParam ); }
+	virtual int GetCallbackSizeBytes() { return sizeof_P; }
 };
 
 
@@ -235,7 +280,7 @@ private:
 		m_hAPICall = k_uAPICallInvalid; // caller unregisters for us
 		(m_pObj->*m_Func)( (P *)pvParam, false );		
 	}
-	void Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall )
+	virtual void Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall )
 	{
 		if ( hSteamAPICall == m_hAPICall )
 		{
@@ -243,7 +288,7 @@ private:
 			(m_pObj->*m_Func)( (P *)pvParam, bIOFailure );			
 		}
 	}
-	int GetCallbackSizeBytes()
+	virtual int GetCallbackSizeBytes()
 	{
 		return sizeof( P );
 	}
@@ -257,31 +302,24 @@ private:
 
 //-----------------------------------------------------------------------------
 // Purpose: maps a steam callback to a class member function
-//			template params: T = local class, P = parameter struct
+//			template params: T = local class, P = parameter struct,
+//			bGameserver = listen for gameserver callbacks instead of client callbacks
 //-----------------------------------------------------------------------------
-template< class T, class P, bool bGameServer >
-class CCallback : protected CCallbackBase
+template< class T, class P, bool bGameserver = false >
+class CCallback : public CCallbackImpl< sizeof( P ) >
 {
 public:
-	typedef void (T::*func_t)( P* );
+	typedef void (T::*func_t)(P*);
 
-	// If you can't support constructing a callback with the correct parameters
-	// then uncomment the empty constructor below and manually call
-	// ::Register() for your object
-	// Or, just call the regular constructor with (NULL, NULL)
-	// CCallback() {}
-	
-	// constructor for initializing this object in owner's constructor
-	CCallback( T *pObj, func_t func ) : m_pObj( pObj ), m_Func( func )
+	// NOTE: If you can't provide the correct parameters at construction time, you should
+	// use the CCallbackManual callback object (STEAM_CALLBACK_MANUAL macro) instead.
+	CCallback( T *pObj, func_t func ) : m_pObj( NULL ), m_Func( NULL )
 	{
-		if ( pObj && func )
-			Register( pObj, func );
-	}
-
-	~CCallback()
-	{
-		if ( m_nCallbackFlags & k_ECallbackFlagsRegistered )
-			Unregister();
+		if ( bGameserver )
+		{
+			this->SetGameserverFlag();
+		}
+		Register( pObj, func );
 	}
 
 	// manual registration of the callback
@@ -290,13 +328,9 @@ public:
 		if ( !pObj || !func )
 			return;
 
-		if ( m_nCallbackFlags & k_ECallbackFlagsRegistered )
+		if ( this->m_nCallbackFlags & CCallbackBase::k_ECallbackFlagsRegistered )
 			Unregister();
 
-		if ( bGameServer )
-		{
-			m_nCallbackFlags |= k_ECallbackFlagsGameServer;
-		}
 		m_pObj = pObj;
 		m_Func = func;
 		// SteamAPI_RegisterCallback sets k_ECallbackFlagsRegistered
@@ -309,38 +343,50 @@ public:
 		SteamAPI_UnregisterCallback( this );
 	}
 
-	void SetGameserverFlag() { m_nCallbackFlags |= k_ECallbackFlagsGameServer; }
 protected:
 	virtual void Run( void *pvParam )
 	{
 		(m_pObj->*m_Func)( (P *)pvParam );
 	}
-	virtual void Run( void *pvParam, bool, SteamAPICall_t )
-	{
-		(m_pObj->*m_Func)( (P *)pvParam );
-	}
-	int GetCallbackSizeBytes()
-	{
-		return sizeof( P );
-	}
 
 	T *m_pObj;
 	func_t m_Func;
 };
 
-// Allows you to defer registration of the callback
-template< class T, class P, bool bGameServer >
+
+//-----------------------------------------------------------------------------
+// Purpose: subclass of CCallback which allows default-construction in
+//			an unregistered state; you must call Register manually
+//-----------------------------------------------------------------------------
+template< class T, class P, bool bGameServer = false >
 class CCallbackManual : public CCallback< T, P, bGameServer >
 {
 public:
 	CCallbackManual() : CCallback< T, P, bGameServer >( NULL, NULL ) {}
+
+	// Inherits public Register and Unregister functions from base class
 };
 
-// utility macro for declaring the function and callback object together
-#define STEAM_CALLBACK( thisclass, func, param, var ) CCallback< thisclass, param, false > var; void func( param *pParam )
 
-// same as above, but lets you defer the callback binding by calling Register later
-#define STEAM_CALLBACK_MANUAL( thisclass, func, param, var ) CCallbackManual< thisclass, param, false > var; void func( param *pParam )
+
+//-----------------------------------------------------------------------------
+// The following macros are implementation details, not intended for public use
+//-----------------------------------------------------------------------------
+#define _STEAM_CALLBACK_AUTO_HOOK( thisclass, func, param )
+#define _STEAM_CALLBACK_HELPER( _1, _2, SELECTED, ... )		_STEAM_CALLBACK_##SELECTED
+#define _STEAM_CALLBACK_SELECT( X, Y )						_STEAM_CALLBACK_HELPER X Y
+#define _STEAM_CALLBACK_3( extra_code, thisclass, func, param ) \
+	struct CCallbackInternal_ ## func : private CCallbackImpl< sizeof( param ) > { \
+		CCallbackInternal_ ## func () { extra_code SteamAPI_RegisterCallback( this, param::k_iCallback ); } \
+		CCallbackInternal_ ## func ( const CCallbackInternal_ ## func & ) { extra_code SteamAPI_RegisterCallback( this, param::k_iCallback ); } \
+		CCallbackInternal_ ## func & operator=( const CCallbackInternal_ ## func & ) { return *this; } \
+		private: virtual void Run( void *pvParam ) { _STEAM_CALLBACK_AUTO_HOOK( thisclass, func, param ) \
+			thisclass *pOuter = reinterpret_cast<thisclass*>( reinterpret_cast<char*>(this) - offsetof( thisclass, m_steamcallback_ ## func ) ); \
+			pOuter->func( reinterpret_cast<param*>( pvParam ) ); \
+		} \
+	} m_steamcallback_ ## func ; void func( param *pParam )
+#define _STEAM_CALLBACK_4( _, thisclass, func, param, var ) \
+	CCallback< thisclass, param > var; void func( param *pParam )
 
 
 #ifdef _WIN32
diff --git a/mp/src/public/steam/steam_gameserver.h b/mp/src/public/steam/steam_gameserver.h
index 98e26a72..6b67da1d 100644
--- a/mp/src/public/steam/steam_gameserver.h
+++ b/mp/src/public/steam/steam_gameserver.h
@@ -59,6 +59,7 @@ S_API ISteamUtils *SteamGameServerUtils();
 S_API ISteamNetworking *SteamGameServerNetworking();
 S_API ISteamGameServerStats *SteamGameServerStats();
 S_API ISteamHTTP *SteamGameServerHTTP();
+S_API ISteamUGC *SteamGameServerUGC();
 #endif
 
 S_API void SteamGameServer_Shutdown();
@@ -67,9 +68,21 @@ S_API void SteamGameServer_RunCallbacks();
 S_API bool SteamGameServer_BSecure();
 S_API uint64 SteamGameServer_GetSteamID();
 
-#define STEAM_GAMESERVER_CALLBACK( thisclass, func, param, var ) CCallback< thisclass, param, true > var; void func( param *pParam )
+
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+// These macros are similar to the STEAM_CALLBACK_* macros in steam_api.h, but only trigger for gameserver callbacks
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+#define STEAM_GAMESERVER_CALLBACK( thisclass, func, /*callback_type, [deprecated] var*/... ) \
+	_STEAM_CALLBACK_SELECT( ( __VA_ARGS__, GS, 3 ), ( this->SetGameserverFlag();, thisclass, func, __VA_ARGS__ ) )
+
+#define STEAM_GAMESERVER_CALLBACK_MANUAL( thisclass, func, callback_type, var ) \
+	CCallbackManual< thisclass, callback_type, true > var; void func( callback_type *pParam )
 
 
+
+#define _STEAM_CALLBACK_GS( _, thisclass, func, param, var ) \
+	CCallback< thisclass, param, true > var; void func( param *pParam )
+
 //----------------------------------------------------------------------------------------------------------------------------------------------------------//
 //	steamclient.dll private wrapper functions
 //
@@ -101,6 +114,7 @@ public:
 	ISteamNetworking *SteamGameServerNetworking() { return m_pSteamGameServerNetworking; }
 	ISteamGameServerStats *SteamGameServerStats() { return m_pSteamGameServerStats; }
 	ISteamHTTP *SteamHTTP() { return m_pSteamHTTP; }
+	ISteamUGC *SteamUGC() { return m_pSteamUGC; }
 
 private:
 	ISteamGameServer			*m_pSteamGameServer;
@@ -108,6 +122,7 @@ private:
 	ISteamNetworking			*m_pSteamGameServerNetworking;
 	ISteamGameServerStats		*m_pSteamGameServerStats;
 	ISteamHTTP					*m_pSteamHTTP;
+	ISteamUGC					*m_pSteamUGC;
 };
 
 inline CSteamGameServerAPIContext::CSteamGameServerAPIContext()
@@ -122,6 +137,7 @@ inline void CSteamGameServerAPIContext::Clear()
 	m_pSteamGameServerNetworking = NULL;
 	m_pSteamGameServerStats = NULL;
 	m_pSteamHTTP = NULL;
+	m_pSteamUGC = NULL;
 }
 
 S_API ISteamClient *g_pSteamClientGameServer;
@@ -154,6 +170,10 @@ inline bool CSteamGameServerAPIContext::Init()
 	if ( !m_pSteamHTTP )
 		return false;
 
+	m_pSteamUGC = g_pSteamClientGameServer->GetISteamUGC( hSteamUser, hSteamPipe, STEAMUGC_INTERFACE_VERSION );
+	if ( !m_pSteamUGC )
+		return false;
+
 	return true;
 }
 
diff --git a/mp/src/public/steam/steamclientpublic.h b/mp/src/public/steam/steamclientpublic.h
index f5998599..4e952dc7 100644
--- a/mp/src/public/steam/steamclientpublic.h
+++ b/mp/src/public/steam/steamclientpublic.h
@@ -114,6 +114,17 @@ enum EResult
 	k_EResultAccountLoginDeniedThrottle = 87,	// login attempt failed, try to throttle response to possible attacker
 	k_EResultTwoFactorCodeMismatch = 88,		// two factor code mismatch
 	k_EResultTwoFactorActivationCodeMismatch = 89,	// activation code for two-factor didn't match
+	k_EResultAccountAssociatedToMultiplePartners = 90,	// account has been associated with multiple partners
+	k_EResultNotModified = 91,					// data not modified
+	k_EResultNoMobileDevice = 92,				// the account does not have a mobile device associated with it
+	k_EResultTimeNotSynced = 93,				// the time presented is out of range or tolerance
+	k_EResultSmsCodeFailed = 94,				// SMS code failure (no match, none pending, etc.)
+	k_EResultAccountLimitExceeded = 95,			// Too many accounts access this resource
+	k_EResultAccountActivityLimitExceeded = 96,	// Too many changes to this account
+	k_EResultPhoneActivityLimitExceeded = 97,	// Too many changes to this phone
+	k_EResultRefundToWallet = 98,				// Cannot refund to payment method, must use wallet
+	k_EResultEmailSendFailure = 99,				// Cannot send an email
+	k_EResultNotSettled = 100,					// Can't perform operation till payment has settled
 };
 
 // Error codes for use with the voice functions
@@ -127,11 +138,13 @@ enum EVoiceResult
 	k_EVoiceResultDataCorrupted = 5,
 	k_EVoiceResultRestricted = 6,
 	k_EVoiceResultUnsupportedCodec = 7,
+	k_EVoiceResultReceiverOutOfDate = 8,
+	k_EVoiceResultReceiverDidNotAnswer = 9,
 
 };
 
 // Result codes to GSHandleClientDeny/Kick
-typedef enum
+enum EDenyReason
 {
 	k_EDenyInvalid = 0,
 	k_EDenyInvalidVersion = 1,
@@ -149,14 +162,14 @@ typedef enum
 	k_EDenySteamResponseTimedOut = 13,
 	k_EDenySteamValidationStalled = 14,
 	k_EDenySteamOwnerLeftGuestUser = 15,
-} EDenyReason;
+};
 
 // return type of GetAuthSessionTicket
 typedef uint32 HAuthTicket;
 const HAuthTicket k_HAuthTicketInvalid = 0;
 
 // results from BeginAuthSession
-typedef enum
+enum EBeginAuthSessionResult
 {
 	k_EBeginAuthSessionResultOK = 0,						// Ticket is valid for this game and this steamID.
 	k_EBeginAuthSessionResultInvalidTicket = 1,				// Ticket is not valid.
@@ -164,10 +177,10 @@ typedef enum
 	k_EBeginAuthSessionResultInvalidVersion = 3,			// Ticket is from an incompatible interface version
 	k_EBeginAuthSessionResultGameMismatch = 4,				// Ticket is not for this game
 	k_EBeginAuthSessionResultExpiredTicket = 5,				// Ticket has expired
-} EBeginAuthSessionResult;
+};
 
 // Callback values for callback ValidateAuthTicketResponse_t which is a response to BeginAuthSession
-typedef enum
+enum EAuthSessionResponse
 {
 	k_EAuthSessionResponseOK = 0,							// Steam has verified the user is online, the ticket is valid and ticket has not been reused.
 	k_EAuthSessionResponseUserNotConnectedToSteam = 1,		// The user in question is not connected to steam
@@ -179,15 +192,15 @@ typedef enum
 	k_EAuthSessionResponseAuthTicketInvalidAlreadyUsed = 7,	// This ticket has already been used, it is not valid.
 	k_EAuthSessionResponseAuthTicketInvalid = 8,			// This ticket is not from a user instance currently connected to steam.
 	k_EAuthSessionResponsePublisherIssuedBan = 9,			// The user is banned for this game. The ban came via the web api and not VAC
-} EAuthSessionResponse;
+};
 
 // results from UserHasLicenseForApp
-typedef enum
+enum EUserHasLicenseForAppResult
 {
 	k_EUserHasLicenseResultHasLicense = 0,					// User has a license for specified app
 	k_EUserHasLicenseResultDoesNotHaveLicense = 1,			// User does not have a license for the specified app
 	k_EUserHasLicenseResultNoAuth = 2,						// User has not been authenticated
-} EUserHasLicenseForAppResult;
+};
 
 
 // Steam account types
@@ -244,6 +257,7 @@ enum EAppOwnershipFlags
 	k_EAppOwnershipFlags_LicensePermanent	= 0x0800,	// permanent license, not borrowed, or guest or freeweekend etc
 	k_EAppOwnershipFlags_LicenseRecurring	= 0x1000,	// Recurring license, user is charged periodically
 	k_EAppOwnershipFlags_LicenseCanceled	= 0x2000,	// Mark as canceled, but might be still active if recurring
+	k_EAppOwnershipFlags_AutoGrant			= 0x4000,	// Ownership is based on any kind of autogrant license
 };
 
 
@@ -262,8 +276,8 @@ enum EAppType
 	k_EAppType_Guide				= 0x040,	// game guide, PDF etc
 	k_EAppType_Driver				= 0x080,	// hardware driver updater (ATI, Razor etc)
 	k_EAppType_Config				= 0x100,	// hidden app used to config Steam features (backpack, sales, etc)
-	k_EAppType_Film					= 0x200,	// A Movie (feature film)
-	k_EAppType_TVSeries				= 0x400,	// A TV or other video series which will have episodes and perhaps seasons
+	k_EAppType_Hardware				= 0x200,	// a hardware device (Steam Machine, Steam Controller, Steam Link, etc.)
+	// 0x400 is up for grabs here
 	k_EAppType_Video				= 0x800,	// A video component of either a Film or TVSeries (may be the feature, an episode, preview, making-of, etc)
 	k_EAppType_Plugin				= 0x1000,	// Plug-in types for other Apps
 	k_EAppType_Music				= 0x2000,	// Music files
@@ -313,6 +327,7 @@ enum EChatEntryType
 	k_EChatEntryTypeHistoricalChat = 11,	// a chat message from user's chat history or offilne message
 	k_EChatEntryTypeReserved1 = 12,
 	k_EChatEntryTypeReserved2 = 13,
+	k_EChatEntryTypeLinkBlocked = 14, // a link was removed by the chat filter.
 };
 
 
@@ -394,6 +409,27 @@ enum ENotificationPosition
 };
 
 
+//-----------------------------------------------------------------------------
+// Purpose: Broadcast upload result details
+//-----------------------------------------------------------------------------
+enum EBroadcastUploadResult
+{
+	k_EBroadcastUploadResultNone = 0,	// broadcast state unknown
+	k_EBroadcastUploadResultOK = 1,		// broadcast was good, no problems
+	k_EBroadcastUploadResultInitFailed = 2,	// broadcast init failed
+	k_EBroadcastUploadResultFrameFailed = 3,	// broadcast frame upload failed
+	k_EBroadcastUploadResultTimeout = 4,	// broadcast upload timed out
+	k_EBroadcastUploadResultBandwidthExceeded = 5,	// broadcast send too much data
+	k_EBroadcastUploadResultLowFPS = 6,	// broadcast FPS too low
+	k_EBroadcastUploadResultMissingKeyFrames = 7,	// broadcast sending not enough key frames
+	k_EBroadcastUploadResultNoConnection = 8,	// broadcast client failed to connect to relay
+	k_EBroadcastUploadResultRelayFailed = 9,	// relay dropped the upload
+	k_EBroadcastUploadResultSettingsChanged = 10,	// the client changed broadcast settings 
+	k_EBroadcastUploadResultMissingAudio = 11,	// client failed to send audio data
+	k_EBroadcastUploadResultTooFarBehind = 12,	// clients was too slow uploading
+};
+
+
 #pragma pack( push, 1 )		
 
 #define CSTEAMID_DEFINED
@@ -896,10 +932,10 @@ public:
 		m_gameID.m_nType = k_EGameIDTypeGameMod;
 
 		char rgchModDir[MAX_PATH];
-		Q_FileBase( pchModPath, rgchModDir, sizeof( rgchModDir ) );
+		V_FileBase( pchModPath, rgchModDir, sizeof( rgchModDir ) );
 		CRC32_t crc32;
 		CRC32_Init( &crc32 );
-		CRC32_ProcessBuffer( &crc32, rgchModDir, Q_strlen( rgchModDir ) );
+		CRC32_ProcessBuffer( &crc32, rgchModDir, V_strlen( rgchModDir ) );
 		CRC32_Final( &crc32 );
 
 		// set the high-bit on the mod-id 
@@ -916,8 +952,8 @@ public:
 
 		CRC32_t crc32;
 		CRC32_Init( &crc32 );
-		CRC32_ProcessBuffer( &crc32, pchExePath, Q_strlen( pchExePath ) );
-		CRC32_ProcessBuffer( &crc32, pchAppName, Q_strlen( pchAppName ) );
+		CRC32_ProcessBuffer( &crc32, pchExePath, V_strlen( pchExePath ) );
+		CRC32_ProcessBuffer( &crc32, pchAppName, V_strlen( pchAppName ) );
 		CRC32_Final( &crc32 );
 
 		// set the high-bit on the mod-id 
@@ -937,7 +973,7 @@ public:
 		CRC32_t crc32;
 		CRC32_Init( &crc32 );
 		const char *pchFileId = vstFileID.Render();
-		CRC32_ProcessBuffer( &crc32, pchFileId, Q_strlen( pchFileId ) );
+		CRC32_ProcessBuffer( &crc32, pchFileId, V_strlen( pchFileId ) );
 		CRC32_Final( &crc32 );
 
 		// set the high-bit on the mod-id 
diff --git a/mp/src/public/steam/steamcontrollerpublic.h b/mp/src/public/steam/steamcontrollerpublic.h
deleted file mode 100644
index 327ea46a..00000000
--- a/mp/src/public/steam/steamcontrollerpublic.h
+++ /dev/null
@@ -1,79 +0,0 @@
-//========= Copyright � 1996-2013, Valve LLC, All rights reserved. ============
-//
-// Purpose: Controller related public types/constants
-//
-//=============================================================================
-
-#ifndef STEAMCONTROLLERPUBLIC_H
-#define STEAMCONTROLLERPUBLIC_H
-#ifdef _WIN32
-#pragma once
-#endif
-
-
-#if defined( STEAM ) || defined( ISTEAMCONTROLLER_H )
-// This file should only be included by the Steam build or directly from
-// isteamcontroller.h.
-#include "steamtypes.h"
-#else
-#include <stdint.h>
-typedef uint32_t uint32;
-#ifdef __C51__
-typedef uint8_t uint64[8];
-#else
-typedef uint64_t uint64;
-#endif
-#endif
-
-#pragma pack(1)
-
-// Safe to add new bitfields at the end of this list for new buttons/actions, 
-// but never re-use or re-number an existing flag as old client code will be 
-// confused.
-#define STEAM_RIGHT_TRIGGER_MASK            0x0000000000000001l
-#define STEAM_LEFT_TRIGGER_MASK             0x0000000000000002l
-#define STEAM_RIGHT_BUMPER_MASK             0x0000000000000004l
-#define STEAM_LEFT_BUMPER_MASK              0x0000000000000008l
-#define STEAM_BUTTON_0_MASK                 0x0000000000000010l
-#define STEAM_BUTTON_1_MASK                 0x0000000000000020l
-#define STEAM_BUTTON_2_MASK                 0x0000000000000040l
-#define STEAM_BUTTON_3_MASK                 0x0000000000000080l
-#define STEAM_TOUCH_0_MASK                  0x0000000000000100l
-#define STEAM_TOUCH_1_MASK                  0x0000000000000200l
-#define STEAM_TOUCH_2_MASK                  0x0000000000000400l
-#define STEAM_TOUCH_3_MASK                  0x0000000000000800l
-#define STEAM_BUTTON_MENU_MASK              0x0000000000001000l
-#define STEAM_BUTTON_STEAM_MASK             0x0000000000002000l
-#define STEAM_BUTTON_ESCAPE_MASK            0x0000000000004000l
-#define STEAM_BUTTON_BACK_LEFT_MASK         0x0000000000008000l
-#define STEAM_BUTTON_BACK_RIGHT_MASK        0x0000000000010000l
-#define STEAM_BUTTON_LEFTPAD_CLICKED_MASK   0x0000000000020000l
-#define STEAM_BUTTON_RIGHTPAD_CLICKED_MASK  0x0000000000040000l
-#define STEAM_LEFTPAD_FINGERDOWN_MASK       0x0000000000080000l
-#define STEAM_RIGHTPAD_FINGERDOWN_MASK      0x0000000000100000l
-
-// Only add fields to the end of this struct, or if you need to change it in a larger
-// way add a new message id and new struct completely so as to not break old clients.
-typedef struct 
-{
-	// If packet num matches that on your prior call, then the controller state hasn't been changed since 
-	// your last call and there is no need to process it
-	uint32 unPacketNum;
-
-	// bit flags for each of the buttons
-	uint64 ulButtons;
-
-	// Left pad coordinates
-	short sLeftPadX;
-	short sLeftPadY;
-
-	// Right pad coordinates
-	short sRightPadX;
-	short sRightPadY;
-
-} SteamControllerState_t; 
-
-#pragma pack()
-
-#endif // STEAMCONTROLLERPUBLIC_H
-
diff --git a/mp/src/public/steam/steamhttpenums.h b/mp/src/public/steam/steamhttpenums.h
index 11a4a03a..e15171f4 100644
--- a/mp/src/public/steam/steamhttpenums.h
+++ b/mp/src/public/steam/steamhttpenums.h
@@ -64,7 +64,7 @@ enum EHTTPStatusCode
 
 	// Error codes
 	k_EHTTPStatusCode400BadRequest =			400,
-	k_EHTTPStatusCode401Unauthorized =			401,
+	k_EHTTPStatusCode401Unauthorized =			401, // You probably want 403 or something else. 401 implies you're sending a WWW-Authenticate header and the client can sent an Authorization header in response.
 	k_EHTTPStatusCode402PaymentRequired =		402, // This is reserved for future HTTP specs, not really supported by clients
 	k_EHTTPStatusCode403Forbidden =				403,
 	k_EHTTPStatusCode404NotFound =				404,
@@ -81,6 +81,7 @@ enum EHTTPStatusCode
 	k_EHTTPStatusCode415UnsupportedMediaType =	415,
 	k_EHTTPStatusCode416RequestedRangeNotSatisfiable = 416,
 	k_EHTTPStatusCode417ExpectationFailed =		417,
+	k_EHTTPStatusCode4xxUnknown = 				418, // 418 is reserved, so we'll use it to mean unknown
 	k_EHTTPStatusCode429TooManyRequests	=		429,
 
 	// Server error codes
@@ -90,6 +91,7 @@ enum EHTTPStatusCode
 	k_EHTTPStatusCode503ServiceUnavailable =	503,
 	k_EHTTPStatusCode504GatewayTimeout =		504,
 	k_EHTTPStatusCode505HTTPVersionNotSupported = 505,
+	k_EHTTPStatusCode5xxUnknown =				599,
 };
 
 #endif // STEAMHTTPENUMS_H
\ No newline at end of file
diff --git a/mp/src/public/steam/steamtypes.h b/mp/src/public/steam/steamtypes.h
index c3320a10..22ce3e61 100644
--- a/mp/src/public/steam/steamtypes.h
+++ b/mp/src/public/steam/steamtypes.h
@@ -84,6 +84,25 @@ typedef unsigned int uintp;
 
 #endif // else _WIN32
 
+#ifdef __clang__
+# define CLANG_ATTR(ATTR) __attribute__((annotate( ATTR )))
+#else
+# define CLANG_ATTR(ATTR)
+#endif
+
+#define METHOD_DESC(DESC) CLANG_ATTR( "desc:" #DESC ";" )
+#define IGNOREATTR() CLANG_ATTR( "ignore" )
+#define OUT_STRUCT() CLANG_ATTR( "out_struct: ;" )
+#define OUT_ARRAY_CALL(COUNTER,FUNCTION,PARAMS) CLANG_ATTR( "out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";" )
+#define OUT_ARRAY_COUNT(COUNTER, DESC) CLANG_ATTR( "out_array_count:" #COUNTER  ";desc:" #DESC )
+#define ARRAY_COUNT(COUNTER) CLANG_ATTR( "array_count:" #COUNTER ";" )
+#define ARRAY_COUNT_D(COUNTER, DESC) CLANG_ATTR( "array_count:" #COUNTER ";desc:" #DESC )
+#define BUFFER_COUNT(COUNTER) CLANG_ATTR( "buffer_count:" #COUNTER ";" )
+#define OUT_BUFFER_COUNT(COUNTER) CLANG_ATTR( "out_buffer_count:" #COUNTER ";" )
+#define OUT_STRING_COUNT(COUNTER) CLANG_ATTR( "out_string_count:" #COUNTER ";" )
+#define DESC(DESC) CLANG_ATTR("desc:" #DESC ";")
+
+
 const int k_cubSaltSize   = 8;
 typedef	uint8 Salt_t[ k_cubSaltSize ];
 
@@ -98,12 +117,13 @@ typedef uint64 GID_t;
 const GID_t k_GIDNil = 0xffffffffffffffffull;
 
 // For convenience, we define a number of types that are just new names for GIDs
-typedef GID_t JobID_t;			// Each Job has a unique ID
+typedef uint64 JobID_t;			// Each Job has a unique ID
 typedef GID_t TxnID_t;			// Each financial transaction has a unique ID
 
 const GID_t k_TxnIDNil = k_GIDNil;
 const GID_t k_TxnIDUnknown = 0;
 
+const JobID_t k_JobIDNil = 0xffffffffffffffffull;
 
 // this is baked into client messages and interfaces as an int, 
 // make sure we never break this.
@@ -111,6 +131,8 @@ typedef uint32 PackageId_t;
 const PackageId_t k_uPackageIdFreeSub = 0x0;
 const PackageId_t k_uPackageIdInvalid = 0xFFFFFFFF;
 
+typedef uint32 BundleId_t;
+const BundleId_t k_uBundleIdInvalid = 0;
 
 // this is baked into client messages and interfaces as an int, 
 // make sure we never break this.
diff --git a/mp/src/public/steam/steamvr.h b/mp/src/public/steam/steamvr.h
deleted file mode 100644
index be62fc86..00000000
--- a/mp/src/public/steam/steamvr.h
+++ /dev/null
@@ -1,261 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-namespace vr
-{
-
-#if defined(__linux__) || defined(__APPLE__) 
-	// The 32-bit version of gcc has the alignment requirement for uint64 and double set to
-	// 4 meaning that even with #pragma pack(8) these types will only be four-byte aligned.
-	// The 64-bit version of gcc has the alignment requirement for these types set to
-	// 8 meaning that unless we use #pragma pack(4) our structures will get bigger.
-	// The 64-bit structure packing has to match the 32-bit structure packing for each platform.
-#pragma pack( push, 4 )
-#else
-#pragma pack( push, 8 )
-#endif
-
-
-// right-handed system
-// +y is up
-// +x is to the right
-// -z is going away from you
-// Distance unit is  meters
-struct HmdMatrix34_t
-{
-	float m[3][4];
-};
-
-struct HmdMatrix44_t
-{
-	float m[4][4];
-};
-
-
-/** Used to return the post-distortion UVs for each color channel. 
-* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
-* source render target. The 0,0 to 1,1 range covers a single eye. */
-struct DistortionCoordinates_t
-{
-	float rfRed[2];
-	float rfGreen[2];
-	float rfBlue[2];
-};
-
-
-enum Hmd_Eye
-{
-	Eye_Left = 0,
-	Eye_Right = 1
-};
-
-enum GraphicsAPIConvention
-{
-	API_DirectX = 0, // Normalized Z goes from 0 at the viewer to 1 at the far clip plane
-	API_OpenGL = 1,  // Normalized Z goes from 1 at the viewer to -1 at the far clip plane
-};
-
-enum HmdTrackingResult
-{
-	TrackingResult_Uninitialized			= 1,
-
-	TrackingResult_Calibrating_InProgress	= 100,
-	TrackingResult_Calibrating_OutOfRange	= 101,
-
-	TrackingResult_Running_OK				= 200,
-	TrackingResult_Running_OutOfRange		= 201,
-};
-
-class IHmd
-{
-public:
-
-
-	// ------------------------------------
-	// Display Methods
-	// ------------------------------------
-
-	/** Size and position that the window needs to be on the VR display. */
-	virtual void GetWindowBounds( int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
-
-	/** Suggested size for the intermediate render target that the distortion pulls from. */
-	virtual void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
-
-	/** Gets the viewport in the frame buffer to draw the output of the distortion into */
-	virtual void GetEyeOutputViewport( Hmd_Eye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
-	
-	/** The projection matrix for the specified eye */
-	virtual HmdMatrix44_t GetProjectionMatrix( Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType ) = 0;
-
-	/** The components necessary to build your own projection matrix in case your
-	* application is doing something fancy like infinite Z */
-	virtual void GetProjectionRaw( Hmd_Eye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom ) = 0;
-
-	/** Returns the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in 
-	* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport. */
-	virtual DistortionCoordinates_t ComputeDistortion( Hmd_Eye eEye, float fU, float fV ) = 0;
-
-	/** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
-	* space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection. 
-	* Normally View and Eye^-1 will be multiplied together and treated as View in your application. 
-	*/
-	virtual HmdMatrix34_t GetHeadFromEyePose( Hmd_Eye eEye ) = 0;
-
-	/** For use in simple VR apps, this method returns the concatenation of the 
-	* tracking pose and the eye matrix to get a full view matrix for each eye.
-	* This is ( GetEyeMatrix() ) * (GetWorldFromHeadPose() ^ -1 )  */
-	virtual bool GetViewMatrix( float fSecondsFromNow, HmdMatrix44_t *pMatLeftView, HmdMatrix44_t *pMatRightView, HmdTrackingResult *peResult ) = 0;
-
-	/** [D3D9 Only]
-	* Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
-	* a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
-	*/
-	virtual int32_t GetD3D9AdapterIndex() = 0;
-
-	/** [D3D10/11 Only]
-	* Returns the adapter index and output index that the user should pass into EnumAdapters adn EnumOutputs 
-	* to create the device and swap chain in DX10 and DX11. If an error occurs both indices will be set to -1.
-	*/
-	virtual void GetDXGIOutputInfo( int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex ) = 0;
-
-	/** [Windows Only]
-	* Notifies the system that the VR output will appear in a particular window.
-	*/
-	virtual void AttachToWindow( void *hWnd ) = 0;
-
-	// ------------------------------------
-	// Tracking Methods
-	// ------------------------------------
-
-	/** The pose that the tracker thinks that the HMD will be in at the specified
-	* number of seconds into the future. Pass 0 to get the current state. 
-	*
-	* This is roughly analogous to the inverse of the view matrix in most applications, though 
-	* many games will need to do some additional rotation or translation on top of the rotation
-	* and translation provided by the head pose.
-	*
-	* If this function returns true the pose has been populated with a pose that can be used by the application.
-	* Check peResult for details about the pose, including messages that should be displayed to the user.
-	*/
-	virtual bool GetTrackerFromHeadPose( float fPredictedSecondsFromNow, HmdMatrix34_t *pmPose, HmdTrackingResult *peResult ) = 0;
-
-	/** Passes back the pose matrix from the last successful call to GetWorldFromHeadPose(). Returns true if that matrix is 
-	* valid (because there has been a previous successful pose.) */
-	virtual bool GetLastTrackerFromHeadPose( HmdMatrix34_t *pmPose ) = 0;
-
-	/** Returns true if the tracker for this HMD will drift the Yaw component of its pose over time regardless of
-	* actual head motion. This is true for gyro-based trackers with no ground truth. */
-	virtual bool WillDriftInYaw() = 0;
-
-	/** Sets the zero pose for the tracker coordinate system. After this call all WorldFromHead poses will be relative 
-	* to the pose whenever this was called. The new zero coordinate system will not change the fact that the Y axis is
-	* up in the real world, so the next pose returned from GetWorldFromHeadPose after a call to ZeroTracker may not be
-	* exactly an identity matrix. */
-	virtual void ZeroTracker() = 0;
-
-	/** Returns the zero pose for the tracker coordinate system. If the tracker has never had a valid pose, this
-	* will be an identity matrix. */
-	virtual HmdMatrix34_t GetTrackerZeroPose() = 0;
-
-	// ------------------------------------
-	// Administrative methods
-	// ------------------------------------
-
-	/** The ID of the driver this HMD uses as a UTF-8 string. Returns the length of the ID in bytes. If 
-	* the buffer is not large enough to fit the ID an empty string will be returned. In general, 128 bytes
-	* will be enough to fit any ID. */
-	virtual uint32_t GetDriverId( char *pchBuffer, uint32_t unBufferLen ) = 0;
-
-	/** The ID of this display within its driver this HMD uses as a UTF-8 string. Returns the length of the ID in bytes. If 
-	* the buffer is not large enough to fit the ID an empty string will be returned. In general, 128 bytes
-	* will be enough to fit any ID. */
-	virtual uint32_t GetDisplayId( char *pchBuffer, uint32_t unBufferLen ) = 0;
-};
-
-static const char * const IHmd_Version = "IHmd_005";
-
-/** error codes returned by Vr_Init */
-enum HmdError
-{
-	HmdError_None = 0,
-
-	HmdError_Init_InstallationNotFound	= 100,
-	HmdError_Init_InstallationCorrupt	= 101,
-	HmdError_Init_VRClientDLLNotFound	= 102,
-	HmdError_Init_FileNotFound			= 103,
-	HmdError_Init_FactoryNotFound		= 104,
-	HmdError_Init_InterfaceNotFound		= 105,
-	HmdError_Init_InvalidInterface		= 106,
-	HmdError_Init_UserConfigDirectoryInvalid = 107,
-	HmdError_Init_HmdNotFound			= 108,
-	HmdError_Init_NotInitialized		= 109,
-
-	HmdError_Driver_Failed = 200,
-	HmdError_Driver_Unknown = 201,
-	HmdError_Driver_HmdUnknown = 202,
-	HmdError_Driver_NotLoaded = 203,
-
-	HmdError_IPC_ServerInitFailed		= 300,
-	HmdError_IPC_ConnectFailed			= 301,
-	HmdError_IPC_SharedStateInitFailed	= 302,
-
-	HmdError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
-
-};
-
-
-// figure out how to import from the VR API dll
-#if defined(_WIN32)
-
-#ifdef VR_API_EXPORT
-#define VR_INTERFACE extern "C" __declspec( dllexport )
-#else
-#define VR_INTERFACE extern "C" __declspec( dllimport )
-#endif
-
-#elif defined(GNUC) || defined(COMPILER_GCC)
-
-#ifdef VR_API_EXPORT
-#define VR_INTERFACE extern "C" __attribute__((visibility("default")))
-#else
-#define VR_INTERFACE extern "C" 
-#endif
-
-#else
-#error "Unsupported Platform."
-#endif
-
-
-
-
-/** Finds the active installation of the VR API and initializes it. The priority for figuring 
-* out where to load vrclient from are:
-*  1. The convar "VR_OVERRIDE", which should contain an absolute path to the root of
-*     an vr API directory. 
-*  2. The pchVROverride argument. This should be an absolute path or a path relative to
-*     the current executable.
-*  3. The path "./vr" relative to the current executable's path.
-*
-* Each of these paths are to the "root" of the VR API install. That's the directory with 
-* the "drivers" directory and a platform (i.e. "win32") directory in it, not the directory with the DLL itself.
-*/
-VR_INTERFACE IHmd *VR_Init( HmdError *peError );
-
-/** unloads vrclient.dll. Any interface pointers from the interface are 
-* invalid after this point */
-VR_INTERFACE void VR_Shutdown( );
-
-/** Returns true if there is an HMD attached. This check is as lightweight as possible and
-* can be called outside of VR_Init/VR_Shutdown. It should be used when an application wants
-* to know if initializing VR is a possibility but isn't ready to take that step yet.
-*/
-VR_INTERFACE bool VR_IsHmdPresent();
-
-/** Returns the string version of an HMD error. This function may be called outside of VR_Init()/VR_Shutdown(). */
-VR_INTERFACE const char *VR_GetStringForHmdError( HmdError error );
-
-#pragma pack( pop )
-
-
-}
\ No newline at end of file
diff --git a/mp/src/public/studio.cpp b/mp/src/public/studio.cpp
index 4d84e1d0..bf6fdb7d 100644
--- a/mp/src/public/studio.cpp
+++ b/mp/src/public/studio.cpp
@@ -920,6 +920,16 @@ mstudioseqdesc_t &CStudioHdr::pSeqdesc( int i )
 	Assert( ( i >= 0 && i < GetNumSeq() ) || ( i == 1 && GetNumSeq() <= 1 ) );
 	if ( i < 0 || i >= GetNumSeq() )
 	{
+		if ( GetNumSeq() <= 0 )
+		{
+			// Return a zero'd out struct reference if we've got nothing.
+			// C_BaseObject::StopAnimGeneratedSounds was crashing due to this function
+			//	returning a reference to garbage. It should now see numevents is 0,
+			//	and bail.
+			static mstudioseqdesc_t s_nil_seq;
+			return s_nil_seq;
+		}
+
 		// Avoid reading random memory.
 		i = 0;
 	}
@@ -1026,9 +1036,10 @@ int CStudioHdr::GetSharedPoseParameter( int iSequence, int iLocalPose ) const
 
 	Assert( m_pVModel );
 
-	virtualgroup_t *pGroup = &m_pVModel->m_group[ m_pVModel->m_seq[iSequence].group ];
+	int group = m_pVModel->m_seq[iSequence].group;
+	virtualgroup_t *pGroup = m_pVModel->m_group.IsValidIndex( group ) ? &m_pVModel->m_group[ group ] : NULL;
 
-	return pGroup->masterPose[iLocalPose];
+	return pGroup ? pGroup->masterPose[iLocalPose] : iLocalPose;
 }
 
 
@@ -1603,6 +1614,7 @@ void CStudioHdr::RunFlexRules( const float *src, float *dest )
 //-----------------------------------------------------------------------------
 #define iabs(i) (( (i) >= 0 ) ? (i) : -(i) )
 
+CUtlSymbolTable g_ActivityModifiersTable;
 
 extern void SetActivityForSequence( CStudioHdr *pstudiohdr, int i );
 void CStudioHdr::CActivityToSequenceMapping::Initialize( CStudioHdr * __restrict pstudiohdr )
@@ -1628,7 +1640,7 @@ void CStudioHdr::CActivityToSequenceMapping::Initialize( CStudioHdr * __restrict
 	
 	// Some studio headers have no activities at all. In those
 	// cases we can avoid a lot of this effort.
-	bool bFoundOne = false;
+	bool bFoundOne = false;	
 
 	// for each sequence in the header...
 	const int NumSeq = pstudiohdr->GetNumSeq();
@@ -1657,7 +1669,10 @@ void CStudioHdr::CActivityToSequenceMapping::Initialize( CStudioHdr * __restrict
 				HashValueType * __restrict toUpdate = &m_ActToSeqHash.Element(handle);
 				toUpdate->count += 1;
 				toUpdate->totalWeight += iabs(seqdesc.actweight);
-				Assert( toUpdate->totalWeight > 0 );
+				if ( !HushAsserts() )
+				{
+					AssertMsg( toUpdate->totalWeight > 0, "toUpdate->totalWeight: %d", toUpdate->totalWeight );
+				}
 			}
 			else
 			{
@@ -1720,6 +1735,23 @@ void CStudioHdr::CActivityToSequenceMapping::Initialize( CStudioHdr * __restrict
 			int tupleOffset = seqsPerAct[seqdesc.activity];
 			Assert( tupleOffset < element.count );
 
+			if ( seqdesc.numactivitymodifiers > 0 )
+			{
+				// add entries for this model's activity modifiers
+				(tupleList + element.startingIdx + tupleOffset)->pActivityModifiers = new CUtlSymbol[ seqdesc.numactivitymodifiers ];
+				(tupleList + element.startingIdx + tupleOffset)->iNumActivityModifiers = seqdesc.numactivitymodifiers;
+
+				for ( int k = 0; k < seqdesc.numactivitymodifiers; k++ )
+				{
+					(tupleList + element.startingIdx + tupleOffset)->pActivityModifiers[ k ] = g_ActivityModifiersTable.AddString( seqdesc.pActivityModifier( k )->pszName() );
+				}
+			}
+			else
+			{
+				(tupleList + element.startingIdx + tupleOffset)->pActivityModifiers = NULL;
+				(tupleList + element.startingIdx + tupleOffset)->iNumActivityModifiers = 0;
+			}
+
 			// You might be tempted to collapse this pointer math into a single pointer --
 			// don't! the tuple list is marked __restrict above.
 			(tupleList + element.startingIdx + tupleOffset)->seqnum = i; // store sequence number
diff --git a/mp/src/public/studio.h b/mp/src/public/studio.h
index bcc38d5d..bc70313b 100644
--- a/mp/src/public/studio.h
+++ b/mp/src/public/studio.h
@@ -26,7 +26,7 @@
 #include "datamap.h"
 #include "generichash.h"
 #include "localflexcontroller.h"
-
+#include "utlsymbol.h"
 
 #define STUDIO_ENABLE_PERF_COUNTERS
 
@@ -755,6 +755,14 @@ struct mstudioautolayer_t
 	float				end;	// end of all influence
 };
 
+struct mstudioactivitymodifier_t
+{
+	DECLARE_BYTESWAP_DATADESC();
+	
+	int					sznameindex;
+	inline char			*pszName() { return (sznameindex) ? (char *)(((byte *)this) + sznameindex ) : NULL; }
+};
+
 // sequence descriptions
 struct mstudioseqdesc_t
 {
@@ -851,7 +859,11 @@ struct mstudioseqdesc_t
 
 	int					cycleposeindex;		// index of pose parameter to use as cycle index
 
-	int					unused[7];		// remove/add as appropriate (grow back to 8 ints on version change!)
+	int					activitymodifierindex;
+	int					numactivitymodifiers;
+	inline mstudioactivitymodifier_t *pActivityModifier( int i ) const { Assert( i >= 0 && i < numactivitymodifiers); return activitymodifierindex != 0 ? (mstudioactivitymodifier_t *)(((byte *)this) + activitymodifierindex) + i : NULL; };
+
+	int					unused[5];		// remove/add as appropriate (grow back to 8 ints on version change!)
 
 	mstudioseqdesc_t(){}
 private:
@@ -1947,75 +1959,75 @@ struct vertexFileFixup_t
 };
 
 // This flag is set if no hitbox information was specified
-#define STUDIOHDR_FLAGS_AUTOGENERATED_HITBOX	( 1 << 0 )
+#define STUDIOHDR_FLAGS_AUTOGENERATED_HITBOX				0x00000001
 
 // NOTE:  This flag is set at loadtime, not mdl build time so that we don't have to rebuild
 // models when we change materials.
-#define STUDIOHDR_FLAGS_USES_ENV_CUBEMAP		( 1 << 1 )
+#define STUDIOHDR_FLAGS_USES_ENV_CUBEMAP					0x00000002
 
 // Use this when there are translucent parts to the model but we're not going to sort it 
-#define STUDIOHDR_FLAGS_FORCE_OPAQUE			( 1 << 2 )
+#define STUDIOHDR_FLAGS_FORCE_OPAQUE						0x00000004
 
 // Use this when we want to render the opaque parts during the opaque pass
 // and the translucent parts during the translucent pass
-#define STUDIOHDR_FLAGS_TRANSLUCENT_TWOPASS		( 1 << 3 )
+#define STUDIOHDR_FLAGS_TRANSLUCENT_TWOPASS					0x00000008
 
 // This is set any time the .qc files has $staticprop in it
 // Means there's no bones and no transforms
-#define STUDIOHDR_FLAGS_STATIC_PROP				( 1 << 4 )
+#define STUDIOHDR_FLAGS_STATIC_PROP							0x00000010
 
 // NOTE:  This flag is set at loadtime, not mdl build time so that we don't have to rebuild
 // models when we change materials.
-#define STUDIOHDR_FLAGS_USES_FB_TEXTURE		    ( 1 << 5 )
+#define STUDIOHDR_FLAGS_USES_FB_TEXTURE						0x00000020
 
 // This flag is set by studiomdl.exe if a separate "$shadowlod" entry was present
 //  for the .mdl (the shadow lod is the last entry in the lod list if present)
-#define STUDIOHDR_FLAGS_HASSHADOWLOD			( 1 << 6 )
+#define STUDIOHDR_FLAGS_HASSHADOWLOD						0x00000040
 
 // NOTE:  This flag is set at loadtime, not mdl build time so that we don't have to rebuild
 // models when we change materials.
-#define STUDIOHDR_FLAGS_USES_BUMPMAPPING		( 1 << 7 )
+#define STUDIOHDR_FLAGS_USES_BUMPMAPPING					0x00000080
 
 // NOTE:  This flag is set when we should use the actual materials on the shadow LOD
 // instead of overriding them with the default one (necessary for translucent shadows)
-#define STUDIOHDR_FLAGS_USE_SHADOWLOD_MATERIALS	( 1 << 8 )
+#define STUDIOHDR_FLAGS_USE_SHADOWLOD_MATERIALS				0x00000100
 
 // NOTE:  This flag is set when we should use the actual materials on the shadow LOD
 // instead of overriding them with the default one (necessary for translucent shadows)
-#define STUDIOHDR_FLAGS_OBSOLETE				( 1 << 9 )
+#define STUDIOHDR_FLAGS_OBSOLETE							0x00000200
 
-#define STUDIOHDR_FLAGS_UNUSED					( 1 << 10 )
+#define STUDIOHDR_FLAGS_UNUSED								0x00000400
 
 // NOTE:  This flag is set at mdl build time
-#define STUDIOHDR_FLAGS_NO_FORCED_FADE			( 1 << 11 )
+#define STUDIOHDR_FLAGS_NO_FORCED_FADE						0x00000800
 
 // NOTE:  The npc will lengthen the viseme check to always include two phonemes
-#define STUDIOHDR_FLAGS_FORCE_PHONEME_CROSSFADE	( 1 << 12 )
+#define STUDIOHDR_FLAGS_FORCE_PHONEME_CROSSFADE				0x00001000
 
 // This flag is set when the .qc has $constantdirectionallight in it
 // If set, we use constantdirectionallightdot to calculate light intensity
 // rather than the normal directional dot product
 // only valid if STUDIOHDR_FLAGS_STATIC_PROP is also set
-#define STUDIOHDR_FLAGS_CONSTANT_DIRECTIONAL_LIGHT_DOT ( 1 << 13 )
+#define STUDIOHDR_FLAGS_CONSTANT_DIRECTIONAL_LIGHT_DOT		0x00002000
 
 // Flag to mark delta flexes as already converted from disk format to memory format
-#define STUDIOHDR_FLAGS_FLEXES_CONVERTED		( 1 << 14 )
+#define STUDIOHDR_FLAGS_FLEXES_CONVERTED					0x00004000
 
 // Indicates the studiomdl was built in preview mode
-#define STUDIOHDR_FLAGS_BUILT_IN_PREVIEW_MODE	( 1 << 15 )
+#define STUDIOHDR_FLAGS_BUILT_IN_PREVIEW_MODE				0x00008000
 
 // Ambient boost (runtime flag)
-#define STUDIOHDR_FLAGS_AMBIENT_BOOST			( 1 << 16 )
+#define STUDIOHDR_FLAGS_AMBIENT_BOOST						0x00010000
 
 // Don't cast shadows from this model (useful on first-person models)
-#define STUDIOHDR_FLAGS_DO_NOT_CAST_SHADOWS		( 1 << 17 )
+#define STUDIOHDR_FLAGS_DO_NOT_CAST_SHADOWS					0x00020000
 
 // alpha textures should cast shadows in vrad on this model (ONLY prop_static!)
-#define STUDIOHDR_FLAGS_CAST_TEXTURE_SHADOWS	( 1 << 18 )
+#define STUDIOHDR_FLAGS_CAST_TEXTURE_SHADOWS				0x00040000
 
 
 // flagged on load to indicate no animation events on this model
-#define STUDIOHDR_FLAGS_VERT_ANIM_FIXED_POINT_SCALE	( 1 << 21 )
+#define STUDIOHDR_FLAGS_VERT_ANIM_FIXED_POINT_SCALE			0x00200000
 
 // NOTE! Next time we up the .mdl file format, remove studiohdr2_t
 // and insert all fields in this structure into studiohdr_t.
@@ -2493,6 +2505,7 @@ private:
 	CUtlVector< int >  m_boneParent;
 
 public:
+
 	// This class maps an activity to sequences allowed for that activity, accelerating the resolution
 	// of SelectWeightedSequence(), especially on PowerPC. Iterating through every sequence
 	// attached to a model turned out to be a very destructive cache access pattern on 360.
@@ -2508,8 +2521,10 @@ public:
 		// A tuple of a sequence and its corresponding weight. Lists of these correspond to activities.
 		struct SequenceTuple
 		{
-			short seqnum;
-			short weight; // the absolute value of the weight from the sequence header
+			short		seqnum;
+			short		weight; // the absolute value of the weight from the sequence header
+			CUtlSymbol	*pActivityModifiers;		// list of activity modifier symbols
+			int			iNumActivityModifiers;
 		};
 
 		// The type of the hash's stored data, a composite of both key and value
@@ -2579,9 +2594,13 @@ public:
 
 		// dtor -- not virtual because this class has no inheritors
 		~CActivityToSequenceMapping()
-		{
+		{	
 			if ( m_pSequenceTuples != NULL )
 			{
+				if ( m_pSequenceTuples->pActivityModifiers != NULL )
+				{
+					delete[] m_pSequenceTuples->pActivityModifiers;
+				}
 				delete[] m_pSequenceTuples;
 			}
 		}
@@ -2612,6 +2631,9 @@ public:
 		/// A more efficient version of the old SelectWeightedSequence() function in animation.cpp. 
 		int SelectWeightedSequence( CStudioHdr *pstudiohdr, int activity, int curSequence );
 
+		// selects the sequence with the most matching modifiers
+		int SelectWeightedSequenceFromModifiers( CStudioHdr *pstudiohdr, int activity, CUtlSymbol *pActivityModifiers, int iModifierCount );
+
 		// Actually a big array, into which the hash values index.
 		SequenceTuple *m_pSequenceTuples;
 		unsigned int m_iSequenceTuplesCount; // (size of the whole array)
@@ -2656,6 +2678,19 @@ public:
 		return m_ActivityToSequence.SelectWeightedSequence( this, activity, curSequence );
 	}
 
+	inline int SelectWeightedSequenceFromModifiers( int activity, CUtlSymbol *pActivityModifiers, int iModifierCount )
+	{
+#if STUDIO_SEQUENCE_ACTIVITY_LAZY_INITIALIZE
+		// We lazy-initialize the header on demand here, because CStudioHdr::Init() is
+		// called from the constructor, at which time the this pointer is illegitimate.
+		if ( !m_ActivityToSequence.IsInitialized() )
+		{
+			m_ActivityToSequence.Initialize( this );
+		}
+#endif
+		return m_ActivityToSequence.SelectWeightedSequenceFromModifiers( this, activity, pActivityModifiers, iModifierCount );
+	}
+
 	/// True iff there is at least one sequence for the given activity.
 	inline bool HaveSequenceForActivity( int activity )	
 	{
diff --git a/mp/src/public/texture_group_names.h b/mp/src/public/texture_group_names.h
index b30ed35a..92b31279 100644
--- a/mp/src/public/texture_group_names.h
+++ b/mp/src/public/texture_group_names.h
@@ -23,6 +23,7 @@
 #define TEXTURE_GROUP_PRECACHED						"Precached"				// TODO: assign texture groups to the precached materials
 #define TEXTURE_GROUP_CUBE_MAP						"CubeMap textures"
 #define TEXTURE_GROUP_RENDER_TARGET					"RenderTargets"
+#define TEXTURE_GROUP_RUNTIME_COMPOSITE				"Runtime Composite"
 #define TEXTURE_GROUP_UNACCOUNTED					"Unaccounted textures"	// Textures that weren't assigned a texture group.
 //#define TEXTURE_GROUP_STATIC_VERTEX_BUFFER		"Static Vertex"
 #define TEXTURE_GROUP_STATIC_INDEX_BUFFER			"Static Indices"
diff --git a/mp/src/public/tier0/dbg.h b/mp/src/public/tier0/dbg.h
index c35e7a67..5fa68adf 100644
--- a/mp/src/public/tier0/dbg.h
+++ b/mp/src/public/tier0/dbg.h
@@ -221,6 +221,9 @@ typedef void (*AssertFailedNotifyFunc_t)( const char *pchFile, int nLine, const
 DBG_INTERFACE void SetAssertFailedNotifyFunc( AssertFailedNotifyFunc_t func );
 DBG_INTERFACE void CallAssertFailedNotifyFunc( const char *pchFile, int nLine, const char *pchMessage );
 
+/* True if -hushasserts was passed on command line. */
+DBG_INTERFACE bool HushAsserts();
+
 #if defined( USE_SDL )
 DBG_INTERFACE void SetAssertDialogParent( struct SDL_Window *window );
 DBG_INTERFACE struct SDL_Window * GetAssertDialogParent();
@@ -412,12 +415,15 @@ DBG_INTERFACE struct SDL_Window * GetAssertDialogParent();
 /* These are always compiled in */
 DBG_INTERFACE void Msg( PRINTF_FORMAT_STRING const tchar* pMsg, ... ) FMTFUNCTION( 1, 2 );
 DBG_INTERFACE void DMsg( const tchar *pGroupName, int level, PRINTF_FORMAT_STRING const tchar *pMsg, ... ) FMTFUNCTION( 3, 4 );
+DBG_INTERFACE void MsgV( PRINTF_FORMAT_STRING const tchar *pMsg, va_list arglist );
 
 DBG_INTERFACE void Warning( PRINTF_FORMAT_STRING const tchar *pMsg, ... ) FMTFUNCTION( 1, 2 );
 DBG_INTERFACE void DWarning( const tchar *pGroupName, int level, PRINTF_FORMAT_STRING const tchar *pMsg, ... ) FMTFUNCTION( 3, 4 );
+DBG_INTERFACE void WarningV( PRINTF_FORMAT_STRING const tchar *pMsg, va_list arglist );
 
 DBG_INTERFACE void Log( PRINTF_FORMAT_STRING const tchar *pMsg, ... ) FMTFUNCTION( 1, 2 );
 DBG_INTERFACE void DLog( const tchar *pGroupName, int level, PRINTF_FORMAT_STRING const tchar *pMsg, ... ) FMTFUNCTION( 3, 4 );
+DBG_INTERFACE void LogV( PRINTF_FORMAT_STRING const tchar *pMsg, va_list arglist );
 
 #ifdef Error
 // p4.cpp does a #define Error Warning and in that case the Error prototype needs to
@@ -425,17 +431,23 @@ DBG_INTERFACE void DLog( const tchar *pGroupName, int level, PRINTF_FORMAT_STRIN
 DBG_INTERFACE void Error( PRINTF_FORMAT_STRING const tchar *pMsg, ... ) FMTFUNCTION( 1, 2 );
 #else
 DBG_INTERFACE void NORETURN Error( PRINTF_FORMAT_STRING const tchar *pMsg, ... ) FMTFUNCTION( 1, 2 );
+DBG_INTERFACE void NORETURN ErrorV( PRINTF_FORMAT_STRING const tchar *pMsg, va_list arglist );
+
 #endif
 
 #else
 
 inline void Msg( ... ) {}
 inline void DMsg( ... ) {}
+inline void MsgV( PRINTF_FORMAT_STRING const tchar *pMsg, va_list arglist ) {}
 inline void Warning( PRINTF_FORMAT_STRING const tchar *pMsg, ... ) {}
+inline void WarningV( PRINTF_FORMAT_STRING const tchar *pMsg, va_list arglist ) {}
 inline void DWarning( ... ) {}
 inline void Log( ... ) {}
 inline void DLog( ... ) {}
+inline void LogV( PRINTF_FORMAT_STRING const tchar *pMsg, va_list arglist ) {}
 inline void Error( ... ) {}
+inline void ErrorV( PRINTF_FORMAT_STRING const tchar *pMsg, va_list arglist ) {}
 
 #endif
 
diff --git a/mp/src/public/tier0/minidump.h b/mp/src/public/tier0/minidump.h
index fad2d073..e6507256 100644
--- a/mp/src/public/tier0/minidump.h
+++ b/mp/src/public/tier0/minidump.h
@@ -82,6 +82,23 @@ PLATFORM_INTERFACE void MinidumpSetUnhandledExceptionFunction( FnMiniDump pfn );
 // being silently swallowed. We should always call this at startup.
 PLATFORM_INTERFACE void EnableCrashingOnCrashes();
 
-#endif
+#endif // defined(_WIN32) && !defined(_X360)
+
+//
+// Minidump User Stream Info Comments.
+//
+// There currently is a single header string, and an array of 64 comment strings.
+//	MinidumpUserStreamInfoSetHeader() will set the single header string.
+//	MinidumpUserStreamInfoAppend() will round robin through and array and set the comment strings, overwriting old.
+PLATFORM_INTERFACE void MinidumpUserStreamInfoSetHeader( const char *pFormat, ... );
+PLATFORM_INTERFACE void MinidumpUserStreamInfoAppend( const char *pFormat, ... );
+
+// Retrieve the StreamInfo strings.
+//  Index 0: header string
+//  Index 1..: comment string
+//  Returns NULL when you've reached the end of the comment string array
+//  Empty strings ("\0") can be returned if comment hasn't been set
+PLATFORM_INTERFACE const char *MinidumpUserStreamInfoGet( int Index );
 
 #endif // MINIDUMP_H
+
diff --git a/mp/src/public/tier0/platform.h b/mp/src/public/tier0/platform.h
index 389ab5b8..652c27c0 100644
--- a/mp/src/public/tier0/platform.h
+++ b/mp/src/public/tier0/platform.h
@@ -9,6 +9,18 @@
 #ifndef PLATFORM_H
 #define PLATFORM_H
 
+#if defined(__x86_64__) || defined(_WIN64)
+#define PLATFORM_64BITS 1
+#endif
+
+#if defined(__GCC__) || defined(__GNUC__)
+#define COMPILER_GCC 1
+#endif
+
+#ifdef __clang__
+#define COMPILER_CLANG 1
+#endif
+
 #if defined( _X360 )
 	#define NO_STEAM
 	#define NO_VOICE
@@ -51,14 +63,13 @@
 // need this for _alloca
 #include <alloca.h>
 #include <unistd.h>
-	#include <signal.h>
+#include <signal.h>
 #include <time.h>
 #endif
 
 #include <malloc.h>
 #include <new>
 
-
 // need this for memset
 #include <string.h>
 
@@ -148,10 +159,6 @@
 typedef unsigned char uint8;
 typedef signed char int8;
 
-#if defined(__x86_64__) || defined(_WIN64)
-	#define X64BITS
-#endif // __x86_64__
-
 #if defined( _WIN32 )
 
 	typedef __int16					int16;
@@ -191,7 +198,7 @@ typedef signed char int8;
 	typedef unsigned int			uint32;
 	typedef long long				int64;
 	typedef unsigned long long		uint64;
-	#ifdef X64BITS
+	#ifdef PLATFORM_64BITS
 		typedef long long			intp;
 		typedef unsigned long long	uintp;
 	#else
@@ -202,17 +209,39 @@ typedef signed char int8;
 
 	// Avoid redefinition warnings if a previous header defines this.
 	#undef OVERRIDE
-	#if defined(__clang__)
+	#if __cplusplus >= 201103L
 		#define OVERRIDE override
-		// warning: 'override' keyword is a C++11 extension [-Wc++11-extensions]
-		// Disabling this warning is less intrusive than enabling C++11 extensions
-		#pragma GCC diagnostic ignored "-Wc++11-extensions"
+		#if defined(__clang__)
+			// warning: 'override' keyword is a C++11 extension [-Wc++11-extensions]
+			// Disabling this warning is less intrusive than enabling C++11 extensions
+			#pragma GCC diagnostic ignored "-Wc++11-extensions"
+		#endif
 	#else
 		#define OVERRIDE
 	#endif
 
 #endif // else _WIN32
 
+//-----------------------------------------------------------------------------
+// Set up platform type defines.
+//-----------------------------------------------------------------------------
+#if defined( PLATFORM_X360 ) || defined( _PS3 )
+	#if !defined( _GAMECONSOLE )
+		#define _GAMECONSOLE
+	#endif
+	#define IsPC()			false
+	#define IsGameConsole()	true
+#else
+	#define IsPC()			true
+	#define IsGameConsole()	false
+#endif
+
+#ifdef PLATFORM_64BITS
+	#define IsPlatform64Bits()	true
+#else
+	#define IsPlatform64Bits()	false
+#endif
+
 // From steam/steamtypes.h
 // RTime32
 // We use this 32 bit time representing real world time.
@@ -407,6 +436,13 @@ typedef void * HINSTANCE;
 #define	DebuggerBreakIfDebugging_StagingOnly()
 #endif
 
+// Allows you to specify code that should only execute if we are in a staging build. Otherwise the code noops.
+#ifdef STAGING_ONLY
+#define STAGING_ONLY_EXEC( _exec ) do { _exec; } while (0)
+#else
+#define STAGING_ONLY_EXEC( _exec ) do { } while (0)
+#endif
+
 // C functions for external declarations that call the appropriate C++ methods
 #ifndef EXPORT
 	#ifdef _WIN32
@@ -1177,6 +1213,9 @@ struct CPUInformation
 
 	tchar* m_szProcessorID;				// Processor vendor Identification.
 
+	uint32 m_nModel;
+	uint32 m_nFeatures[3];
+
 	CPUInformation(): m_Size(0){}
 };
 
diff --git a/mp/src/public/tier0/stacktools.h b/mp/src/public/tier0/stacktools.h
new file mode 100644
index 00000000..c356b8c0
--- /dev/null
+++ b/mp/src/public/tier0/stacktools.h
@@ -0,0 +1,153 @@
+//========= Copyright � 1996-2008, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Tools for grabbing/dumping the stack at runtime
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TIER0_STACKTOOLS_H
+#define TIER0_STACKTOOLS_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tier0/platform.h"
+
+#if (defined( PLATFORM_WINDOWS ) || defined( PLATFORM_X360 )) && !defined( STEAM ) && !defined( _CERT ) && defined( TCHAR_IS_CHAR ) //designed for windows/x360, not built/tested with wide characters, not intended for release builds (but probably wouldn't damage anything)
+#	define ENABLE_RUNTIME_STACK_TRANSLATION //uncomment to enable runtime stack translation tools. All of which use on-demand loading of necessary dll's and pdb's
+#endif
+
+#if defined( ENABLE_RUNTIME_STACK_TRANSLATION )
+//#define ENABLE_THREAD_PARENT_STACK_TRACING 1 //uncomment to actually enable tracking stack traces from threads and jobs to their parent thread. Must also define THREAD_PARENT_STACK_TRACE_SUPPORTED in threadtools.h
+#	if defined( ENABLE_THREAD_PARENT_STACK_TRACING )
+#		define THREAD_PARENT_STACK_TRACE_LENGTH 32
+#	endif
+#endif
+
+
+
+
+PLATFORM_INTERFACE int GetCallStack( void **pReturnAddressesOut, int iArrayCount, int iSkipCount );
+
+//ONLY WORKS IF THE CRAWLED PORTION OF THE STACK DISABLES FRAME POINTER OMISSION (/Oy-)  "vpc /nofpo"
+PLATFORM_INTERFACE int GetCallStack_Fast( void **pReturnAddressesOut, int iArrayCount, int iSkipCount );
+
+typedef int (*FN_GetCallStack)( void **pReturnAddressesOut, int iArrayCount, int iSkipCount );
+
+//where we'll find our PDB's for win32.
+PLATFORM_INTERFACE void SetStackTranslationSymbolSearchPath( const char *szSemicolonSeparatedList = NULL );
+PLATFORM_INTERFACE void StackToolsNotify_LoadedLibrary( const char *szLibName );
+
+//maximum output sample "tier0.dll!TranslateStackInfo - u:\Dev\L4D\src\tier0\stacktools.cpp(162) + 4 bytes"
+enum TranslateStackInfo_StyleFlags_t
+{
+	TSISTYLEFLAG_NONE = 0,
+	TSISTYLEFLAG_MODULENAME = (1<<0), //start with module			Sample: "tier0.dll!"
+	TSISTYLEFLAG_SYMBOLNAME = (1<<1), //include the symbol name		Sample: "TranslateStackInfo"
+	TSISTYLEFLAG_FULLPATH = (1<<2), //include full path				Sample: "u:\Dev\L4D\src\tier0\stacktools.cpp"
+	TSISTYLEFLAG_SHORTPATH = (1<<3), //only include 2 directories	Sample: "\src\tier0\stacktools.cpp"
+	TSISTYLEFLAG_LINE = (1<<4), //file line number					Sample: "(162)"
+	TSISTYLEFLAG_LINEANDOFFSET = (1<<5), //file line + offset		Sample: "(162) + 4 bytes"
+	TSISTYLEFLAG_LAST = TSISTYLEFLAG_LINEANDOFFSET,
+	TSISTYLEFLAG_DEFAULT = (TSISTYLEFLAG_MODULENAME | TSISTYLEFLAG_SYMBOLNAME | TSISTYLEFLAG_FULLPATH | TSISTYLEFLAG_LINEANDOFFSET), //produces sample above
+};
+
+//Generates a formatted list of function information, returns number of translated entries
+//On 360 this generates a string that can be decoded by VXConsole in print functions. Optimal path for translation because it's one way. Other paths require multiple transactions.
+PLATFORM_INTERFACE int TranslateStackInfo( const void * const *pCallStack, int iCallStackCount, tchar *szOutput, int iOutBufferSize, const tchar *szEntrySeparator, TranslateStackInfo_StyleFlags_t style = TSISTYLEFLAG_DEFAULT );
+
+PLATFORM_INTERFACE void PreloadStackInformation( void * const *pAddresses, int iAddressCount ); //caches data and reduces communication with VXConsole to speed up 360 decoding when using any of the Get***FromAddress() functions. Nop on PC.
+PLATFORM_INTERFACE bool GetFileAndLineFromAddress( const void *pAddress, tchar *pFileNameOut, int iMaxFileNameLength, uint32 &iLineNumberOut, uint32 *pDisplacementOut = NULL );
+PLATFORM_INTERFACE bool GetSymbolNameFromAddress( const void *pAddress, tchar *pSymbolNameOut, int iMaxSymbolNameLength, uint64 *pDisplacementOut = NULL );
+PLATFORM_INTERFACE bool GetModuleNameFromAddress( const void *pAddress, tchar *pModuleNameOut, int iMaxModuleNameLength );
+
+
+
+class PLATFORM_CLASS CCallStackStorage //a helper class to grab a stack trace as close to the leaf code surface as possible, then pass it on to deeper functions intact with less unpredictable inlining pollution
+{
+public:
+	CCallStackStorage( FN_GetCallStack GetStackFunction = GetCallStack, uint32 iSkipCalls = 0 );
+	CCallStackStorage( const CCallStackStorage &copyFrom )
+	{
+		iValidEntries = copyFrom.iValidEntries;
+		memcpy( pStack, copyFrom.pStack, sizeof( void * ) * copyFrom.iValidEntries );
+	}
+
+	void *pStack[128]; //probably too big, possibly too small for some applications. Don't want to spend the time figuring out how to generalize this without templatizing pollution or mallocs
+	uint32 iValidEntries;
+};
+
+
+//Hold onto one of these to denote the top of a functional stack trace. Also allows us to string together threads to their parents
+class PLATFORM_CLASS CStackTop_Base
+{
+protected:
+#if defined( ENABLE_RUNTIME_STACK_TRANSLATION )
+	CStackTop_Base *m_pPrevTop;
+	void *m_pStackBase;
+	void *m_pReplaceAddress;
+
+	void * const *m_pParentStackTrace;
+	int m_iParentStackTraceLength;
+#endif
+};
+
+//makes a copy of the parent stack
+class PLATFORM_CLASS CStackTop_CopyParentStack : public CStackTop_Base
+{
+public:
+	CStackTop_CopyParentStack( void * const * pParentStackTrace, int iParentStackTraceLength );
+	~CStackTop_CopyParentStack( void );
+};
+
+//just references the parent stack. Assuming that you'll keep that memory around as long as you're keeping this Stack Top marker.
+class PLATFORM_CLASS CStackTop_ReferenceParentStack : public CStackTop_Base
+{
+public:
+	CStackTop_ReferenceParentStack( void * const * pParentStackTrace = NULL, int iParentStackTraceLength = 0 );
+	~CStackTop_ReferenceParentStack( void );
+	void ReleaseParentStackReferences( void ); //in case you need to delete the parent stack trace before this class goes out of scope
+};
+
+
+//Encodes data so that every byte's most significant bit is a 1. Ensuring no null terminators.
+//This puts the encoded data in the 128-255 value range. Leaving all standard ascii characters for control.
+//Returns string length (not including the written null terminator as is standard). 
+//Or if the buffer is too small. Returns negative of necessary buffer size (including room needed for null terminator)
+PLATFORM_INTERFACE int EncodeBinaryToString( const void *pToEncode, int iDataLength, char *pEncodeOut, int iEncodeBufferSize );
+
+//Decodes a string produced by EncodeBinaryToString(). Safe to decode in place if you don't mind trashing your string, binary byte count always less than string byte count.
+//Returns:
+//	>= 0 is the decoded data size
+//	INT_MIN (most negative value possible) indicates an improperly formatted string (not our data)
+//	all other negative values are the negative of how much dest buffer size is necessary.
+PLATFORM_INTERFACE int DecodeBinaryFromString( const char *pString, void *pDestBuffer, int iDestBufferSize, char **ppParseFinishOut = NULL );
+
+
+
+
+// 360<->VXConsole specific communication definitions
+#define XBX_CALLSTACKDECODEPREFIX ":CSDECODE["
+
+enum StackTranslation_BinaryHandler_Command_t
+{
+	ST_BHC_LOADEDLIBARY,
+	ST_BHC_GETTRANSLATIONINFO,
+};
+
+#pragma pack(push)
+#pragma pack(1)
+struct FullStackInfo_t
+{
+	const void *pAddress;
+	char szModuleName[24];
+	char szFileName[MAX_PATH/2];
+	char szSymbol[64];
+	uint32 iLine;
+	uint32 iSymbolOffset;
+
+};
+#pragma pack(pop)
+
+#endif //#ifndef TIER0_STACKTOOLS_H
diff --git a/mp/src/public/tier0/threadtools.h b/mp/src/public/tier0/threadtools.h
index 7a69f0c6..e5b720e2 100644
--- a/mp/src/public/tier0/threadtools.h
+++ b/mp/src/public/tier0/threadtools.h
@@ -233,7 +233,7 @@ inline void const *ThreadInterlockedExchangePointerToConst( void const * volatil
 inline void const *ThreadInterlockedCompareExchangePointerToConst( void const * volatile *p, void const *value, void const *comperand )	{ return ThreadInterlockedCompareExchangePointer( const_cast < void * volatile * > ( p ), const_cast < void * > ( value ), const_cast < void * > ( comperand ) ); }
 inline bool ThreadInterlockedAssignPointerToConstIf( void const * volatile *p, void const *value, void const *comperand )			{ return ThreadInterlockedAssignPointerIf( const_cast < void * volatile * > ( p ), const_cast < void * > ( value ), const_cast < void * > ( comperand ) ); }
 
-#if defined( X64BITS )
+#if defined( PLATFORM_64BITS )
 #if defined (_WIN32) 
 typedef __m128i int128;
 inline int128 int128_zero()	{ return _mm_setzero_si128(); }
@@ -289,6 +289,30 @@ PLATFORM_INTERFACE void ThreadNotifySyncReleasing(void *p);
 // work in a DLL loaded with LoadLibrary()
 //-----------------------------------------------------------------------------
 
+#ifndef NO_THREAD_LOCAL
+
+#if defined(_LINUX) && !defined(OSX)
+// linux totally supports compiler thread locals, even across dll's.
+#define PLAT_COMPILER_SUPPORTED_THREADLOCALS 1
+#define CTHREADLOCALINTEGER( typ ) __thread int
+#define CTHREADLOCALINT __thread int
+#define CTHREADLOCALPTR( typ ) __thread typ *
+#define CTHREADLOCAL( typ ) __thread typ
+#define GETLOCAL( x ) ( x )
+#endif // _LINUX && !OSX
+
+#if defined(WIN32) || defined(OSX)
+#ifndef __AFXTLS_H__ // not compatible with some Windows headers
+#define CTHREADLOCALINT CThreadLocalInt<int>
+#define CTHREADLOCALINTEGER( typ ) CThreadLocalInt<typ>
+#define CTHREADLOCALPTR( typ ) CThreadLocalPtr<typ>
+#define CTHREADLOCAL( typ ) CThreadLocal<typ>
+#define GETLOCAL( x ) ( x.Get() )
+#endif
+#endif // WIN32 || OSX
+
+#endif // NO_THREAD_LOCALS
+
 #ifndef __AFXTLS_H__ // not compatible with some Windows headers
 #ifndef NO_THREAD_LOCAL
 
@@ -484,7 +508,7 @@ public:
 	bool operator==( T *rhs ) const	{ return ( m_value == rhs ); }
 	bool operator!=( T *rhs ) const	{ return ( m_value != rhs ); }
 
-#ifdef X64BITS
+#if defined( PLATFORM_64BITS )
 	T *operator++()					{ return ((T *)ThreadInterlockedExchangeAdd64( (int64 *)&m_value, sizeof(T) )) + 1; }
 	T *operator++(int)				{ return (T *)ThreadInterlockedExchangeAdd64( (int64 *)&m_value, sizeof(T) ); }
 
@@ -523,6 +547,41 @@ private:
 	T * volatile m_value;
 };
 
+//-----------------------------------------------------------------------------
+// 
+// Platform independent verification that multiple threads aren't getting into the same code at the same time. 
+// Note: This is intended for use to identify problems, it doesn't provide any sort of thread safety.
+// 
+//-----------------------------------------------------------------------------
+class ReentrancyVerifier
+{
+public:
+	inline ReentrancyVerifier(CInterlockedInt* counter, int sleepTimeMS)
+	: mCounter(counter)
+	{
+		Assert(mCounter != NULL);
+
+		if (++(*mCounter) != 1) {
+			DebuggerBreakIfDebugging_StagingOnly();
+		}
+
+		if (sleepTimeMS > 0)
+		{
+			ThreadSleep(sleepTimeMS);
+		}
+	}
+
+	inline ~ReentrancyVerifier()
+	{
+		if (--(*mCounter) != 0) {
+			DebuggerBreakIfDebugging_StagingOnly();
+		}
+	}
+
+private:
+	CInterlockedInt* mCounter;
+};
+
 
 //-----------------------------------------------------------------------------
 //
diff --git a/mp/src/public/tier0/vprof.h b/mp/src/public/tier0/vprof.h
index 9464e4ad..1c7321bb 100644
--- a/mp/src/public/tier0/vprof.h
+++ b/mp/src/public/tier0/vprof.h
@@ -140,6 +140,8 @@
 #define VPROF_BUDGETGROUP_TENFOOT					VPROF_BUDGETGROUP_HTMLSURFACE
 #define VPROF_BUDGETGROUP_STEAMUI					VPROF_BUDGETGROUP_HTMLSURFACE
 #define VPROF_BUDGETGROUP_ATTRIBUTES				_T("Attributes")
+#define VPROF_BUDGETGROUP_FINDATTRIBUTE				_T("FindAttribute")
+#define VPROF_BUDGETGROUP_FINDATTRIBUTEUNSAFE		_T("FindAttributeUnsafe")
 	
 #ifdef _X360
 // update flags
diff --git a/mp/src/public/tier0/vprof_telemetry.h b/mp/src/public/tier0/vprof_telemetry.h
index a7758cf4..c60bde5d 100644
--- a/mp/src/public/tier0/vprof_telemetry.h
+++ b/mp/src/public/tier0/vprof_telemetry.h
@@ -133,7 +133,7 @@ public:
 		float time = ( tmFastTime() - time0 ) * g_Telemetry.flRDTSCToMilliSeconds;
 		if( time >= m_threshold )
 		{
-			tmMessage( TELEMETRY_LEVEL0, TMMF_ICON_NOTE | TMMF_SEVERITY_WARNING, "(dota/spike)%s %.2fms %t", m_message, time, tmSendCallStack( TELEMETRY_LEVEL0, 0 ) );
+			tmMessage( TELEMETRY_LEVEL0, TMMF_ICON_NOTE | TMMF_SEVERITY_WARNING, "(source/spike)%s %.2fms %t", m_message, time, tmSendCallStack( TELEMETRY_LEVEL0, 0 ) );
 		}
 	}
 
diff --git a/mp/src/public/tier0/wchartypes.h b/mp/src/public/tier0/wchartypes.h
index 9803870c..814470fd 100644
--- a/mp/src/public/tier0/wchartypes.h
+++ b/mp/src/public/tier0/wchartypes.h
@@ -88,6 +88,14 @@ typedef char tchar;
 #define TCHAR_IS_CHAR
 #endif
 
+#if defined( _MSC_VER ) || defined( WIN32 )
+typedef wchar_t uchar16;
+typedef unsigned int uchar32;
+#else
+typedef unsigned short uchar16;
+typedef wchar_t uchar32;
+#endif
+
 #ifdef FORCED_UNICODE
 #undef _UNICODE
 #endif
diff --git a/mp/src/public/tier1/KeyValues.h b/mp/src/public/tier1/KeyValues.h
index 0fdffb08..97ae69c2 100644
--- a/mp/src/public/tier1/KeyValues.h
+++ b/mp/src/public/tier1/KeyValues.h
@@ -120,8 +120,8 @@ public:
 	// File access. Set UsesEscapeSequences true, if resource file/buffer uses Escape Sequences (eg \n, \t)
 	void UsesEscapeSequences(bool state); // default false
 	void UsesConditionals(bool state); // default true
-	bool LoadFromFile( IBaseFileSystem *filesystem, const char *resourceName, const char *pathID = NULL );
-	bool SaveToFile( IBaseFileSystem *filesystem, const char *resourceName, const char *pathID = NULL, bool sortKeys = false, bool bAllowEmptyString = false );
+	bool LoadFromFile( IBaseFileSystem *filesystem, const char *resourceName, const char *pathID = NULL, bool refreshCache = false );
+	bool SaveToFile( IBaseFileSystem *filesystem, const char *resourceName, const char *pathID = NULL, bool sortKeys = false, bool bAllowEmptyString = false, bool bCacheResult = false );
 
 	// Read from a buffer...  Note that the buffer must be null terminated
 	bool LoadFromBuffer( char const *resourceName, const char *pBuffer, IBaseFileSystem* pFileSystem = NULL, const char *pPathID = NULL );
@@ -144,6 +144,8 @@ public:
 	//
 	KeyValues *GetFirstSubKey() { return m_pSub; }	// returns the first subkey in the list
 	KeyValues *GetNextKey() { return m_pPeer; }		// returns the next subkey
+	const KeyValues *GetNextKey() const { return m_pPeer; }		// returns the next subkey
+
 	void SetNextKey( KeyValues * pDat);
 	KeyValues *FindLastSubKey();	// returns the LAST subkey in the list.  This requires a linked list iteration to find the key.  Returns NULL if we don't have any children
 
@@ -203,7 +205,7 @@ public:
 	void operator delete( void *pMem );
 	void operator delete( void *pMem, int nBlockUse, const char *pFileName, int nLine );
 
-	KeyValues& operator=( KeyValues& src );
+	KeyValues& operator=( const KeyValues& src );
 
 	// Adds a chain... if we don't find stuff in this keyvalue, we'll look
 	// in the one we're chained to.
@@ -217,6 +219,10 @@ public:
 	// Allocate & create a new copy of the keys
 	KeyValues *MakeCopy( void ) const;
 
+	// Allocate & create a new copy of the keys, including the next keys. This is useful for top level files
+	// that don't use the usual convention of a root key with lots of children (like soundscape files).
+	KeyValues *MakeCopy( bool copySiblings ) const;
+
 	// Make a new copy of all subkeys, add them all to the passed-in keyvalues
 	void CopySubkeys( KeyValues *pParent ) const;
 
@@ -270,7 +276,9 @@ private:
 	KeyValues* CreateKeyUsingKnownLastChild( const char *keyName, KeyValues *pLastChild );
 	void AddSubkeyUsingKnownLastChild( KeyValues *pSubKey, KeyValues *pLastChild );
 
-	void RecursiveCopyKeyValues( KeyValues& src );
+	void CopyKeyValuesFromRecursive( const KeyValues& src );
+	void CopyKeyValue( const KeyValues& src, size_t tmpBufferSizeB, char* tmpBuffer );
+
 	void RemoveEverything();
 //	void RecursiveSaveToFile( IBaseFileSystem *filesystem, CUtlBuffer &buffer, int indentLevel );
 //	void WriteConvertedString( CUtlBuffer &buffer, const char *pszString );
diff --git a/mp/src/public/tier1/lzmaDecoder.h b/mp/src/public/tier1/lzmaDecoder.h
index 51ecfd1a..6f4b87fd 100644
--- a/mp/src/public/tier1/lzmaDecoder.h
+++ b/mp/src/public/tier1/lzmaDecoder.h
@@ -1,15 +1,22 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
 //
-//	LZMA Decoder. Designed for run time decoding.
+//  LZMA Codec interface for engine.
 //
-//	LZMA SDK 4.43 Copyright (c) 1999-2006 Igor Pavlov (2006-05-01)
-//	http://www.7-zip.org/
+//  LZMA SDK 9.38 beta
+//  2015-01-03 : Igor Pavlov : Public domain
+//  http://www.7-zip.org/
 //
-//=====================================================================================//
+//========================================================================//
 
 #ifndef _LZMADECODER_H
 #define _LZMADECODER_H
 #pragma once
 
+// Thanks for the useful define namespacing, LZMA
+#include "../../utils/lzma/C/7zVersion.h"
+#define LZMA_SDK_VERSION_MAJOR MY_VER_MAJOR
+#define LZMA_SDK_VERSION_MINOR MY_VER_MINOR
+
 #if !defined( _X360 )
 #define LZMA_ID				(('A'<<24)|('M'<<16)|('Z'<<8)|('L'))
 #else
@@ -27,15 +34,69 @@ struct lzma_header_t
 };
 #pragma pack()
 
+class CLZMAStream;
+
 class CLZMA
 {
 public:
-	unsigned int	Uncompress( unsigned char *pInput, unsigned char *pOutput );
-	bool			IsCompressed( unsigned char *pInput );
-	unsigned int	GetActualSize( unsigned char *pInput );
+	static unsigned int	Uncompress( unsigned char *pInput, unsigned char *pOutput );
+	static bool			IsCompressed( unsigned char *pInput );
+	static unsigned int	GetActualSize( unsigned char *pInput );
+};
+
+// For files besides the implementation, we forward declare a dummy struct. We can't unconditionally forward declare
+// this because LzmaEnc.h typedefs this directly to an unnamed struct :-/
+#ifndef CLzmaDec_t
+struct _CLzmaDec_t;
+#define CLzmaDec_t struct _CLzmaDec_t
+#endif
+
+class CLZMAStream
+{
+public:
+	CLZMAStream();
+	~CLZMAStream();
+
+	// Initialize a stream to read data from a LZMA style zip file, passing the original size from the zip headers.
+	// Streams with a source-engine style header (lzma_header_t) do not need an init call.
+	void InitZIPHeader( unsigned int nCompressedSize, unsigned int nOriginalSize );
+
+	// Attempt to read up to nMaxInputBytes from the compressed stream, writing up to nMaxOutputBytes to pOutput.
+	// Makes progress until blocked on input or output.
+	// Returns false if read stops due to an error or if called at EOF (GetExpectedBytesRemaining == 0)
+	bool Read( unsigned char *pInput, unsigned int nMaxInputBytes,
+	           unsigned char *pOutput, unsigned int nMaxOutputBytes,
+	           /* out */ unsigned int &nCompressedBytesRead, /* out */ unsigned int &nOutputBytesWritten );
+
+	// Get the expected uncompressed bytes yet to be read from this stream. Returns false if not yet known, such as
+	// before being fed the header.
+	bool GetExpectedBytesRemaining( /* out */ unsigned int &nBytesRemaining );
 
 private:
+	enum eHeaderParse
+	{
+		eHeaderParse_OK,
+		eHeaderParse_Fail,
+		eHeaderParse_NeedMoreBytes
+	};
+
+	eHeaderParse TryParseHeader( unsigned char *pInput, unsigned int nBytesAvailable, /* out */ unsigned int &nBytesConsumed );
+
+	void FreeDecoderState();
+	bool CreateDecoderState( const unsigned char *pProperties );
+
+	// Init from a zip-embedded LZMA stream. Requires the original size be passed from zip headers.
+	CLzmaDec_t *m_pDecoderState;
+
+	unsigned int m_nActualSize;
+	unsigned int m_nActualBytesRead;
+	unsigned int m_nCompressedSize;
+	unsigned int m_nCompressedBytesRead;
+
+	// If we have read past the header
+	bool m_bParsedHeader   : 1;
+	// If InitZIPHeader() was called. We're expecting a zip-style header and have size information.
+	bool m_bZIPStyleHeader : 1;
 };
 
 #endif
-
diff --git a/mp/src/public/tier1/refcount.h b/mp/src/public/tier1/refcount.h
index 264da100..9c756b84 100644
--- a/mp/src/public/tier1/refcount.h
+++ b/mp/src/public/tier1/refcount.h
@@ -14,6 +14,40 @@
 #pragma once
 #endif
 
+template <typename T>
+inline void SafeAssign(T** ppInoutDst, T* pInoutSrc )
+{
+	Assert( ppInoutDst );
+
+	// Do addref before release
+	if ( pInoutSrc )
+		( pInoutSrc )->AddRef();
+
+	// Do addref before release
+	if ( *ppInoutDst )
+		( *ppInoutDst )->Release();
+
+	// Do the assignment
+	( *ppInoutDst ) = pInoutSrc;
+}
+
+template <typename T>
+inline void SafeAddRef( T* pObj )
+{
+	if ( pObj )
+		pObj->AddRef();
+}
+
+template <typename T>
+inline void SafeRelease( T** ppInoutPtr )
+{
+	Assert( ppInoutPtr  );
+	if ( *ppInoutPtr )
+		( *ppInoutPtr )->Release();
+
+	( *ppInoutPtr ) = NULL;
+}
+
 //-----------------------------------------------------------------------------
 // Purpose:	Implement a standard reference counted interface. Use of this
 //			is optional insofar as all the concrete tools only require
diff --git a/mp/src/public/tier1/strtools.h b/mp/src/public/tier1/strtools.h
index 035789f9..12e0a0c4 100644
--- a/mp/src/public/tier1/strtools.h
+++ b/mp/src/public/tier1/strtools.h
@@ -151,6 +151,26 @@ inline bool	StringHasPrefix             ( const char *str, const char *prefix )
 inline bool	StringHasPrefixCaseSensitive( const char *str, const char *prefix ) { return StringAfterPrefixCaseSensitive( str, prefix ) != NULL; }
 
 
+template< bool CASE_SENSITIVE > inline bool _V_strEndsWithInner( const char *pStr, const char *pSuffix )
+{
+	int nSuffixLen = V_strlen( pSuffix );
+	int nStringLen = V_strlen( pStr );
+	if ( nSuffixLen == 0 )
+		return true; // All strings end with the empty string (matches Java & .NET behaviour)
+	if ( nStringLen < nSuffixLen )
+		return false;
+	pStr += nStringLen - nSuffixLen;
+	if ( CASE_SENSITIVE )
+		return !V_strcmp(  pStr, pSuffix );
+	else
+		return !V_stricmp( pStr, pSuffix );
+}
+
+// Does 'pStr' end with 'pSuffix'? (case sensitive/insensitive variants)
+inline bool V_strEndsWith(  const char *pStr, const char *pSuffix ) { return _V_strEndsWithInner<TRUE>(  pStr, pSuffix ); }
+inline bool V_striEndsWith( const char *pStr, const char *pSuffix ) { return _V_strEndsWithInner<FALSE>( pStr, pSuffix ); }
+
+
 // Normalizes a float string in place.  
 // (removes leading zeros, trailing zeros after the decimal point, and the decimal point itself where possible)
 void			V_normalizeFloatString( char* pFloat );
@@ -220,6 +240,15 @@ template <size_t maxLenInChars> void V_strcpy_safe( OUT_Z_ARRAY char (&pDest)[ma
 	V_strncpy( pDest, pSrc, (int)maxLenInChars ); 
 }
 
+// A function which duplicates a string using new[] to allocate the new string.
+inline char *V_strdup( const char *pSrc )
+{
+	int nLen = V_strlen( pSrc );
+	char *pResult = new char [ nLen+1 ];
+	V_memcpy( pResult, pSrc, nLen+1 );
+	return pResult;
+}
+
 void V_wcsncpy( OUT_Z_BYTECAP(maxLenInBytes) wchar_t *pDest, wchar_t const *pSrc, int maxLenInBytes );
 template <size_t maxLenInChars> void V_wcscpy_safe( OUT_Z_ARRAY wchar_t (&pDest)[maxLenInChars], wchar_t const *pSrc ) 
 { 
@@ -245,6 +274,164 @@ template <size_t cchDest> char *V_strlwr_safe( INOUT_Z_ARRAY char (&pBuf)[cchDes
 	return _V_strnlwr( pBuf, (int)cchDest ); 
 }
 
+// Unicode string conversion policies - what to do if an illegal sequence is encountered
+enum EStringConvertErrorPolicy
+{
+	_STRINGCONVERTFLAG_SKIP =		1,
+	_STRINGCONVERTFLAG_FAIL =		2,
+	_STRINGCONVERTFLAG_ASSERT =		4,
+
+	STRINGCONVERT_REPLACE =			0,
+	STRINGCONVERT_SKIP =			_STRINGCONVERTFLAG_SKIP,
+	STRINGCONVERT_FAIL =			_STRINGCONVERTFLAG_FAIL,
+
+	STRINGCONVERT_ASSERT_REPLACE =	_STRINGCONVERTFLAG_ASSERT + STRINGCONVERT_REPLACE,
+	STRINGCONVERT_ASSERT_SKIP =		_STRINGCONVERTFLAG_ASSERT + STRINGCONVERT_SKIP,
+	STRINGCONVERT_ASSERT_FAIL =		_STRINGCONVERTFLAG_ASSERT + STRINGCONVERT_FAIL,
+}; 
+
+// Unicode (UTF-8, UTF-16, UTF-32) fundamental conversion functions.
+bool Q_IsValidUChar32( uchar32 uValue );
+int Q_UChar32ToUTF8Len( uchar32 uValue );
+int Q_UChar32ToUTF8( uchar32 uValue, char *pOut );
+int Q_UChar32ToUTF16Len( uchar32 uValue );
+int Q_UChar32ToUTF16( uchar32 uValue, uchar16 *pOut );
+
+// Validate that a Unicode string is well-formed and contains only valid code points
+bool Q_UnicodeValidate( const char *pUTF8 );
+bool Q_UnicodeValidate( const uchar16 *pUTF16 );
+bool Q_UnicodeValidate( const uchar32 *pUTF32 );
+
+// Returns length of string in Unicode code points (printed glyphs or non-printing characters)
+int Q_UnicodeLength( const char *pUTF8 );
+int Q_UnicodeLength( const uchar16 *pUTF16 );
+int Q_UnicodeLength( const uchar32 *pUTF32 );
+
+// Returns length of string in elements, not characters! These are analogous to Q_strlen and Q_wcslen
+inline int Q_strlen16( const uchar16 *puc16 ) { int nElems = 0; while ( puc16[nElems] ) ++nElems; return nElems; }
+inline int Q_strlen32( const uchar32 *puc32 ) { int nElems = 0; while ( puc32[nElems] ) ++nElems; return nElems; }
+
+
+// Repair invalid Unicode strings by dropping truncated characters and fixing improperly-double-encoded UTF-16 sequences.
+// Unlike conversion functions which replace with '?' by default, a repair operation assumes that you know that something
+// is wrong with the string (eg, mid-sequence truncation) and you just want to do the best possible job of cleaning it up.
+// You can pass a REPLACE or FAIL policy if you would prefer to replace characters with '?' or clear the entire string.
+// Returns nonzero on success, or 0 if the policy is FAIL and an invalid sequence was found.
+int Q_UnicodeRepair( char *pUTF8, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_SKIP );
+int Q_UnicodeRepair( uchar16 *pUTF16, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_SKIP );
+int Q_UnicodeRepair( uchar32 *pUTF32, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_SKIP );
+
+// Advance pointer forward by N Unicode code points (printed glyphs or non-printing characters), stopping at terminating null if encountered.
+char *Q_UnicodeAdvance( char *pUTF8, int nCharacters );
+uchar16 *Q_UnicodeAdvance( uchar16 *pUTF16, int nCharactersnCharacters );
+uchar32 *Q_UnicodeAdvance( uchar32 *pUTF32, int nChars );
+inline const char *Q_UnicodeAdvance( const char *pUTF8, int nCharacters ) { return Q_UnicodeAdvance( (char*) pUTF8, nCharacters ); }
+inline const uchar16 *Q_UnicodeAdvance( const uchar16 *pUTF16, int nCharacters ) { return Q_UnicodeAdvance( (uchar16*) pUTF16, nCharacters ); }
+inline const uchar32 *Q_UnicodeAdvance( const uchar32 *pUTF32, int nCharacters ) { return Q_UnicodeAdvance( (uchar32*) pUTF32, nCharacters ); }
+
+// Truncate to maximum of N Unicode code points (printed glyphs or non-printing characters)
+inline void Q_UnicodeTruncate( char *pUTF8, int nCharacters ) { *Q_UnicodeAdvance( pUTF8, nCharacters ) = 0; }
+inline void Q_UnicodeTruncate( uchar16 *pUTF16, int nCharacters ) { *Q_UnicodeAdvance( pUTF16, nCharacters ) = 0; }
+inline void Q_UnicodeTruncate( uchar32 *pUTF32, int nCharacters ) { *Q_UnicodeAdvance( pUTF32, nCharacters ) = 0; }
+
+
+// Conversion between Unicode string types (UTF-8, UTF-16, UTF-32). Deals with bytes, not element counts,
+// to minimize harm from the programmer mistakes which continue to plague our wide-character string code.
+// Returns the number of bytes written to the output, or if output is NULL, the number of bytes required.
+int Q_UTF8ToUTF16( const char *pUTF8, OUT_Z_BYTECAP(cubDestSizeInBytes) uchar16 *pUTF16, int cubDestSizeInBytes, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_ASSERT_REPLACE );
+int Q_UTF8ToUTF32( const char *pUTF8, OUT_Z_BYTECAP(cubDestSizeInBytes) uchar32 *pUTF32, int cubDestSizeInBytes, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_ASSERT_REPLACE );
+int Q_UTF16ToUTF8( const uchar16 *pUTF16, OUT_Z_BYTECAP(cubDestSizeInBytes) char *pUTF8, int cubDestSizeInBytes, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_ASSERT_REPLACE );
+int Q_UTF16ToUTF32( const uchar16 *pUTF16, OUT_Z_BYTECAP(cubDestSizeInBytes) uchar32 *pUTF32, int cubDestSizeInBytes, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_ASSERT_REPLACE );
+int Q_UTF32ToUTF8( const uchar32 *pUTF32, OUT_Z_BYTECAP(cubDestSizeInBytes) char *pUTF8, int cubDestSizeInBytes, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_ASSERT_REPLACE );
+int Q_UTF32ToUTF16( const uchar32 *pUTF32, OUT_Z_BYTECAP(cubDestSizeInBytes) uchar16 *pUTF16, int cubDestSizeInBytes, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_ASSERT_REPLACE );
+
+// This is disgusting and exist only easily to facilitate having 16-bit and 32-bit wchar_t's on different platforms
+int Q_UTF32ToUTF32( const uchar32 *pUTF32Source, OUT_Z_BYTECAP(cubDestSizeInBytes) uchar32 *pUTF32Dest, int cubDestSizeInBytes, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_ASSERT_REPLACE );
+
+// Conversion between count-limited UTF-n character arrays, including any potential NULL characters.
+// Output has a terminating NULL for safety; strip the last character if you want an unterminated string.
+// Returns the number of bytes written to the output, or if output is NULL, the number of bytes required.
+int Q_UTF8CharsToUTF16( const char *pUTF8, int nElements, OUT_Z_BYTECAP(cubDestSizeInBytes) uchar16 *pUTF16, int cubDestSizeInBytes, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_ASSERT_REPLACE );
+int Q_UTF8CharsToUTF32( const char *pUTF8, int nElements, OUT_Z_BYTECAP(cubDestSizeInBytes) uchar32 *pUTF32, int cubDestSizeInBytes, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_ASSERT_REPLACE );
+int Q_UTF16CharsToUTF8( const uchar16 *pUTF16, int nElements, OUT_Z_BYTECAP(cubDestSizeInBytes) char *pUTF8, int cubDestSizeInBytes, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_ASSERT_REPLACE );
+int Q_UTF16CharsToUTF32( const uchar16 *pUTF16, int nElements, OUT_Z_BYTECAP(cubDestSizeInBytes) uchar32 *pUTF32, int cubDestSizeInBytes, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_ASSERT_REPLACE );
+int Q_UTF32CharsToUTF8( const uchar32 *pUTF32, int nElements, OUT_Z_BYTECAP(cubDestSizeInBytes) char *pUTF8, int cubDestSizeInBytes, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_ASSERT_REPLACE );
+int Q_UTF32CharsToUTF16( const uchar32 *pUTF32, int nElements, OUT_Z_BYTECAP(cubDestSizeInBytes) uchar16 *pUTF16, int cubDestSizeInBytes, EStringConvertErrorPolicy ePolicy = STRINGCONVERT_ASSERT_REPLACE );
+
+// Decode a single UTF-8 character to a uchar32, returns number of UTF-8 bytes parsed
+int Q_UTF8ToUChar32( const char *pUTF8_, uchar32 &uValueOut, bool &bErrorOut );
+
+// Decode a single UTF-16 character to a uchar32, returns number of UTF-16 characters (NOT BYTES) consumed
+int Q_UTF16ToUChar32( const uchar16 *pUTF16, uchar32 &uValueOut, bool &bErrorOut );
+
+
+// NOTE: WString means either UTF32 or UTF16 depending on the platform and compiler settings.
+#if defined( _MSC_VER ) || defined( _WIN32 )
+#define Q_UTF8ToWString Q_UTF8ToUTF16
+#define Q_UTF8CharsToWString Q_UTF8CharsToUTF16
+#define Q_UTF32ToWString Q_UTF32ToUTF16
+#define Q_WStringToUTF8 Q_UTF16ToUTF8
+#define Q_WStringCharsToUTF8 Q_UTF16CharsToUTF8
+#define Q_WStringToUTF32 Q_UTF16ToUTF32
+#else
+#define Q_UTF8ToWString Q_UTF8ToUTF32
+#define Q_UTF8CharsToWString Q_UTF8CharsToUTF32
+#define Q_UTF32ToWString Q_UTF32ToUTF32
+#define Q_WStringToUTF8 Q_UTF32ToUTF8
+#define Q_WStringCharsToUTF8 Q_UTF32CharsToUTF8
+#define Q_WStringToUTF32 Q_UTF32ToUTF32
+#endif
+
+// These are legacy names which don't make a lot of sense but are used everywhere. Prefer the WString convention wherever possible
+#define V_UTF8ToUnicode Q_UTF8ToWString
+#define V_UnicodeToUTF8 Q_WStringToUTF8
+
+
+#ifdef WIN32
+// This function is ill-defined as it relies on the current ANSI code page. Currently Win32 only for tools.
+int Q_LocaleSpecificANSIToUTF8( const char *pANSI, int cubSrcInBytes, OUT_Z_BYTECAP(cubDestSizeInBytes) char *pUTF8, int cubDestSizeInBytes );
+#endif
+
+// Windows-1252 is mostly the same as ISO Latin-1, and probably what you want if you are 
+// saddled with an 8-bit ANSI string that originated on a Windows system.
+int Q_Windows1252CharsToUTF8( const char *pchSrc, int cchSrc, OUT_Z_BYTECAP(cchDestUTF8) char *pchDestUTF8, int cchDestUTF8 );
+
+// CP 437 is used for VGA console text and some old-school file formats such as ZIP. It
+// is also known as the "IBM PC OEM code page" and various related names. You probably
+// don't want to use this function unless you know for a fact that you're dealing with
+// old-school OEM code pages. Otherwise try the Windows-1252 function above.
+int Q_CP437CharsToUTF8( const char *pchSrc, int cchSrc, OUT_Z_BYTECAP(cchDestUTF8) char *pchDestUTF8, int cchDestUTF8 );
+
+// replaces characters in a UTF8 string with their identical-looking equivalent (non-roundtrippable)
+//
+// older version of API uses a small homoglyph table; newer version uses a larger one
+//
+// strings using old version are baked into the database, so we won't toss it quite yet,
+// but don't use it for new features.
+int Q_NormalizeUTF8Old( const char *pchSrc, OUT_Z_CAP(cchDest) char *pchDest, int cchDest );
+int Q_NormalizeUTF8( const char *pchSrc, OUT_Z_CAP(cchDest) char *pchDest, int cchDest );
+
+//-----------------------------------------------------------------------------
+// Purpose: replaces characters in a UTF8 string with similar-looking equivalents.
+// Only replaces with ASCII characters.. non-recognized characters will be replaced with ?
+// This operation is destructive (i.e. you can't roundtrip through the normalized
+// form).
+//-----------------------------------------------------------------------------
+template <size_t maxLenInChars> int Q_NormalizeUTF8ToASCII( OUT_Z_ARRAY char (&pchDest)[maxLenInChars], const char *pchSrc ) 
+{ 
+	int nResult = Q_NormalizeUTF8( pchSrc, pchDest, maxLenInChars );
+
+	// replace non ASCII characters with ?
+	for ( int i = 0; i < nResult; i++ )
+	{
+		if ( pchDest[i] > 127 || pchDest[i] < 0 )
+		{
+			pchDest[i] = '?';
+		}
+	}
+
+	return nResult;
+}
 
 // UNDONE: Find a non-compiler-specific way to do this
 #ifdef _WIN32
@@ -321,13 +508,29 @@ char *V_pretifymem( float value, int digitsafterdecimal = 2, bool usebinaryonek
 // Prints out a pretified integer with comma separators (eg, 7,233,270,000)
 char *V_pretifynum( int64 value );
 
-// conversion functions wchar_t <-> char, returning the number of characters converted
-int V_UTF8ToUnicode( const char *pUTF8, OUT_Z_BYTECAP(cubDestSizeInBytes) wchar_t *pwchDest, int cubDestSizeInBytes );
-int V_UnicodeToUTF8( const wchar_t *pUnicode, OUT_Z_BYTECAP(cubDestSizeInBytes) char *pUTF8, int cubDestSizeInBytes );
-int V_UCS2ToUnicode( const ucs2 *pUCS2, OUT_Z_BYTECAP(cubDestSizeInBytes) wchar_t *pUnicode, int cubDestSizeInBytes );
-int V_UCS2ToUTF8( const ucs2 *pUCS2, OUT_Z_BYTECAP(cubDestSizeInBytes) char *pUTF8, int cubDestSizeInBytes );
-int V_UnicodeToUCS2( const wchar_t *pUnicode, int cubSrcInBytes, OUT_Z_BYTECAP(cubDestSizeInBytes) char *pUCS2, int cubDestSizeInBytes );
-int V_UTF8ToUCS2( const char *pUTF8, int cubSrcInBytes, OUT_Z_BYTECAP(cubDestSizeInBytes) ucs2 *pUCS2, int cubDestSizeInBytes );
+int _V_UCS2ToUnicode( const ucs2 *pUCS2, OUT_Z_BYTECAP(cubDestSizeInBytes) wchar_t *pUnicode, int cubDestSizeInBytes );
+template< typename T > inline int V_UCS2ToUnicode( const ucs2 *pUCS2, OUT_Z_BYTECAP(cubDestSizeInBytes) wchar_t *pUnicode, T cubDestSizeInBytes )
+{
+	return _V_UCS2ToUnicode( pUCS2, pUnicode, static_cast<int>(cubDestSizeInBytes) );
+}
+
+int _V_UCS2ToUTF8( const ucs2 *pUCS2, OUT_Z_BYTECAP(cubDestSizeInBytes) char *pUTF8, int cubDestSizeInBytes );
+template< typename T > inline int V_UCS2ToUTF8( const ucs2 *pUCS2, OUT_Z_BYTECAP(cubDestSizeInBytes) char *pUTF8, T cubDestSizeInBytes )
+{
+	return _V_UCS2ToUTF8( pUCS2, pUTF8, static_cast<int>(cubDestSizeInBytes) );
+}
+
+int _V_UnicodeToUCS2( const wchar_t *pUnicode, int cubSrcInBytes, OUT_Z_BYTECAP(cubDestSizeInBytes) char *pUCS2, int cubDestSizeInBytes );
+template< typename T, typename U > inline int V_UnicodeToUCS2( const wchar_t *pUnicode, T cubSrcInBytes, OUT_Z_BYTECAP(cubDestSizeInBytes) char *pUCS2, U cubDestSizeInBytes )
+{
+	return _V_UnicodeToUCS2( pUnicode, static_cast<int>(cubSrcInBytes), pUCS2, static_cast<int>(cubDestSizeInBytes) );
+}
+
+int _V_UTF8ToUCS2( const char *pUTF8, int cubSrcInBytes, OUT_Z_BYTECAP(cubDestSizeInBytes) ucs2 *pUCS2, int cubDestSizeInBytes );
+template< typename T, typename U > inline int V_UTF8ToUCS2( const char *pUTF8, T cubSrcInBytes, OUT_Z_BYTECAP(cubDestSizeInBytes) ucs2 *pUCS2, U cubDestSizeInBytes )
+{
+	return _V_UTF8ToUCS2( pUTF8, static_cast<int>(cubSrcInBytes), pUCS2, static_cast<int>(cubDestSizeInBytes) );
+}
 
 // strips leading and trailing whitespace; returns true if any characters were removed. UTF-8 and UTF-16 versions.
 bool Q_StripPrecedingAndTrailingWhitespace( char *pch );
@@ -573,6 +776,7 @@ public:
 		m_pwch = NULL;
 #if !defined( WIN32 ) && !defined(_WIN32)
 		m_pucs2 = NULL;
+		m_bCreatedUCS2 = false;
 #endif
 		m_bCreatedUTF16 = false;
 	}
@@ -584,6 +788,7 @@ public:
 		m_pwch = pwch;
 #if !defined( WIN32 ) && !defined(_WIN32)
 		m_pucs2 = NULL;
+		m_bCreatedUCS2 = false;
 #endif
 		m_bCreatedUTF16 = true;
 	}
@@ -594,7 +799,8 @@ public:
 		m_pch = NULL;
 		m_pwch = NULL;
 		m_pucs2 = pwch;
-		m_bCreatedUTF16 = true;
+		m_bCreatedUCS2 = true;
+		m_bCreatedUTF16 = false;
 	}
 #endif
 
@@ -652,6 +858,10 @@ public:
 		{
 			delete [] m_pwch;
 		}
+#if !defined( WIN32 ) && !defined(_WIN32)
+		if ( !m_bCreatedUCS2 && m_pucs2 )
+			delete [] m_pucs2;
+#endif
 	}
 
 private:
@@ -730,6 +940,8 @@ private:
 	// so we perform a second allocation that's just the size we need.
 	void PopulateUCS2()
 	{
+		if ( m_bCreatedUCS2 )
+			return;
 		if ( m_pch == NULL )
 			return;					// no UTF-8 string to convert
 		if ( m_pucs2 != NULL )
@@ -760,6 +972,7 @@ private:
 	const wchar_t *m_pwch;
 #if !defined( WIN32 ) && !defined(_WIN32)
 	const ucs2 *m_pucs2;
+	bool m_bCreatedUCS2;
 #endif
 	// "created as UTF-16", means our owned string is the UTF-8 string not the UTF-16 one.
 	bool m_bCreatedUTF16;
@@ -868,4 +1081,11 @@ size_t Q_URLDecode( OUT_CAP(nDecodeDestLen) char *pchDecodeDest, int nDecodeDest
 #endif // !defined( VSTDLIB_DLL_EXPORT )
 
 
+#ifdef POSIX
+#define FMT_WS L"%ls"
+#else
+#define FMT_WS L"%s"
+#endif
+
+
 #endif	// TIER1_STRTOOLS_H
diff --git a/mp/src/public/tier1/utlarray.h b/mp/src/public/tier1/utlarray.h
index 36850860..ce5ffe8b 100644
--- a/mp/src/public/tier1/utlarray.h
+++ b/mp/src/public/tier1/utlarray.h
@@ -43,6 +43,8 @@ class CUtlArray : public base_array_t
 {
 public:
 	typedef T ElemType_t;
+	typedef T* iterator;
+	typedef const T* const_iterator;
 
 	CUtlArray();
 	CUtlArray( T* pMemory, size_t count );
@@ -59,6 +61,13 @@ public:
 	T& Random();
 	const T& Random() const;
 
+	// STL compatible member functions. These allow easier use of std::sort
+	// and they are forward compatible with the C++ 11 range-based for loops.
+	iterator begin();
+	const_iterator begin() const;
+	iterator end();
+	const_iterator end() const;
+
 	T* Base();
 	const T* Base() const;
 
@@ -131,6 +140,30 @@ inline CUtlArray<T, MAX_SIZE>::CUtlArray( CUtlArray const& vec )
 }
 
 template< typename T, size_t MAX_SIZE >
+typename CUtlArray<T, MAX_SIZE>::iterator CUtlArray<T, MAX_SIZE>::begin()
+{ 
+	return Base(); 
+}
+
+template< typename T, size_t MAX_SIZE >
+typename CUtlArray<T, MAX_SIZE>::const_iterator CUtlArray<T, MAX_SIZE>::begin() const
+{ 
+	return Base(); 
+}
+
+template< typename T, size_t MAX_SIZE >
+typename CUtlArray<T, MAX_SIZE>::iterator CUtlArray<T, MAX_SIZE>::end()
+{ 
+	return Base() + Count(); 
+}
+
+template< typename T, size_t MAX_SIZE >
+typename CUtlArray<T, MAX_SIZE>::const_iterator CUtlArray<T, MAX_SIZE>::end() const
+{ 
+	return Base() + Count(); 
+}
+
+template< typename T, size_t MAX_SIZE >
 inline T *CUtlArray<T, MAX_SIZE>::Base()								
 { 
 	return &m_Memory[0]; 
diff --git a/mp/src/public/tier1/utlbuffer.h b/mp/src/public/tier1/utlbuffer.h
index 4213dd6a..0de85fda 100644
--- a/mp/src/public/tier1/utlbuffer.h
+++ b/mp/src/public/tier1/utlbuffer.h
@@ -189,7 +189,16 @@ public:
 	unsigned int	GetUnsignedInt( );
 	float			GetFloat( );
 	double			GetDouble( );
-	void			GetString( char* pString, int nMaxChars = 0 );
+	template <size_t maxLenInChars> void GetString( char( &pString )[maxLenInChars] )
+	{
+		GetStringInternal( pString, maxLenInChars );
+	}
+
+	void GetStringManualCharCount( char *pString, size_t maxLenInChars )
+	{
+		GetStringInternal( pString, maxLenInChars );
+	}
+
 	void			Get( void* pMem, int size );
 	void			GetLine( char* pLine, int nMaxChars = 0 );
 
@@ -384,6 +393,7 @@ protected:
 	// Call this to peek arbitrarily long into memory. It doesn't fail unless
 	// it can't read *anything* new
 	bool CheckArbitraryPeekGet( int nOffset, int &nIncrement );
+	void GetStringInternal( char *pString, size_t maxLenInChars );
 
 	template <typename T> void GetType( T& dest, const char *pszFmt );
 	template <typename T> void GetTypeBin( T& dest );
diff --git a/mp/src/public/tier1/utllinkedlist.h b/mp/src/public/tier1/utllinkedlist.h
index 822f0b36..46ac4a6f 100644
--- a/mp/src/public/tier1/utllinkedlist.h
+++ b/mp/src/public/tier1/utllinkedlist.h
@@ -679,7 +679,8 @@ I CUtlLinkedList<T,S,ML,I,M>::AllocInternal( bool multilist )
 			Assert( m_Memory.IsValidIterator( it ) );
 			if ( !m_Memory.IsValidIterator( it ) )
 			{
-				ExecuteNTimes( 10, Warning( "CUtlLinkedList overflow! (exhausted memory allocator)\n" ) );
+				// We rarely if ever handle alloc failure. Continuing leads to corruption.
+				Error( "CUtlLinkedList overflow! (exhausted memory allocator)\n" );
 				return InvalidIndex();
 			}
 		}
@@ -687,7 +688,8 @@ I CUtlLinkedList<T,S,ML,I,M>::AllocInternal( bool multilist )
 		// We can overflow before the utlmemory overflows, since S != I
 		if ( !IndexInRange( m_Memory.GetIndex( it ) ) )
 		{
-			ExecuteNTimes( 10, Warning( "CUtlLinkedList overflow! (exhausted index range)\n" ) );
+			// We rarely if ever handle alloc failure. Continuing leads to corruption.
+			Error( "CUtlLinkedList overflow! (exhausted index range)\n" );
 			return InvalidIndex();
 		}
 
diff --git a/mp/src/public/tier1/utlmultilist.h b/mp/src/public/tier1/utlmultilist.h
index c677746c..72a970ff 100644
--- a/mp/src/public/tier1/utlmultilist.h
+++ b/mp/src/public/tier1/utlmultilist.h
@@ -399,7 +399,8 @@ I CUtlMultiList<T,I>::Alloc( )
 		// We can overflow before the utlmemory overflows, since we have have I != int
 		if ( !IndexInRange( m_MaxElementIndex ) )
 		{
-			ExecuteNTimes( 10, Warning( "CUtlMultiList overflow! (exhausted index range)\n" ) );
+			// We rarely if ever handle alloc failure. Continuing leads to corruption.
+			Error( "CUtlMultiList overflow! (exhausted index range)\n" );
 			return InvalidIndex();
 		}
 
@@ -413,7 +414,8 @@ I CUtlMultiList<T,I>::Alloc( )
 			
 			if ( m_MaxElementIndex >= m_Memory.NumAllocated() )
 			{
-				ExecuteNTimes( 10, Warning( "CUtlMultiList overflow! (exhausted memory allocator)\n" ) );
+				// We rarely if ever handle alloc failure. Continuing leads to corruption.
+				Error( "CUtlMultiList overflow! (exhausted memory allocator)\n" );
 				return InvalidIndex();
 			}
 		}
diff --git a/mp/src/public/tier1/utlqueue.h b/mp/src/public/tier1/utlqueue.h
index 8624a3db..05c89ee3 100644
--- a/mp/src/public/tier1/utlqueue.h
+++ b/mp/src/public/tier1/utlqueue.h
@@ -11,104 +11,541 @@
 #pragma once
 #endif
 
-#include "utlvector.h"
+#include "utlmemory.h"
 
-// T is the type stored in the stack
-template< class T > 
+//#define TEST_UTLQUEUE
+
+enum QueueIter_t { QUEUE_ITERATOR_INVALID = 0xffffffff };
+
+// T is the type stored in the queue
+template< class T, class M = CUtlMemory< T > > 
 class CUtlQueue
 {
 public:
 
-	// constructor: lessfunc is required, but may be set after the constructor with
-	// SetLessFunc
 	CUtlQueue( int growSize = 0, int initSize = 0 );
 	CUtlQueue( T *pMemory, int numElements );
 
 	// return the item from the front of the queue and delete it
-	T const& RemoveAtHead();
+	T RemoveAtHead();
+	bool RemoveAtHead( T &removedElement );
+
 	// return the item from the end of the queue and delete it
-	T const& RemoveAtTail();
+	T RemoveAtTail();
+	bool RemoveAtTail( T &removedElement );
 
 	// return item at the front of the queue
-	T const& Head();
+	T const& Head() const;
 	// return item at the end of the queue
-	T const& Tail();
+	T const& Tail() const;
 
 	// Add a new item to the end of the queue
 	void	Insert( T const &element );
 
 	// checks if an element of this value already exists on the stack, returns true if it does
-	bool		Check( T const element );
+	bool		Check( T const element ) const;
+
+	// iterators may be invalidated by Insert()
+	QueueIter_t First() const;
+	QueueIter_t Next( QueueIter_t it ) const;
+	QueueIter_t Last() const;
+	QueueIter_t Previous( QueueIter_t it ) const;
+	bool IsValid( QueueIter_t it ) const;
+	T const& Element( QueueIter_t it ) const;
+
+	// Returns the count of elements in the queue
+	int			Count() const;
+
+	// Return whether the queue is empty or not, faster than Count().
+	bool		IsEmpty() const;
 
-	// Returns the count of elements in the stack
-	int			Count() const { return m_heap.Count(); }
-	
 	// doesn't deallocate memory
-	void		RemoveAll() { m_heap.RemoveAll(); }
+	void		RemoveAll();
 
 	// Memory deallocation
-	void		Purge() { m_heap.Purge(); }
+	void		Purge();
 
 protected:
-	CUtlVector<T>	m_heap;
-	T				m_current;
+	QueueIter_t Next_Unchecked( QueueIter_t it ) const;
+	QueueIter_t Previous_Unchecked( QueueIter_t it ) const;
+
+	M					m_memory;
+
+	// if m_head == m_tail == QUEUE_ITERATOR_INVALID, then the queue is empty
+	QueueIter_t			m_head;
+	QueueIter_t			m_tail;
+
+#ifdef TEST_UTLQUEUE
+	friend void CUtlQueue_Test();
+#endif
+};
+
+//-----------------------------------------------------------------------------
+// The CUtlQueueFixed class:
+// A queue class with a fixed allocation scheme
+//-----------------------------------------------------------------------------
+template< class T, size_t MAX_SIZE >
+class CUtlQueueFixed : public CUtlQueue< T, CUtlMemoryFixed<T, MAX_SIZE > >
+{
+	typedef CUtlQueue< T, CUtlMemoryFixed<T, MAX_SIZE > > BaseClass;
+public:
+
+	// constructor, destructor
+	CUtlQueueFixed( int growSize = 0, int initSize = 0 ) : BaseClass( growSize, initSize ) {}
+	CUtlQueueFixed( T* pMemory, int numElements ) : BaseClass( pMemory, numElements ) {}
 };
 
-template< class T >
-inline CUtlQueue<T>::CUtlQueue( int growSize, int initSize ) :
-	m_heap(growSize, initSize)
+template< class T, class M >
+inline CUtlQueue<T, M>::CUtlQueue( int growSize, int initSize ) :
+	m_memory( growSize, initSize ), m_head( QUEUE_ITERATOR_INVALID ), m_tail( QUEUE_ITERATOR_INVALID )
 {
 }
 
-template< class T >
-inline CUtlQueue<T>::CUtlQueue( T *pMemory, int numElements )	: 
-	m_heap(pMemory, numElements)
+template< class T, class M >
+inline CUtlQueue<T, M>::CUtlQueue( T *pMemory, int numElements ) : 
+	m_memory( pMemory, numElements ), m_head( QUEUE_ITERATOR_INVALID ), m_tail( QUEUE_ITERATOR_INVALID )
 {
 }
 
-template <class T>
-inline T const& CUtlQueue<T>::RemoveAtHead()
+template <class T, class M>
+inline T CUtlQueue<T, M>::RemoveAtHead()
 {
-	m_current = m_heap[0];
-	m_heap.Remove((int)0);
-	return m_current; 
+	T temp;
+	RemoveAtHead( temp );
+	return temp;
 }
 
-template <class T>
-inline T const& CUtlQueue<T>::RemoveAtTail()
+template <class T, class M>
+inline bool CUtlQueue<T, M>::RemoveAtHead( T &removedElement )
 {
-	m_current = m_heap[ m_heap.Count() - 1 ];
-	m_heap.Remove((int)(m_heap.Count() - 1));
-	return m_current; 
+	Assert( m_head != QUEUE_ITERATOR_INVALID );
+	if ( m_head == QUEUE_ITERATOR_INVALID )
+	{
+		Construct( &removedElement );
+		return false;
+	}
+
+	QueueIter_t it = m_head;
+	removedElement = m_memory[ it ];
+	Destruct( &m_memory[ it ] );
+	if ( m_head == m_tail )
+	{
+		m_head = m_tail = QUEUE_ITERATOR_INVALID;
+	}
+	else
+	{
+		m_head = Next_Unchecked( m_head );
+	}
+	return true;
+}
+
+template <class T, class M>
+inline T CUtlQueue<T, M>::RemoveAtTail()
+{
+	T temp;
+	RemoveAtTail( temp );
+	return temp;
+}
+
+template <class T, class M>
+inline bool CUtlQueue<T, M>::RemoveAtTail( T &removedElement )
+{
+	Assert( m_tail != QUEUE_ITERATOR_INVALID );
+	if ( m_tail == QUEUE_ITERATOR_INVALID )
+	{
+		Construct( &removedElement );
+		return false;
+	}
+
+	removedElement = m_memory[ m_tail ];
+	Destruct( &m_memory[ m_tail ] );
+	if ( m_head == m_tail )
+	{
+		m_head = m_tail = QUEUE_ITERATOR_INVALID;
+	}
+	else
+	{
+		m_tail = Previous_Unchecked( m_tail );
+	}
+	return true;
 }
 
-template <class T>
-inline T const& CUtlQueue<T>::Head()
+template <class T, class M>
+inline T const& CUtlQueue<T, M>::Head() const
 {
-	m_current = m_heap[0];
-	return m_current; 
+	Assert( m_head != QUEUE_ITERATOR_INVALID );
+	if ( m_head == QUEUE_ITERATOR_INVALID )
+	{
+		static T dummy;
+		return dummy;
+	}
+
+	return m_memory[ m_head ];
 }
 
-template <class T>
-inline T const& CUtlQueue<T>::Tail()
+template <class T, class M>
+inline T const& CUtlQueue<T, M>::Tail() const
 {
-	m_current = m_heap[ m_heap.Count() - 1 ];
-	return m_current; 
+	Assert( m_tail != QUEUE_ITERATOR_INVALID );
+	if ( m_tail == QUEUE_ITERATOR_INVALID )
+	{
+		static T dummy;
+		return dummy;
+	}
+
+	return m_memory[ m_tail ];
 }
 
-template <class T>
-void CUtlQueue<T>::Insert( T const &element )
+template <class T, class M>
+void CUtlQueue<T, M>::Insert( T const &element )
 {
-	int index = m_heap.AddToTail();
-	m_heap[index] = element;
+	if ( m_tail == QUEUE_ITERATOR_INVALID )
+	{
+		// empty
+		m_memory.EnsureCapacity( 1 );
+		m_head = m_tail = QueueIter_t( 0 );
+	}
+	else
+	{
+		// non-empty
+		QueueIter_t nextTail = Next_Unchecked( m_tail );
+		if ( nextTail == m_head ) // if non-empty, and growing by 1 appears to make the queue of length 1, then we were already full before the Insert
+		{
+			int nOldAllocCount = m_memory.NumAllocated();
+			m_memory.Grow();
+			int nNewAllocCount = m_memory.NumAllocated();
+			int nGrowAmount = nNewAllocCount - nOldAllocCount;
+
+			nextTail = Next_Unchecked( m_tail ); // if nextTail was 0, then it now should be nOldAllocCount
+
+			if ( m_head != QueueIter_t( 0 ) )
+			{
+				// if the queue wraps around the end of m_memory, move the part at the end of memory to the new end of memory
+				Q_memmove( &m_memory[ m_head + nGrowAmount ], &m_memory[ m_head ], ( nOldAllocCount - m_head ) * sizeof( T ) );
+#ifdef _DEBUG
+				Q_memset( &m_memory[ m_head ], 0xdd, nGrowAmount * sizeof( T ) );
+#endif
+				m_head = QueueIter_t( m_head + nGrowAmount );
+			}
+		}
+		m_tail = nextTail;
+	}
+
+	CopyConstruct( &m_memory[ m_tail ], element );
 }
 
-template <class T>
-bool CUtlQueue<T>::Check( T const element )
+template <class T, class M>
+bool CUtlQueue<T, M>::Check( T const element ) const
 {
-	int index = m_heap.Find(element);
-	return ( index != -1 );
+	for ( QueueIter_t it = First(); it != QUEUE_ITERATOR_INVALID; it = Next( it ) )
+	{
+		if ( m_memory[ it ] == element )
+			return true;
+	}
+	return false;
+}
+
+template <class T, class M>
+QueueIter_t CUtlQueue<T, M>::First() const
+{
+	return m_head;
+}
+
+template <class T, class M>
+QueueIter_t CUtlQueue<T, M>::Next( QueueIter_t it ) const
+{
+	if ( it == QUEUE_ITERATOR_INVALID )
+		return QUEUE_ITERATOR_INVALID;
+
+	if ( it == m_tail )
+		return QUEUE_ITERATOR_INVALID;
+
+	Assert( IsValid( it ) );
+	if ( !IsValid( it ) )
+		return QUEUE_ITERATOR_INVALID;
+
+	return Next_Unchecked( it );
+}
+
+template <class T, class M>
+QueueIter_t CUtlQueue<T, M>::Last() const
+{
+	return m_tail;
+}
+
+template <class T, class M>
+QueueIter_t CUtlQueue<T, M>::Previous( QueueIter_t it ) const
+{
+	if ( it == QUEUE_ITERATOR_INVALID )
+		return QUEUE_ITERATOR_INVALID;
+
+	if ( it == m_head )
+		return QUEUE_ITERATOR_INVALID;
+
+	Assert( IsValid( it ) );
+	if ( !IsValid( it ) )
+		return QUEUE_ITERATOR_INVALID;
+
+	return Previous_Unchecked( it );
+}
+
+template <class T, class M>
+QueueIter_t CUtlQueue<T, M>::Next_Unchecked( QueueIter_t it ) const
+{
+	return it == m_memory.Count() - 1 ? QueueIter_t( 0 ) : QueueIter_t( it + 1 );
+}
+
+template <class T, class M>
+QueueIter_t CUtlQueue<T, M>::Previous_Unchecked( QueueIter_t it ) const
+{
+	return it == 0 ? QueueIter_t( m_memory.Count() - 1 ) : QueueIter_t( it - 1 );
+}
+
+template <class T, class M>
+bool CUtlQueue<T, M>::IsValid( QueueIter_t it ) const
+{
+	if ( it == QUEUE_ITERATOR_INVALID )
+		return false;
+
+	if ( m_head == QUEUE_ITERATOR_INVALID )
+		return false;
+
+	if ( m_head <= m_tail )
+		return it >= m_head && it <= m_tail;
+
+	return ( it >= m_head && it < m_memory.Count() ) || ( it >= 0 && it <= m_tail );
+}
+
+template <class T, class M>
+T const& CUtlQueue<T, M>::Element( QueueIter_t it ) const
+{
+	Assert( it != QUEUE_ITERATOR_INVALID );
+	if ( it == QUEUE_ITERATOR_INVALID )
+	{
+		static T dummy;
+		return dummy;
+	}
+
+	Assert( IsValid( it ) );
+	return m_memory[ it ];
+}
+
+template <class T, class M>
+int CUtlQueue<T, M>::Count() const
+{
+	if ( m_head == QUEUE_ITERATOR_INVALID )
+	{
+		Assert( m_tail == QUEUE_ITERATOR_INVALID );
+		return 0;
+	}
+	Assert( m_tail != QUEUE_ITERATOR_INVALID );
+
+	if ( m_head <= m_tail )
+		return m_tail + 1 - m_head;
+
+	return m_tail + 1 - m_head + m_memory.Count();
+}
+
+template <class T, class M>
+bool CUtlQueue<T, M>::IsEmpty() const
+{
+	Assert( ( m_head == QUEUE_ITERATOR_INVALID ) == ( m_tail == QUEUE_ITERATOR_INVALID ) );
+	return ( m_head == QUEUE_ITERATOR_INVALID );
+}
+
+template <class T, class M>
+void CUtlQueue<T, M>::RemoveAll()
+{
+	m_head = m_tail = QUEUE_ITERATOR_INVALID;
+}
+
+template <class T, class M>
+void CUtlQueue<T, M>::Purge()
+{
+	m_head = m_tail = QUEUE_ITERATOR_INVALID;
+	m_memory.Purge();
+}
+
+
+#ifdef TEST_UTLQUEUE
+
+#include <stdlib.h>
+
+struct Data_t
+{
+	Data_t( int i = 0xffffffff ) : m_id( i ) {}
+	Data_t( const Data_t &that ) : m_id( that.m_id ) {}
+	~Data_t() { m_id = 0xdddddddd; }
+	Data_t &operator=( const Data_t &that ) { m_id = that.m_id; return *this; }
+
+	int m_id;
+};
+
+inline void CUtlQueue_Test()
+{
+	CUtlQueue< Data_t > queue;
+
+	for ( int n = 1; n < 100; ++n )
+	{
+		Assert( queue.Count() == 0 );
+		Assert( queue.m_head == QUEUE_ITERATOR_INVALID );
+		Assert( queue.m_tail == QUEUE_ITERATOR_INVALID );
+
+		int w = rand() % n;
+		for ( int i = 0; i < w; ++i )
+		{
+			queue.Insert( Data_t( i ) );
+		}
+
+		if ( w > 0 )
+		{
+			Assert( queue.Head().m_id == queue.First() );
+			Assert( queue.Tail().m_id == queue.Last() );
+			Assert( queue.Head().m_id == 0 );
+			Assert( queue.Tail().m_id == w - 1 );
+		}
+		Assert( queue.Count() == w );
+
+		for ( int j = 0; j < n; ++j )
+		{
+			queue.Insert( Data_t( w + j ) );
+
+			if ( j == 0 )
+			{
+				Assert( queue.Count() == w + j + 1 );
+
+				for ( int i = 0; i < w; ++i )
+				{
+					queue.RemoveAtHead();
+				}
+			}
+
+			Assert( queue.Count() == j + 1 );
+
+			Assert( queue.m_head != QUEUE_ITERATOR_INVALID );
+			Assert( queue.m_tail != QUEUE_ITERATOR_INVALID );
+
+			int id = queue.Head().m_id % queue.m_memory.Count();
+			for ( QueueIter_t it = queue.First(); it != QUEUE_ITERATOR_INVALID; it = queue.Next( it ) )
+			{
+				Assert( queue.Element( it ).m_id % queue.m_memory.Count() == id );
+				id = ( id + 1 ) % queue.m_memory.Count();
+			}
+
+			id = queue.Tail().m_id % queue.m_memory.Count();
+			for ( QueueIter_t it = queue.Last(); it != QUEUE_ITERATOR_INVALID; it = queue.Previous( it ) )
+			{
+				Assert( queue.Element( it ).m_id % queue.m_memory.Count() == id );
+				id = ( id + queue.m_memory.Count() - 1 ) % queue.m_memory.Count();
+			}
+
+			for ( int i = 0; i < j; ++i )
+			{
+				int id = queue.m_memory[ i ].m_id;
+				if ( queue.IsValid( QueueIter_t( i ) ) )
+				{
+					Assert( ( id & 0xff000000 ) == 0 );
+				}
+				else
+				{
+					Assert( id == 0xdddddddd );
+				}
+			}
+		}
+
+		Assert( queue.Count() == n );
+#if 0
+		for ( int j = 0; j < n; ++j )
+		{
+			Assert( queue.m_head != QUEUE_ITERATOR_INVALID );
+			Assert( queue.m_tail != QUEUE_ITERATOR_INVALID );
+
+			Assert( queue.Count() == n - j );
+
+			Data_t data = queue.RemoveAtHead();
+
+			Assert( queue.Count() == n - j - 1 );
+
+			if ( queue.Count() > 0 )
+			{
+				int id = queue.Head().m_id % queue.m_memory.Count();
+				for ( QueueIter_t it = queue.First(); it != QUEUE_ITERATOR_INVALID; it = queue.Next( it ) )
+				{
+					Assert( queue.Element( it ).m_id % queue.m_memory.Count() == id );
+					id = ( id + 1 ) % queue.m_memory.Count();
+				}
+
+				id = queue.Tail().m_id % queue.m_memory.Count();
+				for ( QueueIter_t it = queue.Last(); it != QUEUE_ITERATOR_INVALID; it = queue.Previous( it ) )
+				{
+					Assert( queue.Element( it ).m_id % queue.m_memory.Count() == id );
+					id = ( id + queue.m_memory.Count() - 1 ) % queue.m_memory.Count();
+				}
+			}
+
+			for ( int i = 0; i < j; ++i )
+			{
+				int id = queue.m_memory[ i ].m_id;
+				if ( queue.IsValid( QueueIter_t( i ) ) )
+				{
+					Assert( ( id & 0xff000000 ) == 0 );
+				}
+				else
+				{
+					Assert( id == 0xdddddddd );
+				}
+			}
+		}
+#else
+		for ( int j = n - 1; j >= 0; --j )
+		{
+			Assert( queue.m_head != QUEUE_ITERATOR_INVALID );
+			Assert( queue.m_tail != QUEUE_ITERATOR_INVALID );
+
+			Assert( queue.Count() == j + 1 );
+
+			Data_t data = queue.RemoveAtTail();
+
+			Assert( queue.Count() == j );
+
+			if ( queue.Count() > 0 )
+			{
+				int id = queue.Head().m_id % queue.m_memory.Count();
+				for ( QueueIter_t it = queue.First(); it != QUEUE_ITERATOR_INVALID; it = queue.Next( it ) )
+				{
+					Assert( queue.Element( it ).m_id % queue.m_memory.Count() == id );
+					id = ( id + 1 ) % queue.m_memory.Count();
+				}
+
+				id = queue.Tail().m_id % queue.m_memory.Count();
+				for ( QueueIter_t it = queue.Last(); it != QUEUE_ITERATOR_INVALID; it = queue.Previous( it ) )
+				{
+					Assert( queue.Element( it ).m_id % queue.m_memory.Count() == id );
+					id = ( id + queue.m_memory.Count() - 1 ) % queue.m_memory.Count();
+				}
+			}
+
+			for ( int i = 0; i < j; ++i )
+			{
+				int id = queue.m_memory[ i ].m_id;
+				if ( queue.IsValid( QueueIter_t( i ) ) )
+				{
+					Assert( ( id & 0xff000000 ) == 0 );
+				}
+				else
+				{
+					Assert( id == 0xdddddddd );
+				}
+			}
+		}
+#endif
+
+		Assert( queue.Count() == 0 );
+		Assert( queue.m_head == QUEUE_ITERATOR_INVALID );
+		Assert( queue.m_tail == QUEUE_ITERATOR_INVALID );
+	}
 }
 
+#endif // TEST_UTLQUEUE
 
 #endif // UTLQUEUE_H
diff --git a/mp/src/public/tier1/utlrbtree.h b/mp/src/public/tier1/utlrbtree.h
index 273ee958..ded22bf5 100644
--- a/mp/src/public/tier1/utlrbtree.h
+++ b/mp/src/public/tier1/utlrbtree.h
@@ -1150,6 +1150,11 @@ void CUtlRBTree<T, I, L, M>::RemoveAll()
 
 	// Clear everything else out
 	m_Root = InvalidIndex(); 
+	// Technically, this iterator could become invalid. It will not, because it's 
+	// always the same iterator. If we don't clear this here, the state of this
+	// container will be invalid after we start inserting elements again.
+	m_LastAlloc = m_Elements.InvalidIterator();
+	m_FirstFree = InvalidIndex();
 	m_NumElements = 0;
 
 	Assert( IsValid() );
@@ -1163,9 +1168,7 @@ template < class T, class I, typename L, class M >
 void CUtlRBTree<T, I, L, M>::Purge()
 {
 	RemoveAll();
-	m_FirstFree = InvalidIndex();
 	m_Elements.Purge();
-	m_LastAlloc = m_Elements.InvalidIterator();
 }
 
 
diff --git a/mp/src/public/tier1/utlvector.h b/mp/src/public/tier1/utlvector.h
index 0ddf4ad0..7313bc99 100644
--- a/mp/src/public/tier1/utlvector.h
+++ b/mp/src/public/tier1/utlvector.h
@@ -23,6 +23,7 @@
 #include "tier1/utlmemory.h"
 #include "tier1/utlblockmemory.h"
 #include "tier1/strtools.h"
+#include "vstdlib/random.h"
 
 #define FOR_EACH_VEC( vecName, iteratorName ) \
 	for ( int iteratorName = 0; iteratorName < (vecName).Count(); iteratorName++ )
@@ -63,6 +64,8 @@ public:
 	const T& Head() const;
 	T& Tail();
 	const T& Tail() const;
+	T& Random();
+	const T& Random() const;
 
 	// STL compatible member functions. These allow easier use of std::sort
 	// and they are forward compatible with the C++ 11 range-based for loops.
@@ -159,6 +162,8 @@ public:
 
 	void Sort( int (__cdecl *pfnCompare)(const T *, const T *) );
 
+	void Shuffle( IUniformRandomStream* pSteam = NULL );
+
 #ifdef DBGFLAG_VALIDATE
 	void Validate( CValidator &validator, char *pchName );		// Validate our internal structures
 #endif // DBGFLAG_VALIDATE
@@ -677,6 +682,37 @@ inline int CUtlVector<T, A>::Size() const
 }
 
 template< typename T, class A >
+inline T& CUtlVector<T, A>::Random()
+{
+	Assert( m_Size > 0 );
+	return m_Memory[ RandomInt( 0, m_Size - 1 ) ];
+}
+
+template< typename T, class A >
+inline const T& CUtlVector<T, A>::Random() const
+{
+	Assert( m_Size > 0 );
+	return m_Memory[ RandomInt( 0, m_Size - 1 ) ];
+}
+
+
+//-----------------------------------------------------------------------------
+// Shuffle - Knuth/Fisher-Yates
+//-----------------------------------------------------------------------------
+template< typename T, class A >
+void CUtlVector<T, A>::Shuffle( IUniformRandomStream* pSteam )
+{
+	for ( int i = 0; i < m_Size; i++ )
+	{
+		int j = pSteam ? pSteam->RandomInt( i, m_Size - 1 ) : RandomInt( i, m_Size - 1 );
+		if ( i != j )
+		{
+			V_swap( m_Memory[ i ], m_Memory[ j ] );
+		}
+	}
+}
+
+template< typename T, class A >
 inline int CUtlVector<T, A>::Count() const
 {
 	return m_Size;
diff --git a/mp/src/public/tier2/p4helpers.h b/mp/src/public/tier2/p4helpers.h
index 8d4b3b3f..61c70c81 100644
--- a/mp/src/public/tier2/p4helpers.h
+++ b/mp/src/public/tier2/p4helpers.h
@@ -33,6 +33,9 @@ public:
 	// Opens the file for add
 	virtual bool Add( void );
 
+	// Reverts the file
+	virtual bool Revert( void );
+
 	// Is the file in perforce?
 	virtual bool IsFileInPerforce();
 
@@ -158,4 +161,19 @@ protected:
 };
 
 
+//
+// CP4AutoRevert - reverts the file upon construction
+//
+class CP4AutoRevertFile
+{
+public:
+	explicit CP4AutoRevertFile( char const *szFilename ) : m_spImpl( g_p4factory->AccessFile( szFilename ) ) { m_spImpl->Revert(); }
+
+	CP4File * File() const { return m_spImpl.Get(); }
+
+protected:
+	CPlainAutoPtr< CP4File > m_spImpl;
+};
+
+
 #endif // #ifndef P4HELPERS_H
diff --git a/mp/src/public/togl/glfuncs.inl b/mp/src/public/togl/glfuncs.inl
index 55a24f45..1f6b3b45 100644
--- a/mp/src/public/togl/glfuncs.inl
+++ b/mp/src/public/togl/glfuncs.inl
@@ -1,7 +1,2 @@
-#if defined(LINUX) || defined(_WIN32)
 #include "togl/linuxwin/glfuncs.h"
-#endif
-#if defined(OSX)
-#include "togl/osx/glfuncs.h"
-#endif
 
diff --git a/mp/src/public/togl/linuxwin/cglmbuffer.h b/mp/src/public/togl/linuxwin/cglmbuffer.h
index 45c99882..10782243 100644
--- a/mp/src/public/togl/linuxwin/cglmbuffer.h
+++ b/mp/src/public/togl/linuxwin/cglmbuffer.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 //
 // cglmprogram.h
 //	GLMgr buffers (index / vertex)
@@ -44,6 +66,51 @@ struct GLMBuffLockParams
 
 extern void glBufferSubDataMaxSize( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data, uint nMaxSizePerCall = 128 * 1024 );
 
+//===========================================================================//
+
+// Creates an immutable storage for a buffer object
+// https://www.opengl.org/registry/specs/ARB/buffer_storage.txt
+class CPersistentBuffer
+{
+public:
+
+	CPersistentBuffer();
+	~CPersistentBuffer();
+
+	void Init( EGLMBufferType type,uint nSize );
+	void Deinit();
+
+	void InsertFence();
+	void BlockUntilNotBusy();
+
+	void Append( uint nSize );
+
+	inline uint GetBytesRemaining() const { return m_nSize - m_nOffset; }
+	inline uint GetOffset() const { return m_nOffset; }
+	inline void *GetPtr() const { return m_pImmutablePersistentBuf; }
+	inline GLuint GetHandle() const { return m_nHandle; }
+
+private:
+
+	CPersistentBuffer( const CPersistentBuffer & );
+	CPersistentBuffer & operator= (const CPersistentBuffer &);
+
+	uint			m_nSize;
+
+	EGLMBufferType	m_type;
+	GLenum			m_buffGLTarget;			// GL_ARRAY_BUFFER_ARB / GL_ELEMENT_BUFFER_ARB	
+	GLuint			m_nHandle;				// handle of this program in the GL context
+
+	// Holds a pointer to the persistently mapped buffer
+	void*			m_pImmutablePersistentBuf;
+
+	uint			m_nOffset;
+
+#ifdef HAVE_GL_ARB_SYNC
+	GLsync			m_nSyncObj;
+#endif
+};
+
 //===============================================================================
 
 #if GL_ENABLE_INDEX_VERIFICATION
@@ -92,7 +159,7 @@ public:
 	void DiscardAllSpans();
 		
 	bool IsValid( uint nOffset, uint nSize ) const;
-		
+
 private:
 	bool AllocDynamicBuf( uint nSize, GLDynamicBuf_t &buf );
 	void ReleaseDynamicBuf( GLDynamicBuf_t &buf );
@@ -120,6 +187,8 @@ class CGLMBuffer
 public:
 	void Lock( GLMBuffLockParams *pParams, char **pAddressOut );
 	void Unlock( int nActualSize = -1, const void *pActualData = NULL );
+
+	GLuint GetHandle() const;
 		
 	friend class GLMContext;			// only GLMContext can make CGLMBuffer objects
 	friend class GLMTester;	
@@ -159,6 +228,9 @@ public:
 	float					*m_pLastMappedAddress;
 
 	int						m_nPinnedMemoryOfs;
+
+	uint					m_nPersistentBufferStartOffset;
+	bool					m_bUsingPersistentBuffer;
 	
 	bool					m_bPseudo;				// true if the m_name is 0, and the backing is plain RAM
 			
diff --git a/mp/src/public/togl/linuxwin/cglmfbo.h b/mp/src/public/togl/linuxwin/cglmfbo.h
index 0cfd4226..93ebb11f 100644
--- a/mp/src/public/togl/linuxwin/cglmfbo.h
+++ b/mp/src/public/togl/linuxwin/cglmfbo.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 //
 // cglmfbo.h
 //	GLMgr FBO's (render targets)
diff --git a/mp/src/public/togl/linuxwin/cglmprogram.h b/mp/src/public/togl/linuxwin/cglmprogram.h
index 8fa09fa2..e3f4f60a 100644
--- a/mp/src/public/togl/linuxwin/cglmprogram.h
+++ b/mp/src/public/togl/linuxwin/cglmprogram.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 //
 // cglmprogram.h
 //	GLMgr programs (ARBVP/ARBfp)
@@ -110,8 +132,8 @@ public:
 	void	SetProgramText			( char *text );				// import text to GLM object - invalidate any prev compiled program
 	void	SetShaderName			( const char *name );				// only used for debugging/telemetry markup
 	
-	bool	CompileActiveSources	( void );					// compile only the flavors that were provided.
-	bool	Compile					( EGLMProgramLang lang );	
+	void	CompileActiveSources	( void );					// compile only the flavors that were provided.
+	void	Compile					( EGLMProgramLang lang );	
 	bool	CheckValidity			( EGLMProgramLang lang );
 
 	void	LogSlow					( EGLMProgramLang lang );	// detailed spew when called for first time; one liner or perhaps silence after that
@@ -145,6 +167,9 @@ public:
 
 	uint					m_samplerMask;			// (1<<n) mask of sampler active locs, if this is a fragment shader (dxabstract sets this field)
 	uint					m_samplerTypes;			// SAMPLER_2D, etc.
+	uint					m_fragDataMask;			// (1<<n) mask of gl_FragData[n] outputs referenced, if this is a fragment shader (dxabstract sets this field)
+	uint					m_numDrawBuffers;		// number of draw buffers used
+	GLenum					m_drawBuffers[4];		// GL_COLOR_ATTACHMENT0_EXT1, etc
 	uint					m_nNumUsedSamplers;
 	uint					m_maxSamplers;
 	uint					m_maxVertexAttrs;
@@ -154,6 +179,13 @@ public:
 	bool					m_bTranslatedProgram;
 
 	char					m_shaderName[64];
+
+	// Cache label string from the shader text
+	// example:
+	// trans#2871 label:vs-file vertexlit_and_unlit_generic_vs20 vs-index 294912 vs-combo 1234
+	char					m_labelName[1024];
+	int						m_labelIndex;
+	int						m_labelCombo;
 };	
 
 //===============================================================================
@@ -188,10 +220,15 @@ public:
 
 	bool	SetProgramPair			( CGLMProgram *vp, CGLMProgram *fp );
 		// true result means successful link and query
+		// Note that checking the link status and querying the uniform can be optionally
+		// deferred to take advantage of multi-threaded compilation in the driver
 
 	bool	RefreshProgramPair		( void );
 		// re-link and re-query the uniforms
 
+	bool	ValidateProgramPair( void );
+		// true result means successful link and query
+
 	FORCEINLINE void UpdateScreenUniform( uint nWidthHeight )
 	{
 		if ( m_nScreenWidthHeight == nWidthHeight )
@@ -199,10 +236,10 @@ public:
 		
 		m_nScreenWidthHeight = nWidthHeight;
 
-		uint nWidth = nWidthHeight & 0xFFFF, nHeight = nWidthHeight >> 16;
+		float fWidth = (float)( nWidthHeight & 0xFFFF ), fHeight = (float)( nWidthHeight >> 16 );
 		// Apply half pixel offset to output vertices to account for the pixel center difference between D3D9 and OpenGL.
 		// We output vertices in clip space, which ranges from [-1,1], so 1.0/width in clip space transforms into .5/width in screenspace, see: "Viewports and Clipping (Direct3D 9)" in the DXSDK
-		float v[4] = { 1.0f / (float)nWidth, 1.0f / (float)nHeight, (float)nWidth, (float)nHeight };
+		float v[4] = { 1.0f / fWidth, 1.0f / fHeight, fWidth, fHeight };
 		if ( m_locVertexScreenParams >= 0 )
 			gGL->glUniform4fv( m_locVertexScreenParams, 1, v );
 	}
@@ -227,10 +264,10 @@ public:
 	GLint					m_locVertexBoneParams;	// "vcbones"
 	GLint					m_locVertexInteger0;	// "i0"
 			
-	GLint					m_locVertexBool0;		// "b0"
-	GLint					m_locVertexBool1;		// "b1"
-	GLint					m_locVertexBool2;		// "b2"
-	GLint					m_locVertexBool3;		// "b3"
+	enum { cMaxVertexShaderBoolUniforms = 4, cMaxFragmentShaderBoolUniforms = 1 };
+
+	GLint					m_locVertexBool[cMaxVertexShaderBoolUniforms];		// "b0", etc.
+	GLint					m_locFragmentBool[cMaxFragmentShaderBoolUniforms];		// "fb0", etc.
 	bool					m_bHasBoolOrIntUniforms;
 			
 	// fragment stage uniforms
@@ -243,10 +280,11 @@ public:
 	float					m_fakeSRGBEnableValue;			// shadow to avoid redundant sets of the m_locFragmentFakeSRGBEnable uniform
 		// init it to -1.0 at link or relink, so it will trip on any legit incoming value (0.0 or 1.0)
 
-	GLint					m_locSamplers[ 16 ];			// "sampler0 ... sampler1..."
+	GLint					m_locSamplers[ GLM_SAMPLER_COUNT ];			// "sampler0 ... sampler1..."
 
 	// other stuff
 	bool					m_valid;				// true on successful link
+	bool					m_bCheckLinkStatus;
 	uint					m_revision;				// if this pair is relinked, bump this number.
 
 	GLint					m_locVertexScreenParams; // vcscreen
diff --git a/mp/src/public/togl/linuxwin/cglmquery.h b/mp/src/public/togl/linuxwin/cglmquery.h
index ff1ccfe9..168e3f7c 100644
--- a/mp/src/public/togl/linuxwin/cglmquery.h
+++ b/mp/src/public/togl/linuxwin/cglmquery.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 //
 // cglmquery.h
 //	GLMgr queries
@@ -10,10 +32,6 @@
 
 #pragma once
 
-#ifdef OSX
-#include "glmgr/glmgrbasics.h"
-#endif
-
 //===============================================================================
 
 // forward declarations
diff --git a/mp/src/public/togl/linuxwin/cglmtex.h b/mp/src/public/togl/linuxwin/cglmtex.h
index cafdd1c7..90870a7f 100644
--- a/mp/src/public/togl/linuxwin/cglmtex.h
+++ b/mp/src/public/togl/linuxwin/cglmtex.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 //
 // cglmtex.h
 //	GLMgr textures
@@ -11,7 +33,7 @@
 #pragma once
 
 #ifdef OSX
-#include "glmgr/glmgrbasics.h"
+#include "glmgrbasics.h"
 #endif
 #include "tier1/utlhash.h"
 #include "tier1/utlmap.h"
@@ -199,6 +221,8 @@ struct GLMTexLockDesc
 
 #define	GLM_SAMPLER_COUNT	16
 
+#define GLM_MAX_PIXEL_TEX_SAMPLERS	16
+#define GLM_MAX_VERTEX_TEX_SAMPLERS	0
 typedef CBitVec<GLM_SAMPLER_COUNT> CTexBindMask;
 
 enum EGLMTexSliceFlag
@@ -263,9 +287,11 @@ struct GLMTexSamplingParams
 		m_packed.m_magFilter = D3DTEXF_POINT;
 		m_packed.m_mipFilter = D3DTEXF_NONE;
 		m_packed.m_maxAniso = 1;
+		m_packed.m_compareMode = 0;
 		m_packed.m_isValid = true;
 	}
 
+#ifndef OSX
 	FORCEINLINE void SetToSamplerObject( GLuint nSamplerObject ) const
 	{
 		static const GLenum dxtogl_addressMode[] = { GL_REPEAT, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER, (GLenum)-1 };
@@ -305,6 +331,7 @@ struct GLMTexSamplingParams
 			gGL->glSamplerParameteri( nSamplerObject, GL_TEXTURE_SRGB_DECODE_EXT, m_packed.m_srgb ? GL_DECODE_EXT : GL_SKIP_DECODE_EXT );
 		}
 	}
+#endif // !OSX
 
 	inline void DeltaSetToTarget( GLenum target, const GLMTexSamplingParams &curState )
 	{
@@ -377,7 +404,7 @@ struct GLMTexSamplingParams
 		}
 	}
 
-	inline void SetToTargetTexture( GLenum target )
+	inline void SetToTarget( GLenum target )
 	{
 		static const GLenum dxtogl_addressMode[] = { GL_REPEAT, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER, (GLenum)-1 };
 		static const GLenum dxtogl_magFilter[4] = { GL_NEAREST,	GL_NEAREST,	GL_LINEAR, GL_LINEAR };
@@ -427,6 +454,7 @@ public:
 
 	void					Lock( GLMTexLockParams *params, char** addressOut, int* yStrideOut, int *zStrideOut );
 	void					Unlock( GLMTexLockParams *params );
+	GLuint                                  GetTexName() { return m_texName; }
 	
 protected:
 	friend class GLMContext;			// only GLMContext can make CGLMTex objects
@@ -440,7 +468,7 @@ protected:
 	friend struct IDirect3DCubeTexture9;
 	friend struct IDirect3DVolumeTexture9;
 	
-			CGLMTex( GLMContext *ctx, GLMTexLayout *layout, const char *debugLabel = NULL );
+			CGLMTex( GLMContext *ctx, GLMTexLayout *layout, uint levels, const char *debugLabel = NULL );
 			~CGLMTex( );
 	
 	int						CalcSliceIndex( int face, int mip );
@@ -450,13 +478,17 @@ protected:
 	void					WriteTexels( GLMTexLockDesc *desc, bool writeWholeSlice=true, bool noDataWrite=false );
 		// last param lets us send NULL data ptr (only legal with uncompressed formats, beware)
 		// this helps out ResetSRGB.
+
+#if defined( OSX )
+	void					HandleSRGBMismatch( bool srgb, int &srgbFlipCount );
+	void					ResetSRGB( bool srgb, bool noDataWrite );
+	// re-specify texture format to match desired sRGB form
+	// noWrite means send NULL for texel source addresses instead of actual data - ideal for RT's
+#endif
 				
 	bool					IsRBODirty() const;
 	void					ForceRBONonDirty();
 	void					ForceRBODirty();
-	
-	void					AllocBacking();
-	void					ReleaseBacking();
 			
 		// re-specify texture format to match desired sRGB form
 		// noWrite means send NULL for texel source addresses instead of actual data - ideal for RT's
@@ -464,25 +496,26 @@ protected:
 	GLuint					m_texName;			// name of this texture in the context
 	GLenum					m_texGLTarget;
 	uint					m_nSamplerType;		// SAMPLER_2D, etc.
+	
 	GLMTexSamplingParams	m_SamplingParams;
+
 	GLMTexLayout			*m_layout;		// layout of texture (shared across all tex with same layout)
 	
 	uint					m_nLastResolvedBatchCounter;
 					
 	int						m_minActiveMip;//index of lowest mip that has been written.  used to drive setting of GL_TEXTURE_MAX_LEVEL.
 	int						m_maxActiveMip;//index of highest mip that has been written.  used to drive setting of GL_TEXTURE_MAX_LEVEL.
-	int						m_mipCount;
 						
 	GLMContext				*m_ctx;			// link back to parent context
 		
+	
 	CGLMFBO                 *m_pBlitSrcFBO;
 	CGLMFBO                 *m_pBlitDstFBO;
-	
 	GLuint					m_rboName;		// name of MSAA RBO backing the tex if MSAA enabled (or zero)
 													
 	int						m_rtAttachCount; // how many RT's have this texture attached somewhere
 
-	char					*m_pBacking;		// backing storage if available
+	char					*m_backing;		// backing storage if available
 	
 	int						m_lockCount;	// lock reqs are stored in the GLMContext for tracking
 
@@ -493,6 +526,7 @@ protected:
 	bool					m_texClientStorage;	// was CS selected for texture
 	bool					m_texPreloaded;		// has it been kicked into VRAM with GLMContext::PreloadTex yet
 
+	int						m_srgbFlipCount;
 #if GLMDEBUG
 	CGLMTex					*m_pPrevTex;
 	CGLMTex					*m_pNextTex;
diff --git a/mp/src/public/togl/linuxwin/dxabstract.h b/mp/src/public/togl/linuxwin/dxabstract.h
index 0e367329..b601e78d 100644
--- a/mp/src/public/togl/linuxwin/dxabstract.h
+++ b/mp/src/public/togl/linuxwin/dxabstract.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 //
 // dxabstract.h
 //
@@ -18,8 +40,10 @@
 #define	IUNKNOWN_ALLOC_SPEW 0
 #define	IUNKNOWN_ALLOC_SPEW_MARK_ALL 0	
 
+
 TOGL_INTERFACE void toglGetClientRect( VD3DHWND hWnd, RECT *destRect );
 
+
 struct TOGL_CLASS IUnknown
 {
 	int	m_refcount[2];
@@ -138,7 +162,6 @@ struct TOGL_CLASS IDirect3DBaseTexture9 : public IDirect3DResource9						// "A T
 {
 	D3DSURFACE_DESC			m_descZero;			// desc of top level.
 	CGLMTex					*m_tex;				// a CGLMTex can represent all forms of tex
-	int						m_srgbFlipCount;
 
 	virtual					~IDirect3DBaseTexture9();
 	D3DRESOURCETYPE	TOGLMETHODCALLTYPE GetType();
@@ -270,7 +293,8 @@ struct TOGL_CLASS IDirect3DPixelShader9 : public IDirect3DResource9	//was IUnkno
 	uint					m_pixHighWater;		// count of active constant slots referenced by shader.
 	uint					m_pixSamplerMask;	// (1<<n) mask of samplers referemnced by this pixel shader
 												// this can help FlushSamplers avoid SRGB flipping on textures not being referenced...
-	uint					m_pixSamplerTypes; // SAMPLER_TYPE_2D, etc.
+	uint					m_pixSamplerTypes;  // SAMPLER_TYPE_2D, etc.
+	uint					m_pixFragDataMask;  // (1<<n) mask of gl_FragData[n] referenced by this pixel shader
 	
 	virtual					~IDirect3DPixelShader9();
 };
@@ -404,6 +428,7 @@ struct TOGL_CLASS IDirect3DDevice9 : public IUnknown
 	//
 	HRESULT TOGLMETHODCALLTYPE Reset(D3DPRESENT_PARAMETERS* pPresentationParameters);
 	HRESULT TOGLMETHODCALLTYPE SetViewport(CONST D3DVIEWPORT9* pViewport);
+	HRESULT TOGLMETHODCALLTYPE GetViewport(D3DVIEWPORT9* pViewport);
     HRESULT TOGLMETHODCALLTYPE BeginScene();
 	HRESULT TOGLMETHODCALLTYPE Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil);
     HRESULT TOGLMETHODCALLTYPE EndScene();
@@ -463,6 +488,7 @@ struct TOGL_CLASS IDirect3DDevice9 : public IUnknown
 
 	// POSIX only - preheating for a specific vertex/pixel shader pair - trigger GLSL link inside GLM
 	HRESULT TOGLMETHODCALLTYPE LinkShaderPair( IDirect3DVertexShader9* vs, IDirect3DPixelShader9* ps );
+	HRESULT TOGLMETHODCALLTYPE ValidateShaderPair( IDirect3DVertexShader9* vs, IDirect3DPixelShader9* ps );
 	HRESULT TOGLMETHODCALLTYPE QueryShaderPair( int index, GLMShaderPairInfo *infoOut );
 	
 	// vertex buffers
@@ -484,7 +510,7 @@ struct TOGL_CLASS IDirect3DDevice9 : public IUnknown
     
 	FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetIndices(IDirect3DIndexBuffer9* pIndexData);
 	HRESULT TOGLMETHODCALLTYPE SetIndicesNonInline(IDirect3DIndexBuffer9* pIndexData);
-			
+
 	// State management.
     FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetRenderStateInline(D3DRENDERSTATETYPE State,DWORD Value);
 	FORCEINLINE HRESULT TOGLMETHODCALLTYPE SetRenderStateConstInline(D3DRENDERSTATETYPE State,DWORD Value);
@@ -495,7 +521,13 @@ struct TOGL_CLASS IDirect3DDevice9 : public IUnknown
 
 	FORCEINLINE void TOGLMETHODCALLTYPE SetSamplerStates(DWORD Sampler, DWORD AddressU, DWORD AddressV, DWORD AddressW, DWORD MinFilter, DWORD MagFilter, DWORD MipFilter );
 	void TOGLMETHODCALLTYPE SetSamplerStatesNonInline(DWORD Sampler, DWORD AddressU, DWORD AddressV, DWORD AddressW, DWORD MinFilter, DWORD MagFilter, DWORD MipFilter );
-					
+			
+#ifdef OSX
+	// required for 10.6 support
+	HRESULT TOGLMETHODCALLTYPE FlushIndexBindings(void);		// push index buffer (set index ptr)
+	HRESULT	TOGLMETHODCALLTYPE FlushVertexBindings(uint baseVertexIndex);	// push vertex streams (set attrib ptrs)
+#endif
+
 	// Draw.
     HRESULT TOGLMETHODCALLTYPE DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount);
     HRESULT TOGLMETHODCALLTYPE DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount);
@@ -514,6 +546,7 @@ struct TOGL_CLASS IDirect3DDevice9 : public IUnknown
     HRESULT TOGLMETHODCALLTYPE SetLight(DWORD Index,CONST D3DLIGHT9*);
     void TOGLMETHODCALLTYPE SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp);
 	
+
 	void TOGLMETHODCALLTYPE SaveGLState();
 	void TOGLMETHODCALLTYPE RestoreGLState();
 
@@ -544,7 +577,6 @@ struct TOGL_CLASS IDirect3DDevice9 : public IUnknown
 private:
 	IDirect3DDevice9( const IDirect3DDevice9& );
 	IDirect3DDevice9& operator= ( const IDirect3DDevice9& );
-
 	// Flushing changes to GL
 	void FlushClipPlaneEquation();
 	void InitStates();
@@ -567,8 +599,9 @@ private:
 	// Member variables
 
 	DWORD						m_nValidMarker;
-
-	IDirect3DDevice9Params		m_params;						// mirror of the creation inputs
+public:
+	IDirect3DDevice9Params	m_params;						// mirror of the creation inputs
+private:
 
 	// D3D flavor stuff
 	IDirect3DSurface9			*m_pRenderTargets[4];
@@ -586,8 +619,8 @@ private:
 	IDirect3DVertexShader9		*m_vertexShader;				// Set by SetVertexShader...
 	IDirect3DPixelShader9		*m_pixelShader;					// Set by SetPixelShader...
 
-	IDirect3DBaseTexture9		*m_textures[16];				// set by SetTexture... NULL if stage inactive
-	D3DSamplerDesc				m_samplers[16];					// set by SetSamplerState..
+	IDirect3DBaseTexture9		*m_textures[GLM_SAMPLER_COUNT];				// set by SetTexture... NULL if stage inactive
+	
 	// GLM flavor stuff
 	GLMContext					*m_ctx;
 	CGLMFBOMap					*m_pFBOs;
@@ -673,7 +706,7 @@ private:
 		bool						m_FogEnable;			// not really pushed to GL, just latched here
 
 		// samplers
-		GLMTexSamplingParams		m_samplers[ 16 ];
+		//GLMTexSamplingParams		m_samplers[GLM_SAMPLER_COUNT];
 	} gl;
 	
 #if GL_BATCH_PERF_ANALYSIS
@@ -710,7 +743,7 @@ FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetSamplerState( DWORD
 	return SetSamplerStateNonInline( Sampler, Type, Value );
 #else
 	Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
-	Assert( Sampler < 16 );
+	Assert( Sampler < GLM_SAMPLER_COUNT );
 	
 	m_ctx->SetSamplerDirty( Sampler );
 
@@ -747,7 +780,7 @@ FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetSamplerState( DWORD
 			m_ctx->SetSamplerMaxAnisotropy( Sampler, Value);
 			break;
 		case D3DSAMP_SRGBTEXTURE: 
-			m_samplers[ Sampler ].m_srgb = Value;
+			//m_samplers[ Sampler ].m_srgb = Value;
 			m_ctx->SetSamplerSRGBTexture(Sampler, Value);
 			break;
 		case D3DSAMP_SHADOWFILTER: 
@@ -768,7 +801,7 @@ FORCEINLINE void TOGLMETHODCALLTYPE IDirect3DDevice9::SetSamplerStates(
 	SetSamplerStatesNonInline( Sampler, AddressU, AddressV, AddressW, MinFilter, MagFilter, MipFilter );
 #else
 	Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
-	Assert( Sampler < 16);
+	Assert( Sampler < GLM_SAMPLER_COUNT);
 		
 	m_ctx->SetSamplerDirty( Sampler );
 		
@@ -782,6 +815,7 @@ FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetTexture(DWORD Stage,
 	return SetTextureNonInline( Stage, pTexture );
 #else
 	Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
+	Assert( Stage < GLM_SAMPLER_COUNT );
 	m_textures[Stage] = pTexture;
 	m_ctx->SetSamplerTex( Stage, pTexture ? pTexture->m_tex : NULL );
 	return S_OK;
@@ -809,13 +843,10 @@ FORCEINLINE GLenum D3DBlendOperationToGL( DWORD operation )
 	switch (operation)
 	{
 		case	D3DBLENDOP_ADD			: return GL_FUNC_ADD;				// The result is the destination added to the source. Result = Source + Destination
-
-		/* not covered by dxabstract.h..
-			case	D3DBLENDOP_SUBTRACT		: return GL_FUNC_SUBTRACT;			// The result is the destination subtracted from to the source. Result = Source - Destination
-			case	D3DBLENDOP_REVSUBTRACT	: return GL_FUNC_REVERSE_SUBTRACT;	// The result is the source subtracted from the destination. Result = Destination - Source
-			case	D3DBLENDOP_MIN			: return GL_MIN;					// The result is the minimum of the source and destination. Result = MIN(Source, Destination)
-			case	D3DBLENDOP_MAX			: return GL_MAX;					// The result is the maximum of the source and destination. Result = MAX(Source, Destination)
-		*/
+		case	D3DBLENDOP_SUBTRACT		: return GL_FUNC_SUBTRACT;			// The result is the destination subtracted from to the source. Result = Source - Destination
+		case	D3DBLENDOP_REVSUBTRACT	: return GL_FUNC_REVERSE_SUBTRACT;	// The result is the source subtracted from the destination. Result = Destination - Source
+		case	D3DBLENDOP_MIN			: return GL_MIN;					// The result is the minimum of the source and destination. Result = MIN(Source, Destination)
+		case	D3DBLENDOP_MAX			: return GL_MAX;					// The result is the maximum of the source and destination. Result = MAX(Source, Destination)
 		default:
 			DXABSTRACT_BREAK_ON_ERROR();
 			return 0xFFFFFFFF;
@@ -1174,7 +1205,7 @@ FORCEINLINE HRESULT TOGLMETHODCALLTYPE IDirect3DDevice9::SetStreamSource(UINT St
 	// OK, we are being given the stride, we don't need to calc it..
 
 	GLMPRINTF(("-X- IDirect3DDevice9::SetStreamSource setting stream #%d to D3D buf %p (GL name %d); offset %d, stride %d", StreamNumber, pStreamData, (pStreamData) ? pStreamData->m_vtxBuffer->m_name: -1, OffsetInBytes, Stride));
-		
+	
 	if ( !pStreamData )
 	{
 		OffsetInBytes = 0;
diff --git a/mp/src/public/togl/linuxwin/dxabstract_types.h b/mp/src/public/togl/linuxwin/dxabstract_types.h
index 5f2ccba3..9713ec71 100644
--- a/mp/src/public/togl/linuxwin/dxabstract_types.h
+++ b/mp/src/public/togl/linuxwin/dxabstract_types.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 //
 // dxabstract_types.h
 //
@@ -50,10 +72,6 @@ class CGLMFBO;
 	#define TOGL_GLOBAL		DLL_GLOBAL_IMPORT
 #endif
 
-#ifdef OSX
-#error "Do not use this header's types on OSX until togo is ported to Mac!"
-#endif
-
 #define TOGLMETHODCALLTYPE       __stdcall
 //#define TOGLMETHODCALLTYPE
 
@@ -176,6 +194,25 @@ typedef enum _D3DFORMAT D3DFORMAT;
 #define D3DSP_OPCODESPECIFICCONTROL_MASK 0x00ff0000
 #define D3DSP_OPCODESPECIFICCONTROL_SHIFT 16
 
+// Comparison for dynamic conditional instruction opcodes (i.e. if, breakc)
+typedef enum _D3DSHADER_COMPARISON
+{
+	// < = >
+	D3DSPC_RESERVED0= 0, // 0 0 0
+	D3DSPC_GT       = 1, // 0 0 1
+	D3DSPC_EQ       = 2, // 0 1 0
+	D3DSPC_GE       = 3, // 0 1 1
+	D3DSPC_LT       = 4, // 1 0 0
+	D3DSPC_NE       = 5, // 1 0 1
+	D3DSPC_LE       = 6, // 1 1 0
+	D3DSPC_RESERVED1= 7  // 1 1 1
+} D3DSHADER_COMPARISON;
+
+
+// Comparison is part of instruction opcode token:
+#define D3DSHADER_COMPARISON_SHIFT D3DSP_OPCODESPECIFICCONTROL_SHIFT
+#define D3DSHADER_COMPARISON_MASK  (0x7<<D3DSHADER_COMPARISON_SHIFT)
+
 
 /* Flags to construct D3DRS_COLORWRITEENABLE */
 #define D3DCOLORWRITEENABLE_RED     (1L<<0)
@@ -1004,12 +1041,7 @@ typedef enum _D3DSHADER_PARAM_REGISTER_TYPE
     D3DSPR_FORCE_DWORD  = 0x7fffffff,         // force 32-bit size enum
 } D3DSHADER_PARAM_REGISTER_TYPE;
 
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4201) // warning C4201: nonstandard extension used : nameless struct/union
-#endif
-
-typedef struct _D3DMATRIX 
+struct D3DMATRIX 
 {
     union 
 	{
@@ -1021,12 +1053,15 @@ typedef struct _D3DMATRIX
             float        _41, _42, _43, _44;
         };
         float m[4][4];
+
     };
-} D3DMATRIX;
 
-#ifdef _MSC_VER
-#pragma warning(pop)
+#if defined( WIN32 )
+	operator void* ();
+	bool operator == ( CONST D3DMATRIX& src ) const;
 #endif
+};
+
 
 typedef struct _D3DVERTEXBUFFER_DESC
 {
@@ -1047,6 +1082,7 @@ public:
 	operator FLOAT* ();
 	float& operator()( int row, int column );
 	const float& operator()( int row, int column ) const;
+	bool operator != ( CONST D3DXMATRIX& src ) const;
 };
 
 typedef DWORD D3DCOLOR;
@@ -1681,7 +1717,7 @@ struct IDirect3DDevice9Params
 	D3DPRESENT_PARAMETERS	m_presentationParameters;
 };
 
-#define	D3D_MAX_STREAMS	4
+#define	D3D_MAX_STREAMS	5 //9
 struct D3DStreamDesc
 {
 	IDirect3DVertexBuffer9	*m_vtxBuffer;
diff --git a/mp/src/public/togl/linuxwin/glbase.h b/mp/src/public/togl/linuxwin/glbase.h
index d2d5a219..9c830e6d 100644
--- a/mp/src/public/togl/linuxwin/glbase.h
+++ b/mp/src/public/togl/linuxwin/glbase.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 //
 // glbase.h
 //
@@ -12,23 +34,16 @@
 #undef HAVE_GL_ARB_SYNC
 
 #ifndef OSX
-	#define HAVE_GL_ARB_SYNC 1
+#define HAVE_GL_ARB_SYNC 1
+#endif
+
+#ifdef USE_SDL
+#include "SDL_opengl.h"
 #endif
 
 #ifdef OSX
-	#include <OpenGL/OpenGL.h>
-	#include <OpenGL/gl.h>
-	#include <OpenGL/glext.h>
-	#include <OpenGL/CGLTypes.h>
-	#include <OpenGL/CGLRenderers.h>
-	#include <OpenGL/CGLCurrent.h>
-	#include <OpenGL/CGLProfiler.h>
-	#include <ApplicationServices/ApplicationServices.h>
-#elif defined(DX_TO_GL_ABSTRACTION)
-	#include <GL/gl.h>
-	#include <GL/glext.h>
-#else
-	#error
+#include <OpenGL/CGLCurrent.h>
+#include <ApplicationServices/ApplicationServices.h>
 #endif
 
 #ifdef DX_TO_GL_ABSTRACTION
@@ -37,20 +52,18 @@
 	#endif
 	#undef CurrentTime
 
-	// prevent some conflicts in SDL headers...
-	#undef M_PI
-	#include <stdint.h>
-	#ifndef _STDINT_H_
-	#define _STDINT_H_ 1
+	#if defined( USE_SDL )
+		#include "SDL.h"
 	#endif
 #endif
 
 //===============================================================================
 // glue to call out to Obj-C land (these are in glmgrcocoa.mm)
 #ifdef OSX
-	bool			NewNSGLContext( unsigned long *attribs, PseudoNSGLContextPtr nsglShareCtx, PseudoNSGLContextPtr *nsglCtxOut, CGLContextObj *cglCtxOut );
+	typedef void _PseudoNSGLContext;					// aka NSOpenGLContext
+	typedef _PseudoNSGLContext	*PseudoNSGLContextPtr;
+	
 	CGLContextObj	GetCGLContextFromNSGL( PseudoNSGLContextPtr nsglCtx );
-	void			DelNSGLContext( PseudoNSGLContextPtr nsglCtx );
 #endif
 
 // Set TOGL_SUPPORT_NULL_DEVICE to 1 to support the NULL ref device
diff --git a/mp/src/public/togl/linuxwin/glentrypoints.h b/mp/src/public/togl/linuxwin/glentrypoints.h
index cff42928..9b55c00a 100644
--- a/mp/src/public/togl/linuxwin/glentrypoints.h
+++ b/mp/src/public/togl/linuxwin/glentrypoints.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 //
 // glentrypoints.h
 //
@@ -12,10 +34,8 @@
 #ifdef DX_TO_GL_ABSTRACTION
 
 #include "tier0/platform.h"
-#include "tier0/dynfunction.h"
 #include "tier0/vprof_telemetry.h"
 #include "interface.h"
-
 #include "togl/rendermechanism.h"
 
 void *VoidFnPtrLookup_GlMgr(const char *fn, bool &okay, const bool bRequired, void *fallback=NULL);
@@ -277,7 +297,6 @@ public:
 	~COpenGLEntryPoints();
 
 	void ClearEntryPoints();
-
 	uint64 m_nTotalGLCycles, m_nTotalGLCalls;
 
 	int m_nOpenGLVersionMajor;  // if GL_VERSION is 2.1.0, this will be set to 2.
@@ -288,20 +307,26 @@ public:
 	char *m_pGLDriverStrings[cGLTotalDriverStrings];
 	GLDriverProvider_t m_nDriverProvider;		
 
-	#define GL_EXT(x,glmajor,glminor) bool m_bHave_##x;
-	#define GL_FUNC(ext,req,ret,fn,arg,call) CDynamicFunctionOpenGL< req, ret (APIENTRY *) arg, ret > fn;
-	#define GL_FUNC_VOID(ext,req,fn,arg,call) CDynamicFunctionOpenGL< req, void (APIENTRY *) arg, void > fn;
+#ifdef OSX
+#define GL_EXT(x,glmajor,glminor) bool m_bHave_##x;
+#define GL_FUNC(ext,req,ret,fn,arg,call) CDynamicFunctionOpenGL< req, ret (*) arg, ret > fn;
+#define GL_FUNC_VOID(ext,req,fn,arg,call) CDynamicFunctionOpenGL< req, void (*) arg, void > fn;
+#else
+#define GL_EXT(x,glmajor,glminor) bool m_bHave_##x;
+#define GL_FUNC(ext,req,ret,fn,arg,call) CDynamicFunctionOpenGL< req, ret (APIENTRY *) arg, ret > fn;
+#define GL_FUNC_VOID(ext,req,fn,arg,call) CDynamicFunctionOpenGL< req, void (APIENTRY *) arg, void > fn;
+#endif
 	#include "togl/glfuncs.inl"
 	#undef GL_FUNC_VOID
 	#undef GL_FUNC
 	#undef GL_EXT
-		
+
 	bool HasSwapTearExtension() const
 	{
 #ifdef _WIN32
-		return m_bHave_WGL_EXT_swap_control_tear;
+	return m_bHave_WGL_EXT_swap_control_tear;
 #else
-		return m_bHave_GLX_EXT_swap_control_tear;
+	return m_bHave_GLX_EXT_swap_control_tear;
 #endif
 	}
 };
diff --git a/mp/src/public/togl/linuxwin/glfuncs.h b/mp/src/public/togl/linuxwin/glfuncs.h
index f5795139..f543b4af 100644
--- a/mp/src/public/togl/linuxwin/glfuncs.h
+++ b/mp/src/public/togl/linuxwin/glfuncs.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 // !!! FIXME: Some of these aren't base OpenGL...pick out the extensions.
 // !!! FIXME: Also, look up these -1, -1 versions numbers.
 GL_FUNC(OpenGL,true,GLenum,glGetError,(void),())
@@ -39,8 +61,11 @@ GL_FUNC_VOID(OpenGL,true,glDisable,(GLenum a),(a))
 GL_FUNC_VOID(OpenGL,true,glDisableVertexAttribArray,(GLuint a),(a))
 GL_FUNC_VOID(OpenGL,true,glDrawArrays,(GLenum a,GLint b,GLsizei c),(a,b,c))
 GL_FUNC_VOID(OpenGL,true,glDrawBuffer,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDrawBuffers,(GLsizei a,const GLenum *b),(a,b))
 GL_FUNC_VOID(OpenGL,true,glDrawRangeElements,(GLenum a,GLuint b,GLuint c,GLsizei d,GLenum e,const GLvoid *f),(a,b,c,d,e,f))
+#ifndef OSX // 10.6/GL 2.1 compatability
 GL_FUNC_VOID(OpenGL,true,glDrawRangeElementsBaseVertex,(GLenum a,GLuint b,GLuint c,GLsizei d,GLenum e,const GLvoid *f, GLenum g),(a,b,c,d,e,f,g))
+#endif
 GL_FUNC_VOID(OpenGL,true,glEnable,(GLenum a),(a))
 GL_FUNC_VOID(OpenGL,true,glEnableVertexAttribArray,(GLuint a),(a))
 GL_FUNC_VOID(OpenGL,true,glEnd,(void),())
@@ -185,17 +210,24 @@ GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glRenderbufferStorageMultisample,(G
 GL_EXT(GL_GREMEDY_string_marker,-1,-1)
 GL_FUNC_VOID(GL_GREMEDY_string_marker,false,glStringMarkerGREMEDY,(GLsizei a,const void *b),(a,b))
 GL_EXT(GL_ARB_debug_output,-1,-1)
+#ifdef OSX
+GL_FUNC_VOID(GL_ARB_debug_output,false,glDebugMessageCallbackARB,(void ( *a)(GLenum, GLenum , GLuint , GLenum , GLsizei , const GLchar* , GLvoid*) ,void* b),(a,b))
+#else
 GL_FUNC_VOID(GL_ARB_debug_output,false,glDebugMessageCallbackARB,(void (APIENTRY *a)(GLenum, GLenum , GLuint , GLenum , GLsizei , const GLchar* , GLvoid*) ,void* b),(a,b))
+#endif
 GL_FUNC_VOID(GL_ARB_debug_output,false,glDebugMessageControlARB,(GLenum a, GLenum b, GLenum c, GLsizei d, const GLuint* e, GLboolean f),(a,b,c,d,e,f))
+
 GL_EXT(GL_EXT_direct_state_access,-1,-1)
 GL_FUNC_VOID(GL_EXT_direct_state_access,false,glBindMultiTextureEXT,(GLenum a,GLuint b, GLuint c),(a,b,c))
-GL_FUNC_VOID(OpenGL,true,glGenSamplers,(GLuint a,GLuint *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glDeleteSamplers,(GLsizei a,const GLuint *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glBindSampler,(GLuint a, GLuint b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glSamplerParameteri,(GLuint a, GLenum b, GLint c),(a,b,c))
-GL_FUNC_VOID(OpenGL,true,glSamplerParameterf,(GLuint a, GLenum b, GLfloat c),(a,b,c))
-GL_FUNC_VOID(OpenGL,true,glSamplerParameterfv,(GLuint a, GLenum b, const GLfloat *c),(a,b,c))
 GL_EXT(GL_NV_bindless_texture,-1,-1)
+
+#ifndef OSX
+GL_FUNC_VOID(OpenGL, true, glGenSamplers, (GLuint a, GLuint *b), (a, b))
+GL_FUNC_VOID(OpenGL, true, glDeleteSamplers, (GLsizei a, const GLuint *b), (a, b))
+GL_FUNC_VOID(OpenGL, true, glBindSampler, (GLuint a, GLuint b), (a, b))
+GL_FUNC_VOID(OpenGL, true, glSamplerParameteri, (GLuint a, GLenum b, GLint c), (a, b, c))
+GL_FUNC_VOID(OpenGL, true, glSamplerParameterf, (GLuint a, GLenum b, GLfloat c), (a, b, c))
+GL_FUNC_VOID(OpenGL, true, glSamplerParameterfv, (GLuint a, GLenum b, const GLfloat *c), (a, b, c))
 GL_FUNC(GL_NV_bindless_texture, false, GLuint64, glGetTextureHandleNV, (GLuint texture), (texture))
 GL_FUNC(GL_NV_bindless_texture, false, GLuint64, glGetTextureSamplerHandleNV, (GLuint texture, GLuint sampler), (texture, sampler))
 GL_FUNC_VOID(GL_NV_bindless_texture, false, glMakeTextureHandleResidentNV, (GLuint64 handle), (handle))
@@ -213,11 +245,17 @@ GL_FUNC_VOID(OpenGL,true,glQueryCounter,(GLuint id, GLenum target), (id, target)
 GL_FUNC_VOID(OpenGL,true,glGetQueryObjectiv,(GLuint id, GLenum pname, GLint *params), (id, pname, params))
 GL_FUNC_VOID(OpenGL,true,glGetQueryObjectui64v,(GLuint id, GLenum pname, GLuint64 *params), (id, pname, params))
 GL_FUNC_VOID(OpenGL,true,glCopyBufferSubData,(GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size),(readtarget, writetarget, readoffset, writeoffset, size))
+#endif // !OSX
+
 GL_EXT(GL_AMD_pinned_memory,-1,-1)
 GL_EXT(GL_EXT_framebuffer_multisample_blit_scaled,-1,-1)
+
+#ifndef OSX
 GL_FUNC_VOID(OpenGL,true,glGenVertexArrays,(GLsizei n, GLuint *arrays),(n, arrays))
 GL_FUNC_VOID(OpenGL,true,glDeleteVertexArrays,(GLsizei n, GLuint *arrays),(n, arrays))
 GL_FUNC_VOID(OpenGL,true,glBindVertexArray,(GLuint a),(a))
+#endif // !OSX
+
 GL_EXT(GL_EXT_texture_sRGB_decode,-1,-1)
 GL_FUNC_VOID(OpenGL,true,glPushClientAttrib,(GLbitfield a),(a))
 GL_FUNC_VOID(OpenGL,true,glPopClientAttrib,(void),())
@@ -228,6 +266,9 @@ GL_EXT(GL_EXT_texture_compression_dxt1,-1,-1)
 GL_EXT(GL_ANGLE_texture_compression_dxt3,-1,-1)
 GL_EXT(GL_ANGLE_texture_compression_dxt5,-1,-1)
 
+GL_EXT( GL_ARB_buffer_storage, 4, 4 )
+GL_FUNC_VOID( GL_ARB_buffer_storage, false, glBufferStorage, (GLenum target, GLsizeiptr size, const void *data, GLbitfield flags), (target, size, data, flags) )
+
 // This one is an OS extension. We'll add a little helper function to look for it.
 #ifdef _WIN32
 	GL_EXT(WGL_EXT_swap_control_tear,-1,-1)
diff --git a/mp/src/public/togl/linuxwin/glmdebug.h b/mp/src/public/togl/linuxwin/glmdebug.h
index 8efba8b4..08cb6f91 100644
--- a/mp/src/public/togl/linuxwin/glmdebug.h
+++ b/mp/src/public/togl/linuxwin/glmdebug.h
@@ -1,8 +1,33 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 #ifndef GLMDEBUG_H
 #define	GLMDEBUG_H
 
 #include "tier0/platform.h"
+#if defined( OSX )
+#include <stdarg.h>
+#endif
 
 // include this anywhere you need to be able to compile-out code related specifically to GLM debugging.
 
@@ -132,11 +157,7 @@ inline void GLMDebugger( void )
 {
 	if (GLMDebugChannelMask() & (1<<eDebugger))
 	{
-#ifdef OSX
-		asm {int 3 };
-#else
 		DebuggerBreak();
-#endif
 	}
 	
 	if (GLMDebugChannelMask() & (1<<eGLProfiler))
diff --git a/mp/src/public/togl/linuxwin/glmdisplay.h b/mp/src/public/togl/linuxwin/glmdisplay.h
index 9a3183cc..dfab74ca 100644
--- a/mp/src/public/togl/linuxwin/glmdisplay.h
+++ b/mp/src/public/togl/linuxwin/glmdisplay.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 //
 // glmdisplay.h
 // display related stuff - used by both GLMgr and the CocoaMgr
@@ -10,20 +32,22 @@
 
 #pragma once
 
+#ifdef USE_SDL
+#include "SDL_opengl.h"
+#endif
+
 #ifdef OSX
 #include <OpenGL/OpenGL.h>
 #include <OpenGL/gl.h>
-#include <OpenGL/glext.h>
 #include <OpenGL/CGLTypes.h>
 #include <OpenGL/CGLRenderers.h>
 #include <OpenGL/CGLCurrent.h>
-#include <ApplicationServices/ApplicationServices.h>
-#elif defined(DX_TO_GL_ABSTRACTION)
-#include <GL/gl.h>
-#include <GL/glext.h>
-#include "tier0/platform.h"
-#else
-#error
+#endif
+
+#ifdef MAC_OS_X_VERSION_10_9
+typedef uint32_t CGDirectDisplayID;
+typedef uint32_t CGOpenGLDisplayMask;
+typedef double CGRefreshRate;
 #endif
 
 typedef void _PseudoNSGLContext;					// aka NSOpenGLContext
@@ -125,7 +149,7 @@ struct GLMRendererInfoFields
 	bool	m_intel;
 	bool	m_intel95x;
 	bool	m_intel3100;
-	bool	m_intelNewer;
+	bool	m_intelHD4000;
 
 	bool	m_nv;
 	bool	m_nvG7x;
@@ -169,6 +193,7 @@ struct GLMRendererInfoFields
 
 	//--------------------------- " bads " - known bad drivers
 	bool	m_badDriver1064NV;		// this is the bad NVIDIA driver on 10.6.4 - stutter, tex corruption, black screen issues
+	bool    m_badDriver108Intel;	// this is the bad Intel HD4000 driver on 10.8 - intermittent crash on GLSL compilation.
 };
 
 
diff --git a/mp/src/public/togl/linuxwin/glmdisplaydb.h b/mp/src/public/togl/linuxwin/glmdisplaydb.h
index d9f64d80..686c792d 100644
--- a/mp/src/public/togl/linuxwin/glmdisplaydb.h
+++ b/mp/src/public/togl/linuxwin/glmdisplaydb.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 #ifndef GLMDISPLAYDB_H
 #define	GLMDISPLAYDB_H
 
@@ -32,13 +54,24 @@ class GLMDisplayInfo
 public:
 	GLMDisplayInfoFields			m_info;
 	CUtlVector< GLMDisplayMode* >	*m_modes;				// starts out NULL, set by PopulateModes
+	GLMDisplayMode					m_DesktopMode;
 
+#ifdef OSX
+	GLMDisplayInfo( CGDirectDisplayID displayID, CGOpenGLDisplayMask displayMask );
+#else
 	GLMDisplayInfo( void );
+#endif
+
 	~GLMDisplayInfo( void );
 	
 	void	PopulateModes( void );
 
 	void	Dump( int which );
+
+#ifdef OSX
+private:
+	int m_display;
+#endif
 };
 
 //===============================================================================
@@ -48,23 +81,55 @@ public:
 class GLMRendererInfo
 {
 public:
-	GLMRendererInfoFields	m_info;
-	GLMDisplayInfo			*m_display;
-
+	GLMRendererInfoFields			m_info;
+#ifdef OSX
+	CUtlVector< GLMDisplayInfo* >	*m_displays;			// starts out NULL, set by PopulateDisplays
+#else
+	GLMDisplayInfo					*m_display;
+#endif
+
+#ifdef OSX
+	GLMRendererInfo			( GLMRendererInfoFields *info );
+#else
 	GLMRendererInfo			();
+#endif
 	~GLMRendererInfo		( void );
 
+#ifndef OSX
 	void	Init( GLMRendererInfoFields *info );
+#endif
 	void	PopulateDisplays();
 	void	Dump( int which );
 };
 
 //===============================================================================
 
+#ifdef OSX
+// this is just a tuple describing fake adapters which are really renderer/display pairings.
+// dxabstract bridges the gap between the d3d adapter-centric world and the GL renderer+display world.
+// this makes it straightforward to handle cases like two video cards with two displays on one, and one on the other -
+// you get three fake adapters which represent each useful screen.
+
+// the constraint that dxa will have to follow though, is that if the user wants to change their 
+// display selection for full screen, they would only be able to pick on that has the same underlying renderer.
+// can't change fakeAdapter from one to another with different GL renderer under it.  Screen hop but no card hop.
+
+struct GLMFakeAdapter
+{
+	int		m_rendererIndex;
+	int		m_displayIndex;
+};
+#endif
+
 class GLMDisplayDB
 {
 public:
+#ifdef OSX
+	CUtlVector< GLMRendererInfo* >		*m_renderers;			// starts out NULL, set by PopulateRenderers
+	CUtlVector< GLMFakeAdapter >		m_fakeAdapters;
+#else
 	GLMRendererInfo	m_renderer;
+#endif
 
 	GLMDisplayDB	( void );
 	~GLMDisplayDB	( void );	
diff --git a/mp/src/public/togl/linuxwin/glmgr.h b/mp/src/public/togl/linuxwin/glmgr.h
index 2f555db9..aabcd708 100644
--- a/mp/src/public/togl/linuxwin/glmgr.h
+++ b/mp/src/public/togl/linuxwin/glmgr.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 //
 // glmgr.h
 //	singleton class, common basis for managing GL contexts
@@ -11,6 +33,11 @@
 
 #pragma once
 
+#undef HAVE_GL_ARB_SYNC
+#ifndef OSX
+#define HAVE_GL_ARB_SYNC 1
+#endif
+
 #include "glbase.h"
 #include "glentrypoints.h"
 #include "glmdebug.h"
@@ -28,6 +55,9 @@
 #include "dxabstract_types.h"
 #include "tier0/icommandline.h"
 
+#undef FORCEINLINE
+#define FORCEINLINE inline
+
 //===============================================================================
 
 #define GLM_OPENGL_VENDOR_ID 1
@@ -1066,7 +1096,7 @@ struct GLMVertexSetup
 #define	kGLMProgramParamInt4Limit	16
 
 #define	kGLMVertexProgramParamFloat4Limit	256
-#define	kGLMFragmentProgramParamFloat4Limit	32
+#define	kGLMFragmentProgramParamFloat4Limit	256
 
 struct GLMProgramParamsF
 {
@@ -1174,6 +1204,7 @@ public:
 };
 
 //===========================================================================//
+#ifndef OSX
 
 #ifndef GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD
 #define GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD 0x9160
@@ -1187,7 +1218,16 @@ class CPinnedMemoryBuffer
 	CPinnedMemoryBuffer & operator= ( const CPinnedMemoryBuffer & );
 
 public:
-	CPinnedMemoryBuffer() : m_pRawBuf( NULL ), m_pBuf( NULL ), m_nSize( 0 ), m_nOfs( 0 ), m_nBufferObj( 0 ), m_nSyncObj( 0 )
+	CPinnedMemoryBuffer()
+	: 
+		m_pRawBuf( NULL ) 
+		, m_pBuf( NULL )
+		, m_nSize( 0 )
+		, m_nOfs( 0 )
+		, m_nBufferObj( 0 )
+#ifdef HAVE_GL_ARB_SYNC
+		, m_nSyncObj( 0 )
+#endif
 	{
 	}
 
@@ -1199,7 +1239,7 @@ public:
 	bool Init( uint nSize )
 	{
 		Deinit();
-				
+
 		// Guarantee 64KB alignment
 		m_pRawBuf = malloc( nSize + 65535 );
 		m_pBuf = reinterpret_cast<void *>((reinterpret_cast<uint64>(m_pRawBuf) + 65535) & (~65535));
@@ -1210,7 +1250,7 @@ public:
 		gGL->glBindBufferARB( GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, m_nBufferObj );
 
 		gGL->glBufferDataARB( GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, m_nSize, m_pBuf, GL_STREAM_COPY );
-		
+
 		return true;
 	}
 
@@ -1218,22 +1258,22 @@ public:
 	{
 		if ( !m_pRawBuf )
 			return;
-		
+
 		BlockUntilNotBusy();
-				
+
 		gGL->glBindBufferARB(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, m_nBufferObj );
 
 		gGL->glBufferDataARB( GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, 0, (void*)NULL, GL_STREAM_COPY );
-		
+
 		gGL->glBindBufferARB( GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, 0 );
-		
+
 		gGL->glDeleteBuffersARB( 1, &m_nBufferObj );
 		m_nBufferObj = 0;
 
 		free( m_pRawBuf );
 		m_pRawBuf = NULL;
 		m_pBuf = NULL;
-
+	
 		m_nSize = 0;
 		m_nOfs = 0;
 	}
@@ -1246,43 +1286,49 @@ public:
 
 	void InsertFence()
 	{
+#ifdef HAVE_GL_ARB_SYNC
 		if ( m_nSyncObj  )
 		{
 			gGL->glDeleteSync( m_nSyncObj );
 		}
 
 		m_nSyncObj = gGL->glFenceSync( GL_SYNC_GPU_COMMANDS_COMPLETE, 0 );
+#endif
 	}
 
 	void BlockUntilNotBusy()
 	{
+#ifdef HAVE_GL_ARB_SYNC
 		if ( m_nSyncObj )
 		{
 			gGL->glClientWaitSync( m_nSyncObj, GL_SYNC_FLUSH_COMMANDS_BIT, 3000000000000ULL );
-			
-			gGL->glDeleteSync( m_nSyncObj );
 
+			gGL->glDeleteSync( m_nSyncObj );
+								
 			m_nSyncObj = 0;
 		}
+#endif
 		m_nOfs = 0;
 	}
-		
+
 	void Append( uint nSize )
 	{
 		m_nOfs += nSize;
 		Assert( m_nOfs <= m_nSize );
 	}
-		
+
 private:
 	void *m_pRawBuf;
 	void *m_pBuf;
 	uint m_nSize;
 	uint m_nOfs;
-	
-	GLuint m_nBufferObj;
 
+	GLuint m_nBufferObj;
+#ifdef HAVE_GL_ARB_SYNC
 	GLsync m_nSyncObj;
+#endif
 };
+#endif // !OSX
 
 //===========================================================================//
 
@@ -1310,7 +1356,7 @@ class GLMContext
 
 		// textures
 		// Lock and Unlock reqs go directly to the tex object
-		CGLMTex	*NewTex( GLMTexLayoutKey *key, const char *debugLabel=NULL );
+		CGLMTex	*NewTex( GLMTexLayoutKey *key, uint levels=1, const char *debugLabel=NULL );
 		void	DelTex( CGLMTex	*tex );	
 
 			// options for Blit (replacement for ResolveTex and BlitTex)
@@ -1347,7 +1393,7 @@ class GLMContext
 		// render targets (FBO's)
 		CGLMFBO	*NewFBO( void );
 		void	DelFBO( CGLMFBO *fbo );		
-		
+
 		// programs
 		CGLMProgram	*NewProgram( EGLMProgramType type, char *progString, const char *pShaderName );
 		void	DelProgram( CGLMProgram *pProg );
@@ -1360,6 +1406,7 @@ class GLMContext
 		void	SetDrawingLang( EGLMProgramLang lang, bool immediate=false );	// choose ARB or GLSL.  immediate=false defers lang change to top of frame
 		
 		void	LinkShaderPair( CGLMProgram *vp, CGLMProgram *fp );			// ensure this combo has been linked and is in the GLSL pair cache
+		void	ValidateShaderPair( CGLMProgram *vp, CGLMProgram *fp );
 		void	ClearShaderPairCache( void );								// call this to shoot down all the linked pairs
 		void	QueryShaderPair( int index, GLMShaderPairInfo *infoOut );	// this lets you query the shader pair cache for saving its state
 		
@@ -1403,8 +1450,12 @@ class GLMContext
 		void FlushDrawStatesNoShaders();
 				
 		// drawing
+#ifndef OSX
 		FORCEINLINE void DrawRangeElements(	GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, uint baseVertex, CGLMBuffer *pIndexBuf );
 		void DrawRangeElementsNonInline(	GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, uint baseVertex, CGLMBuffer *pIndexBuf );
+#else
+		void DrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, CGLMBuffer *pIndexBuf );
+#endif
 
 		void	CheckNative( void );
 		
@@ -1421,7 +1472,7 @@ class GLMContext
 
 		// Called when IDirect3DDevice9::Reset() is called.
 		void	Reset();							
-										
+
 		// writers for the state block inputs
 		
 		FORCEINLINE void	WriteAlphaTestEnable( GLAlphaTestEnable_t *src ) { m_AlphaTestEnable.Write( src ); }
@@ -1482,7 +1533,6 @@ class GLMContext
 #endif
 
 		FORCEINLINE void SetMaxUsedVertexShaderConstantsHint( uint nMaxConstants );
-
 		FORCEINLINE DWORD GetCurrentOwnerThreadId() const { return m_nCurOwnerThreadId; }
 								
 	protected:
@@ -1507,8 +1557,10 @@ class GLMContext
 		GLMContext( IDirect3DDevice9 *pDevice, GLMDisplayParams *params );
 		~GLMContext();
 
+#ifndef OSX
 		FORCEINLINE GLuint FindSamplerObject( const GLMTexSamplingParams &desiredParams );
-								
+#endif
+
 		FORCEINLINE void SetBufAndVertexAttribPointer( uint nIndex, GLuint nGLName, GLuint stride, GLuint datatype, GLboolean normalized, GLuint nCompCount, const void *pBuf, uint nRevision )
 		{
 			VertexAttribs_t &curAttribs = m_boundVertexAttribs[nIndex];
@@ -1518,7 +1570,7 @@ class GLMContext
 				gGL->glBindBufferARB( GL_ARRAY_BUFFER_ARB, nGLName );
 			}
 			else if ( ( curAttribs.m_pPtr == pBuf ) && 
-				( curAttribs.m_revision == nRevision ) &&
+					  ( curAttribs.m_revision == nRevision ) &&
 				( curAttribs.m_stride == stride ) &&
 				( curAttribs.m_datatype == datatype ) &&
 				( curAttribs.m_normalized == normalized ) &&
@@ -1533,7 +1585,7 @@ class GLMContext
 			curAttribs.m_stride = stride;
 			curAttribs.m_pPtr = pBuf;
 			curAttribs.m_revision = nRevision;
-
+			
 			gGL->glVertexAttribPointer( nIndex, nCompCount, datatype, normalized, stride, pBuf );
 		}
 
@@ -1555,7 +1607,7 @@ class GLMContext
 			m_CurAttribs.m_vtxAttribMap[0] = 0xBBBBBBBBBBBBBBBBULL;
 			m_CurAttribs.m_vtxAttribMap[1] = 0xBBBBBBBBBBBBBBBBULL;
 		}
-
+		
 		FORCEINLINE void ReleasedShader() {	NullProgram(); }
 		
 		// textures
@@ -1572,7 +1624,7 @@ class GLMContext
 				
 		// render targets / FBO's
 		void BindFBOToCtx( CGLMFBO *fbo, GLenum bindPoint = GL_FRAMEBUFFER_EXT );				// you can also choose GL_READ_FRAMEBUFFER_EXT / GL_DRAW_FRAMEBUFFER_EXT
-						
+		
 		// buffers
 		FORCEINLINE void BindGLBufferToCtx( GLenum nGLBufType, GLuint nGLName, bool bForce = false )
 		{
@@ -1585,40 +1637,48 @@ class GLMContext
 				gGL->glBindBufferARB( nGLBufType, nGLName );
 			}
 		}
-				
+
 		void BindBufferToCtx( EGLMBufferType type, CGLMBuffer *buff, bool force = false );		// does not twiddle any enables.
 
 		FORCEINLINE void BindIndexBufferToCtx( CGLMBuffer *buff );
 		FORCEINLINE void BindVertexBufferToCtx( CGLMBuffer *buff );
-						
+		
+		GLuint CreateTex( GLenum texBind, GLenum internalFormat );
+		void CleanupTex( GLenum texBind, GLMTexLayout* pLayout, GLuint tex );
+		void DestroyTex( GLenum texBind, GLMTexLayout* pLayout, GLuint tex );
+		GLuint FillTexCache( bool holdOne, int newTextures );
+		void PurgeTexCache( );
+
+		// debug font
+		void GenDebugFontTex( void );
+		void DrawDebugText( float x, float y, float z, float drawCharWidth, float drawCharHeight, char *string );
+
+#ifndef OSX
 		CPinnedMemoryBuffer *GetCurPinnedMemoryBuffer( ) { return &m_PinnedMemoryBuffers[m_nCurPinnedMemoryBuffer]; }
-						
+#endif
+
+		CPersistentBuffer* GetCurPersistentBuffer( EGLMBufferType type ) { return &( m_persistentBuffer[m_nCurPersistentBuffer][type] ); }
+
 		// members------------------------------------------
-		
+						
 		// context
 		DWORD							m_nCurOwnerThreadId;
 		uint							m_nThreadOwnershipReleaseCounter;
 
 		bool							m_bUseSamplerObjects;
-		bool							m_bPreferMapBufferRange;
+		bool							m_bTexClientStorage;
 
 		IDirect3DDevice9				*m_pDevice;
 		GLMRendererInfoFields			m_caps;
-					
+	
 		bool							m_displayParamsValid;		// is there a param block copied in yet
 		GLMDisplayParams				m_displayParams;			// last known display config, either via constructor, or by SetDisplayParams...
 		
-#ifdef OSX
-		CGLPixelFormatAttribute			m_pixelFormatAttribs[100];	// more than enough
-		PseudoNSGLContextPtr			m_nsctx;
-		CGLContextObj					m_ctx;
-#elif defined( USE_SDL )
+#if defined( USE_SDL )
 		int								m_pixelFormatAttribs[100];	// more than enough
 		PseudoNSGLContextPtr			m_nsctx;
 		void *							m_ctx;
 #endif
-		bool							m_oneCtxEnable;			// true if we use the window's context directly instead of making a second one shared against it
-
 		bool							m_bUseBoneUniformBuffers; // if true, we use two uniform buffers for vertex shader constants vs. one
 
 		// texture form table
@@ -1712,15 +1772,17 @@ class GLMContext
 		CGLMFBO							*m_scratchFBO[ kGLMScratchFBOCount ];	// general purpose FBO's for internal use
 		
 		CUtlVector< CGLMFBO* >			m_fboTable;				// each live FBO goes in the table
+
+		uint							m_fragDataMask;
 		
 		// program bindings
 		EGLMProgramLang					m_drawingLangAtFrameStart;	// selector for start of frame (spills into m_drawingLang)
 		EGLMProgramLang					m_drawingLang;				// selector for which language we desire to draw with on the next batch
 		CGLMProgram						*m_drawingProgram[ kGLMNumProgramTypes ];
 		bool							m_bDirtyPrograms;
-						
+		
 		GLMProgramParamsF				m_programParamsF[ kGLMNumProgramTypes ];
-		GLMProgramParamsB				m_programParamsB[ kGLMNumProgramTypes ];	// two banks, but only the vertex one is used
+		GLMProgramParamsB				m_programParamsB[ kGLMNumProgramTypes ];
 		GLMProgramParamsI				m_programParamsI[ kGLMNumProgramTypes ];	// two banks, but only the vertex one is used
 		EGLMParamWriteMode				m_paramWriteMode;
 		
@@ -1730,7 +1792,11 @@ class GLMContext
 		CGLMProgram						*m_preload2DTexFragmentProgram;
 		CGLMProgram						*m_preload3DTexFragmentProgram;
 		CGLMProgram						*m_preloadCubeTexFragmentProgram;
-				
+
+#if defined( OSX ) && defined( GLMDEBUG )
+		CGLMProgram						*m_boundProgram[ kGLMNumProgramTypes ];
+#endif
+
 		CGLMShaderPairCache				*m_pairCache;				// GLSL only
 		CGLMShaderPair					*m_pBoundPair;				// GLSL only
 
@@ -1741,7 +1807,7 @@ class GLMContext
 
 		// buffer bindings
 		GLuint							m_nBoundGLBuffer[kGLMNumBufferTypes];
-		
+
 		struct VertexAttribs_t
 		{
 			GLuint m_nCompCount;
@@ -1773,23 +1839,39 @@ class GLMContext
 
 		// batch/frame debugging support
 		int								m_debugFrameIndex;			// init to -1. Increment at BeginFrame
-														
+												
 		int							    m_nMaxUsedVertexProgramConstantsHint;
 		
 		uint32							m_dwRenderThreadId;
 		volatile bool					m_bIsThreading;
-				
+
 		uint m_nCurFrame;
 		uint m_nBatchCounter;
 
+		struct TextureEntry_t
+		{
+			GLenum m_nTexBind;
+			GLenum m_nInternalFormat;
+			GLuint m_nTexName;
+		};
+
+		GLuint							m_destroyPBO;
+		CUtlVector< TextureEntry_t >	m_availableTextures;
+
+#ifndef OSX
 		enum { cNumPinnedMemoryBuffers = 4 };
 		CPinnedMemoryBuffer m_PinnedMemoryBuffers[cNumPinnedMemoryBuffers];
 		uint m_nCurPinnedMemoryBuffer;
-		
+#endif
+
+		enum { cNumPersistentBuffers = 3 };
+		CPersistentBuffer	m_persistentBuffer[cNumPersistentBuffers][kGLMNumBufferTypes];
+		uint				m_nCurPersistentBuffer;
+
 		void SaveColorMaskAndSetToDefault();
 		void RestoreSavedColorMask();
 		GLColorMaskSingle_t				m_SavedColorMask;
-										
+				
 #if GLMDEBUG
 		// interactive (DebugHook) debug support
 
@@ -1825,6 +1907,8 @@ class GLMContext
 #endif
 };
 
+#ifndef OSX
+
 FORCEINLINE void GLMContext::DrawRangeElements(	GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, uint baseVertex, CGLMBuffer *pIndexBuf )
 {
 #if GL_ENABLE_INDEX_VERIFICATION
@@ -1836,20 +1920,25 @@ FORCEINLINE void GLMContext::DrawRangeElements(	GLenum mode, GLuint start, GLuin
 #else
 	//tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s %d-%d count:%d mode:%d type:%d", __FUNCTION__, start, end, count, mode, type );
 #endif
-		
+
 	++m_nBatchCounter;
 
 	SetIndexBuffer( pIndexBuf );
 
 	void *indicesActual = (void*)indices;
-	
+
 	if ( pIndexBuf->m_bPseudo )
 	{
 		// you have to pass actual address, not offset
 		indicesActual = (void*)( (int)indicesActual + (int)pIndexBuf->m_pPseudoBuf );
 	}
+	if (pIndexBuf->m_bUsingPersistentBuffer)
+	{
+		indicesActual = (void*)( (int)indicesActual + (int)pIndexBuf->m_nPersistentBufferStartOffset );
+	}
 
-#if GLMDEBUG
+//#if GLMDEBUG
+#if 0
 	bool	hasVP = m_drawingProgram[ kGLMVertexProgram ] != NULL;
 	bool	hasFP = m_drawingProgram[ kGLMFragmentProgram ] != NULL;
 
@@ -1931,6 +2020,8 @@ FORCEINLINE void GLMContext::DrawRangeElements(	GLenum mode, GLuint start, GLuin
 #endif // GL_ENABLE_INDEX_VERIFICATION
 }
 
+#endif // #ifndef OSX
+
 FORCEINLINE void GLMContext::SetVertexProgram( CGLMProgram *pProg )
 {
 	m_drawingProgram[kGLMVertexProgram] = pProg;
@@ -1969,23 +2060,53 @@ FORCEINLINE void GLMContext::SetProgramParametersF( EGLMProgramType type, uint b
 
 	if ( ( type == kGLMVertexProgram ) && ( m_bUseBoneUniformBuffers ) )
 	{
-		if ( ( baseSlot + slotCount ) > DXABSTRACT_VS_FIRST_BONE_SLOT )
+		// changes here to handle vertex shaders which use constants before and after the bone array i.e. before c58 and after c216
+		// a better change may be to modify the shaders and place the bone consts at either start or end - would simplify this and the flush code
+		// the current supporting code (shader translator(dx9asmtogl2), param setting(here) and flushing(glmgr_flush.inl) should work unchanged, even if the const mapping is changed.
+		int firstDirty = (int)baseSlot;
+		int highWater  = (int)(baseSlot + slotCount);
+
+		if ( highWater <= DXABSTRACT_VS_FIRST_BONE_SLOT )
+		{
+			m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, firstDirty );
+			m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, highWater );
+		}
+		else if ( highWater <= (DXABSTRACT_VS_LAST_BONE_SLOT+1) )
 		{
-			if ( baseSlot < DXABSTRACT_VS_FIRST_BONE_SLOT ) 
+			if ( firstDirty < DXABSTRACT_VS_FIRST_BONE_SLOT )
 			{
-				// The register set crosses between the constant buffers - should only happen at startup during init.
-				m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, (int)baseSlot );
-				m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, (int)MIN( baseSlot + slotCount, DXABSTRACT_VS_FIRST_BONE_SLOT ) );
-				baseSlot = DXABSTRACT_VS_FIRST_BONE_SLOT;
+				m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, firstDirty );
+				m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, MIN( DXABSTRACT_VS_FIRST_BONE_SLOT, highWater ) );
+				firstDirty = DXABSTRACT_VS_FIRST_BONE_SLOT;
 			}
 
-			int nNumActualBones = ( baseSlot + slotCount ) - DXABSTRACT_VS_FIRST_BONE_SLOT;
+			int nNumActualBones = ( firstDirty + slotCount ) - DXABSTRACT_VS_FIRST_BONE_SLOT;
 			m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterBone, nNumActualBones );
 		}
 		else
 		{
-			m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, (int)baseSlot );
-			m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, (int)(baseSlot + slotCount) );
+			const int maxBoneSlots = ( DXABSTRACT_VS_LAST_BONE_SLOT + 1 ) - DXABSTRACT_VS_FIRST_BONE_SLOT;
+
+			if ( firstDirty > DXABSTRACT_VS_LAST_BONE_SLOT )
+			{
+				m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, firstDirty - maxBoneSlots );
+				m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, highWater - maxBoneSlots );
+			}
+			else if ( firstDirty >= DXABSTRACT_VS_FIRST_BONE_SLOT )
+			{
+				m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterBone = DXABSTRACT_VS_LAST_BONE_SLOT + 1;
+
+				m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, DXABSTRACT_VS_FIRST_BONE_SLOT );
+				m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, highWater - maxBoneSlots );
+			}
+			else
+			{
+				int nNumActualBones = ( DXABSTRACT_VS_LAST_BONE_SLOT + 1 ) - DXABSTRACT_VS_FIRST_BONE_SLOT;
+				m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterBone, nNumActualBones );
+
+				m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone = MIN( m_programParamsF[kGLMVertexProgram].m_firstDirtySlotNonBone, firstDirty );
+				m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone = MAX( m_programParamsF[kGLMVertexProgram].m_dirtySlotHighWaterNonBone, highWater - maxBoneSlots );
+			}
 		}
 	}
 	else
@@ -2002,7 +2123,7 @@ FORCEINLINE void GLMContext::SetProgramParametersB( EGLMProgramType type, uint b
 #endif
 
 	Assert( m_drawingLang == kGLMGLSL );
-	Assert( type==kGLMVertexProgram );
+	Assert( type==kGLMVertexProgram || type==kGLMFragmentProgram );
 
 	Assert( baseSlot < kGLMProgramParamBoolLimit );
 	Assert( baseSlot+boolCount <= kGLMProgramParamBoolLimit );
@@ -2069,21 +2190,21 @@ FORCEINLINE void GLMContext::SetSamplerTex( int sampler, CGLMTex *tex )
 	m_samplers[sampler].m_pBoundTex = tex;
 	if ( tex )
 	{
-		if ( !gGL->m_bHave_GL_EXT_direct_state_access )
-		{
-			if ( sampler != m_activeTexture )
+			if ( !gGL->m_bHave_GL_EXT_direct_state_access )
 			{
-				gGL->glActiveTexture( GL_TEXTURE0 + sampler );
-				m_activeTexture = sampler;
-			}
+				if ( sampler != m_activeTexture )
+				{
+					gGL->glActiveTexture( GL_TEXTURE0 + sampler );
+					m_activeTexture = sampler;
+				}
 
-			gGL->glBindTexture( tex->m_texGLTarget, tex->m_texName );
-		}
-		else
-		{
-			gGL->glBindMultiTextureEXT( GL_TEXTURE0 + sampler, tex->m_texGLTarget, tex->m_texName );
+				gGL->glBindTexture( tex->m_texGLTarget, tex->m_texName );
+			}
+			else
+			{
+				gGL->glBindMultiTextureEXT( GL_TEXTURE0 + sampler, tex->m_texGLTarget, tex->m_texName );
+			}
 		}
-	}
 	
 	if ( !m_bUseSamplerObjects )
 	{
@@ -2184,8 +2305,8 @@ FORCEINLINE void GLMContext::BindIndexBufferToCtx( CGLMBuffer *buff )
 	GLMPRINTF(( "--- GLMContext::BindIndexBufferToCtx buff %p, GL name %d", buff, (buff) ? buff->m_nHandle : -1 ));
 		
 	Assert( !buff || ( buff->m_buffGLTarget == GL_ELEMENT_ARRAY_BUFFER_ARB ) );
-		
-	GLuint nGLName = buff ? buff->m_nHandle : 0;
+
+	GLuint nGLName = buff ? buff->GetHandle() : 0;
 
 	if ( m_nBoundGLBuffer[ kGLMIndexBuffer] == nGLName )
 		return;
@@ -2199,8 +2320,8 @@ FORCEINLINE void GLMContext::BindVertexBufferToCtx( CGLMBuffer *buff )
 	GLMPRINTF(( "--- GLMContext::BindVertexBufferToCtx buff %p, GL name %d", buff, (buff) ? buff->m_nHandle : -1 ));
 
 	Assert( !buff || ( buff->m_buffGLTarget == GL_ARRAY_BUFFER_ARB ) );
-		
-	GLuint nGLName = buff ? buff->m_nHandle : 0;
+
+	GLuint nGLName = buff ? buff->GetHandle() : 0;
 
 	if ( m_nBoundGLBuffer[ kGLMVertexBuffer] == nGLName )
 		return;
@@ -2232,6 +2353,45 @@ struct GLMTestParams
 	int			m_frameCount;			// how many frames to test.
 };
 
+class GLMTester
+{
+	public:
+	
+	GLMTester(GLMTestParams *params);
+	~GLMTester();
+	
+
+	// optionally callable by test routines to get basic drawables wired up
+	void	StdSetup( void );
+	void	StdCleanup( void );
+	
+	// callable by test routines to clear the frame or present it
+	void	Clear( void );
+	void	Present( int seed );
+
+	// error reporting
+	void	CheckGLError( const char *comment );					// obey m_params setting for console / debugger response
+	void	InternalError( int errcode, char *comment );	// if errcode!=0, obey m_params setting for console / debugger response
+	
+	void	RunTests();
+
+	void	RunOneTest( int testindex );
+
+	// test routines themselves
+	void	Test0();
+	void	Test1();
+	void	Test2();
+	void	Test3();
+
+	GLMTestParams	m_params;		// copy of caller's params, do not mutate...
+	
+	// std-setup stuff
+	int				m_drawWidth, m_drawHeight;
+	CGLMFBO			*m_drawFBO;
+	CGLMTex			*m_drawColorTex;
+	CGLMTex			*m_drawDepthTex;
+};
+
 class CShowPixelsParams
 {
 public:
diff --git a/mp/src/public/togl/linuxwin/glmgrbasics.h b/mp/src/public/togl/linuxwin/glmgrbasics.h
index ed380de4..a32938ad 100644
--- a/mp/src/public/togl/linuxwin/glmgrbasics.h
+++ b/mp/src/public/togl/linuxwin/glmgrbasics.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 //
 // glmgrbasics.h
 //	types, common headers, forward declarations, utilities
@@ -10,20 +32,20 @@
 
 #pragma once
 
+#ifdef USE_SDL
+#include "SDL_opengl.h"
+#endif
+
 #ifdef OSX
-	#include <OpenGL/OpenGL.h>
-	#include <OpenGL/gl.h>
-	#include <OpenGL/glext.h>
 	#include <OpenGL/CGLTypes.h>
 	#include <OpenGL/CGLRenderers.h>
 	#include <OpenGL/CGLCurrent.h>
+	#include <AvailabilityMacros.h>
+
+#ifndef MAC_OS_X_VERSION_10_9
 	#include <OpenGL/CGLProfiler.h>
 	#include <ApplicationServices/ApplicationServices.h>
-#elif defined(DX_TO_GL_ABSTRACTION)
-	#include <GL/gl.h>
-	#include <GL/glext.h>
-#else
-	#error
+#endif
 #endif
 
 #include "tier0/platform.h"
@@ -301,8 +323,10 @@ public:
 	CUtlVector< GLMTextSection >	m_sectionTable;
 };
 
+#ifndef OSX
 void GLMGPUTimestampManagerInit();
 void GLMGPUTimestampManagerDeinit();
 void GLMGPUTimestampManagerTick();
+#endif
 
 #endif // GLMBASICS_H
diff --git a/mp/src/public/togl/linuxwin/glmgrext.h b/mp/src/public/togl/linuxwin/glmgrext.h
index 8f1aba94..393942a7 100644
--- a/mp/src/public/togl/linuxwin/glmgrext.h
+++ b/mp/src/public/togl/linuxwin/glmgrext.h
@@ -1,4 +1,26 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
 //
 // glmgrext.h
 // helper file for extension testing and runtime importing of entry points
@@ -91,3 +113,11 @@
 #define GL_MAP_UNSYNCHRONIZED_BIT         0x0020
 #endif
 
+#ifndef GL_MAP_PERSISTENT_BIT
+#define GL_MAP_PERSISTENT_BIT				0x0040
+#endif
+
+#ifndef GL_MAP_COHERENT_BIT
+#define GL_MAP_COHERENT_BIT					0x0080
+#endif
+
diff --git a/mp/src/public/togl/osx/cglmbuffer.h b/mp/src/public/togl/osx/cglmbuffer.h
deleted file mode 100644
index 0b161000..00000000
--- a/mp/src/public/togl/osx/cglmbuffer.h
+++ /dev/null
@@ -1,99 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-//
-// cglmprogram.h
-//	GLMgr buffers (index / vertex)
-//	... maybe add PBO later as well
-//===============================================================================
-
-#ifndef CGLMBUFFER_H
-#define	CGLMBUFFER_H
-
-#pragma once
-
-// ext links
-
-// http://www.opengl.org/registry/specs/ARB/vertex_buffer_object.txt
-
-//===============================================================================
-
-// tokens not in the SDK headers
-
-//#ifndef	GL_DEPTH_STENCIL_ATTACHMENT_EXT
-//	#define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9
-//#endif
-
-//===============================================================================
-
-// forward declarations
-
-class GLMContext;
-
-enum EGLMBufferType
-{
-	kGLMVertexBuffer,
-	kGLMIndexBuffer,
-	kGLMUniformBuffer,	// for bindable uniform
-	kGLMPixelBuffer,	// for PBO
-	
-	kGLMNumBufferTypes
-};
-
-	// pass this in "options" to constructor to make a dynamic buffer
-#define	GLMBufferOptionDynamic	0x00000001
-
-struct GLMBuffLockParams
-{
-	uint	m_offset;
-	uint	m_size;
-	bool	m_nonblocking;
-	bool	m_discard;
-};
-
-class CGLMBuffer
-{
-
-public:
-	void	Lock( GLMBuffLockParams *params, char **addressOut );
-	void	Unlock( void );
-
-//protected:
-	friend class GLMContext;			// only GLMContext can make CGLMBuffer objects
-	friend class GLMTester;	
-	friend class IDirect3D9;
-	friend class IDirect3DDevice9;
-		
-	CGLMBuffer					( GLMContext *ctx, EGLMBufferType type, uint size, uint options );
-	~CGLMBuffer					( );	
-	
-	void	SetModes			( bool asyncMap, bool explicitFlush, bool force = false );
-	void	FlushRange			( uint offset, uint size );
-	
-	GLMContext				*m_ctx;					// link back to parent context
-	EGLMBufferType			m_type;
-	uint					m_size;
-	GLenum					m_buffGLTarget;			// GL_ARRAY_BUFFER_ARB / GL_ELEMENT_BUFFER_ARB	
-	GLuint					m_name;					// name of this program in the context	
-	uint					m_revision;				// bump anytime the size changes or buffer is orphaned
-	bool					m_enableAsyncMap;		// mirror of the buffer state
-	bool					m_enableExplicitFlush;	// mirror of the buffer state
-
-	bool					m_bound;				// true if bound to context		
-	bool					m_mapped;				// is it currently mapped
-	uint					m_dirtyMinOffset;		// when equal, range is empty
-	uint					m_dirtyMaxOffset;
-	
-	float					*m_lastMappedAddress;
-	
-	// --------------------- pseudo-VBO support below here (explicitly for dynamic index buffers)
-	bool					m_pseudo;				// true if the m_name is 0, and the backing is plain RAM
-	
-	// in pseudo mode, there is just one RAM buffer that acts as the backing.
-	// expectation is that this mode would only be used for dynamic indices.
-	// since indices have to be consumed (copied to command stream) prior to return from a drawing call,
-	// there's no need to do any fencing or multibuffering.  orphaning in particular becomes a no-op.
-	
-	char					*m_pseudoBuf;			// storage for pseudo buffer
-};	
-
-
-#endif
\ No newline at end of file
diff --git a/mp/src/public/togl/osx/cglmfbo.h b/mp/src/public/togl/osx/cglmfbo.h
deleted file mode 100644
index ccf3e970..00000000
--- a/mp/src/public/togl/osx/cglmfbo.h
+++ /dev/null
@@ -1,91 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-//
-// cglmfbo.h
-//	GLMgr FBO's (render targets)
-//
-//===============================================================================
-
-#ifndef CGLMFBO_H
-#define	CGLMFBO_H
-
-#pragma once
-
-#include "togl/rendermechanism.h"
-
-// good FBO references / recaps
-// http://www.songho.ca/opengl/gl_fbo.html
-// http://www.gamedev.net/reference/articles/article2331.asp
-
-// ext links
-
-// http://www.opengl.org/registry/specs/EXT/framebuffer_object.txt
-// http://www.opengl.org/registry/specs/EXT/framebuffer_multisample.txt
-
-//===============================================================================
-
-// tokens not in the SDK headers
-
-#ifndef	GL_DEPTH_STENCIL_ATTACHMENT_EXT
-	#define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9
-#endif
-
-//===============================================================================
-
-// forward declarations
-
-class	GLMContext;
-
-// implicitly 16 maximum color attachments possible
-enum EGLMFBOAttachment {
-	kAttColor0,		kAttColor1,		kAttColor2,		kAttColor3,
-	kAttColor4,		kAttColor5,		kAttColor6,		kAttColor7,
-	kAttColor8,		kAttColor9,		kAttColor10,	kAttColor11,
-	kAttColor12,	kAttColor13,	kAttColor14,	kAttColor15,
-	kAttDepth,		kAttStencil,	kAttDepthStencil,
-	kAttCount
-};
-
-struct GLMFBOTexAttachParams
-{	
-	CGLMTex				*m_tex;
-	int					m_face;		// keep zero if not cube map
-	int					m_mip;		// keep zero if notmip mapped
-	int					m_zslice;	// keep zero if not a 3D tex
-};
-
-class CGLMFBO
-{
-
-public:
-
-protected:
-	friend class GLMContext;			// only GLMContext can make CGLMFBO objects
-	friend class GLMTester;
-	friend class CGLMTex;
-	
-	friend class IDirect3D9;
-	friend class IDirect3DDevice9;
-		
-			CGLMFBO( GLMContext *ctx );
-			~CGLMFBO( );	
-
-	void	TexAttach( GLMFBOTexAttachParams *params, EGLMFBOAttachment attachIndex, GLenum fboBindPoint = GL_FRAMEBUFFER_EXT );
-	void	TexDetach( EGLMFBOAttachment attachIndex, GLenum fboBindPoint = GL_FRAMEBUFFER_EXT );
-		// you can also pass GL_READ_FRAMEBUFFER_EXT or GL_DRAW_FRAMEBUFFER_EXT to selectively bind the receiving FBO to one or the other.
-
-	void	TexScrub( CGLMTex *tex );
-		// search and destroy any attachment for the named texture
-	
-	bool	IsReady( void );				// aka FBO completeness check - ready to draw
-	
-	GLMContext				*m_ctx;			// link back to parent context
-
-	GLuint					m_name;			// name of this FBO in the context
-	
-	GLMFBOTexAttachParams	m_attach[ kAttCount ];	// indexed by EGLMFBOAttachment
-	
-	int						m_sizeX,m_sizeY;
-};	
-
-
-#endif
diff --git a/mp/src/public/togl/osx/cglmprogram.h b/mp/src/public/togl/osx/cglmprogram.h
deleted file mode 100644
index ee7f4de2..00000000
--- a/mp/src/public/togl/osx/cglmprogram.h
+++ /dev/null
@@ -1,291 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-//
-// cglmprogram.h
-//	GLMgr programs (ARBVP/ARBfp)
-//
-//===============================================================================
-
-#ifndef CGLMPROGRAM_H
-#define	CGLMPROGRAM_H
-
-#include <sys/stat.h>
-
-#pragma once
-
-// good ARB program references
-// http://petewarden.com/notes/archives/2005/05/fragment_progra_2.html
-// http://petewarden.com/notes/archives/2005/06/fragment_progra_3.html
-
-// ext links
-
-// http://www.opengl.org/registry/specs/ARB/vertex_program.txt
-// http://www.opengl.org/registry/specs/ARB/fragment_program.txt
-// http://www.opengl.org/registry/specs/EXT/gpu_program_parameters.txt
-
-
-//===============================================================================
-
-// tokens not in the SDK headers
-
-//#ifndef	GL_DEPTH_STENCIL_ATTACHMENT_EXT
-//	#define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9
-//#endif
-
-//===============================================================================
-
-// forward declarations
-
-class GLMContext;
-class CGLMShaderPair;
-class CGLMShaderPairCache;
-
-// CGLMProgram can contain two flavors of the same program, one in assembler, one in GLSL.
-// these flavors are pretty different in terms of the API's that are used to activate them - 
-// for example, assembler programs can just get bound to the context, whereas GLSL programs
-// have to be linked.  To some extent we try to hide that detail inside GLM.
-
-// for now, make CGLMProgram a container, it does not set policy or hold a preference as to which
-// flavor you want to use.  GLMContext has to handle that. 
-
-enum EGLMProgramType
-{
-	kGLMVertexProgram,
-	kGLMFragmentProgram,
-	
-	kGLMNumProgramTypes
-};
-
-enum EGLMProgramLang
-{
-	kGLMARB,
-	kGLMGLSL,
-	
-	kGLMNumProgramLangs
-};
-
-struct GLMShaderDesc
-{
-	union
-	{
-		GLuint		arb;		// ARB program object name
-		GLhandleARB	glsl;		// GLSL shader object handle (void*)
-	}	m_object;
-
-	// these can change if shader text is edited
-	bool	m_textPresent;	// is this flavor(lang) of text present in the buffer?
-	int		m_textOffset;	// where is it
-	int		m_textLength;	// how big
-	
-	bool	m_compiled;		// has this text been through a compile attempt
-	bool	m_valid;		// and if so, was the compile successful
-
-	int		m_slowMark;		// has it been flagged during a non native draw batch before. increment every time it's slow.
-	
-	int		m_highWater;	// vount of vec4's in the major uniform array ("vc" on vs, "pc" on ps)
-							// written by dxabstract.... gross!
-};
-
-GLenum	GLMProgTypeToARBEnum( EGLMProgramType type );	// map vert/frag to ARB asm bind target
-GLenum	GLMProgTypeToGLSLEnum( EGLMProgramType type );	// map vert/frag to ARB asm bind target
-
-class CGLMProgram
-{
-public:
-	friend class CGLMShaderPairCache;
-	friend class CGLMShaderPair;
-	friend class GLMContext;			// only GLMContext can make CGLMProgram objects
-	friend class GLMTester;	
-	friend class IDirect3D9;
-	friend class IDirect3DDevice9;
-		
-	//===============================
-	
-	// constructor is very light, it just makes one empty program object per flavor.
-	CGLMProgram( GLMContext *ctx, EGLMProgramType type );
-	~CGLMProgram( );	
-
-	void	SetProgramText			( char *text );				// import text to GLM object - invalidate any prev compiled program
-	
-	bool	CompileActiveSources	( void );					// compile only the flavors that were provided.
-	bool	Compile					( EGLMProgramLang lang );	
-	bool	CheckValidity			( EGLMProgramLang lang );
-
-	void	LogSlow					( EGLMProgramLang lang );	// detailed spew when called for first time; one liner or perhaps silence after that
-	
-	void	GetLabelIndexCombo		( char *labelOut, int labelOutMaxChars, int *indexOut, int *comboOut );	
-	void	GetComboIndexNameString	( char *stringOut, int stringOutMaxChars );		// mmmmmmmm-nnnnnnnn-filename
-	
-#if GLMDEBUG
-	bool	PollForChanges( void );			// check mirror for changes.
-	void	ReloadStringFromEditable( void );	// populate m_string from editable item (react to change)
-	bool	SyncWithEditable( void );
-#endif
-
-	//===============================
-	
-	// common stuff
-
-	GLMContext				*m_ctx;					// link back to parent context
-
-	EGLMProgramType			m_type;					// vertex or pixel
-
-	uint					m_serial;				// serial number for hashing
-	
-	char					*m_text;				// copy of text passed into constructor.  Can change if editable shaders is enabled.
-													// note - it can contain multiple flavors, so use CGLMTextSectioner to scan it and locate them
-#if GLMDEBUG
-	CGLMEditableTextItem	*m_editable;			// editable text item for debugging
-#endif	
-	
-	GLMShaderDesc			m_descs[ kGLMNumProgramLangs ];	
-
-	uint					m_samplerMask;			// (1<<n) mask of sampler active locs, if this is a fragment shader (dxabstract sets this field)
-};	
-
-//===============================================================================
-
-struct GLMShaderPairInfo
-{
-	int		m_status;		// -1 means req'd index was out of bounds (loop stop..)  0 means not present.  1 means present/active.
-	
-	char	m_vsName[ 128 ];
-	int		m_vsStaticIndex;
-	int		m_vsDynamicIndex;
-	
-	char	m_psName[ 128 ];
-	int		m_psStaticIndex;
-	int		m_psDynamicIndex;
-};
-
-
-class CGLMShaderPair					// a container for a linked GLSL shader pair, and metadata obtained post-link
-{
-
-public:
-
-	friend class CGLMProgram;
-	friend class GLMContext;
-	friend class CGLMShaderPairCache;
-		
-	//===============================
-	
-	// constructor just sets up a GLSL program object and leaves it empty.
-	CGLMShaderPair( GLMContext *ctx  );
-	~CGLMShaderPair( );	
-
-	bool	SetProgramPair			( CGLMProgram *vp, CGLMProgram *fp );
-		// true result means successful link and query
-
-	bool	RefreshProgramPair		( void );
-		// re-link and re-query the uniforms
-	
-	//===============================
-	
-	// common stuff
-
-	GLMContext				*m_ctx;					// link back to parent context
-
-	CGLMProgram				*m_vertexProg;	
-	CGLMProgram				*m_fragmentProg;
-
-	GLhandleARB				m_program;				// linked program object
-
-	// need meta data for attribs / samplers / params
-	// actually we only need it for samplers and params.
-	// attributes are hardwired.
-	
-	// vertex stage uniforms
-	GLint					m_locVertexParams;		// "vc" per dx9asmtogl2 convention
-	GLint					m_locVertexInteger0;	// "i0"
-	GLint					m_locVertexBool0;		// "b0"
-	GLint					m_locVertexBool1;		// "b1"
-	GLint					m_locVertexBool2;		// "b2"
-	GLint					m_locVertexBool3;		// "b3"
-	
-	// fragment stage uniforms
-	GLint					m_locFragmentParams;			// "pc" per dx9asmtogl2 convention
-	GLint					m_locFragmentFakeSRGBEnable;	// "flSRGBWrite" - set to 1.0 to effect sRGB encoding on output
-	float					m_fakeSRGBEnableValue;			// shadow to avoid redundant sets of the m_locFragmentFakeSRGBEnable uniform
-		// init it to -1.0 at link or relink, so it will trip on any legit incoming value (0.0 or 1.0)
-
-	GLint					m_locSamplers[ 16 ];			// "sampler0 ... sampler1..."
-
-	// other stuff
-	bool					m_valid;				// true on successful link
-	bool					m_samplersFixed;		// set on first draw (can't write the uniforms until the program is in use, and we don't want to mess with cur program inside cglmprogram)
-	uint					m_revision;				// if this pair is relinked, bump this number.
-};	
-
-//===============================================================================
-
-// N-row, M-way associative cache with LRU per row.
-// still needs some metric dump ability and some parameter tuning.
-// extra credit would be to make an auto-tuner.
-
-struct CGLMPairCacheEntry
-{
-	long long		m_lastMark;				// a mark of zero means an empty entry
-	CGLMProgram		*m_vertexProg;
-	CGLMProgram		*m_fragmentProg;
-	uint			m_extraKeyBits;
-	CGLMShaderPair	*m_pair;
-};
-
-class CGLMShaderPairCache				// cache for linked GLSL shader pairs
-{
-
-public:
-
-protected:
-	friend class CGLMShaderPair;
-	friend class CGLMProgram;
-	friend class GLMContext;
-		
-	//===============================
-	
-	CGLMShaderPairCache( GLMContext *ctx  );
-	~CGLMShaderPairCache( );	
-
-	CGLMShaderPair	*SelectShaderPair	( CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits );
-	void			QueryShaderPair		( int index, GLMShaderPairInfo *infoOut );
-	
-	// shoot down linked pairs that use the program in the arg
-	// return true if any had to be skipped due to conflict with currently bound pair
-	bool			PurgePairsWithShader( CGLMProgram *prog );
-	
-	// purge everything (when would GLM know how to do this ?  at context destroy time, but any other times?)
-	// return true if any had to be skipped due to conflict with currently bound pair
-	bool			Purge				( void );
-	
-	// stats
-	void			DumpStats			( void );
-	
-	//===============================
-
-	uint			HashRowIndex		( CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits );
-	CGLMPairCacheEntry*	HashRowPtr		( uint hashRowIndex );
-	void			HashRowProbe		( CGLMPairCacheEntry *row, CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits, int *hitwayOut, int *emptywayOut, int *oldestwayOut );
-	//===============================
-
-	// common stuff
-
-	GLMContext				*m_ctx;					// link back to parent context
-
-	long long				m_mark;
-
-	uint					m_rowsLg2;
-	uint					m_rows;
-	
-	uint					m_waysLg2;
-	uint					m_ways;
-	
-	uint					m_entryCount;
-	
-	CGLMPairCacheEntry		*m_entries;				// array[ m_rows ][ m_ways ]
-
-	uint					*m_evictions;			// array[ m_rows ];
-	uint					*m_hits;				// array[ m_rows ];
-};	
-
-
-#endif
\ No newline at end of file
diff --git a/mp/src/public/togl/osx/cglmquery.h b/mp/src/public/togl/osx/cglmquery.h
deleted file mode 100644
index 1f5b1676..00000000
--- a/mp/src/public/togl/osx/cglmquery.h
+++ /dev/null
@@ -1,85 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-//
-// cglmquery.h
-//	GLMgr queries
-//
-//===============================================================================
-
-#ifndef CGLMQUERY_H
-#define	CGLMQUERY_H
-
-#pragma once
-
-//===============================================================================
-
-// forward declarations
-
-class	GLMContext;
-class	CGLMQuery;
-
-//===============================================================================
-
-enum EGLMQueryType
-{
-	EOcclusion,
-	EFence,
-	EGLMQueryCount
-};
-
-struct GLMQueryParams
-{
-	EGLMQueryType	m_type;
-};
-
-class CGLMQuery
-{
-	// leave everything public til it's running
-public:
-	friend class GLMContext;			// only GLMContext can make CGLMTex objects
-	friend class IDirect3DDevice9;
-	friend class IDirect3DQuery9;
-
-	GLMContext		*m_ctx;				// link back to parent context
-	GLMQueryParams	m_params;			// params created with
-	
-	GLuint			m_name;				// name of the query object per se - could be fence, could be query object ... NOT USED WITH GL_ARB_sync!
-#ifdef HAVE_GL_ARB_SYNC
-	GLsync			m_syncobj;			// GL_ARB_sync object. NOT USED WITH GL_NV_fence or GL_APPLE_fence!
-#else
-	GLuint			m_syncobj;
-#endif
-	
-	bool			m_started;
-	bool			m_stopped;
-	bool			m_done;
-	
-	bool			m_nullQuery;		// was gl_nullqueries true at Start time - if so, continue to act like a null query through Stop/IsDone/Complete time
-										// restated - only Start should examine the convar.
-										
-			CGLMQuery( GLMContext *ctx, GLMQueryParams *params );
-			~CGLMQuery( );
-			
-	// for an occlusion query:
-	//	Start = BeginQuery		query-start goes into stream
-	//	Stop = EndQuery			query-end goes into stream - a fence is also set so we can probe for completion
-	//	IsDone = TestFence		use the added fence to ask if query-end has passed (i.e. will Complete block?)
-	//	Complete = GetQueryObjectuivARB(uint id, enum pname, uint *params) - extract the sample count
-
-	// for a fence query:
-	//	Start = SetFence		fence goes into command stream
-	//	Stop = NOP				fences are self finishing - no need to call Stop on a fence
-	//	IsDone = TestFence		ask if fence passed
-	//	Complete = FinishFence
-
-	void	Start		( void );
-	void	Stop		( void );
-	bool	IsDone		( void );
-	void	Complete	( uint *result );
-
-	// accessors for the started/stopped state
-	bool	IsStarted	( void );
-	bool	IsStopped	( void );
-};
-
-
-#endif
diff --git a/mp/src/public/togl/osx/cglmtex.h b/mp/src/public/togl/osx/cglmtex.h
deleted file mode 100644
index 813395c7..00000000
--- a/mp/src/public/togl/osx/cglmtex.h
+++ /dev/null
@@ -1,273 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-//
-// cglmtex.h
-//	GLMgr textures
-//
-//===============================================================================
-
-#ifndef CGLMTEX_H
-#define	CGLMTEX_H
-
-#pragma once
-
-#include "tier1/utlhash.h"
-#include "tier1/utlmap.h"
-
-//===============================================================================
-
-// forward declarations
-
-class	GLMContext;
-class	GLMTester;
-class	CGLMTexLayoutTable;
-class	CGLMTex;
-class	CGLMFBO;
-
-class	IDirect3DSurface9;
-
-//===============================================================================
-
-struct GLMTexFormatDesc
-{
-	char		*m_formatSummary;	// for debug visibility
-	
-	D3DFORMAT	m_d3dFormat;		// what D3D knows it as; see public/bitmap/imageformat.h
-	
-	GLenum		m_glIntFormat;		// GL internal format
-	GLenum		m_glIntFormatSRGB;	// internal format if SRGB flavor
-	GLenum		m_glDataFormat;		// GL data format
-	GLenum		m_glDataType;		// GL data type
-	
-	int			m_chunkSize;		// 1 or 4 - 4 is used for compressed textures
-	int			m_bytesPerSquareChunk;	// how many bytes for the smallest quantum (m_chunkSize x m_chunkSize)
-									// this description lets us calculate size cleanly without conditional logic for compression
-};
-const GLMTexFormatDesc *GetFormatDesc( D3DFORMAT format );
-
-//===============================================================================
-
-// utility function for generating slabs of texels. mostly for test.
-typedef struct
-{
-	// in
-	D3DFORMAT	m_format;
-	void		*m_dest;			// dest address
-	int			m_chunkCount;		// square chunk count (single texels or compressed blocks)
-	int			m_byteCountLimit;	// caller expectation of max number of bytes to write out
-	float		r,g,b,a;			// color desired
-	
-	// out
-	int			m_bytesWritten;
-}	GLMGenTexelParams;
-
-// return true if successful
-bool	GLMGenTexels( GLMGenTexelParams *params );
-
-
-//===============================================================================
-
-struct GLMTexLayoutSlice
-{
-	int	m_xSize,m_ySize,m_zSize;		//texel dimensions of this slice
-	int	m_storageOffset;				//where in the storage slab does this slice live
-	int	m_storageSize;					//how much storage does this slice occupy
-};
-
-enum EGLMTexFlags
-{
-	kGLMTexMipped		=	0x01,
-	kGLMTexMippedAuto	=	0x02,
-	kGLMTexRenderable	=	0x04,
-	kGLMTexIsStencil	=	0x08,
-	kGLMTexIsDepth		=	0x10,
-	kGLMTexSRGB			=	0x20,
-	kGLMTexMultisampled	=	0x40,		// has an RBO backing it.  Cannot combine with Mipped, MippedAuto.  One slice maximum, only targeting GL_TEXTURE_2D.
-										// actually not 100% positive on the mipmapping, the RBO itself can't be mipped, but the resulting texture could
-										// have mipmaps generated.
-};
-
-//===============================================================================
-
-struct GLMTexLayoutKey
-{
-	// input values: held const, these are the hash key for the form map
-	GLenum				m_texGLTarget;				// flavor of texture: GL_TEXTURE_2D, GL_TEXTURE_3D, GLTEXTURE_CUBE_MAP
-	D3DFORMAT			m_texFormat;				// D3D texel format
-	unsigned long		m_texFlags;					// mipped, autogen mips, render target, ... ?
-	unsigned long		m_texSamples;				// zero for a plain tex, 2/4/6/8 for "MSAA tex" (RBO backed)
-	int					m_xSize,m_ySize,m_zSize;	// size of base mip
-};
-
-bool LessFunc_GLMTexLayoutKey( const GLMTexLayoutKey &a, const GLMTexLayoutKey &b );
-
-#define	GLM_TEX_MAX_MIPS	14
-#define	GLM_TEX_MAX_FACES	6
-#define	GLM_TEX_MAX_SLICES	(GLM_TEX_MAX_MIPS * GLM_TEX_MAX_FACES)
-
-struct GLMTexLayout
-{
-	char		*m_layoutSummary;	// for debug visibility
-
-	// const inputs used for hashing
-	GLMTexLayoutKey		m_key;
-	
-	// refcount
-	int					m_refCount;
-
-	// derived values:	
-	GLMTexFormatDesc	*m_format;					// format specific info
-	int					m_mipCount;					// derived by starying at base size and working down towards 1x1
-	int					m_faceCount;				// 1 for 2d/3d, 6 for cubemap
-	int					m_sliceCount;				// product of faces and mips
-	int					m_storageTotalSize;			// size of storage slab required
-	
-	// slice array
-	GLMTexLayoutSlice	m_slices[0];				// dynamically allocated 2-d array [faces][mips]
-};
-
-
-class	CGLMTexLayoutTable
-{
-public:
-					CGLMTexLayoutTable();
-	
-	GLMTexLayout	*NewLayoutRef( GLMTexLayoutKey *key );		// pass in a pointer to layout key - receive ptr to completed layout
-	void			DelLayoutRef( GLMTexLayout *layout );		// pass in pointer to completed layout.  refcount is dropped.
-	
-	void			DumpStats( void );
-protected:
-	CUtlMap< GLMTexLayoutKey, GLMTexLayout* >	m_layoutMap;
-};
-
-//===============================================================================
-
-// a sampler specifies desired state for drawing on a given sampler index
-// this is the combination of a texture choice and a set of sampler parameters
-// see http://msdn.microsoft.com/en-us/library/bb172602(VS.85).aspx
-
-
-struct	GLMTexSamplingParams
-{
-	GLenum	m_addressModes[3];	// S, T, R
-	GLfloat	m_borderColor[4];	// R,G,B,A
-
-	GLenum	m_magFilter;
-	GLenum	m_minFilter;
-	
-	GLfloat	m_mipmapBias;
-	GLint	m_minMipLevel;
-	GLint	m_maxMipLevel;
-	GLint	m_maxAniso;
-	GLenum	m_compareMode;		// only used for depth and stencil type textures
-	bool	m_srgb;				// srgb texture read... 
-};
-
-struct GLMTexLockParams
-{
-	// input params which identify the slice of interest
-	CGLMTex		*m_tex;
-	int			m_face;
-	int			m_mip;
-	
-	// identifies the region of the slice
-	GLMRegion	m_region;
-	
-	// tells GLM to force re-read of the texels back from GL
-	// i.e. "I know I stepped on those texels with a draw or blit - the GLM copy is stale"
-	bool		m_readback;
-};
-
-struct GLMTexLockDesc
-{
-	GLMTexLockParams	m_req;	// form of the lock request
-	
-	bool				m_active;				// set true at lock time. cleared at unlock time.
-
-	int					m_sliceIndex;			// which slice in the layout
-	int					m_sliceBaseOffset;		// where is that in the texture data
-	int					m_sliceRegionOffset;	// offset to the start (lowest address corner) of the region requested
-};
-
-//===============================================================================
-
-#define	GLM_SAMPLER_COUNT	16
-
-typedef CBitVec<GLM_SAMPLER_COUNT> CTexBindMask;
-
-enum EGLMTexSliceFlag
-{
-	kSliceValid			=	0x01,	// slice has been teximage'd in whole at least once - set to 0 initially
-	kSliceStorageValid	=	0x02,	// if backing store is available, this slice's data is a valid copy - set to 0 initially
-	kSliceLocked		=	0x04,	// are one or more locks outstanding on this slice
-	kSliceFullyDirty	=	0x08,	// does the slice need to be fully downloaded at unlock time (disregard dirty rects)
-};
-
-class CGLMTex
-{
-
-public:
-
-	void					Lock( GLMTexLockParams *params, char** addressOut, int* yStrideOut, int *zStrideOut );
-	void					Unlock( GLMTexLockParams *params );
-	
-protected:
-	friend class GLMContext;			// only GLMContext can make CGLMTex objects
-	friend class GLMTester;
-	friend class CGLMFBO;
-
-	friend class IDirect3DDevice9;
-	friend class IDirect3DBaseTexture9;
-	friend class IDirect3DTexture9;
-	friend class IDirect3DSurface9;
-	friend class IDirect3DCubeTexture9;
-	friend class IDirect3DVolumeTexture9;
-	
-			CGLMTex( GLMContext *ctx, GLMTexLayout *layout, GLMTexSamplingParams *sampling, char *debugLabel = NULL );
-			~CGLMTex( );
-	
-	int						CalcSliceIndex( int face, int mip );
-	void					CalcTexelDataOffsetAndStrides( int sliceIndex, int x, int y, int z, int *offsetOut, int *yStrideOut, int *zStrideOut );
-
-	void					ApplySamplingParams( GLMTexSamplingParams *params, bool noCheck=FALSE );
-
-	void					ReadTexels( GLMTexLockDesc *desc, bool readWholeSlice=true );
-	void					WriteTexels( GLMTexLockDesc *desc, bool writeWholeSlice=true, bool noDataWrite=false );
-		// last param lets us send NULL data ptr (only legal with uncompressed formats, beware)
-		// this helps out ResetSRGB.
-	
-	void					ResetSRGB( bool srgb, bool noDataWrite );
-		// re-specify texture format to match desired sRGB form
-		// noWrite means send NULL for texel source addresses instead of actual data - ideal for RT's
-
-	GLMTexLayout			*m_layout;		// layout of texture (shared across all tex with same layout)
-	int						m_minActiveMip;//index of lowest mip that has been written.  used to drive setting of GL_TEXTURE_MAX_LEVEL.
-	int						m_maxActiveMip;//index of highest mip that has been written.  used to drive setting of GL_TEXTURE_MAX_LEVEL.
-				
-	GLMTexSamplingParams	m_sampling;		// mirror of sampling params currently embodied in the texture
-											// (consult this at draw time, in order to know if changes need to be made)
-						
-	GLMContext				*m_ctx;			// link back to parent context
-
-	GLuint					m_texName;			// name of this texture in the context
-	bool					m_texClientStorage;	// was CS selecetd for texture
-	bool					m_texPreloaded;		// has it been kicked into VRAM with GLMContext::PreloadTex yet
-
-	GLuint					m_rboName;		// name of MSAA RBO backing the tex if MSAA enabled (or zero)
-	bool					m_rboDirty;		// has RBO been drawn on - i.e. needs to be blitted back to texture if texture is going to be sampled from
-	
-	CTexBindMask			m_bindPoints;	// true for each place in the parent ctx where currently
-											// bound (indexed via EGLMTexCtxBindingIndex)
-										
-	int						m_rtAttachCount; // how many RT's have this texture attached somewhere
-
-	char					*m_backing;		// backing storage if available
-	
-	int						m_lockCount;	// lock reqs are stored in the GLMContext for tracking
-
-	CUtlVector<unsigned char>	m_sliceFlags;
-	
-	char					*m_debugLabel;	// strdup() of debugLabel passed in, or NULL
-};
-
-
-#endif
diff --git a/mp/src/public/togl/osx/dxabstract.h b/mp/src/public/togl/osx/dxabstract.h
deleted file mode 100644
index 92f6bc32..00000000
--- a/mp/src/public/togl/osx/dxabstract.h
+++ /dev/null
@@ -1,804 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-//
-//
-//
-//==================================================================================================
-
-#ifndef DXABSTRACT_H
-#define DXABSTRACT_H
-#ifdef _WIN32
-#pragma once
-#endif
-
-#include "togl/rendermechanism.h"
-
-#include "materialsystem/ishader.h"
-
-// Uncomment this on Windows if you want to compile the Windows GL version.
-// #undef USE_ACTUAL_DX
-
-#ifdef USE_ACTUAL_DX
-
-#ifndef WIN32
-#error sorry man
-#endif
-#ifdef _X360
-#include "d3d9.h"
-#include "d3dx9.h"
-#else
-#include <windows.h>
-#include "../../dx9sdk/include/d3d9.h"
-#include "../../dx9sdk/include/d3dx9.h"
-#endif
-typedef HWND VD3DHWND;
-
-#else
-
-#ifdef WIN32
-#error Gl on win32?
-#endif
-
-#include "tier0/platform.h"
-
-#ifndef DX_TO_GL_ABSTRACTION
-#define DX_TO_GL_ABSTRACTION
-#endif
-
-#include "bitmap/imageformat.h"
-#include "togl/rendermechanism.h"
-
-#ifdef OSX
-extern "C" void Debugger(void);
-#endif
-
-// turn this on to get refcount logging from IUnknown
-#define	IUNKNOWN_ALLOC_SPEW 0
-#define	IUNKNOWN_ALLOC_SPEW_MARK_ALL 0	
-
-
-// ------------------------------------------------------------------------------------------------------------------------------ //
-// DEFINES
-// ------------------------------------------------------------------------------------------------------------------------------ //
-
-typedef void* VD3DHWND;
-typedef void* VD3DHANDLE;
-
-
-TOGL_INTERFACE void toglGetClientRect( VD3DHWND hWnd, RECT *destRect );
-
-struct TOGL_CLASS IUnknown
-{
-	int	m_refcount[2];
-	bool m_mark;
-		
-	IUnknown( void )
-	{
-		m_refcount[0] = 1;
-		m_refcount[1] = 0;
-		m_mark = (IUNKNOWN_ALLOC_SPEW_MARK_ALL != 0);	// either all are marked, or only the ones that have SetMark(true) called on them
-
-		#if IUNKNOWN_ALLOC_SPEW
-			if (m_mark)
-			{
-				GLMPRINTF(("-A- IUnew (%08x) refc -> (%d,%d) ",this,m_refcount[0],m_refcount[1]));
-			}
-		#endif
-	};
-				
-	virtual	~IUnknown( void )
-	{
-		#if IUNKNOWN_ALLOC_SPEW
-			if (m_mark)
-			{
-				GLMPRINTF(("-A- IUdel (%08x) ",this ));
-			}
-		#endif
-	};
-		
-	void	AddRef( int which=0, char *comment = NULL )
-	{
-		Assert( which >= 0 );
-		Assert( which < 2 );
-		m_refcount[which]++;
-			
-		#if IUNKNOWN_ALLOC_SPEW
-			if (m_mark)
-			{
-				GLMPRINTF(("-A- IUAddRef  (%08x,%d) refc -> (%d,%d) [%s]",this,which,m_refcount[0],m_refcount[1],comment?comment:"..."))	;
-				if (!comment)
-				{
-					GLMPRINTF((""))	;	// place to hang a breakpoint
-				}
-			}
-		#endif
-	};
-		
-	ULONG __stdcall	Release( int which=0, char *comment = NULL )
-	{
-		Assert( which >= 0 );
-		Assert( which < 2 );
-			
-		//int oldrefcs[2] = { m_refcount[0], m_refcount[1] };
-		bool deleting = false;
-			
-		m_refcount[which]--;
-		if ( (!m_refcount[0]) && (!m_refcount[1]) )
-		{
-			deleting = true;
-		}
-			
-		#if IUNKNOWN_ALLOC_SPEW
-			if (m_mark)
-			{
-				GLMPRINTF(("-A- IURelease (%08x,%d) refc -> (%d,%d) [%s] %s",this,which,m_refcount[0],m_refcount[1],comment?comment:"...",deleting?"->DELETING":""));
-				if (!comment)
-				{
-					GLMPRINTF((""))	;	// place to hang a breakpoint
-				}
-			}
-		#endif
-
-		if (deleting)
-		{
-			if (m_mark)
-			{
-				GLMPRINTF((""))	;		// place to hang a breakpoint
-			}
-			delete this;
-			return 0;
-		}
-		else
-		{
-			return m_refcount[0];
-		}
-	};
-		
-	void	SetMark( bool markValue, char *comment=NULL )
-	{
-		#if IUNKNOWN_ALLOC_SPEW
-			if (!m_mark && markValue)	// leading edge detect
-			{
-				// print the same thing that the constructor would have printed if it had been marked from the beginning
-				// i.e. it's anticipated that callers asking for marking will do so right at create time
-				GLMPRINTF(("-A- IUSetMark (%08x) refc -> (%d,%d) (%s) ",this,m_refcount[0],m_refcount[1],comment?comment:"..."));
-			}
-		#endif
-
-		m_mark = markValue;
-	}
-};
-
-
-// ------------------------------------------------------------------------------------------------------------------------------ //
-// INTERFACES
-// ------------------------------------------------------------------------------------------------------------------------------ //
-
-struct TOGL_CLASS IDirect3DResource9 : public IUnknown
-{
-	IDirect3DDevice9	*m_device;		// parent device
-	D3DRESOURCETYPE		m_restype;
-	
-	DWORD SetPriority(DWORD PriorityNew);
-};
-
-struct TOGL_CLASS IDirect3DBaseTexture9 : public IDirect3DResource9						// "A Texture.."
-{	
-	D3DSURFACE_DESC			m_descZero;			// desc of top level.
-	CGLMTex					*m_tex;				// a CGLMTex can represent all forms of tex
-	int						m_srgbFlipCount;
-
-	virtual					~IDirect3DBaseTexture9();
-    D3DRESOURCETYPE			GetType();
-    DWORD					GetLevelCount();
-	HRESULT					GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc);
-};
-
-struct TOGL_CLASS IDirect3DTexture9 : public IDirect3DBaseTexture9							// "Texture 2D"
-{	
-	IDirect3DSurface9		*m_surfZero;			// surf of top level.
-
-	virtual					~IDirect3DTexture9();
-
-    HRESULT					LockRect(UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags);
-    HRESULT					UnlockRect(UINT Level);
-    HRESULT					GetSurfaceLevel(UINT Level,IDirect3DSurface9** ppSurfaceLevel);
-};
-
-struct TOGL_CLASS IDirect3DCubeTexture9 : public IDirect3DBaseTexture9						// "Texture Cube Map"
-{
-	IDirect3DSurface9		*m_surfZero[6];			// surfs of top level.
-
-	virtual					~IDirect3DCubeTexture9();
-
-    HRESULT					GetCubeMapSurface(D3DCUBEMAP_FACES FaceType,UINT Level,IDirect3DSurface9** ppCubeMapSurface);
-    HRESULT					GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc);
-};
-
-struct TOGL_CLASS IDirect3DVolumeTexture9 : public IDirect3DBaseTexture9					// "Texture 3D"
-{
-	IDirect3DSurface9		*m_surfZero;			// surf of top level.
-	D3DVOLUME_DESC			m_volDescZero;			// volume desc top level
-
-	virtual					~IDirect3DVolumeTexture9();
-
-    HRESULT					LockBox(UINT Level,D3DLOCKED_BOX* pLockedVolume,CONST D3DBOX* pBox,DWORD Flags);
-    HRESULT					UnlockBox(UINT Level);
-	HRESULT					GetLevelDesc( UINT level, D3DVOLUME_DESC *pDesc );
-};
-
-
-// for the moment, a "D3D surface" is modeled as a GLM tex, a face, and a mip.
-// no Create method, these are filled in by the various create surface methods.	
-
-struct TOGL_CLASS IDirect3DSurface9 : public IDirect3DResource9
-{
-	virtual					~IDirect3DSurface9();
-
-    HRESULT					LockRect(D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags);
-    HRESULT					UnlockRect();
-	HRESULT					GetDesc(D3DSURFACE_DESC *pDesc);
-
-	D3DSURFACE_DESC			m_desc;
-	CGLMTex					*m_tex;
-	int						m_face;
-	int						m_mip;
-};
-
-
-
-struct TOGL_CLASS IDirect3D9 : public IUnknown
-{
-public:
-	virtual	~IDirect3D9();
-
-	UINT	GetAdapterCount();			//cheese: returns 1
-
-    HRESULT GetDeviceCaps				(UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps);
-    HRESULT GetAdapterIdentifier		(UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER9* pIdentifier);
-    HRESULT CheckDeviceFormat			(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat);
-    UINT	GetAdapterModeCount			(UINT Adapter,D3DFORMAT Format);
-    HRESULT EnumAdapterModes			(UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode);
-    HRESULT CheckDeviceType				(UINT Adapter,D3DDEVTYPE DevType,D3DFORMAT AdapterFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed);
-    HRESULT GetAdapterDisplayMode		(UINT Adapter,D3DDISPLAYMODE* pMode);
-    HRESULT CheckDepthStencilMatch		(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat);
-    HRESULT CheckDeviceMultiSampleType	(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType,DWORD* pQualityLevels);
-
-    HRESULT CreateDevice				(UINT Adapter,D3DDEVTYPE DeviceType,VD3DHWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice9** ppReturnedDeviceInterface);
-};
-
-struct TOGL_CLASS IDirect3DSwapChain9 : public IUnknown
-{
-};
-
-
-
-	//	typedef enum D3DDECLUSAGE
-	//	{
-	//		D3DDECLUSAGE_POSITION = 0,
-	//		D3DDECLUSAGE_BLENDWEIGHT = 1,
-	//		D3DDECLUSAGE_BLENDINDICES = 2,
-	//		D3DDECLUSAGE_NORMAL = 3,
-	//		D3DDECLUSAGE_PSIZE = 4,
-	//		D3DDECLUSAGE_TEXCOORD = 5,
-	//		D3DDECLUSAGE_TANGENT = 6,
-	//		D3DDECLUSAGE_BINORMAL = 7,
-	//		D3DDECLUSAGE_TESSFACTOR = 8,
-	//		D3DDECLUSAGE_POSITIONT = 9,
-	//		D3DDECLUSAGE_COLOR = 10,
-	//		D3DDECLUSAGE_FOG = 11,
-	//		D3DDECLUSAGE_DEPTH = 12,
-	//		D3DDECLUSAGE_SAMPLE = 13,
-	//	} D3DDECLUSAGE, *LPD3DDECLUSAGE;
-	//	Constants
-	//	
-	//	D3DDECLUSAGE_POSITION
-	//	Position data ranging from (-1,-1) to (1,1). Use D3DDECLUSAGE_POSITION with
-	//	a usage index of 0 to specify untransformed position for fixed function
-	//	vertex processing and the n-patch tessellator. Use D3DDECLUSAGE_POSITION
-	//	with a usage index of 1 to specify untransformed position in the fixed
-	//	function vertex shader for vertex tweening.
-	//	
-	//	D3DDECLUSAGE_BLENDWEIGHT
-	//	Blending weight data. Use D3DDECLUSAGE_BLENDWEIGHT with a usage index of 0
-	//	to specify the blend weights used in indexed and nonindexed vertex
-	//	blending.
-	//	
-	//	D3DDECLUSAGE_BLENDINDICES
-	//	Blending indices data. Use D3DDECLUSAGE_BLENDINDICES with a usage index of
-	//	0 to specify matrix indices for indexed paletted skinning.
-	//	
-	//	D3DDECLUSAGE_NORMAL
-	//	Vertex normal data. Use D3DDECLUSAGE_NORMAL with a usage index of 0 to
-	//	specify vertex normals for fixed function vertex processing and the n-patch
-	//	tessellator. Use D3DDECLUSAGE_NORMAL with a usage index of 1 to specify
-	//	vertex normals for fixed function vertex processing for vertex tweening.
-	//	
-	//	D3DDECLUSAGE_PSIZE
-	//	Point size data. Use D3DDECLUSAGE_PSIZE with a usage index of 0 to specify
-	//	the point-size attribute used by the setup engine of the rasterizer to
-	//	expand a point into a quad for the point-sprite functionality.
-	//	
-	//	D3DDECLUSAGE_TEXCOORD
-	//	Texture coordinate data. Use D3DDECLUSAGE_TEXCOORD, n to specify texture
-	//	coordinates in fixed function vertex processing and in pixel shaders prior
-	//	to ps_3_0. These can be used to pass user defined data.
-	//	
-	//	D3DDECLUSAGE_TANGENT
-	//	Vertex tangent data.
-	//	
-	//	D3DDECLUSAGE_BINORMAL
-	//	Vertex binormal data.
-	//	
-	//	D3DDECLUSAGE_TESSFACTOR
-	//	Single positive floating point value. Use D3DDECLUSAGE_TESSFACTOR with a
-	//	usage index of 0 to specify a tessellation factor used in the tessellation
-	//	unit to control the rate of tessellation. For more information about the
-	//	data type, see D3DDECLTYPE_FLOAT1.
-	//	
-	//	D3DDECLUSAGE_POSITIONT
-	//	Vertex data contains transformed position data ranging from (0,0) to
-	//	(viewport width, viewport height). Use D3DDECLUSAGE_POSITIONT with a usage
-	//	index of 0 to specify transformed position. When a declaration containing
-	//	this is set, the pipeline does not perform vertex processing.
-	//	
-	//	D3DDECLUSAGE_COLOR
-	//	Vertex data contains diffuse or specular color. Use D3DDECLUSAGE_COLOR with
-	//	a usage index of 0 to specify the diffuse color in the fixed function
-	//	vertex shader and pixel shaders prior to ps_3_0. Use D3DDECLUSAGE_COLOR
-	//	with a usage index of 1 to specify the specular color in the fixed function
-	//	vertex shader and pixel shaders prior to ps_3_0.
-	//	
-	//	D3DDECLUSAGE_FOG
-	//	Vertex data contains fog data. Use D3DDECLUSAGE_FOG with a usage index of 0
-	//	to specify a fog blend value used after pixel shading finishes. This
-	//	applies to pixel shaders prior to version ps_3_0.
-	//	
-	//	D3DDECLUSAGE_DEPTH
-	//	Vertex data contains depth data.
-	//	
-	//	D3DDECLUSAGE_SAMPLE
-	//	Vertex data contains sampler data. Use D3DDECLUSAGE_SAMPLE with a usage
-	//	index of 0 to specify the displacement value to look up. It can be used
-	//	only with D3DDECLUSAGE_LOOKUPPRESAMPLED or D3DDECLUSAGE_LOOKUP.
-
-	//note the form of the list terminator..
-
-	//	#define D3DDECL_END() {0xFF,0,D3DDECLTYPE_UNUSED,0,0,0}
-	//	typedef struct _D3DVERTEXELEMENT9
-	//	{
-	//		WORD    Stream;     // Stream index
-	//		WORD    Offset;     // Offset in the stream in bytes
-	//		BYTE    Type;       // Data type
-	//		BYTE    Method;     // Processing method
-	//		BYTE    Usage;      // Semantics
-	//		BYTE    UsageIndex; // Semantic index
-	//	} D3DVERTEXELEMENT9, *LPD3DVERTEXELEMENT9;
-
-#define MAX_D3DVERTEXELEMENTS	16
-
-struct TOGL_CLASS IDirect3DVertexDeclaration9 : public IUnknown
-{
-//public:
-	uint					m_elemCount;
-	D3DVERTEXELEMENT9_GL	m_elements[ MAX_D3DVERTEXELEMENTS ];
-
-	virtual					~IDirect3DVertexDeclaration9();
-};
-
-struct TOGL_CLASS IDirect3DQuery9 : public IDirect3DResource9	//was IUnknown
-{
-//public:
-	D3DQUERYTYPE			m_type;		// D3DQUERYTYPE_OCCLUSION or D3DQUERYTYPE_EVENT
-	GLMContext				*m_ctx;
-	CGLMQuery				*m_query;
-	
-	virtual					~IDirect3DQuery9();
-
-    HRESULT					Issue(DWORD dwIssueFlags);
-    HRESULT					GetData(void* pData,DWORD dwSize,DWORD dwGetDataFlags);
-};
-
-struct TOGL_CLASS IDirect3DVertexBuffer9 : public IDirect3DResource9	//was IUnknown
-{
-//public:
-	GLMContext				*m_ctx;
-	CGLMBuffer				*m_vtxBuffer;
-	D3DVERTEXBUFFER_DESC	m_vtxDesc;		// to satisfy GetDesc
-
-	virtual					~IDirect3DVertexBuffer9();
-    HRESULT					Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags);
-    HRESULT					Unlock();
-	HRESULT					UnlockActualSize( uint nActualSize, const void *pActualData = NULL );
-
-};
-
-struct TOGL_CLASS IDirect3DIndexBuffer9 : public IDirect3DResource9	//was IUnknown
-{
-//public:
-	GLMContext				*m_ctx;
-	CGLMBuffer				*m_idxBuffer;
-	D3DINDEXBUFFER_DESC		m_idxDesc;		// to satisfy GetDesc
-	
-	virtual					~IDirect3DIndexBuffer9();
-
-    HRESULT					Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags);
-    HRESULT					Unlock();
-	HRESULT					UnlockActualSize( uint nActualSize, const void *pActualData = NULL );
-    HRESULT					GetDesc(D3DINDEXBUFFER_DESC *pDesc);
-};
-
-struct TOGL_CLASS IDirect3DPixelShader9 : public IDirect3DResource9	//was IUnknown
-{
-//public:
-	CGLMProgram				*m_pixProgram;
-	uint					m_pixHighWater;		// count of active constant slots referenced by shader.
-	uint					m_pixSamplerMask;	// (1<<n) mask of samplers referemnced by this pixel shader
-												// this can help FlushSamplers avoid SRGB flipping on textures not being referenced...
-
-	virtual					~IDirect3DPixelShader9();
-};
-
-struct TOGL_CLASS IDirect3DVertexShader9 : public IDirect3DResource9	//was IUnknown
-{
-//public:
-	CGLMProgram				*m_vtxProgram;
-	uint					m_vtxHighWater;		// count of active constant slots referenced by shader.
-	unsigned char			m_vtxAttribMap[16];	// high nibble is usage, low nibble is usageindex, array position is attrib number
-
-	virtual					~IDirect3DVertexShader9();
-
-};
-
-struct TOGL_CLASS ID3DXMatrixStack : public IUnknown
-{
-//public:
-	CUtlVector<D3DMATRIX>	m_stack;
-	int						m_stackTop;	// top of stack is at the highest index, this is that index.  push increases, pop decreases.
-	
-	HRESULT	Create( void );
-	
-    D3DXMATRIX* GetTop();
-	void Push();
-	void Pop();
-	void LoadIdentity();
-	void LoadMatrix( const D3DXMATRIX *pMat );
-	void MultMatrix( const D3DXMATRIX *pMat );
-	void MultMatrixLocal( const D3DXMATRIX *pMat );
-    HRESULT ScaleLocal(FLOAT x, FLOAT y, FLOAT z);
-
-	// Left multiply the current matrix with the computed rotation
-    // matrix, counterclockwise about the given axis with the given angle.
-    // (rotation is about the local origin of the object)
-    HRESULT RotateAxisLocal(CONST D3DXVECTOR3* pV, FLOAT Angle);
-
-	// Left multiply the current matrix with the computed translation
-    // matrix. (transformation is about the local origin of the object)
-    HRESULT TranslateLocal(FLOAT x, FLOAT y, FLOAT z);
-};
-typedef ID3DXMatrixStack* LPD3DXMATRIXSTACK;
-
-struct TOGL_CLASS IDirect3DDevice9 : public IUnknown
-{
-public:
-	// members
-	
-	IDirect3DDevice9Params	m_params;						// mirror of the creation inputs
-
-	// D3D flavor stuff
-	IDirect3DSurface9			*m_rtSurfaces[16];				// current color RT surfaces. [0] is initially == m_defaultColorSurface
-	IDirect3DSurface9			*m_dsSurface;					// current DS RT surface. can be changed!
-	
-	IDirect3DSurface9			*m_defaultColorSurface;			// default color surface.
-	IDirect3DSurface9			*m_defaultDepthStencilSurface;	// queried by GetDepthStencilSurface.
-	
-	IDirect3DVertexDeclaration9	*m_vertDecl;					// Set by SetVertexDeclaration...
-	D3DStreamDesc				m_streams[ D3D_MAX_STREAMS ];	// Set by SetStreamSource..
-	D3DIndexDesc				m_indices;						// Set by SetIndices..
-	
-	IDirect3DVertexShader9		*m_vertexShader;				// Set by SetVertexShader...
-	IDirect3DPixelShader9		*m_pixelShader;					// Set by SetPixelShader...
-
-	IDirect3DBaseTexture9		*m_textures[16];				// set by SetTexture... NULL if stage inactive
-	D3DSamplerDesc				m_samplers[16];					// set by SetSamplerState..
-	// GLM flavor stuff
-	GLMContext					*m_ctx;
-	CGLMFBO						*m_drawableFBO;					// this FBO should have all the attachments set to match m_rtSurfaces and m_dsSurface.
-	
-	// GL state 
-	struct 
-	{
-		// render state buckets
-		GLAlphaTestEnable_t			m_AlphaTestEnable;
-		GLAlphaTestFunc_t			m_AlphaTestFunc;
-
-		GLAlphaToCoverageEnable_t	m_AlphaToCoverageEnable;
-		
-		GLDepthTestEnable_t			m_DepthTestEnable;
-		GLDepthMask_t				m_DepthMask;
-		GLDepthFunc_t				m_DepthFunc;
-
-		GLClipPlaneEnable_t			m_ClipPlaneEnable[kGLMUserClipPlanes];
-		GLClipPlaneEquation_t		m_ClipPlaneEquation[kGLMUserClipPlanes];
-		
-		GLColorMaskSingle_t			m_ColorMaskSingle;
-		GLColorMaskMultiple_t		m_ColorMaskMultiple;
-		
-		GLCullFaceEnable_t			m_CullFaceEnable;
-		GLCullFrontFace_t			m_CullFrontFace;
-		GLPolygonMode_t				m_PolygonMode;
-		GLDepthBias_t				m_DepthBias;
-		GLScissorEnable_t			m_ScissorEnable;
-		GLScissorBox_t				m_ScissorBox;
-		GLViewportBox_t				m_ViewportBox;
-		GLViewportDepthRange_t		m_ViewportDepthRange;
-
-		GLBlendEnable_t				m_BlendEnable;
-		GLBlendFactor_t				m_BlendFactor;
-		GLBlendEquation_t			m_BlendEquation;
-		GLBlendColor_t				m_BlendColor;
-		GLBlendEnableSRGB_t			m_BlendEnableSRGB;
-
-		GLStencilTestEnable_t		m_StencilTestEnable;
-		GLStencilFunc_t				m_StencilFunc;
-		GLStencilOp_t				m_StencilOp;
-		GLStencilWriteMask_t		m_StencilWriteMask;
-
-		GLClearColor_t				m_ClearColor;
-		GLClearDepth_t				m_ClearDepth;
-		GLClearStencil_t			m_ClearStencil;
-		
-		bool						m_FogEnable;			// not really pushed to GL, just latched here
-		
-		// samplers
-		GLMTexSamplingParams		m_samplers[ 16 ];
-		
-		// bindings...hmmm...		
-
-		// dirty-bits
-		uint						m_stateDirtyMask;		// covers the state blocks, indexed by 1<<n, n = EGLMStateBlockType
-		uint						m_samplerDirtyMask;		// covers the samplers, indexed 1<<n, n = sampler index
-	}	gl;
-	
-	// methods
-
-public:
-	virtual					~IDirect3DDevice9();
-	
-	// Create call invoked from IDirect3D9
-	HRESULT	Create( IDirect3DDevice9Params *params );
-	
-	//
-	// Basics
-	//
-	HRESULT Reset(D3DPRESENT_PARAMETERS* pPresentationParameters);
-	HRESULT SetViewport(CONST D3DVIEWPORT9* pViewport);
-	HRESULT GetViewport(D3DVIEWPORT9* pViewport);
-    HRESULT BeginScene();
-	HRESULT Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil);
-    HRESULT EndScene();
-    HRESULT Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,VD3DHWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion);
-
-	// textures
-	HRESULT CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
-    HRESULT CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9** ppCubeTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
-    HRESULT CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9** ppVolumeTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
-	
-	HRESULT SetTexture(DWORD Stage,IDirect3DBaseTexture9* pTexture);
-    HRESULT GetTexture(DWORD Stage,IDirect3DBaseTexture9** ppTexture);
-
-	// render targets, color and depthstencil, surfaces, blit
-    HRESULT CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
-    HRESULT SetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9* pRenderTarget);
-    HRESULT GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget);
-
-    HRESULT CreateOffscreenPlainSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle);
-
-    HRESULT CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle);
-    HRESULT SetDepthStencilSurface(IDirect3DSurface9* pNewZStencil);
-    HRESULT GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface);
-
-	HRESULT GetRenderTargetData(IDirect3DSurface9* pRenderTarget,IDirect3DSurface9* pDestSurface);	// ? is anyone using this ?
-    HRESULT GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9* pDestSurface);
-    HRESULT StretchRect(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter);
-
-	// pixel shaders
-    HRESULT CreatePixelShader(CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader, const char *pShaderName, char *debugLabel = NULL);
-	HRESULT SetPixelShader(IDirect3DPixelShader9* pShader);
-    HRESULT SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);
-    HRESULT SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT  BoolCount);
-    HRESULT SetPixelShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount);
-
-	// vertex shaders
-    HRESULT CreateVertexShader(CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader, const char *pShaderName, char *debugLabel = NULL);
-    HRESULT SetVertexShader(IDirect3DVertexShader9* pShader);
-    HRESULT SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);
-    HRESULT SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT  BoolCount);
-    HRESULT SetVertexShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount);
-
-	// POSIX only - preheating for a specific vertex/pixel shader pair - trigger GLSL link inside GLM
-	HRESULT LinkShaderPair( IDirect3DVertexShader9* vs, IDirect3DPixelShader9* ps );
-	HRESULT QueryShaderPair( int index, GLMShaderPairInfo *infoOut );
-	
-	// vertex buffers
-    HRESULT CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl);
-	HRESULT SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl);
-
-    HRESULT SetFVF(DWORD FVF);		// we might not be using these ?
-	HRESULT GetFVF(DWORD* pFVF);
-
-    HRESULT CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9** ppVertexBuffer,VD3DHANDLE* pSharedHandle);
-    HRESULT SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride);
-
-	// index buffers
-    HRESULT CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,VD3DHANDLE* pSharedHandle);
-    HRESULT SetIndices(IDirect3DIndexBuffer9* pIndexData);
-
-	// response to retired objects (when refcount goes to zero and they self-delete..)
-	void	ReleasedTexture			( IDirect3DBaseTexture9 *baseTex );			// called from texture destructor - need to scrub samplers	
-	void	ReleasedSurface			( IDirect3DSurface9 *surface );				// called from any surface destructor - need to scrub RT table if an RT
-	void	ReleasedPixelShader		( IDirect3DPixelShader9 *pixelShader );		// called from IDirect3DPixelShader9 destructor
-	void	ReleasedVertexShader	( IDirect3DVertexShader9 *vertexShader );	// called from IDirect3DVertexShader9 destructor
-	void	ReleasedVertexBuffer	( IDirect3DVertexBuffer9 *vertexBuffer );	// called from IDirect3DVertexBuffer9 destructor
-	void	ReleasedIndexBuffer		( IDirect3DIndexBuffer9 *indexBuffer );		// called from IDirect3DIndexBuffer9 destructor
-	void	ReleasedQuery			( IDirect3DQuery9 *query );					// called from IDirect3DQuery9 destructor
-
-	// State management.
-	HRESULT SetRenderStateInline(D3DRENDERSTATETYPE State,DWORD Value);
-	HRESULT SetRenderStateConstInline(D3DRENDERSTATETYPE State,DWORD Value);
-	HRESULT SetRenderState(D3DRENDERSTATETYPE State,DWORD Value);
-	HRESULT SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value);
-
-
-	// Flushing changes to GL
-	HRESULT FlushStates( uint mask );
-	HRESULT FlushSamplers( uint mask );		// push SetRenderState and SetSamplerState changes
-	HRESULT FlushIndexBindings( void );		// push index buffer (set index ptr)
-	HRESULT	FlushVertexBindings( uint baseVertexIndex );	// push vertex streams (set attrib ptrs)
-	HRESULT FlushGLM( void );
-	
-	// Draw.
-    HRESULT DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount);
-    HRESULT DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount);
-	HRESULT DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride);
-
-	// misc
-    BOOL ShowCursor(BOOL bShow);
-    HRESULT ValidateDevice(DWORD* pNumPasses);
-    HRESULT SetMaterial(CONST D3DMATERIAL9* pMaterial);
-    HRESULT LightEnable(DWORD Index,BOOL Enable);
-    HRESULT SetScissorRect(CONST RECT* pRect);
-	HRESULT CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery);
-    HRESULT GetDeviceCaps(D3DCAPS9* pCaps);
-    HRESULT TestCooperativeLevel();
-    HRESULT EvictManagedResources();
-    HRESULT SetLight(DWORD Index,CONST D3DLIGHT9*);
-    void SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp);
-
-	void SaveGLState();
-	void RestoreGLState();
-
-	// Talk to JasonM about this one. It's tricky in GL.
-    HRESULT SetClipPlane(DWORD Index,CONST float* pPlane);
-
-	//
-	//
-	// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
-	//
-	//
-    HRESULT SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix);
-    HRESULT SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value);	
-
-	void AcquireThreadOwnership( );
-	void ReleaseThreadOwnership( );
-	inline DWORD GetCurrentOwnerThreadId() const { return m_ctx->m_nCurOwnerThreadId; }
-
-};
-
-struct ID3DXInclude
-{
-    virtual HRESULT Open(D3DXINCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes) = 0;
-    virtual HRESULT Close(LPCVOID pData) = 0;
-};
-typedef ID3DXInclude* LPD3DXINCLUDE;
-
-
-struct TOGL_CLASS ID3DXBuffer : public IUnknown
-{
-    void* GetBufferPointer();
-    DWORD GetBufferSize();
-};
-
-typedef ID3DXBuffer* LPD3DXBUFFER;
-
-class TOGL_CLASS ID3DXConstantTable : public IUnknown
-{
-};
-typedef ID3DXConstantTable* LPD3DXCONSTANTTABLE;
-
-
-
-// ------------------------------------------------------------------------------------------------------------------------------ //
-// D3DX stuff.
-// ------------------------------------------------------------------------------------------------------------------------------ //
-
-TOGL_INTERFACE const char* D3DXGetPixelShaderProfile( IDirect3DDevice9 *pDevice );
-
-
-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixMultiply( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM1, CONST D3DXMATRIX *pM2 );
-TOGL_INTERFACE D3DXVECTOR3* D3DXVec3TransformCoord( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM );
-
-TOGL_INTERFACE  HRESULT D3DXCreateMatrixStack( DWORD Flags, LPD3DXMATRIXSTACK* ppStack);
-TOGL_INTERFACE void D3DXMatrixIdentity( D3DXMATRIX * );
-
-TOGL_INTERFACE D3DXINLINE D3DXVECTOR3* D3DXVec3Subtract( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
-{
-    pOut->x = pV1->x - pV2->x;
-    pOut->y = pV1->y - pV2->y;
-    pOut->z = pV1->z - pV2->z;
-    return pOut;
-}
-
-TOGL_INTERFACE D3DXINLINE D3DXVECTOR3* D3DXVec3Cross( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
-{
-    D3DXVECTOR3 v;
-
-    v.x = pV1->y * pV2->z - pV1->z * pV2->y;
-    v.y = pV1->z * pV2->x - pV1->x * pV2->z;
-    v.z = pV1->x * pV2->y - pV1->y * pV2->x;
-
-    *pOut = v;
-    return pOut;
-}
-
-TOGL_INTERFACE D3DXINLINE FLOAT D3DXVec3Dot( CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
-{
-    return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z;
-}
-
-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixInverse( D3DXMATRIX *pOut, FLOAT *pDeterminant, CONST D3DXMATRIX *pM );
-
-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixTranspose( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM );
-
-TOGL_INTERFACE D3DXPLANE* D3DXPlaneNormalize( D3DXPLANE *pOut, CONST D3DXPLANE *pP);
-
-TOGL_INTERFACE D3DXVECTOR4* D3DXVec4Transform( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, CONST D3DXMATRIX *pM );
-
-
-TOGL_INTERFACE D3DXVECTOR4* D3DXVec4Normalize( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV );
-
-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixTranslation( D3DXMATRIX *pOut, FLOAT x, FLOAT y, FLOAT z );
-
-// Build an ortho projection matrix. (right-handed)
-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixOrthoOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn,FLOAT zf );
-
-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixPerspectiveRH( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf );
-
-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixPerspectiveOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf );
-
-// Transform a plane by a matrix.  The vector (a,b,c) must be normal.
-// M should be the inverse transpose of the transformation desired.
-TOGL_INTERFACE D3DXPLANE* D3DXPlaneTransform( D3DXPLANE *pOut, CONST D3DXPLANE *pP, CONST D3DXMATRIX *pM );
-
-TOGL_INTERFACE IDirect3D9 *Direct3DCreate9(UINT SDKVersion);
-
-TOGL_INTERFACE void D3DPERF_SetOptions( DWORD dwOptions );
-
-TOGL_INTERFACE HRESULT D3DXCompileShader(
-        LPCSTR                          pSrcData,
-        UINT                            SrcDataLen,
-        CONST D3DXMACRO*                pDefines,
-        LPD3DXINCLUDE                   pInclude,
-        LPCSTR                          pFunctionName,
-        LPCSTR                          pProfile,
-        DWORD                           Flags,
-        LPD3DXBUFFER*                   ppShader,
-        LPD3DXBUFFER*                   ppErrorMsgs,
-        LPD3DXCONSTANTTABLE*            ppConstantTable);
-
-
-#endif // USE_ACTUAL_DX
-
-// fake D3D usage constant for SRGB tex creation
-#define D3DUSAGE_TEXTURE_SRGB (0x80000000L)
-
-#endif // DXABSTRACT_H
diff --git a/mp/src/public/togl/osx/dxabstract_types.h b/mp/src/public/togl/osx/dxabstract_types.h
deleted file mode 100644
index 6ecc82f0..00000000
--- a/mp/src/public/togl/osx/dxabstract_types.h
+++ /dev/null
@@ -1,1710 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-//
-// dxabstract_types.h
-//
-//==================================================================================================
-#ifndef DXABSTRACT_TYPES_H
-#define DXABSTRACT_TYPES_H
-
-#pragma once
-
-#if GL_BATCH_PERF_ANALYSIS
-	class simple_bitmap;
-#endif
-
-struct IUnknown;
-struct IDirect3D9;
-struct IDirect3DDevice9;
-struct IDirect3DResource9;
-struct IDirect3DBaseTexture9;
-struct IDirect3DTexture9;
-struct IDirect3DCubeTexture9;
-struct IDirect3DVolumeTexture9;
-struct IDirect3DSurface9;
-struct IDirect3DVertexDeclaration9;
-struct IDirect3DQuery9;
-struct IDirect3DVertexBuffer9;
-struct IDirect3DIndexBuffer9;
-struct IDirect3DPixelShader9;
-struct IDirect3DVertexShader9;
-struct IDirect3DDevice9Params;
-
-class GLMContext;
-struct GLMRect;
-struct GLMShaderPairInfo;
-class CGLMBuffer;
-class CGLMQuery;
-class CGLMTex;
-class CGLMProgram;
-class CGLMFBO;
-
-#ifdef TOGL_DLL_EXPORT
-	#define TOGL_INTERFACE	DLL_EXPORT
-	#define TOGL_OVERLOAD	DLL_GLOBAL_EXPORT
-	#define TOGL_CLASS		DLL_CLASS_EXPORT
-	#define TOGL_GLOBAL		DLL_GLOBAL_EXPORT
-#else
-	#define TOGL_INTERFACE	DLL_IMPORT
-	#define TOGL_OVERLOAD	DLL_GLOBAL_IMPORT
-	#define TOGL_CLASS		DLL_CLASS_IMPORT
-	#define TOGL_GLOBAL		DLL_GLOBAL_IMPORT
-#endif
-
-#define TOGLMETHODCALLTYPE       __stdcall
-//#define TOGLMETHODCALLTYPE
-
-#define DXABSTRACT_BREAK_ON_ERROR() DebuggerBreak()
-
-typedef void* VD3DHWND;
-typedef void* VD3DHANDLE;
-
-#define MAKEFOURCC(ch0, ch1, ch2, ch3) ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
-
-//
-//
-// Stuff that would be in windows.h
-//
-//
-#if !defined(_WINNT_)
-
-	typedef int INT;
-	typedef unsigned long ULONG;
-	typedef long LONG;
-	typedef float FLOAT;
-	typedef unsigned short WORD;
-	typedef long long LONGLONG;
-	typedef unsigned int UINT;
-	typedef long HRESULT;
-	typedef unsigned char BYTE;
-	#define CONST const
-		
-	#if defined(POSIX)
-		typedef size_t ULONG_PTR;
-	#else
-		typedef unsigned long ULONG_PTR;
-	#endif
-
-	typedef ULONG_PTR SIZE_T;
-
-	typedef const char* LPCSTR;
-	typedef char* LPSTR;
-#ifndef OSX
-	typedef unsigned int DWORD;
-	typedef DWORD* LPDWORD;
-#endif
-
-
-	#define ZeroMemory RtlZeroMemory
-	#define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length))
-
-	typedef union _LARGE_INTEGER 
-	{
-		struct 
-		{
-			DWORD LowPart;
-			LONG HighPart;
-		};
-		struct 
-		{
-			DWORD LowPart;
-			LONG HighPart;
-		} u;
-		LONGLONG QuadPart;
-	} LARGE_INTEGER;
-
-	typedef struct _GUID 
-	{
-		bool operator==( const struct _GUID &other ) const;
-
-		unsigned long  Data1;
-		unsigned short Data2;
-		unsigned short Data3;
-		unsigned char  Data4[ 8 ];
-	} GUID;
-
-	typedef struct _RECT 
-	{
-		int left;
-		int top;
-		int right;
-		int bottom;
-	} RECT;
-
-	typedef struct tagPOINT
-	{
-		LONG  x;
-		LONG  y;
-	} POINT, *PPOINT, *LPPOINT;
-
-	typedef struct _MEMORYSTATUS 
-	{
-	    DWORD dwLength;
-		SIZE_T dwTotalPhys;
-	} MEMORYSTATUS, *LPMEMORYSTATUS;
-	
-	typedef DWORD   COLORREF;
-	#define RGB(r,g,b)          ((COLORREF)(((BYTE)(r)|((WORD)((BYTE)(g))<<8))|(((DWORD)(BYTE)(b))<<16)))
-
-	#define MAKE_HRESULT(sev,fac,code) ((HRESULT) (((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) | ((unsigned long)(code))) )
-
-
-// Mac header files like to define these
-#ifdef S_FALSE
-#undef S_FALSE
-#endif
-#ifdef S_OK
-#undef S_OK
-#endif
-#ifdef E_FAIL
-#undef E_FAIL
-#endif
-#ifdef E_OUTOFMEMORY
-#undef E_OUTOFMEMORY
-#endif
-#ifdef FAILED
-#undef FAILED
-#endif
-#ifdef SUCCEEDED
-#undef SUCCEEDED
-#endif
-
-	#define S_FALSE ((HRESULT)0x00000001L)
-	#define S_OK 0
-	#define E_FAIL ((HRESULT)0x80004005L)
-	#define E_OUTOFMEMORY ((HRESULT)0x8007000EL)
-
-	#define FAILED(hr) ((HRESULT)(hr) < 0)
-	#define SUCCEEDED(hr) ((HRESULT)(hr) >= 0)
-
-	struct RGNDATA
-	{
-	};
-
-	typedef const void* LPCVOID;
-#endif
-
-//-----------------------------------------------------------------------------
-
-typedef enum _D3DFORMAT D3DFORMAT;
-
-#define D3DSI_OPCODE_MASK 0x0000FFFF
-#define D3DSP_TEXTURETYPE_MASK 0x78000000
-
-#define D3DUSAGE_AUTOGENMIPMAP 0x00000400L
-#define D3DSP_DCL_USAGE_MASK 0x0000000f
-
-#define D3DSP_OPCODESPECIFICCONTROL_MASK 0x00ff0000
-#define D3DSP_OPCODESPECIFICCONTROL_SHIFT 16
-
-
-/* Flags to construct D3DRS_COLORWRITEENABLE */
-#define D3DCOLORWRITEENABLE_RED     (1L<<0)
-#define D3DCOLORWRITEENABLE_GREEN   (1L<<1)
-#define D3DCOLORWRITEENABLE_BLUE    (1L<<2)
-#define D3DCOLORWRITEENABLE_ALPHA   (1L<<3)
-
-#define D3DSGR_NO_CALIBRATION 0x00000000L
-	
-#define D3DXINLINE inline
-
-#define D3D_SDK_VERSION   32
-
-#define _FACD3D  0x876
-#define MAKE_D3DHRESULT( code )  MAKE_HRESULT( 1, _FACD3D, code )
-	
-#define D3DERR_NOTFOUND							MAKE_D3DHRESULT(2150)
-#define D3DERR_DEVICELOST                       MAKE_D3DHRESULT(2152)
-#define D3DERR_NOTAVAILABLE                     MAKE_D3DHRESULT(2154)
-#define D3DERR_DEVICENOTRESET                   MAKE_D3DHRESULT(2153)
-#define D3DERR_INVALIDCALL                      MAKE_D3DHRESULT(2156)
-#define D3DERR_DRIVERINTERNALERROR              MAKE_D3DHRESULT(2087)
-#define D3DERR_OUTOFVIDEOMEMORY                 MAKE_D3DHRESULT(380)
-#define D3D_OK									S_OK
-
-#define D3DPRESENT_RATE_DEFAULT         0x00000000
-
-//
-// DevCaps
-//
-// we need to see who in Source land is interested in these values, as dxabstract is currently reporting zero for the whole Caps word
-#define D3DDEVCAPS_EXECUTESYSTEMMEMORY  0x00000010L /* Device can use execute buffers from system memory */
-#define D3DDEVCAPS_TLVERTEXSYSTEMMEMORY 0x00000040L /* Device can use TL buffers from system memory */
-#define D3DDEVCAPS_TLVERTEXVIDEOMEMORY  0x00000080L /* Device can use TL buffers from video memory */
-#define D3DDEVCAPS_TEXTURESYSTEMMEMORY  0x00000100L /* Device can texture from system memory */
-#define D3DDEVCAPS_TEXTUREVIDEOMEMORY   0x00000200L /* Device can texture from device memory */
-#define D3DDEVCAPS_DRAWPRIMTLVERTEX     0x00000400L /* Device can draw TLVERTEX primitives */
-#define D3DDEVCAPS_CANRENDERAFTERFLIP   0x00000800L /* Device can render without waiting for flip to complete */
-#define D3DDEVCAPS_TEXTURENONLOCALVIDMEM 0x00001000L /* Device can texture from nonlocal video memory */
-#define D3DDEVCAPS_SEPARATETEXTUREMEMORIES 0x00004000L /* Device is texturing from separate memory pools */
-#define D3DDEVCAPS_HWTRANSFORMANDLIGHT  0x00010000L /* Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also */
-#define D3DDEVCAPS_CANBLTSYSTONONLOCAL  0x00020000L /* Device supports a Tex Blt from system memory to non-local vidmem */
-#define D3DDEVCAPS_HWRASTERIZATION      0x00080000L /* Device has HW acceleration for rasterization */
-#define D3DDEVCAPS_PUREDEVICE           0x00100000L /* Device supports D3DCREATE_PUREDEVICE */
-#define D3DDEVCAPS_QUINTICRTPATCHES     0x00200000L /* Device supports quintic Beziers and BSplines */
-#define D3DDEVCAPS_RTPATCHHANDLEZERO    0x00800000L /* Indicates that RT Patches may be drawn efficiently using handle 0 */
-#define D3DDEVCAPS_NPATCHES             0x01000000L /* Device supports N-Patches */
-
-//
-// PrimitiveMiscCaps
-//
-#define D3DPMISCCAPS_MASKZ              0x00000002L
-#define D3DPMISCCAPS_CULLNONE           0x00000010L
-#define D3DPMISCCAPS_CULLCW             0x00000020L
-#define D3DPMISCCAPS_CULLCCW            0x00000040L
-#define D3DPMISCCAPS_COLORWRITEENABLE   0x00000080L
-#define D3DPMISCCAPS_CLIPPLANESCALEDPOINTS 0x00000100L /* Device correctly clips scaled points to clip planes */
-#define D3DPMISCCAPS_CLIPTLVERTS        0x00000200L /* device will clip post-transformed vertex primitives */
-#define D3DPMISCCAPS_TSSARGTEMP         0x00000400L /* device supports D3DTA_TEMP for temporary register */
-#define D3DPMISCCAPS_BLENDOP            0x00000800L /* device supports D3DRS_BLENDOP */
-#define D3DPMISCCAPS_NULLREFERENCE      0x00001000L /* Reference Device that doesnt render */
-#define D3DPMISCCAPS_PERSTAGECONSTANT   0x00008000L /* Device supports per-stage constants */
-#define D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS    0x00040000L /* Device supports different bit depths for MRT */
-#define D3DPMISCCAPS_FOGVERTEXCLAMPED           0x00100000L /* Device clamps fog blend factor per vertex */
-
-// Flags field for Issue
-#define D3DISSUE_END (1 << 0) // Tells the runtime to issue the end of a query, changing it's state to "non-signaled".
-#define D3DISSUE_BEGIN (1 << 1) // Tells the runtime to issue the beginng of a query.
-
-
-#define D3DPRESENT_INTERVAL_ONE         0x00000001L
-#define D3DPRESENT_INTERVAL_IMMEDIATE   0x80000000L
-
-/*
- * Options for clearing
- */
-#define D3DCLEAR_TARGET            0x00000001l  /* Clear target surface */
-#define D3DCLEAR_ZBUFFER           0x00000002l  /* Clear target z buffer */
-#define D3DCLEAR_STENCIL           0x00000004l  /* Clear stencil planes */
-
-
-#define D3DENUM_WHQL_LEVEL                      0x00000002L
-
-
-
-
-#define D3DPTEXTURECAPS_NOPROJECTEDBUMPENV  0x00200000L /* Device does not support projected bump env lookup operation 
-                                                           in programmable and fixed function pixel shaders */
-#define D3DDEVCAPS2_STREAMOFFSET                        0x00000001L /* Device supports offsets in streams. Must be set by DX9 drivers */
-
-#define D3DDEVCAPS_PUREDEVICE           0x00100000L /* Device supports D3DCREATE_PUREDEVICE */
-
-#define D3DCREATE_PUREDEVICE                    0x00000010L
-#define D3DCREATE_SOFTWARE_VERTEXPROCESSING     0x00000020L
-#define D3DCREATE_HARDWARE_VERTEXPROCESSING     0x00000040L
-#define D3DCREATE_FPU_PRESERVE                  0x00000002L
-#define D3DPRASTERCAPS_FOGRANGE               0x00010000L
-#define D3DPRASTERCAPS_FOGTABLE               0x00000100L
-#define D3DPRASTERCAPS_FOGVERTEX              0x00000080L
-#define D3DPRASTERCAPS_WFOG                   0x00100000L
-#define D3DPRASTERCAPS_ZFOG                   0x00200000L
-#define D3DPRASTERCAPS_MIPMAPLODBIAS          0x00002000L
-#define D3DPRASTERCAPS_WBUFFER                0x00040000L
-#define D3DPRASTERCAPS_ZTEST                  0x00000010L
-
-//
-// Caps2
-//
-#define D3DCAPS2_CANCALIBRATEGAMMA      0x00100000L
-#define D3DPRASTERCAPS_SCISSORTEST            0x01000000L
-#define D3DPTEXTURECAPS_MIPCUBEMAP          0x00010000L /* Device can do mipmapped cube maps */
-#define D3DPTEXTURECAPS_ALPHA               0x00000004L /* Alpha in texture pixels is supported */
-#define D3DPTEXTURECAPS_SQUAREONLY          0x00000020L /* Only square textures are supported */
-#define D3DCREATE_MULTITHREADED                 0x00000004L
-#define D3DDEVCAPS_HWTRANSFORMANDLIGHT  0x00010000L /* Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also */
-#define D3DPTFILTERCAPS_MINFANISOTROPIC     0x00000400L
-#define D3DPTFILTERCAPS_MAGFANISOTROPIC     0x04000000L
-#define D3DPTEXTURECAPS_CUBEMAP             0x00000800L /* Device can do cubemap textures */
-#define D3DPTEXTURECAPS_POW2                0x00000002L /* Power-of-2 texture dimensions are required - applies to non-Cube/Volume textures only. */
-#define D3DPTEXTURECAPS_NONPOW2CONDITIONAL  0x00000100L
-#define D3DPTEXTURECAPS_PROJECTED           0x00000400L /* Device can do D3DTTFF_PROJECTED */
-#define D3DTEXOPCAPS_ADD                        0x00000040L
-#define D3DTEXOPCAPS_MODULATE2X                 0x00000010L
-#define D3DPRASTERCAPS_DEPTHBIAS              0x04000000L 
-#define D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS    0x02000000L
-#define D3DVTXPCAPS_TEXGEN_SPHEREMAP    0x00000100L /* device supports D3DTSS_TCI_SPHEREMAP */
-#define D3DCAPS2_DYNAMICTEXTURES        0x20000000L
-
-// The following usages are valid only for querying CheckDeviceFormat
-#define D3DUSAGE_QUERY_SRGBREAD                 (0x00010000L)
-#define D3DUSAGE_QUERY_FILTER                   (0x00020000L)
-#define D3DUSAGE_QUERY_SRGBWRITE                (0x00040000L)
-#define D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING (0x00080000L)
-#define D3DUSAGE_QUERY_VERTEXTEXTURE            (0x00100000L)
-
-/* Usages for Vertex/Index buffers */
-#define D3DUSAGE_WRITEONLY          (0x00000008L)
-#define D3DUSAGE_SOFTWAREPROCESSING (0x00000010L)
-#define D3DUSAGE_DONOTCLIP          (0x00000020L)
-#define D3DUSAGE_POINTS             (0x00000040L)
-#define D3DUSAGE_RTPATCHES          (0x00000080L)
-#define D3DUSAGE_NPATCHES           (0x00000100L)
-
-
-// Flags field for GetData
-#define D3DGETDATA_FLUSH (1 << 0) // Tells the runtime to flush if the query is outstanding.
-
-#define D3DFVF_XYZ              0x002
-
-
-#define D3DTA_SELECTMASK        0x0000000f  // mask for arg selector
-#define D3DTA_DIFFUSE           0x00000000  // select diffuse color (read only)
-#define D3DTA_CURRENT           0x00000001  // select stage destination register (read/write)
-#define D3DTA_TEXTURE           0x00000002  // select texture color (read only)
-#define D3DTA_TFACTOR           0x00000003  // select D3DRS_TEXTUREFACTOR (read only)
-#define D3DTA_SPECULAR          0x00000004  // select specular color (read only)
-#define D3DTA_TEMP              0x00000005  // select temporary register color (read/write)
-#define D3DTA_CONSTANT          0x00000006  // select texture stage constant
-#define D3DTA_COMPLEMENT        0x00000010  // take 1.0 - x (read modifier)
-#define D3DTA_ALPHAREPLICATE    0x00000020  // replicate alpha to color components (read modifier)
-
-
-#define D3DUSAGE_RENDERTARGET			(0x00000001L)
-#define D3DUSAGE_QUERY_VERTEXTEXTURE    (0x00100000L)
-#define D3DUSAGE_QUERY_FILTER           (0x00020000L)
-#define D3DUSAGE_DEPTHSTENCIL			(0x00000002L)
-#define D3DUSAGE_WRITEONLY          (0x00000008L)
-#define D3DUSAGE_SOFTWAREPROCESSING (0x00000010L)
-#define D3DUSAGE_DYNAMIC            (0x00000200L)
-
-#define D3DSI_INSTLENGTH_MASK   0x0F000000
-#define D3DSI_INSTLENGTH_SHIFT  24
-#define D3DSP_TEXTURETYPE_SHIFT 27
-#define D3DSP_REGTYPE_SHIFT     28
-#define D3DSP_REGTYPE_SHIFT2    8
-#define D3DSP_REGTYPE_MASK      0x70000000
-#define D3DSP_REGTYPE_MASK2     0x00001800
-
-#define D3DSP_REGNUM_MASK       0x000007FF
-
-#define D3DSP_DSTMOD_SHIFT      20
-#define D3DSP_DSTMOD_MASK       0x00F00000
-#define    D3DSPDM_MSAMPCENTROID        (4<<D3DSP_DSTMOD_SHIFT) // Relevant to multisampling only:
-                                                                //      When the pixel center is not covered, sample
-                                                                //      attribute or compute gradients/LOD
-                                                                //      using multisample "centroid" location.
-                                                                //      "Centroid" is some location within the covered
-                                                                //      region of the pixel.
-
-#define D3DXSHADER_DEBUG                    (1 << 0)
-#define D3DXSHADER_AVOID_FLOW_CONTROL       (1 << 9)
-
-
-#define D3DLOCK_READONLY           0x00000010L
-#define D3DLOCK_DISCARD            0x00002000L
-#define D3DLOCK_NOOVERWRITE        0x00001000L
-#define D3DLOCK_NOSYSLOCK          0x00000800L
-
-#define D3DLOCK_NO_DIRTY_UPDATE     0x00008000L
-
-
-#define D3DDMAPSAMPLER 256
-#define D3DVERTEXTEXTURESAMPLER0 (D3DDMAPSAMPLER+1)
-#define D3DSP_SRCMOD_SHIFT      24
-
-
-#define D3DCOLOR_ARGB(a,r,g,b) ((D3DCOLOR)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff)))
-#define D3DCOLOR_RGBA(r,g,b,a) D3DCOLOR_ARGB(a,r,g,b)
-#define D3DCOLOR_XRGB(r,g,b)   D3DCOLOR_ARGB(0xff,r,g,b)
-
-// maps floating point channels (0.f to 1.f range) to D3DCOLOR
-#define D3DCOLOR_COLORVALUE(r,g,b,a) \
-    D3DCOLOR_RGBA((DWORD)((r)*255.f),(DWORD)((g)*255.f),(DWORD)((b)*255.f),(DWORD)((a)*255.f))
-
-#define D3DDECL_END() {0xFF,0,D3DDECLTYPE_UNUSED,0,0,0}
-
-#define D3DSP_DCL_USAGEINDEX_SHIFT 16
-#define D3DSP_DCL_USAGEINDEX_MASK  0x000f0000
-
-// Bit masks for destination parameter modifiers
-#define    D3DSPDM_NONE                 (0<<D3DSP_DSTMOD_SHIFT) // nop
-#define    D3DSPDM_SATURATE             (1<<D3DSP_DSTMOD_SHIFT) // clamp to 0. to 1. range
-#define    D3DSPDM_PARTIALPRECISION     (2<<D3DSP_DSTMOD_SHIFT) // Partial precision hint
-#define    D3DSPDM_MSAMPCENTROID        (4<<D3DSP_DSTMOD_SHIFT) // Relevant to multisampling only:
-                                                                //      When the pixel center is not covered, sample
-                                                                //      attribute or compute gradients/LOD
-                                                                //      using multisample "centroid" location.
-                                                                //      "Centroid" is some location within the covered
-                                                                //      region of the pixel.
-
-// Value when there is no swizzle (X is taken from X, Y is taken from Y,
-// Z is taken from Z, W is taken from W
-//
-#define D3DVS_NOSWIZZLE (D3DVS_X_X | D3DVS_Y_Y | D3DVS_Z_Z | D3DVS_W_W)
-
-// extract major/minor from version cap
-#define D3DSHADER_VERSION_MAJOR(_Version) (((_Version)>>8)&0xFF)
-#define D3DSHADER_VERSION_MINOR(_Version) (((_Version)>>0)&0xFF)
-
-#define D3DSHADER_ADDRESSMODE_SHIFT 13
-#define D3DSHADER_ADDRESSMODE_MASK  (1 << D3DSHADER_ADDRESSMODE_SHIFT)
-
-#define D3DPS_END()  0x0000FFFF
-
-// ps_2_0 texld controls
-#define D3DSI_TEXLD_PROJECT (0x01 << D3DSP_OPCODESPECIFICCONTROL_SHIFT)
-#define D3DSI_TEXLD_BIAS    (0x02 << D3DSP_OPCODESPECIFICCONTROL_SHIFT)
-
-
-// destination parameter write mask
-#define D3DSP_WRITEMASK_0       0x00010000  // Component 0 (X;Red)
-#define D3DSP_WRITEMASK_1       0x00020000  // Component 1 (Y;Green)
-#define D3DSP_WRITEMASK_2       0x00040000  // Component 2 (Z;Blue)
-#define D3DSP_WRITEMASK_3       0x00080000  // Component 3 (W;Alpha)
-#define D3DSP_WRITEMASK_ALL     0x000F0000  // All Components
-
-#define D3DVS_SWIZZLE_SHIFT     16
-#define D3DVS_SWIZZLE_MASK      0x00FF0000
-
-// The following bits define where to take component X from:
-
-#define D3DVS_X_X       (0 << D3DVS_SWIZZLE_SHIFT)
-#define D3DVS_X_Y       (1 << D3DVS_SWIZZLE_SHIFT)
-#define D3DVS_X_Z       (2 << D3DVS_SWIZZLE_SHIFT)
-#define D3DVS_X_W       (3 << D3DVS_SWIZZLE_SHIFT)
-
-// The following bits define where to take component Y from:
-
-#define D3DVS_Y_X       (0 << (D3DVS_SWIZZLE_SHIFT + 2))
-#define D3DVS_Y_Y       (1 << (D3DVS_SWIZZLE_SHIFT + 2))
-#define D3DVS_Y_Z       (2 << (D3DVS_SWIZZLE_SHIFT + 2))
-#define D3DVS_Y_W       (3 << (D3DVS_SWIZZLE_SHIFT + 2))
-
-// The following bits define where to take component Z from:
-
-#define D3DVS_Z_X       (0 << (D3DVS_SWIZZLE_SHIFT + 4))
-#define D3DVS_Z_Y       (1 << (D3DVS_SWIZZLE_SHIFT + 4))
-#define D3DVS_Z_Z       (2 << (D3DVS_SWIZZLE_SHIFT + 4))
-#define D3DVS_Z_W       (3 << (D3DVS_SWIZZLE_SHIFT + 4))
-
-// The following bits define where to take component W from:
-
-#define D3DVS_W_X       (0 << (D3DVS_SWIZZLE_SHIFT + 6))
-#define D3DVS_W_Y       (1 << (D3DVS_SWIZZLE_SHIFT + 6))
-#define D3DVS_W_Z       (2 << (D3DVS_SWIZZLE_SHIFT + 6))
-#define D3DVS_W_W       (3 << (D3DVS_SWIZZLE_SHIFT + 6))
-
-// source parameter modifiers
-#define D3DSP_SRCMOD_SHIFT      24
-#define D3DSP_SRCMOD_MASK       0x0F000000
-
-// ------------------------------------------------------------------------------------------------------------------------------ //
-// ENUMS
-// ------------------------------------------------------------------------------------------------------------------------------ //
-
-typedef enum _D3DSHADER_PARAM_SRCMOD_TYPE
-{
-    D3DSPSM_NONE    = 0<<D3DSP_SRCMOD_SHIFT, // nop
-    D3DSPSM_NEG     = 1<<D3DSP_SRCMOD_SHIFT, // negate
-    D3DSPSM_BIAS    = 2<<D3DSP_SRCMOD_SHIFT, // bias
-    D3DSPSM_BIASNEG = 3<<D3DSP_SRCMOD_SHIFT, // bias and negate
-    D3DSPSM_SIGN    = 4<<D3DSP_SRCMOD_SHIFT, // sign
-    D3DSPSM_SIGNNEG = 5<<D3DSP_SRCMOD_SHIFT, // sign and negate
-    D3DSPSM_COMP    = 6<<D3DSP_SRCMOD_SHIFT, // complement
-    D3DSPSM_X2      = 7<<D3DSP_SRCMOD_SHIFT, // *2
-    D3DSPSM_X2NEG   = 8<<D3DSP_SRCMOD_SHIFT, // *2 and negate
-    D3DSPSM_DZ      = 9<<D3DSP_SRCMOD_SHIFT, // divide through by z component
-    D3DSPSM_DW      = 10<<D3DSP_SRCMOD_SHIFT, // divide through by w component
-    D3DSPSM_ABS     = 11<<D3DSP_SRCMOD_SHIFT, // abs()
-    D3DSPSM_ABSNEG  = 12<<D3DSP_SRCMOD_SHIFT, // -abs()
-    D3DSPSM_NOT     = 13<<D3DSP_SRCMOD_SHIFT, // for predicate register: "!p0"
-    D3DSPSM_FORCE_DWORD = 0x7fffffff,        // force 32-bit size enum
-} D3DSHADER_PARAM_SRCMOD_TYPE;
-
-
-typedef enum _D3DSAMPLER_TEXTURE_TYPE
-{
-    D3DSTT_UNKNOWN = 0<<D3DSP_TEXTURETYPE_SHIFT, // uninitialized value
-    D3DSTT_2D      = 2<<D3DSP_TEXTURETYPE_SHIFT, // dcl_2d s# (for declaring a 2-D texture)
-    D3DSTT_CUBE    = 3<<D3DSP_TEXTURETYPE_SHIFT, // dcl_cube s# (for declaring a cube texture)
-    D3DSTT_VOLUME  = 4<<D3DSP_TEXTURETYPE_SHIFT, // dcl_volume s# (for declaring a volume texture)
-    D3DSTT_FORCE_DWORD  = 0x7fffffff,      // force 32-bit size enum
-} D3DSAMPLER_TEXTURE_TYPE;
-
-typedef enum _D3DSHADER_INSTRUCTION_OPCODE_TYPE
-{
-    D3DSIO_NOP          = 0,
-    D3DSIO_MOV          ,
-    D3DSIO_ADD          ,
-    D3DSIO_SUB          ,
-    D3DSIO_MAD          ,
-    D3DSIO_MUL          ,
-    D3DSIO_RCP          ,
-    D3DSIO_RSQ          ,
-    D3DSIO_DP3          ,
-    D3DSIO_DP4          ,
-    D3DSIO_MIN          ,	//10
-    D3DSIO_MAX          ,
-    D3DSIO_SLT          ,
-    D3DSIO_SGE          ,
-    D3DSIO_EXP          ,
-    D3DSIO_LOG          ,
-    D3DSIO_LIT          ,
-    D3DSIO_DST          ,
-    D3DSIO_LRP          ,
-    D3DSIO_FRC          ,
-    D3DSIO_M4x4         ,	//20
-    D3DSIO_M4x3         ,
-    D3DSIO_M3x4         ,
-    D3DSIO_M3x3         ,
-    D3DSIO_M3x2         ,
-    D3DSIO_CALL         ,
-    D3DSIO_CALLNZ       ,
-    D3DSIO_LOOP         ,
-    D3DSIO_RET          ,
-    D3DSIO_ENDLOOP      ,
-    D3DSIO_LABEL        ,	//30
-    D3DSIO_DCL          ,
-    D3DSIO_POW          ,
-    D3DSIO_CRS          ,
-    D3DSIO_SGN          ,
-    D3DSIO_ABS          ,
-    D3DSIO_NRM          ,
-    D3DSIO_SINCOS       ,
-    D3DSIO_REP          ,
-    D3DSIO_ENDREP       ,
-    D3DSIO_IF           ,	//40
-    D3DSIO_IFC          ,
-    D3DSIO_ELSE         ,
-    D3DSIO_ENDIF        ,
-    D3DSIO_BREAK        ,
-    D3DSIO_BREAKC       ,
-    D3DSIO_MOVA         ,
-    D3DSIO_DEFB         ,
-    D3DSIO_DEFI         ,
-
-    D3DSIO_TEXCOORD     = 64,
-    D3DSIO_TEXKILL      ,
-    D3DSIO_TEX          ,
-    D3DSIO_TEXBEM       ,
-    D3DSIO_TEXBEML      ,
-    D3DSIO_TEXREG2AR    ,
-    D3DSIO_TEXREG2GB    ,
-    D3DSIO_TEXM3x2PAD   ,
-    D3DSIO_TEXM3x2TEX   ,
-    D3DSIO_TEXM3x3PAD   ,
-    D3DSIO_TEXM3x3TEX   ,
-    D3DSIO_RESERVED0    ,
-    D3DSIO_TEXM3x3SPEC  ,
-    D3DSIO_TEXM3x3VSPEC ,
-    D3DSIO_EXPP         ,
-    D3DSIO_LOGP         ,
-    D3DSIO_CND          ,
-    D3DSIO_DEF          ,
-    D3DSIO_TEXREG2RGB   ,
-    D3DSIO_TEXDP3TEX    ,
-    D3DSIO_TEXM3x2DEPTH ,
-    D3DSIO_TEXDP3       ,
-    D3DSIO_TEXM3x3      ,
-    D3DSIO_TEXDEPTH     ,
-    D3DSIO_CMP          ,
-    D3DSIO_BEM          ,
-    D3DSIO_DP2ADD       ,
-    D3DSIO_DSX          ,
-    D3DSIO_DSY          ,
-    D3DSIO_TEXLDD       ,
-    D3DSIO_SETP         ,
-    D3DSIO_TEXLDL       ,
-    D3DSIO_BREAKP       ,
-
-    D3DSIO_PHASE        = 0xFFFD,
-    D3DSIO_COMMENT      = 0xFFFE,
-    D3DSIO_END          = 0xFFFF,
-
-    D3DSIO_FORCE_DWORD  = 0x7fffffff,   // force 32-bit size enum
-} D3DSHADER_INSTRUCTION_OPCODE_TYPE;
-
-typedef enum _D3DVS_RASTOUT_OFFSETS
-{
-    D3DSRO_POSITION = 0,
-    D3DSRO_FOG,
-    D3DSRO_POINT_SIZE,
-    D3DSRO_FORCE_DWORD  = 0x7fffffff,   // force 32-bit size enum
-} D3DVS_RASTOUT_OFFSETS;
-
-/* SwapEffects */
-typedef enum _D3DSWAPEFFECT
-{
-    D3DSWAPEFFECT_DISCARD           = 1,
-    D3DSWAPEFFECT_COPY              = 3,
-
-    D3DSWAPEFFECT_FORCE_DWORD       = 0x7fffffff
-} D3DSWAPEFFECT;
-
-typedef enum _D3DRESOURCETYPE 
-{
-    D3DRTYPE_SURFACE                =  1,
-    D3DRTYPE_TEXTURE                =  3,
-    D3DRTYPE_VOLUMETEXTURE          =  4,
-    D3DRTYPE_CUBETEXTURE            =  5,
-    D3DRTYPE_VERTEXBUFFER           =  6,
-    D3DRTYPE_INDEXBUFFER            =  7,
-	
-    D3DRTYPE_FORCE_DWORD            = 0x7fffffff
-} D3DRESOURCETYPE;
-
-typedef enum _D3DDEVTYPE
-{
-    D3DDEVTYPE_HAL         = 1,
-    D3DDEVTYPE_REF         = 2,
-
-    D3DDEVTYPE_NULLREF     = 4,
-    
-    D3DDEVTYPE_FORCE_DWORD  = 0x7fffffff
-} D3DDEVTYPE;
-
-typedef enum _D3DSTENCILOP 
-{
-    D3DSTENCILOP_KEEP           = 1,
-    D3DSTENCILOP_ZERO           = 2,
-	D3DSTENCILOP_REPLACE		= 3,
-    D3DSTENCILOP_INCRSAT        = 4,
-    D3DSTENCILOP_DECRSAT        = 5,
-    D3DSTENCILOP_INVERT         = 6,
-    D3DSTENCILOP_INCR           = 7,
-    D3DSTENCILOP_DECR           = 8,
-    D3DSTENCILOP_FORCE_DWORD    = 0x7fffffff, /* force 32-bit size enum */
-} D3DSTENCILOP;
-
-typedef enum _D3DPATCHEDGESTYLE
-{
-   D3DPATCHEDGE_DISCRETE    = 0,
-   D3DPATCHEDGE_CONTINUOUS  = 1,
-   D3DPATCHEDGE_FORCE_DWORD = 0x7fffffff,
-} D3DPATCHEDGESTYLE;
-
-
-/* Debug monitor tokens (DEBUG only)
-
-   Note that if D3DRS_DEBUGMONITORTOKEN is set, the call is treated as
-   passing a token to the debug monitor.  For example, if, after passing
-   D3DDMT_ENABLE/DISABLE to D3DRS_DEBUGMONITORTOKEN other token values
-   are passed in, the enabled/disabled state of the debug
-   monitor will still persist.
-
-   The debug monitor defaults to enabled.
-
-   Calling GetRenderState on D3DRS_DEBUGMONITORTOKEN is not of any use.
-*/
-typedef enum _D3DDEBUGMONITORTOKENS 
-{
-    D3DDMT_ENABLE            = 0,    // enable debug monitor
-} D3DDEBUGMONITORTOKENS;
-
-typedef enum _D3DDEGREETYPE
-{
-   D3DDEGREE_LINEAR      = 1,
-   D3DDEGREE_QUADRATIC   = 2,
-   D3DDEGREE_CUBIC       = 3,
-   D3DDEGREE_FORCE_DWORD = 0x7fffffff,
-} D3DDEGREETYPE;
-
-typedef enum _D3DBLENDOP 
-{
-    D3DBLENDOP_ADD              = 1,
-    D3DBLENDOP_SUBTRACT         = 2,
-    D3DBLENDOP_REVSUBTRACT      = 3,
-    D3DBLENDOP_MIN              = 4,
-    D3DBLENDOP_MAX              = 5,
-    D3DBLENDOP_FORCE_DWORD      = 0x7fffffff, /* force 32-bit size enum */
-} D3DBLENDOP;
-
-typedef enum _D3DMULTISAMPLE_TYPE
-{
-    D3DMULTISAMPLE_NONE            =  0,
-    D3DMULTISAMPLE_NONMASKABLE     =  1,
-    D3DMULTISAMPLE_2_SAMPLES       =  2,
-    D3DMULTISAMPLE_3_SAMPLES       =  3,
-    D3DMULTISAMPLE_4_SAMPLES       =  4,
-    D3DMULTISAMPLE_5_SAMPLES       =  5,
-    D3DMULTISAMPLE_6_SAMPLES       =  6,
-    D3DMULTISAMPLE_7_SAMPLES       =  7,
-    D3DMULTISAMPLE_8_SAMPLES       =  8,
-    D3DMULTISAMPLE_9_SAMPLES       =  9,
-    D3DMULTISAMPLE_10_SAMPLES      = 10,
-    D3DMULTISAMPLE_11_SAMPLES      = 11,
-    D3DMULTISAMPLE_12_SAMPLES      = 12,
-    D3DMULTISAMPLE_13_SAMPLES      = 13,
-    D3DMULTISAMPLE_14_SAMPLES      = 14,
-    D3DMULTISAMPLE_15_SAMPLES      = 15,
-    D3DMULTISAMPLE_16_SAMPLES      = 16,
-
-    D3DMULTISAMPLE_FORCE_DWORD     = 0x7fffffff
-} D3DMULTISAMPLE_TYPE;
-
-/* Pool types */
-typedef enum _D3DPOOL 
-{
-    D3DPOOL_DEFAULT                 = 0,
-    D3DPOOL_MANAGED                 = 1,
-    D3DPOOL_SYSTEMMEM               = 2,
-    D3DPOOL_SCRATCH                 = 3,
-
-    D3DPOOL_FORCE_DWORD             = 0x7fffffff
-} D3DPOOL;
-
-typedef enum _D3DQUERYTYPE 
-{
-    D3DQUERYTYPE_RESOURCEMANAGER        = 5, /* D3DISSUE_END */
-    D3DQUERYTYPE_EVENT                  = 8, /* D3DISSUE_END */
-    D3DQUERYTYPE_OCCLUSION              = 9, /* D3DISSUE_BEGIN, D3DISSUE_END */
-    D3DQUERYTYPE_TIMESTAMP              = 10, /* D3DISSUE_END */
-    D3DQUERYTYPE_TIMESTAMPFREQ          = 12, /* D3DISSUE_END */
-    D3DQUERYTYPE_INTERFACETIMINGS       = 14, /* D3DISSUE_BEGIN, D3DISSUE_END */
-    D3DQUERYTYPE_PIXELTIMINGS           = 16, /* D3DISSUE_BEGIN, D3DISSUE_END */
-    D3DQUERYTYPE_CACHEUTILIZATION       = 18, /* D3DISSUE_BEGIN, D3DISSUE_END */
-} D3DQUERYTYPE;
-
-typedef enum _D3DRENDERSTATETYPE 
-{
-    D3DRS_ZENABLE                   = 7,    /* D3DZBUFFERTYPE (or TRUE/FALSE for legacy) */
-    D3DRS_FILLMODE                  = 8,    /* D3DFILLMODE */
-    D3DRS_SHADEMODE                 = 9,    /* D3DSHADEMODE */
-    D3DRS_ZWRITEENABLE              = 14,   /* TRUE to enable z writes */
-    D3DRS_ALPHATESTENABLE           = 15,   /* TRUE to enable alpha tests */
-    D3DRS_LASTPIXEL                 = 16,   /* TRUE for last-pixel on lines */
-    D3DRS_SRCBLEND                  = 19,   /* D3DBLEND */
-    D3DRS_DESTBLEND                 = 20,   /* D3DBLEND */
-    D3DRS_CULLMODE                  = 22,   /* D3DCULL */
-    D3DRS_ZFUNC                     = 23,   /* D3DCMPFUNC */
-    D3DRS_ALPHAREF                  = 24,   /* D3DFIXED */
-    D3DRS_ALPHAFUNC                 = 25,   /* D3DCMPFUNC */
-    D3DRS_DITHERENABLE              = 26,   /* TRUE to enable dithering */
-    D3DRS_ALPHABLENDENABLE          = 27,   /* TRUE to enable alpha blending */
-    D3DRS_FOGENABLE                 = 28,   /* TRUE to enable fog blending */
-    D3DRS_SPECULARENABLE            = 29,   /* TRUE to enable specular */
-    D3DRS_FOGCOLOR                  = 34,   /* D3DCOLOR */
-    D3DRS_FOGTABLEMODE              = 35,   /* D3DFOGMODE */
-    D3DRS_FOGSTART                  = 36,   /* Fog start (for both vertex and pixel fog) */
-    D3DRS_FOGEND                    = 37,   /* Fog end      */
-    D3DRS_FOGDENSITY                = 38,   /* Fog density  */
-    D3DRS_RANGEFOGENABLE            = 48,   /* Enables range-based fog */
-    D3DRS_STENCILENABLE             = 52,   /* BOOL enable/disable stenciling */
-    D3DRS_STENCILFAIL               = 53,   /* D3DSTENCILOP to do if stencil test fails */
-    D3DRS_STENCILZFAIL              = 54,   /* D3DSTENCILOP to do if stencil test passes and Z test fails */
-    D3DRS_STENCILPASS               = 55,   /* D3DSTENCILOP to do if both stencil and Z tests pass */
-    D3DRS_STENCILFUNC               = 56,   /* D3DCMPFUNC fn.  Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true */
-    D3DRS_STENCILREF                = 57,   /* Reference value used in stencil test */
-    D3DRS_STENCILMASK               = 58,   /* Mask value used in stencil test */
-    D3DRS_STENCILWRITEMASK          = 59,   /* Write mask applied to values written to stencil buffer */
-    D3DRS_TEXTUREFACTOR             = 60,   /* D3DCOLOR used for multi-texture blend */
-    D3DRS_WRAP0                     = 128,  /* wrap for 1st texture coord. set */
-    D3DRS_WRAP1                     = 129,  /* wrap for 2nd texture coord. set */
-    D3DRS_WRAP2                     = 130,  /* wrap for 3rd texture coord. set */
-    D3DRS_WRAP3                     = 131,  /* wrap for 4th texture coord. set */
-    D3DRS_WRAP4                     = 132,  /* wrap for 5th texture coord. set */
-    D3DRS_WRAP5                     = 133,  /* wrap for 6th texture coord. set */
-    D3DRS_WRAP6                     = 134,  /* wrap for 7th texture coord. set */
-    D3DRS_WRAP7                     = 135,  /* wrap for 8th texture coord. set */
-    D3DRS_CLIPPING                  = 136,
-    D3DRS_LIGHTING                  = 137,
-    D3DRS_AMBIENT                   = 139,
-    D3DRS_FOGVERTEXMODE             = 140,
-    D3DRS_COLORVERTEX               = 141,
-    D3DRS_LOCALVIEWER               = 142,
-    D3DRS_NORMALIZENORMALS          = 143,
-    D3DRS_DIFFUSEMATERIALSOURCE     = 145,
-    D3DRS_SPECULARMATERIALSOURCE    = 146,
-    D3DRS_AMBIENTMATERIALSOURCE     = 147,
-    D3DRS_EMISSIVEMATERIALSOURCE    = 148,
-    D3DRS_VERTEXBLEND               = 151,
-    D3DRS_CLIPPLANEENABLE           = 152,
-    D3DRS_POINTSIZE                 = 154,   /* float point size */
-    D3DRS_POINTSIZE_MIN             = 155,   /* float point size min threshold */
-    D3DRS_POINTSPRITEENABLE         = 156,   /* BOOL point texture coord control */
-    D3DRS_POINTSCALEENABLE          = 157,   /* BOOL point size scale enable */
-    D3DRS_POINTSCALE_A              = 158,   /* float point attenuation A value */
-    D3DRS_POINTSCALE_B              = 159,   /* float point attenuation B value */
-    D3DRS_POINTSCALE_C              = 160,   /* float point attenuation C value */
-    D3DRS_MULTISAMPLEANTIALIAS      = 161,  // BOOL - set to do FSAA with multisample buffer
-    D3DRS_MULTISAMPLEMASK           = 162,  // DWORD - per-sample enable/disable
-    D3DRS_PATCHEDGESTYLE            = 163,  // Sets whether patch edges will use float style tessellation
-    D3DRS_DEBUGMONITORTOKEN         = 165,  // DEBUG ONLY - token to debug monitor
-    D3DRS_POINTSIZE_MAX             = 166,   /* float point size max threshold */
-    D3DRS_INDEXEDVERTEXBLENDENABLE  = 167,
-    D3DRS_COLORWRITEENABLE          = 168,  // per-channel write enable
-    D3DRS_TWEENFACTOR               = 170,   // float tween factor
-    D3DRS_BLENDOP                   = 171,   // D3DBLENDOP setting
-    D3DRS_POSITIONDEGREE            = 172,   // NPatch position interpolation degree. D3DDEGREE_LINEAR or D3DDEGREE_CUBIC (default)
-    D3DRS_NORMALDEGREE              = 173,   // NPatch normal interpolation degree. D3DDEGREE_LINEAR (default) or D3DDEGREE_QUADRATIC
-    D3DRS_SCISSORTESTENABLE         = 174,
-    D3DRS_SLOPESCALEDEPTHBIAS       = 175,
-    D3DRS_ANTIALIASEDLINEENABLE     = 176,
-    D3DRS_MINTESSELLATIONLEVEL      = 178,
-    D3DRS_MAXTESSELLATIONLEVEL      = 179,
-    D3DRS_ADAPTIVETESS_X            = 180,
-    D3DRS_ADAPTIVETESS_Y            = 181,
-    D3DRS_ADAPTIVETESS_Z            = 182,
-    D3DRS_ADAPTIVETESS_W            = 183,
-    D3DRS_ENABLEADAPTIVETESSELLATION = 184,
-    D3DRS_TWOSIDEDSTENCILMODE       = 185,   /* BOOL enable/disable 2 sided stenciling */
-    D3DRS_CCW_STENCILFAIL           = 186,   /* D3DSTENCILOP to do if ccw stencil test fails */
-    D3DRS_CCW_STENCILZFAIL          = 187,   /* D3DSTENCILOP to do if ccw stencil test passes and Z test fails */
-    D3DRS_CCW_STENCILPASS           = 188,   /* D3DSTENCILOP to do if both ccw stencil and Z tests pass */
-    D3DRS_CCW_STENCILFUNC           = 189,   /* D3DCMPFUNC fn.  ccw Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true */
-    D3DRS_COLORWRITEENABLE1         = 190,   /* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
-    D3DRS_COLORWRITEENABLE2         = 191,   /* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
-    D3DRS_COLORWRITEENABLE3         = 192,   /* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
-    D3DRS_BLENDFACTOR               = 193,   /* D3DCOLOR used for a constant blend factor during alpha blending for devices that support D3DPBLENDCAPS_BLENDFACTOR */
-    D3DRS_SRGBWRITEENABLE           = 194,   /* Enable rendertarget writes to be DE-linearized to SRGB (for formats that expose D3DUSAGE_QUERY_SRGBWRITE) */
-    D3DRS_DEPTHBIAS                 = 195,
-    D3DRS_WRAP8                     = 198,   /* Additional wrap states for vs_3_0+ attributes with D3DDECLUSAGE_TEXCOORD */
-    D3DRS_WRAP9                     = 199,
-    D3DRS_WRAP10                    = 200,
-    D3DRS_WRAP11                    = 201,
-    D3DRS_WRAP12                    = 202,
-    D3DRS_WRAP13                    = 203,
-    D3DRS_WRAP14                    = 204,
-    D3DRS_WRAP15                    = 205,
-    D3DRS_SEPARATEALPHABLENDENABLE  = 206,  /* TRUE to enable a separate blending function for the alpha channel */
-    D3DRS_SRCBLENDALPHA             = 207,  /* SRC blend factor for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */
-    D3DRS_DESTBLENDALPHA            = 208,  /* DST blend factor for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */
-    D3DRS_BLENDOPALPHA              = 209,  /* Blending operation for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */
-
-
-    D3DRS_FORCE_DWORD               = 0x7fffffff, /* force 32-bit size enum */
-} D3DRENDERSTATETYPE;
-
-typedef enum _D3DCULL 
-{
-    D3DCULL_NONE                = 1,
-    D3DCULL_CW                  = 2,
-    D3DCULL_CCW                 = 3,
-    D3DCULL_FORCE_DWORD         = 0x7fffffff, /* force 32-bit size enum */
-} D3DCULL;
-
-typedef enum _D3DTEXTUREFILTERTYPE
-{
-    D3DTEXF_NONE            = 0,    // filtering disabled (valid for mip filter only)
-    D3DTEXF_POINT           = 1,    // nearest
-    D3DTEXF_LINEAR          = 2,    // linear interpolation
-    D3DTEXF_ANISOTROPIC     = 3,    // anisotropic
-    D3DTEXF_FORCE_DWORD     = 0x7fffffff,   // force 32-bit size enum
-} D3DTEXTUREFILTERTYPE;
-
-typedef enum _D3DBACKBUFFER_TYPE
-{
-    D3DBACKBUFFER_TYPE_MONO         = 0,
-
-    D3DBACKBUFFER_TYPE_FORCE_DWORD  = 0x7fffffff
-} D3DBACKBUFFER_TYPE;
-
-#define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256)
-#define D3DTS_WORLD  D3DTS_WORLDMATRIX(0)
-#define D3DTS_WORLD1 D3DTS_WORLDMATRIX(1)
-#define D3DTS_WORLD2 D3DTS_WORLDMATRIX(2)
-#define D3DTS_WORLD3 D3DTS_WORLDMATRIX(3)
-
-typedef enum _D3DCMPFUNC 
-{
-    D3DCMP_NEVER                = 1,
-    D3DCMP_LESS                 = 2,
-    D3DCMP_EQUAL                = 3,
-    D3DCMP_LESSEQUAL            = 4,
-    D3DCMP_GREATER              = 5,
-    D3DCMP_NOTEQUAL             = 6,
-    D3DCMP_GREATEREQUAL         = 7,
-    D3DCMP_ALWAYS               = 8,
-    D3DCMP_FORCE_DWORD          = 0x7fffffff, /* force 32-bit size enum */
-} D3DCMPFUNC;
-
-typedef enum _D3DZBUFFERTYPE 
-{
-    D3DZB_FALSE                 = 0,
-    D3DZB_TRUE                  = 1, // Z buffering
-    D3DZB_USEW                  = 2, // W buffering
-    D3DZB_FORCE_DWORD           = 0x7fffffff, /* force 32-bit size enum */
-} D3DZBUFFERTYPE;
-
-typedef enum _D3DFILLMODE 
-{
-    D3DFILL_POINT               = 1,
-    D3DFILL_WIREFRAME           = 2,
-    D3DFILL_SOLID               = 3,
-    D3DFILL_FORCE_DWORD         = 0x7fffffff, /* force 32-bit size enum */
-} D3DFILLMODE;
-
-typedef enum _D3DBLEND 
-{
-    D3DBLEND_ZERO               = 1,
-    D3DBLEND_ONE                = 2,
-    D3DBLEND_SRCCOLOR           = 3,
-    D3DBLEND_INVSRCCOLOR        = 4,
-    D3DBLEND_SRCALPHA           = 5,
-    D3DBLEND_INVSRCALPHA        = 6,
-    D3DBLEND_DESTALPHA          = 7,
-    D3DBLEND_INVDESTALPHA       = 8,
-    D3DBLEND_DESTCOLOR          = 9,
-    D3DBLEND_INVDESTCOLOR       = 10,
-    D3DBLEND_SRCALPHASAT        = 11,
-    D3DBLEND_BOTHSRCALPHA       = 12,
-    D3DBLEND_BOTHINVSRCALPHA    = 13,
-    D3DBLEND_BLENDFACTOR        = 14, /* Only supported if D3DPBLENDCAPS_BLENDFACTOR is on */
-    D3DBLEND_FORCE_DWORD        = 0x7fffffff, /* force 32-bit size enum */
-} D3DBLEND;
-
-// Values for material source
-typedef enum _D3DMATERIALCOLORSOURCE
-{
-    D3DMCS_MATERIAL         = 0,            // Color from material is used
-    D3DMCS_COLOR1           = 1,            // Diffuse vertex color is used
-    D3DMCS_COLOR2           = 2,            // Specular vertex color is used
-    D3DMCS_FORCE_DWORD      = 0x7fffffff,   // force 32-bit size enum
-} D3DMATERIALCOLORSOURCE;
-
-typedef enum _D3DCUBEMAP_FACES
-{
-    D3DCUBEMAP_FACE_POSITIVE_Z     = 4,
-
-    D3DCUBEMAP_FACE_FORCE_DWORD    = 0x7fffffff
-} D3DCUBEMAP_FACES;
-
-typedef enum _D3DTEXTURETRANSFORMFLAGS 
-{
-    D3DTTFF_DISABLE         = 0,    // texture coordinates are passed directly
-    D3DTTFF_COUNT3          = 3,    // rasterizer should expect 3-D texture coords
-    D3DTTFF_PROJECTED       = 256,  // texcoords to be divided by COUNTth element
-    D3DTTFF_FORCE_DWORD     = 0x7fffffff,
-} D3DTEXTURETRANSFORMFLAGS;
-
-// Note: the Linux/win TOGL reorders these.  For the Mac we use the same enums as Windows itself.
-
-typedef enum _D3DTEXTUREADDRESS {
-    D3DTADDRESS_WRAP            = 1,
-    D3DTADDRESS_CLAMP           = 3,
-    D3DTADDRESS_BORDER          = 4,
-    D3DTADDRESS_FORCE_DWORD     = 0x7fffffff, /* force 32-bit size enum */
-} D3DTEXTUREADDRESS;
-
-typedef enum _D3DSHADEMODE 
-{
-    D3DSHADE_FLAT               = 1,
-    D3DSHADE_GOURAUD            = 2,
-    D3DSHADE_PHONG              = 3,
-    D3DSHADE_FORCE_DWORD        = 0x7fffffff, /* force 32-bit size enum */
-} D3DSHADEMODE;
-
-typedef enum _D3DFOGMODE 
-{
-    D3DFOG_NONE                 = 0,
-    D3DFOG_LINEAR               = 3,
-    D3DFOG_FORCE_DWORD          = 0x7fffffff, /* force 32-bit size enum */
-} D3DFOGMODE;
-
-typedef struct _D3DRECT 
-{
-    LONG x1;
-    LONG y1;
-    LONG x2;
-    LONG y2;
-} D3DRECT;
-
-typedef enum _D3DSHADER_PARAM_REGISTER_TYPE
-{
-    D3DSPR_TEMP           =  0, // Temporary Register File
-    D3DSPR_INPUT          =  1, // Input Register File
-    D3DSPR_CONST          =  2, // Constant Register File
-    D3DSPR_ADDR           =  3, // Address Register (VS)
-    D3DSPR_TEXTURE        =  3, // Texture Register File (PS)
-    D3DSPR_RASTOUT        =  4, // Rasterizer Register File
-    D3DSPR_ATTROUT        =  5, // Attribute Output Register File
-    D3DSPR_TEXCRDOUT      =  6, // Texture Coordinate Output Register File
-    D3DSPR_OUTPUT         =  6, // Output register file for VS3.0+
-    D3DSPR_CONSTINT       =  7, // Constant Integer Vector Register File
-    D3DSPR_COLOROUT       =  8, // Color Output Register File
-    D3DSPR_DEPTHOUT       =  9, // Depth Output Register File
-    D3DSPR_SAMPLER        = 10, // Sampler State Register File
-    D3DSPR_CONST2         = 11, // Constant Register File  2048 - 4095
-    D3DSPR_CONST3         = 12, // Constant Register File  4096 - 6143
-    D3DSPR_CONST4         = 13, // Constant Register File  6144 - 8191
-    D3DSPR_CONSTBOOL      = 14, // Constant Boolean register file
-    D3DSPR_LOOP           = 15, // Loop counter register file
-    D3DSPR_TEMPFLOAT16    = 16, // 16-bit float temp register file
-    D3DSPR_MISCTYPE       = 17, // Miscellaneous (single) registers.
-    D3DSPR_LABEL          = 18, // Label
-    D3DSPR_PREDICATE      = 19, // Predicate register
-    D3DSPR_FORCE_DWORD  = 0x7fffffff,         // force 32-bit size enum
-} D3DSHADER_PARAM_REGISTER_TYPE;
-
-typedef struct _D3DMATRIX 
-{
-    union 
-	{
-        struct 
-		{
-            float        _11, _12, _13, _14;
-            float        _21, _22, _23, _24;
-            float        _31, _32, _33, _34;
-            float        _41, _42, _43, _44;
-        };
-        float m[4][4];
-    };
-} D3DMATRIX;
-
-typedef struct _D3DVERTEXBUFFER_DESC
-{
-    D3DFORMAT           Format;
-    D3DRESOURCETYPE     Type;
-    DWORD               Usage;
-    D3DPOOL             Pool;
-    UINT                Size;
-
-    DWORD               FVF;
-
-} D3DVERTEXBUFFER_DESC;
-
-class TOGL_CLASS D3DXMATRIX : public D3DMATRIX
-{
-public:
-	D3DXMATRIX operator*( const D3DXMATRIX &o ) const;
-	operator FLOAT* ();
-	float& operator()( int row, int column );
-	const float& operator()( int row, int column ) const;
-};
-
-typedef DWORD D3DCOLOR;
-
-typedef enum _D3DSAMPLERSTATETYPE
-{
-    D3DSAMP_ADDRESSU       = 1,  /* D3DTEXTUREADDRESS for U coordinate */
-    D3DSAMP_ADDRESSV       = 2,  /* D3DTEXTUREADDRESS for V coordinate */
-    D3DSAMP_ADDRESSW       = 3,  /* D3DTEXTUREADDRESS for W coordinate */
-    D3DSAMP_BORDERCOLOR    = 4,  /* D3DCOLOR */
-    D3DSAMP_MAGFILTER      = 5,  /* D3DTEXTUREFILTER filter to use for magnification */
-    D3DSAMP_MINFILTER      = 6,  /* D3DTEXTUREFILTER filter to use for minification */
-    D3DSAMP_MIPFILTER      = 7,  /* D3DTEXTUREFILTER filter to use between mipmaps during minification */
-    D3DSAMP_MIPMAPLODBIAS  = 8,  /* float Mipmap LOD bias */
-    D3DSAMP_MAXMIPLEVEL    = 9,  /* DWORD 0..(n-1) LOD index of largest map to use (0 == largest) */
-    D3DSAMP_MAXANISOTROPY  = 10, /* DWORD maximum anisotropy */
-    D3DSAMP_SRGBTEXTURE    = 11, /* Default = 0 (which means Gamma 1.0,
-                                   no correction required.) else correct for
-                                   Gamma = 2.2 */
-    D3DSAMP_SHADOWFILTER   = 12, /* Tells the sampler that it should be doing shadow compares */
-    D3DSAMP_FORCE_DWORD   = 0x7fffffff, /* force 32-bit size enum */
-} D3DSAMPLERSTATETYPE;
-
-typedef enum _D3DDECLTYPE
-{
-    D3DDECLTYPE_FLOAT1    =  0,  // 1D float expanded to (value, 0., 0., 1.)
-    D3DDECLTYPE_FLOAT2    =  1,  // 2D float expanded to (value, value, 0., 1.)
-    D3DDECLTYPE_FLOAT3    =  2,  // 3D float expanded to (value, value, value, 1.)
-    D3DDECLTYPE_FLOAT4    =  3,  // 4D float
-    D3DDECLTYPE_D3DCOLOR  =  4,  // 4D packed unsigned bytes mapped to 0. to 1. range
-                                 // Input is in D3DCOLOR format (ARGB) expanded to (R, G, B, A)
-    D3DDECLTYPE_UBYTE4    =  5,  // 4D unsigned byte
-    D3DDECLTYPE_SHORT2    =  6,  // 2D signed short expanded to (value, value, 0., 1.)
-    D3DDECLTYPE_SHORT4    =  7,  // 4D signed short
-
-// The following types are valid only with vertex shaders >= 2.0
-
-
-    D3DDECLTYPE_UBYTE4N   =  8,  // Each of 4 bytes is normalized by dividing to 255.0
-    D3DDECLTYPE_SHORT2N   =  9,  // 2D signed short normalized (v[0]/32767.0,v[1]/32767.0,0,1)
-    D3DDECLTYPE_SHORT4N   = 10,  // 4D signed short normalized (v[0]/32767.0,v[1]/32767.0,v[2]/32767.0,v[3]/32767.0)
-    D3DDECLTYPE_USHORT2N  = 11,  // 2D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,0,1)
-    D3DDECLTYPE_USHORT4N  = 12,  // 4D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,v[2]/65535.0,v[3]/65535.0)
-    D3DDECLTYPE_UDEC3     = 13,  // 3D unsigned 10 10 10 format expanded to (value, value, value, 1)
-    D3DDECLTYPE_DEC3N     = 14,  // 3D signed 10 10 10 format normalized and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1)
-    D3DDECLTYPE_FLOAT16_2 = 15,  // Two 16-bit floating point values, expanded to (value, value, 0, 1)
-    D3DDECLTYPE_FLOAT16_4 = 16,  // Four 16-bit floating point values
-    D3DDECLTYPE_UNUSED    = 17,  // When the type field in a decl is unused.
-} D3DDECLTYPE;
-
-typedef enum _D3DDECLMETHOD
-{
-    D3DDECLMETHOD_DEFAULT = 0,
-    D3DDECLMETHOD_PARTIALU,
-    D3DDECLMETHOD_PARTIALV,
-    D3DDECLMETHOD_CROSSUV,    // Normal
-    D3DDECLMETHOD_UV,
-    D3DDECLMETHOD_LOOKUP,               // Lookup a displacement map
-    D3DDECLMETHOD_LOOKUPPRESAMPLED,     // Lookup a pre-sampled displacement map
-} D3DDECLMETHOD;
-
-typedef enum _D3DDECLUSAGE
-{
-    D3DDECLUSAGE_POSITION		= 0,
-    D3DDECLUSAGE_BLENDWEIGHT	= 1,
-    D3DDECLUSAGE_BLENDINDICES	= 2,
-    D3DDECLUSAGE_NORMAL			= 3,
-    D3DDECLUSAGE_PSIZE			= 4,
-    D3DDECLUSAGE_TEXCOORD		= 5,
-    D3DDECLUSAGE_TANGENT		= 6,
-    D3DDECLUSAGE_BINORMAL		= 7,
-    D3DDECLUSAGE_TESSFACTOR		= 8,
-    D3DDECLUSAGE_PLUGH			= 9,	// mystery value
-    D3DDECLUSAGE_COLOR			= 10,
-    D3DDECLUSAGE_FOG			= 11,
-    D3DDECLUSAGE_DEPTH			= 12,
-    D3DDECLUSAGE_SAMPLE			= 13,
-} D3DDECLUSAGE;
-
-typedef enum _D3DPRIMITIVETYPE 
-{
-    D3DPT_POINTLIST             = 1,
-    D3DPT_LINELIST              = 2,
-    D3DPT_TRIANGLELIST          = 4,
-    D3DPT_TRIANGLESTRIP         = 5,
-    D3DPT_FORCE_DWORD           = 0x7fffffff, /* force 32-bit size enum */
-} D3DPRIMITIVETYPE;
-
-// ------------------------------------------------------------------------------------------------------------------------------ //
-// STRUCTURES
-// ------------------------------------------------------------------------------------------------------------------------------ //
-
-typedef struct TOGL_CLASS D3DXPLANE
-{
-	float& operator[]( int i );
-	bool operator==( const D3DXPLANE &o );
-	bool operator!=( const D3DXPLANE &o );
-	operator float*();
-	operator const float*() const;
-
-	float a, b, c, d;
-} D3DXPLANE;
-
-typedef enum _D3DVERTEXBLENDFLAGS
-{
-    D3DVBF_DISABLE  = 0,     // Disable vertex blending
-    D3DVBF_1WEIGHTS = 1,     // 2 matrix blending
-    D3DVBF_2WEIGHTS = 2,     // 3 matrix blending
-    D3DVBF_3WEIGHTS = 3,     // 4 matrix blending
-    D3DVBF_TWEENING = 255,   // blending using D3DRS_TWEENFACTOR
-    D3DVBF_0WEIGHTS = 256,   // one matrix is used with weight 1.0
-    D3DVBF_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
-} D3DVERTEXBLENDFLAGS;
-
-typedef struct _D3DINDEXBUFFER_DESC
-{
-    D3DFORMAT           Format;
-    D3DRESOURCETYPE     Type;
-    DWORD               Usage;
-    D3DPOOL             Pool;
-    UINT                Size;
-} D3DINDEXBUFFER_DESC;
-
-typedef struct _D3DVERTEXELEMENT9
-{
-    WORD    Stream;     // Stream index
-    WORD    Offset;     // Offset in the stream in bytes
-    BYTE    Type;       // Data type
-    BYTE    Method;     // Processing method
-    BYTE    Usage;      // Semantics
-    BYTE    UsageIndex; // Semantic index
-} D3DVERTEXELEMENT9, *LPD3DVERTEXELEMENT9;
-
-
-#define MAX_DEVICE_IDENTIFIER_STRING        512
-typedef struct _D3DADAPTER_IDENTIFIER9
-{
-    char            Driver[MAX_DEVICE_IDENTIFIER_STRING];
-    char            Description[MAX_DEVICE_IDENTIFIER_STRING];
-    char            DeviceName[32];         /* Device name for GDI (ex. \\.\DISPLAY1) */
-
-    LARGE_INTEGER   DriverVersion;          /* Defined for 32 bit components */
-
-    DWORD           VendorId;
-    DWORD           DeviceId;
-    DWORD           SubSysId;
-    DWORD           Revision;
-    DWORD           VideoMemory;
-
-} D3DADAPTER_IDENTIFIER9;
-
-typedef struct _D3DCOLORVALUE 
-{
-    float r;
-    float g;
-    float b;
-    float a;
-} D3DCOLORVALUE;
-
-typedef struct _D3DMATERIAL9 
-{
-    D3DCOLORVALUE   Diffuse;        /* Diffuse color RGBA */
-    D3DCOLORVALUE   Ambient;        /* Ambient color RGB */
-    D3DCOLORVALUE   Specular;       /* Specular 'shininess' */
-    D3DCOLORVALUE   Emissive;       /* Emissive color RGB */
-    float           Power;          /* Sharpness if specular highlight */
-} D3DMATERIAL9;
-
-typedef struct _D3DVOLUME_DESC
-{
-    D3DFORMAT           Format;
-    D3DRESOURCETYPE     Type;
-    DWORD               Usage;
-    D3DPOOL             Pool;
-
-    UINT                Width;
-    UINT                Height;
-    UINT                Depth;
-} D3DVOLUME_DESC;
-
-typedef struct _D3DVIEWPORT9 
-{
-    DWORD       X;
-    DWORD       Y;            /* Viewport Top left */
-    DWORD       Width;
-    DWORD       Height;       /* Viewport Dimensions */
-    float       MinZ;         /* Min/max of clip Volume */
-    float       MaxZ;
-} D3DVIEWPORT9;
-
-typedef struct _D3DPSHADERCAPS2_0
-{
-    DWORD Caps;
-    INT DynamicFlowControlDepth;
-    INT NumTemps;
-    INT StaticFlowControlDepth;
-    INT NumInstructionSlots;
-} D3DPSHADERCAPS2_0;
-
-typedef struct _D3DCAPS9
-{
-    /* Device Info */
-    D3DDEVTYPE  DeviceType;
-
-    /* Caps from DX7 Draw */
-    DWORD   Caps;
-    DWORD   Caps2;
-    
-    /* Cursor Caps */
-    DWORD   CursorCaps;
-
-    /* 3D Device Caps */
-    DWORD   DevCaps;
-
-    DWORD   PrimitiveMiscCaps;
-    DWORD   RasterCaps;
-    DWORD   TextureCaps;
-    DWORD   TextureFilterCaps;          // D3DPTFILTERCAPS for IDirect3DTexture9's
-    
-    DWORD   MaxTextureWidth, MaxTextureHeight;
-    DWORD   MaxVolumeExtent;
-
-    DWORD   MaxTextureAspectRatio;
-    DWORD   MaxAnisotropy;
-    
-    DWORD   TextureOpCaps;
-    DWORD   MaxTextureBlendStages;
-    DWORD   MaxSimultaneousTextures;
-
-    DWORD   VertexProcessingCaps;
-    DWORD   MaxActiveLights;
-    DWORD   MaxUserClipPlanes;
-    DWORD   MaxVertexBlendMatrices;
-    DWORD   MaxVertexBlendMatrixIndex;
-
-    DWORD   MaxPrimitiveCount;          // max number of primitives per DrawPrimitive call
-    DWORD   MaxStreams;
-
-    DWORD   VertexShaderVersion;
-    DWORD   MaxVertexShaderConst;       // number of vertex shader constant registers
-
-    DWORD   PixelShaderVersion;
-
-    // Here are the DX9 specific ones
-    DWORD   DevCaps2;
-    D3DPSHADERCAPS2_0 PS20Caps;
-
-    DWORD   NumSimultaneousRTs;         // Will be at least 1
-    DWORD   MaxVertexShader30InstructionSlots; 
-    DWORD   MaxPixelShader30InstructionSlots;
-	
-	// only on Posix/GL
-	DWORD	FakeSRGBWrite;				// 1 for parts which can't support SRGB writes due to driver issues - 0 for others
-	DWORD	MixedSizeTargets;			// 1 for parts which can mix attachment sizes (RT's color vs depth)
-	DWORD	CanDoSRGBReadFromRTs;		// 0 when we're on Leopard, 1 when on Snow Leopard
-} D3DCAPS9;
-
-typedef struct _D3DDISPLAYMODE
-{
-    UINT            Width;
-    UINT            Height;
-    UINT            RefreshRate;
-    D3DFORMAT       Format;
-} D3DDISPLAYMODE;
-
-typedef struct _D3DGAMMARAMP
-{
-    WORD                red  [256];
-    WORD                green[256];
-    WORD                blue [256];
-} D3DGAMMARAMP;
-
-
-/* Resize Optional Parameters */
-typedef struct _D3DPRESENT_PARAMETERS_
-{
-    UINT                BackBufferWidth;
-    UINT                BackBufferHeight;
-    D3DFORMAT           BackBufferFormat;
-    UINT                BackBufferCount;
-
-    D3DMULTISAMPLE_TYPE MultiSampleType;
-    DWORD               MultiSampleQuality;
-
-    D3DSWAPEFFECT       SwapEffect;
-    VD3DHWND                hDeviceWindow;
-    BOOL                Windowed;
-    BOOL                EnableAutoDepthStencil;
-    D3DFORMAT           AutoDepthStencilFormat;
-    DWORD               Flags;
-
-    /* FullScreen_RefreshRateInHz must be zero for Windowed mode */
-    UINT                FullScreen_RefreshRateInHz;
-    UINT                PresentationInterval;
-} D3DPRESENT_PARAMETERS;
-
-typedef struct _D3DDEVICE_CREATION_PARAMETERS
-{
-    UINT            AdapterOrdinal;
-    D3DDEVTYPE      DeviceType;
-    VD3DHWND            hFocusWindow;
-    DWORD           BehaviorFlags;
-} D3DDEVICE_CREATION_PARAMETERS;
-
-/* Structures for LockBox */
-typedef struct _D3DBOX
-{
-    UINT                Left;
-    UINT                Top;
-    UINT                Right;
-    UINT                Bottom;
-    UINT                Front;
-    UINT                Back;
-} D3DBOX;
-
-typedef struct _D3DLOCKED_BOX
-{
-    INT                 RowPitch;
-    INT                 SlicePitch;
-    void*               pBits;
-} D3DLOCKED_BOX;
-
-typedef struct _D3DSURFACE_DESC
-{
-    D3DFORMAT           Format;
-    D3DRESOURCETYPE     Type;
-    DWORD               Usage;
-    D3DPOOL             Pool;
-
-    D3DMULTISAMPLE_TYPE MultiSampleType;
-    DWORD               MultiSampleQuality;
-    UINT                Width;
-    UINT                Height;
-} D3DSURFACE_DESC;
-
-
-typedef struct _D3DLOCKED_RECT
-{
-    INT                 Pitch;
-    void*               pBits;
-} D3DLOCKED_RECT;
-
-
-typedef struct _D3DRASTER_STATUS
-{
-    BOOL            InVBlank;
-    UINT            ScanLine;
-} D3DRASTER_STATUS;
-
-typedef enum _D3DLIGHTTYPE 
-{
-    D3DLIGHT_POINT          = 1,
-    D3DLIGHT_SPOT           = 2,
-    D3DLIGHT_DIRECTIONAL    = 3,
-    D3DLIGHT_FORCE_DWORD    = 0x7fffffff, /* force 32-bit size enum */
-} D3DLIGHTTYPE;
-
-typedef struct TOGL_CLASS _D3DVECTOR 
-{
-    float x;
-    float y;
-    float z;
-} D3DVECTOR;
-
-class TOGL_CLASS D3DXVECTOR2
-{
-public:
-    operator FLOAT* ();
-    operator CONST FLOAT* () const;
-
-	float x,y;
-};
-
-class TOGL_CLASS D3DXVECTOR3 : public D3DVECTOR
-{
-public:
-	D3DXVECTOR3() {}
-	D3DXVECTOR3( float a, float b, float c );
-    operator FLOAT* ();
-    operator CONST FLOAT* () const;
-};
-
-typedef enum _D3DXINCLUDE_TYPE
-{
-    D3DXINC_LOCAL,
-
-    // force 32-bit size enum
-    D3DXINC_FORCE_DWORD = 0x7fffffff
-
-} D3DXINCLUDE_TYPE;
-
-typedef struct _D3DLIGHT9 
-{
-    D3DLIGHTTYPE    Type;            /* Type of light source */
-    D3DCOLORVALUE   Diffuse;         /* Diffuse color of light */
-    D3DCOLORVALUE   Specular;        /* Specular color of light */
-    D3DCOLORVALUE   Ambient;         /* Ambient color of light */
-    D3DVECTOR       Position;         /* Position in world space */
-    D3DVECTOR       Direction;        /* Direction in world space */
-    float           Range;            /* Cutoff range */
-    float           Falloff;          /* Falloff */
-    float           Attenuation0;     /* Constant attenuation */
-    float           Attenuation1;     /* Linear attenuation */
-    float           Attenuation2;     /* Quadratic attenuation */
-    float           Theta;            /* Inner angle of spotlight cone */
-    float           Phi;              /* Outer angle of spotlight cone */
-} D3DLIGHT9;
-
-class TOGL_CLASS D3DXVECTOR4
-{
-public:
-	D3DXVECTOR4() {}
-	D3DXVECTOR4( float a, float b, float c, float d );
-
-	float x,y,z,w;
-};
-
-//----------------------------------------------------------------------------
-// D3DXMACRO:
-// ----------
-// Preprocessor macro definition.  The application pass in a NULL-terminated
-// array of this structure to various D3DX APIs.  This enables the application
-// to #define tokens at runtime, before the file is parsed.
-//----------------------------------------------------------------------------
-
-typedef struct _D3DXMACRO
-{
-    LPCSTR Name;
-    LPCSTR Definition;
-
-} D3DXMACRO, *LPD3DXMACRO;
-
-// ------------------------------------------------------------------------------------------------------------------------------ //
-// ------------------------------------------------------------------------------------------------------------------------------ //
-// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
-//
-// Also look for any functions marked with "**** FIXED FUNCTION STUFF"
-//
-// It's only laying around here so we don't have to chop up the shader system a lot to strip out the fixed function code paths.
-// ------------------------------------------------------------------------------------------------------------------------------ //
-// ------------------------------------------------------------------------------------------------------------------------------ //
-
-// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
-typedef enum _D3DTRANSFORMSTATETYPE 
-{
-    D3DTS_VIEW          = 2,
-    D3DTS_PROJECTION    = 3,
-    D3DTS_TEXTURE0      = 16,
-    D3DTS_FORCE_DWORD     = 0x7fffffff, /* force 32-bit size enum */
-} D3DTRANSFORMSTATETYPE;
-
-// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
-typedef enum _D3DTEXTUREOP
-{
-    // Control
-    D3DTOP_DISABLE              = 1,      // disables stage
-    D3DTOP_SELECTARG1           = 2,      // the default
-    D3DTOP_SELECTARG2           = 3,
-
-    // Modulate
-    D3DTOP_MODULATE             = 4,      // multiply args together
-    D3DTOP_MODULATE2X           = 5,      // multiply and  1 bit
-    D3DTOP_MODULATE4X           = 6,      // multiply and  2 bits
-
-    // Add
-    D3DTOP_ADD                  =  7,   // add arguments together
-    D3DTOP_ADDSIGNED            =  8,   // add with -0.5 bias
-    D3DTOP_ADDSIGNED2X          =  9,   // as above but left  1 bit
-    D3DTOP_SUBTRACT             = 10,   // Arg1 - Arg2, with no saturation
-    D3DTOP_ADDSMOOTH            = 11,   // add 2 args, subtract product
-                                        // Arg1 + Arg2 - Arg1*Arg2
-                                        // = Arg1 + (1-Arg1)*Arg2
-
-    // Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha)
-    D3DTOP_BLENDDIFFUSEALPHA    = 12, // iterated alpha
-    D3DTOP_BLENDTEXTUREALPHA    = 13, // texture alpha
-    D3DTOP_BLENDFACTORALPHA     = 14, // alpha from D3DRS_TEXTUREFACTOR
-
-    // Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha)
-    D3DTOP_BLENDTEXTUREALPHAPM  = 15, // texture alpha
-    D3DTOP_BLENDCURRENTALPHA    = 16, // by alpha of current color
-
-    // Specular mapping
-    D3DTOP_PREMODULATE            = 17,     // modulate with next texture before use
-    D3DTOP_MODULATEALPHA_ADDCOLOR = 18,     // Arg1.RGB + Arg1.A*Arg2.RGB
-                                            // COLOROP only
-    D3DTOP_MODULATECOLOR_ADDALPHA = 19,     // Arg1.RGB*Arg2.RGB + Arg1.A
-                                            // COLOROP only
-    D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20,  // (1-Arg1.A)*Arg2.RGB + Arg1.RGB
-                                            // COLOROP only
-    D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21,  // (1-Arg1.RGB)*Arg2.RGB + Arg1.A
-                                            // COLOROP only
-
-    // Bump mapping
-    D3DTOP_BUMPENVMAP           = 22, // per pixel env map perturbation
-    D3DTOP_BUMPENVMAPLUMINANCE  = 23, // with luminance channel
-
-    // This can do either diffuse or specular bump mapping with correct input.
-    // Performs the function (Arg1.R*Arg2.R + Arg1.G*Arg2.G + Arg1.B*Arg2.B)
-    // where each component has been scaled and offset to make it signed.
-    // The result is replicated into all four (including alpha) channels.
-    // This is a valid COLOROP only.
-    D3DTOP_DOTPRODUCT3          = 24,
-
-    // Triadic ops
-    D3DTOP_MULTIPLYADD          = 25, // Arg0 + Arg1*Arg2
-    D3DTOP_LERP                 = 26, // (Arg0)*Arg1 + (1-Arg0)*Arg2
-
-    D3DTOP_FORCE_DWORD = 0x7fffffff,
-} D3DTEXTUREOP;
-
-// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
-typedef enum _D3DTEXTURESTAGESTATETYPE
-{
-    D3DTSS_COLOROP        =  1, /* D3DTEXTUREOP - per-stage blending controls for color channels */
-    D3DTSS_COLORARG1      =  2, /* D3DTA_* (texture arg) */
-    D3DTSS_COLORARG2      =  3, /* D3DTA_* (texture arg) */
-    D3DTSS_ALPHAOP        =  4, /* D3DTEXTUREOP - per-stage blending controls for alpha channel */
-    D3DTSS_ALPHAARG1      =  5, /* D3DTA_* (texture arg) */
-    D3DTSS_ALPHAARG2      =  6, /* D3DTA_* (texture arg) */
-    D3DTSS_BUMPENVMAT00   =  7, /* float (bump mapping matrix) */
-    D3DTSS_BUMPENVMAT01   =  8, /* float (bump mapping matrix) */
-    D3DTSS_BUMPENVMAT10   =  9, /* float (bump mapping matrix) */
-    D3DTSS_BUMPENVMAT11   = 10, /* float (bump mapping matrix) */
-    D3DTSS_TEXCOORDINDEX  = 11, /* identifies which set of texture coordinates index this texture */
-    D3DTSS_BUMPENVLOFFSET = 23, /* float offset for bump map luminance */
-    D3DTSS_TEXTURETRANSFORMFLAGS = 24, /* D3DTEXTURETRANSFORMFLAGS controls texture transform */
-    D3DTSS_COLORARG0      = 26, /* D3DTA_* third arg for triadic ops */
-    D3DTSS_RESULTARG      = 28, /* D3DTA_* arg for result (CURRENT or TEMP) */
-    
-
-    D3DTSS_FORCE_DWORD   = 0x7fffffff, /* force 32-bit size enum */
-} D3DTEXTURESTAGESTATETYPE;
-
-//===========================================================================//
-
-enum	GLMVertexAttributeIndex
-{
-	kGLMGenericAttr00 = 0,
-	kGLMGenericAttr01,
-	kGLMGenericAttr02,
-	kGLMGenericAttr03,
-	kGLMGenericAttr04,
-	kGLMGenericAttr05,
-	kGLMGenericAttr06,
-	kGLMGenericAttr07,
-	kGLMGenericAttr08,
-	kGLMGenericAttr09,
-	kGLMGenericAttr10,
-	kGLMGenericAttr11,
-	kGLMGenericAttr12,
-	kGLMGenericAttr13,
-	kGLMGenericAttr14,
-	kGLMGenericAttr15,
-
-	kGLMVertexAttributeIndexMax			// ideally < 32
-};
-
-struct GLMVertexAttributeDesc			// all the info you need to do vertex setup for one attribute
-{
-	CGLMBuffer				*m_buffer;	// NULL allowed in which case m_offset is the full 32-bit pointer.. so you can draw from plain RAM if desired
-	GLuint					m_datasize;	// comp count of the attribute (1-4)
-	GLenum					m_datatype;	// data type of the attribute (GL_FLOAT, GL_UNSIGNED_BYTE, etc)
-	GLuint					m_stride;
-	GLuint					m_offset;	// net offset to attribute 'zero' within the buffer.
-	GLboolean				m_normalized;	// apply to any fixed point data that needs normalizing, esp color bytes
-	
-		// may need a seed value at some point to be able to disambiguate re-lifed buffers holding same pointer
-		// simpler alternative is to do shoot-down inside the vertex/index buffer free calls.
-		// I'd rather not have to have each attribute fiddling a ref count on the buffer to which it refers..
-
-#define	EQ(fff) ( (src.fff) == (fff) )
-	// test in decreasing order of likelihood of difference, but do not include the buffer revision as caller is not supplying it..
-	bool operator==(const GLMVertexAttributeDesc& src)		const { return EQ(m_buffer) && EQ(m_offset) && EQ(m_stride) && EQ(m_datatype) && EQ(m_normalized) && EQ(m_datasize);	}
-#undef EQ
-
-	uint					m_bufferRevision;	// only set in GLM context's copy, to disambiguate references that are same offset / same buffer but cross an orphan event
-};
-
-
-#define MAX_D3DVERTEXELEMENTS	16
-
-struct D3DVERTEXELEMENT9_GL
-{
-	// fields right out of the original decl element (copied)
-	D3DVERTEXELEMENT9		m_dxdecl;	// d3d info
-	//		WORD    Stream;     // Stream index
-	//		WORD    Offset;     // Offset in the stream in bytes
-	//		BYTE    Type;       // Data type
-	//		BYTE    Method;     // Processing method
-	//		BYTE    Usage;      // Semantics
-	//		BYTE    UsageIndex; // Semantic index
-
-	GLMVertexAttributeDesc	m_gldecl;
-	// CGLMBuffer				*m_buffer;		// late-dropped from selected stream desc (left NULL, will replace with stream source buffer at sync time)
-	// GLuint					m_datasize;		// component count (1,2,3,4) of the attrib
-	// GLenum					m_datatype;		// data type of the attribute (GL_FLOAT et al)
-	// GLuint					m_stride;		// late-dropped from stream desc
-	// GLuint					m_offset;		// net offset to attribute 'zero' within the stream data.  Add the stream offset before passing to GL. 
-	// GLuint					m_normalized;	// net offset to attribute 'zero' within the stream data.  Add the stream offset before passing to GL. 
-};
-
-struct IDirect3DDevice9Params
-{
-	UINT					m_adapter;
-	D3DDEVTYPE				m_deviceType;
-	VD3DHWND				m_focusWindow;
-	DWORD					m_behaviorFlags;
-	D3DPRESENT_PARAMETERS	m_presentationParameters;
-};
-
-#define	D3D_MAX_STREAMS	4
-struct D3DStreamDesc
-{
-	IDirect3DVertexBuffer9	*m_vtxBuffer;
-	uint					m_offset;
-	uint					m_stride;
-};
-
-struct D3DIndexDesc
-{
-	IDirect3DIndexBuffer9	*m_idxBuffer;
-};
-
-// we latch sampler values until draw time and then convert them all to GL form
-// note these are similar in name to the fields of a GLMTexSamplingParams but contents are not
-// particularly in the texture filtering area
-
-struct D3DSamplerDesc
-{
-	D3DTEXTUREADDRESS		m_addressModes[3];	// D3DTEXTUREADDRESS modes for S,T,R
-    DWORD					m_borderColor;		// DWORD bordercolor
-	D3DTEXTUREFILTERTYPE	m_magFilter;		// mag filter
-	D3DTEXTUREFILTERTYPE	m_minFilter;		// min filter
-	D3DTEXTUREFILTERTYPE	m_mipFilter;		// mip filter
-	float					m_mipmapBias;		// float: mipmap bias
-    DWORD					m_maxMipLevel;		// DWORD 0..(n-1) LOD index of largest map to use (0 == largest)
-	DWORD					m_maxAniso;			// D3DSAMP_MAXANISOTROPY max aniso
-	DWORD					m_srgb;				// D3DSAMP_SRGBTEXTURE 0 = no SRGB sampling
-	DWORD					m_shadowFilter;		// D3DSAMP_SHADOWFILTER
-};
-
-// Tracking and naming sampler dimensions
-#define SAMPLER_TYPE_2D		0
-#define SAMPLER_TYPE_CUBE	1
-#define SAMPLER_TYPE_3D		2
-#define SAMPLER_TYPE_UNUSED	3
-
-#endif // DXABSTRACT_TYPES_H
diff --git a/mp/src/public/togl/osx/glentrypoints.h b/mp/src/public/togl/osx/glentrypoints.h
deleted file mode 100644
index be8d5446..00000000
--- a/mp/src/public/togl/osx/glentrypoints.h
+++ /dev/null
@@ -1,329 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-//
-// glentrypoints.h
-//
-//===============================================================================
-
-#ifndef GLENTRYPOINTS_H
-#define GLENTRYPOINTS_H
-
-#pragma once
-
-#ifdef DX_TO_GL_ABSTRACTION
-
-#include "tier0/platform.h"
-#include "tier0/dynfunction.h"
-#include "tier0/vprof_telemetry.h"
-#include "interface.h"
-
-#include "togl/rendermechanism.h"
-
-#ifndef APIENTRY
-#define APIENTRY
-#endif
-
-#ifndef CALLBACK
-#define CALLBACK
-#endif
-
-
-void *VoidFnPtrLookup_GlMgr(const char *fn, bool &okay, const bool bRequired, void *fallback=NULL);
-
-#if GL_TELEMETRY_ZONES || GL_TRACK_API_TIME
-class CGLExecuteHelperBase
-{
-public:
-	inline void StartCall(const char *pName);
-	inline void StopCall(const char *pName);
-#if GL_TRACK_API_TIME
-	TmU64 m_nStartTime;
-#endif
-};
-
-template < class FunctionType, typename Result >
-class CGLExecuteHelper : public CGLExecuteHelperBase
-{
-public:
-	inline CGLExecuteHelper(FunctionType pFn, const char *pName ) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(); StopCall(pName); }
-	template<typename A> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a); StopCall(pName); }
-	template<typename A, typename B> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b); StopCall(pName); }
-	template<typename A, typename B, typename C> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D, typename E> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f, g); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f, g, h); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h, I i) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f, g, h, i); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h, I i, J j) : m_pFn( pFn ) { StartCall(pName); m_Result = (*m_pFn)(a, b, c, d, e, f, g, h, i, j); StopCall(pName); }
-
-	inline operator Result() const { return m_Result; }
-	inline operator char*() const { return (char*)m_Result; }
-		
-	FunctionType m_pFn;
-	
-	Result m_Result;
-};
-
-template < class FunctionType>
-class CGLExecuteHelper<FunctionType, void> : public CGLExecuteHelperBase
-{
-public:
-	inline CGLExecuteHelper(FunctionType pFn, const char *pName ) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(); StopCall(pName); }
-	template<typename A> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a); StopCall(pName); }
-	template<typename A, typename B> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b); StopCall(pName); }
-	template<typename A, typename B, typename C> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D, typename E> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f, g); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f, g, h); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h, I i) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f, g, h, i); StopCall(pName); }
-	template<typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J> inline CGLExecuteHelper(FunctionType pFn, const char *pName, A a, B b, C c, D d, E e, F f, G g, H h, I i, J j) : m_pFn( pFn ) { StartCall(pName); (*m_pFn)(a, b, c, d, e, f, g, h, i, j); StopCall(pName); }
-		
-	FunctionType m_pFn;
-};
-#endif
-
-template < class FunctionType, typename Result >
-class CDynamicFunctionOpenGLBase
-{
-public:
-	// Construct with a NULL function pointer. You must manually call
-	//  Lookup() before you can call a dynamic function through this interface.
-	CDynamicFunctionOpenGLBase() : m_pFn(NULL) {}
-
-	// Construct and do a lookup right away. You will need to make sure that
-	//  the lookup actually succeeded, as the gl library might have failed to load
-	//  or (fn) might not exist in it.
-	CDynamicFunctionOpenGLBase(const char *fn, FunctionType fallback=NULL) : m_pFn(NULL)
-	{
-		Lookup(fn, fallback);
-	}
-
-	// Construct and do a lookup right away. See comments in Lookup() about what (okay) does.
-	CDynamicFunctionOpenGLBase(const char *fn, bool &okay, FunctionType fallback=NULL) : m_pFn(NULL)
-	{
-		Lookup(fn, okay, fallback);
-	}
-
-	// Load library if necessary, look up symbol. Returns true and sets
-	//  m_pFn on successful lookup, returns false otherwise. If the
-	//  function pointer is already looked up, this return true immediately.
-	// Use Reset() first if you want to look up the symbol again.
-	//  This function will return false immediately unless (okay) is true.
-	//  This allows you to chain lookups like this:
-	//     bool okay = true;
-	//     x.Lookup(lib, "x", okay);
-	//     y.Lookup(lib, "y", okay);
-	//     z.Lookup(lib, "z", okay);
-	//     if (okay) { printf("All functions were loaded successfully!\n"); }
-	// If you supply a fallback, it'll be used if the lookup fails (and if
-	//  non-NULL, means this will always return (okay)).
-	bool Lookup(const char *fn, bool &okay, FunctionType fallback=NULL)
-	{
-		if (!okay)
-			return false;
-		else if (this->m_pFn == NULL)
-		{
-			this->m_pFn = (FunctionType) VoidFnPtrLookup_GlMgr(fn, okay, false, (void *) fallback);
-			this->SetFuncName( fn );
-		}
-		return okay;
-	}
-
-	// Load library if necessary, look up symbol. Returns true and sets
-	//  m_pFn on successful lookup, returns false otherwise. If the
-	//  function pointer is already looked up, this return true immediately.
-	// Use Reset() first if you want to look up the symbol again.
-	//  This function will return false immediately unless (okay) is true.
-	// If you supply a fallback, it'll be used if the lookup fails (and if
-	//  non-NULL, means this will always return true).
-	bool Lookup(const char *fn, FunctionType fallback=NULL)
-	{
-		bool okay = true;
-		return Lookup(fn, okay, fallback);
-	}
-
-	// Invalidates the current lookup. Makes the function pointer NULL. You
-	//  will need to call Lookup() before you can call a dynamic function
-	//  through this interface again.
-	void Reset() { m_pFn = NULL; }
-
-	// Force this to be a specific function pointer.
-	void Force(FunctionType ptr) { m_pFn = ptr; }
-
-	// Retrieve the actual function pointer.
-	FunctionType Pointer() const { return m_pFn; }
-
-#if GL_TELEMETRY_ZONES || GL_TRACK_API_TIME
-	#if GL_TELEMETRY_ZONES
-		#define GL_FUNC_NAME m_szName
-	#else
-		#define GL_FUNC_NAME ""
-	#endif
-
-	inline CGLExecuteHelper<FunctionType, Result> operator() () const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME ); }
-	
-	template<typename T>
-	inline CGLExecuteHelper<FunctionType, Result> operator() (T a) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a); }
-
-	template<typename T, typename U>
-	inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b); }
-
-	template<typename T, typename U, typename V>
-	inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c ) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c); }
-
-	template<typename T, typename U, typename V, typename W>
-	inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d); }
-
-	template<typename T, typename U, typename V, typename W, typename X>
-	inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e); }
-
-	template<typename T, typename U, typename V, typename W, typename X, typename Y>
-	inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f); }
-
-	template<typename T, typename U, typename V, typename W, typename X, typename Y, typename Z>
-	inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f, Z g) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f, g); }
-
-	template<typename T, typename U, typename V, typename W, typename X, typename Y, typename Z, typename A>
-	inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f, Z g, A h) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f, g, h); }
-
-	template<typename T, typename U, typename V, typename W, typename X, typename Y, typename Z, typename A, typename B>
-	inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f, Z g, A h, B i) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f, g, h, i); }
-
-	template<typename T, typename U, typename V, typename W, typename X, typename Y, typename Z, typename A, typename B, typename C>
-	inline CGLExecuteHelper<FunctionType, Result> operator() (T a, U b, V c, W d, X e, Y f, Z g, A h, B i, C j) const { return CGLExecuteHelper<FunctionType, Result>(m_pFn, GL_FUNC_NAME, a, b, c, d, e, f, g, h, i, j); }
-#else
-	operator FunctionType() const { return m_pFn; }
-#endif
-
-	// Can be used to verify that we have an actual function looked up and
-	//  ready to call: if (!MyDynFunc) { printf("Function not found!\n"); }
-	operator bool () const { return m_pFn != NULL; }
-	bool operator !() const { return m_pFn == NULL; }
-		
-protected:
-	FunctionType m_pFn;
-
-#if GL_TELEMETRY_ZONES
-	char m_szName[32];
-	inline void SetFuncName(const char *pFn) { V_strncpy( m_szName, pFn, sizeof( m_szName ) ); }
-#else
-	inline void SetFuncName(const char *pFn) { (void)pFn; }
-#endif
-};
-
-// This works a lot like CDynamicFunctionMustInit, but we use SDL_GL_GetProcAddress().
-template < const bool bRequired, class FunctionType, typename Result >
-class CDynamicFunctionOpenGL : public CDynamicFunctionOpenGLBase< FunctionType, Result >
-{
-private:  // forbid default constructor.
-	CDynamicFunctionOpenGL() {}
-
-public:
-	CDynamicFunctionOpenGL(const char *fn, FunctionType fallback=NULL)
-	{
-        bool okay = true;
-		Lookup(fn, okay, fallback);
-		this->SetFuncName( fn );
-	}
-
-	CDynamicFunctionOpenGL(const char *fn, bool &okay, FunctionType fallback=NULL)
-	{
-		Lookup(fn, okay, fallback);
-		this->SetFuncName( fn );
-	}
-
-	// Please note this is not virtual.
-	// !!! FIXME: we might want to fall back and try "EXT" or "ARB" versions in some case.
-	bool Lookup(const char *fn, bool &okay, FunctionType fallback=NULL)
-	{
-		if (this->m_pFn == NULL)
-		{
-			this->m_pFn = (FunctionType) VoidFnPtrLookup_GlMgr(fn, okay, bRequired, (void *) fallback);
-			this->SetFuncName( fn );
-		}
-		return okay;
-	}
-};
-
-
-// This provides all the entry points for a given OpenGL context.
-//  ENTRY POINTS ARE ONLY VALID FOR THE CONTEXT THAT WAS CURRENT WHEN
-//  YOU LOOKED THEM UP. 99% of the time, this is not a problem, but
-//  that 1% is really hard to track down. Always access the GL
-//  through this class!
-class COpenGLEntryPoints
-{
-public:
-	// The GL context you are looking up entry points for must be current when you construct this object!
-	COpenGLEntryPoints();
-
-	uint64 m_nTotalGLCycles, m_nTotalGLCalls;
-
-	int m_nOpenGLVersionMajor;  // if GL_VERSION is 2.1.0, this will be set to 2.
-	int m_nOpenGLVersionMinor;  // if GL_VERSION is 2.1.0, this will be set to 1.
-	int m_nOpenGLVersionPatch;  // if GL_VERSION is 2.1.0, this will be set to 0.
-	bool m_bHave_OpenGL;
-
-	#define GL_EXT(x,glmajor,glminor) bool m_bHave_##x;
-	#define GL_FUNC(ext,req,ret,fn,arg,call) CDynamicFunctionOpenGL< req, ret (APIENTRY *) arg, ret > fn;
-	#define GL_FUNC_VOID(ext,req,fn,arg,call) CDynamicFunctionOpenGL< req, void (APIENTRY *) arg, void > fn;
-	#include "togl/glfuncs.inl"
-	#undef GL_FUNC_VOID
-	#undef GL_FUNC
-	#undef GL_EXT
-};
-
-// This will be set to the current OpenGL context's entry points.
-extern COpenGLEntryPoints *gGL;
-typedef void * (*GL_GetProcAddressCallbackFunc_t)(const char *, bool &, const bool, void *);
-
-#ifdef TOGL_DLL_EXPORT
-	DLL_EXPORT COpenGLEntryPoints *ToGLConnectLibraries( CreateInterfaceFn factory );
-	DLL_EXPORT void ToGLDisconnectLibraries();
-	DLL_EXPORT COpenGLEntryPoints *GetOpenGLEntryPoints(GL_GetProcAddressCallbackFunc_t callback);
-#else
-	DLL_IMPORT COpenGLEntryPoints *ToGLConnectLibraries( CreateInterfaceFn factory );
-	DLL_IMPORT void ToGLDisconnectLibraries();
-	DLL_IMPORT COpenGLEntryPoints *GetOpenGLEntryPoints(GL_GetProcAddressCallbackFunc_t callback);
-#endif
-
-#if GL_TELEMETRY_ZONES || GL_TRACK_API_TIME
-inline void CGLExecuteHelperBase::StartCall(const char *pName) 
-{ 
-	(void)pName;
-
-#if GL_TELEMETRY_ZONES	
-	tmEnter( TELEMETRY_LEVEL3, TMZF_NONE, pName );
-#endif
-
-#if GL_TRACK_API_TIME
-	m_nStartTime = tmFastTime();
-#endif
-}
-
-inline void CGLExecuteHelperBase::StopCall(const char *pName) 
-{ 
-#if GL_TRACK_API_TIME
-	uint64 nTotalCycles = tmFastTime() - m_nStartTime;
-#endif
-
-#if GL_TELEMETRY_ZONES
-	tmLeave( TELEMETRY_LEVEL3 );
-#endif
-
-#if GL_TRACK_API_TIME	
-	//double flMilliseconds = g_Telemetry.flRDTSCToMilliSeconds * nTotalCycles;
-	if (gGL) 
-	{ 
-		gGL->m_nTotalGLCycles += nTotalCycles;
-		gGL->m_nTotalGLCalls++; 
-	} 
-#endif
-}
-#endif
-
-#endif // DX_TO_GL_ABSTRACTION
-
-#endif // GLENTRYPOINTS_H
diff --git a/mp/src/public/togl/osx/glfuncs.h b/mp/src/public/togl/osx/glfuncs.h
deleted file mode 100644
index 78184bef..00000000
--- a/mp/src/public/togl/osx/glfuncs.h
+++ /dev/null
@@ -1,184 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-// !!! FIXME: Some of these aren't base OpenGL...pick out the extensions.
-// !!! FIXME: Also, look up these -1, -1 versions numbers.
-GL_FUNC(OpenGL,true,GLenum,glGetError,(void),())
-GL_FUNC_VOID(OpenGL,true,glActiveTexture,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glAlphaFunc,(GLenum a,GLclampf b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glAttachObjectARB,(GLhandleARB a,GLhandleARB b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glBegin,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glBindAttribLocationARB,(GLhandleARB a,GLuint b,const GLcharARB *c),(a,b,c))
-GL_FUNC_VOID(OpenGL,true,glBindBufferARB,(GLenum a,GLuint b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glBindProgramARB,(GLenum a,GLuint b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glBindTexture,(GLenum a,GLuint b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glBlendColor,(GLclampf a,GLclampf b,GLclampf c,GLclampf d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glBlendEquation,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glBlendFunc,(GLenum a,GLenum b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glBufferDataARB,(GLenum a,GLsizeiptrARB b,const GLvoid *c,GLenum d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glClear,(GLbitfield a),(a))
-GL_FUNC_VOID(OpenGL,true,glClearColor,(GLclampf a,GLclampf b,GLclampf c,GLclampf d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glClearDepth,(GLclampd a),(a))
-GL_FUNC_VOID(OpenGL,true,glClearStencil,(GLint a),(a))
-GL_FUNC_VOID(OpenGL,true,glClipPlane,(GLenum a,const GLdouble *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glColorMask,(GLboolean a,GLboolean b,GLboolean c,GLboolean d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glCompileShaderARB,(GLhandleARB a),(a))
-GL_FUNC_VOID(OpenGL,true,glCompressedTexImage2D,(GLenum a,GLint b,GLenum c,GLsizei d,GLsizei e,GLint f,GLsizei g,const GLvoid *h),(a,b,c,d,e,f,g,h))
-GL_FUNC_VOID(OpenGL,true,glCompressedTexImage3D,(GLenum a,GLint b,GLenum c,GLsizei d,GLsizei e,GLsizei f,GLint g,GLsizei h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))
-GL_FUNC(OpenGL,true,GLhandleARB,glCreateProgramObjectARB,(void),())
-GL_FUNC(OpenGL,true,GLhandleARB,glCreateShaderObjectARB,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glDeleteBuffersARB,(GLsizei a,const GLuint *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glDeleteObjectARB,(GLhandleARB a),(a))
-GL_FUNC_VOID(OpenGL,true,glDeleteProgramsARB,(GLsizei a,const GLuint *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glDeleteQueriesARB,(GLsizei a,const GLuint *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glDeleteShader,(GLuint a),(a))
-GL_FUNC_VOID(OpenGL,true,glDeleteTextures,(GLsizei a,const GLuint *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glDepthFunc,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glDepthMask,(GLboolean a),(a))
-GL_FUNC_VOID(OpenGL,true,glDepthRange,(GLclampd a,GLclampd b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glDetachObjectARB,(GLhandleARB a,GLhandleARB b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glDisable,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glDisableVertexAttribArray,(GLuint a),(a))
-GL_FUNC_VOID(OpenGL,true,glDrawArrays,(GLenum a,GLint b,GLsizei c),(a,b,c))
-GL_FUNC_VOID(OpenGL,true,glDrawBuffer,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glDrawRangeElements,(GLenum a,GLuint b,GLuint c,GLsizei d,GLenum e,const GLvoid *f),(a,b,c,d,e,f))
-GL_FUNC_VOID(OpenGL,true,glEnable,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glEnableVertexAttribArray,(GLuint a),(a))
-GL_FUNC_VOID(OpenGL,true,glEnd,(void),())
-GL_FUNC_VOID(OpenGL,true,glFinish,(void),())
-GL_FUNC_VOID(OpenGL,true,glFlush,(void),())
-GL_FUNC_VOID(OpenGL,true,glFrontFace,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glGenBuffersARB,(GLsizei a,GLuint *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glGenProgramsARB,(GLsizei a,GLuint *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glGenQueriesARB,(GLsizei a,GLuint *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glGenTextures,(GLsizei a,GLuint *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glGetBooleanv,(GLenum a,GLboolean *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glGetCompressedTexImage,(GLenum a,GLint b,GLvoid *c),(a,b,c))
-GL_FUNC_VOID(OpenGL,true,glGetDoublev,(GLenum a,GLdouble *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glGetFloatv,(GLenum a,GLfloat *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glGetInfoLogARB,(GLhandleARB a,GLsizei b,GLsizei *c,GLcharARB *d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glGetIntegerv,(GLenum a,GLint *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glGetObjectParameterivARB,(GLhandleARB a,GLenum b,GLint *c),(a,b,c))
-GL_FUNC_VOID(OpenGL,true,glGetProgramivARB,(GLenum a,GLenum b,GLint *c),(a,b,c))
-GL_FUNC(OpenGL,true,const GLubyte *,glGetString,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glGetTexImage,(GLenum a,GLint b,GLenum c,GLenum d,GLvoid *e),(a,b,c,d,e))
-GL_FUNC(OpenGL,true,GLint,glGetUniformLocationARB,(GLhandleARB a,const GLcharARB *b),(a,b))
-GL_FUNC(OpenGL,true,GLboolean,glIsEnabled,(GLenum a),(a))
-GL_FUNC(OpenGL,true,GLboolean,glIsTexture,(GLuint a),(a))
-GL_FUNC_VOID(OpenGL,true,glLinkProgramARB,(GLhandleARB a),(a))
-GL_FUNC(OpenGL,true,GLvoid*,glMapBufferARB,(GLenum a,GLenum b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glOrtho,(GLdouble a,GLdouble b,GLdouble c,GLdouble d,GLdouble e,GLdouble f),(a,b,c,d,e,f))
-GL_FUNC_VOID(OpenGL,true,glPixelStorei,(GLenum a,GLint b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glPolygonMode,(GLenum a,GLenum b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glPolygonOffset,(GLfloat a,GLfloat b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glPopAttrib,(void),())
-GL_FUNC_VOID(OpenGL,true,glProgramStringARB,(GLenum a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glPushAttrib,(GLbitfield a),(a))
-GL_FUNC_VOID(OpenGL,true,glReadBuffer,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glScissor,(GLint a,GLint b,GLsizei c,GLsizei d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glShaderSourceARB,(GLhandleARB a,GLsizei b,const GLcharARB **c,const GLint *d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glStencilFunc,(GLenum a,GLint b,GLuint c),(a,b,c))
-GL_FUNC_VOID(OpenGL,true,glStencilMask,(GLuint a),(a))
-GL_FUNC_VOID(OpenGL,true,glStencilOp,(GLenum a,GLenum b,GLenum c),(a,b,c))
-GL_FUNC_VOID(OpenGL,true,glTexCoord2f,(GLfloat a,GLfloat b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glTexImage2D,(GLenum a,GLint b,GLint c,GLsizei d,GLsizei e,GLint f,GLenum g,GLenum h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))
-GL_FUNC_VOID(OpenGL,true,glTexImage3D,(GLenum a,GLint b,GLint c,GLsizei d,GLsizei e,GLsizei f,GLint g,GLenum h,GLenum i,const GLvoid *j),(a,b,c,d,e,f,g,h,i,j))
-GL_FUNC_VOID(OpenGL,true,glTexParameterfv,(GLenum a,GLenum b,const GLfloat *c),(a,b,c))
-GL_FUNC_VOID(OpenGL,true,glTexParameteri,(GLenum a,GLenum b,GLint c),(a,b,c))
-GL_FUNC_VOID(OpenGL,true,glTexSubImage2D,(GLenum a,GLint b,GLint c,GLint d,GLsizei e,GLsizei f,GLenum g,GLenum h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))
-GL_FUNC_VOID(OpenGL,true,glUniform1f,(GLint a,GLfloat b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glUniform1i,(GLint a,GLint b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glUniform1iARB,(GLint a,GLint b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glUniform4fv,(GLint a,GLsizei b,const GLfloat *c),(a,b,c))
-GL_FUNC(OpenGL,true,GLboolean,glUnmapBuffer,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glUseProgram,(GLuint a),(a))
-GL_FUNC_VOID(OpenGL,true,glVertex3f,(GLfloat a,GLfloat b,GLfloat c),(a,b,c))
-GL_FUNC_VOID(OpenGL,true,glVertexAttribPointer,(GLuint a,GLint b,GLenum c,GLboolean d,GLsizei e,const GLvoid *f),(a,b,c,d,e,f))
-GL_FUNC_VOID(OpenGL,true,glViewport,(GLint a,GLint b,GLsizei c,GLsizei d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glEnableClientState,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glDisableClientState,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glClientActiveTexture,(GLenum a),(a))
-GL_FUNC_VOID(OpenGL,true,glVertexPointer,(GLint a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glTexCoordPointer,(GLint a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glProgramEnvParameters4fvEXT,(GLenum a,GLuint b,GLsizei c,const GLfloat *d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glColor4sv,(const GLshort  *a),(a))
-GL_FUNC_VOID(OpenGL,true,glStencilOpSeparate,(GLenum a,GLenum b,GLenum c,GLenum d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glStencilFuncSeparate,(GLenum a,GLenum b,GLint c,GLuint d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glGetTexLevelParameteriv,(GLenum a,GLint b,GLenum c,GLint *d),(a,b,c,d))
-GL_FUNC_VOID(OpenGL,true,glColor4f,(GLfloat a,GLfloat b,GLfloat c,GLfloat d),(a,b,c,d))
-GL_EXT(GL_EXT_framebuffer_object,-1,-1)
-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glBindFramebufferEXT,(GLenum a,GLuint b),(a,b))
-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glBindRenderbufferEXT,(GLenum a,GLuint b),(a,b))
-GL_FUNC(GL_EXT_framebuffer_object,false,GLenum,glCheckFramebufferStatusEXT,(GLenum a),(a))
-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glDeleteRenderbuffersEXT,(GLsizei a,const GLuint *b),(a,b))
-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferRenderbufferEXT,(GLenum a,GLenum b,GLenum c,GLuint d),(a,b,c,d))
-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferTexture2DEXT,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e),(a,b,c,d,e))
-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferTexture3DEXT,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e,GLint f),(a,b,c,d,e,f))
-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glGenFramebuffersEXT,(GLsizei a,GLuint *b),(a,b))
-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glGenRenderbuffersEXT,(GLsizei a,GLuint *b),(a,b))
-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glDeleteFramebuffersEXT,(GLsizei a,const GLuint *b),(a,b))
-GL_EXT(GL_EXT_framebuffer_blit,-1,-1)
-GL_FUNC_VOID(GL_EXT_framebuffer_blit,false,glBlitFramebufferEXT,(GLint a,GLint b,GLint c,GLint d,GLint e,GLint f,GLint g,GLint h,GLbitfield i,GLenum j),(a,b,c,d,e,f,g,h,i,j))
-GL_EXT(GL_EXT_framebuffer_multisample,-1,-1)
-GL_FUNC_VOID(GL_EXT_framebuffer_multisample,false,glRenderbufferStorageMultisampleEXT,(GLenum a,GLsizei b,GLenum c,GLsizei d,GLsizei e),(a,b,c,d,e))
-GL_EXT(GL_APPLE_fence,-1,-1)
-GL_FUNC(GL_APPLE_fence,false,GLboolean,glTestFenceAPPLE,(GLuint a),(a))
-GL_FUNC_VOID(GL_APPLE_fence,false,glSetFenceAPPLE,(GLuint a),(a))
-GL_FUNC_VOID(GL_APPLE_fence,false,glFinishFenceAPPLE,(GLuint a),(a))
-GL_FUNC_VOID(GL_APPLE_fence,false,glDeleteFencesAPPLE,(GLsizei a,const GLuint *b),(a,b))
-GL_FUNC_VOID(GL_APPLE_fence,false,glGenFencesAPPLE,(GLsizei a,GLuint *b),(a,b))
-GL_EXT(GL_NV_fence,-1,-1)
-GL_FUNC(GL_NV_fence,false,GLboolean,glTestFenceNV,(GLuint a),(a))
-GL_FUNC_VOID(GL_NV_fence,false,glSetFenceNV,(GLuint a,GLenum b),(a,b))
-GL_FUNC_VOID(GL_NV_fence,false,glFinishFenceNV,(GLuint a),(a))
-GL_FUNC_VOID(GL_NV_fence,false,glDeleteFencesNV,(GLsizei a,const GLuint *b),(a,b))
-GL_FUNC_VOID(GL_NV_fence,false,glGenFencesNV,(GLsizei a,GLuint *b),(a,b))
-GL_EXT(GL_ARB_sync,3,2)
-#ifdef HAVE_GL_ARB_SYNC
-GL_FUNC_VOID(GL_ARB_sync,false,glGetSynciv,(GLsync a, GLenum b, GLsizei c, GLsizei *d, GLint *e),(a,b,c,d,e))
-GL_FUNC(GL_ARB_sync,false,GLenum,glClientWaitSync,(GLsync a, GLbitfield b, GLuint64 c),(a,b,c))
-GL_FUNC_VOID(GL_ARB_sync,false,glWaitSync,(GLsync a, GLbitfield b, GLuint64 c),(a,b,c))
-GL_FUNC_VOID(GL_ARB_sync,false,glDeleteSync,(GLsync a),(a))
-GL_FUNC(GL_ARB_sync,false,GLsync,glFenceSync,(GLenum a, GLbitfield b),(a,b))
-#endif
-GL_EXT(GL_EXT_draw_buffers2,-1,-1)
-GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glColorMaskIndexedEXT,(GLuint a,GLboolean b,GLboolean c,GLboolean d,GLboolean e),(a,b,c,d,e))
-GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glEnableIndexedEXT,(GLenum a,GLuint b),(a,b))
-GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glDisableIndexedEXT,(GLenum a,GLuint b),(a,b))
-GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glGetBooleanIndexedvEXT,(GLenum a,GLuint b,GLboolean  *c),(a,b,c))
-GL_EXT(GL_EXT_bindable_uniform,-1,-1)
-GL_FUNC_VOID(GL_EXT_bindable_uniform,false,glUniformBufferEXT,(GLuint a,GLint b,GLuint c),(a,b,c))
-GL_EXT(GL_APPLE_flush_buffer_range,-1,-1)
-GL_FUNC_VOID(GL_APPLE_flush_buffer_range,false,glBufferParameteriAPPLE,(GLenum a,GLenum b,GLint c),(a,b,c))
-GL_FUNC_VOID(GL_APPLE_flush_buffer_range,false,glFlushMappedBufferRangeAPPLE,(GLenum a,GLintptr b,GLsizeiptr c),(a,b,c))
-GL_EXT(GL_ARB_map_buffer_range,-1,-1)
-GL_FUNC(GL_ARB_map_buffer_range,false,void*,glMapBufferRange,(GLenum a,GLintptr b,GLsizeiptr c,GLbitfield d),(a,b,c,d))
-GL_FUNC_VOID(GL_ARB_map_buffer_range,false,glFlushMappedBufferRange,(GLenum a,GLintptr b,GLsizeiptr c),(a,b,c))
-GL_EXT(GL_ARB_occlusion_query,-1,-1)
-GL_FUNC_VOID(GL_ARB_occlusion_query,false,glBeginQueryARB,(GLenum a,GLuint b),(a,b))
-GL_FUNC_VOID(GL_ARB_occlusion_query,false,glEndQueryARB,(GLenum a),(a))
-GL_FUNC_VOID(GL_ARB_occlusion_query,false,glGetQueryObjectivARB,(GLuint a,GLenum b,GLint *c),(a,b,c))
-GL_FUNC_VOID(GL_ARB_occlusion_query,false,glGetQueryObjectuivARB,(GLuint a,GLenum b,GLuint *c),(a,b,c))
-GL_EXT(GL_APPLE_texture_range,-1,-1)
-GL_FUNC_VOID(GL_APPLE_texture_range,false,glTextureRangeAPPLE,(GLenum a,GLsizei b,void *c),(a,b,c))
-GL_FUNC_VOID(GL_APPLE_texture_range,false,glGetTexParameterPointervAPPLE,(GLenum a,GLenum b,void* *c),(a,b,c))
-GL_EXT(GL_APPLE_client_storage,-1,-1)
-GL_EXT(GL_ARB_uniform_buffer,-1,-1)
-GL_EXT(GL_ARB_vertex_array_bgra,-1,-1)
-GL_EXT(GL_EXT_vertex_array_bgra,-1,-1)
-GL_EXT(GL_ARB_framebuffer_object,3,0)
-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBindFramebuffer,(GLenum a,GLuint b),(a,b))
-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBindRenderbuffer,(GLenum a,GLuint b),(a,b))
-GL_FUNC(GL_ARB_framebuffer_object,false,GLenum,glCheckFramebufferStatus,(GLenum a),(a))
-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glDeleteRenderbuffers,(GLsizei a,const GLuint *b),(a,b))
-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferRenderbuffer,(GLenum a,GLenum b,GLenum c,GLuint d),(a,b,c,d))
-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferTexture2D,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e),(a,b,c,d,e))
-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferTexture3D,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e,GLint f),(a,b,c,d,e,f))
-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glGenFramebuffers,(GLsizei a,GLuint *b),(a,b))
-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glGenRenderbuffers,(GLsizei a,GLuint *b),(a,b))
-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glDeleteFramebuffers,(GLsizei a,const GLuint *b),(a,b))
-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBlitFramebuffer,(GLint a,GLint b,GLint c,GLint d,GLint e,GLint f,GLint g,GLint h,GLbitfield i,GLenum j),(a,b,c,d,e,f,g,h,i,j))
-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glRenderbufferStorageMultisample,(GLenum a,GLsizei b,GLenum c,GLsizei d,GLsizei e),(a,b,c,d,e))
-GL_EXT(GL_GREMEDY_string_marker,-1,-1)
-GL_FUNC_VOID(GL_GREMEDY_string_marker,false,glStringMarkerGREMEDY,(GLsizei a,const void *b),(a,b))
-GL_FUNC_VOID(OpenGL,true,glPushClientAttrib,(GLbitfield a),(a))
-GL_FUNC_VOID(OpenGL,true,glPopClientAttrib,(void),())
-
diff --git a/mp/src/public/togl/osx/glmdebug.h b/mp/src/public/togl/osx/glmdebug.h
deleted file mode 100644
index ee60a3a4..00000000
--- a/mp/src/public/togl/osx/glmdebug.h
+++ /dev/null
@@ -1,157 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-#ifndef GLMDEBUG_H
-#define	GLMDEBUG_H
-
-#include "tier0/platform.h"
-#include <stdarg.h>
-
-// include this anywhere you need to be able to compile-out code related specifically to GLM debugging.
-
-// we expect DEBUG to be driven by the build system so you can include this header anywhere.
-// when we come out, GLMDEBUG will be defined to a value - 0, 1, or 2
-// 0 means no GLM debugging is possible
-// 1 means it's possible and resulted from being a debug build
-// 2 means it's possible and resulted from being manually forced on for a release build
-
-#ifdef POSIX
-	#ifndef GLMDEBUG
-		#ifdef DEBUG
-			#define GLMDEBUG 1	// normally 1 here, testing
-		#else
-			// #define GLMDEBUG 2			// don't check this in enabled..
-		#endif
-		
-		#ifndef GLMDEBUG
-			#define GLMDEBUG 0
-		#endif
-	#endif
-#else
-	#ifndef GLMDEBUG
-		#define GLMDEBUG 0
-	#endif
-#endif
-
-
-//===============================================================================
-// debug channels
-
-enum EGLMDebugChannel
-{
-	ePrintf,
-	eDebugger,
-	eGLProfiler
-};
-
-#if GLMDEBUG
-	// make all these prototypes disappear in non GLMDEBUG
-	void	GLMDebugInitialize( bool forceReinit=false );
-
-	bool	GLMDetectOGLP( void );
-	bool	GLMDetectGDB( void );
-	uint	GLMDetectAvailableChannels( void );
-
-	uint	GLMDebugChannelMask( uint *newValue = NULL );
-		// note that GDB and OGLP can both come and go during run - forceCheck will allow that to be detected.
-		// mask returned is in form of 1<<n, n from EGLMDebugChannel
-#endif
-
-//===============================================================================
-// debug message flavors
-
-enum EGLMDebugFlavor
-{
-	eAllFlavors,		// 0
-	eDebugDump,			// 1 debug dump flavor								-D-
-	eTenure,			// 2 code tenures									> <
-	eComment,			// 3 one off messages								---
-	eMatrixData,		// 4 matrix data									-M-
-	eShaderData,		// 5 shader data (params)							-S-
-	eFrameBufData,		// 6 FBO data (attachments)							-F-
-	eDXStuff,			// 7 dxabstract spew								-X-
-	eAllocations,		// 8 tracking allocs and frees						-A-
-	eSlowness,			// 9 slow things happening (srgb flips..)			-Z-
-	eDefaultFlavor,		// not specified (no marker)
-	eFlavorCount
-};
-uint	GLMDebugFlavorMask( uint *newValue = NULL );
-
-// make all these prototypes disappear in non GLMDEBUG
-#if GLMDEBUG
-		// these are unconditional outputs, they don't interrogate the string
-	void	GLMStringOut( const char *string );
-	void	GLMStringOutIndented( const char *string, int indentColumns );
-
-	#ifdef TOGL_DLL_EXPORT
-			// these will look at the string to guess its flavor: <, >, ---, -M-, -S- 
-		DLL_EXPORT void	GLMPrintfVA( const char *fmt, va_list vargs );
-		DLL_EXPORT void	GLMPrintf( const char *fmt, ... );
-	#else
-		DLL_IMPORT void	GLMPrintfVA( const char *fmt, va_list vargs );
-		DLL_IMPORT void	GLMPrintf( const char *fmt, ... );
-	#endif
-
-		// these take an explicit flavor with a default value
-	void	GLMPrintStr( const char *str, EGLMDebugFlavor flavor = eDefaultFlavor );
-
-	#define	GLMPRINTTEXT_NUMBEREDLINES	0x80000000
-	void	GLMPrintText( const char *str, EGLMDebugFlavor flavor = eDefaultFlavor, uint options=0  );			// indent each newline
-
-	int		GLMIncIndent( int indentDelta );
-	int		GLMGetIndent( void );
-	void	GLMSetIndent( int indent );
-
-#endif
-
-// helpful macro if you are in a position to call GLM functions directly (i.e. you live in materialsystem / shaderapidx9)
-#if GLMDEBUG
-	#define	GLMPRINTF(args)			GLMPrintf args
-	#define	GLMPRINTSTR(args)		GLMPrintStr args
-	#define	GLMPRINTTEXT(args)		GLMPrintText args
-#else
-	#define	GLMPRINTF(args)	
-	#define	GLMPRINTSTR(args)
-	#define	GLMPRINTTEXT(args)
-#endif
-
-
-//===============================================================================
-// knob twiddling
-#ifdef TOGL_DLL_EXPORT
-	DLL_EXPORT float	GLMKnob( char *knobname, float *setvalue );	// Pass NULL to not-set the knob value
-	DLL_EXPORT float	GLMKnobToggle( char *knobname );
-#else
-	DLL_IMPORT float	GLMKnob( char *knobname, float *setvalue );	// Pass NULL to not-set the knob value
-	DLL_IMPORT float	GLMKnobToggle( char *knobname );
-#endif
-
-//===============================================================================
-// other stuff
-
-#if GLMDEBUG
-void GLMTriggerDebuggerBreak();
-inline void GLMDebugger( void )
-{
-	if (GLMDebugChannelMask() & (1<<eDebugger))
-	{
-		DebuggerBreak();
-	}
-	
-	if (GLMDebugChannelMask() & (1<<eGLProfiler))
-	{
-		GLMTriggerDebuggerBreak();
-	}
-}
-#else
-	#define	GLMDebugger() do { } while(0)
-#endif
-
-// helpers for CGLSetOption - no op if no profiler
-void	GLMProfilerClearTrace( void );
-void	GLMProfilerEnableTrace( bool enable );
-
-// helpers for CGLSetParameter - no op if no profiler
-void	GLMProfilerDumpState( void );
-
-void CheckGLError( int line );
-
-#endif // GLMDEBUG_H
diff --git a/mp/src/public/togl/osx/glmdisplay.h b/mp/src/public/togl/osx/glmdisplay.h
deleted file mode 100644
index cf3a3b90..00000000
--- a/mp/src/public/togl/osx/glmdisplay.h
+++ /dev/null
@@ -1,177 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-//
-// glmdisplay.h
-// display related stuff - used by both GLMgr and the CocoaMgr
-//
-//===============================================================================
-
-#ifndef GLMDISPLAY_H
-#define	GLMDISPLAY_H
-
-#pragma once
-
-#ifdef OSX
-#include <OpenGL/OpenGL.h>
-#include <OpenGL/gl.h>
-#include <OpenGL/glext.h>
-#include <OpenGL/CGLTypes.h>
-#include <OpenGL/CGLRenderers.h>
-#include <OpenGL/CGLCurrent.h>
-
-typedef uint32_t CGDirectDisplayID; 
-typedef uint32_t CGOpenGLDisplayMask; 
-typedef double CGRefreshRate; 
-
-//#include <ApplicationServices/ApplicationServices.h>
-#elif defined(LINUX)
-#include "tier0/platform.h"
-#include <GL/gl.h>
-#include <GL/glext.h>
-#else
-#error
-#endif
-
-typedef void _PseudoNSGLContext;					// aka NSOpenGLContext
-typedef _PseudoNSGLContext	*PseudoNSGLContextPtr;
-
-struct GLMDisplayModeInfoFields
-{
-	uint	m_modePixelWidth;
-	uint	m_modePixelHeight;
-	uint	m_modeRefreshHz;
-	// are we even going to talk about bit depth... not yet
-};
-
-struct GLMDisplayInfoFields
-{
-#ifdef OSX
-	CGDirectDisplayID				m_cgDisplayID;
-	CGOpenGLDisplayMask				m_glDisplayMask;		// result of CGDisplayIDToOpenGLDisplayMask on the cg_displayID.
-#endif
-	uint							m_displayPixelWidth;
-	uint							m_displayPixelHeight;	
-};
-
-struct GLMRendererInfoFields
-{
-	/*properties of interest and their desired values.
-	
-	   kCGLRPFullScreen          =  54,		true
-	   kCGLRPAccelerated         =  73,		true
-	   kCGLRPWindow              =  80,		true
-
-	   kCGLRPRendererID          =  70,		informational
-	   kCGLRPDisplayMask         =  84,		informational
-	   kCGLRPBufferModes         = 100,		informational
-	   kCGLRPColorModes          = 103,		informational
-	   kCGLRPAccumModes          = 104,		informational
-	   kCGLRPDepthModes          = 105,		informational
-	   kCGLRPStencilModes        = 106,		informational
-	   kCGLRPMaxAuxBuffers       = 107,		informational
-	   kCGLRPMaxSampleBuffers    = 108,		informational
-	   kCGLRPMaxSamples          = 109,		informational
-	   kCGLRPSampleModes         = 110,		informational
-	   kCGLRPSampleAlpha         = 111,		informational
-	   kCGLRPVideoMemory         = 120,		informational
-	   kCGLRPTextureMemory       = 121,		informational
-	   kCGLRPRendererCount       = 128		number of renderers in the CGLRendererInfoObj under examination
-
-	   kCGLRPOffScreen           =  53,		D/C
-	   kCGLRPRobust              =  75,		FALSE or D/C - aka we're asking for no-fallback
-	   kCGLRPBackingStore        =  76,		D/C
-	   kCGLRPMPSafe              =  78,		D/C
-	   kCGLRPMultiScreen         =  81,		D/C
-	   kCGLRPCompliant           =  83,		D/C
-	*/
-
-
-	//--------------------------- info we have from CGL renderer queries, IOKit, Gestalt
-	//--------------------------- these are set up in the displayDB by CocoaMgr
-	GLint	m_fullscreen;
-	GLint	m_accelerated;
-	GLint	m_windowed;
-	
-	GLint	m_rendererID;
-	GLint	m_displayMask;
-	GLint	m_bufferModes;
-	GLint	m_colorModes;
-	GLint	m_accumModes;
-	GLint	m_depthModes;
-	GLint	m_stencilModes;
-
-	GLint	m_maxAuxBuffers;
-	GLint	m_maxSampleBuffers;
-	GLint	m_maxSamples;
-	GLint	m_sampleModes;
-	GLint	m_sampleAlpha;
-
-	GLint	m_vidMemory;
-	GLint	m_texMemory;
-	
-	uint	m_pciVendorID;
-	uint	m_pciDeviceID;
-	char	m_pciModelString[64];
-	char	m_driverInfoString[64];
-
-	//--------------------------- OS version related - set up by CocoaMgr
-
-	// OS version found
-	uint	m_osComboVersion;			// 0x00XXYYZZ : XX major, YY minor, ZZ minor minor : 10.6.3 --> 0x000A0603.  10.5.8 --> 0x000A0508.
-		
-	//--------------------------- shorthands - also set up by CocoaMgr - driven by vendorid / deviceid
-
-	bool	m_ati;
-	bool	m_atiR5xx;
-	bool	m_atiR6xx;
-	bool	m_atiR7xx;
-	bool	m_atiR8xx;
-	bool	m_atiNewer;
-	
-	bool	m_intel;
-	bool	m_intel95x;
-	bool	m_intel3100;
-	bool	m_intelNewer;
-
-	bool	m_nv;
-	bool	m_nvG7x;
-	bool	m_nvG8x;
-	bool	m_nvNewer;
-	
-	//--------------------------- context query results - left blank in the display DB - but valid in a GLMContext (call ctx->Caps() to get a const ref)
-	
-	// booleans	
-	bool	m_hasGammaWrites;			// aka glGetBooleanv(GL_FRAMEBUFFER_SRGB_CAPABLE_EXT) / glEnable(GL_FRAMEBUFFER_SRGB_EXT)
-	bool	m_hasMixedAttachmentSizes;	// aka ARB_fbo in 10.6.3 - test for min OS vers, then exported ext string
-	bool	m_hasBGRA;					// aka GL_BGRA vertex attribs in 10.6.3 -  - test for min OS vers, then exported ext string
-	bool	m_hasNewFullscreenMode;		// aka 10.6.x "big window" fullscreen mode
-	bool	m_hasNativeClipVertexMode;	// aka GLSL gl_ClipVertex does not fall back to SW- OS version and folklore-based
-	bool	m_hasOcclusionQuery;		// occlusion query: do you speak it ?!
-	bool	m_hasFramebufferBlit;		// framebuffer blit: know what I'm sayin?!
-	bool	m_hasPerfPackage1;			// means new MTGL, fast OQ, fast uniform upload, NV can resolve flipped (late summer 2010 post 10.6.4 update)
-	
-	// counts
-	int		m_maxAniso;					// aniso limit - context query
-	
-	// other exts
-	bool	m_hasBindableUniforms;
-	bool	m_hasUniformBuffers;
-	
-	// runtime options that aren't negotiable once set
-	bool	m_hasDualShaders;			// must supply CLI arg "-glmdualshaders" or we go GLSL only
-
-	//--------------------------- " can'ts " - specific problems that need to be worked around
-
-	bool	m_cantBlitReliably;		// Intel chipsets have problems blitting sRGB sometimes
-	bool	m_cantAttachSRGB;		// NV G8x on 10.5.8 can't have srgb tex on FBO color - separate issue from hasGammaWrites
-	bool	m_cantResolveFlipped;	// happens on NV in 10.6.4 and prior - console variable "gl_can_resolve_flipped" can overrule
-	bool	m_cantResolveScaled;	// happens everywhere per GL spec but may be relaxed some day - console variable "gl_can_resolve_scaled" can overrule
-	bool	m_costlyGammaFlips;		// this means that sRGB sampling state affects shader code gen, resulting in state-dependent code regen
-
-
-	//--------------------------- " bads " - known bad drivers
-	bool	m_badDriver1064NV;		// this is the bad NVIDIA driver on 10.6.4 - stutter, tex corruption, black screen issues
-};
-
-
-
-#endif
diff --git a/mp/src/public/togl/osx/glmdisplaydb.h b/mp/src/public/togl/osx/glmdisplaydb.h
deleted file mode 100644
index 05c98dc8..00000000
--- a/mp/src/public/togl/osx/glmdisplaydb.h
+++ /dev/null
@@ -1,115 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-#ifndef GLMDISPLAYDB_H
-#define	GLMDISPLAYDB_H
-
-#include "tier1/utlvector.h"
-
-//===============================================================================
-
-// modes, displays, and renderers
-// think of renderers as being at the top of a tree.
-// each renderer has displays hanging off of it.
-// each display has modes hanging off of it.
-// the tree is populated on demand and then queried as needed.
-
-//===============================================================================
-
-// GLMDisplayModeInfoFields is in glmdisplay.h
-
-class GLMDisplayMode
-{
-public:
-	GLMDisplayModeInfoFields	m_info;
-	
-	GLMDisplayMode( uint width, uint height, uint refreshHz );
-	GLMDisplayMode() { };
-	~GLMDisplayMode( void );
-
-	
-	void	Init( uint width, uint height, uint refreshHz );
-	void	Dump( int which );
-};
-
-//===============================================================================
-
-// GLMDisplayInfoFields is in glmdisplay.h
-
-class GLMDisplayInfo
-{
-public:
-	GLMDisplayInfoFields			m_info;
-	CUtlVector< GLMDisplayMode* >	*m_modes;				// starts out NULL, set by PopulateModes
-
-	GLMDisplayInfo( void );
-	~GLMDisplayInfo( void );
-	
-	void	PopulateModes( void );
-
-	void	Dump( int which );
-};
-
-//===============================================================================
-
-// GLMRendererInfoFields is in glmdisplay.h
-
-class GLMRendererInfo
-{
-public:
-	GLMRendererInfoFields			m_info;
-	GLMDisplayInfo					*m_display;			// starts out NULL, set by PopulateDisplays
-
-	GLMRendererInfo			( GLMRendererInfoFields *info );
-	~GLMRendererInfo		( void );
-
-	void	PopulateDisplays();
-	void	Dump( int which );
-};
-
-//===============================================================================
-
-// this is just a tuple describing fake adapters which are really renderer/display pairings.
-// dxabstract bridges the gap between the d3d adapter-centric world and the GL renderer+display world.
-// this makes it straightforward to handle cases like two video cards with two displays on one, and one on the other -
-// you get three fake adapters which represent each useful screen.
-
-// the constraint that dxa will have to follow though, is that if the user wants to change their 
-// display selection for full screen, they would only be able to pick on that has the same underlying renderer.
-// can't change fakeAdapter from one to another with different GL renderer under it.  Screen hop but no card hop.
-
-struct GLMFakeAdapter
-{
-	int		m_rendererIndex;
-	int		m_displayIndex;
-};
-
-class GLMDisplayDB
-{
-public:
-	CUtlVector< GLMRendererInfo* >		*m_renderers;			// starts out NULL, set by PopulateRenderers
-
-	CUtlVector< GLMFakeAdapter >		m_fakeAdapters;
-	
-	GLMDisplayDB	( void );
-	~GLMDisplayDB	( void );	
-
-	virtual void	PopulateRenderers( void );
-	virtual void	PopulateFakeAdapters( uint realRendererIndex );		// fake adapters = one real adapter times however many displays are on it
-	virtual void	Populate( void );
-	
-	// The info-get functions return false on success.
-	virtual	int		GetFakeAdapterCount( void );
-	virtual	bool	GetFakeAdapterInfo( int fakeAdapterIndex, int *rendererOut, int *displayOut, GLMRendererInfoFields *rendererInfoOut, GLMDisplayInfoFields *displayInfoOut );
-	
-	virtual	int		GetRendererCount( void );
-	virtual	bool	GetRendererInfo( int rendererIndex, GLMRendererInfoFields *infoOut );
-	
-	virtual	int		GetDisplayCount( int rendererIndex );
-	virtual	bool	GetDisplayInfo( int rendererIndex, int displayIndex, GLMDisplayInfoFields *infoOut );
-
-	virtual	int		GetModeCount( int rendererIndex, int displayIndex );
-	virtual	bool	GetModeInfo( int rendererIndex, int displayIndex, int modeIndex, GLMDisplayModeInfoFields *infoOut );
-	
-	virtual	void	Dump( void );
-};
-
-#endif // GLMDISPLAYDB_H
diff --git a/mp/src/public/togl/osx/glmgr.h b/mp/src/public/togl/osx/glmgr.h
deleted file mode 100644
index cdf64206..00000000
--- a/mp/src/public/togl/osx/glmgr.h
+++ /dev/null
@@ -1,1088 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-//
-// glmgr.h
-//	singleton class, common basis for managing GL contexts
-//	responsible for tracking adapters and contexts
-//
-//===============================================================================
-
-#ifndef GLMGR_H
-#define	GLMGR_H
-
-#pragma once
-
-#undef HAVE_GL_ARB_SYNC
-#ifdef LINUX
-#define HAVE_GL_ARB_SYNC 1
-#endif
-
-#include "glentrypoints.h"
-#include "glmdebug.h"
-#include "glmdisplay.h"
-#include "glmgrext.h"
-#include "glmgrbasics.h"
-#include "cglmtex.h"
-#include "cglmfbo.h"
-#include "cglmprogram.h"
-#include "cglmbuffer.h"
-#include "cglmquery.h"
-
-#include "tier0/vprof_telemetry.h"
-#include "materialsystem/ishader.h"
-#include "dxabstract_types.h"
-
-
-#ifdef LINUX
-#define Debugger DebuggerBreak
-#undef CurrentTime
-
-// prevent some conflicts in SDL headers...
-#undef M_PI
-#include <stdint.h>
-#ifndef _STDINT_H_
-#define _STDINT_H_ 1
-#endif
-
-#include "SDL/SDL.h"
-#endif
-
-//===============================================================================
-// glue to call out to Obj-C land (these are in glmgrcocoa.mm)
-#ifdef OSX
-PseudoNSGLContextPtr  GetCurrentNSGLContext( );
-CGLContextObj         GetCGLContextFromNSGL( PseudoNSGLContextPtr nsglCtx );
-#endif
-
-#include "tier0/dynfunction.h"
-
-//===============================================================================
-
-// parrot the D3D present parameters, more or less... "adapter" translates into "active display index" per the m_activeDisplayCount below.
-class GLMDisplayParams
-{
-	public:
-
-		// presumption, these indices are in sync with the current display DB that GLMgr has handy
-	//int					m_rendererIndex;		// index of renderer (-1 if root context)
-	//int					m_displayIndex;			// index of display in renderer - for FS
-	//int					m_modeIndex;			// index of mode in display - for FS
-
-	void				*m_focusWindow;			// (VD3DHWND aka WindowRef) - what window does this context display into
-	
-	bool				m_fsEnable;				// fullscreen on or not
-	bool				m_vsyncEnable;			// vsync on or not
-
-	// height and width have to match the display mode info if full screen.
-	
-	uint				m_backBufferWidth;		// pixel width (aka screen h-resolution if full screen)
-	uint				m_backBufferHeight;		// pixel height (aka screen v-resolution if full screen)
-	D3DFORMAT           m_backBufferFormat;		// pixel format
-	uint				m_multiSampleCount;		// 0 means no MSAA, 2 means 2x MSAA, etc
-		// uint				m_multiSampleQuality;	// no MSAA quality control yet
-		
-	bool				m_enableAutoDepthStencil;	// generally set to 'TRUE' per CShaderDeviceDx8::SetPresentParameters
-	D3DFORMAT			m_autoDepthStencilFormat;
-	
-	uint				m_fsRefreshHz;			// if full screen, this refresh rate (likely 0 for LCD's)
-	
-	//uint				m_rootRendererID;		// only used if m_rendererIndex is -1.
-	//uint				m_rootDisplayMask;		// only used if m_rendererIndex is -1.
-
-	bool				m_mtgl;					// enable multi threaded GL driver
-};
-
-//===============================================================================
-
-class GLMgr
-{
-public:
-	
-	//===========================================================================
-	// class methods - singleton
-	static void		NewGLMgr( void );			// instantiate singleton..
-	static GLMgr	*aGLMgr( void );			// return singleton..
-	static void		DelGLMgr( void );			// tear down singleton..
-
-	//===========================================================================
-	// plain methods
-
-					#if 0				// turned all these off while new approach is coded
-						void			RefreshDisplayDB( void );	// blow away old display DB, make a new one
-						GLMDisplayDB	*GetDisplayDB( void );		// get a ptr to the one GLMgr keeps.  only valid til next refresh.
-
-							// eligible renderers will be ranked by desirability starting at index 0 within the db
-							// within each renderer, eligible displays will be ranked some kind of desirability (area? dist from menu bar?) 
-							// within each display, eligible modes will be ranked by descending areas
-						
-							// calls supplying indices are implicitly making reference to the current DB
-						bool			CaptureDisplay( int rendIndex, int displayIndex, bool captureAll );		// capture one display or all displays
-						void			ReleaseDisplays( void );												// release all captures
-						
-						int				GetDisplayMode( int rendIndex, int displayIndex );						// retrieve current display res (returns modeIndex)
-						void			SetDisplayMode( GLMDisplayParams *params );								// set the display res (only useful for FS)
-					#endif
-	
-	GLMContext		*NewContext( GLMDisplayParams *params );		// this will have to change
-	void			DelContext( GLMContext *context );
-
-		// with usage of CGLMacro.h we could dispense with the "current context" thing
-		// and just declare a member variable of GLMContext, allowing each glXXX call to be routed directly
-		// to the correct context
-	void		SetCurrentContext( GLMContext *context );	// make current in calling thread only
-	GLMContext	*GetCurrentContext( void );
-		
-protected:
-	friend class GLMContext;
-
-	GLMgr();
-	~GLMgr();
-};
-
-
-//===========================================================================//
-
-// helper function to do enable or disable in one step
-inline void glSetEnable( GLenum which, bool enable )
-{
-	if (enable)
-		gGL->glEnable(which);
-	else
-		gGL->glDisable(which);
-}
-
-// helper function for int vs enum clarity
-inline void glGetEnumv( GLenum which, GLenum *dst )
-{
-	gGL->glGetIntegerv( which, (int*)dst );
-}
-
-//===========================================================================//
-//
-// types to support the GLMContext
-//
-//===========================================================================//
-
-// Each state set/get path we are providing caching for, needs its own struct and a comparison operator.
-// we also provide an enum of how many such types there are, handy for building dirty masks etc.
-
-// shorthand macros
-#define	EQ(fff) ( (src.fff) == (fff) )
-
-//rasterizer
-struct GLAlphaTestEnable_t		{ GLint		enable;													bool operator==(const GLAlphaTestEnable_t& src)		const { return EQ(enable);									} };
-struct GLAlphaTestFunc_t		{ GLenum	func; GLclampf ref;										bool operator==(const GLAlphaTestFunc_t& src)		const { return EQ(func) && EQ(ref);							} };
-struct GLCullFaceEnable_t		{ GLint		enable;													bool operator==(const GLCullFaceEnable_t& src)		const { return EQ(enable);									} };
-struct GLCullFrontFace_t		{ GLenum	value;													bool operator==(const GLCullFrontFace_t& src)		const { return EQ(value);									} };
-struct GLPolygonMode_t			{ GLenum	values[2];												bool operator==(const GLPolygonMode_t& src)			const { return EQ(values[0]) && EQ(values[1]);				} };
-struct GLDepthBias_t			{ GLfloat	factor;		GLfloat units;								bool operator==(const GLDepthBias_t& src)			const { return EQ(factor) && EQ(units);						} };
-struct GLScissorEnable_t		{ GLint		enable;													bool operator==(const GLScissorEnable_t& src)		const { return EQ(enable);									} };
-struct GLScissorBox_t			{ GLint		x,y;		GLsizei width, height;						bool operator==(const GLScissorBox_t& src)			const { return EQ(x) && EQ(y) && EQ(width) && EQ(height);	} };
-struct GLAlphaToCoverageEnable_t{ GLint		enable;													bool operator==(const GLAlphaToCoverageEnable_t& src) const { return EQ(enable);								} };
-struct GLViewportBox_t			{ GLint		x,y;		GLsizei width, height;						bool operator==(const GLViewportBox_t& src)			const { return EQ(x) && EQ(y) && EQ(width) && EQ(height);	} };
-struct GLViewportDepthRange_t	{ GLdouble	near,far;												bool operator==(const GLViewportDepthRange_t& src)	const { return EQ(near) && EQ(far);							} };
-struct GLClipPlaneEnable_t		{ GLint		enable;													bool operator==(const GLClipPlaneEnable_t& src)		const { return EQ(enable);									} };
-struct GLClipPlaneEquation_t	{ GLfloat	x,y,z,w;												bool operator==(const GLClipPlaneEquation_t& src)	const { return EQ(x) && EQ(y) && EQ(z) && EQ(w);			} };
-
-//blend
-struct GLColorMaskSingle_t		{ char		r,g,b,a;												bool operator==(const GLColorMaskSingle_t& src)		const { return EQ(r) && EQ(g) && EQ(b) && EQ(a);			} };
-struct GLColorMaskMultiple_t	{ char		r,g,b,a;												bool operator==(const GLColorMaskMultiple_t& src)	const { return EQ(r) && EQ(g) && EQ(b) && EQ(a);			} };
-struct GLBlendEnable_t			{ GLint		enable;													bool operator==(const GLBlendEnable_t& src)			const { return EQ(enable);									} };
-struct GLBlendFactor_t			{ GLenum	srcfactor,dstfactor;									bool operator==(const GLBlendFactor_t& src)			const { return EQ(srcfactor) && EQ(dstfactor);				} };
-struct GLBlendEquation_t		{ GLenum	equation;												bool operator==(const GLBlendEquation_t& src)		const { return EQ(equation);								} };
-struct GLBlendColor_t			{ GLfloat	r,g,b,a;												bool operator==(const GLBlendColor_t& src)			const { return EQ(r) && EQ(g) && EQ(b) && EQ(a);			} };
-struct GLBlendEnableSRGB_t		{ GLint		enable;													bool operator==(const GLBlendEnableSRGB_t& src)		const { return EQ(enable);									} };
-
-//depth
-struct GLDepthTestEnable_t		{ GLint		enable;													bool operator==(const GLDepthTestEnable_t& src)		const { return EQ(enable);									} };
-struct GLDepthFunc_t			{ GLenum	func;													bool operator==(const GLDepthFunc_t& src)			const { return EQ(func);									} };
-struct GLDepthMask_t			{ char		mask;													bool operator==(const GLDepthMask_t& src)			const { return EQ(mask);									} };
-
-//stencil
-struct GLStencilTestEnable_t	{ GLint		enable;													bool operator==(const GLStencilTestEnable_t& src)	const { return EQ(enable);									} };
-struct GLStencilFunc_t			{ GLenum	frontfunc, backfunc;	GLint ref;  GLuint mask;		bool operator==(const GLStencilFunc_t& src)			const { return EQ(frontfunc) && EQ(backfunc) && EQ(ref) && EQ(mask); } };
-struct GLStencilOp_t			{ GLenum	sfail;	GLenum dpfail; GLenum dppass;					bool operator==(const GLStencilOp_t& src)			const { return EQ(sfail) && EQ(dpfail) && EQ(dppass);		} };
-struct GLStencilWriteMask_t		{ GLint		mask;													bool operator==(const GLStencilWriteMask_t& src)	const { return EQ(mask);									} };
-
-//clearing
-struct GLClearColor_t			{  GLfloat	r,g,b,a;												bool operator==(const GLClearColor_t& src)			const { return EQ(r) && EQ(g) && EQ(b) && EQ(a);			} };
-struct GLClearDepth_t			{  GLdouble	d;														bool operator==(const GLClearDepth_t& src)			const { return EQ(d);										} };
-struct GLClearStencil_t			{  GLint	s;														bool operator==(const GLClearStencil_t& src)		const { return EQ(s);										} };
-
-#undef EQ
-
-enum EGLMStateBlockType
-{
-	kGLAlphaTestEnable,
-	kGLAlphaTestFunc,
-	
-	kGLCullFaceEnable,
-	kGLCullFrontFace,
-
-	kGLPolygonMode,
-
-	kGLDepthBias,
-	
-	kGLScissorEnable,
-	kGLScissorBox,
-
-	kGLViewportBox,
-	kGLViewportDepthRange,
-	
-	kGLClipPlaneEnable,
-	kGLClipPlaneEquation,
-	
-	kGLColorMaskSingle,
-	kGLColorMaskMultiple,
-
-	kGLBlendEnable,
-	kGLBlendFactor,	
-	kGLBlendEquation,
-	kGLBlendColor,
-	kGLBlendEnableSRGB,
-
-	kGLDepthTestEnable,
-	kGLDepthFunc,
-	kGLDepthMask,
-
-	kGLStencilTestEnable,
-	kGLStencilFunc,
-	kGLStencilOp,	
-	kGLStencilWriteMask,
-
-	kGLClearColor,
-	kGLClearDepth,
-	kGLClearStencil,
-
-	kGLAlphaToCoverageEnable,
-	
-	kGLMStateBlockLimit
-};
-
-//===========================================================================//
-
-// templated functions representing GL R/W bottlenecks
-// one set of set/get/getdefault is instantiated for each of the GL*** types above.
-
-// use these from the non array state objects
-template<typename T>	void GLContextSet( T *src );
-template<typename T>	void GLContextGet( T *dst );
-template<typename T>	void GLContextGetDefault( T *dst );
-
-// use these from the array state objects
-template<typename T>	void GLContextSetIndexed( T *src, int index );
-template<typename T>	void GLContextGetIndexed( T *dst, int index );
-template<typename T>	void GLContextGetDefaultIndexed( T *dst, int index );
-
-//===========================================================================//
-
-// caching state object template.  One of these is instantiated in the context per unique struct type above
-template<typename T> class GLState
-{
-	public:
-	
-		GLState<T>()
-		{
-			dirty = false;
-			memset( &data, 0, sizeof(data) );
-		};
-
-		// write: client src into cache
-		// common case is both false.  dirty is calculated, context write is deferred.
-		void	Write( T *src, bool noCompare=false, bool noDefer=false )
-		{
-			if (noCompare)
-			{
-				dirty = true;
-			}
-			else
-			{
-				// only == is implemented, so test for equal and negate
-				// note, you only set dirty if mismatch, you never clear it until flush
-				if ( !(data == *src) )
-				{
-					dirty = true;
-				}
-			}
-			
-			data = *src;
-			
-			if (noDefer)
-			{
-				Flush( true );	// dirty becomes false
-			}
-		};
-		
-		// write cache->context if dirty or forced.
-		void Flush( bool noDefer=false )
-		{
-			if (dirty || noDefer)
-			{
-				GLContextSet( &data );
-				GLMCheckError();
-					// good place for some error checking here
-				dirty = false;
-			}
-		};
-		
-		// default: write default value to cache, optionally write through
-		void Default( bool noDefer=false )
-		{
-			GLContextGetDefault( &data );	// read default values directly to our cache copy
-			dirty = true;
-			Flush(noDefer);
-		};
-
-		// read: sel = 0 for cache, 1 for context
-		void Read( T *dst, int sel )
-		{
-			if (sel==0)
-			{
-				*dst = data;
-			}
-			else
-			{
-				GLContextGet( dst );
-				GLMCheckError();
-			}
-		};
-		
-		// check: verify that context equals cache, return true if mismatched or if illegal values seen
-		bool Check ( void )
-		{
-			T		temp;
-			bool	result;
-
-			GLContextGet( &temp );
-			GLMCheckError();
-			result = !(temp == data);
-			return result;
-		};
-		
-	protected:
-		T		data;
-		bool	dirty;
-};
-
-// caching state object template - with multiple values behind it that are indexed
-template<typename T, int COUNT> class GLStateArray
-{
-	public:
-	
-		GLStateArray<T,COUNT>()
-		{
-			memset( &dirty, 0, sizeof(dirty) );
-			memset( &data, 0, sizeof(data) );
-		};
-
-		// write: client src into cache
-		// common case is both false.  dirty is calculated, context write is deferred.
-		void WriteIndex( T *src, int index, bool noCompare=false, bool noDefer=false )
-		{
-			if (noCompare)
-			{
-				dirty[index] = true;
-			}
-			else
-			{
-				// only == is implemented, so test for equal and negate
-				// note, you only set dirty if mismatch, you never clear it until flush
-				if (! (data[index] == *src) )
-				{
-					dirty[index] = true;
-				}
-			}
-			
-			data[index] = *src;
-			
-			if (noDefer)
-			{
-				FlushIndex( index, true );	// dirty becomes false
-			}
-		};
-		
-		// write cache->context if dirty or forced.
-		void FlushIndex( int index, bool noDefer=false )
-		{
-			if (dirty[index] || noDefer)
-			{
-				GLContextSetIndexed( &data[index], index );
-				GLMCheckError();
-				dirty[index] = false;
-			}
-		};
-		
-		// write all slots in the array
-		void Flush( bool noDefer=false )
-		{
-			for( int i=0; i<COUNT; i++)
-			{
-				FlushIndex( i, noDefer );
-			}
-		}
-		
-		// default: write default value to cache, optionally write through
-		void DefaultIndex( int index, bool noDefer=false )
-		{
-			GLContextGetDefaultIndexed( &data[index], index );	// read default values directly to our cache copy
-			dirty[index] = true;
-			Flush(noDefer);
-		};
-		
-		void Default( void )
-		{
-			for( int i=0; i<COUNT; i++)
-			{
-				DefaultIndex( i );
-			}			
-		}
-
-		// read: sel = 0 for cache, 1 for context
-		void ReadIndex( T *dst, int index, int sel )
-		{
-			if (sel==0)
-			{
-				*dst = data[index];
-			}
-			else
-			{
-				GLContextGetIndexed( dst, index );
-				GLMCheckError();
-			}
-		};
-		
-		// check: verify that context equals cache, return true if mismatched or if illegal values seen
-		bool CheckIndex( int index )
-		{
-			T		temp;
-			bool	result;
-
-			GLContextGetIndexed( &temp, index );
-			GLMCheckError();
-			result = !(temp == data[index]);
-			
-			return result;
-		};
-
-		bool Check( void )
-		{
-			T		temp;
-			bool	result = false;
-
-			for( int i=0; i<COUNT; i++)
-			{
-				result |= CheckIndex( i );
-			}
-			
-			return result;
-		};
-		
-	protected:
-		T		data	[COUNT];
-		bool	dirty	[COUNT];
-};
-
-
-//===========================================================================//
-
-struct	GLMTexSampler
-{
-	GLMTexSamplingParams	m_samp;
-	CGLMTex					*m_drawTex;		// tex which must be bound at time of draw
-	CGLMTex					*m_boundTex;	// tex which is actually bound now (if does not match, a rebind is needed to draw)
-};
-
-#ifdef NEVER
-//===========================================================================//
-
-enum	GLMVertexAttributeIndex
-{
-	kGLMGenericAttr00 = 0,
-	kGLMGenericAttr01,
-	kGLMGenericAttr02,
-	kGLMGenericAttr03,
-	kGLMGenericAttr04,
-	kGLMGenericAttr05,
-	kGLMGenericAttr06,
-	kGLMGenericAttr07,
-	kGLMGenericAttr08,
-	kGLMGenericAttr09,
-	kGLMGenericAttr10,
-	kGLMGenericAttr11,
-	kGLMGenericAttr12,
-	kGLMGenericAttr13,
-	kGLMGenericAttr14,
-	kGLMGenericAttr15,
-
-	kGLMVertexAttributeIndexMax			// ideally < 32
-};
-
-struct GLMVertexAttributeDesc			// all the info you need to do vertex setup for one attribute
-{
-	CGLMBuffer				*m_buffer;	// NULL allowed in which case m_offset is the full 32-bit pointer.. so you can draw from plain RAM if desired
-	GLuint					m_datasize;	// comp count of the attribute (1-4)
-	GLenum					m_datatype;	// data type of the attribute (GL_FLOAT, GL_UNSIGNED_BYTE, etc)
-	GLuint					m_stride;
-	GLuint					m_offset;	// net offset to attribute 'zero' within the buffer.
-	GLboolean				m_normalized;	// apply to any fixed point data that needs normalizing, esp color bytes
-	
-		// may need a seed value at some point to be able to disambiguate re-lifed buffers holding same pointer
-		// simpler alternative is to do shoot-down inside the vertex/index buffer free calls.
-		// I'd rather not have to have each attribute fiddling a ref count on the buffer to which it refers..
-
-#define	EQ(fff) ( (src.fff) == (fff) )
-	// test in decreasing order of likelihood of difference, but do not include the buffer revision as caller is not supplying it..
-	bool operator==(const GLMVertexAttributeDesc& src)		const { return EQ(m_buffer) && EQ(m_offset) && EQ(m_stride) && EQ(m_datatype) && EQ(m_normalized) && EQ(m_datasize);	}
-#undef EQ
-
-	uint					m_bufferRevision;	// only set in GLM context's copy, to disambiguate references that are same offset / same buffer but cross an orphan event
-};
-
-// GLMContext will maintain one of these structures inside the context to represent the current state.
-// Client can supply a new one when it wants to change the setup.
-//FIXME GLMContext can do the work to migrate from old setup to new setup as efficiently as possible (but it doesn't yet)
-#endif
-
-struct GLMVertexSetup
-{
-	uint	m_attrMask;					// which attrs are enabled (1<<n) mask where n is a GLMVertexAttributeIndex.
-	
-	GLMVertexAttributeDesc	m_attrs[ kGLMVertexAttributeIndexMax ];
-
-	// copied in from dxabstract, not strictly needed for operation, helps debugging
-	unsigned char	m_vtxAttribMap[16];
-
-		/* high nibble is usage per _D3DDECLUSAGE
-			typedef enum _D3DDECLUSAGE
-			{
-				D3DDECLUSAGE_POSITION		= 0,
-				D3DDECLUSAGE_BLENDWEIGHT	= 1,
-				D3DDECLUSAGE_BLENDINDICES	= 2,
-				D3DDECLUSAGE_NORMAL			= 3,
-				D3DDECLUSAGE_PSIZE			= 4,
-				D3DDECLUSAGE_TEXCOORD		= 5,
-				D3DDECLUSAGE_TANGENT		= 6,
-				D3DDECLUSAGE_BINORMAL		= 7,
-				D3DDECLUSAGE_TESSFACTOR		= 8,
-				D3DDECLUSAGE_PLUGH			= 9,	// mystery value
-				D3DDECLUSAGE_COLOR			= 10,
-				D3DDECLUSAGE_FOG			= 11,
-				D3DDECLUSAGE_DEPTH			= 12,
-				D3DDECLUSAGE_SAMPLE			= 13,
-			} D3DDECLUSAGE;
-		
-			low nibble is usageindex (i.e. POSITION0, POSITION1, etc)
-			array position is attrib number.
-		*/
-};
-
-//===========================================================================//
-
-//FIXME magic numbers here
-
-#define	kGLMProgramParamFloat4Limit	256
-#define	kGLMProgramParamBoolLimit	16
-#define	kGLMProgramParamInt4Limit	16
-
-#define	kGLMVertexProgramParamFloat4Limit	256
-#define	kGLMFragmentProgramParamFloat4Limit	32
-
-struct GLMProgramParamsF
-{
-	float	m_values[kGLMProgramParamFloat4Limit][4];		// float4's 256 of them
-	uint	m_dirtySlotCount;								// index of slot past highest dirty (assume 0 for base of range)
-};
-
-struct GLMProgramParamsB
-{
-	int		m_values[kGLMProgramParamBoolLimit];			// bools, 4 of them
-	uint	m_dirtySlotCount;
-};
-
-struct GLMProgramParamsI
-{
-	int		m_values[kGLMProgramParamInt4Limit][4];			// int4s, 16 of them
-	uint	m_dirtySlotCount;
-};
-
-enum EGLMParamWriteMode
-{
-	eParamWriteAllSlots,			// glUniform4fv of the maximum size	(not recommended if shader is down-sizing the decl)
-	eParamWriteShaderSlots,			// glUniform4fv of the active slot count ("highwater")
-	eParamWriteShaderSlotsOptional,	// glUniform4fv of the active slot count ("highwater") - but only if at least one has been written - it's optional
-	eParamWriteDirtySlotRange		// glUniform4fv of the 0-N range where N is highest dirty slot
-};
-
-enum EGLMAttribWriteMode
-{
-	eAttribWriteAll,
-	eAttribWriteDirty
-};
-
-//===========================================================================//
-
-#if GLMDEBUG
-enum EGLMDebugCallSite
-{
-	eBeginFrame,		// inside begin frame func - frame number has been inc'd, batch number should be -1
-	eClear,				// inside clear func
-	eDrawElements,		// inside repeat loop, prior to draw call - batch numberhas been inc'd
-	eEndFrame,			// end frame
-	ePresent			// before showing pixels
-};
-
-// caller should zero one of these out and fill in the m_caller before invoking the hook
-struct GLMDebugHookInfo
-{
-		// info from the caller to the debug hook
-	EGLMDebugCallSite	m_caller;
-
-	
-		// state the hook uses to keep track of progress within a single run of the caller		
-	int					m_iteration;	// which call to the hook is this.  if it's zero, it precedes any action in the caller.
-
-	
-		// bools used to communicate between caller and hook
-	bool				m_loop;			// hook tells caller to loop around again (don't exit)
-	bool				m_holding;		// current mood of hook, are we holding on this batch (i.e. rerun)
-	
-		// specific info for a draw call
-	GLenum				m_drawMode;
-	GLuint				m_drawStart;
-	GLuint				m_drawEnd;
-	GLsizei				m_drawCount;
-	GLenum				m_drawType;
-	const GLvoid		*m_drawIndices;
-};
-#endif
-
-//===========================================================================//
-
-#define	kGLMUserClipPlanes			2
-#define kGLMScratchFBOCount			4
-
-class	GLMContext
-{
-	public:
-		// set/check current context (perq for many other calls)
-		void	MakeCurrent( bool bRenderThread = false );
-		void	ReleaseCurrent( bool bRenderThread = false );
-
-		// CheckCurrent has been removed (it no longer compiled). To minimize churn I'm leaving
-		// the inline NOP version.
-		// DO NOT change this to non-inlined. It's called all over the place from very hot codepaths.
-		FORCEINLINE void CheckCurrent( void ) { }
-		
-		void							PopulateCaps( void );	// fill out later portions of renderer info record which need context queries
-		void							DumpCaps( void );		// printf all the caps info (you can call this in release too)
-		const GLMRendererInfoFields&	Caps( void );			// peek at the caps record
-	
-		// state cache/mirror
-		void	SetDefaultStates( void );
-		void	FlushStates( bool noDefer = false );
-		void	VerifyStates( void );
-
-		// textures
-		// Lock and Unlock reqs go directly to the tex object
-		CGLMTex	*NewTex( GLMTexLayoutKey *key, char *debugLabel=NULL );
-		void	DelTex( CGLMTex	*tex );	
-
-			// options for Blit (replacement for ResolveTex and BlitTex)
-			// pass NULL for dstTex if you want to target GL_BACK with the blit.  You get y-flip with that, don't change the dstrect yourself.		
-		void	Blit2( CGLMTex *srcTex, GLMRect *srcRect, int srcFace, int srcMip, CGLMTex *dstTex, GLMRect *dstRect, int dstFace, int dstMip, uint filter );
-
-			// tex blit (via FBO blit)
-		void	BlitTex( CGLMTex *srcTex, GLMRect *srcRect, int srcFace, int srcMip, CGLMTex *dstTex, GLMRect *dstRect, int dstFace, int dstMip, uint filter, bool useBlitFB = true );
-
-			//	MSAA resolve - we do this in GLMContext because it has to do a bunch of FBO/blit gymnastics
-		void	ResolveTex( CGLMTex *tex, bool forceDirty=false );	
-		
-			// texture pre-load (residency forcing) - normally done one-time but you can force it
-		void	PreloadTex( CGLMTex *tex, bool force=false );
-
-		// samplers
-		void	SetSamplerTex( int sampler, CGLMTex *tex );
-		void	SetSamplerParams( int sampler, GLMTexSamplingParams *params );
-
-		// render targets (FBO's)
-		CGLMFBO	*NewFBO( void );
-		void	DelFBO( CGLMFBO *fbo );		
-		void	SetDrawingFBO( CGLMFBO *fbo );	// as with samplers, the notion of the target FBO is latched til draw time and then checked
-
-		// programs
-		CGLMProgram	*NewProgram( EGLMProgramType type, char *progString );
-		void	DelProgram( CGLMProgram *prog );
-		void	NullProgram( void );											// de-ac all shader state
-		
-		void	SetDrawingProgram( EGLMProgramType type, CGLMProgram *prog );	// set NULL for no program
-		void	SetDrawingLang( EGLMProgramLang lang, bool immediate=false );	// choose ARB or GLSL.  immediate=false defers lang change to top of frame
-		
-		void	LinkShaderPair( CGLMProgram *vp, CGLMProgram *fp );			// ensure this combo has been linked and is in the GLSL pair cache
-		void	ClearShaderPairCache( void );								// call this to shoot down all the linked pairs
-		void	QueryShaderPair( int index, GLMShaderPairInfo *infoOut );	// this lets you query the shader pair cache for saving its state
-		
-		// buffers
-		// Lock and Unlock reqs go directly to the buffer object
-		CGLMBuffer	*NewBuffer( EGLMBufferType type, uint size, uint options );
-		void	DelBuffer( CGLMBuffer *buff );
-
-		void	SetIndexBuffer( CGLMBuffer *buff );		
-		void	SetVertexAttributes( GLMVertexSetup *setup );
-			// note, no API is exposed for setting a single attribute source.
-			// come prepared with a complete block of attributes to use.
-			
-		// Queries
-		CGLMQuery	*NewQuery( GLMQueryParams *params );
-		void		DelQuery( CGLMQuery *query );
-			
-		// "slot" means a vec4-sized thing
-		// these write into .env parameter space
-		void	SetProgramParametersF( EGLMProgramType type, uint baseSlot, float *slotData, uint slotCount );	// take vec4f's
-		void	SetProgramParametersB( EGLMProgramType type, uint baseSlot, int  *slotData, uint boolCount );	// take "BOOL" aka int
-		void	SetProgramParametersI( EGLMProgramType type, uint baseSlot, int  *slotData, uint slotCount );	// take int4s
-
-		// state sync
-		void	FlushDrawStates( bool shadersOn=true );				// pushes all drawing state - samplers, tex, programs, etc.
-		
-		// drawing
-		void	DrawRangeElements(	GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices );
-		void	CheckNative( void );
-		
-		// clearing
-		void	Clear( bool color, unsigned long colorValue, bool depth, float depthValue, bool stencil, unsigned int stencilValue, GLScissorBox_t *rect = NULL );
-		
-		// display
-		//void	SetVSyncEnable( bool vsyncOn );
-		//void	SetFullScreen( bool fsOn, int screenIndex );		// will be latched for next BeginFrame
-		//void	ActivateFullScreen( bool fsOn, int screenIndex );	// will be called by BeginFrame
-		bool	SetDisplayParams( GLMDisplayParams *params );		// either the first time setup, or a change to new setup
-		
-		void	Present( CGLMTex *tex );		// somewhat hardwired for the time being
-
-		// mode switch / reset
-		void	Reset( void );							// not a lot of args for now..
-		
-		// writers for the state block inputs
-		
-		void	WriteAlphaTestEnable		( GLAlphaTestEnable_t *src );
-		void	WriteAlphaTestFunc			( GLAlphaTestFunc_t *src );
-		void	WriteCullFaceEnable			( GLCullFaceEnable_t *src );
-		void	WriteCullFrontFace			( GLCullFrontFace_t *src );
-		void	WritePolygonMode			( GLPolygonMode_t *src );
-		void	WriteDepthBias				( GLDepthBias_t *src );
-		void	WriteClipPlaneEnable		( GLClipPlaneEnable_t *src, int which );
-		void	WriteClipPlaneEquation		( GLClipPlaneEquation_t *src, int which );
-		void	WriteScissorEnable			( GLScissorEnable_t *src );
-		void	WriteScissorBox				( GLScissorBox_t *src );
-		void	WriteAlphaToCoverageEnable	( GLAlphaToCoverageEnable_t *src );
-		void	WriteViewportBox			( GLViewportBox_t *src );
-		void	WriteViewportDepthRange		( GLViewportDepthRange_t *src );
-		void	WriteColorMaskSingle		( GLColorMaskSingle_t *src );
-		void	WriteColorMaskMultiple		( GLColorMaskMultiple_t *src, int which );
-		void	WriteBlendEnable			( GLBlendEnable_t *src );
-		void	WriteBlendFactor			( GLBlendFactor_t *src );
-		void	WriteBlendEquation			( GLBlendEquation_t *src );
-		void	WriteBlendColor				( GLBlendColor_t *src );
-		void	WriteBlendEnableSRGB		( GLBlendEnableSRGB_t *src );
-		void	WriteDepthTestEnable		( GLDepthTestEnable_t *src );
-		void	WriteDepthFunc				( GLDepthFunc_t *src );
-		void	WriteDepthMask				( GLDepthMask_t *src );
-		void	WriteStencilTestEnable		( GLStencilTestEnable_t *src );
-		void	WriteStencilFunc			( GLStencilFunc_t *src );
-		void	WriteStencilOp				( GLStencilOp_t *src, int which );
-		void	WriteStencilWriteMask		( GLStencilWriteMask_t *src );
-		void	WriteClearColor				( GLClearColor_t *src );
-		void	WriteClearDepth				( GLClearDepth_t *src );
-		void	WriteClearStencil			( GLClearStencil_t *src );
-
-
-		// debug stuff
-		void	BeginFrame( void );
-		void	EndFrame( void );
-		
-		// new interactive debug stuff
-#if GLMDEBUG
-		void	DebugDump( GLMDebugHookInfo *info, uint options, uint vertDumpMode );
-		void	DebugHook( GLMDebugHookInfo *info );
-		void	DebugPresent( void );
-		void	DebugClear( void );
-#endif
-
-		FORCEINLINE DWORD GetCurrentOwnerThreadId() const { return m_nCurOwnerThreadId; }
-		
-	protected:
-		friend class GLMgr;				// only GLMgr can make GLMContext objects
-		friend class GLMRendererInfo;	// only GLMgr can make GLMContext objects
-		friend class CGLMTex;			// tex needs to be able to do binds
-		friend class CGLMFBO;			// fbo needs to be able to do binds
-		friend class CGLMProgram;
-		friend class CGLMShaderPair;
-		friend class CGLMShaderPairCache;
-		friend class CGLMBuffer;
-		friend class GLMTester;			// tester class needs access back into GLMContext
-		
-		friend class IDirect3D9;
-		friend class IDirect3DDevice9;
-		
-		// methods------------------------------------------
-		
-				// old GLMContext( GLint displayMask, GLint rendererID, PseudoNSGLContextPtr nsglShareCtx );
-				GLMContext( GLMDisplayParams *params );
-				~GLMContext();
-		
-		// textures
-		void	SelectTMU( int tmu );																// wrapper for glActiveTexture()
-		int		BindTexToTMU( CGLMTex *tex, int tmu, bool noCheck=false );
-		
-		// render targets / FBO's
-		void	BindFBOToCtx( CGLMFBO *fbo, GLenum bindPoint = GL_FRAMEBUFFER_EXT );				// you can also choose GL_READ_FRAMEBUFFER_EXT / GL_DRAW_FRAMEBUFFER_EXT
-		
-		// programs
-		//void	BindProgramToCtx( EGLMProgramType type, CGLMProgram *prog );						// will set program mode enable appropriately
-
-		// buffers
-		void	BindBufferToCtx( EGLMBufferType type, CGLMBuffer *buff, bool force = false );		// does not twiddle any enables.
-
-		// debug font
-		void	GenDebugFontTex( void );
-		void	DrawDebugText( float x, float y, float z, float drawCharWidth, float drawCharHeight, char *string );
-		
-		// members------------------------------------------
-		
-		// context
-		DWORD							m_nCurOwnerThreadId;
-
-		GLMRendererInfoFields			m_caps;
-	
-		bool							m_displayParamsValid;		// is there a param block copied in yet
-		GLMDisplayParams				m_displayParams;			// last known display config, either via constructor, or by SetDisplayParams...
-		
-#if defined(USE_SDL)
-		int								m_pixelFormatAttribs[100];	// more than enough
-		void *							m_ctx;
-#endif
-
-		// texture form table
-		CGLMTexLayoutTable				*m_texLayoutTable;
-
-		// context state mirrors
-
-		GLState<GLAlphaTestEnable_t>	m_AlphaTestEnable;
-		
-		GLState<GLAlphaTestFunc_t>		m_AlphaTestFunc;
-		
-		GLState<GLCullFaceEnable_t>		m_CullFaceEnable;			
-		GLState<GLCullFrontFace_t>		m_CullFrontFace;	
-		GLState<GLPolygonMode_t>		m_PolygonMode;
-		
-		GLState<GLDepthBias_t>			m_DepthBias;		
-
-		GLStateArray<GLClipPlaneEnable_t,kGLMUserClipPlanes>	m_ClipPlaneEnable;
-		GLStateArray<GLClipPlaneEquation_t,kGLMUserClipPlanes>	m_ClipPlaneEquation;	// dxabstract puts them directly into param slot 253(0) and 254(1)
-		
-		GLState<GLScissorEnable_t>		m_ScissorEnable;	
-		GLState<GLScissorBox_t>			m_ScissorBox;
-
-		GLState<GLAlphaToCoverageEnable_t> m_AlphaToCoverageEnable;	
-		
-		GLState<GLViewportBox_t>		m_ViewportBox;		
-		GLState<GLViewportDepthRange_t>	m_ViewportDepthRange;
-		
-		GLState<GLColorMaskSingle_t>	m_ColorMaskSingle;	
-		GLStateArray<GLColorMaskMultiple_t,8>	m_ColorMaskMultiple;	// need an official constant for the color buffers limit
-		
-		GLState<GLBlendEnable_t>		m_BlendEnable;		
-		GLState<GLBlendFactor_t>		m_BlendFactor;		
-		GLState<GLBlendEquation_t>		m_BlendEquation;	
-		GLState<GLBlendColor_t>			m_BlendColor;		
-		GLState<GLBlendEnableSRGB_t>	m_BlendEnableSRGB;		// write to this one to transmit intent to write SRGB encoded pixels to drawing FB
-		bool							m_FakeBlendEnableSRGB;	// writes to above will be shunted here if fake SRGB is in effect.
-		
-		GLState<GLDepthTestEnable_t>	m_DepthTestEnable;	
-		GLState<GLDepthFunc_t>			m_DepthFunc;		
-		GLState<GLDepthMask_t>			m_DepthMask;		
-		
-		GLState<GLStencilTestEnable_t>	m_StencilTestEnable;	// global stencil test enable
-		GLState<GLStencilFunc_t>		m_StencilFunc;			// holds front and back stencil funcs
-		GLStateArray<GLStencilOp_t,2>	m_StencilOp;			// indexed: 0=front 1=back
-		GLState<GLStencilWriteMask_t>	m_StencilWriteMask;		
-		
-		GLState<GLClearColor_t>			m_ClearColor;		
-		GLState<GLClearDepth_t>			m_ClearDepth;		
-		GLState<GLClearStencil_t>		m_ClearStencil;		
-		
-		// texture bindings and sampler setup
-		int								m_activeTexture;		// mirror for glActiveTexture
-		GLMTexSampler					m_samplers[GLM_SAMPLER_COUNT];
-	
-		// texture lock tracking - CGLMTex objects share usage of this
-		CUtlVector< GLMTexLockDesc >	m_texLocks;
-		
-		// render target binding - check before draw
-		// similar to tex sampler mechanism, we track "bound" from "chosen for drawing" separately,
-		// so binding for creation/setup need not disrupt any notion of what will be used at draw time
-		
-		CGLMFBO							*m_boundDrawFBO;		// FBO on GL_DRAW_FRAMEBUFFER bind point
-		CGLMFBO							*m_boundReadFBO;		// FBO on GL_READ_FRAMEBUFFER bind point
-																// ^ both are set if you bind to GL_FRAMEBUFFER_EXT
-		
-		CGLMFBO							*m_drawingFBO;			// what FBO should be bound at draw time (to both read/draw bp's).
-
-		CGLMFBO							*m_blitReadFBO;
-		CGLMFBO							*m_blitDrawFBO;			// scratch FBO's for framebuffer blit
-		
-		CGLMFBO							*m_scratchFBO[ kGLMScratchFBOCount ];	// general purpose FBO's for internal use
-		
-		CUtlVector< CGLMFBO* >			m_fboTable;				// each live FBO goes in the table
-		
-		// program bindings
-		EGLMProgramLang					m_drawingLangAtFrameStart;	// selector for start of frame (spills into m_drawingLang)
-		EGLMProgramLang					m_drawingLang;				// selector for which language we desire to draw with on the next batch
-		CGLMProgram						*m_drawingProgram[ kGLMNumProgramTypes ];
-		
-		GLMProgramParamsF				m_programParamsF[ kGLMNumProgramTypes ];
-		GLMProgramParamsB				m_programParamsB[ kGLMNumProgramTypes ];	// two banks, but only the vertex one is used
-		GLMProgramParamsI				m_programParamsI[ kGLMNumProgramTypes ];	// two banks, but only the vertex one is used
-		EGLMParamWriteMode				m_paramWriteMode;
-		
-		CGLMProgram						*m_nullFragmentProgram;		// write opaque black.  Activate when caller asks for null FP
-
-		CGLMProgram						*m_preloadTexVertexProgram;			// programs to help preload textures (dummies)
-		CGLMProgram						*m_preload2DTexFragmentProgram;
-		CGLMProgram						*m_preload3DTexFragmentProgram;
-		CGLMProgram						*m_preloadCubeTexFragmentProgram;
-
-		CGLMProgram						*m_boundProgram[ kGLMNumProgramTypes ];
-
-		CGLMShaderPairCache				*m_pairCache;				// GLSL only
-		CGLMShaderPair					*m_boundPair;				// GLSL only
-		uint							m_boundPairRevision;		// GLSL only
-		GLhandleARB						m_boundPairProgram;			// GLSL only
-
-		// buffer bindings
-		CGLMBuffer						*m_lastKnownBufferBinds[ kGLMNumBufferTypes ];				// tracked per bind point for dupe-bind-absorb
-		GLMVertexAttributeDesc			m_lastKnownVertexAttribs[ kGLMVertexAttributeIndexMax ];	// tracked per attrib for dupe-set-absorb
-		uint							m_lastKnownVertexAttribMask;								// tracked for dupe-enable-absorb
-		
-		CGLMBuffer						*m_drawIndexBuffer;	// ... ? do we need dupe tracking for index buffer setup? ?
-		
-		GLMVertexSetup					m_drawVertexSetup;
-
-		EGLMAttribWriteMode				m_attribWriteMode;
-		
-		bool							m_slowCheckEnable;		// turn this on or no native checking is done ("-glmassertslow" or "-glmsspewslow")
-		bool							m_slowAssertEnable;		// turn this on to assert on a non-native batch	"-glmassertslow"
-		bool							m_slowSpewEnable;	// turn this on to log non-native batches to stdout "-glmspewslow"
-		
-		// debug font texture
-		CGLMTex							*m_debugFontTex;		// might be NULL unless you call GenDebugFontTex
-		CGLMBuffer						*m_debugFontIndices;	// up to 1024 indices (256 chars times 4)
-		CGLMBuffer						*m_debugFontVertices;	// up to 1024 verts
-
-		// batch/frame debugging support
-		int								m_debugFrameIndex;			// init to -1. Increment at BeginFrame
-		int								m_debugBatchIndex;			// init to -1. Increment at any draw call
-
-#if GLMDEBUG
-		// interactive (DebugHook) debug support
-
-			// using these you can implement frame advance, batch single step, and batch rewind (let it run til next frame and hold on prev batch #)
-		int								m_holdFrameBegin;		// -1 if no hold req'd, otherwise # of frame to hold at (at beginframe time)
-		int								m_holdFrameEnd;			// -1 if no hold req'd, otherwise # of frame to hold at (at endframe time)
-
-		int								m_holdBatch,m_holdBatchFrame;	// -1 if no hold, else # of batch&frame to hold at (both must be set)
-																// these can be expired/cleared to -1 if the frame passes without a hit
-																// may be desirable to re-pause in that event, as user was expecting a hold to occur
-
-		bool							m_debugDelayEnable;		// allow sleep delay
-		uint							m_debugDelay;			// sleep time per hook call in microseconds (for usleep())
-		
-			// pre-draw global toggles / options
-		bool							m_autoClearColor,m_autoClearDepth,m_autoClearStencil;
-		float							m_autoClearColorValues[4];
-		
-			// debug knobs
-		int								m_selKnobIndex;
-		float							m_selKnobMinValue,m_selKnobMaxValue,m_selKnobIncrement;
-#endif
-
-};
-
-struct GLMTestParams
-{
-	GLMContext	*m_ctx;
-	int			*m_testList;			// -1 termed
-	
-	bool		m_glErrToDebugger;
-	bool		m_glErrToConsole;
-	
-	bool		m_intlErrToDebugger;
-	bool		m_intlErrToConsole;
-	
-	int			m_frameCount;			// how many frames to test.
-};
-
-class GLMTester
-{
-	public:
-	
-	GLMTester(GLMTestParams *params);
-	~GLMTester();
-	
-
-	// optionally callable by test routines to get basic drawables wired up
-	void	StdSetup( void );
-	void	StdCleanup( void );
-	
-	// callable by test routines to clear the frame or present it
-	void	Clear( void );
-	void	Present( int seed );
-
-	// error reporting
-	void	CheckGLError( char *comment );					// obey m_params setting for console / debugger response
-	void	InternalError( int errcode, char *comment );	// if errcode!=0, obey m_params setting for console / debugger response
-	
-	void	RunTests();
-
-	void	RunOneTest( int testindex );
-
-	// test routines themselves
-	void	Test0();
-	void	Test1();
-	void	Test2();
-	void	Test3();
-
-	GLMTestParams	m_params;		// copy of caller's params, do not mutate...
-	
-	// std-setup stuff
-	int				m_drawWidth, m_drawHeight;
-	CGLMFBO			*m_drawFBO;
-	CGLMTex			*m_drawColorTex;
-	CGLMTex			*m_drawDepthTex;
-};
-
-class CShowPixelsParams
-{
-public:
-	GLuint					m_srcTexName;
-	int						m_width,m_height;
-	bool					m_vsyncEnable;
-	bool					m_fsEnable;		// want receiving view to be full screen.  for now, just target the main screen.  extend later.
-	bool					m_useBlit;		// use FBO blit - sending context says it is available.
-	bool					m_noBlit;		// the back buffer has already been populated by the caller (perhaps via direct MSAA resolve from multisampled RT tex)
-	bool					m_onlySyncView;	// react to full/windowed state change only, do not present bits
-};
-
-
-#define	kMaxCrawlFrames	100
-#define	kMaxCrawlText		(kMaxCrawlFrames * 256)
-class CStackCrawlParams
-{
-	public:
-	uint					m_frameLimit;							// input: max frames to retrieve
-	uint					m_frameCount;							// output: frames found
-	void					*m_crawl[kMaxCrawlFrames];				// call site addresses
-	char					*m_crawlNames[kMaxCrawlFrames];			// pointers into text following, one per decoded name
-	char					m_crawlText[kMaxCrawlText];
-};
-
-#endif
diff --git a/mp/src/public/togl/osx/glmgrbasics.h b/mp/src/public/togl/osx/glmgrbasics.h
deleted file mode 100644
index d6476b3d..00000000
--- a/mp/src/public/togl/osx/glmgrbasics.h
+++ /dev/null
@@ -1,299 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-//
-// glmgrbasics.h
-//	types, common headers, forward declarations, utilities
-//
-//===============================================================================
-
-#ifndef GLMBASICS_H
-#define	GLMBASICS_H
-
-#pragma once
-
-#ifdef OSX
-#include <OpenGL/OpenGL.h>
-#include <OpenGL/gl.h>
-#include <OpenGL/glext.h>
-#include <OpenGL/CGLTypes.h>
-#include <OpenGL/CGLRenderers.h>
-#include <OpenGL/CGLCurrent.h>
-//#include <OpenGL/CGLProfiler.h>
-//#include <ApplicationServices/ApplicationServices.h>
-#elif defined(LINUX)
-#include <GL/gl.h>
-#include <GL/glext.h>
-#else
-#error
-#endif
-
-#include "tier0/platform.h"
-
-#include "bitmap/imageformat.h"
-#include "bitvec.h"
-#include "tier1/checksum_md5.h"
-#include "tier1/utlvector.h"
-#include "tier1/convar.h"
-
-#include <sys/stat.h>
-
-#include "dxabstract_types.h"
-
-// types
-struct GLMRect;
-typedef void *PseudoGLContextPtr;
-
-
-	// 3-d integer box (used for texture lock/unlock etc)
-struct	GLMRegion
-{
-	int	xmin,xmax;
-	int	ymin,ymax;
-	int zmin,zmax;
-};
-
-struct GLMRect	// follows GL convention - if coming from the D3D rect you will need to fiddle the Y's
-{
-    int xmin;	// left
-    int ymin;	// bottom
-    int xmax;	// right
-    int ymax;	// top
-};
-
-// macros
-
-//#define	GLMassert(x)	assert(x)
-
-// forward decls
-class	GLMgr;				// singleton
-class	GLMContext;			// GL context
-class	CGLMContextTester;	// testing class
-class	CGLMTex;
-class	CGLMFBO;
-class	CGLMProgram;
-class	CGLMBuffer;
-
-
-// utilities
-
-typedef enum
-{
-	// D3D codes
-	eD3D_DEVTYPE,
-	eD3D_FORMAT,
-	eD3D_RTYPE,
-	eD3D_USAGE,
-	eD3D_RSTATE,	// render state
-	eD3D_SIO,		// D3D shader bytecode
-	eD3D_VTXDECLUSAGE,
-	
-	// CGL codes
-	eCGL_RENDID,
-	
-	// OpenGL error codes
-	eGL_ERROR,
-	
-	// OpenGL enums
-	eGL_ENUM,
-	eGL_RENDERER
-
-}	GLMThing_t;
-
-const char* GLMDecode( GLMThing_t type, unsigned long value );		// decode a numeric const
-const char* GLMDecodeMask( GLMThing_t type, unsigned long value );	// decode a bitmask
-
-void GLMStop( void );	// aka Debugger()
-void GLMCheckError( bool noStop = false, bool noLog= false );
-void GLMEnableTrace( bool on );
-
-// expose these in release now
-// Mimic PIX events so we can decorate debug spew
-void	GLMBeginPIXEvent( const char *str );
-void	GLMEndPIXEvent( void );
-
-//===============================================================================
-// knob twiddling
-//float	GLMKnob( char *knobname, float *setvalue );	// Pass NULL to not-set the knob value
-//float	GLMKnobToggle( char *knobname );
-
-//===============================================================================
-// other stuff
-
-// helpers for CGLSetOption - no op if no profiler
-void	GLMProfilerClearTrace( void );
-void	GLMProfilerEnableTrace( bool enable );
-
-// helpers for CGLSetParameter - no op if no profiler
-void	GLMProfilerDumpState( void );
-
-
-//===============================================================================
-// classes
-
-// helper class making function tracking easier to wire up
-#if GLMDEBUG
-class GLMFuncLogger
-{
-	public:
-	
-		// simple function log
-		GLMFuncLogger( const char *funcName )
-		{
-			m_funcName = funcName;
-			m_earlyOut = false;
-			
-			GLMPrintf( ">%s", m_funcName );
-		};
-		
-		// more advanced version lets you pass args (i.e. called parameters or anything else of interest)
-		// no macro for this one, since no easy way to pass through the args as well as the funcname
-		GLMFuncLogger( const char *funcName, char *fmt, ... )
-		{
-			m_funcName = funcName;
-			m_earlyOut = false;
-
-			// this acts like GLMPrintf here
-			// all the indent policy is down in GLMPrintfVA
-			// which means we need to inject a ">" at the front of the format string to make this work... sigh.
-			
-			char modifiedFmt[2000];
-			modifiedFmt[0] = '>';
-			strcpy( modifiedFmt+1, fmt );
-			
-			va_list	vargs;
-			va_start(vargs, fmt);
-			GLMPrintfVA( modifiedFmt, vargs );
-			va_end( vargs );
-		}
-		
-		~GLMFuncLogger( )
-		{
-			if (m_earlyOut)
-			{
-				GLMPrintf( "<%s (early out)", m_funcName );
-			}
-			else
-			{
-				GLMPrintf( "<%s", m_funcName );
-			}
-		};
-	
-		void EarlyOut( void )
-		{
-			m_earlyOut = true;
-		};
-		
-		const char *m_funcName;				// set at construction time
-		bool m_earlyOut;
-};
-
-// handy macro to go with the function tracking class
-#define	GLM_FUNC			GLMFuncLogger _logger_ ( __FUNCTION__ )
-#else
-#define	GLM_FUNC
-#endif
-
-
-// class to keep an in-memory mirror of a file which may be getting edited during run
-class CGLMFileMirror
-{
-public:
-	CGLMFileMirror( char *fullpath );		// just associates mirror with file. if file exists it will be read.
-											//if non existent it will be created with size zero
-	~CGLMFileMirror( );
-	
-	bool		HasData( void );								// see if data avail
-	void		GetData( char **dataPtr, uint *dataSizePtr );	// read it out
-	void		SetData( char *data, uint dataSize );			// put data in (and write it to disk)
-	bool		PollForChanges( void );							// check disk copy.  If different, read it back in and return true.
-	
-	void		UpdateStatInfo( void );		// make sure stat info is current for our file
-	void		ReadFile( void );
-	void		WriteFile( void );
-
-	void		OpenInEditor( bool foreground=false );			// pass TRUE if you would like the editor to pop to foreground
-	
-	/// how about a "wait for change" method..
-
-	char		*m_path;	// fullpath to file
-	bool		m_exists;
-	struct stat	m_stat;		// stat results for the file (last time checked)
-	
-	char		*m_data;	// content of file
-	uint		m_size;		// length of content
-
-};
-
-// class based on the file mirror, that makes it easy to edit them outside the app.
-
-// it receives an initial block of text from the engine, and hashes it. ("orig")
-// it munges it by duplicating all the text after the "!!" line, and appending it in commented form. ("munged")
-// a mirror file is activated, using a filename based on the hash from the orig text.
-// if there is already content on disk matching that filename, use that content *unless* the 'blitz' parameter is set.
-//		(i.e. engine is instructing this subsystem to wipe out any old/modified variants of the text)
-
-
-class CGLMEditableTextItem
-{
-public:
-					CGLMEditableTextItem( char *text, uint size, bool forceOverwrite, char *prefix, char *suffix = NULL );		// create a text blob from text source, optional filename suffix
-					~CGLMEditableTextItem( );
-
-	bool			HasData( void );
-	bool			PollForChanges( void );									// return true if stale i.e. you need to get a new edition
-	void			GetCurrentText( char **textOut, uint *sizeOut );		// query for read access to the active blob (could be the original, could be external edited copy)
-	void			OpenInEditor( bool foreground=false );									// call user attention to this text
-
-	// internal methods
-	void			GenHashOfOrigText( void );
-	void			GenBaseNameAndFullPath( char *prefix, char *suffix );
-	void			GenMungedText( bool fromMirror );
-
-	// members
-	// orig
-	uint			m_origSize;
-	char			*m_origText;						// what was submitted
-	unsigned char	m_origDigest[MD5_DIGEST_LENGTH];	// digest of what was submitted
-	
-	// munged
-	uint			m_mungedSize;
-	char			*m_mungedText;						// re-processed edition, initial content submission to the file mirror
-
-	// mirror
-	char			*m_mirrorBaseName;					// generated from the hash of the orig text, plus the label / prefix
-	char			*m_mirrorFullPath;					// base name 
-	CGLMFileMirror	*m_mirror;							// file mirror itself.  holds "official" copy for GetCurrentText to return.
-};
-
-
-// debug font
-extern unsigned char g_glmDebugFontMap[16384];
-
-// class for cracking multi-part text blobs
-// sections are demarcated by beginning-of-line markers submitted in a table by the caller
-
-struct GLMTextSection
-{
-	int		m_markerIndex;		// based on table of markers passed in to constructor
-	uint	m_textOffset;		// where is the text - offset
-	int		m_textLength;		// how big is the section
-};
-
-class CGLMTextSectioner
-{
-public:
-					CGLMTextSectioner( char *text, int textSize, char **markers );		// constructor finds all the sections
-					~CGLMTextSectioner( );
-					
-	int				Count( void );			// how many sections found
-	void			GetSection( int index, uint *offsetOut, uint *lengthOut, int *markerIndexOut );
-		// find section, size, what marker
-		// note that more than one section can be marked similarly.
-		// so policy isn't made here, you walk the sections and decide what to do if there are dupes.
-	
-	//members
-	
-	//section table
-	CUtlVector< GLMTextSection >	m_sectionTable;
-};
-
-#endif
diff --git a/mp/src/public/togl/osx/glmgrext.h b/mp/src/public/togl/osx/glmgrext.h
deleted file mode 100644
index 02939bb6..00000000
--- a/mp/src/public/togl/osx/glmgrext.h
+++ /dev/null
@@ -1,93 +0,0 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//
-//
-// glmgrext.h
-// helper file for extension testing and runtime importing of entry points
-//
-//===============================================================================
-
-#pragma once
-
-#ifdef OSX
-#include <OpenGL/gl.h>
-#include <OpenGL/glext.h>
-#elif defined(LINUX)
-#include <GL/gl.h>
-#include <GL/glext.h>
-#else
-#error
-#endif
-
-#ifndef GL_EXT_framebuffer_sRGB
-	#define GL_FRAMEBUFFER_SRGB_EXT                 0x8DB9
-	#define GL_FRAMEBUFFER_SRGB_CAPABLE_EXT         0x8DBA
-#endif
-
-#ifndef ARB_texture_rg
-	#define GL_COMPRESSED_RED                 0x8225
-	#define GL_COMPRESSED_RG                  0x8226
-	#define GL_RG                             0x8227
-	#define GL_RG_INTEGER                     0x8228
-	#define GL_R8                             0x8229
-	#define GL_R16                            0x822A
-	#define GL_RG8                            0x822B
-	#define GL_RG16                           0x822C
-	#define GL_R16F                           0x822D
-	#define GL_R32F                           0x822E
-	#define GL_RG16F                          0x822F
-	#define GL_RG32F                          0x8230
-	#define GL_R8I                            0x8231
-	#define GL_R8UI                           0x8232
-	#define GL_R16I                           0x8233
-	#define GL_R16UI                          0x8234
-	#define GL_R32I                           0x8235
-	#define GL_R32UI                          0x8236
-	#define GL_RG8I                           0x8237
-	#define GL_RG8UI                          0x8238
-	#define GL_RG16I                          0x8239
-	#define GL_RG16UI                         0x823A
-	#define GL_RG32I                          0x823B
-	#define GL_RG32UI                         0x823C
-#endif
-
-#ifndef GL_EXT_bindable_uniform
-	#define GL_UNIFORM_BUFFER_EXT             0x8DEE
-#endif
-
-// unpublished extension enums (thus the "X")
-
-// from EXT_framebuffer_multisample_blit_scaled..
-#define XGL_SCALED_RESOLVE_FASTEST_EXT 0x90BA
-#define XGL_SCALED_RESOLVE_NICEST_EXT 0x90BB
-
-#ifndef GL_TEXTURE_MINIMIZE_STORAGE_APPLE
-#define GL_TEXTURE_MINIMIZE_STORAGE_APPLE  0x85B6
-#endif
-
-#ifndef GL_ALL_COMPLETED_NV
-#define GL_ALL_COMPLETED_NV               0x84F2
-#endif
-
-#ifndef GL_MAP_READ_BIT
-#define GL_MAP_READ_BIT                   0x0001
-#endif
-
-#ifndef GL_MAP_WRITE_BIT
-#define GL_MAP_WRITE_BIT                  0x0002
-#endif
-
-#ifndef GL_MAP_INVALIDATE_RANGE_BIT
-#define GL_MAP_INVALIDATE_RANGE_BIT       0x0004
-#endif
-
-#ifndef GL_MAP_INVALIDATE_BUFFER_BIT
-#define GL_MAP_INVALIDATE_BUFFER_BIT      0x0008
-#endif
-
-#ifndef GL_MAP_FLUSH_EXPLICIT_BIT
-#define GL_MAP_FLUSH_EXPLICIT_BIT         0x0010
-#endif
-
-#ifndef GL_MAP_UNSYNCHRONIZED_BIT
-#define GL_MAP_UNSYNCHRONIZED_BIT         0x0020
-#endif
-
diff --git a/mp/src/public/togl/rendermechanism.h b/mp/src/public/togl/rendermechanism.h
index 928021a5..47be332d 100644
--- a/mp/src/public/togl/rendermechanism.h
+++ b/mp/src/public/togl/rendermechanism.h
@@ -1,4 +1,27 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
 #ifndef RENDERMECHANISM_H
 #define RENDERMECHANISM_H
 
@@ -8,11 +31,10 @@
 
 #include <GL/gl.h>
 #include <GL/glext.h>
+
 #include "tier0/basetypes.h"
 #include "tier0/platform.h"
 
-#if defined(LINUX) || defined(_WIN32)
-
 #include "togl/linuxwin/glmdebug.h"
 #include "togl/linuxwin/glbase.h"
 #include "togl/linuxwin/glentrypoints.h"
@@ -29,25 +51,6 @@
 #include "togl/linuxwin/dxabstract_types.h"
 #include "togl/linuxwin/dxabstract.h"
 
-#elif defined(OSX)
-#include "togl/osx/glmdebug.h"
-//#include "togl/osx/glbase.h"
-#include "togl/osx/glentrypoints.h"
-#include "togl/osx/glmdisplay.h"
-#include "togl/osx/glmdisplaydb.h"
-#include "togl/osx/glmgrbasics.h"
-#include "togl/osx/glmgrext.h"
-#include "togl/osx/cglmbuffer.h"
-#include "togl/osx/cglmtex.h"
-#include "togl/osx/cglmfbo.h"
-#include "togl/osx/cglmprogram.h"
-#include "togl/osx/cglmquery.h"
-#include "togl/osx/glmgr.h"
-#include "togl/osx/dxabstract_types.h"
-#include "togl/osx/dxabstract.h"
-
-#endif
-
 #else
 	//USE_ACTUAL_DX
 	#ifdef WIN32
diff --git a/mp/src/public/vgui/VGUI.h b/mp/src/public/vgui/VGUI.h
index cd2e9650..34fddfeb 100644
--- a/mp/src/public/vgui/VGUI.h
+++ b/mp/src/public/vgui/VGUI.h
@@ -66,12 +66,10 @@ const HFont INVALID_FONT = 0; // the value of an invalid font handle
 
 #include "tier1/strtools.h"
 
-#if defined( OSX ) // || defined( LINUX )
-// Set to 1 to use GetKernedCharWidth() instead of GetCharABCwide(). Alfred
-//  initially started using that code on the Mac because it did better
-//  kerning, but he was a leery about switching win32 over. I enabled this
-//  for Linux, but it causes some strings to look different than Windows. So
-//  I've disabled it for now. mikesart - 12/2012.
+#if 0 // defined( OSX ) // || defined( LINUX )
+// Disabled all platforms. Did a major cleanup of osxfont.cpp, and having this
+//  turned off renders much closer to Windows and Linux and also uses the same
+//  code paths (which is good).
 #define USE_GETKERNEDCHARWIDTH 1
 #else
 #define USE_GETKERNEDCHARWIDTH 0
diff --git a/mp/src/public/vgui_controls/AnimationController.h b/mp/src/public/vgui_controls/AnimationController.h
index e418f329..93ae7096 100644
--- a/mp/src/public/vgui_controls/AnimationController.h
+++ b/mp/src/public/vgui_controls/AnimationController.h
@@ -52,6 +52,9 @@ public:
 	bool StartAnimationSequence(const char *sequenceName);
 	bool StartAnimationSequence(Panel *pWithinParent, const char *sequenceName);
 
+	bool StopAnimationSequence( Panel *pWithinParent, const char *sequenceName );
+	void CancelAnimationsForPanel( Panel *pWithinParent );
+
 	// gets the length of an animation sequence, in seconds
 	float GetAnimationSequenceLength(const char *sequenceName);
 
@@ -96,6 +99,9 @@ private:
 		CMD_SETFONT,
 		CMD_SETTEXTURE,
 		CMD_SETSTRING,
+		CMD_RUNEVENTCHILD,
+		CMD_FIRECOMMAND,
+		CMD_SETVISIBLE,
 	};
 
 	enum RelativeAlignment
@@ -223,6 +229,7 @@ private:
 	// variable names
 	UtlSymId_t m_sPosition, m_sSize, m_sFgColor, m_sBgColor;
 	UtlSymId_t m_sXPos, m_sYPos, m_sWide, m_sTall;
+	UtlSymId_t m_sModelPos;
 
 	// file name
 	CUtlVector<UtlSymId_t>	m_ScriptFileNames;
diff --git a/mp/src/public/vgui_controls/ComboBox.h b/mp/src/public/vgui_controls/ComboBox.h
index c5c3eba0..266f4dc2 100644
--- a/mp/src/public/vgui_controls/ComboBox.h
+++ b/mp/src/public/vgui_controls/ComboBox.h
@@ -63,7 +63,7 @@ public:
 	virtual int AddItem(const char *itemText, const KeyValues *userData);
 	virtual int AddItem(const wchar_t *itemText, const KeyValues *userData);
 
-	virtual int GetItemCount();
+	virtual int GetItemCount() const;
 	int GetItemIDFromRow( int row );
 
 	// update the item
diff --git a/mp/src/public/vgui_controls/HTML.h b/mp/src/public/vgui_controls/HTML.h
index 59e76770..ad786d20 100644
--- a/mp/src/public/vgui_controls/HTML.h
+++ b/mp/src/public/vgui_controls/HTML.h
@@ -24,7 +24,6 @@
 #endif
 #include "steam/steam_api.h"
 
-class HTMLComboBoxHost;
 namespace vgui
 {
 
@@ -80,7 +79,7 @@ public:
 
 	// overridden to paint our special web browser texture
 	virtual void Paint();
-	
+
 	// pass messages to the texture component to tell it about resizes
 	virtual void OnSizeChanged(int wide,int tall);
 
@@ -124,7 +123,7 @@ public:
 	void AddHeader( const char *pchHeader, const char *pchValue );
 	void OnKillFocus();
 	void OnSetFocus();
-	
+
 	void Find( const char *pchSubStr );
 	void StopFind();
 	void FindNext();
@@ -147,7 +146,6 @@ public:
 	}
 #endif // DBGFLAG_VALIDATE
 
-	void PaintComboBox();
 	ISteamHTMLSurface *SteamHTMLSurface() { return m_SteamAPIContext.SteamHTMLSurface(); }
 
 	void OnHTMLMouseMoved( int x, int y )
@@ -159,20 +157,13 @@ public:
 protected:
 	virtual void ApplySchemeSettings( IScheme *pScheme );
 
-	friend class HTMLComboBoxHost;
 	vgui::Menu *m_pContextMenu;
 
-
 private:
 	STEAM_CALLBACK( HTML, BrowserNeedsPaint, HTML_NeedsPaint_t, m_NeedsPaint );
-	STEAM_CALLBACK( HTML, BrowserComboNeedsPaint, HTML_ComboNeedsPaint_t, m_ComboNeedsPaint );
 	STEAM_CALLBACK( HTML, BrowserStartRequest, HTML_StartRequest_t, m_StartRequest );
 	STEAM_CALLBACK( HTML, BrowserURLChanged, HTML_URLChanged_t, m_URLChanged );
 	STEAM_CALLBACK( HTML, BrowserFinishedRequest, HTML_FinishedRequest_t, m_FinishedRequest );
-	STEAM_CALLBACK( HTML, BrowserShowPopup, HTML_ShowPopup_t, m_ShowPopup );
-	STEAM_CALLBACK( HTML, BrowserHidePopup, HTML_HidePopup_t, m_HidePopup );
-	STEAM_CALLBACK( HTML, BrowserSizePopup, HTML_SizePopup_t, m_SizePopup );
-
 	STEAM_CALLBACK( HTML, BrowserOpenNewTab, HTML_OpenLinkInNewTab_t, m_LinkInNewTab );
 	STEAM_CALLBACK( HTML, BrowserSetHTMLTitle, HTML_ChangedTitle_t, m_ChangeTitle );
 	STEAM_CALLBACK( HTML, BrowserPopupHTMLWindow, HTML_NewWindow_t, m_NewWindow );
@@ -227,7 +218,6 @@ private:
 	};
 
 	CHTMLFindBar *m_pFindBar;
-	HTMLComboBoxHost *m_pComboBoxHost;
 
 	int m_iMouseX,m_iMouseY; // where the mouse is on the control
 
@@ -255,10 +245,7 @@ private:
 	// when the size has changed and reallocate the texture.
 	int m_allocedTextureWidth;
 	int m_allocedTextureHeight;
-	int m_iComboBoxTextureID; // vgui texture id of the combo box
-	bool m_bNeedsFullTextureUpload; 
-	int m_allocedComboBoxWidth;
-	int m_allocedComboBoxHeight;
+	bool m_bNeedsFullTextureUpload;
 	CUtlString m_sCurrentURL; // the url of our current page
 	// find in page state
 	bool m_bInFind;
diff --git a/mp/src/public/vgui_controls/Menu.h b/mp/src/public/vgui_controls/Menu.h
index 2b374373..77937335 100644
--- a/mp/src/public/vgui_controls/Menu.h
+++ b/mp/src/public/vgui_controls/Menu.h
@@ -216,7 +216,7 @@ public:
 	virtual int GetActiveItem();		// returns the itemID (not the row) of the active item
 
 	// Return the number of items currently in the menu list
-	virtual int GetItemCount();
+	virtual int GetItemCount() const;
 
 	// return the menuID of the n'th item in the menu list, valid from [0, GetItemCount)
 	virtual int GetMenuID(int index);
@@ -351,6 +351,29 @@ private:
 	double			m_fLastTypeAheadTime;
 };
 
+
+//-----------------------------------------------------------------------------
+// Helper class to create menu
+//-----------------------------------------------------------------------------
+class MenuBuilder
+{
+public:
+
+	MenuBuilder( Menu *pMenu, Panel *pActionTarget );
+
+	MenuItem* AddMenuItem( const char *pszButtonText, const char *pszCommand, const char *pszCategoryName );
+
+	MenuItem* AddCascadingMenuItem( const char *pszButtonText, Menu *pSubMenu, const char *pszCategoryName );
+
+private:
+
+	void AddSepratorIfNeeded( const char *pszCategoryName );
+
+	Menu *m_pMenu;
+	Panel *m_pActionTarget;
+	const char *m_pszLastCategory;
+};
+
 } // namespace vgui
 
 #endif // MENU_H
diff --git a/mp/src/public/vgui_controls/Panel.h b/mp/src/public/vgui_controls/Panel.h
index 07b63d8d..174dea42 100644
--- a/mp/src/public/vgui_controls/Panel.h
+++ b/mp/src/public/vgui_controls/Panel.h
@@ -180,6 +180,8 @@ public:
 	// all units are in pixels
 	void SetPos(int x,int y);		// sets position of panel, in local space (ie. relative to parent's position)
 	void GetPos(int &x,int &y);		// gets local position of panel
+	int GetXPos();
+	int GetYPos();
 	void SetSize(int wide,int tall);	// sets size of panel
 	void GetSize(int &wide, int &tall);	// gets size of panel
 	void SetBounds(int x, int y, int wide, int tall);		// combination of SetPos/SetSize
@@ -232,7 +234,7 @@ public:
 	Panel *FindSiblingByName(const char *siblingName);
 	void CallParentFunction(KeyValues *message);
 
-	template <class T>
+	template < class T >
 	T *FindControl( const char *pszName, bool recurseDown = false ) { return dynamic_cast<T *>( FindChildByName( pszName, recurseDown ) ); }
 
 	virtual void SetAutoDelete(bool state);		// if set to true, panel automatically frees itself when parent is deleted
@@ -274,6 +276,8 @@ public:
 		PIN_CENTER_RIGHT,
 		PIN_CENTER_BOTTOM,
 		PIN_CENTER_LEFT,
+
+		PIN_LAST
 	};
 
 	// specifies the auto-resize directions for the panel
@@ -398,6 +402,7 @@ public:
 	virtual void OnMousePressed(MouseCode code);
 	virtual void OnMouseDoublePressed(MouseCode code);
 	virtual void OnMouseReleased(MouseCode code);
+	virtual void OnMouseMismatchedRelease( MouseCode code, Panel* pPressedPanel );
 	virtual void OnMouseWheeled(int delta);
 
 	// Trip pressing (e.g., select all text in a TextEntry) requires this to be enabled
@@ -667,6 +672,8 @@ protected:
 	virtual void PaintTraverse(bool Repaint, bool allowForce = true);
 
 protected:
+	virtual void OnChildSettingsApplied( KeyValues *pInResourceData, Panel *pChild );
+
 	MESSAGE_FUNC_ENUM_ENUM( OnRequestFocus, "OnRequestFocus", VPANEL, subFocus, VPANEL, defaultPanel);
 	MESSAGE_FUNC_INT_INT( OnScreenSizeChanged, "OnScreenSizeChanged", oldwide, oldtall );
 	virtual void *QueryInterface(EInterfaceID id);
@@ -913,6 +920,8 @@ private:
 
 	bool			m_bForceStereoRenderToFrameBuffer;
 
+	static Panel* m_sMousePressedPanels[ ( MOUSE_MIDDLE - MOUSE_LEFT ) + 1 ];
+
 	CPanelAnimationVar( float, m_flAlpha, "alpha", "255" );
 
 	// 1 == Textured (TextureId1 only)
diff --git a/mp/src/public/vgui_controls/SectionedListPanel.h b/mp/src/public/vgui_controls/SectionedListPanel.h
index c38f6c74..6fafedd3 100644
--- a/mp/src/public/vgui_controls/SectionedListPanel.h
+++ b/mp/src/public/vgui_controls/SectionedListPanel.h
@@ -210,6 +210,8 @@ public:
 	void MoveSelectionDown( void );
 	void MoveSelectionUp( void );
 
+	ScrollBar *GetScrollBar( void ) { return m_pScrollBar; }
+
 protected:
 	virtual void PerformLayout();
 	virtual void ApplySchemeSettings(IScheme *pScheme);
diff --git a/mp/src/public/vgui_controls/TextImage.h b/mp/src/public/vgui_controls/TextImage.h
index 499785ff..20446e7b 100644
--- a/mp/src/public/vgui_controls/TextImage.h
+++ b/mp/src/public/vgui_controls/TextImage.h
@@ -105,6 +105,9 @@ public:
 	void SetColorChangeStream( CUtlSortVector<label_colorchange_t,CColorChangeListLess> *pUtlVecStream );
 	void ClearColorChangeStream( void ) { m_ColorChangeStream.Purge(); }
 
+	const wchar_t *GetEllipsesPosition( void ) const { return m_pwszEllipsesPosition; }
+	bool IsWrapping() const { return m_LineBreaks.Count() != 0; }
+
 protected:
 	// truncate the _text string to fit into the draw width
 	void SizeText(wchar_t *tempText, int stringLength);
diff --git a/mp/src/public/vstdlib/IKeyValuesSystem.h b/mp/src/public/vstdlib/IKeyValuesSystem.h
index 1bd5a8ab..e999dd81 100644
--- a/mp/src/public/vstdlib/IKeyValuesSystem.h
+++ b/mp/src/public/vstdlib/IKeyValuesSystem.h
@@ -16,6 +16,9 @@
 typedef int HKeySymbol;
 #define INVALID_KEY_SYMBOL (-1)
 
+class IBaseFileSystem;
+class KeyValues;
+
 //-----------------------------------------------------------------------------
 // Purpose: Interface to shared data repository for KeyValues (included in vgui_controls.lib)
 //			allows for central data storage point of KeyValues symbol table
@@ -39,6 +42,12 @@ public:
 	// for debugging, adds KeyValues record into global list so we can track memory leaks
 	virtual void AddKeyValuesToMemoryLeakList(void *pMem, HKeySymbol name) = 0;
 	virtual void RemoveKeyValuesFromMemoryLeakList(void *pMem) = 0;
+
+	// maintain a cache of KeyValues we load from disk. This saves us quite a lot of time on app startup. 
+	virtual void AddFileKeyValuesToCache( const KeyValues* _kv, const char *resourceName, const char *pathID ) = 0;
+	virtual bool LoadFileKeyValuesFromCache( KeyValues* _outKv, const char *resourceName, const char *pathID, IBaseFileSystem *filesystem ) const = 0;
+	virtual void InvalidateCache( ) = 0;
+	virtual void InvalidateCacheForFile( const char *resourceName, const char *pathID ) = 0;
 };
 
 VSTDLIB_INTERFACE IKeyValuesSystem *KeyValuesSystem();
diff --git a/mp/src/public/vstdlib/random.h b/mp/src/public/vstdlib/random.h
index 88188031..fdfd09c6 100644
--- a/mp/src/public/vstdlib/random.h
+++ b/mp/src/public/vstdlib/random.h
@@ -22,9 +22,11 @@
 //-----------------------------------------------------------------------------
 // A generator of uniformly distributed random numbers
 //-----------------------------------------------------------------------------
-class IUniformRandomStream
+class VSTDLIB_CLASS IUniformRandomStream
 {
 public:
+	//virtual ~IUniformRandomStream() { }
+
 	// Sets the seed of the random number generator
 	virtual void	SetSeed( int iSeed ) = 0;
 
@@ -86,7 +88,6 @@ private:
 	CThreadFastMutex m_mutex;
 };
 
-
 //-----------------------------------------------------------------------------
 // A couple of convenience functions to access the library's global uniform stream
 //-----------------------------------------------------------------------------
@@ -96,6 +97,17 @@ VSTDLIB_INTERFACE float	RandomFloatExp( float flMinVal = 0.0f, float flMaxVal =
 VSTDLIB_INTERFACE int	RandomInt( int iMinVal, int iMaxVal );
 VSTDLIB_INTERFACE float	RandomGaussianFloat( float flMean = 0.0f, float flStdDev = 1.0f );
 
+//-----------------------------------------------------------------------------
+// IUniformRandomStream interface for free functions
+//-----------------------------------------------------------------------------
+class VSTDLIB_CLASS CDefaultUniformRandomStream : public IUniformRandomStream
+{
+public:
+	virtual void	SetSeed( int iSeed ) OVERRIDE												{ RandomSeed( iSeed ); }
+	virtual float	RandomFloat( float flMinVal, float flMaxVal ) OVERRIDE						{ return ::RandomFloat( flMinVal, flMaxVal ); }
+	virtual int		RandomInt( int iMinVal, int iMaxVal ) OVERRIDE								{ return ::RandomInt( iMinVal, iMaxVal ); }
+	virtual float	RandomFloatExp( float flMinVal, float flMaxVal, float flExponent ) OVERRIDE	{ return ::RandomFloatExp( flMinVal, flMaxVal, flExponent ); }
+};
 
 //-----------------------------------------------------------------------------
 // Installs a global random number generator, which will affect the Random functions above
diff --git a/mp/src/public/vtf/vtf.h b/mp/src/public/vtf/vtf.h
index ecf10c88..a77e7fb1 100644
--- a/mp/src/public/vtf/vtf.h
+++ b/mp/src/public/vtf/vtf.h
@@ -56,9 +56,9 @@ enum CompiledVtfFlags
 	TEXTUREFLAGS_NODEBUGOVERRIDE               = 0x00020000,
 	TEXTUREFLAGS_SINGLECOPY		               = 0x00040000,
 	
-		TEXTUREFLAGS_UNUSED_00080000		   = 0x00080000,
-		TEXTUREFLAGS_UNUSED_00100000		   = 0x00100000,
-		TEXTUREFLAGS_UNUSED_00200000           = 0x00200000,
+	TEXTUREFLAGS_STAGING_MEMORY                = 0x00080000,
+	TEXTUREFLAGS_IMMEDIATE_CLEANUP			   = 0x00100000,
+	TEXTUREFLAGS_IGNORE_PICMIP				   = 0x00200000,
 		TEXTUREFLAGS_UNUSED_00400000           = 0x00400000,
 
 	TEXTUREFLAGS_NODEPTHBUFFER                 = 0x00800000,
diff --git a/mp/src/public/zip_uncompressed.h b/mp/src/public/zip_uncompressed.h
index 0c8a45e6..11f4e86d 100644
--- a/mp/src/public/zip_uncompressed.h
+++ b/mp/src/public/zip_uncompressed.h
@@ -14,6 +14,10 @@
 
 #define PKID( a, b ) (((b)<<24)|((a)<<16)|('K'<<8)|'P')
 
+// compressionMethod field
+#define ZIP_COMPRESSION_NONE  0
+#define ZIP_COMPRESSION_LZMA 14
+
 #pragma pack(1)
 
 struct ZIP_EndOfCentralDirRecord
diff --git a/mp/src/public/zip_utils.cpp b/mp/src/public/zip_utils.cpp
index 79f51c5c..848e7a79 100644
--- a/mp/src/public/zip_utils.cpp
+++ b/mp/src/public/zip_utils.cpp
@@ -23,6 +23,13 @@
 #include "byteswap.h"
 #include "utlstring.h"
 
+#include "tier1/lzmaDecoder.h"
+
+// Not every user of zip utils wants to link LZMA encoder
+#ifdef ZIP_SUPPORT_LZMA_ENCODE
+#include "lzma/lzma.h"
+#endif
+
 // Data descriptions for byte swapping - only needed
 // for structures that are written to file for use by the game.
 BEGIN_BYTESWAP_DATADESC( ZIP_EndOfCentralDirRecord )
@@ -248,7 +255,7 @@ public:
 	CBufferStream( CUtlBuffer& buff ) : IWriteStream(), m_buff( &buff ) {}
 
 	// Implementing IWriteStream method
-	virtual void Put( const void* pMem, int size ) { m_buff->Put( pMem, size ); }
+	virtual void Put( const void* pMem, int size ) {m_buff->Put( pMem, size );}
 
 	// Implementing IWriteStream method
 	virtual unsigned int Tell( void ) { return m_buff->TellPut(); }
@@ -321,13 +328,13 @@ public:
 	void			Reset( void );
 
 	// Add file to zip under relative name
-	void			AddFileToZip( const char *relativename, const char *fullpath );
+	void			AddFileToZip( const char *relativename, const char *fullpath, IZip::eCompressionType compressionType );
 
 	// Delete file from zip
 	void			RemoveFileFromZip( const char *relativename );
 
 	// Add buffer to zip as a file with given name
-	void			AddBufferToZip( const char *relativename, void *data, int length, bool bTextMode );
+	void			AddBufferToZip( const char *relativename, void *data, int length, bool bTextMode, IZip::eCompressionType compressionType );
 
 	// Check if a file already exists in the zip.
 	bool			FileExistsInZip( const char *relativename );
@@ -373,9 +380,12 @@ private:
 
 	typedef struct
 	{
-		CUtlSymbol			m_Name;
-		unsigned int		filepos;
-		int					filelen;
+		CUtlSymbol             m_Name;
+		unsigned int           filepos;
+		int                    filelen;
+		int                    uncompressedLen;
+		CRC32_t                crc32;
+		IZip::eCompressionType compressionType;
 	} TmpFileInfo_t;
 
 	CByteswap		m_Swap;
@@ -405,18 +415,25 @@ private:
 		CUtlSymbol		m_Name;
 
 		// Lenth of data element
-		int				m_Length;
+		int				m_nCompressedSize;
+
+		// Original, uncompressed size
+		int				m_nUncompressedSize;
+
 		// Raw data, could be null and data may be in disk write cache
 		void			*m_pData;
 
 		// Offset in Zip ( set and valid during final write )
 		unsigned int	m_ZipOffset;
-		// CRC of blob ( set and valid during final write )
+		// CRC of blob
 		CRC32_t			m_ZipCRC;
 
 		// Location of data in disk cache
 		unsigned int	m_DiskCacheOffset;
 		unsigned int	m_SourceDiskOffset;
+
+		// The compression used on the data if any
+		IZip::eCompressionType m_eCompressionType;
 	};
 
 	// For fast name lookup and sorting
@@ -435,12 +452,14 @@ private:
 CZipFile::CZipEntry::CZipEntry( void )
 {
 	m_Name = "";
-	m_Length = 0;
+	m_nCompressedSize = 0;
+	m_nUncompressedSize = 0;
 	m_pData = NULL;
 	m_ZipOffset = 0;
 	m_ZipCRC = 0;
 	m_DiskCacheOffset = 0;
 	m_SourceDiskOffset = 0;
+	m_eCompressionType = IZip::eCompressionType_None;
 }
 
 //-----------------------------------------------------------------------------
@@ -450,12 +469,14 @@ CZipFile::CZipEntry::CZipEntry( void )
 CZipFile::CZipEntry::CZipEntry( const CZipFile::CZipEntry& src )
 {
 	m_Name = src.m_Name;
-	m_Length = src.m_Length;
+	m_nCompressedSize = src.m_nCompressedSize;
+	m_nUncompressedSize = src.m_nUncompressedSize;
+	m_eCompressionType = src.m_eCompressionType;
 
-	if ( src.m_Length > 0 && src.m_pData )
+	if ( src.m_nCompressedSize > 0 && src.m_pData )
 	{
-		m_pData = malloc( src.m_Length );
-		memcpy( m_pData, src.m_pData, src.m_Length );
+		m_pData = malloc( src.m_nCompressedSize );
+		memcpy( m_pData, src.m_pData, src.m_nCompressedSize );
 	}
 	else
 	{
@@ -674,20 +695,27 @@ void CZipFile::ParseFromBuffer( void *buffer, int bufferlength )
 		ZIP_FileHeader zipFileHeader;
 		buf.GetObjects( &zipFileHeader );
 		Assert( zipFileHeader.signature == PKID( 1, 2 ) );
-		Assert( zipFileHeader.compressionMethod == 0 );
-		
-		char tmpString[1024];
-		buf.Get( tmpString, zipFileHeader.fileNameLength );
-		tmpString[zipFileHeader.fileNameLength] = '\0';
+		if ( zipFileHeader.compressionMethod != IZip::eCompressionType_None &&
+		     zipFileHeader.compressionMethod != IZip::eCompressionType_LZMA )
+		{
+			Assert( false );
+			Warning( "Opening ZIP file with unsupported compression type\n");
+		}
+
+		char tmpString[1024] = { 0 };
+		buf.Get( tmpString, Min( (unsigned int)zipFileHeader.fileNameLength, (unsigned int)sizeof( tmpString ) ) );
 		Q_strlower( tmpString );
 
 		// can determine actual filepos, assuming a well formed zip
 		newfiles[i].m_Name = tmpString;
 		newfiles[i].filelen = zipFileHeader.compressedSize;
+		newfiles[i].uncompressedLen = zipFileHeader.uncompressedSize;
+		newfiles[i].crc32 = zipFileHeader.crc32;
 		newfiles[i].filepos = zipFileHeader.relativeOffsetOfLocalHeader +
-								sizeof( ZIP_LocalFileHeader ) + 
-								zipFileHeader.fileNameLength + 
-								zipFileHeader.extraFieldLength;
+		                      sizeof( ZIP_LocalFileHeader ) +
+		                      zipFileHeader.fileNameLength +
+		                      zipFileHeader.extraFieldLength;
+		newfiles[i].compressionType = (IZip::eCompressionType)zipFileHeader.compressionMethod;
 
 		int nextOffset;
 		if ( m_bCompatibleFormat )
@@ -706,16 +734,19 @@ void CZipFile::ParseFromBuffer( void *buffer, int bufferlength )
 	{
 		CZipEntry e;
 		e.m_Name = newfiles[i].m_Name;
-		e.m_Length = newfiles[i].filelen;
-		
+		e.m_nCompressedSize = newfiles[i].filelen;
+		e.m_ZipCRC = newfiles[i].crc32;
+		e.m_nUncompressedSize = newfiles[i].uncompressedLen;
+		e.m_eCompressionType = newfiles[i].compressionType;
+
 		// Make sure length is reasonable
-		if ( e.m_Length > 0 )
+		if ( e.m_nCompressedSize > 0 )
 		{
-			e.m_pData = malloc( e.m_Length );
+			e.m_pData = malloc( e.m_nCompressedSize );
 
 			// Copy in data
 			buf.SeekGet( CUtlBuffer::SEEK_HEAD, newfiles[i].filepos );
-			buf.Get( e.m_pData, e.m_Length );
+			buf.Get( e.m_pData, e.m_nCompressedSize );
 		}
 		else
 		{
@@ -826,7 +857,9 @@ HANDLE CZipFile::ParseFromDisk( const char *pFilename )
 		ZIP_FileHeader zipFileHeader;
 		zipDirBuff.GetObjects( &zipFileHeader );
 
-		if ( zipFileHeader.signature != PKID( 1, 2 ) ||  zipFileHeader.compressionMethod != 0 )
+		if ( zipFileHeader.signature != PKID( 1, 2 )
+		     || ( zipFileHeader.compressionMethod != IZip::eCompressionType_None
+		          && zipFileHeader.compressionMethod != IZip::eCompressionType_LZMA ) )
 		{
 			// bad contents
 #ifdef WIN32
@@ -836,7 +869,7 @@ HANDLE CZipFile::ParseFromDisk( const char *pFilename )
 #endif
 			return NULL;
 		}
-		
+
 		char fileName[1024];
 		zipDirBuff.Get( fileName, zipFileHeader.fileNameLength );
 		fileName[zipFileHeader.fileNameLength] = '\0';
@@ -845,11 +878,15 @@ HANDLE CZipFile::ParseFromDisk( const char *pFilename )
 		// can determine actual filepos, assuming a well formed zip
 		CZipEntry e;
 		e.m_Name = fileName;
-		e.m_Length = zipFileHeader.compressedSize;
+		e.m_nCompressedSize = zipFileHeader.compressedSize;
+		e.m_nUncompressedSize = zipFileHeader.uncompressedSize;
+		e.m_ZipCRC = zipFileHeader.crc32;
 		e.m_SourceDiskOffset = zipFileHeader.relativeOffsetOfLocalHeader +
-								sizeof( ZIP_LocalFileHeader ) + 
-								zipFileHeader.fileNameLength + 
-								zipFileHeader.extraFieldLength;
+		                       sizeof( ZIP_LocalFileHeader ) +
+		                       zipFileHeader.fileNameLength +
+		                       zipFileHeader.extraFieldLength;
+		e.m_eCompressionType = (IZip::eCompressionType)zipFileHeader.compressionMethod;
+
 		// Add to tree
 		m_Files.Insert( e );
 
@@ -954,19 +991,85 @@ static void CopyTextData( char *pDst, const char *pSrc, int dstSize, int srcSize
 //			*data - 
 //			length - 
 //-----------------------------------------------------------------------------
-void CZipFile::AddBufferToZip( const char *relativename, void *data, int length, bool bTextMode )
+void CZipFile::AddBufferToZip( const char *relativename, void *data, int length, bool bTextMode, IZip::eCompressionType compressionType )
 {
 	// Lower case only
 	char name[512];
 	Q_strcpy( name, relativename );
 	Q_strlower( name );
 
-	int dstLength = length;
+	int outLength = length;
+	int uncompressedLength = length;
+	void *outData = data;
+	CUtlBuffer textTransform;
+	CUtlBuffer compressionTransform;
+
 	if ( bTextMode )
 	{
-		dstLength = GetLengthOfBinStringAsText( ( const char * )data, length );
+		int textLen = GetLengthOfBinStringAsText( ( const char * )outData, outLength );
+		textTransform.EnsureCapacity( textLen );
+		CopyTextData( (char *)textTransform.Base(), (char *)outData, textLen, outLength );
+
+		outData = (void *)textTransform.Base();
+		outLength = textLen;
+		uncompressedLength = textLen;
 	}
-	
+
+	// uncompressed data final at this point (CRC is before compression)
+	CRC32_t zipCRC;
+	CRC32_Init( &zipCRC );
+	CRC32_ProcessBuffer( &zipCRC, outData, outLength );
+	CRC32_Final( &zipCRC );
+
+#ifdef ZIP_SUPPORT_LZMA_ENCODE
+	if ( compressionType == IZip::eCompressionType_LZMA )
+	{
+		unsigned int compressedSize = 0;
+		unsigned char *pCompressedOutput = LZMA_Compress( (unsigned char *)outData, outLength, &compressedSize );
+		if ( !pCompressedOutput || compressedSize < sizeof( lzma_header_t ) )
+		{
+			Warning( "ZipFile: LZMA compression failed\n" );
+			return;
+		}
+
+		// Fixup LZMA header for ZIP payload usage
+		// The output of LZMA_Compress uses lzma_header_t, defined alongside it.
+		//
+		// ZIP payload format, see ZIP spec 5.8.8:
+		//  LZMA Version Information 2 bytes
+		//  LZMA Properties Size 2 bytes
+		//  LZMA Properties Data variable, defined by "LZMA Properties Size"
+		unsigned int nZIPHeader = 2 + 2 + sizeof( lzma_header_t().properties );
+		unsigned int finalCompressedSize = compressedSize - sizeof( lzma_header_t ) + nZIPHeader;
+		compressionTransform.EnsureCapacity( finalCompressedSize );
+
+		// LZMA version
+		compressionTransform.PutUnsignedChar( LZMA_SDK_VERSION_MAJOR );
+		compressionTransform.PutUnsignedChar( LZMA_SDK_VERSION_MINOR );
+		// properties size
+		uint16 nSwappedPropertiesSize = LittleWord( sizeof( lzma_header_t().properties ) );
+		compressionTransform.Put( &nSwappedPropertiesSize, sizeof( nSwappedPropertiesSize ) );
+		// properties
+		compressionTransform.Put( &(((lzma_header_t *)pCompressedOutput)->properties), sizeof( lzma_header_t().properties ) );
+		// payload
+		compressionTransform.Put( pCompressedOutput + sizeof( lzma_header_t ), compressedSize - sizeof( lzma_header_t ) );
+
+		// Free original
+		free( pCompressedOutput );
+		pCompressedOutput = NULL;
+
+		outData = (void *)compressionTransform.Base();
+		outLength = finalCompressedSize;
+		// (Not updating uncompressedLength)
+	}
+	else
+#endif
+	/* else from ifdef */ if ( compressionType != IZip::eCompressionType_None )
+	{
+		Error( "Calling AddBufferToZip with unknown compression type\n" );
+		return;
+	}
+
 	// See if entry is in list already
 	CZipEntry e;
 	e.m_Name = name;
@@ -981,23 +1084,17 @@ void CZipFile::AddBufferToZip( const char *relativename, void *data, int length,
 			free( update->m_pData );
 		}
 
-		if ( bTextMode )
-		{
-			update->m_pData = malloc( dstLength );
-			CopyTextData( ( char * )update->m_pData, ( char * )data, dstLength, length );
-			update->m_Length = dstLength;
-		}
-		else
-		{
-			update->m_pData = malloc( length );
-			memcpy( update->m_pData, data, length );
-			update->m_Length = length;
-		}
+		update->m_eCompressionType = compressionType;
+		update->m_pData = malloc( outLength );
+		memcpy( update->m_pData, outData, outLength );
+		update->m_nCompressedSize = outLength;
+		update->m_nUncompressedSize = uncompressedLength;
+		update->m_ZipCRC = zipCRC;
 
 		if ( m_hDiskCacheWriteFile != INVALID_HANDLE_VALUE )
 		{
 			update->m_DiskCacheOffset = CWin32File::FileTell( m_hDiskCacheWriteFile );
-			CWin32File::FileWrite( m_hDiskCacheWriteFile, update->m_pData, update->m_Length );
+			CWin32File::FileWrite( m_hDiskCacheWriteFile, update->m_pData, update->m_nCompressedSize );
 			free( update->m_pData );
 			update->m_pData = NULL;
 		}
@@ -1005,24 +1102,19 @@ void CZipFile::AddBufferToZip( const char *relativename, void *data, int length,
 	else
 	{
 		// Create a new entry
-		e.m_Length = dstLength;
-		if ( dstLength > 0 )
+		e.m_nCompressedSize = outLength;
+		e.m_nUncompressedSize = uncompressedLength;
+		e.m_eCompressionType = compressionType;
+		e.m_ZipCRC = zipCRC;
+		if ( outLength > 0 )
 		{
-			if ( bTextMode )
-			{
-				e.m_pData = malloc( dstLength );
-				CopyTextData( (char *)e.m_pData, ( char * )data, dstLength, length );
-			}
-			else
-			{
-				e.m_pData = malloc( length );
-				memcpy( e.m_pData, data, length );
-			}
-	
+			e.m_pData = malloc( outLength );
+			memcpy( e.m_pData, outData, outLength );
+
 			if ( m_hDiskCacheWriteFile != INVALID_HANDLE_VALUE )
 			{
 				e.m_DiskCacheOffset = CWin32File::FileTell( m_hDiskCacheWriteFile );
-				CWin32File::FileWrite( m_hDiskCacheWriteFile, e.m_pData, e.m_Length );
+				CWin32File::FileWrite( m_hDiskCacheWriteFile, e.m_pData, e.m_nCompressedSize );
 				free( e.m_pData );
 				e.m_pData = NULL;
 			}
@@ -1042,38 +1134,11 @@ void CZipFile::AddBufferToZip( const char *relativename, void *data, int length,
 //-----------------------------------------------------------------------------
 bool CZipFile::ReadFileFromZip( const char *pRelativeName, bool bTextMode, CUtlBuffer &buf )
 {
-	// Lower case only
-	char pName[512];
-	Q_strncpy( pName, pRelativeName, 512 );
-	Q_strlower( pName );
-
-	// See if entry is in list already
-	CZipEntry e;
-	e.m_Name = pName;
-	int nIndex = m_Files.Find( e );
-	if ( nIndex == m_Files.InvalidIndex() )
-	{
-		// not found
-		return false;
-	}
-
-	CZipEntry *pEntry = &m_Files[ nIndex ];
-	if ( bTextMode )
-	{
-		buf.SetBufferType( true, false );
-		ReadTextData( (char*)pEntry->m_pData, pEntry->m_Length, buf );
-	}
-	else
-	{
-		buf.SetBufferType( false, false );
-		buf.Put( pEntry->m_pData, pEntry->m_Length );
-	}
-
-	return true;
+	return ReadFileFromZip( 0, pRelativeName, bTextMode, buf );
 }
 
 //-----------------------------------------------------------------------------
-// Reads a file from the zip
+// Reads a file from the zip. Requires the zip file handle if this zip was loaded via ParseFromDisk
 //-----------------------------------------------------------------------------
 bool CZipFile::ReadFileFromZip( HANDLE hZipFile, const char *pRelativeName, bool bTextMode, CUtlBuffer &buf )
 {
@@ -1094,27 +1159,63 @@ bool CZipFile::ReadFileFromZip( HANDLE hZipFile, const char *pRelativeName, bool
 
 	CZipEntry *pEntry = &m_Files[nIndex];
 
-	void *pData = malloc( pEntry->m_Length );
-	CWin32File::FileSeek( hZipFile, pEntry->m_SourceDiskOffset, FILE_BEGIN );
-	if ( !CWin32File::FileRead( hZipFile, pData, pEntry->m_Length ) )
+	void *pData = pEntry->m_pData;
+	CUtlBuffer readBuffer;
+	if ( !pData && hZipFile )
 	{
-		free( pData );
-		return false;
+		readBuffer.EnsureCapacity( pEntry->m_nCompressedSize );
+		CWin32File::FileSeek( hZipFile, pEntry->m_SourceDiskOffset, FILE_BEGIN );
+		if ( !CWin32File::FileRead( hZipFile, readBuffer.Base(), pEntry->m_nCompressedSize ) )
+		{
+			return false;
+		}
+
+		pData = readBuffer.Base();
+	}
+
+	CUtlBuffer decompressTransform;
+	if ( pEntry->m_eCompressionType != IZip::eCompressionType_None )
+	{
+		if ( pEntry->m_eCompressionType == IZip::eCompressionType_LZMA )
+		{
+			decompressTransform.EnsureCapacity( pEntry->m_nUncompressedSize );
+
+			CLZMAStream decompressStream;
+			decompressStream.InitZIPHeader( pEntry->m_nCompressedSize, pEntry->m_nUncompressedSize );
+
+			unsigned int nCompressedBytesRead = 0;
+			unsigned int nOutputBytesWritten = 0;
+			bool bSuccess = decompressStream.Read( (unsigned char *)pData, pEntry->m_nCompressedSize,
+												   (unsigned char *)decompressTransform.Base(), decompressTransform.Size(),
+												   nCompressedBytesRead, nOutputBytesWritten );
+			if ( !bSuccess ||
+			     (int)nCompressedBytesRead != pEntry->m_nCompressedSize ||
+			     (int)nOutputBytesWritten != pEntry->m_nUncompressedSize )
+			{
+				Error( "Zip: Failed decompressing LZMA data\n" );
+				return false;
+			}
+
+			pData = decompressTransform.Base();
+		}
+		else
+		{
+			Error( "Unsupported compression type in Zip file: %u\n", pEntry->m_eCompressionType );
+			return false;
+		}
 	}
 
 	if ( bTextMode )
 	{
 		buf.SetBufferType( true, false );
-		ReadTextData( (const char *)pData, pEntry->m_Length, buf );
+		ReadTextData( (const char *)pData, pEntry->m_nUncompressedSize, buf );
 	}
 	else
 	{
 		buf.SetBufferType( false, false );
-		buf.Put( pData, pEntry->m_Length );
+		buf.Put( pData, pEntry->m_nUncompressedSize );
 	}
 
-	free( pData );
-
 	return true;
 }
 
@@ -1142,7 +1243,7 @@ bool CZipFile::FileExistsInZip( const char *pRelativeName )
 //-----------------------------------------------------------------------------
 // Purpose: Adds a new file to the zip.
 //-----------------------------------------------------------------------------
-void CZipFile::AddFileToZip( const char *relativename, const char *fullpath )
+void CZipFile::AddFileToZip( const char *relativename, const char *fullpath, IZip::eCompressionType compressionType )
 {
 	FILE *temp = fopen( fullpath, "rb" );
 	if ( !temp )
@@ -1159,8 +1260,8 @@ void CZipFile::AddFileToZip( const char *relativename, const char *fullpath )
 	fclose( temp );
 
 	// Now add as a buffer
-	AddBufferToZip( relativename, buf, size, false );
-	
+	AddBufferToZip( relativename, buf, size, false, compressionType );
+
 	free( buf );
 }
 
@@ -1252,8 +1353,8 @@ unsigned int CZipFile::CalculateSize( void )
 	for ( int i = m_Files.FirstInorder(); i != m_Files.InvalidIndex(); i = m_Files.NextInorder( i ) )
 	{
 		CZipEntry *e = &m_Files[ i ];
-		
-		if ( e->m_Length == 0 )
+
+		if ( e->m_nCompressedSize == 0 )
 			continue;
 
 		// local file header
@@ -1268,7 +1369,7 @@ unsigned int CZipFile::CalculateSize( void )
 		{
 			// round up to next boundary
 			unsigned int nextBoundary = ( size + m_AlignmentSize ) & ~( m_AlignmentSize - 1 );
-			
+
 			// the directory header also duplicates the padding
 			dirHeaders += nextBoundary - size;
 
@@ -1276,7 +1377,7 @@ unsigned int CZipFile::CalculateSize( void )
 		}
 
 		// data size
-		size += e->m_Length;
+		size += e->m_nCompressedSize;
 	}
 
 	size += dirHeaders;
@@ -1322,7 +1423,7 @@ int CZipFile::GetNextFilename( int id, char *pBuffer, int bufferSize, int &fileS
 	CZipEntry *e = &m_Files[id];
 
 	Q_strncpy( pBuffer, e->m_Name.String(), bufferSize );
-	fileSize = e->m_Length;
+	fileSize = e->m_nUncompressedSize;
 
 	return id;
 }
@@ -1373,6 +1474,9 @@ void CZipFile::SaveDirectory( IWriteStream& stream )
 #endif
 	}
 
+	// Might be writing a zip into a larger stream
+	unsigned int zipOffsetInStream = stream.Tell();
+
 	int i;
 	for ( i = m_Files.FirstInorder(); i != m_Files.InvalidIndex(); i = m_Files.NextInorder( i ) )
 	{
@@ -1380,47 +1484,50 @@ void CZipFile::SaveDirectory( IWriteStream& stream )
 		Assert( e );
 
 		// Fix up the offset
-		e->m_ZipOffset = stream.Tell();
+		e->m_ZipOffset = stream.Tell() - zipOffsetInStream;
 
-		if ( e->m_Length > 0 && ( m_hDiskCacheWriteFile != INVALID_HANDLE_VALUE ) )
-		{	
+		if ( e->m_nCompressedSize > 0 && ( m_hDiskCacheWriteFile != INVALID_HANDLE_VALUE ) )
+		{
 			// get the data back from the write cache
-			e->m_pData = malloc( e->m_Length );
+			e->m_pData = malloc( e->m_nCompressedSize );
 			if ( e->m_pData )
 			{
 				CWin32File::FileSeek( m_hDiskCacheWriteFile, e->m_DiskCacheOffset, FILE_BEGIN );
-				CWin32File::FileRead( m_hDiskCacheWriteFile, e->m_pData, e->m_Length );
+				CWin32File::FileRead( m_hDiskCacheWriteFile, e->m_pData, e->m_nCompressedSize );
 			}
 		}
 
-		if ( e->m_Length > 0 && e->m_pData != NULL )
+		if ( e->m_nCompressedSize > 0 && e->m_pData != NULL )
 		{
 			ZIP_LocalFileHeader hdr = { 0 };
 			hdr.signature = PKID( 3, 4 );
-			hdr.versionNeededToExtract = 10;  // This is the version that the winzip that I have writes.
+			hdr.versionNeededToExtract = 10;  // No special features or even compression here, set to 1.0
+#ifdef ZIP_SUPPORT_LZMA_ENCODE
+			if ( e->m_eCompressionType == IZip::eCompressionType_LZMA )
+			{
+				// Per ZIP spec 5.8.8
+				hdr.versionNeededToExtract = 63;
+			}
+#endif
 			hdr.flags = 0;
-			hdr.compressionMethod = 0; // NO COMPRESSION!
+			hdr.compressionMethod = e->m_eCompressionType;
 			hdr.lastModifiedTime = 0;
 			hdr.lastModifiedDate = 0;
-
-			CRC32_Init( &e->m_ZipCRC );
-			CRC32_ProcessBuffer( &e->m_ZipCRC, e->m_pData, e->m_Length );
-			CRC32_Final( &e->m_ZipCRC );
 			hdr.crc32 = e->m_ZipCRC;
-			
+
 			const char *pFilename = e->m_Name.String();
-			hdr.compressedSize = e->m_Length;
-			hdr.uncompressedSize = e->m_Length;
+			hdr.compressedSize = e->m_nCompressedSize;
+			hdr.uncompressedSize = e->m_nUncompressedSize;
 			hdr.fileNameLength = strlen( pFilename );
 			hdr.extraFieldLength = CalculatePadding( hdr.fileNameLength, e->m_ZipOffset );
 			int extraFieldLength = hdr.extraFieldLength;
-			
+
 			// Swap header in place
 			m_Swap.SwapFieldsToTargetEndian( &hdr );
 			stream.Put( &hdr, sizeof( hdr ) );
 			stream.Put( pFilename, strlen( pFilename ) );
 			stream.Put( pPaddingBuffer, extraFieldLength );
-			stream.Put( e->m_pData, e->m_Length );
+			stream.Put( e->m_pData, e->m_nCompressedSize );
 
 			if ( m_hDiskCacheWriteFile != INVALID_HANDLE_VALUE )
 			{
@@ -1437,7 +1544,7 @@ void CZipFile::SaveDirectory( IWriteStream& stream )
 		CWin32File::FileSeek( m_hDiskCacheWriteFile, 0, FILE_END );
 	}
 
-	unsigned int centralDirStart = stream.Tell();
+	unsigned int centralDirStart = stream.Tell() - zipOffsetInStream;
 	if ( m_AlignmentSize )
 	{
 		// align the central directory starting position
@@ -1455,21 +1562,28 @@ void CZipFile::SaveDirectory( IWriteStream& stream )
 	{
 		CZipEntry *e = &m_Files[i];
 		Assert( e );
-		
-		if ( e->m_Length > 0 && e->m_pData != NULL )
+
+		if ( e->m_nCompressedSize > 0 && e->m_pData != NULL )
 		{
 			ZIP_FileHeader hdr = { 0 };
 			hdr.signature = PKID( 1, 2 );
 			hdr.versionMadeBy = 20;				// This is the version that the winzip that I have writes.
-			hdr.versionNeededToExtract = 10;	// This is the version that the winzip that I have writes.
+			hdr.versionNeededToExtract = 10;  // No special features or even compression here, set to 1.0
+#ifdef ZIP_SUPPORT_LZMA_ENCODE
+			if ( e->m_eCompressionType == IZip::eCompressionType_LZMA )
+			{
+				// Per ZIP spec 5.8.8
+				hdr.versionNeededToExtract = 63;
+			}
+#endif
 			hdr.flags = 0;
-			hdr.compressionMethod = 0;
+			hdr.compressionMethod = e->m_eCompressionType;
 			hdr.lastModifiedTime = 0;
 			hdr.lastModifiedDate = 0;
 			hdr.crc32 = e->m_ZipCRC;
 
-			hdr.compressedSize = e->m_Length;
-			hdr.uncompressedSize = e->m_Length;
+			hdr.compressedSize = e->m_nCompressedSize;
+			hdr.uncompressedSize = e->m_nUncompressedSize;
 			hdr.fileNameLength = strlen( e->m_Name.String() );
 			hdr.extraFieldLength = CalculatePadding( hdr.fileNameLength, e->m_ZipOffset );
 			hdr.fileCommentLength = 0;
@@ -1498,7 +1612,7 @@ void CZipFile::SaveDirectory( IWriteStream& stream )
 		}
 	}
 
-	unsigned int centralDirEnd = stream.Tell();
+	unsigned int centralDirEnd = stream.Tell() - zipOffsetInStream;
 	if ( m_AlignmentSize )
 	{
 		// align the central directory starting position
@@ -1541,56 +1655,57 @@ public:
 	CZip( const char *pDiskCacheWritePath, bool bSortByName );
 	virtual ~CZip();
 
-	virtual void			Reset();
+	virtual void			Reset() OVERRIDE;
 
 	// Add a single file to a zip - maintains the zip's previous alignment state
-	virtual void			AddFileToZip( const char *relativename, const char *fullpath );
+	virtual void			AddFileToZip( const char *relativename, const char *fullpath, eCompressionType compressionType ) OVERRIDE;
 
 	// Whether a file is contained in a zip - maintains alignment
-	virtual bool			FileExistsInZip( const char *pRelativeName );
+	virtual bool			FileExistsInZip( const char *pRelativeName ) OVERRIDE;
 
 	// Reads a file from the zip - maintains alignement
-	virtual bool			ReadFileFromZip( const char *pRelativeName, bool bTextMode, CUtlBuffer &buf );
-	virtual bool			ReadFileFromZip( HANDLE hZipFile, const char *relativename, bool bTextMode, CUtlBuffer &buf );
+	virtual bool			ReadFileFromZip( const char *pRelativeName, bool bTextMode, CUtlBuffer &buf ) OVERRIDE;
+	virtual bool			ReadFileFromZip( HANDLE hZipFile, const char *relativename, bool bTextMode, CUtlBuffer &buf ) OVERRIDE;
 
 	// Removes a single file from the zip - maintains alignment
-	virtual void			RemoveFileFromZip( const char *relativename );
+	virtual void			RemoveFileFromZip( const char *relativename ) OVERRIDE;
 
 	// Gets next filename in zip, for walking the directory - maintains alignment
-	virtual int				GetNextFilename( int id, char *pBuffer, int bufferSize, int &fileSize );
+	virtual int				GetNextFilename( int id, char *pBuffer, int bufferSize, int &fileSize ) OVERRIDE;
 
 	// Prints the zip's contents - maintains alignment
-	virtual void			PrintDirectory( void );
+	virtual void			PrintDirectory( void ) OVERRIDE;
 
 	// Estimate the size of the Zip (including header, padding, etc.)
-	virtual unsigned int	EstimateSize( void );
+	virtual unsigned int	EstimateSize( void ) OVERRIDE;
 
 	// Add buffer to zip as a file with given name - uses current alignment size, default 0 (no alignment)
-	virtual void			AddBufferToZip( const char *relativename, void *data, int length, bool bTextMode );
+	virtual void			AddBufferToZip( const char *relativename, void *data, int length,
+											bool bTextMode, eCompressionType compressionType ) OVERRIDE;
 
-	// Writes out zip file to a buffer - uses current alignment size 
+	// Writes out zip file to a buffer - uses current alignment size
 	// (set by file's previous alignment, or a call to ForceAlignment)
-	virtual void			SaveToBuffer( CUtlBuffer& outbuf );
+	virtual void			SaveToBuffer( CUtlBuffer& outbuf ) OVERRIDE;
 
-	// Writes out zip file to a filestream - uses current alignment size 
+	// Writes out zip file to a filestream - uses current alignment size
 	// (set by file's previous alignment, or a call to ForceAlignment)
-	virtual void			SaveToDisk( FILE *fout );
-	virtual void			SaveToDisk( HANDLE hOutFile );
+	virtual void			SaveToDisk( FILE *fout ) OVERRIDE;
+	virtual void			SaveToDisk( HANDLE hOutFile ) OVERRIDE;
 
-	// Reads a zip file from a buffer into memory - sets current alignment size to 
+	// Reads a zip file from a buffer into memory - sets current alignment size to
 	// the file's alignment size, unless overridden by a ForceAlignment call)
-	virtual void			ParseFromBuffer( void *buffer, int bufferlength );
-	virtual HANDLE			ParseFromDisk( const char *pFilename );
+	virtual void			ParseFromBuffer( void *buffer, int bufferlength ) OVERRIDE;
+	virtual HANDLE			ParseFromDisk( const char *pFilename ) OVERRIDE;
 
 	// Forces a specific alignment size for all subsequent file operations, overriding files' previous alignment size.
 	// Return to using files' individual alignment sizes by passing FALSE.
-	virtual void			ForceAlignment( bool aligned, bool bCompatibleFormat, unsigned int alignmentSize );
+	virtual void			ForceAlignment( bool aligned, bool bCompatibleFormat, unsigned int alignmentSize ) OVERRIDE;
 
 	// Sets the endianess of the zip
-	virtual void			SetBigEndian( bool bigEndian );
-	virtual void			ActivateByteSwapping( bool bActivate );
+	virtual void			SetBigEndian( bool bigEndian ) OVERRIDE;
+	virtual void			ActivateByteSwapping( bool bActivate ) OVERRIDE;
 
-	virtual unsigned int	GetAlignment();
+	virtual unsigned int	GetAlignment() OVERRIDE;
 
 private:
 	CZipFile				m_ZipFile;
@@ -1599,11 +1714,11 @@ private:
 static CUtlLinkedList< CZip* > g_ZipUtils;
 
 IZip *IZip::CreateZip( const char *pDiskCacheWritePath, bool bSortByName )
-{ 
+{
 	CZip *pZip = new CZip( pDiskCacheWritePath, bSortByName );
 	g_ZipUtils.AddToTail( pZip );
 
-	return pZip; 
+	return pZip;
 }
 
 void IZip::ReleaseZip( IZip *pZip )
@@ -1632,9 +1747,9 @@ void CZip::ActivateByteSwapping( bool bActivate )
 	m_ZipFile.ActivateByteSwapping( bActivate );
 }
 
-void CZip::AddFileToZip( const char *relativename, const char *fullpath )
+void CZip::AddFileToZip( const char *relativename, const char *fullpath, eCompressionType compressionType )
 {
-	m_ZipFile.AddFileToZip( relativename, fullpath );
+	m_ZipFile.AddFileToZip( relativename, fullpath, compressionType );
 }
 
 bool CZip::FileExistsInZip( const char *pRelativeName )
@@ -1678,9 +1793,9 @@ unsigned int CZip::EstimateSize( void )
 }
 
 // Add buffer to zip as a file with given name
-void CZip::AddBufferToZip( const char *relativename, void *data, int length, bool bTextMode )
+void CZip::AddBufferToZip( const char *relativename, void *data, int length, bool bTextMode, eCompressionType compressionType )
 {
-	m_ZipFile.AddBufferToZip( relativename, data, length, bTextMode );
+	m_ZipFile.AddBufferToZip( relativename, data, length, bTextMode, compressionType );
 }
 
 void CZip::SaveToBuffer( CUtlBuffer& outbuf )
diff --git a/mp/src/public/zip_utils.h b/mp/src/public/zip_utils.h
index be1cc8dd..2ac20052 100644
--- a/mp/src/public/zip_utils.h
+++ b/mp/src/public/zip_utils.h
@@ -1,6 +1,6 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
 //
-// Purpose: 
+// Purpose:
 //
 //=============================================================================//
 
@@ -18,15 +18,22 @@ class CUtlBuffer;
 abstract_class IZip
 {
 public:
+	enum eCompressionType
+	{
+		// Type of compression used for this file in the zip
+		eCompressionType_Unknown = -1,
+		eCompressionType_None    = 0,
+		eCompressionType_LZMA    = 14
+	};
 	virtual void			Reset() = 0;
 
-	// Add a single file to a zip - maintains the zip's previous alignment state
-	virtual void			AddFileToZip		( const char *relativename, const char *fullpath ) = 0;
+	// Add a single file to a zip - maintains the zip's previous alignment state.
+	virtual void			AddFileToZip		( const char *relativename, const char *fullpath, eCompressionType compressionType = eCompressionType_None ) = 0;
 
 	// Whether a file is contained in a zip - maintains alignment
 	virtual bool			FileExistsInZip		( const char *pRelativeName ) = 0;
 
-	// Reads a file from the zip - maintains alignement
+	// Reads a file from the zip - maintains alignement.
 	virtual bool			ReadFileFromZip		( const char *pRelativeName, bool bTextMode, CUtlBuffer &buf ) = 0;
 	virtual bool			ReadFileFromZip		( HANDLE hFile, const char *pRelativeName, bool bTextMode, CUtlBuffer &buf ) = 0;
 
@@ -43,18 +50,18 @@ public:
 	virtual unsigned int	EstimateSize		( void ) = 0;
 
 	// Add buffer to zip as a file with given name - uses current alignment size, default 0 (no alignment)
-	virtual void			AddBufferToZip		( const char *relativename, void *data, int length, bool bTextMode ) = 0;
+	virtual void			AddBufferToZip		( const char *relativename, void *data, int length, bool bTextMode, eCompressionType compressionType = eCompressionType_None ) = 0;
 
-	// Writes out zip file to a buffer - uses current alignment size 
+	// Writes out zip file to a buffer - uses current alignment size
 	// (set by file's previous alignment, or a call to ForceAlignment)
 	virtual void			SaveToBuffer		( CUtlBuffer& outbuf ) = 0;
 
-	// Writes out zip file to a filestream - uses current alignment size 
+	// Writes out zip file to a filestream - uses current alignment size
 	// (set by file's previous alignment, or a call to ForceAlignment)
 	virtual void			SaveToDisk			( FILE *fout ) = 0;
 	virtual void			SaveToDisk			( HANDLE hFileOut ) = 0;
-	
-	// Reads a zip file from a buffer into memory - sets current alignment size to 
+
+	// Reads a zip file from a buffer into memory - sets current alignment size to
 	// the file's alignment size, unless overridden by a ForceAlignment call)
 	virtual void			ParseFromBuffer		( void *buffer, int bufferlength ) = 0;