package vendor:fontstash

Source

AlignHorizontal :: enum int {
	LEFT, 
	CENTER, 
	RIGHT, 
}

AlignVertical :: enum int {
	TOP, 
	MIDDLE, 
	BOTTOM, 
	BASELINE, 
}

AtlasNode :: struct {
	x:     i16,
	y:     i16,
	width: i16,
}

Font :: struct {
	name:           string,
	// allocated
	info:           stb_truetype.fontinfo,
	loadedData:     []u8,
	freeLoadedData: bool,
	// in case you dont want loadedData to be removed
	ascender:       f32,
	descender:      f32,
	lineHeight:     f32,
	glyphs:         [dynamic]Glyph,
	lut:            [256]int,
	fallbacks:      [20]int,
	nfallbacks:     int,
}

FontContext :: struct {
	fonts:          [dynamic]Font,
	// always assuming user wants to resize
	nodes:          [dynamic]AtlasNode,
	// actual pixels
	textureData:    []u8,
	// allocated using context.allocator
	width:          int,
	height:         int,
	// 1 / texture_atlas_width, 1 / texture_atlas_height
	itw:            f32,
	ith:            f32,
	// state 
	states:         []State,
	state_count:    int,
	// used states
	location:       QuadLocation,
	// dirty rectangle of the texture region that was updated
	dirtyRect:      [4]f32,
	// callbacks with userData passed
	userData:       rawptr,
	// called when a texture is expanded and needs handling
	callbackResize: proc(data: rawptr, w, h: int),
	// called in state_end to update the texture region that changed
	callbackUpdate: proc(data: rawptr, dirtyRect: [4]f32, textureData: rawptr),
}

Glyph :: struct {
	codepoint: rune,
	index:     i32,
	next:      int,
	isize:     i16,
	blurSize:  i16,
	x0:        i16,
	y0:        i16,
	x1:        i16,
	y1:        i16,
	xoff:      i16,
	yoff:      i16,
	xadvance:  i16,
}

Glyph_Index :: i32

Quad :: struct {
	x0: f32,
	y0: f32,
	s0: f32,
	t0: f32,
	x1: f32,
	y1: f32,
	s1: f32,
	t1: f32,
}

QuadLocation :: enum int {
	TOPLEFT, 
	BOTTOMLEFT, 
}

State :: struct {
	font:    int,
	size:    f32,
	color:   [4]u8,
	spacing: f32,
	blur:    f32,
	ah:      AlignHorizontal,
	av:      AlignVertical,
}

TextIter :: struct {
	x:                  f32,
	y:                  f32,
	nextx:              f32,
	nexty:              f32,
	scale:              f32,
	spacing:            f32,
	isize:              i16,
	iblur:              i16,
	font:               ^Font,
	previousGlyphIndex: i32,
	// unicode iteration
	utf8state:          rune,
	// utf8
	codepoint:          rune,
	text:               string,
	codepointCount:     int,
	// byte indices
	str:                int,
	next:               int,
	end:                int,
}

Vertex :: struct #packed {
	x:     f32,
	y:     f32,
	u:     f32,
	v:     f32,
	color: [4]u8,
}

BLUR_APREC :: 16

BLUR_ZPREC :: 7

HASH_LUT_SIZE :: 256

INIT_ATLAS_NODES :: 256

INIT_GLYPHS :: 256

INVALID :: -1

MAX_FALLBACKS :: 20

MAX_STATES :: 20

AddFallbackFont :: proc(ctx: ^FontContext, base, fallback: int) -> bool {…}

AddFontMem :: proc(ctx: ^FontContext, name: string, data: []u8, freeLoadedData: bool) -> int {…}

AddFontPath :: proc(ctx: ^FontContext, name: string, path: string) -> int {…}

BeginState :: proc(ctx: ^FontContext) {…}

ClearState :: proc(ctx: ^FontContext) {…}

CodepointWidth :: proc(font: ^Font, codepoint: rune, scale: f32) -> f32 {…}

Destroy :: proc(ctx: ^FontContext) {…}

EndState :: proc(ctx: ^FontContext) {…}

ExpandAtlas :: proc(ctx: ^FontContext, width, height: int, allocator := context.allocator) -> bool {…}

GetFontByName :: proc(ctx: ^FontContext, name: string) -> int {…}

Init :: proc(ctx: ^FontContext, w, h: int, loc: QuadLocation) {…}

LineBounds :: proc(ctx: ^FontContext, y: f32) -> (miny, maxy: f32) {…}

PopState :: proc(ctx: ^FontContext) {…}

PushState :: proc(using ctx: ^FontContext, loc := #caller_location) {…}

Reset :: proc(ctx: ^FontContext) {…}

ResetAtlas :: proc(ctx: ^FontContext, width, height: int, allocator := context.allocator) -> bool {…}

ResetFallbackFont :: proc(ctx: ^FontContext, base: int) {…}

SetAH :: SetAlignHorizontal

SetAV :: SetAlignVertical

SetAlignHorizontal :: proc(ctx: ^FontContext, ah: AlignHorizontal) {…}

SetAlignVertical :: proc(ctx: ^FontContext, av: AlignVertical) {…}

SetBlur :: proc(ctx: ^FontContext, blur: f32) {…}

SetColor :: proc(ctx: ^FontContext, color: [4]u8) {…}

SetFont :: proc(ctx: ^FontContext, font: int) {…}

SetSize :: proc(ctx: ^FontContext, size: f32) {…}

SetSpacing :: proc(ctx: ^FontContext, spacing: f32) {…}

TextBounds :: proc(ctx: ^FontContext, text: string, x: f32 = 0, y: f32 = 0, bounds: ^[4]f32 = nil) -> f32 {…}

TextIterInit :: proc(ctx: ^FontContext, x: f32, y: f32, text: string) -> (res: TextIter) {…}

TextIterNext :: proc(ctx: ^FontContext, iter: ^TextIter, quad: ^Quad) -> (ok: bool) {…}

ValidateTexture :: proc(using ctx: ^FontContext, dirty: ^[4]f32) -> bool {…}

VerticalMetrics :: proc(ctx: ^FontContext) -> (ascender, descender, lineHeight: f32) {…}

AddFont :: proc{
	AddFontPath,
	AddFontMem,
}