From f7a87d75199e62a03fa147feea294247fff8aa5f Mon Sep 17 00:00:00 2001 From: herbglitch Date: Mon, 20 May 2024 03:46:09 -0600 Subject: [PATCH] f***ed up and needed to rework packages --- cmake/archeus_libssh.cmake | 0 cmake/archeus_ncurses.cmake | 21 ++ include/arc/console/buffer/line.h | 102 ++++++++ include/arc/console/buffer/view.h | 98 ++++++++ include/arc/console/element.h | 78 +++++++ include/arc/console/key.h | 76 ++++++ include/arc/console/shell.h | 97 ++++++++ include/arc/console/view.h | 267 +++++++++++++++++++++ include/arc/input/input.h | 32 +++ include/arc/networking/ssh.h | 51 ++++ include/arc/std/time.h | 55 +++++ packages/audio/sdl/audio.c | 7 + packages/audio/sdl/audio.h | 10 + packages/audio/sdl/config.c | 43 ++++ packages/console/ncurses/buffer/line.c | 147 ++++++++++++ packages/console/ncurses/buffer/view.c | 51 ++++ packages/console/ncurses/element.c | 52 +++++ packages/console/ncurses/key.c | 161 +++++++++++++ packages/console/ncurses/key.h | 19 ++ packages/console/ncurses/shell.c | 57 +++++ packages/console/ncurses/view.c | 268 +++++++++++++++++++++ packages/graphics/glfw/config.c | 14 ++ packages/graphics/glfw/renderer.c | 52 +++++ packages/graphics/glfw/renderer.h | 29 +++ packages/graphics/glfw/window.c | 36 +++ packages/graphics/glfw/window.h | 16 ++ packages/graphics/opengl/circle.c | 10 + packages/graphics/opengl/line.c | 8 + packages/graphics/opengl/obround.c | 14 ++ packages/graphics/opengl/rectangle.c | 11 + packages/graphics/opengl/sprite.c | 29 +++ packages/graphics/opengl/sprite.h | 13 ++ packages/graphics/opengl/spritesheet.c | 17 ++ packages/graphics/opengl/spritesheet.h | 13 ++ packages/graphics/opengl/text.c | 26 +++ packages/graphics/opengl/text.h | 14 ++ packages/graphics/sdl/circle.c | 49 ++++ packages/graphics/sdl/config.c | 311 +++++++++++++++++++++++++ packages/graphics/sdl/line.c | 8 + packages/graphics/sdl/obround.c | 48 ++++ packages/graphics/sdl/rectangle.c | 23 ++ packages/graphics/sdl/renderer.c | 39 ++++ packages/graphics/sdl/renderer.h | 10 + packages/graphics/sdl/sprite.c | 90 +++++++ packages/graphics/sdl/sprite.h | 15 ++ packages/graphics/sdl/spritesheet.c | 20 ++ packages/graphics/sdl/spritesheet.h | 12 + packages/graphics/sdl/text.c | 57 +++++ packages/graphics/sdl/text.h | 20 ++ packages/graphics/sdl/view.c | 35 +++ packages/graphics/sdl/window.c | 31 +++ packages/graphics/sdl/window.h | 9 + packages/input/glfw/input.c | 42 ++++ packages/input/glfw/keyboard.c | 23 ++ packages/input/glfw/keyboard.h | 21 ++ packages/input/glfw/mouse.c | 34 +++ packages/input/glfw/mouse.h | 25 ++ packages/input/sdl/input.c | 40 ++++ packages/input/sdl/input.h | 15 ++ packages/input/sdl/keyboard.c | 98 ++++++++ packages/input/sdl/keyboard.h | 14 ++ packages/input/sdl/mouse.c | 105 +++++++++ packages/input/sdl/mouse.h | 17 ++ packages/networking/libssh/ssh.c | 207 ++++++++++++++++ src/graphics/circle.c | 10 + src/graphics/config.c | 10 + src/graphics/line.c | 10 + src/graphics/obround.c | 14 ++ src/graphics/rectangle.c | 22 ++ src/graphics/renderer.c | 22 ++ src/graphics/sprite.c | 48 ++++ src/graphics/spritesheet.c | 21 ++ src/graphics/text.c | 26 +++ src/graphics/window.c | 14 ++ src/input/input.c | 26 +++ src/input/keyboard.c | 23 ++ src/input/mouse.c | 37 +++ src/std/time.c | 18 ++ 78 files changed, 3713 insertions(+) create mode 100644 cmake/archeus_libssh.cmake create mode 100644 cmake/archeus_ncurses.cmake create mode 100644 include/arc/console/buffer/line.h create mode 100644 include/arc/console/buffer/view.h create mode 100644 include/arc/console/element.h create mode 100644 include/arc/console/key.h create mode 100644 include/arc/console/shell.h create mode 100644 include/arc/console/view.h create mode 100644 include/arc/input/input.h create mode 100644 include/arc/networking/ssh.h create mode 100644 include/arc/std/time.h create mode 100644 packages/audio/sdl/audio.c create mode 100644 packages/audio/sdl/audio.h create mode 100644 packages/audio/sdl/config.c create mode 100644 packages/console/ncurses/buffer/line.c create mode 100644 packages/console/ncurses/buffer/view.c create mode 100644 packages/console/ncurses/element.c create mode 100644 packages/console/ncurses/key.c create mode 100644 packages/console/ncurses/key.h create mode 100644 packages/console/ncurses/shell.c create mode 100644 packages/console/ncurses/view.c create mode 100644 packages/graphics/glfw/config.c create mode 100644 packages/graphics/glfw/renderer.c create mode 100644 packages/graphics/glfw/renderer.h create mode 100644 packages/graphics/glfw/window.c create mode 100644 packages/graphics/glfw/window.h create mode 100644 packages/graphics/opengl/circle.c create mode 100644 packages/graphics/opengl/line.c create mode 100644 packages/graphics/opengl/obround.c create mode 100644 packages/graphics/opengl/rectangle.c create mode 100644 packages/graphics/opengl/sprite.c create mode 100644 packages/graphics/opengl/sprite.h create mode 100644 packages/graphics/opengl/spritesheet.c create mode 100644 packages/graphics/opengl/spritesheet.h create mode 100644 packages/graphics/opengl/text.c create mode 100644 packages/graphics/opengl/text.h create mode 100644 packages/graphics/sdl/circle.c create mode 100644 packages/graphics/sdl/config.c create mode 100644 packages/graphics/sdl/line.c create mode 100644 packages/graphics/sdl/obround.c create mode 100644 packages/graphics/sdl/rectangle.c create mode 100644 packages/graphics/sdl/renderer.c create mode 100644 packages/graphics/sdl/renderer.h create mode 100644 packages/graphics/sdl/sprite.c create mode 100644 packages/graphics/sdl/sprite.h create mode 100644 packages/graphics/sdl/spritesheet.c create mode 100644 packages/graphics/sdl/spritesheet.h create mode 100644 packages/graphics/sdl/text.c create mode 100644 packages/graphics/sdl/text.h create mode 100644 packages/graphics/sdl/view.c create mode 100644 packages/graphics/sdl/window.c create mode 100644 packages/graphics/sdl/window.h create mode 100644 packages/input/glfw/input.c create mode 100644 packages/input/glfw/keyboard.c create mode 100644 packages/input/glfw/keyboard.h create mode 100644 packages/input/glfw/mouse.c create mode 100644 packages/input/glfw/mouse.h create mode 100644 packages/input/sdl/input.c create mode 100644 packages/input/sdl/input.h create mode 100644 packages/input/sdl/keyboard.c create mode 100644 packages/input/sdl/keyboard.h create mode 100644 packages/input/sdl/mouse.c create mode 100644 packages/input/sdl/mouse.h create mode 100644 packages/networking/libssh/ssh.c create mode 100644 src/graphics/circle.c create mode 100644 src/graphics/config.c create mode 100644 src/graphics/line.c create mode 100644 src/graphics/obround.c create mode 100644 src/graphics/rectangle.c create mode 100644 src/graphics/renderer.c create mode 100644 src/graphics/sprite.c create mode 100644 src/graphics/spritesheet.c create mode 100644 src/graphics/text.c create mode 100644 src/graphics/window.c create mode 100644 src/input/input.c create mode 100644 src/input/keyboard.c create mode 100644 src/input/mouse.c create mode 100644 src/std/time.c diff --git a/cmake/archeus_libssh.cmake b/cmake/archeus_libssh.cmake new file mode 100644 index 0000000..e69de29 diff --git a/cmake/archeus_ncurses.cmake b/cmake/archeus_ncurses.cmake new file mode 100644 index 0000000..4066834 --- /dev/null +++ b/cmake/archeus_ncurses.cmake @@ -0,0 +1,21 @@ +set(ARCHEUS_STD_NCURSES_CONSOLE_SOURCES + packages/console/ncurses/element.c + packages/console/ncurses/key.c + packages/console/ncurses/view.c + + #TODO: probs want to change line.c to a shell class, and remove view + #packages/console/ncurses/shell.c + #packages/console/ncurses/buffer/line.c + #packages/console/ncurses/buffer/view.c +) + +function(ncurses_check_and_init_needed _ARCHEUS_STD_FLAGS _ARCHEUS_STD_SOURCES ARCHEUS_STD_CONSOLE_BACKEND) + #add matching files for the selected backends + if(${ARCHEUS_STD_CONSOLE_BACKEND} STREQUAL "NCURSES") + string(APPEND ${_ARCHEUS_STD_FLAGS} "-lncurses ") + list(APPEND ${_ARCHEUS_STD_SOURCES} ${ARCHEUS_STD_NCURSES_CONSOLE_SOURCES}) + endif() + + set(${_ARCHEUS_STD_FLAGS} ${${_ARCHEUS_STD_FLAGS}} PARENT_SCOPE) + set(${_ARCHEUS_STD_SOURCES} ${${_ARCHEUS_STD_SOURCES}} PARENT_SCOPE) +endfunction() diff --git a/include/arc/console/buffer/line.h b/include/arc/console/buffer/line.h new file mode 100644 index 0000000..ac2c989 --- /dev/null +++ b/include/arc/console/buffer/line.h @@ -0,0 +1,102 @@ +#ifndef ARC_CONSOLE_LINE_BUFFER_H_ +#define ARC_CONSOLE_LINE_BUFFER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "arc/console/view.h" +#include "arc/std/string.h" + +/** + * @brief +*/ +typedef struct ARC_ConsoleLineBuffer ARC_ConsoleLineBuffer; + +/** + * @brief creates ARC_ConsoleLineBuffer type + * + * @param buffer ARC_ConsoleLineBuffer to create +*/ +void ARC_ConsoleLineBuffer_Create(ARC_ConsoleLineBuffer **buffer); + +/** + * @brief destroys ARC_ConsoleLineBuffer type + * + * @param buffer ARC_ConsoleLineBuffer to destroy +*/ +void ARC_ConsoleLineBuffer_Destroy(ARC_ConsoleLineBuffer *buffer); + +/** + * @brief clears the contents of a ARC_ConsoleLineBuffer + * + * @param buffer ARC_ConsoleLineBuffer to clear +*/ +void ARC_ConsoleLineBuffer_Clear(ARC_ConsoleLineBuffer *buffer); + +/** + * @brief renders a buffer to a ARC_ConsoleView + * + * @param buffer ARC_ConsoleLineBuffer to render + * @param view ARC_ConsoleView to render the buffer contents to +*/ +void ARC_ConsoleLineBuffer_Render(ARC_ConsoleLineBuffer *buffer, ARC_ConsoleView *view); + +/** + * @brief renders a section of buffer to a ARC_ConsoleView + * + * @param buffer ARC_ConsoleLineBuffer to render + * @param view ARC_ConsoleView to render the buffer contents to + * @param startIndex start index of buffer to render + * @param lines the number of lines of buffer to render +*/ +void ARC_ConsoleLineBuffer_RenderSection(ARC_ConsoleLineBuffer *buffer, ARC_ConsoleView *view, uint32_t startIndex, uint32_t lines); + +/** + * @brief adds a character to the buffer + * + * @param buffer ARC_ConsoleLineBuffer to add character to + * @param character char to add to ARC_ConsoleBuffer +*/ +void ARC_ConsoleLineBuffer_AddChar(ARC_ConsoleLineBuffer *buffer, char character); + +/** + * @brief adds an ARC_String to the buffer + * + * @param buffer ARC_ConsoleLineBuffer to add character to + * @param string ARC_String to add to ARC_ConsoleLineBuffer +*/ +void ARC_ConsoleLineBuffer_AddString(ARC_ConsoleLineBuffer *buffer, ARC_String *string); + +/** + * @brief adds a cstring to the buffer + * + * @param buffer ARC_ConsoleLineBuffer to add character to + * @param string cstring to add to ARC_ConsoleLineBuffer + * @param length the length of the c string to add +*/ +void ARC_ConsoleLineBuffer_AddCString(ARC_ConsoleLineBuffer *buffer, char *cstring, uint64_t length); + +/** + * @brief adds a cstring to the buffer with the cstrings string length + * + * @param buffer ARC_ConsoleLineBuffer to add character to + * @param string cstring to add to ARC_ConsoleLineBuffer +*/ +void ARC_ConsoleLineBuffer_AddCStringWithStrlen(ARC_ConsoleLineBuffer *buffer, char *cstring); + +/** + * @brief gets the number of lines from a console line buffer + * + * @param buffer ARC_ConsoleLineBuffer get number of lines from + * + * @return the number of lines within an ARC_ConsoleLineBuffer +*/ +uint32_t ARC_ConsoleLineBuffer_GetLineNumbers(ARC_ConsoleLineBuffer *buffer); + +#ifdef __cplusplus +} +#endif + +#endif //!ARC_CONSOLE_LINE_BUFFER_H_ diff --git a/include/arc/console/buffer/view.h b/include/arc/console/buffer/view.h new file mode 100644 index 0000000..9f917ad --- /dev/null +++ b/include/arc/console/buffer/view.h @@ -0,0 +1,98 @@ +#ifndef ARC_CONSOLE_VIEW_BUFFER_H_ +#define ARC_CONSOLE_VIEW_BUFFER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "arc/console/view.h" +#include "arc/math/point.h" +#include "arc/std/string.h" + +/** + * @brief +*/ +typedef struct ARC_ConsoleViewBuffer ARC_ConsoleViewBuffer; + +/** + * @brief creates ARC_ConsoleViewBuffer type + * + * @param buffer ARC_ConsoleViewBuffer to create +*/ +void ARC_ConsoleViewBuffer_Create(ARC_ConsoleViewBuffer **buffer, ARC_ConsoleView *view); + +/** + * @brief destroys ARC_ConsoleViewBuffer type + * + * @param buffer ARC_ConsoleViewBuffer to destroy +*/ +void ARC_ConsoleViewBuffer_Destroy(ARC_ConsoleViewBuffer *buffer); + +/** + * @brief clears the contents of a ARC_ConsoleViewBuffer + * + * @param buffer ARC_ConsoleViewBuffer to clear +*/ +void ARC_ConsoleViewBuffer_Clear(ARC_ConsoleViewBuffer *buffer); + +/** + * @brief renders a buffer to a ARC_ConsoleView + * + * @param buffer ARC_ConsoleViewBuffer to render + * @param view ARC_ConsoleView to render the buffer contents to +*/ +void ARC_ConsoleViewBuffer_Render(ARC_ConsoleViewBuffer *buffer, ARC_ConsoleView *view); + +/** + * @brief renders a section of buffer to a ARC_ConsoleView + * + * @param buffer ARC_ConsoleViewBuffer to render + * @param view ARC_ConsoleView to render the buffer contents to + * @param startIndex start index of buffer to render + * @param lines the number of lines of buffer to render +*/ +void ARC_ConsoleViewBuffer_RenderArea(ARC_ConsoleViewBuffer *buffer, ARC_ConsoleView *view, uint32_t startIndex, uint32_t lines); + +/** + * @brief adds a character to the buffer + * + * @param buffer ARC_ConsoleViewBuffer to add character to + * @param character char to add to ARC_ConsoleBuffer + * @param pos position to add the char at +*/ +void ARC_ConsoleViewBuffer_AddCharAt(ARC_ConsoleViewBuffer *buffer, char character, ARC_Point pos); + +/** + * @brief adds an ARC_String to the buffer + * + * @param buffer ARC_ConsoleViewBuffer to add character to + * @param string ARC_String to add to ARC_ConsoleViewBuffer + * @param pos position to add the char at +*/ +void ARC_ConsoleViewBuffer_AddStringAt(ARC_ConsoleViewBuffer *buffer, ARC_String *string, ARC_Point pos); + +/** + * @brief adds a cstring to the buffer + * + * @param buffer ARC_ConsoleViewBuffer to add character to + * @param string cstring to add to ARC_ConsoleViewBuffer + * @param length the length of the c string to add + * @param pos position to add the char at +*/ +void ARC_ConsoleViewBuffer_AddCString(ARC_ConsoleViewBuffer *buffer, char *cstring, uint64_t length); + +/** + * @brief adds a cstring to the buffer with the cstrings string length + * + * @param buffer ARC_ConsoleViewBuffer to add character to + * @param string cstring to add to ARC_ConsoleViewBuffer + * @param pos position to add the char at +*/ +void ARC_ConsoleViewBuffer_AddCStringWithStrlen(ARC_ConsoleViewBuffer *buffer, char *cstring); + +#ifdef __cplusplus +} +#endif + +#endif // [!ARC_CONSOLE_VIEW_BUFFER_H_ diff --git a/include/arc/console/element.h b/include/arc/console/element.h new file mode 100644 index 0000000..6b52fce --- /dev/null +++ b/include/arc/console/element.h @@ -0,0 +1,78 @@ +#ifndef ARC_NCURSES_ELEMENT_H_ +#define ARC_NCURSES_ELEMENT_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "view.h" +#include "arc/std/string.h" +#include "arc/std/bool.h" +#include "arc/math/point.h" + +/** + * @brief +*/ +typedef struct ARC_ConsoleElement ARC_ConsoleElement; + +/** + * @brief +*/ +typedef void (*ARC_ConsoleElement_RenderFn)(ARC_ConsoleView *view, ARC_ConsoleElement *element); + +/** + * @brief +*/ +typedef struct ARC_ConsoleElement { + uint32_t type; + uint8_t flags; + ARC_String *string; + + ARC_Point pos; + + ARC_ConsoleElement_RenderFn renderFn; +} ARC_ConsoleElement; + +/** + * @brief +*/ +#define ARC_CONSOLE_ELEMENT_FLAG_NONE 0b00000000 +#define ARC_CONSOLE_ELEMENT_FLAG_SELECTABLE 0b00000001 +#define ARC_CONSOLE_ELEMENT_FLAG_SELECTED 0b00000010 + +/** + * @brief +*/ +void ARC_ConsoleElement_Create(ARC_ConsoleElement **element, uint32_t type, uint8_t flags, ARC_String *string, ARC_Point pos, ARC_ConsoleElement_RenderFn renderFn); + +/** + * @brief +*/ +void ARC_ConsoleElement_Destroy(ARC_ConsoleElement *element); + +/** + * @brief +*/ +void ARC_ConsoleElement_DefaultRenderFn(ARC_ConsoleView *view, ARC_ConsoleElement *element); + +/** + * @brief + * + * @param +*/ +ARC_Bool ARC_ConsoleElement_IsSelectable(ARC_ConsoleElement *element); + +/** + * @brief + * + * @param +*/ +void ARC_ConsoleElement_SetSelected(ARC_ConsoleElement *element, ARC_Bool selected); + +/** + * @brief +*/ +void ARC_ConsoleElement_ToggleSelected(ARC_ConsoleElement *element); + +#endif //!ARC_CONSOLE_ELEMENT_H_ diff --git a/include/arc/console/key.h b/include/arc/console/key.h new file mode 100644 index 0000000..39c3236 --- /dev/null +++ b/include/arc/console/key.h @@ -0,0 +1,76 @@ +#ifndef ARC_CONSOLE_KEY_H_ +#define ARC_CONSOLE_KEY_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "arc/std/bool.h" +#include + +typedef struct ARC_ConsoleKeyType ARC_ConsoleKey; + +typedef enum ARC_ConsoleKey_Key { + ARC_KEY_A, + ARC_KEY_B, + ARC_KEY_C, + ARC_KEY_D, + ARC_KEY_E, + ARC_KEY_F, + ARC_KEY_G, + ARC_KEY_H, + ARC_KEY_I, + ARC_KEY_J, + ARC_KEY_K, + ARC_KEY_L, + ARC_KEY_M, + ARC_KEY_N, + ARC_KEY_O, + ARC_KEY_P, + ARC_KEY_Q, + ARC_KEY_R, + ARC_KEY_S, + ARC_KEY_T, + ARC_KEY_U, + ARC_KEY_V, + ARC_KEY_W, + ARC_KEY_X, + ARC_KEY_Y, + ARC_KEY_Z, + + ARC_KEY_0, + ARC_KEY_1, + ARC_KEY_2, + ARC_KEY_3, + ARC_KEY_4, + ARC_KEY_5, + ARC_KEY_6, + ARC_KEY_7, + ARC_KEY_8, + ARC_KEY_9, + + ARC_KEY_LEFT, + ARC_KEY_RIGHT, + ARC_KEY_DOWN, + ARC_KEY_UP, + + ARC_KEY_ESC +} ARC_ConsoleKey_Key; + +void ARC_ConsoleKey_Create(ARC_ConsoleKey **consoleKey, ARC_ConsoleKey_Key *key); + +void ARC_ConsoleKey_Destroy(ARC_ConsoleKey *consoleKey); + +ARC_Bool ARC_ConsoleKey_Equals(ARC_ConsoleKey consoleKey, enum ARC_ConsoleKey_Key key); + +ARC_Bool ARC_ConsoleKey_EqualsPointer(ARC_ConsoleKey *consoleKey, enum ARC_ConsoleKey_Key key); + +ARC_ConsoleKey ARC_Keyboard_GetConsoleKey(enum ARC_ConsoleKey_Key key); + +uint8_t ARC_ConsoleKey_GetCharFromKey(ARC_ConsoleKey *consoleKey); + +#ifdef __cplusplus +} +#endif + +#endif // !ARC_CONSOLE_KEY_H_ \ No newline at end of file diff --git a/include/arc/console/shell.h b/include/arc/console/shell.h new file mode 100644 index 0000000..d5ec506 --- /dev/null +++ b/include/arc/console/shell.h @@ -0,0 +1,97 @@ +#ifndef ARC_CONSOLE_SHELL_H_ +#define ARC_CONSOLE_SHELL_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +//TODO: fix up this file + +#include "view.h" +//#include "buffer.h" +#include "arc/std/string.h" +#include "arc/std/vector.h" +#include + +/** + * @brief +*/ +typedef struct ARC_ConsoleShell ARC_ConsoleShell; + +/** + * @brief +*/ +typedef void (* ARC_ConsoleShell_UpdateFn)(ARC_ConsoleShell *shell); + +/** + * @brief +*/ +struct ARC_ConsoleShell { + ARC_ConsoleView *view; +// ARC_ConsoleBuffer *buffer; + uint32_t bufferLineIndex; + + ARC_Vector *history; + uint32_t historyIndex; + + ARC_ConsoleShell_UpdateFn updateFn; + + ARC_String *currentLine; + ARC_String *userInput; +}; + +/** + * @brief creates ARC_ConsoleShell type + * + * @param shell ARC_ConsoleShell to create + * @param view ARC_ConsoleView to attach the shell to + * @param updateFn ARC_ConsoleShell_UpdateFn provided that will run the console +*/ +void ARC_ConsoleShell_Create(ARC_ConsoleShell **shell, ARC_ConsoleView *view, ARC_ConsoleShell_UpdateFn updateFn); + +/** + * @brief destroys ARC_ConsoleShell type + * + * @param shell ARC_ConsoleShell to destroy +*/ +void ARC_ConsoleShell_Destroy(ARC_ConsoleShell *shell); + +/** + * @brief updates the ARC_ConsoleShell type + * + * @param shell the ARC_ConsoleShell to update +*/ +void ARC_ConsoleShell_Update(ARC_ConsoleShell *shell); + +/** + * @brief renders the ARC_ConsoleShell type + * + * @param shell the ARC_ConsoleShell to render +*/ +void ARC_ConsoleShell_Render(ARC_ConsoleShell *shell); + +/** + * @brief adds history ARC_String to ARC_ConsoleShell + * + * @param shell the ARC_ConsoleShell to add history to + * @param string the history string to add to ARC_ConsoleShell +*/ +void ARC_ConsoleShell_AddHistory(ARC_ConsoleShell *shell, ARC_String *string); + +/** + * @brief gets history from ARC_ConsoleShell + * + * @note the index 0 will start from the last added history + * + * @param shell the ARC_ConsoleShell to get history from + * @param index the location to get history at + * + * @return the history as an ARC_String +*/ +ARC_String *ARC_ConsoleShell_GetHistoryAt(ARC_ConsoleShell *shell, uint32_t index); + +#ifdef __cplusplus +} +#endif + +#endif //!ARC_CONSOLE_SHELL_H_ diff --git a/include/arc/console/view.h b/include/arc/console/view.h new file mode 100644 index 0000000..cf20a0b --- /dev/null +++ b/include/arc/console/view.h @@ -0,0 +1,267 @@ +#ifndef ARC_CONSOLE_VIEW_H_ +#define ARC_CONSOLE_VIEW_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include "arc/console/key.h" +#include "arc/math/rectangle.h" +#include "arc/std/bool.h" +#include "arc/std/string.h" + +/** + * @brief +*/ +typedef struct ARC_ConsoleView ARC_ConsoleView; + +/** + * @brief +*/ +typedef struct ARC_ConsoleElement ARC_ConsoleElement; + +/** + * @brief creates ARC_ConsoleView type + * + * @param view ARC_ConsoleView to create + * @param bounds the bounds of the window, if bounds.w == 0 or bounds.h == 0, bounds will take up the entire screen +*/ +void ARC_ConsoleView_Create(ARC_ConsoleView **view, ARC_Rect bounds); + +/** + * @brief destroys ARC_ConsoleView type + * + * @param view ARC_ConsoleView to destroy +*/ +void ARC_ConsoleView_Destroy(ARC_ConsoleView *view); + +/** + * @brief adds an ARC_ConsoleElement to the ARC_ConsoleView type + * + * @note the elements position will be based on the ARC_ConsoleView which might mess up how it looks + * + * @param view + * @param elment +*/ +void ARC_ConsoleView_AddElement(ARC_ConsoleView *view, ARC_ConsoleElement *element); + +/** + * @brief + * + * @param view + * @param index +*/ +void ARC_ConsoleView_RemoveElement(ARC_ConsoleView *view, uint32_t index); + +/** + * @brief + * + * @param view + * @param index +*/ +void ARC_ConsoleView_Clear(ARC_ConsoleView *view); + +/** + * @brief + * + * @param view + * @param character + * @param pos +*/ +void ARC_ConsoleView_RenderCharAt(ARC_ConsoleView *view, char character, ARC_Point pos); + +/** + * @brief + * + * @param view + * @param character + * @param pos +*/ +void ARC_ConsoleView_RenderWCharAt(ARC_ConsoleView *view, wchar_t character, ARC_Point pos); + +/** + * @brief + * + * @param view + * @param key + * @param pos +*/ +void ARC_ConsoleView_RenderKeyAt(ARC_ConsoleView *view, ARC_ConsoleKey key, ARC_Point pos); + +/** + * @brief + * + * @param view + * @param uint32 + * @param pos +*/ +void ARC_ConsoleView_RenderUint32At(ARC_ConsoleView *view, uint32_t uint32, ARC_Point pos); + +/** + * @brief + * + * @param view + * @param text + * @param pos +*/ +void ARC_ConsoleView_RenderStringAt(ARC_ConsoleView *view, ARC_String *text, ARC_Point pos); + +/** + * @brief + * + * @param view + * @param text + * @param pos +*/ +void ARC_ConsoleView_RenderCStringWithStrlenAt(ARC_ConsoleView *view, char *cstr, ARC_Point pos); + +/** + * @brief + * + * @param view + * @param bounds +*/ +void ARC_ConsoleView_RenderRect(ARC_ConsoleView *view, ARC_Rect bounds); + +/** + * @brief + * + * @param view +*/ +void ARC_ConsoleView_RenderElements(ARC_ConsoleView *view); + +/** + * @brief gets the bounds of an ARC_ConsoleView + * + * @param view ARC_ConsoleView to get bounds from + * + * @return the bounds of the ARC_ConsoleView +*/ +ARC_Rect ARC_ConsoleView_GetBounds(ARC_ConsoleView *view); + +/** + * @brief adds an ARC_ConsoleElement to the ARC_ConsoleView type + * + * @note the elements position will be based on the ARC_ConsoleView which might mess up how it looks + * + * @param view + * @param index +*/ +ARC_ConsoleElement *ARC_ConsoleView_GetElement(ARC_ConsoleView *view, uint32_t index); + +/** + * @brief gets a char from the view + * + * @note use ARC_ConsoleView_GetInt32At if you want to check for direction key or special character input + * + * @param view the ARC_ConsoleView to get the char from +*/ +char ARC_ConsoleView_GetChar(ARC_ConsoleView *view); + +/** + * @brief gets a char from the view at a position + * + * @note use ARC_ConsoleView_GetInt32At if you want to check for direction key or special character input + * + * @param view the ARC_ConsoleView to get the char from + * @param pos the positiion to get the char at +*/ +char ARC_ConsoleView_GetCharAt(ARC_ConsoleView *view, ARC_Point pos); + +/** + * @brief gets a console key from the view at a position + * + * @note you most likely do not want to use this function outside of a backend as ARC_ConsoleKey is defined within the console backend + * + * @param view the ARC_ConsoleView to get the console key from + * @param pos the positiion to get the console key at + * + * @return a console key +*/ +ARC_ConsoleKey ARC_ConsoleView_GetConsoleKeyAt(ARC_ConsoleView *view, ARC_Point pos); + +/** + * @brief gets and creates a console key from the view at a position + * + * @note the given ARC_ConsoleKey needs to be destroyed + * @note use ARC_ConsoleView_GetConsoleKeyAt if you want to check for keyboard or special character input + * + * @param view the ARC_ConsoleView to get the console key from + * @param pos the positiion to get the console key at + * + * @return a console key +*/ +ARC_ConsoleKey *ARC_ConsoleView_GetCreateConsoleKeyAt(ARC_ConsoleView *view, ARC_Point pos); + +/** + * @brief callback to check char being read in and override functionality + * + * @note this function is used for pressing arrow keys but can be used for anything + * + * @param key the current key being read in + * @param inputCStr the cstring that holds the current contents of the input + * @param inputSize the size of the current contents of the input string + * @param maxInputSize the max size inputCStr can store + * @param userdata data that a user can pass to use within this function +*/ +typedef ARC_Bool (* ARC_ConsoleView_OverrideCharInputFn)(ARC_ConsoleKey *key, char *inputCStr, uint32_t *inputSize, uint32_t maxInputSize, void *userdata); + +/** + * @brief gets a ARC_String from the view at a position + * + * @param view the ARC_ConsoleView to get the string from + * @param pos the positiion to get the string at + * @param overrideCharInputFn a function to allow overriding what happens when inputing chars, can be NULL + * @param userdata data that a user can pass to use within the overrideCharInputFn +*/ +ARC_String *ARC_ConsoleView_GetStringInput(ARC_ConsoleView *view, ARC_Point pos, ARC_ConsoleView_OverrideCharInputFn *overrideCharInputFn, void *userdata); + +/** + * @brief mouse options +*/ +#define ARC_CONSOLE_VIEW_CURSOR_HIDDEN 0x00 +#define ARC_CONSOLE_VIEW_CURSOR_VISIBLE 0x01 + +/** + * @brief sets a visibility of the cursor with an ARC_ConsoleView + * + * @param view ARC_ConsoleView to set mouse visibility + * @param visibility the visibility to set +*/ +void ARC_ConsoleView_SetCursorVisibility(ARC_ConsoleView *view, uint8_t visibility); + +/** + * @brief border options +*/ +#define ARC_CONSOLE_VIEW_BORDER_NONE 0x00 +#define ARC_CONSOLE_VIEW_BORDER_DEFAULT 0x01 + +/** + * @brief sets a border on the ARC_ConsoleView + * + * @param view ARC_ConsoleView to set border to + * @param border The border to set +*/ +void ARC_ConsoleView_SetBorder(ARC_ConsoleView *view, uint32_t border); + +/** + * @brief border options +*/ +#define ARC_CONSOLE_VIEW_ATTRIBUTE_NONE 0x00 +#define ARC_CONSOLE_VIEW_ATTRIBUTE_REVERSE 0x01 + +/** + * @brief sets a border on the ARC_ConsoleView + * + * @param view ARC_ConsoleView to set border to + * @param border The border to set +*/ +void ARC_ConsoleView_SetAttribute(ARC_ConsoleView *view, uint32_t attribute); + +#ifdef __cplusplus +} +#endif + +#endif //!ARC_CONSOLE_VIEW_H_ diff --git a/include/arc/input/input.h b/include/arc/input/input.h new file mode 100644 index 0000000..065bc97 --- /dev/null +++ b/include/arc/input/input.h @@ -0,0 +1,32 @@ +#ifndef ARC_INPUT_H_ +#define ARC_INPUT_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "arc/input/keyboard.h" +#include "arc/input/mouse.h" + +/** + * @brief predefien ARC_EngineData so as not to get circular reference +*/ +typedef struct ARC_EngineData ARC_EngineData; + +typedef struct ARC_Input ARC_Input; + +void ARC_Input_CreateWithEngineData(ARC_Input **input, ARC_EngineData *data); + +void ARC_Input_Destroy(ARC_Input *input); + +void ARC_Input_Update(ARC_Input *input); + +ARC_Keyboard *ARC_Input_GetKeyboard(ARC_Input *input); + +ARC_Mouse *ARC_Input_GetMouse(ARC_Input *input); + +#ifdef __cplusplus +} +#endif + +#endif // !ARC_INPUT_H_ \ No newline at end of file diff --git a/include/arc/networking/ssh.h b/include/arc/networking/ssh.h new file mode 100644 index 0000000..449a104 --- /dev/null +++ b/include/arc/networking/ssh.h @@ -0,0 +1,51 @@ +#ifndef ARC_SSH_H_ +#define ARC_SSH_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief ssh type that holds ssh connection along with credentials +*/ +typedef struct ARC_Ssh ARC_Ssh; + +/** + * @brief a ssh session function + * + * @param data user data that can be used within the callback +*/ +typedef void (* ARC_Ssh_SessionFn)(void *data); + +/** + * @brief creates ARC_Ssh type + * + * @param ssh ARC_Ssh to create + */ +void ARC_Ssh_Create(ARC_Ssh **ssh, char *host, char *user, char *password); + +/** + * @brief destroyes ARC_Ssh type + * + * @param ssh ARC_Ssh to destroy + */ +void ARC_Ssh_Destroy(ARC_Ssh *ssh); + +/** + * @brief runs a callback function within a ssh session + * + * @param ssh ARC_Ssh to create and run function in ssh session + * @param sessionFN callback to run in a ssh session + */ +void ARC_Ssh_RunInSession(ARC_Ssh *ssh, ARC_Ssh_SessionFn sessionFn); + +/** + * @brief +*/ +void ARC_Ssh_ExecStrInNewSession(ARC_Ssh *ssh, char *command); + +#ifdef __cplusplus +} +#endif + +#endif //!ARC_SSH_H_ diff --git a/include/arc/std/time.h b/include/arc/std/time.h new file mode 100644 index 0000000..ca878f2 --- /dev/null +++ b/include/arc/std/time.h @@ -0,0 +1,55 @@ +#ifndef ARC_STD_TIME_H_ +#define ARC_STD_TIME_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +/** + * @brief the ARC_Time data structre based on time.h (mainly added to avoid having to type `struct tm` every time) + * + * seconds == tm_sec [0,60] + * minutes == tm_min [0,59] + * hour == tm_hour [0,23] + * + * day == tm_yday Day of year [0,365] + * month == tm_mon Month of year [0,11] + * year == tm_year Years since 1900 + * + * dayOfWeek == tm_wday Day of week [0,6] (Sunday =0) + * dayOfMonth == tm_mday Day of month [1,31] + * + * daylightSavingsFlag == tm_isdst Daylight Savings flag +*/ +typedef struct ARC_Time { + uint8_t seconds; + uint8_t minutes; + uint8_t hour; + + uint32_t day; + uint8_t month; + uint32_t year; + + uint8_t dayOfWeek; + uint8_t dayOfMonth; + + uint8_t daylightSavingsFlag; +} ARC_Time; + +/** + * @brief copies the contents of a tm struct pointer into the ARC_Time type + * + * @param time the struct tm type to copy + * + * @return the contents of a struct tm as an ARC_Time +*/ +ARC_Time ARC_Time_CopyFromStructTmPtr(struct tm *time); + +#ifdef __cplusplus +} +#endif + +#endif // !ARC_STD_TIME_H_ diff --git a/packages/audio/sdl/audio.c b/packages/audio/sdl/audio.c new file mode 100644 index 0000000..3b1ad27 --- /dev/null +++ b/packages/audio/sdl/audio.c @@ -0,0 +1,7 @@ +#include "arc/audio/audio.h" +#include "audio.h" +#include + +void ARC_Audio_Play(ARC_Audio *audio){ + Mix_PlayChannel(-1, audio->chunk, 0); +} \ No newline at end of file diff --git a/packages/audio/sdl/audio.h b/packages/audio/sdl/audio.h new file mode 100644 index 0000000..3aa6d08 --- /dev/null +++ b/packages/audio/sdl/audio.h @@ -0,0 +1,10 @@ +#ifndef ARC_SDL_AUDIO_H_ +#define ARC_SDL_AUDIO_H_ + +#include + +typedef struct ARC_Audio { + Mix_Chunk *chunk; +} ARC_Audio; + +#endif // !ARC_SDL_AUDIO_H_ diff --git a/packages/audio/sdl/config.c b/packages/audio/sdl/config.c new file mode 100644 index 0000000..854e557 --- /dev/null +++ b/packages/audio/sdl/config.c @@ -0,0 +1,43 @@ +#include "arc/audio/config.h" + +#include "audio.h" +#include +#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); +} \ No newline at end of file diff --git a/packages/console/ncurses/buffer/line.c b/packages/console/ncurses/buffer/line.c new file mode 100644 index 0000000..7b9f99f --- /dev/null +++ b/packages/console/ncurses/buffer/line.c @@ -0,0 +1,147 @@ +#include "arc/console/buffer/line.h" + +#include "arc/console/view.h" +#include "arc/std/string.h" +#include "arc/std/vector.h" +#include +#include + +struct ARC_ConsoleLineBuffer { + ARC_Vector *bufferLines; +}; + +void ARC_ConsoleLineBuffer_Create(ARC_ConsoleLineBuffer **buffer){ + *buffer = (ARC_ConsoleLineBuffer *)malloc(sizeof(ARC_ConsoleLineBuffer)); + + ARC_Vector_Create(&((*buffer)->bufferLines)); + + //add first line to vector + ARC_Vector_Add((*buffer)->bufferLines, NULL); +} + +void ARC_ConsoleLineBuffer_Destroy(ARC_ConsoleLineBuffer *buffer){ + for(uint32_t i = 0; i < ARC_Vector_Size(buffer->bufferLines); i++){ + ARC_String *bufferLine = (ARC_String *)ARC_Vector_Get(buffer->bufferLines, i); + + if(bufferLine != NULL){ + ARC_String_Destroy(bufferLine); + } + } + + ARC_Vector_Destroy(buffer->bufferLines); + free(buffer); +} + +void ARC_ConsoleLineBuffer_Clear(ARC_ConsoleLineBuffer *buffer){ + for(uint32_t i = 0; i < ARC_Vector_Size(buffer->bufferLines); i++){ + ARC_String *bufferLine = (ARC_String *)ARC_Vector_Get(buffer->bufferLines, i); + + if(bufferLine != NULL){ + ARC_String_Destroy(bufferLine); + } + } + + ARC_Vector_Destroy(buffer->bufferLines); + ARC_Vector_Create(&(buffer->bufferLines)); + + //add first line to vector + ARC_Vector_Add(buffer->bufferLines, NULL); +} + +void ARC_ConsoleLineBuffer_Render(ARC_ConsoleLineBuffer *buffer, ARC_ConsoleView *view){ + ARC_Rect viewBounds = ARC_ConsoleView_GetBounds(view); + + uint32_t bufferStartIndex = 0; + if(ARC_Vector_Size(buffer->bufferLines) > (uint32_t)viewBounds.h){ + bufferStartIndex = ARC_Vector_Size(buffer->bufferLines) - viewBounds.h; + } + + for(uint32_t i = 0; i < (uint32_t)viewBounds.h; i++){ + if(i + bufferStartIndex > ARC_Vector_Size(buffer->bufferLines)){ + break; + } + + ARC_String *bufferLine = (ARC_String *)ARC_Vector_Get(buffer->bufferLines, i + bufferStartIndex); + if(bufferLine == NULL){ + continue; + } + + ARC_ConsoleView_RenderStringAt(view, bufferLine, (ARC_Point){ 0, i }); + } +} + +void ARC_ConsoleLineBuffer_RenderSection(ARC_ConsoleLineBuffer *buffer, ARC_ConsoleView *view, uint32_t startIndex, uint32_t lines){ + ARC_Rect viewBounds = ARC_ConsoleView_GetBounds(view); + + for(uint32_t i = 0; i < lines; i++){ + if(i + startIndex >= ARC_Vector_Size(buffer->bufferLines)){ + break; + } + + if(i >= (uint32_t)viewBounds.h){ + break; + } + + ARC_String *bufferLine = (ARC_String *)ARC_Vector_Get(buffer->bufferLines, i + startIndex); + if(bufferLine == NULL){ + continue; + } + + ARC_ConsoleView_RenderStringAt(view, bufferLine, (ARC_Point){ 0, i }); + } +} + +void ARC_ConsoleLineBuffer_AddChar(ARC_ConsoleLineBuffer *buffer, char character){ + if(character == '\n'){ + ARC_Vector_Add(buffer->bufferLines, (void *)NULL); + return; + } + + //get the last line and add a char to it + ARC_String *bufferLine = (ARC_String *)ARC_Vector_Get(buffer->bufferLines, ARC_Vector_Size(buffer->bufferLines) - 1); + ARC_Vector_RemoveIndex(buffer->bufferLines, ARC_Vector_Size(buffer->bufferLines) - 1); + + if(bufferLine == NULL){ + ARC_String_Create(&bufferLine, &character, 1); + ARC_Vector_Add(buffer->bufferLines, (void *)bufferLine); + return; + } + + //add char to the end of the bufferline + ARC_String *nextChar; + ARC_String_Create(&nextChar, &character, 1); + + ARC_String *tempBufferLine = bufferLine; + ARC_String_Merge(&bufferLine, tempBufferLine, nextChar); + + ARC_String_Destroy(tempBufferLine); + ARC_String_Destroy(nextChar); + + //add buffer line back to the bufferLines + ARC_Vector_Add(buffer->bufferLines, (void *)bufferLine); +} + +void ARC_ConsoleLineBuffer_AddString(ARC_ConsoleLineBuffer *buffer, ARC_String *string){ + //TODO: this in a more efficient way + for(uint64_t i = 0; i < string->length; i++){ + ARC_ConsoleLineBuffer_AddChar(buffer, string->data[i]); + } +} + +void ARC_ConsoleLineBuffer_AddCString(ARC_ConsoleLineBuffer *buffer, char *cstring, uint64_t length){ + //TODO: this in a more efficient way + for(uint64_t i = 0; i < length; i++){ + ARC_ConsoleLineBuffer_AddChar(buffer, cstring[i]); + } +} + +void ARC_ConsoleLineBuffer_AddCStringWithStrlen(ARC_ConsoleLineBuffer *buffer, char *cstring){ + //TODO: this in a more efficient way + for(uint64_t i = 0; i < strlen(cstring); i++){ + ARC_ConsoleLineBuffer_AddChar(buffer, cstring[i]); + } +} + +uint32_t ARC_ConsoleLineBuffer_GetLineNumbers(ARC_ConsoleLineBuffer *buffer){ + return ARC_Vector_Size(buffer->bufferLines); +} diff --git a/packages/console/ncurses/buffer/view.c b/packages/console/ncurses/buffer/view.c new file mode 100644 index 0000000..34ff2c2 --- /dev/null +++ b/packages/console/ncurses/buffer/view.c @@ -0,0 +1,51 @@ +#include "arc/console/buffer/view.h" + +#include "arc/console/view.h" +#include "arc/math/point.h" +#include +#include + +struct ARC_ConsoleViewBuffer { + ARC_Point bounds; + char **buffer; +}; + +void ARC_ConsoleViewBuffer_Create(ARC_ConsoleViewBuffer **buffer, ARC_ConsoleView *view){ + *buffer = (ARC_ConsoleViewBuffer *)malloc(sizeof(ARC_ConsoleViewBuffer)); + + ARC_Rect viewBounds = ARC_ConsoleView_GetBounds(view); + (*buffer)->bounds = (ARC_Point){ viewBounds.w - viewBounds.x, viewBounds.h - viewBounds.y }; + + //create the buffer array + (*buffer)->buffer = (char **)malloc(sizeof(char *) * (*buffer)->bounds.y); + for(int32_t y = 0; y < (*buffer)->bounds.y ; y++){ + (*buffer)->buffer[y] = (char *)malloc(sizeof(char) * (*buffer)->bounds.x); + } + + ARC_ConsoleViewBuffer_Clear(*buffer); +} + +void ARC_ConsoleViewBuffer_Destroy(ARC_ConsoleViewBuffer *buffer){ + for(int32_t y = 0; y < buffer->bounds.y; y++){ + free(buffer->buffer[y]); + } + + free(buffer->buffer); + free(buffer); +} + +void ARC_ConsoleViewBuffer_Clear(ARC_ConsoleViewBuffer *buffer){ + for(int32_t y = 0; y < buffer->bounds.y ; y++){ + for(int32_t x = 0; x < buffer->bounds.x; x++){ + buffer->buffer[y][x] = ' '; + } + } +} + +void ARC_ConsoleViewBuffer_Render(ARC_ConsoleViewBuffer *buffer, ARC_ConsoleView *view){ + for(int32_t y = 0; y < buffer->bounds.y ; y++){ + for(int32_t x = 0; x < buffer->bounds.x; x++){ + ARC_ConsoleView_RenderCharAt(view, buffer->buffer[y][x], (ARC_Point){ x, y }); + } + } +} diff --git a/packages/console/ncurses/element.c b/packages/console/ncurses/element.c new file mode 100644 index 0000000..aef8302 --- /dev/null +++ b/packages/console/ncurses/element.c @@ -0,0 +1,52 @@ +#include "arc/console/element.h" +#include "arc/console/view.h" + +#include +#include + +void ARC_ConsoleElement_Create(ARC_ConsoleElement **element, uint32_t type, uint8_t flags, ARC_String *string, ARC_Point pos, ARC_ConsoleElement_RenderFn renderFn){ + *element = (ARC_ConsoleElement *)malloc(sizeof(ARC_ConsoleElement)); + + (*element)->type = type; + (*element)->flags = flags; + (*element)->string = string; + (*element)->pos = pos; + (*element)->renderFn = renderFn; +} + +void ARC_ConsoleElement_Destroy(ARC_ConsoleElement *element){ + free(element); +} + +void ARC_ConsoleElement_DefaultRenderFn(ARC_ConsoleView *view, ARC_ConsoleElement *element){ + if(element->flags & ARC_CONSOLE_ELEMENT_FLAG_SELECTED){ + ARC_ConsoleView_SetAttribute(view, ARC_CONSOLE_VIEW_ATTRIBUTE_REVERSE); + } + + ARC_ConsoleView_RenderStringAt(view, element->string, element->pos); + + if(element->flags & ARC_CONSOLE_ELEMENT_FLAG_SELECTED){ + ARC_ConsoleView_SetAttribute(view, ARC_CONSOLE_VIEW_ATTRIBUTE_NONE); + } +} + +ARC_Bool ARC_ConsoleElement_IsSelectable(ARC_ConsoleElement *element){ + if(element->flags & ARC_CONSOLE_ELEMENT_FLAG_SELECTABLE){ + return ARC_True; + } + + return ARC_False; +} + +void ARC_ConsoleElement_SetSelected(ARC_ConsoleElement *element, ARC_Bool selected){ + if(selected){ + element->flags |= ARC_CONSOLE_ELEMENT_FLAG_SELECTED; + return; + } + + element->flags &= ~ARC_CONSOLE_ELEMENT_FLAG_SELECTED; +} + +void ARC_NCursesElement_ToggleSelected(ARC_ConsoleElement *element){ + element->flags ^= ARC_CONSOLE_ELEMENT_FLAG_SELECTED; +} diff --git a/packages/console/ncurses/key.c b/packages/console/ncurses/key.c new file mode 100644 index 0000000..68e50f6 --- /dev/null +++ b/packages/console/ncurses/key.c @@ -0,0 +1,161 @@ +#include "arc/console/key.h" +#include "key.h" +#include "arc/std/bool.h" +#include +#include + +void ARC_ConsoleKey_Create(ARC_ConsoleKey **consoleKey, ARC_ConsoleKey_Key *key){ + *consoleKey = (ARC_ConsoleKey *)malloc(sizeof(ARC_ConsoleKey)); + (*consoleKey)->key = 0; + + if(key != NULL){ + (*consoleKey)->key = *key; + } +} + +void ARC_ConsoleKey_Destroy(ARC_ConsoleKey *consoleKey){ + free(consoleKey); +} + +ARC_Bool ARC_ConsoleKey_Equals(ARC_ConsoleKey consoleKey, ARC_ConsoleKey_Key key){ + return consoleKey.key == ARC_Keyboard_GetConsoleKey(key).key; +} + +ARC_Bool ARC_ConsoleKey_EqualsPointer(ARC_ConsoleKey *consoleKey, ARC_ConsoleKey_Key key){ + return consoleKey->key == ARC_Keyboard_GetConsoleKey(key).key; +} + +ARC_ConsoleKey ARC_Keyboard_GetConsoleKey(enum ARC_ConsoleKey_Key key){ + switch(key){ + case ARC_KEY_A: + return (ARC_ConsoleKey){ (int32_t)'a' }; + + case ARC_KEY_B: + return (ARC_ConsoleKey){ (int32_t)'b' }; + + case ARC_KEY_C: + return (ARC_ConsoleKey){ (int32_t)'c' }; + + case ARC_KEY_D: + return (ARC_ConsoleKey){ (int32_t)'d' }; + + case ARC_KEY_E: + return (ARC_ConsoleKey){ (int32_t)'e' }; + + case ARC_KEY_F: + return (ARC_ConsoleKey){ (int32_t)'f' }; + + case ARC_KEY_G: + return (ARC_ConsoleKey){ (int32_t)'g' }; + + case ARC_KEY_H: + return (ARC_ConsoleKey){ (int32_t)'h' }; + + case ARC_KEY_I: + return (ARC_ConsoleKey){ (int32_t)'i' }; + + case ARC_KEY_J: + return (ARC_ConsoleKey){ (int32_t)'j' }; + + case ARC_KEY_K: + return (ARC_ConsoleKey){ (int32_t)'k' }; + + case ARC_KEY_L: + return (ARC_ConsoleKey){ (int32_t)'l' }; + + case ARC_KEY_M: + return (ARC_ConsoleKey){ (int32_t)'m' }; + + case ARC_KEY_N: + return (ARC_ConsoleKey){ (int32_t)'n' }; + + case ARC_KEY_O: + return (ARC_ConsoleKey){ (int32_t)'o' }; + + case ARC_KEY_P: + return (ARC_ConsoleKey){ (int32_t)'p' }; + + case ARC_KEY_Q: + return (ARC_ConsoleKey){ (int32_t)'q' }; + + case ARC_KEY_R: + return (ARC_ConsoleKey){ (int32_t)'r' }; + + case ARC_KEY_S: + return (ARC_ConsoleKey){ (int32_t)'s' }; + + case ARC_KEY_T: + return (ARC_ConsoleKey){ (int32_t)'t' }; + + case ARC_KEY_U: + return (ARC_ConsoleKey){ (int32_t)'u' }; + + case ARC_KEY_V: + return (ARC_ConsoleKey){ (int32_t)'v' }; + + case ARC_KEY_W: + return (ARC_ConsoleKey){ (int32_t)'w' }; + + case ARC_KEY_X: + return (ARC_ConsoleKey){ (int32_t)'x' }; + + case ARC_KEY_Y: + return (ARC_ConsoleKey){ (int32_t)'y' }; + + case ARC_KEY_Z: + return (ARC_ConsoleKey){ (int32_t)'z' }; + + case ARC_KEY_0: + return (ARC_ConsoleKey){ (int32_t)'0' }; + + case ARC_KEY_1: + return (ARC_ConsoleKey){ (int32_t)'1' }; + + case ARC_KEY_2: + return (ARC_ConsoleKey){ (int32_t)'2' }; + + case ARC_KEY_3: + return (ARC_ConsoleKey){ (int32_t)'3' }; + + case ARC_KEY_4: + return (ARC_ConsoleKey){ (int32_t)'4' }; + + case ARC_KEY_5: + return (ARC_ConsoleKey){ (int32_t)'5' }; + + case ARC_KEY_6: + return (ARC_ConsoleKey){ (int32_t)'6' }; + + case ARC_KEY_7: + return (ARC_ConsoleKey){ (int32_t)'7' }; + + case ARC_KEY_8: + return (ARC_ConsoleKey){ (int32_t)'8' }; + + case ARC_KEY_9: + return (ARC_ConsoleKey){ (int32_t)'9' }; + + case ARC_KEY_UP: + return (ARC_ConsoleKey){ KEY_UP }; + + case ARC_KEY_DOWN: + return (ARC_ConsoleKey){ KEY_DOWN }; + + case ARC_KEY_LEFT: + return (ARC_ConsoleKey){ KEY_LEFT }; + + case ARC_KEY_RIGHT: + return (ARC_ConsoleKey){ KEY_RIGHT }; + + //TODO: This is escape and alt, need to fix + case ARC_KEY_ESC: + return (ARC_ConsoleKey){ 27 }; + + default: + return (ARC_ConsoleKey){ 0 }; + } +} + +uint8_t ARC_ConsoleKey_GetCharFromKey(ARC_ConsoleKey *consoleKey){ + return consoleKey->key; +} \ No newline at end of file diff --git a/packages/console/ncurses/key.h b/packages/console/ncurses/key.h new file mode 100644 index 0000000..4dab8e1 --- /dev/null +++ b/packages/console/ncurses/key.h @@ -0,0 +1,19 @@ +#ifndef ARC_CONSOLE_NCURSES_KEY_H_ +#define ARC_CONSOLE_NCURSES_KEY_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "arc/console/key.h" +#include + +typedef struct ARC_ConsoleKeyType { + int32_t key; +} ARC_ConsoleKeyType; + +#ifdef __cplusplus +} +#endif + +#endif // !ARC_CONSOLE_NCURSES_KEY_H_ \ No newline at end of file diff --git a/packages/console/ncurses/shell.c b/packages/console/ncurses/shell.c new file mode 100644 index 0000000..a217252 --- /dev/null +++ b/packages/console/ncurses/shell.c @@ -0,0 +1,57 @@ +#include "arc/console/shell.h" + +#include "arc/console/buffer.h" +#include "arc/std/string.h" +#include "arc/std/vector.h" +#include + +void ARC_ConsoleShell_Create(ARC_ConsoleShell **shell, ARC_ConsoleView *view, ARC_ConsoleShell_UpdateFn updateFn){ + *shell = (ARC_ConsoleShell *)malloc(sizeof(ARC_ConsoleShell)); + + (*shell)->view = view; + ARC_ConsoleBuffer_Create(&((*shell)->buffer)); + (*shell)->bufferLineIndex = 0; + + ARC_Vector_Create(&((*shell)->history)); + (*shell)->historyIndex = 0; + + (*shell)->updateFn = updateFn; + (*shell)->currentLine = NULL; + (*shell)->userInput = NULL; +} + +void ARC_ConsoleShell_Destroy(ARC_ConsoleShell *shell){ + ARC_ConsoleBuffer_Destroy(shell->buffer); + + for(uint32_t i = 0; i < ARC_Vector_Size(shell->history); i++){ + ARC_String *temp = (ARC_String *)ARC_Vector_Get(shell->history, i); + + if(temp != NULL){ + ARC_String_Destroy(temp); + } + } + + ARC_Vector_Destroy(shell->history); + free(shell); +} + +void ARC_ConsoleShell_Update(ARC_ConsoleShell *shell){ + shell->updateFn(shell); +} + +void ARC_ConsoleShell_Render(ARC_ConsoleShell *shell){ + ARC_ConsoleBuffer_Render(shell->buffer, shell->view); +} + +void ARC_ConsoleShell_AddHistory(ARC_ConsoleShell *shell, ARC_String *string){ + ARC_Vector_Add(shell->history, (void *)string); +} + +ARC_String *ARC_ConsoleShell_GetHistoryAt(ARC_ConsoleShell *shell, uint32_t index){ + uint32_t maxHistory = ARC_Vector_Size(shell->history); + if(index >= maxHistory){ + return NULL; + } + + return (ARC_String *)ARC_Vector_Get(shell->history, (maxHistory - 1) - index); +} diff --git a/packages/console/ncurses/view.c b/packages/console/ncurses/view.c new file mode 100644 index 0000000..276a63f --- /dev/null +++ b/packages/console/ncurses/view.c @@ -0,0 +1,268 @@ +#include "arc/console/view.h" + +#include "key.h" +#include "arc/console/element.h" +#include "arc/std/bool.h" +#include "arc/std/errno.h" +#include "arc/std/vector.h" +#include "arc/std/string.h" +#include +#include +#include + +uint8_t arc_ncurses_win_size = 0; + +struct ARC_ConsoleView { + WINDOW *window; + ARC_Rect bounds; + ARC_Bool echo; + + ARC_Vector *elements; +}; + +void ARC_ConsoleView_Create(ARC_ConsoleView **view, ARC_Rect bounds){ + if(arc_ncurses_win_size == ~(uint8_t)0){ + arc_errno = ARC_ERRNO_OVERFLOW; + ARC_DEBUG_ERR("ARC_NCurses_Create(ncurses), max num of ARC_NCurses have been created, consider making arc_ncurses_win_size a uint32_t to increase the max"); + *view = NULL; + return; + } + + //if this is the first ncurses, init ncurses + if(arc_ncurses_win_size == 0){ + setlocale(LC_ALL, ""); + initscr(); + //start_color(); + cbreak(); + keypad(stdscr, TRUE); + refresh(); + } + + *view = (ARC_ConsoleView *)malloc(sizeof(ARC_ConsoleView)); + + ARC_Rect viewBounds = { 0, 0, COLS, LINES }; + if(bounds.w != 0 && bounds.h != 0){ + viewBounds = bounds; + } + + (*view)->window = newwin(viewBounds.h, viewBounds.w, viewBounds.y, viewBounds.x); + (*view)->bounds = viewBounds; + + keypad((*view)->window, TRUE); + + noecho(); + (*view)->echo = false; + + ARC_Vector_Create(&(*view)->elements); + + wrefresh((*view)->window); + + arc_ncurses_win_size++; +} + +void ARC_ConsoleView_Destroy(ARC_ConsoleView *ncurses){ + arc_ncurses_win_size--; + + ARC_Vector_Destroy(ncurses->elements); + + delwin(ncurses->window); + free(ncurses); + + if(arc_ncurses_win_size == 0){ + endwin(); + } +} + +void ARC_ConsoleView_AddElement(ARC_ConsoleView *view, ARC_ConsoleElement *element){ + ARC_Vector_Add(view->elements, (void *)element); +} + +void ARC_ConsoleView_RemoveElement(ARC_ConsoleView *view, uint32_t index){ + ARC_Vector_RemoveIndex(view->elements, index); +} + +void ARC_ConsoleView_Clear(ARC_ConsoleView *view){ + wclear(view->window); + wrefresh(view->window); +} + +void ARC_ConsoleView_RenderCharAt(ARC_ConsoleView *view, char character, ARC_Point pos){ + mvwprintw(view->window, pos.y, pos.x, "%c", character); + wrefresh(view->window); +} + +void ARC_ConsoleView_RenderWCharAt(ARC_ConsoleView *view, wchar_t character, ARC_Point pos){ + mvwprintw(view->window, pos.y, pos.x, "%lc", character); + wrefresh(view->window); +} + +void ARC_ConsoleView_RenderKeyAt(ARC_ConsoleView *view, ARC_ConsoleKey key, ARC_Point pos){ + mvwprintw(view->window, pos.y, pos.x, "%c", (char)key.key); + wrefresh(view->window); +} + +void ARC_ConsoleView_RenderUint32At(ARC_ConsoleView *view, uint32_t uint32, ARC_Point pos){ + mvwprintw(view->window, pos.y, pos.x, "%d", uint32); + wrefresh(view->window); +} + +void ARC_ConsoleView_RenderStringAt(ARC_ConsoleView *view, ARC_String *text, ARC_Point pos){ + mvwprintw(view->window, pos.y, pos.x, "%s", text->data); + wrefresh(view->window); +} + +void ARC_ConsoleView_RenderCStringWithStrlenAt(ARC_ConsoleView *view, char *cstr, ARC_Point pos){ + mvwprintw(view->window, pos.y, pos.x, "%s", cstr); + wrefresh(view->window); +} + +void ARC_ConsoleView_RenderRect(ARC_ConsoleView *view, ARC_Rect bounds){ + //render corners + ARC_ConsoleView_RenderWCharAt(view, L'┌', (ARC_Point){ bounds.x, bounds.y }); + ARC_ConsoleView_RenderWCharAt(view, L'└', (ARC_Point){ bounds.x, (bounds.h - 1) + bounds.y }); + ARC_ConsoleView_RenderWCharAt(view, L'┐', (ARC_Point){ (bounds.w - 1) + bounds.x, bounds.y }); + ARC_ConsoleView_RenderWCharAt(view, L'┘', (ARC_Point){ (bounds.w - 1) + bounds.x, (bounds.h - 1) + bounds.y }); + + //render virticle lines + for(int32_t x = 1; x < bounds.w - 1; x++){ + ARC_ConsoleView_RenderWCharAt(view, L'─', (ARC_Point){ bounds.x + x, bounds.y }); + ARC_ConsoleView_RenderWCharAt(view, L'─', (ARC_Point){ bounds.x + x, (bounds.h - 1) + bounds.y }); + } + + //render horizontal lines + for(int32_t y = 1; y < bounds.h - 1; y++){ + ARC_ConsoleView_RenderWCharAt(view, L'│', (ARC_Point){ bounds.x, bounds.y + y }); + ARC_ConsoleView_RenderWCharAt(view, L'│', (ARC_Point){ (bounds.w - 1) + bounds.x, bounds.y + y }); + } +} + +void ARC_ConsoleView_RenderElements(ARC_ConsoleView *view){ + for(uint32_t i = 0; i < ARC_Vector_Size(view->elements); i++){ + ARC_ConsoleElement *element = (ARC_ConsoleElement *)ARC_Vector_Get(view->elements, i); + element->renderFn(view, element); + wrefresh(view->window); + } +} + +ARC_Rect ARC_ConsoleView_GetBounds(ARC_ConsoleView *view){ + return view->bounds; +} + +ARC_ConsoleElement *ARC_ConsoleView_GetElement(ARC_ConsoleView *view, uint32_t index){ + return (ARC_ConsoleElement *)ARC_Vector_Get(view->elements, index); +} + +char ARC_ConsoleView_GetChar(ARC_ConsoleView *view){ + return wgetch(view->window); +} + +char ARC_ConsoleView_GetCharAt(ARC_ConsoleView *view, ARC_Point pos){ + return mvwgetch(view->window, pos.y, pos.x); +} + +ARC_ConsoleKey ARC_ConsoleView_GetConsoleKeyAt(ARC_ConsoleView *view, ARC_Point pos){ + return (ARC_ConsoleKey){ mvwgetch(view->window, pos.y, pos.x) }; +} + +ARC_ConsoleKey *ARC_ConsoleView_GetCreateConsoleKeyAt(ARC_ConsoleView *view, ARC_Point pos){ + ARC_ConsoleKey *key; + ARC_ConsoleKey_Create(&key, NULL); + key->key = mvwgetch(view->window, pos.y, pos.x); + return key; +} + +ARC_String *ARC_ConsoleView_GetStringInput(ARC_ConsoleView *view, ARC_Point pos, ARC_ConsoleView_OverrideCharInputFn *overrideCharInputFn, void *userdata){ + noecho(); + + uint32_t cstringSize = view->bounds.w - pos.x; + char cstring[view->bounds.w - pos.x]; + + ARC_ConsoleKey temp = ARC_ConsoleView_GetConsoleKeyAt(view, pos); + uint32_t index = 0; + while(temp.key != '\n'){ + //store the last size to be able to clear efficeintly + uint32_t lastSize = index; + + //if override function exists and it overrode the current char + if(overrideCharInputFn != NULL && (*overrideCharInputFn)(&temp, cstring, &index, cstringSize, userdata)){ + for(uint32_t i = 0; i < lastSize; i++){ + ARC_ConsoleView_RenderCharAt(view, ' ', (ARC_Point){ pos.x + i, pos.y }); + } + + for(uint32_t i = 0; i < index; i++){ + ARC_ConsoleView_RenderCharAt(view, cstring[i], (ARC_Point){ pos.x + i, pos.y }); + } + + temp = ARC_ConsoleView_GetConsoleKeyAt(view, (ARC_Point){ pos.x + index, pos.y }); + continue; + } + + if(temp.key == KEY_BACKSPACE || temp.key == KEY_DC || temp.key == 127){ + if(index == 0){ + temp = ARC_ConsoleView_GetConsoleKeyAt(view, (ARC_Point){ pos.x + index, pos.y }); + continue; + } + + index--; + ARC_ConsoleView_RenderCharAt(view, ' ', (ARC_Point){ pos.x + index, pos.y }); + cstring[index] = '\0'; + temp = ARC_ConsoleView_GetConsoleKeyAt(view, (ARC_Point){ pos.x + index, pos.y }); + continue; + } + + if(index < (view->bounds.w - 1) - pos.x){ + ARC_ConsoleView_RenderCharAt(view, (char)(temp.key), (ARC_Point){ pos.x + index, pos.y }); + cstring[index] = (char)(temp.key); + index++; + } + + temp = ARC_ConsoleView_GetConsoleKeyAt(view, (ARC_Point){ pos.x + index, pos.y }); + } + + if(view->echo){ + echo(); + } + + if(index == 0){ + return NULL; + } + + ARC_String *string; + ARC_String_Create(&string, cstring, index); + return string; +} + +void ARC_ConsoleView_SetCursorVisibility(ARC_ConsoleView *view, uint8_t visibility){ + switch(visibility){ + case ARC_CONSOLE_VIEW_CURSOR_HIDDEN: + curs_set(0); + break; + case ARC_CONSOLE_VIEW_CURSOR_VISIBLE: + curs_set(1); + break; + } +} + +void ARC_ConsoleView_SetBorder(ARC_ConsoleView *view, uint32_t border){ + switch(border){ + case ARC_CONSOLE_VIEW_BORDER_NONE: + wborder(view->window, ' ', ' ', ' ',' ',' ',' ',' ',' '); + break; + case ARC_CONSOLE_VIEW_BORDER_DEFAULT: + box(view->window, 0, 0); + break; + } + + wrefresh(view->window); +} + +void ARC_ConsoleView_SetAttribute(ARC_ConsoleView *view, uint32_t attribute){ + switch(attribute){ + case ARC_CONSOLE_VIEW_ATTRIBUTE_NONE: + wattroff(view->window, A_REVERSE); + break; + case ARC_CONSOLE_VIEW_ATTRIBUTE_REVERSE: + wattron(view->window, A_REVERSE); + break; + } +} diff --git a/packages/graphics/glfw/config.c b/packages/graphics/glfw/config.c new file mode 100644 index 0000000..193f929 --- /dev/null +++ b/packages/graphics/glfw/config.c @@ -0,0 +1,14 @@ +#ifdef ARC_GLFW_WINDOW + +#include +#include "arc/std/config.h" +#include "arc/std/string.h" +#include "arc/std/errno.h" + +#include "renderer.h" + + +void ARC_GraphicsConfig_Init(ARC_Config *config, ARC_Renderer *renderer){ +} + +#endif // ARC_OPENGL_GRAPHICS \ No newline at end of file diff --git a/packages/graphics/glfw/renderer.c b/packages/graphics/glfw/renderer.c new file mode 100644 index 0000000..0c06f24 --- /dev/null +++ b/packages/graphics/glfw/renderer.c @@ -0,0 +1,52 @@ +#ifdef ARC_GLFW_WINDOW +#include "arc/graphics/renderer.h" +#include "renderer.h" + +// #ifdef ARC_GLEW +#define GLEW_STATIC +#include +// #endif // ARC_GLEW + +#include + +#include "arc/graphics/window.h" +#include "arc/std/errno.h" +#include + +void ARC_Renderer_CreateWithEngineData(ARC_Renderer **renderer, ARC_EngineData *data){ + 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 = (GLFWwindow *)data->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 diff --git a/packages/graphics/glfw/renderer.h b/packages/graphics/glfw/renderer.h new file mode 100644 index 0000000..4ecedb0 --- /dev/null +++ b/packages/graphics/glfw/renderer.h @@ -0,0 +1,29 @@ +#ifndef ARC_OPENGL_RENDERER_H_ +#define ARC_OPENGL_RENDERER_H_ + +#ifdef ARC_GLFW_WINDOW + +#define GLEW_STATIC +#include + +#include + +#include "arc/graphics/renderer.h" +#include "arc/graphics/window.h" + +typedef struct ARC_RendererType { + GLFWwindow *window; +} ARC_RendererType; + +/** + * @brief struct for info needed to create glfw 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_WINDOW + +#endif // !ARC_OPENGL_RENDERER_H_ diff --git a/packages/graphics/glfw/window.c b/packages/graphics/glfw/window.c new file mode 100644 index 0000000..1afc79d --- /dev/null +++ b/packages/graphics/glfw/window.c @@ -0,0 +1,36 @@ +#ifdef ARC_GLFW_WINDOW +#include "arc/graphics/window.h" +#include "window.h" + +#include "arc/std/errno.h" +#include +#include + +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, info->title, 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 diff --git a/packages/graphics/glfw/window.h b/packages/graphics/glfw/window.h new file mode 100644 index 0000000..55ed8d9 --- /dev/null +++ b/packages/graphics/glfw/window.h @@ -0,0 +1,16 @@ +#ifndef ARC_OPENGL_WINDOW_H_ +#define ARC_OPENGL_WINDOW_H_ + +#ifdef ARC_GLFW_WINDOW + +#define GLEW_STATIC +#include + +#include "arc/graphics/window.h" +#include + +typedef GLFWwindow ARC_WindowType; + +#endif // !ARC_GLFW_WINDOW + +#endif // !ARC_GLFW_WINDOW_H_ diff --git a/packages/graphics/opengl/circle.c b/packages/graphics/opengl/circle.c new file mode 100644 index 0000000..c6dee14 --- /dev/null +++ b/packages/graphics/opengl/circle.c @@ -0,0 +1,10 @@ +#ifdef ARC_OPENGL_GRAPHICS + +#include "arc/graphics/circle.h" +#include + +void ARC_Circle_Render(ARC_Circle *circle, ARC_Renderer *renderer, ARC_Color *color){ + printf("OpenGL Backend Selected\n"); +} + +#endif // !ARC_OPENGL_GRAPHICS \ No newline at end of file diff --git a/packages/graphics/opengl/line.c b/packages/graphics/opengl/line.c new file mode 100644 index 0000000..d617d6c --- /dev/null +++ b/packages/graphics/opengl/line.c @@ -0,0 +1,8 @@ +#ifdef ARC_OPENGL_GRAPHICS +#include "arc/graphics/line.h" +#include + +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 \ No newline at end of file diff --git a/packages/graphics/opengl/obround.c b/packages/graphics/opengl/obround.c new file mode 100644 index 0000000..b28a16d --- /dev/null +++ b/packages/graphics/opengl/obround.c @@ -0,0 +1,14 @@ +#ifdef ARC_OPENGL_GRAPHICS + +#include "arc/graphics/obround.h" +#include + +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 \ No newline at end of file diff --git a/packages/graphics/opengl/rectangle.c b/packages/graphics/opengl/rectangle.c new file mode 100644 index 0000000..bca8f6f --- /dev/null +++ b/packages/graphics/opengl/rectangle.c @@ -0,0 +1,11 @@ +#ifdef ARC_OPENGL_GRAPHICS +#include "arc/graphics/rectangle.h" +#include + +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 \ No newline at end of file diff --git a/packages/graphics/opengl/sprite.c b/packages/graphics/opengl/sprite.c new file mode 100644 index 0000000..3507c60 --- /dev/null +++ b/packages/graphics/opengl/sprite.c @@ -0,0 +1,29 @@ +#ifdef ARC_OPENGL_GRAPHICS +#include "arc/graphics/sprite.h" +#include "arc/math/point.h" +#include "arc/math/rectangle.h" +#include + +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 \ No newline at end of file diff --git a/packages/graphics/opengl/sprite.h b/packages/graphics/opengl/sprite.h new file mode 100644 index 0000000..8895174 --- /dev/null +++ b/packages/graphics/opengl/sprite.h @@ -0,0 +1,13 @@ +#ifndef ARC_OPENGL_SPRITE_H_ +#define ARC_OPENGL_SPRITE_H_ + +#ifdef ARC_OPENGL_GRAPHICS + +#include "arc/graphics/sprite.h" + +struct ARC_Sprite { +}; + +#endif // !ARC_OPENGL_GRAPHICS + +#endif // !ARC_OPENGL_SPRITE_H_ diff --git a/packages/graphics/opengl/spritesheet.c b/packages/graphics/opengl/spritesheet.c new file mode 100644 index 0000000..20513ac --- /dev/null +++ b/packages/graphics/opengl/spritesheet.c @@ -0,0 +1,17 @@ +#ifdef ARC_OPENGL_GRAPHICS +#include "arc/graphics/spritesheet.h" +#include "arc/math/point.h" +#include + +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 \ No newline at end of file diff --git a/packages/graphics/opengl/spritesheet.h b/packages/graphics/opengl/spritesheet.h new file mode 100644 index 0000000..a320d8c --- /dev/null +++ b/packages/graphics/opengl/spritesheet.h @@ -0,0 +1,13 @@ +#ifndef ARC_OPENGL_SPRITESHEET_H_ +#define ARC_OPENGL_SPRITESHEET_H_ + +#ifdef ARC_OPENGL_GRAPHICS + +#include "arc/graphics/spritesheet.h" + +struct ARC_Spritesheet { +}; + +#endif // !ARC_OPENGL_GRAPHICS + +#endif // !ARC_OPENGL_SPRITESHEET_H_ diff --git a/packages/graphics/opengl/text.c b/packages/graphics/opengl/text.c new file mode 100644 index 0000000..f5a2284 --- /dev/null +++ b/packages/graphics/opengl/text.c @@ -0,0 +1,26 @@ +#ifdef ARC_OPENGL_GRAPHICS + +#include "arc/graphics/text.h" +#include + +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 \ No newline at end of file diff --git a/packages/graphics/opengl/text.h b/packages/graphics/opengl/text.h new file mode 100644 index 0000000..526b4ce --- /dev/null +++ b/packages/graphics/opengl/text.h @@ -0,0 +1,14 @@ +#ifndef ARC_OPENGL_TEXT_H_ +#define ARC_OPENGL_TEXT_H_ + +#include "arc/std/string.h" +#include "arc/graphics/color.h" +#include "arc/math/rectangle.h" + +#ifdef ARC_OPENGL_GRAPHICS + +typedef struct ARC_Text {} ARC_Text; + +#endif // !ARC_OPENGL_GRAPHICS + +#endif // !ARC_OPENGL_TEXT_H_ diff --git a/packages/graphics/sdl/circle.c b/packages/graphics/sdl/circle.c new file mode 100644 index 0000000..8c208a3 --- /dev/null +++ b/packages/graphics/sdl/circle.c @@ -0,0 +1,49 @@ +#include "arc/graphics/circle.h" +#include "renderer.h" +#include + +//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); + } +} \ No newline at end of file diff --git a/packages/graphics/sdl/config.c b/packages/graphics/sdl/config.c new file mode 100644 index 0000000..f83c124 --- /dev/null +++ b/packages/graphics/sdl/config.c @@ -0,0 +1,311 @@ +#include "arc/graphics/config.h" + +#include +#include +#include "renderer.h" +#include "sprite.h" +#include "spritesheet.h" +#include "arc/std/array.h" +#include "arc/std/string.h" +#include "arc/std/errno.h" +#include "arc/graphics/sprite.h" +#include "arc/graphics/spritesheet.h" +#include "arc/math/config.h" +#include "arc/math/point.h" +#include "arc/math/rectangle.h" + +// #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); +} \ No newline at end of file diff --git a/packages/graphics/sdl/line.c b/packages/graphics/sdl/line.c new file mode 100644 index 0000000..64e21cd --- /dev/null +++ b/packages/graphics/sdl/line.c @@ -0,0 +1,8 @@ +#include "arc/graphics/line.h" +#include "renderer.h" +#include + +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); +} \ No newline at end of file diff --git a/packages/graphics/sdl/obround.c b/packages/graphics/sdl/obround.c new file mode 100644 index 0000000..8148a27 --- /dev/null +++ b/packages/graphics/sdl/obround.c @@ -0,0 +1,48 @@ +#include "arc/graphics/obround.h" +#include "renderer.h" +#include + +//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); +} \ No newline at end of file diff --git a/packages/graphics/sdl/rectangle.c b/packages/graphics/sdl/rectangle.c new file mode 100644 index 0000000..356bd3f --- /dev/null +++ b/packages/graphics/sdl/rectangle.c @@ -0,0 +1,23 @@ +#include "arc/graphics/rectangle.h" +#include "renderer.h" +#include + +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); +} \ No newline at end of file diff --git a/packages/graphics/sdl/renderer.c b/packages/graphics/sdl/renderer.c new file mode 100644 index 0000000..f4263a3 --- /dev/null +++ b/packages/graphics/sdl/renderer.c @@ -0,0 +1,39 @@ +#include "arc/graphics/renderer.h" +#include "renderer.h" + +#include +#include +#include "arc/engine/engine.h" +#include "arc/graphics/window.h" +#include "arc/std/errno.h" + +void ARC_Renderer_CreateWithEngineData(ARC_Renderer **renderer, ARC_EngineData *data){ + if(!data){ + arc_errno = ARC_ERRNO_NULL; + ARC_DEBUG_ERR("ARC_Renderer_CreateWithEngineData(**renderer, NULL)"); + return; + } + + *renderer = (ARC_Renderer *)SDL_CreateRenderer((SDL_Window *)(data->window), -1, SDL_RENDERER_ACCELERATED); + + if(!*renderer){ + arc_errno = ARC_ERRNO_NULL; + ARC_DEBUG_LOG(arc_errno, "SDL_CreateRenderer(%p, %d, %u);", data->window, -1, SDL_RENDERER_ACCELERATED); + 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); +} \ No newline at end of file diff --git a/packages/graphics/sdl/renderer.h b/packages/graphics/sdl/renderer.h new file mode 100644 index 0000000..3a4dda0 --- /dev/null +++ b/packages/graphics/sdl/renderer.h @@ -0,0 +1,10 @@ +#ifndef ARC_SDL_RENDERER_H_ +#define ARC_SDL_RENDERER_H_ + +#include "arc/graphics/renderer.h" +#include "arc/graphics/window.h" +#include + +typedef SDL_Renderer ARC_RendererType; + +#endif // !ARC_SDL_RENDERER_H_ diff --git a/packages/graphics/sdl/sprite.c b/packages/graphics/sdl/sprite.c new file mode 100644 index 0000000..91b2832 --- /dev/null +++ b/packages/graphics/sdl/sprite.c @@ -0,0 +1,90 @@ +#include "arc/graphics/sprite.h" + +#include "sprite.h" +#include "spritesheet.h" +#include "renderer.h" +#include "arc/math/point.h" +#include "arc/math/rectangle.h" +#include "arc/std/errno.h" +#include + +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; +} \ No newline at end of file diff --git a/packages/graphics/sdl/sprite.h b/packages/graphics/sdl/sprite.h new file mode 100644 index 0000000..d2731b5 --- /dev/null +++ b/packages/graphics/sdl/sprite.h @@ -0,0 +1,15 @@ +#ifndef ARC_SDL_SPRITE_H_ +#define ARC_SDL_SPRITE_H_ + +#include "arc/graphics/sprite.h" +#include + +struct ARC_Sprite { + ARC_Spritesheet *spritesheet; + ARC_Array *frames; + uint32_t *frameIndex; + //TODO: temp + uint8_t opacity; +}; + +#endif // !ARC_SDL_SPRITE_H_ \ No newline at end of file diff --git a/packages/graphics/sdl/spritesheet.c b/packages/graphics/sdl/spritesheet.c new file mode 100644 index 0000000..952664b --- /dev/null +++ b/packages/graphics/sdl/spritesheet.c @@ -0,0 +1,20 @@ +#include "arc/graphics/spritesheet.h" + +#include "spritesheet.h" +#include "renderer.h" +#include "arc/math/point.h" +#include + +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; +} \ No newline at end of file diff --git a/packages/graphics/sdl/spritesheet.h b/packages/graphics/sdl/spritesheet.h new file mode 100644 index 0000000..51094a1 --- /dev/null +++ b/packages/graphics/sdl/spritesheet.h @@ -0,0 +1,12 @@ +#ifndef ARC_SDL_SPRITESHEET_H_ +#define ARC_SDL_SPRITESHEET_H_ + +#include "arc/graphics/spritesheet.h" +#include + +struct ARC_Spritesheet { + SDL_Texture *texture; + uint32_t *size; +}; + +#endif // !ARC_SDL_SPRITESHEET_H_ diff --git a/packages/graphics/sdl/text.c b/packages/graphics/sdl/text.c new file mode 100644 index 0000000..f2a8bba --- /dev/null +++ b/packages/graphics/sdl/text.c @@ -0,0 +1,57 @@ +#include "arc/graphics/text.h" + +#include "text.h" +#include "arc/graphics/color.h" +#include "arc/math/point.h" +#include "arc/math/rectangle.h" +#include "arc/std/string.h" + +#include + +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; +} \ No newline at end of file diff --git a/packages/graphics/sdl/text.h b/packages/graphics/sdl/text.h new file mode 100644 index 0000000..d43b7d6 --- /dev/null +++ b/packages/graphics/sdl/text.h @@ -0,0 +1,20 @@ +#ifndef ARC_SDL_TEXT_H_ +#define ARC_SDL_TEXT_H_ + +#include "arc/std/string.h" +#include "arc/graphics/color.h" +#include "arc/math/rectangle.h" + +#include + +typedef struct ARC_Text { + ARC_String *name; + int32_t size; + + ARC_Color color; + + SDL_Texture *texture; + ARC_Rect bounds; +} ARC_Text; + +#endif // !ARC_SDL_TEXT_H_ \ No newline at end of file diff --git a/packages/graphics/sdl/view.c b/packages/graphics/sdl/view.c new file mode 100644 index 0000000..b581e10 --- /dev/null +++ b/packages/graphics/sdl/view.c @@ -0,0 +1,35 @@ +#include "arc/graphics/view.h" + +#include "arc/std/errno.h" +#include +#include + +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; +} \ No newline at end of file diff --git a/packages/graphics/sdl/window.c b/packages/graphics/sdl/window.c new file mode 100644 index 0000000..43f9adc --- /dev/null +++ b/packages/graphics/sdl/window.c @@ -0,0 +1,31 @@ +#include "arc/graphics/window.h" + +#include "window.h" +#include "arc/std/errno.h" +#include + +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, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, info->w, info->h, 0); + + if(!*window){ + arc_errno = ARC_ERRNO_NULL; + ARC_DEBUG_LOG(arc_errno, "SDL_CreateWindow(%s, %d, %d, %d, %d, %x);", info->title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, info->w, info->h, 0); + free(window); + } +} + +void ARC_Window_Destroy(ARC_Window *window){ + SDL_DestroyWindow((SDL_Window *) window); +} \ No newline at end of file diff --git a/packages/graphics/sdl/window.h b/packages/graphics/sdl/window.h new file mode 100644 index 0000000..1c7b23c --- /dev/null +++ b/packages/graphics/sdl/window.h @@ -0,0 +1,9 @@ +#ifndef ARC_SDL_WINDOW_H_ +#define ARC_SDL_WINDOW_H_ + +#include "arc/graphics/window.h" +#include + +typedef SDL_Window ARC_WindowType; + +#endif // !ARC_SDL_WINDOW_H_ diff --git a/packages/input/glfw/input.c b/packages/input/glfw/input.c new file mode 100644 index 0000000..e3e8ea5 --- /dev/null +++ b/packages/input/glfw/input.c @@ -0,0 +1,42 @@ +#ifdef ARC_GLFW_INPUT +#include "arc/input/input.h" + +#include "arc/input/mouse.h" +#include "arc/input/keyboard.h" + +#include +#include + +struct ARC_Input { + ARC_Keyboard *keyboard; + ARC_Mouse *mouse; + + GLFWwindow *window; +}; + +void ARC_Input_CreateWithEngineData(ARC_Input **input, ARC_EngineData *data){ + *input = (ARC_Input *)malloc(sizeof(ARC_Input)); + + (*input)->event = (SDL_Event *)malloc(sizeof(SDL_Event)); + + ARC_Keyboard_CreateWithEngineData(&(*input)->keyboard, data); + ARC_Keyboard_CreateWithEngineData(&(*input)->mouse, data); +} + +void ARC_Input_Destroy(ARC_Input *input){ + ARC_Keyboard_Destroy(input->keyboard); + ARC_Mouse_Destroy(input->mouse); + + free(input->event); + free(input); +} + +ARC_Keyboard *ARC_Input_GetKeyboard(ARC_Input *input){ + return input->keyboard; +} + +ARC_Mouse *ARC_Input_GetMouse(ARC_Input *input){ + return input->mouse; +} + +#endif // ARC_SDL2_INPUT \ No newline at end of file diff --git a/packages/input/glfw/keyboard.c b/packages/input/glfw/keyboard.c new file mode 100644 index 0000000..75a0386 --- /dev/null +++ b/packages/input/glfw/keyboard.c @@ -0,0 +1,23 @@ +#ifdef ARC_GLFW_INPUT +#include "arc/input/keyboard.h" + +#include "keyboard.h" +#include "arc/math/point.h" +#include "arc/std/errno.h" +#include +#include + +void ARC_Keyboard_CreateWithInput(ARC_Keyboard **keyboard, ARC_Input *input){ +} + +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 \ No newline at end of file diff --git a/packages/input/glfw/keyboard.h b/packages/input/glfw/keyboard.h new file mode 100644 index 0000000..451fb65 --- /dev/null +++ b/packages/input/glfw/keyboard.h @@ -0,0 +1,21 @@ +#ifndef ARC_GLFW_KEYBOARD_H_ +#define ARC_GLFW_KEYBOARD_H_ + +#ifdef ARC_GLFW_INPUT +#include +#include "arc/input/keyboard.h" + +struct ARC_Keyboard { + GLFWwindow *window; + + ARC_KeyboardState *keys; + ARC_KeyboardState *released; +}; + +struct ARC_KeyboardInfo { + GLFWwindow *window; +}; + +#endif // !ARC_GLFW_INPUT + +#endif // !ARC_GLFW_KEYBOARD_H_ \ No newline at end of file diff --git a/packages/input/glfw/mouse.c b/packages/input/glfw/mouse.c new file mode 100644 index 0000000..7c76e38 --- /dev/null +++ b/packages/input/glfw/mouse.c @@ -0,0 +1,34 @@ +#ifdef ARC_GLFW_INPUT +#include "arc/input/mouse.h" + +#include "mouse.h" +#include "arc/math/point.h" +#include "arc/std/errno.h" +#include +#include + +void ARC_Mouse_CreateWithInput(ARC_Keyboard **keyboard, ARC_Input *input){ +} + +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 \ No newline at end of file diff --git a/packages/input/glfw/mouse.h b/packages/input/glfw/mouse.h new file mode 100644 index 0000000..281ae00 --- /dev/null +++ b/packages/input/glfw/mouse.h @@ -0,0 +1,25 @@ +#ifndef ARC_GLFW_MOUSE_H_ +#define ARC_GLFW_MOUSE_H_ + +#ifdef ARC_GLFW_INPUT +#include +#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_INPUT + +#endif // !ARC_GLFW_MOUSE_H_ \ No newline at end of file diff --git a/packages/input/sdl/input.c b/packages/input/sdl/input.c new file mode 100644 index 0000000..837ed08 --- /dev/null +++ b/packages/input/sdl/input.c @@ -0,0 +1,40 @@ +#include "arc/input/input.h" +#include "input.h" + +#include "arc/input/mouse.h" +#include "arc/input/keyboard.h" + +#include +#include + +void ARC_Input_CreateWithEngineData(ARC_Input **input, ARC_EngineData *data){ + *input = (ARC_Input *)malloc(sizeof(ARC_Input)); + + (*input)->event = (SDL_Event *)malloc(sizeof(SDL_Event)); + + ARC_Keyboard_CreateWithInput(&((*input)->keyboard), *input); + ARC_Mouse_CreateWithInput(&((*input)->mouse), *input); +} + +void ARC_Input_Destroy(ARC_Input *input){ + ARC_Keyboard_Destroy(input->keyboard); + ARC_Mouse_Destroy(input->mouse); + + free(input->event); + free(input); +} + +void ARC_Input_Update(ARC_Input *input){ + SDL_PollEvent(input->event); + + ARC_Keyboard_Update(input->keyboard); + ARC_Mouse_Update(input->mouse); +} + +ARC_Keyboard *ARC_Input_GetKeyboard(ARC_Input *input){ + return input->keyboard; +} + +ARC_Mouse *ARC_Input_GetMouse(ARC_Input *input){ + return input->mouse; +} \ No newline at end of file diff --git a/packages/input/sdl/input.h b/packages/input/sdl/input.h new file mode 100644 index 0000000..1309750 --- /dev/null +++ b/packages/input/sdl/input.h @@ -0,0 +1,15 @@ +#ifndef ARC_SDL_INPUT_H_ +#define ARC_SDL_INPUT_H_ + +#include "arc/input/keyboard.h" +#include "arc/input/mouse.h" +#include + +struct ARC_Input { + ARC_Keyboard *keyboard; + ARC_Mouse *mouse; + + SDL_Event *event; +}; + +#endif // !ARC_SDL_INPUT_H_ \ No newline at end of file diff --git a/packages/input/sdl/keyboard.c b/packages/input/sdl/keyboard.c new file mode 100644 index 0000000..33c8d0f --- /dev/null +++ b/packages/input/sdl/keyboard.c @@ -0,0 +1,98 @@ +#include "arc/input/keyboard.h" +#include "keyboard.h" +#include "input.h" +#include "arc/math/point.h" +#include "arc/std/errno.h" +#include +#include +#include +#include + +void ARC_Keyboard_CreateWithInput(ARC_Keyboard **keyboard, ARC_Input *input){ + *keyboard = (ARC_Keyboard *)malloc(sizeof(ARC_Keyboard)); + (*keyboard)->event = input->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; + } +} \ No newline at end of file diff --git a/packages/input/sdl/keyboard.h b/packages/input/sdl/keyboard.h new file mode 100644 index 0000000..7feda24 --- /dev/null +++ b/packages/input/sdl/keyboard.h @@ -0,0 +1,14 @@ +#ifndef ARC_SDL_KEYBOARD_H_ +#define ARC_SDL_KEYBOARD_H_ + +#include "arc/input/keyboard.h" +#include + +struct ARC_Keyboard { + SDL_Event *event; + + ARC_KeyboardState *keys; + ARC_KeyboardState *released; +}; + +#endif // !ARC_SDL_KEYBOARD_H_ \ No newline at end of file diff --git a/packages/input/sdl/mouse.c b/packages/input/sdl/mouse.c new file mode 100644 index 0000000..f69e416 --- /dev/null +++ b/packages/input/sdl/mouse.c @@ -0,0 +1,105 @@ +#include "arc/input/mouse.h" + +#include "mouse.h" +#include "input.h" +#include "arc/math/point.h" +#include "arc/std/errno.h" +#include +#include +#include +#include + +void ARC_Mouse_CreateWithInput(ARC_Mouse **mouse, ARC_Input *input){ + *mouse = (ARC_Mouse *)malloc(sizeof(ARC_Mouse)); + (*mouse)->event = input->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; +} \ No newline at end of file diff --git a/packages/input/sdl/mouse.h b/packages/input/sdl/mouse.h new file mode 100644 index 0000000..7089d42 --- /dev/null +++ b/packages/input/sdl/mouse.h @@ -0,0 +1,17 @@ +#ifndef ARC_SDL_MOUSE_H_ +#define ARC_SDL_MOUSE_H_ + +#include +#include "arc/input/mouse.h" +#include "arc/math/point.h" + +struct ARC_Mouse { + SDL_Event *event; + ARC_Point *coords; + int32_t *scrollY; + + ARC_MouseState *buttons; + uint8_t *buttonsReleased; +}; + +#endif // !ARC_SDL_MOUSE_H_ \ No newline at end of file diff --git a/packages/networking/libssh/ssh.c b/packages/networking/libssh/ssh.c new file mode 100644 index 0000000..4f09a4f --- /dev/null +++ b/packages/networking/libssh/ssh.c @@ -0,0 +1,207 @@ +#include "arc/networking/ssh.h" + +#include "arc/std/errno.h" +#include +#include +#include +#include +#include + +struct ARC_Ssh { + ssh_session session; +}; + +int verify_knownhost(ssh_session session){ + enum ssh_known_hosts_e state; + unsigned char *hash = NULL; + ssh_key srv_pubkey = NULL; + size_t hlen; + char buf[10]; + char *hexa; + char *p; + int cmp; + int rc; + + rc = ssh_get_server_publickey(session, &srv_pubkey); + if(rc < 0){ + return -1; + } + + rc = ssh_get_publickey_hash(srv_pubkey, SSH_PUBLICKEY_HASH_SHA1, &hash, &hlen); + ssh_key_free(srv_pubkey); + if(rc < 0){ + return -1; + } + + state = ssh_session_is_known_server(session); + switch(state){ + case SSH_KNOWN_HOSTS_OK: + /* OK */ + break; + + case SSH_KNOWN_HOSTS_CHANGED: + fprintf(stderr, "Host key for server changed: it is now:\n"); + //ssh_print_hexa("Public key hash", hash, hlen); + fprintf(stderr, "For security reasons, connection will be stopped\n"); + ssh_clean_pubkey_hash(&hash); + return -1; + + case SSH_KNOWN_HOSTS_OTHER: + fprintf(stderr, "The host key for this server was not found but an other type of key exists.\n"); + fprintf(stderr, "An attacker might change the default server key to confuse your client into thinking the key does not exist\n"); + ssh_clean_pubkey_hash(&hash); + return -1; + + case SSH_KNOWN_HOSTS_NOT_FOUND: + fprintf(stderr, "Could not find known host file.\n"); + fprintf(stderr, "If you accept the host key here, the file will be automatically created.\n"); + /* FALL THROUGH to SSH_SERVER_NOT_KNOWN behavior */ + + case SSH_KNOWN_HOSTS_UNKNOWN: + hexa = ssh_get_hexa(hash, hlen); + fprintf(stderr,"The server is unknown. Do you trust the host key?\n"); + fprintf(stderr, "Public key hash: %s\n", hexa); + ssh_string_free_char(hexa); + ssh_clean_pubkey_hash(&hash); + p = fgets(buf, sizeof(buf), stdin); + if(p == NULL){ + return -1; + } + + cmp = strncasecmp(buf, "yes", 3); + if(cmp != 0){ + return -1; + } + + rc = ssh_session_update_known_hosts(session); + if(rc < 0){ + fprintf(stderr, "Error %s\n", strerror(errno)); + return -1; + } + break; + + case SSH_KNOWN_HOSTS_ERROR: + fprintf(stderr, "Error %s", ssh_get_error(session)); + ssh_clean_pubkey_hash(&hash); + return -1; + } + + ssh_clean_pubkey_hash(&hash); + return 0; +} + +void ARC_Ssh_Create(ARC_Ssh **ssh, char *host, char *user, char *password){ + *ssh = (ARC_Ssh *)malloc(sizeof(ARC_Ssh)); + + (*ssh)->session = ssh_new(); + if((*ssh)->session == NULL){ + arc_errno = ARC_ERRNO_NULL; + ARC_DEBUG_ERR("ARC_Ssh_Create(ssh), ssh session could not be created\n"); + free(*ssh); + *ssh = NULL; + return; + } + + if(host != NULL){ + ssh_options_set((*ssh)->session, SSH_OPTIONS_HOST, host); + } + + if(user != NULL){ + ssh_options_set((*ssh)->session, SSH_OPTIONS_USER, user); + } + + int32_t returnCode = ssh_connect((*ssh)->session); + if(returnCode != SSH_OK){ + arc_errno = ARC_ERRNO_CONNECTION; + ARC_DEBUG_LOG(arc_errno, "ARC_Ssh_Create(ssh), ssh failed to connect to localhost: %s\n", ssh_get_error((*ssh)->session)); + ssh_free((*ssh)->session); + free(*ssh); + *ssh = NULL; + return; + } + + if(verify_knownhost((*ssh)->session) < 0){ + arc_errno = ARC_ERRNO_CONNECTION; + ARC_DEBUG_ERR("ARC_Ssh_Create(ssh), ssh failed to verify knownhost\n"); + ssh_disconnect((*ssh)->session); + ssh_free((*ssh)->session); + free(*ssh); + *ssh = NULL; + } + + returnCode = ssh_userauth_password((*ssh)->session, NULL, password); + if(returnCode != SSH_AUTH_SUCCESS){ + arc_errno = ARC_ERRNO_CONNECTION; + ARC_DEBUG_LOG(arc_errno, "ARC_Ssh_Create(ssh), ssh failed to authenticate with password: %s\n", ssh_get_error((*ssh)->session)); + ssh_disconnect((*ssh)->session); + ssh_free((*ssh)->session); + free(*ssh); + *ssh = NULL; + } +} + +void ARC_Ssh_Destroy(ARC_Ssh *ssh){ + if(ssh == NULL){ + return; + } + + ssh_disconnect(ssh->session); + ssh_free(ssh->session); + free(ssh); +} + +void ARC_Ssh_RunInSession(ARC_Ssh *ssh, ARC_Ssh_SessionFn sessionFn){ + ssh_channel channel; + + channel = ssh_channel_new(ssh->session); + if(channel == NULL){ + arc_errno = ARC_ERRNO_NULL; + ARC_DEBUG_ERR("ARC_Ssh_RunInSession(ssh, sessionFn), ssh failed to create channel\n"); + return; + } + + int32_t returnCode = ssh_channel_open_session(channel); + if(returnCode != SSH_OK){ + ssh_channel_free(channel); + arc_errno = ARC_ERRNO_CONNECTION; + ARC_DEBUG_LOG(arc_errno, "ARC_Ssh_RunInSession(ssh, sessionFn), ssh failed to open session with return code: %d\n", returnCode); + return; + } + + // sessionFn(ssh, ); + returnCode = ssh_channel_request_exec(channel, "export DISPLAY=:0 ; volume --inc"); + printf("return code: %d\n", returnCode); + + ssh_channel_send_eof(channel); + ssh_channel_close(channel); + ssh_channel_free(channel); +} + +void ARC_Ssh_ExecStrInNewSession(ARC_Ssh *ssh, char *command){ + ssh_channel channel; + + channel = ssh_channel_new(ssh->session); + if(channel == NULL){ + arc_errno = ARC_ERRNO_NULL; + ARC_DEBUG_ERR("ARC_Ssh_RunInSession(ssh, sessionFn), ssh failed to create channel\n"); + return; + } + + int32_t returnCode = ssh_channel_open_session(channel); + if(returnCode != SSH_OK){ + ssh_channel_free(channel); + arc_errno = ARC_ERRNO_CONNECTION; + ARC_DEBUG_LOG(arc_errno, "ARC_Ssh_RunInSession(ssh, sessionFn), ssh failed to open session with return code: %d\n", returnCode); + return; + } + + returnCode = ssh_channel_request_exec(channel, command); + if(returnCode != SSH_OK){ + arc_errno = ARC_ERRNO_DATA; + ARC_DEBUG_LOG(arc_errno, "ARC_Ssh_RunInSession(ssh, sessionFn), ssh failed when executing command with error code: %d\n", returnCode); + } + + ssh_channel_send_eof(channel); + ssh_channel_close(channel); + ssh_channel_free(channel); +} diff --git a/src/graphics/circle.c b/src/graphics/circle.c new file mode 100644 index 0000000..ffe771b --- /dev/null +++ b/src/graphics/circle.c @@ -0,0 +1,10 @@ +#ifdef ARC_NONE_GRAPHICS + +#include "arc/graphics/circle.h" +#include + +void ARC_Circle_Render(ARC_Circle *circle, ARC_Renderer *renderer, ARC_Color *color){ + printf("No Graphics Backend Selected\n"); +} + +#endif // !ARC_NONE_GRAPHICS \ No newline at end of file diff --git a/src/graphics/config.c b/src/graphics/config.c new file mode 100644 index 0000000..c307299 --- /dev/null +++ b/src/graphics/config.c @@ -0,0 +1,10 @@ +#ifdef ARC_NONE_GRAPHICS + +#include "arc/graphics/config.h" +#include + +void ARC_GraphicsConfig_Init(ARC_Config *config, ARC_Renderer *renderer){ + printf("No Graphics Backend Selected\n"); +} + +#endif //ARC_NONE_GRAPHICS \ No newline at end of file diff --git a/src/graphics/line.c b/src/graphics/line.c new file mode 100644 index 0000000..2f59143 --- /dev/null +++ b/src/graphics/line.c @@ -0,0 +1,10 @@ +#ifdef ARC_NONE_GRAPHICS + +#include "arc/graphics/line.h" +#include + +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 \ No newline at end of file diff --git a/src/graphics/obround.c b/src/graphics/obround.c new file mode 100644 index 0000000..4192c4f --- /dev/null +++ b/src/graphics/obround.c @@ -0,0 +1,14 @@ +#ifdef ARC_NONE_GRAPHICS + +#include "arc/graphics/obround.h" +#include + +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 \ No newline at end of file diff --git a/src/graphics/rectangle.c b/src/graphics/rectangle.c new file mode 100644 index 0000000..a59b6f4 --- /dev/null +++ b/src/graphics/rectangle.c @@ -0,0 +1,22 @@ +#ifdef ARC_NONE_GRAPHICS + +#include "arc/graphics/rectangle.h" +#include + +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 \ No newline at end of file diff --git a/src/graphics/renderer.c b/src/graphics/renderer.c new file mode 100644 index 0000000..38d290a --- /dev/null +++ b/src/graphics/renderer.c @@ -0,0 +1,22 @@ +#ifdef ARC_NONE_GRAPHICS + +#include "arc/graphics/renderer.h" +#include + +void ARC_Renderer_CreateWithEngineData(ARC_Renderer **renderer, ARC_EngineData *data){ + 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 diff --git a/src/graphics/sprite.c b/src/graphics/sprite.c new file mode 100644 index 0000000..0b3cb6f --- /dev/null +++ b/src/graphics/sprite.c @@ -0,0 +1,48 @@ +#ifdef ARC_NONE_GRAPHICS + +#include "arc/graphics/sprite.h" +#include + +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 \ No newline at end of file diff --git a/src/graphics/spritesheet.c b/src/graphics/spritesheet.c new file mode 100644 index 0000000..a08d5ce --- /dev/null +++ b/src/graphics/spritesheet.c @@ -0,0 +1,21 @@ +#ifdef ARC_NONE_GRAPHICS + +#include "arc/graphics/spritesheet.h" +#include "arc/math/point.h" +#include + +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 \ No newline at end of file diff --git a/src/graphics/text.c b/src/graphics/text.c new file mode 100644 index 0000000..46efeea --- /dev/null +++ b/src/graphics/text.c @@ -0,0 +1,26 @@ +#ifdef ARC_NONE_GRAPHICS + +#include "arc/graphics/text.h" +#include + +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 \ No newline at end of file diff --git a/src/graphics/window.c b/src/graphics/window.c new file mode 100644 index 0000000..1413c8a --- /dev/null +++ b/src/graphics/window.c @@ -0,0 +1,14 @@ +#ifdef ARC_NONE_WINDOW + +#include "arc/graphics/window.h" +#include + +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 \ No newline at end of file diff --git a/src/input/input.c b/src/input/input.c new file mode 100644 index 0000000..dcea03a --- /dev/null +++ b/src/input/input.c @@ -0,0 +1,26 @@ +#include "arc/input/input.h" + +#include + +void ARC_Input_CreateWithEngineData(ARC_Input **input, ARC_EngineData *data){ + printf("No Input Backend Selected\n"); +} + +void ARC_Input_Destroy(ARC_Input *input){ + printf("No Input Backend Selected\n"); +} + +void ARC_Input_Update(ARC_Input *input){ + printf("No Input Backend Selected\n"); +} + +ARC_Keyboard *ARC_Input_GetKeyboard(ARC_Input *input){ + printf("No Input Backend Selected\n"); + return NULL; +} + +ARC_Mouse *ARC_Input_GetMouse(ARC_Input *input){ + printf("No Input Backend Selected\n"); + return NULL; +} + diff --git a/src/input/keyboard.c b/src/input/keyboard.c new file mode 100644 index 0000000..668c485 --- /dev/null +++ b/src/input/keyboard.c @@ -0,0 +1,23 @@ +#ifdef ARC_NONE_INPUT + +#include "arc/input/keyboard.h" +#include + +void ARC_Keyboard_CreateWithInput(ARC_Keyboard **keyboard, ARC_Input *input){ + 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 \ No newline at end of file diff --git a/src/input/mouse.c b/src/input/mouse.c new file mode 100644 index 0000000..e9f1d9a --- /dev/null +++ b/src/input/mouse.c @@ -0,0 +1,37 @@ +#ifdef ARC_NONE_INPUT + +#include "arc/input/mouse.h" +#include + +void ARC_Mouse_CreateWithInput(ARC_Mouse **mouse, ARC_Input *input){ + 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 diff --git a/src/std/time.c b/src/std/time.c new file mode 100644 index 0000000..9edca59 --- /dev/null +++ b/src/std/time.c @@ -0,0 +1,18 @@ +#include "arc/std/time.h" + +ARC_Time ARC_Time_CopyFromStructTmPtr(struct tm *time){ + return (ARC_Time){ + time->tm_sec, + time->tm_min, + time->tm_hour, + + time->tm_yday, + time->tm_mon, + time->tm_year, + + time->tm_wday, + time->tm_mday, + + time->tm_isdst + }; +}