ed/SectrPrototype
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

WIP - VEFontCache: Rendering 3k lines of whitespace ast is 16 ms rn...

Browse Source
This commit is contained in:
Edward R. Gonzalez
2025-01-02 17:49:39 -05:00
parent 560b2a125b
commit 73ba89e7f9
16 changed files with 538 additions and 391 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
code/font/vefontcache/LRU.odin
View File

@ -139,7 +139,7 @@ pool_list_erase :: proc( pool : ^Pool_List, iter : Pool_ListIter )
}
}
pool_list_move_to_front :: #force_inline proc "contextless" ( pool : ^Pool_List, iter : Pool_ListIter )
pool_list_move_to_front :: proc "contextless" ( pool : ^Pool_List, iter : Pool_ListIter )
{
using pool
@ -156,7 +156,7 @@ pool_list_move_to_front :: #force_inline proc "contextless" ( pool : ^Pool_List,
front = iter
}
pool_list_peek_back :: #force_inline proc ( pool : ^Pool_List ) -> Pool_ListValue #no_bounds_check {
pool_list_peek_back :: #force_inline proc ( pool : Pool_List ) -> Pool_ListValue #no_bounds_check {
assert( pool.back != - 1 )
value := pool.items[ pool.back ].value
return value
@ -212,7 +212,7 @@ lru_clear :: proc ( cache : ^LRU_Cache ) {
cache.num = 0
}
lru_find :: #force_inline proc "contextless" ( cache : ^LRU_Cache, key : u64, must_find := false ) -> (LRU_Link, bool) {
lru_find :: #force_inline proc "contextless" ( cache : LRU_Cache, key : u64, must_find := false ) -> (LRU_Link, bool) {
link, success := cache.table[key]
return link, success
}
@ -225,15 +225,15 @@ lru_get :: #force_inline proc ( cache: ^LRU_Cache, key : u64 ) -> i32 #no_bounds
return -1
}
lru_get_next_evicted :: #force_inline proc ( cache : ^LRU_Cache ) -> u64 {
lru_get_next_evicted :: #force_inline proc ( cache : LRU_Cache ) -> u64 {
if cache.key_queue.size >= cache.capacity {
evict := pool_list_peek_back( & cache.key_queue )
evict := pool_list_peek_back( cache.key_queue )
return evict
}
return 0xFFFFFFFFFFFFFFFF
}
lru_peek :: #force_inline proc "contextless" ( cache : ^LRU_Cache, key : u64, must_find := false ) -> i32 {
lru_peek :: #force_inline proc "contextless" ( cache : LRU_Cache, key : u64, must_find := false ) -> i32 {
iter, success := lru_find( cache, key, must_find )
if success == false {
return -1
@ -267,7 +267,7 @@ lru_put :: #force_inline proc( cache : ^LRU_Cache, key : u64, value : i32 ) -> u
}
lru_refresh :: proc( cache : ^LRU_Cache, key : u64 ) {
link, success := lru_find( cache, key )
link, success := lru_find( cache ^, key )
pool_list_erase( & cache.key_queue, link.ptr )
pool_list_push_front( & cache.key_queue, key )
link.ptr = cache.key_queue.front

68
code/font/vefontcache/atlas.odin
View File

@ -38,56 +38,6 @@ Atlas :: struct {
regions : [4] ^Atlas_Region,
}
atlas_bbox :: #force_inline proc "contextless" ( atlas : ^Atlas, region : Atlas_Region_Kind, local_idx : i32 ) -> (position, size: Vec2)
{
profile(#procedure)
switch region
{
case .A:
size.x = f32(atlas.region_a.width)
size.y = f32(atlas.region_a.height)
position.x = cast(f32) (( local_idx % atlas.region_a.capacity.x ) * atlas.region_a.width)
position.y = cast(f32) (( local_idx / atlas.region_a.capacity.x ) * atlas.region_a.height)
position.x += f32(atlas.region_a.offset.x)
position.y += f32(atlas.region_a.offset.y)
case .B:
size.x = f32(atlas.region_b.width)
size.y = f32(atlas.region_b.height)
position.x = cast(f32) (( local_idx % atlas.region_b.capacity.x ) * atlas.region_b.width)
position.y = cast(f32) (( local_idx / atlas.region_b.capacity.x ) * atlas.region_b.height)
position.x += f32(atlas.region_b.offset.x)
position.y += f32(atlas.region_b.offset.y)
case .C:
size.x = f32(atlas.region_c.width)
size.y = f32(atlas.region_c.height)
position.x = cast(f32) (( local_idx % atlas.region_c.capacity.x ) * atlas.region_c.width)
position.y = cast(f32) (( local_idx / atlas.region_c.capacity.x ) * atlas.region_c.height)
position.x += f32(atlas.region_c.offset.x)
position.y += f32(atlas.region_c.offset.y)
case .D:
size.x = f32(atlas.region_d.width)
size.y = f32(atlas.region_d.height)
position.x = cast(f32) (( local_idx % atlas.region_d.capacity.x ) * atlas.region_d.width)
position.y = cast(f32) (( local_idx / atlas.region_d.capacity.x ) * atlas.region_d.height)
position.x += f32(atlas.region_d.offset.x)
position.y += f32(atlas.region_d.offset.y)
case .Ignore, .None, .E:
}
return
}
atlas_region_bbox :: proc( region : Atlas_Region, local_idx : i32 ) -> (position, size: Vec2)
{
size.x = f32(region.width)
@ -135,28 +85,28 @@ atlas_reserve_slot :: #force_inline proc ( region : ^Atlas_Region, lru_code : u6
}
else
{
next_evict_codepoint := lru_get_next_evicted( & region.state )
assert( next_evict_codepoint != 0xFFFFFFFFFFFFFFFF )
next_evict_codepoint := lru_get_next_evicted( region.state )
// assert( next_evict_codepoint != 0xFFFFFFFFFFFFFFFF )
atlas_index = lru_peek( & region.state, next_evict_codepoint, must_find = true )
assert( atlas_index != -1 )
atlas_index = lru_peek( region.state, next_evict_codepoint, must_find = true )
// assert( atlas_index != -1 )
evicted := lru_put( & region.state, lru_code, atlas_index )
assert( evicted == next_evict_codepoint )
// assert( evicted == next_evict_codepoint )
}
assert( lru_get( & region.state, lru_code ) != - 1 )
return
}
check_and_reserve_slot_in_atlas :: #force_inline proc( ctx : ^Context, glyph_index : Glyph,
check_and_reserve_slot_in_atlas :: #force_inline proc( ctx : Context, glyph_index : Glyph,
lru_code : u64,
atlas_index : ^i32,
region : ^Atlas_Region,
) -> (found, should_cache : b8 )
{
profile(#procedure)
assert( glyph_index != -1 )
// assert( glyph_index != -1 )
if ctx.temp_codepoint_seen_num > i32(cap(ctx.temp_codepoint_seen)) do return
@ -166,10 +116,10 @@ check_and_reserve_slot_in_atlas :: #force_inline proc( ctx : ^Context, glyph_ind
if region.next_idx > region.state.capacity
{
// We will evict LRU. We must predict which LRU will get evicted, and if it's something we've seen then we need to take slowpath and flush batch.
next_evict_codepoint := lru_get_next_evicted( & region.state )
next_evict_codepoint := lru_get_next_evicted( region.state )
success : bool
found, success = ctx.temp_codepoint_seen[next_evict_codepoint]
assert(success != false)
// assert(success != false)
if (found) {
return
}

418
code/font/vefontcache/draw.odin
View File

@ -1,13 +1,42 @@
package vefontcache
import "thirdparty:freetype"
import "base:runtime"
import "core:slice"
import "thirdparty:freetype"
Vertex :: struct {
pos : Vec2,
u, v : f32,
}
GlyphBounds :: struct {
p0, p1 : Vec2
}
Glyph_Pack_Entry :: struct {
shape : Parser_Glyph_Shape,
bounds : GlyphBounds,
bounds_size : Vec2,
bounds_size_scaled : Vec2,
over_sample : Vec2,
translate : Vec2,
// scale : Vec2,
region_pos : Vec2,
region_size : Vec2,
lru_code : u64,
atlas_index : i32,
index : Glyph,
// shape_id : i32,
region_kind : Atlas_Region_Kind,
in_atlas : b8,
should_cache : b8,
}
Glyph_Sub_Pack :: struct {
pack : #soa[]Glyph_Pack_Entry,
num : i32
}
Draw_Call :: struct {
pass : Frame_Buffer_Pass,
start_index : u32,
@ -51,6 +80,11 @@ Glyph_Draw_Buffer :: struct {
batch_x : i32,
clear_draw_list : Draw_List,
draw_list : Draw_List,
glyph_pack : #soa[dynamic]Glyph_Pack_Entry,
oversized : #soa[dynamic]Glyph_Pack_Entry,
to_cache : #soa[dynamic]Glyph_Pack_Entry,
cached : #soa[dynamic]Glyph_Pack_Entry,
}
blit_quad :: #force_inline proc ( draw_list : ^Draw_List, p0 : Vec2 = {0, 0}, p1 : Vec2 = {1, 1}, uv0 : Vec2 = {0, 0}, uv1 : Vec2 = {1, 1} )
@ -246,26 +280,17 @@ blit_quad :: #force_inline proc ( draw_list : ^Draw_List, p0 : Vec2 = {0, 0}, p1
// }
// TODO(Ed): Is it better to cache the glyph vertices for when it must be re-drawn (directly or two atlas)?
cache_glyph :: proc(ctx : ^Context, font : Font_ID, glyph_index : Glyph, entry : ^Entry, bounds_0, bounds_1 : Vec2, scale, translate : Vec2) -> b32
generate_glyph_pass_draw_list :: #force_inline proc(ctx : ^Context,
glyph_index : Glyph,
glyph_shape : Parser_Glyph_Shape,
curve_quality : f32,
bounds : GlyphBounds,
scale, translate : Vec2
) -> b32
{
profile(#procedure)
if glyph_index == Glyph(0) {
return false
}
// Glyph shape handling are not abstractable between freetype and stb_truetype
// if entry.parser_info.kind == .Freetype {
// result := cache_glyph_freetype( ctx, font, glyph_index, entry, bounds_0, bounds_1, scale, translate )
// return result
// }
shape, error := parser_get_glyph_shape(&entry.parser_info, glyph_index)
assert(error == .None)
if len(shape) == 0 {
return false
}
outside := Vec2{bounds_0.x - 21, bounds_0.y - 33}
outside := Vec2{bounds.p0.x - 21, bounds.p0.y - 33}
draw := Draw_Call_Default
draw.pass = Frame_Buffer_Pass.Glyph
@ -274,13 +299,12 @@ cache_glyph :: proc(ctx : ^Context, font : Font_ID, glyph_index : Glyph, entry :
path := &ctx.temp_path
clear(path)
step := 1.0 / entry.curve_quality
for edge in shape do #partial switch edge.type
step := 1.0 / curve_quality
for edge in glyph_shape do #partial switch edge.type
{
case .Move:
if len(path) > 0 {
// draw_filled_path(&ctx.draw_list, outside, path[:], scale, translate, ctx.debug_print_verbose)
draw_filled_path(&ctx.draw_list, outside, path[:], scale, translate)
construct_filled_path(&ctx.draw_list, outside, path[:], scale, translate)
clear(path)
}
fallthrough
@ -294,7 +318,7 @@ cache_glyph :: proc(ctx : ^Context, font : Font_ID, glyph_index : Glyph, entry :
p1 := Vec2{ f32(edge.contour_x0), f32(edge.contour_y0) }
p2 := Vec2{ f32(edge.x), f32(edge.y) }
for index : f32 = 1; index <= entry.curve_quality; index += 1 {
for index : f32 = 1; index <= curve_quality; index += 1 {
alpha := index * step
append( path, Vertex { pos = eval_point_on_bezier3(p0, p1, p2, alpha) } )
}
@ -306,41 +330,33 @@ cache_glyph :: proc(ctx : ^Context, font : Font_ID, glyph_index : Glyph, entry :
p2 := Vec2{ f32(edge.contour_x1), f32(edge.contour_y1) }
p3 := Vec2{ f32(edge.x), f32(edge.y) }
for index : f32 = 1; index <= entry.curve_quality; index += 1 {
for index : f32 = 1; index <= curve_quality; index += 1 {
alpha := index * step
append( path, Vertex { pos = eval_point_on_bezier4(p0, p1, p2, p3, alpha) } )
}
}
if len(path) > 0 {
// draw_filled_path(&ctx.draw_list, outside, path[:], scale, translate, ctx.debug_print_verbose)
draw_filled_path(&ctx.draw_list, outside, path[:], scale, translate)
construct_filled_path(&ctx.draw_list, outside, path[:], scale, translate)
}
draw.end_index = u32(len(ctx.draw_list.indices))
if draw.end_index > draw.start_index {
append( & ctx.draw_list.calls, draw)
}
parser_free_shape(&entry.parser_info, shape)
return true
}
/*
Called by:
* can_batch_glyph : If it determines that the glyph was not detected and we haven't reached capacity in the atlas
* draw_text_shape : Glyph
*/
cache_glyph_to_atlas :: proc ( ctx : ^Context,
font : Font_ID,
cache_glyph_to_atlas :: #force_no_inline proc ( ctx : ^Context,
glyph_index : Glyph,
glyph_shape : Parser_Glyph_Shape,
bounds : GlyphBounds,
bounds_size : Vec2,
region_pos : Vec2,
region_size : Vec2,
lru_code : u64,
atlas_index : i32,
entry : ^Entry,
entry : Entry,
// region_kind : Atlas_Region_Kind,
// region : ^Atlas_Region,
over_sample : Vec2
@ -413,19 +429,48 @@ cache_glyph_to_atlas :: proc ( ctx : ^Context,
append( & glyph_buffer.draw_list.calls, blit_to_atlas )
// Render glyph to glyph render target (FBO)
cache_glyph( ctx, font, glyph_index, entry, bounds.p0, bounds.p1, glyph_draw_scale, glyph_draw_translate )
generate_glyph_pass_draw_list( ctx, glyph_index, glyph_shape, entry.curve_quality, bounds, glyph_draw_scale, glyph_draw_translate )
}
// ve_fontcache_clear_Draw_List
clear_draw_list :: #force_inline proc ( draw_list : ^Draw_List ) {
clear( & draw_list.calls )
clear( & draw_list.indices )
clear( & draw_list.vertices )
// Constructs a triangle fan to fill a shape using the provided path outside_point represents the center point of the fan.
construct_filled_path :: #force_inline proc( draw_list : ^Draw_List, outside_point : Vec2, path : []Vertex,
scale := Vec2 { 1, 1 },
translate := Vec2 { 0, 0 }
)
{
profile(#procedure)
v_offset := cast(u32) len(draw_list.vertices)
for point in path {
point := point
point.pos = point.pos * scale + translate
append( & draw_list.vertices, point )
}
outside_vertex := cast(u32) len(draw_list.vertices)
{
vertex := Vertex {
pos = outside_point * scale + translate,
u = 0,
v = 0,
}
append( & draw_list.vertices, vertex )
}
for index : u32 = 1; index < cast(u32) len(path); index += 1 {
indices := & draw_list.indices
to_add := [3]u32 {
outside_vertex,
v_offset + index - 1,
v_offset + index
}
append( indices, ..to_add[:] )
}
}
directly_draw_massive_glyph :: proc( ctx : ^Context,
entry : ^Entry,
generate_oversized_draw_list :: #force_no_inline proc( ctx : ^Context,
entry : Entry,
glyph : Glyph,
glyph_shape : Parser_Glyph_Shape,
bounds : GlyphBounds,
bounds_size : Vec2,
over_sample, position, scale : Vec2 )
@ -441,7 +486,7 @@ directly_draw_massive_glyph :: proc( ctx : ^Context,
glyph_draw_translate := -1 * bounds.p0 * glyph_draw_scale + vec2_from_scalar(glyph_padding)
screenspace_x_form( & glyph_draw_translate, & glyph_draw_scale, glyph_buffer_size )
cache_glyph( ctx, entry.id, glyph, entry, bounds.p0, bounds.p1, glyph_draw_scale, glyph_draw_translate )
generate_glyph_pass_draw_list( ctx, glyph, glyph_shape, entry.curve_quality, bounds, glyph_draw_scale, glyph_draw_translate )
bounds_scaled := bounds_size * entry.size_scale
@ -484,59 +529,9 @@ directly_draw_massive_glyph :: proc( ctx : ^Context,
append( & ctx.draw_list.calls, ..calls[:] )
}
// Constructs a triangle fan to fill a shape using the provided path
// outside_point represents the center point of the fan.
//
// Note(Original Author):
// WARNING: doesn't actually append Draw_Call; caller is responsible for actually appending the Draw_Call.
// ve_fontcache_draw_filled_path
draw_filled_path :: proc( draw_list : ^Draw_List, outside_point : Vec2, path : []Vertex,
scale := Vec2 { 1, 1 },
translate := Vec2 { 0, 0 }
// debug_print_verbose : b32 = false
) #no_bounds_check
{
profile(#procedure)
// if debug_print_verbose
// {
// log("outline_path:")
// for point in path {
// vec := point.pos * scale + translate
// logf(" %0.2f %0.2f", vec.x, vec.y )
// }
// }
v_offset := cast(u32) len(draw_list.vertices)
for point in path {
point := point
point.pos = point.pos * scale + translate
append( & draw_list.vertices, point )
}
outside_vertex := cast(u32) len(draw_list.vertices)
{
vertex := Vertex {
pos = outside_point * scale + translate,
u = 0,
v = 0,
}
append( & draw_list.vertices, vertex )
}
for index : u32 = 1; index < cast(u32) len(path); index += 1 {
indices := & draw_list.indices
to_add := [3]u32 {
outside_vertex,
v_offset + index - 1,
v_offset + index
}
append( indices, ..to_add[:] )
}
}
draw_text_batch :: #force_inline proc (ctx: ^Context, entry: ^Entry, shaped: ^Shaped_Text,
generate_cached_draw_list :: proc (ctx: ^Context, entry: Entry, shaped: Shaped_Text,
// batch_start_idx, batch_end_idx : i32,
glyph_pack : #soa[]GlyphPackEntry,
glyph_pack : #soa[]Glyph_Pack_Entry,
position, scale : Vec2,
snap_width, snap_height : f32 )
{
@ -575,133 +570,144 @@ draw_text_batch :: #force_inline proc (ctx: ^Context, entry: ^Entry, shaped: ^Sh
}
}
GlyphBounds :: struct {
p0, p1 : Vec2
}
GlyphPackEntry :: struct {
bounds : GlyphBounds,
bounds_size : Vec2,
over_sample : Vec2,
translate : Vec2,
region_pos : Vec2,
region_size : Vec2,
lru_code : u64,
atlas_index : i32,
index : Glyph,
shape_id : i32,
region_kind : Atlas_Region_Kind,
in_atlas : b8,
should_cache : b8,
}
Glyph_Sub_Pack :: struct {
pack : #soa[]GlyphPackEntry,
num : i32
}
// Helper for draw_text, all raw text content should be confirmed to be either formatting or visible shapes before getting cached.
draw_text_shape :: #force_inline proc( ctx : ^Context,
generate_shape_draw_list :: #force_no_inline proc( ctx : ^Context,
font : Font_ID,
entry : ^Entry,
shaped : ^Shaped_Text,
entry : Entry,
shaped : Shaped_Text,
position, scale : Vec2,
snap_width, snap_height : f32
) -> (cursor_pos : Vec2) #no_bounds_check
{
profile(#procedure)
oversized : Glyph_Sub_Pack = {}
to_cache : Glyph_Sub_Pack = {}
cached : Glyph_Sub_Pack = {}
atlas := & ctx.atlas
glyph_buffer := & ctx.glyph_buffer
draw_list := & ctx.draw_list
colour := ctx.colour
atlas_glyph_pad := atlas.glyph_padding
atlas_size := Vec2 { f32(atlas.width), f32(atlas.height) }
profile_begin("soa allocation")
glyph_pack, glyph_pack_alloc_error := make_soa( #soa[]GlyphPackEntry, len(shaped.glyphs), allocator = context.temp_allocator )
alloc_error : Allocator_Error
oversized.pack, alloc_error = make_soa( #soa[]GlyphPackEntry, len(shaped.glyphs), allocator = context.temp_allocator )
to_cache.pack, alloc_error = make_soa( #soa[]GlyphPackEntry, len(shaped.glyphs), allocator = context.temp_allocator )
cached.pack, alloc_error = make_soa( #soa[]GlyphPackEntry, len(shaped.glyphs), allocator = context.temp_allocator )
// Make sure the packs are large enough for the shape
non_zero_resize_soa(& glyph_buffer.glyph_pack, len(shaped.glyphs))
glyph_pack := & glyph_buffer.glyph_pack
oversized := & glyph_buffer.oversized
to_cache := & glyph_buffer.to_cache
cached := & glyph_buffer.cached
append_sub_pack :: #force_inline proc ( pack : ^#soa[dynamic]Glyph_Pack_Entry, entry : Glyph_Pack_Entry )
{
raw := runtime.raw_soa_footer_dynamic_array(pack)
raw.len += 1
pack[len(pack) - 1] = entry
}
sub_slice :: #force_inline proc "contextless" ( pack : ^#soa[dynamic]Glyph_Pack_Entry) -> #soa[]Glyph_Pack_Entry { return pack[:] }
profile_end()
append_sub_pack :: #force_inline proc "contextless" ( sub : ^Glyph_Sub_Pack, entry : GlyphPackEntry )
// profile_begin("soa allocation")
// glyph_pack_, glyph_pack_alloc_error := make_soa( #soa[]Glyph_Pack_Entry, len(shaped.glyphs), allocator = context.temp_allocator )
// oversized_ : Glyph_Sub_Pack = {}
// to_cache_ : Glyph_Sub_Pack = {}
// cached_ : Glyph_Sub_Pack = {}
// glyph_pack := & glyph_pack_
// oversized := & oversized_
// to_cache := & to_cache_
// cached := & cached_
// alloc_error : Allocator_Error
// oversized.pack, alloc_error = make_soa( #soa[]Glyph_Pack_Entry, len(shaped.glyphs), allocator = context.temp_allocator )
// to_cache.pack, alloc_error = make_soa( #soa[]Glyph_Pack_Entry, len(shaped.glyphs), allocator = context.temp_allocator )
// cached.pack, alloc_error = make_soa( #soa[]Glyph_Pack_Entry, len(shaped.glyphs), allocator = context.temp_allocator )
// append_sub_pack :: #force_inline proc "contextless" ( sub : ^Glyph_Sub_Pack, entry : Glyph_Pack_Entry )
// {
// sub.pack[sub.num] = entry
// sub.num += 1
// }
// sub_slice :: #force_inline proc "contextless" ( sub : ^Glyph_Sub_Pack) -> #soa[]Glyph_Pack_Entry { return sub.pack[: sub.num] }
// profile_end()
profile_begin("index")
for & glyph, index in glyph_pack
{
sub.pack[sub.num] = entry
sub.num += 1
// glyph.shape_id = cast(i32) index
glyph.index = shaped.glyphs[ index ]
}
sub_slice :: #force_inline proc "contextless" ( sub : Glyph_Sub_Pack) -> #soa[]GlyphPackEntry { return sub.pack[: sub.num] }
profile_end()
atlas := & ctx.atlas
SOA_Setup:
profile_begin("translate")
for & glyph, index in glyph_pack
{
profile("SOA setup")
glyph.translate = position + (shaped.positions[index]) * scale
}
profile_end()
profile_begin("index & translate")
for & glyph, index in glyph_pack
{
glyph.shape_id = cast(i32) index
glyph.index = shaped.glyphs[ index ]
profile_begin("bounds")
for & glyph, index in glyph_pack
{
glyph.lru_code = font_glyph_lru_code(entry.id, glyph.index)
glyph.bounds = parser_get_bounds( entry.parser_info, glyph.index )
glyph.bounds_size = glyph.bounds.p1 - glyph.bounds.p0
}
profile_end()
profile_begin("region & oversized segregation")
for & glyph, index in glyph_pack
{
glyph.region_kind,
glyph.over_sample = decide_codepoint_region( ctx.atlas, ctx.glyph_buffer, entry.size_scale, glyph.index, glyph.bounds_size )
}
profile_end()
profile_begin("segregation")
for & glyph, index in glyph_pack
{
region := atlas.regions[glyph.region_kind]
if glyph.region_kind == .E {
append_sub_pack(oversized, glyph)
continue
}
profile_end()
profile_begin("translate")
for & glyph, index in glyph_pack
{
glyph.translate = position + (shaped.positions[index]) * scale
glyph.atlas_index = lru_get( & region.state, glyph.lru_code )
glyph.in_atlas, glyph.should_cache = check_and_reserve_slot_in_atlas( ctx ^, glyph.index, glyph.lru_code, & glyph.atlas_index, region )
glyph.region_pos, glyph.region_size = atlas_region_bbox(region ^, glyph.atlas_index)
if glyph.should_cache {
profile("append to_cache")
append_sub_pack(to_cache, glyph)
mark_batch_codepoint_seen(ctx, glyph.lru_code)
}
profile_end()
profile_begin("bounds")
for & glyph, index in glyph_pack
{
glyph.lru_code = font_glyph_lru_code(entry.id, glyph.index)
glyph.bounds = parser_get_bounds( & entry.parser_info, glyph.index )
glyph.bounds_size = glyph.bounds.p1 - glyph.bounds.p0
else {
profile("append cached")
append_sub_pack(cached, glyph)
mark_batch_codepoint_seen(ctx, glyph.lru_code)
}
profile_end()
}
profile_end()
profile_begin("region & oversized segregation")
for & glyph, index in glyph_pack
{
glyph.region_kind,
glyph.over_sample = decide_codepoint_region( ctx.atlas, ctx.glyph_buffer, entry.size_scale, glyph.index, glyph.bounds_size )
}
profile_end()
profile_begin("to_cache: font parser shape generation")
for & glyph, index in sub_slice(to_cache) {
error : Allocator_Error
glyph.shape, error = parser_get_glyph_shape(entry.parser_info, glyph.index)
assert(error == .None)
}
profile_end()
profile_begin("caching setup")
for & glyph, index in glyph_pack
{
region := atlas.regions[glyph.region_kind]
if glyph.region_kind == .E {
append_sub_pack(& oversized, glyph)
continue
}
glyph.atlas_index = lru_get( & region.state, glyph.lru_code )
glyph.in_atlas, glyph.should_cache = check_and_reserve_slot_in_atlas( ctx, glyph.index, glyph.lru_code, & glyph.atlas_index, region )
glyph.region_pos, glyph.region_size = atlas_region_bbox(region ^, glyph.atlas_index)
if glyph.should_cache {
profile("append to_cache")
append_sub_pack(& to_cache, glyph)
mark_batch_codepoint_seen(ctx, glyph.lru_code)
cache_glyph_to_atlas( ctx, font, glyph.index, glyph.bounds, glyph.bounds_size, glyph.region_pos, glyph.region_size, glyph.lru_code, glyph.atlas_index, entry, glyph.over_sample )
continue
}
else {
profile("append cached")
append_sub_pack(& cached, glyph)
mark_batch_codepoint_seen(ctx, glyph.lru_code)
}
}
profile_end()
profile_begin("to_cache: caching to atlas")
for & glyph, index in sub_slice(to_cache) {
cache_glyph_to_atlas( ctx, glyph.index, glyph.shape, glyph.bounds, glyph.bounds_size, glyph.region_pos, glyph.region_size, glyph.lru_code, glyph.atlas_index, entry, glyph.over_sample )
}
profile_end()
for & glyph, index in sub_slice(to_cache)
{
parser_free_shape(entry.parser_info, glyph.shape)
}
draw_text_batch( ctx, entry, shaped, sub_slice(to_cache), position, scale, snap_width, snap_height )
generate_cached_draw_list( ctx, entry, shaped, sub_slice(to_cache), position, scale, snap_width, snap_height )
reset_batch_codepoint_state( ctx )
draw_text_batch( ctx, entry, shaped, sub_slice(cached), position, scale, snap_width , snap_height )
generate_cached_draw_list( ctx, entry, shaped, sub_slice(cached), position, scale, snap_width , snap_height )
reset_batch_codepoint_state( ctx )
profile_begin("generate oversized glyphs draw_list")
@ -709,7 +715,7 @@ draw_text_shape :: #force_inline proc( ctx : ^Context,
for & glyph, index in sub_slice(oversized)
{
directly_draw_massive_glyph(ctx, entry, glyph.index,
generate_oversized_draw_list(ctx, entry, glyph.index, glyph.shape,
glyph.bounds,
glyph.bounds_size,
glyph.over_sample, glyph.translate, scale )
@ -717,6 +723,11 @@ draw_text_shape :: #force_inline proc( ctx : ^Context,
reset_batch_codepoint_state( ctx )
profile_end()
// clear_soa(& glyph_buffer.glyph_pack)
clear_soa(& glyph_buffer.oversized)
clear_soa(& glyph_buffer.to_cache)
clear_soa(& glyph_buffer.cached)
cursor_pos = position + shaped.end_cursor_pos * scale
return
@ -744,8 +755,15 @@ flush_glyph_buffer_to_atlas :: #force_inline proc( ctx : ^Context )
}
}
// ve_fontcache_clear_Draw_List
clear_draw_list :: #force_inline proc ( draw_list : ^Draw_List ) {
clear( & draw_list.calls )
clear( & draw_list.indices )
clear( & draw_list.vertices )
}
// ve_fontcache_merge_Draw_List
merge_draw_list :: #force_inline proc ( #no_alias dst, src : ^Draw_List )
merge_draw_list :: proc ( #no_alias dst, src : ^Draw_List )
{
profile(#procedure)
error : Allocator_Error

2
code/font/vefontcache/mappings.odin
View File

@ -120,7 +120,7 @@ vec2_64 :: proc {
import "../../grime"
DISABLE_PROFILING :: false
DISABLE_PROFILING :: true
@(deferred_none = profile_end, disabled = DISABLE_PROFILING)
profile :: #force_inline proc "contextless" ( name : string, loc := #caller_location ) {

5
code/font/vefontcache/misc.odin
View File

@ -44,6 +44,11 @@ reload_array :: proc( self : ^[dynamic]$Type, allocator : Allocator ) {
raw.allocator = allocator
}
reload_array_soa :: proc( self : ^#soa[dynamic]$Type, allocator : Allocator ) {
raw := runtime.raw_soa_footer(self)
raw.allocator = allocator
}
reload_map :: proc( self : ^map [$KeyType] $EntryType, allocator : Allocator ) {
raw := transmute( ^runtime.Raw_Map) self
raw.allocator = allocator

34
code/font/vefontcache/parser.odin
View File

@ -132,7 +132,7 @@ parser_find_glyph_index :: #force_inline proc "contextless" ( font : Parser_Font
return Glyph(-1)
}
parser_free_shape :: #force_inline proc( font : ^Parser_Font_Info, shape : Parser_Glyph_Shape )
parser_free_shape :: #force_inline proc( font : Parser_Font_Info, shape : Parser_Glyph_Shape )
{
switch font.kind
{
@ -140,11 +140,11 @@ parser_free_shape :: #force_inline proc( font : ^Parser_Font_Info, shape : Parse
delete(shape)
case .STB_TrueType:
stbtt.FreeShape( & font.stbtt_info, transmute( [^]stbtt.vertex) raw_data(shape) )
stbtt.FreeShape( font.stbtt_info, transmute( [^]stbtt.vertex) raw_data(shape) )
}
}
parser_get_codepoint_horizontal_metrics :: #force_inline proc "contextless" ( font : ^Parser_Font_Info, codepoint : rune ) -> ( advance, to_left_side_glyph : i32 )
parser_get_codepoint_horizontal_metrics :: #force_inline proc "contextless" ( font : Parser_Font_Info, codepoint : rune ) -> ( advance, to_left_side_glyph : i32 )
{
switch font.kind
{
@ -170,12 +170,12 @@ parser_get_codepoint_horizontal_metrics :: #force_inline proc "contextless" ( fo
}
case .STB_TrueType:
stbtt.GetCodepointHMetrics( & font.stbtt_info, codepoint, & advance, & to_left_side_glyph )
stbtt.GetCodepointHMetrics( font.stbtt_info, codepoint, & advance, & to_left_side_glyph )
}
return
}
parser_get_codepoint_kern_advance :: #force_inline proc "contextless" ( font : ^Parser_Font_Info, prev_codepoint, codepoint : rune ) -> i32
parser_get_codepoint_kern_advance :: #force_inline proc "contextless" ( font : Parser_Font_Info, prev_codepoint, codepoint : rune ) -> i32
{
switch font.kind
{
@ -198,13 +198,13 @@ parser_get_codepoint_kern_advance :: #force_inline proc "contextless" ( font : ^
}
case .STB_TrueType:
kern := stbtt.GetCodepointKernAdvance( & font.stbtt_info, prev_codepoint, codepoint )
kern := stbtt.GetCodepointKernAdvance( font.stbtt_info, prev_codepoint, codepoint )
return kern
}
return -1
}
parser_get_font_vertical_metrics :: #force_inline proc "contextless" ( font : ^Parser_Font_Info ) -> (ascent, descent, line_gap : i32 )
parser_get_font_vertical_metrics :: #force_inline proc "contextless" ( font : Parser_Font_Info ) -> (ascent, descent, line_gap : i32 )
{
switch font.kind
{
@ -215,12 +215,12 @@ parser_get_font_vertical_metrics :: #force_inline proc "contextless" ( font : ^P
line_gap = i32(info.height) - (ascent - descent)
case .STB_TrueType:
stbtt.GetFontVMetrics( & font.stbtt_info, & ascent, & descent, & line_gap )
stbtt.GetFontVMetrics( font.stbtt_info, & ascent, & descent, & line_gap )
}
return
}
parser_get_bounds :: #force_inline proc "contextless" ( font : ^Parser_Font_Info, glyph_index : Glyph ) -> (bounds : GlyphBounds)
parser_get_bounds :: #force_inline proc "contextless" ( font : Parser_Font_Info, glyph_index : Glyph ) -> (bounds : GlyphBounds)
{
profile(#procedure)
@ -238,7 +238,7 @@ parser_get_bounds :: #force_inline proc "contextless" ( font : ^Parser_Font_Info
case .STB_TrueType:
x0, y0, x1, y1 : i32
success := cast(bool) stbtt.GetGlyphBox( & font.stbtt_info, i32(glyph_index), & x0, & y0, & x1, & y1 )
success := cast(bool) stbtt.GetGlyphBox( font.stbtt_info, i32(glyph_index), & x0, & y0, & x1, & y1 )
// assert( success )
bounds_0 = { x0, y0 }
@ -248,7 +248,7 @@ parser_get_bounds :: #force_inline proc "contextless" ( font : ^Parser_Font_Info
return
}
parser_get_glyph_shape :: #force_inline proc ( font : ^Parser_Font_Info, glyph_index : Glyph ) -> (shape : Parser_Glyph_Shape, error : Allocator_Error)
parser_get_glyph_shape :: #force_inline proc ( font : Parser_Font_Info, glyph_index : Glyph ) -> (shape : Parser_Glyph_Shape, error : Allocator_Error)
{
switch font.kind
{
@ -258,7 +258,7 @@ parser_get_glyph_shape :: #force_inline proc ( font : ^Parser_Font_Info, glyph_i
case .STB_TrueType:
stb_shape : [^]stbtt.vertex
nverts := stbtt.GetGlyphShape( & font.stbtt_info, cast(i32) glyph_index, & stb_shape )
nverts := stbtt.GetGlyphShape( font.stbtt_info, cast(i32) glyph_index, & stb_shape )
shape_raw := transmute( ^runtime.Raw_Dynamic_Array) & shape
shape_raw.data = stb_shape
@ -295,7 +295,7 @@ parser_is_glyph_empty :: #force_inline proc "contextless" ( font : Parser_Font_I
return false
}
parser_scale :: #force_inline proc "contextless" ( font : ^Parser_Font_Info, size : f32 ) -> f32
parser_scale :: #force_inline proc "contextless" ( font : Parser_Font_Info, size : f32 ) -> f32
{
size_scale := size < 0.0 ? \
parser_scale_for_pixel_height( font, -size ) \
@ -304,7 +304,7 @@ parser_scale :: #force_inline proc "contextless" ( font : ^Parser_Font_Info, siz
return size_scale
}
parser_scale_for_pixel_height :: #force_inline proc "contextless" ( font : ^Parser_Font_Info, size : f32 ) -> f32
parser_scale_for_pixel_height :: #force_inline proc "contextless" ( font : Parser_Font_Info, size : f32 ) -> f32
{
switch font.kind {
case .Freetype:
@ -313,12 +313,12 @@ parser_scale_for_pixel_height :: #force_inline proc "contextless" ( font : ^Pars
return size_scale
case.STB_TrueType:
return stbtt.ScaleForPixelHeight( & font.stbtt_info, size )
return stbtt.ScaleForPixelHeight( font.stbtt_info, size )
}
return 0
}
parser_scale_for_mapping_em_to_pixels :: #force_inline proc "contextless" ( font : ^Parser_Font_Info, size : f32 ) -> f32
parser_scale_for_mapping_em_to_pixels :: #force_inline proc "contextless" ( font : Parser_Font_Info, size : f32 ) -> f32
{
switch font.kind {
case .Freetype:
@ -342,7 +342,7 @@ parser_scale_for_mapping_em_to_pixels :: #force_inline proc "contextless" ( font
return size_scale
case .STB_TrueType:
return stbtt.ScaleForMappingEmToPixels( & font.stbtt_info, size )
return stbtt.ScaleForMappingEmToPixels( font.stbtt_info, size )
}
return 0
}

39
code/font/vefontcache/shaped_text.odin
View File

@ -1,6 +1,9 @@
package vefontcache
Shaped_Text :: struct {
font : Font_ID,
entry : ^Entry,
glyphs : [dynamic]Glyph,
positions : [dynamic]Vec2,
end_cursor_pos : Vec2,
@ -19,9 +22,9 @@ shape_lru_hash :: #force_inline proc "contextless" ( hash : ^u64, bytes : []byte
}
}
ShapedTextUncachedProc :: #type proc( ctx : ^Context, font : Font_ID, text_utf8 : string, entry : ^Entry, output : ^Shaped_Text )
ShapedTextUncachedProc :: #type proc( ctx : ^Context, font : Font_ID, text_utf8 : string, entry : Entry, output : ^Shaped_Text )
shape_text_cached :: proc( ctx : ^Context, font : Font_ID, text_utf8 : string, entry : ^Entry, shape_text_uncached : ShapedTextUncachedProc ) -> ^Shaped_Text #no_bounds_check
shaper_shape_text_cached :: #force_inline proc( ctx : ^Context, font : Font_ID, text_utf8 : string, entry : Entry, shape_text_uncached : $ShapedTextUncachedProc ) -> (shaped_text : Shaped_Text)
{
profile(#procedure)
font := font
@ -45,23 +48,27 @@ shape_text_cached :: proc( ctx : ^Context, font : Font_ID, text_utf8 : string, e
}
else
{
next_evict_idx := lru_get_next_evicted( state )
assert( next_evict_idx != 0xFFFFFFFFFFFFFFFF )
next_evict_idx := lru_get_next_evicted( state ^ )
// assert( next_evict_idx != 0xFFFFFFFFFFFFFFFF )
shape_cache_idx = lru_peek( state, next_evict_idx, must_find = true )
assert( shape_cache_idx != - 1 )
shape_cache_idx = lru_peek( state ^, next_evict_idx, must_find = true )
// assert( shape_cache_idx != - 1 )
lru_put( state, lru_code, shape_cache_idx )
}
shape_entry := & shape_cache.storage[ shape_cache_idx ]
shape_text_uncached( ctx, font, text_utf8, entry, shape_entry )
storage_entry := & shape_cache.storage[ shape_cache_idx ]
shape_text_uncached( ctx, font, text_utf8, entry, storage_entry )
shaped_text = storage_entry ^
return
}
return & shape_cache.storage[ shape_cache_idx ]
shaped_text = shape_cache.storage[ shape_cache_idx ]
return
}
shape_text_uncached_advanced :: #force_inline proc( ctx : ^Context, font : Font_ID, text_utf8 : string, entry : ^Entry, output : ^Shaped_Text )
shaper_shape_text_uncached_advanced :: #force_inline proc( ctx : ^Context, font : Font_ID, text_utf8 : string, entry : Entry, output : ^Shaped_Text )
{
profile(#procedure)
assert( ctx != nil )
@ -70,16 +77,16 @@ shape_text_uncached_advanced :: #force_inline proc( ctx : ^Context, font : Font_
clear( & output.glyphs )
clear( & output.positions )
ascent_i32, descent_i32, line_gap_i32 := parser_get_font_vertical_metrics( & entry.parser_info )
ascent_i32, descent_i32, line_gap_i32 := parser_get_font_vertical_metrics( entry.parser_info )
ascent := f32(ascent_i32)
descent := f32(descent_i32)
line_gap := f32(line_gap_i32)
line_height := (ascent - descent + line_gap) * entry.size_scale
shaper_shape_from_text( & ctx.shaper_ctx, entry.parser_info, & entry.shaper_info, output, text_utf8, ascent_i32, descent_i32, line_gap_i32, entry.size, entry.size_scale )
shaper_shape_from_text( & ctx.shaper_ctx, entry.parser_info, entry.shaper_info, output, text_utf8, ascent_i32, descent_i32, line_gap_i32, entry.size, entry.size_scale )
}
shape_text_uncached_latin :: proc( ctx : ^Context, font : Font_ID, text_utf8 : string, entry : ^Entry, output : ^Shaped_Text )
shaper_shape_from_text_latin :: #force_inline proc( ctx : ^Context, font : Font_ID, text_utf8 : string, entry : Entry, output : ^Shaped_Text )
{
profile(#procedure)
assert( ctx != nil )
@ -88,7 +95,7 @@ shape_text_uncached_latin :: proc( ctx : ^Context, font : Font_ID, text_utf8 : s
clear( & output.glyphs )
clear( & output.positions )
ascent_i32, descent_i32, line_gap_i32 := parser_get_font_vertical_metrics( & entry.parser_info )
ascent_i32, descent_i32, line_gap_i32 := parser_get_font_vertical_metrics( entry.parser_info )
ascent := f32(ascent_i32)
descent := f32(descent_i32)
line_gap := f32(line_gap_i32)
@ -102,7 +109,7 @@ shape_text_uncached_latin :: proc( ctx : ^Context, font : Font_ID, text_utf8 : s
for codepoint, index in text_utf8
{
if prev_codepoint > 0 {
kern := parser_get_codepoint_kern_advance( & entry.parser_info, prev_codepoint, codepoint )
kern := parser_get_codepoint_kern_advance( entry.parser_info, prev_codepoint, codepoint )
position.x += f32(kern) * entry.size_scale
}
if codepoint == '\n'
@ -130,7 +137,7 @@ shape_text_uncached_latin :: proc( ctx : ^Context, font : Font_ID, text_utf8 : s
})
}
advance, _ := parser_get_codepoint_horizontal_metrics( & entry.parser_info, codepoint )
advance, _ := parser_get_codepoint_horizontal_metrics( entry.parser_info, codepoint )
position.x += f32(advance) * entry.size_scale
prev_codepoint = codepoint
}

4
code/font/vefontcache/shaper.odin
View File

@ -54,7 +54,7 @@ shaper_unload_font :: proc( ctx : ^Shaper_Info )
if blob != nil do harfbuzz.blob_destroy( blob )
}
shaper_shape_from_text :: #force_inline proc( ctx : ^Shaper_Context, parser_info : Parser_Font_Info, info : ^Shaper_Info, output :^Shaped_Text, text_utf8 : string,
shaper_shape_from_text :: #force_inline proc( ctx : ^Shaper_Context, parser_info : Parser_Font_Info, info : Shaper_Info, output :^Shaped_Text, text_utf8 : string,
ascent, descent, line_gap : i32, size, size_scale : f32 )
{
profile(#procedure)
@ -72,7 +72,7 @@ shaper_shape_from_text :: #force_inline proc( ctx : ^Shaper_Context, parser_info
line_height := ((ascent - descent + line_gap) * size_scale)
position : Vec2
shape_run :: #force_inline proc( parser_info : Parser_Font_Info, buffer : harfbuzz.Buffer, script : harfbuzz.Script, font : harfbuzz.Font, output : ^Shaped_Text,
shape_run :: proc( parser_info : Parser_Font_Info, buffer : harfbuzz.Buffer, script : harfbuzz.Script, font : harfbuzz.Font, output : ^Shaped_Text,
position : ^Vec2, max_line_width: ^f32, line_count: ^int,
ascent, descent, line_gap, size, size_scale: f32,
snap_shape_pos : b32, adv_snap_small_font_threshold : f32 )

131
code/font/vefontcache/vefontcache.odin
View File

@ -21,9 +21,13 @@ Entry :: struct {
}
Entry_Default :: Entry {
id = 0,
used = false,
size = 24.0,
id = 0,
used = false,
curve_quality = 2,
// TODO(Ed): Remove size information. Its not conceptually needed.
// The size_scale can be computed only the fly when needed for a font.
size = 24.0,
size_scale = 1.0,
}
@ -147,10 +151,10 @@ startup :: proc( ctx : ^Context, parser_kind : Parser_Kind = .STB_TrueType,
glyph_draw_params := Init_Glyph_Draw_Params_Default,
shape_cache_params := Init_Shape_Cache_Params_Default,
shaper_params := Init_Shaper_Params_Default,
default_curve_quality : u32 = 8 * 2,
entires_reserve : u32 = 8 * 256,
temp_path_reserve : u32 = 8 * 1024,
temp_codepoint_seen_reserve : u32 = 8 * 1024,
default_curve_quality : u32 = 2,
entires_reserve : u32 = 256,
temp_path_reserve : u32 = 1024,
temp_codepoint_seen_reserve : u32 = 1024,
)
{
assert( ctx != nil, "Must provide a valid context" )
@ -282,6 +286,15 @@ startup :: proc( ctx : ^Context, parser_kind : Parser_Kind = .STB_TrueType,
clear_draw_list.vertices, error = make( [dynamic]Vertex, len = 0, cap = glyph_draw_params.buffer_batch * 2 * 4 )
assert( error == .None, "VEFontCache.init : Failed to allocate vertices array for clear_draw_list" )
glyph_pack,error = make_soa( #soa[dynamic]Glyph_Pack_Entry, length = 0, capacity = 1 * Kilobyte, allocator = context.temp_allocator )
oversized, error = make_soa( #soa[dynamic]Glyph_Pack_Entry, length = 0, capacity = 1 * Kilobyte, allocator = context.temp_allocator )
to_cache, error = make_soa( #soa[dynamic]Glyph_Pack_Entry, length = 0, capacity = 1 * Kilobyte, allocator = context.temp_allocator )
cached, error = make_soa( #soa[dynamic]Glyph_Pack_Entry, length = 0, capacity = 1 * Kilobyte, allocator = context.temp_allocator )
// resize_soa(& glyph_pack, 1 * Kilobyte)
// resize_soa(& oversized, 1 * Kilobyte)
// resize_soa(& to_cache, 1 * Kilobyte)
// resize_soa(& cached, 1 * Kilobyte)
}
parser_init( & parser_ctx, parser_kind )
@ -325,6 +338,11 @@ hot_reload :: proc( ctx : ^Context, allocator : Allocator )
reload_array( & glyph_buffer.clear_draw_list.indices, allocator )
reload_array( & glyph_buffer.clear_draw_list.vertices, allocator )
reload_array_soa( & glyph_buffer.glyph_pack, allocator )
reload_array_soa( & glyph_buffer.oversized, allocator )
reload_array_soa( & glyph_buffer.to_cache, allocator )
reload_array_soa( & glyph_buffer.cached, allocator )
reload_array( & shape_cache.storage, allocator )
}
@ -369,6 +387,11 @@ shutdown :: proc( ctx : ^Context )
delete( glyph_buffer.clear_draw_list.indices )
delete( glyph_buffer.clear_draw_list.calls )
delete_soa( glyph_buffer.glyph_pack)
delete_soa( glyph_buffer.oversized)
delete_soa( glyph_buffer.to_cache)
delete_soa( glyph_buffer.cached)
shaper_shutdown( & shaper_ctx )
parser_shutdown( & parser_ctx )
}
@ -403,7 +426,7 @@ load_font :: proc( ctx : ^Context, label : string, data : []byte, size_px : f32,
shaper_info = shaper_load_font( & shaper_ctx, label, data )
size = size_px
size_scale = parser_scale( & parser_info, size )
size_scale = parser_scale( parser_info, size )
if glyph_curve_quality == 0 {
curve_quality = f32(ctx.default_curve_quality)
@ -457,24 +480,54 @@ draw_text :: #force_inline proc( ctx : ^Context, font : Font_ID, text_utf8 : str
ctx.cursor_pos = {}
position := position
if ctx.snap_width > 0 do position.x = ceil(position.x * ctx.snap_width ) / ctx.snap_width
if ctx.snap_height > 0 do position.y = ceil(position.y * ctx.snap_height) / ctx.snap_height
position.x = ceil(position.x * ctx.snap_width ) / ctx.snap_width
position.y = ceil(position.y * ctx.snap_height) / ctx.snap_height
entry := & ctx.entries[ font ]
entry := ctx.entries[ font ]
ChunkType :: enum u32 { Visible, Formatting }
chunk_kind : ChunkType
chunk_start : int = 0
chunk_end : int = 0
shape := shaper_shape_text_cached( ctx, font, text_utf8, entry, shaper_shape_text_uncached_advanced )
ctx.cursor_pos = generate_shape_draw_list( ctx, font, entry, shape, position, scale, ctx.snap_width, ctx.snap_height )
return true
}
text_utf8_bytes := transmute([]u8) text_utf8
text_chunk : string
draw_text_no_snap :: #force_inline proc( ctx : ^Context, font : Font_ID, text_utf8 : string, position, scale : Vec2 ) -> b32
{
profile(#procedure)
assert( ctx != nil )
assert( font >= 0 && int(font) < len(ctx.entries) )
text_chunk = transmute(string) text_utf8_bytes[ : ]
if len(text_chunk) > 0 {
shaped := shape_text_cached( ctx, font, text_chunk, entry, shape_text_uncached_advanced )
ctx.cursor_pos = draw_text_shape( ctx, font, entry, shaped, position, scale, ctx.snap_width, ctx.snap_height )
}
ctx.cursor_pos = {}
entry := ctx.entries[ font ]
shape := shaper_shape_text_cached( ctx, font, text_utf8, entry, shaper_shape_text_uncached_advanced )
ctx.cursor_pos = generate_shape_draw_list( ctx, font, entry, shape, position, scale, ctx.snap_width, ctx.snap_height )
return true
}
// For high performance: Resolve the shape and track it to reduce iteration overhead
draw_text_shape :: #force_inline proc( ctx : ^Context, font : Font_ID, shape : Shaped_Text, position, scale : Vec2 ) -> b32
{
profile(#procedure)
assert( ctx != nil )
assert( font >= 0 && int(font) < len(ctx.entries) )
position := position
position.x = ceil(position.x * ctx.snap_width ) / ctx.snap_width
position.y = ceil(position.y * ctx.snap_height) / ctx.snap_height
entry := ctx.entries[ font ]
ctx.cursor_pos = generate_shape_draw_list( ctx, font, entry, shape, position, scale, ctx.snap_width, ctx.snap_height )
return true
}
// For high performance: Resolve the shape and track it to reduce iteration overhead
draw_text_shape_no_snap :: #force_inline proc( ctx : ^Context, font : Font_ID, shape : Shaped_Text, position, scale : Vec2 ) -> b32
{
profile(#procedure)
assert( ctx != nil )
assert( font >= 0 && int(font) < len(ctx.entries) )
entry := ctx.entries[ font ]
ctx.cursor_pos = generate_shape_draw_list( ctx, font, entry, shape, position, scale, ctx.snap_width, ctx.snap_height )
return true
}
@ -522,8 +575,8 @@ measure_text_size :: #force_inline proc( ctx : ^Context, font : Font_ID, text_ut
assert( ctx != nil )
assert( font >= 0 && int(font) < len(ctx.entries) )
entry := &ctx.entries[font]
shaped := shape_text_cached(ctx, font, text_utf8, entry, shape_text_uncached_advanced )
entry := ctx.entries[font]
shaped := shaper_shape_text_cached(ctx, font, text_utf8, entry, shaper_shape_text_uncached_advanced )
return shaped.size
}
@ -533,7 +586,7 @@ get_font_vertical_metrics :: #force_inline proc ( ctx : ^Context, font : Font_ID
assert( font >= 0 && int(font) < len(ctx.entries) )
entry := & ctx.entries[ font ]
ascent_i32, descent_i32, line_gap_i32 := parser_get_font_vertical_metrics( & entry.parser_info )
ascent_i32, descent_i32, line_gap_i32 := parser_get_font_vertical_metrics( entry.parser_info )
ascent = (f32(ascent_i32) * entry.size_scale)
descent = (f32(descent_i32) * entry.size_scale)
@ -543,6 +596,34 @@ get_font_vertical_metrics :: #force_inline proc ( ctx : ^Context, font : Font_ID
//#endregion("metrics")
//#region("shaping")
shape_text_latin :: #force_inline proc( ctx : ^Context, font : Font_ID, text_utf8 : string, allocator := context.allocator ) -> Shaped_Text
{
entry := ctx.entries[ font ]
return shaper_shape_text_cached( ctx, font, text_utf8, entry, shaper_shape_from_text_latin )
}
shape_text_advanced :: #force_inline proc( ctx : ^Context, font : Font_ID, text_utf8 : string ) -> Shaped_Text
{
entry := ctx.entries[ font ]
return shaper_shape_text_cached( ctx, font, text_utf8, entry, shaper_shape_text_uncached_advanced )
}
// User handled shaped text. Will not be cached
shape_text_latin_uncached :: #force_inline proc( ctx : ^Context, font : Font_ID, text_utf8 : string, entry : ^Entry, allocator := context.allocator ) -> Shaped_Text
{
return {}
}
// User handled shaped text. Will not be cached
shape_text_advanced_uncahed :: #force_inline proc( ctx : ^Context, font : Font_ID, text_utf8 : string, entry : ^Entry, allocator := context.allocator ) -> Shaped_Text
{
return {}
}
//#endregion("shaping")
// Can be used with hot-reload
clear_atlas_region_caches :: proc(ctx : ^Context)
{