Remove gnCreateWindowSurface, add platform specific window creation

functions

CMakeLists.txt

@@ -12,7 +12,7 @@ add_compile_definitions(GN_REVEAL_IMPL)
 
 if(WIN32)
     add_compile_definitions(GN_PLATFORM_WIN32)
-    add_subdirectory(rendering_api/dirctx/)
+    # add_subdirectory(rendering_api/dirctx/)
     add_subdirectory(rendering_api/vulkan/)
 endif()
 if(APPLE)
@@ -23,6 +23,7 @@ endif()
 if(UNIX AND NOT APPLE)
     add_compile_definitions(GN_PLATFORM_LINUX)
     add_subdirectory(rendering_api/vulkan/)
+    target_include_directories(Gryphn PUBLIC ${CMAKE_SOURCE_DIR/Gryphn/rendering_api/metal/depends/metal-cpp/)
 endif()
 
 target_link_libraries(Gryphn)

rendering_api/metal/CMakeLists.txt

@@ -11,7 +11,6 @@ target_include_directories(GryphnMetalImpl PUBLIC
     ${CMAKE_SOURCE_DIR}/gryphn/include/
     ${CMAKE_SOURCE_DIR}/gryphn/src/
     ${CMAKE_SOURCE_DIR}/gryphn/src/
-    ${CMAKE_SOURCE_DIR}/depends/glfw/glfw-3.4/include/
     depends/metal-cpp/
     src/
     depends/SPIRV-Cross/
@@ -21,10 +20,7 @@ add_compile_definitions(GN_REVEAL_IMPL)
 add_subdirectory(depends/metal-cpp)
 add_subdirectory(depends/SPIRV-Cross)
 
-add_library(glfw SHARED IMPORTED)
+target_link_libraries(GryphnMetalImpl METAL_CPP spirv-cross-core spirv-cross-msl spirv-cross-cpp)
-set_target_properties(glfw PROPERTIES IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/build/depends/glfw/glfw-3.4/src/libglfw.3.4.dylib)
-
-target_link_libraries(GryphnMetalImpl METAL_CPP glfw spirv-cross-core spirv-cross-msl spirv-cross-cpp)
 
 target_link_libraries(GryphnMetalImpl
     "-framework IOKit"

rendering_api/metal/src/bridge/metal_bridege.mm

@@ -3,16 +3,12 @@
 #import <QuartzCore/CAMetalLayer.h>
 #import <QuartzCore/QuartzCore.h>
 #import <Metal/Metal.h>
-#define GLFW_EXPOSE_NATIVE_COCOA
-#include <GLFW/glfw3.h>
-#include <GLFW/glfw3native.h>
 
-void mtlObjectCSetContentViewsLayer(void* window, void* layer) {
+void mtlObjectCSetContentViewsLayer(void* view, void* layer) {
     [CATransaction begin];
     [CATransaction setDisableActions:YES];
 
-    NSWindow* nsWindow = (NSWindow*)glfwGetCocoaWindow((GLFWwindow*)window);
+    NSView* contentView = (__bridge NSView*)view;
-    NSView* contentView = [nsWindow contentView];
 
     CAMetalLayer* metalLayer = (__bridge CAMetalLayer*)layer;
 
@@ -22,17 +18,17 @@ void mtlObjectCSetContentViewsLayer(void* window, void* layer) {
     [CATransaction commit];
 }
 
-void* mtlCreateContentView(void* targetWindow) {
+// void* mtlCreateContentView(void* targetWindow) {
-    NSWindow* window = (__bridge NSWindow*)targetWindow;
+//     NSWindow* window = (__bridge NSWindow*)targetWindow;
-    NSRect frame = [[window contentView] frame]; // fallback size
+//     NSRect frame = [[window contentView] frame]; // fallback size
-    NSView* contentView = [[NSView alloc] initWithFrame:frame];
+//     NSView* contentView = [[NSView alloc] initWithFrame:frame];
-    [window setContentView:contentView];
+//     [window setContentView:contentView];
 
-    if (contentView == nullptr)
+//     if (contentView == nullptr)
-        frame = NSMakeRect(0, 0, window.frame.size.width, window.frame.size.height);
+//         frame = NSMakeRect(0, 0, window.frame.size.width, window.frame.size.height);
 
-    return contentView;
+//     return contentView;
-}
+// }
 
 // void* mtlInitContentView(void* targetView) {
 //     NSView* view = (__bridge NSView*)targetView;

rendering_api/metal/src/bridge/metal_bridge.h

@@ -1,5 +1,5 @@
 #pragma once
 
-void mtlObjectCSetContentViewsLayer(void* window, void* layer);
+void mtlObjectCSetContentViewsLayer(void* view, void* layer);
-void* mtlCreateContentView(void* targetWindow);
+// void* mtlCreateContentView(void* targetView);
 void mtlInitializeMetalLayer(void* layer, bool vsync);

rendering_api/metal/src/core/devices/metal_output_device.cpp

@@ -1,8 +1,6 @@
 #include <core/output_device/gryphn_physical_output_device.h>
 #include <Metal/Metal.hpp>
-// #include
 #include <core/metal_instance.h>
-#include <GLFW/glfw3.h>
 #include "metal_output_devices.h"
 
 struct mtlFramebufferVertex {

rendering_api/metal/src/core/metal_instance.cpp

@@ -1,10 +1,5 @@
 #include <gryphn/gryphn.h>
 #include <gryphn/gryphn_utils.h>
-
-#import <GLFW/glfw3.h>
-#define GLFW_EXPOSE_NATIVE_COCOA
-#import <GLFW/glfw3native.h>
-
 #include "bridge/metal_bridge.h"
 #include "metal_instance.h"
 
@@ -18,14 +13,22 @@ GN_EXPORT void gnDestroyInstanceFn(gnInstance& instance) {
 
 }
 
-GN_EXPORT gnReturnCode gnInstanceSetWindowFn(gnInstance& instance, GLFWwindow* window) {
+GN_EXPORT gnReturnCode gnCreateMacOSWindowSurfaceFn(gnInstance& instance, NS::Window* window, NS::View* view) {
     if (instance.instance == nullptr) instance.instance = new gnPlatformInstanceData();
-    instance.instance->window = window;
 
-    int width, height;
+    instance.instance->metalContentView = view;
-    glfwGetFramebufferSize(instance.instance->window, &width, &height);
-
-    instance.instance->metalWindow = reinterpret_cast<NS::Window*>(glfwGetCocoaWindow(window));
-    instance.instance->metalContentView = reinterpret_cast<NS::View*>(glfwGetCocoaView(window));
     return GN_SUCCESS;
+
 }
+
+// GN_EXPORT gnReturnCode gnInstanceSetWindowFn(gnInstance& instance, GLFWwindow* window) {
+//     if (instance.instance == nullptr) instance.instance = new gnPlatformInstanceData();
+//     instance.instance->window = window;
+
+//     int width, height;
+//     glfwGetFramebufferSize(instance.instance->window, &width, &height);
+
+//     instance.instance->metalWindow = reinterpret_cast<NS::Window*>(glfwGetCocoaWindow(window));
+//     instance.instance->metalContentView = reinterpret_cast<NS::View*>(glfwGetCocoaView(window));
+//     return GN_SUCCESS;
+// }

rendering_api/metal/src/core/metal_instance.h

@@ -13,9 +13,6 @@
 struct GLFWwindow;
 
 struct gnPlatformInstanceData {
-    NS::Window* metalWindow;
     NS::View* metalContentView;
-    GLFWwindow* window;
-
     MTL::RenderPipelineState* framebufferRenderer, *testSquareRenderer;
 };

rendering_api/metal/src/core/presentation_queue/metal_presentation_queue.cpp

@@ -21,7 +21,7 @@ GN_EXPORT gnDevicePresentationDetails gnGetDevicePresentationDetailsFn(const gnP
 
 GN_EXPORT gnReturnCode gnPresentationQueueGetNextImageAsyncFn(gnPresentationQueue& presentationQueue, const gnSyncSemaphore& semaphore, gnUInt* imageIndex) {
     mtlObjectCSetContentViewsLayer(
-        presentationQueue.presentationQueue->outputDevice->outputDevice->instance->instance->window,
+        presentationQueue.presentationQueue->outputDevice->outputDevice->instance->instance->metalContentView,
         presentationQueue.presentationQueue->layer);
 
     presentationQueue.presentationQueue->currentDrawableIndex++;
@@ -43,7 +43,7 @@ GN_EXPORT gnReturnCode gnCreatePresentationQueueFn(gnPresentationQueue* presenta
     presentationQueue->presentationQueue->outputDevice = const_cast<gnOutputDevice*>(&device);
 
     presentationQueue->presentationQueue->layer = CA::MetalLayer::layer();
-    presentationQueue->presentationQueue->layer->setPixelFormat(MTL::PixelFormat::PixelFormatBGRA8Unorm_sRGB);
+    presentationQueue->presentationQueue->layer->setPixelFormat(MTL::PixelFormat::PixelFormatBGRA8Unorm);
     presentationQueue->presentationQueue->layer->setFramebufferOnly(true);
     presentationQueue->presentationQueue->layer->setDrawableSize({ (double)details.ImageSize.x, (double)details.ImageSize.y });
     presentationQueue->presentationQueue->layer->setDevice(device.outputDevice->device);
@@ -51,7 +51,7 @@ GN_EXPORT gnReturnCode gnCreatePresentationQueueFn(gnPresentationQueue* presenta
     mtlInitializeMetalLayer(presentationQueue->presentationQueue->layer, true);
 
     mtlObjectCSetContentViewsLayer(
-        device.outputDevice->instance->instance->window,
+        device.outputDevice->instance->instance->metalContentView,
         presentationQueue->presentationQueue->layer);
 
     for (int i = 0; i < details.ImageCount; i++) {

rendering_api/vulkan/CMakeLists.txt

@@ -5,32 +5,48 @@ file(GLOB_RECURSE SOURCE_FILES CONFIGURE_DEPENDS
     "src/*.cpp" "src/*.hpp"
     "src/*.c" "src/*.h"
 )
-add_library(GryphnVulkanImpl SHARED ${SOURCE_FILES})
+
+if (APPLE)
+    file(GLOB_RECURSE METAL_FILES CONFIGURE_DEPENDS
+    "src/*.mm"
+)
+endif()
+
+add_library(GryphnVulkanImpl SHARED ${SOURCE_FILES} ${METAL_FILES})
 target_include_directories(GryphnVulkanImpl PUBLIC
     ${CMAKE_SOURCE_DIR}/gryphn/include/
     ${CMAKE_SOURCE_DIR}/gryphn/src/
     ${CMAKE_SOURCE_DIR}/gryphn/src/
-    ${CMAKE_SOURCE_DIR}/depends/glfw/glfw-3.4/include/
     src/
     /Applications/vulkansdk/macOS/include/
 )
 add_compile_definitions(GN_REVEAL_IMPL)
 
-add_library(glfw SHARED IMPORTED)
-set_target_properties(glfw PROPERTIES IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/build/depends/glfw/glfw-3.4/src/libglfw.3.4.dylib)
-
 add_library(libvulkan SHARED IMPORTED)
 set_target_properties(libvulkan PROPERTIES IMPORTED_LOCATION /Applications/vulkansdk/macOS/lib/libvulkan.dylib)
 
-target_link_libraries(GryphnVulkanImpl glfw libvulkan)
+target_link_libraries(GryphnVulkanImpl libvulkan)
+
+if(WIN32)
+    add_compile_definitions(GN_PLATFORM_WIN32)
+endif()
+if(APPLE)
 
     target_link_libraries(GryphnVulkanImpl
         "-framework IOKit"
         "-framework CoreFoundation"
         "-framework CoreGraphics"
         "-framework AppKit"
+        "-framework Metal"
+        "-framework QuartzCore"
     )
 
+    add_compile_definitions(GN_PLATFORM_MACOS)
+endif()
+if(UNIX AND NOT APPLE)
+    add_compile_definitions(GN_PLATFORM_LINUX)
+endif()
+
 file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/gryphn/rendering_apis)
 add_custom_command(TARGET GryphnVulkanImpl POST_BUILD
     COMMAND mv libGryphnVulkanImpl.dylib ../../rendering_apis/GryphnVulkanImpl.dylib

rendering_api/vulkan/src/instance/vulkan_instance.cpp

@@ -1,12 +1,11 @@
-#define GLFW_INCLUDE_VULKAN
-#include <GLFW/glfw3.h>
-
 #include "gryphn/gryphn_utils.h"
 #include "vector"
 #include <cstring>
 #include "debugger/vulkan_debugger.h"
 #include "vulkan_instance.h"
 
+
+
 // now I gotta do some shit to setup debug layers
 bool checkValidationLayerSupport(gnList<gnString> layers_to_validate) {
     uint32_t layerCount;
@@ -33,21 +32,24 @@ bool checkValidationLayerSupport(gnList<gnString> layers_to_validate) {
     return true;
 }
 
-std::vector<const char*> getRequiredExtensions(bool validation_layers_required) {
+// std::vector<const char*> getRequiredExtensions(bool validation_layers_required, gnInstance& instance) {
-    uint32_t glfwExtensionCount = 0;
+//     // uint32_t glfwExtensionCount = 0;
-    const char** glfwExtensions;
+//     // const char** glfwExtensions;
-    glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
+//     // glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
 
-    std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);
+//     std::vector<const char*> extensions(instance.instance->extensions, instance.instance->extensions + instance.instance->extensionCount);
 
-    if (validation_layers_required) {
+//     if (validation_layers_required) {
-        extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
+//         extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
-    }
+//     }
-    extensions.push_back("VK_KHR_portability_enumeration");
-    extensions.push_back("VK_EXT_metal_surface");
 
-    return extensions;
+//     #ifdef GN_PLATFORM_MACOS
-}
+//     extensions.push_back("VK_KHR_portability_enumeration");
+//     extensions.push_back("VK_EXT_metal_surface");
+//     #endif
+
+//     return extensions;
+// }
 
 void gnInstanceSetAppInfoFn(gnInstance& instance, gnAppInfo& info) {
     if (instance.instance == nullptr) instance.instance = new gnPlatformInstanceData();
@@ -76,14 +78,36 @@ GN_EXPORT gnReturnCode gnCreateInstanceFn(gnInstance* instance) {
 
     instance->valid = true;
 
+    #ifdef GN_PLATFORM_LINUX
+    #ifdef GN_WINDOW_X11
+    instance->instance->extensions.push_back("VK_KHR_xlib_surface");
+    #endif
+    #ifdef GN_WINFDOW_WAYLAND
+    instance->instance->extensions.push_back("VK_KHR_wayland_surface");
+    #endif
+    #endif
+    #ifdef GN_PLATFORM_WINDOWS
+    instance->instance->extensions.push_back("VK_MVK_macos_surface");
+    #endif
+    #ifdef GN_PLATFORM_MACOS
+    instance->instance->extensions.push_back("VK_MVK_macos_surface");
+    instance->instance->extensions.push_back("VK_KHR_portability_enumeration");
+    instance->instance->extensions.push_back("VK_EXT_metal_surface");
+    #endif
+
+
+    instance->instance->extensions.push_back("VK_KHR_surface");
+    if (instance->debugger)
+        instance->instance->extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
+
     VkInstanceCreateInfo createInfo{};
     createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     createInfo.pApplicationInfo = &instance->instance->appInfo;
     createInfo.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
-    auto extensions = getRequiredExtensions(instance->debugger);
+    // auto extensions = getRequiredExtensions(instance->debugger);
 
-    createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());;
+    createInfo.enabledExtensionCount = static_cast<uint32_t>(instance->instance->extensions.size());;
-    createInfo.ppEnabledExtensionNames = extensions.data();
+    createInfo.ppEnabledExtensionNames = instance->instance->extensions.data();
 
     VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{};
     if (instance->debugger != nullptr) {
@@ -116,16 +140,3 @@ GN_EXPORT void gnDestroyInstanceFn(gnInstance& instance) {
     vkDestroySurfaceKHR(instance.instance->vk_instance, instance.instance->window_surface, nullptr);
     vkDestroyInstance(instance.instance->vk_instance, nullptr);
 }
-
-GN_EXPORT gnReturnCode gnInstanceSetWindowFn(gnInstance& instance, GLFWwindow* window) {
-    instance.instance->window = window;
-
-    if (glfwVulkanSupported() != GLFW_TRUE) {
-        return gnReturnError(GN_UNSUPPORTED_RENDERING_API, "vulkan is not actually supported\n");
-    }
-
-    VkResult result = glfwCreateWindowSurface(instance.instance->vk_instance, window, nullptr, &instance.instance->window_surface);\
-    if (result != VK_SUCCESS)
-        return gnReturnError(GN_FAILED_TO_ATTACH_WINDOW, std::to_string(result).c_str());
-    return GN_SUCCESS;
-}

rendering_api/vulkan/src/instance/vulkan_instance.h

@@ -1,10 +1,14 @@
 #pragma once
 #include "core/instance/gryphn_instance.h"
 #include <vulkan/vulkan.h>
+#ifdef GN_PLATFORM_MACOS
+#include "vulkan_macos_bridge.h"
+#endif
 
 struct gnPlatformInstanceData {
     VkInstance vk_instance;
     VkApplicationInfo appInfo;
     VkSurfaceKHR window_surface;
-    GLFWwindow* window;
+
+    std::vector<const char*> extensions;
 };

rendering_api/vulkan/src/instance/vulkan_macos_bridge.h

@@ -0,0 +1,2 @@
+#pragma once
+void* macosBridge(void* window, void* view);

rendering_api/vulkan/src/instance/vulkan_macos_bridge.mm

@@ -0,0 +1,18 @@
+#include "vulkan_macos_bridge.h"
+#import <Cocoa/Cocoa.h>
+#import <QuartzCore/CAMetalLayer.h>
+#import <QuartzCore/QuartzCore.h>
+#import <Metal/Metal.h>
+
+// kinda borrowed from cocoa_window.m in GLFW
+void* macosBridge(void* inputWindow, void* inputView) {
+    NSWindow* window = (__bridge NSWindow*)inputView;
+    NSView* view = (__bridge NSView*)inputView;
+
+    CAMetalLayer* layer = [CAMetalLayer layer];
+    [layer setContentsScale:[window backingScaleFactor]];
+
+    [view setLayer:layer];
+    [view setWantsLayer:YES];
+    return layer;
+}

rendering_api/vulkan/src/instance/vulkan_surfance.cpp

@@ -0,0 +1,70 @@
+#include "vulkan_instance.h"
+
+#ifdef GN_PLATFORM_LINUX
+#ifdef GN_WINDOW_X11
+#include <vulkan/vulkan_xlib.h>
+#include <X11/Xlib.h>
+
+GN_EXPORT gnReturnCode gnCreateX11WindowSurfaceFn(gnInstance& instance, Display* display, Window* window) {
+    VkXlibSurfaceCreateInfoKHR info{};
+    info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
+    info.dpy = display;
+    info.window = window;
+
+    vkCreateXlibSurfaceKHR(instance.instance->vk_instance, &info, nullptr, &instance.instance->window_surface);
+    return GN_SUCCESS;
+}
+#endif
+
+#ifdef GN_WINFDOW_WAYLAND
+#include <vulkan/vulkan_wayland.h>
+#include <wayland-client.h>
+GN_EXPORT gnReturnCode gnCreateWaylandWindowSurfaceFn(gnInstance& instance, wl_display* display, wl_surface* surface) {
+    VkWaylandSurfaceCreateInfoKHR info{};
+    info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
+    info.display = display;
+    info.surface = surface;
+
+    VkSurfaceKHR surface;
+    vkCreateWaylandSurfaceKHR(instance.instance->vk_instance, &info, nullptr, &instance.instance->window_surface);
+    return GN_SUCCESS;
+}
+#endif
+#endif
+
+#ifdef GN_PLATFORM_WINDOWS
+#include "vulkan/vulkan_win32.h"
+GN_EXPORT gnReturnCode gnCreateWindowsWindowSurfaceFn(gnInstance& instance, HWND* window, HINSTANCE* instance) {
+    VkWin32SurfaceCreateInfoKHR info{};
+    info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+    info.hwnd = window;
+    info.hinstance = instance;
+
+    VkSurfaceKHR surface;
+    vkCreateWin32SurfaceKHR(instance.instance->vk_instance, &info, nullptr, &instance.instance->window_surface);
+    return GN_SUCCESS;
+}
+#endif
+#include "vulkan/vulkan_macos.h"
+#include "vulkan/vulkan_metal.h"
+
+#ifdef GN_PLATFORM_MACOS
+GN_EXPORT gnReturnCode gnCreateMacOSWindowSurfaceFn(gnInstance& instance, NS::Window* window, NS::View* view) {
+    // VkMacOSSurfaceCreateInfoMVK info{};
+    // info.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
+    // info.pView = (void*)view;
+
+    VkMetalSurfaceCreateInfoEXT surfaceCreateInfo = {};
+    surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
+    surfaceCreateInfo.pNext = nullptr;
+    surfaceCreateInfo.flags = 0;
+    surfaceCreateInfo.pLayer = macosBridge(window, view);
+
+    VkSurfaceKHR surface;
+    VkResult result = vkCreateMetalSurfaceEXT(instance.instance->vk_instance, &surfaceCreateInfo, nullptr, &instance.instance->window_surface);
+
+    // VkSurfaceKHR surface;
+    // vkCreateMacOSSurfaceMVK(instance.instance->vk_instance, &info, nullptr, &instance.instance->window_surface);
+    // return GN_SUCCESS;
+}
+#endif

rendering_api/vulkan/src/presentation_queue/vulkan_presentation_queue.cpp

@@ -15,14 +15,12 @@ GN_EXPORT gnReturnCode gnCreatePresentationQueueFn(gnPresentationQueue* presenta
     presentationQueue->presentationQueue->outputDevice = const_cast<gnOutputDevice*>(&device);
 
     vulkanSwapchainDetails swapchain_details = vulkanGetSwapchainDetails(
-            device.physicalOutputDevice->physicalOutputDevice->instance->instance->window,
+        { (float)details.ImageSize.x, (float)details.ImageSize.y },
         device.physicalOutputDevice->physicalOutputDevice->instance->instance->window_surface,
         device.physicalOutputDevice->physicalOutputDevice->device
     );
     presentationQueue->presentationQueue->swapchainDetails = swapchain_details;
 
-    //std::cout << "Swapchain Image Format: " << presentationQueue->presentation_queue->swapchainDetails.surfaceFormat << "\n";
-
     VkSwapchainCreateInfoKHR createInfo{};
     createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
     createInfo.surface = device.physicalOutputDevice->physicalOutputDevice->instance->instance->window_surface;

rendering_api/vulkan/src/presentation_queue/vulkan_swapchain.h

@@ -1,5 +1,4 @@
 #pragma once
-#include <GLFW/glfw3.h>
 #include <vulkan/vulkan.h>
 #include <gryphn/gryphn_utils.h>
 #include <cstdint> // Necessary for uint32_t
@@ -7,6 +6,7 @@
 #include <algorithm> // Necessary for std::clamp
 #include "vector"
 #include "set"
+#include <iostream>
 
 const std::vector<const char*> deviceExtensions = {
     VK_KHR_SWAPCHAIN_EXTENSION_NAME,
@@ -33,16 +33,16 @@ static VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR
     return VK_PRESENT_MODE_FIFO_KHR;
 }
 
-static VkExtent2D chooseSwapExtent(GLFWwindow* window, const VkSurfaceCapabilitiesKHR& capabilities) {
+static VkExtent2D chooseSwapExtent(gnVec2 size, const VkSurfaceCapabilitiesKHR& capabilities) {
     if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max()) {
         return capabilities.currentExtent;
     } else {
-        int width, height;
+        // int width, height;
-        glfwGetFramebufferSize(window, &width, &height);
+        // glfwGetFramebufferSize(window, &width, &height);
 
         VkExtent2D actualExtent = {
-            static_cast<uint32_t>(width),
+            static_cast<uint32_t>(size.x),
-            static_cast<uint32_t>(height)
+            static_cast<uint32_t>(size.y)
         };
 
         actualExtent.width = std::clamp(actualExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);

rendering_api/vulkan/src/presentation_queue/vulkan_swapchain_support.h

@@ -11,12 +11,12 @@ struct vulkanSwapchainDetails {
     SwapChainSupportDetails swapChainSupport;
 };
 
-static vulkanSwapchainDetails vulkanGetSwapchainDetails(GLFWwindow* window, const VkSurfaceKHR& surface, const VkPhysicalDevice& physicalDevice) {
+static vulkanSwapchainDetails vulkanGetSwapchainDetails(gnVec2 size, const VkSurfaceKHR& surface, const VkPhysicalDevice& physicalDevice) {
     SwapChainSupportDetails swapChainSupport = querySwapChainSupport(surface, physicalDevice);
 
     VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
     VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
-    VkExtent2D extent = chooseSwapExtent(window, swapChainSupport.capabilities);
+    VkExtent2D extent = chooseSwapExtent(size, swapChainSupport.capabilities);
 
     return {
         surfaceFormat, presentMode, extent, swapChainSupport

src/core/init/gryphn_init.cpp

@@ -54,7 +54,27 @@ gnReturnCode gnInit(gnRenderingAPI RenderingAPI) {
     gnLoadDLLFunction(gnRenderingAPILIB, gnCreateInstance, "gnCreateInstanceFn");
     gnLoadDLLFunction(gnRenderingAPILIB, gnDestroyInstance, "gnDestroyInstanceFn");
     gnLoadDLLFunction(gnRenderingAPILIB, gnGetPlatformLayerName, "gnGetPlatformLayerNameFn");
-    gnLoadDLLFunction(gnRenderingAPILIB, gnInstanceSetWindow, "gnInstanceSetWindowFn");
+
+    // LOAD THE SET WINDOW FUNCTIONS
+    #ifdef GN_PLATFORM_LINUX
+        #ifdef GN_WINDOW_X11
+            gnLoadDLLFunction(gnRenderingAPILIB, gnCreateX11WindowSurface, "gnCreateX11WindowSurfaceFn");
+        #endif
+        #ifdef GN_WINDOW_WAYLAND
+            gnLoadDLLFunction(gnRenderingAPILIB, gnCreateWaylandWindowSurface, "gnCreateWaylandWindowSurfaceFn");
+        #endif
+    #endif
+
+
+    #ifdef GN_PLATFORM_WIN32
+        gnLoadDLLFunction(gnRenderingAPILIB, gnCreateWindowsWindowSurface, "gnCreateWindowsWindowSurfaceFn");
+    #endif
+
+    #ifdef GN_PLATFORM_MACOS
+        gnLoadDLLFunction(gnRenderingAPILIB, gnCreateMacOSWindowSurface, "gnCreateMacOSWindowSurfaceFn");
+    #endif
+    // This is stupid
+
     gnLoadDLLFunction(gnRenderingAPILIB, gnCreateDebugger, "gnCreateDebuggerFn");
     gnLoadDLLFunction(gnRenderingAPILIB, gnDestroyDebugger, "gnDestroyDebuggerFn");
     gnLoadDLLFunction(gnRenderingAPILIB, gnGetPhysicalOutputDevices, "gnGetPhysicalOutputDevicesFn");

src/core/instance/gryphn_instance.h

@@ -3,8 +3,7 @@
 #include "application_information/gryphn_app_info.h"
 #include "core/debugger/gryphn_debugger.h"
 #include <core/output_device/gryphn_output_device.h>
-
+#include <platform/gryphn_platform_include.h>
-class GLFWwindow;
 
 struct gnPlatformInstanceData;
 
@@ -23,7 +22,26 @@ void gnInstanceSetDebugger(gnInstance& instance, gnDebugger& debugger);
 
 inline gnReturnCode (*gnCreateInstance)(gnInstance* instance);
 inline void (*gnDestroyInstance)(gnInstance& instance);
-inline gnReturnCode (*gnInstanceSetWindow)(gnInstance& instance, GLFWwindow* window);
+// inline gnReturnCode (*gnInstanceSetWindow)(gnInstance& instance, GLFWwindow* window);
+
+#ifdef GN_PLATFORM_LINUX
+    #ifdef GN_WINDOW_X11
+        inline gnReturnCode (*gnCreateX11WindowSurface)(gnInstance& instance, Display* display, Window* window);
+    #endif
+    #ifdef GN_WINDOW_WAYLAND
+        inline gnReturnCode (*gnCreateWaylandWindowSurface)(gnInstance& instance, wl_display* display, wl_surface* surface);
+    #endif
+#endif
+
+
+#ifdef GN_PLATFORM_WIN32
+    inline gnReturnCode (*gnCreateWindowsWindowSurface)(gnInstance& instance, HWND* window, HINSTANCE* instance);
+#endif
+
+#ifdef GN_PLATFORM_MACOS
+    inline gnReturnCode (*gnCreateMacOSWindowSurface)(gnInstance& instance, NS::Window* window, NS::View* view);
+#endif
+
 
 // TODO: if instance creation fails add in a query to why the instance creation failed
 // Lowkey thats a lot of work tho and I dont really want to do alllllll that

src/platform/gryphn_platform_include.h

@@ -1,10 +1,15 @@
 #pragma once
 
+
 #ifdef GN_PLATFORM_LINUX
 #include <platform/platform_linux/gryphn_platform_linux.h>
-#elif GN_PLATFORM_MACOS
+#endif
+
+#ifdef GN_PLATFORM_MACOS
 #include <platform/platform_macos/gryphn_platform_macos.h>
-#elif GN_PLATFORM_WINDOWS
+#endif
+
+#ifdef GN_PLATFORM_WINDOWS
 #include <platform/platform_windows/gryphn_platform_windows.h>
 #endif
 

src/platform/platform_linux/gryphn_platform_linux.h

@@ -0,0 +1,7 @@
+#ifdef GN_WINDOW_X11
+#include <X11/Xlib.h>
+#endif
+
+#ifdef GN_WINDOW_WAYLAND
+#include <wayland-client.h>
+#endif

src/platform/platform_macos/gryphn_platform_macos.h

@@ -3,3 +3,9 @@
 #include <utils/strings/gryphn_string.h>
 #include <vector>
 #include <dlfcn.h>
+
+namespace NS {
+    struct Window;
+    struct View;
+}
+// #include "AppKit/NSView.hpp"