gryphn+vulkan command buffers

include/gryphn/gryphn.h

@@ -15,4 +15,5 @@
 #include <core/textures/gryphn_texture.h>
 #include <core/command/command_pool/gryphn_command_pool.h>
 #include <core/command/command_buffer/gryphn_command_buffer.h>
+#include <core/command/commands/gryphn_command.h>
 #include <core/renderpass/gryphn_render_pass.h>

rendering_api/vulkan/src/commands/command_buffer/vulkan_command_buffer.c

@@ -0,0 +1,41 @@
+#include "vulkan_command_buffer.h"
+#include "commands/command_pool/vulkan_command_pool.h"
+#include "output_device/vulkan_output_devices.h"
+
+gnReturnCode gnCommandPoolAllocateCommandBuffersFn(struct gnCommandBuffer_t* 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;
+}
+
+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;
+}

rendering_api/vulkan/src/commands/command_buffer/vulkan_command_buffer.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "core/command/command_buffer/gryphn_command_buffer.h"
+#include <vulkan/vulkan.h>
+
+typedef struct gnPlatformCommandBuffer_t {
+    VkCommandBuffer buffer;
+} gnPlatformCommandBuffer;

rendering_api/vulkan/src/commands/commands/vulkan_commands.c

@@ -0,0 +1,59 @@
+#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"
+
+void gnCommandBeginRenderPassFn(struct gnCommandBuffer_t* 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.x }
+        },
+        .clearValueCount = passInfo.clearValueCount,
+        .pClearValues = values
+    };
+
+    vkCmdBeginRenderPass(buffer->commandBuffer->buffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
+}
+void gnCommandEndRenderPassFn(struct gnCommandBuffer_t* buffer) {
+    vkCmdEndRenderPass(buffer->commandBuffer->buffer);
+}
+void gnCommandBindGraphicsPipelineFn(struct gnCommandBuffer_t* buffer, struct gnGraphicsPipeline_t* graphicsPipeline) {
+    vkCmdBindPipeline(buffer->commandBuffer->buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline->graphicsPipeline->graphicsPipeline);
+}
+void gnCommandSetViewportFn(struct gnCommandBuffer_t* buffer, struct gnViewport_t viewport) {
+    VkViewport vkViewport = {
+        .x = viewport.position.x,
+        .y = viewport.position.y,
+        .width = viewport.size.x,
+        .height = viewport.size.y,
+        .minDepth = viewport.minDepth,
+        .maxDepth = viewport.maxDepth
+    };
+    vkCmdSetViewport(buffer->commandBuffer->buffer, 0, 1, &vkViewport);
+}
+void gnCommandSetScissorFn(struct gnCommandBuffer_t* 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);
+}
+void gnCommandDrawFn(struct gnCommandBuffer_t* buffer, int vertexCount, int firstVertex, int instanceCount, int firstInstance) {
+    vkCmdDraw(buffer->commandBuffer->buffer, vertexCount, instanceCount, firstVertex, firstInstance);
+}

src/core/command/command_buffer/gryphn_command_buffer.c

@@ -0,0 +1,18 @@
+#include "gryphn_command_buffer.h"
+#include "core/gryphn_platform_functions.h"
+#include "stdio.h"
+
+gnReturnCode gnCommandPoolAllocateCommandBuffers(struct gnCommandBuffer_t* buffers, uint32_t count, struct gnCommandPool_t* commandPool) {
+    for (int i = 0; i < count; i++) {
+        buffers[i].commandPool = commandPool;
+    }
+    return commandPool->commandFunctions->_gnCommandPoolAllocateCommandBuffers(buffers, count, commandPool);
+}
+
+gnReturnCode gnBeginCommandBuffer(struct gnCommandBuffer_t* commandBuffer) {
+    return commandBuffer->commandPool->commandFunctions->_gnBeginCommandBuffer(commandBuffer);
+}
+
+gnReturnCode gnEndCommandBuffer(struct gnCommandBuffer_t* commandBuffer) {
+    return commandBuffer->commandPool->commandFunctions->_gnEndCommandBuffer(commandBuffer);
+}

src/core/command/command_buffer/gryphn_command_buffer.h

@@ -1,10 +1,12 @@
 #pragma once
 #include <core/command/command_pool/gryphn_command_pool.h>
-#include "core/renderpass/gryphn_render_pass.h"
 
 typedef struct gnCommandBuffer_t {
     struct gnPlatformCommandBuffer_t* commandBuffer;
+    struct gnCommandPool_t* commandPool;
 } gnCommandBuffer;
 
+gnReturnCode gnCommandPoolAllocateCommandBuffers(struct gnCommandBuffer_t* buffers, uint32_t count, struct gnCommandPool_t* commandPool);
+
 gnReturnCode gnBeginCommandBuffer(struct gnCommandBuffer_t* commandBuffer);
-void gnCommandBufferBeginRenderPass(struct gnRenderPassInfo_t passInfo);
+gnReturnCode gnEndCommandBuffer(struct gnCommandBuffer_t* commandBuffer);

src/core/command/command_pool/gryphn_command_pool.c

@@ -1,7 +1,15 @@
 #include "gryphn_command_pool.h"
 #include "core/gryphn_platform_functions.h"
+#include "core/instance/init/gryphn_init.h"
 
 gnReturnCode gnCreateCommandPool(struct gnCommandPool_t* commandPool, struct gnOutputDevice_t* device, struct gnCommandPoolInfo_t info) {
+    if (!device->instance->loadCommandFunctions) {
+        device->instance->commandFunctions = malloc(sizeof(struct gnCommandFunctions_t));
+        gnLoadCommandFunctions(device->instance->dynamicLib, device->instance->commandFunctions);
+        device->instance->loadCommandFunctions = gnTrue;
+    }
+    commandPool->commandFunctions = device->instance->commandFunctions;
+
     commandPool->device = device;
     return device->deviceFunctions->_gnCreateCommandPool(commandPool, device, info);
 }

src/core/command/command_pool/gryphn_command_pool.h

@@ -8,6 +8,7 @@ typedef struct gnCommandPoolInfo_t {
 
 typedef struct gnCommandPool_t {
     struct gnPlatformCommandPool_t* commandPool;
+    struct gnCommandFunctions_t* commandFunctions;
     struct gnOutputDevice_t* device;
 } gnCommandPool;
 

src/core/command/commands/gryphn_command.c

@@ -0,0 +1,23 @@
+#include "gryphn_command.h"
+#include "core/gryphn_platform_functions.h"
+
+void gnCommandBeginRenderPass(struct gnCommandBuffer_t* buffer, struct gnRenderPassInfo_t passInfo) {
+    buffer->commandPool->commandFunctions->_gnCommandBeginRenderPass(buffer, passInfo);
+}
+void gnCommandEndRenderPass(struct gnCommandBuffer_t* buffer) {
+    buffer->commandPool->commandFunctions->_gnCommandEndRenderPass(buffer);
+}
+
+void gnCommandBindGraphicsPipeline(struct gnCommandBuffer_t* buffer, struct gnGraphicsPipeline_t* graphicsPipeline) {
+    buffer->commandPool->commandFunctions->_gnCommandBindGraphicsPipeline(buffer, graphicsPipeline);
+}
+void gnCommandSetViewport(struct gnCommandBuffer_t* buffer, struct gnViewport_t viewport) {
+    buffer->commandPool->commandFunctions->_gnCommandSetViewport(buffer, viewport);
+}
+void gnCommandSetScissor(struct gnCommandBuffer_t* buffer, struct gnScissor_t scissor) {
+    buffer->commandPool->commandFunctions->_gnCommandSetScissor(buffer, scissor);
+}
+
+void gnCommandDraw(struct gnCommandBuffer_t* buffer, int vertexCount, int firstVertex, int instanceCount, int firstInstance) {
+    buffer->commandPool->commandFunctions->_gnCommandDraw(buffer, vertexCount, firstVertex, instanceCount, firstInstance);
+}

src/core/command/commands/gryphn_command.h

@@ -0,0 +1,13 @@
+#include "core/command/command_buffer/gryphn_command_buffer.h"
+
+
+#include "core/renderpass/gryphn_render_pass.h"
+void gnCommandBeginRenderPass(struct gnCommandBuffer_t* buffer, struct gnRenderPassInfo_t passInfo);
+void gnCommandEndRenderPass(struct gnCommandBuffer_t* buffer);
+
+#include "core/pipelines/graphics_pipeline/gryphn_graphics_pipeline.h"
+void gnCommandBindGraphicsPipeline(struct gnCommandBuffer_t* buffer, struct gnGraphicsPipeline_t* graphicsPipeline);
+void gnCommandSetViewport(struct gnCommandBuffer_t* buffer, struct gnViewport_t viewport);
+void gnCommandSetScissor(struct gnCommandBuffer_t* buffer, struct gnScissor_t scissor);
+
+void gnCommandDraw(struct gnCommandBuffer_t* buffer, int vertexCount, int firstVertex, int instanceCount, int firstInstance);

src/core/debugger/gryphn_debugger.h

@@ -53,7 +53,7 @@ typedef struct gnDebugger_t {
 gnReturnCode gnCreateDebugger(gnDebugger* debugger, const struct gnDebuggerInfo_t info);
 void gnDestroyDebugger(gnDebugger* debugger);
 
-void gnDebuggerSetErrorMessage(gnDebugger* debugger, gnMessageData data) {
+static void gnDebuggerSetErrorMessage(gnDebugger* debugger, gnMessageData data) {
     debugger->info.callback(
         GN_MESSAGE_ERROR,
         GN_DEBUG_MESSAGE_VALIDATION,

src/core/gryphn_platform_functions.h

@@ -13,6 +13,7 @@
 #include "framebuffer/gryphn_framebuffer.h"
 #include "command/command_pool/gryphn_command_pool.h"
 #include "command/command_buffer/gryphn_command_buffer.h"
+#include "renderpass/gryphn_render_pass.h"
 
 typedef struct gnFunctions_t {
     gnReturnCode (*_gnCreateInstance)(gnInstance* instance, struct gnInstanceInfo_t info);
@@ -75,4 +76,15 @@ typedef struct gnDeviceFunctions_t {
 
 typedef struct gnCommandFunctions_t {
     gnReturnCode (*_gnCommandPoolAllocateCommandBuffers)(struct gnCommandBuffer_t* commandBuffers, uint32_t count, struct gnCommandPool_t* pool);
+    gnReturnCode (*_gnBeginCommandBuffer)(struct gnCommandBuffer_t* commandBuffer);
+    gnReturnCode (*_gnEndCommandBuffer)(struct gnCommandBuffer_t* commandBuffer);
+
+    void (*_gnCommandBeginRenderPass)(struct gnCommandBuffer_t* buffer, struct gnRenderPassInfo_t passInfo);
+    void (*_gnCommandEndRenderPass)(struct gnCommandBuffer_t* buffer);
+
+    void (*_gnCommandBindGraphicsPipeline)(struct gnCommandBuffer_t* buffer, struct gnGraphicsPipeline_t* graphicsPipeline);
+    void (*_gnCommandSetViewport)(struct gnCommandBuffer_t* buffer, struct gnViewport_t viewport);
+    void (*_gnCommandSetScissor)(struct gnCommandBuffer_t* buffer, struct gnScissor_t scissor);
+
+    void (*_gnCommandDraw)(struct gnCommandBuffer_t* buffer, int vertexCount, int firstVertex, int instanceCount, int firstInstance);
 } gnCommandFunctions;

src/core/gryphn_rendering_api.h

@@ -11,7 +11,7 @@ typedef enum gnRenderingAPI_t {
     GN_RENDERINGAPI_METAL
 } gnRenderingAPI;
 
-gnString gnRenderingAPIName(gnRenderingAPI api) {
+static gnString gnRenderingAPIName(gnRenderingAPI api) {
     switch (api) {
         case GN_RENDERINGAPI_NONE: return gnCreateString("GN_RENDERINGAPI_NONE");
         case GN_RENDERINGAPI_SOFTWARE: return gnCreateString("GN_RENDERINGAPI_SOFTWARE");

src/core/instance/init/gryphn_init.c

@@ -82,3 +82,13 @@ void gnLoadDeviceFunctions(struct gnDynamicLibrary_t* lib, struct gnDeviceFuncti
     gnLoadDLLFunction(lib, functions->_gnCreateCommandPool, "gnCreateCommandPoolFn");
     gnLoadDLLFunction(lib, functions->_gnDestroyCommandPool, "gnDestroyCommandPoolFn");
 }
+
+void gnLoadCommandFunctions(struct gnDynamicLibrary_t* lib, struct gnCommandFunctions_t* functions) {
+    gnLoadDLLFunction(lib, functions->_gnCommandPoolAllocateCommandBuffers, "gnCommandPoolAllocateCommandBuffersFn");
+    gnLoadDLLFunction(lib, functions->_gnBeginCommandBuffer, "gnBeginCommandBufferFn");
+    gnLoadDLLFunction(lib, functions->_gnCommandBeginRenderPass, "gnCommandBeginRenderPassFn");
+    gnLoadDLLFunction(lib, functions->_gnCommandEndRenderPass, "gnCommandEndRenderPassFn");
+    gnLoadDLLFunction(lib, functions->_gnCommandSetViewport, "gnCommandSetViewportFn");
+    gnLoadDLLFunction(lib, functions->_gnCommandSetScissor, "gnCommandSetScissorFn");
+    gnLoadDLLFunction(lib, functions->_gnCommandDraw, "gnCommandDraw");
+}

src/core/instance/init/gryphn_init.h

@@ -8,6 +8,7 @@ gnBool gnIsAPISupported(gnRenderingAPI RenderingAPI);
 struct gnDynamicLibrary_t* gnLoadRenderingDLL(gnRenderingAPI RenderingAPI);
 void gnLoadFunctions(struct gnDynamicLibrary_t* lib, struct gnFunctions_t* functions);
 void gnLoadDeviceFunctions(struct gnDynamicLibrary_t* lib, struct gnDeviceFunctions_t* functions);
+void gnLoadCommandFunctions(struct gnDynamicLibrary_t* lib, struct gnCommandFunctions_t* function);
 
 // #ifdef GN_REVEAL_IMPL
 // gnErrorCode gnInit(gnRenderingAPI RenderingAPI);

src/core/renderpass/gryphn_render_pass.h

@@ -1,10 +1,13 @@
 #pragma once
 #include "gryphn_render_pass_descriptor.h"
 #include "core/framebuffer/gryphn_framebuffer.h"
+#include "utils/types/gryphn_color.h"
 
 typedef struct gnRenderPassInfo_t {
     struct gnRenderPassDescriptor_t* renderPassDescriptor;
     struct gnFramebuffer_t* framebuffer;
     gnUInt2 offset;
     gnUInt2 size;
+    uint32_t clearValueCount;
+    gnClearValue* clearValues;
 } gnRenderPassInfo;

src/utils/gryphn_error_code.h

@@ -27,13 +27,15 @@ typedef enum gnReturnCode_t {
     GN_UNKNOWN_SUBPASS,
     GN_FAILED_TO_CREATE_FRAMEBUFFER,
     GN_DIVERGENT_RENDERPASS,
-    GN_FAILED_TO_CREATE_COMMAND_POOL
+    GN_FAILED_TO_CREATE_COMMAND_POOL,
+    GN_FAILED_TO_BEGIN_RECORDING,
+    GN_FAIELD_TO_END_RECORDING,
+    GN_FAILED_TO_ALLOCATE_COMMAND_BUFFERS
 } gnReturnCode;
 
 typedef gnReturnCode gnErrorCode;
-const char* gnErrorCodeToCString(enum gnReturnCode_t returnCode) {
+static const char* gnErrorCodeToCString(enum gnReturnCode_t returnCode) {
     switch (returnCode) {
-    default: return "GN_FORGOT";
     case GN_SUCCESS: return "GN_SUCCESS";
     case GN_UNKNOWN_RENDERINGAPI: return "GN_UNKNOWN_RENDERINGAPI";
     case GN_UNSUPPORTED_RENDERING_API: return "GN_UNSUPPORTED_RENDERING_API";
@@ -41,6 +43,7 @@ const char* gnErrorCodeToCString(enum gnReturnCode_t returnCode) {
     case GN_FAILED_CREATE_INSTANCE: return "GN_FAILED_CREATE_INSTANCE";
     case GN_FAILED_TO_CREATE_DEBUGGER: return "GN_FAILED_TO_CREATE_DEBUGGER";
     case GN_FAILED_TO_CREATE_DEVICE: return "GN_FAILED_TO_CREATE_DEVICE";
+    case GN_FAILED_TO_ATTACH_WINDOW: return "GN_FAILED_TO_ATTACH_WINDOW";
     case GN_INVALID_INSTANCE: return "GN_INVALID_INSTANCE";
     case GN_DEBUGGER_EXISTS: return "GN_DEBUGGER_EXISTS";
     case GN_NO_SUPPORTED_FORMATS: return "GN_NO_SUPPORTED_FORMATS";
@@ -60,5 +63,8 @@ const char* gnErrorCodeToCString(enum gnReturnCode_t returnCode) {
     case GN_FAILED_TO_CREATE_FRAMEBUFFER: return "GN_FAILED_TO_CREATE_FRAMEBUFFER";
     case GN_DIVERGENT_RENDERPASS: return "GN_DIVERGENT_RENDERPASS";
     case GN_FAILED_TO_CREATE_COMMAND_POOL: return "GN_FAILED_TO_CREATE_COMMAND_POOL";
+    case GN_FAILED_TO_BEGIN_RECORDING: return "GN_FAILED_TO_BEGIN_RECORDING";
+    case GN_FAIELD_TO_END_RECORDING: return "GN_FAIELD_TO_END_RECORDING";
+    case GN_FAILED_TO_ALLOCATE_COMMAND_BUFFERS: return "GN_FAILED_TO_ALLOCATE_COMMAND_BUFFERS";
     }
 }

src/utils/strings/gryphn_string.h

@@ -25,7 +25,7 @@ typedef char gnChar;
 
 typedef struct gnString {
     gnChar* value;
-#ifdef __cplusplus
+#ifdef GN_UTILS_CPP
     gnString(const gnChar* input) {
         this->value = new gnChar[strlen(input) + 1]; // so like my dumbass forgot to put this earlier and some shit was broken but now it fixed
                                                      // I was wondering why one specific string crashed my program, it was my fault
@@ -97,7 +97,7 @@ static gnString gnCreateStringFromChar(gnChar input) {
     string.value[1] = '\0';
     return string;
 }
-gnString gnCreateEmptyString(void) {
+static gnString gnCreateEmptyString() {
     gnString string;
     string.value = (char*)malloc(sizeof(char));
     string.value[0] = '\0';
@@ -110,31 +110,31 @@ gnString gnCreateEmptyString(void) {
     gnChar: gnCreateStringFromChar \
 )(input)
 
-const char* gnToCString(const gnString string) { return string.value; }
-int gnStringLength(const gnString string) { return strlen(string.value); }
-int gnStringFindChar(const gnString string, const gnChar letter) {
-    for (unsigned long i = 0; i < strlen(string.value); i++)
+static const char* gnToCString(const gnString string) { return string.value; }
+static int gnStringLength(const gnString string) { return strlen(string.value); }
+static int gnStringFindChar(const gnString string, const gnChar letter) {
+    for (int i = 0; i < strlen(string.value); i++)
         if (string.value[i] == letter)
-            return (int)i;
+            return i;
     return -1;
 }
-int gnStringFindString(const gnString string, const gnString value) {
+static int gnStringFindString(const gnString string, const gnString value) {
     char first_char = value.value[0];
-    for (unsigned long i = 0; i < strlen(string.value); i++)
+    for (int i = 0; i < strlen(string.value); i++)
         if (string.value[i] == first_char) {
             gnBool same = gnTrue;
-            for (unsigned long c = 1; c < strlen(value.value); c++)
+            for (int c = 1; c < strlen(value.value); c++)
                 if (string.value[i + c] != value.value[c]) {
                     same = gnFalse;
                     break;
                 }
 
             if (same)
-                return (int)i;
+                return i;
         }
     return -1;
 }
-gnString gnSubstring(const gnString string, int index1, int index2) {
+static gnString gnSubstring(const gnString string, int index1, int index2) {
     if (index2 == -1) index2 = gnStringLength(string);
     char* out_value = (char*)malloc(sizeof(char) * ((index2 - index1) + 1));
     for (int i = 0; i < (index2 - index1); i++)
@@ -143,7 +143,7 @@ gnString gnSubstring(const gnString string, int index1, int index2) {
     return gnCreateString(out_value); // zero error checking on this function should really add that in later but like I dont have a logging library that I want to use
                                       // my code never breaks either so I dont need error checks, il just not make errors cuz im not tim
 }
-int gnLetterCount(const gnString string, const gnChar letter) {
+static int gnLetterCount(const gnString string, const gnChar letter) {
     int count = 0;
     for (int i = 0; i < gnStringLength(string); i++) if (string.value[i] == letter) count++;
     return count;
@@ -154,16 +154,16 @@ int gnLetterCount(const gnString string, const gnChar letter) {
     const gnString: gnStringFindValue \
 )(string, value)
 
-void gnAddCharToString(gnString* string, gnChar val) {
+static void gnAddCharToString(gnString* string, gnChar val) {
     string->value = add_char_to_string(string->value, val);
 }
-void gnAddCharPtrToString(gnString* string, gnChar* val) {
+static void gnAddCharPtrToString(gnString* string, gnChar* val) {
     string->value = add_string_to_string(string->value, val);
 }
-void gnAddConstCharPtrToString(gnString* string, const gnChar* val) {
+static void gnAddConstCharPtrToString(gnString* string, const gnChar* val) {
     string->value = add_string_to_string(string->value, (gnChar*)val);
 }
-void gnAddContGnStringToString(gnString* string, gnString val) {
+static void gnAddContGnStringToString(gnString* string, gnString val) {
     string->value = add_string_to_string(string->value, val.value);
 }
 
@@ -175,16 +175,16 @@ void gnAddContGnStringToString(gnString* string, gnString val) {
     gnString: gnAddContGnStringToString \
 )(string, value)
 
-gnString gnCombineStringsChar(const gnString string, gnChar val) {
+static gnString gnCombineStringsChar(const gnString string, gnChar val) {
      return gnCreateString(add_char_to_string(string.value, val));
 }
-gnString gnCombineStringsCharPtr(const gnString string, gnChar* val) {
+static gnString gnCombineStringsCharPtr(const gnString string, gnChar* val) {
     return gnCreateString(add_string_to_string(string.value, val));
 }
-gnString gnCombineStringsConstCharPtr(const gnString string, const gnChar* val) {
+static gnString gnCombineStringsConstCharPtr(const gnString string, const gnChar* val) {
     return gnCreateString(add_string_to_string(string.value, (gnChar*)val));
 }
-gnString gnCombineStringsString(const gnString string, const gnString val) {
+static gnString gnCombineStringsString(const gnString string, const gnString val) {
     return gnCreateString(add_string_to_string(string.value, val.value));
 }
 
@@ -196,9 +196,9 @@ gnString gnCombineStringsString(const gnString string, const gnString val) {
     gnString: gnCombineStringsString \
 )(string, value)
 
-gnBool gnStringEqualsCharPtr(const gnString string, gnChar* val) { return (strcmp(string.value, val) == 0); }
-gnBool gnStringEqualsConstCharPtr(const gnString string,const gnChar* val) { return (strcmp(string.value, (gnChar*)val) == 0); }
-gnBool gnStringEqualsString(const gnString string, const gnString val) { return (strcmp(string.value, val.value) == 0); }
+static gnBool gnStringEqualsCharPtr(const gnString string, gnChar* val) { return (strcmp(string.value, val) == 0); }
+static gnBool gnStringEqualsConstCharPtr(const gnString string,const gnChar* val) { return (strcmp(string.value, (gnChar*)val) == 0); }
+static gnBool gnStringEqualsString(const gnString string, const gnString val) { return (strcmp(string.value, val.value) == 0); }
 
 #define gnStringEquals(string, value) _Generic((value), \
     gnChar*: gnStringEqualsCharPtr, \
@@ -206,25 +206,25 @@ gnBool gnStringEqualsString(const gnString string, const gnString val) { return
     gnString: gnStringEqualsString \
 )(string, value)
 
-gnChar gnGetCharAt(const gnString string, int index) { return string.value[index]; }
-void gnSetCharAt(gnString* string, int index, gnChar letter) { string->value[index] = letter; }
+static gnChar gnGetCharAt(const gnString string, int index) { return string.value[0]; }
+static void gnSetCharAt(gnString* string, int index, gnChar letter) { string->value[0] = letter; }
 
-void gnSetStringToChar(gnString* string, gnChar input) {
+static void gnSetStringToChar(gnString* string, gnChar input) {
     string->value = (gnChar*)malloc(sizeof(gnChar) * 2);
     string->value[0] = input;
     string->value[1] = '\0';
 }
-void gnSetStringToCharPtr(gnString* string, gnChar* input) {
+static void gnSetStringToCharPtr(gnString* string, gnChar* input) {
     string->value = (gnChar*)malloc(sizeof(gnChar) * (strlen(input) + 1));
     strcpy(string->value, input);
     string->value[strlen(input)] = '\0';
 }
-void gnSetStringToConstCharPtr(gnString* string, const gnChar* input) {
+static void gnSetStringToConstCharPtr(gnString* string, const gnChar* input) {
     string->value = (gnChar*)malloc(sizeof(gnChar) * (strlen(input) + 1));
     strcpy(string->value, input);
     string->value[strlen(input)] = '\0';
 }
-void gnSetStringToString(gnString* string, const gnString input) {
+static void gnSetStringToString(gnString* string, const gnString input) {
     string->value = (gnChar*)malloc(sizeof(gnChar) * (strlen(input.value) + 1));
     strcpy(string->value, input.value);
     string->value[strlen(input.value)] = '\0';

src/utils/types/gryphn_color.h

@@ -1,3 +1,15 @@
+typedef struct gnClearValue {
+    union {
+      struct {
+          float r, g, b, a;
+      };
+
+      struct {
+          float red, green, blue, alpha;
+      };
+    };
+} gnClearValue;
+
 #pragma once
 typedef struct gnColor {
     union {