get OpenGL to work

CMakeLists.txt

@@ -34,7 +34,7 @@ add_subdirectory(projects/core) # build gryphn core
 add_subdirectory(projects/extensions)
 add_subdirectory(projects/platform) # build gryphn platform
 add_subdirectory(projects/validation_layers/function_loader/)
-target_link_libraries(Gryphn INTERFACE GryphnUtils GryphnCore GryphnLoader GryphnPlatform GryphnFunctionValidator GryphnExtensions)
+target_link_libraries(Gryphn INTERFACE GryphnCore GryphnLoader GryphnPlatform GryphnFunctionValidator GryphnExtensions)
 
 if (VULKAN_BUILT)
     target_link_libraries(Gryphn INTERFACE GryphnVulkanImpl)
@@ -45,3 +45,5 @@ endif()
 if (OPENGL_BUILT)
     target_link_libraries(Gryphn INTERFACE GryphnOpenGLImpl)
 endif()
+
+target_link_libraries(Gryphn INTERFACE GryphnUtils)

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;
+}

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

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);

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) {}

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);

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));
-
+    devices[0] = malloc(sizeof(struct gnPhysicalOutputDevice_t));
-    gnPhysicalDevice device = {
+    *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) {
+gnBool openglCanDevicePresent(gnPhysicalDevice device, gnWindowSurfaceHandle windowSurface) {
-    return gnTrue;
+    return GN_TRUE;
 }

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);

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) {
+    if (instanceInfo->coreAPI != GN_RENDERINGAPI_OPENGL) return GN_UNSUPPORTED_API;
     return GN_SUCCESS;
 }
-void destroyOpenGLInstance(gnInstanceHandle instance) {
+void openglDestroyInstance(gnInstanceHandle instance, gryphnInstanceFunctionLayers* next) {
 
 }

projects/apis/opengl/src/instance/opengl_instance.h

@@ -4,5 +4,5 @@
 
 typedef struct gnPlatformInstance_t {} gnPlatformInstance;
 
-gnReturnCode createOpenGLInstance(gnInstanceHandle instance, gnInstanceInfo instanceInfo);
+gnReturnCode openglCreateInstance(gnInstanceHandle instance, gnInstanceCreateInfo* instanceInfo, gryphnInstanceFunctionLayers* next);
-void destroyOpenGLInstance(gnInstanceHandle instance);
+void openglDestroyInstance(gnInstanceHandle instance, gryphnInstanceFunctionLayers* next);

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);
+        GLuintArrayListAdd(presentationQueue->presentationQueue->textures, presentationQueue->images[i]->texture->id);
-        uint32_tArrayListAdd(&presentationQueue->presentationQueue->avaliableTextures, i);
+        uint32_tArrayListAdd(presentationQueue->presentationQueue->avaliableTextures, i);
     }
     return GN_SUCCESS;
 }
 gnReturnCode getOpenGLPresentationQueueImage(gnPresentationQueue presentationQueue, uint32_t* imageIndex) {
-    while (presentationQueue->presentationQueue->avaliableTextures.count == 0) {}
+    while (uint32_tArrayListCount(presentationQueue->presentationQueue->avaliableTextures) == 0) {}
-    *imageIndex = presentationQueue->presentationQueue->avaliableTextures.data[0];
+    *imageIndex = uint32_tArrayListAt(presentationQueue->presentationQueue->avaliableTextures, 0);
-    uint32_tArrayListPopHead(&presentationQueue->presentationQueue->avaliableTextures);
+    uint32_tArrayListPopHead(presentationQueue->presentationQueue->avaliableTextures);
     return GN_SUCCESS;
 }
 void destroyOpenGLPresentationQueue(gnPresentationQueueHandle presentationQueue) {
     free(presentationQueue->presentationQueue);
 }
+
+
+
+GN_ARRAY_LIST_DEFINITION(GLuint);

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;

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))
+    if (!gladLoadGLLoader((GLADloadproc)glXGetProcAddress)) {
-        return GN_FAILED_TO_INIT_OPENGL;
+        gnDebuggerSetErrorMessage(instance->debugger, (gnMessageData){
+            .message = gnCreateString("Failed to load OpenGL functions")
+        });
+
+        return GN_UNKNOWN_ERROR;
+    }
     return GN_SUCCESS;
 }