global update

.fpccfg

@@ -9,7 +9,11 @@ sysroot = "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.
 
 [x86_64-linux-android]
 sysroot = "/home/kotofyt/Android/Sdk/ndk/29.0.13599879/toolchains/llvm/prebuilt/linux-x86_64/sysroot"
-"clang++" = "/home/kotofyt/Android/Sdk/ndk/29.0.13599879/toolchains/llvm/prebuilt/linux-x86_64/bin/clang++"
-
-[Android_Build_Tools]
+cc = "/home/kotofyt/Android/Sdk/ndk/29.0.13599879/toolchains/llvm/prebuilt/linux-x86_64/bin/clang"
 path = "/home/kotofyt/Android/Sdk/build-tools/36.0.0"
+
+[aarch64-linux-android]
+sysroot = "/home/kotofyt/Downloads/android-ndk-r29/toolchains/llvm/prebuilt/linux-x86_64/sysroot"
+cc = "/home/kotofyt/Downloads/android-ndk-r29/toolchains/llvm/prebuilt/linux-x86_64/bin/clang"
+"clang++" = "/home/kotofyt/Downloads/android-ndk-r29/toolchains/llvm/prebuilt/linux-x86_64/bin/clang++"
+build_tools = "/home/kotofyt/Android/Sdk/build-tools/36.0.0"

engine/engine.cpp

@@ -42,6 +42,7 @@ extern "C" void __cdecl SteamAPIDebug( ESteamNetworkingSocketsDebugOutputType nT
 	V_printf("STEAM: %s\n", pszMsg);
 }
 #endif
+#include "time.h"
 
 extern "C" void FunnyMain( int argc, char **argv )
 {
@@ -124,7 +125,6 @@ extern "C" void FunnyMain( int argc, char **argv )
 	Console()->Execute();
 	double fPrevious = Plat_GetTime();
 	for (;;) {
-
 		if (!stConstants.m_bIsDedicated)
 		{
 			if (pWindow->IsValid() == false)
@@ -145,8 +145,6 @@ extern "C" void FunnyMain( int argc, char **argv )
 		g_pHumanDeviceManager->Frame();
 		g_pServerGame->m_pBridge->Frame(fDelta);
 
-		fCurrent = Plat_GetTime();
-
 		if (!stConstants.m_bIsDedicated)
 		{
 

engine/kottui.cpp

@@ -318,10 +318,6 @@ void CKotUIBuffer::Draw( IImage *pImage )
 	pList->SetLoadStoreModes(0, LOAD_MODE_LOAD, STORE_MODE_STORE);
 	pList->SetRenderResolution(pImage->GetImageWidth(), pImage->GetImageHeight());
 
-	pList->Barrier(m_pDataBuffer, true, false);
-	pList->Barrier(pScreenBuffer, true, false);
-	pList->Barrier(m_pFont->GetAtlas(), true, false);
-
 	pList->SetMaterial(m_pMaterial);
 	pList->SetVertexBuffer(0, s_pGlyphBuffer);
 	pList->DrawPrimitives(6, 0, uRealGlyphCount, 0);

engine/openxr.cpp

@@ -1041,7 +1041,7 @@ void COpenXRHeadset::CreateSwapchainForEye( XrViewConfigurationView *pConf, VkFo
 	for ( int i = 0; i < imageCount; i++ )
 	{
 		pEye->m_pImages[i] = m_pManager->m_pRenderContext->CreateImageFromVkImage(
-				images[i].image, 
+				(uint64_t)images[i].image, 
 				createInfo.width,
 				createInfo.height,
 				VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,

game/client/game.cpp

@@ -85,9 +85,9 @@ void CFunnyGameBridge::Init()
 	g_pKotUI->ConnectInterface(g_pRenderContext, RENDER_CONTEXT_INTERFACE_VERSION);
 	g_pKotUI->Init();
 
-	g_pXRManager->ConnectInterface(g_pRenderContext, RENDER_CONTEXT_INTERFACE_VERSION);
-	g_pXRManager->Init();
-	g_pRenderContext->ConnectInterface(g_pXRManager, XR_INTERFACE_VERSION);
+	//g_pXRManager->ConnectInterface(g_pRenderContext, RENDER_CONTEXT_INTERFACE_VERSION);
+	//g_pXRManager->Init();
+	//g_pRenderContext->ConnectInterface(g_pXRManager, XR_INTERFACE_VERSION);
 
 
 	g_pWorldRenderer->Init();
@@ -96,6 +96,7 @@ void CFunnyGameBridge::Init()
 	m_pMainViewport->SetPosition({0,0,0});
 	m_pMainViewport->SetRotation({0,0,0,1});
 
+	/*
 	IXRHeadset *pHeadSet = g_pXRManager->GetHeadset(0);
 	if (pHeadSet)
 	{
@@ -116,8 +117,8 @@ void CFunnyGameBridge::Init()
 	{
 		pHeadSet->GetController(i)->SetInputCallback(XRInputCallback);
 		V_printf("callback set on %p\n", pHeadSet->GetController(i));
-
 	}
+	*/
 }
 
 void CFunnyGameBridge::Tick( float fDelta )
@@ -168,7 +169,7 @@ void CFunnyGameBridge::Frame( float fDelta )
 	TryToConnectToServer();
 
 
-	g_pXRManager->Frame();
+	//g_pXRManager->Frame();
 
 	INetworkBase *pCurrentServer = g_pServerBridge;
 	pCurrentServer = g_pServerBridge;

game/client/worldrender.cpp

@@ -49,11 +49,17 @@ void CFunnyViewport::UpdateResolution( uint32_t uX, uint32_t uY )
 		g_pRenderContext->DestroyImage(m_pRenderImage);
 	}
 	m_pColor = g_pRenderContext->CreateRenderTarget(uX, uY, IMAGE_FORMAT_RGBA8_UNORM, MULTISAMPLE_TYPE_4_SAMPLES);
+	m_pColor->SetDebugName("m_pColor");
 	m_pNormal = g_pRenderContext->CreateRenderTarget(uX, uY, IMAGE_FORMAT_RGBA16_SNORM, MULTISAMPLE_TYPE_4_SAMPLES);
+	m_pNormal->SetDebugName("m_pNormal");
 	m_pWorldCoords = g_pRenderContext->CreateRenderTarget(uX, uY, IMAGE_FORMAT_RGBA32_SFLOAT, MULTISAMPLE_TYPE_4_SAMPLES);
+	m_pWorldCoords->SetDebugName("m_pWorldCoords");
 	m_pDepth = g_pRenderContext->CreateRenderTarget(uX, uY, IMAGE_FORMAT_D32_SFLOAT, MULTISAMPLE_TYPE_4_SAMPLES);
+	m_pDepth->SetDebugName("m_pDepth");
 	m_pColorResolved = g_pRenderContext->CreateRenderTarget(uX, uY, IMAGE_FORMAT_RGBA8_UNORM, MULTISAMPLE_TYPE_1_SAMPLES);
+	m_pColorResolved->SetDebugName("m_pColorResolved");
 	m_pRenderImage = g_pRenderContext->CreateStorageImage(uX, uY, IMAGE_FORMAT_RGBA16_SFLOAT, MULTISAMPLE_TYPE_1_SAMPLES);
+	m_pRenderImage->SetDebugName("m_pRenderImage");
 	m_uX = uX;
 	m_uY = uY;
 }
@@ -319,6 +325,26 @@ void CFunnyWorldRenderer::Frame( float fDelta )
 		m_pViewBuffer->Unmap();
 
 		m_pRasterCommandList->StartRecording();
+		m_pRasterCommandList->BarrierTransition(
+				v->m_pColor, 
+				IMAGE_LAYOUT_UNDEFINED, IMAGE_LAYOUT_COLOR, 
+				STAGE_HAZARD_NONE, STAGE_HAZARD_RASTER_COLOR_OUT, 
+				BARRIER_HAZARD_RASTER_COLOR);
+		m_pRasterCommandList->BarrierTransition(
+				v->m_pNormal, 
+				IMAGE_LAYOUT_UNDEFINED, IMAGE_LAYOUT_COLOR, 
+				STAGE_HAZARD_NONE, STAGE_HAZARD_RASTER_COLOR_OUT, 
+				BARRIER_HAZARD_RASTER_COLOR);
+		m_pRasterCommandList->BarrierTransition(
+				v->m_pWorldCoords, 
+				IMAGE_LAYOUT_UNDEFINED, IMAGE_LAYOUT_COLOR, 
+				STAGE_HAZARD_NONE, STAGE_HAZARD_RASTER_COLOR_OUT, 
+				BARRIER_HAZARD_RASTER_COLOR);
+		m_pRasterCommandList->BarrierTransition(
+				v->m_pDepth, 
+				IMAGE_LAYOUT_UNDEFINED, IMAGE_LAYOUT_DEPTH_STENCIL, 
+				STAGE_HAZARD_NONE, STAGE_HAZARD_RASTER_EARLY_DEPTH_OUT, 
+				BARRIER_HAZARD_DEPTH_STENCIL);
 		m_pRasterCommandList->SetRenderResolution(uWidth, uHeight);
 		m_pRasterCommandList->SetRenderTarget(0, v->m_pColor);
 		m_pRasterCommandList->SetRenderTarget(1, v->m_pNormal);
@@ -373,15 +399,35 @@ void CFunnyWorldRenderer::Frame( float fDelta )
 			m_pRasterCommandList->DrawPrimitives(mesh->m_pVertexBuffer->GetSize()/32, 0, mesh->m_instances.GetSize(), u);
 			u += mesh->m_instances.GetSize();
 		}
+		m_pRasterCommandList->Barrier(STAGE_HAZARD_RASTER_COLOR_OUT, STAGE_HAZARD_NONE, 0);
+		m_pRasterCommandList->BarrierTransition(
+				v->m_pColor, 
+				IMAGE_LAYOUT_COLOR, IMAGE_LAYOUT_TRANSFER_SRC, 
+				STAGE_HAZARD_RASTER_COLOR_OUT, STAGE_HAZARD_TRANSFER, 
+				0);
+		m_pRasterCommandList->BarrierTransition(
+				v->m_pColorResolved, 
+				IMAGE_LAYOUT_UNDEFINED, IMAGE_LAYOUT_TRANSFER_DST, 
+				STAGE_HAZARD_NONE, STAGE_HAZARD_TRANSFER, 
+				0);
 
 		m_pRasterCommandList->ResolveImage(v->m_pColor, v->m_pColorResolved);
+		m_pRasterCommandList->BarrierTransition(
+				v->m_pColorResolved, 
+				IMAGE_LAYOUT_TRANSFER_DST, IMAGE_LAYOUT_GENERAL, 
+				STAGE_HAZARD_TRANSFER, STAGE_HAZARD_COMPUTE, 
+				0);
+		m_pRasterCommandList->BarrierTransition(
+				v->m_pRenderImage, 
+				IMAGE_LAYOUT_UNDEFINED, IMAGE_LAYOUT_GENERAL, 
+				STAGE_HAZARD_NONE, STAGE_HAZARD_COMPUTE, 
+				0);
 
 		m_pPostProcessingMaterial->CSSetTexture(0, 0, v->m_pColorResolved);
 		m_pPostProcessingMaterial->CSSetTexture(1, 0, v->m_pRenderImage);
 		m_pRasterCommandList->SetMaterial(m_pPostProcessingMaterial);
-		m_pRasterCommandList->Barrier(v->m_pColorResolved, true, false);
-		m_pRasterCommandList->Barrier(v->m_pRenderImage, false, true);
 		m_pRasterCommandList->DispatchCompute(uWidth, uHeight, 1);
+		m_pRasterCommandList->Barrier(STAGE_HAZARD_COMPUTE, STAGE_HAZARD_NONE, 0);
 		m_pRasterCommandList->EndRecording();
 
 		g_pRenderContext->SubmitCommandList(m_pRasterCommandList);

launcher/build.cpp

@@ -49,7 +49,6 @@ DECLARE_BUILD_STAGE(launcher)
 		manifest.SetPackageName("funnygame");
 		manifest.SetPackageID("com.kotofyt.funnygame");
 		manifest.SetPackageExecutable(outputProject);
-		V_printf("%s\n", manifest.m_szPackageName.GetString());
 
 		CUtlString szOutputDir = manifest.BuildManifest();
 
@@ -65,6 +64,32 @@ DECLARE_BUILD_STAGE(launcher)
 		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../build/funnygame/assets/shaders");
 		CUtlString szIpa = AppleTool()->BuildPackage( manifest, szOutputDir );
 	}
+	if (compileProject.m_target.kernel == TARGET_KERNEL_ANDROID)
+	{
+		AndroidManifest_t manifest = {};
+		manifest.SetPackageName("funnygame");
+		manifest.SetPackageID("com.kotofyt.funnygame");
+		manifest.SetTargetSDKVersion(32);
+		manifest.SetMinSDKVersion(32);
+
+		CUtlString szOutputDir = manifest.BuildManifest();
+
+		filesystem2->MakeDirectory(CUtlString("%s/lib/x86_64",szOutputDir.GetString()));
+		filesystem2->CopyFile(CUtlString("%s/lib/x86_64/libnative-app.so",szOutputDir.GetString()), outputProject);
+
+		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/maps");
+		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/models");
+		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/meshes");
+		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/materials");
+		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/textures");
+		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/physics");
+		filesystem2->CopyFile(CUtlString("%s/core/",szOutputDir.GetString()), "../funnyassets/default.cfg");
+		filesystem2->CopyDirectory(szOutputDir, "../external/ios/SDL3.framework");
+
+		filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "../build/funnygame/assets/shaders");
+		CUtlString szApkPackage = APKTool()->BuildPackage( manifest, szOutputDir );
+		APKTool()->SignPackage(szApkPackage, NULL, "kotofyt", "password1", "password1");
+	}
 	ADD_OUTPUT_OBJECT("launcher", outputProject);
 	return 0;
 };

materialsystem/vulkan/commandbuffer.cpp

@@ -4,40 +4,18 @@
 #include "tier1/utlvector.h"
 #include "vulkan_state.h"
 
-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:
 	virtual void SetVulkanHandlers( VkDevice hDevice, IVkCommandBufferManager *pManager ) override;
 	virtual void AddCommand( CVkCommand *pCommand ) override;
 	virtual void Reset() override;
-	virtual void Submit( int iFrameIndex ) override;
+	virtual void Submit() override;
 	virtual void Render() override;
 	void FreeWithCommands();
 private:
-	void SortDependencies();
-	void TryBarrier( int iCurrent, int iCurrentBuffer );
-	VulkanCommandDepenency_t *FindLastObjectDependency( IRenderingObject *pObject );
-
 	CUtlVector<CVkCommand*> m_commands;
-	CUtlVector<VkCommandBuffer> m_hBuffers = NULL;
-	CUtlVector<VulkanCommandLastUsage_t> m_usedDependencies; 
-	CUtlVector<CUtlVector<VulkanCommandLastUsage_t>> m_dependencies; 
-	CUtlVector<VulkanSwapchainCommandLastUsage_t> m_usedSwapchainDependencies; 
-	CUtlVector<CUtlVector<VulkanSwapchainCommandLastUsage_t>> m_swapchainDependencies; 
+	VkCommandBuffer m_hBuffer = NULL;
 
 	VkDevice m_hDevice;
 	IVkCommandBufferManager *m_pMgr;
@@ -52,7 +30,7 @@ void CVkCommandBuffer::FreeWithCommands()
 		{
 			delete c;
 		};
-		vkFreeCommandBuffers(m_hDevice, m_hPool, m_hBuffers.GetSize(), m_hBuffers.GetData());
+		vkFreeCommandBuffers(m_hDevice, m_hPool, 1, &m_hBuffer);
 		vkDestroyCommandPool(m_hDevice, m_hPool, NULL);
 		m_hPool = NULL;
 	}
@@ -74,14 +52,13 @@ void CVkCommandBuffer::Reset()
 	stCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
 	stCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
 	vkCreateCommandPool(m_hDevice, &stCreateInfo, NULL, &m_hPool);
-	m_hBuffers = {};
-	m_hBuffers.Resize(FRAMES_IN_FLIGHT);
+	m_hBuffer = {};
 
 	commandBufferAllocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
 	commandBufferAllocInfo.commandPool = m_hPool;
 	commandBufferAllocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
-	commandBufferAllocInfo.commandBufferCount = FRAMES_IN_FLIGHT;
-	vkAllocateCommandBuffers(m_hDevice, &commandBufferAllocInfo, m_hBuffers.GetData());
+	commandBufferAllocInfo.commandBufferCount = 1;
+	vkAllocateCommandBuffers(m_hDevice, &commandBufferAllocInfo, &m_hBuffer);
 
 	m_commands = {};
 }
@@ -91,273 +68,25 @@ void CVkCommandBuffer::AddCommand( CVkCommand *pCommand )
 	m_commands.AppendTail(pCommand);
 }
 
-void CVkCommandBuffer::Submit( int iFrameIndex )
+void CVkCommandBuffer::Submit()
 {
-	m_pMgr->GetVulkanCommands().AppendTail(m_hBuffers[iFrameIndex]);
-};
-
-struct VulkanBarrierObjects_t
-{
-	VulkanCommandDepenency_t m_dependency;
+	m_pMgr->GetVulkanCommands().AppendTail(m_hBuffer);
 };
 
 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);
+	vkBeginCommandBuffer(m_hBuffer, &stCommandBufferBeginInfo);
 
 	for (auto &pCommand: m_commands)
 	{
-			TryBarrier(y,i);
-			pCommand->Execute(hBuffer, i);
-			y++;
+		pCommand->Execute(m_hBuffer, 0);
 	};
-		TryBarrier(y, i);
-		vkEndCommandBuffer(hBuffer);
-		
-		i++;
-	}
-}
-
-struct VulkanCommandBarrier_t
-{
-	EDependencyMode m_eOldDependency;
-	EDependencyMode m_eNewDependency;
-	IRenderingObject *m_pObject;
-};
-
-void CVkCommandBuffer::SortDependencies()
-{
-	m_dependencies = {};
-	m_swapchainDependencies = {};
-	m_dependencies.Resize(m_commands.GetSize()+1);
-	m_swapchainDependencies.Resize(m_commands.GetSize()+1);
-	m_usedDependencies = {};
-	m_usedSwapchainDependencies = {};
-	
-	int i = 0;
-	for ( auto dependency: m_dependencies)
-	{
-		dependency = NULL;
-	}
-
-	for (auto &pCommand: m_commands)
-	{
-		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_NEXT_STAGE;
-
-			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_NEXT_STAGE;
-
-			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++;
-	}
-
-
-	for (auto &pCommand: m_commands)
-	{
-		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_dependency.m_eDependencyMode = DEPENDENCY_MODE_NEXT_STAGE;
-			stLastUsage.m_eLastUsage = DEPENDENCY_MODE_NEXT_STAGE;
-
-			if (pLastUsage)
-			{
-				stLastUsage.m_eLastUsage = pLastUsage->m_dependency.m_eDependencyMode;
-				if (pLastUsage->m_nLastUsedCommand == i)
-					continue;
-				m_dependencies[i].AppendTail(stLastUsage);
-				m_usedDependencies.AppendTail(stLastUsage);
-			}
+	vkEndCommandBuffer(m_hBuffer);
 	
 }
-		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_dependency.m_eDependencyMode = DEPENDENCY_MODE_NEXT_STAGE;
-			stLastUsage.m_eLastUsage = DEPENDENCY_MODE_NEXT_STAGE;
-
-			if (pLastUsage)
-			{
-				stLastUsage.m_eLastUsage = pLastUsage->m_dependency.m_eDependencyMode;
-				if (pLastUsage->m_nLastUsedCommand == i)
-					continue;
-				m_swapchainDependencies[i].AppendTail(stLastUsage);
-				m_usedSwapchainDependencies.AppendTail(stLastUsage);
-			}
-		}
-	}
-}
-
-
-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;
-			if (barrier.m_eNewDependency == DEPENDENCY_MODE_NEXT_STAGE)
-				imageMemoryBarrier.newLayout = pImage->m_ePreferredLayout;
-			else 
-				imageMemoryBarrier.newLayout = VulkanGetImageLayout(barrier.m_eNewDependency);
-			imageMemoryBarrier.dstStageMask = VulkanGetStageFlags(barrier.m_eNewDependency);
-			imageMemoryBarrier.dstAccessMask = VulkanGetAccessFlags(barrier.m_eNewDependency);
-			if (barrier.m_eOldDependency == DEPENDENCY_MODE_NEXT_STAGE)
-			{	
-				if (pImage->m_eLastUsage == DEPENDENCY_MODE_JUST_CREATED)
-				{
-					imageMemoryBarrier.oldLayout = VulkanGetImageLayout(DEPENDENCY_MODE_JUST_CREATED);
-					imageMemoryBarrier.srcStageMask = VulkanGetStageFlags(DEPENDENCY_MODE_JUST_CREATED);
-					imageMemoryBarrier.srcAccessMask = VulkanGetAccessFlags(DEPENDENCY_MODE_JUST_CREATED);
-				}
-				else
-				{
-					imageMemoryBarrier.oldLayout = pImage->m_ePreferredLayout;
-					imageMemoryBarrier.srcStageMask = VulkanGetStageFlags(DEPENDENCY_MODE_NEXT_STAGE);
-					imageMemoryBarrier.srcAccessMask = VulkanGetAccessFlags(DEPENDENCY_MODE_NEXT_STAGE);
-				}
-			} 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))
-		{
-		}
-	}
-
-	if (imageBarriers.GetSize() == 0 && bufferBarriers.GetSize() == 0 )
-		return;
-
-	stDependencyInfo.imageMemoryBarrierCount = imageBarriers.GetSize();
-	stDependencyInfo.bufferMemoryBarrierCount = bufferBarriers.GetSize();
-	stDependencyInfo.pImageMemoryBarriers = imageBarriers.GetData();
-	stDependencyInfo.pBufferMemoryBarriers = bufferBarriers.GetData();
-	vkCmdPipelineBarrier2(m_hBuffers[iCurrentBuffer], &stDependencyInfo);
-};
 
 class CVkCommandBufferManager: public IVkCommandBufferManager
 {
@@ -446,14 +175,3 @@ CVkCommandRegistry::CVkCommandRegistry( const char *szName, fnCreateVulkanComman
 	pCommand->m_pNext = s_pVulkanCommands;
 	s_pVulkanCommands = pCommand;
 }
-
-
-void CVkCommand::AddDependency( IRenderingObject *pObject, EDependencyMode eDependencyMode )
-{
-	m_dependencies.AppendTail({ pObject, eDependencyMode });
-}
-void CVkCommand::AddSwapchainDependency( IRenderingObject **ppObject, EDependencyMode eDependencyMode )
-{
-	m_swapchainDependencies.AppendTail({ ppObject, eDependencyMode });
-}
-

materialsystem/vulkan/commands.h

@@ -5,13 +5,13 @@
 #include "vulkan_state.h"
 
 BEGIN_VULKAN_COMMAND(Empty)
-END_VULKAN_COMMAND(Empty)
+END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(Dispatch)
 	uint32_t uX = 0;
 	uint32_t uY = 0;
 	uint32_t uZ = 0;
-END_VULKAN_COMMAND(Dispatch)
+END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(Blit)
 	VkFrameObject_t stInputImage;
@@ -20,7 +20,7 @@ BEGIN_VULKAN_COMMAND(Blit)
 	int32_t iSrcMax[3] = {};
 	int32_t iDstMin[3] = {};
 	int32_t iDstMax[3] = {};
-END_VULKAN_COMMAND(Blit)
+END_VULKAN_COMMAND()
 	
 BEGIN_VULKAN_COMMAND(ClearColor)
 	float r;
@@ -28,7 +28,7 @@ BEGIN_VULKAN_COMMAND(ClearColor)
 	float b;
 	float a;
 	VkFrameObject_t stImage;
-END_VULKAN_COMMAND(ClearColor)
+END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(Begin)
 	CUtlVector<VulkanRenderOutput_t> images;
@@ -38,37 +38,37 @@ BEGIN_VULKAN_COMMAND(Begin)
 	uint32_t nResolutionY = 0;
 
 	
-END_VULKAN_COMMAND(Begin)
+END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(End)
-END_VULKAN_COMMAND(End)
+END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(SetVertexBuffer)
 	uint32_t uBinding;
 	IVertexBuffer *pBuffer;
-END_VULKAN_COMMAND(SetVertexBuffer)
+END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(SetShader)
 	IBaseShader *pShader;
-END_VULKAN_COMMAND(SetShader)
+END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(SetShaderData)
 	IMaterial *pShaderData;
-END_VULKAN_COMMAND(SetShaderData)
+END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(DrawPrimitives)
 	uint32_t nVertexCount;
 	uint32_t nFirstVertex;
 	uint32_t nInstanceCount;
 	uint32_t nFirstInstance;
-END_VULKAN_COMMAND(DrawPrimitives)
+END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(SetScissors)
 	int32_t iX = 0;
 	int32_t iY = 0;
 	uint32_t uWidth = 0;
 	uint32_t uHeight = 0;
-END_VULKAN_COMMAND(SetScissors)
+END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(SetViewport)
 	float fX = 0;
@@ -77,12 +77,12 @@ BEGIN_VULKAN_COMMAND(SetViewport)
 	float fHeight = 0;
 	float fDepthMin = 0;
 	float fDepthMax = 1;
-END_VULKAN_COMMAND(SetViewport)
+END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(ResolveImage)
 	VkFrameObject_t stInputImage;
 	VkFrameObject_t stOutputImage;
-END_VULKAN_COMMAND(ResolveImage)
+END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(CopyBufferToImage)
 	IBuffer *pBuffer;
@@ -93,7 +93,22 @@ BEGIN_VULKAN_COMMAND(CopyBufferToImage)
 	uint32_t iImageX = 1;
 	uint32_t iImageY = 1;
 	uint32_t iImageZ = 1;
-END_VULKAN_COMMAND(CopyBufferToImage)
+END_VULKAN_COMMAND()
+
+BEGIN_VULKAN_COMMAND(Barrier)
+	EStageHazard eStageIn;
+	EStageHazard eStageOut;
+	uint32_t eHazard;
+END_VULKAN_COMMAND()
+
+BEGIN_VULKAN_COMMAND(LayoutBarrier)
+	IImage *pImage;
+	EImageLayoutHazard eLayoutIn;
+	EImageLayoutHazard eLayoutOut;
+	EStageHazard eStageIn;
+	EStageHazard eStageOut;
+	uint32_t eHazard;
+END_VULKAN_COMMAND()
 
 
 #endif

materialsystem/vulkan/commands/draw.cpp

@@ -163,3 +163,116 @@ DECLARE_VULKAN_COMMAND(ResolveImage)
 	vkCmdResolveImage2(hCommandBuffer, &i);
 }
 
+static VkPipelineStageFlags2 GetStage( EStageHazard stage )
+{
+	switch (stage)
+	{
+	case STAGE_HAZARD_COMPUTE:
+		return VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
+	case STAGE_HAZARD_TRANSFER:
+		return VK_PIPELINE_STAGE_2_TRANSFER_BIT;
+	case STAGE_HAZARD_RASTER_COLOR_OUT:
+		return VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
+	case STAGE_HAZARD_NONE:
+		return VK_PIPELINE_STAGE_2_NONE;
+	case STAGE_HAZARD_RASTER_EARLY_DEPTH_OUT:
+		return VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT;
+	case STAGE_HAZARD_RASTER_LATE_DEPTH_OUT:
+		return VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT;
+	}
+
+}
+static VkAccessFlags2 GetAccessSrc( uint32_t hazard, EStageHazard stage )
+{
+	VkAccessFlags2 f = 0;
+	if (hazard & BARRIER_HAZARD_DRAW_ARGUMENTS)
+		f |= VK_ACCESS_2_SHADER_WRITE_BIT;
+	if (hazard & BARRIER_HAZARD_DESCRIPTOR)
+		f |= VK_ACCESS_2_SHADER_WRITE_BIT;
+	if (stage == STAGE_HAZARD_RASTER_EARLY_DEPTH_OUT)
+	{
+		if (hazard & BARRIER_HAZARD_DEPTH_STENCIL)
+			f |= VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+	}
+	if (stage == STAGE_HAZARD_RASTER_COLOR_OUT)
+	{
+		if (hazard & BARRIER_HAZARD_RASTER_COLOR)
+			f |= VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
+
+	}
+	if (hazard == 0)
+		f |= VK_ACCESS_2_MEMORY_READ_BIT | VK_ACCESS_2_MEMORY_WRITE_BIT;
+	return f;
+
+}
+static VkAccessFlags2 GetAccessDst( uint32_t hazard, EStageHazard stage )
+{
+	VkAccessFlags2 f = 0;
+	if (hazard & BARRIER_HAZARD_DRAW_ARGUMENTS)
+		f |= VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT;
+	if (hazard & BARRIER_HAZARD_DESCRIPTOR)
+		f |= VK_ACCESS_2_SHADER_READ_BIT;
+	if (hazard & BARRIER_HAZARD_DEPTH_STENCIL)
+		f |= VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+	if (hazard & BARRIER_HAZARD_RASTER_COLOR)
+		f |= VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
+	if (hazard == 0)
+		f |= VK_ACCESS_2_MEMORY_READ_BIT | VK_ACCESS_2_MEMORY_WRITE_BIT;
+	return f;
+}
+static VkImageLayout GetLayout( EImageLayoutHazard hazard )
+{
+	switch (hazard)
+	{
+	case IMAGE_LAYOUT_COLOR:
+		return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+	case IMAGE_LAYOUT_DEPTH_STENCIL:
+		return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+	case IMAGE_LAYOUT_GENERAL:
+		return VK_IMAGE_LAYOUT_GENERAL;
+	case IMAGE_LAYOUT_PRESENT:
+		return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+	case IMAGE_LAYOUT_UNDEFINED:
+		return VK_IMAGE_LAYOUT_UNDEFINED;
+	case IMAGE_LAYOUT_TRANSFER_SRC:
+		return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+	case IMAGE_LAYOUT_TRANSFER_DST:
+		return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+	}
+
+}
+
+DECLARE_VULKAN_COMMAND(Barrier)
+{
+
+	VkMemoryBarrier2 barrier = {};
+	barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2;
+	barrier.srcStageMask = GetStage(eStageIn);
+	barrier.srcAccessMask = GetAccessSrc(eHazard, eStageIn);
+	barrier.dstStageMask = GetStage(eStageOut);
+	barrier.dstAccessMask = GetAccessDst(eHazard, eStageOut);
+	VkDependencyInfo dependency = {};
+	dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
+	dependency.memoryBarrierCount = 1;
+	dependency.pMemoryBarriers = &barrier;
+	vkCmdPipelineBarrier2(hCommandBuffer, &dependency);
+}
+
+DECLARE_VULKAN_COMMAND(LayoutBarrier)
+{
+	VkImageMemoryBarrier2 barrier = {};
+	barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
+	barrier.srcStageMask = GetStage(eStageIn);
+	barrier.srcAccessMask = GetAccessSrc(eHazard, eStageIn);
+	barrier.dstStageMask = GetStage(eStageOut);
+	barrier.dstAccessMask = GetAccessDst(eHazard, eStageOut);
+	barrier.image = ((CVkImage*)pImage)->m_image;
+	barrier.subresourceRange = ((CVkImage*)pImage)->m_range;
+	barrier.oldLayout = GetLayout(eLayoutIn);
+	barrier.newLayout = GetLayout(eLayoutOut);
+	VkDependencyInfo dependency = {};
+	dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
+	dependency.imageMemoryBarrierCount = 1;
+	dependency.pImageMemoryBarriers = &barrier;
+	vkCmdPipelineBarrier2(hCommandBuffer, &dependency);
+}

materialsystem/vulkan/rendercommandlist.cpp

@@ -116,13 +116,8 @@ void CVkRenderCommandList::SetMaterial( IMaterial *pMaterial )
 			pBeginCommand->images = m_pOutput;
 			pBeginCommand->nResolutionX = m_uWidth;
 			pBeginCommand->nResolutionY = m_uHeight;
-			for ( auto &i: pBeginCommand->images)
-			{
-				pBeginCommand->AddDependency(i.m_stImage.m_pSingle, DEPENDENCY_MODE_DRAWCALL_MIXED_IMAGE);
-			}
 			if ( m_bDepthEnabled )
 			{
-				pBeginCommand->AddDependency(m_depth.m_stImage.m_pSingle, DEPENDENCY_MODE_DRAWCALL_OUTPUT_DEPTH_IMAGE);
 				pBeginCommand->bDepthEnabled = m_bDepthEnabled;
 				pBeginCommand->stDepthImage = m_depth;
 
@@ -161,7 +156,6 @@ void CVkRenderCommandList::SetVertexBuffer( uint32_t uBinding, IVertexBuffer *pB
 	CVkSetVertexBufferCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, SetVertexBuffer);
 	pCmd->uBinding = uBinding;
 	pCmd->pBuffer = pBuffer;
-	pCmd->AddDependency(pBuffer, DEPENDENCY_MODE_BUFFER_SOURCE);
 	m_pCurrentMaterialBuffer->AddCommand(pCmd);
 }
 
@@ -179,7 +173,6 @@ void CVkRenderCommandList::DrawPrimitives( uint32_t nVertexCount, uint32_t nFirs
 	pCmd->nFirstVertex = nFirstVertex;
 	pCmd->nInstanceCount = nInstanceCount;
 	pCmd->nFirstInstance = nFirstInstance;
-	FlushBarriers(pCmd);
 
 	m_pCurrentMaterialBuffer->AddCommand(pCmd);
 }
@@ -204,8 +197,6 @@ void CVkRenderCommandList::BlitImageToImage( IImage *pSrc, ImageSector_t src, II
 	pCmd->stInputImage.m_pSingle = pSrc;
 	pCmd->stOutputImage.m_eObjectType = FRAME_OBJECT_TYPE_SINGLE;
 	pCmd->stOutputImage.m_pSingle = pDst;
-	pCmd->AddDependency(pSrc, DEPENDENCY_MODE_BLIT_IMAGE_SOURCE);
-	pCmd->AddDependency(pDst, DEPENDENCY_MODE_BLIT_IMAGE_DESTINATION);
 	pCmd->iSrcMin[0] = src.m_iX;
 	pCmd->iSrcMin[1] = src.m_iY;
 	pCmd->iSrcMin[2] = 0;
@@ -226,7 +217,6 @@ void CVkRenderCommandList::ClearImage( IImage *pImage, float fR, float fG, float
 {
 	SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
 	CVkClearColorCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, ClearColor);
-	pCmd->AddDependency(pImage, DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION);
 	pCmd->r = fR;
 	pCmd->g = fG;
 	pCmd->b = fB;
@@ -251,8 +241,6 @@ void CVkRenderCommandList::ResolveImage( IImage *pOriginal, IImage *pResolved )
 	pCmd->stInputImage.m_pSingle = pOriginal;
 	pCmd->stOutputImage.m_eObjectType = FRAME_OBJECT_TYPE_SINGLE;
 	pCmd->stOutputImage.m_pSingle = pResolved;
-	pCmd->AddDependency(pOriginal, DEPENDENCY_MODE_IMAGE_RESOLVE_SOURCE);
-	pCmd->AddDependency(pResolved, DEPENDENCY_MODE_IMAGE_RESOLVE_DESTINATION);
 	m_pPostRaster->AddCommand(pCmd);
 }
 
@@ -266,18 +254,37 @@ void CVkRenderCommandList::EndRecording()
 {
 	SwitchRenderingStage(RENDERING_STAGE_FINISHED);
 }
-
-void CVkRenderCommandList::Barrier( IRenderingObject *pObject, bool bIsRead, bool bIsWrite )
+void CVkRenderCommandList::Barrier( EStageHazard eBefore, EStageHazard eAfter, uint32_t hazard )
 {
-	m_barriers.AppendTail({pObject, bIsRead, bIsWrite});
+	SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
+	CVkBarrierCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, Barrier);
+	pCmd->eStageIn = eBefore;
+	pCmd->eStageOut = eAfter;
+	pCmd->eHazard = hazard;
+	m_pPostRaster->AddCommand(pCmd);
+
 }
+
+void CVkRenderCommandList::BarrierTransition( IImage *pObject, EImageLayoutHazard old_layout, EImageLayoutHazard layout, EStageHazard eBefore, EStageHazard eAfter, uint32_t hazard )
+{
+	SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
+	CVkLayoutBarrierCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, LayoutBarrier);
+	pCmd->eStageIn = eBefore;
+	pCmd->eStageOut = eAfter;
+	pCmd->eHazard = hazard;
+	pCmd->pImage = pObject;
+	pCmd->eLayoutIn = old_layout;
+	pCmd->eLayoutOut = layout;
+	m_pPostRaster->AddCommand(pCmd);
+
+}
+
 void CVkRenderCommandList::DispatchCompute( uint32_t uX, uint32_t uY, uint32_t uZ )
 {	
 	SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
 
 	CVkDispatchCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, Dispatch);
 
-	FlushBarriers(pCmd);
 	pCmd->uX = uX;
 	pCmd->uY = uY;
 	pCmd->uZ = uZ;
@@ -293,38 +300,6 @@ void CVkRenderCommandList::Submit()
 	}
 }
 
-void CVkRenderCommandList::FlushBarriers( CVkCommand *pCmd )
-{	
-	for ( auto &b: m_barriers )
-	{
-		if (dynamic_cast<CVkBuffer*>(b.pObject))
-		{
-			if (b.m_bIsRead)
-				if (b.m_bIsWrite)
-					pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_BUFFER_READ_WRITE);
-				else
-					pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_BUFFER_READ);
-			else
-				if (b.m_bIsWrite)
-					pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_BUFFER_WRITE);
-
-		}
-		if (dynamic_cast<CVkImage*>(b.pObject))
-		{
-			if (b.m_bIsRead)
-				if (b.m_bIsWrite)
-					pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_IMAGE_READ_WRITE);
-				else
-					pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_IMAGE_READ);
-			else
-				if (b.m_bIsWrite)
-					pCmd->AddDependency(b.pObject, DEPENDENCY_MODE_SHADER_IMAGE_WRITE);
-
-		}
-	}
-	m_barriers = {};
-}
-
 void CVkRenderCommandList::SwitchRenderingStage( EVulkanRenderingStage eStage )
 {
 	if (eStage != RENDERING_STAGE_RASTER)

materialsystem/vulkan/rendercontext.cpp

@@ -45,9 +45,6 @@ struct VulkanWindow_t
 	VkSurfaceKHR m_surface;
 	VkSwapchainKHR m_swapchain;
 	VkFormat m_eFormat;
-	VkFence m_fences[FRAMES_IN_FLIGHT];
-	VkSemaphore m_imageAvailable[FRAMES_IN_FLIGHT];
-	VkSemaphore m_renderFinished[FRAMES_IN_FLIGHT];
 	CUtlVector<IImage*> m_images;
 	uint32_t m_uCurrentFrame;
 };
@@ -58,21 +55,13 @@ CVkImage::CVkImage()
 
 }
 
-CVkImage::CVkImage( uint32_t nWidth, uint32_t nHeight, uint32_t nDepth, EImageFormat eFormat, EMultisampleType eMultisampleType, EImageType eImageType, VkImageUsageFlagBits eUsage )
+CVkImage::CVkImage( uint32_t nWidth, uint32_t nHeight, uint32_t nDepth, EImageFormat eFormat, EMultisampleType eMultisampleType, EImageType eImageType, VkImageUsageFlags eUsage )
 {
 	m_nWidth = nWidth;
 	m_nHeight = nHeight;
 	m_eMultisampleType = eMultisampleType;
 	m_eImageType = eImageType;
 	m_eFormat = eFormat;
-	if (eFormat == IMAGE_FORMAT_D32_SFLOAT)
-		m_ePreferredLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
-	else
-		if (eUsage == VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
-			m_ePreferredLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-		else
-			m_ePreferredLayout = VK_IMAGE_LAYOUT_GENERAL;
-
 	CreateImage(nWidth, nHeight, eFormat, eMultisampleType, eUsage);
 	CreateImageView();
 }
@@ -186,7 +175,7 @@ VkSampleCountFlagBits CVkImage::GetMultisampling( enum EMultisampleType eImageFo
 	}
 }
 
-void CVkImage::CreateImage( uint32_t nWidth, uint32_t nHeight, EImageFormat eFormat, EMultisampleType eMultisampleType, VkImageUsageFlagBits eUsage )
+void CVkImage::CreateImage( uint32_t nWidth, uint32_t nHeight, EImageFormat eFormat, EMultisampleType eMultisampleType, VkImageUsageFlags eUsage )
 {
 	VkImageCreateInfo stCreateInfo = {};
 	VmaAllocationCreateInfo stAlloc = {};
@@ -233,7 +222,13 @@ void CVkImage::CreateImageView()
 }
 void CVkImage::SetDebugName( const char *szName )
 {
+	VkDebugUtilsObjectNameInfoEXT nameInfo = {};
+	nameInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
+	nameInfo.objectType = VK_OBJECT_TYPE_IMAGE;
+	nameInfo.objectHandle = (uint64_t)m_image;
+	nameInfo.pObjectName = szName;
 
+	vkSetDebugUtilsObjectNameEXT(s_vkDevice, &nameInfo);
 }
 
 
@@ -421,12 +416,21 @@ uint32_t CVkTextureArray::CreateTexture( uint32_t i, const char *szPath )
 	stbi_image_free(pImg);
 
 
+	CVkLayoutBarrierCommand *pBarrierCommand = NULL;
 	CVkCopyBufferToImageCommand *pCopyCommand = NULL;
+
 	IVkCommandBuffer *pCommandBuffer = m_pCommandBufferManager->CreateCommandBuffer();
 	pCommandBuffer->Reset();
+
+	pBarrierCommand = CREATE_COMMAND(m_pCommandBufferManager, LayoutBarrier);
+	pBarrierCommand->pImage = pImage;
+	pBarrierCommand->eHazard = 0;
+	pBarrierCommand->eStageIn = STAGE_HAZARD_NONE;
+	pBarrierCommand->eStageOut = STAGE_HAZARD_TRANSFER;
+	pBarrierCommand->eLayoutIn = IMAGE_LAYOUT_UNDEFINED;
+	pBarrierCommand->eLayoutOut = IMAGE_LAYOUT_TRANSFER_DST;
+	pCommandBuffer->AddCommand(pBarrierCommand);
 	pCopyCommand = CREATE_COMMAND(m_pCommandBufferManager, CopyBufferToImage);
-	pCopyCommand->AddDependency((IRenderingObject*)pBuffer, DEPENDENCY_MODE_BUFFER_SOURCE);
-	pCopyCommand->AddDependency((IRenderingObject*)pImage, DEPENDENCY_MODE_IMAGE_DESTINATION);
 	pCopyCommand->pBuffer = pBuffer;
 	pCopyCommand->stOutputImage.m_eObjectType = FRAME_OBJECT_TYPE_SINGLE;
 	pCopyCommand->stOutputImage.m_pSingle = pImage;
@@ -502,7 +506,7 @@ public:
 	virtual void *GetVulkanInstance() override;
 	virtual void *GetVulkanPhysicalDevice() override;
 	virtual void *GetVulkanDevice() override;
-	virtual IImage *CreateImageFromVkImage( void *pVkImage, uint32_t x, uint32_t y, uint64_t optimalLayout, EImageFormat eFormat, EMultisampleType eMultisampleType ) override;
+	virtual IImage *CreateImageFromVkImage( uint64_t pVkImage, uint32_t x, uint32_t y, uint64_t optimalLayout, EImageFormat eFormat, EMultisampleType eMultisampleType ) override;
 private:
 	VkPhysicalDevice SelectPhysicalDevice( CUtlVector<VkPhysicalDevice> physicalDevices );
 	CUtlVector<const char *> GetDeviceExtensions();
@@ -593,14 +597,13 @@ IBuffer *CVkRenderContext::CreateBufferAligned( uint32_t nSize, uint32_t nAlignm
 IImage *CVkRenderContext::CreateRenderTarget( uint32_t x, uint32_t y, EImageFormat eFormat, EMultisampleType eMultisampleType )
 {
 	if (eFormat == IMAGE_FORMAT_D32_SFLOAT)
-		return new CVkImage(x, y, 1, eFormat, eMultisampleType, IMAGE_TYPE_2D, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
+		return new CVkImage(x, y, 1, eFormat, eMultisampleType, IMAGE_TYPE_2D, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
 	else
-		return new CVkImage(x, y, 1, eFormat, eMultisampleType, IMAGE_TYPE_2D, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
+		return new CVkImage(x, y, 1, eFormat, eMultisampleType, IMAGE_TYPE_2D, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
 }
 IImage *CVkRenderContext::CreateTexture( uint32_t x, uint32_t y, EImageFormat eFormat, EMultisampleType eMultisampleType )
 {
 	CVkImage *pImage = new CVkImage(x, y, 1, eFormat, eMultisampleType, IMAGE_TYPE_2D, VK_IMAGE_USAGE_SAMPLED_BIT);
-	pImage->m_ePreferredLayout = VK_IMAGE_LAYOUT_GENERAL;
 	return pImage;
 }
 
@@ -734,7 +737,7 @@ void *CVkRenderContext::GetVulkanDevice()
 	return s_vkDevice;
 }
 
-IImage *CVkRenderContext::CreateImageFromVkImage( void *pVkImage, uint32_t x, uint32_t y, uint64_t optimalLayout, EImageFormat eFormat, EMultisampleType eMultisampleType )
+IImage *CVkRenderContext::CreateImageFromVkImage( uint64_t pVkImage, uint32_t x, uint32_t y, uint64_t optimalLayout, EImageFormat eFormat, EMultisampleType eMultisampleType )
 {
 	CVkImage *pImage;
 	pImage = new CVkImage;
@@ -744,7 +747,6 @@ IImage *CVkRenderContext::CreateImageFromVkImage( void *pVkImage, uint32_t x, ui
 	pImage->m_eFormat = eFormat;
 	pImage->m_nHeight = x;
 	pImage->m_nWidth = y;
-	pImage->m_ePreferredLayout = (VkImageLayout)optimalLayout;
 	pImage->CreateImageView();
 	return pImage;
 }
@@ -798,6 +800,7 @@ void CVkRenderContext::Init()
 	stInstanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
 	stInstanceCreateInfo.pApplicationInfo = &stApplicationInfo;
 	enabledInstanceExtensions.AppendTail(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+	enabledInstanceExtensions.AppendTail(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
 	stInstanceCreateInfo.enabledExtensionCount = enabledInstanceExtensions.GetSize();
 	stInstanceCreateInfo.ppEnabledExtensionNames = enabledInstanceExtensions.GetData();
 
@@ -862,6 +865,7 @@ void CVkRenderContext::Init()
 	vk12Features.runtimeDescriptorArray = VK_TRUE;
 	vk12Features.descriptorBindingPartiallyBound = VK_TRUE;
 	vk12Features.descriptorBindingVariableDescriptorCount = VK_TRUE;
+	vk12Features.timelineSemaphore = VK_TRUE;
 	VkPhysicalDeviceVulkan11Features vk11Features = {};
 	vk11Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
 	vk11Features.pNext = &vk12Features;
@@ -925,13 +929,10 @@ void CVkRenderContext::Init()
 	vkCreateSampler(s_vkDevice, &samplerInfo, nullptr, &m_defaultSampler.m_sampler);
 }
 
+#include "time.h"
 void CVkRenderContext::Frame( float fDeltaTime )
 {
-
 	uint32_t i;
-	CUtlVector<VkFence> fences = {};
-	CUtlVector<VkSemaphore> imageReady = {};
-	CUtlVector<VkSemaphore> renderFinish = {};
 	CUtlVector<VkSwapchainKHR> swapchains = {};
 	CUtlVector<uint32_t> uImageIndexes = {};
 	CUtlVector<uint32_t> uSwapchainImageIndexes = {};
@@ -961,24 +962,25 @@ void CVkRenderContext::Frame( float fDeltaTime )
 
 	for ( auto &s: m_renderWindows)
 	{
-		fences.AppendTail(s.m_fences[s.m_uCurrentFrame]);
-		imageReady.AppendTail(s.m_imageAvailable[s.m_uCurrentFrame]);
-		renderFinish.AppendTail(s.m_renderFinished[s.m_uCurrentFrame]);
 		swapchains.AppendTail(s.m_swapchain);
 		uImageIndexes.AppendTail(s.m_uCurrentFrame);
 	}
 	uSwapchainImageIndexes.Resize(m_renderWindows.GetSize());
 	
-
-	vkWaitForFences(s_vkDevice, fences.GetSize(), fences.GetData(), VK_TRUE, UINT64_MAX);
-	vkResetFences(s_vkDevice, fences.GetSize(), fences.GetData());
-
+	VkFence fence;
+	VkFenceCreateInfo fci = {};
+	fci.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+	fci.flags = VK_FENCE_CREATE_SIGNALED_BIT;
+	vkCreateFence(s_vkDevice, &fci, NULL, &fence);
 	i = 0;
 	for ( auto &s: m_renderWindows )
 	{
-		VkResult r = vkAcquireNextImageKHR(s_vkDevice, s.m_swapchain, UINT64_MAX, s.m_imageAvailable[s.m_uCurrentFrame], NULL, &uSwapchainImageIndexes[i]);
+		vkResetFences(s_vkDevice, 1, &fence);
+		VkResult r = vkAcquireNextImageKHR(s_vkDevice, s.m_swapchain, UINT64_MAX, NULL, fence, &uSwapchainImageIndexes[i]);
+		vkWaitForFences(s_vkDevice, 1, &fence, true, UINT64_MAX);
 		i++;
 	}
+	vkDestroyFence(s_vkDevice, fence, 0);
 	
 	if (m_pXRManager)
 		m_pXRManager->PreRender();
@@ -987,13 +989,11 @@ void CVkRenderContext::Frame( float fDeltaTime )
 	pList->StartRecording();
 
 
-	double a = Plat_GetTime();
 	i = 0;
 	for ( auto &s: m_renderWindows )
 	{
 
 
-		CVkBlitCommand *pBlitCommand = NULL;
 		if (s.m_pWindow->GetOutputImage())
 		{
 
@@ -1007,7 +1007,23 @@ void CVkRenderContext::Frame( float fDeltaTime )
 			dst.m_iHeight = s.m_pWindow->GetRenderHeight();
 			dst.m_iX = 0;
 			dst.m_iY = 0;
+			pList->BarrierTransition(
+					s.m_pWindow->GetOutputImage(), 
+					IMAGE_LAYOUT_GENERAL, IMAGE_LAYOUT_TRANSFER_SRC,
+					STAGE_HAZARD_NONE, STAGE_HAZARD_TRANSFER, 0);
+			pList->BarrierTransition(
+					s.m_images[uSwapchainImageIndexes[i]], 
+					IMAGE_LAYOUT_UNDEFINED, IMAGE_LAYOUT_TRANSFER_DST,
+					STAGE_HAZARD_NONE, STAGE_HAZARD_TRANSFER, 0);
 			pList->BlitImageToImage(s.m_pWindow->GetOutputImage(), src, s.m_images[uSwapchainImageIndexes[i]], dst);
+			pList->BarrierTransition(
+					s.m_pWindow->GetOutputImage(), 
+					IMAGE_LAYOUT_TRANSFER_SRC, IMAGE_LAYOUT_GENERAL,
+					STAGE_HAZARD_TRANSFER, STAGE_HAZARD_NONE, 0);
+			pList->BarrierTransition(
+					s.m_images[uSwapchainImageIndexes[i]], 
+					IMAGE_LAYOUT_TRANSFER_DST, IMAGE_LAYOUT_PRESENT,
+					STAGE_HAZARD_TRANSFER, STAGE_HAZARD_NONE, 0);
 		}
 		i++;
 	}
@@ -1017,34 +1033,54 @@ void CVkRenderContext::Frame( float fDeltaTime )
 
 	if (m_pXRManager)
 		m_pXRManager->CopySwapchain();
+	VkSemaphoreTypeCreateInfo timelineInfo = {};
+	timelineInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
+	timelineInfo.pNext = NULL;
+	timelineInfo.semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE;
+	timelineInfo.initialValue = 0;
 
+	VkSemaphoreCreateInfo semaphore_ci = {};
+	semaphore_ci.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+	semaphore_ci.pNext = &timelineInfo;
+	VkSemaphore semaphore = {};
+	vkCreateSemaphore(s_vkDevice, &semaphore_ci, NULL, &semaphore);
 
 	VkPipelineStageFlags uPipelineStageFlags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 	VkSubmitInfo stSubmitInfo = {};
 	stSubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
-	stSubmitInfo.waitSemaphoreCount = imageReady.GetSize();
-	stSubmitInfo.pWaitSemaphores = imageReady.GetData();
 	stSubmitInfo.pWaitDstStageMask = &uPipelineStageFlags;
 
 	stSubmitInfo.commandBufferCount = m_pCommandBufferManager->GetVulkanCommands().GetSize();
 	stSubmitInfo.pCommandBuffers = m_pCommandBufferManager->GetVulkanCommands().GetData();
 
-	stSubmitInfo.signalSemaphoreCount = renderFinish.GetSize();
-	stSubmitInfo.pSignalSemaphores = renderFinish.GetData();
+	stSubmitInfo.signalSemaphoreCount = 1;
+	stSubmitInfo.pSignalSemaphores = &semaphore;
 
+	const uint64_t v = 1;
+	VkTimelineSemaphoreSubmitInfo tssi = {};
+	tssi.sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
+	tssi.signalSemaphoreValueCount = 1;
+	tssi.pSignalSemaphoreValues = &v;
+	stSubmitInfo.pNext = &tssi;
 
-	vkQueueSubmit(s_vkDrawQueue, 1, &stSubmitInfo, fences[0]);
+	double a = Plat_GetTime();
+	vkQueueSubmit(s_vkDrawQueue, 1, &stSubmitInfo, 0);
+	VkSemaphoreWaitInfo wi = {};
+	wi.sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO;
+	wi.semaphoreCount = 1;
+	wi.pSemaphores = &semaphore;
+	wi.pValues = &v;
+	vkWaitSemaphores(s_vkDevice, &wi, UINT64_MAX);
 
 	VkPresentInfoKHR stPresentInfo = {};
 	stPresentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
-	stPresentInfo.waitSemaphoreCount = renderFinish.GetSize();
-	stPresentInfo.pWaitSemaphores = renderFinish.GetData();
 	stPresentInfo.swapchainCount = swapchains.GetSize();
 	stPresentInfo.pSwapchains = swapchains.GetData();
 	stPresentInfo.pImageIndices = uImageIndexes.GetData();
 
 	vkQueuePresentKHR(s_vkPresentQueue, &stPresentInfo);
 	vkDeviceWaitIdle(s_vkDevice);
+	vkDestroySemaphore(s_vkDevice, semaphore, NULL);
 	if (m_pXRManager)
 		m_pXRManager->PostRender();
 
@@ -1116,6 +1152,7 @@ VulkanWindow_t CVkRenderContext::CreateSwapchain( IGameWindow *pWindow )
 
 	for (auto &format: surfaceFormats)
 	{
+		
 		for (int i = 0; i < sizeof(preferedSurfaceFormats)/sizeof(VkFormat); i++)
 		{
 			if (format.format == preferedSurfaceFormats[i])
@@ -1126,6 +1163,7 @@ VulkanWindow_t CVkRenderContext::CreateSwapchain( IGameWindow *pWindow )
 		}
 	}
 formatPicked:
+	V_printf("Surface format: %s\n", string_VkFormat(stSelectedFormat.format));
 
 	vkGetPhysicalDeviceSurfacePresentModesKHR(s_vkPhysicalDevice, window.m_surface, &nSurfacePresentModes, NULL);
 	surfacePresentModes.Resize(nSurfacePresentModes);
@@ -1165,20 +1203,9 @@ formatPicked:
 		pImage->m_eFormat = IMAGE_FORMAT_BGRA8_UNORM;
 		pImage->m_nHeight = pWindow->GetRenderWidth();
 		pImage->m_nWidth = pWindow->GetRenderHeight();
-		pImage->m_ePreferredLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
 		pImage->CreateImageView();
 		window.m_images[i] = pImage;
 	}
-	for ( int i = 0; i < FRAMES_IN_FLIGHT; i++ )
-	{
-		stFenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
-		stFenceCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
-		vkCreateFence(s_vkDevice, &stFenceCreateInfo, NULL, &window.m_fences[i]);
-
-		stSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
-		vkCreateSemaphore(s_vkDevice, &stSemaphoreCreateInfo, NULL, &window.m_imageAvailable[i]);
-		vkCreateSemaphore(s_vkDevice, &stSemaphoreCreateInfo, NULL, &window.m_renderFinished[i]);
-	}
 
 	window.m_pWindow = pWindow;
 	return window;
@@ -1193,12 +1220,6 @@ void CVkRenderContext::DestroySwapchain( uint32_t uIndex )
 	}
 	vkDestroySwapchainKHR(s_vkDevice, m_renderWindows[uIndex].m_swapchain, NULL);
 	m_renderWindows[uIndex].m_pWindow->DestroyVulkanSurface(s_vkInstance);
-	for ( int i = 0; i < FRAMES_IN_FLIGHT; i++ )
-	{
-		vkDestroyFence(s_vkDevice, m_renderWindows[uIndex].m_fences[i], NULL);
-		vkDestroySemaphore(s_vkDevice, m_renderWindows[uIndex].m_imageAvailable[i], NULL);
-		vkDestroySemaphore(s_vkDevice, m_renderWindows[uIndex].m_renderFinished[i], NULL);
-	}
 }
 
 //-----------------------------------------------------------------------------

materialsystem/vulkan/utils.cpp

@@ -13,108 +13,6 @@ IRenderingObject *VulkanGetObject( VkFrameObject_t stObject, int iIndex )
 		return NULL;
 	}
 }
-
-VkAccessFlags2 VulkanGetAccessFlags( EDependencyMode eMode )
-{
-	switch (eMode)
-	{
-	case DEPENDENCY_MODE_JUST_CREATED: return VK_ACCESS_2_NONE; 
-	case DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE: return VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR; 
-	case DEPENDENCY_MODE_DRAWCALL_OUTPUT_DEPTH_IMAGE: return VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; 
-	case DEPENDENCY_MODE_DRAWCALL_MIXED_IMAGE: return VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR | 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;
-	case DEPENDENCY_MODE_SHADER_BUFFER_READ: return VK_ACCESS_2_SHADER_READ_BIT;
-	case DEPENDENCY_MODE_SHADER_BUFFER_WRITE: return VK_ACCESS_2_SHADER_READ_BIT;
-	case DEPENDENCY_MODE_SHADER_BUFFER_READ_WRITE: return VK_ACCESS_2_SHADER_READ_BIT | VK_ACCESS_2_SHADER_WRITE_BIT;
-	case DEPENDENCY_MODE_SHADER_IMAGE_READ: return VK_ACCESS_2_SHADER_READ_BIT;
-	case DEPENDENCY_MODE_SHADER_IMAGE_WRITE: return VK_ACCESS_2_SHADER_READ_BIT;
-	case DEPENDENCY_MODE_SHADER_IMAGE_READ_WRITE: return VK_ACCESS_2_SHADER_READ_BIT | VK_ACCESS_2_SHADER_WRITE_BIT;
-
-	case DEPENDENCY_MODE_BLIT_IMAGE_SOURCE:
-	case DEPENDENCY_MODE_IMAGE_SOURCE: 
-	case DEPENDENCY_MODE_BUFFER_SOURCE: 
-	case DEPENDENCY_MODE_IMAGE_RESOLVE_SOURCE: 
-		return VK_ACCESS_2_TRANSFER_READ_BIT;
-
-	case DEPENDENCY_MODE_IMAGE_DESTINATION:
-	case DEPENDENCY_MODE_BLIT_IMAGE_DESTINATION: 
-	case DEPENDENCY_MODE_BUFFER_DESTINATION: 
-	case DEPENDENCY_MODE_IMAGE_RESOLVE_DESTINATION: 
-		return VK_ACCESS_2_TRANSFER_WRITE_BIT;
-
-	default:
-		return VK_ACCESS_2_NONE;
-	}
-}
-
-VkPipelineStageFlags2 VulkanGetStageFlags( EDependencyMode eMode )
-{
-	switch (eMode)
-	{
-	case DEPENDENCY_MODE_JUST_CREATED: return VK_PIPELINE_STAGE_2_NONE; 
-	case DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE: return VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT; 
-	case DEPENDENCY_MODE_DRAWCALL_OUTPUT_DEPTH_IMAGE: return VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT; 
-	case DEPENDENCY_MODE_DRAWCALL_MIXED_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; 
-
-	case DEPENDENCY_MODE_SHADER_BUFFER_READ: return VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT;
-	case DEPENDENCY_MODE_SHADER_BUFFER_WRITE: return VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT;
-	case DEPENDENCY_MODE_SHADER_BUFFER_READ_WRITE: return VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT;
-	case DEPENDENCY_MODE_SHADER_IMAGE_READ: return VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT;
-	case DEPENDENCY_MODE_SHADER_IMAGE_WRITE: return VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT;
-	case DEPENDENCY_MODE_SHADER_IMAGE_READ_WRITE: return VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT;
-
-	case DEPENDENCY_MODE_BLIT_IMAGE_SOURCE: 
-	case DEPENDENCY_MODE_BLIT_IMAGE_DESTINATION: 
-		return VK_PIPELINE_STAGE_2_BLIT_BIT; 
-
-	case DEPENDENCY_MODE_BUFFER_SOURCE: 
-	case DEPENDENCY_MODE_IMAGE_SOURCE: 
-	case DEPENDENCY_MODE_BUFFER_DESTINATION: 
-	case DEPENDENCY_MODE_IMAGE_DESTINATION: 
-		return VK_PIPELINE_STAGE_2_COPY_BIT; 
-
-	case DEPENDENCY_MODE_IMAGE_RESOLVE_SOURCE: 
-	case DEPENDENCY_MODE_IMAGE_RESOLVE_DESTINATION: 
-		return VK_PIPELINE_STAGE_2_RESOLVE_BIT; 
-
-	default:
-		return VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
-	}
-}
-
-VkImageLayout VulkanGetImageLayout( EDependencyMode eMode )
-{
-	switch (eMode)
-	{
-	case DEPENDENCY_MODE_JUST_CREATED: return VK_IMAGE_LAYOUT_UNDEFINED; 
-	case DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE: return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; 
-	case DEPENDENCY_MODE_DRAWCALL_OUTPUT_DEPTH_IMAGE: return VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL; 
-	case DEPENDENCY_MODE_DRAWCALL_MIXED_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; 
-	case DEPENDENCY_MODE_BLIT_IMAGE_SOURCE: 
-	case DEPENDENCY_MODE_IMAGE_SOURCE: 
-	case DEPENDENCY_MODE_BUFFER_SOURCE: 
-	case DEPENDENCY_MODE_IMAGE_RESOLVE_SOURCE: 
-		return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-	case DEPENDENCY_MODE_BLIT_IMAGE_DESTINATION: 
-	case DEPENDENCY_MODE_IMAGE_DESTINATION:
-	case DEPENDENCY_MODE_BUFFER_DESTINATION: 
-	case DEPENDENCY_MODE_IMAGE_RESOLVE_DESTINATION: 
-		return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-
-	case DEPENDENCY_MODE_SHADER_IMAGE_READ: 
-	case DEPENDENCY_MODE_SHADER_IMAGE_WRITE: 
-	case DEPENDENCY_MODE_SHADER_IMAGE_READ_WRITE: 
-		return VK_IMAGE_LAYOUT_GENERAL;
-
-	default:
-		return VK_IMAGE_LAYOUT_UNDEFINED;
-	}
-}
 VkFormat VulkanGetVertexFormat( EVertexFormat eFormat )
 {
 	switch (eFormat)

materialsystem/vulkan/vulkan_state.h

@@ -41,57 +41,6 @@ enum EVulkanCommandParameterType
 	VULKAN_PARAMETER_TYPE_IMAGE,
 };
 
-enum EDependencyMode
-{
-	DEPENDENCY_MODE_JUST_CREATED,
-
-	DEPENDENCY_MODE_SHADER_IMAGE_READ,
-	DEPENDENCY_MODE_SHADER_BUFFER_READ,
-	DEPENDENCY_MODE_SHADER_IMAGE_WRITE,
-	DEPENDENCY_MODE_SHADER_BUFFER_WRITE,
-	DEPENDENCY_MODE_SHADER_BUFFER_READ_WRITE,
-	DEPENDENCY_MODE_SHADER_IMAGE_READ_WRITE,
-	DEPENDENCY_MODE_SHADER_ACCELERATION_STRUCTURE,
-
-	DEPENDENCY_MODE_DRAWCALL_VERTEX_BUFFER,
-	DEPENDENCY_MODE_DRAWCALL_INDEX_BUFFER,
-	DEPENDENCY_MODE_DRAWCALL_OUTPUT_IMAGE,
-	DEPENDENCY_MODE_DRAWCALL_OUTPUT_DEPTH_IMAGE,
-	DEPENDENCY_MODE_DRAWCALL_INPUT_IMAGE,
-	DEPENDENCY_MODE_DRAWCALL_MIXED_IMAGE,
-
-	DEPENDENCY_MODE_BUFFER_SOURCE,
-	DEPENDENCY_MODE_IMAGE_SOURCE,
-	DEPENDENCY_MODE_IMAGE_DESTINATION,
-	DEPENDENCY_MODE_BUFFER_DESTINATION,
-
-	DEPENDENCY_MODE_IMAGE_RESOLVE_SOURCE,
-	DEPENDENCY_MODE_IMAGE_RESOLVE_DESTINATION,
-
-	DEPENDENCY_MODE_BLIT_IMAGE_SOURCE,
-	DEPENDENCY_MODE_BLIT_IMAGE_DESTINATION,
-
-	DEPENDENCY_MODE_COLOR_CLEAR_SOURCE,
-	DEPENDENCY_MODE_COLOR_CLEAR_DESTINATION,
-
-	DEPENDENCY_MODE_ALL_COMMANDS,
-	DEPENDENCY_MODE_IMAGE_PRESENT,
-
-	DEPENDENCY_MODE_NEXT_STAGE,
-
-	DEPENDENCY_MODE_COUNT,
-};
-
-
-struct VulkanCommandDepenency_t {
-	IRenderingObject *m_pObject;
-	EDependencyMode m_eDependencyMode;
-};
-struct VulkanCommandSwapchainDepenency_t {
-	IRenderingObject **m_ppObjects;
-	EDependencyMode m_eDependencyMode;
-};
-
 struct VulkanCommandParameter_t
 {
 	const char *m_szName;
@@ -109,12 +58,7 @@ public:
 	virtual ~CVkCommand() = default;
 	//virtual const char *GetName();
 
-	CUtlVector<VulkanCommandDepenency_t> m_dependencies = {};
-	CUtlVector<VulkanCommandSwapchainDepenency_t> m_swapchainDependencies = {};
 	EVulkanCommandType m_eType;
-
-	void AddDependency( IRenderingObject *pObject, EDependencyMode eDependencyMode );
-	void AddSwapchainDependency( IRenderingObject **ppObjects, EDependencyMode eDependencyMode );
 };
 
 class IVkCommandBufferManager;
@@ -125,7 +69,7 @@ public:
 	virtual void AddCommand( CVkCommand *pCommand ) = 0;
 
 	virtual void Reset() = 0;
-	virtual void Submit( int iFrameIndex = 0 ) = 0;
+	virtual void Submit() = 0;
 	virtual void Render() = 0;
 };
 
@@ -157,7 +101,7 @@ class CVk##name##Command : public CVkCommand \
 public: \
 	virtual void Execute( VkCommandBuffer hCommandBuffer, int iCurrentFrame ) override; \
 
-#define END_VULKAN_COMMAND( name ) \
+#define END_VULKAN_COMMAND() \
 }; \
 
 #define DECLARE_VULKAN_COMMAND(name) \
@@ -177,7 +121,7 @@ class CVkImage: public IImage
 {
 public:
 	CVkImage();
-	CVkImage( uint32_t nWidth, uint32_t nHeight, uint32_t nDepth, EImageFormat eFormat, EMultisampleType eMultisampleType, EImageType eImageType, VkImageUsageFlagBits eUsage );
+	CVkImage( uint32_t nWidth, uint32_t nHeight, uint32_t nDepth, EImageFormat eFormat, EMultisampleType eMultisampleType, EImageType eImageType, VkImageUsageFlags eUsage );
 	~CVkImage();
 
 	virtual void SetDebugName( const char *szName ) override;
@@ -186,7 +130,7 @@ public:
 	virtual EImageFormat GetImageFormat() override;
 	virtual EMultisampleType GetMultisampleType() override;
 
-	void CreateImage( uint32_t nWidth, uint32_t nHeight, EImageFormat eFormat, EMultisampleType eMultisampleType, VkImageUsageFlagBits eUsage );
+	void CreateImage( uint32_t nWidth, uint32_t nHeight, EImageFormat eFormat, EMultisampleType eMultisampleType, VkImageUsageFlags eUsage );
 	void CreateImageView();
 
 	static VkImageViewType GetImageViewType( enum EImageType eImageType );
@@ -204,10 +148,6 @@ public:
 	VmaAllocation m_allocation;
 	VkImageSubresourceRange m_range;
 
-	VkImageLayout m_ePreferredLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-
-	VkImageLayout m_eImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-	EDependencyMode m_eLastUsage = DEPENDENCY_MODE_JUST_CREATED;
 	VkDescriptorType m_eDescriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
 };
 
@@ -433,6 +373,7 @@ enum EVulkanRenderingStage
 	RENDERING_STAGE_RASTER,
 	RENDERING_STAGE_POST_RASTER,
 	RENDERING_STAGE_FINISHED,
+	RENDERING_STAGE_SYNC,
 };
 
 struct VulkanMaterialCommandBuffer_t
@@ -508,7 +449,8 @@ public:
 	virtual void StartRecording() override;
 	virtual void EndRecording() override;
 
-	virtual void Barrier( IRenderingObject *pObject, bool bIsRead, bool bIsWrite ) override;
+	virtual void Barrier( EStageHazard eBefore, EStageHazard eAfter, uint32_t hazard ) override;
+	virtual void BarrierTransition( IImage *pObject, EImageLayoutHazard old_layout, EImageLayoutHazard layout, EStageHazard eBefore, EStageHazard eAfter, uint32_t hazard ) override;
 	virtual void DispatchCompute( uint32_t uX, uint32_t uY, uint32_t uZ ) override;
 
 	virtual void CopyImageToImage( IImage *pSrc, IImage *pDst ) override;
@@ -517,7 +459,6 @@ public:
 	virtual void ClearDepth( IImage *pImage, float fVal ) override;
 
 	void Submit();
-	void FlushBarriers( CVkCommand *pCmd );
 
 	IVkCommandBufferManager *m_pCommandBufferManager;
 private:
@@ -539,7 +480,6 @@ private:
 	uint32_t m_uHeight;
 	CUtlVector<IVkCommandBuffer*> m_pCommandBuffers = {};
 	CUtlVector<IVkCommandBuffer*> m_pScheduledDestroyPostRaster = {};
-	CUtlVector<VkRenderBarrier_t> m_barriers = {};
 
 	EVulkanRenderingStage m_eCurrentStage = RENDERING_STAGE_SETUP_RASTER;
 };
@@ -547,9 +487,6 @@ private:
 
 IRenderingObject *VulkanGetObject( VkFrameObject_t stObject, int iIndex );
 
-VkAccessFlags2 VulkanGetAccessFlags( EDependencyMode eMode );
-VkPipelineStageFlags2 VulkanGetStageFlags( EDependencyMode eMode );
-VkImageLayout VulkanGetImageLayout( EDependencyMode eMode );
 VkFormat VulkanGetVertexFormat( EVertexFormat eFormat );
 VkPrimitiveTopology VulkanGetTopology( ETopologyMode eMode );
 VkShaderStageFlagBits VulkanGetShaderStage( EShaderStage eStage );

public/materialsystem/imaterialsystem.h

@@ -314,6 +314,35 @@ struct ImageSector_t
 	int32_t m_iHeight;
 };
 
+enum EBarrierHazard
+{
+	BARRIER_HAZARD_DRAW_ARGUMENTS = 0x1,
+	BARRIER_HAZARD_DESCRIPTOR = 0x2,
+	BARRIER_HAZARD_DEPTH_STENCIL = 0x4,
+	BARRIER_HAZARD_RASTER_COLOR = 0x8,
+};
+
+enum EStageHazard
+{
+	STAGE_HAZARD_NONE = 0,
+	STAGE_HAZARD_TRANSFER,
+	STAGE_HAZARD_COMPUTE,
+	STAGE_HAZARD_RASTER_COLOR_OUT,
+	STAGE_HAZARD_RASTER_EARLY_DEPTH_OUT,
+	STAGE_HAZARD_RASTER_LATE_DEPTH_OUT,
+};
+
+enum EImageLayoutHazard
+{
+	IMAGE_LAYOUT_UNDEFINED,
+	IMAGE_LAYOUT_GENERAL,
+	IMAGE_LAYOUT_COLOR,
+	IMAGE_LAYOUT_DEPTH_STENCIL,
+	IMAGE_LAYOUT_PRESENT,
+	IMAGE_LAYOUT_TRANSFER_SRC,
+	IMAGE_LAYOUT_TRANSFER_DST,
+};
+
 abstract_class IRenderCommandList
 {
 public:
@@ -342,7 +371,8 @@ public:
 	virtual void StartRecording() = 0;
 	virtual void EndRecording() = 0;
 
-	virtual void Barrier( IRenderingObject *pObject, bool bIsRead, bool bIsWrite ) = 0;
+	virtual void Barrier( EStageHazard eBefore, EStageHazard eAfter, uint32_t hazard ) = 0;
+	virtual void BarrierTransition( IImage *pObject, EImageLayoutHazard old_layout, EImageLayoutHazard layout, EStageHazard eBefore, EStageHazard eAfter, uint32_t hazard ) = 0;
 	virtual void CopyImageToImage( IImage *pSrc, IImage *pDst ) = 0;
 	virtual void BlitImageToImage( IImage *pSrc, ImageSector_t src, IImage *pDst, ImageSector_t dst ) = 0;
 	virtual void ClearImage( IImage *pImage, float fR, float fG, float fB, float fA ) = 0;
@@ -395,7 +425,7 @@ public:
 	virtual void *GetVulkanInstance() = 0;
 	virtual void *GetVulkanPhysicalDevice() = 0;
 	virtual void *GetVulkanDevice() = 0;
-	virtual IImage *CreateImageFromVkImage( void *pVkImage, uint32_t x, uint32_t y,  uint64_t optimalLayout, EImageFormat eFormat, EMultisampleType eMultisampleType ) = 0;
+	virtual IImage *CreateImageFromVkImage( uint64_t pVkImage, uint32_t x, uint32_t y,  uint64_t optimalLayout, EImageFormat eFormat, EMultisampleType eMultisampleType ) = 0;
 };
 
 #define RENDER_CONTEXT_INTERFACE_VERSION "RenderContext001"