自学教程：C++ vkQueueSubmit函数代码示例

void VulkanRenderManager::Submit(int frame, bool triggerFence) {	FrameData &frameData = frameData_[frame];	if (frameData.hasInitCommands) {		VkResult res = vkEndCommandBuffer(frameData.initCmd);		_assert_msg_(G3D, res == VK_SUCCESS, "vkEndCommandBuffer failed (init)! result=%s", VulkanResultToString(res));	}	VkResult res = vkEndCommandBuffer(frameData.mainCmd);	_assert_msg_(G3D, res == VK_SUCCESS, "vkEndCommandBuffer failed (main)! result=%s", VulkanResultToString(res));	VkCommandBuffer cmdBufs[2];	int numCmdBufs = 0;	if (frameData.hasInitCommands) {		cmdBufs[numCmdBufs++] = frameData.initCmd;		frameData.hasInitCommands = false;		if (splitSubmit_) {			// Send the init commands off separately. Used this once to confirm that the cause of a device loss was in the init cmdbuf.			VkSubmitInfo submit_info{ VK_STRUCTURE_TYPE_SUBMIT_INFO };			submit_info.commandBufferCount = (uint32_t)numCmdBufs;			submit_info.pCommandBuffers = cmdBufs;			res = vkQueueSubmit(vulkan_->GetGraphicsQueue(), 1, &submit_info, VK_NULL_HANDLE);			if (res == VK_ERROR_DEVICE_LOST) {				_assert_msg_(G3D, false, "Lost the Vulkan device!");			} else {				_assert_msg_(G3D, res == VK_SUCCESS, "vkQueueSubmit failed (init)! result=%s", VulkanResultToString(res));			}			numCmdBufs = 0;		}	}	cmdBufs[numCmdBufs++] = frameData.mainCmd;	VkSubmitInfo submit_info{ VK_STRUCTURE_TYPE_SUBMIT_INFO };	if (triggerFence && !frameData.skipSwap) {		submit_info.waitSemaphoreCount = 1;		submit_info.pWaitSemaphores = &acquireSemaphore_;		VkPipelineStageFlags waitStage[1]{ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };		submit_info.pWaitDstStageMask = waitStage;	}	submit_info.commandBufferCount = (uint32_t)numCmdBufs;	submit_info.pCommandBuffers = cmdBufs;	if (triggerFence && !frameData.skipSwap) {		submit_info.signalSemaphoreCount = 1;		submit_info.pSignalSemaphores = &renderingCompleteSemaphore_;	}	res = vkQueueSubmit(vulkan_->GetGraphicsQueue(), 1, &submit_info, triggerFence ? frameData.fence : VK_NULL_HANDLE);	if (res == VK_ERROR_DEVICE_LOST) {		_assert_msg_(G3D, false, "Lost the Vulkan device!");	} else {		_assert_msg_(G3D, res == VK_SUCCESS, "vkQueueSubmit failed (main, split=%d)! result=%s", (int)splitSubmit_, VulkanResultToString(res));	}	// When !triggerFence, we notify after syncing with Vulkan.	if (useThread_ && triggerFence) {		VLOG("PULL: Frame %d.readyForFence = true", frame);		std::unique_lock<std::mutex> lock(frameData.push_mutex);		frameData.readyForFence = true;		frameData.push_condVar.notify_all();	}}

	void draw()	{		VkResult err;		VkSemaphore presentCompleteSemaphore;		VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo =			vkTools::initializers::semaphoreCreateInfo(VK_FENCE_CREATE_SIGNALED_BIT);		err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);		assert(!err);		// Get next image in the swap chain (back/front buffer)		err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);		assert(!err);		VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();		submitInfo.waitSemaphoreCount = 1;		submitInfo.pWaitSemaphores = &presentCompleteSemaphore;		submitInfo.commandBufferCount = 1;		submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];		// Submit draw command buffer		err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);		assert(!err);		err = swapChain.queuePresent(queue, currentBuffer);		assert(!err);		vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);		submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);		err = vkQueueWaitIdle(queue);		assert(!err);	}

void VulkanBase::submitPostPresentBarrier(VkImage image) {	VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();	vkTools::checkResult(vkBeginCommandBuffer(postPresentCmdBuffer, &cmdBufInfo));	VkImageMemoryBarrier postPresentBarrier = vkTools::initializers::imageMemoryBarrier();	postPresentBarrier.srcAccessMask = 0;	postPresentBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;	postPresentBarrier.oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;	postPresentBarrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;	postPresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;	postPresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;	postPresentBarrier.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };	postPresentBarrier.image = image;	vkCmdPipelineBarrier(		postPresentCmdBuffer,		VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,		VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,		0,		0, nullptr, // No memory barriers,		0, nullptr, // No buffer barriers,		1, &postPresentBarrier);	vkTools::checkResult(vkEndCommandBuffer(postPresentCmdBuffer));	VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();	submitInfo.commandBufferCount = 1;	submitInfo.pCommandBuffers = &postPresentCmdBuffer;	vkTools::checkResult(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));}

		/**		* Finish command buffer recording and submit it to a queue		*		* @param commandBuffer Command buffer to flush		* @param queue Queue to submit the command buffer to 		* @param free (Optional) Free the command buffer once it has been submitted (Defaults to true)		*		* @note The queue that the command buffer is submitted to must be from the same family index as the pool it was allocated from		* @note Uses a fence to ensure command buffer has finished executing		*/		void flushCommandBuffer(VkCommandBuffer commandBuffer, VkQueue queue, bool free = true)		{			if (commandBuffer == VK_NULL_HANDLE)			{				return;			}			VK_CHECK_RESULT(vkEndCommandBuffer(commandBuffer));			VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();			submitInfo.commandBufferCount = 1;			submitInfo.pCommandBuffers = &commandBuffer;			// Create fence to ensure that the command buffer has finished executing			VkFenceCreateInfo fenceInfo = vkTools::initializers::fenceCreateInfo(VK_FLAGS_NONE);			VkFence fence;			VK_CHECK_RESULT(vkCreateFence(logicalDevice, &fenceInfo, nullptr, &fence));						// Submit to the queue			VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, fence));			// Wait for the fence to signal that command buffer has finished executing			VK_CHECK_RESULT(vkWaitForFences(logicalDevice, 1, &fence, VK_TRUE, DEFAULT_FENCE_TIMEOUT));			vkDestroyFence(logicalDevice, fence, nullptr);			if (free)			{				vkFreeCommandBuffers(logicalDevice, commandPool, 1, &commandBuffer);			}		}

 void VulkanWindow::EndRender() const {     vkCmdEndRenderPass ( mVulkanRenderer.GetCommandBuffer() );     if ( VkResult result = vkEndCommandBuffer ( mVulkanRenderer.GetCommandBuffer() ) )     {         std::cout << GetVulkanResultString ( result ) << "  " << __func__ << " " << __LINE__ << " " << std::endl;     }     VkSubmitInfo submit_info{};     submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;     submit_info.waitSemaphoreCount = 0;     submit_info.pWaitSemaphores = nullptr;     submit_info.pWaitDstStageMask = nullptr;     submit_info.commandBufferCount = 1;     submit_info.pCommandBuffers = &mVulkanRenderer.GetCommandBuffer();     submit_info.signalSemaphoreCount = 1;     submit_info.pSignalSemaphores = &mVulkanRenderer.GetSignalSemaphore();     if ( VkResult result = vkQueueSubmit ( mVulkanRenderer.GetQueue(), 1, &submit_info, VK_NULL_HANDLE ) )     {         std::cout << GetVulkanResultString ( result ) << "  " << __func__ << " " << __LINE__ << " " << std::endl;     }     std::array<VkResult, 1> result_array{ { VkResult::VK_SUCCESS } };     VkPresentInfoKHR present_info{};     present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;     present_info.waitSemaphoreCount = 1;     present_info.pWaitSemaphores = &mVulkanRenderer.GetSignalSemaphore();     present_info.swapchainCount = 1;     present_info.pSwapchains = &mVkSwapchainKHR;     present_info.pImageIndices = &mActiveImageIndex;     present_info.pResults = result_array.data();     if ( VkResult result = vkQueuePresentKHR ( mVulkanRenderer.GetQueue(), &present_info ) )     {         std::cout << GetVulkanResultString ( result ) << "  " << __func__ << " " << __LINE__ << " " << std::endl;     } }

	bool RHI_CommandList::Submit()	{		// Ensure the command list has stopped recording		if (m_is_recording)			return false;		// Fixes "Error: Vulkan: Queue 0x1f1c2542ee0 is waiting on semaphore 0x3e that has no way to be signaled."		//vulkan_helper::fence::wait_reset(m_rhi_device, m_swap_chain->GetFenceImageAcquired());			m_current_frame							= (m_current_frame + 1) % g_max_frames_in_flight;		vector<VkSemaphore> wait_semaphores		= { static_cast<VkSemaphore>(m_swap_chain->GetSemaphoreImageAcquired()) };		vector<VkSemaphore> signal_semaphores	= { static_cast<VkSemaphore>(m_semaphores_render_finished[m_current_frame]) };		VkPipelineStageFlags wait_flags[]		= { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };		VkSubmitInfo submit_info			= {};		submit_info.sType					= VK_STRUCTURE_TYPE_SUBMIT_INFO;		submit_info.waitSemaphoreCount		= static_cast<uint32_t>(wait_semaphores.size());		submit_info.pWaitSemaphores			= wait_semaphores.data();		submit_info.pWaitDstStageMask		= wait_flags;		submit_info.commandBufferCount		= 1;		submit_info.pCommandBuffers			= &CMD_BUFFER_VK;		submit_info.signalSemaphoreCount	= static_cast<uint32_t>(signal_semaphores.size());		submit_info.pSignalSemaphores		= signal_semaphores.data();		auto result = vkQueueSubmit(m_rhi_device->GetContext()->queue_graphics, 1, &submit_info, IN_FLIGHT_FENCE_VK);		if (result != VK_SUCCESS)		{			LOGF_ERROR("Failed to submit command buffer, %s.", Vulkan_Common::result_to_string(result));		}				m_is_rendering = true;		return result == VK_SUCCESS;	}

void executeQueue( VkCommandBuffer cmd ){	const VkCommandBuffer cmds[] = { cmd };	VkFenceCreateInfo fenceInfo;	VkFence drawFence;	fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;	fenceInfo.pNext = nullptr;	fenceInfo.flags = 0;	vkCreateFence( gDevice, &fenceInfo, nullptr, &drawFence );	VkPipelineStageFlags pipeStageFlags = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;	VkSubmitInfo submitInfo[1] = {};	submitInfo[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;	submitInfo[0].pNext = nullptr;	submitInfo[0].waitSemaphoreCount = 0;	submitInfo[0].pWaitSemaphores = nullptr;	submitInfo[0].pWaitDstStageMask = &pipeStageFlags;	submitInfo[0].commandBufferCount = 1;	submitInfo[0].pCommandBuffers = cmds;	submitInfo[0].signalSemaphoreCount = 0;	submitInfo[0].pSignalSemaphores = nullptr;	HR( vkQueueSubmit( gQueue, 1, submitInfo, drawFence ) );	VkResult res;	do {		res = vkWaitForFences( gDevice, 1, &drawFence, VK_TRUE, 100000000 );	} while( res == VK_TIMEOUT );	vkDestroyFence( gDevice, drawFence, nullptr );}

bool _agpu_swap_chain::getNextBackBufferIndex(){    auto semaphore = semaphores[currentSemaphoreIndex];    currentSemaphoreIndex = (currentSemaphoreIndex + 1) % semaphores.size();    auto error = device->fpAcquireNextImageKHR(device->device, handle, UINT64_MAX, semaphore, VK_NULL_HANDLE, &currentBackBufferIndex);    if (error == VK_ERROR_OUT_OF_DATE_KHR)    {        // TODO: Recreate the swap chain.        printf("Swap chain is out of date/n");        return true;    }    else if (error == VK_SUBOPTIMAL_KHR)    {    }    else if(error)    {        return false;    }    {        VkSubmitInfo submit;        memset(&submit, 0, sizeof(submit));        submit.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;        submit.waitSemaphoreCount = 1;        submit.pWaitSemaphores = &semaphore;        VkPipelineStageFlags waitDstStageMask = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;        submit.pWaitDstStageMask = &waitDstStageMask;        vkQueueSubmit(graphicsQueue->queue, 1, &submit, VK_NULL_HANDLE);    }    return true;}

static void FrameRender(ImGui_ImplVulkanH_WindowData* wd){	VkResult err;	VkSemaphore& image_acquired_semaphore  = wd->Frames[wd->FrameIndex].ImageAcquiredSemaphore;	err = vkAcquireNextImageKHR(g_Device, wd->Swapchain, UINT64_MAX, image_acquired_semaphore, VK_NULL_HANDLE, &wd->FrameIndex);	check_vk_result(err);    ImGui_ImplVulkanH_FrameData* fd = &wd->Frames[wd->FrameIndex];    {		err = vkWaitForFences(g_Device, 1, &fd->Fence, VK_TRUE, UINT64_MAX);	// wait indefinitely instead of periodically checking        check_vk_result(err);		err = vkResetFences(g_Device, 1, &fd->Fence);        check_vk_result(err);    }    {        err = vkResetCommandPool(g_Device, fd->CommandPool, 0);        check_vk_result(err);        VkCommandBufferBeginInfo info = {};        info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;        info.flags |= VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;        err = vkBeginCommandBuffer(fd->CommandBuffer, &info);        check_vk_result(err);    }    {        VkRenderPassBeginInfo info = {};        info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;        info.renderPass = wd->RenderPass;		info.framebuffer = wd->Framebuffer[wd->FrameIndex];        info.renderArea.extent.width = wd->Width;        info.renderArea.extent.height = wd->Height;        info.clearValueCount = 1;        info.pClearValues = &wd->ClearValue;        vkCmdBeginRenderPass(fd->CommandBuffer, &info, VK_SUBPASS_CONTENTS_INLINE);    }	// Record Imgui Draw Data and draw funcs into command buffer	ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), fd->CommandBuffer);	// Submit command buffer    vkCmdEndRenderPass(fd->CommandBuffer);    {        VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;        VkSubmitInfo info = {};        info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;        info.waitSemaphoreCount = 1;		info.pWaitSemaphores = &image_acquired_semaphore;        info.pWaitDstStageMask = &wait_stage;        info.commandBufferCount = 1;        info.pCommandBuffers = &fd->CommandBuffer;        info.signalSemaphoreCount = 1;        info.pSignalSemaphores = &fd->RenderCompleteSemaphore;        err = vkEndCommandBuffer(fd->CommandBuffer);        check_vk_result(err);        err = vkQueueSubmit(g_Queue, 1, &info, fd->Fence);        check_vk_result(err);    }}

			void VkContext::EndFrame() {				// Submit current draw buffer				VkSubmitInfo submitInfo = {};				submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;				submitInfo.pNext = nullptr;				submitInfo.commandBufferCount = 1;				submitInfo.pCommandBuffers = &drawCmdBuffers[currentImage];				// Wait on image acquire				submitInfo.waitSemaphoreCount = 1;				submitInfo.pWaitSemaphores = &acquireCompleteSemaphore;				// Only wait on transfer bit				VkPipelineStageFlags waitDstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;				submitInfo.pWaitDstStageMask = &waitDstStageMask;				// Signal render complete semaphore				submitInfo.signalSemaphoreCount = 1;				submitInfo.pSignalSemaphores = &renderCompleteSemaphore;				if (vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE) != VK_SUCCESS) {					std::cout << "Unable to submit command buffer" << std::endl;				}				VkPresentInfoKHR presentInfo = {};				presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;				presentInfo.pNext = nullptr;				presentInfo.waitSemaphoreCount = 1;				presentInfo.pWaitSemaphores = &renderCompleteSemaphore;				presentInfo.swapchainCount = 1;				presentInfo.pSwapchains = &swapchain;				presentInfo.pImageIndices = &currentImage;				CheckVkResult(vkQueuePresentKHR(queue, &presentInfo));			}

	void draw()	{		VkResult err;		// Get next image in the swap chain (back/front buffer)		err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);		assert(!err);		submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);		// Command buffer to be sumitted to the queue		submitInfo.commandBufferCount = 1;		submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];		// Submit to queue		err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);		assert(!err);		submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);		err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);		assert(!err);		err = vkQueueWaitIdle(queue);		assert(!err);	}

	void draw()	{		VkResult err;		// Get next image in the swap chain (back/front buffer)		err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);		assert(!err);		submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);		VkPipelineStageFlags pipelineStages = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;		VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();		submitInfo.waitSemaphoreCount = 1;		submitInfo.pWaitSemaphores = &semaphores.presentComplete;		submitInfo.commandBufferCount = 1;		submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];		submitInfo.pWaitDstStageMask = &pipelineStages;		submitInfo.signalSemaphoreCount = 1;		submitInfo.pSignalSemaphores = &semaphores.submitSignal;		// Submit to the graphics queue		err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);		assert(!err);		submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);		// Present the current buffer to the swap chain		// This will display the image		err = swapChain.queuePresent(queue, currentBuffer, semaphores.submitSignal);		assert(!err);	}

void op3d::Engine::drawFrame(){    uint32_t imageIndex;    VkResult result = vkAcquireNextImageKHR(device, swapChain, std::numeric_limits<uint64_t>::max(), imageAvailableSemaphore, VK_NULL_HANDLE, &imageIndex);    if (result == VK_ERROR_OUT_OF_DATE_KHR)    {        recreateSwapChain();        return;    }    else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR)    {        throw std::runtime_error("failed to acquire swap chain image!");    }    VkSubmitInfo submitInfo = {};    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;    VkSemaphore waitSemaphores[] = {imageAvailableSemaphore};    VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};    submitInfo.waitSemaphoreCount = 1;    submitInfo.pWaitSemaphores = waitSemaphores;    submitInfo.pWaitDstStageMask = waitStages;    submitInfo.commandBufferCount = 1;    submitInfo.pCommandBuffers = &commandBuffers[imageIndex];    VkSemaphore signalSemaphores[] = {renderFinishedSemaphore};    submitInfo.signalSemaphoreCount = 1;    submitInfo.pSignalSemaphores = signalSemaphores;    if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE) != VK_SUCCESS)    {        throw std::runtime_error("failed to submit draw command buffer!");    }    VkPresentInfoKHR presentInfo = {};    presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;    presentInfo.waitSemaphoreCount = 1;    presentInfo.pWaitSemaphores = signalSemaphores;    VkSwapchainKHR swapChains[] = {swapChain};    presentInfo.swapchainCount = 1;    presentInfo.pSwapchains = swapChains;    presentInfo.pImageIndices = &imageIndex;    result = vkQueuePresentKHR(presentQueue, &presentInfo);    if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR)    {        recreateSwapChain();    }    else if (result != VK_SUCCESS)    {        throw std::runtime_error("failed to present swap chain image!");    }}

	void draw()	{		VulkanExampleBase::prepareFrame();		submitInfo.commandBufferCount = 1;		submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));		VulkanExampleBase::submitFrame();	}

	void draw()	{		VulkanExampleBase::prepareFrame();		submitInfo.pWaitSemaphores = &semaphores.presentComplete;		submitInfo.pSignalSemaphores = &offscreen.semaphore;		submitInfo.commandBufferCount = 1;		submitInfo.pCommandBuffers = &offscreen.cmdBuffer;		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));		submitInfo.pWaitSemaphores = &offscreen.semaphore;		submitInfo.pSignalSemaphores = &semaphores.renderComplete;		submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));		VulkanExampleBase::submitFrame();	}

  bool Tutorial03::Draw() {    VkSwapchainKHR swap_chain = GetSwapChain().Handle;    uint32_t image_index;    VkResult result = vkAcquireNextImageKHR( GetDevice(), swap_chain, UINT64_MAX, Vulkan.ImageAvailableSemaphore, VK_NULL_HANDLE, &image_index );    switch( result ) {      case VK_SUCCESS:      case VK_SUBOPTIMAL_KHR:        break;      case VK_ERROR_OUT_OF_DATE_KHR:        return OnWindowSizeChanged();      default:        std::cout << "Problem occurred during swap chain image acquisition!" << std::endl;        return false;    }    VkPipelineStageFlags wait_dst_stage_mask = VK_PIPELINE_STAGE_TRANSFER_BIT;    VkSubmitInfo submit_info = {      VK_STRUCTURE_TYPE_SUBMIT_INFO,                // VkStructureType              sType      nullptr,                                      // const void                  *pNext      1,                                            // uint32_t                     waitSemaphoreCount      &Vulkan.ImageAvailableSemaphore,              // const VkSemaphore           *pWaitSemaphores      &wait_dst_stage_mask,                         // const VkPipelineStageFlags  *pWaitDstStageMask;      1,                                            // uint32_t                     commandBufferCount      &Vulkan.GraphicsCommandBuffers[image_index],  // const VkCommandBuffer       *pCommandBuffers      1,                                            // uint32_t                     signalSemaphoreCount      &Vulkan.RenderingFinishedSemaphore            // const VkSemaphore           *pSignalSemaphores    };    if( vkQueueSubmit( GetGraphicsQueue().Handle, 1, &submit_info, VK_NULL_HANDLE ) != VK_SUCCESS ) {      return false;    }    VkPresentInfoKHR present_info = {      VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,           // VkStructureType              sType      nullptr,                                      // const void                  *pNext      1,                                            // uint32_t                     waitSemaphoreCount      &Vulkan.RenderingFinishedSemaphore,           // const VkSemaphore           *pWaitSemaphores      1,                                            // uint32_t                     swapchainCount      &swap_chain,                                  // const VkSwapchainKHR        *pSwapchains      &image_index,                                 // const uint32_t              *pImageIndices      nullptr                                       // VkResult                    *pResults    };    result = vkQueuePresentKHR( GetPresentQueue().Handle, &present_info );    switch( result ) {      case VK_SUCCESS:        break;      case VK_ERROR_OUT_OF_DATE_KHR:      case VK_SUBOPTIMAL_KHR:        return OnWindowSizeChanged();      default:        std::cout << "Problem occurred during image presentation!" << std::endl;        return false;    }    return true;  }

void Device::submit(VkCommandBuffer commandBuffer){    VkSubmitInfo submitInfo = {VK_STRUCTURE_TYPE_SUBMIT_INFO};    submitInfo.commandBufferCount = 1;    VkCommandBuffer commandBuffers[1] = {commandBuffer};    submitInfo.pCommandBuffers = commandBuffers;    if (VK_SUCCESS != vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE)) {        throw ERROR_DEVICES;    }}

static void vulkan_raster_font_flush(vulkan_raster_t *font){   const struct vk_draw_triangles call = {      font->vk->pipelines.font,      &font->texture_optimal,      font->vk->samplers.mipmap_linear,      &font->vk->mvp,      sizeof(font->vk->mvp),      &font->range,      font->vertices,   };   if(font->needs_update)   {      VkCommandBuffer staging;      VkSubmitInfo submit_info             = { VK_STRUCTURE_TYPE_SUBMIT_INFO };      VkCommandBufferAllocateInfo cmd_info = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };      VkCommandBufferBeginInfo begin_info  = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };      cmd_info.commandPool        = font->vk->staging_pool;      cmd_info.level              = VK_COMMAND_BUFFER_LEVEL_PRIMARY;      cmd_info.commandBufferCount = 1;      vkAllocateCommandBuffers(font->vk->context->device, &cmd_info, &staging);      begin_info.flags            = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;      vkBeginCommandBuffer(staging, &begin_info);      vulkan_copy_staging_to_dynamic(font->vk, staging,            &font->texture_optimal, &font->texture);      vkEndCommandBuffer(staging);#ifdef HAVE_THREADS      slock_lock(font->vk->context->queue_lock);#endif      submit_info.commandBufferCount = 1;      submit_info.pCommandBuffers    = &staging;      vkQueueSubmit(font->vk->context->queue,            1, &submit_info, VK_NULL_HANDLE);      vkQueueWaitIdle(font->vk->context->queue);#ifdef HAVE_THREADS      slock_unlock(font->vk->context->queue_lock);#endif      vkFreeCommandBuffers(font->vk->context->device,            font->vk->staging_pool, 1, &staging);      font->needs_update = false;   }   vulkan_draw_triangles(font->vk, &call);}

void VkApp::endSingleTimeCommands(VkCommandBuffer commandBuffer){	vkEndCommandBuffer(commandBuffer);	VkSubmitInfo submitInfo = {};	submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;	submitInfo.commandBufferCount = 1;	submitInfo.pCommandBuffers = &commandBuffer;	vkQueueSubmit(graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);	vkQueueWaitIdle(graphicsQueue);	vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer);}

void Renderer::_EndSingleTimeCommands(VkCommandPool pool, VkCommandBuffer commandBuffer) {	ErrorCheck(vkEndCommandBuffer(commandBuffer));	VkSubmitInfo submit_info {};	submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;	submit_info.commandBufferCount = 1;	submit_info.pCommandBuffers = &commandBuffer;	ErrorCheck(vkQueueSubmit(_queue, 1, &submit_info, VK_NULL_HANDLE));	ErrorCheck(vkQueueWaitIdle(_queue));	vkFreeCommandBuffers(_device, pool, 1, &commandBuffer);}

	void draw()	{		VulkanExampleBase::prepareFrame();		submitInfo.commandBufferCount = 1;		submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));		// Read query results for displaying in next frame		getQueryResults();		VulkanExampleBase::submitFrame();	}

void Queue::Submit(const std::vector<CommandBufferBatch*>& p_Batches) const{	ASSERT(!p_Batches.empty(), "Empty list of batches");	std::vector<VkSubmitInfo> l_InfoVec;	l_InfoVec.resize(p_Batches.size());	for (uint32 i = 0; i < p_Batches.size(); i++)	{		l_InfoVec[i] = p_Batches[i]->GetSubmitInfo();	}	VK_THROW_IF_NOT_SUCCESS(vkQueueSubmit(m_Handle, (uint32)l_InfoVec.size(), l_InfoVec.data(), VK_NULL_HANDLE), "Failed to submit " << l_InfoVec.size() << " batches to queue");}

/*! * /brief Finishes initializing all previously recorded objects * * Submits internal vulkan command buffer */bool rSceneBase::endInitObject() {   if ( !vInitializingObjects ) {      eLOG( "beginInitObject was NOT called on secene ", vName_str );      return false;   }   vkEndCommandBuffer( vInitBuff_vk );   VkSubmitInfo lInfo         = {};   lInfo.sType                = VK_STRUCTURE_TYPE_SUBMIT_INFO;   lInfo.pNext                = nullptr;   lInfo.waitSemaphoreCount   = 0;   lInfo.pWaitSemaphores      = nullptr;   lInfo.pWaitDstStageMask    = nullptr;   lInfo.commandBufferCount   = 1;   lInfo.pCommandBuffers      = &vInitBuff_vk;   lInfo.signalSemaphoreCount = 0;   lInfo.pSignalSemaphores    = nullptr;   auto lFence = vWorldPtr->createFence();   VkResult lRes;   {      std::lock_guard<std::mutex> lLock( vWorldPtr->getInitPtr()->getQueueMutex( vInitQueue_vk ) );      lRes = vkQueueSubmit( vInitQueue_vk, 1, &lInfo, lFence );   }   if ( lRes ) {      eLOG( "'vkQueueSubmit' returned ", uEnum2Str::toStr( lRes ) );      vInitObjs.clear();      vObjectsInit_MUT.unlock();      return false;   }   lRes = vkWaitForFences( vWorldPtr->getDevice(), 1, &lFence, VK_TRUE, UINT64_MAX );   if ( lRes ) {      eLOG( "'vkQueueSubmit' returned ", uEnum2Str::toStr( lRes ) );   }   for ( auto &i : vInitObjs )      i->finishData();   vkDestroyFence( vWorldPtr->getDevice(), lFence, nullptr );   vkFreeCommandBuffers( vWorldPtr->getDevice(), vInitPool_vk, 1, &vInitBuff_vk );   vInitObjs.clear();   vInitializingObjects = false;   vObjectsInit_MUT.unlock();   return true;}

void Shadow::SubmitFrameRender(VkQueue graphicQueue){	auto submitInfo = vkstruct<VkSubmitInfo>();	submitInfo.waitSemaphoreCount = 0u;	submitInfo.pWaitSemaphores = nullptr;	submitInfo.pWaitDstStageMask = nullptr;	submitInfo.commandBufferCount = 1u;	submitInfo.pCommandBuffers = &mCmdBuffer;	submitInfo.signalSemaphoreCount = 1u;	submitInfo.pSignalSemaphores = &shadowMapCompleteSemaphore;	gVkLastRes = vkQueueSubmit(graphicQueue, 1u, &submitInfo, VK_NULL_HANDLE);	VKFN_LAST_RES_SUCCESS_OR_QUIT(vkQueueSubmit);}

	/**	* Submit the text command buffers to a queue	*/	void submit(VkQueue queue, uint32_t bufferindex, VkSubmitInfo submitInfo)	{		if (!visible)		{			return;		}		submitInfo.pCommandBuffers = &cmdBuffers[bufferindex];		submitInfo.commandBufferCount = 1;		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, fence));		VK_CHECK_RESULT(vkWaitForFences(vulkanDevice->logicalDevice, 1, &fence, VK_TRUE, UINT64_MAX));		VK_CHECK_RESULT(vkResetFences(vulkanDevice->logicalDevice, 1, &fence));	}

		void flush_command_buffer() {			VkResult err;			if (_vulkan_command_buffer == VK_NULL_HANDLE) {				return;			}			err = vkEndCommandBuffer(_vulkan_command_buffer);			assert(!err);			const VkCommandBuffer command_buffers[] = { _vulkan_command_buffer };			VkFence nullFence = VK_NULL_HANDLE;			/*			typedef struct VkSubmitInfo {				VkStructureType                sType;				const void*                    pNext;				uint32_t                       waitSemaphoreCount;				const VkSemaphore*             pWaitSemaphores;				const VkPipelineStageFlags*    pWaitDstStageMask;				uint32_t                       commandBufferCount;				const VkCommandBuffer*         pCommandBuffers;				uint32_t                       signalSemaphoreCount;				const VkSemaphore*             pSignalSemaphores;			} VkSubmitInfo;			*/			VkSubmitInfo submit_info = { 				VK_STRUCTURE_TYPE_SUBMIT_INFO,				NULL,				0,				NULL,				NULL,				1,				command_buffers,				0,				NULL };			err = vkQueueSubmit(_vulkan_queue, 1, &submit_info, nullFence);			assert(!err);			err = vkQueueWaitIdle(_vulkan_queue);			assert(!err);			vkFreeCommandBuffers(_vulkan_device, _vulkan_command_pool, 1, command_buffers);			_vulkan_command_buffer = VK_NULL_HANDLE;		}

void Queue::submit(const std::vector<const CommandBuffer *> &cmds,                   Fence &fence) {    const std::vector<VkCommandBuffer> cmd_handles =        make_handles<VkCommandBuffer>(cmds);    VkSubmitInfo submit_info;    submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;    submit_info.pNext = NULL;    submit_info.waitSemaphoreCount = 0;    submit_info.pWaitSemaphores = NULL;    submit_info.pWaitDstStageMask = NULL;    submit_info.commandBufferCount = (uint32_t)cmd_handles.size();    submit_info.pCommandBuffers = cmd_handles.data();    submit_info.signalSemaphoreCount = 0;    submit_info.pSignalSemaphores = NULL;    EXPECT(vkQueueSubmit(handle(), 1, &submit_info, fence.handle()) ==           VK_SUCCESS);}

	void draw()	{		// Get next image in the swap chain (back/front buffer)		VK_CHECK_RESULT(swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer));		submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);		// Command buffer to be sumitted to the queue		submitInfo.commandBufferCount = 1;		submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];		// Submit to queue		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));		submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);		VK_CHECK_RESULT(swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete));	}

void VkHelper::endSingleTimeCommandBuffer(VkDevice device, VkCommandPool cmdPool, VkQueue queue, VkCommandBuffer cmdBuffer){	if (vkEndCommandBuffer(cmdBuffer) != VK_SUCCESS)		std::runtime_error("ERROR: Command buffer end failed.");	VkSubmitInfo submitInfo{};	submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;	submitInfo.pNext = VK_NULL_HANDLE;	submitInfo.commandBufferCount = 1;	submitInfo.pCommandBuffers = &cmdBuffer;		if (vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE) != VK_SUCCESS)		std::runtime_error("ERROR: Submission to the queue failed.");	vkQueueWaitIdle(queue);	vkFreeCommandBuffers(device, cmdPool, 1, &cmdBuffer);}