fix transfer queue jazz

add allocators into instance
finish moving present queue index to presentation queue
2025-08-12 18:03:41 -04:00 · 2025-08-12 17:54:10 -04:00 · 2025-08-12 17:53:56 -04:00 · 2025-08-12 17:53:41 -04:00 · 2025-08-12 17:49:37 -04:00 · 2025-08-12 17:47:45 -04:00
34 changed files with 162 additions and 102 deletions
--- a/CMakeLists.txt
+++ b/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 GryphnUtils GryphnCore GryphnLoader GryphnPlatform GryphnFunctionValidator GryphnAllocatorChecker GryphnExtensions)
+target_link_libraries(Gryphn INTERFACE 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)
--- a/projects/apis/opengl/loader/opengl_extensions.c
+++ b/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;
+}
--- a/projects/apis/opengl/loader/opengl_instance_loader.c
+++ b/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
--- a/projects/apis/opengl/loader/opengl_loader.h
+++ b/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);
--- a/projects/apis/opengl/src/device/opengl_output_device.c
+++ b/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) {}
--- a/projects/apis/opengl/src/device/opengl_output_device.h
+++ b/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);
--- a/projects/apis/opengl/src/device/opengl_physical_device.c
+++ b/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));
-
-    gnPhysicalDevice device = {
+    devices[0] = malloc(sizeof(struct gnPhysicalOutputDevice_t));
+    *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) {
-    return gnTrue;
+gnBool openglCanDevicePresent(gnPhysicalDevice device, gnWindowSurfaceHandle windowSurface) {
+    return GN_TRUE;
 }
--- a/projects/apis/opengl/src/device/opengl_physical_device.h
+++ b/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);
--- a/projects/apis/opengl/src/instance/opengl_instance.c
+++ b/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) {

 }
--- a/projects/apis/opengl/src/instance/opengl_instance.h
+++ b/projects/apis/opengl/src/instance/opengl_instance.h
@@ -4,5 +4,5 @@

 typedef struct gnPlatformInstance_t {} gnPlatformInstance;

-gnReturnCode createOpenGLInstance(gnInstanceHandle instance, gnInstanceInfo instanceInfo);
-void destroyOpenGLInstance(gnInstanceHandle instance);
+gnReturnCode openglCreateInstance(gnInstanceHandle instance, gnInstanceCreateInfo* instanceInfo, gryphnInstanceFunctionLayers* next, gnAllocators* allocators);
+void openglDestroyInstance(gnInstanceHandle instance, gryphnInstanceFunctionLayers* next, gnAllocators* allocators);
--- a/projects/apis/opengl/src/presentation_queue/opengl_presentation_queue.c
+++ b/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);
-        uint32_tArrayListAdd(&presentationQueue->presentationQueue->avaliableTextures, i);
+        GLuintArrayListAdd(presentationQueue->presentationQueue->textures, presentationQueue->images[i]->texture->id);
+        uint32_tArrayListAdd(presentationQueue->presentationQueue->avaliableTextures, i);
    }
    return GN_SUCCESS;
 }
 gnReturnCode getOpenGLPresentationQueueImage(gnPresentationQueue presentationQueue, uint32_t* imageIndex) {
-    while (presentationQueue->presentationQueue->avaliableTextures.count == 0) {}
-    *imageIndex = presentationQueue->presentationQueue->avaliableTextures.data[0];
-    uint32_tArrayListPopHead(&presentationQueue->presentationQueue->avaliableTextures);
+    while (uint32_tArrayListCount(presentationQueue->presentationQueue->avaliableTextures) == 0) {}
+    *imageIndex = uint32_tArrayListAt(presentationQueue->presentationQueue->avaliableTextures, 0);
+    uint32_tArrayListPopHead(presentationQueue->presentationQueue->avaliableTextures);
    return GN_SUCCESS;
 }
 void destroyOpenGLPresentationQueue(gnPresentationQueueHandle presentationQueue) {
    free(presentationQueue->presentationQueue);
 }
+
+
+
+GN_ARRAY_LIST_DEFINITION(GLuint);
--- a/projects/apis/opengl/src/presentation_queue/opengl_presentation_queue.h
+++ b/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;
--- a/projects/apis/opengl/src/surface/opengl_surface.c
+++ b/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))
-        return GN_FAILED_TO_INIT_OPENGL;
+    if (!gladLoadGLLoader((GLADloadproc)glXGetProcAddress)) {
+        gnDebuggerSetErrorMessage(instance->debugger, (gnMessageData){
+            .message = gnCreateString("Failed to load OpenGL functions")
+        });
+
+        return GN_UNKNOWN_ERROR;
+    }
    return GN_SUCCESS;
 }

--- a/projects/apis/vulkan/loader/vulkan_device_loader.c
+++ b/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,
--- a/projects/apis/vulkan/src/instance/vulkan_instance.c
+++ b/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;
--- a/projects/apis/vulkan/src/output_device/vulkan_output_device.c
+++ b/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);
 }

--- a/projects/apis/vulkan/src/output_device/vulkan_physical_device.c
+++ b/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;
+    uint32_t queueFamilyCount = 0;
+    vkGetPhysicalDeviceQueueFamilyProperties(device->physicalDevice->device, &queueFamilyCount, NULL);
+    for (uint32_t i = 0; i < queueFamilyCount; i++) {
+        VkBool32 supportsPresent;
+        vkGetPhysicalDeviceSurfaceSupportKHR(device->physicalDevice->device, i, surface->windowSurface->surface, &supportsPresent);
+        if (supportsPresent) return GN_TRUE;
    }
-
-    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;
+    return GN_FALSE;
 }
+
+    // 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;
--- a/projects/apis/vulkan/src/present/vulkan_present.c
+++ b/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);
 }
--- a/projects/apis/vulkan/src/presentation_queue/vulkan_presentation_queue.c
+++ b/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;
        }
    }

--- a/projects/apis/vulkan/src/presentation_queue/vulkan_presentation_queue.h
+++ b/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);
--- a/projects/apis/vulkan/src/vulkan_surface/vulkan_surface.c
+++ b/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;
-
-    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;
+    return VkResultToGnReturnCode(vkCreateXlibSurfaceKHR(instance->instance->vk_instance, &info, NULL, &windowSurface->windowSurface->surface));
 }
 #endif

--- a/projects/apis/vulkan/src/vulkan_surface/vulkan_surface.h
+++ b/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);
--- a/projects/core/src/buffers/gryphn_buffer.c
+++ b/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);
 }
--- a/projects/core/src/buffers/gryphn_buffer.h
+++ b/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);
--- a/projects/core/src/instance/gryphn_debugger.c
+++ b/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
-    );
-}
--- a/projects/core/src/instance/gryphn_debugger.h
+++ b/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,
--- a/projects/loader/src/gryphn_device_functions.h
+++ b/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);
--- a/projects/loader/src/gryphn_loader.c
+++ b/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();
--- a/projects/platform/gryphn_platform_include.h
+++ b/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>
--- a/projects/platform/platform_linux/gryphn_platform_linux.c
+++ b/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;
-    return gnFalse;
+    for (int i = 0; i < 3; i++) if (api == renderingAPIs[i]) return GN_TRUE;
+    return GN_FALSE;
 }

 #endif
--- a/projects/utils
+++ b/projects/utils
--- a/projects/validation_layers/function_loader/loader/function_loader.c
+++ b/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,
--- a/projects/validation_layers/function_loader/src/device_functions.c
+++ b/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);
 }
--- a/projects/validation_layers/function_loader/src/device_functions.h
+++ b/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);
Author	SHA1	Message	Date
Gregory Wells	70f8d5f31d	fix transfer queue jazz	2025-08-12 18:03:41 -04:00
Gregory Wells	94fb6fa2dc	add allocators into instance	2025-08-12 17:54:10 -04:00
Gregory Wells	3c8205c20f	finish moving present queue index to presentation queue	2025-08-12 17:53:56 -04:00
Gregory Wells	9b0a90f8fc	make debugger header only	2025-08-12 17:53:41 -04:00
Gregory Wells	499fa5b1e7	present queue now stores present queue index	2025-08-12 17:49:37 -04:00
Gregory Wells	baac536897	redo does support present	2025-08-12 17:47:45 -04:00
Gregory Wells	0736d87d23	fix some stuff up	2025-08-12 16:08:56 -04:00
Gregory Wells	96808c1940	Merge branch 'master' of https://github.com/GregoryWells2007/Gryphn	2025-08-12 16:07:08 -04:00
Gregory Wells	acf2f8c228	fix destruction order	2025-08-12 15:40:32 -04:00
Gregory Wells	ddd28858ef	gnUnmapBuffer	2025-08-12 14:33:03 -04:00
Gregory Wells	56d79663a2	fix some bugs on linux	2025-08-05 09:12:21 -04:00
Gregory Wells	dd5f1485d9	get OpenGL to work	2025-08-05 09:12:12 -04:00