start work on migration to render passes

external/vma/vma.cpp

@@ -1,7 +1,7 @@
 #define VMA_IMPLEMENTATION
 #define VMA_STATIC_VULKAN_FUNCTIONS 0
 #define VMA_DYNAMIC_VULKAN_FUNCTIONS 1
-#define VMA_VULKAN_VERSION 1003000
+#define VMA_VULKAN_VERSION 1002000
 
 #ifdef __linux__
 #define VK_USE_PLATFORM_XCB_KHR

src/gears/vulkan.d

@@ -16,6 +16,11 @@ import math;
 
 alias InitRenderer = Init;
 alias Renderer = Vulkan;
+alias Shader = VkShaderModule;
+alias Pipeline = PipelineHandle;
+alias Attribute = VkVertexInputAttributeDescription;
+alias SpecEntry = VkSpecializationMapEntry;
+alias RenderPass = VkRenderPass;
 
 bool g_VLAYER_SUPPORT = false;
 bool g_DEBUG_PRINTF = false;
@@ -56,7 +61,6 @@ const char*[] VK_BASE_DEVICE_EXTENSIONS = [
 	cast(char*)VK_KHR_SWAPCHAIN_EXTENSION_NAME,
 	cast(char*)VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME,
 	cast(char*)VK_KHR_8BIT_STORAGE_EXTENSION_NAME,
-	cast(char*)"VK_KHR_dynamic_rendering_local_read",
 ];
 
 const char*[] VK_AMD_DEVICE_EXTENSIONS = [
@@ -80,11 +84,6 @@ const VkFormat[] VK_IMAGE_FORMATS = [
 	VK_FORMAT_R8G8B8A8_UNORM,
 ];
 
-alias Shader = VkShaderModule;
-alias Pipeline = PipelineHandle;
-alias Attribute = VkVertexInputAttributeDescription;
-alias SpecEntry = VkSpecializationMapEntry;
-
 enum InputRate : int
 {
 	Vertex = VK_VERTEX_INPUT_RATE_VERTEX,
@@ -151,9 +150,9 @@ struct GlobalUniforms
 	Mat4 projection_view = Mat4Identity();
 	Vec4 light_color;
 	Vec4 ambient_color;
-	Vec3 light_direction;
+	vec3 light_direction;
 	f32 padding;
-	Vec2 res;
+	vec2 res;
 }
 
 struct Image
@@ -222,6 +221,7 @@ struct GfxPipelineInfo
 	Specialization frag_spec;
 	ImageView*		 draw_image;
 	ImageView*		 depth_image;
+	bool					 self_dependency;
 }
 
 struct CompPipelineInfo
@@ -306,6 +306,8 @@ struct Vulkan
 	VkPresentModeKHR				 	 present_mode;
 	VkExtent3D							 	 swapchain_extent;
 
+	VkRenderPass 							 render_pass;
+	VkFramebuffer[]						 framebuffers;
 	ImageView[]							 	 present_images;
 	u32												 image_index;
 
@@ -667,46 +669,30 @@ BeginFrame(Vulkan* vk)
 }
 
 void
-BeginRendering(Vulkan* vk, ImageView* draw_image, ImageView* depth_image)
+BeginRendering(Vulkan* vk)
 {
-	// TODO: probably get rid of these
+	VkClearValue clear_color = {
-	Transition(vk.cmds[vk.frame_index], draw_image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+		color: {
-	Transition(vk.cmds[vk.frame_index], depth_image, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL);
+			float32: [0.0, 0.0, 0.0, 1.0],
-
+		},
-	VkImage image = CurrentImage(vk);
-	Transition(vk.cmds[vk.frame_index], image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
-
-	VkRenderingAttachmentInfo col_attach = {
-		sType: VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
-		imageView: draw_image.view,
-		imageLayout: draw_image.layout,
-		loadOp: VK_ATTACHMENT_LOAD_OP_CLEAR, // CLEAR instead of LOAD if wanting to clear colors, also clearColor value (or whatever)
-		storeOp: VK_ATTACHMENT_STORE_OP_STORE,
 	};
 
-	VkRenderingAttachmentInfo depth_attach = {
+	VkRenderPassBeginInfo pass_info = {
-		sType: VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
+		sType: VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
-		imageView: depth_image.view,
+		renderPass: vk.render_pass,
-		imageLayout: depth_image.layout,
+		framebuffer: vk.framebuffers[vk.image_index],
-		loadOp: VK_ATTACHMENT_LOAD_OP_CLEAR,
-		storeOp: VK_ATTACHMENT_STORE_OP_STORE,
-	};
-
-	VkRenderingInfo render_info = {
-		sType: VK_STRUCTURE_TYPE_RENDERING_INFO,
-		layerCount: 1,
-		colorAttachmentCount: 1,
-		pColorAttachments: &col_attach,
-		pDepthAttachment: &depth_attach,
 		renderArea: {
-			extent: {
+			offset: {
-				width: vk.swapchain_extent.width,
+				x: 0,
-				height: vk.swapchain_extent.height,
+				y: 0,
 			},
+			extent: vk.swapchain_extent,
 		},
+		clearValueCount: 1,
+		pClearValues: &clear_color,
 	};
 
-	vkCmdBeginRendering(vk.cmds[vk.frame_index], &render_info);
+	vkCmdBeginRenderPass(vk.cmds[vk.frame_index], &pass_info, VK_SUBPASS_CONTENTS_INLINE);
 }
 
 pragma(inline): void
@@ -748,7 +734,7 @@ PrepComputeDrawImage(Vulkan* vk)
 void
 FinishRendering(Vulkan* vk)
 {
-	vkCmdEndRendering(vk.cmds[vk.frame_index]);
+	vkCmdEndRenderPass(vk.cmds[vk.frame_index]);
 }
 
 void
@@ -779,36 +765,20 @@ SubmitAndPresent(Vulkan* vk, ImageView* draw_image)
 	VkResult result = vkEndCommandBuffer(vk.cmds[vk.frame_index]);
 	VkCheckA("FinishFrame failure: vkEndCommandBuffer error", result);
 
-	VkCommandBufferSubmitInfo cmd_info = {
+	VkPipelineStage stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-		sType: VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO,
+
-		commandBuffer: vk.cmds[vk.frame_index],
+	VkSubmitInfo submit_info = {
+		sType: VK_STRUCTURE_TYPE_SUBMIT_INFO,
+		waitSemaphoreCount: 1,
+		pWaitSemaphores: &acquire_sem,
+		pWaitDstStageMask: &stage,
+		commandBufferCount: 1,
+		pCommandBuffers: vk.cmds.ptr + vk.frame_index,
+		signalSemaphoreCount: 1,
+		pSignalSemaphores: &submit_sem,
 	};
 
-	VkSemaphoreSubmitInfo wait_info = {
+	result = vkQueueSubmit(vk.queues.gfx_queue, 1, &submit_info, vk.render_fences[vk.frame_index]);
-		sType: VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
-		semaphore: acquire_sem,
-		stageMask: VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
-		value: 1,
-	};
-
-	VkSemaphoreSubmitInfo signal_info = {
-		sType: VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
-		semaphore: submit_sem,
-		stageMask: VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT,
-		value: 1,
-	};
-
-	VkSubmitInfo2 submit_info = {
-		sType: VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
-		waitSemaphoreInfoCount: 1,
-		pWaitSemaphoreInfos: &wait_info,
-		signalSemaphoreInfoCount: 1,
-		pSignalSemaphoreInfos: &signal_info,
-		commandBufferInfoCount: 1,
-		pCommandBufferInfos: &cmd_info,
-	};
-
-	result = vkQueueSubmit2(vk.queues.gfx_queue, 1, &submit_info, vk.render_fences[vk.frame_index]);
 	VkCheckA("FinishFrame failure: vkQueueSubmit2 error", result);
 
 	VkPresentInfoKHR present_info = {
@@ -1176,22 +1146,18 @@ PushConstants(Vulkan* vk, PushConst* pc)
 void
 ImageBarrier(Vulkan* vk)
 {
-	VkMemoryBarrier2 barrier = {
+	vkCmdPipelineBarrier(
-		sType: VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
+		vk.cmds[vk.frame_index], 
-		srcStageMask: VK_PIPELINE_STAGE_2_TRANSFER_BIT,
+		VK_PIPELINE_STAGE_2_TRANSFER_BIT,
-		srcAccessMask: VK_ACCESS_2_TRANSFER_WRITE_BIT,
+		VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
-		dstStageMask: VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
+		VK_DEPENDENCY_BY_REGION_BIT,
-		dstAccessMask: VK_ACCESS_2_SHADER_READ_BIT | VK_ACCESS_2_SHADER_WRITE_BIT,
+		1,
-	};
+		&barrier,
-
+		0,
-	VkDependencyInfo dependency = {
+		null,
-		sType: VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
+		0,
-		dependencyFlags: VK_DEPENDENCY_BY_REGION_BIT,
+		null
-		memoryBarrierCount: 1,
+	);
-		pMemoryBarriers: &barrier,
-	};
-
-	vkCmdPipelineBarrier2(vk.cmds[vk.frame_index], &dependency);
 }
 
 bool
@@ -1427,6 +1393,23 @@ Bind(Vulkan* vk, PipelineHandle* pipeline)
 pragma(inline): void
 Transition(VkCommandBuffer cmd, VkImage image, VkImageLayout current_layout, VkImageLayout new_layout)
 {
+	// TODO: continue from here
+	VkPipelineStageFlags src_stage, dst_stage;
+	VkAccessFlagBits src_access, dst_access;
+
+	switch(current_layout)
+	{
+		case VK_IMAGE_LAYOUT_UNDEFINED: 
+			{
+				src_stage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+			} break;
+		case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
+			{
+				src_stage = VK_PIPELINE_STAGE_TRANSFER_BIT;
+				src_mask = VK_ACCESS_FLAG_TRANSFER_WRITE_BIT;
+			} break;
+	}
+
 	VkImageMemoryBarrier2 barrier = {
 		sType: VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
 		srcStageMask: VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
@@ -1485,9 +1468,92 @@ BuildShader(Vulkan* vk, u8[] bytes)
 	return shader;
 }
 
+void
+InitFramebufferAndRenderpass(Vulkan* vk, ImageView* draw_image, ImageView* depth_image)
+{
+	VkAttachmentDescription[] attach_descriptions = [
+		{
+			format: draw_image.format,
+			samples: VK_SAMPLE_COUNT_1_BIT,
+			loadOp: VK_ATTACHMENT_LOAD_OP_CLEAR,
+			storeOp: VK_ATTACHMENT_STORE_OP_STORE,
+			stencilLoadOp: VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+			stencilStoreOp: VK_ATTACHMENT_STORE_OP_DONT_CARE,
+			initialLayout: VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+			finalLayout: VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+		},
+		{
+			format: depth_image.format,
+			initialLayout: VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+			finalLayout: VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+		},
+	];
+
+	VkAttachmentReference color_ref = {
+		attachment: 0,
+		layout: VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+	};
+
+	VkAttachmentReference depth_ref =	{
+		attachment: 1,
+		layout: VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+	};
+
+	VkSubpassDescription subpass = {
+		pipelineBindPoint: VK_PIPELINE_BIND_POINT_GRAPHICS,
+		colorAttachmentCount: 1,
+		pColorAttachments: &color_ref,
+		pDepthStencilAttachment: &depth_ref,
+	};
+
+	VkSubpassDependency self_dependency = {
+		srcSubpass: 0,
+		dstSubpass: 0,
+		srcStageMask: VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+		dstStageMask: VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+		srcAccessMask: VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
+		dstAccessMask: VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
+ 		dependencyFlags: VK_DEPENDENCY_BY_REGION_BIT,
+	};
+
+	VkRenderPassCreateInfo pass_info = {
+		sType: VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
+		attachmentCount: cast(u32)attach_descriptions.length,
+		pAttachments: attach_descriptions.ptr,
+		subpassCount: 1,
+		pSubpasses: &subpass,
+		dependencyCount: 1,
+		pDependencies: &self_dependency,
+	};
+
+	VkResult result = vkCreateRenderPass(vk.device, &pass_info, null, &vk.render_pass);
+	VkCheckA("vkCreateRenderPass failure", result);
+
+	VkFramebufferCreateInfo framebuffer_info = {
+		sType: VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
+		renderPass: vk.render_pass,
+		attachmentCount: 1,
+		width: vk.swapchain_extent.width,
+		height: vk.swapchain_extent.height,
+		layers: 1,
+	};
+
+	vk.framebuffers = AllocArray!(VkFramebuffer)(&vk.arena, vk.present_images.length);
+
+	foreach(i, image; vk.present_images)
+	{
+		framebuffer_info.pAttachments = &image.view;
+
+		result = vkCreateFramebuffer(vk.device, &framebuffer_info, null, &vk.framebuffers[i]);
+		VkCheckA("vkCreateFramebuffer failure", result);
+	}
+}
+
 Pipeline
 CreateGraphicsPipeline(Vulkan* vk, GfxPipelineInfo* build_info)
 {
+	PipelineHandle pipeline = { type: VK_PIPELINE_BIND_POINT_GRAPHICS };
+
 	VkDynamicState[] dyn_state = [ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR ];
 
 	VkPipelineDynamicStateCreateInfo dyn_info = {
@@ -1532,8 +1598,8 @@ CreateGraphicsPipeline(Vulkan* vk, GfxPipelineInfo* build_info)
 	VkPipelineRenderingCreateInfo rendering_info = {
 		sType: VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
 		colorAttachmentCount: 1,
-		pColorAttachmentFormats: cast(VkFormat*)&build_info.draw_image.format,
+		pColorAttachmentFormats: cast(VkFormat*)&vk.draw_image.format,
-		depthAttachmentFormat: build_info.depth_image.format,
+		depthAttachmentFormat: vk.depth_image.format,
 	};
 
 	VkPipelineColorBlendAttachmentState blend_state = {
@@ -1649,8 +1715,6 @@ CreateGraphicsPipeline(Vulkan* vk, GfxPipelineInfo* build_info)
 		layout: vk.pipeline_layout,
 	};
 
-	PipelineHandle pipeline = { type: VK_PIPELINE_BIND_POINT_GRAPHICS };
-	
 	VkResult result = vkCreateGraphicsPipelines(vk.device, null, 1, &create_info, null, &pipeline.handle);
 	assert(VkCheck("CreateGraphicsPipeline failure", result), "Unable to build pipeline");
 
@@ -2554,6 +2618,10 @@ CreateSwapchain(Vulkan* vk)
 		},
 	};
 
+	VkFramebufferCreateInfo framebuffer_info = {
+		sType: VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
+	};
+
 	foreach(i, image; vk.present_images)
 	{
 		vk.present_images[i].image = images[i];
@@ -2604,7 +2672,7 @@ InitVMA(Vulkan* vk)
 
 	VmaAllocatorCreateInfo info = {
 		flags: VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT,
-		vulkanApiVersion: VK_MAKE_API_VERSION(0, 1, 3, 0),
+		vulkanApiVersion: VK_MAKE_API_VERSION(0, 1, 2, 0),
 		pVulkanFunctions: &vk_functions,
 		physicalDevice: vk.physical_device,
 		device: vk.device,
@@ -2683,15 +2751,8 @@ InitDevice(Vulkan* vk)
 			count += 1;
 		}
 
-		VkPhysicalDeviceVulkan13Features features_13 = {
-			sType: VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
-			synchronization2: VK_TRUE,
-			dynamicRendering: VK_TRUE,
-		};
-
 		VkPhysicalDeviceVulkan12Features features_12 = {
 			sType: VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
-			pNext: &features_13,
 			descriptorIndexing: VK_TRUE,
 			bufferDeviceAddress: VK_TRUE,
 			descriptorBindingUniformBufferUpdateAfterBind: VK_TRUE,
@@ -3156,7 +3217,7 @@ InitInstance(Vulkan* vk)
 		applicationVersion: VK_MAKE_API_VERSION(0, 0, 0, 1),
 		pEngineName: "Gears",
 		engineVersion: VK_MAKE_API_VERSION(0, 0, 0, 1),
-		apiVersion: VK_MAKE_API_VERSION(0, 1, 3, 0),
+		apiVersion: VK_MAKE_API_VERSION(0, 1, 2, 0),
 	};
 
 	VkInstanceCreateInfo instance_info = {

src/gears/vulkan_funcs.d

@@ -56,6 +56,12 @@ version(AMD_GPU)
 // Device Functions
 
 PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = null;
+PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = null;
+PFN_vkCmdEndRenderPass vkCmdEndRenderPass = null;
+PFN_vkCreateFramebuffer vkCreateFramebuffer = null;
+PFN_vkDestroyFramebuffer vkDestroyFramebuffer = null;
+PFN_vkCreateRenderPass vkCreateRenderPass = null;
+PFN_vkDestroyRenderPass vkDestroyRenderPass = null;
 PFN_vkCreateImage vkCreateImage = null;
 PFN_vkCreateImageView vkCreateImageView = null;
 PFN_vkCreateBufferView vkCreateBufferView = null;
@@ -83,6 +89,7 @@ PFN_vkDestroyCommandPool vkDestroyCommandPool = null;
 PFN_vkDestroySemaphore vkDestroySemaphore = null;
 PFN_vkDestroyFence vkDestroyFence = null;
 PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = null;
+PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = null;
 PFN_vkDestroyPipeline vkDestroyPipeline = null;
 PFN_vkWaitForFences vkWaitForFences = null;
 PFN_vkBeginCommandBuffer vkBeginCommandBuffer = null;
@@ -91,19 +98,14 @@ PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = null;
 PFN_vkCmdBindPipeline vkCmdBindPipeline = null;
 PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = null;
 PFN_vkCmdDispatch vkCmdDispatch = null;
-PFN_vkCmdBeginRendering vkCmdBeginRendering = null;
-PFN_vkCmdEndRendering vkCmdEndRendering = null;
 PFN_vkCmdSetViewport vkCmdSetViewport = null;
 PFN_vkCmdSetScissor vkCmdSetScissor = null;
 PFN_vkCmdPushConstants vkCmdPushConstants = null;
 PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = null;
 PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = null;
 PFN_vkCmdDrawIndexed vkCmdDrawIndexed = null;
-PFN_vkCmdBlitImage2 vkCmdBlitImage2 = null;
-PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2 = null;
 PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = null;
 PFN_vkCmdCopyBuffer vkCmdCopyBuffer = null;
-PFN_vkQueueSubmit2 vkQueueSubmit2 = null;
 PFN_vkResetFences vkResetFences = null;
 PFN_vkResetCommandBuffer vkResetCommandBuffer = null;
 PFN_vkFreeCommandBuffers vkFreeCommandBuffers = null;
@@ -153,6 +155,12 @@ void
 LoadDeviceFunctions(Vulkan* vk)
 {
 	vkCreateSwapchainKHR = cast(PFN_vkCreateSwapchainKHR)vkGetDeviceProcAddr(vk.device, "vkCreateSwapchainKHR");
+	vkCmdBeginRenderPass = cast(PFN_vkCmdBeginRenderPass)vkGetDeviceProcAddr(vk.device, "vkCmdBeginRenderPass");
+	vkCmdEndRenderPass = cast(PFN_vkCmdEndRenderPass)vkGetDeviceProcAddr(vk.device, "vkCmdEndRenderPass");
+	vkCreateFramebuffer = cast(PFN_vkCreateFramebuffer)vkGetDeviceProcAddr(vk.device, "vkCreateFramebuffer");
+	vkDestroyFramebuffer = cast(PFN_vkDestroyFramebuffer)vkGetDeviceProcAddr(vk.device, "vkDestroyFramebuffer");
+	vkCreateRenderPass = cast(PFN_vkCreateRenderPass)vkGetDeviceProcAddr(vk.device, "vkCreateRenderPass");
+	vkDestroyRenderPass = cast(PFN_vkDestroyRenderPass)vkGetDeviceProcAddr(vk.device, "vkDestroyRenderPass");
 	vkCreateImage = cast(PFN_vkCreateImage)vkGetDeviceProcAddr(vk.device, "vkCreateImage");
 	vkCreateImageView = cast(PFN_vkCreateImageView)vkGetDeviceProcAddr(vk.device, "vkCreateImageView");
 	vkCreateBufferView = cast(PFN_vkCreateBufferView)vkGetDeviceProcAddr(vk.device, "vkCreateBufferView");
@@ -161,6 +169,7 @@ LoadDeviceFunctions(Vulkan* vk)
 	vkCreateSemaphore = cast(PFN_vkCreateSemaphore)vkGetDeviceProcAddr(vk.device, "vkCreateSemaphore");
 	vkAllocateCommandBuffers = cast(PFN_vkAllocateCommandBuffers)vkGetDeviceProcAddr(vk.device, "vkAllocateCommandBuffers");
 	vkCreateCommandPool = cast(PFN_vkCreateCommandPool)vkGetDeviceProcAddr(vk.device, "vkCreateCommandPool");
+	vkCmdPipelineBarrier = cast(PFN_vkCmdPipelineBarrier)vkGetDeviceProcAddr(vk.device, "vkCmdPipelineBarrier");
 	vkCreateFence = cast(PFN_vkCreateFence)vkGetDeviceProcAddr(vk.device, "vkCreateFence");
 	vkCreateDescriptorPool = cast(PFN_vkCreateDescriptorPool)vkGetDeviceProcAddr(vk.device, "vkCreateDescriptorPool");
 	vkCreateDescriptorSetLayout = cast(PFN_vkCreateDescriptorSetLayout)vkGetDeviceProcAddr(vk.device, "vkCreateDescriptorSetLayout");
@@ -188,19 +197,14 @@ LoadDeviceFunctions(Vulkan* vk)
 	vkCmdBindPipeline = cast(PFN_vkCmdBindPipeline)vkGetDeviceProcAddr(vk.device, "vkCmdBindPipeline");
 	vkCmdBindDescriptorSets = cast(PFN_vkCmdBindDescriptorSets)vkGetDeviceProcAddr(vk.device, "vkCmdBindDescriptorSets");
 	vkCmdDispatch = cast(PFN_vkCmdDispatch)vkGetDeviceProcAddr(vk.device, "vkCmdDispatch");
-	vkCmdBeginRendering = cast(PFN_vkCmdBeginRendering)vkGetDeviceProcAddr(vk.device, "vkCmdBeginRendering");
-	vkCmdEndRendering = cast(PFN_vkCmdEndRendering)vkGetDeviceProcAddr(vk.device, "vkCmdEndRendering");
 	vkCmdSetViewport = cast(PFN_vkCmdSetViewport)vkGetDeviceProcAddr(vk.device, "vkCmdSetViewport");
 	vkCmdSetScissor = cast(PFN_vkCmdSetScissor)vkGetDeviceProcAddr(vk.device, "vkCmdSetScissor");
 	vkCmdPushConstants = cast(PFN_vkCmdPushConstants)vkGetDeviceProcAddr(vk.device, "vkCmdPushConstants");
 	vkCmdBindIndexBuffer = cast(PFN_vkCmdBindIndexBuffer)vkGetDeviceProcAddr(vk.device, "vkCmdBindIndexBuffer");
 	vkCmdBindVertexBuffers = cast(PFN_vkCmdBindVertexBuffers)vkGetDeviceProcAddr(vk.device, "vkCmdBindVertexBuffers");
 	vkCmdDrawIndexed = cast(PFN_vkCmdDrawIndexed)vkGetDeviceProcAddr(vk.device, "vkCmdDrawIndexed");
-	vkCmdBlitImage2 = cast(PFN_vkCmdBlitImage2)vkGetDeviceProcAddr(vk.device, "vkCmdBlitImage2");
-	vkCmdPipelineBarrier2 = cast(PFN_vkCmdPipelineBarrier2)vkGetDeviceProcAddr(vk.device, "vkCmdPipelineBarrier2");
 	vkCmdCopyBufferToImage = cast(PFN_vkCmdCopyBufferToImage)vkGetDeviceProcAddr(vk.device, "vkCmdCopyBufferToImage");
 	vkCmdCopyBuffer = cast(PFN_vkCmdCopyBuffer)vkGetDeviceProcAddr(vk.device, "vkCmdCopyBuffer");
-	vkQueueSubmit2 = cast(PFN_vkQueueSubmit2)vkGetDeviceProcAddr(vk.device, "vkQueueSubmit2");
 	vkResetFences = cast(PFN_vkResetFences)vkGetDeviceProcAddr(vk.device, "vkResetFences");
 	vkResetCommandBuffer = cast(PFN_vkResetCommandBuffer)vkGetDeviceProcAddr(vk.device, "vkResetCommandBuffer");
 	vkFreeCommandBuffers = cast(PFN_vkFreeCommandBuffers)vkGetDeviceProcAddr(vk.device, "vkFreeCommandBuffers");

src/shared/includes.c

@@ -22,7 +22,7 @@
 
 #define VMA_STATIC_VULKAN_FUNCTIONS 0
 #define VMA_DYNAMIC_VULKAN_FUNCTIONS 1
-#define VMA_VULKAN_VERSION 1003000
+#define VMA_VULKAN_VERSION 1002000
 
 #include "../../external/vma/vk_mem_alloc.h"