Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-fonts

Source of release 0.7.1

0.7.1 / tests / programs / fonts / main.lucb

## Native font metrics, grayscale coverage and the copied GPU mask contract.
from luce_fonts import fonts
from luce_gpu import gpu
import memory
import platform
from luce_window import window

pub func main(arguments: str[]) -> i32!:
    try proportional()
    var face = try fonts.Face()
    defer face.close()
    assert(face.size == 14.0 and face.advance > 0.0 and face.ascent > 0.0 and face.descent >= 0.0)
    assert(try face.measure("iii") == try face.measure("WWW"))
    assert(try face.measure("é—") == face.advance * 2.0)
    try wide_cells(&face)
    var blank = try face.rasterize("   ", 2.0)
    defer blank.close()
    for pixel in blank.pixels:
        assert(pixel == 0)
    for scale in [1.0, 2.0]:
        var raster = try face.rasterize("Ag0 é—", scale)
        defer raster.close()
        assert(raster.pixels.length == (usize)raster.width * (usize)raster.height)
        var visible: usize = 0
        var gray: usize = 0
        for pixel in raster.pixels:
            if pixel > 0:
                visible += 1
            if pixel > 0 and pixel < 255:
                gray += 1
        assert(visible > 20 and gray > 10)
        assert(visible < raster.pixels.length // 2)
        # Padding must be transparent, so adjacent runs cannot paint rectangles.
        for column in 0..<(usize)raster.width:
            assert(raster.pixels[column] == 0)
            assert(raster.pixels[((usize)raster.height - 1) * (usize)raster.width + column] == 0)
    var invalid = false
    var bad: fonts.Face? = fonts.Face(size = 0.0) catch failure:
        assert(failure.code == fonts.failed)
        invalid = true
        recover none
    assert(invalid)
    if let loaded = bad:
        var unexpected = loaded
        unexpected.close()
    var invalid_bytes: u8[1] = [255]
    var malformed = false
    _ = face.measure((str)invalid_bytes[..<1]) catch failure:
        assert(failure.code == fonts.failed)
        malformed = true
    assert(malformed)
    var frame = try gpu.Frame(window.Size(100.0, 80.0, 200.0, 160.0, 2.0))
    defer frame.close()
    let target = try frame.target()
    defer target.release()
    var coverage: u8[4] = [0, 85, 170, 255]
    try target.get().mask(coverage, 4, 1, gpu.Rect(10.0, 10.0, 40.0, 10.0), gpu.Color(1.0, 1.0, 1.0))
    coverage[0] = 255
    var rejected = false
    target.get().mask(coverage, 3, 1, gpu.Rect(10.0, 10.0, 40.0, 10.0), gpu.Color()) catch failure:
        assert(failure.code == gpu.invalid_geometry)
        rejected = true
    assert(rejected)
    frame.close()
    var expired = false
    target.get().mask(coverage, 4, 1, gpu.Rect(10.0, 10.0, 40.0, 10.0), gpu.Color()) catch failure:
        expired = true
    assert(expired)
    print("ok native monospace metrics, grayscale glyphs and scoped GPU coverage")
    return 0

## Proportional type: families and styles listed, a face that is not
## monospace, text broken into lines in a box, aligned, tracked and led.
func proportional() -> !:
    var families = try fonts.families()
    defer families.close()
    assert(families.length() > 0)
    let family = "Helvetica" if platform.macos else ("Arial" if platform.windows else "Sans")
    if platform.macos or platform.windows:
        assert(families.contains(family))
    var styles = try fonts.styles(family)
    defer styles.close()
    assert(styles.length() > 0)
    var face = try fonts.TypeFace(family, "Regular", 40.0)
    defer face.close()
    assert(face.ascent > 20.0 and face.descent > 0.0 and face.line_height() >= face.ascent + face.descent)
    assert((try face.measure("iiii")) < (try face.measure("WWWW")))
    var point = try fonts.set_text(&face, "Hello\nworld", fonts.Setting())
    defer point.close()
    let hello = try face.measure("Hello")
    let world = try face.measure("world")
    assert(point.lines == 2 and point.width == (hello if hello > world else world))
    var visible: usize = 0
    for pixel in point.bitmap.pixels:
        if pixel > 128:
            visible += 1
    assert(visible > 200)
    # In a box 200 wide the words wrap; tracking widens a line; leading spaces the lines.
    var boxed = try fonts.set_text(&face, "The quick brown fox jumps over the lazy dog", fonts.Setting(width = 200.0, alignment = 1))
    defer boxed.close()
    assert(boxed.lines >= 3 and boxed.width == 200.0)
    var tracked = try fonts.set_text(&face, "Hello", fonts.Setting(tracking = 200.0))
    defer tracked.close()
    assert(tracked.width > hello + 30.0)
    var led = try fonts.set_text(&face, "a\nb", fonts.Setting(leading = 100.0))
    defer led.close()
    assert(led.height > 100.0 + face.ascent)
    var justified = try fonts.set_text(&face, "one two three four five six", fonts.Setting(width = 260.0, alignment = 3))
    defer justified.close()
    assert(justified.lines >= 2)

## Wide scalars take two cells and marks none: in measure, in the bitmap's width and
## in where each glyph lands. "田a" draws its 'a' exactly where "  a" does.
func wide_cells(face: fonts.Face*) -> !:
    assert(try face.measure("田中") == face.advance * 4.0)
    assert(try face.measure("会議の件") == face.advance * 8.0)
    assert(try face.measure("e\u{301}") == face.advance)
    assert(try face.measure("\u{20000}x") == face.advance * 3.0)
    assert(try fonts.text_cells("田a") == 3)
    for scale in [1.0, 2.0]:
        var wide = try face.rasterize("田a", scale)
        defer wide.close()
        var narrow = try face.rasterize("  a", scale)
        defer narrow.close()
        assert(wide.width == narrow.width and wide.height == narrow.height)
        let cell = face.advance * scale
        # Everything from just past the second cell on is the 'a', placed alike.
        let boundary = (usize)(2.0 + 2.0 * cell) + 1
        var ink: usize = 0
        for row in 0..<(usize)wide.height:
            for column in boundary..<(usize)wide.width:
                let at = row * (usize)wide.width + column
                assert(wide.pixels[at] == narrow.pixels[at])
                if wide.pixels[at] > 0:
                    ink += 1
        assert(ink > 4)
        # The ideograph spans both of its cells: ink on either side of the first cell's edge.
        var left = false
        var right = false
        for row in 0..<(usize)wide.height:
            for column in 2..<boundary - 1:
                if wide.pixels[row * (usize)wide.width + column] > 0:
                    if (f64)column < 2.0 + cell:
                        left = true
                    else:
                        right = true
        assert(left and right)
        # A combining mark composes over its base: no extra cell, more ink.
        var plain = try face.rasterize("e", scale)
        defer plain.close()
        var marked = try face.rasterize("e\u{301}", scale)
        defer marked.close()
        assert(marked.width == plain.width)
        var plain_ink: usize = 0
        var marked_ink: usize = 0
        for at in 0..<plain.pixels.length:
            if plain.pixels[at] > 0:
                plain_ink += 1
            if marked.pixels[at] > 0:
                marked_ink += 1
        assert(marked_ink > plain_ink)