105 lines
3.1 KiB
Rust
105 lines
3.1 KiB
Rust
use crate::{convert, Unit::*};
|
|
use ttf_parser::colr::{self, Painter};
|
|
use ttf_parser::{cpal, GlyphId, RgbaColor};
|
|
|
|
#[test]
|
|
fn basic() {
|
|
let cpal_data = convert(&[
|
|
UInt16(0), // version
|
|
UInt16(3), // number of palette entries
|
|
UInt16(1), // number of palettes
|
|
UInt16(3), // number of colors
|
|
UInt32(14), // offset to colors
|
|
UInt16(0), // index of palette 0's first color
|
|
UInt8(10), UInt8(15), UInt8(20), UInt8(25), // color 0
|
|
UInt8(30), UInt8(35), UInt8(40), UInt8(45), // color 1
|
|
UInt8(50), UInt8(55), UInt8(60), UInt8(65), // color 2
|
|
]);
|
|
|
|
let colr_data = convert(&[
|
|
UInt16(0), // version
|
|
UInt16(3), // number of base glyphs
|
|
UInt32(14), // offset to base glyphs
|
|
UInt32(32), // offset to layers
|
|
UInt16(4), // number of layers
|
|
UInt16(2), UInt16(2), UInt16(2), // base glyph 0 (id 2)
|
|
UInt16(3), UInt16(0), UInt16(3), // base glyph 1 (id 3)
|
|
UInt16(7), UInt16(1), UInt16(1), // base glyph 2 (id 7)
|
|
UInt16(10), UInt16(2), // layer 0
|
|
UInt16(11), UInt16(1), // layer 1
|
|
UInt16(12), UInt16(2), // layer 2
|
|
UInt16(13), UInt16(0), // layer 3
|
|
]);
|
|
|
|
let cpal = cpal::Table::parse(&cpal_data).unwrap();
|
|
let colr = colr::Table::parse(cpal, &colr_data).unwrap();
|
|
let paint = |id| {
|
|
let mut painter = VecPainter(vec![]);
|
|
colr.paint(GlyphId(id), 0, &mut painter).map(|_| painter.0)
|
|
};
|
|
|
|
let a = RgbaColor::new(20, 15, 10, 25);
|
|
let b = RgbaColor::new(40, 35, 30, 45);
|
|
let c = RgbaColor::new(60, 55, 50, 65);
|
|
|
|
assert_eq!(cpal.get(0, 0), Some(a));
|
|
assert_eq!(cpal.get(0, 1), Some(b));
|
|
assert_eq!(cpal.get(0, 2), Some(c));
|
|
assert_eq!(cpal.get(0, 3), None);
|
|
assert_eq!(cpal.get(1, 0), None);
|
|
|
|
assert!(!colr.contains(GlyphId(1)));
|
|
assert!(colr.contains(GlyphId(2)));
|
|
assert!(colr.contains(GlyphId(3)));
|
|
assert!(!colr.contains(GlyphId(4)));
|
|
assert!(!colr.contains(GlyphId(5)));
|
|
assert!(!colr.contains(GlyphId(6)));
|
|
assert!(colr.contains(GlyphId(7)));
|
|
|
|
assert_eq!(paint(1), None);
|
|
|
|
assert_eq!(paint(2).unwrap(), vec![
|
|
Command::Outline(12),
|
|
Command::PaintColor(c),
|
|
Command::Outline(13),
|
|
Command::PaintColor(a),
|
|
]);
|
|
|
|
assert_eq!(paint(3).unwrap(), vec![
|
|
Command::Outline(10),
|
|
Command::PaintColor(c),
|
|
Command::Outline(11),
|
|
Command::PaintColor(b),
|
|
Command::Outline(12),
|
|
Command::PaintColor(c),
|
|
]);
|
|
|
|
assert_eq!(paint(7).unwrap(), vec![
|
|
Command::Outline(11),
|
|
Command::PaintColor(b),
|
|
]);
|
|
}
|
|
|
|
#[derive(Clone, Copy, PartialEq, Debug)]
|
|
enum Command {
|
|
Outline(u16),
|
|
Foreground,
|
|
PaintColor(RgbaColor),
|
|
}
|
|
|
|
struct VecPainter(Vec<Command>);
|
|
|
|
impl Painter for VecPainter {
|
|
fn outline(&mut self, glyph_id: GlyphId) {
|
|
self.0.push(Command::Outline(glyph_id.0));
|
|
}
|
|
|
|
fn paint_foreground(&mut self) {
|
|
self.0.push(Command::Foreground);
|
|
}
|
|
|
|
fn paint_color(&mut self, color: RgbaColor) {
|
|
self.0.push(Command::PaintColor(color));
|
|
}
|
|
}
|