added renderpass manager

engine/filesystem_android.cpp

@@ -16,8 +16,6 @@ class CAndroidDirectoryHandle: public IDirectoryHandle
 public:
 };
 
-#include "android/log.h"
-#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, "funnygame", __VA_ARGS__)
 extern struct android_app *g_android_app;
 class CAndroidFileSystem : public IFileSystem
 {
@@ -29,7 +27,6 @@ public:
 
 	virtual IFileHandle *Open( const char *szFileName, int eOpCode ) override 
 	{
-		LOGI("Opening file: %s", szFileName);
 		FILE *pFile;
 		CAndroidFileHandle *pHandle = NULL;
 
@@ -44,7 +41,6 @@ public:
 		pHandle = new CAndroidFileHandle;
 		pHandle->m_pFileSystem = this;
 		pHandle->m_pFile = AAssetManager_open(g_android_app->activity->assetManager, szFileName, AASSET_MODE_RANDOM);
-		LOGI("Opened file: %p", pHandle->m_pFile);
 		pHandle->m_nSize = AAsset_getLength64(pHandle->m_pFile);
 		return pHandle;
 	}

engine/kottui.cpp

@@ -336,6 +336,7 @@ void CKotUIBuffer::Draw( IImage *pImage )
 
 	pList->EndRecording();
 	m_pRenderContext->SubmitCommandList(pList);
+	m_pRenderContext->DestroyCommandList(pList);
 	m_pRenderContext->DestroyBuffer(pScreenBuffer);
 
 }

game/client/game.cpp

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

materialsystem/build.cpp

@@ -32,6 +32,7 @@ CUtlVector<CUtlString> RenderContextVulkan_CompiledFiles = {
 	"vulkan/commands/transfer.cpp",
 	"vulkan/commands/base.cpp",
 	"vulkan/libraries/raster.cpp",
+	"vulkan/renderpassmgr.cpp",
 	EXTERNAL"volk/volk.c",
 	"stb.c",
 };

materialsystem/gamewindow_android.cpp

@@ -179,7 +179,6 @@ void CAndroidGameWindowManager::Frame( float fDelta )
 	while (ALooper_pollOnce(0, nullptr, &events, (void**)&source) >= 0) {
 		if (source) source->process(g_android_app, source);
 	}
-	LOGI("%u %u", m_window.m_uRenderWidth, m_window.m_uRenderHeight);
 	uint32_t uNewWidth = ANativeWindow_getWidth(g_android_app->window);
 	uint32_t uNewHeight = ANativeWindow_getHeight(g_android_app->window);
 	if (m_window.m_uRenderWidth != uNewWidth || m_window.m_uRenderHeight != uNewHeight)

materialsystem/vulkan/commands.h

@@ -3,6 +3,7 @@
 
 #include "tier1/utlvector.h"
 #include "vulkan_state.h"
+#include "renderpassmgr.h"
 
 BEGIN_VULKAN_COMMAND(Empty)
 END_VULKAN_COMMAND()
@@ -36,12 +37,10 @@ BEGIN_VULKAN_COMMAND(Begin)
 	bool bDepthEnabled = {};
 	uint32_t nResolutionX = 0;
 	uint32_t nResolutionY = 0;
-	VkRenderPass hRenderPass;
+	CRenderPassMgr *pMgr;
-	VkFramebuffer hFrameBuffer;
 END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(End)
-	CVkBeginCommand *pBeginCommand;
 END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(SetVertexBuffer)

materialsystem/vulkan/commands/draw.cpp

@@ -23,9 +23,6 @@ DECLARE_VULKAN_COMMAND(Begin)
 {
 	if (vkCmdBeginRendering || vkCmdBeginRenderingKHR)
 	{
-		V_printf("USING DYNAMIC RENDERING\n");
-		V_printf("%p\n", vkCmdBeginRendering);
-		V_printf("%p\n", vkCmdBeginRenderingKHR);
 		VkRenderingInfo stRenderingInfo = {};
 		CUtlVector<VkRenderingAttachmentInfo> attachments = {};
 		VkRenderingAttachmentInfo depthAttachment = {};
@@ -78,98 +75,42 @@ DECLARE_VULKAN_COMMAND(Begin)
 	}
 	else
 	{
-		V_printf("USING RENDERPASS");
-		CUtlVector<VkAttachmentDescription> attachments = {};
-		CUtlVector<VkAttachmentReference> input_refs = {};
-		CUtlVector<VkImageView> image_views = {};
 		CUtlVector<VkClearValue> colors = {};
-		attachments.Resize(images.GetSize());
+		CUtlVector<RenderImage> imgs = {};
-		input_refs.Resize(images.GetSize());
+		for (auto &a: images)
-		image_views.Resize(images.GetSize());
-		colors.Resize(images.GetSize());
-		uint32_t i = 0;
-
-		for (auto f: images)
 		{
-			VkAttachmentDescription a = {};
+			RenderImage ri = {};
-			a.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+			ri.pImage = (IImage*)a.m_stImage.m_pSingle;
-			a.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+			ri.eLoadMode = a.m_eLoadMode;
-			a.format = CVkImage::GetImageFormat(
+			ri.eStoreMode = a.m_eStoreMode;
-					((CVkImage*)VulkanGetObject(f.m_stImage, iCurrentFrame))->m_eFormat);
+			VkClearValue ci = {};
-			a.samples = CVkImage::GetMultisampling(
+			ci.color.float32[0] = a.m_fClearColor[0];
-					((CVkImage*)VulkanGetObject(f.m_stImage, iCurrentFrame))->m_eMultisampleType);
+			ci.color.float32[1] = a.m_fClearColor[1];
-			switch( f.m_eLoadMode )
+			ci.color.float32[2] = a.m_fClearColor[2];
-			{
+			ci.color.float32[3] = a.m_fClearColor[3];
-			case LOAD_MODE_DONT_CARE:
+			colors.AppendTail(ci);
-				a.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+			imgs.AppendTail(ri);
-				break;
-			case LOAD_MODE_LOAD:
-				a.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
-				break;
-			case LOAD_MODE_CLEAR:
-				a.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
-				colors[i].color.float32[0] = f.m_fClearColor[0];
-				colors[i].color.float32[1] = f.m_fClearColor[1];
-				colors[i].color.float32[2] = f.m_fClearColor[2];
-				colors[i].color.float32[3] = f.m_fClearColor[3];
-				break;
-			}
-			a.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-			attachments[i] = a;
-
-			VkAttachmentReference ref = {};
-			ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-			ref.attachment = i;
-			input_refs[i] = ref;
-			
-			image_views[i] = ((CVkImage*)VulkanGetObject(f.m_stImage, iCurrentFrame))->m_imageView;
-			i++;
-
 		}
+		RenderImage depth = {};
+		depth.pImage = (IImage*)stDepthImage.m_stImage.m_pSingle;
+		depth.eLoadMode = stDepthImage.m_eLoadMode;
+		depth.eStoreMode = stDepthImage.m_eStoreMode;
+		BeginInfo bi = {};
+		bi.uRenderImageCount = imgs.GetSize();
+		bi.pRenderImages = imgs.GetData();
+		bi.uWidth = nResolutionX;
+		bi.uHeight = nResolutionY;
 		if (bDepthEnabled)
 		{
-			CVkImage *depth = (CVkImage*)VulkanGetObject(stDepthImage.m_stImage, iCurrentFrame); 
+			bi.pDepth = &depth;
-			VkAttachmentDescription desc = {};
+			VkClearValue ci = {};
-			desc.format = CVkImage::GetImageFormat(depth->m_eFormat);
+			ci.depthStencil.depth = stDepthImage.m_fClearDepth;
-			desc.samples = CVkImage::GetMultisampling(depth->m_eMultisampleType);
+			colors.AppendTail(ci);
-			desc.initialLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
-			desc.finalLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
-			desc.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
-			desc.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-			attachments.AppendTail(desc);
-			VkClearValue val = {};
-			val.depthStencil.depth = stDepthImage.m_fClearDepth;
-			colors.AppendTail(val);
-			image_views.AppendTail(depth->m_imageView);
 		}
-		VkAttachmentReference depthRef;
+		VkRenderPass hRenderPass;
-		depthRef.attachment = attachments.GetSize() - 1;
+		VkFramebuffer hFrameBuffer;
-		depthRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+		pMgr->CreateRenderPass(&bi, &hRenderPass, &hFrameBuffer);
-		VkSubpassDescription subpass = {};
-		subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
-		subpass.colorAttachmentCount = input_refs.GetSize();
-		subpass.pColorAttachments = input_refs.GetData();
-		if (bDepthEnabled)
-		{
-			subpass.pDepthStencilAttachment = &depthRef;
-		}
-		VkRenderPassCreateInfo rpci = {};
-		rpci.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
-		rpci.attachmentCount = attachments.GetSize();
-		rpci.pAttachments = attachments.GetData();
-		rpci.subpassCount = 1;
-		rpci.pSubpasses = &subpass;
-		vkCreateRenderPass(hDevice, &rpci, NULL, &hRenderPass);
 
-		VkFramebufferCreateInfo fbci = {};
-		fbci.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
-		fbci.renderPass = hRenderPass;
-		fbci.attachmentCount = image_views.GetSize();
-		fbci.pAttachments = image_views.GetData();
-		fbci.width = nResolutionX;
-		fbci.height = nResolutionY;
-		fbci.layers = 1;
-		vkCreateFramebuffer(hDevice, &fbci, NULL, &hFrameBuffer);
 		VkRenderPassBeginInfo rpbi = {};
 		rpbi.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
 		rpbi.renderPass = hRenderPass;
@@ -190,7 +131,6 @@ DECLARE_VULKAN_COMMAND(End)
 	else
 	{
 		vkCmdEndRenderPass(hCommandBuffer);
-
 	}
 }
 

materialsystem/vulkan/rendercommandlist.cpp

@@ -34,6 +34,7 @@ void CVkRenderCommandList::Begin( BeginInfo *pBegin )
 		images.AppendTail(output);
 	}
 	pBeginCommand->images = images;
+	pBeginCommand->pMgr = m_pRenderPassMgr;
 	if ( pBegin->pDepth )
 	{
 		VulkanRenderOutput_t output = {};
@@ -50,7 +51,6 @@ void CVkRenderCommandList::Begin( BeginInfo *pBegin )
 void CVkRenderCommandList::End()
 {
 	CVkEndCommand *pEndCommand = CREATE_COMMAND(m_pCommandBufferManager, End);
-	pEndCommand->pBeginCommand = (CVkBeginCommand*)m_pCurrentBegin;
 	m_pCommandBuffer->AddCommand(pEndCommand);
 }
 
@@ -181,6 +181,7 @@ void CVkRenderCommandList::ResolveImage( IImage *pOriginal, IImage *pResolved )
 
 void CVkRenderCommandList::StartRecording()
 {
+	if (m_pCommandBuffer == NULL)
 		m_pCommandBuffer = m_pCommandBufferManager->CreateCommandBuffer();
 	m_pCommandBuffer->Reset();
 }

materialsystem/vulkan/rendercontext.cpp

@@ -156,9 +156,10 @@ VkFormat CVkImage::GetImageFormat( enum EImageFormat eImageFormat )
 
 	case IMAGE_FORMAT_D32_SFLOAT:
 		return VK_FORMAT_D32_SFLOAT;
-	}
+	default:
 		return VK_FORMAT_UNDEFINED;
 	}
+}
 
 VkSampleCountFlagBits CVkImage::GetMultisampling( enum EMultisampleType eImageFormat )
 {
@@ -514,6 +515,7 @@ public:
 	virtual void *GetVulkanPhysicalDevice() override;
 	virtual void *GetVulkanDevice() 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();
@@ -538,6 +540,7 @@ private:
 	CUtlVector<CVkImage*> m_scheduledRemovalImages;
 
 	CVkSampler m_defaultSampler;
+	CRenderPassMgr m_renderPassMgr = {};
 };
 EXPOSE_INTERFACE(CVkRenderContext, IRenderContext, RENDER_CONTEXT_INTERFACE_VERSION);
 
@@ -681,6 +684,7 @@ IRenderCommandList *CVkRenderContext::CreateCommandList()
 {
 	CVkRenderCommandList *pList = new CVkRenderCommandList;
 	pList->m_pCommandBufferManager = m_pCommandBufferManager;
+	pList->m_pRenderPassMgr = &m_renderPassMgr;
 	return pList;
 }
 
@@ -941,6 +945,8 @@ void CVkRenderContext::Init()
 	samplerInfo.minLod = 0.0f;
 	samplerInfo.maxLod = VK_LOD_CLAMP_NONE;
 	vkCreateSampler(s_vkDevice, &samplerInfo, nullptr, &m_defaultSampler.m_sampler);
+
+	m_renderPassMgr.m_hDevice = s_vkDevice;
 }
 
 #include "time.h"
@@ -1127,6 +1133,8 @@ void CVkRenderContext::Frame( float fDeltaTime )
 	m_scheduledRemovalTextureArrays = {};
 	m_scheduledRemovalBuffers = {};
 
+	m_renderPassMgr.Frame();
+
 }
 
 VulkanWindow_t CVkRenderContext::CreateSwapchain( IGameWindow *pWindow )

materialsystem/vulkan/renderpassmgr.cpp

@@ -0,0 +1,229 @@
+#include "renderpassmgr.h"
+
+void CRenderPassMgr::CreateRenderPass(BeginInfo *pBeginInfo, VkRenderPass *prp, VkFramebuffer *pfb)
+{
+	RenderPassHandle *pRP = FindRenderPass(pBeginInfo);
+
+	*prp = pRP->renderpass;
+	if (pRP->framebuffer)
+	{
+		if (pRP->uWidth != pBeginInfo->uWidth)
+			goto recreate;
+		if (pRP->uHeight != pBeginInfo->uHeight)
+			goto recreate;
+		for (uint32_t i = 0; i < pRP->usages.GetSize(); i++)
+		{
+			RenderPassUsage *u = &pRP->usages[i];
+			RenderImage *im = &pBeginInfo->pRenderImages[i];
+			CVkImage *vku = (CVkImage*)u->pImage;
+			CVkImage *imu = (CVkImage*)im->pImage;
+			if (vku != imu)
+				goto recreate;
+			if (vku->m_imageView != imu->m_imageView)
+				goto recreate;
+		}
+		if (pRP->bIsDepth)
+		{
+
+			CVkImage *vku = (CVkImage*)pRP->depth.pImage;
+			CVkImage *imu = (CVkImage*)pBeginInfo->pDepth->pImage;
+			if (vku != imu)
+				goto recreate;
+			if (vku->m_imageView != imu->m_imageView)
+				goto recreate;
+		}
+		*pfb = pRP->framebuffer;
+		return;
+recreate:
+		m_scheduledReleasesFB.AppendTail(pRP->framebuffer);
+	}
+
+	CUtlVector<VkImageView> image_views = {};
+	for (uint32_t i = 0; i < pRP->usages.GetSize(); i++)
+	{
+		RenderPassUsage *u = &pRP->usages[i];
+		RenderImage *im = &pBeginInfo->pRenderImages[i];
+		CVkImage *imu = (CVkImage*)im->pImage;
+		u->pImage = imu;
+		image_views.AppendTail(imu->m_imageView);
+	}
+	if (pRP->bIsDepth)
+	{
+		CVkImage *imu = (CVkImage*)pBeginInfo->pDepth->pImage;
+		pRP->depth.pImage = imu;
+		image_views.AppendTail(imu->m_imageView);
+	}
+	image_views.Reserve(pBeginInfo->uRenderImageCount);
+	VkFramebufferCreateInfo fbci = {};
+	fbci.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+	fbci.renderPass = pRP->renderpass;
+	fbci.attachmentCount = image_views.GetSize();
+	fbci.pAttachments = image_views.GetData();
+	fbci.width = pBeginInfo->uWidth;
+	fbci.height = pBeginInfo->uHeight;
+	fbci.layers = 1;
+	vkCreateFramebuffer(m_hDevice, &fbci, NULL, &pRP->framebuffer);
+	pRP->uWidth = pBeginInfo->uWidth;
+	pRP->uHeight = pBeginInfo->uHeight;
+	*pfb = pRP->framebuffer;
+}
+
+void CRenderPassMgr::Frame()
+{
+	CUtlVector<RenderPassHandle> renderPassHandles = {};
+	for (auto &r: m_renderPassHandles)
+	{
+		if (r.bIsUsed)
+		{
+			renderPassHandles.AppendTail(r);
+			r.bIsUsed = false;
+		}
+		else
+		{
+			m_scheduledReleasesRP.AppendTail(r.renderpass);
+			m_scheduledReleasesFB.AppendTail(r.framebuffer);
+		}
+
+	}
+	m_renderPassHandles = renderPassHandles;
+
+	for (auto fb: m_scheduledReleasesFB)
+	{
+		vkDestroyFramebuffer(m_hDevice, fb, NULL);
+	}
+	for (auto rp: m_scheduledReleasesRP)
+	{
+		vkDestroyRenderPass(m_hDevice, rp, NULL);
+	}
+	m_scheduledReleasesFB = {};
+	m_scheduledReleasesRP = {};
+
+}
+RenderPassHandle *CRenderPassMgr::FindRenderPass(BeginInfo *pBeginInfo)
+{
+	for (auto &r: m_renderPassHandles)
+	{
+		if (!(pBeginInfo->pDepth && r.bIsDepth))
+			continue;
+		if (pBeginInfo->uRenderImageCount != r.usages.GetSize())
+			continue;
+		for (uint32_t i = 0; i < r.usages.GetSize(); i++)
+		{
+			RenderPassUsage *u = &r.usages[i];
+			RenderImage *im = &pBeginInfo->pRenderImages[i];
+			if (u->eLoadMode != im->eLoadMode)
+				goto next_usage;
+			if (u->eStoreMode != im->eStoreMode)
+				goto next_usage;
+			if (u->eFormat != im->pImage->GetImageFormat())
+				goto next_usage;
+			if (u->eMultisampleType != im->pImage->GetMultisampleType())
+				goto next_usage;
+		}
+		r.bIsUsed = true;
+		return &r;
+next_usage:
+		continue;
+	}
+	
+	VkRenderPass hRenderPass = NULL;
+	CUtlVector<VkAttachmentDescription> attachments = {};
+	CUtlVector<VkAttachmentReference> input_refs = {};
+	attachments.Resize(pBeginInfo->uRenderImageCount);
+	input_refs.Resize(pBeginInfo->uRenderImageCount);
+	uint32_t i = 0;
+
+	for (uint32_t i = 0; i < pBeginInfo->uRenderImageCount; i++)
+	{
+		RenderImage *ri = pBeginInfo->pRenderImages+i;
+
+		VkAttachmentDescription a = {};
+		a.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+		a.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+		a.format = CVkImage::GetImageFormat(ri->pImage->GetImageFormat());
+		a.samples = CVkImage::GetMultisampling(ri->pImage->GetMultisampleType());
+
+		V_printf("INTERNAL IMAGE %p\n",ri->pImage);
+		V_printf("  %u\n",ri->pImage->GetImageFormat());
+		V_printf("  %u\n",ri->pImage->GetMultisampleType());
+		switch( ri->eLoadMode )
+		{
+		case LOAD_MODE_DONT_CARE:
+			a.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+			break;
+		case LOAD_MODE_LOAD:
+			a.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
+			break;
+		case LOAD_MODE_CLEAR:
+			a.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+			break;
+		}
+		a.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+		attachments[i] = a;
+
+		VkAttachmentReference ref = {};
+		ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+		ref.attachment = i;
+		input_refs[i] = ref;
+
+	}
+	if (pBeginInfo->pDepth)
+	{
+		CVkImage *depth = (CVkImage*)pBeginInfo->pDepth->pImage; 
+		VkAttachmentDescription desc = {};
+		desc.format = CVkImage::GetImageFormat(depth->GetImageFormat());
+		desc.samples = CVkImage::GetMultisampling(depth->GetMultisampleType());
+		desc.initialLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
+		desc.finalLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
+		desc.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+		desc.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+		desc.initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+		desc.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+		attachments.AppendTail(desc);
+	}
+	VkAttachmentReference depthRef;
+	depthRef.attachment = attachments.GetSize() - 1;
+	depthRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+	VkSubpassDescription subpass = {};
+	subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+	subpass.colorAttachmentCount = input_refs.GetSize();
+	subpass.pColorAttachments = input_refs.GetData();
+	if (pBeginInfo->pDepth)
+	{
+		subpass.pDepthStencilAttachment = &depthRef;
+	}
+	VkRenderPassCreateInfo rpci = {};
+	rpci.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+	rpci.attachmentCount = attachments.GetSize();
+	rpci.pAttachments = attachments.GetData();
+	rpci.subpassCount = 1;
+	rpci.pSubpasses = &subpass;
+	vkCreateRenderPass(m_hDevice, &rpci, NULL, &hRenderPass);
+
+	RenderPassHandle hHandle = {};
+	if (pBeginInfo->pDepth)
+	{
+		V_printf("DEPTH %p\n", pBeginInfo->pDepth->pImage);
+		hHandle.depth.pImage = pBeginInfo->pDepth->pImage;
+		hHandle.depth.eMultisampleType = pBeginInfo->pDepth->pImage->GetMultisampleType();
+		hHandle.depth.eFormat = pBeginInfo->pDepth->pImage->GetImageFormat();
+		hHandle.depth.eLoadMode = pBeginInfo->pDepth->eLoadMode;
+		hHandle.depth.eStoreMode = pBeginInfo->pDepth->eStoreMode;
+		hHandle.bIsDepth = true;
+	}
+	for (uint32_t i = 0; i < pBeginInfo->uRenderImageCount; i++)
+	{
+		RenderPassUsage hUsage = {};
+		RenderImage *ri = pBeginInfo->pRenderImages+i;
+		hUsage.pImage = ri->pImage;
+		hUsage.eMultisampleType = ri->pImage->GetMultisampleType();
+		hUsage.eFormat = ri->pImage->GetImageFormat();
+		hUsage.eLoadMode = ri->eLoadMode;
+		hUsage.eStoreMode = ri->eStoreMode;
+		hHandle.usages.AppendTail(hUsage);
+	}
+	hHandle.bIsUsed = true;
+	hHandle.renderpass = hRenderPass;
+	m_renderPassHandles.AppendTail(hHandle);
+	return &m_renderPassHandles[m_renderPassHandles.GetSize()-1];
+}

materialsystem/vulkan/renderpassmgr.h

@@ -0,0 +1,40 @@
+#ifndef RENDERPASSMGR_H
+#define RENDERPASSMGR_H
+
+#include "vulkan_state.h"
+
+struct RenderPassUsage
+{
+	IImage *pImage;
+	EImageFormat eFormat;
+	EMultisampleType eMultisampleType;
+	ELoadMode eLoadMode;
+	EStoreMode eStoreMode;
+};
+
+struct RenderPassHandle
+{
+	uint32_t uWidth;
+	uint32_t uHeight;
+	CUtlVector<RenderPassUsage> usages;
+	RenderPassUsage depth;
+	VkRenderPass renderpass;
+	VkFramebuffer framebuffer;
+	bool bIsDepth;
+	bool bIsUsed;
+};
+
+class CRenderPassMgr
+{
+public:
+	void CreateRenderPass(BeginInfo *pBeginInfo, VkRenderPass *prp, VkFramebuffer *pfb);
+	void Frame();
+	VkDevice m_hDevice;
+private:
+	RenderPassHandle *FindRenderPass(BeginInfo *pBeginInfo);
+	CUtlVector<RenderPassHandle> m_renderPassHandles;
+	CUtlVector<VkFramebuffer> m_scheduledReleasesFB;
+	CUtlVector<VkRenderPass> m_scheduledReleasesRP;
+	
+};
+#endif

materialsystem/vulkan/vulkan_state.h

@@ -456,6 +456,7 @@ public:
 	void Submit();
 
 	IVkCommandBufferManager *m_pCommandBufferManager;
+	class CRenderPassMgr *m_pRenderPassMgr;
 private:
 	IVkCommandBuffer *m_pCommandBuffer = NULL;
 	CVkCommand *m_pCurrentBegin = NULL;