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

pp refactor progress

Browse Source
This commit is contained in:
jacob 2025-08-05 16:14:39 -05:00
parent bb300b9ef4
commit b25bd21b72
7 changed files with 751 additions and 744 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
src/pp/pp_core.c
View File

@ -97,7 +97,7 @@ void DrawDebugMovement(Entity *ent)
u32 color_vel = ColorOrange; u32 color_vel = ColorOrange;
Xform xf = sim_ent_get_xform(ent); Xform xf = XformFromEntity(ent);
Vec2 velocity = ent->linear_velocity; Vec2 velocity = ent->linear_velocity;
Vec2 pos = MulXformV2(g->world_to_ui_xf, xf.og); Vec2 pos = MulXformV2(g->world_to_ui_xf, xf.og);
@ -122,8 +122,8 @@ String DebugStringFromEntity(Arena *arena, Entity *ent)
//result.len += StringFormat(arena, Lit("[%F]"), FmtUid(ent->id.uid)).len; //result.len += StringFormat(arena, Lit("[%F]"), FmtUid(ent->id.uid)).len;
{ {
b32 transmitting = sim_ent_has_prop(ent, Prop_SyncSrc); b32 transmitting = HasProp(ent, Prop_SyncSrc);
b32 receiving = sim_ent_has_prop(ent, Prop_SyncDst); b32 receiving = HasProp(ent, Prop_SyncDst);
if (transmitting & receiving) if (transmitting & receiving)
{ {
result.len += PushString(arena, Lit(" networked (sending & receiving)")).len; result.len += PushString(arena, Lit(" networked (sending & receiving)")).len;
@ -166,12 +166,12 @@ String DebugStringFromEntity(Arena *arena, Entity *ent)
result.len += PushString(arena, Lit("\n")).len; result.len += PushString(arena, Lit("\n")).len;
} }
if (!sim_ent_id_eq(ent->parent, SIM_ENT_ROOT_ID)) if (!EqEntityId(ent->parent, RootEntityId))
{ {
result.len += StringFormat(arena, Lit("parent: [%F]\n"), FmtUid(ent->parent.uid)).len; result.len += StringFormat(arena, Lit("parent: [%F]\n"), FmtUid(ent->parent.uid)).len;
} }
if (!sim_ent_id_is_nil(ent->next) || !sim_ent_id_is_nil(ent->prev)) if (!IsNilEntityId(ent->next) || !IsNilEntityId(ent->prev))
{ {
result.len += StringFormat(arena, Lit("prev: [%F]\n"), FmtUid(ent->prev.uid)).len; result.len += StringFormat(arena, Lit("prev: [%F]\n"), FmtUid(ent->prev.uid)).len;
result.len += StringFormat(arena, Lit("next: [%F]\n"), FmtUid(ent->next.uid)).len; result.len += StringFormat(arena, Lit("next: [%F]\n"), FmtUid(ent->next.uid)).len;
@ -180,7 +180,7 @@ String DebugStringFromEntity(Arena *arena, Entity *ent)
result.len += PushString(arena, Lit("\n")).len; result.len += PushString(arena, Lit("\n")).len;
/* Pos */ /* Pos */
Xform xf = sim_ent_get_xform(ent); Xform xf = XformFromEntity(ent);
Vec2 linear_velocity = ent->linear_velocity; Vec2 linear_velocity = ent->linear_velocity;
f32 angular_velocity = ent->angular_velocity; f32 angular_velocity = ent->angular_velocity;
result.len += StringFormat(arena, Lit("pos: (%F, %F)\n"), FmtFloat(xf.og.x), FmtFloat(xf.og.y)).len; result.len += StringFormat(arena, Lit("pos: (%F, %F)\n"), FmtFloat(xf.og.x), FmtFloat(xf.og.y)).len;
@ -191,10 +191,10 @@ String DebugStringFromEntity(Arena *arena, Entity *ent)
result.len += StringFormat(arena, Lit("collision dir: (%F, %F)\n"), FmtFloat(ent->collision_dir.x), FmtFloat(ent->collision_dir.y)).len; result.len += StringFormat(arena, Lit("collision dir: (%F, %F)\n"), FmtFloat(ent->collision_dir.x), FmtFloat(ent->collision_dir.y)).len;
/* Children */ /* Children */
if (!sim_ent_id_is_nil(ent->first) || !sim_ent_id_is_nil(ent->last)) if (!IsNilEntityId(ent->first) || !IsNilEntityId(ent->last))
{ {
Entity *child = sim_ent_from_id(ss, ent->first); Entity *child = EntityFromId(ss, ent->first);
if (!sim_ent_id_eq(ent->first, ent->last) || !child->valid) if (!EqEntityId(ent->first, ent->last) || !child->valid)
{ {
result.len += StringFormat(arena, Lit("first child: [%F]\n"), FmtUid(ent->first.uid)).len; result.len += StringFormat(arena, Lit("first child: [%F]\n"), FmtUid(ent->first.uid)).len;
result.len += StringFormat(arena, Lit("last child: [%F]\n"), FmtUid(ent->last.uid)).len; result.len += StringFormat(arena, Lit("last child: [%F]\n"), FmtUid(ent->last.uid)).len;
@ -205,7 +205,7 @@ String DebugStringFromEntity(Arena *arena, Entity *ent)
result.len += PushString(arena, Lit("CHILD\n")).len; result.len += PushString(arena, Lit("CHILD\n")).len;
String child_text = DebugStringFromEntity(scratch.arena, child); String child_text = DebugStringFromEntity(scratch.arena, child);
result.len += IndentString(arena, child_text, 4).len; result.len += IndentString(arena, child_text, 4).len;
child = sim_ent_from_id(ss, child->next); child = EntityFromId(ss, child->next);
} }
} }
@ -365,8 +365,8 @@ MergesortCompareFuncDef(EntitySortCmp, arg_a, arg_b, _)
if (result == 0) if (result == 0)
{ {
/* Sort by light */ /* Sort by light */
b32 a_cmp = sim_ent_has_prop(a, Prop_LightTest); b32 a_cmp = HasProp(a, Prop_LightTest);
b32 b_cmp = sim_ent_has_prop(b, Prop_LightTest); b32 b_cmp = HasProp(b, Prop_LightTest);
result = (a_cmp > b_cmp) - (a_cmp < b_cmp); result = (a_cmp > b_cmp) - (a_cmp < b_cmp);
} }
if (result == 0) if (result == 0)
@ -616,13 +616,13 @@ void UpdateUser(P_Window *window)
//- Find local entities //- Find local entities
Entity *local_player = sim_ent_from_id(g->ss_blended, g->ss_blended->local_player); Entity *local_player = EntityFromId(g->ss_blended, g->ss_blended->local_player);
Entity *local_control = sim_ent_from_id(g->ss_blended, local_player->player_control_ent); Entity *local_control = EntityFromId(g->ss_blended, local_player->player_control_ent);
Entity *local_camera = sim_ent_from_id(g->ss_blended, local_player->player_camera_ent); Entity *local_camera = EntityFromId(g->ss_blended, local_player->player_camera_ent);
//- Find hovered entity //- Find hovered entity
Entity *hovered_ent = sim_ent_nil(); Entity *hovered_ent = NilEntity();
{ {
Xform mouse_xf = XformFromPos(g->world_cursor); Xform mouse_xf = XformFromPos(g->world_cursor);
CLD_Shape mouse_shape = ZI; CLD_Shape mouse_shape = ZI;
@ -632,17 +632,17 @@ void UpdateUser(P_Window *window)
for (u64 ent_index = 0; ent_index < g->ss_blended->num_ents_reserved; ++ent_index) for (u64 ent_index = 0; ent_index < g->ss_blended->num_ents_reserved; ++ent_index)
{ {
Entity *ent = &g->ss_blended->ents[ent_index]; Entity *ent = &g->ss_blended->ents[ent_index];
if (!sim_ent_is_valid_and_active(ent)) continue; if (!IsValidAndActive(ent)) continue;
CLD_Shape ent_collider = ent->local_collider; CLD_Shape ent_collider = ent->local_collider;
if (ent_collider.count > 0) if (ent_collider.count > 0)
{ {
/* TODO: Can just use boolean GJK */ /* TODO: Can just use boolean GJK */
Xform ent_xf = sim_ent_get_xform(ent); Xform ent_xf = XformFromEntity(ent);
CLD_CollisionData collision_result = CLD_CollisionDataFromShapes(&ent_collider, &mouse_shape, ent_xf, mouse_xf); CLD_CollisionData collision_result = CLD_CollisionDataFromShapes(&ent_collider, &mouse_shape, ent_xf, mouse_xf);
if (collision_result.num_points > 0) if (collision_result.num_points > 0)
{ {
hovered_ent = sim_ent_from_id(g->ss_blended, ent->top); hovered_ent = EntityFromId(g->ss_blended, ent->top);
break; break;
} }
} }
@ -685,23 +685,23 @@ void UpdateUser(P_Window *window)
{ {
if (g->bind_states[BindKind_DebugFollow].num_presses > 0) if (g->bind_states[BindKind_DebugFollow].num_presses > 0)
{ {
if (sim_ent_id_is_nil(g->debug_following)) if (IsNilEntityId(g->debug_following))
{ {
g->debug_following = hovered_ent->id; g->debug_following = hovered_ent->id;
} }
else else
{ {
g->debug_following = SIM_ENT_NIL_ID; g->debug_following = NilEntityId;
} }
} }
if (!sim_ent_id_is_nil(g->debug_following)) if (!IsNilEntityId(g->debug_following))
{ {
Entity *follow_ent = sim_ent_from_id(g->ss_blended, g->debug_following); Entity *follow_ent = EntityFromId(g->ss_blended, g->debug_following);
Entity *follow_camera = sim_ent_nil(); Entity *follow_camera = NilEntity();
for (u64 i = 0; i < g->ss_blended->num_ents_reserved; ++i) for (u64 i = 0; i < g->ss_blended->num_ents_reserved; ++i)
{ {
Entity *ent = &g->ss_blended->ents[i]; Entity *ent = &g->ss_blended->ents[i];
Entity *ent_camera_follow = sim_ent_from_id(g->ss_blended, ent->camera_follow); Entity *ent_camera_follow = EntityFromId(g->ss_blended, ent->camera_follow);
if (ent_camera_follow->valid && ent_camera_follow == follow_ent) if (ent_camera_follow->valid && ent_camera_follow == follow_ent)
{ {
follow_camera = ent; follow_camera = ent;
@ -714,7 +714,7 @@ void UpdateUser(P_Window *window)
} }
else else
{ {
g->debug_following = SIM_ENT_NIL_ID; g->debug_following = NilEntityId;
} }
} }
} }
@ -724,7 +724,7 @@ void UpdateUser(P_Window *window)
for (u64 ent_index = 0; ent_index < g->ss_blended->num_ents_reserved; ++ent_index) for (u64 ent_index = 0; ent_index < g->ss_blended->num_ents_reserved; ++ent_index)
{ {
Entity *ent = &g->ss_blended->ents[ent_index]; Entity *ent = &g->ss_blended->ents[ent_index];
if (!sim_ent_is_valid_and_active(ent)) continue; if (!IsValidAndActive(ent)) continue;
/* How much time between camera shakes */ /* How much time between camera shakes */
i64 frequency_ns = NsFromSeconds(0.01f); i64 frequency_ns = NsFromSeconds(0.01f);
@ -744,9 +744,9 @@ void UpdateUser(P_Window *window)
f32 blend = (f32)(g->ss_blended->sim_time_ns % frequency_ns) / (f32)frequency_ns; f32 blend = (f32)(g->ss_blended->sim_time_ns % frequency_ns) / (f32)frequency_ns;
Vec2 vec = LerpVec2(vec0, vec1, blend); Vec2 vec = LerpVec2(vec0, vec1, blend);
Xform xf = sim_ent_get_xform(ent); Xform xf = XformFromEntity(ent);
xf.og = AddVec2(xf.og, MulVec2(vec, shake)); xf.og = AddVec2(xf.og, MulVec2(vec, shake));
sim_ent_set_xform(ent, xf); SetEntityXform(ent, xf);
} }
} }
@ -764,7 +764,7 @@ void UpdateUser(P_Window *window)
f32 aspect_ratio = (f32)(DEFAULT_CAMERA_WIDTH / DEFAULT_CAMERA_HEIGHT); f32 aspect_ratio = (f32)(DEFAULT_CAMERA_WIDTH / DEFAULT_CAMERA_HEIGHT);
if (local_camera->valid) if (local_camera->valid)
{ {
Xform quad_xf = MulXform(sim_ent_get_xform(local_camera), local_camera->camera_quad_xform); Xform quad_xf = MulXform(XformFromEntity(local_camera), local_camera->camera_quad_xform);
Vec2 camera_size = ScaleFromXform(quad_xf); Vec2 camera_size = ScaleFromXform(quad_xf);
if (!IsVec2Zero(camera_size)) if (!IsVec2Zero(camera_size))
{ {
@ -833,7 +833,7 @@ void UpdateUser(P_Window *window)
} }
else else
{ {
Xform xf = sim_ent_get_xform(local_camera); Xform xf = XformFromEntity(local_camera);
Vec2 world_center = xf.og; Vec2 world_center = xf.og;
f32 rot = RotationFromXform(xf); f32 rot = RotationFromXform(xf);
@ -937,7 +937,7 @@ void UpdateUser(P_Window *window)
for (u64 ent_index = 0; ent_index < g->ss_blended->num_ents_reserved; ++ent_index) for (u64 ent_index = 0; ent_index < g->ss_blended->num_ents_reserved; ++ent_index)
{ {
Entity *chunk_ent = &g->ss_blended->ents[ent_index]; Entity *chunk_ent = &g->ss_blended->ents[ent_index];
if (sim_ent_is_valid_and_active(chunk_ent) && sim_ent_has_prop(chunk_ent, Prop_TileChunk)) if (IsValidAndActive(chunk_ent) && HasProp(chunk_ent, Prop_TileChunk))
{ {
struct user_tile_cache_entry *entry = user_tile_cache_entry_from_chunk_pos(chunk_ent->tile_chunk_pos); struct user_tile_cache_entry *entry = user_tile_cache_entry_from_chunk_pos(chunk_ent->tile_chunk_pos);
if (!entry->valid) if (!entry->valid)
@ -1049,7 +1049,7 @@ void UpdateUser(P_Window *window)
for (u64 ent_index = 0; ent_index < g->ss_blended->num_ents_reserved; ++ent_index) for (u64 ent_index = 0; ent_index < g->ss_blended->num_ents_reserved; ++ent_index)
{ {
Entity *ent = &g->ss_blended->ents[ent_index]; Entity *ent = &g->ss_blended->ents[ent_index];
if (sim_ent_is_valid_and_active(ent)) if (IsValidAndActive(ent))
{ {
*PushStructNoZero(scratch.arena, Entity *) = ent; *PushStructNoZero(scratch.arena, Entity *) = ent;
++sorted_count; ++sorted_count;
@ -1070,20 +1070,20 @@ void UpdateUser(P_Window *window)
for (u64 sorted_index = 0; sorted_index < sorted_count; ++sorted_index) for (u64 sorted_index = 0; sorted_index < sorted_count; ++sorted_index)
{ {
Entity *ent = sorted[sorted_index]; Entity *ent = sorted[sorted_index];
if (!sim_ent_is_valid_and_active(ent)) continue; if (!IsValidAndActive(ent)) continue;
//if (S_IsTagNil(ent->sprite)) continue; //if (S_IsTagNil(ent->sprite)) continue;
S_Tag sprite = ent->sprite; S_Tag sprite = ent->sprite;
Entity *parent = sim_ent_from_id(g->ss_blended, ent->parent); Entity *parent = EntityFromId(g->ss_blended, ent->parent);
Xform xf = sim_ent_get_xform(ent); Xform xf = XformFromEntity(ent);
Xform parent_xf = sim_ent_get_xform(parent); Xform parent_xf = XformFromEntity(parent);
b32 skip_debug_draw = !g->debug_camera && ent == local_camera; b32 skip_debug_draw = !g->debug_camera && ent == local_camera;
skip_debug_draw = skip_debug_draw || sim_ent_has_prop(ent, Prop_MotorJoint); skip_debug_draw = skip_debug_draw || HasProp(ent, Prop_MotorJoint);
b32 skip_debug_draw_transform = sim_ent_has_prop(ent, Prop_Camera); b32 skip_debug_draw_transform = HasProp(ent, Prop_Camera);
skip_debug_draw_transform = 1; skip_debug_draw_transform = 1;
Xform sprite_xform = MulXform(xf, ent->sprite_local_xform); Xform sprite_xform = MulXform(xf, ent->sprite_local_xform);
@ -1091,7 +1091,7 @@ void UpdateUser(P_Window *window)
/* Draw tracer */ /* Draw tracer */
/* TODO: Enable this */ /* TODO: Enable this */
#if 0 #if 0
if (sim_ent_has_prop(ent, Prop_Tracer)) if (HasProp(ent, Prop_Tracer))
{ {
Vec2 velocity = ent->tracer_start_velocity; Vec2 velocity = ent->tracer_start_velocity;
@ -1143,7 +1143,7 @@ void UpdateUser(P_Window *window)
/* TODO: Fade in placeholder if texture isn't loaded */ /* TODO: Fade in placeholder if texture isn't loaded */
if (sheet->loaded && texture->loaded) if (sheet->loaded && texture->loaded)
{ {
b32 is_light = sim_ent_has_prop(ent, Prop_LightTest); b32 is_light = HasProp(ent, Prop_LightTest);
Vec3 emittance = ent->sprite_emittance; Vec3 emittance = ent->sprite_emittance;
u32 tint = ent->sprite_tint; u32 tint = ent->sprite_tint;
S_Frame frame = S_FrameFromIndex(sheet, ent->animation_frame); S_Frame frame = S_FrameFromIndex(sheet, ent->animation_frame);
@ -1154,7 +1154,7 @@ void UpdateUser(P_Window *window)
/* Draw tiles */ /* Draw tiles */
/* TODO: Something better */ /* TODO: Something better */
if (sim_ent_has_prop(ent, Prop_TileChunk)) if (HasProp(ent, Prop_TileChunk))
{ {
Vec2I32 chunk_index = ent->tile_chunk_index; Vec2I32 chunk_index = ent->tile_chunk_index;
S_Tag tile_sprite = S_TagFromPath(Lit("sprite/tile.ase")); S_Tag tile_sprite = S_TagFromPath(Lit("sprite/tile.ase"));
@ -1187,7 +1187,7 @@ void UpdateUser(P_Window *window)
{ {
TempArena temp = BeginTempArena(scratch.arena); TempArena temp = BeginTempArena(scratch.arena);
if (sim_ent_has_prop(ent, Prop_Kinematic) || sim_ent_has_prop(ent, Prop_Dynamic)) if (HasProp(ent, Prop_Kinematic) || HasProp(ent, Prop_Dynamic))
{ {
DrawDebugMovement(ent); DrawDebugMovement(ent);
} }
@ -1212,7 +1212,7 @@ void UpdateUser(P_Window *window)
} }
/* Draw focus arrow */ /* Draw focus arrow */
if (ent == local_control || sim_ent_id_eq(ent->id, g->debug_following)) if (ent == local_control || EqEntityId(ent->id, g->debug_following))
{ {
S_Sheet *sheet = S_SheetFromTagAsync(sprite_frame_scope, ent->sprite); S_Sheet *sheet = S_SheetFromTagAsync(sprite_frame_scope, ent->sprite);
S_Slice slice = S_SliceFromNameIndex(sheet, Lit("attach.wep"), ent->animation_frame); S_Slice slice = S_SliceFromNameIndex(sheet, Lit("attach.wep"), ent->animation_frame);
@ -1269,10 +1269,10 @@ void UpdateUser(P_Window *window)
/* Draw weld joint */ /* Draw weld joint */
#if 0 #if 0
if (sim_ent_has_prop(ent, Prop_WeldJoint)) if (HasProp(ent, Prop_WeldJoint))
{ {
Entity *e1 = sim_ent_from_id(g->ss_blended, ent->weld_joint_data.e1); Entity *e1 = EntityFromId(g->ss_blended, ent->weld_joint_data.e1);
Xform e1_xf = sim_ent_get_xform(e1); Xform e1_xf = XformFromEntity(e1);
u32 color = ColorYellow; u32 color = ColorYellow;
f32 radius = 3; f32 radius = 3;
@ -1285,10 +1285,10 @@ void UpdateUser(P_Window *window)
#endif #endif
/* Draw mouse joint */ /* Draw mouse joint */
if (sim_ent_has_prop(ent, Prop_MouseJoint)) if (HasProp(ent, Prop_MouseJoint))
{ {
Entity *target = sim_ent_from_id(g->ss_blended, ent->mouse_joint_data.target); Entity *target = EntityFromId(g->ss_blended, ent->mouse_joint_data.target);
Xform target_xf = sim_ent_get_xform(target); Xform target_xf = XformFromEntity(target);
u32 color = ColorWhite; u32 color = ColorWhite;
Vec2 point_start = MulXformV2(target_xf, ent->mouse_joint_data.point_local_start); Vec2 point_start = MulXformV2(target_xf, ent->mouse_joint_data.point_local_start);
Vec2 point_end = g->world_cursor; Vec2 point_end = g->world_cursor;
@ -1338,11 +1338,11 @@ void UpdateUser(P_Window *window)
} }
/* Draw contact constraint */ /* Draw contact constraint */
if (sim_ent_has_prop(ent, Prop_ContactConstraint)) if (HasProp(ent, Prop_ContactConstraint))
{ {
ContactConstraint *data = &ent->contact_constraint_data; ContactConstraint *data = &ent->contact_constraint_data;
Entity *e0 = sim_ent_from_id(g->ss_blended, data->e0); Entity *e0 = EntityFromId(g->ss_blended, data->e0);
Entity *e1 = sim_ent_from_id(g->ss_blended, data->e1); Entity *e1 = EntityFromId(g->ss_blended, data->e1);
LAX e0; LAX e0;
LAX e1; LAX e1;
@ -1410,12 +1410,12 @@ void UpdateUser(P_Window *window)
/* Draw collision debug */ /* Draw collision debug */
#if COLLIDER_DEBUG #if COLLIDER_DEBUG
if (sim_ent_has_prop(ent, Prop_CollisionDebug)) if (HasProp(ent, Prop_CollisionDebug))
{ {
CollisionDebugData *data = &ent->collision_debug_data; CollisionDebugData *data = &ent->collision_debug_data;
CLD_CollisionData collision_reuslt = data->collision_result; CLD_CollisionData collision_reuslt = data->collision_result;
Entity *e0 = sim_ent_from_id(g->ss_blended, data->e0); Entity *e0 = EntityFromId(g->ss_blended, data->e0);
Entity *e1 = sim_ent_from_id(g->ss_blended, data->e1); Entity *e1 = EntityFromId(g->ss_blended, data->e1);
CLD_Shape e0_collider = e0->local_collider; CLD_Shape e0_collider = e0->local_collider;
CLD_Shape e1_collider = e1->local_collider; CLD_Shape e1_collider = e1->local_collider;
LAX e0_collider; LAX e0_collider;
@ -1610,7 +1610,7 @@ void UpdateUser(P_Window *window)
#endif #endif
/* Draw hierarchy */ /* Draw hierarchy */
if (sim_ent_has_prop(parent, Prop_Active) && !parent->is_root) if (HasProp(parent, Prop_Active) && !parent->is_root)
{ {
u32 color = Rgba32F(0.6, 0.6, 1, 0.75); u32 color = Rgba32F(0.6, 0.6, 1, 0.75);
f32 thickness = 2; f32 thickness = 2;
@ -1622,7 +1622,7 @@ void UpdateUser(P_Window *window)
} }
/* Draw camera rect */ /* Draw camera rect */
if (sim_ent_has_prop(ent, Prop_Camera)) if (HasProp(ent, Prop_Camera))
{ {
u32 color = ent == local_camera ? Rgba32F(1, 1, 1, 0.5) : Rgba32F(0, 0.75, 0, 0.5); u32 color = ent == local_camera ? Rgba32F(1, 1, 1, 0.5) : Rgba32F(0, 0.75, 0, 0.5);
f32 thickness = 3; f32 thickness = 3;
@ -1731,7 +1731,7 @@ void UpdateUser(P_Window *window)
if (!g->debug_camera) if (!g->debug_camera)
{ {
g->focus_send = SubVec2(g->world_cursor, sim_ent_get_xform(local_control).og); g->focus_send = SubVec2(g->world_cursor, XformFromEntity(local_control).og);
} }
Vec2 input_aim_dir = g->focus_send; Vec2 input_aim_dir = g->focus_send;
@ -2084,16 +2084,16 @@ void GenerateuserInputCmds(Client *user_input_client, u64 tick)
SharedUserState *g = &shared_user_state; SharedUserState *g = &shared_user_state;
Snapshot *prev_user_input_ss = sim_snapshot_from_tick(user_input_client, user_input_client->last_tick); Snapshot *prev_user_input_ss = sim_snapshot_from_tick(user_input_client, user_input_client->last_tick);
Snapshot *user_input_ss = sim_snapshot_acquire(user_input_client, prev_user_input_ss, tick); Snapshot *user_input_ss = sim_snapshot_acquire(user_input_client, prev_user_input_ss, tick);
Entity *user_input_root = sim_ent_from_id(user_input_ss, SIM_ENT_ROOT_ID); Entity *user_input_root = EntityFromId(user_input_ss, RootEntityId);
/* Find / create local control cmd ent */ /* Find / create local control cmd ent */
Entity *control_cmd = sim_ent_find_first_match_one(user_input_ss, Prop_Cmd); Entity *control_cmd = FirstEntityWithProp(user_input_ss, Prop_Cmd);
if (!control_cmd->valid) if (!control_cmd->valid)
{ {
control_cmd = sim_ent_acquire_sync_src(user_input_root); control_cmd = AcquireSyncSrcEntity(user_input_root);
control_cmd->cmd_kind = SIM_CMD_KIND_CONTROL; control_cmd->cmd_kind = SIM_CMD_KIND_CONTROL;
control_cmd->predictor = user_input_client->player_id; control_cmd->predictor = user_input_client->player_id;
sim_ent_enable_prop(control_cmd, Prop_Cmd); EnableProp(control_cmd, Prop_Cmd);
sim_ent_activate(control_cmd, user_input_ss->tick); ActivateEntity(control_cmd, user_input_ss->tick);
} }
{ {
Lock lock = LockE(&g->user_sim_cmd_mutex); Lock lock = LockE(&g->user_sim_cmd_mutex);
@ -2106,7 +2106,7 @@ void GenerateuserInputCmds(Client *user_input_client, u64 tick)
/* Create chat cmd */ /* Create chat cmd */
if (g->user_sim_cmd_chat.len > 0) if (g->user_sim_cmd_chat.len > 0)
{ {
Entity *chat_cmd = sim_ent_acquire_sync_src(user_input_root); Entity *chat_cmd = AcquireSyncSrcEntity(user_input_root);
chat_cmd->cmd_kind = SIM_CMD_KIND_CHAT; chat_cmd->cmd_kind = SIM_CMD_KIND_CHAT;
//chat_cmd->chat_msg = ZI //chat_cmd->chat_msg = ZI
} }
@ -2382,10 +2382,10 @@ JobDef(SimJob, UNUSED sig, UNUSED id)
for (u64 i = 0; i < ss->num_ents_reserved; ++i) for (u64 i = 0; i < ss->num_ents_reserved; ++i)
{ {
Entity *ent = &ss->ents[i]; Entity *ent = &ss->ents[i];
if (ent->valid && sim_ent_has_prop(ent, Prop_SyncDst)) if (ent->valid && HasProp(ent, Prop_SyncDst))
{ {
sim_ent_disable_prop(ent, Prop_SyncDst); DisableProp(ent, Prop_SyncDst);
sim_ent_enable_prop(ent, Prop_SyncSrc); EnableProp(ent, Prop_SyncSrc);
} }
} }
} }
@ -2620,7 +2620,7 @@ JobDef(SimJob, UNUSED sig, UNUSED id)
if (master_ss->valid) if (master_ss->valid)
{ {
Entity *master_player = sim_ent_find_first_match_one(master_ss, Prop_IsMaster); Entity *master_player = FirstEntityWithProp(master_ss, Prop_IsMaster);
/* Update ent id from master */ /* Update ent id from master */
{ {

292
src/pp/pp_ent.c
View File

@ -1,7 +1,7 @@
//////////////////////////////// ////////////////////////////////
//~ Acquire //~ Acquire
Entity *sim_ent_acquire_raw(Snapshot *ss, Entity *parent, EntityId id) Entity *AcquireEntityRaw(Snapshot *ss, Entity *parent, EntityId id)
{ {
Assert(parent->valid); Assert(parent->valid);
Assert(ss->valid); Assert(ss->valid);
@ -16,61 +16,61 @@ Entity *sim_ent_acquire_raw(Snapshot *ss, Entity *parent, EntityId id)
ent = PushStructNoZero(ss->ents_arena, Entity); ent = PushStructNoZero(ss->ents_arena, Entity);
++ss->num_ents_reserved; ++ss->num_ents_reserved;
} }
*ent = *sim_ent_nil(); *ent = *NilEntity();
ent->ss = ss; ent->ss = ss;
ent->valid = 1; ent->valid = 1;
ent->owner = ss->client->player_id; ent->owner = ss->client->player_id;
ent->_is_xform_dirty = 1; ent->_is_xform_dirty = 1;
++ss->num_ents_allocated; ++ss->num_ents_allocated;
sim_ent_set_id(ent, id); SetEntityId(ent, id);
sim_ent_link_parent(ent, parent); LinkEntity(ent, parent);
return ent; return ent;
} }
/* Acquires a new entity that will not sync */ /* Acquires a new entity that will not sync */
Entity *sim_ent_acquire_local(Entity *parent) Entity *AcquireLocalEntity(Entity *parent)
{ {
Snapshot *ss = parent->ss; Snapshot *ss = parent->ss;
Entity *e = sim_ent_acquire_raw(ss, parent, sim_ent_random_id()); Entity *e = AcquireEntityRaw(ss, parent, RandomEntityId());
e->owner = ss->local_player; e->owner = ss->local_player;
return e; return e;
} }
Entity *sim_ent_acquire_local_with_id(Entity *parent, EntityId id) Entity *AcquireLocalEntityWithId(Entity *parent, EntityId id)
{ {
Snapshot *ss = parent->ss; Snapshot *ss = parent->ss;
Entity *e = sim_ent_acquire_raw(ss, parent, id); Entity *e = AcquireEntityRaw(ss, parent, id);
e->owner = ss->local_player; e->owner = ss->local_player;
return e; return e;
} }
/* Acquires a new entity to be synced to clients */ /* Acquires a new entity to be synced to clients */
Entity *sim_ent_acquire_sync_src(Entity *parent) Entity *AcquireSyncSrcEntity(Entity *parent)
{ {
Snapshot *ss = parent->ss; Snapshot *ss = parent->ss;
Entity *e = sim_ent_acquire_raw(ss, parent, sim_ent_random_id()); Entity *e = AcquireEntityRaw(ss, parent, RandomEntityId());
sim_ent_enable_prop(e, Prop_SyncSrc); EnableProp(e, Prop_SyncSrc);
e->owner = ss->local_player; e->owner = ss->local_player;
return e; return e;
} }
Entity *sim_ent_acquire_sync_src_with_id(Entity *parent, EntityId id) Entity *AcquireSyncSrcEntityWithId(Entity *parent, EntityId id)
{ {
Snapshot *ss = parent->ss; Snapshot *ss = parent->ss;
Entity *e = sim_ent_acquire_raw(ss, parent, id); Entity *e = AcquireEntityRaw(ss, parent, id);
sim_ent_enable_prop(e, Prop_SyncSrc); EnableProp(e, Prop_SyncSrc);
e->owner = ss->local_player; e->owner = ss->local_player;
return e; return e;
} }
/* Acquires a new entity that will sync with incoming net src ents containing id, and coming from the specified owner */ /* Acquires a new entity that will sync with incoming net src ents containing id, and coming from the specified owner */
Entity *sim_ent_acquire_sync_dst(Entity *parent, EntityId ent_id, EntityId owner_id) Entity *AcquireSyncDstEntity(Entity *parent, EntityId ent_id, EntityId owner_id)
{ {
Snapshot *ss = parent->ss; Snapshot *ss = parent->ss;
Entity *e = sim_ent_acquire_raw(ss, parent, ent_id); Entity *e = AcquireEntityRaw(ss, parent, ent_id);
sim_ent_enable_prop(e, Prop_SyncDst); EnableProp(e, Prop_SyncDst);
e->owner = owner_id; e->owner = owner_id;
return e; return e;
} }
@ -78,38 +78,38 @@ Entity *sim_ent_acquire_sync_dst(Entity *parent, EntityId ent_id, EntityId owner
//////////////////////////////// ////////////////////////////////
//~ Release //~ Release
void sim_ent_release_raw(Entity *ent) void ReleaseEntityRaw(Entity *ent)
{ {
Snapshot *ss = ent->ss; Snapshot *ss = ent->ss;
/* Release children */ /* Release children */
Entity *child = sim_ent_from_id(ss, ent->first); Entity *child = EntityFromId(ss, ent->first);
while (child->valid) { while (child->valid) {
Entity *next = sim_ent_from_id(ss, child->next); Entity *next = EntityFromId(ss, child->next);
sim_ent_release_raw(child); ReleaseEntityRaw(child);
child = next; child = next;
} }
/* Release uid */ /* Release uid */
sim_ent_set_id(ent, SIM_ENT_NIL_ID); SetEntityId(ent, NilEntityId);
/* Release */ /* Release */
ent->valid = 0; ent->valid = 0;
ent->next_free = ss->first_free_ent; ent->next_free = ss->first_free_ent;
ss->first_free_ent = index_from_ent(ss, ent); ss->first_free_ent = IndexFromEntity(ss, ent);
--ss->num_ents_allocated; --ss->num_ents_allocated;
} }
void sim_ent_release(Entity *ent) void ReleaseEntity(Entity *ent)
{ {
Snapshot *ss = ent->ss; Snapshot *ss = ent->ss;
Entity *parent = sim_ent_from_id(ss, ent->parent); Entity *parent = EntityFromId(ss, ent->parent);
if (parent->valid) { if (parent->valid) {
sim_ent_unlink_from_parent(ent); UnlinkEntity(ent);
} }
sim_ent_release_raw(ent); ReleaseEntityRaw(ent);
} }
void sim_ent_release_all_with_prop(Snapshot *ss, Prop prop) void ReleaseAllEntitiesWithProp(Snapshot *ss, Prop prop)
{ {
TempArena scratch = BeginScratchNoConflict(); TempArena scratch = BeginScratchNoConflict();
@ -117,7 +117,7 @@ void sim_ent_release_all_with_prop(Snapshot *ss, Prop prop)
u64 ents_to_release_count = 0; u64 ents_to_release_count = 0;
for (u64 ent_index = 0; ent_index < ss->num_ents_reserved; ++ent_index) { for (u64 ent_index = 0; ent_index < ss->num_ents_reserved; ++ent_index) {
Entity *ent = &ss->ents[ent_index]; Entity *ent = &ss->ents[ent_index];
if (ent->valid && sim_ent_has_prop(ent, prop)) { if (ent->valid && HasProp(ent, prop)) {
*PushStructNoZero(scratch.arena, Entity *) = ent; *PushStructNoZero(scratch.arena, Entity *) = ent;
++ents_to_release_count; ++ents_to_release_count;
} }
@ -128,8 +128,8 @@ void sim_ent_release_all_with_prop(Snapshot *ss, Prop prop)
* child entities will be released along with parent anyway) */ * child entities will be released along with parent anyway) */
for (u64 i = 0; i < ents_to_release_count; ++i) { for (u64 i = 0; i < ents_to_release_count; ++i) {
Entity *ent = ents_to_release[i]; Entity *ent = ents_to_release[i];
if (ent->valid && !ent->is_root && !sim_ent_has_prop(ent, Prop_Cmd) && !sim_ent_has_prop(ent, Prop_Player)) { if (ent->valid && !ent->is_root && !HasProp(ent, Prop_Cmd) && !HasProp(ent, Prop_Player)) {
sim_ent_release(ent); ReleaseEntity(ent);
} }
} }
@ -139,9 +139,9 @@ void sim_ent_release_all_with_prop(Snapshot *ss, Prop prop)
//////////////////////////////// ////////////////////////////////
//~ Activate //~ Activate
void sim_ent_activate(Entity *ent, u64 current_tick) void ActivateEntity(Entity *ent, u64 current_tick)
{ {
sim_ent_enable_prop(ent, Prop_Active); EnableProp(ent, Prop_Active);
ent->activation_tick = current_tick; ent->activation_tick = current_tick;
++ent->continuity_gen; ++ent->continuity_gen;
} }
@ -149,44 +149,44 @@ void sim_ent_activate(Entity *ent, u64 current_tick)
//////////////////////////////// ////////////////////////////////
//~ Entity id //~ Entity id
u32 index_from_ent(Snapshot *ss, Entity *ent) u32 IndexFromEntity(Snapshot *ss, Entity *ent)
{ {
return ent - ss->ents; return ent - ss->ents;
} }
Entity *ent_from_index(Snapshot *ss, u32 index) Entity *EntityFromIndex(Snapshot *ss, u32 index)
{ {
if (index > 0 && index < ss->num_ents_reserved) { if (index > 0 && index < ss->num_ents_reserved) {
return &ss->ents[index]; return &ss->ents[index];
} else { } else {
return sim_ent_nil(); return NilEntity();
} }
} }
EntBin *bin_from_id(Snapshot *ss, EntityId id) EntBin *BinFromEntityId(Snapshot *ss, EntityId id)
{ {
return &ss->id_bins[id.uid.lo % ss->num_id_bins]; return &ss->id_bins[id.uid.lo % ss->num_id_bins];
} }
/* NOTE: This should only really happen during ent allocation (it doesn't make sense for an allocated ent's id to change) */ /* NOTE: This should only really happen during ent allocation (it doesn't make sense for an allocated ent's id to change) */
void sim_ent_set_id(Entity *ent, EntityId id) void SetEntityId(Entity *ent, EntityId id)
{ {
Snapshot *ss = ent->ss; Snapshot *ss = ent->ss;
EntityId old_id = ent->id; EntityId old_id = ent->id;
if (!sim_ent_id_eq(old_id, id)) { if (!EqEntityId(old_id, id)) {
/* Release old from lookup */ /* Release old from lookup */
if (!sim_ent_id_is_nil(old_id)) { if (!IsNilEntityId(old_id)) {
EntBin *bin = bin_from_id(ss, old_id); EntBin *bin = BinFromEntityId(ss, old_id);
u32 prev_index = 0; u32 prev_index = 0;
u32 next_index = 0; u32 next_index = 0;
u32 search_index = bin->first; u32 search_index = bin->first;
Entity *prev = sim_ent_nil(); Entity *prev = NilEntity();
Entity *next = sim_ent_nil(); Entity *next = NilEntity();
Entity *search = ent_from_index(ss, search_index); Entity *search = EntityFromIndex(ss, search_index);
while (search->valid) { while (search->valid) {
next_index = search->next_in_id_bin; next_index = search->next_in_id_bin;
next = ent_from_index(ss, next_index); next = EntityFromIndex(ss, next_index);
if (sim_ent_id_eq(search->id, old_id)) { if (EqEntityId(search->id, old_id)) {
break; break;
} }
prev_index = search_index; prev_index = search_index;
@ -212,18 +212,18 @@ void sim_ent_set_id(Entity *ent, EntityId id)
} }
/* Insert new id into lookup */ /* Insert new id into lookup */
if (!sim_ent_id_is_nil(id)) { if (!IsNilEntityId(id)) {
#if RtcIsEnabled #if RtcIsEnabled
{ {
Entity *existing = sim_ent_from_id(ss, id); Entity *existing = EntityFromId(ss, id);
/* Collision should be extremely unlikely under normal circumstances, there's probably a logic error somewhere. */ /* Collision should be extremely unlikely under normal circumstances, there's probably a logic error somewhere. */
Assert(!existing->valid); Assert(!existing->valid);
} }
#endif #endif
EntBin *bin = bin_from_id(ss, id); EntBin *bin = BinFromEntityId(ss, id);
u32 ent_index = index_from_ent(ss, ent); u32 ent_index = IndexFromEntity(ss, ent);
Entity *last = ent_from_index(ss, bin->last); Entity *last = EntityFromIndex(ss, bin->last);
if (last->valid) { if (last->valid) {
last->next_in_id_bin = ent_index; last->next_in_id_bin = ent_index;
ent->prev_in_id_bin = bin->last; ent->prev_in_id_bin = bin->last;
@ -239,13 +239,13 @@ void sim_ent_set_id(Entity *ent, EntityId id)
} }
Entity *sim_ent_from_id(Snapshot *ss, EntityId id) Entity *EntityFromId(Snapshot *ss, EntityId id)
{ {
Entity *result = sim_ent_nil(); Entity *result = NilEntity();
if (!sim_ent_id_is_nil(id) && ss->valid) { if (!IsNilEntityId(id) && ss->valid) {
EntBin *bin = bin_from_id(ss, id); EntBin *bin = BinFromEntityId(ss, id);
for (Entity *e = ent_from_index(ss, bin->first); e->valid; e = ent_from_index(ss, e->next_in_id_bin)) { for (Entity *e = EntityFromIndex(ss, bin->first); e->valid; e = EntityFromIndex(ss, e->next_in_id_bin)) {
if (sim_ent_id_eq(e->id, id)) { if (EqEntityId(e->id, id)) {
result = e; result = e;
break; break;
} }
@ -254,7 +254,7 @@ Entity *sim_ent_from_id(Snapshot *ss, EntityId id)
return result; return result;
} }
EntityId sim_ent_random_id(void) EntityId RandomEntityId(void)
{ {
EntityId result = ZI; EntityId result = ZI;
result.uid = UidFromTrueRand(); result.uid = UidFromTrueRand();
@ -262,10 +262,10 @@ EntityId sim_ent_random_id(void)
} }
/* Returns the deterministic id of the contact constraint ent id that should be produced from e0 & e1 colliding */ /* Returns the deterministic id of the contact constraint ent id that should be produced from e0 & e1 colliding */
EntityId sim_ent_contact_constraint_id_from_contacting_ids(EntityId player_id, EntityId id0, EntityId id1) EntityId ContactConstraintIdFromContactingIds(EntityId player_id, EntityId id0, EntityId id1)
{ {
EntityId result = ZI; EntityId result = ZI;
result.uid = SIM_ENT_CONTACT_BASIS_Uid; result.uid = ContactBasisUid;
result.uid = CombineUid(result.uid, player_id.uid); result.uid = CombineUid(result.uid, player_id.uid);
result.uid = CombineUid(result.uid, id0.uid); result.uid = CombineUid(result.uid, id0.uid);
result.uid = CombineUid(result.uid, id1.uid); result.uid = CombineUid(result.uid, id1.uid);
@ -273,10 +273,10 @@ EntityId sim_ent_contact_constraint_id_from_contacting_ids(EntityId player_id, E
} }
/* Returns the deterministic id of the debug contact constraint ent id that should be produced from e0 & e1 colliding */ /* Returns the deterministic id of the debug contact constraint ent id that should be produced from e0 & e1 colliding */
EntityId sim_ent_collision_debug_id_from_ids(EntityId player_id, EntityId id0, EntityId id1) EntityId CollisionDebugIdFromIds(EntityId player_id, EntityId id0, EntityId id1)
{ {
EntityId result = ZI; EntityId result = ZI;
result.uid = SIM_ENT_COLLISION_DEBUG_BASIS_Uid; result.uid = CollisionDebugBasisUid;
result.uid = CombineUid(result.uid, player_id.uid); result.uid = CombineUid(result.uid, player_id.uid);
result.uid = CombineUid(result.uid, id0.uid); result.uid = CombineUid(result.uid, id0.uid);
result.uid = CombineUid(result.uid, id1.uid); result.uid = CombineUid(result.uid, id1.uid);
@ -284,10 +284,10 @@ EntityId sim_ent_collision_debug_id_from_ids(EntityId player_id, EntityId id0, E
} }
/* Returns the deterministic id of the tile chunk that should be produced at chunk pos */ /* Returns the deterministic id of the tile chunk that should be produced at chunk pos */
EntityId sim_ent_tile_chunk_id_from_tile_chunk_index(Vec2I32 chunk_index) EntityId TileChunkIdFromIndex(Vec2I32 chunk_index)
{ {
EntityId result = ZI; EntityId result = ZI;
result.uid = SIM_ENT_TILE_CHUNK_BASIS_Uid; result.uid = TileChunkBasisUid;
result.uid = CombineUid(result.uid, UID(RandU64FromSeed(chunk_index.x), RandU64FromSeed(chunk_index.y))); result.uid = CombineUid(result.uid, UID(RandU64FromSeed(chunk_index.x), RandU64FromSeed(chunk_index.y)));
return result; return result;
} }
@ -295,20 +295,20 @@ EntityId sim_ent_tile_chunk_id_from_tile_chunk_index(Vec2I32 chunk_index)
//////////////////////////////// ////////////////////////////////
//~ Query //~ Query
Entity *sim_ent_find_first_match_one(Snapshot *ss, Prop prop) Entity *FirstEntityWithProp(Snapshot *ss, Prop prop)
{ {
u64 count = ss->num_ents_reserved; u64 count = ss->num_ents_reserved;
Entity *entities = ss->ents; Entity *entities = ss->ents;
for (u64 ent_index = 0; ent_index < count; ++ent_index) { for (u64 ent_index = 0; ent_index < count; ++ent_index) {
Entity *ent = &entities[ent_index]; Entity *ent = &entities[ent_index];
if (ent->valid && sim_ent_has_prop(ent, prop)) { if (ent->valid && HasProp(ent, prop)) {
return ent; return ent;
} }
} }
return sim_ent_nil(); return NilEntity();
} }
Entity *sim_ent_find_first_match_all(Snapshot *ss, EntPropArray props) Entity *FirstEntityWithAllProps(Snapshot *ss, PropArray props)
{ {
u64 count = ss->num_ents_reserved; u64 count = ss->num_ents_reserved;
Entity *entities = ss->ents; Entity *entities = ss->ents;
@ -317,7 +317,7 @@ Entity *sim_ent_find_first_match_all(Snapshot *ss, EntPropArray props)
if (ent->valid) { if (ent->valid) {
b32 all = 1; b32 all = 1;
for (u64 i = 0; i < props.count; ++i) { for (u64 i = 0; i < props.count; ++i) {
if (!sim_ent_has_prop(ent, props.props[i])) { if (!HasProp(ent, props.props[i])) {
all = 0; all = 0;
break; break;
} }
@ -327,25 +327,25 @@ Entity *sim_ent_find_first_match_all(Snapshot *ss, EntPropArray props)
} }
} }
} }
return sim_ent_nil(); return NilEntity();
} }
//////////////////////////////// ////////////////////////////////
//~ Tree //~ Tree
void sim_ent_link_parent(Entity *ent, Entity *parent) void LinkEntity(Entity *ent, Entity *parent)
{ {
Snapshot *ss = ent->ss; Snapshot *ss = ent->ss;
Entity *old_parent = sim_ent_from_id(ss, ent->parent); Entity *old_parent = EntityFromId(ss, ent->parent);
if (old_parent->valid) { if (old_parent->valid) {
/* Unlink from current parent */ /* Unlink from current parent */
sim_ent_unlink_from_parent(ent); UnlinkEntity(ent);
} }
EntityId ent_id = ent->id; EntityId ent_id = ent->id;
EntityId last_child_id = parent->last; EntityId last_child_id = parent->last;
Entity *last_child = sim_ent_from_id(ss, last_child_id); Entity *last_child = EntityFromId(ss, last_child_id);
if (last_child->valid) { if (last_child->valid) {
ent->prev = last_child_id; ent->prev = last_child_id;
last_child->next = ent_id; last_child->next = ent_id;
@ -365,14 +365,14 @@ void sim_ent_link_parent(Entity *ent, Entity *parent)
} }
/* NOTE: Entity will be dangling after calling this, should re-link to root ent. */ /* NOTE: Entity will be dangling after calling this, should re-link to root ent. */
void sim_ent_unlink_from_parent(Entity *ent) void UnlinkEntity(Entity *ent)
{ {
Snapshot *ss = ent->ss; Snapshot *ss = ent->ss;
EntityId parent_id = ent->parent; EntityId parent_id = ent->parent;
Entity *parent = sim_ent_from_id(ss, parent_id); Entity *parent = EntityFromId(ss, parent_id);
Entity *prev = sim_ent_from_id(ss, ent->prev); Entity *prev = EntityFromId(ss, ent->prev);
Entity *next = sim_ent_from_id(ss, ent->next); Entity *next = EntityFromId(ss, ent->next);
/* Unlink from parent & siblings */ /* Unlink from parent & siblings */
if (prev->valid) { if (prev->valid) {
@ -385,34 +385,34 @@ void sim_ent_unlink_from_parent(Entity *ent)
} else { } else {
parent->last = prev->id; parent->last = prev->id;
} }
ent->prev = SIM_ENT_NIL_ID; ent->prev = NilEntityId;
ent->next = SIM_ENT_NIL_ID; ent->next = NilEntityId;
} }
//////////////////////////////// ////////////////////////////////
//~ Xform //~ Xform
void sim_ent_mark_child_xforms_dirty(Snapshot *ss, Entity *ent) void MarkChildEntityXformsDirty(Snapshot *ss, Entity *ent)
{ {
for (Entity *child = sim_ent_from_id(ss, ent->first); child->valid; child = sim_ent_from_id(ss, child->next)) { for (Entity *child = EntityFromId(ss, ent->first); child->valid; child = EntityFromId(ss, child->next)) {
if (child->_is_xform_dirty) { if (child->_is_xform_dirty) {
break; break;
} else { } else {
child->_is_xform_dirty = 1; child->_is_xform_dirty = 1;
sim_ent_mark_child_xforms_dirty(ss, child); MarkChildEntityXformsDirty(ss, child);
} }
} }
} }
Xform sim_ent_get_xform_internal(Snapshot *ss, Entity *ent) Xform XformFromEntity_(Snapshot *ss, Entity *ent)
{ {
Xform xf; Xform xf;
if (ent->_is_xform_dirty) { if (ent->_is_xform_dirty) {
if (ent->is_top) { if (ent->is_top) {
xf = ent->_local_xform; xf = ent->_local_xform;
} else { } else {
Entity *parent = sim_ent_from_id(ss, ent->parent); Entity *parent = EntityFromId(ss, ent->parent);
xf = sim_ent_get_xform_internal(ss, parent); xf = XformFromEntity_(ss, parent);
xf = MulXform(xf, ent->_local_xform); xf = MulXform(xf, ent->_local_xform);
ent->_xform = xf; ent->_xform = xf;
ent->_is_xform_dirty = 0; ent->_is_xform_dirty = 0;
@ -425,7 +425,7 @@ Xform sim_ent_get_xform_internal(Snapshot *ss, Entity *ent)
return xf; return xf;
} }
Xform sim_ent_get_xform(Entity *ent) Xform XformFromEntity(Entity *ent)
{ {
Xform xf; Xform xf;
if (ent->_is_xform_dirty) { if (ent->_is_xform_dirty) {
@ -433,8 +433,8 @@ Xform sim_ent_get_xform(Entity *ent)
xf = ent->_local_xform; xf = ent->_local_xform;
} else { } else {
Snapshot *ss = ent->ss; Snapshot *ss = ent->ss;
Entity *parent = sim_ent_from_id(ss, ent->parent); Entity *parent = EntityFromId(ss, ent->parent);
xf = sim_ent_get_xform_internal(ss, parent); xf = XformFromEntity_(ss, parent);
xf = MulXform(xf, ent->_local_xform); xf = MulXform(xf, ent->_local_xform);
ent->_xform = xf; ent->_xform = xf;
ent->_is_xform_dirty = 0; ent->_is_xform_dirty = 0;
@ -447,12 +447,12 @@ Xform sim_ent_get_xform(Entity *ent)
return xf; return xf;
} }
Xform sim_ent_get_local_xform(Entity *ent) Xform LocalXformFromEntity(Entity *ent)
{ {
return ent->_local_xform; return ent->_local_xform;
} }
void sim_ent_set_xform(Entity *ent, Xform xf) void SetEntityXform(Entity *ent, Xform xf)
{ {
if (!EqXform(xf, ent->_xform)) { if (!EqXform(xf, ent->_xform)) {
Snapshot *ss = ent->ss; Snapshot *ss = ent->ss;
@ -460,88 +460,88 @@ void sim_ent_set_xform(Entity *ent, Xform xf)
if (ent->is_top) { if (ent->is_top) {
ent->_local_xform = xf; ent->_local_xform = xf;
} else { } else {
Entity *parent = sim_ent_from_id(ss, ent->parent); Entity *parent = EntityFromId(ss, ent->parent);
Xform parent_global = sim_ent_get_xform_internal(ss, parent); Xform parent_global = XformFromEntity_(ss, parent);
ent->_local_xform = MulXform(InvertXform(parent_global), xf); ent->_local_xform = MulXform(InvertXform(parent_global), xf);
} }
ent->_xform = xf; ent->_xform = xf;
ent->_is_xform_dirty = 0; ent->_is_xform_dirty = 0;
sim_ent_mark_child_xforms_dirty(ss, ent); MarkChildEntityXformsDirty(ss, ent);
} }
} }
void sim_ent_set_local_xform(Entity *ent, Xform xf) void SetEntityLocalXform(Entity *ent, Xform xf)
{ {
if (!EqXform(xf, ent->_local_xform)) { if (!EqXform(xf, ent->_local_xform)) {
ent->_local_xform = xf; ent->_local_xform = xf;
ent->_is_xform_dirty = 1; ent->_is_xform_dirty = 1;
sim_ent_mark_child_xforms_dirty(ent->ss, ent); MarkChildEntityXformsDirty(ent->ss, ent);
} }
} }
//////////////////////////////// ////////////////////////////////
//~ Movement //~ Movement
void sim_ent_set_linear_velocity(Entity *ent, Vec2 velocity) void SetLinearVelocity(Entity *ent, Vec2 velocity)
{ {
if (sim_ent_has_prop(ent, Prop_Kinematic) || sim_ent_has_prop(ent, Prop_Dynamic)) { if (HasProp(ent, Prop_Kinematic) || HasProp(ent, Prop_Dynamic)) {
ent->linear_velocity = ClampVec2Len(velocity, SIM_MAX_LINEAR_VELOCITY); ent->linear_velocity = ClampVec2Len(velocity, SIM_MAX_LINEAR_VELOCITY);
} }
} }
void sim_ent_set_angular_velocity(Entity *ent, f32 velocity) void SetAngularVelocity(Entity *ent, f32 velocity)
{ {
if (sim_ent_has_prop(ent, Prop_Kinematic) || sim_ent_has_prop(ent, Prop_Dynamic)) { if (HasProp(ent, Prop_Kinematic) || HasProp(ent, Prop_Dynamic)) {
ent->angular_velocity = ClampF32(velocity, -SIM_MAX_ANGULAR_VELOCITY, SIM_MAX_ANGULAR_VELOCITY); ent->angular_velocity = ClampF32(velocity, -SIM_MAX_ANGULAR_VELOCITY, SIM_MAX_ANGULAR_VELOCITY);
} }
} }
void sim_ent_apply_linear_impulse(Entity *ent, Vec2 impulse, Vec2 point) void ApplyLinearImpulse(Entity *ent, Vec2 impulse, Vec2 point)
{ {
if (sim_ent_has_prop(ent, Prop_Dynamic)) { if (HasProp(ent, Prop_Dynamic)) {
Xform xf = sim_ent_get_xform(ent); Xform xf = XformFromEntity(ent);
Vec2 center = xf.og; Vec2 center = xf.og;
f32 scale = AbsF32(DeterminantFromXform(xf)); f32 scale = AbsF32(DeterminantFromXform(xf));
f32 inv_mass = 1.f / (ent->mass_unscaled * scale); f32 inv_mass = 1.f / (ent->mass_unscaled * scale);
f32 inv_inertia = 1.f / (ent->inertia_unscaled * scale); f32 inv_inertia = 1.f / (ent->inertia_unscaled * scale);
Vec2 vcp = SubVec2(point, center); Vec2 vcp = SubVec2(point, center);
sim_ent_set_linear_velocity(ent, AddVec2(ent->linear_velocity, MulVec2(impulse, inv_mass))); SetLinearVelocity(ent, AddVec2(ent->linear_velocity, MulVec2(impulse, inv_mass)));
sim_ent_set_angular_velocity(ent, WedgeVec2(vcp, impulse) * inv_inertia); SetAngularVelocity(ent, WedgeVec2(vcp, impulse) * inv_inertia);
} }
} }
void sim_ent_apply_linear_impulse_to_center(Entity *ent, Vec2 impulse) void ApplyLinearImpulseToCenter(Entity *ent, Vec2 impulse)
{ {
if (sim_ent_has_prop(ent, Prop_Dynamic)) { if (HasProp(ent, Prop_Dynamic)) {
Xform xf = sim_ent_get_xform(ent); Xform xf = XformFromEntity(ent);
f32 scale = AbsF32(DeterminantFromXform(xf)); f32 scale = AbsF32(DeterminantFromXform(xf));
f32 inv_mass = 1.f / (ent->mass_unscaled * scale); f32 inv_mass = 1.f / (ent->mass_unscaled * scale);
sim_ent_set_linear_velocity(ent, AddVec2(ent->linear_velocity, MulVec2(impulse, inv_mass))); SetLinearVelocity(ent, AddVec2(ent->linear_velocity, MulVec2(impulse, inv_mass)));
} }
} }
void sim_ent_apply_force_to_center(Entity *ent, Vec2 force) void ApplyForceToCenter(Entity *ent, Vec2 force)
{ {
if (sim_ent_has_prop(ent, Prop_Dynamic)) { if (HasProp(ent, Prop_Dynamic)) {
ent->force = AddVec2(ent->force, force); ent->force = AddVec2(ent->force, force);
} }
} }
void sim_ent_apply_angular_impulse(Entity *ent, f32 impulse) void ApplyAngularImpulse(Entity *ent, f32 impulse)
{ {
if (sim_ent_has_prop(ent, Prop_Dynamic)) { if (HasProp(ent, Prop_Dynamic)) {
Xform xf = sim_ent_get_xform(ent); Xform xf = XformFromEntity(ent);
f32 scale = AbsF32(DeterminantFromXform(xf)); f32 scale = AbsF32(DeterminantFromXform(xf));
f32 inv_inertia = 1.f / (ent->inertia_unscaled * scale); f32 inv_inertia = 1.f / (ent->inertia_unscaled * scale);
sim_ent_set_angular_velocity(ent, ent->angular_velocity + impulse * inv_inertia); SetAngularVelocity(ent, ent->angular_velocity + impulse * inv_inertia);
} }
} }
void sim_ent_apply_torque(Entity *ent, f32 torque) void ApplyTorque(Entity *ent, f32 torque)
{ {
if (sim_ent_has_prop(ent, Prop_Dynamic)) { if (HasProp(ent, Prop_Dynamic)) {
ent->torque += torque; ent->torque += torque;
} }
} }
@ -549,21 +549,21 @@ void sim_ent_apply_torque(Entity *ent, f32 torque)
//////////////////////////////// ////////////////////////////////
//~ Tile //~ Tile
Entity *sim_tile_chunk_from_chunk_index(Snapshot *ss, Vec2I32 chunk_index) Entity *TileChunkFromChunkIndex(Snapshot *ss, Vec2I32 chunk_index)
{ {
EntityId chunk_id = sim_ent_tile_chunk_id_from_tile_chunk_index(chunk_index); EntityId chunk_id = TileChunkIdFromIndex(chunk_index);
Entity *chunk_ent = sim_ent_from_id(ss, chunk_id); Entity *chunk_ent = EntityFromId(ss, chunk_id);
return chunk_ent; return chunk_ent;
} }
Entity *sim_tile_chunk_from_world_tile_index(Snapshot *ss, Vec2I32 world_tile_index) Entity *TileChunkFromWorldTileIndex(Snapshot *ss, Vec2I32 world_tile_index)
{ {
Vec2I32 chunk_index = sim_tile_chunk_index_from_world_tile_index(world_tile_index); Vec2I32 chunk_index = sim_tile_chunk_index_from_world_tile_index(world_tile_index);
Entity *chunk_ent = sim_tile_chunk_from_chunk_index(ss, chunk_index); Entity *chunk_ent = TileChunkFromChunkIndex(ss, chunk_index);
return chunk_ent; return chunk_ent;
} }
TileKind sim_get_chunk_tile(Entity *chunk_ent, Vec2I32 local_tile_index) TileKind TileKindFromChunk(Entity *chunk_ent, Vec2I32 local_tile_index)
{ {
TileKind result = chunk_ent->tile_chunk_tiles[local_tile_index.x + (local_tile_index.y * SIM_TILES_PER_CHUNK_SQRT)]; TileKind result = chunk_ent->tile_chunk_tiles[local_tile_index.x + (local_tile_index.y * SIM_TILES_PER_CHUNK_SQRT)];
return result; return result;
@ -572,18 +572,18 @@ TileKind sim_get_chunk_tile(Entity *chunk_ent, Vec2I32 local_tile_index)
//////////////////////////////// ////////////////////////////////
//~ Lerp //~ Lerp
void sim_ent_lerp(Entity *e, Entity *e0, Entity *e1, f64 blend) void LerpEntity(Entity *e, Entity *e0, Entity *e1, f64 blend)
{ {
if (sim_ent_is_valid_and_active(e0) && sim_ent_is_valid_and_active(e1) if (IsValidAndActive(e0) && IsValidAndActive(e1)
&& sim_ent_id_eq(e0->id, e1->id) && EqEntityId(e0->id, e1->id)
&& e0->continuity_gen == e1->continuity_gen) { && e0->continuity_gen == e1->continuity_gen) {
e->_local_xform = LerpXform(e0->_local_xform, e1->_local_xform, blend); e->_local_xform = LerpXform(e0->_local_xform, e1->_local_xform, blend);
if (e->is_top) { if (e->is_top) {
/* TODO: Cache parent & child xforms in sim */ /* TODO: Cache parent & child xforms in sim */
Xform e0_xf = sim_ent_get_xform(e0); Xform e0_xf = XformFromEntity(e0);
Xform e1_xf = sim_ent_get_xform(e1); Xform e1_xf = XformFromEntity(e1);
sim_ent_set_xform(e, LerpXform(e0_xf, e1_xf, blend)); SetEntityXform(e, LerpXform(e0_xf, e1_xf, blend));
} }
e->control_force = LerpF32(e0->control_force, e1->control_force, blend); e->control_force = LerpF32(e0->control_force, e1->control_force, blend);
@ -611,33 +611,33 @@ void sim_ent_lerp(Entity *e, Entity *e0, Entity *e1, f64 blend)
//////////////////////////////// ////////////////////////////////
//~ Sync //~ Sync
/* Walks a local & remote ent tree and allocates any missing net dst ents from remote src ents */ /* Walks a local & remote ent tree and allocates any missing net dst ents from remote src ents */
void sim_ent_sync_acquire_tree(Entity *local_parent, Entity *remote, EntityId remote_player) void CreateMissingEntitiesFromSnapshots(Entity *local_parent, Entity *remote, EntityId remote_player)
{ {
__prof; __prof;
if (sim_ent_has_prop(remote, Prop_SyncSrc)) { if (HasProp(remote, Prop_SyncSrc)) {
Snapshot *local_ss = local_parent->ss; Snapshot *local_ss = local_parent->ss;
Snapshot *remote_ss = remote->ss; Snapshot *remote_ss = remote->ss;
EntityId id = remote->id; EntityId id = remote->id;
Entity *local_ent = sim_ent_from_id(local_ss, id); Entity *local_ent = EntityFromId(local_ss, id);
if (!local_ent->valid) { if (!local_ent->valid) {
local_ent = sim_ent_acquire_sync_dst(local_parent, id, remote_player); local_ent = AcquireSyncDstEntity(local_parent, id, remote_player);
} }
for (Entity *remote_child = sim_ent_from_id(remote_ss, remote->first); remote_child->valid; remote_child = sim_ent_from_id(remote_ss, remote_child->next)) { for (Entity *remote_child = EntityFromId(remote_ss, remote->first); remote_child->valid; remote_child = EntityFromId(remote_ss, remote_child->next)) {
sim_ent_sync_acquire_tree(local_ent, remote_child, remote_player); CreateMissingEntitiesFromSnapshots(local_ent, remote_child, remote_player);
} }
} }
} }
/* Copies data between two synced entities */ /* Copies data between two synced entities */
void sim_ent_sync(Entity *local, Entity *remote) void SyncEntity(Entity *local, Entity *remote)
{ {
Entity old = *local; Entity old = *local;
CopyStruct(local, remote); CopyStruct(local, remote);
/* Why would 2 ents w/ different uids ever be synced? */ /* Why would 2 ents w/ different uids ever be synced? */
Assert(sim_ent_id_eq(local->id, old.id)); Assert(EqEntityId(local->id, old.id));
local->ss = old.ss; local->ss = old.ss;
local->id = old.id; local->id = old.id;
@ -656,8 +656,8 @@ void sim_ent_sync(Entity *local, Entity *remote)
local->prev_in_id_bin = old.prev_in_id_bin; local->prev_in_id_bin = old.prev_in_id_bin;
local->next_free = old.next_free; local->next_free = old.next_free;
sim_ent_disable_prop(local, Prop_SyncSrc); DisableProp(local, Prop_SyncSrc);
sim_ent_enable_prop(local, Prop_SyncDst); EnableProp(local, Prop_SyncDst);
} }
//////////////////////////////// ////////////////////////////////
@ -667,7 +667,7 @@ void sim_ent_sync(Entity *local, Entity *remote)
//- Encode //- Encode
void sim_ent_encode(BB_Writer *bw, Entity *e0, Entity *e1) void EncodeEntity(BB_Writer *bw, Entity *e0, Entity *e1)
{ {
Snapshot *ss = e1->ss; Snapshot *ss = e1->ss;
/* FIXME: Things like xforms need to be retreived manually rather than memcopied. */ /* FIXME: Things like xforms need to be retreived manually rather than memcopied. */
@ -692,7 +692,7 @@ void sim_ent_encode(BB_Writer *bw, Entity *e0, Entity *e1)
//- Decode //- Decode
void sim_ent_decode(BB_Reader *br, Entity *e) void DecodeEntity(BB_Reader *br, Entity *e)
{ {
Snapshot *old_ss = e->ss; Snapshot *old_ss = e->ss;
{ {
@ -715,7 +715,7 @@ void sim_ent_decode(BB_Reader *br, Entity *e)
//- Encode //- Encode
void sim_ent_encode(BB_Writer *bw, Entity *e0, Entity *e1) void EncodeEntity(BB_Writer *bw, Entity *e0, Entity *e1)
{ {
Snapshot *ss = e1->ss; Snapshot *ss = e1->ss;
@ -746,7 +746,7 @@ void sim_ent_encode(BB_Writer *bw, Entity *e0, Entity *e1)
//- Decode //- Decode
void sim_ent_decode(BB_Reader *br, Entity *e) void DecodeEntity(BB_Reader *br, Entity *e)
{ {
Entity decoded = *e; Entity decoded = *e;
{ {
@ -767,8 +767,8 @@ void sim_ent_decode(BB_Reader *br, Entity *e)
EntityId new_id = decoded.id; EntityId new_id = decoded.id;
CopyStruct(e, &decoded); CopyStruct(e, &decoded);
e->id = old_id; e->id = old_id;
if (!sim_ent_id_eq(old_id, new_id)) { if (!EqEntityId(old_id, new_id)) {
sim_ent_set_id(e, new_id); SetEntityId(e, new_id);
} }
} }
#endif #endif

151
src/pp/pp_ent.h
View File

@ -1,7 +1,8 @@
//////////////////////////////// ////////////////////////////////
//~ Entity props //~ Entity props
typedef i32 Prop; enum { typedef i32 Prop; enum
{
Prop_Active, Prop_Active,
Prop_Release, Prop_Release,
@ -63,7 +64,8 @@ typedef i32 Prop; enum {
//////////////////////////////// ////////////////////////////////
//~ Entity //~ Entity
Struct(Entity) { Struct(Entity)
{
Snapshot *ss; Snapshot *ss;
//- Metadata //- Metadata
@ -233,7 +235,7 @@ Struct(Entity) {
f32 linear_ground_friction; f32 linear_ground_friction;
f32 angular_ground_friction; f32 angular_ground_friction;
/* Use sim_ent_set_linear_velocity & sim_ent_set_angular_velocity to set */ /* Use SetLinearVelocity & SetAngularVelocity to set */
Vec2 linear_velocity; /* m/s */ Vec2 linear_velocity; /* m/s */
f32 angular_velocity; /* rad/s */ f32 angular_velocity; /* rad/s */
@ -367,22 +369,25 @@ Struct(Entity) {
f32 shake; f32 shake;
}; };
Struct(EntArray) { Struct(EntityArray)
{
Entity *ents; Entity *ents;
u64 count; u64 count;
}; };
Struct(EntPropArray) { Struct(PropArray)
{
Prop *props; Prop *props;
u64 count; u64 count;
}; };
Struct(EntBin) { Struct(EntBin)
{
u32 first; u32 first;
u32 last; u32 last;
}; };
Inline Entity *sim_ent_nil(void) Inline Entity *NilEntity(void)
{ {
extern Readonly Entity **_g_sim_ent_nil; extern Readonly Entity **_g_sim_ent_nil;
return *_g_sim_ent_nil; return *_g_sim_ent_nil;
@ -391,74 +396,76 @@ Inline Entity *sim_ent_nil(void)
//////////////////////////////// ////////////////////////////////
//~ Id types //~ Id types
#define SIM_ENT_TILE_CHUNK_BASIS_Uid (UID(0x3ce42de071dd226b, 0x9b566f7df30c813a)) #define NilEntityId ((EntityId) { UID(0, 0) })
#define SIM_ENT_NIL_ID ((EntityId) { UID(0, 0) }) #define RootEntityId ((EntityId) { UID(0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa) })
#define SIM_ENT_ROOT_ID ((EntityId) { UID(0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa) })
/* Id magic number constants (to be used in conjunction with ent ids in deterministic id combinations) */ /* Id magic number constants (to be used in conjunction with ent ids in deterministic id combinations) */
#define SIM_ENT_CONTACT_BASIS_Uid (UID(0x6a2a5d2dbecf534f, 0x0a8ca7c372a015af)) #define TileChunkBasisUid (UID(0x3ce42de071dd226b, 0x9b566f7df30c813a))
#define SIM_ENT_COLLISION_DEBUG_BASIS_Uid (UID(0x302c01182013bb02, 0x570bd270399d11a5)) #define ContactBasisUid (UID(0x6a2a5d2dbecf534f, 0x0a8ca7c372a015af))
#define CollisionDebugBasisUid (UID(0x302c01182013bb02, 0x570bd270399d11a5))
//////////////////////////////// ////////////////////////////////
//~ Id helpers //~ Id helpers
Inline b32 sim_ent_id_eq(EntityId a, EntityId b) Inline b32 EqEntityId(EntityId a, EntityId b)
{ {
return EqUid(a.uid, b.uid); return EqUid(a.uid, b.uid);
} }
Inline b32 sim_ent_id_is_nil(EntityId id) Inline b32 IsNilEntityId(EntityId id)
{ {
return EqUid(id.uid, SIM_ENT_NIL_ID.uid); return EqUid(id.uid, NilEntityId.uid);
} }
//////////////////////////////// ////////////////////////////////
//~ Property helpers //~ Property helpers
Inline void sim_ent_enable_prop(Entity *ent, Prop prop) Inline void EnableProp(Entity *ent, Prop prop)
{ {
u64 index = prop / 64; u64 index = prop / 64;
u64 bit = prop % 64; u64 bit = prop % 64;
ent->props[index] |= ((u64)1 << bit); ent->props[index] |= ((u64)1 << bit);
} }
Inline void sim_ent_disable_prop(Entity *ent, Prop prop) Inline void DisableProp(Entity *ent, Prop prop)
{ {
u64 index = prop / 64; u64 index = prop / 64;
u64 bit = prop % 64; u64 bit = prop % 64;
ent->props[index] &= ~((u64)1 << bit); ent->props[index] &= ~((u64)1 << bit);
} }
Inline b32 sim_ent_has_prop(Entity *ent, Prop prop) Inline b32 HasProp(Entity *ent, Prop prop)
{ {
u64 index = prop / 64; u64 index = prop / 64;
u64 bit = prop % 64; u64 bit = prop % 64;
return !!(ent->props[index] & ((u64)1 << bit)); return !!(ent->props[index] & ((u64)1 << bit));
} }
Inline b32 sim_ent_is_valid_and_active(Entity *ent) Inline b32 IsValidAndActive(Entity *ent)
{ {
return ent->valid && sim_ent_has_prop(ent, Prop_Active); return ent->valid && HasProp(ent, Prop_Active);
} }
Inline b32 sim_ent_should_predict(Entity *ent) Inline b32 ShouldPredict(Entity *ent)
{ {
return sim_ent_id_eq(ent->predictor, ent->ss->local_player); return EqEntityId(ent->predictor, ent->ss->local_player);
} }
Inline b32 sim_ent_is_owner(Entity *ent) Inline b32 IsOwner(Entity *ent)
{ {
return sim_ent_id_eq(ent->owner, ent->ss->local_player); return EqEntityId(ent->owner, ent->ss->local_player);
} }
Inline b32 sim_ent_should_simulate(Entity *ent) Inline b32 ShouldSimulate(Entity *ent)
{ {
b32 result = 0; b32 result = 0;
if (sim_ent_is_valid_and_active(ent)) { if (IsValidAndActive(ent))
{
result = 1; result = 1;
if (sim_ent_has_prop(ent, Prop_SyncDst)) { if (HasProp(ent, Prop_SyncDst))
{
EntityId local_player = ent->ss->local_player; EntityId local_player = ent->ss->local_player;
result = sim_ent_id_eq(local_player, ent->owner) || sim_ent_id_eq(local_player, ent->predictor); result = EqEntityId(local_player, ent->owner) || EqEntityId(local_player, ent->predictor);
} }
} }
return result; return result;
@ -467,91 +474,91 @@ Inline b32 sim_ent_should_simulate(Entity *ent)
//////////////////////////////// ////////////////////////////////
//~ Acquire operations //~ Acquire operations
Entity *sim_ent_acquire_raw(Snapshot *ss, Entity *parent, EntityId id); Entity *AcquireEntityRaw(Snapshot *ss, Entity *parent, EntityId id);
Entity *sim_ent_acquire_local(Entity *parent); Entity *AcquireLocalEntity(Entity *parent);
Entity *sim_ent_acquire_local_with_id(Entity *parent, EntityId id); Entity *AcquireLocalEntityWithId(Entity *parent, EntityId id);
Entity *sim_ent_acquire_sync_src(Entity *parent); Entity *AcquireSyncSrcEntity(Entity *parent);
Entity *sim_ent_acquire_sync_src_with_id(Entity *parent, EntityId id); Entity *AcquireSyncSrcEntityWithId(Entity *parent, EntityId id);
Entity *sim_ent_acquire_sync_dst(Entity *parent, EntityId ent_id, EntityId owner_id); Entity *AcquireSyncDstEntity(Entity *parent, EntityId ent_id, EntityId owner_id);
//////////////////////////////// ////////////////////////////////
//~ Release operations //~ Release operations
void sim_ent_release_raw(Entity *ent); void ReleaseEntityRaw(Entity *ent);
void sim_ent_release(Entity *ent); void ReleaseEntity(Entity *ent);
void sim_ent_release_all_with_prop(Snapshot *ss, Prop prop); void ReleaseAllEntitiesWithProp(Snapshot *ss, Prop prop);
//////////////////////////////// ////////////////////////////////
//~ Activate operations //~ Activate operations
void sim_ent_activate(Entity *ent, u64 current_tick); void ActivateEntity(Entity *ent, u64 current_tick);
//////////////////////////////// ////////////////////////////////
//~ Id operations //~ Id operations
u32 index_from_ent(Snapshot *ss, Entity *ent); u32 IndexFromEntity(Snapshot *ss, Entity *ent);
Entity *ent_from_index(Snapshot *ss, u32 index); Entity *EntityFromIndex(Snapshot *ss, u32 index);
EntBin *bin_from_id(Snapshot *ss, EntityId id); EntBin *BinFromEntityId(Snapshot *ss, EntityId id);
void sim_ent_set_id(Entity *ent, EntityId id); void SetEntityId(Entity *ent, EntityId id);
Entity *sim_ent_from_id(Snapshot *ss, EntityId id); Entity *EntityFromId(Snapshot *ss, EntityId id);
EntityId sim_ent_random_id(void); EntityId RandomEntityId(void);
EntityId sim_ent_contact_constraint_id_from_contacting_ids(EntityId player_id, EntityId id0, EntityId id1); EntityId ContactConstraintIdFromContactingIds(EntityId player_id, EntityId id0, EntityId id1);
EntityId sim_ent_collision_debug_id_from_ids(EntityId player_id, EntityId id0, EntityId id1); EntityId CollisionDebugIdFromIds(EntityId player_id, EntityId id0, EntityId id1);
EntityId sim_ent_tile_chunk_id_from_tile_chunk_index(Vec2I32 chunk_start); EntityId TileChunkIdFromIndex(Vec2I32 chunk_start);
//////////////////////////////// ////////////////////////////////
//~ Query operations //~ Query operations
Entity *sim_ent_find_first_match_one(Snapshot *ss, Prop prop); Entity *FirstEntityWithProp(Snapshot *ss, Prop prop);
Entity *sim_ent_find_first_match_all(Snapshot *ss, EntPropArray props); Entity *FirstEntityWithAllProps(Snapshot *ss, PropArray props);
//////////////////////////////// ////////////////////////////////
//~ Tree operations //~ Tree operations
void sim_ent_link_parent(Entity *parent, Entity *child); void LinkEntity(Entity *parent, Entity *child);
void sim_ent_unlink_from_parent(Entity *ent); void UnlinkEntity(Entity *ent);
//////////////////////////////// ////////////////////////////////
//~ Xform operations //~ Xform operations
void sim_ent_mark_child_xforms_dirty(Snapshot *ss, Entity *ent); void MarkChildEntityXformsDirty(Snapshot *ss, Entity *ent);
Xform sim_ent_get_xform_internal(Snapshot *ss, Entity *ent); Xform XformFromEntity_(Snapshot *ss, Entity *ent);
Xform sim_ent_get_xform(Entity *ent); Xform XformFromEntity(Entity *ent);
Xform sim_ent_get_local_xform(Entity *ent); Xform LocalXformFromEntity(Entity *ent);
void sim_ent_set_xform(Entity *ent, Xform xf); void SetEntityXform(Entity *ent, Xform xf);
void sim_ent_set_local_xform(Entity *ent, Xform xf); void SetEntityLocalXform(Entity *ent, Xform xf);
//////////////////////////////// ////////////////////////////////
//~ Movement operations //~ Movement operations
void sim_ent_set_linear_velocity(Entity *ent, Vec2 velocity); void SetLinearVelocity(Entity *ent, Vec2 velocity);
void sim_ent_set_angular_velocity(Entity *ent, f32 velocity); void SetAngularVelocity(Entity *ent, f32 velocity);
void sim_ent_apply_linear_impulse(Entity *ent, Vec2 impulse, Vec2 world_point); void ApplyLinearImpulse(Entity *ent, Vec2 impulse, Vec2 world_point);
void sim_ent_apply_linear_impulse_to_center(Entity *ent, Vec2 impulse); void ApplyLinearImpulseToCenter(Entity *ent, Vec2 impulse);
void sim_ent_apply_force_to_center(Entity *ent, Vec2 force); void ApplyForceToCenter(Entity *ent, Vec2 force);
void sim_ent_apply_angular_impulse(Entity *ent, f32 impulse); void ApplyAngularImpulse(Entity *ent, f32 impulse);
void sim_ent_apply_torque(Entity *ent, f32 torque); void ApplyTorque(Entity *ent, f32 torque);
//////////////////////////////// ////////////////////////////////
//~ Tile operations //~ Tile operations
Entity *sim_tile_chunk_from_chunk_index(Snapshot *ss, Vec2I32 chunk_index); Entity *TileChunkFromChunkIndex(Snapshot *ss, Vec2I32 chunk_index);
Entity *sim_tile_chunk_from_world_tile_index(Snapshot *ss, Vec2I32 world_tile_index); Entity *TileChunkFromWorldTileIndex(Snapshot *ss, Vec2I32 world_tile_index);
TileKind sim_get_chunk_tile(Entity *chunk_ent, Vec2I32 local_tile_index); TileKind TileKindFromChunk(Entity *chunk_ent, Vec2I32 local_tile_index);
//////////////////////////////// ////////////////////////////////
//~ Lerp operations //~ Lerp operations
void sim_ent_lerp(Entity *e, Entity *e0, Entity *e1, f64 blend); void LerpEntity(Entity *e, Entity *e0, Entity *e1, f64 blend);
//////////////////////////////// ////////////////////////////////
//~ Sync operations //~ Sync operations
void sim_ent_sync_acquire_tree(Entity *local_parent, Entity *remote, EntityId remote_player); void CreateMissingEntitiesFromSnapshots(Entity *local_parent, Entity *remote, EntityId remote_player);
void sim_ent_sync(Entity *local, Entity *remote); void SyncEntity(Entity *local, Entity *remote);
//////////////////////////////// ////////////////////////////////
//~ Encode / decode operations //~ Encode / decode operations
void sim_ent_encode(BB_Writer *bw, Entity *e0, Entity *e1); void EncodeEntity(BB_Writer *bw, Entity *e0, Entity *e1);
void sim_ent_decode(BB_Reader *br, Entity *e); void DecodeEntity(BB_Reader *br, Entity *e);

318
src/pp/pp_phys.c
View File

@ -9,8 +9,8 @@ internal b32 can_contact(Entity *e0, Entity *e1)
{ {
b32 result = 0; b32 result = 0;
result = e0 != e1 && result = e0 != e1 &&
!sim_ent_id_eq(e0->top, e1->top) && !EqEntityId(e0->top, e1->top) &&
!(sim_ent_has_prop(e0, Prop_Wall) && sim_ent_has_prop(e1, Prop_Wall)); !(HasProp(e0, Prop_Wall) && HasProp(e1, Prop_Wall));
return result; return result;
} }
@ -23,25 +23,25 @@ void phys_create_and_update_contacts(PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_
EntityId local_player = ss->local_player; EntityId local_player = ss->local_player;
phys_collision_callback_func *collision_callback = ctx->collision_callback; phys_collision_callback_func *collision_callback = ctx->collision_callback;
Entity *root = sim_ent_from_id(ss, SIM_ENT_ROOT_ID); Entity *root = EntityFromId(ss, RootEntityId);
u64 tick = ss->tick; u64 tick = ss->tick;
for (u64 check0_index = 0; check0_index < ss->num_ents_reserved; ++check0_index) { for (u64 check0_index = 0; check0_index < ss->num_ents_reserved; ++check0_index) {
Entity *check0 = &ss->ents[check0_index]; Entity *check0 = &ss->ents[check0_index];
if (!sim_ent_is_valid_and_active(check0)) continue; if (!IsValidAndActive(check0)) continue;
if (!(sim_ent_has_prop(check0, Prop_Solid) || sim_ent_has_prop(check0, Prop_Sensor))) continue; if (!(HasProp(check0, Prop_Solid) || HasProp(check0, Prop_Sensor))) continue;
if (check0->local_collider.count <= 0) continue; if (check0->local_collider.count <= 0) continue;
Xform check0_xf = sim_ent_get_xform(check0); Xform check0_xf = XformFromEntity(check0);
CLD_Shape check0_collider = check0->local_collider; CLD_Shape check0_collider = check0->local_collider;
Aabb aabb = CLD_AabbFromShape(&check0_collider, check0_xf); Aabb aabb = CLD_AabbFromShape(&check0_collider, check0_xf);
SpaceIter iter = space_iter_begin_aabb(space, aabb); SpaceIter iter = space_iter_begin_aabb(space, aabb);
SpaceEntry *space_entry; SpaceEntry *space_entry;
while ((space_entry = space_iter_next(&iter)) != 0) { while ((space_entry = space_iter_next(&iter)) != 0) {
Entity *check1 = sim_ent_from_id(ss, space_entry->ent); Entity *check1 = EntityFromId(ss, space_entry->ent);
if (!sim_ent_is_valid_and_active(check1)) continue; if (!IsValidAndActive(check1)) continue;
if (!(sim_ent_has_prop(check1, Prop_Solid) || sim_ent_has_prop(check1, Prop_Sensor))) continue; if (!(HasProp(check1, Prop_Solid) || HasProp(check1, Prop_Sensor))) continue;
if (check1->local_collider.count <= 0) continue; if (check1->local_collider.count <= 0) continue;
if (!can_contact(check0, check1)) continue; if (!can_contact(check0, check1)) continue;
@ -56,20 +56,20 @@ void phys_create_and_update_contacts(PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_
e0 = check0; e0 = check0;
e1 = check1; e1 = check1;
e0_xf = check0_xf; e0_xf = check0_xf;
e1_xf = sim_ent_get_xform(check1); e1_xf = XformFromEntity(check1);
e0_collider = check0_collider; e0_collider = check0_collider;
e1_collider = check1->local_collider; e1_collider = check1->local_collider;
} else { } else {
e0 = check1; e0 = check1;
e1 = check0; e1 = check0;
e0_xf = sim_ent_get_xform(check1); e0_xf = XformFromEntity(check1);
e1_xf = check0_xf; e1_xf = check0_xf;
e0_collider = check1->local_collider; e0_collider = check1->local_collider;
e1_collider = check0_collider; e1_collider = check0_collider;
} }
EntityId constraint_id = sim_ent_contact_constraint_id_from_contacting_ids(local_player, e0->id, e1->id); EntityId constraint_id = ContactConstraintIdFromContactingIds(local_player, e0->id, e1->id);
Entity *constraint_ent = sim_ent_from_id(ss, constraint_id); Entity *constraint_ent = EntityFromId(ss, constraint_id);
if (constraint_ent->valid) { if (constraint_ent->valid) {
if (constraint_ent->contact_constraint_data.last_phys_iteration >= phys_iteration) { if (constraint_ent->contact_constraint_data.last_phys_iteration >= phys_iteration) {
@ -93,17 +93,17 @@ void phys_create_and_update_contacts(PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_
if (!constraint_ent->valid) { if (!constraint_ent->valid) {
is_start = 1; is_start = 1;
/* Create constraint */ /* Create constraint */
constraint_ent = sim_ent_acquire_local_with_id(root, constraint_id); constraint_ent = AcquireLocalEntityWithId(root, constraint_id);
constraint_ent->contact_constraint_data.e0 = e0->id; constraint_ent->contact_constraint_data.e0 = e0->id;
constraint_ent->contact_constraint_data.e1 = e1->id; constraint_ent->contact_constraint_data.e1 = e1->id;
/* Both entities must be solid and one must be dynamic for a solve to be necessary. */ /* Both entities must be solid and one must be dynamic for a solve to be necessary. */
constraint_ent->contact_constraint_data.skip_solve = !sim_ent_has_prop(e0, Prop_Solid) || !sim_ent_has_prop(e1, Prop_Solid) || constraint_ent->contact_constraint_data.skip_solve = !HasProp(e0, Prop_Solid) || !HasProp(e1, Prop_Solid) ||
!(sim_ent_has_prop(e0, Prop_Dynamic) || sim_ent_has_prop(e1, Prop_Dynamic)); !(HasProp(e0, Prop_Dynamic) || HasProp(e1, Prop_Dynamic));
sim_ent_enable_prop(constraint_ent, Prop_Active); EnableProp(constraint_ent, Prop_Active);
/* TODO: Should we recalculate normal as more contact points are added? */ /* TODO: Should we recalculate normal as more contact points are added? */
sim_ent_enable_prop(constraint_ent, Prop_ContactConstraint); EnableProp(constraint_ent, Prop_ContactConstraint);
sim_ent_activate(constraint_ent, tick); ActivateEntity(constraint_ent, tick);
} }
constraint = &constraint_ent->contact_constraint_data; constraint = &constraint_ent->contact_constraint_data;
constraint->normal = collision_result.normal; constraint->normal = collision_result.normal;
@ -228,12 +228,12 @@ void phys_create_and_update_contacts(PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_
/* TODO: Remove this (debugging) */ /* TODO: Remove this (debugging) */
#if COLLIDER_DEBUG && COLLIDER_DEBUG_DETAILED #if COLLIDER_DEBUG && COLLIDER_DEBUG_DETAILED
{ {
EntityId dbg_ent_id = sim_ent_collision_debug_id_from_ids(local_player, e0->id, e1->id); EntityId dbg_ent_id = CollisionDebugIdFromIds(local_player, e0->id, e1->id);
Entity *dbg_ent = sim_ent_from_id(ss, dbg_ent_id); Entity *dbg_ent = EntityFromId(ss, dbg_ent_id);
if (!dbg_ent->valid) { if (!dbg_ent->valid) {
/* FIXME: Entity never released */ /* FIXME: Entity never released */
dbg_ent = sim_ent_acquire_local_with_id(root, dbg_ent_id); dbg_ent = AcquireLocalEntityWithId(root, dbg_ent_id);
sim_ent_enable_prop(dbg_ent, Prop_CollisionDebug); EnableProp(dbg_ent, Prop_CollisionDebug);
} }
CollisionDebugData *dbg = &dbg_ent->collision_debug_data; CollisionDebugData *dbg = &dbg_ent->collision_debug_data;
@ -272,20 +272,20 @@ void phys_prepare_contacts(PhysStepCtx *ctx, u64 phys_iteration)
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *constraint_ent = &ss->ents[sim_ent_index]; Entity *constraint_ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(constraint_ent)) continue; if (!ShouldSimulate(constraint_ent)) continue;
if (!sim_ent_has_prop(constraint_ent, Prop_ContactConstraint)) continue; if (!HasProp(constraint_ent, Prop_ContactConstraint)) continue;
ContactConstraint *constraint = &constraint_ent->contact_constraint_data; ContactConstraint *constraint = &constraint_ent->contact_constraint_data;
u32 num_points = constraint->num_points; u32 num_points = constraint->num_points;
Entity *e0 = sim_ent_from_id(ss, constraint->e0); Entity *e0 = EntityFromId(ss, constraint->e0);
Entity *e1 = sim_ent_from_id(ss, constraint->e1); Entity *e1 = EntityFromId(ss, constraint->e1);
if (constraint->last_phys_iteration >= phys_iteration && num_points > 0 && sim_ent_is_valid_and_active(e0) && sim_ent_is_valid_and_active(e1)) { if (constraint->last_phys_iteration >= phys_iteration && num_points > 0 && IsValidAndActive(e0) && IsValidAndActive(e1)) {
Vec2 normal = constraint->normal; Vec2 normal = constraint->normal;
Vec2 tangent = PerpVec2(normal); Vec2 tangent = PerpVec2(normal);
Xform e0_xf = sim_ent_get_xform(e0); Xform e0_xf = XformFromEntity(e0);
Xform e1_xf = sim_ent_get_xform(e1); Xform e1_xf = XformFromEntity(e1);
/* TODO: Cache this */ /* TODO: Cache this */
/* Calculate masses */ /* Calculate masses */
@ -295,14 +295,14 @@ void phys_prepare_contacts(PhysStepCtx *ctx, u64 phys_iteration)
f32 inv_i1 = 0; f32 inv_i1 = 0;
{ {
/* If not simulated locally or ent is not dynamic, pretend contact mass is infinite */ /* If not simulated locally or ent is not dynamic, pretend contact mass is infinite */
if (sim_ent_should_simulate(e0) && sim_ent_has_prop(e0, Prop_Dynamic)) { if (ShouldSimulate(e0) && HasProp(e0, Prop_Dynamic)) {
f32 scale = AbsF32(DeterminantFromXform(e0_xf)); f32 scale = AbsF32(DeterminantFromXform(e0_xf));
f32 scaled_mass = e0->mass_unscaled * scale; f32 scaled_mass = e0->mass_unscaled * scale;
f32 scaled_inertia = e0->inertia_unscaled * scale; f32 scaled_inertia = e0->inertia_unscaled * scale;
inv_m0 = 1.f / scaled_mass; inv_m0 = 1.f / scaled_mass;
inv_i0 = 1.f / scaled_inertia; inv_i0 = 1.f / scaled_inertia;
} }
if (sim_ent_should_simulate(e1) && sim_ent_has_prop(e1, Prop_Dynamic)) { if (ShouldSimulate(e1) && HasProp(e1, Prop_Dynamic)) {
f32 scale = AbsF32(DeterminantFromXform(e1_xf)); f32 scale = AbsF32(DeterminantFromXform(e1_xf));
f32 scaled_mass = e1->mass_unscaled * scale; f32 scaled_mass = e1->mass_unscaled * scale;
f32 scaled_inertia = e1->inertia_unscaled * scale; f32 scaled_inertia = e1->inertia_unscaled * scale;
@ -346,8 +346,8 @@ void phys_prepare_contacts(PhysStepCtx *ctx, u64 phys_iteration)
} else { } else {
/* Mark constraint for removal */ /* Mark constraint for removal */
constraint_ent->contact_constraint_data.num_points = 0; constraint_ent->contact_constraint_data.num_points = 0;
sim_ent_disable_prop(constraint_ent, Prop_Active); DisableProp(constraint_ent, Prop_Active);
sim_ent_enable_prop(constraint_ent, Prop_Release); EnableProp(constraint_ent, Prop_Release);
} }
} }
@ -356,19 +356,19 @@ void phys_prepare_contacts(PhysStepCtx *ctx, u64 phys_iteration)
/* Remove collision debug ents */ /* Remove collision debug ents */
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *dbg_ent = &ss->ents[sim_ent_index]; Entity *dbg_ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(dbg_ent)) continue; if (!ShouldSimulate(dbg_ent)) continue;
if (!sim_ent_has_prop(dbg_ent, Prop_CollisionDebug)) continue; if (!HasProp(dbg_ent, Prop_CollisionDebug)) continue;
CollisionDebugData *dbg = &dbg_ent->collision_debug_data; CollisionDebugData *dbg = &dbg_ent->collision_debug_data;
Entity *e0 = sim_ent_from_id(ss, dbg->e0); Entity *e0 = EntityFromId(ss, dbg->e0);
Entity *e1 = sim_ent_from_id(ss, dbg->e1); Entity *e1 = EntityFromId(ss, dbg->e1);
if (!(sim_ent_should_simulate(e0) && sim_ent_should_simulate(e1)) || if (!(ShouldSimulate(e0) && ShouldSimulate(e1)) ||
!(sim_ent_has_prop(e0, Prop_Solid) || sim_ent_has_prop(e0, Prop_Sensor)) || !(HasProp(e0, Prop_Solid) || HasProp(e0, Prop_Sensor)) ||
!(sim_ent_has_prop(e1, Prop_Solid) || sim_ent_has_prop(e1, Prop_Sensor))) { !(HasProp(e1, Prop_Solid) || HasProp(e1, Prop_Sensor))) {
/* Mark dbg ent for removal */ /* Mark dbg ent for removal */
sim_ent_disable_prop(dbg_ent, Prop_Active); DisableProp(dbg_ent, Prop_Active);
sim_ent_enable_prop(dbg_ent, Prop_Release); EnableProp(dbg_ent, Prop_Release);
} }
} }
#endif #endif
@ -381,16 +381,16 @@ void phys_warm_start_contacts(PhysStepCtx *ctx)
Snapshot *ss = ctx->sim_step_ctx->world; Snapshot *ss = ctx->sim_step_ctx->world;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *constraint_ent = &ss->ents[sim_ent_index]; Entity *constraint_ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(constraint_ent)) continue; if (!ShouldSimulate(constraint_ent)) continue;
if (!sim_ent_has_prop(constraint_ent, Prop_ContactConstraint)) continue; if (!HasProp(constraint_ent, Prop_ContactConstraint)) continue;
ContactConstraint *constraint = &constraint_ent->contact_constraint_data; ContactConstraint *constraint = &constraint_ent->contact_constraint_data;
u32 num_points = constraint->num_points; u32 num_points = constraint->num_points;
Entity *e0 = sim_ent_from_id(ss, constraint->e0); Entity *e0 = EntityFromId(ss, constraint->e0);
Entity *e1 = sim_ent_from_id(ss, constraint->e1); Entity *e1 = EntityFromId(ss, constraint->e1);
if (num_points > 0 && sim_ent_is_valid_and_active(e0) && sim_ent_is_valid_and_active(e1) && !constraint->skip_solve && !constraint->wrong_dir) { if (num_points > 0 && IsValidAndActive(e0) && IsValidAndActive(e1) && !constraint->skip_solve && !constraint->wrong_dir) {
f32 inv_m0 = constraint->inv_m0; f32 inv_m0 = constraint->inv_m0;
f32 inv_m1 = constraint->inv_m1; f32 inv_m1 = constraint->inv_m1;
f32 inv_i0 = constraint->inv_i0; f32 inv_i0 = constraint->inv_i0;
@ -419,10 +419,10 @@ void phys_warm_start_contacts(PhysStepCtx *ctx)
w1 += WedgeVec2(vcp1, impulse) * inv_i1; w1 += WedgeVec2(vcp1, impulse) * inv_i1;
} }
sim_ent_set_linear_velocity(e0, v0); SetLinearVelocity(e0, v0);
sim_ent_set_angular_velocity(e0, w0); SetAngularVelocity(e0, w0);
sim_ent_set_linear_velocity(e1, v1); SetLinearVelocity(e1, v1);
sim_ent_set_angular_velocity(e1, w1); SetAngularVelocity(e1, w1);
} }
} }
} }
@ -433,13 +433,13 @@ void phys_solve_contacts(PhysStepCtx *ctx, f32 dt, b32 apply_bias)
Snapshot *ss = ctx->sim_step_ctx->world; Snapshot *ss = ctx->sim_step_ctx->world;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *constraint_ent = &ss->ents[sim_ent_index]; Entity *constraint_ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(constraint_ent)) continue; if (!ShouldSimulate(constraint_ent)) continue;
if (!sim_ent_has_prop(constraint_ent, Prop_ContactConstraint)) continue; if (!HasProp(constraint_ent, Prop_ContactConstraint)) continue;
ContactConstraint *constraint = &constraint_ent->contact_constraint_data; ContactConstraint *constraint = &constraint_ent->contact_constraint_data;
Entity *e0 = sim_ent_from_id(ss, constraint->e0); Entity *e0 = EntityFromId(ss, constraint->e0);
Entity *e1 = sim_ent_from_id(ss, constraint->e1); Entity *e1 = EntityFromId(ss, constraint->e1);
Vec2 v0 = e0->linear_velocity; Vec2 v0 = e0->linear_velocity;
Vec2 v1 = e1->linear_velocity; Vec2 v1 = e1->linear_velocity;
@ -447,9 +447,9 @@ void phys_solve_contacts(PhysStepCtx *ctx, f32 dt, b32 apply_bias)
f32 w1 = e1->angular_velocity; f32 w1 = e1->angular_velocity;
u32 num_points = constraint->num_points; u32 num_points = constraint->num_points;
if (num_points > 0 && sim_ent_is_valid_and_active(e0) && sim_ent_is_valid_and_active(e1) && !constraint->skip_solve && !constraint->wrong_dir) { if (num_points > 0 && IsValidAndActive(e0) && IsValidAndActive(e1) && !constraint->skip_solve && !constraint->wrong_dir) {
Xform e0_xf = sim_ent_get_xform(e0); Xform e0_xf = XformFromEntity(e0);
Xform e1_xf = sim_ent_get_xform(e1); Xform e1_xf = XformFromEntity(e1);
f32 inv_m0 = constraint->inv_m0; f32 inv_m0 = constraint->inv_m0;
f32 inv_m1 = constraint->inv_m1; f32 inv_m1 = constraint->inv_m1;
@ -536,10 +536,10 @@ void phys_solve_contacts(PhysStepCtx *ctx, f32 dt, b32 apply_bias)
w1 += WedgeVec2(vcp1, impulse) * inv_i1; w1 += WedgeVec2(vcp1, impulse) * inv_i1;
} }
sim_ent_set_linear_velocity(e0, v0); SetLinearVelocity(e0, v0);
sim_ent_set_angular_velocity(e0, w0); SetAngularVelocity(e0, w0);
sim_ent_set_linear_velocity(e1, v1); SetLinearVelocity(e1, v1);
sim_ent_set_angular_velocity(e1, w1); SetAngularVelocity(e1, w1);
} }
} }
} }
@ -571,17 +571,17 @@ void phys_prepare_motor_joints(PhysStepCtx *ctx)
Snapshot *ss = ctx->sim_step_ctx->world; Snapshot *ss = ctx->sim_step_ctx->world;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *joint_ent = &ss->ents[sim_ent_index]; Entity *joint_ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(joint_ent)) continue; if (!ShouldSimulate(joint_ent)) continue;
if (!sim_ent_has_prop(joint_ent, Prop_MotorJoint)) continue; if (!HasProp(joint_ent, Prop_MotorJoint)) continue;
MotorJoint *joint = &joint_ent->motor_joint_data; MotorJoint *joint = &joint_ent->motor_joint_data;
Entity *e0 = sim_ent_from_id(ss, joint->e0); Entity *e0 = EntityFromId(ss, joint->e0);
Entity *e1 = sim_ent_from_id(ss, joint->e1); Entity *e1 = EntityFromId(ss, joint->e1);
if (sim_ent_should_simulate(e0) && sim_ent_should_simulate(e1)) { if (ShouldSimulate(e0) && ShouldSimulate(e1)) {
Xform e0_xf = sim_ent_get_xform(e0); Xform e0_xf = XformFromEntity(e0);
Xform e1_xf = sim_ent_get_xform(e1); Xform e1_xf = XformFromEntity(e1);
/* TODO: Cache this */ /* TODO: Cache this */
/* Calculate masses */ /* Calculate masses */
@ -623,8 +623,8 @@ void phys_prepare_motor_joints(PhysStepCtx *ctx)
#endif #endif
} else { } else {
/* Mark joint for removal */ /* Mark joint for removal */
sim_ent_disable_prop(joint_ent, Prop_Active); DisableProp(joint_ent, Prop_Active);
sim_ent_enable_prop(joint_ent, Prop_Release); EnableProp(joint_ent, Prop_Release);
} }
} }
} }
@ -635,16 +635,16 @@ void phys_warm_start_motor_joints(PhysStepCtx *ctx)
Snapshot *ss = ctx->sim_step_ctx->world; Snapshot *ss = ctx->sim_step_ctx->world;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *joint_ent = &ss->ents[sim_ent_index]; Entity *joint_ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(joint_ent)) continue; if (!ShouldSimulate(joint_ent)) continue;
if (!sim_ent_has_prop(joint_ent, Prop_MotorJoint)) continue; if (!HasProp(joint_ent, Prop_MotorJoint)) continue;
MotorJoint *joint = &joint_ent->motor_joint_data; MotorJoint *joint = &joint_ent->motor_joint_data;
Entity *e0 = sim_ent_from_id(ss, joint->e0); Entity *e0 = EntityFromId(ss, joint->e0);
Entity *e1 = sim_ent_from_id(ss, joint->e1); Entity *e1 = EntityFromId(ss, joint->e1);
Xform e0_xf = sim_ent_get_xform(e0); Xform e0_xf = XformFromEntity(e0);
Xform e1_xf = sim_ent_get_xform(e1); Xform e1_xf = XformFromEntity(e1);
f32 inv_m0 = joint->inv_m0; f32 inv_m0 = joint->inv_m0;
f32 inv_m1 = joint->inv_m1; f32 inv_m1 = joint->inv_m1;
@ -654,8 +654,8 @@ void phys_warm_start_motor_joints(PhysStepCtx *ctx)
Vec2 vcp0 = SubVec2(MulXformV2(e0_xf, joint->point_local_e0), e0_xf.og); Vec2 vcp0 = SubVec2(MulXformV2(e0_xf, joint->point_local_e0), e0_xf.og);
Vec2 vcp1 = SubVec2(MulXformV2(e1_xf, joint->point_local_e1), e1_xf.og); Vec2 vcp1 = SubVec2(MulXformV2(e1_xf, joint->point_local_e1), e1_xf.og);
sim_ent_set_linear_velocity(e0, SubVec2(e0->linear_velocity, MulVec2(joint->linear_impulse, inv_m0))); SetLinearVelocity(e0, SubVec2(e0->linear_velocity, MulVec2(joint->linear_impulse, inv_m0)));
sim_ent_set_linear_velocity(e1, AddVec2(e1->linear_velocity, MulVec2(joint->linear_impulse, inv_m1))); SetLinearVelocity(e1, AddVec2(e1->linear_velocity, MulVec2(joint->linear_impulse, inv_m1)));
e0->angular_velocity -= (WedgeVec2(vcp0, joint->linear_impulse) + joint->angular_impulse) * inv_i0; e0->angular_velocity -= (WedgeVec2(vcp0, joint->linear_impulse) + joint->angular_impulse) * inv_i0;
e1->angular_velocity += (WedgeVec2(vcp1, joint->linear_impulse) + joint->angular_impulse) * inv_i1; e1->angular_velocity += (WedgeVec2(vcp1, joint->linear_impulse) + joint->angular_impulse) * inv_i1;
} }
@ -667,16 +667,16 @@ void phys_solve_motor_joints(PhysStepCtx *ctx, f32 dt)
Snapshot *ss = ctx->sim_step_ctx->world; Snapshot *ss = ctx->sim_step_ctx->world;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *joint_ent = &ss->ents[sim_ent_index]; Entity *joint_ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(joint_ent)) continue; if (!ShouldSimulate(joint_ent)) continue;
if (!sim_ent_has_prop(joint_ent, Prop_MotorJoint)) continue; if (!HasProp(joint_ent, Prop_MotorJoint)) continue;
MotorJoint *joint = &joint_ent->motor_joint_data; MotorJoint *joint = &joint_ent->motor_joint_data;
Entity *e0 = sim_ent_from_id(ss, joint->e0); Entity *e0 = EntityFromId(ss, joint->e0);
Entity *e1 = sim_ent_from_id(ss, joint->e1); Entity *e1 = EntityFromId(ss, joint->e1);
Xform e0_xf = sim_ent_get_xform(e0); Xform e0_xf = XformFromEntity(e0);
Xform e1_xf = sim_ent_get_xform(e1); Xform e1_xf = XformFromEntity(e1);
f32 inv_m0 = joint->inv_m0; f32 inv_m0 = joint->inv_m0;
f32 inv_m1 = joint->inv_m1; f32 inv_m1 = joint->inv_m1;
@ -731,10 +731,10 @@ void phys_solve_motor_joints(PhysStepCtx *ctx, f32 dt)
w1 += WedgeVec2(vcp1, delta) * inv_i1; w1 += WedgeVec2(vcp1, delta) * inv_i1;
} }
sim_ent_set_linear_velocity(e0, v0); SetLinearVelocity(e0, v0);
sim_ent_set_angular_velocity(e0, w0); SetAngularVelocity(e0, w0);
sim_ent_set_linear_velocity(e1, v1); SetLinearVelocity(e1, v1);
sim_ent_set_angular_velocity(e1, w1); SetAngularVelocity(e1, w1);
} }
} }
@ -773,13 +773,13 @@ void phys_prepare_mouse_joints(PhysStepCtx *ctx)
Snapshot *ss = ctx->sim_step_ctx->world; Snapshot *ss = ctx->sim_step_ctx->world;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *joint_ent = &ss->ents[sim_ent_index]; Entity *joint_ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(joint_ent)) continue; if (!ShouldSimulate(joint_ent)) continue;
if (!sim_ent_has_prop(joint_ent, Prop_MouseJoint)) continue; if (!HasProp(joint_ent, Prop_MouseJoint)) continue;
MouseJoint *joint = &joint_ent->mouse_joint_data; MouseJoint *joint = &joint_ent->mouse_joint_data;
Entity *ent = sim_ent_from_id(ss, joint->target); Entity *ent = EntityFromId(ss, joint->target);
if (sim_ent_should_simulate(ent)) { if (ShouldSimulate(ent)) {
Xform xf = sim_ent_get_xform(ent); Xform xf = XformFromEntity(ent);
/* TODO: Cache this */ /* TODO: Cache this */
/* Calculate masses */ /* Calculate masses */
@ -808,8 +808,8 @@ void phys_prepare_mouse_joints(PhysStepCtx *ctx)
#endif #endif
} else { } else {
/* Mark joint for removal */ /* Mark joint for removal */
sim_ent_disable_prop(joint_ent, Prop_Active); DisableProp(joint_ent, Prop_Active);
sim_ent_enable_prop(joint_ent, Prop_Release); EnableProp(joint_ent, Prop_Release);
} }
} }
} }
@ -820,18 +820,18 @@ void phys_warm_start_mouse_joints(PhysStepCtx *ctx)
Snapshot *ss = ctx->sim_step_ctx->world; Snapshot *ss = ctx->sim_step_ctx->world;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *joint_ent = &ss->ents[sim_ent_index]; Entity *joint_ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(joint_ent)) continue; if (!ShouldSimulate(joint_ent)) continue;
if (!sim_ent_has_prop(joint_ent, Prop_MouseJoint)) continue; if (!HasProp(joint_ent, Prop_MouseJoint)) continue;
MouseJoint *joint = &joint_ent->mouse_joint_data; MouseJoint *joint = &joint_ent->mouse_joint_data;
Entity *ent = sim_ent_from_id(ss, joint->target); Entity *ent = EntityFromId(ss, joint->target);
if (sim_ent_should_simulate(ent)) { if (ShouldSimulate(ent)) {
f32 inv_m = joint->inv_m; f32 inv_m = joint->inv_m;
f32 inv_i = joint->inv_i; f32 inv_i = joint->inv_i;
Xform xf = sim_ent_get_xform(ent); Xform xf = XformFromEntity(ent);
Vec2 vcp = SubVec2(MulXformV2(xf, joint->point_local_start), xf.og); Vec2 vcp = SubVec2(MulXformV2(xf, joint->point_local_start), xf.og);
sim_ent_set_linear_velocity(ent, AddVec2(ent->linear_velocity, MulVec2(joint->linear_impulse, inv_m))); SetLinearVelocity(ent, AddVec2(ent->linear_velocity, MulVec2(joint->linear_impulse, inv_m)));
sim_ent_set_angular_velocity(ent, ent->angular_velocity + ((WedgeVec2(vcp, joint->linear_impulse) + joint->angular_impulse) * inv_i)); SetAngularVelocity(ent, ent->angular_velocity + ((WedgeVec2(vcp, joint->linear_impulse) + joint->angular_impulse) * inv_i));
} }
} }
} }
@ -842,12 +842,12 @@ void phys_solve_mouse_joints(PhysStepCtx *ctx, f32 dt)
Snapshot *ss = ctx->sim_step_ctx->world; Snapshot *ss = ctx->sim_step_ctx->world;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *joint_ent = &ss->ents[sim_ent_index]; Entity *joint_ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(joint_ent)) continue; if (!ShouldSimulate(joint_ent)) continue;
if (!sim_ent_has_prop(joint_ent, Prop_MouseJoint)) continue; if (!HasProp(joint_ent, Prop_MouseJoint)) continue;
MouseJoint *joint = &joint_ent->mouse_joint_data; MouseJoint *joint = &joint_ent->mouse_joint_data;
Entity *ent = sim_ent_from_id(ss, joint->target); Entity *ent = EntityFromId(ss, joint->target);
if (sim_ent_should_simulate(ent)) { if (ShouldSimulate(ent)) {
Vec2 v = ent->linear_velocity; Vec2 v = ent->linear_velocity;
f32 w = ent->angular_velocity; f32 w = ent->angular_velocity;
@ -868,7 +868,7 @@ void phys_solve_mouse_joints(PhysStepCtx *ctx, f32 dt)
{ {
f32 max_impulse = joint->max_force / dt; f32 max_impulse = joint->max_force / dt;
Xform xf = sim_ent_get_xform(ent); Xform xf = XformFromEntity(ent);
Vec2 point_start = MulXformV2(xf, joint->point_local_start); Vec2 point_start = MulXformV2(xf, joint->point_local_start);
Vec2 point_end = joint->point_end; Vec2 point_end = joint->point_end;
@ -899,8 +899,8 @@ void phys_solve_mouse_joints(PhysStepCtx *ctx, f32 dt)
w += WedgeVec2(vcp, impulse) * inv_i; w += WedgeVec2(vcp, impulse) * inv_i;
} }
sim_ent_set_linear_velocity(ent, v); SetLinearVelocity(ent, v);
sim_ent_set_angular_velocity(ent, w); SetAngularVelocity(ent, w);
} }
} }
} }
@ -938,17 +938,17 @@ void phys_prepare_weld_joints(PhysStepCtx *ctx)
Snapshot *ss = ctx->sim_step_ctx->world; Snapshot *ss = ctx->sim_step_ctx->world;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *joint_ent = &ss->ents[sim_ent_index]; Entity *joint_ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(joint_ent)) continue; if (!ShouldSimulate(joint_ent)) continue;
if (!sim_ent_has_prop(joint_ent, Prop_WeldJoint)) continue; if (!HasProp(joint_ent, Prop_WeldJoint)) continue;
/* TODO: Lookup and disable collision for any contacts between e0 & e1? */ /* TODO: Lookup and disable collision for any contacts between e0 & e1? */
WeldJoint *joint = &joint_ent->weld_joint_data; WeldJoint *joint = &joint_ent->weld_joint_data;
Entity *e0 = sim_ent_from_id(ss, joint->e0); Entity *e0 = EntityFromId(ss, joint->e0);
Entity *e1 = sim_ent_from_id(ss, joint->e1); Entity *e1 = EntityFromId(ss, joint->e1);
if (sim_ent_should_simulate(e0) && sim_ent_should_simulate(e1)) { if (ShouldSimulate(e0) && ShouldSimulate(e1)) {
Xform e0_xf = sim_ent_get_xform(e0); Xform e0_xf = XformFromEntity(e0);
Xform e1_xf = sim_ent_get_xform(e1); Xform e1_xf = XformFromEntity(e1);
f32 inv_m0; f32 inv_m0;
f32 inv_m1; f32 inv_m1;
@ -975,8 +975,8 @@ void phys_prepare_weld_joints(PhysStepCtx *ctx)
#endif #endif
} else { } else {
/* Mark joint for removal */ /* Mark joint for removal */
sim_ent_disable_prop(joint_ent, Prop_Active); DisableProp(joint_ent, Prop_Active);
sim_ent_enable_prop(joint_ent, Prop_Release); EnableProp(joint_ent, Prop_Release);
} }
} }
} }
@ -987,30 +987,30 @@ void phys_warm_start_weld_joints(PhysStepCtx *ctx)
Snapshot *ss = ctx->sim_step_ctx->world; Snapshot *ss = ctx->sim_step_ctx->world;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *joint_ent = &ss->ents[sim_ent_index]; Entity *joint_ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(joint_ent)) continue; if (!ShouldSimulate(joint_ent)) continue;
if (!sim_ent_has_prop(joint_ent, Prop_WeldJoint)) continue; if (!HasProp(joint_ent, Prop_WeldJoint)) continue;
WeldJoint *joint = &joint_ent->weld_joint_data; WeldJoint *joint = &joint_ent->weld_joint_data;
#if 0 #if 0
Entity *e0 = sim_ent_from_id(ss, joint->e0); Entity *e0 = EntityFromId(ss, joint->e0);
if (sim_ent_should_simulate(e0)) { if (ShouldSimulate(e0)) {
f32 inv_m = joint->inv_m0; f32 inv_m = joint->inv_m0;
f32 inv_i = joint->inv_i0; f32 inv_i = joint->inv_i0;
Xform xf = sim_ent_get_xform(e1); Xform xf = XformFromEntity(e1);
Vec2 vcp = SubVec2(MulXformV2(xf, joint->point_local_start), xf.og); Vec2 vcp = SubVec2(MulXformV2(xf, joint->point_local_start), xf.og);
sim_ent_set_linear_velocity(ent, AddVec2(ent->linear_velocity, MulVec2(joint->linear_impulse, inv_m))); SetLinearVelocity(ent, AddVec2(ent->linear_velocity, MulVec2(joint->linear_impulse, inv_m)));
ent->angular_velocity += (WedgeVec2(vcp, joint->linear_impulse) + joint->angular_impulse) * inv_i; ent->angular_velocity += (WedgeVec2(vcp, joint->linear_impulse) + joint->angular_impulse) * inv_i;
} }
#endif #endif
#if 1 #if 1
Entity *e1 = sim_ent_from_id(ss, joint->e1); Entity *e1 = EntityFromId(ss, joint->e1);
if (sim_ent_should_simulate(e1)) { if (ShouldSimulate(e1)) {
f32 inv_m = joint->inv_m1; f32 inv_m = joint->inv_m1;
f32 inv_i = joint->inv_i1; f32 inv_i = joint->inv_i1;
sim_ent_set_linear_velocity(e1, AddVec2(e1->linear_velocity, MulVec2(joint->linear_impulse1, inv_m))); SetLinearVelocity(e1, AddVec2(e1->linear_velocity, MulVec2(joint->linear_impulse1, inv_m)));
sim_ent_set_angular_velocity(e1, e1->angular_velocity + joint->angular_impulse1 * inv_i); SetAngularVelocity(e1, e1->angular_velocity + joint->angular_impulse1 * inv_i);
} }
#else #else
LAX joint; LAX joint;
@ -1024,15 +1024,15 @@ void phys_solve_weld_joints(PhysStepCtx *ctx, f32 dt)
Snapshot *ss = ctx->sim_step_ctx->world; Snapshot *ss = ctx->sim_step_ctx->world;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *joint_ent = &ss->ents[sim_ent_index]; Entity *joint_ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(joint_ent)) continue; if (!ShouldSimulate(joint_ent)) continue;
if (!sim_ent_has_prop(joint_ent, Prop_WeldJoint)) continue; if (!HasProp(joint_ent, Prop_WeldJoint)) continue;
WeldJoint *joint = &joint_ent->weld_joint_data; WeldJoint *joint = &joint_ent->weld_joint_data;
Entity *e0 = sim_ent_from_id(ss, joint->e0); Entity *e0 = EntityFromId(ss, joint->e0);
Entity *e1 = sim_ent_from_id(ss, joint->e1); Entity *e1 = EntityFromId(ss, joint->e1);
if (sim_ent_should_simulate(e0) && sim_ent_should_simulate(e1)) { if (ShouldSimulate(e0) && ShouldSimulate(e1)) {
Xform xf0 = sim_ent_get_xform(e0); Xform xf0 = XformFromEntity(e0);
Xform xf1 = sim_ent_get_xform(e1); Xform xf1 = XformFromEntity(e1);
Xform target_xf1 = MulXform(xf0, joint->xf0_to_xf1); Xform target_xf1 = MulXform(xf0, joint->xf0_to_xf1);
@ -1076,8 +1076,8 @@ void phys_solve_weld_joints(PhysStepCtx *ctx, f32 dt)
} }
sim_ent_set_linear_velocity(e1, v1); SetLinearVelocity(e1, v1);
sim_ent_set_angular_velocity(e1, w1); SetAngularVelocity(e1, w1);
} }
} }
} }
@ -1088,7 +1088,7 @@ void phys_solve_weld_joints(PhysStepCtx *ctx, f32 dt)
internal Xform get_derived_xform(Entity *ent, f32 dt) internal Xform get_derived_xform(Entity *ent, f32 dt)
{ {
Xform xf = sim_ent_get_xform(ent); Xform xf = XformFromEntity(ent);
Vec2 step_linear_velocity = MulVec2(ent->linear_velocity, dt); Vec2 step_linear_velocity = MulVec2(ent->linear_velocity, dt);
f32 step_angular_velocity = ent->angular_velocity * dt; f32 step_angular_velocity = ent->angular_velocity * dt;
@ -1104,10 +1104,10 @@ void phys_integrate_forces(PhysStepCtx *ctx, f32 dt)
Snapshot *ss = ctx->sim_step_ctx->world; Snapshot *ss = ctx->sim_step_ctx->world;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *ent = &ss->ents[sim_ent_index]; Entity *ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(ent)) continue; if (!ShouldSimulate(ent)) continue;
b32 is_dynamic = sim_ent_has_prop(ent, Prop_Dynamic); b32 is_dynamic = HasProp(ent, Prop_Dynamic);
b32 is_kinematic = sim_ent_has_prop(ent, Prop_Kinematic); b32 is_kinematic = HasProp(ent, Prop_Kinematic);
if (is_dynamic || is_kinematic) { if (is_dynamic || is_kinematic) {
Vec2 linear_velocity = ent->linear_velocity; Vec2 linear_velocity = ent->linear_velocity;
f32 angular_velocity = ent->angular_velocity; f32 angular_velocity = ent->angular_velocity;
@ -1116,7 +1116,7 @@ void phys_integrate_forces(PhysStepCtx *ctx, f32 dt)
/* Integrate forces */ /* Integrate forces */
if (is_dynamic) { if (is_dynamic) {
Xform xf = sim_ent_get_xform(ent); Xform xf = XformFromEntity(ent);
f32 det_abs = AbsF32(DeterminantFromXform(xf)); f32 det_abs = AbsF32(DeterminantFromXform(xf));
f32 mass = ent->mass_unscaled * det_abs; f32 mass = ent->mass_unscaled * det_abs;
f32 inertia = ent->inertia_unscaled * det_abs; f32 inertia = ent->inertia_unscaled * det_abs;
@ -1131,8 +1131,8 @@ void phys_integrate_forces(PhysStepCtx *ctx, f32 dt)
angular_velocity *= angular_damping_factor; angular_velocity *= angular_damping_factor;
/* Update entity */ /* Update entity */
sim_ent_set_linear_velocity(ent, linear_velocity); SetLinearVelocity(ent, linear_velocity);
sim_ent_set_angular_velocity(ent, angular_velocity); SetAngularVelocity(ent, angular_velocity);
ent->force = VEC2(0, 0); ent->force = VEC2(0, 0);
ent->torque = 0; ent->torque = 0;
} }
@ -1146,11 +1146,11 @@ void phys_integrate_velocities(PhysStepCtx *ctx, f32 dt)
Snapshot *ss = ctx->sim_step_ctx->world; Snapshot *ss = ctx->sim_step_ctx->world;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *ent = &ss->ents[sim_ent_index]; Entity *ent = &ss->ents[sim_ent_index];
if (!sim_ent_should_simulate(ent)) continue; if (!ShouldSimulate(ent)) continue;
if (!sim_ent_has_prop(ent, Prop_Dynamic) && !sim_ent_has_prop(ent, Prop_Kinematic)) continue; if (!HasProp(ent, Prop_Dynamic) && !HasProp(ent, Prop_Kinematic)) continue;
Xform xf = get_derived_xform(ent, dt); Xform xf = get_derived_xform(ent, dt);
sim_ent_set_xform(ent, xf); SetEntityXform(ent, xf);
} }
} }
@ -1167,13 +1167,13 @@ f32 phys_determine_earliest_toi(PhysStepCtx *ctx, f32 step_dt, f32 tolerance, u3
for (u64 e0_index = 0; e0_index < ss->num_ents_reserved; ++e0_index) { for (u64 e0_index = 0; e0_index < ss->num_ents_reserved; ++e0_index) {
Entity *e0 = &ss->ents[e0_index]; Entity *e0 = &ss->ents[e0_index];
if (!sim_ent_should_simulate(e0)) continue; if (!ShouldSimulate(e0)) continue;
if (!(sim_ent_has_prop(e0, Prop_Solid) || sim_ent_has_prop(e0, Prop_Sensor))) continue; if (!(HasProp(e0, Prop_Solid) || HasProp(e0, Prop_Sensor))) continue;
if (!sim_ent_has_prop(e0, Prop_Toi)) continue; if (!HasProp(e0, Prop_Toi)) continue;
if (e0->local_collider.count <= 0) continue; if (e0->local_collider.count <= 0) continue;
CLD_Shape e0_collider = e0->local_collider; CLD_Shape e0_collider = e0->local_collider;
Xform e0_xf_t0 = sim_ent_get_xform(e0); Xform e0_xf_t0 = XformFromEntity(e0);
Xform e0_xf_t1 = get_derived_xform(e0, step_dt); Xform e0_xf_t1 = get_derived_xform(e0, step_dt);
/* TODO: Use swept aabb rather than combined aabb. This should prevent spikes from bullets returning 0 positive TOIs with irrelevant entities. */ /* TODO: Use swept aabb rather than combined aabb. This should prevent spikes from bullets returning 0 positive TOIs with irrelevant entities. */
@ -1184,14 +1184,14 @@ f32 phys_determine_earliest_toi(PhysStepCtx *ctx, f32 step_dt, f32 tolerance, u3
SpaceIter iter = space_iter_begin_aabb(space, combined_aabb); SpaceIter iter = space_iter_begin_aabb(space, combined_aabb);
SpaceEntry *entry; SpaceEntry *entry;
while ((entry = space_iter_next(&iter)) != 0) { while ((entry = space_iter_next(&iter)) != 0) {
Entity *e1 = sim_ent_from_id(ss, entry->ent); Entity *e1 = EntityFromId(ss, entry->ent);
if (!sim_ent_should_simulate(e1)) continue; if (!ShouldSimulate(e1)) continue;
if (!(sim_ent_has_prop(e1, Prop_Solid) || sim_ent_has_prop(e1, Prop_Sensor))) continue; if (!(HasProp(e1, Prop_Solid) || HasProp(e1, Prop_Sensor))) continue;
if (e1->local_collider.count <= 0) continue; if (e1->local_collider.count <= 0) continue;
if (!can_contact(e0, e1)) continue; if (!can_contact(e0, e1)) continue;
CLD_Shape e1_collider = e1->local_collider; CLD_Shape e1_collider = e1->local_collider;
Xform e1_xf_t0 = sim_ent_get_xform(e1); Xform e1_xf_t0 = XformFromEntity(e1);
Xform e1_xf_t1 = get_derived_xform(e1, step_dt); Xform e1_xf_t1 = get_derived_xform(e1, step_dt);
f32 t = CLD_TimeOfImpact(&e0_collider, &e1_collider, e0_xf_t0, e1_xf_t0, e0_xf_t1, e1_xf_t1, tolerance, max_iterations); f32 t = CLD_TimeOfImpact(&e0_collider, &e1_collider, e0_xf_t0, e1_xf_t0, e0_xf_t1, e1_xf_t1, tolerance, max_iterations);
@ -1216,9 +1216,9 @@ void phys_update_aabbs(PhysStepCtx *ctx)
Space *space = ctx->sim_step_ctx->accel->space; Space *space = ctx->sim_step_ctx->accel->space;
for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) { for (u64 sim_ent_index = 0; sim_ent_index < ss->num_ents_reserved; ++sim_ent_index) {
Entity *ent = &ss->ents[sim_ent_index]; Entity *ent = &ss->ents[sim_ent_index];
if (!sim_ent_is_valid_and_active(ent)) continue; if (!IsValidAndActive(ent)) continue;
if (ent->local_collider.count > 0) { if (ent->local_collider.count > 0) {
Xform xf = sim_ent_get_xform(ent); Xform xf = XformFromEntity(ent);
SpaceEntry *space_entry = space_entry_from_handle(space, ent->space_handle); SpaceEntry *space_entry = space_entry_from_handle(space, ent->space_handle);
if (!space_entry->valid) { if (!space_entry->valid) {
space_entry = space_entry_acquire(space, ent->id); space_entry = space_entry_acquire(space, ent->id);

80
src/pp/pp_sim.c
View File

@ -49,7 +49,7 @@ Readonly Client **_g_sim_client_nil = &G.nil_client;
/* Accessed via `sim_snapshot_nil()` */ /* Accessed via `sim_snapshot_nil()` */
Readonly Snapshot **_g_sim_snapshot_nil = &G.nil_snapshot; Readonly Snapshot **_g_sim_snapshot_nil = &G.nil_snapshot;
/* Accessed via `sim_ent_nil()` */ /* Accessed via `NilEntity()` */
Readonly Entity **_g_sim_ent_nil = &G.nil_ent; Readonly Entity **_g_sim_ent_nil = &G.nil_ent;
void StartupSim(void) void StartupSim(void)
@ -75,7 +75,7 @@ void StartupSim(void)
G.nil_ent = PushStruct(G.nil_arena, Entity); G.nil_ent = PushStruct(G.nil_arena, Entity);
G.nil_ent->ss = sim_snapshot_nil(); G.nil_ent->ss = sim_snapshot_nil();
G.nil_ent->valid = 0; G.nil_ent->valid = 0;
G.nil_ent->id = SIM_ENT_NIL_ID; G.nil_ent->id = NilEntityId;
G.nil_ent->_local_xform = XformIdentity; G.nil_ent->_local_xform = XformIdentity;
G.nil_ent->_xform = XformIdentity; G.nil_ent->_xform = XformIdentity;
G.nil_ent->_is_xform_dirty = 0; G.nil_ent->_is_xform_dirty = 0;
@ -328,7 +328,7 @@ Snapshot *sim_snapshot_acquire(Client *client, Snapshot *src, u64 tick)
if (ss->num_ents_reserved == 0) { if (ss->num_ents_reserved == 0) {
/* Copying from nil snapshot, need to create blank & root entity */ /* Copying from nil snapshot, need to create blank & root entity */
/* Push blank ent at index 0 (because index 0 is never valid anyway since it maps to sim_ent_nil()) */ /* Push blank ent at index 0 (because index 0 is never valid anyway since it maps to NilEntity()) */
{ {
PushStruct(ss->ents_arena, Entity); PushStruct(ss->ents_arena, Entity);
++ss->num_ents_allocated; ++ss->num_ents_allocated;
@ -338,13 +338,13 @@ Snapshot *sim_snapshot_acquire(Client *client, Snapshot *src, u64 tick)
/* Push root ent with constant id */ /* Push root ent with constant id */
{ {
Entity *root = PushStructNoZero(ss->ents_arena, Entity); Entity *root = PushStructNoZero(ss->ents_arena, Entity);
*root = *sim_ent_nil(); *root = *NilEntity();
root->ss = ss; root->ss = ss;
root->valid = 1; root->valid = 1;
root->is_root = 1; root->is_root = 1;
root->mass_unscaled = F32Infinity; root->mass_unscaled = F32Infinity;
root->inertia_unscaled = F32Infinity; root->inertia_unscaled = F32Infinity;
sim_ent_set_id(root, SIM_ENT_ROOT_ID); SetEntityId(root, RootEntityId);
++ss->num_ents_allocated; ++ss->num_ents_allocated;
++ss->num_ents_reserved; ++ss->num_ents_reserved;
} }
@ -592,12 +592,12 @@ void sim_snapshot_set_tile(Snapshot *ss, Vec2I32 world_tile_index, TileKind tile
{ {
Vec2I32 chunk_index = sim_tile_chunk_index_from_world_tile_index(world_tile_index); Vec2I32 chunk_index = sim_tile_chunk_index_from_world_tile_index(world_tile_index);
EntityId chunk_id = sim_ent_tile_chunk_id_from_tile_chunk_index(chunk_index); EntityId chunk_id = TileChunkIdFromIndex(chunk_index);
Entity *chunk_ent = sim_ent_from_id(ss, chunk_id); Entity *chunk_ent = EntityFromId(ss, chunk_id);
if (!chunk_ent->valid) { if (!chunk_ent->valid) {
Entity *root = sim_ent_from_id(ss, SIM_ENT_ROOT_ID); Entity *root = EntityFromId(ss, RootEntityId);
chunk_ent = sim_ent_acquire_sync_src_with_id(root, chunk_id); chunk_ent = AcquireSyncSrcEntityWithId(root, chunk_id);
sim_ent_enable_prop(chunk_ent, Prop_TileChunk); EnableProp(chunk_ent, Prop_TileChunk);
chunk_ent->tile_chunk_index = chunk_index; chunk_ent->tile_chunk_index = chunk_index;
} }
@ -647,7 +647,7 @@ Snapshot *sim_snapshot_acquire_from_lerp(Client *client, Snapshot *ss0, Snapshot
Entity *e = &ss->ents[i]; Entity *e = &ss->ents[i];
Entity *e0 = &ss0->ents[i]; Entity *e0 = &ss0->ents[i];
Entity *e1 = &ss1->ents[i]; Entity *e1 = &ss1->ents[i];
sim_ent_lerp(e, e0, e1, blend); LerpEntity(e, e0, e1, blend);
} }
} }
} }
@ -669,36 +669,36 @@ void sim_snapshot_sync_ents(Snapshot *local_ss, Snapshot *remote_ss, EntityId re
* - Determine new UUids for newly created ents * - Determine new UUids for newly created ents
*/ */
Entity *local_root = sim_ent_from_id(local_ss, SIM_ENT_ROOT_ID); Entity *local_root = EntityFromId(local_ss, RootEntityId);
Entity *remote_root = sim_ent_from_id(remote_ss, SIM_ENT_ROOT_ID); Entity *remote_root = EntityFromId(remote_ss, RootEntityId);
/* Create new ents from remote */ /* Create new ents from remote */
for (Entity *remote_top = sim_ent_from_id(remote_ss, remote_root->first); remote_top->valid; remote_top = sim_ent_from_id(remote_ss, remote_top->next)) { for (Entity *remote_top = EntityFromId(remote_ss, remote_root->first); remote_top->valid; remote_top = EntityFromId(remote_ss, remote_top->next)) {
sim_ent_sync_acquire_tree(local_root, remote_top, remote_player); CreateMissingEntitiesFromSnapshots(local_root, remote_top, remote_player);
} }
/* Sync ents with remote, skipping index 0 (nil) & index 1 (root) */ /* Sync ents with remote, skipping index 0 (nil) & index 1 (root) */
for (u64 i = 2; i < local_ss->num_ents_reserved; ++i) { for (u64 i = 2; i < local_ss->num_ents_reserved; ++i) {
Entity *local_ent = &local_ss->ents[i]; Entity *local_ent = &local_ss->ents[i];
if (local_ent->valid && sim_ent_has_prop(local_ent, Prop_SyncDst)) { if (local_ent->valid && HasProp(local_ent, Prop_SyncDst)) {
b32 should_sync = sim_ent_id_eq(local_ent->owner, remote_player) || sim_ent_id_is_nil(remote_player); b32 should_sync = EqEntityId(local_ent->owner, remote_player) || IsNilEntityId(remote_player);
if ((sync_flags & SIM_SYNC_FLAG_NOSYNC_PREDICTABLES) && sim_ent_id_eq(local_ent->predictor, local_ss->local_player)) { if ((sync_flags & SIM_SYNC_FLAG_NOSYNC_PREDICTABLES) && EqEntityId(local_ent->predictor, local_ss->local_player)) {
should_sync = 0; should_sync = 0;
} }
if (should_sync) { if (should_sync) {
Entity *remote_ent = sim_ent_from_id(remote_ss, local_ent->id); Entity *remote_ent = EntityFromId(remote_ss, local_ent->id);
if (remote_ent->valid) { if (remote_ent->valid) {
/* Copy all ent data from remote */ /* Copy all ent data from remote */
sim_ent_sync(local_ent, remote_ent); SyncEntity(local_ent, remote_ent);
} else { } else {
/* Remote ent is no longer valid / networked, release it */ /* Remote ent is no longer valid / networked, release it */
sim_ent_enable_prop(local_ent, Prop_Release); EnableProp(local_ent, Prop_Release);
sim_ent_disable_prop(local_ent, Prop_SyncDst); DisableProp(local_ent, Prop_SyncDst);
} }
} }
} }
} }
sim_ent_release_all_with_prop(local_ss, Prop_Release); ReleaseAllEntitiesWithProp(local_ss, Prop_Release);
} }
@ -773,12 +773,12 @@ void sim_snapshot_encode(BB_Writer *bw, Client *receiver, Snapshot *ss0, Snapsho
BB_WriteDebugMarker(bw, StringFromStruct(&ss1->num_ents_reserved)); BB_WriteDebugMarker(bw, StringFromStruct(&ss1->num_ents_reserved));
for (u64 i = 1; i < ss1->num_ents_reserved; ++i) { for (u64 i = 1; i < ss1->num_ents_reserved; ++i) {
Entity *e0 = sim_ent_nil(); Entity *e0 = NilEntity();
if (i < ss0->num_ents_reserved) { if (i < ss0->num_ents_reserved) {
e0 = &ss0->ents[i]; e0 = &ss0->ents[i];
} }
Entity *e1 = &ss1->ents[i]; Entity *e1 = &ss1->ents[i];
sim_ent_encode(bw, e0, e1); EncodeEntity(bw, e0, e1);
} }
BB_WriteDebugMarker(bw, Lit("SNAPSHOT END")); BB_WriteDebugMarker(bw, Lit("SNAPSHOT END"));
@ -840,7 +840,7 @@ void sim_snapshot_decode(BB_Reader *br, Snapshot *ss)
PushStructsNoZero(ss->ents_arena, Entity, reserve_diff); PushStructsNoZero(ss->ents_arena, Entity, reserve_diff);
for (u64 i = old_num_ents_reserved; i < ss->num_ents_reserved; ++i) { for (u64 i = old_num_ents_reserved; i < ss->num_ents_reserved; ++i) {
Entity *e = &ss->ents[i]; Entity *e = &ss->ents[i];
*e = *sim_ent_nil(); *e = *NilEntity();
e->ss = ss; e->ss = ss;
} }
} else if (reserve_diff < 0) { } else if (reserve_diff < 0) {
@ -855,7 +855,7 @@ void sim_snapshot_decode(BB_Reader *br, Snapshot *ss)
for (u64 i = 1; i < ss->num_ents_reserved; ++i) { for (u64 i = 1; i < ss->num_ents_reserved; ++i) {
Entity *e = &ss->ents[i]; Entity *e = &ss->ents[i];
e->ss = ss; e->ss = ss;
sim_ent_decode(br, e); DecodeEntity(br, e);
} }
BB_ReadDebugMarker(br, Lit("SNAPSHOT END")); BB_ReadDebugMarker(br, Lit("SNAPSHOT END"));
@ -900,7 +900,7 @@ void sim_snapshot_encode(BB_Writer *bw, Client *receiver, Snapshot *ss0, Snapsho
BB_AlignWriter(bw); BB_AlignWriter(bw);
for (u64 i = 0; i < ss1->num_ents_reserved; ++i) { for (u64 i = 0; i < ss1->num_ents_reserved; ++i) {
Entity *e0 = sim_ent_nil(); Entity *e0 = NilEntity();
if (i < ss0->num_ents_reserved) { if (i < ss0->num_ents_reserved) {
e0 = &ss0->ents[i]; e0 = &ss0->ents[i];
} }
@ -917,7 +917,7 @@ void sim_snapshot_encode(BB_Writer *bw, Client *receiver, Snapshot *ss0, Snapsho
if (e1->valid) { if (e1->valid) {
Entity *e1 = &ss1->ents[i]; Entity *e1 = &ss1->ents[i];
sim_ent_encode(bw, e0, e1); EncodeEntity(bw, e0, e1);
} }
} }
} }
@ -961,7 +961,7 @@ void sim_snapshot_decode(BB_Reader *br, Snapshot *ss)
PushStructsNoZero(ss->ents_arena, Entity, reserve_diff); PushStructsNoZero(ss->ents_arena, Entity, reserve_diff);
for (u64 i = old_num_ents_reserved; i < ss->num_ents_reserved; ++i) { for (u64 i = old_num_ents_reserved; i < ss->num_ents_reserved; ++i) {
Entity *e = &ss->ents[i]; Entity *e = &ss->ents[i];
*e = *sim_ent_nil(); *e = *NilEntity();
e->ss = ss; e->ss = ss;
} }
} }
@ -984,7 +984,7 @@ void sim_snapshot_decode(BB_Reader *br, Snapshot *ss)
Entity *e = sim_ent_from_index(ss, e); Entity *e = sim_ent_from_index(ss, e);
Assert(e->valid); /* An entity that we don't have allocated should never have been marked for release */ Assert(e->valid); /* An entity that we don't have allocated should never have been marked for release */
if (e->valid) { if (e->valid) {
sim_ent_enable_prop(e, Prop_Release); EnableProp(e, Prop_Release);
} }
} else { } else {
alloc_parent_index = BB_ReadUV(); alloc_parent_index = BB_ReadUV();
@ -1019,13 +1019,13 @@ void sim_snapshot_decode(BB_Reader *br, Snapshot *ss)
if (n->is_new) { if (n->is_new) {
u32 index = n->index; u32 index = n->index;
Entity *parent = sim_ent_from_index(ss, n->alloc_parent_index); Entity *parent = sim_ent_from_index(ss, n->alloc_parent_index);
Assert(!sim_ent_from_index(ss, index)->valid && !sim_ent_from_id(ss, alloc_ent_id)->valid); /* An entity that we have allocated already should never be marked for allocation */ Assert(!sim_ent_from_index(ss, index)->valid && !EntityFromId(ss, alloc_ent_id)->valid); /* An entity that we have allocated already should never be marked for allocation */
Assert(parent->valid); /* Parent for new entity allocation should always be valid */ Assert(parent->valid); /* Parent for new entity allocation should always be valid */
if (parent->valid && index < ss->num_ents_reserved) { if (parent->valid && index < ss->num_ents_reserved) {
Entity *ent = &ss->ents[index]; Entity *ent = &ss->ents[index];
ent->valid = 1; ent->valid = 1;
sim_ent_set_id(ent, n->alloc_ent_id); SetEntityId(ent, n->alloc_ent_id);
sim_ent_link_parent(parent, ent); LinkEntity(parent, ent);
} else { } else {
/* Received an invalid entity allocation */ /* Received an invalid entity allocation */
Assert(0); Assert(0);
@ -1039,7 +1039,7 @@ void sim_snapshot_decode(BB_Reader *br, Snapshot *ss)
u32 index = n->index; u32 index = n->index;
Entity *e = sim_ent_from_index(ss, index); Entity *e = sim_ent_from_index(ss, index);
if (e->valid) { if (e->valid) {
sim_ent_decode(&ent_br, e); DecodeEntity(&ent_br, e);
} else { } else {
/* Received delta for unallocated ent */ /* Received delta for unallocated ent */
Assert(0); Assert(0);
@ -1058,7 +1058,7 @@ void sim_snapshot_decode(BB_Reader *br, Snapshot *ss)
PushStructsNoZero(ss->ents_arena, Entity, reserve_diff); PushStructsNoZero(ss->ents_arena, Entity, reserve_diff);
for (u64 i = old_num_ents_reserved; i < ss->num_ents_reserved; ++i) { for (u64 i = old_num_ents_reserved; i < ss->num_ents_reserved; ++i) {
Entity *e = &ss->ents[i]; Entity *e = &ss->ents[i];
*e = *sim_ent_nil(); *e = *NilEntity();
e->ss = ss; e->ss = ss;
} }
} }
@ -1070,7 +1070,7 @@ void sim_snapshot_decode(BB_Reader *br, Snapshot *ss)
if (BB_ReadBit(br)) { if (BB_ReadBit(br)) {
struct sim_ent_decode_node *n = PushStruct(scratch.arena, struct sim_ent_decode_node) struct sim_ent_decode_node *n = PushStruct(scratch.arena, struct sim_ent_decode_node)
} else { } else {
sim_ent_enable_prop(e, Prop_Release); EnableProp(e, Prop_Release);
} }
} }
} }
@ -1089,13 +1089,13 @@ void sim_snapshot_decode(BB_Reader *br, Snapshot *ss)
/* Why is an already released ent being marked as released? */ /* Why is an already released ent being marked as released? */
Assert(e->valid); Assert(e->valid);
if (e->valid) { if (e->valid) {
sim_ent_enable_prop(e, Prop_Release); EnableProp(e, Prop_Release);
} }
} else { } else {
sim_ent_decode(br, e); DecodeEntity(br, e);
} }
} }
sim_ent_release_all_with_prop(ss, Prop_Release); ReleaseAllEntitiesWithProp(ss, Prop_Release);
#endif #endif
EndScratch(scratch); EndScratch(scratch);

2
src/pp/pp_space.c
View File

@ -3,7 +3,7 @@
/* Offset in bytes from start of space struct to start of entry array (assume adjacently allocated) */ /* Offset in bytes from start of space struct to start of entry array (assume adjacently allocated) */
#define SPACE_ENTRIES_OFFSET (sizeof(Space) + (sizeof(Space) % alignof(SpaceEntry))) #define SPACE_ENTRIES_OFFSET (sizeof(Space) + (sizeof(Space) % alignof(SpaceEntry)))
/* Accessed via sim_ent_nil() */ /* Accessed via NilEntity() */
Readonly SpaceEntry _g_space_entry_nil = { .valid = 0 }; Readonly SpaceEntry _g_space_entry_nil = { .valid = 0 };
Readonly SpaceCell _g_space_cell_nil = { .valid = 0 }; Readonly SpaceCell _g_space_cell_nil = { .valid = 0 };
Readonly Space _g_space_nil = { .valid = 0 }; Readonly Space _g_space_nil = { .valid = 0 };

514
src/pp/pp_step.c
View File

File diff suppressed because it is too large Load Diff