109 lines
3.8 KiB
Rust
109 lines
3.8 KiB
Rust
use std::collections::HashMap;
|
|
use swash::scale::{ScaleContext, image::Content};
|
|
use swash::scale::{Render, Source, StrikeWith};
|
|
use swash::zeno::{Format, Vector};
|
|
|
|
use crate::{CacheKey, FontMatches};
|
|
|
|
pub use swash::scale::image::Image as SwashImage;
|
|
|
|
pub struct SwashCache {
|
|
context: ScaleContext,
|
|
pub image_cache: HashMap<CacheKey, Option<SwashImage>>,
|
|
}
|
|
|
|
impl SwashCache {
|
|
/// Create a new swash cache
|
|
pub fn new() -> Self {
|
|
Self {
|
|
context: ScaleContext::new(),
|
|
image_cache: HashMap::new()
|
|
}
|
|
}
|
|
|
|
/// Create a swash Image from a cache key, caching results
|
|
pub fn get_image(&mut self, matches: &FontMatches<'_>, cache_key: CacheKey) -> &Option<SwashImage> {
|
|
self.image_cache.entry(cache_key).or_insert_with(|| {
|
|
let font = match matches.get_font(&cache_key.font_id) {
|
|
Some(some) => some,
|
|
None => {
|
|
log::warn!("did not find font {:?}", cache_key.font_id);
|
|
return None;
|
|
},
|
|
};
|
|
|
|
// Build the scaler
|
|
let mut scaler = self.context
|
|
.builder(font.swash)
|
|
.size(cache_key.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(cache_key.x_bin.as_float(), cache_key.y_bin.as_float());
|
|
|
|
// Select our source order
|
|
Render::new(&[
|
|
// Color outline with the first palette
|
|
Source::ColorOutline(0),
|
|
// Color bitmap with best fit selection mode
|
|
Source::ColorBitmap(StrikeWith::BestFit),
|
|
// Standard scalable outline
|
|
Source::Outline,
|
|
])
|
|
// Select a subpixel format
|
|
.format(Format::Alpha)
|
|
// Apply the fractional offset
|
|
.offset(offset)
|
|
// Render the image
|
|
.render(&mut scaler, cache_key.glyph_id)
|
|
})
|
|
}
|
|
|
|
/// Enumerate pixels in an Image, use `with_image` for better performance
|
|
pub fn with_pixels<F: FnMut(i32, i32, u32)>(
|
|
&mut self,
|
|
matches: &FontMatches<'_>,
|
|
cache_key: CacheKey,
|
|
base: u32,
|
|
mut f: F
|
|
) {
|
|
if let Some(image) = self.get_image(matches, cache_key) {
|
|
let x = image.placement.left;
|
|
let y = -image.placement.top;
|
|
|
|
match image.content {
|
|
Content::Mask => {
|
|
let mut i = 0;
|
|
for off_y in 0..image.placement.height as i32 {
|
|
for off_x in 0..image.placement.width as i32 {
|
|
//TODO: blend base alpha?
|
|
let color = (image.data[i] as u32) << 24 | base & 0xFFFFFF;
|
|
f(x + off_x, y + off_y, color);
|
|
i += 1;
|
|
}
|
|
}
|
|
}
|
|
Content::Color => {
|
|
let mut i = 0;
|
|
for off_y in 0..image.placement.height as i32 {
|
|
for off_x in 0..image.placement.width as i32 {
|
|
//TODO: blend base alpha?
|
|
let color = (image.data[i + 3] as u32) << 24
|
|
| (image.data[i] as u32) << 16
|
|
| (image.data[i + 1] as u32) << 8
|
|
| (image.data[i + 2] as u32);
|
|
f(x + off_x, y + off_y, color);
|
|
i += 4;
|
|
}
|
|
}
|
|
}
|
|
Content::SubpixelMask => {
|
|
log::warn!("TODO: SubpixelMask");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|