From f1f98ffafb1fc4e0928bd4b7b6d9926f9f79b2ca Mon Sep 17 00:00:00 2001 From: Ed_ Date: Mon, 6 Jan 2025 11:23:30 -0500 Subject: [PATCH] Removed usage of procedure using statements from vefontcache --- code/font/vefontcache/LRU.odin | 100 ++++++++++++------------- code/font/vefontcache/draw.odin | 41 ++++------ code/font/vefontcache/shaper.odin | 16 ++-- code/font/vefontcache/vefontcache.odin | 87 ++++++++++----------- 4 files changed, 110 insertions(+), 134 deletions(-) diff --git a/code/font/vefontcache/LRU.odin b/code/font/vefontcache/LRU.odin index 3659719..24e907d 100644 --- a/code/font/vefontcache/LRU.odin +++ b/code/font/vefontcache/LRU.odin @@ -39,18 +39,17 @@ pool_list_init :: proc( pool : ^Pool_List, capacity : i32, dbg_name : string = " pool.capacity = capacity pool.dbg_name = dbg_name - using pool - for id in 0 ..< capacity { - free_list[id] = i32(id) - items[id] = { + for id in 0 ..< pool.capacity { + pool.free_list[id] = i32(id) + pool.items[id] = { prev = -1, next = -1, } } - front = -1 - back = -1 + pool.front = -1 + pool.back = -1 } pool_list_free :: proc( pool : ^Pool_List ) { @@ -65,96 +64,91 @@ pool_list_reload :: proc( pool : ^Pool_List, allocator : Allocator ) { pool_list_clear :: proc( pool: ^Pool_List ) { - using pool - clear(& items) - clear(& free_list) + clear(& pool.items) + clear(& pool.free_list) resize( & pool.items, cap(pool.items) ) resize( & pool.free_list, cap(pool.free_list) ) - for id in 0 ..< capacity { - free_list[id] = i32(id) - items[id] = { + for id in 0 ..< pool.capacity { + pool.free_list[id] = i32(id) + pool.items[id] = { prev = -1, next = -1, } } - front = -1 - back = -1 - size = 0 + pool.front = -1 + pool.back = -1 + pool.size = 0 } pool_list_push_front :: proc( pool : ^Pool_List, value : Pool_ListValue ) { - using pool - if size >= capacity do return + if pool.size >= pool.capacity do return - length := len(free_list) + length := len(pool.free_list) assert( length > 0 ) - assert( length == int(capacity - size) ) + assert( length == int(pool.capacity - pool.size) ) - id := free_list[ len(free_list) - 1 ] + id := pool.free_list[ len(pool.free_list) - 1 ] if pool.dbg_name != "" { logf("pool_list: back %v", id) } - pop( & free_list ) - items[ id ].prev = -1 - items[ id ].next = front - items[ id ].value = value + pop( & pool.free_list ) + pool.items[ id ].prev = -1 + pool.items[ id ].next = pool.front + pool.items[ id ].value = value if pool.dbg_name != "" { logf("pool_list: pushed %v into id %v", value, id) } - if front != -1 do items[ front ].prev = id - if back == -1 do back = id - front = id - size += 1 + if pool.front != -1 do pool.items[ pool.front ].prev = id + if pool.back == -1 do pool.back = id + pool.front = id + pool.size += 1 } pool_list_erase :: proc( pool : ^Pool_List, iter : Pool_ListIter ) { - using pool - if size <= 0 do return - assert( iter >= 0 && iter < i32(capacity) ) - assert( len(free_list) == int(capacity - size) ) + if pool.size <= 0 do return + assert( iter >= 0 && iter < i32(pool.capacity) ) + assert( len(pool.free_list) == int(pool.capacity - pool.size) ) - iter_node := & items[ iter ] + iter_node := & pool.items[ iter ] prev := iter_node.prev next := iter_node.next - if iter_node.prev != -1 do items[ prev ].next = iter_node.next - if iter_node.next != -1 do items[ next ].prev = iter_node.prev + if iter_node.prev != -1 do pool.items[ prev ].next = iter_node.next + if iter_node.next != -1 do pool.items[ next ].prev = iter_node.prev - if front == iter do front = iter_node.next - if back == iter do back = iter_node.prev + if pool.front == iter do pool.front = iter_node.next + if pool.back == iter do pool.back = iter_node.prev iter_node.prev = -1 iter_node.next = -1 iter_node.value = 0 - append( & free_list, iter ) + append( & pool.free_list, iter ) - size -= 1 - if size == 0 { - back = -1 - front = -1 + pool.size -= 1 + if pool.size == 0 { + pool.back = -1 + pool.front = -1 } } pool_list_move_to_front :: proc "contextless" ( pool : ^Pool_List, iter : Pool_ListIter ) { - using pool + if pool.front == iter do return - if front == iter do return + item := & pool.items[iter] + if item.prev != -1 do pool.items[ item.prev ].next = item.next + if item.next != -1 do pool.items[ item.next ].prev = item.prev + if pool.back == iter do pool.back = item.prev - item := & items[iter] - if item.prev != -1 do items[ item.prev ].next = item.next - if item.next != -1 do items[ item.next ].prev = item.prev - if back == iter do back = item.prev - - item.prev = -1 - item.next = front - items[ front ].prev = iter - front = iter + item.prev = -1 + item.next = pool.front + pool.items[ pool.front ].prev = iter + pool.front = iter } pool_list_peek_back :: #force_inline proc ( pool : Pool_List ) -> Pool_ListValue #no_bounds_check { diff --git a/code/font/vefontcache/draw.odin b/code/font/vefontcache/draw.odin index 8f612fc..ac76139 100644 --- a/code/font/vefontcache/draw.odin +++ b/code/font/vefontcache/draw.odin @@ -615,19 +615,14 @@ batch_generate_glyphs_draw_list :: proc ( draw_list : ^Draw_List, to_glyph_buffer_space( & dst_region_pos, & dst_region_size, atlas_size ) clear_target_region : Draw_Call - { - using clear_target_region - pass = .Atlas - region = .Ignore - start_index = cast(u32) len(glyph_buffer.clear_draw_list.indices) - - blit_quad( & glyph_buffer.clear_draw_list, - dst_region_pos, dst_region_pos + dst_region_size, - { 1.0, 1.0 }, { 1.0, 1.0 } - ) - - end_index = cast(u32) len(glyph_buffer.clear_draw_list.indices) - } + clear_target_region.pass = .Atlas + clear_target_region.region = .Ignore + clear_target_region.start_index = cast(u32) len(glyph_buffer.clear_draw_list.indices) + blit_quad( & glyph_buffer.clear_draw_list, + dst_region_pos, dst_region_pos + dst_region_size, + { 1.0, 1.0 }, { 1.0, 1.0 } + ) + clear_target_region.end_index = cast(u32) len(glyph_buffer.clear_draw_list.indices) dst_glyph_pos := glyph.region_pos dst_glyph_size := glyph.bounds_size_scaled + atlas.glyph_padding @@ -638,21 +633,15 @@ batch_generate_glyphs_draw_list :: proc ( draw_list : ^Draw_List, src_size := (glyph.bounds_size_scaled + atlas.glyph_padding) * glyph_buffer.over_sample // src_size.y = ceil(src_size.y) // Note(Ed): Seems to improve hinting to_target_space( & src_position, & src_size, glyph_buffer_size ) - blit_to_atlas : Draw_Call - { - using blit_to_atlas - pass = .Atlas - region = .None - start_index = cast(u32) len(glyph_buffer.draw_list.indices) - - blit_quad( & glyph_buffer.draw_list, - dst_glyph_pos, dst_glyph_pos + dst_glyph_size, - src_position, src_position + src_size ) - - end_index = cast(u32) len(glyph_buffer.draw_list.indices) - } + blit_to_atlas.pass = .Atlas + blit_to_atlas.region = .None + blit_to_atlas.start_index = cast(u32) len(glyph_buffer.draw_list.indices) + blit_quad( & glyph_buffer.draw_list, + dst_glyph_pos, dst_glyph_pos + dst_glyph_size, + src_position, src_position + src_size ) + blit_to_atlas.end_index = cast(u32) len(glyph_buffer.draw_list.indices) append( & glyph_buffer.clear_draw_list.calls, clear_target_region ) append( & glyph_buffer.draw_list.calls, blit_to_atlas ) diff --git a/code/font/vefontcache/shaper.odin b/code/font/vefontcache/shaper.odin index 2bf94d8..24d606d 100644 --- a/code/font/vefontcache/shaper.odin +++ b/code/font/vefontcache/shaper.odin @@ -58,19 +58,17 @@ shaper_shutdown :: proc( ctx : ^Shaper_Context ) shaper_load_font :: #force_inline proc( ctx : ^Shaper_Context, label : string, data : []byte, user_data : rawptr = nil ) -> (info : Shaper_Info) { - using info - blob = harfbuzz.blob_create( raw_data(data), cast(c.uint) len(data), harfbuzz.Memory_Mode.READONLY, user_data, nil ) - face = harfbuzz.face_create( blob, 0 ) - font = harfbuzz.font_create( face ) + info.blob = harfbuzz.blob_create( raw_data(data), cast(c.uint) len(data), harfbuzz.Memory_Mode.READONLY, user_data, nil ) + info.face = harfbuzz.face_create( info.blob, 0 ) + info.font = harfbuzz.font_create( info.face ) return } -shaper_unload_font :: #force_inline proc( ctx : ^Shaper_Info ) +shaper_unload_font :: #force_inline proc( info : ^Shaper_Info ) { - using ctx - if blob != nil do harfbuzz.font_destroy( font ) - if face != nil do harfbuzz.face_destroy( face ) - if blob != nil do harfbuzz.blob_destroy( blob ) + if info.blob != nil do harfbuzz.font_destroy( info.font ) + if info.face != nil do harfbuzz.face_destroy( info.face ) + if info.blob != nil do harfbuzz.blob_destroy( info.blob ) } shaper_shape_harfbuzz :: #force_inline proc( ctx : ^Shaper_Context, text_utf8 : string, entry : Entry, font_px_Size, font_scale : f32, output :^Shaped_Text ) diff --git a/code/font/vefontcache/vefontcache.odin b/code/font/vefontcache/vefontcache.odin index 415be65..7b5c392 100644 --- a/code/font/vefontcache/vefontcache.odin +++ b/code/font/vefontcache/vefontcache.odin @@ -273,8 +273,6 @@ startup :: proc( ctx : ^Context, parser_kind : Parser_Kind = .STB_TrueType, Glyph_Buffer_Setup: { glyph_buffer := & ctx.glyph_buffer - - // using glyph_buffer glyph_buffer.over_sample = glyph_draw_params.over_sample glyph_buffer.width = atlas.region_d.width * i32(glyph_buffer.over_sample.x) * i32(glyph_draw_params.buffer_glyph_limit) glyph_buffer.height = atlas.region_d.height * i32(glyph_buffer.over_sample.y) @@ -325,10 +323,13 @@ hot_reload :: proc( ctx : ^Context, allocator : Allocator ) assert( ctx != nil ) ctx.backing = allocator context.allocator = ctx.backing - using ctx - // using ctx.atlas - reload_array( & entries, allocator ) + atlas := & ctx.atlas + glyph_buffer := & ctx.glyph_buffer + shape_cache := & ctx.shape_cache + draw_list := & ctx.draw_list + + reload_array( & ctx.entries, allocator ) reload_array( & glyph_buffer.draw_list.calls, allocator ) reload_array( & glyph_buffer.draw_list.indices, allocator ) @@ -353,10 +354,9 @@ hot_reload :: proc( ctx : ^Context, allocator : Allocator ) lru_reload( & shape_cache.state, allocator ) for idx : i32 = 0; idx < i32(len(shape_cache.storage)); idx += 1 { - stroage_entry := & shape_cache.storage[idx] - using stroage_entry - reload_array( & glyphs, allocator ) - reload_array( & positions, allocator ) + storage_entry := & shape_cache.storage[idx] + reload_array( & storage_entry.glyphs, allocator ) + reload_array( & storage_entry.positions, allocator ) } reload_array( & shape_cache.storage, allocator ) @@ -369,12 +369,16 @@ shutdown :: proc( ctx : ^Context ) { assert( ctx != nil ) context.allocator = ctx.backing - using ctx - for & entry in entries { + atlas := & ctx.atlas + glyph_buffer := & ctx.glyph_buffer + shape_cache := & ctx.shape_cache + draw_list := & ctx.draw_list + + for & entry in ctx.entries { unload_font( ctx, entry.id ) } - delete( entries ) + delete( ctx.entries ) delete( glyph_buffer.draw_list.vertices ) delete( glyph_buffer.draw_list.indices ) @@ -398,11 +402,9 @@ shutdown :: proc( ctx : ^Context ) lru_free( & atlas.region_d.state ) for idx : i32 = 0; idx < i32(len(shape_cache.storage)); idx += 1 { - stroage_entry := & shape_cache.storage[idx] - using stroage_entry - - delete( glyphs ) - delete( positions ) + storage_entry := & shape_cache.storage[idx] + delete( storage_entry.glyphs ) + delete( storage_entry.positions ) } lru_free( & shape_cache.state ) @@ -410,8 +412,8 @@ shutdown :: proc( ctx : ^Context ) delete( draw_list.indices ) delete( draw_list.calls ) - shaper_shutdown( & shaper_ctx ) - parser_shutdown( & parser_ctx ) + shaper_shutdown( & ctx.shaper_ctx ) + parser_shutdown( & ctx.parser_ctx ) } load_font :: proc( ctx : ^Context, label : string, data : []byte, glyph_curve_quality : u32 = 0 ) -> (font_id : Font_ID, error : Load_Font_Error) @@ -419,8 +421,9 @@ load_font :: proc( ctx : ^Context, label : string, data : []byte, glyph_curve_qu profile(#procedure) assert( ctx != nil ) assert( len(data) > 0 ) - using ctx - context.allocator = backing + context.allocator = ctx.backing + + entries := & ctx.entries id : i32 = -1 @@ -430,7 +433,7 @@ load_font :: proc( ctx : ^Context, label : string, data : []byte, glyph_curve_qu break } if id == -1 { - append_elem( & entries, Entry {}) + append_elem( entries, Entry {}) id = cast(i32) len(entries) - 1 } assert( id >= 0 && id < i32(len(entries)) ) @@ -441,12 +444,12 @@ load_font :: proc( ctx : ^Context, label : string, data : []byte, glyph_curve_qu profile_begin("calling loaders") parser_error : b32 - entry.parser_info, parser_error = parser_load_font( & parser_ctx, label, data ) + entry.parser_info, parser_error = parser_load_font( & ctx.parser_ctx, label, data ) if parser_error { error = .Parser_Failed return } - entry.shaper_info = shaper_load_font( & shaper_ctx, label, data ) + entry.shaper_info = shaper_load_font( & ctx.shaper_ctx, label, data ) profile_end() ascent, descent, line_gap := parser_get_font_vertical_metrics(entry.parser_info) @@ -628,19 +631,17 @@ get_draw_list_layer :: #force_inline proc( ctx : ^Context, optimize_before_retur flush_draw_list :: #force_inline proc( ctx : ^Context ) { assert( ctx != nil ) - using ctx - clear_draw_list( & draw_list ) - draw_layer.vertices_offset = 0 - draw_layer.indices_offset = 0 - draw_layer.calls_offset = 0 + clear_draw_list( & ctx.draw_list ) + ctx.draw_layer.vertices_offset = 0 + ctx.draw_layer.indices_offset = 0 + ctx.draw_layer.calls_offset = 0 } flush_draw_list_layer :: #force_inline proc( ctx : ^Context ) { assert( ctx != nil ) - using ctx - draw_layer.vertices_offset = len(draw_list.vertices) - draw_layer.indices_offset = len(draw_list.indices) - draw_layer.calls_offset = len(draw_list.calls) + ctx.draw_layer.vertices_offset = len(ctx.draw_list.vertices) + ctx.draw_layer.indices_offset = len(ctx.draw_list.indices) + ctx.draw_layer.calls_offset = len(ctx.draw_list.calls) } //#endregion("drawing") @@ -759,19 +760,13 @@ clear_atlas_region_caches :: proc(ctx : ^Context) // Can be used with hot-reload clear_shape_cache :: proc (ctx : ^Context) { - using ctx - lru_clear(& shape_cache.state) - for idx : i32 = 0; idx < cast(i32) cap(shape_cache.storage); idx += 1 - { - stroage_entry := & shape_cache.storage[idx] - using stroage_entry - end_cursor_pos = {} - size = {} - clear(& glyphs) - clear(& positions) - clear(& draw_list.calls) - clear(& draw_list.indices) - clear(& draw_list.vertices) + lru_clear(& ctx.shape_cache.state) + for idx : i32 = 0; idx < cast(i32) cap(ctx.shape_cache.storage); idx += 1 { + stroage_entry := & ctx.shape_cache.storage[idx] + stroage_entry.end_cursor_pos = {} + stroage_entry.size = {} + clear(& stroage_entry.glyphs) + clear(& stroage_entry.positions) } ctx.shape_cache.next_cache_id = 0 }