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

texture cache w/ eviction & reloading

Browse Source
This commit is contained in:
jacob 2024-05-01 00:22:06 -05:00
parent 42a2d97d3d
commit cf3d678699
21 changed files with 1149 additions and 516 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
res/graphics/white.ase (Stored with Git LFS) Normal file
View File

Binary file not shown.

5
src/app.c
View File

@ -20,6 +20,7 @@
#include "settings.h"
#include "draw.h"
#include "math.h"
#include "renderer.h"
struct exit_callback {
app_exit_callback_func *func;
@ -209,8 +210,8 @@ void app_entry_point(void)
struct asset_cache_startup_receipt asset_cache_sr = asset_cache_startup(&work_sr);
struct ttf_startup_receipt ttf_sr = ttf_startup();
struct font_startup_receipt font_sr = font_startup(&work_sr, &renderer_sr, &asset_cache_sr, &ttf_sr, &resource_sr);
struct texture_startup_receipt texture_sr = texture_startup(&work_sr, &renderer_sr, &asset_cache_sr, &resource_sr);
struct sheet_startup_receipt sheet_sr = sheet_startup(&work_sr, &asset_cache_sr, &resource_sr);
struct texture_startup_receipt texture_sr = texture_startup(&renderer_sr, &resource_sr);
struct sheet_startup_receipt sheet_sr = sheet_startup(&resource_sr);
struct mixer_startup_receipt mixer_sr = mixer_startup();
struct sound_startup_receipt sound_sr = sound_startup(&work_sr, &asset_cache_sr, &resource_sr);
struct draw_startup_receipt draw_sr = draw_startup(&renderer_sr, &font_sr);

6
src/ase.c
View File

@ -240,7 +240,7 @@ INTERNAL u16 huffman_decode(struct huffman *huffman, struct bitbuf *bb)
return res;
}
INTERNAL void inflate(struct arena *arena, u8 *dest, u8 *encoded)
INTERNAL void inflate(u8 *dest, u8 *encoded)
{
__prof;
struct bitbuf bb = { encoded };
@ -273,7 +273,7 @@ INTERNAL void inflate(struct arena *arena, u8 *dest, u8 *encoded)
case BLOCK_TYPE_COMPRESSED_FIXED:
case BLOCK_TYPE_COMPRESSED_DYNAMIC: {
struct temp_arena scratch = scratch_begin(arena);
struct temp_arena scratch = scratch_begin_no_conflict();
u32 lit_len_dist_table[512] = { 0 };
u32 hlit;
u32 hdist;
@ -692,7 +692,7 @@ struct ase_decode_image_result ase_decode_image(struct arena *arena, struct buff
cel->height = br_read_u16(&br);
cel->pixels = arena_push_array(scratch.arena, u32, cel->width * cel->height);
inflate(scratch.arena, (u8 *)cel->pixels, br.at);
inflate((u8 *)cel->pixels, br.at);
br_seek_to(&br, chunk_end_pos);
} break;

30
src/common.h
View File

@ -8,12 +8,6 @@
extern "C" {
#endif
/* ========================== *
* Configurable constants
* ========================== */
#include "config.h"
/* ========================== *
* Compiler headers
* ========================== */
@ -368,6 +362,24 @@ struct buffer {
u8 *data;
};
struct renderer_handle {
u64 v[1];
};
/* ========================== *
* Tag structs
* ========================== */
struct texture_tag {
u128 hash;
struct string path;
};
struct sheet_tag {
u128 hash;
struct string path;
};
/* ========================== *
* Buffer utils
* ========================== */
@ -566,6 +578,12 @@ INLINE void __prof_zone_cleanup_func(TracyCZoneCtx *__tracy_ctx) { TracyCZoneEnd
#endif /* PROFILING */
/* ========================== *
* Configurable constants
* ========================== */
#include "config.h"
#ifdef __cplusplus
}
#endif

22
src/config.h
View File

@ -39,6 +39,28 @@
#define USER_INTERP_OFFSET_TICK_RATIO 1.1
#define USER_INTERP_ENABLED 1
/* ========================== *
* Cache limits
*
* (Size of caches before evicting starts)
* ========================== */
/* NOTE: Total memory budget should be half of envisioned hard cache memory
* budget. This is because eviction can happen in parallel, so theoretically
* cache entries can load and exist in memory at the same time the old evicted
* record is still around. */
#define TOTAL_CACHE_MEMORY_BUDGET (MEGABYTE(256))
#define TEXTURE_CACHE_MEMORY_BUDGET (MEGABYTE(128))
#define SHEET_CACHE_MEMORY_BUDGET (MEGABYTE(128))
/* Sum of cache budgets must = total cache memory budget */
CT_ASSERT(
(
SHEET_CACHE_MEMORY_BUDGET +
TEXTURE_CACHE_MEMORY_BUDGET
) == TOTAL_CACHE_MEMORY_BUDGET
);
/* ========================== *
* Settings

45
src/draw.c
View File

@ -3,9 +3,10 @@
#include "math.h"
#include "font.h"
#include "scratch.h"
#include "texture.h"
GLOBAL struct {
struct renderer_handle solid_white;
struct texture_tag solid_white;
} G = { 0 }, DEBUG_ALIAS(G, G_draw);
/* ========================== *
@ -17,20 +18,7 @@ struct draw_startup_receipt draw_startup(struct renderer_startup_receipt *render
{
(UNUSED)renderer_sr;
(UNUSED)font_sr;
/* Generate solid white texture */
{
struct temp_arena scratch = scratch_begin_no_conflict();
struct image_rgba image_data = {
.width = 1,
.height = 1,
.pixels = arena_push(scratch.arena, u32)
};
image_data.pixels[0] = COLOR_WHITE;
G.solid_white = renderer_texture_alloc(image_data);
scratch_end(scratch);
}
G.solid_white = texture_tag_from_path(STR("res/graphics/white.ase"));
return (struct draw_startup_receipt) { 0 };
}
@ -82,8 +70,7 @@ INTERNAL void draw_texture_quad_internal(struct renderer_canvas *canvas, struct
void draw_texture_quad(struct renderer_canvas *canvas, struct draw_texture_params params, struct quad quad)
{
ASSERT(params.texture);
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture = params.texture->renderer_handle });
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_tag = params.texture_tag });
draw_texture_quad_internal(canvas, params.clip, params.tint, quad);
}
@ -130,7 +117,7 @@ void draw_solid_poly(struct renderer_canvas *canvas, struct v2_array array, u32
return;
}
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture = G.solid_white });
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_tag = G.solid_white });
draw_solid_poly_internal(canvas, array, color);
}
@ -158,13 +145,13 @@ void draw_solid_circle(struct renderer_canvas *canvas, struct v2 pos, f32 radius
void draw_solid_quad(struct renderer_canvas *canvas, struct quad quad, u32 color)
{
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture = G.solid_white });
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_tag = G.solid_white });
draw_texture_quad_internal(canvas, CLIP_ALL, color, quad);
}
void draw_solid_rect(struct renderer_canvas *canvas, struct rect rect, u32 color)
{
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture = G.solid_white });
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_tag = G.solid_white });
struct quad quad = quad_from_rect(rect);
draw_texture_quad_internal(canvas, CLIP_ALL, color, quad);
}
@ -175,14 +162,14 @@ void draw_solid_rect(struct renderer_canvas *canvas, struct rect rect, u32 color
void draw_solid_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, u32 color)
{
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture = G.solid_white });
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_tag = G.solid_white });
struct quad quad = quad_from_line(start, end, thickness);
draw_texture_quad_internal(canvas, CLIP_ALL, color, quad);
}
void draw_solid_ray(struct renderer_canvas *canvas, struct v2 pos, struct v2 rel, f32 thickness, u32 color)
{
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture = G.solid_white });
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_tag = G.solid_white });
struct quad quad = quad_from_ray(pos, rel, thickness);
draw_texture_quad_internal(canvas, CLIP_ALL, color, quad);
}
@ -193,7 +180,7 @@ void draw_solid_poly_line(struct renderer_canvas *canvas, struct v2_array array,
return;
}
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture = G.solid_white });
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_tag = G.solid_white });
for (u64 i = 1; i < array.count; ++i) {
struct v2 p1 = array.points[i - 1];
struct v2 p2 = array.points[i];
@ -223,7 +210,7 @@ void draw_solid_rect_line(struct renderer_canvas *canvas, struct rect rect, f32
void draw_solid_arrow_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color)
{
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture = G.solid_white });
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_tag = G.solid_white });
const f32 head_width_ratio = 0.5f; /* Width of arrowhead relative to its length */
@ -270,7 +257,7 @@ void draw_text(struct renderer_canvas *canvas, struct font *font, struct v2 pos,
void draw_text_ex(struct renderer_canvas *canvas, struct font *font, struct v2 pos, f32 scale, struct string str)
{
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture = font->texture.renderer_handle });
renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_handle = font->image_renderer_handle });
struct v2 draw_pos = pos;
draw_pos.y += font->point_size * scale;
@ -294,13 +281,13 @@ void draw_text_ex(struct renderer_canvas *canvas, struct font *font, struct v2 p
struct clip_rect clip = {
{
glyph->atlas_rect.x / font->texture.size.x,
glyph->atlas_rect.y / font->texture.size.y
glyph->atlas_rect.x / font->image_size.x,
glyph->atlas_rect.y / font->image_size.y
},
{
(glyph->atlas_rect.x + glyph->atlas_rect.width) / font->texture.size.x,
(glyph->atlas_rect.y + glyph->atlas_rect.height) / font->texture.size.y
(glyph->atlas_rect.x + glyph->atlas_rect.width) / font->image_size.x,
(glyph->atlas_rect.y + glyph->atlas_rect.height) / font->image_size.y
}
};

3
src/draw.h
View File

@ -11,8 +11,9 @@ struct font_startup_receipt;
.clip = CLIP_ALL, \
__VA_ARGS__ \
})
struct draw_texture_params {
struct texture *texture;
struct texture_tag texture_tag;
struct clip_rect clip;
u32 tint;
};

4
src/entity.h
View File

@ -1,7 +1,7 @@
#ifndef ENTITY_H
#define ENTITY_H
#include "mixer.h"
#include "texture.h"
#include "sheet.h"
#include "mixer.h"
@ -66,7 +66,7 @@ struct entity {
/* ====================================================================== */
/* Sprite */
struct string sprite_name;
struct texture_tag sprite_texture_tag;
struct sheet_tag sprite_sheet_tag;
struct string sprite_span_name;
struct xform sprite_quad_xform;

8
src/font.c
View File

@ -121,7 +121,7 @@ INTERNAL WORK_TASK_FUNC_DEF(font_load_asset_task, vparams)
resource_close(res);
/* Send texture to GPU */
struct renderer_handle texture_renderer_handle = renderer_texture_alloc(result.image_data);
struct renderer_handle image_renderer_handle = renderer_texture_alloc(result.image_data);
/* Allocate store memory */
struct font *font = NULL;
@ -134,10 +134,8 @@ INTERNAL WORK_TASK_FUNC_DEF(font_load_asset_task, vparams)
}
/* Set font data */
font->texture = (struct texture) {
.renderer_handle = texture_renderer_handle,
.size = V2(result.image_data.width, result.image_data.height),
};
font->image_renderer_handle = image_renderer_handle;
font->image_size = V2(result.image_data.width, result.image_data.height);
font->glyphs_count = result.glyphs_count;
font->point_size = point_size;

3
src/font.h
View File

@ -21,8 +21,9 @@ struct font_glyph {
};
struct font {
struct renderer_handle image_renderer_handle;
struct v2 image_size;
f32 point_size;
struct texture texture;
u16 glyphs_count;
struct font_glyph *glyphs;
u16 *lookup;

66
src/game.c
View File

@ -152,6 +152,21 @@ INTERNAL void recalculate_world_xform_recurse(struct entity *parent)
scratch_end(scratch);
}
#if 0
INTERNAL struct v2 sheet_size_meters(struct sheet_tag s)
{
struct v2 size = { 0 };
struct sheet_scope *scope = sheet_scope_begin();
{
struct sheet *sheet = sheet_from_tag_await(scope, s);
size.x = sheet->frame_size.x / (f32)PIXELS_PER_UNIT;
size.y = sheet->frame_size.y / (f32)PIXELS_PER_UNIT;
}
sheet_scope_end(scope);
return size;
}
#endif
INTERNAL void game_update(void)
{
__prof;
@ -183,22 +198,13 @@ INTERNAL void game_update(void)
struct string sprite_name = STR("res/graphics/tim.ase");
struct string sprite_span_name = STR("UNARMED");
struct texture_tag sprite_texture_tag = texture_tag_from_path(sprite_name);
struct sheet_tag sprite_sheet_tag = sheet_tag_from_path(sprite_name);
f32 meters_width, meters_height;
{
struct sheet_scope *scope = sheet_scope_begin();
{
struct sheet *sheet = sheet_from_tag_await(scope, sprite_sheet_tag);
meters_width = sheet->frame_size.x / (f32)PIXELS_PER_UNIT;
meters_height = sheet->frame_size.y / (f32)PIXELS_PER_UNIT;
}
sheet_scope_end(scope);
}
struct v2 sprite_pos = V2(0, 0);
f32 sprite_rot = 0;
struct v2 sprite_size = V2(meters_width, meters_height);
struct v2 sprite_size = V2(0.5f, 0.5f);
// struct v2 sprite_size = sheet_size_meters(sprite_sheet_tag);
struct v2 sprite_pivot;
{
@ -213,7 +219,7 @@ INTERNAL void game_update(void)
sprite_xf = xform_scale(sprite_xf, sprite_size);
e->sprite_quad_xform = sprite_xf;
e->sprite_name = sprite_name;
e->sprite_texture_tag = sprite_texture_tag;
e->sprite_sheet_tag = sprite_sheet_tag;
e->sprite_span_name = sprite_span_name;
e->sprite_tint = COLOR_WHITE;
@ -244,22 +250,13 @@ INTERNAL void game_update(void)
struct string sprite_name = STR("res/graphics/tim.ase");
struct string sprite_span_name = STR("UNARMED");
struct texture_tag sprite_texture_tag = texture_tag_from_path(sprite_name);
struct sheet_tag sprite_sheet_tag = sheet_tag_from_path(sprite_name);
f32 meters_width, meters_height;
{
struct sheet_scope *scope = sheet_scope_begin();
{
struct sheet *sheet = sheet_from_tag_await(scope, sprite_sheet_tag);
meters_width = sheet->frame_size.x / (f32)PIXELS_PER_UNIT;
meters_height = sheet->frame_size.y / (f32)PIXELS_PER_UNIT;
}
sheet_scope_end(scope);
}
struct v2 sprite_pos = V2(0, 0);
f32 sprite_rot = 0;
struct v2 sprite_size = V2(meters_width, meters_height);
struct v2 sprite_size = V2(0.5f, 0.5f);
// struct v2 sprite_size = sheet_size_meters(sprite_sheet_tag);
struct v2 sprite_pivot;
{
@ -274,7 +271,7 @@ INTERNAL void game_update(void)
sprite_xf = xform_scale(sprite_xf, sprite_size);
e->sprite_quad_xform = sprite_xf;
e->sprite_name = sprite_name;
e->sprite_texture_tag = sprite_texture_tag;
e->sprite_sheet_tag = sprite_sheet_tag;
e->sprite_span_name = sprite_span_name;
e->sprite_tint = RGBA_F(0.5, 0.5, 0, 1);
@ -322,23 +319,14 @@ INTERNAL void game_update(void)
e->rel_xform = XFORM_POS(V2(-3, -3));
struct string sprite_name = STR("res/graphics/sound.ase");
struct texture_tag sprite_texture_tag = texture_tag_from_path(sprite_name);
struct sheet_tag sprite_sheet_tag = sheet_tag_from_path(sprite_name);
f32 meters_width, meters_height;
{
struct sheet_scope *scope = sheet_scope_begin();
{
struct sheet *sheet = sheet_from_tag_await(scope, sprite_sheet_tag);
meters_width = sheet->frame_size.x / (f32)PIXELS_PER_UNIT;
meters_height = sheet->frame_size.y / (f32)PIXELS_PER_UNIT;
}
sheet_scope_end(scope);
}
struct v2 sprite_size = V2(meters_width, meters_height);
struct v2 sprite_size = V2(0.25f, 0.25f);
// struct v2 sprite_size = sheet_size_meters(sprite_sheet_tag);
e->sprite_quad_xform = xform_with_scale(XFORM_IDENT, sprite_size);
e->sprite_name = sprite_name;
e->sprite_texture_tag = sprite_texture_tag;
e->sprite_sheet_tag = sprite_sheet_tag;
e->sprite_tint = RGBA_F(1, 1, 0, 1);

10
src/renderer.h
View File

@ -2,7 +2,6 @@
#define RENDERER_H
struct sys_window;
struct texture;
#define RENDERER_TEXTURE_MAX_WIDTH 16384
#define RENDERER_TEXTURE_MAX_HEIGHT 16384
@ -11,10 +10,6 @@ typedef u32 vidx;
struct renderer_canvas;
struct renderer_handle {
u64 v[1];
};
/* ========================== *
* Shaders
* ========================== */
@ -27,7 +22,8 @@ enum shader_kind {
};
struct texture_shader_parameters {
struct renderer_handle texture;
struct renderer_handle texture_handle; /* Overrides texture_tag */
struct texture_tag texture_tag;
};
struct texture_shader_vertex {
@ -80,7 +76,7 @@ void renderer_canvas_present(struct renderer_canvas **canvases, u32 canvases_cou
* ========================== */
struct renderer_handle renderer_texture_alloc(struct image_rgba data);
void renderer_texture_release(struct renderer_handle handle);
b32 renderer_texture_is_nil(struct renderer_handle handle);
#endif

37
src/renderer_d3d11.c
View File

@ -7,6 +7,7 @@
#include "math.h"
#include "inc.h"
#include "tar.h"
#include "texture.h"
#include <Windows.h>
#define CINTERFACE
@ -57,7 +58,9 @@ struct dx11_buffer {
struct renderer_cmd {
struct dx11_shader *shader;
struct renderer_handle texture;
struct renderer_handle texture_handle; /* Overrides texture_tag */
struct texture_tag texture_tag;
/* Associated buffer data */
u32 vertex_count;
@ -275,9 +278,15 @@ INTERNAL void *handle_data(struct renderer_handle handle)
INTERNAL b32 handle_eq(struct renderer_handle h1, struct renderer_handle h2)
{
CT_ASSERT(sizeof(struct renderer_handle) == 8);
return h1.v[0] == h2.v[0];
}
INTERNAL b32 handle_is_nil(struct renderer_handle h)
{
return h.v[0] == 0;
}
/* ========================== *
* Shader
* ========================== */
@ -693,12 +702,15 @@ u32 renderer_canvas_push_vertices(struct renderer_canvas *canvas, u8 **vertices_
void renderer_canvas_ensure_texture_cmd(struct renderer_canvas *canvas, struct texture_shader_parameters params)
{
struct renderer_cmd *last_cmd = canvas->cpu_cmd_store.cmd_last;
if (!last_cmd || last_cmd->shader->kind != SHADER_TEXTURE || !handle_eq(last_cmd->texture, params.texture)) {
if (!last_cmd || last_cmd->shader->kind != SHADER_TEXTURE ||
!handle_eq(last_cmd->texture_handle, params.texture_handle) ||
!texture_tag_eq(last_cmd->texture_tag, params.texture_tag)) {
/* Command parameters are not the same, insert new command */
struct renderer_cmd *cmd = arena_push(&canvas->cpu_cmd_store.arena, struct renderer_cmd);
*cmd = (struct renderer_cmd){
.shader = &G.shaders[SHADER_TEXTURE],
.texture = params.texture
.texture_handle = params.texture_handle,
.texture_tag = params.texture_tag
};
if (!canvas->cpu_cmd_store.cmd_first) {
@ -829,6 +841,8 @@ void renderer_canvas_present(struct renderer_canvas **canvases, u32 canvases_cou
{
__prof;
struct texture_scope *texture_scope = texture_scope_begin();
/* Resize back buffer */
if (!v2_eq(G.backbuffer_size, screen_size)) {
resize_backbuffer(screen_size);
@ -864,7 +878,13 @@ void renderer_canvas_present(struct renderer_canvas **canvases, u32 canvases_cou
for (struct renderer_cmd *cmd = canvas->gpu_cmd_store.cmd_first; cmd; cmd = cmd->next) {
struct dx11_shader *shader = cmd->shader;
struct dx11_buffer *buffer = &canvas->buffers[shader->kind];
struct renderer_handle texture_handle = cmd->texture;
struct renderer_handle texture_handle;
if (handle_is_nil(cmd->texture_handle)) {
texture_handle = texture_from_tag_async(texture_scope, cmd->texture_tag)->renderer_handle;
} else {
texture_handle = cmd->texture_handle;
}
/* Activate shader */
if (shader != last_shader) {
@ -904,6 +924,8 @@ void renderer_canvas_present(struct renderer_canvas **canvases, u32 canvases_cou
__profframe(0);
}
renderer_capture_image_for_profiler(viewport.width, viewport.height);
texture_scope_end(texture_scope);
}
/* ========================== *
@ -964,6 +986,11 @@ void renderer_texture_release(struct renderer_handle handle)
handle_release(handle);
}
b32 renderer_texture_is_nil(struct renderer_handle handle)
{
return handle_is_nil(handle);
}
/* ========================== *
* Profiling frame capture
* ========================== */
@ -1054,9 +1081,11 @@ INTERNAL void renderer_capture_image_for_profiler(f32 width, f32 height)
}
}
#else
INTERNAL void renderer_capture_image_for_profiler(f32 width, f32 height)
{
(UNUSED)width;
(UNUSED)height;
}
#endif

3
src/resource.c
View File

@ -19,7 +19,6 @@ struct resource_startup_receipt resource_startup(void)
{
#if RESOURCES_EMBEDDED
struct buffer embedded_data = inc_res_tar();
//struct buffer embedded_data = ((struct buffer) { (u8 *)(_incbin_res_tar_end) - (u8 *)(_incbin_res_tar_start), (u8 *)_incbin_res_tar_start });;
G.arena = arena_alloc(GIGABYTE(64));
if (embedded_data.size <= 0) {
sys_panic(STR("No embedded resources found"));
@ -55,7 +54,7 @@ struct resource resource_open(struct string path)
.bytes = entry ? entry->buff : BUFFER(0, 0)
};
#else
struct sys_file file = sys_file_open_read(path);
struct sys_file file = sys_file_open_read_wait(path);
struct sys_file_map file_map = sys_file_map_open_read(file);
struct buffer bytes = sys_file_map_data(file_map);
return (struct resource) {

112
src/sheet.c
View File

@ -4,14 +4,12 @@
#include "sys.h"
#include "scratch.h"
#include "resource.h"
#include "asset_cache.h"
#include "ase.h"
#include "util.h"
#include "work.h"
#include "atomic.h"
#include "thread_local.h"
#include "app.h"
#include "intrinsics.h"
#define SHEET_ARENA_RESERVE MEGABYTE(64)
#define SHEET_LOOKUP_TABLE_BUCKET_RATIO 2.0
@ -21,13 +19,10 @@
#define MAX_LOADER_THREADS 4
/* Size of cache memory until evictor starts evicting */
#define CACHE_MEMORY_BUDGET MEGABYTE(8)
/* How long between evictor thread scans */
#define EVICTOR_CYCLE_INTERVAL 0.500
#define EVICTOR_CYCLE_INTERVAL (RESOURCE_RELOADING ? 0.100 : 0.500)
/* Time a cache entry spends unused until it's considered evictable (at granularity of EVICTOR_CYCLE_INTERVAL) */
/* Time a cache entry spends unused until it's considered evictable (rounded up to multiple of of EVICTOR_CYCLE_INTERVAL) */
#define EVICTOR_GRACE_PERIOD 10.000
/* ========================== *
@ -168,12 +163,8 @@ INTERNAL APP_EXIT_CALLBACK_FUNC_DEF(sheet_shutdown);
INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sheet_loader_thread_entry_point, arg);
INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sheet_evictor_thread_entry_point, arg);
struct sheet_startup_receipt sheet_startup(struct work_startup_receipt *work_sr,
struct asset_cache_startup_receipt *asset_cache_sr,
struct resource_startup_receipt *resource_sr)
struct sheet_startup_receipt sheet_startup(struct resource_startup_receipt *resource_sr)
{
(UNUSED)work_sr;
(UNUSED)asset_cache_sr;
(UNUSED)resource_sr;
G.cache.node_pool_mutex = sys_mutex_alloc();
@ -201,7 +192,7 @@ struct sheet_startup_receipt sheet_startup(struct work_startup_receipt *work_sr,
}
scratch_end(scratch);
}
G.evictor_thread = sys_thread_alloc(sheet_evictor_thread_entry_point, NULL, STR("[P0] Sheet evictor thread"));
G.evictor_thread = sys_thread_alloc(sheet_evictor_thread_entry_point, NULL, STR("[P0] Sheet evictor"));
app_register_exit_callback(&sheet_shutdown);
@ -249,6 +240,28 @@ struct sheet_tag sheet_tag_from_path(struct string path)
return res;
}
/* ========================== *
* Refcount
* ========================== */
INTERNAL void node_refcount_add(struct cache_node *n, i32 amount)
{
u32 evictor_cycle = atomic_u32_eval(&G.evictor_cycle);
struct atomic_u64 *refcount_atomic = &n->refcount_struct;
u64 old_refcount_uncast = atomic_u64_eval(refcount_atomic);
do {
struct cache_node_refcount new_refcount = *(struct cache_node_refcount *)&old_refcount_uncast;
new_refcount.count += amount;
new_refcount.last_modified_cycle = evictor_cycle;
u64 v = atomic_u64_eval_compare_exchange(refcount_atomic, old_refcount_uncast, *(u64 *)&new_refcount);
if (v != old_refcount_uncast) {
old_refcount_uncast = v;
} else {
break;
}
} while (true);
}
/* ========================== *
* Load
* ========================== */
@ -315,9 +328,6 @@ INTERNAL void sheet_load(struct cache_node *n, struct sheet_tag tag)
decoded = ase_decode_sheet(scratch.arena, sheet_rs.bytes);
#if RESOURCE_RELOADING
n->initial_resource_file_modified_time = sys_file_get_time(sheet_rs.file).modified;
u64 cpy_len = min_u64(tag.path.len, ARRAY_COUNT(n->tag_path));
n->tag_path_len = cpy_len;
MEMCPY(n->tag_path, tag.path.text, cpy_len);
#endif
resource_close(sheet_rs);
@ -329,14 +339,20 @@ INTERNAL void sheet_load(struct cache_node *n, struct sheet_tag tag)
logf_error("Resource \"%F\" not found", path);
}
}
#if RESOURCE_RELOADING
u64 cpy_len = min_u64(tag.path.len, ARRAY_COUNT(n->tag_path));
n->tag_path_len = cpy_len;
MEMCPY(n->tag_path, tag.path.text, cpy_len);
#endif
arena_set_readonly(&n->arena);
n->memory_usage = n->arena.committed;
atomic_u64_eval_add(&G.cache.memory_usage, n->memory_usage);
logf_info("Finished loading sheet \"%F\" in %F seconds (final size: %F bytes).",
logf_info("Finished loading sheet \"%F\" in %F seconds (cache size: %F bytes).",
FMT_STR(path),
FMT_FLOAT(sys_timestamp_seconds(sys_timestamp() - start_ts)),
FMT_UINT(n->arena.pos));
FMT_UINT(n->memory_usage));
atomic_u32_eval_exchange(&n->state, CACHE_NODE_STATE_LOADED);
@ -364,19 +380,7 @@ INTERNAL void scope_ensure_reference(struct sheet_scope *scope, struct cache_nod
if (!ref) {
/* Increment refcount */
u32 evictor_cycle = atomic_u32_eval(&G.evictor_cycle);
u64 old_refcount_uncast = atomic_u64_eval(&cache_node->refcount_struct);
do {
struct cache_node_refcount new_refcount = *(struct cache_node_refcount *)&old_refcount_uncast;
new_refcount.count += 1;
new_refcount.last_modified_cycle = evictor_cycle;
u64 v = atomic_u64_eval_compare_exchange(&cache_node->refcount_struct, old_refcount_uncast, *(u64 *)&new_refcount);
if (v != old_refcount_uncast) {
old_refcount_uncast = v;
} else {
break;
}
} while (true);
node_refcount_add(cache_node, 1);
/* Add reference to scope */
struct sheet_tctx *tctx = thread_local_var_eval(&tl_sheet_tctx);
if (tctx->first_free_reference) {
@ -418,20 +422,7 @@ void sheet_scope_end(struct sheet_scope *scope)
struct sheet_scope_reference *ref = scope->reference_buckets[i];
while (ref) {
/* Decrement refcount */
struct cache_node *cache_node = ref->cache_node;
u32 evictor_cycle = atomic_u32_eval(&G.evictor_cycle);
u64 old_refcount_uncast = atomic_u64_eval(&cache_node->refcount_struct);
do {
struct cache_node_refcount new_refcount = *(struct cache_node_refcount *)&old_refcount_uncast;
new_refcount.count -= 1;
new_refcount.last_modified_cycle = evictor_cycle;
u64 v = atomic_u64_eval_compare_exchange(&cache_node->refcount_struct, old_refcount_uncast, *(u64 *)&new_refcount);
if (v != old_refcount_uncast) {
old_refcount_uncast = v;
} else {
break;
}
} while (true);
node_refcount_add(ref->cache_node, -1);
/* Add reference to free list */
ref->next_free = tctx->first_free_reference;
tctx->first_free_reference = ref;
@ -530,8 +521,9 @@ INTERNAL struct sheet *sheet_from_tag_internal(struct sheet_scope *scope, struct
if (G.first_free_loader_cmd) {
cmd = G.first_free_loader_cmd;
G.first_free_loader_cmd = cmd->next_free;
MEMZERO_STRUCT(cmd);
} else {
cmd = arena_push(&G.loader_cmd_arena, struct loader_cmd);
cmd = arena_push_zero(&G.loader_cmd_arena, struct loader_cmd);
}
/* Initialize cmd */
@ -547,6 +539,9 @@ INTERNAL struct sheet *sheet_from_tag_internal(struct sheet_scope *scope, struct
*(G.last_loader_cmd ? &G.last_loader_cmd->next : &G.first_loader_cmd) = cmd;
G.last_loader_cmd = cmd;
/* Cmd holds reference to node */
node_refcount_add(n, 1);
/* Signal work ready */
sys_condition_variable_signal(&G.loaders_cv);
}
@ -641,6 +636,9 @@ INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sheet_loader_thread_entry_point, arg)
/* Free cmd */
cmd->next_free = G.first_free_loader_cmd;
G.first_free_loader_cmd = cmd;
/* Cmd no longer references node */
node_refcount_add(cmd->cache_node, -1);
}
sys_mutex_unlock(&G.loaders_mutex);
@ -684,11 +682,10 @@ INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sheet_evictor_thread_entry_point, arg)
}
if (!G.evictor_shutdown) {
sys_timestamp_t cur_timestamp = sys_timestamp();
f64 cur_time = sys_timestamp_seconds(cur_timestamp);
u32 cur_cycle = *atomic_u32_raw(&G.evictor_cycle);
/* Scan for evictable nodes */
b32 cache_over_budget = atomic_u64_eval(&G.cache.memory_usage) > CACHE_MEMORY_BUDGET;
b32 cache_over_budget = atomic_u64_eval(&G.cache.memory_usage) > SHEET_CACHE_MEMORY_BUDGET;
if (cache_over_budget || RESOURCE_RELOADING) {
__profscope(eviction_scan);
for (u64 i = 0; i < CACHE_BUCKETS_COUNT; ++i) {
@ -699,7 +696,6 @@ INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sheet_evictor_thread_entry_point, arg)
while (n) {
b32 consider_for_eviction = false;
b32 force_evict = false;
if (atomic_u32_eval(&n->state) == CACHE_NODE_STATE_LOADED) {
u64 refcount_uncast = atomic_u64_eval(&n->refcount_struct);
struct cache_node_refcount refcount = *(struct cache_node_refcount *)&refcount_uncast;
if (refcount.count <= 0) {
@ -708,9 +704,6 @@ INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sheet_evictor_thread_entry_point, arg)
if (!consider_for_eviction) {
struct string path = string_from_cstr_len((char *)n->tag_path, n->tag_path_len);
b32 file_changed = false;
if (!sys_is_file(path)) {
file_changed = true;
} else {
struct sys_datetime current_file_time;
{
struct sys_file file = sys_file_open_read(path);
@ -718,7 +711,6 @@ INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sheet_evictor_thread_entry_point, arg)
sys_file_close(file);
}
file_changed = MEMCMP_STRUCT(&n->initial_resource_file_modified_time, &current_file_time) != 0;
}
if (file_changed) {
logf_info("Resource file for sheet \"%F\" has changed. Evicting to allow for reloading.", FMT_STR(path));
consider_for_eviction = true;
@ -729,11 +721,14 @@ INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sheet_evictor_thread_entry_point, arg)
/* Check usage time */
#if RESOURCE_RELOADING
if (cache_over_budget) /* Only check conditional if RESOURCE_RELOADING, since over-budget is assumed to be true otherwise */
/* Only check conditional if * RESOURCE_RELOADING is enabled,
* since over-budget is assumed to be * true otherwise */
if (cache_over_budget)
#endif
{
f64 last_used_time = (f64)refcount.last_modified_cycle * EVICTOR_CYCLE_INTERVAL;
if (cur_time - last_used_time > EVICTOR_GRACE_PERIOD) {
u32 last_used_cycle = refcount.last_modified_cycle;
f64 time_since_use = (f64)(cur_cycle - last_used_cycle) * EVICTOR_CYCLE_INTERVAL;
if (time_since_use > EVICTOR_GRACE_PERIOD) {
/* Cache is over budget and node hasn't been referenced in a while */
consider_for_eviction = true;
}
@ -754,7 +749,6 @@ INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sheet_evictor_thread_entry_point, arg)
n = n->next_hash;
}
}
sys_rw_mutex_unlock_shared(&bucket->rw_mutex);
}
}
@ -793,7 +787,7 @@ INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sheet_evictor_thread_entry_point, arg)
struct cache_node_refcount refcount = *(struct cache_node_refcount *)atomic_u64_raw(&n->refcount_struct);
if (refcount.count > 0 || ((refcount.last_modified_cycle != en->refcount.last_modified_cycle) && !en->force_evict)) {
/* Cache node has been referenced since scan, skip eviction. */
} else if (en->force_evict || atomic_u64_eval(&G.cache.memory_usage) > CACHE_MEMORY_BUDGET) {
} else if (en->force_evict || atomic_u64_eval(&G.cache.memory_usage) > SHEET_CACHE_MEMORY_BUDGET) {
/* Remove from cache bucket */
if (n->prev_hash) {
n->prev_hash->next_hash = n->next_hash;

12
src/sheet.h
View File

@ -3,17 +3,9 @@
#include "util.h"
struct asset;
struct sheet_frame;
struct work_startup_receipt;
struct asset_cache_startup_receipt;
struct resource_startup_receipt;
struct sheet_tag {
u128 hash;
struct string path;
};
struct sheet {
b32 loading;
struct v2 image_size;
@ -29,9 +21,7 @@ struct sheet {
* ========================== */
struct sheet_startup_receipt { i32 _; };
struct sheet_startup_receipt sheet_startup(struct work_startup_receipt *work_sr,
struct asset_cache_startup_receipt *asset_cache_srm,
struct resource_startup_receipt *resource_sr);
struct sheet_startup_receipt sheet_startup(struct resource_startup_receipt *resource_sr);
/* ========================== *
* Tag

1
src/sys.h
View File

@ -215,6 +215,7 @@ b32 sys_is_dir(struct string path);
void sys_mkdir(struct string path);
struct sys_file sys_file_open_read(struct string path);
struct sys_file sys_file_open_read_wait(struct string path); /* Waits until file is not being used by another program */
struct sys_file sys_file_open_write(struct string path);
struct sys_file sys_file_open_append(struct string path);
void sys_file_close(struct sys_file file);

47
src/sys_win32.c
View File

@ -363,9 +363,8 @@ struct sys_file sys_file_open_read(struct string path)
{
__prof;
struct temp_arena scratch = scratch_begin_no_conflict();
wchar_t *path_wstr = wstr_from_string(scratch.arena, path);
/* TODO: Handle errors / non-existing file (handle == INVALID_HANDLE_VALUE) */
wchar_t *path_wstr = wstr_from_string(scratch.arena, path);
HANDLE handle = CreateFileW(
path_wstr,
GENERIC_READ,
@ -375,16 +374,43 @@ struct sys_file sys_file_open_read(struct string path)
FILE_ATTRIBUTE_NORMAL,
NULL
);
scratch_end(scratch);
struct sys_file file = (struct sys_file) { (u64)handle };
return file;
}
struct sys_file sys_file_open_read_wait(struct string path)
{
__prof;
struct temp_arena scratch = scratch_begin_no_conflict();
wchar_t *path_wstr = wstr_from_string(scratch.arena, path);
i32 delay_ms = 1;
HANDLE handle;
while ((handle = CreateFileW(path_wstr, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE) {
if (GetLastError() == ERROR_SHARING_VIOLATION) {
__profscope(file_share_conflict_delay);
Sleep(delay_ms);
if (delay_ms < 1024) {
delay_ms *= 2;
}
} else {
break;
}
}
scratch_end(scratch);
return (struct sys_file) { (u64)handle };
}
struct sys_file sys_file_open_write(struct string path)
{
__prof;
struct temp_arena scratch = scratch_begin_no_conflict();
wchar_t *path_wstr = wstr_from_string(scratch.arena, path);
/* TODO: Handle errors / non-existing file (handle == INVALID_HANDLE_VALUE) */
HANDLE handle = CreateFileW(
path_wstr,
GENERIC_WRITE,
@ -394,10 +420,9 @@ struct sys_file sys_file_open_write(struct string path)
FILE_ATTRIBUTE_NORMAL,
NULL
);
/* TODO: Handle errors / non-existing file (handle == INVALID_HANDLE_VALUE) */
scratch_end(scratch);
struct sys_file file = (struct sys_file) { (u64)handle };
return file;
return (struct sys_file) { (u64)handle };
}
struct sys_file sys_file_open_append(struct string path)
@ -405,6 +430,7 @@ struct sys_file sys_file_open_append(struct string path)
__prof;
struct temp_arena scratch = scratch_begin_no_conflict();
wchar_t *path_wstr = wstr_from_string(scratch.arena, path);
/* TODO: Handle errors / non-existing file (handle == INVALID_HANDLE_VALUE) */
HANDLE handle = CreateFileW(
path_wstr,
FILE_APPEND_DATA,
@ -414,7 +440,6 @@ struct sys_file sys_file_open_append(struct string path)
FILE_ATTRIBUTE_NORMAL,
NULL
);
/* TODO: Handle errors / non-existing file (handle == INVALID_HANDLE_VALUE) */
scratch_end(scratch);
struct sys_file file = (struct sys_file) { (u64)handle };
return file;
@ -450,6 +475,7 @@ struct buffer sys_file_read_all(struct arena *arena, struct sys_file file)
NULL
);
}
return buff;
}
@ -491,8 +517,8 @@ struct sys_file_time sys_file_get_time(struct sys_file file)
FILETIME ft_created;
FILETIME ft_accessed;
FILETIME ft_modified;
GetFileTime((HANDLE)file.handle, &ft_created, &ft_accessed, &ft_modified);
b32 success = !!GetFileTime((HANDLE)file.handle, &ft_created, &ft_accessed, &ft_modified);
if (success) {
/* Convert file times to local file time */
FileTimeToLocalFileTime(&ft_created, &ft_created);
FileTimeToLocalFileTime(&ft_accessed, &ft_accessed);
@ -511,6 +537,9 @@ struct sys_file_time sys_file_get_time(struct sys_file file)
.accessed = win32_time_to_sys_time(st_accessed),
.modified = win32_time_to_sys_time(st_modified)
};
} else {
return (struct sys_file_time) { 0 };
}
}
/* ========================== *
@ -536,7 +565,6 @@ struct sys_file_map sys_file_map_open_read(struct sys_file file)
);
if (!map_handle) {
ASSERT(false);
return (struct sys_file_map) { 0 };
}
@ -1839,6 +1867,7 @@ u32 sys_rand_u32(void)
void sys_panic(struct string msg)
{
ASSERT(false);
if (atomic_i32_eval_compare_exchange(&G.panicking, 0, 1) == 0) {
log_panic(msg);

939
src/texture.c
View File

File diff suppressed because it is too large Load Diff

57
src/texture.h
View File

@ -1,42 +1,51 @@
#ifndef TEXTURE_H
#define TEXTURE_H
#include "renderer.h"
#include "util.h"
struct asset;
struct work_startup_receipt;
struct renderer_startup_receipt;
struct asset_cache_startup_receipt;
struct resource_startup_receipt;
struct texture_frame {
struct clip_rect clip;
u32 duration_ms;
};
struct texture_slice {
struct clip_rect clip;
};
struct texture_anim {
u32 frame_start;
u32 frame_end;
};
struct texture {
b32 loading;
b32 valid;
struct renderer_handle renderer_handle;
struct v2 size;
};
/* ========================== *
* Startup
* ========================== */
struct texture_startup_receipt { i32 _; };
struct texture_startup_receipt texture_startup(struct work_startup_receipt *work_sr,
struct renderer_startup_receipt *renderer_sr,
struct asset_cache_startup_receipt *asset_cache_sr,
struct texture_startup_receipt texture_startup(struct renderer_startup_receipt *renderer_sr,
struct resource_startup_receipt *resource_sr);
struct asset *texture_load_asset(struct string path, b32 wait);
struct texture *texture_load_async(struct string path);
struct texture *texture_load(struct string path);
/* ========================== *
* Tag
* ========================== */
struct texture_tag texture_tag_from_path(struct string path);
b32 texture_tag_is_nil(struct texture_tag tag);
b32 texture_tag_eq(struct texture_tag t1, struct texture_tag t2);
/* ========================== *
* Scope
* ========================== */
struct texture_scope {
struct texture_scope_reference **reference_buckets;
struct texture_scope *next_free;
};
struct texture_scope *texture_scope_begin(void);
void texture_scope_end(struct texture_scope *scope);
/* ========================== *
* Load
* ========================== */
struct texture *texture_from_tag_await(struct texture_scope *scope, struct texture_tag tag);
struct texture *texture_from_tag_async(struct texture_scope *scope, struct texture_tag tag);
#endif

42
src/user.c
View File

@ -400,6 +400,8 @@ INTERNAL void user_update(void)
* Begin frame cache scopes
* ========================== */
/* TODO: Remove texture scope once renderer is rewritten to work with tags */
struct texture_scope *texture_frame_scope = texture_scope_begin();
struct sheet_scope *sheet_frame_scope = sheet_scope_begin();
/* ========================== *
@ -757,23 +759,23 @@ INTERNAL void user_update(void)
b32 skip_debug_draw_transform = ent == active_camera;
/* Draw sprite */
if (ent->sprite_name.len > 0) {
struct string tex_name = ent->sprite_name;
if (!texture_tag_is_nil(ent->sprite_texture_tag)) {
/* Draw texture */
struct texture *texture = texture_load_async(tex_name);
if (texture) {
struct texture_tag texture_tag = ent->sprite_texture_tag;
/* TODO: Remove this once renderer is rewritten to work with tags */
struct texture *texture = texture_from_tag_async(texture_frame_scope, texture_tag);
struct xform xf = xform_mul(ent->world_xform, ent->sprite_quad_xform);
struct quad quad = quad_mul_xform(QUAD_UNIT_SQUARE_CENTERED, xf);
u32 tint = ent->sprite_tint;
struct draw_texture_params params = DRAW_TEXTURE_PARAMS(.texture = texture, .tint = tint);
struct sheet *sheet = sheet_from_tag_async(sheet_frame_scope, ent->sprite_sheet_tag);
struct sheet_frame frame = { 0 };
{
struct sheet_span span = sheet_get_span(sheet, ent->sprite_span_name);
u64 frame_index = span.start + ent->animation_frame;
struct sheet_frame frame = sheet_get_frame(sheet, frame_index);
frame = sheet_get_frame(sheet, frame_index);
if (entity_has_prop(ent, ENTITY_PROP_ANIMATING)) {
f64 time_in_frame = ent->animation_time_in_frame;
while (time_in_frame > frame.duration) {
@ -786,12 +788,12 @@ INTERNAL void user_update(void)
frame = sheet_get_frame(sheet, frame_index);
}
}
params.clip = frame.clip;
}
struct draw_texture_params params = DRAW_TEXTURE_PARAMS(.texture_tag = texture_tag, .tint = tint, .clip = frame.clip);
/* TODO: Check for texture loading as well */
if (!sheet->loading) {
if (!sheet->loading && !texture->loading) {
/* TODO: Fade in a placeholder or something instead of drawing nothing. */
draw_texture_quad(G.world_canvas, params, quad);
}
@ -818,7 +820,6 @@ INTERNAL void user_update(void)
}
#endif
}
}
/* Debug draw info */
if (G.debug_draw && !skip_debug_draw) {
@ -911,14 +912,13 @@ INTERNAL void user_update(void)
struct v2 crosshair_pos = G.viewport_cursor;
u32 tint = RGBA_F(1, 1, 1, 1);
struct v2 size = V2(0, 0);
struct texture *t = texture_load_async(STR("res/graphics/crosshair.ase"));
if (t) {
size = t->size;
struct texture_tag crosshair_tag = texture_tag_from_path(STR("res/graphics/crosshair.ase"));
struct texture *t = texture_from_tag_async(texture_frame_scope, crosshair_tag);
struct v2 size = t->size;
struct xform xf = XFORM_TRS(.t = crosshair_pos, .s = size);
struct quad quad = quad_mul_xform(QUAD_UNIT_SQUARE_CENTERED, xf);
draw_texture_quad(G.viewport_canvas, DRAW_TEXTURE_PARAMS(.texture = t, .tint = tint), quad);
}
draw_texture_quad(G.viewport_canvas, DRAW_TEXTURE_PARAMS(.texture_tag = crosshair_tag, .tint = tint), quad);
struct rect cursor_clip = RECT_FROM_V2(G.viewport_screen_offset, G.viewport_size);
cursor_clip.pos = v2_add(cursor_clip.pos, v2_mul(size, 0.5f));
@ -989,11 +989,12 @@ INTERNAL void user_update(void)
/* Debug draw info */
if (G.debug_draw) {
struct temp_arena temp = arena_temp_begin(scratch.arena);
f32 spacing = 20;
struct v2 pos = V2(10, 8);
struct font *font = font_load(STR("res/fonts/fixedsys.ttf"), 12.0f);
struct font *font = font_load_async(STR("res/fonts/fixedsys.ttf"), 12.0f);
if (font) {
struct temp_arena temp = arena_temp_begin(scratch.arena);
draw_text(G.viewport_canvas, font, pos, string_format(temp.arena, STR("time: %F"), FMT_FLOAT((f64)G.time)));
pos.y += spacing;
@ -1034,6 +1035,8 @@ INTERNAL void user_update(void)
arena_temp_end(temp);
}
}
/* Push game cmds */
pubilsh_game_cmds(&cmd_list);
@ -1080,6 +1083,7 @@ INTERNAL void user_update(void)
* ========================== */
sheet_scope_end(sheet_frame_scope);
texture_scope_end(texture_frame_scope);
scratch_end(scratch);
}