Method draw

cube/cube.cpp:856–969

}

void Demo::draw() {
    // Don't draw if initialization isn't complete, if the swapchain became outdated, or if the window is minimized
    if (!initialized || !swapchain_ready || is_minimized) {
        return;
    }

    auto &current_submission = submission_resources[current_submission_index];

    // Ensure no more than FRAME_LAG renderings are outstanding
    const vk::Result wait_result = device.waitForFences(current_submission.fence, VK_TRUE, UINT64_MAX);
    VERIFY(wait_result == vk::Result::eSuccess || wait_result == vk::Result::eTimeout);

    vk::Result acquire_result;
    uint32_t current_swapchain_image_index = 0;
    do {
        acquire_result = device.acquireNextImageKHR(swapchain, UINT64_MAX, current_submission.image_acquired_semaphore, vk::Fence(),
                                                    &current_swapchain_image_index);
        if (acquire_result == vk::Result::eErrorOutOfDateKHR) {
            // demo.swapchain is out of date (e.g. the window was resized) and
            // must be recreated:
            resize();
        } else if (acquire_result == vk::Result::eSuboptimalKHR) {
            // swapchain is not as optimal as it could be, but the platform's
            // presentation engine will still present the image correctly.
            break;
        } else if (acquire_result == vk::Result::eErrorSurfaceLostKHR) {
            inst.destroySurfaceKHR(surface);
            create_surface();
            resize();
        } else {
            VERIFY(acquire_result == vk::Result::eSuccess);
        }
        // If we minimized then stop trying to draw
        if (!swapchain_ready) {
            return;
        }
    } while (acquire_result != vk::Result::eSuccess);

    auto &current_swapchain_resource = swapchain_resources[current_swapchain_image_index];

    update_data_buffer(submission_resources[current_submission_index].uniform_memory_ptr);

    draw_build_cmd(current_submission, current_swapchain_resource);

    if (separate_present_queue) {
        build_image_ownership_cmd(current_submission, current_swapchain_resource);
    }

    // Only reset right before submitting so we can't deadlock on an un-signalled fence that has nothing submitted to it
    auto reset_result = device.resetFences({current_submission.fence});
    VERIFY(reset_result == vk::Result::eSuccess);

    // Wait for the image acquired semaphore to be signaled to ensure
    // that the image won't be rendered to until the presentation
    // engine has fully released ownership to the application, and it is
    // okay to render to the image.
    vk::PipelineStageFlags const pipe_stage_flags = vk::PipelineStageFlagBits::eColorAttachmentOutput;
    auto protected_submit_info = vk::ProtectedSubmitInfo().setProtectedSubmit(protected_output);