mirror of
https://github.com/Ed94/VEFontCache-Odin.git
synced 2025-08-05 14:42:42 -07:00
731 lines
29 KiB
Odin
731 lines
29 KiB
Odin
package sokol_demo
|
||
|
||
import "base:runtime"
|
||
import "core:path/filepath"
|
||
file_name_from_path :: filepath.short_stem
|
||
import "core:fmt"
|
||
import "core:math"
|
||
import "core:math/rand"
|
||
import "core:mem"
|
||
import "core:os"
|
||
import "core:strings"
|
||
|
||
import ve "../../vefontcache"
|
||
import ve_sokol "backend:sokol"
|
||
import app "thirdparty:sokol/app"
|
||
import gfx "thirdparty:sokol/gfx"
|
||
import glue "thirdparty:sokol/glue"
|
||
import slog "thirdparty:sokol/log"
|
||
|
||
Vec2 :: ve.Vec2
|
||
|
||
RGBA8 :: struct { r, g, b, a : u8 }
|
||
RGBAN :: [4]f32
|
||
|
||
normalize_rgba8 :: #force_inline proc( color : RGBA8 ) -> RGBAN {
|
||
quotient : f32 = 1.0 / 255
|
||
|
||
result := RGBAN {
|
||
f32(color.r) * quotient,
|
||
f32(color.g) * quotient,
|
||
f32(color.b) * quotient,
|
||
f32(color.a) * quotient,
|
||
}
|
||
return result
|
||
}
|
||
|
||
COLOR_BLUE :: RGBA8 { 90, 90, 230, 255 }
|
||
COLOR_RED :: RGBA8 { 230, 90, 90, 255 }
|
||
COLOR_WHITE :: RGBA8 { 255, 255, 255, 255 }
|
||
|
||
FONT_LARGEST_PIXEL_SIZE :: 400
|
||
FONT_SIZE_INTERVAL :: 2
|
||
|
||
FONT_DEFAULT :: Font_ID { "" }
|
||
FONT_DEFAULT_SIZEZ :: 12.0
|
||
|
||
FONT_LOAD_USE_DEFAULT_SIZE :: -1
|
||
FONT_LOAD_GEN_ID :: ""
|
||
|
||
// Working directory assumed to be the build folder
|
||
PATH_FONTS :: "../fonts/"
|
||
|
||
OVER_SAMPLE_ZOOM : f32 : 2.0 // Adjust this value as needed, used by draw_text_zoomed_norm
|
||
|
||
Font_ID :: struct {
|
||
label : string,
|
||
}
|
||
|
||
FontDef :: struct {
|
||
path_file : string,
|
||
default_size : i32,
|
||
size_table : [FONT_LARGEST_PIXEL_SIZE / FONT_SIZE_INTERVAL] ve.Font_ID,
|
||
}
|
||
|
||
Demo_Context :: struct {
|
||
ve_ctx : ve.Context,
|
||
render_ctx : ve_sokol.Context,
|
||
font_ids : map[string]FontDef,
|
||
|
||
// Values between 1, & -1 on Y axis
|
||
mouse_scroll : Vec2,
|
||
|
||
font_firacode : Font_ID,
|
||
font_logo : Font_ID,
|
||
font_title : Font_ID,
|
||
font_print : Font_ID,
|
||
font_mono : Font_ID,
|
||
font_small : Font_ID,
|
||
font_demo_sans : Font_ID,
|
||
font_demo_serif : Font_ID,
|
||
font_demo_script : Font_ID,
|
||
font_demo_mono : Font_ID,
|
||
font_demo_chinese : Font_ID,
|
||
font_demo_japanese : Font_ID,
|
||
font_demo_korean : Font_ID,
|
||
font_demo_thai : Font_ID,
|
||
font_demo_arabic : Font_ID,
|
||
font_demo_hebrew : Font_ID,
|
||
font_demo_raincode : Font_ID,
|
||
font_demo_grid2 : Font_ID,
|
||
font_demo_grid3 : Font_ID,
|
||
|
||
screen_size : [2]f32,
|
||
}
|
||
|
||
demo_ctx : Demo_Context
|
||
|
||
font_load :: proc(path_file : string,
|
||
default_size : i32 = FONT_LOAD_USE_DEFAULT_SIZE,
|
||
desired_id : string = FONT_LOAD_GEN_ID,
|
||
curve_quality : u32 = 3,
|
||
) -> Font_ID
|
||
{
|
||
msg := fmt.println("Loading font: %v", path_file)
|
||
|
||
font_data, read_succeded : = os.read_entire_file( path_file )
|
||
assert( bool(read_succeded), fmt.tprintf("Failed to read font file for: %v", path_file) )
|
||
font_data_size := cast(i32) len(font_data)
|
||
font_firacode : Font_ID
|
||
|
||
|
||
desired_id := desired_id
|
||
if len(desired_id) == 0 {
|
||
fmt.println("desired_key not provided, using file name. Give it a proper name!")
|
||
desired_id = file_name_from_path(path_file)
|
||
}
|
||
|
||
demo_ctx.font_ids[desired_id] = FontDef {}
|
||
def := & demo_ctx.font_ids[desired_id]
|
||
|
||
default_size := default_size
|
||
if default_size < 0 {
|
||
default_size = FONT_DEFAULT_SIZEZ
|
||
}
|
||
|
||
def.path_file = path_file
|
||
def.default_size = default_size
|
||
|
||
for font_size : i32 = clamp( FONT_SIZE_INTERVAL, 2, FONT_SIZE_INTERVAL ); font_size <= FONT_LARGEST_PIXEL_SIZE; font_size += FONT_SIZE_INTERVAL
|
||
{
|
||
id := (font_size / FONT_SIZE_INTERVAL) + (font_size % FONT_SIZE_INTERVAL)
|
||
ve_id := & def.size_table[id - 1]
|
||
ve_ret_id := ve.load_font( & demo_ctx.ve_ctx, desired_id, font_data, f32(font_size), curve_quality )
|
||
(ve_id^) = ve_ret_id
|
||
}
|
||
|
||
fid := Font_ID { desired_id }
|
||
return fid
|
||
}
|
||
|
||
Font_Use_Default_Size :: f32(0.0)
|
||
|
||
font_resolve_draw_id :: proc( id : Font_ID, size := Font_Use_Default_Size ) -> ( ve_id : ve.Font_ID, resolved_size : i32 )
|
||
{
|
||
def := demo_ctx.font_ids[ id.label ]
|
||
size := size == 0.0 ? f32(def.default_size) : size
|
||
even_size := math.round(size * (1.0 / f32(FONT_SIZE_INTERVAL))) * f32(FONT_SIZE_INTERVAL)
|
||
resolved_size = clamp( i32( even_size), 2, FONT_LARGEST_PIXEL_SIZE )
|
||
|
||
id := (resolved_size / FONT_SIZE_INTERVAL) + (resolved_size % FONT_SIZE_INTERVAL)
|
||
ve_id = def.size_table[ id - 1 ]
|
||
return
|
||
}
|
||
|
||
measure_text_size :: proc( text : string, font : Font_ID, font_size := Font_Use_Default_Size, spacing : f32 ) -> Vec2
|
||
{
|
||
ve_id, size := font_resolve_draw_id( font, font_size )
|
||
measured := ve.measure_text_size( & demo_ctx.ve_ctx, ve_id, text )
|
||
return measured
|
||
}
|
||
|
||
get_font_vertical_metrics :: #force_inline proc ( font : Font_ID, font_size := Font_Use_Default_Size ) -> ( ascent, descent, line_gap : f32 )
|
||
{
|
||
ve_id, size := font_resolve_draw_id( font, font_size )
|
||
ascent, descent, line_gap = ve.get_font_vertical_metrics( & demo_ctx.ve_ctx, ve_id )
|
||
return
|
||
}
|
||
|
||
// Draw text using a string and normalized render coordinates
|
||
draw_text_string_pos_norm :: proc( content : string, id : Font_ID, size : f32, pos : Vec2, color := COLOR_WHITE, scale : f32 = 1.0 )
|
||
{
|
||
width := demo_ctx.screen_size.x
|
||
height := demo_ctx.screen_size.y
|
||
|
||
ve_id, resolved_size := font_resolve_draw_id( id, size )
|
||
color_norm := normalize_rgba8(color)
|
||
|
||
ve.set_colour( & demo_ctx.ve_ctx, color_norm )
|
||
ve.draw_text( & demo_ctx.ve_ctx, ve_id, content, pos, Vec2{1 / width, 1 / height} * scale )
|
||
return
|
||
}
|
||
|
||
// Draw text using a string and extent-based screen coordinates
|
||
draw_text_string_pos_extent :: proc( content : string, id : Font_ID, size : f32, pos : Vec2, color := COLOR_WHITE ) {
|
||
render_pos := pos + demo_ctx.screen_size * 0.5
|
||
normalized_pos := render_pos * (1.0 / demo_ctx.screen_size)
|
||
draw_text_string_pos_norm( content, id, size, normalized_pos, color )
|
||
}
|
||
|
||
// Adapt the draw_text_string_pos_extent_zoomed procedure
|
||
draw_text_zoomed_norm :: proc(content : string, id : Font_ID, size : f32, pos : Vec2, zoom : f32, color := COLOR_WHITE)
|
||
{
|
||
screen_size := demo_ctx.screen_size
|
||
screen_scale := Vec2{1.0 / screen_size.x, 1.0 / screen_size.y}
|
||
zoom_adjust_size := size * zoom
|
||
|
||
// Over-sample font-size
|
||
|
||
zoom_adjust_size *= OVER_SAMPLE_ZOOM
|
||
|
||
ve_id, resolved_size := font_resolve_draw_id(id, zoom_adjust_size)
|
||
|
||
text_scale := screen_scale
|
||
{
|
||
f32_resolved_size := f32(resolved_size)
|
||
diff_scalar := 1 + (zoom_adjust_size - f32_resolved_size) / f32_resolved_size
|
||
text_scale = diff_scalar * screen_scale
|
||
text_scale.x = clamp(text_scale.x, 0, 1)
|
||
text_scale.y = clamp(text_scale.y, 0, 1)
|
||
}
|
||
|
||
// Down-sample back
|
||
text_scale /= OVER_SAMPLE_ZOOM
|
||
|
||
color_norm := normalize_rgba8(color)
|
||
ve.set_colour(&demo_ctx.ve_ctx, color_norm)
|
||
ve.draw_text(&demo_ctx.ve_ctx, ve_id, content, pos, text_scale)
|
||
}
|
||
|
||
sokol_app_alloc :: proc "c" ( size : u64, user_data : rawptr ) -> rawptr {
|
||
context = runtime.default_context()
|
||
block, error := mem.alloc( int(size), allocator = context.allocator )
|
||
assert(error == .None, "sokol_app allocation failed")
|
||
return block
|
||
}
|
||
|
||
sokol_app_free :: proc "c" ( data : rawptr, user_data : rawptr ) {
|
||
context = runtime.default_context()
|
||
free(data, allocator = context.allocator)
|
||
}
|
||
|
||
sokol_gfx_alloc :: proc "c" ( size : u64, user_data : rawptr ) -> rawptr {
|
||
context = runtime.default_context()
|
||
block, error := mem.alloc( int(size), allocator = context.allocator )
|
||
assert(error == .None, "sokol_gfx allocation failed")
|
||
return block
|
||
}
|
||
|
||
sokol_gfx_free :: proc "c" ( data : rawptr, user_data : rawptr ) {
|
||
context = runtime.default_context()
|
||
free(data, allocator = context.allocator )
|
||
}
|
||
|
||
init :: proc "c" ()
|
||
{
|
||
context = runtime.default_context()
|
||
desc := gfx.Desc {
|
||
buffer_pool_size = 128,
|
||
image_pool_size = 128,
|
||
sampler_pool_size = 64,
|
||
shader_pool_size = 32,
|
||
pipeline_pool_size = 64,
|
||
attachments_pool_size = 16,
|
||
uniform_buffer_size = 4 * mem.Megabyte,
|
||
max_commit_listeners = 1024,
|
||
allocator = { sokol_gfx_alloc, sokol_gfx_free, nil },
|
||
logger = { func = slog.func },
|
||
environment = glue.environment(),
|
||
}
|
||
gfx.setup(desc)
|
||
|
||
// just some debug output what backend we're running on
|
||
switch gfx.query_backend() {
|
||
case .D3D11 : fmt.println(">> using D3D11 backend")
|
||
case .GLCORE, .GLES3: fmt.println(">> using GL backend")
|
||
|
||
case .METAL_MACOS, .METAL_IOS, .METAL_SIMULATOR:
|
||
fmt.println(">> using Metal backend")
|
||
|
||
case .WGPU : fmt.println(">> using WebGPU backend")
|
||
case .DUMMY: fmt.println(">> using dummy backend")
|
||
}
|
||
|
||
ve.startup( & demo_ctx.ve_ctx, .STB_TrueType, allocator = context.allocator, snap_shape_position = false, use_advanced_text_shaper = true )
|
||
ve_sokol.setup_gfx_objects( & demo_ctx.render_ctx, & demo_ctx.ve_ctx, vert_cap = 1024 * 1024, index_cap = 1024 * 1024 )
|
||
|
||
error : mem.Allocator_Error
|
||
demo_ctx.font_ids, error = make( map[string]FontDef, 256 )
|
||
assert( error == .None, "Failed to allocate demo_ctx.font_ids" )
|
||
|
||
path_sawarabi_mincho := strings.concatenate({ PATH_FONTS, "SawarabiMincho-Regular.ttf" })
|
||
path_open_sans := strings.concatenate({ PATH_FONTS, "OpenSans-Regular.ttf" })
|
||
path_noto_sans_jp := strings.concatenate({ PATH_FONTS, "NotoSansJP-Light.otf" })
|
||
path_ubuntu_mono := strings.concatenate({ PATH_FONTS, "UbuntuMono-Regular.ttf" })
|
||
path_roboto := strings.concatenate({ PATH_FONTS, "Roboto-Regular.ttf" })
|
||
path_bitter := strings.concatenate({ PATH_FONTS, "Bitter-Regular.ttf" })
|
||
path_dancing_script := strings.concatenate({ PATH_FONTS, "DancingScript-Regular.ttf" })
|
||
path_nova_mono := strings.concatenate({ PATH_FONTS, "NovaMono-Regular.ttf" })
|
||
path_noto_serif_sc := strings.concatenate({ PATH_FONTS, "NotoSerifSC-Regular.otf" })
|
||
path_nanum_pen_script := strings.concatenate({ PATH_FONTS, "NanumPenScript-Regular.ttf" })
|
||
path_krub := strings.concatenate({ PATH_FONTS, "Krub-Regular.ttf" })
|
||
path_tajawal := strings.concatenate({ PATH_FONTS, "Tajawal-Regular.ttf" })
|
||
path_david_libre := strings.concatenate({ PATH_FONTS, "DavidLibre-Regular.ttf" })
|
||
path_noto_sans_jp_reg := strings.concatenate({ PATH_FONTS, "NotoSansJP-Regular.otf" })
|
||
path_firacode := strings.concatenate({ PATH_FONTS, "FiraCode-Regular.ttf" })
|
||
|
||
using demo_ctx
|
||
font_logo = font_load(path_sawarabi_mincho, 330.0, "SawarabiMincho", 6 )
|
||
font_title = font_load(path_open_sans, 92.0, "OpenSans", 12 )
|
||
font_print = font_load(path_noto_sans_jp, 19.0, "NotoSansJP")
|
||
font_mono = font_load(path_ubuntu_mono, 21.0, "UbuntuMono")
|
||
font_small = font_load(path_roboto, 10.0, "Roboto")
|
||
font_demo_sans = font_load(path_open_sans, 18.0, "OpenSans")
|
||
font_demo_serif = font_load(path_bitter, 18.0, "Bitter")
|
||
font_demo_script = font_load(path_dancing_script, 22.0, "DancingScript")
|
||
font_demo_mono = font_load(path_nova_mono, 18.0, "NovaMono")
|
||
font_demo_chinese = font_load(path_noto_serif_sc, 24.0, "NotoSerifSC")
|
||
font_demo_japanese = font_load(path_sawarabi_mincho, 24.0, "SawarabiMincho")
|
||
font_demo_korean = font_load(path_nanum_pen_script, 36.0, "NanumPenScript")
|
||
font_demo_thai = font_load(path_krub, 24.0, "Krub")
|
||
font_demo_arabic = font_load(path_tajawal, 24.0, "Tajawal")
|
||
font_demo_hebrew = font_load(path_david_libre, 22.0, "DavidLibre")
|
||
font_demo_raincode = font_load(path_noto_sans_jp_reg, 20.0, "NotoSansJPRegular")
|
||
font_demo_grid2 = font_load(path_noto_serif_sc, 54.0, "NotoSerifSC")
|
||
font_demo_grid3 = font_load(path_bitter, 44.0, "Bitter")
|
||
font_firacode = font_load(path_firacode, 16.0, "FiraCode", 12 )
|
||
}
|
||
|
||
event :: proc "c" (sokol_event : ^app.Event)
|
||
{
|
||
#partial switch sokol_event.type {
|
||
case .MOUSE_SCROLL:
|
||
demo_ctx.mouse_scroll = clamp(sokol_event.scroll_y, -1, 1) * -1
|
||
}
|
||
}
|
||
|
||
frame :: proc "c" ()
|
||
{
|
||
context = runtime.default_context()
|
||
|
||
demo_ctx.screen_size = { app.widthf(), app.heightf() }
|
||
|
||
pass_action : gfx.Pass_Action;
|
||
pass_action.colors[0] = { load_action = .CLEAR, clear_value = { 0.18, 0.204, 0.251, 1.0 } }
|
||
gfx.begin_pass({ action = pass_action, swapchain = glue.swapchain() })
|
||
gfx.end_pass()
|
||
{
|
||
ve.configure_snap( & demo_ctx.ve_ctx, u32(demo_ctx.screen_size.x), u32(demo_ctx.screen_size.y) )
|
||
ve.set_colour( & demo_ctx.ve_ctx, ve.Colour { 1.0, 1.0, 1.0, 1.0 })
|
||
|
||
using demo_ctx
|
||
|
||
// Smooth scrolling implementation
|
||
@static demo_autoscroll := false
|
||
@static current_scroll : f32 = 0.0
|
||
@static mouse_down_pos : f32 = -1.0
|
||
@static mouse_down_scroll : f32 = -1.0
|
||
@static mouse_prev_pos : f32 = 0.0
|
||
@static scroll_velocity : f32 = 0.0
|
||
|
||
frame_duration := cast(f32) app.frame_duration()
|
||
|
||
scroll_velocity += mouse_scroll.y * 0.05
|
||
mouse_down_pos = -1.0
|
||
substep_dt := frame_duration / 4.0
|
||
for _ in 0 ..< 4 {
|
||
scroll_velocity *= math.exp(-3.0 * substep_dt)
|
||
current_scroll += scroll_velocity * substep_dt * 10.0
|
||
}
|
||
if demo_autoscroll {
|
||
current_scroll += 0.05 * frame_duration
|
||
}
|
||
mouse_scroll = {} // Reset mouse scroll
|
||
|
||
// Clamp scroll value if needed
|
||
current_scroll = clamp(current_scroll, 0, 6.1) // Adjust max value as needed
|
||
|
||
// Frametime display
|
||
frametime_text := fmt.tprintf("Frametime %v", frame_duration)
|
||
draw_text_string_pos_norm(frametime_text, font_title, 0, {0.0, 0.0}, COLOR_WHITE)
|
||
|
||
if current_scroll < 1.5 {
|
||
intro := `Ça va! Everything here is rendered using VE Font Cache, a single header-only library designed for game engines.
|
||
It aims to:
|
||
• Be fast and simple to integrate.
|
||
• Take advantage of modern GPU power.
|
||
• Be backend agnostic and easy to port to any API such as Vulkan, DirectX, OpenGL.
|
||
• Load TTF & OTF file formats directly.
|
||
• Use only runtime cache with no offline calculation.
|
||
• Render glyphs at reasonable quality at a wide range of hb_font sizes.
|
||
• Support a good amount of internationalisation. そうですね!
|
||
• Support cached text shaping with HarfBuzz with simple Latin-style fallback.
|
||
• Load and unload fonts at any time.`
|
||
|
||
draw_text_string_pos_norm("ゑ", font_logo, 330, {0.4, current_scroll}, COLOR_WHITE)
|
||
draw_text_string_pos_norm("VEFontCache Demo", font_title, 92, {0.2, current_scroll - 0.1}, COLOR_WHITE)
|
||
draw_text_string_pos_norm(intro, font_print, 19, {0.2, current_scroll - 0.14}, COLOR_WHITE)
|
||
}
|
||
|
||
section_start : f32 = 0.42
|
||
section_end : f32 = 2.32
|
||
if current_scroll > section_start && current_scroll < section_end {
|
||
how_it_works := `Glyphs are GPU rasterised with 16x supersampling. This method is a simplification of "Easy Scalable Text Rendering on the GPU",
|
||
by Evan Wallace, making use of XOR blending. Bézier curves are handled via brute force triangle tessellation; even 6 triangles per
|
||
curve only generates < 300 triangles, which is nothing for modern GPUs! This avoids complex frag shader for reasonable quality.
|
||
|
||
Texture atlas caching uses naïve grid placement; this wastes a lot of space but ensures interchangeable cache slots allowing for
|
||
LRU ( Least Recently Used ) caching scheme to be employed.
|
||
The hb_font atlas is a single 4k x 2k R8 texture divided into 4 regions:`
|
||
|
||
caching_strategy := ` 2k
|
||
--------------------
|
||
| | |
|
||
| A | |
|
||
| | | 2
|
||
|---------| C | k
|
||
| | |
|
||
1k | B | |
|
||
| | |
|
||
--------------------
|
||
| |
|
||
| |
|
||
| | 2
|
||
| D | k
|
||
| |
|
||
| |
|
||
| |
|
||
--------------------
|
||
|
||
Region A = 32x32 caches, 1024 glyphs
|
||
Region B = 32x64 caches, 512 glyphs
|
||
Region C = 64x64 caches, 512 glyphs
|
||
Region D = 128x128 caches, 256 glyphs`
|
||
|
||
how_it_works2 := `Region A is designed for small glyphs, Region B is for tall glyphs, Region C is for large glyphs, and Region D for huge glyphs.
|
||
Glyphs are first rendered to an intermediate 2k x 512px R8 texture. This allows for minimum 4 Region D glyphs supersampled at
|
||
4 x 4 = 16x supersampling, and 8 Region C glyphs similarly. A simple 16-tap box downsample shader is then used to blit from this
|
||
intermediate texture to the final atlas location.`
|
||
|
||
draw_text_string_pos_norm("How it works", font_title, 92, {0.2, current_scroll - (section_start + 0.06)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm(how_it_works, font_print, 19, {0.2, current_scroll - (section_start + 0.1)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm(caching_strategy, demo_ctx.font_mono, 21, {0.28, current_scroll - (section_start + 0.32)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm(how_it_works2, font_print, 19, {0.2, current_scroll - (section_start + 0.82)}, COLOR_WHITE)
|
||
}
|
||
|
||
// Showcase section
|
||
section_start, section_end = 1.2, 3.2
|
||
if current_scroll > section_start && current_scroll < section_end
|
||
{
|
||
font_family_test := `Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
|
||
incididunt ut labore et dolore magna aliqua. Est ullamcorper eget nulla facilisi
|
||
etiam dignissim diam quis enim. Convallis convallis tellus id interdum.`
|
||
|
||
draw_text_string_pos_norm("Showcase", font_title, 92, {0.2, current_scroll - (section_start + 0.2)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm("This is a showcase demonstrating different hb_font categories and languages.", font_print, 19, {0.2, current_scroll - (section_start + 0.24)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Sans serif", font_print, 19, {0.2, current_scroll - (section_start + 0.28)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm(font_family_test, font_demo_sans, 18, {0.3, current_scroll - (section_start + 0.28)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Serif", font_print, 19, {0.2, current_scroll - (section_start + 0.36)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm(font_family_test, font_demo_serif, 18, {0.3, current_scroll - (section_start + 0.36)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Script", font_print, 19, {0.2, current_scroll - (section_start + 0.44)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm(font_family_test, font_demo_script, 22, {0.3, current_scroll - (section_start + 0.44)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Monospace", font_print, 19, {0.2, current_scroll - (section_start + 0.52)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm(font_family_test, font_demo_mono, 18, {0.3, current_scroll - (section_start + 0.52)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Small", font_print, 19, {0.2, current_scroll - (section_start + 0.60)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm(font_family_test, font_small, 10, {0.3, current_scroll - (section_start + 0.60)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Greek", font_print, 19, {0.2, current_scroll - (section_start + 0.72)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm("Ήταν απλώς θέμα χρόνου.", font_demo_sans, 18, {0.3, current_scroll - (section_start + 0.72)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Vietnamese", font_print, 19, {0.2, current_scroll - (section_start + 0.76)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm("Bầu trời trong xanh thăm thẳm, không một gợn mây.", font_demo_sans, 18, {0.3, current_scroll - (section_start + 0.76)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Thai", font_print, 19, {0.2, current_scroll - (section_start + 0.80)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm("การเดินทางขากลับคงจะเหงา", font_demo_thai, 24, {0.3, current_scroll - (section_start + 0.80)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Chinese", font_print, 19, {0.2, current_scroll - (section_start + 0.84)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm("床前明月光 疑是地上霜 举头望明月 低头思故乡", font_demo_chinese, 24, {0.3, current_scroll - (section_start + 0.84)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Japanese", font_print, 19, {0.2, current_scroll - (section_start + 0.88)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm("ぎょしょうとナレズシの研究 モンスーン・アジアの食事文化", font_demo_japanese, 24, {0.3, current_scroll - (section_start + 0.88)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Korean", font_print, 19, {0.2, current_scroll - (section_start + 0.92)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm("그들의 장비와 기구는 모두 살아 있다.", font_demo_korean, 36, {0.3, current_scroll - (section_start + 0.92)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Needs harfbuzz to work:", font_print, 14, {0.2, current_scroll - (section_start + 0.96)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Arabic", font_print, 19, {0.2, current_scroll - (section_start + 1.00)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm("حب السماء لا تمطر غير الأحلام.", font_demo_arabic, 24, {0.3, current_scroll - (section_start + 1.00)}, COLOR_WHITE)
|
||
|
||
draw_text_string_pos_norm("Hebrew", font_print, 19, {0.2, current_scroll - (section_start + 1.04)}, COLOR_WHITE)
|
||
draw_text_string_pos_norm("אז הגיע הלילה של כוכב השביט הראשון.", font_demo_hebrew, 22, {0.3, current_scroll - (section_start + 1.04)}, COLOR_WHITE)
|
||
}
|
||
|
||
// Zoom Test
|
||
section_start = 2.3
|
||
section_end = section_start + 2.23
|
||
if current_scroll > section_start && current_scroll < section_end
|
||
{
|
||
zoom_text := `Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
|
||
incididunt ut labore et dolore magna aliqua. Est ullamcorper eget nulla facilisi
|
||
etiam dignissim diam quis enim. Convallis convallis tellus id interdum.`
|
||
|
||
@static zoom_time: f32 = 0
|
||
zoom_time += frame_duration
|
||
zoom_duration :: 10.0 // Time for one complete zoom cycle in seconds
|
||
|
||
modified_linear_zoom :: proc( delta : f32) -> f32
|
||
{
|
||
// Adjust these values to control the time spent at min/max zoom
|
||
min_threshold :: 0.05
|
||
max_threshold :: 0.95
|
||
|
||
if delta < min_threshold do return 0
|
||
else if delta > max_threshold do return 1
|
||
else do return (delta - min_threshold) / (max_threshold - min_threshold)
|
||
}
|
||
|
||
// Calculate the current zoom
|
||
delta := (math.sin(2 * math.PI * zoom_time / zoom_duration) + 1) / 2 // Normalize sine wave to 0-1
|
||
zoom_t := modified_linear_zoom(delta)
|
||
current_zoom := math.lerp(f32(1.0), f32(20.0), zoom_t) // Zoom range from 0.5x to 50x
|
||
|
||
// Calculate positions with reduced gaps
|
||
scroll_offset := current_scroll - section_start
|
||
title_y := current_scroll - (section_start + 0.05)
|
||
zoom_info_y := current_scroll - (section_start + 0.10)
|
||
zoomed_text_y := current_scroll - (section_start + 0.30) + math.sin(zoom_time) * 0.02
|
||
|
||
draw_text_string_pos_norm("Zoom Test", font_title, 92, {0.2, title_y}, COLOR_WHITE)
|
||
|
||
zoomed_text_base_size : f32 = 12.0
|
||
zoom_adjust_size := zoomed_text_base_size * current_zoom
|
||
ve_id, resolved_size := font_resolve_draw_id( font_firacode, zoom_adjust_size * OVER_SAMPLE_ZOOM )
|
||
current_zoom_text := fmt.tprintf("Current Zoom : %.2f x\nCurrent Resolved Size: %v px", current_zoom, resolved_size )
|
||
draw_text_string_pos_norm(current_zoom_text, font_firacode, 19, {0.2, zoom_info_y}, COLOR_WHITE)
|
||
|
||
ve.configure_snap( & demo_ctx.ve_ctx, u32(0), u32(0) )
|
||
|
||
size := measure_text_size( zoom_text, font_firacode, zoomed_text_base_size, 0 ) * current_zoom
|
||
x_offset := (size.x / demo_ctx.screen_size.x) * 0.5
|
||
zoomed_text_pos := Vec2 { 0.5 - x_offset, zoomed_text_y }
|
||
draw_text_zoomed_norm(zoom_text, font_firacode, zoomed_text_base_size, zoomed_text_pos, current_zoom, COLOR_WHITE)
|
||
}
|
||
|
||
// Raincode Demo
|
||
section_start = 3.6
|
||
section_end = 5.4
|
||
if current_scroll > section_start && current_scroll < section_end
|
||
{
|
||
GRID_W :: 80
|
||
GRID_H :: 50
|
||
NUM_RAINDROPS :: GRID_W / 3
|
||
|
||
@static init_grid := false
|
||
@static grid : [ GRID_W * GRID_H ]int
|
||
@static grid_age : [ GRID_W * GRID_H ]f32
|
||
@static raindropsX : [ NUM_RAINDROPS ]int
|
||
@static raindropsY : [ NUM_RAINDROPS ]int
|
||
@static code_colour : RGBA8
|
||
|
||
@static codes := [?]string {
|
||
" ", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "Z", "T", "H", "E", "｜", "¦", "日",
|
||
"ﾊ", "ﾐ", "ﾋ", "ｰ", "ｳ", "ｼ", "ﾅ", "ﾓ", "ﾆ", "ｻ", "ﾜ", "ﾂ", "ｵ", "ﾘ", "ｱ", "ﾎ", "ﾃ", "ﾏ",
|
||
"ｹ", "ﾒ", "ｴ", "ｶ", "ｷ", "ﾑ", "ﾕ", "ﾗ", "ｾ", "ﾈ", "ｽ", "ﾂ", "ﾀ", "ﾇ", "ﾍ", ":", "・", ".",
|
||
"\"", "=", "*", "+", "-", "<", ">", "ç", "ﾘ", "ｸ", "ｺ", "ﾁ", "ﾔ", "ﾙ", "ﾝ", "C", "O", "D"
|
||
}
|
||
|
||
if !init_grid {
|
||
for idx in 0..<NUM_RAINDROPS do raindropsY[idx] = GRID_H
|
||
init_grid = true
|
||
}
|
||
|
||
@static fixed_timestep_passed : f32 = 0.0
|
||
fixed_timestep : f32 = (1.0 / 30.0)
|
||
fixed_timestep_passed += frame_duration
|
||
for fixed_timestep_passed > fixed_timestep
|
||
{
|
||
for idx in 0 ..< (GRID_W * GRID_H) do grid_age[idx] += frame_duration
|
||
for idx in 0 ..< NUM_RAINDROPS {
|
||
raindropsY[idx] += 1
|
||
if raindropsY[idx] < 0 do continue
|
||
if raindropsY[idx] >= GRID_H {
|
||
raindropsY[idx] = -5 - rand.int_max(40)
|
||
raindropsX[idx] = rand.int_max(GRID_W)
|
||
continue
|
||
}
|
||
grid [ raindropsY[idx] * GRID_W + raindropsX[idx] ] = rand.int_max(len(codes))
|
||
grid_age[ raindropsY[idx] * GRID_W + raindropsX[idx] ] = 0.0
|
||
}
|
||
fixed_timestep_passed = 0
|
||
}
|
||
|
||
// Draw grid
|
||
draw_text_string_pos_norm("Raincode demo", font_title, 92, { 0.2, current_scroll - (section_start + 0.2) }, COLOR_WHITE)
|
||
for y in 0 ..< GRID_H do for x in 0 ..< GRID_W
|
||
{
|
||
pos_x := 0.2 + f32(x) * 0.007
|
||
pos_y := current_scroll - (section_start + 0.24 + f32(y) * 0.018)
|
||
age := grid_age[y * GRID_W + x]
|
||
|
||
code_colour = {255, 255, 255, 255}
|
||
if age > 0.0 {
|
||
code_colour = {
|
||
51 + 30,
|
||
77 + 30,
|
||
102 + 30,
|
||
u8(clamp((1.0 - age) * 255, 0, 255) ) }
|
||
if code_colour.a == 0 do continue
|
||
}
|
||
|
||
draw_text_string_pos_norm(codes[grid[y * GRID_W + x]], font_demo_raincode, 20, {pos_x, pos_y}, code_colour)
|
||
}
|
||
|
||
ve.set_colour(&ve_ctx, {1.0, 1.0, 1.0, 1.0})
|
||
}
|
||
|
||
// Cache pressure test
|
||
section_start = 5.3
|
||
section_end = 6.2
|
||
if current_scroll > section_start && current_scroll < section_end && true
|
||
{
|
||
GRID_W :: 30
|
||
GRID_H :: 15
|
||
GRID2_W :: 8
|
||
GRID2_H :: 2
|
||
GRID3_W :: 16
|
||
GRID3_H :: 4
|
||
|
||
@static grid : [GRID_W * GRID_H ]int
|
||
@static grid2 : [GRID2_W * GRID2_H]int
|
||
@static grid3 : [GRID3_W * GRID3_H]int
|
||
|
||
@static rotate_current : int = 0
|
||
@static fixed_timestep_passed : f32 = 0.0
|
||
|
||
fixed_timestep_passed += frame_duration
|
||
fixed_timestep := f32(1.0 / 30.0)
|
||
for fixed_timestep_passed > fixed_timestep
|
||
{
|
||
rotate_current = (rotate_current + 1) % 4
|
||
rotate_idx := 0
|
||
for & g in grid
|
||
{
|
||
if (rotate_idx % 4) != rotate_current {
|
||
rotate_idx += 1
|
||
continue
|
||
}
|
||
g = 0x4E00 + rand.int_max(0x9FFF - 0x4E00)
|
||
rotate_idx += 1
|
||
}
|
||
for & g in grid2 do g = 0x4E00 + rand.int_max(0x9FFF - 0x4E00)
|
||
for & g in grid3 do g = rand.int_max(128)
|
||
fixed_timestep_passed -= fixed_timestep
|
||
}
|
||
|
||
codepoint_to_utf8 :: proc(c: []u8, chr: int) {
|
||
if chr == 0 {
|
||
return
|
||
}
|
||
else if (0xffffff80 & chr) == 0 {
|
||
c[0] = u8(chr)
|
||
}
|
||
else if (0xfffff800 & chr) == 0 {
|
||
c[0] = 0xc0 | u8(chr >> 6)
|
||
c[1] = 0x80 | u8(chr & 0x3f)
|
||
}
|
||
else if (0xffff0000 & chr) == 0 {
|
||
c[0] = 0xe0 | u8(chr >> 12)
|
||
c[1] = 0x80 | u8((chr >> 6) & 0x3f)
|
||
c[2] = 0x80 | u8(chr & 0x3f)
|
||
}
|
||
else {
|
||
c[0] = 0xf0 | u8(chr >> 18)
|
||
c[1] = 0x80 | u8((chr >> 12) & 0x3f)
|
||
c[2] = 0x80 | u8((chr >> 6) & 0x3f)
|
||
c[3] = 0x80 | u8(chr & 0x3f)
|
||
}
|
||
}
|
||
|
||
// Draw grid
|
||
draw_text_string_pos_norm("Cache pressure test", font_title, 92, {0.2, current_scroll - (section_start + 0.2)}, COLOR_WHITE)
|
||
for y in 0..< GRID_H do for x in 0 ..< GRID_W
|
||
{
|
||
posx := 0.2 + f32(x) * 0.02
|
||
posy := current_scroll - (section_start + 0.24 + f32(y) * 0.025)
|
||
c := [5]u8{}
|
||
codepoint_to_utf8(c[:], grid[ y * GRID_W + x ])
|
||
draw_text_string_pos_norm(string( c[:] ), font_demo_chinese, 24, {posx, posy}, COLOR_WHITE)
|
||
}
|
||
for y in 0 ..< GRID2_H do for x in 0 ..< GRID2_W {
|
||
posx := 0.2 + f32(x) * 0.03
|
||
posy := current_scroll - (section_start + 0.66 + f32(y) * 0.052)
|
||
c := [5]u8{}
|
||
codepoint_to_utf8(c[:], grid2[ y * GRID2_W + x ])
|
||
draw_text_string_pos_norm(string( c[:] ), font_demo_grid2, 54, {posx, posy}, COLOR_WHITE)
|
||
}
|
||
for y in 0 ..< GRID3_H do for x in 0 ..< GRID3_W {
|
||
posx := 0.45 + f32(x) * 0.02
|
||
posy := current_scroll - (section_start + 0.64 + f32(y) * 0.034)
|
||
c := [5]u8{}
|
||
codepoint_to_utf8( c[:], grid3[ y * GRID3_W + x ])
|
||
draw_text_string_pos_norm(string( c[:] ), font_demo_grid3, 44, {posx, posy}, COLOR_WHITE)
|
||
}
|
||
}
|
||
|
||
ve_sokol.render_text_layer(demo_ctx.screen_size * 0.5, & demo_ctx.ve_ctx, demo_ctx.render_ctx)
|
||
}
|
||
|
||
gfx.commit()
|
||
ve.flush_draw_list( & demo_ctx.ve_ctx )
|
||
}
|
||
|
||
cleanup :: proc "c" () {
|
||
context = runtime.default_context()
|
||
ve.shutdown( & demo_ctx.ve_ctx )
|
||
gfx.shutdown()
|
||
}
|
||
|
||
main :: proc()
|
||
{
|
||
demo_ctx.screen_size = Vec2 { 1920, 1080 }
|
||
|
||
app.run({
|
||
init_cb = init,
|
||
event_cb = event,
|
||
frame_cb = frame,
|
||
cleanup_cb = cleanup,
|
||
width = i32(demo_ctx.screen_size.x),
|
||
height = i32(demo_ctx.screen_size.y),
|
||
window_title = "VEFonCache: Sokol Backend Demo",
|
||
icon = { sokol_default = true },
|
||
logger = { func = slog.func },
|
||
allocator = { sokol_app_alloc, sokol_app_free, nil },
|
||
})
|
||
}
|