diff options
Diffstat (limited to 'src')
23 files changed, 1123 insertions, 28 deletions
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index f8c0315..c6adabf 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -1,10 +1,12 @@ add_library(daw_core - cleanup.c - dltools.c - harness.c - init.c - logging.c - loop.c - memory.c - state.c + src/cleanup.c + src/dltools.c + src/harness.c + src/init.c + src/logging.c + src/loop.c + src/memory.c + src/state.c ) + +target_include_directories(daw_core PRIVATE include) diff --git a/src/core/include/engine/core/dltools.h b/src/core/include/engine/core/dltools.h new file mode 100644 index 0000000..5a53f49 --- /dev/null +++ b/src/core/include/engine/core/dltools.h @@ -0,0 +1,16 @@ +#ifndef DLTOOLS_H +#define DLTOOLS_H + +#include <stdbool.h> + +/* Utility functions for handling runtime linked shared libraries */ +bool dynamic_library_close(void* shared_library); +void* dynamic_library_open(const char* library_path); +void* dynamic_library_reload(void* shared_library, const char* library_path); + +/* Returns the address of symbol in the provided shared_library handle. + * NULL on error*/ +void* dynamic_library_get_symbol(void* shared_library, const char* symbol); +char* dynamic_library_get_error(void); + +#endif diff --git a/src/core/include/engine/core/logging.h b/src/core/include/engine/core/logging.h new file mode 100644 index 0000000..d1c5890 --- /dev/null +++ b/src/core/include/engine/core/logging.h @@ -0,0 +1,49 @@ +#ifndef LOGGING_H +#define LOGGING_H + +#include <math.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "types.h" + +#if defined __linux__ || defined __APPLE__ +#define TERM_COLOR_RESET "\033[0m" +#define TERM_COLOR_RED "\033[31m" +#define TERM_COLOR_GREEN "\033[32m" +#define TERM_COLOR_YELLOW "\033[33m" +#define TERM_COLOR_BLUE "\033[34m" +#define TERM_COLOR_PURPLE "\033[35m" +#else +#define TERM_COLOR_RESET +#define TERM_COLOR_RED +#define TERM_COLOR_GREEN +#define TERM_COLOR_YELLOW +#define TERM_COLOR_BLUE +#define TERM_COLOR_PURPLE +#endif + +#define STR(a) (#a) + +void _log(FILE* stream, const char* prefix, const char* fmt, va_list ap); + +void LOG(const char* fmt, ...); + +void INFO_(const char* fmt, ...); +void INFO(const char* fmt, ...); + +#ifdef _DEBUG +#define DEBUG(fmt, ...) __DEBUG(__FILE__, __LINE__, __func__, fmt, __VA_ARGS__) +void __DEBUG(const char* file, const i32 line, const char* func, + const char* fmt, ...); +#else +#define DEBUG(...) +#endif + +void WARN(const char* fmt, ...); + +void ERROR(const char* fmt, ...); + +#endif diff --git a/src/core/include/engine/core/memory.h b/src/core/include/engine/core/memory.h new file mode 100644 index 0000000..04c24d5 --- /dev/null +++ b/src/core/include/engine/core/memory.h @@ -0,0 +1,25 @@ +#ifndef MEMORY_H +#define MEMORY_H + +#include "types.h" +// #include <stdlib.h> + +typedef struct memory { + void* data; + usize size; + usize pos; + usize free; +} memory; + +memory* memory_new(usize max_size); + +/* Returns a pointer to the allocated data */ +void* memory_allocate(memory* mem, usize size); + +memory memory_init(void* data, usize size); + +void memory_free(memory* mem, usize size); + +void memory_clear(memory* mem); + +#endif diff --git a/src/core/include/engine/core/state.h b/src/core/include/engine/core/state.h new file mode 100644 index 0000000..13593ed --- /dev/null +++ b/src/core/include/engine/core/state.h @@ -0,0 +1,31 @@ +#ifndef STATE_H +#define STATE_H + +#include <engine/memory.h> + +typedef enum StateType { + STATE_null, +#define State(name) STATE_##name, +#include <states/list_of_states.h> +#undef State + STATE_quit, +} StateType; + +extern const char* StateTypeStr[]; + +StateType (*State_updateFunc(StateType type))(void*); + +void State_init(StateType type, memory* mem); +void State_free(StateType type, memory* mem); +StateType State_update(StateType type, memory* mem); + +/* Reloads shared object file associated with state */ +#ifdef DAW_BUILD_HOTRELOAD +#include <engine/input.h> +bool State_reload(StateType type, i_ctx** ctx, usize ctx_len); + +#else +#define State_reload(_, _0, _1) true +#endif + +#endif diff --git a/src/core/include/engine/core/types.h b/src/core/include/engine/core/types.h new file mode 100644 index 0000000..934cb63 --- /dev/null +++ b/src/core/include/engine/core/types.h @@ -0,0 +1,34 @@ +#ifndef ENGINE_TYPES_H +#define ENGINE_TYPES_H + +#include <stdbool.h> +#include <stdint.h> + +/* Signed */ +typedef int8_t i8; +typedef int16_t i16; +typedef int32_t i32; +typedef int64_t i64; + +/* Unsigned */ +typedef uint8_t u8; +typedef uint16_t u16; +typedef uint32_t u32; +typedef uint64_t u64; + +/* floating points */ +typedef float f32; +typedef double f64; + +/* sizes */ +#if __x86_64__ || __ppc64__ || _WIN64 +typedef u64 usize; +typedef i64 isize; +#else +typedef u32 usize; +typedef i32 isize; +#endif + +typedef bool(predicate_t)(const void*); + +#endif diff --git a/src/core/include/engine/engine.h b/src/core/include/engine/engine.h new file mode 100644 index 0000000..e8a5ace --- /dev/null +++ b/src/core/include/engine/engine.h @@ -0,0 +1,130 @@ +#ifndef ENGINE_H +#define ENGINE_H + +#include <stdbool.h> + +#include <engine/input.h> +#include <engine/logging.h> +#include <engine/memory.h> +#include <engine/resources.h> +#include <engine/stack.h> +#include <engine/state.h> +#include <engine/types.h> +#include <engine/vector.h> + +typedef struct { + u32 texture_id; + i32 x, y, w, h; +} RenderUnit; + +typedef struct Window Window; + +#define NUM_GLOBAL_BINDINGS 1 +typedef struct { + void* data; /* Contains textures and such */ + u64 data_len; + + Window* window; + bool quit; + + u64 frame; + f32 fps_target; + + /* TODO: Move mouse data to input ctx */ + v2_i32 mouse_pos; + + v2_i32 mousedown; + v2_i32 mouseup; + + bool mouse_lclick; + bool mouse_rclick; + + i32 camera_x; + i32 camera_y; + + /* Text input/editing is currently not used/implemented */ + char* edit_text; + usize edit_pos; + + memory* mem; + + i_ctx** bindings; + usize bindings_sz; + usize bindings_len; + + struct RenderObject *testobject; + + binding_t bindings_global[NUM_GLOBAL_BINDINGS]; +} Platform; + +/* Essential functions */ +Platform* engine_init(const char* windowtitle, v2_i32 windowsize, + const f32 render_scale, const u32 flags, + const usize initial_memory, const Asset_FontSpec* fonts[], + const Asset_TextureSpec* textures[]); + +i32 engine_run(Platform* p, StateType initial_state); + +void engine_stop(Platform* p); + +/* Utility functions */ +void engine_fps_max(u64 cap); + +void render_set_zoom(f32 new_zoom); +void render_adjust_zoom(f32 diff); +void render_add_unit(RenderUnit* u); + +f64 get_time(void); +v2_i32 get_windowsize(void); +v2_i32* get_mousepos(void); + +/* Input handling */ +void engine_input_ctx_push(i_ctx* ctx); +void engine_input_ctx_pop(void); +void engine_input_ctx_reset(void); + +#include "rendering.h" + +#ifdef ENGINE_INTERNALS + +#include <glad/gl.h> +#define GLFW_INCLUDE_NONE +#include <GLFW/glfw3.h> + +/* Window */ +struct Window { + GLFWwindow* window; + GladGLContext* context; + f32 render_scale; + + v2_i32 windowsize; + + i32* game_w; + i32* game_h; +}; + +typedef struct { + const i32 tilesize; + const i32 width; + const i32 height; +} Texture; + +struct Resources { + usize textures_len; + usize textures_size; + usize fonts_len; + + usize texturepaths_len; + usize fontpaths_len; + + /* Paths for our sources, kept in case the user wants to reload them */ + Asset_TextureSpec** texture_paths; + Asset_FontSpec** font_paths; + + /* Our actual sources */ + Texture** textures; + //TTF_Font** fonts; +}; + +#endif +#endif diff --git a/src/ctrl/CMakeLists.txt b/src/ctrl/CMakeLists.txt index e086f07..7a449d6 100644 --- a/src/ctrl/CMakeLists.txt +++ b/src/ctrl/CMakeLists.txt @@ -1,7 +1,9 @@ add_library(daw_ctrl - controller.c - ctx.c - input.c - keyboard.c - mouse.c + src/controller.c + src/ctx.c + src/input.c + src/keyboard.c + src/mouse.c ) + +target_include_directories(daw_ctrl PRIVATE include) diff --git a/src/ctrl/include/engine/ctrl/input.h b/src/ctrl/include/engine/ctrl/input.h new file mode 100644 index 0000000..49b3a96 --- /dev/null +++ b/src/ctrl/include/engine/ctrl/input.h @@ -0,0 +1,92 @@ +#ifndef INPUT_H +#define INPUT_H + +#include <engine/types.h> + +typedef void input_callback_t(void*); +typedef i32 scancode_t; + +typedef enum InputType { + InputType_error = 0, + InputType_action, + InputType_state, + InputType_range, /* TBD */ +} InputType; + +typedef union action_t { + InputType type; + + struct { + InputType type; + input_callback_t* callback; + char* callback_str; + } action; + + struct { + InputType type; + input_callback_t* activate; + input_callback_t* deactivate; + char* activate_str; + char* deactivate_str; + } state; +} action_t; + +typedef struct binding_t { + action_t action; + + // Change type depending on input handling back-end. like u16 for GLFW_KEY + scancode_t scancode; + scancode_t scancode_alt; + + u64 since_last_activation; +} binding_t; + +typedef struct i_ctx { + binding_t* bindings; + isize len; +} i_ctx; + +void i_ctx_t_free(i_ctx* c); +/* Executes all callbacks that has been pushed onto the callstack and resets the + * callstack */ +void i_flush_bindings(usize numcalls, void* state_mem, input_callback_t* c[]); +action_t i_get_action(const i_ctx* restrict ctx, u32 time, scancode_t scancode); + +void i_ctx_push(i_ctx* ctx); +void i_ctx_pop(void); +void i_ctx_reset(void); + +/* Finds and updates the scancode of a binding with the given action in ctx */ +void i_bind_ctx(i_ctx* c, scancode_t s, action_t* a); +void i_bind_ctx_alt(i_ctx* c, scancode_t s, action_t* a); + +/* Update the scancode of a binding */ +void i_bind(binding_t* b, scancode_t s); +void i_bind_alt(binding_t* b, scancode_t s); + +#define BindAction(key, altkey, f_action) \ + (binding_t) { \ + .action = (action_t){.action = \ + { \ + .type = InputType_action, \ + .callback = (input_callback_t*)&f_action, \ + .callback_str = strdup(#f_action), \ + }}, \ + .scancode = key, .scancode_alt = altkey, .since_last_activation = 0 \ + } + +#define BindState(key, altkey, f_activate, f_deactivate) \ + (binding_t) { \ + .action = \ + (action_t){.state = \ + { \ + .type = InputType_state, \ + .activate = (input_callback_t*)&f_activate, \ + .deactivate = (input_callback_t*)&f_deactivate, \ + .activate_str = strdup(#f_activate), \ + .deactivate_str = strdup(#f_deactivate), \ + }}, \ + .scancode = key, .scancode_alt = altkey, .since_last_activation = 0 \ + } + +#endif diff --git a/src/rendering/CMakeLists.txt b/src/rendering/CMakeLists.txt index a7313e9..e04d858 100644 --- a/src/rendering/CMakeLists.txt +++ b/src/rendering/CMakeLists.txt @@ -1,6 +1,13 @@ add_library(daw_rendering - gl.c - rendering.c - text.c - window.c + src/gl.c + src/rendering.c + src/text.c + src/window.c + ) + +target_include_directories(daw_rendering PRIVATE include) +target_link_libraries(daw_rendering PRIVATE + OpenGL::GL + cglm + glfw ) diff --git a/src/rendering/include/engine/rendering/rendering.h b/src/rendering/include/engine/rendering/rendering.h new file mode 100644 index 0000000..ff24412 --- /dev/null +++ b/src/rendering/include/engine/rendering/rendering.h @@ -0,0 +1,101 @@ +#ifndef RENDERING_H +#define RENDERING_H + +#include "types.h" +#include "vector.h" + +#define GLFW_INCLUDE_NONE +#include <GLFW/glfw3.h> + +/* Definitions */ +#define RGBA(_r, _g, _b, _a) \ + ((Engine_color){.r = _r, .g = _g, .b = _b, .a = _a}) +#define RGB(_r, _g, _b) RGBA(_r, _g, _b, 0xFF) + +/* Types */ +typedef struct { + u8 r; + u8 g; + u8 b; + u8 a; +} Engine_color; + +typedef struct { + u32 texture_id; + v2_i32 coord; +} Sprite; + + +#include "engine.h" +#include "ui.h" + +/* Rendering functions */ +void render_begin(Window* w); +void render_present(Window* w); +void drawcall_reset(void); +void render(Window* w); + +/* Misc */ +void window_size_callback(GLFWwindow* window, i32 width, i32 height); +void engine_window_resize_pointers(i32* w, i32* h); +void engine_window_resize_pointers_reset(void); + +/* UI rendering */ +/* See rendering_ui.c for implementation */ +i64 engine_render_text(i32 font_id, Engine_color fg, char* text, + v2_i32* size_out, bool wrapped); +void engine_draw_uitree(UITree* t); +void engine_draw_sprite(Sprite* s, v2_i32* pos, f32 scale); +void engine_draw_sprite_ex(Sprite* s, v2_i32* pos, f32 scale, + Engine_color colormod); + +Sprite sprite_new(u64 tid, u8 coord); + +#ifdef ENGINE_INTERNALS +#include "engine.h" + +//#include <glad/gl.h> +//#define GLFW_INCLUDE_NONE +//#include <GLFW/glfw3.h> + +#define TEXTURES_INCREMENT 512 + +typedef enum { + RenderDrawCallType_UITree, + /*RenderDrawCallType_UIButton,*/ + RenderDrawCallType_Text, + RenderDrawCallType_Sprite, +} RenderDrawCallType; + +typedef struct { + RenderDrawCallType type; + union { + void* data; + struct { + Sprite* sprite; + i32 x; + i32 y; + f32 scale; + } sprite; + } data; +} RenderDrawCall; + +struct RenderObject { + u32 vao; + u32 vbo; + u32 col; + u32 shaderprogram; + f32 g_vertex_buffer_data[9]; +}; + +void render_uitree(Window* w, UITree* t); + +void render_container(Window* w, UITree_container* t); +void render_button(Window* w, UITree_button* t); +void render_title(Window* w, UITree_title* t); +void render_text(Window* w, UITree_text* t); +v2_i32 elem_size(UITree* root); + +#endif + +#endif diff --git a/src/resources/CMakeLists.txt b/src/resources/CMakeLists.txt index 7fe5cac..02ab1ca 100644 --- a/src/resources/CMakeLists.txt +++ b/src/resources/CMakeLists.txt @@ -1,5 +1,7 @@ add_library(daw_resources - fonts.c - scripts.c - textures.c + src/fonts.c + src/scripts.c + src/textures.c ) + +target_include_directories(daw_resources PRIVATE include) diff --git a/src/resources/include/engine/resources/resources.h b/src/resources/include/engine/resources/resources.h new file mode 100644 index 0000000..1689544 --- /dev/null +++ b/src/resources/include/engine/resources/resources.h @@ -0,0 +1,79 @@ +#ifndef RESOURCES_H +#define RESOURCES_H + +#include <engine/types.h> + +/* We need some "global resources", available to all states. + * These are resources such as common fonts, GUI frames, button background + * images. + * + * We need to define state-specific resources as well. + * - Can both be defined alike? + * If we lazy-load all resources we can get away with a lot. + * Maybe use fall-back resources? like the missing source texture, and an ugly + * font? + * - Then declare to the engine, in the main function for the game, that these + * resources are to be made available throughout? + * - Make all resource specifications A UNION?! 🤯 + * */ + +enum Asset { + Asset_error, + Asset_font, + Asset_texture, + Asset_audio, +}; + +typedef struct { + enum Asset type; + const char* font_path; + i32 ptsize; +} Asset_FontSpec; + +typedef struct { + enum Asset type; + const char* path; + i32 width; + i32 height; +} Asset_TextureSpec; + +typedef struct { + enum Asset type; + const char* path; +} Asset_AudioSpec; + +typedef union { + enum Asset type; + Asset_FontSpec font; + Asset_TextureSpec texture; + Asset_AudioSpec audio; +} asset_t; + +#define Resource_FontDefinition(_path, _fontsize) \ + (const Asset_FontSpec) { \ + .type = Asset_font, .font_path = _path, .ptsize = _fontsize \ + } + +#define Resource_TextureAtlasDefinition(_path, _subtexture_width, \ + _subtexture_height) \ + (const Asset_TextureSpec) { \ + .type = Asset_texture, .width = _subtexture_width, \ + .height = _subtexture_height, .path = _path \ + } + +#define TextureDefinition(_path, ...) unimplemented + +#define Resource_AudioDefinition(_path, ...) unimplemented + +/* Each of resource_load_font, resource_load_texture, and resource_load_audio + * loads a given resource into the engines memory and returns an identifier. + */ +isize resource_load_font(Asset_FontSpec font_def); +isize resource_load_texture(Asset_TextureSpec texture_def); +isize resource_load_audio(Asset_AudioSpec audio_def); + +/* Makes a resource globally available. This must be called **BEFORE** any call + * to `engine_run` */ +isize resource_make_global(isize resource_id); + +#endif diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt index 05b2648..23dcae6 100644 --- a/src/ui/CMakeLists.txt +++ b/src/ui/CMakeLists.txt @@ -1,4 +1,6 @@ add_library(daw_ui - positioning.c - rendering.c + src/positioning.c + src/rendering.c ) + +target_include_directories(daw_ui PRIVATE include) diff --git a/src/ui/include/engine/ui/ui.h b/src/ui/include/engine/ui/ui.h new file mode 100644 index 0000000..4a3cd3e --- /dev/null +++ b/src/ui/include/engine/ui/ui.h @@ -0,0 +1,264 @@ +#ifndef ENGINE_UI_H +#define ENGINE_UI_H + +#include "list.h" +#include "types.h" +#include "vector.h" + +#define DIRECTION_HORIZONTAL true +#define DIRECTION_VERTICAL false + +/* Ui positioning constraints */ +typedef enum { + ui_size_pixel, + ui_size_percent, +} ui_size_t; + +typedef union { + ui_size_t type; + struct { + ui_size_t type; + i32 value; + } pixel; + struct { + ui_size_t type; + f32 value; + } percent; +} ui_size; + +typedef enum { + ui_constraint_width, + ui_constraint_height, + + ui_constraint_horizontal_align, + ui_constraint_vertical_align, + + ui_constraint_left, + ui_constraint_right, + ui_constraint_top, + ui_constraint_bottom, +} ui_constraint_t; + +typedef enum { + ui_constraint_vertical_align_top, + ui_constraint_vertical_align_center, + ui_constraint_vertical_align_bottom, +} ui_constraint_vertical_align_t; + +typedef enum { + ui_constraint_horizontal_align_left, + ui_constraint_horizontal_align_center, + ui_constraint_horizontal_align_right, +} ui_constraint_horizontal_align_t; + +typedef union { + struct { + ui_size size; + } width; + struct { + ui_size size; + } height; + + /* spacing is the padding between the aligned edge and the container itself */ + struct { + ui_constraint_horizontal_align_t align; + ui_size spacing; + } horizontal_align; + struct { + ui_constraint_vertical_align_t align; + ui_size spacing; + } vertical_align; + + struct { + ui_size pos; + } left; + struct { + ui_size pos; + } top; + struct { + ui_size pos; + } right; + struct { + ui_size pos; + } bottom; +} constraintval_t; + +#define CONSTRAINT_POSITION(axis, alignment_sub, margin, cnext) \ + { \ + .value = \ + { \ + .type = ui_constraint_##axis##_align, \ + .constraint.axis##_align = \ + { \ + .align = ui_constraint_##axis##_align_##alignment_sub, \ + .spacing = margin, \ + }, \ + }, \ + .next = cnext, \ + } + +#define CONSTRAINT_SIZE(c_type, csize, cnext) \ + { \ + .value = \ + { \ + .type = ui_constraint_##c_type, \ + .constraint.c_type = \ + { \ + .size = csize, \ + }, \ + }, \ + .next = cnext, \ + } + +typedef struct { + ui_constraint_t type; + constraintval_t constraint; +} ui_constraint; + +typedef DEFINE_LLIST(ui_constraint); + +enum uitype { + uitype_container, + uitype_button, + uitype_title, + uitype_text, + + uitype_MAX, +}; + +typedef struct UITree_container { + enum uitype type; + bool visible; + bool direction; + i32 x, y, w, h; + i32 padding; + i32 margin; + + Engine_color fg; + Engine_color bg; + Engine_color bordercolor; + + usize children_len; /* Number of children */ + usize children_size; /* Memory size */ + union UITree** children; + struct List_ui_constraint* constraints; +} UITree_container; + +typedef struct UITree_button { + enum uitype type; + + bool enabled; + u64 id; + + i32 x, y, w, h; + i32 padding; + i32 margin; + + Engine_color fg; + Engine_color bg; + + i32 font_id; + const char* text_original; + u64 text_texture_index; + v2_i32 texture_size; + struct List_ui_constraint* constraints; +} UITree_button; + +typedef struct UITree_title { + enum uitype type; + i32 x, y, w, h; + + i32 padding; + i32 margin; + + Engine_color fg; + + i32 font_id; + const char* text_original; + u64 text_texture_index; + v2_i32 texture_size; + struct List_ui_constraint* constraints; +} UITree_title; + +typedef struct UITree_text { + enum uitype type; + i32 x, y, w, h; + + i32 padding; + i32 margin; + + Engine_color fg; + + i32 font_id; + const char* text_original; + u64 text_texture_index; + v2_i32 texture_size; + struct List_ui_constraint* constraints; +} UITree_text; + +typedef union UITree { + enum uitype type; + + UITree_container container; + UITree_button button; + UITree_title title; + UITree_text text; + struct List_ui_constraint constraints; +} UITree; + +/* Sizes */ +f32 ui_size_pixel_to_percent_width(i32 pixels); +f32 ui_size_pixel_to_percent_height(i32 pixels); +f32 ui_size_pixel_to_percent(i32 pixels); +i32 ui_size_percent_width_to_pixel(f32 percent); +i32 ui_size_percent_height_to_pixel(f32 percent); +i32 ui_size_percent_to_pixel(f32 percent); +i32 ui_size_to_pixel(ui_size s); + +#define ui_size_percent_new(p) \ + { \ + .percent = {.type = ui_size_percent, .value = p } \ + } +#define ui_size_pixel_new(p) \ + { \ + .pixel = {.type = ui_size_pixel, .value = p } \ + } + +/* Constructors */ +UITree* ui_container(bool direction, struct List_ui_constraint* constraints); +UITree* ui_button(u64 id, i32 font_id, char* text, + struct List_ui_constraint* constraints); +UITree* ui_title(i32 font_id, const char* text, + struct List_ui_constraint* constraints); +UITree* ui_text(i32 font_id, const char* text, + struct List_ui_constraint* constraints); + +/* Extended Constructors */ +UITree* ui_container_new_ex(Engine_color fg, Engine_color bg, + Engine_color border, bool direction, + struct List_ui_constraint* constraints); + +/* Destructors */ +void clear_ui(void); +void uitree_free(UITree* t); + +/* Manipulation */ +void ui_container_attach(UITree* container, UITree* child); + +void ui_resolve_constraints(void); + +void ui_button_enable(UITree_button* b); +void ui_button_disable(UITree_button* b); + +/* Tweaking default colors */ +void ui_set_default_colors(Engine_color fg, Engine_color bg); +void ui_set_default_padding(i32 padding); +Engine_color ui_get_default_fg(void); +Engine_color ui_get_default_bg(void); + +#define ELEM_NOT_FOUND (-1) +#define NO_CLICK (-2) +/* Returns -1 if not found */ +u64 ui_check_click(UITree* root); + +#endif diff --git a/src/utils/CMakeLists.txt b/src/utils/CMakeLists.txt index 3274f55..7508d26 100644 --- a/src/utils/CMakeLists.txt +++ b/src/utils/CMakeLists.txt @@ -1,8 +1,10 @@ add_library(daw_utils - btree.c - fov.c - hashmap.c - misc.c - stack.c - vector.c + src/btree.c + src/fov.c + src/hashmap.c + src/misc.c + src/stack.c + src/vector.c ) + +target_include_directories(daw_utils PRIVATE include) diff --git a/src/utils/include/engine/utils/btree.h b/src/utils/include/engine/utils/btree.h new file mode 100644 index 0000000..04f9ff8 --- /dev/null +++ b/src/utils/include/engine/utils/btree.h @@ -0,0 +1,54 @@ +#ifndef BTREE_H +#define BTREE_H + +#include <stddef.h> + +#define BTREE_DEGREE_DEFAULT 4 + +#define BTREE_SIZE_MIN 8 +#define BTREE_SIZE_MAX 4096 + +#define BTREE_CMP_LT (-1) +#define BTREE_CMP_EQ (0) +#define BTREE_CMP_GT (1) + +struct btree; +struct btree_iter_t; + +/* elem_size: the size of the elements, typically `sizeof(struct <your struct>)` + * t: degree of the btree, if you're in doubt, use `BTREE_SIZE_DEFAULT` + * cmp: comparison function, in order to support any operations on the tree. + * + * This function just calls `btree_new_with_allocator` with `free` and `malloc` + * as initializers. + */ +struct btree* btree_new(size_t elem_size, size_t t, + int (*cmp)(const void* a, const void* b)); + +/* Same as `btree_new`, except that it actually initializes a btree, but with + * the given allocators. + */ +struct btree* btree_new_with_allocator(size_t elem_size, size_t t, + int (*cmp)(const void* a, const void* b), + void* (*alloc)(size_t), + void (*dealloc)(void*)); + +void btree_free(struct btree** btree); + +void* btree_search(struct btree* btree, void* elem); +void btree_insert(struct btree* btree, void* elem); +int btree_delete(struct btree* btree, void* elem); + +void btree_print(struct btree* btree, void (*print_elem)(const void*)); + +void* btree_first(struct btree* btree); +void* btree_last(struct btree* btree); + +size_t btree_size(struct btree* btree); + +struct btree_iter_t* btree_iter_t_new(struct btree* tree); +void btree_iter_t_reset(struct btree* tree, struct btree_iter_t** it); + +void* btree_iter(struct btree* tree, struct btree_iter_t* iter); + +#endif diff --git a/src/utils/include/engine/utils/fov.h b/src/utils/include/engine/utils/fov.h new file mode 100644 index 0000000..15ef38b --- /dev/null +++ b/src/utils/include/engine/utils/fov.h @@ -0,0 +1,21 @@ +#ifndef ENGINE_FOV_H +#define ENGINE_FOV_H + +#include "types.h" +#include "vector.h" +#include <stdbool.h> + +/* `fov_shadowcast`: */ +/* map: your 2D enum tile grid + * mapsize: x: width, y: height of the map + * visblocking: pointer to a function that returns `true` when receiving a + * pointer to a LOS blocking tile + * lightmap: [out] 2D lightmap, this is simply overwritten with the + * distance to the source. range: visibility range/radius. src: 2D + * point to calculate FOV from + * */ +void fov_shadowcast(const void* map, const v2_i32 mapsize, + bool (*visblocking)(const void*), i32* lightmap, + const i32 range, v2_i32 src); + +#endif diff --git a/src/utils/include/engine/utils/hashmap.h b/src/utils/include/engine/utils/hashmap.h new file mode 100644 index 0000000..bf1d87c --- /dev/null +++ b/src/utils/include/engine/utils/hashmap.h @@ -0,0 +1,54 @@ +#ifndef ENGINE_HASHMAP_H +#define ENGINE_HASHMAP_H + +#include "types.h" + +#include "list.h" +#include "memory.h" +#include <stdlib.h> + +i32 lolhash(const usize s, i32 v); + +/* Define a linked list before using this */ +/* Example: DEFINE_LLIST(i32) */ +#define DEFINE_HASHMAP(type, lsize, cmp, type_to_int) \ + typedef DEFINE_LLIST(type); \ + typedef struct hashmap_##type { \ + usize size; \ + List_##type elems[64]; \ + } hashmap_##type; \ + \ + type* hashmap_##type##_lookup(hashmap_##type* hmap, const type* val) { \ + const i32 idx = lolhash(64, type_to_int(val)); \ + List_##type* head = &hmap->elems[idx]; \ + while (head != NULL) { \ + if (!cmp(&(head->value), val)) return &(head->value); \ + head = head->next; \ + } \ + return NULL; \ + } \ + \ + void hashmap_##type##_insert(memory* m, hashmap_##type* hmap, \ + const type* val) { \ + const i32 idx = lolhash(64, type_to_int(val)); \ + List_##type* head = &(hmap->elems[idx]); \ + \ + /* This is highly dependant on whether the memory is zero-initialized */ \ + if (!type_to_int(&(head->value))) { \ + memcpy(&(head->value), val, sizeof(type)); \ + return; \ + } \ + \ + while (head->next != NULL && cmp(&head->value, val)) { \ + head = head->next; \ + } \ + \ + if (!cmp(&head->value, val)) \ + memcpy(&(head->value), val, sizeof(type)); \ + else { \ + head->next = memory_allocate(m, sizeof(List_##type)); \ + memcpy(&(head->next->value), val, sizeof(type)); \ + } \ + } + +#endif diff --git a/src/utils/include/engine/utils/list.h b/src/utils/include/engine/utils/list.h new file mode 100644 index 0000000..37857f0 --- /dev/null +++ b/src/utils/include/engine/utils/list.h @@ -0,0 +1,11 @@ +#ifndef ENGINE_LIST_H +#define ENGINE_LIST_H + +#define DEFINE_LLIST(type) \ + struct List_##type { \ + type value; \ + struct List_##type* next; \ + /* Force the user to add `;` for style consistency */ \ + } List_##type + +#endif diff --git a/src/utils/include/engine/utils/stack.h b/src/utils/include/engine/utils/stack.h new file mode 100644 index 0000000..69975df --- /dev/null +++ b/src/utils/include/engine/utils/stack.h @@ -0,0 +1,50 @@ +/* Copyright © 2021 Upqwerk + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the “Software”), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * */ + +/* Stack implementation + * Author: Upqwerk + */ +#ifndef STACK_H +#define STACK_H + +#include "types.h" + +typedef struct { + isize head; /* current number of elements */ + const usize elem_size; /* size in bytes of each element */ + usize size; /* current memory size used by the stack */ + const usize chunk_size; /* size of which the stack increases when running out + of mem */ + void* data; /* memory buffer */ +} Stack; + +Stack stack_new_ex(const usize element_size, const usize size); + +Stack stack_new(const usize element_size); + +void stack_free(Stack* s); +void* stack_pop(Stack* s); +void stack_push(Stack* s, void* elem); +void* stack_peek(Stack* s); +isize stack_size(const Stack* s); +void stack_swap(Stack* s, Stack* t); + +#endif diff --git a/src/utils/include/engine/utils/utils.h b/src/utils/include/engine/utils/utils.h new file mode 100644 index 0000000..e537f52 --- /dev/null +++ b/src/utils/include/engine/utils/utils.h @@ -0,0 +1,36 @@ +#ifndef ENGINE_UTILS_H +#define ENGINE_UTILS_H + +#include "types.h" +#include "vector.h" + +#define MIN(a, b) ((a < b) ? (a) : (b)) +#define MAX(a, b) ((a > b) ? (a) : (b)) + +#define MASK_TL (1 << 0) +#define MASK_T (1 << 1) +#define MASK_TR (1 << 2) +#define MASK_L (1 << 3) +#define MASK_C (1 << 4) +#define MASK_R (1 << 5) +#define MASK_BL (1 << 6) +#define MASK_B (1 << 7) +#define MASK_BR (1 << 8) + +/* Linear interpolate */ +f32 lerp(f32 dt, f32 a, f32 b); +i32 int_lerp(f32 dt, i32 a, i32 b); + +/* Hashes */ +u32 hash(char* str); + +/* Masks surrounding tiles of a kernel size of 3x3 */ +/* In reality we only need 9 bits for this, but I think I had a reason for using + * i32 */ +i32* kernmap(const void* map, i32* dstmap, const v2_i32 mapsize, + predicate_t* predicate); + +/* Returns an index from the given weights. */ +i32 pick_from_sample(const i32* weights, i32 len); + +#endif diff --git a/src/utils/include/engine/utils/vector.h b/src/utils/include/engine/utils/vector.h new file mode 100644 index 0000000..58bb0a2 --- /dev/null +++ b/src/utils/include/engine/utils/vector.h @@ -0,0 +1,31 @@ +#ifndef VECTOR_H +#define VECTOR_H + +#include "types.h" + +#include <stdbool.h> +#include <stdio.h> + +typedef struct { + i32 x; + i32 y; +} v2_i32; + +bool v2_i32_eq(const v2_i32 a, const v2_i32 b); + +v2_i32 v2_i32_add(v2_i32 a, v2_i32 b); +v2_i32 v2_i32_add_i(v2_i32 a, i32 b); +v2_i32 v2_i32_sub(v2_i32 a, v2_i32 b); +v2_i32 v2_i32_sub_i(v2_i32 a, i32 b); +v2_i32 v2_i32_div(v2_i32 a, v2_i32 b); +v2_i32 v2_i32_div_i(v2_i32 a, i32 b); +v2_i32 v2_i32_mul(v2_i32 a, v2_i32 b); +v2_i32 v2_i32_mul_i(v2_i32 a, i32 b); +v2_i32 v2_i32_mod(v2_i32 a, v2_i32 b); +v2_i32 v2_i32_mod_i(v2_i32 a, i32 b); +v2_i32 v2_i32_max(v2_i32 a, v2_i32 b); +v2_i32 v2_i32_min(v2_i32 a, v2_i32 b); +v2_i32 v2_i32_lerp(f32 dt, v2_i32 a, v2_i32 b); + +void v2_i32_fprintf(FILE* stream, v2_i32 a); +#endif |