sdl3 migrate now compiling, need to go through all the files and clean them up

packages/graphics/sdl3/circle.c

@@ -0,0 +1,12 @@
+#include "arc/graphics/circle.h"
+//#include <SDL2_gfxPrimitives.h>
+
+//Modified from https://stackoverflow.com/questions/38334081/how-to-draw-circles-arcs-and-vector-graphics-in-sdl
+void ARC_Circle_Render(ARC_Circle circle, ARC_Renderer *renderer, ARC_Color color){
+//    circleRGBA((SDL_Renderer *)renderer, (Sint16)circle.x, (Sint16)circle.y, (Sint16)circle.r, (Uint8)color.r, (Uint8)color.g, (Uint8)color.b, (Uint8)color.a);
+}
+
+//TODO: very temp
+void ARC_Circle_RenderFill(ARC_Circle circle, ARC_Renderer *renderer, ARC_Color color){
+//    filledCircleRGBA((SDL_Renderer *)renderer, (Sint16)circle.x, (Sint16)circle.y, (Sint16)circle.r, (Uint8)color.r, (Uint8)color.g, (Uint8)color.b, (Uint8)color.a);
+}

packages/graphics/sdl3/config.c

@@ -0,0 +1,228 @@
+#include "arc/graphics/config.h"
+
+#include <SDL3_image/SDL_image.h>
+#include <stdio.h>
+#include "renderer.h"
+#include "sprite.h"
+#include "spritesheet.h"
+#include "arc/std/string.h"
+#include "arc/std/parser/helpers.h"
+#include "arc/std/errno.h"
+#include "arc/graphics/sprite.h"
+#include "arc/graphics/spritesheet.h"
+#include "arc/math/config.h"
+#include "arc/math/point.h"
+#include "arc/math/rectangle.h"
+
+void ARC_Config_InitGraphics(ARC_Config *config, ARC_Renderer *renderer){
+    ARC_Config_RegisterTypeWithCStr(config, "ARC_Spritesheet", (ARC_ConfigType){ ARC_ConfigType_SpritesheetCopyFn, ARC_ConfigType_SpritesheetDestroyFn, renderer});
+    ARC_Config_RegisterTypeWithCStr(config, "ARC_Sprite"     , (ARC_ConfigType){ ARC_ConfigType_SpriteCopyFn     , ARC_ConfigType_SpriteDestroyFn     , renderer});
+}
+
+void ARC_ConfigType_SpritesheetString(void **type, ARC_ParserTagToken *parsedData, ARC_Config *config, void *userdata){
+    ARC_Renderer *renderer = (ARC_Renderer *)userdata;
+
+    //get the string chars between the quotes
+    ARC_ParserTagToken *stringCharsTagToken = (ARC_ParserTagToken *)ARC_Vector_Get(parsedData->tagTokens, 1);
+
+    //get the path
+    ARC_String *path;
+    ARC_String_Create(&path, NULL, 0);
+    ARC_ParserData_HelperRecurseStringAdd(&path, stringCharsTagToken);
+
+    //read in and set the texture
+    ARC_Spritesheet_CreateFromFile((ARC_Spritesheet **)type, renderer, path);
+
+    //cleanup
+    ARC_String_Destroy(path);
+}
+
+void ARC_ConfigType_SpritesheetCopyFn(void **type, ARC_ParserTagToken *parsedData, ARC_Config *config, void *userdata){
+    ARC_ParserTagToken *valueTagToken = (ARC_ParserTagToken *)ARC_Vector_Get(parsedData->tagTokens, 0);
+
+    switch(valueTagToken->id){
+        case ARC_CONFIG_STRING:
+            ARC_ConfigType_SpritesheetString(type, valueTagToken, config, userdata);
+            break;
+
+        case ARC_CONFIG_NESTED_VALUE:
+            return;
+
+        default:
+            arc_errno = ARC_ERRNO_DATA;
+            ARC_DEBUG_LOG_ERROR("ARC_ConfigType_SpritesheetCopyFn(type, parsedData, config, userdata), cannot use a value that is not a string or nested value. Look at documention for this function for more info");
+            break;
+    }
+}
+
+void ARC_ConfigType_SpritesheetDestroyFn(void *type){
+    ARC_Spritesheet_Destroy((ARC_Spritesheet *)type);
+}
+
+void ARC_ConfigType_SpriteCopyFn(void **type, ARC_ParserTagToken *parsedData, ARC_Config *config, void *userdata){
+}
+
+void ARC_ConfigType_SpriteDestroyFn(void *type){
+}
+
+
+
+//uint8_t ARC_Sprite_Read(ARC_Config* config, ARC_String *string, void **value){
+//    ARC_Config_Get(config, string, value);
+//    if(*value){
+//        return 1;
+//    }
+//
+//    if(string->data[0] != '{' || string->data[string->length - 1] != '}'){
+//       ARC_Spritesheet_ReadTexture(config, string, NULL, value);
+//       return 0;
+//    }
+//
+//    uint64_t split = ARC_GraphicsConfig_GetIndexAndErrorCheck(string, ",", 1);
+//    if(arc_errno){
+//        return 0;
+//    }
+//
+//    ARC_String *temp, *spritesheetStr, *framesStr;
+//    ARC_String_CopySubstring(&temp, string, 1, split - 2);
+//    ARC_String_StripEndsWhitespace(&spritesheetStr, temp);
+//    ARC_String_Destroy(temp);
+//
+//    ARC_String_CopySubstring(&temp, string, split + 1, string->length - (split + 2));
+//    ARC_String_StripEndsWhitespace(&framesStr, temp);
+//    ARC_String_Destroy(temp);
+//
+//    //spritesheet
+//    ARC_Spritesheet *spritesheet;
+//    ARC_Config_Get(config, spritesheetStr, (void **)&spritesheet);
+//
+//    if(!spritesheet){
+//        ARC_Spritesheet_Read(config, spritesheetStr, (void **)&spritesheet);
+//        if(arc_errno){
+//            ARC_String_Destroy(spritesheetStr);
+//            ARC_String_Destroy(framesStr     );
+//            return 0;
+//        }
+//    }
+//
+//    //bounds
+//    ARC_Array *frames;
+//    ARC_Config_Get(config, framesStr, (void **)&frames);
+//
+//    if(!frames){
+//        ARC_RectArray_Read(config, framesStr, (void **)&frames);
+//        if(arc_errno){
+//            ARC_String_Destroy(spritesheetStr);
+//            ARC_String_Destroy(framesStr     );
+//            return 0;
+//        }
+//    }
+//
+//    ARC_String_Destroy(spritesheetStr);
+//    ARC_String_Destroy(framesStr     );
+//
+//    // Scale frames to match spritesheet size
+//    // TODO: possible bug for sheets that use same frames
+//    if(spritesheet->size){
+//        for(uint32_t i = 0; i < frames->size; i++){
+//            ((ARC_Rect *)frames->data)[i].x *= *spritesheet->size;
+//            ((ARC_Rect *)frames->data)[i].y *= *spritesheet->size;
+//            ((ARC_Rect *)frames->data)[i].w *= *spritesheet->size;
+//            ((ARC_Rect *)frames->data)[i].h *= *spritesheet->size;
+//        }
+//    }
+//    //sprite
+//    ARC_Sprite_Create((ARC_Sprite **)value, spritesheet, frames);
+//
+//    return 0;
+//}
+//
+//void ARC_SDL_Texture_Delete(ARC_Config* config, ARC_String *string, void *value){
+//    SDL_DestroyTexture((SDL_Texture *) value);
+//}
+//
+//void ARC_Spritesheet_Delete(ARC_Config* config, ARC_String *string, void *value){
+//    ARC_Spritesheet *sheetValue = (ARC_Spritesheet *)value;
+//
+//    //check if read in as a Textrue reference
+//    void *temp;
+//    ARC_Config_Get(config, string, &temp);
+//    if(temp){
+//        //TODO: test to see if this breaks references
+//        free(sheetValue);
+//        return;
+//    }
+//
+//    uint64_t split = ARC_GraphicsConfig_GetIndexAndErrorCheck(string, ",", 1);
+//    if(arc_errno){
+//        //TODO: test to make sure no edge cases
+//        // free(sheetValue);
+//        ARC_SDL_Texture_Delete(config, string, value);
+//        arc_errno = 0;
+//        return;
+//    }
+//
+//    if(split == ~0){
+//
+//    }
+//
+//    //check if texture and size are references
+//    ARC_String *tempStr, *textureStr, *sizeStr;
+//    ARC_String_CopySubstring(&tempStr, string, 1, split - 1);
+//    ARC_String_StripEndsWhitespace(&textureStr, tempStr);
+//    ARC_String_Destroy(tempStr);
+//
+//    ARC_String_CopySubstring(&tempStr, string, split + 1, string->length - (split + 1));
+//    ARC_String_StripEndsWhitespace(&sizeStr, tempStr);
+//    ARC_String_Destroy(tempStr);
+//
+//    ARC_Config_Get(config, sizeStr, (void **)&temp);
+//    ARC_String_Destroy(sizeStr);
+//    if(temp){
+//        free(sheetValue->size);
+//    }
+//
+//    ARC_Config_Get(config, textureStr, (void **)&temp);
+//    ARC_String_Destroy(textureStr);
+//    if(temp){
+//        free(sheetValue->size);
+//    }
+//
+//    free(sheetValue);
+//}
+//
+//void ARC_Sprite_Delete(ARC_Config* config, ARC_String *string, void *value){
+//    ARC_Sprite *spriteValue = (ARC_Sprite *)value;
+//
+//    //check if read in as a Textrue reference
+//    void *temp;
+//    uint64_t split = ARC_GraphicsConfig_GetIndexAndErrorCheck(string, ",", 1);
+//    if(arc_errno){
+//        free(spriteValue);
+//        return;
+//    }
+//
+//    //check if texture and size are references
+//    ARC_String *tempStr, *spritesheetStr, *framesStr;
+//    ARC_String_CopySubstring(&tempStr, string, 1, split - 1);
+//    ARC_String_StripEndsWhitespace(&spritesheetStr, tempStr);
+//    ARC_String_Destroy(tempStr);
+//
+//    ARC_String_CopySubstring(&tempStr, string, split + 1, string->length - (split + 1));
+//    ARC_String_StripEndsWhitespace(&framesStr, tempStr);
+//    ARC_String_Destroy(tempStr);
+//
+//    ARC_Config_Get(config, spritesheetStr, (void **)&temp);
+//    ARC_String_Destroy(spritesheetStr);
+//    if(temp){
+//        free(spriteValue->spritesheet);
+//    }
+//
+//    ARC_Config_Get(config, framesStr, (void **)&temp);
+//    ARC_String_Destroy(framesStr);
+//    if(temp){
+//        free(spriteValue->frames);
+//    }
+//
+//    free(spriteValue);
+//}

packages/graphics/sdl3/line.c

@@ -0,0 +1,7 @@
+#include "arc/graphics/line.h"
+#include "renderer.h"
+
+void ARC_Line_Render(ARC_Point point1, ARC_Point point2, ARC_Renderer *renderer, ARC_Color color){
+    SDL_SetRenderDrawColor((SDL_Renderer *)renderer, color.r, color.g, color.b, color.a);
+    SDL_RenderLine((SDL_Renderer *)renderer, point1.x, point1.y, point2.x, point2.y);
+}

packages/graphics/sdl3/obround.c

@@ -0,0 +1,13 @@
+#include "arc/graphics/obround.h"
+#include "renderer.h"
+#include <stdlib.h>
+
+//Modified from https://stackoverflow.com/questions/38334081/how-to-draw-circles-arcs-and-vector-graphics-in-sdl
+void ARC_Obround_Render(ARC_Obround *obround, ARC_Renderer *renderer, ARC_Color *color){
+    //TODO: write this
+}
+
+void ARC_FObround_Render(ARC_FObround *obround, ARC_Renderer *renderer, ARC_Color *color){
+    ARC_Obround casted = ARC_FObround_CastToObround(obround);
+    ARC_Obround_Render(&casted, renderer, color);
+}

packages/graphics/sdl3/rectangle.c

@@ -0,0 +1,23 @@
+#include "arc/graphics/rectangle.h"
+#include "renderer.h"
+#include <stdlib.h>
+
+void ARC_Rect_Render(ARC_Rect rect, ARC_Renderer *renderer, ARC_Color color){
+    ARC_FRect casted = ARC_Rect_CastToFRect(rect);
+    ARC_FRect_Render(casted, renderer, color);
+}
+
+void ARC_Rect_RenderFill(ARC_Rect rect, ARC_Renderer *renderer, ARC_Color color){
+    ARC_FRect casted = ARC_Rect_CastToFRect(rect);
+    ARC_FRect_RenderFill(casted, renderer, color);
+}
+
+void ARC_FRect_Render(ARC_FRect rect, ARC_Renderer *renderer, ARC_Color color){
+    SDL_SetRenderDrawColor((SDL_Renderer *)renderer, color.r, color.g, color.b, color.a);
+    SDL_RenderRect((SDL_Renderer *)renderer, (SDL_FRect *)&rect);
+}
+
+void ARC_FRect_RenderFill(ARC_FRect rect, ARC_Renderer *renderer, ARC_Color color){
+    SDL_SetRenderDrawColor((SDL_Renderer *)renderer, color.r, color.g, color.b, color.a);
+    SDL_RenderFillRect((SDL_Renderer *)renderer, (SDL_FRect *)&rect);
+}

packages/graphics/sdl3/renderer.c

@@ -0,0 +1,39 @@
+#include "arc/graphics/renderer.h"
+#include "renderer.h"
+
+#include <SDL3/SDL.h>
+#include <stdlib.h>
+#include "arc/engine/engine.h"
+#include "arc/graphics/window.h"
+#include "arc/std/errno.h"
+
+void ARC_Renderer_CreateWithEngineData(ARC_Renderer **renderer, ARC_EngineData *data){
+    if(!data){
+        arc_errno = ARC_ERRNO_NULL;
+        ARC_DEBUG_LOG_ERROR("ARC_Renderer_CreateWithEngineData(**renderer, NULL)");
+        return;
+    }
+
+    *renderer = (ARC_Renderer *)SDL_CreateRenderer((SDL_Window *)(data->window), NULL);
+
+    if(!*renderer){
+        arc_errno = ARC_ERRNO_NULL;
+        ARC_DEBUG_LOG_ERROR_WITH_VARIABLES("SDL_CreateRenderer(%p, NULL);", data->window);
+        free(renderer);
+    }
+
+    SDL_SetRenderDrawBlendMode((SDL_Renderer *)*renderer, SDL_BLENDMODE_BLEND);
+}
+
+void ARC_Renderer_Destroy(ARC_Renderer *renderer){
+    SDL_DestroyRenderer((SDL_Renderer *) renderer);
+}
+
+void ARC_Renderer_Clear(ARC_Renderer *renderer){
+    SDL_SetRenderDrawColor((SDL_Renderer *)renderer, 0x1c, 0x2c, 0x3c, 0xff);
+    SDL_RenderClear((SDL_Renderer *)renderer);
+}
+
+void ARC_Renderer_Render(ARC_Renderer *renderer){
+    SDL_RenderPresent((SDL_Renderer *)renderer);
+}

packages/graphics/sdl3/renderer.h

@@ -0,0 +1,10 @@
+#ifndef ARC_SDL_RENDERER_H_
+#define ARC_SDL_RENDERER_H_
+
+#include "arc/graphics/renderer.h"
+#include "arc/graphics/window.h"
+#include <SDL3/SDL.h>
+
+typedef SDL_Renderer ARC_RendererType;
+
+#endif // !ARC_SDL_RENDERER_H_

packages/graphics/sdl3/sprite.c

@@ -0,0 +1,96 @@
+#include "arc/graphics/sprite.h"
+
+#include "sprite.h"
+#include "spritesheet.h"
+#include "renderer.h"
+#include "arc/math/point.h"
+#include "arc/math/rectangle.h"
+#include "arc/std/errno.h"
+#include <stdlib.h>
+
+void ARC_Sprite_Create(ARC_Sprite **sprite, ARC_Spritesheet *spritesheet, ARC_Array *frames){
+    *sprite = (ARC_Sprite *)malloc(sizeof(ARC_Sprite));
+    (*sprite)->spritesheet = spritesheet;
+    (*sprite)->frames = frames;
+    (*sprite)->frameIndex = (uint32_t *)malloc(sizeof(uint32_t));
+    *(*sprite)->frameIndex = 0;
+    (*sprite)->opacity = 255;
+}
+
+void ARC_Sprite_Destroy(ARC_Sprite *sprite){
+    free(sprite);
+}
+
+void ARC_Sprite_Copy(ARC_Sprite **newSprite, ARC_Sprite *oldSprite){
+    *newSprite = (ARC_Sprite *)malloc(sizeof(ARC_Sprite));
+    (*newSprite)->spritesheet = oldSprite->spritesheet;
+    (*newSprite)->frames = oldSprite->frames;
+    (*newSprite)->frameIndex = (uint32_t *)malloc(sizeof(uint32_t));
+    *(*newSprite)->frameIndex = *oldSprite->frameIndex;
+}
+
+void ARC_Sprite_SetOpacity(ARC_Sprite *sprite, uint8_t opacity){
+    sprite->opacity = opacity;
+}
+
+void ARC_Sprite_Render(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds){
+    //TODO: note, this is set here so not all entities in the sheet get opacity set
+    SDL_SetTextureAlphaMod((SDL_Texture *)sprite->spritesheet->texture, sprite->opacity); 
+    ARC_FRect sourceRect = ARC_Rect_CastToFRect(*(ARC_Rect *)(sprite->frames->data + *sprite->frameIndex));
+    ARC_FRect destinationRect = ARC_Rect_CastToFRect(*renderBounds);
+    SDL_RenderTexture((SDL_Renderer *)renderer, sprite->spritesheet->texture, (SDL_FRect *)&sourceRect, (SDL_FRect *)&destinationRect);
+}
+
+void ARC_Sprite_RenderFlip(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds, enum ARC_Sprite_Axis axis){
+    SDL_FlipMode flip = SDL_FLIP_NONE;
+    if(axis & ARC_SPRITE_AXIS_X){
+        flip |= SDL_FLIP_HORIZONTAL;
+    }
+
+    if(axis & ARC_SPRITE_AXIS_Y){
+        flip |= SDL_FLIP_VERTICAL;
+    }
+
+    //TODO: note, this is set here so not all entities in the sheet get opacity set
+    SDL_SetTextureAlphaMod((SDL_Texture *)sprite->spritesheet->texture, sprite->opacity);
+    ARC_FRect sourceRect = ARC_Rect_CastToFRect(*(ARC_Rect *)(sprite->frames->data + *sprite->frameIndex));
+    ARC_FRect destinationRect = ARC_Rect_CastToFRect(*renderBounds);
+    SDL_RenderTextureRotated((SDL_Renderer *)renderer, sprite->spritesheet->texture, (SDL_FRect *)&sourceRect, (SDL_FRect *)&destinationRect, 0.0, NULL, flip);
+}
+
+void ARC_Sprite_RenderRotated(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds, ARC_Point *center, double angle){
+    //TODO: note, this is set here so not all entities in the sheet get opacity set
+    SDL_SetTextureAlphaMod((SDL_Texture *)sprite->spritesheet->texture, sprite->opacity);
+    ARC_FRect sourceRect = ARC_Rect_CastToFRect(*(ARC_Rect *)(sprite->frames->data + *sprite->frameIndex));
+    ARC_FRect destinationRect = ARC_Rect_CastToFRect(*renderBounds);
+    SDL_RenderTextureRotated((SDL_Renderer *)renderer, sprite->spritesheet->texture, (SDL_FRect *)&sourceRect, (SDL_FRect *)&destinationRect, angle, NULL, SDL_FLIP_NONE);
+}
+
+void ARC_Sprite_SetFrameIndex(ARC_Sprite *sprite, uint32_t index){
+    if(sprite->frames->size <= index){
+        arc_errno = ARC_ERRNO_DATA;
+        ARC_DEBUG_LOG_ERROR_WITH_VARIABLES("in ARC_Sprite_SetFrameIndex(sprite, %d); index out of bounds", index);
+        return;
+    }
+    *sprite->frameIndex = index;
+}
+
+void ARC_Sprite_IterateFrame(ARC_Sprite *sprite){
+    ++*sprite->frameIndex;
+
+    if(*sprite->frameIndex == sprite->frames->size){
+        *sprite->frameIndex = 0;
+    }
+}
+
+uint32_t ARC_Sprite_GetFrameIndex(ARC_Sprite *sprite){
+    return *sprite->frameIndex;
+}
+
+ARC_Rect *ARC_Sprite_GetBounds(ARC_Sprite *sprite){
+    return (ARC_Rect *)sprite->frames->data + *sprite->frameIndex;
+}
+
+ARC_Array *ARC_Sprite_GetAllBounds(ARC_Sprite *sprite){
+    return sprite->frames;
+}

packages/graphics/sdl3/sprite.h

@@ -0,0 +1,14 @@
+#ifndef ARC_SDL_SPRITE_H_
+#define ARC_SDL_SPRITE_H_
+
+#include "arc/graphics/sprite.h"
+
+struct ARC_Sprite {
+    ARC_Spritesheet *spritesheet;
+    ARC_Array       *frames;
+    uint32_t        *frameIndex;
+    //TODO: temp
+    uint8_t          opacity;
+};
+
+#endif // !ARC_SDL_SPRITE_H_

packages/graphics/sdl3/spritesheet.c

@@ -0,0 +1,86 @@
+#include "arc/graphics/spritesheet.h"
+
+#include "spritesheet.h"
+#include "renderer.h"
+#include "arc/math/point.h"
+#include "arc/std/errno.h"
+#include <SDL3/SDL.h>
+#include <SDL3_image/SDL_image.h>
+#include <stdlib.h>
+
+void ARC_Spritesheet_CreateFromFile(ARC_Spritesheet **spritesheet, ARC_Renderer *renderer, ARC_String *path){
+    //TODO: allow other types of images
+
+    //get and check the SDL surface
+    SDL_Surface *surface = IMG_Load(path->data);
+    if(!surface){
+        arc_errno = ARC_ERRNO_DATA;
+        ARC_DEBUG_LOG_ERROR_WITH_VARIABLES("ARC_Spritesheet_CreateFromFile(spritesheet, renderer, path), could not read path \"%s\"", path->data);
+
+        //set the spritesheet to null and throw an error
+        *spritesheet = NULL;
+        return;
+    }
+
+    //create the place to store the spritesheet
+    *spritesheet = (ARC_Spritesheet *)malloc(sizeof(ARC_Spritesheet));
+
+    //set the texture
+    SDL_BlendMode tempMode;
+    SDL_GetSurfaceBlendMode(surface, &tempMode);
+    (*spritesheet)->texture = SDL_CreateTextureFromSurface((SDL_Renderer *)renderer, surface);
+    SDL_SetTextureBlendMode((*spritesheet)->texture, tempMode);
+
+    //set the tile size to empty
+    (*spritesheet)->size = 0;
+
+    //cleanup
+    SDL_DestroySurface(surface);
+}
+
+void ARC_Spritesheet_Destroy(ARC_Spritesheet *spritesheet){
+    SDL_DestroyTexture(spritesheet->texture);
+    free(spritesheet);
+}
+
+void ARC_Spritesheet_Render(ARC_Spritesheet *spritesheet, ARC_Renderer *renderer, ARC_FRect renderBounds){
+    SDL_RenderTexture((SDL_Renderer *)renderer, spritesheet->texture, NULL, (SDL_FRect *)&renderBounds);
+}
+
+void ARC_Spritesheet_RenderArea(ARC_Spritesheet *spritesheet, ARC_Rect sheetBounds, ARC_Renderer *renderer, ARC_FRect renderBounds){
+    ARC_FRect bounds = ARC_Rect_CastToFRect(sheetBounds);
+    SDL_RenderTexture((SDL_Renderer *)renderer, spritesheet->texture, (SDL_FRect *)&bounds, (SDL_FRect *)&renderBounds);
+}
+
+void ARC_Spritesheet_RenderTile(ARC_Spritesheet *spritesheet, ARC_Point tilePosition, ARC_Renderer *renderer, ARC_FRect renderBounds){
+    //error when size is 0
+    if(spritesheet->size == 0){
+        arc_errno = ARC_ERRNO_NULL;
+        ARC_DEBUG_LOG_ERROR("ARC_Spritesheet_RenderTile(spritesheet, tilePosition, renderer, renderBounds), could not render a tile of size 0");
+        return;
+    }
+
+    //get bounds based on the sheet size
+    ARC_FRect sheetBounds = {
+        spritesheet->size * tilePosition.x,
+        spritesheet->size * tilePosition.y,
+        spritesheet->size,
+        spritesheet->size
+    };
+
+    //render the bounds
+    SDL_RenderTexture((SDL_Renderer *)renderer, spritesheet->texture, (SDL_FRect *)&sheetBounds, (SDL_FRect *)&renderBounds);
+}
+
+ARC_Point ARC_Spritesheet_GetSize(ARC_Spritesheet *spritesheet){
+    float x = 0.0;
+    float y = 0.0;
+
+    SDL_GetTextureSize(spritesheet->texture, &x, &y);
+
+    return (ARC_Point){ x, y };
+}
+
+uint32_t ARC_Spritesheet_GetTileSize(ARC_Spritesheet *spritesheet){
+    return spritesheet->size;
+}

packages/graphics/sdl3/spritesheet.h

@@ -0,0 +1,12 @@
+#ifndef ARC_SDL_SPRITESHEET_H_
+#define ARC_SDL_SPRITESHEET_H_
+
+#include "arc/graphics/spritesheet.h"
+#include <SDL3/SDL.h>
+
+struct ARC_Spritesheet {
+    SDL_Texture *texture;
+    uint32_t     size;
+};
+
+#endif // !ARC_SDL_SPRITESHEET_H_

packages/graphics/sdl3/text.c

@@ -0,0 +1,66 @@
+#include "arc/graphics/text.h"
+
+#include "text.h"
+#include "arc/graphics/color.h"
+#include "arc/math/point.h"
+#include "arc/math/rectangle.h"
+#include "arc/std/string.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <SDL3_ttf/SDL_ttf.h>
+
+void ARC_Text_Create(ARC_Text **text, ARC_String *path, int32_t size, ARC_Color color){
+    *text = (ARC_Text *)malloc(sizeof(ARC_Text));
+    ARC_String_Copy(&(*text)->name, path);
+    (*text)->size = size;
+    (*text)->color = color;
+    (*text)->texture = NULL;
+    (*text)->bounds = (ARC_Rect){ 0, 0, 0, 0 };
+
+    //TODO: fix this
+    if(TTF_Init() == false) {
+        printf("TTF_Init: %s\n", SDL_GetError());
+        exit(2);
+    }
+}
+
+void ARC_Text_Destroy(ARC_Text *font){
+    if(font->texture != NULL){
+        SDL_DestroyTexture(font->texture);
+    }
+    ARC_String_Destroy(font->name);
+    free(font);
+}
+
+void ARC_Text_SetString(ARC_Text *text, ARC_Renderer *renderer, ARC_String *string){
+    TTF_Font *ttfont = TTF_OpenFont(text->name->data, text->size);
+    SDL_Color textColor = (SDL_Color){ text->color.r, text->color.g, text->color.b, text->color.a };
+
+    SDL_Surface *surface = TTF_RenderText_Blended(ttfont, string->data, 0, textColor);
+
+    text->bounds.w = surface->w;
+    text->bounds.h = surface->h;
+
+    if(text->texture){
+        SDL_DestroyTexture(text->texture);
+    }
+    text->texture = SDL_CreateTextureFromSurface((SDL_Renderer *)renderer, surface);
+
+    SDL_DestroySurface(surface);
+    TTF_CloseFont(ttfont);
+}
+
+void ARC_Text_Render(ARC_Text *text, ARC_Renderer *renderer){
+    if(text->texture == NULL){
+        return;
+    }
+
+    SDL_FRect bounds = (SDL_FRect){ text->bounds.x, text->bounds.y, text->bounds.w, text->bounds.h };
+    SDL_RenderTexture((SDL_Renderer *)renderer, text->texture, NULL, &bounds);
+}
+
+void ARC_Text_SetPos(ARC_Text *text, ARC_Point pos){
+    text->bounds.x = pos.x;
+    text->bounds.y = pos.y;
+}

packages/graphics/sdl3/text.h

@@ -0,0 +1,20 @@
+#ifndef ARC_SDL_TEXT_H_
+#define ARC_SDL_TEXT_H_
+
+#include "arc/std/string.h"
+#include "arc/graphics/color.h"
+#include "arc/math/rectangle.h"
+
+#include <SDL3/SDL.h>
+
+typedef struct ARC_Text {
+    ARC_String *name;
+    int32_t size;
+
+    ARC_Color color;
+
+    SDL_Texture *texture;
+    ARC_Rect bounds;
+} ARC_Text;
+
+#endif // !ARC_SDL_TEXT_H_

packages/graphics/sdl3/view.c

@@ -0,0 +1,35 @@
+#include "arc/graphics/view.h"
+
+#include "arc/std/errno.h"
+#include <SDL.h>
+#include <stdlib.h>
+
+void ARC_View_Create(ARC_View **view, ARC_Renderer *renderer, ARC_Rect bounds){
+    *view = (ARC_View *)malloc(sizeof(ARC_View));
+    (*view)->renderer = renderer;
+    (*view)->bounds = bounds;
+}
+
+void ARC_View_Destroy(ARC_View *view){
+    free(view);
+}
+
+void ARC_View_Render(ARC_View *view, ARC_View_RenderFn renderFn, void *data){
+    int err = SDL_RenderSetViewport((SDL_Renderer *)view->renderer, (const SDL_Rect *)&(view->bounds));
+    if(err){
+        ARC_DEBUG_LOG(ARC_ERRNO_DATA, "in src/graphics/sdl/view.c ARC_View_Render(view, renderFn), SDL_RenderSetViewport(...) returned: %d", err);
+        return;
+    }
+
+    renderFn(data);
+
+    err = SDL_RenderSetViewport((SDL_Renderer *)view->renderer, NULL);
+    if(err){
+        ARC_DEBUG_LOG(ARC_ERRNO_DATA, "in src/graphics/sdl/view.c ARC_View_Render(view, NULL), SDL_RenderSetViewport(...) returned: %d", err);
+        return;
+    }
+}
+
+ARC_Rect ARC_View_GetBounds(ARC_View *view){
+    return view->bounds;
+}

packages/graphics/sdl3/window.c

@@ -0,0 +1,26 @@
+#include "arc/graphics/window.h"
+
+#include "window.h"
+#include "arc/std/errno.h"
+#include <SDL3/SDL.h>
+
+void ARC_Window_Create(ARC_Window **window, ARC_WindowInfo *info){
+    if(!info){
+        arc_errno = ARC_ERRNO_NULL;
+        ARC_DEBUG_LOG_ERROR("ARC_Window_Create(**window, NULL)");
+        return;
+    }
+
+    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);
+
+    *window = (ARC_Window *)SDL_CreateWindow((const char *)info->title, info->w, info->h, 0);
+
+    if(window == NULL){
+        arc_errno = ARC_ERRNO_NULL;
+        ARC_DEBUG_LOG_ERROR_WITH_VARIABLES("SDL_CreateWindow(%s, %d, %d, %x);", info->title, info->w, info->h, 0);
+    }
+}
+
+void ARC_Window_Destroy(ARC_Window *window){
+    SDL_DestroyWindow((SDL_Window *) window);
+}

packages/graphics/sdl3/window.h

@@ -0,0 +1,9 @@
+#ifndef ARC_SDL_WINDOW_H_
+#define ARC_SDL_WINDOW_H_
+
+#include "arc/graphics/window.h"
+#include <SDL3/SDL.h>
+
+typedef SDL_Window ARC_WindowType;
+
+#endif // !ARC_SDL_WINDOW_H_