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, ¤tBuffer);
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, ¤tBackBufferIndex);
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 = ¤tImage;
CheckVkResult(vkQueuePresentKHR(queue, &presentInfo));
}
void draw()
{
VkResult err;
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(semaphores.presentComplete, ¤tBuffer);
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, ¤tBuffer);
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 GrManagerImpl::flushCommandBuffer(CommandBufferPtr cmdb, Bool wait)
{
CommandBufferImpl& impl = *cmdb->m_impl;
VkCommandBuffer handle = impl.getHandle();
VkSubmitInfo submit = {};
submit.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
FencePtr fence = newFence();
LockGuard<Mutex> lock(m_globalMtx);
PerFrame& frame = m_perFrame[m_frame % MAX_FRAMES_IN_FLIGHT];
// Do some special stuff for the last command buffer
VkPipelineStageFlags waitFlags;
if(impl.renderedToDefaultFramebuffer())
{
submit.pWaitSemaphores = &frame.m_acquireSemaphore->getHandle();
waitFlags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
submit.pWaitDstStageMask = &waitFlags;
submit.waitSemaphoreCount = 1;
// Create the semaphore to signal
ANKI_ASSERT(!frame.m_renderSemaphore && "Only one begin/end render pass is allowed with the default fb");
frame.m_renderSemaphore = m_semaphores.newInstance(fence);
submit.signalSemaphoreCount = 1;
submit.pSignalSemaphores = &frame.m_renderSemaphore->getHandle();
frame.m_presentFence = fence;
}
submit.commandBufferCount = 1;
submit.pCommandBuffers = &handle;
frame.m_cmdbsSubmitted.pushBack(getAllocator(), cmdb);
ANKI_TRACE_START_EVENT(VK_QUEUE_SUBMIT);
ANKI_VK_CHECKF(vkQueueSubmit(m_queue, 1, &submit, fence->getHandle()));
ANKI_TRACE_STOP_EVENT(VK_QUEUE_SUBMIT);
if(wait)
{
vkQueueWaitIdle(m_queue);
}
}
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, ¤tBuffer));
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);
}
