dymokomi/luce-fonts
Source of release 0.7.2
0.7.2 / tests / native_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)