dymokomi/luce-ui
Source of release 0.19.1
## UI typography owns a native face and a bounded cache of grayscale text runs.
## Font copies borrow; widgets clone the shared reference and release it on close.
from luce_fonts import fonts
from luce_gpu import gpu
import interop
from luce_std import math
import memory
import ownership
struct CachedRun:
var text: interop.Owned[str]?
var bitmap: fonts.Bitmap
var scale: f64
var used: u64
func close():
if let text = self.text:
text.release()
self.bitmap.close()
self = CachedRun()
struct FontState:
var face: fonts.Face
var runs: CachedRun[]
var clock: u64
var bytes: usize
func close():
for index in 0..<self.runs.length:
self.runs[index].close()
if self.runs.length > 0:
free(self.runs) in memory.heap
var empty: CachedRun[]
self.runs = empty
self.face.close()
pub func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
for run in self.runs:
if let text = run.text:
text.trace(visit, context)
func raster(text: str, scale: f64) -> fonts.Bitmap!:
self.clock += 1
var oldest: usize = 0
for index in 0..<self.runs.length:
let run = self.runs[index]
if let cached = run.text:
if run.scale == scale and cached.value == text:
self.runs[index].used = self.clock
return run.bitmap
if run.used < self.runs[oldest].used:
oldest = index
let bitmap = try self.face.rasterize(text, scale)
errdefer close_bitmap(bitmap)
let copied = try interop.copy_text(text)
errdefer copied.release()
# Evict least-recently-used runs before accepting another raster. The
# image limit and entry limit bound both pixel storage and string owners.
while self.bytes + bitmap.pixels.length > 16777216:
self.bytes -= self.runs[oldest].bitmap.pixels.length
self.runs[oldest].close()
var found = false
for index in 0..<self.runs.length:
if self.runs[index].text != none:
if not found or self.runs[index].used < self.runs[oldest].used:
oldest = index
found = true
self.bytes -= self.runs[oldest].bitmap.pixels.length
self.runs[oldest].close()
self.runs[oldest] = CachedRun(copied, bitmap, scale, self.clock)
self.bytes += bitmap.pixels.length
return bitmap
func close_bitmap(bitmap: fonts.Bitmap):
var owned = bitmap
owned.close()
let font_state_type: interop.Type[FontState] = interop.Type[FontState]("UI font cache", FontState.close, FontState.trace, closeable = true, main_thread = true)
## The shared UI default, in logical points.
pub let default_font_size: f64 = 12.0
## An installed monospace font. Size is measured in logical points; rasterization
## follows the target's backing scale, so Retina text retains its intended size.
## Use one shared Font across controls to keep typography consistent.
pub struct Font:
var state: interop.Reference[FontState]
pub func init(size: f64 = default_font_size, family: str = "") -> !:
var reservation = try interop.Reservation[FontState](font_state_type)
errdefer reservation.cancel()
var face = try fonts.Face(size, family)
errdefer face.close()
let runs = try new CachedRun[512] in memory.heap
errdefer free(runs) in memory.heap
let storage = try new FontState(face = face, runs = runs) in memory.heap
self.state = reservation.publish(storage, memory.heap)
## Replace the shared face only after loading succeeds. Controls retain the
## Font object, so a settings reload updates all of them together.
pub func configure(size: f64, family: str = "") -> !:
let replacement = try Font(size, family)
let previous_state = self.state
self.state = replacement.state
previous_state.release()
pub func size() -> f64:
return self.state.value().face.size
pub func advance() -> f64:
return self.state.value().face.advance
pub func height() -> f64:
let face = self.state.value().face
return face.ascent + face.descent
pub func line_height() -> f64:
return math.ceil(self.height() + self.size() / 3.0)
pub func measure(text: str) -> f64!:
return try self.state.value().face.measure(text)
## The monospace cells `text` takes: two per wide East Asian scalar, none per
## combining mark, one for the rest. Fails when `text` is not UTF-8.
pub func cells(text: str) -> i64!:
return (i64)(try fonts.text_cells(text))
## Internal rendering entry: cache-owned pixels are copied into the frame.
## The application never sees native fonts, raster storage or backend objects.
pub func draw(target: interop.View[gpu.RenderTarget], text: str, x: f64, y: f64, color: gpu.Color) -> !:
_ = try self.measure(text)
if text.length == 0:
return
let destination = try target.get()
let size = try destination.size()
if size.width <= 0.0 or size.height <= 0.0:
return
let scale = math.clamp(size.scale, 0.5, 4.0)
let bitmap = try self.state.value().raster(text, scale)
let rectangle = gpu.Rect(x - bitmap.padding, y - bitmap.padding,
(f64)bitmap.width / scale, (f64)bitmap.height / scale)
try destination.mask(bitmap.pixels, bitmap.width, bitmap.height, rectangle, color)
pub func close():
self.state.release()
pub func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
self.state.trace(visit, context)
pub let font_type: interop.Type[Font] = interop.Type[Font]("Font", Font.close, Font.trace, closeable = true, main_thread = true)
pub func selected_font(font: interop.Reference[Font]?) -> interop.Reference[Font]!:
if let existing = font:
return existing.clone()
return try interop.Reference[Font].adopt(new Font() in memory.heap, font_type, memory.heap)