GraphicsDeviceVK.cpp

#include "GraphicsDeviceVK.h"
 
#include "Foundation/StringView.h"
#include "Foundation/Platform/WindowData.h"
 
#include <vector>
#include <cassert>
 
namespace
{
  HMODULE moduleHandle;
}
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("GraphicsDeviceVK");
 
  VkBool32 DebugCallback(VkDebugReportFlagsEXT flags,
    VkDebugReportObjectTypeEXT objectType,
    uint64_t object,
    size_t location,
    int32_t messageCode,
    const char * pLayerPrefix,
    const char * pMessage,
    void * pUserData)
  {
    const auto format = "[%s] %s";
 
    if (pMessage) {
      if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
        LOG_ERROR(logger, format, pLayerPrefix, pMessage);
      } else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
        LOG_WARNING(logger, format, pLayerPrefix, pMessage);
      } else if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) {
        LOG_INFO(logger, format, pLayerPrefix, pMessage);
      } else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) {
        LOG_DEBUG(logger, format, pLayerPrefix, pMessage);
      }
    }
 
    return true;
  }
}
 
bool Cogs::GraphicsDeviceVK::initializeInstance()
{
  loaderInit();
 
  uint32_t layerCount = 0;
  vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
 
  std::vector<VkLayerProperties> layers(layerCount);
  vkEnumerateInstanceLayerProperties(&layerCount, layers.data());
 
  uint32_t extensionCount = 0;
  vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
 
  std::vector<VkExtensionProperties> extensions(extensionCount);
  vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions.data());
 
  VkApplicationInfo applicationInfo = {
    VK_STRUCTURE_TYPE_APPLICATION_INFO,
    nullptr,
    "Cogs",
    2,
    "Cogs",
    2,
    VK_API_VERSION_1_0
  };
 
  std::vector<const char *> activeExtensions;
  std::vector<const char *> activeLayers;
 
  std::vector<StringView> desiredLayers = {
#ifdef _DEBUG
    //"VK_LAYER_LUNARG_standard_validation", // Performs SPIR-V validation.
    "VK_LAYER_LUNARG_threading",
    "VK_LAYER_LUNARG_mem_tracker",
    //"VK_LAYER_LUNARG_object_tracker",
    "VK_LAYER_LUNARG_draw_state",
    "VK_LAYER_LUNARG_param_checker",
    "VK_LAYER_LUNARG_swapchain",
    "VK_LAYER_LUNARG_device_limits",
    "VK_LAYER_LUNARG_image",
    "VK_LAYER_GOOGLE_unique_objects",
#endif
  };
 
  for (auto & layer : layers) {
    for (auto desiredLayer : desiredLayers) {
      if (desiredLayer == layer.layerName) {
        activeLayers.push_back(layer.layerName);
      }
    }
  }
 
  std::vector<StringView> desiredExtensions = {
    VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
    VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
    VK_KHR_SURFACE_EXTENSION_NAME
  };
 
  for (auto & extension : extensions) {
    for (auto & desiredExtension : desiredExtensions) {
      if (desiredExtension == extension.extensionName) {
        activeExtensions.push_back(extension.extensionName);
      }
    }
  }
 
  if (activeExtensions.size() != desiredExtensions.size()) {
    LOG_WARNING(logger, "Could not find all desired extensions.");
  }
 
  VkInstanceCreateInfo instanceInfo = {
    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, nullptr, 0,
    &applicationInfo,
    static_cast<uint32_t>(activeLayers.size()),
    activeLayers.data(),
    static_cast<uint32_t>(activeExtensions.size()),
    activeExtensions.data()
  };
 
  auto result = vkCreateInstance(&instanceInfo, nullptr, &instance);
 
  if (VK_FAILED(result) || !instance) {
    LOG_ERROR(logger, "Could not create Vulkan API instance.");
    return false;
  }
 
#ifndef COGS_USE_VK_SDK
  LOAD_INSTANCE_FUNCTION(vkCreateDebugReportCallbackEXT);
  LOAD_INSTANCE_FUNCTION(vkDebugReportMessageEXT);
 
  if (vkCreateDebugReportCallbackEXT) {
    VkDebugReportCallbackCreateInfoEXT reportCallbackInfo = {};
    reportCallbackInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
    reportCallbackInfo.pNext = nullptr;
    reportCallbackInfo.pfnCallback = DebugCallback;
    reportCallbackInfo.pUserData = this;
    reportCallbackInfo.flags = VK_DEBUG_REPORT_INFORMATION_BIT_EXT |
      VK_DEBUG_REPORT_WARNING_BIT_EXT |
      VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT |
      VK_DEBUG_REPORT_ERROR_BIT_EXT |
      VK_DEBUG_REPORT_DEBUG_BIT_EXT;
 
    VkDebugReportCallbackEXT reportCallback;
    result = vkCreateDebugReportCallbackEXT(instance, &reportCallbackInfo, nullptr, &reportCallback);
 
    if (result != VK_SUCCESS) {
      return false;
    }
 
    vkDebugReportMessageEXT(instance, VK_DEBUG_REPORT_DEBUG_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, 0, 0, 0, "Cogs", "Initialized debug callbacks.");
  }
#else
  instanceAssign(CreateDebugReportCallbackEXT, instance, "vkCreateDebugReportCallbackEXT");
  instanceAssign(DebugReportMessageEXT, instance, "vkDebugReportMessageEXT");
 
  if (CreateDebugReportCallbackEXT) {
    VkDebugReportCallbackCreateInfoEXT reportCallbackInfo = {};
    reportCallbackInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
    reportCallbackInfo.pNext = nullptr;
    reportCallbackInfo.pfnCallback = (PFN_vkDebugReportCallbackEXT)DebugCallback;
    reportCallbackInfo.pUserData = this;
    reportCallbackInfo.flags = VK_DEBUG_REPORT_INFORMATION_BIT_EXT |
      VK_DEBUG_REPORT_WARNING_BIT_EXT |
      VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT |
      VK_DEBUG_REPORT_ERROR_BIT_EXT |
      VK_DEBUG_REPORT_DEBUG_BIT_EXT;
 
    VkDebugReportCallbackEXT reportCallback;
    result = CreateDebugReportCallbackEXT(instance, &reportCallbackInfo, nullptr, &reportCallback);
 
    if (result != VK_SUCCESS) {
      return false;
    }
 
    DebugReportMessageEXT(instance, VK_DEBUG_REPORT_DEBUG_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, 0, 0, 0, "Cogs", "Initialized debug callbacks.");
  }
#endif
 
  loaderInitInstance(instance);
 
  return true;
}
 
bool Cogs::GraphicsDeviceVK::initializeDevice()
{
  uint32_t physicalDeviceCount = 0;
  vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, nullptr);
 
  std::vector<VkPhysicalDevice> physicalDevices(physicalDeviceCount);
  auto result = vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices.data());
 
  if (VK_FAILED(result)) {
    VK_LOG_ERROR(result, "Failed to enumerate physical devices.");
    return false;
  }
 
  if (!physicalDeviceCount) {
    LOG_ERROR(logger, "No physical devices available.");
    return false;
  }
 
  uint32_t queueFamilyIndex = 0;
 
  for (auto & physicalDevice : physicalDevices) {
    VkPhysicalDeviceFeatures features;
    vkGetPhysicalDeviceFeatures(physicalDevice, &features);
 
    uint32_t queueFamilyCount = 0;
    vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr);
 
    std::vector<VkQueueFamilyProperties> queueFamilyProperties(queueFamilyCount);
    vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilyProperties.data());
 
    for (size_t i = 0; i < queueFamilyProperties.size(); ++i) {
      if (queueFamilyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
        queueFamilyIndex = static_cast<uint32_t>(i);
        break;
      }
    }
 
    VkBool32 supported = 0;
    vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, 0, surface, &supported);
 
    if (!supported) {
      continue;
    }
 
    vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, &capabilities.surfaceCapabilities);
 
    uint32_t presentModeCount = 0;
    vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, &presentModeCount, nullptr);
 
    capabilities.presentModes.resize(presentModeCount);
    vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, &presentModeCount, capabilities.presentModes.data());
 
    uint32_t surfaceFormatCount = 0;
    vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, &surfaceFormatCount, nullptr);
 
    capabilities.surfaceFormats.resize(surfaceFormatCount);
    vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, &surfaceFormatCount, capabilities.surfaceFormats.data());
 
    if (true) { // Check if features are OK
      this->physicalDevice = physicalDevice;
      physicalDeviceFeatures = features;
      break;
    }
  }
 
  vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memoryProperties);
 
  VkPhysicalDeviceProperties deviceProperties;
  vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
 
  uint32_t layerCount = 0;
  vkEnumerateDeviceLayerProperties(physicalDevice, &layerCount, nullptr);
 
  std::vector<VkLayerProperties> layers;
  vkEnumerateDeviceLayerProperties(physicalDevice, &layerCount, layers.data());
 
  uint32_t extensionCount = 0;
  vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, nullptr);
 
  std::vector<VkExtensionProperties> deviceExtensions(extensionCount);
  vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, deviceExtensions.data());
 
  std::vector<const char *> activeLayers;
  std::vector<const char *> activeExtensions;
 
  for (auto & layer : layers) {
    activeLayers.push_back(layer.layerName);
  }
 
  bool foundKHRSwapchain = false;
  bool foundNVGLSL = false;
  for (auto & extension : deviceExtensions) {
    if (StringView(VK_KHR_SWAPCHAIN_EXTENSION_NAME) == extension.extensionName) {
      foundKHRSwapchain = true;
    } else if (StringView("VK_NV_glsl_shader") == extension.extensionName) {
      foundNVGLSL = true;
    }
 
    activeExtensions.push_back(extension.extensionName);
  }
 
  if (!foundKHRSwapchain) {
    LOG_ERROR(logger, "Could not find VK_KHR_SWAPCHAIN_EXTENSION.");
    return false;
  }
 
  if (!foundNVGLSL) {
    LOG_WARNING(logger, "Could not find VK_NV_glsl_shader. GLSL usage may fail.");
  }
 
  float priority = 1.0f;
 
  VkDeviceQueueCreateInfo queueCreateInfo = {
    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
    nullptr,
    0,
    queueFamilyIndex,
    1,
    &priority
  };
 
  VkDeviceCreateInfo createInfo = {
    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
    nullptr,
    0,
    1,
    &queueCreateInfo,
    static_cast<uint32_t>(activeLayers.size()),
    activeLayers.data(),
    static_cast<uint32_t>(activeExtensions.size()),
    activeExtensions.data(),
    &physicalDeviceFeatures
  };
 
  VkAllocationCallbacks allocator = {
    0
  };
 
  result = vkCreateDevice(physicalDevice, &createInfo, nullptr, &device);
 
  if (VK_FAILED(result)) {
    VK_LOG_ERROR(result, "Could not create Vulkan device.");
    return false;
  }
 
  vkGetDeviceQueue(device, 0, 0, &queue);
 
  loaderInitDevice(instance, device);
 
  return true;
}
 
bool Cogs::GraphicsDeviceVK::initializeSwapChain()
{
  vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, &capabilities.surfaceCapabilities);
 
  VkExtent2D swapchainExtent;
  swapchainExtent.width = std::min((uint32_t)width, capabilities.surfaceCapabilities.currentExtent.width);
  swapchainExtent.height = std::min((uint32_t)height, capabilities.surfaceCapabilities.currentExtent.height);;
 
  VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
 
  uint32_t desiredNumberOfSwapchainImages = 3;
 
  auto oldSwapchain = swapChain;
 
  VkSwapchainCreateInfoKHR swapChainInfo = {};
  swapChainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
  swapChainInfo.pNext = nullptr;
  swapChainInfo.surface = surface;
  swapChainInfo.minImageCount = desiredNumberOfSwapchainImages;
  swapChainInfo.imageFormat = VK_FORMAT_B8G8R8A8_UNORM;
  swapChainInfo.imageColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
  swapChainInfo.imageExtent = swapchainExtent;
  swapChainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
  swapChainInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
  swapChainInfo.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
  swapChainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
  swapChainInfo.imageArrayLayers = 1;
  swapChainInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
  swapChainInfo.queueFamilyIndexCount = 0;
  swapChainInfo.pQueueFamilyIndices = nullptr;
  swapChainInfo.presentMode = swapchainPresentMode;
  swapChainInfo.oldSwapchain = oldSwapchain;
  swapChainInfo.clipped = true;
 
  auto result = vkCreateSwapchainKHR(device, &swapChainInfo, nullptr, &swapChain);
 
  if (VK_FAILED(result)) {
    VK_LOG_ERROR(result, "Could not create swap chain.");
    return false;
  }
 
  uint32_t numSwapChainImages = 0;
  vkGetSwapchainImagesKHR(device, swapChain, &numSwapChainImages, nullptr);
 
  swapChainImages.resize(numSwapChainImages);
  vkGetSwapchainImagesKHR(device, swapChain, &numSwapChainImages, swapChainImages.data());
 
  backBuffers.resize(numSwapChainImages);
 
  if (settings.numSamples > 1) {
    backBuffersMS.resize(numSwapChainImages);
  }
 
  for (uint32_t i = 0; i < numSwapChainImages; ++i) {
    backBuffers[i] = textures.loadTexture((uint8_t *)swapChainImages[i], width, height, TextureFormat::B8G8R8A8, TextureFlags::ExternalTexture | TextureFlags::RenderTarget);
 
    if (settings.numSamples > 1) {
      backBuffersMS[i] = textures.loadTexture(nullptr, width, height, TextureFormat::R8G8B8A8_UNORM, settings.numSamples, TextureFlags::RenderTarget);
    }
 
    if (!HandleIsValid(backBuffers[i])) {
      LOG_ERROR(logger, "Failed creating back buffer texture wrappers.");
    }
  }
 
  return true;
}
 
bool Cogs::GraphicsDeviceVK::initializeCommandPool()
{
  const VkCommandPoolCreateInfo commandPoolInfo = {
    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
    nullptr,
    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
    0,
  };
 
  auto result = vkCreateCommandPool(device, &commandPoolInfo, nullptr, &commandPool);
 
  if (VK_FAILED(result)) {
    VK_LOG_ERROR(result, "Could not create command pool.");
    return false;
  }
 
  return true;
}
 
Cogs::GraphicsDeviceVK::GraphicsDeviceVK(RenderingAllocatorInfo * allocator)
{
}
 
bool Cogs::GraphicsDeviceVK::initialize()
{
  if (!initializeInstance()) {
    LOG_ERROR(logger, "Could not initialize instance.");
    return false;
  }
 
  VkWin32SurfaceCreateInfoKHR surfaceCreateInfo = {};
  surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
  surfaceCreateInfo.pNext = nullptr;
  surfaceCreateInfo.flags = 0;
  surfaceCreateInfo.hinstance = ::GetModuleHandle(0);
  surfaceCreateInfo.hwnd = settings.windowData->windowHandle;
 
  auto result = vkCreateWin32SurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface);
 
  if (VK_FAILED(result)) {
    VK_LOG_ERROR(result, "Could not create surface.");
    return false;
  }
 
  if (!initializeDevice()) {
    LOG_ERROR(logger, "Could not initialize device.");
    return false;
  }
 
  buffers.initialize(this);
  textures.initialize(this);
  renderTargets.initialize(this);
 
  if (!initializeSwapChain()) {
    LOG_ERROR(logger, "Could not initialize swap chain.");
    return false;
  }
 
  if (!initializeCommandPool()) {
    LOG_ERROR(logger, "Could not initialize command pool.");
    return false;
  }
 
  context.initialize(this);
  buffers.graphicsDevice = this;
  effects.initialize(this);
 
  if (settings.ioHandler) effects.setIOHandler(settings.ioHandler);
 
  if (!initializeDepth()) {
    return false;
  }
 
  if (!initializeFramebuffers()) {
    return false;
  }
 
  return true;
}
 
bool Cogs::GraphicsDeviceVK::initializeDepth()
{
  depthTextureHandle = textures.loadTexture(nullptr, width, height, settings.depthFormat, settings.numSamples, TextureFlags::DepthBuffer);
 
  return true;
}
 
void Cogs::GraphicsDeviceVK::flushSetup()
{
  if (setupCommands == VK_NULL_HANDLE) {
    return;
  }
 
  auto result = vkEndCommandBuffer(setupCommands);
  assert(!result);
 
  const VkCommandBuffer commandBuffers[] = { setupCommands };
 
  VkSubmitInfo submitInfo = {};
  submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
  submitInfo.commandBufferCount = 1;
  submitInfo.pCommandBuffers = commandBuffers;
 
  result = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
  assert(!result);
 
  result = vkQueueWaitIdle(queue);
  assert(!result);
 
  vkFreeCommandBuffers(device, commandPool, 1, commandBuffers);
 
  setupCommands = VK_NULL_HANDLE;
}
 
bool Cogs::GraphicsDeviceVK::initializeFramebuffers()
{
  framebuffers.resize(swapChainImages.size());
 
  for (size_t i = 0; i < swapChainImages.size(); i++) {
    if (settings.numSamples == 1) {
      framebuffers[i] = renderTargets.createRenderTarget(backBuffers[i]);
    } else {
      framebuffers[i] = renderTargets.createRenderTarget(backBuffersMS[i]);
    }
 
    auto dsv = renderTargets.createDepthStencilTarget(framebuffers[i], depthTextureHandle);
 
    if (!HandleIsValid(framebuffers[i]) || !HandleIsValid(dsv)) {
      LOG_ERROR(logger, "Failed creating render targets.");
    }
  }
 
  return true;
}
 
bool Cogs::GraphicsDeviceVK::getMemoryType(uint32_t typeBits, VkFlags requirementsMask, uint32_t * typeIndex)
{
  for (uint32_t i = 0; i < 32; i++) {
    if ((typeBits & 1) == 1) {
      // Type is available, does it match user properties?
      if ((memoryProperties.memoryTypes[i].propertyFlags &
        requirementsMask) == requirementsMask) {
        *typeIndex = i;
        return true;
      }
    }
    typeBits >>= 1;
  }
 
  return false;
}
 
void Cogs::GraphicsDeviceVK::setSize(int width, int height)
{
  if (width == this->width && height == this->height) return;
 
  this->width = width;
  this->height = height;
 
  needsResize = true;
}
 
bool Cogs::GraphicsDeviceVK::getSize(int& width, int& height) const
{
  width = this->width;
  height = this->height;
  return true;
}
 
void Cogs::GraphicsDeviceVK::beginFrame()
{
  VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = {
    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
    nullptr,
    0,
  };
 
  auto err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
 
  assert(!err);
 
  if (needsResize) {
    resize();
  }
 
  err = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, presentCompleteSemaphore,
    (VkFence)0,
    &currentFrameBuffer);
 
  context.defaultRenderTarget = framebuffers[currentFrameBuffer];
 
  flushSetup();
 
  context.beginFrame();
 
  if (context.currentFrameResources->presentSemaphore) {
    vkDestroySemaphore(device, context.currentFrameResources->presentSemaphore, nullptr);
  }
 
  context.currentFrameResources->presentSemaphore = presentCompleteSemaphore;
}
 
void Cogs::GraphicsDeviceVK::endFrame(uint32_t syncInterval, uint32_t presentFlags)
{
  flushSetup();
 
  context.endFrame();
 
  VkPipelineStageFlags stageFlags = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
 
  VkSubmitInfo submitInfo = {};
  submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
  submitInfo.pNext = nullptr;
  submitInfo.waitSemaphoreCount = 1;
  submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
  submitInfo.pWaitDstStageMask = &stageFlags;
  submitInfo.commandBufferCount = 1;
  submitInfo.pCommandBuffers = &context.currentFrameResources->commandBuffer;
  submitInfo.signalSemaphoreCount = 0;
  submitInfo.pSignalSemaphores = nullptr;
 
  auto err = vkQueueSubmit(queue, 1, &submitInfo, context.currentFrameResources->fence);
 
  if (VK_FAILED(err)) {
    VK_LOG_ERROR(err, "Queue submit failed.");
  }
 
  context.currentFrameResources = nullptr;
 
  VkPresentInfoKHR presentInfo = {
    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
    nullptr,
    0,
    nullptr,
    1,
    &swapChain,
    &currentFrameBuffer,
    nullptr
  };
 
  vkQueuePresentKHR(queue, &presentInfo);
 
  ++currentFrameBuffer;
  if (currentFrameBuffer > 1) currentFrameBuffer = 0;
}
 
void Cogs::GraphicsDeviceVK::waitForCommandSync()
{
  assert(false);
}
 
void Cogs::GraphicsDeviceVK::releaseResources()
{
}
 
Cogs::ISwapChain * Cogs::GraphicsDeviceVK::getDefaultSwapChain()
{
  assert(false);
  return nullptr;
}
 
VkCommandBuffer Cogs::GraphicsDeviceVK::getCommandBuffer()
{
  if (context.currentFrameResources) {
    return context.currentFrameResources->commandBuffer;
  } else {
    if (setupCommands == VK_NULL_HANDLE) {
      VkCommandBufferAllocateInfo cmd = {};
      cmd.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
      cmd.pNext = nullptr;
      cmd.commandPool = commandPool;
      cmd.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
      cmd.commandBufferCount = 1;
 
      auto result = vkAllocateCommandBuffers(device, &cmd, &setupCommands);
 
      if (VK_FAILED(result)) {
        VK_LOG_ERROR(result, "Failed to allocate setup command buffer.");
        return VK_NULL_HANDLE;
      }
 
      VkCommandBufferBeginInfo commandBufferInfo = {};
      commandBufferInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
      commandBufferInfo.pNext = nullptr;
      commandBufferInfo.flags = 0;
      commandBufferInfo.pInheritanceInfo = nullptr;
 
      result = vkBeginCommandBuffer(setupCommands, &commandBufferInfo);
    }
 
    return setupCommands;
  }
}
 
void Cogs::GraphicsDeviceVK::resize()
{
  vkDeviceWaitIdle(device);
 
  for (auto & frameBuffer : framebuffers) {
    renderTargets.releaseRenderTarget(frameBuffer);
  }
 
  framebuffers.clear();
 
  for (auto & t : backBuffers) {
    textures.releaseTexture(t);
  }
 
  backBuffers.clear();
 
  textures.releaseTexture(depthTextureHandle);
 
  initializeSwapChain();
  initializeDepth();
  initializeFramebuffers();
 
  needsResize = false;
}