render pass first work

funnyassets/shaders/agx.shader

@@ -22,11 +22,11 @@ CS
 	Texture2D<float4> g_in;
 	RWTexture2D<float4> g_out;
 
-	[numthreads(1,1,1)]
+	[numthreads(32,32,1)]
 	void csMain( int3 threadId : SV_DispatchThreadID )
 	{
 		float4 vColor = g_in.Load(threadId);
-		vColor.xyz = agxDefaultContrastApprox(vColor.xyz);
+		//vColor.xyz = agxDefaultContrastApprox(vColor.xyz);
 		g_out.Store(threadId.xy, vColor);
 
 	}

game/client/worldrender.cpp

@@ -48,13 +48,13 @@ void CFunnyViewport::UpdateResolution( uint32_t uX, uint32_t uY )
 		g_pRenderContext->DestroyImage(m_pColorResolved);
 		g_pRenderContext->DestroyImage(m_pRenderImage);
 	}
-	m_pColor = g_pRenderContext->CreateRenderTarget(uX, uY, IMAGE_FORMAT_RGBA8_UNORM, MULTISAMPLE_TYPE_4_SAMPLES);
+	m_pColor = g_pRenderContext->CreateRenderTarget(uX, uY, IMAGE_FORMAT_RGBA8_UNORM, MULTISAMPLE_TYPE_1_SAMPLES);
 	m_pColor->SetDebugName("m_pColor");
-	m_pNormal = g_pRenderContext->CreateRenderTarget(uX, uY, IMAGE_FORMAT_RGBA16_SNORM, MULTISAMPLE_TYPE_4_SAMPLES);
+	m_pNormal = g_pRenderContext->CreateRenderTarget(uX, uY, IMAGE_FORMAT_RGBA16_SNORM, MULTISAMPLE_TYPE_1_SAMPLES);
 	m_pNormal->SetDebugName("m_pNormal");
-	m_pWorldCoords = g_pRenderContext->CreateRenderTarget(uX, uY, IMAGE_FORMAT_RGBA32_SFLOAT, MULTISAMPLE_TYPE_4_SAMPLES);
+	m_pWorldCoords = g_pRenderContext->CreateRenderTarget(uX, uY, IMAGE_FORMAT_RGBA32_SFLOAT, MULTISAMPLE_TYPE_1_SAMPLES);
 	m_pWorldCoords->SetDebugName("m_pWorldCoords");
-	m_pDepth = g_pRenderContext->CreateRenderTarget(uX, uY, IMAGE_FORMAT_D32_SFLOAT, MULTISAMPLE_TYPE_4_SAMPLES);
+	m_pDepth = g_pRenderContext->CreateRenderTarget(uX, uY, IMAGE_FORMAT_D32_SFLOAT, MULTISAMPLE_TYPE_1_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");
@@ -268,7 +268,7 @@ void CFunnyWorldRenderer::ConfigureShader( IShader *pShader )
 	pShader->AddOutputImage(1, IMAGE_FORMAT_RGBA16_SNORM);
 	pShader->AddOutputImage(2, IMAGE_FORMAT_RGBA32_SFLOAT);
 
-	pShader->SetMultisampling(MULTISAMPLE_TYPE_4_SAMPLES);
+	pShader->SetMultisampling(MULTISAMPLE_TYPE_1_SAMPLES);
 
 	pShader->SetDepthImage(IMAGE_FORMAT_D32_SFLOAT);
 }
@@ -402,9 +402,10 @@ void CFunnyWorldRenderer::Frame( float fDelta )
 		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, 
+				IMAGE_LAYOUT_COLOR, IMAGE_LAYOUT_GENERAL, 
-				STAGE_HAZARD_RASTER_COLOR_OUT, STAGE_HAZARD_TRANSFER, 
+				STAGE_HAZARD_RASTER_COLOR_OUT, STAGE_HAZARD_COMPUTE, 
 				0);
+		/*
 		m_pRasterCommandList->BarrierTransition(
 				v->m_pColorResolved, 
 				IMAGE_LAYOUT_UNDEFINED, IMAGE_LAYOUT_TRANSFER_DST, 
@@ -417,16 +418,17 @@ void CFunnyWorldRenderer::Frame( float fDelta )
 				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(0, 0, v->m_pColor);
 		m_pPostProcessingMaterial->CSSetTexture(1, 0, v->m_pRenderImage);
 		m_pRasterCommandList->SetMaterial(m_pPostProcessingMaterial);
-		m_pRasterCommandList->DispatchCompute(uWidth, uHeight, 1);
+		m_pRasterCommandList->DispatchCompute((uWidth+31)/32, (uHeight+31)/32, 1);
 		m_pRasterCommandList->Barrier(STAGE_HAZARD_COMPUTE, STAGE_HAZARD_NONE, 0);
 		m_pRasterCommandList->EndRecording();
 

materialsystem/vulkan/commandbuffer.cpp

@@ -17,6 +17,7 @@ private:
 	CUtlVector<CVkCommand*> m_commands;
 	VkCommandBuffer m_hBuffer = NULL;
 
+
 	VkDevice m_hDevice;
 	IVkCommandBufferManager *m_pMgr;
 	VkCommandPool m_hPool = NULL;
@@ -82,7 +83,7 @@ void CVkCommandBuffer::Render()
 
 	for (auto &pCommand: m_commands)
 	{
-		pCommand->Execute(m_hBuffer, 0);
+		pCommand->Execute(m_hDevice, m_hBuffer, 0);
 	};
 	vkEndCommandBuffer(m_hBuffer);
 	

materialsystem/vulkan/commands.h

@@ -36,11 +36,12 @@ BEGIN_VULKAN_COMMAND(Begin)
 	bool bDepthEnabled = {};
 	uint32_t nResolutionX = 0;
 	uint32_t nResolutionY = 0;
-
+	VkRenderPass hRenderPass;
-	
+	VkFramebuffer hFrameBuffer;
 END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(End)
+	CVkBeginCommand *pBeginCommand;
 END_VULKAN_COMMAND()
 
 BEGIN_VULKAN_COMMAND(SetVertexBuffer)

materialsystem/vulkan/commands/draw.cpp

@@ -21,57 +21,170 @@ DECLARE_VULKAN_COMMAND(ClearColor)
 
 DECLARE_VULKAN_COMMAND(Begin)
 {
-	VkRenderingInfo stRenderingInfo = {};
+	if (vkCmdBeginRendering || vkCmdBeginRenderingKHR)
-	CUtlVector<VkRenderingAttachmentInfo> attachments = {};
-	VkRenderingAttachmentInfo depthAttachment = {};
-	for (auto i: images)
 	{
-		VkRenderingAttachmentInfo a = {};
+		VkRenderingInfo stRenderingInfo = {};
-		a.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
+		CUtlVector<VkRenderingAttachmentInfo> attachments = {};
-		a.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+		VkRenderingAttachmentInfo depthAttachment = {};
-		switch( i.m_eLoadMode )
+		for (auto i: images)
 		{
-		case LOAD_MODE_DONT_CARE:
+			VkRenderingAttachmentInfo a = {};
-			a.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+			a.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
-			break;
+			a.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-		case LOAD_MODE_LOAD:
+			switch( i.m_eLoadMode )
-			a.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
+			{
-			break;
+			case LOAD_MODE_DONT_CARE:
-		case LOAD_MODE_CLEAR:
+				a.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-			a.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+				break;
-			a.clearValue.color.float32[0] = i.m_fClearColor[0];
+			case LOAD_MODE_LOAD:
-			a.clearValue.color.float32[1] = i.m_fClearColor[1];
+				a.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
-			a.clearValue.color.float32[2] = i.m_fClearColor[2];
+				break;
-			a.clearValue.color.float32[3] = i.m_fClearColor[3];
+			case LOAD_MODE_CLEAR:
-			break;
+				a.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+				a.clearValue.color.float32[0] = i.m_fClearColor[0];
+				a.clearValue.color.float32[1] = i.m_fClearColor[1];
+				a.clearValue.color.float32[2] = i.m_fClearColor[2];
+				a.clearValue.color.float32[3] = i.m_fClearColor[3];
+				break;
+			}
+			a.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+			a.imageView = ((CVkImage*)VulkanGetObject(i.m_stImage, iCurrentFrame))->m_imageView;
+			attachments.AppendTail(a);
 		}
-		a.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+		if (bDepthEnabled)
-		a.imageView = ((CVkImage*)VulkanGetObject(i.m_stImage, iCurrentFrame))->m_imageView;
+		{
-		attachments.AppendTail(a);
+			depthAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
+			depthAttachment.imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
+			depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+			depthAttachment.clearValue.depthStencil.depth = stDepthImage.m_fClearDepth;
+			depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+			depthAttachment.imageView = ((CVkImage*)VulkanGetObject(stDepthImage.m_stImage, iCurrentFrame))->m_imageView;
+			stRenderingInfo.pDepthAttachment = &depthAttachment;
+		}
+
+		stRenderingInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
+		stRenderingInfo.layerCount = 1;
+		stRenderingInfo.colorAttachmentCount = attachments.GetSize();
+		stRenderingInfo.pColorAttachments = attachments.GetData();
+		stRenderingInfo.renderArea = (VkRect2D){0,0,nResolutionX,nResolutionY};
+		
+		if (vkCmdBeginRendering)
+			vkCmdBeginRendering(hCommandBuffer, &stRenderingInfo);
+		else
+			vkCmdBeginRenderingKHR(hCommandBuffer, &stRenderingInfo);
 	}
-	if (bDepthEnabled)
+	else
 	{
-		depthAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
+		CUtlVector<VkAttachmentDescription> attachments = {};
-		depthAttachment.imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
+		CUtlVector<VkAttachmentReference> input_refs = {};
-		depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+		CUtlVector<VkImageView> image_views = {};
-		depthAttachment.clearValue.depthStencil.depth = stDepthImage.m_fClearDepth;
+		CUtlVector<VkClearValue> colors = {};
-		depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+		attachments.Resize(images.GetSize());
-		depthAttachment.imageView = ((CVkImage*)VulkanGetObject(stDepthImage.m_stImage, iCurrentFrame))->m_imageView;
+		input_refs.Resize(images.GetSize());
-		stRenderingInfo.pDepthAttachment = &depthAttachment;
+		image_views.Resize(images.GetSize());
+		colors.Resize(images.GetSize());
+		uint32_t i = 0;
+
+		for (auto f: images)
+		{
+			VkAttachmentDescription a = {};
+			a.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+			a.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+			a.format = CVkImage::GetImageFormat(
+					((CVkImage*)VulkanGetObject(f.m_stImage, iCurrentFrame))->m_eFormat);
+			a.samples = CVkImage::GetMultisampling(
+					((CVkImage*)VulkanGetObject(f.m_stImage, iCurrentFrame))->m_eMultisampleType);
+			switch( f.m_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;
+				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++;
+
+		}
+		if (bDepthEnabled)
+		{
+			CVkImage *depth = (CVkImage*)VulkanGetObject(stDepthImage.m_stImage, iCurrentFrame); 
+			VkAttachmentDescription desc = {};
+			desc.format = CVkImage::GetImageFormat(depth->m_eFormat);
+			desc.samples = CVkImage::GetMultisampling(depth->m_eMultisampleType);
+			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;
+		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 (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;
+		rpbi.framebuffer = hFrameBuffer;
+		rpbi.renderArea = (VkRect2D){0,0,nResolutionX,nResolutionY};
+		rpbi.clearValueCount = colors.GetSize();
+		rpbi.pClearValues = colors.GetData();
+		vkCmdBeginRenderPass(hCommandBuffer, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
 	}
-
-	stRenderingInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
-	stRenderingInfo.layerCount = 1;
-	stRenderingInfo.colorAttachmentCount = attachments.GetSize();
-	stRenderingInfo.pColorAttachments = attachments.GetData();
-	stRenderingInfo.renderArea = (VkRect2D){0,0,nResolutionX,nResolutionY};
-	
-	vkCmdBeginRendering(hCommandBuffer, &stRenderingInfo);
 }
 
 DECLARE_VULKAN_COMMAND(End)
 {
-	vkCmdEndRendering(hCommandBuffer);
+	if (vkCmdEndRendering)
+		vkCmdEndRendering(hCommandBuffer);
+	else if (vkCmdEndRenderingKHR)
+		vkCmdEndRenderingKHR(hCommandBuffer);
+	else
+		vkCmdEndRenderPass(hCommandBuffer);
 }
 
 DECLARE_VULKAN_COMMAND(SetShader)
@@ -118,7 +231,10 @@ DECLARE_VULKAN_COMMAND(SetScissors)
 			uHeight,
 		},
 	};
-	vkCmdSetScissorWithCount(hCommandBuffer, 1, &r);
+	if (vkCmdSetScissorWithCount)
+		vkCmdSetScissorWithCount(hCommandBuffer, 1, &r);
+	else
+		vkCmdSetScissor(hCommandBuffer, 0, 1, &r);
 }
 
 DECLARE_VULKAN_COMMAND(SetViewport)
@@ -131,7 +247,10 @@ DECLARE_VULKAN_COMMAND(SetViewport)
 		fDepthMin,
 		fDepthMax
 	};
-	vkCmdSetViewportWithCount(hCommandBuffer, 1, &v);
+	if (vkCmdSetScissorWithCount)
+		vkCmdSetViewportWithCount(hCommandBuffer, 1, &v);
+	else
+		vkCmdSetViewport(hCommandBuffer, 0, 1, &v);
 }
 DECLARE_VULKAN_COMMAND(ResolveImage)
 {
@@ -176,7 +295,7 @@ static VkPipelineStageFlags2 GetStage( EStageHazard stage )
 	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;
+		return VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT;
 	case STAGE_HAZARD_RASTER_LATE_DEPTH_OUT:
 		return VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT;
 	}
@@ -197,7 +316,7 @@ static VkAccessFlags2 GetAccessSrc( uint32_t hazard, EStageHazard stage )
 	if (stage == STAGE_HAZARD_RASTER_COLOR_OUT)
 	{
 		if (hazard & BARRIER_HAZARD_RASTER_COLOR)
-			f |= VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
+			f |= VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT;
 
 	}
 	if (hazard == 0)
@@ -244,7 +363,6 @@ static VkImageLayout GetLayout( EImageLayoutHazard hazard )
 
 DECLARE_VULKAN_COMMAND(Barrier)
 {
-
 	VkMemoryBarrier2 barrier = {};
 	barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2;
 	barrier.srcStageMask = GetStage(eStageIn);
@@ -255,7 +373,23 @@ DECLARE_VULKAN_COMMAND(Barrier)
 	dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
 	dependency.memoryBarrierCount = 1;
 	dependency.pMemoryBarriers = &barrier;
-	vkCmdPipelineBarrier2(hCommandBuffer, &dependency);
+	if (vkCmdPipelineBarrier2)
+		vkCmdPipelineBarrier2(hCommandBuffer, &dependency);
+	else if (vkCmdPipelineBarrier2KHR)
+		vkCmdPipelineBarrier2KHR(hCommandBuffer, &dependency);
+	else
+	{
+		VkMemoryBarrier barrier = {};
+		barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
+		barrier.srcAccessMask = GetAccessSrc(eHazard, eStageIn);
+		barrier.dstAccessMask = GetAccessDst(eHazard, eStageOut);
+		vkCmdPipelineBarrier(hCommandBuffer, 
+				GetStage(eStageIn),
+				GetStage(eStageOut),
+				0, 1,&barrier, 0, NULL, 0, NULL);
+
+	}
+
 }
 
 DECLARE_VULKAN_COMMAND(LayoutBarrier)
@@ -274,5 +408,24 @@ DECLARE_VULKAN_COMMAND(LayoutBarrier)
 	dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
 	dependency.imageMemoryBarrierCount = 1;
 	dependency.pImageMemoryBarriers = &barrier;
-	vkCmdPipelineBarrier2(hCommandBuffer, &dependency);
+	if (vkCmdPipelineBarrier2)
+		vkCmdPipelineBarrier2(hCommandBuffer, &dependency);
+	else if (vkCmdPipelineBarrier2KHR)
+		vkCmdPipelineBarrier2KHR(hCommandBuffer, &dependency);
+	else
+	{
+		VkImageMemoryBarrier barrier = {};
+		barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+		barrier.srcAccessMask = GetAccessSrc(eHazard, eStageIn);
+		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);
+		vkCmdPipelineBarrier(hCommandBuffer, 
+				GetStage(eStageIn),
+				GetStage(eStageOut),
+				0, 0, NULL, 0, NULL, 1, &barrier);
+
+	}
 }

materialsystem/vulkan/commands/transfer.cpp

@@ -45,6 +45,11 @@ DECLARE_VULKAN_COMMAND(CopyBufferToImage)
 		.imageOffset = {iOffsetX, iOffsetY, iOffsetZ},
 		.imageExtent = {iImageX, iImageY, iImageZ},
 	};
+	VkBufferImageCopy r2 = {
+		.imageSubresource = r.imageSubresource,
+		.imageOffset = r.imageOffset,
+		.imageExtent = r.imageExtent
+	};
 	VkCopyBufferToImageInfo2 c = {
 		.sType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2,
 		.srcBuffer = ((CVkBuffer*)pBuffer)->m_buffer,
@@ -53,5 +58,8 @@ DECLARE_VULKAN_COMMAND(CopyBufferToImage)
 		.regionCount = 1,
 		.pRegions = &r,
 	};
-	vkCmdCopyBufferToImage2(hCommandBuffer, &c);
+	if (vkCmdCopyBufferToImage2)
+		vkCmdCopyBufferToImage2(hCommandBuffer, &c);
+	else
+		vkCmdCopyBufferToImage(hCommandBuffer, c.srcBuffer, c.dstImage, c.dstImageLayout, 1, &r2);
 }

materialsystem/vulkan/device_extensions.h

@@ -2,6 +2,16 @@ REQUIRED_EXTENSION(VK_KHR_SWAPCHAIN)
 REQUIRED_EXTENSION(VK_KHR_PIPELINE_LIBRARY)
 REQUIRED_EXTENSION(VK_EXT_GRAPHICS_PIPELINE_LIBRARY)
 REQUIRED_EXTENSION(VK_KHR_EXTERNAL_FENCE_CAPABILITIES)
+REQUIRED_EXTENSION(VK_EXT_DESCRIPTOR_INDEXING)
+REQUIRED_EXTENSION(VK_KHR_TIMELINE_SEMAPHORE )
+REQUIRED_EXTENSION(VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS)
 OPTIONAL_EXTENSION(VK_KHR_RAY_TRACING_PIPELINE)
 OPTIONAL_EXTENSION(VK_KHR_ACCELERATION_STRUCTURE)
 OPTIONAL_EXTENSION(VK_KHR_DEFERRED_HOST_OPERATIONS)
+OPTIONAL_EXTENSION(VK_KHR_BUFFER_DEVICE_ADDRESS)
+OPTIONAL_EXTENSION(VK_EXT_BUFFER_DEVICE_ADDRESS)
+OPTIONAL_EXTENSION(VK_KHR_MAINTENANCE_5)
+//OPTIONAL_EXTENSION(VK_KHR_DYNAMIC_RENDERING)
+//OPTIONAL_EXTENSION(VK_KHR_SYNCHRONIZATION2)
+//OPTIONAL_EXTENSION(VK_KHR_COPY_COMMANDS2)
+//OPTIONAL_EXTENSION(VK_KHR_DYNAMIC_RENDERING)

materialsystem/vulkan/rendercommandlist.cpp

@@ -120,8 +120,8 @@ void CVkRenderCommandList::SetMaterial( IMaterial *pMaterial )
 			{
 				pBeginCommand->bDepthEnabled = m_bDepthEnabled;
 				pBeginCommand->stDepthImage = m_depth;
-
 			}
+			m_materials[m_materials.GetSize()-1].m_pBeginCommand = pBeginCommand;
 			m_pCurrentMaterialBuffer->AddCommand(pBeginCommand);
 
 			CVkSetShaderCommand *pSetShader = CREATE_COMMAND(m_pCommandBufferManager, SetShader);

materialsystem/vulkan/rendercontext.cpp

@@ -276,7 +276,9 @@ CVkBuffer::CVkBuffer( uint32_t nSize, VkBufferUsageFlags2 eUsage, uint32_t nAlig
 
 	stBufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
 	stBufferInfo.size = nSize;
-	stBufferInfo.pNext = &stUsage;
+	stBufferInfo.usage = stUsage.usage;
+	if (g_vkAvailableExtensions.bIsSupported_VK_KHR_MAINTENANCE_5)
+		stBufferInfo.pNext = &stUsage;
 
 	stAllocInfo.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
 	stAllocInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
@@ -286,7 +288,12 @@ CVkBuffer::CVkBuffer( uint32_t nSize, VkBufferUsageFlags2 eUsage, uint32_t nAlig
 
 	stAddress.sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
 	stAddress.buffer = m_buffer;
-	m_address = vkGetBufferDeviceAddress(s_vkDevice, &stAddress);
+	if (vkGetBufferDeviceAddress)
+		m_address = vkGetBufferDeviceAddress(s_vkDevice, &stAddress);
+	else if (vkGetBufferDeviceAddressEXT)
+		m_address = vkGetBufferDeviceAddressEXT(s_vkDevice, &stAddress);
+	else if (vkGetBufferDeviceAddressKHR)
+		m_address = vkGetBufferDeviceAddressKHR(s_vkDevice, &stAddress);
 
 	m_nSize = nSize;
 }
@@ -411,7 +418,7 @@ uint32_t CVkTextureArray::CreateTexture( uint32_t i, const char *szPath )
 	pBuffer->Unmap();
 	pBuffer->Unlock();
 	vkDeviceWaitIdle(s_vkDevice);
-	IImage *pImage = m_pRenderContext->CreateTexture(uWidth, uHeight, IMAGE_FORMAT_RGBA8_UNORM, MULTISAMPLE_TYPE_NONE);
+	IImage *pImage = m_pRenderContext->CreateTexture(uWidth, uHeight, IMAGE_FORMAT_RGBA8_UNORM, MULTISAMPLE_TYPE_1_SAMPLES);
 	m_pImages[i] = (CVkImage*)pImage;
 	stbi_image_free(pImg);
 
@@ -872,6 +879,10 @@ void CVkRenderContext::Init()
 	vk11Features.shaderDrawParameters = VK_TRUE;
 	vk11Features.multiview = VK_TRUE;
 
+	VkPhysicalDeviceFeatures features = {};
+	features.shaderStorageImageReadWithoutFormat = VK_TRUE;
+	features.shaderStorageImageWriteWithoutFormat = VK_TRUE;
+
 
 	stDeviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
 	stDeviceCreateInfo.queueCreateInfoCount = 1;
@@ -879,6 +890,7 @@ void CVkRenderContext::Init()
 	stDeviceCreateInfo.enabledExtensionCount = enabledDeviceExtensions.GetSize();
 	stDeviceCreateInfo.ppEnabledExtensionNames = enabledDeviceExtensions.GetData();
 	stDeviceCreateInfo.pNext = &vk11Features;
+	stDeviceCreateInfo.pEnabledFeatures = &features;
 	r = vkCreateDevice(s_vkPhysicalDevice, &stDeviceCreateInfo, NULL, &s_vkDevice);
 	VULKAN_RESULT_PRINT(r, vkEnumeratePhysicalDevices);
 	for (auto &extension: enabledDeviceExtensions)
@@ -994,6 +1006,7 @@ void CVkRenderContext::Frame( float fDeltaTime )
 	{
 
 
+		CVkBlitCommand *pBlitCommand = NULL;
 		if (s.m_pWindow->GetOutputImage())
 		{
 
@@ -1070,7 +1083,10 @@ void CVkRenderContext::Frame( float fDeltaTime )
 	wi.semaphoreCount = 1;
 	wi.pSemaphores = &semaphore;
 	wi.pValues = &v;
-	vkWaitSemaphores(s_vkDevice, &wi, UINT64_MAX);
+	if (vkWaitSemaphores)
+		vkWaitSemaphores(s_vkDevice, &wi, UINT64_MAX);
+	else
+		vkWaitSemaphoresKHR(s_vkDevice, &wi, UINT64_MAX);
 
 	VkPresentInfoKHR stPresentInfo = {};
 	stPresentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;

materialsystem/vulkan/shader.cpp

@@ -81,6 +81,8 @@ void CVkShader::Build()
 	VkPipelineRenderingCreateInfo render = {};
 	CUtlVector<VkPipelineColorBlendAttachmentState> attachments = {};
 	VkDynamicState dynamicStates[] = {
+		VK_DYNAMIC_STATE_VIEWPORT,
+		VK_DYNAMIC_STATE_SCISSOR,
 		VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT,
 		VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT,
 	};
@@ -178,6 +180,8 @@ void CVkShader::Build()
 	rasterState.frontFace = VK_FRONT_FACE_CLOCKWISE;
 
 	viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+	viewportState.viewportCount = 1;
+	viewportState.scissorCount = 1;
 
 	msaa.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
 	msaa.rasterizationSamples = CVkImage::GetMultisampling(m_eMultiSampling);
@@ -186,10 +190,70 @@ void CVkShader::Build()
 	for ( uint32_t i = 0; i < m_formats.GetSize(); i++ )
 		formats[i] = m_formats[i].m_eFormat;
 
-	render.sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
+	if (! (vkCmdBeginRendering || vkCmdBeginRenderingKHR) )
-	render.colorAttachmentCount = formats.GetSize();
+	{
-	render.pColorAttachmentFormats = formats.GetData();
+		CUtlVector<VkAttachmentDescription> attachments = {};
+		CUtlVector<VkAttachmentReference> input_refs = {};
+		attachments.Resize(formats.GetSize());
+		input_refs.Resize(formats.GetSize());
+		uint32_t i = 0;
+		for (auto f: formats)
+		{
+			/* fuck vulkan 1.0*/
+			/* anyway we create compatible render passes somewhere */
+			VkAttachmentDescription desc = {};
+			desc.format = f;
+			desc.samples = CVkImage::GetMultisampling(m_eMultiSampling);
+			desc.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+			desc.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+			attachments[i] = desc;
 
+			VkAttachmentReference ref = {};
+			ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+			ref.attachment = i;
+			input_refs[i] = ref;
+			i++;
+		}
+		if (m_eDepthFormat == VK_FORMAT_D32_SFLOAT)
+		{
+			VkAttachmentDescription desc = {};
+			desc.format = m_eDepthFormat;
+			desc.samples = CVkImage::GetMultisampling(m_eMultiSampling);
+			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 (m_eDepthFormat == VK_FORMAT_D32_SFLOAT)
+		{
+			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, &m_hRenderPass);
+		createInfo.renderPass = m_hRenderPass;
+
+	}
+	else
+	{
+		render.sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
+		render.colorAttachmentCount = formats.GetSize();
+		render.pColorAttachmentFormats = formats.GetData();
+		if (m_eDepthFormat == VK_FORMAT_D32_SFLOAT)
+			render.depthAttachmentFormat = m_eDepthFormat;
+
+
+	}
 	depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
 	if (m_eDepthFormat == VK_FORMAT_D32_SFLOAT)
 	{
@@ -235,7 +299,8 @@ void CVkShader::Build()
 	createInfo.pDepthStencilState = &depthStencil;
 	createInfo.pColorBlendState = &blend;
 	createInfo.pMultisampleState = &msaa;
-	createInfo.pNext = &render;
+	if (vkCmdBeginRendering || vkCmdBeginRenderingKHR)
+		createInfo.pNext = &render;
 	vkCreateGraphicsPipelines(m_hDevice, NULL, 1, &createInfo, NULL, &m_hPipeline);
 }
 

materialsystem/vulkan/vulkan_state.h

@@ -54,7 +54,7 @@ struct VulkanCommandParameter_t
 class CVkCommand
 {
 public:
-	virtual void Execute( VkCommandBuffer hCommandBuffer, int iCurrentFrame ) = 0;
+	virtual void Execute( VkDevice hDevice, VkCommandBuffer hCommandBuffer, int iCurrentFrame ) = 0;
 	virtual ~CVkCommand() = default;
 	//virtual const char *GetName();
 
@@ -99,7 +99,7 @@ public:
 class CVk##name##Command : public CVkCommand \
 { \
 public: \
-	virtual void Execute( VkCommandBuffer hCommandBuffer, int iCurrentFrame ) override; \
+	virtual void Execute( VkDevice hDevice, VkCommandBuffer hCommandBuffer, int iCurrentFrame ) override; \
 
 #define END_VULKAN_COMMAND() \
 }; \
@@ -107,7 +107,7 @@ public: \
 #define DECLARE_VULKAN_COMMAND(name) \
 CVkCommand *_VulkanCommandCreate_##name() { return new CVk##name##Command; } \
 CVkCommandRegistry _VulkanCommandRegistry_##name( #name, _VulkanCommandCreate_##name ); \
-void CVk##name##Command::Execute( VkCommandBuffer hCommandBuffer, int iCurrentFrame ) \
+void CVk##name##Command::Execute( VkDevice hDevice, VkCommandBuffer hCommandBuffer, int iCurrentFrame ) \
 
 #undef __cplusplus
 #include "vulkan/vk_enum_string_helper.h"
@@ -253,11 +253,12 @@ public:
 	CCompiledShader m_shader;
 	CUtlVector<VkDescriptorSetLayout> m_setLayouts;
 	CUtlVector<VulkanDescriptor_t> m_bindings;
+	VkRenderPass m_hRenderPass;
 private:
 	CUtlVector<VkVertexInputBindingDescription> m_layouts;
 	CUtlVector<VkVertexInputAttributeDescription> m_attributes;
 	CUtlVector<VkOutputImageConfig_t> m_formats;
-	EMultisampleType m_eMultiSampling;
+	EMultisampleType m_eMultiSampling = MULTISAMPLE_TYPE_1_SAMPLES;
 	VkFormat m_eDepthFormat;
 	bool m_bIsFragmentEnabled;
 };
@@ -380,6 +381,7 @@ struct VulkanMaterialCommandBuffer_t
 {
 	IMaterial *m_pMaterial;
 	IVkCommandBuffer *m_pCommandBuffer;
+	void *m_pBeginCommand;
 };
 
 

public/materialsystem/imaterialsystem.h

@@ -81,11 +81,11 @@ enum EImageType
 
 enum EMultisampleType
 {
-	MULTISAMPLE_TYPE_NONE,
+	MULTISAMPLE_TYPE_NONE = 0,
-	MULTISAMPLE_TYPE_1_SAMPLES = MULTISAMPLE_TYPE_NONE,
+	MULTISAMPLE_TYPE_1_SAMPLES = 1,
-	MULTISAMPLE_TYPE_2_SAMPLES,
+	MULTISAMPLE_TYPE_2_SAMPLES = 2,
-	MULTISAMPLE_TYPE_4_SAMPLES,
+	MULTISAMPLE_TYPE_4_SAMPLES = 4,
-	MULTISAMPLE_TYPE_8_SAMPLES,
+	MULTISAMPLE_TYPE_8_SAMPLES = 8,
 };
 
 enum EResolveMode

shadercompiler/slang/vulkan_spirv.cpp

@@ -228,7 +228,7 @@ void CSlangVulkanSpirvShaderCompiler::CompileShader( const char *szInput, CCompi
 	stSessionDesc.targets = &stTargetDesc;
 
 	stTargetDesc.format = SLANG_SPIRV;
-	stTargetDesc.profile = s_pGlobalSession->findProfile("spirv_1_6");
+	stTargetDesc.profile = s_pGlobalSession->findProfile("spirv_1_3");
 
 
 	for ( i = 0; i<SHADER_STAGE_COUNT; i++ )