feat: shape and antialias Tessera text with system fonts
Verify Tessera GUI / verify (push) Successful in 13m28s

This commit is contained in:
2026-10-20 14:25:28 +08:00
parent 1f64de48b9
commit f0fae1792f
19 changed files with 661 additions and 95 deletions
+7 -1
View File
@@ -15,6 +15,7 @@
| display_list.rs | Rendering primitives and color representation |
| geometry.rs | Native points and rectangles |
| software_renderer.rs | Software rasterization of the display list |
| text.rs | Shared system font discovery, shaping, real measurements, antialiased glyphs and bounded caches |
| README.md | Module map |
Aster is an unmodified source submodule. Language parsing, AST definitions,
@@ -37,4 +38,9 @@ Tests in api.rs execute real HTTP CRUD and a controlled queued-PUT/DELETE race
without opening a window. Tests in endor_host.rs cover lifecycle, direct script and
module entry, page methods, multiline inputs, original source ranges, malformed input,
entry checks, budgets, failure preservation and stale-result invalidation. They
run only in remote CI. See the [project guide](../README.md) for public behavior.
run only in remote CI. Font tests in text.rs and software_renderer.rs cover real
advances, multiline height, fractional scaling, CJK fallback, grapheme-safe fitting,
antialiasing and transparency. A process-wide mutex keeps font discovery, shaping
and glyph caches shared between the worker's layout and window redraw. The
256-string/512-KiB source cache and 4096-glyph/32-MiB image cache are discarded
when their budgets are exceeded. See the [project guide](../README.md) for public behavior.
+4 -2
View File
@@ -339,8 +339,10 @@ PUT waits for its worker result. Errors return 422 with diagnostics and preserve
the last successful revision. A newer accepted PUT or DELETE supersedes older
work (409); a full eight-entry queue returns 503. DELETE immediately clears the
document. GET remains available while Aster executes. The window redraws from an
owned snapshot; resize does not rerun Endor. This first stage builds static UI;
events, persistent VM state, Chinese font rendering and process isolation remain
owned snapshot; resize does not rerun Endor. Text uses system fonts, antialiasing
and font fallback; Chinese needs an installed CJK font. Size 1 is 14 logical pixels
with 20-pixel line height; larger sizes multiply both. This first stage builds static UI;
events, persistent VM state and process isolation remain
future work. It is not an untrusted-code sandbox.
"##,
name = namespace.name,
+14 -25
View File
@@ -2,6 +2,7 @@ use crate::{
display_list::{Color, DisplayList, DrawCommand},
document::{CodeNode, RenderDocument},
geometry::{Point, Rect},
text::{self as typography, TextStyle},
};
const PANEL: Color = Color::rgb(247, 247, 245);
@@ -154,14 +155,13 @@ pub fn build(
if state.selected_node_id.as_deref() == Some(node.id.as_str()) {
fill(&mut list, row, 5.0 * scale, SELECTED);
}
text(
&mut list,
row.x + (9.0 + depth as f32 * 14.0) * scale,
row.y + 8.0 * scale,
&fit(&format!("{} {}", node.kind, node.name), 44),
scale,
TEXT,
let text_x = row.x + (9.0 + depth as f32 * 14.0) * scale;
let label = typography::fit(
&format!("{} {}", node.kind, node.name),
(width - 14.0 * scale - text_x).max(0.0),
TextStyle::code().scaled(scale),
);
text(&mut list, text_x, row.y + 3.0 * scale, &label, scale, TEXT);
layout.rows.push(TreeRowHit {
rect: row,
node_id: node.id.clone(),
@@ -235,7 +235,7 @@ fn draw_source(
let first_y = area.y + 42.0 * scale;
let maximum_lines =
((area.y + area.height - first_y - 10.0 * scale) / line_height).max(0.0) as usize;
let max_chars = ((area.width / (8.0 * scale)) - 9.0).max(8.0) as usize;
let source_width = (area.width - 65.0 * scale).max(0.0);
for (offset, source_line) in all_lines[start..end].iter().take(maximum_lines).enumerate() {
let line_number = start + offset + 1;
@@ -252,7 +252,11 @@ fn draw_source(
list,
area.x + 55.0 * scale,
y,
&fit(&source_line.replace('\t', " "), max_chars),
&typography::fit(
&source_line.replace('\t', " "),
source_width,
TextStyle::code().scaled(scale),
),
scale,
TEXT,
);
@@ -266,21 +270,6 @@ fn flatten<'a>(node: &'a CodeNode, depth: usize, output: &mut Vec<(usize, &'a Co
}
}
fn fit(value: &str, maximum: usize) -> String {
let characters: Vec<_> = value.chars().collect();
if characters.len() <= maximum {
return value.to_owned();
}
if maximum < 3 {
return characters.into_iter().take(maximum).collect();
}
characters
.into_iter()
.take(maximum - 3)
.chain(['.', '.', '.'])
.collect()
}
fn fill(list: &mut DisplayList, rect: Rect, radius: f32, color: Color) {
list.push(DrawCommand::FillRoundedRect {
rect,
@@ -293,7 +282,7 @@ fn text(list: &mut DisplayList, x: f32, y: f32, value: &str, scale: f32, color:
list.push(DrawCommand::Text {
origin: Point::new(x, y),
value: value.to_owned(),
scale: scale.round().max(1.0) as u32,
style: TextStyle::code().scaled(scale),
color,
});
}
+2 -1
View File
@@ -1,4 +1,5 @@
use crate::geometry::{Point, Rect};
use crate::text::TextStyle;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Color {
@@ -45,7 +46,7 @@ pub enum DrawCommand {
Text {
origin: Point,
value: String,
scale: u32,
style: TextStyle,
color: Color,
},
}
+1 -1
View File
@@ -300,7 +300,7 @@ impl RenderCommand {
} => DrawCommand::Text {
origin: Point::new(x * scale, y * scale),
value: value.clone(),
scale: ((*size as f32 * scale).round() as u32).max(1),
style: crate::text::TextStyle::ui(*size).scaled(scale),
color: parse_color(color)?,
},
})
+6 -12
View File
@@ -378,7 +378,7 @@ mod tests {
matches!(&document.frame.commands[0], RenderCommand::Text { value, size: 2, x: 24.0, y: 24.0, .. } if value == "Hello Endor")
);
assert!(
matches!(&document.frame.commands[1], RenderCommand::RoundedRect { x: 24.0, y: 52.0, width: 240.0, height: 80.0, radius: 12.0, color } if color == "#DCE8FF")
matches!(&document.frame.commands[1], RenderCommand::RoundedRect { x: 24.0, y: 76.0, width: 240.0, height: 80.0, radius: 12.0, color } if color == "#DCE8FF")
);
assert_eq!(document.display_list(2.0).unwrap().commands().len(), 3);
let wrapped = compile(include_str!("../examples/main.endor"), "app.main", 10).unwrap();
@@ -553,19 +553,16 @@ paint(ui.text("last"))"#;
&document.frame.commands[1],
RenderCommand::RoundedRect {
x: 24.0,
y: 52.0,
y: 76.0,
width: 240.0,
height: 80.0,
..
}
));
let first_width = crate::text::measure("Aster VM", crate::text::TextStyle::ui(1)).width;
assert!(matches!(
&document.frame.commands[3],
RenderCommand::Text {
x: 120.0,
y: 144.0,
..
}
RenderCommand::Text { x, y: 168.0, .. } if (*x - (24.0 + first_width + 12.0 + 8.0 + 12.0)).abs() < 0.01
));
// Candidate::close already proved zero remaining VM objects. Both
// redraws must still work from native data at different display scales.
@@ -583,13 +580,10 @@ function main(): View { let child = ui.text("shared") return wrap(child) }"#;
&document.frame.commands[0],
RenderCommand::Text { x: 4.0, y: 4.0, .. }
));
let width = crate::text::measure("shared", crate::text::TextStyle::ui(1)).width;
assert!(matches!(
&document.frame.commands[1],
RenderCommand::Text {
x: 60.0,
y: 4.0,
..
}
RenderCommand::Text { x, y: 4.0, .. } if (*x - (4.0 + width + 8.0)).abs() < 0.01
));
}
+4 -2
View File
@@ -3,6 +3,7 @@ use anyhow::{Result, bail};
use crate::{
document::{Frame, RenderCommand},
text::{self, TextStyle},
ui_bridge::{MAX_DIMENSION, UiKind, UiNode},
};
@@ -50,9 +51,10 @@ fn layout(
size: *size,
color: color.clone(),
});
let measured = text::measure(value, TextStyle::ui(*size));
Size {
width: value.chars().count() as f32 * 8.0 * *size as f32,
height: 8.0 * *size as f32,
width: measured.width,
height: measured.height,
}
}
UiKind::Rect {
+1
View File
@@ -9,6 +9,7 @@ mod geometry;
mod layout;
mod scene;
mod software_renderer;
mod text;
mod ui_bridge;
use std::sync::{Arc, RwLock};
+37 -35
View File
@@ -1,8 +1,7 @@
use font8x8::{BASIC_FONTS, UnicodeFonts};
use crate::{
display_list::{Color, DisplayList, DrawCommand},
geometry::{Point, Rect},
text::{self, TextStyle},
};
pub struct SoftwareRenderer;
@@ -32,9 +31,9 @@ impl SoftwareRenderer {
DrawCommand::Text {
origin,
value,
scale,
style,
color,
} => canvas.draw_text(*origin, value, *scale, *color),
} => canvas.draw_text(*origin, value, *style, *color),
}
}
}
@@ -88,29 +87,12 @@ impl Canvas<'_> {
}
}
fn draw_text(&mut self, origin: Point, value: &str, scale: u32, color: Color) {
let scale = scale.max(1) as i32;
let mut cursor_x = origin.x.round() as i32;
let baseline_y = origin.y.round() as i32;
for character in value.chars() {
if let Some(glyph) = BASIC_FONTS.get(character) {
for (row, byte) in glyph.iter().enumerate() {
for column in 0..8 {
if byte & (1 << column) != 0 {
self.fill_pixels(
cursor_x + column * scale,
baseline_y + row as i32 * scale,
scale,
scale,
color,
);
}
}
}
}
cursor_x += 8 * scale;
}
fn draw_text(&mut self, origin: Point, value: &str, style: TextStyle, color: Color) {
let x = origin.x.round() as i32;
let y = origin.y.round() as i32;
text::draw(value, style, color, |dx, dy, pixel| {
self.blend_pixel(x + dx, y + dy, pixel)
});
}
fn clamped_bounds(&self, rect: Rect) -> (i32, i32, i32, i32) {
@@ -122,14 +104,6 @@ impl Canvas<'_> {
)
}
fn fill_pixels(&mut self, x: i32, y: i32, width: i32, height: i32, color: Color) {
for py in y.max(0)..(y + height).min(self.height as i32) {
for px in x.max(0)..(x + width).min(self.width as i32) {
self.blend_pixel(px, py, color);
}
}
}
fn blend_pixel(&mut self, x: i32, y: i32, source: Color) {
if x < 0 || y < 0 || x >= self.width as i32 || y >= self.height as i32 || source.alpha == 0
{
@@ -192,4 +166,32 @@ mod tests {
assert_eq!(pixels[5], 0x00ff0000);
assert_eq!(pixels[0], 0);
}
#[test]
fn text_edges_are_antialiased_and_respect_opacity() {
let mut list = DisplayList::default();
list.push(DrawCommand::Clear(Color::rgb(0, 0, 0)));
list.push(DrawCommand::Text {
origin: Point::new(2.0, 2.0),
value: "Hello 中文".into(),
style: TextStyle::ui(1).scaled(1.25),
color: Color::rgba(255, 255, 255, 128),
});
let mut pixels = vec![0; 256 * 48];
SoftwareRenderer::render(&list, &mut pixels, 256, 48);
assert!(pixels.iter().any(|pixel| *pixel > 0));
assert!(pixels.iter().all(|pixel| (pixel & 255) <= 128));
assert!(pixels.iter().any(|pixel| (1..128).contains(&(pixel & 255))));
let mut invisible = DisplayList::default();
invisible.push(DrawCommand::Text {
origin: Point::new(2.0, 2.0),
value: "Hello 中文".into(),
style: TextStyle::ui(1),
color: Color::rgba(255, 255, 255, 0),
});
let mut pixels = vec![0; 256 * 48];
SoftwareRenderer::render(&invisible, &mut pixels, 256, 48);
assert!(pixels.iter().all(|pixel| *pixel == 0));
}
}
+310
View File
@@ -0,0 +1,310 @@
//! Shared font discovery, shaping, measurement and antialiased rasterization.
use std::{
collections::HashMap,
sync::{Mutex, OnceLock},
};
use cosmic_text::{Align, Attrs, Buffer, Family, FontSystem, Metrics, Shaping, SwashCache, Wrap};
use crate::display_list::Color;
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
pub enum TextFamily {
Interface,
Code,
}
#[derive(Clone, Copy, Debug)]
pub struct TextStyle {
pub font_size: f32,
pub line_height: f32,
pub family: TextFamily,
}
impl TextStyle {
pub fn ui(size: u32) -> Self {
Self {
font_size: 14.0 * size as f32,
line_height: 20.0 * size as f32,
family: TextFamily::Interface,
}
}
pub fn code() -> Self {
Self {
font_size: 13.0,
line_height: 18.0,
family: TextFamily::Code,
}
}
pub fn scaled(self, scale: f32) -> Self {
Self {
font_size: self.font_size * scale,
line_height: self.line_height * scale,
..self
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct TextSize {
pub width: f32,
pub height: f32,
}
#[derive(Clone, Hash, PartialEq, Eq)]
struct TextKey {
value: String,
font_size: u32,
line_height: u32,
family: TextFamily,
}
struct PreparedText {
buffer: Buffer,
size: TextSize,
}
struct TextEngine {
fonts: FontSystem,
swash: SwashCache,
buffers: HashMap<TextKey, PreparedText>,
source_bytes: usize,
}
impl TextEngine {
fn new() -> Self {
let mut fonts = FontSystem::new();
// Select installed, readable families rather than assuming an OS font
// name exists. COSMIC Text handles per-glyph fallback (including CJK).
let choose = |choices: &[&str]| {
choices.iter().find_map(|choice| {
fonts
.db()
.faces()
.any(|face| face.families.iter().any(|(name, _)| name == choice))
.then(|| (*choice).to_owned())
})
};
let sans = choose(&[
".AppleSystemUIFont",
"SF Pro Text",
"Helvetica Neue",
"Segoe UI",
"Noto Sans",
"DejaVu Sans",
"Liberation Sans",
]);
let mono = choose(&["Menlo", "Consolas", "DejaVu Sans Mono", "Liberation Mono"]);
if let Some(name) = sans {
fonts.db_mut().set_sans_serif_family(name);
}
if let Some(name) = mono {
fonts.db_mut().set_monospace_family(name);
}
Self {
fonts,
swash: SwashCache::new(),
buffers: HashMap::new(),
source_bytes: 0,
}
}
fn prepare(&mut self, value: &str, style: TextStyle) -> TextKey {
let key = TextKey {
value: value.to_owned(),
font_size: style.font_size.to_bits(),
line_height: style.line_height.to_bits(),
family: style.family,
};
if self.buffers.contains_key(&key) {
return key;
}
// Cache recent shaped strings, without retaining every submitted source.
if self.buffers.len() >= 256 || self.source_bytes + value.len() > 524_288 {
self.buffers.clear();
self.source_bytes = 0;
}
let family = match style.family {
TextFamily::Interface => Family::SansSerif,
TextFamily::Code => Family::Monospace,
};
let mut buffer = Buffer::new(
&mut self.fonts,
Metrics::new(style.font_size, style.line_height),
);
buffer.set_wrap(Wrap::None);
buffer.set_size(None, None);
buffer.set_text(
value,
&Attrs::new().family(family),
Shaping::Advanced,
Some(Align::Left),
);
buffer.shape_until_scroll(&mut self.fonts, false);
let mut size = TextSize {
width: 0.0,
height: style.line_height,
};
for run in buffer.layout_runs() {
size.width = size.width.max(run.line_w);
size.height = size.height.max(run.line_top + run.line_height);
}
self.source_bytes += value.len();
self.buffers
.insert(key.clone(), PreparedText { buffer, size });
key
}
}
fn engine() -> &'static Mutex<TextEngine> {
static ENGINE: OnceLock<Mutex<TextEngine>> = OnceLock::new();
ENGINE.get_or_init(|| Mutex::new(TextEngine::new()))
}
pub fn measure(value: &str, style: TextStyle) -> TextSize {
let mut engine = engine().lock().expect("text engine lock");
let key = engine.prepare(value, style);
engine.buffers[&key].size
}
/// Draw at the actual device font size; no scaling of an already rasterized bitmap.
pub fn draw(value: &str, style: TextStyle, color: Color, mut pixel: impl FnMut(i32, i32, Color)) {
let mut engine = engine().lock().expect("text engine lock");
let key = engine.prepare(value, style);
let TextEngine {
fonts,
swash,
buffers,
..
} = &mut *engine;
let opacity = u16::from(color.alpha);
buffers.get_mut(&key).expect("prepared text").buffer.draw(
fonts,
swash,
cosmic_text::Color::rgb(color.red, color.green, color.blue),
|x, y, width, height, color| {
for dy in 0..height as i32 {
for dx in 0..width as i32 {
pixel(
x + dx,
y + dy,
Color::rgba(
color.r(),
color.g(),
color.b(),
(u16::from(color.a()) * opacity / 255) as u8,
),
);
}
}
},
);
// The cache is an optimization, never an archive of all submitted glyphs.
if swash.image_cache.len() > 4096
|| swash
.image_cache
.values()
.flatten()
.map(|image| image.data.len())
.sum::<usize>()
> 33_554_432
{
*swash = SwashCache::new();
}
}
/// Fit a single displayed source line without slicing a UTF-8/grapheme cluster.
pub fn fit(value: &str, width: f32, style: TextStyle) -> String {
use unicode_segmentation::UnicodeSegmentation;
// A source line may include a very large comment. Only shape a bounded
// preview for the sidebar; the stored source and its AST spans stay intact.
let truncated = value.len() > 8192;
let value = if truncated {
let end = value
.grapheme_indices(true)
.map(|(index, _)| index)
.take_while(|index| *index <= 8192)
.last()
.unwrap_or(0);
&value[..end]
} else {
value
};
if !truncated && measure(value, style).width <= width {
return value.to_owned();
}
let ellipsis = "…";
if width <= 0.0 || measure(ellipsis, style).width > width {
return String::new();
}
let ends: Vec<_> = value
.grapheme_indices(true)
.map(|(start, part)| start + part.len())
.collect();
let mut low = 0;
let mut high = ends.len();
while low < high {
let count = (low + high).div_ceil(2);
let end = ends[count - 1];
let candidate = format!("{}{ellipsis}", &value[..end]);
if measure(&candidate, style).width <= width {
low = count;
} else {
high = count - 1;
}
}
let end = low.checked_sub(1).map_or(0, |index| ends[index]);
format!("{}{ellipsis}", &value[..end])
}
#[cfg(test)]
mod tests {
use super::*;
use unicode_segmentation::UnicodeSegmentation;
#[test]
fn proportional_metrics_monospace_and_multiline_height_come_from_the_fonts() {
let ui = TextStyle::ui(1);
assert!(measure("WWWW", ui).width > measure("iiii", ui).width * 2.0);
let mono = TextStyle::code();
assert!((measure("WWWW", mono).width - measure("iiii", mono).width).abs() < 0.1);
assert_eq!(measure("one\ntwo", ui).height, ui.line_height * 2.0);
let width = measure("Hello Endor", ui).width;
assert!((measure("Hello Endor", ui.scaled(1.25)).width - width * 1.25).abs() < 0.5);
}
#[test]
fn system_fallback_shapes_chinese_without_missing_glyphs() {
let mut engine = engine().lock().unwrap();
for style in [TextStyle::ui(1), TextStyle::code()] {
let key = engine.prepare("中文字体", style);
let glyphs: Vec<_> = engine.buffers[&key]
.buffer
.layout_runs()
.flat_map(|run| run.glyphs)
.collect();
assert_eq!(glyphs.len(), 4);
assert!(glyphs.iter().all(|glyph| glyph.glyph_id != 0));
}
}
#[test]
fn ellipsis_fits_actual_width_and_preserves_graphemes() {
let style = TextStyle::code();
let value = "e\u{301}e\u{301}中文字体e\u{301}e\u{301}";
let width = measure("e\u{301}e\u{301}中…", style).width + 0.01;
let fitted = fit(value, width, style);
let prefix = fitted.strip_suffix('…').unwrap();
assert!(value.starts_with(prefix));
assert!(
value
.grapheme_indices(true)
.any(|(index, _)| index == prefix.len())
);
assert!(measure(&fitted, style).width <= width);
assert_eq!(fit(value, 0.0, style), "");
}
}