demos/smoke/Shell.cpp - third_party/vulkan_loader_and_validation_layers - Git at Google

 /*
  * Copyright (C) 2016 Google, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <cassert>
 #include <array>
 #include <iostream>
 #include <string>
 #include <sstream>
 #include <set>
 #include "Helpers.h"
 #include "Shell.h"
 #include "Game.h"

 Shell::Shell(Game &game)
     : game_(game), settings_(game.settings()), ctx_(), game_tick_(1.0f / settings_.ticks_per_second), game_time_(game_tick_) {
     // require generic WSI extensions
     instance_extensions_.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
     device_extensions_.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);

     if (settings_.validate) {
         instance_extensions_.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
     }
 }

 void Shell::log(LogPriority priority, const char *msg) {
     std::ostream &st = (priority >= LOG_ERR) ? std::cerr : std::cout;
     st << msg << "\n";
 }

 void Shell::init_vk() {
     vk::init_dispatch_table_top(load_vk());

     init_instance();
     vk::init_dispatch_table_middle(ctx_.instance, false);

     init_debug_report();
     init_physical_dev();
 }

 void Shell::cleanup_vk() {
     if (settings_.validate) vk::DestroyDebugReportCallbackEXT(ctx_.instance, ctx_.debug_report, nullptr);

     vk::DestroyInstance(ctx_.instance, nullptr);
 }

 bool Shell::debug_report_callback(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT obj_type, uint64_t object,
                                   size_t location, int32_t msg_code, const char *layer_prefix, const char *msg) {
     LogPriority prio = LOG_WARN;
     if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT)
         prio = LOG_ERR;
     else if (flags & (VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT))
         prio = LOG_WARN;
     else if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)
         prio = LOG_INFO;
     else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT)
         prio = LOG_DEBUG;

     std::stringstream ss;
     ss << layer_prefix << ": " << msg;

     log(prio, ss.str().c_str());

     return false;
 }

 void Shell::assert_all_instance_layers() const {
     // enumerate instance layer
     std::vector<VkLayerProperties> layers;
     vk::enumerate(layers);

     std::set<std::string> layer_names;
     for (const auto &layer : layers) layer_names.insert(layer.layerName);

     // all listed instance layers are required
     for (const auto &name : instance_layers_) {
         if (layer_names.find(name) == layer_names.end()) {
             std::stringstream ss;
             ss << "instance layer " << name << " is missing";
             throw std::runtime_error(ss.str());
         }
     }
 }

 void Shell::assert_all_instance_extensions() const {
     // enumerate instance extensions
     std::vector<VkExtensionProperties> exts;
     vk::enumerate(nullptr, exts);

     std::set<std::string> ext_names;
     for (const auto &ext : exts) ext_names.insert(ext.extensionName);

     // all listed instance extensions are required
     for (const auto &name : instance_extensions_) {
         if (ext_names.find(name) == ext_names.end()) {
             std::stringstream ss;
             ss << "instance extension " << name << " is missing";
             throw std::runtime_error(ss.str());
         }
     }
 }

 bool Shell::has_all_device_extensions(VkPhysicalDevice phy) const {
     // enumerate device extensions
     std::vector<VkExtensionProperties> exts;
     vk::enumerate(phy, nullptr, exts);

     std::set<std::string> ext_names;
     for (const auto &ext : exts) ext_names.insert(ext.extensionName);

     // all listed device extensions are required
     for (const auto &name : device_extensions_) {
         if (ext_names.find(name) == ext_names.end()) return false;
     }

     return true;
 }

 void Shell::init_instance() {
     assert_all_instance_layers();
     assert_all_instance_extensions();

     VkApplicationInfo app_info = {};
     app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
     app_info.pApplicationName = settings_.name.c_str();
     app_info.applicationVersion = 0;
     app_info.apiVersion = VK_API_VERSION_1_0;

     VkInstanceCreateInfo instance_info = {};
     instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     instance_info.pApplicationInfo = &app_info;
     instance_info.enabledLayerCount = static_cast<uint32_t>(instance_layers_.size());
     instance_info.ppEnabledLayerNames = instance_layers_.data();
     instance_info.enabledExtensionCount = static_cast<uint32_t>(instance_extensions_.size());
     instance_info.ppEnabledExtensionNames = instance_extensions_.data();

     vk::assert_success(vk::CreateInstance(&instance_info, nullptr, &ctx_.instance));
 }

 void Shell::init_debug_report() {
     if (!settings_.validate) return;

     VkDebugReportCallbackCreateInfoEXT debug_report_info = {};
     debug_report_info.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;

     debug_report_info.flags =
         VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT | VK_DEBUG_REPORT_ERROR_BIT_EXT;
     if (settings_.validate_verbose) {
         debug_report_info.flags = VK_DEBUG_REPORT_INFORMATION_BIT_EXT | VK_DEBUG_REPORT_DEBUG_BIT_EXT;
     }

     debug_report_info.pfnCallback = debug_report_callback;
     debug_report_info.pUserData = reinterpret_cast<void *>(this);

     vk::assert_success(vk::CreateDebugReportCallbackEXT(ctx_.instance, &debug_report_info, nullptr, &ctx_.debug_report));
 }

 void Shell::init_physical_dev() {
     // enumerate physical devices
     std::vector<VkPhysicalDevice> phys;
     vk::assert_success(vk::enumerate(ctx_.instance, phys));

     ctx_.physical_dev = VK_NULL_HANDLE;
     for (auto phy : phys) {
         if (!has_all_device_extensions(phy)) continue;

         // get queue properties
         std::vector<VkQueueFamilyProperties> queues;
         vk::get(phy, queues);

         int game_queue_family = -1, present_queue_family = -1;
         for (uint32_t i = 0; i < queues.size(); i++) {
             const VkQueueFamilyProperties &q = queues[i];

             // requires only GRAPHICS for game queues
             const VkFlags game_queue_flags = VK_QUEUE_GRAPHICS_BIT;
             if (game_queue_family < 0 && (q.queueFlags & game_queue_flags) == game_queue_flags) game_queue_family = i;

             // present queue must support the surface
             if (present_queue_family < 0 && can_present(phy, i)) present_queue_family = i;

             if (game_queue_family >= 0 && present_queue_family >= 0) break;
         }

         if (game_queue_family >= 0 && present_queue_family >= 0) {
             ctx_.physical_dev = phy;
             ctx_.game_queue_family = game_queue_family;
             ctx_.present_queue_family = present_queue_family;
             break;
         }
     }

     if (ctx_.physical_dev == VK_NULL_HANDLE) throw std::runtime_error("failed to find any capable Vulkan physical device");
 }

 void Shell::create_context() {
     create_dev();
     vk::init_dispatch_table_bottom(ctx_.instance, ctx_.dev);

     vk::GetDeviceQueue(ctx_.dev, ctx_.game_queue_family, 0, &ctx_.game_queue);
     vk::GetDeviceQueue(ctx_.dev, ctx_.present_queue_family, 0, &ctx_.present_queue);

     create_back_buffers();

     // initialize ctx_.{surface,format} before attach_shell
     create_swapchain();

     game_.attach_shell(*this);
 }

 void Shell::destroy_context() {
     if (ctx_.dev == VK_NULL_HANDLE) return;

     vk::DeviceWaitIdle(ctx_.dev);

     destroy_swapchain();

     game_.detach_shell();

     destroy_back_buffers();

     ctx_.game_queue = VK_NULL_HANDLE;
     ctx_.present_queue = VK_NULL_HANDLE;

     vk::DestroyDevice(ctx_.dev, nullptr);
     ctx_.dev = VK_NULL_HANDLE;
 }

 void Shell::create_dev() {
     VkDeviceCreateInfo dev_info = {};
     dev_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;

     const std::vector<float> queue_priorities(settings_.queue_count, 0.0f);
     std::array<VkDeviceQueueCreateInfo, 2> queue_info = {};
     queue_info[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
     queue_info[0].queueFamilyIndex = ctx_.game_queue_family;
     queue_info[0].queueCount = settings_.queue_count;
     queue_info[0].pQueuePriorities = queue_priorities.data();

     if (ctx_.game_queue_family != ctx_.present_queue_family) {
         queue_info[1].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
         queue_info[1].queueFamilyIndex = ctx_.present_queue_family;
         queue_info[1].queueCount = 1;
         queue_info[1].pQueuePriorities = queue_priorities.data();

         dev_info.queueCreateInfoCount = 2;
     } else {
         dev_info.queueCreateInfoCount = 1;
     }

     dev_info.pQueueCreateInfos = queue_info.data();

     dev_info.enabledExtensionCount = static_cast<uint32_t>(device_extensions_.size());
     dev_info.ppEnabledExtensionNames = device_extensions_.data();

     // disable all features
     VkPhysicalDeviceFeatures features = {};
     dev_info.pEnabledFeatures = &features;

     vk::assert_success(vk::CreateDevice(ctx_.physical_dev, &dev_info, nullptr, &ctx_.dev));
 }

 void Shell::create_back_buffers() {
     VkSemaphoreCreateInfo sem_info = {};
     sem_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;

     VkFenceCreateInfo fence_info = {};
     fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
     fence_info.flags = VK_FENCE_CREATE_SIGNALED_BIT;

     // BackBuffer is used to track which swapchain image and its associated
     // sync primitives are busy.  Having more BackBuffer's than swapchain
     // images may allows us to replace CPU wait on present_fence by GPU wait
     // on acquire_semaphore.
     const int count = settings_.back_buffer_count + 1;
     for (int i = 0; i < count; i++) {
         BackBuffer buf = {};
         vk::assert_success(vk::CreateSemaphore(ctx_.dev, &sem_info, nullptr, &buf.acquire_semaphore));
         vk::assert_success(vk::CreateSemaphore(ctx_.dev, &sem_info, nullptr, &buf.render_semaphore));
         vk::assert_success(vk::CreateFence(ctx_.dev, &fence_info, nullptr, &buf.present_fence));

         ctx_.back_buffers.push(buf);
     }
 }

 void Shell::destroy_back_buffers() {
     while (!ctx_.back_buffers.empty()) {
         const auto &buf = ctx_.back_buffers.front();

         vk::DestroySemaphore(ctx_.dev, buf.acquire_semaphore, nullptr);
         vk::DestroySemaphore(ctx_.dev, buf.render_semaphore, nullptr);
         vk::DestroyFence(ctx_.dev, buf.present_fence, nullptr);

         ctx_.back_buffers.pop();
     }
 }

 void Shell::create_swapchain() {
     ctx_.surface = create_surface(ctx_.instance);

     VkBool32 supported;
     vk::assert_success(
         vk::GetPhysicalDeviceSurfaceSupportKHR(ctx_.physical_dev, ctx_.present_queue_family, ctx_.surface, &supported));
     // this should be guaranteed by the platform-specific can_present call
     assert(supported);

     std::vector<VkSurfaceFormatKHR> formats;
     vk::get(ctx_.physical_dev, ctx_.surface, formats);
     ctx_.format = formats[0];

     // defer to resize_swapchain()
     ctx_.swapchain = VK_NULL_HANDLE;
     ctx_.extent.width = (uint32_t)-1;
     ctx_.extent.height = (uint32_t)-1;
 }

 void Shell::destroy_swapchain() {
     if (ctx_.swapchain != VK_NULL_HANDLE) {
         game_.detach_swapchain();

         vk::DestroySwapchainKHR(ctx_.dev, ctx_.swapchain, nullptr);
         ctx_.swapchain = VK_NULL_HANDLE;
     }

     vk::DestroySurfaceKHR(ctx_.instance, ctx_.surface, nullptr);
     ctx_.surface = VK_NULL_HANDLE;
 }

 void Shell::resize_swapchain(uint32_t width_hint, uint32_t height_hint) {
     VkSurfaceCapabilitiesKHR caps;
     vk::assert_success(vk::GetPhysicalDeviceSurfaceCapabilitiesKHR(ctx_.physical_dev, ctx_.surface, &caps));

     VkExtent2D extent = caps.currentExtent;
     // use the hints
     if (extent.width == (uint32_t)-1) {
         extent.width = width_hint;
         extent.height = height_hint;
     }
     // clamp width; to protect us from broken hints?
     if (extent.width < caps.minImageExtent.width)
         extent.width = caps.minImageExtent.width;
     else if (extent.width > caps.maxImageExtent.width)
         extent.width = caps.maxImageExtent.width;
     // clamp height
     if (extent.height < caps.minImageExtent.height)
         extent.height = caps.minImageExtent.height;
     else if (extent.height > caps.maxImageExtent.height)
         extent.height = caps.maxImageExtent.height;

     if (ctx_.extent.width == extent.width && ctx_.extent.height == extent.height) return;

     uint32_t image_count = settings_.back_buffer_count;
     if (image_count < caps.minImageCount)
         image_count = caps.minImageCount;
     else if (image_count > caps.maxImageCount)
         image_count = caps.maxImageCount;

     assert(caps.supportedUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
     assert(caps.supportedTransforms & caps.currentTransform);
     assert(caps.supportedCompositeAlpha & (VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR | VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR));
     VkCompositeAlphaFlagBitsKHR composite_alpha = (caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR)
                                                       ? VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
                                                       : VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;

     std::vector<VkPresentModeKHR> modes;
     vk::get(ctx_.physical_dev, ctx_.surface, modes);

     // FIFO is the only mode universally supported
     VkPresentModeKHR mode = VK_PRESENT_MODE_FIFO_KHR;
     for (auto m : modes) {
         if ((settings_.vsync && m == VK_PRESENT_MODE_MAILBOX_KHR) || (!settings_.vsync && m == VK_PRESENT_MODE_IMMEDIATE_KHR)) {
             mode = m;
             break;
         }
     }

     VkSwapchainCreateInfoKHR swapchain_info = {};
     swapchain_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
     swapchain_info.surface = ctx_.surface;
     swapchain_info.minImageCount = image_count;
     swapchain_info.imageFormat = ctx_.format.format;
     swapchain_info.imageColorSpace = ctx_.format.colorSpace;
     swapchain_info.imageExtent = extent;
     swapchain_info.imageArrayLayers = 1;
     swapchain_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;

     std::vector<uint32_t> queue_families(1, ctx_.game_queue_family);
     if (ctx_.game_queue_family != ctx_.present_queue_family) {
         queue_families.push_back(ctx_.present_queue_family);

         swapchain_info.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
         swapchain_info.queueFamilyIndexCount = (uint32_t)queue_families.size();
         swapchain_info.pQueueFamilyIndices = queue_families.data();
     } else {
         swapchain_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
     }

     swapchain_info.preTransform = caps.currentTransform;
     ;
     swapchain_info.compositeAlpha = composite_alpha;
     swapchain_info.presentMode = mode;
     swapchain_info.clipped = true;
     swapchain_info.oldSwapchain = ctx_.swapchain;

     vk::assert_success(vk::CreateSwapchainKHR(ctx_.dev, &swapchain_info, nullptr, &ctx_.swapchain));
     ctx_.extent = extent;

     // destroy the old swapchain
     if (swapchain_info.oldSwapchain != VK_NULL_HANDLE) {
         game_.detach_swapchain();

         vk::DeviceWaitIdle(ctx_.dev);
         vk::DestroySwapchainKHR(ctx_.dev, swapchain_info.oldSwapchain, nullptr);
     }

     game_.attach_swapchain();
 }

 void Shell::add_game_time(float time) {
     int max_ticks = 3;

     if (!settings_.no_tick) game_time_ += time;

     while (game_time_ >= game_tick_ && max_ticks--) {
         game_.on_tick();
         game_time_ -= game_tick_;
     }
 }

 void Shell::acquire_back_buffer() {
     // acquire just once when not presenting
     if (settings_.no_present && ctx_.acquired_back_buffer.acquire_semaphore != VK_NULL_HANDLE) return;

     auto &buf = ctx_.back_buffers.front();

     // wait until acquire and render semaphores are waited/unsignaled
     vk::assert_success(vk::WaitForFences(ctx_.dev, 1, &buf.present_fence, true, UINT64_MAX));
     // reset the fence
     vk::assert_success(vk::ResetFences(ctx_.dev, 1, &buf.present_fence));

     vk::assert_success(
         vk::AcquireNextImageKHR(ctx_.dev, ctx_.swapchain, UINT64_MAX, buf.acquire_semaphore, VK_NULL_HANDLE, &buf.image_index));

     ctx_.acquired_back_buffer = buf;
     ctx_.back_buffers.pop();
 }

 void Shell::present_back_buffer() {
     const auto &buf = ctx_.acquired_back_buffer;

     if (!settings_.no_render) game_.on_frame(game_time_ / game_tick_);

     if (settings_.no_present) {
         fake_present();
         return;
     }

     VkPresentInfoKHR present_info = {};
     present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
     present_info.waitSemaphoreCount = 1;
     present_info.pWaitSemaphores = (settings_.no_render) ? &buf.acquire_semaphore : &buf.render_semaphore;
     present_info.swapchainCount = 1;
     present_info.pSwapchains = &ctx_.swapchain;
     present_info.pImageIndices = &buf.image_index;

     vk::assert_success(vk::QueuePresentKHR(ctx_.present_queue, &present_info));

     vk::assert_success(vk::QueueSubmit(ctx_.present_queue, 0, nullptr, buf.present_fence));
     ctx_.back_buffers.push(buf);
 }

 void Shell::fake_present() {
     const auto &buf = ctx_.acquired_back_buffer;

     assert(settings_.no_present);

     // wait render semaphore and signal acquire semaphore
     if (!settings_.no_render) {
         VkPipelineStageFlags stage = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
         VkSubmitInfo submit_info = {};
         submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
         submit_info.waitSemaphoreCount = 1;
         submit_info.pWaitSemaphores = &buf.render_semaphore;
         submit_info.pWaitDstStageMask = &stage;
         submit_info.signalSemaphoreCount = 1;
         submit_info.pSignalSemaphores = &buf.acquire_semaphore;
         vk::assert_success(vk::QueueSubmit(ctx_.game_queue, 1, &submit_info, VK_NULL_HANDLE));
     }

     // push the buffer back just once for Shell::cleanup_vk
     if (buf.acquire_semaphore != ctx_.back_buffers.back().acquire_semaphore) ctx_.back_buffers.push(buf);
 }
	/*
	* Copyright (C) 2016 Google, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <cassert>
	#include <array>
	#include <iostream>
	#include <string>
	#include <sstream>
	#include <set>
	#include "Helpers.h"
	#include "Shell.h"
	#include "Game.h"

	Shell::Shell(Game &game)
	: game_(game), settings_(game.settings()), ctx_(), game_tick_(1.0f / settings_.ticks_per_second), game_time_(game_tick_) {
	// require generic WSI extensions
	instance_extensions_.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
	device_extensions_.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);

	if (settings_.validate) {
	instance_extensions_.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
	}
	}

	void Shell::log(LogPriority priority, const char *msg) {
	std::ostream &st = (priority >= LOG_ERR) ? std::cerr : std::cout;
	st << msg << "\n";
	}

	void Shell::init_vk() {
	vk::init_dispatch_table_top(load_vk());

	init_instance();
	vk::init_dispatch_table_middle(ctx_.instance, false);

	init_debug_report();
	init_physical_dev();
	}

	void Shell::cleanup_vk() {
	if (settings_.validate) vk::DestroyDebugReportCallbackEXT(ctx_.instance, ctx_.debug_report, nullptr);

	vk::DestroyInstance(ctx_.instance, nullptr);
	}

	bool Shell::debug_report_callback(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT obj_type, uint64_t object,
	size_t location, int32_t msg_code, const char layer_prefix, const char msg) {
	LogPriority prio = LOG_WARN;
	if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT)
	prio = LOG_ERR;
	else if (flags & (VK_DEBUG_REPORT_WARNING_BIT_EXT \| VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT))
	prio = LOG_WARN;
	else if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)
	prio = LOG_INFO;
	else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT)
	prio = LOG_DEBUG;

	std::stringstream ss;
	ss << layer_prefix << ": " << msg;

	log(prio, ss.str().c_str());

	return false;
	}

	void Shell::assert_all_instance_layers() const {
	// enumerate instance layer
	std::vector<VkLayerProperties> layers;
	vk::enumerate(layers);

	std::set<std::string> layer_names;
	for (const auto &layer : layers) layer_names.insert(layer.layerName);

	// all listed instance layers are required
	for (const auto &name : instance_layers_) {
	if (layer_names.find(name) == layer_names.end()) {
	std::stringstream ss;
	ss << "instance layer " << name << " is missing";
	throw std::runtime_error(ss.str());
	}
	}
	}

	void Shell::assert_all_instance_extensions() const {
	// enumerate instance extensions
	std::vector<VkExtensionProperties> exts;
	vk::enumerate(nullptr, exts);

	std::set<std::string> ext_names;
	for (const auto &ext : exts) ext_names.insert(ext.extensionName);

	// all listed instance extensions are required
	for (const auto &name : instance_extensions_) {
	if (ext_names.find(name) == ext_names.end()) {
	std::stringstream ss;
	ss << "instance extension " << name << " is missing";
	throw std::runtime_error(ss.str());
	}
	}
	}

	bool Shell::has_all_device_extensions(VkPhysicalDevice phy) const {
	// enumerate device extensions
	std::vector<VkExtensionProperties> exts;
	vk::enumerate(phy, nullptr, exts);

	std::set<std::string> ext_names;
	for (const auto &ext : exts) ext_names.insert(ext.extensionName);

	// all listed device extensions are required
	for (const auto &name : device_extensions_) {
	if (ext_names.find(name) == ext_names.end()) return false;
	}

	return true;
	}

	void Shell::init_instance() {
	assert_all_instance_layers();
	assert_all_instance_extensions();

	VkApplicationInfo app_info = {};
	app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
	app_info.pApplicationName = settings_.name.c_str();
	app_info.applicationVersion = 0;
	app_info.apiVersion = VK_API_VERSION_1_0;

	VkInstanceCreateInfo instance_info = {};
	instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
	instance_info.pApplicationInfo = &app_info;
	instance_info.enabledLayerCount = static_cast<uint32_t>(instance_layers_.size());
	instance_info.ppEnabledLayerNames = instance_layers_.data();
	instance_info.enabledExtensionCount = static_cast<uint32_t>(instance_extensions_.size());
	instance_info.ppEnabledExtensionNames = instance_extensions_.data();

	vk::assert_success(vk::CreateInstance(&instance_info, nullptr, &ctx_.instance));
	}

	void Shell::init_debug_report() {
	if (!settings_.validate) return;

	VkDebugReportCallbackCreateInfoEXT debug_report_info = {};
	debug_report_info.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;

	debug_report_info.flags =
	VK_DEBUG_REPORT_WARNING_BIT_EXT \| VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT \| VK_DEBUG_REPORT_ERROR_BIT_EXT;
	if (settings_.validate_verbose) {
	debug_report_info.flags = VK_DEBUG_REPORT_INFORMATION_BIT_EXT \| VK_DEBUG_REPORT_DEBUG_BIT_EXT;
	}

	debug_report_info.pfnCallback = debug_report_callback;
	debug_report_info.pUserData = reinterpret_cast<void *>(this);

	vk::assert_success(vk::CreateDebugReportCallbackEXT(ctx_.instance, &debug_report_info, nullptr, &ctx_.debug_report));
	}

	void Shell::init_physical_dev() {
	// enumerate physical devices
	std::vector<VkPhysicalDevice> phys;
	vk::assert_success(vk::enumerate(ctx_.instance, phys));

	ctx_.physical_dev = VK_NULL_HANDLE;
	for (auto phy : phys) {
	if (!has_all_device_extensions(phy)) continue;

	// get queue properties
	std::vector<VkQueueFamilyProperties> queues;
	vk::get(phy, queues);

	int game_queue_family = -1, present_queue_family = -1;
	for (uint32_t i = 0; i < queues.size(); i++) {
	const VkQueueFamilyProperties &q = queues[i];

	// requires only GRAPHICS for game queues
	const VkFlags game_queue_flags = VK_QUEUE_GRAPHICS_BIT;
	if (game_queue_family < 0 && (q.queueFlags & game_queue_flags) == game_queue_flags) game_queue_family = i;

	// present queue must support the surface
	if (present_queue_family < 0 && can_present(phy, i)) present_queue_family = i;

	if (game_queue_family >= 0 && present_queue_family >= 0) break;
	}

	if (game_queue_family >= 0 && present_queue_family >= 0) {
	ctx_.physical_dev = phy;
	ctx_.game_queue_family = game_queue_family;
	ctx_.present_queue_family = present_queue_family;
	break;
	}
	}

	if (ctx_.physical_dev == VK_NULL_HANDLE) throw std::runtime_error("failed to find any capable Vulkan physical device");
	}

	void Shell::create_context() {
	create_dev();
	vk::init_dispatch_table_bottom(ctx_.instance, ctx_.dev);

	vk::GetDeviceQueue(ctx_.dev, ctx_.game_queue_family, 0, &ctx_.game_queue);
	vk::GetDeviceQueue(ctx_.dev, ctx_.present_queue_family, 0, &ctx_.present_queue);

	create_back_buffers();

	// initialize ctx_.{surface,format} before attach_shell
	create_swapchain();

	game_.attach_shell(*this);
	}

	void Shell::destroy_context() {
	if (ctx_.dev == VK_NULL_HANDLE) return;

	vk::DeviceWaitIdle(ctx_.dev);

	destroy_swapchain();

	game_.detach_shell();

	destroy_back_buffers();

	ctx_.game_queue = VK_NULL_HANDLE;
	ctx_.present_queue = VK_NULL_HANDLE;

	vk::DestroyDevice(ctx_.dev, nullptr);
	ctx_.dev = VK_NULL_HANDLE;
	}

	void Shell::create_dev() {
	VkDeviceCreateInfo dev_info = {};
	dev_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;

	const std::vector<float> queue_priorities(settings_.queue_count, 0.0f);
	std::array<VkDeviceQueueCreateInfo, 2> queue_info = {};
	queue_info[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
	queue_info[0].queueFamilyIndex = ctx_.game_queue_family;
	queue_info[0].queueCount = settings_.queue_count;
	queue_info[0].pQueuePriorities = queue_priorities.data();

	if (ctx_.game_queue_family != ctx_.present_queue_family) {
	queue_info[1].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
	queue_info[1].queueFamilyIndex = ctx_.present_queue_family;
	queue_info[1].queueCount = 1;
	queue_info[1].pQueuePriorities = queue_priorities.data();

	dev_info.queueCreateInfoCount = 2;
	} else {
	dev_info.queueCreateInfoCount = 1;
	}

	dev_info.pQueueCreateInfos = queue_info.data();

	dev_info.enabledExtensionCount = static_cast<uint32_t>(device_extensions_.size());
	dev_info.ppEnabledExtensionNames = device_extensions_.data();

	// disable all features
	VkPhysicalDeviceFeatures features = {};
	dev_info.pEnabledFeatures = &features;

	vk::assert_success(vk::CreateDevice(ctx_.physical_dev, &dev_info, nullptr, &ctx_.dev));
	}

	void Shell::create_back_buffers() {
	VkSemaphoreCreateInfo sem_info = {};
	sem_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;

	VkFenceCreateInfo fence_info = {};
	fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
	fence_info.flags = VK_FENCE_CREATE_SIGNALED_BIT;

	// BackBuffer is used to track which swapchain image and its associated
	// sync primitives are busy. Having more BackBuffer's than swapchain
	// images may allows us to replace CPU wait on present_fence by GPU wait
	// on acquire_semaphore.
	const int count = settings_.back_buffer_count + 1;
	for (int i = 0; i < count; i++) {
	BackBuffer buf = {};
	vk::assert_success(vk::CreateSemaphore(ctx_.dev, &sem_info, nullptr, &buf.acquire_semaphore));
	vk::assert_success(vk::CreateSemaphore(ctx_.dev, &sem_info, nullptr, &buf.render_semaphore));
	vk::assert_success(vk::CreateFence(ctx_.dev, &fence_info, nullptr, &buf.present_fence));

	ctx_.back_buffers.push(buf);
	}
	}

	void Shell::destroy_back_buffers() {
	while (!ctx_.back_buffers.empty()) {
	const auto &buf = ctx_.back_buffers.front();

	vk::DestroySemaphore(ctx_.dev, buf.acquire_semaphore, nullptr);
	vk::DestroySemaphore(ctx_.dev, buf.render_semaphore, nullptr);
	vk::DestroyFence(ctx_.dev, buf.present_fence, nullptr);

	ctx_.back_buffers.pop();
	}
	}

	void Shell::create_swapchain() {
	ctx_.surface = create_surface(ctx_.instance);

	VkBool32 supported;
	vk::assert_success(
	vk::GetPhysicalDeviceSurfaceSupportKHR(ctx_.physical_dev, ctx_.present_queue_family, ctx_.surface, &supported));
	// this should be guaranteed by the platform-specific can_present call
	assert(supported);

	std::vector<VkSurfaceFormatKHR> formats;
	vk::get(ctx_.physical_dev, ctx_.surface, formats);
	ctx_.format = formats[0];

	// defer to resize_swapchain()
	ctx_.swapchain = VK_NULL_HANDLE;
	ctx_.extent.width = (uint32_t)-1;
	ctx_.extent.height = (uint32_t)-1;
	}

	void Shell::destroy_swapchain() {
	if (ctx_.swapchain != VK_NULL_HANDLE) {
	game_.detach_swapchain();

	vk::DestroySwapchainKHR(ctx_.dev, ctx_.swapchain, nullptr);
	ctx_.swapchain = VK_NULL_HANDLE;
	}

	vk::DestroySurfaceKHR(ctx_.instance, ctx_.surface, nullptr);
	ctx_.surface = VK_NULL_HANDLE;
	}

	void Shell::resize_swapchain(uint32_t width_hint, uint32_t height_hint) {
	VkSurfaceCapabilitiesKHR caps;
	vk::assert_success(vk::GetPhysicalDeviceSurfaceCapabilitiesKHR(ctx_.physical_dev, ctx_.surface, &caps));

	VkExtent2D extent = caps.currentExtent;
	// use the hints
	if (extent.width == (uint32_t)-1) {
	extent.width = width_hint;
	extent.height = height_hint;
	}
	// clamp width; to protect us from broken hints?
	if (extent.width < caps.minImageExtent.width)
	extent.width = caps.minImageExtent.width;
	else if (extent.width > caps.maxImageExtent.width)
	extent.width = caps.maxImageExtent.width;
	// clamp height
	if (extent.height < caps.minImageExtent.height)
	extent.height = caps.minImageExtent.height;
	else if (extent.height > caps.maxImageExtent.height)
	extent.height = caps.maxImageExtent.height;

	if (ctx_.extent.width == extent.width && ctx_.extent.height == extent.height) return;

	uint32_t image_count = settings_.back_buffer_count;
	if (image_count < caps.minImageCount)
	image_count = caps.minImageCount;
	else if (image_count > caps.maxImageCount)
	image_count = caps.maxImageCount;

	assert(caps.supportedUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
	assert(caps.supportedTransforms & caps.currentTransform);
	assert(caps.supportedCompositeAlpha & (VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR \| VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR));
	VkCompositeAlphaFlagBitsKHR composite_alpha = (caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR)
	? VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
	: VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;

	std::vector<VkPresentModeKHR> modes;
	vk::get(ctx_.physical_dev, ctx_.surface, modes);

	// FIFO is the only mode universally supported
	VkPresentModeKHR mode = VK_PRESENT_MODE_FIFO_KHR;
	for (auto m : modes) {
	if ((settings_.vsync && m == VK_PRESENT_MODE_MAILBOX_KHR) \|\| (!settings_.vsync && m == VK_PRESENT_MODE_IMMEDIATE_KHR)) {
	mode = m;
	break;
	}
	}

	VkSwapchainCreateInfoKHR swapchain_info = {};
	swapchain_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
	swapchain_info.surface = ctx_.surface;
	swapchain_info.minImageCount = image_count;
	swapchain_info.imageFormat = ctx_.format.format;
	swapchain_info.imageColorSpace = ctx_.format.colorSpace;
	swapchain_info.imageExtent = extent;
	swapchain_info.imageArrayLayers = 1;
	swapchain_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;

	std::vector<uint32_t> queue_families(1, ctx_.game_queue_family);
	if (ctx_.game_queue_family != ctx_.present_queue_family) {
	queue_families.push_back(ctx_.present_queue_family);

	swapchain_info.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
	swapchain_info.queueFamilyIndexCount = (uint32_t)queue_families.size();
	swapchain_info.pQueueFamilyIndices = queue_families.data();
	} else {
	swapchain_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
	}

	swapchain_info.preTransform = caps.currentTransform;
	;
	swapchain_info.compositeAlpha = composite_alpha;
	swapchain_info.presentMode = mode;
	swapchain_info.clipped = true;
	swapchain_info.oldSwapchain = ctx_.swapchain;

	vk::assert_success(vk::CreateSwapchainKHR(ctx_.dev, &swapchain_info, nullptr, &ctx_.swapchain));
	ctx_.extent = extent;

	// destroy the old swapchain
	if (swapchain_info.oldSwapchain != VK_NULL_HANDLE) {
	game_.detach_swapchain();

	vk::DeviceWaitIdle(ctx_.dev);
	vk::DestroySwapchainKHR(ctx_.dev, swapchain_info.oldSwapchain, nullptr);
	}

	game_.attach_swapchain();
	}

	void Shell::add_game_time(float time) {
	int max_ticks = 3;

	if (!settings_.no_tick) game_time_ += time;

	while (game_time_ >= game_tick_ && max_ticks--) {
	game_.on_tick();
	game_time_ -= game_tick_;
	}
	}

	void Shell::acquire_back_buffer() {
	// acquire just once when not presenting
	if (settings_.no_present && ctx_.acquired_back_buffer.acquire_semaphore != VK_NULL_HANDLE) return;

	auto &buf = ctx_.back_buffers.front();

	// wait until acquire and render semaphores are waited/unsignaled
	vk::assert_success(vk::WaitForFences(ctx_.dev, 1, &buf.present_fence, true, UINT64_MAX));
	// reset the fence
	vk::assert_success(vk::ResetFences(ctx_.dev, 1, &buf.present_fence));

	vk::assert_success(
	vk::AcquireNextImageKHR(ctx_.dev, ctx_.swapchain, UINT64_MAX, buf.acquire_semaphore, VK_NULL_HANDLE, &buf.image_index));

	ctx_.acquired_back_buffer = buf;
	ctx_.back_buffers.pop();
	}

	void Shell::present_back_buffer() {
	const auto &buf = ctx_.acquired_back_buffer;

	if (!settings_.no_render) game_.on_frame(game_time_ / game_tick_);

	if (settings_.no_present) {
	fake_present();
	return;
	}

	VkPresentInfoKHR present_info = {};
	present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
	present_info.waitSemaphoreCount = 1;
	present_info.pWaitSemaphores = (settings_.no_render) ? &buf.acquire_semaphore : &buf.render_semaphore;
	present_info.swapchainCount = 1;
	present_info.pSwapchains = &ctx_.swapchain;
	present_info.pImageIndices = &buf.image_index;

	vk::assert_success(vk::QueuePresentKHR(ctx_.present_queue, &present_info));

	vk::assert_success(vk::QueueSubmit(ctx_.present_queue, 0, nullptr, buf.present_fence));
	ctx_.back_buffers.push(buf);
	}

	void Shell::fake_present() {
	const auto &buf = ctx_.acquired_back_buffer;

	assert(settings_.no_present);

	// wait render semaphore and signal acquire semaphore
	if (!settings_.no_render) {
	VkPipelineStageFlags stage = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
	VkSubmitInfo submit_info = {};
	submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
	submit_info.waitSemaphoreCount = 1;
	submit_info.pWaitSemaphores = &buf.render_semaphore;
	submit_info.pWaitDstStageMask = &stage;
	submit_info.signalSemaphoreCount = 1;
	submit_info.pSignalSemaphores = &buf.acquire_semaphore;
	vk::assert_success(vk::QueueSubmit(ctx_.game_queue, 1, &submit_info, VK_NULL_HANDLE));
	}

	// push the buffer back just once for Shell::cleanup_vk
	if (buf.acquire_semaphore != ctx_.back_buffers.back().acquire_semaphore) ctx_.back_buffers.push(buf);
	}