load device functions

include/gryphn/gryphn.h

@@ -7,6 +7,7 @@
 #include <core/src/window_surface/gryphn_surface_create_functions.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_layout.h>
 #include <core/src/pipelines/graphics_pipeline/gryphn_graphics_pipeline.h>
 #include <core/src/renderpass/gryphn_render_pass_descriptor.h>
 #include <core/src/framebuffer/gryphn_framebuffer.h>
@@ -19,7 +20,6 @@
 #include <core/src/sync/fence/gryphn_fence.h>
 #include <core/src/submit/gryphn_submit.h>
 #include <core/src/present/gryphn_present.h>
-#include <core/src/shader_input/gryphn_shader_layout.h>
 #include <core/src/buffers/gryphn_buffer.h>
 #include <core/src/uniforms/gryphn_uniform_pool.h>
 #include <core/src/uniforms/gryphn_uniform.h>

projects/core/src/pipelines/graphics_pipeline/gryphn_graphics_pipeline.h

@@ -5,7 +5,7 @@
 #include <shader_module/gryphn_shader_module.h>
 #include "utils/math/gryphn_vec2.h"
 #include "gryphn_handles.h"
-#include "shader_input/gryphn_shader_layout.h"
+#include "shader_module/gryphn_shader_layout.h"
 
 typedef enum gnDynamicState {
     GN_DYNAMIC_VIEWPORT,

projects/core/src/presentation_queue/gryphn_presentation_queue.h

@@ -1,5 +1,4 @@
 #pragma once
-#include <gryphn/gryphn_utils.h>
 #include <utils/gryphn_image_format.h>
 #include <output_device/gryphn_output_device.h>
 #include <window_surface/gryphn_surface.h>

projects/validation_layers/function_loader/loader/device_functions.c

@@ -0,0 +1,206 @@
+#include "device_functions.h"
+#include "core/src/debugger/gryphn_debugger.h"
+#include "core/src/presentation_queue/gryphn_presentation_queue.h"
+#include "core/src/shader_module/gryphn_shader_module.h"
+#include "core/src/renderpass/gryphn_render_pass_descriptor.h"
+#include "core/src/pipelines/graphics_pipeline/gryphn_graphics_pipeline.h"
+#include "core/src/framebuffer/gryphn_framebuffer.h"
+#include "core/src/command/command_pool/gryphn_command_pool.h"
+#include "core/src/buffers/gryphn_buffer.h"
+#include "core/src/uniforms/gryphn_uniform_pool.h"
+#include "core/src/textures/gryphn_texture.h"
+#include "core/src/sync/fence/gryphn_fence.h"
+#include "core/src/submit/gryphn_submit.h"
+#include "core/src/present/gryphn_present.h"
+
+gnReturnCode checkCreatePresentationQueue(gnPresentationQueueHandle presentationQueue, const gnOutputDeviceHandle device, gnPresentationQueueInfo presentationInfo){
+    loaderLayer* nextLayer = loaderGetNextLayer(presentationQueue->outputDevice->instance);
+    if (nextLayer->deviceFunctions._gnCreatePresentationQueue == NULL) {
+        gnDebuggerSetErrorMessage(presentationQueue->outputDevice->instance->debugger, (gnMessageData){
+            .message = gnCreateString("Failed to load create presentation queue function")
+        });
+        resetLayer(presentationQueue->outputDevice->instance);
+        return GN_FAILED_TO_LOAD_FUNCTION;
+    }
+    return nextLayer->deviceFunctions._gnCreatePresentationQueue(presentationQueue, device, presentationInfo);
+}
+gnReturnCode checkPresentationQueueGetImage(gnPresentationQueueHandle presentationQueue, uint64_t timeout, gnSemaphoreHandle semaphore, uint32_t* imageIndex) {
+    loaderLayer* nextLayer = loaderGetNextLayer(presentationQueue->outputDevice->instance);
+    if (nextLayer->deviceFunctions._gnPresentationQueueGetImage == NULL) {
+        gnDebuggerSetErrorMessage(presentationQueue->outputDevice->instance->debugger, (gnMessageData){
+            .message = gnCreateString("Failed to load presentation queue get image function")
+        });
+        resetLayer(presentationQueue->outputDevice->instance);
+        return GN_FAILED_TO_LOAD_FUNCTION;
+    }
+    return nextLayer->deviceFunctions._gnPresentationQueueGetImage(presentationQueue, timeout, semaphore, imageIndex);
+}
+void checkDestroyPresentationQueue(gnPresentationQueueHandle presentationQueue) {
+    loaderLayer* nextLayer = loaderGetNextLayer(presentationQueue->outputDevice->instance);
+    if (nextLayer->deviceFunctions._gnDestroyPresentationQueue == NULL) {
+        gnDebuggerSetErrorMessage(presentationQueue->outputDevice->instance->debugger, (gnMessageData){
+            .message = gnCreateString("Failed to load destroy presentation queue function")
+        });
+        resetLayer(presentationQueue->outputDevice->instance);
+    }
+    nextLayer->deviceFunctions._gnDestroyPresentationQueue(presentationQueue);
+}
+
+gnReturnCode checkCreateShaderModule(gnShaderModuleHandle module, gnOutputDeviceHandle device, gnShaderModuleInfo shaderModuleInfo) {
+    loaderLayer* nextLayer = loaderGetNextLayer(device->instance);
+    if (nextLayer->deviceFunctions._gnCreateShaderModule == NULL) {
+        gnDebuggerSetErrorMessage(device->instance->debugger, (gnMessageData){
+            .message = gnCreateString("Failed to load create shader module function")
+        });
+        resetLayer(device->instance);
+        return GN_FAILED_TO_LOAD_FUNCTION;
+    }
+    return nextLayer->deviceFunctions._gnCreateShaderModule(module, device, shaderModuleInfo);
+}
+void checkDestroyShaderModule(gnShaderModuleHandle module){
+    loaderLayer* nextLayer = loaderGetNextLayer(module->device->instance);
+    if (nextLayer->deviceFunctions._gnDestroyShaderModule == NULL) {
+        gnDebuggerSetErrorMessage(module->device->instance->debugger, (gnMessageData){
+            .message = gnCreateString("Failed to load destroy shader module function")
+        });
+        resetLayer(module->device->instance);
+    }
+    nextLayer->deviceFunctions._gnDestroyShaderModule(module);
+}
+
+#define CHECK_FUNCTION_WITH_RETURN_CODE(instance, function, ...) \
+loaderLayer* nextLayer = loaderGetNextLayer(instance); \
+if (nextLayer->deviceFunctions.function == NULL) { \
+    gnDebuggerSetErrorMessage(instance->debugger, (gnMessageData){ \
+        .message = gnCreateString("Failed to load destroy " #function " function") \
+    }); \
+    resetLayer(instance); \
+    return GN_FAILED_TO_LOAD_FUNCTION; \
+} \
+return nextLayer->deviceFunctions.function(__VA_ARGS__);
+
+#define CHECK_VOID_FUNCTION(instance, function, ...) \
+loaderLayer* nextLayer = loaderGetNextLayer(instance); \
+if (nextLayer->deviceFunctions.function == NULL) { \
+    gnDebuggerSetErrorMessage(instance->debugger, (gnMessageData){ \
+        .message = gnCreateString("Failed to load destroy " #function " function") \
+    }); \
+    resetLayer(instance); \
+    return; \
+} \
+nextLayer->deviceFunctions.function(__VA_ARGS__);
+
+gnReturnCode checkCreateRenderPassDescriptor(gnRenderPassDescriptorHandle renderPass, gnOutputDeviceHandle device, gnRenderPassDescriptorInfo info) {
+    CHECK_FUNCTION_WITH_RETURN_CODE(device->instance, _gnCreateRenderPassDescriptor, renderPass, device, info);
+}
+void checkDestroyRenderPassDescriptor(gnRenderPassDescriptorHandle renderPass) {
+    CHECK_VOID_FUNCTION(renderPass->device->instance, _gnDestroyRenderPassDescriptor, renderPass);
+}
+
+gnReturnCode checkCreateGraphicsPipeline(gnGraphicsPipelineHandle pipeline, gnOutputDeviceHandle device, gnGraphicsPipelineInfo info) {
+    CHECK_FUNCTION_WITH_RETURN_CODE(device->instance, _gnCreateGraphicsPipeline, pipeline, device, info);
+}
+void checkDestroyGraphicsPipeline(gnGraphicsPipelineHandle pipeline) {
+    CHECK_VOID_FUNCTION(pipeline->device->instance, _gnDestroyGraphicsPipeline, pipeline);
+}
+
+gnReturnCode checkCreateFramebuffer(gnFramebuffer framebuffer, gnOutputDeviceHandle device, gnFramebufferInfo framebufferInfo) {
+    CHECK_FUNCTION_WITH_RETURN_CODE(device->instance, _gnCreateFramebuffer, framebuffer, device, framebufferInfo);
+}
+void checkDestroyFramebuffer(gnFramebuffer framebuffer) {
+    CHECK_VOID_FUNCTION(framebuffer->device->instance, _gnDestroyFramebuffer, framebuffer);
+}
+
+gnReturnCode checkCreateCommandPool(gnCommandPoolHandle commandPool, gnOutputDeviceHandle device, gnCommandPoolInfo info) {
+    CHECK_FUNCTION_WITH_RETURN_CODE(device->instance, _gnCreateCommandPool, commandPool, device, info);
+}
+void checkDestroyCommandPool(gnCommandPoolHandle commandPool) {
+    CHECK_VOID_FUNCTION(commandPool->device->instance, _gnDestroyCommandPool, commandPool);
+}
+
+gnReturnCode checkCreateSemaphore(gnSemaphoreHandle semaphore, gnOutputDeviceHandle device) {
+    CHECK_FUNCTION_WITH_RETURN_CODE(device->instance, _gnCreateSemaphore, semaphore, device);
+}
+void checkDestroySemaphore(gnSemaphoreHandle semaphore) {
+    CHECK_VOID_FUNCTION(semaphore->device->instance, _gnDestroySemaphore, semaphore);
+}
+
+gnReturnCode checkCreateBuffer(gnBufferHandle buffer, gnDeviceHandle device, gnBufferInfo info) {
+    CHECK_FUNCTION_WITH_RETURN_CODE(device->instance, _gnCreateBuffer, buffer, device, info);
+}
+void checkBufferData(gnBufferHandle buffer, size_t size, void* data) {
+    CHECK_VOID_FUNCTION(buffer->device->instance, _gnBufferData, buffer, size, data);
+}
+void* checkMapBuffer(gnBufferHandle buffer) {
+    loaderLayer* nextLayer = loaderGetNextLayer(buffer->device->instance);
+    if (nextLayer->deviceFunctions._gnMapBuffer == NULL) {
+        gnDebuggerSetErrorMessage(buffer->device->instance->debugger, (gnMessageData){
+            .message = gnCreateString("Failed to load create map buffer function")
+        });
+        resetLayer(buffer->device->instance);
+        return NULL;
+    }
+    return nextLayer->deviceFunctions._gnMapBuffer(buffer);
+}
+void checkDestroyBuffer(gnBufferHandle buffer) {
+    CHECK_VOID_FUNCTION(buffer->device->instance, _gnDestroyBuffer, buffer);
+}
+
+gnReturnCode checkCreateUniformPool(gnUniformPool pool, gnDeviceHandle device) {
+    CHECK_FUNCTION_WITH_RETURN_CODE(device->instance, _gnCreateUniformPool, pool, device);
+}
+gnUniform* checkUniformPoolAllocateUniforms(gnUniformPool pool, gnUniformAllocationInfo allocInfo) {
+    loaderLayer* nextLayer = loaderGetNextLayer(pool->device->instance);
+    if (nextLayer->deviceFunctions._gnUniformPoolAllocateUniforms == NULL) {
+        gnDebuggerSetErrorMessage(pool->device->instance->debugger, (gnMessageData){
+            .message = gnCreateString("Failed to load allocate uniform functions")
+        });
+        resetLayer(pool->device->instance);
+        return NULL;
+    }
+    return nextLayer->deviceFunctions._gnUniformPoolAllocateUniforms(pool, allocInfo);
+}
+void checkDestroyUniformPool(gnUniformPool pool) {
+    CHECK_VOID_FUNCTION(pool->device->instance, _gnDestroyUniformPool, pool);
+}
+
+void checkUpdateBufferUniform(gnUniform uniform, gnBufferUniformInfo* bufferInfo) {
+    CHECK_VOID_FUNCTION(uniform->pool->device->instance, _gnUpdateBufferUniform, uniform, bufferInfo);
+}
+void checkUpdateImageUniform(gnUniform uniform, gnImageUniformInfo* imageInfo) {
+    CHECK_VOID_FUNCTION(uniform->pool->device->instance, _gnUpdateImageUniform, uniform, imageInfo);
+}
+
+gnReturnCode checkCreateTexture(gnTexture texture, gnDevice device, const gnTextureInfo info) {
+    CHECK_FUNCTION_WITH_RETURN_CODE(device->instance, _gnCreateTexture, texture, device, info);
+}
+void checkTextureData(gnTextureHandle texture, void* pixelData) {
+    CHECK_VOID_FUNCTION(texture->device->instance, _gnTextureData, texture, pixelData);
+}
+void checkDestroyTexture(gnTexture texture) {
+    CHECK_VOID_FUNCTION(texture->device->instance, _gnDestroyTexture, texture);
+}
+
+gnReturnCode checkCreateFence(gnFenceHandle fence, gnOutputDeviceHandle device) {
+    CHECK_FUNCTION_WITH_RETURN_CODE(device->instance, _gnCreateFence, fence, device);
+}
+void checkWaitForFence(gnFenceHandle fence, uint64_t timeout) {
+    CHECK_VOID_FUNCTION(fence->device->instance, _gnWaitForFence, fence, timeout);
+}
+void checkResetFence(gnFenceHandle fence) {
+    CHECK_VOID_FUNCTION(fence->device->instance, _gnResetFence, fence);
+}
+void checkDestroyFence(gnFenceHandle fence) {
+    CHECK_VOID_FUNCTION(fence->device->instance, _gnDestroyFence, fence);
+}
+
+gnReturnCode checkSubmit(gnOutputDeviceHandle device, gnSubmitInfo info) {
+    CHECK_FUNCTION_WITH_RETURN_CODE(device->instance, _gnSubmit, device, info);
+}
+gnReturnCode checkPresent(gnOutputDeviceHandle device, gnPresentInfo info) {
+    CHECK_FUNCTION_WITH_RETURN_CODE(device->instance, _gnPresent, device, info);
+}
+
+void checkWaitForDevice(gnOutputDeviceHandle device) {
+    CHECK_VOID_FUNCTION(device->instance, _gnWaitForDevice, device);
+}

projects/validation_layers/function_loader/loader/device_functions.h

@@ -0,0 +1,49 @@
+#include "loader/src/gryphn_device_functions.h"
+
+gnReturnCode checkCreatePresentationQueue(gnPresentationQueueHandle presentationQueue, const gnOutputDeviceHandle device, gnPresentationQueueInfo presentationInfo);
+gnReturnCode checkPresentationQueueGetImage(gnPresentationQueueHandle presentationQueue, uint64_t timeout, gnSemaphoreHandle semaphore, uint32_t* imageIndex);
+void checkDestroyPresentationQueue(gnPresentationQueueHandle presentationQueue);
+
+gnReturnCode checkCreateShaderModule(gnShaderModuleHandle module, gnOutputDeviceHandle device, gnShaderModuleInfo shaderModuleInfo);
+void checkDestroyShaderModule(gnShaderModuleHandle module);
+
+gnReturnCode checkCreateRenderPassDescriptor(gnRenderPassDescriptorHandle renderPass, gnOutputDeviceHandle device, gnRenderPassDescriptorInfo info);
+void checkDestroyRenderPassDescriptor(gnRenderPassDescriptorHandle renderPass);
+
+gnReturnCode checkCreateGraphicsPipeline(gnGraphicsPipelineHandle pipeline, gnOutputDeviceHandle device, gnGraphicsPipelineInfo pipelineInfo);
+void checkDestroyGraphicsPipeline(gnGraphicsPipelineHandle pipeline);
+
+gnReturnCode checkCreateFramebuffer(gnFramebuffer framebuffer, gnOutputDeviceHandle device, gnFramebufferInfo framebufferInfo);
+void checkDestroyFramebuffer(gnFramebuffer framebuffer);
+
+gnReturnCode checkCreateCommandPool(gnCommandPoolHandle commandPool, gnOutputDeviceHandle device, gnCommandPoolInfo info);
+void checkDestroyCommandPool(gnCommandPoolHandle commandPool);
+
+gnReturnCode checkCreateSemaphore(gnSemaphoreHandle semaphore, gnOutputDeviceHandle device);
+void checkDestroySemaphore(gnSemaphoreHandle semaphore);
+
+gnReturnCode checkCreateBuffer(gnBufferHandle buffer, gnDeviceHandle device, gnBufferInfo info);
+void checkBufferData(gnBufferHandle buffer, size_t size, void* data);
+void* checkMapBuffer(gnBufferHandle buffer);
+void checkDestroyBuffer(gnBufferHandle buffer);
+
+gnReturnCode checkCreateUniformPool(gnUniformPool pool, gnDeviceHandle device);
+gnUniform* checkUniformPoolAllocateUniforms(gnUniformPool pool, gnUniformAllocationInfo allocInfo);
+void checkDestroyUniformPool(gnUniformPool pool);
+
+void checkUpdateBufferUniform(gnUniform uniform, gnBufferUniformInfo* bufferInfo);
+void checkUpdateImageUniform(gnUniform uniform, gnImageUniformInfo* imageInfo);
+
+gnReturnCode checkCreateTexture(gnTexture texture, gnDevice device, const gnTextureInfo info);
+void checkTextureData(gnTextureHandle texture, void* pixelData);
+void checkDestroyTexture(gnTexture texture);
+
+gnReturnCode checkCreateFence(gnFenceHandle fence, gnOutputDeviceHandle device);
+void checkWaitForFence(gnFenceHandle fence, uint64_t timeout);
+void checkResetFence(gnFenceHandle fence);
+void checkDestroyFence(gnFenceHandle fence);
+
+gnReturnCode checkSubmit(gnOutputDeviceHandle device, gnSubmitInfo submit);
+gnReturnCode checkPresent(gnOutputDeviceHandle device, gnPresentInfo info);
+
+void checkWaitForDevice(gnOutputDeviceHandle device);

projects/validation_layers/function_loader/loader/function_loader.c

@@ -1,5 +1,6 @@
 #include "function_loader.h"
 #include "instance_functions.h"
+#include "device_functions.h"
 
 gnInstanceFunctions loadFunctionLoaderInstanceFunctions() {
     return (gnInstanceFunctions){
@@ -37,7 +38,53 @@ gnInstanceFunctions loadFunctionLoaderInstanceFunctions() {
 }
 gnDeviceFunctions loadFunctionLoaderDeviceFunctions() {
     return (gnDeviceFunctions){
-        NULL
+        ._gnCreatePresentationQueue = checkCreatePresentationQueue,
+        ._gnPresentationQueueGetImage = checkPresentationQueueGetImage,
+        ._gnDestroyPresentationQueue = checkDestroyPresentationQueue,
+
+        ._gnCreateShaderModule = checkCreateShaderModule,
+        ._gnDestroyShaderModule = checkDestroyShaderModule,
+
+        ._gnCreateRenderPassDescriptor = checkCreateRenderPassDescriptor,
+        ._gnDestroyRenderPassDescriptor = checkDestroyRenderPassDescriptor,
+
+        ._gnCreateGraphicsPipeline = checkCreateGraphicsPipeline,
+        ._gnDestroyGraphicsPipeline = checkDestroyGraphicsPipeline,
+
+        ._gnCreateFramebuffer = checkCreateFramebuffer,
+        ._gnDestroyFramebuffer = checkDestroyFramebuffer,
+
+        ._gnCreateCommandPool = checkCreateCommandPool,
+        ._gnDestroyCommandPool = checkDestroyCommandPool,
+
+        ._gnCreateSemaphore = checkCreateSemaphore,
+        ._gnDestroySemaphore = checkDestroySemaphore,
+
+        ._gnCreateBuffer = checkCreateBuffer,
+        ._gnBufferData = checkBufferData,
+        ._gnMapBuffer = checkMapBuffer,
+        ._gnDestroyBuffer = checkDestroyBuffer,
+
+        ._gnCreateUniformPool = checkCreateUniformPool,
+        ._gnUniformPoolAllocateUniforms = checkUniformPoolAllocateUniforms,
+        ._gnDestroyUniformPool = checkDestroyUniformPool,
+
+        ._gnUpdateBufferUniform = checkUpdateBufferUniform,
+        ._gnUpdateImageUniform = checkUpdateImageUniform,
+
+        ._gnCreateTexture = checkCreateTexture,
+        ._gnTextureData = checkTextureData,
+        ._gnDestroyTexture = checkDestroyTexture,
+
+        ._gnCreateFence = checkCreateFence,
+        ._gnWaitForFence = checkWaitForFence,
+        ._gnResetFence = checkResetFence,
+        ._gnDestroyFence = checkDestroyFence,
+
+        ._gnSubmit = checkSubmit,
+        ._gnPresent = checkPresent,
+
+        ._gnWaitForDevice = checkWaitForDevice
     };
 }
 gnCommandFunctions loadFunctionLoaderCommandFunctions() {