text

type Atlas ¶

type Atlas struct {
	Size, MaxPages int
	// contains filtered or unexported fields
}

Atlas owns fixed-size monochrome pages. One pixel padding isolates bilinear samples. It is not concurrent-safe; call BeginFrame before inserting a new frame and drain Uploads before displaying that frame. An active page is never evicted within the same frame. Placements expire when their page is evicted; the caller must only retain them for its current frame. Drain Uploads once per frame; undrained changes are coalesced, never discarded. At most one pending upload per page (bounding union of all dirty rects) uses at most MaxPages*Size*Size pending bytes.

func NewAtlas(size, maxPages int) (*Atlas, error)

func (a *Atlas) BeginFrame()

func (a *Atlas) Insert(k Key, m Mask) (Placement, error)

func (a *Atlas) Lookup(k Key) (Placement, bool)

func (a *Atlas) MarkAllDirty()

func (a *Atlas) PagesUsed() int

func (a *Atlas) Uploads() []Upload

type Catalog ¶

type Catalog struct {
	Faces []*Face

	Diagnostics []error
	// contains filtered or unexported fields
}

func Load(source FontSource) (*Catalog, error)

type DirectorySource ¶

type DirectorySource string

DirectorySource reads font files recursively; paths are sorted before parsing.

func (d DirectorySource) Fonts() (map[string][]byte, error)

type Engine ¶

type Engine struct {
	// contains filtered or unexported fields
}

Engine is single-goroutine only: Measure and EndFrame are not synchronized. Its catalog is fixed at NewEngine and must not change afterwards, because cached measurements depend on its faces.

func NewEngine(c *Catalog) *Engine

func (e *Engine) EndFrame()

func (e *Engine) Measure(s string, r Request, width float64) (Layout, error)

type Face ¶

type Face struct {
	ID         string
	Family     string
	Aspect     font.Aspect
	Shape      *font.Face
	Raster     *sfnt.Font
	Data       []byte
	Variations []font.Variation // immutable after construction; use WithVariations to clone
	Variable   bool             // fvar table present
	// contains filtered or unexported fields
}

Face is a parsed font, paired with its bytes for static TrueType rasterization.

func (f *Face) WithVariations(v []font.Variation) *Face

type FontFile ¶

type FontFile struct {
	Path          string
	Family        string
	Aspect        font.Aspect
	Index         int
	UnicodeRanges [4]uint32 // OS/2 ulUnicodeRange; zero means unknown
}

type FontSource ¶

type FontSource interface {
	Fonts() (map[string][]byte, error)
}

FontSource is the only external boundary: it provides files, not font matching policy. Implementations must return a stable snapshot. Corrupt files are reported, not silently accepted.

type Glyph ¶

type Glyph struct {
	ID      font.GID
	X, Y    float64
	Advance float64
	// Cluster is the rune index, in the original Measure input, of the first
	// rune of the glyph's cluster. It is not a UTF-8 byte offset.
	Cluster int
	Missing bool
}

Glyph contains a positioned glyph in logical pixels, with its original shaping metrics.

type IndexSource ¶

type IndexSource interface {
	Index() ([]FontFile, error)
	Open(path string) (io.ReadCloser, error)
}

IndexSource supplies metadata without retaining font bytes. Open is invoked only when a face is selected. Sources must keep paths stable during the catalog lifetime.

type Key ¶

type Key struct {
	FaceID     string
	Glyph      font.GID
	Size       fixed.Int26_6
	Variations [32]byte
	Phase      uint8
}

Key identifies a grayscale glyph mask. Size is physical px in 26.6 units; Phase is one of four horizontal quarter-pixel origins (vertical phase is zero).

func GlyphKey(face *Face, id font.GID, physicalSize, originX float64, variations []font.Variation) (Key, error)

type Layout ¶

type Layout struct {
	Lines                               []Line
	Direction                           di.Direction // paragraph basis, auto resolved by bidi analysis
	Width, Height, Baseline, LineHeight float64
}

func (l Layout) Clone() Layout

type LazySource ¶ added in v0.7.1

type LazySource interface {
	FontSource
	IndexSource
	Paths() ([]string, error)
	IndexFiles(paths []string) ([]FontFile, error)
}

LazySource lists font files cheaply and indexes chosen ones on demand, so a catalog reads only the files a request needs. Paths fixes the catalog order; IndexFiles returns entries in the order of its paths.

type Line ¶

type Line struct {
	Runs                    []Run
	Direction               di.Direction // resolved paragraph base direction
	Width, Baseline, Height float64
}

type Mask ¶

type Mask struct {
	Alpha  *image.Alpha
	Origin image.Point
}

func Rasterize(face *Face, key Key) (Mask, error)

type Placement ¶

type Placement struct {
	Page   int
	Rect   image.Rectangle
	Origin image.Point
}

type Request ¶

type Request struct {
	Direction bidi.BaseDirection // Auto (default), LTR, or RTL
	Families  []string
	Weight    float32
	Stretch   float32
	Italic    bool
	Size      float64
	// LetterSpacing is the signed logical-pixel spacing between shaped clusters.
	LetterSpacing float64
	Variations    []font.Variation
}

Request specifies CSS font selection. Weight defaults to 400, Stretch to 1, Style normal.

type Run ¶

type Run struct {
	Face      *Face
	Direction di.Direction
	Level     uint8 // resolved embedding level after L1
	// Start and End are rune indices in the original Measure input; End is
	// exclusive. A CRLF separator counts as two runes.
	Start, End    int
	X, Y, Advance float64
	Glyphs        []Glyph
}

Run is a shaped span with one face, direction and embedding level.

type SystemSource ¶

type SystemSource struct{}

SystemSource searches XDG user and system font directories without fontconfig/cgo. Earlier locations win identical family/aspect ties.

func (s SystemSource) Fonts() (map[string][]byte, error)

func (s SystemSource) Index() ([]FontFile, error)

func (SystemSource) IndexFiles(paths []string) ([]FontFile, error)

func (SystemSource) Open(path string) (io.ReadCloser, error)

func (s SystemSource) Paths() ([]string, error)

type Upload ¶

type Upload struct {
	Page  int
	Rect  image.Rectangle
	Bytes []byte
}

Upload is an immutable tightly packed grayscale rectangle, for the future renderer. It contains the latest pixels for Rect, including zeroed areas after eviction.