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

f***ed up and needed to rework packages

Browse source
This commit is contained in:
herbglitch 2024-05-20 03:46:09 -06:00
parent b43ab1702f
commit f7a87d7519
78 changed files with 3713 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

0
cmake/archeus_libssh.cmake Normal file
View file

21
cmake/archeus_ncurses.cmake Normal file
View file

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

102
include/arc/console/buffer/line.h Normal file
View file

@ -0,0 +1,102 @@
#ifndef ARC_CONSOLE_LINE_BUFFER_H_
#define ARC_CONSOLE_LINE_BUFFER_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#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_

98
include/arc/console/buffer/view.h Normal file
View file

@ -0,0 +1,98 @@
#ifndef ARC_CONSOLE_VIEW_BUFFER_H_
#define ARC_CONSOLE_VIEW_BUFFER_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#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_

78
include/arc/console/element.h Normal file
View file

@ -0,0 +1,78 @@
#ifndef ARC_NCURSES_ELEMENT_H_
#define ARC_NCURSES_ELEMENT_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#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_

76
include/arc/console/key.h Normal file
View file

@ -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 <stdint.h>
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_

97
include/arc/console/shell.h Normal file
View file

@ -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 <stdint.h>
/**
* @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_

267
include/arc/console/view.h Normal file
View file

@ -0,0 +1,267 @@
#ifndef ARC_CONSOLE_VIEW_H_
#define ARC_CONSOLE_VIEW_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <wchar.h>
#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_

32
include/arc/input/input.h Normal file
View file

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

51
include/arc/networking/ssh.h Normal file
View file

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

55
include/arc/std/time.h Normal file
View file

@ -0,0 +1,55 @@
#ifndef ARC_STD_TIME_H_
#define ARC_STD_TIME_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <time.h>
/**
* @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_

7
packages/audio/sdl/audio.c Normal file
View file

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

10
packages/audio/sdl/audio.h Normal file
View file

@ -0,0 +1,10 @@
#ifndef ARC_SDL_AUDIO_H_
#define ARC_SDL_AUDIO_H_
#include <SDL2/SDL_mixer.h>
typedef struct ARC_Audio {
Mix_Chunk *chunk;
} ARC_Audio;
#endif // !ARC_SDL_AUDIO_H_

43
packages/audio/sdl/config.c Normal file
View file

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

147
packages/console/ncurses/buffer/line.c Normal file
View file

@ -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 <stdlib.h>
#include <string.h>
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);
}

51
packages/console/ncurses/buffer/view.c Normal file
View file

@ -0,0 +1,51 @@
#include "arc/console/buffer/view.h"
#include "arc/console/view.h"
#include "arc/math/point.h"
#include <stdlib.h>
#include <stdint.h>
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 });
}
}
}

52
packages/console/ncurses/element.c Normal file
View file

@ -0,0 +1,52 @@
#include "arc/console/element.h"
#include "arc/console/view.h"
#include <stdlib.h>
#include <ncurses.h>
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;
}

161
packages/console/ncurses/key.c Normal file
View file

@ -0,0 +1,161 @@
#include "arc/console/key.h"
#include "key.h"
#include "arc/std/bool.h"
#include <ncurses.h>
#include <stdlib.h>
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;
}

19
packages/console/ncurses/key.h Normal file
View file

@ -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 <stdint.h>
typedef struct ARC_ConsoleKeyType {
int32_t key;
} ARC_ConsoleKeyType;
#ifdef __cplusplus
}
#endif
#endif // !ARC_CONSOLE_NCURSES_KEY_H_

57
packages/console/ncurses/shell.c Normal file
View file

@ -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 <stdlib.h>
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);
}

268
packages/console/ncurses/view.c Normal file
View file

@ -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 <locale.h>
#include <ncurses.h>
#include <stdlib.h>
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;
}
}

14
packages/graphics/glfw/config.c Normal file
View file

@ -0,0 +1,14 @@
#ifdef ARC_GLFW_WINDOW
#include <stdio.h>
#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

52
packages/graphics/glfw/renderer.c Normal file
View file

@ -0,0 +1,52 @@
#ifdef ARC_GLFW_WINDOW
#include "arc/graphics/renderer.h"
#include "renderer.h"
// #ifdef ARC_GLEW
#define GLEW_STATIC
#include <GL/glew.h>
// #endif // ARC_GLEW
#include <GLFW/glfw3.h>
#include "arc/graphics/window.h"
#include "arc/std/errno.h"
#include <stdlib.h>
void ARC_Renderer_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

29
packages/graphics/glfw/renderer.h Normal file
View file

@ -0,0 +1,29 @@
#ifndef ARC_OPENGL_RENDERER_H_
#define ARC_OPENGL_RENDERER_H_
#ifdef ARC_GLFW_WINDOW
#define GLEW_STATIC
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#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_

36
packages/graphics/glfw/window.c Normal file
View file

@ -0,0 +1,36 @@
#ifdef ARC_GLFW_WINDOW
#include "arc/graphics/window.h"
#include "window.h"
#include "arc/std/errno.h"
#include <GLFW/glfw3.h>
#include <stdio.h>
void framebufferSizeCallback(GLFWwindow *window, int width, int height){
glViewport(0, 0, width, height);
}
void ARC_Window_Create(ARC_Window **window, ARC_WindowInfo *info){
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_FLOATING, GLFW_TRUE);
*window = (ARC_Window *) glfwCreateWindow(info->w, info->h, 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

16
packages/graphics/glfw/window.h Normal file
View file

@ -0,0 +1,16 @@
#ifndef ARC_OPENGL_WINDOW_H_
#define ARC_OPENGL_WINDOW_H_
#ifdef ARC_GLFW_WINDOW
#define GLEW_STATIC
#include <GL/glew.h>
#include "arc/graphics/window.h"
#include <GLFW/glfw3.h>
typedef GLFWwindow ARC_WindowType;
#endif // !ARC_GLFW_WINDOW
#endif // !ARC_GLFW_WINDOW_H_

10
packages/graphics/opengl/circle.c Normal file
View file

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

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

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

14
packages/graphics/opengl/obround.c Normal file
View file

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

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

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

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

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

13
packages/graphics/opengl/sprite.h Normal file
View file

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

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

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

13
packages/graphics/opengl/spritesheet.h Normal file
View file

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

26
packages/graphics/opengl/text.c Normal file
View file

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

14
packages/graphics/opengl/text.h Normal file
View file

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

49
packages/graphics/sdl/circle.c Normal file
View file

@ -0,0 +1,49 @@
#include "arc/graphics/circle.h"
#include "renderer.h"
#include <stdlib.h>
//Modified from https://stackoverflow.com/questions/38334081/how-to-draw-circles-arcs-and-vector-graphics-in-sdl
void ARC_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);
}
}

311
packages/graphics/sdl/config.c Normal file
View file

@ -0,0 +1,311 @@
#include "arc/graphics/config.h"
#include <SDL_image.h>
#include <stdio.h>
#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);
}

8
packages/graphics/sdl/line.c Normal file
View file

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

48
packages/graphics/sdl/obround.c Normal file
View file

@ -0,0 +1,48 @@
#include "arc/graphics/obround.h"
#include "renderer.h"
#include <stdlib.h>
//Modified from https://stackoverflow.com/questions/38334081/how-to-draw-circles-arcs-and-vector-graphics-in-sdl
void ARC_Obround_Render(ARC_Obround *obround, ARC_Renderer *renderer, ARC_Color *color){
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);
}

23
packages/graphics/sdl/rectangle.c Normal file
View file

@ -0,0 +1,23 @@
#include "arc/graphics/rectangle.h"
#include "renderer.h"
#include <stdlib.h>
void ARC_Rect_Render(ARC_Rect *rect, ARC_Renderer *renderer, ARC_Color *color){
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);
}

39
packages/graphics/sdl/renderer.c Normal file
View file

@ -0,0 +1,39 @@
#include "arc/graphics/renderer.h"
#include "renderer.h"
#include <SDL.h>
#include <stdlib.h>
#include "arc/engine/engine.h"
#include "arc/graphics/window.h"
#include "arc/std/errno.h"
void ARC_Renderer_CreateWithEngineData(ARC_Renderer **renderer, ARC_EngineData *data){
if(!data){
arc_errno = ARC_ERRNO_NULL;
ARC_DEBUG_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);
}

10
packages/graphics/sdl/renderer.h Normal file
View file

@ -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 <SDL.h>
typedef SDL_Renderer ARC_RendererType;
#endif // !ARC_SDL_RENDERER_H_

90
packages/graphics/sdl/sprite.c Normal file
View file

@ -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 <stdlib.h>
void ARC_Sprite_Create(ARC_Sprite **sprite, ARC_Spritesheet *spritesheet, ARC_Array *frames){
*sprite = (ARC_Sprite *)malloc(sizeof(ARC_Sprite));
(*sprite)->spritesheet = spritesheet;
(*sprite)->frames = frames;
(*sprite)->frameIndex = (uint32_t *)malloc(sizeof(uint32_t));
*(*sprite)->frameIndex = 0;
(*sprite)->opacity = 255;
}
void ARC_Sprite_Destroy(ARC_Sprite *sprite){
free(sprite);
}
void ARC_Sprite_Copy(ARC_Sprite **newSprite, ARC_Sprite *oldSprite){
*newSprite = (ARC_Sprite *)malloc(sizeof(ARC_Sprite));
(*newSprite)->spritesheet = oldSprite->spritesheet;
(*newSprite)->frames = oldSprite->frames;
(*newSprite)->frameIndex = (uint32_t *)malloc(sizeof(uint32_t));
*(*newSprite)->frameIndex = *oldSprite->frameIndex;
}
void ARC_Sprite_SetOpacity(ARC_Sprite *sprite, uint8_t opacity){
sprite->opacity = opacity;
}
void ARC_Sprite_Render(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds){
//TODO: note, this is set here so not all entities in the sheet get opacity set
SDL_SetTextureAlphaMod((SDL_Texture *)sprite->spritesheet->texture, sprite->opacity);
SDL_RenderCopy((SDL_Renderer *)renderer, sprite->spritesheet->texture, (SDL_Rect *)sprite->frames->data + *sprite->frameIndex, (SDL_Rect *)renderBounds);
}
void ARC_Sprite_RenderFlip(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds, enum ARC_Sprite_Axis axis){
SDL_RendererFlip flip = SDL_FLIP_NONE;
if(axis & ARC_SPRITE_AXIS_X){
flip |= SDL_FLIP_HORIZONTAL;
}
if(axis & ARC_SPRITE_AXIS_Y){
flip |= SDL_FLIP_VERTICAL;
}
//TODO: note, this is set here so not all entities in the sheet get opacity set
SDL_SetTextureAlphaMod((SDL_Texture *)sprite->spritesheet->texture, sprite->opacity);
SDL_RenderCopyEx((SDL_Renderer *)renderer, sprite->spritesheet->texture, (SDL_Rect *)sprite->frames->data + *sprite->frameIndex, (SDL_Rect *)renderBounds, 0.0, NULL, flip);
}
void ARC_Sprite_RenderRotated(ARC_Sprite *sprite, ARC_Renderer *renderer, ARC_Rect *renderBounds, ARC_Point *center, double angle){
//TODO: note, this is set here so not all entities in the sheet get opacity set
SDL_SetTextureAlphaMod((SDL_Texture *)sprite->spritesheet->texture, sprite->opacity);
SDL_RenderCopyEx((SDL_Renderer *)renderer, sprite->spritesheet->texture, (SDL_Rect *)sprite->frames->data + *sprite->frameIndex, (SDL_Rect *)renderBounds, angle, (SDL_Point *)center, SDL_FLIP_NONE);
}
void ARC_Sprite_SetFrameIndex(ARC_Sprite *sprite, uint32_t index){
if(sprite->frames->size <= index){
arc_errno = ARC_ERRNO_DATA;
ARC_DEBUG_LOG(arc_errno, "in ARC_Sprite_SetFrameIndex(sprite, %d); index out of bounds", index);
return;
}
*sprite->frameIndex = index;
}
void ARC_Sprite_IterateFrame(ARC_Sprite *sprite){
++*sprite->frameIndex;
if(*sprite->frameIndex == sprite->frames->size){
*sprite->frameIndex = 0;
}
}
uint32_t ARC_Sprite_GetFrameIndex(ARC_Sprite *sprite){
return *sprite->frameIndex;
}
ARC_Rect *ARC_Sprite_GetBounds(ARC_Sprite *sprite){
return (ARC_Rect *)sprite->frames->data + *sprite->frameIndex;
}
ARC_Array *ARC_Sprite_GetAllBounds(ARC_Sprite *sprite){
return sprite->frames;
}

15
packages/graphics/sdl/sprite.h Normal file
View file

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

20
packages/graphics/sdl/spritesheet.c Normal file
View file

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

12
packages/graphics/sdl/spritesheet.h Normal file
View file

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

57
packages/graphics/sdl/text.c Normal file
View file

@ -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 <SDL2/SDL_ttf.h>
void ARC_Text_Create(ARC_Text **text, ARC_String *path, int32_t size, ARC_Color color){
*text = (ARC_Text *)malloc(sizeof(ARC_Text));
ARC_String_Copy(&(*text)->name, path);
(*text)->size = size;
(*text)->color = color;
(*text)->texture = NULL;
(*text)->bounds = (ARC_Rect){ 0, 0, 0, 0 };
}
void ARC_Text_Destroy(ARC_Text *font){
if(font->texture != NULL){
SDL_DestroyTexture(font->texture);
}
ARC_String_Destroy(font->name);
free(font);
}
void ARC_Text_SetString(ARC_Text *text, ARC_Renderer *renderer, ARC_String *string){
TTF_Font *ttfont = TTF_OpenFont(text->name->data, text->size);
SDL_Color textColor = (SDL_Color){ text->color.r, text->color.g, text->color.b, text->color.a };
SDL_Surface *surface = TTF_RenderText_Blended_Wrapped(ttfont, string->data, textColor, 0);
text->bounds.w = surface->w;
text->bounds.h = surface->h;
if(text->texture){
SDL_DestroyTexture(text->texture);
}
text->texture = SDL_CreateTextureFromSurface((SDL_Renderer *)renderer, surface);
SDL_FreeSurface(surface);
TTF_CloseFont(ttfont);
}
void ARC_Text_Render(ARC_Text *text, ARC_Renderer *renderer){
if(text->texture == NULL){
return;
}
SDL_Rect bounds = (SDL_Rect){ text->bounds.x, text->bounds.y, text->bounds.w, text->bounds.h };
SDL_RenderCopy((SDL_Renderer *)renderer, text->texture, NULL, &bounds);
}
void ARC_Text_SetPos(ARC_Text *text, ARC_Point pos){
text->bounds.x = pos.x;
text->bounds.y = pos.y;
}

20
packages/graphics/sdl/text.h Normal file
View file

@ -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 <SDL.h>
typedef struct ARC_Text {
ARC_String *name;
int32_t size;
ARC_Color color;
SDL_Texture *texture;
ARC_Rect bounds;
} ARC_Text;
#endif // !ARC_SDL_TEXT_H_

35
packages/graphics/sdl/view.c Normal file
View file

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

31
packages/graphics/sdl/window.c Normal file
View file

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

9
packages/graphics/sdl/window.h Normal file
View file

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

42
packages/input/glfw/input.c Normal file
View file

@ -0,0 +1,42 @@
#ifdef ARC_GLFW_INPUT
#include "arc/input/input.h"
#include "arc/input/mouse.h"
#include "arc/input/keyboard.h"
#include <GLFW/glfw3.h>
#include <stdlib.h>
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

23
packages/input/glfw/keyboard.c Normal file
View file

@ -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 <stdlib.h>
#include <stdint.h>
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

21
packages/input/glfw/keyboard.h Normal file
View file

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

34
packages/input/glfw/mouse.c Normal file
View file

@ -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 <stdlib.h>
#include <stdint.h>
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

25
packages/input/glfw/mouse.h Normal file
View file

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

40
packages/input/sdl/input.c Normal file
View file

@ -0,0 +1,40 @@
#include "arc/input/input.h"
#include "input.h"
#include "arc/input/mouse.h"
#include "arc/input/keyboard.h"
#include <SDL.h>
#include <stdlib.h>
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;
}

15
packages/input/sdl/input.h Normal file
View file

@ -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 <SDL.h>
struct ARC_Input {
ARC_Keyboard *keyboard;
ARC_Mouse *mouse;
SDL_Event *event;
};
#endif // !ARC_SDL_INPUT_H_

98
packages/input/sdl/keyboard.c Normal file
View file

@ -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 <stdlib.h>
#include <stdint.h>
#include <SDL_keyboard.h>
#include <SDL_events.h>
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;
}
}

14
packages/input/sdl/keyboard.h Normal file
View file

@ -0,0 +1,14 @@
#ifndef ARC_SDL_KEYBOARD_H_
#define ARC_SDL_KEYBOARD_H_
#include "arc/input/keyboard.h"
#include <SDL.h>
struct ARC_Keyboard {
SDL_Event *event;
ARC_KeyboardState *keys;
ARC_KeyboardState *released;
};
#endif // !ARC_SDL_KEYBOARD_H_

105
packages/input/sdl/mouse.c Normal file
View file

@ -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 <stdlib.h>
#include <stdint.h>
#include <SDL_mouse.h>
#include <SDL_events.h>
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;
}

17
packages/input/sdl/mouse.h Normal file
View file

@ -0,0 +1,17 @@
#ifndef ARC_SDL_MOUSE_H_
#define ARC_SDL_MOUSE_H_
#include <SDL.h>
#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_

207
packages/networking/libssh/ssh.c Normal file
View file

@ -0,0 +1,207 @@
#include "arc/networking/ssh.h"
#include "arc/std/errno.h"
#include <stdint.h>
#include <stdlib.h>
#include <libssh/libssh.h>
#include <errno.h>
#include <string.h>
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);
}

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

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

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

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

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

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

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

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

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

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

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

@ -0,0 +1,22 @@
#ifdef ARC_NONE_GRAPHICS
#include "arc/graphics/renderer.h"
#include <stdio.h>
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

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

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

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

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

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

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

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

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

26
src/input/input.c Normal file
View file

@ -0,0 +1,26 @@
#include "arc/input/input.h"
#include <stdio.h>
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;
}

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

@ -0,0 +1,23 @@
#ifdef ARC_NONE_INPUT
#include "arc/input/keyboard.h"
#include <stdio.h>
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

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

@ -0,0 +1,37 @@
#ifdef ARC_NONE_INPUT
#include "arc/input/mouse.h"
#include <stdio.h>
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

18
src/std/time.c Normal file
View file

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