leyoda/libcosmic
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add support for swash

Browse source
This commit is contained in:
Jeremy Soller 2022-10-07 09:41:36 -06:00
parent 51639e53cb
commit cf43655357
No known key found for this signature in database
GPG key ID: 87F211AF2BE4C2FE
7 changed files with 116 additions and 66 deletions
Download patch file Download diff file Expand all files Collapse all files

1
examples/text/Cargo.toml
View file

@ -10,6 +10,7 @@ ab_glyph = { version = "0.2", optional = true }
orbclient = "0.3"
rusttype = { version = "0.9", optional = true }
rustybuzz = "0.5"
swash = { version = "0.1", optional = true }
unicode-bidi = "0.3"
unicode-linebreak = "0.1"
unicode-script = "0.5"

24
examples/text/src/font/layout.rs
View file

@ -11,6 +11,8 @@ pub struct FontLayoutGlyph<'a, T: 'a> {
pub inner: Option<ab_glyph::OutlinedGlyph>,
#[cfg(feature = "rusttype")]
pub inner: rusttype::PositionedGlyph<'a>,
#[cfg(feature = "swash")]
pub inner: Option<swash::scale::image::Image>,
pub phantom: PhantomData<&'a T>,
}
@ -20,7 +22,7 @@ pub struct FontLayoutLine<'a> {
}
impl<'a> FontLayoutLine<'a> {
pub fn draw<F: FnMut(i32, i32, f32)>(&self, mut f: F) {
pub fn draw<F: FnMut(i32, i32, u8)>(&self, mut f: F) {
for glyph in self.glyphs.iter() {
#[cfg(feature = "ab_glyph")]
if let Some(ref outline) = glyph.inner {
@ -28,7 +30,7 @@ impl<'a> FontLayoutLine<'a> {
let x = bb.min.x as i32;
let y = bb.min.y as i32;
outline.draw(|off_x, off_y, v| {
f(x + off_x as i32, y + off_y as i32, v);
f(x + off_x as i32, y + off_y as i32, (v * 255.0) as u8);
});
}
@ -37,9 +39,25 @@ impl<'a> FontLayoutLine<'a> {
let x = bb.min.x;
let y = bb.min.y;
glyph.inner.draw(|off_x, off_y, v| {
f(x + off_x as i32, y + off_y as i32, v);
f(x + off_x as i32, y + off_y as i32, (v * 255.0) as u8);
});
}
#[cfg(feature = "swash")]
if let Some(ref image) = glyph.inner {
assert_eq!(image.content, swash::scale::image::Content::Mask);
let x = glyph.x as i32 + image.placement.left;
let y = -image.placement.top;
let mut i = 0;
for off_y in 0..image.placement.height as i32 {
for off_x in 0..image.placement.width as i32 {
f(x + off_x, y + off_y, image.data[i]);
i += 1;
}
}
}
}
}
}

5
examples/text/src/font/matches.rs
View file

@ -40,6 +40,9 @@ impl<'a> FontMatches<'a> {
#[cfg(feature = "rusttype")]
let inner = font.rusttype.glyph(rusttype::GlyphId(info.glyph_id as u16));
#[cfg(feature = "swash")]
let inner = info.glyph_id as swash::GlyphId;
glyphs.push(FontShapeGlyph {
start: start_word + info.cluster as usize,
end: end_word, // Set later
@ -49,6 +52,8 @@ impl<'a> FontMatches<'a> {
y_offset,
#[cfg(feature = "ab_glyph")]
font: &font.ab_glyph,
#[cfg(feature = "swash")]
font: &font.swash,
inner,
});
}

4
examples/text/src/font/mod.rs
View file

@ -30,6 +30,8 @@ pub struct Font<'a> {
pub ab_glyph: ab_glyph::FontRef<'a>,
#[cfg(feature = "rusttype")]
pub rusttype: rusttype::Font<'a>,
#[cfg(feature = "swash")]
pub swash: swash::FontRef<'a>,
}
impl<'a> Font<'a> {
@ -41,6 +43,8 @@ impl<'a> Font<'a> {
ab_glyph: ab_glyph::FontRef::try_from_slice_and_index(data, index).ok()?,
#[cfg(feature = "rusttype")]
rusttype: rusttype::Font::try_from_bytes_and_index(data, index)?,
#[cfg(feature = "swash")]
swash: swash::FontRef::from_index(data, index as usize)?,
})
}
}

137
examples/text/src/font/shape.rs
View file

@ -17,6 +17,83 @@ pub struct FontShapeGlyph<'a> {
pub inner: ab_glyph::GlyphId,
#[cfg(feature = "rusttype")]
pub inner: rusttype::Glyph<'a>,
#[cfg(feature = "swash")]
pub font: &'a swash::FontRef<'a>,
#[cfg(feature = "swash")]
pub inner: swash::GlyphId,
}
impl<'a> FontShapeGlyph<'a> {
fn layout(&self, font_size: i32, x: f32, y: f32) -> FontLayoutGlyph<'a, ()> {
let x_offset = font_size as f32 * self.x_offset;
let y_offset = font_size as f32 * self.y_offset;
let x_advance = font_size as f32 * self.x_advance;
#[cfg(feature = "ab_glyph")]
let inner = self.font.outline_glyph(
self.inner.with_scale_and_position(
font_size as f32,
ab_glyph::point(
x + x_offset,
y + y_offset,
)
)
);
#[cfg(feature = "rusttype")]
let inner = self.inner.clone()
.scaled(rusttype::Scale::uniform(font_size as f32))
.positioned(rusttype::point(
x + x_offset,
y + y_offset,
));
#[cfg(feature = "swash")]
let inner = {
use swash::scale::{Render, ScaleContext, Source, StrikeWith};
use swash::zeno::{Format, Vector};
//TODO: store somewhere else
static mut CONTEXT: Option<ScaleContext> = None;
unsafe {
if CONTEXT.is_none() {
CONTEXT = Some(ScaleContext::new());
}
}
// Build the scaler
let mut scaler = unsafe { CONTEXT.as_mut().unwrap() }
.builder(*self.font)
.size(font_size as f32)
.hint(true)
.build();
// Compute the fractional offset-- you'll likely want to quantize this
// in a real renderer
let offset = Vector::new(x_offset, y_offset);
// Select our source order
Render::new(&[
Source::Outline,
])
// Select a subpixel format
.format(Format::Alpha)
// Apply the fractional offset
.offset(offset)
// Render the image
.render(&mut scaler, self.inner)
};
FontLayoutGlyph {
start: self.start,
end: self.end,
x: x,
w: x_advance,
inner,
phantom: PhantomData,
}
}
}
pub struct FontShapeWord<'a> {
@ -66,36 +143,8 @@ impl<'a> FontShapeLine<'a> {
for glyph in word.glyphs.iter() {
let x_advance = font_size as f32 * glyph.x_advance;
let y_advance = font_size as f32 * glyph.y_advance;
let x_offset = font_size as f32 * glyph.x_offset;
let y_offset = font_size as f32 * glyph.y_offset;
#[cfg(feature = "ab_glyph")]
let inner = glyph.font.outline_glyph(
glyph.inner.with_scale_and_position(
font_size as f32,
ab_glyph::point(
x + x_offset,
y + y_offset,
)
)
);
#[cfg(feature = "rusttype")]
let inner = glyph.inner.clone()
.scaled(rusttype::Scale::uniform(font_size as f32))
.positioned(rusttype::point(
x + x_offset,
y + y_offset,
));
glyphs.push(FontLayoutGlyph {
start: glyph.start,
end: glyph.end,
x,
w: x_advance,
inner,
phantom: PhantomData,
});
glyphs.push(glyph.layout(font_size, x, y));
push_line = true;
x += x_advance;
@ -142,38 +191,10 @@ impl<'a> FontShapeLine<'a> {
for glyph in word.glyphs.iter().rev() {
let x_advance = font_size as f32 * glyph.x_advance;
let y_advance = font_size as f32 * glyph.y_advance;
let x_offset = font_size as f32 * glyph.x_offset;
let y_offset = font_size as f32 * glyph.y_offset;
x -= x_advance;
#[cfg(feature = "ab_glyph")]
let inner = glyph.font.outline_glyph(
glyph.inner.with_scale_and_position(
font_size as f32,
ab_glyph::point(
x + x_offset,
y + y_offset,
)
)
);
#[cfg(feature = "rusttype")]
let inner = glyph.inner.clone()
.scaled(rusttype::Scale::uniform(font_size as f32))
.positioned(rusttype::point(
x + x_offset,
y + y_offset,
));
glyphs.push(FontLayoutGlyph {
start: glyph.start,
end: glyph.end,
x,
w: x_advance,
inner,
phantom: PhantomData,
});
glyphs.push(glyph.layout(font_size, x, y));
push_line = true;
y += y_advance;

4
examples/text/src/font/system.rs
View file

@ -53,7 +53,9 @@ impl<'a> FontSystem<'a> {
}
}
if ! fonts.is_empty() {
Some(FontMatches { fonts })
Some(FontMatches {
fonts
})
} else {
None
}

7
examples/text/src/main.rs
View file

@ -202,10 +202,9 @@ fn main() {
}
}
line.draw(|x, y, v| {
let c = (v * 255.0) as u32;
window.pixel(line_x + x, line_y + y, Color{
data: c << 24 | (font_color.data & 0x00FF_FFFF)
line.draw(|x, y, alpha| {
window.pixel(line_x + x, line_y + y, Color {
data: (alpha as u32) << 24 | (font_color.data & 0x00FF_FFFF)
});
});