jacob/power_play
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove buffer struct, use string struct instead

Browse Source
This commit is contained in:
jacob 2025-01-30 15:12:26 -06:00
parent a1a1430fd8
commit d7f1ac06cb
44 changed files with 383 additions and 403 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/app.c
View File

@ -50,7 +50,7 @@ INTERNAL struct string initialize_write_directory(struct arena *arena, struct st
/* Create write path */ /* Create write path */
struct string base_write_dir = sys_get_write_path(scratch.arena); struct string base_write_dir = sys_get_write_path(scratch.arena);
struct string write_path_fmt = base_write_dir.len > 0 ? STR("%F/%F/") : STR("%F%F/"); struct string write_path_fmt = base_write_dir.len > 0 ? LIT("%F/%F/") : LIT("%F%F/");
struct string write_path = string_format( struct string write_path = string_format(
arena, arena,
write_path_fmt, write_path_fmt,
@ -148,12 +148,12 @@ void app_entry_point(void)
#endif #endif
} }
G.write_path = initialize_write_directory(&G.arena, STR(WRITE_DIR)); G.write_path = initialize_write_directory(&G.arena, LIT(WRITE_DIR));
/* Startup logging */ /* Startup logging */
{ {
struct temp_arena temp = arena_temp_begin(scratch.arena); struct temp_arena temp = arena_temp_begin(scratch.arena);
struct string logfile_path = app_write_path_cat(temp.arena, STR("log.txt")); struct string logfile_path = app_write_path_cat(temp.arena, LIT("log.txt"));
struct log_startup_receipt log_sr = log_startup(logfile_path); struct log_startup_receipt log_sr = log_startup(logfile_path);
(UNUSED)log_sr; (UNUSED)log_sr;
logf_info("Start of logs"); logf_info("Start of logs");
@ -168,20 +168,20 @@ void app_entry_point(void)
struct temp_arena temp = arena_temp_begin(scratch.arena); struct temp_arena temp = arena_temp_begin(scratch.arena);
struct sys_window_settings window_settings = ZI; struct sys_window_settings window_settings = ZI;
struct string settings_path = app_write_path_cat(temp.arena, STR(SETTINGS_FILENAME)); struct string settings_path = app_write_path_cat(temp.arena, LIT(SETTINGS_FILENAME));
logf_info("Looking for settings file \"%F\"", FMT_STR(settings_path)); logf_info("Looking for settings file \"%F\"", FMT_STR(settings_path));
if (sys_is_file(settings_path)) { if (sys_is_file(settings_path)) {
logf_info("Settings file found"); logf_info("Settings file found");
struct sys_file settings_file = sys_file_open_read(settings_path); struct sys_file settings_file = sys_file_open_read(settings_path);
struct buffer file_data = sys_file_read_all(temp.arena, settings_file); struct string file_data = sys_file_read_all(temp.arena, settings_file);
sys_file_close(settings_file); sys_file_close(settings_file);
logf_info("Deserializing settings file data: %F", FMT_STR(STRING_FROM_BUFFER(file_data))); logf_info("Deserializing settings file data: %F", FMT_STR(file_data));
struct string error = ZI; struct string error = ZI;
struct sys_window_settings *res = settings_deserialize(temp.arena, file_data, &error); struct sys_window_settings *res = settings_deserialize(temp.arena, file_data, &error);
if (error.len > 0) { if (error.len > 0) {
logf_info("Failed to load settings file with error - %F", FMT_STR(error)); logf_info("Failed to load settings file with error - %F", FMT_STR(error));
struct string msg = string_format(temp.arena, struct string msg = string_format(temp.arena,
STR( LIT(
"Failed to loading settings file \"%F\":\n" "Failed to loading settings file \"%F\":\n"
"------------\n" "------------\n"
"%F\n" "%F\n"
@ -198,7 +198,7 @@ void app_entry_point(void)
logf_info("Settings file not found, loading default"); logf_info("Settings file not found, loading default");
window_settings = default_window_settings(&window); window_settings = default_window_settings(&window);
} }
string_copy_buff(BUFFER_FROM_ARRAY(window_settings.title), STR(WINDOW_TITLE)); string_copy_to_string(STRING_FROM_ARRAY(window_settings.title), LIT(WINDOW_TITLE));
sys_window_update_settings(&window, &window_settings); sys_window_update_settings(&window, &window_settings);
arena_temp_end(temp); arena_temp_end(temp);
@ -240,7 +240,7 @@ void app_entry_point(void)
/* Start callback threads */ /* Start callback threads */
for (struct exit_callback *callback = G.exit_callbacks_head; callback; callback = callback->next) { for (struct exit_callback *callback = G.exit_callbacks_head; callback; callback = callback->next) {
callback->thread = sys_thread_alloc(&exit_callback_thread_entry_point, callback, STR("[P4] Exit callback thread")); callback->thread = sys_thread_alloc(&exit_callback_thread_entry_point, callback, LIT("[P4] Exit callback thread"));
} }
/* Wait on callback threads */ /* Wait on callback threads */
@ -255,15 +255,15 @@ void app_entry_point(void)
{ {
struct temp_arena temp = arena_temp_begin(scratch.arena); struct temp_arena temp = arena_temp_begin(scratch.arena);
struct string window_settings_path = app_write_path_cat(temp.arena, STR(SETTINGS_FILENAME)); struct string window_settings_path = app_write_path_cat(temp.arena, LIT(SETTINGS_FILENAME));
struct sys_window_settings settings = sys_window_get_settings(&window); struct sys_window_settings settings = sys_window_get_settings(&window);
struct buffer buff = settings_serialize(temp.arena, &settings); struct string str = settings_serialize(temp.arena, &settings);
logf_info("Serialized window settings: %F", FMT_STR(STRING_FROM_BUFFER(buff))); logf_info("Serialized window settings: %F", FMT_STR(str));
logf_info("Writing settings file to path \"%F\"", FMT_STR(window_settings_path)); logf_info("Writing settings file to path \"%F\"", FMT_STR(window_settings_path));
struct sys_file settings_file = sys_file_open_write(window_settings_path); struct sys_file settings_file = sys_file_open_write(window_settings_path);
sys_file_write(settings_file, buff); sys_file_write(settings_file, str);
sys_file_close(settings_file); sys_file_close(settings_file);
logf_info("Finished writing settings file"); logf_info("Finished writing settings file");

8
src/arena.c
View File

@ -22,7 +22,7 @@ struct arena arena_alloc(u64 reserve)
arena.base = sys_memory_reserve(reserve); arena.base = sys_memory_reserve(reserve);
if (!arena.base) { if (!arena.base) {
/* Hard fail on memory reserve failure for now */ /* Hard fail on memory reserve failure for now */
sys_panic(STR("Failed to reserve memory")); sys_panic(LIT("Failed to reserve memory"));
} }
arena.reserved = reserve; arena.reserved = reserve;
@ -32,7 +32,7 @@ struct arena arena_alloc(u64 reserve)
ASAN_POISON(arena.base, ARENA_BLOCK_SIZE); ASAN_POISON(arena.base, ARENA_BLOCK_SIZE);
if (!arena.base) { if (!arena.base) {
/* Hard fail on commit failure */ /* Hard fail on commit failure */
sys_panic(STR("Failed to commit initial memory block: System may be out of memory")); sys_panic(LIT("Failed to commit initial memory block: System may be out of memory"));
} }
arena.committed = ARENA_BLOCK_SIZE; arena.committed = ARENA_BLOCK_SIZE;
@ -72,12 +72,12 @@ void *_arena_push_bytes(struct arena *arena, u64 size, u64 align)
u64 new_capacity = arena->committed + commit_bytes; u64 new_capacity = arena->committed + commit_bytes;
if (new_capacity > arena->reserved) { if (new_capacity > arena->reserved) {
/* Hard fail if we overflow reserved memory for now */ /* Hard fail if we overflow reserved memory for now */
sys_panic(STR("Failed to commit new memory block: Overflow of reserved memory")); sys_panic(LIT("Failed to commit new memory block: Overflow of reserved memory"));
} }
void *commit_address = arena->base + arena->committed; void *commit_address = arena->base + arena->committed;
if (!sys_memory_commit(commit_address, commit_bytes)) { if (!sys_memory_commit(commit_address, commit_bytes)) {
/* Hard fail on memory allocation failure for now */ /* Hard fail on memory allocation failure for now */
sys_panic(STR("Failed to commit new memory block: System may be out of memory")); sys_panic(LIT("Failed to commit new memory block: System may be out of memory"));
} }
__proffree(arena->base); __proffree(arena->base);
__profalloc(arena->base, arena->committed + commit_bytes); __profalloc(arena->base, arena->committed + commit_bytes);

8
src/arena.h
View File

@ -102,11 +102,11 @@ INLINE void arena_reset(struct arena *arena)
arena_pop_to(arena, 0); arena_pop_to(arena, 0);
} }
INLINE struct buffer arena_to_buffer(struct arena *arena) INLINE struct string arena_to_string(struct arena *arena)
{ {
struct buffer b; struct string b;
b.data = arena->base; b.text = arena->base;
b.size = arena->pos; b.len = arena->pos;
return b; return b;
} }

14
src/ase.c
View File

@ -270,7 +270,7 @@ INTERNAL void inflate(u8 *dest, u8 *encoded)
u8 btype = consume_bits(&bb, 2); u8 btype = consume_bits(&bb, 2);
switch (btype) { switch (btype) {
case BLOCK_TYPE_UNCOMPRESSED: { case BLOCK_TYPE_UNCOMPRESSED: {
sys_panic(STR("Unsupported block type while inflating ase: BLOCK_TYPE_UNCOMPRESSED")); sys_panic(LIT("Unsupported block type while inflating ase: BLOCK_TYPE_UNCOMPRESSED"));
} break; } break;
case BLOCK_TYPE_COMPRESSED_FIXED: case BLOCK_TYPE_COMPRESSED_FIXED:
@ -551,7 +551,7 @@ INTERNAL void make_image_dimensions_squareish(struct ase_header *header, u32 *fr
} }
} }
struct ase_decode_image_result ase_decode_image(struct arena *arena, struct buffer encoded) struct ase_decode_image_result ase_decode_image(struct arena *arena, struct string encoded)
{ {
__prof; __prof;
@ -563,13 +563,13 @@ struct ase_decode_image_result ase_decode_image(struct arena *arena, struct buff
br_read_to_struct(&br, &ase_header); br_read_to_struct(&br, &ase_header);
if (ase_header.magic != 0xA5E0) { if (ase_header.magic != 0xA5E0) {
push_error_copy_msg(arena, &res.errors, STR("Not a valid aseprite file")); push_error_copy_msg(arena, &res.errors, LIT("Not a valid aseprite file"));
goto abort; goto abort;
} }
if (ase_header.color_depth != 32) { if (ase_header.color_depth != 32) {
struct string msg = string_format(scratch.arena, struct string msg = string_format(scratch.arena,
STR("Only 32 bit rgba color mode is supported (got %F)"), LIT("Only 32 bit rgba color mode is supported (got %F)"),
FMT_UINT(ase_header.color_depth)); FMT_UINT(ase_header.color_depth));
push_error_copy_msg(arena, &res.errors, msg); push_error_copy_msg(arena, &res.errors, msg);
goto abort; goto abort;
@ -635,7 +635,7 @@ struct ase_decode_image_result ase_decode_image(struct arena *arena, struct buff
if (layer->blend_mode != 0) { if (layer->blend_mode != 0) {
push_error_copy_msg(arena, push_error_copy_msg(arena,
&res.errors, &res.errors,
STR("Layer has unsupported blend mode (only 'Normal' mode is supported). Tip: Try using 'merge down' to create a normal layer as a workaround")); LIT("Layer has unsupported blend mode (only 'Normal' mode is supported). Tip: Try using 'merge down' to create a normal layer as a workaround"));
goto abort; goto abort;
} }
@ -706,7 +706,7 @@ struct ase_decode_image_result ase_decode_image(struct arena *arena, struct buff
case CEL_TYPE_COMPRESSED_TILEMAP: { case CEL_TYPE_COMPRESSED_TILEMAP: {
/* Unsupported */ /* Unsupported */
push_error_copy_msg(arena, &res.errors, STR("Tilemaps are not supported")); push_error_copy_msg(arena, &res.errors, LIT("Tilemaps are not supported"));
goto abort; goto abort;
} break; } break;
} }
@ -814,7 +814,7 @@ struct ase_decode_image_result ase_decode_image(struct arena *arena, struct buff
* Decode sheet * Decode sheet
* ========================== */ * ========================== */
struct ase_decode_sheet_result ase_decode_sheet(struct arena *arena, struct buffer encoded) struct ase_decode_sheet_result ase_decode_sheet(struct arena *arena, struct string encoded)
{ {
__prof; __prof;

4
src/ase.h
View File

@ -62,7 +62,7 @@ struct ase_decode_sheet_result {
struct ase_error_list errors; struct ase_error_list errors;
}; };
struct ase_decode_image_result ase_decode_image(struct arena *arena, struct buffer encoded); struct ase_decode_image_result ase_decode_image(struct arena *arena, struct string encoded);
struct ase_decode_sheet_result ase_decode_sheet(struct arena *arena, struct buffer encoded); struct ase_decode_sheet_result ase_decode_sheet(struct arena *arena, struct string encoded);
#endif #endif

4
src/asset_cache.c
View File

@ -103,7 +103,7 @@ INTERNAL struct asset *asset_cache_get_slot_locked(struct sys_lock *lock, struct
u64 asset_cache_hash(struct string key) u64 asset_cache_hash(struct string key)
{ {
/* TODO: Better hash */ /* TODO: Better hash */
return hash_fnv64(HASH_FNV64_BASIS, BUFFER_FROM_STRING(key)); return hash_fnv64(HASH_FNV64_BASIS, key);
} }
/* `key` text is copied by this function /* `key` text is copied by this function
@ -137,7 +137,7 @@ struct asset *asset_cache_touch(struct string key, u64 hash, b32 *is_first_touch
if (!asset->hash) { if (!asset->hash) {
if (G.num_assets >= MAX_ASSETS) { if (G.num_assets >= MAX_ASSETS) {
sys_panic(STR("Max assets reached")); sys_panic(LIT("Max assets reached"));
} }
struct string key_stored = ZI; struct string key_stored = ZI;
{ {

38
src/byteio.c
View File

@ -13,7 +13,7 @@ INTERNAL b32 write_check_overflow(struct byte_writer *bw, i64 amount)
overflowed = true; overflowed = true;
bw->overflowed = true; bw->overflowed = true;
} else { } else {
u8 *end = bw->buff.data + bw->buff.size; u8 *end = bw->buff.text + bw->buff.len;
u8 *new_pos = bw->at + amount; u8 *new_pos = bw->at + amount;
i64 new_space_left = end - new_pos; i64 new_space_left = end - new_pos;
if (new_space_left < 0) { if (new_space_left < 0) {
@ -21,7 +21,7 @@ INTERNAL b32 write_check_overflow(struct byte_writer *bw, i64 amount)
if (arena) { if (arena) {
if ((arena->base + arena->pos) == end) { if ((arena->base + arena->pos) == end) {
arena_push_array(arena, u8, -new_space_left); arena_push_array(arena, u8, -new_space_left);
bw->buff.size += -new_space_left; bw->buff.len += -new_space_left;
} else { } else {
/* Writer memory must be contiguous in arena */ /* Writer memory must be contiguous in arena */
overflowed = true; overflowed = true;
@ -46,11 +46,11 @@ INTERNAL void write(struct byte_writer *bw, void *v, u64 size)
bw->at += size; bw->at += size;
} }
struct byte_writer bw_from_buffer(struct buffer buff) struct byte_writer bw_from_buffer(struct string buff)
{ {
struct byte_writer bw = ZI; struct byte_writer bw = ZI;
bw.buff = buff; bw.buff = buff;
bw.at = buff.data; bw.at = buff.text;
return bw; return bw;
} }
@ -59,16 +59,16 @@ struct byte_writer bw_from_arena(struct arena *arena)
{ {
struct byte_writer bw = ZI; struct byte_writer bw = ZI;
bw.arena = arena; bw.arena = arena;
bw.buff.data = arena->base + arena->pos; bw.buff.text = arena->base + arena->pos;
bw.buff.size = 0; bw.buff.len = 0;
bw.at = bw.buff.data; bw.at = bw.buff.text;
return bw; return bw;
} }
/* Seeks forward and returns a new writer pointing to the skipped bytes */ /* Seeks forward and returns a new writer pointing to the skipped bytes */
struct byte_writer bw_branch(struct byte_writer *bw, u64 size) struct byte_writer bw_branch(struct byte_writer *bw, u64 size)
{ {
struct buffer buff = BUFFER(size, bw->at); struct string buff = STRING(size, bw->at);
struct byte_writer branch = bw_from_buffer(buff); struct byte_writer branch = bw_from_buffer(buff);
bw_seek(bw, size); bw_seek(bw, size);
branch.overflowed = bw->overflowed; branch.overflowed = bw->overflowed;
@ -85,15 +85,15 @@ void bw_seek(struct byte_writer *bw, u64 amount)
void bw_seek_to(struct byte_writer *bw, u64 pos) void bw_seek_to(struct byte_writer *bw, u64 pos)
{ {
if (write_check_overflow(bw, (i64)pos - (i64)(bw->at - bw->buff.data))) { if (write_check_overflow(bw, (i64)pos - (i64)(bw->at - bw->buff.text))) {
return; return;
} }
bw->at = bw->buff.data + pos; bw->at = bw->buff.text + pos;
} }
void bw_write_buffer(struct byte_writer *bw, struct buffer buff) void bw_write_string(struct byte_writer *bw, struct string s)
{ {
write(bw, buff.data, buff.size); write(bw, s.text, s.len);
} }
void bw_write_u8(struct byte_writer *bw, u8 v) void bw_write_u8(struct byte_writer *bw, u8 v)
@ -171,7 +171,7 @@ void bw_write_v2(struct byte_writer *bw, struct v2 v)
INTERNAL b32 read_check_overflow(struct byte_reader *br, i64 amount) INTERNAL b32 read_check_overflow(struct byte_reader *br, i64 amount)
{ {
b32 overflowed = br->overflowed; b32 overflowed = br->overflowed;
if (overflowed || amount < 0 || (br->at + amount) > (br->buff.data + br->buff.size) ){ if (overflowed || amount < 0 || (br->at + amount) > (br->buff.text + br->buff.len) ){
ASSERT(false); ASSERT(false);
br->overflowed = true; br->overflowed = true;
overflowed = true; overflowed = true;
@ -188,11 +188,11 @@ INTERNAL void read(struct byte_reader *br, void *dst, u64 size)
br->at += size; br->at += size;
} }
struct byte_reader br_from_buffer(struct buffer buff) struct byte_reader br_from_buffer(struct string buff)
{ {
struct byte_reader br = ZI; struct byte_reader br = ZI;
br.buff = buff; br.buff = buff;
br.at = buff.data; br.at = buff.text;
return br; return br;
} }
@ -212,18 +212,18 @@ void *br_seek(struct byte_reader *br, u64 amount)
void *br_seek_to(struct byte_reader *br, u64 pos) void *br_seek_to(struct byte_reader *br, u64 pos)
{ {
void *ptr = NULL; void *ptr = NULL;
if (read_check_overflow(br, (i64)pos - (i64)(br->at - br->buff.data))) { if (read_check_overflow(br, (i64)pos - (i64)(br->at - br->buff.text))) {
return ptr; return ptr;
} }
ptr = br->at; ptr = br->at;
br->at = br->buff.data + pos; br->at = br->buff.text + pos;
return ptr; return ptr;
} }
/* Will fill buff with zeroes on overflow */ /* Will fill buff with zeroes on overflow */
void br_read_to_buffer(struct byte_reader *br, struct buffer buff) void br_read_to_string(struct byte_reader *br, struct string buff)
{ {
read(br, buff.data, buff.size); read(br, buff.text, buff.len);
} }
u8 br_read_u8(struct byte_reader *br) u8 br_read_u8(struct byte_reader *br)

30
src/byteio.h
View File

@ -3,13 +3,13 @@
struct byte_writer { struct byte_writer {
struct arena *arena; /* If arena is set, then the writer cannot overflow and will instead allocate more memory as it grows */ struct arena *arena; /* If arena is set, then the writer cannot overflow and will instead allocate more memory as it grows */
struct buffer buff; struct string buff;
b32 overflowed; b32 overflowed;
u8 *at; u8 *at;
}; };
struct byte_reader { struct byte_reader {
struct buffer buff; struct string buff;
b32 overflowed; b32 overflowed;
u8 *at; u8 *at;
}; };
@ -18,14 +18,14 @@ struct byte_reader {
* Writer * Writer
* ========================== */ * ========================== */
struct byte_writer bw_from_buffer(struct buffer buff); struct byte_writer bw_from_buffer(struct string buff);
struct byte_writer bw_from_arena(struct arena *arena); struct byte_writer bw_from_arena(struct arena *arena);
struct byte_writer bw_branch(struct byte_writer *bw, u64 size); struct byte_writer bw_branch(struct byte_writer *bw, u64 size);
void bw_seek(struct byte_writer *bw, u64 amount); void bw_seek(struct byte_writer *bw, u64 amount);
void bw_seek_to(struct byte_writer *bw, u64 pos); void bw_seek_to(struct byte_writer *bw, u64 pos);
void bw_write_buffer(struct byte_writer *bw, struct buffer buff); void bw_write_string(struct byte_writer *bw, struct string s);
void bw_write_u8(struct byte_writer *bw, u8 v); void bw_write_u8(struct byte_writer *bw, u8 v);
void bw_write_u16(struct byte_writer *bw, u16 v); void bw_write_u16(struct byte_writer *bw, u16 v);
void bw_write_u32(struct byte_writer *bw, u32 v); void bw_write_u32(struct byte_writer *bw, u32 v);
@ -40,18 +40,18 @@ void bw_write_f32(struct byte_writer *bw, f32 v);
void bw_write_f64(struct byte_writer *bw, f64 v); void bw_write_f64(struct byte_writer *bw, f64 v);
void bw_write_v2(struct byte_writer *bw, struct v2 v); void bw_write_v2(struct byte_writer *bw, struct v2 v);
/* Returns a buffer containing written bytes only */ /* Returns a string containing written bytes only */
INLINE struct buffer bw_get_written(struct byte_writer *bw) INLINE struct string bw_get_written(struct byte_writer *bw)
{ {
struct buffer buff = ZI; struct string buff = ZI;
buff.data = bw->buff.data; buff.text = bw->buff.text;
buff.size = bw->at - bw->buff.data; buff.len = bw->at - bw->buff.text;
return buff; return buff;
} }
INLINE u64 bw_pos(struct byte_writer *bw) INLINE u64 bw_pos(struct byte_writer *bw)
{ {
return bw->at - bw->buff.data; return bw->at - bw->buff.text;
} }
/* ========================== * /* ========================== *
@ -59,14 +59,14 @@ INLINE u64 bw_pos(struct byte_writer *bw)
* ========================== */ * ========================== */
/* Will fill struct with zeroes on overflow */ /* Will fill struct with zeroes on overflow */
#define br_read_to_struct(br_ptr, var_ptr) (br_read_to_buffer(br_ptr, BUFFER(sizeof(*var_ptr), (u8 *)var_ptr))) #define br_read_to_struct(br_ptr, var_ptr) (br_read_to_string(br_ptr, STRING(sizeof(*var_ptr), (u8 *)var_ptr)))
struct byte_reader br_from_buffer(struct buffer buff); struct byte_reader br_from_buffer(struct string buff);
void *br_seek(struct byte_reader *br, u64 amount); void *br_seek(struct byte_reader *br, u64 amount);
void *br_seek_to(struct byte_reader *br, u64 pos); void *br_seek_to(struct byte_reader *br, u64 pos);
void br_read_to_buffer(struct byte_reader *br, struct buffer buff); void br_read_to_string(struct byte_reader *br, struct string s);
u8 br_read_u8(struct byte_reader *br); u8 br_read_u8(struct byte_reader *br);
u16 br_read_u16(struct byte_reader *br); u16 br_read_u16(struct byte_reader *br);
u32 br_read_u32(struct byte_reader *br); u32 br_read_u32(struct byte_reader *br);
@ -83,12 +83,12 @@ struct v2 br_read_v2(struct byte_reader *br);
INLINE u64 br_bytes_left(const struct byte_reader *br) INLINE u64 br_bytes_left(const struct byte_reader *br)
{ {
return br->overflowed ? 0 : br->buff.size - (br->at - br->buff.data); return br->overflowed ? 0 : br->buff.len - (br->at - br->buff.text);
} }
INLINE u64 br_pos(struct byte_reader *br) INLINE u64 br_pos(struct byte_reader *br)
{ {
return br->at - br->buff.data; return br->at - br->buff.text;
} }
#endif #endif

46
src/common.h
View File

@ -496,11 +496,6 @@ struct pcm {
i16 *samples; i16 *samples;
}; };
struct buffer {
u64 size;
u8 *data;
};
struct entity_handle { struct entity_handle {
u64 idx; u64 idx;
u64 gen; u64 gen;
@ -521,42 +516,31 @@ struct sprite_tag {
}; };
/* ========================== * /* ========================== *
* Buffer utils * String utils
* ========================== */ * ========================== */
/* Utility buffer constructor */ /* Expand C string literal with size for string initialization */
#define BUFFER(size, data) (CPPCOMPAT_INITLIST_TYPE(struct buffer) { (size), (data) }) #define LIT(cstr_lit) CPPCOMPAT_INITLIST_TYPE(struct string) { (sizeof((cstr_lit)) - 1), (u8 *)(cstr_lit) }
/* Utility buffer constructor from static array */ /* Same as `STR`, but works with static variable initialization */
#define BUFFER_FROM_ARRAY(a) \ #define LIT_NOCAST(cstr_lit) { .len = (sizeof((cstr_lit)) - 1), .text = (u8 *)(cstr_lit) }
#define STRING(size, data) (CPPCOMPAT_INITLIST_TYPE(struct string) { (size), (data) })
#define STRING_FROM_POINTERS(p0, p1) (CPPCOMPAT_INITLIST_TYPE(struct string) { (u8 *)(p1) - (u8 *)(p0), (u8 *)p0 })
#define STRING_FROM_STRUCT(ptr) (CPPCOMPAT_INITLIST_TYPE(struct string) { sizeof(*(ptr)), (u8 *)(ptr) })
/* String from static array */
#define STRING_FROM_ARRAY(a) \
( \ ( \
/* Must be array */ \ /* Must be array */ \
ASSERT(IS_ARRAY(a)), \ ASSERT(IS_ARRAY(a)), \
/* Must be array of bytes */ \ /* Must be array of bytes */ \
ASSERT(sizeof((a)[0]) == sizeof(u8)), \ ASSERT(sizeof((a)[0]) == sizeof(u8)), \
((struct buffer) { .size = ARRAY_COUNT(a), .data = (u8 *)(a) }) \ ((struct string) { .len = ARRAY_COUNT(a), .text = (u8 *)(a) }) \
) )
#define BUFFER_FROM_STRING(str) (CPPCOMPAT_INITLIST_TYPE(struct buffer) { (str).len, (str).text })
#define BUFFER_FROM_POINTERS(p0, p1) (CPPCOMPAT_INITLIST_TYPE(struct buffer) { (u8 *)(p1) - (u8 *)(p0), (u8 *)p0 })
#define BUFFER_FROM_STRUCT(ptr) (CPPCOMPAT_INITLIST_TYPE(struct buffer) { sizeof(*(ptr)), (u8 *)(ptr) })
/* ========================== *
* String utils
* ========================== */
/* Expand C string literal with size for string initialization */
#define STR(cstr_lit) CPPCOMPAT_INITLIST_TYPE(struct string) { (sizeof((cstr_lit)) - 1), (u8 *)(cstr_lit) }
/* Same as `STR`, but works with static variable initialization */
#define STR_NOCAST(cstr_lit) { .len = (sizeof((cstr_lit)) - 1), .text = (u8 *)(cstr_lit) }
#define STRING_FROM_BUFFER(buff) (CPPCOMPAT_INITLIST_TYPE(struct string) { buff.size, buff.data })
#define STRING_FROM_ARRAY(a) STRING_FROM_BUFFER(BUFFER_FROM_ARRAY(a))
/* ========================== * /* ========================== *
* Math types * Math types
* ========================== */ * ========================== */

4
src/entity.c
View File

@ -498,8 +498,8 @@ void entity_lookup_remove(struct entity_lookup *l, struct entity_lookup_entry *e
struct entity_lookup_key entity_lookup_key_from_two_handles(struct entity_handle h0, struct entity_handle h1) struct entity_lookup_key entity_lookup_key_from_two_handles(struct entity_handle h0, struct entity_handle h1)
{ {
struct entity_lookup_key key = ZI; struct entity_lookup_key key = ZI;
struct buffer b0 = BUFFER_FROM_STRUCT(&h0); struct string b0 = STRING_FROM_STRUCT(&h0);
struct buffer b1 = BUFFER_FROM_STRUCT(&h1); struct string b1 = STRING_FROM_STRUCT(&h1);
key.hash = hash_fnv64(HASH_FNV64_BASIS, b0); key.hash = hash_fnv64(HASH_FNV64_BASIS, b0);
key.hash = hash_fnv64(key.hash, b1); key.hash = hash_fnv64(key.hash, b1);
return key; return key;

14
src/font.c
View File

@ -104,11 +104,11 @@ INTERNAL WORK_TASK_FUNC_DEF(font_load_asset_task, vparams)
logf_info("Loading font \"%F\" (point size %F)", FMT_STR(path), FMT_FLOAT((f64)point_size)); logf_info("Loading font \"%F\" (point size %F)", FMT_STR(path), FMT_FLOAT((f64)point_size));
i64 start_ns = sys_time_ns(); i64 start_ns = sys_time_ns();
ASSERT(string_ends_with(path, STR(".ttf"))); ASSERT(string_ends_with(path, LIT(".ttf")));
if (!resource_exists(path)) { if (!resource_exists(path)) {
/* FIME: Load baked font instead of panicking */ /* FIME: Load baked font instead of panicking */
sys_panic(string_format(scratch.arena, sys_panic(string_format(scratch.arena,
STR("Font \"%F\" not found"), LIT("Font \"%F\" not found"),
FMT_STR(path))); FMT_STR(path)));
} }
@ -116,7 +116,7 @@ INTERNAL WORK_TASK_FUNC_DEF(font_load_asset_task, vparams)
/* Decode */ /* Decode */
struct resource res = resource_open(path); struct resource res = resource_open(path);
struct ttf_decode_result result = ttf_decode(scratch.arena, res.bytes, point_size, g_font_codes, ARRAY_COUNT(g_font_codes)); struct ttf_decode_result result = ttf_decode(scratch.arena, res.data, point_size, g_font_codes, ARRAY_COUNT(g_font_codes));
resource_close(res); resource_close(res);
/* Send texture to GPU */ /* Send texture to GPU */
@ -142,7 +142,7 @@ INTERNAL WORK_TASK_FUNC_DEF(font_load_asset_task, vparams)
/* FIXME: Load baked font instead of panicking */ /* FIXME: Load baked font instead of panicking */
if (font->glyphs_count <= 0) { if (font->glyphs_count <= 0) {
sys_panic(string_format(scratch.arena, sys_panic(string_format(scratch.arena,
STR("Parsed 0 glyphs from font \"%F\"!"), LIT("Parsed 0 glyphs from font \"%F\"!"),
FMT_STR(path))); FMT_STR(path)));
} }
@ -172,7 +172,7 @@ struct asset *font_load_asset(struct string path, f32 point_size, b32 help)
/* Concatenate point_size to path for key */ /* Concatenate point_size to path for key */
struct string key = string_format(scratch.arena, struct string key = string_format(scratch.arena,
STR("%F%F_font"), LIT("%F%F_font"),
FMT_STR(path), FMT_STR(path),
FMT_FLOAT_P((f64)point_size, 3)); FMT_FLOAT_P((f64)point_size, 3));
u64 hash = asset_cache_hash(key); u64 hash = asset_cache_hash(key);
@ -184,10 +184,10 @@ struct asset *font_load_asset(struct string path, f32 point_size, b32 help)
struct font_task_params *params = font_task_params_alloc(); struct font_task_params *params = font_task_params_alloc();
if (path.len > (sizeof(params->path_cstr) - 1)) { if (path.len > (sizeof(params->path_cstr) - 1)) {
sys_panic(string_format(scratch.arena, sys_panic(string_format(scratch.arena,
STR("Font path \"%F\" too long!"), LIT("Font path \"%F\" too long!"),
FMT_STR(path))); FMT_STR(path)));
} }
cstr_buff_from_string(BUFFER_FROM_ARRAY(params->path_cstr), path); cstr_buff_from_string(STRING_FROM_ARRAY(params->path_cstr), path);
params->path_len = path.len; params->path_len = path.len;
params->asset = asset; params->asset = asset;
params->point_size = point_size; params->point_size = point_size;

76
src/game.c
View File

@ -84,7 +84,7 @@ struct game_startup_receipt game_startup(struct mixer_startup_receipt *mixer_sr,
arena_set_readonly(&G.prev_tick.entity_store->arena); arena_set_readonly(&G.prev_tick.entity_store->arena);
G.prev_tick_mutex = sys_mutex_alloc(); G.prev_tick_mutex = sys_mutex_alloc();
G.game_thread = sys_thread_alloc(&game_thread_entry_point, NULL, STR("[P2] Game thread")); G.game_thread = sys_thread_alloc(&game_thread_entry_point, NULL, LIT("[P2] Game thread"));
app_register_exit_callback(&game_shutdown); app_register_exit_callback(&game_shutdown);
return (struct game_startup_receipt) { 0 }; return (struct game_startup_receipt) { 0 };
@ -157,16 +157,16 @@ INTERNAL void spawn_test_entities(void)
if (!G.extra_spawn) { if (!G.extra_spawn) {
entity_enable_prop(e, ENTITY_PROP_PLAYER_CONTROLLED); entity_enable_prop(e, ENTITY_PROP_PLAYER_CONTROLLED);
entity_enable_prop(e, ENTITY_PROP_TEST); entity_enable_prop(e, ENTITY_PROP_TEST);
e->sprite = sprite_tag_from_path(STR("res/graphics/tim.ase")); e->sprite = sprite_tag_from_path(LIT("res/graphics/tim.ase"));
e->mass_unscaled = 10; e->mass_unscaled = 10;
e->inertia_unscaled = 5; e->inertia_unscaled = 5;
} else { } else {
entity_enable_prop(e, ENTITY_PROP_TEST); entity_enable_prop(e, ENTITY_PROP_TEST);
e->sprite = sprite_tag_from_path(STR("res/graphics/tim.ase")); e->sprite = sprite_tag_from_path(LIT("res/graphics/tim.ase"));
e->mass_unscaled = 10; e->mass_unscaled = 10;
e->inertia_unscaled = 5; e->inertia_unscaled = 5;
#if 0 #if 0
e->sprite = sprite_tag_from_path(STR("res/graphics/box.ase")); e->sprite = sprite_tag_from_path(LIT("res/graphics/box.ase"));
e->mass_unscaled = 100; e->mass_unscaled = 100;
e->inertia_unscaled = 100; e->inertia_unscaled = 100;
#endif #endif
@ -177,10 +177,10 @@ INTERNAL void spawn_test_entities(void)
e->local_collider.count = 2; e->local_collider.count = 2;
e->local_collider.radius = 0.075f; e->local_collider.radius = 0.075f;
//e->sprite = sprite_tag_from_path(STR("res/graphics/box_rounded.ase")); //e->sprite = sprite_tag_from_path(LIT("res/graphics/box_rounded.ase"));
//e->sprite_span_name = STR("idle.unarmed"); //e->sprite_span_name = LIT("idle.unarmed");
//e->sprite_span_name = STR("idle.one_handed"); //e->sprite_span_name = LIT("idle.one_handed");
e->sprite_span_name = STR("idle.two_handed"); e->sprite_span_name = LIT("idle.two_handed");
e->layer = GAME_LAYER_SHOULDERS; e->layer = GAME_LAYER_SHOULDERS;
struct xform xf = XFORM_TRS(.t = pos, .r = r, .s = size); struct xform xf = XFORM_TRS(.t = pos, .r = r, .s = size);
@ -212,8 +212,8 @@ INTERNAL void spawn_test_entities(void)
struct xform xf = XFORM_TRS(.t = pos, .r = r, .s = size); struct xform xf = XFORM_TRS(.t = pos, .r = r, .s = size);
entity_set_xform(e, xf); entity_set_xform(e, xf);
e->sprite = sprite_tag_from_path(STR("res/graphics/tim.ase")); e->sprite = sprite_tag_from_path(LIT("res/graphics/tim.ase"));
e->sprite_collider_slice = STR("shape"); e->sprite_collider_slice = LIT("shape");
e->layer = GAME_LAYER_SHOULDERS; e->layer = GAME_LAYER_SHOULDERS;
entity_enable_prop(e, ENTITY_PROP_PHYSICAL_DYNAMIC); entity_enable_prop(e, ENTITY_PROP_PHYSICAL_DYNAMIC);
@ -235,8 +235,8 @@ INTERNAL void spawn_test_entities(void)
struct xform xf = XFORM_TRS(.t = pos, .r = r, .s = size); struct xform xf = XFORM_TRS(.t = pos, .r = r, .s = size);
entity_set_xform(e, xf); entity_set_xform(e, xf);
e->sprite = sprite_tag_from_path(STR("res/graphics/box.ase")); e->sprite = sprite_tag_from_path(LIT("res/graphics/box.ase"));
e->sprite_collider_slice = STR("shape"); e->sprite_collider_slice = LIT("shape");
e->layer = GAME_LAYER_SHOULDERS; e->layer = GAME_LAYER_SHOULDERS;
entity_enable_prop(e, ENTITY_PROP_PHYSICAL_DYNAMIC); entity_enable_prop(e, ENTITY_PROP_PHYSICAL_DYNAMIC);
@ -258,8 +258,8 @@ INTERNAL void spawn_test_entities(void)
struct xform xf = XFORM_TRS(.t = pos, .r = r, .s = size); struct xform xf = XFORM_TRS(.t = pos, .r = r, .s = size);
entity_set_xform(e, xf); entity_set_xform(e, xf);
e->sprite = sprite_tag_from_path(STR("res/graphics/bullet.ase")); e->sprite = sprite_tag_from_path(LIT("res/graphics/bullet.ase"));
e->sprite_collider_slice = STR("shape"); e->sprite_collider_slice = LIT("shape");
e->layer = GAME_LAYER_SHOULDERS; e->layer = GAME_LAYER_SHOULDERS;
entity_enable_prop(e, ENTITY_PROP_PHYSICAL_DYNAMIC); entity_enable_prop(e, ENTITY_PROP_PHYSICAL_DYNAMIC);
@ -272,10 +272,10 @@ INTERNAL void spawn_test_entities(void)
/* Player weapon */ /* Player weapon */
if (player_ent->valid) { if (player_ent->valid) {
struct entity *e = entity_alloc(player_ent); struct entity *e = entity_alloc(player_ent);
e->sprite = sprite_tag_from_path(STR("res/graphics/gun.ase")); e->sprite = sprite_tag_from_path(LIT("res/graphics/gun.ase"));
entity_enable_prop(e, ENTITY_PROP_ATTACHED); entity_enable_prop(e, ENTITY_PROP_ATTACHED);
e->attach_slice = STR("attach.wep"); e->attach_slice = LIT("attach.wep");
e->layer = GAME_LAYER_RELATIVE_WEAPON; e->layer = GAME_LAYER_RELATIVE_WEAPON;
entity_enable_prop(e, ENTITY_PROP_WEAPON); entity_enable_prop(e, ENTITY_PROP_WEAPON);
@ -411,7 +411,7 @@ INTERNAL PHYS_COLLISION_CALLBACK_FUNC_DEF(on_collision, array)
{ {
struct xform xf = XFORM_TRS(.t = point, .r = rng_rand_f32(0, TAU)); struct xform xf = XFORM_TRS(.t = point, .r = rng_rand_f32(0, TAU));
struct entity *decal = entity_alloc(root); struct entity *decal = entity_alloc(root);
decal->sprite = sprite_tag_from_path(STR("res/graphics/blood.ase")); decal->sprite = sprite_tag_from_path(LIT("res/graphics/blood.ase"));
decal->sprite_tint = RGBA_32_F(1, 1, 1, 0.25f); decal->sprite_tint = RGBA_32_F(1, 1, 1, 0.25f);
decal->layer = GAME_LAYER_FLOOR_DECALS; decal->layer = GAME_LAYER_FLOOR_DECALS;
entity_set_xform(decal, xf); entity_set_xform(decal, xf);
@ -611,7 +611,7 @@ INTERNAL void game_update(struct game_cmd_list game_cmds)
/* Update sprite local xform */ /* Update sprite local xform */
{ {
struct sprite_sheet_slice slice = sprite_sheet_get_slice(sheet, STR("pivot"), ent->animation_frame); struct sprite_sheet_slice slice = sprite_sheet_get_slice(sheet, LIT("pivot"), ent->animation_frame);
struct v2 sprite_size = v2_div(sheet->frame_size, (f32)IMAGE_PIXELS_PER_UNIT); struct v2 sprite_size = v2_div(sheet->frame_size, (f32)IMAGE_PIXELS_PER_UNIT);
struct v2 dir = v2_mul_v2(sprite_size, slice.dir); struct v2 dir = v2_mul_v2(sprite_size, slice.dir);
@ -838,7 +838,7 @@ INTERNAL void game_update(struct game_cmd_list game_cmds)
struct xform sprite_local_xform = ent->sprite_local_xform; struct xform sprite_local_xform = ent->sprite_local_xform;
struct sprite_sheet_slice out_slice = sprite_sheet_get_slice(sheet, STR("out"), animation_frame); struct sprite_sheet_slice out_slice = sprite_sheet_get_slice(sheet, LIT("out"), animation_frame);
struct v2 rel_pos = xform_mul_v2(sprite_local_xform, out_slice.center); struct v2 rel_pos = xform_mul_v2(sprite_local_xform, out_slice.center);
struct v2 rel_dir = xform_basis_mul_v2(sprite_local_xform, out_slice.dir); struct v2 rel_dir = xform_basis_mul_v2(sprite_local_xform, out_slice.dir);
@ -861,8 +861,8 @@ INTERNAL void game_update(struct game_cmd_list game_cmds)
bullet->local_collider.points[0] = V2(0, 0); bullet->local_collider.points[0] = V2(0, 0);
bullet->local_collider.count = 1; bullet->local_collider.count = 1;
#else #else
bullet->sprite = sprite_tag_from_path(STR("res/graphics/bullet.ase")); bullet->sprite = sprite_tag_from_path(LIT("res/graphics/bullet.ase"));
bullet->sprite_collider_slice = STR("shape"); bullet->sprite_collider_slice = LIT("shape");
#endif #endif
entity_enable_prop(bullet, ENTITY_PROP_BULLET); entity_enable_prop(bullet, ENTITY_PROP_BULLET);
@ -972,7 +972,7 @@ INTERNAL void game_update(struct game_cmd_list game_cmds)
struct v2 sprite_hold_dir; struct v2 sprite_hold_dir;
{ {
struct sprite_sheet *sheet = sprite_sheet_from_tag_await(sprite_frame_scope, ent->sprite); struct sprite_sheet *sheet = sprite_sheet_from_tag_await(sprite_frame_scope, ent->sprite);
struct sprite_sheet_slice slice = sprite_sheet_get_slice(sheet, STR("attach.wep"), ent->animation_frame); struct sprite_sheet_slice slice = sprite_sheet_get_slice(sheet, LIT("attach.wep"), ent->animation_frame);
sprite_hold_pos = slice.center; sprite_hold_pos = slice.center;
sprite_hold_dir = slice.dir; sprite_hold_dir = slice.dir;
} }
@ -1315,7 +1315,7 @@ INTERNAL void game_update(struct game_cmd_list game_cmds)
* Game cmd * Game cmd
* ========================== */ * ========================== */
struct buffer game_string_from_cmds(struct arena *arena, struct game_cmd_list *cmds) struct string game_string_from_cmds(struct arena *arena, struct game_cmd_list *cmds)
{ {
struct byte_writer bw = bw_from_arena(arena); struct byte_writer bw = bw_from_arena(arena);
@ -1346,16 +1346,14 @@ struct buffer game_string_from_cmds(struct arena *arena, struct game_cmd_list *c
} }
u64 size = bw_pos(&bw) - start; u64 size = bw_pos(&bw) - start;
if (size > 100) {
DEBUGBREAKABLE;
}
bw_write_u64(&bw_size, size); bw_write_u64(&bw_size, size);
} }
return bw.buff;
return bw_get_written(&bw);
} }
struct game_cmd_list game_cmds_from_string(struct arena *arena, struct buffer str) struct game_cmd_list game_cmds_from_string(struct arena *arena, struct string str)
{ {
struct game_cmd_list l = ZI; struct game_cmd_list l = ZI;
@ -1404,24 +1402,24 @@ struct game_cmd_list game_cmds_from_string(struct arena *arena, struct buffer st
* Game cmd * Game cmd
* ========================== */ * ========================== */
INTERNAL void push_input_string(struct buffer input) INTERNAL void push_input_string(struct string input)
{ {
struct sys_lock lock = sys_mutex_lock_e(&G.game_input_mutex); struct sys_lock lock = sys_mutex_lock_e(&G.game_input_mutex);
u8 *dst = arena_push_array(&G.game_input_arena, u8, input.size); u8 *dst = arena_push_array(&G.game_input_arena, u8, input.len);
MEMCPY(dst, input.data, input.size); MEMCPY(dst, input.text, input.len);
sys_mutex_unlock(&lock); sys_mutex_unlock(&lock);
} }
INTERNAL struct buffer pop_input_string(struct arena *arena) INTERNAL struct string pop_input_string(struct arena *arena)
{ {
struct buffer buff = ZI; struct string s = ZI;
struct sys_lock lock = sys_mutex_lock_e(&G.game_input_mutex); struct sys_lock lock = sys_mutex_lock_e(&G.game_input_mutex);
buff.size = G.game_input_arena.pos; s.len = G.game_input_arena.pos;
buff.data = arena_push_array(arena, u8, buff.size); s.text = arena_push_array(arena, u8, s.len);
MEMCPY(buff.data, G.game_input_arena.base, buff.size); MEMCPY(s.text, G.game_input_arena.base, s.len);
arena_reset(&G.game_input_arena); arena_reset(&G.game_input_arena);
sys_mutex_unlock(&lock); sys_mutex_unlock(&lock);
return buff; return s;
} }
/* ========================== * /* ========================== *
@ -1446,7 +1444,7 @@ u64 game_get_latest_tick_continuity_gen(void)
return atomic_u64_eval(&G.prev_tick_continuity_gen); return atomic_u64_eval(&G.prev_tick_continuity_gen);
} }
void game_push_cmds_string(struct buffer str) void game_push_cmds_string(struct string str)
{ {
push_input_string(str); push_input_string(str);
} }
@ -1468,7 +1466,7 @@ INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(game_thread_entry_point, arg)
sleep_frame(last_frame_ns, target_dt_ns); sleep_frame(last_frame_ns, target_dt_ns);
last_frame_ns = sys_time_ns(); last_frame_ns = sys_time_ns();
{ {
struct buffer input_str = pop_input_string(temp.arena); struct string input_str = pop_input_string(temp.arena);
struct game_cmd_list cmds = game_cmds_from_string(temp.arena, input_str); struct game_cmd_list cmds = game_cmds_from_string(temp.arena, input_str);
if (!G.paused) { if (!G.paused) {
game_update(cmds); game_update(cmds);

6
src/game.h
View File

@ -78,12 +78,12 @@ struct game_cmd_list {
* Interface * Interface
* ========================== */ * ========================== */
struct buffer game_string_from_cmds(struct arena *arena, struct game_cmd_list *cmds); struct string game_string_from_cmds(struct arena *arena, struct game_cmd_list *cmds);
struct game_cmd_list game_cmds_from_string(struct arena *arena, struct buffer str); struct game_cmd_list game_cmds_from_string(struct arena *arena, struct string str);
void game_get_latest_tick(struct world *dest); void game_get_latest_tick(struct world *dest);
u64 game_get_latest_tick_id(void); u64 game_get_latest_tick_id(void);
u64 game_get_latest_tick_continuity_gen(void); u64 game_get_latest_tick_continuity_gen(void);
void game_push_cmds_string(struct buffer str); void game_push_cmds_string(struct string str);
#endif #endif

4
src/inc.c
View File

@ -8,14 +8,14 @@
#if RESOURCES_EMBEDDED #if RESOURCES_EMBEDDED
INCBIN_INCLUDE(res_tar, INCBIN_DIR "res.tar"); INCBIN_INCLUDE(res_tar, INCBIN_DIR "res.tar");
struct buffer inc_res_tar(void) struct string inc_res_tar(void)
{ {
return INCBIN_GET(res_tar); return INCBIN_GET(res_tar);
} }
#endif #endif
INCBIN_INCLUDE(shaders_tar, INCBIN_DIR "shaders.tar"); INCBIN_INCLUDE(shaders_tar, INCBIN_DIR "shaders.tar");
struct buffer inc_shaders_tar(void) struct string inc_shaders_tar(void)
{ {
return INCBIN_GET(shaders_tar); return INCBIN_GET(shaders_tar);
} }

4
src/inc.h
View File

@ -2,9 +2,9 @@
#define INC_H #define INC_H
#if RESOURCES_EMBEDDED #if RESOURCES_EMBEDDED
struct buffer inc_res_tar(void); struct string inc_res_tar(void);
#endif #endif
struct buffer inc_shaders_tar(void); struct string inc_shaders_tar(void);
#endif #endif

12
src/incbin.c
View File

@ -19,7 +19,7 @@ struct rc_search_params {
struct string name_lower; struct string name_lower;
/* Out */ /* Out */
b32 found; b32 found;
struct buffer data; struct string data;
}; };
/* Find first resource with `type` and return the data in `udata`. */ /* Find first resource with `type` and return the data in `udata`. */
@ -29,15 +29,15 @@ INTERNAL BOOL CALLBACK enum_func(HMODULE module, LPCWSTR type, LPCWSTR wstr_entr
struct rc_search_params *params = (struct rc_search_params *)udata; struct rc_search_params *params = (struct rc_search_params *)udata;
struct string entry_name_lower = string_lower(scratch.arena, string_from_wstr(scratch.arena, (LPWSTR)wstr_entry_name)); struct string entry_name_lower = string_lower(scratch.arena, string_from_wstr(scratch.arena, (LPWSTR)wstr_entry_name));
params->found = false; params->found = false;
params->data = BUFFER(0, 0); params->data = STRING(0, 0);
if (string_eq(entry_name_lower, params->name_lower)) { if (string_eq(entry_name_lower, params->name_lower)) {
HRSRC hres = FindResourceW(module, wstr_entry_name, type); HRSRC hres = FindResourceW(module, wstr_entry_name, type);
if (hres) { if (hres) {
HGLOBAL hg = LoadResource(module, hres); HGLOBAL hg = LoadResource(module, hres);
if (hg) { if (hg) {
params->found = true; params->found = true;
params->data.size = SizeofResource(module, hres); params->data.len = SizeofResource(module, hres);
params->data.data = LockResource(hg); params->data.text = LockResource(hg);
} }
} }
} }
@ -45,7 +45,7 @@ INTERNAL BOOL CALLBACK enum_func(HMODULE module, LPCWSTR type, LPCWSTR wstr_entr
return !params->found; return !params->found;
} }
struct buffer _incbin_get(struct _incbin_rc_resource *inc) struct string _incbin_get(struct _incbin_rc_resource *inc)
{ {
enum inc_state state = atomic_i32_eval(&inc->state); enum inc_state state = atomic_i32_eval(&inc->state);
if (state != INCBIN_STATE_SEARCHED) { if (state != INCBIN_STATE_SEARCHED) {
@ -60,7 +60,7 @@ struct buffer _incbin_get(struct _incbin_rc_resource *inc)
EnumResourceNamesW(NULL, RT_RCDATA, &enum_func, (LONG_PTR)&params); EnumResourceNamesW(NULL, RT_RCDATA, &enum_func, (LONG_PTR)&params);
if (!params.found) { if (!params.found) {
sys_panic(string_format(scratch.arena, sys_panic(string_format(scratch.arena,
STR("INCBIN include not found in RC file: \"%F\""), LIT("INCBIN include not found in RC file: \"%F\""),
FMT_STR(inc->rc_name))); FMT_STR(inc->rc_name)));
} }
inc->data = params.data; inc->data = params.data;

10
src/incbin.h
View File

@ -12,7 +12,7 @@
* file). * file).
* ========================== */ * ========================== */
#define INCBIN_INCLUDE(var, _rc_name) static struct _incbin_rc_resource _incbin_ ## var = { .rc_name = STR_NOCAST((_rc_name)) } #define INCBIN_INCLUDE(var, _rc_name) static struct _incbin_rc_resource _incbin_ ## var = { .rc_name = LIT_NOCAST((_rc_name)) }
#define INCBIN_GET(var) _incbin_get(&_incbin_ ## var) #define INCBIN_GET(var) _incbin_get(&_incbin_ ## var)
enum _incbin_state { enum _incbin_state {
@ -24,10 +24,10 @@ enum _incbin_state {
struct _incbin_rc_resource { struct _incbin_rc_resource {
struct atomic_i32 state; struct atomic_i32 state;
struct string rc_name; struct string rc_name;
struct buffer data; struct string data;
}; };
struct buffer _incbin_get(struct _incbin_rc_resource *inc); struct string _incbin_get(struct _incbin_rc_resource *inc);
#else #else
@ -62,8 +62,8 @@ struct buffer _incbin_get(struct _incbin_rc_resource *inc);
extern __attribute((aligned(16))) const char _incbin_ ## var ## _start[]; \ extern __attribute((aligned(16))) const char _incbin_ ## var ## _start[]; \
extern const char _incbin_ ## var ## _end[] extern const char _incbin_ ## var ## _end[]
/* Retrieve a buffer for included data using the variable supplied to INCBIN_INCLUDE */ /* Retrieve a string from included data using the variable supplied to INCBIN_INCLUDE */
#define INCBIN_GET(var) BUFFER_FROM_POINTERS(_incbin_ ## var ## _start, _incbin_ ## var ## _end) #define INCBIN_GET(var) STRING_FROM_POINTERS(_incbin_ ## var ## _start, _incbin_ ## var ## _end)
#endif #endif

22
src/json.c
View File

@ -70,9 +70,9 @@ enum lex_number_state {
}; };
GLOBAL READONLY struct string g_keyword_strings[] = { GLOBAL READONLY struct string g_keyword_strings[] = {
['t'] = STR_NOCAST("true"), ['t'] = LIT_NOCAST("true"),
['f'] = STR_NOCAST("false"), ['f'] = LIT_NOCAST("false"),
['n'] = STR_NOCAST("null") ['n'] = LIT_NOCAST("null")
}; };
GLOBAL READONLY enum token_type g_keyword_types[] = { GLOBAL READONLY enum token_type g_keyword_types[] = {
@ -537,7 +537,7 @@ INTERNAL struct string interpret_string(struct arena *arena, struct string src,
if (src.len < 2) { if (src.len < 2) {
if (error) { if (error) {
*error = STR("Malformed string."); *error = LIT("Malformed string.");
} }
return res; return res;
} }
@ -599,7 +599,7 @@ INTERNAL struct string interpret_string(struct arena *arena, struct string src,
default: { default: {
if (error) { if (error) {
*error = STR("Invalid escape character in string."); *error = LIT("Invalid escape character in string.");
return res; return res;
} }
} break; } break;
@ -627,7 +627,7 @@ INTERNAL struct string interpret_string(struct arena *arena, struct string src,
if (!valid_close) { if (!valid_close) {
if (error) { if (error) {
*error = STR("Expected end of string."); *error = LIT("Expected end of string.");
} }
} }
@ -695,7 +695,7 @@ INTERNAL void parse(struct arena *arena, struct parser *p)
if (at->type == tok_close_type) { if (at->type == tok_close_type) {
at = at->next; at = at->next;
} else { } else {
push_error(arena, p, at, STR("Expected comma.")); push_error(arena, p, at, LIT("Expected comma."));
at = at->next; at = at->next;
goto abort; goto abort;
} }
@ -715,7 +715,7 @@ INTERNAL void parse(struct arena *arena, struct parser *p)
at = at->next; at = at->next;
} }
} else { } else {
push_error(arena, p, at, STR("Key expected.")); push_error(arena, p, at, LIT("Key expected."));
goto abort; goto abort;
} }
@ -723,7 +723,7 @@ INTERNAL void parse(struct arena *arena, struct parser *p)
if (at->type == TOKEN_TYPE_COLON) { if (at->type == TOKEN_TYPE_COLON) {
at = at->next; at = at->next;
} else { } else {
push_error(arena, p, at, STR("Colon expected.")); push_error(arena, p, at, LIT("Colon expected."));
goto abort; goto abort;
} }
} }
@ -790,7 +790,7 @@ INTERNAL void parse(struct arena *arena, struct parser *p)
} break; } break;
default: { default: {
push_error(arena, p, at, STR("Value expected.")); push_error(arena, p, at, LIT("Value expected."));
at = at->next; at = at->next;
goto abort; goto abort;
} break; } break;
@ -847,7 +847,7 @@ struct json_parse_result json_from_string(struct arena *arena, struct string src
/* Verify end of file */ /* Verify end of file */
if (p.errors.count == 0 && p.at->type != TOKEN_TYPE_EOF) { if (p.errors.count == 0 && p.at->type != TOKEN_TYPE_EOF) {
push_error(arena, &p, p.at, STR("Expected end of file.")); push_error(arena, &p, p.at, LIT("Expected end of file."));
} }
scratch_end(scratch); scratch_end(scratch);

26
src/log.c
View File

@ -24,27 +24,27 @@ GLOBAL struct {
GLOBAL READONLY struct log_level_settings g_log_level_settings[LOG_LEVEL_COUNT] = { GLOBAL READONLY struct log_level_settings g_log_level_settings[LOG_LEVEL_COUNT] = {
[LOG_LEVEL_CRITICAL] = { [LOG_LEVEL_CRITICAL] = {
STR_NOCAST("CRITICAL"), LIT_NOCAST("CRITICAL"),
0xFFFF00FF 0xFFFF00FF
}, },
[LOG_LEVEL_ERROR] = { [LOG_LEVEL_ERROR] = {
STR_NOCAST("ERROR"), LIT_NOCAST("ERROR"),
0xFFFF0000 0xFFFF0000
}, },
[LOG_LEVEL_WARNING] = { [LOG_LEVEL_WARNING] = {
STR_NOCAST("WARNING"), LIT_NOCAST("WARNING"),
0xFFFFFF00 0xFFFFFF00
}, },
[LOG_LEVEL_INFO] = { [LOG_LEVEL_INFO] = {
STR_NOCAST("INFO"), LIT_NOCAST("INFO"),
0xFFFFFFFF 0xFFFFFFFF
}, },
[LOG_LEVEL_DEBUG] = { [LOG_LEVEL_DEBUG] = {
STR_NOCAST("DEBUG"), LIT_NOCAST("DEBUG"),
0xFF30D5C8 0xFF30D5C8
} }
}; };
@ -96,8 +96,8 @@ INTERNAL void append_to_logfile(struct string msg)
if (G.file_valid) { if (G.file_valid) {
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
struct string msg_line = string_cat(scratch.arena, msg, STR("\n")); struct string msg_line = string_cat(scratch.arena, msg, LIT("\n"));
sys_file_write(G.file, BUFFER_FROM_STRING(msg_line)); sys_file_write(G.file, msg_line);
scratch_end(scratch); scratch_end(scratch);
} }
} }
@ -109,9 +109,9 @@ void _log_panic(struct string msg)
if (!atomic_i32_eval(&G.initialized)) { return; } if (!atomic_i32_eval(&G.initialized)) { return; }
if (G.file_valid) { if (G.file_valid) {
sys_file_write(G.file, BUFFER_FROM_STRING(STR("******** PANICKING ********\n"))); sys_file_write(G.file, LIT("******** PANICKING ********\n"));
sys_file_write(G.file, BUFFER_FROM_STRING(msg)); sys_file_write(G.file, msg);
sys_file_write(G.file, BUFFER_FROM_STRING(STR("\n***************************\n"))); sys_file_write(G.file, LIT("\n***************************\n"));
} }
} }
@ -125,7 +125,7 @@ void _log(i32 level, struct string msg)
if (!atomic_i32_eval(&G.initialized)) { return; } if (!atomic_i32_eval(&G.initialized)) { return; }
if (level < 0 || level >= LOG_LEVEL_COUNT) { if (level < 0 || level >= LOG_LEVEL_COUNT) {
sys_panic(STR("Invalid log level")); sys_panic(LIT("Invalid log level"));
} }
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
@ -139,7 +139,7 @@ void _log(i32 level, struct string msg)
#if LOG_INCLUDE_SOURCE_LOCATION #if LOG_INCLUDE_SOURCE_LOCATION
struct string msg_formatted = string_format( struct string msg_formatted = string_format(
scratch.arena, scratch.arena,
STR("%F:%F:%F |Thread %F| [%F] <%F:%F> %F"), LIT("%F:%F:%F |Thread %F| [%F] <%F:%F> %F"),
/* Time */ /* Time */
FMT_UINT(lt.hour), FMT_UINT(lt.hour),
@ -162,7 +162,7 @@ void _log(i32 level, struct string msg)
#else #else
struct string msg_formatted = string_format( struct string msg_formatted = string_format(
scratch.arena, scratch.arena,
STR("%F:%F:%F |Thread %F| [%F] %F"), LIT("%F:%F:%F |Thread %F| [%F] %F"),
/* Time */ /* Time */
FMT_UINT(lt.hour), FMT_UINT(lt.hour),

30
src/log.h
View File

@ -58,11 +58,11 @@ void log_register_callback(log_event_callback_func *func);
#if LOG_LEVEL(LOG_LEVEL_CRITICAL) #if LOG_LEVEL(LOG_LEVEL_CRITICAL)
# if LOG_INCLUDE_SOURCE_LOCATION # if LOG_INCLUDE_SOURCE_LOCATION
# define log_critical(msg) _log(LOG_LEVEL_CRITICAL, STR(__FILE__), __LINE__, msg) # define log_critical(msg) _log(LOG_LEVEL_CRITICAL, LIT(__FILE__), __LINE__, msg)
# define logf_critical(fmt, ...) _logf(LOG_LEVEL_CRITICAL, STR(__FILE__), __LINE__, STR(fmt) , ## __VA_ARGS__, FMT_END) # define logf_critical(fmt, ...) _logf(LOG_LEVEL_CRITICAL, LIT(__FILE__), __LINE__, LIT(fmt) , ## __VA_ARGS__, FMT_END)
# else # else
# define log_critical(msg) _log(LOG_LEVEL_CRITICAL, msg) # define log_critical(msg) _log(LOG_LEVEL_CRITICAL, msg)
# define logf_critical(fmt, ...) _logf(LOG_LEVEL_CRITICAL, STR(fmt) , ## __VA_ARGS__, FMT_END) # define logf_critical(fmt, ...) _logf(LOG_LEVEL_CRITICAL, LIT(fmt) , ## __VA_ARGS__, FMT_END)
# endif # endif
#else #else
# define log_critical(msg) # define log_critical(msg)
@ -71,11 +71,11 @@ void log_register_callback(log_event_callback_func *func);
#if LOG_LEVEL(LOG_LEVEL_ERROR) #if LOG_LEVEL(LOG_LEVEL_ERROR)
# if LOG_INCLUDE_SOURCE_LOCATION # if LOG_INCLUDE_SOURCE_LOCATION
# define log_error(msg) _log(LOG_LEVEL_ERROR, STR(__FILE__), __LINE__, msg) # define log_error(msg) _log(LOG_LEVEL_ERROR, LIT(__FILE__), __LINE__, msg)
# define logf_error(fmt, ...) _logf(LOG_LEVEL_ERROR, STR(__FILE__), __LINE__, STR(fmt) , ## __VA_ARGS__, FMT_END) # define logf_error(fmt, ...) _logf(LOG_LEVEL_ERROR, LIT(__FILE__), __LINE__, LIT(fmt) , ## __VA_ARGS__, FMT_END)
# else # else
# define log_error(msg) _log(LOG_LEVEL_ERROR, msg) # define log_error(msg) _log(LOG_LEVEL_ERROR, msg)
# define logf_error(fmt, ...) _logf(LOG_LEVEL_ERROR, STR(fmt) , ## __VA_ARGS__, FMT_END) # define logf_error(fmt, ...) _logf(LOG_LEVEL_ERROR, LIT(fmt) , ## __VA_ARGS__, FMT_END)
# endif # endif
#else #else
# define log_error(msg) # define log_error(msg)
@ -84,11 +84,11 @@ void log_register_callback(log_event_callback_func *func);
#if LOG_LEVEL(LOG_LEVEL_WARNING) #if LOG_LEVEL(LOG_LEVEL_WARNING)
# if LOG_INCLUDE_SOURCE_LOCATION # if LOG_INCLUDE_SOURCE_LOCATION
# define log_warning(msg) _log(LOG_LEVEL_WARNING, STR(__FILE__), __LINE__, msg) # define log_warning(msg) _log(LOG_LEVEL_WARNING, LIT(__FILE__), __LINE__, msg)
# define logf_warning(fmt, ...) _logf(LOG_LEVEL_WARNING, STR(__FILE__), __LINE__, STR(fmt) , ## __VA_ARGS__, FMT_END) # define logf_warning(fmt, ...) _logf(LOG_LEVEL_WARNING, LIT(__FILE__), __LINE__, LIT(fmt) , ## __VA_ARGS__, FMT_END)
# else # else
# define log_warning(msg) _log(LOG_LEVEL_WARNING, msg) # define log_warning(msg) _log(LOG_LEVEL_WARNING, msg)
# define logf_warning(fmt, ...) _logf(LOG_LEVEL_WARNING, STR(fmt) , ## __VA_ARGS__, FMT_END) # define logf_warning(fmt, ...) _logf(LOG_LEVEL_WARNING, LIT(fmt) , ## __VA_ARGS__, FMT_END)
# endif # endif
#else #else
# define log_warning(msg) # define log_warning(msg)
@ -97,11 +97,11 @@ void log_register_callback(log_event_callback_func *func);
#if LOG_LEVEL(LOG_LEVEL_DEBUG) #if LOG_LEVEL(LOG_LEVEL_DEBUG)
# if LOG_INCLUDE_SOURCE_LOCATION # if LOG_INCLUDE_SOURCE_LOCATION
# define log_debug(msg) _log(LOG_LEVEL_DEBUG, STR(__FILE__), __LINE__, msg) # define log_debug(msg) _log(LOG_LEVEL_DEBUG, LIT(__FILE__), __LINE__, msg)
# define logf_debug(fmt, ...) _logf(LOG_LEVEL_DEBUG, STR(__FILE__), __LINE__, STR(fmt) , ## __VA_ARGS__, FMT_END) # define logf_debug(fmt, ...) _logf(LOG_LEVEL_DEBUG, LIT(__FILE__), __LINE__, LIT(fmt) , ## __VA_ARGS__, FMT_END)
# else # else
# define log_debug(msg) _log(LOG_LEVEL_DEBUG, msg) # define log_debug(msg) _log(LOG_LEVEL_DEBUG, msg)
# define logf_debug(fmt, ...) _logf(LOG_LEVEL_DEBUG, STR(fmt) , ## __VA_ARGS__, FMT_END) # define logf_debug(fmt, ...) _logf(LOG_LEVEL_DEBUG, LIT(fmt) , ## __VA_ARGS__, FMT_END)
# endif # endif
#else #else
# define log_debug(msg) # define log_debug(msg)
@ -111,11 +111,11 @@ void log_register_callback(log_event_callback_func *func);
#if LOG_LEVEL(LOG_LEVEL_INFO) #if LOG_LEVEL(LOG_LEVEL_INFO)
# if LOG_INCLUDE_SOURCE_LOCATION # if LOG_INCLUDE_SOURCE_LOCATION
# define log_info(msg) _log(LOG_LEVEL_INFO, STR(__FILE__), __LINE__, msg) # define log_info(msg) _log(LOG_LEVEL_INFO, LIT(__FILE__), __LINE__, msg)
# define logf_info(fmt, ...) _logf(LOG_LEVEL_INFO, STR(__FILE__), __LINE__, STR(fmt) , ## __VA_ARGS__, FMT_END) # define logf_info(fmt, ...) _logf(LOG_LEVEL_INFO, LIT(__FILE__), __LINE__, LIT(fmt) , ## __VA_ARGS__, FMT_END)
# else # else
# define log_info(msg) _log(LOG_LEVEL_INFO, msg) # define log_info(msg) _log(LOG_LEVEL_INFO, msg)
# define logf_info(fmt, ...) _logf(LOG_LEVEL_INFO, STR(fmt) , ## __VA_ARGS__, FMT_END) # define logf_info(fmt, ...) _logf(LOG_LEVEL_INFO, LIT(fmt) , ## __VA_ARGS__, FMT_END)
# endif # endif
#else #else
# define log_info(msg) # define log_info(msg)

2
src/mp3.h
View File

@ -9,6 +9,6 @@ struct mp3_decode_result {
b32 success; b32 success;
}; };
struct mp3_decode_result mp3_decode(struct arena *arena, struct buffer encoded, u32 flags); struct mp3_decode_result mp3_decode(struct arena *arena, struct string encoded, u32 flags);
#endif #endif

6
src/mp3_mmf.c
View File

@ -24,7 +24,7 @@
#pragma comment(lib, "mfreadwrite") #pragma comment(lib, "mfreadwrite")
#pragma comment(lib, "shlwapi") #pragma comment(lib, "shlwapi")
struct mp3_decode_result mp3_decode(struct arena *arena, struct buffer encoded, u32 flags) struct mp3_decode_result mp3_decode(struct arena *arena, struct string encoded, u32 flags)
{ {
struct mp3_decode_result res = ZI; struct mp3_decode_result res = ZI;
@ -47,8 +47,8 @@ struct mp3_decode_result mp3_decode(struct arena *arena, struct buffer encoded,
MFStartup(MF_VERSION, MFSTARTUP_LITE); MFStartup(MF_VERSION, MFSTARTUP_LITE);
/* Create IStream from buffer */ /* Create IStream from encoded string */
IStream *i_stream = SHCreateMemStream(encoded.data, encoded.size); IStream *i_stream = SHCreateMemStream(encoded.text, encoded.len);
/* Create IMFByteStream from IStream */ /* Create IMFByteStream from IStream */
IMFByteStream *byte_stream = NULL; IMFByteStream *byte_stream = NULL;

2
src/playback_wasapi.c
View File

@ -60,7 +60,7 @@ struct playback_startup_receipt playback_startup(struct mixer_startup_receipt *m
(UNUSED)mixer_sr; (UNUSED)mixer_sr;
wasapi_initialize(); wasapi_initialize();
G.playback_thread = sys_thread_alloc(&playback_thread_entry_point, NULL, STR("[P3] Audio thread")); G.playback_thread = sys_thread_alloc(&playback_thread_entry_point, NULL, LIT("[P3] Audio thread"));
app_register_exit_callback(&playback_shutdown); app_register_exit_callback(&playback_shutdown);
return (struct playback_startup_receipt) { 0 }; return (struct playback_startup_receipt) { 0 };

20
src/renderer_d3d11.c
View File

@ -196,7 +196,7 @@ INTERNAL void send_constant_buffer_data(ID3D11Buffer *buffer, struct mat4x4 vp)
INTERNAL void process_shader_compilation_error(ID3DBlob *error_blob) INTERNAL void process_shader_compilation_error(ID3DBlob *error_blob)
{ {
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
struct string error_prefix = string_copy(scratch.arena, STR("Failed to compile shader:\n")); struct string error_prefix = string_copy(scratch.arena, LIT("Failed to compile shader:\n"));
if (error_blob) { if (error_blob) {
char *compile_error_cstr = (char *)ID3D10Blob_GetBufferPointer(error_blob); char *compile_error_cstr = (char *)ID3D10Blob_GetBufferPointer(error_blob);
struct string error_msg = string_cat(scratch.arena, error_prefix, string_from_cstr(compile_error_cstr)); struct string error_msg = string_cat(scratch.arena, error_prefix, string_from_cstr(compile_error_cstr));
@ -259,21 +259,21 @@ INTERNAL void shader_init(struct dx11_shader *shader, enum shader_kind kind)
struct tar_entry *tar_entry = tar_get(&G.shaders_archive, name); struct tar_entry *tar_entry = tar_get(&G.shaders_archive, name);
if (!tar_entry) { if (!tar_entry) {
sys_panic(string_format(scratch.arena, sys_panic(string_format(scratch.arena,
STR("Could not find shader \"%F\""), LIT("Could not find shader \"%F\""),
FMT_STR(name))); FMT_STR(name)));
} }
struct buffer shader_src = tar_entry->buff; struct string shader_src = tar_entry->data;
logf_info("Compiling shader \"%F\"", FMT_STR(name)); logf_info("Compiling shader \"%F\"", FMT_STR(name));
/* Compile shader */ /* Compile shader */
/* TODO: pre-compile shaders w/ FXC? */ /* TODO: pre-compile shaders w/ FXC? */
ID3DBlob *error_blob; ID3DBlob *error_blob;
HRESULT v_res = D3DCompile(shader_src.data, shader_src.size, NULL, NULL, NULL, "vs_main", "vs_5_0", flags, 0, &vs_blob, &error_blob); HRESULT v_res = D3DCompile(shader_src.text, shader_src.len, NULL, NULL, NULL, "vs_main", "vs_5_0", flags, 0, &vs_blob, &error_blob);
if (FAILED(v_res)) { if (FAILED(v_res)) {
process_shader_compilation_error(error_blob); process_shader_compilation_error(error_blob);
} }
HRESULT p_res = D3DCompile(shader_src.data, shader_src.size, NULL, NULL, NULL, "ps_main", "ps_5_0", flags, 0, &ps_blob, &error_blob); HRESULT p_res = D3DCompile(shader_src.text, shader_src.len, NULL, NULL, NULL, "ps_main", "ps_5_0", flags, 0, &ps_blob, &error_blob);
if (FAILED(p_res)) { if (FAILED(p_res)) {
process_shader_compilation_error(error_blob); process_shader_compilation_error(error_blob);
} }
@ -316,9 +316,9 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window)
G.textures_arena = arena_alloc(GIGABYTE(64)); G.textures_arena = arena_alloc(GIGABYTE(64));
/* Load shader archive */ /* Load shader archive */
struct buffer embedded_data = inc_shaders_tar(); struct string embedded_data = inc_shaders_tar();
if (embedded_data.size > 0) { if (embedded_data.len > 0) {
G.shaders_archive = tar_parse(&G.arena, embedded_data, STR("shaders/")); G.shaders_archive = tar_parse(&G.arena, embedded_data, LIT("shaders/"));
} }
/* Initialize shader table */ /* Initialize shader table */
@ -421,7 +421,7 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window)
if (!SUCCEEDED(hr) || !device || !context || !swapchain) { if (!SUCCEEDED(hr) || !device || !context || !swapchain) {
/* Renderer initialization failure */ /* Renderer initialization failure */
/* TODO: Better message */ /* TODO: Better message */
sys_panic(STR("Failed to initialize renderer")); sys_panic(LIT("Failed to initialize renderer"));
} }
G.dev = device; G.dev = device;
G.devcon = context; G.devcon = context;
@ -866,7 +866,7 @@ struct renderer_cmd_buffer *renderer_cmd_buffer_alloc(void)
} }
if (!cmdbuff) { if (!cmdbuff) {
sys_panic(STR("Max renderer cmdbuffs reached")); sys_panic(LIT("Max renderer cmdbuffs reached"));
return NULL; return NULL;
} }

18
src/resource.c
View File

@ -18,16 +18,16 @@ GLOBAL struct {
struct resource_startup_receipt resource_startup(void) struct resource_startup_receipt resource_startup(void)
{ {
#if RESOURCES_EMBEDDED #if RESOURCES_EMBEDDED
struct buffer embedded_data = inc_res_tar(); struct string embedded_data = inc_res_tar();
G.arena = arena_alloc(GIGABYTE(64)); G.arena = arena_alloc(GIGABYTE(64));
if (embedded_data.size <= 0) { if (embedded_data.len <= 0) {
sys_panic(STR("No embedded resources found")); sys_panic(LIT("No embedded resources found"));
} }
G.archive = tar_parse(&G.arena, embedded_data, STR("res/")); G.archive = tar_parse(&G.arena, embedded_data, LIT("res/"));
#else #else
/* Ensure we have the right working directory */ /* Ensure we have the right working directory */
if (!sys_is_dir(STR("res"))) { if (!sys_is_dir(LIT("res"))) {
sys_panic(STR("Resource directory \"res\" not found")); sys_panic(LIT("Resource directory \"res\" not found"));
} }
#endif #endif
@ -51,14 +51,14 @@ struct resource resource_open(struct string path)
#if RESOURCES_EMBEDDED #if RESOURCES_EMBEDDED
struct tar_entry *entry = tar_get(&G.archive, path); struct tar_entry *entry = tar_get(&G.archive, path);
return (struct resource) { return (struct resource) {
.bytes = entry ? entry->buff : BUFFER(0, 0) .data = entry ? entry->data : STRING(0, 0)
}; };
#else #else
struct sys_file file = sys_file_open_read_wait(path); struct sys_file file = sys_file_open_read_wait(path);
struct sys_file_map file_map = sys_file_map_open_read(file); struct sys_file_map file_map = sys_file_map_open_read(file);
struct buffer bytes = sys_file_map_data(file_map); struct string data = sys_file_map_data(file_map);
return (struct resource) { return (struct resource) {
.bytes = bytes, .data = data,
.file = file, .file = file,
.file_map = file_map .file_map = file_map
}; };

2
src/resource.h
View File

@ -6,7 +6,7 @@
/* Represents raw bytes that can back a resource. This can be file data or embedded /* Represents raw bytes that can back a resource. This can be file data or embedded
* data in the executable. */ * data in the executable. */
struct resource { struct resource {
struct buffer bytes; struct string data;
/* Internal */ /* Internal */
#if !RESOURCES_EMBEDDED #if !RESOURCES_EMBEDDED

16
src/rng.c
View File

@ -20,13 +20,13 @@ INTERNAL void gen_random_file(struct string path, u32 count)
{ {
/* Clear file */ /* Clear file */
struct sys_file f = sys_file_open_write(path); struct sys_file f = sys_file_open_write(path);
sys_file_write(f, BUFFER(0, 0)); sys_file_write(f, STRING(0, 0));
sys_file_close(f); sys_file_close(f);
} }
struct sys_file f = sys_file_open_append(path); struct sys_file f = sys_file_open_append(path);
for (u32 i = 0; i < count; ++i) { for (u32 i = 0; i < count; ++i) {
u64 rand = rng_rand_u64(); u64 rand = rng_rand_u64();
sys_file_write(f, BUFFER_FROM_STRUCT(&rand)); sys_file_write(f, STRING_FROM_STRUCT(&rand));
} }
sys_file_close(f); sys_file_close(f);
} }
@ -40,15 +40,15 @@ struct rng_startup_receipt rng_startup(struct resource_startup_receipt *resource
{ {
(UNUSED)resource_sr; (UNUSED)resource_sr;
G.arena = arena_alloc(GIGABYTE(64)); G.arena = arena_alloc(GIGABYTE(64));
struct string noise_path = STR("res/noise.dat"); struct string noise_path = LIT("res/noise.dat");
if (resource_exists(noise_path)) { if (resource_exists(noise_path)) {
struct resource r = resource_open(noise_path); struct resource r = resource_open(noise_path);
G.noise_count = r.bytes.size / sizeof(*G.noise); G.noise_count = r.data.len / sizeof(*G.noise);
G.noise = arena_push_array(&G.arena, u64, G.noise_count); G.noise = arena_push_array(&G.arena, u64, G.noise_count);
MEMCPY(G.noise, r.bytes.data, r.bytes.size); MEMCPY(G.noise, r.data.text, r.data.len);
resource_close(r); resource_close(r);
} else { } else {
sys_panic(STR("Failed to locate pre-computed noise resource")); sys_panic(LIT("Failed to locate pre-computed noise resource"));
} }
return (struct rng_startup_receipt) { 0 }; return (struct rng_startup_receipt) { 0 };
} }
@ -60,14 +60,14 @@ struct rng_startup_receipt rng_startup(struct resource_startup_receipt *resource
u32 rng_rand_u32(void) u32 rng_rand_u32(void)
{ {
u32 v = 0; u32 v = 0;
sys_rand(BUFFER_FROM_STRUCT(&v)); sys_rand(STRING_FROM_STRUCT(&v));
return v; return v;
} }
u64 rng_rand_u64(void) u64 rng_rand_u64(void)
{ {
u64 v = 0; u64 v = 0;
sys_rand(BUFFER_FROM_STRUCT(&v)); sys_rand(STRING_FROM_STRUCT(&v));
return v; return v;
} }

2
src/scratch.h
View File

@ -32,7 +32,7 @@ INLINE void scratch_dbg_push(struct scratch_ctx *ctx, struct temp_arena *temp)
{ {
#if RTC #if RTC
if (ctx->scratch_id_stack_count >= ARRAY_COUNT(ctx->scratch_id_stack)) { if (ctx->scratch_id_stack_count >= ARRAY_COUNT(ctx->scratch_id_stack)) {
sys_panic(STR("Max debug scratch depth reached")); sys_panic(LIT("Max debug scratch depth reached"));
} }
temp->scratch_id = ctx->next_scratch_id++; temp->scratch_id = ctx->next_scratch_id++;
ctx->scratch_id_stack[ctx->scratch_id_stack_count++] = temp->scratch_id; ctx->scratch_id_stack[ctx->scratch_id_stack_count++] = temp->scratch_id;

60
src/settings.c
View File

@ -5,19 +5,19 @@
#include "scratch.h" #include "scratch.h"
#include "math.h" #include "math.h"
struct buffer settings_serialize(struct arena *arena, const struct sys_window_settings *settings) struct string settings_serialize(struct arena *arena, const struct sys_window_settings *settings)
{ {
__prof; __prof;
struct string minimized = settings->flags & SYS_WINDOW_SETTINGS_FLAG_MINIMIZED ? STR("true") : STR("false"); struct string minimized = settings->flags & SYS_WINDOW_SETTINGS_FLAG_MINIMIZED ? LIT("true") : LIT("false");
struct string maximized = settings->flags & SYS_WINDOW_SETTINGS_FLAG_MAXIMIZED ? STR("true") : STR("false"); struct string maximized = settings->flags & SYS_WINDOW_SETTINGS_FLAG_MAXIMIZED ? LIT("true") : LIT("false");
struct string fullscreen = settings->flags & SYS_WINDOW_SETTINGS_FLAG_FULLSCREEN ? STR("true") : STR("false"); struct string fullscreen = settings->flags & SYS_WINDOW_SETTINGS_FLAG_FULLSCREEN ? LIT("true") : LIT("false");
i32 x = settings->floating_x; i32 x = settings->floating_x;
i32 y = settings->floating_y; i32 y = settings->floating_y;
i32 width = settings->floating_width; i32 width = settings->floating_width;
i32 height = settings->floating_height; i32 height = settings->floating_height;
struct string fmt = STR( struct string fmt = LIT(
"{\n" "{\n"
" \"window\": {\n" " \"window\": {\n"
" \"minimized\": %F,\n" " \"minimized\": %F,\n"
@ -41,10 +41,10 @@ struct buffer settings_serialize(struct arena *arena, const struct sys_window_se
FMT_SINT(width), FMT_SINT(width),
FMT_SINT(height)); FMT_SINT(height));
return BUFFER_FROM_STRING(formatted); return formatted;
} }
struct sys_window_settings *settings_deserialize(struct arena *arena, struct buffer src, struct string *error_out) struct sys_window_settings *settings_deserialize(struct arena *arena, struct string src, struct string *error_out)
{ {
__prof; __prof;
struct temp_arena scratch = scratch_begin(arena); struct temp_arena scratch = scratch_begin(arena);
@ -53,7 +53,7 @@ struct sys_window_settings *settings_deserialize(struct arena *arena, struct buf
struct json_error json_error = ZI; struct json_error json_error = ZI;
struct sys_window_settings *settings = arena_push_zero(arena, struct sys_window_settings); struct sys_window_settings *settings = arena_push_zero(arena, struct sys_window_settings);
struct json_parse_result parse_res = json_from_string(scratch.arena, STRING_FROM_BUFFER(src)); struct json_parse_result parse_res = json_from_string(scratch.arena, src);
if (parse_res.errors.count > 0) { if (parse_res.errors.count > 0) {
json_error = *parse_res.errors.first; json_error = *parse_res.errors.first;
@ -62,13 +62,13 @@ struct sys_window_settings *settings_deserialize(struct arena *arena, struct buf
struct json *root = parse_res.root; struct json *root = parse_res.root;
if (!root) { if (!root) {
error = STR("Root object not found."); error = LIT("Root object not found.");
goto abort; goto abort;
} }
struct json *window = root->child_first; struct json *window = root->child_first;
if (!window || window->type != JSON_TYPE_OBJECT || !string_eq(window->key, STR("window"))) { if (!window || window->type != JSON_TYPE_OBJECT || !string_eq(window->key, LIT("window"))) {
error = STR("\"window\" object not found"); error = LIT("\"window\" object not found");
goto abort; goto abort;
} }
@ -81,48 +81,48 @@ struct sys_window_settings *settings_deserialize(struct arena *arena, struct buf
for (struct json *child = window->child_first; child; child = child->next) { for (struct json *child = window->child_first; child; child = child->next) {
struct string key = child->key; struct string key = child->key;
if (string_eq(key, STR("maximized"))) { if (string_eq(key, LIT("maximized"))) {
if (child->type != JSON_TYPE_BOOL) { if (child->type != JSON_TYPE_BOOL) {
error = STR("Expected boolean for \"maximized\""); error = LIT("Expected boolean for \"maximized\"");
goto abort; goto abort;
} }
if (child->value.boolean) { if (child->value.boolean) {
settings->flags |= SYS_WINDOW_SETTINGS_FLAG_MAXIMIZED; settings->flags |= SYS_WINDOW_SETTINGS_FLAG_MAXIMIZED;
} }
found_maximized = true; found_maximized = true;
} else if (string_eq(key, STR("fullscreen"))) { } else if (string_eq(key, LIT("fullscreen"))) {
if (child->type != JSON_TYPE_BOOL) { if (child->type != JSON_TYPE_BOOL) {
error = STR("Expected boolean for \"fulscreen\""); error = LIT("Expected boolean for \"fulscreen\"");
goto abort; goto abort;
} }
if (child->value.boolean) { if (child->value.boolean) {
settings->flags |= SYS_WINDOW_SETTINGS_FLAG_FULLSCREEN; settings->flags |= SYS_WINDOW_SETTINGS_FLAG_FULLSCREEN;
} }
found_fullscreen = true; found_fullscreen = true;
} else if (string_eq(key, STR("x"))) { } else if (string_eq(key, LIT("x"))) {
if (child->type != JSON_TYPE_NUMBER) { if (child->type != JSON_TYPE_NUMBER) {
error = STR("Expected number for \"x\""); error = LIT("Expected number for \"x\"");
goto abort; goto abort;
} }
settings->floating_x = math_round_to_int(child->value.number); settings->floating_x = math_round_to_int(child->value.number);
found_x = true; found_x = true;
} else if (string_eq(key, STR("y"))) { } else if (string_eq(key, LIT("y"))) {
if (child->type != JSON_TYPE_NUMBER) { if (child->type != JSON_TYPE_NUMBER) {
error = STR("Expected number for \"y\""); error = LIT("Expected number for \"y\"");
goto abort; goto abort;
} }
settings->floating_y = math_round_to_int(child->value.number); settings->floating_y = math_round_to_int(child->value.number);
found_y = true; found_y = true;
} else if (string_eq(key, STR("width"))) { } else if (string_eq(key, LIT("width"))) {
if (child->type != JSON_TYPE_NUMBER) { if (child->type != JSON_TYPE_NUMBER) {
error = STR("Expected number for \"width\""); error = LIT("Expected number for \"width\"");
goto abort; goto abort;
} }
settings->floating_width = math_round_to_int(child->value.number); settings->floating_width = math_round_to_int(child->value.number);
found_width = true; found_width = true;
} else if (string_eq(key, STR("height"))) { } else if (string_eq(key, LIT("height"))) {
if (child->type != JSON_TYPE_NUMBER) { if (child->type != JSON_TYPE_NUMBER) {
error = STR("Expected number for \"height\""); error = LIT("Expected number for \"height\"");
goto abort; goto abort;
} }
settings->floating_height = math_round_to_int(child->value.number); settings->floating_height = math_round_to_int(child->value.number);
@ -130,19 +130,19 @@ struct sys_window_settings *settings_deserialize(struct arena *arena, struct buf
} }
} }
if (!found_maximized) { error = STR("Missing \"maximized\""); goto abort; } if (!found_maximized) { error = LIT("Missing \"maximized\""); goto abort; }
if (!found_fullscreen) { error = STR("Missing \"fullscreen\""); goto abort; } if (!found_fullscreen) { error = LIT("Missing \"fullscreen\""); goto abort; }
if (!found_x) { error = STR("Missing \"x\""); goto abort; } if (!found_x) { error = LIT("Missing \"x\""); goto abort; }
if (!found_y) { error = STR("Missing \"y\""); goto abort; } if (!found_y) { error = LIT("Missing \"y\""); goto abort; }
if (!found_width) { error = STR("Missing \"width\""); goto abort; } if (!found_width) { error = LIT("Missing \"width\""); goto abort; }
if (!found_height) { error = STR("Missing \"height\""); goto abort; } if (!found_height) { error = LIT("Missing \"height\""); goto abort; }
abort: abort:
if (error_out && (error.len > 0 || json_error.msg.len > 0)) { if (error_out && (error.len > 0 || json_error.msg.len > 0)) {
if (json_error.msg.len > 0) { if (json_error.msg.len > 0) {
*error_out = string_format(arena, *error_out = string_format(arena,
STR("%F\n(%F:%F)"), LIT("%F\n(%F:%F)"),
FMT_STR(json_error.msg), FMT_STR(json_error.msg),
FMT_UINT(json_error.start), FMT_UINT(json_error.start),
FMT_UINT(json_error.end)); FMT_UINT(json_error.end));

4
src/settings.h
View File

@ -3,7 +3,7 @@
struct sys_window_settings; struct sys_window_settings;
struct buffer settings_serialize(struct arena *arena, const struct sys_window_settings *settings); struct string settings_serialize(struct arena *arena, const struct sys_window_settings *settings);
struct sys_window_settings *settings_deserialize(struct arena *arena, struct buffer src, struct string *error_out); struct sys_window_settings *settings_deserialize(struct arena *arena, struct string src, struct string *error_out);
#endif #endif

16
src/sound.c
View File

@ -94,9 +94,9 @@ INTERNAL WORK_TASK_FUNC_DEF(sound_load_asset_task, vparams)
i64 start_ns = sys_time_ns(); i64 start_ns = sys_time_ns();
b32 success = true; b32 success = true;
struct string error_msg = STR("Unknown error"); struct string error_msg = LIT("Unknown error");
ASSERT(string_ends_with(path, STR(".mp3"))); ASSERT(string_ends_with(path, LIT(".mp3")));
if (resource_exists(path)) { if (resource_exists(path)) {
u64 decode_flags = 0; u64 decode_flags = 0;
if (flags & SOUND_FLAG_STEREO) { if (flags & SOUND_FLAG_STEREO) {
@ -105,12 +105,12 @@ INTERNAL WORK_TASK_FUNC_DEF(sound_load_asset_task, vparams)
/* Decode */ /* Decode */
struct resource sound_rs = resource_open(path); struct resource sound_rs = resource_open(path);
struct mp3_decode_result decoded = mp3_decode(scratch.arena, sound_rs.bytes, decode_flags); struct mp3_decode_result decoded = mp3_decode(scratch.arena, sound_rs.data, decode_flags);
resource_close(sound_rs); resource_close(sound_rs);
if (!decoded.success) { if (!decoded.success) {
success = false; success = false;
error_msg = STR("Failed to decode sound file"); error_msg = LIT("Failed to decode sound file");
goto abort; goto abort;
} }
@ -138,7 +138,7 @@ INTERNAL WORK_TASK_FUNC_DEF(sound_load_asset_task, vparams)
asset_cache_mark_ready(asset, sound); asset_cache_mark_ready(asset, sound);
} else { } else {
success = false; success = false;
error_msg = STR("Resource not found"); error_msg = LIT("Resource not found");
goto abort; goto abort;
} }
@ -171,7 +171,7 @@ struct asset *sound_load_asset(struct string path, u32 flags, b32 help)
/* Generate and append sound flags to path key */ /* Generate and append sound flags to path key */
struct string key = string_format(scratch.arena, struct string key = string_format(scratch.arena,
STR("%F%F_sound"), LIT("%F%F_sound"),
FMT_STR(path), FMT_STR(path),
FMT_UINT((u64)flags)); FMT_UINT((u64)flags));
u64 hash = asset_cache_hash(key); u64 hash = asset_cache_hash(key);
@ -183,10 +183,10 @@ struct asset *sound_load_asset(struct string path, u32 flags, b32 help)
struct sound_task_params *params = sound_task_params_alloc(); struct sound_task_params *params = sound_task_params_alloc();
if (path.len > (sizeof(params->path_cstr) - 1)) { if (path.len > (sizeof(params->path_cstr) - 1)) {
sys_panic(string_format(scratch.arena, sys_panic(string_format(scratch.arena,
STR("Sound path \"%F\" too long!"), LIT("Sound path \"%F\" too long!"),
FMT_STR(path))); FMT_STR(path)));
} }
cstr_buff_from_string(BUFFER_FROM_ARRAY(params->path_cstr), path); cstr_buff_from_string(STRING_FROM_ARRAY(params->path_cstr), path);
params->path_len = path.len; params->path_len = path.len;
params->asset = asset; params->asset = asset;
params->flags = flags; params->flags = flags;

20
src/sprite.c
View File

@ -259,7 +259,7 @@ struct sprite_startup_receipt sprite_startup(struct renderer_startup_receipt *re
G.evictor_mutex = sys_mutex_alloc(); G.evictor_mutex = sys_mutex_alloc();
G.evictor_cv = sys_condition_variable_alloc(); G.evictor_cv = sys_condition_variable_alloc();
G.evictor_thread = sys_thread_alloc(sprite_evictor_thread_entry_point, NULL, STR("[P0] Sprite evictor")); G.evictor_thread = sys_thread_alloc(sprite_evictor_thread_entry_point, NULL, LIT("[P0] Sprite evictor"));
app_register_exit_callback(&sprite_shutdown); app_register_exit_callback(&sprite_shutdown);
@ -287,7 +287,7 @@ struct sprite_tag sprite_tag_from_path(struct string path)
{ {
struct sprite_tag res = ZI; struct sprite_tag res = ZI;
res.hash = HASH_FNV128_BASIS; res.hash = HASH_FNV128_BASIS;
res.hash = hash_fnv128(res.hash, BUFFER_FROM_STRING(path)); res.hash = hash_fnv128(res.hash, path);
res.path = path; res.path = path;
return res; return res;
} }
@ -304,7 +304,7 @@ b32 sprite_tag_eq(struct sprite_tag t1, struct sprite_tag t2)
INTERNAL struct cache_node_hash cache_node_hash_from_tag_hash(u128 tag_hash, enum cache_node_kind kind) INTERNAL struct cache_node_hash cache_node_hash_from_tag_hash(u128 tag_hash, enum cache_node_kind kind)
{ {
return (struct cache_node_hash) { .v = hash_fnv128(tag_hash, BUFFER(1, (u8 *)&kind)) }; return (struct cache_node_hash) { .v = hash_fnv128(tag_hash, STRING(1, (u8 *)&kind)) };
} }
/* ========================== * /* ========================== *
@ -344,7 +344,7 @@ INTERNAL void cache_node_load_texture(struct cache_node *n, struct sprite_tag ta
logf_info("Loading sprite texture \"%F\"", FMT_STR(path)); logf_info("Loading sprite texture \"%F\"", FMT_STR(path));
i64 start_ns = sys_time_ns(); i64 start_ns = sys_time_ns();
ASSERT(string_ends_with(path, STR(".ase"))); ASSERT(string_ends_with(path, LIT(".ase")));
ASSERT(n->kind == CACHE_NODE_KIND_TEXTURE); ASSERT(n->kind == CACHE_NODE_KIND_TEXTURE);
/* TODO: Arena probably overkill. Just using it to store texture struct. */ /* TODO: Arena probably overkill. Just using it to store texture struct. */
@ -355,7 +355,7 @@ INTERNAL void cache_node_load_texture(struct cache_node *n, struct sprite_tag ta
struct ase_decode_image_result decoded = ZI; struct ase_decode_image_result decoded = ZI;
if (resource_exists(path)) { if (resource_exists(path)) {
struct resource texture_rs = resource_open(path); struct resource texture_rs = resource_open(path);
decoded = ase_decode_image(scratch.arena, texture_rs.bytes); decoded = ase_decode_image(scratch.arena, texture_rs.data);
#if RESOURCE_RELOADING #if RESOURCE_RELOADING
n->initial_resource_file_modified_time = sys_file_get_time(texture_rs.file).modified; n->initial_resource_file_modified_time = sys_file_get_time(texture_rs.file).modified;
#endif #endif
@ -602,7 +602,7 @@ INTERNAL struct sprite_sheet init_sheet_from_ase_result(struct arena *arena, str
/* Calculate dirs */ /* Calculate dirs */
for (struct temp_slice_group_node *temp_slice_group_node = temp_slice_group_head; temp_slice_group_node; temp_slice_group_node = temp_slice_group_node->next) { for (struct temp_slice_group_node *temp_slice_group_node = temp_slice_group_head; temp_slice_group_node; temp_slice_group_node = temp_slice_group_node->next) {
struct string ray_suffix = STR(".ray"); struct string ray_suffix = LIT(".ray");
struct sprite_sheet_slice_group *ray_slice_group = temp_slice_group_node->final_slice_group; struct sprite_sheet_slice_group *ray_slice_group = temp_slice_group_node->final_slice_group;
struct string ray_slice_name = ray_slice_group->name; struct string ray_slice_name = ray_slice_group->name;
@ -650,7 +650,7 @@ INTERNAL void cache_node_load_sheet(struct cache_node *n, struct sprite_tag tag)
logf_info("Loading sprite sheet \"%F\"", FMT_STR(path)); logf_info("Loading sprite sheet \"%F\"", FMT_STR(path));
i64 start_ns = sys_time_ns(); i64 start_ns = sys_time_ns();
//ASSERT(string_ends_with(path, STR(".ase"))); //ASSERT(string_ends_with(path, LIT(".ase")));
ASSERT(n->kind == CACHE_NODE_KIND_SHEET); ASSERT(n->kind == CACHE_NODE_KIND_SHEET);
n->arena = arena_alloc(SHEET_ARENA_RESERVE); n->arena = arena_alloc(SHEET_ARENA_RESERVE);
@ -659,7 +659,7 @@ INTERNAL void cache_node_load_sheet(struct cache_node *n, struct sprite_tag tag)
struct ase_decode_sheet_result decoded = ZI; struct ase_decode_sheet_result decoded = ZI;
if (resource_exists(path)) { if (resource_exists(path)) {
struct resource sheet_rs = resource_open(path); struct resource sheet_rs = resource_open(path);
decoded = ase_decode_sheet(scratch.arena, sheet_rs.bytes); decoded = ase_decode_sheet(scratch.arena, sheet_rs.data);
#if RESOURCE_RELOADING #if RESOURCE_RELOADING
n->initial_resource_file_modified_time = sys_file_get_time(sheet_rs.file).modified; n->initial_resource_file_modified_time = sys_file_get_time(sheet_rs.file).modified;
#endif #endif
@ -975,14 +975,14 @@ struct sprite_sheet_slice sprite_sheet_get_slice(struct sprite_sheet *sheet, str
/* Return 'pivot' by default */ /* Return 'pivot' by default */
struct sprite_sheet_slice res = ZI; struct sprite_sheet_slice res = ZI;
if (string_eq(name, STR("pivot"))) { if (string_eq(name, LIT("pivot"))) {
/* 'pivot' slice does not exist, return center */ /* 'pivot' slice does not exist, return center */
res.center = V2(0, 0); res.center = V2(0, 0);
res.center_px = v2_mul(sheet->frame_size, 0.5f); res.center_px = v2_mul(sheet->frame_size, 0.5f);
res.dir_px = V2(res.center_px.x, 0); res.dir_px = V2(res.center_px.x, 0);
res.dir = V2(0, -0.5); res.dir = V2(0, -0.5);
} else { } else {
res = sprite_sheet_get_slice(sheet, STR("pivot"), frame_index); res = sprite_sheet_get_slice(sheet, LIT("pivot"), frame_index);
} }
return res; return res;

46
src/string.c
View File

@ -11,7 +11,7 @@
* All string functions return a new string as a result. Any strings used as * All string functions return a new string as a result. Any strings used as
* an argument (IE: in string_cat) will not be modified. * an argument (IE: in string_cat) will not be modified.
* *
* Use the STR macro to create strings from string literals * Use the LIT macro to create strings from string literals
* *
* NOTE: It is valid for a string to have len 0 but a non-NULL text pointer. * NOTE: It is valid for a string to have len 0 but a non-NULL text pointer.
* Always check string.len rather than string.text for string presence. * Always check string.len rather than string.text for string presence.
@ -86,7 +86,7 @@ struct string string_from_int(struct arena *arena, i64 n, u32 base)
struct string string_from_ptr(struct arena *arena, void *ptr) struct string string_from_ptr(struct arena *arena, void *ptr)
{ {
struct string prepend = string_copy(arena, STR("0x")); struct string prepend = string_copy(arena, LIT("0x"));
struct string uint_str = string_from_uint(arena, (u64)ptr, 16); struct string uint_str = string_from_uint(arena, (u64)ptr, 16);
return (struct string) { return (struct string) {
.len = prepend.len + uint_str.len, .len = prepend.len + uint_str.len,
@ -101,11 +101,11 @@ struct string string_from_float(struct arena *arena, f64 f, u32 precision)
u64 final_len = 0; u64 final_len = 0;
if (F32_IS_NAN(f)) { if (F32_IS_NAN(f)) {
final_len += string_copy(arena, STR("NaN")).len; final_len += string_copy(arena, LIT("NaN")).len;
} else if (f == F64_INFINITY) { } else if (f == F64_INFINITY) {
final_len += string_copy(arena, STR("inf")).len; final_len += string_copy(arena, LIT("inf")).len;
} else if (f == -F64_INFINITY) { } else if (f == -F64_INFINITY) {
final_len += string_copy(arena, STR("-inf")).len; final_len += string_copy(arena, LIT("-inf")).len;
} else { } else {
if (f < 0) { if (f < 0) {
string_from_char(arena, '-'); string_from_char(arena, '-');
@ -173,15 +173,13 @@ struct string string_copy(struct arena *arena, struct string src)
return str; return str;
} }
struct string string_copy_buff(struct buffer dest_buff, struct string src) struct string string_copy_to_string(struct string dst, struct string src)
{ {
u64 len = min_u64(dest_buff.size, src.len); struct string res = ZI;
struct string str = { res.len = min_u64(dst.len, src.len);
.len = len, res.text = dst.text;
.text = dest_buff.data MEMCPY(res.text, src.text, res.len);
}; return res;
MEMCPY(str.text, src.text, src.len);
return str;
} }
struct string string_repeat(struct arena *arena, struct string src, u64 count) struct string string_repeat(struct arena *arena, struct string src, u64 count)
@ -256,7 +254,7 @@ struct string string_indent(struct arena *arena, struct string str, u32 indent)
u64 final_len = 0; u64 final_len = 0;
u8 *final_text = arena_dry_push(arena, u8); u8 *final_text = arena_dry_push(arena, u8);
struct string_array split = string_split(scratch.arena, str, STR("\n")); struct string_array split = string_split(scratch.arena, str, LIT("\n"));
for (u64 i = 0; i < split.count; ++i) { for (u64 i = 0; i < split.count; ++i) {
struct string piece = split.strings[i]; struct string piece = split.strings[i];
for (u32 j = 0; j < indent; ++j) { for (u32 j = 0; j < indent; ++j) {
@ -390,8 +388,8 @@ b32 string_ends_with(struct string str, struct string substring)
* *
* Example: * Example:
* string_format(arena, * string_format(arena,
* STR("Hello there %F. You are %F feet %F inches tall!"), * LIT("Hello there %F. You are %F feet %F inches tall!"),
* FMT_STR(STR("George")), * FMT_STR(LIT("George")),
* FMT_UINT(6), * FMT_UINT(6),
* FMT_FLOAT(5.375)); * FMT_FLOAT(5.375));
* *
@ -470,14 +468,14 @@ struct string string_formatv(struct arena *arena, struct string fmt, va_list arg
case FMT_TYPE_END: { case FMT_TYPE_END: {
/* Unexpected end. Not enough FMT args passed to function. */ /* Unexpected end. Not enough FMT args passed to function. */
ASSERT(false); ASSERT(false);
parsed_str = string_copy(arena, STR("<?>")); parsed_str = string_copy(arena, LIT("<?>"));
no_more_args = true; no_more_args = true;
} break; } break;
default: { default: {
/* Unknown format type */ /* Unknown format type */
ASSERT(false); ASSERT(false);
parsed_str = string_copy(arena, STR("<?>")); parsed_str = string_copy(arena, LIT("<?>"));
no_more_args = true; no_more_args = true;
} break; } break;
} }
@ -668,14 +666,14 @@ char *cstr_from_string(struct arena *arena, struct string src)
return (char *)text; return (char *)text;
} }
char *cstr_buff_from_string(struct buffer dest_buff, struct string src) char *cstr_buff_from_string(struct string dest_buff, struct string src)
{ {
if (dest_buff.size > 0) { if (dest_buff.len > 0) {
u64 len = min_u64(src.len, dest_buff.size - 1); u64 len = min_u64(src.len, dest_buff.len - 1);
MEMCPY(dest_buff.data, src.text, len); MEMCPY(dest_buff.text, src.text, len);
dest_buff.data[len] = 0; dest_buff.text[len] = 0;
} }
return (char *)dest_buff.data; return (char *)dest_buff.text;
} }
struct string string_from_cstr(char *cstr) struct string string_from_cstr(char *cstr)

4
src/string.h
View File

@ -21,7 +21,7 @@ struct string string_from_float(struct arena *arena, f64 f, u32 precision);
* ========================== */ * ========================== */
struct string string_copy(struct arena *arena, struct string src); struct string string_copy(struct arena *arena, struct string src);
struct string string_copy_buff(struct buffer dest_buff, struct string src); struct string string_copy_to_string(struct string dst, struct string src);
struct string string_repeat(struct arena *arena, struct string src, u64 count); struct string string_repeat(struct arena *arena, struct string src, u64 count);
struct string string_cat(struct arena *arena, struct string str1, struct string str2); struct string string_cat(struct arena *arena, struct string str1, struct string str2);
struct string_array string_split(struct arena *arena, struct string str, struct string delim); struct string_array string_split(struct arena *arena, struct string str, struct string delim);
@ -112,7 +112,7 @@ struct string32 string32_from_string(struct arena *arena, struct string str8);
u64 cstr_len(char *cstr); u64 cstr_len(char *cstr);
char *cstr_from_string(struct arena *arena, struct string src); char *cstr_from_string(struct arena *arena, struct string src);
char *cstr_buff_from_string(struct buffer dest_buff, struct string src); char *cstr_buff_from_string(struct string dest_buff, struct string src);
struct string string_from_cstr(char *cstr); struct string string_from_cstr(char *cstr);
struct string string_from_cstr_len(char *cstr, u64 len); struct string string_from_cstr_len(char *cstr, u64 len);

10
src/sys.h
View File

@ -219,8 +219,8 @@ struct sys_file sys_file_open_write(struct string path);
struct sys_file sys_file_open_append(struct string path); struct sys_file sys_file_open_append(struct string path);
void sys_file_close(struct sys_file file); void sys_file_close(struct sys_file file);
struct buffer sys_file_read_all(struct arena *arena, struct sys_file file); struct string sys_file_read_all(struct arena *arena, struct sys_file file);
void sys_file_write(struct sys_file file, struct buffer data); void sys_file_write(struct sys_file file, struct string data);
u64 sys_file_get_size(struct sys_file file); u64 sys_file_get_size(struct sys_file file);
struct sys_file_time sys_file_get_time(struct sys_file file); struct sys_file_time sys_file_get_time(struct sys_file file);
@ -229,13 +229,13 @@ struct sys_file_time sys_file_get_time(struct sys_file file);
* ========================== */ * ========================== */
struct sys_file_map { struct sys_file_map {
struct buffer mapped_memory; struct string mapped_memory;
u64 handle; u64 handle;
}; };
struct sys_file_map sys_file_map_open_read(struct sys_file file); struct sys_file_map sys_file_map_open_read(struct sys_file file);
void sys_file_map_close(struct sys_file_map map); void sys_file_map_close(struct sys_file_map map);
struct buffer sys_file_map_data(struct sys_file_map map); struct string sys_file_map_data(struct sys_file_map map);
/* ========================== * /* ========================== *
* Dir iter * Dir iter
@ -442,7 +442,7 @@ struct string sys_get_clipboard_text(struct arena *arena);
* Util * Util
* ========================== */ * ========================== */
void sys_rand(struct buffer b); void sys_rand(struct string b);
u32 sys_num_logical_processors(void); u32 sys_num_logical_processors(void);
void sys_exit(void); void sys_exit(void);
void sys_panic(struct string msg); void sys_panic(struct string msg);

62
src/sys_win32.c
View File

@ -328,26 +328,26 @@ void sys_mkdir(struct string path)
struct string err = ZI; struct string err = ZI;
switch (err_code) { switch (err_code) {
case ERROR_BAD_PATHNAME: { case ERROR_BAD_PATHNAME: {
err = STR("Bad path name"); err = LIT("Bad path name");
} break; } break;
case ERROR_FILENAME_EXCED_RANGE: { case ERROR_FILENAME_EXCED_RANGE: {
err = STR("Path name too long"); err = LIT("Path name too long");
} break; } break;
case ERROR_FILE_EXISTS: { case ERROR_FILE_EXISTS: {
err = STR("A file already exists at this location"); err = LIT("A file already exists at this location");
} break; } break;
case ERROR_CANCELLED: { case ERROR_CANCELLED: {
err = STR("User canceled the operation"); err = LIT("User canceled the operation");
} break; } break;
default: break; default: break;
} }
if (err.len > 0) { if (err.len > 0) {
struct string msg = string_format(scratch.arena, struct string msg = string_format(scratch.arena,
STR("Failed to create directory \"%F\": %F"), LIT("Failed to create directory \"%F\": %F"),
FMT_STR(path), FMT_STR(path),
FMT_STR(err)); FMT_STR(err));
sys_panic(msg); sys_panic(msg);
@ -447,52 +447,52 @@ void sys_file_close(struct sys_file file)
CloseHandle((HANDLE)file.handle); CloseHandle((HANDLE)file.handle);
} }
struct buffer sys_file_read_all(struct arena *arena, struct sys_file file) struct string sys_file_read_all(struct arena *arena, struct sys_file file)
{ {
__prof; __prof;
i64 size = 0; i64 size = 0;
GetFileSizeEx((HANDLE)file.handle, (PLARGE_INTEGER)&size); GetFileSizeEx((HANDLE)file.handle, (PLARGE_INTEGER)&size);
struct buffer buff = { struct string s = {
.size = size, .len = size,
.data = NULL .text = NULL
}; };
if (size > 0) { if (size > 0) {
/* ReadFile returns non-zero on success */ /* ReadFile returns non-zero on success */
/* TODO: error checking */ /* TODO: error checking */
arena_align(arena, 16); arena_align(arena, 16);
buff.data = arena_push_array(arena, u8, size); s.text = arena_push_array(arena, u8, size);
(UNUSED)ReadFile( (UNUSED)ReadFile(
(HANDLE)file.handle, (HANDLE)file.handle,
buff.data, s.text,
(DWORD)buff.size, (DWORD)s.len,
NULL, /* lpNumberOfBytesRead */ NULL, /* lpNumberOfBytesRead */
NULL NULL
); );
} }
return buff; return s;
} }
void sys_file_write(struct sys_file file, struct buffer data) void sys_file_write(struct sys_file file, struct string data)
{ {
__prof; __prof;
/* TODO: Check what the real data limit is and chunk sequentially based on /* TODO: Check what the real data limit is and chunk sequentially based on
* that (rather than failing) */ * that (rather than failing) */
if (data.size >= 0x7FFF) { if (data.len >= 0x7FFF) {
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
sys_panic(string_format(scratch.arena, sys_panic(string_format(scratch.arena,
STR("Tried to write too many bytes to disk (%F)"), LIT("Tried to write too many bytes to disk (%F)"),
FMT_UINT(data.size))); FMT_UINT(data.len)));
scratch_end(scratch); scratch_end(scratch);
} }
/* WriteFile returns TRUE on success */ /* WriteFile returns TRUE on success */
(UNUSED)WriteFile( (UNUSED)WriteFile(
(HANDLE)file.handle, (HANDLE)file.handle,
data.data, data.text,
(DWORD)data.size, (DWORD)data.len,
NULL, /* lpNumberOfBytesWritten */ NULL, /* lpNumberOfBytesWritten */
NULL NULL
); );
@ -587,21 +587,21 @@ struct sys_file_map sys_file_map_open_read(struct sys_file file)
return (struct sys_file_map) { return (struct sys_file_map) {
.handle = (u64)map_handle, .handle = (u64)map_handle,
.mapped_memory = BUFFER(size, base_ptr) .mapped_memory = STRING(size, base_ptr)
}; };
} }
void sys_file_map_close(struct sys_file_map map) void sys_file_map_close(struct sys_file_map map)
{ {
if (map.mapped_memory.data) { if (map.mapped_memory.text) {
UnmapViewOfFile(map.mapped_memory.data); UnmapViewOfFile(map.mapped_memory.text);
} }
if (map.handle) { if (map.handle) {
CloseHandle((HANDLE)map.handle); CloseHandle((HANDLE)map.handle);
} }
} }
struct buffer sys_file_map_data(struct sys_file_map map) struct string sys_file_map_data(struct sys_file_map map)
{ {
return map.mapped_memory; return map.mapped_memory;
} }
@ -640,7 +640,7 @@ b32 sys_file_filter_next(struct arena *arena, struct sys_file_filter *filter)
if (found) { if (found) {
struct string file_name = string_from_wstr(arena, find_file_data.cFileName); struct string file_name = string_from_wstr(arena, find_file_data.cFileName);
if (string_eq(file_name, STR(".")) || string_eq(file_name, STR(".."))) { if (string_eq(file_name, LIT(".")) || string_eq(file_name, LIT(".."))) {
/* Skip initial '.' and '..' matches */ /* Skip initial '.' and '..' matches */
found = sys_file_filter_next(arena, filter); found = sys_file_filter_next(arena, filter);
} else { } else {
@ -815,7 +815,7 @@ INTERNAL struct win32_window *win32_window_alloc(void)
window->event_callbacks_mutex = sys_mutex_alloc(); window->event_callbacks_mutex = sys_mutex_alloc();
/* Start window thread for processing events */ /* Start window thread for processing events */
window->event_thread = sys_thread_alloc(&window_thread_entry_point, window, STR("[P8] Window thread")); window->event_thread = sys_thread_alloc(&window_thread_entry_point, window, LIT("[P8] Window thread"));
/* Wait for event thread to create actual window */ /* Wait for event thread to create actual window */
sync_flag_wait(&window->ready_sf); sync_flag_wait(&window->ready_sf);
@ -1215,7 +1215,7 @@ void sys_window_register_event_callback(struct sys_window *sys_window, sys_windo
struct sys_lock lock = sys_mutex_lock_e(&window->event_callbacks_mutex); struct sys_lock lock = sys_mutex_lock_e(&window->event_callbacks_mutex);
{ {
if (window->event_callbacks_count + 1 > ARRAY_COUNT(window->event_callbacks)) { if (window->event_callbacks_count + 1 > ARRAY_COUNT(window->event_callbacks)) {
sys_panic(STR("Too many window event callbacks registered")); sys_panic(LIT("Too many window event callbacks registered"));
} else { } else {
window->event_callbacks[window->event_callbacks_count++] = func; window->event_callbacks[window->event_callbacks_count++] = func;
} }
@ -1721,7 +1721,7 @@ struct sys_thread sys_thread_alloc(sys_thread_entry_point_func *entry_point, voi
t->thread_data = thread_data; t->thread_data = thread_data;
/* Copy thread name to params */ /* Copy thread name to params */
cstr_buff_from_string(BUFFER_FROM_ARRAY(t->thread_name_cstr), thread_name); cstr_buff_from_string(STRING_FROM_ARRAY(t->thread_name_cstr), thread_name);
t->handle = CreateThread( t->handle = CreateThread(
NULL, NULL,
@ -1733,7 +1733,7 @@ struct sys_thread sys_thread_alloc(sys_thread_entry_point_func *entry_point, voi
); );
if (!t->handle) { if (!t->handle) {
sys_panic(STR("Failed to create thread")); sys_panic(LIT("Failed to create thread"));
} }
res.handle = (u64)t; res.handle = (u64)t;
@ -1861,9 +1861,9 @@ struct string sys_get_clipboard_text(struct arena *arena)
* RNG * RNG
* ========================== */ * ========================== */
void sys_rand(struct buffer b) void sys_rand(struct string b)
{ {
BCryptGenRandom(BCRYPT_RNG_ALG_HANDLE, (PUCHAR)b.data, b.size, 0); BCryptGenRandom(BCRYPT_RNG_ALG_HANDLE, (PUCHAR)b.text, b.len, 0);
} }
u32 sys_num_logical_processors(void) u32 sys_num_logical_processors(void)
@ -2149,7 +2149,7 @@ int CALLBACK wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev_instance,
/* Call app thread and wait for return */ /* Call app thread and wait for return */
{ {
/* Start app thread */ /* Start app thread */
struct sys_thread app_thread = sys_thread_alloc(&app_thread_entry_point, NULL, STR("[P9] App thread")); struct sys_thread app_thread = sys_thread_alloc(&app_thread_entry_point, NULL, LIT("[P9] App thread"));
/* Get app thread handle */ /* Get app thread handle */
HANDLE app_thread_handle = 0; HANDLE app_thread_handle = 0;

8
src/tar.c
View File

@ -65,7 +65,7 @@ INTERNAL u64 str_oct_to_u64(struct string str)
* copying is done. Accessing the archive assumes that the data it's derived * copying is done. Accessing the archive assumes that the data it's derived
* from is valid (AKA open if from a file / memory map). * from is valid (AKA open if from a file / memory map).
*/ */
struct tar_archive tar_parse(struct arena *arena, struct buffer data, struct string prefix) struct tar_archive tar_parse(struct arena *arena, struct string data, struct string prefix)
{ {
__prof; __prof;
@ -78,7 +78,7 @@ struct tar_archive tar_parse(struct arena *arena, struct buffer data, struct str
struct tar_header header = ZI; struct tar_header header = ZI;
br_read_to_struct(&br, &header); br_read_to_struct(&br, &header);
if (!string_eq(STRING_FROM_ARRAY(header.ustar_indicator), STR("ustar\0"))) { if (!string_eq(STRING_FROM_ARRAY(header.ustar_indicator), LIT("ustar\0"))) {
/* Invalid header */ /* Invalid header */
ASSERT(false); ASSERT(false);
continue; continue;
@ -97,7 +97,7 @@ struct tar_archive tar_parse(struct arena *arena, struct buffer data, struct str
if (!file_data_ptr) { if (!file_data_ptr) {
file_size = 0; file_size = 0;
} }
struct buffer file_data = BUFFER(file_size, file_data_ptr); struct string file_data = STRING(file_size, file_data_ptr);
/* Skip sector padding */ /* Skip sector padding */
u64 remaining = (512 - (file_size % 512)) % 512; u64 remaining = (512 - (file_size % 512)) % 512;
@ -123,7 +123,7 @@ struct tar_archive tar_parse(struct arena *arena, struct buffer data, struct str
*entry = (struct tar_entry) { *entry = (struct tar_entry) {
.is_dir = is_dir, .is_dir = is_dir,
.file_name = file_name, .file_name = file_name,
.buff = file_data .data = file_data
}; };
entry->next = archive.head; entry->next = archive.head;

4
src/tar.h
View File

@ -5,7 +5,7 @@
struct tar_entry { struct tar_entry {
struct string file_name; struct string file_name;
struct buffer buff; struct string data;
b32 is_dir; b32 is_dir;
struct tar_entry *next; struct tar_entry *next;
@ -17,7 +17,7 @@ struct tar_archive {
struct tar_entry *head; struct tar_entry *head;
}; };
struct tar_archive tar_parse(struct arena *arena, struct buffer data, struct string prefix); struct tar_archive tar_parse(struct arena *arena, struct string data, struct string prefix);
struct tar_entry *tar_get(const struct tar_archive *archive, struct string name); struct tar_entry *tar_get(const struct tar_archive *archive, struct string name);
#endif #endif

2
src/thread_local.c
View File

@ -72,7 +72,7 @@ void *_thread_local_var_eval(struct thread_local_var_meta *meta)
if (id_plus_one == 0) { if (id_plus_one == 0) {
id = G.metas_count++; id = G.metas_count++;
if (id >= MAX_THREAD_LOCAL_VARS) { if (id >= MAX_THREAD_LOCAL_VARS) {
sys_panic(STR("Maximum number of thread local variables reached")); sys_panic(LIT("Maximum number of thread local variables reached"));
} }
atomic_u64_eval_exchange(&meta->id_plus_one, id + 1); atomic_u64_eval_exchange(&meta->id_plus_one, id + 1);
G.metas[id] = *meta; G.metas[id] = *meta;

2
src/ttf.h
View File

@ -14,6 +14,6 @@ struct ttf_decode_result {
struct ttf_startup_receipt { i32 _; }; struct ttf_startup_receipt { i32 _; };
struct ttf_startup_receipt ttf_startup(void); struct ttf_startup_receipt ttf_startup(void);
struct ttf_decode_result ttf_decode(struct arena *arena, struct buffer encoded, f32 point_size, u32 *cache_codes, u32 cache_codes_count); struct ttf_decode_result ttf_decode(struct arena *arena, struct string encoded, f32 point_size, u32 *cache_codes, u32 cache_codes_count);
#endif #endif

6
src/ttf_dwrite.cpp
View File

@ -68,13 +68,13 @@ struct ttf_startup_receipt ttf_startup(void)
# pragma clang diagnostic pop # pragma clang diagnostic pop
#endif #endif
if (error != S_OK) { if (error != S_OK) {
sys_panic(STR("Error creating DWrite factory")); sys_panic(LIT("Error creating DWrite factory"));
} }
return { 0 }; return { 0 };
} }
struct ttf_decode_result ttf_decode(struct arena *arena, struct buffer encoded, f32 point_size, u32 *cache_codes, u32 cache_codes_count) struct ttf_decode_result ttf_decode(struct arena *arena, struct string encoded, f32 point_size, u32 *cache_codes, u32 cache_codes_count)
{ {
COLORREF bg_color = RGB_32(0,0,0); COLORREF bg_color = RGB_32(0,0,0);
COLORREF fg_color = RGB_32(255,255,255); COLORREF fg_color = RGB_32(255,255,255);
@ -95,7 +95,7 @@ struct ttf_decode_result ttf_decode(struct arena *arena, struct buffer encoded,
IDWriteFontSetBuilder1 *builder = NULL; IDWriteFontSetBuilder1 *builder = NULL;
error = factory->CreateFontSetBuilder(&builder); error = factory->CreateFontSetBuilder(&builder);
error = loader->CreateInMemoryFontFileReference(factory, encoded.data, (u32)encoded.size, NULL, &font_file); error = loader->CreateInMemoryFontFileReference(factory, encoded.text, (u32)encoded.len, NULL, &font_file);
error = builder->AddFontFile(font_file); error = builder->AddFontFile(font_file);
} }

68
src/user.c
View File

@ -163,7 +163,7 @@ struct user_startup_receipt user_startup(struct work_startup_receipt *work_sr,
G.debug_draw = true; G.debug_draw = true;
G.user_thread = sys_thread_alloc(&user_thread_entry_point, NULL, STR("[P1] User thread")); G.user_thread = sys_thread_alloc(&user_thread_entry_point, NULL, LIT("[P1] User thread"));
app_register_exit_callback(&user_shutdown); app_register_exit_callback(&user_shutdown);
return (struct user_startup_receipt) { 0 }; return (struct user_startup_receipt) { 0 };
@ -185,11 +185,11 @@ INTERNAL struct sys_event_array pop_sys_events(struct arena *arena)
struct sys_event_array array = ZI; struct sys_event_array array = ZI;
struct sys_lock lock = sys_mutex_lock_e(&G.sys_events_mutex); struct sys_lock lock = sys_mutex_lock_e(&G.sys_events_mutex);
{ {
struct buffer events_buff = arena_to_buffer(&G.sys_events_arena); struct string events_buff = arena_to_string(&G.sys_events_arena);
arena_align(arena, alignof(struct sys_event)); arena_align(arena, alignof(struct sys_event));
array.events = (struct sys_event *)arena_push_array(arena, u8, events_buff.size); array.events = (struct sys_event *)arena_push_array(arena, u8, events_buff.len);
array.count = events_buff.size / sizeof(struct sys_event); array.count = events_buff.len / sizeof(struct sys_event);
MEMCPY(array.events, events_buff.data, events_buff.size); MEMCPY(array.events, events_buff.text, events_buff.len);
arena_reset(&G.sys_events_arena); arena_reset(&G.sys_events_arena);
} }
sys_mutex_unlock(&lock); sys_mutex_unlock(&lock);
@ -375,8 +375,8 @@ INTERNAL void queue_game_cmd(struct arena *arena, struct game_cmd_list *list, st
INTERNAL void pubilsh_game_cmds(struct game_cmd_list *list) INTERNAL void pubilsh_game_cmds(struct game_cmd_list *list)
{ {
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
struct buffer buff = game_string_from_cmds(scratch.arena, list); struct string s = game_string_from_cmds(scratch.arena, list);
game_push_cmds_string(buff); game_push_cmds_string(s);
scratch_end(scratch); scratch_end(scratch);
} }
@ -722,7 +722,7 @@ INTERNAL void user_update(void)
i64 frequency_ns = NS_FROM_SECONDS(0.01f); i64 frequency_ns = NS_FROM_SECONDS(0.01f);
f32 shake = ent->shake; f32 shake = ent->shake;
if (shake > 0) { if (shake > 0) {
u64 basis = hash_fnv64(HASH_FNV64_BASIS, BUFFER_FROM_STRUCT(&ent->handle)); u64 basis = hash_fnv64(HASH_FNV64_BASIS, STRING_FROM_STRUCT(&ent->handle));
u64 angle_seed0 = basis + (u64)(G.world.time_ns / frequency_ns); u64 angle_seed0 = basis + (u64)(G.world.time_ns / frequency_ns);
u64 angle_seed1 = angle_seed0 + 1; u64 angle_seed1 = angle_seed0 + 1;
f32 angle0 = rng_noise_f32(angle_seed0, 0, TAU); f32 angle0 = rng_noise_f32(angle_seed0, 0, TAU);
@ -1005,7 +1005,7 @@ INTERNAL void user_update(void)
/* Draw focus arrow */ /* Draw focus arrow */
if (entity_has_prop(ent, ENTITY_PROP_PLAYER_CONTROLLED)) { if (entity_has_prop(ent, ENTITY_PROP_PLAYER_CONTROLLED)) {
struct sprite_sheet *sheet = sprite_sheet_from_tag_async(sprite_frame_scope, ent->sprite); struct sprite_sheet *sheet = sprite_sheet_from_tag_async(sprite_frame_scope, ent->sprite);
struct sprite_sheet_slice slice = sprite_sheet_get_slice(sheet, STR("attach.wep"), ent->animation_frame); struct sprite_sheet_slice slice = sprite_sheet_get_slice(sheet, LIT("attach.wep"), ent->animation_frame);
struct v2 start = xform_mul_v2(sprite_xform, slice.center); struct v2 start = xform_mul_v2(sprite_xform, slice.center);
start = xform_mul_v2(G.world_to_ui_xf, start); start = xform_mul_v2(G.world_to_ui_xf, start);
struct v2 end = v2_add(xf.og, ent->control.focus); struct v2 end = v2_add(xf.og, ent->control.focus);
@ -1028,7 +1028,7 @@ INTERNAL void user_update(void)
for (u64 i = 0; i < sheet->slice_groups_count; ++i) { for (u64 i = 0; i < sheet->slice_groups_count; ++i) {
struct sprite_sheet_slice_group *group = &sheet->slice_groups[i]; struct sprite_sheet_slice_group *group = &sheet->slice_groups[i];
if (string_ends_with(group->name, STR(".ray"))) continue; if (string_ends_with(group->name, LIT(".ray"))) continue;
for (u32 j = 0; j < group->per_frame_count; ++j) { for (u32 j = 0; j < group->per_frame_count; ++j) {
struct sprite_sheet_slice slice = group->frame_slices[(ent->animation_frame * group->per_frame_count) + j]; struct sprite_sheet_slice slice = group->frame_slices[(ent->animation_frame * group->per_frame_count) + j];
@ -1135,11 +1135,11 @@ INTERNAL void user_update(void)
#if 0 #if 0
/* Draw contact info */ /* Draw contact info */
{ {
struct font *disp_font = font_load_async(STR("res/fonts/fixedsys.ttf"), 12.0f); struct font *disp_font = font_load_async(LIT("res/fonts/fixedsys.ttf"), 12.0f);
if (disp_font) { if (disp_font) {
f32 offset_px = 10; f32 offset_px = 10;
struct string fmt = STR( struct string fmt = LIT(
"e0 index: %F\n" "e0 index: %F\n"
"e1 index: %F\n" "e1 index: %F\n"
"id: 0x%F\n" "id: 0x%F\n"
@ -1251,10 +1251,10 @@ INTERNAL void user_update(void)
#if 0 #if 0
/* Test info */ /* Test info */
{ {
struct font *disp_font = font_load_async(STR("res/fonts/fixedsys.ttf"), 12.0f); struct font *disp_font = font_load_async(LIT("res/fonts/fixedsys.ttf"), 12.0f);
if (disp_font) { if (disp_font) {
f32 offset_px = 10; f32 offset_px = 10;
struct string fmt = STR( struct string fmt = LIT(
"e0 pos: (%F, %F)\n" "e0 pos: (%F, %F)\n"
"e0 rot: %F\n" "e0 rot: %F\n"
"e1 pos: (%F, %F)\n" "e1 pos: (%F, %F)\n"
@ -1393,7 +1393,7 @@ INTERNAL void user_update(void)
struct v2 crosshair_pos = G.ui_cursor; struct v2 crosshair_pos = G.ui_cursor;
u32 tint = RGBA_32_F(1, 1, 1, 1); u32 tint = RGBA_32_F(1, 1, 1, 1);
struct sprite_tag crosshair_tag = sprite_tag_from_path(STR("res/graphics/crosshair.ase")); struct sprite_tag crosshair_tag = sprite_tag_from_path(LIT("res/graphics/crosshair.ase"));
struct sprite_texture *t = sprite_texture_from_tag_async(sprite_frame_scope, crosshair_tag); struct sprite_texture *t = sprite_texture_from_tag_async(sprite_frame_scope, crosshair_tag);
struct v2 size = V2(t->width, t->height); struct v2 size = V2(t->width, t->height);
@ -1514,66 +1514,66 @@ INTERNAL void user_update(void)
f32 spacing = 20; f32 spacing = 20;
struct v2 pos = V2(10, 8); struct v2 pos = V2(10, 8);
struct font *font = font_load_async(STR("res/fonts/fixedsys.ttf"), 12.0f); struct font *font = font_load_async(LIT("res/fonts/fixedsys.ttf"), 12.0f);
if (font) { if (font) {
struct temp_arena temp = arena_temp_begin(scratch.arena); struct temp_arena temp = arena_temp_begin(scratch.arena);
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("time: %F"), FMT_FLOAT(SECONDS_FROM_NS(G.time_ns)))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("time: %F"), FMT_FLOAT(SECONDS_FROM_NS(G.time_ns))));
pos.y += spacing; pos.y += spacing;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("world time: %F"), FMT_FLOAT(SECONDS_FROM_NS(G.world.time_ns)))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("world time: %F"), FMT_FLOAT(SECONDS_FROM_NS(G.world.time_ns))));
pos.y += spacing; pos.y += spacing;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("entities: %F/%F"), FMT_UINT(G.world.entity_store->allocated), FMT_UINT(G.world.entity_store->reserved))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("entities: %F/%F"), FMT_UINT(G.world.entity_store->allocated), FMT_UINT(G.world.entity_store->reserved)));
pos.y += spacing; pos.y += spacing;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("screen_size: (%F, %F)"), FMT_FLOAT((f64)G.screen_size.x), FMT_FLOAT((f64)G.screen_size.y))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("screen_size: (%F, %F)"), FMT_FLOAT((f64)G.screen_size.x), FMT_FLOAT((f64)G.screen_size.y)));
pos.y += spacing; pos.y += spacing;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("screen_cursor: (%F, %F)"), FMT_FLOAT((f64)G.screen_cursor.x), FMT_FLOAT((f64)G.screen_cursor.y))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("screen_cursor: (%F, %F)"), FMT_FLOAT((f64)G.screen_cursor.x), FMT_FLOAT((f64)G.screen_cursor.y)));
pos.y += spacing; pos.y += spacing;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("ui_screen_offset: (%F, %F)"), FMT_FLOAT((f64)G.ui_screen_offset.x), FMT_FLOAT((f64)G.ui_screen_offset.y))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("ui_screen_offset: (%F, %F)"), FMT_FLOAT((f64)G.ui_screen_offset.x), FMT_FLOAT((f64)G.ui_screen_offset.y)));
pos.y += spacing; pos.y += spacing;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("ui_size: (%F, %F)"), FMT_FLOAT((f64)G.ui_size.x), FMT_FLOAT((f64)G.ui_size.y))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("ui_size: (%F, %F)"), FMT_FLOAT((f64)G.ui_size.x), FMT_FLOAT((f64)G.ui_size.y)));
pos.y += spacing; pos.y += spacing;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("ui_center: (%F, %F)"), FMT_FLOAT((f64)G.ui_center.x), FMT_FLOAT((f64)G.ui_center.y))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("ui_center: (%F, %F)"), FMT_FLOAT((f64)G.ui_center.x), FMT_FLOAT((f64)G.ui_center.y)));
pos.y += spacing; pos.y += spacing;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("ui_cursor: (%F, %F)"), FMT_FLOAT((f64)G.ui_cursor.x), FMT_FLOAT((f64)G.ui_cursor.y))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("ui_cursor: (%F, %F)"), FMT_FLOAT((f64)G.ui_cursor.x), FMT_FLOAT((f64)G.ui_cursor.y)));
pos.y += spacing; pos.y += spacing;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("world_to_ui_xf.og: (%F, %F)"), FMT_FLOAT((f64)G.world_to_ui_xf.og.x), FMT_FLOAT((f64)G.world_to_ui_xf.og.y))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("world_to_ui_xf.og: (%F, %F)"), FMT_FLOAT((f64)G.world_to_ui_xf.og.x), FMT_FLOAT((f64)G.world_to_ui_xf.og.y)));
pos.y += spacing; pos.y += spacing;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("world_to_ui_xf rotation: %F"), FMT_FLOAT((f64)xform_get_rotation(G.world_to_ui_xf)))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("world_to_ui_xf rotation: %F"), FMT_FLOAT((f64)xform_get_rotation(G.world_to_ui_xf))));
pos.y += spacing; pos.y += spacing;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("world_to_ui_xf scale: (%F, %F)"), FMT_FLOAT((f64)xform_get_scale(G.world_to_ui_xf).x), FMT_FLOAT((f64)xform_get_scale(G.world_to_ui_xf).x))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("world_to_ui_xf scale: (%F, %F)"), FMT_FLOAT((f64)xform_get_scale(G.world_to_ui_xf).x), FMT_FLOAT((f64)xform_get_scale(G.world_to_ui_xf).x)));
pos.y += spacing; pos.y += spacing;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("world_cursor: (%F, %F)"), FMT_FLOAT((f64)G.world_cursor.x), FMT_FLOAT((f64)G.world_cursor.y))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("world_cursor: (%F, %F)"), FMT_FLOAT((f64)G.world_cursor.x), FMT_FLOAT((f64)G.world_cursor.y)));
pos.y += spacing; pos.y += spacing;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("debug_camera: %F"), FMT_STR(G.debug_camera ? STR("true") : STR("false")))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("debug_camera: %F"), FMT_STR(G.debug_camera ? LIT("true") : LIT("false"))));
pos.y += spacing; pos.y += spacing;
struct v2 player_linear_vel = entity_find_first_match_one(store, ENTITY_PROP_PLAYER_CONTROLLED)->linear_velocity; struct v2 player_linear_vel = entity_find_first_match_one(store, ENTITY_PROP_PLAYER_CONTROLLED)->linear_velocity;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("player linear velocity: (%F, %F)"), FMT_FLOAT_P((f64)player_linear_vel.x, 12), FMT_FLOAT_P((f64)player_linear_vel.y, 12))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("player linear velocity: (%F, %F)"), FMT_FLOAT_P((f64)player_linear_vel.x, 12), FMT_FLOAT_P((f64)player_linear_vel.y, 12)));
pos.y += spacing; pos.y += spacing;
f32 player_angular_vel = entity_find_first_match_one(store, ENTITY_PROP_PLAYER_CONTROLLED)->angular_velocity; f32 player_angular_vel = entity_find_first_match_one(store, ENTITY_PROP_PLAYER_CONTROLLED)->angular_velocity;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("player angular velocity: %F"), FMT_FLOAT_P((f64)player_angular_vel, 12))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("player angular velocity: %F"), FMT_FLOAT_P((f64)player_angular_vel, 12)));
pos.y += spacing; pos.y += spacing;
struct v2 player_pos = entity_get_xform(entity_find_first_match_one(store, ENTITY_PROP_PLAYER_CONTROLLED)).og; struct v2 player_pos = entity_get_xform(entity_find_first_match_one(store, ENTITY_PROP_PLAYER_CONTROLLED)).og;
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("player pos: (%F, %F)"), FMT_FLOAT_P((f64)player_pos.x, 12), FMT_FLOAT_P((f64)player_pos.y, 12))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("player pos: (%F, %F)"), FMT_FLOAT_P((f64)player_pos.x, 12), FMT_FLOAT_P((f64)player_pos.y, 12)));
pos.y += spacing; pos.y += spacing;
#if COLLIDER_DEBUG #if COLLIDER_DEBUG
draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("collider gjk steps: %F"), FMT_UINT(collider_debug_steps))); draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, LIT("collider gjk steps: %F"), FMT_UINT(collider_debug_steps)));
pos.y += spacing; pos.y += spacing;
#endif #endif

16
src/util.h
View File

@ -20,23 +20,23 @@
*/ */
#define HASH_FNV64_BASIS 0xCBF29CE484222325 #define HASH_FNV64_BASIS 0xCBF29CE484222325
INLINE u64 hash_fnv64(u64 seed, struct buffer buff) INLINE u64 hash_fnv64(u64 seed, struct string s)
{ {
u64 hash = seed; u64 hash = seed;
for (u64 i = 0; i < buff.size; ++i) { for (u64 i = 0; i < s.len; ++i) {
hash ^= (u8)buff.data[i]; hash ^= (u8)s.text[i];
hash *= 0x100000001B3; hash *= 0x100000001B3;
} }
return hash; return hash;
} }
#define HASH_FNV128_BASIS U128(0x6C62272E07BB0142, 0x62B821756295C58D) #define HASH_FNV128_BASIS U128(0x6C62272E07BB0142, 0x62B821756295C58D)
INLINE u128 hash_fnv128(u128 seed, struct buffer buff) INLINE u128 hash_fnv128(u128 seed, struct string s)
{ {
/* FIXME: Verify MSVC version of 128 is same */ /* FIXME: Verify MSVC version of 128 is same */
u128 hash = seed; u128 hash = seed;
for (u64 i = 0; i < buff.size; ++i) { for (u64 i = 0; i < s.len; ++i) {
u8 c = (u8)buff.data[i]; u8 c = (u8)s.text[i];
hash = u128_xor_u8(hash, c); hash = u128_xor_u8(hash, c);
hash = u128_mul(hash, U128(0x1000000, 0x000000000000013B)); hash = u128_mul(hash, U128(0x1000000, 0x000000000000013B));
} }
@ -149,7 +149,7 @@ INLINE void fixed_dict_set(struct arena *arena, struct fixed_dict *dict, struct
{ {
__prof; __prof;
u64 hash = hash_fnv64(HASH_FNV64_BASIS, BUFFER_FROM_STRING(key)); u64 hash = hash_fnv64(HASH_FNV64_BASIS, key);
u64 index = hash % dict->buckets_count; u64 index = hash % dict->buckets_count;
struct fixed_dict_bucket *bucket = &dict->buckets[index]; struct fixed_dict_bucket *bucket = &dict->buckets[index];
@ -178,7 +178,7 @@ INLINE void *fixed_dict_get(const struct fixed_dict *dict, struct string key)
{ {
__prof; __prof;
u64 hash = hash_fnv64(HASH_FNV64_BASIS, BUFFER_FROM_STRING(key)); u64 hash = hash_fnv64(HASH_FNV64_BASIS, key);
u64 index = hash % dict->buckets_count; u64 index = hash % dict->buckets_count;
struct fixed_dict_bucket *bucket = &dict->buckets[index]; struct fixed_dict_bucket *bucket = &dict->buckets[index];

4
src/work.c
View File

@ -106,7 +106,7 @@ struct work_startup_receipt work_startup(u32 num_worker_threads)
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
if (num_worker_threads <= 0) { if (num_worker_threads <= 0) {
sys_panic(STR("Tried to start up worker pool with 0 threads")); sys_panic(LIT("Tried to start up worker pool with 0 threads"));
} }
G.arena = arena_alloc(GIGABYTE(64)); G.arena = arena_alloc(GIGABYTE(64));
@ -122,7 +122,7 @@ struct work_startup_receipt work_startup(u32 num_worker_threads)
struct worker *prev = NULL; struct worker *prev = NULL;
for (u32 i = 0; i < num_worker_threads; ++i) { for (u32 i = 0; i < num_worker_threads; ++i) {
struct string thread_name = string_format(scratch.arena, struct string thread_name = string_format(scratch.arena,
STR("[P0] Worker %F"), LIT("[P0] Worker %F"),
FMT_UINT(i)); FMT_UINT(i));
struct worker *worker = arena_push_zero(&G.arena, struct worker); struct worker *worker = arena_push_zero(&G.arena, struct worker);