rename to projects (DOES NOT COMPILE)

projects/apis/vulkan/src/commands/command_buffer/vulkan_command_buffer.c

@@ -0,0 +1,80 @@
+#include "vulkan_command_buffer.h"
+#include "commands/command_pool/vulkan_command_pool.h"
+#include "output_device/vulkan_output_devices.h"
+
+gnReturnCode gnCommandPoolAllocateCommandBuffersFn(gnCommandBufferHandle* commandBuffers, uint32_t count, struct gnCommandPool_t* pool) {
+    VkCommandBufferAllocateInfo allocInfo = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+        .commandPool = pool->commandPool->commandPool,
+        .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+        .commandBufferCount = count,
+    };
+
+    VkCommandBuffer* buffers = malloc(sizeof(VkCommandBuffer) * count);
+
+    if (vkAllocateCommandBuffers(pool->device->outputDevice->device, &allocInfo, buffers) != VK_SUCCESS)
+        return GN_FAILED_TO_ALLOCATE_COMMAND_BUFFERS;
+
+    for (int i = 0; i < count; i++) {
+        commandBuffers[i]->commandBuffer = malloc(sizeof(gnPlatformCommandBuffer));
+        commandBuffers[i]->commandBuffer->buffer = buffers[i];
+    }
+
+    return GN_SUCCESS;
+}
+
+void gnResetCommandBufferFn(struct gnCommandBuffer_t* commandBuffer) {
+    vkResetCommandBuffer(commandBuffer->commandBuffer->buffer, 0);
+}
+
+
+gnReturnCode gnBeginCommandBufferFn(struct gnCommandBuffer_t* commandBuffer) {
+    VkCommandBufferBeginInfo beginInfo = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
+    };
+
+    if (vkBeginCommandBuffer(commandBuffer->commandBuffer->buffer, &beginInfo) != VK_SUCCESS) {
+        return GN_FAILED_TO_BEGIN_RECORDING;
+    }
+    return GN_SUCCESS;
+}
+
+gnReturnCode gnEndCommandBufferFn(struct gnCommandBuffer_t* commandBuffer) {
+    if (vkEndCommandBuffer(commandBuffer->commandBuffer->buffer) != VK_SUCCESS)
+        return GN_FAIELD_TO_END_RECORDING;
+    return GN_SUCCESS;
+}
+
+
+VkCommandBuffer VkBeginTransferOperation(VkDevice device, VkCommandPool pool) {
+    VkCommandBufferAllocateInfo allocInfo = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+        .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+        .commandPool = pool,
+        .commandBufferCount = 1
+    };
+
+    VkCommandBuffer commandBuffer;
+    vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);
+
+    VkCommandBufferBeginInfo beginInfo = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+        .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
+    };
+    vkBeginCommandBuffer(commandBuffer, &beginInfo);
+    return commandBuffer;
+}
+
+void VkEndTransferOperation(VkCommandBuffer transferBuffer, VkCommandPool pool, VkQueue syncQueue, VkDevice device) {
+    vkEndCommandBuffer(transferBuffer);
+
+    VkSubmitInfo submitInfo = {
+        .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
+        .commandBufferCount = 1,
+        .pCommandBuffers = &transferBuffer
+    };
+
+    vkQueueSubmit(syncQueue, 1, &submitInfo, VK_NULL_HANDLE);
+    vkQueueWaitIdle(syncQueue);
+    vkFreeCommandBuffers(device, pool, 1, &transferBuffer);
+}

projects/apis/vulkan/src/commands/command_buffer/vulkan_command_buffer.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "core/command/command_buffer/gryphn_command_buffer.h"
+#include "utils/gryphn_bool.h"
+#include <vulkan/vulkan.h>
+
+typedef struct gnPlatformCommandBuffer_t {
+    VkCommandBuffer buffer;
+
+    gnBool changedBuffer;
+    gnBufferHandle boundIndexBuffer;
+    gnGraphicsPipeline boundGraphicsPipeline;
+} gnPlatformCommandBuffer;
+
+VkCommandBuffer VkBeginTransferOperation(VkDevice device, VkCommandPool pool);
+void VkEndTransferOperation(VkCommandBuffer transferBuffer, VkCommandPool pool, VkQueue syncQueue, VkDevice device);

projects/apis/vulkan/src/commands/command_pool/vulkan_command_pool.c

@@ -0,0 +1,23 @@
+#include "vulkan_command_pool.h"
+#include "output_device/vulkan_output_devices.h"
+
+gnReturnCode gnCreateCommandPoolFn(struct gnCommandPool_t* commandPool, struct gnOutputDevice_t* device, struct gnCommandPoolInfo_t info) {
+    commandPool->commandPool = malloc(sizeof(gnPlatformCommandPool));
+
+    VkCommandPoolCreateInfo poolInfo = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
+        .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
+        .queueFamilyIndex = info.queueIndex,
+    };
+
+    if (vkCreateCommandPool(device->outputDevice->device, &poolInfo, NULL, &commandPool->commandPool->commandPool) != VK_SUCCESS) {
+        return GN_FAILED_TO_CREATE_COMMAND_POOL;
+    }
+
+    return GN_SUCCESS;
+}
+
+void gnDestroyCommandPoolFn(struct gnCommandPool_t* commandPool) {
+    vkDestroyCommandPool(commandPool->device->outputDevice->device, commandPool->commandPool->commandPool, NULL);
+    free(commandPool->commandPool);
+}

projects/apis/vulkan/src/commands/command_pool/vulkan_command_pool.h

@@ -0,0 +1,7 @@
+#pragma once
+#include <vulkan/vulkan.h>
+#include "core/command/command_pool/gryphn_command_pool.h"
+
+typedef struct gnPlatformCommandPool_t {
+    VkCommandPool commandPool;
+} gnPlatformCommandPool;

projects/apis/vulkan/src/commands/commands/vulkan_commands.c

@@ -0,0 +1,97 @@
+#include <vulkan/vulkan.h>
+#include "core/command/commands/gryphn_command.h"
+#include <renderpass/vulkan_render_pass_descriptor.h>
+#include "framebuffers/vulkan_framebuffer.h"
+#include "commands/command_buffer/vulkan_command_buffer.h"
+#include "pipelines/graphics_pipeline/vulkan_graphics_pipeline.h"
+#include "buffers/vulkan_buffer.h"
+#include "uniforms/vulkan_uniform.h"
+#include "shader_module/vulkan_shader_module.h"
+
+void gnCommandBeginRenderPassFn(gnCommandBuffer buffer, struct gnRenderPassInfo_t passInfo) {
+    VkClearValue* values = malloc(sizeof(VkClearValue) * passInfo.clearValueCount);
+    for (int i = 0; i < passInfo.clearValueCount; i++) {
+        values[i] = (VkClearValue){{{
+            passInfo.clearValues[i].red,
+            passInfo.clearValues[i].green,
+            passInfo.clearValues[i].blue,
+            passInfo.clearValues[i].alpha
+        }}};
+    }
+
+    VkRenderPassBeginInfo renderPassInfo ={
+        .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+        .renderPass = passInfo.renderPassDescriptor->renderPassDescriptor->renderPass,
+        .framebuffer = passInfo.framebuffer->framebuffer->framebuffer,
+        .renderArea = {
+            .extent = { passInfo.size.x, passInfo.size.y },
+            .offset = { passInfo.offset.x, passInfo.offset.y }
+        },
+        .clearValueCount = passInfo.clearValueCount,
+        .pClearValues = values,
+    };
+
+    vkCmdBeginRenderPass(buffer->commandBuffer->buffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
+}
+void gnCommandEndRenderPassFn(gnCommandBuffer buffer) {
+    vkCmdEndRenderPass(buffer->commandBuffer->buffer);
+}
+void gnCommandBindGraphicsPipelineFn(gnCommandBuffer buffer, gnGraphicsPipeline graphicsPipeline) {
+    buffer->commandBuffer->boundGraphicsPipeline = graphicsPipeline;
+    vkCmdBindPipeline(buffer->commandBuffer->buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline->graphicsPipeline->graphicsPipeline);
+}
+void gnCommandSetViewportFn(gnCommandBuffer buffer, gnViewport viewport) {
+    VkViewport vkViewport = {
+        .x = viewport.position.x,
+        .y = viewport.size.y,
+        .width = viewport.size.x,
+        .height = -viewport.size.y,
+        .minDepth = viewport.minDepth,
+        .maxDepth = viewport.maxDepth
+    };
+    vkCmdSetViewport(buffer->commandBuffer->buffer, 0, 1, &vkViewport);
+}
+void gnCommandSetScissorFn(gnCommandBuffer buffer, struct gnScissor_t scissor) {
+    VkRect2D vkScissor = {
+        .extent = { scissor.size.x, scissor.size.y },
+        .offset = { scissor.position.x, scissor.position.y }
+    };
+    vkCmdSetScissor(buffer->commandBuffer->buffer, 0, 1, &vkScissor);
+}
+VkDeviceSize offsets[] = {0};
+void gnCommandBindBufferFn(gnCommandBufferHandle buffer, gnBufferHandle bufferToBind, gnBufferType type)  {
+    if (type == GN_VERTEX_BUFFER)
+        vkCmdBindVertexBuffers(buffer->commandBuffer->buffer, 0, 1, &bufferToBind->buffer->buffer.buffer, offsets);
+    else if (type == GN_INDEX_BUFFER) {
+        buffer->commandBuffer->changedBuffer = gnTrue;
+        buffer->commandBuffer->boundIndexBuffer = bufferToBind;
+    }
+}
+void gnCommandDrawFn(gnCommandBuffer buffer, int vertexCount, int firstVertex, int instanceCount, int firstInstance) {
+    vkCmdDraw(buffer->commandBuffer->buffer, vertexCount, instanceCount, firstVertex, firstInstance);
+}
+void gnCommandDrawIndexedFn(gnCommandBufferHandle buffer, gnIndexType type, int indexCount, int firstIndex, int vertexOffset, int instanceCount, int firstInstance)  {
+    if (buffer->commandBuffer->changedBuffer) vkCmdBindIndexBuffer(buffer->commandBuffer->buffer, buffer->commandBuffer->boundIndexBuffer->buffer->buffer.buffer, 0, (type == GN_UINT32) ? VK_INDEX_TYPE_UINT32 : VK_INDEX_TYPE_UINT16);
+    vkCmdDrawIndexed(buffer->commandBuffer->buffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+    buffer->commandBuffer->changedBuffer = gnFalse;
+}
+
+void gnCommandBindUniformFn(gnCommandBufferHandle buffer, gnUniform uniform, uint32_t set) {
+    vkCmdBindDescriptorSets(
+        buffer->commandBuffer->buffer,
+        VK_PIPELINE_BIND_POINT_GRAPHICS,
+        buffer->commandBuffer->boundGraphicsPipeline->graphicsPipeline->pipelineLayout, set, 1,
+        &uniform->uniform->set, 0, NULL
+    );
+}
+
+void gnCommandPushConstantFn(gnCommandBufferHandle buffer, gnPushConstantLayout layout, void* data) {
+    vkCmdPushConstants(
+        buffer->commandBuffer->buffer,
+        buffer->commandBuffer->boundGraphicsPipeline->graphicsPipeline->pipelineLayout,
+        vkGryphnShaderModuleStage(layout.stage),
+        layout.offset,
+        layout.size,
+        data
+    );
+}