From 571f1b71817358617e63fa741aefa246c2b6821f Mon Sep 17 00:00:00 2001 From: jacob Date: Thu, 6 Nov 2025 18:16:47 -0600 Subject: [PATCH] renamespace sprite 'S' -> 'SPR' --- src/meta/meta.c | 2 +- src/pp/pp.c | 26 ++++----- src/pp/pp_ent.h | 6 +-- src/pp/pp_step.c | 48 ++++++++--------- src/sprite/sprite.c | 126 ++++++++++++++++++++++---------------------- src/sprite/sprite.h | 102 +++++++++++++++++------------------ src/ui/ui_core.c | 6 +++ src/ui/ui_core.h | 1 + 8 files changed, 162 insertions(+), 155 deletions(-) diff --git a/src/meta/meta.c b/src/meta/meta.c index d898d185..f1742001 100644 --- a/src/meta/meta.c +++ b/src/meta/meta.c @@ -903,7 +903,7 @@ JobDef(Build, _, __) EchoLine(Lit("No layer supplied, assuming \"pp\" build")); layer_name = Lit("pp"); } - EchoLine(StringF(arena, "Building program from layer \"%F\"", FmtString(layer_name))); + EchoLine(StringF(arena, "Building \"%F\"", FmtString(layer_name))); cmdline.leaf_layer_name = layer_name; } diff --git a/src/pp/pp.c b/src/pp/pp.c index 9e1a99ee..ec03f06f 100644 --- a/src/pp/pp.c +++ b/src/pp/pp.c @@ -1101,7 +1101,7 @@ void PP_UpdateUser(void) { PP_Ent *ent = sorted[sorted_index]; if (!PP_IsValidAndActive(ent)) continue; - //if (S_IsNil(ent->sprite)) continue; + //if (SPR_IsNil(ent->sprite)) continue; ResourceKey sprite = ent->sprite; @@ -1167,15 +1167,15 @@ void PP_UpdateUser(void) /* Draw sprite */ if (!IsResourceNil(sprite)) { - S_Sheet *sheet = S_SheetFromResourceAsync(sprite); - S_Texture *texture = S_TextureFromResourceAsync(sprite); + SPR_Sheet *sheet = SPR_SheetFromResourceAsync(sprite); + SPR_Texture *texture = SPR_TextureFromResourceAsync(sprite); /* TODO: Fade in placeholder if texture isn't loaded */ if (sheet->loaded && texture->loaded) { b32 is_light = PP_HasProp(ent, PP_Prop_LightTest); Vec3 emittance = ent->sprite_emittance; u32 tint = ent->sprite_tint; - S_Frame frame = S_FrameFromIndex(sheet, ent->animation_frame); + SPR_Frame frame = SPR_FrameFromIndex(sheet, ent->animation_frame); PP_MaterialInstance *mat = PushStruct(g->material_instances_arena, PP_MaterialInstance); *mat = PP_DefaultMaterialInstance; mat->xf = sprite_xform; @@ -1194,7 +1194,7 @@ void PP_UpdateUser(void) { Vec2I32 chunk_index = ent->tile_chunk_index; ResourceKey tile_sprite = ResourceKeyFromStore(&PP_Resources, Lit("sprite/tile.ase")); - S_Texture *tile_texture = S_TextureFromResourceAsync(tile_sprite); + SPR_Texture *tile_texture = SPR_TextureFromResourceAsync(tile_sprite); if (tile_texture->loaded) { f32 tile_size = 1.f / SIM_TILES_PER_UNIT_SQRT; @@ -1257,8 +1257,8 @@ void PP_UpdateUser(void) /* Draw focus arrow */ if (ent == local_control || PP_EqEntKey(ent->key, g->debug_following)) { - S_Sheet *sheet = S_SheetFromResourceAsync(ent->sprite); - S_Slice slice = S_SliceFromNameIndex(sheet, Lit("attach.wep"), ent->animation_frame); + SPR_Sheet *sheet = SPR_SheetFromResourceAsync(ent->sprite); + SPR_Slice slice = SPR_SliceFromNameIndex(sheet, Lit("attach.wep"), ent->animation_frame); Vec2 start = MulXformV2(sprite_xform, slice.center); start = MulXformV2(g->world_to_ui_xf, start); Vec2 end = AddVec2(xf.og, ent->control.focus); @@ -1269,9 +1269,9 @@ void PP_UpdateUser(void) #if 0 /* Draw slices */ - if (!S_IsNil(ent->sprite)) + if (!SPR_IsNil(ent->sprite)) { - S_Sheet *sheet = S_SheetFromResourceAsync(sprite); + SPR_Sheet *sheet = SPR_SheetFromResourceAsync(sprite); u32 quad_color = Rgba32F(1, 0, 0.5, 1); u32 point_color = Rgba32F(1, 0, 0, 1); @@ -1279,12 +1279,12 @@ void PP_UpdateUser(void) for (u64 i = 0; i < sheet->slice_groups_count; ++i) { - S_SheetSliceGroup *group = &sheet->slice_groups[i]; + SPR_SheetSliceGroup *group = &sheet->slice_groups[i]; if (StringEndsWith(group->name, Lit(".ray"))) continue; for (u32 j = 0; j < group->per_frame_count; ++j) { - S_Slice slice = group->frame_slices[(ent->animation_frame * group->per_frame_count) + j]; + SPR_Slice slice = group->frame_slices[(ent->animation_frame * group->per_frame_count) + j]; Vec2 center = MulXformV2(sprite_xform, slice.center); center = MulXformV2(g->world_to_ui_xf, center); @@ -1701,7 +1701,7 @@ void PP_UpdateUser(void) __profn("Draw crosshair"); Vec2 crosshair_pos = g->ui_cursor; ResourceKey crosshair = ResourceKeyFromStore(PP_Resources, Lit("sprite/crosshair.ase")); - S_Texture *t = S_TextureFromResourceAsync(crosshair); + SPR_Texture *t = SPR_TextureFromResourceAsync(crosshair); Vec2 size = VEC2(t->width, t->height); Xform xf = XformFromTrs(TRS(.t = crosshair_pos, .s = size)); D_DrawUiRect(g->render_sig, D_UIRECTPARAMS(.xf = xf, .texture = t->gpu_resource)); @@ -1719,7 +1719,7 @@ void PP_UpdateUser(void) } else { - S_Texture *t = S_TextureFromResourceAsync(ResourceKeyFromStore(PP_Resources, Lit("sprite/crosshair.ase"))); + SPR_Texture *t = SPR_TextureFromResourceAsync(ResourceKeyFromStore(PP_Resources, Lit("sprite/crosshair.ase"))); Vec2 size = VEC2(t->width, t->height); Rect cursor_clip = RectFromVec2(g->ui_screen_offset, g->ui_size); cursor_clip.pos = AddVec2(cursor_clip.pos, MulVec2(size, 0.5f)); diff --git a/src/pp/pp_ent.h b/src/pp/pp_ent.h index d02f4e35..6b5368e9 100644 --- a/src/pp/pp_ent.h +++ b/src/pp/pp_ent.h @@ -248,11 +248,11 @@ Struct(PP_Ent) //- Sprite ResourceKey sprite; - S_SpanKey sprite_span_key; + SPR_SpanKey sprite_span_key; u32 sprite_tint; Vec3 sprite_emittance; - S_SliceKey sprite_collider_slice_key; /* Collider will sync to bounds of this slice if set */ + SPR_SliceKey sprite_collider_slice_key; /* Collider will sync to bounds of this slice if set */ Xform sprite_local_xform; /* Sprite transform in relation to ent */ @@ -266,7 +266,7 @@ Struct(PP_Ent) /* PP_Prop_Attached */ /* Slice on the parent ent's sprite to attach to */ - S_SliceKey attach_slice_key; + SPR_SliceKey attach_slice_key; //- Equip diff --git a/src/pp/pp_step.c b/src/pp/pp_step.c index 78454db8..78fc1f3c 100644 --- a/src/pp/pp_step.c +++ b/src/pp/pp_step.c @@ -39,7 +39,7 @@ PP_Ent *PP_SpawnTestSmg(PP_Ent *parent) e->sprite = ResourceKeyFromStore(&PP_Resources, Lit("sprite/gun.ase")); PP_EnableProp(e, PP_Prop_Attached); - e->attach_slice_key = S_SliceKeyFromName(Lit("attach.wep")); + e->attach_slice_key = SPR_SliceKeyFromName(Lit("attach.wep")); e->layer = PP_Layer_RelativeWeapon; PP_EnableProp(e, PP_Prop_Smg); @@ -55,7 +55,7 @@ PP_Ent *PP_SpawnTestLauncher(PP_Ent *parent) e->sprite = ResourceKeyFromStore(&PP_Resources, Lit("sprite/gun.ase")); PP_EnableProp(e, PP_Prop_Attached); - e->attach_slice_key = S_SliceKeyFromName(Lit("attach.wep")); + e->attach_slice_key = SPR_SliceKeyFromName(Lit("attach.wep")); e->layer = PP_Layer_RelativeWeapon; PP_EnableProp(e, PP_Prop_Launcher); @@ -71,7 +71,7 @@ PP_Ent *PP_SpawnTestChucker(PP_Ent *parent) chucker->sprite = ResourceKeyFromStore(&PP_Resources, Lit("sprite/gun.ase")); PP_EnableProp(chucker, PP_Prop_Attached); - chucker->attach_slice_key = S_SliceKeyFromName(Lit("attach.wep")); + chucker->attach_slice_key = SPR_SliceKeyFromName(Lit("attach.wep")); chucker->layer = PP_Layer_RelativeWeapon; PP_EnableProp(chucker, PP_Prop_Chucker); @@ -85,7 +85,7 @@ PP_Ent *PP_SpawnTestChucker(PP_Ent *parent) PP_EnableProp(zone, PP_Prop_ChuckerZone); PP_EnableProp(zone, PP_Prop_Attached); - zone->attach_slice_key = S_SliceKeyFromName(Lit("out")); + zone->attach_slice_key = SPR_SliceKeyFromName(Lit("out")); PP_EnableProp(zone, PP_Prop_Sensor); CLD_Shape collider = ZI; @@ -125,9 +125,9 @@ PP_Ent *PP_SpawnTestEmployee(PP_Ent *parent) } //e->sprite = ResourceKeyFromStore(PP_Resources, Lit("sprite/box_rounded.ase")); - //e->sprite_span_key = S_SpanKeyFromName(Lit("idle.unarmed")); - //e->sprite_span_key = S_SpanKeyFromName(Lit("idle.one_handed")); - e->sprite_span_key = S_SpanKeyFromName(Lit("idle.two_handed")); + //e->sprite_span_key = SPR_SpanKeyFromName(Lit("idle.unarmed")); + //e->sprite_span_key = SPR_SpanKeyFromName(Lit("idle.one_handed")); + e->sprite_span_key = SPR_SpanKeyFromName(Lit("idle.two_handed")); e->layer = PP_Layer_Shoulders; e->local_collider.points[0] = VEC2(0, 0); @@ -383,8 +383,8 @@ void PP_SpawnTestTile(PP_Snapshot *world, Vec2 world_pos) e->sprite = ResourceKeyFromStore(PP_Resources, Lit("sprite/tile.ase")); e->sprite_tint = Color_Red; - S_Sheet *sheet = S_SheetFromResource(e->sprite); - e->sprite_local_xform = XformFromTrs(.s = DivVec2(sheet->frame_size, PIXELS_PER_UNIT)); + SPR_Sheet *sheet = SPR_SheetFromResource(e->sprite); + e->sprite_local_xform = XformFromTrs(.s = DivVec2(sheet->frame_size, PIXELSPR_PER_UNIT)); PP_EnableProp(e, PP_Prop_Solid); Quad collider_quad = QuadFromRect(RectFromScalar(-tile_size.x / 2, -tile_size.y / 2, tile_size.y, tile_size.y)); @@ -1251,11 +1251,11 @@ void PP_StepSim(PP_SimStepCtx *ctx) if (!PP_ShouldSimulate(ent)) continue; if (IsResourceNil(ent->sprite)) continue; - S_Sheet *sheet = S_SheetFromResource(ent->sprite); + SPR_Sheet *sheet = SPR_SheetFromResource(ent->sprite); /* Update animation */ { - S_Span span = S_SpanFromKey(sheet, ent->sprite_span_key); + SPR_Span span = SPR_SpanFromKey(sheet, ent->sprite_span_key); if (ent->animation_last_frame_change_time_ns == 0) { ent->animation_last_frame_change_time_ns = SecondsFromNs(world->sim_time_ns); @@ -1270,7 +1270,7 @@ void PP_StepSim(PP_SimStepCtx *ctx) if (span.end > span.start) { - S_Frame frame = S_FrameFromIndex(sheet, frame_index); + SPR_Frame frame = SPR_FrameFromIndex(sheet, frame_index); while (time_in_frame > frame.duration) { time_in_frame -= frame.duration; @@ -1280,7 +1280,7 @@ void PP_StepSim(PP_SimStepCtx *ctx) /* Loop animation */ frame_index = span.start; } - frame = S_FrameFromIndex(sheet, frame_index); + frame = SPR_FrameFromIndex(sheet, frame_index); ent->animation_last_frame_change_time_ns = world->sim_time_ns; } } @@ -1291,8 +1291,8 @@ void PP_StepSim(PP_SimStepCtx *ctx) #if 0 /* Update sprite local xform */ { - S_Slice pivot_slice = S_SliceFromKey(sheet, Lit("pivot"), ent->animation_frame); - Vec2 sprite_size = DivVec2(sheet->frame_size, (f32)PIXELS_PER_UNIT); + SPR_Slice pivot_slice = SPR_SliceFromKey(sheet, Lit("pivot"), ent->animation_frame); + Vec2 sprite_size = DivVec2(sheet->frame_size, (f32)PIXELSPR_PER_UNIT); Vec2 dir = MulVec2Vec2(sprite_size, pivot_slice.dir); f32 rot = AngleFromVec2(dir) + Pi / 2; @@ -1309,7 +1309,7 @@ void PP_StepSim(PP_SimStepCtx *ctx) if (ent->sprite_collider_slice_key.hash != 0) { Xform cxf = ent->sprite_local_xform; - S_Slice slice = S_SliceFromKey(sheet, ent->sprite_collider_slice_key, ent->animation_frame); + SPR_Slice slice = SPR_SliceFromKey(sheet, ent->sprite_collider_slice_key, ent->animation_frame); ent->local_collider = CLD_ShapeFromQuad(MulXformQuad(cxf, QuadFromRect(slice.rect))); } @@ -1360,11 +1360,11 @@ void PP_StepSim(PP_SimStepCtx *ctx) PP_Ent *parent = PP_EntFromKey(world, ent->parent); ResourceKey parent_sprite = parent->sprite; - S_Sheet *parent_sheet = S_SheetFromResource(parent_sprite); + SPR_Sheet *parent_sheet = SPR_SheetFromResource(parent_sprite); Xform parent_sprite_xf = parent->sprite_local_xform; - S_Slice attach_slice = S_SliceFromKey(parent_sheet, ent->attach_slice_key, parent->animation_frame); + SPR_Slice attach_slice = SPR_SliceFromKey(parent_sheet, ent->attach_slice_key, parent->animation_frame); Vec2 attach_pos = MulXformV2(parent_sprite_xf, attach_slice.center); Vec2 attach_dir = MulXformBasisV2(parent_sprite_xf, attach_slice.dir); @@ -1452,9 +1452,9 @@ void PP_StepSim(PP_SimStepCtx *ctx) { ResourceKey sprite = ent->sprite; u32 animation_frame = ent->animation_frame; - S_Sheet *sheet = S_SheetFromResource(sprite); + SPR_Sheet *sheet = SPR_SheetFromResource(sprite); Xform sprite_local_xform = ent->sprite_local_xform; - S_Slice out_slice = S_SliceFromKey(sheet, S_SliceKeyFromName(Lit("out")), animation_frame); + SPR_Slice out_slice = SPR_SliceFromKey(sheet, SPR_SliceKeyFromName(Lit("out")), animation_frame); Vec2 rel_pos = MulXformV2(sprite_local_xform, out_slice.center); Vec2 rel_dir = MulXformBasisV2(sprite_local_xform, out_slice.dir); @@ -1501,9 +1501,9 @@ void PP_StepSim(PP_SimStepCtx *ctx) { ResourceKey sprite = ent->sprite; u32 animation_frame = ent->animation_frame; - S_Sheet *sheet = S_SheetFromResource(sprite); + SPR_Sheet *sheet = SPR_SheetFromResource(sprite); Xform sprite_local_xform = ent->sprite_local_xform; - S_Slice out_slice = S_SliceFromKey(sheet, S_SliceKeyFromName(Lit("out")), animation_frame); + SPR_Slice out_slice = SPR_SliceFromKey(sheet, SPR_SliceKeyFromName(Lit("out")), animation_frame); Vec2 rel_pos = MulXformV2(sprite_local_xform, out_slice.center); Vec2 rel_dir = MulXformBasisV2(sprite_local_xform, out_slice.dir); @@ -1673,8 +1673,8 @@ void PP_StepSim(PP_SimStepCtx *ctx) Vec2 sprite_hold_pos; Vec2 sprite_hold_dir; { - S_Sheet *sheet = S_SheetFromResource(ent->sprite); - S_Slice slice = S_SliceFromKey(sheet, S_SliceKeyFromName(Lit("attach.wep")), ent->animation_frame); + SPR_Sheet *sheet = SPR_SheetFromResource(ent->sprite); + SPR_Slice slice = SPR_SliceFromKey(sheet, SPR_SliceKeyFromName(Lit("attach.wep")), ent->animation_frame); sprite_hold_pos = slice.center; sprite_hold_dir = slice.dir; } diff --git a/src/sprite/sprite.c b/src/sprite/sprite.c index 40a9c5a4..e92b6800 100644 --- a/src/sprite/sprite.c +++ b/src/sprite/sprite.c @@ -1,17 +1,17 @@ -Readonly S_Texture S_NilTexture = ZI; -Readonly S_Sheet S_NilSheet = ZI; -S_SharedState S_shared_state = ZI; +Readonly SPR_Texture SPR_NilTexture = ZI; +Readonly SPR_Sheet SPR_NilSheet = ZI; +SPR_SharedState SPR_shared_state = ZI; //////////////////////////////////////////////////////////// //~ Load jobs -JobDef(S_LoadTexture, sig, _) +JobDef(SPR_LoadTexture, sig, _) { TempArena scratch = BeginScratchNoConflict(); - S_Entry *entry = sig->entry; + SPR_Entry *entry = sig->entry; ResourceKey resource = entry->resource; b32 ok = 1; - S_Texture *texture = &entry->texture; + SPR_Texture *texture = &entry->texture; texture->valid = 1; String name = NameFromResource(resource); @@ -93,14 +93,14 @@ JobDef(S_LoadTexture, sig, _) EndScratch(scratch); } -JobDef(S_LoadSheet, sig, _) +JobDef(SPR_LoadSheet, sig, _) { TempArena scratch = BeginScratchNoConflict(); Arena *perm = PermArena(); - S_Entry *entry = sig->entry; + SPR_Entry *entry = sig->entry; ResourceKey resource = entry->resource; b32 ok = 1; - S_Sheet *sheet = &entry->sheet; + SPR_Sheet *sheet = &entry->sheet; sheet->valid = 1; String name = NameFromResource(resource); @@ -120,10 +120,10 @@ JobDef(S_LoadSheet, sig, _) /* Init frames */ sheet->frames_count = decoded.num_frames; - sheet->frames = PushStructs(perm, S_Frame, sheet->frames_count); + sheet->frames = PushStructs(perm, SPR_Frame, sheet->frames_count); for (ASE_Frame *src = decoded.first_frame; src; src = src->next) { - S_Frame *dst = &sheet->frames[src->index]; + SPR_Frame *dst = &sheet->frames[src->index]; dst->index = src->index; dst->duration = src->duration; dst->clip.p0 = VEC2((f32)src->x1 / (f32)image_size.x, (f32)src->y1 / (f32)image_size.y); @@ -133,20 +133,20 @@ JobDef(S_LoadSheet, sig, _) /* Init spans */ sheet->spans_count = decoded.num_spans; sheet->span_bins_count = MaxU32(AlignU64Pow2(sheet->spans_count * 2), 1); - sheet->spans = PushStructs(perm, S_Span, sheet->spans_count); - sheet->span_bins = PushStructs(perm, S_SpanBin, sheet->span_bins_count); + sheet->spans = PushStructs(perm, SPR_Span, sheet->spans_count); + sheet->span_bins = PushStructs(perm, SPR_SpanBin, sheet->span_bins_count); { i32 span_index = 0; for (ASE_Span *src = decoded.first_span; src; src = src->next) { - S_Span *dst = &sheet->spans[span_index]; + SPR_Span *dst = &sheet->spans[span_index]; dst->hash = HashFnv64(Fnv64Basis, src->name); dst->name = PushString(perm, src->name); dst->start = src->start; dst->end = src->end; /* Insert span into bin */ { - S_SpanBin *bin = &sheet->span_bins[dst->hash % sheet->span_bins_count]; + SPR_SpanBin *bin = &sheet->span_bins[dst->hash % sheet->span_bins_count]; QueuePushN(bin->first, bin->last, dst, next_in_bin); } ++span_index; @@ -156,18 +156,18 @@ JobDef(S_LoadSheet, sig, _) /* Init slice groups */ sheet->slice_groups_count = decoded.num_slice_keys; sheet->slice_group_bins_count = MaxU32(AlignU64Pow2(sheet->slice_groups_count * 2), 1); - sheet->slice_groups = PushStructs(perm, S_SliceGroup, sheet->slice_groups_count); - sheet->slice_group_bins = PushStructs(perm, S_SliceGroupBin, sheet->slice_group_bins_count); + sheet->slice_groups = PushStructs(perm, SPR_SliceGroup, sheet->slice_groups_count); + sheet->slice_group_bins = PushStructs(perm, SPR_SliceGroupBin, sheet->slice_group_bins_count); { i32 group_index = 0; for (ASE_SliceKey *src_group = decoded.first_slice_key; src_group; src_group = src_group->next) { - S_SliceGroup *dst_group = &sheet->slice_groups[group_index]; + SPR_SliceGroup *dst_group = &sheet->slice_groups[group_index]; dst_group->hash = HashFnv64(Fnv64Basis, src_group->name); dst_group->name = PushString(perm, src_group->name); /* Init slices */ - dst_group->slices = PushStructs(perm, S_Slice, sheet->frames_count); + dst_group->slices = PushStructs(perm, SPR_Slice, sheet->frames_count); { /* Fill is_original slices */ for (ASE_Slice *src_slice = src_group->first_slice; src_slice; src_slice = src_slice->next) @@ -198,7 +198,7 @@ JobDef(S_LoadSheet, sig, _) Vec2 dir_px = VEC2(center_px.x, -1); Vec2 dir = VEC2(0, -1); - S_Slice *dst_slice = &dst_group->slices[src_slice->start]; + SPR_Slice *dst_slice = &dst_group->slices[src_slice->start]; dst_slice->is_original = 1; dst_slice->rect_px = rect_px; dst_slice->center_px = center_px; @@ -210,10 +210,10 @@ JobDef(S_LoadSheet, sig, _) /* Copy slices forward into frames without a slice */ { - S_Slice *origin = 0; + SPR_Slice *origin = 0; for (u32 frame_index = 0; frame_index < sheet->frames_count; ++frame_index) { - S_Slice *slice = &dst_group->slices[frame_index]; + SPR_Slice *slice = &dst_group->slices[frame_index]; if (slice->is_original) { origin = slice; @@ -229,7 +229,7 @@ JobDef(S_LoadSheet, sig, _) /* Insert group into bin */ { - S_SliceGroupBin *bin = &sheet->slice_group_bins[dst_group->hash % sheet->slice_group_bins_count]; + SPR_SliceGroupBin *bin = &sheet->slice_group_bins[dst_group->hash % sheet->slice_group_bins_count]; QueuePushN(bin->first, bin->last, dst_group, next_in_bin); } ++group_index; @@ -241,14 +241,14 @@ JobDef(S_LoadSheet, sig, _) String ray_suffix = Lit(".ray"); for (u32 slice_group_index = 0; slice_group_index < sheet->slice_groups_count; ++slice_group_index) { - S_SliceGroup *group = &sheet->slice_groups[slice_group_index]; + SPR_SliceGroup *group = &sheet->slice_groups[slice_group_index]; if (StringEndsWith(group->name, ray_suffix)) { String point_slice_group_name = group->name; point_slice_group_name.len -= ray_suffix.len; u64 point_slice_group_hash = HashFnv64(Fnv64Basis, point_slice_group_name); - S_SliceGroupBin *bin = &sheet->slice_group_bins[point_slice_group_hash % sheet->slice_group_bins_count]; - S_SliceGroup *point_slice_group = bin->first; + SPR_SliceGroupBin *bin = &sheet->slice_group_bins[point_slice_group_hash % sheet->slice_group_bins_count]; + SPR_SliceGroup *point_slice_group = bin->first; for (; point_slice_group; point_slice_group = point_slice_group->next_in_bin) { if (point_slice_group->hash == point_slice_group_hash) @@ -260,8 +260,8 @@ JobDef(S_LoadSheet, sig, _) { for (u32 frame_index = 0; frame_index < sheet->frames_count; ++frame_index) { - S_Slice *point_slice = &point_slice_group->slices[frame_index]; - S_Slice *ray_slice = &group->slices[frame_index]; + SPR_Slice *point_slice = &point_slice_group->slices[frame_index]; + SPR_Slice *ray_slice = &group->slices[frame_index]; Vec2 ray_end = ray_slice->center_px; Vec2 ray_end_norm = ray_slice->center; point_slice->dir_px = SubVec2(ray_end, point_slice->center_px); @@ -283,12 +283,12 @@ JobDef(S_LoadSheet, sig, _) //~ Cache /* TODO: Per-fiber L1 cache */ -S_Entry *S_FetchEntry(ResourceKey resource, JobPoolId pool, S_FetchFlag flags) +SPR_Entry *SPR_FetchEntry(ResourceKey resource, JobPoolId pool, SPR_FetchFlag flags) { - S_SharedState *g = &S_shared_state; - S_Entry *entry = 0; + SPR_SharedState *g = &SPR_shared_state; + SPR_Entry *entry = 0; { - S_EntryBin *bin = &g->entry_bins[resource.hash % S_EntryBinsCount]; + SPR_EntryBin *bin = &g->entry_bins[resource.hash % SPR_EntryBinsCount]; /* Search for entry */ entry = bin->first; { @@ -322,7 +322,7 @@ S_Entry *S_FetchEntry(ResourceKey resource, JobPoolId pool, S_FetchFlag flags) if (!entry) { Arena *perm = PermArena(); - entry = PushStruct(perm, S_Entry); + entry = PushStruct(perm, SPR_Entry); entry->resource = resource; QueuePushN(bin->first, bin->last, entry, next_in_bin); } @@ -331,17 +331,17 @@ S_Entry *S_FetchEntry(ResourceKey resource, JobPoolId pool, S_FetchFlag flags) } } /* Launch load jobs */ - if ((flags & S_FetchFlag_Texture) + if ((flags & SPR_FetchFlag_Texture) && !Atomic32Fetch(&entry->texture_touched) && !Atomic32FetchTestSet(&entry->texture_touched, 0, 1)) { - RunJob(S_LoadTexture, .pool = pool, .sig.entry = entry); + RunJob(SPR_LoadTexture, .pool = pool, .sig.entry = entry); } - if ((flags & S_FetchFlag_Sheet) + if ((flags & SPR_FetchFlag_Sheet) && !Atomic32Fetch(&entry->sheet_touched) && !Atomic32FetchTestSet(&entry->sheet_touched, 0, 1)) { - RunJob(S_LoadSheet, .pool = pool, .sig.entry = entry); + RunJob(SPR_LoadSheet, .pool = pool, .sig.entry = entry); } return entry; } @@ -349,17 +349,17 @@ S_Entry *S_FetchEntry(ResourceKey resource, JobPoolId pool, S_FetchFlag flags) //////////////////////////////////////////////////////////// //~ Sprite data retrieval operations -S_Texture *S_TextureFromResource(ResourceKey resource) +SPR_Texture *SPR_TextureFromResource(ResourceKey resource) { - S_Entry *entry = S_FetchEntry(resource, CurrentPool(), S_FetchFlag_Texture); + SPR_Entry *entry = SPR_FetchEntry(resource, CurrentPool(), SPR_FetchFlag_Texture); YieldOnFence(&entry->texture_ready_fence, 1); return &entry->texture; } -S_Texture *S_TextureFromResourceAsync(ResourceKey resource) +SPR_Texture *SPR_TextureFromResourceAsync(ResourceKey resource) { - S_Texture *result = &S_NilTexture; - S_Entry *entry = S_FetchEntry(resource, AsyncPool(), S_FetchFlag_Texture); + SPR_Texture *result = &SPR_NilTexture; + SPR_Entry *entry = SPR_FetchEntry(resource, AsyncPool(), SPR_FetchFlag_Texture); if (FetchFence(&entry->texture_ready_fence) >= 1) { result = &entry->texture; @@ -367,17 +367,17 @@ S_Texture *S_TextureFromResourceAsync(ResourceKey resource) return result; } -S_Sheet *S_SheetFromResource(ResourceKey resource) +SPR_Sheet *SPR_SheetFromResource(ResourceKey resource) { - S_Entry *entry = S_FetchEntry(resource, CurrentPool(), S_FetchFlag_Sheet); + SPR_Entry *entry = SPR_FetchEntry(resource, CurrentPool(), SPR_FetchFlag_Sheet); YieldOnFence(&entry->sheet_ready_fence, 1); return &entry->sheet; } -S_Sheet *S_SheetFromResourceAsync(ResourceKey resource) +SPR_Sheet *SPR_SheetFromResourceAsync(ResourceKey resource) { - S_Sheet *result = &S_NilSheet; - S_Entry *entry = S_FetchEntry(resource, AsyncPool(), S_FetchFlag_Sheet); + SPR_Sheet *result = &SPR_NilSheet; + SPR_Entry *entry = SPR_FetchEntry(resource, AsyncPool(), SPR_FetchFlag_Sheet); if (FetchFence(&entry->sheet_ready_fence) >= 1) { result = &entry->sheet; @@ -388,16 +388,16 @@ S_Sheet *S_SheetFromResourceAsync(ResourceKey resource) //////////////////////////////////////////////////////////// //~ Key helpers -S_SpanKey S_SpanKeyFromName(String name) +SPR_SpanKey SPR_SpanKeyFromName(String name) { - S_SpanKey result = ZI; + SPR_SpanKey result = ZI; result.hash = HashFnv64(Fnv64Basis, name); return result; } -S_SliceKey S_SliceKeyFromName(String name) +SPR_SliceKey SPR_SliceKeyFromName(String name) { - S_SliceKey result = ZI; + SPR_SliceKey result = ZI; result.hash = HashFnv64(Fnv64Basis, name); return result; } @@ -405,14 +405,14 @@ S_SliceKey S_SliceKeyFromName(String name) //////////////////////////////////////////////////////////// //~ Sheet access operations -S_Span S_SpanFromKey(S_Sheet *sheet, S_SpanKey key) +SPR_Span SPR_SpanFromKey(SPR_Sheet *sheet, SPR_SpanKey key) { - S_Span result = ZI; + SPR_Span result = ZI; u32 bins_count = sheet->span_bins_count; if (bins_count > 0) { - S_SpanBin *bin = &sheet->span_bins[key.hash % bins_count]; - S_Span *span = bin->first; + SPR_SpanBin *bin = &sheet->span_bins[key.hash % bins_count]; + SPR_Span *span = bin->first; for (; span; span = span->next_in_bin) { if (span->hash == key.hash) @@ -426,9 +426,9 @@ S_Span S_SpanFromKey(S_Sheet *sheet, S_SpanKey key) return result; } -S_Frame S_FrameFromIndex(S_Sheet *sheet, u64 index) +SPR_Frame SPR_FrameFromIndex(SPR_Sheet *sheet, u64 index) { - S_Frame result = ZI; + SPR_Frame result = ZI; if (sheet->frames_count > 0) { result = sheet->frames[index % sheet->frames_count]; @@ -436,16 +436,16 @@ S_Frame S_FrameFromIndex(S_Sheet *sheet, u64 index) return result; } -S_Slice S_SliceFromKey(S_Sheet *sheet, S_SliceKey key, u64 frame_index) +SPR_Slice SPR_SliceFromKey(SPR_Sheet *sheet, SPR_SliceKey key, u64 frame_index) { - S_Slice result = ZI; + SPR_Slice result = ZI; b32 match = 0; u32 bins_count = sheet->slice_group_bins_count; if (bins_count > 0 && sheet->frames_count > 0) { - S_SliceGroupBin *bin = &sheet->slice_group_bins[key.hash % bins_count]; - S_SliceGroup *group = bin->first; + SPR_SliceGroupBin *bin = &sheet->slice_group_bins[key.hash % bins_count]; + SPR_SliceGroup *group = bin->first; for (; group; group = group->next_in_bin) { if (group->hash == key.hash) @@ -460,7 +460,7 @@ S_Slice S_SliceFromKey(S_Sheet *sheet, S_SliceKey key, u64 frame_index) /* Return 'pivot' by default */ if (!match) { - S_SliceKey pivot_key = S_SliceKeyFromName(Lit("pivot")); + SPR_SliceKey pivot_key = SPR_SliceKeyFromName(Lit("pivot")); if (key.hash == pivot_key.hash) { /* 'pivot' slice does not exist, return center */ @@ -471,7 +471,7 @@ S_Slice S_SliceFromKey(S_Sheet *sheet, S_SliceKey key, u64 frame_index) } else { - result = S_SliceFromKey(sheet, pivot_key, frame_index); + result = SPR_SliceFromKey(sheet, pivot_key, frame_index); } } diff --git a/src/sprite/sprite.h b/src/sprite/sprite.h index 21587592..eaa01760 100644 --- a/src/sprite/sprite.h +++ b/src/sprite/sprite.h @@ -1,12 +1,12 @@ //////////////////////////////////////////////////////////// //~ Key types -Struct(S_SpanKey) +Struct(SPR_SpanKey) { u64 hash; }; -Struct(S_SliceKey) +Struct(SPR_SliceKey) { u64 hash; }; @@ -14,7 +14,7 @@ Struct(S_SliceKey) //////////////////////////////////////////////////////////// //~ Texture types -Struct(S_Texture) +Struct(SPR_Texture) { b32 valid; b32 loaded; @@ -23,34 +23,34 @@ Struct(S_Texture) u32 height; }; -extern Readonly S_Texture S_NilTexture; +extern Readonly SPR_Texture SPR_NilTexture; //////////////////////////////////////////////////////////// //~ Sheet types -Struct(S_Frame) +Struct(SPR_Frame) { u32 index; f64 duration; ClipRect clip; }; -Struct(S_Span) +Struct(SPR_Span) { - S_Span *next_in_bin; + SPR_Span *next_in_bin; u64 hash; String name; u32 start; u32 end; }; -Struct(S_SpanBin) +Struct(SPR_SpanBin) { - S_Span *first; - S_Span *last; + SPR_Span *first; + SPR_Span *last; }; -Struct(S_Slice) +Struct(SPR_Slice) { /* If 1, this slice was not copied over from another frame in the sprite sheet */ b32 is_original; @@ -69,21 +69,21 @@ Struct(S_Slice) Vec2 dir_px; }; -Struct(S_SliceGroup) +Struct(SPR_SliceGroup) { - S_SliceGroup *next_in_bin; + SPR_SliceGroup *next_in_bin; u64 hash; String name; - S_Slice *slices; + SPR_Slice *slices; }; -Struct(S_SliceGroupBin) +Struct(SPR_SliceGroupBin) { - S_SliceGroup *first; - S_SliceGroup *last; + SPR_SliceGroup *first; + SPR_SliceGroup *last; }; -Struct(S_Sheet) +Struct(SPR_Sheet) { b32 valid; b32 loaded; @@ -91,32 +91,32 @@ Struct(S_Sheet) Vec2 frame_size; u32 frames_count; - S_Frame *frames; + SPR_Frame *frames; u32 spans_count; - S_Span *spans; + SPR_Span *spans; u32 slice_groups_count; - S_SliceGroup *slice_groups; + SPR_SliceGroup *slice_groups; u32 span_bins_count; - S_SpanBin *span_bins; + SPR_SpanBin *span_bins; u32 slice_group_bins_count; - S_SliceGroupBin *slice_group_bins; + SPR_SliceGroupBin *slice_group_bins; }; -extern Readonly S_Sheet S_NilSheet; +extern Readonly SPR_Sheet SPR_NilSheet; //////////////////////////////////////////////////////////// //~ Cache types -Struct(S_Entry) +Struct(SPR_Entry) { - S_Entry *next_in_bin; + SPR_Entry *next_in_bin; - S_Texture texture; - S_Sheet sheet; + SPR_Texture texture; + SPR_Sheet sheet; Atomic32 texture_touched; Atomic32 sheet_touched; @@ -126,59 +126,59 @@ Struct(S_Entry) Fence sheet_ready_fence; }; -Struct(S_EntryBin) +Struct(SPR_EntryBin) { - S_Entry *first; - S_Entry *last; + SPR_Entry *first; + SPR_Entry *last; Mutex mutex; }; //////////////////////////////////////////////////////////// //~ State types -#define S_EntryBinsCount 1024 +#define SPR_EntryBinsCount 1024 -Struct(S_SharedState) +Struct(SPR_SharedState) { - S_EntryBin entry_bins[S_EntryBinsCount]; -} extern S_shared_state; + SPR_EntryBin entry_bins[SPR_EntryBinsCount]; +} extern SPR_shared_state; //////////////////////////////////////////////////////////// //~ Load jobs -JobDecl(S_LoadTexture, { S_Entry *entry; }); -JobDecl(S_LoadSheet, { S_Entry *entry; }); +JobDecl(SPR_LoadTexture, { SPR_Entry *entry; }); +JobDecl(SPR_LoadSheet, { SPR_Entry *entry; }); //////////////////////////////////////////////////////////// //~ Cache operations -Enum(S_FetchFlag) +Enum(SPR_FetchFlag) { - S_FetchFlag_None = 0, - S_FetchFlag_Texture = (1 << 0), - S_FetchFlag_Sheet = (1 << 1), + SPR_FetchFlag_None = 0, + SPR_FetchFlag_Texture = (1 << 0), + SPR_FetchFlag_Sheet = (1 << 1), }; -S_Entry *S_FetchEntry(ResourceKey resource, JobPoolId pool, S_FetchFlag flags); +SPR_Entry *SPR_FetchEntry(ResourceKey resource, JobPoolId pool, SPR_FetchFlag flags); //////////////////////////////////////////////////////////// //~ Sprite data retrieval operations -S_Texture *S_TextureFromResource(ResourceKey resource); -S_Texture *S_TextureFromResourceAsync(ResourceKey resource); +SPR_Texture *SPR_TextureFromResource(ResourceKey resource); +SPR_Texture *SPR_TextureFromResourceAsync(ResourceKey resource); -S_Sheet *S_SheetFromResource(ResourceKey resource); -S_Sheet *S_SheetFromResourceAsync(ResourceKey resource); +SPR_Sheet *SPR_SheetFromResource(ResourceKey resource); +SPR_Sheet *SPR_SheetFromResourceAsync(ResourceKey resource); //////////////////////////////////////////////////////////// //~ Key helpers -S_SpanKey S_SpanKeyFromName(String name); -S_SliceKey S_SliceKeyFromName(String name); +SPR_SpanKey SPR_SpanKeyFromName(String name); +SPR_SliceKey SPR_SliceKeyFromName(String name); //////////////////////////////////////////////////////////// //~ Sheet access operations -S_Span S_SpanFromKey(S_Sheet *sheet, S_SpanKey key); -S_Frame S_FrameFromIndex(S_Sheet *sheet, u64 index); -S_Slice S_SliceFromKey(S_Sheet *sheet, S_SliceKey key, u64 frame_index); +SPR_Span SPR_SpanFromKey(SPR_Sheet *sheet, SPR_SpanKey key); +SPR_Frame SPR_FrameFromIndex(SPR_Sheet *sheet, u64 index); +SPR_Slice SPR_SliceFromKey(SPR_Sheet *sheet, SPR_SliceKey key, u64 frame_index); diff --git a/src/ui/ui_core.c b/src/ui/ui_core.c index 0d06e5a5..0a94afbe 100644 --- a/src/ui/ui_core.c +++ b/src/ui/ui_core.c @@ -631,6 +631,11 @@ UI_Frame UI_BeginFrame(UI_FrameFlag frame_flags) } } } break; + + case ControllerEventKind_Quit: + { + SignalExit(0); + } break; } } @@ -709,6 +714,7 @@ UI_Frame UI_BeginFrame(UI_FrameFlag frame_flags) UI_PushEmptyStack(); + frame.cursor_pos = g->cursor_pos; return frame; } diff --git a/src/ui/ui_core.h b/src/ui/ui_core.h index e977a29b..36297524 100644 --- a/src/ui/ui_core.h +++ b/src/ui/ui_core.h @@ -273,6 +273,7 @@ Enum(UI_FrameFlag) Struct(UI_Frame) { WND_Frame window_frame; + Vec2 cursor_pos; }; ////////////////////////////////////////////////////////////