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

actually get it to work

Browse Source
This commit is contained in:
Greg Wells
2025-06-26 18:04:14 -04:00
parent ab3bd566d2
commit f98dc5fead
23 changed files with 81 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
projects/core/src/buffers/gryphn_buffer.c
View File

@@ -1,19 +1,20 @@
#include "gryphn_buffer.h" #include "gryphn_buffer.h"
#include "output_device/gryphn_output_device.h" #include "output_device/gryphn_output_device.h"
#include "instance/gryphn_instance.h"
gnReturnCode gnCreateBuffer(gnBufferHandle* buffer, gnOutputDeviceHandle device, gnBufferInfo info) { gnReturnCode gnCreateBuffer(gnBufferHandle* buffer, gnOutputDeviceHandle device, gnBufferInfo info) {
*buffer = malloc(sizeof(struct gnBuffer_t)); *buffer = malloc(sizeof(struct gnBuffer_t));
(*buffer)->device = device; (*buffer)->device = device;
(*buffer)->info = info; (*buffer)->info = info;
return device->deviceFunctions->_gnCreateBuffer(*buffer, device, info); return device->instance->callingLayer->deviceFunctions._gnCreateBuffer(*buffer, device, info);
} }
void gnBufferData(gnBufferHandle buffer, size_t dataSize, void* data) { void gnBufferData(gnBufferHandle buffer, size_t dataSize, void* data) {
buffer->device->deviceFunctions->_gnBufferData(buffer, dataSize, data); buffer->device->instance->callingLayer->deviceFunctions._gnBufferData(buffer, dataSize, data);
} }
void* gnMapBuffer(gnBufferHandle buffer) { void* gnMapBuffer(gnBufferHandle buffer) {
if (buffer->info.usage == GN_STATIC_DRAW) return NULL; if (buffer->info.usage == GN_STATIC_DRAW) return NULL;
return buffer->device->deviceFunctions->_gnMapBuffer(buffer); return buffer->device->instance->callingLayer->deviceFunctions._gnMapBuffer(buffer);
} }
void gnDestroyBuffer(gnBufferHandle buffer) { void gnDestroyBuffer(gnBufferHandle buffer) {
buffer->device->deviceFunctions->_gnDestroyBuffer(buffer); buffer->device->instance->callingLayer->deviceFunctions._gnDestroyBuffer(buffer);
} }

10
projects/core/src/command/command_buffer/gryphn_command_buffer.c
View File

@@ -1,12 +1,14 @@
#include "gryphn_command_buffer.h" #include "gryphn_command_buffer.h"
#include "command/command_pool/gryphn_command_pool.h" #include "command/command_pool/gryphn_command_pool.h"
#include "instance/gryphn_instance.h"
gnReturnCode gnCommandPoolAllocateCommandBuffersFromPointer(gnCommandBufferHandle* buffers, uint32_t count, gnCommandPoolHandle commandPool) { gnReturnCode gnCommandPoolAllocateCommandBuffersFromPointer(gnCommandBufferHandle* buffers, uint32_t count, gnCommandPoolHandle commandPool) {
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
buffers[i] = malloc(sizeof(struct gnCommandBuffer_t)); buffers[i] = malloc(sizeof(struct gnCommandBuffer_t));
buffers[i]->commandPool = commandPool; buffers[i]->commandPool = commandPool;
buffers[i]->instance = commandPool->instance;
} }
return commandPool->commandFunctions->_gnCommandPoolAllocateCommandBuffers(buffers, count, commandPool); return commandPool->instance->callingLayer->commandFunctions._gnCommandPoolAllocateCommandBuffers(buffers, count, commandPool);
} }
gnReturnCode gnCommandPoolAllocateCommandBuffersFromList(gnCommandBufferArrayList buffers, uint32_t count, gnCommandPoolHandle commandPool) { gnReturnCode gnCommandPoolAllocateCommandBuffersFromList(gnCommandBufferArrayList buffers, uint32_t count, gnCommandPoolHandle commandPool) {
@@ -18,13 +20,13 @@ gnReturnCode gnCommandPoolAllocateCommandBuffersFromList(gnCommandBufferArrayLis
} }
void gnResetCommandBuffer(gnCommandBufferHandle commandBuffer) { void gnResetCommandBuffer(gnCommandBufferHandle commandBuffer) {
commandBuffer->commandPool->commandFunctions->_gnResetCommandBuffer(commandBuffer); commandBuffer->commandPool->instance->callingLayer->commandFunctions._gnResetCommandBuffer(commandBuffer);
} }
gnReturnCode gnBeginCommandBuffer(gnCommandBufferHandle commandBuffer) { gnReturnCode gnBeginCommandBuffer(gnCommandBufferHandle commandBuffer) {
return commandBuffer->commandPool->commandFunctions->_gnBeginCommandBuffer(commandBuffer); return commandBuffer->commandPool->instance->callingLayer->commandFunctions._gnBeginCommandBuffer(commandBuffer);
} }
gnReturnCode gnEndCommandBuffer(gnCommandBufferHandle commandBuffer) { gnReturnCode gnEndCommandBuffer(gnCommandBufferHandle commandBuffer) {
return commandBuffer->commandPool->commandFunctions->_gnEndCommandBuffer(commandBuffer); return commandBuffer->commandPool->instance->callingLayer->commandFunctions._gnEndCommandBuffer(commandBuffer);
} }

1
projects/core/src/command/command_buffer/gryphn_command_buffer.h
View File

@@ -8,6 +8,7 @@
struct gnCommandBuffer_t { struct gnCommandBuffer_t {
struct gnPlatformCommandBuffer_t* commandBuffer; struct gnPlatformCommandBuffer_t* commandBuffer;
gnCommandPoolHandle commandPool; gnCommandPoolHandle commandPool;
gnInstance instance;
}; };
#endif #endif

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

@@ -5,12 +5,12 @@
gnReturnCode gnCreateCommandPool(gnCommandPoolHandle* commandPool, gnOutputDeviceHandle device, gnCommandPoolInfo info) { gnReturnCode gnCreateCommandPool(gnCommandPoolHandle* commandPool, gnOutputDeviceHandle device, gnCommandPoolInfo info) {
*commandPool = malloc(sizeof(struct gnCommandPool_t)); *commandPool = malloc(sizeof(struct gnCommandPool_t));
(*commandPool)->commandFunctions = &device->instance->commandFunctions; (*commandPool)->instance = device->instance;
(*commandPool)->device = device; (*commandPool)->device = device;
return device->deviceFunctions->_gnCreateCommandPool((*commandPool), device, info); return device->instance->callingLayer->deviceFunctions._gnCreateCommandPool((*commandPool), device, info);
} }
void gnDestroyCommandPool(gnCommandPoolHandle commandPool) { void gnDestroyCommandPool(gnCommandPoolHandle commandPool) {
commandPool->device->deviceFunctions->_gnDestroyCommandPool(commandPool); commandPool->instance->callingLayer->deviceFunctions._gnDestroyCommandPool(commandPool);
} }

3
projects/core/src/command/command_pool/gryphn_command_pool.h
View File

@@ -2,7 +2,6 @@
#include "stdint.h" #include "stdint.h"
#include <utils/gryphn_error_code.h> #include <utils/gryphn_error_code.h>
#include "gryphn_handles.h" #include "gryphn_handles.h"
#include "loader/src/gryphn_command_functions.h"
typedef struct gnCommandPoolInfo { typedef struct gnCommandPoolInfo {
uint32_t queueIndex; uint32_t queueIndex;
@@ -11,8 +10,8 @@ typedef struct gnCommandPoolInfo {
#ifdef GN_REVEAL_IMPL #ifdef GN_REVEAL_IMPL
struct gnCommandPool_t { struct gnCommandPool_t {
struct gnPlatformCommandPool_t* commandPool; struct gnPlatformCommandPool_t* commandPool;
gnCommandFunctions* commandFunctions;
gnDevice device; gnDevice device;
gnInstance instance;
}; };
#endif #endif

21
projects/core/src/command/commands/gryphn_command.c
View File

@@ -1,35 +1,36 @@
#include "gryphn_command.h" #include "gryphn_command.h"
#include "command/command_buffer/gryphn_command_buffer.h" #include "command/command_buffer/gryphn_command_buffer.h"
#include "command/command_pool/gryphn_command_pool.h" #include "command/command_pool/gryphn_command_pool.h"
#include "instance/gryphn_instance.h"
void gnCommandBeginRenderPass(gnCommandBufferHandle buffer, gnRenderPassInfo passInfo) { void gnCommandBeginRenderPass(gnCommandBufferHandle buffer, gnRenderPassInfo passInfo) {
buffer->commandPool->commandFunctions->_gnCommandBeginRenderPass(buffer, passInfo); buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandBeginRenderPass(buffer, passInfo);
} }
void gnCommandEndRenderPass(gnCommandBufferHandle buffer) { void gnCommandEndRenderPass(gnCommandBufferHandle buffer) {
buffer->commandPool->commandFunctions->_gnCommandEndRenderPass(buffer); buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandEndRenderPass(buffer);
} }
void gnCommandBindGraphicsPipeline(gnCommandBufferHandle buffer, gnGraphicsPipeline graphicsPipeline) { void gnCommandBindGraphicsPipeline(gnCommandBufferHandle buffer, gnGraphicsPipeline graphicsPipeline) {
buffer->commandPool->commandFunctions->_gnCommandBindGraphicsPipeline(buffer, graphicsPipeline); buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandBindGraphicsPipeline(buffer, graphicsPipeline);
} }
void gnCommandSetViewport(gnCommandBufferHandle buffer, gnViewport viewport) { void gnCommandSetViewport(gnCommandBufferHandle buffer, gnViewport viewport) {
buffer->commandPool->commandFunctions->_gnCommandSetViewport(buffer, viewport); buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandSetViewport(buffer, viewport);
} }
void gnCommandSetScissor(gnCommandBufferHandle buffer, gnScissor scissor) { void gnCommandSetScissor(gnCommandBufferHandle buffer, gnScissor scissor) {
buffer->commandPool->commandFunctions->_gnCommandSetScissor(buffer, scissor); buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandSetScissor(buffer, scissor);
} }
void gnCommandBindUniform(gnCommandBufferHandle buffer, gnUniform uniform, uint32_t set) { void gnCommandBindUniform(gnCommandBufferHandle buffer, gnUniform uniform, uint32_t set) {
buffer->commandPool->commandFunctions->_gnCommandBindUniform(buffer, uniform, set); buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandBindUniform(buffer, uniform, set);
} }
void gnCommandBindBuffer(gnCommandBufferHandle buffer, gnBufferHandle bufferToBind, gnBufferType type) { void gnCommandBindBuffer(gnCommandBufferHandle buffer, gnBufferHandle bufferToBind, gnBufferType type) {
buffer->commandPool->commandFunctions->_gnCommandBindBuffer(buffer, bufferToBind, type); buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandBindBuffer(buffer, bufferToBind, type);
} }
void gnCommandPushConstant(gnCommandBufferHandle buffer, gnPushConstantLayout layout, void* data) { void gnCommandPushConstant(gnCommandBufferHandle buffer, gnPushConstantLayout layout, void* data) {
buffer->commandPool->commandFunctions->_gnCommandPushConstant(buffer, layout, data); buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandPushConstant(buffer, layout, data);
} }
void gnCommandDraw(gnCommandBufferHandle buffer, int vertexCount, int firstVertex, int instanceCount, int firstInstance) { void gnCommandDraw(gnCommandBufferHandle buffer, int vertexCount, int firstVertex, int instanceCount, int firstInstance) {
buffer->commandPool->commandFunctions->_gnCommandDraw(buffer, vertexCount, firstVertex, instanceCount, firstInstance); buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandDraw(buffer, vertexCount, firstVertex, instanceCount, firstInstance);
} }
void gnCommandDrawIndexed(gnCommandBufferHandle buffer, gnIndexType type, int indexCount, int firstIndex, int vertexOffset, int instanceCount, int firstInstance) { void gnCommandDrawIndexed(gnCommandBufferHandle buffer, gnIndexType type, int indexCount, int firstIndex, int vertexOffset, int instanceCount, int firstInstance) {
buffer->commandPool->commandFunctions->_gnCommandDrawIndexed(buffer, type, indexCount, firstIndex, vertexOffset, instanceCount, firstInstance); buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandDrawIndexed(buffer, type, indexCount, firstIndex, vertexOffset, instanceCount, firstInstance);
} }

5
projects/core/src/framebuffer/gryphn_framebuffer.c
View File

@@ -1,13 +1,14 @@
#include "gryphn_framebuffer.h" #include "gryphn_framebuffer.h"
#include "stdlib.h" #include "stdlib.h"
#include "output_device/gryphn_output_device.h" #include "output_device/gryphn_output_device.h"
#include "instance/gryphn_instance.h"
gnReturnCode gnCreateFramebuffer(gnFramebuffer* framebuffer, gnOutputDeviceHandle device, gnFramebufferInfo framebufferInfo) { gnReturnCode gnCreateFramebuffer(gnFramebuffer* framebuffer, gnOutputDeviceHandle device, gnFramebufferInfo framebufferInfo) {
*framebuffer = malloc(sizeof(struct gnFramebuffer_t)); *framebuffer = malloc(sizeof(struct gnFramebuffer_t));
(*framebuffer)->device = device; (*framebuffer)->device = device;
return device->deviceFunctions->_gnCreateFramebuffer(*framebuffer, device, framebufferInfo); return device->instance->callingLayer->deviceFunctions._gnCreateFramebuffer(*framebuffer, device, framebufferInfo);
} }
void gnDestroyFramebuffer(gnFramebuffer framebuffer) { void gnDestroyFramebuffer(gnFramebuffer framebuffer) {
framebuffer->device->deviceFunctions->_gnDestroyFramebuffer(framebuffer); framebuffer->device->instance->callingLayer->deviceFunctions._gnDestroyFramebuffer(framebuffer);
} }

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

@@ -3,17 +3,16 @@
gnReturnCode gnCreateOutputDevice(gnOutputDeviceHandle* outputDevice, gnInstanceHandle instance, gnOutputDeviceInfo deviceInfo) { gnReturnCode gnCreateOutputDevice(gnOutputDeviceHandle* outputDevice, gnInstanceHandle instance, gnOutputDeviceInfo deviceInfo) {
*outputDevice = malloc(sizeof(struct gnOutputDevice_t)); *outputDevice = malloc(sizeof(struct gnOutputDevice_t));
(*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->instanceFunctions._gnCreateOutputDevice(*outputDevice, instance, deviceInfo); return instance->callingLayer->instanceFunctions._gnCreateOutputDevice(*outputDevice, instance, deviceInfo);
} }
void gnWaitForDevice(gnOutputDeviceHandle device) { void gnWaitForDevice(gnOutputDeviceHandle device) {
device->deviceFunctions->_gnWaitForDevice(device); device->instance->callingLayer->deviceFunctions._gnWaitForDevice(device);
} }
void gnDestroyOutputDevice(gnOutputDeviceHandle device) { void gnDestroyOutputDevice(gnOutputDeviceHandle device) {
device->instance->instanceFunctions._gnDestroyOutputDevice(device); device->instance->callingLayer->instanceFunctions._gnDestroyOutputDevice(device);
free(device); free(device);
} }

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

@@ -19,7 +19,6 @@ typedef struct gnOutputDeviceInfo {
#ifdef GN_REVEAL_IMPL #ifdef GN_REVEAL_IMPL
struct gnOutputDevice_t { struct gnOutputDevice_t {
struct gnPlatformOutputDevice_t* outputDevice; struct gnPlatformOutputDevice_t* outputDevice;
gnDeviceFunctions* deviceFunctions;
gnOutputDeviceInfo deviceInfo; gnOutputDeviceInfo deviceInfo;
gnInstanceHandle instance; gnInstanceHandle instance;
gnPhysicalDevice physicalDevice; gnPhysicalDevice physicalDevice;

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

@@ -2,7 +2,7 @@
#include "instance/gryphn_instance.h" #include "instance/gryphn_instance.h"
gnPhysicalDevice* gnGetPhyscialDevices(gnInstanceHandle instance, uint32_t* count) { gnPhysicalDevice* gnGetPhyscialDevices(gnInstanceHandle instance, uint32_t* count) {
gnPhysicalDevice* devices = instance->instanceFunctions._gnGetPhysicalDevices(instance, count); gnPhysicalDevice* devices = instance->callingLayer->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;
} }
@@ -18,7 +18,7 @@ gnBool gnQueueCanPresentToSurface(const gnPhysicalDevice device, uint32_t queueI
// ); // );
// return gnFalse; // return gnFalse;
// } // }
return device.instance->instanceFunctions._gnQueueCanPresentToSurface(device, queueIndex, windowSurface); return device.instance->callingLayer->instanceFunctions._gnQueueCanPresentToSurface(device, queueIndex, windowSurface);
} }
gnBool gnHasGraphicsQueue(const gnPhysicalDevice device) { gnBool gnHasGraphicsQueue(const gnPhysicalDevice device) {

5
projects/core/src/pipelines/graphics_pipeline/gryphn_graphics_pipeline.c
View File

@@ -1,12 +1,13 @@
#include "gryphn_graphics_pipeline.h" #include "gryphn_graphics_pipeline.h"
#include "instance/gryphn_instance.h"
gnReturnCode gnCreateGraphicsPipeline(gnGraphicsPipelineHandle* graphicsPipeline, gnDevice device, gnGraphicsPipelineInfo info) { gnReturnCode gnCreateGraphicsPipeline(gnGraphicsPipelineHandle* graphicsPipeline, gnDevice device, gnGraphicsPipelineInfo info) {
*graphicsPipeline = malloc(sizeof(struct gnGraphicsPipeline_t)); *graphicsPipeline = malloc(sizeof(struct gnGraphicsPipeline_t));
(*graphicsPipeline)->device = device; (*graphicsPipeline)->device = device;
(*graphicsPipeline)->info = info; (*graphicsPipeline)->info = info;
return device->deviceFunctions->_gnCreateGraphicsPipeline(*graphicsPipeline, device, info); return device->instance->callingLayer->deviceFunctions._gnCreateGraphicsPipeline(*graphicsPipeline, device, info);
} }
void gnDestroyGraphicsPipeline(gnGraphicsPipelineHandle graphicsPipeline) { void gnDestroyGraphicsPipeline(gnGraphicsPipelineHandle graphicsPipeline) {
graphicsPipeline->device->deviceFunctions->_gnDestroyGraphicsPipeline(graphicsPipeline); graphicsPipeline->device->instance->callingLayer->deviceFunctions._gnDestroyGraphicsPipeline(graphicsPipeline);
} }

3
projects/core/src/present/gryphn_present.c
View File

@@ -1,6 +1,7 @@
#include "gryphn_present.h" #include "gryphn_present.h"
#include "output_device/gryphn_output_device.h" #include "output_device/gryphn_output_device.h"
#include "instance/gryphn_instance.h"
gnReturnCode gnPresent(gnDevice device, gnPresentInfo info) { gnReturnCode gnPresent(gnDevice device, gnPresentInfo info) {
return device->deviceFunctions->_gnPresent(device, info); return device->instance->callingLayer->deviceFunctions._gnPresent(device, info);
} }

6
projects/core/src/presentation_queue/gryphn_presentation_queue.c
View File

@@ -4,17 +4,17 @@ gnReturnCode gnCreatePresentationQueue(gnPresentationQueueHandle* presentationQu
*presentationQueue = malloc(sizeof(struct gnPresentationQueue_t)); *presentationQueue = malloc(sizeof(struct gnPresentationQueue_t));
(*presentationQueue)->outputDevice = device; (*presentationQueue)->outputDevice = device;
(*presentationQueue)->info = presentationInfo; (*presentationQueue)->info = presentationInfo;
return device->deviceFunctions->_gnCreatePresentationQueue(*presentationQueue, device, presentationInfo); return device->instance->callingLayer->deviceFunctions._gnCreatePresentationQueue(*presentationQueue, device, presentationInfo);
} }
gnReturnCode gnPresentationQueueGetImage(gnPresentationQueueHandle presentationQueue, uint64_t timeout, gnSemaphoreHandle semaphore, uint32_t* imageIndex) { gnReturnCode gnPresentationQueueGetImage(gnPresentationQueueHandle presentationQueue, uint64_t timeout, gnSemaphoreHandle semaphore, uint32_t* imageIndex) {
return presentationQueue->outputDevice->deviceFunctions->_gnPresentationQueueGetImage(presentationQueue, timeout, semaphore, imageIndex); return presentationQueue->outputDevice->instance->callingLayer->deviceFunctions._gnPresentationQueueGetImage(presentationQueue, timeout, semaphore, imageIndex);
} }
uint32_t gnGetPresentationQueueImageCount(gnPresentationQueueHandle presentationQueue) { return presentationQueue->imageCount; } uint32_t gnGetPresentationQueueImageCount(gnPresentationQueueHandle presentationQueue) { return presentationQueue->imageCount; }
gnTextureHandle gnGetPresentationQueueImage(gnPresentationQueueHandle presentationQueue, uint32_t index) { gnTextureHandle gnGetPresentationQueueImage(gnPresentationQueueHandle presentationQueue, uint32_t index) {
return presentationQueue->images[index]; return presentationQueue->images[index];
} }
void gnDestroyPresentationQueue(gnPresentationQueueHandle presentationQueue) { void gnDestroyPresentationQueue(gnPresentationQueueHandle presentationQueue) {
presentationQueue->outputDevice->deviceFunctions->_gnDestroyPresentationQueue(presentationQueue); presentationQueue->outputDevice->instance->callingLayer->deviceFunctions._gnDestroyPresentationQueue(presentationQueue);
free(presentationQueue); free(presentationQueue);
} }

5
projects/core/src/renderpass/gryphn_render_pass_descriptor.c
View File

@@ -1,13 +1,14 @@
#include "gryphn_render_pass_descriptor.h" #include "gryphn_render_pass_descriptor.h"
#include "output_device/gryphn_output_device.h" #include "output_device/gryphn_output_device.h"
#include "instance/gryphn_instance.h"
gnReturnCode gnCreateRenderPassDescriptor(gnRenderPassDescriptorHandle* renderPass, gnOutputDeviceHandle device, gnRenderPassDescriptorInfo info) { gnReturnCode gnCreateRenderPassDescriptor(gnRenderPassDescriptorHandle* renderPass, gnOutputDeviceHandle device, gnRenderPassDescriptorInfo info) {
*renderPass = malloc(sizeof(struct gnRenderPassDescriptor_t)); *renderPass = malloc(sizeof(struct gnRenderPassDescriptor_t));
(*renderPass)->device = device; (*renderPass)->device = device;
(*renderPass)->info = info; (*renderPass)->info = info;
return device->deviceFunctions->_gnCreateRenderPassDescriptor(*renderPass, device, info); return device->instance->callingLayer->deviceFunctions._gnCreateRenderPassDescriptor(*renderPass, device, info);
} }
void gnDestroyRenderPassDescriptor(gnRenderPassDescriptorHandle renderPass) { void gnDestroyRenderPassDescriptor(gnRenderPassDescriptorHandle renderPass) {
renderPass->device->deviceFunctions->_gnDestroyRenderPassDescriptor(renderPass); renderPass->device->instance->callingLayer->deviceFunctions._gnDestroyRenderPassDescriptor(renderPass);
} }

5
projects/core/src/shader_module/gryphn_shader_module.c
View File

@@ -1,13 +1,14 @@
#include "gryphn_shader_module.h" #include "gryphn_shader_module.h"
#include "output_device/gryphn_output_device.h" #include "output_device/gryphn_output_device.h"
#include "instance/gryphn_instance.h"
gnReturnCode gnCreateShaderModule(gnShaderModuleHandle* module, gnOutputDeviceHandle device, struct gnShaderModuleInfo shaderModuleInfo) { gnReturnCode gnCreateShaderModule(gnShaderModuleHandle* module, gnOutputDeviceHandle device, struct gnShaderModuleInfo shaderModuleInfo) {
*module = malloc(sizeof(struct gnShaderModule_t)); *module = malloc(sizeof(struct gnShaderModule_t));
(*module)->device = device; (*module)->device = device;
(*module)->info = shaderModuleInfo; (*module)->info = shaderModuleInfo;
return device->deviceFunctions->_gnCreateShaderModule(*module, device, shaderModuleInfo); return device->instance->callingLayer->deviceFunctions._gnCreateShaderModule(*module, device, shaderModuleInfo);
} }
void gnDestroyShaderModule(gnShaderModuleHandle module) { void gnDestroyShaderModule(gnShaderModuleHandle module) {
module->device->deviceFunctions->_gnDestroyShaderModule(module); module->device->instance->callingLayer->deviceFunctions._gnDestroyShaderModule(module);
} }

3
projects/core/src/submit/gryphn_submit.c
View File

@@ -1,6 +1,7 @@
#include "gryphn_submit.h" #include "gryphn_submit.h"
#include "output_device/gryphn_output_device.h" #include "output_device/gryphn_output_device.h"
#include "instance/gryphn_instance.h"
gnReturnCode gnSubmit(gnOutputDevice device, gnSubmitInfo info) { gnReturnCode gnSubmit(gnOutputDevice device, gnSubmitInfo info) {
return device->deviceFunctions->_gnSubmit(device, info); return device->instance->callingLayer->deviceFunctions._gnSubmit(device, info);
} }

11
projects/core/src/sync/fence/gryphn_fence.c
View File

@@ -1,23 +1,24 @@
#include "gryphn_fence.h" #include "gryphn_fence.h"
#include "output_device/gryphn_output_device.h" #include "output_device/gryphn_output_device.h"
#include "instance/gryphn_instance.h"
gnReturnCode gnCreateFence(gnFenceHandle* fence, struct gnOutputDevice_t* device) { gnReturnCode gnCreateFence(gnFenceHandle* fence, gnDevice device) {
*fence = malloc(sizeof(struct gnFence_t)); *fence = malloc(sizeof(struct gnFence_t));
(*fence)->device = device; (*fence)->device = device;
(*fence)->signaled = gnFalse; (*fence)->signaled = gnFalse;
return device->deviceFunctions->_gnCreateFence(*fence, device); return device->instance->callingLayer->deviceFunctions._gnCreateFence(*fence, device);
} }
void gnSignalFence(gnFenceHandle fence) { void gnSignalFence(gnFenceHandle fence) {
fence->signaled = gnTrue; fence->signaled = gnTrue;
} }
void gnWaitForFence(gnFenceHandle fence, uint64_t timeout) { void gnWaitForFence(gnFenceHandle fence, uint64_t timeout) {
if (fence->signaled == gnTrue) return; if (fence->signaled == gnTrue) return;
fence->device->deviceFunctions->_gnWaitForFence(fence, timeout); fence->device->instance->callingLayer->deviceFunctions._gnWaitForFence(fence, timeout);
} }
void gnResetFence(gnFenceHandle fence) { void gnResetFence(gnFenceHandle fence) {
fence->signaled = gnFalse; fence->signaled = gnFalse;
fence->device->deviceFunctions->_gnResetFence(fence); fence->device->instance->callingLayer->deviceFunctions._gnResetFence(fence);
} }
void gnDestroyFence(gnFenceHandle fence) { void gnDestroyFence(gnFenceHandle fence) {
fence->device->deviceFunctions->_gnDestroyFence(fence); fence->device->instance->callingLayer->deviceFunctions._gnDestroyFence(fence);
} }

5
projects/core/src/sync/semaphore/gryphn_semaphore.c
View File

@@ -1,11 +1,12 @@
#include "gryphn_semaphore.h" #include "gryphn_semaphore.h"
#include "output_device/gryphn_output_device.h" #include "output_device/gryphn_output_device.h"
#include "instance/gryphn_instance.h"
gnReturnCode gnCreateSemaphore(gnSemaphore* semaphore, struct gnOutputDevice_t* device) { gnReturnCode gnCreateSemaphore(gnSemaphore* semaphore, struct gnOutputDevice_t* device) {
*semaphore = malloc(sizeof(struct gnSemaphore_t)); *semaphore = malloc(sizeof(struct gnSemaphore_t));
(*semaphore)->device = device; (*semaphore)->device = device;
return device->deviceFunctions->_gnCreateSemaphore((*semaphore), device); return device->instance->callingLayer->deviceFunctions._gnCreateSemaphore((*semaphore), device);
} }
void gnDestroySemaphore(struct gnSemaphore_t* semaphore) { void gnDestroySemaphore(struct gnSemaphore_t* semaphore) {
semaphore->device->deviceFunctions->_gnDestroySemaphore(semaphore); semaphore->device->instance->callingLayer->deviceFunctions._gnDestroySemaphore(semaphore);
} }

7
projects/core/src/textures/gryphn_texture.c
View File

@@ -1,16 +1,17 @@
#include "gryphn_texture.h" #include "gryphn_texture.h"
#include "output_device/gryphn_output_device.h" #include "output_device/gryphn_output_device.h"
#include "instance/gryphn_instance.h"
gnReturnCode gnCreateTexture(gnTexture* texture, gnDevice device, const gnTextureInfo info) { gnReturnCode gnCreateTexture(gnTexture* texture, gnDevice device, const gnTextureInfo info) {
*texture = malloc(sizeof(struct gnTexture_t)); *texture = malloc(sizeof(struct gnTexture_t));
(*texture)->device = device; (*texture)->device = device;
(*texture)->info = info; (*texture)->info = info;
return device->deviceFunctions->_gnCreateTexture(*texture, device, info); return device->instance->callingLayer->deviceFunctions._gnCreateTexture(*texture, device, info);
} }
void gnTextureData(gnTextureHandle texture, void* pixelData) { void gnTextureData(gnTextureHandle texture, void* pixelData) {
texture->device->deviceFunctions->_gnTextureData(texture, pixelData); texture->device->instance->callingLayer->deviceFunctions._gnTextureData(texture, pixelData);
} }
void gnDestroyTexture(gnTexture texture) { void gnDestroyTexture(gnTexture texture) {
texture->device->deviceFunctions->_gnDestroyTexture(texture); texture->device->instance->callingLayer->deviceFunctions._gnDestroyTexture(texture);
} }

5
projects/core/src/uniforms/gryphn_uniform.c
View File

@@ -1,11 +1,12 @@
#include "gryphn_uniform.h" #include "gryphn_uniform.h"
#include "gryphn_uniform_pool.h" #include "gryphn_uniform_pool.h"
#include "output_device/gryphn_output_device.h" #include "output_device/gryphn_output_device.h"
#include "instance/gryphn_instance.h"
void gnUpdateBufferUniform(gnUniform uniform, gnBufferUniformInfo bufferInfo) { void gnUpdateBufferUniform(gnUniform uniform, gnBufferUniformInfo bufferInfo) {
uniform->pool->device->deviceFunctions->_gnUpdateBufferUniform(uniform, &bufferInfo); uniform->pool->device->instance->callingLayer->deviceFunctions._gnUpdateBufferUniform(uniform, &bufferInfo);
} }
void gnUpdateImageUniform(gnUniform uniform, gnImageUniformInfo imageInfo) { void gnUpdateImageUniform(gnUniform uniform, gnImageUniformInfo imageInfo) {
uniform->pool->device->deviceFunctions->_gnUpdateImageUniform(uniform, &imageInfo); uniform->pool->device->instance->callingLayer->deviceFunctions._gnUpdateImageUniform(uniform, &imageInfo);
} }

7
projects/core/src/uniforms/gryphn_uniform_pool.c
View File

@@ -1,17 +1,18 @@
#include "gryphn_uniform_pool.h" #include "gryphn_uniform_pool.h"
#include "output_device/gryphn_output_device.h" #include "output_device/gryphn_output_device.h"
#include "gryphn_uniform.h" #include "gryphn_uniform.h"
#include "instance/gryphn_instance.h"
#include "stdlib.h" #include "stdlib.h"
gnReturnCode gnCreateUniformPool(gnUniformPool* pool, gnDeviceHandle device) { gnReturnCode gnCreateUniformPool(gnUniformPool* pool, gnDeviceHandle device) {
*pool = malloc(sizeof(struct gnUniformPool_t)); *pool = malloc(sizeof(struct gnUniformPool_t));
(*pool)->device = device; (*pool)->device = device;
return device->deviceFunctions->_gnCreateUniformPool(*pool, device); return device->instance->callingLayer->deviceFunctions._gnCreateUniformPool(*pool, device);
} }
// you own this memory now // you own this memory now
gnUniformArrayList gnUniformPoolAllocateUniforms(gnUniformPool pool, gnUniformAllocationInfo allocInfo) { gnUniformArrayList gnUniformPoolAllocateUniforms(gnUniformPool pool, gnUniformAllocationInfo allocInfo) {
gnUniform* uniforms = pool->device->deviceFunctions->_gnUniformPoolAllocateUniforms(pool, allocInfo); gnUniform* uniforms = pool->device->instance->callingLayer->deviceFunctions._gnUniformPoolAllocateUniforms(pool, allocInfo);
for (int i = 0; i < allocInfo.setCount; i++) for (int i = 0; i < allocInfo.setCount; i++)
uniforms[i]->pool = pool; uniforms[i]->pool = pool;
@@ -22,5 +23,5 @@ gnUniformArrayList gnUniformPoolAllocateUniforms(gnUniformPool pool, gnUniformAl
} }
void gnDestroyUniformPool(gnUniformPool pool) { void gnDestroyUniformPool(gnUniformPool pool) {
pool->device->deviceFunctions->_gnDestroyUniformPool(pool); pool->device->instance->callingLayer->deviceFunctions._gnDestroyUniformPool(pool);
} }

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

@@ -1,7 +1,7 @@
#include "gryphn_surface.h" #include "gryphn_surface.h"
void gnDestroyWindowSurface(gnWindowSurfaceHandle windowSurface) { void gnDestroyWindowSurface(gnWindowSurfaceHandle windowSurface) {
windowSurface->instance->instanceFunctions._gnDestroyWindowSurface(windowSurface); windowSurface->instance->callingLayer->instanceFunctions._gnDestroyWindowSurface(windowSurface);
} }
gnSurfaceFormat* gnGetSupportedSurfaceFormats( gnSurfaceFormat* gnGetSupportedSurfaceFormats(
@@ -9,7 +9,7 @@ gnSurfaceFormat* gnGetSupportedSurfaceFormats(
gnPhysicalDevice device, gnPhysicalDevice device,
uint32_t* formatCount uint32_t* formatCount
) { ) {
gnSurfaceDetails surfaceDetails = windowSurface->instance->instanceFunctions._gnGetSurfaceDetails(windowSurface, device); gnSurfaceDetails surfaceDetails = windowSurface->instance->callingLayer->instanceFunctions._gnGetSurfaceDetails(windowSurface, device);
*formatCount = surfaceDetails.formatCount; *formatCount = surfaceDetails.formatCount;
return surfaceDetails.formats; return surfaceDetails.formats;
} }
@@ -53,16 +53,16 @@ gnSurfaceFormat gnGetPreferredSurfaceFormat(
} }
uint32_t gnGetMinImageCount(gnWindowSurfaceHandle surface, gnPhysicalDevice device) { uint32_t gnGetMinImageCount(gnWindowSurfaceHandle surface, gnPhysicalDevice device) {
gnSurfaceDetails surfaceDetails = surface->instance->instanceFunctions._gnGetSurfaceDetails(surface, device); gnSurfaceDetails surfaceDetails = surface->instance->callingLayer->instanceFunctions._gnGetSurfaceDetails(surface, device);
return surfaceDetails.minImageCount; return surfaceDetails.minImageCount;
} }
uint32_t gnGetMaxImageCount(gnWindowSurfaceHandle surface, gnPhysicalDevice device) { uint32_t gnGetMaxImageCount(gnWindowSurfaceHandle surface, gnPhysicalDevice device) {
gnSurfaceDetails surfaceDetails = surface->instance->instanceFunctions._gnGetSurfaceDetails(surface, device); gnSurfaceDetails surfaceDetails = surface->instance->callingLayer->instanceFunctions._gnGetSurfaceDetails(surface, device);
return surfaceDetails.maxImageCount; return surfaceDetails.maxImageCount;
} }
uint32_t gnGetPreferredImageCount(gnWindowSurfaceHandle surface, gnPhysicalDevice device) { uint32_t gnGetPreferredImageCount(gnWindowSurfaceHandle surface, gnPhysicalDevice device) {
gnSurfaceDetails surfaceDetails = surface->instance->instanceFunctions._gnGetSurfaceDetails(surface, device); gnSurfaceDetails surfaceDetails = surface->instance->callingLayer->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) {
@@ -71,4 +71,4 @@ uint32_t gnGetPreferredImageCount(gnWindowSurfaceHandle surface, gnPhysicalDevi
return imageCount; return imageCount;
} }
gnSurfaceDetails gnGetSurfaceDetails(gnWindowSurfaceHandle surface, gnPhysicalDevice device) { return surface->instance->instanceFunctions._gnGetSurfaceDetails(surface, device); } gnSurfaceDetails gnGetSurfaceDetails(gnWindowSurfaceHandle surface, gnPhysicalDevice device) { return surface->instance->callingLayer->instanceFunctions._gnGetSurfaceDetails(surface, device); }

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

@@ -7,13 +7,13 @@
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->instanceFunctions._gnCreateX11WindowSurface(*windowSurface, instance, createInfo); return instance->callingLayer->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->instanceFunctions._gnCreateWaylandWindowSurface(windowSurface, instance, createInfo); return instance->callingLayer->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->instanceFunctions._gnCreateWin32WindowSurface(windowSurface, instance, createInfo); return instance->callingLayer->instanceFunctions._gnCreateWin32WindowSurface(windowSurface, instance, createInfo);
} }
#endif #endif
@@ -30,6 +30,6 @@
gnReturnCode gnCreateMacOSWindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, gnMacOSWindowSurfaceInfo createInfo) { gnReturnCode gnCreateMacOSWindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, gnMacOSWindowSurfaceInfo createInfo) {
*windowSurface = malloc(sizeof(struct gnWindowSurface_t)); *windowSurface = malloc(sizeof(struct gnWindowSurface_t));
(*windowSurface)->instance = instance; (*windowSurface)->instance = instance;
return instance->instanceFunctions._gnCreateMacOSWindowSurface(*windowSurface, instance, createInfo); return instance->callingLayer->instanceFunctions._gnCreateMacOSWindowSurface(*windowSurface, instance, createInfo);
} }
#endif #endif