opengl added to engine

CMakeLists.txt

@@ -11,7 +11,10 @@ endfunction()
 
 option(ARCHEUS_STD_DEBUG          "Build in debug mode"            ON)
 option(ARCHEUS_STD_DEFAULT_CONFIG "Build with default config keys" ON)
-option(ARCHEUS_STD_SDL            "Build with SDL"                 ON)
+option(ARCHEUS_STD_SDL            "Build with SDL"                 OFF)
+option(ARCHEUS_STD_GLFW           "Build with GLFW window"         OFF)
+option(ARCHEUS_STD_GLEW           "Build with GLEW"                OFF)
+option(ARCHEUS_STD_OPENGL         "Build with OpenGL"              OFF)
 
 set(ARCHEUS_STD_FLAGS "")
 
@@ -30,6 +33,18 @@ if(ARCHEUS_STD_SDL)
     string(APPEND ARCHEUS_STD_FLAGS "-DARC_SDL ")
 endif()
 
+if(ARCHEUS_STD_GLFW)
+    string(APPEND ARCHEUS_STD_FLAGS "-DARC_GLFW ")
+endif()
+
+if(ARCHEUS_STD_GLEW)
+    string(APPEND ARCHEUS_STD_FLAGS "-DARC_GLEW ")
+endif()
+
+if(ARCHEUS_STD_OPENGL)
+    string(APPEND ARCHEUS_STD_FLAGS "-DARC_OPENGL")
+endif()
+
 set(CMAKE_C_FLAGS ${ARCHEUS_STD_FLAGS})
 
 set(ARCHEUS_STD_SOURCES
@@ -63,21 +78,53 @@ set(ARCHEUS_STD_SDL_SOURCES
     src/graphics/sdl/window.c
 )
 
+set(ARCHEUS_STD_OPENGL_SOURCES
+    src/graphics/opengl/config.c
+    src/graphics/opengl/line.c
+    src/graphics/opengl/rectangle.c
+    src/graphics/opengl/renderer.c
+    src/graphics/opengl/sprite.c
+    src/graphics/opengl/spritesheet.c
+    src/graphics/opengl/window.c
+)
+
+set(ARCHEUS_STD_GLFW_SOURCES
+    src/input/glfw/keyboard.c
+    src/input/glfw/mouse.c
+)
+
+if(ARCHEUS_STD_SDL)
+    list(APPEND ARCHEUS_STD_SOURCES ${ARCHEUS_STD_SDL_SOURCES})
+endif()
+
+if(ARCHEUS_STD_OPENGL)
+    list(APPEND ARCHEUS_STD_SOURCES ${ARCHEUS_STD_OPENGL_SOURCES})
+endif()
+
+if(ARCHEUS_STD_GLFW)
+    list(APPEND ARCHEUS_STD_SOURCES ${ARCHEUS_STD_GLFW_SOURCES})
+endif()
+
 add_library(archeus_std SHARED
     ${ARCHEUS_STD_SOURCES}
-    ${ARCHEUS_STD_SDL_SOURCES}
 )
 
-# target_sources(archeus_std PRIVATE
+if(ARCHEUS_STD_SDL)
-    # ${ARCHEUS_STD_SOURCES}
+    target_include_directories(archeus_std PRIVATE
-    # ${ARCHEUS_STD_SDL_SOURCES}
+        include
-# )
+        PUBLIC ${SDL2_INCLUDE_DIRS}
+        PUBLIC ${SDL2IMAGE_INCLUDE_DIRS}
+    )
+endif()
 
-target_include_directories(archeus_std PRIVATE
+if(ARCHEUS_STD_OPENGL)
-    include
+    target_include_directories(archeus_std PRIVATE
-    PUBLIC ${SDL2_INCLUDE_DIRS}
+        include
-    PUBLIC ${SDL2IMAGE_INCLUDE_DIRS}
+        GL
-)
+        glfw
+        GLEW
+    )
+endif()
 
 install(TARGETS archeus_std EXPORT archeus_std_Exports
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}

include/arc/graphics/opengl/renderer.h

@@ -0,0 +1,36 @@
+#ifndef ARC_OPENGL_RENDERER_H_
+#define ARC_OPENGL_RENDERER_H_
+
+#ifdef ARC_OPENGL
+
+#ifdef ARC_GLEW
+#define GLEW_STATIC
+#include <GL/glew.h>
+#endif // !ARC_GLEW
+
+#ifdef ARC_GLFW
+#include <GLFW/glfw3.h>
+#endif
+
+#include "arc/graphics/renderer.h"
+#include "arc/graphics/window.h"
+
+#ifdef ARC_GLFW
+typedef struct ARC_RendererType {
+    GLFWwindow *window;
+} ARC_RendererType;
+
+/**
+ * @brief struct for info needed to create opengl renderer
+ *
+ * @note this is what needs to be passed into the data parameter for ARC_Renderer_Create
+ */
+struct ARC_RenderInfo {
+    GLFWwindow *window;
+};
+
+#endif // !ARC_GLFW
+
+#endif // !ARC_OPENGL
+
+#endif // !ARC_OPENGL_RENDERER_H_

include/arc/graphics/opengl/sprite.h

@@ -0,0 +1,13 @@
+#ifndef ARC_OPENGL_SPRITE_H_
+#define ARC_OPENGL_SPRITE_H_
+
+#ifdef ARC_OPENGL
+
+#include "arc/graphics/sprite.h"
+
+struct ARC_Sprite {
+};
+
+#endif // !ARC_OPENGL
+
+#endif // !ARC_OPENGL_SPRITE_H_

include/arc/graphics/opengl/spritesheet.h

@@ -0,0 +1,13 @@
+#ifndef ARC_OPENGL_SPRITESHEET_H_
+#define ARC_OPENGL_SPRITESHEET_H_
+
+#ifdef ARC_OPENGL
+
+#include "arc/graphics/spritesheet.h"
+
+struct ARC_Spritesheet {
+};
+
+#endif // !ARC_OPENGL
+
+#endif // !ARC_OPENGL_SPRITESHEET_H_

include/arc/graphics/opengl/window.h

@@ -0,0 +1,29 @@
+#ifndef ARC_OPENGL_WINDOW_H_
+#define ARC_OPENGL_WINDOW_H_
+
+#ifdef ARC_GLFW
+
+#ifdef ARC_GLEW
+#define GLEW_STATIC
+#include <GL/glew.h>
+#endif // !ARC_GLEW
+
+#include "arc/graphics/window.h"
+#include <GLFW/glfw3.h>
+
+typedef GLFWwindow ARC_WindowType;
+
+/**
+ * @brief struct for info needed to create a GLFWwindow
+ *
+ * @note this is what needs to be passed into the data parameter for ARC_Window_Create
+ */
+struct ARC_WindowInfo {
+    char   *title;
+    int     w;
+    int     h;
+};
+
+#endif // !ARC_GLFW
+
+#endif // !ARC_GLFW_WINDOW_H_

include/arc/graphics/renderer.h

@@ -5,7 +5,10 @@
 extern "C" {
 #endif
 
-typedef struct ARC_Renderer ARC_Renderer;
+/**
+ * @note ARC_RendererType is determined by which window library you are using
+*/
+typedef struct ARC_RendererType ARC_Renderer;
 
 typedef struct ARC_RenderInfo ARC_RenderInfo;
 

include/arc/graphics/sdl/renderer.h

@@ -7,10 +7,7 @@
 #include "arc/graphics/renderer.h"
 #include "arc/graphics/window.h"
 
-// Temp till I figure out a better solution
+typedef SDL_Renderer ARC_RendererType;
-struct ARC_Renderer {
-    SDL_Renderer *renderer;
-};
 
 /**
  * @brief struct for info needed to create SDL_Renderer
@@ -24,6 +21,6 @@ struct ARC_RenderInfo {
     Uint32      flags;
 };
 
-#endif // ARC_SDL
+#endif // !ARC_SDL
 
-#endif // ARC_SDL_RENDERER_H_
+#endif // !ARC_SDL_RENDERER_H_

include/arc/graphics/sdl/sprite.h

@@ -12,6 +12,6 @@ struct ARC_Sprite {
     uint32_t        *frameIndex;
 };
 
-#endif // ARC_SDL
+#endif // !ARC_SDL
 
-#endif // ARC_SDL_SPRITE_H_
+#endif // !ARC_SDL_SPRITE_H_

include/arc/graphics/sdl/spritesheet.h

@@ -11,6 +11,6 @@ struct ARC_Spritesheet {
     uint32_t    *size;
 };
 
-#endif // ARC_SDL
+#endif // !ARC_SDL
 
-#endif // ARC_SDL_SPRITESHEET_H_
+#endif // !ARC_SDL_SPRITESHEET_H_

include/arc/graphics/sdl/window.h

@@ -6,10 +6,7 @@
 #include <SDL.h>
 #include "arc/graphics/window.h"
 
-// Temp till I figure out a better solution
+typedef SDL_Window ARC_WindowType;
-struct ARC_Window {
-    SDL_Window *window;
-};
 
 /**
  * @brief struct for info needed to create SDL_Window
@@ -25,6 +22,6 @@ struct ARC_WindowInfo {
     Uint32  flags;
 };
 
-#endif // ARC_SDL
+#endif // !ARC_SDL
 
-#endif // ARC_SDL_WINDOW_H_
+#endif // !ARC_SDL_WINDOW_H_

include/arc/graphics/window.h

@@ -5,7 +5,10 @@
 extern "C" {
 #endif
 
-typedef struct ARC_Window ARC_Window;
+/**
+ * @note ARC_WindowType is determined by which window library you are using
+*/
+typedef struct ARC_WindowType ARC_Window;
 
 typedef struct ARC_WindowInfo ARC_WindowInfo;
 

include/arc/input/glfw/keyboard.h

@@ -0,0 +1,21 @@
+#ifndef ARC_GLFW_KEYBOARD_H_
+#define ARC_GLFW_KEYBOARD_H_
+
+#ifdef ARC_GLFW
+#include <GLFW/glfw3.h>
+#include "arc/input/keyboard.h"
+
+struct ARC_Keyboard {
+    GLFWwindow *window;
+
+    ARC_KeyboardState *keys;
+    ARC_KeyboardState *released;
+};
+
+struct ARC_KeyboardInfo {
+    GLFWwindow *window;
+};
+
+#endif // !ARC_GLFW
+
+#endif // !ARC_GLFW_KEYBOARD_H_

include/arc/input/glfw/mouse.h

@@ -0,0 +1,25 @@
+#ifndef ARC_GLFW_MOUSE_H_
+#define ARC_GLFW_MOUSE_H_
+
+#ifdef ARC_GLFW
+#include <GLFW/glfw3.h>
+#include "arc/input/mouse.h"
+#include "arc/math/point.h"
+
+struct ARC_Mouse {
+    GLFWwindow *window;
+
+    ARC_Point *coords;
+    int32_t   *scrollY;
+
+    ARC_MouseState *buttons;
+    uint8_t *buttonsReleased;
+};
+
+struct ARC_MouseInfo {
+    GLFWwindow *window;
+};
+
+#endif // !ARC_GLFW
+
+#endif // !ARC_GLFW_MOUSE_H_

src/engine/engine.c

@@ -1,5 +1,4 @@
 #include "arc/engine/engine.h"
-#include <SDL_video.h>
 #include <stdlib.h>
 #include "arc/engine/state.h"
 #include "arc/graphics/window.h"
@@ -12,11 +11,19 @@
 //NOTE: some of this file is temporary, mostly to get smthn running so I can test out different ideas
 #ifdef ARC_SDL
 #include <SDL.h>
+#include <SDL_video.h>
 #include "arc/graphics/sdl/window.h"
 #include "arc/graphics/sdl/renderer.h"
 #include "arc/input/sdl/mouse.h"
 #include "arc/input/sdl/keyboard.h"
-#endif // ARC_SDL
+#elif ARC_OPENGL
+#include "arc/graphics/opengl/window.h"
+#include "arc/graphics/opengl/renderer.h"
+#ifdef ARC_GLFW
+#include "arc/input/glfw/mouse.h"
+#include "arc/input/glfw/keyboard.h"
+#endif // ARC_GLFW
+#endif
 
 void ARC_EngineData_Create(ARC_EngineData **data, ARC_Handler_CleanDataFn cleanfn, ARC_Point windowSize){
     *data = (ARC_EngineData *)malloc(sizeof(ARC_EngineData));
@@ -35,6 +42,8 @@ void ARC_EngineData_Create(ARC_EngineData **data, ARC_Handler_CleanDataFn cleanf
 
 #ifdef ARC_SDL
     windowInfo = (ARC_WindowInfo){ "title", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, (*data)->windowSize.x, (*data)->windowSize.y, 0 };
+#elif ARC_GLFW
+    windowInfo = (ARC_WindowInfo){ "title", (*data)->windowSize.x, (*data)->windowSize.y };
 #endif // ARC_SDL
 
     ARC_Window_Create(&((*data)->window), &windowInfo);
@@ -44,7 +53,9 @@ void ARC_EngineData_Create(ARC_EngineData **data, ARC_Handler_CleanDataFn cleanf
     }
 
 #ifdef ARC_SDL
-    renderInfo = (ARC_RenderInfo){ (SDL_Window *)(*data)->window->window, -1, SDL_RENDERER_ACCELERATED };
+    renderInfo = (ARC_RenderInfo){ (SDL_Window *)(*data)->window, -1, SDL_RENDERER_ACCELERATED };
+#elif ARC_GLFW
+    renderInfo = (ARC_RenderInfo){ (GLFWwindow *)(*data)->window };
 #endif // ARC_SDL
 
     ARC_Renderer_Create(&((*data)->renderer), &renderInfo);
@@ -57,10 +68,12 @@ void ARC_EngineData_Create(ARC_EngineData **data, ARC_Handler_CleanDataFn cleanf
     SDL_Event *event = (SDL_Event *)malloc(sizeof(SDL_Event));
     mouseInfo    = (ARC_MouseInfo   ){ event };
     keyboardInfo = (ARC_KeyboardInfo){ event };
+#elif ARC_GLFW
+    mouseInfo    = (ARC_MouseInfo   ){ (GLFWwindow *)(*data)->window };
+    keyboardInfo = (ARC_KeyboardInfo){ (GLFWwindow *)(*data)->window };
 #endif // ARC_SDL
 
-    ARC_Mouse_Create(&((*data)->mouse), &mouseInfo);
+    ARC_Mouse_Create   (&((*data)->mouse)   , &mouseInfo   );
-
     ARC_Keyboard_Create(&((*data)->keyboard), &keyboardInfo);
 }
 
@@ -83,11 +96,10 @@ void ARC_Engine_Run(ARC_EngineData *data){
 
 #ifdef ARC_SDL
     SDL_Event *event = data->mouse->event;
+    double lastTime = 0, currentTime;
+    data->dt = 0;
 #endif // ARC_SDL
 
-    double lastTime = 0, currentTime;
-
-    data->dt = 0;
     data->running = 0;
 
     while(!data->running){
@@ -97,8 +109,10 @@ void ARC_Engine_Run(ARC_EngineData *data){
         lastTime = currentTime;
 
         SDL_PollEvent(data->mouse->event);
-        if(event->type == SDL_QUIT){ return; }
+        if(event->type == SDL_QUIT){ data->running = 1; }
-        if(event->type == SDL_KEYDOWN && event->key.keysym.sym == SDLK_ESCAPE){ return; }
+#elif ARC_GLFW
+        glfwPollEvents();
+        data->running = glfwWindowShouldClose((GLFWwindow *)data->window);
 #endif // ARC_SDL
 
         ARC_Mouse_Update(data->mouse);

src/graphics/opengl/config.c

@@ -0,0 +1,14 @@
+#ifdef ARC_OPENGL
+
+#include <stdio.h>
+#include "arc/std/config.h"
+#include "arc/std/string.h"
+#include "arc/std/errno.h"
+
+#include "arc/graphics/opengl/renderer.h"
+
+
+void ARC_GraphicsConfig_Init(ARC_Config *config, ARC_Renderer *renderer){
+}
+
+#endif // ARC_OPENGL

src/graphics/opengl/line.c

@@ -0,0 +1,8 @@
+#ifdef ARC_OPENGL
+#include "arc/graphics/line.h"
+#include <stdlib.h>
+
+void ARC_Line_Render(int32_t *x1, int32_t *y1, int32_t *x2, int32_t *y2, ARC_Renderer *renderer, ARC_Color *color){
+}
+
+#endif // ARC_OPENGL

src/graphics/opengl/rectangle.c

@@ -0,0 +1,11 @@
+#ifdef ARC_OPENGL
+#include "arc/graphics/rectangle.h"
+#include <stdlib.h>
+
+void ARC_Rect_Render(ARC_Rect *rect, ARC_Renderer *renderer, ARC_Color *color){
+}
+
+void ARC_Rect_RenderFill(ARC_Rect *rect, ARC_Renderer *renderer, ARC_Color *color){
+}
+
+#endif // ARC_OPENGL

src/graphics/opengl/renderer.c

@@ -0,0 +1,55 @@
+#ifdef ARC_OPENGL
+#include "arc/graphics/renderer.h"
+#include "arc/graphics/opengl/renderer.h"
+
+#ifdef ARC_GLEW
+#define GLEW_STATIC
+#include <GL/glew.h>
+#endif // ARC_GLEW
+
+#ifdef ARC_GLFW
+#include <GLFW/glfw3.h>
+#endif
+
+#include "arc/graphics/window.h"
+#include "arc/std/errno.h"
+#include <stdlib.h>
+
+void ARC_Renderer_Create(ARC_Renderer **renderer, ARC_RenderInfo *info){
+    if(!info){
+        arc_errno = ARC_ERRNO_NULL;
+        ARC_DEBUG_ERR("ARC_Renderer_Create(**renderer, NULL)");
+        return;
+    }
+
+#ifdef ARC_GLFW
+    *renderer = (ARC_Renderer *)malloc(sizeof(ARC_Renderer));
+    (*renderer)->window = info->window;
+
+
+    glewExperimental = GL_TRUE;
+    if(glewInit() != GLEW_OK){
+        ARC_DEBUG_ERR("ARC_Renderer_Create(**renderer, info), GLEW failed to init");
+        glfwTerminate();
+        arc_errno = ARC_ERRNO_INIT;
+    }
+#endif // ARC_GLEW
+
+    glClearColor(0.23f, 0.38f, 0.47f, 1.0f);
+}
+
+void ARC_Renderer_Destroy(ARC_Renderer *renderer){
+    free(renderer);
+}
+
+void ARC_Renderer_Clear(ARC_Renderer *renderer){
+    glClear(GL_COLOR_BUFFER_BIT);
+}
+
+void ARC_Renderer_Render(ARC_Renderer *renderer){
+#ifdef ARC_GLFW
+    glfwSwapBuffers(renderer->window);
+#endif // ARC_GLEW
+}
+
+#endif //ARC_SDL

src/graphics/opengl/sprite.c

@@ -0,0 +1,29 @@
+#ifdef ARC_OPENGL
+#include "arc/graphics/sprite.h"
+#include "arc/math/point.h"
+#include "arc/math/rectangle.h"
+#include <stdlib.h>
+
+void ARC_Sprite_Create(ARC_Sprite **sprite, ARC_Spritesheet *spritesheet, ARC_Array *frames){
+}
+
+void ARC_Sprite_Destroy(ARC_Sprite *sprite){
+}
+
+void ARC_Sprite_Copy(ARC_Sprite **newSprite, ARC_Sprite *oldSprite){
+}
+
+void ARC_Sprite_Render(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds){
+}
+
+void ARC_Sprite_RenderRotated(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds, ARC_Point *center, double angle){
+}
+
+void ARC_Sprite_IterateFrame(ARC_Sprite *sprite){
+}
+
+ARC_Rect *ARC_Sprite_GetBounds(ARC_Sprite *sprite){
+    return NULL;
+}
+
+#endif // ARC_OPENGL

src/graphics/opengl/spritesheet.c

@@ -0,0 +1,17 @@
+#ifdef ARC_OPENGL
+#include "arc/graphics/spritesheet.h"
+#include "arc/math/point.h"
+#include <stdlib.h>
+
+void ARC_Spritesheet_RenderArea(ARC_Spritesheet *spritesheet, ARC_Rect *sheetBounds, ARC_Renderer *renderer, ARC_Rect *renderBounds){
+}
+
+ARC_Point ARC_Spritesheet_GetSize(ARC_Spritesheet *spritesheet){
+    return (ARC_Point){0, 0};
+}
+
+uint32_t *ARC_Spritesheet_GetTileSize(ARC_Spritesheet *spritesheet){
+    return NULL;
+}
+
+#endif // ARC_OPENGL

src/graphics/opengl/window.c

@@ -0,0 +1,36 @@
+#ifdef ARC_GLFW
+#include "arc/graphics/window.h"
+#include "arc/graphics/opengl/window.h"
+
+#include "arc/std/errno.h"
+#include <GLFW/glfw3.h>
+#include <stdio.h>
+
+void framebufferSizeCallback(GLFWwindow *window, int width, int height){
+    glViewport(0, 0, width, height);
+}
+
+void ARC_Window_Create(ARC_Window **window, ARC_WindowInfo *info){
+    glfwInit();
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+    glfwWindowHint(GLFW_FLOATING, GLFW_TRUE);
+
+    *window = (ARC_Window *) glfwCreateWindow(info->w, info->h, "learnopengl window", NULL, NULL);
+    if(*window == NULL){
+        printf("Failed to create GLFW window\n");
+        glfwTerminate();
+        arc_errno = ARC_ERRNO_NULL;
+    }
+
+    glfwMakeContextCurrent((GLFWwindow *)*window);
+    glViewport(0, 0, info->w, info->h);
+    glfwSetFramebufferSizeCallback((GLFWwindow *)*window, framebufferSizeCallback);
+}
+
+void ARC_Window_Destroy(ARC_Window *window){
+    glfwTerminate();
+}
+
+#endif //ARC_GLFW

src/graphics/sdl/config.c

@@ -34,7 +34,7 @@ void ARC_Spritesheet_Delete(ARC_Config *config, ARC_String *string, void *value)
 void ARC_Sprite_Delete     (ARC_Config *config, ARC_String *string, void *value);
 
 void ARC_GraphicsConfig_Init(ARC_Config *config, ARC_Renderer *renderer){
-    global_renderer = renderer->renderer;
+    global_renderer = (SDL_Renderer *)renderer;
     ARC_Config_AddKeyCString(config, (char *)"ARC_Point"      ,  9, ARC_Point_Read      , ARC_Point_Delete      );
     ARC_Config_AddKeyCString(config, (char *)"ARC_Rect"       ,  8, ARC_Rect_Read       , ARC_Rect_Delete       );
     ARC_Config_AddKeyCString(config, (char *)"ARC_Rect[]"     , 10, ARC_RectArray_Read  , ARC_RectArray_Delete  );

src/graphics/sdl/line.c

@@ -1,11 +1,11 @@
-#include "arc/graphics/line.h"
 #ifdef ARC_SDL
+#include "arc/graphics/line.h"
 #include "arc/graphics/sdl/renderer.h"
 #include <stdlib.h>
 
 void ARC_Line_Render(int32_t *x1, int32_t *y1, int32_t *x2, int32_t *y2, ARC_Renderer *renderer, ARC_Color *color){
-    SDL_SetRenderDrawColor(renderer->renderer, color->r, color->g, color->b, color->a);
+    SDL_SetRenderDrawColor((SDL_Renderer *)renderer, color->r, color->g, color->b, color->a);
-    SDL_RenderDrawLine(renderer->renderer, *x1, *y1, *x2, *y2);
+    SDL_RenderDrawLine((SDL_Renderer *)renderer, *x1, *y1, *x2, *y2);
 }
 
 #endif // ARC_SDL

src/graphics/sdl/rectangle.c

@@ -1,16 +1,16 @@
-#include "arc/graphics/rectangle.h"
 #ifdef ARC_SDL
+#include "arc/graphics/rectangle.h"
 #include "arc/graphics/sdl/renderer.h"
 #include <stdlib.h>
 
 void ARC_Rect_Render(ARC_Rect *rect, ARC_Renderer *renderer, ARC_Color *color){
-    SDL_SetRenderDrawColor(renderer->renderer, color->r, color->g, color->b, color->a);
+    SDL_SetRenderDrawColor((SDL_Renderer *)renderer, color->r, color->g, color->b, color->a);
-    SDL_RenderDrawRect(renderer->renderer, (SDL_Rect *) rect);
+    SDL_RenderDrawRect((SDL_Renderer *)renderer, (SDL_Rect *) rect);
 }
 
 void ARC_Rect_RenderFill(ARC_Rect *rect, ARC_Renderer *renderer, ARC_Color *color){
-    SDL_SetRenderDrawColor(renderer->renderer, color->r, color->g, color->b, color->a);
+    SDL_SetRenderDrawColor((SDL_Renderer *)renderer, color->r, color->g, color->b, color->a);
-    SDL_RenderFillRect(renderer->renderer, (SDL_Rect *) rect);
+    SDL_RenderFillRect((SDL_Renderer *)renderer, (SDL_Rect *) rect);
 }
 
 #endif // ARC_SDL

src/graphics/sdl/renderer.c

@@ -14,10 +14,9 @@ void ARC_Renderer_Create(ARC_Renderer **renderer, ARC_RenderInfo *info){
         return;
     }
 
-    *renderer = (ARC_Renderer *)malloc(sizeof(ARC_Renderer));
+    *renderer = (ARC_Renderer *)SDL_CreateRenderer((SDL_Window *)info->window, info->index, info->flags);
-    (*renderer)->renderer = SDL_CreateRenderer((SDL_Window *)info->window, info->index, info->flags);
 
-    if(!(*renderer)->renderer){
+    if(!*renderer){
         arc_errno = ARC_ERRNO_NULL;
         ARC_DEBUG_LOG(arc_errno, "SDL_CreateRenderer(%p, %d, %u);", info->window, info->index, info->flags);
         free(renderer);
@@ -25,17 +24,16 @@ void ARC_Renderer_Create(ARC_Renderer **renderer, ARC_RenderInfo *info){
 }
 
 void ARC_Renderer_Destroy(ARC_Renderer *renderer){
-    SDL_DestroyRenderer((SDL_Renderer *) renderer->renderer);
+    SDL_DestroyRenderer((SDL_Renderer *) renderer);
-    free(renderer);
 }
 
 void ARC_Renderer_Clear(ARC_Renderer *renderer){
-    SDL_SetRenderDrawColor((SDL_Renderer *)renderer->renderer, 0x1c, 0x2c, 0x3c, 0x00);
+    SDL_SetRenderDrawColor((SDL_Renderer *)renderer, 0x1c, 0x2c, 0x3c, 0x00);
-    SDL_RenderClear((SDL_Renderer *)renderer->renderer);
+    SDL_RenderClear((SDL_Renderer *)renderer);
 }
 
 void ARC_Renderer_Render(ARC_Renderer *renderer){
-    SDL_RenderPresent((SDL_Renderer *)renderer->renderer);
+    SDL_RenderPresent((SDL_Renderer *)renderer);
 }
 
 #endif //ARC_SDL

src/graphics/sdl/sprite.c

@@ -1,5 +1,5 @@
-#include "arc/graphics/sprite.h"
 #ifdef ARC_SDL
+#include "arc/graphics/sprite.h"
 #include "arc/graphics/sdl/sprite.h"
 #include "arc/graphics/sdl/spritesheet.h"
 #include "arc/graphics/sdl/renderer.h"
@@ -28,11 +28,11 @@ void ARC_Sprite_Copy(ARC_Sprite **newSprite, ARC_Sprite *oldSprite){
 }
 
 void ARC_Sprite_Render(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds){
-    SDL_RenderCopy(renderer->renderer, sprite->spritesheet->texture, (SDL_Rect *)sprite->frames->data + *sprite->frameIndex, (SDL_Rect *)renderBounds);
+    SDL_RenderCopy((SDL_Renderer *)renderer, sprite->spritesheet->texture, (SDL_Rect *)sprite->frames->data + *sprite->frameIndex, (SDL_Rect *)renderBounds);
 }
 
 void ARC_Sprite_RenderRotated(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds, ARC_Point *center, double angle){
-    SDL_RenderCopyEx(renderer->renderer, sprite->spritesheet->texture, (SDL_Rect *)sprite->frames->data + *sprite->frameIndex, (SDL_Rect *)renderBounds, angle, (SDL_Point *)center, SDL_FLIP_NONE);
+    SDL_RenderCopyEx((SDL_Renderer *)renderer, sprite->spritesheet->texture, (SDL_Rect *)sprite->frames->data + *sprite->frameIndex, (SDL_Rect *)renderBounds, angle, (SDL_Point *)center, SDL_FLIP_NONE);
 }
 
 void ARC_Sprite_IterateFrame(ARC_Sprite *sprite){

src/graphics/sdl/spritesheet.c

@@ -1,3 +1,4 @@
+#ifdef ARC_SDL
 #include "arc/graphics/spritesheet.h"
 #include "arc/graphics/sdl/spritesheet.h"
 #include "arc/graphics/sdl/renderer.h"
@@ -5,7 +6,7 @@
 #include <SDL_render.h>
 
 void ARC_Spritesheet_RenderArea(ARC_Spritesheet *spritesheet, ARC_Rect *sheetBounds, ARC_Renderer *renderer, ARC_Rect *renderBounds){
-    SDL_RenderCopy(renderer->renderer, spritesheet->texture, (SDL_Rect *)sheetBounds, (SDL_Rect *)renderBounds);
+    SDL_RenderCopy((SDL_Renderer *)renderer, spritesheet->texture, (SDL_Rect *)sheetBounds, (SDL_Rect *)renderBounds);
 }
 
 ARC_Point ARC_Spritesheet_GetSize(ARC_Spritesheet *spritesheet){
@@ -17,3 +18,4 @@ ARC_Point ARC_Spritesheet_GetSize(ARC_Spritesheet *spritesheet){
 uint32_t *ARC_Spritesheet_GetTileSize(ARC_Spritesheet *spritesheet){
     return spritesheet->size;
 }
+#endif //ARC_SDL

src/graphics/sdl/window.c

@@ -18,10 +18,9 @@ void ARC_Window_Create(ARC_Window **window, ARC_WindowInfo *info){
         return;
     }
 
-    *window = (ARC_Window *)malloc(sizeof(ARC_Window));
+    *window = (ARC_Window *)SDL_CreateWindow((const char *)info->title, info->x, info->y, info->w, info->h, info->flags);
-    (*window)->window = SDL_CreateWindow((const char *)info->title, info->x, info->y, info->w, info->h, info->flags);
 
-    if(!(*window)->window){
+    if(!*window){
         arc_errno = ARC_ERRNO_NULL;
         ARC_DEBUG_LOG(arc_errno, "SDL_CreateWindow(%s, %d, %d, %d, %d, %x);", info->title, info->x, info->y, info->w, info->h, info->flags);
         free(window);
@@ -29,8 +28,7 @@ void ARC_Window_Create(ARC_Window **window, ARC_WindowInfo *info){
 }
 
 void ARC_Window_Destroy(ARC_Window *window){
-    SDL_DestroyWindow((SDL_Window *) window->window);
+    SDL_DestroyWindow((SDL_Window *) window);
-    free(window);
 }
 
 #endif //ARC_SDL

src/input/glfw/keyboard.c

@@ -0,0 +1,22 @@
+#ifdef ARC_GLFW
+#include "arc/input/glfw/keyboard.h"
+#include "arc/input/keyboard.h"
+#include "arc/math/point.h"
+#include "arc/std/errno.h"
+#include <stdlib.h>
+#include <stdint.h>
+
+void ARC_Keyboard_Create(ARC_Keyboard **keyboard, ARC_KeyboardInfo *info){
+}
+
+void ARC_Keyboard_Destroy(ARC_Keyboard *keyboard){
+}
+
+void ARC_Keyboard_Update(ARC_Keyboard *keyboard){
+}
+
+ARC_KeyboardState ARC_Keyboard_GetState(ARC_Keyboard *keyboard, uint8_t key){
+    return ARC_KEY_NONE;
+}
+
+#endif // ARC_GLFW

src/input/glfw/mouse.c

@@ -0,0 +1,33 @@
+#ifdef ARC_GLFW
+#include "arc/input/glfw/mouse.h"
+#include "arc/input/mouse.h"
+#include "arc/math/point.h"
+#include "arc/std/errno.h"
+#include <stdlib.h>
+#include <stdint.h>
+
+void ARC_Mouse_Create(ARC_Mouse **mouse, ARC_MouseInfo *info){
+}
+
+void ARC_Mouse_Destroy(ARC_Mouse *mouse){
+}
+
+void ARC_Mouse_UpdateButton(ARC_Mouse *mouse, uint8_t button, uint32_t *buttons, uint32_t mask){
+}
+
+void ARC_Mouse_Update(ARC_Mouse *mouse){
+}
+
+ARC_Point *ARC_Mouse_GetCoords(ARC_Mouse *mouse){
+    return mouse->coords;
+}
+
+ARC_MouseState ARC_Mouse_GetState(ARC_Mouse *mouse, ARC_MouseButton button){
+    return mouse->buttons[button];
+}
+
+int32_t *ARC_Mouse_GetScrollY(ARC_Mouse *mouse){
+    return mouse->scrollY;
+}
+
+#endif // ARC_SDL

src/math/rectangle.c

@@ -1,7 +1,7 @@
 #include "arc/math/rectangle.h"
 
 //VERY TEMP
-#include <SDL.h>
+// #include <SDL.h>
 
 int32_t ARC_Rect_Intersects(ARC_Rect *rect1, ARC_Rect *rect2){
     if(rect1->x <= rect2->x + rect2->w && rect1->x + rect1->w >= rect2->x &&
@@ -13,6 +13,7 @@ int32_t ARC_Rect_Intersects(ARC_Rect *rect1, ARC_Rect *rect2){
 
 int32_t ARC_Rect_LineIntersects(ARC_Rect *rect, int32_t *x1, int32_t *y1, int32_t *x2, int32_t *y2){
     //TODO: Replace soon
-    return SDL_IntersectRectAndLine((SDL_Rect *) rect, x1, y1, x2, y2);
+    // return SDL_IntersectRectAndLine((SDL_Rect *) rect, x1, y1, x2, y2);
+    return 1;
 }