1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
#include <cstdio>
#include <vector>
#include "window.hpp"
#define NELEMS(x) (sizeof(x) / sizeof((x)[0]))
GLFWwindow *window = nullptr;
VkInstance vkInstance = nullptr;
VkPhysicalDevice vkPhysicalDevice = nullptr;
VkSurfaceKHR vkSurfaceKHR = nullptr;
const bool ENABLE_VALIDATION_LAYERS = true;
VkBool32 UserDebugCallback(
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VkDebugUtilsMessageTypeFlagsEXT messageType,
const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData, void *pUserData) {
printf("Validation Layer: %s\n", pCallbackData->pMessage);
return VK_FALSE;
}
void InitVulkan() {
if (ENABLE_VALIDATION_LAYERS) {
unsigned int layerCount;
vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
std::vector<VkLayerProperties> availableLayers(layerCount);
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
printf("Available Layers:\n");
for (const auto &layerProperties : availableLayers) {
printf("\t%s\n", layerProperties.layerName);
}
}
VkApplicationInfo appInfo{};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.apiVersion = VK_API_VERSION_1_3;
appInfo.pApplicationName = "pikul";
appInfo.pEngineName = "pikul";
appInfo.applicationVersion = 1;
appInfo.engineVersion = 1;
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
createInfo.enabledLayerCount = 0;
std::vector<const char *> enabledLayerNames(1);
enabledLayerNames[0] = "VK_LAYER_KHRONOS_validation";
printf("Requested Layers:\n");
for (const char *s : enabledLayerNames) {
printf("\t%s\n", s);
}
VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{};
debugCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
if (ENABLE_VALIDATION_LAYERS) {
createInfo.enabledLayerCount = enabledLayerNames.size();
createInfo.ppEnabledLayerNames = enabledLayerNames.data();
debugCreateInfo.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;
debugCreateInfo.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;
debugCreateInfo.pfnUserCallback = UserDebugCallback;
debugCreateInfo.pUserData = nullptr;
debugCreateInfo.pNext = nullptr;
createInfo.pNext = &debugCreateInfo;
}
std::vector<const char *> allGlfwExtensions;
{
unsigned int extensionCount = 0;
const char **glfwExtensions = glfwGetRequiredInstanceExtensions(&extensionCount);
allGlfwExtensions.reserve(extensionCount + 2);
copy(&glfwExtensions[0], &glfwExtensions[extensionCount], back_inserter(allGlfwExtensions));
if (ENABLE_VALIDATION_LAYERS) {
allGlfwExtensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
allGlfwExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
}
createInfo.ppEnabledExtensionNames = allGlfwExtensions.data();
createInfo.enabledExtensionCount = allGlfwExtensions.size();
}
printf("Required Extensions:\n");
for (const auto &ext : allGlfwExtensions) {
printf("\t%s\n", ext);
}
if (ENABLE_VALIDATION_LAYERS) {
unsigned int extensionCount = 0;
vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
std::vector<VkExtensionProperties> extensions(extensionCount);
vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions.data());
printf("Available Extensions:\n");
for (const auto &extension : extensions) {
printf("\t%s\n", extension.extensionName);
}
}
auto result = vkCreateInstance(&createInfo, nullptr, &vkInstance);
if (result != VK_SUCCESS) {
printf("Failed to create VkInstance! : %d\n", result);
throw result;
}
}
void CreateWindow(PKEWindowProperties *wp) {
if (vkInstance != nullptr) return;
glfwInit();
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
window = glfwCreateWindow(wp->width, wp->height, "Pikul", nullptr, nullptr);
InitVulkan();
}
void DestroyWindow() {
if (vkInstance != nullptr) return;
PFN_vkDestroyInstance(vkInstance);
glfwDestroyWindow(window);
glfwTerminate();
}
|
