From fc3c67b445dcdcebb13ceb56013376e80ea26184 Mon Sep 17 00:00:00 2001 From: jacob Date: Thu, 24 Apr 2025 13:21:36 -0500 Subject: [PATCH] tiles in progress --- src/config.h | 7 ++- src/phys.c | 3 +- src/sim.h | 8 +++- src/sim_ent.c | 40 +++++++++++++++-- src/sim_ent.h | 11 ++++- src/sim_step.c | 31 +++++++++++++ src/string.c | 34 +++++++-------- src/sys_win32.c | 28 +++++++----- src/thread_local.c | 3 +- src/uid.c | 12 +++-- src/user.c | 106 +++++++++++++++++++++++++++++++++++++++++++-- src/user.h | 3 ++ 12 files changed, 241 insertions(+), 45 deletions(-) diff --git a/src/config.h b/src/config.h index fd038b59..ef6eedc9 100644 --- a/src/config.h +++ b/src/config.h @@ -36,8 +36,11 @@ #define USER_INTERP_ENABLED 1 /* 64^2 = 4096 bins */ -#define SPACE_CELL_BINS_SQRT (64) -#define SPACE_CELL_SIZE 1.0f +#define SPACE_CELL_BINS_SQRT (64) +#define SPACE_CELL_SIZE (1.0f) + +#define SIM_TILES_PER_UNIT_SQRT (2) +#define SIM_TILES_PER_CHUNK_SQRT (16) #define SIM_TICKS_PER_SECOND 50 #define SIM_TIMESCALE 1 diff --git a/src/phys.c b/src/phys.c index 6c23fffc..5c70dfef 100644 --- a/src/phys.c +++ b/src/phys.c @@ -47,6 +47,7 @@ struct phys_collision_data_array phys_create_and_update_contacts(struct arena *a res.a = arena_dry_push(arena, struct phys_collision_data); struct sim_snapshot *ss = ctx->sim_step_ctx->world; struct space *space = ctx->sim_step_ctx->accel->space; + struct sim_ent_id local_player = ss->local_player; struct sim_ent *root = sim_ent_from_id(ss, SIM_ENT_ROOT_ID); u64 tick = ss->tick; @@ -93,7 +94,7 @@ struct phys_collision_data_array phys_create_and_update_contacts(struct arena *a e1_collider = check0_collider; } - struct sim_ent_id constraint_id = sim_ent_contact_constraint_id_from_contacting_ids(e0->id, e1->id); + struct sim_ent_id constraint_id = sim_ent_contact_constraint_id_from_contacting_ids(local_player, e0->id, e1->id); struct sim_ent *constraint_ent = sim_ent_from_id(ss, constraint_id); if (constraint_ent->valid) { diff --git a/src/sim.h b/src/sim.h index b8200302..5788a4b2 100644 --- a/src/sim.h +++ b/src/sim.h @@ -141,7 +141,8 @@ enum sim_control_flag { SIM_CONTROL_FLAG_CLEAR_ALL = 1 << 2, SIM_CONTROL_FLAG_SPAWN_TEST = 1 << 3, SIM_CONTROL_FLAG_PAUSE = 1 << 4, - SIM_CONTROL_FLAG_STEP = 1 << 5 + SIM_CONTROL_FLAG_STEP = 1 << 5, + SIM_CONTROL_FLAG_TILE_TEST = 1 << 6, }; struct sim_control { @@ -157,6 +158,11 @@ enum sim_cmd_kind { SIM_CMD_KIND_CHAT }; +enum sim_tile_kind { + SIM_TILE_KIND_NONE, + SIM_TILE_KIND_TEST +}; + struct sim_ent_bin; struct sim_snapshot { diff --git a/src/sim_ent.c b/src/sim_ent.c index d31b3bde..1fac6f04 100644 --- a/src/sim_ent.c +++ b/src/sim_ent.c @@ -3,9 +3,11 @@ #include "math.h" #include "bitbuff.h" #include "uid.h" +#include "rand.h" /* Id magic number constants (to be used in conjunction with ent ids in deterministic id combinations) */ -#define SIM_ENT_CONTACT_BASIS_ID (UID(0x6a2a5d2dbecf534f, 0x0a8ca7c372a015af)) +#define SIM_ENT_CONTACT_BASIS_UID (UID(0x6a2a5d2dbecf534f, 0x0a8ca7c372a015af)) +#define SIM_ENT_TILE_CHUNK_BASIS_UID (UID(0x3ce42de071dd226b, 0x9b566f7df30c813a)) INTERNAL u32 index_from_ent(struct sim_snapshot *ss, struct sim_ent *ent) { @@ -271,10 +273,23 @@ struct sim_ent_id sim_ent_random_id(void) } /* Returns the deterministic id of the contact constraint ent id that should be produced from e0 & e1 colliding */ -struct sim_ent_id sim_ent_contact_constraint_id_from_contacting_ids(struct sim_ent_id id0, struct sim_ent_id id1) +struct sim_ent_id sim_ent_contact_constraint_id_from_contacting_ids(struct sim_ent_id player_id, struct sim_ent_id id0, struct sim_ent_id id1) { struct sim_ent_id res = ZI; - res.uid = uid_combine(uid_combine(SIM_ENT_CONTACT_BASIS_ID, id0.uid), id1.uid); + res.uid = SIM_ENT_CONTACT_BASIS_UID; + res.uid = uid_combine(res.uid, player_id.uid); + res.uid = uid_combine(res.uid, id0.uid); + res.uid = uid_combine(res.uid, id1.uid); + return res; +} + +/* Returns the deterministic id of the tile chunk that should be produced at chunk pos */ +struct sim_ent_id sim_ent_chunk_id_from_chunk_pos(struct sim_ent_id player_id, struct v2i32 chunk_pos) +{ + struct sim_ent_id res = ZI; + res.uid = SIM_ENT_TILE_CHUNK_BASIS_UID; + res.uid = uid_combine(res.uid, player_id.uid); + res.uid = uid_combine(res.uid, UID(rand_u64_from_seed(chunk_pos.x), rand_u64_from_seed(chunk_pos.y))); return res; } @@ -512,6 +527,25 @@ void sim_ent_apply_torque(struct sim_ent *ent, f32 torque) ent->torque += torque; } +/* ========================== * + * Tile chunk + * ========================== */ + +struct string sim_ent_get_tile_chunk_data(struct sim_ent *ent) +{ + DEBUGBREAKABLE; + (UNUSED)ent; + struct string res = ZI; + return res; +} + +void sim_ent_set_tile_chunk_data(struct sim_ent *ent, struct string data) +{ + DEBUGBREAKABLE; + (UNUSED)ent; + (UNUSED)data; +} + /* ========================== * * Ent lerp * ========================== */ diff --git a/src/sim_ent.h b/src/sim_ent.h index a8750eae..f9b328c6 100644 --- a/src/sim_ent.h +++ b/src/sim_ent.h @@ -7,7 +7,7 @@ #include "phys.h" #define SIM_ENT_NIL_ID ((struct sim_ent_id) { UID(0, 0) }) -#define SIM_ENT_ROOT_ID ((struct sim_ent_id) { UID(0x66a36cc2bcc752da, 0x6c286c09b366eae6) }) +#define SIM_ENT_ROOT_ID ((struct sim_ent_id) { UID(0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa) }) struct bitbuff_writer; struct bitbuff_reader; @@ -24,6 +24,8 @@ enum sim_ent_prop { SIM_ENT_PROP_CMD, + SIM_ENT_PROP_TILE_CHUNK, + SIM_ENT_PROP_PHYSICAL_DYNAMIC, SIM_ENT_PROP_PHYSICAL_KINEMATIC, @@ -456,7 +458,8 @@ void sim_ent_activate(struct sim_ent *ent, u64 current_tick); void sim_ent_set_id(struct sim_ent *ent, struct sim_ent_id id); struct sim_ent *sim_ent_from_id(struct sim_snapshot *ss, struct sim_ent_id id); struct sim_ent_id sim_ent_random_id(void); -struct sim_ent_id sim_ent_contact_constraint_id_from_contacting_ids(struct sim_ent_id id0, struct sim_ent_id id1); +struct sim_ent_id sim_ent_contact_constraint_id_from_contacting_ids(struct sim_ent_id player_id, struct sim_ent_id id0, struct sim_ent_id id1); +struct sim_ent_id sim_ent_chunk_id_from_chunk_pos(struct sim_ent_id player_id, struct v2i32 chunk_pos); /* Query */ struct sim_ent *sim_ent_find_first_match_one(struct sim_snapshot *ss, enum sim_ent_prop prop); @@ -481,6 +484,10 @@ void sim_ent_apply_force_to_center(struct sim_ent *ent, struct v2 force); void sim_ent_apply_angular_impulse(struct sim_ent *ent, f32 impulse); void sim_ent_apply_torque(struct sim_ent *ent, f32 torque); +/* Tile chunk */ +struct string sim_ent_get_tile_chunk_data(struct sim_ent *ent); +void sim_ent_set_tile_chunk_data(struct sim_ent *ent, struct string data); + /* Lerp */ void sim_ent_lerp(struct sim_ent *e, struct sim_ent *e0, struct sim_ent *e1, f64 blend); diff --git a/src/sim_step.c b/src/sim_step.c index 815b0c29..af4324c3 100644 --- a/src/sim_step.c +++ b/src/sim_step.c @@ -551,6 +551,37 @@ void sim_step(struct sim_step_ctx *ctx) } } } + if (flags & SIM_CONTROL_FLAG_TILE_TEST) { +#if 0 + if (is_master) { + struct v2 cursor_pos = player->player_cursor_pos; + /* FIXME: Negative indices */ + struct v2i32 tile_pos = V2I32(cursor_pos.x * SIM_TILES_PER_UNIT_SQRT, cursor_pos.y * SIM_TILES_PER_UNIT_SQRT); + struct v2i32 chunk_pos = V2I32(tile_pos.x * SIM_TILES_PER_CHUNK_SQRT, tile_pos.y * SIM_TILES_PER_CHUNK_SQRT); + struct v2i32 tile_pos_in_chunk = V2I32(tile_pos.x % SIM_TILES_PER_CHUNK_SQRT, tile_pos.y % SIM_TILES_PER_CHUNK_SQRT); + + struct sim_ent_id chunk_id = sim_ent_chunk_id_from_chunk_pos(player->id, chunk_pos); + struct sim_ent *chunk_ent = sim_ent_from_id(world, chunk_id); + if (!chunk_ent->valid) { + chunk_ent = sim_ent_alloc_sync_src_with_id(root, chunk_id); + sim_ent_enable_prop(chunk_ent, SIM_ENT_PROP_TILE_CHUNK); + } + + struct string old_data = sim_ent_get_tile_chunk_data(chunk_ent); + struct string new_data = ZI; + new_data.len = SIM_TILES_PER_CHUNK_SQRT * SIM_TILES_PER_CHUNK_SQRT; + new_data.text = arena_push_array(scratch.arena, u8, new_data.len); + if (old_data.len == new_data.len) { + MEMCPY(new_data.text, old_data.text, new_data.len); + } else { + MEMZERO(new_data.text, new_data.len); + } + u64 tile_index = tile_pos_in_chunk.x + (tile_pos_in_chunk.y * SIM_TILES_PER_CHUNK_SQRT); + new_data.text[tile_index] = SIM_TILE_KIND_TEST; + sim_ent_set_tile_chunk_data(chunk_ent, new_data); + } +#endif + } } } break; diff --git a/src/string.c b/src/string.c index 68cb99c2..384492a2 100644 --- a/src/string.c +++ b/src/string.c @@ -28,11 +28,11 @@ struct string string_from_char(struct arena *arena, char c) { - u8 *dest = arena_push(arena, u8); - *dest = c; + u8 *dst = arena_push(arena, u8); + *dst = c; return (struct string) { .len = 1, - .text = dest + .text = dst }; } @@ -592,8 +592,8 @@ struct string string_from_string16(struct arena *arena, struct string16 str16) struct uni_decode_utf16_result decoded = uni_decode_utf16(str16_remaining); struct uni_encode_utf8_result encoded = uni_encode_utf8(decoded.codepoint); - u8 *dest = arena_push_array(arena, u8, encoded.count8); - MEMCPY(dest, encoded.chars8, encoded.count8); + u8 *dst = arena_push_array(arena, u8, encoded.count8); + MEMCPY(dst, encoded.chars8, encoded.count8); pos16 += decoded.advance16; res.len += encoded.count8; @@ -616,8 +616,8 @@ struct string string_from_string32(struct arena *arena, struct string32 str32) struct uni_decode_utf32_result decoded = uni_decode_utf32(str32_remaining); struct uni_encode_utf8_result encoded = uni_encode_utf8(decoded.codepoint); - u8 *dest = arena_push_array(arena, u8, encoded.count8); - MEMCPY(dest, &encoded.chars8, encoded.count8); + u8 *dst = arena_push_array(arena, u8, encoded.count8); + MEMCPY(dst, &encoded.chars8, encoded.count8); pos32 += 1; res.len += encoded.count8; @@ -640,8 +640,8 @@ struct string16 string16_from_string(struct arena *arena, struct string str8) struct uni_decode_utf8_result decoded = uni_decode_utf8(str8_remaining); struct uni_encode_utf16_result encoded = uni_encode_utf16(decoded.codepoint); - u16 *dest = arena_push_array(arena, u16, encoded.count16); - MEMCPY(dest, encoded.chars16, (encoded.count16 << 1)); + u16 *dst = arena_push_array(arena, u16, encoded.count16); + MEMCPY(dst, encoded.chars16, (encoded.count16 << 1)); pos8 += decoded.advance8; res.len += encoded.count16; @@ -664,8 +664,8 @@ struct string32 string32_from_string(struct arena *arena, struct string str8) struct uni_decode_utf8_result decoded = uni_decode_utf8(str8_remaining); struct uni_encode_utf32_result encoded = uni_encode_utf32(decoded.codepoint); - u32 *dest = arena_push(arena, u32); - *dest = encoded.chars32; + u32 *dst = arena_push(arena, u32); + *dst = encoded.chars32; pos8 += decoded.advance8; res.len += 1; @@ -712,14 +712,14 @@ char *cstr_from_string(struct arena *arena, struct string src) return (char *)text; } -char *cstr_buff_from_string(struct string dest_buff, struct string src) +char *cstr_buff_from_string(struct string dst_buff, struct string src) { - if (dest_buff.len > 0) { - u64 len = min_u64(src.len, dest_buff.len - 1); - MEMCPY(dest_buff.text, src.text, len); - dest_buff.text[len] = 0; + if (dst_buff.len > 0) { + u64 len = min_u64(src.len, dst_buff.len - 1); + MEMCPY(dst_buff.text, src.text, len); + dst_buff.text[len] = 0; } - return (char *)dest_buff.text; + return (char *)dst_buff.text; } struct string string_from_cstr_no_limit(char *cstr) diff --git a/src/sys_win32.c b/src/sys_win32.c index 053c2f0e..99863616 100644 --- a/src/sys_win32.c +++ b/src/sys_win32.c @@ -37,6 +37,7 @@ struct win32_thread { sys_thread_entry_point_func *entry_point; void *thread_data; char thread_name_cstr[256]; + wchar_t thread_name_wstr[256]; struct win32_thread *next; struct win32_thread *prev; @@ -1596,13 +1597,11 @@ struct win32_tls { INTERNAL void win32_thread_set_tls(struct win32_tls *ctx) { - /* TODO: Fail if error */ TlsSetValue(G.thread_tls_index, (LPVOID)ctx); } INTERNAL struct win32_tls *win32_thread_get_tls(void) { - /* TODO: Fail if error */ return TlsGetValue(G.thread_tls_index); } @@ -1688,16 +1687,11 @@ INTERNAL DWORD WINAPI win32_thread_proc(LPVOID vt) win32_thread_set_tls(&tls); /* Set thread name */ - struct string thread_name = string_from_cstr_no_limit(t->thread_name_cstr); - if (thread_name.len > 0) { - /* FIXME: Don't use scratch arena here, to avoid scratch TLS being initialized for threads that don't need them otherwise */ - struct temp_arena scratch = scratch_begin_no_conflict(); - wchar_t *wc_thread_name = wstr_from_string(scratch.arena, thread_name); - SetThreadDescription(GetCurrentThread(), wc_thread_name); - scratch_end(scratch); + if (t->thread_name_wstr[0] != 0) { + SetThreadDescription(GetCurrentThread(), t->thread_name_wstr); } - logf_info("New thread \"%F\" created with ID %F", FMT_STR(thread_name), FMT_UINT(sys_thread_id())); + logf_info("New thread \"%F\" created with ID %F", FMT_STR(string_from_cstr_no_limit(t->thread_name_cstr)), FMT_UINT(sys_thread_id())); /* Enter thread entry point */ t->entry_point(t->thread_data); @@ -1714,6 +1708,7 @@ INTERNAL DWORD WINAPI win32_thread_proc(LPVOID vt) struct sys_thread sys_thread_alloc(sys_thread_entry_point_func *entry_point, void *thread_data, struct string thread_name) { __prof; + struct temp_arena scratch = scratch_begin_no_conflict(); ASSERT(entry_point != NULL); logf_info("Creating thread \"%F\"", FMT_STR(thread_name)); @@ -1725,7 +1720,17 @@ struct sys_thread sys_thread_alloc(sys_thread_entry_point_func *entry_point, voi t->thread_data = thread_data; /* Copy thread name to params */ - cstr_buff_from_string(STRING_FROM_ARRAY(t->thread_name_cstr), thread_name); + { + u64 cstr_len = min_u64((ARRAY_COUNT(t->thread_name_cstr) - 1), thread_name.len); + MEMCPY(t->thread_name_cstr, thread_name.text, cstr_len * sizeof(*t->thread_name_cstr)); + t->thread_name_cstr[cstr_len] = 0; + } + { + struct string16 thread_name16 = string16_from_string(scratch.arena, thread_name); + u64 wstr_len = min_u64((ARRAY_COUNT(t->thread_name_wstr) - 1), thread_name16.len); + MEMCPY(t->thread_name_wstr, thread_name16.text, wstr_len * sizeof(*t->thread_name_wstr)); + t->thread_name_wstr[wstr_len] = 0; + } t->handle = CreateThread( NULL, @@ -1741,6 +1746,7 @@ struct sys_thread sys_thread_alloc(sys_thread_entry_point_func *entry_point, voi } res.handle = (u64)t; + scratch_end(scratch); return res; } diff --git a/src/thread_local.c b/src/thread_local.c index ab5c2027..2ddb1afa 100644 --- a/src/thread_local.c +++ b/src/thread_local.c @@ -86,9 +86,10 @@ void *_thread_local_var_eval(struct thread_local_var_meta *meta) } } - /* Allocate var for thread if unallocated */ struct thread_local_store *t = sys_thread_get_thread_local_store(); void *data = t->lookup[id]; + + /* Allocate var for thread if unallocated */ if (!data) { __profscope(_thread_local_var_eval__ALLOC); /* Allocate */ diff --git a/src/uid.c b/src/uid.c index 439a46eb..05a45b76 100644 --- a/src/uid.c +++ b/src/uid.c @@ -10,11 +10,17 @@ struct uid uid_true_rand(void) return res; } -/* Commutatively combines 2 uids into a new uid */ +/* Combines 2 uids into a new uid */ struct uid uid_combine(struct uid a, struct uid b) { struct uid res; - res.hi = rand_u64_from_seed(a.hi + b.hi); - res.lo = rand_u64_from_seed(a.lo + b.lo); + res.hi = (a.hi * 3) + b.hi; + res.lo = (a.lo * 3) + b.lo; + res.hi += res.lo; + res.lo += res.hi; + res.hi = rand_u64_from_seed(res.hi); + res.lo = rand_u64_from_seed(res.lo); + res.hi += res.lo; + res.lo += res.hi; return res; } diff --git a/src/user.c b/src/user.c index 99a63d0a..49e00ea0 100644 --- a/src/user.c +++ b/src/user.c @@ -138,6 +138,8 @@ GLOBAL READONLY enum user_bind_kind g_binds[SYS_BTN_COUNT] = { /* Testing */ + [SYS_BTN_M4] = USER_BIND_KIND_TILE_TEST, + [SYS_BTN_M2] = USER_BIND_KIND_DEBUG_DRAG, [SYS_BTN_C] = USER_BIND_KIND_DEBUG_CLEAR, [SYS_BTN_V] = USER_BIND_KIND_DEBUG_SPAWN, @@ -644,6 +646,7 @@ INTERNAL void user_update(void) * Find local entities * ========================== */ + struct sim_ent *master_player = sim_ent_find_first_match_one(G.ss_blended, SIM_ENT_PROP_PLAYER_IS_MASTER); struct sim_ent *local_player = sim_ent_from_id(G.ss_blended, G.ss_blended->local_player); struct sim_ent *local_control = sim_ent_from_id(G.ss_blended, local_player->player_control_ent); struct sim_ent *local_camera = sim_ent_from_id(G.ss_blended, local_player->player_camera_ent); @@ -744,7 +747,7 @@ INTERNAL void user_update(void) f32 angle1 = rand_f64_from_seed(angle_seed1, 0, TAU); struct v2 vec0 = v2_with_len(v2_from_angle(angle0), shake); - /* NOTE: vec1 not completely accurate since shake can change between frames, just a prediction */ + /* NOTE: vec1 not completely accurate since shake can change between frames, it's just a prediction */ struct v2 vec1 = v2_with_len(v2_from_angle(angle1), shake); /* TODO: Cubic interp? */ @@ -884,11 +887,102 @@ INTERNAL void user_update(void) draw_grid(G.world_cmd_buffer, RECT_FROM_V2(pos, size), color, thickness, spacing, offset); } - /* ---------------------------------------------------------------------- */ - /* ---------------------------------------------------------------------- */ + /* ========================== * + * Alloc / release tile cache entries + * ========================== */ + + /* Alloc entries from new sim chunks */ + + for (u64 ent_index = 0; ent_index < G.ss_blended->num_ents_reserved; ++ent_index) { + struct sim_ent *chunk_ent = &G.ss_blended->ents[ent_index]; + if (sim_ent_is_valid_and_active(chunk_ent) && sim_ent_has_prop(chunk_ent, SIM_ENT_PROP_TILE_CHUNK)) { + struct user_tile_cache_entry *entry = user_tile_cache_entry_from_chunk_pos(chunk_ent->tile_chunk_pos); + if (!entry->valid) { + entry = user_tile_cache_entry_alloc(chunk_ent->tile_chunk_pos); + } + } + } + + /* Release entries with invalid sim chunks */ + + for (u64 entry_index = 0; entry_index < G.tile_cache.num_reserved_entries; ++entry_index) { + struct tile_cache_entry *entry = &G.tile_cache.entries[entry_index]; + if (entry->valid) { + struct sim_ent *chunk_ent = sim_ent_from_chunk_pos(entry->pos); + if (!chunk_ent->valid) { + user_tile_cache_entry_release(entry); + } + } + } /* ========================== * - * Sort entities + * Draw dirty tile cache entries + * ========================== */ + + for (u64 entry_index = 0; entry_index < G.tile_cache.num_reserved_entries; ++entry_index) { + struct tile_cache_entry *entry = &G.tile_cache.entries[entry_index]; + if (entry->valid) { + struct v2i32 chunk_pos = entry->pos; + struct sim_ent *chunk_ent = sim_ent_from_chunk_pos(chunk_pos); + if (entry->applied_dirty_gen != chunk_ent->dirty_gen) { + entry->applied_dirty_gen = chunk_ent->dirty_gen; + /* TODO: Autotiling */ + + struct string data = sim_ent_get_chunk_tile_data(chunk_ent); + u64 tile_count = data.len; + if (tile_count == SIM_TILES_PER_CHUNK_SQRT * SIM_TILES_PER_CHUNK_SQRT) { + for (u64 y_in_chunk = 0; y_in_chunk < SIM_TILES_PER_CHUNK_SQRT; ++y_in_chunk) { + for (u64 x_in_chunk = 0; x_in_chunk < SIM_TILES_PER_CHUNK_SQRT; ++x_in_chunk) { + } + } + } else { + /* TODO: Clear gpu buffer if it exists */ + } + } + } + } + +#if 0 + for (u64 entry_index = 0; entry_index < G.tile_cache.num_reserved_entries; ++entry_index) { + struct tile_cache_entry *entry = &G.tile_cache.entries[entry_index]; + if (entry->valid) { + struct v2i32 chunk_pos = entry->pos; + struct sim_ent *chunk_ent = sim_ent_from_chunk_pos(chunk_pos); + if (entry->applied_dirty_gen != chunk_ent->dirty_gen) { + entry->applied_dirty_gen = chunk_ent->dirty_gen; + + /* Retreive surrounding chunk info since we're auto-tiling + * [TL] [T] [TR] + * [L ] X [R ] + * [BL] [B] [BR] + */ + struct v2i32 chunk_pos_tl = V2I32(chunk_pos.x - 1, chunk_pos.y - 1); + struct v2i32 chunk_pos_t = V2I32(chunk_pos.x, chunk_pos.y - 1); + struct v2i32 chunk_pos_tr = V2I32(chunk_pos.x + 1, chunk_pos.y - 1); + struct v2i32 chunk_pos_l = V2I32(chunk_pos.x - 1, chunk_pos.y); + struct v2i32 chunk_pos_r = V2I32(chunk_pos.x + 1, chunk_pos.y); + struct v2i32 chunk_pos_bl = V2I32(chunk_pos.x - 1, chunk_pos.y + 1); + struct v2i32 chunk_pos_b = V2I32(chunk_pos.x, chunk_pos.y + 1); + struct v2i32 chunk_pos_br = V2I32(chunk_pos.x + 1, chunk_pos.y + 1); + struct sim_ent *chunk_ent_tl = sim_ent_from_chunk_pos(chunk_pos_tl); + struct sim_ent *chunk_ent_t = sim_ent_from_chunk_pos(chunk_pos_t); + struct sim_ent *chunk_ent_tr = sim_ent_from_chunk_pos(chunk_pos_tr); + struct sim_ent *chunk_ent_l = sim_ent_from_chunk_pos(chunk_pos_l); + struct sim_ent *chunk_ent_r = sim_ent_from_chunk_pos(chunk_pos_r); + struct sim_ent *chunk_ent_bl = sim_ent_from_chunk_pos(chunk_pos_bl); + struct sim_ent *chunk_ent_b = sim_ent_from_chunk_pos(chunk_pos_b); + struct sim_ent *chunk_ent_br = sim_ent_from_chunk_pos(chunk_pos_br); + + struct string data = sim_ent_get_chunk_tile_data(chunk_ent); + + //for (u64 x = 0; x < + } + } + } +#endif + + /* ========================== * + * Sort drawable entities * ========================== */ struct sim_ent **sorted = arena_dry_push(scratch.arena, struct sim_ent *); @@ -1491,6 +1585,7 @@ INTERNAL void user_update(void) struct bind_state pause_state = G.bind_states[USER_BIND_KIND_DEBUG_PAUSE]; struct bind_state step_state = G.bind_states[USER_BIND_KIND_DEBUG_STEP]; struct bind_state spawn_state = G.bind_states[USER_BIND_KIND_DEBUG_SPAWN]; + struct bind_state tile_state = G.bind_states[USER_BIND_KIND_TILE_TEST]; if (fire_state.num_presses || fire_state.is_held) { control.flags |= SIM_CONTROL_FLAG_FIRE; @@ -1510,6 +1605,9 @@ INTERNAL void user_update(void) if (spawn_state.num_presses) { control.flags |= SIM_CONTROL_FLAG_SPAWN_TEST; } + if (tile_state.num_presses) { + control.flags |= SIM_CONTROL_FLAG_TILE_TEST; + } /* Set user sim control */ { diff --git a/src/user.h b/src/user.h index 8515f2d0..79f8f664 100644 --- a/src/user.h +++ b/src/user.h @@ -25,6 +25,9 @@ enum user_bind_kind { USER_BIND_KIND_FIRE, /* Testing */ + + USER_BIND_KIND_TILE_TEST, + USER_BIND_KIND_DEBUG_CLEAR, USER_BIND_KIND_DEBUG_SPAWN, USER_BIND_KIND_DEBUG_FOLLOW,