AstralTech/Gryphn
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

re implement debugger in C

Browse Source
This commit is contained in:
Greg Wells
2025-05-21 10:16:58 -04:00
parent fa58a2f2d6
commit f97e26d019
12 changed files with 158 additions and 255 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
rendering_api/vulkan/src/debugger/vulkan_debugger.cpp
View File

@@ -1,5 +1,34 @@
#include "iostream"
#include "vulkan_debugger.h"
#include "instance/vulkan_instance.h"
bool checkValidationLayerSupport(std::vector<std::string> layers_to_validate) {
uint32_t layerCount;
vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
std::vector<VkLayerProperties> availableLayers(layerCount);
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
for (int i = 0; i < layers_to_validate.size(); i++) {
bool layerFound = false;
for (const auto& layerProperties : availableLayers) {
if (strcmp(layers_to_validate[i].c_str(), layerProperties.layerName) == 0) {
layerFound = true;
break;
}
}
if (!layerFound)
return false;
}
return true;
}
typedef struct vk_userData_t {
gnDebuggerCallback debuggerCallback;
void* userData;
} vkUserData;
static VKAPI_ATTR VkBool32 VKAPI_CALL vk_debuggerDebugCallback(
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
@@ -7,22 +36,42 @@ static VKAPI_ATTR VkBool32 VKAPI_CALL vk_debuggerDebugCallback(
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
void* pUserData) {
if (messageSeverity >= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT)
std::cerr << "validation layer error: " << pCallbackData->pMessage << std::endl;
else
std::cout << "validation layer: " << pCallbackData->pMessage << std::endl;
vk_userData_t userData = *(struct vk_userData_t*)pUserData;
gnMessageSeverity severity;
gnMessageType type;
gnMessageData data = {
.message = gnCreateString(pCallbackData->pMessage)
};
switch (messageSeverity) {
default: break;
case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: severity = GN_MESSAGE_VERBOSE; break;
case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: severity = GN_MESSAGE_INFO; break;
case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: severity = GN_MESSAGE_WARNING; break;
case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: severity = GN_MESSAGE_ERROR; break;
}
switch (messageType) {
default: break;
case VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT: type = GN_DEBUG_MESSAGE_GENERAL; break;
case VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT: type = GN_DEBUG_MESSAGE_VALIDATION; break;
case VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT: type = GN_DEBUG_MESSAGE_PERFORMANCE; break;
}
gnDebuggerCallback callback = *userData.debuggerCallback;
gnBool result = callback(severity, type, data, userData.userData);
if (result == gnFalse) return VK_FALSE;
else if (result == gnTrue) return VK_TRUE;
return VK_FALSE;
}
// zero fucking clue what this does but the guy who wrote vulkan-tutorial.com does
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 {
VkResult vk_createDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger) {
PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
if (vkCreateDebugUtilsMessengerEXT != nullptr)
return vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pDebugMessenger);
else
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
}
void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) {
@@ -33,25 +82,33 @@ void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& create
createInfo.pfnUserCallback = vk_debuggerDebugCallback;
}
void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator) {
auto func = (PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
if (func != nullptr) {
func(instance, debugMessenger, pAllocator);
void vk_destroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator) {
PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = (PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
if (vkDestroyDebugUtilsMessengerEXT != nullptr) {
vkDestroyDebugUtilsMessengerEXT(instance, debugMessenger, pAllocator);
}
}
GN_EXPORT gnReturnCode gnCreateDebuggerFn(gnDebugger* debugger) {
if (debugger->debugger == nullptr) debugger->debugger = new gnPlatformDebugger();
GN_EXPORT gnReturnCode gnCreateDebuggerFn(gnDebugger* debugger, gnInstance* instance, const gnDebuggerInfo_t info) {
debugger->debugger = new gnPlatformDebugger();
if (!checkValidationLayerSupport({"VK_LAYER_KHRONOS_validation"}))
return GN_FAILED_TO_CREATE_DEBUGGER;
VkDebugUtilsMessengerCreateInfoEXT createInfo;
populateDebugMessengerCreateInfo(createInfo);
if (CreateDebugUtilsMessengerEXT(*debugger->debugger->instance, &createInfo, nullptr, &debugger->debugger->debugMessenger) != VK_SUCCESS) {
return GN_FAILED;
}
vk_userData_t* userData = (vk_userData_t*)malloc(sizeof(vk_userData_t));
userData->debuggerCallback = info.callback;
userData->userData = info.userData;
populateDebugMessengerCreateInfo(createInfo);
createInfo.pUserData = (void*)userData;
if (vk_createDebugUtilsMessengerEXT(instance->instance->vk_instance, &createInfo, nullptr, &debugger->debugger->debugMessenger) != VK_SUCCESS)
return GN_FAILED_TO_CREATE_DEBUGGER;
return GN_SUCCESS;
}
GN_EXPORT void gnDestroyDebuggerFn(gnDebugger& debugger) {
DestroyDebugUtilsMessengerEXT(*debugger.debugger->instance, debugger.debugger->debugMessenger, nullptr);
vk_destroyDebugUtilsMessengerEXT(*debugger.debugger->instance, debugger.debugger->debugMessenger, nullptr);
}

7
rendering_api/vulkan/src/debugger/vulkan_layers.cpp
View File

@@ -1,7 +0,0 @@
#undef GN_UTILS_CPP
#include <core/debugger/gryphn_layers.h>
GN_EXPORT gnString gnGetPlatformLayerNameFn(const gnString& gnName) {
if (gnStringEquals(gnName, "GN_DEFAULT_DEBUG_LAYER")) return gnCreateString("VK_LAYER_KHRONOS_validation");
return gnCreateString("GN_NO_LAYER");
}

70
rendering_api/vulkan/src/instance/vulkan_instance.cpp
View File

@@ -1,57 +1,10 @@
#include "gryphn/gryphn_utils.h"
#include "vector"
#include <cstring>
// #include "debugger/vulkan_debugger.h"
#include "vulkan_instance.h"
// now I gotta do some shit to setup debug layers
bool checkValidationLayerSupport(std::vector<std::string> layers_to_validate) {
uint32_t layerCount;
vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
std::vector<VkLayerProperties> availableLayers(layerCount);
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
for (int i = 0; i < layers_to_validate.size(); i++) {
bool layerFound = false;
for (const auto& layerProperties : availableLayers) {
if (strcmp(layers_to_validate[i].c_str(), layerProperties.layerName) == 0) {
layerFound = true;
break;
}
}
if (!layerFound)
return false;
}
return true;
}
// void gnInstanceSetAppInfoFn(gnInstance& instance, gnInstanceInfo& info) {
// if (instance.instance == nullptr) instance.instance = new gnPlatformInstanceData();
// instance.AppInfo = info;
// instance.instance->appInfo = {};
// instance.instance->appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
// instance.instance->appInfo.pApplicationName = "Hello Triangle";
// instance.instance->appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
// instance.instance->appInfo.pEngineName = "No Engine";
// instance.instance->appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
// instance.instance->appInfo.apiVersion = VK_API_VERSION_1_3;
// }
GN_EXPORT gnReturnCode gnCreateInstanceFn(gnInstance* instance, gnInstanceInfo instanceInfo) {
instance->instance = new gnPlatformInstance();
// if (instance->debugger != nullptr && !checkValidationLayerSupport(instance->debugger->debug_layers)) {
// return gnReturnError(GN_FAILED_CREATE_INSTANCE, "validation layers requested, but not available!");
// }
// gnInstanceSetAppInfoFn(*instance, instance->AppInfo);
instance->valid = true;
#ifdef GN_PLATFORM_LINUX
@@ -73,8 +26,7 @@ GN_EXPORT gnReturnCode gnCreateInstanceFn(gnInstance* instance, gnInstanceInfo i
instance->instance->extensions.push_back("VK_KHR_surface");
// if (instance->debugger)
// instance->instance->extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
instance->instance->extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
VkApplicationInfo appInfo = {
.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
@@ -89,34 +41,14 @@ GN_EXPORT gnReturnCode gnCreateInstanceFn(gnInstance* instance, gnInstanceInfo i
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
createInfo.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
// auto extensions = getRequiredExtensions(instance->debugger);
createInfo.enabledExtensionCount = static_cast<uint32_t>(instance->instance->extensions.size());;
createInfo.ppEnabledExtensionNames = instance->instance->extensions.data();
// VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{};
// if (instance->debugger != nullptr) {
// auto validation_layers = instance->debugger->debug_layers;
// gnList<const char*> validation_layers_c = gnCreateList<const char*>();
// for (int i = 0; i < gnListLength(validation_layers); i++)
// gnListAdd(validation_layers_c, gnToCString(validation_layers[i]));
// createInfo.enabledLayerCount = static_cast<uint32_t>(gnListLength(validation_layers_c));
// createInfo.ppEnabledLayerNames = gnListData(validation_layers_c);
// populateDebugMessengerCreateInfo(debugCreateInfo);
// createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT*) &debugCreateInfo;
// } else {
createInfo.enabledLayerCount = 0;
// }
if (vkCreateInstance(&createInfo, nullptr, &instance->instance->vk_instance) != VK_SUCCESS) {
return GN_FAILED_CREATE_INSTANCE;
}
// if (instance->debugger->debugger == nullptr) instance->debugger->debugger = new gnPlatformDebugger();
// instance->debugger->debugger->instance = &instance->instance->vk_instance;
return GN_SUCCESS;
}