actually get it to work

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

View File

@@ -1,19 +1,20 @@
#include "gryphn_buffer.h"
#include "output_device/gryphn_output_device.h"
#include "instance/gryphn_instance.h"
gnReturnCode gnCreateBuffer(gnBufferHandle* buffer, gnOutputDeviceHandle device, gnBufferInfo info) {
*buffer = malloc(sizeof(struct gnBuffer_t));
(*buffer)->device = device;
(*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) {
buffer->device->deviceFunctions->_gnBufferData(buffer, dataSize, data);
buffer->device->instance->callingLayer->deviceFunctions._gnBufferData(buffer, dataSize, data);
}
void* gnMapBuffer(gnBufferHandle buffer) {
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) {
buffer->device->deviceFunctions->_gnDestroyBuffer(buffer);
buffer->device->instance->callingLayer->deviceFunctions._gnDestroyBuffer(buffer);
}

View File

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

View File

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

View File

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

View File

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

View File

@@ -1,35 +1,36 @@
#include "gryphn_command.h"
#include "command/command_buffer/gryphn_command_buffer.h"
#include "command/command_pool/gryphn_command_pool.h"
#include "instance/gryphn_instance.h"
void gnCommandBeginRenderPass(gnCommandBufferHandle buffer, gnRenderPassInfo passInfo) {
buffer->commandPool->commandFunctions->_gnCommandBeginRenderPass(buffer, passInfo);
buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandBeginRenderPass(buffer, passInfo);
}
void gnCommandEndRenderPass(gnCommandBufferHandle buffer) {
buffer->commandPool->commandFunctions->_gnCommandEndRenderPass(buffer);
buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandEndRenderPass(buffer);
}
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) {
buffer->commandPool->commandFunctions->_gnCommandSetViewport(buffer, viewport);
buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandSetViewport(buffer, viewport);
}
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) {
buffer->commandPool->commandFunctions->_gnCommandBindUniform(buffer, uniform, set);
buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandBindUniform(buffer, uniform, set);
}
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) {
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) {
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) {
buffer->commandPool->commandFunctions->_gnCommandDrawIndexed(buffer, type, indexCount, firstIndex, vertexOffset, instanceCount, firstInstance);
buffer->commandPool->instance->callingLayer->commandFunctions._gnCommandDrawIndexed(buffer, type, indexCount, firstIndex, vertexOffset, instanceCount, firstInstance);
}

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -4,17 +4,17 @@ gnReturnCode gnCreatePresentationQueue(gnPresentationQueueHandle* presentationQu
*presentationQueue = malloc(sizeof(struct gnPresentationQueue_t));
(*presentationQueue)->outputDevice = device;
(*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) {
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; }
gnTextureHandle gnGetPresentationQueueImage(gnPresentationQueueHandle presentationQueue, uint32_t index) {
return presentationQueue->images[index];
}
void gnDestroyPresentationQueue(gnPresentationQueueHandle presentationQueue) {
presentationQueue->outputDevice->deviceFunctions->_gnDestroyPresentationQueue(presentationQueue);
presentationQueue->outputDevice->instance->callingLayer->deviceFunctions._gnDestroyPresentationQueue(presentationQueue);
free(presentationQueue);
}

View File

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

View File

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

View File

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

View File

@@ -1,23 +1,24 @@
#include "gryphn_fence.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)->device = device;
(*fence)->signaled = gnFalse;
return device->deviceFunctions->_gnCreateFence(*fence, device);
return device->instance->callingLayer->deviceFunctions._gnCreateFence(*fence, device);
}
void gnSignalFence(gnFenceHandle fence) {
fence->signaled = gnTrue;
}
void gnWaitForFence(gnFenceHandle fence, uint64_t timeout) {
if (fence->signaled == gnTrue) return;
fence->device->deviceFunctions->_gnWaitForFence(fence, timeout);
fence->device->instance->callingLayer->deviceFunctions._gnWaitForFence(fence, timeout);
}
void gnResetFence(gnFenceHandle fence) {
fence->signaled = gnFalse;
fence->device->deviceFunctions->_gnResetFence(fence);
fence->device->instance->callingLayer->deviceFunctions._gnResetFence(fence);
}
void gnDestroyFence(gnFenceHandle fence) {
fence->device->deviceFunctions->_gnDestroyFence(fence);
fence->device->instance->callingLayer->deviceFunctions._gnDestroyFence(fence);
}

View File

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

View File

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

View File

@@ -1,11 +1,12 @@
#include "gryphn_uniform.h"
#include "gryphn_uniform_pool.h"
#include "output_device/gryphn_output_device.h"
#include "instance/gryphn_instance.h"
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) {
uniform->pool->device->deviceFunctions->_gnUpdateImageUniform(uniform, &imageInfo);
uniform->pool->device->instance->callingLayer->deviceFunctions._gnUpdateImageUniform(uniform, &imageInfo);
}

View File

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

View File

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

View File

@@ -7,13 +7,13 @@
gnReturnCode gnCreateX11WindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, gnX11WindowSurfaceInfo createInfo) {
*windowSurface = malloc(sizeof(struct gnWindowSurface_t));
(*windowSurface)->instance = instance;
return instance->instanceFunctions._gnCreateX11WindowSurface(*windowSurface, instance, createInfo);
return instance->callingLayer->instanceFunctions._gnCreateX11WindowSurface(*windowSurface, instance, createInfo);
}
#endif
#ifdef GN_WINDOW_WAYLAND
gnReturnCode gnCreateWaylandWindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnWaylandWindowSurfaceInfo_t createInfo) {
*windowSurface = malloc(sizeof(struct gnWindowSurface_t));
return instance->instanceFunctions._gnCreateWaylandWindowSurface(windowSurface, instance, createInfo);
return instance->callingLayer->instanceFunctions._gnCreateWaylandWindowSurface(windowSurface, instance, createInfo);
}
#endif
#endif
@@ -22,7 +22,7 @@
#ifdef GN_PLATFORM_WIN32
gnReturnCode gnCreateWin32WindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, struct gnWin32WindowSurfaceInfo_t createInfo) {
*windowSurface = malloc(sizeof(struct gnWindowSurface_t));
return instance->instanceFunctions._gnCreateWin32WindowSurface(windowSurface, instance, createInfo);
return instance->callingLayer->instanceFunctions._gnCreateWin32WindowSurface(windowSurface, instance, createInfo);
}
#endif
@@ -30,6 +30,6 @@
gnReturnCode gnCreateMacOSWindowSurface(gnWindowSurfaceHandle* windowSurface, gnInstanceHandle instance, gnMacOSWindowSurfaceInfo createInfo) {
*windowSurface = malloc(sizeof(struct gnWindowSurface_t));
(*windowSurface)->instance = instance;
return instance->instanceFunctions._gnCreateMacOSWindowSurface(*windowSurface, instance, createInfo);
return instance->callingLayer->instanceFunctions._gnCreateMacOSWindowSurface(*windowSurface, instance, createInfo);
}
#endif