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);
}
}
static void frame_begin()
{
VkResult err;
while (true)
{
err = vkWaitForFences(g_Device, 1, &g_Fence[g_FrameIndex], VK_TRUE, 100);
if (err == VK_SUCCESS) break;
if (err == VK_TIMEOUT) continue;
check_vk_result(err);
}
{
err = vkAcquireNextImageKHR(g_Device, g_Swapchain, UINT64_MAX, g_PresentCompleteSemaphore[g_FrameIndex], VK_NULL_HANDLE, &g_BackbufferIndices[g_FrameIndex]);
check_vk_result(err);
}
{
err = vkResetCommandPool(g_Device, g_CommandPool[g_FrameIndex], 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(g_CommandBuffer[g_FrameIndex], &info);
check_vk_result(err);
}
{
VkRenderPassBeginInfo info = {};
info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
info.renderPass = g_RenderPass;
info.framebuffer = g_Framebuffer[g_BackbufferIndices[g_FrameIndex]];
info.renderArea.extent.width = fb_width;
info.renderArea.extent.height = fb_height;
info.clearValueCount = 1;
info.pClearValues = &g_ClearValue;
vkCmdBeginRenderPass(g_CommandBuffer[g_FrameIndex], &info, VK_SUBPASS_CONTENTS_INLINE);
}
}
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!");
}
}
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;
}
VkResult SwapChain::AcquireNextImage(VkSemaphore available_semaphore)
{
VkResult res =
vkAcquireNextImageKHR(g_vulkan_context->GetDevice(), m_swap_chain, UINT64_MAX,
available_semaphore, VK_NULL_HANDLE, &m_current_swap_chain_image_index);
if (res != VK_SUCCESS && res != VK_ERROR_OUT_OF_DATE_KHR && res != VK_SUBOPTIMAL_KHR)
LOG_VULKAN_ERROR(res, "vkAcquireNextImageKHR failed: ");
return res;
}
std::tuple<VkResult, uint32_t> acquire_next_image(swapchain_type &swapchain,
std::chrono::nanoseconds timeout,
const semaphore::semaphore_type &semaphore,
const fence::fence_type &fence) {
uint32_t image_index;
std::lock(internal::get_mutex(swapchain), internal::get_mutex(semaphore));
std::lock_guard<std::mutex> swapchain_lock(internal::get_mutex(swapchain), std::adopt_lock);
std::lock_guard<std::mutex> semaphore_lock(internal::get_mutex(semaphore), std::adopt_lock);
std::lock_guard<std::mutex> fence_lock(internal::get_mutex(fence), std::adopt_lock);
const VkResult result(vkAcquireNextImageKHR(
internal::get_instance(*internal::get_parent(swapchain)),
internal::get_instance(swapchain), timeout.count(),
internal::get_instance(semaphore), internal::get_instance(fence),
&image_index));
return std::make_tuple(result, image_index);
}
void GrManagerImpl::beginFrame()
{
PerFrame& frame = m_perFrame[m_frame % MAX_FRAMES_IN_FLIGHT];
// Create sync objects
FencePtr fence = newFence();
frame.m_acquireSemaphore = m_semaphores.newInstance(fence);
// Get new image
uint32_t imageIdx;
ANKI_TRACE_START_EVENT(VK_ACQUIRE_IMAGE);
ANKI_VK_CHECKF(vkAcquireNextImageKHR(
m_device, m_swapchain, UINT64_MAX, frame.m_acquireSemaphore->getHandle(), fence->getHandle(), &imageIdx));
ANKI_TRACE_STOP_EVENT(VK_ACQUIRE_IMAGE);
ANKI_ASSERT(imageIdx < MAX_FRAMES_IN_FLIGHT);
m_crntBackbufferIdx = imageIdx;
}
void VulkanSwapChain::acquireBackBuffer()
{
uint32_t imageIndex;
VkResult result = vkAcquireNextImageKHR(mDevice->getLogical(), mSwapChain, UINT64_MAX,
mSurfaces[mCurrentSemaphoreIdx].sync->getHandle(), VK_NULL_HANDLE, &imageIndex);
assert(result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR);
// In case surfaces aren't being distributed in round-robin fashion the image and semaphore indices might not match,
// in which case just move the semaphores
if(imageIndex != mCurrentSemaphoreIdx)
std::swap(mSurfaces[mCurrentSemaphoreIdx].sync, mSurfaces[imageIndex].sync);
mCurrentSemaphoreIdx = (mCurrentSemaphoreIdx + 1) % mSurfaces.size();
assert(!mSurfaces[imageIndex].acquired && "Same swap chain surface being acquired twice in a row without present().");
mSurfaces[imageIndex].acquired = true;
mSurfaces[imageIndex].needsWait = true;
mCurrentBackBufferIdx = imageIndex;
}
// Can be called multiple times with no bad side effects. This is so that we can either begin a frame the normal way,
// or stop it in the middle for a synchronous readback, then start over again mostly normally but without repeating
// the backbuffer image acquisition.
void VulkanRenderManager::BeginSubmitFrame(int frame) {
FrameData &frameData = frameData_[frame];
if (!frameData.hasBegun) {
// Get the index of the next available swapchain image, and a semaphore to block command buffer execution on.
// Now, I wonder if we should do this early in the frame or late? Right now we do it early, which should be fine.
VkResult res = vkAcquireNextImageKHR(vulkan_->GetDevice(), vulkan_->GetSwapchain(), UINT64_MAX, acquireSemaphore_, (VkFence)VK_NULL_HANDLE, &frameData.curSwapchainImage);
if (res == VK_SUBOPTIMAL_KHR) {
// Hopefully the resize will happen shortly. Ignore - one frame might look bad or something.
} else if (res == VK_ERROR_OUT_OF_DATE_KHR) {
frameData.skipSwap = true;
} else {
_assert_msg_(G3D, res == VK_SUCCESS, "vkAcquireNextImageKHR failed! result=%s", VulkanResultToString(res));
}
VkCommandBufferBeginInfo begin{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
begin.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
res = vkBeginCommandBuffer(frameData.mainCmd, &begin);
_assert_msg_(G3D, res == VK_SUCCESS, "vkBeginCommandBuffer failed! result=%s", VulkanResultToString(res));
queueRunner_.SetBackbuffer(framebuffers_[frameData.curSwapchainImage], swapchainImages_[frameData.curSwapchainImage].image);
frameData.hasBegun = true;
}
}
std::tuple<VkResult, uint32_t> acquire_next_image(swapchain_type &swapchain, const semaphore::semaphore_type &semaphore) {
uint32_t image_index;
const VkResult result(vkAcquireNextImageKHR(internal::get_instance(*internal::get_parent(swapchain)), internal::get_instance(swapchain), UINT64_MAX, internal::get_instance(semaphore), VK_NULL_HANDLE, &image_index));
return std::make_tuple(result, image_index);
}
DWORD game_loop_main(LPVOID thread_input) {
struct common_vars common_vars = *(struct common_vars *)thread_input;
profiler profiler = {};
profiler_create(&profiler);
LARGE_INTEGER performance_frequency = {};
QueryPerformanceFrequency(&performance_frequency);
memory_arena memory_arena = {};
if (!virtual_alloc_memory_arena(m_megabytes(16), common_vars.system_info.dwPageSize, &memory_arena)) {
m_die("call to \"virtual_alloc_memory_arena\" failed(event_render_loop_thread memory arena)");
}
vulkan vulkan = {};
{
m_memory_arena_undo_allocations_at_scope_exit(&memory_arena);
string info_string = { memory_arena_allocate<char>(&memory_arena, m_kilobytes(4)), 0, m_kilobytes(2) };
string err_string = { memory_arena_allocate<char>(&memory_arena, m_kilobytes(1)), 0, m_kilobytes(1) };
vulkan_create_info vulkan_create_info = {};
vulkan_create_info.win32_instance = common_vars.instance;
vulkan_create_info.win32_window = common_vars.window;
const char *shader_file_paths[] = { "shaders\\swap_chain_pipeline_image.vert.spv", "shaders\\swap_chain_pipeline_image.frag.spv" };
if (!read_file_into_memory_arena(shader_file_paths[0], &memory_arena, &vulkan_create_info.swap_chain_pipeline_image_code[0], &vulkan_create_info.swap_chain_pipeline_image_code_sizes[0]) ||
!read_file_into_memory_arena(shader_file_paths[1], &memory_arena, &vulkan_create_info.swap_chain_pipeline_image_code[1], &vulkan_create_info.swap_chain_pipeline_image_code_sizes[1])) {
m_die("call to \"read_file_into_memory_arena\" failed(swap_chain_pipeline_image shaders)");
}
if (!vulkan_create(vulkan_create_info, &memory_arena, &info_string, &err_string, &vulkan)) {
m_die("%s", err_string.buf);
}
else {
m_printf("%s", info_string.buf);
}
}
game_buffer game_buffer = {};
vec4 game_buffer_viewport = {};
HANDLE game_buffer_gpk_file_handle = nullptr;
HANDLE game_buffer_gpk_file_mapping = nullptr;
void *game_buffer_gpk_file_mapping_ptr = nullptr;
HANDLE game_buffer_mpk_import_shared_memory_mapping = nullptr;
void *game_buffer_mpk_import_shared_memory_mapping_ptr = nullptr;
HANDLE game_buffer_mpk_import_shared_memory_semaphore = nullptr;
{
game_buffer_create_info game_buffer_create_info = {};
if (!virtual_alloc_memory_arena(m_megabytes(512), common_vars.system_info.dwPageSize, &game_buffer_create_info.memory_arena)) {
m_die("call to \"virtual_alloc_memory_arena\" failed(game buffer memory arena)");
}
game_buffer_create_info.vulkan = &vulkan;
game_buffer_create_info.vulkan_framebuffer_width = 1920;
game_buffer_create_info.vulkan_framebuffer_height = 1080;
if (!game_buffer_create(game_buffer_create_info, &game_buffer)) {
m_die("call to \"game_buffer_create\" failed");
}
#ifdef EDITOR_ENABLE
game_buffer_editor_create_info game_buffer_editor_create_info = {};
game_buffer_editor_create_info.game_buffer = &game_buffer;
game_buffer_editor_create_info.vulkan = &vulkan;
game_buffer_editor_create_info.imgui_init_file = "assets\\gpks\\example.gpk.imgui.ini";
game_buffer_editor_create_info.imgui_font_file = "assets\\fonts\\OpenSans-Regular.ttf";
game_buffer_editor_create_info.imgui_font_size = GetSystemMetrics(SM_CXSCREEN) / 150;
game_buffer_editor_create_info.set_imgui_keymap = [] (ImGuiIO *imgui_io) {
imgui_io->KeyMap[ImGuiKey_Tab] = VK_TAB;
imgui_io->KeyMap[ImGuiKey_LeftArrow] = VK_LEFT;
imgui_io->KeyMap[ImGuiKey_RightArrow] = VK_RIGHT;
imgui_io->KeyMap[ImGuiKey_UpArrow] = VK_UP;
imgui_io->KeyMap[ImGuiKey_DownArrow] = VK_DOWN;
imgui_io->KeyMap[ImGuiKey_PageUp] = VK_PRIOR;
imgui_io->KeyMap[ImGuiKey_PageDown] = VK_NEXT;
imgui_io->KeyMap[ImGuiKey_Home] = VK_HOME;
imgui_io->KeyMap[ImGuiKey_End] = VK_END;
imgui_io->KeyMap[ImGuiKey_Backspace] = VK_BACK;
imgui_io->KeyMap[ImGuiKey_Enter] = VK_RETURN;
imgui_io->KeyMap[ImGuiKey_Escape] = VK_ESCAPE;
imgui_io->KeyMap[ImGuiKey_A] = 'A';
imgui_io->KeyMap[ImGuiKey_C] = 'C';
imgui_io->KeyMap[ImGuiKey_V] = 'V';
imgui_io->KeyMap[ImGuiKey_X] = 'X';
imgui_io->KeyMap[ImGuiKey_Y] = 'Y';
imgui_io->KeyMap[ImGuiKey_Z] = 'Z';
};
{
m_memory_arena_undo_allocations_at_scope_exit(&memory_arena);
const char *file_paths[] = { "shaders\\imgui.vert.spv", "shaders\\imgui.frag.spv" };
VkShaderModule shader_modules[m_countof(file_paths)] = {};
for (uint i = 0; i < m_countof(file_paths); i += 1) {
void *file_data;
uint file_size;
if (!read_file_into_memory_arena(file_paths[i], &memory_arena, &file_data, &file_size)) {
m_die("call to \"read_file_into_memory_arena\" failed(game buffer shader files)");
}
VkShaderModuleCreateInfo shader_module_info = { VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
shader_module_info.codeSize = file_size;
shader_module_info.pCode = (const uint32_t *)file_data;
if(vkCreateShaderModule(vulkan.device, &shader_module_info, nullptr, &shader_modules[i]) != VK_SUCCESS) {
m_die("game buffer creation failed\ncall to \"vkCreateShaderModule\" failed for shader file %s", file_paths[i]);
}
}
game_buffer_editor_create_info.imgui_vulkan_shaders[0] = shader_modules[0];
game_buffer_editor_create_info.imgui_vulkan_shaders[1] = shader_modules[1];
}
game_buffer.editor = memory_arena_allocate<game_buffer_editor>(&game_buffer.memory_arena, 1);
*game_buffer.editor = {};
if (!game_buffer_editor_create(&game_buffer_editor_create_info, game_buffer.editor)) {
m_die("call to \"game_buffer_editor_create\" failed");
}
{
uint shared_memory_size = m_megabytes(32);
HANDLE shared_memory_mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE | SEC_COMMIT, 0, shared_memory_size, m_mpk_import_shared_memory_name);
if (!shared_memory_mapping) {
m_last_error_str(err_str);
m_die("call to \"CreateFileMappingA\" failed\nfile: %s\nerr: %s", m_mpk_import_shared_memory_name, err_str);
}
void *shared_memory_mapping_ptr = MapViewOfFile(shared_memory_mapping, FILE_MAP_WRITE, 0, 0, shared_memory_size);
if (!shared_memory_mapping_ptr) {
m_last_error_str(err_str);
m_die("call to \"MapViewOfFile\" failed\nfile: %s\nerr: %s", m_mpk_import_shared_memory_name, err_str);
}
((mpk_import_shared_memory_header *)shared_memory_mapping_ptr)->total_size = shared_memory_size;
((mpk_import_shared_memory_header *)shared_memory_mapping_ptr)->mpk_size = shared_memory_size - sizeof(struct mpk_import_shared_memory_header);
SetLastError(ERROR_SUCCESS);
HANDLE shared_memory_semaphore = CreateSemaphore(nullptr, 1, 1, m_mpk_import_shared_memory_semaphore_name);
if (!shared_memory_semaphore) {
m_last_error_str(err_str);
m_die("call to \"CreateSemaphore\" failed\nsemaphore: %s\nerr: %s", m_mpk_import_shared_memory_semaphore_name, err_str);
}
if (GetLastError() == ERROR_ALREADY_EXISTS) {
m_die("call to \"CreateSemaphore\" failed\nsemaphore: %s\nerr: %s", m_mpk_import_shared_memory_semaphore_name, "named semaphore already exist");
}
game_buffer_mpk_import_shared_memory_mapping = shared_memory_mapping;
game_buffer_mpk_import_shared_memory_mapping_ptr = shared_memory_mapping_ptr;
game_buffer_mpk_import_shared_memory_semaphore = shared_memory_semaphore;
}
{
game_buffer_editor_job *new_job = nullptr;
if (game_buffer_editor_add_mpk_job(&game_buffer, &new_job)) {
mpk_import_command_line cmdl = m_mpk_import_command_line_default;
cmdl.job_id = new_job->id;
cmdl.import_type = mpk_import_type_fbx;
strcpy(cmdl.fbx_file_path, "assets\\models\\simple_man\\simple_man.fbx");
mpk_import_create_process(&cmdl, common_vars.process_group, &memory_arena);
}
}
#endif // EDITOR_ENABLE
{
char gpk_file_name[] = "assets\\gpks\\example.gpk";
HANDLE gpk_file_handle = CreateFileA(gpk_file_name, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
if (gpk_file_handle == INVALID_HANDLE_VALUE) {
m_last_error_str(err_str);
m_die("call to \"CreateFile\" failed\nfile: %s\nerr: %s", gpk_file_name, err_str);
}
uint file_size = m_megabytes(32);
SetFilePointer(gpk_file_handle, file_size, nullptr, FILE_BEGIN);
if (!SetEndOfFile(gpk_file_handle)) {
m_last_error_str(err_str);
m_die("call to \"SetEndOfFile\" failed\nfile: %s\nsize: %d\nerr: %s", gpk_file_name, file_size, err_str);
}
HANDLE gpk_file_mapping = CreateFileMappingA(gpk_file_handle, nullptr, PAGE_READWRITE, 0, 0, nullptr);
if (!gpk_file_mapping) {
m_last_error_str(err_str);
m_die("call to \"CreateFileMappingA\" failed\nfile: %s\nerr: %s", gpk_file_name, err_str);
}
void *gpk_file_mapping_ptr = MapViewOfFile(gpk_file_mapping, FILE_MAP_WRITE, 0, 0, file_size);
if (!gpk_file_mapping_ptr) {
m_last_error_str(err_str);
m_die("call to \"MapViewOfFile\" failed\nfile: %s\nerr: %s", gpk_file_name, err_str);
}
uint gpk_file_initial_state_size = 0;
if (!gpk_write_initial_state(gpk_file_mapping_ptr, file_size, &gpk_file_initial_state_size)) {
m_die("call to \"gpk_write_initial_state\" failed");
}
if (!FlushViewOfFile(gpk_file_mapping_ptr, gpk_file_initial_state_size)) {
m_last_error_str(err_str);
m_die("call to \"FlushViewOfFile\" failed\nfile: %s\nerr: %s", gpk_file_name, err_str);
}
game_buffer_gpk_file_handle = gpk_file_handle;
game_buffer_gpk_file_mapping = gpk_file_mapping;
game_buffer_gpk_file_mapping_ptr = gpk_file_mapping_ptr;
}
{
game_buffer_update_vulkan_swap_chain_image(&game_buffer, &vulkan);
game_buffer_viewport = rectangle_fit_into_viewport((float)vulkan.swap_chain_info.imageExtent.width, (float)vulkan.swap_chain_info.imageExtent.height, (float)game_buffer.vulkan_framebuffer_image_width, (float)game_buffer.vulkan_framebuffer_image_height);
}
}
uint64 last_frame_time_microsecs = 0;
bool mouse_down_up_same_frame[3] = {};
for (;;) {
LARGE_INTEGER frame_begin_performance_count;
QueryPerformanceCounter(&frame_begin_performance_count);
m_scope_exit(
LARGE_INTEGER frame_end_performance_count;
QueryPerformanceCounter(&frame_end_performance_count);
last_frame_time_microsecs = (frame_end_performance_count.QuadPart - frame_begin_performance_count.QuadPart) * 1000000 / performance_frequency.QuadPart;
);
{
bool mouse_down_this_frame[3] = {};
for (uint i = 0; i < 3; i += 1) {
if (mouse_down_up_same_frame[i]) {
mouse_down_up_same_frame[i] = false;
#ifdef EDITOR_ENABLE
game_buffer_editor_handle_mouse_up(&game_buffer, i);
#endif
}
}
HANDLE iocp = common_vars.io_completion_port;
DWORD iocp_num_bytes = 0;
ULONG_PTR iocp_completion_key = 0;
LPOVERLAPPED iocp_overlapped = nullptr;
DWORD iocp_time_out = 0;
while (GetQueuedCompletionStatus(iocp, &iocp_num_bytes, &iocp_completion_key, &iocp_overlapped, iocp_time_out) == TRUE) {
switch (iocp_completion_key) {
case quit_win_main_event : {
#ifdef EDITOR_ENABLE
ImGui::Shutdown();
#endif
ExitThread(0);
} break;
case window_resize_event : {
uint32 new_width = LOWORD((LPARAM)iocp_overlapped);
uint32 new_height = HIWORD((LPARAM)iocp_overlapped);
if (vulkan.swap_chain_info.imageExtent.width != new_width || vulkan.swap_chain_info.imageExtent.height != new_height) {
if (!vulkan_resize_swap_chain_images(&vulkan, new_width, new_height)) {
m_die("call to \"vulkan_resize_swap_chain_images\" failed");
}
game_buffer_viewport = rectangle_fit_into_viewport((float)vulkan.swap_chain_info.imageExtent.width, (float)vulkan.swap_chain_info.imageExtent.height, (float)game_buffer.vulkan_framebuffer_image_width, (float)game_buffer.vulkan_framebuffer_image_height);
}
} break;
case key_down_event : {
} break;
case key_up_event : {
} break;
case mouse_move_event : {
#ifdef EDITOR_ENABLE
game_buffer_editor_handle_mouse_move(&game_buffer, game_buffer_viewport, LOWORD((LPARAM)iocp_overlapped), HIWORD((LPARAM)iocp_overlapped));
#endif
} break;
case mouse_lbutton_down_event : {
mouse_down_this_frame[0] = true;
#ifdef EDITOR_ENABLE
game_buffer_editor_handle_mouse_down(&game_buffer, 0);
#endif
} break;
case mouse_lbutton_up_event : {
if (mouse_down_this_frame[0]) {
mouse_down_up_same_frame[0] = true;
}
else {
#ifdef EDITOR_ENABLE
game_buffer_editor_handle_mouse_up(&game_buffer, 0);
#endif
}
} break;
case mouse_rbutton_down_event : {
mouse_down_this_frame[1] = true;
#ifdef EDITOR_ENABLE
game_buffer_editor_handle_mouse_down(&game_buffer, 1);
#endif
} break;
case mouse_rbutton_up_event : {
if (mouse_down_this_frame[1]) {
mouse_down_up_same_frame[1] = true;
}
else {
#ifdef EDITOR_ENABLE
game_buffer_editor_handle_mouse_up(&game_buffer, 1);
#endif
}
} break;
case mpk_import_named_pipe_event : {
#ifdef EDITOR_ENABLE
mpk_import_named_pipe_instance *named_pipe_instance = (mpk_import_named_pipe_instance *)iocp_overlapped;
if (named_pipe_instance->connected) {
m_printf("got message %d bytes: %s\n", iocp_num_bytes, named_pipe_instance->message.msg);
game_buffer_editor_handle_mpk_import_message(&game_buffer, &named_pipe_instance->message);
if (named_pipe_instance->message.type == mpk_import_named_pipe_message_type_done) {
void *mpk_ptr = ((struct mpk_import_shared_memory_header *)game_buffer_mpk_import_shared_memory_mapping_ptr) + 1;
struct mpk_header *mpk_header_ptr = (struct mpk_header *)mpk_ptr;
ReleaseSemaphore(game_buffer_mpk_import_shared_memory_semaphore, 1, nullptr);
}
ReadFile(named_pipe_instance->handle, &named_pipe_instance->message, sizeof(named_pipe_instance->message), nullptr, &named_pipe_instance->overlapped);
}
else {
m_printf("new named pipe instance connected\n");
named_pipe_instance->connected = true;
ReadFile(named_pipe_instance->handle, &named_pipe_instance->message, sizeof(named_pipe_instance->message), nullptr, &named_pipe_instance->overlapped);
mpk_import_add_named_pipe_instance(&common_vars);
}
#else
m_die("game loop main: received event \"mpk_import_named_pipe_event\", but editor is not enabled");
#endif
} break;
default : {
m_die("game loop main: call to \"GetQueuedCompletionStatus\" returned an invalid event");
} break;
}
}
}
#ifdef EDITOR_ENABLE
game_buffer.editor->imgui_io->DeltaTime = (float)(last_frame_time_microsecs / 1000000.0);
ImGui::NewFrame();
game_buffer_editor_imgui_new_frame(&game_buffer, &vulkan);
#endif
{
VkResult vk_result = {};
vkWaitForFences(vulkan.device, 1, &vulkan.swap_chain_fence, VK_TRUE, UINT64_MAX);
vkResetFences(vulkan.device, 1, &vulkan.swap_chain_fence);
uint swap_chain_image_index = 0;
if ((vk_result = vkAcquireNextImageKHR(vulkan.device, vulkan.swap_chain, UINT64_MAX, vulkan.swap_chain_image_semaphore, VK_NULL_HANDLE, &swap_chain_image_index)) != VK_SUCCESS) {
m_die("call to \"vkAcquireNextImageKHR\" failed");
}
VkCommandBufferBeginInfo cmd_buffer_begin_info = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
cmd_buffer_begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(vulkan.swap_chain_cmd_buffer, &cmd_buffer_begin_info);
game_buffer_record_vulkan_commands(&game_buffer, &vulkan);
vulkan_record_swap_chain_commands(&vulkan, swap_chain_image_index, game_buffer_viewport);
vkEndCommandBuffer(vulkan.swap_chain_cmd_buffer);
VkSubmitInfo queue_submit_info = { VK_STRUCTURE_TYPE_SUBMIT_INFO };
queue_submit_info.waitSemaphoreCount = 1;
queue_submit_info.pWaitSemaphores = &vulkan.swap_chain_image_semaphore;
VkPipelineStageFlags wait_dst_stage_mask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
queue_submit_info.pWaitDstStageMask = &wait_dst_stage_mask;
queue_submit_info.commandBufferCount = 1;
queue_submit_info.pCommandBuffers = &vulkan.swap_chain_cmd_buffer;
queue_submit_info.signalSemaphoreCount = 1;
queue_submit_info.pSignalSemaphores = &vulkan.swap_chain_queue_semaphore;
if ((vk_result = vkQueueSubmit(vulkan.device_queue, 1, &queue_submit_info, vulkan.swap_chain_fence)) != VK_SUCCESS) {
m_die("call to \"vkQueueSubmit\" failed");
}
VkPresentInfoKHR device_queue_present_info = { VK_STRUCTURE_TYPE_PRESENT_INFO_KHR };
device_queue_present_info.waitSemaphoreCount = 1;
device_queue_present_info.pWaitSemaphores = &vulkan.swap_chain_queue_semaphore;
device_queue_present_info.swapchainCount = 1;
device_queue_present_info.pSwapchains = &vulkan.swap_chain;
device_queue_present_info.pImageIndices = &swap_chain_image_index;
if ((vk_result = vkQueuePresentKHR(vulkan.device_queue, &device_queue_present_info)) != VK_SUCCESS) {
m_die("call to \"vkQueuePresentKHR\" failed");
}
}
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
bool U_ASSERT_ONLY pass;
struct sample_info info = {};
char sample_title[] = "Input Attachment Sample";
const bool depthPresent = false;
const bool vertexPresent = false;
process_command_line_args(info, argc, argv);
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
VkFormatProperties props;
vkGetPhysicalDeviceFormatProperties(info.gpus[0], VK_FORMAT_R8G8B8A8_UNORM, &props);
if (!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) {
std::cout << "VK_FORMAT_R8G8B8A8_UNORM format unsupported for input "
"attachment\n";
exit(-1);
}
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
/* VULKAN_KEY_START */
// Create a framebuffer with 2 attachments, one the color attachment
// the shaders render into, and the other an input attachment which
// will be cleared to yellow, and then used by the shaders to color
// the drawn triangle. Final result should be a yellow triangle
// Create the image that will be used as the input attachment
// The image for the color attachment is the presentable image already
// created in init_swapchain()
VkImageCreateInfo image_create_info = {};
image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
image_create_info.pNext = NULL;
image_create_info.imageType = VK_IMAGE_TYPE_2D;
image_create_info.format = info.format;
image_create_info.extent.width = info.width;
image_create_info.extent.height = info.height;
image_create_info.extent.depth = 1;
image_create_info.mipLevels = 1;
image_create_info.arrayLayers = 1;
image_create_info.samples = NUM_SAMPLES;
image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
image_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
image_create_info.usage = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
image_create_info.queueFamilyIndexCount = 0;
image_create_info.pQueueFamilyIndices = NULL;
image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
image_create_info.flags = 0;
VkMemoryAllocateInfo mem_alloc = {};
mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
mem_alloc.pNext = NULL;
mem_alloc.allocationSize = 0;
mem_alloc.memoryTypeIndex = 0;
VkImage input_image;
VkDeviceMemory input_memory;
res = vkCreateImage(info.device, &image_create_info, NULL, &input_image);
assert(res == VK_SUCCESS);
VkMemoryRequirements mem_reqs;
vkGetImageMemoryRequirements(info.device, input_image, &mem_reqs);
mem_alloc.allocationSize = mem_reqs.size;
pass = memory_type_from_properties(info, mem_reqs.memoryTypeBits, 0, &mem_alloc.memoryTypeIndex);
assert(pass);
res = vkAllocateMemory(info.device, &mem_alloc, NULL, &input_memory);
assert(res == VK_SUCCESS);
res = vkBindImageMemory(info.device, input_image, input_memory, 0);
assert(res == VK_SUCCESS);
// Set the image layout to TRANSFER_DST_OPTIMAL to be ready for clear
set_image_layout(info, input_image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
VkImageSubresourceRange srRange = {};
srRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
srRange.baseMipLevel = 0;
srRange.levelCount = VK_REMAINING_MIP_LEVELS;
srRange.baseArrayLayer = 0;
srRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
VkClearColorValue clear_color;
clear_color.float32[0] = 1.0f;
clear_color.float32[1] = 1.0f;
clear_color.float32[2] = 0.0f;
clear_color.float32[3] = 0.0f;
// Clear the input attachment image to yellow
vkCmdClearColorImage(info.cmd, input_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &srRange);
// Set the image layout to SHADER_READONLY_OPTIMAL for use by the shaders
set_image_layout(info, input_image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
VkImageViewCreateInfo view_info = {};
view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
view_info.pNext = NULL;
view_info.image = VK_NULL_HANDLE;
view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
view_info.format = info.format;
view_info.components.r = VK_COMPONENT_SWIZZLE_R;
view_info.components.g = VK_COMPONENT_SWIZZLE_G;
view_info.components.b = VK_COMPONENT_SWIZZLE_B;
view_info.components.a = VK_COMPONENT_SWIZZLE_A;
view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
view_info.subresourceRange.baseMipLevel = 0;
view_info.subresourceRange.levelCount = 1;
view_info.subresourceRange.baseArrayLayer = 0;
view_info.subresourceRange.layerCount = 1;
VkImageView input_attachment_view;
view_info.image = input_image;
res = vkCreateImageView(info.device, &view_info, NULL, &input_attachment_view);
assert(res == VK_SUCCESS);
VkDescriptorImageInfo input_image_info = {};
input_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
input_image_info.imageView = input_attachment_view;
input_image_info.sampler = VK_NULL_HANDLE;
VkDescriptorSetLayoutBinding layout_bindings[1];
layout_bindings[0].binding = 0;
layout_bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
layout_bindings[0].descriptorCount = 1;
layout_bindings[0].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
layout_bindings[0].pImmutableSamplers = NULL;
VkDescriptorSetLayoutCreateInfo descriptor_layout = {};
descriptor_layout.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
descriptor_layout.pNext = NULL;
descriptor_layout.bindingCount = 1;
descriptor_layout.pBindings = layout_bindings;
info.desc_layout.resize(NUM_DESCRIPTOR_SETS);
res = vkCreateDescriptorSetLayout(info.device, &descriptor_layout, NULL, info.desc_layout.data());
assert(res == VK_SUCCESS);
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {};
pPipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pPipelineLayoutCreateInfo.pNext = NULL;
pPipelineLayoutCreateInfo.pushConstantRangeCount = 0;
pPipelineLayoutCreateInfo.pPushConstantRanges = NULL;
pPipelineLayoutCreateInfo.setLayoutCount = NUM_DESCRIPTOR_SETS;
pPipelineLayoutCreateInfo.pSetLayouts = info.desc_layout.data();
res = vkCreatePipelineLayout(info.device, &pPipelineLayoutCreateInfo, NULL, &info.pipeline_layout);
assert(res == VK_SUCCESS);
// First attachment is the color attachment - clear at the beginning of the
// renderpass and transition layout to PRESENT_SRC_KHR at the end of
// renderpass
VkAttachmentDescription attachments[2];
attachments[0].format = info.format;
attachments[0].samples = VK_SAMPLE_COUNT_1_BIT;
attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachments[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
attachments[0].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
attachments[0].flags = 0;
// Second attachment is input attachment. Once cleared it should have
// width*height yellow pixels. Doing a subpassLoad in the fragment shader
// should give the shader the color at the fragments x,y location
// from the input attachment
attachments[1].format = info.format;
attachments[1].samples = VK_SAMPLE_COUNT_1_BIT;
attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachments[1].initialLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
attachments[1].finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
attachments[1].flags = 0;
VkAttachmentReference color_reference = {};
color_reference.attachment = 0;
color_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkAttachmentReference input_reference = {};
input_reference.attachment = 1;
input_reference.layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
VkSubpassDescription subpass = {};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.flags = 0;
subpass.inputAttachmentCount = 1;
subpass.pInputAttachments = &input_reference;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &color_reference;
subpass.pResolveAttachments = NULL;
subpass.pDepthStencilAttachment = NULL;
subpass.preserveAttachmentCount = 0;
subpass.pPreserveAttachments = NULL;
VkRenderPassCreateInfo rp_info = {};
rp_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
rp_info.pNext = NULL;
rp_info.attachmentCount = 2;
rp_info.pAttachments = attachments;
rp_info.subpassCount = 1;
rp_info.pSubpasses = &subpass;
rp_info.dependencyCount = 0;
rp_info.pDependencies = NULL;
res = vkCreateRenderPass(info.device, &rp_info, NULL, &info.render_pass);
assert(!res);
init_shaders(info, vertShaderText, fragShaderText);
VkImageView fb_attachments[2];
fb_attachments[1] = input_attachment_view;
VkFramebufferCreateInfo fbc_info = {};
fbc_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
fbc_info.pNext = NULL;
fbc_info.renderPass = info.render_pass;
fbc_info.attachmentCount = 2;
fbc_info.pAttachments = fb_attachments;
fbc_info.width = info.width;
fbc_info.height = info.height;
fbc_info.layers = 1;
uint32_t i;
info.framebuffers = (VkFramebuffer *)malloc(info.swapchainImageCount * sizeof(VkFramebuffer));
for (i = 0; i < info.swapchainImageCount; i++) {
fb_attachments[0] = info.buffers[i].view;
res = vkCreateFramebuffer(info.device, &fbc_info, NULL, &info.framebuffers[i]);
assert(res == VK_SUCCESS);
}
VkDescriptorPoolSize type_count[1];
type_count[0].type = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
type_count[0].descriptorCount = 1;
VkDescriptorPoolCreateInfo descriptor_pool = {};
descriptor_pool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
descriptor_pool.pNext = NULL;
descriptor_pool.maxSets = 1;
descriptor_pool.poolSizeCount = 1;
descriptor_pool.pPoolSizes = type_count;
res = vkCreateDescriptorPool(info.device, &descriptor_pool, NULL, &info.desc_pool);
assert(res == VK_SUCCESS);
VkDescriptorSetAllocateInfo desc_alloc_info[1];
desc_alloc_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
desc_alloc_info[0].pNext = NULL;
desc_alloc_info[0].descriptorPool = info.desc_pool;
desc_alloc_info[0].descriptorSetCount = 1;
desc_alloc_info[0].pSetLayouts = info.desc_layout.data();
info.desc_set.resize(1);
res = vkAllocateDescriptorSets(info.device, desc_alloc_info, info.desc_set.data());
assert(res == VK_SUCCESS);
VkWriteDescriptorSet writes[1];
// Write descriptor set with one write describing input attachment
writes[0] = {};
writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
writes[0].dstSet = info.desc_set[0];
writes[0].dstBinding = 0;
writes[0].descriptorCount = 1;
writes[0].descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
writes[0].pImageInfo = &input_image_info;
writes[0].pBufferInfo = nullptr;
writes[0].pTexelBufferView = nullptr;
writes[0].dstArrayElement = 0;
vkUpdateDescriptorSets(info.device, 1, writes, 0, NULL);
init_pipeline_cache(info);
init_pipeline(info, depthPresent, vertexPresent);
// Color attachment clear to gray
VkClearValue clear_values;
clear_values.color.float32[0] = 0.2f;
clear_values.color.float32[1] = 0.2f;
clear_values.color.float32[2] = 0.2f;
clear_values.color.float32[3] = 0.2f;
VkSemaphoreCreateInfo imageAcquiredSemaphoreCreateInfo;
imageAcquiredSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
imageAcquiredSemaphoreCreateInfo.pNext = NULL;
imageAcquiredSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &imageAcquiredSemaphoreCreateInfo, NULL, &info.imageAcquiredSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX, info.imageAcquiredSemaphore, VK_NULL_HANDLE,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
VkRenderPassBeginInfo rp_begin;
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.pNext = NULL;
rp_begin.renderPass = info.render_pass;
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderArea.offset.x = 0;
rp_begin.renderArea.offset.y = 0;
rp_begin.renderArea.extent.width = info.width;
rp_begin.renderArea.extent.height = info.height;
rp_begin.clearValueCount = 1;
rp_begin.pClearValues = &clear_values;
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 0, NULL);
init_viewports(info);
init_scissors(info);
vkCmdDraw(info.cmd, 3, 1, 0, 0);
vkCmdEndRenderPass(info.cmd);
res = vkEndCommandBuffer(info.cmd);
assert(res == VK_SUCCESS);
/* VULKAN_KEY_END */
const VkCommandBuffer cmd_bufs[] = {info.cmd};
VkFenceCreateInfo fenceInfo;
VkFence drawFence;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);
execute_queue_cmdbuf(info, cmd_bufs, drawFence);
do {
res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
vkDestroyFence(info.device, drawFence, NULL);
execute_present_image(info);
wait_seconds(1);
if (info.save_images) write_ppm(info, "input_attachment");
vkDestroySemaphore(info.device, info.imageAcquiredSemaphore, NULL);
vkDestroyImageView(info.device, input_attachment_view, NULL);
vkDestroyImage(info.device, input_image, NULL);
vkFreeMemory(info.device, input_memory, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
destroy_descriptor_pool(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
destroy_descriptor_and_pipeline_layouts(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
bool render() {
if (!vk_globals::is_init) {
return false;
}
vkDeviceWaitIdle(vk_globals::device);
if (!check_events()) {
return false;
}
resources::s_render_context const* render_context;
VERIFY(resources::get_current_render_context(&render_context));
uint32_t image_index;
VkResult result = vkAcquireNextImageKHR(vk_globals::device, vk_globals::swapchain.handle,
UINT64_MAX, render_context->image_available_semaphore,
VK_NULL_HANDLE, &image_index);
switch (result) {
case VK_SUCCESS:
break;
case VK_SUBOPTIMAL_KHR:
case VK_ERROR_OUT_OF_DATE_KHR:
graphics::render3d::resources::create_pipeline();
return true;
default:
SET_ERROR (LOG_TYPE, "Problem occurred during swap chain image acquisition!", "");
return false;
}
VERIFY(fill_present_command_buffer(render_context->command_buffer, vk_globals::swapchain.images[image_index]));
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
&render_context->image_available_semaphore, // const VkSemaphore *pWaitSemaphores
&wait_dst_stage_mask, // const VkPipelineStageFlags *pWaitDstStageMask;
1, // uint32_t commandBufferCount
&render_context->command_buffer, // const VkCommandBuffer *pCommandBuffers
1, // uint32_t signalSemaphoreCount
&render_context->rendering_finished_semaphore // const VkSemaphore *pSignalSemaphores
};
VK_VERIFY (vkQueueSubmit(vk_globals::present_queue.handle, 1, &submit_info, render_context->fence));
VkPresentInfoKHR present_info = {
VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, // VkStructureType sType
nullptr, // const void *pNext
1, // uint32_t waitSemaphoreCount
&render_context->rendering_finished_semaphore, // const VkSemaphore *pWaitSemaphores
1, // uint32_t swapchainCount
&(vk_globals::swapchain.handle), // const VkSwapchainKHR *pSwapchains
&image_index, // const uint32_t *pImageIndices
nullptr // VkResult *pResults
};
result = vkQueuePresentKHR(vk_globals::present_queue.handle, &present_info);
switch (result) {
case VK_SUCCESS:
break;
case VK_ERROR_OUT_OF_DATE_KHR:
case VK_SUBOPTIMAL_KHR:
return true;
default:
SET_ERROR (LOG_TYPE, "Problem occurred during image presentation!", "");
return false;
}
return true;
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
bool U_ASSERT_ONLY pass;
struct sample_info info = {};
char sample_title[] = "Texel Buffer Sample";
float texels[] = {1.0, 0.0, 1.0};
const bool depthPresent = false;
const bool vertexPresent = false;
process_command_line_args(info, argc, argv);
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
if (info.gpu_props.limits.maxTexelBufferElements < 4) {
std::cout << "maxTexelBufferElements too small\n";
exit(-1);
}
VkFormatProperties props;
vkGetPhysicalDeviceFormatProperties(info.gpus[0], VK_FORMAT_R32_SFLOAT, &props);
if (!(props.bufferFeatures & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)) {
std::cout << "R32_SFLOAT format unsupported for texel buffer\n";
exit(-1);
}
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
VkBufferCreateInfo buf_info = {};
buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
buf_info.pNext = NULL;
buf_info.usage = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
buf_info.size = sizeof(texels);
buf_info.queueFamilyIndexCount = 0;
buf_info.pQueueFamilyIndices = NULL;
buf_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
buf_info.flags = 0;
VkBuffer texelBuf;
res = vkCreateBuffer(info.device, &buf_info, NULL, &texelBuf);
assert(res == VK_SUCCESS);
VkMemoryRequirements mem_reqs;
vkGetBufferMemoryRequirements(info.device, texelBuf, &mem_reqs);
VkMemoryAllocateInfo alloc_info = {};
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
alloc_info.pNext = NULL;
alloc_info.memoryTypeIndex = 0;
alloc_info.allocationSize = mem_reqs.size;
pass = memory_type_from_properties(info, mem_reqs.memoryTypeBits,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&alloc_info.memoryTypeIndex);
assert(pass && "No mappable, coherent memory");
VkDeviceMemory texelMem;
res = vkAllocateMemory(info.device, &alloc_info, NULL, &texelMem);
assert(res == VK_SUCCESS);
uint8_t *pData;
res = vkMapMemory(info.device, texelMem, 0, mem_reqs.size, 0, (void **)&pData);
assert(res == VK_SUCCESS);
memcpy(pData, &texels, sizeof(texels));
vkUnmapMemory(info.device, texelMem);
res = vkBindBufferMemory(info.device, texelBuf, texelMem, 0);
assert(res == VK_SUCCESS);
VkBufferView texel_view;
VkBufferViewCreateInfo view_info = {};
view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
view_info.pNext = NULL;
view_info.buffer = texelBuf;
view_info.format = VK_FORMAT_R32_SFLOAT;
view_info.offset = 0;
view_info.range = sizeof(texels);
vkCreateBufferView(info.device, &view_info, NULL, &texel_view);
VkDescriptorBufferInfo texel_buffer_info = {};
texel_buffer_info.buffer = texelBuf;
texel_buffer_info.offset = 0;
texel_buffer_info.range = sizeof(texels);
// init_descriptor_and_pipeline_layouts(info, false);
VkDescriptorSetLayoutBinding layout_bindings[1];
layout_bindings[0].binding = 0;
layout_bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
layout_bindings[0].descriptorCount = 1;
layout_bindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
layout_bindings[0].pImmutableSamplers = NULL;
/* Next take layout bindings and use them to create a descriptor set layout
*/
VkDescriptorSetLayoutCreateInfo descriptor_layout = {};
descriptor_layout.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
descriptor_layout.pNext = NULL;
descriptor_layout.bindingCount = 1;
descriptor_layout.pBindings = layout_bindings;
info.desc_layout.resize(NUM_DESCRIPTOR_SETS);
res = vkCreateDescriptorSetLayout(info.device, &descriptor_layout, NULL, info.desc_layout.data());
assert(res == VK_SUCCESS);
/* Now use the descriptor layout to create a pipeline layout */
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {};
pPipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pPipelineLayoutCreateInfo.pNext = NULL;
pPipelineLayoutCreateInfo.pushConstantRangeCount = 0;
pPipelineLayoutCreateInfo.pPushConstantRanges = NULL;
pPipelineLayoutCreateInfo.setLayoutCount = NUM_DESCRIPTOR_SETS;
pPipelineLayoutCreateInfo.pSetLayouts = info.desc_layout.data();
res = vkCreatePipelineLayout(info.device, &pPipelineLayoutCreateInfo, NULL, &info.pipeline_layout);
assert(res == VK_SUCCESS);
init_renderpass(info, depthPresent);
init_shaders(info, vertShaderText, fragShaderText);
init_framebuffers(info, depthPresent);
VkDescriptorPoolSize type_count[1];
type_count[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
type_count[0].descriptorCount = 1;
VkDescriptorPoolCreateInfo descriptor_pool = {};
descriptor_pool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
descriptor_pool.pNext = NULL;
descriptor_pool.maxSets = 1;
descriptor_pool.poolSizeCount = 1;
descriptor_pool.pPoolSizes = type_count;
res = vkCreateDescriptorPool(info.device, &descriptor_pool, NULL, &info.desc_pool);
assert(res == VK_SUCCESS);
VkDescriptorSetAllocateInfo desc_alloc_info[1];
desc_alloc_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
desc_alloc_info[0].pNext = NULL;
desc_alloc_info[0].descriptorPool = info.desc_pool;
desc_alloc_info[0].descriptorSetCount = NUM_DESCRIPTOR_SETS;
desc_alloc_info[0].pSetLayouts = info.desc_layout.data();
/* Allocate descriptor set with UNIFORM_BUFFER_DYNAMIC */
info.desc_set.resize(NUM_DESCRIPTOR_SETS);
res = vkAllocateDescriptorSets(info.device, desc_alloc_info, info.desc_set.data());
assert(res == VK_SUCCESS);
VkWriteDescriptorSet writes[1];
writes[0] = {};
writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
writes[0].dstSet = info.desc_set[0];
writes[0].dstBinding = 0;
writes[0].descriptorCount = 1;
writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
writes[0].pBufferInfo = &texel_buffer_info;
writes[0].pTexelBufferView = &texel_view;
writes[0].dstArrayElement = 0;
vkUpdateDescriptorSets(info.device, 1, writes, 0, NULL);
init_pipeline_cache(info);
init_pipeline(info, depthPresent, vertexPresent);
/* VULKAN_KEY_START */
VkClearValue clear_values[1];
clear_values[0].color.float32[0] = 0.2f;
clear_values[0].color.float32[1] = 0.2f;
clear_values[0].color.float32[2] = 0.2f;
clear_values[0].color.float32[3] = 0.2f;
VkSemaphoreCreateInfo imageAcquiredSemaphoreCreateInfo;
imageAcquiredSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
imageAcquiredSemaphoreCreateInfo.pNext = NULL;
imageAcquiredSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &imageAcquiredSemaphoreCreateInfo, NULL, &info.imageAcquiredSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX, info.imageAcquiredSemaphore, VK_NULL_HANDLE,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
VkRenderPassBeginInfo rp_begin;
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.pNext = NULL;
rp_begin.renderPass = info.render_pass;
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderArea.offset.x = 0;
rp_begin.renderArea.offset.y = 0;
rp_begin.renderArea.extent.width = info.width;
rp_begin.renderArea.extent.height = info.height;
rp_begin.clearValueCount = 1;
rp_begin.pClearValues = clear_values;
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 0, NULL);
init_viewports(info);
init_scissors(info);
vkCmdDraw(info.cmd, 3, 1, 0, 0);
vkCmdEndRenderPass(info.cmd);
res = vkEndCommandBuffer(info.cmd);
const VkCommandBuffer cmd_bufs[] = {info.cmd};
VkFenceCreateInfo fenceInfo;
VkFence drawFence;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);
execute_queue_cmdbuf(info, cmd_bufs, drawFence);
do {
res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
vkDestroyFence(info.device, drawFence, NULL);
execute_present_image(info);
wait_seconds(1);
/* VULKAN_KEY_END */
if (info.save_images) write_ppm(info, "texel_buffer");
vkDestroySemaphore(info.device, info.imageAcquiredSemaphore, NULL);
vkDestroyBufferView(info.device, texel_view, NULL);
vkDestroyBuffer(info.device, texelBuf, NULL);
vkFreeMemory(info.device, texelMem, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
destroy_descriptor_pool(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
destroy_descriptor_and_pipeline_layouts(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Copy/Blit Image";
VkImageCreateInfo image_info;
VkImage bltSrcImage;
VkImage bltDstImage;
VkMemoryRequirements memReq;
VkMemoryAllocateInfo memAllocInfo;
VkDeviceMemory dmem;
unsigned char *pImgMem;
process_command_line_args(info, argc, argv);
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_window_size(info, 640, 640);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
VkSurfaceCapabilitiesKHR surfCapabilities;
res = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(info.gpus[0], info.surface,
&surfCapabilities);
if (!(surfCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) {
std::cout << "Surface cannot be destination of blit - abort \n";
exit(-1);
}
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT);
/* VULKAN_KEY_START */
VkFormatProperties formatProps;
vkGetPhysicalDeviceFormatProperties(info.gpus[0], info.format,
&formatProps);
assert(
(formatProps.linearTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT) &&
"Format cannot be used as transfer source");
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo;
presentCompleteSemaphoreCreateInfo.sType =
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
presentCompleteSemaphoreCreateInfo.pNext = NULL;
presentCompleteSemaphoreCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
res = vkCreateSemaphore(info.device, &presentCompleteSemaphoreCreateInfo,
NULL, &presentCompleteSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX,
presentCompleteSemaphore, VK_NULL_HANDLE,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
// Create an image, map it, and write some values to the image
image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
image_info.pNext = NULL;
image_info.imageType = VK_IMAGE_TYPE_2D;
image_info.format = info.format;
image_info.extent.width = info.width;
image_info.extent.height = info.height;
image_info.extent.depth = 1;
image_info.mipLevels = 1;
image_info.arrayLayers = 1;
image_info.samples = NUM_SAMPLES;
image_info.queueFamilyIndexCount = 0;
image_info.pQueueFamilyIndices = NULL;
image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
image_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
image_info.flags = 0;
image_info.tiling = VK_IMAGE_TILING_LINEAR;
image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
res = vkCreateImage(info.device, &image_info, NULL, &bltSrcImage);
memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
memAllocInfo.pNext = NULL;
vkGetImageMemoryRequirements(info.device, bltSrcImage, &memReq);
bool pass = memory_type_from_properties(info, memReq.memoryTypeBits,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
&memAllocInfo.memoryTypeIndex);
assert(pass);
memAllocInfo.allocationSize = memReq.size;
res = vkAllocateMemory(info.device, &memAllocInfo, NULL, &dmem);
res = vkBindImageMemory(info.device, bltSrcImage, dmem, 0);
set_image_layout(info, bltSrcImage, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL);
res = vkEndCommandBuffer(info.cmd);
assert(res == VK_SUCCESS);
VkFence cmdFence;
init_fence(info, cmdFence);
VkPipelineStageFlags pipe_stage_flags =
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
VkSubmitInfo submit_info = {};
submit_info.pNext = NULL;
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info.waitSemaphoreCount = 1;
submit_info.pWaitSemaphores = &presentCompleteSemaphore;
submit_info.pWaitDstStageMask = &pipe_stage_flags;
submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &info.cmd;
submit_info.signalSemaphoreCount = 0;
submit_info.pSignalSemaphores = NULL;
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, &submit_info, cmdFence);
assert(res == VK_SUCCESS);
/* Make sure command buffer is finished before mapping */
do {
res =
vkWaitForFences(info.device, 1, &cmdFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
vkDestroyFence(info.device, cmdFence, NULL);
res = vkMapMemory(info.device, dmem, 0, memReq.size, 0, (void **)&pImgMem);
// Checkerboard of 8x8 pixel squares
for (int row = 0; row < info.height; row++) {
for (int col = 0; col < info.width; col++) {
unsigned char rgb = (((row & 0x8) == 0) ^ ((col & 0x8) == 0)) * 255;
pImgMem[0] = rgb;
pImgMem[1] = rgb;
pImgMem[2] = rgb;
pImgMem[3] = 255;
pImgMem += 4;
}
}
// Flush the mapped memory and then unmap it Assume it isn't coherent since
// we didn't really confirm
VkMappedMemoryRange memRange;
memRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
memRange.pNext = NULL;
memRange.memory = dmem;
memRange.offset = 0;
memRange.size = memReq.size;
res = vkFlushMappedMemoryRanges(info.device, 1, &memRange);
vkUnmapMemory(info.device, dmem);
vkResetCommandBuffer(info.cmd, 0);
execute_begin_command_buffer(info);
set_image_layout(info, bltSrcImage, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_GENERAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
bltDstImage = info.buffers[info.current_buffer].image;
// init_swap_chain will create the images as color attachment optimal
// but we want transfer dst optimal
set_image_layout(info, bltDstImage, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
// Do a 32x32 blit to all of the dst image - should get big squares
VkImageBlit region;
region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.srcSubresource.mipLevel = 0;
region.srcSubresource.baseArrayLayer = 0;
region.srcSubresource.layerCount = 1;
region.srcOffsets[0].x = 0;
region.srcOffsets[0].y = 0;
region.srcOffsets[0].z = 0;
region.srcOffsets[1].x = 32;
region.srcOffsets[1].y = 32;
region.srcOffsets[1].z = 1;
region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.dstSubresource.mipLevel = 0;
region.dstSubresource.baseArrayLayer = 0;
region.dstSubresource.layerCount = 1;
region.dstOffsets[0].x = 0;
region.dstOffsets[0].y = 0;
region.dstOffsets[0].z = 0;
region.dstOffsets[1].x = info.width;
region.dstOffsets[1].y = info.height;
region.dstOffsets[1].z = 1;
vkCmdBlitImage(info.cmd, bltSrcImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
bltDstImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
®ion, VK_FILTER_LINEAR);
// Do a image copy to part of the dst image - checks should stay small
VkImageCopy cregion;
cregion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
cregion.srcSubresource.mipLevel = 0;
cregion.srcSubresource.baseArrayLayer = 0;
cregion.srcSubresource.layerCount = 1;
cregion.srcOffset.x = 0;
cregion.srcOffset.y = 0;
cregion.srcOffset.z = 0;
cregion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
cregion.dstSubresource.mipLevel = 0;
cregion.dstSubresource.baseArrayLayer = 0;
cregion.dstSubresource.layerCount = 1;
cregion.dstOffset.x = 256;
cregion.dstOffset.y = 256;
cregion.dstOffset.z = 0;
cregion.extent.width = 128;
cregion.extent.height = 128;
cregion.extent.depth = 1;
vkCmdCopyImage(info.cmd, bltSrcImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
bltDstImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
&cregion);
VkImageMemoryBarrier prePresentBarrier = {};
prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
prePresentBarrier.pNext = NULL;
prePresentBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
prePresentBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
prePresentBarrier.subresourceRange.baseMipLevel = 0;
prePresentBarrier.subresourceRange.levelCount = 1;
prePresentBarrier.subresourceRange.baseArrayLayer = 0;
prePresentBarrier.subresourceRange.layerCount = 1;
prePresentBarrier.image = info.buffers[info.current_buffer].image;
vkCmdPipelineBarrier(info.cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0,
NULL, 1, &prePresentBarrier);
res = vkEndCommandBuffer(info.cmd);
VkFenceCreateInfo fenceInfo;
VkFence drawFence;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);
submit_info.pNext = NULL;
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info.waitSemaphoreCount = 0;
submit_info.pWaitSemaphores = NULL;
submit_info.pWaitDstStageMask = NULL;
submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &info.cmd;
submit_info.signalSemaphoreCount = 0;
submit_info.pSignalSemaphores = NULL;
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, &submit_info, drawFence);
assert(res == VK_SUCCESS);
res = vkQueueWaitIdle(info.queue);
assert(res == VK_SUCCESS);
/* Now present the image in the window */
VkPresentInfoKHR present;
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present.pNext = NULL;
present.swapchainCount = 1;
present.pSwapchains = &info.swap_chain;
present.pImageIndices = &info.current_buffer;
present.pWaitSemaphores = NULL;
present.waitSemaphoreCount = 0;
present.pResults = NULL;
/* Make sure command buffer is finished before presenting */
do {
res =
vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
res = vkQueuePresentKHR(info.queue, &present);
assert(res == VK_SUCCESS);
wait_seconds(1);
/* VULKAN_KEY_END */
if (info.save_images)
write_ppm(info, "copyblitimage");
vkDestroySemaphore(info.device, presentCompleteSemaphore, NULL);
vkDestroyFence(info.device, drawFence, NULL);
vkDestroyImage(info.device, bltSrcImage, NULL);
vkFreeMemory(info.device, dmem, NULL);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
int tut7_render_start(struct tut7_render_essentials *essentials, struct tut2_device *dev,
struct tut6_swapchain *swapchain, VkImageLayout to_layout, uint32_t *image_index)
{
tut1_error retval = TUT1_ERROR_NONE;
VkResult res;
/* Use `vkAcquireNextImageKHR` to get an image to render to */
res = vkAcquireNextImageKHR(dev->device, swapchain->swapchain, 1000000000, essentials->sem_post_acquire, NULL, image_index);
tut1_error_set_vkresult(&retval, res);
if (res == VK_TIMEOUT)
{
printf("A whole second and no image. I give up.\n");
return -1;
}
else if (res == VK_SUBOPTIMAL_KHR)
printf("Did you change the window size? I didn't recreate the swapchains,\n"
"so the presentation is now suboptimal.\n");
else if (res < 0)
{
tut1_error_printf(&retval, "Couldn't acquire image\n");
return -1;
}
/*
* Unless the first time we are rendering, wait for the last frame to finish rendering. Let's wait up to a
* second, and if the fence is still not signalled, we'll assume something went horribly wrong and quit.
*
* This wait needs to be done before we start recording over the command buffer again, because, well, if not
* we would be resetting it while it's being executed.
*/
if (!essentials->first_render)
{
res = vkWaitForFences(dev->device, 1, &essentials->exec_fence, true, 1000000000);
tut1_error_set_vkresult(&retval, res);
if (res)
{
tut1_error_printf(&retval, "Wait for fence failed\n");
return -1;
}
}
essentials->first_render = false;
/*
* We have seen many of the command buffer functions in Tutorial 4. Here is a short recap:
*
* - reset: remove all previous recordings from the command buffer
* - begin: start recording
* - bind pipeline: specify the pipeline the commands run on (unused here)
* - bind descriptor set: specify resources to use for rendering (unused here)
* - end: stop recording
*/
vkResetCommandBuffer(essentials->cmd_buffer, 0);
VkCommandBufferBeginInfo begin_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
};
res = vkBeginCommandBuffer(essentials->cmd_buffer, &begin_info);
tut1_error_set_vkresult(&retval, res);
if (res)
{
tut1_error_printf(&retval, "Couldn't even begin recording a command buffer\n");
return -1;
}
/*
* To transition an image to a new layout, an image barrier is used. Before we see how that is done, let's see
* what it even means.
*
* In Vulkan, there are barriers on different kinds of resources (images, buffers and memory) and other means
* to specify execution dependency. In each case, you want to make sure some actions A are all executed before
* some actions B. In the specific case of barriers, A could be actions that do something to the resource and
* B could be actions that need the result of those actions.
*
* In our specific case, we want to change the layout of a swapchain image. For the transition from present
* src, we want to make sure that all writes to the image are done after the transition is done. For the
* transition to present src, we want to make sure that all writes to the image are done before the transition
* is done. Note: if we had a graphics pipeline, we would be talking about "color attachment writes" instead
* of just "writes". Keep that in mind.
*
* Using a VkImageMemoryBarrier, we are not only specifying how the image layout should change (if changed at
* all), but also defining the actions A and B where an execution dependency would be created. In the first
* barrier (transition from present src), all reads of the image (for previous presentation) must happen before
* the barrier (A is the set of READ operations), and all writes must be done after the barrier (B is the set
* of WRITE operations). The situation is reversed with the second barrier (transition to present src).
*
* In Vulkan, actions A are referred to as `src` and actions B are referred to as `dst`.
*
* Using an image barrier, it's also possible to transfer one image from a queue family to another, in which
* case A is the set of actions accessing the image in the first queue family and B is the set of actions
* accessing the image in the second queue family. We are not moving between queue families, so we'll specify
* this intention as well.
*
* In our layout transition, we are transitioning from present src to to_layout and back. However, the first
* time the transition happens, the swapchain image layout is actually UNDEFINED. Either way, since we are not
* interested in what was previously in the image when we are just about to render into it, we can set the
* `oldLayout` (the layout transitioning from) to UNDEFINED. This makes the transition more efficient because
* Vulkan knows it can just throw away the contents of the image. Note: in Tutorial 7, we are transition to
* "general", but if we had a graphics pipeline, we would be transition to the "color attachment optimal"
* layout instead.
*
* Finally, we need to specify which part of the image (subresource) is being transitioned. We want to
* transition COLOR parts of the image (which in this case, all of the image is COLOR), and all mip levels and
* arrays (which are both in this case single).
*/
VkImageMemoryBarrier image_barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT,
.dstAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.newLayout = to_layout,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = essentials->images[*image_index],
.subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0,
.levelCount = 1,
.baseArrayLayer = 0,
.layerCount = 1,
},
};
/*
* The image barrier structure above defines the execution dependency of sets of actions A and B. When
* applying the barrier, we also need to specify which pipeline stages these sets of actions are taken from.
*
* In our barrier, first we want to make sure all READs from the image (by the previous presentation) is done
* before the barrier. These reads are not part of our rendering. In fact, they are really done before the
* graphics pipeline even begins. So the pipeline stage we specify for `src` would be the top of the pipeline,
* which means before the pipeline begins. Second, we want to make sure all writes to the image (for
* rendering) is done after the barrier. The writes to the image are likely to happen at later stages of the
* graphics pipeline, so we can specify those stages as `dst` stages of the barrier. We have already specified
* that the barrier works on WRITEs, so we can also be a bit lazy and say that the `dst` stage is all graphics
* pipeline stages.
*
* Let's rephrase the above to make sure it's clear. The vkCmdPipelineBarrier takes a src and dst stage mask.
* The arguments are called srcStageMask and dstStageMask. They can contain more than one pipeline stage.
* Take the combinations (srcAccessMask, srcStageMask) and (dstAccessMask, dstStageMask). Say we make a
* barrier from (A, Sa) to (B, Sb) as src and dst parts of the barrier respectively. The barrier then means
* that all actions A in stages Sa are done before all actions B in stages Sb. So, if Sb is all graphics
* stages, it means that all actions A in stages Sa are done before all actions B anywhere. If Sa is top of
* the pipeline, it means that all actions A before the pipeline are done before all actions B anywhere.
*
* All READs before the pipeline must be done before all WRITEs anywhere.
*/
vkCmdPipelineBarrier(essentials->cmd_buffer,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
0, /* no flags */
0, NULL, /* no memory barriers */
0, NULL, /* no buffer barriers */
1, &image_barrier); /* our image transition */
return 0;
}
void VulkanBase::createInstance() {
// Application info init
const VkApplicationInfo applicationInfo = {
.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
.pNext = NULL,
.pApplicationName = name.c_str(),
.applicationVersion = 1,
.pEngineName = engineName.c_str(),
.engineVersion = 1,
.apiVersion = VK_API_VERSION, //FIXME Nvidia driver not updated to latest Vulkan Version
};
VkInstanceCreateInfo instanceCreateInfo = {
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pNext = NULL,
.flags = VK_FLAGS_NONE,
.pApplicationInfo = &applicationInfo,
.enabledLayerCount = 0,
.ppEnabledLayerNames = NULL,
.enabledExtensionCount = 0,
.ppEnabledExtensionNames = NULL,
};
std::vector<const char*> enabledExtensions = { VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XCB_SURFACE_EXTENSION_NAME};
//Check if extensions are present
vkUtils::checkGlobalExtensionPresent(VK_KHR_SURFACE_EXTENSION_NAME);
vkUtils::checkGlobalExtensionPresent(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
#ifdef _DEBUG
if (enableValidation) {
//Extensions management
enabledExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
vkUtils::checkGlobalExtensionPresent(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
// Layer management
instanceCreateInfo.enabledLayerCount = vkDebug::validationLayerCount;
instanceCreateInfo.ppEnabledLayerNames = vkDebug::validationLayerNames;
// Check standard debug layers are present
for(uint32_t i = 0; i < instanceCreateInfo.enabledLayerCount; i++) {
vkUtils::checkGlobalLayerPresent(vkDebug::validationLayerNames[i]);
}
}
#endif // DEBUG
instanceCreateInfo.ppEnabledExtensionNames = enabledExtensions.data();
instanceCreateInfo.enabledExtensionCount = (uint32_t) enabledExtensions.size();
CHECK_RESULT(vkCreateInstance(&instanceCreateInfo, nullptr, &instance));
}
void VulkanBase::selectVkPhysicalDevice() {
uint32_t physicalDeviceCount = 0;
CHECK_RESULT(vkEnumeratePhysicalDevices(instance,&physicalDeviceCount,nullptr));
if (physicalDeviceCount<=0) {
ERROR("No physical device found");
}
std::vector<VkPhysicalDevice> physicalDevicesVector(physicalDeviceCount);
CHECK_RESULT(vkEnumeratePhysicalDevices(instance,&physicalDeviceCount,physicalDevicesVector.data()));
#ifdef _DEBUG
int deviceIndex = 0;
for(const auto & phyDev : physicalDevicesVector) {
VkPhysicalDeviceProperties phyDevProperties;
vkGetPhysicalDeviceProperties(phyDev, &phyDevProperties);
std::cout << "--- Physical device: " << phyDevProperties.deviceName << " (index: " << (deviceIndex++) << ")" << std::endl;
std::cout << " apiVersion: " << phyDevProperties.apiVersion << std::endl;
std::cout << " driverVersion: " << phyDevProperties.driverVersion << std::endl;
std::cout << " vendorID: " << phyDevProperties.vendorID << std::endl;
std::cout << " deviceID: " << phyDevProperties.deviceID << std::endl;
std::cout << " deviceType: ";
switch(phyDevProperties.deviceType) {
case VK_PHYSICAL_DEVICE_TYPE_OTHER:
std::cout << "OTHER";
break;
case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
std::cout << "INTEGRATED_GPU";
break;
case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
std::cout << "DISCRETE_GPU";
break;
case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
std::cout << "VIRTUAL_GPU";
break;
case VK_PHYSICAL_DEVICE_TYPE_CPU:
std::cout << "CPU";
break;
default:
std::cout << "UNKNOWN!!!";
break;
}
std::cout << std::endl;
}
#endif // _DEBUG
physicalDevice = physicalDevicesVector.at(0);
// Gather Physical Device Memory Properties
vkGetPhysicalDeviceMemoryProperties(physicalDevice,&physicalDeviceMemoryProperties);
}
void VulkanBase::selectQueue() {
uint32_t queueFamilyPropertyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice,&queueFamilyPropertyCount,nullptr);
if (queueFamilyPropertyCount<=0)
ERROR("Physical device has no queue families");
std::vector<VkQueueFamilyProperties> queueFamilyPropertiesVector(queueFamilyPropertyCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice,&queueFamilyPropertyCount,queueFamilyPropertiesVector.data());
uint32_t queueFamilyIndex = 0;
int32_t selectedQueueFamilyIndex = -1;
VkBool32 presentSupport = VK_FALSE;
#ifdef _DEBUG
std::cout << std::endl << "--- Number of queue families " << queueFamilyPropertyCount << std::endl;
#endif // _DEBUG
for(const auto & queueFamProp : queueFamilyPropertiesVector) {
CHECK_RESULT(vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, swapchain.surface, &presentSupport));
#ifdef _DEBUG
std::cout << "--- Properties for queue family " << queueFamilyIndex << std::endl;
std::cout << " queueFlags:";
if(queueFamProp.queueFlags & VK_QUEUE_GRAPHICS_BIT)
std::cout << " G";
if(queueFamProp.queueFlags & VK_QUEUE_COMPUTE_BIT)
std::cout << " C";
if(queueFamProp.queueFlags & VK_QUEUE_TRANSFER_BIT)
std::cout << " T";
if(queueFamProp.queueFlags & VK_QUEUE_SPARSE_BINDING_BIT)
std::cout << " S";
std::cout << '\n';
std::cout << " queueCount: " << queueFamProp.queueCount << std::endl;
std::cout << " timestampValidBits: " << queueFamProp.timestampValidBits << std::endl;
std::cout << " minImageTransferGranularity: " << queueFamProp.minImageTransferGranularity.width
<< ", " << queueFamProp.minImageTransferGranularity.height
<< ", " << queueFamProp.minImageTransferGranularity.depth
<< std::endl;
std::cout << " Supports present?: " << std::boolalpha << bool(presentSupport) << std::endl << std::endl;
#endif // _DEBUG
if (bool(queueFamProp.queueFlags & VK_QUEUE_GRAPHICS_BIT) && presentSupport == VK_TRUE) {
if (selectedQueueFamilyIndex < 0)
selectedQueueFamilyIndex = queueFamilyIndex;
}
queueFamilyIndex++;
}
if (selectedQueueFamilyIndex<0)
ERROR("No queue with both graphics and present capabilities found");
// Create device after selecting the queue
std::array<float,1> queuePriorities = {0.0f};
VkDeviceQueueCreateInfo queueCreateInfo = {
.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
.pNext = nullptr,
.flags = VK_FLAGS_NONE,
.queueFamilyIndex = (uint32_t) selectedQueueFamilyIndex,
.queueCount = 1, //Number of queues to create
.pQueuePriorities = queuePriorities.data()
};
// Call to createDevice
createDevice(queueCreateInfo,1);
//Get a handle to the selected queue
vkGetDeviceQueue(device, (uint32_t) selectedQueueFamilyIndex, 0, &queue); //TODO get handle if using multiple queues
queueFamilyIndex = (uint32_t) selectedQueueFamilyIndex;
}
void VulkanBase::createDevice(VkDeviceQueueCreateInfo requestedQueues, uint32_t requestedQueuesCount) {
//Check extensions available on the selected physical device before creating it
// Check swap chain extension
vkUtils::checkDeviceExtensionPresent(physicalDevice,VK_KHR_SWAPCHAIN_EXTENSION_NAME);
std::vector<const char*> enabledExtensions = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
VkDeviceCreateInfo deviceCreateInfo = {
.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
.pNext = nullptr,
.flags = VK_FLAGS_NONE,
.queueCreateInfoCount = requestedQueuesCount,
.pQueueCreateInfos = &requestedQueues,
.enabledLayerCount = 0,
.ppEnabledLayerNames = nullptr,
.enabledExtensionCount = (uint32_t) enabledExtensions.size(),
.ppEnabledExtensionNames = enabledExtensions.data(),
.pEnabledFeatures = NULL
};
#ifdef _DEBUG
if (enableValidation) {
deviceCreateInfo.enabledLayerCount = vkDebug::validationLayerCount;
deviceCreateInfo.ppEnabledLayerNames = vkDebug::validationLayerNames;
// Check standard debug layers are present on the device
for(uint32_t i = 0; i < deviceCreateInfo.enabledLayerCount; i++) {
vkUtils::checkGlobalLayerPresent(vkDebug::validationLayerNames[i]);
}
}
#endif // _DEBUG
CHECK_RESULT(vkCreateDevice(physicalDevice, &deviceCreateInfo, nullptr, &device));
}
void VulkanBase::createCommandPool(const uint32_t queueFamilyIndex, const VkCommandPoolCreateFlagBits createFlagBits) {
const VkCommandPoolCreateInfo commandPoolCreateInfo= {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.pNext = NULL,
.flags = createFlagBits,
.queueFamilyIndex = queueFamilyIndex
};
CHECK_RESULT(vkCreateCommandPool(device, &commandPoolCreateInfo,nullptr,&commandPool));
#ifdef _DEBUG
std::cout << "\n+++ Created command pool" << std::endl;
#endif // _DEBUG
}
void VulkanBase::createSynchroItems()
{
// Semaphores
VkSemaphoreCreateInfo semaphoreCreateInfo = {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
.pNext = NULL,
.flags = VK_FLAGS_NONE
};
// Semaphore signaled on swapchain image ready to use and wait on the queue before rendering/present
CHECK_RESULT(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &imageAcquiredSemaphore));
// Semaphore signaled on queue rendering termination and waited on present operation
CHECK_RESULT(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &renderingCompletedSemaphore));
// Fences
VkFenceCreateInfo fenceCreateInfo = {
.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
.pNext = NULL,
.flags = VK_FLAGS_NONE
};
CHECK_RESULT(vkCreateFence(device, &fenceCreateInfo, nullptr, &presentFence));
#ifdef _DEBUG
std::cout << "\n+++ Created semaphores and fences\n";
#endif // _DEBUG
}
void VulkanBase::createCommandBuffers(VkCommandBuffer* cmdBuffer, uint32_t commandBufferCount, VkCommandBufferLevel cmdBufferLevel)
{
const VkCommandBufferAllocateInfo commandBufferAllocateInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
.pNext = NULL,
.commandPool = commandPool,
.level = cmdBufferLevel,
.commandBufferCount = commandBufferCount
};
CHECK_RESULT(vkAllocateCommandBuffers(device, &commandBufferAllocateInfo, cmdBuffer));
#ifdef _DEBUG
std::cout << "\n+++ Allocated " << commandBufferCount << " command buffers" << std::endl;
#endif // _DEBUG
}
void VulkanBase::setupInitCommandBuffer()
{
VkCommandBufferBeginInfo commandBufferBeginInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.pNext = NULL,
.flags = VK_FLAGS_NONE,
.pInheritanceInfo = NULL
};
CHECK_RESULT(vkBeginCommandBuffer(initCommandBuffer, &commandBufferBeginInfo));
// Creates an image memory barrier to change the layout for every image on the swapchain
VkImageMemoryBarrier imageMemoryBarrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.pNext = NULL,
.srcAccessMask = VK_FLAGS_NONE,
.dstAccessMask = VK_FLAGS_NONE,
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = 0,
.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}
};
// Pipeline Barrier for each swapchain image
for (const auto& image: swapchain.swapchainImagesVector){
imageMemoryBarrier.image = image;
vkCmdPipelineBarrier(initCommandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, //Put barrier on top of the pipeline
VK_FLAGS_NONE,
0, nullptr, // memoryBarrier
0, nullptr, // bufferMemoryBarrier
1, &imageMemoryBarrier); // imageMemoryBarrier
}
CHECK_RESULT(vkEndCommandBuffer(initCommandBuffer));
#ifdef _DEBUG
std::cout << "\n+++ Finished recording initCommandBuffer\n";
#endif // _DEBUG
}
void VulkanBase::setupPresentCommandBuffer(const VkImage currentSwapchainImage, const float* clearColors)
{
VkCommandBufferBeginInfo commandBufferBeginInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.pNext = NULL,
.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
.pInheritanceInfo = NULL
};
CHECK_RESULT(vkBeginCommandBuffer(presentCommandBuffer, &commandBufferBeginInfo));
VkImageMemoryBarrier imageMemoryBarrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.pNext = NULL,
.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT,
.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = currentSwapchainImage,
.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}
};
//Set barrier on top to change layout and access
vkCmdPipelineBarrier(presentCommandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);
VkClearColorValue clearColorValue;
VkImageSubresourceRange imageSubresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
clearColorValue.float32[0] = clearColors[0];
clearColorValue.float32[1] = clearColors[1];
clearColorValue.float32[2] = clearColors[2];
clearColorValue.float32[3] = 1.0f;
// Command to clear the swapchain image
vkCmdClearColorImage(presentCommandBuffer,currentSwapchainImage,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColorValue, 1, &imageSubresourceRange);
/*
* Transition the swapchain image from VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
* to VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
*/
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
imageMemoryBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
imageMemoryBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
// Set barrier end of pipeline
vkCmdPipelineBarrier(presentCommandBuffer,
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier
);
CHECK_RESULT(vkEndCommandBuffer(presentCommandBuffer));
#ifdef _DEBUG
//std::cout << "\n+++ Finished recording presentCommandBuffer\n";
#endif // _DEBUG
}
void VulkanBase::renderFrame(const float* clearColors)
{
// Wait on previous frame fence (render too fast)
//CHECK_RESULT(vkWaitForFences(device, 1, &presentFence, VK_TRUE, UINT64_MAX));
//CHECK_RESULT(vkResetFences(device, 1, &presentFence));
// Acquire next image on the swapchain
uint32_t imageIndex = UINT64_MAX;
CHECK_RESULT(vkAcquireNextImageKHR(device, swapchain.swapchain, UINT64_MAX, imageAcquiredSemaphore, VK_NULL_HANDLE, &imageIndex));
// Setup the present command buffer
setupPresentCommandBuffer(swapchain.swapchainImagesVector.at(imageIndex),clearColors);
// Submit present command buffer to the queue
// Waits on imageAcquiredSemaphore so it doesnt start rendering until the image from the swapchain is ready and
// it also signals the renderingCompletedSemaphore used by the later present
VkPipelineStageFlags pipelineStageFlags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
VkSubmitInfo submitInfo = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pNext = NULL,
.waitSemaphoreCount = 1,
.pWaitSemaphores = &imageAcquiredSemaphore,
.pWaitDstStageMask = &pipelineStageFlags,
.commandBufferCount = 1,
.pCommandBuffers = &presentCommandBuffer,
.signalSemaphoreCount = 1,
.pSignalSemaphores = &renderingCompletedSemaphore
};
CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
// Present the rendered image
VkPresentInfoKHR presentInfo = {
.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
.pNext = NULL,
.waitSemaphoreCount = 1,
.pWaitSemaphores = &renderingCompletedSemaphore,
.swapchainCount = 1,
.pSwapchains = &swapchain.swapchain,
.pImageIndices = &imageIndex,
.pResults = nullptr
};
CHECK_RESULT(vkQueuePresentKHR(queue,&presentInfo));
CHECK_RESULT(vkQueueWaitIdle(queue)); //TODO Not sure this is the correct way...
}
void VulkanBase::prepare()
{
//Allocate command Buffers
createCommandBuffers(&initCommandBuffer, 1, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
createCommandBuffers(&presentCommandBuffer, 1, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
commandBuffersVector.push_back(initCommandBuffer);
commandBuffersVector.push_back(presentCommandBuffer);
//Initialize command Buffers
setupInitCommandBuffer();
// Submit initialization command buffer to the queue
VkSubmitInfo submitInfo = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pNext = nullptr,
.waitSemaphoreCount = 0,
.pWaitSemaphores = nullptr,
.pWaitDstStageMask = VK_FLAGS_NONE,
.commandBufferCount = 1,
.pCommandBuffers = &initCommandBuffer,
.signalSemaphoreCount = 0,
.pSignalSemaphores = nullptr
};
CHECK_RESULT(vkQueueSubmit(queue,1,&submitInfo, VK_NULL_HANDLE));
CHECK_RESULT(vkQueueWaitIdle(queue));
vkFreeCommandBuffers(device, commandPool, 1, &initCommandBuffer);
#ifdef _DEBUG
std::cout << "\n+++ initCommandBuffer work complete!\n";
std::cout << "\n******* Rendering Start ******\n";
#endif // _DEBUG
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Multiple Descriptor Sets";
process_command_line_args(info, argc, argv);
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
init_depth_buffer(info);
// Sample from a green texture to easily see that we've pulled correct texel
// value
const char *textureName = "green.ppm";
init_texture(info, textureName);
init_uniform_buffer(info);
init_renderpass(info, true);
init_shaders(info, vertShaderText, fragShaderText);
init_framebuffers(info, true);
init_vertex_buffer(info, g_vb_texture_Data, sizeof(g_vb_texture_Data), sizeof(g_vb_texture_Data[0]), true);
/* VULKAN_KEY_START */
// Set up two descriptor sets
static const unsigned descriptor_set_count = 2;
// Create first layout to contain uniform buffer data
VkDescriptorSetLayoutBinding uniform_binding[1] = {};
uniform_binding[0].binding = 0;
uniform_binding[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
uniform_binding[0].descriptorCount = 1;
uniform_binding[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
uniform_binding[0].pImmutableSamplers = NULL;
VkDescriptorSetLayoutCreateInfo uniform_layout_info[1] = {};
uniform_layout_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
uniform_layout_info[0].pNext = NULL;
uniform_layout_info[0].bindingCount = 1;
uniform_layout_info[0].pBindings = uniform_binding;
// Create second layout containing combined sampler/image data
VkDescriptorSetLayoutBinding sampler2D_binding[1] = {};
sampler2D_binding[0].binding = 0;
sampler2D_binding[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
sampler2D_binding[0].descriptorCount = 1;
sampler2D_binding[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
sampler2D_binding[0].pImmutableSamplers = NULL;
VkDescriptorSetLayoutCreateInfo sampler2D_layout_info[1] = {};
sampler2D_layout_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
sampler2D_layout_info[0].pNext = NULL;
sampler2D_layout_info[0].bindingCount = 1;
sampler2D_layout_info[0].pBindings = sampler2D_binding;
// Create multiple sets, using each createInfo
static const unsigned uniform_set_index = 0;
static const unsigned sampler_set_index = 1;
VkDescriptorSetLayout descriptor_layouts[descriptor_set_count] = {};
res = vkCreateDescriptorSetLayout(info.device, uniform_layout_info, NULL, &descriptor_layouts[uniform_set_index]);
assert(res == VK_SUCCESS);
res = vkCreateDescriptorSetLayout(info.device, sampler2D_layout_info, NULL, &descriptor_layouts[sampler_set_index]);
assert(res == VK_SUCCESS);
// Create pipeline layout with multiple descriptor sets
VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo[1] = {};
pipelineLayoutCreateInfo[0].sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipelineLayoutCreateInfo[0].pNext = NULL;
pipelineLayoutCreateInfo[0].pushConstantRangeCount = 0;
pipelineLayoutCreateInfo[0].pPushConstantRanges = NULL;
pipelineLayoutCreateInfo[0].setLayoutCount = descriptor_set_count;
pipelineLayoutCreateInfo[0].pSetLayouts = descriptor_layouts;
res = vkCreatePipelineLayout(info.device, pipelineLayoutCreateInfo, NULL, &info.pipeline_layout);
assert(res == VK_SUCCESS);
// Create a single pool to contain data for our two descriptor sets
VkDescriptorPoolSize type_count[2] = {};
type_count[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
type_count[0].descriptorCount = 1;
type_count[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
type_count[1].descriptorCount = 1;
VkDescriptorPoolCreateInfo pool_info[1] = {};
pool_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
pool_info[0].pNext = NULL;
pool_info[0].maxSets = descriptor_set_count;
pool_info[0].poolSizeCount = sizeof(type_count) / sizeof(VkDescriptorPoolSize);
pool_info[0].pPoolSizes = type_count;
VkDescriptorPool descriptor_pool[1] = {};
res = vkCreateDescriptorPool(info.device, pool_info, NULL, descriptor_pool);
assert(res == VK_SUCCESS);
VkDescriptorSetAllocateInfo alloc_info[1];
alloc_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
alloc_info[0].pNext = NULL;
alloc_info[0].descriptorPool = descriptor_pool[0];
alloc_info[0].descriptorSetCount = descriptor_set_count;
alloc_info[0].pSetLayouts = descriptor_layouts;
// Populate descriptor sets
VkDescriptorSet descriptor_sets[descriptor_set_count] = {};
res = vkAllocateDescriptorSets(info.device, alloc_info, descriptor_sets);
assert(res == VK_SUCCESS);
// Using empty brace initializer on the next line triggers a bug in older
// versions of gcc, so memset instead
VkWriteDescriptorSet descriptor_writes[2];
memset(descriptor_writes, 0, sizeof(descriptor_writes));
// Populate with info about our uniform buffer
descriptor_writes[0] = {};
descriptor_writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptor_writes[0].pNext = NULL;
descriptor_writes[0].dstSet = descriptor_sets[uniform_set_index];
descriptor_writes[0].descriptorCount = 1;
descriptor_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
descriptor_writes[0].pBufferInfo = &info.uniform_data.buffer_info; // populated by init_uniform_buffer()
descriptor_writes[0].dstArrayElement = 0;
descriptor_writes[0].dstBinding = 0;
// Populate with info about our sampled image
descriptor_writes[1] = {};
descriptor_writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptor_writes[1].pNext = NULL;
descriptor_writes[1].dstSet = descriptor_sets[sampler_set_index];
descriptor_writes[1].descriptorCount = 1;
descriptor_writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
descriptor_writes[1].pImageInfo = &info.texture_data.image_info; // populated by init_texture()
descriptor_writes[1].dstArrayElement = 0;
descriptor_writes[1].dstBinding = 0;
vkUpdateDescriptorSets(info.device, descriptor_set_count, descriptor_writes, 0, NULL);
/* VULKAN_KEY_END */
// Call remaining boilerplate utils
init_pipeline_cache(info);
init_pipeline(info, true);
// The remaining is identical to drawtexturedcube
VkClearValue clear_values[2];
clear_values[0].color.float32[0] = 0.2f;
clear_values[0].color.float32[1] = 0.2f;
clear_values[0].color.float32[2] = 0.2f;
clear_values[0].color.float32[3] = 0.2f;
clear_values[1].depthStencil.depth = 1.0f;
clear_values[1].depthStencil.stencil = 0;
VkSemaphore imageAcquiredSemaphore;
VkSemaphoreCreateInfo imageAcquiredSemaphoreCreateInfo;
imageAcquiredSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
imageAcquiredSemaphoreCreateInfo.pNext = NULL;
imageAcquiredSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &imageAcquiredSemaphoreCreateInfo, NULL, &imageAcquiredSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX, imageAcquiredSemaphore, VK_NULL_HANDLE,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
VkRenderPassBeginInfo rp_begin;
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.pNext = NULL;
rp_begin.renderPass = info.render_pass;
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderArea.offset.x = 0;
rp_begin.renderArea.offset.y = 0;
rp_begin.renderArea.extent.width = info.width;
rp_begin.renderArea.extent.height = info.height;
rp_begin.clearValueCount = 2;
rp_begin.pClearValues = clear_values;
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, descriptor_set_count,
descriptor_sets, 0, NULL);
const VkDeviceSize offsets[1] = {0};
vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);
init_viewports(info);
init_scissors(info);
vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);
vkCmdEndRenderPass(info.cmd);
res = vkEndCommandBuffer(info.cmd);
assert(res == VK_SUCCESS);
const VkCommandBuffer cmd_bufs[] = {info.cmd};
VkFenceCreateInfo fenceInfo;
VkFence drawFence;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);
VkPipelineStageFlags pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
VkSubmitInfo submit_info[1] = {};
submit_info[0].pNext = NULL;
submit_info[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info[0].waitSemaphoreCount = 1;
submit_info[0].pWaitSemaphores = &imageAcquiredSemaphore;
submit_info[0].pWaitDstStageMask = &pipe_stage_flags;
submit_info[0].commandBufferCount = 1;
submit_info[0].pCommandBuffers = cmd_bufs;
submit_info[0].signalSemaphoreCount = 0;
submit_info[0].pSignalSemaphores = NULL;
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.graphics_queue, 1, submit_info, drawFence);
assert(res == VK_SUCCESS);
/* Now present the image in the window */
VkPresentInfoKHR present;
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present.pNext = NULL;
present.swapchainCount = 1;
present.pSwapchains = &info.swap_chain;
present.pImageIndices = &info.current_buffer;
present.pWaitSemaphores = NULL;
present.waitSemaphoreCount = 0;
present.pResults = NULL;
/* Make sure command buffer is finished before presenting */
do {
res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
res = vkQueuePresentKHR(info.present_queue, &present);
assert(res == VK_SUCCESS);
wait_seconds(1);
if (info.save_images) write_ppm(info, "multiple_sets");
vkDestroySemaphore(info.device, imageAcquiredSemaphore, NULL);
vkDestroyFence(info.device, drawFence, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
destroy_textures(info);
// instead of destroy_descriptor_pool(info);
vkDestroyDescriptorPool(info.device, descriptor_pool[0], NULL);
destroy_vertex_buffer(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
// instead of destroy_descriptor_and_pipeline_layouts(info);
for (int i = 0; i < descriptor_set_count; i++) vkDestroyDescriptorSetLayout(info.device, descriptor_layouts[i], NULL);
vkDestroyPipelineLayout(info.device, info.pipeline_layout, NULL);
destroy_uniform_buffer(info);
destroy_depth_buffer(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
//==============================================================================
// 描画
//==============================================================================
void Render()
{
VkResult result;
VkCommandBuffer command = g_commandBuffers[g_currentBufferIndex];
//==================================================
// コマンド記録開始
//==================================================
VkCommandBufferInheritanceInfo commandBufferInheritanceInfo = {};
commandBufferInheritanceInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
commandBufferInheritanceInfo.pNext = nullptr;
commandBufferInheritanceInfo.renderPass = nullptr;
commandBufferInheritanceInfo.subpass = 0;
commandBufferInheritanceInfo.framebuffer = g_frameBuffers[g_currentBufferIndex];
commandBufferInheritanceInfo.occlusionQueryEnable = VK_FALSE;
commandBufferInheritanceInfo.queryFlags = 0;
commandBufferInheritanceInfo.pipelineStatistics = 0;
VkCommandBufferBeginInfo cmdBeginInfo = {};
cmdBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
cmdBeginInfo.pNext = nullptr;
cmdBeginInfo.flags = 0;
cmdBeginInfo.pInheritanceInfo = &commandBufferInheritanceInfo;
vkBeginCommandBuffer(command, &cmdBeginInfo);
//==================================================
// カラーバッファをクリア
//==================================================
static float count = 0;
count += 0.0001f;
count = fmodf(count, 1.0f);
VkClearColorValue clearColor;
clearColor.float32[0] = 0.0f; // R
clearColor.float32[1] = count; // G
clearColor.float32[2] = 1.0f; // B
clearColor.float32[3] = 1.0f;
VkImageSubresourceRange imageSubresourceRange;
imageSubresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageSubresourceRange.baseMipLevel = 0;
imageSubresourceRange.levelCount = 1;
imageSubresourceRange.baseArrayLayer = 0;
imageSubresourceRange.layerCount = 1;
vkCmdClearColorImage(
command,
g_backBuffersTextures[g_currentBufferIndex].image,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
&clearColor,
1,
&imageSubresourceRange);
//==================================================
// 深度バッファをクリア
//==================================================
VkClearDepthStencilValue clearDepthStencil;
clearDepthStencil.depth = 1.0f;
clearDepthStencil.stencil = 0;
imageSubresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
imageSubresourceRange.baseMipLevel = 0;
imageSubresourceRange.levelCount = 1;
imageSubresourceRange.baseArrayLayer = 0;
imageSubresourceRange.layerCount = 1;
vkCmdClearDepthStencilImage(
command,
g_depthBufferTexture.image,
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
&clearDepthStencil,
1,
&imageSubresourceRange);
//==================================================
// リソースバリアの設定
//==================================================
VkImageMemoryBarrier imageMemoryBarrier;
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
imageMemoryBarrier.pNext = nullptr;
imageMemoryBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
imageMemoryBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
imageMemoryBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageMemoryBarrier.subresourceRange.baseMipLevel = 0;
imageMemoryBarrier.subresourceRange.levelCount = 1;
imageMemoryBarrier.subresourceRange.baseArrayLayer = 0;
imageMemoryBarrier.subresourceRange.layerCount = 1;
imageMemoryBarrier.image = g_backBuffersTextures[g_currentBufferIndex].image;
vkCmdPipelineBarrier(
command,
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
0,
0,
nullptr,
0,
nullptr,
1,
&imageMemoryBarrier);
//==================================================
// コマンドの記録を終了
//==================================================
vkEndCommandBuffer(command);
//==================================================
// コマンドを実行し，表示する
//==================================================
VkPipelineStageFlags pipeStageFlags = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
VkSubmitInfo submitInfo = {};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.pNext = nullptr;
submitInfo.waitSemaphoreCount = 0;
submitInfo.pWaitSemaphores = nullptr;
submitInfo.pWaitDstStageMask = &pipeStageFlags;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &command;
submitInfo.signalSemaphoreCount = 0;
submitInfo.pSignalSemaphores = nullptr;
// コマンドを実行
result = vkQueueSubmit(g_VulkanQueue, 1, &submitInfo, g_VulkanFence);
checkVulkanError(result, TEXT("グラフィックスキューへのサブミット失敗"));
// 完了を待機
result = vkWaitForFences(g_VulkanDevice, 1, &g_VulkanFence, VK_TRUE, TIMEOUT_NANO_SEC);
// 成功したら表示
if(result == VK_SUCCESS)
{
VkPresentInfoKHR present = {};
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present.pNext = nullptr;
present.swapchainCount = 1;
present.pSwapchains = &g_VulkanSwapChain;
present.pImageIndices = &g_currentBufferIndex;
present.pWaitSemaphores = nullptr;
present.waitSemaphoreCount = 0;
present.pResults = nullptr;
result = vkQueuePresentKHR(g_VulkanQueue, &present);
checkVulkanError(result, TEXT("プレゼント失敗"));
}
else if(result == VK_TIMEOUT)
{
checkVulkanError(VK_TIMEOUT, TEXT("タイムアウトしました"));
}
// フェンスをリセット
result = vkResetFences(g_VulkanDevice, 1, &g_VulkanFence);
checkVulkanError(result, TEXT("フェンスのリセット失敗"));
// 次のイメージを取得
result = vkAcquireNextImageKHR(
g_VulkanDevice,
g_VulkanSwapChain,
TIMEOUT_NANO_SEC,
g_VulkanSemahoreRenderComplete,
nullptr,
&g_currentBufferIndex);
checkVulkanError(result, TEXT("次の有効なイメージインデックスの獲得に失敗"));
}
int sample_main() {
VkResult U_ASSERT_ONLY res;
char sample_title[] = "MT Cmd Buffer Sample";
const bool depthPresent = false;
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo;
presentCompleteSemaphoreCreateInfo.sType =
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
presentCompleteSemaphoreCreateInfo.pNext = NULL;
presentCompleteSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &presentCompleteSemaphoreCreateInfo,
NULL, &info.presentCompleteSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX,
info.presentCompleteSemaphore, NULL,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {};
pPipelineLayoutCreateInfo.sType =
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pPipelineLayoutCreateInfo.pNext = NULL;
pPipelineLayoutCreateInfo.pushConstantRangeCount = 0;
pPipelineLayoutCreateInfo.pPushConstantRanges = NULL;
pPipelineLayoutCreateInfo.setLayoutCount = 0;
pPipelineLayoutCreateInfo.pSetLayouts = NULL;
res = vkCreatePipelineLayout(info.device, &pPipelineLayoutCreateInfo, NULL,
&info.pipeline_layout);
assert(res == VK_SUCCESS);
init_renderpass(
info, depthPresent,
false); // Can't clear in renderpass load because we re-use pipeline
init_shaders(info, vertShaderText, fragShaderText);
init_framebuffers(info, depthPresent);
/* The binding and attributes should be the same for all 3 vertex buffers,
* so init here */
info.vi_binding.binding = 0;
info.vi_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
info.vi_binding.stride = sizeof(triData[0]);
info.vi_attribs[0].binding = 0;
info.vi_attribs[0].location = 0;
info.vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT;
info.vi_attribs[0].offset = 0;
info.vi_attribs[1].binding = 0;
info.vi_attribs[1].location = 1;
info.vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
info.vi_attribs[1].offset = 16;
init_pipeline_cache(info);
init_pipeline(info, depthPresent);
VkImageSubresourceRange srRange = {};
srRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
srRange.baseMipLevel = 0;
srRange.levelCount = VK_REMAINING_MIP_LEVELS;
srRange.baseArrayLayer = 0;
srRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
VkClearColorValue clear_color[1];
clear_color[0].float32[0] = 0.2f;
clear_color[0].float32[1] = 0.2f;
clear_color[0].float32[2] = 0.2f;
clear_color[0].float32[3] = 0.2f;
/* We need to do the clear here instead of as a load op since all 3 threads
* share the same pipeline / renderpass */
set_image_layout(info, info.buffers[info.current_buffer].image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
vkCmdClearColorImage(info.cmd, info.buffers[info.current_buffer].image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, clear_color, 1,
&srRange);
set_image_layout(info, info.buffers[info.current_buffer].image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
res = vkEndCommandBuffer(info.cmd);
const VkCommandBuffer cmd_bufs[] = {info.cmd};
VkFence clearFence;
init_fence(info, clearFence);
VkPipelineStageFlags pipe_stage_flags =
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
VkSubmitInfo submit_info[1] = {};
submit_info[0].pNext = NULL;
submit_info[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info[0].waitSemaphoreCount = 1;
submit_info[0].pWaitSemaphores = &info.presentCompleteSemaphore;
submit_info[0].pWaitDstStageMask = NULL;
submit_info[0].commandBufferCount = 1;
submit_info[0].pCommandBuffers = cmd_bufs;
submit_info[0].signalSemaphoreCount = 0;
submit_info[0].pSignalSemaphores = NULL;
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, submit_info, clearFence);
assert(!res);
do {
res = vkWaitForFences(info.device, 1, &clearFence, VK_TRUE,
FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
vkDestroyFence(info.device, clearFence, NULL);
/* VULKAN_KEY_START */
/* Use the fourth slot in the command buffer array for the presentation */
/* barrier using the command buffer in info */
threadCmdBufs[3] = info.cmd;
sample_platform_thread vk_threads[3];
for (size_t i = 0; i < 3; i++) {
sample_platform_thread_create(&vk_threads[i], &per_thread_code,
(void *)i);
}
VkCommandBufferBeginInfo cmd_buf_info = {};
cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
cmd_buf_info.pNext = NULL;
cmd_buf_info.flags = 0;
cmd_buf_info.pInheritanceInfo = NULL;
res = vkBeginCommandBuffer(threadCmdBufs[3], &cmd_buf_info);
assert(res == VK_SUCCESS);
VkImageMemoryBarrier prePresentBarrier = {};
prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
prePresentBarrier.pNext = NULL;
prePresentBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
prePresentBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
prePresentBarrier.subresourceRange.baseMipLevel = 0;
prePresentBarrier.subresourceRange.levelCount = 1;
prePresentBarrier.subresourceRange.baseArrayLayer = 0;
prePresentBarrier.subresourceRange.layerCount = 1;
prePresentBarrier.image = info.buffers[info.current_buffer].image;
vkCmdPipelineBarrier(threadCmdBufs[3], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0,
NULL, 1, &prePresentBarrier);
res = vkEndCommandBuffer(threadCmdBufs[3]);
assert(res == VK_SUCCESS);
pipe_stage_flags = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
submit_info[0].pNext = NULL;
submit_info[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info[0].waitSemaphoreCount = 0;
submit_info[0].pWaitSemaphores = NULL;
submit_info[0].pWaitDstStageMask = &pipe_stage_flags;
submit_info[0].commandBufferCount =
4; /* 3 from threads + prePresentBarrier */
submit_info[0].pCommandBuffers = threadCmdBufs;
submit_info[0].signalSemaphoreCount = 0;
submit_info[0].pSignalSemaphores = NULL;
/* Wait for all of the threads to finish */
for (int i = 0; i < 3; i++) {
sample_platform_thread_join(vk_threads[i], NULL);
}
VkFenceCreateInfo fenceInfo;
VkFence drawFence;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, submit_info, drawFence);
assert(!res);
/* Make sure command buffer is finished before presenting */
do {
res =
vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
execute_present_image(info);
wait_seconds(1);
/* VULKAN_KEY_END */
vkDestroyBuffer(info.device, vertex_buffer[0].buf, NULL);
vkDestroyBuffer(info.device, vertex_buffer[1].buf, NULL);
vkDestroyBuffer(info.device, vertex_buffer[2].buf, NULL);
vkFreeMemory(info.device, vertex_buffer[0].mem, NULL);
vkFreeMemory(info.device, vertex_buffer[1].mem, NULL);
vkFreeMemory(info.device, vertex_buffer[2].mem, NULL);
for (int i = 0; i < 3; i++) {
vkFreeCommandBuffers(info.device, threadCmdPools[i], 1,
&threadCmdBufs[i]);
vkDestroyCommandPool(info.device, threadCmdPools[i], NULL);
}
vkDestroySemaphore(info.device, info.presentCompleteSemaphore, NULL);
vkDestroyFence(info.device, drawFence, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
vkDestroyPipelineLayout(info.device, info.pipeline_layout, NULL);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_window(info);
destroy_device(info);
destroy_instance(info);
return 0;
}
int sample_main(int argc, char **argv) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Memory Barriers";
process_command_line_args(info, argc, argv);
init_global_layer_properties(info);
info.instance_extension_names.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
#ifdef _WIN32
info.instance_extension_names.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
#elif __ANDROID__
info.instance_extension_names.push_back(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);
#else
info.instance_extension_names.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
#endif
info.device_extension_names.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
init_instance(info, sample_title);
init_enumerate_device(info);
init_device(info);
info.width = info.height = 500;
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
// CmdClearColorImage is going to require usage of TRANSFER_DST, but
// it's not clear which format feature maps to the required TRANSFER_DST usage,
// BLIT_DST is a reasonable guess and it seems to work
init_texture(info, nullptr, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_FORMAT_FEATURE_BLIT_DST_BIT);
init_uniform_buffer(info);
init_descriptor_and_pipeline_layouts(info, true);
init_renderpass(info, DEPTH_PRESENT, false, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
init_shaders(info, vertShaderText, fragShaderText);
init_framebuffers(info, DEPTH_PRESENT);
init_vertex_buffer(info, vb_Data, sizeof(vb_Data), sizeof(vb_Data[0]), true);
init_descriptor_pool(info, true);
init_descriptor_set(info, true);
init_pipeline_cache(info);
init_pipeline(info, DEPTH_PRESENT);
/* VULKAN_KEY_START */
VkImageSubresourceRange srRange = {};
srRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
srRange.baseMipLevel = 0;
srRange.levelCount = VK_REMAINING_MIP_LEVELS;
srRange.baseArrayLayer = 0;
srRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
VkClearColorValue clear_color[1];
clear_color[0].float32[0] = 0.2f;
clear_color[0].float32[1] = 0.2f;
clear_color[0].float32[2] = 0.2f;
clear_color[0].float32[3] = 0.2f;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo;
presentCompleteSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
presentCompleteSemaphoreCreateInfo.pNext = NULL;
presentCompleteSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &presentCompleteSemaphoreCreateInfo, NULL, &info.imageAcquiredSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX, info.imageAcquiredSemaphore, VK_NULL_HANDLE,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
set_image_layout(info, info.buffers[info.current_buffer].image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
// We need to do the clear here instead of using a renderpass load op since
// we will use the same renderpass multiple times in the frame
vkCmdClearColorImage(info.cmd, info.buffers[info.current_buffer].image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, clear_color, 1,
&srRange);
VkRenderPassBeginInfo rp_begin;
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.pNext = NULL;
rp_begin.renderPass = info.render_pass;
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderArea.offset.x = 0;
rp_begin.renderArea.offset.y = 0;
rp_begin.renderArea.extent.width = info.width;
rp_begin.renderArea.extent.height = info.height;
rp_begin.clearValueCount = 0;
rp_begin.pClearValues = NULL;
// Draw a textured quad on the left side of the window
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 0, NULL);
const VkDeviceSize offsets[1] = {0};
vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);
init_viewports(info);
init_scissors(info);
vkCmdDraw(info.cmd, 2 * 3, 1, 0, 0);
// We can't do a clear inside a renderpass, so end this one and start another one
// for the next draw
vkCmdEndRenderPass(info.cmd);
// Send a barrier to change the texture image's layout from SHADER_READ_ONLY
// to COLOR_ATTACHMENT_GENERAL because we're going to clear it
VkImageMemoryBarrier textureBarrier = {};
textureBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
textureBarrier.pNext = NULL;
textureBarrier.srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
textureBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
textureBarrier.oldLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
textureBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
textureBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
textureBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
textureBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
textureBarrier.subresourceRange.baseMipLevel = 0;
textureBarrier.subresourceRange.levelCount = 1;
textureBarrier.subresourceRange.baseArrayLayer = 0;
textureBarrier.subresourceRange.layerCount = 1;
textureBarrier.image = info.textures[0].image;
vkCmdPipelineBarrier(info.cmd, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 1,
&textureBarrier);
clear_color[0].float32[0] = 0.0f;
clear_color[0].float32[1] = 1.0f;
clear_color[0].float32[2] = 0.0f;
clear_color[0].float32[3] = 1.0f;
/* Clear texture to green */
vkCmdClearColorImage(info.cmd, info.textures[0].image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, clear_color, 1, &srRange);
// Send a barrier to change the texture image's layout back to SHADER_READ_ONLY
// because we're going to use it as a texture again
textureBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
textureBarrier.pNext = NULL;
textureBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
textureBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
textureBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
textureBarrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
textureBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
textureBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
textureBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
textureBarrier.subresourceRange.baseMipLevel = 0;
textureBarrier.subresourceRange.levelCount = 1;
textureBarrier.subresourceRange.baseArrayLayer = 0;
textureBarrier.subresourceRange.layerCount = 1;
textureBarrier.image = info.textures[0].image;
vkCmdPipelineBarrier(info.cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, NULL, 0, NULL, 1,
&textureBarrier);
// Draw the second quad to the right using the (now) green texture
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
// Draw starting with vertex index 6 to draw to the right of the first quad
vkCmdDraw(info.cmd, 2 * 3, 1, 6, 0);
vkCmdEndRenderPass(info.cmd);
// Change the present buffer from COLOR_ATTACHMENT_OPTIMAL to
// PRESENT_SOURCE_KHR
// so it can be presented
execute_pre_present_barrier(info);
res = vkEndCommandBuffer(info.cmd);
assert(res == VK_SUCCESS);
VkSubmitInfo submit_info = {};
VkPipelineStageFlags pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
init_submit_info(info, submit_info, pipe_stage_flags);
assert(res == VK_SUCCESS);
VkFence drawFence = {};
init_fence(info, drawFence);
// Queue the command buffer for execution
res = vkQueueSubmit(info.graphics_queue, 1, &submit_info, drawFence);
assert(res == VK_SUCCESS);
// Now present the image in the window
VkPresentInfoKHR present{};
init_present_info(info, present);
// Make sure command buffer is finished before presenting
do {
res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
res = vkQueuePresentKHR(info.present_queue, &present);
assert(res == VK_SUCCESS);
/* VULKAN_KEY_END */
wait_seconds(1);
if (info.save_images) write_ppm(info, "memory_barriers");
vkDestroySemaphore(info.device, info.imageAcquiredSemaphore, NULL);
vkDestroyFence(info.device, drawFence, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
destroy_textures(info);
destroy_descriptor_pool(info);
destroy_vertex_buffer(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
destroy_descriptor_and_pipeline_layouts(info);
destroy_uniform_buffer(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_window(info);
destroy_device(info);
destroy_instance(info);
return 0;
}
/**
* Sample using multiple render passes per framebuffer (different x,y extents)
* and multiple subpasses per renderpass.
*/
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Multi-pass render passes";
const bool depthPresent = true;
process_command_line_args(info, argc, argv);
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
info.depth.format = VK_FORMAT_D32_SFLOAT_S8_UINT;
init_depth_buffer(info);
init_uniform_buffer(info);
init_descriptor_and_pipeline_layouts(info, false);
init_vertex_buffer(info, g_vb_solid_face_colors_Data,
sizeof(g_vb_solid_face_colors_Data),
sizeof(g_vb_solid_face_colors_Data[0]), false);
init_descriptor_pool(info, false);
init_descriptor_set(info, false);
init_pipeline_cache(info);
/* VULKAN_KEY_START */
/**
* First renderpass in this sample.
* Stenciled rendering: subpass 1 draw to stencil buffer, subpass 2 draw to
* color buffer with stencil test
*/
VkAttachmentDescription attachments[2];
attachments[0].format = info.format;
attachments[0].samples = VK_SAMPLE_COUNT_1_BIT;
attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachments[0].initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
attachments[0].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
attachments[0].flags = 0;
attachments[1].format = info.depth.format;
attachments[1].samples = VK_SAMPLE_COUNT_1_BIT;
attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
attachments[1].initialLayout =
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
attachments[1].finalLayout =
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
attachments[1].flags = 0;
VkAttachmentReference color_reference = {};
color_reference.attachment = 0;
color_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkAttachmentReference depth_reference = {};
depth_reference.attachment = 1;
depth_reference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass = {};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.flags = 0;
subpass.inputAttachmentCount = 0;
subpass.pInputAttachments = NULL;
subpass.colorAttachmentCount = 0;
subpass.pColorAttachments = NULL;
subpass.pResolveAttachments = NULL;
subpass.pDepthStencilAttachment = &depth_reference;
subpass.preserveAttachmentCount = 0;
subpass.pPreserveAttachments = NULL;
std::vector<VkSubpassDescription> subpasses;
/* first a depthstencil-only subpass */
subpasses.push_back(subpass);
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &color_reference;
/* then depthstencil and color */
subpasses.push_back(subpass);
/* Set up a dependency between the source and destination subpasses */
VkSubpassDependency dependency = {};
dependency.srcSubpass = 0;
dependency.dstSubpass = 1;
dependency.dependencyFlags = 0;
dependency.srcStageMask = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
dependency.dstStageMask = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
dependency.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
dependency.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
VkRenderPassCreateInfo rp_info = {};
rp_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
rp_info.pNext = NULL;
rp_info.attachmentCount = 2;
rp_info.pAttachments = attachments;
rp_info.subpassCount = subpasses.size();
rp_info.pSubpasses = subpasses.data();
rp_info.dependencyCount = 1;
rp_info.pDependencies = &dependency;
VkRenderPass stencil_render_pass;
res = vkCreateRenderPass(info.device, &rp_info, NULL, &stencil_render_pass);
assert(!res);
/* now that we have the render pass, create framebuffer and pipelines */
info.render_pass = stencil_render_pass;
init_framebuffers(info, depthPresent);
VkDynamicState dynamicStateEnables[VK_DYNAMIC_STATE_RANGE_SIZE];
VkPipelineDynamicStateCreateInfo dynamicState = {};
memset(dynamicStateEnables, 0, sizeof dynamicStateEnables);
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
dynamicState.pNext = NULL;
dynamicState.pDynamicStates = dynamicStateEnables;
dynamicState.dynamicStateCount = 0;
VkPipelineVertexInputStateCreateInfo vi;
vi.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vi.pNext = NULL;
vi.vertexBindingDescriptionCount = 1;
vi.pVertexBindingDescriptions = &info.vi_binding;
vi.vertexAttributeDescriptionCount = 2;
vi.pVertexAttributeDescriptions = info.vi_attribs;
VkPipelineInputAssemblyStateCreateInfo ia;
ia.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
ia.pNext = NULL;
ia.primitiveRestartEnable = VK_FALSE;
ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
VkPipelineRasterizationStateCreateInfo rs;
rs.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
rs.pNext = NULL;
rs.polygonMode = VK_POLYGON_MODE_FILL;
rs.cullMode = VK_CULL_MODE_BACK_BIT;
rs.frontFace = VK_FRONT_FACE_CLOCKWISE;
rs.depthClampEnable = VK_FALSE;
rs.rasterizerDiscardEnable = VK_FALSE;
rs.depthBiasEnable = VK_FALSE;
rs.depthBiasConstantFactor = 0;
rs.depthBiasClamp = 0;
rs.depthBiasSlopeFactor = 0;
rs.lineWidth = 0;
VkPipelineColorBlendStateCreateInfo cb;
cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
cb.pNext = NULL;
VkPipelineColorBlendAttachmentState att_state[1];
att_state[0].colorWriteMask = 0xf;
att_state[0].blendEnable = VK_FALSE;
att_state[0].alphaBlendOp = VK_BLEND_OP_ADD;
att_state[0].colorBlendOp = VK_BLEND_OP_ADD;
att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_ZERO;
att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_ZERO;
att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
att_state[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
cb.attachmentCount = 1;
cb.pAttachments = att_state;
cb.logicOpEnable = VK_FALSE;
cb.logicOp = VK_LOGIC_OP_NO_OP;
cb.blendConstants[0] = 1.0f;
cb.blendConstants[1] = 1.0f;
cb.blendConstants[2] = 1.0f;
cb.blendConstants[3] = 1.0f;
VkPipelineViewportStateCreateInfo vp = {};
vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
vp.pNext = NULL;
vp.viewportCount = NUM_VIEWPORTS;
dynamicStateEnables[dynamicState.dynamicStateCount++] =
VK_DYNAMIC_STATE_VIEWPORT;
vp.scissorCount = NUM_SCISSORS;
dynamicStateEnables[dynamicState.dynamicStateCount++] =
VK_DYNAMIC_STATE_SCISSOR;
VkPipelineDepthStencilStateCreateInfo ds;
ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
ds.pNext = NULL;
ds.depthTestEnable = VK_TRUE;
ds.depthWriteEnable = VK_TRUE;
ds.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
ds.depthBoundsTestEnable = VK_FALSE;
ds.minDepthBounds = 0;
ds.maxDepthBounds = 0;
ds.stencilTestEnable = VK_TRUE;
ds.back.failOp = VK_STENCIL_OP_REPLACE;
ds.back.depthFailOp = VK_STENCIL_OP_REPLACE;
ds.back.passOp = VK_STENCIL_OP_REPLACE;
ds.back.compareOp = VK_COMPARE_OP_ALWAYS;
ds.back.compareMask = 0xff;
ds.back.writeMask = 0xff;
ds.back.reference = 0x44;
ds.front = ds.back;
VkPipelineMultisampleStateCreateInfo ms;
ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
ms.pNext = NULL;
ms.pSampleMask = NULL;
ms.rasterizationSamples = NUM_SAMPLES;
ms.sampleShadingEnable = VK_FALSE;
ms.minSampleShading = 0.0;
ms.alphaToCoverageEnable = VK_FALSE;
ms.alphaToOneEnable = VK_FALSE;
VkGraphicsPipelineCreateInfo pipeline;
pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
pipeline.pNext = NULL;
pipeline.layout = info.pipeline_layout;
pipeline.basePipelineHandle = VK_NULL_HANDLE;
pipeline.basePipelineIndex = 0;
pipeline.flags = 0;
pipeline.pVertexInputState = &vi;
pipeline.pInputAssemblyState = &ia;
pipeline.pRasterizationState = &rs;
pipeline.pColorBlendState = NULL;
pipeline.pTessellationState = NULL;
pipeline.pMultisampleState = &ms;
pipeline.pDynamicState = &dynamicState;
pipeline.pViewportState = &vp;
pipeline.pDepthStencilState = &ds;
pipeline.pStages = info.shaderStages;
pipeline.stageCount = 2;
pipeline.renderPass = stencil_render_pass;
pipeline.subpass = 0;
init_shaders(info, normalVertShaderText, fragShaderText);
/* The first pipeline will render in subpass 0 to fill the stencil */
pipeline.subpass = 0;
VkPipeline stencil_cube_pipe = VK_NULL_HANDLE;
res = vkCreateGraphicsPipelines(info.device, info.pipelineCache, 1,
&pipeline, NULL, &stencil_cube_pipe);
assert(res == VK_SUCCESS);
/* destroy the shaders used for the above pipelin eand replace them with
those for the
fullscreen fill pass */
destroy_shaders(info);
init_shaders(info, fullscreenVertShaderText, fragShaderText);
/* the second pipeline will stencil test but not write, using the same
* reference */
ds.back.failOp = VK_STENCIL_OP_KEEP;
ds.back.depthFailOp = VK_STENCIL_OP_KEEP;
ds.back.passOp = VK_STENCIL_OP_KEEP;
ds.back.compareOp = VK_COMPARE_OP_EQUAL;
ds.front = ds.back;
/* don't test depth, only use stencil test */
ds.depthTestEnable = VK_FALSE;
/* the second pipeline will be a fullscreen triangle strip, with vertices
generated purely from the vertex shader - no inputs needed */
ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
vi.vertexAttributeDescriptionCount = 0;
vi.vertexBindingDescriptionCount = 0;
/* this pipeline will run in the second subpass */
pipeline.subpass = 1;
pipeline.pColorBlendState = &cb;
VkPipeline stencil_fullscreen_pipe = VK_NULL_HANDLE;
res = vkCreateGraphicsPipelines(info.device, info.pipelineCache, 1,
&pipeline, NULL, &stencil_fullscreen_pipe);
assert(res == VK_SUCCESS);
destroy_shaders(info);
info.pipeline = VK_NULL_HANDLE;
VkClearValue clear_values[2];
clear_values[0].color.float32[0] = 0.2f;
clear_values[0].color.float32[1] = 0.2f;
clear_values[0].color.float32[2] = 0.2f;
clear_values[0].color.float32[3] = 0.2f;
clear_values[1].depthStencil.depth = 1.0f;
clear_values[1].depthStencil.stencil = 0;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo;
presentCompleteSemaphoreCreateInfo.sType =
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
presentCompleteSemaphoreCreateInfo.pNext = NULL;
presentCompleteSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &presentCompleteSemaphoreCreateInfo,
NULL, &presentCompleteSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX,
presentCompleteSemaphore, NULL,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
VkRenderPassBeginInfo rp_begin;
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.pNext = NULL;
rp_begin.renderPass = stencil_render_pass;
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderArea.offset.x = 0;
rp_begin.renderArea.offset.y = 0;
rp_begin.renderArea.extent.width = info.width / 2;
rp_begin.renderArea.extent.height = info.height;
rp_begin.clearValueCount = 2;
rp_begin.pClearValues = clear_values;
/* Begin the first render pass. This will render in the left half of the
screen. Subpass 0 will render a cube, stencil writing but outputting
no color. Subpass 1 will render a fullscreen pass, stencil testing and
outputting color only where the cube filled in stencil */
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
stencil_cube_pipe);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 0, NULL);
const VkDeviceSize offsets[1] = {0};
vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);
VkViewport viewport;
viewport.height = (float)info.height;
viewport.width = (float)info.width / 2;
viewport.minDepth = (float)0.0f;
viewport.maxDepth = (float)1.0f;
viewport.x = 0;
viewport.y = 0;
vkCmdSetViewport(info.cmd, 0, NUM_VIEWPORTS, &viewport);
VkRect2D scissor;
scissor.extent.width = info.width / 2;
scissor.extent.height = info.height;
scissor.offset.x = 0;
scissor.offset.y = 0;
vkCmdSetScissor(info.cmd, 0, NUM_SCISSORS, &scissor);
/* Draw the cube into stencil */
vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);
/* Advance to the next subpass */
vkCmdNextSubpass(info.cmd, VK_SUBPASS_CONTENTS_INLINE);
/* Bind the fullscreen pass pipeline */
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
stencil_fullscreen_pipe);
vkCmdSetViewport(info.cmd, 0, NUM_VIEWPORTS, &viewport);
vkCmdSetScissor(info.cmd, 0, NUM_SCISSORS, &scissor);
/* Draw the fullscreen pass */
vkCmdDraw(info.cmd, 4, 1, 0, 0);
vkCmdEndRenderPass(info.cmd);
/**
* Second renderpass in this sample.
* Blended rendering, each subpass blends continuously onto the color
*/
/* note that we reuse a lot of the initialisation strutures from the first
render pass, so this represents a 'delta' from that configuration */
/* This time, the first subpass will use color */
subpasses[0].colorAttachmentCount = 1;
subpasses[0].pColorAttachments = &color_reference;
/* The dependency between the subpasses now includes the color attachment */
dependency.srcAccessMask |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
dependency.dstAccessMask |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
/* Otherwise, the render pass is identical */
VkRenderPass blend_render_pass;
res = vkCreateRenderPass(info.device, &rp_info, NULL, &blend_render_pass);
assert(!res);
pipeline.renderPass = blend_render_pass;
/* We must recreate the framebuffers with this renderpass as the two render
passes are not compatible. Store the current framebuffers for later
deletion */
VkFramebuffer *stencil_framebuffers = info.framebuffers;
info.framebuffers = NULL;
info.render_pass = blend_render_pass;
init_framebuffers(info, depthPresent);
/* Now create the pipelines for the second render pass */
/* We are rendering the cube again, configure the vertex inputs */
ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
vi.vertexAttributeDescriptionCount = 2;
vi.vertexBindingDescriptionCount = 1;
/* The first pipeline will depth write and depth test */
ds.depthWriteEnable = VK_TRUE;
ds.depthTestEnable = VK_TRUE;
/* We don't want to stencil test */
ds.stencilTestEnable = VK_FALSE;
/* This time, both pipelines will blend. the first pipeline uses the blend
constant
to determine the blend amount */
att_state[0].colorWriteMask = 0xf;
att_state[0].blendEnable = VK_TRUE;
att_state[0].alphaBlendOp = VK_BLEND_OP_ADD;
att_state[0].colorBlendOp = VK_BLEND_OP_ADD;
att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_CONSTANT_ALPHA;
att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE;
att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_CONSTANT_ALPHA;
att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
cb.blendConstants[0] = 1.0f;
cb.blendConstants[1] = 1.0f;
cb.blendConstants[2] = 1.0f;
cb.blendConstants[3] = 0.3f;
init_shaders(info, normalVertShaderText, fragShaderText);
/* This is the first subpass's pipeline, to blend a cube onto the color
* image */
pipeline.subpass = 0;
VkPipeline blend_cube_pipe = VK_NULL_HANDLE;
res = vkCreateGraphicsPipelines(info.device, info.pipelineCache, 1,
&pipeline, NULL, &blend_cube_pipe);
assert(res == VK_SUCCESS);
/* Now we will set up the fullscreen pass to render on top. */
destroy_shaders(info);
init_shaders(info, fullscreenVertShaderText, fragShaderText);
/* the second pipeline will be a fullscreen triangle strip with no inputs */
ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
vi.vertexAttributeDescriptionCount = 0;
vi.vertexBindingDescriptionCount = 0;
/* We'll use the alpha output from the shader */
att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE;
att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
att_state[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
/* This renders in the second subpass */
pipeline.subpass = 1;
VkPipeline blend_fullscreen_pipe = VK_NULL_HANDLE;
res = vkCreateGraphicsPipelines(info.device, info.pipelineCache, 1,
&pipeline, NULL, &blend_fullscreen_pipe);
assert(res == VK_SUCCESS);
destroy_shaders(info);
info.pipeline = VK_NULL_HANDLE;
/* Now we are going to render in the right half of the screen */
viewport.x = (float)info.width / 2;
scissor.offset.x = info.width / 2;
rp_begin.renderArea.offset.x = info.width / 2;
/* Use our framebuffer and render pass */
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderPass = blend_render_pass;
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
blend_cube_pipe);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 0, NULL);
vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);
vkCmdSetViewport(info.cmd, 0, NUM_VIEWPORTS, &viewport);
vkCmdSetScissor(info.cmd, 0, NUM_SCISSORS, &scissor);
/* Draw the cube blending */
vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);
/* Advance to the next subpass */
vkCmdNextSubpass(info.cmd, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
blend_fullscreen_pipe);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 0, NULL);
/* Adjust the viewport to be a square in the centre, just overlapping the
* cube */
viewport.x += 25.0f;
viewport.y += 150.0f;
viewport.width -= 50.0f;
viewport.height -= 300.0f;
vkCmdSetViewport(info.cmd, 0, NUM_VIEWPORTS, &viewport);
vkCmdSetScissor(info.cmd, 0, NUM_SCISSORS, &scissor);
vkCmdDraw(info.cmd, 4, 1, 0, 0);
/* The second renderpass is complete */
vkCmdEndRenderPass(info.cmd);
/* VULKAN_KEY_END */
VkImageMemoryBarrier prePresentBarrier = {};
prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
prePresentBarrier.pNext = NULL;
prePresentBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
prePresentBarrier.dstAccessMask = 0;
prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
prePresentBarrier.subresourceRange.baseMipLevel = 0;
prePresentBarrier.subresourceRange.levelCount = 1;
prePresentBarrier.subresourceRange.baseArrayLayer = 0;
prePresentBarrier.subresourceRange.layerCount = 1;
prePresentBarrier.image = info.buffers[info.current_buffer].image;
vkCmdPipelineBarrier(info.cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, NULL, 0, NULL,
1, &prePresentBarrier);
res = vkEndCommandBuffer(info.cmd);
const VkCommandBuffer cmd_bufs[] = {info.cmd};
VkFenceCreateInfo fenceInfo;
VkFence drawFence;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);
VkPipelineStageFlags pipe_stage_flags =
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
VkSubmitInfo submit_info[1] = {};
submit_info[0].pNext = NULL;
submit_info[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info[0].waitSemaphoreCount = 1;
submit_info[0].pWaitSemaphores = &presentCompleteSemaphore;
submit_info[0].commandBufferCount = 1;
submit_info[0].pCommandBuffers = cmd_bufs;
submit_info[0].pWaitDstStageMask = &pipe_stage_flags;
submit_info[0].signalSemaphoreCount = 0;
submit_info[0].pSignalSemaphores = NULL;
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, submit_info, drawFence);
assert(res == VK_SUCCESS);
/* Now present the image in the window */
VkPresentInfoKHR present;
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present.pNext = NULL;
present.swapchainCount = 1;
present.pSwapchains = &info.swap_chain;
present.pImageIndices = &info.current_buffer;
present.pWaitSemaphores = NULL;
present.waitSemaphoreCount = 0;
present.pResults = NULL;
/* Make sure command buffer is finished before presenting */
do {
res =
vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
res = vkQueuePresentKHR(info.queue, &present);
assert(res == VK_SUCCESS);
wait_seconds(1);
/* VULKAN_KEY_END */
if (info.save_images)
write_ppm(info, "drawsubpasses");
for (uint32_t i = 0; i < info.swapchainImageCount; i++)
vkDestroyFramebuffer(info.device, stencil_framebuffers[i], NULL);
free(stencil_framebuffers);
vkDestroyRenderPass(info.device, stencil_render_pass, NULL);
vkDestroyRenderPass(info.device, blend_render_pass, NULL);
vkDestroyPipeline(info.device, blend_cube_pipe, NULL);
vkDestroyPipeline(info.device, blend_fullscreen_pipe, NULL);
vkDestroyPipeline(info.device, stencil_cube_pipe, NULL);
vkDestroyPipeline(info.device, stencil_fullscreen_pipe, NULL);
vkDestroySemaphore(info.device, presentCompleteSemaphore, NULL);
vkDestroyFence(info.device, drawFence, NULL);
destroy_pipeline_cache(info);
destroy_descriptor_pool(info);
destroy_vertex_buffer(info);
destroy_framebuffers(info);
destroy_descriptor_and_pipeline_layouts(info);
destroy_uniform_buffer(info);
destroy_depth_buffer(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
std::tuple<VkResult, uint32_t> acquire_next_image(swapchain_type &swapchain, std::chrono::nanoseconds timeout, const semaphore::semaphore_type &semaphore) {
uint32_t image_index;
const VkResult result(vkAcquireNextImageKHR(internal::get_instance(*internal::get_parent(swapchain)), internal::get_instance(swapchain), timeout.count(), internal::get_instance(semaphore), VK_NULL_HANDLE, &image_index));
return std::make_tuple(result, image_index);
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
bool U_ASSERT_ONLY pass;
struct sample_info info = {};
char sample_title[] = "Vertex Buffer Sample";
const bool depthPresent = true;
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
init_depth_buffer(info);
init_renderpass(info, depthPresent);
init_framebuffers(info, depthPresent);
/* VULKAN_KEY_START */
/*
* Set up a vertex buffer:
* - Create a buffer
* - Map it and write the vertex data into it
* - Bind it using vkCmdBindVertexBuffers
* - Later, at pipeline creation,
* - fill in vertex input part of the pipeline with relevent data
*/
VkBufferCreateInfo buf_info = {};
buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
buf_info.pNext = NULL;
buf_info.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
buf_info.size = sizeof(g_vb_solid_face_colors_Data);
buf_info.queueFamilyIndexCount = 0;
buf_info.pQueueFamilyIndices = NULL;
buf_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
buf_info.flags = 0;
res = vkCreateBuffer(info.device, &buf_info, NULL, &info.vertex_buffer.buf);
assert(res == VK_SUCCESS);
VkMemoryRequirements mem_reqs;
vkGetBufferMemoryRequirements(info.device, info.vertex_buffer.buf, &mem_reqs);
VkMemoryAllocateInfo alloc_info = {};
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
alloc_info.pNext = NULL;
alloc_info.memoryTypeIndex = 0;
alloc_info.allocationSize = mem_reqs.size;
pass = memory_type_from_properties(info, mem_reqs.memoryTypeBits,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&alloc_info.memoryTypeIndex);
assert(pass && "No mappable, coherent memory");
res = vkAllocateMemory(info.device, &alloc_info, NULL, &(info.vertex_buffer.mem));
assert(res == VK_SUCCESS);
uint8_t *pData;
res = vkMapMemory(info.device, info.vertex_buffer.mem, 0, mem_reqs.size, 0, (void **)&pData);
assert(res == VK_SUCCESS);
memcpy(pData, g_vb_solid_face_colors_Data, sizeof(g_vb_solid_face_colors_Data));
vkUnmapMemory(info.device, info.vertex_buffer.mem);
res = vkBindBufferMemory(info.device, info.vertex_buffer.buf, info.vertex_buffer.mem, 0);
assert(res == VK_SUCCESS);
/* We won't use these here, but we will need this info when creating the
* pipeline */
info.vi_binding.binding = 0;
info.vi_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
info.vi_binding.stride = sizeof(g_vb_solid_face_colors_Data[0]);
info.vi_attribs[0].binding = 0;
info.vi_attribs[0].location = 0;
info.vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT;
info.vi_attribs[0].offset = 0;
info.vi_attribs[1].binding = 0;
info.vi_attribs[1].location = 1;
info.vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
info.vi_attribs[1].offset = 16;
const VkDeviceSize offsets[1] = {0};
/* We cannot bind the vertex buffer until we begin a renderpass */
VkClearValue clear_values[2];
clear_values[0].color.float32[0] = 0.2f;
clear_values[0].color.float32[1] = 0.2f;
clear_values[0].color.float32[2] = 0.2f;
clear_values[0].color.float32[3] = 0.2f;
clear_values[1].depthStencil.depth = 1.0f;
clear_values[1].depthStencil.stencil = 0;
VkSemaphore imageAcquiredSemaphore;
VkSemaphoreCreateInfo imageAcquiredSemaphoreCreateInfo;
imageAcquiredSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
imageAcquiredSemaphoreCreateInfo.pNext = NULL;
imageAcquiredSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &imageAcquiredSemaphoreCreateInfo, NULL, &imageAcquiredSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX, imageAcquiredSemaphore, VK_NULL_HANDLE,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
VkRenderPassBeginInfo rp_begin = {};
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.pNext = NULL;
rp_begin.renderPass = info.render_pass;
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderArea.offset.x = 0;
rp_begin.renderArea.offset.y = 0;
rp_begin.renderArea.extent.width = info.width;
rp_begin.renderArea.extent.height = info.height;
rp_begin.clearValueCount = 2;
rp_begin.pClearValues = clear_values;
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindVertexBuffers(info.cmd, 0, /* Start Binding */
1, /* Binding Count */
&info.vertex_buffer.buf, /* pBuffers */
offsets); /* pOffsets */
vkCmdEndRenderPass(info.cmd);
execute_end_command_buffer(info);
execute_queue_command_buffer(info);
/* VULKAN_KEY_END */
vkDestroySemaphore(info.device, imageAcquiredSemaphore, NULL);
vkDestroyBuffer(info.device, info.vertex_buffer.buf, NULL);
vkFreeMemory(info.device, info.vertex_buffer.mem, NULL);
destroy_framebuffers(info);
destroy_renderpass(info);
destroy_depth_buffer(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
void VkContext::StartFrame() {
// Acquire next image
CheckVkResult(vkAcquireNextImageKHR(dev, swapchain, UINT64_MAX, acquireCompleteSemaphore, VK_NULL_HANDLE, ¤tImage));
}
int main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
bool U_ASSERT_ONLY pass;
struct sample_info info = {};
char sample_title[] = "Draw Cube";
process_command_line_args(info, argc, argv);
init_global_layer_properties(info);
info.instance_extension_names.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
#ifdef _WIN32
info.instance_extension_names.push_back(
VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
#else
info.instance_extension_names.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
#endif
info.device_extension_names.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
init_instance(info, sample_title);
init_enumerate_device(info);
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
init_depth_buffer(info);
init_uniform_buffer(info);
init_descriptor_and_pipeline_layouts(info, false);
init_renderpass(info, DEPTH_PRESENT);
init_shaders(info, vertShaderText, fragShaderText);
init_framebuffers(info, DEPTH_PRESENT);
init_vertex_buffer(info, g_vb_solid_face_colors_Data,
sizeof(g_vb_solid_face_colors_Data),
sizeof(g_vb_solid_face_colors_Data[0]), false);
init_descriptor_pool(info, false);
init_descriptor_set(info, false);
init_pipeline_cache(info);
init_pipeline(info, DEPTH_PRESENT);
/* VULKAN_KEY_START */
VkClearValue clear_values[2];
clear_values[0].color.float32[0] = 0.2f;
clear_values[0].color.float32[1] = 0.2f;
clear_values[0].color.float32[2] = 0.2f;
clear_values[0].color.float32[3] = 0.2f;
clear_values[1].depthStencil.depth = 1.0f;
clear_values[1].depthStencil.stencil = 0;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo;
presentCompleteSemaphoreCreateInfo.sType =
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
presentCompleteSemaphoreCreateInfo.pNext = NULL;
presentCompleteSemaphoreCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
res = vkCreateSemaphore(info.device, &presentCompleteSemaphoreCreateInfo,
NULL, &presentCompleteSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX,
presentCompleteSemaphore, NULL,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
/* Allocate a uniform buffer that will take query results. */
VkBuffer query_result_buf;
VkDeviceMemory query_result_mem;
VkBufferCreateInfo buf_info = {};
buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
buf_info.pNext = NULL;
buf_info.usage =
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
buf_info.size = 4 * sizeof(uint64_t);
buf_info.queueFamilyIndexCount = 0;
buf_info.pQueueFamilyIndices = NULL;
buf_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
buf_info.flags = 0;
res = vkCreateBuffer(info.device, &buf_info, NULL, &query_result_buf);
assert(res == VK_SUCCESS);
VkMemoryRequirements mem_reqs;
vkGetBufferMemoryRequirements(info.device, query_result_buf, &mem_reqs);
VkMemoryAllocateInfo alloc_info = {};
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
alloc_info.pNext = NULL;
alloc_info.memoryTypeIndex = 0;
alloc_info.allocationSize = mem_reqs.size;
pass = memory_type_from_properties(info, mem_reqs.memoryTypeBits,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
&alloc_info.memoryTypeIndex);
assert(pass);
res = vkAllocateMemory(info.device, &alloc_info, NULL, &query_result_mem);
assert(res == VK_SUCCESS);
res =
vkBindBufferMemory(info.device, query_result_buf, query_result_mem, 0);
assert(res == VK_SUCCESS);
VkQueryPool query_pool;
VkQueryPoolCreateInfo query_pool_info;
query_pool_info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
query_pool_info.pNext = NULL;
query_pool_info.queryType = VK_QUERY_TYPE_OCCLUSION;
query_pool_info.flags = 0;
query_pool_info.queryCount = 2;
query_pool_info.pipelineStatistics = 0;
res = vkCreateQueryPool(info.device, &query_pool_info, NULL, &query_pool);
assert(res == VK_SUCCESS);
vkCmdResetQueryPool(info.cmd, query_pool, 0 /*startQuery*/,
2 /*queryCount*/);
VkRenderPassBeginInfo rp_begin;
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.pNext = NULL;
rp_begin.renderPass = info.render_pass;
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderArea.offset.x = 0;
rp_begin.renderArea.offset.y = 0;
rp_begin.renderArea.extent.width = info.width;
rp_begin.renderArea.extent.height = info.height;
rp_begin.clearValueCount = 2;
rp_begin.pClearValues = clear_values;
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 0, NULL);
const VkDeviceSize offsets[1] = {0};
vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);
VkViewport viewport;
viewport.height = (float)info.height;
viewport.width = (float)info.width;
viewport.minDepth = (float)0.0f;
viewport.maxDepth = (float)1.0f;
viewport.x = 0;
viewport.y = 0;
vkCmdSetViewport(info.cmd, 0, NUM_VIEWPORTS, &viewport);
VkRect2D scissor;
scissor.extent.width = info.width;
scissor.extent.height = info.height;
scissor.offset.x = 0;
scissor.offset.y = 0;
vkCmdSetScissor(info.cmd, 0, NUM_SCISSORS, &scissor);
vkCmdBeginQuery(info.cmd, query_pool, 0 /*slot*/, 0 /*flags*/);
vkCmdEndQuery(info.cmd, query_pool, 0 /*slot*/);
vkCmdBeginQuery(info.cmd, query_pool, 1 /*slot*/, 0 /*flags*/);
vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);
vkCmdEndRenderPass(info.cmd);
vkCmdEndQuery(info.cmd, query_pool, 1 /*slot*/);
vkCmdCopyQueryPoolResults(
info.cmd, query_pool, 0 /*firstQuery*/, 2 /*queryCount*/,
query_result_buf, 0 /*dstOffset*/, sizeof(uint64_t) /*stride*/,
VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
VkImageMemoryBarrier prePresentBarrier = {};
prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
prePresentBarrier.pNext = NULL;
prePresentBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
prePresentBarrier.dstAccessMask = 0;
prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
prePresentBarrier.subresourceRange.baseMipLevel = 0;
prePresentBarrier.subresourceRange.levelCount = 1;
prePresentBarrier.subresourceRange.baseArrayLayer = 0;
prePresentBarrier.subresourceRange.layerCount = 1;
prePresentBarrier.image = info.buffers[info.current_buffer].image;
vkCmdPipelineBarrier(info.cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, NULL, 0, NULL,
1, &prePresentBarrier);
res = vkEndCommandBuffer(info.cmd);
const VkCommandBuffer cmd_bufs[] = {info.cmd};
VkFenceCreateInfo fenceInfo;
VkFence drawFence;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);
VkPipelineStageFlags pipe_stage_flags =
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
VkSubmitInfo submit_info[1] = {};
submit_info[0].pNext = NULL;
submit_info[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info[0].waitSemaphoreCount = 1;
submit_info[0].pWaitSemaphores = &presentCompleteSemaphore;
submit_info[0].pWaitDstStageMask = &pipe_stage_flags;
submit_info[0].commandBufferCount = 1;
submit_info[0].pCommandBuffers = cmd_bufs;
submit_info[0].signalSemaphoreCount = 0;
submit_info[0].pSignalSemaphores = NULL;
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, submit_info, drawFence);
assert(res == VK_SUCCESS);
res = vkQueueWaitIdle(info.queue);
assert(res == VK_SUCCESS);
uint64_t samples_passed[4];
samples_passed[0] = 0;
samples_passed[1] = 0;
res = vkGetQueryPoolResults(
info.device, query_pool, 0 /*firstQuery*/, 2 /*queryCount*/,
sizeof(samples_passed) /*dataSize*/, samples_passed,
sizeof(uint64_t) /*stride*/,
VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
assert(res == VK_SUCCESS);
std::cout << "vkGetQueryPoolResults data"
<< "\n";
std::cout << "samples_passed[0] = " << samples_passed[0] << "\n";
std::cout << "samples_passed[1] = " << samples_passed[1] << "\n";
/* Read back query result from buffer */
uint64_t *samples_passed_ptr;
res = vkMapMemory(info.device, query_result_mem, 0, mem_reqs.size, 0,
(void **)&samples_passed_ptr);
assert(res == VK_SUCCESS);
std::cout << "vkCmdCopyQueryPoolResults data"
<< "\n";
std::cout << "samples_passed[0] = " << samples_passed_ptr[0] << "\n";
std::cout << "samples_passed[1] = " << samples_passed_ptr[1] << "\n";
vkUnmapMemory(info.device, query_result_mem);
/* Now present the image in the window */
VkPresentInfoKHR present;
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present.pNext = NULL;
present.swapchainCount = 1;
present.pSwapchains = &info.swap_chain;
present.pImageIndices = &info.current_buffer;
present.pWaitSemaphores = NULL;
present.waitSemaphoreCount = 0;
present.pResults = NULL;
/* Make sure command buffer is finished before presenting */
do {
res =
vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
res = vkQueuePresentKHR(info.queue, &present);
assert(res == VK_SUCCESS);
wait_seconds(1);
/* VULKAN_KEY_END */
if (info.save_images)
write_ppm(info, "occlusion_query");
vkDestroyBuffer(info.device, query_result_buf, NULL);
vkFreeMemory(info.device, query_result_mem, NULL);
vkDestroySemaphore(info.device, presentCompleteSemaphore, NULL);
vkDestroyQueryPool(info.device, query_pool, NULL);
vkDestroyFence(info.device, drawFence, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
destroy_descriptor_pool(info);
destroy_vertex_buffer(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
destroy_descriptor_and_pipeline_layouts(info);
destroy_uniform_buffer(info);
destroy_depth_buffer(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
bool U_ASSERT_ONLY pass;
struct sample_info info = {};
char sample_title[] = "Draw Cube";
const bool depthPresent = true;
process_command_line_args(info, argc, argv);
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
if (info.gpu_props.limits.maxDescriptorSetUniformBuffersDynamic < 1) {
std::cout << "No dynamic uniform buffers supported\n";
exit(-1);
}
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
init_depth_buffer(info);
init_renderpass(info, depthPresent);
init_shaders(info, vertShaderText, fragShaderText);
init_framebuffers(info, depthPresent);
init_vertex_buffer(info, g_vb_solid_face_colors_Data,
sizeof(g_vb_solid_face_colors_Data),
sizeof(g_vb_solid_face_colors_Data[0]), false);
/* Set up uniform buffer with 2 transform matrices in it */
info.Projection = glm::perspective(glm::radians(45.0f), 1.0f, 0.1f, 100.0f);
info.View = glm::lookAt(
glm::vec3(0, 3, 10), // Camera is at (0,3,10), in World Space
glm::vec3(0, 0, 0), // and looks at the origin
glm::vec3(0, -1, 0) // Head is up (set to 0,-1,0 to look upside-down)
);
info.Model = glm::mat4(1.0f);
// Vulkan clip space has inverted Y and half Z.
info.Clip = glm::mat4(1.0f, 0.0f, 0.0f, 0.0f,
0.0f, -1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.5f, 0.0f,
0.0f, 0.0f, 0.5f, 1.0f);
info.MVP = info.Clip * info.Projection * info.View * info.Model;
/* VULKAN_KEY_START */
info.Model = glm::translate(info.Model, glm::vec3(1.5, 1.5, 1.5));
glm::mat4 MVP2 = info.Clip * info.Projection * info.View * info.Model;
VkDeviceSize buf_size = sizeof(info.MVP);
if (info.gpu_props.limits.minUniformBufferOffsetAlignment)
buf_size = (buf_size +
info.gpu_props.limits.minUniformBufferOffsetAlignment - 1) &
~(info.gpu_props.limits.minUniformBufferOffsetAlignment - 1);
VkBufferCreateInfo buf_info = {};
buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
buf_info.pNext = NULL;
buf_info.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
buf_info.size = 2 * buf_size;
buf_info.queueFamilyIndexCount = 0;
buf_info.pQueueFamilyIndices = NULL;
buf_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
buf_info.flags = 0;
res = vkCreateBuffer(info.device, &buf_info, NULL, &info.uniform_data.buf);
assert(res == VK_SUCCESS);
VkMemoryRequirements mem_reqs;
vkGetBufferMemoryRequirements(info.device, info.uniform_data.buf,
&mem_reqs);
VkMemoryAllocateInfo alloc_info = {};
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
alloc_info.pNext = NULL;
alloc_info.memoryTypeIndex = 0;
alloc_info.allocationSize = mem_reqs.size;
pass = memory_type_from_properties(info, mem_reqs.memoryTypeBits,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
&alloc_info.memoryTypeIndex);
assert(pass);
res = vkAllocateMemory(info.device, &alloc_info, NULL,
&(info.uniform_data.mem));
assert(res == VK_SUCCESS);
/* Map the buffer memory and copy both matrices */
uint8_t *pData;
res = vkMapMemory(info.device, info.uniform_data.mem, 0, mem_reqs.size, 0,
(void **)&pData);
assert(res == VK_SUCCESS);
memcpy(pData, &info.MVP, sizeof(info.MVP));
pData += buf_size;
memcpy(pData, &MVP2, sizeof(MVP2));
vkUnmapMemory(info.device, info.uniform_data.mem);
res = vkBindBufferMemory(info.device, info.uniform_data.buf,
info.uniform_data.mem, 0);
assert(res == VK_SUCCESS);
info.uniform_data.buffer_info.buffer = info.uniform_data.buf;
info.uniform_data.buffer_info.offset = 0;
info.uniform_data.buffer_info.range = buf_size;
/* Init desciptor and pipeline layouts - descriptor type is
* UNIFORM_BUFFER_DYNAMIC */
VkDescriptorSetLayoutBinding layout_bindings[2];
layout_bindings[0].binding = 0;
layout_bindings[0].descriptorType =
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
layout_bindings[0].descriptorCount = 1;
layout_bindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
layout_bindings[0].pImmutableSamplers = NULL;
/* Next take layout bindings and use them to create a descriptor set layout
*/
VkDescriptorSetLayoutCreateInfo descriptor_layout = {};
descriptor_layout.sType =
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
descriptor_layout.pNext = NULL;
descriptor_layout.bindingCount = 1;
descriptor_layout.pBindings = layout_bindings;
info.desc_layout.resize(NUM_DESCRIPTOR_SETS);
res = vkCreateDescriptorSetLayout(info.device, &descriptor_layout, NULL,
info.desc_layout.data());
assert(res == VK_SUCCESS);
/* Now use the descriptor layout to create a pipeline layout */
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {};
pPipelineLayoutCreateInfo.sType =
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pPipelineLayoutCreateInfo.pNext = NULL;
pPipelineLayoutCreateInfo.pushConstantRangeCount = 0;
pPipelineLayoutCreateInfo.pPushConstantRanges = NULL;
pPipelineLayoutCreateInfo.setLayoutCount = NUM_DESCRIPTOR_SETS;
pPipelineLayoutCreateInfo.pSetLayouts = info.desc_layout.data();
res = vkCreatePipelineLayout(info.device, &pPipelineLayoutCreateInfo, NULL,
&info.pipeline_layout);
assert(res == VK_SUCCESS);
/* Create descriptor pool with UNIFOM_BUFFER_DYNAMIC type */
VkDescriptorPoolSize type_count[1];
type_count[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
type_count[0].descriptorCount = 1;
VkDescriptorPoolCreateInfo descriptor_pool = {};
descriptor_pool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
descriptor_pool.pNext = NULL;
descriptor_pool.maxSets = 1;
descriptor_pool.poolSizeCount = 1;
descriptor_pool.pPoolSizes = type_count;
res = vkCreateDescriptorPool(info.device, &descriptor_pool, NULL,
&info.desc_pool);
assert(res == VK_SUCCESS);
VkDescriptorSetAllocateInfo desc_alloc_info[1];
desc_alloc_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
desc_alloc_info[0].pNext = NULL;
desc_alloc_info[0].descriptorPool = info.desc_pool;
desc_alloc_info[0].descriptorSetCount = NUM_DESCRIPTOR_SETS;
desc_alloc_info[0].pSetLayouts = info.desc_layout.data();
/* Allocate descriptor set with UNIFORM_BUFFER_DYNAMIC */
info.desc_set.resize(NUM_DESCRIPTOR_SETS);
res = vkAllocateDescriptorSets(info.device, desc_alloc_info,
info.desc_set.data());
assert(res == VK_SUCCESS);
VkWriteDescriptorSet writes[1];
writes[0] = {};
writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
writes[0].pNext = NULL;
writes[0].dstSet = info.desc_set[0];
writes[0].descriptorCount = 1;
writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
writes[0].pBufferInfo = &info.uniform_data.buffer_info;
writes[0].dstArrayElement = 0;
writes[0].dstBinding = 0;
vkUpdateDescriptorSets(info.device, 1, writes, 0, NULL);
init_pipeline_cache(info);
init_pipeline(info, depthPresent);
VkClearValue clear_values[2];
clear_values[0].color.float32[0] = 0.2f;
clear_values[0].color.float32[1] = 0.2f;
clear_values[0].color.float32[2] = 0.2f;
clear_values[0].color.float32[3] = 0.2f;
clear_values[1].depthStencil.depth = 1.0f;
clear_values[1].depthStencil.stencil = 0;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo;
presentCompleteSemaphoreCreateInfo.sType =
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
presentCompleteSemaphoreCreateInfo.pNext = NULL;
presentCompleteSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &presentCompleteSemaphoreCreateInfo,
NULL, &presentCompleteSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX,
presentCompleteSemaphore, VK_NULL_HANDLE,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
VkRenderPassBeginInfo rp_begin;
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.pNext = NULL;
rp_begin.renderPass = info.render_pass;
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderArea.offset.x = 0;
rp_begin.renderArea.offset.y = 0;
rp_begin.renderArea.extent.width = info.width;
rp_begin.renderArea.extent.height = info.height;
rp_begin.clearValueCount = 2;
rp_begin.pClearValues = clear_values;
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);
/* The first draw should use the first matrix in the buffer */
uint32_t uni_offsets[1] = {0};
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 1, uni_offsets);
const VkDeviceSize vtx_offsets[1] = {0};
vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf,
vtx_offsets);
init_viewports(info);
init_scissors(info);
vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);
uni_offsets[0] = (uint32_t)buf_size; /* The second draw should use the
second matrix in the buffer */
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 1, uni_offsets);
vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);
vkCmdEndRenderPass(info.cmd);
VkImageMemoryBarrier prePresentBarrier = {};
prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
prePresentBarrier.pNext = NULL;
prePresentBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
prePresentBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
prePresentBarrier.subresourceRange.baseMipLevel = 0;
prePresentBarrier.subresourceRange.levelCount = 1;
prePresentBarrier.subresourceRange.baseArrayLayer = 0;
prePresentBarrier.subresourceRange.layerCount = 1;
prePresentBarrier.image = info.buffers[info.current_buffer].image;
vkCmdPipelineBarrier(info.cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0,
NULL, 1, &prePresentBarrier);
res = vkEndCommandBuffer(info.cmd);
const VkCommandBuffer cmd_bufs[] = {info.cmd};
VkFenceCreateInfo fenceInfo;
VkFence drawFence;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);
VkPipelineStageFlags pipe_stage_flags =
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
VkSubmitInfo submit_info[1] = {};
submit_info[0].pNext = NULL;
submit_info[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info[0].waitSemaphoreCount = 1;
submit_info[0].pWaitSemaphores = &presentCompleteSemaphore;
submit_info[0].pWaitDstStageMask = &pipe_stage_flags;
submit_info[0].commandBufferCount = 1;
submit_info[0].pCommandBuffers = cmd_bufs;
submit_info[0].signalSemaphoreCount = 0;
submit_info[0].pSignalSemaphores = NULL;
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, submit_info, drawFence);
assert(res == VK_SUCCESS);
/* Now present the image in the window */
VkPresentInfoKHR present;
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present.pNext = NULL;
present.swapchainCount = 1;
present.pSwapchains = &info.swap_chain;
present.pImageIndices = &info.current_buffer;
present.pWaitSemaphores = NULL;
present.waitSemaphoreCount = 0;
present.pResults = NULL;
/* Make sure command buffer is finished before presenting */
do {
res =
vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
res = vkQueuePresentKHR(info.queue, &present);
assert(res == VK_SUCCESS);
wait_seconds(1);
/* VULKAN_KEY_END */
if (info.save_images)
write_ppm(info, "dynamicuniform");
vkDestroySemaphore(info.device, presentCompleteSemaphore, NULL);
vkDestroyFence(info.device, drawFence, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
destroy_descriptor_pool(info);
destroy_vertex_buffer(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
destroy_descriptor_and_pipeline_layouts(info);
destroy_uniform_buffer(info);
destroy_depth_buffer(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
void createSwapChainAndImages(VulkanContext& context, VulkanSurfaceContext& surfaceContext) {
// Pick an image count and format. According to section 30.5 of VK 1.1, maxImageCount of zero
// apparently means "that there is no limit on the number of images, though there may be limits
// related to the total amount of memory used by presentable images."
uint32_t desiredImageCount = 2;
const uint32_t maxImageCount = surfaceContext.surfaceCapabilities.maxImageCount;
if (desiredImageCount < surfaceContext.surfaceCapabilities.minImageCount ||
(maxImageCount != 0 && desiredImageCount > maxImageCount)) {
utils::slog.e << "Swap chain does not support " << desiredImageCount << " images.\n";
desiredImageCount = surfaceContext.surfaceCapabilities.minImageCount;
}
surfaceContext.surfaceFormat = surfaceContext.surfaceFormats[0];
for (const VkSurfaceFormatKHR& format : surfaceContext.surfaceFormats) {
if (format.format == VK_FORMAT_R8G8B8A8_UNORM) {
surfaceContext.surfaceFormat = format;
break;
}
}
const auto compositionCaps = surfaceContext.surfaceCapabilities.supportedCompositeAlpha;
const auto compositeAlpha = (compositionCaps & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) ?
VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR : VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
// Create the low-level swap chain.
const auto size = surfaceContext.surfaceCapabilities.currentExtent;
VkSwapchainCreateInfoKHR createInfo {
.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
.surface = surfaceContext.surface,
.minImageCount = desiredImageCount,
.imageFormat = surfaceContext.surfaceFormat.format,
.imageColorSpace = surfaceContext.surfaceFormat.colorSpace,
.imageExtent = size,
.imageArrayLayers = 1,
.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
.compositeAlpha = compositeAlpha,
.presentMode = VK_PRESENT_MODE_FIFO_KHR,
.clipped = VK_TRUE
};
VkSwapchainKHR swapchain;
VkResult result = vkCreateSwapchainKHR(context.device, &createInfo, VKALLOC, &swapchain);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkGetPhysicalDeviceSurfaceFormatsKHR error.");
surfaceContext.swapchain = swapchain;
// Extract the VkImage handles from the swap chain.
uint32_t imageCount;
result = vkGetSwapchainImagesKHR(context.device, swapchain, &imageCount, nullptr);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkGetSwapchainImagesKHR count error.");
surfaceContext.swapContexts.resize(imageCount);
std::vector<VkImage> images(imageCount);
result = vkGetSwapchainImagesKHR(context.device, swapchain, &imageCount,
images.data());
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkGetSwapchainImagesKHR error.");
for (size_t i = 0; i < images.size(); ++i) {
surfaceContext.swapContexts[i].attachment = {
.image = images[i],
.format = surfaceContext.surfaceFormat.format
};
}
utils::slog.i
<< "vkCreateSwapchain"
<< ": " << size.width << "x" << size.height
<< ", " << surfaceContext.surfaceFormat.format
<< ", " << surfaceContext.surfaceFormat.colorSpace
<< ", " << imageCount
<< utils::io::endl;
// Create image views.
VkImageViewCreateInfo ivCreateInfo = {};
ivCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
ivCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
ivCreateInfo.format = surfaceContext.surfaceFormat.format;
ivCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
ivCreateInfo.subresourceRange.levelCount = 1;
ivCreateInfo.subresourceRange.layerCount = 1;
for (size_t i = 0; i < images.size(); ++i) {
ivCreateInfo.image = images[i];
result = vkCreateImageView(context.device, &ivCreateInfo, VKALLOC,
&surfaceContext.swapContexts[i].attachment.view);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateImageView error.");
}
createSemaphore(context.device, &surfaceContext.imageAvailable);
createSemaphore(context.device, &surfaceContext.renderingFinished);
surfaceContext.depth = {};
}
void createDepthBuffer(VulkanContext& context, VulkanSurfaceContext& surfaceContext,
VkFormat depthFormat) {
assert(context.cmdbuffer);
// Create an appropriately-sized device-only VkImage.
const auto size = surfaceContext.surfaceCapabilities.currentExtent;
VkImage depthImage;
VkImageCreateInfo imageInfo {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
.imageType = VK_IMAGE_TYPE_2D,
.extent = { size.width, size.height, 1 },
.format = depthFormat,
.mipLevels = 1,
.arrayLayers = 1,
.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
.samples = VK_SAMPLE_COUNT_1_BIT,
};
VkResult error = vkCreateImage(context.device, &imageInfo, VKALLOC, &depthImage);
ASSERT_POSTCONDITION(!error, "Unable to create depth image.");
// Allocate memory for the VkImage and bind it.
VkMemoryRequirements memReqs;
vkGetImageMemoryRequirements(context.device, depthImage, &memReqs);
VkMemoryAllocateInfo allocInfo {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.allocationSize = memReqs.size,
.memoryTypeIndex = selectMemoryType(context, memReqs.memoryTypeBits,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
};
error = vkAllocateMemory(context.device, &allocInfo, nullptr,
&surfaceContext.depth.memory);
ASSERT_POSTCONDITION(!error, "Unable to allocate depth memory.");
error = vkBindImageMemory(context.device, depthImage, surfaceContext.depth.memory, 0);
ASSERT_POSTCONDITION(!error, "Unable to bind depth memory.");
// Create a VkImageView so that we can attach depth to the framebuffer.
VkImageView depthView;
VkImageViewCreateInfo viewInfo {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = depthImage,
.viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = depthFormat,
.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,
.subresourceRange.levelCount = 1,
.subresourceRange.layerCount = 1,
};
error = vkCreateImageView(context.device, &viewInfo, VKALLOC, &depthView);
ASSERT_POSTCONDITION(!error, "Unable to create depth view.");
// Transition the depth image into an optimal layout.
VkImageMemoryBarrier barrier {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = depthImage,
.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,
.subresourceRange.levelCount = 1,
.subresourceRange.layerCount = 1,
.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
};
vkCmdPipelineBarrier(context.cmdbuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
// Go ahead and set the depth attachment fields, which serves as a signal to VulkanDriver that
// it is now ready.
surfaceContext.depth.view = depthView;
surfaceContext.depth.image = depthImage;
surfaceContext.depth.format = depthFormat;
}
void transitionDepthBuffer(VulkanContext& context, VulkanSurfaceContext& sc, VkFormat depthFormat) {
// Begin a new command buffer solely for the purpose of transitioning the image layout.
SwapContext& swap = getSwapContext(context);
VkResult result = vkWaitForFences(context.device, 1, &swap.fence, VK_FALSE, UINT64_MAX);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkWaitForFences error.");
result = vkResetFences(context.device, 1, &swap.fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkResetFences error.");
VkCommandBuffer cmdbuffer = swap.cmdbuffer;
result = vkResetCommandBuffer(cmdbuffer, 0);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkResetCommandBuffer error.");
VkCommandBufferBeginInfo beginInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
};
result = vkBeginCommandBuffer(cmdbuffer, &beginInfo);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkBeginCommandBuffer error.");
context.cmdbuffer = cmdbuffer;
// Create the depth buffer and issue a pipeline barrier command.
createDepthBuffer(context, sc, depthFormat);
// Flush the command buffer.
result = vkEndCommandBuffer(context.cmdbuffer);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkEndCommandBuffer error.");
context.cmdbuffer = nullptr;
VkSubmitInfo submitInfo {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.commandBufferCount = 1,
.pCommandBuffers = &swap.cmdbuffer,
};
result = vkQueueSubmit(context.graphicsQueue, 1, &submitInfo, swap.fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkQueueSubmit error.");
swap.submitted = false;
}
void createCommandBuffersAndFences(VulkanContext& context, VulkanSurfaceContext& surfaceContext) {
// Allocate command buffers.
VkCommandBufferAllocateInfo allocateInfo = {};
allocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocateInfo.commandPool = context.commandPool;
allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocateInfo.commandBufferCount = (uint32_t) surfaceContext.swapContexts.size();
std::vector<VkCommandBuffer> cmdbufs(allocateInfo.commandBufferCount);
VkResult result = vkAllocateCommandBuffers(context.device, &allocateInfo, cmdbufs.data());
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkAllocateCommandBuffers error.");
for (uint32_t i = 0; i < allocateInfo.commandBufferCount; ++i) {
surfaceContext.swapContexts[i].cmdbuffer = cmdbufs[i];
}
// Create fences.
VkFenceCreateInfo fenceCreateInfo = {};
fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (uint32_t i = 0; i < allocateInfo.commandBufferCount; i++) {
result = vkCreateFence(context.device, &fenceCreateInfo, VKALLOC,
&surfaceContext.swapContexts[i].fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateFence error.");
}
}
void destroySurfaceContext(VulkanContext& context, VulkanSurfaceContext& surfaceContext) {
for (SwapContext& swapContext : surfaceContext.swapContexts) {
vkFreeCommandBuffers(context.device, context.commandPool, 1, &swapContext.cmdbuffer);
vkDestroyFence(context.device, swapContext.fence, VKALLOC);
vkDestroyImageView(context.device, swapContext.attachment.view, VKALLOC);
swapContext.fence = VK_NULL_HANDLE;
swapContext.attachment.view = VK_NULL_HANDLE;
}
vkDestroySwapchainKHR(context.device, surfaceContext.swapchain, VKALLOC);
vkDestroySemaphore(context.device, surfaceContext.imageAvailable, VKALLOC);
vkDestroySemaphore(context.device, surfaceContext.renderingFinished, VKALLOC);
vkDestroySurfaceKHR(context.instance, surfaceContext.surface, VKALLOC);
vkDestroyImageView(context.device, surfaceContext.depth.view, VKALLOC);
vkDestroyImage(context.device, surfaceContext.depth.image, VKALLOC);
vkFreeMemory(context.device, surfaceContext.depth.memory, VKALLOC);
if (context.currentSurface == &surfaceContext) {
context.currentSurface = nullptr;
}
}
uint32_t selectMemoryType(VulkanContext& context, uint32_t flags, VkFlags reqs) {
for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
if (flags & 1) {
if ((context.memoryProperties.memoryTypes[i].propertyFlags & reqs) == reqs) {
return i;
}
}
flags >>= 1;
}
ASSERT_POSTCONDITION(false, "Unable to find a memory type that meets requirements.");
return (uint32_t) ~0ul;
}
VkFormat getVkFormat(ElementType type, bool normalized) {
using ElementType = ElementType;
if (normalized) {
switch (type) {
// Single Component Types
case ElementType::BYTE: return VK_FORMAT_R8_SNORM;
case ElementType::UBYTE: return VK_FORMAT_R8_UNORM;
case ElementType::SHORT: return VK_FORMAT_R16_SNORM;
case ElementType::USHORT: return VK_FORMAT_R16_UNORM;
// Two Component Types
case ElementType::BYTE2: return VK_FORMAT_R8G8_SNORM;
case ElementType::UBYTE2: return VK_FORMAT_R8G8_UNORM;
case ElementType::SHORT2: return VK_FORMAT_R16G16_SNORM;
case ElementType::USHORT2: return VK_FORMAT_R16G16_UNORM;
// Three Component Types
case ElementType::BYTE3: return VK_FORMAT_R8G8B8_SNORM;
case ElementType::UBYTE3: return VK_FORMAT_R8G8B8_UNORM;
case ElementType::SHORT3: return VK_FORMAT_R16G16B16_SNORM;
case ElementType::USHORT3: return VK_FORMAT_R16G16B16_UNORM;
// Four Component Types
case ElementType::BYTE4: return VK_FORMAT_R8G8B8A8_SNORM;
case ElementType::UBYTE4: return VK_FORMAT_R8G8B8A8_UNORM;
case ElementType::SHORT4: return VK_FORMAT_R16G16B16A16_SNORM;
case ElementType::USHORT4: return VK_FORMAT_R16G16B16A16_UNORM;
default:
ASSERT_POSTCONDITION(false, "Normalized format does not exist.");
return VK_FORMAT_UNDEFINED;
}
}
switch (type) {
// Single Component Types
case ElementType::BYTE: return VK_FORMAT_R8_SINT;
case ElementType::UBYTE: return VK_FORMAT_R8_UINT;
case ElementType::SHORT: return VK_FORMAT_R16_SINT;
case ElementType::USHORT: return VK_FORMAT_R16_UINT;
case ElementType::HALF: return VK_FORMAT_R16_SFLOAT;
case ElementType::INT: return VK_FORMAT_R32_SINT;
case ElementType::UINT: return VK_FORMAT_R32_UINT;
case ElementType::FLOAT: return VK_FORMAT_R32_SFLOAT;
// Two Component Types
case ElementType::BYTE2: return VK_FORMAT_R8G8_SINT;
case ElementType::UBYTE2: return VK_FORMAT_R8G8_UINT;
case ElementType::SHORT2: return VK_FORMAT_R16G16_SINT;
case ElementType::USHORT2: return VK_FORMAT_R16G16_UINT;
case ElementType::HALF2: return VK_FORMAT_R16G16_SFLOAT;
case ElementType::FLOAT2: return VK_FORMAT_R32G32_SFLOAT;
// Three Component Types
case ElementType::BYTE3: return VK_FORMAT_R8G8B8_SINT;
case ElementType::UBYTE3: return VK_FORMAT_R8G8B8_UINT;
case ElementType::SHORT3: return VK_FORMAT_R16G16B16_SINT;
case ElementType::USHORT3: return VK_FORMAT_R16G16B16_UINT;
case ElementType::HALF3: return VK_FORMAT_R16G16B16_SFLOAT;
case ElementType::FLOAT3: return VK_FORMAT_R32G32B32_SFLOAT;
// Four Component Types
case ElementType::BYTE4: return VK_FORMAT_R8G8B8A8_SINT;
case ElementType::UBYTE4: return VK_FORMAT_R8G8B8A8_UINT;
case ElementType::SHORT4: return VK_FORMAT_R16G16B16A16_SINT;
case ElementType::USHORT4: return VK_FORMAT_R16G16B16A16_UINT;
case ElementType::HALF4: return VK_FORMAT_R16G16B16A16_SFLOAT;
case ElementType::FLOAT4: return VK_FORMAT_R32G32B32A32_SFLOAT;
}
return VK_FORMAT_UNDEFINED;
}
VkFormat getVkFormat(TextureFormat format) {
using TextureFormat = TextureFormat;
switch (format) {
// 8 bits per element.
case TextureFormat::R8: return VK_FORMAT_R8_UNORM;
case TextureFormat::R8_SNORM: return VK_FORMAT_R8_SNORM;
case TextureFormat::R8UI: return VK_FORMAT_R8_UINT;
case TextureFormat::R8I: return VK_FORMAT_R8_SINT;
case TextureFormat::STENCIL8: return VK_FORMAT_S8_UINT;
// 16 bits per element.
case TextureFormat::R16F: return VK_FORMAT_R16_SFLOAT;
case TextureFormat::R16UI: return VK_FORMAT_R16_UINT;
case TextureFormat::R16I: return VK_FORMAT_R16_SINT;
case TextureFormat::RG8: return VK_FORMAT_R8G8_UNORM;
case TextureFormat::RG8_SNORM: return VK_FORMAT_R8G8_SNORM;
case TextureFormat::RG8UI: return VK_FORMAT_R8G8_UINT;
case TextureFormat::RG8I: return VK_FORMAT_R8G8_SINT;
case TextureFormat::RGB565: return VK_FORMAT_R5G6B5_UNORM_PACK16;
case TextureFormat::RGB5_A1: return VK_FORMAT_R5G5B5A1_UNORM_PACK16;
case TextureFormat::RGBA4: return VK_FORMAT_R4G4B4A4_UNORM_PACK16;
case TextureFormat::DEPTH16: return VK_FORMAT_D16_UNORM;
// 24 bits per element. In practice, very few GPU vendors support these. For simplicity
// we just assume they are not supported, not bothering to query the device capabilities.
// Note that VK_FORMAT_ enums for 24-bit formats exist, but are meant for vertex attributes.
case TextureFormat::RGB8:
case TextureFormat::SRGB8:
case TextureFormat::RGB8_SNORM:
case TextureFormat::RGB8UI:
case TextureFormat::RGB8I:
case TextureFormat::DEPTH24:
return VK_FORMAT_UNDEFINED;
// 32 bits per element.
case TextureFormat::R32F: return VK_FORMAT_R32_SFLOAT;
case TextureFormat::R32UI: return VK_FORMAT_R32_UINT;
case TextureFormat::R32I: return VK_FORMAT_R32_SINT;
case TextureFormat::RG16F: return VK_FORMAT_R16G16_SFLOAT;
case TextureFormat::RG16UI: return VK_FORMAT_R16G16_UINT;
case TextureFormat::RG16I: return VK_FORMAT_R16G16_SINT;
case TextureFormat::R11F_G11F_B10F: return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
case TextureFormat::RGB9_E5: return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
case TextureFormat::RGBA8: return VK_FORMAT_R8G8B8A8_UNORM;
case TextureFormat::SRGB8_A8: return VK_FORMAT_R8G8B8A8_SRGB;
case TextureFormat::RGBA8_SNORM: return VK_FORMAT_R8G8B8A8_SNORM;
case TextureFormat::RGBM: return VK_FORMAT_R8G8B8A8_UNORM;
case TextureFormat::RGB10_A2: return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
case TextureFormat::RGBA8UI: return VK_FORMAT_R8G8B8A8_UINT;
case TextureFormat::RGBA8I: return VK_FORMAT_R8G8B8A8_SINT;
case TextureFormat::DEPTH32F: return VK_FORMAT_D32_SFLOAT;
case TextureFormat::DEPTH24_STENCIL8: return VK_FORMAT_D24_UNORM_S8_UINT;
case TextureFormat::DEPTH32F_STENCIL8: return VK_FORMAT_D32_SFLOAT_S8_UINT;
// 48 bits per element. Note that many GPU vendors do not support these.
case TextureFormat::RGB16F: return VK_FORMAT_R16G16B16_SFLOAT;
case TextureFormat::RGB16UI: return VK_FORMAT_R16G16B16_UINT;
case TextureFormat::RGB16I: return VK_FORMAT_R16G16B16_SINT;
// 64 bits per element.
case TextureFormat::RG32F: return VK_FORMAT_R32G32_SFLOAT;
case TextureFormat::RG32UI: return VK_FORMAT_R32G32_UINT;
case TextureFormat::RG32I: return VK_FORMAT_R32G32_SINT;
case TextureFormat::RGBA16F: return VK_FORMAT_R16G16B16A16_SFLOAT;
case TextureFormat::RGBA16UI: return VK_FORMAT_R16G16B16A16_UINT;
case TextureFormat::RGBA16I: return VK_FORMAT_R16G16B16A16_SINT;
// 96-bits per element.
case TextureFormat::RGB32F: return VK_FORMAT_R32G32B32_SFLOAT;
case TextureFormat::RGB32UI: return VK_FORMAT_R32G32B32_UINT;
case TextureFormat::RGB32I: return VK_FORMAT_R32G32B32_SINT;
// 128-bits per element
case TextureFormat::RGBA32F: return VK_FORMAT_R32G32B32A32_SFLOAT;
case TextureFormat::RGBA32UI: return VK_FORMAT_R32G32B32A32_UINT;
case TextureFormat::RGBA32I: return VK_FORMAT_R32G32B32A32_SINT;
default:
return VK_FORMAT_UNDEFINED;
}
}
uint32_t getBytesPerPixel(TextureFormat format) {
return details::FTexture::getFormatSize(format);
}
// See also FTexture::computeTextureDataSize, which takes a public-facing Texture format rather
// than a driver-level Texture format, and can account for a specified byte alignment.
uint32_t computeSize(TextureFormat format, uint32_t w, uint32_t h, uint32_t d) {
const size_t bytesPerTexel = details::FTexture::getFormatSize(format);
return bytesPerTexel * w * h * d;
}
SwapContext& getSwapContext(VulkanContext& context) {
VulkanSurfaceContext& surface = *context.currentSurface;
return surface.swapContexts[surface.currentSwapIndex];
}
bool hasPendingWork(VulkanContext& context) {
if (context.pendingWork.size() > 0) {
return true;
}
if (context.currentSurface) {
for (auto& swapContext : context.currentSurface->swapContexts) {
if (swapContext.pendingWork.size() > 0) {
return true;
}
}
}
return false;
}
VkCompareOp getCompareOp(SamplerCompareFunc func) {
using Compare = driver::SamplerCompareFunc;
switch (func) {
case Compare::LE: return VK_COMPARE_OP_LESS_OR_EQUAL;
case Compare::GE: return VK_COMPARE_OP_GREATER_OR_EQUAL;
case Compare::L: return VK_COMPARE_OP_LESS;
case Compare::G: return VK_COMPARE_OP_GREATER;
case Compare::E: return VK_COMPARE_OP_EQUAL;
case Compare::NE: return VK_COMPARE_OP_NOT_EQUAL;
case Compare::A: return VK_COMPARE_OP_ALWAYS;
case Compare::N: return VK_COMPARE_OP_NEVER;
}
}
VkBlendFactor getBlendFactor(BlendFunction mode) {
using BlendFunction = filament::driver::BlendFunction;
switch (mode) {
case BlendFunction::ZERO: return VK_BLEND_FACTOR_ZERO;
case BlendFunction::ONE: return VK_BLEND_FACTOR_ONE;
case BlendFunction::SRC_COLOR: return VK_BLEND_FACTOR_SRC_COLOR;
case BlendFunction::ONE_MINUS_SRC_COLOR: return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
case BlendFunction::DST_COLOR: return VK_BLEND_FACTOR_DST_COLOR;
case BlendFunction::ONE_MINUS_DST_COLOR: return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
case BlendFunction::SRC_ALPHA: return VK_BLEND_FACTOR_SRC_ALPHA;
case BlendFunction::ONE_MINUS_SRC_ALPHA: return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
case BlendFunction::DST_ALPHA: return VK_BLEND_FACTOR_DST_ALPHA;
case BlendFunction::ONE_MINUS_DST_ALPHA: return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
case BlendFunction::SRC_ALPHA_SATURATE: return VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;
}
}
void waitForIdle(VulkanContext& context) {
// If there's no valid GPU then we have nothing to do.
if (!context.device) {
return;
}
// If there's no surface, then there's no command buffer.
if (!context.currentSurface) {
return;
}
// First, wait for submitted command buffer(s) to finish.
VkFence fences[2];
uint32_t nfences = 0;
auto& surfaceContext = *context.currentSurface;
for (auto& swapContext : surfaceContext.swapContexts) {
assert(nfences < 2);
if (swapContext.submitted && swapContext.fence) {
fences[nfences++] = swapContext.fence;
swapContext.submitted = false;
}
}
if (nfences > 0) {
vkWaitForFences(context.device, nfences, fences, VK_FALSE, ~0ull);
}
// If we don't have any pending work, we're done.
if (!hasPendingWork(context)) {
return;
}
// We cannot invoke arbitrary commands inside a render pass.
assert(context.currentRenderPass.renderPass == VK_NULL_HANDLE);
// Create a one-off command buffer to avoid the cost of swap chain acquisition and to avoid
// the possibility of SURFACE_LOST. Note that Vulkan command buffers use the Allocate/Free
// model instead of Create/Destroy and are therefore okay to create at a high frequency.
VkCommandBuffer cmdbuffer;
VkFence fence;
VkCommandBufferBeginInfo beginInfo { .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
VkCommandBufferAllocateInfo allocateInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
.commandPool = context.commandPool,
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
.commandBufferCount = 1
};
VkFenceCreateInfo fenceCreateInfo { .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, };
vkAllocateCommandBuffers(context.device, &allocateInfo, &cmdbuffer);
vkCreateFence(context.device, &fenceCreateInfo, VKALLOC, &fence);
// Keep performing work until there's nothing queued up. This should never iterate more than
// a couple times because the only work we queue up is for resource transition / reclamation.
VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
VkSubmitInfo submitInfo {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pWaitDstStageMask = &waitDestStageMask,
.commandBufferCount = 1,
.pCommandBuffers = &cmdbuffer,
};
int cycles = 0;
while (hasPendingWork(context)) {
if (cycles++ > 2) {
utils::slog.e << "Unexpected daisychaining of pending work." << utils::io::endl;
break;
}
for (auto& swapContext : context.currentSurface->swapContexts) {
vkBeginCommandBuffer(cmdbuffer, &beginInfo);
performPendingWork(context, swapContext, cmdbuffer);
vkEndCommandBuffer(cmdbuffer);
vkQueueSubmit(context.graphicsQueue, 1, &submitInfo, fence);
vkWaitForFences(context.device, 1, &fence, VK_FALSE, UINT64_MAX);
vkResetFences(context.device, 1, &fence);
vkResetCommandBuffer(cmdbuffer, 0);
}
}
vkFreeCommandBuffers(context.device, context.commandPool, 1, &cmdbuffer);
vkDestroyFence(context.device, fence, VKALLOC);
}
void acquireCommandBuffer(VulkanContext& context) {
// Ask Vulkan for the next image in the swap chain and update the currentSwapIndex.
VulkanSurfaceContext& surface = *context.currentSurface;
VkResult result = vkAcquireNextImageKHR(context.device, surface.swapchain,
UINT64_MAX, surface.imageAvailable, VK_NULL_HANDLE, &surface.currentSwapIndex);
ASSERT_POSTCONDITION(result != VK_ERROR_OUT_OF_DATE_KHR,
"Stale / resized swap chain not yet supported.");
ASSERT_POSTCONDITION(result == VK_SUBOPTIMAL_KHR || result == VK_SUCCESS,
"vkAcquireNextImageKHR error.");
SwapContext& swap = getSwapContext(context);
// Ensure that the previous submission of this command buffer has finished.
result = vkWaitForFences(context.device, 1, &swap.fence, VK_FALSE, UINT64_MAX);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkWaitForFences error.");
// Restart the command buffer.
result = vkResetFences(context.device, 1, &swap.fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkResetFences error.");
VkCommandBuffer cmdbuffer = swap.cmdbuffer;
VkResult error = vkResetCommandBuffer(cmdbuffer, 0);
ASSERT_POSTCONDITION(not error, "vkResetCommandBuffer error.");
VkCommandBufferBeginInfo beginInfo {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
};
error = vkBeginCommandBuffer(cmdbuffer, &beginInfo);
ASSERT_POSTCONDITION(not error, "vkBeginCommandBuffer error.");
context.cmdbuffer = cmdbuffer;
swap.submitted = false;
}
void releaseCommandBuffer(VulkanContext& context) {
// Finalize the command buffer and set the cmdbuffer pointer to null.
VkResult result = vkEndCommandBuffer(context.cmdbuffer);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkEndCommandBuffer error.");
context.cmdbuffer = nullptr;
// Submit the command buffer.
VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
VulkanSurfaceContext& surfaceContext = *context.currentSurface;
SwapContext& swapContext = getSwapContext(context);
VkSubmitInfo submitInfo {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.waitSemaphoreCount = 1u,
.pWaitSemaphores = &surfaceContext.imageAvailable,
.pWaitDstStageMask = &waitDestStageMask,
.commandBufferCount = 1,
.pCommandBuffers = &swapContext.cmdbuffer,
.signalSemaphoreCount = 1u,
.pSignalSemaphores = &surfaceContext.renderingFinished,
};
result = vkQueueSubmit(context.graphicsQueue, 1, &submitInfo, swapContext.fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkQueueSubmit error.");
swapContext.submitted = true;
}
void performPendingWork(VulkanContext& context, SwapContext& swapContext, VkCommandBuffer cmdbuf) {
// First, execute pending tasks that are specific to this swap context. Copy the tasks into a
// local queue first, which allows newly added tasks to be deferred until the next frame.
decltype(swapContext.pendingWork) tasks;
tasks.swap(swapContext.pendingWork);
for (auto& callback : tasks) {
callback(cmdbuf);
}
// Next, execute the global pending work. Again, we copy the work queue into a local queue
// to allow tasks to re-add themselves.
tasks.clear();
tasks.swap(context.pendingWork);
for (auto& callback : tasks) {
callback(cmdbuf);
}
}
// Flushes the command buffer and waits for it to finish executing. Useful for diagnosing
// sychronization issues.
void flushCommandBuffer(VulkanContext& context) {
VulkanSurfaceContext& surface = *context.currentSurface;
const SwapContext& sc = surface.swapContexts[surface.currentSwapIndex];
// Submit the command buffer.
VkResult error = vkEndCommandBuffer(context.cmdbuffer);
ASSERT_POSTCONDITION(!error, "vkEndCommandBuffer error.");
VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
VkSubmitInfo submitInfo {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pWaitDstStageMask = &waitDestStageMask,
.commandBufferCount = 1,
.pCommandBuffers = &context.cmdbuffer,
};
error = vkQueueSubmit(context.graphicsQueue, 1, &submitInfo, sc.fence);
ASSERT_POSTCONDITION(!error, "vkQueueSubmit error.");
// Restart the command buffer.
error = vkWaitForFences(context.device, 1, &sc.fence, VK_FALSE, UINT64_MAX);
ASSERT_POSTCONDITION(!error, "vkWaitForFences error.");
error = vkResetFences(context.device, 1, &sc.fence);
ASSERT_POSTCONDITION(!error, "vkResetFences error.");
error = vkResetCommandBuffer(context.cmdbuffer, 0);
ASSERT_POSTCONDITION(!error, "vkResetCommandBuffer error.");
VkCommandBufferBeginInfo beginInfo {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
};
error = vkBeginCommandBuffer(context.cmdbuffer, &beginInfo);
ASSERT_POSTCONDITION(!error, "vkBeginCommandBuffer error.");
}
VkFormat findSupportedFormat(VulkanContext& context, const std::vector<VkFormat>& candidates,
VkImageTiling tiling, VkFormatFeatureFlags features) {
for (VkFormat format : candidates) {
VkFormatProperties props;
vkGetPhysicalDeviceFormatProperties(context.physicalDevice, format, &props);
if (tiling == VK_IMAGE_TILING_LINEAR &&
(props.linearTilingFeatures & features) == features) {
return format;
} else if (tiling == VK_IMAGE_TILING_OPTIMAL &&
(props.optimalTilingFeatures & features) == features) {
return format;
}
}
return VK_FORMAT_UNDEFINED;
}
} // namespace filament
} // namespace driver
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Secondary command buffers";
const bool depthPresent = true;
process_command_line_args(info, argc, argv);
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
init_depth_buffer(info);
init_uniform_buffer(info);
init_descriptor_and_pipeline_layouts(info, true);
init_renderpass(info, depthPresent, true, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
init_shaders(info, vertShaderText, fragShaderText);
init_framebuffers(info, depthPresent);
init_vertex_buffer(info, g_vb_texture_Data, sizeof(g_vb_texture_Data), sizeof(g_vb_texture_Data[0]), true);
init_pipeline_cache(info);
init_pipeline(info, depthPresent);
// we have to set up a couple of things by hand, but this
// isn't any different to other examples
// get two different textures
init_texture(info, "green.ppm");
VkDescriptorImageInfo greenTex = info.texture_data.image_info;
init_texture(info, "lunarg.ppm");
VkDescriptorImageInfo lunargTex = info.texture_data.image_info;
// create two identical descriptor sets, each with a different texture but
// identical UBOa
VkDescriptorPoolSize pool_size[2];
pool_size[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
pool_size[0].descriptorCount = 2;
pool_size[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
pool_size[1].descriptorCount = 2;
VkDescriptorPoolCreateInfo descriptor_pool = {};
descriptor_pool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
descriptor_pool.pNext = NULL;
descriptor_pool.flags = 0;
descriptor_pool.maxSets = 2;
descriptor_pool.poolSizeCount = 2;
descriptor_pool.pPoolSizes = pool_size;
res = vkCreateDescriptorPool(info.device, &descriptor_pool, NULL, &info.desc_pool);
assert(res == VK_SUCCESS);
VkDescriptorSetLayout layouts[] = {info.desc_layout[0], info.desc_layout[0]};
VkDescriptorSetAllocateInfo alloc_info[1];
alloc_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
alloc_info[0].pNext = NULL;
alloc_info[0].descriptorPool = info.desc_pool;
alloc_info[0].descriptorSetCount = 2;
alloc_info[0].pSetLayouts = layouts;
info.desc_set.resize(2);
res = vkAllocateDescriptorSets(info.device, alloc_info, info.desc_set.data());
assert(res == VK_SUCCESS);
VkWriteDescriptorSet writes[2];
writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
writes[0].pNext = NULL;
writes[0].dstSet = info.desc_set[0];
writes[0].descriptorCount = 1;
writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
writes[0].pBufferInfo = &info.uniform_data.buffer_info;
writes[0].dstArrayElement = 0;
writes[0].dstBinding = 0;
writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
writes[1].pNext = NULL;
writes[1].dstSet = info.desc_set[0];
writes[1].dstBinding = 1;
writes[1].descriptorCount = 1;
writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
writes[1].pImageInfo = &greenTex;
writes[1].dstArrayElement = 0;
vkUpdateDescriptorSets(info.device, 2, writes, 0, NULL);
writes[0].dstSet = writes[1].dstSet = info.desc_set[1];
writes[1].pImageInfo = &lunargTex;
vkUpdateDescriptorSets(info.device, 2, writes, 0, NULL);
/* VULKAN_KEY_START */
// create four secondary command buffers, for each quadrant of the screen
VkCommandBufferAllocateInfo cmdalloc = {};
cmdalloc.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
cmdalloc.pNext = NULL;
cmdalloc.commandPool = info.cmd_pool;
cmdalloc.level = VK_COMMAND_BUFFER_LEVEL_SECONDARY;
cmdalloc.commandBufferCount = 4;
VkCommandBuffer secondary_cmds[4];
res = vkAllocateCommandBuffers(info.device, &cmdalloc, secondary_cmds);
assert(res == VK_SUCCESS);
VkClearValue clear_values[2];
clear_values[0].color.float32[0] = 0.2f;
clear_values[0].color.float32[1] = 0.2f;
clear_values[0].color.float32[2] = 0.2f;
clear_values[0].color.float32[3] = 0.2f;
clear_values[1].depthStencil.depth = 1.0f;
clear_values[1].depthStencil.stencil = 0;
VkSemaphore imageAcquiredSemaphore;
VkSemaphoreCreateInfo imageAcquiredSemaphoreCreateInfo;
imageAcquiredSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
imageAcquiredSemaphoreCreateInfo.pNext = NULL;
imageAcquiredSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &imageAcquiredSemaphoreCreateInfo, NULL, &imageAcquiredSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX, imageAcquiredSemaphore, VK_NULL_HANDLE,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
set_image_layout(info, info.buffers[info.current_buffer].image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
const VkDeviceSize offsets[1] = {0};
VkViewport viewport;
viewport.height = 200.0f;
viewport.width = 200.0f;
viewport.minDepth = (float)0.0f;
viewport.maxDepth = (float)1.0f;
viewport.x = 0;
viewport.y = 0;
VkRect2D scissor;
scissor.extent.width = info.width;
scissor.extent.height = info.height;
scissor.offset.x = 0;
scissor.offset.y = 0;
// now we record four separate command buffers, one for each quadrant of the
// screen
VkCommandBufferInheritanceInfo cmd_buf_inheritance_info = {};
cmd_buf_inheritance_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, cmd_buf_inheritance_info.pNext = NULL;
cmd_buf_inheritance_info.renderPass = info.render_pass;
cmd_buf_inheritance_info.subpass = 0;
cmd_buf_inheritance_info.framebuffer = info.framebuffers[info.current_buffer];
cmd_buf_inheritance_info.occlusionQueryEnable = VK_FALSE;
cmd_buf_inheritance_info.queryFlags = 0;
cmd_buf_inheritance_info.pipelineStatistics = 0;
VkCommandBufferBeginInfo secondary_begin = {};
secondary_begin.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
secondary_begin.pNext = NULL;
secondary_begin.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
secondary_begin.pInheritanceInfo = &cmd_buf_inheritance_info;
for (int i = 0; i < 4; i++) {
vkBeginCommandBuffer(secondary_cmds[i], &secondary_begin);
vkCmdBindPipeline(secondary_cmds[i], VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);
vkCmdBindDescriptorSets(secondary_cmds[i], VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, 1,
&info.desc_set[i == 0 || i == 3], 0, NULL);
vkCmdBindVertexBuffers(secondary_cmds[i], 0, 1, &info.vertex_buffer.buf, offsets);
viewport.x = 25.0f + 250.0f * (i % 2);
viewport.y = 25.0f + 250.0f * (i / 2);
vkCmdSetViewport(secondary_cmds[i], 0, NUM_VIEWPORTS, &viewport);
vkCmdSetScissor(secondary_cmds[i], 0, NUM_SCISSORS, &scissor);
vkCmdDraw(secondary_cmds[i], 12 * 3, 1, 0, 0);
vkEndCommandBuffer(secondary_cmds[i]);
}
VkRenderPassBeginInfo rp_begin;
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.pNext = NULL;
rp_begin.renderPass = info.render_pass;
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderArea.offset.x = 0;
rp_begin.renderArea.offset.y = 0;
rp_begin.renderArea.extent.width = info.width;
rp_begin.renderArea.extent.height = info.height;
rp_begin.clearValueCount = 2;
rp_begin.pClearValues = clear_values;
// specifying VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS means this
// render pass may
// ONLY call vkCmdExecuteCommands
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
vkCmdExecuteCommands(info.cmd, 4, secondary_cmds);
vkCmdEndRenderPass(info.cmd);
VkImageMemoryBarrier prePresentBarrier = {};
prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
prePresentBarrier.pNext = NULL;
prePresentBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
prePresentBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
prePresentBarrier.subresourceRange.baseMipLevel = 0;
prePresentBarrier.subresourceRange.levelCount = 1;
prePresentBarrier.subresourceRange.baseArrayLayer = 0;
prePresentBarrier.subresourceRange.layerCount = 1;
prePresentBarrier.image = info.buffers[info.current_buffer].image;
vkCmdPipelineBarrier(info.cmd, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL,
0, NULL, 1, &prePresentBarrier);
res = vkEndCommandBuffer(info.cmd);
assert(res == VK_SUCCESS);
const VkCommandBuffer cmd_bufs[] = {info.cmd};
VkFenceCreateInfo fenceInfo;
VkFence drawFence;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);
VkPipelineStageFlags pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
VkSubmitInfo submit_info[1] = {};
submit_info[0].pNext = NULL;
submit_info[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info[0].waitSemaphoreCount = 1;
submit_info[0].pWaitSemaphores = &imageAcquiredSemaphore;
submit_info[0].pWaitDstStageMask = &pipe_stage_flags;
submit_info[0].commandBufferCount = 1;
submit_info[0].pCommandBuffers = cmd_bufs;
submit_info[0].signalSemaphoreCount = 0;
submit_info[0].pSignalSemaphores = NULL;
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.graphics_queue, 1, submit_info, drawFence);
assert(res == VK_SUCCESS);
/* Now present the image in the window */
VkPresentInfoKHR present;
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present.pNext = NULL;
present.swapchainCount = 1;
present.pSwapchains = &info.swap_chain;
present.pImageIndices = &info.current_buffer;
present.pWaitSemaphores = NULL;
present.waitSemaphoreCount = 0;
present.pResults = NULL;
/* Make sure command buffer is finished before presenting */
do {
res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
res = vkQueuePresentKHR(info.present_queue, &present);
assert(res == VK_SUCCESS);
wait_seconds(1);
if (info.save_images) write_ppm(info, "secondary_command_buffer");
vkFreeCommandBuffers(info.device, info.cmd_pool, 4, secondary_cmds);
/* VULKAN_KEY_END */
vkDestroyFence(info.device, drawFence, NULL);
vkDestroySemaphore(info.device, imageAcquiredSemaphore, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
destroy_textures(info);
destroy_descriptor_pool(info);
destroy_vertex_buffer(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
destroy_descriptor_and_pipeline_layouts(info);
destroy_uniform_buffer(info);
destroy_depth_buffer(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Draw Textured Cube";
const bool depthPresent = true;
process_command_line_args(info, argc, argv);
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
init_depth_buffer(info);
init_texture(info);
init_uniform_buffer(info);
init_descriptor_and_pipeline_layouts(info, true);
init_renderpass(info, depthPresent);
init_shaders(info, vertShaderText, fragShaderText);
init_framebuffers(info, depthPresent);
init_vertex_buffer(info, g_vb_texture_Data, sizeof(g_vb_texture_Data),
sizeof(g_vb_texture_Data[0]), true);
init_descriptor_pool(info, true);
init_descriptor_set(info, true);
init_pipeline_cache(info);
init_pipeline(info, depthPresent);
/* VULKAN_KEY_START */
VkClearValue clear_values[2];
clear_values[0].color.float32[0] = 0.2f;
clear_values[0].color.float32[1] = 0.2f;
clear_values[0].color.float32[2] = 0.2f;
clear_values[0].color.float32[3] = 0.2f;
clear_values[1].depthStencil.depth = 1.0f;
clear_values[1].depthStencil.stencil = 0;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo;
presentCompleteSemaphoreCreateInfo.sType =
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
presentCompleteSemaphoreCreateInfo.pNext = NULL;
presentCompleteSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &presentCompleteSemaphoreCreateInfo,
NULL, &presentCompleteSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX,
presentCompleteSemaphore, VK_NULL_HANDLE,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
set_image_layout(info, info.buffers[info.current_buffer].image,
VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
VkRenderPassBeginInfo rp_begin;
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.pNext = NULL;
rp_begin.renderPass = info.render_pass;
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderArea.offset.x = 0;
rp_begin.renderArea.offset.y = 0;
rp_begin.renderArea.extent.width = info.width;
rp_begin.renderArea.extent.height = info.height;
rp_begin.clearValueCount = 2;
rp_begin.pClearValues = clear_values;
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 0, NULL);
const VkDeviceSize offsets[1] = {0};
vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);
init_viewports(info);
init_scissors(info);
vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);
vkCmdEndRenderPass(info.cmd);
VkImageMemoryBarrier prePresentBarrier = {};
prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
prePresentBarrier.pNext = NULL;
prePresentBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
prePresentBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
prePresentBarrier.subresourceRange.baseMipLevel = 0;
prePresentBarrier.subresourceRange.levelCount = 1;
prePresentBarrier.subresourceRange.baseArrayLayer = 0;
prePresentBarrier.subresourceRange.layerCount = 1;
prePresentBarrier.image = info.buffers[info.current_buffer].image;
vkCmdPipelineBarrier(info.cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0,
NULL, 1, &prePresentBarrier);
res = vkEndCommandBuffer(info.cmd);
assert(res == VK_SUCCESS);
const VkCommandBuffer cmd_bufs[] = {info.cmd};
VkFenceCreateInfo fenceInfo;
VkFence drawFence;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);
VkPipelineStageFlags pipe_stage_flags =
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
VkSubmitInfo submit_info[1] = {};
submit_info[0].pNext = NULL;
submit_info[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info[0].waitSemaphoreCount = 1;
submit_info[0].pWaitSemaphores = &presentCompleteSemaphore;
submit_info[0].pWaitDstStageMask = &pipe_stage_flags;
submit_info[0].commandBufferCount = 1;
submit_info[0].pCommandBuffers = cmd_bufs;
submit_info[0].signalSemaphoreCount = 0;
submit_info[0].pSignalSemaphores = NULL;
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, submit_info, drawFence);
assert(res == VK_SUCCESS);
/* Now present the image in the window */
VkPresentInfoKHR present;
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present.pNext = NULL;
present.swapchainCount = 1;
present.pSwapchains = &info.swap_chain;
present.pImageIndices = &info.current_buffer;
present.pWaitSemaphores = NULL;
present.waitSemaphoreCount = 0;
present.pResults = NULL;
/* Make sure command buffer is finished before presenting */
do {
res =
vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
res = vkQueuePresentKHR(info.queue, &present);
assert(res == VK_SUCCESS);
wait_seconds(1);
/* VULKAN_KEY_END */
if (info.save_images)
write_ppm(info, "drawtexturedcube");
vkDestroyFence(info.device, drawFence, NULL);
vkDestroySemaphore(info.device, presentCompleteSemaphore, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
destroy_textures(info);
destroy_descriptor_pool(info);
destroy_vertex_buffer(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
destroy_descriptor_and_pipeline_layouts(info);
destroy_uniform_buffer(info);
destroy_depth_buffer(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
