me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Update cosmic-text to latest 🎉

Browse source
This commit is contained in:
Héctor Ramón Jiménez 2023-03-19 14:52:30 +01:00
parent d1dc62ebcd
commit 5f9e7f6cb9
No known key found for this signature in database
GPG key ID: 140CC052C94F138E
4 changed files with 278 additions and 360 deletions
Download patch file Download diff file Expand all files Collapse all files

5
tiny_skia/Cargo.toml
View file

@ -14,7 +14,6 @@ softbuffer = "0.2"
tiny-skia = "0.8" tiny-skia = "0.8"
bytemuck = "1" bytemuck = "1"
rustc-hash = "1.1" rustc-hash = "1.1"
ouroboros = "0.15"
kurbo = "0.9" kurbo = "0.9"
[dependencies.iced_graphics] [dependencies.iced_graphics]
@ -24,8 +23,8 @@ features = ["tiny-skia"]
[dependencies.cosmic-text] [dependencies.cosmic-text]
features = ["std", "swash"] features = ["std", "swash"]
git = "https://github.com/hecrj/cosmic-text" git = "https://github.com/pop-os/cosmic-text"
rev = "81080c1b9498933b43c1889601a7ea6a3d16e161" rev = "e788c175ec31094b04dcacbc0537dba4433afcfc"
[dependencies.twox-hash] [dependencies.twox-hash]
version = "1.6" version = "1.6"

108
tiny_skia/src/text.rs
View file

@ -11,62 +11,31 @@ use std::sync::Arc;
#[allow(missing_debug_implementations)] #[allow(missing_debug_implementations)]
pub struct Pipeline { pub struct Pipeline {
system: Option<System>, font_system: RefCell<cosmic_text::FontSystem>,
glyph_cache: GlyphCache, glyph_cache: GlyphCache,
} measurement_cache: RefCell<Cache>,
render_cache: Cache,
#[ouroboros::self_referencing]
struct System {
fonts: cosmic_text::FontSystem,
#[borrows(fonts)]
#[not_covariant]
measurement_cache: RefCell<Cache<'this>>,
#[borrows(fonts)]
#[not_covariant]
render_cache: Cache<'this>,
} }
impl Pipeline { impl Pipeline {
pub fn new() -> Self { pub fn new() -> Self {
Pipeline { Pipeline {
system: Some( font_system: RefCell::new(cosmic_text::FontSystem::new_with_fonts(
SystemBuilder {
fonts: cosmic_text::FontSystem::new_with_fonts(
[cosmic_text::fontdb::Source::Binary(Arc::new( [cosmic_text::fontdb::Source::Binary(Arc::new(
include_bytes!("../../wgpu/fonts/Iced-Icons.ttf") include_bytes!("../../wgpu/fonts/Iced-Icons.ttf")
.as_slice(), .as_slice(),
))] ))]
.into_iter(), .into_iter(),
), )),
measurement_cache_builder: |_| RefCell::new(Cache::new()),
render_cache_builder: |_| Cache::new(),
}
.build(),
),
glyph_cache: GlyphCache::new(), glyph_cache: GlyphCache::new(),
measurement_cache: RefCell::new(Cache::new()),
render_cache: Cache::new(),
} }
} }
pub fn load_font(&mut self, bytes: Cow<'static, [u8]>) { pub fn load_font(&mut self, bytes: Cow<'static, [u8]>) {
let heads = self.system.take().unwrap().into_heads(); self.font_system.get_mut().db_mut().load_font_source(
cosmic_text::fontdb::Source::Binary(Arc::new(bytes.into_owned())),
let (locale, mut db) = heads.fonts.into_locale_and_db();
db.load_font_source(cosmic_text::fontdb::Source::Binary(Arc::new(
bytes.into_owned(),
)));
self.system = Some(
SystemBuilder {
fonts: cosmic_text::FontSystem::new_with_locale_and_db(
locale, db,
),
measurement_cache_builder: |_| RefCell::new(Cache::new()),
render_cache_builder: |_| Cache::new(),
}
.build(),
); );
} }
@ -82,7 +51,7 @@ impl Pipeline {
pixels: &mut tiny_skia::PixmapMut<'_>, pixels: &mut tiny_skia::PixmapMut<'_>,
clip_mask: Option<&tiny_skia::ClipMask>, clip_mask: Option<&tiny_skia::ClipMask>,
) { ) {
self.system.as_mut().unwrap().with_mut(|fields| { let font_system = self.font_system.get_mut();
let key = Key { let key = Key {
bounds: { bounds: {
let size = bounds.size(); let size = bounds.size();
@ -95,7 +64,7 @@ impl Pipeline {
size, size,
}; };
let (_, buffer) = fields.render_cache.allocate(fields.fonts, key); let (_, buffer) = self.render_cache.allocate(font_system, key);
let (total_lines, max_width) = buffer let (total_lines, max_width) = buffer
.layout_runs() .layout_runs()
@ -118,14 +87,16 @@ impl Pipeline {
alignment::Vertical::Bottom => bounds.y - total_height, alignment::Vertical::Bottom => bounds.y - total_height,
}; };
let mut swash = cosmic_text::SwashCache::new(fields.fonts); let mut swash = cosmic_text::SwashCache::new();
for run in buffer.layout_runs() { for run in buffer.layout_runs() {
for glyph in run.glyphs { for glyph in run.glyphs {
if let Some((buffer, placement)) = self if let Some((buffer, placement)) = self.glyph_cache.allocate(
.glyph_cache glyph.cache_key,
.allocate(glyph.cache_key, color, &mut swash) color,
{ font_system,
&mut swash,
) {
let pixmap = tiny_skia::PixmapRef::from_bytes( let pixmap = tiny_skia::PixmapRef::from_bytes(
buffer, buffer,
placement.width, placement.width,
@ -145,15 +116,10 @@ impl Pipeline {
} }
} }
} }
});
} }
pub fn trim_cache(&mut self) { pub fn trim_cache(&mut self) {
self.system self.render_cache.trim();
.as_mut()
.unwrap()
.with_render_cache_mut(|cache| cache.trim());
self.glyph_cache.trim(); self.glyph_cache.trim();
} }
@ -164,11 +130,10 @@ impl Pipeline {
font: Font, font: Font,
bounds: Size, bounds: Size,
) -> (f32, f32) { ) -> (f32, f32) {
self.system.as_ref().unwrap().with(|fields| { let mut measurement_cache = self.measurement_cache.borrow_mut();
let mut measurement_cache = fields.measurement_cache.borrow_mut();
let (_, paragraph) = measurement_cache.allocate( let (_, paragraph) = measurement_cache.allocate(
fields.fonts, &mut self.font_system.borrow_mut(),
Key { Key {
content, content,
size, size,
@ -185,7 +150,6 @@ impl Pipeline {
}); });
(max_width, size * 1.2 * total_lines as f32) (max_width, size * 1.2 * total_lines as f32)
})
} }
pub fn hit_test( pub fn hit_test(
@ -197,11 +161,10 @@ impl Pipeline {
point: Point, point: Point,
_nearest_only: bool, _nearest_only: bool,
) -> Option<Hit> { ) -> Option<Hit> {
self.system.as_ref().unwrap().with(|fields| { let mut measurement_cache = self.measurement_cache.borrow_mut();
let mut measurement_cache = fields.measurement_cache.borrow_mut();
let (_, paragraph) = measurement_cache.allocate( let (_, paragraph) = measurement_cache.allocate(
fields.fonts, &mut self.font_system.borrow_mut(),
Key { Key {
content, content,
size, size,
@ -213,14 +176,10 @@ impl Pipeline {
let cursor = paragraph.hit(point.x, point.y)?; let cursor = paragraph.hit(point.x, point.y)?;
Some(Hit::CharOffset(cursor.index)) Some(Hit::CharOffset(cursor.index))
})
} }
pub fn trim_measurement_cache(&mut self) { pub fn trim_measurement_cache(&mut self) {
self.system self.measurement_cache.borrow_mut().trim();
.as_mut()
.unwrap()
.with_measurement_cache_mut(|cache| cache.borrow_mut().trim());
} }
} }
@ -256,14 +215,15 @@ impl GlyphCache {
&mut self, &mut self,
cache_key: cosmic_text::CacheKey, cache_key: cosmic_text::CacheKey,
color: Color, color: Color,
swash: &mut cosmic_text::SwashCache<'_>, font_system: &mut cosmic_text::FontSystem,
swash: &mut cosmic_text::SwashCache,
) -> Option<(&[u8], cosmic_text::Placement)> { ) -> Option<(&[u8], cosmic_text::Placement)> {
let [r, g, b, _a] = color.into_rgba8(); let [r, g, b, _a] = color.into_rgba8();
let key = (cache_key, [r, g, b]); let key = (cache_key, [r, g, b]);
if let hash_map::Entry::Vacant(entry) = self.entries.entry(key) { if let hash_map::Entry::Vacant(entry) = self.entries.entry(key) {
// TODO: Outline support // TODO: Outline support
let image = swash.get_image_uncached(cache_key)?; let image = swash.get_image_uncached(font_system, cache_key)?;
let glyph_size = image.placement.width as usize let glyph_size = image.placement.width as usize
* image.placement.height as usize; * image.placement.height as usize;
@ -343,8 +303,8 @@ impl GlyphCache {
} }
} }
struct Cache<'a> { struct Cache {
entries: FxHashMap<KeyHash, cosmic_text::Buffer<'a>>, entries: FxHashMap<KeyHash, cosmic_text::Buffer>,
recently_used: FxHashSet<KeyHash>, recently_used: FxHashSet<KeyHash>,
hasher: HashBuilder, hasher: HashBuilder,
} }
@ -355,7 +315,7 @@ type HashBuilder = twox_hash::RandomXxHashBuilder64;
#[cfg(target_arch = "wasm32")] #[cfg(target_arch = "wasm32")]
type HashBuilder = std::hash::BuildHasherDefault<twox_hash::XxHash64>; type HashBuilder = std::hash::BuildHasherDefault<twox_hash::XxHash64>;
impl<'a> Cache<'a> { impl Cache {
fn new() -> Self { fn new() -> Self {
Self { Self {
entries: FxHashMap::default(), entries: FxHashMap::default(),
@ -366,9 +326,9 @@ impl<'a> Cache<'a> {
fn allocate( fn allocate(
&mut self, &mut self,
fonts: &'a cosmic_text::FontSystem, font_system: &mut cosmic_text::FontSystem,
key: Key<'_>, key: Key<'_>,
) -> (KeyHash, &mut cosmic_text::Buffer<'a>) { ) -> (KeyHash, &mut cosmic_text::Buffer) {
let hash = { let hash = {
let mut hasher = self.hasher.build_hasher(); let mut hasher = self.hasher.build_hasher();
@ -383,13 +343,15 @@ impl<'a> Cache<'a> {
if let hash_map::Entry::Vacant(entry) = self.entries.entry(hash) { if let hash_map::Entry::Vacant(entry) = self.entries.entry(hash) {
let metrics = cosmic_text::Metrics::new(key.size, key.size * 1.2); let metrics = cosmic_text::Metrics::new(key.size, key.size * 1.2);
let mut buffer = cosmic_text::Buffer::new(fonts, metrics); let mut buffer = cosmic_text::Buffer::new(font_system, metrics);
buffer.set_size( buffer.set_size(
font_system,
key.bounds.width, key.bounds.width,
key.bounds.height.max(key.size * 1.2), key.bounds.height.max(key.size * 1.2),
); );
buffer.set_text( buffer.set_text(
font_system,
key.content, key.content,
cosmic_text::Attrs::new() cosmic_text::Attrs::new()
.family(to_family(key.font)) .family(to_family(key.font))

3
wgpu/Cargo.toml
View file

@ -21,7 +21,6 @@ futures = "0.3"
bitflags = "1.2" bitflags = "1.2"
once_cell = "1.0" once_cell = "1.0"
rustc-hash = "1.1" rustc-hash = "1.1"
ouroboros = "0.15"
[target.'cfg(target_arch = "wasm32")'.dependencies] [target.'cfg(target_arch = "wasm32")'.dependencies]
wgpu = { version = "0.14", features = ["webgl"] } wgpu = { version = "0.14", features = ["webgl"] }
@ -45,7 +44,7 @@ path = "../graphics"
[dependencies.glyphon] [dependencies.glyphon]
version = "0.2" version = "0.2"
git = "https://github.com/hecrj/glyphon.git" git = "https://github.com/hecrj/glyphon.git"
rev = "edd23695ad53db5f89d455c3c130172fd107d6a2" rev = "47050174841a4f58fc8d85c943a2117f72f19e8e"
[dependencies.encase] [dependencies.encase]
version = "0.3.0" version = "0.3.0"

108
wgpu/src/text.rs
View file

@ -12,23 +12,12 @@ use std::sync::Arc;
#[allow(missing_debug_implementations)] #[allow(missing_debug_implementations)]
pub struct Pipeline { pub struct Pipeline {
system: Option<System>, font_system: RefCell<glyphon::FontSystem>,
renderers: Vec<glyphon::TextRenderer>, renderers: Vec<glyphon::TextRenderer>,
atlas: glyphon::TextAtlas, atlas: glyphon::TextAtlas,
prepare_layer: usize, prepare_layer: usize,
} measurement_cache: RefCell<Cache>,
render_cache: Cache,
#[ouroboros::self_referencing]
struct System {
fonts: glyphon::FontSystem,
#[borrows(fonts)]
#[not_covariant]
measurement_cache: RefCell<Cache<'this>>,
#[borrows(fonts)]
#[not_covariant]
render_cache: Cache<'this>,
} }
impl Pipeline { impl Pipeline {
@ -38,42 +27,23 @@ impl Pipeline {
format: wgpu::TextureFormat, format: wgpu::TextureFormat,
) -> Self { ) -> Self {
Pipeline { Pipeline {
system: Some( font_system: RefCell::new(glyphon::FontSystem::new_with_fonts(
SystemBuilder {
fonts: glyphon::FontSystem::new_with_fonts(
[glyphon::fontdb::Source::Binary(Arc::new( [glyphon::fontdb::Source::Binary(Arc::new(
include_bytes!("../fonts/Iced-Icons.ttf") include_bytes!("../fonts/Iced-Icons.ttf").as_slice(),
.as_slice(),
))] ))]
.into_iter(), .into_iter(),
), )),
measurement_cache_builder: |_| RefCell::new(Cache::new()),
render_cache_builder: |_| Cache::new(),
}
.build(),
),
renderers: Vec::new(), renderers: Vec::new(),
atlas: glyphon::TextAtlas::new(device, queue, format), atlas: glyphon::TextAtlas::new(device, queue, format),
prepare_layer: 0, prepare_layer: 0,
measurement_cache: RefCell::new(Cache::new()),
render_cache: Cache::new(),
} }
} }
pub fn load_font(&mut self, bytes: Cow<'static, [u8]>) { pub fn load_font(&mut self, bytes: Cow<'static, [u8]>) {
let heads = self.system.take().unwrap().into_heads(); self.font_system.get_mut().db_mut().load_font_source(
glyphon::fontdb::Source::Binary(Arc::new(bytes.into_owned())),
let (locale, mut db) = heads.fonts.into_locale_and_db();
db.load_font_source(glyphon::fontdb::Source::Binary(Arc::new(
bytes.into_owned(),
)));
self.system = Some(
SystemBuilder {
fonts: glyphon::FontSystem::new_with_locale_and_db(locale, db),
measurement_cache_builder: |_| RefCell::new(Cache::new()),
render_cache_builder: |_| Cache::new(),
}
.build(),
); );
} }
@ -86,26 +56,25 @@ impl Pipeline {
scale_factor: f32, scale_factor: f32,
target_size: Size<u32>, target_size: Size<u32>,
) -> bool { ) -> bool {
self.system.as_mut().unwrap().with_mut(|fields| {
if self.renderers.len() <= self.prepare_layer { if self.renderers.len() <= self.prepare_layer {
self.renderers self.renderers
.push(glyphon::TextRenderer::new(device, queue)); .push(glyphon::TextRenderer::new(device, queue));
} }
let font_system = self.font_system.get_mut();
let renderer = &mut self.renderers[self.prepare_layer]; let renderer = &mut self.renderers[self.prepare_layer];
let keys: Vec<_> = sections let keys: Vec<_> = sections
.iter() .iter()
.map(|section| { .map(|section| {
let (key, _) = fields.render_cache.allocate( let (key, _) = self.render_cache.allocate(
fields.fonts, font_system,
Key { Key {
content: section.content, content: section.content,
size: section.size * scale_factor, size: section.size * scale_factor,
font: section.font, font: section.font,
bounds: Size { bounds: Size {
width: (section.bounds.width * scale_factor) width: (section.bounds.width * scale_factor).ceil(),
.ceil(),
height: (section.bounds.height * scale_factor) height: (section.bounds.height * scale_factor)
.ceil(), .ceil(),
}, },
@ -125,10 +94,8 @@ impl Pipeline {
let text_areas = let text_areas =
sections.iter().zip(keys.iter()).map(|(section, key)| { sections.iter().zip(keys.iter()).map(|(section, key)| {
let buffer = fields let buffer =
.render_cache self.render_cache.get(key).expect("Get cached buffer");
.get(key)
.expect("Get cached buffer");
let x = section.bounds.x * scale_factor; let x = section.bounds.x * scale_factor;
let y = section.bounds.y * scale_factor; let y = section.bounds.y * scale_factor;
@ -176,13 +143,14 @@ impl Pipeline {
let result = renderer.prepare( let result = renderer.prepare(
device, device,
queue, queue,
font_system,
&mut self.atlas, &mut self.atlas,
glyphon::Resolution { glyphon::Resolution {
width: target_size.width, width: target_size.width,
height: target_size.height, height: target_size.height,
}, },
text_areas, text_areas,
&mut glyphon::SwashCache::new(fields.fonts), &mut glyphon::SwashCache::new(),
); );
match result { match result {
@ -205,7 +173,6 @@ impl Pipeline {
} }
} }
} }
})
} }
pub fn render<'a>( pub fn render<'a>(
@ -230,11 +197,7 @@ impl Pipeline {
pub fn end_frame(&mut self) { pub fn end_frame(&mut self) {
self.atlas.trim(); self.atlas.trim();
self.render_cache.trim();
self.system
.as_mut()
.unwrap()
.with_render_cache_mut(|cache| cache.trim());
self.prepare_layer = 0; self.prepare_layer = 0;
} }
@ -246,11 +209,10 @@ impl Pipeline {
font: Font, font: Font,
bounds: Size, bounds: Size,
) -> (f32, f32) { ) -> (f32, f32) {
self.system.as_ref().unwrap().with(|fields| { let mut measurement_cache = self.measurement_cache.borrow_mut();
let mut measurement_cache = fields.measurement_cache.borrow_mut();
let (_, paragraph) = measurement_cache.allocate( let (_, paragraph) = measurement_cache.allocate(
fields.fonts, &mut self.font_system.borrow_mut(),
Key { Key {
content, content,
size, size,
@ -267,7 +229,6 @@ impl Pipeline {
}); });
(max_width, size * 1.2 * total_lines as f32) (max_width, size * 1.2 * total_lines as f32)
})
} }
pub fn hit_test( pub fn hit_test(
@ -279,11 +240,10 @@ impl Pipeline {
point: Point, point: Point,
_nearest_only: bool, _nearest_only: bool,
) -> Option<Hit> { ) -> Option<Hit> {
self.system.as_ref().unwrap().with(|fields| { let mut measurement_cache = self.measurement_cache.borrow_mut();
let mut measurement_cache = fields.measurement_cache.borrow_mut();
let (_, paragraph) = measurement_cache.allocate( let (_, paragraph) = measurement_cache.allocate(
fields.fonts, &mut self.font_system.borrow_mut(),
Key { Key {
content, content,
size, size,
@ -295,14 +255,10 @@ impl Pipeline {
let cursor = paragraph.hit(point.x, point.y)?; let cursor = paragraph.hit(point.x, point.y)?;
Some(Hit::CharOffset(cursor.index)) Some(Hit::CharOffset(cursor.index))
})
} }
pub fn trim_measurement_cache(&mut self) { pub fn trim_measurement_cache(&mut self) {
self.system self.measurement_cache.borrow_mut().trim();
.as_mut()
.unwrap()
.with_measurement_cache_mut(|cache| cache.borrow_mut().trim());
} }
} }
@ -317,8 +273,8 @@ fn to_family(font: Font) -> glyphon::Family<'static> {
} }
} }
struct Cache<'a> { struct Cache {
entries: FxHashMap<KeyHash, glyphon::Buffer<'a>>, entries: FxHashMap<KeyHash, glyphon::Buffer>,
recently_used: FxHashSet<KeyHash>, recently_used: FxHashSet<KeyHash>,
hasher: HashBuilder, hasher: HashBuilder,
} }
@ -329,7 +285,7 @@ type HashBuilder = twox_hash::RandomXxHashBuilder64;
#[cfg(target_arch = "wasm32")] #[cfg(target_arch = "wasm32")]
type HashBuilder = std::hash::BuildHasherDefault<twox_hash::XxHash64>; type HashBuilder = std::hash::BuildHasherDefault<twox_hash::XxHash64>;
impl<'a> Cache<'a> { impl Cache {
fn new() -> Self { fn new() -> Self {
Self { Self {
entries: FxHashMap::default(), entries: FxHashMap::default(),
@ -338,15 +294,15 @@ impl<'a> Cache<'a> {
} }
} }
fn get(&self, key: &KeyHash) -> Option<&glyphon::Buffer<'a>> { fn get(&self, key: &KeyHash) -> Option<&glyphon::Buffer> {
self.entries.get(key) self.entries.get(key)
} }
fn allocate( fn allocate(
&mut self, &mut self,
fonts: &'a glyphon::FontSystem, font_system: &mut glyphon::FontSystem,
key: Key<'_>, key: Key<'_>,
) -> (KeyHash, &mut glyphon::Buffer<'a>) { ) -> (KeyHash, &mut glyphon::Buffer) {
let hash = { let hash = {
let mut hasher = self.hasher.build_hasher(); let mut hasher = self.hasher.build_hasher();
@ -361,13 +317,15 @@ impl<'a> Cache<'a> {
if let hash_map::Entry::Vacant(entry) = self.entries.entry(hash) { if let hash_map::Entry::Vacant(entry) = self.entries.entry(hash) {
let metrics = glyphon::Metrics::new(key.size, key.size * 1.2); let metrics = glyphon::Metrics::new(key.size, key.size * 1.2);
let mut buffer = glyphon::Buffer::new(fonts, metrics); let mut buffer = glyphon::Buffer::new(font_system, metrics);
buffer.set_size( buffer.set_size(
font_system,
key.bounds.width, key.bounds.width,
key.bounds.height.max(key.size * 1.2), key.bounds.height.max(key.size * 1.2),
); );
buffer.set_text( buffer.set_text(
font_system,
key.content, key.content,
glyphon::Attrs::new() glyphon::Attrs::new()
.family(to_family(key.font)) .family(to_family(key.font))