improvements

engine/gamemgr.cpp

@@ -0,0 +1,72 @@
+#include "igamemgr.h"
+#include "tier0/platform.h"
+#include "tier1/interface.h"
+#include "tier2/ifilesystem.h"
+#include "tier2/fileformats/ini.h"
+
+abstract_class CGame: public IGame {
+public:
+	virtual void Load() override;
+
+	virtual void GameFrame() override;
+private:
+	void *m_pLibrary;
+};
+
+abstract_class CGameManager: public IGameManager 
+{
+public:
+	virtual void Init() override;
+	virtual void Shutdown() override;
+	virtual IGame *LoadGame( const char *szGameName ) override;
+	virtual IGameMod *LoadGlobalMod( const char *szModName ) override;
+
+private:
+	IINIFile *g_pGameParameters;
+};
+
+void CGameManager::Init()
+{
+	IFileHandle *pFile;
+	size_t nDataSize = 0;
+	CUtlBuffer<char> szData;
+
+	IINISection *pMainGame;
+
+	CUtlString sz;
+
+	pFile = filesystem->Open("game.ini", FILEMODE_READ);
+	szData = CUtlBuffer<char>(pFile->Size());
+	pFile->Read(szData.GetMemory(), szData.GetSize());
+	pFile->Close();
+
+	g_pGameParameters= INIManager()->ReadString(szData);
+	pMainGame = g_pGameParameters->GetSection("MainGame");
+
+	LoadGame(pMainGame->GetStringValue("path"));
+}
+
+void CGameManager::Shutdown()
+{
+	INIManager()->ReleaseFile(g_pGameParameters);
+}
+
+//-----------------------------------------------------------------------------
+// Load all the packages
+//-----------------------------------------------------------------------------
+IGame *CGameManager::LoadGame( const char *szGameName )
+{
+	
+}
+
+IGameMod *CGameManager::LoadGlobalMod( const char *szModName )
+{
+
+}
+
+
+IGameManager *GameManager()
+{
+	static CGameManager manager;
+	return (IGameManager*)&manager;
+}

fpc/library/c.cpp

@@ -56,13 +56,14 @@ LinkProject_t ICCompiler::Compile( CProject_t *pProject )
 	// Run CC
 	for (auto &file: pProject->files)
 	{
-		V_printf("  CC       %s\n", file.GetString());
 		CUtlString szOutputFile = GetOutputObjectName(pProject, hash, file);
 		CUtlVector<CUtlString> args;
 
 		args = BuildCommandLine(pProject, file, szOutputFile);
 		if (!filesystem2->ShouldRecompile(file, szOutputFile))
 			goto skipcompile;
+		else
+			V_printf("  CC       %s\n", file.GetString());
 		runner->Run(GetCompilerExecutable(pProject), args);
 skipcompile:
 		proj.objects.AppendTail((Object_t){szOutputFile});

fpc/library/clang/c.cpp

@@ -152,7 +152,6 @@ LinkProject_t CClangCompiler::Compile( CProject_t *pProject )
 	// Run CC
 	for (auto &file: pProject->files)
 	{
-		V_printf("  CC       %s\n", file.GetString());
 		
 		bool bAreDependenciesUpdated = false;
 		CUtlString szOutputFile = GetOutputObjectName(pProject, hash, file);
@@ -201,6 +200,10 @@ LinkProject_t CClangCompiler::Compile( CProject_t *pProject )
 			args.AppendTail(CUtlString("--sysroot=%s", pProject->m_target.szSysroot));
 		}
 		*/
+		if (!filesystem2->ShouldRecompile(file, szOutputFile))
+			goto skipcompile;
+		else
+			V_printf("  CC       %s\n", file.GetString());
 
 		runner->Run(GetCompilerExecutable(pProject), args);
 skipcompile:

funnyassets/game.ini

@@ -0,0 +1,5 @@
+
+[MainGame]
+name = "FunnyGame"
+path = "funnygame"
+version = 1

materialsystem/__build.cpp

@@ -9,6 +9,7 @@ CUtlVector<CUtlString> MaterialSystem_CompiledFiles = {
 	"materialsystem/vulkan/rendercontext.cpp",
 	"materialsystem/vulkan/material.cpp",
 	"materialsystem/vulkan/commandbuffer.cpp",
+	"materialsystem/vulkan/commands/draw.cpp",
 	"external/volk/volk.c",
 };
 CUtlString material_lib;

materialsystem/vulkan/commandbuffer.cpp

@@ -1,33 +1,169 @@
+#include "tier0/platform.h"
+#include "tier1/interface.h"
 #include "tier1/utlvector.h"
 #include "vulkan_state.h"
 
+CUtlVector<VkCommandBuffer> g_vkCommandBuffers;
+IVkCommandBufferManager *g_pCommandBufferManager;
+
 class CVkCommandBuffer: public IVkCommandBuffer
 {
 public:
-	virtual void Init() override;
+	virtual void AddCommand( CVkCommand *pCommand ) override;
-	virtual void Shutdown() override;
+	virtual void Reset() override;
-	virtual void AddCommand( EVulkanCommandType eType, CVkCommand *pCommand ) override;
+	virtual void Submit( int iFrameIndex ) override;
-	virtual void Submit() override;
+	virtual void Render() override;
 private:
 	CUtlSelfReferencingVector<CVkCommand*> g_commands;
+	CUtlVector<VkCommandBuffer> m_hBuffers = NULL;
 };
 
-void CVkCommandBuffer::AddCommand( EVulkanCommandType eType, CVkCommand *pCommand )
+void CVkCommandBuffer::Reset()
+{
+	VkCommandBufferAllocateInfo commandBufferAllocInfo = {};
+	int i = 0;
+
+	for ( auto pool: g_vkCommandPools)
+	{
+		commandBufferAllocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+		commandBufferAllocInfo.commandPool = pool;
+		commandBufferAllocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+		commandBufferAllocInfo.commandBufferCount = 1;
+		vkAllocateCommandBuffers(g_vkDevice, &commandBufferAllocInfo, &m_hBuffers[i]);
+		i++;
+	}
+
+	g_commands = {};
+}
+
+void CVkCommandBuffer::AddCommand( CVkCommand *pCommand )
 {
 	g_commands.AppendTail(pCommand);
 }
 
-void CVkCommandBuffer::Submit()
+void CVkCommandBuffer::Submit( int iFrameIndex )
+{
+	g_vkCommandBuffers.AppendTail(m_hBuffers[iFrameIndex]);
+};
+
+void CVkCommandBuffer::Render()
+{
+
+	uint32_t nNumDependencies;
+
+	
+	nNumDependencies = 0;
+	for (auto pCommand: g_commands)
+	{
+		nNumDependencies += pCommand->m_depedencies.GetSize();
+	}
+
+	// issue vkCmdPipelineBarrier if there are any
+	if (nNumDependencies)
+	{
+
+	}
+
+	for (auto hBuffer: m_hBuffers)
 	{
 		for (auto &pCommand: g_commands)
 		{
-		pCommand->Execute();
+			pCommand->Execute(hBuffer);
-		delete pCommand;
 		};
+	}
+}
+
+void CVkCommand::SetUIntParam( const char *szName, uint32_t uintParam )
+{
+	for ( auto p: m_parameters )
+	{
+		if (!V_strcmp(p.m_szName, szName))
+			p.uint32_Data = uintParam;
+	}
+}
+
+uint32_t CVkCommand::GetUIntParam( const char *szName )
+{
+	for ( auto p: m_parameters )
+	{
+		if (!V_strcmp(p.m_szName, szName))
+			return p.uint32_Data;
+	}
+	return 0;
+}
+
+void CVkCommand::SetImageParam( const char *szName, IImage *pImageParam )
+{
+	for ( auto p: m_parameters )
+	{
+		if (!V_strcmp(p.m_szName, szName))
+			p.pImageData = pImageParam;
+	}
+}
+
+IImage *CVkCommand::GetImageParam( const char *szName )
+{
+	for ( auto p: m_parameters )
+	{
+		if (!V_strcmp(p.m_szName, szName))
+			return p.pImageData;
+	}
+	return 0;
+}
+
+class CVkCommandBufferManager: public IVkCommandBufferManager
+{
+public:
+	virtual void Init() override;
+	virtual void Shutdown() override;
+	virtual IVkCommandBuffer *CreateCommandBuffer() override;
+	virtual CVkCommand *CreateCommand( const char *szName ) override;
 };
 
-static CVkCommandBuffer s_vkCommandBuffer;
+EXPOSE_INTERFACE(CVkCommandBufferManager, IVkCommandBufferManager, VULKAN_COMMAND_BUFFER_MANAGER_INTERFACE_NAME);
-IVkCommandBuffer *VulkanCommandBuffer()
+
+void CVkCommandBufferManager::Init()
 {
-	return &s_vkCommandBuffer;
+
 }
+
+void CVkCommandBufferManager::Shutdown()
+{
+
+}
+
+IVkCommandBuffer *CVkCommandBufferManager::CreateCommandBuffer()
+{
+	return new CVkCommandBuffer;
+}
+
+
+struct VulkanCommandRegistry_t
+{
+	const char *m_szName;
+	fnCreateVulkanCommand_t m_pfnCreate;
+	struct VulkanCommandRegistry_t *m_pNext;
+} *s_pVulkanCommands = NULL;
+
+CVkCommand *CVkCommandBufferManager::CreateCommand( const char *szName )
+{
+	VulkanCommandRegistry_t *pCommand;
+	for ( pCommand = s_pVulkanCommands; pCommand; pCommand = pCommand->m_pNext )
+	{
+		if (!V_strcmp(pCommand->m_szName, szName))
+			return pCommand->m_pfnCreate();
+	}
+	Plat_FatalErrorFunc("Command %s not found\n", szName);
+	return NULL;
+}
+
+CVkCommandRegistry::CVkCommandRegistry( const char *szName, fnCreateVulkanCommand_t pfnCreate )
+{
+	VulkanCommandRegistry_t *pCommand = new VulkanCommandRegistry_t;
+	pCommand->m_szName = szName;
+	pCommand->m_pfnCreate = pfnCreate;
+	pCommand->m_pNext = s_pVulkanCommands;
+	s_pVulkanCommands = pCommand;
+}
+
+

materialsystem/vulkan/commands/draw.cpp

@@ -0,0 +1,32 @@
+#include "../vulkan_state.h"
+
+DECLARE_VULKAN_COMMAND(Draw)
+{
+
+}
+
+BEGIN_VULKAN_COMMAND_DATA(Draw)
+	{"", VULKAN_PARAMETER_TYPE_UINT32},
+END_VULKAN_COMMAND_DATA()
+
+
+DECLARE_VULKAN_COMMAND(ClearColor)
+{
+	CVkImage *pImage = (CVkImage*)GetImageParam("Image");
+	VkClearColorValue color = {.float32 = {1,0,1,0}};
+	VkImageSubresourceRange range = {
+		.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+		.levelCount = 1,
+		.layerCount = 1,
+	};
+	vkCmdClearColorImage(hCommandBuffer, pImage->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &color, 1, &range);
+
+}
+
+BEGIN_VULKAN_COMMAND_DATA(ClearColor)
+	{"R", VULKAN_PARAMETER_TYPE_FLOAT},
+	{"G", VULKAN_PARAMETER_TYPE_FLOAT},
+	{"B", VULKAN_PARAMETER_TYPE_FLOAT},
+	{"A", VULKAN_PARAMETER_TYPE_FLOAT},
+	{"Image", VULKAN_PARAMETER_TYPE_IMAGE},
+END_VULKAN_COMMAND_DATA()

materialsystem/vulkan/rendercontext.cpp

@@ -2,6 +2,7 @@
 #include "materialsystem/imaterialsystem.h"
 #include "tier0/lib.h"
 #include "tier0/platform.h"
+#include "tier1/interface.h"
 #include "tier1/utlstring.h"
 #include "tier1/utlvector.h"
 #define VK_NO_PROTOTYPES
@@ -36,41 +37,11 @@ CUtlVector<VkFence> g_vkFences;
 CUtlVector<VkSemaphore> g_vkGraphicsSemaphores;
 CUtlVector<VkSemaphore> g_vkPresentSemaphores;
 
-VkCommandPool g_vkCommandPool;
+CUtlVector<VkCommandPool> g_vkCommandPools;
-CUtlVector<VkCommandBuffer> g_vkCommandBuffers;
 
 CUtlVector<IImage*> g_vkSwapchainImages;
 VkFormat g_vkWindowImageFormat;
 
-class CVkImage: public IImage
-{
-public:
-	CVkImage();
-	CVkImage( uint32_t nWidth, uint32_t nHeight, EImageFormat eFormat, EMultisampleType eMultisampleType );
-	~CVkImage();
-	
-	virtual void SetDebugName( const char *szName ) override;
-	virtual uint32_t GetImageWidth() override;
-	virtual uint32_t GetImageHeight() override;
-	virtual EImageFormat GetImageFormat() override;
-	virtual EMultisampleType GetMultisampleType() override;
-
-	void CreateImage( uint32_t nWidth, uint32_t nHeight, EImageFormat eFormat, EMultisampleType eMultisampleType );
-	void CreateImageView();
-
-	static VkImageViewType GetImageViewType( enum EImageType eImageType );
-	static VkFormat GetImageFormat( enum EImageFormat eImageFormat );
-
-	uint32_t m_nWidth;
-	uint32_t m_nHeight;
-	EImageFormat m_eFormat;
-	EMultisampleType m_eMultisampleType;
-	EImageType m_eImageType;
-
-	VkImage m_image;
-	VkImageView m_imageView;
-	VmaAllocation m_allocation;
-};
 
 CVkImage::CVkImage()
 {
@@ -343,6 +314,51 @@ void CVkRenderContext::DestroyImage( IImage *pImage )
 
 }
 
+IShader *CVkRenderContext::CreateShader( const char *szName )
+{
+
+}
+
+void CVkRenderContext::DestroyShader( IShader *pMaterial )
+{
+
+}
+
+IMaterial *CVkRenderContext::CreateMaterial( IShader *pShader )
+{
+
+}
+
+void CVkRenderContext::DestroyMaterial( IMaterial *pMaterial )
+{
+
+}
+void CVkRenderContext::SetMaterial( IMaterial *pMaterial )
+{
+
+}
+
+void CVkRenderContext::SetVertexBuffer( IVertexBuffer *pBuffer )
+{
+
+}
+
+void CVkRenderContext::SetIndexBuffer( IVertexBuffer *pBuffer )
+{
+
+}
+
+void CVkRenderContext::DrawPrimitives( uint32_t nVertexCount, uint32_t nFirstVertex, uint32_t nInstanceCount, uint32_t nFirstInstance )
+{
+
+}
+
+void CVkRenderContext::DrawPrimitivesIndexed( uint32_t nIndexCount, uint32_t nFirstIndex, uint32_t nVertexOffset, uint32_t nInstanceCount, uint32_t nFirstInstance )
+{
+
+}
+
+
 void CVkRenderContext::Init()
 {
 	VkResult r;
@@ -443,22 +459,27 @@ void CVkRenderContext::Init()
 	
 	CreateSwapchain();
 
-	g_vkCommandBuffers.Resize(g_vkSwapchainImages.GetSize());
+	g_vkCommandPools.Resize(g_vkSwapchainImages.GetSize());
 
+	for (auto &pool: g_vkCommandPools)
+	{
 		VkCommandPoolCreateInfo commandPoolCreateInfo = {};
 		commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
 		commandPoolCreateInfo.queueFamilyIndex = g_iDrawFamily;
 		commandPoolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
-	vkCreateCommandPool(g_vkDevice, &commandPoolCreateInfo, NULL, &g_vkCommandPool);
+		vkCreateCommandPool(g_vkDevice, &commandPoolCreateInfo, NULL, &pool);
+	}
 
-	VkCommandBufferAllocateInfo commandBufferAllocInfo = {};
+	g_pCommandBufferManager = (IVkCommandBufferManager*)CreateInterface(VULKAN_COMMAND_BUFFER_MANAGER_INTERFACE_NAME, NULL);
-	commandBufferAllocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+	g_pCommandBufferManager->Init();
-	commandBufferAllocInfo.commandPool = g_vkCommandPool;
-	commandBufferAllocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
-	commandBufferAllocInfo.commandBufferCount = g_vkSwapchainImages.GetSize();
-	vkAllocateCommandBuffers(g_vkDevice, &commandBufferAllocInfo, g_vkCommandBuffers.GetData());
 
+	IVkCommandBuffer *pCommandBuffer = g_pCommandBufferManager->CreateCommandBuffer();
+	CVkCommand *pCommand = g_pCommandBufferManager->CreateCommand("Draw");
+	pCommand->AddDependency(g_vkSwapchainImages[0], DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION);
+	pCommand->SetImageParam("Image", g_vkSwapchainImages[0]);
+	pCommandBuffer->AddCommand(pCommand);
 
+	pCommandBuffer->Render();
 }
 
 void CVkRenderContext::Frame( float fDeltaTime )
@@ -466,25 +487,21 @@ void CVkRenderContext::Frame( float fDeltaTime )
 	static uint32_t s_nImageIndex = 0;
 	uint32_t nImageIndex = 0;
 
-	vkWaitForFences(g_vkDevice, 1, &g_vkFences[s_nImageIndex], UINT64_MAX, VK_TRUE);
+	vkWaitForFences(g_vkDevice, 1, &g_vkFences[s_nImageIndex], VK_TRUE, UINT64_MAX);
 	VkResult r = vkAcquireNextImageKHR(g_vkDevice, g_vkSwapchain, UINT64_MAX, g_vkGraphicsSemaphores[s_nImageIndex], NULL, &nImageIndex);
 	
-	VkCommandBufferBeginInfo commandBufferBeginInfo = {};
-	commandBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-	vkBeginCommandBuffer(GetCommandBuffer(), &commandBufferBeginInfo);
-	vkEndCommandBuffer(GetCommandBuffer());
-	
 	vkResetFences(g_vkDevice, 1, &g_vkFences[s_nImageIndex]);
 	
-	VkCommandBuffer currentCommandBuffer = GetCommandBuffer();
 	VkPipelineStageFlags uPipelineStageFlags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 	VkSubmitInfo stSubmitInfo = {};
 	stSubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
 	stSubmitInfo.waitSemaphoreCount = 1;
 	stSubmitInfo.pWaitSemaphores = &g_vkGraphicsSemaphores[s_nImageIndex];
 	stSubmitInfo.pWaitDstStageMask = &uPipelineStageFlags;
-	stSubmitInfo.commandBufferCount = 1;
+	
-	stSubmitInfo.pCommandBuffers = &currentCommandBuffer;
+	stSubmitInfo.commandBufferCount = g_vkCommandBuffers.GetSize();
+	stSubmitInfo.pCommandBuffers = g_vkCommandBuffers.GetData();
+	
 	stSubmitInfo.signalSemaphoreCount = 1;
 	stSubmitInfo.pSignalSemaphores = &g_vkPresentSemaphores[nImageIndex];
 
@@ -693,7 +710,3 @@ CUtlVector<const char *> CVkRenderContext::GetDeviceExtensions()
 	return enabledExtensions;
 }
 
-VkCommandBuffer CVkRenderContext::GetCommandBuffer()
-{
-	return g_vkCommandBuffers[0];
-}

materialsystem/vulkan/vulkan_state.h

@@ -8,6 +8,7 @@
 #include "tier1/utlvector.h"
 #include "tier2/iappsystem.h"
 #include "materialsystem/imaterialsystem.h"
+#include "vulkan/vulkan_core.h"
 
 #define REQUIRED_EXTENSION(ext) bool bIsSupported_##ext;
 #define OPTIONAL_EXTENSION(ext) bool bIsSupported_##ext;
@@ -18,6 +19,16 @@ extern struct SupportedVulkanExtensions_t
 #undef REQUIRED_EXTENSION
 #undef OPTIONAL_EXTENSION
 
+extern CUtlVector<IImage*> g_vkSwapchainImages;
+
+
+extern CUtlVector<VkCommandPool> g_vkCommandPools;
+extern CUtlVector<VkCommandBuffer> g_vkCommandBuffers;
+
+extern VkInstance g_vkInstance;
+extern VkPhysicalDevice g_vkPhysicalDevice;
+extern VkDevice g_vkDevice;
+
 enum EVulkanCommandType
 {
 	COMMAND_TYPE_GENERAL,
@@ -27,6 +38,14 @@ enum EVulkanCommandType
 	COMMAND_TYPE_END,
 };
 
+enum EVulkanCommandParameterType
+{
+	VULKAN_PARAMETER_TYPE_UINT32,
+	VULKAN_PARAMETER_TYPE_FLOAT,
+	VULKAN_PARAMETER_TYPE_BUFFER,
+	VULKAN_PARAMETER_TYPE_IMAGE,
+};
+
 enum EDependencyMode
 {
 	DEPENDENCY_MODE_SHADER_IMAGE_READ,
@@ -41,46 +60,92 @@ enum EDependencyMode
 
 	DEPENDENCY_MODE_IMAGE_SOURCE,
 	DEPENDENCY_MODE_IMAGE_DESTINATION,
+
+	DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION,
 };
 
-#define EXPOSE_VULKAN_COMMAND( name ) \
-class CVulkanCommand_##name; \
-CVulkanCommand_##name *name(); \
-
-#define DECLARE_VULKAN_COMMAND( name ) \
-class CVulkanCommand_##name \
-{ \
-public: \
-	virtual void Execute() override; \
-}; \
-CVulkanCommand_##name *name(); \
-{ \
-	return new CVulkanCommand_##name \
-} \
-void CVulkanCommand_##name::Execute() \
-
-abstract_class CVkCommand
-{
-public:
-	void AddDependency( IRenderingObject *pObject, EDependencyMode eDependencyMode );
-	virtual void Execute();
 
 struct VulkanCommandDepenency_t {
 	IRenderingObject *m_pObject;
 	EDependencyMode m_eDependencyMode;
 };
-	CUtlVector<VulkanCommandDepenency_t> m_depedencies;
+
+struct VulkanCommandParameter_t
+{
+	const char *m_szName;
+	const EVulkanCommandParameterType m_eParameterType;
+	union {
+		uint32_t uint32_Data;
+		IImage *pImageData;
+	};
 };
 
-abstract_class IVkCommandBuffer: public IAppSystem
+abstract_class CVkCommand
 {
 public:
-	virtual void AddCommand( EVulkanCommandType eType, CVkCommand * ) = 0;
+	void AddDependency( IRenderingObject *pObject, EDependencyMode eDependencyMode );
+	virtual void Execute( VkCommandBuffer hCommandBuffer ) = 0;
+	//virtual const char *GetName();
 
-	virtual void Submit() = 0;
+	CUtlVector<VulkanCommandDepenency_t> m_depedencies;
+	EVulkanCommandType m_eType;
+
+	void SetUIntParam( const char *szName, uint32_t uintParam );
+	uint32_t GetUIntParam( const char *szName );
+	void SetImageParam( const char *szName, IImage *pImageParam );
+	IImage *GetImageParam( const char *szName );
+	virtual CUtlVector<VulkanCommandParameter_t> GetDataTemplate() = 0;
+	CUtlVector<VulkanCommandParameter_t> m_parameters;
+};
+
+abstract_class IVkCommandBuffer
+{
+public:
+	virtual void AddCommand( CVkCommand *pCommand ) = 0;
+
+	virtual void Reset() = 0;
+	virtual void Submit( int iFrameIndex ) = 0;
+	virtual void Render() = 0;
+};
+
+typedef CVkCommand *(*fnCreateVulkanCommand_t)();
+
+abstract_class IVkCommandBufferManager: public IAppSystem
+{
+public:
+	virtual IVkCommandBuffer *CreateCommandBuffer() = 0;
+	virtual CVkCommand *CreateCommand( const char *szName ) = 0;
+};
+#define VULKAN_COMMAND_BUFFER_MANAGER_INTERFACE_NAME "VulkanCommandBufferManager"
+extern IVkCommandBufferManager *g_pCommandBufferManager;
+
+class CVkCommandRegistry
+{
+public:
+	CVkCommandRegistry( const char *szName, fnCreateVulkanCommand_t pfnCreate );
+};
+
+#define DECLARE_VULKAN_COMMAND( name ) \
+class VulkanCommand_##name : public CVkCommand \
+{ \
+public: \
+	virtual void Execute( VkCommandBuffer hCommandBuffer ) override; \
+	virtual CUtlVector<VulkanCommandParameter_t> GetDataTemplate() override; \
+}; \
+CVkCommand *_VulkanCommandCreate_##name() { return new VulkanCommand_##name; } \
+CVkCommandRegistry _VulkanCommandRegistry_##name( #name, _VulkanCommandCreate_##name ); \
+void VulkanCommand_##name::Execute( VkCommandBuffer hCommandBuffer ) \
+
+#define BEGIN_VULKAN_COMMAND_DATA(name) \
+CUtlVector<VulkanCommandParameter_t> VulkanCommand_##name::GetDataTemplate() \
+{ \
+	CUtlVector<VulkanCommandParameter_t> parameters = {
+
+#define END_VULKAN_COMMAND_DATA() \
+	}; \
+	return parameters; \
 };
 
-IVkCommandBuffer *VulkanCommandBuffer();
 
 #undef __cplusplus
 #include "vulkan/vk_enum_string_helper.h"
@@ -90,4 +155,34 @@ IVkCommandBuffer *VulkanCommandBuffer();
 if (r != VK_SUCCESS) \
 	Plat_FatalErrorFunc(#func " failed: %s\n", string_VkResult(r))
 
+class CVkImage: public IImage
+{
+public:
+	CVkImage();
+	CVkImage( uint32_t nWidth, uint32_t nHeight, EImageFormat eFormat, EMultisampleType eMultisampleType );
+	~CVkImage();
+	
+	virtual void SetDebugName( const char *szName ) override;
+	virtual uint32_t GetImageWidth() override;
+	virtual uint32_t GetImageHeight() override;
+	virtual EImageFormat GetImageFormat() override;
+	virtual EMultisampleType GetMultisampleType() override;
+
+	void CreateImage( uint32_t nWidth, uint32_t nHeight, EImageFormat eFormat, EMultisampleType eMultisampleType );
+	void CreateImageView();
+
+	static VkImageViewType GetImageViewType( enum EImageType eImageType );
+	static VkFormat GetImageFormat( enum EImageFormat eImageFormat );
+
+	uint32_t m_nWidth;
+	uint32_t m_nHeight;
+	EImageFormat m_eFormat;
+	EMultisampleType m_eMultisampleType;
+	EImageType m_eImageType;
+
+	VkImage m_image;
+	VkImageView m_imageView;
+	VmaAllocation m_allocation;
+};
+
 #endif

public/gamesystem.h

@@ -0,0 +1,15 @@
+#ifndef GAME_SYSTEM_H
+#define GAME_SYSTEM_H
+
+#include "tier1/interface.h"
+
+abstract_class IGameSystem
+{
+public:
+	virtual void Init() = 0;
+	virtual void Tick( float fDelta ) = 0;
+	virtual void Frame( float fDelta ) = 0;
+	virtual void Shutdown() = 0;
+};
+
+#endif

public/iassetmgr.h

@@ -0,0 +1,20 @@
+#ifndef ASSET_MGR_H
+#define ASSET_MGR_H
+
+#include "tier0/platform.h"
+#include "tier2/iappsystem.h"
+
+abstract_class IModel;
+abstract_class ITexture;
+abstract_class ISound;
+
+abstract_class IAssetManager: public IAppSystem
+{
+public:
+	virtual void Preload( const char *szName ) = 0;
+	virtual ITexture *LoadTexture( const char *szName ) = 0;
+	virtual IModel *LoadModel( const char *szName ) = 0;
+	virtual ISound *LoadSound( const char *szName ) = 0;
+};
+
+#endif

public/igamemgr.h

@@ -0,0 +1,39 @@
+#ifndef GAME_MGR_H
+#define GAME_MGR_H
+
+#include "tier2/iappsystem.h"
+
+abstract_class IGameBase: public IAppSystem {
+public:
+	virtual void Load() = 0;
+
+	virtual void GameFrame() = 0;
+
+	virtual const char *GetAssetDirectory();
+};
+
+abstract_class IGameMod: public IGameBase
+{
+
+};
+
+abstract_class IGame: public IGameBase
+{
+public:
+	virtual IGameMod *LoadLocalMod( const char *szModName ) = 0;
+
+private:
+	void *m_pLibrary;
+};
+
+abstract_class IGameManager: public IAppSystem
+{
+public:
+	virtual IGame *LoadGame( const char *szGameName ) = 0;
+	virtual IGameMod *LoadGlobalMod( const char *szModName ) = 0;
+};
+
+
+IGameManager *GameManager();
+
+#endif

rapier/__build.cpp

@@ -7,6 +7,8 @@
 CUtlString rapier_lib;
 DECLARE_BUILD_STAGE(rapier)
 {
+	if (CommandLine()->CheckParam("-norust"))
+		return 0;
 	rapier_lib = CUtlString("rapier/target/%s/release/librapier_rtt.a",szTarget.GetString());
 	V_printf("%s\n",rapier_lib.GetString());
 	CUtlVector<CUtlString> cargo_args = {