fix transfer queue jazz

CMakeLists.txt

@@ -36,8 +36,7 @@ add_subdirectory(projects/platform) # build gryphn platform
 
 add_subdirectory(projects/validation_layers/function_loader/)
 add_subdirectory(projects/validation_layers/allocators/)
-
+target_link_libraries(Gryphn INTERFACE GryphnCore GryphnLoader GryphnPlatform GryphnFunctionValidator GryphnAllocatorChecker GryphnExtensions)
-target_link_libraries(Gryphn INTERFACE GryphnUtils GryphnCore GryphnLoader GryphnPlatform GryphnFunctionValidator GryphnAllocatorChecker GryphnExtensions)
 
 if (VULKAN_BUILT)
     target_link_libraries(Gryphn INTERFACE GryphnVulkanImpl)
@@ -48,3 +47,5 @@ endif()
 if (OPENGL_BUILT)
     target_link_libraries(Gryphn INTERFACE GryphnOpenGLImpl)
 endif()
+
+target_link_libraries(Gryphn INTERFACE GryphnUtils)

projects/apis/opengl/loader/opengl_extensions.c

@@ -0,0 +1,8 @@
+#include "opengl_loader.h"
+#include "gryphn_extensions.h"
+
+gnBool openglIsExtensionSupported(gnExtension extension) {
+    if (extension == GN_EXT_SYNCHRONIZATION) return GN_FALSE;
+    if (extension == GN_EXT_QUEUES) return GN_FALSE;
+    return GN_FALSE;
+}

projects/apis/opengl/loader/opengl_instance_loader.c

@@ -4,12 +4,18 @@
 #include "device/opengl_physical_device.h"
 #include "device/opengl_output_device.h"
 
+gryphnInstanceFunctionLayers loadOpenGLAPILayer() {
+    return (gryphnInstanceFunctionLayers) {
+        .createInstance = openglCreateInstance,
+        .destroyInstance = openglDestroyInstance,
+        NULL
+    };
+}
+
 gnInstanceFunctions loadOpenGLInstanceFunctions() {
     return (gnInstanceFunctions){
-        ._gnCreateInstance = createOpenGLInstance,
-        ._gnDestroyInstance = destroyOpenGLInstance,
         ._gnGetPhysicalDevices = getOpenGLDevice,
-        ._gnQueueCanPresentToSurface = openGLQueueCanPresent,
+        ._gnPhysicalDeviceCanPresentToSurface = openglCanDevicePresent,
         ._gnCreateOutputDevice = createOpenGLOutputDevice,
         ._gnDestroyOutputDevice = destroyOpenGLOutputDevice,
         #ifdef GN_PLATFORM_LINUX

projects/apis/opengl/loader/opengl_loader.h

@@ -2,7 +2,11 @@
 #include "loader/src/gryphn_instance_functions.h"
 #include "loader/src/gryphn_device_functions.h"
 #include "loader/src/gryphn_command_functions.h"
+#include "gryphn_extensions.h"
 
 gnInstanceFunctions loadOpenGLInstanceFunctions();
 gnDeviceFunctions loadOpenGLDeviceFunctions();
 gnCommandFunctions loadOpenGLCommandFunctions();
+
+gryphnInstanceFunctionLayers loadOpenGLAPILayer();
+gnBool openglIsExtensionSupported(gnExtension extension);

projects/apis/opengl/src/device/opengl_output_device.c

@@ -1,5 +1,5 @@
 #include "opengl_output_device.h"
 
-gnReturnCode createOpenGLOutputDevice(gnOutputDeviceHandle outputDevice, gnInstanceHandle instance, gnOutputDeviceInfo deviceInfo) { return GN_SUCCESS; }
+gnReturnCode createOpenGLOutputDevice(gnInstanceHandle instance, gnOutputDeviceHandle device, gnOutputDeviceInfo deviceInfo) { return GN_SUCCESS; }
 void waitForOpenGLDevice(const gnOutputDeviceHandle device) {}
 void destroyOpenGLOutputDevice(gnOutputDeviceHandle device) {}

projects/apis/opengl/src/device/opengl_output_device.h

@@ -3,6 +3,6 @@
 
 typedef struct gnPlatformOutputDevice_t {} gnPlatformOutputDevice;
 
-gnReturnCode createOpenGLOutputDevice(gnOutputDeviceHandle outputDevice, gnInstanceHandle instance, gnOutputDeviceInfo deviceInfo);
+gnReturnCode createOpenGLOutputDevice(gnInstanceHandle instance, gnOutputDeviceHandle device, gnOutputDeviceInfo deviceInfo);
 void waitForOpenGLDevice(const gnOutputDeviceHandle device);
 void destroyOpenGLOutputDevice(gnOutputDeviceHandle device);

projects/apis/opengl/src/device/opengl_physical_device.c

@@ -1,11 +1,12 @@
 #include "opengl_physical_device.h"
+#include "stdlib.h"
 
 gnPhysicalDevice* getOpenGLDevice(gnInstanceHandle instance, uint32_t* deviceCount) {
     *deviceCount = 1;
 
     gnPhysicalDevice* devices = malloc(sizeof(gnPhysicalDevice));
-
+    devices[0] = malloc(sizeof(struct gnPhysicalOutputDevice_t));
-    gnPhysicalDevice device = {
+    *devices[0] = (struct gnPhysicalOutputDevice_t){
         .physicalDevice = malloc(sizeof(gnPlatformPhysicalDevice)),
         .features = {
             .maxColorSamples = GN_SAMPLE_BIT_1,
@@ -16,20 +17,10 @@ gnPhysicalDevice* getOpenGLDevice(gnInstanceHandle instance, uint32_t* deviceCou
         .properties = {
             .deviceType = GN_DEDICATED_DEVICE,
             .name = gnCreateString("Generic OpenGL device")
-        },
-        .queueProperties = {
-            .queueCount = 1,
-            .queueProperties = (gnQueueProperties[1]){
-                (gnQueueProperties){
-                    .queueCount = 1,
-                    .queueType = GN_QUEUE_GRAPHICS
-                }
-            }
         }
     };
-    devices[0] = device;
     return devices;
 }
-gnBool openGLQueueCanPresent(const gnPhysicalDevice device, uint32_t queueIndex, gnWindowSurfaceHandle windowSurface) {
+gnBool openglCanDevicePresent(gnPhysicalDevice device, gnWindowSurfaceHandle windowSurface) {
-    return gnTrue;
+    return GN_TRUE;
 }

projects/apis/opengl/src/device/opengl_physical_device.h

@@ -5,4 +5,4 @@
 typedef struct gnPlatformPhysicalDevice_t {} gnPlatformPhysicalDevice;
 
 gnPhysicalDevice* getOpenGLDevice(gnInstanceHandle instance, uint32_t* deviceCount);
-gnBool openGLQueueCanPresent(const gnPhysicalDevice device, uint32_t queueIndex, gnWindowSurfaceHandle windowSurface);
+gnBool openglCanDevicePresent(gnPhysicalDevice device, gnWindowSurfaceHandle windowSurface);

projects/apis/opengl/src/instance/opengl_instance.c

@@ -1,8 +1,9 @@
 #include "opengl_instance.h"
 
-gnReturnCode createOpenGLInstance(gnInstanceHandle instance, gnInstanceInfo instanceInfo) {
+gnReturnCode openglCreateInstance(gnInstanceHandle instance, gnInstanceCreateInfo* instanceInfo, gryphnInstanceFunctionLayers* next, gnAllocators* allocators) {
+    if (instanceInfo->coreAPI != GN_RENDERINGAPI_OPENGL) return GN_UNSUPPORTED_API;
     return GN_SUCCESS;
 }
-void destroyOpenGLInstance(gnInstanceHandle instance) {
+void openglDestroyInstance(gnInstanceHandle instance, gryphnInstanceFunctionLayers* next, gnAllocators* allocators) {
 
 }

projects/apis/opengl/src/instance/opengl_instance.h

@@ -4,5 +4,5 @@
 
 typedef struct gnPlatformInstance_t {} gnPlatformInstance;
 
-gnReturnCode createOpenGLInstance(gnInstanceHandle instance, gnInstanceInfo instanceInfo);
+gnReturnCode openglCreateInstance(gnInstanceHandle instance, gnInstanceCreateInfo* instanceInfo, gryphnInstanceFunctionLayers* next, gnAllocators* allocators);
-void destroyOpenGLInstance(gnInstanceHandle instance);
+void openglDestroyInstance(gnInstanceHandle instance, gryphnInstanceFunctionLayers* next, gnAllocators* allocators);

projects/apis/opengl/src/presentation_queue/opengl_presentation_queue.c

@@ -27,17 +27,21 @@ gnReturnCode createOpenGLPresentationQueue(gnPresentationQueueHandle presentatio
             NULL
         );
 
-        GLuintArrayListAdd(&presentationQueue->presentationQueue->textures, presentationQueue->images[i]->texture->id);
+        GLuintArrayListAdd(presentationQueue->presentationQueue->textures, presentationQueue->images[i]->texture->id);
-        uint32_tArrayListAdd(&presentationQueue->presentationQueue->avaliableTextures, i);
+        uint32_tArrayListAdd(presentationQueue->presentationQueue->avaliableTextures, i);
     }
     return GN_SUCCESS;
 }
 gnReturnCode getOpenGLPresentationQueueImage(gnPresentationQueue presentationQueue, uint32_t* imageIndex) {
-    while (presentationQueue->presentationQueue->avaliableTextures.count == 0) {}
+    while (uint32_tArrayListCount(presentationQueue->presentationQueue->avaliableTextures) == 0) {}
-    *imageIndex = presentationQueue->presentationQueue->avaliableTextures.data[0];
+    *imageIndex = uint32_tArrayListAt(presentationQueue->presentationQueue->avaliableTextures, 0);
-    uint32_tArrayListPopHead(&presentationQueue->presentationQueue->avaliableTextures);
+    uint32_tArrayListPopHead(presentationQueue->presentationQueue->avaliableTextures);
     return GN_SUCCESS;
 }
 void destroyOpenGLPresentationQueue(gnPresentationQueueHandle presentationQueue) {
     free(presentationQueue->presentationQueue);
 }
+
+
+
+GN_ARRAY_LIST_DEFINITION(GLuint);

projects/apis/opengl/src/presentation_queue/opengl_presentation_queue.h

@@ -2,7 +2,7 @@
 #include <glad/glad.h>
 #include "presentation_queue/gryphn_presentation_queue.h"
 
-GN_ARRAY_LIST(GLuint);
+GN_ARRAY_LIST_HEADER(GLuint);
 
 typedef struct gnPlatformPresentationQueue_t {
     GLuintArrayList textures;

projects/apis/opengl/src/surface/opengl_surface.c

@@ -1,6 +1,7 @@
 #include <glad/glad.h>
 #include "GL/glext.h"
 #include "opengl_surface.h"
+#include "utils/gryphn_string.h"
 
 #ifdef GN_PLATFORM_LINUX
 #ifdef GN_WINDOW_X11
@@ -17,11 +18,16 @@ gnReturnCode createGLXContext(gnWindowSurfaceHandle windowSurface, gnInstanceHan
     XVisualInfo* vi = glXChooseVisual(createInfo.display, 0, attribs);
     windowSurface->windowSurface->context = glXCreateContext(createInfo.display, vi, NULL, GL_TRUE);
     if (glXMakeCurrent(createInfo.display, createInfo.window, windowSurface->windowSurface->context) == GL_FALSE)
-        return GN_FAILED_TO_ATTACH_WINDOW;
+        return GN_WINDOW_IN_USE;
     windowSurface->windowSurface->window = createInfo.window;
     windowSurface->windowSurface->display = createInfo.display;
-    if (!gladLoadGLLoader((GLADloadproc)glXGetProcAddress))
+    if (!gladLoadGLLoader((GLADloadproc)glXGetProcAddress)) {
-        return GN_FAILED_TO_INIT_OPENGL;
+        gnDebuggerSetErrorMessage(instance->debugger, (gnMessageData){
+            .message = gnCreateString("Failed to load OpenGL functions")
+        });
+
+        return GN_UNKNOWN_ERROR;
+    }
     return GN_SUCCESS;
 }
 

projects/apis/vulkan/loader/vulkan_device_loader.c

@@ -38,6 +38,7 @@ gnDeviceFunctions loadVulkanDeviceFunctions(void) {
         ._gnBufferData = vulkanBufferData,
         ._gnBufferSubData = vulkanBufferSubData,
         ._gnMapBuffer = vulkanMapBuffer,
+        ._gnUnmapBuffer = vulkanUnmapBuffer,
         ._gnDestroyBuffer = destroyBuffer,
 
         ._gnCreateUniformPool = createUniformPool,

projects/apis/vulkan/src/instance/vulkan_instance.c

@@ -83,10 +83,11 @@ gnReturnCode vulkanCreateInstance(gnInstanceHandle instance, gnInstanceCreateInf
     #endif
 
     VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo;
+    const char* enabledLayerNames = "VK_LAYER_KHRONOS_validation";
     if (instance->enabledLayerCounts[GN_DEBUGGER_LAYER_PLATFORM] > 0) {
         vkStringArrayListAdd(extensions, VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
         createInfo.enabledLayerCount = 1;
-        createInfo.ppEnabledLayerNames = (const char*[]){ "VK_LAYER_KHRONOS_validation" };
+        createInfo.ppEnabledLayerNames = &enabledLayerNames;
 
         instance->instance->userData.debuggerCallback = instanceInfo->debuggerInfo.callback;
         instance->instance->userData.userData = instanceInfo->debuggerInfo.userData;

projects/apis/vulkan/src/output_device/vulkan_output_device.c

@@ -8,6 +8,8 @@
 #include "vulkan_result_converter.h"
 #include "string.h"
 
+#include "stdio.h"
+
 gnReturnCode createVulkanOutputDevice(gnInstanceHandle instance, gnOutputDeviceHandle device, gnOutputDeviceInfo deviceInfo) {
     device->outputDevice = malloc(sizeof(gnPlatformOutputDevice));
     device->outputDevice->physicalDevice = deviceInfo.physicalDevice->physicalDevice->device;
@@ -21,6 +23,7 @@ gnReturnCode createVulkanOutputDevice(gnInstanceHandle instance, gnOutputDeviceH
         float queuePriority = 1.0f;
         for (uint32_t i = 0; i < deviceInfo.physicalDevice->physicalDevice->neededQueueCount; i++) {
             queueCreateInfos[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+            queueCreateInfos[i].pNext = NULL;
             queueCreateInfos[i].flags = 0;
             queueCreateInfos[i].queueCount = 1;
             queueCreateInfos[i].queueFamilyIndex = deviceInfo.physicalDevice->physicalDevice->neededQueues[i].queueIndex;
@@ -32,6 +35,7 @@ gnReturnCode createVulkanOutputDevice(gnInstanceHandle instance, gnOutputDeviceH
         for (uint32_t i = 0; i < deviceInfo.queueInfoCount; i++) {
             queueCreateInfos[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
             queueCreateInfos[i].flags = 0;
+            queueCreateInfos[i].pNext = NULL;
             queueCreateInfos[i].queueCount = deviceInfo.queueInfos[i].queueCount;
             queueCreateInfos[i].queueFamilyIndex = deviceInfo.queueInfos[i].queueFamilyIndex;
             queueCreateInfos[i].pQueuePriorities = deviceInfo.queueInfos[i].queuePrioritys;
@@ -44,6 +48,8 @@ gnReturnCode createVulkanOutputDevice(gnInstanceHandle instance, gnOutputDeviceH
 
     VkDeviceCreateInfo deviceCreateInfo = {
         .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+        .flags = 0,
+        .pNext = NULL,
         .queueCreateInfoCount = createQueueCount,
         .pQueueCreateInfos = queueCreateInfos,
         .pEnabledFeatures = &deviceFeatures
@@ -68,24 +74,28 @@ gnReturnCode createVulkanOutputDevice(gnInstanceHandle instance, gnOutputDeviceH
 
     device->outputDevice->queues = malloc(sizeof(vulkanQueue) * deviceInfo.physicalDevice->physicalDevice->neededQueueCount);
     uint32_t transferQueue = 0;
+    gnBool foundTransferQueue = GN_FALSE, foundGraphicsQueue = GN_FALSE;
     for (uint32_t i = 0; i < deviceInfo.physicalDevice->physicalDevice->neededQueueCount; i++) {
         device->outputDevice->queues[i].queueInfo = deviceInfo.physicalDevice->physicalDevice->neededQueues[i];
 
         vkGetDeviceQueue(device->outputDevice->device, deviceInfo.physicalDevice->physicalDevice->neededQueues[i].queueIndex, 0, &device->outputDevice->queues[i].queue);
-        if ((device->outputDevice->queues[i].queueInfo.createFlags & VK_QUEUE_TRANSFER_BIT) == VK_QUEUE_TRANSFER_BIT) {
+        if ((device->outputDevice->queues[i].queueInfo.createFlags & VK_QUEUE_TRANSFER_BIT) == VK_QUEUE_TRANSFER_BIT && !foundTransferQueue) {
             device->outputDevice->transferQueueIndex = i;
             transferQueue = device->outputDevice->queues[i].queueInfo.queueIndex;
+            foundTransferQueue = GN_TRUE;
         }
 
-        if ((device->outputDevice->queues[i].queueInfo.createFlags & VK_QUEUE_GRAPHICS_BIT) == VK_QUEUE_GRAPHICS_BIT) {
+        if ((device->outputDevice->queues[i].queueInfo.createFlags & VK_QUEUE_GRAPHICS_BIT) == VK_QUEUE_GRAPHICS_BIT && !foundGraphicsQueue) {
             device->outputDevice->graphicsQueueIndex = i;
+            foundGraphicsQueue = GN_FALSE;
         }
     }
 
     VkCommandPoolCreateInfo poolInfo = {
         .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
         .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
-        .queueFamilyIndex = transferQueue
+        .queueFamilyIndex = transferQueue,
+        .pNext = NULL
     };
 
     VkResult command_pool_result = vkCreateCommandPool(device->outputDevice->device, &poolInfo, NULL, &device->outputDevice->transferCommandPool);
@@ -132,10 +142,10 @@ void waitForDevice(const gnOutputDeviceHandle device) {
 
 void destroyVulkanOutputDevice(gnOutputDeviceHandle device) {
     vkDestroyFence(device->outputDevice->device, device->outputDevice->barrierFence, NULL);
-    vmaDestroyBuffer(device->outputDevice->allocator, device->outputDevice->stagingBuffer.buffer, device->outputDevice->stagingBuffer.allocation);
     vkDestroyCommandPool(device->outputDevice->device, device->outputDevice->transferCommandPool, NULL);
-    vkDestroyDevice(device->outputDevice->device, NULL);
+    vmaDestroyBuffer(device->outputDevice->allocator, device->outputDevice->stagingBuffer.buffer, device->outputDevice->stagingBuffer.allocation);
     vmaDestroyAllocator(device->outputDevice->allocator);
+    vkDestroyDevice(device->outputDevice->device, NULL);
     free(device->outputDevice);
 }
 

projects/apis/vulkan/src/output_device/vulkan_physical_device.c

@@ -106,38 +106,47 @@ gnPhysicalDevice* getPhysicalDevices(gnInstanceHandle instance, uint32_t* device
 }
 
 gnBool deviceCanPresentToSurface(gnPhysicalDevice device, gnWindowSurface surface) {
-    gnBool foundQueue = GN_FALSE;
-    for (uint32_t i = 0; i < device->physicalDevice->neededQueueCount; i++) {
-        VkBool32 supportsPresent = VK_FALSE;
-        vkGetPhysicalDeviceSurfaceSupportKHR(device->physicalDevice->device, device->physicalDevice->neededQueues[i].queueIndex, surface->windowSurface->surface, &supportsPresent);
-        if (supportsPresent) {
-            device->physicalDevice->neededQueues[i].usedForPresent = GN_TRUE;
-            foundQueue = GN_TRUE;
-            break;
-        }
-        surface->windowSurface->presentQueueIndex = i;
-    }
-
-    if (!foundQueue) {
     uint32_t queueFamilyCount = 0;
     vkGetPhysicalDeviceQueueFamilyProperties(device->physicalDevice->device, &queueFamilyCount, NULL);
-
     for (uint32_t i = 0; i < queueFamilyCount; i++) {
-            VkBool32 supportsPresent = VK_FALSE;
+        VkBool32 supportsPresent;
         vkGetPhysicalDeviceSurfaceSupportKHR(device->physicalDevice->device, i, surface->windowSurface->surface, &supportsPresent);
-            if (supportsPresent) {
+        if (supportsPresent) return GN_TRUE;
-                device->physicalDevice->neededQueues[device->physicalDevice->neededQueueCount] = (vulkanNeededQueue){
-                    .queueIndex = i,
-                    .createFlags = 0,
-                    .usedForPresent = GN_TRUE
-                };
-                foundQueue = GN_TRUE;
-                surface->windowSurface->presentQueueIndex = device->physicalDevice->neededQueueCount;
-                device->physicalDevice->neededQueueCount++;
-                break;
     }
-        }
+    return GN_FALSE;
-    }
-
-    return foundQueue;
 }
+
+    // gnBool foundQueue = GN_FALSE;
+    // for (uint32_t i = 0; i < device->physicalDevice->neededQueueCount; i++) {
+    //     VkBool32 supportsPresent = VK_FALSE;
+    //     vkGetPhysicalDeviceSurfaceSupportKHR(device->physicalDevice->device, device->physicalDevice->neededQueues[i].queueIndex, surface->windowSurface->surface, &supportsPresent);
+    //     if (supportsPresent) {
+    //         device->physicalDevice->neededQueues[i].usedForPresent = GN_TRUE;
+    //         foundQueue = GN_TRUE;
+    //         break;
+    //     }
+    //     surface->windowSurface->presentQueueIndex = i;
+    // }
+
+    // if (!foundQueue) {
+    //     uint32_t queueFamilyCount = 0;
+    //     vkGetPhysicalDeviceQueueFamilyProperties(device->physicalDevice->device, &queueFamilyCount, NULL);
+
+    //     for (uint32_t i = 0; i < queueFamilyCount; i++) {
+    //         VkBool32 supportsPresent = VK_FALSE;
+    //         vkGetPhysicalDeviceSurfaceSupportKHR(device->physicalDevice->device, i, surface->windowSurface->surface, &supportsPresent);
+    //         if (supportsPresent) {
+    //             device->physicalDevice->neededQueues[device->physicalDevice->neededQueueCount] = (vulkanNeededQueue){
+    //                 .queueIndex = i,
+    //                 .createFlags = 0,
+    //                 .usedForPresent = GN_TRUE
+    //             };
+    //             foundQueue = GN_TRUE;
+    //             surface->windowSurface->presentQueueIndex = device->physicalDevice->neededQueueCount;
+    //             device->physicalDevice->neededQueueCount++;
+    //             break;
+    //         }
+    //     }
+    // }
+
+    // return foundQueue;

projects/apis/vulkan/src/present/vulkan_present.c

@@ -1,6 +1,5 @@
 #include "vulkan_present.h"
 #include "extensions/synchronization/commands/gryphn_sync_present.h"
-#include "vulkan_surface/vulkan_surface.h"
 #include "vulkan_result_converter.h"
 
 gnReturnCode vulkanQueuePresentSync(gnDevice device, gnQueue queue, gnPresentSyncInfo info) {
@@ -25,7 +24,7 @@ gnReturnCode vulkanQueuePresentSync(gnDevice device, gnQueue queue, gnPresentSyn
 }
 
 gnReturnCode vulkanPresentSync(gnDevice device, gnPresentSyncInfo info) {
-    return vulkanQueuePresentSync(device, (gnQueue)device->outputDevice->queues[info.presentationQueues[0]->info.surface->windowSurface->presentQueueIndex].queue, info);
+    return vulkanQueuePresentSync(device, (gnQueue)device->outputDevice->queues[info.presentationQueues[0]->presentationQueue->presentQueueIndex].queue, info);
 }
 
 gnReturnCode vulkanQueuePresent(gnDevice device, gnQueue queue, gnPresentInfo info) {
@@ -47,5 +46,5 @@ gnReturnCode vulkanQueuePresent(gnDevice device, gnQueue queue, gnPresentInfo in
 }
 
 gnReturnCode vulkanPresent(gnDevice device, gnPresentInfo info) {
-    return vulkanQueuePresent(device, (gnQueue)device->outputDevice->queues[info.presentationQueues[0]->info.surface->windowSurface->presentQueueIndex].queue, info);
+    return vulkanQueuePresent(device, (gnQueue)device->outputDevice->queues[info.presentationQueues[0]->presentationQueue->presentQueueIndex].queue, info);
 }

projects/apis/vulkan/src/presentation_queue/vulkan_presentation_queue.c

@@ -40,17 +40,25 @@ gnReturnCode createPresentationQueue(gnPresentationQueueHandle presentationQueue
         presentQueueCreateInfo.queueFamilyIndexCount = presentationInfo.queueFamilyCount;
         presentQueueCreateInfo.pQueueFamilyIndices = presentationInfo.queueFamilies;
     } else {
-        if (presentationInfo.surface->windowSurface->presentQueueIndex != device->outputDevice->graphicsQueueIndex) {
+        uint32_t queueFamilyCount = 0;
+        vkGetPhysicalDeviceQueueFamilyProperties(device->outputDevice->physicalDevice, &queueFamilyCount, NULL);
+        for (uint32_t i = 0; i < queueFamilyCount; i++) {
+            VkBool32 supportsPresent;
+            vkGetPhysicalDeviceSurfaceSupportKHR(device->outputDevice->physicalDevice, i, presentationInfo.surface->windowSurface->surface, &supportsPresent);
+            if (supportsPresent) { presentationQueue->presentationQueue->presentQueueIndex = i; break; };
+        }
+
+        if (presentationQueue->presentationQueue->presentQueueIndex != device->outputDevice->graphicsQueueIndex) {
             presentQueueCreateInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
             presentQueueCreateInfo.queueFamilyIndexCount = 2;
             presentQueueCreateInfo.pQueueFamilyIndices = (uint32_t[]){
-                device->outputDevice->queues[presentationInfo.surface->windowSurface->presentQueueIndex].queueInfo.queueIndex,
+                presentationQueue->presentationQueue->presentQueueIndex,
                 device->outputDevice->queues[device->outputDevice->graphicsQueueIndex].queueInfo.queueIndex
             };
         } else {
             presentQueueCreateInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
             presentQueueCreateInfo.queueFamilyIndexCount = 1;
-            presentQueueCreateInfo.pQueueFamilyIndices = &device->outputDevice->queues[presentationInfo.surface->windowSurface->presentQueueIndex].queueInfo.queueIndex;
+            presentQueueCreateInfo.pQueueFamilyIndices = &presentationQueue->presentationQueue->presentQueueIndex;
         }
     }
 

projects/apis/vulkan/src/presentation_queue/vulkan_presentation_queue.h

@@ -7,6 +7,8 @@ typedef struct gnPlatformPresentationQueue_t {
 
     VkImage* swapChainImages;
     VkImageView* swapChainImageViews;
+
+    uint32_t presentQueueIndex;
 } gnPlatformPresentationQueue;
 
 gnReturnCode createPresentationQueue(gnPresentationQueueHandle presentationQueue, const gnDevice device, gnPresentationQueueInfo presentationInfo);

projects/apis/vulkan/src/vulkan_surface/vulkan_surface.c

@@ -2,7 +2,7 @@
 #include <instance/vulkan_instance.h>
 #include "vulkan_surface.h"
 #include <output_device/vulkan_physical_device.h>
-
+#include "vulkan_result_converter.h"
 
 #ifdef GN_PLATFORM_LINUX
 #ifdef GN_WINDOW_X11
@@ -14,11 +14,7 @@ gnReturnCode createX11WindowSurface(gnWindowSurfaceHandle windowSurface, gnInsta
     info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
     info.dpy = createInfo.display;
     info.window = createInfo.window;
-
+    return VkResultToGnReturnCode(vkCreateXlibSurfaceKHR(instance->instance->vk_instance, &info, NULL, &windowSurface->windowSurface->surface));
-    VkResult result = vkCreateXlibSurfaceKHR(instance->instance->vk_instance, &info, NULL, &windowSurface->windowSurface->surface);
-    if (result != VK_SUCCESS)
-        return GN_FAILED_TO_ATTACH_WINDOW;
-    return GN_SUCCESS;
 }
 #endif
 

projects/apis/vulkan/src/vulkan_surface/vulkan_surface.h

@@ -5,7 +5,7 @@
 
 typedef struct gnPlatformWindowSurface_t {
     VkSurfaceKHR surface;
-    uint32_t presentQueueIndex;
+    // uint32_t presentQueueIndex;
 } gnPlatformWindowSurface;
 
 VkFormat vkGryphnFormatToVulkanFormat(gnImageFormat format);

projects/core/src/buffers/gryphn_buffer.c

@@ -21,6 +21,9 @@ void* gnMapBuffer(gnBufferHandle buffer) {
     if (buffer->info.usage == GN_STATIC_DRAW) return NULL;
     return buffer->device->instance->callingLayer->deviceFunctions._gnMapBuffer(buffer);
 }
+void gnUnmapBuffer(gnBufferHandle buffer) {
+    buffer->device->instance->callingLayer->deviceFunctions._gnUnmapBuffer(buffer);
+}
 void gnDestroyBuffer(gnBufferHandle buffer) {
     buffer->device->instance->callingLayer->deviceFunctions._gnDestroyBuffer(buffer);
 }

projects/core/src/buffers/gryphn_buffer.h

@@ -44,4 +44,5 @@ gnReturnCode gnCreateBuffer(gnBufferHandle* buffer, gnOutputDeviceHandle device,
 void gnBufferData(gnBufferHandle buffer, size_t dataSize, gnBufferMemory data);
 void gnBufferSubData(gnBufferHandle buffer, size_t offset, size_t dataSize, gnBufferMemory data);
 gnBufferMemory gnMapBuffer(gnBufferHandle buffer);
+void gnUnmapBuffer(gnBufferHandle buffer);
 void gnDestroyBuffer(gnBufferHandle buffer);

projects/core/src/instance/gryphn_debugger.c

@@ -1,10 +1 @@
 #include "gryphn_debugger.h"
-
-void gnDebuggerSetVerboseMessage(gnDebuggerCreateInfo* debugger, gnMessageData data) {
-    debugger->callback(
-        GN_MESSAGE_VERBOSE,
-        GN_DEBUG_MESSAGE_GENERAL,
-        data,
-        debugger->userData
-    );
-}

projects/core/src/instance/gryphn_debugger.h

@@ -43,9 +43,19 @@ typedef struct gnDebuggerCreateInfo {
 } gnDebuggerCreateInfo;
 
 #ifdef GN_REVEAL_IMPL
-void gnDebuggerSetVerboseMessage(gnDebuggerCreateInfo* debugger, gnMessageData data);
+#include "stdlib.h"
+static inline void gnDebuggerSetVerboseMessage(gnDebuggerCreateInfo* debugger, gnMessageData data) {
+    if (debugger->callback == 0 || debugger == NULL) return;
+    debugger->callback(
+        GN_MESSAGE_VERBOSE,
+        GN_DEBUG_MESSAGE_GENERAL,
+        data,
+        debugger->userData
+    );
+}
+
 static inline void gnDebuggerSetErrorMessage(gnDebuggerCreateInfo debugger, gnMessageData data) {
-    // if (debugger == NULL) return;
+    if (debugger.callback == 0) return;
     debugger.callback(
         GN_MESSAGE_ERROR,
         GN_DEBUG_MESSAGE_VALIDATION,

projects/loader/src/gryphn_device_functions.h

@@ -42,6 +42,7 @@ typedef struct gnDeviceFunctions {
     void (*_gnBufferData)(gnBufferHandle buffer, size_t size, void* data);
     void (*_gnBufferSubData)(gnBufferHandle buffer, size_t offset, size_t dataSize, void* data);
     void* (*_gnMapBuffer)(gnBufferHandle buffer);
+    void (*_gnUnmapBuffer)(gnBufferHandle buffer);
     void (*_gnDestroyBuffer)(gnBufferHandle buffer);
 
     gnReturnCode (*_gnCreateUniformPool)(gnUniformPool pool, gnDeviceHandle device);

projects/loader/src/gryphn_loader.c

@@ -23,7 +23,7 @@ gryphnInstanceFunctionLayers gryphnLoadAPILayer(gnRenderingAPI api) {
     case GN_RENDERINGAPI_DIRECTX11: return (gryphnInstanceFunctionLayers){};
     case GN_RENDERINGAPI_DIRECTX12: return (gryphnInstanceFunctionLayers){};
 #ifdef GN_API_OPENGL
-    // case GN_RENDERINGAPI_OPENGL: return loadOpenGLInstanceFunctions();
+    case GN_RENDERINGAPI_OPENGL: return loadOpenGLAPILayer();
 #endif
 #ifdef GN_API_METAL
     case GN_RENDERINGAPI_METAL: return metalLoadAPILayer();

projects/platform/gryphn_platform_include.h

@@ -1,5 +1,6 @@
 #pragma once
 #include <gryphn_rendering_api.h>
+#include "utils/gryphn_bool.h"
 
 #ifdef GN_PLATFORM_LINUX
 #include <platform_linux/gryphn_platform_linux.h>

projects/platform/platform_linux/gryphn_platform_linux.c

@@ -1,6 +1,7 @@
 #ifdef GN_PLATFORM_LINUX
 #include "gryphn_platform_linux.h"
 #include "gryphn_rendering_api.h"
+#include "utils/gryphn_bool.h"
 
 gnRenderingAPI renderingAPIs[3] = {
     GN_RENDERINGAPI_VULKAN,
@@ -14,8 +15,8 @@ gnRenderingAPI* gnGetSupportedRenderingAPIs(int* count) {
 }
 
 gnBool gnSupportsRenderingAPI(gnRenderingAPI api) {
-    for (int i = 0; i < 3; i++) if (api == renderingAPIs[i]) return gnTrue;
+    for (int i = 0; i < 3; i++) if (api == renderingAPIs[i]) return GN_TRUE;
-    return gnFalse;
+    return GN_FALSE;
 }
 
 #endif

projects/validation_layers/function_loader/loader/function_loader.c

@@ -68,6 +68,7 @@ gnDeviceFunctions loadFunctionLoaderDeviceFunctions(void) {
         ._gnBufferData = checkBufferData,
         ._gnBufferSubData = checkBufferSubData,
         ._gnMapBuffer = checkMapBuffer,
+        ._gnUnmapBuffer = checkUnmapBuffer,
         ._gnDestroyBuffer = checkDestroyBuffer,
 
         ._gnCreateUniformPool = checkCreateUniformPool,

projects/validation_layers/function_loader/src/device_functions.c

@@ -70,6 +70,9 @@ void checkBufferSubData(gnBufferHandle buffer, size_t offset, size_t size, void*
 void* checkMapBuffer(gnBufferHandle buffer) {
     CHECK_RETURNED_FUNCTION(buffer->device->instance, _gnMapBuffer, deviceFunctions, NULL, buffer);
 }
+void checkUnmapBuffer(gnBufferHandle buffer) {
+    CHECK_VOID_FUNCTION(buffer->device->instance, _gnUnmapBuffer, deviceFunctions, buffer);
+}
 void checkDestroyBuffer(gnBufferHandle buffer) {
     CHECK_VOID_FUNCTION(buffer->device->instance, _gnDestroyBuffer, deviceFunctions, buffer);
 }

projects/validation_layers/function_loader/src/device_functions.h

@@ -23,6 +23,7 @@ gnReturnCode checkCreateBuffer(gnBufferHandle buffer, gnDeviceHandle device, gnB
 void checkBufferData(gnBufferHandle buffer, size_t size, void* data);
 void checkBufferSubData(gnBufferHandle buffer, size_t offset, size_t size, void* data);
 void* checkMapBuffer(gnBufferHandle buffer);
+void checkUnmapBuffer(gnBufferHandle buffer);
 void checkDestroyBuffer(gnBufferHandle buffer);
 
 gnReturnCode checkCreateUniformPool(gnUniformPool pool, gnDeviceHandle device);