From 6dcddb4da3279c32ff5c10694c27abce904e5eb2 Mon Sep 17 00:00:00 2001 From: qwertzuiopy Date: Fri, 4 Apr 2025 19:58:54 +0200 Subject: [PATCH] nyaaaa thats all the namespacing your going to get for nyow, im tired :3 --- Makefile | 4 +- main.c | 10 ++-- src/allocator.h | 28 ---------- src/glfw.c | 2 +- src/gpu_allocator.c | 2 +- src/hashmap.c | 2 +- src/io.c | 2 +- src/kitty.c | 48 ++++++++-------- src/kitty.h | 14 ++--- src/lang/ast.c | 82 ++++++++++++++-------------- src/lang/ast.h | 63 +++++++++++---------- src/lang/ast_disc.c | 8 +-- src/lang/functable.c | 2 +- src/lang/glue.c | 2 +- src/lang/vstack.c | 14 ++--- src/object.h | 45 --------------- src/{allocator.c => paw_allocator.c} | 52 ++++++++++-------- src/paw_allocator.h | 28 ++++++++++ src/{dynarray.c => paw_da.c} | 18 +++--- src/{dynarray.h => paw_da.h} | 42 +++++++------- src/{log.c => paw_log.c} | 6 +- src/{log.h => paw_log.h} | 4 +- src/{object.c => paw_object.c} | 72 ++++++++++++------------ src/paw_object.h | 46 ++++++++++++++++ src/register.c | 17 +++--- src/register.h | 23 ++++---- src/string.c | 38 ++++++------- src/string.h | 18 +++--- src/util.c | 33 +++++------ src/util.h | 4 +- src/vulkan.c | 7 +-- src/vulkan.h | 8 +-- src/vulkan_helpers.c | 2 +- src/wayland.c | 20 +++---- trig.c | 20 +++---- 35 files changed, 394 insertions(+), 392 deletions(-) delete mode 100644 src/allocator.h delete mode 100644 src/object.h rename src/{allocator.c => paw_allocator.c} (58%) create mode 100644 src/paw_allocator.h rename src/{dynarray.c => paw_da.c} (66%) rename src/{dynarray.h => paw_da.h} (74%) rename src/{log.c => paw_log.c} (91%) rename src/{log.h => paw_log.h} (89%) rename src/{object.c => paw_object.c} (56%) create mode 100644 src/paw_object.h diff --git a/Makefile b/Makefile index 75ad604..ff7a852 100644 --- a/Makefile +++ b/Makefile @@ -9,8 +9,8 @@ FLAGS=-g $(CFLAGS) $(LDFLAGS) $(LIBS) S=comp.c wayland.c glfw.c S+=vulkan.c kitty.c -S+=string.c gpu_allocator.c hashmap.c util.c io.c matrix.c dynarray.c image.c types.c allocator.c log.c -S+=object.c register.c +S+=string.c gpu_allocator.c hashmap.c util.c io.c matrix.c paw_da.c image.c types.c paw_allocator.c paw_log.c +S+=paw_object.c register.c S+=Wayland/xdg-shell-protocol.c S+=lang/ast.c lang/vstack.c lang/ast_disc.c lang/functable.c lang/glue.c SO=$(addprefix build/,$(S:.c=.o)) diff --git a/main.c b/main.c index def2e65..ec0a09f 100644 --- a/main.c +++ b/main.c @@ -1,5 +1,5 @@ #include "src/comp.h" -#include "src/object.h" +#include "src/paw_object.h" #include "src/register.h" #include "trig.c" @@ -22,16 +22,16 @@ int main() { struct Register *reg = make_register(); reg_attatch_type(reg, "trig", OBJ_MAKE make_trig, OBJ_FREE free_trig, OBJ_TICK trig_tick); - struct Scene *scene = make_scene(vk, reg); + struct PawScene *scene = paw_scene_make(vk, reg); - scene_queue_insert(scene, "trig", trig_make_args(scene)); + paw_scene_queue_insert(scene, "trig", trig_make_args(scene)); while (!cat_comp_should_close(state)) { - scene_tick(scene); + paw_scene_tick(scene); cat_comp_draw(state); } - free_scene(scene); + paw_scene_free(scene); free_register(reg); cat_comp_uninit(state); diff --git a/src/allocator.h b/src/allocator.h deleted file mode 100644 index e607bfa..0000000 --- a/src/allocator.h +++ /dev/null @@ -1,28 +0,0 @@ -#ifndef INCLUDE_WAYLANDCLIENT_ALLOCATOR_H_ -#define INCLUDE_WAYLANDCLIENT_ALLOCATOR_H_ - -#include "sys/types.h" - -#define MAX_ALLOCS 256 -struct Alloc { - void *start; - uint size; - struct Alloc *next; -}; -struct Mem { - void *mem; - size_t mem_size; - uint count; - struct Alloc *alloc; - struct Alloc allocs[MAX_ALLOCS]; -}; - -struct Mem *make_mem(size_t size); -void uninit_mem(struct Mem *mem); - -void *mem_malloc(struct Mem *mem, size_t size); -void mem_free(struct Mem *mem, void *p); -void *malloc_or_mem_malloc(struct Mem *mem, size_t size); -void free_or_mem_free(struct Mem *mem, void *ptr); - -#endif // INCLUDE_WAYLANDCLIENT_ALLOCATOR_H_ diff --git a/src/glfw.c b/src/glfw.c index 7d42315..1030bb0 100644 --- a/src/glfw.c +++ b/src/glfw.c @@ -1,4 +1,4 @@ -#include "log.h" +#include "paw_log.h" #include "vulkan.h" #include diff --git a/src/gpu_allocator.c b/src/gpu_allocator.c index 3f8cdda..1aa378c 100644 --- a/src/gpu_allocator.c +++ b/src/gpu_allocator.c @@ -146,7 +146,7 @@ void gpu_mem_free(struct Vk *state, struct GpuMem *mem, if (current == NULL || pointer.offset != current->start) { meow("WHOOOPPSIIIEEEE could not find allocated block, potential dobble " "free"); - print_backtrace(); + paw_print_backtrace(); return; } prev->next = current->next; diff --git a/src/hashmap.c b/src/hashmap.c index 4d9b32f..41c6e4c 100644 --- a/src/hashmap.c +++ b/src/hashmap.c @@ -3,7 +3,7 @@ #include #include -#include "log.h" +#include "paw_log.h" #define HASH_MASK 0b111111 #define TYPE uint32_t diff --git a/src/io.c b/src/io.c index 218ce00..00da57d 100644 --- a/src/io.c +++ b/src/io.c @@ -1,4 +1,4 @@ -#include "log.h" +#include "paw_log.h" #include #include diff --git a/src/kitty.c b/src/kitty.c index c1474c8..3256469 100644 --- a/src/kitty.c +++ b/src/kitty.c @@ -3,30 +3,30 @@ #include #include -#include "allocator.h" -#include "dynarray.h" #include "io.h" #include "kitty.h" +#include "paw_allocator.h" +#include "paw_da.h" #include "vulkan.h" #include "vulkan_helpers.c" -struct Kitty *kitty_make(struct Mem *mem) { +struct Kitty *kitty_make(struct PawMem *mem) { struct Kitty *kitty; if (mem == NULL) { kitty = malloc(sizeof(struct Kitty)); } else { - kitty = mem_malloc(mem, sizeof(struct Kitty)); + kitty = paw_memmalloc(mem, sizeof(struct Kitty)); } memset(kitty, 0, sizeof(struct Kitty)); kitty->mem = mem; if (kitty->mem == NULL) { - dyn_array_create_inplace(&kitty->attatchments); - dyn_array_create_inplace(&kitty->vertex_buffer.format); - dyn_array_create_inplace(&kitty->instance_buffer.format); + paw_da_make_inplace(&kitty->attatchments); + paw_da_make_inplace(&kitty->vertex_buffer.format); + paw_da_make_inplace(&kitty->instance_buffer.format); } else { - dyn_array_create_inplace_mem(&kitty->attatchments, kitty->mem); - dyn_array_create_inplace_mem(&kitty->vertex_buffer.format, kitty->mem); - dyn_array_create_inplace_mem(&kitty->instance_buffer.format, kitty->mem); + paw_da_make_inplace_mem(&kitty->attatchments, kitty->mem); + paw_da_make_inplace_mem(&kitty->vertex_buffer.format, kitty->mem); + paw_da_make_inplace_mem(&kitty->instance_buffer.format, kitty->mem); } meow("alloced a kitty at %p", kitty); return kitty; @@ -63,34 +63,34 @@ void kitty_add_instance_buffer(struct Kitty *kitty, void *data, uint32_t count, } void kitty_add_instance_buffer_format(struct Kitty *kitty, enum VkFormat format) { - dyn_array_append(&kitty->instance_buffer.format, format); + paw_da_append(&kitty->instance_buffer.format, format); } void kitty_add_vertex_buffer_format(struct Kitty *kitty, enum VkFormat format) { - dyn_array_append(&kitty->vertex_buffer.format, format); + paw_da_append(&kitty->vertex_buffer.format, format); } void kitty_attatch_image(struct Kitty *kitty, const char *path) { - struct Attatchment attatchment = {0}; + struct KittyAttatchment attatchment = {0}; attatchment.type = CAT_ATTATCH_IMAGE; attatchment.image.path = path; - dyn_array_append(&kitty->attatchments, attatchment); + paw_da_append(&kitty->attatchments, attatchment); meow("image was attatched"); } int kitty_attatch_ubo(struct Kitty *kitty, uint32_t size) { - struct Attatchment attatchment = {0}; + struct KittyAttatchment attatchment = {0}; attatchment.type = CAT_ATTATCH_UBO; attatchment.ubo.size = size; - dyn_array_append(&kitty->attatchments, attatchment); + paw_da_append(&kitty->attatchments, attatchment); meow("ubo of size %d was attatched", size); return kitty->attatchments.count - 1; } int kitty_attatch_ubo_array(struct Kitty *kitty, uint32_t size, uint32_t count) { - struct Attatchment attatchment = {0}; + struct KittyAttatchment attatchment = {0}; attatchment.type = CAT_ATTATCH_UBO_ARRAY; attatchment.ubo_array.size = size; attatchment.ubo_array.count = count; - dyn_array_append(&kitty->attatchments, attatchment); + paw_da_append(&kitty->attatchments, attatchment); return kitty->attatchments.count - 1; } @@ -107,10 +107,10 @@ void kitty_finalise(struct Vk *state, struct Kitty *kitty) { kitty_create_instance_buffer(kitty, state); } - dyn_array_append(&state->kitties, kitty); + paw_da_append(&state->kitties, kitty); } -void free_kitty(struct Vk *state, struct Kitty *kitty) { +void kitty_free(struct Vk *state, struct Kitty *kitty) { vkDeviceWaitIdle(state->device); vkDestroyBuffer(state->device, kitty->vertex_buffer.buffer, NULL); gpu_mem_free(state, state->mem, kitty->vertex_buffer.memory); @@ -154,14 +154,14 @@ void free_kitty(struct Vk *state, struct Kitty *kitty) { } } - dyn_array_destroy(&kitty->vertex_buffer.format); - dyn_array_destroy(&kitty->attatchments); + paw_da_free(&kitty->vertex_buffer.format); + paw_da_free(&kitty->attatchments); if (kitty->mem == NULL) { memset(kitty, 0, sizeof(struct Kitty)); free(kitty); } else { - mem_free(kitty->mem, kitty); + paw_memfree(kitty->mem, kitty); } } @@ -537,7 +537,7 @@ void kitty_create_image_attatchments(struct Kitty *kitty, struct Vk *state) { if (kitty->attatchments.items[index].type != CAT_ATTATCH_IMAGE) { continue; } - struct Attatchment *atch = &kitty->attatchments.items[index]; + struct KittyAttatchment *atch = &kitty->attatchments.items[index]; atch->image.pixels = load_image(atch->image.path, &atch->image.dims); atch->image.size = atch->image.dims.x * atch->image.dims.y * 4; diff --git a/src/kitty.h b/src/kitty.h index d4d2fe6..f88c3c1 100644 --- a/src/kitty.h +++ b/src/kitty.h @@ -5,14 +5,14 @@ #include "vulkan.h" #include -enum AttatchType { +enum KittyAttatchType { CAT_ATTATCH_IMAGE, CAT_ATTATCH_UBO, CAT_ATTATCH_UBO_ARRAY, }; -struct Attatchment { - enum AttatchType type; +struct KittyAttatchment { + enum KittyAttatchType type; union { struct { const char *path; @@ -38,7 +38,7 @@ struct Attatchment { }; }; -dyn_array_define(da_Attatchment, struct Attatchment); +paw_da_define(da_Attatchment, struct KittyAttatchment); struct Kitty { VkPipeline pipeline; @@ -60,10 +60,10 @@ struct Kitty { VkDescriptorSetLayout descriptor_set_layout; VkDescriptorSet descriptor_sets[MAX_FRAMES_IN_FLIGHT]; - struct Mem *mem; + struct PawMem *mem; }; -struct Kitty *kitty_make(struct Mem *mem); +struct Kitty *kitty_make(struct PawMem *mem); void kitty_set_vertex_shader(struct Kitty *thingy, const char *path); void kitty_set_fragment_shader(struct Kitty *thingy, const char *path); @@ -105,7 +105,7 @@ void *kitty_get_next_ubo_pointer(struct Vk *state, struct Kitty *kitty, void kitty_draw(struct Vk *state, uint32_t image_index, struct Kitty *thingy); -void free_kitty(struct Vk *state, struct Kitty *kitty); +void kitty_free(struct Vk *state, struct Kitty *kitty); void kitty_create_layout_bindings(struct Kitty *kitty, struct Vk *state); void kitty_create_pipeline(struct Kitty *kitty, struct Vk *state); diff --git a/src/lang/ast.c b/src/lang/ast.c index 1308241..bc6c488 100644 --- a/src/lang/ast.c +++ b/src/lang/ast.c @@ -1,7 +1,7 @@ #include #include -#include "../log.h" +#include "../paw_log.h" #include "ast.h" const bool log_stack = false; @@ -73,7 +73,7 @@ char *print_stackval(struct PawStackVal val) { sprintf(res, "%d", val.i); break; case PAW_VAL_BOOL: - strcpy(res, bool_to_string(val.b)); + strcpy(res, paw_b_to_s(val.b)); break; case PAW_VAL_CHAR: sprintf(res, "%c", val.c); @@ -178,7 +178,7 @@ struct PawStackVal try_cast(enum PawVal target, enum PawVal *val) { return PSV_NULL; } -enum PawVal *ast_stack_to_heap(struct Mem *mem, struct PawStackVal val) { +enum PawVal *ast_stack_to_heap(struct PawMem *mem, struct PawStackVal val) { switch (val.type) { case PAW_VAL_FLOAT: return make_pawval_float(mem, val.f); @@ -229,7 +229,7 @@ struct PawStackVal op_add(struct PawStackVal lhs, struct PawStackVal rhs) { return PSV_NULL; } -enum PawVal *make_pawval_float(struct Mem *mem, float n) { +enum PawVal *make_pawval_float(struct PawMem *mem, float n) { enum PawVal *val; val_make(val, float, PAW_VAL_FLOAT); float *f = val_get_data(val); @@ -237,7 +237,7 @@ enum PawVal *make_pawval_float(struct Mem *mem, float n) { return val; } -enum PawVal *make_pawval_int(struct Mem *mem, int n) { +enum PawVal *make_pawval_int(struct PawMem *mem, int n) { enum PawVal *val; val_make(val, int, PAW_VAL_INT); int *i = (int *)val_get_data(val); @@ -245,7 +245,7 @@ enum PawVal *make_pawval_int(struct Mem *mem, int n) { return val; } -enum PawVal *make_pawval_bool(struct Mem *mem, bool n) { +enum PawVal *make_pawval_bool(struct PawMem *mem, bool n) { enum PawVal *val; val_make(val, bool, PAW_VAL_BOOL); bool *i = val_get_data(val); @@ -253,7 +253,7 @@ enum PawVal *make_pawval_bool(struct Mem *mem, bool n) { return val; } -enum PawVal *make_pawval_point(struct Mem *mem, paw_p n) { +enum PawVal *make_pawval_point(struct PawMem *mem, paw_p n) { enum PawVal *val; val_make(val, paw_p, PAW_VAL_POINT); paw_p *i = val_get_data(val); @@ -261,7 +261,7 @@ enum PawVal *make_pawval_point(struct Mem *mem, paw_p n) { return val; } -enum PawVal *make_pawval_spoint(struct Mem *mem, int n) { +enum PawVal *make_pawval_spoint(struct PawMem *mem, int n) { enum PawVal *val; val_make(val, paw_p, PAW_VAL_SPOINT); int *i = val_get_data(val); @@ -269,7 +269,7 @@ enum PawVal *make_pawval_spoint(struct Mem *mem, int n) { return val; } -enum PawVal *make_pawval_char(struct Mem *mem, char n) { +enum PawVal *make_pawval_char(struct PawMem *mem, char n) { enum PawVal *val; val_make(val, paw_p, PAW_VAL_CHAR); char *i = val_get_data(val); @@ -277,7 +277,7 @@ enum PawVal *make_pawval_char(struct Mem *mem, char n) { return val; } -enum PawVal *make_pawval_expr(struct Mem *mem, enum PawVal *lhs, +enum PawVal *make_pawval_expr(struct PawMem *mem, enum PawVal *lhs, enum PawVal *rhs, uint32_t op) { enum PawVal *val; val_make(val, struct PawExpr, PAW_VAL_EXPR); @@ -288,7 +288,7 @@ enum PawVal *make_pawval_expr(struct Mem *mem, enum PawVal *lhs, return val; } -void free_pawval(struct Mem *mem, enum PawVal *val) { +void free_pawval(struct PawMem *mem, enum PawVal *val) { switch (*val) { case PAW_VAL_FLOAT: case PAW_VAL_INT: @@ -296,58 +296,58 @@ void free_pawval(struct Mem *mem, enum PawVal *val) { case PAW_VAL_POINT: case PAW_VAL_SPOINT: case PAW_VAL_CHAR: - mem_free(mem, val); + paw_memfree(mem, val); break; case PAW_VAL_EXPR:; struct PawExpr *expr = val_get_data(val); free_pawval(mem, expr->lhs); free_pawval(mem, expr->rhs); - mem_free(mem, val); + paw_memfree(mem, val); break; } } -enum PawCtrl *make_pawctrl_seq(struct Mem *mem) { +enum PawCtrl *make_pawctrl_seq(struct PawMem *mem) { enum PawCtrl *ctrl; ctrl_make(ctrl, struct PawSeq, PAW_CTRL_SEQ); struct PawSeq *i = ctrl_get_data(ctrl); - dyn_array_create_inplace_mem(&i->seq, mem); + paw_da_make_inplace_mem(&i->seq, mem); return ctrl; } -enum PawCtrl *make_pawctrl_call(struct Mem *mem, enum PawCtrl *body) { +enum PawCtrl *make_pawctrl_call(struct PawMem *mem, enum PawCtrl *body) { enum PawCtrl *ctrl; ctrl_make(ctrl, struct PawCall, PAW_CTRL_CALL); struct PawCall *i = ctrl_get_data(ctrl); i->body = body; return ctrl; } -enum PawCtrl *make_pawctrl_spush(struct Mem *mem, struct PawStackVal val) { +enum PawCtrl *make_pawctrl_spush(struct PawMem *mem, struct PawStackVal val) { enum PawCtrl *ctrl; ctrl_make(ctrl, struct PawStackPush, PAW_CTRL_SPUSH); struct PawStackPush *i = ctrl_get_data(ctrl); i->v = val; return ctrl; } -enum PawCtrl *make_pawctrl_spop(struct Mem *mem) { +enum PawCtrl *make_pawctrl_spop(struct PawMem *mem) { enum PawCtrl *ctrl; ctrl_make(ctrl, struct PawEmpty, PAW_CTRL_SPOP); return ctrl; } -enum PawCtrl *make_pawctrl_break(struct Mem *mem) { +enum PawCtrl *make_pawctrl_break(struct PawMem *mem) { enum PawCtrl *ctrl; ctrl_make(ctrl, struct PawEmpty, PAW_CTRL_BREAK); return ctrl; } -enum PawCtrl *make_pawctrl_loop(struct Mem *mem, enum PawCtrl *body) { +enum PawCtrl *make_pawctrl_loop(struct PawMem *mem, enum PawCtrl *body) { enum PawCtrl *ctrl; ctrl_make(ctrl, struct PawLoop, PAW_CTRL_LOOP); struct PawLoop *i = ctrl_get_data(ctrl); i->body = body; return ctrl; } -enum PawCtrl *make_pawctrl_if(struct Mem *mem, enum PawVal *cond, +enum PawCtrl *make_pawctrl_if(struct PawMem *mem, enum PawVal *cond, enum PawCtrl *truthy, enum PawCtrl *falsy) { enum PawCtrl *ctrl; ctrl_make(ctrl, struct PawIf, PAW_CTRL_IF); @@ -358,7 +358,7 @@ enum PawCtrl *make_pawctrl_if(struct Mem *mem, enum PawVal *cond, return ctrl; } -enum PawCtrl *make_pawctrl_asign(struct Mem *mem, struct PawStackVal target, +enum PawCtrl *make_pawctrl_asign(struct PawMem *mem, struct PawStackVal target, enum PawVal *val) { enum PawCtrl *ctrl; ctrl_make(ctrl, struct PawAsign, PAW_CTRL_ASIGN); @@ -368,7 +368,7 @@ enum PawCtrl *make_pawctrl_asign(struct Mem *mem, struct PawStackVal target, return ctrl; } -enum PawCtrl *make_pawctrl_ccall(struct Mem *mem, int index) { +enum PawCtrl *make_pawctrl_ccall(struct PawMem *mem, int index) { enum PawCtrl *ctrl; ctrl_make(ctrl, struct PawCCall, PAW_CTRL_CCALL); struct PawCCall *i = ctrl_get_data(ctrl); @@ -378,32 +378,32 @@ enum PawCtrl *make_pawctrl_ccall(struct Mem *mem, int index) { void pawseq_append(enum PawCtrl *seq, enum PawCtrl *ctrl) { struct PawSeq *seqval = ctrl_get_data(seq); - dyn_array_append(&seqval->seq, ctrl); + paw_da_append(&seqval->seq, ctrl); } void pawseq_insert(enum PawCtrl *seq, int index, enum PawCtrl *ctrl) { struct PawSeq *seqval = ctrl_get_data(seq); - dyn_array_insert(&seqval->seq, index, ctrl); + paw_da_insert(&seqval->seq, index, ctrl); } struct PawAST *ast_make() { - struct Mem *mem = make_mem(8192); + struct PawMem *mem = paw_memmake(8192); // ast HAS to be the first thing allocated with mem - struct PawAST *ast = mem_malloc(mem, sizeof(struct PawAST)); + struct PawAST *ast = paw_memmalloc(mem, sizeof(struct PawAST)); char *t = "meow\n"; - char *test = mem_malloc(mem, strlen(t) + 1); + char *test = paw_memmalloc(mem, strlen(t) + 1); memcpy(test, t, strlen(t) + 1); ast->mem = mem; - dyn_array_create_inplace_mem(&ast->properties, ast->mem); - dyn_array_create_inplace_mem(&ast->methods, ast->mem); + paw_da_make_inplace_mem(&ast->properties, ast->mem); + paw_da_make_inplace_mem(&ast->methods, ast->mem); return ast; } void ast_register_method(struct PawAST *ast, char *name, enum PawCtrl *body) { - dyn_array_append(&ast->methods, - ((struct PawMethod){.body = body, .name = name})); + paw_da_append(&ast->methods, + ((struct PawMethod){.body = body, .name = name})); } enum PawVal *ast_get_property(struct PawAST *ast, char *name) { @@ -417,12 +417,12 @@ enum PawVal *ast_get_property(struct PawAST *ast, char *name) { } void ast_insert_property(struct PawAST *ast, char *name, enum PawVal *val) { - dyn_array_append(&ast->properties, ((struct PawProperty){name, val})); + paw_da_append(&ast->properties, ((struct PawProperty){name, val})); } -struct Stack *stack_make(struct Mem *mem, size_t size) { - struct Stack *stack = mem_malloc(mem, sizeof(struct Stack)); - stack->left = mem_malloc(mem, size); +struct Stack *stack_make(struct PawMem *mem, size_t size) { + struct Stack *stack = paw_memmalloc(mem, sizeof(struct Stack)); + stack->left = paw_memmalloc(mem, size); stack->right = stack->left + size; stack->top = stack->right; return stack; @@ -452,9 +452,9 @@ void stack_set2(struct Stack *stack, void *v) { *n = v; } -void stack_free(struct Stack *stack, struct Mem *mem) { - mem_free(mem, stack->left); - mem_free(mem, stack); +void stack_free(struct Stack *stack, struct PawMem *mem) { + paw_memfree(mem, stack->left); + paw_memfree(mem, stack); } void print(struct VStack *stack, int offset) { @@ -468,7 +468,7 @@ void print(struct VStack *stack, int offset) { meow("%i", val.i); break; case PAW_VAL_BOOL: - meow("%s", bool_to_string(val.b)); + meow("%s", paw_b_to_s(val.b)); break; case PAW_VAL_CHAR: meow("%c", val.c); @@ -573,7 +573,7 @@ void unwind_stack(struct Stack *stack) { crash("unwound stack, exiting"); } -void ast_call(struct PawAST *ast, char *method, struct Scene *scene) { +void ast_call(struct PawAST *ast, char *method, struct PawScene *scene) { enum PawCtrl *entry; for (int i = 0; i < ast->methods.count; i++) { if (strcmp(ast->methods.items[i].name, method) == 0) { diff --git a/src/lang/ast.h b/src/lang/ast.h index dc4b1a7..72ce9a1 100644 --- a/src/lang/ast.h +++ b/src/lang/ast.h @@ -5,9 +5,9 @@ #include #include -#include "../allocator.h" -#include "../dynarray.h" -#include "../object.h" +#include "../paw_allocator.h" +#include "../paw_da.h" +#include "../paw_object.h" #define paw_p void * #define paw_sp int @@ -67,20 +67,19 @@ enum PawCtrl { PAW_CTRL_CALL, PAW_CTRL_CCALL, }; -dyn_array_define(da_paw_ctrl, enum PawCtrl *); -dyn_array_define(da_paw_val, enum PawVal *); +paw_da_define(da_paw_ctrl, enum PawCtrl *); +paw_da_define(da_paw_val, enum PawVal *); struct PawProperty { char *name; enum PawVal *val; }; -dyn_array_define(da_paw_property, struct PawProperty); - -dyn_array_define(da_method, struct PawMethod); +paw_da_define(da_paw_property, struct PawProperty); +paw_da_define(da_method, struct PawMethod); struct PawAST { - struct Mem *mem; + struct PawMem *mem; struct da_paw_property properties; struct da_method methods; }; @@ -146,7 +145,7 @@ struct PawCCall { }; struct VStack { - struct Scene *scene; + struct PawScene *scene; void *left; void *right; void *top; @@ -154,8 +153,8 @@ struct VStack { void print(struct VStack *stack, int offset); -struct VStack *vstack_make(struct Mem *mem, size_t size); -void vstack_free(struct VStack *stack, struct Mem *mem); +struct VStack *vstack_make(struct PawMem *mem, size_t size); +void vstack_free(struct VStack *stack, struct PawMem *mem); void vstack_pop(struct VStack *stack); void vstack_push(struct VStack *stack, struct PawStackVal val); struct PawStackVal vstack_poke(struct VStack *stack); @@ -175,47 +174,47 @@ struct PawStackVal op_equals(struct PawStackVal lhs, struct PawStackVal rhs); struct PawStackVal op_unequals(struct PawStackVal lhs, struct PawStackVal rhs); struct PawStackVal op_add(struct PawStackVal lhs, struct PawStackVal rhs); -enum PawVal *make_pawval_float(struct Mem *mem, float n); -enum PawVal *make_pawval_int(struct Mem *mem, int n); -enum PawVal *make_pawval_bool(struct Mem *mem, bool n); -enum PawVal *make_pawval_point(struct Mem *mem, paw_p n); -enum PawVal *make_pawval_spoint(struct Mem *mem, int n); -enum PawVal *make_pawval_expr(struct Mem *mem, enum PawVal *lhs, +enum PawVal *make_pawval_float(struct PawMem *mem, float n); +enum PawVal *make_pawval_int(struct PawMem *mem, int n); +enum PawVal *make_pawval_bool(struct PawMem *mem, bool n); +enum PawVal *make_pawval_point(struct PawMem *mem, paw_p n); +enum PawVal *make_pawval_spoint(struct PawMem *mem, int n); +enum PawVal *make_pawval_expr(struct PawMem *mem, enum PawVal *lhs, enum PawVal *rhs, uint32_t op); -void free_pawval(struct Mem *mem, enum PawVal *val); -enum PawCtrl *make_pawctrl_seq(struct Mem *mem); -enum PawCtrl *make_pawctrl_spush(struct Mem *mem, struct PawStackVal val); -enum PawCtrl *make_pawctrl_spop(struct Mem *mem); -enum PawCtrl *make_pawctrl_call(struct Mem *mem, enum PawCtrl *body); -enum PawCtrl *make_pawctrl_ccall(struct Mem *mem, int index); -enum PawCtrl *make_pawctrl_loop(struct Mem *mem, enum PawCtrl *body); -enum PawCtrl *make_pawctrl_break(struct Mem *mem); -enum PawCtrl *make_pawctrl_if(struct Mem *mem, enum PawVal *cond, +void free_pawval(struct PawMem *mem, enum PawVal *val); +enum PawCtrl *make_pawctrl_seq(struct PawMem *mem); +enum PawCtrl *make_pawctrl_spush(struct PawMem *mem, struct PawStackVal val); +enum PawCtrl *make_pawctrl_spop(struct PawMem *mem); +enum PawCtrl *make_pawctrl_call(struct PawMem *mem, enum PawCtrl *body); +enum PawCtrl *make_pawctrl_ccall(struct PawMem *mem, int index); +enum PawCtrl *make_pawctrl_loop(struct PawMem *mem, enum PawCtrl *body); +enum PawCtrl *make_pawctrl_break(struct PawMem *mem); +enum PawCtrl *make_pawctrl_if(struct PawMem *mem, enum PawVal *cond, enum PawCtrl *truthy, enum PawCtrl *falsy); -enum PawCtrl *make_pawctrl_asign(struct Mem *mem, struct PawStackVal target, +enum PawCtrl *make_pawctrl_asign(struct PawMem *mem, struct PawStackVal target, enum PawVal *val); void pawseq_append(enum PawCtrl *seq, enum PawCtrl *ctrl); void pawseq_insert(enum PawCtrl *seq, int index, enum PawCtrl *ctrl); -enum PawVal *ast_stack_to_heap(struct Mem *mem, struct PawStackVal val); +enum PawVal *ast_stack_to_heap(struct PawMem *mem, struct PawStackVal val); struct PawAST *ast_make(); void ast_insert_property(struct PawAST *ast, char *name, enum PawVal *val); void ast_register_method(struct PawAST *ast, char *name, enum PawCtrl *body); void ast_append_cfunc(struct PawAST *ast, void (*func)(struct VStack *stack, int offset)); enum PawVal *ast_get_property(struct PawAST *ast, char *name); -void ast_call(struct PawAST *ast, char *method, struct Scene *scene); +void ast_call(struct PawAST *ast, char *method, struct PawScene *scene); #define val_get_data($val) ((void *)$val + sizeof(enum PawVal)) #define val_make($ret, $type, $TYPE_ENUM) \ do { \ - $ret = mem_malloc(mem, sizeof(enum PawVal) + sizeof($type)); \ + $ret = paw_memmalloc(mem, sizeof(enum PawVal) + sizeof($type)); \ *$ret = $TYPE_ENUM; \ } while (0) #define ctrl_get_data($ctrl) (void *)$ctrl + sizeof(enum PawCtrl) #define ctrl_make($ret, $type, $TYPE_ENUM) \ do { \ - $ret = mem_malloc(mem, sizeof(enum PawCtrl) + sizeof($type)); \ + $ret = paw_memmalloc(mem, sizeof(enum PawCtrl) + sizeof($type)); \ *$ret = $TYPE_ENUM; \ } while (0) diff --git a/src/lang/ast_disc.c b/src/lang/ast_disc.c index 7a0d0a5..c375e54 100644 --- a/src/lang/ast_disc.c +++ b/src/lang/ast_disc.c @@ -1,7 +1,7 @@ #include "ast_disc.h" #include "../io.h" -#include "../log.h" +#include "../paw_log.h" #include "ast.h" #define AO1($p) \ @@ -23,10 +23,10 @@ bool apply_before = false; // for nyow ast and ast->mem will be garbled afterwards void ast_write(struct PawAST *ast, char *path) { - int size = ast->mem->mem_size + sizeof(struct Mem); + int size = ast->mem->mem_size + sizeof(struct PawMem); char *data = (char *)ast->mem; region_start = ast->mem; - region_end = ast->mem + ast->mem->mem_size + sizeof(struct Mem); + region_end = ast->mem + ast->mem->mem_size + sizeof(struct PawMem); offset = -(long)region_start; apply_before = false; AO2(ast->mem->alloc); @@ -68,7 +68,7 @@ struct PawAST *ast_read(char *path) { char *data = (char *)read_binary_file(path, &size); offset = (long)data; region_end = (void *)(long)size; - struct Mem *mem = (struct Mem *)data; + struct PawMem *mem = (struct PawMem *)data; apply_before = true; for (int i = 0; i < MAX_ALLOCS; i++) { diff --git a/src/lang/functable.c b/src/lang/functable.c index 2b37c32..5f866ed 100644 --- a/src/lang/functable.c +++ b/src/lang/functable.c @@ -1,4 +1,4 @@ -#include "../log.h" +#include "../paw_log.h" #include "../util.h" #include "ast.h" #include "glue.h" diff --git a/src/lang/glue.c b/src/lang/glue.c index 99a573e..c04c17e 100644 --- a/src/lang/glue.c +++ b/src/lang/glue.c @@ -8,5 +8,5 @@ void pawlang_kitty_make(struct VStack *stack, int offset) { } void pawlang_kitty_free(struct VStack *stack, int offset) { - free_kitty(stack->scene->vk, vstack_poke_n(stack, offset).p); + kitty_free(stack->scene->vk, vstack_poke_n(stack, offset).p); } diff --git a/src/lang/vstack.c b/src/lang/vstack.c index 8fb54b7..6fe2a9f 100644 --- a/src/lang/vstack.c +++ b/src/lang/vstack.c @@ -1,16 +1,16 @@ -#include "../log.h" +#include "../paw_log.h" #include "ast.h" -struct VStack *vstack_make(struct Mem *mem, size_t size) { - struct VStack *stack = mem_malloc(mem, sizeof(struct VStack)); - stack->left = mem_malloc(mem, size); +struct VStack *vstack_make(struct PawMem *mem, size_t size) { + struct VStack *stack = paw_memmalloc(mem, sizeof(struct VStack)); + stack->left = paw_memmalloc(mem, size); stack->right = stack->left + size; stack->top = stack->right; return stack; } -void vstack_free(struct VStack *stack, struct Mem *mem) { - mem_free(mem, stack->left); - mem_free(mem, stack); +void vstack_free(struct VStack *stack, struct PawMem *mem) { + paw_memfree(mem, stack->left); + paw_memfree(mem, stack); } void vstack_pop(struct VStack *stack) { diff --git a/src/object.h b/src/object.h deleted file mode 100644 index 4b6bafe..0000000 --- a/src/object.h +++ /dev/null @@ -1,45 +0,0 @@ -#ifndef INCLUDE_WAYLANDCLIENT_OBJECT_H_ -#define INCLUDE_WAYLANDCLIENT_OBJECT_H_ - -#include "dynarray.h" -// #include "vulkan_internal.h" - -dyn_array_define(da_Object, struct Object *); -dyn_array_define(da_Named, struct Named); - -struct Scene { - struct Vk *vk; - struct Mem *mem; - struct da_Object objects; - struct da_Object insert_queue; - struct da_Named named; - struct Register *reg; - - float delta_secs; - long avg_delta; - long sleep; - long target_delta; - long last_start_time; -}; - -struct Object { - struct Type *type; - void *data; -}; - -struct Named { - const char *id; - struct Object *object; -}; - -struct Scene *make_scene(struct Vk *vk, struct Register *reg); -void free_scene(struct Scene *scene); -void scene_tick(struct Scene *scene); -void scene_queue_insert(struct Scene *scene, char *name, void *object_data); - -void scene_register_named(struct Scene *scene, const char *id, - struct Object *object); -void scene_unregister_named(struct Scene *scene, const char *id); -struct Object *scene_get_named(struct Scene *scene, const char *id); - -#endif // INCLUDE_WAYLANDCLIENT_OBJECT_H_ diff --git a/src/allocator.c b/src/paw_allocator.c similarity index 58% rename from src/allocator.c rename to src/paw_allocator.c index bbc8676..514db23 100644 --- a/src/allocator.c +++ b/src/paw_allocator.c @@ -1,5 +1,5 @@ -#include "allocator.h" -#include "log.h" +#include "paw_allocator.h" +#include "paw_log.h" #include #include @@ -7,21 +7,27 @@ #include #include -struct Mem *make_mem(size_t size) { - struct Mem *mem = malloc(sizeof(struct Mem) + size); +struct PawMem *paw_memmake(size_t size) { + struct PawMem *mem = malloc(sizeof(struct PawMem) + size); mem->mem_size = size; mem->mem = mem + 1; memset(mem->mem, 0, mem->mem_size); mem->count = 0; - memset(&mem->allocs, 0, sizeof(struct Alloc) * MAX_ALLOCS); - mem->allocs[0] = (struct Alloc){mem->mem + mem->mem_size, 0, NULL}; - mem->allocs[1] = (struct Alloc){mem->mem, 0, &mem->allocs[0]}; + memset(&mem->allocs, 0, sizeof(struct PawAlloc) * MAX_ALLOCS); + mem->allocs[0] = (struct PawAlloc){mem->mem + mem->mem_size, 0, NULL}; + mem->allocs[1] = (struct PawAlloc){mem->mem, 0, &mem->allocs[0]}; mem->alloc = &mem->allocs[1]; return mem; } -void uninit_mem(struct Mem *mem) { free(mem); } +void paw_memunmake(struct PawMem *mem) { + if (mem != NULL) { + free(mem); + } else { + meow("tried to free a null mem"); + } +} -static struct Alloc *get_next_alloc(struct Mem *mem) { +static struct PawAlloc *get_next_alloc(struct PawMem *mem) { while (mem->allocs[mem->count].start != NULL || mem->allocs[mem->count].size != 0 || mem->allocs[mem->count].next != NULL) { @@ -33,31 +39,31 @@ static struct Alloc *get_next_alloc(struct Mem *mem) { return &mem->allocs[mem->count]; } -void *malloc_or_mem_malloc(struct Mem *mem, size_t size) { +void *paw_malloc_memmalloc(struct PawMem *mem, size_t size) { if (mem == NULL) { return malloc(size); } else { - return mem_malloc(mem, size); + return paw_memmalloc(mem, size); } } -void free_or_mem_free(struct Mem *mem, void *ptr) { +void paw_free_memfree(struct PawMem *mem, void *ptr) { if (mem == NULL) { free(ptr); } else { - mem_free(mem, ptr); + paw_memfree(mem, ptr); } } -void *mem_malloc(struct Mem *mem, size_t size) { +void *paw_memmalloc(struct PawMem *mem, size_t size) { if (size <= 0) { size = 1; } - struct Alloc *prev = mem->alloc; + struct PawAlloc *prev = mem->alloc; while (prev->next != NULL) { - struct Alloc *next = prev->next; + struct PawAlloc *next = prev->next; if (next->start - (prev->start + prev->size) > size && next != prev) { - struct Alloc *new = get_next_alloc(mem); - *new = (struct Alloc){ + struct PawAlloc *new = get_next_alloc(mem); + *new = (struct PawAlloc){ prev->start + prev->size, size, next, @@ -76,16 +82,16 @@ void *mem_malloc(struct Mem *mem, size_t size) { return NULL; } -void mem_free(struct Mem *mem, void *p) { - struct Alloc *current = mem->alloc; - struct Alloc *prev = mem->alloc; +void paw_memfree(struct PawMem *mem, void *p) { + struct PawAlloc *current = mem->alloc; + struct PawAlloc *prev = mem->alloc; while (current != NULL && (p > current->start || current->size <= 0)) { prev = current; current = current->next; } if (current == NULL || p != current->start) { meow("OOPSIE DAISY double free"); - print_backtrace(); + paw_print_backtrace(); return; } prev->next = current->next; @@ -95,5 +101,5 @@ void mem_free(struct Mem *mem, void *p) { } /*meow("FREE at %d : %p", index, current->start); print_backtrace(); */ - memset(&mem->allocs[index], 0, sizeof(struct Alloc)); + memset(&mem->allocs[index], 0, sizeof(struct PawAlloc)); } diff --git a/src/paw_allocator.h b/src/paw_allocator.h new file mode 100644 index 0000000..e92d613 --- /dev/null +++ b/src/paw_allocator.h @@ -0,0 +1,28 @@ +#ifndef INCLUDE_WAYLANDCLIENT_ALLOCATOR_H_ +#define INCLUDE_WAYLANDCLIENT_ALLOCATOR_H_ + +#include "sys/types.h" + +#define MAX_ALLOCS 256 +struct PawAlloc { + void *start; + uint size; + struct PawAlloc *next; +}; +struct PawMem { + void *mem; + size_t mem_size; + uint count; + struct PawAlloc *alloc; + struct PawAlloc allocs[MAX_ALLOCS]; +}; + +struct PawMem *paw_memmake(size_t size); +void paw_memunmake(struct PawMem *mem); + +void *paw_memmalloc(struct PawMem *mem, size_t size); +void *paw_malloc_memmalloc(struct PawMem *mem, size_t size); +void paw_memfree(struct PawMem *mem, void *p); +void paw_free_memfree(struct PawMem *mem, void *ptr); + +#endif // INCLUDE_WAYLANDCLIENT_ALLOCATOR_H_ diff --git a/src/dynarray.c b/src/paw_da.c similarity index 66% rename from src/dynarray.c rename to src/paw_da.c index b60010b..4751c6e 100644 --- a/src/dynarray.c +++ b/src/paw_da.c @@ -1,4 +1,4 @@ -#include "allocator.h" +#include "paw_da.h" #include @@ -6,12 +6,12 @@ struct da_template { int count; int capacity; void *items; - struct Mem *mem; + struct PawMem *mem; }; // the array struct has to be freed manually, all internal data is freedd by // dyn_array_destroy -void *dyn_array_create() { +void *paw_da_make() { struct da_template *da = malloc(sizeof(struct da_template)); da->items = malloc(0); da->capacity = 0; @@ -21,24 +21,24 @@ void *dyn_array_create() { } // the array struct has to be freed manually, all internal data is freedd by // dyn_array_destroy -void *dyn_array_create_mem(struct Mem *mem) { - struct da_template *da = mem_malloc(mem, sizeof(struct da_template)); - da->items = mem_malloc(mem, 0); +void *paw_da_make_mem(struct PawMem *mem) { + struct da_template *da = paw_memmalloc(mem, sizeof(struct da_template)); + da->items = paw_memmalloc(mem, 0); da->capacity = 0; da->count = 0; da->mem = mem; return da; } -void dyn_array_create_inplace(void *array) { +void paw_da_make_inplace(void *array) { struct da_template *da = array; da->items = malloc(0); da->count = 0; da->capacity = 0; da->mem = NULL; } -void dyn_array_create_inplace_mem(void *array, struct Mem *mem) { +void paw_da_make_inplace_mem(void *array, struct PawMem *mem) { struct da_template *da = array; - da->items = mem_malloc(mem, 0); + da->items = paw_memmalloc(mem, 0); da->count = 0; da->capacity = 0; da->mem = mem; diff --git a/src/dynarray.h b/src/paw_da.h similarity index 74% rename from src/dynarray.h rename to src/paw_da.h index 53d8586..e85df47 100644 --- a/src/dynarray.h +++ b/src/paw_da.h @@ -1,13 +1,13 @@ #ifndef INCLUDE_WAYLANDCLIENT_DYNARRAY_H_ #define INCLUDE_WAYLANDCLIENT_DYNARRAY_H_ -#include "allocator.h" +#include "paw_allocator.h" #include #include #include -#define dyn_array_append(array, item) \ +#define paw_da_append(array, item) \ do { \ if ((array)->count >= (array)->capacity) { \ (array)->capacity += 10; \ @@ -16,39 +16,39 @@ (array)->capacity * sizeof(*(array)->items)); \ } else { \ void *temp = (array)->items; \ - (array)->items = mem_malloc( \ + (array)->items = paw_memmalloc( \ (array)->mem, (array)->capacity * sizeof(*(array)->items)); \ memcpy((array)->items, temp, \ ((array)->count) * sizeof(*(array)->items)); \ - mem_free((array)->mem, temp); \ + paw_memfree((array)->mem, temp); \ } \ } \ (array)->items[(array)->count++] = (item); \ } while (0) -#define dyn_array_insert(array, index, item) \ +#define paw_da_insert(array, index, item) \ do { \ - dyn_array_append(array, item); \ + paw_da_append(array, item); \ memcpy(&(array)->items[(index) + 1], &(array)->items[(index)], \ sizeof(*(array)->items) * ((array)->count - index)); \ (array)->items[(index)] = (item); \ } while (0) -#define dyn_array_remove(array, index) \ +#define paw_da_remove(array, index) \ do { \ (array)->items[(index)] = (array)->items[(array)->count - 1]; \ memset(&(array)->items[(array)->count], 0, sizeof((array)->items[0])); \ (array)->count--; \ } while (0) -#define dyn_array_destroy(array) \ +#define paw_da_free(array) \ if ((array)->mem == NULL) { \ free((array)->items); \ } else { \ - mem_free((array)->mem, (array)->items); \ + paw_memfree((array)->mem, (array)->items); \ } -#define dyn_array_reset(array) \ +#define paw_da_reset(array) \ do { \ (array)->capacity = 10; \ (array)->count = 0; \ @@ -56,26 +56,26 @@ (array)->items = realloc((array)->items, \ (array)->capacity * sizeof(*(array)->items)); \ } else { \ - mem_free((array)->mem, (array)->items); \ - (array)->items = mem_malloc((array)->mem, (array)->capacity * \ - sizeof(*(array)->items)); \ + paw_memfree((array)->mem, (array)->items); \ + (array)->items = paw_memmalloc( \ + (array)->mem, (array)->capacity * sizeof(*(array)->items)); \ } \ } while (0) -#define dyn_array_define($name, $type) \ +#define paw_da_define($name, $type) \ struct $name { \ int count; \ int capacity; \ $type *items; \ - struct Mem *mem; \ + struct PawMem *mem; \ } -dyn_array_define(da_uint32_t, uint32_t); -dyn_array_define(da_string, char *); +paw_da_define(da_uint32_t, uint32_t); +paw_da_define(da_string, char *); -void *dyn_array_create(); -void *dyn_array_create_mem(struct Mem *mem); -void dyn_array_create_inplace(void *array); -void dyn_array_create_inplace_mem(void *array, struct Mem *mem); +void *paw_da_make(); +void *paw_da_make_mem(struct PawMem *mem); +void paw_da_make_inplace(void *array); +void paw_da_make_inplace_mem(void *array, struct PawMem *mem); #endif // INCLUDE_WAYLANDCLIENT_DYNARRAY_H_ diff --git a/src/log.c b/src/paw_log.c similarity index 91% rename from src/log.c rename to src/paw_log.c index 4531c18..ef4fdd6 100644 --- a/src/log.c +++ b/src/paw_log.c @@ -1,4 +1,4 @@ -#include "log.h" +#include "paw_log.h" #include #include @@ -17,7 +17,7 @@ static void full_write(int fd, const char *buf, size_t len) { } } -void print_backtrace() { +void paw_print_backtrace() { static const char start[] = "BACKTRACE ------------\n"; static const char end[] = "----------------------\n"; @@ -38,7 +38,7 @@ void print_backtrace() { free(bt_syms); } -char *bool_to_string(bool b) { +const char *paw_b_to_s(bool b) { if (b) { return "true"; } else { diff --git a/src/log.h b/src/paw_log.h similarity index 89% rename from src/log.h rename to src/paw_log.h index 702aaa7..b0c8bac 100644 --- a/src/log.h +++ b/src/paw_log.h @@ -11,7 +11,7 @@ fprintf(stderr, "[%s:%d] " fmt "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ *(int *)0 = 0; -void print_backtrace(); -char *bool_to_string(bool b); +void paw_print_backtrace(); +const char *paw_b_to_s(bool b); #endif // INCLUDE_WAYLANDCLIENT_LOG_H_ diff --git a/src/object.c b/src/paw_object.c similarity index 56% rename from src/object.c rename to src/paw_object.c index f4aaa6f..b9dc899 100644 --- a/src/object.c +++ b/src/paw_object.c @@ -1,7 +1,6 @@ -#include "object.h" -#include "allocator.h" -#include "dynarray.h" -#include "log.h" +#include "paw_object.h" +#include "paw_allocator.h" +#include "paw_log.h" #include "register.h" #include @@ -10,20 +9,20 @@ #define DT_TARGET 0.016 -struct Scene *make_scene(struct Vk *vk, struct Register *reg) { - struct Scene *scene = malloc(sizeof(struct Scene)); - memset(scene, 0, sizeof(struct Scene)); +struct PawScene *paw_scene_make(struct Vk *vk, struct Register *reg) { + struct PawScene *scene = malloc(sizeof(struct PawScene)); + memset(scene, 0, sizeof(struct PawScene)); scene->vk = vk; - scene->mem = make_mem(100000); + scene->mem = paw_memmake(100000); if (reg == NULL) { scene->reg = make_register(); } else { scene->reg = reg; } - dyn_array_create_inplace_mem(&scene->objects, scene->mem); - dyn_array_create_inplace_mem(&scene->insert_queue, scene->mem); - dyn_array_create_inplace_mem(&scene->named, scene->mem); + paw_da_make_inplace_mem(&scene->objects, scene->mem); + paw_da_make_inplace_mem(&scene->insert_queue, scene->mem); + paw_da_make_inplace_mem(&scene->named, scene->mem); struct timespec time; clock_gettime(CLOCK_MONOTONIC, &time); @@ -35,26 +34,26 @@ struct Scene *make_scene(struct Vk *vk, struct Register *reg) { return scene; } -void free_scene(struct Scene *scene) { +void paw_scene_free(struct PawScene *scene) { for (int i = 0; i < scene->objects.count; i++) { scene->objects.items[i]->type->free(scene, scene->objects.items[i]->data); - mem_free(scene->mem, scene->objects.items[i]); + paw_memfree(scene->mem, scene->objects.items[i]); } - dyn_array_destroy(&scene->objects); + paw_da_free(&scene->objects); for (int i = 0; i < scene->insert_queue.count; i++) { scene->insert_queue.items[i]->type->free( scene, scene->insert_queue.items[i]->data); - mem_free(scene->mem, scene->insert_queue.items[i]); + paw_memfree(scene->mem, scene->insert_queue.items[i]); } - dyn_array_destroy(&scene->insert_queue); - dyn_array_destroy(&scene->named); - uninit_mem(scene->mem); + paw_da_free(&scene->insert_queue); + paw_da_free(&scene->named); + paw_memunmake(scene->mem); - memset(scene, 0, sizeof(struct Scene)); + memset(scene, 0, sizeof(struct PawScene)); free(scene); } -void scene_tick(struct Scene *scene) { +void paw_scene_tick(struct PawScene *scene) { struct timespec time; clock_gettime(CLOCK_MONOTONIC, &time); long msecs_start = time.tv_sec * 1000000 + time.tv_nsec / 1000; @@ -65,7 +64,7 @@ void scene_tick(struct Scene *scene) { if (scene->insert_queue.count > 0) { for (int i = 0; i < scene->insert_queue.count; i++) { - dyn_array_append(&scene->objects, scene->insert_queue.items[i]); + paw_da_append(&scene->objects, scene->insert_queue.items[i]); } scene->insert_queue.count = 0; } @@ -74,7 +73,7 @@ void scene_tick(struct Scene *scene) { } if (scene->insert_queue.count > 0) { for (int i = 0; i < scene->insert_queue.count; i++) { - dyn_array_append(&scene->objects, scene->insert_queue.items[i]); + paw_da_append(&scene->objects, scene->insert_queue.items[i]); } scene->insert_queue.count = 0; } @@ -91,38 +90,41 @@ void scene_tick(struct Scene *scene) { scene->last_start_time = msecs_start; } -void scene_queue_insert(struct Scene *scene, char *name, void *object_data) { +void paw_scene_queue_insert(struct PawScene *scene, char *name, + void *object_data) { struct Type *type = reg_get_type(scene->reg, name); - struct Object *object = mem_malloc(scene->mem, sizeof(struct Object)); + struct PawObject *object = + paw_memmalloc(scene->mem, sizeof(struct PawObject)); object->type = type; object->data = object_data; - dyn_array_append(&scene->insert_queue, object); + paw_da_append(&scene->insert_queue, object); } -void scene_queue_insert_from_data(struct Scene *scene, char *name, char *data, - int len) { +void paw_scene_queue_insert_from_data(struct PawScene *scene, char *name, + char *data, int len) { struct Type *type = reg_get_type(scene->reg, name); - struct Object *object = mem_malloc(scene->mem, sizeof(struct Object)); + struct PawObject *object = + paw_memmalloc(scene->mem, sizeof(struct PawObject)); object->type = type; object->data = type->make(scene, data, len); - dyn_array_append(&scene->insert_queue, object); + paw_da_append(&scene->insert_queue, object); } -void scene_register_named(struct Scene *scene, const char *id, - struct Object *object) { - dyn_array_append(&scene->named, ((struct Named){id, object})); +void paw_scene_reg_named(struct PawScene *scene, const char *id, + struct PawObject *object) { + paw_da_append(&scene->named, ((struct PawNamed){id, object})); } -void scene_unregister_named(struct Scene *scene, const char *id) { +void paw_scene_unreg_named(struct PawScene *scene, const char *id) { for (int i = 0; i < scene->named.count; i++) { if (strcmp(scene->named.items[i].id, id) == 0) { - dyn_array_remove(&scene->named, i); + paw_da_remove(&scene->named, i); return; } } meow("object with name %s was not found", id); } -struct Object *scene_get_named(struct Scene *scene, const char *id) { +struct PawObject *paw_scene_get_named(struct PawScene *scene, const char *id) { for (int i = 0; i < scene->named.count; i++) { if (strcmp(scene->named.items[i].id, id) == 0) { return scene->named.items[i].object; diff --git a/src/paw_object.h b/src/paw_object.h new file mode 100644 index 0000000..fd40109 --- /dev/null +++ b/src/paw_object.h @@ -0,0 +1,46 @@ +#ifndef INCLUDE_WAYLANDCLIENT_OBJECT_H_ +#define INCLUDE_WAYLANDCLIENT_OBJECT_H_ + +#include "paw_da.h" +// #include "vulkan_internal.h" + +paw_da_define(da_Object, struct PawObject *); +paw_da_define(da_Named, struct PawNamed); + +struct PawScene { + struct Vk *vk; + struct PawMem *mem; + struct da_Object objects; + struct da_Object insert_queue; + struct da_Named named; + struct Register *reg; + + float delta_secs; + long avg_delta; + long sleep; + long target_delta; + long last_start_time; +}; + +struct PawObject { + struct Type *type; + void *data; +}; + +struct PawNamed { + const char *id; + struct PawObject *object; +}; + +struct PawScene *paw_scene_make(struct Vk *vk, struct Register *reg); +void paw_scene_free(struct PawScene *scene); +void paw_scene_tick(struct PawScene *scene); +void paw_scene_queue_insert(struct PawScene *scene, char *name, + void *object_data); + +void paw_scene_reg_named(struct PawScene *scene, const char *id, + struct PawObject *object); +void paw_scene_unreg_named(struct PawScene *scene, const char *id); +struct PawObject *paw_scene_get_named(struct PawScene *scene, const char *id); + +#endif // INCLUDE_WAYLANDCLIENT_OBJECT_H_ diff --git a/src/register.c b/src/register.c index e96457b..74486b4 100644 --- a/src/register.c +++ b/src/register.c @@ -1,28 +1,27 @@ #include "register.h" -#include "dynarray.h" -#include "log.h" -#include "object.h" +#include "paw_log.h" +#include "paw_object.h" #include #include struct Register *make_register() { struct Register *reg = malloc(sizeof(struct Register)); - dyn_array_create_inplace(®->reg); + paw_da_make_inplace(®->reg); return reg; } void free_register(struct Register *reg) { - dyn_array_destroy(®->reg); + paw_da_free(®->reg); free(reg); } void reg_attatch_type(struct Register *reg, char *name, - void *(*make)(struct Scene *, char *, int len), - void (*free)(struct Scene *, void *), - void (*tick)(struct Scene *, void *)) { + void *(*make)(struct PawScene *, char *, int len), + void (*free)(struct PawScene *, void *), + void (*tick)(struct PawScene *, void *)) { struct Type type = {name, make, free, tick}; - dyn_array_append(®->reg, type); + paw_da_append(®->reg, type); } struct Type *reg_get_type(struct Register *reg, char *name) { diff --git a/src/register.h b/src/register.h index 038e471..5faea0a 100644 --- a/src/register.h +++ b/src/register.h @@ -1,33 +1,32 @@ #ifndef INCLUDE_WAYLANDCLIENT_REGISTER_H_ #define INCLUDE_WAYLANDCLIENT_REGISTER_H_ -#include "dynarray.h" -#include "object.h" +#include "paw_object.h" -dyn_array_define(da_Type, struct Type); +paw_da_define(da_Type, struct Type); struct Type { char *name; - void *(*make)(struct Scene *, char *, int len); - void (*free)(struct Scene *, void *); - void (*tick)(struct Scene *, void *); + void *(*make)(struct PawScene *, char *, int len); + void (*free)(struct PawScene *, void *); + void (*tick)(struct PawScene *, void *); }; struct Register { struct da_Type reg; }; -#define OBJ_FREE (void (*)(struct Scene *, void *)) -#define OBJ_TICK (void (*)(struct Scene *, void *)) -#define OBJ_MAKE (void *(*)(struct Scene *, char *, int len)) +#define OBJ_FREE (void (*)(struct PawScene *, void *)) +#define OBJ_TICK (void (*)(struct PawScene *, void *)) +#define OBJ_MAKE (void *(*)(struct PawScene *, char *, int len)) struct Register *make_register(); void free_register(struct Register *reg); struct Type *reg_get_type(struct Register *reg, char *name); void reg_attatch_type(struct Register *reg, char *name, - void *(*make)(struct Scene *, char *, int len), - void (*free)(struct Scene *, void *), - void (*tick)(struct Scene *, void *)); + void *(*make)(struct PawScene *, char *, int len), + void (*free)(struct PawScene *, void *), + void (*tick)(struct PawScene *, void *)); #endif // INCLUDE_WAYLANDCLIENT_REGISTER_H_ diff --git a/src/string.c b/src/string.c index 61b948e..b7135d5 100644 --- a/src/string.c +++ b/src/string.c @@ -1,31 +1,31 @@ #include "string.h" -#include "allocator.h" -#include "log.h" +#include "paw_allocator.h" +#include "paw_log.h" #include "util.h" #include #include #include -struct da_string split(struct Mem *mem, char *string, char needle) { +struct da_string split(struct PawMem *mem, char *string, char needle) { struct da_string items; - dyn_array_create_inplace_mem(&items, mem); + paw_da_make_inplace_mem(&items, mem); int last = 0; for (int i = 0; i < strlen(string); i++) { meow("got match!"); if (string[i] == needle) { - char *tmp = mem_malloc(mem, i - last + 1); + char *tmp = paw_memmalloc(mem, i - last + 1); memcpy(tmp, &string[last], i - last); tmp[i - last + 1] = 0x0; - dyn_array_append(&items, tmp); + paw_da_append(&items, tmp); last = i; } } - char *tmp = mem_malloc(mem, strlen(string) - last + 1); + char *tmp = paw_memmalloc(mem, strlen(string) - last + 1); memcpy(tmp, &string[last], strlen(string) - last); tmp[strlen(string) - last + 1] = 0x0; - dyn_array_append(&items, tmp); + paw_da_append(&items, tmp); return items; } @@ -34,7 +34,7 @@ bool start_matches(char *string, char *match) { return memcmp(string, match, strlen(match)) == 0; } -char *extract_brackets(struct Mem *mem, char *start, char open, char close) { +char *extract_brackets(struct PawMem *mem, char *start, char open, char close) { char *end = skip_brackets(start, open, close); // { ... } // ^ end @@ -47,7 +47,7 @@ char *extract_brackets(struct Mem *mem, char *start, char open, char close) { // { ... } // start ^ ^ end start++; - char *res = mem_malloc(mem, end - start + 1); + char *res = paw_memmalloc(mem, end - start + 1); memcpy(res, start, end - start); res[end - start] = 0x0; @@ -90,14 +90,14 @@ int index_of_char(char *string, char key) { } } -char *extract(struct Mem *mem, char *string, int start, int size) { - char *new = mem_malloc(mem, size + 1); +char *extract(struct PawMem *mem, char *string, int start, int size) { + char *new = paw_memmalloc(mem, size + 1); memcpy(new, string + start, size); new[size + 1] = 0x0; return new; } -char *extract_inbetween_chars(struct Mem *mem, char *string, char one, +char *extract_inbetween_chars(struct PawMem *mem, char *string, char one, char two) { int start = index_of_char(string, one) + 1; int end = index_of_char(string, two); @@ -108,13 +108,13 @@ char *extract_inbetween_chars(struct Mem *mem, char *string, char one, return extract(mem, string, start, end - start); } -char *tmp_format(struct Mem *mem, char *format, ...) { +char *tmp_format(struct PawMem *mem, char *format, ...) { char *res = malloc(1024); va_list ap; va_start(ap, NULL); vsprintf(res, format, ap); - char *new = mem_malloc(mem, (strlen(res) + 1) * sizeof(char)); + char *new = paw_memmalloc(mem, (strlen(res) + 1) * sizeof(char)); memcpy(new, res, (strlen(res) + 1) * sizeof(char)); free(res); @@ -165,15 +165,15 @@ bool includes_between(char *start, char *end, char n) { } } -char *mem_strdup(char *string, struct Mem *mem) { - char *new = mem_malloc(mem, (strlen(string) + 1) * sizeof(char)); +char *mem_strdup(char *string, struct PawMem *mem) { + char *new = paw_memmalloc(mem, (strlen(string) + 1) * sizeof(char)); memcpy(new, string, (strlen(string) + 1) * sizeof(char)); return new; } // inclusive!!! -char *mem_strdup_reg(char *start, char *end, struct Mem *mem) { - char *new = mem_malloc(mem, end - start + 2); +char *mem_strdup_reg(char *start, char *end, struct PawMem *mem) { + char *new = paw_memmalloc(mem, end - start + 2); memcpy(new, start, end - start + 1); new[end - start + 2] = 0x0; return new; diff --git a/src/string.h b/src/string.h index 59dc06d..74046ad 100644 --- a/src/string.h +++ b/src/string.h @@ -1,27 +1,27 @@ #ifndef INCLUDE_SRC_STRING_H_ #define INCLUDE_SRC_STRING_H_ -#include "allocator.h" -#include "dynarray.h" +#include "paw_allocator.h" +#include "paw_da.h" #include -struct da_string split(struct Mem *mem, char *string, char needle); +struct da_string split(struct PawMem *mem, char *string, char needle); bool start_matches(char *string, char *match); -char *extract_brackets(struct Mem *mem, char *start, char open, char close); +char *extract_brackets(struct PawMem *mem, char *start, char open, char close); char *skip_brackets(char *start, char open, char close); int index_of_char(char *string, char key); -char *extract(struct Mem *mem, char *string, int start, int size); -char *extract_inbetween_chars(struct Mem *mem, char *string, char one, +char *extract(struct PawMem *mem, char *string, int start, int size); +char *extract_inbetween_chars(struct PawMem *mem, char *string, char one, char two); -char *tmp_format(struct Mem *mem, char *format, ...); +char *tmp_format(struct PawMem *mem, char *format, ...); char *trim_start(char *string); char *trim_end(char *string); bool is_digid(char n); bool is_char(char n); bool includes_between(char *start, char *end, char n); -char *mem_strdup(char *string, struct Mem *mem); -char *mem_strdup_reg(char *start, char *end, struct Mem *mem); +char *mem_strdup(char *string, struct PawMem *mem); +char *mem_strdup_reg(char *start, char *end, struct PawMem *mem); char *strdup_reg(char *start, char *end); char *skip_to_char(char *string, char n); char *skip_after_char(char *string, char n); diff --git a/src/util.c b/src/util.c index b141d11..569c769 100644 --- a/src/util.c +++ b/src/util.c @@ -1,8 +1,10 @@ -#include "allocator.h" -#include "dynarray.h" +#include "paw_allocator.h" +#include "paw_da.h" #include #include +#include "util.h" + float randf() { return (float)rand() / (float)RAND_MAX; } struct ST_key { @@ -10,29 +12,29 @@ struct ST_key { void *value; }; -dyn_array_define(da_ST_key, struct ST_key); +paw_da_define(da_ST_key, struct ST_key); struct StringTable { struct da_ST_key keys; }; -struct StringTable *st_make(struct Mem *mem) { +struct StringTable *st_make(struct PawMem *mem) { struct StringTable *st = - malloc_or_mem_malloc(mem, sizeof(struct StringTable)); + paw_malloc_memmalloc(mem, sizeof(struct StringTable)); if (mem == NULL) { - dyn_array_create_inplace(&st->keys); + paw_da_make_inplace(&st->keys); } else { - dyn_array_create_inplace_mem(&st->keys, mem); + paw_da_make_inplace_mem(&st->keys, mem); } return st; } struct StringTable *st_dup(struct StringTable *st) { struct StringTable *new = - malloc_or_mem_malloc(st->keys.mem, sizeof(struct StringTable)); + paw_malloc_memmalloc(st->keys.mem, sizeof(struct StringTable)); new->keys.mem = st->keys.mem; new->keys.count = st->keys.count; new->keys.capacity = st->keys.capacity; - new->keys.items = malloc_or_mem_malloc(new->keys.mem, sizeof(struct ST_key) * + new->keys.items = paw_malloc_memmalloc(new->keys.mem, sizeof(struct ST_key) * new->keys.capacity); memcpy(new->keys.items, st->keys.items, st->keys.capacity * sizeof(struct ST_key)); @@ -40,7 +42,7 @@ struct StringTable *st_dup(struct StringTable *st) { return new; } void st_insert(struct StringTable *st, char *key, void *value) { - dyn_array_append(&st->keys, ((struct ST_key){.key = key, .value = value})); + paw_da_append(&st->keys, ((struct ST_key){.key = key, .value = value})); } bool st_has_key(struct StringTable *st, char *key) { for (int i = 0; i < st->keys.count; i++) { @@ -79,18 +81,13 @@ int st_get_index(struct StringTable *st, char *key) { void st_remove(struct StringTable *st, char *key) { for (int i = 0; i < st->keys.count; i++) { if (strcmp(st->keys.items[i].key, key) == 0) { - dyn_array_remove(&st->keys, i); + paw_da_remove(&st->keys, i); } } } void st_unmake(struct StringTable *st) { - if (st->keys.mem == NULL) { - dyn_array_destroy(&st->keys); - free(st); - } else { - dyn_array_destroy(&st->keys); - mem_free(st->keys.mem, st); - } + paw_da_free(&st->keys); + paw_free_memfree(st->keys.mem, st); } int st_get_size(struct StringTable *st) { return st->keys.count; } char *st_get_nth_key(struct StringTable *st, int index) { diff --git a/src/util.h b/src/util.h index 0d9df66..3f55a8f 100644 --- a/src/util.h +++ b/src/util.h @@ -3,7 +3,7 @@ #define UINT32_NULL 42424242 -#include "allocator.h" +#include "paw_allocator.h" float randf(); @@ -16,7 +16,7 @@ float randf(); } while (0) struct StringTable; -struct StringTable *st_make(struct Mem *mem); +struct StringTable *st_make(struct PawMem *mem); struct StringTable *st_dup(struct StringTable *st); void st_insert(struct StringTable *st, char *key, void *value); bool st_has_key(struct StringTable *st, char *key); diff --git a/src/vulkan.c b/src/vulkan.c index dcda392..c3d4dba 100644 --- a/src/vulkan.c +++ b/src/vulkan.c @@ -1,6 +1,5 @@ #include "vulkan.h" #include "kitty.h" -#include "log.h" #include "types.h" #include "image.h" @@ -62,7 +61,7 @@ handle_vulkan_error(VkDebugUtilsMessageSeverityFlagBitsEXT severity, } printf("%s\n", callbackData->pMessage); if (backtrace) { - print_backtrace(); + paw_print_backtrace(); } return 0; } @@ -737,7 +736,7 @@ struct Vk *init_vk(void *data, int width, int heigh, setup_command_buffers(state); setup_sync_objects(state); - dyn_array_create_inplace(&state->kitties); + paw_da_make_inplace(&state->kitties); return state; } @@ -745,7 +744,7 @@ struct Vk *init_vk(void *data, int width, int heigh, void uninit_vk(struct Vk *state) { CHECK_VK_RESULT(vkDeviceWaitIdle(state->device)); - dyn_array_destroy(&state->kitties); + paw_da_free(&state->kitties); destroy_swapchain(state); diff --git a/src/vulkan.h b/src/vulkan.h index 93ca40d..1b5ac35 100644 --- a/src/vulkan.h +++ b/src/vulkan.h @@ -4,8 +4,8 @@ #include #include -#include "dynarray.h" -#include "log.h" +#include "paw_da.h" +#include "paw_log.h" #include "types.h" struct GpuMem; @@ -28,8 +28,8 @@ struct GpuPointer { #define MAX_FRAMES_IN_FLIGHT 2 -dyn_array_define(da_VK_FORMAT, enum VkFormat); -dyn_array_define(da_Kitty, struct Kitty *); +paw_da_define(da_VK_FORMAT, enum VkFormat); +paw_da_define(da_Kitty, struct Kitty *); struct VertexBuffer { void *data; diff --git a/src/vulkan_helpers.c b/src/vulkan_helpers.c index 436d00a..e5e7f33 100644 --- a/src/vulkan_helpers.c +++ b/src/vulkan_helpers.c @@ -1,4 +1,4 @@ -#include "log.h" +#include "paw_log.h" #include diff --git a/src/wayland.c b/src/wayland.c index 0ef7879..03c83fc 100644 --- a/src/wayland.c +++ b/src/wayland.c @@ -12,9 +12,9 @@ #include #include -#include "dynarray.h" #include "hashmap.h" -#include "log.h" +#include "paw_da.h" +#include "paw_log.h" #include "vulkan.h" #include @@ -116,10 +116,10 @@ static void keyboard_event_key(void *data, struct wl_keyboard *wl_keyboard, xkb_state_key_get_utf8(state->xkb_state, key, buffer, sizeof(buffer)); if (key_state == 1) { insert_hashmap_ui32(state->keys, sym); - dyn_array_append(&state->pressed, sym); + paw_da_append(&state->pressed, sym); } else if (key_state == 0) { remove_hashmap_ui32(state->keys, sym); - dyn_array_append(&state->released, sym); + paw_da_append(&state->released, sym); } else { meow("bad wayland, a key can either go up or down, not %d", key_state); } @@ -243,8 +243,8 @@ struct cat_Wl *cat_init_wl(const char *name, int width, int heigh, struct cat_Wl *state = malloc(sizeof(struct cat_Wl)); memset(state, 0, sizeof(struct cat_Wl)); state->keys = create_hashmap_ui32(); - dyn_array_create_inplace(&state->pressed); - dyn_array_create_inplace(&state->released); + paw_da_make_inplace(&state->pressed); + paw_da_make_inplace(&state->released); state->should_close = state->resize_ready = state->resize_coming = false; @@ -279,8 +279,8 @@ struct cat_Wl *cat_init_wl(const char *name, int width, int heigh, } void cat_wl_draw(struct cat_Wl *state) { - dyn_array_reset(&state->pressed); - dyn_array_reset(&state->released); + paw_da_reset(&state->pressed); + paw_da_reset(&state->released); if (state->resize_ready && state->resize_coming) { meow("resizing to %d x %d", state->new_width, state->new_heigh); @@ -306,8 +306,8 @@ void cat_uninit_wl(struct cat_Wl *state) { uninit_vk(state->vk); destroy_hashmap_ui32(state->keys); - dyn_array_destroy(&state->pressed); - dyn_array_destroy(&state->released); + paw_da_free(&state->pressed); + paw_da_free(&state->released); if (state->xkb_state != NULL) { xkb_state_unref(state->xkb_state); diff --git a/trig.c b/trig.c index d50defc..d87690c 100644 --- a/trig.c +++ b/trig.c @@ -1,8 +1,8 @@ -#include "src/allocator.h" #include "src/kitty.h" -#include "src/log.h" #include "src/matrix.h" -#include "src/object.h" +#include "src/paw_allocator.h" +#include "src/paw_log.h" +#include "src/paw_object.h" #include "src/types.h" #include "src/util.h" @@ -34,8 +34,8 @@ struct TrigUBO { struct mat3x3 view; struct mat3x3 proj; }; -struct Trig *trig_make_args(struct Scene *scene) { - struct Trig *trig = mem_malloc(scene->mem, sizeof(struct Trig)); +struct Trig *trig_make_args(struct PawScene *scene) { + struct Trig *trig = paw_memmalloc(scene->mem, sizeof(struct Trig)); trig->kitty = kitty_make(scene->mem); kitty_set_vertex_shader(trig->kitty, "./Shaders/vert.spv"); @@ -67,16 +67,16 @@ struct Trig *trig_make_args(struct Scene *scene) { return trig; } -struct Trig *make_trig(struct Scene *scene, char *_data, int _len) { +struct Trig *make_trig(struct PawScene *scene, char *_data, int _len) { return trig_make_args(scene); } -void free_trig(struct Scene *scene, struct Trig *trig) { - free_kitty(scene->vk, trig->kitty); - mem_free(scene->mem, trig); +void free_trig(struct PawScene *scene, struct Trig *trig) { + kitty_free(scene->vk, trig->kitty); + paw_memfree(scene->mem, trig); } -void trig_tick(struct Scene *scene, struct Trig *trig) { +void trig_tick(struct PawScene *scene, struct Trig *trig) { struct TrigUBO ubo = {0}; ubo.view = multiply3x3(translate3x3((struct Vec2){-1.5f, -0.5f}), scale3x3((struct Vec2){1.0f, 1.0f}));