452 lines
15 KiB
C++
452 lines
15 KiB
C++
/*
|
|
* GLFW_INCLUDE_VULKAN will include its own definitions and
|
|
* automatically load the Vulkan header with it.
|
|
*
|
|
* The stdexcept and iostream headers are included for reporting and
|
|
* propagating errors. The cstdlib header provides the EXIT_SUCCESS
|
|
* and EXIT_FAILURE macros.
|
|
*/
|
|
|
|
#define GLFW_INCLUDE_VULKAN
|
|
#include <GLFW/glfw3.h>
|
|
#include <iostream>
|
|
#include <stdexcept>
|
|
#include <vector>
|
|
#include <cstring>
|
|
#include <cstdlib>
|
|
#include <optional>
|
|
#include <set>
|
|
|
|
const uint32_t WIDTH = 800;
|
|
const uint32_t HEIGHT = 600;
|
|
|
|
/*
|
|
* All of the useful standard validation is bundled into a layer
|
|
* included in the SDK that is known as VK_LAYER_KHRONOS_validation.
|
|
*/
|
|
|
|
const std::vector<const char*> validationLayers = {
|
|
"VK_LAYER_KHRONOS_validation"
|
|
};
|
|
|
|
/*
|
|
* The NDEBUG macro is part of the C++ standard and means "not debug".
|
|
* Base that value on whether the program is being compiled in debug
|
|
* mode or not.
|
|
*/
|
|
|
|
#ifdef NDEBUG
|
|
const bool enableValidationLayers = false;
|
|
#else
|
|
const bool enableValidationLayers = true;
|
|
#endif
|
|
|
|
/*
|
|
* Proxy function that handles looks up the address of
|
|
* VkDebugUtilsMessengerEXT using vkGetInstanceProcAddr.
|
|
*/
|
|
|
|
VkResult CreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger) {
|
|
auto func = (PFN_vkCreateDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
|
|
if (func != nullptr) {
|
|
return func(instance, pCreateInfo, pAllocator, pDebugMessenger);
|
|
} else {
|
|
return VK_ERROR_EXTENSION_NOT_PRESENT;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Proxy function that handles cleaning up the
|
|
* VkDebugUtilsMessengerEXT object.
|
|
*/
|
|
|
|
void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator) {
|
|
auto func = (PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
|
|
if (func != nullptr) {
|
|
func(instance, debugMessenger, pAllocator);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* It has been briefly touched upon before that almost every operation in Vulkan,
|
|
* anything from drawing to uploading textures, requires commands to be submitted
|
|
* to a queue. There are different types of queues that originate from different
|
|
* queue families and each family of queues allows only a subset of commands.
|
|
* For example, there could be a queue family that only allows processing of compute
|
|
* commands or one that only allows memory transfer related commands.
|
|
* We need to check which queue families are supported by the device and which
|
|
* one of these supports the commands that we want to use. For that purpose we'll
|
|
* add a new function findQueueFamilies that looks for all the queue families
|
|
* we need.
|
|
*/
|
|
|
|
struct QueueFamilyIndices {
|
|
|
|
/*
|
|
* std::optional is a wrapper that contains no value until you assign something
|
|
* to it. At any point you can query if it contains a value or not by calling
|
|
* its has_value() member function.
|
|
*/
|
|
|
|
std::optional<uint32_t> graphicsFamily;
|
|
std::optional<uint32_t> presentFamily;
|
|
|
|
bool isComplete() {
|
|
return graphicsFamily.has_value() && presentFamily.has_value();
|
|
}
|
|
};
|
|
|
|
/*
|
|
* The program itself is wrapped into a class where we'll store the
|
|
* Vulkan objects as private class members and add functions to
|
|
* initiate each of them, which will be called from the initVulkan
|
|
* function.
|
|
*/
|
|
|
|
class Application {
|
|
public:
|
|
void run() {
|
|
initWindow();
|
|
initVulkan();
|
|
mainLoop();
|
|
cleanup();
|
|
}
|
|
|
|
private:
|
|
GLFWwindow* window; // Member to store a reference to it and initialize the window
|
|
|
|
VkInstance instance; // Data member to hold the handle to the instance
|
|
VkDebugUtilsMessengerEXT debugMessenger;
|
|
VkSurfaceKHR surface;
|
|
|
|
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
|
|
VkDevice device;
|
|
|
|
VkQueue graphicsQueue; // Class member to store a handle to the graphics queue
|
|
VkQueue presentQueue;
|
|
|
|
void initWindow() {
|
|
glfwInit();
|
|
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
|
|
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
|
|
|
|
window = glfwCreateWindow(
|
|
WIDTH,
|
|
HEIGHT,
|
|
"@@@ Window Name",
|
|
nullptr,
|
|
nullptr
|
|
);
|
|
}
|
|
|
|
void initVulkan() {
|
|
createInstance();
|
|
setupDebugMessenger();
|
|
createSurface();
|
|
pickPhysicalDevice();
|
|
createLogicalDevice();
|
|
}
|
|
|
|
void mainLoop() {
|
|
while (!glfwWindowShouldClose(window)) {
|
|
glfwPollEvents();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Once the window is closed and mainLoop returns,
|
|
* we'll make sure to deallocate the resources.
|
|
*/
|
|
|
|
void cleanup() {
|
|
vkDestroyDevice(device, nullptr); // Destroy logical device
|
|
|
|
if (enableValidationLayers) {
|
|
DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);
|
|
}
|
|
|
|
vkDestroySurfaceKHR(instance, surface, nullptr);
|
|
vkDestroyInstance(instance, nullptr);
|
|
|
|
glfwDestroyWindow(window);
|
|
glfwTerminate();
|
|
}
|
|
|
|
void createInstance() {
|
|
if (enableValidationLayers && !checkValidationLayerSupport()) {
|
|
throw std::runtime_error("validation layers requested, but not available!");
|
|
}
|
|
|
|
/*
|
|
* Struct with some information about our application. This data is technically
|
|
* optional, but it may provide some useful information to the driver in order
|
|
* to optimize our specific application (e.g. because it uses a well-known
|
|
* graphics engine with certain special behavior).
|
|
*/
|
|
|
|
VkApplicationInfo gameInfo{};
|
|
gameInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
|
|
gameInfo.pApplicationName = "@@@ Application Name";
|
|
gameInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
|
|
gameInfo.pEngineName = "No Engine";
|
|
gameInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
|
|
gameInfo.apiVersion = VK_API_VERSION_1_0;
|
|
|
|
VkInstanceCreateInfo createInfo{};
|
|
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
|
createInfo.pApplicationInfo = &gameInfo;
|
|
|
|
auto extensions = getRequiredExtensions();
|
|
createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
|
|
createInfo.ppEnabledExtensionNames = extensions.data();
|
|
|
|
/*
|
|
* If the check was successful then vkCreateInstance should not ever return
|
|
* a VK_ERROR_LAYER_NOT_PRESENT error.
|
|
*/
|
|
|
|
VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{};
|
|
if (enableValidationLayers) {
|
|
createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
|
|
createInfo.ppEnabledLayerNames = validationLayers.data();
|
|
|
|
populateDebugMessengerCreateInfo(debugCreateInfo);
|
|
createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT*) &debugCreateInfo;
|
|
} else {
|
|
createInfo.enabledLayerCount = 0;
|
|
createInfo.pNext = nullptr;
|
|
}
|
|
|
|
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create instance!");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This struct should be passed to the vkCreateDebugUtilsMessengerEXT
|
|
* function to create the VkDebugUtilsMessengerEXT object. Unfortunately,
|
|
* because this function is an extension function, it is not automatically
|
|
* loaded. We use a proxy function, VkResult.
|
|
*/
|
|
|
|
void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) {
|
|
createInfo = {};
|
|
createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
|
|
createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
|
|
createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
|
|
createInfo.pfnUserCallback = debugCallback;
|
|
}
|
|
|
|
void setupDebugMessenger() {
|
|
if (!enableValidationLayers) return;
|
|
|
|
VkDebugUtilsMessengerCreateInfoEXT createInfo;
|
|
populateDebugMessengerCreateInfo(createInfo);
|
|
|
|
if (CreateDebugUtilsMessengerEXT(instance, &createInfo, nullptr, &debugMessenger) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to set up debug messenger!");
|
|
}
|
|
}
|
|
|
|
void createSurface() {
|
|
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create window surface!");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Select a physical device
|
|
*/
|
|
|
|
void pickPhysicalDevice() {
|
|
uint32_t deviceCount = 0;
|
|
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
|
|
|
|
if (deviceCount == 0) {
|
|
throw std::runtime_error("failed to find GPUs with Vulkan support!");
|
|
}
|
|
|
|
std::vector<VkPhysicalDevice> devices(deviceCount);
|
|
vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
|
|
|
|
for (const auto& device : devices) {
|
|
if (isDeviceSuitable(device)) {
|
|
physicalDevice = device;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Check if any of the physical devices meet the requirements
|
|
*/
|
|
|
|
if (physicalDevice == VK_NULL_HANDLE) {
|
|
throw std::runtime_error("failed to find a suitable GPU!");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Check if any of the physical devices meet the requirements
|
|
*/
|
|
|
|
void createLogicalDevice() {
|
|
QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
|
|
|
|
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
|
|
std::set<uint32_t> uniqueQueueFamilies = {indices.graphicsFamily.value(), indices.presentFamily.value()};
|
|
|
|
float queuePriority = 1.0f;
|
|
for (uint32_t queueFamily : uniqueQueueFamilies) {
|
|
VkDeviceQueueCreateInfo queueCreateInfo{};
|
|
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
|
|
queueCreateInfo.queueFamilyIndex = queueFamily;
|
|
queueCreateInfo.queueCount = 1;
|
|
queueCreateInfo.pQueuePriorities = &queuePriority;
|
|
queueCreateInfos.push_back(queueCreateInfo);
|
|
}
|
|
|
|
VkPhysicalDeviceFeatures deviceFeatures{};
|
|
|
|
VkDeviceCreateInfo createInfo{};
|
|
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
|
|
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
|
|
createInfo.pQueueCreateInfos = queueCreateInfos.data();
|
|
createInfo.pEnabledFeatures = &deviceFeatures;
|
|
createInfo.enabledExtensionCount = 0;
|
|
|
|
if (enableValidationLayers) {
|
|
createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
|
|
createInfo.ppEnabledLayerNames = validationLayers.data();
|
|
} else {
|
|
createInfo.enabledLayerCount = 0;
|
|
}
|
|
|
|
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create logical device!");
|
|
}
|
|
|
|
vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
|
|
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
|
|
}
|
|
|
|
bool isDeviceSuitable(VkPhysicalDevice device) {
|
|
QueueFamilyIndices indices = findQueueFamilies(device);
|
|
|
|
return indices.isComplete();
|
|
}
|
|
|
|
QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device) {
|
|
QueueFamilyIndices indices;
|
|
|
|
uint32_t queueFamilyCount = 0;
|
|
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
|
|
|
|
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
|
|
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
|
|
|
|
int i = 0;
|
|
for (const auto& queueFamily : queueFamilies) {
|
|
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
|
|
indices.graphicsFamily = i;
|
|
}
|
|
|
|
VkBool32 presentSupport = false;
|
|
vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
|
|
|
|
if (presentSupport) {
|
|
indices.presentFamily = i;
|
|
}
|
|
|
|
if (indices.isComplete()) {
|
|
break;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
return indices;
|
|
}
|
|
|
|
std::vector<const char*> getRequiredExtensions() {
|
|
|
|
/*
|
|
* Vulkan is a platform agnostic API, which means that you need
|
|
* an extension to interface with the window system. GLFW has a
|
|
* handy built-in function that returns the extension(s) it needs
|
|
* to do that.
|
|
*/
|
|
|
|
uint32_t glfwExtensionCount = 0;
|
|
const char** glfwExtensions;
|
|
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
|
|
|
|
std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);
|
|
|
|
if (enableValidationLayers) {
|
|
extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
|
|
}
|
|
|
|
return extensions;
|
|
}
|
|
|
|
/*
|
|
* checkValidationLayerSupport checks if all of the requested layers
|
|
* are available. First list all of the available layers using the
|
|
* vkEnumerateInstanceLayerProperties function.
|
|
*/
|
|
|
|
bool checkValidationLayerSupport() {
|
|
uint32_t layerCount;
|
|
vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
|
|
|
|
std::vector<VkLayerProperties> availableLayers(layerCount);
|
|
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
|
|
|
|
/*
|
|
* Check if all of the layers in validationLayers exist in the
|
|
* availableLayers list.
|
|
*/
|
|
|
|
for (const char* layerName : validationLayers) {
|
|
bool layerFound = false;
|
|
|
|
for (const auto& layerProperties : availableLayers) {
|
|
if (strcmp(layerName, layerProperties.layerName) == 0) {
|
|
layerFound = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!layerFound) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData) {
|
|
std::cerr << "validation layer: " << pCallbackData->pMessage << std::endl;
|
|
|
|
return VK_FALSE;
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Enter the main loop to start rendering frames. We'll fill in
|
|
* the mainLoop function to include a loop that iterates until
|
|
* the window is closed.
|
|
*/
|
|
|
|
int main() {
|
|
Application game;
|
|
|
|
try {
|
|
game.run();
|
|
} catch (const std::exception& e) {
|
|
std::cerr << e.what() << std::endl;
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|