From 26aef75d7cea8a22c846be52f6263b9cab6ccf5b Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 22:58:52 +0100 Subject: [PATCH] Shape and reorder right-to-left text before drawing it --- Cargo.lock | 7 + crates/horizon-client/Cargo.toml | 1 + crates/horizon-client/src/bidi.rs | 306 ++++++++++++++++++ .../horizon-client/src/block_entity_render.rs | 2 + crates/horizon-client/src/font.rs | 11 +- crates/horizon-client/src/game/names.rs | 4 +- crates/horizon-client/src/hud.rs | 2 + crates/horizon-client/src/lang.rs | 19 +- crates/horizon-client/src/lib.rs | 1 + 9 files changed, 348 insertions(+), 5 deletions(-) create mode 100644 crates/horizon-client/src/bidi.rs diff --git a/Cargo.lock b/Cargo.lock index bbbac4b2c..ecce142eb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1396,6 +1396,7 @@ dependencies = [ "sha1", "sha2", "symphonia", + "unicode-bidi", "ureq", "wgpu", "winit", @@ -3741,6 +3742,12 @@ version = "1.20.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" +[[package]] +name = "unicode-bidi" +version = "0.3.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5" + [[package]] name = "unicode-ident" version = "1.0.26" diff --git a/crates/horizon-client/Cargo.toml b/crates/horizon-client/Cargo.toml index f1011c534..1613fd08c 100644 --- a/crates/horizon-client/Cargo.toml +++ b/crates/horizon-client/Cargo.toml @@ -60,6 +60,7 @@ gilrs = { version = "0.11", optional = true } horizon-dualsense = { path = "../horizon-dualsense", optional = true } # HTTPS to the Minecraft services (online-mode session join). ureq = { version = "2", default-features = false, features = ["tls"] } +unicode-bidi = "0.3.18" [target.'cfg(unix)'.dependencies] # The server thread's CPU time per tick (`HORIZON_SPIKES`, spans.rs). diff --git a/crates/horizon-client/src/bidi.rs b/crates/horizon-client/src/bidi.rs new file mode 100644 index 000000000..c07b69c6d --- /dev/null +++ b/crates/horizon-client/src/bidi.rs @@ -0,0 +1,306 @@ +//! Right-to-left text (`FormattedBidiReorder.reorder`, behind +//! `Language.getVisualOrder`): the logical text a player types becomes the +//! glyphs a font draws left to right. Arabic letters are shaped into their +//! joined presentation forms (ICU's `ArabicShaping` with `LETTERS_SHAPE`), the +//! text is reordered by the Unicode bidirectional algorithm, and characters in +//! right-to-left runs are mirrored. Left-to-right text comes back unchanged. +use crate::text::{Span, Text}; +use std::borrow::Cow; +use unicode_bidi::{ + BidiClass, Direction, Level, ParagraphBidiInfo, bidi_class, get_base_direction, +}; + +/// How a letter joins its neighbours, as ICU's shaper sees it: `Right` joins +/// the letter before it only, `Dual` both neighbours, `Mark` is skipped over +/// (diacritics) and `None` never joins. +#[derive(Clone, Copy, PartialEq)] +enum Join { + None, + Right, + Dual, + Mark, +} +use Join::{Dual, Mark, Right}; + +/// ICU's joining table (`araLink`): code point ranges and their class, with the +/// lam-alef ligatures at the end. Anything else is `Join::None`. +const JOINS: &[(u32, u32, Join)] = &[ + (0x0622, 0x0625, Right), + (0x0626, 0x0626, Dual), + (0x0627, 0x0627, Right), + (0x0628, 0x0628, Dual), + (0x0629, 0x0629, Right), + (0x062A, 0x062E, Dual), + (0x062F, 0x0632, Right), + (0x0633, 0x063A, Dual), + (0x0640, 0x0647, Dual), + (0x0648, 0x0649, Right), + (0x064A, 0x064A, Dual), + (0x064B, 0x0656, Mark), + (0x0670, 0x0670, Mark), + (0x0671, 0x0673, Right), + (0x0675, 0x0677, Right), + (0x0678, 0x0687, Dual), + (0x0688, 0x0699, Right), + (0x069A, 0x06B9, Dual), + (0x06BA, 0x06BA, Right), + (0x06BB, 0x06BF, Dual), + (0x06C0, 0x06C0, Right), + (0x06C1, 0x06C1, Dual), + (0x06C2, 0x06CB, Right), + (0x06CC, 0x06CC, Dual), + (0x06CD, 0x06CD, Right), + (0x06CE, 0x06D1, Dual), + (0x06D2, 0x06D3, Right), + (0x200D, 0x200D, Dual), + (0x206D, 0x206F, Mark), + (0xFEF5, 0xFEFC, Right), +]; + +/// Letters that have joined forms and the code point of the isolated one; the +/// final, initial and medial forms follow it (a right-joining letter has the +/// isolated and final only). The lam-alef ligatures are their own letters. +#[rustfmt::skip] +const FORMS: &[(u32, u32)] = &[ + (0x0622, 0xFE81), (0x0623, 0xFE83), (0x0624, 0xFE85), (0x0625, 0xFE87), (0x0626, 0xFE89), + (0x0627, 0xFE8D), (0x0628, 0xFE8F), (0x0629, 0xFE93), (0x062A, 0xFE95), (0x062B, 0xFE99), + (0x062C, 0xFE9D), (0x062D, 0xFEA1), (0x062E, 0xFEA5), (0x062F, 0xFEA9), (0x0630, 0xFEAB), + (0x0631, 0xFEAD), (0x0632, 0xFEAF), (0x0633, 0xFEB1), (0x0634, 0xFEB5), (0x0635, 0xFEB9), + (0x0636, 0xFEBD), (0x0637, 0xFEC1), (0x0638, 0xFEC5), (0x0639, 0xFEC9), (0x063A, 0xFECD), + (0x0641, 0xFED1), (0x0642, 0xFED5), (0x0643, 0xFED9), (0x0644, 0xFEDD), (0x0645, 0xFEE1), + (0x0646, 0xFEE5), (0x0647, 0xFEE9), (0x0648, 0xFEED), (0x0649, 0xFEEF), (0x064A, 0xFEF1), + (0x0679, 0xFB66), (0x067A, 0xFB5E), (0x067B, 0xFB52), (0x067E, 0xFB56), (0x0686, 0xFB7A), + (0x0688, 0xFB88), (0x068C, 0xFB84), (0x068D, 0xFB82), (0x068E, 0xFB86), (0x0691, 0xFB8C), + (0x0698, 0xFB8A), (0x06A9, 0xFB8E), (0x06AF, 0xFB92), (0x06BA, 0xFB9E), (0x06BB, 0xFBA0), + (0x06BE, 0xFBAA), (0x06C0, 0xFBA4), (0x06C1, 0xFBA6), (0x06C5, 0xFBE0), (0x06C6, 0xFBD9), + (0x06C7, 0xFBD7), (0x06C8, 0xFBDB), (0x06C9, 0xFBE2), (0x06CB, 0xFBDE), (0x06CC, 0xFBFC), + (0x06D0, 0xFBE4), (0x06D2, 0xFBAE), (0x06D3, 0xFBB0), (0xFEF5, 0xFEF5), (0xFEF7, 0xFEF7), + (0xFEF9, 0xFEF9), (0xFEFB, 0xFEFB), +]; + +/// `Bidi_Mirroring_Glyph` (`UCharacter.getMirror`): each pair is two +/// neighbouring characters that mirror each other. +const MIRRORED: &str = "\ + ()<>[]{}«»༺༻༼༽᚛᚜‹›⁅⁆⁽⁾₍₎∈∋∉∌∊∍∕⧵∟⯾∠⦣∡⦛∢⦠∤⫮∼∽≃⋍≅≌≒≓\ + ≔≕≤≥≦≧≨≩≪≫≮≯≰≱≲≳≴≵≶≷≸≹≺≻≼≽≾≿⊀⊁⊂⊃⊄⊅⊆⊇⊈⊉⊊⊋⊏⊐⊑⊒⊘⦸⊢⊣⊦⫞\ + ⊨⫤⊩⫣⊫⫥⊰⊱⊲⊳⊴⊵⊶⊷⊸⟜⋉⋊⋋⋌⋐⋑⋖⋗⋘⋙⋚⋛⋜⋝⋞⋟⋠⋡⋢⋣⋤⋥⋦⋧⋨⋩⋪⋫⋬⋭⋰⋱⋲⋺\ + ⋳⋻⋴⋼⋶⋽⋷⋾⌈⌉⌊⌋〈〉❨❩❪❫❬❭❮❯❰❱❲❳❴❵⟃⟄⟅⟆⟈⟉⟋⟍⟕⟖⟝⟞⟢⟣⟤⟥⟦⟧⟨⟩⟪⟫\ + ⟬⟭⟮⟯⦃⦄⦅⦆⦇⦈⦉⦊⦋⦌⦍⦐⦎⦏⦑⦒⦓⦔⦕⦖⦗⦘⦤⦥⦨⦩⦪⦫⦬⦭⦮⦯⧀⧁⧄⧅⧏⧐⧑⧒⧔⧕⧘⧙⧚⧛\ + ⧨⧩⧸⧹⧼⧽⨫⨬⨭⨮⨴⨵⨼⨽⩤⩥⩹⩺⩻⩼⩽⩾⩿⪀⪁⪂⪃⪄⪅⪆⪇⪈⪉⪊⪋⪌⪍⪎⪏⪐⪑⪒⪓⪔⪕⪖⪗⪘⪙⪚\ + ⪛⪜⪝⪞⪟⪠⪡⪢⪦⪧⪨⪩⪪⪫⪬⪭⪯⪰⪱⪲⪳⪴⪵⪶⪷⪸⪹⪺⪻⪼⪽⪾⪿⫀⫁⫂⫃⫄⫅⫆⫇⫈⫉⫊⫋⫌⫍⫎⫏⫐\ + ⫑⫒⫓⫔⫕⫖⫬⫭⫷⫸⫹⫺⸂⸃⸄⸅⸉⸊⸌⸍⸜⸝⸠⸡⸢⸣⸤⸥⸦⸧⸨⸩⹕⹖⹗⹘⹙⹚⹛⹜〈〉《》「」『』【】\ + 〔〕〖〗〘〙〚〛﹙﹚﹛﹜﹝﹞﹤﹥()<>[]{}⦅⦆「」"; + +fn join(c: char) -> Join { + let c = c as u32; + JOINS + .iter() + .find(|&&(from, to, _)| (from..=to).contains(&c)) + .map_or(Join::None, |&(_, _, join)| join) +} + +/// The letter whose joined form `c` is (ICU shapes the forms again), or `c`. +fn letter_of(c: char) -> char { + let c32 = c as u32; + if !matches!(c32, 0xFB50..=0xFDFF | 0xFE70..=0xFEFC) { + return c; + } + if (0xFE70..0xFE80).contains(&c32) { + // The diacritics' forms pair up from fathatan on. + return char::from_u32(0x064B + (c32 - 0xFE70) / 2).unwrap_or(c); + } + FORMS + .iter() + .find(|&&(letter, iso)| { + let forms = if join(char::from_u32(letter).unwrap_or(c)) == Dual { + 4 + } else { + 2 + }; + (iso..iso + forms).contains(&c32) + }) + .and_then(|&(letter, _)| char::from_u32(letter)) + .unwrap_or(c) +} + +/// `ArabicShaping(LETTERS_SHAPE).shape`: lam followed by an alef (diacritics +/// may sit between) becomes one ligature, then every letter takes the isolated, +/// final, initial or medial form its neighbours call for. Diacritics take the +/// tatweel form between two joined letters. The text can only get shorter. +fn shape(text: &[char]) -> Vec { + let letters: Vec = text.iter().map(|&c| letter_of(c)).collect(); + let mut chars = Vec::with_capacity(letters.len()); + let mut i = 0; + while i < letters.len() { + if letters[i] == '\u{644}' { + let mut at = i + 1; + while letters.get(at).is_some_and(|&c| join(c) == Mark) { + at += 1; + } + let alef = letters.get(at).and_then(|&c| { + ['\u{622}', '\u{623}', '\u{625}', '\u{627}'] + .iter() + .position(|&a| a == c) + }); + if let Some(alef) = alef { + chars.push(char::from_u32(0xFEF5 + 2 * alef as u32).unwrap_or('\u{644}')); + chars.extend_from_slice(&letters[i + 1..at]); + i = at + 1; + continue; + } + } + chars.push(letters[i]); + i += 1; + } + // Whether the nearest letter before joins the next one, and the joins of + // the nearest letter after. + let mut joins_next = false; + let mut out = Vec::with_capacity(chars.len()); + for (i, &c) in chars.iter().enumerate() { + let next_joins = chars[i + 1..] + .iter() + .map(|&n| join(n)) + .find(|&j| j != Mark) + .is_some_and(|j| j != Join::None); + let kind = join(c); + let shaped = match kind { + Join::None => { + joins_next = false; + c + } + Mark => match c as u32 { + m @ 0x064B..=0x0652 => { + let iso = 0xFE70 + 2 * (m - 0x064B); + let tatweel = joins_next && next_joins && !matches!(m, 0x064C | 0x064D); + char::from_u32(iso + u32::from(tatweel)).unwrap_or(c) + } + _ => c, + }, + Right | Dual => { + let to_next = kind == Dual && next_joins; + let form = match (joins_next, to_next) { + (false, false) => 0, + (true, false) => 1, + (false, true) => 2, + (true, true) => 3, + }; + joins_next = kind == Dual; + FORMS + .binary_search_by_key(&(c as u32), |&(letter, _)| letter) + .ok() + .and_then(|at| char::from_u32(FORMS[at].1 + form)) + .unwrap_or(c) + } + }; + out.push(shaped); + } + out +} + +/// `UCharacter.getMirror`. +fn mirror(c: char) -> char { + if bidi_class(c) != BidiClass::ON { + return c; + } + let mut pairs = MIRRORED.chars(); + while let (Some(a), Some(b)) = (pairs.next(), pairs.next()) { + if c == a { + return b; + } + if c == b { + return a; + } + } + c +} + +/// Whether a character can change anything: right-to-left letters and numbers, +/// the explicit direction controls and the diacritics that shaping turns into +/// letters. Without any, left-to-right text keeps its order. +fn directional(c: char) -> bool { + c as u32 >= 0x0590 + && (matches!(c as u32, 0x064B..=0x0652) + || matches!( + bidi_class(c), + BidiClass::R + | BidiClass::AL + | BidiClass::AN + | BidiClass::LRE + | BidiClass::RLE + | BidiClass::LRO + | BidiClass::RLO + | BidiClass::PDF + | BidiClass::LRI + | BidiClass::RLI + | BidiClass::FSI + | BidiClass::PDI + )) +} + +/// Whether `chars` keep their order and shapes: left-to-right text without +/// anything directional, in a language that reads left to right by default. +fn unchanged(mut chars: impl Iterator, default_rtl: bool) -> bool { + !default_rtl && !chars.any(directional) +} + +/// `FormattedBidiReorder.reorder`: `chars` shaped, in visual order, with each +/// character's position in the shaped text. A character's style is the one at +/// its position in the shaped text, as `SubStringSource` takes it (the text +/// shrinks at a lam-alef ligature). +fn reorder(chars: &[char], default_rtl: bool) -> Vec<(char, usize)> { + let shaped = shape(chars); + let plain: String = shaped.iter().collect(); + // DEFAULT_RTL only changes text without a strong character. + let level = + (default_rtl && get_base_direction(plain.as_str()) == Direction::Mixed).then(Level::rtl); + let info = ParagraphBidiInfo::new(&plain, level); + let levels = info.reordered_levels_per_char(0..plain.len()); + ParagraphBidiInfo::reorder_visual(&levels) + .into_iter() + .map(|i| { + let c = if levels[i].is_rtl() { + mirror(shaped[i]) + } else { + shaped[i] + }; + (c, i) + }) + .collect() +} + +/// `Language.getVisualOrder` of a text (its `§` codes already resolved), for +/// the current language's direction. +pub fn visual(text: &Text) -> Cow<'_, Text> { + let default_rtl = crate::lang::bidirectional(); + if unchanged(text.chars().map(|(c, _)| c), default_rtl) { + return Cow::Borrowed(text); + } + let chars: Vec = text.chars().map(|(c, _)| c).collect(); + let styles: Vec<_> = text.chars().map(|(_, style)| style).collect(); + let mut out = Text::default(); + for (c, at) in reorder(&chars, default_rtl) { + match out.spans.last_mut() { + Some(span) if span.style == *styles[at] => span.text.push(c), + _ => out.spans.push(Span { + text: c.to_string(), + style: styles[at].clone(), + }), + } + } + Cow::Owned(out) +} + +/// The same for a plain string. +pub fn visual_str(s: &str) -> Cow<'_, str> { + let default_rtl = crate::lang::bidirectional(); + if unchanged(s.chars(), default_rtl) { + return Cow::Borrowed(s); + } + let chars: Vec = s.chars().collect(); + Cow::Owned( + reorder(&chars, default_rtl) + .into_iter() + .map(|(c, _)| c) + .collect(), + ) +} diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 28a876d80..a312fe9f7 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -610,7 +610,9 @@ fn sign_text_calls( .iter() .enumerate() .map(|(i, line)| { + // The line that fits, in the order it is drawn (getVisualOrder). let shown = first_line(line, data.max_line_width(), &advance); + let shown = crate::bidi::visual_str(&shown).into_owned(); TextCall { matrix: m, x: -((width(&shown) as i32) / 2) as f32, diff --git a/crates/horizon-client/src/font.rs b/crates/horizon-client/src/font.rs index d0e8c8499..2bb712612 100644 --- a/crates/horizon-client/src/font.rs +++ b/crates/horizon-client/src/font.rs @@ -889,12 +889,17 @@ impl Font { if s.contains('§') { return self.width_text(&Text::legacy(s)); } - s.chars().map(|c| self.glyph(c).advance).sum::().ceil() + crate::bidi::visual_str(s) + .chars() + .map(|c| self.glyph(c).advance) + .sum::() + .ceil() } /// Font.width of a component: `§` codes in the spans are formatting, - /// not glyphs. + /// not glyphs. Right-to-left text is measured as it is drawn, shaped. pub fn width_text(&self, t: &Text) -> f32 { - t.resolved() + let t = t.resolved(); + crate::bidi::visual(&t) .chars() .map(|(c, s)| self.advance(c, s)) .sum::() diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs index 9f7561e53..6b5324e3a 100644 --- a/crates/horizon-client/src/game/names.rs +++ b/crates/horizon-client/src/game/names.rs @@ -338,7 +338,9 @@ impl Game<'_> { let (r, u) = (right.as_vec3() * 0.025, up.as_vec3() * 0.025); // Text space: x right, y down (scale 0.025, -0.025). let at = |x: f32, y: f32| o + r * x - u * y; - let chars: Vec<(char, u32)> = text + // Component.getVisualOrderText. + let shown = horizon_client::bidi::visual(text); + let chars: Vec<(char, u32)> = shown .spans .iter() .flat_map(|s| { diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 2b6acda41..850093780 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -912,6 +912,8 @@ impl HudBatch { // StringDecomposer.iterateFormatted inside Font.drawInternal: // `§` codes inside a span restyle what follows and are not drawn. let text = text.resolved(); + // Language.getVisualOrder: shaped and reordered for right-to-left text. + let text = crate::bidi::visual(&text); let font = &atlas.font; let alpha = (color >> 24) as u8; let mut glyphs = Vec::new(); diff --git a/crates/horizon-client/src/lang.rs b/crates/horizon-client/src/lang.rs index cb96cc373..093a87929 100644 --- a/crates/horizon-client/src/lang.rs +++ b/crates/horizon-client/src/lang.rs @@ -4,7 +4,10 @@ //! language used by every screen. use std::{ collections::{BTreeMap, HashMap}, - sync::{Arc, RwLock}, + sync::{ + Arc, RwLock, + atomic::{AtomicBool, Ordering}, + }, }; #[derive(Clone, Debug, PartialEq, Eq)] @@ -23,11 +26,16 @@ impl LanguageInfo { #[derive(Default)] pub struct Language { pub code: String, + /// `LanguageInfo.bidirectional`: text without a strong character reads + /// right to left (`ClientLanguage.defaultRightToLeft`). + bidirectional: bool, map: HashMap, } pub const DEFAULT: &str = "en_us"; static CURRENT: RwLock>> = RwLock::new(None); +/// The current language's `bidirectional`, read for every drawn string. +static BIDIRECTIONAL: AtomicBool = AtomicBool::new(false); /// A source of resource files: the prepared root plus packs, highest priority last. pub trait ResourceSource { @@ -130,8 +138,12 @@ impl Language { { apply_deprecated(&mut map, &bytes); } + let bidirectional = available(sources) + .iter() + .any(|info| info.code == code && info.bidirectional); Self { code: code.to_owned(), + bidirectional, map, } } @@ -193,11 +205,16 @@ pub fn available(sources: &[&dyn ResourceSource]) -> Vec { } pub fn set(language: Language) { + BIDIRECTIONAL.store(language.bidirectional, Ordering::Relaxed); *CURRENT.write().unwrap_or_else(|e| e.into_inner()) = Some(Arc::new(language)); } pub fn current() -> Option> { CURRENT.read().unwrap_or_else(|e| e.into_inner()).clone() } +/// `ClientLanguage.defaultRightToLeft` of the current language. +pub fn bidirectional() -> bool { + BIDIRECTIONAL.load(Ordering::Relaxed) +} pub fn code() -> String { current().map_or_else(|| DEFAULT.to_owned(), |l| l.code.clone()) } diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index ebfbdea58..2adc13cd6 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -15,6 +15,7 @@ pub mod auto_jump; pub mod banner; pub mod beehive; pub mod benchmark; +pub mod bidi; pub mod biome; pub mod block_entities; pub mod block_entity_anim;