diff --git a/pxl8.sh b/pxl8.sh index 3087f63..4dec268 100755 --- a/pxl8.sh +++ b/pxl8.sh @@ -407,7 +407,8 @@ case "$COMMAND" in src/sfx/pxl8_sfx.c src/script/pxl8_repl.c src/script/pxl8_script.c - src/hal/pxl8_sdl3.c + src/hal/pxl8_hal_sdl3.c + src/hal/pxl8_mem_sdl3.c src/world/pxl8_bsp.c src/world/pxl8_gen.c src/world/pxl8_world.c diff --git a/src/asset/pxl8_ase.c b/src/asset/pxl8_ase.c index 36f9620..df78459 100644 --- a/src/asset/pxl8_ase.c +++ b/src/asset/pxl8_ase.c @@ -14,6 +14,7 @@ #include "pxl8_io.h" #include "pxl8_log.h" +#include "pxl8_mem.h" static pxl8_result parse_ase_header(pxl8_stream* stream, pxl8_ase_header* header) { header->file_size = pxl8_read_u32(stream); @@ -58,7 +59,7 @@ static pxl8_result parse_old_palette_chunk(pxl8_stream* stream, pxl8_ase_palette palette->entry_count = total_colors; palette->first_color = 0; palette->last_color = total_colors - 1; - palette->colors = (u32*)malloc(total_colors * sizeof(u32)); + palette->colors = (u32*)pxl8_malloc(total_colors * sizeof(u32)); if (!palette->colors) { return PXL8_ERROR_OUT_OF_MEMORY; } @@ -97,7 +98,7 @@ static pxl8_result parse_layer_chunk(pxl8_stream* stream, pxl8_ase_layer* layer) u16 name_len = pxl8_read_u16(stream); if (name_len > 0) { - layer->name = (char*)malloc(name_len + 1); + layer->name = (char*)pxl8_malloc(name_len + 1); if (!layer->name) return PXL8_ERROR_OUT_OF_MEMORY; pxl8_read_bytes(stream, layer->name, name_len); layer->name[name_len] = '\0'; @@ -120,7 +121,7 @@ static pxl8_result parse_palette_chunk(pxl8_stream* stream, pxl8_ase_palette* pa return PXL8_ERROR_ASE_MALFORMED_CHUNK; } - palette->colors = (u32*)malloc(color_count * sizeof(u32)); + palette->colors = (u32*)pxl8_malloc(color_count * sizeof(u32)); if (!palette->colors) { return PXL8_ERROR_OUT_OF_MEMORY; } @@ -154,7 +155,7 @@ static pxl8_result parse_user_data_chunk(pxl8_stream* stream, pxl8_ase_user_data if (user_data->has_text) { u16 text_len = pxl8_read_u16(stream); if (text_len > 0) { - user_data->text = (char*)malloc(text_len + 1); + user_data->text = (char*)pxl8_malloc(text_len + 1); if (!user_data->text) return PXL8_ERROR_OUT_OF_MEMORY; pxl8_read_bytes(stream, user_data->text, text_len); user_data->text[text_len] = '\0'; @@ -174,14 +175,14 @@ static pxl8_result parse_user_data_chunk(pxl8_stream* stream, pxl8_ase_user_data u32 num_properties = pxl8_read_u32(stream); if (num_properties > 0) { - user_data->properties = (pxl8_ase_property*)calloc(num_properties, sizeof(pxl8_ase_property)); + user_data->properties = (pxl8_ase_property*)pxl8_calloc(num_properties, sizeof(pxl8_ase_property)); if (!user_data->properties) return PXL8_ERROR_OUT_OF_MEMORY; user_data->property_count = num_properties; for (u32 i = 0; i < num_properties; i++) { u16 name_len = pxl8_read_u16(stream); if (name_len > 0) { - user_data->properties[i].name = (char*)malloc(name_len + 1); + user_data->properties[i].name = (char*)pxl8_malloc(name_len + 1); if (!user_data->properties[i].name) return PXL8_ERROR_OUT_OF_MEMORY; pxl8_read_bytes(stream, user_data->properties[i].name, name_len); user_data->properties[i].name[name_len] = '\0'; @@ -207,7 +208,7 @@ static pxl8_result parse_user_data_chunk(pxl8_stream* stream, pxl8_ase_user_data case 8: { u16 str_len = pxl8_read_u16(stream); if (str_len > 0) { - user_data->properties[i].string_val = (char*)malloc(str_len + 1); + user_data->properties[i].string_val = (char*)pxl8_malloc(str_len + 1); if (!user_data->properties[i].string_val) return PXL8_ERROR_OUT_OF_MEMORY; pxl8_read_bytes(stream, user_data->properties[i].string_val, str_len); user_data->properties[i].string_val[str_len] = '\0'; @@ -236,7 +237,7 @@ static pxl8_result parse_tileset_chunk(pxl8_stream* stream, pxl8_ase_tileset* ti u16 name_len = pxl8_read_u16(stream); if (name_len > 0) { - tileset->name = (char*)malloc(name_len + 1); + tileset->name = (char*)pxl8_malloc(name_len + 1); if (!tileset->name) return PXL8_ERROR_OUT_OF_MEMORY; pxl8_read_bytes(stream, tileset->name, name_len); tileset->name[name_len] = '\0'; @@ -249,7 +250,7 @@ static pxl8_result parse_tileset_chunk(pxl8_stream* stream, pxl8_ase_tileset* ti if (tileset->flags & 2) { u32 compressed_size = pxl8_read_u32(stream); tileset->pixels_size = tileset->tile_width * tileset->tile_height * tileset->tile_count; - tileset->pixels = (u8*)malloc(tileset->pixels_size); + tileset->pixels = (u8*)pxl8_malloc(tileset->pixels_size); if (!tileset->pixels) return PXL8_ERROR_OUT_OF_MEMORY; const u8* compressed_data = pxl8_read_ptr(stream, compressed_size); @@ -257,13 +258,13 @@ static pxl8_result parse_tileset_chunk(pxl8_stream* stream, pxl8_ase_tileset* ti i32 result = mz_uncompress(tileset->pixels, &dest_len, compressed_data, compressed_size); if (result != MZ_OK) { pxl8_error("Failed to decompress tileset data: miniz error %d", result); - free(tileset->pixels); + pxl8_free(tileset->pixels); tileset->pixels = NULL; return PXL8_ERROR_ASE_MALFORMED_CHUNK; } } - tileset->tile_user_data = (pxl8_ase_user_data*)calloc(tileset->tile_count, sizeof(pxl8_ase_user_data)); + tileset->tile_user_data = (pxl8_ase_user_data*)pxl8_calloc(tileset->tile_count, sizeof(pxl8_ase_user_data)); if (!tileset->tile_user_data) return PXL8_ERROR_OUT_OF_MEMORY; return PXL8_OK; @@ -288,7 +289,7 @@ static pxl8_result parse_cel_chunk(pxl8_stream* stream, u32 chunk_size, pxl8_ase u32 pixels_size = cel->image.width * cel->image.height; u32 compressed_size = chunk_size - 20; - cel->image.pixels = (u8*)malloc(pixels_size); + cel->image.pixels = (u8*)pxl8_malloc(pixels_size); if (!cel->image.pixels) return PXL8_ERROR_OUT_OF_MEMORY; const u8* compressed_data = pxl8_read_ptr(stream, compressed_size); @@ -296,7 +297,7 @@ static pxl8_result parse_cel_chunk(pxl8_stream* stream, u32 chunk_size, pxl8_ase i32 result = mz_uncompress(cel->image.pixels, &dest_len, compressed_data, compressed_size); if (result != MZ_OK) { pxl8_error("Failed to decompress cel data: miniz error %d", result); - free(cel->image.pixels); + pxl8_free(cel->image.pixels); cel->image.pixels = NULL; return PXL8_ERROR_ASE_MALFORMED_CHUNK; } @@ -321,7 +322,7 @@ static pxl8_result parse_cel_chunk(pxl8_stream* stream, u32 chunk_size, pxl8_ase u32 uncompressed_size = tile_count * bytes_per_tile; u32 compressed_size = chunk_size - 36; - u8* temp_buffer = (u8*)malloc(uncompressed_size); + u8* temp_buffer = (u8*)pxl8_malloc(uncompressed_size); if (!temp_buffer) return PXL8_ERROR_OUT_OF_MEMORY; const u8* compressed_data = pxl8_read_ptr(stream, compressed_size); @@ -329,13 +330,13 @@ static pxl8_result parse_cel_chunk(pxl8_stream* stream, u32 chunk_size, pxl8_ase i32 result = mz_uncompress(temp_buffer, &dest_len, compressed_data, compressed_size); if (result != MZ_OK) { pxl8_error("Failed to decompress tilemap data: miniz error %d", result); - free(temp_buffer); + pxl8_free(temp_buffer); return PXL8_ERROR_ASE_MALFORMED_CHUNK; } - cel->tilemap.tiles = (u32*)calloc(tile_count, sizeof(u32)); + cel->tilemap.tiles = (u32*)pxl8_calloc(tile_count, sizeof(u32)); if (!cel->tilemap.tiles) { - free(temp_buffer); + pxl8_free(temp_buffer); return PXL8_ERROR_OUT_OF_MEMORY; } @@ -353,7 +354,7 @@ static pxl8_result parse_cel_chunk(pxl8_stream* stream, u32 chunk_size, pxl8_ase } } - free(temp_buffer); + pxl8_free(temp_buffer); } return PXL8_OK; @@ -367,7 +368,7 @@ pxl8_result pxl8_ase_load(const char* filepath, pxl8_ase_file* ase_file) { memset(ase_file, 0, sizeof(pxl8_ase_file)); u8* file_data; - size_t file_size; + usize file_size; pxl8_result result = pxl8_io_read_binary_file(filepath, &file_data, &file_size); if (result != PXL8_OK) { return result; @@ -387,7 +388,7 @@ pxl8_result pxl8_ase_load(const char* filepath, pxl8_ase_file* ase_file) { } ase_file->frame_count = ase_file->header.frames; - ase_file->frames = (pxl8_ase_frame*)calloc(ase_file->frame_count, sizeof(pxl8_ase_frame)); + ase_file->frames = (pxl8_ase_frame*)pxl8_calloc(ase_file->frame_count, sizeof(pxl8_ase_frame)); if (!ase_file->frames) { pxl8_io_free_binary_data(file_data); return PXL8_ERROR_OUT_OF_MEMORY; @@ -425,7 +426,7 @@ pxl8_result pxl8_ase_load(const char* filepath, pxl8_ase_file* ase_file) { frame->duration = frame_header.duration; u32 pixel_count = frame->width * frame->height; - frame->pixels = (u8*)calloc(pixel_count, sizeof(u8)); + frame->pixels = (u8*)pxl8_calloc(pixel_count, sizeof(u8)); if (!frame->pixels) { result = PXL8_ERROR_OUT_OF_MEMORY; break; @@ -457,7 +458,7 @@ pxl8_result pxl8_ase_load(const char* filepath, pxl8_ase_file* ase_file) { case PXL8_ASE_CHUNK_LAYER: { pxl8_ase_layer* new_layers = - (pxl8_ase_layer*)realloc(ase_file->layers, + (pxl8_ase_layer*)pxl8_realloc(ase_file->layers, (ase_file->layer_count + 1) * sizeof(pxl8_ase_layer)); if (!new_layers) { result = PXL8_ERROR_OUT_OF_MEMORY; @@ -476,7 +477,7 @@ pxl8_result pxl8_ase_load(const char* filepath, pxl8_ase_file* ase_file) { pxl8_ase_cel cel = {0}; result = parse_cel_chunk(&stream, chunk_header.chunk_size - 6, &cel); if (result == PXL8_OK) { - pxl8_ase_cel* new_cels = (pxl8_ase_cel*)realloc(frame->cels, (frame->cel_count + 1) * sizeof(pxl8_ase_cel)); + pxl8_ase_cel* new_cels = (pxl8_ase_cel*)pxl8_realloc(frame->cels, (frame->cel_count + 1) * sizeof(pxl8_ase_cel)); if (!new_cels) { result = PXL8_ERROR_OUT_OF_MEMORY; break; @@ -515,14 +516,14 @@ pxl8_result pxl8_ase_load(const char* filepath, pxl8_ase_file* ase_file) { case PXL8_ASE_CHUNK_PALETTE: if (ase_file->palette.colors) { - free(ase_file->palette.colors); + pxl8_free(ase_file->palette.colors); ase_file->palette.colors = NULL; } result = parse_palette_chunk(&stream, &ase_file->palette); break; case PXL8_ASE_CHUNK_TILESET: { - pxl8_ase_tileset* new_tilesets = (pxl8_ase_tileset*)realloc(ase_file->tilesets, + pxl8_ase_tileset* new_tilesets = (pxl8_ase_tileset*)pxl8_realloc(ase_file->tilesets, (ase_file->tileset_count + 1) * sizeof(pxl8_ase_tileset)); if (!new_tilesets) { result = PXL8_ERROR_OUT_OF_MEMORY; @@ -579,57 +580,57 @@ void pxl8_ase_destroy(pxl8_ase_file* ase_file) { if (ase_file->frames) { for (u32 i = 0; i < ase_file->frame_count; i++) { - if (ase_file->frames[i].pixels) free(ase_file->frames[i].pixels); + if (ase_file->frames[i].pixels) pxl8_free(ase_file->frames[i].pixels); if (ase_file->frames[i].cels) { for (u32 j = 0; j < ase_file->frames[i].cel_count; j++) { pxl8_ase_cel* cel = &ase_file->frames[i].cels[j]; if (cel->cel_type == 2 && cel->image.pixels) { - free(cel->image.pixels); + pxl8_free(cel->image.pixels); } else if (cel->cel_type == 3 && cel->tilemap.tiles) { - free(cel->tilemap.tiles); + pxl8_free(cel->tilemap.tiles); } } - free(ase_file->frames[i].cels); + pxl8_free(ase_file->frames[i].cels); } } - free(ase_file->frames); + pxl8_free(ase_file->frames); } if (ase_file->palette.colors) { - free(ase_file->palette.colors); + pxl8_free(ase_file->palette.colors); } if (ase_file->layers) { for (u32 i = 0; i < ase_file->layer_count; i++) { if (ase_file->layers[i].name) { - free(ase_file->layers[i].name); + pxl8_free(ase_file->layers[i].name); } } - free(ase_file->layers); + pxl8_free(ase_file->layers); } if (ase_file->tilesets) { for (u32 i = 0; i < ase_file->tileset_count; i++) { - if (ase_file->tilesets[i].name) free(ase_file->tilesets[i].name); - if (ase_file->tilesets[i].pixels) free(ase_file->tilesets[i].pixels); + if (ase_file->tilesets[i].name) pxl8_free(ase_file->tilesets[i].name); + if (ase_file->tilesets[i].pixels) pxl8_free(ase_file->tilesets[i].pixels); if (ase_file->tilesets[i].tile_user_data) { for (u32 j = 0; j < ase_file->tilesets[i].tile_count; j++) { pxl8_ase_user_data* ud = &ase_file->tilesets[i].tile_user_data[j]; - if (ud->text) free(ud->text); + if (ud->text) pxl8_free(ud->text); if (ud->properties) { for (u32 k = 0; k < ud->property_count; k++) { - if (ud->properties[k].name) free(ud->properties[k].name); + if (ud->properties[k].name) pxl8_free(ud->properties[k].name); if (ud->properties[k].type == 8 && ud->properties[k].string_val) { - free(ud->properties[k].string_val); + pxl8_free(ud->properties[k].string_val); } } - free(ud->properties); + pxl8_free(ud->properties); } } - free(ase_file->tilesets[i].tile_user_data); + pxl8_free(ase_file->tilesets[i].tile_user_data); } } - free(ase_file->tilesets); + pxl8_free(ase_file->tilesets); } memset(ase_file, 0, sizeof(pxl8_ase_file)); diff --git a/src/asset/pxl8_cart.c b/src/asset/pxl8_cart.c index 1bbf69f..9f4131e 100644 --- a/src/asset/pxl8_cart.c +++ b/src/asset/pxl8_cart.c @@ -8,6 +8,7 @@ #include #include "pxl8_log.h" +#include "pxl8_mem.h" #define PXL8_CART_MAGIC 0x43585850 #define PXL8_CART_VERSION 1 @@ -62,7 +63,7 @@ static bool is_directory(const char* path) { } static bool is_pxc_file(const char* path) { - size_t len = strlen(path); + usize len = strlen(path); return len > 4 && strcmp(path + len - 4, ".pxc") == 0; } @@ -97,7 +98,7 @@ static void collect_files_recursive(const char* dir_path, const char* prefix, } else { if (*count >= *capacity) { *capacity = (*capacity == 0) ? 64 : (*capacity * 2); - *paths = realloc(*paths, *capacity * sizeof(char*)); + *paths = pxl8_realloc(*paths, *capacity * sizeof(char*)); } (*paths)[(*count)++] = strdup(rel_path); } @@ -123,13 +124,13 @@ static pxl8_result load_packed_cart(pxl8_cart* cart, const u8* data, u32 size) { if (header->magic != PXL8_CART_MAGIC) return PXL8_ERROR_INVALID_FORMAT; if (header->version > PXL8_CART_VERSION) return PXL8_ERROR_INVALID_FORMAT; - cart->data = malloc(size); + cart->data = pxl8_malloc(size); if (!cart->data) return PXL8_ERROR_OUT_OF_MEMORY; memcpy(cart->data, data, size); cart->data_size = size; cart->file_count = header->file_count; - cart->files = calloc(cart->file_count, sizeof(pxl8_cart_file)); + cart->files = pxl8_calloc(cart->file_count, sizeof(pxl8_cart_file)); if (!cart->files) return PXL8_ERROR_OUT_OF_MEMORY; const u8* toc = cart->data + sizeof(pxl8_cart_header); @@ -137,7 +138,7 @@ static pxl8_result load_packed_cart(pxl8_cart* cart, const u8* data, u32 size) { const pxl8_cart_entry* entry = (const pxl8_cart_entry*)toc; toc += sizeof(pxl8_cart_entry); - cart->files[i].path = malloc(entry->path_len + 1); + cart->files[i].path = pxl8_malloc(entry->path_len + 1); memcpy(cart->files[i].path, toc, entry->path_len); cart->files[i].path[entry->path_len] = '\0'; toc += entry->path_len; @@ -151,7 +152,7 @@ static pxl8_result load_packed_cart(pxl8_cart* cart, const u8* data, u32 size) { } pxl8_cart* pxl8_cart_create(void) { - pxl8_cart* cart = calloc(1, sizeof(pxl8_cart)); + pxl8_cart* cart = pxl8_calloc(1, sizeof(pxl8_cart)); if (cart) { cart->resolution = PXL8_RESOLUTION_640x360; cart->window_size = (pxl8_size){1280, 720}; @@ -167,7 +168,7 @@ pxl8_cart* pxl8_get_cart(void) { void pxl8_cart_destroy(pxl8_cart* cart) { if (!cart) return; pxl8_cart_unload(cart); - free(cart); + pxl8_free(cart); } pxl8_result pxl8_cart_load(pxl8_cart* cart, const char* path) { @@ -202,16 +203,16 @@ pxl8_result pxl8_cart_load(pxl8_cart* cart, const char* path) { u32 size = (u32)ftell(file); fseek(file, 0, SEEK_SET); - u8* data = malloc(size); + u8* data = pxl8_malloc(size); if (!data || fread(data, 1, size, file) != size) { - free(data); + pxl8_free(data); fclose(file); return PXL8_ERROR_SYSTEM_FAILURE; } fclose(file); pxl8_result result = load_packed_cart(cart, data, size); - free(data); + pxl8_free(data); if (result == PXL8_OK) { pxl8_info("Loaded cart"); @@ -242,16 +243,16 @@ pxl8_result pxl8_cart_load_embedded(pxl8_cart* cart, const char* exe_path) { } fseek(file, trailer.cart_offset, SEEK_SET); - u8* data = malloc(trailer.cart_size); + u8* data = pxl8_malloc(trailer.cart_size); if (!data || fread(data, 1, trailer.cart_size, file) != trailer.cart_size) { - free(data); + pxl8_free(data); fclose(file); return PXL8_ERROR_SYSTEM_FAILURE; } fclose(file); pxl8_result result = load_packed_cart(cart, data, trailer.cart_size); - free(data); + pxl8_free(data); if (result == PXL8_OK) { pxl8_info("Loaded embedded cart"); @@ -265,7 +266,7 @@ void pxl8_cart_unload(pxl8_cart* cart) { if (cart->title) { pxl8_info("Unloaded cart: %s", cart->title); pxl8_cart_unmount(cart); - free(cart->title); + pxl8_free(cart->title); cart->title = NULL; } else if (cart->base_path || cart->data) { pxl8_info("Unloaded cart"); @@ -274,18 +275,18 @@ void pxl8_cart_unload(pxl8_cart* cart) { if (cart->files) { for (u32 i = 0; i < cart->file_count; i++) { - free(cart->files[i].path); + pxl8_free(cart->files[i].path); } - free(cart->files); + pxl8_free(cart->files); cart->files = NULL; } cart->file_count = 0; - free(cart->data); + pxl8_free(cart->data); cart->data = NULL; cart->data_size = 0; - free(cart->base_path); + pxl8_free(cart->base_path); cart->base_path = NULL; cart->is_folder = false; } @@ -302,7 +303,7 @@ pxl8_result pxl8_cart_mount(pxl8_cart* cart) { pxl8_original_cwd = getcwd(NULL, 0); if (chdir(cart->base_path) != 0) { pxl8_error("Failed to change to cart directory: %s", cart->base_path); - free(pxl8_original_cwd); + pxl8_free(pxl8_original_cwd); pxl8_original_cwd = NULL; return PXL8_ERROR_FILE_NOT_FOUND; } @@ -323,7 +324,7 @@ void pxl8_cart_unmount(pxl8_cart* cart) { if (pxl8_original_cwd) { chdir(pxl8_original_cwd); - free(pxl8_original_cwd); + pxl8_free(pxl8_original_cwd); pxl8_original_cwd = NULL; } @@ -343,7 +344,7 @@ const char* pxl8_cart_get_title(const pxl8_cart* cart) { void pxl8_cart_set_title(pxl8_cart* cart, const char* title) { if (!cart || !title) return; - free(cart->title); + pxl8_free(cart->title); cart->title = strdup(title); } @@ -399,16 +400,16 @@ bool pxl8_cart_file_exists(const pxl8_cart* cart, const char* path) { return find_file(cart, path) != NULL; } -bool pxl8_cart_resolve_path(const pxl8_cart* cart, const char* relative_path, char* out_path, size_t out_size) { +bool pxl8_cart_resolve_path(const pxl8_cart* cart, const char* relative_path, char* out_path, usize out_size) { if (!cart || !relative_path || !out_path || out_size == 0) return false; if (cart->is_folder && cart->base_path) { i32 written = snprintf(out_path, out_size, "%s/%s", cart->base_path, relative_path); - return written >= 0 && (size_t)written < out_size; + return written >= 0 && (usize)written < out_size; } i32 written = snprintf(out_path, out_size, "%s", relative_path); - return written >= 0 && (size_t)written < out_size; + return written >= 0 && (usize)written < out_size; } pxl8_result pxl8_cart_read_file(const pxl8_cart* cart, const char* path, u8** data_out, u32* size_out) { @@ -427,9 +428,9 @@ pxl8_result pxl8_cart_read_file(const pxl8_cart* cart, const char* path, u8** da *size_out = (u32)ftell(file); fseek(file, 0, SEEK_SET); - *data_out = malloc(*size_out); + *data_out = pxl8_malloc(*size_out); if (!*data_out || fread(*data_out, 1, *size_out, file) != *size_out) { - free(*data_out); + pxl8_free(*data_out); *data_out = NULL; fclose(file); return PXL8_ERROR_SYSTEM_FAILURE; @@ -442,7 +443,7 @@ pxl8_result pxl8_cart_read_file(const pxl8_cart* cart, const char* path, u8** da if (!cf) return PXL8_ERROR_FILE_NOT_FOUND; *size_out = cf->size; - *data_out = malloc(cf->size); + *data_out = pxl8_malloc(cf->size); if (!*data_out) return PXL8_ERROR_OUT_OF_MEMORY; memcpy(*data_out, cart->data + cf->offset, cf->size); @@ -450,7 +451,7 @@ pxl8_result pxl8_cart_read_file(const pxl8_cart* cart, const char* path, u8** da } void pxl8_cart_free_file(u8* data) { - free(data); + pxl8_free(data); } pxl8_result pxl8_cart_pack(const char* folder_path, const char* output_path) { @@ -483,7 +484,7 @@ pxl8_result pxl8_cart_pack(const char* folder_path, const char* output_path) { u32 data_offset = sizeof(pxl8_cart_header) + toc_size; u32 total_size = data_offset; - u32* file_sizes = malloc(count * sizeof(u32)); + u32* file_sizes = pxl8_malloc(count * sizeof(u32)); for (u32 i = 0; i < count; i++) { char full_path[1024]; snprintf(full_path, sizeof(full_path), "%s/%s", folder_path, paths[i]); @@ -496,11 +497,11 @@ pxl8_result pxl8_cart_pack(const char* folder_path, const char* output_path) { } } - u8* buffer = calloc(1, total_size); + u8* buffer = pxl8_calloc(1, total_size); if (!buffer) { - free(file_sizes); - for (u32 i = 0; i < count; i++) free(paths[i]); - free(paths); + pxl8_free(file_sizes); + for (u32 i = 0; i < count; i++) pxl8_free(paths[i]); + pxl8_free(paths); return PXL8_ERROR_OUT_OF_MEMORY; } @@ -536,20 +537,20 @@ pxl8_result pxl8_cart_pack(const char* folder_path, const char* output_path) { } file_offset += file_sizes[i]; - free(paths[i]); + pxl8_free(paths[i]); } - free(paths); - free(file_sizes); + pxl8_free(paths); + pxl8_free(file_sizes); FILE* out = fopen(output_path, "wb"); if (!out) { - free(buffer); + pxl8_free(buffer); return PXL8_ERROR_SYSTEM_FAILURE; } fwrite(buffer, 1, total_size, out); fclose(out); - free(buffer); + pxl8_free(buffer); pxl8_info("Cart packed: %u files, %u bytes", count, total_size); return PXL8_OK; @@ -573,7 +574,7 @@ pxl8_result pxl8_cart_bundle(const char* input_path, const char* output_path, co fseek(f, 0, SEEK_END); cart_size = (u32)ftell(f); fseek(f, 0, SEEK_SET); - cart_data = malloc(cart_size); + cart_data = pxl8_malloc(cart_size); fread(cart_data, 1, cart_size, f); fclose(f); unlink(temp_pxc); @@ -584,7 +585,7 @@ pxl8_result pxl8_cart_bundle(const char* input_path, const char* output_path, co fseek(f, 0, SEEK_END); cart_size = (u32)ftell(f); fseek(f, 0, SEEK_SET); - cart_data = malloc(cart_size); + cart_data = pxl8_malloc(cart_size); fread(cart_data, 1, cart_size, f); fclose(f); free_cart = true; @@ -594,30 +595,30 @@ pxl8_result pxl8_cart_bundle(const char* input_path, const char* output_path, co FILE* exe = fopen(exe_path, "rb"); if (!exe) { - if (free_cart) free(cart_data); + if (free_cart) pxl8_free(cart_data); return PXL8_ERROR_FILE_NOT_FOUND; } fseek(exe, 0, SEEK_END); u32 exe_size = (u32)ftell(exe); fseek(exe, 0, SEEK_SET); - u8* exe_data = malloc(exe_size); + u8* exe_data = pxl8_malloc(exe_size); fread(exe_data, 1, exe_size, exe); fclose(exe); FILE* out = fopen(output_path, "wb"); if (!out) { - free(exe_data); - if (free_cart) free(cart_data); + pxl8_free(exe_data); + if (free_cart) pxl8_free(cart_data); return PXL8_ERROR_SYSTEM_FAILURE; } fwrite(exe_data, 1, exe_size, out); - free(exe_data); + pxl8_free(exe_data); u32 cart_offset = exe_size; fwrite(cart_data, 1, cart_size, out); - if (free_cart) free(cart_data); + if (free_cart) pxl8_free(cart_data); pxl8_cart_trailer trailer = { .magic = PXL8_CART_TRAILER_MAGIC, diff --git a/src/asset/pxl8_cart.h b/src/asset/pxl8_cart.h index b142c9b..9384192 100644 --- a/src/asset/pxl8_cart.h +++ b/src/asset/pxl8_cart.h @@ -34,7 +34,7 @@ bool pxl8_cart_is_packed(const pxl8_cart* cart); bool pxl8_cart_has_embedded(const char* exe_path); bool pxl8_cart_file_exists(const pxl8_cart* cart, const char* path); -bool pxl8_cart_resolve_path(const pxl8_cart* cart, const char* relative_path, char* out_path, size_t out_size); +bool pxl8_cart_resolve_path(const pxl8_cart* cart, const char* relative_path, char* out_path, usize out_size); pxl8_result pxl8_cart_read_file(const pxl8_cart* cart, const char* path, u8** data_out, u32* size_out); void pxl8_cart_free_file(u8* data); diff --git a/src/asset/pxl8_save.c b/src/asset/pxl8_save.c index 2bec3fa..5233869 100644 --- a/src/asset/pxl8_save.c +++ b/src/asset/pxl8_save.c @@ -17,6 +17,7 @@ #endif #include "pxl8_log.h" +#include "pxl8_mem.h" typedef struct { u32 magic; @@ -40,7 +41,7 @@ static u32 pxl8_save_checksum(const u8* data, u32 size) { return hash; } -static void pxl8_save_get_slot_path(pxl8_save* save, u8 slot, char* path, size_t path_size) { +static void pxl8_save_get_slot_path(pxl8_save* save, u8 slot, char* path, usize path_size) { if (slot == PXL8_SAVE_HOTRELOAD_SLOT) { snprintf(path, path_size, "%s%chotreload.sav", save->directory, PATH_SEP); } else { @@ -68,7 +69,7 @@ static pxl8_result pxl8_save_ensure_directory(const char* path) { pxl8_save* pxl8_save_create(const char* game_name, u32 magic, u32 version) { if (!game_name) return NULL; - pxl8_save* save = (pxl8_save*)calloc(1, sizeof(pxl8_save)); + pxl8_save* save = (pxl8_save*)pxl8_calloc(1, sizeof(pxl8_save)); if (!save) return NULL; save->magic = magic; @@ -81,7 +82,7 @@ pxl8_save* pxl8_save_create(const char* game_name, u32 magic, u32 version) { snprintf(save->directory, sizeof(save->directory), "%s%cpxl8%c%s", base_dir, PATH_SEP, PATH_SEP, game_name); } else { - free(save); + pxl8_free(save); return NULL; } #else @@ -91,7 +92,7 @@ pxl8_save* pxl8_save_create(const char* game_name, u32 magic, u32 version) { if (pw) home = pw->pw_dir; } if (!home) { - free(save); + pxl8_free(save); return NULL; } @@ -106,7 +107,7 @@ pxl8_save* pxl8_save_create(const char* game_name, u32 magic, u32 version) { #endif if (pxl8_save_ensure_directory(save->directory) != PXL8_OK) { - free(save); + pxl8_free(save); return NULL; } @@ -116,7 +117,7 @@ pxl8_save* pxl8_save_create(const char* game_name, u32 magic, u32 version) { void pxl8_save_destroy(pxl8_save* save) { if (save) { - free(save); + pxl8_free(save); } } @@ -199,14 +200,14 @@ pxl8_result pxl8_save_read(pxl8_save* save, u8 slot, u8** data_out, u32* size_ou return PXL8_ERROR_INVALID_FORMAT; } - u8* data = (u8*)malloc(header.size); + u8* data = (u8*)pxl8_malloc(header.size); if (!data) { fclose(file); return PXL8_ERROR_OUT_OF_MEMORY; } if (fread(data, 1, header.size, file) != header.size) { - free(data); + pxl8_free(data); fclose(file); return PXL8_ERROR_SYSTEM_FAILURE; } @@ -215,7 +216,7 @@ pxl8_result pxl8_save_read(pxl8_save* save, u8 slot, u8** data_out, u32* size_ou u32 checksum = pxl8_save_checksum(data, header.size); if (checksum != header.checksum) { - free(data); + pxl8_free(data); pxl8_error("Save file checksum mismatch"); return PXL8_ERROR_INVALID_FORMAT; } @@ -234,7 +235,7 @@ pxl8_result pxl8_save_read(pxl8_save* save, u8 slot, u8** data_out, u32* size_ou void pxl8_save_free(u8* data) { if (data) { - free(data); + pxl8_free(data); } } diff --git a/src/core/pxl8.c b/src/core/pxl8.c index 0c7d0d2..f6943f8 100644 --- a/src/core/pxl8.c +++ b/src/core/pxl8.c @@ -13,6 +13,7 @@ #include "pxl8_hal.h" #include "pxl8_log.h" #include "pxl8_macros.h" +#include "pxl8_mem.h" #include "pxl8_repl.h" #include "pxl8_replay.h" #include "pxl8_script.h" @@ -38,23 +39,23 @@ static void pxl8_audio_event_callback(u8 event_type, u8 context_id, u8 note, f32 #endif pxl8* pxl8_create(const pxl8_hal* hal) { - pxl8* sys = (pxl8*)calloc(1, sizeof(pxl8)); + pxl8* sys = (pxl8*)pxl8_calloc(1, sizeof(pxl8)); if (!sys) return NULL; pxl8_log_init(&sys->log); if (!hal) { pxl8_error("hal cannot be null"); - free(sys); + pxl8_free(sys); return NULL; } sys->hal = hal; - sys->game = (pxl8_game*)calloc(1, sizeof(pxl8_game)); + sys->game = (pxl8_game*)pxl8_calloc(1, sizeof(pxl8_game)); if (!sys->game) { pxl8_error("failed to allocate game"); - free(sys); + pxl8_free(sys); return NULL; } @@ -64,11 +65,11 @@ pxl8* pxl8_create(const pxl8_hal* hal) { void pxl8_destroy(pxl8* sys) { if (!sys) return; - if (sys->game) free(sys->game); + if (sys->game) pxl8_free(sys->game); if (sys->cart) pxl8_cart_destroy(sys->cart); if (sys->hal && sys->platform_data) sys->hal->destroy(sys->platform_data); - free(sys); + pxl8_free(sys); } static void pxl8_print_help(void) { @@ -170,7 +171,7 @@ pxl8_result pxl8_init(pxl8* sys, i32 argc, char* argv[]) { cart_path = "."; } else { pxl8_error("no main.fnl or main.lua found in current directory"); - free(original_cwd); + pxl8_free(original_cwd); return PXL8_ERROR_INITIALIZATION_FAILED; } } @@ -189,7 +190,7 @@ pxl8_result pxl8_init(pxl8* sys, i32 argc, char* argv[]) { pxl8_error("failed to load cart%s%s", load_from_path ? ": " : "", load_from_path ? cart_path : ""); if (sys->cart) pxl8_cart_destroy(sys->cart); sys->cart = NULL; - free(original_cwd); + pxl8_free(original_cwd); return PXL8_ERROR_INITIALIZATION_FAILED; } @@ -202,7 +203,7 @@ pxl8_result pxl8_init(pxl8* sys, i32 argc, char* argv[]) { } else if (script_arg) { pxl8_strncpy(game->script_path, script_arg, sizeof(game->script_path)); } - free(original_cwd); + pxl8_free(original_cwd); const char* window_title = pxl8_cart_get_title(sys->cart); if (!window_title) window_title = "pxl8"; diff --git a/src/core/pxl8_bytes.c b/src/core/pxl8_bytes.c index 1894878..7da60b0 100644 --- a/src/core/pxl8_bytes.c +++ b/src/core/pxl8_bytes.c @@ -1,35 +1,35 @@ #include "pxl8_bytes.h" #include -void pxl8_pack_u8(u8* buf, size_t offset, u8 val) { +void pxl8_pack_u8(u8* buf, usize offset, u8 val) { buf[offset] = val; } -void pxl8_pack_u16_le(u8* buf, size_t offset, u16 val) { +void pxl8_pack_u16_le(u8* buf, usize offset, u16 val) { buf[offset] = (u8)(val); buf[offset + 1] = (u8)(val >> 8); } -void pxl8_pack_u16_be(u8* buf, size_t offset, u16 val) { +void pxl8_pack_u16_be(u8* buf, usize offset, u16 val) { buf[offset] = (u8)(val >> 8); buf[offset + 1] = (u8)(val); } -void pxl8_pack_u32_le(u8* buf, size_t offset, u32 val) { +void pxl8_pack_u32_le(u8* buf, usize offset, u32 val) { buf[offset] = (u8)(val); buf[offset + 1] = (u8)(val >> 8); buf[offset + 2] = (u8)(val >> 16); buf[offset + 3] = (u8)(val >> 24); } -void pxl8_pack_u32_be(u8* buf, size_t offset, u32 val) { +void pxl8_pack_u32_be(u8* buf, usize offset, u32 val) { buf[offset] = (u8)(val >> 24); buf[offset + 1] = (u8)(val >> 16); buf[offset + 2] = (u8)(val >> 8); buf[offset + 3] = (u8)(val); } -void pxl8_pack_u64_le(u8* buf, size_t offset, u64 val) { +void pxl8_pack_u64_le(u8* buf, usize offset, u64 val) { buf[offset] = (u8)(val); buf[offset + 1] = (u8)(val >> 8); buf[offset + 2] = (u8)(val >> 16); @@ -40,7 +40,7 @@ void pxl8_pack_u64_le(u8* buf, size_t offset, u64 val) { buf[offset + 7] = (u8)(val >> 56); } -void pxl8_pack_u64_be(u8* buf, size_t offset, u64 val) { +void pxl8_pack_u64_be(u8* buf, usize offset, u64 val) { buf[offset] = (u8)(val >> 56); buf[offset + 1] = (u8)(val >> 48); buf[offset + 2] = (u8)(val >> 40); @@ -51,85 +51,85 @@ void pxl8_pack_u64_be(u8* buf, size_t offset, u64 val) { buf[offset + 7] = (u8)(val); } -void pxl8_pack_i8(u8* buf, size_t offset, i8 val) { +void pxl8_pack_i8(u8* buf, usize offset, i8 val) { buf[offset] = (u8)val; } -void pxl8_pack_i16_le(u8* buf, size_t offset, i16 val) { +void pxl8_pack_i16_le(u8* buf, usize offset, i16 val) { pxl8_pack_u16_le(buf, offset, (u16)val); } -void pxl8_pack_i16_be(u8* buf, size_t offset, i16 val) { +void pxl8_pack_i16_be(u8* buf, usize offset, i16 val) { pxl8_pack_u16_be(buf, offset, (u16)val); } -void pxl8_pack_i32_le(u8* buf, size_t offset, i32 val) { +void pxl8_pack_i32_le(u8* buf, usize offset, i32 val) { pxl8_pack_u32_le(buf, offset, (u32)val); } -void pxl8_pack_i32_be(u8* buf, size_t offset, i32 val) { +void pxl8_pack_i32_be(u8* buf, usize offset, i32 val) { pxl8_pack_u32_be(buf, offset, (u32)val); } -void pxl8_pack_i64_le(u8* buf, size_t offset, i64 val) { +void pxl8_pack_i64_le(u8* buf, usize offset, i64 val) { pxl8_pack_u64_le(buf, offset, (u64)val); } -void pxl8_pack_i64_be(u8* buf, size_t offset, i64 val) { +void pxl8_pack_i64_be(u8* buf, usize offset, i64 val) { pxl8_pack_u64_be(buf, offset, (u64)val); } -void pxl8_pack_f32_le(u8* buf, size_t offset, f32 val) { +void pxl8_pack_f32_le(u8* buf, usize offset, f32 val) { u32 bits; memcpy(&bits, &val, sizeof(bits)); pxl8_pack_u32_le(buf, offset, bits); } -void pxl8_pack_f32_be(u8* buf, size_t offset, f32 val) { +void pxl8_pack_f32_be(u8* buf, usize offset, f32 val) { u32 bits; memcpy(&bits, &val, sizeof(bits)); pxl8_pack_u32_be(buf, offset, bits); } -void pxl8_pack_f64_le(u8* buf, size_t offset, f64 val) { +void pxl8_pack_f64_le(u8* buf, usize offset, f64 val) { u64 bits; memcpy(&bits, &val, sizeof(bits)); pxl8_pack_u64_le(buf, offset, bits); } -void pxl8_pack_f64_be(u8* buf, size_t offset, f64 val) { +void pxl8_pack_f64_be(u8* buf, usize offset, f64 val) { u64 bits; memcpy(&bits, &val, sizeof(bits)); pxl8_pack_u64_be(buf, offset, bits); } -u8 pxl8_unpack_u8(const u8* buf, size_t offset) { +u8 pxl8_unpack_u8(const u8* buf, usize offset) { return buf[offset]; } -u16 pxl8_unpack_u16_le(const u8* buf, size_t offset) { +u16 pxl8_unpack_u16_le(const u8* buf, usize offset) { return (u16)buf[offset] | ((u16)buf[offset + 1] << 8); } -u16 pxl8_unpack_u16_be(const u8* buf, size_t offset) { +u16 pxl8_unpack_u16_be(const u8* buf, usize offset) { return ((u16)buf[offset] << 8) | (u16)buf[offset + 1]; } -u32 pxl8_unpack_u32_le(const u8* buf, size_t offset) { +u32 pxl8_unpack_u32_le(const u8* buf, usize offset) { return (u32)buf[offset] | ((u32)buf[offset + 1] << 8) | ((u32)buf[offset + 2] << 16) | ((u32)buf[offset + 3] << 24); } -u32 pxl8_unpack_u32_be(const u8* buf, size_t offset) { +u32 pxl8_unpack_u32_be(const u8* buf, usize offset) { return ((u32)buf[offset] << 24) | ((u32)buf[offset + 1] << 16) | ((u32)buf[offset + 2] << 8) | (u32)buf[offset + 3]; } -u64 pxl8_unpack_u64_le(const u8* buf, size_t offset) { +u64 pxl8_unpack_u64_le(const u8* buf, usize offset) { return (u64)buf[offset] | ((u64)buf[offset + 1] << 8) | ((u64)buf[offset + 2] << 16) | @@ -140,7 +140,7 @@ u64 pxl8_unpack_u64_le(const u8* buf, size_t offset) { ((u64)buf[offset + 7] << 56); } -u64 pxl8_unpack_u64_be(const u8* buf, size_t offset) { +u64 pxl8_unpack_u64_be(const u8* buf, usize offset) { return ((u64)buf[offset] << 56) | ((u64)buf[offset + 1] << 48) | ((u64)buf[offset + 2] << 40) | @@ -151,56 +151,56 @@ u64 pxl8_unpack_u64_be(const u8* buf, size_t offset) { (u64)buf[offset + 7]; } -i8 pxl8_unpack_i8(const u8* buf, size_t offset) { +i8 pxl8_unpack_i8(const u8* buf, usize offset) { return (i8)buf[offset]; } -i16 pxl8_unpack_i16_le(const u8* buf, size_t offset) { +i16 pxl8_unpack_i16_le(const u8* buf, usize offset) { return (i16)pxl8_unpack_u16_le(buf, offset); } -i16 pxl8_unpack_i16_be(const u8* buf, size_t offset) { +i16 pxl8_unpack_i16_be(const u8* buf, usize offset) { return (i16)pxl8_unpack_u16_be(buf, offset); } -i32 pxl8_unpack_i32_le(const u8* buf, size_t offset) { +i32 pxl8_unpack_i32_le(const u8* buf, usize offset) { return (i32)pxl8_unpack_u32_le(buf, offset); } -i32 pxl8_unpack_i32_be(const u8* buf, size_t offset) { +i32 pxl8_unpack_i32_be(const u8* buf, usize offset) { return (i32)pxl8_unpack_u32_be(buf, offset); } -i64 pxl8_unpack_i64_le(const u8* buf, size_t offset) { +i64 pxl8_unpack_i64_le(const u8* buf, usize offset) { return (i64)pxl8_unpack_u64_le(buf, offset); } -i64 pxl8_unpack_i64_be(const u8* buf, size_t offset) { +i64 pxl8_unpack_i64_be(const u8* buf, usize offset) { return (i64)pxl8_unpack_u64_be(buf, offset); } -f32 pxl8_unpack_f32_le(const u8* buf, size_t offset) { +f32 pxl8_unpack_f32_le(const u8* buf, usize offset) { u32 bits = pxl8_unpack_u32_le(buf, offset); f32 result; memcpy(&result, &bits, sizeof(result)); return result; } -f32 pxl8_unpack_f32_be(const u8* buf, size_t offset) { +f32 pxl8_unpack_f32_be(const u8* buf, usize offset) { u32 bits = pxl8_unpack_u32_be(buf, offset); f32 result; memcpy(&result, &bits, sizeof(result)); return result; } -f64 pxl8_unpack_f64_le(const u8* buf, size_t offset) { +f64 pxl8_unpack_f64_le(const u8* buf, usize offset) { u64 bits = pxl8_unpack_u64_le(buf, offset); f64 result; memcpy(&result, &bits, sizeof(result)); return result; } -f64 pxl8_unpack_f64_be(const u8* buf, size_t offset) { +f64 pxl8_unpack_f64_be(const u8* buf, usize offset) { u64 bits = pxl8_unpack_u64_be(buf, offset); f64 result; memcpy(&result, &bits, sizeof(result)); diff --git a/src/core/pxl8_bytes.h b/src/core/pxl8_bytes.h index 5f5a5e7..852f50a 100644 --- a/src/core/pxl8_bytes.h +++ b/src/core/pxl8_bytes.h @@ -10,43 +10,43 @@ void pxl8_bit_set(u32* val, u8 bit); bool pxl8_bit_test(u32 val, u8 bit); void pxl8_bit_toggle(u32* val, u8 bit); -void pxl8_pack_u8(u8* buf, size_t offset, u8 val); -void pxl8_pack_u16_be(u8* buf, size_t offset, u16 val); -void pxl8_pack_u16_le(u8* buf, size_t offset, u16 val); -void pxl8_pack_u32_be(u8* buf, size_t offset, u32 val); -void pxl8_pack_u32_le(u8* buf, size_t offset, u32 val); -void pxl8_pack_u64_be(u8* buf, size_t offset, u64 val); -void pxl8_pack_u64_le(u8* buf, size_t offset, u64 val); -void pxl8_pack_i8(u8* buf, size_t offset, i8 val); -void pxl8_pack_i16_be(u8* buf, size_t offset, i16 val); -void pxl8_pack_i16_le(u8* buf, size_t offset, i16 val); -void pxl8_pack_i32_be(u8* buf, size_t offset, i32 val); -void pxl8_pack_i32_le(u8* buf, size_t offset, i32 val); -void pxl8_pack_i64_be(u8* buf, size_t offset, i64 val); -void pxl8_pack_i64_le(u8* buf, size_t offset, i64 val); -void pxl8_pack_f32_be(u8* buf, size_t offset, f32 val); -void pxl8_pack_f32_le(u8* buf, size_t offset, f32 val); -void pxl8_pack_f64_be(u8* buf, size_t offset, f64 val); -void pxl8_pack_f64_le(u8* buf, size_t offset, f64 val); +void pxl8_pack_u8(u8* buf, usize offset, u8 val); +void pxl8_pack_u16_be(u8* buf, usize offset, u16 val); +void pxl8_pack_u16_le(u8* buf, usize offset, u16 val); +void pxl8_pack_u32_be(u8* buf, usize offset, u32 val); +void pxl8_pack_u32_le(u8* buf, usize offset, u32 val); +void pxl8_pack_u64_be(u8* buf, usize offset, u64 val); +void pxl8_pack_u64_le(u8* buf, usize offset, u64 val); +void pxl8_pack_i8(u8* buf, usize offset, i8 val); +void pxl8_pack_i16_be(u8* buf, usize offset, i16 val); +void pxl8_pack_i16_le(u8* buf, usize offset, i16 val); +void pxl8_pack_i32_be(u8* buf, usize offset, i32 val); +void pxl8_pack_i32_le(u8* buf, usize offset, i32 val); +void pxl8_pack_i64_be(u8* buf, usize offset, i64 val); +void pxl8_pack_i64_le(u8* buf, usize offset, i64 val); +void pxl8_pack_f32_be(u8* buf, usize offset, f32 val); +void pxl8_pack_f32_le(u8* buf, usize offset, f32 val); +void pxl8_pack_f64_be(u8* buf, usize offset, f64 val); +void pxl8_pack_f64_le(u8* buf, usize offset, f64 val); -u8 pxl8_unpack_u8(const u8* buf, size_t offset); -u16 pxl8_unpack_u16_be(const u8* buf, size_t offset); -u16 pxl8_unpack_u16_le(const u8* buf, size_t offset); -u32 pxl8_unpack_u32_be(const u8* buf, size_t offset); -u32 pxl8_unpack_u32_le(const u8* buf, size_t offset); -u64 pxl8_unpack_u64_be(const u8* buf, size_t offset); -u64 pxl8_unpack_u64_le(const u8* buf, size_t offset); -i8 pxl8_unpack_i8(const u8* buf, size_t offset); -i16 pxl8_unpack_i16_be(const u8* buf, size_t offset); -i16 pxl8_unpack_i16_le(const u8* buf, size_t offset); -i32 pxl8_unpack_i32_be(const u8* buf, size_t offset); -i32 pxl8_unpack_i32_le(const u8* buf, size_t offset); -i64 pxl8_unpack_i64_be(const u8* buf, size_t offset); -i64 pxl8_unpack_i64_le(const u8* buf, size_t offset); -f32 pxl8_unpack_f32_be(const u8* buf, size_t offset); -f32 pxl8_unpack_f32_le(const u8* buf, size_t offset); -f64 pxl8_unpack_f64_be(const u8* buf, size_t offset); -f64 pxl8_unpack_f64_le(const u8* buf, size_t offset); +u8 pxl8_unpack_u8(const u8* buf, usize offset); +u16 pxl8_unpack_u16_be(const u8* buf, usize offset); +u16 pxl8_unpack_u16_le(const u8* buf, usize offset); +u32 pxl8_unpack_u32_be(const u8* buf, usize offset); +u32 pxl8_unpack_u32_le(const u8* buf, usize offset); +u64 pxl8_unpack_u64_be(const u8* buf, usize offset); +u64 pxl8_unpack_u64_le(const u8* buf, usize offset); +i8 pxl8_unpack_i8(const u8* buf, usize offset); +i16 pxl8_unpack_i16_be(const u8* buf, usize offset); +i16 pxl8_unpack_i16_le(const u8* buf, usize offset); +i32 pxl8_unpack_i32_be(const u8* buf, usize offset); +i32 pxl8_unpack_i32_le(const u8* buf, usize offset); +i64 pxl8_unpack_i64_be(const u8* buf, usize offset); +i64 pxl8_unpack_i64_le(const u8* buf, usize offset); +f32 pxl8_unpack_f32_be(const u8* buf, usize offset); +f32 pxl8_unpack_f32_le(const u8* buf, usize offset); +f64 pxl8_unpack_f64_be(const u8* buf, usize offset); +f64 pxl8_unpack_f64_le(const u8* buf, usize offset); typedef struct { const u8* bytes; diff --git a/src/core/pxl8_io.c b/src/core/pxl8_io.c index ae354b7..3de6ca1 100644 --- a/src/core/pxl8_io.c +++ b/src/core/pxl8_io.c @@ -1,4 +1,5 @@ #include "pxl8_io.h" +#include "pxl8_mem.h" #include #include @@ -10,7 +11,7 @@ static inline char pxl8_to_lower(char c) { return (c >= 'A' && c <= 'Z') ? c + 32 : c; } -pxl8_result pxl8_io_read_file(const char* path, char** content, size_t* size) { +pxl8_result pxl8_io_read_file(const char* path, char** content, usize* size) { if (!path || !content || !size) return PXL8_ERROR_NULL_POINTER; pxl8_cart* cart = pxl8_get_cart(); @@ -19,7 +20,7 @@ pxl8_result pxl8_io_read_file(const char* path, char** content, size_t* size) { u32 cart_size = 0; pxl8_result result = pxl8_cart_read_file(cart, path, &data, &cart_size); if (result == PXL8_OK) { - *content = realloc(data, cart_size + 1); + *content = pxl8_realloc(data, cart_size + 1); if (!*content) { pxl8_cart_free_file(data); return PXL8_ERROR_OUT_OF_MEMORY; @@ -44,13 +45,13 @@ pxl8_result pxl8_io_read_file(const char* path, char** content, size_t* size) { return PXL8_ERROR_SYSTEM_FAILURE; } - *content = malloc(file_size + 1); + *content = pxl8_malloc(file_size + 1); if (!*content) { fclose(file); return PXL8_ERROR_OUT_OF_MEMORY; } - size_t bytes_read = fread(*content, 1, file_size, file); + usize bytes_read = fread(*content, 1, file_size, file); (*content)[bytes_read] = '\0'; *size = bytes_read; @@ -58,7 +59,7 @@ pxl8_result pxl8_io_read_file(const char* path, char** content, size_t* size) { return PXL8_OK; } -pxl8_result pxl8_io_write_file(const char* path, const char* content, size_t size) { +pxl8_result pxl8_io_write_file(const char* path, const char* content, usize size) { if (!path || !content) return PXL8_ERROR_NULL_POINTER; FILE* file = fopen(path, "wb"); @@ -66,17 +67,17 @@ pxl8_result pxl8_io_write_file(const char* path, const char* content, size_t siz return PXL8_ERROR_SYSTEM_FAILURE; } - size_t bytes_written = fwrite(content, 1, size, file); + usize bytes_written = fwrite(content, 1, size, file); fclose(file); return (bytes_written == size) ? PXL8_OK : PXL8_ERROR_SYSTEM_FAILURE; } -pxl8_result pxl8_io_read_binary_file(const char* path, u8** data, size_t* size) { +pxl8_result pxl8_io_read_binary_file(const char* path, u8** data, usize* size) { return pxl8_io_read_file(path, (char**)data, size); } -pxl8_result pxl8_io_write_binary_file(const char* path, const u8* data, size_t size) { +pxl8_result pxl8_io_write_binary_file(const char* path, const u8* data, usize size) { return pxl8_io_write_file(path, (const char*)data, size); } @@ -112,13 +113,13 @@ pxl8_result pxl8_io_create_directory(const char* path) { void pxl8_io_free_file_content(char* content) { if (content) { - free(content); + pxl8_free(content); } } void pxl8_io_free_binary_data(u8* data) { if (data) { - free(data); + pxl8_free(data); } } @@ -144,7 +145,7 @@ static i32 pxl8_key_code(const char* key_name) { }; char lower_name[64]; - size_t i; + usize i; for (i = 0; i < sizeof(lower_name) - 1 && key_name[i]; i++) { lower_name[i] = pxl8_to_lower(key_name[i]); } diff --git a/src/core/pxl8_io.h b/src/core/pxl8_io.h index 13daab5..9770ebe 100644 --- a/src/core/pxl8_io.h +++ b/src/core/pxl8_io.h @@ -15,10 +15,10 @@ bool pxl8_io_file_exists(const char* path); void pxl8_io_free_binary_data(u8* data); void pxl8_io_free_file_content(char* content); f64 pxl8_io_get_file_modified_time(const char* path); -pxl8_result pxl8_io_read_binary_file(const char* path, u8** data, size_t* size); -pxl8_result pxl8_io_read_file(const char* path, char** content, size_t* size); -pxl8_result pxl8_io_write_binary_file(const char* path, const u8* data, size_t size); -pxl8_result pxl8_io_write_file(const char* path, const char* content, size_t size); +pxl8_result pxl8_io_read_binary_file(const char* path, u8** data, usize* size); +pxl8_result pxl8_io_read_file(const char* path, char** content, usize* size); +pxl8_result pxl8_io_write_binary_file(const char* path, const u8* data, usize size); +pxl8_result pxl8_io_write_file(const char* path, const char* content, usize size); bool pxl8_key_down(const pxl8_input_state* input, const char* key_name); bool pxl8_key_pressed(const pxl8_input_state* input, const char* key_name); diff --git a/src/core/pxl8_log.c b/src/core/pxl8_log.c index d897000..688760b 100644 --- a/src/core/pxl8_log.c +++ b/src/core/pxl8_log.c @@ -34,7 +34,7 @@ void pxl8_log_set_level(pxl8_log_level level) { if (g_log) g_log->level = level; } -static void log_timestamp(char* buffer, size_t size) { +static void log_timestamp(char* buffer, usize size) { time_t now = time(NULL); struct tm* tm_info = localtime(&now); strftime(buffer, size, "%H:%M:%S", tm_info); diff --git a/src/core/pxl8_replay.c b/src/core/pxl8_replay.c index 32983fd..205b1f7 100644 --- a/src/core/pxl8_replay.c +++ b/src/core/pxl8_replay.c @@ -1,5 +1,6 @@ #include "pxl8_replay.h" #include "pxl8_log.h" +#include "pxl8_mem.h" #include "pxl8_sys.h" #include @@ -42,8 +43,8 @@ struct pxl8_replay { static void pxl8_replay_chunk_free(pxl8_replay_chunk* chunk) { while (chunk) { pxl8_replay_chunk* next = chunk->next; - free(chunk->data); - free(chunk); + pxl8_free(chunk->data); + pxl8_free(chunk); chunk = next; } } @@ -52,7 +53,7 @@ static void pxl8_replay_keyframe_entry_free(pxl8_keyframe_entry* entry) { while (entry) { pxl8_keyframe_entry* next = entry->next; pxl8_replay_chunk_free(entry->input_deltas); - free(entry); + pxl8_free(entry); entry = next; } } @@ -64,7 +65,7 @@ pxl8_replay* pxl8_replay_create(const char* path, u32 keyframe_interval) { return NULL; } - pxl8_replay* r = calloc(1, sizeof(pxl8_replay)); + pxl8_replay* r = pxl8_calloc(1, sizeof(pxl8_replay)); if (!r) { fclose(f); return NULL; @@ -85,7 +86,7 @@ pxl8_replay* pxl8_replay_create(const char* path, u32 keyframe_interval) { } pxl8_replay* pxl8_replay_create_buffer(u32 keyframe_interval, u32 max_keyframes) { - pxl8_replay* r = calloc(1, sizeof(pxl8_replay)); + pxl8_replay* r = pxl8_calloc(1, sizeof(pxl8_replay)); if (!r) return NULL; r->recording = true; @@ -125,7 +126,7 @@ pxl8_replay* pxl8_replay_open(const char* path) { return NULL; } - pxl8_replay* r = calloc(1, sizeof(pxl8_replay)); + pxl8_replay* r = pxl8_calloc(1, sizeof(pxl8_replay)); if (!r) { fclose(f); return NULL; @@ -146,14 +147,14 @@ pxl8_replay* pxl8_replay_open(const char* path) { if (fread(size_bytes, 3, 1, f) != 1) break; u32 size = size_bytes[0] | (size_bytes[1] << 8) | (size_bytes[2] << 16); - u8* data = malloc(size); + u8* data = pxl8_malloc(size); if (!data || fread(data, size, 1, f) != 1) { - free(data); + pxl8_free(data); break; } if (chunk_type == PXL8_REPLAY_CHUNK_KEYFRAME) { - pxl8_keyframe_entry* entry = calloc(1, sizeof(pxl8_keyframe_entry)); + pxl8_keyframe_entry* entry = pxl8_calloc(1, sizeof(pxl8_keyframe_entry)); if (entry && size >= sizeof(pxl8_keyframe)) { memcpy(&entry->keyframe, data, sizeof(pxl8_keyframe)); entry->prev = r->current_keyframe; @@ -166,10 +167,10 @@ pxl8_replay* pxl8_replay_open(const char* path) { } r->keyframe_count++; } - free(data); + pxl8_free(data); } else if (chunk_type == PXL8_REPLAY_CHUNK_INPUT) { if (r->current_keyframe) { - pxl8_replay_chunk* chunk = calloc(1, sizeof(pxl8_replay_chunk)); + pxl8_replay_chunk* chunk = pxl8_calloc(1, sizeof(pxl8_replay_chunk)); if (chunk) { chunk->type = chunk_type; chunk->size = size; @@ -185,9 +186,9 @@ pxl8_replay* pxl8_replay_open(const char* path) { } } } - free(data); + pxl8_free(data); } else if (chunk_type == PXL8_REPLAY_CHUNK_AUDIO_EVENT) { - pxl8_replay_chunk* chunk = calloc(1, sizeof(pxl8_replay_chunk)); + pxl8_replay_chunk* chunk = pxl8_calloc(1, sizeof(pxl8_replay_chunk)); if (chunk) { chunk->type = chunk_type; chunk->size = size; @@ -202,9 +203,9 @@ pxl8_replay* pxl8_replay_open(const char* path) { r->audio_events_tail = chunk; } } - free(data); + pxl8_free(data); } else { - free(data); + pxl8_free(data); } } @@ -231,7 +232,7 @@ void pxl8_replay_destroy(pxl8_replay* r) { pxl8_replay_chunk_free(r->pending_inputs); pxl8_replay_chunk_free(r->audio_events); - free(r); + pxl8_free(r); } bool pxl8_replay_is_recording(pxl8_replay* r) { @@ -262,14 +263,14 @@ static void write_chunk(FILE* f, u8 type, const void* data, u32 size) { } static void add_chunk_to_buffer(pxl8_replay* r, u8 type, const void* data, u32 size) { - pxl8_replay_chunk* chunk = calloc(1, sizeof(pxl8_replay_chunk)); + pxl8_replay_chunk* chunk = pxl8_calloc(1, sizeof(pxl8_replay_chunk)); if (!chunk) return; chunk->type = type; chunk->size = size; - chunk->data = malloc(size); + chunk->data = pxl8_malloc(size); if (!chunk->data) { - free(chunk); + pxl8_free(chunk); return; } memcpy(chunk->data, data, size); @@ -327,7 +328,7 @@ void pxl8_replay_write_keyframe(pxl8_replay* r, u32 frame, f32 time, pxl8_rng* r write_chunk(r->file, PXL8_REPLAY_CHUNK_KEYFRAME, &kf, sizeof(kf)); fflush(r->file); } else { - pxl8_keyframe_entry* entry = calloc(1, sizeof(pxl8_keyframe_entry)); + pxl8_keyframe_entry* entry = pxl8_calloc(1, sizeof(pxl8_keyframe_entry)); if (!entry) return; entry->keyframe = kf; @@ -342,7 +343,7 @@ void pxl8_replay_write_keyframe(pxl8_replay* r, u32 frame, f32 time, pxl8_rng* r r->keyframes->prev = NULL; } pxl8_replay_chunk_free(oldest->input_deltas); - free(oldest); + pxl8_free(oldest); r->keyframe_count--; } @@ -446,14 +447,14 @@ void pxl8_replay_write_audio_event(pxl8_replay* r, u32 frame, u8 event_type, u8 if (r->file) { write_chunk(r->file, PXL8_REPLAY_CHUNK_AUDIO_EVENT, &evt, sizeof(evt)); } else { - pxl8_replay_chunk* chunk = calloc(1, sizeof(pxl8_replay_chunk)); + pxl8_replay_chunk* chunk = pxl8_calloc(1, sizeof(pxl8_replay_chunk)); if (!chunk) return; chunk->type = PXL8_REPLAY_CHUNK_AUDIO_EVENT; chunk->size = sizeof(evt); - chunk->data = malloc(sizeof(evt)); + chunk->data = pxl8_malloc(sizeof(evt)); if (!chunk->data) { - free(chunk); + pxl8_free(chunk); return; } memcpy(chunk->data, &evt, sizeof(evt)); diff --git a/src/core/pxl8_types.h b/src/core/pxl8_types.h index e5e1135..437ebce 100644 --- a/src/core/pxl8_types.h +++ b/src/core/pxl8_types.h @@ -23,6 +23,9 @@ typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; +typedef size_t usize; +typedef ptrdiff_t isize; + #if defined(__SIZEOF_INT128__) typedef __int128_t i128; typedef __uint128_t u128; diff --git a/src/gfx/pxl8_3d_camera.c b/src/gfx/pxl8_3d_camera.c index 0744493..fc5429f 100644 --- a/src/gfx/pxl8_3d_camera.c +++ b/src/gfx/pxl8_3d_camera.c @@ -1,4 +1,5 @@ #include "pxl8_3d_camera.h" +#include "pxl8_mem.h" #include #include @@ -28,7 +29,7 @@ struct pxl8_3d_camera { }; pxl8_3d_camera* pxl8_3d_camera_create(void) { - pxl8_3d_camera* cam = calloc(1, sizeof(pxl8_3d_camera)); + pxl8_3d_camera* cam = pxl8_calloc(1, sizeof(pxl8_3d_camera)); if (!cam) return NULL; cam->position = (pxl8_vec3){0, 0, 0}; @@ -46,7 +47,7 @@ pxl8_3d_camera* pxl8_3d_camera_create(void) { } void pxl8_3d_camera_destroy(pxl8_3d_camera* cam) { - free(cam); + pxl8_free(cam); } void pxl8_3d_camera_lookat(pxl8_3d_camera* cam, pxl8_vec3 eye, pxl8_vec3 target, pxl8_vec3 up) { diff --git a/src/gfx/pxl8_anim.c b/src/gfx/pxl8_anim.c index 9fbffc5..638848e 100644 --- a/src/gfx/pxl8_anim.c +++ b/src/gfx/pxl8_anim.c @@ -7,6 +7,7 @@ #include "pxl8_atlas.h" #include "pxl8_gfx.h" #include "pxl8_log.h" +#include "pxl8_mem.h" #define PXL8_ANIM_MAX_STATES 32 @@ -36,36 +37,36 @@ pxl8_anim* pxl8_anim_create(const u32* frame_ids, const u16* frame_durations, u1 return NULL; } - pxl8_anim* anim = (pxl8_anim*)calloc(1, sizeof(pxl8_anim)); + pxl8_anim* anim = (pxl8_anim*)pxl8_calloc(1, sizeof(pxl8_anim)); if (!anim) { pxl8_error("Failed to allocate animation"); return NULL; } - anim->frame_ids = (u32*)malloc(frame_count * sizeof(u32)); + anim->frame_ids = (u32*)pxl8_malloc(frame_count * sizeof(u32)); if (!anim->frame_ids) { pxl8_error("Failed to allocate frame IDs"); - free(anim); + pxl8_free(anim); return NULL; } memcpy(anim->frame_ids, frame_ids, frame_count * sizeof(u32)); if (frame_durations) { - anim->frame_durations = (u16*)malloc(frame_count * sizeof(u16)); + anim->frame_durations = (u16*)pxl8_malloc(frame_count * sizeof(u16)); if (!anim->frame_durations) { pxl8_error("Failed to allocate frame durations"); - free(anim->frame_ids); - free(anim); + pxl8_free(anim->frame_ids); + pxl8_free(anim); return NULL; } memcpy(anim->frame_durations, frame_durations, frame_count * sizeof(u16)); } else { - anim->frame_durations = (u16*)calloc(frame_count, sizeof(u16)); + anim->frame_durations = (u16*)pxl8_calloc(frame_count, sizeof(u16)); if (!anim->frame_durations) { pxl8_error("Failed to allocate frame durations"); - free(anim->frame_ids); - free(anim); + pxl8_free(anim->frame_ids); + pxl8_free(anim); return NULL; } for (u16 i = 0; i < frame_count; i++) { @@ -107,12 +108,12 @@ pxl8_anim* pxl8_anim_create_from_ase(pxl8_gfx* gfx, const char* path) { return NULL; } - u32* frame_ids = (u32*)malloc(ase_file.frame_count * sizeof(u32)); - u16* frame_durations = (u16*)malloc(ase_file.frame_count * sizeof(u16)); + u32* frame_ids = (u32*)pxl8_malloc(ase_file.frame_count * sizeof(u32)); + u16* frame_durations = (u16*)pxl8_malloc(ase_file.frame_count * sizeof(u16)); if (!frame_ids || !frame_durations) { pxl8_error("Failed to allocate frame arrays"); - free(frame_ids); - free(frame_durations); + pxl8_free(frame_ids); + pxl8_free(frame_durations); pxl8_ase_destroy(&ase_file); return NULL; } @@ -122,8 +123,8 @@ pxl8_anim* pxl8_anim_create_from_ase(pxl8_gfx* gfx, const char* path) { result = pxl8_gfx_create_texture(gfx, frame->pixels, frame->width, frame->height); if (result != PXL8_OK) { pxl8_error("Failed to create texture for frame %u", i); - free(frame_ids); - free(frame_durations); + pxl8_free(frame_ids); + pxl8_free(frame_durations); pxl8_ase_destroy(&ase_file); return NULL; } @@ -133,8 +134,8 @@ pxl8_anim* pxl8_anim_create_from_ase(pxl8_gfx* gfx, const char* path) { pxl8_anim* anim = pxl8_anim_create(frame_ids, frame_durations, ase_file.frame_count); - free(frame_ids); - free(frame_durations); + pxl8_free(frame_ids); + pxl8_free(frame_durations); pxl8_ase_destroy(&ase_file); return anim; @@ -145,15 +146,15 @@ void pxl8_anim_destroy(pxl8_anim* anim) { if (anim->state_machine) { for (u16 i = 0; i < anim->state_machine->state_count; i++) { - free(anim->state_machine->states[i].name); + pxl8_free(anim->state_machine->states[i].name); pxl8_anim_destroy(anim->state_machine->states[i].anim); } - free(anim->state_machine); + pxl8_free(anim->state_machine); } - free(anim->frame_ids); - free(anim->frame_durations); - free(anim); + pxl8_free(anim->frame_ids); + pxl8_free(anim->frame_durations); + pxl8_free(anim); } pxl8_result pxl8_anim_add_state(pxl8_anim* anim, const char* name, pxl8_anim* state_anim) { @@ -162,7 +163,7 @@ pxl8_result pxl8_anim_add_state(pxl8_anim* anim, const char* name, pxl8_anim* st } if (!anim->state_machine) { - anim->state_machine = (pxl8_anim_state_machine*)calloc(1, sizeof(pxl8_anim_state_machine)); + anim->state_machine = (pxl8_anim_state_machine*)pxl8_calloc(1, sizeof(pxl8_anim_state_machine)); if (!anim->state_machine) { return PXL8_ERROR_OUT_OF_MEMORY; } diff --git a/src/gfx/pxl8_atlas.c b/src/gfx/pxl8_atlas.c index 0f87389..910dba6 100644 --- a/src/gfx/pxl8_atlas.c +++ b/src/gfx/pxl8_atlas.c @@ -7,6 +7,7 @@ #include "pxl8_color.h" #include "pxl8_log.h" +#include "pxl8_mem.h" typedef struct pxl8_skyline_fit { bool found; @@ -105,7 +106,7 @@ static bool pxl8_skyline_add_rect(pxl8_skyline* skyline, pxl8_point pos, u32 w, if (skyline->count - nodes_to_remove + 1 > skyline->capacity) { u32 new_capacity = (skyline->count - nodes_to_remove + 1) * 2; - pxl8_skyline_node* new_nodes = (pxl8_skyline_node*)realloc( + pxl8_skyline_node* new_nodes = (pxl8_skyline_node*)pxl8_realloc( skyline->nodes, new_capacity * sizeof(pxl8_skyline_node) ); @@ -144,44 +145,44 @@ static void pxl8_skyline_compact(pxl8_skyline* skyline) { } pxl8_atlas* pxl8_atlas_create(u32 width, u32 height, pxl8_pixel_mode pixel_mode) { - pxl8_atlas* atlas = (pxl8_atlas*)calloc(1, sizeof(pxl8_atlas)); + pxl8_atlas* atlas = (pxl8_atlas*)pxl8_calloc(1, sizeof(pxl8_atlas)); if (!atlas) return NULL; atlas->height = height; atlas->width = width; i32 bytes_per_pixel = pxl8_bytes_per_pixel(pixel_mode); - atlas->pixels = (u8*)calloc(width * height, bytes_per_pixel); + atlas->pixels = (u8*)pxl8_calloc(width * height, bytes_per_pixel); if (!atlas->pixels) { - free(atlas); + pxl8_free(atlas); return NULL; } atlas->entry_capacity = PXL8_DEFAULT_ATLAS_ENTRY_CAPACITY; - atlas->entries = (pxl8_atlas_entry*)calloc(atlas->entry_capacity, sizeof(pxl8_atlas_entry)); + atlas->entries = (pxl8_atlas_entry*)pxl8_calloc(atlas->entry_capacity, sizeof(pxl8_atlas_entry)); if (!atlas->entries) { - free(atlas->pixels); - free(atlas); + pxl8_free(atlas->pixels); + pxl8_free(atlas); return NULL; } atlas->free_capacity = 16; - atlas->free_list = (u32*)calloc(atlas->free_capacity, sizeof(u32)); + atlas->free_list = (u32*)pxl8_calloc(atlas->free_capacity, sizeof(u32)); if (!atlas->free_list) { - free(atlas->entries); - free(atlas->pixels); - free(atlas); + pxl8_free(atlas->entries); + pxl8_free(atlas->pixels); + pxl8_free(atlas); return NULL; } atlas->skyline.capacity = 16; atlas->skyline.nodes = - (pxl8_skyline_node*)calloc(atlas->skyline.capacity, sizeof(pxl8_skyline_node)); + (pxl8_skyline_node*)pxl8_calloc(atlas->skyline.capacity, sizeof(pxl8_skyline_node)); if (!atlas->skyline.nodes) { - free(atlas->free_list); - free(atlas->entries); - free(atlas->pixels); - free(atlas); + pxl8_free(atlas->free_list); + pxl8_free(atlas->entries); + pxl8_free(atlas->pixels); + pxl8_free(atlas); return NULL; } @@ -194,12 +195,12 @@ pxl8_atlas* pxl8_atlas_create(u32 width, u32 height, pxl8_pixel_mode pixel_mode) void pxl8_atlas_destroy(pxl8_atlas* atlas) { if (!atlas) return; - free(atlas->entries); - free(atlas->free_list); - free(atlas->pixels); - free(atlas->pixels_tiled); - free(atlas->skyline.nodes); - free(atlas); + pxl8_free(atlas->entries); + pxl8_free(atlas->free_list); + pxl8_free(atlas->pixels); + pxl8_free(atlas->pixels_tiled); + pxl8_free(atlas->skyline.nodes); + pxl8_free(atlas); } void pxl8_atlas_clear(pxl8_atlas* atlas, u32 preserve_count) { @@ -232,13 +233,13 @@ bool pxl8_atlas_expand(pxl8_atlas* atlas, pxl8_pixel_mode pixel_mode) { u32 new_size = atlas->width * 2; u32 old_width = atlas->width; - u8* new_pixels = (u8*)calloc(new_size * new_size, bytes_per_pixel); + u8* new_pixels = (u8*)pxl8_calloc(new_size * new_size, bytes_per_pixel); if (!new_pixels) return false; pxl8_skyline new_skyline; - new_skyline.nodes = (pxl8_skyline_node*)calloc(16, sizeof(pxl8_skyline_node)); + new_skyline.nodes = (pxl8_skyline_node*)pxl8_calloc(16, sizeof(pxl8_skyline_node)); if (!new_skyline.nodes) { - free(new_pixels); + pxl8_free(new_pixels); return false; } @@ -258,8 +259,8 @@ bool pxl8_atlas_expand(pxl8_atlas* atlas, pxl8_pixel_mode pixel_mode) { ); if (!fit.found) { - free(new_skyline.nodes); - free(new_pixels); + pxl8_free(new_skyline.nodes); + pxl8_free(new_pixels); return false; } @@ -279,15 +280,15 @@ bool pxl8_atlas_expand(pxl8_atlas* atlas, pxl8_pixel_mode pixel_mode) { atlas->entries[i].y = fit.pos.y; if (!pxl8_skyline_add_rect(&new_skyline, fit.pos, atlas->entries[i].w, atlas->entries[i].h)) { - free(new_skyline.nodes); - free(new_pixels); + pxl8_free(new_skyline.nodes); + pxl8_free(new_pixels); return false; } pxl8_skyline_compact(&new_skyline); } - free(atlas->pixels); - free(atlas->skyline.nodes); + pxl8_free(atlas->pixels); + pxl8_free(atlas->skyline.nodes); atlas->pixels = new_pixels; atlas->skyline = new_skyline; @@ -326,7 +327,7 @@ u32 pxl8_atlas_add_texture( } else { if (atlas->entry_count >= atlas->entry_capacity) { u32 new_capacity = atlas->entry_capacity * 2; - pxl8_atlas_entry* new_entries = (pxl8_atlas_entry*)realloc( + pxl8_atlas_entry* new_entries = (pxl8_atlas_entry*)pxl8_realloc( atlas->entries, new_capacity * sizeof(pxl8_atlas_entry) ); @@ -365,7 +366,7 @@ u32 pxl8_atlas_add_texture( if (new_tiled_size > atlas->tiled_capacity) { u32 new_cap = atlas->tiled_capacity ? atlas->tiled_capacity * 2 : 4096; while (new_cap < new_tiled_size) new_cap *= 2; - u8* new_tiled = (u8*)realloc(atlas->pixels_tiled, new_cap); + u8* new_tiled = (u8*)pxl8_realloc(atlas->pixels_tiled, new_cap); if (!new_tiled) { entry->active = false; return UINT32_MAX; diff --git a/src/gfx/pxl8_cpu.c b/src/gfx/pxl8_cpu.c index 31d177b..a43d494 100644 --- a/src/gfx/pxl8_cpu.c +++ b/src/gfx/pxl8_cpu.c @@ -1,4 +1,5 @@ #include "pxl8_cpu.h" +#include "pxl8_mem.h" #include #include @@ -173,7 +174,7 @@ static inline void clip_line_2d(i32* x0, i32* y0, i32* x1, i32* y1, i32 w, i32 h } pxl8_cpu_backend* pxl8_cpu_create(u32 width, u32 height) { - pxl8_cpu_backend* cpu = calloc(1, sizeof(pxl8_cpu_backend)); + pxl8_cpu_backend* cpu = pxl8_calloc(1, sizeof(pxl8_cpu_backend)); if (!cpu) return NULL; pxl8_cpu_render_target_desc desc = { @@ -184,7 +185,7 @@ pxl8_cpu_backend* pxl8_cpu_create(u32 width, u32 height) { }; pxl8_cpu_render_target* base_target = pxl8_cpu_create_render_target(&desc); if (!base_target) { - free(cpu); + pxl8_free(cpu); return NULL; } @@ -193,10 +194,10 @@ pxl8_cpu_backend* pxl8_cpu_create(u32 width, u32 height) { cpu->current_target = base_target; cpu->output_size = width * height; - cpu->output = calloc(cpu->output_size, sizeof(u32)); + cpu->output = pxl8_calloc(cpu->output_size, sizeof(u32)); if (!cpu->output) { pxl8_cpu_destroy_render_target(base_target); - free(cpu); + pxl8_free(cpu); return NULL; } @@ -208,8 +209,8 @@ void pxl8_cpu_destroy(pxl8_cpu_backend* cpu) { for (u32 i = 0; i < cpu->target_stack_depth; i++) { pxl8_cpu_destroy_render_target(cpu->target_stack[i]); } - free(cpu->output); - free(cpu); + pxl8_free(cpu->output); + pxl8_free(cpu); } void pxl8_cpu_begin_frame(pxl8_cpu_backend* cpu, const pxl8_3d_frame* frame) { @@ -1194,33 +1195,33 @@ u32 pxl8_cpu_get_width(const pxl8_cpu_backend* cpu) { pxl8_cpu_render_target* pxl8_cpu_create_render_target(const pxl8_cpu_render_target_desc* desc) { if (!desc) return NULL; - pxl8_cpu_render_target* target = calloc(1, sizeof(pxl8_cpu_render_target)); + pxl8_cpu_render_target* target = pxl8_calloc(1, sizeof(pxl8_cpu_render_target)); if (!target) return NULL; u32 size = desc->width * desc->height; target->width = desc->width; target->height = desc->height; - target->framebuffer = calloc(size, sizeof(u8)); + target->framebuffer = pxl8_calloc(size, sizeof(u8)); if (!target->framebuffer) { - free(target); + pxl8_free(target); return NULL; } if (desc->with_depth) { - target->zbuffer = calloc(size, sizeof(u16)); + target->zbuffer = pxl8_calloc(size, sizeof(u16)); if (!target->zbuffer) { - free(target->framebuffer); - free(target); + pxl8_free(target->framebuffer); + pxl8_free(target); return NULL; } } if (desc->with_lighting) { - target->light_accum = calloc(size, sizeof(u32)); + target->light_accum = pxl8_calloc(size, sizeof(u32)); if (!target->light_accum) { - free(target->zbuffer); - free(target->framebuffer); - free(target); + pxl8_free(target->zbuffer); + pxl8_free(target->framebuffer); + pxl8_free(target); return NULL; } } @@ -1230,10 +1231,10 @@ pxl8_cpu_render_target* pxl8_cpu_create_render_target(const pxl8_cpu_render_targ void pxl8_cpu_destroy_render_target(pxl8_cpu_render_target* target) { if (!target) return; - free(target->light_accum); - free(target->zbuffer); - free(target->framebuffer); - free(target); + pxl8_free(target->light_accum); + pxl8_free(target->zbuffer); + pxl8_free(target->framebuffer); + pxl8_free(target); } pxl8_cpu_render_target* pxl8_cpu_get_target(pxl8_cpu_backend* cpu) { diff --git a/src/gfx/pxl8_font.c b/src/gfx/pxl8_font.c index 445ec67..3d8ad7b 100644 --- a/src/gfx/pxl8_font.c +++ b/src/gfx/pxl8_font.c @@ -1,4 +1,5 @@ #include "pxl8_font.h" +#include "pxl8_mem.h" #include #include @@ -15,7 +16,7 @@ pxl8_result pxl8_font_create_atlas(const pxl8_font* font, u8** atlas_data, i32* *atlas_height = rows_needed * font->default_height; i32 atlas_size = (*atlas_width) * (*atlas_height); - *atlas_data = (u8*)malloc(atlas_size); + *atlas_data = (u8*)pxl8_malloc(atlas_size); if (!*atlas_data) { return PXL8_ERROR_OUT_OF_MEMORY; } diff --git a/src/gfx/pxl8_gfx.c b/src/gfx/pxl8_gfx.c index f243062..00e2826 100644 --- a/src/gfx/pxl8_gfx.c +++ b/src/gfx/pxl8_gfx.c @@ -14,6 +14,7 @@ #include "pxl8_log.h" #include "pxl8_macros.h" #include "pxl8_math.h" +#include "pxl8_mem.h" #include "pxl8_sys.h" #include "pxl8_types.h" @@ -122,7 +123,7 @@ pxl8_gfx* pxl8_gfx_create( pxl8_pixel_mode mode, pxl8_resolution resolution ) { - pxl8_gfx* gfx = (pxl8_gfx*)calloc(1, sizeof(pxl8_gfx)); + pxl8_gfx* gfx = (pxl8_gfx*)pxl8_calloc(1, sizeof(pxl8_gfx)); if (!gfx) { pxl8_error("Failed to allocate graphics context"); return NULL; @@ -138,7 +139,7 @@ pxl8_gfx* pxl8_gfx_create( if (!gfx->platform_data) { pxl8_error("Platform data cannot be NULL"); - free(gfx); + pxl8_free(gfx); return NULL; } @@ -157,7 +158,7 @@ pxl8_gfx* pxl8_gfx_create( gfx->framebuffer = pxl8_cpu_get_framebuffer(gfx->backend.cpu); if (mode != PXL8_PIXEL_HICOLOR) { - gfx->colormap = calloc(1, sizeof(pxl8_colormap)); + gfx->colormap = pxl8_calloc(1, sizeof(pxl8_colormap)); if (gfx->colormap) { pxl8_cpu_set_colormap(gfx->backend.cpu, gfx->colormap); } @@ -180,12 +181,12 @@ void pxl8_gfx_destroy(pxl8_gfx* gfx) { if (gfx->backend.type == PXL8_GFX_BACKEND_CPU) { pxl8_cpu_destroy(gfx->backend.cpu); } - free(gfx->colormap); + pxl8_free(gfx->colormap); pxl8_palette_cube_destroy(gfx->palette_cube); pxl8_palette_destroy(gfx->palette); - free(gfx->sprite_cache); + pxl8_free(gfx->sprite_cache); - free(gfx); + pxl8_free(gfx); } static pxl8_result pxl8_gfx_ensure_atlas(pxl8_gfx* gfx) { @@ -226,7 +227,7 @@ pxl8_result pxl8_gfx_load_sprite(pxl8_gfx* gfx, const char* path) { if (!gfx->sprite_cache) { gfx->sprite_cache_capacity = PXL8_DEFAULT_SPRITE_CACHE_CAPACITY; - gfx->sprite_cache = (pxl8_sprite_cache_entry*)calloc( + gfx->sprite_cache = (pxl8_sprite_cache_entry*)pxl8_calloc( gfx->sprite_cache_capacity, sizeof(pxl8_sprite_cache_entry) ); if (!gfx->sprite_cache) return PXL8_ERROR_OUT_OF_MEMORY; @@ -271,7 +272,7 @@ pxl8_result pxl8_gfx_load_sprite(pxl8_gfx* gfx, const char* path) { if (gfx->sprite_cache_count >= gfx->sprite_cache_capacity) { u32 new_capacity = gfx->sprite_cache_capacity * 2; - pxl8_sprite_cache_entry* new_cache = (pxl8_sprite_cache_entry*)realloc( + pxl8_sprite_cache_entry* new_cache = (pxl8_sprite_cache_entry*)pxl8_realloc( gfx->sprite_cache, new_capacity * sizeof(pxl8_sprite_cache_entry) ); diff --git a/src/gfx/pxl8_glows.c b/src/gfx/pxl8_glows.c index 0fba4b4..018fea5 100644 --- a/src/gfx/pxl8_glows.c +++ b/src/gfx/pxl8_glows.c @@ -1,6 +1,7 @@ #include "pxl8_glows.h" #include "pxl8_gfx.h" +#include "pxl8_mem.h" #include @@ -11,12 +12,12 @@ struct pxl8_glows { }; pxl8_glows* pxl8_glows_create(u32 capacity) { - pxl8_glows* glows = calloc(1, sizeof(pxl8_glows)); + pxl8_glows* glows = pxl8_calloc(1, sizeof(pxl8_glows)); if (!glows) return NULL; - glows->data = calloc(capacity, sizeof(pxl8_glow)); + glows->data = pxl8_calloc(capacity, sizeof(pxl8_glow)); if (!glows->data) { - free(glows); + pxl8_free(glows); return NULL; } @@ -28,8 +29,8 @@ pxl8_glows* pxl8_glows_create(u32 capacity) { void pxl8_glows_destroy(pxl8_glows* glows) { if (!glows) return; - free(glows->data); - free(glows); + pxl8_free(glows->data); + pxl8_free(glows); } void pxl8_glows_add(pxl8_glows* glows, i16 x, i16 y, u8 radius, u16 intensity, u8 color, u8 shape) { diff --git a/src/gfx/pxl8_lightmap.c b/src/gfx/pxl8_lightmap.c index 0c29521..4a4ccf8 100644 --- a/src/gfx/pxl8_lightmap.c +++ b/src/gfx/pxl8_lightmap.c @@ -1,18 +1,19 @@ #include "pxl8_lightmap.h" +#include "pxl8_mem.h" #include #include pxl8_lightmap* pxl8_lightmap_create(u32 width, u32 height, u32 scale) { - pxl8_lightmap* lm = calloc(1, sizeof(pxl8_lightmap)); + pxl8_lightmap* lm = pxl8_calloc(1, sizeof(pxl8_lightmap)); if (!lm) return NULL; lm->width = width; lm->height = height; lm->scale = scale; - lm->data = calloc(width * height * 3, sizeof(u8)); + lm->data = pxl8_calloc(width * height * 3, sizeof(u8)); if (!lm->data) { - free(lm); + pxl8_free(lm); return NULL; } @@ -22,8 +23,8 @@ pxl8_lightmap* pxl8_lightmap_create(u32 width, u32 height, u32 scale) { void pxl8_lightmap_destroy(pxl8_lightmap* lm) { if (!lm) return; - free(lm->data); - free(lm); + pxl8_free(lm->data); + pxl8_free(lm); } void pxl8_lightmap_clear(pxl8_lightmap* lm, u8 r, u8 g, u8 b) { diff --git a/src/gfx/pxl8_lights.c b/src/gfx/pxl8_lights.c index c3280f1..429ef14 100644 --- a/src/gfx/pxl8_lights.c +++ b/src/gfx/pxl8_lights.c @@ -1,4 +1,5 @@ #include "pxl8_lights.h" +#include "pxl8_mem.h" #include @@ -11,12 +12,12 @@ struct pxl8_lights { pxl8_lights* pxl8_lights_create(u32 capacity) { if (capacity > PXL8_LIGHTS_MAX) capacity = PXL8_LIGHTS_MAX; - pxl8_lights* lights = calloc(1, sizeof(pxl8_lights)); + pxl8_lights* lights = pxl8_calloc(1, sizeof(pxl8_lights)); if (!lights) return NULL; - lights->data = calloc(capacity, sizeof(pxl8_light)); + lights->data = pxl8_calloc(capacity, sizeof(pxl8_light)); if (!lights->data) { - free(lights); + pxl8_free(lights); return NULL; } @@ -28,8 +29,8 @@ pxl8_lights* pxl8_lights_create(u32 capacity) { void pxl8_lights_destroy(pxl8_lights* lights) { if (!lights) return; - free(lights->data); - free(lights); + pxl8_free(lights->data); + pxl8_free(lights); } void pxl8_lights_add(pxl8_lights* lights, f32 x, f32 y, f32 z, u8 r, u8 g, u8 b, u8 intensity, f32 radius) { diff --git a/src/gfx/pxl8_mesh.c b/src/gfx/pxl8_mesh.c index 6f8da2c..05698ec 100644 --- a/src/gfx/pxl8_mesh.c +++ b/src/gfx/pxl8_mesh.c @@ -1,3 +1,4 @@ +#include "pxl8_mem.h" #include "pxl8_mesh.h" #include #include @@ -6,16 +7,16 @@ pxl8_mesh* pxl8_mesh_create(u32 vertex_capacity, u32 index_capacity) { if (vertex_capacity > PXL8_MESH_MAX_VERTICES) vertex_capacity = PXL8_MESH_MAX_VERTICES; if (index_capacity > PXL8_MESH_MAX_INDICES) index_capacity = PXL8_MESH_MAX_INDICES; - pxl8_mesh* mesh = calloc(1, sizeof(pxl8_mesh)); + pxl8_mesh* mesh = pxl8_calloc(1, sizeof(pxl8_mesh)); if (!mesh) return NULL; - mesh->vertices = calloc(vertex_capacity, sizeof(pxl8_vertex)); - mesh->indices = calloc(index_capacity, sizeof(u16)); + mesh->vertices = pxl8_calloc(vertex_capacity, sizeof(pxl8_vertex)); + mesh->indices = pxl8_calloc(index_capacity, sizeof(u16)); if (!mesh->vertices || !mesh->indices) { - free(mesh->vertices); - free(mesh->indices); - free(mesh); + pxl8_free(mesh->vertices); + pxl8_free(mesh->indices); + pxl8_free(mesh); return NULL; } @@ -29,9 +30,9 @@ pxl8_mesh* pxl8_mesh_create(u32 vertex_capacity, u32 index_capacity) { void pxl8_mesh_destroy(pxl8_mesh* mesh) { if (!mesh) return; - free(mesh->vertices); - free(mesh->indices); - free(mesh); + pxl8_free(mesh->vertices); + pxl8_free(mesh->indices); + pxl8_free(mesh); } void pxl8_mesh_clear(pxl8_mesh* mesh) { diff --git a/src/gfx/pxl8_palette.c b/src/gfx/pxl8_palette.c index 93b4eee..6e32aef 100644 --- a/src/gfx/pxl8_palette.c +++ b/src/gfx/pxl8_palette.c @@ -7,6 +7,7 @@ #include "pxl8_color.h" #include "pxl8_colormap.h" #include "pxl8_log.h" +#include "pxl8_mem.h" #define PXL8_PALETTE_HASH_SIZE 512 @@ -207,7 +208,7 @@ static void update_cycle_colors(pxl8_palette* pal, u8 slot) { } pxl8_palette* pxl8_palette_create(void) { - pxl8_palette* pal = calloc(1, sizeof(pxl8_palette)); + pxl8_palette* pal = pxl8_calloc(1, sizeof(pxl8_palette)); if (!pal) return NULL; pal->colors[0] = 0x00000000; @@ -228,7 +229,7 @@ pxl8_palette* pxl8_palette_create(void) { } void pxl8_palette_destroy(pxl8_palette* pal) { - free(pal); + pxl8_free(pal); } pxl8_result pxl8_palette_load_ase(pxl8_palette* pal, const char* path) { @@ -517,14 +518,14 @@ static u8 find_closest_stable(const pxl8_palette* pal, u8 r, u8 g, u8 b) { } pxl8_palette_cube* pxl8_palette_cube_create(const pxl8_palette* pal) { - pxl8_palette_cube* cube = calloc(1, sizeof(pxl8_palette_cube)); + pxl8_palette_cube* cube = pxl8_calloc(1, sizeof(pxl8_palette_cube)); if (!cube) return NULL; pxl8_palette_cube_rebuild(cube, pal); return cube; } void pxl8_palette_cube_destroy(pxl8_palette_cube* cube) { - free(cube); + pxl8_free(cube); } void pxl8_palette_cube_rebuild(pxl8_palette_cube* cube, const pxl8_palette* pal) { diff --git a/src/gfx/pxl8_particles.c b/src/gfx/pxl8_particles.c index deb2d83..5448625 100644 --- a/src/gfx/pxl8_particles.c +++ b/src/gfx/pxl8_particles.c @@ -3,6 +3,7 @@ #include #include "pxl8_gfx.h" +#include "pxl8_mem.h" #include "pxl8_gfx2d.h" #include "pxl8_palette.h" #include "pxl8_rng.h" @@ -37,12 +38,12 @@ struct pxl8_particles { }; pxl8_particles* pxl8_particles_create(u32 max_count, pxl8_rng* rng) { - pxl8_particles* ps = calloc(1, sizeof(pxl8_particles)); + pxl8_particles* ps = pxl8_calloc(1, sizeof(pxl8_particles)); if (!ps) return NULL; - ps->particles = calloc(max_count, sizeof(pxl8_particle)); + ps->particles = pxl8_calloc(max_count, sizeof(pxl8_particle)); if (!ps->particles) { - free(ps); + pxl8_free(ps); return NULL; } @@ -61,8 +62,8 @@ pxl8_particles* pxl8_particles_create(u32 max_count, pxl8_rng* rng) { void pxl8_particles_destroy(pxl8_particles* ps) { if (!ps) return; - free(ps->particles); - free(ps); + pxl8_free(ps->particles); + pxl8_free(ps); } void pxl8_particles_clear(pxl8_particles* ps) { diff --git a/src/gfx/pxl8_tilemap.c b/src/gfx/pxl8_tilemap.c index ca129e9..263b65c 100644 --- a/src/gfx/pxl8_tilemap.c +++ b/src/gfx/pxl8_tilemap.c @@ -6,6 +6,7 @@ #include "pxl8_ase.h" #include "pxl8_log.h" #include "pxl8_macros.h" +#include "pxl8_mem.h" #include "pxl8_tilesheet.h" struct pxl8_tilesheet { @@ -58,7 +59,7 @@ static pxl8_tile_chunk* pxl8_get_or_create_chunk(pxl8_tilemap_layer* layer, u32 if (idx >= layer->chunks_wide * layer->chunks_high) return NULL; if (!layer->chunks[idx]) { - layer->chunks[idx] = calloc(1, sizeof(pxl8_tile_chunk)); + layer->chunks[idx] = pxl8_calloc(1, sizeof(pxl8_tile_chunk)); if (!layer->chunks[idx]) return NULL; layer->chunks[idx]->chunk_x = chunk_x; @@ -75,7 +76,7 @@ pxl8_tilemap* pxl8_tilemap_create(u32 width, u32 height, u32 tile_size) { return NULL; } - pxl8_tilemap* tilemap = calloc(1, sizeof(pxl8_tilemap)); + pxl8_tilemap* tilemap = pxl8_calloc(1, sizeof(pxl8_tilemap)); if (!tilemap) return NULL; tilemap->width = width; @@ -85,7 +86,7 @@ pxl8_tilemap* pxl8_tilemap_create(u32 width, u32 height, u32 tile_size) { tilemap->tilesheet = pxl8_tilesheet_create(tilemap->tile_size); if (!tilemap->tilesheet) { - free(tilemap); + pxl8_free(tilemap); return NULL; } @@ -103,13 +104,13 @@ pxl8_tilemap* pxl8_tilemap_create(u32 width, u32 height, u32 tile_size) { layer->visible = (i == 0); layer->opacity = 255; - layer->chunks = calloc(layer->chunk_count, sizeof(pxl8_tile_chunk*)); + layer->chunks = pxl8_calloc(layer->chunk_count, sizeof(pxl8_tile_chunk*)); if (!layer->chunks) { for (u32 j = 0; j < i; j++) { - free(tilemap->layers[j].chunks); + pxl8_free(tilemap->layers[j].chunks); } if (tilemap->tilesheet) pxl8_tilesheet_destroy(tilemap->tilesheet); - free(tilemap); + pxl8_free(tilemap); return NULL; } } @@ -125,17 +126,17 @@ void pxl8_tilemap_destroy(pxl8_tilemap* tilemap) { if (layer->chunks) { for (u32 j = 0; j < layer->chunk_count; j++) { if (layer->chunks[j]) { - free(layer->chunks[j]); + pxl8_free(layer->chunks[j]); } } - free(layer->chunks); + pxl8_free(layer->chunks); } } if (tilemap->tilesheet) pxl8_tilesheet_unref(tilemap->tilesheet); - if (tilemap->tile_user_data) free(tilemap->tile_user_data); + if (tilemap->tile_user_data) pxl8_free(tilemap->tile_user_data); - free(tilemap); + pxl8_free(tilemap); } u32 pxl8_tilemap_get_width(const pxl8_tilemap* tilemap) { @@ -155,7 +156,7 @@ void pxl8_tilemap_set_tile_user_data(pxl8_tilemap* tilemap, u16 tile_id, void* u if (tile_id >= tilemap->tile_user_data_capacity) { u32 new_capacity = tile_id + 64; - void** new_data = realloc(tilemap->tile_user_data, new_capacity * sizeof(void*)); + void** new_data = pxl8_realloc(tilemap->tile_user_data, new_capacity * sizeof(void*)); if (!new_data) return; for (u32 i = tilemap->tile_user_data_capacity; i < new_capacity; i++) { @@ -478,7 +479,7 @@ void pxl8_tilemap_compress(pxl8_tilemap* tilemap) { } if (!has_tiles) { - free(chunk); + pxl8_free(chunk); layer->chunks[j] = NULL; layer->allocated_chunks--; } else { @@ -535,8 +536,8 @@ pxl8_result pxl8_tilemap_load_ase(pxl8_tilemap* tilemap, const char* filepath, u u32 tilesheet_width = tiles_per_row * tilemap->tile_size; u32 tilesheet_height = tilesheet_rows * tilemap->tile_size; - if (tilemap->tilesheet->data) free(tilemap->tilesheet->data); - tilemap->tilesheet->data = calloc(tilesheet_width * tilesheet_height, 1); + if (tilemap->tilesheet->data) pxl8_free(tilemap->tilesheet->data); + tilemap->tilesheet->data = pxl8_calloc(tilesheet_width * tilesheet_height, 1); if (!tilemap->tilesheet->data) { pxl8_ase_destroy(&ase_file); return PXL8_ERROR_OUT_OF_MEMORY; @@ -548,8 +549,8 @@ pxl8_result pxl8_tilemap_load_ase(pxl8_tilemap* tilemap, const char* filepath, u tilemap->tilesheet->total_tiles = tileset->tile_count; tilemap->tilesheet->pixel_mode = PXL8_PIXEL_INDEXED; - if (tilemap->tilesheet->tile_valid) free(tilemap->tilesheet->tile_valid); - tilemap->tilesheet->tile_valid = calloc(tileset->tile_count + 1, sizeof(bool)); + if (tilemap->tilesheet->tile_valid) pxl8_free(tilemap->tilesheet->tile_valid); + tilemap->tilesheet->tile_valid = pxl8_calloc(tileset->tile_count + 1, sizeof(bool)); for (u32 i = 0; i < tileset->tile_count; i++) { u32 sheet_row = i / tiles_per_row; diff --git a/src/gfx/pxl8_tilesheet.c b/src/gfx/pxl8_tilesheet.c index 3f8dd39..9f41cd3 100644 --- a/src/gfx/pxl8_tilesheet.c +++ b/src/gfx/pxl8_tilesheet.c @@ -7,6 +7,7 @@ #include "pxl8_color.h" #include "pxl8_gfx.h" #include "pxl8_log.h" +#include "pxl8_mem.h" #include "pxl8_tilemap.h" struct pxl8_tilesheet { @@ -32,7 +33,7 @@ struct pxl8_tilesheet { }; pxl8_tilesheet* pxl8_tilesheet_create(u32 tile_size) { - pxl8_tilesheet* tilesheet = calloc(1, sizeof(pxl8_tilesheet)); + pxl8_tilesheet* tilesheet = pxl8_calloc(1, sizeof(pxl8_tilesheet)); if (!tilesheet) return NULL; tilesheet->tile_size = tile_size; @@ -45,37 +46,37 @@ void pxl8_tilesheet_destroy(pxl8_tilesheet* tilesheet) { if (!tilesheet) return; if (tilesheet->data) { - free(tilesheet->data); + pxl8_free(tilesheet->data); } if (tilesheet->tile_valid) { - free(tilesheet->tile_valid); + pxl8_free(tilesheet->tile_valid); } if (tilesheet->animations) { for (u32 i = 0; i < tilesheet->animation_count; i++) { if (tilesheet->animations[i].frames) { - free(tilesheet->animations[i].frames); + pxl8_free(tilesheet->animations[i].frames); } } - free(tilesheet->animations); + pxl8_free(tilesheet->animations); } if (tilesheet->properties) { - free(tilesheet->properties); + pxl8_free(tilesheet->properties); } if (tilesheet->autotile_rules) { for (u32 i = 0; i <= tilesheet->total_tiles; i++) { if (tilesheet->autotile_rules[i]) { - free(tilesheet->autotile_rules[i]); + pxl8_free(tilesheet->autotile_rules[i]); } } - free(tilesheet->autotile_rules); - free(tilesheet->autotile_rule_counts); + pxl8_free(tilesheet->autotile_rules); + pxl8_free(tilesheet->autotile_rule_counts); } - free(tilesheet); + pxl8_free(tilesheet); } pxl8_result pxl8_tilesheet_load(pxl8_tilesheet* tilesheet, const char* filepath, pxl8_gfx* gfx) { @@ -89,7 +90,7 @@ pxl8_result pxl8_tilesheet_load(pxl8_tilesheet* tilesheet, const char* filepath, } if (tilesheet->data) { - free(tilesheet->data); + pxl8_free(tilesheet->data); } u32 width = ase_file.header.width; @@ -111,8 +112,8 @@ pxl8_result pxl8_tilesheet_load(pxl8_tilesheet* tilesheet, const char* filepath, u16 ase_depth = ase_file.header.color_depth; bool gfx_hicolor = (tilesheet->pixel_mode == PXL8_PIXEL_HICOLOR); - size_t data_size = pixel_count * pxl8_bytes_per_pixel(tilesheet->pixel_mode); - tilesheet->data = malloc(data_size); + usize data_size = pixel_count * pxl8_bytes_per_pixel(tilesheet->pixel_mode); + tilesheet->data = pxl8_malloc(data_size); if (!tilesheet->data) { pxl8_ase_destroy(&ase_file); return PXL8_ERROR_OUT_OF_MEMORY; @@ -138,9 +139,9 @@ pxl8_result pxl8_tilesheet_load(pxl8_tilesheet* tilesheet, const char* filepath, } else if (ase_depth == 8 && gfx_hicolor) { pxl8_warn("Indexed ASE with hicolor gfx - storing as indexed"); tilesheet->pixel_mode = PXL8_PIXEL_INDEXED; - u8* new_data = realloc(tilesheet->data, pixel_count); + u8* new_data = pxl8_realloc(tilesheet->data, pixel_count); if (!new_data) { - free(tilesheet->data); + pxl8_free(tilesheet->data); tilesheet->data = NULL; pxl8_ase_destroy(&ase_file); return PXL8_ERROR_OUT_OF_MEMORY; @@ -149,16 +150,16 @@ pxl8_result pxl8_tilesheet_load(pxl8_tilesheet* tilesheet, const char* filepath, memcpy(tilesheet->data, src, pixel_count); } else { pxl8_error("Unsupported ASE color depth %d for gfx mode", ase_depth); - free(tilesheet->data); + pxl8_free(tilesheet->data); tilesheet->data = NULL; pxl8_ase_destroy(&ase_file); return PXL8_ERROR_INVALID_ARGUMENT; } } - tilesheet->tile_valid = calloc(tilesheet->total_tiles + 1, sizeof(bool)); + tilesheet->tile_valid = pxl8_calloc(tilesheet->total_tiles + 1, sizeof(bool)); if (!tilesheet->tile_valid) { - free(tilesheet->data); + pxl8_free(tilesheet->data); tilesheet->data = NULL; pxl8_ase_destroy(&ase_file); return PXL8_ERROR_OUT_OF_MEMORY; @@ -259,14 +260,14 @@ pxl8_result pxl8_tilesheet_add_animation(pxl8_tilesheet* tilesheet, u16 base_til if (base_tile_id == 0 || base_tile_id > tilesheet->total_tiles) return PXL8_ERROR_INVALID_ARGUMENT; if (!tilesheet->animations) { - tilesheet->animations = calloc(tilesheet->total_tiles + 1, sizeof(pxl8_tile_animation)); + tilesheet->animations = pxl8_calloc(tilesheet->total_tiles + 1, sizeof(pxl8_tile_animation)); if (!tilesheet->animations) return PXL8_ERROR_OUT_OF_MEMORY; } pxl8_tile_animation* anim = &tilesheet->animations[base_tile_id]; - if (anim->frames) free(anim->frames); + if (anim->frames) pxl8_free(anim->frames); - anim->frames = malloc(frame_count * sizeof(u16)); + anim->frames = pxl8_malloc(frame_count * sizeof(u16)); if (!anim->frames) return PXL8_ERROR_OUT_OF_MEMORY; memcpy(anim->frames, frames, frame_count * sizeof(u16)); @@ -340,7 +341,7 @@ void pxl8_tilesheet_set_tile_property(pxl8_tilesheet* tilesheet, u16 tile_id, if (!tilesheet || !props || tile_id == 0 || tile_id > tilesheet->total_tiles) return; if (!tilesheet->properties) { - tilesheet->properties = calloc(tilesheet->total_tiles + 1, sizeof(pxl8_tile_properties)); + tilesheet->properties = pxl8_calloc(tilesheet->total_tiles + 1, sizeof(pxl8_tile_properties)); if (!tilesheet->properties) return; } @@ -365,15 +366,15 @@ pxl8_result pxl8_tilesheet_add_autotile_rule(pxl8_tilesheet* tilesheet, u16 base } if (!tilesheet->autotile_rules) { - tilesheet->autotile_rules = calloc(tilesheet->total_tiles + 1, sizeof(pxl8_autotile_rule*)); - tilesheet->autotile_rule_counts = calloc(tilesheet->total_tiles + 1, sizeof(u32)); + tilesheet->autotile_rules = pxl8_calloc(tilesheet->total_tiles + 1, sizeof(pxl8_autotile_rule*)); + tilesheet->autotile_rule_counts = pxl8_calloc(tilesheet->total_tiles + 1, sizeof(u32)); if (!tilesheet->autotile_rules || !tilesheet->autotile_rule_counts) { return PXL8_ERROR_OUT_OF_MEMORY; } } u32 count = tilesheet->autotile_rule_counts[base_tile_id]; - pxl8_autotile_rule* new_rules = realloc(tilesheet->autotile_rules[base_tile_id], + pxl8_autotile_rule* new_rules = pxl8_realloc(tilesheet->autotile_rules[base_tile_id], (count + 1) * sizeof(pxl8_autotile_rule)); if (!new_rules) return PXL8_ERROR_OUT_OF_MEMORY; diff --git a/src/gfx/pxl8_transition.c b/src/gfx/pxl8_transition.c index f19001f..ba76e1d 100644 --- a/src/gfx/pxl8_transition.c +++ b/src/gfx/pxl8_transition.c @@ -6,6 +6,7 @@ #include "pxl8_gfx.h" #include "pxl8_log.h" #include "pxl8_math.h" +#include "pxl8_mem.h" pxl8_transition* pxl8_transition_create(pxl8_transition_type type, f32 duration) { if (duration <= 0.0f) { @@ -13,7 +14,7 @@ pxl8_transition* pxl8_transition_create(pxl8_transition_type type, f32 duration) return NULL; } - pxl8_transition* transition = (pxl8_transition*)calloc(1, sizeof(pxl8_transition)); + pxl8_transition* transition = (pxl8_transition*)pxl8_calloc(1, sizeof(pxl8_transition)); if (!transition) { pxl8_error("Failed to allocate transition"); return NULL; @@ -33,7 +34,7 @@ pxl8_transition* pxl8_transition_create(pxl8_transition_type type, f32 duration) void pxl8_transition_destroy(pxl8_transition* transition) { if (!transition) return; - free(transition); + pxl8_free(transition); } f32 pxl8_transition_get_progress(const pxl8_transition* transition) { diff --git a/src/gui/pxl8_gui.c b/src/gui/pxl8_gui.c index 72fdc29..f81a910 100644 --- a/src/gui/pxl8_gui.c +++ b/src/gui/pxl8_gui.c @@ -4,9 +4,10 @@ #include #include "pxl8_gfx.h" +#include "pxl8_mem.h" pxl8_gui_state* pxl8_gui_state_create(void) { - pxl8_gui_state* state = (pxl8_gui_state*)malloc(sizeof(pxl8_gui_state)); + pxl8_gui_state* state = (pxl8_gui_state*)pxl8_malloc(sizeof(pxl8_gui_state)); if (!state) return NULL; memset(state, 0, sizeof(pxl8_gui_state)); @@ -15,7 +16,7 @@ pxl8_gui_state* pxl8_gui_state_create(void) { void pxl8_gui_state_destroy(pxl8_gui_state* state) { if (!state) return; - free(state); + pxl8_free(state); } void pxl8_gui_begin_frame(pxl8_gui_state* state, pxl8_gfx* gfx) { diff --git a/src/hal/pxl8_sdl3.c b/src/hal/pxl8_hal_sdl3.c similarity index 99% rename from src/hal/pxl8_sdl3.c rename to src/hal/pxl8_hal_sdl3.c index 3f2f909..66c4f0b 100644 --- a/src/hal/pxl8_sdl3.c +++ b/src/hal/pxl8_hal_sdl3.c @@ -1,4 +1,4 @@ -#include "pxl8_sdl3.h" +#include "pxl8_hal.h" #define SDL_MAIN_USE_CALLBACKS #include @@ -8,13 +8,15 @@ #include "pxl8_log.h" #include "pxl8_sys.h" +extern const pxl8_hal pxl8_hal_sdl3; + typedef struct pxl8_sdl3_context { SDL_Texture* framebuffer; SDL_Renderer* renderer; SDL_Window* window; u32* rgba_buffer; - size_t rgba_buffer_size; + usize rgba_buffer_size; } pxl8_sdl3_context; static void* sdl3_create(i32 render_w, i32 render_h, @@ -101,7 +103,7 @@ static void sdl3_upload_texture(void* platform_data, const void* pixels, u32 w, if (!platform_data || !pixels) return; pxl8_sdl3_context* ctx = (pxl8_sdl3_context*)platform_data; - size_t pixel_count = w * h; + usize pixel_count = w * h; if (bpp == 4) { SDL_UpdateTexture(ctx->framebuffer, NULL, pixels, w * 4); diff --git a/src/hal/pxl8_mem.h b/src/hal/pxl8_mem.h new file mode 100644 index 0000000..790a19c --- /dev/null +++ b/src/hal/pxl8_mem.h @@ -0,0 +1,8 @@ +#pragma once + +#include "pxl8_types.h" + +void* pxl8_malloc(usize size); +void* pxl8_calloc(usize count, usize size); +void* pxl8_realloc(void* ptr, usize size); +void pxl8_free(void* ptr); diff --git a/src/hal/pxl8_mem_sdl3.c b/src/hal/pxl8_mem_sdl3.c new file mode 100644 index 0000000..4fc5aaa --- /dev/null +++ b/src/hal/pxl8_mem_sdl3.c @@ -0,0 +1,19 @@ +#include "pxl8_mem.h" + +#include + +void* pxl8_malloc(usize size) { + return SDL_malloc(size); +} + +void* pxl8_calloc(usize count, usize size) { + return SDL_calloc(count, size); +} + +void* pxl8_realloc(void* ptr, usize size) { + return SDL_realloc(ptr, size); +} + +void pxl8_free(void* ptr) { + SDL_free(ptr); +} diff --git a/src/hal/pxl8_sdl3.h b/src/hal/pxl8_sdl3.h deleted file mode 100644 index 4051e9e..0000000 --- a/src/hal/pxl8_sdl3.h +++ /dev/null @@ -1,5 +0,0 @@ -#pragma once - -#include "pxl8_hal.h" - -extern const pxl8_hal pxl8_hal_sdl3; diff --git a/src/net/pxl8_net.c b/src/net/pxl8_net.c index e5cba62..8ea7440 100644 --- a/src/net/pxl8_net.c +++ b/src/net/pxl8_net.c @@ -1,4 +1,5 @@ #include "pxl8_net.h" +#include "pxl8_mem.h" #include #include @@ -94,7 +95,7 @@ bool pxl8_net_connected(const pxl8_net* net) { } pxl8_net* pxl8_net_create(const pxl8_net_config* config) { - pxl8_net* net = calloc(1, sizeof(pxl8_net)); + pxl8_net* net = pxl8_calloc(1, sizeof(pxl8_net)); if (!net) return NULL; net->mode = config->mode; @@ -116,7 +117,7 @@ pxl8_net* pxl8_net_create(const pxl8_net_config* config) { void pxl8_net_destroy(pxl8_net* net) { if (!net) return; pxl8_net_disconnect(net); - free(net); + pxl8_free(net); } void pxl8_net_disconnect(pxl8_net* net) { @@ -203,11 +204,11 @@ u64 pxl8_net_player_id(const pxl8_net* net) { bool pxl8_net_poll(pxl8_net* net) { if (!net || !net->connected) return false; - size_t len = pxl8_net_recv(net, net->recv_buf, sizeof(net->recv_buf)); + usize len = pxl8_net_recv(net, net->recv_buf, sizeof(net->recv_buf)); if (len < sizeof(pxl8_msg_header)) return false; pxl8_msg_header hdr; - size_t offset = pxl8_protocol_deserialize_header(net->recv_buf, len, &hdr); + usize offset = pxl8_protocol_deserialize_header(net->recv_buf, len, &hdr); if (hdr.type != PXL8_MSG_SNAPSHOT) return false; pxl8_snapshot_header snap; @@ -243,17 +244,17 @@ void pxl8_net_predicted_tick_set(pxl8_net* net, u64 tick) { net->predicted_tick = tick; } -size_t pxl8_net_recv(pxl8_net* net, u8* buf, size_t len) { +usize pxl8_net_recv(pxl8_net* net, u8* buf, usize len) { if (!net || !net->connected) return 0; struct sockaddr_in from; socklen_t from_len = sizeof(from); ssize_t received = recvfrom(net->sock, (char*)buf, len, 0, (struct sockaddr*)&from, &from_len); - return (received > 0) ? (size_t)received : 0; + return (received > 0) ? (usize)received : 0; } -pxl8_result pxl8_net_send(pxl8_net* net, const u8* data, size_t len) { +pxl8_result pxl8_net_send(pxl8_net* net, const u8* data, usize len) { if (!net || !net->connected) return PXL8_ERROR_INVALID_ARGUMENT; ssize_t sent = sendto(net->sock, (const char*)data, len, 0, @@ -273,7 +274,7 @@ pxl8_result pxl8_net_send_command(pxl8_net* net, const pxl8_command_msg* cmd) { .sequence = 0 }; - size_t offset = pxl8_protocol_serialize_header(&hdr, buf, sizeof(buf)); + usize offset = pxl8_protocol_serialize_header(&hdr, buf, sizeof(buf)); offset += pxl8_protocol_serialize_command(cmd, buf + offset, sizeof(buf) - offset); return pxl8_net_send(net, buf, offset); @@ -290,7 +291,7 @@ pxl8_result pxl8_net_send_input(pxl8_net* net, const pxl8_input_msg* input) { .sequence = 0 }; - size_t offset = pxl8_protocol_serialize_header(&hdr, buf, sizeof(buf)); + usize offset = pxl8_protocol_serialize_header(&hdr, buf, sizeof(buf)); offset += pxl8_protocol_serialize_input(input, buf + offset, sizeof(buf) - offset); return pxl8_net_send(net, buf, offset); diff --git a/src/net/pxl8_net.h b/src/net/pxl8_net.h index d14ea10..cf81270 100644 --- a/src/net/pxl8_net.h +++ b/src/net/pxl8_net.h @@ -41,8 +41,8 @@ u64 pxl8_net_player_id(const pxl8_net* net); bool pxl8_net_poll(pxl8_net* net); u8* pxl8_net_predicted_state(pxl8_net* net); void pxl8_net_predicted_tick_set(pxl8_net* net, u64 tick); -size_t pxl8_net_recv(pxl8_net* net, u8* buf, size_t len); -pxl8_result pxl8_net_send(pxl8_net* net, const u8* data, size_t len); +usize pxl8_net_recv(pxl8_net* net, u8* buf, usize len); +pxl8_result pxl8_net_send(pxl8_net* net, const u8* data, usize len); pxl8_result pxl8_net_send_command(pxl8_net* net, const pxl8_command_msg* cmd); pxl8_result pxl8_net_send_input(pxl8_net* net, const pxl8_input_msg* input); const pxl8_snapshot_header* pxl8_net_snapshot(const pxl8_net* net); diff --git a/src/net/pxl8_protocol.c b/src/net/pxl8_protocol.c index 3c4a48d..cb74099 100644 --- a/src/net/pxl8_protocol.c +++ b/src/net/pxl8_protocol.c @@ -1,7 +1,7 @@ #include "pxl8_protocol.h" #include "pxl8_bytes.h" -size_t pxl8_protocol_serialize_header(const pxl8_msg_header* msg, u8* buf, size_t len) { +usize pxl8_protocol_serialize_header(const pxl8_msg_header* msg, u8* buf, usize len) { if (len < sizeof(pxl8_msg_header)) return 0; pxl8_write_stream s = pxl8_write_stream_create(buf, (u32)len); pxl8_write_u32_be(&s, msg->sequence); @@ -11,7 +11,7 @@ size_t pxl8_protocol_serialize_header(const pxl8_msg_header* msg, u8* buf, size_ return s.offset; } -size_t pxl8_protocol_deserialize_header(const u8* buf, size_t len, pxl8_msg_header* msg) { +usize pxl8_protocol_deserialize_header(const u8* buf, usize len, pxl8_msg_header* msg) { if (len < sizeof(pxl8_msg_header)) return 0; pxl8_stream s = pxl8_stream_create(buf, (u32)len); msg->sequence = pxl8_read_u32_be(&s); @@ -21,7 +21,7 @@ size_t pxl8_protocol_deserialize_header(const u8* buf, size_t len, pxl8_msg_head return s.offset; } -size_t pxl8_protocol_serialize_input(const pxl8_input_msg* msg, u8* buf, size_t len) { +usize pxl8_protocol_serialize_input(const pxl8_input_msg* msg, u8* buf, usize len) { if (len < sizeof(pxl8_input_msg)) return 0; pxl8_write_stream s = pxl8_write_stream_create(buf, (u32)len); pxl8_write_u32_be(&s, msg->buttons); @@ -35,7 +35,7 @@ size_t pxl8_protocol_serialize_input(const pxl8_input_msg* msg, u8* buf, size_t return s.offset; } -size_t pxl8_protocol_deserialize_input(const u8* buf, size_t len, pxl8_input_msg* msg) { +usize pxl8_protocol_deserialize_input(const u8* buf, usize len, pxl8_input_msg* msg) { if (len < sizeof(pxl8_input_msg)) return 0; pxl8_stream s = pxl8_stream_create(buf, (u32)len); msg->buttons = pxl8_read_u32_be(&s); @@ -49,7 +49,7 @@ size_t pxl8_protocol_deserialize_input(const u8* buf, size_t len, pxl8_input_msg return s.offset; } -size_t pxl8_protocol_serialize_command(const pxl8_command_msg* msg, u8* buf, size_t len) { +usize pxl8_protocol_serialize_command(const pxl8_command_msg* msg, u8* buf, usize len) { if (len < sizeof(pxl8_command_msg)) return 0; pxl8_write_stream s = pxl8_write_stream_create(buf, (u32)len); pxl8_write_u16_be(&s, msg->cmd_type); @@ -59,7 +59,7 @@ size_t pxl8_protocol_serialize_command(const pxl8_command_msg* msg, u8* buf, siz return s.offset; } -size_t pxl8_protocol_deserialize_command(const u8* buf, size_t len, pxl8_command_msg* msg) { +usize pxl8_protocol_deserialize_command(const u8* buf, usize len, pxl8_command_msg* msg) { if (len < sizeof(pxl8_command_msg)) return 0; pxl8_stream s = pxl8_stream_create(buf, (u32)len); msg->cmd_type = pxl8_read_u16_be(&s); @@ -69,7 +69,7 @@ size_t pxl8_protocol_deserialize_command(const u8* buf, size_t len, pxl8_command return s.offset; } -size_t pxl8_protocol_serialize_entity_state(const pxl8_entity_state* state, u8* buf, size_t len) { +usize pxl8_protocol_serialize_entity_state(const pxl8_entity_state* state, u8* buf, usize len) { if (len < sizeof(pxl8_entity_state)) return 0; pxl8_write_stream s = pxl8_write_stream_create(buf, (u32)len); pxl8_write_u64_be(&s, state->entity_id); @@ -77,7 +77,7 @@ size_t pxl8_protocol_serialize_entity_state(const pxl8_entity_state* state, u8* return s.offset; } -size_t pxl8_protocol_deserialize_entity_state(const u8* buf, size_t len, pxl8_entity_state* state) { +usize pxl8_protocol_deserialize_entity_state(const u8* buf, usize len, pxl8_entity_state* state) { if (len < sizeof(pxl8_entity_state)) return 0; pxl8_stream s = pxl8_stream_create(buf, (u32)len); state->entity_id = pxl8_read_u64_be(&s); @@ -85,7 +85,7 @@ size_t pxl8_protocol_deserialize_entity_state(const u8* buf, size_t len, pxl8_en return s.offset; } -size_t pxl8_protocol_serialize_event(const pxl8_event_msg* msg, u8* buf, size_t len) { +usize pxl8_protocol_serialize_event(const pxl8_event_msg* msg, u8* buf, usize len) { if (len < sizeof(pxl8_event_msg)) return 0; pxl8_write_stream s = pxl8_write_stream_create(buf, (u32)len); pxl8_write_u8(&s, msg->event_type); @@ -93,7 +93,7 @@ size_t pxl8_protocol_serialize_event(const pxl8_event_msg* msg, u8* buf, size_t return s.offset; } -size_t pxl8_protocol_deserialize_event(const u8* buf, size_t len, pxl8_event_msg* msg) { +usize pxl8_protocol_deserialize_event(const u8* buf, usize len, pxl8_event_msg* msg) { if (len < sizeof(pxl8_event_msg)) return 0; pxl8_stream s = pxl8_stream_create(buf, (u32)len); msg->event_type = pxl8_read_u8(&s); @@ -101,7 +101,7 @@ size_t pxl8_protocol_deserialize_event(const u8* buf, size_t len, pxl8_event_msg return s.offset; } -size_t pxl8_protocol_serialize_snapshot_header(const pxl8_snapshot_header* hdr, u8* buf, size_t len) { +usize pxl8_protocol_serialize_snapshot_header(const pxl8_snapshot_header* hdr, u8* buf, usize len) { if (len < sizeof(pxl8_snapshot_header)) return 0; pxl8_write_stream s = pxl8_write_stream_create(buf, (u32)len); pxl8_write_u16_be(&s, hdr->entity_count); @@ -112,7 +112,7 @@ size_t pxl8_protocol_serialize_snapshot_header(const pxl8_snapshot_header* hdr, return s.offset; } -size_t pxl8_protocol_deserialize_snapshot_header(const u8* buf, size_t len, pxl8_snapshot_header* hdr) { +usize pxl8_protocol_deserialize_snapshot_header(const u8* buf, usize len, pxl8_snapshot_header* hdr) { if (len < sizeof(pxl8_snapshot_header)) return 0; pxl8_stream s = pxl8_stream_create(buf, (u32)len); hdr->entity_count = pxl8_read_u16_be(&s); diff --git a/src/net/pxl8_protocol.h b/src/net/pxl8_protocol.h index 78a4207..696a7ad 100644 --- a/src/net/pxl8_protocol.h +++ b/src/net/pxl8_protocol.h @@ -70,23 +70,23 @@ typedef struct pxl8_snapshot_header { f32 time; } pxl8_snapshot_header; -size_t pxl8_protocol_serialize_header(const pxl8_msg_header* msg, u8* buf, size_t len); -size_t pxl8_protocol_deserialize_header(const u8* buf, size_t len, pxl8_msg_header* msg); +usize pxl8_protocol_serialize_header(const pxl8_msg_header* msg, u8* buf, usize len); +usize pxl8_protocol_deserialize_header(const u8* buf, usize len, pxl8_msg_header* msg); -size_t pxl8_protocol_serialize_input(const pxl8_input_msg* msg, u8* buf, size_t len); -size_t pxl8_protocol_deserialize_input(const u8* buf, size_t len, pxl8_input_msg* msg); +usize pxl8_protocol_serialize_input(const pxl8_input_msg* msg, u8* buf, usize len); +usize pxl8_protocol_deserialize_input(const u8* buf, usize len, pxl8_input_msg* msg); -size_t pxl8_protocol_serialize_command(const pxl8_command_msg* msg, u8* buf, size_t len); -size_t pxl8_protocol_deserialize_command(const u8* buf, size_t len, pxl8_command_msg* msg); +usize pxl8_protocol_serialize_command(const pxl8_command_msg* msg, u8* buf, usize len); +usize pxl8_protocol_deserialize_command(const u8* buf, usize len, pxl8_command_msg* msg); -size_t pxl8_protocol_serialize_entity_state(const pxl8_entity_state* state, u8* buf, size_t len); -size_t pxl8_protocol_deserialize_entity_state(const u8* buf, size_t len, pxl8_entity_state* state); +usize pxl8_protocol_serialize_entity_state(const pxl8_entity_state* state, u8* buf, usize len); +usize pxl8_protocol_deserialize_entity_state(const u8* buf, usize len, pxl8_entity_state* state); -size_t pxl8_protocol_serialize_event(const pxl8_event_msg* msg, u8* buf, size_t len); -size_t pxl8_protocol_deserialize_event(const u8* buf, size_t len, pxl8_event_msg* msg); +usize pxl8_protocol_serialize_event(const pxl8_event_msg* msg, u8* buf, usize len); +usize pxl8_protocol_deserialize_event(const u8* buf, usize len, pxl8_event_msg* msg); -size_t pxl8_protocol_serialize_snapshot_header(const pxl8_snapshot_header* hdr, u8* buf, size_t len); -size_t pxl8_protocol_deserialize_snapshot_header(const u8* buf, size_t len, pxl8_snapshot_header* hdr); +usize pxl8_protocol_serialize_snapshot_header(const pxl8_snapshot_header* hdr, u8* buf, usize len); +usize pxl8_protocol_deserialize_snapshot_header(const u8* buf, usize len, pxl8_snapshot_header* hdr); #ifdef __cplusplus } diff --git a/src/procgen/pxl8_graph.c b/src/procgen/pxl8_graph.c index 9777f06..ffb377c 100644 --- a/src/procgen/pxl8_graph.c +++ b/src/procgen/pxl8_graph.c @@ -5,6 +5,7 @@ #include #include "pxl8_math.h" +#include "pxl8_mem.h" static inline u32 hash2d(i32 x, i32 y, u32 seed) { return pxl8_hash32((u32)x ^ ((u32)y * 2654435769u) ^ seed); @@ -168,12 +169,12 @@ static f32 gradient_radial(f32 x, f32 y, f32 cx, f32 cy) { } pxl8_graph* pxl8_graph_create(u32 capacity) { - pxl8_graph* graph = calloc(1, sizeof(pxl8_graph)); + pxl8_graph* graph = pxl8_calloc(1, sizeof(pxl8_graph)); if (!graph) return NULL; - graph->nodes = calloc(capacity, sizeof(pxl8_node)); + graph->nodes = pxl8_calloc(capacity, sizeof(pxl8_node)); if (!graph->nodes) { - free(graph); + pxl8_free(graph); return NULL; } @@ -186,8 +187,8 @@ pxl8_graph* pxl8_graph_create(u32 capacity) { void pxl8_graph_destroy(pxl8_graph* graph) { if (!graph) return; - free(graph->nodes); - free(graph); + pxl8_free(graph->nodes); + pxl8_free(graph); } void pxl8_graph_clear(pxl8_graph* graph) { diff --git a/src/script/pxl8_repl.c b/src/script/pxl8_repl.c index 7df3ab7..5c7853f 100644 --- a/src/script/pxl8_repl.c +++ b/src/script/pxl8_repl.c @@ -1,4 +1,5 @@ #include "pxl8_repl.h" +#include "pxl8_mem.h" #include #include @@ -55,15 +56,15 @@ static void pxl8_repl_completion(const char* buf, linenoiseCompletions* lc) { "pxl8.error", "pxl8.debug", "pxl8.trace" }; - size_t buf_len = strlen(buf); + usize buf_len = strlen(buf); - for (size_t i = 0; i < sizeof(fennel_keywords) / sizeof(fennel_keywords[0]); i++) { + for (usize i = 0; i < sizeof(fennel_keywords) / sizeof(fennel_keywords[0]); i++) { if (strncmp(buf, fennel_keywords[i], buf_len) == 0) { linenoiseAddCompletion(lc, fennel_keywords[i]); } } - for (size_t i = 0; i < sizeof(pxl8_functions) / sizeof(pxl8_functions[0]); i++) { + for (usize i = 0; i < sizeof(pxl8_functions) / sizeof(pxl8_functions[0]); i++) { if (strncmp(buf, pxl8_functions[i], buf_len) == 0) { linenoiseAddCompletion(lc, pxl8_functions[i]); } @@ -216,7 +217,7 @@ static int pxl8_repl_thread(void* arg) { } pxl8_repl* pxl8_repl_create(void) { - pxl8_repl* repl = (pxl8_repl*)calloc(1, sizeof(pxl8_repl)); + pxl8_repl* repl = (pxl8_repl*)pxl8_calloc(1, sizeof(pxl8_repl)); if (!repl) return NULL; repl->accumulator[0] = '\0'; @@ -237,7 +238,7 @@ pxl8_repl* pxl8_repl_create(void) { repl->thread = SDL_CreateThread(pxl8_repl_thread, "pxl8-repl", repl); if (!repl->thread) { - free(repl); + pxl8_free(repl); g_repl = NULL; return NULL; } @@ -261,7 +262,7 @@ void pxl8_repl_destroy(pxl8_repl* repl) { g_repl = NULL; system("stty sane 2>/dev/null"); - free(repl); + pxl8_free(repl); } pxl8_repl_command* pxl8_repl_pop_command(pxl8_repl* repl) { diff --git a/src/script/pxl8_script.c b/src/script/pxl8_script.c index 481e8ca..dda3c5f 100644 --- a/src/script/pxl8_script.c +++ b/src/script/pxl8_script.c @@ -17,6 +17,7 @@ #include "pxl8_gui.h" #include "pxl8_log.h" #include "pxl8_macros.h" +#include "pxl8_mem.h" #include "pxl8_script_ffi.h" struct pxl8_script { @@ -37,7 +38,7 @@ struct pxl8_script { static int pxl8_cart_loader(lua_State* L) { const char* found_path = lua_tostring(L, lua_upvalueindex(1)); const char* code = lua_tostring(L, lua_upvalueindex(2)); - size_t code_len = lua_objlen(L, lua_upvalueindex(2)); + usize code_len = lua_objlen(L, lua_upvalueindex(2)); bool is_fennel = lua_toboolean(L, lua_upvalueindex(3)); if (is_fennel) { @@ -75,9 +76,9 @@ static int pxl8_cart_searcher(lua_State* L) { } char path[512]; - size_t len = strlen(modname); - size_t j = 0; - for (size_t i = 0; i < len && j < sizeof(path) - 5; i++) { + usize len = strlen(modname); + usize j = 0; + for (usize i = 0; i < len && j < sizeof(path) - 5; i++) { if (modname[i] == '.') { path[j++] = '/'; } else { @@ -114,9 +115,9 @@ static int pxl8_cart_searcher(lua_State* L) { return 1; } -static void pxl8_script_repl_promote_locals(const char* input, char* output, size_t output_size) { - size_t i = 0; - size_t j = 0; +static void pxl8_script_repl_promote_locals(const char* input, char* output, usize output_size) { + usize i = 0; + usize j = 0; bool in_string = false; bool in_comment = false; @@ -182,18 +183,18 @@ static void pxl8_script_set_error(pxl8_script* script, const char* error) { src += 9; const char* mod_start = src; while (*src && !(*src == '"' && *(src+1) == ']')) src++; - size_t mod_len = src - mod_start; + usize mod_len = src - mod_start; if (mod_len > 4 && strncmp(mod_start, "pxl8", 4) == 0) { const char* prefix = "src/lua/"; while (*prefix && dst < end) *dst++ = *prefix++; - for (size_t i = 0; i < mod_len && dst < end; i++) { + for (usize i = 0; i < mod_len && dst < end; i++) { *dst++ = (mod_start[i] == '.') ? '/' : mod_start[i]; } const char* suffix = ".lua"; while (*suffix && dst < end) *dst++ = *suffix++; } else { - for (size_t i = 0; i < mod_len && dst < end; i++) { + for (usize i = 0; i < mod_len && dst < end; i++) { *dst++ = mod_start[i]; } } @@ -244,13 +245,13 @@ static void pxl8_install_embed_searcher(lua_State* L) { } pxl8_script* pxl8_script_create(bool repl_mode) { - pxl8_script* script = (pxl8_script*)calloc(1, sizeof(pxl8_script)); + pxl8_script* script = (pxl8_script*)pxl8_calloc(1, sizeof(pxl8_script)); if (!script) return NULL; script->repl_mode = repl_mode; script->L = luaL_newstate(); if (!script->L) { - free(script); + pxl8_free(script); return NULL; } @@ -349,7 +350,7 @@ void pxl8_script_destroy(pxl8_script* script) { } lua_close(script->L); } - free(script); + pxl8_free(script); } void pxl8_script_set_gfx(pxl8_script* script, pxl8_gfx* gfx) { @@ -395,7 +396,7 @@ void pxl8_script_set_sys(pxl8_script* script, void* sys) { } } -static pxl8_result pxl8_script_prepare_path(pxl8_script* script, const char* filename, char* out_basename, size_t basename_size) { +static pxl8_result pxl8_script_prepare_path(pxl8_script* script, const char* filename, char* out_basename, usize basename_size) { char filename_copy[PATH_MAX]; pxl8_strncpy(filename_copy, filename, sizeof(filename_copy)); @@ -470,7 +471,7 @@ static time_t get_latest_script_mod_time(const char* dir_path) { latest = subdir_time; } } else { - size_t len = strlen(entry->d_name); + usize len = strlen(entry->d_name); bool is_script = (len > 4 && strcmp(entry->d_name + len - 4, ".fnl") == 0) || (len > 4 && strcmp(entry->d_name + len - 4, ".lua") == 0); @@ -618,8 +619,8 @@ static pxl8_result pxl8_script_eval_internal(pxl8_script* script, const char* co const char* error = lua_tostring(script->L, -1); if (error) { char cleaned_error[2048]; - size_t j = 0; - for (size_t i = 0; error[i] && j < sizeof(cleaned_error) - 1; i++) { + usize j = 0; + for (usize i = 0; error[i] && j < sizeof(cleaned_error) - 1; i++) { if (error[i] == '\t') { cleaned_error[j++] = ' '; } else { @@ -877,7 +878,7 @@ typedef struct { static void ser_buffer_init(ser_buffer* buf) { buf->capacity = 1024; - buf->data = malloc(buf->capacity); + buf->data = pxl8_malloc(buf->capacity); buf->size = 0; } @@ -886,7 +887,7 @@ static void ser_buffer_grow(ser_buffer* buf, u32 needed) { while (buf->size + needed > buf->capacity) { buf->capacity *= 2; } - buf->data = realloc(buf->data, buf->capacity); + buf->data = pxl8_realloc(buf->data, buf->capacity); } } @@ -930,7 +931,7 @@ static void ser_write_value(ser_buffer* buf, lua_State* L, int idx, int depth) { ser_write_f64(buf, lua_tonumber(L, idx)); break; case LUA_TSTRING: { - size_t len; + usize len; const char* str = lua_tolstring(L, idx, &len); ser_write_u8(buf, SER_STRING); ser_write_u32(buf, (u32)len); @@ -1080,7 +1081,7 @@ void pxl8_script_deserialize_globals(pxl8_script* script, const u8* data, u32 si } void pxl8_script_free_serialized(u8* data) { - free(data); + pxl8_free(data); } pxl8_result pxl8_script_load_main(pxl8_script* script, const char* path) { diff --git a/src/script/pxl8_script_ffi.h b/src/script/pxl8_script_ffi.h index 63ac9d7..4ca83fe 100644 --- a/src/script/pxl8_script_ffi.h +++ b/src/script/pxl8_script_ffi.h @@ -11,6 +11,8 @@ static const char* pxl8_ffi_cdefs = "typedef int64_t i64;\n" "typedef float f32;\n" "typedef double f64;\n" +"typedef size_t usize;\n" +"typedef ptrdiff_t isize;\n" "typedef struct pxl8 pxl8;\n" "typedef struct pxl8_gfx pxl8_gfx;\n" "typedef struct { int x, y, w, h; } pxl8_bounds;\n" @@ -579,40 +581,40 @@ static const char* pxl8_ffi_cdefs = "bool pxl8_bit_test(u32 val, u8 bit);\n" "void pxl8_bit_toggle(u32* val, u8 bit);\n" "\n" -"void pxl8_pack_u8(u8* buf, size_t offset, u8 val);\n" -"void pxl8_pack_u16_be(u8* buf, size_t offset, u16 val);\n" -"void pxl8_pack_u16_le(u8* buf, size_t offset, u16 val);\n" -"void pxl8_pack_u32_be(u8* buf, size_t offset, u32 val);\n" -"void pxl8_pack_u32_le(u8* buf, size_t offset, u32 val);\n" -"void pxl8_pack_u64_be(u8* buf, size_t offset, u64 val);\n" -"void pxl8_pack_u64_le(u8* buf, size_t offset, u64 val);\n" -"void pxl8_pack_i8(u8* buf, size_t offset, i8 val);\n" -"void pxl8_pack_i16_be(u8* buf, size_t offset, i16 val);\n" -"void pxl8_pack_i16_le(u8* buf, size_t offset, i16 val);\n" -"void pxl8_pack_i32_be(u8* buf, size_t offset, i32 val);\n" -"void pxl8_pack_i32_le(u8* buf, size_t offset, i32 val);\n" -"void pxl8_pack_i64_be(u8* buf, size_t offset, i64 val);\n" -"void pxl8_pack_i64_le(u8* buf, size_t offset, i64 val);\n" -"void pxl8_pack_f32_be(u8* buf, size_t offset, f32 val);\n" -"void pxl8_pack_f32_le(u8* buf, size_t offset, f32 val);\n" -"void pxl8_pack_f64_be(u8* buf, size_t offset, f64 val);\n" -"void pxl8_pack_f64_le(u8* buf, size_t offset, f64 val);\n" +"void pxl8_pack_u8(u8* buf, usize offset, u8 val);\n" +"void pxl8_pack_u16_be(u8* buf, usize offset, u16 val);\n" +"void pxl8_pack_u16_le(u8* buf, usize offset, u16 val);\n" +"void pxl8_pack_u32_be(u8* buf, usize offset, u32 val);\n" +"void pxl8_pack_u32_le(u8* buf, usize offset, u32 val);\n" +"void pxl8_pack_u64_be(u8* buf, usize offset, u64 val);\n" +"void pxl8_pack_u64_le(u8* buf, usize offset, u64 val);\n" +"void pxl8_pack_i8(u8* buf, usize offset, i8 val);\n" +"void pxl8_pack_i16_be(u8* buf, usize offset, i16 val);\n" +"void pxl8_pack_i16_le(u8* buf, usize offset, i16 val);\n" +"void pxl8_pack_i32_be(u8* buf, usize offset, i32 val);\n" +"void pxl8_pack_i32_le(u8* buf, usize offset, i32 val);\n" +"void pxl8_pack_i64_be(u8* buf, usize offset, i64 val);\n" +"void pxl8_pack_i64_le(u8* buf, usize offset, i64 val);\n" +"void pxl8_pack_f32_be(u8* buf, usize offset, f32 val);\n" +"void pxl8_pack_f32_le(u8* buf, usize offset, f32 val);\n" +"void pxl8_pack_f64_be(u8* buf, usize offset, f64 val);\n" +"void pxl8_pack_f64_le(u8* buf, usize offset, f64 val);\n" "\n" -"u8 pxl8_unpack_u8(const u8* buf, size_t offset);\n" -"u16 pxl8_unpack_u16_be(const u8* buf, size_t offset);\n" -"u16 pxl8_unpack_u16_le(const u8* buf, size_t offset);\n" -"u32 pxl8_unpack_u32_be(const u8* buf, size_t offset);\n" -"u32 pxl8_unpack_u32_le(const u8* buf, size_t offset);\n" -"u64 pxl8_unpack_u64_be(const u8* buf, size_t offset);\n" -"u64 pxl8_unpack_u64_le(const u8* buf, size_t offset);\n" -"i8 pxl8_unpack_i8(const u8* buf, size_t offset);\n" -"i16 pxl8_unpack_i16_be(const u8* buf, size_t offset);\n" -"i16 pxl8_unpack_i16_le(const u8* buf, size_t offset);\n" -"i32 pxl8_unpack_i32_be(const u8* buf, size_t offset);\n" -"i32 pxl8_unpack_i32_le(const u8* buf, size_t offset);\n" -"i64 pxl8_unpack_i64_be(const u8* buf, size_t offset);\n" -"i64 pxl8_unpack_i64_le(const u8* buf, size_t offset);\n" -"f32 pxl8_unpack_f32_be(const u8* buf, size_t offset);\n" -"f32 pxl8_unpack_f32_le(const u8* buf, size_t offset);\n" -"f64 pxl8_unpack_f64_be(const u8* buf, size_t offset);\n" -"f64 pxl8_unpack_f64_le(const u8* buf, size_t offset);\n"; +"u8 pxl8_unpack_u8(const u8* buf, usize offset);\n" +"u16 pxl8_unpack_u16_be(const u8* buf, usize offset);\n" +"u16 pxl8_unpack_u16_le(const u8* buf, usize offset);\n" +"u32 pxl8_unpack_u32_be(const u8* buf, usize offset);\n" +"u32 pxl8_unpack_u32_le(const u8* buf, usize offset);\n" +"u64 pxl8_unpack_u64_be(const u8* buf, usize offset);\n" +"u64 pxl8_unpack_u64_le(const u8* buf, usize offset);\n" +"i8 pxl8_unpack_i8(const u8* buf, usize offset);\n" +"i16 pxl8_unpack_i16_be(const u8* buf, usize offset);\n" +"i16 pxl8_unpack_i16_le(const u8* buf, usize offset);\n" +"i32 pxl8_unpack_i32_be(const u8* buf, usize offset);\n" +"i32 pxl8_unpack_i32_le(const u8* buf, usize offset);\n" +"i64 pxl8_unpack_i64_be(const u8* buf, usize offset);\n" +"i64 pxl8_unpack_i64_le(const u8* buf, usize offset);\n" +"f32 pxl8_unpack_f32_be(const u8* buf, usize offset);\n" +"f32 pxl8_unpack_f32_le(const u8* buf, usize offset);\n" +"f64 pxl8_unpack_f64_be(const u8* buf, usize offset);\n" +"f64 pxl8_unpack_f64_le(const u8* buf, usize offset);\n"; diff --git a/src/sfx/pxl8_sfx.c b/src/sfx/pxl8_sfx.c index 75c7937..1d143d7 100644 --- a/src/sfx/pxl8_sfx.c +++ b/src/sfx/pxl8_sfx.c @@ -6,6 +6,7 @@ #include "pxl8_hal.h" #include "pxl8_log.h" #include "pxl8_math.h" +#include "pxl8_mem.h" #define VOICE_SCALE 0.15f @@ -466,14 +467,14 @@ static void delay_process_stereo(void* state, f32* left, f32* right) { static void delay_destroy_state(void* state) { delay_state* d = (delay_state*)state; if (d) { - free(d->buffer_l); - free(d->buffer_r); - free(d); + pxl8_free(d->buffer_l); + pxl8_free(d->buffer_r); + pxl8_free(d); } } static void comb_init(comb_filter* c, u32 size, f32 feedback, f32 damping) { - c->buffer = (f32*)calloc(size, sizeof(f32)); + c->buffer = (f32*)pxl8_calloc(size, sizeof(f32)); c->size = size; c->feedback = feedback; c->damping = damping; @@ -482,7 +483,7 @@ static void comb_init(comb_filter* c, u32 size, f32 feedback, f32 damping) { } static void comb_destroy(comb_filter* c) { - free(c->buffer); + pxl8_free(c->buffer); } static f32 comb_process(comb_filter* c, f32 input) { @@ -497,14 +498,14 @@ static f32 comb_process(comb_filter* c, f32 input) { } static void allpass_init(allpass_filter* a, u32 size) { - a->buffer = (f32*)calloc(size, sizeof(f32)); + a->buffer = (f32*)pxl8_calloc(size, sizeof(f32)); a->size = size; a->feedback = 0.5f; a->index = 0; } static void allpass_destroy(allpass_filter* a) { - free(a->buffer); + pxl8_free(a->buffer); } static f32 allpass_process(allpass_filter* a, f32 input) { @@ -560,7 +561,7 @@ static void reverb_destroy_state(void* state) { if (r) { for (int i = 0; i < 4; i++) comb_destroy(&r->combs[i]); for (int i = 0; i < 2; i++) allpass_destroy(&r->allpasses[i]); - free(r); + pxl8_free(r); } } @@ -606,7 +607,7 @@ static void compressor_process_stereo(void* state, f32* left, f32* right) { } static void compressor_destroy_state(void* state) { - free(state); + pxl8_free(state); } static void context_process_sample(pxl8_sfx_context* ctx, f32* out_left, f32* out_right) { @@ -654,12 +655,12 @@ static void context_process_sample(pxl8_sfx_context* ctx, f32* out_left, f32* ou pxl8_sfx_mixer* pxl8_sfx_mixer_create(const pxl8_hal* hal) { if (!hal || !hal->audio_create) return NULL; - pxl8_sfx_mixer* mixer = (pxl8_sfx_mixer*)calloc(1, sizeof(pxl8_sfx_mixer)); + pxl8_sfx_mixer* mixer = (pxl8_sfx_mixer*)pxl8_calloc(1, sizeof(pxl8_sfx_mixer)); if (!mixer) return NULL; - mixer->output_buffer = (f32*)calloc(PXL8_SFX_BUFFER_SIZE * 2, sizeof(f32)); + mixer->output_buffer = (f32*)pxl8_calloc(PXL8_SFX_BUFFER_SIZE * 2, sizeof(f32)); if (!mixer->output_buffer) { - free(mixer); + pxl8_free(mixer); return NULL; } @@ -668,8 +669,8 @@ pxl8_sfx_mixer* pxl8_sfx_mixer_create(const pxl8_hal* hal) { mixer->audio_handle = hal->audio_create(PXL8_SFX_SAMPLE_RATE, 2); if (!mixer->audio_handle) { - free(mixer->output_buffer); - free(mixer); + pxl8_free(mixer->output_buffer); + pxl8_free(mixer); return NULL; } @@ -686,8 +687,8 @@ void pxl8_sfx_mixer_destroy(pxl8_sfx_mixer* mixer) { mixer->hal->audio_destroy(mixer->audio_handle); } - free(mixer->output_buffer); - free(mixer); + pxl8_free(mixer->output_buffer); + pxl8_free(mixer); } void pxl8_sfx_mixer_process(pxl8_sfx_mixer* mixer) { @@ -790,7 +791,7 @@ f32 pxl8_sfx_mixer_get_master_volume(const pxl8_sfx_mixer* mixer) { } pxl8_sfx_context* pxl8_sfx_context_create(void) { - pxl8_sfx_context* ctx = (pxl8_sfx_context*)calloc(1, sizeof(pxl8_sfx_context)); + pxl8_sfx_context* ctx = (pxl8_sfx_context*)pxl8_calloc(1, sizeof(pxl8_sfx_context)); if (!ctx) return NULL; ctx->volume = 1.0f; @@ -809,7 +810,7 @@ void pxl8_sfx_context_destroy(pxl8_sfx_context* ctx) { node = next; } - free(ctx); + pxl8_free(ctx); } void pxl8_sfx_context_set_volume(pxl8_sfx_context* ctx, f32 volume) { @@ -876,26 +877,26 @@ void pxl8_sfx_node_destroy(pxl8_sfx_node* node) { if (node->destroy && node->state) { node->destroy(node->state); } - free(node); + pxl8_free(node); } pxl8_sfx_node* pxl8_sfx_delay_create(pxl8_sfx_delay_config cfg) { - pxl8_sfx_node* node = (pxl8_sfx_node*)calloc(1, sizeof(pxl8_sfx_node)); + pxl8_sfx_node* node = (pxl8_sfx_node*)pxl8_calloc(1, sizeof(pxl8_sfx_node)); if (!node) return NULL; - delay_state* d = (delay_state*)calloc(1, sizeof(delay_state)); + delay_state* d = (delay_state*)pxl8_calloc(1, sizeof(delay_state)); if (!d) { - free(node); + pxl8_free(node); return NULL; } - d->buffer_l = (f32*)calloc(PXL8_SFX_MAX_DELAY_SAMPLES, sizeof(f32)); - d->buffer_r = (f32*)calloc(PXL8_SFX_MAX_DELAY_SAMPLES, sizeof(f32)); + d->buffer_l = (f32*)pxl8_calloc(PXL8_SFX_MAX_DELAY_SAMPLES, sizeof(f32)); + d->buffer_r = (f32*)pxl8_calloc(PXL8_SFX_MAX_DELAY_SAMPLES, sizeof(f32)); if (!d->buffer_l || !d->buffer_r) { - free(d->buffer_l); - free(d->buffer_r); - free(d); - free(node); + pxl8_free(d->buffer_l); + pxl8_free(d->buffer_r); + pxl8_free(d); + pxl8_free(node); return NULL; } @@ -938,12 +939,12 @@ void pxl8_sfx_delay_set_mix(pxl8_sfx_node* node, f32 mix) { } pxl8_sfx_node* pxl8_sfx_reverb_create(pxl8_sfx_reverb_config cfg) { - pxl8_sfx_node* node = (pxl8_sfx_node*)calloc(1, sizeof(pxl8_sfx_node)); + pxl8_sfx_node* node = (pxl8_sfx_node*)pxl8_calloc(1, sizeof(pxl8_sfx_node)); if (!node) return NULL; - reverb_state* r = (reverb_state*)calloc(1, sizeof(reverb_state)); + reverb_state* r = (reverb_state*)pxl8_calloc(1, sizeof(reverb_state)); if (!r) { - free(node); + pxl8_free(node); return NULL; } @@ -996,12 +997,12 @@ void pxl8_sfx_reverb_set_mix(pxl8_sfx_node* node, f32 mix) { } pxl8_sfx_node* pxl8_sfx_compressor_create(pxl8_sfx_compressor_config cfg) { - pxl8_sfx_node* node = (pxl8_sfx_node*)calloc(1, sizeof(pxl8_sfx_node)); + pxl8_sfx_node* node = (pxl8_sfx_node*)pxl8_calloc(1, sizeof(pxl8_sfx_node)); if (!node) return NULL; - compressor_state* c = (compressor_state*)calloc(1, sizeof(compressor_state)); + compressor_state* c = (compressor_state*)pxl8_calloc(1, sizeof(compressor_state)); if (!c) { - free(node); + pxl8_free(node); return NULL; } diff --git a/src/world/pxl8_bsp.c b/src/world/pxl8_bsp.c index e687820..3275b31 100644 --- a/src/world/pxl8_bsp.c +++ b/src/world/pxl8_bsp.c @@ -8,6 +8,7 @@ #include "pxl8_gfx.h" #include "pxl8_io.h" #include "pxl8_log.h" +#include "pxl8_mem.h" #define BSP_VERSION 29 @@ -56,7 +57,7 @@ static inline pxl8_vec3 read_vec3(pxl8_stream* stream) { return (pxl8_vec3){x, z, y}; } -static bool validate_chunk(const pxl8_bsp_chunk* chunk, u32 element_size, size_t file_size) { +static bool validate_chunk(const pxl8_bsp_chunk* chunk, u32 element_size, usize file_size) { if (chunk->size == 0) return true; if (chunk->offset >= file_size) return false; if (chunk->offset + chunk->size > file_size) return false; @@ -89,7 +90,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { memset(bsp, 0, sizeof(*bsp)); u8* file_data = NULL; - size_t file_size = 0; + usize file_size = 0; pxl8_result result = pxl8_io_read_binary_file(path, &file_data, &file_size); if (result != PXL8_OK) { pxl8_error("Failed to load BSP file: %s", path); @@ -98,7 +99,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (file_size < sizeof(pxl8_bsp_header)) { pxl8_error("BSP file too small: %s", path); - free(file_data); + pxl8_free(file_data); return PXL8_ERROR_INVALID_FORMAT; } @@ -109,7 +110,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (header.version != BSP_VERSION) { pxl8_error("Invalid BSP version: %u (expected %d)", header.version, BSP_VERSION); - free(file_data); + pxl8_free(file_data); return PXL8_ERROR_INVALID_FORMAT; } @@ -122,7 +123,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (!validate_chunk(chunk, 12, file_size)) goto error_cleanup; bsp->num_vertices = chunk->size / 12; if (bsp->num_vertices > 0) { - bsp->vertices = calloc(bsp->num_vertices, sizeof(pxl8_bsp_vertex)); + bsp->vertices = pxl8_calloc(bsp->num_vertices, sizeof(pxl8_bsp_vertex)); if (!bsp->vertices) goto error_cleanup; pxl8_stream_seek(&stream, chunk->offset); for (u32 i = 0; i < bsp->num_vertices; i++) { @@ -134,7 +135,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (!validate_chunk(chunk, 4, file_size)) goto error_cleanup; bsp->num_edges = chunk->size / 4; if (bsp->num_edges > 0) { - bsp->edges = calloc(bsp->num_edges, sizeof(pxl8_bsp_edge)); + bsp->edges = pxl8_calloc(bsp->num_edges, sizeof(pxl8_bsp_edge)); pxl8_stream_seek(&stream, chunk->offset); for (u32 i = 0; i < bsp->num_edges; i++) { bsp->edges[i].vertex[0] = pxl8_read_u16(&stream); @@ -146,7 +147,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (!validate_chunk(chunk, 4, file_size)) goto error_cleanup; bsp->num_surfedges = chunk->size / 4; if (bsp->num_surfedges > 0) { - bsp->surfedges = calloc(bsp->num_surfedges, sizeof(i32)); + bsp->surfedges = pxl8_calloc(bsp->num_surfedges, sizeof(i32)); pxl8_stream_seek(&stream, chunk->offset); for (u32 i = 0; i < bsp->num_surfedges; i++) { bsp->surfedges[i] = pxl8_read_i32(&stream); @@ -157,7 +158,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (!validate_chunk(chunk, 20, file_size)) goto error_cleanup; bsp->num_planes = chunk->size / 20; if (bsp->num_planes > 0) { - bsp->planes = calloc(bsp->num_planes, sizeof(pxl8_bsp_plane)); + bsp->planes = pxl8_calloc(bsp->num_planes, sizeof(pxl8_bsp_plane)); pxl8_stream_seek(&stream, chunk->offset); for (u32 i = 0; i < bsp->num_planes; i++) { bsp->planes[i].normal = read_vec3(&stream); @@ -170,7 +171,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (!validate_chunk(chunk, 40, file_size)) goto error_cleanup; bsp->num_materials = chunk->size / 40; if (bsp->num_materials > 0) { - bsp->materials = calloc(bsp->num_materials, sizeof(pxl8_gfx_material)); + bsp->materials = pxl8_calloc(bsp->num_materials, sizeof(pxl8_gfx_material)); pxl8_stream_seek(&stream, chunk->offset); for (u32 i = 0; i < bsp->num_materials; i++) { bsp->materials[i].u_axis = read_vec3(&stream); @@ -189,7 +190,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (!validate_chunk(chunk, 20, file_size)) goto error_cleanup; bsp->num_faces = chunk->size / 20; if (bsp->num_faces > 0) { - bsp->faces = calloc(bsp->num_faces, sizeof(pxl8_bsp_face)); + bsp->faces = pxl8_calloc(bsp->num_faces, sizeof(pxl8_bsp_face)); pxl8_stream_seek(&stream, chunk->offset); for (u32 i = 0; i < bsp->num_faces; i++) { bsp->faces[i].plane_id = pxl8_read_u16(&stream); @@ -212,7 +213,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (!validate_chunk(chunk, 24, file_size)) goto error_cleanup; bsp->num_nodes = chunk->size / 24; if (bsp->num_nodes > 0) { - bsp->nodes = calloc(bsp->num_nodes, sizeof(pxl8_bsp_node)); + bsp->nodes = pxl8_calloc(bsp->num_nodes, sizeof(pxl8_bsp_node)); pxl8_stream_seek(&stream, chunk->offset); for (u32 i = 0; i < bsp->num_nodes; i++) { bsp->nodes[i].plane_id = pxl8_read_u32(&stream); @@ -239,7 +240,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (!validate_chunk(chunk, 28, file_size)) goto error_cleanup; bsp->num_leafs = chunk->size / 28; if (bsp->num_leafs > 0) { - bsp->leafs = calloc(bsp->num_leafs, sizeof(pxl8_bsp_leaf)); + bsp->leafs = pxl8_calloc(bsp->num_leafs, sizeof(pxl8_bsp_leaf)); pxl8_stream_seek(&stream, chunk->offset); for (u32 i = 0; i < bsp->num_leafs; i++) { bsp->leafs[i].contents = pxl8_read_i32(&stream); @@ -266,7 +267,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (!validate_chunk(chunk, 2, file_size)) goto error_cleanup; bsp->num_marksurfaces = chunk->size / 2; if (bsp->num_marksurfaces > 0) { - bsp->marksurfaces = calloc(bsp->num_marksurfaces, sizeof(u16)); + bsp->marksurfaces = pxl8_calloc(bsp->num_marksurfaces, sizeof(u16)); pxl8_stream_seek(&stream, chunk->offset); for (u32 i = 0; i < bsp->num_marksurfaces; i++) { bsp->marksurfaces[i] = pxl8_read_u16(&stream); @@ -277,7 +278,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (!validate_chunk(chunk, 64, file_size)) goto error_cleanup; bsp->num_models = chunk->size / 64; if (bsp->num_models > 0) { - bsp->models = calloc(bsp->num_models, sizeof(pxl8_bsp_model)); + bsp->models = pxl8_calloc(bsp->num_models, sizeof(pxl8_bsp_model)); pxl8_stream_seek(&stream, chunk->offset); for (u32 i = 0; i < bsp->num_models; i++) { f32 minx = pxl8_read_f32(&stream); @@ -304,7 +305,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (!validate_chunk(chunk, 1, file_size)) goto error_cleanup; bsp->visdata_size = chunk->size; if (bsp->visdata_size > 0) { - bsp->visdata = malloc(bsp->visdata_size); + bsp->visdata = pxl8_malloc(bsp->visdata_size); memcpy(bsp->visdata, file_data + chunk->offset, bsp->visdata_size); } @@ -312,11 +313,11 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { if (!validate_chunk(chunk, 1, file_size)) goto error_cleanup; bsp->lightdata_size = chunk->size; if (bsp->lightdata_size > 0) { - bsp->lightdata = malloc(bsp->lightdata_size); + bsp->lightdata = pxl8_malloc(bsp->lightdata_size); memcpy(bsp->lightdata, file_data + chunk->offset, bsp->lightdata_size); } - free(file_data); + pxl8_free(file_data); for (u32 i = 0; i < bsp->num_faces; i++) { pxl8_bsp_face* face = &bsp->faces[i]; @@ -350,7 +351,7 @@ pxl8_result pxl8_bsp_load(const char* path, pxl8_bsp* bsp) { error_cleanup: pxl8_error("BSP chunk validation failed: %s", path); - free(file_data); + pxl8_free(file_data); pxl8_bsp_destroy(bsp); return PXL8_ERROR_INVALID_FORMAT; } @@ -358,21 +359,21 @@ error_cleanup: void pxl8_bsp_destroy(pxl8_bsp* bsp) { if (!bsp) return; - free(bsp->cell_portals); - free(bsp->edges); - free(bsp->faces); - free(bsp->leafs); - free(bsp->lightdata); - free(bsp->marksurfaces); - free(bsp->materials); - free(bsp->models); - free(bsp->nodes); - free(bsp->planes); - free(bsp->render_face_flags); - free(bsp->surfedges); - free(bsp->vertex_lights); - free(bsp->vertices); - free(bsp->visdata); + pxl8_free(bsp->cell_portals); + pxl8_free(bsp->edges); + pxl8_free(bsp->faces); + pxl8_free(bsp->leafs); + pxl8_free(bsp->lightdata); + pxl8_free(bsp->marksurfaces); + pxl8_free(bsp->materials); + pxl8_free(bsp->models); + pxl8_free(bsp->nodes); + pxl8_free(bsp->planes); + pxl8_free(bsp->render_face_flags); + pxl8_free(bsp->surfedges); + pxl8_free(bsp->vertex_lights); + pxl8_free(bsp->vertices); + pxl8_free(bsp->visdata); memset(bsp, 0, sizeof(*bsp)); } @@ -434,7 +435,7 @@ pxl8_bsp_pvs pxl8_bsp_decompress_pvs(const pxl8_bsp* bsp, i32 leaf) { pxl8_bsp_pvs pvs = {0}; u32 row = (bsp->num_leafs + 7) >> 3; - pvs.data = malloc(row); + pvs.data = pxl8_malloc(row); pvs.size = row; if (!pvs.data) return pvs; @@ -472,7 +473,7 @@ pxl8_bsp_pvs pxl8_bsp_decompress_pvs(const pxl8_bsp* bsp, i32 leaf) { void pxl8_bsp_pvs_destroy(pxl8_bsp_pvs* pvs) { if (pvs) { - free(pvs->data); + pxl8_free(pvs->data); pvs->data = NULL; pvs->size = 0; } @@ -756,7 +757,7 @@ void pxl8_bsp_render(pxl8_gfx* gfx, const pxl8_bsp* bsp, pxl8_vec3 camera_pos) { pxl8_bsp* bsp_mut = (pxl8_bsp*)bsp; if (!bsp_mut->render_face_flags) { - bsp_mut->render_face_flags = calloc(bsp->num_faces, 1); + bsp_mut->render_face_flags = pxl8_calloc(bsp->num_faces, 1); if (!bsp_mut->render_face_flags) return; } memset(bsp_mut->render_face_flags, 0, bsp->num_faces); @@ -764,13 +765,13 @@ void pxl8_bsp_render(pxl8_gfx* gfx, const pxl8_bsp* bsp, pxl8_vec3 camera_pos) { pxl8_bsp_pvs pvs = pxl8_bsp_decompress_pvs(bsp, camera_leaf); u32 visited_bytes = (bsp->num_leafs + 7) / 8; - u8* visited = calloc(visited_bytes, 1); - screen_rect* cell_windows = calloc(bsp->num_leafs, sizeof(screen_rect)); - portal_queue_entry* queue = malloc(bsp->num_leafs * 4 * sizeof(portal_queue_entry)); + u8* visited = pxl8_calloc(visited_bytes, 1); + screen_rect* cell_windows = pxl8_calloc(bsp->num_leafs, sizeof(screen_rect)); + portal_queue_entry* queue = pxl8_malloc(bsp->num_leafs * 4 * sizeof(portal_queue_entry)); if (!visited || !cell_windows || !queue) { - free(visited); - free(cell_windows); - free(queue); + pxl8_free(visited); + pxl8_free(cell_windows); + pxl8_free(queue); pxl8_bsp_pvs_destroy(&pvs); return; } @@ -829,9 +830,9 @@ void pxl8_bsp_render(pxl8_gfx* gfx, const pxl8_bsp* bsp, pxl8_vec3 camera_pos) { pxl8_mesh* mesh = pxl8_mesh_create(8192, 16384); if (!mesh) { - free(visited); - free(cell_windows); - free(queue); + pxl8_free(visited); + pxl8_free(cell_windows); + pxl8_free(queue); return; } @@ -890,8 +891,8 @@ void pxl8_bsp_render(pxl8_gfx* gfx, const pxl8_bsp* bsp, pxl8_vec3 camera_pos) { } pxl8_bsp_pvs_destroy(&pvs); - free(visited); - free(cell_windows); - free(queue); + pxl8_free(visited); + pxl8_free(cell_windows); + pxl8_free(queue); pxl8_mesh_destroy(mesh); } diff --git a/src/world/pxl8_gen.c b/src/world/pxl8_gen.c index 7880c4b..d9308b8 100644 --- a/src/world/pxl8_gen.c +++ b/src/world/pxl8_gen.c @@ -5,6 +5,7 @@ #include #include "pxl8_log.h" +#include "pxl8_mem.h" #include "pxl8_rng.h" #define CELL_SIZE 64.0f @@ -33,7 +34,7 @@ typedef struct light_source { static bool room_grid_init(room_grid* grid, i32 width, i32 height) { grid->width = width; grid->height = height; - grid->cells = calloc(width * height, sizeof(u8)); + grid->cells = pxl8_calloc(width * height, sizeof(u8)); return grid->cells != NULL; } @@ -126,7 +127,7 @@ static void compute_bsp_vertex_lighting( ) { if (!bsp || bsp->num_vertices == 0) return; - bsp->vertex_lights = calloc(bsp->num_vertices, sizeof(u32)); + bsp->vertex_lights = pxl8_calloc(bsp->num_vertices, sizeof(u32)); if (!bsp->vertex_lights) return; bsp->num_vertex_lights = bsp->num_vertices; @@ -169,7 +170,7 @@ static void compute_bsp_vertex_lighting( static pxl8_bsp_cell_portals* build_pxl8_bsp_cell_portals(const room_grid* grid, f32 cell_size) { i32 total_cells = grid->width * grid->height; - pxl8_bsp_cell_portals* portals = calloc(total_cells, sizeof(pxl8_bsp_cell_portals)); + pxl8_bsp_cell_portals* portals = pxl8_calloc(total_cells, sizeof(pxl8_bsp_cell_portals)); if (!portals) return NULL; for (i32 y = 0; y < grid->height; y++) { @@ -235,11 +236,11 @@ static void portal_flood_bfs( (void)grid_width; u32 pvs_bytes = (num_leafs + 7) / 8; - u8* visited = calloc(pvs_bytes, 1); - flood_entry* queue = malloc(num_leafs * sizeof(flood_entry)); + u8* visited = pxl8_calloc(pvs_bytes, 1); + flood_entry* queue = pxl8_malloc(num_leafs * sizeof(flood_entry)); if (!visited || !queue) { - free(visited); - free(queue); + pxl8_free(visited); + pxl8_free(queue); return; } @@ -271,15 +272,15 @@ static void portal_flood_bfs( } } - free(visited); - free(queue); + pxl8_free(visited); + pxl8_free(queue); } static u8* compute_leaf_pvs(u32 start_leaf, const pxl8_bsp_cell_portals* portals, u32 num_leafs, const pxl8_bsp_leaf* leafs, const room_grid* grid, f32 cell_size) { u32 pvs_bytes = (num_leafs + 7) / 8; - u8* pvs = calloc(pvs_bytes, 1); + u8* pvs = pxl8_calloc(pvs_bytes, 1); if (!pvs) return NULL; portal_flood_bfs(start_leaf, portals, leafs, pvs, num_leafs, cell_size, grid->width); @@ -313,14 +314,14 @@ static pxl8_result build_pvs_data(pxl8_bsp* bsp, const pxl8_bsp_cell_portals* po u32 pvs_bytes = (num_leafs + 7) / 8; u32 max_visdata = num_leafs * pvs_bytes * 2; - u8* visdata = malloc(max_visdata); + u8* visdata = pxl8_malloc(max_visdata); if (!visdata) return PXL8_ERROR_OUT_OF_MEMORY; u32 visdata_pos = 0; - u8* compressed = malloc(pvs_bytes * 2); + u8* compressed = pxl8_malloc(pvs_bytes * 2); if (!compressed) { - free(visdata); + pxl8_free(visdata); return PXL8_ERROR_OUT_OF_MEMORY; } @@ -333,8 +334,8 @@ static pxl8_result build_pvs_data(pxl8_bsp* bsp, const pxl8_bsp_cell_portals* po u8* pvs = compute_leaf_pvs(leaf, portals, num_leafs, bsp->leafs, grid, cell_size); if (!pvs) { - free(compressed); - free(visdata); + pxl8_free(compressed); + pxl8_free(visdata); return PXL8_ERROR_OUT_OF_MEMORY; } @@ -355,11 +356,11 @@ static pxl8_result build_pvs_data(pxl8_bsp* bsp, const pxl8_bsp_cell_portals* po memcpy(visdata + visdata_pos, compressed, compressed_size); visdata_pos += compressed_size; - free(pvs); + pxl8_free(pvs); } - free(compressed); - bsp->visdata = realloc(visdata, visdata_pos > 0 ? visdata_pos : 1); + pxl8_free(compressed); + bsp->visdata = pxl8_realloc(visdata, visdata_pos > 0 ? visdata_pos : 1); bsp->visdata_size = visdata_pos; pxl8_debug("Built PVS: %u leafs, %u bytes visdata", num_leafs, visdata_pos); @@ -429,18 +430,18 @@ static pxl8_result grid_to_bsp(pxl8_bsp* bsp, const room_grid* grid) { u32 max_nodes = 2 * total_cells; u32 total_planes = face_count + max_nodes; - bsp->vertices = calloc(vertex_count, sizeof(pxl8_bsp_vertex)); - bsp->faces = calloc(face_count, sizeof(pxl8_bsp_face)); - bsp->planes = calloc(total_planes, sizeof(pxl8_bsp_plane)); - bsp->edges = calloc(vertex_count, sizeof(pxl8_bsp_edge)); - bsp->surfedges = calloc(vertex_count, sizeof(i32)); - bsp->nodes = calloc(max_nodes, sizeof(pxl8_bsp_node)); + bsp->vertices = pxl8_calloc(vertex_count, sizeof(pxl8_bsp_vertex)); + bsp->faces = pxl8_calloc(face_count, sizeof(pxl8_bsp_face)); + bsp->planes = pxl8_calloc(total_planes, sizeof(pxl8_bsp_plane)); + bsp->edges = pxl8_calloc(vertex_count, sizeof(pxl8_bsp_edge)); + bsp->surfedges = pxl8_calloc(vertex_count, sizeof(i32)); + bsp->nodes = pxl8_calloc(max_nodes, sizeof(pxl8_bsp_node)); - u32* face_cell = calloc(face_count, sizeof(u32)); + u32* face_cell = pxl8_calloc(face_count, sizeof(u32)); if (!bsp->vertices || !bsp->faces || !bsp->planes || !bsp->edges || !bsp->surfedges || !bsp->nodes || !face_cell) { - free(face_cell); + pxl8_free(face_cell); return PXL8_ERROR_OUT_OF_MEMORY; } @@ -617,26 +618,26 @@ static pxl8_result grid_to_bsp(pxl8_bsp* bsp, const room_grid* grid) { bsp->num_edges = vertex_count; bsp->num_surfedges = vertex_count; - bsp->leafs = calloc(total_cells, sizeof(pxl8_bsp_leaf)); - bsp->marksurfaces = calloc(face_count, sizeof(u16)); + bsp->leafs = pxl8_calloc(total_cells, sizeof(pxl8_bsp_leaf)); + bsp->marksurfaces = pxl8_calloc(face_count, sizeof(u16)); if (!bsp->leafs || !bsp->marksurfaces) { - free(face_cell); + pxl8_free(face_cell); return PXL8_ERROR_OUT_OF_MEMORY; } bsp->num_leafs = total_cells; bsp->num_marksurfaces = face_count; - u32* faces_per_cell = calloc(total_cells, sizeof(u32)); - u32* cell_offset = calloc(total_cells, sizeof(u32)); - u32* cell_cursor = calloc(total_cells, sizeof(u32)); + u32* faces_per_cell = pxl8_calloc(total_cells, sizeof(u32)); + u32* cell_offset = pxl8_calloc(total_cells, sizeof(u32)); + u32* cell_cursor = pxl8_calloc(total_cells, sizeof(u32)); if (!faces_per_cell || !cell_offset || !cell_cursor) { - free(faces_per_cell); - free(cell_offset); - free(cell_cursor); - free(face_cell); + pxl8_free(faces_per_cell); + pxl8_free(cell_offset); + pxl8_free(cell_cursor); + pxl8_free(face_cell); return PXL8_ERROR_OUT_OF_MEMORY; } @@ -683,10 +684,10 @@ static pxl8_result grid_to_bsp(pxl8_bsp* bsp, const room_grid* grid) { } } - free(faces_per_cell); - free(cell_offset); - free(cell_cursor); - free(face_cell); + pxl8_free(faces_per_cell); + pxl8_free(cell_offset); + pxl8_free(cell_cursor); + pxl8_free(face_cell); bsp_build_context ctx = { .bsp = bsp, @@ -722,8 +723,8 @@ static pxl8_result grid_to_bsp(pxl8_bsp* bsp, const room_grid* grid) { if (first_walkable >= 0) { u32 pvs_bytes = (total_cells + 7) / 8; - u8* visited = calloc(pvs_bytes, 1); - u8* queue = malloc(total_cells * sizeof(u32)); + u8* visited = pxl8_calloc(pvs_bytes, 1); + u8* queue = pxl8_malloc(total_cells * sizeof(u32)); u32 head = 0, tail = 0; ((u32*)queue)[tail++] = first_walkable; visited[first_walkable >> 3] |= (1 << (first_walkable & 7)); @@ -742,13 +743,13 @@ static pxl8_result grid_to_bsp(pxl8_bsp* bsp, const room_grid* grid) { } pxl8_debug("Connectivity: %u/%u walkable cells reachable from leaf %d", reachable, walkable_cells, first_walkable); - free(visited); - free(queue); + pxl8_free(visited); + pxl8_free(queue); } pxl8_result pvs_result = build_pvs_data(bsp, portals, grid, cell_size); if (pvs_result != PXL8_OK) { - free(portals); + pxl8_free(portals); return pvs_result; } @@ -852,7 +853,7 @@ static pxl8_result procgen_rooms(pxl8_bsp* bsp, const pxl8_procgen_params* param params->width, params->height, room_count); pxl8_result result = grid_to_bsp(bsp, &grid); - free(grid.cells); + pxl8_free(grid.cells); if (result != PXL8_OK) { return result; diff --git a/src/world/pxl8_world.c b/src/world/pxl8_world.c index c27f086..b4d1840 100644 --- a/src/world/pxl8_world.c +++ b/src/world/pxl8_world.c @@ -7,6 +7,7 @@ #include "pxl8_gen.h" #include "pxl8_log.h" #include "pxl8_math.h" +#include "pxl8_mem.h" struct pxl8_world { pxl8_bsp bsp; @@ -14,7 +15,7 @@ struct pxl8_world { }; pxl8_world* pxl8_world_create(void) { - pxl8_world* world = (pxl8_world*)calloc(1, sizeof(pxl8_world)); + pxl8_world* world = (pxl8_world*)pxl8_calloc(1, sizeof(pxl8_world)); if (!world) { pxl8_error("Failed to allocate world"); return NULL; @@ -32,7 +33,7 @@ void pxl8_world_destroy(pxl8_world* world) { pxl8_bsp_destroy(&world->bsp); } - free(world); + pxl8_free(world); } pxl8_result pxl8_world_generate(pxl8_world* world, pxl8_gfx* gfx, const pxl8_procgen_params* params) { @@ -96,7 +97,7 @@ pxl8_result pxl8_world_apply_textures(pxl8_world* world, const pxl8_world_textur pxl8_bsp* bsp = &world->bsp; u32 max_materials = count * 6; - bsp->materials = calloc(max_materials, sizeof(pxl8_gfx_material)); + bsp->materials = pxl8_calloc(max_materials, sizeof(pxl8_gfx_material)); if (!bsp->materials) { return PXL8_ERROR_OUT_OF_MEMORY; }