Conjure/conjure-engine
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

CONGE-2 Added better login in Demo1 and added error handling in VulkanContext.cpp

Browse Source
This commit is contained in:
Jimmy Tremblay-Bernier 2024-11-22 20:29:48 -05:00
parent 829c7b5c52
commit 15f8898808
4 changed files with 163 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
ConjureEngine/src/ConjureEngine/VulkanContext.cpp
View File

@ -15,13 +15,32 @@ namespace ConjureEngine {
void VulkanContext::AttachTo(SDL_Window* window, const VkApplicationInfo& appInfo) void VulkanContext::AttachTo(SDL_Window* window, const VkApplicationInfo& appInfo)
{ {
// LOAD THE EXTENSIONS // LOAD THE EXTENSIONS
SDL_Vulkan_GetInstanceExtensions(window, &m_extensionCount, nullptr); SDL_bool sdlSuccess;
VkResult vk_result;
// FETCH NUMBER OF EXTENSIONS TO RESERVE SPACE IN VECTOR
sdlSuccess = SDL_Vulkan_GetInstanceExtensions(window, &m_extensionCount, nullptr);
if(sdlSuccess != SDL_TRUE)
{
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Error Getting Extensions: %s", SDL_GetError());
exit(1);
}
m_extensionNames.reserve(m_extensionCount); m_extensionNames.reserve(m_extensionCount);
SDL_Vulkan_GetInstanceExtensions(window, &m_extensionCount, m_extensionNames.data());
// FILLING UP THE VECTOR
sdlSuccess = SDL_Vulkan_GetInstanceExtensions(window, &m_extensionCount, m_extensionNames.data());
if(sdlSuccess != SDL_TRUE)
{
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Error Getting Extensions: %s", SDL_GetError());
exit(1);
}
else
{
SDL_LogDebug(SDL_LOG_CATEGORY_SYSTEM,"FETCHING OF EXTENSION FINISHED SUCCESSFULLY");
}
// Fill the instance create info using appInfo // Fill the instance create info struct using appInfo
VkInstanceCreateInfo vulkanInfos{}; VkInstanceCreateInfo vulkanInfos{};
vulkanInfos.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; vulkanInfos.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
vulkanInfos.pApplicationInfo = &appInfo; vulkanInfos.pApplicationInfo = &appInfo;
@ -29,26 +48,57 @@ namespace ConjureEngine {
// ENABLE THE REQUIRED EXTENSIONS // ENABLE THE REQUIRED EXTENSIONS
this->EnableGlobalExtentions(window, vulkanInfos); this->EnableGlobalExtentions(window, vulkanInfos);
// CREATE VULKAN INSTANCE // CREATE THE VULKAN INSTANCE
vkCreateInstance(&vulkanInfos, nullptr, &m_vkInst); vk_result = vkCreateInstance(&vulkanInfos, nullptr, &m_vkInst);
if(vk_result != VkResult::VK_SUCCESS) {
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Error while creating the device: CODE = %d", static_cast<int>(vk_result));
exit(1);
}
else {
SDL_LogDebug(SDL_LOG_CATEGORY_SYSTEM,"VULKAN INSTANCE CREATED SUCCESSFULLY");
}
// LOAD THE PHYSICAL DEVICES (GPUs) // FETCH THE NUMBER OF PHYSICAL DEVICES (GPUs) TO RESERVE SPACE INTHE VECTOR
vkEnumeratePhysicalDevices(m_vkInst, &m_physicalDeviceCount, nullptr); vk_result = vkEnumeratePhysicalDevices(m_vkInst, &m_physicalDeviceCount, nullptr);
if(vk_result != VkResult::VK_SUCCESS) {
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Error while enumerating physical devices: CODE = %d", static_cast<int>(vk_result));
exit(1);
}
m_physicalDevices = std::vector<VkPhysicalDevice>(m_physicalDeviceCount); m_physicalDevices = std::vector<VkPhysicalDevice>(m_physicalDeviceCount);
vkEnumeratePhysicalDevices(m_vkInst, &m_physicalDeviceCount, m_physicalDevices.data());
// SELECT THE MAIN GPU (WE COULD HAVE A SMARTER SELECTION LATER) // FILL THE VECTOR WITH ACTUAL DEVICES DATA
vk_result = vkEnumeratePhysicalDevices(m_vkInst, &m_physicalDeviceCount, m_physicalDevices.data());
if(vk_result != VkResult::VK_SUCCESS) {
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Error while enumerating physical devices: CODE = %d", static_cast<int>(vk_result));
exit(1);
}
else {
SDL_LogDebug(SDL_LOG_CATEGORY_SYSTEM, "VULKAN ENUMERATION OF PHYSICAL DEVICES FINISHED SUCCESSFULLY");
}
// SELECT THE MAIN GPU (WE COULD HAVE A SMARTER SELECTION LATER. FOR NOW, WE SELECT THE FIRST ONE WE SEE)
m_selectedPhysicalDevice = m_physicalDevices[0]; m_selectedPhysicalDevice = m_physicalDevices[0];
// LOAD THE FAMILLY QUEUE PROPERTIES // FETCH THE QUANTITY OF FAMILY QUEUE TO RESERVE SPACE IN THE VECTOR
vkGetPhysicalDeviceQueueFamilyProperties(m_selectedPhysicalDevice, &m_queueFamilyCount, nullptr); vkGetPhysicalDeviceQueueFamilyProperties(m_selectedPhysicalDevice, &m_queueFamilyCount, nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(m_queueFamilyCount); std::vector<VkQueueFamilyProperties> queueFamilies(m_queueFamilyCount);
// FILL THE VECTOR WITH ACTUAL QUEUE DATA
vkGetPhysicalDeviceQueueFamilyProperties(m_selectedPhysicalDevice, &m_queueFamilyCount, queueFamilies.data()); vkGetPhysicalDeviceQueueFamilyProperties(m_selectedPhysicalDevice, &m_queueFamilyCount, queueFamilies.data());
// CREATE THE SURFACE FOR RENDERING // CREATE THE SURFACE FOR RENDERING
SDL_Vulkan_CreateSurface(window, m_vkInst, &m_surface); sdlSuccess = SDL_Vulkan_CreateSurface(window, m_vkInst, &m_surface);
if(sdlSuccess != SDL_TRUE)
{
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Error Getting Extensions: %s", SDL_GetError());
exit(1);
}
else
{
SDL_LogDebug(SDL_LOG_CATEGORY_SYSTEM, "VULKAN SURFACE CREATED SUCCESSFULLY");
}
// ??? // NOT SURE WHAT THIS DOES YET, WILL CHECK IN THE TUTORIAL
uint32_t graphicsQueueIndex = UINT32_MAX; uint32_t graphicsQueueIndex = UINT32_MAX;
uint32_t presentQueueIndex = UINT32_MAX; uint32_t presentQueueIndex = UINT32_MAX;
VkBool32 support; VkBool32 support;
@ -58,7 +108,11 @@ namespace ConjureEngine {
VK_QUEUE_GRAPHICS_BIT) VK_QUEUE_GRAPHICS_BIT)
graphicsQueueIndex = i; graphicsQueueIndex = i;
if (presentQueueIndex == UINT32_MAX) { if (presentQueueIndex == UINT32_MAX) {
vkGetPhysicalDeviceSurfaceSupportKHR(m_selectedPhysicalDevice, i, m_surface, &support); vk_result = vkGetPhysicalDeviceSurfaceSupportKHR(m_selectedPhysicalDevice, i, m_surface, &support);
if(vk_result != VkResult::VK_SUCCESS) {
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Error while checking the surface capability: CODE = %d", static_cast<int>(vk_result));
}
if (support) if (support)
presentQueueIndex = i; presentQueueIndex = i;
} }
@ -94,12 +148,13 @@ namespace ConjureEngine {
// CREATE VIRTUAL DEVICE FOR RENDERING // CREATE VIRTUAL DEVICE FOR RENDERING
VkResult result = vkCreateDevice(m_selectedPhysicalDevice, &m_deviceCreateInfo, nullptr, &m_device); vk_result = vkCreateDevice(m_selectedPhysicalDevice, &m_deviceCreateInfo, nullptr, &m_device);
if(result != VkResult::VK_SUCCESS) { if(vk_result != VkResult::VK_SUCCESS) {
SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Error while creating the device: %d", static_cast<int>(result)); SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Error while creating the device: %d", static_cast<int>(vk_result));
exit(1);
} }
else { else {
SDL_Log("DEVICE CREATED SUCCESSFULLY"); SDL_LogDebug(SDL_LOG_CATEGORY_SYSTEM, "DEVICE CREATED SUCCESSFULLY");
} }
vkGetDeviceQueue(m_device, graphicsQueueIndex, 0, &m_graphicQueue); vkGetDeviceQueue(m_device, graphicsQueueIndex, 0, &m_graphicQueue);

6
ConjureEngine/src/ConjureEngine/Window.cpp
View File

@ -19,7 +19,11 @@ namespace ConjureEngine {
SDL_Vulkan_UnloadLibrary(); SDL_Vulkan_UnloadLibrary();
SDL_Quit(); SDL_Quit();
SDL_Log("Cleaned up with errors: %s", SDL_GetError()); std::string error = SDL_GetError();
if(!error.empty())
{
SDL_Log("Cleaned up with errors: %s", error);
}
} }
SDL_Window* Window::GetWindow() const SDL_Window* Window::GetWindow() const

8
Demo1/src/Demo1.cpp
View File

@ -21,22 +21,22 @@ namespace Demo1 {
void Demo1::Awake() void Demo1::Awake()
{ {
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,"[DEMO1 - TRACE] - AWAKING"); SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,"AWAKING");
} }
void Demo1::Start() void Demo1::Start()
{ {
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,"[DEMO1 - TRACE] - STARTING"); SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,"STARTING");
} }
void Demo1::Tick(double deltaTime) void Demo1::Tick(double deltaTime)
{ {
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[DEMO1 - TRACE] - TICKING %f", deltaTime); SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "TICKING %f", deltaTime);
} }
void Demo1::Destroy() void Demo1::Destroy()
{ {
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,"[DEMO1 - TRACE] - DESTROYING"); SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,"DESTROYING");
} }
} // Demo1 } // Demo1

82
Demo1/src/main.cpp
View File

@ -1,14 +1,94 @@
#define SDL_MAIN_HANDLED #define SDL_MAIN_HANDLED
#include <fstream>
#include <iostream>
#include "Demo1.h" #include "Demo1.h"
static std::ofstream logFile;
void OutputLog(void *userdata, int category, SDL_LogPriority priority, const char *message)
{
(void)userdata;
std::string categoryString;
switch (category)
{
case SDL_LOG_CATEGORY_APPLICATION:
categoryString = "Application";
break;
case SDL_LOG_CATEGORY_ERROR:
categoryString = "Error";
break;
case SDL_LOG_CATEGORY_ASSERT:
categoryString = "Assert";
break;
case SDL_LOG_CATEGORY_SYSTEM:
categoryString = "System";
break;
case SDL_LOG_CATEGORY_AUDIO:
categoryString = "Audio";
break;
case SDL_LOG_CATEGORY_VIDEO:
categoryString = "Video";
break;
case SDL_LOG_CATEGORY_RENDER:
categoryString = "Render";
break;
case SDL_LOG_CATEGORY_INPUT:
categoryString = "Input";
break;
case SDL_LOG_CATEGORY_TEST:
categoryString = "Test";
break;
default:
categoryString = "";
break;
}
std::string priorityString;
switch (priority)
{
case SDL_LOG_PRIORITY_VERBOSE:
priorityString = "VERBOSE";
break;
case SDL_LOG_PRIORITY_DEBUG:
priorityString = "DEBUG";
break;
case SDL_LOG_PRIORITY_INFO:
priorityString = "INFO";
break;
case SDL_LOG_PRIORITY_WARN:
priorityString = "WARN";
break;
case SDL_LOG_PRIORITY_ERROR:
priorityString = "ERROR";
break;
case SDL_LOG_PRIORITY_CRITICAL:
priorityString = "CRITICAL";
break;
default:
std::cout << message << "\n";
break;
}
logFile << "[" << categoryString << " - " << priorityString << "] " << message << "\n";
std::cout << "[" << categoryString << " - " << priorityString << "] " << message << "\n";
}
int main ( int argc, char* argv[] ) int main ( int argc, char* argv[] )
{ {
logFile = std::ofstream{"log.txt"};
SDL_SetMainReady(); SDL_SetMainReady();
SDL_LogSetAllPriority(SDL_LOG_PRIORITY_VERBOSE);
SDL_LogSetOutputFunction(&OutputLog, nullptr);
// I WANT TO CREATE AN APP // I WANT TO CREATE AN APP
Demo1::Demo1 app; Demo1::Demo1 app;
// AND THEN START IT // AND THEN START IT
return app.Run(); int status = app.Run();
return status;
} }