CommonVK.cpp

#include "CommonVK.h"
 
#undef COGS_DECLARE_FUNCTION
#define COGS_DECLARE_FUNCTION(function) COGS_DEFINE_FUNCTION(function)
#include "FunctionsVK.h"
 
#include "TexturesVK.h"
 
HMODULE gModuleHandle;
 
void loaderInit()
{
#ifndef COGS_USE_VK_SDK
  gModuleHandle = ::LoadLibraryA("vulkan-1.dll");
 
  LOAD_FUNCTION(vkCreateInstance);
  LOAD_FUNCTION(vkEnumerateInstanceExtensionProperties);
  LOAD_FUNCTION(vkEnumerateInstanceLayerProperties);
  LOAD_FUNCTION(vkGetInstanceProcAddr);
  LOAD_FUNCTION(vkGetDeviceProcAddr);
#endif
}
 
void loaderInitInstance(VkInstance instance)
{
#ifndef COGS_USE_VK_SDK
  LOAD_INSTANCE_FUNCTION(vkCreateWin32SurfaceKHR);
 
  LOAD_INSTANCE_FUNCTION(vkGetPhysicalDeviceQueueFamilyProperties);
  LOAD_INSTANCE_FUNCTION(vkGetPhysicalDeviceMemoryProperties);
  LOAD_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties);
  LOAD_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures);
 
  LOAD_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceSupportKHR);
  LOAD_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
  LOAD_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceFormatsKHR);
  LOAD_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfacePresentModesKHR);
 
  LOAD_INSTANCE_FUNCTION(vkEnumeratePhysicalDevices);
 
  LOAD_INSTANCE_FUNCTION(vkEnumerateDeviceExtensionProperties);
  LOAD_INSTANCE_FUNCTION(vkEnumerateDeviceLayerProperties);
 
  LOAD_INSTANCE_FUNCTION(vkCreateDevice);
  LOAD_INSTANCE_FUNCTION(vkDestroyDevice);
 
  LOAD_INSTANCE_FUNCTION(vkGetDeviceQueue);
  LOAD_INSTANCE_FUNCTION(vkQueueSubmit);
  LOAD_INSTANCE_FUNCTION(vkQueueWaitIdle);
 
  LOAD_INSTANCE_FUNCTION(vkQueuePresentKHR);
  LOAD_INSTANCE_FUNCTION(vkCreateSwapchainKHR);
  LOAD_INSTANCE_FUNCTION(vkDestroySwapchainKHR);
  LOAD_INSTANCE_FUNCTION(vkGetSwapchainImagesKHR);
  LOAD_INSTANCE_FUNCTION(vkAcquireNextImageKHR);
#endif
}
 
void loaderInitDevice(VkInstance instance, VkDevice device)
{
#ifndef COGS_USE_VK_SDK
  LOAD_DEVICE_FUNCTION(vkDeviceWaitIdle);
 
  LOAD_DEVICE_FUNCTION(vkCreateCommandPool);
  LOAD_DEVICE_FUNCTION(vkDestroyCommandPool);
  LOAD_DEVICE_FUNCTION(vkAllocateCommandBuffers);
  LOAD_DEVICE_FUNCTION(vkFreeCommandBuffers);
 
  LOAD_DEVICE_FUNCTION(vkCreateImage);
  LOAD_DEVICE_FUNCTION(vkDestroyImage);
  LOAD_DEVICE_FUNCTION(vkCreateImageView);
  LOAD_DEVICE_FUNCTION(vkDestroyImageView);
 
  LOAD_DEVICE_FUNCTION(vkCreateSampler);
  LOAD_DEVICE_FUNCTION(vkDestroySampler);
 
  LOAD_DEVICE_FUNCTION(vkCreateBuffer);
  LOAD_DEVICE_FUNCTION(vkDestroyBuffer);
  LOAD_DEVICE_FUNCTION(vkCreateBufferView);
  LOAD_DEVICE_FUNCTION(vkDestroyBufferView);
 
  LOAD_DEVICE_FUNCTION(vkCreateDescriptorSetLayout);
  LOAD_DEVICE_FUNCTION(vkDestroyDescriptorSetLayout);
  LOAD_DEVICE_FUNCTION(vkCreatePipelineLayout);
  LOAD_DEVICE_FUNCTION(vkDestroyPipelineLayout);
  LOAD_DEVICE_FUNCTION(vkUpdateDescriptorSets);
 
  LOAD_DEVICE_FUNCTION(vkGetImageMemoryRequirements);
  LOAD_DEVICE_FUNCTION(vkGetBufferMemoryRequirements);
 
  LOAD_DEVICE_FUNCTION(vkGetImageSubresourceLayout);
 
  LOAD_DEVICE_FUNCTION(vkAllocateMemory);
  LOAD_DEVICE_FUNCTION(vkFreeMemory);
 
  LOAD_DEVICE_FUNCTION(vkBindImageMemory);
  LOAD_DEVICE_FUNCTION(vkCmdCopyImage);
 
  LOAD_DEVICE_FUNCTION(vkCmdPipelineBarrier);
 
  LOAD_DEVICE_FUNCTION(vkBeginCommandBuffer);
  LOAD_DEVICE_FUNCTION(vkEndCommandBuffer);
  LOAD_DEVICE_FUNCTION(vkResetCommandBuffer);
 
  LOAD_DEVICE_FUNCTION(vkCreateRenderPass);
  LOAD_DEVICE_FUNCTION(vkDestroyRenderPass);
 
  LOAD_DEVICE_FUNCTION(vkMapMemory);
  LOAD_DEVICE_FUNCTION(vkUnmapMemory);
 
  LOAD_DEVICE_FUNCTION(vkBindBufferMemory);
 
  LOAD_DEVICE_FUNCTION(vkCreateShaderModule);
  LOAD_DEVICE_FUNCTION(vkDestroyShaderModule);
 
  LOAD_DEVICE_FUNCTION(vkCreatePipelineCache);
  LOAD_DEVICE_FUNCTION(vkDestroyPipelineCache);
  LOAD_DEVICE_FUNCTION(vkCreateGraphicsPipelines);
 
  LOAD_DEVICE_FUNCTION(vkCreateDescriptorPool);
  LOAD_DEVICE_FUNCTION(vkDestroyDescriptorPool);
  LOAD_DEVICE_FUNCTION(vkResetDescriptorPool);
 
  LOAD_DEVICE_FUNCTION(vkAllocateDescriptorSets);
  LOAD_DEVICE_FUNCTION(vkFreeDescriptorSets);
 
  LOAD_DEVICE_FUNCTION(vkCreateFramebuffer);
  LOAD_DEVICE_FUNCTION(vkDestroyFramebuffer);
 
  LOAD_DEVICE_FUNCTION(vkCreateFence);
  LOAD_DEVICE_FUNCTION(vkDestroyFence);
  LOAD_DEVICE_FUNCTION(vkResetFences);
  LOAD_DEVICE_FUNCTION(vkGetFenceStatus);
  LOAD_DEVICE_FUNCTION(vkWaitForFences);
 
  LOAD_DEVICE_FUNCTION(vkCreateSemaphore);
  LOAD_DEVICE_FUNCTION(vkDestroySemaphore);
 
  LOAD_DEVICE_FUNCTION(vkCmdBeginRenderPass);
  LOAD_DEVICE_FUNCTION(vkCmdEndRenderPass);
 
  LOAD_DEVICE_FUNCTION(vkCmdBindPipeline);
  LOAD_DEVICE_FUNCTION(vkCmdBindDescriptorSets);
 
  LOAD_DEVICE_FUNCTION(vkCmdSetViewport);
  LOAD_DEVICE_FUNCTION(vkCmdSetScissor);
 
  LOAD_DEVICE_FUNCTION(vkCmdBindVertexBuffers);
  LOAD_DEVICE_FUNCTION(vkCmdBindIndexBuffer);
 
  LOAD_DEVICE_FUNCTION(vkCmdDraw);
  LOAD_DEVICE_FUNCTION(vkCmdDrawIndexed);
  LOAD_DEVICE_FUNCTION(vkCmdDrawIndirect);
  LOAD_DEVICE_FUNCTION(vkCmdDrawIndexedIndirect);
 
  LOAD_DEVICE_FUNCTION(vkCmdResolveImage);
#endif
}
 
bool Cogs::setImageLayout(VkCommandBuffer commandBuffer, VkImage image, VkImageAspectFlags aspectMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageSubresourceRange range)
{
  if (newLayout == oldLayout) return false;
 
  VkImageMemoryBarrier imageMemoryBarrier = {};
  imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
  imageMemoryBarrier.pNext = nullptr;
  imageMemoryBarrier.srcAccessMask = 0;
  imageMemoryBarrier.dstAccessMask = 0;
  imageMemoryBarrier.oldLayout = oldLayout;
  imageMemoryBarrier.newLayout = newLayout;
  imageMemoryBarrier.image = image;
  imageMemoryBarrier.subresourceRange = range;
  imageMemoryBarrier.subresourceRange.aspectMask = aspectMask;
 
  if (newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
    imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
  }
 
  if (newLayout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL) {
    imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
  }
 
  if (newLayout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) {
    imageMemoryBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
  }
 
  if (newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) {
    imageMemoryBarrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
  }
 
  if (newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
    imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
  }
 
  if (newLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) {
    imageMemoryBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
  }
 
  VkPipelineStageFlags sourceStages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
  VkPipelineStageFlags destinationStages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
 
  vkCmdPipelineBarrier(commandBuffer, sourceStages, destinationStages, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);
 
  return true;
}
 
bool Cogs::setImageLayout(VkCommandBuffer commandBuffer, TextureVK & texture, VkImageAspectFlags aspectMask, VkImageLayout newLayout, VkImageSubresourceRange range)
{
  if (setImageLayout(commandBuffer, texture.image, aspectMask, texture.layout, newLayout)) {
    texture.layout = newLayout;
    return true;
  }
 
  return false;
}