fixed windows builds

engine/baseentity.cpp

@@ -1,9 +1,7 @@
 #include "baseentity.h"
 #include "tier0/platform.h"
 #include "tier1/utlstring.h"
-
+#include <winscard.h>
-CUtlVector<CBaseEntity*> g_entities;
-CUtlVector<CEntityRegistry*> g_RegisteredEntities;
 
 CBaseEntity::CBaseEntity()
 {
@@ -43,21 +41,42 @@ void CBaseEntity::SetScale( vec3 scale )
 	V_memcpy(m_scale, scale, sizeof(vec3));
 }
 
+class CEntityManager: public IEntityManager
+{
+public:
+	virtual void Init() override {}
+	virtual void Frame() override {}
+	virtual void Deinit() override {}
+};
 
-CEntityRegistry::CEntityRegistry(const char *szName, const char *szClass, EntityRegistryFn pfn) : 
+DECLARE_ENGINE_INTERFACE(EntityManager, CEntityManager);
+
+CEntityRegistryObject::CEntityRegistryObject(const char *szName, const char *szClass, EntityRegistryFn pfn) : 
 	m_szName(szName), m_szClass(szClass), m_pfn(pfn), m_pClientfn(0)
 {
-	g_RegisteredEntities.AppendTail(this);
+	for (auto &entity: EntityManager()->m_RegisteredEntities)
+	{
+		if (!V_strcmp(entity->m_szClass, szClass))
+		{
+			entity->m_szName = szName;
+			entity->m_pfn = pfn;
+			return;
+                }
+        }
+	EntityManager()->m_RegisteredEntities.AppendTail(this);
 };
 
 
 C_EntityRegistry::C_EntityRegistry( const char *szName, ClientEntityRegistryFn pfn )
 {
-	for (auto &entity: g_RegisteredEntities)
+	for (auto &entity: EntityManager()->m_RegisteredEntities)
 	{
 		if (!V_strcmp(entity->m_szClass, szName))
 		{
                         entity->m_pClientfn = pfn;
+			return;
                 }
         }
+	CEntityRegistryObject *pObject = new CEntityRegistryObject(0, szName, 0);
+	pObject->m_pClientfn = pfn;
 }

engine/brush.cpp

@@ -83,7 +83,7 @@ void C_BrushEntity::Spawn()
 	CBrushEntity* pBrushEntity = (CBrushEntity*)pEntity;
 	uint32_t numVertices = pBrushEntity->m_mesh.GetSize();
 	
-	vertexBuffer = IRenderer::CreateVertexBuffer(numVertices*60);
+	vertexBuffer = Renderer()->CreateVertexBuffer(numVertices*60);
 
 	Vertex_t *pTriangles = (Vertex_t*)vertexBuffer->Map();
 	uint32_t i = 0;
@@ -134,7 +134,7 @@ IGraphicsPipeline *g_BrushPipeline;
 ITexture *bricks;
 void CBrushRendering::Init()
 {
-	g_BrushPipeline = IRenderer::CreateGraphicsPipeline(
+	g_BrushPipeline = Renderer()->CreateGraphicsPipeline(
 		{
 		{"gfx/mesh_vert.shader", SHADER_TYPE_VERTEX},
 		{"gfx/mesh_frag.shader", SHADER_TYPE_FRAGMENT},
@@ -154,12 +154,12 @@ void CBrushRendering::Init()
 
 void CBrushRendering::Frame( float fDelta )
 {
-	g_BrushPipeline->BindData(0, IRenderer::GetCameraMatrix(), 0);
+	g_BrushPipeline->BindData(0, Renderer()->GetCameraMatrix(), 0);
 	g_BrushPipeline->PushBindings();
 
-	IRenderer::ResetState();
+	Renderer()->ResetState();
-	IRenderer::SetDepthMode(DEPTH_MODE_LESS);
+	Renderer()->SetDepthMode(DEPTH_MODE_LESS);
-	IRenderer::BindPipeline(g_BrushPipeline);
+	Renderer()->BindPipeline(g_BrushPipeline);
 	struct {
 		mat4 i;
 		uint32_t a = ITextureManager::GetTextureID(bricks);
@@ -167,10 +167,10 @@ void CBrushRendering::Frame( float fDelta )
 		uint32_t c = 0;
 	} constants;
 	glm_mat4_identity(constants.i);
-	IRenderer::SetConstants(sizeof(constants), &constants);
+	Renderer()->SetConstants(sizeof(constants), &constants);
 	for (auto &v: g_BrushVertices)
 	{
-		IRenderer::Draw(v, 0);
+		Renderer()->Draw(v, 0);
 	}
 	g_BrushVertices = {};
 };

engine/console.cpp

@@ -3,13 +3,12 @@
 #include "fgui/widget.h"
 #include "fgui/label.h"
 #include "filesystem.h"
+#include "interface.h"
 #include "rendering.h"
 #include "tier1/utlstring.h"
 #include "tier1/utlvector.h"
 #include "stdarg.h"
 
-CUtlVector<ConVar*> g_convars;
-CUtlVector<ConCommand*> g_commands;
 
 enum EConsoleMessageType
 {
@@ -24,14 +23,9 @@ struct ConsoleMessage_t
 	CUtlString szMessage;
 };
 
-uint32_t g_nNumConsoleMessages = 0;
-ConsoleMessage_t g_consoleLog[1024];
-
 void Msg( const char* message )
 {
 	printf(message);
-	g_consoleLog[g_nNumConsoleMessages] = {CONSOLE_MESSAGE_TYPE_MESSAGE, message};
-	g_nNumConsoleMessages = (g_nNumConsoleMessages+1)%1024;
 
 }
 
@@ -45,32 +39,60 @@ void Error( const char* message )
 
 }
 
-void IConsole::Init()
+interface CConsole: public IConsole 
+{
+public:
+	virtual void Init() override;
+	virtual void Frame() override;
+	virtual void Deinit() override;
+
+	// Variables
+	virtual void RegisterVar( ConVar *cvar ) override;
+	virtual void UnRegisterVar( ConVar *cvar ) override;
+	virtual ConVar *FindVar( const char *pName ) override;
+
+	// Commands
+	virtual void RegisterCommand( ConCommand *cvar ) override;
+	virtual void UnRegisterCommand( ConCommand *cvar ) override;
+	virtual ConCommand *FindCommand( const char *pName ) override;
+
+	// Command buffer 
+	virtual void Execute( void ) override;
+	virtual void ExecuteArguments( CUtlVector<CUtlString> &args ) override;
+	virtual CUtlVector<CUtlVector<CUtlString>> ParseCommandLine( CUtlString psz ) override;
+
+	virtual void AddCommand( const char *psz ) override;
+	virtual void InsertCommand( const char *psz ) override;
+};
+
+DECLARE_ENGINE_INTERFACE(Console, CConsole)
+
+void CConsole::Init()
 {
 }
 
-void IConsole::Frame()
+void CConsole::Frame()
 {
 
 }
 
-void IConsole::Deinit()
+void CConsole::Deinit()
 {
 
 }
 
 
-void IConsole::RegisterVar( ConVar *cvar )
+void CConsole::RegisterVar( ConVar *cvar )
 {
-	g_convars.AppendTail(cvar);
+	m_convars.AppendTail(cvar);
 }
-void IConsole::UnRegisterVar( ConVar *cvar )
+void CConsole::UnRegisterVar( ConVar *cvar )
 {
 
 }
-ConVar *IConsole::FindVar( const char *pName )
+ConVar *CConsole::FindVar( const char *pName )
 {
-	for (auto &var: g_convars)
+	for (auto &var: m_convars)
 	{
 		if (!V_strcmp(var->GetName(), pName))
 			return var;
@@ -78,17 +100,17 @@ ConVar *IConsole::FindVar( const char *pName )
 	return NULL;
 }
 
-void IConsole::RegisterCommand( ConCommand *cvar )
+void CConsole::RegisterCommand( ConCommand *cvar )
 {
-	g_commands.AppendTail(cvar);
+	m_commands.AppendTail(cvar);
 }
-void IConsole::UnRegisterCommand( ConCommand *cvar )
+void CConsole::UnRegisterCommand( ConCommand *cvar )
 {
 
 }
-ConCommand *IConsole::FindCommand( const char *pName )
+ConCommand *CConsole::FindCommand( const char *pName )
 {
-	for (auto &var: g_commands)
+	for (auto &var: m_commands)
 	{
 		if (!V_strcmp(var->GetName(), pName))
 			return var;
@@ -98,14 +120,14 @@ ConCommand *IConsole::FindCommand( const char *pName )
 CUtlString g_commandBuffer;
 
 //-----------------------------------------------------------------------------
-// Executes arguments from IConsole::Execute 
+// Executes arguments from CConsole::Execute 
 //-----------------------------------------------------------------------------
-void IConsole::Execute2( CUtlVector<CUtlString> &args )
+void CConsole::ExecuteArguments( CUtlVector<CUtlString> &args )
 {
 	if (args.GetSize()<1)
 		return;
 
-	ConCommand *cmd = IConsole::FindCommand(args[0]);
+	ConCommand *cmd = CConsole::FindCommand(args[0]);
 	if (!cmd)
 	{
 		V_printf("%s not found\n", args[0].GetString());
@@ -119,20 +141,20 @@ void IConsole::Execute2( CUtlVector<CUtlString> &args )
 	(cmd->GetCallback())(args.GetSize(), strbuffer);
 }
 
-void IConsole::Execute( void )
+void CConsole::Execute( void )
 {
 	CUtlVector<CUtlVector<CUtlString>> commands = ParseCommandLine(g_commandBuffer);
 	g_commandBuffer = 0;
 	for (auto &command: commands)
 	{
-		IConsole::Execute2(command);
+		ExecuteArguments(command);
 	}
 }
 
 //-----------------------------------------------------------------------------
 // Parses command buffer. 
 //-----------------------------------------------------------------------------
-CUtlVector<CUtlVector<CUtlString>> IConsole::ParseCommandLine( CUtlString psz )
+CUtlVector<CUtlVector<CUtlString>> CConsole::ParseCommandLine( CUtlString psz )
 {	
 	CUtlVector<CUtlString> arguments;
 	CUtlVector<CUtlVector<CUtlString>> commands;
@@ -182,12 +204,12 @@ CUtlVector<CUtlVector<CUtlString>> IConsole::ParseCommandLine( CUtlString psz )
 	return commands;
 }
 
-void IConsole::AddCommand( const char *psz )
+void CConsole::AddCommand( const char *psz )
 {
 	g_commandBuffer.AppendTail(psz);
 }
 
-void IConsole::InsertCommand( const char *psz )
+void CConsole::InsertCommand( const char *psz )
 {
 	g_commandBuffer.AppendHead(psz);
 };
@@ -210,7 +232,7 @@ ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags,
 	m_szValue = pDefaultValue;
 	m_fValue = V_atof(pDefaultValue);
 	m_nValue = V_atoi(pDefaultValue);
-	IConsole::RegisterVar(this);
+	Console()->RegisterVar(this);
 }
 
 bool ConVar::IsFlagSet( int flag )
@@ -287,7 +309,7 @@ ConCommand::ConCommand(const char *pName, ConCommandFn callback,
 	m_szName = pName;
 	m_callback = callback;
 	m_flags = flags;
-	IConsole::RegisterCommand(this);
+	Console()->RegisterCommand(this);
 };
 const char *ConCommand::GetHelpText( void )
 {
@@ -309,15 +331,15 @@ void IConsole_Exec( int argc, char **argv)
 	if (argc != 2)
 		return;
 
-	FileHandle_t f = IFileSystem::Open(argv[1], IFILE_READ);
+	FileHandle_t f = FileSystem()->Open(argv[1], IFILE_READ);
 	if (!f)
 		return;
-	CUtlBuffer<char> b(IFileSystem::Size(f)+1);
+	CUtlBuffer<char> b(FileSystem()->Size(f)+1);
-	IFileSystem::Read(f, b, b.GetSize());
+	FileSystem()->Read(f, b, b.GetSize());
-	b[IFileSystem::Size(f)] = 0;
+	b[FileSystem()->Size(f)] = 0;
-	IConsole::AddCommand(b);
+	Console()->AddCommand(b);
-	IConsole::AddCommand(";");
+	Console()->AddCommand(";");
-	IConsole::Execute();
+	Console()->Execute();
 }
 
 ConCommand IConsole_ExecCmd("exec", IConsole_Exec);
@@ -341,11 +363,13 @@ CConsoleGUI::CConsoleGUI()
 	m_pBackground = new CFGUI_Rect();
 	m_pBackground->SetBoxColor(0.13, 0.13, 0.13, 1);
 	m_pBackground->SetSize(200, 200);
+	m_pBackground->SetPosition(0, 0);
 	m_pBackground->SetParent(this);
 
 	m_pLog = new CFGUI_Label();
 	m_pLog->SetFont("fonts/IBMPlexMono-Regular");
 	m_pLog->SetLabel("CONSOLE");
+	m_pLog->SetPosition(0, 0);
 	m_pLog->SetGlyphSize(24);
 	m_pLog->SetParent(this);
 };

engine/engine.cpp

@@ -93,19 +93,14 @@ void IEngine::Init()
 	signal(SIGTERM, IEngine_Signal);
 	#endif
 
-#ifdef STEAM_ENABLED 
+#ifdef STEAM_ENABLED
-	if(SteamAPI_RestartAppIfNecessary(480))
-	{
-		Plat_Exit(0);
-	}
 	if (!SteamAPI_Init())
 	{
-		Plat_FatalErrorFunc("failed to init steam\n");
+		Plat_FatalErrorFunc("Failed to init Steam\n");
 	}
-	
 #endif
 
-	IFileSystem::InitFilesystem();
+	FileSystem()->InitFilesystem();
 	px = px_init();
 
 	if (!ICommandLine::CheckParam("-dedicated"))
@@ -123,7 +118,6 @@ void IEngine::Init()
 
 	INetworking::Init();
 
-
 	// load game
 	IServer::LoadGame("funnygame");
 
@@ -132,12 +126,13 @@ void IEngine::Init()
 		IVideo::CreatePipelines();
 
 	// execute default config
-	IConsole::AddCommand("exec default.cfg;");
+	Console()->AddCommand("exec default.cfg;");
-	IConsole::Execute();
+	Console()->Execute();
 		
 	MainMenu()->Init();
 	
 	IConsoleUI::Init();
+	
 
 };
 //-----------------------------------------------------------------------------
@@ -145,11 +140,7 @@ void IEngine::Init()
 //-----------------------------------------------------------------------------
 void IEngine::Frame(float fDelta)
 {
-#ifdef STEAM_ENABLED
-        SteamAPI_RunCallbacks();
-#endif
 	IServer::Think(fDelta);
-	INetworking::Frame();
 	if (!ICommandLine::CheckParam("-dedicated"))
 	{
 		MainMenu()->Frame();
@@ -175,13 +166,13 @@ uint64_t g_lastServerID = 1;
 uint64_t g_lastPredictedID = 1;
 CBaseEntity *IIEngine::SpawnEntity( const char *szName )
 {
-	for (auto &entity: g_RegisteredEntities)
+	for (auto &entity: EntityManager()->m_RegisteredEntities)
 	{
 		if (!V_strcmp(entity->m_szName, szName))
 		{
 			CBaseEntity *pEnt = entity->m_pfn();
 			pEnt->m_id = g_lastPredictedID+=1;
-			g_entities.AppendTail(pEnt);
+			EntityManager()->m_entities.AppendTail(pEnt);
 			if (ICommandLine::CheckParam("-dedicated"))
 				return pEnt;
 			if (entity->m_pClientfn)
@@ -215,14 +206,14 @@ void IIEngine::DestroyEntity( CBaseEntity *pEntity )
 	uint32_t i = 0;
 	if (pEntity == NULL)
 		return;
-	for (auto &entity: g_entities)
+	for (auto &entity: EntityManager()->m_entities)
 	{
 		if (pEntity == entity)
 		{
 			pEntity->Destroy();
 			if (pEntity->pClientEntity)
 				pEntity->pClientEntity->Destroy();
-			g_entities.RemoveAt(i);
+			EntityManager()->m_entities.RemoveAt(i);
 			return;
 		}
 		i++;

engine/filesystem.cpp

@@ -1,3 +1,4 @@
+#include "interface.h"
 #include "tier0/platform.h"
 #include "tier1/commandline.h"
 #include "filesystem.h"
@@ -37,18 +38,37 @@ CUtlString fs_basedir;
 CUtlString fs_gamedir;
 CUtlSelfReferencingVector<FileDirectory_t> fs_directories;
 
-class CFileSystem: public IFileSystem
+interface CFileSystem: public IFileSystem
 {
 public:
+	virtual void Init() override {}
+	virtual void Frame() override {}
+	virtual void Deinit() override {}
+
+	virtual void InitFilesystem( void ) override;
+	virtual void AddGameDirectory( const char *psz ) override;
+	virtual bool LoadPackFile( const char *szFilename ) override;
+	virtual void CreatePath( const char *szPath ) override;
+	virtual FileHandle_t Open( const char *szFilename, EFileOptions options ) override;
+	virtual void Close( FileHandle_t file ) override;
+	virtual size_t Size( FileHandle_t file ) override;
+	virtual size_t Read( FileHandle_t file, void *pOutput, size_t nSize) override;
+	virtual size_t ReadLine( FileHandle_t file, void *pOutput, size_t nSize) override;
+	virtual size_t Write( FileHandle_t file, void *pInput, size_t nSize) override;
+	virtual size_t Seek( FileHandle_t file, size_t nSize) override;
+	virtual size_t Tell( FileHandle_t file, size_t nSize) override;
+	virtual size_t fprintf( FileHandle_t file, const char *szFormat, ...) override;
+	
 	static void AddDirectory( const char *psz );
 	static void AddFile( const char *psz );
 };
 
+DECLARE_ENGINE_INTERFACE(FileSystem, CFileSystem);
 
 //-----------------------------------------------------------------------------
 //
 //-----------------------------------------------------------------------------
-void IFileSystem::InitFilesystem()
+void CFileSystem::InitFilesystem()
 {
 #ifdef STATIC_BUILD
 	fs_basedir = ICommandLine::ParamValue("-basedir");
@@ -75,14 +95,14 @@ void CFileSystem::AddFile( const char *psz )
 	CUtlString extension = Plat_GetExtension(psz);
 	if (extension=="pak")
 	{
-		IFileSystem::LoadPackFile(psz);
+		FileSystem()->LoadPackFile(psz);
 	};
 }
 
 //-----------------------------------------------------------------------------
 // Adds directory which can contain pack files
 //-----------------------------------------------------------------------------
-void IFileSystem::AddGameDirectory( const char *psz )
+void CFileSystem::AddGameDirectory( const char *psz )
 {
 	FileDirectory_t dir = {};
 	dir.path = psz;
@@ -99,7 +119,7 @@ void IFileSystem::AddGameDirectory( const char *psz )
 //-----------------------------------------------------------------------------
 //
 //-----------------------------------------------------------------------------
-bool IFileSystem::LoadPackFile( const char *szFilename )
+bool CFileSystem::LoadPackFile( const char *szFilename )
 {
 	Pack_t pack = {};
 	PackHeader_t header = {};
@@ -142,7 +162,7 @@ bool IFileSystem::LoadPackFile( const char *szFilename )
 //-----------------------------------------------------------------------------
 // Creates path
 //-----------------------------------------------------------------------------
-void IFileSystem::CreatePath( const char *szPath )
+void CFileSystem::CreatePath( const char *szPath )
 {
 
 }
@@ -151,7 +171,7 @@ void IFileSystem::CreatePath( const char *szPath )
 // Opens file
 // If it is located in a pack then it can only be read
 //-----------------------------------------------------------------------------
-FileHandle_t IFileSystem::Open( const char *szFilename, EFileOptions options )
+FileHandle_t CFileSystem::Open( const char *szFilename, EFileOptions options )
 {
 	if (options == IFILE_READ)
 	{
@@ -198,7 +218,7 @@ FileHandle_t IFileSystem::Open( const char *szFilename, EFileOptions options )
 //-----------------------------------------------------------------------------
 // Closes file
 //-----------------------------------------------------------------------------
-void IFileSystem::Close( FileHandle_t file )
+void CFileSystem::Close( FileHandle_t file )
 {
 	/* close only fs files */
 	if (file->file)
@@ -212,7 +232,7 @@ void IFileSystem::Close( FileHandle_t file )
 //-----------------------------------------------------------------------------
 //
 //-----------------------------------------------------------------------------
-size_t IFileSystem::Size( FileHandle_t file )
+size_t CFileSystem::Size( FileHandle_t file )
 {
 	return file->nSize;
 }
@@ -220,7 +240,7 @@ size_t IFileSystem::Size( FileHandle_t file )
 //-----------------------------------------------------------------------------
 // Reads nSize bytes of file
 //-----------------------------------------------------------------------------
-size_t IFileSystem::Read( FileHandle_t file, void *pOutput, size_t nSize)
+size_t CFileSystem::Read( FileHandle_t file, void *pOutput, size_t nSize)
 {
 	if (file->file)
 	{
@@ -238,7 +258,7 @@ size_t IFileSystem::Read( FileHandle_t file, void *pOutput, size_t nSize)
 //-----------------------------------------------------------------------------
 //
 //-----------------------------------------------------------------------------
-size_t IFileSystem::ReadLine( FileHandle_t file, void *pOutput, size_t nSize)
+size_t CFileSystem::ReadLine( FileHandle_t file, void *pOutput, size_t nSize)
 {
 
 }
@@ -246,7 +266,23 @@ size_t IFileSystem::ReadLine( FileHandle_t file, void *pOutput, size_t nSize)
 //-----------------------------------------------------------------------------
 //
 //-----------------------------------------------------------------------------
-size_t IFileSystem::Write( FileHandle_t file, void *pInput, size_t nSize)
+size_t CFileSystem::Write( FileHandle_t file, void *pInput, size_t nSize)
 {
 
 }
+
+size_t CFileSystem::Seek( FileHandle_t file, size_t nSize)
+{
+
+}
+
+size_t CFileSystem::Tell( FileHandle_t file, size_t nSize)
+{
+
+}
+
+size_t CFileSystem::fprintf( FileHandle_t file, const char *szFormat, ...)
+{
+
+}
+

engine/gamemode.cpp

@@ -9,7 +9,6 @@
 
 CGameMode *pCurrentMode = NULL;
 CUtlString szCurrentModeName;
-CUtlVector<CGameModeRegistry*> g_RegisteredGameModes;
 
 //-----------------------------------------------------------------------------
 // Round begin handler
@@ -71,7 +70,7 @@ public:
 	virtual void RestartCurrentGameMode( void ) override;
 };
 
-DECLARE_INTERFACE(GameModeManager, CGameModeManager);
+DECLARE_ENGINE_INTERFACE(GameModeManager, CGameModeManager);
 
 //-----------------------------------------------------------------------------
 //
@@ -106,7 +105,7 @@ void CGameModeManager::StartGameMode( const char *szName )
 		pCurrentMode->RoundEnd();
 		delete pCurrentMode;
 	}
-	for (auto &mode: g_RegisteredGameModes)
+	for (auto &mode: m_RegisteredGameModes)
 	{
 		if (!V_strcmp(mode->m_szName, szName))
 		{
@@ -160,7 +159,7 @@ void CGameModeManager::RestartCurrentGameMode( void )
 CGameModeRegistry::CGameModeRegistry(const char *szName, GameModeRegistryFn pfn) : 
 	m_szName(szName), m_pfn(pfn)
 {
-	g_RegisteredGameModes.AppendTail(this);
+	GameModeManager()->m_RegisteredGameModes.AppendTail(this);
 };
 
 

engine/input.cpp

@@ -177,7 +177,7 @@ void IInput::KeyEvent( EInputKey key, EKeyEventType event )
 	
 	if (event == KEY_EVENT_TYPE_DOWN && key == KEY_F11)
 	{
-		IConsole::AddCommand("exit;");
+		Console()->AddCommand("exit;");
 		return;
 	}
 
@@ -185,12 +185,12 @@ void IInput::KeyEvent( EInputKey key, EKeyEventType event )
 	if (g_inputModeStack[g_inputModeStack.GetSize()-1] == INPUT_MODE_GAME)
 	{
 		if (event == KEY_EVENT_TYPE_DOWN) {
-			IConsole::AddCommand(g_bindings[key]);
+			Console()->AddCommand(g_bindings[key]);
-			IConsole::AddCommand(";");
+			Console()->AddCommand(";");
 		}
 		if (event == KEY_EVENT_TYPE_UP)
 		{
-			auto binding = IConsole::ParseCommandLine(g_bindings[key]);
+			auto binding = Console()->ParseCommandLine(g_bindings[key]);
 			if (binding.GetSize()==0)
 				return;
 			if (binding[0].GetSize() == 0)
@@ -199,8 +199,8 @@ void IInput::KeyEvent( EInputKey key, EKeyEventType event )
 			{
 				CUtlString command = binding[0][0];
 				command.GetString()[0] = '-';
-				IConsole::AddCommand(command);
+				Console()->AddCommand(command);
-				IConsole::AddCommand(";");
+				Console()->AddCommand(";");
 			}
 		}
 	}

engine/level.cpp

@@ -3,6 +3,7 @@
 #include "brush.h"
 #include "engine.h"
 #include "filesystem.h"
+#include "interface.h"
 #include "tier1/utlbuffer.h"
 #include "tier1/utlstring.h"
 
@@ -18,15 +19,27 @@ struct EntityHeader_t
 	uint32_t nProperties;
 };
 
+interface CLevelManager: public ILevelManager 
+{
+public:
+	virtual void Init() override {}
+	virtual void Frame() override {}
+	virtual void Deinit() override {}
+
+	virtual void LoadLevel( const char *szLevelName ) override;
+};
+
+DECLARE_ENGINE_INTERFACE(LevelManager, CLevelManager);
+
 //-----------------------------------------------------------------------------
 // Loads level from file, deserializes it and creates entities.
 //-----------------------------------------------------------------------------
-void ILevel::LoadLevel( const char *szLevelName )
+void CLevelManager::LoadLevel( const char *szLevelName )
 {
-	FileHandle_t handle = IFileSystem::Open(CUtlString("%s.fmap",szLevelName), IFILE_READ);
+	FileHandle_t handle = FileSystem()->Open(CUtlString("%s.fmap",szLevelName), IFILE_READ);
-	CUtlBuffer<char> mapdata(IFileSystem::Size(handle));
+	CUtlBuffer<char> mapdata(FileSystem()->Size(handle));
-	IFileSystem::Read(handle, mapdata.GetMemory(), mapdata.GetSize());
+	FileSystem()->Read(handle, mapdata.GetMemory(), mapdata.GetSize());
-	IFileSystem::Close(handle);
+	FileSystem()->Close(handle);
 	MapHeader_t* pHeader = (MapHeader_t*)mapdata.GetMemory();
 	char *pData = (char*)mapdata.GetMemory()+sizeof(MapHeader_t);
 	for ( uint32_t i = 0; i < pHeader->nEntities; i++ )

engine/mesh.cpp

@@ -95,7 +95,7 @@ class CMeshRendering: public IMeshRendering
 	
 void CMeshRendering::Init()
 {
-	g_MeshPipeline = IRenderer::CreateGraphicsPipeline(
+	g_MeshPipeline = Renderer()->CreateGraphicsPipeline(
 		{
 		{"gfx/mesh_vert.shader", SHADER_TYPE_VERTEX},
 		{"gfx/mesh_frag.shader", SHADER_TYPE_FRAGMENT},
@@ -115,12 +115,12 @@ void CMeshRendering::Init()
 
 void CMeshRendering::Frame( float fDelta )
 {
-	g_MeshPipeline->BindData(0, IRenderer::GetCameraMatrix(), 0);
+	g_MeshPipeline->BindData(0, Renderer()->GetCameraMatrix(), 0);
 	g_MeshPipeline->PushBindings();
 
-	IRenderer::ResetState();
+	Renderer()->ResetState();
-	IRenderer::SetDepthMode(DEPTH_MODE_LESS);
+	Renderer()->SetDepthMode(DEPTH_MODE_LESS);
-	IRenderer::BindPipeline(g_MeshPipeline);
+	Renderer()->BindPipeline(g_MeshPipeline);
 	for (auto &v: g_meshes)
 	{
 		CMeshInstance *pMesh = (CMeshInstance*)v;
@@ -134,8 +134,8 @@ void CMeshRendering::Frame( float fDelta )
 		constants.i[3][0] = pMesh->m_position[0];
 		constants.i[3][1] = pMesh->m_position[1];
 		constants.i[3][2] = pMesh->m_position[2];
-		IRenderer::SetConstants(sizeof(constants), &constants);
+		Renderer()->SetConstants(sizeof(constants), &constants);
-		IRenderer::Draw(pMesh->m_pVertexBuffer, pMesh->m_pIndexBuffer);
+		Renderer()->Draw(pMesh->m_pVertexBuffer, pMesh->m_pIndexBuffer);
 	}
 	g_meshes = {};
 }

engine/ml_video.cpp

@@ -452,13 +452,13 @@ IGraphicsPipeline *IRenderer::CreateGraphicsPipeline(
 	for ( auto &shader: shaders )
 	{
 		MLShader_t mlshader = {};
-		FileHandle_t f = IFileSystem::Open(shader.szPath, IFILE_READ);
+		FileHandle_t f = FileSystem()->Open(shader.szPath, IFILE_READ);
 		if (!f)
 			Plat_FatalErrorFunc("Failed to open shader %s\n", shader.szPath.GetString());
-		CUtlBuffer<uint8_t> buffer(IFileSystem::Size(f)+1);
+		CUtlBuffer<uint8_t> buffer(FileSystem()->Size(f)+1);
-		IFileSystem::Read(f, buffer.GetMemory(), buffer.GetSize());
+		FileSystem()->Read(f, buffer.GetMemory(), buffer.GetSize());
-		buffer[IFileSystem::Size(f)] = 0;
+		buffer[FileSystem()->Size(f)] = 0;
-		IFileSystem::Close(f);
+		FileSystem()->Close(f);
 		NS::String *szSourceCode = NS::String::string((const char*)buffer.GetMemory(), NS::StringEncoding::UTF8StringEncoding);
 		MTL::CompileOptions *options = NULL;
 		mlshader.library = g_mlDevice->newLibrary(szSourceCode, options, &error);
@@ -539,12 +539,12 @@ ITexture *ITextureManager::LoadTexture( const char *szName )
 		if (!V_strcmp(texture->szName, szName))
 			return texture;
 	};
-	FileHandle_t file = IFileSystem::Open(szName, IFILE_READ);
+	FileHandle_t file = FileSystem()->Open(szName, IFILE_READ);
 	if (!file)
 		Plat_FatalErrorFunc("Failed to load %s\n", szName);
 
-	CUtlBuffer<stbi_uc> buffer(IFileSystem::Size(file));
+	CUtlBuffer<stbi_uc> buffer(FileSystem()->Size(file));
-	IFileSystem::Read(file, buffer.GetMemory(), buffer.GetSize());
+	FileSystem()->Read(file, buffer.GetMemory(), buffer.GetSize());
 	int nImageX;
 	int nImageY;
 	int nImageChannels;
@@ -579,23 +579,23 @@ void IMetal::Init()
 static MTL::RenderPipelineState* s_fullScreenDraw;
 void IMetal::CreatePipelines()
 {
-	for (auto &step: g_StepPrepass)
+	for (auto &step: Renderer()->m_StepPrepass)
 		step.pPipeline->Init();
-	for (auto &step: g_StepMeshRendering)
+	for (auto &step: Renderer()->m_StepMeshRendering)
 		step.pPipeline->Init();
-	for (auto &step: g_StepShading)
+	for (auto &step: Renderer()->m_StepShading)
 		step.pPipeline->Init();
-	for (auto &step: g_StepPostProcessing)
+	for (auto &step: Renderer()->m_StepPostProcessing)
 		step.pPipeline->Init();
-	for (auto &step: g_StepUI)
+	for (auto &step: Renderer()->m_StepUI)
 		step.pPipeline->Init();
 
 	NS::Error *error = 0;
-	FileHandle_t f = IFileSystem::Open("gfx/ml_quad.metal", IFILE_READ);
+	FileHandle_t f = FileSystem()->Open("gfx/ml_quad.metal", IFILE_READ);
-	CUtlBuffer<uint8_t> buffer(IFileSystem::Size(f)+1);
+	CUtlBuffer<uint8_t> buffer(FileSystem()->Size(f)+1);
-	IFileSystem::Read(f, buffer.GetMemory(), buffer.GetSize());
+	FileSystem()->Read(f, buffer.GetMemory(), buffer.GetSize());
-	buffer[IFileSystem::Size(f)] = 0;
+	buffer[FileSystem()->Size(f)] = 0;
-	IFileSystem::Close(f);
+	FileSystem()->Close(f);
 	NS::String *szSourceCode = NS::String::string((const char*)buffer.GetMemory(), NS::StringEncoding::UTF8StringEncoding);
 	MTL::CompileOptions *options = NULL;
 	MTL::Library *library = g_mlDevice->newLibrary(szSourceCode, options, &error);

engine/networking.cpp

@@ -69,7 +69,7 @@ static CClientNetworkingCallbacks *net_pClientCallbacks;
 
 void INetworking::Init()
 {
-	
+/*	
 	Net_Init();
 
 #ifdef STEAMNETWORKINGSOCKETS_OPENSOURCE
@@ -113,6 +113,7 @@ void INetworking::Init()
 		net_listenSocket = SteamGameServerNetworkingSockets()->CreateListenSocketP2P(0, 0, NULL);
 		net_bIsServer = true;
 	}
+	*/
 }
 void INetworking::Deinit()
 {

engine/rendering.cpp

@@ -1,11 +1,5 @@
 #include "rendering.h"
 
-CUtlVector<RenderingStep_t> g_StepPrepass;
-CUtlVector<RenderingStep_t> g_StepMeshRendering;
-CUtlVector<RenderingStep_t> g_StepShading;
-CUtlVector<RenderingStep_t> g_StepPostProcessing;
-CUtlVector<RenderingStep_t> g_StepUI;
-
 CRenderingStep::CRenderingStep()
 {
 
@@ -18,26 +12,26 @@ CRenderingStep::CRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
 	
 CPrepassRenderingStep::CPrepassRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
 {
-	g_StepPrepass.AppendTail({pfn(), szStepName});
+	Renderer()->m_StepPrepass.AppendTail({pfn(), szStepName});
 }
 
 CMeshRenderingStep::CMeshRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
 {
-	g_StepMeshRendering.AppendTail({pfn(), szStepName});
+	Renderer()->m_StepMeshRendering.AppendTail({pfn(), szStepName});
 }
 
 CShadingRenderingStep::CShadingRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
 {
-	g_StepShading.AppendTail({pfn(), szStepName});
+	Renderer()->m_StepShading.AppendTail({pfn(), szStepName});
 }
 
 CPostProcessingRenderingStep::CPostProcessingRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
 {
-	g_StepPostProcessing.AppendTail({pfn(), szStepName});
+	Renderer()->m_StepPostProcessing.AppendTail({pfn(), szStepName});
 }
 
 CUIRenderingStep::CUIRenderingStep(const char *szStepName, CreateRenderStepFn pfn)
 {
-	g_StepUI.AppendTail({pfn(), szStepName});
+	Renderer()->m_StepUI.AppendTail({pfn(), szStepName});
 }
 

engine/server.cpp

@@ -55,17 +55,16 @@ void IServer::Think( float fDelta )
 	while(g_fAccumulator>=fTickrate)
 	{
 		IInput::Frame();
-		IConsole::Execute();
+		Console()->Execute();
 		g_fAccumulator-=fTickrate;
-		for (auto &entity: g_entities)
+		for (auto &entity: EntityManager()->m_entities)
 		{
 			entity->Think(fTickrate);
-			entity->SendToServer();
 		}
 		px_frame(px, fTickrate);
 		INetworking::Frame();
 	}
-	for (auto &entity: g_entities)
+	for (auto &entity: EntityManager()->m_entities)
 	{
 		if (entity->pClientEntity)
 			entity->pClientEntity->Think(fDelta);

engine/vk_video.cpp

@@ -1,3 +1,4 @@
+#include "interface.h"
 #include "math3d.h"
 #include "filesystem.h"
 #include "rendering.h"
@@ -232,26 +233,26 @@ void IVulkan::Init()
 	samplerInfo.maxLod = 0.0f;
 	vkCreateSampler(g_vkDevice, &samplerInfo, nullptr, &g_invalidTextureSampler);
 	
-	g_cameraProperties = IRenderer::CreateUniformBuffer(sizeof(CameraProjection));
+	g_cameraProperties = Renderer()->CreateUniformBuffer(sizeof(CameraProjection));
 	g_cameraDataMap = (CameraProjection*)g_cameraProperties->Map();
 
-	g_meshDepth = IRenderer::CreateImage(IMAGE_FORMAT_DEPTH, IMAGE_USAGE_DEPTH_ATTACHMENT, 1280, 720, 1);
+	g_meshDepth = Renderer()->CreateImage(IMAGE_FORMAT_DEPTH, IMAGE_USAGE_DEPTH_ATTACHMENT, 1280, 720, 1);
-	g_meshDepthMSAA = IRenderer::CreateImage(IMAGE_FORMAT_DEPTH, IMAGE_USAGE_DEPTH_ATTACHMENT, 1280, 720, 4);
+	g_meshDepthMSAA = Renderer()->CreateImage(IMAGE_FORMAT_DEPTH, IMAGE_USAGE_DEPTH_ATTACHMENT, 1280, 720, 4);
-	g_meshColor = IRenderer::CreateImage(IMAGE_FORMAT_R8G8B8A8, IMAGE_USAGE_COLOR_ATTACHMENT, 1280, 720, 1);
+	g_meshColor = Renderer()->CreateImage(IMAGE_FORMAT_R8G8B8A8, IMAGE_USAGE_COLOR_ATTACHMENT, 1280, 720, 1);
-	g_meshColorMSAA = IRenderer::CreateImage(IMAGE_FORMAT_R8G8B8A8, IMAGE_USAGE_COLOR_ATTACHMENT, 1280, 720, 4);
+	g_meshColorMSAA = Renderer()->CreateImage(IMAGE_FORMAT_R8G8B8A8, IMAGE_USAGE_COLOR_ATTACHMENT, 1280, 720, 4);
 	glm_mat4_identity(g_cameraView);
 };
 void IVulkan::CreatePipelines()
 {
-	for (auto &step: g_StepPrepass)
+	for (auto &step: Renderer()->m_StepPrepass)
 		step.pPipeline->Init();
-	for (auto &step: g_StepMeshRendering)
+	for (auto &step: Renderer()->m_StepMeshRendering)
 		step.pPipeline->Init();
-	for (auto &step: g_StepShading)
+	for (auto &step: Renderer()->m_StepShading)
 		step.pPipeline->Init();
-	for (auto &step: g_StepPostProcessing)
+	for (auto &step: Renderer()->m_StepPostProcessing)
 		step.pPipeline->Init();
-	for (auto &step: g_StepUI)
+	for (auto &step: Renderer()->m_StepUI)
 		step.pPipeline->Init();
 }
 
@@ -273,19 +274,19 @@ void IVulkan::Frame()
 
 	if (g_bConfigNotify)
 	{
-		IRenderer::DestroyImage(g_meshDepth);
+		Renderer()->DestroyImage(g_meshDepth);
-		IRenderer::DestroyImage(g_meshDepthMSAA);
+		Renderer()->DestroyImage(g_meshDepthMSAA);
-		IRenderer::DestroyImage(g_meshColor);
+		Renderer()->DestroyImage(g_meshColor);
-		IRenderer::DestroyImage(g_meshColorMSAA);
+		Renderer()->DestroyImage(g_meshColorMSAA);
-		g_meshDepth = IRenderer::CreateImage(IMAGE_FORMAT_DEPTH, IMAGE_USAGE_DEPTH_ATTACHMENT, g_nWindowWidth, g_nWindowHeight, 1);
+		g_meshDepth = Renderer()->CreateImage(IMAGE_FORMAT_DEPTH, IMAGE_USAGE_DEPTH_ATTACHMENT, g_nWindowWidth, g_nWindowHeight, 1);
-		g_meshDepthMSAA = IRenderer::CreateImage(IMAGE_FORMAT_DEPTH, IMAGE_USAGE_DEPTH_ATTACHMENT, g_nWindowWidth, g_nWindowHeight, 4);
+		g_meshDepthMSAA = Renderer()->CreateImage(IMAGE_FORMAT_DEPTH, IMAGE_USAGE_DEPTH_ATTACHMENT, g_nWindowWidth, g_nWindowHeight, 4);
-		g_meshColor = IRenderer::CreateImage(IMAGE_FORMAT_R8G8B8A8, IMAGE_USAGE_COLOR_ATTACHMENT, g_nWindowWidth, g_nWindowHeight, 1);
+		g_meshColor = Renderer()->CreateImage(IMAGE_FORMAT_R8G8B8A8, IMAGE_USAGE_COLOR_ATTACHMENT, g_nWindowWidth, g_nWindowHeight, 1);
-		g_meshColorMSAA = IRenderer::CreateImage(IMAGE_FORMAT_R8G8B8A8, IMAGE_USAGE_COLOR_ATTACHMENT, g_nWindowWidth, g_nWindowHeight, 4);
+		g_meshColorMSAA = Renderer()->CreateImage(IMAGE_FORMAT_R8G8B8A8, IMAGE_USAGE_COLOR_ATTACHMENT, g_nWindowWidth, g_nWindowHeight, 4);
 	}
 
-	for (auto &step: g_StepPrepass)
+	for (auto &step: Renderer()->m_StepPrepass)
 		step.pPipeline->Frame(0);
-	IRenderer::Barrier(BARRIER_STAGE_TOP, BARRIER_STAGE_COLOR_OUTPUT | BARRIER_STAGE_DEPTH_OUTPUT, {}, {
+	Renderer()->Barrier(BARRIER_STAGE_TOP, BARRIER_STAGE_COLOR_OUTPUT | BARRIER_STAGE_DEPTH_OUTPUT, {}, {
 		{
 		.in = BARRIER_MEMORY_PERMISSIONS_NONE,
 		.out = BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE,
@@ -298,7 +299,7 @@ void IVulkan::Frame()
 		},
 		}
 	);
-	IRenderer::Begin(g_nWindowWidth, g_nWindowHeight,
+	Renderer()->Begin(g_nWindowWidth, g_nWindowHeight,
 			{
 			{
 				g_meshColor,
@@ -314,12 +315,12 @@ void IVulkan::Frame()
 				ATTACHMENT_STORE_MODE_STORE,
 			});
 		
-	for (auto &step: g_StepMeshRendering)
+	for (auto &step: Renderer()->m_StepMeshRendering)
 	{
 		step.pPipeline->Frame(0);
 	}
-	IRenderer::End();
+	Renderer()->End();
-	IRenderer::Barrier(BARRIER_STAGE_DEPTH_OUTPUT, BARRIER_STAGE_BOTTOM, {}, {
+	Renderer()->Barrier(BARRIER_STAGE_DEPTH_OUTPUT, BARRIER_STAGE_BOTTOM, {}, {
 		{
 		.in = BARRIER_MEMORY_PERMISSIONS_DEPTH_WRITE,
 		.out = BARRIER_MEMORY_PERMISSIONS_NONE,
@@ -328,7 +329,7 @@ void IVulkan::Frame()
 		}
 	);
 
-	IRenderer::Barrier(BARRIER_STAGE_COLOR_OUTPUT, BARRIER_STAGE_BLIT, {}, {
+	Renderer()->Barrier(BARRIER_STAGE_COLOR_OUTPUT, BARRIER_STAGE_BLIT, {}, {
 		{
 
 		.in = BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE,
@@ -338,7 +339,7 @@ void IVulkan::Frame()
 		{
 		.in = BARRIER_MEMORY_PERMISSIONS_NONE,
 		.out = BARRIER_MEMORY_PERMISSIONS_COPY_WRITE,
-		.pImage = IRenderer::GetOutputImage(),
+		.pImage = Renderer()->GetOutputImage(),
 		}
 		}
 	);
@@ -364,29 +365,29 @@ void IVulkan::Frame()
 	    1, &imageCopyRegion,
 	    VK_FILTER_NEAREST
 	);
-	IRenderer::Barrier(BARRIER_STAGE_BLIT, BARRIER_STAGE_COLOR_OUTPUT, {},
+	Renderer()->Barrier(BARRIER_STAGE_BLIT, BARRIER_STAGE_COLOR_OUTPUT, {},
 		{
 		{
 			
 			.in = BARRIER_MEMORY_PERMISSIONS_COPY_WRITE,
 			.out = BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE | BARRIER_MEMORY_PERMISSIONS_COLOR_READ,
-			.pImage = IRenderer::GetOutputImage(),
+			.pImage = Renderer()->GetOutputImage(),
 		}
 		}
 	);
-	for (auto &step: g_StepShading)
+	for (auto &step: Renderer()->m_StepShading)
 		step.pPipeline->Frame(0);
-	for (auto &step: g_StepPostProcessing)
+	for (auto &step: Renderer()->m_StepPostProcessing)
 		step.pPipeline->Frame(0);
-	for (auto &step: g_StepUI)
+	for (auto &step: Renderer()->m_StepUI)
 		step.pPipeline->Frame(0);	
-	IRenderer::Barrier(BARRIER_STAGE_COLOR_OUTPUT, BARRIER_STAGE_IMAGE_OUPUT, {},
+	Renderer()->Barrier(BARRIER_STAGE_COLOR_OUTPUT, BARRIER_STAGE_IMAGE_OUPUT, {},
 		{
 		{
 			
 			.in = BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE,
 			.out = 0,
-			.pImage = IRenderer::GetOutputImage(),
+			.pImage = Renderer()->GetOutputImage(),
 		}
 		}
 	);
@@ -394,13 +395,13 @@ void IVulkan::Frame()
 
 void vk_shader_t::Create( const char *szPath, VkShaderStageFlagBits shaderStage )
 {
-	FileHandle_t shader = IFileSystem::Open(szPath, IFILE_READ);
+	FileHandle_t shader = FileSystem()->Open(szPath, IFILE_READ);
 	if (!shader)
 		Plat_FatalErrorFunc("Failed to open shader %s\n", szPath);
-	CUtlBuffer<uint8_t> buffer(IFileSystem::Size(shader));
+	CUtlBuffer<uint8_t> buffer(FileSystem()->Size(shader));
-	IFileSystem::Read(shader, buffer.GetMemory(), buffer.GetSize());
+	FileSystem()->Read(shader, buffer.GetMemory(), buffer.GetSize());
 	Create(buffer, shaderStage);
-	IFileSystem::Close(shader);
+	FileSystem()->Close(shader);
 }
 
 void vk_shader_t::Create( CUtlBuffer<uint8_t> &spirv, VkShaderStageFlagBits shaderStage )
@@ -857,12 +858,12 @@ ITexture *ITextureManager::LoadTexture( const char *szName )
 		if (!V_strcmp(texture->szName, szName))
 			return texture;
 	};
-	FileHandle_t file = IFileSystem::Open(szName, IFILE_READ);
+	FileHandle_t file = FileSystem()->Open(szName, IFILE_READ);
 	if (!file)
 		Plat_FatalErrorFunc("Failed to load %s\n", szName);
 
-	CUtlBuffer<stbi_uc> buffer(IFileSystem::Size(file));
+	CUtlBuffer<stbi_uc> buffer(FileSystem()->Size(file));
-	IFileSystem::Read(file, buffer.GetMemory(), buffer.GetSize());
+	FileSystem()->Read(file, buffer.GetMemory(), buffer.GetSize());
 	int nImageX;
 	int nImageY;
 	int nImageChannels;
@@ -872,15 +873,70 @@ ITexture *ITextureManager::LoadTexture( const char *szName )
 	return pTexture;
 };
 
+interface CVkRenderer: public IRenderer 
+{
+public:
+	virtual void Init() override {};
+	virtual void Frame() override {};
+	virtual void Deinit() override {};
 
-IStorageBuffer *IRenderer::CreateStorageBuffer( uint32_t uSize )
+	virtual IStorageBuffer *CreateStorageBuffer( uint32_t uSize ) override;
+	virtual IUniformBuffer *CreateUniformBuffer( uint32_t uSize ) override;
+	virtual IVertexBuffer *CreateVertexBuffer( uint32_t uSize ) override;
+	virtual IIndexBuffer *CreateIndexBuffer( uint32_t uSize ) override;
+	virtual IImage *CreateImage( EImageFormat format, uint32_t usage, uint32_t nWidth, uint32_t nHeight, uint32_t nSamples = 1 ) override;
+
+	virtual void DestroyBuffer( IBuffer *pBuffer ) override;
+	virtual void DestroyImage( IImage *pImage ) override;
+
+	virtual void SetConstants( uint32_t nSize, void *pData ) override;
+	virtual void Barrier( uint32_t stageIn, uint32_t stageOut, CUtlVector<BufferBarrier_t> buffers, CUtlVector<ImageBarrier_t> images ) override;
+	virtual void BindPipeline( IPipeline *pPipeline ) override;
+
+	virtual void Begin( uint32_t nWidth, uint32_t nHeight, CUtlVector<RenderingColorAttachment_t> attachments, RenderingDepthAttachment_t depth ) override;
+	virtual void ResetState() override;
+	virtual void SetDepthMode( EDepthMode mode ) override;
+	virtual void Draw( IVertexBuffer *pVertex, IIndexBuffer *pIndex ) override;
+	virtual void End() override;
+	
+	virtual void Dispatch( uint32_t x, uint32_t y, uint32_t z ) override;
+	virtual void TraceRays( uint32_t x, uint32_t y, uint32_t z ) override;
+
+	virtual IGraphicsPipeline *CreateGraphicsPipeline(
+		CUtlVector<Shader_t> shaders,
+		CUtlVector<ShaderInput_t> inputs,
+		uint32_t nConstantsSize,
+		uint32_t nVertexSize,
+		CUtlVector<VertexAttribute_t> vertexFormat,
+		CUtlVector<EImageFormat> outputFormats,
+		bool bDepth
+	) override;
+	virtual IComputePipeline *CreateComputePipeline(
+		Shader_t szShader,
+		CUtlVector<ShaderInput_t> inputs,
+		uint32_t nConstantsSize
+	) override;
+
+	virtual IRayTracingPipeline *CreateRayTracingPipeline(
+		CUtlVector<Shader_t> shaders,
+		CUtlVector<ShaderInput_t> inputs,
+		uint32_t nConstantsSize
+	) override;
+	
+	virtual IBuffer *GetCameraMatrix() override;
+	virtual IImage *GetOutputImage() override;
+};
+
+DECLARE_ENGINE_INTERFACE(Renderer, CVkRenderer)
+
+IStorageBuffer *CVkRenderer::CreateStorageBuffer( uint32_t uSize )
 {
 	CVkBuffer *pBuffer = new CVkBuffer();
 	pBuffer->m_buffer.Create(uSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
 	return pBuffer;
 }
 
-IUniformBuffer *IRenderer::CreateUniformBuffer( uint32_t uSize )
+IUniformBuffer *CVkRenderer::CreateUniformBuffer( uint32_t uSize )
 {
 	CVkBuffer *pBuffer = new CVkBuffer();
 	pBuffer->m_buffer.Create(uSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
@@ -888,14 +944,14 @@ IUniformBuffer *IRenderer::CreateUniformBuffer( uint32_t uSize )
 }
 
 
-IVertexBuffer *IRenderer::CreateVertexBuffer( uint32_t uSize )
+IVertexBuffer *CVkRenderer::CreateVertexBuffer( uint32_t uSize )
 {
 	CVkBuffer *pBuffer = new CVkBuffer();
 	pBuffer->m_buffer.Create(uSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
 	return pBuffer;
 }
 
-IIndexBuffer *IRenderer::CreateIndexBuffer( uint32_t uSize )
+IIndexBuffer *CVkRenderer::CreateIndexBuffer( uint32_t uSize )
 {
 	CVkBuffer *pBuffer = new CVkBuffer();
 	pBuffer->m_buffer.Create(uSize, VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
@@ -903,7 +959,7 @@ IIndexBuffer *IRenderer::CreateIndexBuffer( uint32_t uSize )
 }
 
 
-IImage *IRenderer::CreateImage( EImageFormat format, uint32_t usage, uint32_t nWidth, uint32_t nHeight, uint32_t nSamples )
+IImage *CVkRenderer::CreateImage( EImageFormat format, uint32_t usage, uint32_t nWidth, uint32_t nHeight, uint32_t nSamples )
 {
 	VkFormat vkformat;
 	VkImageUsageFlags vkusage = 0;
@@ -935,14 +991,14 @@ IImage *IRenderer::CreateImage( EImageFormat format, uint32_t usage, uint32_t nW
 	pImage->m_image.Create(nWidth, nHeight, vkformat, vkusage, samples);
 	return pImage;
 };
-void IRenderer::DestroyBuffer( IBuffer *pBuffer )
+void CVkRenderer::DestroyBuffer( IBuffer *pBuffer )
 {
 	CVkBuffer *pVkBuffer = (CVkBuffer*)pBuffer;
 	if (pVkBuffer)
 		pVkBuffer->m_buffer.Destroy();
 }
 
-void IRenderer::DestroyImage( IImage *pImage )
+void CVkRenderer::DestroyImage( IImage *pImage )
 {
 	CVkImage *pVkImage = (CVkImage*)pImage;
 	if (pVkImage)
@@ -951,7 +1007,7 @@ void IRenderer::DestroyImage( IImage *pImage )
 
 IPipeline *g_pCurrentPipeline;
 
-void IRenderer::SetConstants( uint32_t nSize, void *pData )
+void CVkRenderer::SetConstants( uint32_t nSize, void *pData )
 {
 
 	if (!g_pCurrentPipeline)
@@ -964,7 +1020,7 @@ void IRenderer::SetConstants( uint32_t nSize, void *pData )
 	}
 }
 
-void IRenderer::Barrier( uint32_t stageIn, uint32_t stageOut, CUtlVector<BufferBarrier_t> buffers, CUtlVector<ImageBarrier_t> images )
+void CVkRenderer::Barrier( uint32_t stageIn, uint32_t stageOut, CUtlVector<BufferBarrier_t> buffers, CUtlVector<ImageBarrier_t> images )
 {
 	VkPipelineStageFlags psfSrc = 0;
 	VkPipelineStageFlags psfDst = 0;
@@ -1068,7 +1124,7 @@ void IRenderer::Barrier( uint32_t stageIn, uint32_t stageOut, CUtlVector<BufferB
 	vkCmdPipelineBarrier(g_vkCommandBuffer, psfSrc, psfDst, 0, 0, 0, bmb.GetSize(), bmb.GetData(), imb.GetSize(), imb.GetData());
 }
 
-void IRenderer::BindPipeline( IPipeline *pPipeline )
+void CVkRenderer::BindPipeline( IPipeline *pPipeline )
 {
 	if (!pPipeline)
 		return;
@@ -1083,7 +1139,7 @@ void IRenderer::BindPipeline( IPipeline *pPipeline )
 }
 
 
-void IRenderer::Begin( uint32_t nWidth, uint32_t nHeight, CUtlVector<RenderingColorAttachment_t> attachments, RenderingDepthAttachment_t depth )
+void CVkRenderer::Begin( uint32_t nWidth, uint32_t nHeight, CUtlVector<RenderingColorAttachment_t> attachments, RenderingDepthAttachment_t depth )
 {
 	CUtlVector<VkRenderingAttachmentInfo> colorAttachments = {};
 	VkRenderingAttachmentInfo depthAttachment = {};
@@ -1140,7 +1196,7 @@ skip_depth:
 	vkCmdBeginRendering(g_vkCommandBuffer, &renderInfo);
 }
 
-void IRenderer::ResetState()
+void CVkRenderer::ResetState()
 {
 
 	vkCmdSetRasterizerDiscardEnable(g_vkCommandBuffer, VK_FALSE);
@@ -1169,7 +1225,7 @@ void IRenderer::ResetState()
 	vkCmdSetPrimitiveRestartEnable(g_vkCommandBuffer, VK_FALSE);
 }
 
-void IRenderer::SetDepthMode( EDepthMode mode )
+void CVkRenderer::SetDepthMode( EDepthMode mode )
 {
 	if (mode == DEPTH_MODE_DISABLED)
 	{
@@ -1183,7 +1239,7 @@ void IRenderer::SetDepthMode( EDepthMode mode )
 	vkCmdSetStencilTestEnable(g_vkCommandBuffer, VK_FALSE);
 }
 
-void IRenderer::Draw( IVertexBuffer *pVertex, IIndexBuffer *pIndex )
+void CVkRenderer::Draw( IVertexBuffer *pVertex, IIndexBuffer *pIndex )
 {
 	CVkBuffer *pVkVertex = (CVkBuffer*)pVertex;
 	CVkBuffer *pVkIndex = (CVkBuffer*)pIndex;
@@ -1211,14 +1267,24 @@ void IRenderer::Draw( IVertexBuffer *pVertex, IIndexBuffer *pIndex )
 		}
 	}
 
+}	
+void CVkRenderer::Dispatch( uint32_t x, uint32_t y, uint32_t z )
+{
+
 }
 
-void IRenderer::End()
+void CVkRenderer::TraceRays( uint32_t x, uint32_t y, uint32_t z )
+{
+
+}
+
+
+void CVkRenderer::End()
 {
 	vkCmdEndRendering(g_vkCommandBuffer);
 }
 
-IGraphicsPipeline *IRenderer::CreateGraphicsPipeline(
+IGraphicsPipeline *CVkRenderer::CreateGraphicsPipeline(
 	CUtlVector<Shader_t> shaders,
 	CUtlVector<ShaderInput_t> inputs,
 	uint32_t nConstantsSize,
@@ -1315,13 +1381,30 @@ IGraphicsPipeline *IRenderer::CreateGraphicsPipeline(
 
 	return pipeline;
 };
+IComputePipeline *CVkRenderer::CreateComputePipeline(
+	Shader_t szShader,
+	CUtlVector<ShaderInput_t> inputs,
+	uint32_t nConstantsSize
+)
+{
 
-IBuffer *IRenderer::GetCameraMatrix()
+}
+
+IRayTracingPipeline *CVkRenderer::CreateRayTracingPipeline(
+	CUtlVector<Shader_t> shaders,
+	CUtlVector<ShaderInput_t> inputs,
+	uint32_t nConstantsSize
+)
+{
+
+}
+
+IBuffer *CVkRenderer::GetCameraMatrix()
 {
 	return g_cameraProperties;
 }
 
-IImage *IRenderer::GetOutputImage()
+IImage *CVkRenderer::GetOutputImage()
 {
 	return &s_SwapchainImage;
 }

fgui/fgui.cpp

@@ -95,7 +95,7 @@ void IFGUI::SetRectColor( float r, float g, float b, float a )
 //----------------------------------------------------------------------------
 void IFGUI::DrawRect( int32_t iPosX, int32_t iPosY, uint32_t uSizeX, uint32_t uSizeY )
 {
-	IRenderer::BindPipeline(fgui_RectPipeline);
+	Renderer()->BindPipeline(fgui_RectPipeline);
 	struct RectConstants_t
 	{
 		uint32_t nResolution[2];	
@@ -113,8 +113,8 @@ void IFGUI::DrawRect( int32_t iPosX, int32_t iPosY, uint32_t uSizeX, uint32_t uS
 	constants.nSize[1] = uSizeY;
 	for ( int i = 0; i < 4; i++ )
 		constants.fColor[i] = fgui_fRectColor[i];
-	IRenderer::SetConstants(sizeof(RectConstants_t), &constants);
+	Renderer()->SetConstants(sizeof(RectConstants_t), &constants);
-	IRenderer::Draw(fgui_pRectangleBuffer, NULL);
+	Renderer()->Draw(fgui_pRectangleBuffer, NULL);
 }
 
 CUtlVector<CFont*> fgui_fonts;
@@ -133,10 +133,10 @@ CFont *IFGUI::LoadFont( CUtlString szFontPath )
 	CFont *pFont = new CFont;
 	pFont->szName = szFontPath;
 	pFont->pTexture = ITextureManager::LoadTexture(CUtlString("%s.png", szFontPath.GetString()));
-	FileHandle_t f = IFileSystem::Open(CUtlString("%s.fontdata", szFontPath.GetString()), IFILE_READ);
+	FileHandle_t f = FileSystem()->Open(CUtlString("%s.fontdata", szFontPath.GetString()), IFILE_READ);
-	CUtlBuffer<char> b = IFileSystem::Size(f)+1;
+	CUtlBuffer<char> b = FileSystem()->Size(f)+1;
-	IFileSystem::Read(f, b.GetMemory(), IFileSystem::Size(f));
+	FileSystem()->Read(f, b.GetMemory(), FileSystem()->Size(f));
-	IFileSystem::Close(f);
+	FileSystem()->Close(f);
 	char cCharacterSet[256] = {};
 	V_memset(cCharacterSet, 0, 256);
 	uint32_t nElementsWidth;
@@ -191,7 +191,7 @@ void IFGUI::DrawText( CUtlString psz )
 	}
 
 
-	IRenderer::BindPipeline(fgui_TextPipeline);
+	Renderer()->BindPipeline(fgui_TextPipeline);
 
 	struct RectConstants_t
 	{
@@ -223,8 +223,8 @@ void IFGUI::DrawText( CUtlString psz )
 		constants.fGlyphPos[1] = fgui_pTextFont->cCharacterSet[psz[i]] / fgui_pTextFont->nGlyphsPerRow;
 		if (isprint(psz[i]) && !isspace(psz[i]))
 		{
-			IRenderer::SetConstants(sizeof(RectConstants_t), &constants);
+			Renderer()->SetConstants(sizeof(RectConstants_t), &constants);
-			IRenderer::Draw(fgui_pUVRectangleBuffer, NULL);
+			Renderer()->Draw(fgui_pUVRectangleBuffer, NULL);
 		}
 		constants.nPosition[0] += constants.nSize[0];
 	}
@@ -241,7 +241,7 @@ DECLARE_UI_RENDERING_STAGE(CFGUI_Rendering, fgui_rendering);
 
 void CFGUI_Rendering::Init()
 {
-	fgui_RectPipeline = IRenderer::CreateGraphicsPipeline(
+	fgui_RectPipeline = Renderer()->CreateGraphicsPipeline(
 		{
 		{"gfx/fgui_rect_vert.shader", SHADER_TYPE_VERTEX},
 		{"gfx/fgui_rect_frag.shader", SHADER_TYPE_FRAGMENT},
@@ -253,7 +253,7 @@ void CFGUI_Rendering::Init()
 		{IMAGE_FORMAT_WINDOW},
 		true
 	);	
-	fgui_TextPipeline = IRenderer::CreateGraphicsPipeline(
+	fgui_TextPipeline = Renderer()->CreateGraphicsPipeline(
 		{
 		{"gfx/fgui_text_vert.shader", SHADER_TYPE_VERTEX},
 		{"gfx/fgui_text_frag.shader", SHADER_TYPE_FRAGMENT},
@@ -276,7 +276,7 @@ void CFGUI_Rendering::Init()
 			0,1,
 			1,1,
 		};
-		fgui_pRectangleBuffer = IRenderer::CreateVertexBuffer(sizeof(vertices));
+		fgui_pRectangleBuffer = Renderer()->CreateVertexBuffer(sizeof(vertices));
 		void *pMapping = fgui_pRectangleBuffer->Map();
 		V_memcpy(pMapping, vertices, sizeof(vertices));
 		fgui_pRectangleBuffer->Unmap();
@@ -290,7 +290,7 @@ void CFGUI_Rendering::Init()
 			0,1, 0,1,
 			1,1, 1,1,
 		};
-		fgui_pUVRectangleBuffer = IRenderer::CreateVertexBuffer(sizeof(vertices));
+		fgui_pUVRectangleBuffer = Renderer()->CreateVertexBuffer(sizeof(vertices));
 		void *pMapping = fgui_pUVRectangleBuffer->Map();
 		V_memcpy(pMapping, vertices, sizeof(vertices));
 		fgui_pUVRectangleBuffer->Unmap();
@@ -301,16 +301,16 @@ void CFGUI_Rendering::Frame( float fDelta )
 {
 	fgui_TextPipeline->PushBindings();
 
-	IRenderer::Begin(g_nWindowWidth, g_nWindowHeight, {
+	Renderer()->Begin(g_nWindowWidth, g_nWindowHeight, {
 			{
-				IRenderer::GetOutputImage(),
+				Renderer()->GetOutputImage(),
 				NULL,
 				ATTACHMENT_LOAD_MODE_LOAD,
 				ATTACHMENT_STORE_MODE_STORE,
 			}
 	}, {});
-	IRenderer::ResetState();
+	Renderer()->ResetState();
-	IRenderer::SetDepthMode(DEPTH_MODE_LESS);
+	Renderer()->SetDepthMode(DEPTH_MODE_LESS);
 	for (auto &widget: fgui_widgets)
 	{
 		if (!widget->IsVisible())
@@ -321,7 +321,7 @@ void CFGUI_Rendering::Frame( float fDelta )
 		widget->ComputeOffset();
 		widget->Draw();
 	}
-	IRenderer::End();
+	Renderer()->End();
 };
 
 void CFGUI_Rendering::Deinit()

game/client/milmoba/mainmenu.cpp

@@ -84,7 +84,7 @@ void CMOBAMainMenu::Deinit()
 
 }
 
-DECLARE_INTERFACE(MainMenu, CMOBAMainMenu);
+DECLARE_ENGINE_INTERFACE(MainMenu, CMOBAMainMenu);
 
 
 

game/client/milmoba/player.cpp

@@ -77,7 +77,7 @@ void C_MOBAPlayer::Spawn()
 		-0.1f, -0.1f,  0.1f, 0, 1
 	};
 
-	IVertexBuffer *pVertexBuffer = IRenderer::CreateVertexBuffer(sizeof(cubeVertices));
+	IVertexBuffer *pVertexBuffer = Renderer()->CreateVertexBuffer(sizeof(cubeVertices));
 	void *pMapping = pVertexBuffer->Map();
 	V_memcpy(pMapping, cubeVertices, sizeof(cubeVertices));
 	pVertexBuffer->Unmap();

game/server/game.cpp

@@ -15,7 +15,7 @@ DECLARE_GAME_MODE(CTestGameMode, test_gamemode)
 
 DLL_EXPORT void IGame_Load()
 {
-	ILevel::LoadLevel("maps/test_map");
+	LevelManager()->LoadLevel("maps/test_map");
 	GameModeManager()->StartGameMode("test_gamemode");
 	return;
 };

public/baseentity.h

@@ -2,6 +2,7 @@
 #define ENTITY_H
 
 #include "engine.h"
+#include "interface.h"
 #include "tier1/utlvector.h"
 #include "math3d.h"
 
@@ -72,10 +73,11 @@ public:
 typedef CBaseEntity*(*EntityRegistryFn)( void );
 typedef C_BaseEntity*(*ClientEntityRegistryFn)( void );
 
-interface CEntityRegistry
+
+class CEntityRegistryObject
 {
 public:
-	CEntityRegistry( const char *szName, const char *szClass, EntityRegistryFn pfn );
+	CEntityRegistryObject( const char *szName, const char *szClass, EntityRegistryFn pfn );
 
 	const char *m_szName;
 	const char *m_szClass;
@@ -83,6 +85,14 @@ public:
 	ClientEntityRegistryFn m_pClientfn = 0;
 };
 
+interface IEntityManager: public IInterface
+{
+public:
+	CUtlVector<CBaseEntity*> m_entities;
+	CUtlVector<CEntityRegistryObject*> m_RegisteredEntities;
+};
+
+IEntityManager *EntityManager();
 
 
 #define DECLARE_ENTITY(name, class) \
@@ -90,7 +100,7 @@ CBaseEntity *__entity_alloc_##name() \
 { \
 	return new class; \
 }; \
-CEntityRegistry __entity_##name##_registry(#name, #class, __entity_alloc_##name); \
+CEntityRegistryObject __entity_##name##_registry(#name, #class, __entity_alloc_##name); \
 
 
 //-----------------------------------------------------------------------------
@@ -127,8 +137,4 @@ C_BaseEntity *__c_entity_alloc_##server() \
 C_EntityRegistry __c_entity_##server##_registry(#server, __c_entity_alloc_##server); \
 
 
-extern CUtlVector<CBaseEntity*> g_entities;
-extern CUtlVector<CEntityRegistry*> g_RegisteredEntities;
-
-
 #endif

public/console.h

@@ -2,6 +2,7 @@
 #define CONSOLE_H
 
 #include "engine.h"
+#include "interface.h"
 #include "tier1/utlstring.h"
 #include "tier1/utlvector.h"
 
@@ -21,33 +22,37 @@ public:
 	static bool IsVisibile();
 };
 
-interface IConsole
+interface IConsole: public IInterface
 {
 public:
-	static void Init();
+	virtual void Init() = 0;
-	static void Frame();
+	virtual void Frame() = 0;
-	static void Deinit();
+	virtual void Deinit() = 0;
 
 	// Variables
-	static void RegisterVar( ConVar *cvar );
+	virtual void RegisterVar( ConVar *cvar ) = 0;
-	static void UnRegisterVar( ConVar *cvar );
+	virtual void UnRegisterVar( ConVar *cvar ) = 0;
-	static ConVar *FindVar( const char *pName );
+	virtual ConVar *FindVar( const char *pName ) = 0;
 
 	// Commands
-	static void RegisterCommand( ConCommand *cvar );
+	virtual void RegisterCommand( ConCommand *cvar ) = 0;
-	static void UnRegisterCommand( ConCommand *cvar );
+	virtual void UnRegisterCommand( ConCommand *cvar ) = 0;
-	static ConCommand *FindCommand( const char *pName );
+	virtual ConCommand *FindCommand( const char *pName ) = 0;
 
 	// Command buffer 
-	static void Execute( void );
+	virtual void Execute( void ) = 0;
-	static CUtlVector<CUtlVector<CUtlString>> ParseCommandLine( CUtlString psz );
+	virtual void ExecuteArguments( CUtlVector<CUtlString> &args ) = 0;
+	virtual CUtlVector<CUtlVector<CUtlString>> ParseCommandLine( CUtlString psz ) = 0;
 
-	static void AddCommand( const char *psz );
+	virtual void AddCommand( const char *psz ) = 0;
-	static void InsertCommand( const char *psz );
+	virtual void InsertCommand( const char *psz ) = 0;
-private:
+	
-	static void Execute2( CUtlVector<CUtlString> &args );
+	CUtlVector<ConVar*> m_convars;
+	CUtlVector<ConCommand*> m_commands;
 };
 
+IConsole *Console();
+
 
 #define FCVAR_NONE 0
 #define FCVAR_DEVELOPMENTONLY 0x1

public/fgui/widget.h

@@ -24,8 +24,8 @@ public:
 	virtual void Frame() = 0;
 	virtual void SetVisibility( bool bValue );
 
-	int32_t m_iPosition[2];
+	int32_t m_iPosition[2] = {0, 0};
-	uint32_t m_iSize[2];
+	uint32_t m_iSize[2] = {0, 0};
 	CFGUI_Widget *m_pParent = NULL;
 	bool m_bIsVisible = true;
 };

public/filesystem.h

@@ -3,7 +3,7 @@
 #include "tier0/platform.h"
 #include "tier1/utlbuffer.h"
 #include "tier1/utlstring.h"
-
+#include "interface.h"
 
 enum EFileOptions
 {
@@ -22,22 +22,24 @@ typedef struct FileHandle_s
 	size_t nPtr;
 } *FileHandle_t;
 
-interface IFileSystem
+interface IFileSystem: public IInterface
 {
 public:
-	static void InitFilesystem( void );
+	virtual void InitFilesystem( void ) = 0;
-	static void AddGameDirectory( const char *psz );
+	virtual void AddGameDirectory( const char *psz ) = 0;
-	static bool LoadPackFile( const char *szFilename );
+	virtual bool LoadPackFile( const char *szFilename ) = 0;
-	static void CreatePath( const char *szPath );
+	virtual void CreatePath( const char *szPath ) = 0;
-	static FileHandle_t Open( const char *szFilename, EFileOptions options );
+	virtual FileHandle_t Open( const char *szFilename, EFileOptions options ) = 0;
-	static void Close( FileHandle_t file );
+	virtual void Close( FileHandle_t file ) = 0;
-	static size_t Size( FileHandle_t file );
+	virtual size_t Size( FileHandle_t file ) = 0;
-	static size_t Read( FileHandle_t file, void *pOutput, size_t nSize);
+	virtual size_t Read( FileHandle_t file, void *pOutput, size_t nSize) = 0;
-	static size_t ReadLine( FileHandle_t file, void *pOutput, size_t nSize);
+	virtual size_t ReadLine( FileHandle_t file, void *pOutput, size_t nSize) = 0;
-	static size_t Write( FileHandle_t file, void *pInput, size_t nSize);
+	virtual size_t Write( FileHandle_t file, void *pInput, size_t nSize) = 0;
-	static size_t Seek( FileHandle_t file, size_t nSize);
+	virtual size_t Seek( FileHandle_t file, size_t nSize) = 0;
-	static size_t Tell( FileHandle_t file, size_t nSize);
+	virtual size_t Tell( FileHandle_t file, size_t nSize) = 0;
-	static size_t fprintf( FileHandle_t file, const char *szFormat, ...);
+	virtual size_t fprintf( FileHandle_t file, const char *szFormat, ...) = 0;
 };
 
+IFileSystem *FileSystem();
+
 #endif

public/gamemode.h

@@ -3,6 +3,7 @@
 
 #include "interface.h"
 #include "tier0/platform.h"
+#include "tier1/utlvector.h"
 
 class CGameMode
 {
@@ -12,16 +13,6 @@ public:
 	bool bCanPlayerSpawnMidRound;
 };
 
-interface IGameModeManager: public IInterface
-{
-public:
-	virtual void StartGameMode( const char *szName ) = 0;
-	virtual const char *GetCurrentGameMode( void ) = 0;
-	virtual CGameMode *GetCurrentGameModeClass( void ) = 0;
-	virtual void RestartCurrentGameMode( void ) = 0;
-};
-
-extern IGameModeManager *GameModeManager();
 
 typedef CGameMode*(*GameModeRegistryFn)();
 class CGameModeRegistry
@@ -39,5 +30,17 @@ CGameMode *__gamemode_alloc_##name() \
 }; \
 CGameModeRegistry __gamemode_##name##_registry(#name, __gamemode_alloc_##name); \
 
+interface IGameModeManager: public IInterface
+{
+public:
+	virtual void StartGameMode( const char *szName ) = 0;
+	virtual const char *GetCurrentGameMode( void ) = 0;
+	virtual CGameMode *GetCurrentGameModeClass( void ) = 0;
+	virtual void RestartCurrentGameMode( void ) = 0;
+
+	CUtlVector<CGameModeRegistry*> m_RegisteredGameModes;
+};
+
+extern IGameModeManager *GameModeManager();
 
 #endif

public/interface.h

@@ -20,12 +20,12 @@ public:
 };
 
 
-#define DECLARE_INTERFACE(iface, impl) \
+#define DECLARE_ENGINE_INTERFACE(iface, impl) \
 IInterface *__interface_alloc_##impl() \
 { \
 	return new impl; \
 }; \
-CInterfaceRegistry __interface_##name##_registry(#iface, __interface_alloc_##impl); \
+CInterfaceRegistry __interface_##iface##_registry(#iface, __interface_alloc_##impl); \
 I##iface *iface() { \
 	static I##iface *pInterface = (I##iface*)__interface_alloc_##impl(); \
 	return pInterface; \

public/level.h

@@ -2,11 +2,14 @@
 #define LEVEL_H
 
 #include "engine.h"
+#include "interface.h"
 
-interface ILevel
+interface ILevelManager: public IInterface
 {
 public:
-	static void LoadLevel( const char *szLevelName );
+	virtual void LoadLevel( const char *szLevelName ) = 0;
 };
 
+ILevelManager *LevelManager();
+
 #endif

public/rendering.h

@@ -1,6 +1,7 @@
 #ifndef RENDERING_H
 #define RENDERING_H
 
+#include "interface.h"
 #include "math3d.h"
 #include "tier0/platform.h"
 #include "tier1/utlbuffer.h"
@@ -304,66 +305,6 @@ struct RenderingDepthAttachment_t
 	EMSAAMode msaaMode;
 };
 
-
-//----------------------------------------------------------------------------
-// Manages all buffers and pipelines.
-// It is meant to be used in render pipelines
-//----------------------------------------------------------------------------
-interface IRenderer
-{
-public:
-
-	static IStorageBuffer *CreateStorageBuffer( uint32_t uSize );
-	static IUniformBuffer *CreateUniformBuffer( uint32_t uSize );
-	static IVertexBuffer *CreateVertexBuffer( uint32_t uSize );
-	static IIndexBuffer *CreateIndexBuffer( uint32_t uSize );
-	static IImage *CreateImage( EImageFormat format, uint32_t usage, uint32_t nWidth, uint32_t nHeight, uint32_t nSamples = 1 );
-
-	static void DestroyBuffer( IBuffer *pBuffer );
-	static void DestroyImage( IImage *pImage );
-
-	static void SetConstants( uint32_t nSize, void *pData );
-	static void Barrier( uint32_t stageIn, uint32_t stageOut, CUtlVector<BufferBarrier_t> buffers, CUtlVector<ImageBarrier_t> images );
-	static void BindPipeline( IPipeline *pPipeline );
-
-	static void Begin( uint32_t nWidth, uint32_t nHeight, CUtlVector<RenderingColorAttachment_t> attachments, RenderingDepthAttachment_t depth );
-	static void ResetState();
-	static void SetDepthMode( EDepthMode mode );
-	static void Draw( IVertexBuffer *pVertex, IIndexBuffer *pIndex );
-	static void End();
-	
-	static void Dispatch( uint32_t x, uint32_t y, uint32_t z );
-	static void TraceRays( uint32_t x, uint32_t y, uint32_t z );
-
-	static IGraphicsPipeline *CreateGraphicsPipeline(
-		CUtlVector<Shader_t> shaders,
-		CUtlVector<ShaderInput_t> inputs,
-		uint32_t nConstantsSize,
-		uint32_t nVertexSize,
-		CUtlVector<VertexAttribute_t> vertexFormat,
-		CUtlVector<EImageFormat> outputFormats,
-		bool bDepth
-	);
-	static IComputePipeline *CreateComputePipeline(
-		Shader_t szShader,
-		CUtlVector<ShaderInput_t> inputs,
-		uint32_t nConstantsSize
-	);
-
-	static IRayTracingPipeline *CreateRayTracingPipeline(
-		CUtlVector<Shader_t> shaders,
-		CUtlVector<ShaderInput_t> inputs,
-		uint32_t nConstantsSize
-	);
-	
-	static IBuffer *GetCameraMatrix();
-	static IImage *GetOutputImage();
-};
-
-extern char g_bConfigNotify;
-extern uint32_t g_nWindowWidth;
-extern uint32_t g_nWindowHeight;
-
 abstract_class IRenderingPipelineStep
 {
 public:
@@ -372,20 +313,82 @@ public:
 	virtual void Deinit() = 0;
 };
 
+typedef IRenderingPipelineStep*(*CreateRenderStepFn)();
 struct RenderingStep_t
 {
 	IRenderingPipelineStep *pPipeline;
 	const char *szName;
 };
 
-extern CUtlVector<RenderingStep_t> g_StepPrepass;
+
-extern CUtlVector<RenderingStep_t> g_StepMeshRendering;
+//----------------------------------------------------------------------------
-extern CUtlVector<RenderingStep_t> g_StepShading;
+// Manages all buffers and pipelines.
-extern CUtlVector<RenderingStep_t> g_StepPostProcessing;
+// It is meant to be used in render pipelines
-extern CUtlVector<RenderingStep_t> g_StepUI;
+//----------------------------------------------------------------------------
+interface IRenderer: public IInterface
+{
+public:
+
+	virtual IStorageBuffer *CreateStorageBuffer( uint32_t uSize ) = 0;
+	virtual IUniformBuffer *CreateUniformBuffer( uint32_t uSize ) = 0;
+	virtual IVertexBuffer *CreateVertexBuffer( uint32_t uSize ) = 0;
+	virtual IIndexBuffer *CreateIndexBuffer( uint32_t uSize ) = 0;
+	virtual IImage *CreateImage( EImageFormat format, uint32_t usage, uint32_t nWidth, uint32_t nHeight, uint32_t nSamples = 1 ) = 0;
+
+	virtual void DestroyBuffer( IBuffer *pBuffer ) = 0;
+	virtual void DestroyImage( IImage *pImage ) = 0;
+
+	virtual void SetConstants( uint32_t nSize, void *pData ) = 0;
+	virtual void Barrier( uint32_t stageIn, uint32_t stageOut, CUtlVector<BufferBarrier_t> buffers, CUtlVector<ImageBarrier_t> images ) = 0;
+	virtual void BindPipeline( IPipeline *pPipeline ) = 0;
+
+	virtual void Begin( uint32_t nWidth, uint32_t nHeight, CUtlVector<RenderingColorAttachment_t> attachments, RenderingDepthAttachment_t depth ) = 0;
+	virtual void ResetState() = 0;
+	virtual void SetDepthMode( EDepthMode mode ) = 0;
+	virtual void Draw( IVertexBuffer *pVertex, IIndexBuffer *pIndex ) = 0;
+	virtual void End() = 0;
+	
+	virtual void Dispatch( uint32_t x, uint32_t y, uint32_t z ) = 0;
+	virtual void TraceRays( uint32_t x, uint32_t y, uint32_t z ) = 0;
+
+	virtual IGraphicsPipeline *CreateGraphicsPipeline(
+		CUtlVector<Shader_t> shaders,
+		CUtlVector<ShaderInput_t> inputs,
+		uint32_t nConstantsSize,
+		uint32_t nVertexSize,
+		CUtlVector<VertexAttribute_t> vertexFormat,
+		CUtlVector<EImageFormat> outputFormats,
+		bool bDepth
+	) = 0;
+	virtual IComputePipeline *CreateComputePipeline(
+		Shader_t szShader,
+		CUtlVector<ShaderInput_t> inputs,
+		uint32_t nConstantsSize
+	) = 0;
+
+	virtual IRayTracingPipeline *CreateRayTracingPipeline(
+		CUtlVector<Shader_t> shaders,
+		CUtlVector<ShaderInput_t> inputs,
+		uint32_t nConstantsSize
+	) = 0;
+	
+	virtual IBuffer *GetCameraMatrix() = 0;
+	virtual IImage *GetOutputImage() = 0;
+
+	CUtlVector<RenderingStep_t> m_StepPrepass;
+	CUtlVector<RenderingStep_t> m_StepMeshRendering;
+	CUtlVector<RenderingStep_t> m_StepShading;
+	CUtlVector<RenderingStep_t> m_StepPostProcessing;
+	CUtlVector<RenderingStep_t> m_StepUI;
+};
+
+IRenderer *Renderer();
+
+extern char g_bConfigNotify;
+extern uint32_t g_nWindowWidth;
+extern uint32_t g_nWindowHeight;
 
 
-typedef IRenderingPipelineStep*(*CreateRenderStepFn)();
 class CRenderingStep
 {
 public: