130 lines
3.5 KiB
Go
130 lines
3.5 KiB
Go
// Copyright 2015 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
//go:generate go run gen.go
|
|
|
|
// Package basicfont provides fixed-size font faces.
|
|
package basicfont // import "git.fireandbrimst.one/aw/golang-image/font/basicfont"
|
|
|
|
import (
|
|
"image"
|
|
|
|
"git.fireandbrimst.one/aw/golang-image/font"
|
|
"git.fireandbrimst.one/aw/golang-image/math/fixed"
|
|
)
|
|
|
|
// Range maps a contiguous range of runes to vertically adjacent sub-images of
|
|
// a Face's Mask image. The rune range is inclusive on the low end and
|
|
// exclusive on the high end.
|
|
//
|
|
// If Low <= r && r < High, then the rune r is mapped to the sub-image of
|
|
// Face.Mask whose bounds are image.Rect(0, y*h, Face.Width, (y+1)*h),
|
|
// where y = (int(r-Low) + Offset) and h = (Face.Ascent + Face.Descent).
|
|
type Range struct {
|
|
Low, High rune
|
|
Offset int
|
|
}
|
|
|
|
// Face7x13 is a Face derived from the public domain X11 misc-fixed font files.
|
|
//
|
|
// At the moment, it holds the printable characters in ASCII starting with
|
|
// space, and the Unicode replacement character U+FFFD.
|
|
//
|
|
// Its data is entirely self-contained and does not require loading from
|
|
// separate files.
|
|
var Face7x13 = &Face{
|
|
Advance: 7,
|
|
Width: 6,
|
|
Height: 13,
|
|
Ascent: 11,
|
|
Descent: 2,
|
|
Mask: mask7x13,
|
|
Ranges: []Range{
|
|
{'\u0020', '\u007f', 0},
|
|
{'\ufffd', '\ufffe', 95},
|
|
},
|
|
}
|
|
|
|
// Face is a basic font face whose glyphs all have the same metrics.
|
|
//
|
|
// It is safe to use concurrently.
|
|
type Face struct {
|
|
// Advance is the glyph advance, in pixels.
|
|
Advance int
|
|
// Width is the glyph width, in pixels.
|
|
Width int
|
|
// Height is the inter-line height, in pixels.
|
|
Height int
|
|
// Ascent is the glyph ascent, in pixels.
|
|
Ascent int
|
|
// Descent is the glyph descent, in pixels.
|
|
Descent int
|
|
// Left is the left side bearing, in pixels. A positive value means that
|
|
// all of a glyph is to the right of the dot.
|
|
Left int
|
|
|
|
// Mask contains all of the glyph masks. Its width is typically the Face's
|
|
// Width, and its height a multiple of the Face's Height.
|
|
Mask image.Image
|
|
// Ranges map runes to sub-images of Mask. The rune ranges must not
|
|
// overlap, and must be in increasing rune order.
|
|
Ranges []Range
|
|
}
|
|
|
|
func (f *Face) Close() error { return nil }
|
|
func (f *Face) Kern(r0, r1 rune) fixed.Int26_6 { return 0 }
|
|
|
|
func (f *Face) Metrics() font.Metrics {
|
|
return font.Metrics{
|
|
Height: fixed.I(f.Height),
|
|
Ascent: fixed.I(f.Ascent),
|
|
Descent: fixed.I(f.Descent),
|
|
XHeight: fixed.I(f.Ascent),
|
|
CapHeight: fixed.I(f.Ascent),
|
|
CaretSlope: image.Point{X: 0, Y: 1},
|
|
}
|
|
}
|
|
|
|
func (f *Face) Glyph(dot fixed.Point26_6, r rune) (
|
|
dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool) {
|
|
|
|
loop:
|
|
for _, rr := range [2]rune{r, '\ufffd'} {
|
|
for _, rng := range f.Ranges {
|
|
if rr < rng.Low || rng.High <= rr {
|
|
continue
|
|
}
|
|
maskp.Y = (int(rr-rng.Low) + rng.Offset) * (f.Ascent + f.Descent)
|
|
ok = true
|
|
break loop
|
|
}
|
|
}
|
|
if !ok {
|
|
return image.Rectangle{}, nil, image.Point{}, 0, false
|
|
}
|
|
|
|
x := int(dot.X+32)>>6 + f.Left
|
|
y := int(dot.Y+32) >> 6
|
|
dr = image.Rectangle{
|
|
Min: image.Point{
|
|
X: x,
|
|
Y: y - f.Ascent,
|
|
},
|
|
Max: image.Point{
|
|
X: x + f.Width,
|
|
Y: y + f.Descent,
|
|
},
|
|
}
|
|
|
|
return dr, f.Mask, maskp, fixed.I(f.Advance), true
|
|
}
|
|
|
|
func (f *Face) GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool) {
|
|
return fixed.R(0, -f.Ascent, f.Width, +f.Descent), fixed.I(f.Advance), true
|
|
}
|
|
|
|
func (f *Face) GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool) {
|
|
return fixed.I(f.Advance), true
|
|
}
|