From 3231124346be2f281ff0e9472bb1ed665cae5200 Mon Sep 17 00:00:00 2001 From: jacekpoz Date: Tue, 13 Aug 2024 14:39:11 +0200 Subject: [PATCH] Squashed commit of the following: commit ef2fdaab863af71f7afcf23b469f4f220c538d8b Author: jacekpoz Date: Tue Aug 13 14:22:09 2024 +0200 improve all vector types by deunionifying them commit e9948256687a767e2e81a5c1aee2fd47942548c2 Author: jacekpoz Date: Tue Aug 13 14:19:56 2024 +0200 use w and h for radii in ellipse intersects commit 2eb53fb8a3045c3f3b5679a278158e6efecb8e98 Author: jacekpoz Date: Tue Aug 13 13:47:03 2024 +0200 add PTK_LIST_CLEAR commit a63f65067ded311192358c4aa54f207e307a8e02 Author: jacekpoz Date: Tue Aug 13 13:46:29 2024 +0200 remove semicolon from filled macro commit 4ac6a1bb70833579898034b4e44486ba62d5cfa6 Author: jacekpoz Date: Tue Aug 13 13:31:13 2024 +0200 ... commit 5142127ae0a73a83534561c6b3873b1cfb74ffab Author: jacekpoz Date: Tue Aug 13 12:50:08 2024 +0200 add clickable to components if encountered commit b1f31b79650ed7cb74715864b1332973382298fc Author: jacekpoz Date: Tue Aug 13 12:41:52 2024 +0200 stupid fucking switch syntax commit 8ff74e7235c34ed5a85258f568516d61a38dd416 Author: jacekpoz Date: Tue Aug 13 12:40:05 2024 +0200 remove redundant vertex update commit 448e9fed146fa547293a6ce4eb36841a53e26c6f Author: jacekpoz Date: Tue Aug 13 12:10:48 2024 +0200 handle button hitboxes properly commit a4025fa924b50eb1e51676626f30da8c54a1c34a Author: jacekpoz Date: Tue Aug 13 12:04:11 2024 +0200 add more const on local variables commit c7386ddfbff8e52ad21964c021e3d22b90c1010d Author: jacekpoz Date: Tue Aug 13 12:02:24 2024 +0200 fix rect triangle comments (xd) commit ca212ac65ec903ea448cb1cd8ae62b89b60fe5d3 Author: jacekpoz Date: Tue Aug 13 11:57:33 2024 +0200 spam const over local variables and function parameters commit 43707826d93d1f9a7a25306f76d4d78277bcbff7 Author: jacekpoz Date: Tue Aug 13 11:31:50 2024 +0200 improve rect triangle init readability commit 2b3f4c58c44277b8ee33b8a32449b807e28928f0 Author: jacekpoz Date: Tue Aug 13 02:08:18 2024 +0200 set ellipse rect's type to the ellipse's type commit 4872e59e16f1f1db8fc1bd504656c131d0d00be7 Merge: 336aadc 565aa4d Author: jacekpoz Date: Tue Aug 13 01:29:01 2024 +0200 Merge branch 'main' into button commit 336aadc7a01a2bdd9de2555638de92ac7c393b98 Author: jacekpoz Date: Tue Aug 13 01:25:13 2024 +0200 whoops forgot about this one commit 29f0d9f56a7439f8f224cc18be73d99b0b73705f Author: jacekpoz Date: Tue Aug 13 01:22:45 2024 +0200 improve component initialization compound literals zero-initialize all omitted fields including children.size, now we don't have to explicitly do that in each function commit 913286e9e70539a01d6ee5c8f1922db0785cb9fc Merge: 425e670 520b0b9 Author: jacekpoz Date: Tue Aug 13 01:18:39 2024 +0200 Merge branch 'main' into button commit 425e6709b4fd07ef958fa83c7e201f6cbd284615 Author: jacekpoz Date: Tue Aug 13 01:16:38 2024 +0200 initialize children size to 0 on childless components commit 70ef0e030fb63aeb9a18e003494d0f56f3e721e8 Author: jacekpoz Date: Tue Aug 13 01:13:39 2024 +0200 fix vertex input attribute description commit 44204b56777fee3fb5d60f9445d52dd61a641c78 Merge: 0788992 f95c47d Author: jacekpoz Date: Tue Aug 13 01:03:26 2024 +0200 Merge branch 'main' into button commit 0788992af425ec90bb0b998e6cfa99b50a938b11 Author: jacekpoz Date: Tue Aug 13 00:45:13 2024 +0200 remove vk_clickable from components commit 7cc71d31771b0dd5b3a29db17693e4b2268a5ff7 Merge: 3020724 b74186b Author: jacekpoz Date: Tue Aug 13 00:44:02 2024 +0200 Merge branch 'main' into button commit 30207243196ea3692565d3414d2bf8884462aed9 Merge: 83c7968 80a8069 Author: jacekpoz Date: Tue Aug 13 00:18:31 2024 +0200 Merge branch 'main' into button commit 83c7968d480a773c62d99d1c170cd2ec38f7b38d Author: jacekpoz Date: Tue Aug 13 00:03:51 2024 +0200 a few component changes before separating them from shapes commit 4b1fdf8e04b3c68aeb977a84730ce3faa3061057 Author: jacekpoz Date: Mon Aug 12 23:49:52 2024 +0200 rename button to clickable in one more place commit 6aeb2124d94d502e08f857bd2010ec2bc2d55081 Author: jacekpoz Date: Mon Aug 12 23:49:39 2024 +0200 improve box creation commit af3066ab7bcd555ca355695291f80a591638acff Author: jacekpoz Date: Mon Aug 12 23:48:39 2024 +0200 add pointer versions of add and remove all in ptk list commit b95ddb45a02f49cc4e424a284249b56d9babd9ba Author: jacekpoz Date: Mon Aug 12 23:48:14 2024 +0200 rename button to clickable commit 50197a6a2158fe6e141ecdbb23a0f7212453956b Author: jacekpoz Date: Sun Aug 11 21:09:02 2024 +0200 change default component members and add PTK_COMPONENT_DEFINE commit 2b5be4c732242461b5b20e0342f1a305a5f23aa3 Author: jacekpoz Date: Sun Aug 11 21:07:53 2024 +0200 extract PTK_LIST_STATIC_INIT into PTK_ARRAY commit 276138043dea71d6647e6c8d38b58f6fdb6a94ee Author: jacekpoz Date: Fri Aug 9 22:04:01 2024 +0200 make the example target not remove the binary commit c101379150352dc014e0d3b92347d7cab465ad17 Author: jacekpoz Date: Fri Aug 9 17:16:35 2024 +0200 initial button test --- examples/Makefile | 4 +- examples/amogus.c | 2 +- examples/button.c | 30 ++++++++ include/ptk.h | 57 ++++++++------ include/ptk_log.h | 14 ++-- include/ptk_vec.h | 66 ++++++++--------- src/ptk.c | 110 ++++++++++++++++----------- src/ptk_array.h | 18 +++++ src/ptk_list.h | 14 ++-- src/ptk_log.c | 18 ++--- src/ptk_vk/components.c | 159 +++++++++++++++++++++++++++++++--------- src/ptk_vk/components.h | 6 +- src/ptk_vk/draw.c | 22 +++--- src/ptk_vk/init.c | 121 +++++++++++++++--------------- src/ptk_vk/init.h | 6 +- src/ptk_vk/utils.h | 2 +- test/list.c | 14 ++-- 17 files changed, 420 insertions(+), 243 deletions(-) create mode 100644 examples/button.c create mode 100644 src/ptk_array.h diff --git a/examples/Makefile b/examples/Makefile index 457e03c..ecc6c54 100644 --- a/examples/Makefile +++ b/examples/Makefile @@ -13,7 +13,7 @@ NAMES = $(OBJ:$(EXAMPLE_DIR)/%=%) all: ifdef EXAMPLE - $(MAKE) -f $(EXAMPLE_DIR)/Makefile example-$(EXAMPLE) + $(MAKE) -f $(EXAMPLE_DIR)/Makefile example else @echo "you need to pick a test: make example EXAMPLE=" @echo -n "available examples:" @@ -21,7 +21,7 @@ else @echo endif -example-%: $(BIN)/$(EXAMPLE_DIR)/% +example: $(BIN)/$(EXAMPLE_DIR)/$(EXAMPLE) LD_LIBRARY_PATH=$(BIN) $(BIN)/$(EXAMPLE_DIR)/$(EXAMPLE) $(BIN)/%: %.c diff --git a/examples/amogus.c b/examples/amogus.c index a3f3fa1..f87c477 100644 --- a/examples/amogus.c +++ b/examples/amogus.c @@ -8,7 +8,7 @@ int main(void) { return EXIT_FAILURE; } - PtkColor red = { .r = 1.0f, .g = 0.0f, .b = 0.0f }; + const PtkColor red = { .r = 1.0f, .g = 0.0f, .b = 0.0f }; return ptk_run(PTK_BOX( ptk_rect((PtkPos){ .x = 250.0f, .y = 200.0f }, (PtkSize){ .w = 300.0f, .h = 200.0f }, red), diff --git a/examples/button.c b/examples/button.c new file mode 100644 index 0000000..40963e0 --- /dev/null +++ b/examples/button.c @@ -0,0 +1,30 @@ +#include +#include +#include + +static PtkRect *r; + +static void on_press(const int button, const int action, const int mods) { + (void)button; (void)action; (void)mods; + PTK_DEBUG("pressed!"); + r->color.r = r->color.r + (1.0f / 255.0f); + if (r->color.r == 256.0f) { + r->color.r = 0.0f; + } +} + +int main(void) { + if (!ptk_init(800, 600, "button", (PtkVersion){ .major = 0, .minor = 1, .patch = 0 })) { + return EXIT_FAILURE; + } + + r = (PtkRect *)ptk_rect( + (PtkPos){ .x = 100.0f, .y = 100.0f }, + (PtkSize){ .w = 100.0f, .h = 50.0f }, + (PtkColor){ .r = 1.0f, .g = 0.0f, .b = 0.0f } + ); + + return ptk_run( + ptk_clickable((PtkHandle)r, on_press) + ); +} diff --git a/include/ptk.h b/include/ptk.h index 36fe213..b069194 100644 --- a/include/ptk.h +++ b/include/ptk.h @@ -1,6 +1,7 @@ #ifndef PTK_PTK_H_ #define PTK_PTK_H_ +#include #include #include @@ -13,7 +14,7 @@ typedef struct { uint32_t patch; } PtkVersion; -bool ptk_init(size_t width, size_t height, const char *title, PtkVersion application_version); +bool ptk_init(const size_t width, const size_t height, const char *title, const PtkVersion application_version); typedef struct PtkComponent *PtkHandle; #define PTK_NULL_HANDLE (void *)0 @@ -23,44 +24,52 @@ typedef enum { PTK_COMPONENT_TYPE_TRIANGLE = 1, PTK_COMPONENT_TYPE_RECT = 2, PTK_COMPONENT_TYPE_ELLIPSE = 3, + PTK_COMPONENT_TYPE_CLICKABLE = 4, } PtkComponentType; -typedef struct PtkComponent { - PtkComponentType type; -} PtkComponent; +PTK_LIST_DEFINE(PtkHandle); -typedef struct PtkBox { - PtkComponentType type; - size_t child_count; - PtkHandle *children; -} PtkBox; +#define PTK_COMPONENT_DEFINE(name, ...) \ + typedef struct name {\ + PtkComponentType type;\ + PtkHandle parent;\ + PTK_LIST(PtkHandle) children;\ + __VA_ARGS__\ + } name -typedef struct PtkTriangle { - PtkComponentType type; +PTK_COMPONENT_DEFINE(PtkComponent, ); + +PTK_COMPONENT_DEFINE(PtkTriangle, PtkPos vertices[3]; PtkColor color; -} PtkTriangle; +); -typedef struct PtkRect { - PtkComponentType type; +PTK_COMPONENT_DEFINE(PtkRect, PtkPos top_left; PtkSize size; PtkColor color; -} PtkRect; +); -typedef struct PtkEllipse { - PtkComponentType type; +PTK_COMPONENT_DEFINE(PtkEllipse, PtkPos center; PtkSize radii; PtkColor color; -} PtkEllipse; +); -PtkHandle ptk_box(size_t child_count, PtkHandle *children); -PtkHandle ptk_triangle(PtkPos vertices[3], PtkColor color); -PtkHandle ptk_rect(PtkPos top_left, PtkSize size, PtkColor color); -PtkHandle ptk_square(PtkPos top_left, float size, PtkColor color); -PtkHandle ptk_ellipse(PtkPos center, PtkSize radii, PtkColor color); -PtkHandle ptk_circle(PtkPos center, float radius, PtkColor color); +typedef void (*MouseButtonCallback)(const int button, const int action, const int mods); + +PTK_COMPONENT_DEFINE(PtkClickable, + PtkHandle hitbox; + MouseButtonCallback on_press; +); + +PtkHandle ptk_box(const size_t child_count, PtkHandle *children); +PtkHandle ptk_triangle(const PtkPos vertices[3], const PtkColor color); +PtkHandle ptk_rect(const PtkPos top_left, const PtkSize size, const PtkColor color); +PtkHandle ptk_square(const PtkPos top_left, const float size, const PtkColor color); +PtkHandle ptk_ellipse(const PtkPos center, const PtkSize radii, const PtkColor color); +PtkHandle ptk_circle(const PtkPos center, const float radius, const PtkColor color); +PtkHandle ptk_clickable(PtkHandle hitbox, const MouseButtonCallback on_press); #define PTK_BOX(...) ptk_box(sizeof((PtkHandle []){ __VA_ARGS__ }) / sizeof(PtkHandle), (PtkHandle []) { __VA_ARGS__ }) diff --git a/include/ptk_log.h b/include/ptk_log.h index df94d78..9bbacc7 100644 --- a/include/ptk_log.h +++ b/include/ptk_log.h @@ -14,15 +14,15 @@ typedef enum { PTK_LOG_LEVEL_ALL = INT_MAX, } PtkLogLevel; -void ptk_log_init(PtkLogLevel level); +void ptk_log_init(const PtkLogLevel level); -void ptk_log(const char *file, int line, PtkLogLevel level, const char *fmt, ...); +void ptk_log(const char *file, const int line, const PtkLogLevel level, const char *fmt, ...); -void ptk_err (const char *file, int line, const char *fmt, ...); -void ptk_warn (const char *file, int line, const char *fmt, ...); -void ptk_info (const char *file, int line, const char *fmt, ...); -void ptk_debug(const char *file, int line, const char *fmt, ...); -void ptk_trace(const char *file, int line, const char *fmt, ...); +void ptk_err (const char *file, const int line, const char *fmt, ...); +void ptk_warn (const char *file, const int line, const char *fmt, ...); +void ptk_info (const char *file, const int line, const char *fmt, ...); +void ptk_debug(const char *file, const int line, const char *fmt, ...); +void ptk_trace(const char *file, const int line, const char *fmt, ...); #define PTK_LOG(level, ...) ptk_log(__FILE__, __LINE__, level, __VA_ARGS__) diff --git a/include/ptk_vec.h b/include/ptk_vec.h index d63684d..fa5d1b1 100644 --- a/include/ptk_vec.h +++ b/include/ptk_vec.h @@ -1,65 +1,63 @@ #ifndef PTK_PTK_VEC_H_ #define PTK_PTK_VEC_H_ -typedef union { - struct { // PtkVec2, PtkPos - float x; - float y; - }; - struct { // PtkSize - float w; - float h; - }; - struct { // PtkSize - float width; - float height; - }; +typedef struct { + float x; + float y; } PtkVec2; typedef PtkVec2 PtkPos; -typedef PtkVec2 PtkSize; typedef union { - struct { // PtkVec3 - float x; - float y; - float z; + struct { + float w; + float h; }; - struct { // PtkColor + struct { + float width; + float height; + }; +} PtkSize; + +typedef struct { + float x; + float y; + float z; +} PtkVec3; + +typedef union { + struct { float r; float g; float b; }; - struct { // PtkColor + struct { float red; float green; float blue; }; -} PtkVec3; +} PtkColor; -typedef PtkVec3 PtkColor; +typedef struct { + float x; + float y; + float z; + float w; +} PtkVec4; typedef union { - struct { // PtkVec4 - float x; - float y; - float z; - float w; - }; - struct { // PtkColorA + struct { float r; float g; float b; float a; }; - struct { // PtkColorA + struct { float red; float green; float blue; float alpha; }; -} PtkVec4; +} PtkColorA; -typedef PtkVec4 PtkColorA; - -#endif // _PTK_PTK_VEC_H +#endif // PTK_PTK_VEC_H_ diff --git a/src/ptk.c b/src/ptk.c index a6128bd..a6cd946 100644 --- a/src/ptk.c +++ b/src/ptk.c @@ -23,11 +23,27 @@ static GLFWwindow *g_window = NULL; -void framebuffer_resize_callback(GLFWwindow *window, int width, int height) { +static void framebuffer_resize_callback(GLFWwindow *window, int width, int height) { (void)window; (void)width; (void)height; g_framebuffer_resized = true; } +static void key_callback(GLFWwindow *window, int key, int scancode, int action, int mods) { + (void)window; (void)scancode; (void)action; (void)mods; + if (key == GLFW_KEY_SPACE) { + for (size_t i = 0; i < g_vertices.size; ++i) { + g_vertices.data[i].pos.x += 1.0f; + } + vk_transfer_vertex_data(); + } +} + +static void mouse_button_callback(GLFWwindow *window, int button, int action, int mods) { + double x, y; + glfwGetCursorPos(window, &x, &y); + vk_handle_mouse_button_input((PtkPos){ .x = x, .y = y }, button, action, mods); +} + PTK_OPTION_DEFINE(PtkLogLevel); PTK_OPTION(PtkLogLevel) get_log_level(void) { @@ -38,7 +54,7 @@ PTK_OPTION(PtkLogLevel) get_log_level(void) { return PTK_OPTION_NONE(PtkLogLevel); } - size_t log_level_len = strlen(log_level); + const size_t log_level_len = strlen(log_level); char *lowercase = malloc(log_level_len * sizeof(char)); @@ -72,8 +88,8 @@ PTK_OPTION(PtkLogLevel) get_log_level(void) { return ret; } -bool ptk_init(size_t width, size_t height, const char *title, PtkVersion application_version) { - PTK_OPTION(PtkLogLevel) log_level = get_log_level(); +bool ptk_init(const size_t width, const size_t height, const char *title, const PtkVersion application_version) { + const PTK_OPTION(PtkLogLevel) log_level = get_log_level(); if (log_level.exists) { ptk_log_init(log_level.value); } @@ -103,6 +119,8 @@ bool ptk_init(size_t width, size_t height, const char *title, PtkVersion applica } glfwSetFramebufferSizeCallback(g_window, framebuffer_resize_callback); + glfwSetKeyCallback(g_window, key_callback); + glfwSetMouseButtonCallback(g_window, mouse_button_callback); vk_components_init(); @@ -114,74 +132,82 @@ bool ptk_init(size_t width, size_t height, const char *title, PtkVersion applica return true; } -PtkHandle ptk_box(size_t child_count, PtkHandle *children) { - PtkBox *ret = malloc(sizeof(PtkBox)); - ret->type = PTK_COMPONENT_TYPE_BOX; - ret->child_count = child_count; - ret->children = children; +PtkHandle ptk_box(const size_t child_count, PtkHandle *children) { + PtkComponent *ret = malloc(sizeof(PtkComponent)); + *ret = (PtkComponent){ + .type = PTK_COMPONENT_TYPE_BOX, + .children = PTK_LIST_NEW(PtkHandle, child_count), + }; + PTK_LIST_ADD_ALL_P(PtkHandle, ret->children, children, child_count); return (PtkHandle)ret; } -PtkHandle ptk_triangle(PtkPos vertices[3], PtkColor color) { +PtkHandle ptk_triangle(const PtkPos vertices[3], const PtkColor color) { PtkTriangle *ret = malloc(sizeof(PtkTriangle)); - ret->type = PTK_COMPONENT_TYPE_TRIANGLE; + *ret = (PtkTriangle){ + .type = PTK_COMPONENT_TYPE_TRIANGLE, + .color = color, + }; memcpy(ret->vertices, vertices, sizeof(PtkPos) * 3); - ret->color = color; return (PtkHandle)ret; } -PtkHandle ptk_rect(PtkPos top_left, PtkSize size, PtkColor color) { +PtkHandle ptk_rect(const PtkPos top_left, const PtkSize size, const PtkColor color) { PtkRect *ret = malloc(sizeof(PtkRect)); - ret->type = PTK_COMPONENT_TYPE_RECT; - ret->top_left = top_left; - ret->size = size; - ret->color = color; + *ret = (PtkRect){ + .type = PTK_COMPONENT_TYPE_RECT, + .top_left = top_left, + .size = size, + .color = color, + }; return (PtkHandle)ret; } -PtkHandle ptk_square(PtkPos top_left, float size, PtkColor color) { +PtkHandle ptk_square(const PtkPos top_left, const float size, const PtkColor color) { return ptk_rect(top_left, (PtkSize){ .w = size, .h = size }, color); } -PtkHandle ptk_ellipse(PtkPos center, PtkSize radii, PtkColor color) { +PtkHandle ptk_ellipse(const PtkPos center, const PtkSize radii, const PtkColor color) { PtkEllipse *ret = malloc(sizeof(PtkEllipse)); - ret->type = PTK_COMPONENT_TYPE_ELLIPSE; - ret->center = center; - ret->radii = radii; - ret->color = color; + *ret = (PtkEllipse){ + .type = PTK_COMPONENT_TYPE_ELLIPSE, + .center = center, + .radii = radii, + .color = color, + }; return (PtkHandle)ret; } -PtkHandle ptk_circle(PtkPos center, float radius, PtkColor color) { +PtkHandle ptk_circle(const PtkPos center, const float radius, const PtkColor color) { return ptk_ellipse(center, (PtkSize){ .w = radius, .h = radius }, color); } -void init_components(PtkHandle root) { - switch (root->type) { - case PTK_COMPONENT_TYPE_TRIANGLE: { - vk_triangle((PtkTriangle *)root); - } break; - case PTK_COMPONENT_TYPE_RECT: { - vk_rect((PtkRect *)root); - } break; - case PTK_COMPONENT_TYPE_ELLIPSE: { - vk_ellipse((PtkEllipse *)root); - } break; - case PTK_COMPONENT_TYPE_BOX: { - PtkBox *box = (PtkBox *)root; - for (size_t i = 0; i < box->child_count; ++i) { - init_components(box->children[i]); - } - } break; +PtkHandle ptk_clickable(PtkHandle hitbox, const MouseButtonCallback on_press) { + PtkClickable *ret = malloc(sizeof(PtkClickable)); + *ret = (PtkClickable){ + .type = PTK_COMPONENT_TYPE_CLICKABLE, + .hitbox = hitbox, + .on_press = on_press, + }; + + return (PtkHandle)ret; +} + +void init_component(PtkHandle component) { + vk_component(component); + for (size_t i = 0; i < component->children.size; ++i) { + PtkHandle child = component->children.data[i]; + child->parent = component; + init_component(child); } } int ptk_run(PtkHandle root) { - init_components(root); + init_component(root); while (!glfwWindowShouldClose(g_window)) { glfwPollEvents(); diff --git a/src/ptk_array.h b/src/ptk_array.h new file mode 100644 index 0000000..6f5ab79 --- /dev/null +++ b/src/ptk_array.h @@ -0,0 +1,18 @@ +#ifndef PTK_PTK_ARRAY_H_ +#define PTK_PTK_ARRAY_H_ + +#define PTK_ARRAY(T) struct PtkArray_##T + +#define PTK_ARRAY_DEFINE(T) \ + PTK_ARRAY(T) {\ + T *data;\ + uint32_t size;\ + }\ + +#define PTK_ARRAY_NEW(T, ...) \ + (PTK_ARRAY(T)){\ + .data = (T []) __VA_ARGS__ ,\ + .size = sizeof((T []) __VA_ARGS__) / sizeof(T),\ + } + +#endif // PTK_PTK_ARRAY_H_ diff --git a/src/ptk_list.h b/src/ptk_list.h index 303bf48..8efa9c8 100644 --- a/src/ptk_list.h +++ b/src/ptk_list.h @@ -14,10 +14,14 @@ #define PTK_LIST_ADD_ALL(T, list, ...) _add_PtkList((void **)&list.data, &list.size, &list.allocated, (T []) __VA_ARGS__, sizeof((T []) __VA_ARGS__) / sizeof(T), sizeof(T)) +#define PTK_LIST_ADD_ALL_P(T, list, p_elem, elem_count) _add_PtkList((void **)&list.data, &list.size, &list.allocated, p_elem, elem_count, sizeof(T)) + #define PTK_LIST_REMOVE(T, list, elem) _remove_PtkList((void *)list.data, &list.size, &elem, 1, sizeof(T)) #define PTK_LIST_REMOVE_ALL(T, list, ...) _remove_PtkList((void *)list.data, &list.size, (T []) __VA_ARGS__, sizeof((T []) __VA_ARGS__) / sizeof(T), sizeof(T)) +#define PTK_LIST_REMOVE_ALL_P(T, list, p_elem, elem_count) _remove_PtkList((void *)list.data, &list.size, p_elem, elem_count, sizeof(T)) + #define PTK_LIST_REMOVE_AT(T, list, index) _remove_at_PtkList((void *)list.data, &list.size, index, sizeof(T)) bool _grow_PtkList(void **data, uint32_t *allocated, size_t element_size); @@ -39,18 +43,14 @@ bool _remove_at_PtkList(void *data, uint32_t *size, size_t index, size_t element .allocated = _size,\ } -#define PTK_LIST_STATIC_INIT(T, ...) \ - (PTK_LIST(T)){\ - .data = (T []) __VA_ARGS__ ,\ - .size = sizeof((T []) __VA_ARGS__) / sizeof(T),\ - .allocated = sizeof((T []) __VA_ARGS__) / sizeof(T),\ - } +#define PTK_LIST_CLEAR(list) \ + list.size = 0 #define PTK_LIST_FREE(list) \ free(list.data) #define PTK_LIST_FILLED(list) \ - list.size = list.allocated; + list.size = list.allocated PTK_LIST_DEFINE(char); diff --git a/src/ptk_log.c b/src/ptk_log.c index 5c34fbe..7e3cbf5 100644 --- a/src/ptk_log.c +++ b/src/ptk_log.c @@ -8,7 +8,7 @@ #define BG(r, g, b) "\033[48;2;" #r ";" #g ";" #b "m" #define RESET "\033[0m" -static const char *log_level_to_str(PtkLogLevel level) { +static const char *log_level_to_str(const PtkLogLevel level) { const char *ret; switch (level) { case PTK_LOG_LEVEL_ERR: ret = FG(235, 28, 35) " ERR" RESET; break; @@ -27,11 +27,11 @@ static PtkLogLevel log_level = PTK_LOG_LEVEL_DEBUG; static PtkLogLevel log_level = PTK_LOG_LEVEL_WARN; #endif -void ptk_log_init(PtkLogLevel level) { +void ptk_log_init(const PtkLogLevel level) { log_level = level; } -void _ptk_log(const char *file, int line, PtkLogLevel level, const char *fmt, va_list args) { +void _ptk_log(const char *file, const int line, const PtkLogLevel level, const char *fmt, va_list args) { if (log_level < level) { return; } fprintf(stderr, "[%s | %s:%d] ", log_level_to_str(level), file, line); @@ -41,15 +41,15 @@ void _ptk_log(const char *file, int line, PtkLogLevel level, const char *fmt, va fprintf(stderr, "\n"); } -void ptk_log(const char *file, int line, PtkLogLevel level, const char *fmt, ...) { +void ptk_log(const char *file, const int line, const PtkLogLevel level, const char *fmt, ...) { va_list args; va_start(args, fmt); _ptk_log(file, line, level, fmt, args); va_end(args); } -void ptk_err (const char *file, int line, const char *fmt, ...) { va_list args; va_start(args, fmt); _ptk_log(file, line, PTK_LOG_LEVEL_ERR, fmt, args); va_end(args); } -void ptk_warn (const char *file, int line, const char *fmt, ...) { va_list args; va_start(args, fmt); _ptk_log(file, line, PTK_LOG_LEVEL_WARN, fmt, args); va_end(args); } -void ptk_info (const char *file, int line, const char *fmt, ...) { va_list args; va_start(args, fmt); _ptk_log(file, line, PTK_LOG_LEVEL_INFO, fmt, args); va_end(args); } -void ptk_debug(const char *file, int line, const char *fmt, ...) { va_list args; va_start(args, fmt); _ptk_log(file, line, PTK_LOG_LEVEL_DEBUG, fmt, args); va_end(args); } -void ptk_trace(const char *file, int line, const char *fmt, ...) { va_list args; va_start(args, fmt); _ptk_log(file, line, PTK_LOG_LEVEL_TRACE, fmt, args); va_end(args); } +void ptk_err (const char *file, const int line, const char *fmt, ...) { va_list args; va_start(args, fmt); _ptk_log(file, line, PTK_LOG_LEVEL_ERR, fmt, args); va_end(args); } +void ptk_warn (const char *file, const int line, const char *fmt, ...) { va_list args; va_start(args, fmt); _ptk_log(file, line, PTK_LOG_LEVEL_WARN, fmt, args); va_end(args); } +void ptk_info (const char *file, const int line, const char *fmt, ...) { va_list args; va_start(args, fmt); _ptk_log(file, line, PTK_LOG_LEVEL_INFO, fmt, args); va_end(args); } +void ptk_debug(const char *file, const int line, const char *fmt, ...) { va_list args; va_start(args, fmt); _ptk_log(file, line, PTK_LOG_LEVEL_DEBUG, fmt, args); va_end(args); } +void ptk_trace(const char *file, const int line, const char *fmt, ...) { va_list args; va_start(args, fmt); _ptk_log(file, line, PTK_LOG_LEVEL_TRACE, fmt, args); va_end(args); } diff --git a/src/ptk_vk/components.c b/src/ptk_vk/components.c index 2c7422c..0eb08a9 100644 --- a/src/ptk_vk/components.c +++ b/src/ptk_vk/components.c @@ -1,11 +1,10 @@ // Copyright (jacekpoz 2024). Licensed under the EUPL-1.2 or later. #include +#include #include #include -PTK_LIST_DEFINE(PtkHandle); - PTK_LIST(PtkHandle) m_components; PTK_LIST(Vertex) g_vertices; @@ -23,12 +22,12 @@ void vk_components_init(void) { g_vertices = PTK_LIST_NEW(Vertex, 1); } -void _vk_triangle(PtkTriangle *triangle, PtkComponentType type, size_t uvs_offset) { +void triangle(const PtkTriangle *triangle, const size_t uvs_offset) { for (size_t i = 0; i < 3; ++i) { Vertex v = { .pos = triangle->vertices[i], .color = triangle->color, - .shape_type = type, + .shape_type = triangle->type, .uv = uvs[i + uvs_offset], }; @@ -36,58 +35,150 @@ void _vk_triangle(PtkTriangle *triangle, PtkComponentType type, size_t uvs_offse } } -void vk_triangle(PtkTriangle *triangle) { - PTK_LIST_ADD(PtkHandle, m_components, triangle); +void rect(const PtkRect *rect) { + const float x = rect->top_left.x; + const float y = rect->top_left.y; + const float w = rect->size.w; + const float h = rect->size.h; - _vk_triangle(triangle, PTK_COMPONENT_TYPE_TRIANGLE, 0); - vk_transfer_vertex_data(); -} - -void _vk_rect(PtkRect *rect, PtkComponentType type) { PtkPos t1_positions[3]; // top left - t1_positions[0] = (PtkPos){ .x = rect->top_left.x, .y = rect->top_left.y }; - // bottom left - t1_positions[1] = (PtkPos){ .x = rect->top_left.x + rect->size.w, .y = rect->top_left.y }; + t1_positions[0] = (PtkPos){ .x = x, .y = y }; // top right - t1_positions[2] = (PtkPos){ .x = rect->top_left.x, .y = rect->top_left.y + rect->size.h }; + t1_positions[1] = (PtkPos){ .x = x + w, .y = y }; + // bottom left + t1_positions[2] = (PtkPos){ .x = x, .y = y + h }; PtkTriangle *t1 = (PtkTriangle *)ptk_triangle((PtkPos *)t1_positions, rect->color); + t1->type = rect->type; - _vk_triangle(t1, type, 0); + triangle(t1, 0); PtkPos t2_positions[3]; - // bottom left - t2_positions[0] = (PtkPos){ .x = rect->top_left.x + rect->size.w, .y = rect->top_left.y }; // top right - t2_positions[1] = (PtkPos){ .x = rect->top_left.x, .y = rect->top_left.y + rect->size.h }; + t2_positions[0] = (PtkPos){ .x = x + w, .y = y }; + // bottom left + t2_positions[1] = (PtkPos){ .x = x, .y = y + h }; // bottom right - t2_positions[2] = (PtkPos){ .x = rect->top_left.x + rect->size.w, .y = rect->top_left.y + rect->size.h }; + t2_positions[2] = (PtkPos){ .x = x + w, .y = y + h }; PtkTriangle *t2 = (PtkTriangle *)ptk_triangle((PtkPos *)t2_positions, rect->color); + t2->type = rect->type; - _vk_triangle(t2, type, 1); - vk_transfer_vertex_data(); + triangle(t2, 1); } -void vk_rect(PtkRect *rect) { - PTK_LIST_ADD(PtkHandle, m_components, rect); - - _vk_rect(rect, PTK_COMPONENT_TYPE_RECT); -} - -void vk_ellipse(PtkEllipse *ellipse) { - PTK_LIST_ADD(PtkHandle, m_components, ellipse); - - PtkPos top_left = { +void ellipse(const PtkEllipse *ellipse) { + const PtkPos top_left = { .x = ellipse->center.x - ellipse->radii.w, .y = ellipse->center.y - ellipse->radii.h, }; - PtkSize size = { + const PtkSize size = { .w = ellipse->radii.w * 2.0f, .h = ellipse->radii.h * 2.0f, }; - _vk_rect((PtkRect *)ptk_rect(top_left, size, ellipse->color), PTK_COMPONENT_TYPE_ELLIPSE); + PtkRect *r = (PtkRect *)ptk_rect(top_left, size, ellipse->color); + r->type = ellipse->type; + + rect(r); +} + +void vk_component(PtkHandle component) { + if (component->type == PTK_COMPONENT_TYPE_BOX) { + return; + } + + PTK_LIST_ADD(PtkHandle, m_components, component); + + if (component->type == PTK_COMPONENT_TYPE_CLICKABLE) { + PtkClickable *c = (PtkClickable *)component; + vk_component(c->hitbox); + return; + } + + switch (component->type) { + case PTK_COMPONENT_TYPE_TRIANGLE: { + triangle((PtkTriangle *)component, 0); + } break; + case PTK_COMPONENT_TYPE_RECT: { + rect((PtkRect *)component); + } break; + case PTK_COMPONENT_TYPE_ELLIPSE: { + ellipse((PtkEllipse *)component); + } break; + default: { + return; + } + } + + vk_transfer_vertex_data(); +} + +inline bool triangle_intersects(const PtkTriangle t, const PtkPos p) { + const PtkPos p0 = t.vertices[0]; + const PtkPos p1 = t.vertices[1]; + const PtkPos p2 = t.vertices[2]; + const float a = 1.0f/2.0f * (-p1.y * p2.x + p0.y * (-p1.x + p2.x) + p0.x * (p1.y - p2.y) + p1.x * p2.y); + const int sign = a < 0.0f ? -1 : 1; + const float s = (p0.y * p2.x - p0.x * p2.y + (p2.y - p0.y) * p.x + (p0.x - p2.x) * p.y) * sign; + const float r = (p0.x * p1.y - p0.y * p1.x + (p0.y - p1.y) * p.x + (p1.x - p0.x) * p.y) * sign; + + return s > 0 && r > 0 && (s + r) < 2 * a * sign; +} + +inline bool rect_intersects(const PtkRect r, const PtkPos p) { + const bool intersects_x = p.x >= r.top_left.x && + p.x <= r.top_left.x + r.size.w; + + const bool intersects_y = p.y >= r.top_left.y && + p.y <= r.top_left.y + r.size.h; + + return intersects_x && intersects_y; +} + +inline bool ellipse_intersects(const PtkEllipse e, const PtkPos p) { + const float x = p.x - e.center.x; + const float rx = e.radii.w; + const float y = p.y - e.center.y; + const float ry = e.radii.h; + return ((x * x) / (rx * rx)) + ((y * y) / (ry * ry)) <= 1.0f; +} + +bool intersects(const PtkHandle component, const PtkPos point) { + switch (component->type) { + case PTK_COMPONENT_TYPE_BOX: { + for (size_t i = 0; i < component->children.size; ++i) { + if (intersects(component->children.data[i], point)) { + return true; + } + } + + return false; + } + case PTK_COMPONENT_TYPE_TRIANGLE: + return triangle_intersects(*(PtkTriangle *)component, point); + case PTK_COMPONENT_TYPE_RECT: + return rect_intersects(*(PtkRect *)component, point); + case PTK_COMPONENT_TYPE_ELLIPSE: + return ellipse_intersects(*(PtkEllipse *)component, point); + case PTK_COMPONENT_TYPE_CLICKABLE: + return intersects(((PtkClickable *)component)->hitbox, point); + } +} + +void vk_handle_mouse_button_input(const PtkPos cursor_pos, const int button, const int action, const int mods) { + for (size_t i = 0; i < m_components.size; ++i) { + const PtkHandle current = m_components.data[i]; + if (current->type != PTK_COMPONENT_TYPE_CLICKABLE) { + continue; + } + + const PtkClickable *c = (PtkClickable *)current; + + if (intersects((PtkHandle)c, cursor_pos)) { + c->on_press(button, action, mods); + } + } } void vk_components_cleanup(void) { diff --git a/src/ptk_vk/components.h b/src/ptk_vk/components.h index 74c8944..941c9c0 100644 --- a/src/ptk_vk/components.h +++ b/src/ptk_vk/components.h @@ -19,9 +19,9 @@ extern PTK_LIST(Vertex) g_vertices; void vk_components_init(void); -void vk_triangle(PtkTriangle *triangle); -void vk_rect(PtkRect *rect); -void vk_ellipse(PtkEllipse *ellipse); +void vk_component(PtkHandle component); + +void vk_handle_mouse_button_input(const PtkPos cursor_pos, const int button, const int action, const int mode); void vk_components_cleanup(void); diff --git a/src/ptk_vk/draw.c b/src/ptk_vk/draw.c index 6ea0907..c58d75d 100644 --- a/src/ptk_vk/draw.c +++ b/src/ptk_vk/draw.c @@ -16,7 +16,7 @@ bool vk_draw_frame(void) { vkWaitForFences(g_dev, 1, &g_in_flight_fences.data[g_current_frame], VK_TRUE, UINT64_MAX); uint32_t image_index; - VkResult res = vkAcquireNextImageKHR( + const VkResult acquire_next_image_result = vkAcquireNextImageKHR( g_dev, g_swapchain, UINT64_MAX, @@ -25,13 +25,13 @@ bool vk_draw_frame(void) { &image_index ); - if (res == VK_ERROR_OUT_OF_DATE_KHR) { + if (acquire_next_image_result == VK_ERROR_OUT_OF_DATE_KHR) { if (!vk_recreate_swapchain()) { return false; } return true; - } else if (res != VK_SUCCESS && res != VK_SUBOPTIMAL_KHR) { - PTK_ERR("%s", vk_result_string(res)); + } else if (acquire_next_image_result != VK_SUCCESS && acquire_next_image_result != VK_SUBOPTIMAL_KHR) { + PTK_ERR("%s", vk_result_string(acquire_next_image_result)); return false; } @@ -45,7 +45,7 @@ bool vk_draw_frame(void) { return false; } - VkSemaphore signal_semaphores[] = {g_render_finished_semaphores.data[g_current_frame]}; + const VkSemaphore signal_semaphores[] = {g_render_finished_semaphores.data[g_current_frame]}; VK_TRY(false, vkQueueSubmit( @@ -66,7 +66,7 @@ bool vk_draw_frame(void) { ) ); - res = vkQueuePresentKHR(g_present_queue, &(VkPresentInfoKHR){ + const VkResult queue_present_result = vkQueuePresentKHR(g_present_queue, &(VkPresentInfoKHR){ .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, .pNext = NULL, .waitSemaphoreCount = 1, @@ -77,14 +77,18 @@ bool vk_draw_frame(void) { .pResults = NULL, }); - if (res == VK_ERROR_OUT_OF_DATE_KHR || res == VK_SUBOPTIMAL_KHR || g_framebuffer_resized) { + if ( + queue_present_result == VK_ERROR_OUT_OF_DATE_KHR || + queue_present_result == VK_SUBOPTIMAL_KHR || + g_framebuffer_resized + ) { g_framebuffer_resized = false; if (!vk_recreate_swapchain()) { return false; } PTK_TRACE("recreated swapchain"); - } else if (res != VK_SUCCESS) { - PTK_ERR("%s", vk_result_string(res)); + } else if (queue_present_result != VK_SUCCESS) { + PTK_ERR("%s", vk_result_string(queue_present_result)); return false; } diff --git a/src/ptk_vk/init.c b/src/ptk_vk/init.c index 103d280..4b0d8ea 100644 --- a/src/ptk_vk/init.c +++ b/src/ptk_vk/init.c @@ -8,6 +8,7 @@ #include #include +#include #include #include #include @@ -20,7 +21,7 @@ PTK_OPTION_DEFINE(uint32_t); PTK_LIST_DEFINE(VkSurfaceFormatKHR); PTK_LIST_DEFINE(VkPresentModeKHR); PTK_LIST_DEFINE(VkFramebuffer); -PTK_LIST_DEFINE(VkVertexInputAttributeDescription); +PTK_ARRAY_DEFINE(VkVertexInputAttributeDescription); PTK_LIST_DEFINE(VkExtensionProperties); PTK_LIST_DEFINE(VkQueueFamilyProperties); PTK_OPTION_DEFINE(VkShaderModule); @@ -87,7 +88,7 @@ static const VkVertexInputBindingDescription m_vertex_binding_description = { .inputRate = VK_VERTEX_INPUT_RATE_VERTEX, }; -PTK_LIST(VkVertexInputAttributeDescription) m_vertex_attribute_descriptions = PTK_LIST_STATIC_INIT(VkVertexInputAttributeDescription, { +PTK_ARRAY(VkVertexInputAttributeDescription) m_vertex_attribute_descriptions = PTK_ARRAY_NEW(VkVertexInputAttributeDescription, { (VkVertexInputAttributeDescription){ .location = 0, .binding = 0, @@ -109,7 +110,7 @@ PTK_LIST(VkVertexInputAttributeDescription) m_vertex_attribute_descriptions = PT (VkVertexInputAttributeDescription){ .location = 3, .binding = 0, - .format = VK_FORMAT_R32G32_SINT, + .format = VK_FORMAT_R32G32_SFLOAT, .offset = offsetof(Vertex, uv), }, }); @@ -144,7 +145,7 @@ static const char * const g_validation_layers[] = { "VK_LAYER_KHRONOS_validation" }; -bool check_validation_layers(const char * const *validation_layers, uint32_t validation_layer_count) { +bool check_validation_layers(const char * const *validation_layers, const uint32_t validation_layer_count) { PTK_LIST(VkLayerProperties) available_layers; vkEnumerateInstanceLayerProperties(&available_layers.allocated, NULL); @@ -181,11 +182,11 @@ bool create_vk_instance(const char *title, const PtkVersion version) { PTK_ERR("couldn't find requested validation layer"); return false; } - uint32_t enabledLayerCount = g_validation_layer_count; - const char * const *ppEnabledLayerNames = g_validation_layers; + const uint32_t enabled_layer_count = g_validation_layer_count; + const char * const *enabled_layer_names = g_validation_layers; #else - uint32_t enabledLayerCount = 0; - const char * const *ppEnabledLayerNames = NULL; + const uint32_t enabled_layer_count = 0; + const char * const *enabled_layer_names = NULL; #endif uint32_t extension_count = 0; @@ -206,8 +207,8 @@ bool create_vk_instance(const char *title, const PtkVersion version) { .engineVersion = VK_MAKE_API_VERSION(0, PTK_VERSION_MAJOR, PTK_VERSION_MINOR, PTK_VERSION_PATCH), .apiVersion = VK_API_VERSION_1_3, }, - .enabledLayerCount = enabledLayerCount, - .ppEnabledLayerNames = ppEnabledLayerNames, + .enabledLayerCount = enabled_layer_count, + .ppEnabledLayerNames = enabled_layer_names, .enabledExtensionCount = extension_count, .ppEnabledExtensionNames = extension_names, }, @@ -293,7 +294,7 @@ bool select_physical_dev(void) { VkSurfaceFormatKHR select_swap_surface_format(const PTK_LIST(VkSurfaceFormatKHR) available_formats) { for (size_t i = 0; i < available_formats.size; ++i) { - VkSurfaceFormatKHR current_format = available_formats.data[i]; + const VkSurfaceFormatKHR current_format = available_formats.data[i]; if (current_format.format == VK_FORMAT_B8G8R8A8_SRGB && current_format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) { return current_format; } @@ -304,7 +305,7 @@ VkSurfaceFormatKHR select_swap_surface_format(const PTK_LIST(VkSurfaceFormatKHR) VkPresentModeKHR select_swap_present_mode(const PTK_LIST(VkPresentModeKHR) available_present_modes) { for (size_t i = 0; i < available_present_modes.size; ++i) { - VkPresentModeKHR current_present_mode = available_present_modes.data[i]; + const VkPresentModeKHR current_present_mode = available_present_modes.data[i]; if (current_present_mode == VK_PRESENT_MODE_MAILBOX_KHR) { return current_present_mode; } @@ -313,7 +314,7 @@ VkPresentModeKHR select_swap_present_mode(const PTK_LIST(VkPresentModeKHR) avail return VK_PRESENT_MODE_FIFO_KHR; } -VkExtent2D select_swap_extent(VkSurfaceCapabilitiesKHR capabilities) { +VkExtent2D select_swap_extent(const VkSurfaceCapabilitiesKHR capabilities) { if (capabilities.currentExtent.width != UINT32_MAX) { return capabilities.currentExtent; } @@ -342,7 +343,7 @@ VkExtent2D select_swap_extent(VkSurfaceCapabilitiesKHR capabilities) { return actual_extent; } -SwapchainSupportInfo query_swapchain_support(VkPhysicalDevice dev) { +SwapchainSupportInfo query_swapchain_support(const VkPhysicalDevice dev) { SwapchainSupportInfo info; vkGetPhysicalDeviceSurfaceCapabilitiesKHR(dev, m_surface, &info.capabilities); @@ -377,7 +378,7 @@ SwapchainSupportInfo query_swapchain_support(VkPhysicalDevice dev) { return info; } -bool are_extensions_supported(VkPhysicalDevice dev) { +bool are_extensions_supported(const VkPhysicalDevice dev) { PTK_LIST(VkExtensionProperties) available_extensions; vkEnumerateDeviceExtensionProperties(dev, NULL, &available_extensions.allocated, NULL); @@ -399,7 +400,7 @@ bool are_extensions_supported(VkPhysicalDevice dev) { return supported_extensions == m_device_extension_count; } -bool is_device_suitable(VkPhysicalDevice dev) { +bool is_device_suitable(const VkPhysicalDevice dev) { PTK_LIST(VkQueueFamilyProperties) queue_families; vkGetPhysicalDeviceQueueFamilyProperties(dev, &queue_families.allocated, NULL); @@ -421,13 +422,13 @@ bool is_device_suitable(VkPhysicalDevice dev) { } } - bool indices_found = m_queue_family_indices.graphics.exists + const bool indices_found = m_queue_family_indices.graphics.exists && m_queue_family_indices.present.exists; - bool extensions_supported = are_extensions_supported(dev); + const bool extensions_supported = are_extensions_supported(dev); bool swapchain_adequate = false; if (extensions_supported) { - SwapchainSupportInfo swapchain_support = query_swapchain_support(dev); + const SwapchainSupportInfo swapchain_support = query_swapchain_support(dev); swapchain_adequate = swapchain_support.formats.size != 0 && swapchain_support.present_modes.size != 0; PTK_LIST_FREE(swapchain_support.formats); @@ -448,7 +449,7 @@ bool create_logical_dev(void) { VkDeviceQueueCreateInfo queue_create_infos[m_queue_family_count]; for (size_t i = 0; i < m_queue_family_count; ++i) { - PTK_OPTION(uint32_t) index = *(((PTK_OPTION(uint32_t) *)&m_queue_family_indices) + i); + const PTK_OPTION(uint32_t) index = *(((PTK_OPTION(uint32_t) *)&m_queue_family_indices) + i); queue_create_infos[i] = (VkDeviceQueueCreateInfo){ .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, @@ -461,11 +462,11 @@ bool create_logical_dev(void) { } #ifdef DEBUG - uint32_t enabledLayerCount = g_validation_layer_count; - const char * const *ppEnabledLayerNames = g_validation_layers; + const uint32_t enabled_layer_count = g_validation_layer_count; + const char * const *enabled_layer_names = g_validation_layers; #else - uint32_t enabledLayerCount = 0; - const char * const *ppEnabledLayerNames = NULL; + const uint32_t enabled_layer_count = 0; + const char * const *enabled_layer_names = NULL; #endif VK_TRY(false, @@ -477,8 +478,8 @@ bool create_logical_dev(void) { .flags = 0, .queueCreateInfoCount = m_queue_family_count, .pQueueCreateInfos = queue_create_infos, - .enabledLayerCount = enabledLayerCount, - .ppEnabledLayerNames = ppEnabledLayerNames, + .enabledLayerCount = enabled_layer_count, + .ppEnabledLayerNames = enabled_layer_names, .enabledExtensionCount = m_device_extension_count, .ppEnabledExtensionNames = m_device_extensions, .pEnabledFeatures = &(VkPhysicalDeviceFeatures){0}, @@ -495,11 +496,11 @@ bool create_logical_dev(void) { } bool create_swapchain(void) { - SwapchainSupportInfo swapchain_support = query_swapchain_support(m_physical_dev); + const SwapchainSupportInfo swapchain_support = query_swapchain_support(m_physical_dev); - VkSurfaceFormatKHR surface_format = select_swap_surface_format(swapchain_support.formats); - VkPresentModeKHR present_mode = select_swap_present_mode(swapchain_support.present_modes); - VkExtent2D extent = select_swap_extent(swapchain_support.capabilities); + const VkSurfaceFormatKHR surface_format = select_swap_surface_format(swapchain_support.formats); + const VkPresentModeKHR present_mode = select_swap_present_mode(swapchain_support.present_modes); + const VkExtent2D extent = select_swap_extent(swapchain_support.capabilities); uint32_t image_count = swapchain_support.capabilities.minImageCount + 1; @@ -507,7 +508,7 @@ bool create_swapchain(void) { image_count = swapchain_support.capabilities.maxImageCount; } - bool queue_families_differ = m_queue_family_indices.graphics.value != m_queue_family_indices.present.value; + const bool queue_families_differ = m_queue_family_indices.graphics.value != m_queue_family_indices.present.value; VK_TRY(false, vkCreateSwapchainKHR( @@ -621,7 +622,7 @@ PTK_STRING read_spv(const char *filename) { buffer = PTK_STRING_NEW(buffer.allocated); - size_t items_read = fread(buffer.data, sizeof(char), buffer.allocated, file); + const size_t items_read = fread(buffer.data, sizeof(char), buffer.allocated, file); if (items_read != buffer.allocated) { if (feof(file)) { @@ -639,7 +640,7 @@ PTK_STRING read_spv(const char *filename) { return buffer; } -PTK_OPTION(VkShaderModule) create_shader_module(PTK_STRING code) { +PTK_OPTION(VkShaderModule) create_shader_module(const PTK_STRING code) { VkShaderModule shader_module; VK_TRY(PTK_OPTION_NONE(VkShaderModule), @@ -741,24 +742,24 @@ bool create_descriptor_set_layout(void) { } bool create_graphics_pipeline(void) { - PTK_STRING vert_shader_code = read_spv("target/shaders/shader.vert.spv"); - PTK_STRING frag_shader_code = read_spv("target/shaders/shader.frag.spv"); + const PTK_STRING vert_shader_code = read_spv("target/shaders/shader.vert.spv"); + const PTK_STRING frag_shader_code = read_spv("target/shaders/shader.frag.spv"); - PTK_OPTION(VkShaderModule) vert_shader_module = create_shader_module(vert_shader_code); + const PTK_OPTION(VkShaderModule) vert_shader_module = create_shader_module(vert_shader_code); if (!vert_shader_module.exists) { PTK_ERR("failed creating vert shader module"); return false; } - PTK_OPTION(VkShaderModule) frag_shader_module = create_shader_module(frag_shader_code); + const PTK_OPTION(VkShaderModule) frag_shader_module = create_shader_module(frag_shader_code); if (!frag_shader_module.exists) { PTK_ERR("failed creating frag shader module"); return false; } - VkSpecializationInfo spec_info = { + const VkSpecializationInfo spec_info = { .mapEntryCount = 1, .pMapEntries = &(VkSpecializationMapEntry){ .constantID = 0, @@ -769,7 +770,7 @@ bool create_graphics_pipeline(void) { .pData = &(int){PTK_COMPONENT_TYPE_ELLIPSE}, }; - VkPipelineShaderStageCreateInfo shader_stages[] = { + const VkPipelineShaderStageCreateInfo shader_stages[] = { (VkPipelineShaderStageCreateInfo){ .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, .pNext = NULL, @@ -790,7 +791,7 @@ bool create_graphics_pipeline(void) { }, }; - VkPipelineVertexInputStateCreateInfo vertex_input_info = { + const VkPipelineVertexInputStateCreateInfo vertex_input_info = { .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, .pNext = NULL, .flags = 0, @@ -800,7 +801,7 @@ bool create_graphics_pipeline(void) { .pVertexAttributeDescriptions = m_vertex_attribute_descriptions.data, }; - VkPipelineDynamicStateCreateInfo dynamic_state = { + const VkPipelineDynamicStateCreateInfo dynamic_state = { .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, .pNext = NULL, .flags = 0, @@ -808,7 +809,7 @@ bool create_graphics_pipeline(void) { .pDynamicStates = NULL, }; - VkPipelineInputAssemblyStateCreateInfo input_assembly = { + const VkPipelineInputAssemblyStateCreateInfo input_assembly = { .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, .pNext = NULL, .flags = 0, @@ -816,7 +817,7 @@ bool create_graphics_pipeline(void) { .primitiveRestartEnable = VK_FALSE, }; - VkPipelineViewportStateCreateInfo viewport_state = { + const VkPipelineViewportStateCreateInfo viewport_state = { .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, .pNext = NULL, .flags = 0, @@ -839,7 +840,7 @@ bool create_graphics_pipeline(void) { }, }; - VkPipelineRasterizationStateCreateInfo rasterizer = { + const VkPipelineRasterizationStateCreateInfo rasterizer = { .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, .pNext = NULL, .flags = 0, @@ -855,7 +856,7 @@ bool create_graphics_pipeline(void) { .lineWidth = 1.0f, }; - VkPipelineMultisampleStateCreateInfo multisampling = { + const VkPipelineMultisampleStateCreateInfo multisampling = { .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, .pNext = NULL, .flags = 0, @@ -867,7 +868,7 @@ bool create_graphics_pipeline(void) { .alphaToOneEnable = VK_FALSE, }; - VkPipelineColorBlendAttachmentState color_blend_attachment = { + const VkPipelineColorBlendAttachmentState color_blend_attachment = { .blendEnable = VK_TRUE, .srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA, .dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, @@ -878,7 +879,7 @@ bool create_graphics_pipeline(void) { .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT, }; - VkPipelineColorBlendStateCreateInfo color_blending = { + const VkPipelineColorBlendStateCreateInfo color_blending = { .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, .pNext = NULL, .flags = 0, @@ -992,7 +993,7 @@ bool create_command_pool(void) { return true; } -PTK_OPTION(uint32_t) find_memory_type(uint32_t type_filter, VkMemoryPropertyFlags props) { +PTK_OPTION(uint32_t) find_memory_type(const uint32_t type_filter, const VkMemoryPropertyFlags props) { VkPhysicalDeviceMemoryProperties mem_props; vkGetPhysicalDeviceMemoryProperties(m_physical_dev, &mem_props); @@ -1005,7 +1006,7 @@ PTK_OPTION(uint32_t) find_memory_type(uint32_t type_filter, VkMemoryPropertyFlag return PTK_OPTION_NONE(uint32_t); } -bool create_buffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props, VkBuffer *buffer, VkDeviceMemory *buffer_memory) { +bool create_buffer(const VkDeviceSize size, const VkBufferUsageFlags usage, const VkMemoryPropertyFlags props, VkBuffer *buffer, VkDeviceMemory *buffer_memory) { VK_TRY(false, vkCreateBuffer( g_dev, @@ -1027,7 +1028,7 @@ bool create_buffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryProperty VkMemoryRequirements mem_reqs; vkGetBufferMemoryRequirements(g_dev, *buffer, &mem_reqs); - PTK_OPTION(uint32_t) memory_type = find_memory_type(mem_reqs.memoryTypeBits, props); + const PTK_OPTION(uint32_t) memory_type = find_memory_type(mem_reqs.memoryTypeBits, props); if (!memory_type.exists) { PTK_ERR("failed to find suitable memory type"); @@ -1053,7 +1054,7 @@ bool create_buffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryProperty return true; } -bool copy_buffer(VkBuffer src, VkBuffer dst, VkDeviceSize size) { +bool copy_buffer(const VkBuffer src, const VkBuffer dst, const VkDeviceSize size) { VkCommandBuffer command_buffer; VK_TRY(false, @@ -1117,12 +1118,12 @@ bool vk_transfer_vertex_data(void) { PTK_DEBUG("vertices updated!"); for (size_t i = 0; i < g_vertices.size; ++i) { PTK_DEBUG("v[%d]:", i); - Vertex current = g_vertices.data[i]; + const Vertex current = g_vertices.data[i]; PTK_DEBUG(" pos: (%f, %f)", current.pos.x, current.pos.y); PTK_DEBUG(" color: (%f, %f, %f)", current.color.r, current.color.g, current.color.b); } PTK_DEBUG("transferring vertices to gpu…"); - VkDeviceSize buffer_size = sizeof(g_vertices.data[0]) * g_vertices.size; + const VkDeviceSize buffer_size = sizeof(g_vertices.data[0]) * g_vertices.size; VkBuffer staging_buffer; VkDeviceMemory staging_buffer_memory; @@ -1156,8 +1157,8 @@ bool vk_transfer_vertex_data(void) { } bool create_vertex_buffer(void) { - // VkDeviceSize buffer_size = sizeof(g_vertices.data[0]) * g_vertices.size; - VkDeviceSize buffer_size = 65536; + // const VkDeviceSize buffer_size = sizeof(g_vertices.data[0]) * g_vertices.size; + const VkDeviceSize buffer_size = 65536; if ( !create_buffer( buffer_size, @@ -1175,7 +1176,7 @@ bool create_vertex_buffer(void) { } bool create_uniform_buffers(void) { - VkDeviceSize buffer_size = sizeof(UniformBufferObject); + const VkDeviceSize buffer_size = sizeof(UniformBufferObject); m_uniform_buffers = PTK_LIST_NEW(VkBuffer, g_max_frames_in_flight); m_uniform_buffers_memory = PTK_LIST_NEW(VkDeviceMemory, g_max_frames_in_flight); @@ -1297,7 +1298,7 @@ bool allocate_command_buffers(void) { return true; } -bool vk_record_command_buffer(VkCommandBuffer command_buffer, uint32_t image_index) { +bool vk_record_command_buffer(const VkCommandBuffer command_buffer, const uint32_t image_index) { VK_TRY(false, vkBeginCommandBuffer( command_buffer, @@ -1359,7 +1360,7 @@ bool create_sync_objects(void) { g_render_finished_semaphores = PTK_LIST_NEW(VkSemaphore, g_max_frames_in_flight); g_in_flight_fences = PTK_LIST_NEW(VkFence, g_max_frames_in_flight); - VkSemaphoreCreateInfo semaphore_info = { + const VkSemaphoreCreateInfo semaphore_info = { .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, .pNext = NULL, .flags = 0, @@ -1437,7 +1438,7 @@ bool vk_recreate_swapchain(void) { return true; } -bool vk_update_uniform_buffer(size_t current_frame) { +bool vk_update_uniform_buffer(const size_t current_frame) { m_uniform_buffer_object.window_size.w = m_swapchain_extent.width; m_uniform_buffer_object.window_size.h = m_swapchain_extent.height; @@ -1446,7 +1447,7 @@ bool vk_update_uniform_buffer(size_t current_frame) { return true; } -bool vk_init(GLFWwindow *window, size_t width, size_t height, const char *title, const PtkVersion version) { +bool vk_init(GLFWwindow *window, const size_t width, const size_t height, const char *title, const PtkVersion version) { m_window = window; m_uniform_buffer_object.initial_window_size.w = width; m_uniform_buffer_object.initial_window_size.h = height; diff --git a/src/ptk_vk/init.h b/src/ptk_vk/init.h index d685a33..4ed0be9 100644 --- a/src/ptk_vk/init.h +++ b/src/ptk_vk/init.h @@ -28,15 +28,15 @@ extern PTK_LIST(VkSemaphore) g_image_available_semaphores; extern PTK_LIST(VkSemaphore) g_render_finished_semaphores; extern PTK_LIST(VkFence) g_in_flight_fences; -bool vk_init(GLFWwindow *window, size_t width, size_t height, const char *title, const PtkVersion version); +bool vk_init(GLFWwindow *window, const size_t width, const size_t height, const char *title, const PtkVersion version); bool vk_transfer_vertex_data(void); -bool vk_record_command_buffer(VkCommandBuffer command_buffer, uint32_t image_index); +bool vk_record_command_buffer(const VkCommandBuffer command_buffer, const uint32_t image_index); bool vk_recreate_swapchain(void); -bool vk_update_uniform_buffer(size_t current_frame); +bool vk_update_uniform_buffer(const size_t current_frame); void vk_cleanup(void); diff --git a/src/ptk_vk/utils.h b/src/ptk_vk/utils.h index 7bf2005..df9e214 100644 --- a/src/ptk_vk/utils.h +++ b/src/ptk_vk/utils.h @@ -9,7 +9,7 @@ const char *vk_result_string(VkResult res); #define VK_TRY(return_value, ...) do {\ - VkResult res = __VA_ARGS__;\ + const VkResult res = __VA_ARGS__;\ if (res != VK_SUCCESS) {\ PTK_ERR("%s", vk_result_string(res));\ return return_value;\ diff --git a/test/list.c b/test/list.c index afecc53..6d2d355 100644 --- a/test/list.c +++ b/test/list.c @@ -7,7 +7,7 @@ PTK_LIST_DEFINE(uint32_t); TEST_START() TEST("create list", { - size_t size = 5; + const size_t size = 5; PTK_LIST(uint32_t) list = PTK_LIST_NEW(uint32_t, size); TEST_ASSERT(list.allocated == size, "incorrect list allocation"); @@ -15,7 +15,7 @@ TEST_START() }); TEST("add elements without growing", { - size_t size = 5; + const size_t size = 5; PTK_LIST(uint32_t) list = PTK_LIST_NEW(uint32_t, size); PTK_LIST_ADD(uint32_t, list, (uint32_t){21}); @@ -29,7 +29,7 @@ TEST_START() }); TEST("add elements and grow", { - size_t size = 1; + const size_t size = 1; PTK_LIST(uint32_t) list = PTK_LIST_NEW(uint32_t, size); PTK_LIST_ADD(uint32_t, list, (uint32_t){21}); @@ -45,7 +45,7 @@ TEST_START() }); TEST("add multiple elements", { - size_t size = 1; + const size_t size = 1; PTK_LIST(uint32_t) list = PTK_LIST_NEW(uint32_t, size); PTK_LIST_ADD_ALL(uint32_t, list, { 21, 37, 2137, 31, 27, 7312 }); @@ -56,7 +56,7 @@ TEST_START() }); TEST("remove elements", { - size_t size = 1; + const size_t size = 1; PTK_LIST(uint32_t) list = PTK_LIST_NEW(uint32_t, size); PTK_LIST_ADD(uint32_t, list, (uint32_t){21}); @@ -73,7 +73,7 @@ TEST_START() }); TEST("remove multiple elements", { - size_t size = 1; + const size_t size = 1; PTK_LIST(uint32_t) list = PTK_LIST_NEW(uint32_t, size); PTK_LIST_ADD(uint32_t, list, (uint32_t){21}); @@ -90,7 +90,7 @@ TEST_START() }); TEST("remove elements at index", { - size_t size = 1; + const size_t size = 1; PTK_LIST(uint32_t) list = PTK_LIST_NEW(uint32_t, size); PTK_LIST_ADD(uint32_t, list, (uint32_t){21});