herbglitch/archeus
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

opengl added to engine

Browse source
This commit is contained in:
herbglitch 2023-03-10 17:34:22 -07:00
parent d8378484a7
commit 706a519452
31 changed files with 490 additions and 68 deletions
Download patch file Download diff file Expand all files Collapse all files

67
CMakeLists.txt
View file

@ -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
)
add_library(archeus_std SHARED
${ARCHEUS_STD_SOURCES}
${ARCHEUS_STD_SDL_SOURCES}
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
)
# target_sources(archeus_std PRIVATE
# ${ARCHEUS_STD_SOURCES}
# ${ARCHEUS_STD_SDL_SOURCES}
# )
set(ARCHEUS_STD_GLFW_SOURCES
src/input/glfw/keyboard.c
src/input/glfw/mouse.c
)
target_include_directories(archeus_std PRIVATE
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}
)
if(ARCHEUS_STD_SDL)
target_include_directories(archeus_std PRIVATE
include
PUBLIC ${SDL2_INCLUDE_DIRS}
PUBLIC ${SDL2IMAGE_INCLUDE_DIRS}
)
)
endif()
if(ARCHEUS_STD_OPENGL)
target_include_directories(archeus_std PRIVATE
include
GL
glfw
GLEW
)
endif()
install(TARGETS archeus_std EXPORT archeus_std_Exports
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}

36
include/arc/graphics/opengl/renderer.h Normal file
View file

@ -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_

13
include/arc/graphics/opengl/sprite.h Normal file
View file

@ -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_

13
include/arc/graphics/opengl/spritesheet.h Normal file
View file

@ -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_

29
include/arc/graphics/opengl/window.h Normal file
View file

@ -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_

5
include/arc/graphics/renderer.h
View file

@ -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;

9
include/arc/graphics/sdl/renderer.h
View file

@ -7,10 +7,7 @@
#include "arc/graphics/renderer.h"
#include "arc/graphics/window.h"
// Temp till I figure out a better solution
struct ARC_Renderer {
SDL_Renderer *renderer;
};
typedef SDL_Renderer ARC_RendererType;
/**
* @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_

4
include/arc/graphics/sdl/sprite.h
View file

@ -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_

4
include/arc/graphics/sdl/spritesheet.h
View file

@ -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_

9
include/arc/graphics/sdl/window.h
View file

@ -6,10 +6,7 @@
#include <SDL.h>
#include "arc/graphics/window.h"
// Temp till I figure out a better solution
struct ARC_Window {
SDL_Window *window;
};
typedef SDL_Window ARC_WindowType;
/**
* @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_

5
include/arc/graphics/window.h
View file

@ -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;

21
include/arc/input/glfw/keyboard.h Normal file
View file

@ -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_

25
include/arc/input/glfw/mouse.h Normal file
View file

@ -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_

34
src/engine/engine.c
View file

@ -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_KEYDOWN && event->key.keysym.sym == SDLK_ESCAPE){ return; }
if(event->type == SDL_QUIT){ data->running = 1; }
#elif ARC_GLFW
glfwPollEvents();
data->running = glfwWindowShouldClose((GLFWwindow *)data->window);
#endif // ARC_SDL
ARC_Mouse_Update(data->mouse);

14
src/graphics/opengl/config.c Normal file
View file

@ -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

8
src/graphics/opengl/line.c Normal file
View file

@ -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

11
src/graphics/opengl/rectangle.c Normal file
View file

@ -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

55
src/graphics/opengl/renderer.c Normal file
View file

@ -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

29
src/graphics/opengl/sprite.c Normal file
View file

@ -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

17
src/graphics/opengl/spritesheet.c Normal file
View file

@ -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

36
src/graphics/opengl/window.c Normal file
View file

@ -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

2
src/graphics/sdl/config.c
View file

@ -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 );

6
src/graphics/sdl/line.c
View file

@ -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_RenderDrawLine(renderer->renderer, *x1, *y1, *x2, *y2);
SDL_SetRenderDrawColor((SDL_Renderer *)renderer, color->r, color->g, color->b, color->a);
SDL_RenderDrawLine((SDL_Renderer *)renderer, *x1, *y1, *x2, *y2);
}
#endif // ARC_SDL

10
src/graphics/sdl/rectangle.c
View file

@ -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_RenderDrawRect(renderer->renderer, (SDL_Rect *) rect);
SDL_SetRenderDrawColor((SDL_Renderer *)renderer, color->r, color->g, color->b, color->a);
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_RenderFillRect(renderer->renderer, (SDL_Rect *) rect);
SDL_SetRenderDrawColor((SDL_Renderer *)renderer, color->r, color->g, color->b, color->a);
SDL_RenderFillRect((SDL_Renderer *)renderer, (SDL_Rect *) rect);
}
#endif // ARC_SDL

14
src/graphics/sdl/renderer.c
View file

@ -14,10 +14,9 @@ void ARC_Renderer_Create(ARC_Renderer **renderer, ARC_RenderInfo *info){
return;
}
*renderer = (ARC_Renderer *)malloc(sizeof(ARC_Renderer));
(*renderer)->renderer = SDL_CreateRenderer((SDL_Window *)info->window, info->index, info->flags);
*renderer = (ARC_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);
free(renderer);
SDL_DestroyRenderer((SDL_Renderer *) renderer);
}
void ARC_Renderer_Clear(ARC_Renderer *renderer){
SDL_SetRenderDrawColor((SDL_Renderer *)renderer->renderer, 0x1c, 0x2c, 0x3c, 0x00);
SDL_RenderClear((SDL_Renderer *)renderer->renderer);
SDL_SetRenderDrawColor((SDL_Renderer *)renderer, 0x1c, 0x2c, 0x3c, 0x00);
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

6
src/graphics/sdl/sprite.c
View file

@ -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){

4
src/graphics/sdl/spritesheet.c
View file

@ -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

8
src/graphics/sdl/window.c
View file

@ -18,10 +18,9 @@ void ARC_Window_Create(ARC_Window **window, ARC_WindowInfo *info){
return;
}
*window = (ARC_Window *)malloc(sizeof(ARC_Window));
(*window)->window = SDL_CreateWindow((const char *)info->title, info->x, info->y, info->w, info->h, info->flags);
*window = (ARC_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);
free(window);
SDL_DestroyWindow((SDL_Window *) window);
}
#endif //ARC_SDL

22
src/input/glfw/keyboard.c Normal file
View file

@ -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

33
src/input/glfw/mouse.c Normal file
View file

@ -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

5
src/math/rectangle.c
View file

@ -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;
}