jacob/power_play
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
638b459b08
power_play/src/pp/pp.c

3097 lines
128 KiB
C
Raw Blame History

PP_SharedUserState PP_shared_user_state = ZI;
////////////////////////////////////////////////////////////
//~ Startup
void PP_StartupUser(void)
{
__prof;
PP_SharedUserState *g = &PP_shared_user_state;
SetGstat(GSTAT_DEBUG_STEPS, U64Max);
Arena *perm = PermArena();
g->real_time_ns = TimeNs();
/* TODO: Remove this */
String connect_address_str = Lit("");
g->connect_address_str = PushString(perm, connect_address_str);
/* Initialize average dt to a reasonable value */
g->average_local_to_user_snapshot_publish_dt_ns = NsFromSeconds(1) / SIM_TICKS_PER_SECOND;
/* User blend clients */
g->user_client_store = PP_AcquireClientStore();
g->user_unblended_client = PP_AcquireClient(g->user_client_store);
g->user_blended_client = PP_AcquireClient(g->user_client_store);
g->ss_blended = PP_NilSnapshot();
/* Local to user client */
g->local_to_user_client_store = PP_AcquireClientStore();
g->local_to_user_client = PP_AcquireClient(g->local_to_user_client_store);
/* Init from swap */
if (IsSwappedIn());
{
TempArena scratch = BeginScratchNoConflict();
String swap_encoded = SwappedStateFromName(scratch.arena, Lit("pp_user"));
BB_Buff bb = BB_BuffFromString(swap_encoded);
BB_Reader br = BB_ReaderFromBuff(&bb);
String swap_str = BB_ReadString(scratch.arena, &br);
g->window_restore = BB_ReadString(perm, &br);
if (swap_str.len == sizeof(PP_SwappedUserState))
{
PP_SwappedUserState *swap = PushStructNoZero(scratch.arena, PP_SwappedUserState);
CopyBytes(swap, swap_str.text, swap_str.len);
PP_SharedUserState *old = &swap->s;
CopyStructRegion(g, old, AUTO_PERSIST_START, AUTO_PERSIST_END);
}
EndScratch(scratch);
}
/* Create job pools */
JobPoolId user_pool = InitJobPool(1, Lit("User"), JobPoolPriority_Graphics);
JobPoolId sim_pool = InitJobPool(1, Lit("Simulation"), JobPoolPriority_Simulation);
/* Start jobs */
g->shutdown_jobs_count += RunJob(PP_UpdateUserOrSleep, .pool = user_pool, .fence = &g->shutdown_jobs_fence);
g->shutdown_jobs_count += RunJob(PP_UpdateSim, .pool = sim_pool, .fence = &g->shutdown_jobs_fence);
OnExit(&PP_ShutdownUser);
}
////////////////////////////////////////////////////////////
//~ Shutdown
ExitFuncDef(PP_ShutdownUser)
{
__prof;
PP_SharedUserState *g = &PP_shared_user_state;
Atomic32Set(&g->shutdown, 1);
YieldOnFence(&g->shutdown_jobs_fence, g->shutdown_jobs_count);
/* Swap out */
if (IsSwappingOut())
{
TempArena scratch = BeginScratchNoConflict();
u64 max_size = Mebi(16);
u8 *bytes = PushStructsNoZero(scratch.arena, u8, max_size);
BB_Buff bb = BB_BuffFromString(STRING(max_size, bytes));
{
BB_Writer bw = BB_WriterFromBuff(&bb);
PP_SwappedUserState *swap = PushStruct(scratch.arena, PP_SwappedUserState);
swap->s = *g;
BB_WriteString(&bw, StringFromStruct(swap));
BB_WriteString(&bw, g->window_restore);
WriteSwappedState(Lit("pp_user"), STRING(BB_GetNumBytesWritten(&bw), BB_GetWrittenRaw(&bw)));
}
EndScratch(scratch);
}
}
////////////////////////////////////////////////////////////
//~ Ui helpers
//- Ui style
void PP_PushGameUiStyle(void)
{
// UI_Push(FontSize, 48);
// UI_Push(FontSize, 32);
// UI_Push(Font, ResourceKeyFromStore(&PP_Resources, Lit("font/roboto-med.ttf")));
UI_Push(Font, ResourceKeyFromStore(&PP_Resources, Lit("font/fixedsys.ttf")));
UI_Push(FontSize, 16);
UI_Push(Rounding, UI_RPIX(0));
UI_Push(Border, 1);
// UI_Push(BackgroundColor, Rgba32F(0.3, 0.5, 0.3, 0.3));
UI_Push(BackgroundColor, Rgba32F(0.3, 0.3, 0.3, 1));
UI_Push(BorderColor, Rgba32F(0.6, 0.6, 0.6, 1));
UI_Push(Width, UI_FILL(1, 0));
UI_Push(Height, UI_FILL(1, 0));
UI_Push(LayoutAxis, Axis_Y);
}
//- Draw xform
void PP_DrawDebugXform(Xform xf, u32 color_x, u32 color_y)
{
PP_SharedUserState *g = &PP_shared_user_state;
f32 thickness = 2.f;
f32 arrowhead_len = 15.f;
Vec2 pos = MulXformV2(g->world_to_ui_xf, xf.og);
Vec2 x_ray = MulXformBasisV2(g->world_to_ui_xf, RightFromXform(xf));
Vec2 y_ray = MulXformBasisV2(g->world_to_ui_xf, UpFromXform(xf));
f32 ray_scale = 1;
x_ray = MulVec2(x_ray, ray_scale);
y_ray = MulVec2(y_ray, ray_scale);
/* FIXME: Enable this */
#if 0
D_DrawArrowRay(g->render_sig, pos, x_ray, thickness, arrowhead_len, color_x);
D_DrawArrowRay(g->render_sig, pos, y_ray, thickness, arrowhead_len, color_y);
#else
LAX x_ray;
LAX y_ray;
LAX thickness;
LAX arrowhead_len;
LAX pos;
LAX color_x;
LAX color_y;
#endif
//u32 color_quad = Rgba32F(0, 1, 1, 0.3);
//Quad quad = QuadFromRect(RectFromScalar(0, 0, 1, -1));
//quad = MulXformQuad(xf, ScaleQuad(quad, 0.075f));
//D_DrawQuad(g->render_sig, quad, color);
}
//- Draw movement
void PP_DrawDebugMovement(PP_Ent *ent)
{
PP_SharedUserState *g = &PP_shared_user_state;
f32 thickness = 2.f;
f32 arrow_len = 15.f;
u32 color_vel = Color_Orange;
Xform xf = PP_XformFromEnt(ent);
Vec2 velocity = ent->linear_velocity;
Vec2 pos = MulXformV2(g->world_to_ui_xf, xf.og);
Vec2 vel_ray = MulXformBasisV2(g->world_to_ui_xf, velocity);
if (Vec2Len(vel_ray) > 0.00001)
{
/* FIXME: Enable this */
#if 0
D_DrawArrowRay(g->render_sig, pos, vel_ray, thickness, arrow_len, color_vel);
#else
LAX thickness;
LAX arrow_len;
LAX color_vel;
LAX xf;
LAX velocity;
LAX pos;
LAX vel_ray;
#endif
}
}
//- Ent debug string
String PP_DebugStringFromEnt(Arena *arena, PP_Ent *ent)
{
TempArena scratch = BeginScratch(arena);
PP_Snapshot *ss = ent->ss;
const u8 hex[] = "0123456789abcdef";
String result = ZI;
result.text = PushDry(arena, u8);
//result.len += StringF(arena, "[%F]", FmtUid(ent->key.uid)).len;
{
b32 transmitting = PP_HasProp(ent, PP_Prop_SyncSrc);
b32 receiving = PP_HasProp(ent, PP_Prop_SyncDst);
if (transmitting & receiving)
{
result.len += StringF(arena, " networked (sending & receiving)").len;
}
else if (transmitting)
{
result.len += StringF(arena, " networked (sending)").len;
}
else if (receiving)
{
result.len += StringF(arena, " networked (receiving)").len;
}
else
{
result.len += StringF(arena, " local").len;
}
}
result.len += StringF(arena, "\n").len;
result.len += StringF(arena, "owner: [%F]\n", FmtUid(ent->owner.uid)).len;
result.len += StringF(arena, "\n").len;
{
result.len += StringF(arena, "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)) <= PP_Prop_Count)
{
u8 part = (chunk >> (part_index * 8)) & 0xFF;
StringFromChar(arena, hex[(part >> 4) & 0x0F]);
StringFromChar(arena, hex[(part >> 0) & 0x0F]);
result.len += 2;
}
}
}
result.len += StringF(arena, "\n").len;
}
if (!PP_EqEntKey(ent->parent, PP_RootEntKey))
{
result.len += StringF(arena, "parent: [%F]\n", FmtUid(ent->parent.uid)).len;
}
if (!PP_IsNilEntKey(ent->next) || !PP_IsNilEntKey(ent->prev))
{
result.len += StringF(arena, "prev: [%F]\n", FmtUid(ent->prev.uid)).len;
result.len += StringF(arena, "next: [%F]\n", FmtUid(ent->next.uid)).len;
}
result.len += StringF(arena, "\n").len;
/* Pos */
Xform xf = PP_XformFromEnt(ent);
Vec2 linear_velocity = ent->linear_velocity;
f32 angular_velocity = ent->angular_velocity;
result.len += StringF(arena, "pos: (%F, %F)\n", FmtFloat(xf.og.x), FmtFloat(xf.og.y)).len;
result.len += StringF(arena, "linear velocity: (%F, %F)\n", FmtFloat(linear_velocity.x), FmtFloat(linear_velocity.y)).len;
result.len += StringF(arena, "angular velocity: %F\n", FmtFloat(angular_velocity)).len;
/* Test */
result.len += StringF(arena, "collision dir: (%F, %F)\n", FmtFloat(ent->collision_dir.x), FmtFloat(ent->collision_dir.y)).len;
/* Children */
if (!PP_IsNilEntKey(ent->first) || !PP_IsNilEntKey(ent->last))
{
PP_Ent *child = PP_EntFromKey(ss, ent->first);
if (!PP_EqEntKey(ent->first, ent->last) || !child->valid)
{
result.len += StringF(arena, "first child: [%F]\n", FmtUid(ent->first.uid)).len;
result.len += StringF(arena, "last child: [%F]\n", FmtUid(ent->last.uid)).len;
}
while (child->valid)
{
result.len += StringF(arena, "\n---------------------------------\n").len;
result.len += StringF(arena, "CHILD\n").len;
String child_text = PP_DebugStringFromEnt(scratch.arena, child);
result.len += IndentString(arena, child_text, 4).len;
child = PP_EntFromKey(ss, child->next);
}
}
EndScratch(scratch);
return result;
}
////////////////////////////////////////////////////////////
//~ Render buffers
//- Gbuffer
GPU_Resource *PP_AcquireGbuffer(GPU_Format format, Vec2I32 size)
{
__prof;
GPU_ResourceDesc desc = ZI;
desc.kind = GPU_ResourceKind_Texture2D;
desc.flags = GPU_ResourceFlag_Writable | GPU_ResourceFlag_Renderable;
desc.texture.format = format;
desc.texture.size = VEC3I32(size.x, size.y, 1);
return GPU_AcquireResource(desc);
}
////////////////////////////////////////////////////////////
//~ Sort entities
MergesortCompareFuncDef(PP_EntSortCmp, arg_a, arg_b, _)
{
PP_Ent *a = *(PP_Ent **)arg_a;
PP_Ent *b = *(PP_Ent **)arg_b;
i32 result = 0;
if (result == 0)
{
/* Sort by light */
b32 a_cmp = PP_HasProp(a, PP_Prop_LightTest);
b32 b_cmp = PP_HasProp(b, PP_Prop_LightTest);
result = (a_cmp > b_cmp) - (a_cmp < b_cmp);
}
if (result == 0)
{
/* Sort by layer */
i32 a_cmp = a->layer;
i32 b_cmp = b->layer;
result = (a_cmp < b_cmp) - (a_cmp > b_cmp);
}
if (result == 0)
{
/* Sort by sprite */
u64 a_cmp = a->sprite.hash;
u64 b_cmp = b->sprite.hash;
result = (a_cmp < b_cmp) - (a_cmp > b_cmp);
}
if (result == 0)
{
/* Sort by activation */
u64 a_cmp = a->activation_tick;
u64 b_cmp = b->activation_tick;
result = (a_cmp < b_cmp) - (a_cmp > b_cmp);
}
return result;
}
////////////////////////////////////////////////////////////
//~ User update
void PP_UpdateUser(void)
{
__prof;
PP_SharedUserState *g = &PP_shared_user_state;
TempArena scratch = BeginScratchNoConflict();
//- Begin UI frame
UI_FrameFlag ui_frame_flags = 0;
if (g->ui_debug)
{
ui_frame_flags |= UI_FrameFlag_Debug;
}
UI_Frame ui_frame = UI_BeginFrame(ui_frame_flags);
WND_Frame window_frame = ui_frame.window_frame;
ControllerEventsArray controller_events = window_frame.controller_events;
g->real_dt_ns = TimeNs() - g->real_time_ns;
g->real_time_ns += g->real_dt_ns;
//- Restore window
if (g->user_tick == 0)
{
String restore = g->window_restore;
if (restore.len > 0)
{
WND_PushCmd(window_frame, .kind = WND_CmdKind_Restore, .restore = restore);
}
}
else
{
String src = window_frame.restore;
if (src.len > g->window_restore.len)
{
Arena *perm = PermArena();
g->window_restore = PushString(perm, src);
}
CopyBytes(g->window_restore.text, src.text, src.len);
g->window_restore.len = src.len;
}
g->screen_size = window_frame.draw_size;
g->screen_size.x = MaxI32(g->screen_size.x, 1);
g->screen_size.y = MaxI32(g->screen_size.y, 1);
//- Init render data buffers
if (!g->material_instances_arena)
{
g->material_instances_tbuff = GPU_AcquireTransientBuffer(GPU_QueueKind_Direct, sizeof(PP_MaterialInstance));
g->grids_tbuff = GPU_AcquireTransientBuffer(GPU_QueueKind_Direct, sizeof(PP_MaterialGrid));
g->material_instances_arena = AcquireArena(Gibi(64));
g->grids_arena = AcquireArena(Gibi(64));
}
//- Pull latest local sim snapshot
{
__profn("Pull snapshot");
Lock lock = LockE(&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)
{
PP_Snapshot *src = PP_SnapshotFromTick(g->local_to_user_client, last_tick);
PP_AcquireSnapshot(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;
}
Unlock(&lock);
}
//- Create user world from blended snapshots
{
__profn("Blend snapshots");
/* Determine how far 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. */
PP_Snapshot *newest_snapshot = PP_SnapshotFromTick(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 (Atomic32Fetch(&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 && !Atomic32Fetch(&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 > NsFromSeconds(0.010) || render_time_target_diff_ns < NsFromSeconds(-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 */
PP_Snapshot *left_snapshot = PP_NilSnapshot();
PP_Snapshot *right_snapshot = newest_snapshot;
{
PP_Snapshot *ss = PP_SnapshotFromTick(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 = PP_SnapshotFromTick(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 = PP_AcquireSnapshotFromLerp(g->user_blended_client, left_snapshot, right_snapshot, blend);
}
else if (left_snapshot->valid)
{
g->ss_blended = PP_AcquireSnapshot(g->user_blended_client, left_snapshot, left_snapshot->tick);
}
else if (right_snapshot->valid)
{
g->ss_blended = PP_AcquireSnapshot(g->user_blended_client, right_snapshot, right_snapshot->tick);
}
/* Release unneeded unblended snapshots */
if (left_snapshot->tick > 0)
{
PP_ReleaseSnapshotsInRange(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 = PP_AcquireSnapshot(g->user_blended_client, newest_snapshot, newest_snapshot->tick);
/* Release unneeded unblended snapshots */
if (newest_snapshot->tick > 0)
{
PP_ReleaseSnapshotsInRange(g->user_unblended_client, 0, newest_snapshot->tick - 1);
}
}
/* Release unneeded blended snapshots */
if (g->ss_blended->tick > 0)
{
PP_ReleaseSnapshotsInRange(g->user_blended_client, 0, g->ss_blended->tick - 1);
PP_ReleaseSnapshotsInRange(g->user_blended_client, g->ss_blended->tick + 1, U64Max);
}
}
//- Process controller events into user bind state
{
__profn("Process controller events");
/* Reset bind pressed / released states */
for (u32 i = 0; i < countof(g->bind_states); ++i)
{
g->bind_states[i] = (PP_BindState) {
.is_held = g->bind_states[i].is_held
};
}
for (u64 idx = 0; idx < controller_events.count; ++idx)
{
ControllerEvent *event = &controller_events.events[idx];
if (event->kind == ControllerEventKind_Quit)
{
SignalExit(0);
}
if (event->kind == ControllerEventKind_ButtonUp)
{
/* Escape quit */
if (event->button == Btn_Esc)
{
SignalExit(0);
}
}
/* Update mouse pos */
if (event->kind == ControllerEventKind_CursorMove)
{
g->screen_cursor = Vec2FromFields(event->cursor_pos);
}
/* Update bind states */
if ((event->kind == ControllerEventKind_ButtonDown || event->kind == ControllerEventKind_ButtonUp))
{
Btn button = event->button;
button = button >= Btn_Count ? Btn_None : button;
PP_BindKind bind = g_binds[button];
if (bind)
{
b32 pressed = event->kind == ControllerEventKind_ButtonDown;
#if 0
b32 out_of_bounds = button >= Btn_M1 && button <= 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
PP_Ent *local_player = PP_EntFromKey(g->ss_blended, g->ss_blended->local_player);
PP_Ent *local_control = PP_EntFromKey(g->ss_blended, local_player->player_control_ent);
PP_Ent *local_camera = PP_EntFromKey(g->ss_blended, local_player->player_camera_ent);
//- Find hovered entity
PP_Ent *hovered_ent = PP_NilEnt();
{
Xform mouse_xf = XformFromPos(g->world_cursor);
CLD_Shape mouse_shape = ZI;
mouse_shape.points[0] = VEC2(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)
{
PP_Ent *ent = &g->ss_blended->ents[ent_index];
if (!PP_IsValidAndActive(ent)) continue;
CLD_Shape ent_collider = ent->local_collider;
if (ent_collider.count > 0)
{
/* TODO: Can just use boolean GJK */
Xform ent_xf = PP_XformFromEnt(ent);
CLD_CollisionData collision_result = CLD_CollisionDataFromShapes(&ent_collider, &mouse_shape, ent_xf, mouse_xf);
if (collision_result.num_points > 0)
{
hovered_ent = PP_EntFromKey(g->ss_blended, ent->top);
break;
}
}
}
}
//- Update user state from binds
{
if (g->bind_states[PP_BindKind_Fullscreen].num_presses && g->bind_states[PP_BindKind_FullscreenMod].is_held)
{
WND_PushCmd(window_frame, .kind = WND_CmdKind_SetFullscreen, .v = !window_frame.fullscreen);
}
}
if (g->bind_states[PP_BindKind_DebugDraw].num_presses > 0)
{
g->debug_draw = !g->debug_draw;
}
if (g->bind_states[PP_BindKind_DebugToggleTopmost].num_presses > 0)
{
WND_PushCmd(window_frame, .kind = WND_CmdKind_SetForcedTop, .v = !window_frame.forced_top);
LogSuccessF("Toggle topmost");
}
if (g->bind_states[PP_BindKind_DebugConsole].num_presses > 0)
{
g->debug_console = !g->debug_console;
}
if (g->bind_states[PP_BindKind_DebugCamera].num_presses > 0)
{
g->debug_camera = !g->debug_camera;
}
if (g->bind_states[PP_BindKind_DebugUi].num_presses > 0)
{
g->ui_debug = !g->ui_debug;
}
if (g->bind_states[PP_BindKind_DebugLister].num_presses > 0)
{
g->lister_active = !g->lister_active;
}
{
if (g->bind_states[PP_BindKind_DebugFollow].num_presses > 0)
{
if (PP_IsNilEntKey(g->debug_following))
{
g->debug_following = hovered_ent->key;
}
else
{
g->debug_following = PP_NilEntKey;
}
}
if (!PP_IsNilEntKey(g->debug_following))
{
PP_Ent *follow_ent = PP_EntFromKey(g->ss_blended, g->debug_following);
PP_Ent *follow_camera = PP_NilEnt();
for (u64 i = 0; i < g->ss_blended->num_ents_reserved; ++i)
{
PP_Ent *ent = &g->ss_blended->ents[i];
PP_Ent *ent_camera_follow = PP_EntFromKey(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 = PP_NilEntKey;
}
}
}
//- Apply shake
for (u64 ent_index = 0; ent_index < g->ss_blended->num_ents_reserved; ++ent_index)
{
PP_Ent *ent = &g->ss_blended->ents[ent_index];
if (!PP_IsValidAndActive(ent)) continue;
/* How much time between camera shakes */
i64 frequency_ns = NsFromSeconds(0.01f);
f32 shake = ent->shake;
if (shake > 0)
{
u64 angle_seed0 = ent->key.uid.lo + (u64)(g->ss_blended->sim_time_ns / frequency_ns);
u64 angle_seed1 = angle_seed0 + 1;
f32 angle0 = RandF64FromSeed(angle_seed0, 0, Tau);
f32 angle1 = RandF64FromSeed(angle_seed1, 0, Tau);
Vec2 vec0 = Vec2WithLen(Vec2FromAngle(angle0), shake);
/* NOTE: vec1 not completely accurate since shake can change between frames, it's just a prediction */
Vec2 vec1 = Vec2WithLen(Vec2FromAngle(angle1), shake);
/* TODO: Cubic interp? */
f32 blend = (f32)(g->ss_blended->sim_time_ns % frequency_ns) / (f32)frequency_ns;
Vec2 vec = LerpVec2(vec0, vec1, blend);
Xform xf = PP_XformFromEnt(ent);
xf.og = AddVec2(xf.og, MulVec2(vec, shake));
PP_SetXform(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 = XformIdentity;
g->ui_to_screen_xf.og = RoundVec2(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)
{
Xform quad_xf = MulXform(PP_XformFromEnt(local_camera), local_camera->camera_quad_xform);
Vec2 camera_size = ScaleFromXform(quad_xf);
if (!IsVec2Zero(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 = CeilF32(width / aspect_ratio);
}
g->ui_size = VEC2I32(width, height);
/* Center ui in window */
f32 x = RoundF32(g->screen_size.x / 2 - width / 2);
f32 y = RoundF32(g->screen_size.y / 2 - height / 2);
g->ui_to_screen_xf = XformFromTrs(TRS(.t = VEC2(x, y)));
g->ui_to_screen_xf.og = RoundVec2(g->ui_to_screen_xf.og);
}
g->ui_cursor = MulXformV2(InvertXform(g->ui_to_screen_xf), g->screen_cursor);
//- Init pp root box
UI_Push(LayoutAxis, Axis_Y);
if (window_frame.forced_top)
{
UI_SetNext(Border, 10);
UI_SetNext(BorderColor, Rgba32F(1, 0, 0, 0.5));
}
UI_SetNext(Width, UI_PIX(g->ui_size.x, 1));
UI_SetNext(Height, UI_PIX(g->ui_size.y, 1));
UI_SetNext(Padding, UI_PADALL(UI_FILL(1, 0)));
UI_Box *pp_root_box = UI_BuildBox(Lit("pp root"));
PP_PushGameUiStyle();
UI_Push(Parent, pp_root_box);
//- Update world to ui xform from camera
if (g->debug_camera)
{
g->world_to_ui_xf = XformWithWorldRotation(g->world_to_ui_xf, 0);
Vec2 world_cursor = InvertXformMulV2(g->world_to_ui_xf, g->ui_cursor);
/* Pan view */
if (g->bind_states[PP_BindKind_Pan].is_held)
{
if (!g->debug_camera_panning)
{
g->debug_camera_pan_start = world_cursor;
g->debug_camera_panning = 1;
}
Vec2 offset = NegVec2(SubVec2(g->debug_camera_pan_start, world_cursor));
g->world_to_ui_xf = TranslateXform(g->world_to_ui_xf, offset);
world_cursor = InvertXformMulV2(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[PP_BindKind_ZoomIn].num_presses - g->bind_states[PP_BindKind_ZoomOut].num_presses;
if (input_zooms != 0)
{
/* Zoom to cursor */
f32 zoom_rate = 2;
f32 zoom = PowF32(zoom_rate, input_zooms);
g->world_to_ui_xf = TranslateXform(g->world_to_ui_xf, world_cursor);
g->world_to_ui_xf = ScaleXform(g->world_to_ui_xf, VEC2(zoom, zoom));
g->world_to_ui_xf = TranslateXform(g->world_to_ui_xf, NegVec2(world_cursor));
}
g->world_to_ui_xf.og = RoundVec2(g->world_to_ui_xf.og);
}
else
{
Xform xf = PP_XformFromEnt(local_camera);
Vec2 world_center = xf.og;
f32 rot = RotationFromXform(xf);
/* Scale view into viewport based on camera size */
Vec2 scale = VEC2(g->ui_size.x, g->ui_size.y);
{
Xform quad_xf = MulXform(xf, local_camera->camera_quad_xform);
Vec2 camera_size = ScaleFromXform(quad_xf);
if (!IsVec2Zero(camera_size))
{
scale = DivVec2Vec2(scale, camera_size);
}
}
scale.x = MinF32(scale.x, scale.y);
scale.y = scale.x;
Vec2 ui_center = MulVec2(VEC2(g->ui_size.x, g->ui_size.y), 0.5);
Trs trs = TRS(.t = SubVec2(ui_center, world_center), .r = rot, .s = scale);
Vec2 pivot = world_center;
g->world_to_ui_xf = XformIdentity;
g->world_to_ui_xf = TranslateXform(g->world_to_ui_xf, pivot);
g->world_to_ui_xf = TranslateXform(g->world_to_ui_xf, trs.t);
g->world_to_ui_xf = RotateXform(g->world_to_ui_xf, trs.r);
g->world_to_ui_xf = ScaleXform(g->world_to_ui_xf, trs.s);
g->world_to_ui_xf = TranslateXform(g->world_to_ui_xf, NegVec2(pivot));
g->world_to_ui_xf.og = RoundVec2(g->world_to_ui_xf.og);
}
g->world_cursor = InvertXformMulV2(g->world_to_ui_xf, g->ui_cursor);
//- Update world to render xform from world to ui xform
b32 effects_disabled = 0;
// b32 effects_disabled = 1;
g->render_size = RoundVec2ToVec2I32(VEC2(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
{
Xform ui_to_world_xf = InvertXform(g->world_to_ui_xf);
Vec2 world_center = MulXformV2(ui_to_world_xf, MulVec2(VEC2(g->ui_size.x, g->ui_size.y), 0.5));
Vec2 scale = VEC2(PIXELS_PER_UNIT, PIXELS_PER_UNIT);
Xform xf = XformIdentity;
xf = TranslateXform(xf, MulVec2(VEC2(g->render_size.x, g->render_size.y), 0.5));
xf = ScaleXform(xf, scale);
xf = TranslateXform(xf, MulVec2(world_center, -1));
xf.og = RoundVec2(xf.og);
g->world_to_render_xf = xf;
}
//- Update render to ui xform
{
Xform world_to_ui_xf = g->world_to_ui_xf;
Xform world_to_render_xf = g->world_to_render_xf;
Xform render_to_world_xf = InvertXform(world_to_render_xf);
Xform render_to_ui_xf = MulXform(world_to_ui_xf, render_to_world_xf);
g->render_to_ui_xf = render_to_ui_xf;
}
//- Update listener from view
{
Vec2 up = VEC2(0, -1);
Vec2 ui_center = MulVec2(VEC2(g->ui_size.x, g->ui_size.y), 0.5f);
Vec2 listener_pos = InvertXformMulV2(g->world_to_ui_xf, ui_center);
Vec2 listener_dir = NormVec2(InvertXformBasisMulV2(g->world_to_ui_xf, up));
MIX_UpdateListener(listener_pos, listener_dir);
}
//- Draw grid
{
f32 thickness = 2;
Vec2 offset = NegVec2(MulXformV2(g->world_to_render_xf, VEC2(0, 0)));
f32 spacing = ScaleFromXform(g->world_to_render_xf).x;
Vec2 pos = InvertXformMulV2(g->world_to_render_xf, VEC2(0, 0));
Vec2 size = InvertXformBasisMulV2(g->world_to_render_xf, VEC2(g->render_size.x, g->render_size.y));
u32 color0 = Rgba32F(0.17f, 0.17f, 0.17f, 1.f);
u32 color1 = Rgba32F(0.15f, 0.15f, 0.15f, 1.f);
PP_MaterialGrid *grid = PushStruct(g->grids_arena, PP_MaterialGrid);
*grid = PP_DefaultMaterialGrid;
grid->line_thickness = thickness;
grid->line_spacing = spacing;
grid->offset = offset;
grid->bg0_srgb = color0;
grid->bg1_srgb = color1;
grid->line_srgb = Rgba32(0x3f, 0x3f, 0x3f, 0xFF);
grid->x_srgb = Color_Red;
grid->y_srgb = Color_Green;
PP_MaterialInstance *mat = PushStruct(g->material_instances_arena, PP_MaterialInstance);
*mat = PP_DefaultMaterialInstance;
mat->grid_id = grid - (PP_MaterialGrid *)ArenaBase(g->grids_arena);
mat->xf = XformFromRect(RectFromVec2(pos, size));
}
#if 0
//- Acquire / release tile cache entries
/* Acquire entries from new sim chunks */
for (u64 ent_index = 0; ent_index < g->ss_blended->num_ents_reserved; ++ent_index)
{
PP_Ent *chunk_ent = &g->ss_blended->ents[ent_index];
if (PP_IsValidAndActive(chunk_ent) && PP_HasProp(chunk_ent, PP_Prop_TileChunk))
{
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_acquire(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)
{
PP_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)
{
Vec2I32 chunk_pos = entry->pos;
PP_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 */
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)
{
Vec2I32 chunk_pos = entry->pos;
PP_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]
*/
Vec2I32 chunk_pos_tl = VEC2I32(chunk_pos.x - 1, chunk_pos.y - 1);
Vec2I32 chunk_pos_t = VEC2I32(chunk_pos.x, chunk_pos.y - 1);
Vec2I32 chunk_pos_tr = VEC2I32(chunk_pos.x + 1, chunk_pos.y - 1);
Vec2I32 chunk_pos_l = VEC2I32(chunk_pos.x - 1, chunk_pos.y);
Vec2I32 chunk_pos_r = VEC2I32(chunk_pos.x + 1, chunk_pos.y);
Vec2I32 chunk_pos_bl = VEC2I32(chunk_pos.x - 1, chunk_pos.y + 1);
Vec2I32 chunk_pos_b = VEC2I32(chunk_pos.x, chunk_pos.y + 1);
Vec2I32 chunk_pos_br = VEC2I32(chunk_pos.x + 1, chunk_pos.y + 1);
PP_Ent *chunk_ent_tl = sim_ent_from_chunk_pos(chunk_pos_tl);
PP_Ent *chunk_ent_t = sim_ent_from_chunk_pos(chunk_pos_t);
PP_Ent *chunk_ent_tr = sim_ent_from_chunk_pos(chunk_pos_tr);
PP_Ent *chunk_ent_l = sim_ent_from_chunk_pos(chunk_pos_l);
PP_Ent *chunk_ent_r = sim_ent_from_chunk_pos(chunk_pos_r);
PP_Ent *chunk_ent_bl = sim_ent_from_chunk_pos(chunk_pos_bl);
PP_Ent *chunk_ent_b = sim_ent_from_chunk_pos(chunk_pos_b);
PP_Ent *chunk_ent_br = sim_ent_from_chunk_pos(chunk_pos_br);
String data = sim_ent_get_chunk_tile_data(chunk_ent);
}
}
}
#endif
#endif
//- Sort drawable entities
PP_Ent **sorted = PushDry(scratch.arena, PP_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)
{
PP_Ent *ent = &g->ss_blended->ents[ent_index];
if (PP_IsValidAndActive(ent))
{
*PushStructNoZero(scratch.arena, PP_Ent *) = ent;
++sorted_count;
}
}
}
/* Sort */
{
__profn("Sort ents");
Mergesort(sorted, sorted_count, sizeof(*sorted), PP_EntSortCmp, 0);
}
}
//- Draw entities
{
__profn("Draw entities");
for (u64 sorted_index = 0; sorted_index < sorted_count; ++sorted_index)
{
PP_Ent *ent = sorted[sorted_index];
if (!PP_IsValidAndActive(ent)) continue;
//if (S_IsNil(ent->sprite)) continue;
ResourceKey sprite = ent->sprite;
PP_Ent *parent = PP_EntFromKey(g->ss_blended, ent->parent);
Xform xf = PP_XformFromEnt(ent);
UNUSED Xform parent_xf = PP_XformFromEnt(parent);
b32 skip_debug_draw = !g->debug_camera && ent == local_camera;
skip_debug_draw = skip_debug_draw || PP_HasProp(ent, PP_Prop_MotorJoint);
b32 skip_debug_draw_transform = PP_HasProp(ent, PP_Prop_Camera);
skip_debug_draw_transform = 1;
UNUSED Xform sprite_xform = MulXform(xf, ent->sprite_local_xform);
/* Draw tracer */
/* TODO: Enable this */
#if 0
if (PP_HasProp(ent, PP_Prop_Tracer))
{
Vec2 velocity = ent->tracer_start_velocity;
Vec2 a = ent->tracer_start;
Vec2 b = xf.og;
Vec2 c = ent->tracer_gradient_start;
Vec2 d = ent->tracer_gradient_end;
Vec2 vcd = SubVec2(d, c);
Vec2 vca = SubVec2(a, c);
Vec2 vdb = SubVec2(b, d);
Vec2 vdc = NegVec2(vcd);
f32 opacity_a = 1;
f32 opacity_b = 1;
if (Vec2LenSq(vcd) != 0)
{
if (DotVec2(velocity, vca) <= 0)
{
a = c;
opacity_a = 0;
}
else
{
opacity_a = DotVec2(vcd, vca) / Vec2LenSq(vcd);
}
opacity_a = ClampF32(opacity_a, 0, 1);
opacity_b = ClampF32(1.f - (DotVec2(vdc, vdb) / Vec2LenSq(vdc)), 0, 1);
}
f32 thickness = 0.01f;
u32 color_start = Rgba32F(1, 0.5, 0, opacity_a);
u32 color_end = Rgba32F(1, 0.8, 0.4, opacity_b);
if (opacity_b > 0.99f)
{
D_DrawCircle(g->render_sig, b, thickness / 2, color_end, 20);
}
D_DrawLineGradient(g->render_sig, a, b, thickness, color_start, color_end);
}
#endif
/* Draw sprite */
if (!IsResourceNil(sprite))
{
S_Sheet *sheet = S_SheetFromResourceAsync(sprite);
S_Texture *texture = S_TextureFromResourceAsync(sprite);
/* TODO: Fade in placeholder if texture isn't loaded */
if (sheet->loaded && texture->loaded)
{
b32 is_light = PP_HasProp(ent, PP_Prop_LightTest);
Vec3 emittance = ent->sprite_emittance;
u32 tint = ent->sprite_tint;
S_Frame frame = S_FrameFromIndex(sheet, ent->animation_frame);
PP_MaterialInstance *mat = PushStruct(g->material_instances_arena, PP_MaterialInstance);
*mat = PP_DefaultMaterialInstance;
mat->xf = sprite_xform;
mat->tex = GPU_Texture2DRidFromResource(texture->gpu_texture);
mat->tint_srgb = tint;
mat->tex_uv0 = frame.clip.p0;
mat->tex_uv1 = frame.clip.p1;
mat->is_light = is_light;
mat->light_emittance_srgb = emittance;
}
}
/* Draw tiles */
/* TODO: Something better */
if (PP_HasProp(ent, PP_Prop_TileChunk))
{
Vec2I32 chunk_index = ent->tile_chunk_index;
ResourceKey tile_sprite = ResourceKeyFromStore(&PP_Resources, Lit("sprite/tile.ase"));
S_Texture *tile_texture = S_TextureFromResourceAsync(tile_sprite);
if (tile_texture->loaded)
{
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)
{
Vec2I32 local_tile_index = VEC2I32(tile_x, tile_y);
PP_TileKind tile = ent->tile_chunk_tiles[local_tile_index.x + (local_tile_index.y * SIM_TILES_PER_CHUNK_SQRT)];
/* FIXME: Enable this */
//if (tile > -1)
if (tile == PP_TileKind_Wall)
{
Vec2I32 world_tile_index = PP_WorldTileIndexFromLocalTileIndex(chunk_index, local_tile_index);
Vec2 pos = PP_PosFromWorldTileIndex(world_tile_index);
Xform tile_xf = XformFromRect(RectFromVec2(pos, VEC2(tile_size, tile_size)));
PP_MaterialInstance *mat = PushStruct(g->material_instances_arena, PP_MaterialInstance);
*mat = PP_DefaultMaterialInstance;
mat->xf = tile_xf;
mat->tex = GPU_Texture2DRidFromResource(tile_texture->gpu_texture);
mat->is_light = 1;
mat->light_emittance_srgb = VEC3(0, 0, 0);
}
}
}
}
}
/* Debug draw entity info */
if (g->debug_draw && !skip_debug_draw)
{
TempArena temp = BeginTempArena(scratch.arena);
if (PP_HasProp(ent, PP_Prop_Kinematic) || PP_HasProp(ent, PP_Prop_Dynamic))
{
PP_DrawDebugMovement(ent);
}
/* Draw xform */
if (!skip_debug_draw_transform)
{
u32 color_x = Rgba32F(1, 0, 0, 0.5);
u32 color_y = Rgba32F(0, 1, 0, 0.5);
PP_DrawDebugXform(xf, color_x, color_y);
}
/* Draw AABB */
/* FIXME: Enable this */
#if 0
if (ent->local_collider.count > 0)
{
Aabb aabb = CLD_AabbFromShape(&ent->local_collider, xf);
f32 thickness = 1;
u32 color = Rgba32F(1, 0, 1, 0.5);
Quad quad = QuadFromAabb(aabb);
quad = MulXformQuad(g->world_to_ui_xf, quad);
D_DrawQuadLine(g->render_sig, quad, thickness, color);
}
/* Draw focus arrow */
if (ent == local_control || PP_EqEntKey(ent->key, g->debug_following))
{
S_Sheet *sheet = S_SheetFromResourceAsync(ent->sprite);
S_Slice slice = S_SliceFromNameIndex(sheet, Lit("attach.wep"), ent->animation_frame);
Vec2 start = MulXformV2(sprite_xform, slice.center);
start = MulXformV2(g->world_to_ui_xf, start);
Vec2 end = AddVec2(xf.og, ent->control.focus);
end = MulXformV2(g->world_to_ui_xf, end);
D_DrawArrowLine(g->render_sig, start, end, 3, 10, Rgba32F(1, 1, 1, 0.5));
}
#endif
#if 0
/* Draw slices */
if (!S_IsNil(ent->sprite))
{
S_Sheet *sheet = S_SheetFromResourceAsync(sprite);
u32 quad_color = Rgba32F(1, 0, 0.5, 1);
u32 point_color = Rgba32F(1, 0, 0, 1);
u32 ray_color = Rgba32F(1, 0, 0.5, 1);
for (u64 i = 0; i < sheet->slice_groups_count; ++i)
{
S_SheetSliceGroup *group = &sheet->slice_groups[i];
if (StringEndsWith(group->name, Lit(".ray"))) continue;
for (u32 j = 0; j < group->per_frame_count; ++j)
{
S_Slice slice = group->frame_slices[(ent->animation_frame * group->per_frame_count) + j];
Vec2 center = MulXformV2(sprite_xform, slice.center);
center = MulXformV2(g->world_to_ui_xf, center);
if (!slice.has_ray)
{
Quad quad = QuadFromRect(slice.rect);
quad = MulXformQuad(sprite_xform, quad);
quad = MulXformQuad(g->world_to_ui_xf, quad);
D_DrawQuadLine(g->render_sig, quad, 2, quad_color);
}
D_DrawCircle(g->render_sig, center, 3, point_color, 20);
if (slice.has_ray)
{
Vec2 ray = MulXformBasisV2(sprite_xform, slice.dir);
ray = MulXformBasisV2(g->world_to_ui_xf, ray);
ray = Vec2WithLen(ray, 25);
D_DrawArrowRay(g->render_sig, center, ray, 2, 10, ray_color);
}
}
}
}
#endif
/* Draw weld joint */
#if 0
if (PP_HasProp(ent, PP_Prop_WeldJoint))
{
PP_Ent *e1 = PP_EntFromKey(g->ss_blended, ent->weld_joint_data.e1);
Xform e1_xf = PP_XformFromEnt(e1);
u32 color = Color_Yellow;
f32 radius = 3;
Vec2 point = MulXformV2(e1_xf, ent->weld_joint_data.point_local_e1);
point = MulXformV2(g->world_to_ui_xf, point);
D_DrawCircle(g->render_sig, point, radius, color, 10);
DEBUGBREAKABLE;
}
#endif
/* Draw mouse joint */
/* FIXME: Enable this */
#if 0
if (PP_HasProp(ent, PP_Prop_MouseJoint))
{
PP_Ent *target = PP_EntFromKey(g->ss_blended, ent->mouse_joint_data.target);
Xform target_xf = PP_XformFromEnt(target);
u32 color = Color_White;
Vec2 point_start = MulXformV2(target_xf, ent->mouse_joint_data.point_local_start);
Vec2 point_end = g->world_cursor;
point_start = MulXformV2(g->world_to_ui_xf, point_start);
point_end = MulXformV2(g->world_to_ui_xf, point_end);
D_DrawArrowLine(g->render_sig, point_start, point_end, 3, 10, color);
D_DrawCircle(g->render_sig, point_start, 4, color, 10);
}
#endif
/* Draw collider */
/* FIXME: Enable this */
#if 0
if (ent->local_collider.count > 0)
{
CLD_Shape collider = ent->local_collider;
u32 color = Rgba32F(1, 1, 0, 0.5);
f32 thickness = 2;
{
/* Draw collider using support points */
u32 detail = 32;
Xform collider_draw_xf = MulXform(g->world_to_ui_xf, xf);
D_DrawColliderLine(g->render_sig, collider, collider_draw_xf, thickness, color, detail);
}
{
/* Draw collider shape points */
for (u32 i = 0; i < collider.count; ++i)
{
Vec2 p = MulXformV2(MulXform(g->world_to_ui_xf, xf), collider.points[i]);
D_DrawCircle(g->render_sig, p, 3, Color_Blue, 10);
}
}
if (collider.count == 1 && collider.radius > 0)
{
/* Draw upwards line for circle */
Vec2 start = xf.og;
Vec2 end = CLD_SupportPointFromDir(&collider, xf, NegVec2(xf.by)).p;
start = MulXformV2(g->world_to_ui_xf, start);
end = MulXformV2(g->world_to_ui_xf, end);
D_DrawLine(g->render_sig, start, end, thickness, color);
}
#if 0
/* Draw support point at focus dir */
{
Vec2 p = collider_support_point(&collider, xf, ent->control.focus);
p = MulXformV2(g->world_to_ui_xf, p);
D_DrawCircle(g->render_sig, p, 3, Color_Red, 10);
}
#endif
}
#endif
/* Draw contact constraint */
/* FIXME: Enable this */
#if 0
if (PP_HasProp(ent, PP_Prop_ContactConstraint))
{
ContactConstraint *data = &ent->contact_constraint_data;
PP_Ent *e0 = PP_EntFromKey(g->ss_blended, data->e0);
PP_Ent *e1 = PP_EntFromKey(g->ss_blended, data->e1);
LAX e0;
LAX e1;
#if DeveloperIsEnabled
/* Draw contact points */
{
f32 radius = 5;
for (u32 i = 0; i < data->num_points; ++i)
{
u32 color = (data->skip_solve || data->wrong_dir) ? Alpha32F(Color_Yellow, 0.3) : Rgba32F(0.8, 0.2, 0.2, 1);
ContactPoint point = data->points[i];
Vec2 dbg_pt = point.dbg_pt;
/* Draw point */
{
D_DrawCircle(g->render_sig, MulXformV2(g->world_to_ui_xf, dbg_pt), radius, color, 10);
}
/* Draw normal */
{
f32 len = 0.1f;
f32 arrow_thickness = 2;
f32 arrow_height = 5;
Vec2 start = MulXformV2(g->world_to_ui_xf, dbg_pt);
Vec2 end = MulXformV2(g->world_to_ui_xf, AddVec2(dbg_pt, MulVec2(NormVec2(data->normal), len)));
D_DrawArrowLine(g->render_sig, start, end, arrow_thickness, arrow_height, color);
}
#if 0
/* Draw contact info */
{
F_Font *disp_font = F_LoadFontAsync(ResourceKeyFromStore(&PP_Resources, Lit("font/fixedsys.ttf")), 12.0f);
if (disp_font)
{
f32 offset_px = 10;
String fmt = Lit(
"e0 index: %F\n"
"e1 index: %F\n"
"key: 0x%F\n"
"impulse (n): %F\n"
"impulse (t): %F\n"
"separation: %F\n"
"normal: (%F, %F)\n"
"num contacts: %F"
);
String text = StringF(temp.arena, fmt,
FmtUint(e0->key.idx),
FmtUint(e1->key.idx),
FmtHex(point.key),
FmtFloat(point.normal_impulse),
FmtFloat(point.tangent_impulse),
FmtFloatP(point.starting_separation, 6),
FmtFloatP(data->normal.x, 6), FmtFloatP(data->normal.y, 6),
FmtUint(data->num_points));
draw_text(g->render_sig, disp_font, AddVec2(RoundVec2(MulXformV2(g->world_to_ui_xf, dbg_pt)), VEC2(0, offset_px)), text);
}
}
#endif
}
}
#endif
}
#endif
/* Draw collision debug */
#if COLLIDER_DEBUG
if (PP_HasProp(ent, PP_Prop_CollisionDebug))
{
ContactDebugData *data = &ent->collision_debug_data;
CLD_CollisionData collision_reuslt = data->collision_result;
PP_Ent *e0 = PP_EntFromKey(g->ss_blended, data->e0);
PP_Ent *e1 = PP_EntFromKey(g->ss_blended, data->e1);
CLD_Shape e0_collider = e0->local_collider;
CLD_Shape e1_collider = e1->local_collider;
LAX e0_collider;
LAX e1_collider;
/* Draw closest points */
#if 0
{
f32 radius = 4;
u32 color = Rgba32F(1, 1, 0, 0.5);
Vec2 a = MulXformV2(g->world_to_ui_xf, data->closest0);
Vec2 b = MulXformV2(g->world_to_ui_xf, data->closest1);
D_DrawCircle(g->render_sig, a, radius, color, 10);
D_DrawCircle(g->render_sig, b, radius, color, 10);
}
#endif
/* Draw clipping */
{
f32 thickness = 4;
f32 radius = 4;
u32 color_line = Rgba32F(1, 0, 1, 0.75);
u32 color_a = Rgba32F(1, 0, 0, 0.25);
u32 color_b = Rgba32F(0, 1, 0, 0.25);
u32 color_line_clipped = Rgba32F(1, 0, 1, 1);
u32 color_a_clipped = Rgba32F(1, 0, 0, 1);
u32 color_b_clipped = Rgba32F(0, 1, 0, 1);
{
Vec2 a = MulXformV2(g->world_to_ui_xf, collision_reuslt.a0);
Vec2 b = MulXformV2(g->world_to_ui_xf, collision_reuslt.b0);
D_DrawLine(g->render_sig, a, b, thickness, color_line);
D_DrawCircle(g->render_sig, a, radius, color_a, 10);
D_DrawCircle(g->render_sig, b, radius, color_b, 10);
Vec2 a_clipped = MulXformV2(g->world_to_ui_xf, collision_reuslt.a0_clipped);
Vec2 b_clipped = MulXformV2(g->world_to_ui_xf, collision_reuslt.b0_clipped);
D_DrawLine(g->render_sig, a_clipped, b_clipped, thickness, color_line_clipped);
D_DrawCircle(g->render_sig, a_clipped, radius, color_a_clipped, 10);
D_DrawCircle(g->render_sig, b_clipped, radius, color_b_clipped, 10);
}
{
Vec2 a = MulXformV2(g->world_to_ui_xf, collision_reuslt.a1);
Vec2 b = MulXformV2(g->world_to_ui_xf, collision_reuslt.b1);
D_DrawLine(g->render_sig, a, b, thickness, color_line);
D_DrawCircle(g->render_sig, a, radius, color_a, 10);
D_DrawCircle(g->render_sig, b, radius, color_b, 10);
Vec2 a_clipped = MulXformV2(g->world_to_ui_xf, collision_reuslt.a1_clipped);
Vec2 b_clipped = MulXformV2(g->world_to_ui_xf, collision_reuslt.b1_clipped);
D_DrawLine(g->render_sig, a_clipped, b_clipped, thickness, color_line_clipped);
D_DrawCircle(g->render_sig, a_clipped, radius, color_a_clipped, 10);
D_DrawCircle(g->render_sig, b_clipped, radius, color_b_clipped, 10);
}
}
#if COLLIDER_DEBUG_DETAILED_DRAW_MENKOWSKI
Xform e0_xf = data->xf0;
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 */
{
F_Font *disp_font = F_LoadFontAsync(ResourceKeyFromStore(&PP_Resources, Lit("font/fixedsys.ttf")), 12.0f);
if (disp_font)
{
f32 offset_px = 10;
String fmt = Lit(
"e0 pos: (%F, %F)\n"
"e0 rot: %F\n"
"e1 pos: (%F, %F)\n"
"e1 rot: %F\n"
);
String text = StringF(temp.arena, fmt,
FmtFloatP(e0_xf.og.x, 24), FmtFloatP(e0_xf.og.y, 24),
FmtFloatP(RotationFromXform(e0_xf), 24),
FmtFloatP(e1_xf.og.x, 24), FmtFloatP(e1_xf.og.y, 24),
FmtFloatP(RotationFromXform(e1_xf), 24));
draw_text(g->render_sig, disp_font, AddVec2(RoundVec2(MulXformV2(g->world_to_ui_xf, VEC2(0, 0))), VEC2(0, offset_px)), text);
}
}
#endif
/* Draw CLD_Menkowski */
{
u32 color = collision_reuslt.solved ? Rgba32F(0, 0, 0.25, 1) : Rgba32F(0, 0.25, 0.25, 1);
f32 thickness = 2;
u32 detail = 512;
LAX thickness;
Vec2Array m = CLD_Menkowski(temp.arena, &e0_collider, &e1_collider, e0_xf, e1_xf, detail);
for (u64 i = 0; i < m.count; ++i) m.points[i] = MulXformV2(g->world_to_ui_xf, m.points[i]);
D_DrawPolyLine(g->render_sig, m, 1, thickness, color);
//D_DrawPoly(g->render_sig, m, color);
}
/* Draw CLD_PointCloud */
{
u32 color = Rgba32F(1, 1, 1, 1);
f32 radius = 2;
Vec2Array m = CLD_PointCloud(temp.arena, &e0_collider, &e1_collider, e0_xf, e1_xf);
for (u64 i = 0; i < m.count; ++i)
{
Vec2 p = MulXformV2(g->world_to_ui_xf, m.points[i]);
D_DrawCircle(g->render_sig, p, radius, color, 10);
}
}
/* Draw prototype */
{
f32 thickness = 2;
u32 color = Rgba32F(1, 1, 1, 0.25);
Vec2Array m = {
.points = collision_reuslt.prototype.points,
.count = collision_reuslt.prototype.len
};
for (u64 i = 0; i < m.count; ++i) m.points[i] = MulXformV2(g->world_to_ui_xf, m.points[i]);
D_DrawPolyLine(g->render_sig, m, 1, thickness, color);
for (u64 i = 0; i < m.count; ++i) D_DrawCircle(g->render_sig, m.points[i], 10, color, 10);
}
/* Draw simplex */
{
f32 thickness = 2;
u32 line_color = Color_Yellow;
u32 color_first = Rgba32F(1, 0, 0, 0.75);
u32 color_second = Rgba32F(0, 1, 0, 0.75);
u32 color_third = Rgba32F(0, 0, 1, 0.75);
CLD_MenkowskiSimplex simplex = collision_reuslt.simplex;
Vec2 simplex_points[] = { simplex.a.p, simplex.b.p, simplex.c.p };
for (u64 i = 0; i < countof(simplex_points); ++i) simplex_points[i] = MulXformV2(g->world_to_ui_xf, simplex_points[i]);
Vec2Array 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);
D_DrawCircle(g->render_sig, simplex_array.points[0], thickness * 3, color, 10);
}
if (simplex.len >= 2)
{
u32 color = simplex.len == 2 ? color_first : color_second;
D_DrawCircle(g->render_sig, simplex_array.points[1], thickness * 3, color, 10);
}
if (simplex.len >= 3)
{
u32 color = color_first;
D_DrawCircle(g->render_sig, simplex_array.points[2], thickness * 3, color, 10);
}
if (simplex.len >= 2)
{
D_DrawPolyLine(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;
Vec2 start = MulXformV2(g->world_to_ui_xf, VEC2(0, 0));
Vec2 end = MulXformV2(g->world_to_ui_xf, MulVec2(NormVec2(collision_reuslt.normal), len));
D_DrawArrowLine(g->render_sig, start, end, arrow_thickness, arrowhead_height, color);
}
}
#endif
}
#endif
/* Draw hierarchy */
/* FIXME: Enable this */
#if 0
if (PP_HasProp(parent, PP_Prop_Active) && !parent->is_root)
{
u32 color = Rgba32F(0.6, 0.6, 1, 0.75);
f32 thickness = 2;
f32 arrow_height = 15;
Vec2 start = MulXformV2(g->world_to_ui_xf, xf.og);
Vec2 end = MulXformV2(g->world_to_ui_xf, parent_xf.og);
D_DrawArrowLine(g->render_sig, start, end, thickness, arrow_height, color);
}
/* Draw camera rect */
if (PP_HasProp(ent, PP_Prop_Camera))
{
u32 color = ent == local_camera ? Rgba32F(1, 1, 1, 0.5) : Rgba32F(0, 0.75, 0, 0.5);
f32 thickness = 3;
Xform quad_xf = MulXform(xf, ent->camera_quad_xform);
Quad quad = MulXformQuad(quad_xf, CenteredUnitSquareQuad);
quad = MulXformQuad(g->world_to_ui_xf, quad);
D_DrawQuadLine(g->render_sig, quad, thickness, color);
}
#endif
EndTempArena(temp);
}
}
}
/* Draw crosshair or show cursor */
/* FIXME: Enable this */
#if 0
if (!g->debug_camera)
{
__profn("Draw crosshair");
Vec2 crosshair_pos = g->ui_cursor;
ResourceKey crosshair = ResourceKeyFromStore(PP_Resources, Lit("sprite/crosshair.ase"));
S_Texture *t = S_TextureFromResourceAsync(crosshair);
Vec2 size = VEC2(t->width, t->height);
Xform xf = XformFromTrs(TRS(.t = crosshair_pos, .s = size));
D_DrawUiRect(g->render_sig, D_UIRECTPARAMS(.xf = xf, .texture = t->gpu_resource));
}
#endif
/* FIXME: Enable this */
#if 0
{
__profn("Update window cursor");
if (g->debug_camera)
{
P_DisableWindoweCursorClip(g->window);
P_ShowWindowCursor(g->window);
}
else
{
S_Texture *t = S_TextureFromResourceAsync(ResourceKeyFromStore(PP_Resources, Lit("sprite/crosshair.ase")));
Vec2 size = VEC2(t->width, t->height);
Rect cursor_clip = RectFromVec2(g->ui_screen_offset, g->ui_size);
cursor_clip.pos = AddVec2(cursor_clip.pos, MulVec2(size, 0.5f));
cursor_clip.pos = AddVec2(cursor_clip.pos, VEC2(1, 1));
cursor_clip.size = SubVec2(cursor_clip.size, size);
P_HideWindowCursor(g->window);
P_EnableWindoweCursorClip(g->window, cursor_clip);
}
}
#endif
//- Create user sim cmd
{
/* Queue player move cmd */
f32 move_speed = 1.0f;
//if (g->bind_states[PP_BindKind_Walk].is_held)
if (g->bind_states[PP_BindKind_FullscreenMod].is_held)
{
//const f32 walk_ratio = 0.25f;
const f32 walk_ratio = 0.05f;
move_speed *= walk_ratio;
}
Vec2 input_move_dir = ZI;
{
for (PP_BindKind bind = 0; bind < (i32)countof(g->bind_states); ++bind)
{
PP_BindState state = g->bind_states[bind];
if (!state.is_held && state.num_presses <= 0)
{
continue;
}
switch (bind)
{
default: break;
/* Movement */
case PP_BindKind_MoveUp:
{
input_move_dir.y -= 1;
} break;
case PP_BindKind_MoveDown:
{
input_move_dir.y += 1;
} break;
case PP_BindKind_MoveLeft:
{
input_move_dir.x -= 1;
} break;
case PP_BindKind_MoveRight:
{
input_move_dir.x += 1;
} break;
}
}
input_move_dir = InvertXformBasisMulV2(g->world_to_ui_xf, input_move_dir); /* Make move dir relative to world view */
input_move_dir = MulVec2(NormVec2(input_move_dir), move_speed);
}
if (!g->debug_camera)
{
g->focus_send = SubVec2(g->world_cursor, PP_XformFromEnt(local_control).og);
}
Vec2 input_aim_dir = g->focus_send;
/* Queue player control cmd */
{
PP_ControlData control = ZI;
control.move = input_move_dir;
control.focus = input_aim_dir;
control.dbg_cursor = g->world_cursor;
PP_BindState fire_state = g->bind_states[PP_BindKind_Fire];
PP_BindState fire_alt_state = g->bind_states[PP_BindKind_AltFire];
PP_BindState drag_state = g->bind_states[PP_BindKind_DebugDrag];
PP_BindState delete_state = g->bind_states[PP_BindKind_DebugDelete];
PP_BindState clear_state = g->bind_states[PP_BindKind_DebugClear];
PP_BindState spawn1_state = g->bind_states[PP_BindKind_DebugSpawn1];
PP_BindState spawn2_state = g->bind_states[PP_BindKind_DebugSpawn2];
PP_BindState spawn3_state = g->bind_states[PP_BindKind_DebugSpawn3];
PP_BindState spawn4_state = g->bind_states[PP_BindKind_DebugSpawn4];
PP_BindState walls_state = g->bind_states[PP_BindKind_DebugWalls];
PP_BindState pause_state = g->bind_states[PP_BindKind_DebugPause];
PP_BindState step_state = g->bind_states[PP_BindKind_DebugStep];
PP_BindState tile_state = g->bind_states[PP_BindKind_TestTile];
PP_BindState explode_state = g->bind_states[PP_BindKind_DebugExplode];
PP_BindState teleport_state = g->bind_states[PP_BindKind_DebugTeleport];
if (fire_state.num_presses || fire_state.is_held)
{
control.flags |= PP_ControlFlag_Fire;
}
if (fire_alt_state.num_presses || fire_alt_state.is_held)
{
control.flags |= PP_ControlFlag_AltFire;
}
if (drag_state.num_presses || drag_state.is_held)
{
control.flags |= PP_ControlFlag_Drag;
}
if (delete_state.num_presses || delete_state.is_held)
{
control.flags |= PP_ControlFlag_Delete;
}
if (clear_state.num_presses_and_repeats)
{
control.flags |= PP_ControlFlag_ClearAll;
}
if (spawn1_state.num_presses_and_repeats)
{
control.flags |= PP_ControlFlag_SpawnTest1;
}
if (spawn2_state.num_presses_and_repeats)
{
control.flags |= PP_ControlFlag_SpawnTest2;
}
if (spawn3_state.num_presses_and_repeats)
{
control.flags |= PP_ControlFlag_SpawnTest3;
}
if (spawn4_state.num_presses_and_repeats)
{
control.flags |= PP_ControlFlag_SpawnTest4;
}
if (walls_state.num_presses_and_repeats)
{
control.flags |= PP_ControlFlag_TestWalls;
}
if (tile_state.num_presses || tile_state.is_held)
{
control.flags |= PP_ControlFlag_TestTiles;
}
if (explode_state.num_presses_and_repeats)
{
control.flags |= PP_ControlFlag_TestExplode;
}
if (teleport_state.num_presses_and_repeats || (g->debug_camera && teleport_state.is_held))
{
control.flags |= PP_ControlFlag_TestTeleport;
}
if (pause_state.num_presses)
{
Atomic32FetchXor(&g->user_paused, 1);
}
Atomic32FetchAdd(&g->user_paused_steps, step_state.num_presses_and_repeats);
/* Set user sim control */
{
Lock lock = LockE(&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->key;
Unlock(&lock);
}
}
#if RtcIsEnabled
/* Gjk steps */
{
if (g->bind_states[PP_BindKind_ResetDebugSteps].num_presses_and_repeats > 0)
{
SetGstat(GSTAT_DEBUG_STEPS, 0);
}
i32 add_steps = 0;
add_steps += g->bind_states[PP_BindKind_IncrementDebugSteps].num_presses_and_repeats;
add_steps -= g->bind_states[PP_BindKind_DecrementDebugSteps].num_presses_and_repeats;
if (add_steps != 0)
{
AddGstat(GSTAT_DEBUG_STEPS, add_steps);
}
}
#endif
}
{
/* Update network usage stats */
i64 stat_now_ns = TimeNs();
g->net_bytes_read.last_second_end = GetGstat(GSTAT_SOCK_BYTES_RECEIVED);
g->net_bytes_sent.last_second_end = GetGstat(GSTAT_SOCK_BYTES_SENT);
if (stat_now_ns - g->last_second_reset_ns > NsFromSeconds(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
/* FIXME: Enable this */
#if 0
if (g->debug_draw && hovered_ent->valid)
{
PP_Ent *ent = hovered_ent;
Vec2 pos = AddVec2(g->ui_cursor, VEC2(15, 15));
F_Font *font = F_LoadFontAsync(ResourceKeyFromStore(&PP_Resources, Lit("font/fixedsys.ttf")), 12.0f);
if (font)
{
TempArena temp = BeginTempArena(scratch.arena);
String dbg_text = ZI;
dbg_text.text = PushDry(temp.arena, u8);
dbg_text.len += PP_DebugStringFromEnt(temp.arena, ent).len;
draw_text(g->render_sig, D_TEXTPARAMS(.font = font, .pos = pos, .str = dbg_text));
EndTempArena(temp);
}
}
#endif
//////////////////////////////
//- Debug draw
GPU_Stats gpu_stats = GPU_QueryStats();
/* Draw console */
UI_Box *console_box = 0;
{
b32 console_minimized = !g->debug_console;
console_box = PP_BuildDebugConsole(console_minimized);
}
/* Draw lister */
if (g->lister_active)
{
UI_PushCP(pp_root_box);
{
Vec2 size = VEC2(400, 500);
UI_Report rep = UI_ReportFromKey(g->lister_key);
if (rep.flags & UI_ReportFlag_Active)
{
g->lister_pos = SubVec2(g->ui_cursor, rep.activation_offset);
}
UI_Push(BackgroundColor, Rgba32F(0.075, 0.075, 0.075, 0.99));
UI_Push(BorderColor, Rgba32F(0.2, 0.2, 0.2, 1));
UI_Push(Border, 2);
// UI_Size padding = UI_FILL(1, 0);
// UI_Size padding = UI_PIX(10, 0);
UI_Push(Width, UI_PIX(size.x, 0));
UI_Push(Height, UI_PIX(size.y, 0));
UI_Push(LayoutAxis, Axis_Y);
UI_Push(FloatingPos, g->lister_pos);
UI_SetNext(Flags, UI_BoxFlag_Floating);
UI_SetNext(Rounding, UI_RPIX(50));
UI_Box *lister_box = UI_BuildBox(Lit("lister"));
UI_Box *lister_pad = lister_box;
UI_PushCP(lister_pad);
{
// UI_BuildSpacer(UI_PIX(10, 0));
UI_Push(BackgroundColor, 0);
UI_Push(LayoutAxis, Axis_X);
UI_Push(Width, UI_FILL(1, 0));
UI_Push(Height, UI_FNT(5, 0));
{
UI_Push(BackgroundColor, Color_Orange);
UI_Push(Border, 2);
UI_Box *title_bar = UI_BuildBox(Zstr);
UI_PushCP(title_bar);
{
UI_Push(Width, UI_FILL(1, 0));
UI_Push(Padding, 0);
UI_Push(BackgroundColor, 0);
UI_Push(Border, 0);
UI_Box *left_box = UI_BuildBox(Zstr);
// UI_SetNext(LeftPadding, UI_PIX(10, 1));
// UI_SetNext(Padding, UI_PAD(UI_FILL(1, 0)));
UI_Box *center_box = UI_BuildBox(Zstr);
UI_Box *right_box = UI_BuildBox(Zstr);
// UI_Pad title_padding = UI_PADEX(.left = UI_PIX(50, 0), .right = UI_PIX(50, 0), .bottom = UI_PIX(10, 0));
// UI_Pad title_padding = UI_PAD(UI_FILL(1, 0));
// UI_Box *center_pad = UI_BuildPad(center_box, title_padding);
// UI_Box *center_pad = center_box;
UI_PushCP(center_box);
{
UI_SetNext(Text, Lit("Title"));
UI_SetNext(Flags, UI_BoxFlag_DrawText);
// UI_SetNext(Padding, UI_PADEX(.left = UI_PIX(100, 0), .right = UI_PIX(50, 0), .bottom = UI_PIX(10, 0)));
// UI_SetNext(Padding, UI_PADEX(.left = UI_PIX(1, 0)));
UI_SetNext(Padding, UI_PADALL(UI_FILL(1, 0)));
// UI_SetNext(Padding, UI_PAD(.left = UI_FILL(1, 0), .right = UI_FILL(1, 0)));
UI_Box *title_box = UI_BuildBox(Zstr);
}
UI_PopCP();
}
UI_PopCP();
}
}
UI_PopCP();
g->lister_key = lister_box->key;
}
UI_PopCP();
}
/* Draw debug info */
if (g->debug_draw)
{
__profn("Draw debug info");
UI_BuildSpacer(UI_FILL(1, 0));
UI_SetNext(LayoutAxis, Axis_Y);
UI_SetNext(BackgroundColor, 0);
UI_SetNext(BorderColor, 0);
UI_SetNext(Width, UI_FIT(0));
UI_SetNext(Height, UI_FIT(1));
UI_SetNext(Tint, 0);
UI_Box *dbg_box = UI_BuildBox(Lit("dbg"));
UI_PushCP(dbg_box);
{
UI_Push(BackgroundColor, 0);
UI_Push(BorderColor, 0);
// UI_Push(Padding, UI_PIX(5, 0));
UI_BuildLabelF("Blended world entities: %F/%F", FmtUint(g->ss_blended->num_ents_allocated), FmtUint(g->ss_blended->num_ents_reserved));
UI_BuildLabelF("Blended world tick: %F", FmtUint(g->ss_blended->tick));
UI_BuildLabelF("Blended world time: %F", FmtFloat(SecondsFromNs(g->ss_blended->sim_time_ns)));
UI_BuildSpacer(UI_FNT(1, 0));
UI_BuildLabelF("Average local sim publish dt: %F", FmtFloat(SecondsFromNs(g->average_local_to_user_snapshot_publish_dt_ns)));
UI_BuildLabelF("Local sim last known tick: %F", FmtUint(g->local_sim_last_known_tick));
UI_BuildLabelF("Local sim last known time: %F", FmtFloat(SecondsFromNs(g->local_sim_last_known_time_ns)));
UI_BuildLabelF("Local sim predicted time: %F", FmtFloat(SecondsFromNs(g->local_sim_predicted_time_ns)));
UI_BuildLabelF("Render time target: %F", FmtFloat(SecondsFromNs(g->render_time_target_ns)));
UI_BuildLabelF("Render time: %F", FmtFloat(SecondsFromNs(g->render_time_ns)));
UI_BuildLabelF("Local player: [%F]", FmtUid(local_player->key.uid));
UI_BuildSpacer(UI_FNT(1, 0));
Vec2 world_cursor = g->world_cursor;
UI_BuildLabelF("Cursor world: %F, %F", FmtFloat(world_cursor.x), FmtFloat(world_cursor.y));
Vec2I32 world_tile_cursor = PP_WorldTileIndexFromPos(world_cursor);
UI_BuildLabelF("Cursor world tile: %F, %F", FmtSint(world_tile_cursor.x), FmtSint(world_tile_cursor.y));
Vec2I32 local_tile_cursor = PP_LocalTileIndexFromWorldTileIndex(world_tile_cursor);
UI_BuildLabelF("Cursor local tile: %F, %F", FmtSint(local_tile_cursor.x), FmtSint(local_tile_cursor.y));
Vec2I32 tile_chunk_cursor = PP_TileChunkIndexFromWorldTileIndex(world_tile_cursor);
UI_BuildLabelF("Cursor tile chunk: %F, %F", FmtSint(tile_chunk_cursor.x), FmtSint(tile_chunk_cursor.y));
UI_BuildSpacer(UI_FNT(1, 0));
UI_BuildLabelF("Network read: %F mbit/s", FmtFloat((f64)g->net_bytes_read.last_second * 8 / 1000 / 1000));
UI_BuildLabelF("Network write: %F mbit/s", FmtFloat((f64)g->net_bytes_sent.last_second * 8 / 1000 / 1000));
UI_BuildLabelF("Ping (real): %F ms", FmtFloat(SecondsFromNs(local_player->player_last_rtt_ns) * 1000));
UI_BuildLabelF("Ping (average): %F ms", FmtFloat(local_player->player_average_rtt_seconds * 1000));
UI_BuildSpacer(UI_FNT(1, 0));
UI_BuildLabelF("Memory committed: %F MiB", FmtFloat((f64)GetGstat(GSTAT_MEMORY_COMMITTED) / 1024 / 1024));
UI_BuildLabelF("Virtual memory reserved: %F TiB", FmtFloat((f64)GetGstat(GSTAT_MEMORY_RESERVED) / 1024 / 1024 / 1024 / 1024));
UI_BuildLabelF("Arenas allocated: %F", FmtUint(GetGstat(GSTAT_NUM_ARENAS)));
UI_BuildSpacer(UI_FNT(1, 0));
UI_BuildLabelF("GPU dedicated memory usage: %F MiB", FmtFloat((f64)gpu_stats.local_committed / 1024 / 1024));
UI_BuildLabelF("GPU shared memory usage: %F MiB", FmtFloat((f64)gpu_stats.non_local_committed / 1024 / 1024));
UI_BuildSpacer(UI_FNT(1, 0));
UI_BuildLabelF("GPU resources: %F", FmtUint(gpu_stats.driver_resources_allocated));
UI_BuildLabelF("GPU descriptors: %F", FmtUint(gpu_stats.driver_descriptors_allocated));
//UI_BuildLabelF(\n"));
//UI_BuildLabelF(\n"));
#if RtcIsEnabled
UI_BuildSpacer(UI_FNT(1, 0));
UI_BuildLabelF("Debug steps: %F", FmtUint(GetGstat(GSTAT_DEBUG_STEPS)));
//UI_BuildLabelF(\n"));
#endif
}
UI_PopCP();
}
//////////////////////////////
//- Render
Rect ui_viewport = RectFromVec2(VEC2(0, 0), VEC2(g->ui_size.x, g->ui_size.y));
Rect render_viewport = RectFromVec2(VEC2(0, 0), VEC2(g->render_size.x, g->render_size.y));
GPU_QueueKind gpu_render_queue = GPU_QueueKind_Direct;
Fence *submit_fence = GPU_FenceFromQueue(gpu_render_queue);
{
__profn("Render");
/* Acquire gbuffers */
if (g->shade_target && !EqVec2I32(g->render_size, GPU_GetTextureSize2D(g->shade_target)))
{
__profn("Release render resources");
YieldOnFence(submit_fence, g->gpu_submit_fence_target);
GPU_ReleaseResource(g->albedo, GPU_ReleaseFlag_None);
GPU_ReleaseResource(g->emittance, GPU_ReleaseFlag_None);
GPU_ReleaseResource(g->emittance_flood_read, GPU_ReleaseFlag_None);
GPU_ReleaseResource(g->emittance_flood_target, GPU_ReleaseFlag_None);
GPU_ReleaseResource(g->shade_read, GPU_ReleaseFlag_None);
GPU_ReleaseResource(g->shade_target, GPU_ReleaseFlag_None);
g->shade_target = 0;
}
if (!g->shade_target)
{
__profn("Acquire sig resources");
g->albedo = PP_AcquireGbuffer(GPU_Format_R8G8B8A8_Unorm, g->render_size);
g->emittance = PP_AcquireGbuffer(GPU_Format_R16G16B16A16_Float, g->render_size);
g->emittance_flood_read = PP_AcquireGbuffer(GPU_Format_R16G16_Uint, g->render_size);
g->emittance_flood_target = PP_AcquireGbuffer(GPU_Format_R16G16_Uint, g->render_size);
g->shade_read = PP_AcquireGbuffer(GPU_Format_R16G16B16A16_Float, g->render_size);
g->shade_target = PP_AcquireGbuffer(GPU_Format_R16G16B16A16_Float, g->render_size);
}
/* Upload transient buffers */
GPU_Resource *material_instances_buffer = GPU_UploadTransientBufferFromArena(&g->material_instances_tbuff, g->material_instances_arena);
GPU_Resource *grids_buffer = GPU_UploadTransientBufferFromArena(&g->grids_tbuff, g->grids_arena);
u64 material_instances_count = GPU_GetBufferCount(material_instances_buffer);
u64 grids_count = GPU_GetBufferCount(grids_buffer);
GPU_CommandList *cl = GPU_BeginCommandList(gpu_render_queue);
{
__profn("Run render");
GPU_ProfN(cl, Lit("Run render"));
Mat4x4 world_to_render_vp_matrix = ProjectMat4x4View(g->world_to_render_xf, render_viewport.width, render_viewport.height);
Mat4x4 ui_vp_matrix = ProjectMat4x4View(XformIdentity, ui_viewport.width, ui_viewport.height);
Mat4x4 blit_vp_matrix = ZI;
{
Xform xf = g->render_to_ui_xf;
xf = ScaleXform(xf, VEC2(g->render_size.x, g->render_size.y));
xf = TranslateXform(xf, VEC2(0.5, 0.5));
blit_vp_matrix = ProjectMat4x4View(xf, ui_viewport.width, ui_viewport.height);
}
//- Prep material pass
{
__profn("Clear gbuffers");
GPU_ProfN(cl, Lit("Clear gbuffers"));
GPU_TransitionToRenderable(cl, g->albedo, 0);
GPU_TransitionToRenderable(cl, g->emittance, 1);
GPU_ClearRenderable(cl, g->albedo);
GPU_ClearRenderable(cl, g->emittance);
}
//- Material pass
if (material_instances_count > 0)
{
__profn("Material pass");
GPU_ProfN(cl, Lit("Material pass"));
GPU_Viewport viewport = GPU_ViewportFromRect(render_viewport);
GPU_Scissor scissor = GPU_ScissorFromRect(render_viewport);
PP_MaterialSig sig = ZI;
sig.projection = world_to_render_vp_matrix;
sig.sampler = GPU_SamplerStateRidFromResource(GPU_GetCommonPointSampler());
sig.instances = GPU_StructuredBufferRidFromResource(material_instances_buffer);
sig.grids = GPU_StructuredBufferRidFromResource(grids_buffer);
GPU_Rasterize(cl,
&sig,
PP_MaterialVS, PP_MaterialPS,
2,
viewport,
scissor,
material_instances_count,
GPU_GetCommonQuadIndices(),
GPU_RasterizeMode_TriangleList);
}
//- Prep flood pass
{
GPU_TransitionToReadable(cl, g->emittance);
GPU_TransitionToWritable(cl, g->emittance_flood_read);
GPU_TransitionToWritable(cl, g->emittance_flood_target);
}
//- Flood pass
if (!effects_disabled)
{
__profn("Flood pass");
GPU_ProfN(cl, Lit("Flood pass"));
i32 step_length = -1;
/* TODO: Remove this */
u64 max_steps = GetGstat(GSTAT_DEBUG_STEPS);
u64 step = 0;
while (step_length != 0 && step < max_steps)
{
__profn("Flood step");
GPU_ProfN(cl, Lit("Flood step"));
GPU_FlushWritable(cl, g->emittance_flood_read);
PP_FloodSig sig = ZI;
sig.step_len = step_length;
sig.emittance = GPU_Texture2DRidFromResource(g->emittance);
sig.read = GPU_RWTexture2DRidFromResource(g->emittance_flood_read);
sig.target = GPU_RWTexture2DRidFromResource(g->emittance_flood_target);
sig.tex_width = g->render_size.x;
sig.tex_height = g->render_size.y;
GPU_Compute(cl, &sig, PP_FloodCS, (g->render_size.x + 7) / 8, (g->render_size.y + 7) / 8, 1);
/* Swap buffers */
GPU_Resource *swp = g->emittance_flood_read;
g->emittance_flood_read = g->emittance_flood_target;
g->emittance_flood_target = swp;
/* Update step */
if (step_length == -1)
{
step_length = MaxI32(g->render_size.x, g->render_size.y) / 2;
}
else
{
step_length /= 2;
}
++step;
}
}
//- Prep shade pass
{
__profn("Clear shade target");
GPU_ProfN(cl, Lit("Clear shade target"));
GPU_TransitionToReadable(cl, g->albedo);
GPU_TransitionToReadable(cl, g->emittance);
GPU_TransitionToWritable(cl, g->shade_target);
GPU_FlushWritable(cl, g->emittance_flood_read);
GPU_FlushWritable(cl, g->shade_read);
}
//- Shade pass
{
__profn("Shade pass");
GPU_ProfN(cl, Lit("Shade pass"));
Vec3I32 noise_size = GPU_GetTextureSize3D(GPU_GetCommonNoise());
u32 shade_flags = PP_ShadeFlag_None | PP_ShadeFlag_ToneMap;
if (effects_disabled)
{
shade_flags |= PP_ShadeFlag_DisableEffects;
}
PP_ShadeSig sig = ZI;
sig.flags = shade_flags;
sig.tex_width = g->render_size.x;
sig.tex_height = g->render_size.y;
sig.exposure = 2.0;
sig.frame_seed = VEC4U32((u32)(RandU64FromState(&g->frame_rand) & 0xFFFFFFFF),
(u32)(RandU64FromState(&g->frame_rand) & 0xFFFFFFFF),
(u32)(RandU64FromState(&g->frame_rand) & 0xFFFFFFFF),
(u32)(RandU64FromState(&g->frame_rand) & 0xFFFFFFFF));
sig.frame_index = g->frame_index;
sig.camera_offset = g->world_to_render_xf.og;
sig.noise = GPU_Texture3DRidFromResource(GPU_GetCommonNoise());
sig.albedo = GPU_Texture2DRidFromResource(g->albedo);
sig.emittance = GPU_Texture2DRidFromResource(g->emittance);
sig.emittance_flood = GPU_Texture2DRidFromResource(g->emittance_flood_read);
sig.read = GPU_Texture2DRidFromResource(g->shade_read);
sig.target = GPU_RWTexture2DRidFromResource(g->shade_target);
sig.noise_tex_width = noise_size.x;
sig.noise_tex_height = noise_size.y;
sig.noise_tex_depth = noise_size.z;
GPU_Compute(cl, &sig, PP_ShadeCS, (g->render_size.x + 7) / 8, (g->render_size.y + 7) / 8, 1);
/* Swap */
GPU_Resource *swp = g->shade_read;
g->shade_read = g->shade_target;
g->shade_target = swp;
}
//- Transition target to readable before UI pass
GPU_TransitionToReadable(cl, g->shade_read);
GPU_TransitionToReadable(cl, g->shade_target);
}
g->gpu_submit_fence_target = GPU_EndCommandList(cl);
/* Reset render data */
GPU_ResetTransientBuffer(&g->material_instances_tbuff, g->gpu_submit_fence_target);
GPU_ResetTransientBuffer(&g->grids_tbuff, g->gpu_submit_fence_target);
ResetArena(g->material_instances_arena);
ResetArena(g->grids_arena);
}
/* Set root background texture to game texture */
{
Xform ui_to_render_xf = InvertXform(g->render_to_ui_xf);
Vec2 p0 = MulXformV2(ui_to_render_xf, VEC2(0, 0));
Vec2 p1 = MulXformV2(ui_to_render_xf, Vec2FromFields(g->ui_size));
Vec2 uv0 = DivVec2Vec2(p0, Vec2FromFields(g->render_size));
Vec2 uv1 = DivVec2Vec2(p1, Vec2FromFields(g->render_size));
UI_SetBackgroundTexture(pp_root_box, g->shade_read, uv0, uv1);
}
//////////////////////////////
//- End frame
g->gpu_submit_fence_target = UI_EndFrame(ui_frame);
++g->user_tick;
EndScratch(scratch);
}
////////////////////////////////////////////////////////////
//~ User update job
JobDef(PP_UpdateUserOrSleep, UNUSED sig, UNUSED key)
{
PP_SharedUserState *g = &PP_shared_user_state;
i64 time_ns = TimeNs();
while (!Atomic32Fetch(&g->shutdown))
{
u32 fps_limit = FPS_LIMIT;
if (fps_limit > 0)
{
__profn("User frame limit");
P_SleepFrame(time_ns, 1000000000 / fps_limit);
time_ns = TimeNs();
}
PP_UpdateUser();
}
}
////////////////////////////////////////////////////////////
//~ Generate user input cmds
void PP_GenerateuserInputCmds(PP_Client *user_input_client, u64 tick)
{
PP_SharedUserState *g = &PP_shared_user_state;
PP_Snapshot *prev_user_input_ss = PP_SnapshotFromTick(user_input_client, user_input_client->last_tick);
PP_Snapshot *user_input_ss = PP_AcquireSnapshot(user_input_client, prev_user_input_ss, tick);
PP_Ent *user_input_root = PP_EntFromKey(user_input_ss, PP_RootEntKey);
/* Find / create local control cmd ent */
PP_Ent *control_cmd = PP_FirstWithProp(user_input_ss, PP_Prop_Cmd);
if (!control_cmd->valid)
{
control_cmd = PP_AcquireSyncSrcEnt(user_input_root);
control_cmd->cmd_kind = PP_CmdKind_Control;
control_cmd->predictor = user_input_client->player_id;
PP_EnableProp(control_cmd, PP_Prop_Cmd);
PP_ActivateEnt(control_cmd, user_input_ss->tick);
}
{
Lock lock = LockE(&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)
{
PP_Ent *chat_cmd = PP_AcquireSyncSrcEnt(user_input_root);
chat_cmd->cmd_kind = PP_CmdKind_Chat;
//chat_cmd->chat_msg = ZI
}
#endif
++g->user_sim_cmd_gen;
Unlock(&lock);
}
}
////////////////////////////////////////////////////////////
//~ Sim update
JobDef(PP_UpdateSim, UNUSED sig, UNUSED key)
{
PP_SharedUserState *g = &PP_shared_user_state;
#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);
//N_Host *host = N_AcquireHost();
/* 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;
N_Host *host;
if (g->connect_address_str.len > 0)
{
host = N_AcquireHost(0);
P_Address addr = P_AddressFromString(g->connect_address_str);
N_Connect(host, addr);
}
else
{
host = N_AcquireHost(12345);
is_master = 1;
}
BB_Buff msg_writer_bb = BB_AcquireBuff(Gibi(64));
BB_Buff snapshot_writer_bb = BB_AcquireBuff(Gibi(64));
PP_Accel accel = PP_AcquireAccel();
PP_ClientStore *store = PP_AcquireClientStore();
PP_Client *user_input_client = PP_AcquireClient(store); /* Stores snapshots containing commands to be published to local client */
PP_Client *local_client = PP_AcquireClient(store); /* Stores snapshots produced locally */
PP_Client *publish_client = PP_AcquireClient(store); /* Stores versions of local snapshots that will be published to remote sims */
PP_Client *master_client = PP_NilClient(); /* Stores snapshots received from master */
PP_Client *master_blended_client = PP_NilClient(); /* 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 = NsFromSeconds(1) / SIM_TICKS_PER_SECOND;
f64 compute_timescale = 1.0;
while (!Atomic32Fetch(&g->shutdown))
{
TempArena scratch = BeginScratchNoConflict();
{
__profn("Sim sleep");
P_SleepFrame(real_time_ns, step_dt_ns * compute_timescale);
}
{
__profn("Sim update");
real_dt_ns = TimeNs() - real_time_ns;
real_time_ns += real_dt_ns;
N_EventList host_events = N_BeginUpdate(scratch.arena, host);
/* Read net messages */
PP_DecodeQueue queue = ZI;
{
for (N_Event *event = host_events.first; event; event = event->next)
{
N_ChannelId channel_id = event->channel_id;
PP_Client *client = PP_ClientFromChannelId(store, channel_id);
switch (event->kind)
{
case N_EventKind_ChannelOpened:
{
if (!client->valid)
{
if (is_master)
{
/* Create remote client */
client = PP_AcquireClient(store);
PP_SetClientChannelId(client, channel_id);
}
else
{
/* Create master client */
if (!master_client->valid)
{
client = PP_AcquireClient(store);
PP_SetClientChannelId(client, channel_id);
master_client = client;
master_blended_client = PP_AcquireClient(store);
}
else
{
/* We already have a master client */
Assert(0);
}
}
}
} break;
case N_EventKind_Msg:
{
if (client->valid)
{
BB_Buff msg_bb = BB_BuffFromString(event->msg);
BB_Reader msg_br = BB_ReaderFromBuff(&msg_bb);
u64 ack = BB_ReadUV(&msg_br);
u64 double_ack = BB_ReadUV(&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 = BB_ReadUV(&msg_br);
while (tmp_encoded_len > 0)
{
u8 *tmp_encoded_bytes = BB_ReadBytesRaw(&msg_br, tmp_encoded_len);
if (!tmp_encoded_bytes) break;
BB_Buff decoder_bb = BB_BuffFromString(STRING(tmp_encoded_len, tmp_encoded_bytes));
BB_Reader decoder_br = BB_ReaderFromBuff(&decoder_bb);
u64 base_tick = BB_ReadUV(&decoder_br);
u64 tick = BB_ReadUV(&decoder_br);
String tmp_encoded = ZI;
tmp_encoded.len = BB_NumBytesRemaining(&decoder_br);
tmp_encoded.text = BB_ReadBytesRaw(&decoder_br, tmp_encoded.len);
if (!tmp_encoded.text) tmp_encoded.len = 0;
PP_Snapshot *base_ss = PP_SnapshotFromTick(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)
{
PP_DecodeQueueNode *node = PushStruct(scratch.arena, PP_DecodeQueueNode);
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)
{
PP_DecodeQueueNode *node = queue.first ? queue.first : PushStruct(scratch.arena, PP_DecodeQueueNode);
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 = NsFromSeconds(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 = BB_ReadUV(&msg_br);
}
}
} break;
default: break;
}
}
}
/* Decode incoming snapshots */
for (PP_DecodeQueueNode *n = queue.first; n; n = n->next)
{
PP_Client *client = n->client;
u64 base_tick = n->base_tick;
u64 tick = n->tick;
PP_Snapshot *base_ss = PP_SnapshotFromTick(client, base_tick);
if (base_ss->tick == base_tick)
{
BB_Buff bb = BB_BuffFromString(n->tmp_encoded);
BB_Reader br = BB_ReaderFromBuff(&bb);
/* Acquire & decode snapshot */
PP_Snapshot *ss = PP_AcquireSnapshot(client, base_ss, tick);
PP_DecodeSnapshot(&br, ss);
/* Assume all incoming ents want to be sync srcs */
for (u64 i = 0; i < ss->num_ents_reserved; ++i)
{
PP_Ent *ent = &ss->ents[i];
if (ent->valid && PP_HasProp(ent, PP_Prop_SyncDst))
{
PP_DisableProp(ent, PP_Prop_SyncDst);
PP_EnableProp(ent, PP_Prop_SyncSrc);
}
}
}
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 = !Atomic32Fetch(&g->user_paused);
if (Atomic32Fetch(&g->user_paused_steps) > 0)
{
should_step = 1;
Atomic32FetchAdd(&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)
{
PP_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 = N_GetChannelLastRttNs(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 = MinU64(client->double_ack, local_client->last_tick);
if (keep_tick > 0)
{
PP_ReleaseSnapshotsInRange(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;
}
PP_ReleaseSnapshotsInRange(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;
PP_ReleaseSnapshotsInRange(local_client, 0, keep_tick);
}
}
/* Release unneeded user input snapshots */
PP_ReleaseSnapshotsInRange(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;
PP_SimStepCtx 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;
PP_Snapshot *prev_world = PP_SnapshotFromTick(local_client, prev_tick);
ctx.world = PP_AcquireSnapshot(local_client, prev_world, next_tick);
PP_GenerateuserInputCmds(user_input_client, next_tick);
PP_StepSim(&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;
PP_Snapshot *master_ss = PP_NilSnapshot();
{
/* 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. */
PP_Snapshot *newest_snapshot = PP_SnapshotFromTick(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 > NsFromSeconds(0.100) || blend_time_target_diff_ns < NsFromSeconds(-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 */
PP_Snapshot *left_snapshot = PP_NilSnapshot();
PP_Snapshot *right_snapshot = newest_snapshot;
{
PP_Snapshot *ss = PP_SnapshotFromTick(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 = PP_SnapshotFromTick(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 = PP_AcquireSnapshotFromLerp(master_blended_client, left_snapshot, right_snapshot, blend);
/* Release unneeded blended master snapshots */
if (master_ss->tick > 0)
{
PP_ReleaseSnapshotsInRange(master_blended_client, 0, master_ss->tick - 1);
PP_ReleaseSnapshotsInRange(master_blended_client, master_ss->tick + 1, U64Max);
}
}
}
else
{
master_ss_is_blended = 0;
master_ss = left_snapshot->valid ? left_snapshot : right_snapshot;
}
/* Release unneeded master snapshots */
u64 keep_master_tick = MinU64(left_snapshot->tick, master_client->double_ack);
if (keep_master_tick > 0)
{
PP_ReleaseSnapshotsInRange(master_client, 0, keep_master_tick - 1);
}
#if 0
DEBUGBREAKABLE;
LogDebugF("*************************************************");
LogDebugF("local_client->last_tick: %F", FmtUint(local_client->last_tick));
LogDebugF("master_sim_predicted_time_ns: %F", FmtSint(master_sim_predicted_time_ns));
LogDebugF("tick_progress: %F", FmtFloat(tick_progress));
LogDebugF("sim_publish_timescale: %F", FmtFloat(sim_publish_timescale));
LogDebugF("last_tick_from_master_received_at_ns: %F", FmtSint(last_tick_from_master_received_at_ns));
LogDebugF("average_master_receive_dt_ns: %F", FmtSint(average_master_receive_dt_ns));
LogDebugF("next_tick_expected_ns: %F", FmtSint(next_tick_expected_ns));
LogDebugF("master_blend_time_target_ns: %F", FmtSint(master_blend_time_target_ns));
LogDebugF("blend_time_target_diff_ns: %F", FmtSint(blend_time_target_diff_ns));
LogDebugF("master_blend_time_ns: %F", FmtSint(master_blend_time_ns));
LogDebugF("left_snapshot->tick: %F", FmtUint(left_snapshot->tick));
LogDebugF("right_snapshot->tick: %F", FmtUint(right_snapshot->tick));
LogDebugF("master_ss->tick: %F", FmtUint(master_ss->tick));
#endif
}
if (master_ss->valid)
{
PP_Ent *master_player = PP_FirstWithProp(master_ss, PP_Prop_IsMaster);
/* Update ent key 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 = RoundF64ToI64(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 */
PP_Snapshot *base_ss = PP_SnapshotFromTick(local_client, step_base_tick);
if (mispredicted_tick)
{
if (base_ss->valid)
{
PP_SyncSnapshotEnts(base_ss, master_ss, master_player->key, 0);
}
else
{
base_ss = PP_AcquireSnapshot(local_client, master_ss, step_base_tick);
}
}
/* Release any existing ticks that are about to be simulated */
PP_ReleaseSnapshotsInRange(local_client, step_base_tick + 1, U64Max);
/* Step */
PP_GenerateuserInputCmds(user_input_client, step_end_tick);
{
PP_SimStepCtx 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;
PP_Snapshot *prev_ss = base_ss;
while (step_tick <= step_end_tick)
{
ctx.world = PP_AcquireSnapshot(local_client, prev_ss, step_tick);
if (!mispredicted_tick && step_tick == step_end_tick)
{
PP_SyncSnapshotEnts(ctx.world, master_ss, master_player->key, PP_SyncFlag_NoSyncPredictables);
}
PP_StepSim(&ctx);
prev_ss = ctx.world;
++step_tick;
}
}
}
}
/* Publish snapshot to remote clients */
for (u64 i = 0; i < store->num_clients_reserved; ++i)
{
PP_Client *client = &store->clients[i];
if (client->valid && client != user_input_client && client != local_client && client != publish_client)
{
BB_Writer msg_bw = BB_WriterFromBuff(&msg_writer_bb);
BB_WriteUV(&msg_bw, client->highest_received_tick); /* ack */
BB_WriteUV(&msg_bw, client->ack); /* double ack */
PP_Snapshot *base_ss = PP_SnapshotFromTick(publish_client, client->ack);
PP_Snapshot *publish_ss;
if (client == master_client)
{
/* If sending to master, start sending all snapshots since last ack */
publish_ss = PP_SnapshotFromClosestTickGte(publish_client, base_ss->tick + 1);
}
else
{
/* If sending to slave, only send latest snapshot */
publish_ss = PP_SnapshotFromTick(publish_client, publish_client->last_tick);
}
while (publish_ss->valid)
{
BB_Writer snapshot_bw = BB_WriterFromBuff(&snapshot_writer_bb);
String tmp_snapshot_encoded = ZI;
{
BB_WriteUV(&snapshot_bw, base_ss->tick);
BB_WriteUV(&snapshot_bw, publish_ss->tick);
PP_EncodeSnapshot(&snapshot_bw, client, base_ss, publish_ss);
tmp_snapshot_encoded.len = BB_GetNumBytesWritten(&snapshot_bw);
tmp_snapshot_encoded.text = BB_GetWrittenRaw(&snapshot_bw);
}
BB_WriteUV(&msg_bw, tmp_snapshot_encoded.len);
BB_WriteBytes(&msg_bw, tmp_snapshot_encoded);
publish_ss = PP_SnapshotFromTick(publish_client, publish_ss->tick + 1);
}
BB_WriteUV(&msg_bw, 0);
String encoded = ZI;
encoded.len = BB_GetNumBytesWritten(&msg_bw);
encoded.text = BB_GetWrittenRaw(&msg_bw);
N_Write(host, client->channel_id, encoded, 0);
}
}
/* Copy local snapshot to user client */
{
PP_Snapshot *local_ss = PP_SnapshotFromTick(local_client, local_client->last_tick);
if (local_ss->valid)
{
/* TODO: Double buffer */
Lock lock = LockE(&g->local_to_user_client_mutex);
PP_AcquireSnapshot(g->local_to_user_client, local_ss, local_ss->tick);
i64 publish_ns = TimeNs();
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;
PP_ReleaseSnapshotsInRange(g->local_to_user_client, 0, local_ss->tick - 1);
Unlock(&lock);
}
}
skip_step:
/* Send host messages */
N_EndUpdate(host);
__profframe("Local sim");
EndScratch(scratch);
}
}
#if 0
PP_ReleaseClientStore(store);
PP_ReleaseAccel(&accel);
BB_ReleaseBuff(&snapshot_writer_bb);
BB_ReleaseBuff(&msg_writer_bb);
N_ReleaseHost(host);
#endif
}
Reference in New Issue View Git Blame Copy Permalink