AstralTech/Gryphn
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

make some gryphn stuff happen (DOES NOT COMPILE)

Browse Source
This commit is contained in:
Gregory Wells
2025-06-24 13:04:33 -04:00
parent 78202825db
commit 1915166c82
21 changed files with 150 additions and 294 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@@ -3,8 +3,8 @@ project(Gryphn)
add_compile_definitions(GN_PLATFORM_LINUX GN_WINDOW_X11 GN_REVEAL_IMPL) add_compile_definitions(GN_PLATFORM_LINUX GN_WINDOW_X11 GN_REVEAL_IMPL)
add_subdirectory(projects/core/) # build gryphn core
add_subdirectory(projects/loader) # build gryphn loader add_subdirectory(projects/loader) # build gryphn loader
add_subdirectory(projects/core/) # build gryphn core
add_subdirectory(projects/apis/vulkan/) add_subdirectory(projects/apis/vulkan/)
add_library(Gryphn INTERFACE) add_library(Gryphn INTERFACE)

2
include/gryphn/gryphn.h
View File

@@ -1,10 +1,10 @@
#pragma once #pragma once
#define GRYPHN_INCLUDE #define GRYPHN_INCLUDE
#include <core/src/instance/init/gryphn_init.h>
#include <core/src/instance/gryphn_instance.h> #include <core/src/instance/gryphn_instance.h>
#include <core/src/debugger/gryphn_debugger.h> #include <core/src/debugger/gryphn_debugger.h>
#include <core/src/output_device/gryphn_physical_output_device.h> #include <core/src/output_device/gryphn_physical_output_device.h>
#include <core/src/window_surface/gryphn_surface.h> #include <core/src/window_surface/gryphn_surface.h>
#include <core/src/window_surface/gryphn_surface_create_functions.h>
#include <core/src/presentation_queue/gryphn_presentation_queue.h> #include <core/src/presentation_queue/gryphn_presentation_queue.h>
#include <core/src/shader_module/gryphn_shader_module.h> #include <core/src/shader_module/gryphn_shader_module.h>
#include <core/src/pipelines/graphics_pipeline/gryphn_graphics_pipeline.h> #include <core/src/pipelines/graphics_pipeline/gryphn_graphics_pipeline.h>

1
projects/core/CMakeLists.txt
View File

@@ -12,4 +12,3 @@ target_include_directories(GryphnCore PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../)
target_include_directories(GryphnCore PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src/) target_include_directories(GryphnCore PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src/)
target_include_directories(GryphnCore PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../include/) target_include_directories(GryphnCore PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../include/)
target_include_directories(GryphnCore PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../utils) target_include_directories(GryphnCore PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../utils)
target_include_directories(GryphnCore PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../utils)

6
projects/core/src/command/command_pool/gryphn_command_pool.c
View File

@@ -1,14 +1,8 @@
#include "gryphn_command_pool.h" #include "gryphn_command_pool.h"
#include "gryphn_platform_functions.h" #include "gryphn_platform_functions.h"
#include "instance/init/gryphn_init.h"
gnReturnCode gnCreateCommandPool(gnCommandPoolHandle* commandPool, gnOutputDeviceHandle device, struct gnCommandPoolInfo_t info) { gnReturnCode gnCreateCommandPool(gnCommandPoolHandle* commandPool, gnOutputDeviceHandle device, struct gnCommandPoolInfo_t info) {
*commandPool = malloc(sizeof(struct gnCommandPool_t)); *commandPool = malloc(sizeof(struct gnCommandPool_t));
if (!device->instance->loadCommandFunctions) {
device->instance->commandFunctions = malloc(sizeof(struct gnCommandFunctions_t));
gnLoadCommandFunctions(device->instance->dynamicLib, device->instance->commandFunctions);
device->instance->loadCommandFunctions = gnTrue;
}
(*commandPool)->commandFunctions = device->instance->commandFunctions; (*commandPool)->commandFunctions = device->instance->commandFunctions;
(*commandPool)->device = device; (*commandPool)->device = device;

33
projects/core/src/gryphn_platform_functions.h
View File

@@ -20,39 +20,6 @@
#include "textures/gryphn_texture.h" #include "textures/gryphn_texture.h"
#include "uniforms/gryphn_uniform_pool.h" #include "uniforms/gryphn_uniform_pool.h"
typedef struct gnInstanceFunctions {
gnReturnCode (*_gnCreateInstance)(gnInstanceHandle instance, gnInstanceInfo info);
void (*_gnDestroyInstance)(gnInstanceHandle instance);
gnPhysicalDevice* (*_gnGetPhysicalDevices)(gnInstanceHandle instance, uint32_t* count);
gnBool (*_gnQueueCanPresentToSurface)(const gnPhysicalDevice device, uint32_t queueIndex, const gnWindowSurfaceHandle windowSurface);
gnReturnCode (*_gnCreateOutputDevice)(gnOutputDeviceHandle device, gnInstanceHandle instance, struct gnOutputDeviceInfo_t deviceInfo);
void (*_gnDestroyOutputDevice)(gnOutputDeviceHandle device);
#ifdef GN_PLATFORM_LINUX
#ifdef GN_WINDOW_X11
gnReturnCode (*_gnCreateX11WindowSurface)(gnWindowSurfaceHandle windowSurface, gnInstanceHandle instance, gnX11WindowSurfaceInfo createInfo);
#endif
#ifdef GN_WINDOW_WAYLAND
gnReturnCode (*_gnCreateWaylandWindowSurface)(gnWindowSurfaceHandle windowSurface, gnInstanceHandle instance, struct gnWaylandWindowSurfaceInfo_t createInfo);
#endif
#endif
#ifdef GN_PLATFORM_WIN32
gnReturnCode (*_gnCreateWin32WindowSurface)(gnWindowSurfaceHandle windowSurface, gnInstanceHandle instance, struct gnWin32WindowSurfaceInfo_t createInfo);
#endif
#ifdef GN_PLATFORM_MACOS
gnReturnCode (*_gnCreateMacOSWindowSurface)(gnWindowSurfaceHandle windowSurface, gnInstanceHandle instance, struct gnMacOSWindowSurfaceInfo_t createInfo);
#endif
void (*_gnDestroyWindowSurface)(gnWindowSurfaceHandle windowSurface);
gnSurfaceDetails (*_gnGetSurfaceDetails)(gnWindowSurfaceHandle windowSurface, struct gnPhysicalDevice_t device);
} gnInstanceFunctions;
#include "presentation_queue/gryphn_presentation_queue.h" #include "presentation_queue/gryphn_presentation_queue.h"
typedef struct gnDeviceFunctions_t { typedef struct gnDeviceFunctions_t {
gnReturnCode (*_gnCreatePresentationQueue)(gnPresentationQueueHandle presentationQueue, const gnOutputDeviceHandle device, gnPresentationQueueInfo presentationInfo); gnReturnCode (*_gnCreatePresentationQueue)(gnPresentationQueueHandle presentationQueue, const gnOutputDeviceHandle device, gnPresentationQueueInfo presentationInfo);

8
projects/core/src/instance/gryphn_instance.c
View File

@@ -1,10 +1,13 @@
#include "gryphn_instance.h" #include "gryphn_instance.h"
#include <gryphn_platform_functions.h> #include <gryphn_platform_functions.h>
#include "instance/gryphn_instance.h" #include "instance/gryphn_instance.h"
#include <loader/src/gryphn_instance_functions.h>
#include "loader/src/gryphn_loader.h" #include "loader/src/gryphn_loader.h"
gnReturnCode gnCreateInstance(gnInstanceHandle* instance, gnInstanceInfo info) { gnReturnCode gnCreateInstance(gnInstanceHandle* instance, gnInstanceInfo info) {
*instance = malloc(sizeof(struct gnInstance_t)); *instance = malloc(sizeof(struct gnInstance_t));
(*instance)->instanceFunctions = loadInstanceFunctions(info.renderingAPI);
// instance->dynamicLib = gnLoadRenderingDLL(info.renderingAPI); // instance->dynamicLib = gnLoadRenderingDLL(info.renderingAPI);
// if (instance->dynamicLib == NULL) return GN_UNABLE_TO_LOAD_DYNAMIC_LIBARRY; // if (instance->dynamicLib == NULL) return GN_UNABLE_TO_LOAD_DYNAMIC_LIBARRY;
// instance->functions = gnLoadFunctions(instance); // instance->functions = gnLoadFunctions(instance);
@@ -12,10 +15,9 @@ gnReturnCode gnCreateInstance(gnInstanceHandle* instance, gnInstanceInfo info) {
// if (info.debugger) // if (info.debugger)
// instance->debugger = info.debugger; // instance->debugger = info.debugger;
// return instance->functions->_gnCreateInstance(instance, info); return (*instance)->instanceFunctions._gnCreateInstance((*instance), info);
return GN_SUCCESS;
} }
void gnDestroyInstance(gnInstanceHandle instance) { void gnDestroyInstance(gnInstanceHandle instance) {
instance->functions->_gnDestroyInstance(instance); instance->instanceFunctions._gnDestroyInstance(instance);
} }

14
projects/core/src/instance/gryphn_instance.h
View File

@@ -1,11 +1,11 @@
#pragma once #pragma once
#include <gryphn/gryphn_utils.h>
#include "gryphn_rendering_api.h" #include "gryphn_rendering_api.h"
#include "gryphn_handles.h" #include "gryphn_handles.h"
#include "utils/gryphn_version.h"
#include "utils/gryphn_error_code.h"
#include "loader/src/gryphn_instance_functions.h"
typedef struct gnInstanceFunctions gnInstanceFunctions; typedef struct gnInstanceInfo {
typedef struct gnInstanceInfo_t {
gnString applicationName; gnString applicationName;
gnVersion applicationVersion; gnVersion applicationVersion;
@@ -23,9 +23,7 @@ struct gnInstance_t {
loadDeviceFunctions, loadDeviceFunctions,
loadCommandFunctions; loadCommandFunctions;
struct gnDynamicLibrary_t* dynamicLib; gnInstanceFunctions instanceFunctions;
gnInstanceFunctions *functions, *unvalidatedFunctions;
struct gnDeviceFunctions_t* deviceFunctions; struct gnDeviceFunctions_t* deviceFunctions;
struct gnCommandFunctions_t* commandFunctions; struct gnCommandFunctions_t* commandFunctions;
@@ -33,5 +31,5 @@ struct gnInstance_t {
}; };
#endif #endif
gnReturnCode gnCreateInstance(gnInstanceHandle* instance, struct gnInstanceInfo_t info); gnReturnCode gnCreateInstance(gnInstanceHandle* instance, gnInstanceInfo info);
void gnDestroyInstance(gnInstanceHandle instance); void gnDestroyInstance(gnInstanceHandle instance);

126
projects/core/src/instance/init/gryphn_init.c
View File

@@ -1,126 +0,0 @@
// #undef GN_UTILS_CPP
#include "gryphn_init.h"
#include <platform/gryphn_platform_include.h>
// #include <dlfcn.h>
#include "stdbool.h"
#include "stdio.h"
// gnBool gnIsAPISupported(gnRenderingAPI api) {
// int renderingAPICount = 0;
// gnRenderingAPI* supportedRenderingAPIS = gnGetSupportedRenderingAPIs(&renderingAPICount);
// for (int i = 0; i < renderingAPICount; i++) if (supportedRenderingAPIS[i] == api) return true;
// return false;
// }
// struct gnDynamicLibrary_t* gnLoadRenderingDLL(gnRenderingAPI renderingAPI) {
// gnString libName = gnCreateEmptyString();
// switch (renderingAPI) {
// case GN_RENDERINGAPI_NONE: return NULL;
// case GN_RENDERINGAPI_SOFTWARE: return NULL;
// case GN_RENDERINGAPI_OPENGL: return NULL;
// case GN_RENDERINGAPI_VULKAN: {
// if (!gnIsAPISupported(GN_RENDERINGAPI_VULKAN)) return NULL;
// libName = gnCreateString("GryphnVulkanImpl");
// break;
// }
// case GN_RENDERINGAPI_DIRECTX11: return NULL;
// case GN_RENDERINGAPI_DIRECTX12: return NULL;
// case GN_RENDERINGAPI_METAL: {
// if (!gnIsAPISupported(GN_RENDERINGAPI_METAL)) return NULL;
// libName = gnCreateString("GryphnMetalImpl");
// break;
// }
// }
// return gnLoadDynamicLibrary(gnCombineStrings(gnCreateString("gryphn/rendering_apis/"), libName));
// }
gnInstanceFunctions* gnLoadFunctions(gnInstanceHandle instance) {
gnInstanceFunctions* functions = malloc(sizeof(gnInstanceFunctions));
// gnLoadDLLFunction(instance->dynamicLib, functions->_gnCreateInstance, "gnCreateInstanceFn");
// gnLoadDLLFunction(instance->dynamicLib, functions->_gnDestroyInstance, "gnDestroyInstanceFn");
// gnLoadDLLFunction(instance->dynamicLib, functions->_gnGetPhysicalDevices, "gnGetPhysicalDevicesFn");
// gnLoadDLLFunction(instance->dynamicLib, functions->_gnQueueCanPresentToSurface, "gnQueueCanPresentToSurfaceFn");
// gnLoadDLLFunction(instance->dynamicLib, functions->_gnCreateOutputDevice, "gnCreateOutputDeviceFn");
// gnLoadDLLFunction(instance->dynamicLib, functions->_gnDestroyOutputDevice, "gnDestroyOutputDeviceFn");
// #ifdef GN_PLATFORM_LINUX
// #ifdef GN_WINDOW_X11
// gnLoadDLLFunction(instance->dynamicLib, functions->_gnCreateX11WindowSurface, "gnCreateX11WindowSurfaceFn");
// #endif
// #ifdef GN_WINDOW_WAYLAND
// gnLoadDLLFunction(instance->dynamicLib, functions->_gnCreateWaylandWindowSurface, "gnCreateWaylandWindowSurfaceFn");
// #endif
// #endif
// #ifdef GN_PLATFORM_WIN32
// gnLoadDLLFunction(instance->dynamicLib, functions->_gnCreateWin32WindowSurface, "gnCreateWin32WindowSurfaceFn");
// #endif
// #ifdef GN_PLATFORM_MACOS
// gnLoadDLLFunction(instance->dynamicLib, functions->_gnCreateMacOSWindowSurface, "gnCreateMacOSWindowSurfaceFn");
// #endif
// gnLoadDLLFunction(instance->dynamicLib, functions->_gnDestroyWindowSurface, "gnDestroyWindowSurfaceFn");
// gnLoadDLLFunction(instance->dynamicLib, functions->_gnGetSurfaceDetails, "gnGetSurfaceDetailsFn");
return functions;
}
void gnLoadDeviceFunctions(struct gnDynamicLibrary_t* lib, struct gnDeviceFunctions_t* functions) {
// gnLoadDLLFunction(lib, functions->_gnCreatePresentationQueue, "gnCreatePresentationQueueFn");
// gnLoadDLLFunction(lib, functions->_gnPresentationQueueGetImage, "gnPresentationQueueGetImageFn");
// gnLoadDLLFunction(lib, functions->_gnDestroyPresentationQueue, "gnDestroyPresentationQueueFn");
// gnLoadDLLFunction(lib, functions->_gnCreateShaderModule, "gnCreateShaderModuleFn");
// gnLoadDLLFunction(lib, functions->_gnDestroyShaderModule, "gnDestroyShaderModuleFn");
// gnLoadDLLFunction(lib, functions->_gnCreateRenderPassDescriptor, "gnCreateRenderPassDescriptorFn");
// gnLoadDLLFunction(lib, functions->_gnDestroyRenderPassDescriptor, "gnDestroyRenderPassDescriptorFn");
// gnLoadDLLFunction(lib, functions->_gnCreateGraphicsPipeline, "gnCreateGraphicsPipelineFn");
// gnLoadDLLFunction(lib, functions->_gnDestroyGraphicsPipeline, "gnDestroyGraphicsPipelineFn");
// gnLoadDLLFunction(lib, functions->_gnCreateFramebuffer, "gnCreateFramebufferFn");
// gnLoadDLLFunction(lib, functions->_gnDestroyFramebuffer, "gnDestroyFramebufferFn");
// gnLoadDLLFunction(lib, functions->_gnCreateCommandPool, "gnCreateCommandPoolFn");
// gnLoadDLLFunction(lib, functions->_gnDestroyCommandPool, "gnDestroyCommandPoolFn");
// gnLoadDLLFunction(lib, functions->_gnCreateSemaphore, "gnCreateSemaphoreFn");
// gnLoadDLLFunction(lib, functions->_gnDestroySemaphore, "gnDestroySemaphoreFn");
// gnLoadDLLFunction(lib, functions->_gnCreateBuffer, "gnCreateBufferFn");
// gnLoadDLLFunction(lib, functions->_gnBufferData, "gnBufferDataFn");
// gnLoadDLLFunction(lib, functions->_gnMapBuffer, "gnMapBufferFn");
// gnLoadDLLFunction(lib, functions->_gnDestroyBuffer, "gnDestroyBufferFn");
// gnLoadDLLFunction(lib, functions->_gnCreateUniformPool, "gnCreateUniformPoolFn");
// gnLoadDLLFunction(lib, functions->_gnUniformPoolAllocateUniforms, "gnUniformPoolAllocateUniformsFn");
// gnLoadDLLFunction(lib, functions->_gnDestroyUniformPool, "gnDestroyUniformPoolFn");
// gnLoadDLLFunction(lib, functions->_gnUpdateBufferUniform, "gnUpdateBufferUniformFn");
// gnLoadDLLFunction(lib, functions->_gnUpdateImageUniform, "gnUpdateImageUniformFn");
// gnLoadDLLFunction(lib, functions->_gnCreateTexture, "gnCreateTextureFn");
// gnLoadDLLFunction(lib, functions->_gnTextureData, "gnTextureDataFn");
// gnLoadDLLFunction(lib, functions->_gnDestroyTexture, "gnDestroyTextureFn");
// gnLoadDLLFunction(lib, functions->_gnCreateFence, "gnCreateFenceFn");
// gnLoadDLLFunction(lib, functions->_gnSignalFence, "gnSignalFenceFn");
// gnLoadDLLFunction(lib, functions->_gnWaitForFence, "gnWaitForFenceFn");
// gnLoadDLLFunction(lib, functions->_gnResetFence, "gnResetFenceFn");
// gnLoadDLLFunction(lib, functions->_gnDestroyFence, "gnDestroyFenceFn");
// gnLoadDLLFunction(lib, functions->_gnSubmit, "gnSubmitFn");
// gnLoadDLLFunction(lib, functions->_gnPresent, "gnPresentFn");
// gnLoadDLLFunction(lib, functions->_gnWaitForDevice, "gnWaitForDeviceFn");
}
void gnLoadCommandFunctions(struct gnDynamicLibrary_t* lib, struct gnCommandFunctions_t* functions) {
// gnLoadDLLFunction(lib, functions->_gnCommandPoolAllocateCommandBuffers, "gnCommandPoolAllocateCommandBuffersFn");
// gnLoadDLLFunction(lib, functions->_gnBeginCommandBuffer, "gnBeginCommandBufferFn");
// gnLoadDLLFunction(lib, functions->_gnResetCommandBuffer, "gnResetCommandBufferFn");
// gnLoadDLLFunction(lib, functions->_gnEndCommandBuffer, "gnEndCommandBufferFn");
// gnLoadDLLFunction(lib, functions->_gnCommandBeginRenderPass, "gnCommandBeginRenderPassFn");
// gnLoadDLLFunction(lib, functions->_gnCommandEndRenderPass, "gnCommandEndRenderPassFn");
// gnLoadDLLFunction(lib, functions->_gnCommandBindGraphicsPipeline, "gnCommandBindGraphicsPipelineFn");
// gnLoadDLLFunction(lib, functions->_gnCommandSetViewport, "gnCommandSetViewportFn");
// gnLoadDLLFunction(lib, functions->_gnCommandSetScissor, "gnCommandSetScissorFn");
// gnLoadDLLFunction(lib, functions->_gnCommandBindUniform, "gnCommandBindUniformFn");
// gnLoadDLLFunction(lib, functions->_gnCommandBindBuffer, "gnCommandBindBufferFn");
// gnLoadDLLFunction(lib, functions->_gnCommandPushConstant, "gnCommandPushConstantFn");
// gnLoadDLLFunction(lib, functions->_gnCommandDraw, "gnCommandDrawFn");
// gnLoadDLLFunction(lib, functions->_gnCommandDrawIndexed, "gnCommandDrawIndexedFn");
}

11
projects/core/src/instance/init/gryphn_init.h
View File

@@ -1,11 +0,0 @@
#pragma once
#include <gryphn/gryphn_utils.h>
#include <gryphn_rendering_api.h>
#include "gryphn_platform_functions.h"
// #include "utils/gryphn_error_code.h"
gnBool gnIsAPISupported(gnRenderingAPI RenderingAPI);
struct gnDynamicLibrary_t* gnLoadRenderingDLL(gnRenderingAPI RenderingAPI);
gnInstanceFunctions* gnLoadFunctions(gnInstance instance);
void gnLoadDeviceFunctions(struct gnDynamicLibrary_t* lib, struct gnDeviceFunctions_t* functions);
void gnLoadCommandFunctions(struct gnDynamicLibrary_t* lib, struct gnCommandFunctions_t* function);

15
projects/core/src/output_device/gryphn_output_device.c
View File

@@ -1,29 +1,20 @@
#include "gryphn_output_device.h" #include "gryphn_output_device.h"
#include "instance/gryphn_instance.h" #include "instance/gryphn_instance.h"
#include "gryphn_platform_functions.h" #include "gryphn_platform_functions.h"
#include "instance/init/gryphn_init.h"
#include "utils/gryphn_bool.h"
gnReturnCode gnCreateOutputDevice(gnOutputDeviceHandle* outputDevice, gnInstanceHandle instance, struct gnOutputDeviceInfo_t deviceInfo) { gnReturnCode gnCreateOutputDevice(gnOutputDeviceHandle* outputDevice, gnInstanceHandle instance, gnOutputDeviceInfo deviceInfo) {
*outputDevice = malloc(sizeof(struct gnOutputDevice_t)); *outputDevice = malloc(sizeof(struct gnOutputDevice_t));
if (instance->loadDeviceFunctions == gnFalse) {
instance->deviceFunctions = malloc(sizeof(struct gnDeviceFunctions_t));
gnLoadDeviceFunctions(instance->dynamicLib, instance->deviceFunctions);
instance->loadDeviceFunctions = gnTrue;
}
(*outputDevice)->deviceFunctions = instance->deviceFunctions; (*outputDevice)->deviceFunctions = instance->deviceFunctions;
(*outputDevice)->instance = instance; (*outputDevice)->instance = instance;
(*outputDevice)->physicalDevice = deviceInfo.physicalDevice; (*outputDevice)->physicalDevice = deviceInfo.physicalDevice;
(*outputDevice)->deviceInfo = deviceInfo; (*outputDevice)->deviceInfo = deviceInfo;
return instance->functions->_gnCreateOutputDevice(*outputDevice, instance, deviceInfo); return instance->instanceFunctions._gnCreateOutputDevice(*outputDevice, instance, deviceInfo);
} }
void gnWaitForDevice(gnOutputDeviceHandle device) { void gnWaitForDevice(gnOutputDeviceHandle device) {
device->deviceFunctions->_gnWaitForDevice(device); device->deviceFunctions->_gnWaitForDevice(device);
} }
void gnDestroyOutputDevice(gnOutputDeviceHandle device) { void gnDestroyOutputDevice(gnOutputDeviceHandle device) {
device->instance->functions->_gnDestroyOutputDevice(device); device->instance->instanceFunctions._gnDestroyOutputDevice(device);
free(device); free(device);
} }

17
projects/core/src/output_device/gryphn_output_device.h
View File

@@ -2,32 +2,29 @@
#include <output_device/gryphn_physical_output_device.h> #include <output_device/gryphn_physical_output_device.h>
#include <utils/gryphn_error_code.h> #include <utils/gryphn_error_code.h>
struct gnPlatformOutputDevice_t; typedef struct gnDeviceQueueInfo {
struct gnDeviceFunctions_t;
typedef struct gnDeviceQueueInfo_t {
int queueIndex; int queueIndex;
int queueCount; int queueCount;
// float* queuePriority; // float* queuePriority;
} gnDeviceQueueInfo; } gnDeviceQueueInfo;
typedef struct gnOutputDeviceInfo_t { typedef struct gnOutputDeviceInfo {
uint32_t queueInfoCount; uint32_t queueInfoCount;
struct gnDeviceQueueInfo_t* queueInfos; gnDeviceQueueInfo* queueInfos;
struct gnPhysicalDeviceFeatures_t enabledFeatures; gnPhysicalDeviceFeatures enabledFeatures;
struct gnPhysicalDevice_t physicalDevice; gnPhysicalDevice physicalDevice;
} gnOutputDeviceInfo; } gnOutputDeviceInfo;
#ifdef GN_REVEAL_IMPL #ifdef GN_REVEAL_IMPL
struct gnOutputDevice_t { struct gnOutputDevice_t {
struct gnPlatformOutputDevice_t* outputDevice; struct gnPlatformOutputDevice_t* outputDevice;
struct gnDeviceFunctions_t* deviceFunctions; struct gnDeviceFunctions_t* deviceFunctions;
struct gnOutputDeviceInfo_t deviceInfo; gnOutputDeviceInfo deviceInfo;
gnInstanceHandle instance; gnInstanceHandle instance;
gnPhysicalDevice physicalDevice; gnPhysicalDevice physicalDevice;
}; };
#endif #endif
gnReturnCode gnCreateOutputDevice(gnOutputDeviceHandle* outputDevice, gnInstanceHandle instance, struct gnOutputDeviceInfo_t deviceInfo); gnReturnCode gnCreateOutputDevice(gnOutputDeviceHandle* outputDevice, gnInstanceHandle instance, gnOutputDeviceInfo deviceInfo);
void gnWaitForDevice(gnOutputDeviceHandle device); void gnWaitForDevice(gnOutputDeviceHandle device);
void gnDestroyOutputDevice(gnOutputDeviceHandle device); void gnDestroyOutputDevice(gnOutputDeviceHandle device);

26
projects/core/src/output_device/gryphn_physical_output_device.c
View File

@@ -1,15 +1,15 @@
#include "gryphn_physical_output_device.h" #include "gryphn_physical_output_device.h"
#include "gryphn_platform_functions.h" #include "instance/gryphn_instance.h"
gnPhysicalDevice* gnGetPhyscialDevices(gnInstanceHandle instance, uint32_t* count) { gnPhysicalDevice* gnGetPhyscialDevices(gnInstanceHandle instance, uint32_t* count) {
gnPhysicalDevice* devices = instance->functions->_gnGetPhysicalDevices(instance, count); gnPhysicalDevice* devices = instance->instanceFunctions._gnGetPhysicalDevices(instance, count);
for (int i = 0; i < *count; i++) { for (int i = 0; i < *count; i++) {
devices[i].instance = instance; devices[i].instance = instance;
} }
return devices; return devices;
} }
gnBool gnQueueCanPresentToSurface(const struct gnPhysicalDevice_t device, uint32_t queueIndex, gnWindowSurfaceHandle windowSurface) { gnBool gnQueueCanPresentToSurface(const gnPhysicalDevice device, uint32_t queueIndex, gnWindowSurfaceHandle windowSurface) {
// if (queueIndex >= device.queueProperties.queueCount) { // if (queueIndex >= device.queueProperties.queueCount) {
// gnDebuggerSetErrorMessage(device.instance->debugger, // gnDebuggerSetErrorMessage(device.instance->debugger,
// (gnMessageData){ // (gnMessageData){
@@ -18,10 +18,10 @@ gnBool gnQueueCanPresentToSurface(const struct gnPhysicalDevice_t device, uint32
// ); // );
// return gnFalse; // return gnFalse;
// } // }
return device.instance->functions->_gnQueueCanPresentToSurface(device, queueIndex, windowSurface); return device.instance->instanceFunctions._gnQueueCanPresentToSurface(device, queueIndex, windowSurface);
} }
gnBool gnHasGraphicsQueue(const struct gnPhysicalDevice_t device) { gnBool gnHasGraphicsQueue(const gnPhysicalDevice device) {
for (int i = 0; i < device.queueProperties.queueCount; i++) { for (int i = 0; i < device.queueProperties.queueCount; i++) {
if (device.queueProperties.queueProperties[i].queueType & GN_QUEUE_GRAPHICS) { if (device.queueProperties.queueProperties[i].queueType & GN_QUEUE_GRAPHICS) {
return gnTrue; return gnTrue;
@@ -29,7 +29,7 @@ gnBool gnHasGraphicsQueue(const struct gnPhysicalDevice_t device) {
} }
return gnFalse; return gnFalse;
} }
gnBool gnHasPresentQueue(const struct gnPhysicalDevice_t device, gnWindowSurfaceHandle windowSurface) { gnBool gnHasPresentQueue(const gnPhysicalDevice device, gnWindowSurfaceHandle windowSurface) {
for (int i = 0; i < device.queueProperties.queueCount; i++) { for (int i = 0; i < device.queueProperties.queueCount; i++) {
if (gnQueueCanPresentToSurface(device, i, windowSurface)) { if (gnQueueCanPresentToSurface(device, i, windowSurface)) {
return gnTrue; return gnTrue;
@@ -38,31 +38,21 @@ gnBool gnHasPresentQueue(const struct gnPhysicalDevice_t device, gnWindowSurface
return gnFalse; return gnFalse;
} }
int gnGetGraphicsQueueIndex(const struct gnPhysicalDevice_t device) { int gnGetGraphicsQueueIndex(const gnPhysicalDevice device) {
for (int i = 0; i < device.queueProperties.queueCount; i++) { for (int i = 0; i < device.queueProperties.queueCount; i++) {
if (device.queueProperties.queueProperties[i].queueType & GN_QUEUE_GRAPHICS) { if (device.queueProperties.queueProperties[i].queueType & GN_QUEUE_GRAPHICS) {
return i; return i;
break; break;
} }
} }
// gnDebuggerSetErrorMessage(device.instance->debugger,
// (gnMessageData){
// .message = gnCreateString("gnGetGraphicsQueueIndex failed no queue that support graphics on this device")
// }
// );
return -1; return -1;
} }
int gnGetPresentQueueIndex(const struct gnPhysicalDevice_t device, gnWindowSurfaceHandle windowSurface) { int gnGetPresentQueueIndex(const gnPhysicalDevice device, gnWindowSurfaceHandle windowSurface) {
for (int i = 0; i < device.queueProperties.queueCount; i++) { for (int i = 0; i < device.queueProperties.queueCount; i++) {
if (gnQueueCanPresentToSurface(device, i, windowSurface)) { if (gnQueueCanPresentToSurface(device, i, windowSurface)) {
return i; return i;
break; break;
} }
} }
// gnDebuggerSetErrorMessage(device.instance->debugger,
// (gnMessageData){
// .message = gnCreateString("gnGetPresentQueueIndex failed no queue that support presenting to this window surface")
// }
// );
return -1; return -1;
} }

36
projects/core/src/output_device/gryphn_physical_output_device.h
View File

@@ -3,52 +3,50 @@
#include "utils/gryphn_string.h" #include "utils/gryphn_string.h"
#include "gryphn_handles.h" #include "gryphn_handles.h"
struct gnPlatformPhysicalDevice_t; typedef enum gnDeviceType {
typedef enum gnDeviceType_e {
GN_DEDICATED_DEVICE, GN_INTEGRATED_DEVICE, GN_EXTERNAL_DEVICE GN_DEDICATED_DEVICE, GN_INTEGRATED_DEVICE, GN_EXTERNAL_DEVICE
} gnDeviceType; } gnDeviceType;
typedef struct gnPhysicalDeviceProperties_t { typedef struct gnPhysicalDeviceProperties {
gnString name; gnString name;
gnDeviceType deviceType; gnDeviceType deviceType;
} gnPhysicalDeviceProperties; } gnPhysicalDeviceProperties;
typedef struct gnPhysicalDeviceFeatures_t { typedef struct gnPhysicalDeviceFeatures {
gnBool supportsGeometryShader; gnBool supportsGeometryShader;
} gnPhysicalDeviceFeatures; } gnPhysicalDeviceFeatures;
typedef enum gnQueueTypeFlags_e { typedef enum gnQueueTypeFlags {
GN_QUEUE_GRAPHICS = 0x00000001, GN_QUEUE_GRAPHICS = 0x00000001,
GN_QUEUE_COMPUTE = 0x00000002, GN_QUEUE_COMPUTE = 0x00000002,
GN_QUEUE_TRANSFER = 0x00000004, GN_QUEUE_TRANSFER = 0x00000004,
GN_QUEUE_SPARSE_BINDING = 0x00000008 GN_QUEUE_SPARSE_BINDING = 0x00000008
} gnQueueTypeFlags; } gnQueueTypeFlags;
typedef struct gnQueueProperties_t { typedef struct gnQueueProperties {
uint32_t queueCount; uint32_t queueCount;
enum gnQueueTypeFlags_e queueType; gnQueueTypeFlags queueType;
} gnQueueProperties; } gnQueueProperties;
typedef struct gnPhysicalDeviceQueueProperties_t { typedef struct gnPhysicalDeviceQueueProperties {
uint32_t queueCount; uint32_t queueCount;
struct gnQueueProperties_t* queueProperties; gnQueueProperties* queueProperties;
} gnPhysicalDeviceQueueProperties; } gnPhysicalDeviceQueueProperties;
typedef struct gnPhysicalDevice_t { typedef struct gnPhysicalDevice {
struct gnPlatformPhysicalDevice_t* physicalDevice; struct gnPlatformPhysicalDevice_t* physicalDevice;
struct gnPhysicalDeviceProperties_t properties; gnPhysicalDeviceProperties properties;
struct gnPhysicalDeviceFeatures_t features; gnPhysicalDeviceFeatures features;
struct gnPhysicalDeviceQueueProperties_t queueProperties; gnPhysicalDeviceQueueProperties queueProperties;
gnInstanceHandle instance; gnInstanceHandle instance;
} gnPhysicalDevice; } gnPhysicalDevice;
gnPhysicalDevice* gnGetPhyscialDevices(gnInstanceHandle instance, uint32_t* count); gnPhysicalDevice* gnGetPhyscialDevices(gnInstanceHandle instance, uint32_t* count);
gnBool gnQueueCanPresentToSurface(const struct gnPhysicalDevice_t device, uint32_t queueIndex, gnWindowSurfaceHandle windowSurface); gnBool gnQueueCanPresentToSurface(const gnPhysicalDevice device, uint32_t queueIndex, gnWindowSurfaceHandle windowSurface);
gnBool gnHasGraphicsQueue(const struct gnPhysicalDevice_t device); gnBool gnHasGraphicsQueue(const gnPhysicalDevice device);
gnBool gnHasPresentQueue(const struct gnPhysicalDevice_t device, gnWindowSurfaceHandle windowSurface); gnBool gnHasPresentQueue(const gnPhysicalDevice device, gnWindowSurfaceHandle windowSurface);
int gnGetGraphicsQueueIndex(const struct gnPhysicalDevice_t device); int gnGetGraphicsQueueIndex(const gnPhysicalDevice device);
int gnGetPresentQueueIndex(const struct gnPhysicalDevice_t device, gnWindowSurfaceHandle windowSurface); int gnGetPresentQueueIndex(const gnPhysicalDevice device, gnWindowSurfaceHandle windowSurface);

33
projects/core/src/window_surface/gryphn_surface.c
View File

@@ -1,24 +1,23 @@
#include "gryphn_surface.h" #include "gryphn_surface.h"
#include "gryphn_platform_functions.h"
void gnDestroyWindowSurface(gnWindowSurfaceHandle windowSurface) { void gnDestroyWindowSurface(gnWindowSurfaceHandle windowSurface) {
windowSurface->instance->functions->_gnDestroyWindowSurface(windowSurface); windowSurface->instance->instanceFunctions._gnDestroyWindowSurface(windowSurface);
} }
struct gnSurfaceFormat_t* gnGetSupportedSurfaceFormats( gnSurfaceFormat* gnGetSupportedSurfaceFormats(
gnWindowSurfaceHandle windowSurface, gnWindowSurfaceHandle windowSurface,
struct gnPhysicalDevice_t device, gnPhysicalDevice device,
uint32_t* formatCount uint32_t* formatCount
) { ) {
gnSurfaceDetails surfaceDetails = windowSurface->instance->functions->_gnGetSurfaceDetails(windowSurface, device); gnSurfaceDetails surfaceDetails = windowSurface->instance->instanceFunctions._gnGetSurfaceDetails(windowSurface, device);
*formatCount = surfaceDetails.formatCount; *formatCount = surfaceDetails.formatCount;
return surfaceDetails.formats; return surfaceDetails.formats;
} }
gnBool gnIsSurfaceFormatSupported( gnBool gnIsSurfaceFormatSupported(
gnWindowSurfaceHandle windowSurface, gnWindowSurfaceHandle windowSurface,
struct gnPhysicalDevice_t device, gnPhysicalDevice device,
struct gnSurfaceFormat_t format gnSurfaceFormat format
) { ) {
uint32_t formatCount = 0; uint32_t formatCount = 0;
gnSurfaceFormat* formats = gnGetSupportedSurfaceFormats(windowSurface, device, &formatCount); gnSurfaceFormat* formats = gnGetSupportedSurfaceFormats(windowSurface, device, &formatCount);
@@ -30,10 +29,10 @@ gnBool gnIsSurfaceFormatSupported(
return gnFalse; return gnFalse;
} }
struct gnSurfaceFormat_t gnGetPreferredSurfaceFormat( gnSurfaceFormat gnGetPreferredSurfaceFormat(
gnWindowSurfaceHandle windowSurface, gnWindowSurfaceHandle windowSurface,
struct gnPhysicalDevice_t device, gnPhysicalDevice device,
struct gnSurfaceFormat_t format gnSurfaceFormat format
) { ) {
uint32_t formatCount = 0; uint32_t formatCount = 0;
gnSurfaceFormat* formats = gnGetSupportedSurfaceFormats(windowSurface, device, &formatCount); gnSurfaceFormat* formats = gnGetSupportedSurfaceFormats(windowSurface, device, &formatCount);
@@ -53,17 +52,17 @@ struct gnSurfaceFormat_t gnGetPreferredSurfaceFormat(
return formats[0]; return formats[0];
} }
uint32_t gnGetMinImageCount(gnWindowSurfaceHandle surface, struct gnPhysicalDevice_t device) { uint32_t gnGetMinImageCount(gnWindowSurfaceHandle surface, gnPhysicalDevice device) {
gnSurfaceDetails surfaceDetails = surface->instance->functions->_gnGetSurfaceDetails(surface, device); gnSurfaceDetails surfaceDetails = surface->instance->instanceFunctions._gnGetSurfaceDetails(surface, device);
return surfaceDetails.minImageCount; return surfaceDetails.minImageCount;
} }
uint32_t gnGetMaxImageCount(gnWindowSurfaceHandle surface, struct gnPhysicalDevice_t device) { uint32_t gnGetMaxImageCount(gnWindowSurfaceHandle surface, gnPhysicalDevice device) {
gnSurfaceDetails surfaceDetails = surface->instance->functions->_gnGetSurfaceDetails(surface, device); gnSurfaceDetails surfaceDetails = surface->instance->instanceFunctions._gnGetSurfaceDetails(surface, device);
return surfaceDetails.maxImageCount; return surfaceDetails.maxImageCount;
} }
uint32_t gnGetPreferredImageCount(gnWindowSurfaceHandle surface, struct gnPhysicalDevice_t device) { uint32_t gnGetPreferredImageCount(gnWindowSurfaceHandle surface, gnPhysicalDevice device) {
gnSurfaceDetails surfaceDetails = surface->instance->functions->_gnGetSurfaceDetails(surface, device); gnSurfaceDetails surfaceDetails = surface->instance->instanceFunctions._gnGetSurfaceDetails(surface, device);
uint32_t imageCount = surfaceDetails.minImageCount + 1; uint32_t imageCount = surfaceDetails.minImageCount + 1;
if (surfaceDetails.maxImageCount > 0 && imageCount > surfaceDetails.maxImageCount) { if (surfaceDetails.maxImageCount > 0 && imageCount > surfaceDetails.maxImageCount) {
@@ -72,4 +71,4 @@ uint32_t gnGetPreferredImageCount(gnWindowSurfaceHandle surface, struct gnPhysi
return imageCount; return imageCount;
} }
gnSurfaceDetails gnGetSurfaceDetails(gnWindowSurfaceHandle surface, gnPhysicalDevice device) { return surface->instance->functions->_gnGetSurfaceDetails(surface, device); } gnSurfaceDetails gnGetSurfaceDetails(gnWindowSurfaceHandle surface, gnPhysicalDevice device) { return surface->instance->instanceFunctions._gnGetSurfaceDetails(surface, device); }

25
projects/core/src/window_surface/gryphn_surface.h
View File

@@ -3,15 +3,16 @@
#include <utils/gryphn_image_format.h> #include <utils/gryphn_image_format.h>
#include <instance/gryphn_instance.h> #include <instance/gryphn_instance.h>
#include "output_device/gryphn_physical_output_device.h" #include "output_device/gryphn_physical_output_device.h"
#include "utils/math/gryphn_vec2.h"
typedef struct gnSurfaceFormat_t { typedef struct gnSurfaceFormat {
gnImageFormat format; gnImageFormat format;
gnColorSpace colorSpace; gnColorSpace colorSpace;
} gnSurfaceFormat; } gnSurfaceFormat;
typedef struct gnSurfaceDetails { typedef struct gnSurfaceDetails {
uint32_t formatCount; uint32_t formatCount;
struct gnSurfaceFormat_t* formats; gnSurfaceFormat* formats;
uint32_t minImageCount, maxImageCount; uint32_t minImageCount, maxImageCount;
gnUInt2 minImageSize, maxImageSize, currentSize; gnUInt2 minImageSize, maxImageSize, currentSize;
@@ -27,27 +28,27 @@ struct gnWindowSurface_t {
void gnDestroyWindowSurface(gnWindowSurfaceHandle windowSurface); void gnDestroyWindowSurface(gnWindowSurfaceHandle windowSurface);
struct gnSurfaceFormat_t* gnGetSupportedSurfaceFormats( gnSurfaceFormat* gnGetSupportedSurfaceFormats(
gnWindowSurfaceHandle windowSurface, gnWindowSurfaceHandle windowSurface,
struct gnPhysicalDevice_t device, gnPhysicalDevice device,
uint32_t* formatCount uint32_t* formatCount
); );
gnBool gnIsSurfaceFormatSupported( gnBool gnIsSurfaceFormatSupported(
gnWindowSurfaceHandle windowSurface, gnWindowSurfaceHandle windowSurface,
struct gnPhysicalDevice_t device, gnPhysicalDevice device,
struct gnSurfaceFormat_t format gnSurfaceFormat format
); );
// this function will give you you're preferred surface format // this function will give you you're preferred surface format
// unless its not supported then it will give you the first supported surface format // unless its not supported then it will give you the first supported surface format
// at some point this function will attempt to give you the most simmilar surface format // at some point this function will attempt to give you the most simmilar surface format
struct gnSurfaceFormat_t gnGetPreferredSurfaceFormat( gnSurfaceFormat gnGetPreferredSurfaceFormat(
gnWindowSurfaceHandle windowSurface, gnWindowSurfaceHandle windowSurface,
struct gnPhysicalDevice_t device, gnPhysicalDevice device,
struct gnSurfaceFormat_t format gnSurfaceFormat format
); );
uint32_t gnGetMinImageCount(gnWindowSurfaceHandle surface, struct gnPhysicalDevice_t device); uint32_t gnGetMinImageCount(gnWindowSurfaceHandle surface, gnPhysicalDevice device);
uint32_t gnGetMaxImageCount(gnWindowSurfaceHandle surface, struct gnPhysicalDevice_t device); uint32_t gnGetMaxImageCount(gnWindowSurfaceHandle surface, gnPhysicalDevice device);
uint32_t gnGetPreferredImageCount(gnWindowSurfaceHandle surface, struct gnPhysicalDevice_t device); uint32_t gnGetPreferredImageCount(gnWindowSurfaceHandle surface, gnPhysicalDevice device);
gnSurfaceDetails gnGetSurfaceDetails(gnWindowSurfaceHandle surface, gnPhysicalDevice device); gnSurfaceDetails gnGetSurfaceDetails(gnWindowSurfaceHandle surface, gnPhysicalDevice device);

10
projects/core/src/window_surface/gryphn_surface_create_functions.c
View File

@@ -1,19 +1,19 @@
#include "gryphn_surface_create_functions.h" #include "gryphn_surface_create_functions.h"
#include "gryphn_surface.h"
#include "instance/gryphn_instance.h" #include "instance/gryphn_instance.h"
#include "gryphn_platform_functions.h"
#ifdef GN_PLATFORM_LINUX #ifdef GN_PLATFORM_LINUX
#ifdef GN_WINDOW_X11 #ifdef GN_WINDOW_X11
gnReturnCode gnCreateX11WindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, gnX11WindowSurfaceInfo createInfo) { gnReturnCode gnCreateX11WindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, gnX11WindowSurfaceInfo createInfo) {
*windowSurface = malloc(sizeof(struct gnWindowSurface_t)); *windowSurface = malloc(sizeof(struct gnWindowSurface_t));
(*windowSurface)->instance = instance; (*windowSurface)->instance = instance;
return instance->functions->_gnCreateX11WindowSurface(*windowSurface, instance, createInfo); return instance->instanceFunctions._gnCreateX11WindowSurface(*windowSurface, instance, createInfo);
} }
#endif #endif
#ifdef GN_WINDOW_WAYLAND #ifdef GN_WINDOW_WAYLAND
gnReturnCode gnCreateWaylandWindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnWaylandWindowSurfaceInfo_t createInfo) { gnReturnCode gnCreateWaylandWindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnWaylandWindowSurfaceInfo_t createInfo) {
*windowSurface = malloc(sizeof(struct gnWindowSurface_t)); *windowSurface = malloc(sizeof(struct gnWindowSurface_t));
return instance->functions->_gnCreateWaylandWindowSurface(windowSurface, instance, createInfo); return instance->instanceFunctions._gnCreateWaylandWindowSurface(windowSurface, instance, createInfo);
} }
#endif #endif
#endif #endif
@@ -22,7 +22,7 @@
#ifdef GN_PLATFORM_WIN32 #ifdef GN_PLATFORM_WIN32
gnReturnCode gnCreateWin32WindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnWin32WindowSurfaceInfo_t createInfo) { gnReturnCode gnCreateWin32WindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnWin32WindowSurfaceInfo_t createInfo) {
*windowSurface = malloc(sizeof(struct gnWindowSurface_t)); *windowSurface = malloc(sizeof(struct gnWindowSurface_t));
return instance->functions->_gnCreateWin32WindowSurface(windowSurface, instance, createInfo); return instance->instanceFunctions._gnCreateWin32WindowSurface(windowSurface, instance, createInfo);
} }
#endif #endif
@@ -30,6 +30,6 @@
gnReturnCode gnCreateMacOSWindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnMacOSWindowSurfaceInfo_t createInfo) { gnReturnCode gnCreateMacOSWindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnMacOSWindowSurfaceInfo_t createInfo) {
*windowSurface = malloc(sizeof(struct gnWindowSurface_t)); *windowSurface = malloc(sizeof(struct gnWindowSurface_t));
(*windowSurface)->instance = instance; (*windowSurface)->instance = instance;
return instance->functions->_gnCreateMacOSWindowSurface(*windowSurface, instance, createInfo); return instance->instanceFunctions._gnCreateMacOSWindowSurface(*windowSurface, instance, createInfo);
} }
#endif #endif

12
projects/core/src/window_surface/gryphn_surface_create_functions.h
View File

@@ -17,29 +17,29 @@
gnReturnCode gnCreateX11WindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, gnX11WindowSurfaceInfo createInfo); gnReturnCode gnCreateX11WindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, gnX11WindowSurfaceInfo createInfo);
#endif #endif
#ifdef GN_WINDOW_WAYLAND #ifdef GN_WINDOW_WAYLAND
typedef struct gnWaylandWindowSurfaceInfo_t { typedef struct gnWaylandWindowSurfaceInfo {
wl_display* display; wl_display* display;
wl_surface* surface; wl_surface* surface;
} gnWaylandWindowSurfaceInfo; } gnWaylandWindowSurfaceInfo;
gnReturnCode gnCreateWaylandWindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnWaylandWindowSurfaceInfo_t createInfo); gnReturnCode gnCreateWaylandWindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnWaylandWindowSurfaceInfo createInfo);
#endif #endif
#endif #endif
#ifdef GN_PLATFORM_WIN32 #ifdef GN_PLATFORM_WIN32
typedef struct gnWin32WindowSurfaceInfo_t { typedef struct gnWin32WindowSurfaceInfo {
HWND* window; HWND* window;
HINSTANCE* instance; HINSTANCE* instance;
} gnWin32WindowSurfaceInfo; } gnWin32WindowSurfaceInfo;
gnReturnCode gnCreateWin32WindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnWin32WindowSurfaceInfo_t createInfo); gnReturnCode gnCreateWin32WindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnWin32WindowSurfaceInfo createInfo);
#endif #endif
#ifdef GN_PLATFORM_MACOS #ifdef GN_PLATFORM_MACOS
typedef struct gnMacOSWindowSurfaceInfo_t { typedef struct gnMacOSWindowSurfaceInfo {
CAMetalLayer* layer; CAMetalLayer* layer;
} gnMacOSWindowSurfaceInfo; } gnMacOSWindowSurfaceInfo;
gnReturnCode gnCreateMacOSWindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnMacOSWindowSurfaceInfo_t createInfo); gnReturnCode gnCreateMacOSWindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnMacOSWindowSurfaceInfo createInfo);
#endif #endif

3
projects/loader/CMakeLists.txt
View File

@@ -3,3 +3,6 @@ project(GryphnLoader)
file(GLOB_RECURSE SOURCE_FILES CONFIGURE_DEPENDS "src/*.c") file(GLOB_RECURSE SOURCE_FILES CONFIGURE_DEPENDS "src/*.c")
add_library(GryphnLoader STATIC ${SOURCE_FILES}) add_library(GryphnLoader STATIC ${SOURCE_FILES})
target_include_directories(GryphnLoader PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../utils)
target_include_directories(GryphnLoader PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../)
target_include_directories(GryphnLoader PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../core/src/)

50
projects/loader/src/gryphn_instance_functions.h Normal file
View File

@@ -0,0 +1,50 @@
#pragma once
#include "stdint.h"
#include "utils/gryphn_error_code.h"
#include "utils/gryphn_bool.h"
#include "gryphn_handles.h"
typedef struct gnInstanceInfo gnInstanceInfo;
typedef struct gnPhysicalDevice gnPhysicalDevice;
typedef struct gnSurfaceDetails gnSurfaceDetails;
typedef struct gnOutputDeviceInfo gnOutputDeviceInfo;
#ifdef GN_PLATFORM_LINUX
#ifdef GN_WINDOW_X11
typedef struct gnX11WindowSurfaceInfo gnX11WindowSurfaceInfo;
#endif
#endif
typedef struct gnInstanceFunctions {
gnReturnCode (*_gnCreateInstance)(gnInstanceHandle instance, gnInstanceInfo info);
void (*_gnDestroyInstance)(gnInstanceHandle instance);
gnPhysicalDevice* (*_gnGetPhysicalDevices)(gnInstanceHandle instance, uint32_t* count);
gnBool (*_gnQueueCanPresentToSurface)(const gnPhysicalDevice device, uint32_t queueIndex, const gnWindowSurfaceHandle windowSurface);
gnReturnCode (*_gnCreateOutputDevice)(gnOutputDeviceHandle device, gnInstanceHandle instance, gnOutputDeviceInfo deviceInfo);
void (*_gnDestroyOutputDevice)(gnOutputDeviceHandle device);
#ifdef GN_PLATFORM_LINUX
#ifdef GN_WINDOW_X11
gnReturnCode (*_gnCreateX11WindowSurface)(gnWindowSurfaceHandle windowSurface, gnInstanceHandle instance, gnX11WindowSurfaceInfo createInfo);
#endif
#ifdef GN_WINDOW_WAYLAND
gnReturnCode (*_gnCreateWaylandWindowSurface)(gnWindowSurfaceHandle windowSurface, gnInstanceHandle instance, struct gnWaylandWindowSurfaceInfo_t createInfo);
#endif
#endif
#ifdef GN_PLATFORM_WIN32
gnReturnCode (*_gnCreateWin32WindowSurface)(gnWindowSurfaceHandle windowSurface, gnInstanceHandle instance, struct gnWin32WindowSurfaceInfo_t createInfo);
#endif
#ifdef GN_PLATFORM_MACOS
gnReturnCode (*_gnCreateMacOSWindowSurface)(gnWindowSurfaceHandle windowSurface, gnInstanceHandle instance, struct gnMacOSWindowSurfaceInfo_t createInfo);
#endif
void (*_gnDestroyWindowSurface)(gnWindowSurfaceHandle windowSurface);
gnSurfaceDetails (*_gnGetSurfaceDetails)(gnWindowSurfaceHandle windowSurface, gnPhysicalDevice device);
} gnInstanceFunctions;

6
projects/loader/src/gryphn_loader.c
View File

@@ -1,5 +1,7 @@
#include "gryphn_loader.h"
#include "stdio.h" #include "stdio.h"
void test_loader() { gnInstanceFunctions loadInstanceFunctions(gnRenderingAPI api) {
printf("Loader works %i\n", 32); printf("Loading instance functions");
return (gnInstanceFunctions){ NULL };
} }

4
projects/loader/src/gryphn_loader.h
View File

@@ -1,3 +1,5 @@
#pragma once #pragma once
#include "gryphn_rendering_api.h"
#include "gryphn_instance_functions.h"
void test_loader(); gnInstanceFunctions loadInstanceFunctions(gnRenderingAPI api);