redo uniform allocation

rendering_api/vulkan/src/pipelines/graphics_pipeline/vulkan_graphics_pipeline.c

@@ -180,9 +180,9 @@ gnReturnCode gnCreateGraphicsPipelineFn(gnGraphicsPipeline graphicsPipeline, gnD
         .blendConstants[3] = 0.0f
     };
 
-    graphicsPipeline->graphicsPipeline->sets = vkGryphnCreateSetLayouts(
+    graphicsPipeline->graphicsPipeline->setCount = 1;
-        &info.uniformLayout, &graphicsPipeline->graphicsPipeline->setCount, device->outputDevice->device
+    graphicsPipeline->graphicsPipeline->sets = malloc(sizeof(VkDescriptorSetLayout));
-    );
+    graphicsPipeline->graphicsPipeline->sets[0] = vkGryphnCreateSetLayouts(&info.uniformLayout, device->outputDevice->device);
 
     VkPipelineLayoutCreateInfo pipelineLayoutInfo = {
         .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,

rendering_api/vulkan/src/uniforms/vulkan_uniform_layout.c

@@ -8,31 +8,31 @@ VkDescriptorType vkGryphnUniformType(gnUniformType type) {
     }
 }
 
-VkDescriptorSetLayout* vkGryphnCreateSetLayouts(
+VkDescriptorSetLayout vkGryphnCreateSetLayouts(
-    const gnUniformLayout* layout, uint32_t* setCount,
+    const gnUniformLayout* layout,
     VkDevice device
 ) {
+    VkDescriptorSetLayout vkLayout;
     gnUniformLayout uniformLayout = *layout;
 
-    *setCount = uniformLayout.uniformBindingCount;
+    VkDescriptorSetLayoutBinding* bindings = malloc(sizeof(VkDescriptorSetLayoutBinding) * uniformLayout.uniformBindingCount);
-    VkDescriptorSetLayout* sets = malloc(sizeof(VkDescriptorSetLayoutBinding) * uniformLayout.uniformBindingCount);
     for (int i = 0; i < uniformLayout.uniformBindingCount; i++) {
-        VkDescriptorSetLayoutBinding setLayout = {
+        bindings[i] = (VkDescriptorSetLayoutBinding){
             .binding = uniformLayout.uniformBindings[i].binding,
             .descriptorCount = 1,
             .descriptorType = vkGryphnUniformType(uniformLayout.uniformBindings[i].type),
             .stageFlags = vkGryphnShaderModuleStage(uniformLayout.uniformBindings[i].stage)
         };
+    }
+
 
     VkDescriptorSetLayoutCreateInfo info = {
         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-            .bindingCount = 1,
+        .bindingCount = uniformLayout.uniformBindingCount,
-            .pBindings = &setLayout
+        .pBindings = bindings
     };
 
-        if (vkCreateDescriptorSetLayout(device, &info, NULL, sets) != VK_SUCCESS) {
+    if (vkCreateDescriptorSetLayout(device, &info, NULL, &vkLayout) != VK_SUCCESS)
         return NULL;
-        }
+    return vkLayout;
-    }
-    return sets;
 }

rendering_api/vulkan/src/uniforms/vulkan_uniform_layout.h

@@ -2,5 +2,5 @@
 #include <vulkan/vulkan.h>
 #include <core/uniforms/gryphn_uniform_layout.h>
 
-VkDescriptorSetLayout* vkGryphnCreateSetLayouts(const gnUniformLayout* layout, uint32_t* setCount, VkDevice device);
+VkDescriptorSetLayout vkGryphnCreateSetLayouts(const gnUniformLayout* layout, VkDevice device);
 VkDescriptorType vkGryphnUniformType(gnUniformType type);

rendering_api/vulkan/src/uniforms/vulkan_uniform_pool.c

@@ -4,6 +4,8 @@
 #include "output_device/vulkan_output_devices.h"
 #include "core/uniforms/gryphn_uniform.h"
 #include "vulkan_uniform.h"
+#include "shader_module/vulkan_shader_module.h"
+#include "stdio.h"
 
 gnReturnCode gnCreateUniformPoolFn(gnUniformPool pool, gnDeviceHandle device) {
     pool->uniformPool = malloc(sizeof(struct gnPlatformUniformPool_t));
@@ -13,25 +15,60 @@ gnReturnCode gnCreateUniformPoolFn(gnUniformPool pool, gnDeviceHandle device) {
     return GN_SUCCESS;
 }
 
-gnUniform* gnUniformPoolAllocateUniformsFn(gnUniformPool pool, const gnUniformLayout layout) {
+VkDescriptorSetLayout* fsdfsdfsdfsdfsdfdsf(
+    const gnUniformLayout* layout, uint32_t* setCount,
+    VkDevice device
+) {
+    gnUniformLayout uniformLayout = *layout;
+
+    *setCount = uniformLayout.uniformBindingCount;
+    VkDescriptorSetLayout* sets = malloc(sizeof(VkDescriptorSetLayoutBinding) * uniformLayout.uniformBindingCount);
+    for (int i = 0; i < uniformLayout.uniformBindingCount; i++) {
+        VkDescriptorSetLayoutBinding setLayout = {
+            .binding = uniformLayout.uniformBindings[i].binding,
+            .descriptorCount = 1,
+            .descriptorType = vkGryphnUniformType(uniformLayout.uniformBindings[i].type),
+            .stageFlags = vkGryphnShaderModuleStage(uniformLayout.uniformBindings[i].stage)
+        };
+
+        VkDescriptorSetLayoutCreateInfo info = {
+            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+            .bindingCount = 1,
+            .pBindings = &setLayout
+        };
+
+        if (vkCreateDescriptorSetLayout(device, &info, NULL, sets) != VK_SUCCESS) {
+            return NULL;
+        }
+    }
+    return sets;
+}
+
+gnUniform* gnUniformPoolAllocateUniformsFn(gnUniformPool pool, gnUniformAllocationInfo allocInfo) {
     if (pool->uniformPool->poolCount >= pool->uniformPool->maxPoolCount) {
         pool->uniformPool->maxPoolCount *= 2;
         pool->uniformPool->pools = realloc(pool->uniformPool->pools, sizeof(vkGryphnUniformPool) * pool->uniformPool->maxPoolCount);
     }
 
-    pool->uniformPool->pools[pool->uniformPool->poolCount].layouts = vkGryphnCreateSetLayouts(&layout, &pool->uniformPool->pools[pool->uniformPool->poolCount].layoutCount, pool->device->outputDevice->device);
+    pool->uniformPool->pools[pool->uniformPool->poolCount].layouts = malloc(sizeof(VkDescriptorSetLayout) * allocInfo.layoutCount);
-    VkDescriptorPoolSize* sizes = malloc(sizeof(VkDescriptorPoolSize) * layout.uniformBindingCount);
+    pool->uniformPool->pools[pool->uniformPool->poolCount].layoutCount = allocInfo.layoutCount;
-
+    VkDescriptorPoolSize uniformBufferSize = {
-    for (int i = 0; i < layout.uniformBindingCount; i++) {
+        .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-        sizes[i].type = vkGryphnUniformType(layout.uniformBindings[i].type);
+        .descriptorCount = 0
-        sizes[i].descriptorCount = 1;
+    };
+    for (int i = 0; i < allocInfo.layoutCount; i++) {
+        for (int c = 0; c < allocInfo.layouts[i].uniformBindingCount; c++)
+            if (allocInfo.layouts[i].uniformBindings[c].type == GN_UNIFORM_BUFFER_DESCRIPTOR) uniformBufferSize.descriptorCount++;
+        pool->uniformPool->pools[pool->uniformPool->poolCount].layouts[i] = vkGryphnCreateSetLayouts(&allocInfo.layouts[i], pool->device->outputDevice->device);
     }
 
+    uint32_t maxSets = uniformBufferSize.descriptorCount;
+
     VkDescriptorPoolCreateInfo poolInfo = {
         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
-        .poolSizeCount = layout.uniformBindingCount,
+        .poolSizeCount = 1,
-        .pPoolSizes = sizes,
+        .pPoolSizes = &uniformBufferSize,
-        .maxSets = layout.uniformBindingCount,
+        .maxSets = maxSets
     };
 
     if (vkCreateDescriptorPool(
@@ -40,35 +77,34 @@ gnUniform* gnUniformPoolAllocateUniformsFn(gnUniformPool pool, const gnUniformLa
     ) != VK_SUCCESS)
         return NULL;
 
-    VkDescriptorSetAllocateInfo allocInfo = {
+    VkDescriptorSetAllocateInfo vkAllocInfo = {
         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
         .descriptorPool = pool->uniformPool->pools[pool->uniformPool->poolCount].pool,
-        .descriptorSetCount = 1,
+        .descriptorSetCount = allocInfo.layoutCount,
         .pSetLayouts = pool->uniformPool->pools[pool->uniformPool->poolCount].layouts
     };
 
-    VkDescriptorSet* sets = malloc(sizeof(VkDescriptorSet) * layout.uniformBindingCount);
+    VkDescriptorSet* sets = malloc(sizeof(VkDescriptorSet) * allocInfo.layoutCount);
-    if (vkAllocateDescriptorSets(pool->device->outputDevice->device, &allocInfo, sets) != VK_SUCCESS)
+    if (vkAllocateDescriptorSets(pool->device->outputDevice->device, &vkAllocInfo, sets) != VK_SUCCESS)
         return NULL;
 
-    gnUniform* uniforms = malloc(sizeof(gnUniform) * layout.uniformBindingCount);
+    gnUniform* uniforms = malloc(sizeof(gnUniform) * allocInfo.layoutCount);
-    for (int i = 0; i < pool->uniformPool->pools[pool->uniformPool->poolCount].layoutCount; i++) {
+    for (int i = 0; i < allocInfo.layoutCount; i++) {
         uniforms[i] = malloc(sizeof(struct gnUniform_t));
         uniforms[i]->uniform = malloc(sizeof(struct gnPlatformUniform_t));
         uniforms[i]->uniform->set = sets[i];
     }
 
     pool->uniformPool->poolCount++;
-
-    free(sizes);
     return uniforms;
 }
 
 void gnDestroyUniformPoolFn(gnUniformPool pool) {
     for (int i = 0; i < pool->uniformPool->poolCount; i++) {
-        for (int k = 0; k < pool->uniformPool->pools[i].layoutCount; k++)
-            vkDestroyDescriptorSetLayout(pool->device->outputDevice->device, pool->uniformPool->pools[i].layouts[k], NULL);
         vkDestroyDescriptorPool(pool->device->outputDevice->device, pool->uniformPool->pools[i].pool, NULL);
+        for (int k = 0; k < pool->uniformPool->pools[i].layoutCount; k++) {
+            vkDestroyDescriptorSetLayout(pool->device->outputDevice->device, pool->uniformPool->pools[i].layouts[k], NULL);
+        }
     }
     free(pool->uniformPool);
 }

src/core/gryphn_handles.h

@@ -4,7 +4,7 @@
 typedef struct type##_t* type##Handle; \
 typedef struct type##_t* type
 
-#define GN_HANDLE_ALIAS(alias, handle) \
+#define GN_HANDLE_ALIAS(handle, alias) \
 typedef struct handle##_t* alias##Handle; \
 typedef struct handle##_t* alias
 
@@ -15,7 +15,7 @@ GN_HANDLE(gnPresentationQueue);
 GN_HANDLE(gnTexture);
 GN_HANDLE(gnRenderPassDescriptor);
 GN_HANDLE(gnOutputDevice);
-GN_HANDLE_ALIAS(gnDevice, gnOutputDevice);
+GN_HANDLE_ALIAS(gnOutputDevice, gnDevice);
 GN_HANDLE(gnShaderModule);
 GN_HANDLE(gnGraphicsPipeline);
 GN_HANDLE(gnCommandPool);

src/core/gryphn_platform_functions.h

@@ -18,6 +18,7 @@
 #include "core/buffers/gryphn_buffer.h"
 #include "core/uniforms/gryphn_uniform.h"
 #include "core/textures/gryphn_texture.h"
+#include "core/uniforms/gryphn_uniform_pool.h"
 
 typedef struct gnFunctions_t {
     gnReturnCode (*_gnCreateInstance)(gnInstanceHandle instance, gnInstanceInfo info);
@@ -86,7 +87,7 @@ typedef struct gnDeviceFunctions_t {
     void (*_gnDestroyBuffer)(gnBufferHandle buffer);
 
     gnReturnCode (*_gnCreateUniformPool)(gnUniformPool pool, gnDeviceHandle device);
-    gnUniform* (*_gnUniformPoolAllocateUniforms)(gnUniformPool pool, const gnUniformLayout layout);
+    gnUniform* (*_gnUniformPoolAllocateUniforms)(gnUniformPool pool, gnUniformAllocationInfo allocInfo);
     void (*_gnDestroyUniformPool)(gnUniformPool pool);
 
     void (*_gnUpdateBufferUniform)(gnUniform uniform, gnBufferUniformInfo* bufferInfo);

src/core/uniforms/gryphn_uniform_pool.c

@@ -11,14 +11,14 @@ gnReturnCode gnCreateUniformPool(gnUniformPool* pool, gnDeviceHandle device) {
 }
 
 // you own this memory now
-gnUniformArrayList gnUniformPoolAllocateUniforms(gnUniformPool pool, const gnUniformLayout layout, uint32_t count) {
+gnUniformArrayList gnUniformPoolAllocateUniforms(gnUniformPool pool, gnUniformAllocationInfo allocInfo) {
-    gnUniform* uniforms = pool->device->deviceFunctions->_gnUniformPoolAllocateUniforms(pool, layout);
+    gnUniform* uniforms = pool->device->deviceFunctions->_gnUniformPoolAllocateUniforms(pool, allocInfo);
-    for (int i = 0; i < layout.uniformBindingCount; i++)
+    for (int i = 0; i < allocInfo.layoutCount; i++)
         uniforms[i]->pool = pool;
 
     gnUniformArrayList list = gnUniformArrayListCreate();
-    gnUniformArrayListResize(&list, layout.uniformBindingCount);
+    gnUniformArrayListResize(&list, allocInfo.layoutCount);
-    for (int i = 0; i < layout.uniformBindingCount; i++) list.data[i] = uniforms[i];
+    for (int i = 0; i < allocInfo.layoutCount; i++) list.data[i] = uniforms[i];
     return list;
 }
 

src/core/uniforms/gryphn_uniform_pool.h

@@ -11,6 +11,11 @@ struct gnUniformPool_t {
 };
 #endif
 
+typedef struct gnUniformAllocationInfo {
+    const uint32_t layoutCount;
+    const gnUniformLayout* layouts;
+} gnUniformAllocationInfo;
+
 gnReturnCode gnCreateUniformPool(gnUniformPool* pool, gnDeviceHandle device);
-gnUniformArrayList gnUniformPoolAllocateUniforms(gnUniformPool pool, const gnUniformLayout layout);
+gnUniformArrayList gnUniformPoolAllocateUniforms(gnUniformPool pool, gnUniformAllocationInfo allocInfo);
 void gnDestroyUniformPool(gnUniformPool pool);