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

rename ent id -> key

Browse Source
This commit is contained in:
jacob 2025-11-02 17:00:04 -06:00
parent 029c88e74e
commit 1500fb7dc3
9 changed files with 201 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/pp/pp.c
View File

@ -199,7 +199,7 @@ String PP_DebugStringFromEnt(Arena *arena, PP_Ent *ent)
String result = ZI; String result = ZI;
result.text = PushDry(arena, u8); result.text = PushDry(arena, u8);
//result.len += StringF(arena, "[%F]", FmtUid(ent->id.uid)).len; //result.len += StringF(arena, "[%F]", FmtUid(ent->key.uid)).len;
{ {
b32 transmitting = PP_HasProp(ent, PP_Prop_SyncSrc); b32 transmitting = PP_HasProp(ent, PP_Prop_SyncSrc);
b32 receiving = PP_HasProp(ent, PP_Prop_SyncDst); b32 receiving = PP_HasProp(ent, PP_Prop_SyncDst);
@ -862,7 +862,7 @@ void PP_UpdateUser(void)
{ {
if (PP_IsNilEntKey(g->debug_following)) if (PP_IsNilEntKey(g->debug_following))
{ {
g->debug_following = hovered_ent->id; g->debug_following = hovered_ent->key;
} }
else else
{ {
@ -905,7 +905,7 @@ void PP_UpdateUser(void)
f32 shake = ent->shake; f32 shake = ent->shake;
if (shake > 0) if (shake > 0)
{ {
u64 angle_seed0 = ent->id.uid.lo + (u64)(g->ss_blended->sim_time_ns / frequency_ns); u64 angle_seed0 = ent->key.uid.lo + (u64)(g->ss_blended->sim_time_ns / frequency_ns);
u64 angle_seed1 = angle_seed0 + 1; u64 angle_seed1 = angle_seed0 + 1;
f32 angle0 = RandF64FromSeed(angle_seed0, 0, Tau); f32 angle0 = RandF64FromSeed(angle_seed0, 0, Tau);
f32 angle1 = RandF64FromSeed(angle_seed1, 0, Tau); f32 angle1 = RandF64FromSeed(angle_seed1, 0, Tau);
@ -1406,7 +1406,7 @@ void PP_UpdateUser(void)
} }
/* Draw focus arrow */ /* Draw focus arrow */
if (ent == local_control || PP_EqEntKey(ent->id, g->debug_following)) if (ent == local_control || PP_EqEntKey(ent->key, g->debug_following))
{ {
S_Sheet *sheet = S_SheetFromResourceAsync(ent->sprite); S_Sheet *sheet = S_SheetFromResourceAsync(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);
@ -1584,7 +1584,7 @@ void PP_UpdateUser(void)
String fmt = Lit( String fmt = Lit(
"e0 index: %F\n" "e0 index: %F\n"
"e1 index: %F\n" "e1 index: %F\n"
"id: 0x%F\n" "key: 0x%F\n"
"impulse (n): %F\n" "impulse (n): %F\n"
"impulse (t): %F\n" "impulse (t): %F\n"
"separation: %F\n" "separation: %F\n"
@ -1592,9 +1592,9 @@ void PP_UpdateUser(void)
"num contacts: %F" "num contacts: %F"
); );
String text = StringF(temp.arena, fmt, String text = StringF(temp.arena, fmt,
FmtUint(e0->handle.idx), FmtUint(e0->key.idx),
FmtUint(e1->handle.idx), FmtUint(e1->key.idx),
FmtHex(point.id), FmtHex(point.key),
FmtFloat(point.normal_impulse), FmtFloat(point.normal_impulse),
FmtFloat(point.tangent_impulse), FmtFloat(point.tangent_impulse),
FmtFloatP(point.starting_separation, 6), FmtFloatP(point.starting_separation, 6),
@ -2039,7 +2039,7 @@ void PP_UpdateUser(void)
u32 old_flags = g->user_sim_cmd_control.flags; u32 old_flags = g->user_sim_cmd_control.flags;
g->user_sim_cmd_control = control; g->user_sim_cmd_control = control;
g->user_sim_cmd_control.flags |= old_flags; g->user_sim_cmd_control.flags |= old_flags;
g->user_hovered_ent = hovered_ent->id; g->user_hovered_ent = hovered_ent->key;
Unlock(&lock); Unlock(&lock);
} }
} }
@ -2146,7 +2146,7 @@ void PP_UpdateUser(void)
UI_BuildLabelF("render time: %F", FmtFloat(SecondsFromNs(g->render_time_ns))); UI_BuildLabelF("render time: %F", FmtFloat(SecondsFromNs(g->render_time_ns)));
UI_BuildLabelF("local player: [%F]", FmtUid(local_player->id.uid)); UI_BuildLabelF("local player: [%F]", FmtUid(local_player->key.uid));
UI_BuildSpacer(UI_EM(1.5, 0)); UI_BuildSpacer(UI_EM(1.5, 0));
Vec2 world_cursor = g->world_cursor; Vec2 world_cursor = g->world_cursor;
@ -2451,7 +2451,7 @@ void PP_UpdateUser(void)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ User update job //~ User update job
JobDef(PP_UpdateUserOrSleep, UNUSED sig, UNUSED id) JobDef(PP_UpdateUserOrSleep, UNUSED sig, UNUSED key)
{ {
PP_SharedUserState *g = &PP_shared_user_state; PP_SharedUserState *g = &PP_shared_user_state;
i64 time_ns = TimeNs(); i64 time_ns = TimeNs();
@ -2511,7 +2511,7 @@ void PP_GenerateuserInputCmds(PP_Client *user_input_client, u64 tick)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Sim update //~ Sim update
JobDef(PP_UpdateSim, UNUSED sig, UNUSED id) JobDef(PP_UpdateSim, UNUSED sig, UNUSED key)
{ {
PP_SharedUserState *g = &PP_shared_user_state; PP_SharedUserState *g = &PP_shared_user_state;
#if 0 #if 0
@ -3014,7 +3014,7 @@ JobDef(PP_UpdateSim, UNUSED sig, UNUSED id)
{ {
PP_Ent *master_player = PP_FirstWithProp(master_ss, PP_Prop_IsMaster); PP_Ent *master_player = PP_FirstWithProp(master_ss, PP_Prop_IsMaster);
/* Update ent id from master */ /* Update ent key from master */
{ {
user_input_client->player_id = master_ss->local_player; user_input_client->player_id = master_ss->local_player;
local_client->player_id = master_ss->local_player; local_client->player_id = master_ss->local_player;
@ -3083,7 +3083,7 @@ JobDef(PP_UpdateSim, UNUSED sig, UNUSED id)
{ {
if (base_ss->valid) if (base_ss->valid)
{ {
PP_SyncSnapshotEnts(base_ss, master_ss, master_player->id, 0); PP_SyncSnapshotEnts(base_ss, master_ss, master_player->key, 0);
} }
else else
{ {
@ -3112,7 +3112,7 @@ JobDef(PP_UpdateSim, UNUSED sig, UNUSED id)
ctx.world = PP_AcquireSnapshot(local_client, prev_ss, step_tick); ctx.world = PP_AcquireSnapshot(local_client, prev_ss, step_tick);
if (!mispredicted_tick && step_tick == step_end_tick) if (!mispredicted_tick && step_tick == step_end_tick)
{ {
PP_SyncSnapshotEnts(ctx.world, master_ss, master_player->id, PP_SyncFlag_NoSyncPredictables); PP_SyncSnapshotEnts(ctx.world, master_ss, master_player->key, PP_SyncFlag_NoSyncPredictables);
} }
PP_StepSim(&ctx); PP_StepSim(&ctx);
prev_ss = ctx.world; prev_ss = ctx.world;

88
src/pp/pp_ent.c
View File

@ -1,7 +1,7 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Acquire //~ Acquire
PP_Ent *PP_AcquireRawEnt(PP_Snapshot *ss, PP_Ent *parent, PP_EntKey id) PP_Ent *PP_AcquireRawEnt(PP_Snapshot *ss, PP_Ent *parent, PP_EntKey key)
{ {
Assert(parent->valid); Assert(parent->valid);
Assert(ss->valid); Assert(ss->valid);
@ -26,7 +26,7 @@ PP_Ent *PP_AcquireRawEnt(PP_Snapshot *ss, PP_Ent *parent, PP_EntKey id)
ent->_is_xform_dirty = 1; ent->_is_xform_dirty = 1;
++ss->num_ents_allocated; ++ss->num_ents_allocated;
PP_SetEntKey(ent, id); PP_SetEntKey(ent, key);
PP_Link(ent, parent); PP_Link(ent, parent);
return ent; return ent;
@ -41,10 +41,10 @@ PP_Ent *PP_AcquireLocalEnt(PP_Ent *parent)
return e; return e;
} }
PP_Ent *PP_AcquireLocalEntWithKey(PP_Ent *parent, PP_EntKey id) PP_Ent *PP_AcquireLocalEntWithKey(PP_Ent *parent, PP_EntKey key)
{ {
PP_Snapshot *ss = parent->ss; PP_Snapshot *ss = parent->ss;
PP_Ent *e = PP_AcquireRawEnt(ss, parent, id); PP_Ent *e = PP_AcquireRawEnt(ss, parent, key);
e->owner = ss->local_player; e->owner = ss->local_player;
return e; return e;
} }
@ -59,16 +59,16 @@ PP_Ent *PP_AcquireSyncSrcEnt(PP_Ent *parent)
return e; return e;
} }
PP_Ent *PP_AcquireSyncSrcEntWithKey(PP_Ent *parent, PP_EntKey id) PP_Ent *PP_AcquireSyncSrcEntWithKey(PP_Ent *parent, PP_EntKey key)
{ {
PP_Snapshot *ss = parent->ss; PP_Snapshot *ss = parent->ss;
PP_Ent *e = PP_AcquireRawEnt(ss, parent, id); PP_Ent *e = PP_AcquireRawEnt(ss, parent, key);
PP_EnableProp(e, PP_Prop_SyncSrc); PP_EnableProp(e, PP_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 key, and coming from the specified owner */
PP_Ent *PP_AcquireSyncDstEnt(PP_Ent *parent, PP_EntKey ent_id, PP_EntKey owner_id) PP_Ent *PP_AcquireSyncDstEnt(PP_Ent *parent, PP_EntKey ent_id, PP_EntKey owner_id)
{ {
PP_Snapshot *ss = parent->ss; PP_Snapshot *ss = parent->ss;
@ -156,7 +156,7 @@ void PP_ActivateEnt(PP_Ent *ent, u64 current_tick)
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Ent id //~ Ent key
u32 PP_IndexFromEnt(PP_Snapshot *ss, PP_Ent *ent) u32 PP_IndexFromEnt(PP_Snapshot *ss, PP_Ent *ent)
{ {
@ -175,17 +175,17 @@ PP_Ent *PP_EntFromIndex(PP_Snapshot *ss, u32 index)
} }
} }
PP_EntBin *PP_EntBinFromKey(PP_Snapshot *ss, PP_EntKey id) PP_EntBin *PP_EntBinFromKey(PP_Snapshot *ss, PP_EntKey key)
{ {
return &ss->id_bins[id.uid.lo % ss->num_id_bins]; return &ss->key_bins[key.uid.lo % ss->num_key_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 key to change) */
void PP_SetEntKey(PP_Ent *ent, PP_EntKey id) void PP_SetEntKey(PP_Ent *ent, PP_EntKey key)
{ {
PP_Snapshot *ss = ent->ss; PP_Snapshot *ss = ent->ss;
PP_EntKey old_id = ent->id; PP_EntKey old_id = ent->key;
if (!PP_EqEntKey(old_id, id)) if (!PP_EqEntKey(old_id, key))
{ {
/* Release old from lookup */ /* Release old from lookup */
if (!PP_IsNilEntKey(old_id)) if (!PP_IsNilEntKey(old_id))
@ -201,7 +201,7 @@ void PP_SetEntKey(PP_Ent *ent, PP_EntKey id)
{ {
next_index = search->next_in_id_bin; next_index = search->next_in_id_bin;
next = PP_EntFromIndex(ss, next_index); next = PP_EntFromIndex(ss, next_index);
if (PP_EqEntKey(search->id, old_id)) if (PP_EqEntKey(search->key, old_id))
{ {
break; break;
} }
@ -211,7 +211,7 @@ void PP_SetEntKey(PP_Ent *ent, PP_EntKey id)
search = next; search = next;
} }
/* Old id not in bin, this should be impossible. */ /* Old key not in bin, this should be impossible. */
Assert(search->valid); Assert(search->valid);
if (prev->valid) if (prev->valid)
@ -233,18 +233,18 @@ void PP_SetEntKey(PP_Ent *ent, PP_EntKey id)
} }
} }
/* Insert new id into lookup */ /* Insert new key into lookup */
if (!PP_IsNilEntKey(id)) if (!PP_IsNilEntKey(key))
{ {
#if RtcIsEnabled #if RtcIsEnabled
{ {
PP_Ent *existing = PP_EntFromKey(ss, id); PP_Ent *existing = PP_EntFromKey(ss, key);
/* 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
PP_EntBin *bin = PP_EntBinFromKey(ss, id); PP_EntBin *bin = PP_EntBinFromKey(ss, key);
u32 ent_index = PP_IndexFromEnt(ss, ent); u32 ent_index = PP_IndexFromEnt(ss, ent);
PP_Ent *last = PP_EntFromIndex(ss, bin->last); PP_Ent *last = PP_EntFromIndex(ss, bin->last);
if (last->valid) if (last->valid)
@ -260,20 +260,20 @@ void PP_SetEntKey(PP_Ent *ent, PP_EntKey id)
bin->last = ent_index; bin->last = ent_index;
} }
ent->id = id; ent->key = key;
} }
} }
PP_Ent *PP_EntFromKey(PP_Snapshot *ss, PP_EntKey id) PP_Ent *PP_EntFromKey(PP_Snapshot *ss, PP_EntKey key)
{ {
PP_Ent *result = PP_NilEnt(); PP_Ent *result = PP_NilEnt();
if (!PP_IsNilEntKey(id) && ss->valid) if (!PP_IsNilEntKey(key) && ss->valid)
{ {
PP_EntBin *bin = PP_EntBinFromKey(ss, id); PP_EntBin *bin = PP_EntBinFromKey(ss, key);
for (PP_Ent *e = PP_EntFromIndex(ss, bin->first); e->valid; e = PP_EntFromIndex(ss, e->next_in_id_bin)) for (PP_Ent *e = PP_EntFromIndex(ss, bin->first); e->valid; e = PP_EntFromIndex(ss, e->next_in_id_bin))
{ {
if (PP_EqEntKey(e->id, id)) if (PP_EqEntKey(e->key, key))
{ {
result = e; result = e;
break; break;
@ -290,7 +290,7 @@ PP_EntKey PP_RandomKey(void)
return result; return result;
} }
/* Returns the deterministic id of the contact constraint ent id that should be produced from e0 & e1 colliding */ /* Returns the deterministic key of the contact constraint ent key that should be produced from e0 & e1 colliding */
PP_EntKey PP_ContactConstraintKeyFromContactingKeys(PP_EntKey player_id, PP_EntKey id0, PP_EntKey id1) PP_EntKey PP_ContactConstraintKeyFromContactingKeys(PP_EntKey player_id, PP_EntKey id0, PP_EntKey id1)
{ {
PP_EntKey result = ZI; PP_EntKey result = ZI;
@ -301,7 +301,7 @@ PP_EntKey PP_ContactConstraintKeyFromContactingKeys(PP_EntKey player_id, PP_EntK
return result; return result;
} }
/* Returns the deterministic id of the debug contact constraint ent id that should be produced from e0 & e1 colliding */ /* Returns the deterministic key of the debug contact constraint ent key that should be produced from e0 & e1 colliding */
PP_EntKey PP_CollisionDebugKeyFromKeys(PP_EntKey player_id, PP_EntKey id0, PP_EntKey id1) PP_EntKey PP_CollisionDebugKeyFromKeys(PP_EntKey player_id, PP_EntKey id0, PP_EntKey id1)
{ {
PP_EntKey result = ZI; PP_EntKey result = ZI;
@ -312,7 +312,7 @@ PP_EntKey PP_CollisionDebugKeyFromKeys(PP_EntKey player_id, PP_EntKey id0, PP_En
return result; return result;
} }
/* Returns the deterministic id of the tile chunk that should be produced at chunk pos */ /* Returns the deterministic key of the tile chunk that should be produced at chunk pos */
PP_EntKey PP_TileChunkKeyFromIndex(Vec2I32 chunk_index) PP_EntKey PP_TileChunkKeyFromIndex(Vec2I32 chunk_index)
{ {
PP_EntKey result = ZI; PP_EntKey result = ZI;
@ -380,7 +380,7 @@ void PP_Link(PP_Ent *ent, PP_Ent *parent)
PP_Unlink(ent); PP_Unlink(ent);
} }
PP_EntKey ent_id = ent->id; PP_EntKey ent_id = ent->key;
PP_EntKey last_child_id = parent->last; PP_EntKey last_child_id = parent->last;
PP_Ent *last_child = PP_EntFromKey(ss, last_child_id); PP_Ent *last_child = PP_EntFromKey(ss, last_child_id);
if (last_child->valid) if (last_child->valid)
@ -404,7 +404,7 @@ void PP_Link(PP_Ent *ent, PP_Ent *parent)
ent->top = parent->top; ent->top = parent->top;
} }
ent->parent = parent->id; ent->parent = parent->key;
} }
/* NOTE: PP_Ent will be dangling after calling this, should re-link to root ent. */ /* NOTE: PP_Ent will be dangling after calling this, should re-link to root ent. */
@ -420,19 +420,19 @@ void PP_Unlink(PP_Ent *ent)
/* Unlink from parent & siblings */ /* Unlink from parent & siblings */
if (prev->valid) if (prev->valid)
{ {
prev->next = next->id; prev->next = next->key;
} }
else else
{ {
parent->first = next->id; parent->first = next->key;
} }
if (next->valid) if (next->valid)
{ {
next->prev = prev->id; next->prev = prev->key;
} }
else else
{ {
parent->last = prev->id; parent->last = prev->key;
} }
ent->prev = PP_NilEntKey; ent->prev = PP_NilEntKey;
ent->next = PP_NilEntKey; ent->next = PP_NilEntKey;
@ -652,7 +652,7 @@ PP_TileKind PP_TileKindFromChunk(PP_Ent *chunk_ent, Vec2I32 local_tile_index)
void PP_LerpEnt(PP_Ent *e, PP_Ent *e0, PP_Ent *e1, f64 blend) void PP_LerpEnt(PP_Ent *e, PP_Ent *e0, PP_Ent *e1, f64 blend)
{ {
if (PP_IsValidAndActive(e0) && PP_IsValidAndActive(e1) if (PP_IsValidAndActive(e0) && PP_IsValidAndActive(e1)
&& PP_EqEntKey(e0->id, e1->id) && PP_EqEntKey(e0->key, e1->key)
&& 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);
@ -699,11 +699,11 @@ void PP_CreateMissingEntsFromSnapshots(PP_Ent *local_parent, PP_Ent *remote, PP_
PP_Snapshot *local_ss = local_parent->ss; PP_Snapshot *local_ss = local_parent->ss;
PP_Snapshot *remote_ss = remote->ss; PP_Snapshot *remote_ss = remote->ss;
PP_EntKey id = remote->id; PP_EntKey key = remote->key;
PP_Ent *local_ent = PP_EntFromKey(local_ss, id); PP_Ent *local_ent = PP_EntFromKey(local_ss, key);
if (!local_ent->valid) if (!local_ent->valid)
{ {
local_ent = PP_AcquireSyncDstEnt(local_parent, id, remote_player); local_ent = PP_AcquireSyncDstEnt(local_parent, key, remote_player);
} }
for (PP_Ent *remote_child = PP_EntFromKey(remote_ss, remote->first); remote_child->valid; remote_child = PP_EntFromKey(remote_ss, remote_child->next)) for (PP_Ent *remote_child = PP_EntFromKey(remote_ss, remote->first); remote_child->valid; remote_child = PP_EntFromKey(remote_ss, remote_child->next))
{ {
@ -719,10 +719,10 @@ void PP_SyncEnt(PP_Ent *local, PP_Ent *remote)
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(PP_EqEntKey(local->id, old.id)); Assert(PP_EqEntKey(local->key, old.key));
local->ss = old.ss; local->ss = old.ss;
local->id = old.id; local->key = old.key;
/* Keep local tree */ /* Keep local tree */
local->parent = old.parent; local->parent = old.parent;
@ -807,7 +807,7 @@ void PP_EncodeEnt(BB_Writer *bw, PP_Ent *e0, PP_Ent *e1)
/* FIXME: Things like xforms need to be retreived manually rather than memcopied. /* FIXME: Things like xforms need to be retreived manually rather than memcopied.
* This will also be true for things like ent handles once uids are implemented. */ * This will also be true for things like ent keys once uids are implemented. */
/* TODO: Granular delta encoding */ /* TODO: Granular delta encoding */
@ -856,10 +856,10 @@ void PP_DecodeEnt(BB_Reader *br, PP_Ent *e)
} }
decoded.ss = e->ss; decoded.ss = e->ss;
PP_EntKey old_id = e->id; PP_EntKey old_id = e->key;
PP_EntKey new_id = decoded.id; PP_EntKey new_id = decoded.key;
CopyStruct(e, &decoded); CopyStruct(e, &decoded);
e->id = old_id; e->key = old_id;
if (!PP_EqEntKey(old_id, new_id)) if (!PP_EqEntKey(old_id, new_id))
{ {
PP_SetEntKey(e, new_id); PP_SetEntKey(e, new_id);

36
src/pp/pp_ent.h
View File

@ -71,7 +71,7 @@ Struct(PP_Ent)
//- Metadata //- Metadata
b32 valid; /* Is this ent allocated in memory that can be written to (can always be read) */ b32 valid; /* Is this ent allocated in memory that can be written to (can always be read) */
PP_EntKey id; PP_EntKey key;
u64 props[(PP_Prop_Count + 63) / 64]; u64 props[(PP_Prop_Count + 63) / 64];
u64 continuity_gen; u64 continuity_gen;
@ -81,7 +81,7 @@ Struct(PP_Ent)
/* Is ent a child of the root ent */ /* Is ent a child of the root ent */
b32 is_top; b32 is_top;
/* The id of the top level parent of the ent tree (if ent is top then this point to itself) */ /* The key of the top level parent of the ent tree (if ent is top then this point to itself) */
PP_EntKey top; PP_EntKey top;
/* Tree */ /* Tree */
@ -101,10 +101,10 @@ Struct(PP_Ent)
/* PP_Prop_SyncSrc */ /* PP_Prop_SyncSrc */
/* PP_Prop_SyncDst */ /* PP_Prop_SyncDst */
/* Id of the player that owns simulation for this entity */ /* Key of the player that owns simulation for this entity */
PP_EntKey owner; PP_EntKey owner;
/* Id of the player that should predict simulation of this this entity locally */ /* Key of the player that should predict simulation of this this entity locally */
PP_EntKey predictor; PP_EntKey predictor;
//- Position //- Position
@ -162,7 +162,7 @@ Struct(PP_Ent)
/* FIXME: Lerp */ /* FIXME: Lerp */
PP_ClientKey player_client_handle; /* The client key on the master sim's machine */ PP_ClientKey player_client_key; /* The client key on the master sim's machine */
PP_ControlData player_control; PP_ControlData player_control;
Vec2 player_cursor_pos; Vec2 player_cursor_pos;
@ -188,7 +188,7 @@ Struct(PP_Ent)
ContactDebugData collision_debug_data; ContactDebugData collision_debug_data;
#endif #endif
PP_SpaceEntryKey space_handle; PP_SpaceEntryKey space_key;
//- Constraints / joints //- Constraints / joints
@ -394,27 +394,27 @@ Inline PP_Ent *PP_NilEnt(void)
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Id types //~ Key types
#define PP_NilEntKey ((PP_EntKey) { UID(0, 0) }) #define PP_NilEntKey ((PP_EntKey) { UID(0, 0) })
#define PP_RootEntKey ((PP_EntKey) { UID(0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa) }) #define PP_RootEntKey ((PP_EntKey) { UID(0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa) })
/* Id magic number constants (to be used in conjunction with ent ids in deterministic id combinations) */ /* Key magic number constants (to be used in conjunction with ent ids in deterministic key combinations) */
#define PP_TileChunkBasisUid (UID(0x3ce42de071dd226b, 0x9b566f7df30c813a)) #define PP_TileChunkBasisUid (UID(0x3ce42de071dd226b, 0x9b566f7df30c813a))
#define PP_ContactBasisUid (UID(0x6a2a5d2dbecf534f, 0x0a8ca7c372a015af)) #define PP_ContactBasisUid (UID(0x6a2a5d2dbecf534f, 0x0a8ca7c372a015af))
#define PP_CollisionDebugBasisUid (UID(0x302c01182013bb02, 0x570bd270399d11a5)) #define PP_CollisionDebugBasisUid (UID(0x302c01182013bb02, 0x570bd270399d11a5))
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Id helpers //~ Key helpers
Inline b32 PP_EqEntKey(PP_EntKey a, PP_EntKey b) Inline b32 PP_EqEntKey(PP_EntKey a, PP_EntKey b)
{ {
return EqUid(a.uid, b.uid); return EqUid(a.uid, b.uid);
} }
Inline b32 PP_IsNilEntKey(PP_EntKey id) Inline b32 PP_IsNilEntKey(PP_EntKey key)
{ {
return EqUid(id.uid, PP_NilEntKey.uid); return EqUid(key.uid, PP_NilEntKey.uid);
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
@ -474,11 +474,11 @@ Inline b32 PP_ShouldSimulate(PP_Ent *ent)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Acquire operations //~ Acquire operations
PP_Ent *PP_AcquireRawEnt(PP_Snapshot *ss, PP_Ent *parent, PP_EntKey id); PP_Ent *PP_AcquireRawEnt(PP_Snapshot *ss, PP_Ent *parent, PP_EntKey key);
PP_Ent *PP_AcquireLocalEnt(PP_Ent *parent); PP_Ent *PP_AcquireLocalEnt(PP_Ent *parent);
PP_Ent *PP_AcquireLocalEntWithKey(PP_Ent *parent, PP_EntKey id); PP_Ent *PP_AcquireLocalEntWithKey(PP_Ent *parent, PP_EntKey key);
PP_Ent *PP_AcquireSyncSrcEnt(PP_Ent *parent); PP_Ent *PP_AcquireSyncSrcEnt(PP_Ent *parent);
PP_Ent *PP_AcquireSyncSrcEntWithKey(PP_Ent *parent, PP_EntKey id); PP_Ent *PP_AcquireSyncSrcEntWithKey(PP_Ent *parent, PP_EntKey key);
PP_Ent *PP_AcquireSyncDstEnt(PP_Ent *parent, PP_EntKey ent_id, PP_EntKey owner_id); PP_Ent *PP_AcquireSyncDstEnt(PP_Ent *parent, PP_EntKey ent_id, PP_EntKey owner_id);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
@ -494,13 +494,13 @@ void PP_ReleaseAllWithProp(PP_Snapshot *ss, PP_Prop prop);
void PP_ActivateEnt(PP_Ent *ent, u64 current_tick); void PP_ActivateEnt(PP_Ent *ent, u64 current_tick);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Id operations //~ Key operations
u32 PP_IndexFromEnt(PP_Snapshot *ss, PP_Ent *ent); u32 PP_IndexFromEnt(PP_Snapshot *ss, PP_Ent *ent);
PP_Ent *PP_EntFromIndex(PP_Snapshot *ss, u32 index); PP_Ent *PP_EntFromIndex(PP_Snapshot *ss, u32 index);
PP_EntBin *PP_EntBinFromKey(PP_Snapshot *ss, PP_EntKey id); PP_EntBin *PP_EntBinFromKey(PP_Snapshot *ss, PP_EntKey key);
void PP_SetEntKey(PP_Ent *ent, PP_EntKey id); void PP_SetEntKey(PP_Ent *ent, PP_EntKey key);
PP_Ent *PP_EntFromKey(PP_Snapshot *ss, PP_EntKey id); PP_Ent *PP_EntFromKey(PP_Snapshot *ss, PP_EntKey key);
PP_EntKey PP_RandomKey(void); PP_EntKey PP_RandomKey(void);
PP_EntKey PP_ContactConstraintKeyFromContactingKeys(PP_EntKey player_id, PP_EntKey id0, PP_EntKey id1); PP_EntKey PP_ContactConstraintKeyFromContactingKeys(PP_EntKey player_id, PP_EntKey id0, PP_EntKey id1);
PP_EntKey PP_CollisionDebugKeyFromKeys(PP_EntKey player_id, PP_EntKey id0, PP_EntKey id1); PP_EntKey PP_CollisionDebugKeyFromKeys(PP_EntKey player_id, PP_EntKey id0, PP_EntKey id1);

26
src/pp/pp_phys.c
View File

@ -43,14 +43,14 @@ void PP_CreateAndUpdateContacts(PP_PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_it
if (check1->local_collider.count <= 0) continue; if (check1->local_collider.count <= 0) continue;
if (!PP_CanEntsContact(check0, check1)) continue; if (!PP_CanEntsContact(check0, check1)) continue;
/* Deterministic order based on entity id */ /* Deterministic order based on entity key */
PP_Ent *e0; PP_Ent *e0;
PP_Ent *e1; PP_Ent *e1;
Xform e0_xf; Xform e0_xf;
Xform e1_xf; Xform e1_xf;
CLD_Shape e0_collider; CLD_Shape e0_collider;
CLD_Shape e1_collider; CLD_Shape e1_collider;
if (check0->id.uid.hi < check1->id.uid.hi) if (check0->key.uid.hi < check1->key.uid.hi)
{ {
e0 = check0; e0 = check0;
e1 = check1; e1 = check1;
@ -69,7 +69,7 @@ void PP_CreateAndUpdateContacts(PP_PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_it
e1_collider = check0_collider; e1_collider = check0_collider;
} }
PP_EntKey constraint_id = PP_ContactConstraintKeyFromContactingKeys(local_player, e0->id, e1->id); PP_EntKey constraint_id = PP_ContactConstraintKeyFromContactingKeys(local_player, e0->key, e1->key);
PP_Ent *constraint_ent = PP_EntFromKey(ss, constraint_id); PP_Ent *constraint_ent = PP_EntFromKey(ss, constraint_id);
if (constraint_ent->valid) if (constraint_ent->valid)
@ -101,8 +101,8 @@ void PP_CreateAndUpdateContacts(PP_PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_it
is_start = 1; is_start = 1;
/* Create constraint */ /* Create constraint */
constraint_ent = PP_AcquireLocalEntWithKey(root, constraint_id); constraint_ent = PP_AcquireLocalEntWithKey(root, constraint_id);
constraint_ent->contact_constraint_data.e0 = e0->id; constraint_ent->contact_constraint_data.e0 = e0->key;
constraint_ent->contact_constraint_data.e1 = e1->id; constraint_ent->contact_constraint_data.e1 = e1->key;
/* 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 = !PP_HasProp(e0, PP_Prop_Solid) || !PP_HasProp(e1, PP_Prop_Solid) || constraint_ent->contact_constraint_data.skip_solve = !PP_HasProp(e0, PP_Prop_Solid) || !PP_HasProp(e1, PP_Prop_Solid) ||
!(PP_HasProp(e0, PP_Prop_Dynamic) || PP_HasProp(e1, PP_Prop_Dynamic)); !(PP_HasProp(e0, PP_Prop_Dynamic) || PP_HasProp(e1, PP_Prop_Dynamic));
@ -197,8 +197,8 @@ void PP_CreateAndUpdateContacts(PP_PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_it
if (collision_callback) if (collision_callback)
{ {
PP_CollisionData data = ZI; PP_CollisionData data = ZI;
data.e0 = e0->id; data.e0 = e0->key;
data.e1 = e1->id; data.e1 = e1->key;
data.normal = collision_result.normal; data.normal = collision_result.normal;
data.is_start = is_start; data.is_start = is_start;
data.dt = elapsed_dt; data.dt = elapsed_dt;
@ -250,7 +250,7 @@ void PP_CreateAndUpdateContacts(PP_PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_it
/* TODO: Remove this (debugging) */ /* TODO: Remove this (debugging) */
#if COLLIDER_DEBUG && COLLIDER_DEBUG_DETAILED #if COLLIDER_DEBUG && COLLIDER_DEBUG_DETAILED
{ {
PP_EntKey dbg_ent_id = PP_CollisionDebugKeyFromKeys(local_player, e0->id, e1->id); PP_EntKey dbg_ent_id = PP_CollisionDebugKeyFromKeys(local_player, e0->key, e1->key);
PP_Ent *dbg_ent = PP_EntFromKey(ss, dbg_ent_id); PP_Ent *dbg_ent = PP_EntFromKey(ss, dbg_ent_id);
if (!dbg_ent->valid) if (!dbg_ent->valid)
{ {
@ -261,8 +261,8 @@ void PP_CreateAndUpdateContacts(PP_PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_it
ContactDebugData *dbg = &dbg_ent->collision_debug_data; ContactDebugData *dbg = &dbg_ent->collision_debug_data;
dbg->e0 = e0->id; dbg->e0 = e0->key;
dbg->e1 = e1->id; dbg->e1 = e1->key;
dbg->collision_result = collision_result; dbg->collision_result = collision_result;
if (constraint) if (constraint)
@ -1290,11 +1290,11 @@ void PP_UpdateAabbs(PP_PhysStepCtx *ctx)
if (ent->local_collider.count > 0) if (ent->local_collider.count > 0)
{ {
Xform xf = PP_XformFromEnt(ent); Xform xf = PP_XformFromEnt(ent);
PP_SpaceEntry *space_entry = PP_SpaceEntryFromKey(space, ent->space_handle); PP_SpaceEntry *space_entry = PP_SpaceEntryFromKey(space, ent->space_key);
if (!space_entry->valid) if (!space_entry->valid)
{ {
space_entry = PP_AcquireSpaceEntry(space, ent->id); space_entry = PP_AcquireSpaceEntry(space, ent->key);
ent->space_handle = space_entry->handle; ent->space_key = space_entry->key;
} }
Aabb aabb = CLD_AabbFromShape(&ent->local_collider, xf); Aabb aabb = CLD_AabbFromShape(&ent->local_collider, xf);
PP_UpdateSpaceEntryAabb(space_entry, aabb); PP_UpdateSpaceEntryAabb(space_entry, aabb);

92
src/pp/pp_sim.c
View File

@ -2,26 +2,26 @@
* *
* PP_Client store -> clients -> snapshots -> ents * PP_Client store -> clients -> snapshots -> ents
* *
* A client store holds clients, which can be retrieved by client handle or by a host channel id (if one is assigned). * A client store holds clients, which can be retrieved by client key or by a host channel id (if one is assigned).
* *
* A client holds snapshots, which can be retrieved by tick number. * A client holds snapshots, which can be retrieved by tick number.
* - The snapshots stored in clients & the contents of those snapshots are determined from data transmitted by the client. * - The snapshots stored in clients & the contents of those snapshots are determined from data transmitted by the client.
* - Different kinds of clients will transmit different subsets of snapshot data (e.g. a master client will transmit most ent state, while slave clients may just transmit 1 or more command ents) * - Different kinds of clients will transmit different subsets of snapshot data (e.g. a master client will transmit most ent state, while slave clients may just transmit 1 or more command ents)
* - A client will never hold more than one snapshot for the same tick (e.g. a client will never have 2 snapshots at tick 5) * - A client will never hold more than one snapshot for the same tick (e.g. a client will never have 2 snapshots at tick 5)
* *
* A snapshot holds the ent tree for a particular tick, in which ents can be retrieved by ent id. * A snapshot holds the ent tree for a particular tick, in which ents can be retrieved by ent key.
* - A tick is the quantized time step that all clients implicitly conform to. * - A tick is the quantized time step that all clients implicitly conform to.
* *
* An ent is the smallest unit of simulation state. * An ent is the smallest unit of simulation state.
* - It is assigned a 128 bit unique identifer generated at allocation time. * - It is assigned a 128 bit unique identifer generated at allocation time.
* - This id is used to refer to other ents in the tree and to sync ents accross clients. * - This key is used to refer to other ents in the tree and to sync ents accross clients.
* - This id is usually random, but can be deterministic under certain conditions. * - This key is usually random, but can be deterministic under certain conditions.
* - For example, instead of storing a contact constraint lookup table, contact constraints are * - For example, instead of storing a contact constraint lookup table, contact constraints are
* retrieved by searching for the ent with the id resulting from combining the ent ids of the * retrieved by searching for the ent with the key resulting from combining the ent keys of the
* two contacting entities (plus a unique 'basis' ent id used for all contact constraints). * two contacting entities (plus a unique 'basis' ent key used for all contact constraints).
* - The ent also implicitly has a 32 bit index, which is just its offset from the start of the entity array in the local snapshot. * - The ent also implicitly has a 32 bit index, which is just its offset from the start of the entity array in the local snapshot.
* - Since index is based on offset which remains stable regardless of snapshot memory location, it * - Since index is based on offset which remains stable regardless of snapshot memory location, it
* is used when working in contexts where id is irrelevant. * is used when working in contexts where key is irrelevant.
*/ */
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
@ -57,7 +57,7 @@ void PP_StartupSim(void)
g->nil_ent = PushStruct(g->nil_arena, PP_Ent); g->nil_ent = PushStruct(g->nil_arena, PP_Ent);
g->nil_ent->ss = PP_NilSnapshot(); g->nil_ent->ss = PP_NilSnapshot();
g->nil_ent->valid = 0; g->nil_ent->valid = 0;
g->nil_ent->id = PP_NilEntKey; g->nil_ent->key = PP_NilEntKey;
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;
@ -111,27 +111,27 @@ void PP_ReleaseClientStore(PP_ClientStore *store)
PP_Client *PP_AcquireClient(PP_ClientStore *store) PP_Client *PP_AcquireClient(PP_ClientStore *store)
{ {
PP_ClientKey handle = ZI; PP_ClientKey key = ZI;
PP_Client *client = PP_ClientFromKey(store, store->first_free_client); PP_Client *client = PP_ClientFromKey(store, store->first_free_client);
if (client->valid) if (client->valid)
{ {
store->first_free_client = client->next_free; store->first_free_client = client->next_free;
handle = client->handle; key = client->key;
++handle.gen; ++key.gen;
} }
else else
{ {
client = PushStructNoZero(store->clients_arena, PP_Client); client = PushStructNoZero(store->clients_arena, PP_Client);
handle.gen = 1; key.gen = 1;
handle.idx = store->num_clients_reserved; key.idx = store->num_clients_reserved;
++store->num_clients_reserved; ++store->num_clients_reserved;
} }
++store->num_clients_allocated; ++store->num_clients_allocated;
*client = *PP_NilClient(); *client = *PP_NilClient();
client->store = store; client->store = store;
client->valid = 1; client->valid = 1;
client->handle = handle; client->key = key;
client->snapshots_arena = AcquireArena(Gibi(8)); client->snapshots_arena = AcquireArena(Gibi(8));
client->num_snapshot_lookup_bins = PP_TickLookupBinsCount; client->num_snapshot_lookup_bins = PP_TickLookupBinsCount;
@ -163,9 +163,9 @@ void PP_ReleaseClient(PP_Client *client)
PP_ClientStore *store = client->store; PP_ClientStore *store = client->store;
client->valid = 0; client->valid = 0;
client->next_free = store->first_free_client; client->next_free = store->first_free_client;
store->first_free_client = client->handle; store->first_free_client = client->key;
--store->num_clients_allocated; --store->num_clients_allocated;
++client->handle.gen; ++client->key.gen;
ReleaseArena(client->snapshots_arena); ReleaseArena(client->snapshots_arena);
} }
@ -191,19 +191,19 @@ void PP_SetClientChannelId(PP_Client *client, N_ChannelId channel_id)
PP_Client *next = PP_ClientFromKey(store, client->next_in_bin); PP_Client *next = PP_ClientFromKey(store, client->next_in_bin);
if (prev->valid) if (prev->valid)
{ {
prev->next_in_bin = next->handle; prev->next_in_bin = next->key;
} }
else else
{ {
bin->first = next->handle; bin->first = next->key;
} }
if (next->valid) if (next->valid)
{ {
next->prev_in_bin = prev->handle; next->prev_in_bin = prev->key;
} }
else else
{ {
bin->last = prev->handle; bin->last = prev->key;
} }
} }
@ -220,14 +220,14 @@ void PP_SetClientChannelId(PP_Client *client, N_ChannelId channel_id)
PP_Client *prev_in_bin = PP_ClientFromKey(store, bin->last); PP_Client *prev_in_bin = PP_ClientFromKey(store, bin->last);
if (prev_in_bin->valid) if (prev_in_bin->valid)
{ {
prev_in_bin->next_in_bin = client->handle; prev_in_bin->next_in_bin = client->key;
client->prev_in_bin = prev_in_bin->handle; client->prev_in_bin = prev_in_bin->key;
} }
else else
{ {
bin->first = client->handle; bin->first = client->key;
} }
bin->last = client->handle; bin->last = client->key;
} }
} }
} }
@ -249,12 +249,12 @@ PP_Client *PP_ClientFromChannelId(PP_ClientStore *store, N_ChannelId channel_id)
return result; return result;
} }
PP_Client *PP_ClientFromKey(PP_ClientStore *store, PP_ClientKey handle) PP_Client *PP_ClientFromKey(PP_ClientStore *store, PP_ClientKey key)
{ {
if (handle.gen != 0 && handle.idx < store->num_clients_reserved) if (key.gen != 0 && key.idx < store->num_clients_reserved)
{ {
PP_Client *client = &store->clients[handle.idx]; PP_Client *client = &store->clients[key.idx];
if (client->handle.gen == handle.gen) if (client->key.gen == key.gen)
{ {
return client; return client;
} }
@ -313,19 +313,19 @@ PP_Snapshot *PP_AcquireSnapshot(PP_Client *client, PP_Snapshot *src, u64 tick)
ss->local_player = src->local_player; ss->local_player = src->local_player;
ss->phys_iteration = src->phys_iteration; ss->phys_iteration = src->phys_iteration;
/* Copy id lookup bins */ /* Copy key lookup bins */
ss->num_id_bins = src->num_id_bins > 0 ? src->num_id_bins : PP_IdLookupBinsCount; ss->num_key_bins = src->num_key_bins > 0 ? src->num_key_bins : PP_KeyLookupBinsCount;
ss->id_bins = PushStructsNoZero(ss->arena, PP_EntBin, ss->num_id_bins); ss->key_bins = PushStructsNoZero(ss->arena, PP_EntBin, ss->num_key_bins);
if (src->num_id_bins > 0) if (src->num_key_bins > 0)
{ {
for (u64 i = 0; i < src->num_id_bins; ++i) for (u64 i = 0; i < src->num_key_bins; ++i)
{ {
ss->id_bins[i] = src->id_bins[i]; ss->key_bins[i] = src->key_bins[i];
} }
} }
else else
{ {
ZeroBytes(ss->id_bins, sizeof(*ss->id_bins) * ss->num_id_bins); ZeroBytes(ss->key_bins, sizeof(*ss->key_bins) * ss->num_key_bins);
} }
/* Copy entities */ /* Copy entities */
@ -344,7 +344,7 @@ PP_Snapshot *PP_AcquireSnapshot(PP_Client *client, PP_Snapshot *src, u64 tick)
++ss->num_ents_reserved; ++ss->num_ents_reserved;
} }
/* Push root ent with constant id */ /* Push root ent with constant key */
{ {
PP_Ent *root = PushStructNoZero(ss->ents_arena, PP_Ent); PP_Ent *root = PushStructNoZero(ss->ents_arena, PP_Ent);
*root = *PP_NilEnt(); *root = *PP_NilEnt();
@ -750,7 +750,7 @@ void PP_SyncSnapshotEnts(PP_Snapshot *local_ss, PP_Snapshot *remote_ss, PP_EntKe
} }
if (should_sync) if (should_sync)
{ {
PP_Ent *remote_ent = PP_EntFromKey(remote_ss, local_ent->id); PP_Ent *remote_ent = PP_EntFromKey(remote_ss, local_ent->key);
if (remote_ent->valid) if (remote_ent->valid)
{ {
/* Copy all ent data from remote */ /* Copy all ent data from remote */
@ -799,20 +799,20 @@ void PP_EncodeSnapshot(BB_Writer *bw, PP_Client *receiver, PP_Snapshot *ss0, PP_
BB_WriteUid(bw, receiver->player_id.uid); BB_WriteUid(bw, receiver->player_id.uid);
/* Id bins */ /* Key bins */
/* TODO: Don't encode these */ /* TODO: Don't encode these */
BB_WriteDebugMarker(bw, Lit("SNAPSHOT BINS")); BB_WriteDebugMarker(bw, Lit("SNAPSHOT BINS"));
for (u64 i = 0; i < ss1->num_id_bins; ++i) for (u64 i = 0; i < ss1->num_key_bins; ++i)
{ {
u32 old_first = 0; u32 old_first = 0;
u32 old_last = 0; u32 old_last = 0;
if (i < ss0->num_id_bins) if (i < ss0->num_key_bins)
{ {
PP_EntBin *old_bin = &ss0->id_bins[i]; PP_EntBin *old_bin = &ss0->key_bins[i];
old_first = old_bin->first; old_first = old_bin->first;
old_last = old_bin->last; old_last = old_bin->last;
} }
PP_EntBin *bin = &ss1->id_bins[i]; PP_EntBin *bin = &ss1->key_bins[i];
b32 first_diff = bin->first != old_first; b32 first_diff = bin->first != old_first;
b32 last_diff = bin->last != old_last; b32 last_diff = bin->last != old_last;
if (first_diff || last_diff) if (first_diff || last_diff)
@ -876,7 +876,7 @@ void PP_DecodeSnapshot(BB_Reader *br, PP_Snapshot *ss)
ss->local_player = (PP_EntKey){ .uid = BB_ReadUid(br) }; ss->local_player = (PP_EntKey){ .uid = BB_ReadUid(br) };
/* Id bins */ /* Key bins */
/* TODO: Don't decode these, determine them implicitly from decoded ents */ /* TODO: Don't decode these, determine them implicitly from decoded ents */
BB_ReadDebugMarker(br, Lit("SNAPSHOT BINS")); BB_ReadDebugMarker(br, Lit("SNAPSHOT BINS"));
{ {
@ -884,9 +884,9 @@ void PP_DecodeSnapshot(BB_Reader *br, PP_Snapshot *ss)
while (bin_changed) while (bin_changed)
{ {
u32 bin_index = BB_ReadUV(br); u32 bin_index = BB_ReadUV(br);
if (bin_index < ss->num_id_bins) if (bin_index < ss->num_key_bins)
{ {
PP_EntBin *bin = &ss->id_bins[bin_index]; PP_EntBin *bin = &ss->key_bins[bin_index];
if (BB_ReadBit(br)) if (BB_ReadBit(br))
{ {
bin->first = BB_ReadUV(br); bin->first = BB_ReadUV(br);
@ -1005,7 +1005,7 @@ void PP_EncodeSnapshot(BB_Writer *bw, PP_Client *receiver, PP_Snapshot *ss0, PP_
BB_WriteBit(e1->valid); BB_WriteBit(e1->valid);
if (e1->valid) if (e1->valid)
{ {
BB_WriteUid(bw, e1->id.uid); BB_WriteUid(bw, e1->key.uid);
} }
} }
else else

18
src/pp/pp_sim.h
View File

@ -12,7 +12,7 @@ Struct(PP_ClientKey)
u32 gen; u32 gen;
}; };
#define PP_NilClientHandle ((PP_ClientKey) { .gen = 0, .idx = 0 }) #define PP_NilClientKey ((PP_ClientKey) { .gen = 0, .idx = 0 })
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
@ -59,7 +59,7 @@ Struct(PP_SnapshotLookupBin)
Struct(PP_Client) Struct(PP_Client)
{ {
b32 valid; b32 valid;
PP_ClientKey handle; PP_ClientKey key;
PP_ClientStore *store; PP_ClientStore *store;
Arena *snapshots_arena; Arena *snapshots_arena;
@ -74,7 +74,7 @@ Struct(PP_Client)
PP_ClientKey next_in_bin; PP_ClientKey next_in_bin;
PP_ClientKey prev_in_bin; PP_ClientKey prev_in_bin;
/* The client's player entity id in the master sim (if relevant) */ /* The client's player entity key in the master sim (if relevant) */
PP_EntKey player_id; PP_EntKey player_id;
/* This is the highest confirmed tick of ours that we know this client has received */ /* This is the highest confirmed tick of ours that we know this client has received */
@ -205,12 +205,12 @@ Struct(PP_Snapshot)
/* The last physics iteration (used for tracking contact lifetime) */ /* The last physics iteration (used for tracking contact lifetime) */
u64 phys_iteration; u64 phys_iteration;
/* The id of the receiver's player in the snapshot */ /* The key of the receiver's player in the snapshot */
PP_EntKey local_player; PP_EntKey local_player;
/* Id lookup */ /* Key lookup */
struct PP_EntBin *id_bins; struct PP_EntBin *key_bins;
u64 num_id_bins; u64 num_key_bins;
/* Ents */ /* Ents */
Arena *ents_arena; Arena *ents_arena;
@ -231,7 +231,7 @@ Inline PP_Snapshot *PP_NilSnapshot(void)
#define PP_ClientLookupBinsCount 127 #define PP_ClientLookupBinsCount 127
#define PP_TickLookupBinsCount 127 #define PP_TickLookupBinsCount 127
#define PP_IdLookupBinsCount 4096 #define PP_KeyLookupBinsCount 4096
Struct(PP_SharedSimCtx) Struct(PP_SharedSimCtx)
{ {
@ -275,7 +275,7 @@ void PP_ReleaseClient(PP_Client *client);
u64 PP_ClientChannelHashFromChannelId(N_ChannelId channel_id); u64 PP_ClientChannelHashFromChannelId(N_ChannelId channel_id);
void PP_SetClientChannelId(PP_Client *client, N_ChannelId channel_id); void PP_SetClientChannelId(PP_Client *client, N_ChannelId channel_id);
PP_Client *PP_ClientFromChannelId(PP_ClientStore *store, N_ChannelId channel_id); PP_Client *PP_ClientFromChannelId(PP_ClientStore *store, N_ChannelId channel_id);
PP_Client *PP_ClientFromKey(PP_ClientStore *store, PP_ClientKey handle); PP_Client *PP_ClientFromKey(PP_ClientStore *store, PP_ClientKey key);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Snapshot acquire operations //~ Snapshot acquire operations

22
src/pp/pp_space.c
View File

@ -52,7 +52,7 @@ PP_Space *PP_SpaceFromEntry(PP_SpaceEntry *entry)
{ {
if (entry->valid) if (entry->valid)
{ {
u64 first_entry_addr = (u64)(entry - entry->handle.idx); u64 first_entry_addr = (u64)(entry - entry->key.idx);
PP_Space *space = (PP_Space *)(first_entry_addr - PP_SpaceEntriesOffset); PP_Space *space = (PP_Space *)(first_entry_addr - PP_SpaceEntriesOffset);
Assert(space->entries == (PP_SpaceEntry *)first_entry_addr); Assert(space->entries == (PP_SpaceEntry *)first_entry_addr);
return space; return space;
@ -288,14 +288,14 @@ void PP_ReleaseSpaceCellNode(PP_SpaceCellNode *n)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Entry //~ Entry
PP_SpaceEntry *PP_SpaceEntryFromKey(PP_Space *space, PP_SpaceEntryKey handle) PP_SpaceEntry *PP_SpaceEntryFromKey(PP_Space *space, PP_SpaceEntryKey key)
{ {
PP_SpaceEntry *entry = PP_NilSpaceEntry(); PP_SpaceEntry *entry = PP_NilSpaceEntry();
if (handle.gen > 0 && handle.idx < space->num_entries_reserved) if (key.gen > 0 && key.idx < space->num_entries_reserved)
{ {
PP_SpaceEntry *tmp = &space->entries[handle.idx]; PP_SpaceEntry *tmp = &space->entries[key.idx];
if (tmp->handle.gen == handle.gen) if (tmp->key.gen == key.gen)
{ {
entry = tmp; entry = tmp;
} }
@ -307,23 +307,23 @@ PP_SpaceEntry *PP_SpaceEntryFromKey(PP_Space *space, PP_SpaceEntryKey handle)
PP_SpaceEntry *PP_AcquireSpaceEntry(PP_Space *space, PP_EntKey ent) PP_SpaceEntry *PP_AcquireSpaceEntry(PP_Space *space, PP_EntKey ent)
{ {
PP_SpaceEntry *entry = 0; PP_SpaceEntry *entry = 0;
PP_SpaceEntryKey handle = ZI; PP_SpaceEntryKey key = ZI;
if (space->first_free_entry) if (space->first_free_entry)
{ {
entry = space->first_free_entry; entry = space->first_free_entry;
space->first_free_entry = entry->next_free; space->first_free_entry = entry->next_free;
handle = entry->handle; key = entry->key;
} }
else else
{ {
entry = PushStructNoZero(space->entry_arena, PP_SpaceEntry); entry = PushStructNoZero(space->entry_arena, PP_SpaceEntry);
handle.idx = space->num_entries_reserved; key.idx = space->num_entries_reserved;
handle.gen = 1; key.gen = 1;
++space->num_entries_reserved; ++space->num_entries_reserved;
} }
ZeroStruct(entry); ZeroStruct(entry);
entry->valid = 1; entry->valid = 1;
entry->handle = handle; entry->key = key;
entry->ent = ent; entry->ent = ent;
return entry; return entry;
} }
@ -343,7 +343,7 @@ void PP_ReleaseSpaceEntry(PP_SpaceEntry *entry)
PP_Space *space = PP_SpaceFromEntry(entry); PP_Space *space = PP_SpaceFromEntry(entry);
entry->next_free = space->first_free_entry; entry->next_free = space->first_free_entry;
entry->valid = 0; entry->valid = 0;
++entry->handle.gen; ++entry->key.gen;
space->first_free_entry = entry; space->first_free_entry = entry;
} }

4
src/pp/pp_space.h
View File

@ -10,7 +10,7 @@ Struct(PP_SpaceEntryKey)
Struct(PP_SpaceEntry) Struct(PP_SpaceEntry)
{ {
b32 valid; b32 valid;
PP_SpaceEntryKey handle; PP_SpaceEntryKey key;
struct PP_SpaceCellNode *first_node; struct PP_SpaceCellNode *first_node;
struct PP_SpaceCellNode *last_node; struct PP_SpaceCellNode *last_node;
@ -146,7 +146,7 @@ void PP_ReleaseSpaceCellNode(PP_SpaceCellNode *n);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Entry //~ Entry
PP_SpaceEntry *PP_SpaceEntryFromKey(PP_Space *space, PP_SpaceEntryKey handle); PP_SpaceEntry *PP_SpaceEntryFromKey(PP_Space *space, PP_SpaceEntryKey key);
PP_SpaceEntry *PP_AcquireSpaceEntry(PP_Space *space, PP_EntKey ent); PP_SpaceEntry *PP_AcquireSpaceEntry(PP_Space *space, PP_EntKey ent);
void PP_ReleaseSpaceEntry(PP_SpaceEntry *entry); void PP_ReleaseSpaceEntry(PP_SpaceEntry *entry);
void PP_UpdateSpaceEntryAabb(PP_SpaceEntry *entry, Aabb new_aabb); void PP_UpdateSpaceEntryAabb(PP_SpaceEntry *entry, Aabb new_aabb);

86
src/pp/pp_step.c
View File

@ -23,7 +23,7 @@ void PP_ResetAccel(PP_Snapshot *ss, PP_Accel *accel)
PP_Ent *ent = &ss->ents[sim_ent_index]; PP_Ent *ent = &ss->ents[sim_ent_index];
if (ent->valid) if (ent->valid)
{ {
ZeroStruct(&ent->space_handle); ZeroStruct(&ent->space_key);
} }
} }
} }
@ -94,7 +94,7 @@ PP_Ent *PP_SpawnTestChucker(PP_Ent *parent)
collider.radius = 0.1f; collider.radius = 0.1f;
zone->local_collider = collider; zone->local_collider = collider;
chucker->chucker_zone = zone->id; chucker->chucker_zone = zone->key;
} }
return chucker; return chucker;
@ -176,7 +176,7 @@ PP_Ent *PP_SpawnTestEmployee(PP_Ent *parent)
LAX PP_SpawnTestChucker; LAX PP_SpawnTestChucker;
PP_Ent *e = PP_SpawnTestChucker(employee); PP_Ent *e = PP_SpawnTestChucker(employee);
employee->equipped = e->id; employee->equipped = e->key;
PP_EnableProp(e, PP_Prop_LightTest); PP_EnableProp(e, PP_Prop_LightTest);
e->sprite_emittance = VEC3(1, 1, 1); e->sprite_emittance = VEC3(1, 1, 1);
@ -195,7 +195,7 @@ PP_Ent *PP_SpawnTestCamera(PP_Ent *parent, PP_Ent *follow)
PP_EnableProp(camera_ent, PP_Prop_Camera); PP_EnableProp(camera_ent, PP_Prop_Camera);
PP_EnableProp(camera_ent, PP_Prop_ActiveCamera); PP_EnableProp(camera_ent, PP_Prop_ActiveCamera);
camera_ent->camera_follow = follow->id; camera_ent->camera_follow = follow->key;
f32 width = (f32)DEFAULT_CAMERA_WIDTH; f32 width = (f32)DEFAULT_CAMERA_WIDTH;
f32 height = (f32)DEFAULT_CAMERA_HEIGHT; f32 height = (f32)DEFAULT_CAMERA_HEIGHT;
@ -863,7 +863,7 @@ PP_CollisionCallbackFuncDef(PP_OnEntCollision, data, step_ctx)
{ {
if (!PP_EqEntKey(e0->top, e1->top) && PP_HasProp(e1, PP_Prop_Solid)) if (!PP_EqEntKey(e0->top, e1->top) && PP_HasProp(e1, PP_Prop_Solid))
{ {
e0->chucker_zone_ent = e1->id; e0->chucker_zone_ent = e1->key;
e0->chucker_zone_ent_tick = world->tick; e0->chucker_zone_ent_tick = world->tick;
} }
} }
@ -916,20 +916,20 @@ void PP_StepSim(PP_SimStepCtx *ctx)
{ {
/* FIXME: Player never released upon disconnect */ /* FIXME: Player never released upon disconnect */
player = PP_AcquireSyncSrcEnt(root); player = PP_AcquireSyncSrcEnt(root);
player->player_client_handle = client->handle; player->player_client_key = client->key;
PP_EnableProp(player, PP_Prop_Player); PP_EnableProp(player, PP_Prop_Player);
player->predictor = player->id; player->predictor = player->key;
PP_ActivateEnt(player, world->tick); PP_ActivateEnt(player, world->tick);
client->player_id = player->id; client->player_id = player->key;
if (client == user_input_client) if (client == user_input_client)
{ {
user_input_client->player_id = player->id; user_input_client->player_id = player->key;
world_client->player_id = player->id; world_client->player_id = player->key;
world->local_player = player->id; world->local_player = player->key;
player->owner = player->id; player->owner = player->key;
PP_EnableProp(player, PP_Prop_IsMaster); PP_EnableProp(player, PP_Prop_IsMaster);
} }
P_LogInfoF("Created player with id %F for sim client %F. is_master: %F", FmtUid(player->id.uid), FmtHandle(client->handle), FmtUint(PP_HasProp(player, PP_Prop_IsMaster))); P_LogInfoF("Created player with key %F for sim client %F. is_master: %F", FmtUid(player->key.uid), FmtHandle(client->key), FmtUint(PP_HasProp(player, PP_Prop_IsMaster)));
} }
/* Update rtt */ /* Update rtt */
@ -946,7 +946,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
PP_Snapshot *src_ss = PP_SnapshotFromTick(client, world->tick); PP_Snapshot *src_ss = PP_SnapshotFromTick(client, world->tick);
if (src_ss->valid) if (src_ss->valid)
{ {
PP_SyncSnapshotEnts(world, src_ss, player->id, 0); PP_SyncSnapshotEnts(world, src_ss, player->key, 0);
} }
} }
} }
@ -1027,7 +1027,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
if (PP_ShouldSimulate(player)) if (PP_ShouldSimulate(player))
{ {
b32 persist_cmd = 0; b32 persist_cmd = 0;
if (!is_master && !PP_EqEntKey(player->id, world->local_player)) if (!is_master && !PP_EqEntKey(player->key, world->local_player))
{ {
/* We are not the master and the command is not our own, skip processing */ /* We are not the master and the command is not our own, skip processing */
continue; continue;
@ -1173,7 +1173,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
{ {
PP_Ent *chat_ent = PP_AcquireSyncSrcEnt(root); PP_Ent *chat_ent = PP_AcquireSyncSrcEnt(root);
PP_EnableProp(chat_ent, PP_Prop_CHAT); PP_EnableProp(chat_ent, PP_Prop_CHAT);
chat_ent->chat_player = player->id; chat_ent->chat_player = player->key;
chat_ent->chat_msg = msg_key; chat_ent->chat_msg = msg_key;
} }
} break; } break;
@ -1222,22 +1222,22 @@ void PP_StepSim(PP_SimStepCtx *ctx)
if (!control_ent->valid) if (!control_ent->valid)
{ {
control_ent = PP_SpawnTestEmployee(root); control_ent = PP_SpawnTestEmployee(root);
control_ent->predictor = ent->id; control_ent->predictor = ent->key;
PP_EnableProp(control_ent, PP_Prop_Controlled); PP_EnableProp(control_ent, PP_Prop_Controlled);
ent->player_control_ent = control_ent->id; ent->player_control_ent = control_ent->key;
control_ent->controlling_player = ent->id; control_ent->controlling_player = ent->key;
} }
PP_Ent *camera_ent = PP_EntFromKey(world, ent->player_camera_ent); PP_Ent *camera_ent = PP_EntFromKey(world, ent->player_camera_ent);
if (!camera_ent->valid) if (!camera_ent->valid)
{ {
camera_ent = PP_SpawnTestCamera(root, control_ent); camera_ent = PP_SpawnTestCamera(root, control_ent);
camera_ent->predictor = ent->id; camera_ent->predictor = ent->key;
ent->player_camera_ent = camera_ent->id; ent->player_camera_ent = camera_ent->key;
} }
PP_Ent *camera_follow = PP_EntFromKey(world, camera_ent->camera_follow); PP_Ent *camera_follow = PP_EntFromKey(world, camera_ent->camera_follow);
if (!camera_follow->valid) if (!camera_follow->valid)
{ {
camera_ent->camera_follow = control_ent->id; camera_ent->camera_follow = control_ent->key;
} }
} }
} }
@ -1464,7 +1464,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
bullet = PP_AcquireSyncSrcEnt(root); bullet = PP_AcquireSyncSrcEnt(root);
PP_EnableProp(bullet, PP_Prop_Bullet); PP_EnableProp(bullet, PP_Prop_Bullet);
bullet->bullet_src = ent->id; bullet->bullet_src = ent->key;
bullet->bullet_src_pos = rel_pos; bullet->bullet_src_pos = rel_pos;
bullet->bullet_src_dir = rel_dir; bullet->bullet_src_dir = rel_dir;
//bullet->bullet_launch_velocity = 0.75f; //bullet->bullet_launch_velocity = 0.75f;
@ -1489,7 +1489,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
tracer->layer = PP_Layer_Tracers; tracer->layer = PP_Layer_Tracers;
PP_EnableProp(tracer, PP_Prop_Tracer); PP_EnableProp(tracer, PP_Prop_Tracer);
bullet->bullet_tracer = tracer->id; bullet->bullet_tracer = tracer->key;
} }
} }
} }
@ -1513,7 +1513,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
bullet = PP_AcquireSyncSrcEnt(root); bullet = PP_AcquireSyncSrcEnt(root);
PP_EnableProp(bullet, PP_Prop_Bullet); PP_EnableProp(bullet, PP_Prop_Bullet);
bullet->bullet_src = ent->id; bullet->bullet_src = ent->key;
bullet->bullet_src_pos = rel_pos; bullet->bullet_src_pos = rel_pos;
bullet->bullet_src_dir = rel_dir; bullet->bullet_src_dir = rel_dir;
//bullet->bullet_launch_velocity = 0.75f; //bullet->bullet_launch_velocity = 0.75f;
@ -1537,7 +1537,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
tracer->layer = PP_Layer_Tracers; tracer->layer = PP_Layer_Tracers;
PP_EnableProp(tracer, PP_Prop_Tracer); PP_EnableProp(tracer, PP_Prop_Tracer);
bullet->bullet_tracer = tracer->id; bullet->bullet_tracer = tracer->key;
} }
} }
} }
@ -1555,7 +1555,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
PP_Ent *old_joint_ent = PP_EntFromKey(world, ent->chucker_joint); PP_Ent *old_joint_ent = PP_EntFromKey(world, ent->chucker_joint);
if (PP_IsValidAndActive(target) && zone->chucker_zone_ent_tick == world->tick - 1) if (PP_IsValidAndActive(target) && zone->chucker_zone_ent_tick == world->tick - 1)
{ {
if (!PP_EqEntKey(old_joint_ent->weld_joint_data.e1, target->id)) if (!PP_EqEntKey(old_joint_ent->weld_joint_data.e1, target->key))
{ {
PP_Ent *joint_ent = PP_AcquireSyncSrcEnt(root); PP_Ent *joint_ent = PP_AcquireSyncSrcEnt(root);
PP_EnableProp(joint_ent, PP_Prop_Active); PP_EnableProp(joint_ent, PP_Prop_Active);
@ -1566,15 +1566,15 @@ void PP_StepSim(PP_SimStepCtx *ctx)
PP_EnableProp(joint_ent, PP_Prop_WeldJoint); PP_EnableProp(joint_ent, PP_Prop_WeldJoint);
PP_WeldJointDesc def = PP_CreateWeldJointDef(); PP_WeldJointDesc def = PP_CreateWeldJointDef();
def.e0 = ent->id; def.e0 = ent->key;
def.e1 = target->id; def.e1 = target->key;
def.xf = xf0_to_xf1; def.xf = xf0_to_xf1;
def.linear_spring_hz = 10; def.linear_spring_hz = 10;
def.linear_spring_damp = 0.3f; def.linear_spring_damp = 0.3f;
def.angular_spring_hz = 10; def.angular_spring_hz = 10;
def.angular_spring_damp = 0.3f; def.angular_spring_damp = 0.3f;
joint_ent->weld_joint_data = PP_WeldJointFromDef(def); joint_ent->weld_joint_data = PP_WeldJointFromDef(def);
ent->chucker_joint = joint_ent->id; ent->chucker_joint = joint_ent->key;
} }
} }
if (old_joint_ent->valid) if (old_joint_ent->valid)
@ -1604,12 +1604,12 @@ void PP_StepSim(PP_SimStepCtx *ctx)
joint_ent->inertia_unscaled = F32Infinity; joint_ent->inertia_unscaled = F32Infinity;
PP_EnableProp(joint_ent, PP_Prop_Active); PP_EnableProp(joint_ent, PP_Prop_Active);
PP_EnableProp(joint_ent, PP_Prop_Kinematic); PP_EnableProp(joint_ent, PP_Prop_Kinematic);
ent->move_joint = joint_ent->id; ent->move_joint = joint_ent->key;
PP_EnableProp(joint_ent, PP_Prop_MotorJoint); PP_EnableProp(joint_ent, PP_Prop_MotorJoint);
PP_MotorJointDesc def = PP_CreateMotorJointDef(); PP_MotorJointDesc def = PP_CreateMotorJointDef();
def.e0 = joint_ent->id; /* Re-using joint entity as e0 */ def.e0 = joint_ent->key; /* Re-using joint entity as e0 */
def.e1 = ent->id; def.e1 = ent->key;
def.correction_rate = 0; def.correction_rate = 0;
def.max_force = ent->control_force; def.max_force = ent->control_force;
def.max_torque = 0; def.max_torque = 0;
@ -1648,11 +1648,11 @@ void PP_StepSim(PP_SimStepCtx *ctx)
PP_EnableProp(joint_ent, PP_Prop_Kinematic); /* Since we'll be setting velocity manually */ PP_EnableProp(joint_ent, PP_Prop_Kinematic); /* Since we'll be setting velocity manually */
PP_EnableProp(joint_ent, PP_Prop_MotorJoint); PP_EnableProp(joint_ent, PP_Prop_MotorJoint);
PP_EnableProp(joint_ent, PP_Prop_Active); PP_EnableProp(joint_ent, PP_Prop_Active);
ent->aim_joint = joint_ent->id; ent->aim_joint = joint_ent->key;
PP_MotorJointDesc def = PP_CreateMotorJointDef(); PP_MotorJointDesc def = PP_CreateMotorJointDef();
def.e0 = joint_ent->id; /* Re-using joint entity as e0 */ def.e0 = joint_ent->key; /* Re-using joint entity as e0 */
def.e1 = ent->id; def.e1 = ent->key;
def.max_force = 0; def.max_force = 0;
def.max_torque = ent->control_torque; def.max_torque = ent->control_torque;
joint_ent->motor_joint_data = PP_MotorJointFromDef(def); joint_ent->motor_joint_data = PP_MotorJointFromDef(def);
@ -1739,8 +1739,8 @@ void PP_StepSim(PP_SimStepCtx *ctx)
PP_Ent *joint_ent = PP_EntFromKey(world, ent->ground_friction_joint); PP_Ent *joint_ent = PP_EntFromKey(world, ent->ground_friction_joint);
PP_MotorJointDesc def = PP_CreateMotorJointDef(); PP_MotorJointDesc def = PP_CreateMotorJointDef();
def.e0 = root->id; def.e0 = root->key;
def.e1 = ent->id; def.e1 = ent->key;
def.correction_rate = 0; def.correction_rate = 0;
def.max_force = ent->linear_ground_friction; def.max_force = ent->linear_ground_friction;
def.max_torque = ent->angular_ground_friction; def.max_torque = ent->angular_ground_friction;
@ -1753,7 +1753,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
PP_EnableProp(joint_ent, PP_Prop_MotorJoint); PP_EnableProp(joint_ent, PP_Prop_MotorJoint);
PP_EnableProp(joint_ent, PP_Prop_Active); PP_EnableProp(joint_ent, PP_Prop_Active);
joint_ent->motor_joint_data = PP_MotorJointFromDef(def); joint_ent->motor_joint_data = PP_MotorJointFromDef(def);
ent->ground_friction_joint = joint_ent->id; ent->ground_friction_joint = joint_ent->key;
} }
} }
} }
@ -1793,15 +1793,15 @@ void PP_StepSim(PP_SimStepCtx *ctx)
joint_ent = PP_AcquireLocalEnt(root); joint_ent = PP_AcquireLocalEnt(root);
joint_ent->mass_unscaled = F32Infinity; joint_ent->mass_unscaled = F32Infinity;
joint_ent->inertia_unscaled = F32Infinity; joint_ent->inertia_unscaled = F32Infinity;
player->player_dbg_drag_joint_ent = joint_ent->id; player->player_dbg_drag_joint_ent = joint_ent->key;
PP_EnableProp(joint_ent, PP_Prop_MouseJoint); PP_EnableProp(joint_ent, PP_Prop_MouseJoint);
PP_EnableProp(joint_ent, PP_Prop_Active); PP_EnableProp(joint_ent, PP_Prop_Active);
} }
Xform xf = PP_XformFromEnt(target_ent); Xform xf = PP_XformFromEnt(target_ent);
PP_MouseJointDesc def = PP_CreateMouseJointDef(); PP_MouseJointDesc def = PP_CreateMouseJointDef();
def.target = target_ent->id; def.target = target_ent->key;
if (PP_EqEntKey(joint_ent->mouse_joint_data.target, target_ent->id)) if (PP_EqEntKey(joint_ent->mouse_joint_data.target, target_ent->key))
{ {
def.point_local_start = joint_ent->mouse_joint_data.point_local_start; def.point_local_start = joint_ent->mouse_joint_data.point_local_start;
} }
@ -1819,7 +1819,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
} }
else if (PP_IsValidAndActive(joint_ent)) else if (PP_IsValidAndActive(joint_ent))
{ {
joint_ent->mouse_joint_data.target = target_ent->id; joint_ent->mouse_joint_data.target = target_ent->key;
} }
} }
} }