get the queues when GN_EXT_QUEUES is enabled

projects/apis/vulkan/src/extensions/queues/vulkan_device_queues.c

@@ -0,0 +1,23 @@
+#include <output_device/vulkan_physical_device.h>
+#include "extensions/queues/gryphn_physcial_device_queue.h"
+
+gnReturnCode vulkanPhysicalDeviceQueueProperties(gnPhysicalOutputDeviceHandle device, uint32_t queueFamilyCount, gnQueueFamilyProperties* queues) {
+    vkGetPhysicalDeviceQueueFamilyProperties(device->physicalDevice->device, &queueFamilyCount, NULL);
+    if (queues == NULL) return GN_SUCCESS;
+
+    VkQueueFamilyProperties* queueFamilies = malloc(sizeof(VkQueueFamilyProperties) * queueFamilyCount);
+    vkGetPhysicalDeviceQueueFamilyProperties(device->physicalDevice->device, &queueFamilyCount, queueFamilies);
+
+    for (int i = 0; i < queueFamilyCount; i++) {
+        queues[i].queueCount = queueFamilies[i].queueCount;
+        queues[i].queueTypeFlags = 0;
+
+        if ((queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == VK_QUEUE_GRAPHICS_BIT)             queues[i].queueTypeFlags |= GN_QUEUE_GRAPHICS_BIT;
+        if ((queueFamilies[i].queueFlags & VK_QUEUE_COMPUTE_BIT) == VK_QUEUE_COMPUTE_BIT)               queues[i].queueTypeFlags |= GN_QUEUE_COMPUTE_BIT;
+        if ((queueFamilies[i].queueFlags & VK_QUEUE_TRANSFER_BIT) == VK_QUEUE_TRANSFER_BIT)             queues[i].queueTypeFlags |= GN_QUEUE_TRANSFER_BIT;
+        if ((queueFamilies[i].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) == VK_QUEUE_SPARSE_BINDING_BIT) queues[i].queueTypeFlags |= GN_QUEUE_SPARSE_BINDING_BIT;
+        if ((queueFamilies[i].queueFlags & VK_QUEUE_PROTECTED_BIT) == VK_QUEUE_PROTECTED_BIT)           queues[i].queueTypeFlags |= GN_QUEUE_PROTECTED_BIT;
+    }
+
+    return GN_SUCCESS;
+}

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

@@ -31,6 +31,43 @@ VkSampleCountFlags gnSampleCountToVulkan(gnMultisampleCountFlags counts) {
     return sampleCount;
 }
 
+void vulkanLoadNeededQueues(VkPhysicalDevice vulkanDevice, gnPhysicalDevice gryphnDevice) {
+    uint32_t queueFamilyCount = 0;
+    vkGetPhysicalDeviceQueueFamilyProperties(vulkanDevice, &queueFamilyCount, NULL);
+    VkQueueFamilyProperties* queueFamilies = malloc(sizeof(VkQueueFamilyProperties) * queueFamilyCount);
+    vkGetPhysicalDeviceQueueFamilyProperties(vulkanDevice, &queueFamilyCount, queueFamilies);
+
+    gryphnDevice->physicalDevice->neededQueues = malloc(sizeof(vulkanNeededQueue) * queueFamilyCount);
+    gnBool foundGraphicsQueueFamily = gnFalse, foundTransferQueueFamily = gnFalse;
+    for (int c = 0; c < queueFamilyCount; c++) {
+        gnBool hasNeededQueue = gnFalse;
+
+        if ((queueFamilies[c].queueFlags & VK_QUEUE_GRAPHICS_BIT) == VK_QUEUE_GRAPHICS_BIT) {
+            foundGraphicsQueueFamily = true;
+            hasNeededQueue = gnTrue;
+        }
+        if ((queueFamilies[c].queueFlags & VK_QUEUE_TRANSFER_BIT) == VK_QUEUE_TRANSFER_BIT) {
+            foundTransferQueueFamily = true;
+            hasNeededQueue = gnTrue;
+        }
+
+        if (hasNeededQueue) {
+            vulkanNeededQueue neededQueue = {
+                .queueIndex = c,
+                .createFlags = 0,
+                .usedForPresent = gnFalse
+            };
+            if ((queueFamilies[c].queueFlags & VK_QUEUE_GRAPHICS_BIT)) neededQueue.createFlags |= VK_QUEUE_GRAPHICS_BIT;
+            if ((queueFamilies[c].queueFlags & VK_QUEUE_TRANSFER_BIT)) neededQueue.createFlags |= VK_QUEUE_TRANSFER_BIT;
+
+            gryphnDevice->physicalDevice->neededQueues[gryphnDevice->physicalDevice->neededQueueCount] = neededQueue;
+            gryphnDevice->physicalDevice->neededQueueCount++;
+        }
+    }
+
+    free(queueFamilies);
+}
+
 gnPhysicalDevice* getPhysicalDevices(gnInstanceHandle instance, uint32_t* deviceCount) {
     vkEnumeratePhysicalDevices(instance->instance->vk_instance, deviceCount, NULL);
     if (deviceCount == 0)
@@ -57,38 +94,9 @@ gnPhysicalDevice* getPhysicalDevices(gnInstanceHandle instance, uint32_t* device
         case VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM: outputDevices[i]->properties.deviceType = GN_INTEGRATED_DEVICE;
         }
 
-        uint32_t queueFamilyCount = 0;
+        if (instance->enabledExtensions[GN_EXT_QUEUES] == gnFalse)
-        vkGetPhysicalDeviceQueueFamilyProperties(physicalDevices[i], &queueFamilyCount, NULL);
+            vulkanLoadNeededQueues(physicalDevices[i], outputDevices[i]);
-        VkQueueFamilyProperties* queueFamilies = malloc(sizeof(VkQueueFamilyProperties) * queueFamilyCount);
-        vkGetPhysicalDeviceQueueFamilyProperties(physicalDevices[i], &queueFamilyCount, queueFamilies);
 
-        outputDevices[i]->physicalDevice->neededQueues = malloc(sizeof(vulkanNeededQueue) * queueFamilyCount);
-        gnBool foundGraphicsQueueFamily = gnFalse, foundTransferQueueFamily = gnFalse;
-        for (int c = 0; c < queueFamilyCount; c++) {
-            gnBool hasNeededQueue = gnFalse;
-
-            if ((queueFamilies[c].queueFlags & VK_QUEUE_GRAPHICS_BIT) == VK_QUEUE_GRAPHICS_BIT) {
-                foundGraphicsQueueFamily = true;
-                hasNeededQueue = gnTrue;
-            }
-            if ((queueFamilies[c].queueFlags & VK_QUEUE_TRANSFER_BIT) == VK_QUEUE_TRANSFER_BIT) {
-                foundTransferQueueFamily = true;
-                hasNeededQueue = gnTrue;
-            }
-
-            if (hasNeededQueue) {
-                vulkanNeededQueue neededQueue = {
-                    .queueIndex = c,
-                    .createFlags = 0,
-                    .usedForPresent = gnFalse
-                };
-                if ((queueFamilies[c].queueFlags & VK_QUEUE_GRAPHICS_BIT)) neededQueue.createFlags |= VK_QUEUE_GRAPHICS_BIT;
-                if ((queueFamilies[c].queueFlags & VK_QUEUE_TRANSFER_BIT)) neededQueue.createFlags |= VK_QUEUE_TRANSFER_BIT;
-
-                outputDevices[i]->physicalDevice->neededQueues[outputDevices[i]->physicalDevice->neededQueueCount] = neededQueue;
-                outputDevices[i]->physicalDevice->neededQueueCount++;
-            }
-        }
 
         VkPhysicalDeviceProperties physicalDeviceProperties;
         vkGetPhysicalDeviceProperties(physicalDevices[i], &physicalDeviceProperties);
@@ -96,8 +104,6 @@ gnPhysicalDevice* getPhysicalDevices(gnInstanceHandle instance, uint32_t* device
         outputDevices[i]->features.maxDepthSamples = vkSampleCountToGryphn(physicalDeviceProperties.limits.framebufferDepthSampleCounts);
         outputDevices[i]->features.maxMemoryAllocations = physicalDeviceProperties.limits.maxMemoryAllocationCount;
         outputDevices[i]->features.maxPushConstantSize = physicalDeviceProperties.limits.maxPushConstantsSize;
-
-        free(queueFamilies);
     }
     free(physicalDevices);
 

projects/core/gryphn_extensions.h

@@ -1,6 +1,7 @@
 #pragma once
-#include "stdint.h"
 
-typedef uint32_t gnExtension;
+typedef enum gnExtension {
-#define GN_EXT_SYNCHRONIZATION 0
+    GN_EXT_SYNCHRONIZATION = 0,
-#define GN_EXT_QUEUES 1
+    GN_EXT_QUEUES = 1,
+    GN_EXT_MAX
+} gnExtension;

projects/core/src/gryphn_handles.h

@@ -1,6 +1,8 @@
 #pragma once
+#include <stdint.h>
 
 #define GN_NULL_HANDLE 0
+typedef uint32_t gnFlags;
 
 #define GN_HANDLE(type) \
 typedef struct type##_t* type##Handle; \

projects/core/src/instance/gryphn_instance.c

@@ -14,10 +14,10 @@ gnReturnCode gnCreateInstance(gnInstanceHandle* instance, gnInstanceInfo info) {
         .layerToLoad = api_layer
     }));
 
-    // TODO: still needs to check to see if the extension is supported
+    for (int c = 0; c < GN_EXT_MAX; c++) (*instance)->enabledExtensions[c] = gnFalse;
-    for (int i = 0; i < info.extensionCount; i++) {
+    for (int i = 0; i < info.extensionCount; i++) (*instance)->enabledExtensions[info.extensions[i]] = gnTrue;
-        if (info.extensions[i] == GN_EXT_SYNCHRONIZATION) (*instance)->layers.data[0].syncFunctions = loadAPISyncFunctions(info.renderingAPI);
+
-    }
+    if ((*instance)->enabledExtensions[GN_EXT_SYNCHRONIZATION]) (*instance)->layers.data[0].syncFunctions = loadAPISyncFunctions(info.renderingAPI);
 
     gnBool loaderFunctionChecker = gnFalse;
     if (info.debugger != NULL) {

projects/core/src/instance/gryphn_instance.h

@@ -30,6 +30,8 @@ struct gnInstance_t {
     loaderLayer* callingLayer;
     uint32_t currentLayer;
 
+    gnBool enabledExtensions[GN_EXT_MAX];
+
     gnBool hasDebugger;
     gnDebuggerInfo debugger;
 };

projects/core/src/output_device/gryphn_physical_output_device.c

@@ -14,41 +14,3 @@ gnBool gnPhysicalDeviceCanPresentToSurface(gnPhysicalOutputDeviceHandle device,
 
 gnPhysicalDeviceProperties gnGetPhysicalDeviceProperties(gnPhysicalOutputDeviceHandle device) { return device->properties; }
 gnPhysicalDeviceFeatures gnGetPhysicalDeviceFeatures(gnPhysicalOutputDeviceHandle device) { return device->features; }
-
-// gnBool gnHasGraphicsQueue(gnPhysicalDevice device) {
-//     for (int i = 0; i < device->queueProperties.queueCount; i++) {
-//         if ((device->queueProperties.queueProperties[i].queueType & GN_QUEUE_GRAPHICS) == GN_QUEUE_GRAPHICS) {
-//             return gnTrue;
-//         }
-//     }
-//     return gnFalse;
-// }
-// gnBool gnHasPresentQueue(gnPhysicalDevice device, gnWindowSurfaceHandle windowSurface) {
-//     for (int i = 0; i < device->queueProperties.queueCount; i++) {
-//         if (gnQueueCanPresentToSurface(device, i, windowSurface)) {
-//             return gnTrue;
-//         }
-//     }
-//     return gnFalse;
-// }
-
-// int gnGetGraphicsQueueIndex(gnPhysicalDevice device) {
-//     for (int i = 0; i < device->queueProperties.queueCount; i++) {
-//         if ((device->queueProperties.queueProperties[i].queueType & GN_QUEUE_GRAPHICS) == GN_QUEUE_GRAPHICS) {
-//             return i;
-//             break;
-//         }
-//     }
-//     return -1;
-// }
-// int gnGetPresentQueueIndex(gnPhysicalDevice device, gnWindowSurfaceHandle windowSurface) {
-//     for (int i = 0; i < device->queueProperties.queueCount; i++) {
-//         if (gnQueueCanPresentToSurface(device, i, windowSurface)) {
-//             return i;
-//             break;
-//         }
-//     }
-//     return -1;
-// }
-
-// gnPhysicalDeviceQueueProperties gnGetPhysicalDeviceQueueProperties(gnPhysicalOutputDeviceHandle device) { return device->queueProperties; }

projects/core/src/output_device/gryphn_physical_output_device.h

@@ -28,29 +28,11 @@ typedef struct gnPhysicalDeviceFeatures {
     uint32_t maxPushConstantSize;
 } gnPhysicalDeviceFeatures;
 
-// typedef enum gnQueueTypeFlags {
-//     GN_QUEUE_GRAPHICS       = 1 << 0,
-//     GN_QUEUE_COMPUTE        = 1 << 1,
-//     GN_QUEUE_TRANSFER       = 1 << 2,
-//     GN_QUEUE_SPARSE_BINDING = 1 << 3
-// } gnQueueTypeFlags;
-
-// typedef struct gnQueueProperties {
-//     uint32_t queueCount;
-//     gnQueueTypeFlags queueType;
-// } gnQueueProperties;
-
-// typedef struct gnPhysicalDeviceQueueProperties {
-//     uint32_t queueCount;
-//     gnQueueProperties* queueProperties;
-// } gnPhysicalDeviceQueueProperties;
-
 #ifdef GN_REVEAL_IMPL
 typedef struct gnPhysicalOutputDevice_t {
     struct gnPlatformPhysicalDevice_t* physicalDevice;
     gnPhysicalDeviceProperties properties;
     gnPhysicalDeviceFeatures features;
-    // gnPhysicalDeviceQueueProperties queueProperties;
 
     gnInstanceHandle instance;
 } gnPhysicalOutputDevice_t;
@@ -61,10 +43,3 @@ gnBool gnPhysicalDeviceCanPresentToSurface(gnPhysicalOutputDeviceHandle device,
 
 gnPhysicalDeviceProperties gnGetPhysicalDeviceProperties(gnPhysicalOutputDeviceHandle device);
 gnPhysicalDeviceFeatures gnGetPhysicalDeviceFeatures(gnPhysicalOutputDeviceHandle device);
-// gnPhysicalDeviceQueueProperties gnGetPhysicalDeviceQueueProperties(gnPhysicalOutputDeviceHandle device);
-
-// gnBool gnHasGraphicsQueue(gnPhysicalOutputDeviceHandle device);
-// gnBool gnHasPresentQueue(gnPhysicalOutputDeviceHandle device, gnWindowSurfaceHandle windowSurface);
-
-// int gnGetGraphicsQueueIndex(gnPhysicalOutputDeviceHandle device);
-// int gnGetPresentQueueIndex(gnPhysicalOutputDeviceHandle device, gnWindowSurfaceHandle windowSurface);

projects/extensions/queues/gryphn_physcial_device_queue.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "utils/gryphn_error_code.h"
+#include "gryphn_handles.h"
+
+typedef enum gnQueueTypeBits {
+    GN_QUEUE_GRAPHICS_BIT       = 1 << 0,
+    GN_QUEUE_COMPUTE_BIT        = 1 << 1,
+    GN_QUEUE_TRANSFER_BIT       = 1 << 2,
+    GN_QUEUE_SPARSE_BINDING_BIT = 1 << 3,
+    GN_QUEUE_PROTECTED_BIT      = 1 << 4
+} gnQueueTypeBits;
+typedef gnFlags gnQueueTypeFlags;
+
+typedef struct gnQueueFamilyProperties {
+    uint32_t queueCount;
+    gnQueueTypeFlags queueTypeFlags;
+} gnQueueFamilyProperties;
+
+gnReturnCode gnGetPhysicalDeviceQueueProperties(gnPhysicalOutputDeviceHandle device, uint32_t queueCount, gnQueueFamilyProperties* queues);