added barriers, started working on libraries

engine/filesystem_pak.cpp

@@ -82,7 +82,7 @@ public:
 			return;
 		delete pHandle;
 	}
+	virtual CUtlBuffer<unsigned char> Read( IFileHandle *pFile ) override { return NULL; }; 
 };
 
-CPAKFileSystem g_pakFileSystem;
+EXPOSE_FILESYSTEM(CPAKFileSystem, "pakfs");
-IFileSystem *filesystem_pak = &g_pakFileSystem;

funnyassets/__build.cpp

@@ -8,24 +8,24 @@
 
 void build_shader( const char *szName )
 {
-	filesystem2->MakeDirectory(CUtlString("build/funnygame/metal/gfx"));
+	filesystem2->MakeDirectory(CUtlString("build/funnygame/metal/shaders"));
-	filesystem2->MakeDirectory(CUtlString("build/funnygame/vulkan/gfx"));
+	filesystem2->MakeDirectory(CUtlString("build/funnygame/vulkan/shaders"));
 
 	CUtlVector<CUtlString> slang_args = {
-		CUtlString("funnyassets/gfx_shaders/%s.slang", szName),
+		CUtlString("funnyassets/shaders/%s.slang", szName),
 		"-g",
 		"-target",
 		"spirv",
 		"-D",
 		"__SPIRV__=1",
 		"-o",
-		CUtlString("build/funnygame/vulkan/gfx/%s.shader", szName),
+		CUtlString("build/funnygame/vulkan/shaders/%s.spv", szName),
 	};
 
 	runner->Run("slangc", slang_args);
 	slang_args[3] = "metal";
 	slang_args[5] = "__METAL__=1";
-	slang_args[7] = CUtlString("build/funnygame/metal/gfx/%s.shader", szName);
+	slang_args[7] = CUtlString("build/funnygame/metal/shaders/%s.spv", szName);
 	runner->Run("slangc", slang_args);
 	runner->Wait();	
 };
@@ -37,16 +37,19 @@ DECLARE_BUILD_STAGE(assets)
 	filesystem2->CopyDirectory("build", "tools");
 
 	filesystem2->CopyDirectory(CUtlString("build/funnygame/assets"), "funnyassets/maps");
-	filesystem2->CopyDirectory(CUtlString("build/funnygame/assets"), "funnyassets/gfx");
+	filesystem2->CopyDirectory(CUtlString("build/funnygame/assets"), "funnyassets/shaders");
 	filesystem2->CopyDirectory(CUtlString("build/funnygame/assets"), "funnyassets/fonts");
 	filesystem2->CopyDirectory(CUtlString("build/funnygame/assets"), "funnyassets/textures");
 	filesystem2->CopyDirectory(CUtlString("build/funnygame/assets"), "funnyassets/materials");
+	/*
 	build_shader("mesh_frag");
 	build_shader("mesh_vert");
 	build_shader("fgui_rect_frag");
 	build_shader("fgui_rect_vert");
 	build_shader("fgui_text_frag");
 	build_shader("fgui_text_vert");
+	*/
+	build_shader("flat");
 	CUtlVector<CUtlString> python_args = {
 		"build/tools/makepak64.py",
 		CUtlString("build/funnygame/assets"),
@@ -62,12 +65,15 @@ DECLARE_BUILD_STAGE(assets)
 		};
 		runner->Run("python3", python_args);
 	} else {
+		filesystem2->CopyDirectory(CUtlString("%s/funnygame", szOutputDir.GetString()),"build/funnygame/vulkan/shaders");
+		/*
 		python_args = {
 			"build/tools/makepak64.py",
 			CUtlString("build/funnygame/vulkan"),
 			bStaticBuild ? CUtlString("%s/bin/%s.pak", szOutputDir.GetString(), "vulkan") : CUtlString("%s/funnygame/%s.pak", szOutputDir.GetString(), "vulkan"),
 		};
 		runner->Run("python3", python_args);
+		*/
 	}
 	runner->Wait();	
 

funnyassets/shaders/flat.slang

@@ -0,0 +1,23 @@
+struct VS_INPUT
+{
+	float3 m_vPosition;
+}
+
+struct PS_INPUT 
+{
+	float4 m_vPosition;
+}
+
+[shader("vertex")]
+PS_INPUT vsMain( VS_INPUT i )
+{
+	PS_INPUT o;
+	o.m_vPosition = { i.m_vPosition, 1 };
+	return o;
+}
+
+[shader("pixel")]
+float4 psMain( PS_INPUT i )
+{
+	return float4(1);
+}

materialsystem/__build.cpp

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

materialsystem/vulkan/commandbuffer.cpp

@@ -7,6 +7,20 @@
 CUtlVector<VkCommandBuffer> g_vkCommandBuffers;
 IVkCommandBufferManager *g_pCommandBufferManager;
 
+struct VulkanCommandLastUsage_t
+{
+	uint32_t m_nLastUsedCommand;
+	EDependencyMode m_eLastUsage;
+	VulkanCommandDepenency_t m_dependency;
+};
+
+struct VulkanSwapchainCommandLastUsage_t
+{
+	uint32_t m_nLastUsedCommand;
+	EDependencyMode m_eLastUsage;
+	VulkanCommandSwapchainDepenency_t m_dependency;
+};
+
 class CVkCommandBuffer: public IVkCommandBuffer
 {
 public:
@@ -16,12 +30,15 @@ public:
 	virtual void Render() override;
 private:
 	void SortDependencies();
-	void TryBarrier();
+	void TryBarrier( int iCurrent, int iCurrentBuffer );
 	VulkanCommandDepenency_t *FindLastObjectDependency( IRenderingObject *pObject );
 
-	CUtlSelfReferencingVector<CVkCommand*> m_commands;
+	CUtlVector<CVkCommand*> m_commands;
 	CUtlVector<VkCommandBuffer> m_hBuffers = NULL;
-	CUtlVector<VulkanCommandDepenency_t> m_usedDependencies;
+	CUtlVector<VulkanCommandLastUsage_t> m_usedDependencies; 
+	CUtlVector<CUtlVector<VulkanCommandLastUsage_t>> m_dependencies; 
+	CUtlVector<VulkanSwapchainCommandLastUsage_t> m_usedSwapchainDependencies; 
+	CUtlVector<CUtlVector<VulkanSwapchainCommandLastUsage_t>> m_swapchainDependencies; 
 };
 
 void CVkCommandBuffer::Reset()
@@ -65,17 +82,22 @@ void CVkCommandBuffer::Render()
 
 	uint32_t nNumDependencies;
 	int i = 0;
+	int y = 0;
+
+	SortDependencies();
 	
 	for (auto hBuffer: m_hBuffers)
 	{
+		y = 0;
 		VkCommandBufferBeginInfo stCommandBufferBeginInfo = {};
 		stCommandBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 		vkBeginCommandBuffer(hBuffer, &stCommandBufferBeginInfo);
 
 		for (auto &pCommand: m_commands)
 		{
-			TryBarrier();
+			TryBarrier(y,i);
 			pCommand->Execute(hBuffer, i);
+			y++;
 		};
 		vkEndCommandBuffer(hBuffer);
 		
@@ -89,33 +111,161 @@ struct VulkanCommandBarrier_t
 	EDependencyMode m_eNewDependency;
 	IRenderingObject *m_pObject;
 };
+
 void CVkCommandBuffer::SortDependencies()
 {
+	m_dependencies = {};
+	m_swapchainDependencies = {};
+	m_dependencies.Resize(m_commands.GetSize());
+	m_swapchainDependencies.Resize(m_commands.GetSize());
+	m_usedDependencies = {};
+	m_usedSwapchainDependencies = {};
 	
-}
+	int i = 0;
+	for ( auto dependency: m_dependencies)
+	{
+		dependency = NULL;
+	}
 
-void CVkCommandBuffer::TryBarrier()
-{
-	CUtlVector<VulkanCommandBarrier_t> barriers;
 	for (auto &pCommand: m_commands)
 	{
-		for ( auto dependency: pCommand->m_depedencies)
+		for ( auto dependency: pCommand->m_dependencies)
+		{
+			VulkanCommandLastUsage_t *pLastUsage = NULL;
+
+			for ( auto &dep: m_usedDependencies )
+			{
+				if (dep.m_dependency.m_pObject == dependency.m_pObject)
+					pLastUsage = &dep;
+			}
+
+			VulkanCommandLastUsage_t stLastUsage = {};
+			stLastUsage.m_nLastUsedCommand = i;
+			stLastUsage.m_dependency = dependency;
+			stLastUsage.m_eLastUsage = DEPENDENCY_MODE_FROM_PREVIOUS;
+
+			if (pLastUsage)
+				stLastUsage.m_eLastUsage = pLastUsage->m_dependency.m_eDependencyMode;
+
+			if (pLastUsage)
+				m_dependencies[pLastUsage->m_nLastUsedCommand+1].AppendTail(stLastUsage);
+			else
+				m_dependencies[0].AppendTail(stLastUsage);
+
+			m_usedDependencies.AppendTail(stLastUsage);
+		}
+		for ( auto dependency: pCommand->m_swapchainDependencies)
+		{
+			VulkanSwapchainCommandLastUsage_t *pLastUsage = NULL;
+
+			for ( auto &dep: m_usedSwapchainDependencies )
+			{
+				if (dep.m_dependency.m_ppObjects == dependency.m_ppObjects)
+					pLastUsage = &dep;
+			}
+
+			VulkanSwapchainCommandLastUsage_t stLastUsage = {};
+			stLastUsage.m_nLastUsedCommand = i;
+			stLastUsage.m_dependency = dependency;
+			stLastUsage.m_eLastUsage = DEPENDENCY_MODE_FROM_PREVIOUS;
+
+			if (pLastUsage)
+				stLastUsage.m_eLastUsage = pLastUsage->m_dependency.m_eDependencyMode;
+
+			if (pLastUsage)
+				m_swapchainDependencies[pLastUsage->m_nLastUsedCommand+1].AppendTail(stLastUsage);
+			else
+				m_swapchainDependencies[0].AppendTail(stLastUsage);
+
+			m_usedSwapchainDependencies.AppendTail(stLastUsage);
+		}
+		i++;
+	}
+}
+
+
+void CVkCommandBuffer::TryBarrier( int iCurrent, int iCurrentBuffer )
+{
+	int x = 0;
+	CUtlVector<VulkanCommandLastUsage_t> dependency = m_dependencies[iCurrent];
+	CUtlVector<VulkanSwapchainCommandLastUsage_t> swapchainDependency = m_swapchainDependencies[iCurrent];
+	CUtlVector<VulkanCommandBarrier_t> barriers;
+
+	VkDependencyInfo stDependencyInfo = {};
+	stDependencyInfo.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
+	CUtlVector<VkMemoryBarrier2> memoryBarriers = {};
+	CUtlVector<VkImageMemoryBarrier2> imageBarriers = {};
+	CUtlVector<VkBufferMemoryBarrier2> bufferBarriers = {};
+
+	for (auto barrier: dependency)
+	{
+		VulkanCommandBarrier_t stBarrier = {};
+		stBarrier.m_eOldDependency = barrier.m_eLastUsage;
+		stBarrier.m_eNewDependency = barrier.m_dependency.m_eDependencyMode;
+		stBarrier.m_pObject = barrier.m_dependency.m_pObject;
+		barriers.AppendTail(stBarrier);
+		x++;
+	};
+	x = 0;
+	for (auto barrier: swapchainDependency)
+	{
+		VulkanCommandBarrier_t stBarrier = {};
+		stBarrier.m_eOldDependency = barrier.m_eLastUsage;
+		stBarrier.m_eNewDependency = barrier.m_dependency.m_eDependencyMode;
+		stBarrier.m_pObject = barrier.m_dependency.m_ppObjects[iCurrentBuffer];
+		barriers.AppendTail(stBarrier);
+		x++;
+	};
+	for ( auto barrier: barriers )
+	{
+		union {
+			IRenderingObject *pObject;
+			CVkImage *pImage;
+			CVkBuffer *pBuffer;
+		};
+
+		pObject = barrier.m_pObject;
+
+		if (dynamic_cast<CVkImage*>(pObject))
+		{
+			
+			VkImageMemoryBarrier2 imageMemoryBarrier = {};
+			imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
+			imageMemoryBarrier.image = pImage->m_image;
+			imageMemoryBarrier.subresourceRange = pImage->m_range;
+			imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+			imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+			imageMemoryBarrier.newLayout = VulkanGetImageLayout(barrier.m_eNewDependency);
+			imageMemoryBarrier.dstStageMask = VulkanGetStageFlags(barrier.m_eNewDependency);
+			imageMemoryBarrier.dstAccessMask = VulkanGetAccessFlags(barrier.m_eNewDependency);
+			if (barrier.m_eOldDependency == DEPENDENCY_MODE_FROM_PREVIOUS)
+			{	
+				imageMemoryBarrier.oldLayout = VulkanGetImageLayout(pImage->m_eLastUsage);
+				imageMemoryBarrier.srcStageMask = VulkanGetStageFlags(pImage->m_eLastUsage);
+				imageMemoryBarrier.srcAccessMask = VulkanGetAccessFlags(pImage->m_eLastUsage);
+			} else {
+				imageMemoryBarrier.oldLayout = VulkanGetImageLayout(barrier.m_eOldDependency);
+				imageMemoryBarrier.srcStageMask = VulkanGetStageFlags(barrier.m_eOldDependency);
+				imageMemoryBarrier.srcAccessMask = VulkanGetAccessFlags(barrier.m_eOldDependency);
+			}
+			imageBarriers.AppendTail(imageMemoryBarrier);
+			
+			pImage->m_eLastUsage = barrier.m_eNewDependency;
+		}
+		if (dynamic_cast<CVkBuffer*>(pObject))
 		{
-			VulkanCommandDepenency_t *pLastDependency = FindLastObjectDependency(dependency.m_pObject);
 		}
 	}
-};
 
-VulkanCommandDepenency_t *CVkCommandBuffer::FindLastObjectDependency( IRenderingObject *pObject )
+	if (imageBarriers.GetSize() == 0 && bufferBarriers.GetSize() == 0 )
-{
+		return;
-	VulkanCommandDepenency_t *pDependency = NULL;
+
-	for ( auto &dependency: m_usedDependencies )
+	stDependencyInfo.imageMemoryBarrierCount = imageBarriers.GetSize();
-	{
+	stDependencyInfo.bufferMemoryBarrierCount = bufferBarriers.GetSize();
-		if ( dependency.m_pObject == pObject )
+	stDependencyInfo.pImageMemoryBarriers = imageBarriers.GetData();
-			pDependency = &dependency;
+	stDependencyInfo.pBufferMemoryBarriers = bufferBarriers.GetData();
-	}
+	vkCmdPipelineBarrier2(m_hBuffers[iCurrentBuffer], &stDependencyInfo);
-	return pDependency;
+};
-}
 
 class CVkCommandBufferManager: public IVkCommandBufferManager
 {
@@ -175,5 +325,10 @@ CVkCommandRegistry::CVkCommandRegistry( const char *szName, fnCreateVulkanComman
 
 void CVkCommand::AddDependency( IRenderingObject *pObject, EDependencyMode eDependencyMode )
 {
-	m_depedencies.AppendTail({ pObject, eDependencyMode });
+	m_dependencies.AppendTail({ pObject, eDependencyMode });
 }
+void CVkCommand::AddSwapchainDependency( IRenderingObject **ppObject, EDependencyMode eDependencyMode )
+{
+	m_swapchainDependencies.AppendTail({ ppObject, eDependencyMode });
+}
+

materialsystem/vulkan/commands.h

@@ -1,6 +1,7 @@
 #ifndef VULKAN_COMMANDS_H
 #define VULKAN_COMMANDS_H
 
+#include "tier1/utlvector.h"
 #include "vulkan_state.h"
 
 BEGIN_VULKAN_COMMAND(ClearColor)
@@ -12,4 +13,29 @@ BEGIN_VULKAN_COMMAND(ClearColor)
 	IImage **ppSwapchainImages = NULL;
 END_VULKAN_COMMAND(ClearColor)
 
+struct VulkanRenderOutput_t {
+	EResolveMode m_eResolveMode;
+
+	VkFrameObject_t m_stImage;
+	VkFrameObject_t m_stResolveImage;
+
+	ELoadMode m_eLoadMode;
+	EStoreMode m_eStoreMode;
+};
+
+BEGIN_VULKAN_COMMAND(Begin)
+	CUtlVector<VulkanRenderOutput_t> images;
+	VulkanRenderOutput_t stDepthImage;
+	uint32_t nResolutionX;
+	uint32_t nResolutionY;
+
+	
+END_VULKAN_COMMAND(Begin)
+
+BEGIN_VULKAN_COMMAND(End)
+END_VULKAN_COMMAND(End)
+
+BEGIN_VULKAN_COMMAND(Empty)
+END_VULKAN_COMMAND(Empty)
+
 #endif

materialsystem/vulkan/commands/base.cpp

@@ -0,0 +1,7 @@
+#include "../vulkan_state.h"
+#include "../commands.h"
+#include "tier0/platform.h"
+
+DECLARE_VULKAN_COMMAND(Empty)
+{
+}

materialsystem/vulkan/commands/draw.cpp

@@ -1,6 +1,9 @@
 #include "../vulkan_state.h"
 #include "../commands.h"
+#include "materialsystem/imaterialsystem.h"
 #include "tier0/platform.h"
+#include "tier1/utlvector.h"
+#include "vulkan/vulkan_core.h"
 
 
 DECLARE_VULKAN_COMMAND(ClearColor)
@@ -8,7 +11,6 @@ DECLARE_VULKAN_COMMAND(ClearColor)
 
 	CVkImage *pImg;
 
-	pImage = NULL;
 	if (pImage)
 		pImg = (CVkImage*)pImage;
 	if (ppSwapchainImages)
@@ -17,7 +19,6 @@ DECLARE_VULKAN_COMMAND(ClearColor)
 	if (pImg == NULL)
 		Plat_FatalErrorFunc("pImage and *ppSwapchainImages are NULL\n");
 
-	AddDependency(pImg, DEPENDENCY_MODE_IMAGE_DESTINATION);
 
 	VkClearColorValue color = {.float32 = {r,g,b,a}};
 	VkImageSubresourceRange range = {
@@ -27,3 +28,31 @@ DECLARE_VULKAN_COMMAND(ClearColor)
 	};
 	vkCmdClearColorImage(hCommandBuffer, pImg->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &color, 1, &range);
 }
+
+DECLARE_VULKAN_COMMAND(Begin)
+{
+	VkRenderingInfo stRenderingInfo = {};
+	CUtlVector<VkRenderingAttachmentInfo> attachments;
+	for (auto i: images)
+	{
+		VkRenderingAttachmentInfo a;
+		a.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
+		a.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+		a.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+		a.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+		a.imageView = ((CVkImage*)VulkanGetObject(i.m_stImage, iCurrentFrame))->m_imageView;
+		attachments.AppendTail(a);
+	}
+
+	stRenderingInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
+	stRenderingInfo.layerCount = 1;
+	stRenderingInfo.colorAttachmentCount = attachments.GetSize();
+	stRenderingInfo.pColorAttachments = attachments.GetData();
+	
+	vkCmdBeginRendering(hCommandBuffer, &stRenderingInfo);
+}
+
+DECLARE_VULKAN_COMMAND(End)
+{
+	vkCmdEndRendering(hCommandBuffer);
+}

materialsystem/vulkan/libraries/raster.cpp

@@ -0,0 +1,57 @@
+#include "../vulkan_state.h"
+#include "../raster_libraries.h"
+#include "tier1/utlbuffer.h"
+#include "tier2/ifilesystem.h"
+#include "vulkan/vulkan_core.h"
+
+BEGIN_BUILD_PIPELINE_LIBRARY(Functions)
+	CUtlBuffer<unsigned char> vertexShaderData;
+	VkShaderModuleCreateInfo stVertexModule = {}; 
+	VkPipelineShaderStageCreateInfo stVertexStage = {};
+	if (szVertexShader)
+	{
+
+		IFileHandle *pFile = filesystem->Open(szVertexShader, FILEMODE_READ);
+		vertexShaderData = filesystem->Read(pFile);
+		pFile->Close();
+
+		stVertexModule.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+		stVertexModule.codeSize = vertexShaderData.GetSize();
+		stVertexModule.pCode = (uint32_t*)vertexShaderData.GetMemory();
+
+		stVertexStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+		stVertexStage.pName = szVertexShaderMain;
+		stVertexStage.pNext = &stVertexModule;
+	}
+
+	CUtlBuffer<unsigned char> pixelShaderData;
+	VkShaderModuleCreateInfo stPixelModule = {}; 
+	VkPipelineShaderStageCreateInfo stPixelStage = {};
+	if (szPixelShader)
+	{
+
+		IFileHandle *pFile = filesystem->Open(szPixelShader, FILEMODE_READ);
+		pixelShaderData = filesystem->Read(pFile);
+		pFile->Close();
+
+		stPixelModule.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+		stPixelModule.codeSize = pixelShaderData.GetSize();
+		stPixelModule.pCode = (uint32_t*)pixelShaderData.GetMemory();
+
+		stPixelStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+		stPixelStage.pName = szPixelShaderMain;
+		stPixelStage.pNext = &stPixelModule;
+	}
+END_BUILD_PIPELINE_LIBRARY()
+void CVkFunctionsPipelineLibrary::SetVertex( const char *szFile, const char *szMain )
+{
+	szVertexShader = szFile;
+	szVertexShaderMain = szMain;
+}
+
+void CVkFunctionsPipelineLibrary::SetPixel( const char *szFile, const char *szMain )
+{
+	szPixelShader = szFile;
+	szPixelShaderMain = szMain;
+}
+

materialsystem/vulkan/raster_libraries.h

@@ -0,0 +1,36 @@
+#include "vulkan_state.h"
+
+BEGIN_DEFINE_PIPELINE_LIBRARY(Functions)
+private:
+	const char *szVertexShader;
+	const char *szVertexShaderMain;
+	const char *szPixelShader;
+	const char *szPixelShaderMain;
+public:
+	void SetVertex( const char *szFile, const char *szMain );
+	void SetPixel( const char *szFile, const char *szMain );
+END_DEFINE_PIPELINE_LIBRARY()
+
+BEGIN_DEFINE_PIPELINE_LIBRARY(VertexInput)
+END_DEFINE_PIPELINE_LIBRARY()
+
+BEGIN_DEFINE_PIPELINE_LIBRARY(InputAssembly)
+END_DEFINE_PIPELINE_LIBRARY()
+
+BEGIN_DEFINE_PIPELINE_LIBRARY(Tesselation)
+END_DEFINE_PIPELINE_LIBRARY()
+
+BEGIN_DEFINE_PIPELINE_LIBRARY(ViewportState)
+END_DEFINE_PIPELINE_LIBRARY()
+
+BEGIN_DEFINE_PIPELINE_LIBRARY(RasterizationState)
+END_DEFINE_PIPELINE_LIBRARY()
+
+BEGIN_DEFINE_PIPELINE_LIBRARY(MultisampleState)
+END_DEFINE_PIPELINE_LIBRARY()
+
+BEGIN_DEFINE_PIPELINE_LIBRARY(DepthStencilState)
+END_DEFINE_PIPELINE_LIBRARY()
+
+BEGIN_DEFINE_PIPELINE_LIBRARY(ColorBlend)
+END_DEFINE_PIPELINE_LIBRARY()

materialsystem/vulkan/rendercontext.cpp

@@ -10,6 +10,7 @@
 #include "vulkan/vulkan_core.h"
 #include "vulkan_state.h"
 #include "igamewindow.h"
+#include "raster_libraries.h"
 
 
 #define REQUIRED_EXTENSION(ext) ext##_EXTENSION_NAME,
@@ -126,6 +127,7 @@ void CVkImage::CreateImageView()
 		stImageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
 	stImageViewCreateInfo.subresourceRange.layerCount = 1;
 	stImageViewCreateInfo.subresourceRange.levelCount = 1;
+	m_range = stImageViewCreateInfo.subresourceRange;
 	vkCreateImageView(g_vkDevice, &stImageViewCreateInfo, NULL, &m_imageView);
 }
 void CVkImage::SetDebugName( const char *szName )
@@ -155,25 +157,6 @@ EMultisampleType CVkImage::GetMultisampleType()
 }
 
 
-class CVkBuffer: public IBuffer
-{
-public:
-	CVkBuffer( uint32_t nSize, VkBufferUsageFlags2 eUsage, uint32_t nAlignment );
-	~CVkBuffer();
-
-	virtual void SetDebugName( const char *szName ) override;
-	virtual void Lock() override;
-	virtual void Unlock() override;
-	virtual void *Map() override;
-	virtual void Unmap() override;
-	virtual uint32_t GetSize() override;
-
-	VmaAllocation allocation;
-	VkBuffer buffer;
-	VkDeviceAddress address;
-	uint32_t nSize;
-};
-
 CVkBuffer::CVkBuffer( uint32_t nSize, VkBufferUsageFlags2 eUsage, uint32_t nAlignment )
 {
 }
@@ -360,8 +343,7 @@ void CVkRenderContext::DrawPrimitivesIndexed( uint32_t nIndexCount, uint32_t nFi
 }
 
 IVkCommandBuffer *pCommandBuffer;
-IVkCommandBuffer *s_pPresentCommandBuffer;
+static IVkCommandBuffer *s_pPresentCommandBuffer;
-IImage *pCurrentImage;
 void CVkRenderContext::Init()
 {
 	VkResult r;
@@ -448,11 +430,16 @@ void CVkRenderContext::Init()
 	stDeviceQueueCreateInfo.pQueuePriorities = &fPriority;
 	stDeviceQueueCreateInfo.queueFamilyIndex = g_iDrawFamily;
 
+	VkPhysicalDeviceVulkan13Features vk13Features = {};
+	vk13Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
+	vk13Features.synchronization2 = VK_TRUE;
+
 	stDeviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
 	stDeviceCreateInfo.queueCreateInfoCount = 1;
 	stDeviceCreateInfo.pQueueCreateInfos = &stDeviceQueueCreateInfo;
 	stDeviceCreateInfo.enabledExtensionCount = enabledDeviceExtensions.GetSize();
 	stDeviceCreateInfo.ppEnabledExtensionNames = enabledDeviceExtensions.GetData();
+	stDeviceCreateInfo.pNext = &vk13Features;
 	r = vkCreateDevice(g_vkPhysicalDevice, &stDeviceCreateInfo, NULL, &g_vkDevice);
 	VULKAN_RESULT_PRINT(r, vkEnumeratePhysicalDevices);
 	for (auto &extension: enabledDeviceExtensions)
@@ -477,21 +464,44 @@ void CVkRenderContext::Init()
 	g_pCommandBufferManager->Init();
 
 	pCommandBuffer = g_pCommandBufferManager->CreateCommandBuffer();
+	s_pPresentCommandBuffer = g_pCommandBufferManager->CreateCommandBuffer();
+
 	CVkClearColorCommand *pCommand = (CVkClearColorCommand*)g_pCommandBufferManager->CreateCommand("ClearColor");
 	
 	pCommand->pImage = NULL;
 	pCommand->ppSwapchainImages = g_vkSwapchainImages.GetData();
 	pCommand->r = 1;
 	pCommand->b = 1;
+	pCommand->g = 0;
+	pCommand->AddSwapchainDependency( (IRenderingObject**)g_vkSwapchainImages.GetData(), DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION );
+
+	CVkFunctionsPipelineLibrary functions = {};
+	functions.SetVertex("funnygame/shaders/flat.spv", "vsMain");
+	functions.SetPixel("funnygame/shaders/flat.spv", "psMain");
+	functions.Build();
+
+	CVkEmptyCommand *pPresentCommand = (CVkEmptyCommand*)g_pCommandBufferManager->CreateCommand("Empty");	
+	pPresentCommand->AddSwapchainDependency( (IRenderingObject**)g_vkSwapchainImages.GetData(), DEPENDENCY_MODE_IMAGE_PRESENT );
+
+	CVkBeginCommand *pBeginCommand = (CVkBeginCommand*)g_pCommandBufferManager->CreateCommand("Empty");
+	pBeginCommand->AddSwapchainDependency((IRenderingObject**)g_vkSwapchainImages.GetData(), DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE);
+	CVkBeginCommand *pEndCommand = (CVkBeginCommand*)g_pCommandBufferManager->CreateCommand("Empty");
 
 	pCommandBuffer->Reset();
 	pCommandBuffer->AddCommand(pCommand);
 	pCommandBuffer->Render();
 
+	s_pPresentCommandBuffer->Reset();
+	s_pPresentCommandBuffer->AddCommand(pPresentCommand);
+	s_pPresentCommandBuffer->Render();
 }
 
 void CVkRenderContext::Frame( float fDeltaTime )
 {
+	vkDeviceWaitIdle(g_vkDevice);
+	pCommandBuffer->Render();
+	s_pPresentCommandBuffer->Render();
+
 	static uint32_t s_nImageIndex = 0;
 	uint32_t nImageIndex = 0;
 
@@ -500,6 +510,11 @@ void CVkRenderContext::Frame( float fDeltaTime )
 
 	vkResetFences(g_vkDevice, 1, &g_vkFences[s_nImageIndex]);
 
+	g_vkCommandBuffers = {};
+
+	pCommandBuffer->Submit(nImageIndex);
+	s_pPresentCommandBuffer->Submit(nImageIndex);
+	
 	VkPipelineStageFlags uPipelineStageFlags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 	VkSubmitInfo stSubmitInfo = {};
 	stSubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
@@ -507,10 +522,6 @@ void CVkRenderContext::Frame( float fDeltaTime )
 	stSubmitInfo.pWaitSemaphores = &g_vkGraphicsSemaphores[s_nImageIndex];
 	stSubmitInfo.pWaitDstStageMask = &uPipelineStageFlags;
 	
-	pCurrentImage = g_vkSwapchainImages[nImageIndex];
-	g_vkCommandBuffers = {};
-	pCommandBuffer->Submit(nImageIndex);
-	
 	stSubmitInfo.commandBufferCount = g_vkCommandBuffers.GetSize();
 	stSubmitInfo.pCommandBuffers = g_vkCommandBuffers.GetData();
 	

materialsystem/vulkan/shader.cpp

@@ -0,0 +1,3 @@
+#include "vulkan_state.h"
+
+

materialsystem/vulkan/utils.cpp

@@ -0,0 +1,50 @@
+#include "vulkan_state.h"
+
+IRenderingObject *VulkanGetObject( VkFrameObject_t stObject, int iIndex )
+{
+	switch (stObject.m_eObjectType)
+	{
+	case FRAME_OBJECT_TYPE_SINGLE:
+		return stObject.m_pSingle;
+	case FRAME_OBJECT_TYPE_SWAPPED:
+		return stObject.m_ppSwapped[iIndex];
+	default:
+		return NULL;
+	}
+}
+
+VkAccessFlags2 VulkanGetAccessFlags( EDependencyMode eMode )
+{
+	switch (eMode)
+	{
+	case DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE: return VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR; 
+	case DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION: return VK_ACCESS_2_TRANSFER_WRITE_BIT; 
+	case DEPENDENCY_MODE_IMAGE_PRESENT: return VK_ACCESS_2_NONE;
+	default:
+		return 0;
+	}
+}
+
+VkPipelineStageFlags2 VulkanGetStageFlags( EDependencyMode eMode )
+{
+	switch (eMode)
+	{
+	case DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE: return VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT; 
+	case DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION: return VK_PIPELINE_STAGE_2_TRANSFER_BIT; 
+	case DEPENDENCY_MODE_IMAGE_PRESENT: return VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT; 
+	default:
+		return VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
+	}
+}
+
+VkImageLayout VulkanGetImageLayout( EDependencyMode eMode )
+{
+	switch (eMode)
+	{
+	case DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE: return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; 
+	case DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION: return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; 
+	case DEPENDENCY_MODE_IMAGE_PRESENT: return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; 
+	default:
+		return VK_IMAGE_LAYOUT_UNDEFINED;
+	}
+}

materialsystem/vulkan/vulkan_state.h

@@ -58,13 +58,20 @@ enum EDependencyMode
 	DEPENDENCY_MODE_DRAWCALL_VERTEX_BUFFER,
 	DEPENDENCY_MODE_DRAWCALL_INDEX_BUFFER,
 	DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE,
+	DEPENDENCY_MODE_DRAWCALL_INPUT_IMAGE,
+	DEPENDENCY_MODE_DRAWCALL_MIXED_IMAGE,
 
 	DEPENDENCY_MODE_IMAGE_SOURCE,
 	DEPENDENCY_MODE_IMAGE_DESTINATION,
 	
+	DEPENDENCY_MODE_COLOR_CLEAR_SOURCE,
+	DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION,
+	
 	DEPENDENCY_MODE_ALL_COMMANDS,
 	DEPENDENCY_MODE_IMAGE_PRESENT,
 
+	DEPENDENCY_MODE_FROM_PREVIOUS,
+
 	DEPENDENCY_MODE_COUNT,
 };
 
@@ -73,6 +80,10 @@ struct VulkanCommandDepenency_t {
 	IRenderingObject *m_pObject;
 	EDependencyMode m_eDependencyMode;
 };
+struct VulkanCommandSwapchainDepenency_t {
+	IRenderingObject **m_ppObjects;
+	EDependencyMode m_eDependencyMode;
+};
 
 struct VulkanCommandParameter_t
 {
@@ -90,10 +101,12 @@ public:
 	virtual void Execute( VkCommandBuffer hCommandBuffer, int iCurrentFrame ) = 0;
 	//virtual const char *GetName();
 
-	CUtlVector<VulkanCommandDepenency_t> m_depedencies;
+	CUtlVector<VulkanCommandDepenency_t> m_dependencies = {};
+	CUtlVector<VulkanCommandSwapchainDepenency_t> m_swapchainDependencies = {};
 	EVulkanCommandType m_eType;
-protected:
+	
 	void AddDependency( IRenderingObject *pObject, EDependencyMode eDependencyMode );
+	void AddSwapchainDependency( IRenderingObject **ppObjects, EDependencyMode eDependencyMode );
 };
 
 abstract_class IVkCommandBuffer
@@ -173,9 +186,88 @@ public:
 	VkImage m_image;
 	VkImageView m_imageView;
 	VmaAllocation m_allocation;
+	VkImageSubresourceRange m_range;
 
 	VkImageLayout m_eImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 	EDependencyMode m_eLastUsage;
 };
 
+class CVkBuffer: public IBuffer
+{
+public:
+	CVkBuffer( uint32_t nSize, VkBufferUsageFlags2 eUsage, uint32_t nAlignment );
+	~CVkBuffer();
+
+	virtual void SetDebugName( const char *szName ) override;
+	virtual void Lock() override;
+	virtual void Unlock() override;
+	virtual void *Map() override;
+	virtual void Unmap() override;
+	virtual uint32_t GetSize() override;
+
+	VmaAllocation allocation;
+	VkBuffer buffer;
+	VkDeviceAddress address;
+	uint32_t nSize;
+};
+
+class CVkPipelineLibrary
+{
+public:
+	virtual void Build() = 0;
+
+	VkPipeline m_hPipeline = NULL;
+};
+
+#define BEGIN_DEFINE_PIPELINE_LIBRARY(name) \
+class CVk##name##PipelineLibrary: public CVkPipelineLibrary \
+{ \
+public: \
+	virtual void Build() override; \
+
+#define END_DEFINE_PIPELINE_LIBRARY() \
+};
+
+#define BEGIN_BUILD_PIPELINE_LIBRARY(name) \
+void CVk##name##PipelineLibrary::Build() \
+{ \
+	VkGraphicsPipelineCreateInfo pipeline = {}; \
+	pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; \
+
+#define END_BUILD_PIPELINE_LIBRARY() \
+	vkCreateGraphicsPipelines(g_vkDevice, NULL, 1, &pipeline, NULL, &m_hPipeline); \
+}
+
+class CVkShader : IShader
+{
+public:
+	void AddShaderLibrary( CVkPipelineLibrary *pLibrary );
+	void Build();
+	VkPipeline m_hPipeline = NULL;
+	VkPipelineLayout m_hPipelineLayout;
+	CUtlVector<CVkPipelineLibrary*> m_libraries;
+};
+
+enum EVkFrameObjectType_t
+{
+	FRAME_OBJECT_TYPE_SINGLE,
+	FRAME_OBJECT_TYPE_SWAPPED,
+};
+
+struct VkFrameObject_t
+{
+	EVkFrameObjectType_t m_eObjectType;
+	union {
+		IRenderingObject *m_pSingle;
+		IRenderingObject **m_ppSwapped;
+	};
+};
+
+
+IRenderingObject *VulkanGetObject( VkFrameObject_t stObject, int iIndex );
+
+VkAccessFlags2 VulkanGetAccessFlags( EDependencyMode eMode );
+VkPipelineStageFlags2 VulkanGetStageFlags( EDependencyMode eMode );
+VkImageLayout VulkanGetImageLayout( EDependencyMode eMode );
+
 #endif

public/materialsystem/imaterialsystem.h

@@ -38,6 +38,37 @@ enum EMultisampleType
 	MULTISAMPLE_TYPE_8_SAMPLES,
 };
 
+enum EResolveMode
+{
+	RESOLVE_MODE_NONE,
+	RESOLVE_MODE_ZERO,
+	RESOLVE_MODE_AVERAGE,
+	RESOLVE_MODE_MIN,
+	RESOLVE_MODE_MAX,
+};
+
+enum ELoadMode
+{
+	LOAD_MODE_LOAD,
+	LOAD_MODE_CLEAR,
+	LOAD_MODE_DONT_CARE,
+};
+
+enum EStoreMode
+{
+	STORE_MODE_STORE,
+	STORE_MODE_DONT_CARE,
+};
+
+enum ETopologyMode
+{
+	TOPOLOGY_MODE_POINT_LIST,
+	TOPOLOGY_MODE_LINE_LIST,
+	TOPOLOGY_MODE_LINE_STRIP,
+	TOPOLOGY_MODE_TRIANGLE_LIST,
+	TOPOLOGY_MODE_TRIANGLE_STRIP,
+};
+
 abstract_class IRenderingObject
 {
 public:
@@ -49,7 +80,7 @@ abstract_class IBuffer : public IRenderingObject
 public:
 	virtual void Lock() = 0;
 	virtual void Unlock() = 0;
-	virtual void *Map() = 0;
+virtual void *Map() = 0;
 	virtual void Unmap() = 0;
 
 	virtual uint32_t GetSize() = 0;

public/tier2/ifilesystem.h

@@ -3,6 +3,7 @@
 
 #include "iappsystem.h"
 #include "tier0/platform.h"
+#include "tier1/utlbuffer.h"
 
 enum EFileMode
 {
@@ -55,6 +56,9 @@ public:
 
 	virtual void Close( IFileHandle *pFile ) = 0;
 
+	// Some cool stuff
+	virtual CUtlBuffer<unsigned char> Read( IFileHandle *pFile ) = 0;
+
 	IFileSystem *m_pNext;
 	
 	void RegisterFileSystem();

tier2/filesystem.cpp

@@ -1,6 +1,8 @@
+#include "tier1/utlbuffer.h"
 #include "tier2/ifilesystem.h"
 #include "tier1/interface.h"
 #include "tier0/lib.h"
+#include <cstdio>
 
 size_t IFileHandle::Write( const void *pData, size_t nDataSize )
 {
@@ -83,6 +85,15 @@ public:
 	{
 
 	}
+	virtual CUtlBuffer<unsigned char> Read( IFileHandle *pFile ) override
+	{
+		CUtlBuffer<unsigned char> buffer;
+		buffer = CUtlBuffer<unsigned char>(Size(pFile));
+
+		Read(pFile, buffer.GetMemory(), buffer.GetSize());
+		
+		return buffer;
+	}
 };
 
 

tier2/filesystem_libc.cpp

@@ -107,6 +107,8 @@ public:
 		V_fclose(pHandle->m_pFile);
 		delete pHandle;
 	}
+
+	virtual CUtlBuffer<unsigned char> Read( IFileHandle *pFile ) override { return NULL; }; 
 };
 
 EXPOSE_FILESYSTEM(CLIBCFileSystem, "sysfs");