struct bind_state { b32 is_held; /* Is this bind held down this frame */ u32 num_presses; /* How many times was this bind's pressed since last frame */ u32 num_repeats; /* How many times was this bind's key repeated since last frame */ u32 num_presses_and_repeats; /* Same as `num_presses` but includes key repeats as well */ u32 num_releases; /* How many times was this bind released since last frame */ }; struct second_stat { u64 last_second_start; u64 last_second_end; u64 last_second; }; struct console_log { struct string msg; i32 level; i32 color_index; struct sys_datetime datetime; i64 time_ns; struct rect bounds; struct console_log *prev; struct console_log *next; }; GLOBAL struct { struct atomic32 shutdown; struct snc_counter shutdown_job_counters; struct sys_window *window; struct gp_swapchain *swapchain; struct sim_ctx *local_sim_ctx; struct arena *arena; struct string connect_address_str; struct sim_client_store *user_client_store; struct sim_client *user_unblended_client; /* Contains snapshots received from local sim */ struct sim_client *user_blended_client; /* Contains single snapshot from result of blending local sim snapshots */ struct sim_snapshot *ss_blended; /* Points to blended snapshot contained in blended client */ /* Usage stats */ i64 last_second_reset_ns; struct second_stat net_bytes_read; struct second_stat net_bytes_sent; /* Gpu resources */ struct gp_render_sig *render_sig; struct bind_state bind_states[USER_BIND_KIND_COUNT]; /* Debug camera */ struct sim_ent_id debug_following; b32 debug_camera; b32 debug_camera_panning; struct v2 debug_camera_pan_start; b32 debug_draw; /* Debug console */ struct snc_mutex console_logs_mutex; struct arena *console_logs_arena; struct console_log *first_console_log; struct console_log *last_console_log; i32 console_log_color_indices[LOG_LEVEL_COUNT]; f32 console_logs_height; b32 debug_console; /* Window -> user */ struct snc_mutex sys_window_events_mutex; struct arena *sys_window_events_arena; /* User -> local sim */ struct snc_mutex user_sim_cmd_mutex; struct sim_control user_sim_cmd_control; struct sim_ent_id user_hovered_ent; u64 last_user_sim_cmd_gen; u64 user_sim_cmd_gen; struct atomic32 user_paused; struct atomic32 user_paused_steps; /* Local sim -> user */ struct snc_mutex local_to_user_client_mutex; struct sim_client_store *local_to_user_client_store; struct sim_client *local_to_user_client; i64 local_to_user_client_publish_dt_ns; i64 local_to_user_client_publish_time_ns; /* Rolling window of local sim -> user publish time deltas */ i64 last_local_to_user_snapshot_published_at_ns; i64 average_local_to_user_snapshot_publish_dt_ns; i64 local_sim_predicted_time_ns; /* Calculated from + */ i64 render_time_target_ns; /* Claculated from - */ i64 render_time_ns; /* Incremented at a constant rate based on average local to user publish delta, but snaps to render_time_target_ns if it gets too distant */ u64 local_sim_last_known_tick; i64 local_sim_last_known_time_ns; i64 real_dt_ns; i64 real_time_ns; /* Per-frame */ struct v2 screen_size; struct v2 screen_cursor; struct xform ui_to_screen_xf; struct v2 ui_size; struct v2 ui_cursor; struct xform render_to_ui_xf; struct v2 render_size; struct xform world_to_render_xf; struct xform world_to_ui_xf; struct v2 world_cursor; struct v2 focus_send; } G = ZI, DEBUG_ALIAS(G, G_user); /* ========================== * * Bind state * ========================== */ /* TODO: Remove this */ GLOBAL READONLY enum user_bind_kind g_binds[SYS_BTN_COUNT] = { [SYS_BTN_W] = USER_BIND_KIND_MOVE_UP, [SYS_BTN_S] = USER_BIND_KIND_MOVE_DOWN, [SYS_BTN_A] = USER_BIND_KIND_MOVE_LEFT, [SYS_BTN_D] = USER_BIND_KIND_MOVE_RIGHT, //[SYS_BTN_ALT] = USER_BIND_KIND_WALK, [SYS_BTN_M1] = USER_BIND_KIND_FIRE, [SYS_BTN_M2] = USER_BIND_KIND_FIRE_ALT, /* Testing */ [SYS_BTN_Z] = USER_BIND_KIND_TILE_TEST, [SYS_BTN_M5] = USER_BIND_KIND_DEBUG_DRAG, [SYS_BTN_M4] = USER_BIND_KIND_DEBUG_DELETE, [SYS_BTN_F] = USER_BIND_KIND_DEBUG_EXPLODE, [SYS_BTN_T] = USER_BIND_KIND_DEBUG_TELEPORT, [SYS_BTN_C] = USER_BIND_KIND_DEBUG_CLEAR, [SYS_BTN_1] = USER_BIND_KIND_DEBUG_SPAWN1, [SYS_BTN_2] = USER_BIND_KIND_DEBUG_SPAWN2, [SYS_BTN_3] = USER_BIND_KIND_DEBUG_SPAWN3, [SYS_BTN_4] = USER_BIND_KIND_DEBUG_SPAWN4, [SYS_BTN_G] = USER_BIND_KIND_DEBUG_WALLS, [SYS_BTN_N] = USER_BIND_KIND_DEBUG_STEP, [SYS_BTN_Q] = USER_BIND_KIND_DEBUG_FOLLOW, [SYS_BTN_F1] = USER_BIND_KIND_DEBUG_PAUSE, [SYS_BTN_F2] = USER_BIND_KIND_DEBUG_CAMERA, [SYS_BTN_F3] = USER_BIND_KIND_DEBUG_DRAW, [SYS_BTN_F4] = USER_BIND_KIND_DEBUG_TOGGLE_TOPMOST, [SYS_BTN_GRAVE_ACCENT] = USER_BIND_KIND_DEBUG_CONSOLE, [SYS_BTN_ALT] = USER_BIND_KIND_FULLSCREEN_MOD, [SYS_BTN_ENTER] = USER_BIND_KIND_FULLSCREEN, [SYS_BTN_MWHEELUP] = USER_BIND_KIND_ZOOM_IN, [SYS_BTN_MWHEELDOWN] = USER_BIND_KIND_ZOOM_OUT, [SYS_BTN_M3] = USER_BIND_KIND_PAN, #if RTC /* Debug */ [SYS_BTN_FORWARD_SLASH] = USER_BIND_KIND_RESET_DEBUG_STEPS, [SYS_BTN_COMMA] = USER_BIND_KIND_DECR_DEBUG_STEPS, [SYS_BTN_PERIOD] = USER_BIND_KIND_INCR_DEBUG_STEPS #endif }; /* ========================== * * Startup * ========================== */ INTERNAL SYS_EXIT_FUNC(user_shutdown); INTERNAL LOG_EVENT_CALLBACK_FUNC_DEF(debug_console_log_callback, log); INTERNAL SYS_JOB_DEF(user_update_job, _); INTERNAL SYS_JOB_DEF(local_sim_job , _); struct user_startup_receipt user_startup(struct font_startup_receipt *font_sr, struct sprite_startup_receipt *sprite_sr, struct draw_startup_receipt *draw_sr, struct asset_cache_startup_receipt *asset_cache_sr, struct sound_startup_receipt *sound_sr, struct mixer_startup_receipt *mixer_sr, struct host_startup_receipt *host_sr, struct sim_startup_receipt *sim_sr, struct string connect_address_str) { __prof; (UNUSED)font_sr; (UNUSED)sprite_sr; (UNUSED)draw_sr; (UNUSED)asset_cache_sr; (UNUSED)sound_sr; (UNUSED)mixer_sr; (UNUSED)host_sr; (UNUSED)sim_sr; gstat_set(GSTAT_DEBUG_STEPS, U64_MAX); G.arena = arena_alloc(GIBI(64)); G.real_time_ns = sys_time_ns(); /* TODO: Remove this */ G.connect_address_str = string_copy(G.arena, connect_address_str); /* Initialize average dt to a reasonable value */ G.average_local_to_user_snapshot_publish_dt_ns = NS_FROM_SECONDS(1) / SIM_TICKS_PER_SECOND; /* User blend clients */ G.user_client_store = sim_client_store_alloc(); G.user_unblended_client = sim_client_alloc(G.user_client_store); G.user_blended_client = sim_client_alloc(G.user_client_store); G.ss_blended = sim_snapshot_nil(); /* Local to user client */ G.local_to_user_client_store = sim_client_store_alloc(); G.local_to_user_client = sim_client_alloc(G.local_to_user_client_store); /* GPU handles */ G.world_to_ui_xf = XFORM_IDENT; G.world_to_render_xf = XFORM_IDENT; G.render_sig = gp_render_sig_alloc(); G.console_logs_arena = arena_alloc(GIBI(64)); //log_register_callback(debug_console_log_callback, LOG_LEVEL_SUCCESS); log_register_callback(debug_console_log_callback, LOG_LEVEL_DEBUG); G.window = sys_window_alloc(); G.swapchain = gp_swapchain_alloc(G.window, V2I32(100, 100)); sys_window_show(G.window); /* Start jobs */ sys_run(1, user_update_job, 0, SYS_POOL_USER, SYS_PRIORITY_HIGH, &G.shutdown_job_counters); sys_run(1, local_sim_job, 0, SYS_POOL_SIM, SYS_PRIORITY_HIGH, &G.shutdown_job_counters); sys_on_exit(&user_shutdown); return (struct user_startup_receipt) { 0 }; } INTERNAL SYS_EXIT_FUNC(user_shutdown) { __prof; atomic32_fetch_set(&G.shutdown, 1); snc_counter_wait(&G.shutdown_job_counters); sys_window_release(G.window); } /* ========================== * * Debug draw * ========================== */ /* TODO: remove this (testing) */ INTERNAL void debug_draw_xform(struct xform xf, u32 color_x, u32 color_y) { f32 thickness = 2.f; f32 arrowhead_len = 15.f; struct v2 pos = xform_mul_v2(G.world_to_ui_xf, xf.og); struct v2 x_ray = xform_basis_mul_v2(G.world_to_ui_xf, xform_get_right(xf)); struct v2 y_ray = xform_basis_mul_v2(G.world_to_ui_xf, xform_get_up(xf)); f32 ray_scale = 1; x_ray = v2_mul(x_ray, ray_scale); y_ray = v2_mul(y_ray, ray_scale); draw_arrow_ray(G.render_sig, pos, x_ray, thickness, arrowhead_len, color_x); draw_arrow_ray(G.render_sig, pos, y_ray, thickness, arrowhead_len, color_y); //u32 color_quad = RGBA32_F(0, 1, 1, 0.3); //struct quad quad = quad_from_rect(RECT(0, 0, 1, -1)); //quad = xform_mul_quad(xf, quad_scale(quad, 0.075f)); //draw_quad(G.render_sig, quad, color); } INTERNAL void debug_draw_movement(struct sim_ent *ent) { f32 thickness = 2.f; f32 arrow_len = 15.f; u32 color_vel = COLOR_ORANGE; struct xform xf = sim_ent_get_xform(ent); struct v2 velocity = ent->linear_velocity; struct v2 pos = xform_mul_v2(G.world_to_ui_xf, xf.og); struct v2 vel_ray = xform_basis_mul_v2(G.world_to_ui_xf, velocity); if (v2_len(vel_ray) > 0.00001) { draw_arrow_ray(G.render_sig, pos, vel_ray, thickness, arrow_len, color_vel); } } INTERNAL struct string get_ent_debug_text(struct arena *arena, struct sim_ent *ent) { struct arena_temp scratch = scratch_begin(arena); struct sim_snapshot *ss = ent->ss; const u8 hex[] = "0123456789abcdef"; struct string res = ZI; res.text = arena_push_dry(arena, u8); res.len += string_format(arena, LIT("[%F]"), FMT_UID(ent->id.uid)).len; { b32 transmitting = sim_ent_has_prop(ent, SEPROP_SYNC_SRC); b32 receiving = sim_ent_has_prop(ent, SEPROP_SYNC_DST); if (transmitting & receiving) { res.len += string_copy(arena, LIT(" networked (sending & receiving)")).len; } else if (transmitting) { res.len += string_copy(arena, LIT(" networked (sending)")).len; } else if (receiving) { res.len += string_copy(arena, LIT(" networked (receiving)")).len; } else { res.len += string_copy(arena, LIT(" local")).len; } } res.len += string_copy(arena, LIT("\n")).len; res.len += string_format(arena, LIT("owner: [%F]\n"), FMT_UID(ent->owner.uid)).len; res.len += string_copy(arena, LIT("\n")).len; { res.len += string_copy(arena, LIT("props: 0x")).len; for (u64 chunk_index = countof(ent->props); chunk_index-- > 0;) { u64 chunk = ent->props[chunk_index]; for (u64 part_index = 8; part_index-- > 0;) { if ((chunk_index != (countof(ent->props) - 1)) || ((chunk_index * 64) + (part_index * 8)) <= SEPROP_COUNT) { u8 part = (chunk >> (part_index * 8)) & 0xFF; string_from_char(arena, hex[(part >> 4) & 0x0F]); string_from_char(arena, hex[(part >> 0) & 0x0F]); res.len += 2; } } } res.len += string_copy(arena, LIT("\n")).len; } if (!sim_ent_id_eq(ent->parent, SIM_ENT_ROOT_ID)) { res.len += string_format(arena, LIT("parent: [%F]\n"), FMT_UID(ent->parent.uid)).len; } if (!sim_ent_id_is_nil(ent->next) || !sim_ent_id_is_nil(ent->prev)) { res.len += string_format(arena, LIT("prev: [%F]\n"), FMT_UID(ent->prev.uid)).len; res.len += string_format(arena, LIT("next: [%F]\n"), FMT_UID(ent->next.uid)).len; } res.len += string_copy(arena, LIT("\n")).len; /* Pos */ struct xform xf = sim_ent_get_xform(ent); struct v2 linear_velocity = ent->linear_velocity; f32 angular_velocity = ent->angular_velocity; res.len += string_format(arena, LIT("pos: (%F, %F)\n"), FMT_FLOAT(xf.og.x), FMT_FLOAT(xf.og.y)).len; res.len += string_format(arena, LIT("linear velocity: (%F, %F)\n"), FMT_FLOAT(linear_velocity.x), FMT_FLOAT(linear_velocity.y)).len; res.len += string_format(arena, LIT("angular velocity: %F\n"), FMT_FLOAT(angular_velocity)).len; /* Test */ res.len += string_format(arena, LIT("collision dir: (%F, %F)\n"), FMT_FLOAT(ent->collision_dir.x), FMT_FLOAT(ent->collision_dir.y)).len; /* Children */ if (!sim_ent_id_is_nil(ent->first) || !sim_ent_id_is_nil(ent->last)) { struct sim_ent *child = sim_ent_from_id(ss, ent->first); if (!sim_ent_id_eq(ent->first, ent->last) || !child->valid) { res.len += string_format(arena, LIT("first child: [%F]\n"), FMT_UID(ent->first.uid)).len; res.len += string_format(arena, LIT("last child: [%F]\n"), FMT_UID(ent->last.uid)).len; } while (child->valid) { res.len += string_copy(arena, LIT("\n---------------------------------\n")).len; res.len += string_copy(arena, LIT("CHILD\n")).len; struct string child_text = get_ent_debug_text(scratch.arena, child); res.len += string_indent(arena, child_text, 4).len; child = sim_ent_from_id(ss, child->next); } } scratch_end(scratch); return res; } /* ========================== * * Debug console * ========================== */ INTERNAL LOG_EVENT_CALLBACK_FUNC_DEF(debug_console_log_callback, log) { __prof; struct snc_lock lock = snc_lock_e(&G.console_logs_mutex); { struct console_log *clog = arena_push(G.console_logs_arena, struct console_log); clog->level = log.level; clog->msg = string_copy(G.console_logs_arena, log.msg); clog->datetime = log.datetime; clog->time_ns = log.time_ns; if (G.last_console_log) { G.last_console_log->next = clog; clog->prev = G.last_console_log; /* Alternating color index between logs of same level */ i32 *color_index = &G.console_log_color_indices[log.level]; clog->color_index = *color_index; *color_index = 1 - *color_index; } else { G.first_console_log = clog; } G.last_console_log = clog; } snc_unlock(&lock); } INTERNAL void draw_debug_console(i32 level, b32 minimized) { __prof; struct arena_temp scratch = scratch_begin_no_conflict(); struct v2 desired_start_pos = V2(10, minimized ? 100 : 600); i64 fade_time_ns = NS_FROM_SECONDS(10); f32 fade_curve = 0.5; f32 spacing = 0; f32 bg_margin = 5; LOCAL_PERSIST u32 colors[LOG_LEVEL_COUNT][2] = ZI; MEMSET(colors, 0xFF, sizeof(colors)); #if 1 colors[LOG_LEVEL_DEBUG][0] = RGB32_F(0.4, 0.1, 0.4); colors[LOG_LEVEL_DEBUG][1] = RGB32_F(0.5, 0.2, 0.5); colors[LOG_LEVEL_INFO][0] = RGB32_F(0.4, 0.4, 0.4); colors[LOG_LEVEL_INFO][1] = RGB32_F(0.5, 0.5, 0.5); colors[LOG_LEVEL_SUCCESS][0] = RGB32_F(0.1, 0.3, 0.1); colors[LOG_LEVEL_SUCCESS][1] = RGB32_F(0.2, 0.4, 0.2); colors[LOG_LEVEL_WARNING][0] = RGB32_F(0.4, 0.4, 0.1); colors[LOG_LEVEL_WARNING][1] = RGB32_F(0.5, 0.5, 0.2); colors[LOG_LEVEL_ERROR][0] = RGB32_F(0.4, 0.1, 0.1); colors[LOG_LEVEL_ERROR][1] = RGB32_F(0.5, 0.2, 0.2); #else u32 info_colors[2] = { RGB32_F(0.4, 0.4, 0.4), RGB32_F(0.5, 0.5, 0.5) }; u32 success_colors[2] = { RGB32_F(0.1, 0.3, 0.1), RGB32_F(0.2, 0.4, 0.2) }; u32 warning_colors[2] = { RGB32_F(0.4, 0.4, 0.1), RGB32_F(0.5, 0.5, 0.2) }; u32 error_colors[2] = { RGB32_F(0.4, 0.1, 0.1), RGB32_F(0.5, 0.2, 0.2) }; #endif struct v2 draw_pos = desired_start_pos; f32 bounds_top = F32_INFINITY; f32 bounds_bottom = -F32_INFINITY; if (G.console_logs_height < desired_start_pos.y) { draw_pos.y = G.console_logs_height; } G.console_logs_height = 0; i64 now_ns = sys_time_ns(); struct font *font = font_load_async(LIT("font/fixedsys.ttf"), 12.0f); if (font) { struct snc_lock lock = snc_lock_e(&G.console_logs_mutex); { for (struct console_log *log = G.last_console_log; log; log = log->prev) { f32 opacity = 0.75; if (minimized) { f32 lin = 1.0 - clamp_f64((f64)(now_ns - log->time_ns) / (f64)fade_time_ns, 0, 1); opacity *= math_pow(lin, fade_curve); } if (draw_pos.y > -desired_start_pos.y && opacity > 0) { if (log->level <= level) { /* Draw background */ u32 color = colors[log->level][log->color_index]; draw_quad(G.render_sig, quad_from_rect(log->bounds), ALPHA32_F(color, opacity)); /* Draw text */ struct string text = log->msg; if (!minimized) { struct sys_datetime datetime = log->datetime; text = string_format( scratch.arena, LIT("[%F:%F:%F.%F] %F"), FMT_UINT_Z(datetime.hour, 2), FMT_UINT_Z(datetime.minute, 2), FMT_UINT_Z(datetime.second, 2), FMT_UINT_Z(datetime.milliseconds, 3), FMT_STR(text)); } struct draw_text_params params = DRAW_TEXT_PARAMS(.font = font, .pos = draw_pos, .offset_y = DRAW_TEXT_OFFSET_Y_BOTTOM, .color = ALPHA32_F(COLOR_WHITE, opacity), .str = text); struct rect bounds = draw_text(G.render_sig, params); struct rect draw_bounds = bounds; draw_bounds.x -= bg_margin; draw_bounds.y -= bg_margin; draw_bounds.width += bg_margin * 2.f; draw_bounds.height += bg_margin * 2.f; draw_pos.y -= draw_bounds.height + spacing; log->bounds = draw_bounds; bounds_top = min_f32(bounds_top, draw_bounds.y); bounds_bottom = max_f32(bounds_bottom, draw_bounds.y + draw_bounds.height); } } else { break; } } } snc_unlock(&lock); } if (bounds_top < F32_INFINITY && bounds_bottom > -F32_INFINITY) { G.console_logs_height = bounds_bottom - bounds_top; } scratch_end(scratch); } /* ========================== * * Sort entities * ========================== */ INTERNAL SORT_COMPARE_FUNC_DEF(ent_draw_order_cmp, arg_a, arg_b, udata) { (UNUSED)udata; struct sim_ent *a = *(struct sim_ent **)arg_a; struct sim_ent *b = *(struct sim_ent **)arg_b; i32 res = 0; if (res == 0) { /* Sort by light */ b32 a_cmp = sim_ent_has_prop(a, SEPROP_LIGHT_TEST); b32 b_cmp = sim_ent_has_prop(b, SEPROP_LIGHT_TEST); res = (a_cmp > b_cmp) - (a_cmp < b_cmp); } if (res == 0) { /* Sort by layer */ i32 a_cmp = a->layer; i32 b_cmp = b->layer; res = (a_cmp < b_cmp) - (a_cmp > b_cmp); } if (res == 0) { /* Sort by sprite */ u64 a_cmp = a->sprite.hash; u64 b_cmp = b->sprite.hash; res = (a_cmp < b_cmp) - (a_cmp > b_cmp); } if (res == 0) { /* Sort by activation */ u64 a_cmp = a->activation_tick; u64 b_cmp = b->activation_tick; res = (a_cmp < b_cmp) - (a_cmp > b_cmp); } return res; } /* ========================== * * Update * ========================== */ INTERNAL void user_update(struct sys_window *window) { __prof; struct arena_temp scratch = scratch_begin_no_conflict(); /* ========================== * * Begin frame * ========================== */ G.real_dt_ns = sys_time_ns() - G.real_time_ns; G.real_time_ns += G.real_dt_ns; G.screen_size = sys_window_get_size(window); struct sprite_scope *sprite_frame_scope = sprite_scope_begin(); /* ========================== * * Pull latest local sim snapshot * ========================== */ { __profn("Pull snapshot"); struct snc_lock lock = snc_lock_e(&G.local_to_user_client_mutex); u64 old_last_tick = G.user_unblended_client->last_tick; u64 last_tick = G.local_to_user_client->last_tick; if (last_tick > old_last_tick) { struct sim_snapshot *src = sim_snapshot_from_tick(G.local_to_user_client, last_tick); sim_snapshot_alloc(G.user_unblended_client, src, src->tick); G.last_local_to_user_snapshot_published_at_ns = G.local_to_user_client_publish_time_ns; G.average_local_to_user_snapshot_publish_dt_ns -= G.average_local_to_user_snapshot_publish_dt_ns / 50; G.average_local_to_user_snapshot_publish_dt_ns += G.local_to_user_client_publish_dt_ns / 50; } snc_unlock(&lock); } /* ========================== * * Create user world from blended snapshots * ========================== */ { __profn("Blend snapshots"); /* How along are we between sim ticks (0 = start of tick, 1 = end of tick) */ f64 tick_progress = 0; i64 next_tick_expected_ns = G.last_local_to_user_snapshot_published_at_ns + G.average_local_to_user_snapshot_publish_dt_ns; if (next_tick_expected_ns > G.last_local_to_user_snapshot_published_at_ns) { tick_progress = (f64)(G.real_time_ns - G.last_local_to_user_snapshot_published_at_ns) / (f64)(next_tick_expected_ns - G.last_local_to_user_snapshot_published_at_ns); } /* Predict local sim time based on average snapshot publish dt. */ struct sim_snapshot *newest_snapshot = sim_snapshot_from_tick(G.user_unblended_client, G.user_unblended_client->last_tick); G.local_sim_last_known_time_ns = newest_snapshot->sim_time_ns; G.local_sim_last_known_tick = newest_snapshot->tick; if (atomic32_fetch(&G.user_paused)) { G.local_sim_predicted_time_ns = G.local_sim_last_known_tick; } else { G.local_sim_predicted_time_ns = newest_snapshot->sim_time_ns + (newest_snapshot->sim_dt_ns * tick_progress); } if (USER_INTERP_ENABLED && !atomic32_fetch(&G.user_paused)) { /* Determine render time */ G.render_time_target_ns = G.local_sim_predicted_time_ns - (USER_INTERP_RATIO * G.average_local_to_user_snapshot_publish_dt_ns); if (G.average_local_to_user_snapshot_publish_dt_ns > 0) { /* Increment render time based on average publish dt */ f64 sim_publish_timescale = (f64)newest_snapshot->sim_dt_ns / (f64)G.average_local_to_user_snapshot_publish_dt_ns; G.render_time_ns += G.real_dt_ns * sim_publish_timescale; } i64 render_time_target_diff_ns = G.render_time_target_ns - G.render_time_ns; if (render_time_target_diff_ns > NS_FROM_SECONDS(0.010) || render_time_target_diff_ns < NS_FROM_SECONDS(-0.005)) { /* Snap render time if it gets too out of sync with target render time */ G.render_time_ns = G.render_time_target_ns; } /* Get two snapshots nearest to render time */ struct sim_snapshot *left_snapshot = sim_snapshot_nil(); struct sim_snapshot *right_snapshot = newest_snapshot; { struct sim_snapshot *ss = sim_snapshot_from_tick(G.user_unblended_client, G.user_unblended_client->first_tick); while (ss->valid) { u64 next_tick = ss->next_tick; i64 ss_time_ns = ss->sim_time_ns; if (ss_time_ns < G.render_time_ns && ss_time_ns > left_snapshot->sim_time_ns) { left_snapshot = ss; } if (ss_time_ns > G.render_time_ns && ss_time_ns < right_snapshot->sim_time_ns) { right_snapshot = ss; } ss = sim_snapshot_from_tick(G.user_unblended_client, next_tick); } } /* Create world from blended snapshots */ if (left_snapshot->valid && right_snapshot->valid) { f64 blend = (f64)(G.render_time_ns - left_snapshot->sim_time_ns) / (f64)(right_snapshot->sim_time_ns - left_snapshot->sim_time_ns); G.ss_blended = sim_snapshot_alloc_from_lerp(G.user_blended_client, left_snapshot, right_snapshot, blend); } else if (left_snapshot->valid) { G.ss_blended = sim_snapshot_alloc(G.user_blended_client, left_snapshot, left_snapshot->tick); } else if (right_snapshot->valid) { G.ss_blended = sim_snapshot_alloc(G.user_blended_client, right_snapshot, right_snapshot->tick); } /* Release unneeded unblended snapshots */ if (left_snapshot->tick > 0) { sim_snapshot_release_ticks_in_range(G.user_unblended_client, 0, left_snapshot->tick - 1); } } else { /* Interp disabled, just copy latest snapshot */ G.render_time_target_ns = newest_snapshot->sim_time_ns; G.render_time_ns = newest_snapshot->sim_time_ns; G.ss_blended = sim_snapshot_alloc(G.user_blended_client, newest_snapshot, newest_snapshot->tick); /* Release unneeded unblended snapshots */ if (newest_snapshot->tick > 0) { sim_snapshot_release_ticks_in_range(G.user_unblended_client, 0, newest_snapshot->tick - 1); } } /* Release unneeded blended snapshots */ if (G.ss_blended->tick > 0) { sim_snapshot_release_ticks_in_range(G.user_blended_client, 0, G.ss_blended->tick - 1); sim_snapshot_release_ticks_in_range(G.user_blended_client, G.ss_blended->tick + 1, U64_MAX); } } /* ========================== * * Process sys events into user bind state * ========================== */ { __profn("Process sys events"); struct sys_window_event_array events = sys_window_pop_events(scratch.arena, window); /* Reset bind pressed / released states */ for (u32 i = 0; i < countof(G.bind_states); ++i) { G.bind_states[i] = (struct bind_state) { .is_held = G.bind_states[i].is_held }; } for (u64 ent_index = 0; ent_index < events.count; ++ent_index) { struct sys_window_event *event = &events.events[ent_index]; if (event->kind == SYS_EVENT_KIND_QUIT) { sys_exit(); } if (event->kind == SYS_EVENT_KIND_BUTTON_UP) { /* Escape quit */ if (event->button == SYS_BTN_ESC) { sys_exit(); } } /* Update mouse pos */ if (event->kind == SYS_EVENT_KIND_CURSOR_MOVE) { G.screen_cursor = event->cursor_position; } /* Update bind states */ if ((event->kind == SYS_EVENT_KIND_BUTTON_DOWN || event->kind == SYS_EVENT_KIND_BUTTON_UP)) { enum sys_btn button = event->button; button = button >= SYS_BTN_COUNT ? SYS_BTN_NONE : button; enum user_bind_kind bind = g_binds[button]; if (bind) { b32 pressed = event->kind == SYS_EVENT_KIND_BUTTON_DOWN; #if 0 b32 out_of_bounds = button >= SYS_BTN_M1 && button <= SYS_BTN_M5 && (G.ui_cursor.x < 0 || G.ui_cursor.y < 0 || G.ui_cursor.x > G.ui_size.x || G.ui_cursor.y > G.ui_size.y); #else b32 out_of_bounds = 0; #endif G.bind_states[bind].is_held = pressed && !out_of_bounds; if (pressed) { if (!out_of_bounds) { ++G.bind_states[bind].num_presses_and_repeats; if (event->is_repeat) { ++G.bind_states[bind].num_repeats; } else { ++G.bind_states[bind].num_presses; } } } else { ++G.bind_states[bind].num_releases; } } } } } /* ========================== * * Find local entities * ========================== */ 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); /* ========================== * * Find hovered entity * ========================== */ struct sim_ent *hovered_ent = sim_ent_nil(); { struct xform mouse_xf = xform_from_pos(G.world_cursor); struct collider_shape mouse_shape = ZI; mouse_shape.points[0] = V2(0, 0); mouse_shape.count = 1; mouse_shape.radius = 0.01f; for (u64 ent_index = 0; ent_index < G.ss_blended->num_ents_reserved; ++ent_index) { struct sim_ent *ent = &G.ss_blended->ents[ent_index]; if (!sim_ent_is_valid_and_active(ent)) continue; struct collider_shape ent_collider = ent->local_collider; if (ent_collider.count > 0) { /* TODO: Can just use boolean GJK */ struct xform ent_xf = sim_ent_get_xform(ent); struct collider_collision_points_result res = collider_collision_points(&ent_collider, &mouse_shape, ent_xf, mouse_xf); if (res.num_points > 0) { hovered_ent = sim_ent_from_id(G.ss_blended, ent->top); break; } } } } /* ========================== * * Update user state from binds * ========================== */ /* Test fullscreen */ { if (G.bind_states[USER_BIND_KIND_FULLSCREEN].num_presses && G.bind_states[USER_BIND_KIND_FULLSCREEN_MOD].is_held) { struct sys_window_settings settings = sys_window_get_settings(window); settings.flags ^= SYS_WINDOW_SETTINGS_FLAG_FULLSCREEN; sys_window_update_settings(window, &settings); } } if (G.bind_states[USER_BIND_KIND_DEBUG_DRAW].num_presses > 0) { G.debug_draw = !G.debug_draw; } if (G.bind_states[USER_BIND_KIND_DEBUG_TOGGLE_TOPMOST].num_presses > 0) { sys_window_toggle_topmost(window); logf_success("Toggle topmost"); } if (G.bind_states[USER_BIND_KIND_DEBUG_CONSOLE].num_presses > 0) { G.debug_console = !G.debug_console; } if (G.bind_states[USER_BIND_KIND_DEBUG_CAMERA].num_presses > 0) { G.debug_camera = !G.debug_camera; } { if (G.bind_states[USER_BIND_KIND_DEBUG_FOLLOW].num_presses > 0) { if (sim_ent_id_is_nil(G.debug_following)) { G.debug_following = hovered_ent->id; } else { G.debug_following = SIM_ENT_NIL_ID; } } if (!sim_ent_id_is_nil(G.debug_following)) { struct sim_ent *follow_ent = sim_ent_from_id(G.ss_blended, G.debug_following); struct sim_ent *follow_camera = sim_ent_nil(); for (u64 i = 0; i < G.ss_blended->num_ents_reserved; ++i) { struct sim_ent *ent = &G.ss_blended->ents[i]; struct sim_ent *ent_camera_follow = sim_ent_from_id(G.ss_blended, ent->camera_follow); if (ent_camera_follow->valid && ent_camera_follow == follow_ent) { follow_camera = ent; break; } } if (follow_camera->valid) { local_camera = follow_camera; } else { G.debug_following = SIM_ENT_NIL_ID; } } } /* ========================== * * Apply shake * ========================== */ for (u64 ent_index = 0; ent_index < G.ss_blended->num_ents_reserved; ++ent_index) { struct sim_ent *ent = &G.ss_blended->ents[ent_index]; if (!sim_ent_is_valid_and_active(ent)) continue; /* How much time between camera shakes */ i64 frequency_ns = NS_FROM_SECONDS(0.01f); f32 shake = ent->shake; if (shake > 0) { u64 angle_seed0 = ent->id.uid.lo + (u64)(G.ss_blended->sim_time_ns / frequency_ns); u64 angle_seed1 = angle_seed0 + 1; f32 angle0 = rand_f64_from_seed(angle_seed0, 0, TAU); 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, it's just a prediction */ struct v2 vec1 = v2_with_len(v2_from_angle(angle1), shake); /* TODO: Cubic interp? */ f32 blend = (f32)(G.ss_blended->sim_time_ns % frequency_ns) / (f32)frequency_ns; struct v2 vec = v2_lerp(vec0, vec1, blend); struct xform xf = sim_ent_get_xform(ent); xf.og = v2_add(xf.og, v2_mul(vec, shake)); sim_ent_set_xform(ent, xf); } } /* ========================== * * Update ui to screen xform from screen size * ========================== */ if (G.debug_camera) { G.ui_size = G.screen_size; G.ui_to_screen_xf = XFORM_IDENT; G.ui_to_screen_xf.og = v2_round(G.ui_to_screen_xf.og); } else { /* Determine ui size by camera & window dimensions */ f32 aspect_ratio = (f32)(DEFAULT_CAMERA_WIDTH / DEFAULT_CAMERA_HEIGHT); if (local_camera->valid) { struct xform quad_xf = xform_mul(sim_ent_get_xform(local_camera), local_camera->camera_quad_xform); struct v2 camera_size = xform_get_scale(quad_xf); if (!v2_is_zero(camera_size)) { aspect_ratio = camera_size.x / camera_size.y; } } f32 width = G.screen_size.x; f32 height = G.screen_size.y; if (width / height > aspect_ratio) { width = height * aspect_ratio; } else { height = math_ceil(width / aspect_ratio); } G.ui_size = V2(width, height); /* Center ui in window */ f32 x = math_round(G.screen_size.x / 2 - width / 2); f32 y = math_round(G.screen_size.y / 2 - height / 2); G.ui_to_screen_xf = XFORM_TRS(.t = V2(x, y)); G.ui_to_screen_xf.og = v2_round(G.ui_to_screen_xf.og); } G.ui_cursor = xform_mul_v2(xform_invert(G.ui_to_screen_xf), G.screen_cursor); /* ========================== * * Update world to ui xform from camera * ========================== */ if (G.debug_camera) { G.world_to_ui_xf = xform_basis_with_rotation_world(G.world_to_ui_xf, 0); struct v2 world_cursor = xform_invert_mul_v2(G.world_to_ui_xf, G.ui_cursor); /* Pan view */ if (G.bind_states[USER_BIND_KIND_PAN].is_held) { if (!G.debug_camera_panning) { G.debug_camera_pan_start = world_cursor; G.debug_camera_panning = 1; } struct v2 offset = v2_neg(v2_sub(G.debug_camera_pan_start, world_cursor)); G.world_to_ui_xf = xform_translated(G.world_to_ui_xf, offset); world_cursor = xform_invert_mul_v2(G.world_to_ui_xf, G.ui_cursor); G.debug_camera_pan_start = world_cursor; } else { G.debug_camera_panning = 0; } /* Zoom view */ i32 input_zooms = G.bind_states[USER_BIND_KIND_ZOOM_IN].num_presses - G.bind_states[USER_BIND_KIND_ZOOM_OUT].num_presses; if (input_zooms != 0) { /* Zoom to cursor */ f32 zoom_rate = 2; f32 zoom = math_pow(zoom_rate, input_zooms); G.world_to_ui_xf = xform_translated(G.world_to_ui_xf, world_cursor); G.world_to_ui_xf = xform_scaled(G.world_to_ui_xf, V2(zoom, zoom)); G.world_to_ui_xf = xform_translated(G.world_to_ui_xf, v2_neg(world_cursor)); } G.world_to_ui_xf.og = v2_round(G.world_to_ui_xf.og); } else { struct xform xf = sim_ent_get_xform(local_camera); struct v2 world_center = xf.og; f32 rot = xform_get_rotation(xf); /* Scale view into viewport based on camera size */ struct v2 scale = G.ui_size; { struct xform quad_xf = xform_mul(xf, local_camera->camera_quad_xform); struct v2 camera_size = xform_get_scale(quad_xf); if (!v2_is_zero(camera_size)) { scale = v2_div_v2(G.ui_size, camera_size); } } scale.x = min_f32(scale.x, scale.y); scale.y = scale.x; struct v2 ui_center = v2_mul(G.ui_size, 0.5); struct trs trs = TRS(.t = v2_sub(ui_center, world_center), .r = rot, .s = scale); struct v2 pivot = world_center; G.world_to_ui_xf = XFORM_IDENT; G.world_to_ui_xf = xform_translated(G.world_to_ui_xf, pivot); G.world_to_ui_xf = xform_translated(G.world_to_ui_xf, trs.t); G.world_to_ui_xf = xform_rotated(G.world_to_ui_xf, trs.r); G.world_to_ui_xf = xform_scaled(G.world_to_ui_xf, trs.s); G.world_to_ui_xf = xform_translated(G.world_to_ui_xf, v2_neg(pivot)); G.world_to_ui_xf.og = v2_round(G.world_to_ui_xf.og); } G.world_cursor = xform_invert_mul_v2(G.world_to_ui_xf, G.ui_cursor); /* ========================== * * Update world to render xform from world to ui xform * ========================== */ b32 effects_disabled = 0; G.render_size = v2_round(V2(RENDER_WIDTH, RENDER_HEIGHT)); if (G.debug_camera) { G.render_size = G.ui_size; effects_disabled = 1; G.world_to_render_xf = G.world_to_ui_xf; } else { struct xform ui_to_world_xf = xform_invert(G.world_to_ui_xf); struct v2 world_center = xform_mul_v2(ui_to_world_xf, v2_mul(G.ui_size, 0.5)); struct v2 scale = V2(PIXELS_PER_UNIT, PIXELS_PER_UNIT); struct xform xf = XFORM_IDENT; xf = xform_translated(xf, v2_mul(G.render_size, 0.5)); xf = xform_scaled(xf, scale); xf = xform_translated(xf, v2_mul(world_center, -1)); xf.og = v2_round(xf.og); G.world_to_render_xf = xf; } /* ========================== * * Update render to ui xform * ========================== */ { struct xform world_to_ui_xf = G.world_to_ui_xf; struct xform world_to_render_xf = G.world_to_render_xf; struct xform render_to_world_xf = xform_invert(world_to_render_xf); struct xform render_to_ui_xf = xform_mul(world_to_ui_xf, render_to_world_xf); G.render_to_ui_xf = render_to_ui_xf; } /* ========================== * * Update listener from view * ========================== */ { struct v2 up = V2(0, -1); struct v2 ui_center = v2_mul(G.ui_size, 0.5f); struct v2 listener_pos = xform_invert_mul_v2(G.world_to_ui_xf, ui_center); struct v2 listener_dir = v2_norm(xform_basis_invert_mul_v2(G.world_to_ui_xf, up)); mixer_set_listener(listener_pos, listener_dir); } /* ========================== * * Draw grid * ========================== */ { f32 thickness = 2; struct v2 offset = v2_neg(xform_mul_v2(G.world_to_render_xf, V2(0, 0))); f32 spacing = xform_get_scale(G.world_to_render_xf).x; struct v2 pos = xform_invert_mul_v2(G.world_to_render_xf, V2(0, 0)); struct v2 size = xform_basis_invert_mul_v2(G.world_to_render_xf, G.render_size); u32 color0 = RGBA32_F(0.17f, 0.17f, 0.17f, 1.f); u32 color1 = RGBA32_F(0.15f, 0.15f, 0.15f, 1.f); draw_grid(G.render_sig, xform_from_rect(RECT_FROM_V2(pos, size)), color0, color1, RGBA32(0x3f, 0x3f, 0x3f, 0xFF), COLOR_RED, COLOR_GREEN, thickness, spacing, offset); } #if 0 /* ========================== * * 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, SEPROP_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); } } } /* ========================== * * 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 #endif /* ========================== * * Sort drawable entities * ========================== */ struct sim_ent **sorted = arena_push_dry(scratch.arena, struct sim_ent *); u64 sorted_count = 0; { /* Copy valid entities */ { __profn("Build ents list for sorting"); for (u64 ent_index = 0; ent_index < G.ss_blended->num_ents_reserved; ++ent_index) { struct sim_ent *ent = &G.ss_blended->ents[ent_index]; if (sim_ent_is_valid_and_active(ent)) { *arena_push_no_zero(scratch.arena, struct sim_ent *) = ent; ++sorted_count; } } } /* Sort */ { __profn("Sort ents"); merge_sort(sorted, sorted_count, sizeof(*sorted), ent_draw_order_cmp, 0); } } /* ========================== * * Draw entities * ========================== */ { __profn("Draw entities"); for (u64 sorted_index = 0; sorted_index < sorted_count; ++sorted_index) { struct sim_ent *ent = sorted[sorted_index]; if (!sim_ent_is_valid_and_active(ent)) continue; //if (sprite_tag_is_nil(ent->sprite)) continue; struct sprite_tag sprite = ent->sprite; struct sim_ent *parent = sim_ent_from_id(G.ss_blended, ent->parent); struct xform xf = sim_ent_get_xform(ent); struct xform parent_xf = sim_ent_get_xform(parent); b32 skip_debug_draw = !G.debug_camera && ent == local_camera; skip_debug_draw = skip_debug_draw || sim_ent_has_prop(ent, SEPROP_MOTOR_JOINT); b32 skip_debug_draw_transform = sim_ent_has_prop(ent, SEPROP_CAMERA); skip_debug_draw_transform = 1; struct xform sprite_xform = xform_mul(xf, ent->sprite_local_xform); /* Draw tracer */ /* TODO: Enable this */ #if 0 if (sim_ent_has_prop(ent, SEPROP_TRACER)) { struct v2 velocity = ent->tracer_start_velocity; struct v2 a = ent->tracer_start; struct v2 b = xf.og; struct v2 c = ent->tracer_gradient_start; struct v2 d = ent->tracer_gradient_end; struct v2 vcd = v2_sub(d, c); struct v2 vca = v2_sub(a, c); struct v2 vdb = v2_sub(b, d); struct v2 vdc = v2_neg(vcd); f32 opacity_a = 1; f32 opacity_b = 1; if (v2_len_sq(vcd) != 0) { if (v2_dot(velocity, vca) <= 0) { a = c; opacity_a = 0; } else { opacity_a = v2_dot(vcd, vca) / v2_len_sq(vcd); } opacity_a = clamp_f32(opacity_a, 0, 1); opacity_b = clamp_f32(1.f - (v2_dot(vdc, vdb) / v2_len_sq(vdc)), 0, 1); } f32 thickness = 0.01f; u32 color_start = RGBA32_F(1, 0.5, 0, opacity_a); u32 color_end = RGBA32_F(1, 0.8, 0.4, opacity_b); if (opacity_b > 0.99f) { draw_circle(G.render_sig, b, thickness / 2, color_end, 20); } draw_gradient_line(G.render_sig, a, b, thickness, color_start, color_end); } #endif /* Draw sprite */ if (!sprite_tag_is_nil(sprite)) { struct sprite_sheet *sheet = sprite_sheet_from_tag_async(sprite_frame_scope, sprite); sprite_texture_from_tag_prefetch(sprite_frame_scope, sprite); /* TODO: Fade in placeholder if texture isn't loaded */ if (sheet->loaded) { b32 is_light = sim_ent_has_prop(ent, SEPROP_LIGHT_TEST); struct v3 emittance = ent->sprite_emittance; u32 tint = ent->sprite_tint; struct sprite_sheet_frame frame = sprite_sheet_get_frame(sheet, ent->animation_frame); struct draw_material_params params = DRAW_MATERIAL_PARAMS(.xf = sprite_xform, .sprite = sprite, .tint = tint, .clip = frame.clip, .is_light = is_light, .light_emittance = emittance); draw_material(G.render_sig, params); } } /* Draw tiles */ /* TODO: Something better */ if (sim_ent_has_prop(ent, SEPROP_TILE_CHUNK)) { struct v2i32 chunk_index = ent->tile_chunk_index; struct sprite_tag tile_sprite = sprite_tag_from_path(LIT("sprite/tile.ase")); f32 tile_size = 1.f / SIM_TILES_PER_UNIT_SQRT; for (i32 tile_y = 0; tile_y < SIM_TILES_PER_CHUNK_SQRT; ++tile_y) { for (i32 tile_x = 0; tile_x < SIM_TILES_PER_CHUNK_SQRT; ++tile_x) { struct v2i32 local_tile_index = V2I32(tile_x, tile_y); enum sim_tile_kind tile = ent->tile_chunk_tiles[local_tile_index.x + (local_tile_index.y * SIM_TILES_PER_CHUNK_SQRT)]; //if (tile > -1) { if (tile == SIM_TILE_KIND_WALL) { struct v2i32 world_tile_index = sim_world_tile_index_from_local_tile_index(chunk_index, local_tile_index); struct v2 pos = sim_pos_from_world_tile_index(world_tile_index); struct xform tile_xf = xform_from_rect(RECT_FROM_V2(pos, V2(tile_size, tile_size))); struct draw_material_params params = DRAW_MATERIAL_PARAMS(.xf = tile_xf, .sprite = tile_sprite, .is_light = 1, .light_emittance = V3(0, 0, 0)); draw_material(G.render_sig, params); } } } } /* Debug draw entity info */ if (G.debug_draw && !skip_debug_draw) { struct arena_temp temp = arena_temp_begin(scratch.arena); if (sim_ent_has_prop(ent, SEPROP_KINEMATIC) || sim_ent_has_prop(ent, SEPROP_DYNAMIC)) { debug_draw_movement(ent); } /* Draw xform */ if (!skip_debug_draw_transform) { u32 color_x = RGBA32_F(1, 0, 0, 0.5); u32 color_y = RGBA32_F(0, 1, 0, 0.5); debug_draw_xform(xf, color_x, color_y); } /* Draw AABB */ if (ent->local_collider.count > 0) { struct aabb aabb = collider_aabb_from_collider(&ent->local_collider, xf); f32 thickness = 1; u32 color = RGBA32_F(1, 0, 1, 0.5); struct quad quad = quad_from_aabb(aabb); quad = xform_mul_quad(G.world_to_ui_xf, quad); draw_quad_line(G.render_sig, quad, thickness, color); } /* Draw focus arrow */ if (ent == local_control || sim_ent_id_eq(ent->id, G.debug_following)) { struct sprite_sheet *sheet = sprite_sheet_from_tag_async(sprite_frame_scope, ent->sprite); 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); start = xform_mul_v2(G.world_to_ui_xf, start); struct v2 end = v2_add(xf.og, ent->control.focus); end = xform_mul_v2(G.world_to_ui_xf, end); draw_arrow_line(G.render_sig, start, end, 3, 10, RGBA32_F(1, 1, 1, 0.5)); } #if 0 /* Draw slices */ if (!sprite_tag_is_nil(ent->sprite)) { struct sprite_sheet *sheet = sprite_sheet_from_tag_async(sprite_frame_scope, sprite); u32 quad_color = RGBA32_F(1, 0, 0.5, 1); u32 point_color = RGBA32_F(1, 0, 0, 1); u32 ray_color = RGBA32_F(1, 0, 0.5, 1); for (u64 i = 0; i < sheet->slice_groups_count; ++i) { struct sprite_sheet_slice_group *group = &sheet->slice_groups[i]; if (string_ends_with(group->name, LIT(".ray"))) continue; 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 v2 center = xform_mul_v2(sprite_xform, slice.center); center = xform_mul_v2(G.world_to_ui_xf, center); if (!slice.has_ray) { struct quad quad = quad_from_rect(slice.rect); quad = xform_mul_quad(sprite_xform, quad); quad = xform_mul_quad(G.world_to_ui_xf, quad); draw_quad_line(G.render_sig, quad, 2, quad_color); } draw_circle(G.render_sig, center, 3, point_color, 20); if (slice.has_ray) { struct v2 ray = xform_basis_mul_v2(sprite_xform, slice.dir); ray = xform_basis_mul_v2(G.world_to_ui_xf, ray); ray = v2_with_len(ray, 25); draw_arrow_ray(G.render_sig, center, ray, 2, 10, ray_color); } } } } #endif /* Draw weld joint */ #if 0 if (sim_ent_has_prop(ent, SEPROP_WELD_JOINT)) { struct sim_ent *e1 = sim_ent_from_id(G.ss_blended, ent->weld_joint_data.e1); struct xform e1_xf = sim_ent_get_xform(e1); u32 color = COLOR_YELLOW; f32 radius = 3; struct v2 point = xform_mul_v2(e1_xf, ent->weld_joint_data.point_local_e1); point = xform_mul_v2(G.world_to_ui_xf, point); draw_circle(G.render_sig, point, radius, color, 10); DEBUGBREAKABLE; } #endif /* Draw mouse joint */ if (sim_ent_has_prop(ent, SEPROP_MOUSE_JOINT)) { struct sim_ent *target = sim_ent_from_id(G.ss_blended, ent->mouse_joint_data.target); struct xform target_xf = sim_ent_get_xform(target); u32 color = COLOR_WHITE; struct v2 point_start = xform_mul_v2(target_xf, ent->mouse_joint_data.point_local_start); struct v2 point_end = G.world_cursor; point_start = xform_mul_v2(G.world_to_ui_xf, point_start); point_end = xform_mul_v2(G.world_to_ui_xf, point_end); draw_arrow_line(G.render_sig, point_start, point_end, 3, 10, color); draw_circle(G.render_sig, point_start, 4, color, 10); } /* Draw collider */ if (ent->local_collider.count > 0) { struct collider_shape collider = ent->local_collider; u32 color = RGBA32_F(1, 1, 0, 0.5); f32 thickness = 2; { /* Draw collider using support points */ u32 detail = 32; struct xform collider_draw_xf = xform_mul(G.world_to_ui_xf, xf); draw_collider_line(G.render_sig, collider, collider_draw_xf, thickness, color, detail); } { /* Draw collider shape points */ for (u32 i = 0; i < collider.count; ++i) { struct v2 p = xform_mul_v2(xform_mul(G.world_to_ui_xf, xf), collider.points[i]); draw_circle(G.render_sig, p, 3, COLOR_BLUE, 10); } } if (collider.count == 1 && collider.radius > 0) { /* Draw upwards line for circle */ struct v2 start = xf.og; struct v2 end = collider_get_support_point(&collider, xf, v2_neg(xf.by)).p; start = xform_mul_v2(G.world_to_ui_xf, start); end = xform_mul_v2(G.world_to_ui_xf, end); draw_line(G.render_sig, start, end, thickness, color); } #if 0 /* Draw support point at focus dir */ { struct v2 p = collider_support_point(&collider, xf, ent->control.focus); p = xform_mul_v2(G.world_to_ui_xf, p); draw_circle(G.render_sig, p, 3, COLOR_RED, 10); } #endif } /* Draw contact constraint */ if (sim_ent_has_prop(ent, SEPROP_CONTACT_CONSTRAINT)) { struct phys_contact_constraint *data = &ent->contact_constraint_data; struct sim_ent *e0 = sim_ent_from_id(G.ss_blended, data->e0); struct sim_ent *e1 = sim_ent_from_id(G.ss_blended, data->e1); (UNUSED)e0; (UNUSED)e1; #if DEVELOPER /* Draw contact points */ { f32 radius = 5; for (u32 i = 0; i < data->num_points; ++i) { u32 color = (data->skip_solve || data->wrong_dir) ? ALPHA32_F(COLOR_YELLOW, 0.3) : RGBA32_F(0.8, 0.2, 0.2, 1); struct phys_contact_point point = data->points[i]; struct v2 dbg_pt = point.dbg_pt; /* Draw point */ { draw_circle(G.render_sig, xform_mul_v2(G.world_to_ui_xf, dbg_pt), radius, color, 10); } /* Draw normal */ { f32 len = 0.1f; f32 arrow_thickness = 2; f32 arrow_height = 5; struct v2 start = xform_mul_v2(G.world_to_ui_xf, dbg_pt); struct v2 end = xform_mul_v2(G.world_to_ui_xf, v2_add(dbg_pt, v2_mul(v2_norm(data->normal), len))); draw_arrow_line(G.render_sig, start, end, arrow_thickness, arrow_height, color); } #if 0 /* Draw contact info */ { struct font *disp_font = font_load_async(LIT("font/fixedsys.ttf"), 12.0f); if (disp_font) { f32 offset_px = 10; struct string fmt = LIT( "e0 index: %F\n" "e1 index: %F\n" "id: 0x%F\n" "impulse (n): %F\n" "impulse (t): %F\n" "separation: %F\n" "normal: (%F, %F)\n" "num contacts: %F" ); struct string text = string_format(temp.arena, fmt, FMT_UINT(e0->handle.idx), FMT_UINT(e1->handle.idx), FMT_HEX(point.id), FMT_FLOAT(point.normal_impulse), FMT_FLOAT(point.tangent_impulse), FMT_FLOAT_P(point.starting_separation, 6), FMT_FLOAT_P(data->normal.x, 6), FMT_FLOAT_P(data->normal.y, 6), FMT_UINT(data->num_points)); draw_text(G.render_sig, disp_font, v2_add(v2_round(xform_mul_v2(G.world_to_ui_xf, dbg_pt)), V2(0, offset_px)), text); } } #endif } } #endif } /* Draw collision debug */ #if COLLIDER_DEBUG if (sim_ent_has_prop(ent, SEPROP_COLLISION_DEBUG)) { struct phys_collision_debug *data = &ent->collision_debug_data; struct collider_collision_points_result collider_res = data->res; struct sim_ent *e0 = sim_ent_from_id(G.ss_blended, data->e0); struct sim_ent *e1 = sim_ent_from_id(G.ss_blended, data->e1); struct collider_shape e0_collider = e0->local_collider; struct collider_shape e1_collider = e1->local_collider; (UNUSED)e0_collider; (UNUSED)e1_collider; /* Draw closest points */ #if 0 { f32 radius = 4; u32 color = RGBA32_F(1, 1, 0, 0.5); struct v2 a = xform_mul_v2(G.world_to_ui_xf, data->closest0); struct v2 b = xform_mul_v2(G.world_to_ui_xf, data->closest1); draw_circle(G.render_sig, a, radius, color, 10); draw_circle(G.render_sig, b, radius, color, 10); } #endif /* Draw clipping */ { f32 thickness = 4; f32 radius = 4; u32 color_line = RGBA32_F(1, 0, 1, 0.75); u32 color_a = RGBA32_F(1, 0, 0, 0.25); u32 color_b = RGBA32_F(0, 1, 0, 0.25); u32 color_line_clipped = RGBA32_F(1, 0, 1, 1); u32 color_a_clipped = RGBA32_F(1, 0, 0, 1); u32 color_b_clipped = RGBA32_F(0, 1, 0, 1); { struct v2 a = xform_mul_v2(G.world_to_ui_xf, collider_res.a0); struct v2 b = xform_mul_v2(G.world_to_ui_xf, collider_res.b0); draw_line(G.render_sig, a, b, thickness, color_line); draw_circle(G.render_sig, a, radius, color_a, 10); draw_circle(G.render_sig, b, radius, color_b, 10); struct v2 a_clipped = xform_mul_v2(G.world_to_ui_xf, collider_res.a0_clipped); struct v2 b_clipped = xform_mul_v2(G.world_to_ui_xf, collider_res.b0_clipped); draw_line(G.render_sig, a_clipped, b_clipped, thickness, color_line_clipped); draw_circle(G.render_sig, a_clipped, radius, color_a_clipped, 10); draw_circle(G.render_sig, b_clipped, radius, color_b_clipped, 10); } { struct v2 a = xform_mul_v2(G.world_to_ui_xf, collider_res.a1); struct v2 b = xform_mul_v2(G.world_to_ui_xf, collider_res.b1); draw_line(G.render_sig, a, b, thickness, color_line); draw_circle(G.render_sig, a, radius, color_a, 10); draw_circle(G.render_sig, b, radius, color_b, 10); struct v2 a_clipped = xform_mul_v2(G.world_to_ui_xf, collider_res.a1_clipped); struct v2 b_clipped = xform_mul_v2(G.world_to_ui_xf, collider_res.b1_clipped); draw_line(G.render_sig, a_clipped, b_clipped, thickness, color_line_clipped); draw_circle(G.render_sig, a_clipped, radius, color_a_clipped, 10); draw_circle(G.render_sig, b_clipped, radius, color_b_clipped, 10); } } #if COLLIDER_DEBUG_DETAILED_DRAW_MENKOWSKI struct xform e0_xf = data->xf0; struct xform e1_xf = data->xf1; #if 0 /* Only draw points with large separation */ b32 should_draw = 0; for (u32 i = 0; i < data->num_points; ++i) { if (data->points[i].starting_separation < -0.1) { should_draw = 1; break; } } #else b32 should_draw = 1; #endif if (should_draw) { #if 0 /* Test info */ { struct font *disp_font = font_load_async(LIT("font/fixedsys.ttf"), 12.0f); if (disp_font) { f32 offset_px = 10; struct string fmt = LIT( "e0 pos: (%F, %F)\n" "e0 rot: %F\n" "e1 pos: (%F, %F)\n" "e1 rot: %F\n" ); struct string text = string_format(temp.arena, fmt, FMT_FLOAT_P(e0_xf.og.x, 24), FMT_FLOAT_P(e0_xf.og.y, 24), FMT_FLOAT_P(xform_get_rotation(e0_xf), 24), FMT_FLOAT_P(e1_xf.og.x, 24), FMT_FLOAT_P(e1_xf.og.y, 24), FMT_FLOAT_P(xform_get_rotation(e1_xf), 24)); draw_text(G.render_sig, disp_font, v2_add(v2_round(xform_mul_v2(G.world_to_ui_xf, V2(0, 0))), V2(0, offset_px)), text); } } #endif /* Draw menkowski */ { u32 color = collider_res.solved ? RGBA32_F(0, 0, 0.25, 1) : RGBA32_F(0, 0.25, 0.25, 1); f32 thickness = 2; u32 detail = 512; (UNUSED)thickness; struct v2_array m = menkowski(temp.arena, &e0_collider, &e1_collider, e0_xf, e1_xf, detail); for (u64 i = 0; i < m.count; ++i) m.points[i] = xform_mul_v2(G.world_to_ui_xf, m.points[i]); draw_poly_line(G.render_sig, m, 1, thickness, color); //draw_poly(G.render_sig, m, color); } /* Draw cloud */ { u32 color = RGBA32_F(1, 1, 1, 1); f32 radius = 2; struct v2_array m = cloud(temp.arena, &e0_collider, &e1_collider, e0_xf, e1_xf); for (u64 i = 0; i < m.count; ++i) { struct v2 p = xform_mul_v2(G.world_to_ui_xf, m.points[i]); draw_circle(G.render_sig, p, radius, color, 10); } } /* Draw prototype */ { f32 thickness = 2; u32 color = RGBA32_F(1, 1, 1, 0.25); struct v2_array m = { .points = collider_res.prototype.points, .count = collider_res.prototype.len }; for (u64 i = 0; i < m.count; ++i) m.points[i] = xform_mul_v2(G.world_to_ui_xf, m.points[i]); draw_poly_line(G.render_sig, m, 1, thickness, color); for (u64 i = 0; i < m.count; ++i) draw_circle(G.render_sig, m.points[i], 10, color, 10); } /* Draw simplex */ { f32 thickness = 2; u32 line_color = COLOR_YELLOW; u32 color_first = RGBA32_F(1, 0, 0, 0.75); u32 color_second = RGBA32_F(0, 1, 0, 0.75); u32 color_third = RGBA32_F(0, 0, 1, 0.75); struct collider_menkowski_simplex simplex = collider_res.simplex; struct v2 simplex_points[] = { simplex.a.p, simplex.b.p, simplex.c.p }; for (u64 i = 0; i < countof(simplex_points); ++i) simplex_points[i] = xform_mul_v2(G.world_to_ui_xf, simplex_points[i]); struct v2_array simplex_array = { .count = simplex.len, .points = simplex_points }; if (simplex.len >= 1) { u32 color = simplex.len == 1 ? color_first : (simplex.len == 2 ? color_second : color_third); draw_circle(G.render_sig, simplex_array.points[0], thickness * 3, color, 10); } if (simplex.len >= 2) { u32 color = simplex.len == 2 ? color_first : color_second; draw_circle(G.render_sig, simplex_array.points[1], thickness * 3, color, 10); } if (simplex.len >= 3) { u32 color = color_first; draw_circle(G.render_sig, simplex_array.points[2], thickness * 3, color, 10); } if (simplex.len >= 2) { draw_poly_line(G.render_sig, simplex_array, simplex.len > 2, thickness, line_color); } } /* Draw normal */ { u32 color = COLOR_WHITE; f32 len = 0.1f; f32 arrow_thickness = 4; f32 arrowhead_height = 10; struct v2 start = xform_mul_v2(G.world_to_ui_xf, V2(0, 0)); struct v2 end = xform_mul_v2(G.world_to_ui_xf, v2_mul(v2_norm(collider_res.normal), len)); draw_arrow_line(G.render_sig, start, end, arrow_thickness, arrowhead_height, color); } } #endif } #endif /* Draw hierarchy */ if (sim_ent_has_prop(parent, SEPROP_ACTIVE) && !parent->is_root) { u32 color = RGBA32_F(0.6, 0.6, 1, 0.75); f32 thickness = 2; f32 arrow_height = 15; struct v2 start = xform_mul_v2(G.world_to_ui_xf, xf.og); struct v2 end = xform_mul_v2(G.world_to_ui_xf, parent_xf.og); draw_arrow_line(G.render_sig, start, end, thickness, arrow_height, color); } /* Draw camera rect */ if (sim_ent_has_prop(ent, SEPROP_CAMERA)) { u32 color = ent == local_camera ? RGBA32_F(1, 1, 1, 0.5) : RGBA32_F(0, 0.75, 0, 0.5); f32 thickness = 3; struct xform quad_xf = xform_mul(xf, ent->camera_quad_xform); struct quad quad = xform_mul_quad(quad_xf, QUAD_UNIT_SQUARE_CENTERED); quad = xform_mul_quad(G.world_to_ui_xf, quad); draw_quad_line(G.render_sig, quad, thickness, color); } arena_temp_end(temp); } } } /* Draw crosshair or show cursor */ if (!G.debug_camera) { __profn("Draw crosshair"); struct v2 crosshair_pos = G.ui_cursor; struct sprite_tag crosshair = sprite_tag_from_path(LIT("sprite/crosshair.ase")); struct sprite_texture *t = sprite_texture_from_tag_async(sprite_frame_scope, crosshair); struct v2 size = V2(t->width, t->height); struct xform xf = XFORM_TRS(.t = crosshair_pos, .s = size); draw_ui_rect(G.render_sig, DRAW_UI_RECT_PARAMS(.xf = xf, .sprite = crosshair)); } /* FIXME: Enable this */ #if 0 { __profn("Update window cursor"); if (G.debug_camera) { sys_window_cursor_disable_clip(G.window); sys_window_cursor_show(G.window); } else { struct sprite_texture *t = sprite_texture_from_tag_async(sprite_frame_scope, sprite_tag_from_path(LIT("sprite/crosshair.ase"))); struct v2 size = V2(t->width, t->height); struct rect cursor_clip = RECT_FROM_V2(G.ui_screen_offset, G.ui_size); cursor_clip.pos = v2_add(cursor_clip.pos, v2_mul(size, 0.5f)); cursor_clip.pos = v2_add(cursor_clip.pos, V2(1, 1)); cursor_clip.size = v2_sub(cursor_clip.size, size); sys_window_cursor_hide(G.window); sys_window_cursor_enable_clip(G.window, cursor_clip); } } #endif /* ========================== * * Create user sim cmd * ========================== */ { /* Queue player move cmd */ f32 move_speed = 1.0f; //if (G.bind_states[USER_BIND_KIND_WALK].is_held) { if (G.bind_states[USER_BIND_KIND_FULLSCREEN_MOD].is_held) { //const f32 walk_ratio = 0.25f; const f32 walk_ratio = 0.05f; move_speed *= walk_ratio; } struct v2 input_move_dir = ZI; { for (enum user_bind_kind bind = 0; bind < (i32)countof(G.bind_states); ++bind) { struct bind_state state = G.bind_states[bind]; if (!state.is_held && state.num_presses <= 0) { continue; } switch (bind) { /* Movement */ case USER_BIND_KIND_MOVE_UP: { input_move_dir.y -= 1; } break; case USER_BIND_KIND_MOVE_DOWN: { input_move_dir.y += 1; } break; case USER_BIND_KIND_MOVE_LEFT: { input_move_dir.x -= 1; } break; case USER_BIND_KIND_MOVE_RIGHT: { input_move_dir.x += 1; } break; default: break; } } input_move_dir = xform_basis_invert_mul_v2(G.world_to_ui_xf, input_move_dir); /* Make move dir relative to world view */ input_move_dir = v2_mul(v2_norm(input_move_dir), move_speed); } if (!G.debug_camera) { G.focus_send = v2_sub(G.world_cursor, sim_ent_get_xform(local_control).og); } struct v2 input_aim_dir = G.focus_send; /* Queue player control cmd */ { struct sim_control control = ZI; control.move = input_move_dir; control.focus = input_aim_dir; control.dbg_cursor = G.world_cursor; struct bind_state fire_state = G.bind_states[USER_BIND_KIND_FIRE]; struct bind_state fire_alt_state = G.bind_states[USER_BIND_KIND_FIRE_ALT]; struct bind_state drag_state = G.bind_states[USER_BIND_KIND_DEBUG_DRAG]; struct bind_state delete_state = G.bind_states[USER_BIND_KIND_DEBUG_DELETE]; struct bind_state clear_state = G.bind_states[USER_BIND_KIND_DEBUG_CLEAR]; struct bind_state spawn1_state = G.bind_states[USER_BIND_KIND_DEBUG_SPAWN1]; struct bind_state spawn2_state = G.bind_states[USER_BIND_KIND_DEBUG_SPAWN2]; struct bind_state spawn3_state = G.bind_states[USER_BIND_KIND_DEBUG_SPAWN3]; struct bind_state spawn4_state = G.bind_states[USER_BIND_KIND_DEBUG_SPAWN4]; struct bind_state walls_state = G.bind_states[USER_BIND_KIND_DEBUG_WALLS]; 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 tile_state = G.bind_states[USER_BIND_KIND_TILE_TEST]; struct bind_state explode_state = G.bind_states[USER_BIND_KIND_DEBUG_EXPLODE]; struct bind_state teleport_state = G.bind_states[USER_BIND_KIND_DEBUG_TELEPORT]; if (fire_state.num_presses || fire_state.is_held) { control.flags |= SIM_CONTROL_FLAG_FIRE; } if (fire_alt_state.num_presses || fire_alt_state.is_held) { control.flags |= SIM_CONTROL_FLAG_FIRE_ALT; } if (drag_state.num_presses || drag_state.is_held) { control.flags |= SIM_CONTROL_FLAG_DRAG; } if (delete_state.num_presses || delete_state.is_held) { control.flags |= SIM_CONTROL_FLAG_DELETE; } if (clear_state.num_presses_and_repeats) { control.flags |= SIM_CONTROL_FLAG_CLEAR_ALL; } if (spawn1_state.num_presses_and_repeats) { control.flags |= SIM_CONTROL_FLAG_SPAWN1_TEST; } if (spawn2_state.num_presses_and_repeats) { control.flags |= SIM_CONTROL_FLAG_SPAWN2_TEST; } if (spawn3_state.num_presses_and_repeats) { control.flags |= SIM_CONTROL_FLAG_SPAWN3_TEST; } if (spawn4_state.num_presses_and_repeats) { control.flags |= SIM_CONTROL_FLAG_SPAWN4_TEST; } if (walls_state.num_presses_and_repeats) { control.flags |= SIM_CONTROL_FLAG_WALLS_TEST; } if (tile_state.num_presses || tile_state.is_held) { control.flags |= SIM_CONTROL_FLAG_TILE_TEST; } if (explode_state.num_presses_and_repeats) { control.flags |= SIM_CONTROL_FLAG_EXPLODE_TEST; } if (teleport_state.num_presses_and_repeats || (G.debug_camera && teleport_state.is_held)) { control.flags |= SIM_CONTROL_FLAG_TELEPORT_TEST; } if (pause_state.num_presses) { atomic32_fetch_xor(&G.user_paused, 1); } atomic32_fetch_add(&G.user_paused_steps, step_state.num_presses_and_repeats); /* Set user sim control */ { struct snc_lock lock = snc_lock_e(&G.user_sim_cmd_mutex); /* Reset flags */ if (G.user_sim_cmd_gen != G.last_user_sim_cmd_gen) { G.user_sim_cmd_control.flags = 0; G.last_user_sim_cmd_gen = G.user_sim_cmd_gen; } u32 old_flags = G.user_sim_cmd_control.flags; G.user_sim_cmd_control = control; G.user_sim_cmd_control.flags |= old_flags; G.user_hovered_ent = hovered_ent->id; snc_unlock(&lock); } } #if RTC /* Gjk steps */ { if (G.bind_states[USER_BIND_KIND_RESET_DEBUG_STEPS].num_presses_and_repeats > 0) { gstat_set(GSTAT_DEBUG_STEPS, 0); } i32 add_steps = 0; add_steps += G.bind_states[USER_BIND_KIND_INCR_DEBUG_STEPS].num_presses_and_repeats; add_steps -= G.bind_states[USER_BIND_KIND_DECR_DEBUG_STEPS].num_presses_and_repeats; if (add_steps != 0) { gstat_add(GSTAT_DEBUG_STEPS, add_steps); } } #endif } { /* Update network usage stats */ i64 stat_now_ns = sys_time_ns(); G.net_bytes_read.last_second_end = gstat_get(GSTAT_SOCK_BYTES_RECEIVED); G.net_bytes_sent.last_second_end = gstat_get(GSTAT_SOCK_BYTES_SENT); if (stat_now_ns - G.last_second_reset_ns > NS_FROM_SECONDS(1)) { G.last_second_reset_ns = stat_now_ns; G.net_bytes_read.last_second = G.net_bytes_read.last_second_end - G.net_bytes_read.last_second_start; G.net_bytes_sent.last_second = G.net_bytes_sent.last_second_end - G.net_bytes_sent.last_second_start; G.net_bytes_read.last_second_start = G.net_bytes_read.last_second_end; G.net_bytes_sent.last_second_start = G.net_bytes_sent.last_second_end; } } /* ========================== * * Draw ent debug info * ========================== */ if (G.debug_draw && hovered_ent->valid) { struct sim_ent *ent = hovered_ent; struct v2 pos = v2_add(G.ui_cursor, V2(15, 15)); struct font *font = font_load_async(LIT("font/fixedsys.ttf"), 12.0f); if (font) { struct arena_temp temp = arena_temp_begin(scratch.arena); struct string dbg_text = ZI; dbg_text.text = arena_push_dry(temp.arena, u8); dbg_text.len += get_ent_debug_text(temp.arena, ent).len; draw_text(G.render_sig, DRAW_TEXT_PARAMS(.font = font, .pos = pos, .str = dbg_text)); arena_temp_end(temp); } } /* ========================== * * Query vram * ========================== */ struct gp_memory_info vram = gp_query_memory_info(); /* ========================== * * Draw global debug info * ========================== */ if (G.debug_draw) { __profn("Draw debug info"); struct font *font = font_load_async(LIT("font/fixedsys.ttf"), 12.0f); if (font) { struct arena_temp temp = arena_temp_begin(scratch.arena); struct string text = ZI; text.text = arena_push_dry(temp.arena, u8); #if BITBUFF_DEBUG text.len += string_format(temp.arena, LIT("(bitbuff debug enabled)")).len; text.len += string_copy(temp.arena, LIT("\n")).len; #endif text.len += string_format(temp.arena, LIT("blended world entities: %F/%F"), FMT_UINT(G.ss_blended->num_ents_allocated), FMT_UINT(G.ss_blended->num_ents_reserved)).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("blended world tick: %F"), FMT_UINT(G.ss_blended->tick)).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("blended world time: %F"), FMT_FLOAT(SECONDS_FROM_NS(G.ss_blended->sim_time_ns))).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("average local sim publish dt: %F"), FMT_FLOAT(SECONDS_FROM_NS(G.average_local_to_user_snapshot_publish_dt_ns))).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("local sim last known tick: %F"), FMT_UINT(G.local_sim_last_known_tick)).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("local sim last known time: %F"), FMT_FLOAT(SECONDS_FROM_NS(G.local_sim_last_known_time_ns))).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("local sim predicted time: %F"), FMT_FLOAT(SECONDS_FROM_NS(G.local_sim_predicted_time_ns))).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("render time target: %F"), FMT_FLOAT(SECONDS_FROM_NS(G.render_time_target_ns))).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("render time: %F"), FMT_FLOAT(SECONDS_FROM_NS(G.render_time_ns))).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("local player: [%F]"), FMT_UID(local_player->id.uid)).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_copy(temp.arena, LIT("\n")).len; struct v2 world_cursor = G.world_cursor; text.len += string_format(temp.arena, LIT("cursor world: %F, %F"), FMT_FLOAT(world_cursor.x), FMT_FLOAT(world_cursor.y)).len; text.len += string_copy(temp.arena, LIT("\n")).len; struct v2i32 world_tile_cursor = sim_world_tile_index_from_pos(world_cursor); text.len += string_format(temp.arena, LIT("cursor world tile: %F, %F"), FMT_SINT(world_tile_cursor.x), FMT_SINT(world_tile_cursor.y)).len; text.len += string_copy(temp.arena, LIT("\n")).len; struct v2i32 local_tile_cursor = sim_local_tile_index_from_world_tile_index(world_tile_cursor); text.len += string_format(temp.arena, LIT("cursor local tile: %F, %F"), FMT_SINT(local_tile_cursor.x), FMT_SINT(local_tile_cursor.y)).len; text.len += string_copy(temp.arena, LIT("\n")).len; struct v2i32 tile_chunk_cursor = sim_tile_chunk_index_from_world_tile_index(world_tile_cursor); text.len += string_format(temp.arena, LIT("cursor tile chunk: %F, %F"), FMT_SINT(tile_chunk_cursor.x), FMT_SINT(tile_chunk_cursor.y)).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("Network read: %F mbit/s"), FMT_FLOAT((f64)G.net_bytes_read.last_second * 8 / 1000 / 1000)).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("Network write: %F mbit/s"), FMT_FLOAT((f64)G.net_bytes_sent.last_second * 8 / 1000 / 1000)).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("Ping (real): %F ms"), FMT_FLOAT(SECONDS_FROM_NS(local_player->player_last_rtt_ns) * 1000)).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("Ping (average): %F ms"), FMT_FLOAT(local_player->player_average_rtt_seconds * 1000)).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("Memory committed: %F MiB"), FMT_FLOAT((f64)gstat_get(GSTAT_MEMORY_COMMITTED) / 1024 / 1024)).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("Virtual memory reserved: %F TiB"), FMT_FLOAT((f64)gstat_get(GSTAT_MEMORY_RESERVED) / 1024 / 1024 / 1024 / 1024)).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("Arenas allocated: %F"), FMT_UINT(gstat_get(GSTAT_NUM_ARENAS))).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("Video memory (GPU): %F MiB"), FMT_FLOAT((f64)vram.local_used / 1024 / 1024)).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("Video memory (shared): %F MiB"), FMT_FLOAT((f64)vram.non_local_used / 1024 / 1024)).len; //text.len += string_copy(temp.arena, LIT("\n")).len; //text.len += string_copy(temp.arena, LIT("\n")).len; #if RTC text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_copy(temp.arena, LIT("\n")).len; text.len += string_format(temp.arena, LIT("Debug steps: %F"), FMT_UINT(gstat_get(GSTAT_DEBUG_STEPS))).len; //text.len += string_copy(temp.arena, LIT("\n")).len; #endif //draw_text(G.render_sig, font, pos, string_format(temp.arena, LIT("blended world entities: %F/%F"), FMT_UINT(G.ss_blended->num_ents_allocated), FMT_UINT(G.ss_blended->num_ents_reserved))); //draw_text(G.render_sig, font, pos, text); struct v2 pos = V2(10, G.ui_size.y); enum draw_text_offset_y offset_y = DRAW_TEXT_OFFSET_Y_BOTTOM; draw_text(G.render_sig, DRAW_TEXT_PARAMS(.font = font, .pos = pos, .str = text, .offset_y = offset_y, .color = COLOR_WHITE)); arena_temp_end(temp); } } { #if DEVELOPER b32 console_minimized = !G.debug_console; i32 console_level = console_minimized ? LOG_LEVEL_SUCCESS: LOG_LEVEL_DEBUG; draw_debug_console(console_level, console_minimized); #else if (G.debug_draw) { draw_debug_console(LOG_LEVEL_INFO, 0); } #endif } /* ========================== * * Render * ========================== */ { __profn("Render"); struct v2i32 world_resolution = v2_round_to_int(G.render_size); struct v2i32 user_resolution = v2_round_to_int(G.ui_size); struct v2i32 backbuffer_resolution = v2_round_to_int(G.screen_size); /* Draw world to user texture */ struct gp_resource *render_texture = 0; { struct gp_render_params params = ZI; params.ui_size = user_resolution; params.render_size = world_resolution; params.world_to_render_xf = G.world_to_render_xf; params.render_to_ui_xf = G.render_to_ui_xf; params.effects_disabled = effects_disabled; render_texture = gp_run_render(G.render_sig, params); } /* Present */ gp_present(G.swapchain, backbuffer_resolution, render_texture, G.ui_to_screen_xf, VSYNC); } /* ========================== * * End frame cache scopes * ========================== */ sprite_scope_end(sprite_frame_scope); scratch_end(scratch); } INTERNAL SYS_JOB_DEF(user_update_job, _) { (UNUSED)_; i64 time_ns = sys_time_ns(); while (!atomic32_fetch(&G.shutdown)) { struct sys_window *window = G.window; { __profn("User sleep"); { __profn("Swapchain wait"); gp_swapchain_wait(G.swapchain); } { __profn("Frame limiter wait"); sys_sleep_frame(time_ns, 1000000000 / FPS_LIMIT); time_ns = sys_time_ns(); } } user_update(window); } } /* ========================== * * Local sim thread * ========================== */ INTERNAL void generate_user_input_cmds(struct sim_client *user_input_client, u64 tick) { struct sim_snapshot *prev_user_input_ss = sim_snapshot_from_tick(user_input_client, user_input_client->last_tick); struct sim_snapshot *user_input_ss = sim_snapshot_alloc(user_input_client, prev_user_input_ss, tick); struct sim_ent *user_input_root = sim_ent_from_id(user_input_ss, SIM_ENT_ROOT_ID); /* Find / create local control cmd ent */ struct sim_ent *control_cmd = sim_ent_find_first_match_one(user_input_ss, SEPROP_CMD); if (!control_cmd->valid) { control_cmd = sim_ent_alloc_sync_src(user_input_root); control_cmd->cmd_kind = SIM_CMD_KIND_CONTROL; control_cmd->predictor = user_input_client->player_id; sim_ent_enable_prop(control_cmd, SEPROP_CMD); sim_ent_activate(control_cmd, user_input_ss->tick); } { struct snc_lock lock = snc_lock_e(&G.user_sim_cmd_mutex); /* Update control cmd */ { control_cmd->cmd_control = G.user_sim_cmd_control; control_cmd->cmd_control_hovered_ent = G.user_hovered_ent; } #if 0 /* Create chat cmd */ if (G.user_sim_cmd_chat.len > 0) { struct sim_ent *chat_cmd = sim_ent_alloc_sync_src(user_input_root); chat_cmd->cmd_kind = SIM_CMD_KIND_CHAT; //chat_cmd->chat_msg = ZI } #endif ++G.user_sim_cmd_gen; snc_unlock(&lock); } } struct sim_ss_decode_node { struct sim_client *client; u64 tick; u64 base_tick; struct string tmp_encoded; struct sim_ss_decode_node *next; }; struct sim_decode_queue { struct sim_ss_decode_node *first; struct sim_ss_decode_node *last; }; INTERNAL SYS_JOB_DEF(local_sim_job, _) { (UNUSED)_; #if 0 struct host_listen_address local_listen_addr = host_listen_address_from_local_name(LIT("LOCAL_SIM")); struct host_listen_address net_listen_addr = host_listen_address_from_net_port(12345); //struct host *host = host_alloc(); /* TODO: Host system should allocate & copy string stored in local_listen_addr */ //host_listen(host, local_listen_addr); //host_listen(host, net_listen_addr); #endif b32 is_master = 0; struct host *host; if (G.connect_address_str.len > 0) { host = host_alloc(0); struct sys_address addr = sys_address_from_string(G.connect_address_str); host_queue_connect_to_address(host, addr); } else { host = host_alloc(12345); is_master = 1; } struct bitbuff msg_writer_bb = bitbuff_alloc(GIBI(64)); struct bitbuff snapshot_writer_bb = bitbuff_alloc(GIBI(64)); struct sim_accel accel = sim_accel_alloc(); struct sim_client_store *store = sim_client_store_alloc(); struct sim_client *user_input_client = sim_client_alloc(store); /* Stores snapshots containing commands to be published to local client */ struct sim_client *local_client = sim_client_alloc(store); /* Stores snapshots produced locally */ struct sim_client *publish_client = sim_client_alloc(store); /* Stores versions of local snapshots that will be published to remote sims */ struct sim_client *master_client = sim_client_nil(); /* Stores snapshots received from master */ struct sim_client *master_blended_client = sim_client_nil(); /* Stores interpolated master snapshots */ b32 initialized_from_master = 0; i64 master_blend_time_ns = 0; i64 average_master_receive_dt_ns = 0; i64 last_tick_from_master_received_at_ns = 0; i64 last_publish_to_user_ns = 0; i64 real_time_ns = 0; i64 real_dt_ns = 0; i64 step_dt_ns = NS_FROM_SECONDS(1) / SIM_TICKS_PER_SECOND; f64 compute_timescale = 1.0; while (!atomic32_fetch(&G.shutdown)) { struct arena_temp scratch = scratch_begin_no_conflict(); { __profn("Sim sleep"); sys_sleep_frame(real_time_ns, step_dt_ns * compute_timescale); } { __profn("Sim update"); real_dt_ns = sys_time_ns() - real_time_ns; real_time_ns += real_dt_ns; struct host_event_list host_events = host_update_begin(scratch.arena, host); /* Read net messages */ struct sim_decode_queue queue = ZI; { for (struct host_event *event = host_events.first; event; event = event->next) { struct host_channel_id channel_id = event->channel_id; struct sim_client *client = sim_client_from_channel_id(store, channel_id); switch (event->kind) { case HOST_EVENT_KIND_CHANNEL_OPENED: { if (!client->valid) { if (is_master) { /* Create remote client */ client = sim_client_alloc(store); sim_client_set_channel_id(client, channel_id); } else { /* Create master client */ if (!master_client->valid) { client = sim_client_alloc(store); sim_client_set_channel_id(client, channel_id); master_client = client; master_blended_client = sim_client_alloc(store); } else { /* We already have a master client */ ASSERT(0); } } } } break; case HOST_EVENT_KIND_MSG: { if (client->valid) { struct bitbuff msg_bb = bitbuff_from_string(event->msg); struct bitbuff_reader msg_br = br_from_bitbuff(&msg_bb); u64 ack = br_read_uv(&msg_br); u64 double_ack = br_read_uv(&msg_br); if (ack > client->ack) { client->ack = ack; } if (double_ack > client->double_ack) { client->double_ack = double_ack; } /* Read & queue incoming snapshots for decoding */ u64 tmp_encoded_len = br_read_uv(&msg_br); while (tmp_encoded_len > 0) { u8 *tmp_encoded_bytes = br_read_bytes_raw(&msg_br, tmp_encoded_len); if (!tmp_encoded_bytes) break; struct bitbuff decoder_bb = bitbuff_from_string(STRING(tmp_encoded_len, tmp_encoded_bytes)); struct bitbuff_reader decoder_br = br_from_bitbuff(&decoder_bb); u64 base_tick = br_read_uv(&decoder_br); u64 tick = br_read_uv(&decoder_br); struct string tmp_encoded = ZI; tmp_encoded.len = br_num_bytes_left(&decoder_br); tmp_encoded.text = br_read_bytes_raw(&decoder_br, tmp_encoded.len); if (!tmp_encoded.text) tmp_encoded.len = 0; struct sim_snapshot *base_ss = sim_snapshot_from_tick(client, base_tick); if (base_ss->tick == base_tick) { if (is_master) { /* Queue incoming slave client snapshot for decoding */ //b32 should_decode = tick == client->highest_received_tick + 1 || client->highest_received_tick == 0; b32 should_decode = tick > client->highest_received_tick; if (should_decode) { struct sim_ss_decode_node *node = arena_push(scratch.arena, struct sim_ss_decode_node); node->client = client; node->tick = tick; node->base_tick = base_tick; node->tmp_encoded = tmp_encoded; if (queue.last) { queue.last->next = node; } else { queue.first = node; } queue.last = node; if (tick > client->highest_received_tick) { client->highest_received_tick = tick; } } } else { /* Decode incoming master client snapshots for decoding (only the newest one) */ b32 should_decode = client == master_client && tick > client->highest_received_tick; if (should_decode) { struct sim_ss_decode_node *node = queue.first ? queue.first : arena_push(scratch.arena, struct sim_ss_decode_node); node->client = client; node->tick = tick; node->base_tick = base_tick; node->tmp_encoded = tmp_encoded; queue.first = node; queue.last = node; if (tick > client->highest_received_tick) { client->highest_received_tick = tick; if (average_master_receive_dt_ns == 0) { average_master_receive_dt_ns = NS_FROM_SECONDS(1) / SIM_TICKS_PER_SECOND; } else { average_master_receive_dt_ns -= average_master_receive_dt_ns / 50; average_master_receive_dt_ns += (real_time_ns - last_tick_from_master_received_at_ns) / 50; } last_tick_from_master_received_at_ns = real_time_ns; } } } } else { /* We do not have the tick that the incoming delta is based from */ ASSERT(0); } tmp_encoded_len = br_read_uv(&msg_br); } } } break; default: break; } } } /* Decode incoming snapshots */ for (struct sim_ss_decode_node *n = queue.first; n; n = n->next) { struct sim_client *client = n->client; u64 base_tick = n->base_tick; u64 tick = n->tick; struct sim_snapshot *base_ss = sim_snapshot_from_tick(client, base_tick); if (base_ss->tick == base_tick) { struct bitbuff bb = bitbuff_from_string(n->tmp_encoded); struct bitbuff_reader br = br_from_bitbuff(&bb); /* Alloc & decode snapshot */ struct sim_snapshot *ss = sim_snapshot_alloc(client, base_ss, tick); sim_snapshot_decode(&br, ss); /* Assume all incoming ents want to be sync srcs */ for (u64 i = 0; i < ss->num_ents_reserved; ++i) { struct sim_ent *ent = &ss->ents[i]; if (ent->valid && sim_ent_has_prop(ent, SEPROP_SYNC_DST)) { sim_ent_disable_prop(ent, SEPROP_SYNC_DST); sim_ent_enable_prop(ent, SEPROP_SYNC_SRC); } } } else { /* We do not have the tick that the incoming delta is based from. * This decode should never have been queued in the first place. */ ASSERT(0); } } if (!is_master && !initialized_from_master) { if (master_client->valid && master_client->last_tick > 0) { initialized_from_master = 1; } else { goto skip_step; } } b32 should_step = !atomic32_fetch(&G.user_paused); if (atomic32_fetch(&G.user_paused_steps) > 0) { should_step = 1; atomic32_fetch_add(&G.user_paused_steps, -1); } if (!should_step) { goto skip_step; } /* Update networked clients */ u64 oldest_client_ack = 0; for (u64 i = 0; i < store->num_clients_reserved; ++i) { struct sim_client *client = &store->clients[i]; if (client->valid && client != local_client && client != publish_client && client != user_input_client && client != master_client) { client->last_rtt_ns = host_get_channel_last_rtt_ns(host, client->channel_id); /* Release unneeded received snapshots */ /* TDOO: Cap how many client snapshots we're willing to retain */ if (client->double_ack > 0) { u64 keep_tick = min_u64(client->double_ack, local_client->last_tick); if (keep_tick > 0) { sim_snapshot_release_ticks_in_range(client, 0, keep_tick - 1); } } if (client->ack < oldest_client_ack || oldest_client_ack == 0) { oldest_client_ack = client->ack; } } } /* Release unneeded published snapshots */ { u64 keep_tick = oldest_client_ack; if (keep_tick == 0 && publish_client->last_tick > 0) { keep_tick = publish_client->last_tick - 1; } if (keep_tick > 0) { --keep_tick; } sim_snapshot_release_ticks_in_range(publish_client, 0, keep_tick); } /* Release old local snapshots */ { u64 keep_range = 50; if (local_client->last_tick > keep_range) { u64 keep_tick = local_client->last_tick - keep_range; sim_snapshot_release_ticks_in_range(local_client, 0, keep_tick); } } /* Release unneeded user input snapshots */ sim_snapshot_release_ticks_in_range(user_input_client, 0, local_client->first_tick - 1); if (is_master) { /* Step master */ u64 prev_tick = local_client->last_tick; u64 next_tick = prev_tick + 1; struct sim_step_ctx ctx = ZI; ctx.is_master = is_master; ctx.sim_dt_ns = step_dt_ns; ctx.accel = &accel; ctx.user_input_client = user_input_client; ctx.master_client = master_client; ctx.publish_client = publish_client; struct sim_snapshot *prev_world = sim_snapshot_from_tick(local_client, prev_tick); ctx.world = sim_snapshot_alloc(local_client, prev_world, next_tick); generate_user_input_cmds(user_input_client, next_tick); sim_step(&ctx); } else if (master_client->valid) { /* Step client */ /* TODO: Eventually determine master tick based on a delay to allow for jitter and also interpolation so we can lower snapshot publish frequency */ b32 master_ss_is_blended = 0; struct sim_snapshot *master_ss = sim_snapshot_nil(); { /* How along are we between master sim ticks (0 = start of tick, 1 = end of tick) */ f64 tick_progress = 0; i64 next_tick_expected_ns = last_tick_from_master_received_at_ns + average_master_receive_dt_ns; if (next_tick_expected_ns > last_tick_from_master_received_at_ns) { tick_progress = (f64)(real_time_ns - last_tick_from_master_received_at_ns) / (f64)(next_tick_expected_ns - last_tick_from_master_received_at_ns); } /* Predict master sim time based on average snapshot publish dt. */ struct sim_snapshot *newest_snapshot = sim_snapshot_from_tick(master_client, master_client->last_tick); i64 master_sim_predicted_time_ns = newest_snapshot->sim_time_ns + (newest_snapshot->sim_dt_ns * tick_progress); /* Determine blend time */ i64 master_blend_time_target_ns = master_sim_predicted_time_ns - (SIM_CLIENT_INTERP_RATIO * average_master_receive_dt_ns); if (average_master_receive_dt_ns > 0) { master_blend_time_ns += real_dt_ns; } i64 blend_time_target_diff_ns = master_blend_time_target_ns - master_blend_time_ns; if (blend_time_target_diff_ns > NS_FROM_SECONDS(0.100) || blend_time_target_diff_ns < NS_FROM_SECONDS(-0.100)) { /* Snap blend time if it gets too far from target blend time */ master_blend_time_ns = master_blend_time_target_ns; } u64 master_blend_tick = master_blend_time_ns / newest_snapshot->sim_dt_ns; /* Get snapshot nearest to master blend time */ /* TODO: Blend */ struct sim_snapshot *left_snapshot = sim_snapshot_nil(); struct sim_snapshot *right_snapshot = newest_snapshot; { struct sim_snapshot *ss = sim_snapshot_from_tick(master_client, master_client->first_tick); while (ss->valid) { u64 next_tick = ss->next_tick; i64 ss_time_ns = ss->sim_time_ns; if (ss_time_ns < master_blend_time_ns && ss_time_ns > left_snapshot->sim_time_ns) { left_snapshot = ss; } if (ss_time_ns > master_blend_time_ns && ss_time_ns < right_snapshot->sim_time_ns) { right_snapshot = ss; } ss = sim_snapshot_from_tick(master_client, next_tick); } } /* Create world from blended master snapshots */ f64 blend = 0; if (left_snapshot->valid && right_snapshot->valid && right_snapshot->tick > left_snapshot->tick) { blend = (f64)(master_blend_tick - left_snapshot->tick) / (f64)(right_snapshot->tick - left_snapshot->tick); f64 epsilon = 0.001; if (blend < epsilon) { master_ss_is_blended = 0; master_ss = left_snapshot; } else if (blend > 1 - epsilon) { master_ss_is_blended = 0; master_ss = right_snapshot; } else { master_ss_is_blended = 1; master_ss = sim_snapshot_alloc_from_lerp(master_blended_client, left_snapshot, right_snapshot, blend); /* Release unneeded blended master snapshots */ if (master_ss->tick > 0) { sim_snapshot_release_ticks_in_range(master_blended_client, 0, master_ss->tick - 1); sim_snapshot_release_ticks_in_range(master_blended_client, master_ss->tick + 1, U64_MAX); } } } else { master_ss_is_blended = 0; master_ss = left_snapshot->valid ? left_snapshot : right_snapshot; } /* Release unneeded master snapshots */ u64 keep_master_tick = min_u64(left_snapshot->tick, master_client->double_ack); if (keep_master_tick > 0) { sim_snapshot_release_ticks_in_range(master_client, 0, keep_master_tick - 1); } #if 0 DEBUGBREAKABLE; logf_debug("*************************************************"); logf_debug("local_client->last_tick: %F", FMT_UINT(local_client->last_tick)); logf_debug("master_sim_predicted_time_ns: %F", FMT_SINT(master_sim_predicted_time_ns)); logf_debug("tick_progress: %F", FMT_FLOAT(tick_progress)); logf_debug("sim_publish_timescale: %F", FMT_FLOAT(sim_publish_timescale)); logf_debug("last_tick_from_master_received_at_ns: %F", FMT_SINT(last_tick_from_master_received_at_ns)); logf_debug("average_master_receive_dt_ns: %F", FMT_SINT(average_master_receive_dt_ns)); logf_debug("next_tick_expected_ns: %F", FMT_SINT(next_tick_expected_ns)); logf_debug("master_blend_time_target_ns: %F", FMT_SINT(master_blend_time_target_ns)); logf_debug("blend_time_target_diff_ns: %F", FMT_SINT(blend_time_target_diff_ns)); logf_debug("master_blend_time_ns: %F", FMT_SINT(master_blend_time_ns)); logf_debug("left_snapshot->tick: %F", FMT_UINT(left_snapshot->tick)); logf_debug("right_snapshot->tick: %F", FMT_UINT(right_snapshot->tick)); logf_debug("master_ss->tick: %F", FMT_UINT(master_ss->tick)); #endif } if (master_ss->valid) { struct sim_ent *master_player = sim_ent_find_first_match_one(master_ss, SEPROP_PLAYER_IS_MASTER); /* Update ent id from master */ { user_input_client->player_id = master_ss->local_player; local_client->player_id = master_ss->local_player; } /* Check for misprediction */ u64 mispredicted_tick = 0; if (!master_ss_is_blended) { /* TODO: Actually check for misprediction rather than triggering mispredict any time a new master snapshot is received */ mispredicted_tick = master_ss->tick; } u64 step_base_tick = local_client->last_tick; u64 step_end_tick = step_base_tick + 1; if (mispredicted_tick > 0) { step_base_tick = mispredicted_tick; if (step_end_tick <= step_base_tick) { step_end_tick = step_base_tick + 1; } } /* We want to simulate the ahead of the server to predict client input. * How many ticks ahead we want to simulate is a balance between added latency and the server not receiving our inputs on time. * We can take the server's ack minus the server's tick to determine how many cmds of ours the server has buffered. * * If this buffer gets too low (because we are lagging behind or the connection is unstable), meaning the server is not getting our input on time: * - Shorten local compute rate to increase the rate at which we predict ahead & produce cmds, until the server's ack indicates a buffer size within desired range. * * If this buffer gets too large (because the client predicts too far ahead), meaning unneeded latency is being introduced: * - Dilate local compute rate to decrease the rate at which we predict ahead & produce cmds until the server's ack indicates a buffer size within desired range. */ { i64 cmds_ahead_on_master = (i64)master_client->ack - (i64)master_client->last_tick; if (cmds_ahead_on_master < -3 || cmds_ahead_on_master > 10) { /* Cmds are too far from master time, snap step end tick */ i64 rtt_ns = master_client->last_rtt_ns; f64 rtt_tick_ratio = (f64)(rtt_ns + (step_dt_ns - 1)) / (f64)step_dt_ns; i64 num_predict_ticks = math_round_to_int64(rtt_tick_ratio) + 5; step_end_tick = master_client->last_tick + num_predict_ticks; compute_timescale = 1.1; } else if (cmds_ahead_on_master > 2) { /* Slow down simulation to dial back how far ahead we are predicting and bring local sim time closer to master sim time */ compute_timescale = 1.1; } else if (cmds_ahead_on_master < 1) { /* Speed up simulation rate predict more ticks and give master more inputs to work with */ compute_timescale = 0.9; } else { /* Server's cmd buffer is in a healthy range */ compute_timescale = 1; } } /* Sync master with local base tick */ struct sim_snapshot *base_ss = sim_snapshot_from_tick(local_client, step_base_tick); if (mispredicted_tick) { if (base_ss->valid) { sim_snapshot_sync_ents(base_ss, master_ss, master_player->id, 0); } else { base_ss = sim_snapshot_alloc(local_client, master_ss, step_base_tick); } } /* Release any existing ticks that are about to be simulated */ sim_snapshot_release_ticks_in_range(local_client, step_base_tick + 1, U64_MAX); /* Step */ generate_user_input_cmds(user_input_client, step_end_tick); { struct sim_step_ctx ctx = ZI; ctx.is_master = is_master; ctx.sim_dt_ns = step_dt_ns; ctx.accel = &accel; ctx.user_input_client = user_input_client; ctx.master_client = master_client; ctx.publish_client = publish_client; u64 step_tick = step_base_tick + 1; struct sim_snapshot *prev_ss = base_ss; while (step_tick <= step_end_tick) { ctx.world = sim_snapshot_alloc(local_client, prev_ss, step_tick); if (!mispredicted_tick && step_tick == step_end_tick) { sim_snapshot_sync_ents(ctx.world, master_ss, master_player->id, SIM_SYNC_FLAG_NOSYNC_PREDICTABLES); } sim_step(&ctx); prev_ss = ctx.world; ++step_tick; } } } } /* Publish snapshot to remote clients */ for (u64 i = 0; i < store->num_clients_reserved; ++i) { struct sim_client *client = &store->clients[i]; if (client->valid && client != user_input_client && client != local_client && client != publish_client) { struct bitbuff_writer msg_bw = bw_from_bitbuff(&msg_writer_bb); bw_write_uv(&msg_bw, client->highest_received_tick); /* ack */ bw_write_uv(&msg_bw, client->ack); /* double ack */ struct sim_snapshot *base_ss = sim_snapshot_from_tick(publish_client, client->ack); struct sim_snapshot *publish_ss; if (client == master_client) { /* If sending to master, start sending all snapshots since last ack */ publish_ss = sim_snapshot_from_closest_tick_gte(publish_client, base_ss->tick + 1); } else { /* If sending to slave, only send latest snapshot */ publish_ss = sim_snapshot_from_tick(publish_client, publish_client->last_tick); } while (publish_ss->valid) { struct bitbuff_writer snapshot_bw = bw_from_bitbuff(&snapshot_writer_bb); struct string tmp_snapshot_encoded = ZI; { bw_write_uv(&snapshot_bw, base_ss->tick); bw_write_uv(&snapshot_bw, publish_ss->tick); sim_snapshot_encode(&snapshot_bw, client, base_ss, publish_ss); tmp_snapshot_encoded.len = bw_num_bytes_written(&snapshot_bw); tmp_snapshot_encoded.text = bw_get_written_raw(&snapshot_bw); } bw_write_uv(&msg_bw, tmp_snapshot_encoded.len); bw_write_bytes(&msg_bw, tmp_snapshot_encoded); publish_ss = sim_snapshot_from_tick(publish_client, publish_ss->tick + 1); } bw_write_uv(&msg_bw, 0); struct string encoded = ZI; encoded.len = bw_num_bytes_written(&msg_bw); encoded.text = bw_get_written_raw(&msg_bw); host_queue_write(host, client->channel_id, encoded, 0); } } /* Copy local snapshot to user client */ { struct sim_snapshot *local_ss = sim_snapshot_from_tick(local_client, local_client->last_tick); if (local_ss->valid) { /* TODO: Double buffer */ struct snc_lock lock = snc_lock_e(&G.local_to_user_client_mutex); sim_snapshot_alloc(G.local_to_user_client, local_ss, local_ss->tick); i64 publish_ns = sys_time_ns(); if (last_publish_to_user_ns == 0) { last_publish_to_user_ns = publish_ns - G.average_local_to_user_snapshot_publish_dt_ns; } G.local_to_user_client_publish_dt_ns = publish_ns - last_publish_to_user_ns; G.local_to_user_client_publish_time_ns = publish_ns; last_publish_to_user_ns = publish_ns; sim_snapshot_release_ticks_in_range(G.local_to_user_client, 0, local_ss->tick - 1); snc_unlock(&lock); } } skip_step: /* Send host messages */ host_update_end(host); __profframe("Local sim"); scratch_end(scratch); } } sim_client_store_release(store); sim_accel_release(&accel); bitbuff_release(&snapshot_writer_bb); bitbuff_release(&msg_writer_bb); host_release(host); }