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

f***ed up and needed to rework packages

Browse source
This commit is contained in:
herbglitch 2024-05-20 03:46:04 -06:00
parent f4592ae8d0
commit b43ab1702f
73 changed files with 194 additions and 2045 deletions
Download patch file Download diff file Expand all files Collapse all files

7
src/audio/sdl/audio.c
View file

@ -1,7 +0,0 @@
#include "arc/audio/audio.h"
#include "arc/audio/sdl/audio.h"
#include <SDL2/SDL_mixer.h>
void ARC_Audio_Play(ARC_Audio *audio){
Mix_PlayChannel(-1, audio->chunk, 0);
}

43
src/audio/sdl/config.c
View file

@ -1,43 +0,0 @@
#include "arc/audio/config.h"
#include "arc/audio/sdl/audio.h"
#include <stdio.h>
#include <stdlib.h>
#include "arc/std/config.h"
#include "arc/std/errno.h"
#include "arc/audio/audio.h"
// #define ARC_DEFAULT_CONFIG
#include "arc/std/defaults/config.h"
void ARC_AudioConfig_Init(ARC_Config *config){
ARC_Config_AddKeyCString(config, (char *)"ARC_Audio", 9, ARC_Audio_Read, ARC_Audio_Delete);
}
uint8_t ARC_Audio_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_DEBUG_LOG(arc_errno, "in ARC_Point_Read(config, string, value); no matching quotes: %s", string->data);
arc_errno = ARC_ERRNO_DATA;
return 0;
}
ARC_Audio *audio = (ARC_Audio *)malloc(sizeof(ARC_Audio));
ARC_String *path;
ARC_String_CopySubstring(&path, string, 1, string->length - 2);
audio->chunk = Mix_LoadWAV(path->data);
//TODO: get error message if not loaded
*value = (void *)audio;
return 0;
}
void ARC_Audio_Delete(ARC_Config* config, ARC_String *string, void *value){
Mix_FreeChunk(((ARC_Audio *)value)->chunk);
free((ARC_Audio *)value);
}

103
src/engine/engine.c
View file

@ -1,94 +1,50 @@
#include "arc/engine/engine.h"
//NOTE: some of this file is temporary, mostly to get smthn running so I can test out different ideas
#include <stdlib.h>
#include "arc/engine/state.h"
#include "arc/graphics/window.h"
#include "arc/graphics/renderer.h"
#include "arc/input/mouse.h"
#include "arc/input/keyboard.h"
#include "arc/std/bool.h"
#include "arc/std/errno.h"
#include "arc/std/handler.h"
//NOTE: some of this file is temporary, mostly to get smthn running so I can test out different ideas
#include "arc/graphics/none/window.h"
#include "arc/graphics/none/renderer.h"
#include "arc/input/none/mouse.h"
#include "arc/input/none/keyboard.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"
#include "arc/graphics/glfw/window.h"
#include "arc/graphics/glfw/renderer.h"
#include "arc/input/glfw/mouse.h"
#include "arc/input/glfw/keyboard.h"
void ARC_EngineData_Create(ARC_EngineData **data, ARC_Handler_CleanDataFn cleanfn, ARC_Point windowSize){
void ARC_EngineData_Create(ARC_EngineData **data, ARC_Handler_CleanDataFn cleanFn, ARC_Point windowSize){
*data = (ARC_EngineData *)malloc(sizeof(ARC_EngineData));
(*data)->window = NULL;
(*data)->renderer = NULL;
(*data)->input = NULL;
(*data)->keyboard = NULL;
(*data)->mouse = NULL;
ARC_Handler_Create(&((*data)->state), cleanfn);
ARC_Handler_Create(&((*data)->state), cleanFn);
ARC_WindowInfo windowInfo;
ARC_RenderInfo renderInfo;
ARC_MouseInfo mouseInfo;
ARC_KeyboardInfo keyboardInfo;
(*data)->dt = 0.0;
(*data)->running = ARC_False;
(*data)->windowSize = windowSize;
//TEMP
#ifdef ARC_SDL
// TTF_Init();
// Mix_Init(0);
// Mix_OpenAudio(MIX_DEFAULT_FREQUENCY, MIX_DEFAULT_FORMAT, 2, 1024);
#endif
#ifdef ARC_SDL2_WINDOW
windowInfo = (ARC_WindowInfo){ "title", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, (*data)->windowSize.x, (*data)->windowSize.y, 0 };
#elif ARC_GLFW_WINDOW
windowInfo = (ARC_WindowInfo){ "title", (*data)->windowSize.x, (*data)->windowSize.y };
#endif // ARC_SDL
ARC_WindowInfo windowInfo = (ARC_WindowInfo){ "title", (*data)->windowSize.x, (*data)->windowSize.y };
ARC_Window_Create(&((*data)->window), &windowInfo);
if(arc_errno){
free(data);
return;
}
#ifdef ARC_SDL2_WINDOW
renderInfo = (ARC_RenderInfo){ (SDL_Window *)(*data)->window, -1, SDL_RENDERER_ACCELERATED };
#elif ARC_GLFW_WINDOW
renderInfo = (ARC_RenderInfo){ (GLFWwindow *)(*data)->window };
#endif // ARC_SDL
ARC_Renderer_Create(&((*data)->renderer), &renderInfo);
ARC_Renderer_CreateWithEngineData(&((*data)->renderer), *data);
if(arc_errno){
ARC_Window_Destroy((*data)->window);
free(data);
}
#ifdef ARC_SDL2_INPUT
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_Input_CreateWithEngineData(&((*data)->input), *data);
ARC_Mouse_Create (&((*data)->mouse) , &mouseInfo );
ARC_Keyboard_Create(&((*data)->keyboard), &keyboardInfo);
(*data)->keyboard = ARC_Input_GetKeyboard((*data)->input);
(*data)->mouse = ARC_Input_GetMouse((*data)->input);
}
void ARC_EngineData_Destroy(ARC_EngineData *data){
#ifdef ARC_SDL2_INPUT
free(data->mouse->event);
// TTF_Quit();
// Mix_Quit();
#endif // ARC_SDL
ARC_Mouse_Destroy(data->mouse);
ARC_Keyboard_Destroy(data->keyboard);
ARC_Renderer_Destroy(data->renderer);
@ -96,35 +52,20 @@ void ARC_EngineData_Destroy(ARC_EngineData *data){
ARC_Handler_Destroy(data->state);
}
void ARC_Engine_Run(ARC_EngineData *data){
void ARC_Engine_RunUncapped(ARC_EngineData *data){
if(arc_errno){
return;
}
#ifdef ARC_SDL2_INPUT
SDL_Event *event = data->mouse->event;
double lastTime = 0, currentTime;
data->dt = 0;
#endif // ARC_SDL
// double lastTime = 0, currentTime;
data->running = 0;
data->running = ARC_True;
while(data->running){
// currentTime = SDL_GetTicks();
// data->dt = currentTime - lastTime;
// lastTime = currentTime;
while(!data->running){
#ifdef ARC_SDL2_INPUT
currentTime = SDL_GetTicks();
data->dt = currentTime - lastTime;
lastTime = currentTime;
SDL_PollEvent(data->mouse->event);
if(event->type == SDL_QUIT){ data->running = 1; }
#elif ARC_GLFW_WINDOW
glfwPollEvents();
data->running = glfwWindowShouldClose((GLFWwindow *)data->window);
#endif // ARC_SDL
ARC_Mouse_Update(data->mouse);
ARC_Keyboard_Update(data->keyboard);
ARC_Input_Update(data->input);
ARC_Handler_Clean(data->state);

14
src/graphics/glfw/config.c
View file

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

52
src/graphics/glfw/renderer.c
View file

@ -1,52 +0,0 @@
#ifdef ARC_GLFW_WINDOW
#include "arc/graphics/renderer.h"
#include "arc/graphics/glfw/renderer.h"
// #ifdef ARC_GLEW
#define GLEW_STATIC
#include <GL/glew.h>
// #endif // ARC_GLEW
#include <GLFW/glfw3.h>
#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_GLEW
*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_GLEW
glfwSwapBuffers(renderer->window);
// #endif // ARC_GLEW
}
#endif //ARC_SDL

36
src/graphics/glfw/window.c
View file

@ -1,36 +0,0 @@
#ifdef ARC_GLFW_WINDOW
#include "arc/graphics/window.h"
#include "arc/graphics/glfw/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

10
src/graphics/none/circle.c
View file

@ -1,10 +0,0 @@
#ifdef ARC_NONE_GRAPHICS
#include "arc/graphics/circle.h"
#include <stdio.h>
void ARC_Circle_Render(ARC_Circle *circle, ARC_Renderer *renderer, ARC_Color *color){
printf("No Graphics Backend Selected\n");
}
#endif // !ARC_NONE_GRAPHICS

10
src/graphics/none/config.c
View file

@ -1,10 +0,0 @@
#ifdef ARC_NONE_GRAPHICS
#include "arc/graphics/config.h"
#include <stdio.h>
void ARC_GraphicsConfig_Init(ARC_Config *config, ARC_Renderer *renderer){
printf("No Graphics Backend Selected\n");
}
#endif //ARC_NONE_GRAPHICS

10
src/graphics/none/line.c
View file

@ -1,10 +0,0 @@
#ifdef ARC_NONE_GRAPHICS
#include "arc/graphics/line.h"
#include <stdio.h>
void ARC_Line_Render(int32_t *x1, int32_t *y1, int32_t *x2, int32_t *y2, ARC_Renderer *renderer, ARC_Color *color){
printf("No Graphics Backend Selected\n");
}
#endif // !ARC_NONE_GRAPHICS

14
src/graphics/none/obround.c
View file

@ -1,14 +0,0 @@
#ifdef ARC_NONE_GRAPHICS
#include "arc/graphics/obround.h"
#include <stdio.h>
void ARC_Obround_Render(ARC_Obround *obround, ARC_Renderer *renderer, ARC_Color *color){
printf("No Graphics Backend Selected\n");
}
void ARC_FObround_Render(ARC_FObround *obround, ARC_Renderer *renderer, ARC_Color *color){
printf("No Graphics Backend Selected\n");
}
#endif // ARC_NONE_GRAPHICS

22
src/graphics/none/rectangle.c
View file

@ -1,22 +0,0 @@
#ifdef ARC_NONE_GRAPHICS
#include "arc/graphics/rectangle.h"
#include <stdio.h>
void ARC_Rect_Render(ARC_Rect *rect, ARC_Renderer *renderer, ARC_Color *color){
printf("No Graphics Backend Selected\n");
}
void ARC_Rect_RenderFill(ARC_Rect *rect, ARC_Renderer *renderer, ARC_Color *color){
printf("No Graphics Backend Selected\n");
}
void ARC_FRect_Render(ARC_FRect *rect, ARC_Renderer *renderer, ARC_Color *color){
printf("No Graphics Backend Selected\n");
}
void ARC_FRect_RenderFill(ARC_FRect *rect, ARC_Renderer *renderer, ARC_Color *color){
printf("No Graphics Backend Selected\n");
}
#endif // !ARC_NONE_GRAPHICS

22
src/graphics/none/renderer.c
View file

@ -1,22 +0,0 @@
#ifdef ARC_NONE_GRAPHICS
#include "arc/graphics/renderer.h"
#include <stdio.h>
void ARC_Renderer_Create(ARC_Renderer **renderer, ARC_RenderInfo *info){
printf("No Graphics Backend Selected\n");
}
void ARC_Renderer_Destroy(ARC_Renderer *renderer){
printf("No Graphics Backend Selected\n");
}
void ARC_Renderer_Clear(ARC_Renderer *renderer){
printf("No Graphics Backend Selected\n");
}
void ARC_Renderer_Render(ARC_Renderer *renderer){
printf("No Graphics Backend Selected\n");
}
#endif // !ARC_NONE_GRAPHICS

48
src/graphics/none/sprite.c
View file

@ -1,48 +0,0 @@
#ifdef ARC_NONE_GRAPHICS
#include "arc/graphics/sprite.h"
#include <stdio.h>
void ARC_Sprite_Create(ARC_Sprite **sprite, ARC_Spritesheet *spritesheet, ARC_Array *frames){
printf("No Graphics Backend Selected\n");
}
void ARC_Sprite_Destroy(ARC_Sprite *sprite){
printf("No Graphics Backend Selected\n");
}
void ARC_Sprite_Copy(ARC_Sprite **newSprite, ARC_Sprite *oldSprite){
printf("No Graphics Backend Selected\n");
}
void ARC_Sprite_Render(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds){
printf("No Graphics Backend Selected\n");
}
void ARC_Sprite_RenderFlip(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds, enum ARC_Sprite_Axis axis){
printf("No Graphics Backend Selected\n");
}
void ARC_Sprite_RenderRotated(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds, ARC_Point *center, double angle){
printf("No Graphics Backend Selected\n");
}
void ARC_Sprite_SetFrameIndex(ARC_Sprite *sprite, uint32_t index){
printf("No Graphics Backend Selected\n");
}
void ARC_Sprite_IterateFrame(ARC_Sprite *sprite){
printf("No Graphics Backend Selected\n");
}
ARC_Rect *ARC_Sprite_GetBounds(ARC_Sprite *sprite){
printf("No Graphics Backend Selected\n");
return NULL;
}
ARC_Array *ARC_Sprite_GetAllBounds(ARC_Sprite *sprite){
printf("No Graphics Backend Selected\n");
return NULL;
}
#endif // !ARC_NONE_GRAPHICS

21
src/graphics/none/spritesheet.c
View file

@ -1,21 +0,0 @@
#ifdef ARC_NONE_GRAPHICS
#include "arc/graphics/spritesheet.h"
#include "arc/math/point.h"
#include <stdio.h>
void ARC_Spritesheet_RenderArea(ARC_Spritesheet *spritesheet, ARC_Rect *sheetBounds, ARC_Renderer *renderer, ARC_Rect *renderBounds){
printf("No Graphics Backend Selected\n");
}
ARC_Point ARC_Spritesheet_GetSize(ARC_Spritesheet *spritesheet){
printf("No Graphics Backend Selected\n");
return (ARC_Point){ 0, 0 };
}
uint32_t *ARC_Spritesheet_GetTileSize(ARC_Spritesheet *spritesheet){
printf("No Graphics Backend Selected\n");
return NULL;
}
#endif // !ARC_NONE_GRAPHICS

26
src/graphics/none/text.c
View file

@ -1,26 +0,0 @@
#ifdef ARC_NONE_GRAPHICS
#include "arc/graphics/text.h"
#include <stdio.h>
void ARC_Text_Create(ARC_Text **text, ARC_String *path, int32_t size, ARC_Color color){
printf("No Graphics Backend Selected\n");
}
void ARC_Text_Destroy(ARC_Text *font){
printf("No Graphics Backend Selected\n");
}
void ARC_Text_SetString(ARC_Text *text, ARC_Renderer *renderer, ARC_String *string){
printf("No Graphics Backend Selected\n");
}
void ARC_Text_Render(ARC_Text *text, ARC_Renderer *renderer){
printf("No Graphics Backend Selected\n");
}
void ARC_Text_SetPos(ARC_Text *text, ARC_Point pos){
printf("No Graphics Backend Selected\n");
}
#endif // !ARC_NONE_GRAPHICS

14
src/graphics/none/window.c
View file

@ -1,14 +0,0 @@
#ifdef ARC_NONE_WINDOW
#include "arc/graphics/window.h"
#include <stdio.h>
void ARC_Window_Create(ARC_Window **window, ARC_WindowInfo *info){
printf("No Window Backend Selected\n");
}
void ARC_Window_Destroy(ARC_Window *window){
printf("No Window Backend Selected\n");
}
#endif // !ARC_NONE_WINDOW

10
src/graphics/opengl/circle.c
View file

@ -1,10 +0,0 @@
#ifdef ARC_OPENGL_GRAPHICS
#include "arc/graphics/circle.h"
#include <stdio.h>
void ARC_Circle_Render(ARC_Circle *circle, ARC_Renderer *renderer, ARC_Color *color){
printf("OpenGL Backend Selected\n");
}
#endif // !ARC_OPENGL_GRAPHICS

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

@ -1,8 +0,0 @@
#ifdef ARC_OPENGL_GRAPHICS
#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_GRAPHICS

14
src/graphics/opengl/obround.c
View file

@ -1,14 +0,0 @@
#ifdef ARC_OPENGL_GRAPHICS
#include "arc/graphics/obround.h"
#include <stdio.h>
void ARC_Obround_Render(ARC_Obround *obround, ARC_Renderer *renderer, ARC_Color *color){
printf("OpenGL Backend Selected\n");
}
void ARC_FObround_Render(ARC_FObround *obround, ARC_Renderer *renderer, ARC_Color *color){
printf("OpenGL Backend Selected\n");
}
#endif // ARC_OPENGL_GRAPHICS

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

@ -1,11 +0,0 @@
#ifdef ARC_OPENGL_GRAPHICS
#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_GRAPHICS

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

@ -1,29 +0,0 @@
#ifdef ARC_OPENGL_GRAPHICS
#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_GRAPHICS

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

@ -1,17 +0,0 @@
#ifdef ARC_OPENGL_GRAPHICS
#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_GRAPHICS

26
src/graphics/opengl/text.c
View file

@ -1,26 +0,0 @@
#ifdef ARC_OPENGL_GRAPHICS
#include "arc/graphics/text.h"
#include <stdio.h>
void ARC_Text_Create(ARC_Text **text, ARC_String *path, int32_t size, ARC_Color color){
printf("OpenGL Backend Selected\n");
}
void ARC_Text_Destroy(ARC_Text *font){
printf("OpenGL Backend Selected\n");
}
void ARC_Text_SetString(ARC_Text *text, ARC_Renderer *renderer, ARC_String *string){
printf("OpenGL Backend Selected\n");
}
void ARC_Text_Render(ARC_Text *text, ARC_Renderer *renderer){
printf("OpenGL Backend Selected\n");
}
void ARC_Text_SetPos(ARC_Text *text, ARC_Point pos){
printf("OpenGL Backend Selected\n");
}
#endif // !ARC_OPENGL_GRAPHICS

52
src/graphics/sdl/circle.c
View file

@ -1,52 +0,0 @@
#ifdef ARC_SDL2_GRAPHICS
#include "arc/graphics/circle.h"
#include "arc/graphics/sdl/renderer.h"
#include <stdlib.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){
SDL_SetRenderDrawColor((SDL_Renderer *)renderer, color->r, color->g, color->b, color->a);
int32_t diameter = (circle->r * 2);
int32_t x = (circle->r - 1);
int32_t y = 0;
int32_t tx = 1;
int32_t ty = 1;
int32_t error = (tx - diameter);
while(x >= y){
// Each of the following renders an octant of the circle
SDL_RenderDrawPoint((SDL_Renderer *)renderer, circle->x + x, circle->y - y);
SDL_RenderDrawPoint((SDL_Renderer *)renderer, circle->x + x, circle->y + y);
SDL_RenderDrawPoint((SDL_Renderer *)renderer, circle->x - x, circle->y - y);
SDL_RenderDrawPoint((SDL_Renderer *)renderer, circle->x - x, circle->y + y);
SDL_RenderDrawPoint((SDL_Renderer *)renderer, circle->x + y, circle->y - x);
SDL_RenderDrawPoint((SDL_Renderer *)renderer, circle->x + y, circle->y + x);
SDL_RenderDrawPoint((SDL_Renderer *)renderer, circle->x - y, circle->y - x);
SDL_RenderDrawPoint((SDL_Renderer *)renderer, circle->x - y, circle->y + x);
if(error <= 0){
++y;
error += ty;
ty += 2;
}
if(error > 0){
--x;
tx += 2;
error += (tx - diameter);
}
}
}
//TODO: very temp
void ARC_Circle_RenderFill(ARC_Circle *circle, ARC_Renderer *renderer, ARC_Color *color){
ARC_Circle temp = *circle;
for(; temp.r; temp.r--){
ARC_Circle_Render(&temp, renderer, color);
}
}
#endif // ARC_SDL2_GRAPHICS

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

@ -1,314 +0,0 @@
#ifdef ARC_SDL2_GRAPHICS
#include "arc/graphics/config.h"
#include <SDL_image.h>
#include <stdio.h>
#include "arc/std/array.h"
#include "arc/std/string.h"
#include "arc/std/errno.h"
#include "arc/graphics/sdl/renderer.h"
#include "arc/graphics/sprite.h"
#include "arc/graphics/sdl/sprite.h"
#include "arc/graphics/spritesheet.h"
#include "arc/graphics/sdl/spritesheet.h"
#include "arc/math/config.h"
#include "arc/math/point.h"
#include "arc/math/rectangle.h"
// #define ARC_DEFAULT_CONFIG
#include "arc/std/defaults/config.h"
SDL_Renderer *global_renderer;
uint8_t ARC_SDL_Texture_Read(ARC_Config *config, ARC_String *string, void **value);
uint8_t ARC_Spritesheet_Read(ARC_Config *config, ARC_String *string, void **value);
uint8_t ARC_Sprite_Read (ARC_Config *config, ARC_String *string, void **value);
void ARC_SDL_Texture_Delete(ARC_Config *config, ARC_String *string, void *value);
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 = (SDL_Renderer *)renderer;
ARC_Config_AddKeyCString(config, (char *)"SDL_Texture" , 11, ARC_SDL_Texture_Read, ARC_SDL_Texture_Delete);
ARC_Config_AddKeyCString(config, (char *)"ARC_Spritesheet", 15, ARC_Spritesheet_Read, ARC_Spritesheet_Delete);
ARC_Config_AddKeyCString(config, (char *)"ARC_Sprite" , 10, ARC_Sprite_Read , ARC_Sprite_Delete );
}
uint64_t ARC_GraphicsConfig_GetIndexAndErrorCheck(ARC_String *string, char *search, uint64_t searchLength){
uint64_t separator = ARC_String_FindCString(string, ",", 1);
if(separator == ~(uint64_t)0){
arc_errno = ARC_ERRNO_DATA;
}
return separator;
}
int32_t ARC_SDL_Texture_Load(const char *path, SDL_Texture **texture){
IMG_Init(IMG_INIT_PNG);
SDL_Surface *surface = IMG_Load(path);
if(!surface){
printf("Error: reading png '%s'\nSDL_Image Error: %s", path, IMG_GetError());
return 1; // GE_SDL_ERRNO_
}
SDL_BlendMode tempMode;
SDL_GetSurfaceBlendMode(surface, &tempMode);
*texture = SDL_CreateTextureFromSurface(global_renderer, surface);
SDL_GetTextureBlendMode(*texture, &tempMode);
SDL_FreeSurface(surface);
IMG_Quit();
return 0;
}
uint8_t ARC_SDL_Texture_Read(ARC_Config* config, ARC_String *string, void **value){
ARC_Config_Get(config, string, value);
if(*value){
return 1;
}
ARC_String *tempStr, *textureStr;
ARC_String_StripEndsWhitespace(&tempStr, string);
ARC_String_CopySubstring(&textureStr, tempStr, 1, tempStr->length - 2);
ARC_String_Destroy(tempStr);
ARC_SDL_Texture_Load(textureStr->data, (SDL_Texture **)value);
ARC_String_Destroy(textureStr);
return 0;
}
void ARC_Spritesheet_ReadTexture(ARC_Config *config, ARC_String *string, uint32_t *size, void **value){
SDL_Texture *texture;
ARC_String *tempStr, *textureStr;
ARC_String_StripEndsWhitespace(&tempStr, string);
//check for reference
ARC_Config_Get(config, tempStr, (void **)&texture);
if(!texture && (tempStr->data[0] != '"' || tempStr->data[string->length - 1] != '"')){
arc_errno = ARC_ERRNO_DATA;
}
ARC_String_CopySubstring(&textureStr, tempStr, 1, tempStr->length - 2);
ARC_String_Destroy(tempStr);
//try reading in the texture
if(!texture){
ARC_SDL_Texture_Read(config, string, (void **)&texture);
if(arc_errno){
*value = NULL;
}
}
ARC_String_Destroy(textureStr);
*value = malloc(sizeof(ARC_Spritesheet));
((ARC_Spritesheet *) *value)->texture = texture;
((ARC_Spritesheet *) *value)->size = size;
}
uint8_t ARC_Spritesheet_Read(ARC_Config* config, ARC_String *string, void **value){
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, *textureStr, *sizeStr;
ARC_String_CopySubstring(&temp, string, 1, split - 2);
ARC_String_StripEndsWhitespace(&textureStr, temp);
ARC_String_Destroy(temp);
ARC_String_CopySubstring(&temp, string, split + 1, string->length - (split + 1));
ARC_String_StripEndsWhitespace(&sizeStr, temp);
ARC_String_Destroy(temp);
uint32_t *size;
ARC_Config_Get(config, string, (void **)&size);
if(!size){
ARC_ConfigKey_Read_Uint32_t(config, sizeStr, (void **)&size);
if(arc_errno){
ARC_String_Destroy(sizeStr);
ARC_String_Destroy(textureStr);
return ARC_ERRNO_DATA;
}
}
ARC_Spritesheet_ReadTexture(config, textureStr, size, value);
ARC_String_Destroy(sizeStr);
ARC_String_Destroy(textureStr);
return 0;
}
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);
}
#endif //ARC_SDL2_GRAPHICS

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

@ -1,11 +0,0 @@
#ifdef ARC_SDL2_GRAPHICS
#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((SDL_Renderer *)renderer, color->r, color->g, color->b, color->a);
SDL_RenderDrawLine((SDL_Renderer *)renderer, *x1, *y1, *x2, *y2);
}
#endif // ARC_SDL2_GRAPHCIS

51
src/graphics/sdl/obround.c
View file

@ -1,51 +0,0 @@
#ifdef ARC_SDL2_GRAPHICS
#include "arc/graphics/obround.h"
#include "arc/graphics/sdl/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){
SDL_SetRenderDrawColor((SDL_Renderer *)renderer, color->r, color->g, color->b, color->a);
int32_t diameter = (obround->r * 2);
int32_t x = (obround->r - 1);
int32_t y = 0;
int32_t tx = 1;
int32_t ty = 1;
int32_t error = (tx - diameter);
SDL_RenderDrawLine((SDL_Renderer *)renderer, obround->x - obround->r, obround->y - (obround->h / 2), obround->x - obround->r, obround->y + (obround->h / 2));
SDL_RenderDrawLine((SDL_Renderer *)renderer, obround->x + obround->r, obround->y - (obround->h / 2), obround->x + obround->r, obround->y + (obround->h / 2));
while(x >= y){
// Each of the following renders an octant of the circle
SDL_RenderDrawPoint((SDL_Renderer *)renderer, obround->x + x, obround->y - y - (obround->h / 2));
SDL_RenderDrawPoint((SDL_Renderer *)renderer, obround->x + x, obround->y + y + (obround->h / 2));
SDL_RenderDrawPoint((SDL_Renderer *)renderer, obround->x - x, obround->y - y - (obround->h / 2));
SDL_RenderDrawPoint((SDL_Renderer *)renderer, obround->x - x, obround->y + y + (obround->h / 2));
SDL_RenderDrawPoint((SDL_Renderer *)renderer, obround->x + y, obround->y - x - (obround->h / 2));
SDL_RenderDrawPoint((SDL_Renderer *)renderer, obround->x + y, obround->y + x + (obround->h / 2));
SDL_RenderDrawPoint((SDL_Renderer *)renderer, obround->x - y, obround->y - x - (obround->h / 2));
SDL_RenderDrawPoint((SDL_Renderer *)renderer, obround->x - y, obround->y + x + (obround->h / 2));
if(error <= 0){
++y;
error += ty;
ty += 2;
}
if(error > 0){
--x;
tx += 2;
error += (tx - diameter);
}
}
}
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);
}
#endif // ARC_SDL2_GRAPHICS

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

@ -1,26 +0,0 @@
#ifdef ARC_SDL2_GRAPHICS
#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((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((SDL_Renderer *)renderer, color->r, color->g, color->b, color->a);
SDL_RenderFillRect((SDL_Renderer *)renderer, (SDL_Rect *) rect);
}
void ARC_FRect_Render(ARC_FRect *rect, ARC_Renderer *renderer, ARC_Color *color){
ARC_Rect casted = ARC_FRect_CastToRect(rect);
ARC_Rect_Render(&casted, renderer, color);
}
void ARC_FRect_RenderFill(ARC_FRect *rect, ARC_Renderer *renderer, ARC_Color *color){
ARC_Rect casted = ARC_FRect_CastToRect(rect);
ARC_Rect_RenderFill(&casted, renderer, color);
}
#endif // ARC_SDL2_GRAPHICS

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

@ -1,41 +0,0 @@
#ifdef ARC_SDL2_WINDOW
#include "arc/graphics/renderer.h"
#include "arc/graphics/sdl/renderer.h"
#include <SDL.h>
#include <stdlib.h>
#include "arc/graphics/window.h"
#include "arc/std/errno.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;
}
*renderer = (ARC_Renderer *)SDL_CreateRenderer((SDL_Window *)info->window, info->index, info->flags);
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);
}
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, 0x00);
SDL_RenderClear((SDL_Renderer *)renderer);
}
void ARC_Renderer_Render(ARC_Renderer *renderer){
SDL_RenderPresent((SDL_Renderer *)renderer);
}
#endif //ARC_SDL2_WINDOW

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

@ -1,92 +0,0 @@
#ifdef ARC_SDL2_GRAPHICS
#include "arc/graphics/sprite.h"
#include "arc/graphics/sdl/sprite.h"
#include "arc/graphics/sdl/spritesheet.h"
#include "arc/graphics/sdl/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);
SDL_RenderCopy((SDL_Renderer *)renderer, sprite->spritesheet->texture, (SDL_Rect *)sprite->frames->data + *sprite->frameIndex, (SDL_Rect *)renderBounds);
}
void ARC_Sprite_RenderFlip(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds, enum ARC_Sprite_Axis axis){
SDL_RendererFlip 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);
SDL_RenderCopyEx((SDL_Renderer *)renderer, sprite->spritesheet->texture, (SDL_Rect *)sprite->frames->data + *sprite->frameIndex, (SDL_Rect *)renderBounds, 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);
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_SetFrameIndex(ARC_Sprite *sprite, uint32_t index){
if(sprite->frames->size <= index){
arc_errno = ARC_ERRNO_DATA;
ARC_DEBUG_LOG(arc_errno, "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;
}
#endif // ARC_SDL2_GRAPHICS

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

@ -1,22 +0,0 @@
#ifdef ARC_SDL2_GRAPHICS
#include "arc/graphics/spritesheet.h"
#include "arc/graphics/sdl/spritesheet.h"
#include "arc/graphics/sdl/renderer.h"
#include "arc/math/point.h"
#include <SDL_render.h>
void ARC_Spritesheet_RenderArea(ARC_Spritesheet *spritesheet, ARC_Rect *sheetBounds, ARC_Renderer *renderer, ARC_Rect *renderBounds){
SDL_RenderCopy((SDL_Renderer *)renderer, spritesheet->texture, (SDL_Rect *)sheetBounds, (SDL_Rect *)renderBounds);
}
ARC_Point ARC_Spritesheet_GetSize(ARC_Spritesheet *spritesheet){
ARC_Point size;
SDL_QueryTexture(spritesheet->texture, NULL, NULL, &size.x, &size.y);
return size;
}
uint32_t *ARC_Spritesheet_GetTileSize(ARC_Spritesheet *spritesheet){
return spritesheet->size;
}
#endif //ARC_SDL2_GRAPHICS

59
src/graphics/sdl/text.c
View file

@ -1,59 +0,0 @@
#ifdef ARC_SDL2_GRAPHICS
#include "arc/graphics/text.h"
#include "arc/graphics/sdl/text.h"
#include "arc/graphics/color.h"
#include "arc/math/point.h"
#include "arc/math/rectangle.h"
#include "arc/std/string.h"
#include <SDL2/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 };
}
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_Wrapped(ttfont, string->data, textColor, 0);
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_FreeSurface(surface);
TTF_CloseFont(ttfont);
}
void ARC_Text_Render(ARC_Text *text, ARC_Renderer *renderer){
if(text->texture == NULL){
return;
}
SDL_Rect bounds = (SDL_Rect){ text->bounds.x, text->bounds.y, text->bounds.w, text->bounds.h };
SDL_RenderCopy((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;
}
#endif //ARC_SDL2_GRAPHICS

38
src/graphics/sdl/view.c
View file

@ -1,38 +0,0 @@
#ifdef ARC_SDL2_GRAPHICS
#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;
}
#endif //ARC_SDL2_GRAPHICS

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

@ -1,34 +0,0 @@
#ifdef ARC_SDL2_WINDOW
#include "arc/graphics/window.h"
#include "arc/graphics/sdl/window.h"
#include "arc/std/errno.h"
#include <SDL.h>
void ARC_Window_Create(ARC_Window **window, ARC_WindowInfo *info){
if(!info){
arc_errno = ARC_ERRNO_NULL;
ARC_DEBUG_ERR("ARC_Window_Create(**window, NULL)");
return;
}
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0){
arc_errno = ARC_ERRNO_INIT;
printf("Error: initializing SDL\nSDL Error: %s\n", SDL_GetError());
return;
}
*window = (ARC_Window *)SDL_CreateWindow((const char *)info->title, info->x, info->y, info->w, info->h, info->flags);
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);
}
}
void ARC_Window_Destroy(ARC_Window *window){
SDL_DestroyWindow((SDL_Window *) window);
}
#endif //ARC_SDL2_WINDOW

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

@ -1,22 +0,0 @@
#ifdef ARC_GLFW_INPUT
#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, enum ARC_KeyboardKey key){
return ARC_KEY_NONE;
}
#endif // ARC_GLFW_INPUT

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

@ -1,33 +0,0 @@
#ifdef ARC_GLFW_INPUT
#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_INPUT

23
src/input/none/keyboard.c
View file

@ -1,23 +0,0 @@
#ifdef ARC_NONE_INPUT
#include "arc/input/keyboard.h"
#include <stdio.h>
void ARC_Keyboard_Create(ARC_Keyboard **keyboard, ARC_KeyboardInfo *info){
printf("No Input Backend Selected\n");
}
void ARC_Keyboard_Destroy(ARC_Keyboard *keyboard){
printf("No Input Backend Selected\n");
}
void ARC_Keyboard_Update(ARC_Keyboard *keyboard){
printf("No Input Backend Selected\n");
}
ARC_KeyboardState ARC_Keyboard_GetState(ARC_Keyboard *keyboard, enum ARC_KeyboardKey key){
printf("No Input Backend Selected\n");
return ARC_KEY_NONE;
}
#endif // !ARC_NONE_INPUT

37
src/input/none/mouse.c
View file

@ -1,37 +0,0 @@
#ifdef ARC_NONE_INPUT
#include "arc/input/mouse.h"
#include <stdio.h>
void ARC_Mouse_Create(ARC_Mouse **mouse, ARC_MouseInfo *info){
printf("No Input Backend Selected\n");
}
void ARC_Mouse_Destroy(ARC_Mouse *mouse){
printf("No Input Backend Selected\n");
}
void ARC_Mouse_UpdateButton(ARC_Mouse *mouse, uint8_t button, uint32_t *buttons, uint32_t mask){
printf("No Input Backend Selected\n");
}
void ARC_Mouse_Update(ARC_Mouse *mouse){
printf("No Input Backend Selected\n");
}
ARC_Point *ARC_Mouse_GetCoords(ARC_Mouse *mouse){
printf("No Input Backend Selected\n");
return NULL;
}
ARC_MouseState ARC_Mouse_GetState(ARC_Mouse *mouse, ARC_MouseButton button){
printf("No Input Backend Selected\n");
return ARC_MOUSE_NONE;
}
int32_t *ARC_Mouse_GetScrollY(ARC_Mouse *mouse){
printf("No Input Backend Selected\n");
return NULL;
}
#endif // !ARC_INPUT_NONE

101
src/input/sdl/keyboard.c
View file

@ -1,101 +0,0 @@
#ifdef ARC_SDL2_INPUT
#include "arc/input/sdl/keyboard.h"
#include "arc/input/keyboard.h"
#include "arc/math/point.h"
#include "arc/std/errno.h"
#include <stdlib.h>
#include <stdint.h>
#include <SDL_keyboard.h>
#include <SDL_events.h>
void ARC_Keyboard_Create(ARC_Keyboard **keyboard, ARC_KeyboardInfo *info){
*keyboard = (ARC_Keyboard *)malloc(sizeof(ARC_Keyboard));
(*keyboard)->event = info->event;
(*keyboard)->keys = (ARC_KeyboardState *)malloc(sizeof(ARC_KeyboardState) * ARC_KEYBOARD_BUTTON_NUM);
(*keyboard)->released = NULL;
for(uint8_t i = 0; i < ARC_KEYBOARD_BUTTON_NUM; i++){
(*keyboard)->keys[i] = ARC_KEY_NONE;
}
}
void ARC_Keyboard_Destroy(ARC_Keyboard *keyboard){
free(keyboard->keys);
free(keyboard);
}
void ARC_Keyboard_Update(ARC_Keyboard *keyboard){
if(keyboard->released){
*keyboard->released = ARC_KEY_NONE;
keyboard->released = NULL;
}
if(keyboard->event->type != SDL_KEYDOWN && keyboard->event->type != SDL_KEYUP){
return;
}
if(keyboard->event->key.keysym.sym >= 239 || keyboard->event->key.keysym.sym < 0){
return;
}
if(keyboard->event->type == SDL_KEYDOWN){
keyboard->keys[keyboard->event->key.keysym.sym] = ARC_KEY_PRESSED;
return;
}
keyboard->keys[keyboard->event->key.keysym.sym] = ARC_KEY_RELEASED;
keyboard->released = (keyboard->keys + keyboard->event->key.keysym.sym);
}
ARC_KeyboardState ARC_Keyboard_GetState(ARC_Keyboard *keyboard, enum ARC_KeyboardKey key){
switch(key){
case ARC_KEY_A: return keyboard->keys[SDLK_a];
case ARC_KEY_B: return keyboard->keys[SDLK_b];
case ARC_KEY_C: return keyboard->keys[SDLK_c];
case ARC_KEY_D: return keyboard->keys[SDLK_d];
case ARC_KEY_E: return keyboard->keys[SDLK_e];
case ARC_KEY_F: return keyboard->keys[SDLK_f];
case ARC_KEY_G: return keyboard->keys[SDLK_g];
case ARC_KEY_H: return keyboard->keys[SDLK_h];
case ARC_KEY_I: return keyboard->keys[SDLK_i];
case ARC_KEY_J: return keyboard->keys[SDLK_j];
case ARC_KEY_K: return keyboard->keys[SDLK_k];
case ARC_KEY_L: return keyboard->keys[SDLK_l];
case ARC_KEY_M: return keyboard->keys[SDLK_m];
case ARC_KEY_N: return keyboard->keys[SDLK_n];
case ARC_KEY_O: return keyboard->keys[SDLK_o];
case ARC_KEY_P: return keyboard->keys[SDLK_p];
case ARC_KEY_Q: return keyboard->keys[SDLK_q];
case ARC_KEY_R: return keyboard->keys[SDLK_r];
case ARC_KEY_S: return keyboard->keys[SDLK_s];
case ARC_KEY_T: return keyboard->keys[SDLK_t];
case ARC_KEY_U: return keyboard->keys[SDLK_u];
case ARC_KEY_V: return keyboard->keys[SDLK_v];
case ARC_KEY_W: return keyboard->keys[SDLK_w];
case ARC_KEY_X: return keyboard->keys[SDLK_x];
case ARC_KEY_Y: return keyboard->keys[SDLK_y];
case ARC_KEY_Z: return keyboard->keys[SDLK_z];
case ARC_KEY_0: return keyboard->keys[SDLK_0];
case ARC_KEY_1: return keyboard->keys[SDLK_1];
case ARC_KEY_2: return keyboard->keys[SDLK_2];
case ARC_KEY_3: return keyboard->keys[SDLK_3];
case ARC_KEY_4: return keyboard->keys[SDLK_4];
case ARC_KEY_5: return keyboard->keys[SDLK_5];
case ARC_KEY_6: return keyboard->keys[SDLK_6];
case ARC_KEY_7: return keyboard->keys[SDLK_7];
case ARC_KEY_8: return keyboard->keys[SDLK_8];
case ARC_KEY_9: return keyboard->keys[SDLK_9];
case ARC_KEY_SPACE: return keyboard->keys[SDLK_SPACE ];
case ARC_KEY_ESC: return keyboard->keys[SDLK_ESCAPE];
case ARC_KEY_ENTER: return keyboard->keys[SDLK_RETURN];
default: return ARC_KEY_NONE;
}
}
#endif // ARC_SDL2_INPUT

108
src/input/sdl/mouse.c
View file

@ -1,108 +0,0 @@
#ifdef ARC_SDL2_INPUT
#include "arc/input/sdl/mouse.h"
#include "arc/input/mouse.h"
#include "arc/math/point.h"
#include "arc/std/errno.h"
#include <stdlib.h>
#include <stdint.h>
#include <SDL_mouse.h>
#include <SDL_events.h>
void ARC_Mouse_Create(ARC_Mouse **mouse, ARC_MouseInfo *info){
*mouse = (ARC_Mouse *)malloc(sizeof(ARC_Mouse));
(*mouse)->event = info->event;
(*mouse)->coords = (ARC_Point *)malloc(sizeof(ARC_Point));
(*mouse)->scrollY = (int32_t *)malloc(sizeof(int32_t ));
(*mouse)->buttons = (ARC_MouseState *)malloc(sizeof(ARC_MouseState) * ARC_MOUSE_BUTTON_NUM);
(*mouse)->buttonsReleased = (uint8_t *)malloc(sizeof(uint8_t));
*(*mouse)->coords = (ARC_Point){0, 0};
*(*mouse)->scrollY = 0;
for(uint8_t i = 0; i < ARC_MOUSE_BUTTON_NUM; i++){
(*mouse)->buttons[i] = ARC_MOUSE_NONE;
}
*(*mouse)->buttonsReleased = 0;
}
void ARC_Mouse_Destroy(ARC_Mouse *mouse){
free(mouse->buttonsReleased);
free(mouse->buttons);
free(mouse->scrollY);
free(mouse->coords );
free(mouse);
}
void ARC_Mouse_UpdateButton(ARC_Mouse *mouse, uint8_t button, uint32_t *buttons, uint32_t mask){
if(*buttons & mask){
mouse->buttons[button] = ARC_MOUSE_PRESSED;
return;
}
if(mouse->buttons[button] == ARC_MOUSE_NONE){
return;
}
if(mouse->buttons[button] == ARC_MOUSE_RELEASED){
mouse->buttons[button] = ARC_MOUSE_NONE;
--*mouse->buttonsReleased;
return;
}
mouse->buttons[button] = ARC_MOUSE_RELEASED;
++*mouse->buttonsReleased;
}
void ARC_Mouse_Update(ARC_Mouse *mouse){
*mouse->scrollY = 0;
if(mouse->event->type == SDL_MOUSEWHEEL){
*mouse->scrollY = mouse->event->wheel.y;
}
uint32_t buttons = SDL_GetMouseState(&(mouse->coords->x), &(mouse->coords->y));
if(mouse->event->type != SDL_MOUSEBUTTONDOWN && mouse->event->type != SDL_MOUSEBUTTONUP){
if(!*mouse->buttonsReleased){
return;
}
for(uint8_t i = *mouse->buttonsReleased; i > 0; i--){
if(mouse->buttons[i - 1] == ARC_MOUSE_RELEASED){
mouse->buttons[i - 1] = ARC_MOUSE_NONE;
--*mouse->buttonsReleased;
}
}
// if(*mouse->buttonsReleased){
// arc_errno = ARC_ERRNO_DATA;
// ARC_DEBUG_LOG(arc_errno, "in ARC_Mouse_Update mouse->buttonsReleased == %u, it needs to be 0\n", *(mouse->buttonsReleased));
// }
return;
}
ARC_Mouse_UpdateButton(mouse, ARC_MOUSE_LEFT , &buttons, SDL_BUTTON_LMASK );
ARC_Mouse_UpdateButton(mouse, ARC_MOUSE_MIDDLE, &buttons, SDL_BUTTON_MMASK );
ARC_Mouse_UpdateButton(mouse, ARC_MOUSE_RIGHT , &buttons, SDL_BUTTON_RMASK );
ARC_Mouse_UpdateButton(mouse, ARC_MOUSE_X1 , &buttons, SDL_BUTTON_X1MASK);
ARC_Mouse_UpdateButton(mouse, ARC_MOUSE_X2 , &buttons, SDL_BUTTON_X2MASK);
}
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_SDL2_INPUT

20
src/std/handler.c
View file

@ -37,8 +37,8 @@ void ARC_Handler_Remove(ARC_Handler *handler, void *data, ARC_Handler_CompareDat
ARC_Vector_Remove(handler->data, data, (ARC_Vector_CompareDataFn) compare);
}
void ARC_Handler_RemoveIndex(ARC_Handler *handler, uint32_t *index){
if(!*ARC_Vector_Size(handler->data)){
void ARC_Handler_RemoveIndex(ARC_Handler *handler, uint32_t index){
if(ARC_Vector_Size(handler->data) == 0){
return;
}
@ -48,31 +48,31 @@ void ARC_Handler_RemoveIndex(ARC_Handler *handler, uint32_t *index){
}
void ARC_Handler_Iterate(ARC_Handler *handler, ARC_Handler_DataFn datafn){
for(uint32_t i = 0; i < *ARC_Vector_Size(handler->data); i++){
datafn(ARC_Vector_Get(handler->data, &i));
for(uint32_t i = 0; i < ARC_Vector_Size(handler->data); i++){
datafn(ARC_Vector_Get(handler->data, i));
}
}
void ARC_Handler_Clear(ARC_Handler *handler){
uint32_t zeroIndex = 0;
while(*ARC_Vector_Size(handler->data)){
ARC_Handler_RemoveIndex(handler, &zeroIndex);
while(ARC_Vector_Size(handler->data)){
ARC_Handler_RemoveIndex(handler, zeroIndex);
}
}
void ARC_Handler_Clean(ARC_Handler *handler){
uint32_t i = 0;
while(*ARC_Vector_Size(handler->trash)){
void *data = ARC_Vector_Get(handler->trash, &i);
while(ARC_Vector_Size(handler->trash)){
void *data = ARC_Vector_Get(handler->trash, i);
if(handler->cleanfn){
handler->cleanfn(data);
}
ARC_Vector_RemoveIndex(handler->trash, &i);
ARC_Vector_RemoveIndex(handler->trash, i);
}
}
uint32_t *ARC_Handler_Size(ARC_Handler *handler){
uint32_t ARC_Handler_Size(ARC_Handler *handler){
return ARC_Vector_Size(handler->data);
}

2
src/std/queue.c
View file

@ -72,7 +72,7 @@ void ARC_Queue_Push(ARC_Queue *queue, void *data){
void *ARC_Queue_Pop(ARC_Queue *queue){
if(queue->currentSize == 0){
arc_errno = ARC_ERRNO_DATA;
ARC_DEBUG_ERR("ARC_Queue_Pop(queue) called, but queue was not empty");
ARC_DEBUG_ERR("ARC_Queue_Pop(queue) called, but queue was empty");
return NULL;
}

67
src/std/vector.c
View file

@ -6,58 +6,53 @@
#include <string.h>
struct ARC_Vector {
uint32_t *currentSize, *capacity;
uint32_t currentSize, capacity;
void **data;
};
void ARC_Vector_Create(ARC_Vector **vector){
*vector = (ARC_Vector *) malloc(sizeof(ARC_Vector));
(*vector)->currentSize = (uint32_t *)malloc(sizeof(uint32_t));
(*vector)->capacity = (uint32_t *)malloc(sizeof(uint32_t));
(*vector)->data = (void **)malloc(sizeof(void *));
*(*vector)->currentSize = 0;
*(*vector)->capacity = 1;
(*vector)->currentSize = 0;
(*vector)->capacity = 1;
(*vector)->data = (void **)malloc(sizeof(void *));
}
void ARC_Vector_Destroy(ARC_Vector *vector){
free(vector->currentSize);
free(vector->capacity);
free(vector->data);
free(vector);
}
void ARC_Vector_Add(ARC_Vector *vector, void *data){
if(*vector->currentSize == ~((uint32_t)0)){
if(vector->currentSize == ~((uint32_t)0)){
arc_errno = ARC_ERRNO_OVERFLOW;
return;
}
if(*vector->currentSize == *vector->capacity){
if(!*vector->capacity){
++*vector->capacity;
if(vector->currentSize == vector->capacity){
if(!vector->capacity){
++vector->capacity;
}
*vector->capacity <<= 1;
vector->capacity <<= 1;
vector->data = (void *)realloc(vector->data, sizeof(void *) * *vector->capacity);
vector->data = (void *)realloc(vector->data, sizeof(void *) * vector->capacity);
}
vector->data[*vector->currentSize] = data;
++*(vector->currentSize);
vector->data[vector->currentSize] = data;
++(vector->currentSize);
}
//this function removes the redundant checking currentSize and index that would happen if ARC_Vector_Remove called ARC_Vector_RemoveIndex
void ARC_Vector_RemoveIndexNoCheck(ARC_Vector *vector, uint32_t *index);
void ARC_Vector_RemoveIndexNoCheck(ARC_Vector *vector, uint32_t index);
void ARC_Vector_Remove(ARC_Vector *vector, void *data, ARC_Vector_CompareDataFn compare){
if(!*vector->currentSize){
if(!vector->currentSize){
arc_errno = ARC_ERRNO_DATA;
return;
}
for(uint32_t i = 0; i < *vector->currentSize; i++){
for(uint32_t i = 0; i < vector->currentSize; i++){
if(!compare(data, vector->data[i])){
ARC_Vector_RemoveIndexNoCheck(vector, &i);
ARC_Vector_RemoveIndexNoCheck(vector, i);
return;
}
}
@ -66,8 +61,8 @@ void ARC_Vector_Remove(ARC_Vector *vector, void *data, ARC_Vector_CompareDataFn
arc_errno = ARC_ERRNO_DATA;
}
void ARC_Vector_RemoveIndex(ARC_Vector *vector, uint32_t *index){
if(!*vector->currentSize || *index >= *vector->currentSize){
void ARC_Vector_RemoveIndex(ARC_Vector *vector, uint32_t index){
if(!vector->currentSize || index >= vector->currentSize){
arc_errno = ARC_ERRNO_DATA;
return;
}
@ -75,36 +70,36 @@ void ARC_Vector_RemoveIndex(ARC_Vector *vector, uint32_t *index){
ARC_Vector_RemoveIndexNoCheck(vector, index);
}
void ARC_Vector_RemoveIndexNoCheck(ARC_Vector *vector, uint32_t *index){
for(uint32_t i = *index; i <= *vector->currentSize; i++){
if(i + 1 >= *vector->currentSize - 1){
void ARC_Vector_RemoveIndexNoCheck(ARC_Vector *vector, uint32_t index){
for(uint32_t i = index; i <= vector->currentSize; i++){
if(i + 1 >= vector->currentSize - 1){
break;
}
vector->data[i] = vector->data[i + 1];
}
--*vector->currentSize;
--vector->currentSize;
if(*vector->currentSize != *vector->capacity >> 1){
if(vector->currentSize != vector->capacity >> 1){
return;
}
*vector->capacity >>= 1;
if(*vector->capacity <= 0){
*vector->capacity = 1;
vector->capacity >>= 1;
if(vector->capacity <= 0){
vector->capacity = 1;
}
vector->data = (void *)realloc(vector->data, sizeof(void *) * *vector->capacity);
vector->data = (void *)realloc(vector->data, sizeof(void *) * vector->capacity);
}
uint32_t *ARC_Vector_Size(ARC_Vector *vector){
uint32_t ARC_Vector_Size(ARC_Vector *vector){
return vector->currentSize;
}
void *ARC_Vector_Get(ARC_Vector *vector, uint32_t *index){
if(*index >= *vector->currentSize){
void *ARC_Vector_Get(ARC_Vector *vector, uint32_t index){
if(index >= vector->currentSize){
return NULL;
}
return vector->data[*index];
return vector->data[index];
}