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;
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 receiving = PP_HasProp(ent, PP_Prop_SyncDst);
@ -862,7 +862,7 @@ void PP_UpdateUser(void)
{
if (PP_IsNilEntKey(g->debug_following))
{
g->debug_following = hovered_ent->id;
g->debug_following = hovered_ent->key;
}
else
{
@ -905,7 +905,7 @@ void PP_UpdateUser(void)
f32 shake = ent->shake;
if (shake > 0)
{
u64 angle_seed0 = ent->id.uid.lo + (u64)(g->ss_blended->sim_time_ns / frequency_ns);
u64 angle_seed0 = ent->key.uid.lo + (u64)(g->ss_blended->sim_time_ns / frequency_ns);
u64 angle_seed1 = angle_seed0 + 1;
f32 angle0 = RandF64FromSeed(angle_seed0, 0, Tau);
f32 angle1 = RandF64FromSeed(angle_seed1, 0, Tau);
@ -1406,7 +1406,7 @@ void PP_UpdateUser(void)
}
/* 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_Slice slice = S_SliceFromNameIndex(sheet, Lit("attach.wep"), ent->animation_frame);
@ -1584,7 +1584,7 @@ void PP_UpdateUser(void)
String fmt = Lit(
"e0 index: %F\n"
"e1 index: %F\n"
"id: 0x%F\n"
"key: 0x%F\n"
"impulse (n): %F\n"
"impulse (t): %F\n"
"separation: %F\n"
@ -1592,9 +1592,9 @@ void PP_UpdateUser(void)
"num contacts: %F"
);
String text = StringF(temp.arena, fmt,
FmtUint(e0->handle.idx),
FmtUint(e1->handle.idx),
FmtHex(point.id),
FmtUint(e0->key.idx),
FmtUint(e1->key.idx),
FmtHex(point.key),
FmtFloat(point.normal_impulse),
FmtFloat(point.tangent_impulse),
FmtFloatP(point.starting_separation, 6),
@ -2039,7 +2039,7 @@ void PP_UpdateUser(void)
u32 old_flags = g->user_sim_cmd_control.flags;
g->user_sim_cmd_control = control;
g->user_sim_cmd_control.flags |= old_flags;
g->user_hovered_ent = hovered_ent->id;
g->user_hovered_ent = hovered_ent->key;
Unlock(&lock);
}
}
@ -2146,7 +2146,7 @@ void PP_UpdateUser(void)
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));
Vec2 world_cursor = g->world_cursor;
@ -2451,7 +2451,7 @@ void PP_UpdateUser(void)
////////////////////////////////////////////////////////////
//~ User update job
JobDef(PP_UpdateUserOrSleep, UNUSED sig, UNUSED id)
JobDef(PP_UpdateUserOrSleep, UNUSED sig, UNUSED key)
{
PP_SharedUserState *g = &PP_shared_user_state;
i64 time_ns = TimeNs();
@ -2511,7 +2511,7 @@ void PP_GenerateuserInputCmds(PP_Client *user_input_client, u64 tick)
////////////////////////////////////////////////////////////
//~ Sim update
JobDef(PP_UpdateSim, UNUSED sig, UNUSED id)
JobDef(PP_UpdateSim, UNUSED sig, UNUSED key)
{
PP_SharedUserState *g = &PP_shared_user_state;
#if 0
@ -3014,7 +3014,7 @@ JobDef(PP_UpdateSim, UNUSED sig, UNUSED id)
{
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;
local_client->player_id = master_ss->local_player;
@ -3083,7 +3083,7 @@ JobDef(PP_UpdateSim, UNUSED sig, UNUSED id)
{
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
{
@ -3112,7 +3112,7 @@ JobDef(PP_UpdateSim, UNUSED sig, UNUSED id)
ctx.world = PP_AcquireSnapshot(local_client, prev_ss, step_tick);
if (!mispredicted_tick && step_tick == step_end_tick)
{
PP_SyncSnapshotEnts(ctx.world, master_ss, master_player->id, PP_SyncFlag_NoSyncPredictables);
PP_SyncSnapshotEnts(ctx.world, master_ss, master_player->key, PP_SyncFlag_NoSyncPredictables);
}
PP_StepSim(&ctx);
prev_ss = ctx.world;

88
src/pp/pp_ent.c
View File

@ -1,7 +1,7 @@
////////////////////////////////////////////////////////////
//~ 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(ss->valid);
@ -26,7 +26,7 @@ PP_Ent *PP_AcquireRawEnt(PP_Snapshot *ss, PP_Ent *parent, PP_EntKey id)
ent->_is_xform_dirty = 1;
++ss->num_ents_allocated;
PP_SetEntKey(ent, id);
PP_SetEntKey(ent, key);
PP_Link(ent, parent);
return ent;
@ -41,10 +41,10 @@ PP_Ent *PP_AcquireLocalEnt(PP_Ent *parent)
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_Ent *e = PP_AcquireRawEnt(ss, parent, id);
PP_Ent *e = PP_AcquireRawEnt(ss, parent, key);
e->owner = ss->local_player;
return e;
}
@ -59,16 +59,16 @@ PP_Ent *PP_AcquireSyncSrcEnt(PP_Ent *parent)
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_Ent *e = PP_AcquireRawEnt(ss, parent, id);
PP_Ent *e = PP_AcquireRawEnt(ss, parent, key);
PP_EnableProp(e, PP_Prop_SyncSrc);
e->owner = ss->local_player;
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_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)
{
@ -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) */
void PP_SetEntKey(PP_Ent *ent, PP_EntKey id)
/* 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 key)
{
PP_Snapshot *ss = ent->ss;
PP_EntKey old_id = ent->id;
if (!PP_EqEntKey(old_id, id))
PP_EntKey old_id = ent->key;
if (!PP_EqEntKey(old_id, key))
{
/* Release old from lookup */
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 = PP_EntFromIndex(ss, next_index);
if (PP_EqEntKey(search->id, old_id))
if (PP_EqEntKey(search->key, old_id))
{
break;
}
@ -211,7 +211,7 @@ void PP_SetEntKey(PP_Ent *ent, PP_EntKey id)
search = next;
}
/* Old id not in bin, this should be impossible. */
/* Old key not in bin, this should be impossible. */
Assert(search->valid);
if (prev->valid)
@ -233,18 +233,18 @@ void PP_SetEntKey(PP_Ent *ent, PP_EntKey id)
}
}
/* Insert new id into lookup */
if (!PP_IsNilEntKey(id))
/* Insert new key into lookup */
if (!PP_IsNilEntKey(key))
{
#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. */
Assert(!existing->valid);
}
#endif
PP_EntBin *bin = PP_EntBinFromKey(ss, id);
PP_EntBin *bin = PP_EntBinFromKey(ss, key);
u32 ent_index = PP_IndexFromEnt(ss, ent);
PP_Ent *last = PP_EntFromIndex(ss, bin->last);
if (last->valid)
@ -260,20 +260,20 @@ void PP_SetEntKey(PP_Ent *ent, PP_EntKey id)
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();
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))
{
if (PP_EqEntKey(e->id, id))
if (PP_EqEntKey(e->key, key))
{
result = e;
break;
@ -290,7 +290,7 @@ PP_EntKey PP_RandomKey(void)
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 result = ZI;
@ -301,7 +301,7 @@ PP_EntKey PP_ContactConstraintKeyFromContactingKeys(PP_EntKey player_id, PP_EntK
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 result = ZI;
@ -312,7 +312,7 @@ PP_EntKey PP_CollisionDebugKeyFromKeys(PP_EntKey player_id, PP_EntKey id0, PP_En
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 result = ZI;
@ -380,7 +380,7 @@ void PP_Link(PP_Ent *ent, PP_Ent *parent)
PP_Unlink(ent);
}
PP_EntKey ent_id = ent->id;
PP_EntKey ent_id = ent->key;
PP_EntKey last_child_id = parent->last;
PP_Ent *last_child = PP_EntFromKey(ss, last_child_id);
if (last_child->valid)
@ -404,7 +404,7 @@ void PP_Link(PP_Ent *ent, PP_Ent *parent)
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. */
@ -420,19 +420,19 @@ void PP_Unlink(PP_Ent *ent)
/* Unlink from parent & siblings */
if (prev->valid)
{
prev->next = next->id;
prev->next = next->key;
}
else
{
parent->first = next->id;
parent->first = next->key;
}
if (next->valid)
{
next->prev = prev->id;
next->prev = prev->key;
}
else
{
parent->last = prev->id;
parent->last = prev->key;
}
ent->prev = 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)
{
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)
{
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 *remote_ss = remote->ss;
PP_EntKey id = remote->id;
PP_Ent *local_ent = PP_EntFromKey(local_ss, id);
PP_EntKey key = remote->key;
PP_Ent *local_ent = PP_EntFromKey(local_ss, key);
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))
{
@ -719,10 +719,10 @@ void PP_SyncEnt(PP_Ent *local, PP_Ent *remote)
CopyStruct(local, remote);
/* 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->id = old.id;
local->key = old.key;
/* Keep local tree */
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.
* 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 */
@ -856,10 +856,10 @@ void PP_DecodeEnt(BB_Reader *br, PP_Ent *e)
}
decoded.ss = e->ss;
PP_EntKey old_id = e->id;
PP_EntKey new_id = decoded.id;
PP_EntKey old_id = e->key;
PP_EntKey new_id = decoded.key;
CopyStruct(e, &decoded);
e->id = old_id;
e->key = old_id;
if (!PP_EqEntKey(old_id, new_id))
{
PP_SetEntKey(e, new_id);

36
src/pp/pp_ent.h
View File

@ -71,7 +71,7 @@ Struct(PP_Ent)
//- Metadata
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 continuity_gen;
@ -81,7 +81,7 @@ Struct(PP_Ent)
/* Is ent a child of the root ent */
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;
/* Tree */
@ -101,10 +101,10 @@ Struct(PP_Ent)
/* PP_Prop_SyncSrc */
/* 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;
/* 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;
//- Position
@ -162,7 +162,7 @@ Struct(PP_Ent)
/* 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;
Vec2 player_cursor_pos;
@ -188,7 +188,7 @@ Struct(PP_Ent)
ContactDebugData collision_debug_data;
#endif
PP_SpaceEntryKey space_handle;
PP_SpaceEntryKey space_key;
//- 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_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_ContactBasisUid (UID(0x6a2a5d2dbecf534f, 0x0a8ca7c372a015af))
#define PP_CollisionDebugBasisUid (UID(0x302c01182013bb02, 0x570bd270399d11a5))
////////////////////////////////////////////////////////////
//~ Id helpers
//~ Key helpers
Inline b32 PP_EqEntKey(PP_EntKey a, PP_EntKey b)
{
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
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_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_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);
////////////////////////////////////////////////////////////
@ -494,13 +494,13 @@ void PP_ReleaseAllWithProp(PP_Snapshot *ss, PP_Prop prop);
void PP_ActivateEnt(PP_Ent *ent, u64 current_tick);
////////////////////////////////////////////////////////////
//~ Id operations
//~ Key operations
u32 PP_IndexFromEnt(PP_Snapshot *ss, PP_Ent *ent);
PP_Ent *PP_EntFromIndex(PP_Snapshot *ss, u32 index);
PP_EntBin *PP_EntBinFromKey(PP_Snapshot *ss, PP_EntKey id);
void PP_SetEntKey(PP_Ent *ent, PP_EntKey id);
PP_Ent *PP_EntFromKey(PP_Snapshot *ss, PP_EntKey id);
PP_EntBin *PP_EntBinFromKey(PP_Snapshot *ss, PP_EntKey key);
void PP_SetEntKey(PP_Ent *ent, PP_EntKey key);
PP_Ent *PP_EntFromKey(PP_Snapshot *ss, PP_EntKey key);
PP_EntKey PP_RandomKey(void);
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);

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 (!PP_CanEntsContact(check0, check1)) continue;
/* Deterministic order based on entity id */
/* Deterministic order based on entity key */
PP_Ent *e0;
PP_Ent *e1;
Xform e0_xf;
Xform e1_xf;
CLD_Shape e0_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;
e1 = check1;
@ -69,7 +69,7 @@ void PP_CreateAndUpdateContacts(PP_PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_it
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);
if (constraint_ent->valid)
@ -101,8 +101,8 @@ void PP_CreateAndUpdateContacts(PP_PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_it
is_start = 1;
/* Create constraint */
constraint_ent = PP_AcquireLocalEntWithKey(root, constraint_id);
constraint_ent->contact_constraint_data.e0 = e0->id;
constraint_ent->contact_constraint_data.e1 = e1->id;
constraint_ent->contact_constraint_data.e0 = e0->key;
constraint_ent->contact_constraint_data.e1 = e1->key;
/* 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) ||
!(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)
{
PP_CollisionData data = ZI;
data.e0 = e0->id;
data.e1 = e1->id;
data.e0 = e0->key;
data.e1 = e1->key;
data.normal = collision_result.normal;
data.is_start = is_start;
data.dt = elapsed_dt;
@ -250,7 +250,7 @@ void PP_CreateAndUpdateContacts(PP_PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_it
/* TODO: Remove this (debugging) */
#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);
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;
dbg->e0 = e0->id;
dbg->e1 = e1->id;
dbg->e0 = e0->key;
dbg->e1 = e1->key;
dbg->collision_result = collision_result;
if (constraint)
@ -1290,11 +1290,11 @@ void PP_UpdateAabbs(PP_PhysStepCtx *ctx)
if (ent->local_collider.count > 0)
{
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)
{
space_entry = PP_AcquireSpaceEntry(space, ent->id);
ent->space_handle = space_entry->handle;
space_entry = PP_AcquireSpaceEntry(space, ent->key);
ent->space_key = space_entry->key;
}
Aabb aabb = CLD_AabbFromShape(&ent->local_collider, xf);
PP_UpdateSpaceEntryAabb(space_entry, aabb);

92
src/pp/pp_sim.c
View File

@ -2,26 +2,26 @@
*
* 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.
* - 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)
* - 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.
*
* An ent is the smallest unit of simulation state.
* - 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 id is usually random, but can be deterministic under certain conditions.
* - This key is used to refer to other ents in the tree and to sync ents accross clients.
* - 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
* retrieved by searching for the ent with the id resulting from combining the ent ids of the
* two contacting entities (plus a unique 'basis' ent id used for all contact constraints).
* 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 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.
* - 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->ss = PP_NilSnapshot();
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->_xform = XformIdentity;
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_ClientKey handle = ZI;
PP_ClientKey key = ZI;
PP_Client *client = PP_ClientFromKey(store, store->first_free_client);
if (client->valid)
{
store->first_free_client = client->next_free;
handle = client->handle;
++handle.gen;
key = client->key;
++key.gen;
}
else
{
client = PushStructNoZero(store->clients_arena, PP_Client);
handle.gen = 1;
handle.idx = store->num_clients_reserved;
key.gen = 1;
key.idx = store->num_clients_reserved;
++store->num_clients_reserved;
}
++store->num_clients_allocated;
*client = *PP_NilClient();
client->store = store;
client->valid = 1;
client->handle = handle;
client->key = key;
client->snapshots_arena = AcquireArena(Gibi(8));
client->num_snapshot_lookup_bins = PP_TickLookupBinsCount;
@ -163,9 +163,9 @@ void PP_ReleaseClient(PP_Client *client)
PP_ClientStore *store = client->store;
client->valid = 0;
client->next_free = store->first_free_client;
store->first_free_client = client->handle;
store->first_free_client = client->key;
--store->num_clients_allocated;
++client->handle.gen;
++client->key.gen;
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);
if (prev->valid)
{
prev->next_in_bin = next->handle;
prev->next_in_bin = next->key;
}
else
{
bin->first = next->handle;
bin->first = next->key;
}
if (next->valid)
{
next->prev_in_bin = prev->handle;
next->prev_in_bin = prev->key;
}
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);
if (prev_in_bin->valid)
{
prev_in_bin->next_in_bin = client->handle;
client->prev_in_bin = prev_in_bin->handle;
prev_in_bin->next_in_bin = client->key;
client->prev_in_bin = prev_in_bin->key;
}
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;
}
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];
if (client->handle.gen == handle.gen)
PP_Client *client = &store->clients[key.idx];
if (client->key.gen == key.gen)
{
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->phys_iteration = src->phys_iteration;
/* Copy id lookup bins */
ss->num_id_bins = src->num_id_bins > 0 ? src->num_id_bins : PP_IdLookupBinsCount;
ss->id_bins = PushStructsNoZero(ss->arena, PP_EntBin, ss->num_id_bins);
if (src->num_id_bins > 0)
/* Copy key lookup bins */
ss->num_key_bins = src->num_key_bins > 0 ? src->num_key_bins : PP_KeyLookupBinsCount;
ss->key_bins = PushStructsNoZero(ss->arena, PP_EntBin, ss->num_key_bins);
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
{
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 */
@ -344,7 +344,7 @@ PP_Snapshot *PP_AcquireSnapshot(PP_Client *client, PP_Snapshot *src, u64 tick)
++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);
*root = *PP_NilEnt();
@ -750,7 +750,7 @@ void PP_SyncSnapshotEnts(PP_Snapshot *local_ss, PP_Snapshot *remote_ss, PP_EntKe
}
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)
{
/* 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);
/* Id bins */
/* Key bins */
/* TODO: Don't encode these */
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_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_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 last_diff = bin->last != old_last;
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) };
/* Id bins */
/* Key bins */
/* TODO: Don't decode these, determine them implicitly from decoded ents */
BB_ReadDebugMarker(br, Lit("SNAPSHOT BINS"));
{
@ -884,9 +884,9 @@ void PP_DecodeSnapshot(BB_Reader *br, PP_Snapshot *ss)
while (bin_changed)
{
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))
{
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);
if (e1->valid)
{
BB_WriteUid(bw, e1->id.uid);
BB_WriteUid(bw, e1->key.uid);
}
}
else

18
src/pp/pp_sim.h
View File

@ -12,7 +12,7 @@ Struct(PP_ClientKey)
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)
{
b32 valid;
PP_ClientKey handle;
PP_ClientKey key;
PP_ClientStore *store;
Arena *snapshots_arena;
@ -74,7 +74,7 @@ Struct(PP_Client)
PP_ClientKey next_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;
/* 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) */
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;
/* Id lookup */
struct PP_EntBin *id_bins;
u64 num_id_bins;
/* Key lookup */
struct PP_EntBin *key_bins;
u64 num_key_bins;
/* Ents */
Arena *ents_arena;
@ -231,7 +231,7 @@ Inline PP_Snapshot *PP_NilSnapshot(void)
#define PP_ClientLookupBinsCount 127
#define PP_TickLookupBinsCount 127
#define PP_IdLookupBinsCount 4096
#define PP_KeyLookupBinsCount 4096
Struct(PP_SharedSimCtx)
{
@ -275,7 +275,7 @@ void PP_ReleaseClient(PP_Client *client);
u64 PP_ClientChannelHashFromChannelId(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_ClientFromKey(PP_ClientStore *store, PP_ClientKey handle);
PP_Client *PP_ClientFromKey(PP_ClientStore *store, PP_ClientKey key);
////////////////////////////////////////////////////////////
//~ 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)
{
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);
Assert(space->entries == (PP_SpaceEntry *)first_entry_addr);
return space;
@ -288,14 +288,14 @@ void PP_ReleaseSpaceCellNode(PP_SpaceCellNode *n)
////////////////////////////////////////////////////////////
//~ 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();
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];
if (tmp->handle.gen == handle.gen)
PP_SpaceEntry *tmp = &space->entries[key.idx];
if (tmp->key.gen == key.gen)
{
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 *entry = 0;
PP_SpaceEntryKey handle = ZI;
PP_SpaceEntryKey key = ZI;
if (space->first_free_entry)
{
entry = space->first_free_entry;
space->first_free_entry = entry->next_free;
handle = entry->handle;
key = entry->key;
}
else
{
entry = PushStructNoZero(space->entry_arena, PP_SpaceEntry);
handle.idx = space->num_entries_reserved;
handle.gen = 1;
key.idx = space->num_entries_reserved;
key.gen = 1;
++space->num_entries_reserved;
}
ZeroStruct(entry);
entry->valid = 1;
entry->handle = handle;
entry->key = key;
entry->ent = ent;
return entry;
}
@ -343,7 +343,7 @@ void PP_ReleaseSpaceEntry(PP_SpaceEntry *entry)
PP_Space *space = PP_SpaceFromEntry(entry);
entry->next_free = space->first_free_entry;
entry->valid = 0;
++entry->handle.gen;
++entry->key.gen;
space->first_free_entry = entry;
}

4
src/pp/pp_space.h
View File

@ -10,7 +10,7 @@ Struct(PP_SpaceEntryKey)
Struct(PP_SpaceEntry)
{
b32 valid;
PP_SpaceEntryKey handle;
PP_SpaceEntryKey key;
struct PP_SpaceCellNode *first_node;
struct PP_SpaceCellNode *last_node;
@ -146,7 +146,7 @@ void PP_ReleaseSpaceCellNode(PP_SpaceCellNode *n);
////////////////////////////////////////////////////////////
//~ 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);
void PP_ReleaseSpaceEntry(PP_SpaceEntry *entry);
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];
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;
zone->local_collider = collider;
chucker->chucker_zone = zone->id;
chucker->chucker_zone = zone->key;
}
return chucker;
@ -176,7 +176,7 @@ PP_Ent *PP_SpawnTestEmployee(PP_Ent *parent)
LAX PP_SpawnTestChucker;
PP_Ent *e = PP_SpawnTestChucker(employee);
employee->equipped = e->id;
employee->equipped = e->key;
PP_EnableProp(e, PP_Prop_LightTest);
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_ActiveCamera);
camera_ent->camera_follow = follow->id;
camera_ent->camera_follow = follow->key;
f32 width = (f32)DEFAULT_CAMERA_WIDTH;
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))
{
e0->chucker_zone_ent = e1->id;
e0->chucker_zone_ent = e1->key;
e0->chucker_zone_ent_tick = world->tick;
}
}
@ -916,20 +916,20 @@ void PP_StepSim(PP_SimStepCtx *ctx)
{
/* FIXME: Player never released upon disconnect */
player = PP_AcquireSyncSrcEnt(root);
player->player_client_handle = client->handle;
player->player_client_key = client->key;
PP_EnableProp(player, PP_Prop_Player);
player->predictor = player->id;
player->predictor = player->key;
PP_ActivateEnt(player, world->tick);
client->player_id = player->id;
client->player_id = player->key;
if (client == user_input_client)
{
user_input_client->player_id = player->id;
world_client->player_id = player->id;
world->local_player = player->id;
player->owner = player->id;
user_input_client->player_id = player->key;
world_client->player_id = player->key;
world->local_player = player->key;
player->owner = player->key;
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 */
@ -946,7 +946,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
PP_Snapshot *src_ss = PP_SnapshotFromTick(client, world->tick);
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))
{
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 */
continue;
@ -1173,7 +1173,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
{
PP_Ent *chat_ent = PP_AcquireSyncSrcEnt(root);
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;
}
} break;
@ -1222,22 +1222,22 @@ void PP_StepSim(PP_SimStepCtx *ctx)
if (!control_ent->valid)
{
control_ent = PP_SpawnTestEmployee(root);
control_ent->predictor = ent->id;
control_ent->predictor = ent->key;
PP_EnableProp(control_ent, PP_Prop_Controlled);
ent->player_control_ent = control_ent->id;
control_ent->controlling_player = ent->id;
ent->player_control_ent = control_ent->key;
control_ent->controlling_player = ent->key;
}
PP_Ent *camera_ent = PP_EntFromKey(world, ent->player_camera_ent);
if (!camera_ent->valid)
{
camera_ent = PP_SpawnTestCamera(root, control_ent);
camera_ent->predictor = ent->id;
ent->player_camera_ent = camera_ent->id;
camera_ent->predictor = ent->key;
ent->player_camera_ent = camera_ent->key;
}
PP_Ent *camera_follow = PP_EntFromKey(world, camera_ent->camera_follow);
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);
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_dir = rel_dir;
//bullet->bullet_launch_velocity = 0.75f;
@ -1489,7 +1489,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
tracer->layer = PP_Layer_Tracers;
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);
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_dir = rel_dir;
//bullet->bullet_launch_velocity = 0.75f;
@ -1537,7 +1537,7 @@ void PP_StepSim(PP_SimStepCtx *ctx)
tracer->layer = PP_Layer_Tracers;
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);
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_EnableProp(joint_ent, PP_Prop_Active);
@ -1566,15 +1566,15 @@ void PP_StepSim(PP_SimStepCtx *ctx)
PP_EnableProp(joint_ent, PP_Prop_WeldJoint);
PP_WeldJointDesc def = PP_CreateWeldJointDef();
def.e0 = ent->id;
def.e1 = target->id;
def.e0 = ent->key;
def.e1 = target->key;
def.xf = xf0_to_xf1;
def.linear_spring_hz = 10;
def.linear_spring_damp = 0.3f;
def.angular_spring_hz = 10;
def.angular_spring_damp = 0.3f;
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)
@ -1604,12 +1604,12 @@ void PP_StepSim(PP_SimStepCtx *ctx)
joint_ent->inertia_unscaled = F32Infinity;
PP_EnableProp(joint_ent, PP_Prop_Active);
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_MotorJointDesc def = PP_CreateMotorJointDef();
def.e0 = joint_ent->id; /* Re-using joint entity as e0 */
def.e1 = ent->id;
def.e0 = joint_ent->key; /* Re-using joint entity as e0 */
def.e1 = ent->key;
def.correction_rate = 0;
def.max_force = ent->control_force;
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_MotorJoint);
PP_EnableProp(joint_ent, PP_Prop_Active);
ent->aim_joint = joint_ent->id;
ent->aim_joint = joint_ent->key;
PP_MotorJointDesc def = PP_CreateMotorJointDef();
def.e0 = joint_ent->id; /* Re-using joint entity as e0 */
def.e1 = ent->id;
def.e0 = joint_ent->key; /* Re-using joint entity as e0 */
def.e1 = ent->key;
def.max_force = 0;
def.max_torque = ent->control_torque;
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_MotorJointDesc def = PP_CreateMotorJointDef();
def.e0 = root->id;
def.e1 = ent->id;
def.e0 = root->key;
def.e1 = ent->key;
def.correction_rate = 0;
def.max_force = ent->linear_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_Active);
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->mass_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_Active);
}
Xform xf = PP_XformFromEnt(target_ent);
PP_MouseJointDesc def = PP_CreateMouseJointDef();
def.target = target_ent->id;
if (PP_EqEntKey(joint_ent->mouse_joint_data.target, target_ent->id))
def.target = target_ent->key;
if (PP_EqEntKey(joint_ent->mouse_joint_data.target, target_ent->key))
{
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))
{
joint_ent->mouse_joint_data.target = target_ent->id;
joint_ent->mouse_joint_data.target = target_ent->key;
}
}
}