diff --git a/code/font/vefontcache/atlas.odin b/code/font/vefontcache/atlas.odin index 72c10d2..ba64550 100644 --- a/code/font/vefontcache/atlas.odin +++ b/code/font/vefontcache/atlas.odin @@ -54,6 +54,7 @@ Atlas :: struct { } // Hahser for the atlas. +@(optimization_mode="favor_size") atlas_glyph_lru_code :: #force_inline proc "contextless" ( font : Font_ID, px_size : f32, glyph_index : Glyph ) -> (lru_code : Atlas_Key) { // lru_code = u32(glyph_index) + ( ( 0x10000 * u32(font) ) & 0xFFFF0000 ) font := font @@ -131,7 +132,7 @@ atlas_decide_region_branchless :: #force_inline proc "contextless" ( which_ab := min(score_a, score_b) which_cd := min(score_c, score_d) which_region := min(which_ab, which_cd) - resolved := min(which_region, score_buffer) + 6 + resolved := min(which_region, score_buffer) + 6 return Atlas_Region_Kind(resolved) } diff --git a/code/font/vefontcache/draw.odin b/code/font/vefontcache/draw.odin index d71e346..d1ce886 100644 --- a/code/font/vefontcache/draw.odin +++ b/code/font/vefontcache/draw.odin @@ -21,15 +21,6 @@ Vertex :: struct { u, v : f32, } -Transform :: struct { - pos : Vec2, - scale : Vec2, -} - -Range2 :: struct { - p0, p1 : Vec2, -} - Glyph_Bounds_Mat :: matrix[2, 2] f32 Glyph_Draw_Quad :: struct { @@ -44,21 +35,21 @@ Glyph_Draw_Quad :: struct { Glyph_Pack_Entry :: struct #packed { position : Vec2, - index : Glyph, - lru_code : Atlas_Key, + // index : Glyph, + // lru_code : Atlas_Key, atlas_index : i32, in_atlas : b8, should_cache : b8, - region_kind : Atlas_Region_Kind, + // region_kind : Atlas_Region_Kind, region_pos : Vec2, region_size : Vec2, - bounds : Range2, - bounds_scaled : Range2, - bounds_size : Vec2, - bounds_size_scaled : Vec2, + // bounds : Range2, + // bounds_scaled : Range2, + // bounds_size : Vec2, + // bounds_size_scaled : Vec2, over_sample : Vec2, - scale : Vec2, + // scale : Vec2, shape : Parser_Glyph_Shape, draw_transform : Transform, @@ -358,41 +349,12 @@ generate_shape_draw_list :: proc( draw_list : ^Draw_List, shape : Shaped_Text, } sub_slice :: #force_inline proc "contextless" ( pack : ^[dynamic]i32) -> []i32 { return pack[:] } - profile_begin("index") - for & glyph, index in glyph_pack - { - glyph.index = shape.glyph_id[ index ] - glyph.lru_code = atlas_glyph_lru_code(entry.id, px_size, glyph.index) - } - profile_end() - profile_begin("translate") - for & glyph, index in glyph_pack - { + for & glyph, index in glyph_pack { glyph.position = target_position + (shape.position[index]) * target_scale } profile_end() - profile_begin("bounds") - for & glyph, index in glyph_pack - { - glyph.bounds = parser_get_bounds( entry.parser_info, glyph.index ) - glyph.bounds_scaled = { glyph.bounds.p0 * font_scale, glyph.bounds.p1 * font_scale } - glyph.bounds_size = glyph.bounds.p1 - glyph.bounds.p0 - glyph.bounds_size_scaled = glyph.bounds_size * font_scale - glyph.scale = glyph.bounds_size_scaled + atlas.glyph_padding - } - profile_end() - - glyph_padding_dbl := atlas.glyph_padding * 2 - - profile_begin("region") - for & glyph, index in glyph_pack - { - glyph.region_kind = atlas_decide_region( atlas ^, glyph_buffer_size, glyph.bounds_size_scaled ) - } - profile_end() - profile_begin("batching") clear(oversized) clear(to_cache) @@ -401,15 +363,20 @@ generate_shape_draw_list :: proc( draw_list : ^Draw_List, shape : Shaped_Text, for & glyph, index in glyph_pack { - if glyph.region_kind == .None { + atlas_key := shape.atlas_lru_code[index] + region_kind := shape.region_kind[index] + bounds := shape.bounds[index] + bounds_size_scaled := size(bounds) * font_scale + + if region_kind == .None { assert(false, "FAILED TO ASSGIN REGION") continue } - if glyph.region_kind == .E + if region_kind == .E { glyph.over_sample = \ - glyph.bounds_size_scaled.x <= glyph_buffer_size.x / 2 && - glyph.bounds_size_scaled.y <= glyph_buffer_size.y / 2 ? \ + bounds_size_scaled.x <= glyph_buffer_size.x / 2 && + bounds_size_scaled.y <= glyph_buffer_size.y / 2 ? \ {2.0, 2.0} \ : {1.0, 1.0} append_sub_pack(oversized, cast(i32) index) @@ -417,8 +384,8 @@ generate_shape_draw_list :: proc( draw_list : ^Draw_List, shape : Shaped_Text, } glyph.over_sample = glyph_buffer.over_sample - region := atlas.regions[glyph.region_kind] - glyph.atlas_index = lru_get( & region.state, glyph.lru_code ) + region := atlas.regions[region_kind] + glyph.atlas_index = lru_get( & region.state, atlas_key ) // Glyphs are prepared in batches based on the capacity of the batch cache. Prepare_For_Batch: @@ -441,22 +408,22 @@ generate_shape_draw_list :: proc( draw_list : ^Draw_List, shape : Shaped_Text, } profile("append to_cache") - glyph.atlas_index = atlas_reserve_slot(region, glyph.lru_code) + glyph.atlas_index = atlas_reserve_slot(region, atlas_key) glyph.region_pos, glyph.region_size = atlas_region_bbox(region ^, glyph.atlas_index) append_sub_pack(to_cache, cast(i32) index) - mark_glyph_seen(& glyph_buffer.batch_cache, glyph.lru_code) + mark_glyph_seen(& glyph_buffer.batch_cache, atlas_key) continue } profile("append cached") glyph.region_pos, glyph.region_size = atlas_region_bbox(region ^, glyph.atlas_index) append_sub_pack(cached, cast(i32) index) - mark_glyph_seen(& glyph_buffer.batch_cache, glyph.lru_code) + mark_glyph_seen(& glyph_buffer.batch_cache, atlas_key) continue } // Batch has been prepared for a set of glyphs time to generate glyphs. - batch_generate_glyphs_draw_list( draw_list, glyph_pack, sub_slice(cached), sub_slice(to_cache), sub_slice(oversized), + batch_generate_glyphs_draw_list( draw_list, shape, glyph_pack, sub_slice(cached), sub_slice(to_cache), sub_slice(oversized), atlas, glyph_buffer, atlas_size, @@ -478,7 +445,7 @@ generate_shape_draw_list :: proc( draw_list : ^Draw_List, shape : Shaped_Text, if len(oversized) > 0 || glyph_buffer.batch_cache.num > 0 { // Last batch pass - batch_generate_glyphs_draw_list( draw_list, glyph_pack, sub_slice(cached), sub_slice(to_cache), sub_slice(oversized), + batch_generate_glyphs_draw_list( draw_list, shape, glyph_pack, sub_slice(cached), sub_slice(to_cache), sub_slice(oversized), atlas, glyph_buffer, atlas_size, @@ -508,7 +475,9 @@ generate_shape_draw_list :: proc( draw_list : ^Draw_List, shape : Shaped_Text, * Oversized will have a draw call setup to blit directly from the glyph buffer to the target. * to_cache will blit the glyphs rendered to the buffer to the atlas. */ +@(optimization_mode = "favor_size") batch_generate_glyphs_draw_list :: proc ( draw_list : ^Draw_List, + shape : Shaped_Text, glyph_pack : ^#soa[dynamic]Glyph_Pack_Entry, cached : []i32, to_cache : []i32, @@ -533,22 +502,29 @@ batch_generate_glyphs_draw_list :: proc ( draw_list : ^Draw_List, for id, index in cached { // Quad to for drawing atlas slot to target - glyph := & glyph_pack[id] + glyph := & glyph_pack[id] + bounds := shape.bounds[id] + bounds_scaled := mul(bounds, font_scale) + glyph_scale := size(bounds_scaled) + atlas.glyph_padding + quad := & glyph.draw_quad - quad.dst_pos = glyph.position + (glyph.bounds_scaled.p0) * target_scale - quad.dst_scale = (glyph.scale) * target_scale - quad.src_scale = (glyph.scale) + quad.dst_pos = glyph.position + (bounds_scaled.p0) * target_scale + quad.dst_scale = (glyph_scale) * target_scale + quad.src_scale = (glyph_scale) quad.src_pos = (glyph.region_pos) to_target_space( & quad.src_pos, & quad.src_scale, atlas_size ) } for id, index in to_cache { - glyph := & glyph_pack[id] + glyph := & glyph_pack[id] + bounds := shape.bounds[id] + bounds_scaled := mul(bounds, font_scale) + glyph_scale := size(bounds_scaled) + glyph_buffer.draw_padding f32_allocated_x := cast(f32) glyph_buffer.allocated_x // Resolve how much space this glyph will allocate in the buffer - buffer_size := (glyph.bounds_size_scaled + glyph_buffer.draw_padding) * glyph_buffer.over_sample + buffer_size := glyph_scale * glyph_buffer.over_sample // Allocate a glyph glyph render target region (FBO) to_allocate_x := buffer_size.x + 2.0 @@ -559,7 +535,7 @@ batch_generate_glyphs_draw_list :: proc ( draw_list : ^Draw_List, // The glyph buffer space transform for generate_glyph_pass_draw_list draw_transform := & glyph.draw_transform draw_transform.scale = font_scale * glyph_buffer.over_sample - draw_transform.pos = -1 * (glyph.bounds.p0) * draw_transform.scale + glyph_buffer.draw_padding + draw_transform.pos = -1 * (bounds.p0) * draw_transform.scale + glyph_buffer.draw_padding draw_transform.pos.x += glyph.buffer_x to_glyph_buffer_space( & draw_transform.pos, & draw_transform.scale, glyph_buffer_size ) @@ -570,21 +546,25 @@ batch_generate_glyphs_draw_list :: proc ( draw_list : ^Draw_List, draw_quad := & glyph.draw_quad // Destination (draw_list's target image) - draw_quad.dst_pos = glyph.position + (glyph.bounds_scaled.p0) * target_scale - draw_quad.dst_scale = (glyph.scale) * target_scale + draw_quad.dst_pos = glyph.position + (bounds_scaled.p0) * target_scale + draw_quad.dst_scale = (glyph_scale) * target_scale // UV Coordinates for sampling the atlas - draw_quad.src_scale = (glyph.scale) + draw_quad.src_scale = (glyph_scale) draw_quad.src_pos = (glyph.region_pos) to_target_space( & draw_quad.src_pos, & draw_quad.src_scale, atlas_size ) } - for id, index in oversized + when ENABLE_OVERSIZED_GLYPHS do for id, index in oversized { - glyph := & glyph_pack[id] + glyph_padding := vec2(glyph_buffer.draw_padding) + glyph := & glyph_pack[id] + bounds := shape.bounds[id] + bounds_scaled := mul(bounds, font_scale) + bounds_size_scaled := size(bounds_scaled) f32_allocated_x := cast(f32) glyph_buffer.allocated_x // Resolve how much space this glyph will allocate in the buffer - buffer_size := (glyph.bounds_size_scaled + glyph_buffer.draw_padding) * glyph.over_sample + buffer_size := (bounds_size_scaled + glyph_padding) * glyph.over_sample // Allocate a glyph glyph render target region (FBO) to_allocate_x := buffer_size.x + 2.0 @@ -597,40 +577,40 @@ batch_generate_glyphs_draw_list :: proc ( draw_list : ^Draw_List, // Quad to for drawing atlas slot to target draw_quad := & glyph.draw_quad - glyph_padding := vec2(glyph_buffer.draw_padding) // Target position (draw_list's target image) - draw_quad.dst_pos = glyph.position + (glyph.bounds_scaled.p0 - glyph_padding) * target_scale - draw_quad.dst_scale = (glyph.bounds_size_scaled + glyph_padding) * target_scale + draw_quad.dst_pos = glyph.position + (bounds_scaled.p0 - glyph_padding) * target_scale + draw_quad.dst_scale = (bounds_size_scaled + glyph_padding) * target_scale // The glyph buffer space transform for generate_glyph_pass_draw_list draw_transform := & glyph.draw_transform draw_transform.scale = font_scale * glyph.over_sample - draw_transform.pos = -1 * glyph.bounds.p0 * draw_transform.scale + vec2(atlas.glyph_padding) + draw_transform.pos = -1 * bounds.p0 * draw_transform.scale + vec2(atlas.glyph_padding) draw_transform.pos.x += glyph.buffer_x to_glyph_buffer_space( & draw_transform.pos, & draw_transform.scale, glyph_buffer_size ) draw_quad.src_pos = Vec2 { glyph.buffer_x, 0 } - draw_quad.src_scale = glyph.bounds_size_scaled * glyph.over_sample + glyph_padding + draw_quad.src_scale = bounds_size_scaled * glyph.over_sample + glyph_padding to_target_space( & draw_quad.src_pos, & draw_quad.src_scale, glyph_buffer_size ) } profile_end() profile_begin("generate oversized glyphs draw_list") - if len(oversized) > 0 + when ENABLE_OVERSIZED_GLYPHS do if len(oversized) > 0 { // colour.r = max(colour.a, enable_debug_vis_type) // colour.g = max(colour.g, enable_debug_vis_type) // colour.b = colour.b * f32(cast(i32) ! b32(cast(i32) enable_debug_vis_type)) - for id, index in oversized { + for pack_id, index in oversized { error : Allocator_Error - glyph_pack[id].shape, error = parser_get_glyph_shape(entry.parser_info, glyph_pack[id].index) + glyph_pack[pack_id].shape, error = parser_get_glyph_shape(entry.parser_info, shape.glyph_id[pack_id]) assert(error == .None) } for id, index in oversized { - glyph := & glyph_pack[id] + glyph := & glyph_pack[id] + bounds := shape.bounds[id] if glyph.flush_glyph_buffer do flush_glyph_buffer_draw_list(draw_list, & glyph_buffer.draw_list, & glyph_buffer.clear_draw_list, @@ -640,7 +620,7 @@ batch_generate_glyphs_draw_list :: proc ( draw_list : ^Draw_List, generate_glyph_pass_draw_list( draw_list, & glyph_buffer.shape_gen_scratch, glyph_pack[id].shape, entry.curve_quality, - glyph_pack[id].bounds, + bounds, glyph_pack[id].draw_transform.pos, glyph_pack[id].draw_transform.scale ) @@ -691,16 +671,19 @@ batch_generate_glyphs_draw_list :: proc ( draw_list : ^Draw_List, profile_begin("to_cache: caching to atlas") if len(to_cache) > 0 { - for id, index in to_cache { + for pack_id, index in to_cache { error : Allocator_Error - glyph_pack[id].shape, error = parser_get_glyph_shape(entry.parser_info, glyph_pack[id].index) + glyph_pack[pack_id].shape, error = parser_get_glyph_shape(entry.parser_info, shape.glyph_id[pack_id]) assert(error == .None) } for id, index in to_cache { profile("glyph") - glyph := & glyph_pack[id] + glyph := & glyph_pack[id] + bounds := shape.bounds[id] + bounds_scaled := mul(bounds, font_scale) + bounds_size_scaled := size(bounds_scaled) if glyph.flush_glyph_buffer do flush_glyph_buffer_draw_list( draw_list, & glyph_buffer.draw_list, @@ -723,12 +706,12 @@ batch_generate_glyphs_draw_list :: proc ( draw_list : ^Draw_List, 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 + dst_glyph_size := bounds_size_scaled + atlas.glyph_padding dst_glyph_size.y = max(dst_glyph_size.y, ceil(dst_glyph_size.y) * glyph_buffer.snap_glyph_height) // Note(Ed): Seems to improve hinting to_glyph_buffer_space( & dst_glyph_pos, & dst_glyph_size, atlas_size ) src_position := Vec2 { glyph.buffer_x, 0 } - src_size := (glyph.bounds_size_scaled + atlas.glyph_padding) * glyph_buffer.over_sample + src_size := (bounds_size_scaled + atlas.glyph_padding) * glyph_buffer.over_sample src_size.y = max(src_size.y, ceil(src_size.y) * glyph_buffer.snap_glyph_height) // Note(Ed): Seems to improve hinting to_target_space( & src_position, & src_size, glyph_buffer_size ) @@ -748,7 +731,7 @@ batch_generate_glyphs_draw_list :: proc ( draw_list : ^Draw_List, generate_glyph_pass_draw_list( draw_list, & glyph_buffer.shape_gen_scratch, glyph.shape, entry.curve_quality, - glyph.bounds, + bounds, glyph.draw_transform.pos, glyph.draw_transform.scale ) diff --git a/code/font/vefontcache/misc.odin b/code/font/vefontcache/misc.odin index 5240228..b955b3f 100644 --- a/code/font/vefontcache/misc.odin +++ b/code/font/vefontcache/misc.odin @@ -58,6 +58,18 @@ Vec2 :: [2]f32 Vec2i :: [2]i32 Vec2_64 :: [2]f64 +Transform :: struct { + pos : Vec2, + scale : Vec2, +} + +Range2 :: struct { + p0, p1 : Vec2, +} + +mul_range2_vec2 :: #force_inline proc "contextless" ( range : Range2, v : Vec2 ) -> Range2 { return { range.p0 * v, range.p1 * v } } +size_range2 :: #force_inline proc "contextless" ( range : Range2 ) -> Vec2 { return range.p1 - range.p0 } + vec2_from_scalar :: #force_inline proc "contextless" ( scalar : f32 ) -> Vec2 { return { scalar, scalar }} vec2_64_from_vec2 :: #force_inline proc "contextless" ( v2 : Vec2 ) -> Vec2_64 { return { f64(v2.x), f64(v2.y) }} vec2_from_vec2i :: #force_inline proc "contextless" ( v2i : Vec2i ) -> Vec2 { return { f32(v2i.x), f32(v2i.y) }} diff --git a/code/font/vefontcache/pkg_mapping.odin b/code/font/vefontcache/pkg_mapping.odin index 5b20913..aa73ce4 100644 --- a/code/font/vefontcache/pkg_mapping.odin +++ b/code/font/vefontcache/pkg_mapping.odin @@ -102,6 +102,10 @@ make_soa :: proc { builtin.make_soa_slice, } +mul :: proc { + mul_range2_vec2, +} + peek :: proc { peek_array, } @@ -110,6 +114,10 @@ resize :: proc { builtin.resize_dynamic_array, } +size :: proc { + size_range2, +} + vec2 :: proc { vec2_from_scalar, vec2_from_vec2i, diff --git a/code/font/vefontcache/shaper.odin b/code/font/vefontcache/shaper.odin index dacbe85..cba587c 100644 --- a/code/font/vefontcache/shaper.odin +++ b/code/font/vefontcache/shaper.odin @@ -25,12 +25,15 @@ Shape_Key :: u32 If your doing something heavy though (where there is thousands, or tens-of thousands) your not going to be satisfied with keeping that in the iteration). */ -Shaped_Text :: struct { +Shaped_Text :: struct #packed { glyph_id : [dynamic]Glyph, position : [dynamic]Vec2, atlas_lru_code : [dynamic]Atlas_Key, region_kind : [dynamic]Atlas_Region_Kind, - bound : [dynamic]Range2, + bounds : [dynamic]Range2, + // bounds_scaled : [dynamic]Range2, + // bounds_size : [dynamic]Vec2, + // bounds_size_Scaled : [dynamic]Vec2, end_cursor_pos : Vec2, size : Vec2, } @@ -281,28 +284,41 @@ shaper_shape_text_uncached_advanced :: #force_inline proc( ctx : ^Shaper_Context // Resolve each glyphs: bounds, atlas lru, and the atlas region as we have everything we need now. + resize( & output.atlas_lru_code, len(output.glyph_id) ) + resize( & output.region_kind, len(output.glyph_id) ) + resize( & output.bounds, len(output.glyph_id) ) + // resize( & output.bounds_scaled, len(output.glyph_id) ) + profile_begin("bounds") for id, index in output.glyph_id { - // glyph.bounds = parser_get_bounds( entry.parser_info, glyph.index ) - // glyph.bounds_scaled = { glyph.bounds.p0 * font_scale, glyph.bounds.p1 * font_scale } - // glyph.bounds_size = glyph.bounds.p1 - glyph.bounds.p0 - // glyph.bounds_size_scaled = glyph.bounds_size * font_scale - // glyph.scale = glyph.bounds_size_scaled + atlas.glyph_padding + bounds := & output.bounds[index] + // bounds_scaled := & output.bounds_scaled[index] + // bounds_size := & output.bounds_size[index] + // bounds_size_scaled := & output.bounds_size_scaled[index] + // scale := & output.scale[index] + (bounds ^) = parser_get_bounds( entry.parser_info, id ) + // (bounds_scaled ^) = { bounds.p0 * font_scale, bounds.p1 * font_scale } + // bounds_size = bounds.p1 - bounds.p0 + // bounds_size_scaled = bounds_size * font_scale + // scale = glyph.bounds_size_scaled + atlas.glyph_padding } profile_end() - profile_begin("index") + profile_begin("atlas_lru_code") for id, index in output.glyph_id { - // output.atlas_lru_code[index] = atlas_glyph_lru_code(entry.id, px_size, glyph.index) + output.atlas_lru_code[index] = atlas_glyph_lru_code(entry.id, font_px_size, id) } profile_end() profile_begin("region") for id, index in output.glyph_id { - // output.region_kind[index] = atlas_decide_region_branchless( atlas ^, glyph_buffer_size, glyph.bounds_size_scaled ) + bounds := & output.bounds[index] + bounds_size_scaled := (bounds.p1 - bounds.p0) * font_scale + + output.region_kind[index] = atlas_decide_region( atlas, glyph_buffer_size, bounds_size_scaled ) } profile_end() } diff --git a/code/font/vefontcache/vefontcache.odin b/code/font/vefontcache/vefontcache.odin index f84dd21..4a13275 100644 --- a/code/font/vefontcache/vefontcache.odin +++ b/code/font/vefontcache/vefontcache.odin @@ -8,7 +8,8 @@ package vetext import "base:runtime" // See: mappings.odin for profiling hookup -DISABLE_PROFILING :: false +DISABLE_PROFILING :: false +ENABLE_OVERSIZED_GLYPHS :: true Font_ID :: distinct i32 Glyph :: distinct i32 @@ -158,13 +159,14 @@ Init_Shaper_Params_Default :: Init_Shaper_Params { Init_Shape_Cache_Params :: struct { // Note(Ed): This should mostly just be given the worst-case capacity and reserve at the same time. // If memory is a concern it can easily be 256 - 2k if not much text is going to be rendered often. + // Shapes should really not exceed 1024 glyphs.. capacity : u32, reserve : u32, } Init_Shape_Cache_Params_Default :: Init_Shape_Cache_Params { capacity = 10 * 1024, - reserve = 10 * 1024, + reserve = 1024, } //#region("lifetime") @@ -268,7 +270,8 @@ startup :: proc( ctx : ^Context, parser_kind : Parser_Kind = .STB_TrueType, shape_cache.storage, error = make( [dynamic]Shaped_Text, shape_cache_params.capacity ) assert(error == .None, "VEFontCache.init : Failed to allocate shape_cache.storage") - for idx : u32 = 0; idx < shape_cache_params.capacity; idx += 1 { + for idx : u32 = 0; idx < shape_cache_params.capacity; idx += 1 + { stroage_entry := & shape_cache.storage[idx] stroage_entry.glyph_id, error = make( [dynamic]Glyph, len = 0, cap = shape_cache_params.reserve ) @@ -276,6 +279,18 @@ startup :: proc( ctx : ^Context, parser_kind : Parser_Kind = .STB_TrueType, stroage_entry.position, error = make( [dynamic]Vec2, len = 0, cap = shape_cache_params.reserve ) assert( error == .None, "VEFontCache.init : Failed to allocate positions array for shape cache storage" ) + + stroage_entry.atlas_lru_code, error = make( [dynamic]Atlas_Key, len = 0, cap = shape_cache_params.reserve ) + assert( error == .None, "VEFontCache.init : Failed to allocate atlas_lru_code array for shape cache storage" ) + + stroage_entry.region_kind, error = make( [dynamic]Atlas_Region_Kind, len = 0, cap = shape_cache_params.reserve ) + assert( error == .None, "VEFontCache.init : Failed to allocate region_kind array for shape cache storage" ) + + stroage_entry.bounds, error = make( [dynamic]Range2, len = 0, cap = shape_cache_params.reserve ) + assert( error == .None, "VEFontCache.init : Failed to allocate bounds array for shape cache storage" ) + + // stroage_entry.bounds_scaled, error = make( [dynamic]Range2, len = 0, cap = shape_cache_params.reserve ) + // assert( error == .None, "VEFontCache.init : Failed to allocate bounds_scaled array for shape cache storage" ) } } @@ -365,8 +380,12 @@ 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 { storage_entry := & shape_cache.storage[idx] - reload_array( & storage_entry.glyph_id, allocator ) - reload_array( & storage_entry.position, allocator ) + reload_array( & storage_entry.glyph_id, allocator) + reload_array( & storage_entry.position, allocator) + reload_array( & storage_entry.atlas_lru_code, allocator) + reload_array( & storage_entry.region_kind, allocator) + reload_array( & storage_entry.bounds, allocator) + // reload_array( & storage_entry.bounds_scaled, allocator) } reload_array( & shape_cache.storage, allocator ) @@ -415,6 +434,10 @@ shutdown :: proc( ctx : ^Context ) storage_entry := & shape_cache.storage[idx] delete( storage_entry.glyph_id ) delete( storage_entry.position ) + delete( storage_entry.atlas_lru_code) + delete( storage_entry.region_kind) + delete( storage_entry.bounds) + // delete( storage_entry.bounds_scaled) } lru_free( & shape_cache.state ) diff --git a/code/grime/profiler.odin b/code/grime/profiler.odin index 3a3a27c..2fcc5f7 100644 --- a/code/grime/profiler.odin +++ b/code/grime/profiler.odin @@ -15,7 +15,7 @@ set_profiler_module_context :: #force_inline proc "contextless" ( ctx : ^SpallPr Module_Context = ctx } -DISABLE_PROFILING :: false +DISABLE_PROFILING :: true @(deferred_none = profile_end, disabled = DISABLE_PROFILING) profile :: #force_inline proc "contextless" ( name : string, loc := #caller_location ) { diff --git a/scripts/build.ps1 b/scripts/build.ps1 index 5d7a531..f783fe5 100644 --- a/scripts/build.ps1 +++ b/scripts/build.ps1 @@ -205,11 +205,11 @@ push-location $path_root # $build_args += $flag_micro_architecture_native $build_args += $flag_use_separate_modules $build_args += $flag_thread_count + $CoreCount_Physical - $build_args += $flag_optimize_none + # $build_args += $flag_optimize_none # $build_args += $flag_optimize_minimal # $build_args += $flag_optimize_speed - # $build_args += $falg_optimize_aggressive - $build_args += $flag_debug + $build_args += $falg_optimize_aggressive + # $build_args += $flag_debug $build_args += $flag_pdb_name + $pdb $build_args += $flag_subsystem + 'windows' # $build_args += $flag_show_system_calls