rename to projects (DOES NOT COMPILE)

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

@@ -0,0 +1,41 @@
+#include "vulkan_device_extensions.h"
+#include "utils/gryphn_bool.h"
+#include "stdlib.h"
+#include "string.h"
+#include "stdio.h"
+
+const char* *vkGetGryphnDeviceExtensions(uint32_t* outCount, VkPhysicalDevice device) {
+    uint32_t count = 1;
+    const char* *extensiosns = malloc(sizeof(const char*) * count);
+    extensiosns[count-1] = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
+
+    #ifdef GN_PLATFORM_MACOS
+    count++;
+    extensiosns = realloc(extensiosns, sizeof(const char*) * count);
+    extensiosns[(count - 1)] = "VK_KHR_portability_subset";
+    #endif
+
+    uint32_t extensionCount = 0;
+    vkEnumerateDeviceExtensionProperties(device, NULL, &extensionCount, NULL);
+    VkExtensionProperties* vkExtensions = malloc(sizeof(VkExtensionProperties) * extensionCount);
+    vkEnumerateDeviceExtensionProperties(device, NULL, &extensionCount, vkExtensions);
+
+    gnBool supportsDescriptorPoolOverallocation = gnFalse;
+    for (uint32_t i = 0; i < extensionCount; i++) {
+        if (strcmp(VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME, vkExtensions[i].extensionName) == 0) {
+            supportsDescriptorPoolOverallocation = gnTrue;
+            break;
+        }
+    }
+    free(vkExtensions);
+
+    if (supportsDescriptorPoolOverallocation) {
+        count++;
+        extensiosns = realloc(extensiosns, sizeof(const char*) * count);
+        extensiosns[(count - 1)] = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME;
+    }
+
+    *outCount = count;
+
+    return extensiosns;
+}

projects/apis/vulkan/src/output_device/vulkan_device_extensions.h

@@ -0,0 +1,4 @@
+#pragma once
+#include <vulkan/vulkan.h>
+
+const char* *vkGetGryphnDeviceExtensions(uint32_t* count, VkPhysicalDevice device);

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

@@ -0,0 +1,109 @@
+#include <vulkan/vulkan.h>
+#include <output_device/vulkan_physical_device.h>
+#include <output_device/vulkan_output_devices.h>
+#include "vulkan_device_extensions.h"
+#include "core/instance/gryphn_instance.h"
+#include "commands/command_buffer/vulkan_command_buffer.h"
+
+gnReturnCode gnCreateOutputDeviceFn(gnOutputDeviceHandle outputDevice, gnInstanceHandle instance, gnOutputDeviceInfo deviceInfo) {
+    outputDevice->outputDevice = malloc(sizeof(gnPlatformOutputDevice));
+
+    VkDeviceQueueCreateInfo* queueCreateInfos = malloc(sizeof(VkDeviceQueueCreateInfo) * deviceInfo.queueInfoCount);
+    float queuePriority = 1.0f;
+    for (int i = 0; i < deviceInfo.queueInfoCount; i++) {
+        queueCreateInfos[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+        queueCreateInfos[i].flags = 0;
+        queueCreateInfos[i].queueFamilyIndex = deviceInfo.queueInfos[i].queueIndex;
+        queueCreateInfos[i].queueCount = deviceInfo.queueInfos[i].queueCount;
+        queueCreateInfos[i].pQueuePriorities = &queuePriority;
+    }
+
+    VkPhysicalDeviceFeatures deviceFeatures = {
+        .samplerAnisotropy = VK_TRUE
+    };
+
+
+
+    VkDeviceCreateInfo deviceCreateInfo = {
+        .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+        .queueCreateInfoCount = deviceInfo.queueInfoCount,
+        .pQueueCreateInfos = queueCreateInfos,
+        .pEnabledFeatures = &deviceFeatures
+    };
+    deviceCreateInfo.ppEnabledExtensionNames = vkGetGryphnDeviceExtensions(&deviceCreateInfo.enabledExtensionCount, deviceInfo.physicalDevice.physicalDevice->device);
+
+    outputDevice->outputDevice->enabledOversizedDescriptorPools = gnFalse;
+    for (int i = 0; i < deviceCreateInfo.enabledExtensionCount; i++)
+        if (strcmp(deviceCreateInfo.ppEnabledExtensionNames[i], VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME) == 0) outputDevice->outputDevice->enabledOversizedDescriptorPools = gnTrue;
+
+    if (instance->debugger == NULL)
+        deviceCreateInfo.enabledLayerCount = 0;
+    else {
+        const char* validation_layers[1] = { "VK_LAYER_KHRONOS_validation" };
+        deviceCreateInfo.enabledLayerCount = 1;
+        deviceCreateInfo.ppEnabledLayerNames = validation_layers;
+    }
+
+    if (vkCreateDevice(deviceInfo.physicalDevice.physicalDevice->device, &deviceCreateInfo, NULL, &outputDevice->outputDevice->device) != VK_SUCCESS)
+        return GN_FAILED_TO_CREATE_DEVICE;
+
+    outputDevice->outputDevice->queues = malloc(sizeof(VkQueue) * deviceInfo.queueInfoCount);
+    for (int i = 0; i < deviceInfo.queueInfoCount; i++) {
+        vkGetDeviceQueue(outputDevice->outputDevice->device, deviceInfo.queueInfos[i].queueIndex, 0, &outputDevice->outputDevice->queues[i]);
+    }
+
+    uint32_t queueCount = 0;
+    vkGetPhysicalDeviceQueueFamilyProperties(
+        deviceInfo.physicalDevice.physicalDevice->device,
+        &queueCount,
+        NULL
+    );
+
+    VkQueueFamilyProperties* queueFamilies = malloc(sizeof(VkQueueFamilyProperties) * queueCount);
+    vkGetPhysicalDeviceQueueFamilyProperties(
+        deviceInfo.physicalDevice.physicalDevice->device,
+        &queueCount,
+        queueFamilies
+    );
+
+    uint32_t transferQueueIndex = 0;
+    for (int i = 0; i < queueCount; i++) {
+        if ((queueFamilies[i].queueFlags & VK_QUEUE_TRANSFER_BIT) == VK_QUEUE_TRANSFER_BIT) {
+            transferQueueIndex = i;
+            vkGetDeviceQueue(outputDevice->outputDevice->device, deviceInfo.queueInfos[i].queueIndex, 0, &outputDevice->outputDevice->transferQueue);
+            break;
+        }
+    }
+
+    VkCommandPoolCreateInfo poolInfo = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
+        .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
+        .queueFamilyIndex = transferQueueIndex
+    };
+
+    if (vkCreateCommandPool(outputDevice->outputDevice->device, &poolInfo, NULL, &outputDevice->outputDevice->transferCommandPool) != VK_SUCCESS)
+        return GN_FAILED_TO_CREATE_COMMAND_POOL;
+
+    free(queueCreateInfos);
+    free(queueFamilies);
+
+    return GN_SUCCESS;
+}
+
+void gnWaitForDeviceFn(const gnOutputDeviceHandle device) {
+    vkDeviceWaitIdle(device->outputDevice->device);
+}
+
+void gnDestroyOutputDeviceFn(gnOutputDeviceHandle device) {
+    vkDestroyCommandPool(device->outputDevice->device, device->outputDevice->transferCommandPool, NULL);
+    vkDestroyDevice(device->outputDevice->device, NULL);
+    free(device->outputDevice);
+}
+
+
+VkCommandBuffer gnBeginVulkanTransferOperation(gnDevice device) {
+    return VkBeginTransferOperation(device->outputDevice->device, device->outputDevice->transferCommandPool);
+}
+void gnEndVulkanTransferOperation(gnDevice device, VkCommandBuffer buffer) {
+    VkEndTransferOperation(buffer, device->outputDevice->transferCommandPool, device->outputDevice->transferQueue, device->outputDevice->device);
+}

projects/apis/vulkan/src/output_device/vulkan_output_devices.h

@@ -0,0 +1,17 @@
+#pragma once
+#include <vulkan/vulkan.h>
+#include <core/output_device/gryphn_output_device.h>
+
+typedef struct gnPlatformOutputDevice_t {
+    VkDevice device;
+    uint32_t queueCount;
+    VkQueue* queues;
+
+    VkQueue transferQueue;
+    VkCommandPool transferCommandPool;
+
+    gnBool enabledOversizedDescriptorPools;
+} gnPlatformOutputDevice;
+
+VkCommandBuffer gnBeginVulkanTransferOperation(gnDevice device);
+void gnEndVulkanTransferOperation(gnDevice device, VkCommandBuffer commandBuffer);

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

@@ -0,0 +1,58 @@
+#include "vulkan_physical_device.h"
+#include <instance/vulkan_instance.h>
+#include <output_device/vulkan_device_extensions.h>
+#include <vulkan_surface/vulkan_surface.h>
+
+gnPhysicalDevice* gnGetPhysicalDevicesFn(gnInstanceHandle instance, uint32_t* deviceCount) {
+    vkEnumeratePhysicalDevices(instance->instance->vk_instance, deviceCount, NULL);
+    if (deviceCount == 0)
+        return NULL;
+
+    VkPhysicalDevice* physicalDevices = malloc(sizeof(VkPhysicalDevice) * *deviceCount);
+    vkEnumeratePhysicalDevices(instance->instance->vk_instance, deviceCount, physicalDevices);
+    gnPhysicalDevice* outputDevices = (gnPhysicalDevice*)malloc(sizeof(gnPhysicalDevice) * *deviceCount);
+
+    for (int i = 0; i < *deviceCount; i++) {
+        outputDevices[i].physicalDevice = malloc(sizeof(struct gnPlatformPhysicalDevice_t));
+        outputDevices[i].physicalDevice->device = physicalDevices[i];
+
+        VkPhysicalDeviceProperties deviceProperties;
+        vkGetPhysicalDeviceProperties(physicalDevices[i], &deviceProperties);
+        outputDevices[i].properties.name = gnCreateString(deviceProperties.deviceName);
+        switch(deviceProperties.deviceType) {
+        case VK_PHYSICAL_DEVICE_TYPE_OTHER: outputDevices[i].properties.deviceType = GN_EXTERNAL_DEVICE;
+        case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: outputDevices[i].properties.deviceType = GN_INTEGRATED_DEVICE;
+        case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: outputDevices[i].properties.deviceType = GN_DEDICATED_DEVICE;
+        case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: outputDevices[i].properties.deviceType = GN_INTEGRATED_DEVICE;
+        case VK_PHYSICAL_DEVICE_TYPE_CPU: outputDevices[i].properties.deviceType = GN_INTEGRATED_DEVICE;
+        case VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM: outputDevices[i].properties.deviceType = GN_INTEGRATED_DEVICE;
+        }
+
+        vkGetPhysicalDeviceQueueFamilyProperties(physicalDevices[i], &outputDevices[i].queueProperties.queueCount, NULL);
+
+        VkQueueFamilyProperties* queueFamilies = malloc(sizeof(VkQueueFamilyProperties) * outputDevices[i].queueProperties.queueCount);
+        outputDevices[i].queueProperties.queueProperties = malloc(sizeof(gnQueueProperties) * outputDevices[i].queueProperties.queueCount);
+        vkGetPhysicalDeviceQueueFamilyProperties(physicalDevices[i], &outputDevices[i].queueProperties.queueCount, queueFamilies);
+        for (int c = 0; c < outputDevices[i].queueProperties.queueCount; c++) {
+            outputDevices[i].queueProperties.queueProperties[i].queueCount = queueFamilies[i].queueCount;
+
+            gnQueueTypeFlags finalQueueType = 0;
+            if (queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) finalQueueType |= GN_QUEUE_GRAPHICS;
+            if (queueFamilies[i].queueFlags & VK_QUEUE_COMPUTE_BIT) finalQueueType |= GN_QUEUE_COMPUTE;
+            if (queueFamilies[i].queueFlags & VK_QUEUE_TRANSFER_BIT) finalQueueType |= GN_QUEUE_TRANSFER;
+            if (queueFamilies[i].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) finalQueueType |= GN_QUEUE_SPARSE_BINDING;
+            outputDevices[i].queueProperties.queueProperties[i].queueType = finalQueueType;
+        }
+    }
+    free(physicalDevices);
+
+    return outputDevices;
+}
+
+gnBool gnQueueCanPresentToSurfaceFn(const struct gnPhysicalDevice_t device, uint32_t queueIndex, gnWindowSurfaceHandle windowSurface) {
+    VkBool32 supportsPresent = VK_FALSE;
+    vkGetPhysicalDeviceSurfaceSupportKHR(device.physicalDevice->device, queueIndex, windowSurface->windowSurface->surface, &supportsPresent);
+    if (supportsPresent)
+        return gnTrue;
+    return gnFalse;
+}

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

@@ -0,0 +1,7 @@
+#pragma once
+#include <vulkan/vulkan.h>
+#include <core/output_device/gryphn_physical_output_device.h>
+
+typedef struct gnPlatformPhysicalDevice_t {
+    VkPhysicalDevice device;
+} gnPlatformPhysicalDevice;