final vulkn functions

Gryphn/CMakeLists.txt

@@ -11,8 +11,10 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 # Add subdirectories
 add_subdirectory(GryphnLoader)
 if (APPLE)
+    add_compile_definitions(GN_USE_SURFACE_COCOA)
     add_subdirectory(apis/GryphnMetal)
 endif()
 if (UNIX)
+    add_compile_definitions(GN_USE_SURFACE_XLIB)
     add_subdirectory(apis/GryphnVulkan)
 endif()

Gryphn/GryphnLoader/src/core/gryphn_format.h

@@ -21,6 +21,7 @@ typedef enum gnFormat {
 
 typedef enum gnColorSpace {
     GN_COLOR_SPACE_SRGB_NONLINEAR = 0,
+    GN_COLOR_SPACE_UNKNOWN = 1
 } gnColorSpace;
 
 typedef struct gnSurfaceFormat {

Gryphn/GryphnLoader/src/core/gryphn_present_mode.h

@@ -5,4 +5,5 @@ typedef enum gnPresentMode {
     GN_PRESENT_MODE_MAILBOX = 1,
     GN_PRESENT_MODE_FIFO = 2,
     GN_PRESENT_MODE_FIFO_RELAXED = 3,
+    GN_PRESENT_MODE_UNKNOWN = 4
 } gnPresentMode;

Gryphn/apis/GryphnVulkan/src/extensions/vulkan_surface.c

@@ -0,0 +1,97 @@
+#include "core/gryphn_format.h"
+#include "core/gryphn_present_mode.h"
+#include "gryphn_return_code.h"
+#include "../vulkan_functions.h"
+#include <vulkan/vulkan_core.h>
+#include "instance/gryphn_instance.h"
+#include "surface/gryphn_surface.h"
+#include "../vulkan_helpers.h"
+#include "stdlib.h"
+#include <stdio.h>
+#ifdef GN_USE_SURFACE_XLIB
+#include <vulkan/vulkan_xlib.h>
+#endif
+
+gnReturnCode vulkanCreateXlibSurface(gnInstance instance, gnXlibSurfaceCreateInfo* info, gnSurface* surface) {
+    #ifdef GN_USE_SURFACE_XLIB
+    VkXlibSurfaceCreateInfoKHR createInfo = {
+        .sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
+        .pNext = 0,
+        .flags = 0,
+        .dpy = info->dpy,
+        .window = info->window
+    };
+    return vulkanCodeToGryphnCode(vkCreateXlibSurfaceKHR(instance->internalData, &createInfo, NULL, (VkSurfaceKHR*)surface));
+    #else
+    return GN_SUCCESS;
+    #endif
+}
+gnReturnCode vulkanGetSurfaceCapabilities(gnPhysicalDevice device, gnSurface surface, gnSurfaceCapabilities* capabilities) {
+    VkSurfaceCapabilitiesKHR vulkanCapabilities;
+    VkResult result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device->internalData, surface, &vulkanCapabilities);
+    *capabilities = (gnSurfaceCapabilities){
+        .minImageCount = vulkanCapabilities.minImageCount,
+        .maxImageCount = vulkanCapabilities.maxImageCount,
+        .currentExtent = { vulkanCapabilities.currentExtent.width, vulkanCapabilities.currentExtent.height },
+        .minImageExtent = { vulkanCapabilities.maxImageExtent.width, vulkanCapabilities.maxImageExtent.height },
+        .maxImageExtent = { vulkanCapabilities.maxImageExtent.width, vulkanCapabilities.maxImageExtent.height },
+        .maxImageArrayLayers = vulkanCapabilities.maxImageArrayLayers
+    };
+    return vulkanCodeToGryphnCode(result);
+}
+gnReturnCode vulkanGetSurfaceFormats(gnPhysicalDevice device, gnSurface surface, uint32_t* formatCount, gnSurfaceFormat* formats) {
+    uint32_t internal_formatCout;
+    gnReturnCode result = vulkanCodeToGryphnCode(vkGetPhysicalDeviceSurfaceFormatsKHR(device->internalData, surface, &internal_formatCout, NULL));
+    if (result != GN_SUCCESS) {
+        *formatCount = internal_formatCout;
+        return result;
+    }
+    VkSurfaceFormatKHR* internal_formats = malloc(sizeof(VkSurfaceFormatKHR) * internal_formatCout);
+    result = vulkanCodeToGryphnCode(vkGetPhysicalDeviceSurfaceFormatsKHR(device->internalData, surface, &internal_formatCout, internal_formats));
+    if (result != GN_SUCCESS) {
+        free(internal_formats);
+        *formatCount = internal_formatCout;
+        return result;
+    }
+    for (int i = 0; i < internal_formatCout; i++) {
+        gnSurfaceFormat format = {
+            .format = vulkanFormatToGryphnFormat(internal_formats[i].format),
+            .colorSpace = vulkanColorSpaceToGryphnColorSpace(internal_formats[i].colorSpace)
+        };
+        if ((format.format == GN_FORMAT_UNDEFINED && internal_formats[i].format != VK_FORMAT_UNDEFINED) || format.colorSpace == GN_COLOR_SPACE_UNKNOWN)
+            continue;
+        if (formats != NULL)
+            formats[*formatCount] = format;
+        (*formatCount)++;
+    }
+    free(internal_formats);
+    return GN_SUCCESS;
+}
+gnReturnCode vulkanGetSurfacePresentModes(gnPhysicalDevice device, gnSurface surface, uint32_t* presentModeCount, gnPresentMode* presentModes) {
+    uint32_t internal_presentModeCount;
+    gnReturnCode result = vulkanCodeToGryphnCode(vkGetPhysicalDeviceSurfacePresentModesKHR(device->internalData, surface, &internal_presentModeCount, NULL));
+    if (result != GN_SUCCESS) {
+        *presentModeCount = internal_presentModeCount;
+        return result;
+    }
+    VkPresentModeKHR* internal_presentModes = malloc(sizeof(VkPresentModeKHR) * internal_presentModeCount);
+    result = vulkanCodeToGryphnCode(vkGetPhysicalDeviceSurfacePresentModesKHR(device->internalData, surface, &internal_presentModeCount, NULL));
+    if (result != GN_SUCCESS) {
+        free(internal_presentModes);
+        *presentModeCount = internal_presentModeCount;
+        return result;
+    }
+    for (int i = 0; i < internal_presentModeCount; i++) {
+        gnPresentMode mode = vulkanPresentModeToGryphnPresentMode(internal_presentModes[i]);
+        if (mode == GN_PRESENT_MODE_UNKNOWN) continue;
+        if (presentModes != NULL)
+            presentModes[*presentModeCount] = mode;
+        (*presentModeCount)++;
+    }
+    free(internal_presentModes);
+    return GN_SUCCESS;
+}
+gnReturnCode vulkanDestroySurface(gnInstance instance, gnSurface* surface) {
+    vkDestroySurfaceKHR(instance->internalData, *surface, NULL);
+    return GN_SUCCESS;
+}

Gryphn/apis/GryphnVulkan/src/vulkan.c

@@ -1,3 +1,4 @@
+#include "core/gryphn_format.h"
 #include "stdio.h"
 #include "instance/gryphn_instance.h"
 #include "gryphn_handle.h"
@@ -62,15 +63,15 @@ gnReturnCode initBackend(gnInstance instance, gnInstanceCreateInfo* info) {
         if (strcmp(info->enabledExtensions[i], "GN_EXT_surface") == 0) {
             extensions[realEnabledExtensionCount] = "VK_KHR_surface";
             realEnabledExtensionCount++;
-            // instance->dispatchTable.destroySurface = metalDestroySurface;
+            instance->dispatchTable.destroySurface = vulkanDestroySurface;
-            // instance->dispatchTable.getSurfaceCapabilities = metalGetSurfaceCapabilities;
+            instance->dispatchTable.getSurfaceCapabilities = vulkanGetSurfaceCapabilities;
-            // instance->dispatchTable.getSurfaceFormats = metalGetSurfaceFormats;
+            instance->dispatchTable.getSurfaceFormats = vulkanGetSurfaceFormats;
-            // instance->dispatchTable.getSurfacePresentModes = metalGetSurfacePresentModes;
+            instance->dispatchTable.getSurfacePresentModes = vulkanGetSurfacePresentModes;
         }
         if (strcmp(info->enabledExtensions[i], "GN_EXT_surface_xlib") == 0) {
             extensions[realEnabledExtensionCount] = "VK_KHR_xlib_surface";
             realEnabledExtensionCount++;
-            // instance->dispatchTable.createMetalSurface = metalCreateSurface;
+            instance->dispatchTable.createXlibSurface = vulkanCreateXlibSurface;
         }
     }
     VkInstanceCreateInfo createInfo = {
@@ -89,18 +90,6 @@ gnReturnCode initBackend(gnInstance instance, gnInstanceCreateInfo* info) {
     instance->dispatchTable.getPhysicalDeviceProperties = vulkanGetPhysicalDeviceProperties;
     instance->dispatchTable.createDevice = vulkanCreateDevice;
 
-    // for (int i = 0; i < info->enabledExtensionCount; i++) {
-    //     if (strcmp(info->enabledExtensions[i], "GN_EXT_surface") == 0) {
-    //         instance->dispatchTable.destroySurface = metalDestroySurface;
-    //         instance->dispatchTable.getSurfaceCapabilities = metalGetSurfaceCapabilities;
-    //         instance->dispatchTable.getSurfaceFormats = metalGetSurfaceFormats;
-    //         instance->dispatchTable.getSurfacePresentModes = metalGetSurfacePresentModes;
-    //     }
-    //     if (strcmp(info->enabledExtensions[i], "GN_EXT_surface_cocoa") == 0) {
-    //         instance->dispatchTable.createMetalSurface = metalCreateSurface;
-    //     }
-    // }
-
     VkInstance vulkanInstance;
     VkResult result = vkCreateInstance(&createInfo, NULL, &vulkanInstance);
     instance->internalData = vulkanInstance;

Gryphn/apis/GryphnVulkan/src/vulkan_functions.h

@@ -4,8 +4,14 @@
 #include "gryphn_return_code.h"
 #include "device/gryphn_physical_device.h"
 #include "device/gryphn_device.h"
+#include "dispatch/gryphn_instance_dispatch_table.h"
 
 gnReturnCode vulkanEnumeratePhysicalDevices(gnInstance instance, uint32_t* deviceCount, gnPhysicalDevice* devices);
 gnReturnCode vulkanGetPhysicalDeviceProperties(gnPhysicalDevice device, gnPhysicalDeviceProperties* properties);
 gnReturnCode vulkanCreateDevice(gnInstance instance, gnDeviceCreateInfo* createInfo, gnDevice device);
 gnReturnCode vulkanDestroyDevice(gnDevice device);
+gnReturnCode vulkanCreateXlibSurface(gnInstance instance, gnXlibSurfaceCreateInfo* createInfo, gnSurface* surface);
+gnReturnCode vulkanGetSurfaceCapabilities(gnPhysicalDevice device, gnSurface surface, gnSurfaceCapabilities* capabilities);
+gnReturnCode vulkanGetSurfaceFormats(gnPhysicalDevice device, gnSurface surface, uint32_t* formatCount, gnSurfaceFormat* formats);
+gnReturnCode vulkanGetSurfacePresentModes(gnPhysicalDevice device, gnSurface surface, uint32_t* presentModeCount, gnPresentMode* presentModes);
+gnReturnCode vulkanDestroySurface(gnInstance instance, gnSurface* surface);

Gryphn/apis/GryphnVulkan/src/vulkan_helpers.c

@@ -0,0 +1,39 @@
+#include "vulkan_helpers.h"
+#include "core/gryphn_format.h"
+
+gnFormat vulkanFormatToGryphnFormat(VkFormat format) {
+    switch (format) {
+        case VK_FORMAT_UNDEFINED: return GN_FORMAT_UNDEFINED;
+        case VK_FORMAT_R8G8B8A8_UNORM: return GN_FORMAT_RGBA8_UNORM;
+        case VK_FORMAT_R8G8B8A8_SNORM: return GN_FORMAT_RGBA8_SNORM;
+        case VK_FORMAT_R8G8B8A8_USCALED: return GN_FORMAT_RGBA8_USCALED;
+        case VK_FORMAT_R8G8B8A8_SSCALED: return GN_FORMAT_RGBA8_SSCALED;
+        case VK_FORMAT_R8G8B8A8_UINT: return GN_FORMAT_RGBA8_UINT;
+        case VK_FORMAT_R8G8B8A8_SINT: return GN_FORMAT_RGBA8_SINT;
+        case VK_FORMAT_R8G8B8A8_SRGB: return GN_FORMAT_RGBA8_SRGB;
+
+        case VK_FORMAT_B8G8R8A8_UNORM: return GN_FORMAT_BGRA8_UNORM;
+        case VK_FORMAT_B8G8R8A8_SNORM: return GN_FORMAT_BGRA8_SNORM;
+        case VK_FORMAT_B8G8R8A8_USCALED: return GN_FORMAT_BGRA8_USCALED;
+        case VK_FORMAT_B8G8R8A8_SSCALED: return GN_FORMAT_BGRA8_SSCALED;
+        case VK_FORMAT_B8G8R8A8_UINT: return GN_FORMAT_BGRA8_UINT;
+        case VK_FORMAT_B8G8R8A8_SINT: return GN_FORMAT_BGRA8_SINT;
+        case VK_FORMAT_B8G8R8A8_SRGB: return GN_FORMAT_BGRA8_SRGB;
+        default: return GN_FORMAT_UNDEFINED;
+    }
+}
+gnColorSpace vulkanColorSpaceToGryphnColorSpace(VkColorSpaceKHR colorSpace) {
+    switch (colorSpace) {
+        case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR: return GN_COLOR_SPACE_SRGB_NONLINEAR;
+        default: return GN_COLOR_SPACE_UNKNOWN;
+    }
+}
+gnPresentMode vulkanPresentModeToGryphnPresentMode(VkPresentModeKHR presentMode) {
+    switch (presentMode) {
+        case VK_PRESENT_MODE_IMMEDIATE_KHR: return GN_PRESENT_MODE_IMMEDIATE;
+        case VK_PRESENT_MODE_MAILBOX_KHR: return GN_PRESENT_MODE_MAILBOX;
+        case VK_PRESENT_MODE_FIFO_KHR: return GN_PRESENT_MODE_FIFO;
+        case VK_PRESENT_MODE_FIFO_RELAXED_KHR: return GN_PRESENT_MODE_FIFO_RELAXED;
+        default: return GN_PRESENT_MODE_UNKNOWN;
+    }
+}

Gryphn/apis/GryphnVulkan/src/vulkan_helpers.h

@@ -1,5 +1,10 @@
 #pragma once
 #include "gryphn_return_code.h"
+#include "core/gryphn_format.h"
+#include "core/gryphn_present_mode.h"
 #include <vulkan/vulkan_core.h>
 
 gnReturnCode vulkanCodeToGryphnCode(VkResult result);
+gnFormat vulkanFormatToGryphnFormat(VkFormat format);
+gnColorSpace vulkanColorSpaceToGryphnColorSpace(VkColorSpaceKHR colorSpace);
+gnPresentMode vulkanPresentModeToGryphnPresentMode(VkPresentModeKHR presentMode);

main.cpp

@@ -86,8 +86,8 @@ void createSurface() {
 
     CHECK(gnCreateXlibSurface(instance, &createInfo, &surface));
 
-    // gnSurfaceCapabilities capabilites;
+    gnSurfaceCapabilities capabilites;
-    // gnGetSurfaceCapabilities(pysicalDevice, surface, &capabilites);
+    gnGetSurfaceCapabilities(pysicalDevice, surface, &capabilites);
 }
 
 void createSwapchain() {