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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
#include "context.h"
#include "vkassert.h"
#include <rune/core/logging.h>
#include <rune/core/alloc.h>
#include <stdlib.h>
#include <string.h>
VKAPI_ATTR VkBool32 VKAPI_CALL _vulkan_db_callback(
VkDebugUtilsMessageSeverityFlagBitsEXT message_severity,
VkDebugUtilsMessageTypeFlagsEXT message_types,
const VkDebugUtilsMessengerCallbackDataEXT *callback_data,
void *user_data) {
switch (message_severity) {
case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT:
log_output(LOG_ERROR, callback_data->pMessage);
break;
case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT:
log_output(LOG_WARN, callback_data->pMessage);
break;
case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT:
log_output(LOG_INFO, callback_data->pMessage);
break;
case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT:
log_output(LOG_DEBUG, callback_data->pMessage);
break;
default:
break;
}
return VK_FALSE;
}
int _init_vkdebugger(struct vkcontext *context) {
log_output(LOG_INFO, "Initializing Vulkan debugger");
uint32_t log_severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT;
VkDebugUtilsMessengerCreateInfoEXT dbinfo = {VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT};
dbinfo.messageSeverity = log_severity;
dbinfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
dbinfo.pfnUserCallback = _vulkan_db_callback;
dbinfo.pUserData = NULL;
PFN_vkCreateDebugUtilsMessengerEXT func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(context->instance, "vkCreateDebugUtilsMessengerEXT");
if (func == NULL) {
log_output(LOG_ERROR, "Failed to create Vulkan debugger");
return -1;
}
VkResult res;
res = func(context->instance, &dbinfo, NULL, &context->db_messenger);
if (res != VK_SUCCESS) {
char *err_str = get_vkerr_str(res);
log_output(LOG_ERROR, "Cannot create a Vulkan debug session: %s", err_str);
free(err_str);
return -1;
}
return 0;
}
struct vkcontext* create_vkcontext(struct vklayer_container *vklayers, struct ext_container *ext) {
log_output(LOG_DEBUG, "Initializing Vulkan");
VkApplicationInfo app_info = {VK_STRUCTURE_TYPE_APPLICATION_INFO};
app_info.apiVersion = VK_API_VERSION_1_2;
app_info.pApplicationName = "RuneClient";
app_info.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
app_info.pEngineName = "RuneEngine";
app_info.engineVersion = VK_MAKE_VERSION(1, 0, 0);
VkInstanceCreateInfo cinfo = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO};
cinfo.pApplicationInfo = &app_info;
cinfo.enabledExtensionCount = ext->ext_count;
cinfo.ppEnabledExtensionNames = ext->extensions;
cinfo.pNext = NULL;
struct vkcontext *ret = rune_calloc(0, sizeof(struct vkcontext));
ret->surface = rune_alloc(sizeof(struct vksurface));
VkResult res;
res = vkCreateInstance(&cinfo, NULL, &ret->instance);
if (res != VK_SUCCESS) {
char *err_str = get_vkerr_str(res);
log_output(LOG_FATAL, "Cannot create a Vulkan instance: %s", err_str);
free(err_str);
rune_free(ret);
ret = NULL;
}
if (vklayers != NULL) {
log_output(LOG_INFO, "Validation layers enabled");
_init_vkdebugger(ret);
cinfo.enabledLayerCount = vklayers->vklayer_count;
cinfo.ppEnabledLayerNames = vklayers->vklayer_names;
} else {
log_output(LOG_INFO, "Validation layers disabled");
}
return ret;
}
void destroy_vkcontext(struct vkcontext *context) {
log_output(LOG_DEBUG, "Closing Vulkan instance");
PFN_vkDestroyDebugUtilsMessengerEXT func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(context->instance, "vkDestroyDebugUtilsMessengerEXT");
func(context->instance, context->db_messenger, NULL);
vkDestroySurfaceKHR(context->instance, context->surface->handle, NULL);
vkDestroyInstance(context->instance, NULL);
rune_free(context->surface);
rune_free(context);
}
struct vklayer_container* init_vklayers(struct ext_container *ext) {
const char** new_extensions = rune_alloc(sizeof(char*) * ext->ext_count++);
for (uint32_t i = 0; i < ext->ext_count-1; i++)
new_extensions[i] = ext->extensions[i];
new_extensions[ext->ext_count-1] = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
ext->extensions = new_extensions;
uint32_t layer_count;
vkEnumerateInstanceLayerProperties(&layer_count, NULL);
VkLayerProperties layer_props[layer_count];
vkEnumerateInstanceLayerProperties(&layer_count, layer_props);
struct vklayer_container *ret = rune_alloc(sizeof(struct vklayer_container));
ret->vklayer_count = 1;
ret->vklayer_names = rune_alloc(sizeof(char*) * ret->vklayer_count);
ret->vklayer_names[0] = "VK_LAYER_KHRONOS_validation";
for (uint32_t i = 0; i < ret->vklayer_count; i++) {
log_output(LOG_DEBUG, "Searching for layer: %s", ret->vklayer_names[i]);
int found = 0;
for (uint32_t j = 0; j < layer_count; j++) {
if (strcmp(ret->vklayer_names[i], layer_props[j].layerName) == 0) {
found = 1;
break;
}
}
if (found == 0) {
log_output(LOG_WARN, "Required validation layer is missing: %s", ret->vklayer_names[i]);
rune_free(ret);
rune_free(ext->extensions);
return NULL;
}
}
log_output(LOG_INFO, "All prerequisite validation layers found");
rune_free(ext->extensions);
return ret;
}
|
