package vendor:freetype

Source

Alloc_Func :: proc "c" (memory: ^Memory_Rec, size: i64) -> rawptr

BBox :: struct {
	xMin: Pos,
	yMin: Pos,
	xMax: Pos,
	yMax: Pos,
}

B_Box :: struct {
	x_min: Pos,
	y_min: Pos,
	x_max: Pos,
	y_max: Pos,
}

Bitmap :: struct {
	rows:         u32,
	width:        u32,
	pitch:        i32,
	buffer:       [^]u8,
	num_grays:    u16,
	pixel_mode:   u8,
	palette_mode: u8,
	palette:      rawptr,
}

Bitmap_Size :: struct {
	height: i16,
	width:  i16,
	size:   Pos,
	x_ppem: Pos,
	y_ppem: Pos,
}

Bool :: distinct u8

Char_Map :: ^Char_Map_Rec

Char_Map_Rec :: struct {
	face:        ^Face_Rec,
	encoding:    Encoding,
	platform_id: u16,
	encoding_id: u16,
}

Driver :: ^Driver_Rec

Driver_Class :: ^Driver_Class_Rec

Driver_Class_Rec :: struct {
	root:             Module_Class,
	face_object_size: i64,
	size_object_size: i64,
	slot_object_size: i64,
	init_face:        Face_Init_Func,
	done_face:        Face_Done_Func,
	init_size:        Size_Init_Func,
	done_size:        Size_Done_Func,
	init_slot:        Slot_Init_Func,
	done_slot:        Slot_Done_Func,
	load_glyph:       Slot_Load_Func,
	get_kerning:      Face_Get_Kerning_Func,
	attach_file:      Face_Attach_Func,
	get_advances:     Face_Get_Advances_Func,
	request_size:     Size_Request_Func,
	select_size:      Size_Select_Func,
}

Driver_Rec :: struct {
	root:         Module_Rec,
	clazz:        ^Driver_Class_Rec,
	face_list:    List_Rec,
	glyph_loader: ^Glyph_Loader_Rec,
}

Encoding :: enum i32 {
	None           = 0, 
	MS_Symbol      = 1937337698, 
	Unicode        = 1970170211, 
	Sjis           = 1936353651, 
	Prc            = 1734484000, 
	Big5           = 1651074869, 
	Wansung        = 2002873971, 
	Johab          = 1785686113, 
	Adobe_Standard = 1094995778, 
	Adobe_Expert   = 1094992453, 
	Adobe_Custom   = 1094992451, 
	Adobe_Latin_1  = 1818326065, 
	Old_Latin_2    = 1818326066, 
	Apple_Roman    = 1634889070, 
}

Error :: enum i32 {
	Ok                            = 0, 
	Cannot_Open_Resource          = 1, 
	Unknown_File_Format           = 2, 
	Invalid_File_Format           = 3, 
	Invalid_Version               = 4, 
	Lower_Module_Version          = 5, 
	Invalid_Argument              = 6, 
	Unimplemented_Feature         = 7, 
	Invalid_Table                 = 8, 
	Invalid_Offset                = 9, 
	Array_Too_Large               = 10, 
	Missing_Module                = 11, 
	Missing_Property              = 12, 
	Invalid_Glyph_Index           = 16, 
	Invalid_Character_Code        = 17, 
	Invalid_Glyph_Format          = 18, 
	Cannot_Render_Glyph           = 19, 
	Invalid_Outline               = 20, 
	Invalid_Composite             = 21, 
	Too_Many_Hints                = 22, 
	Invalid_Pixel_Size            = 23, 
	Invalid_SVG_Document          = 24, 
	Invalid_Handle                = 32, 
	Invalid_Library_Handle        = 33, 
	Invalid_Driver_Handle         = 34, 
	Invalid_Face_Handle           = 35, 
	Invalid_Size_Handle           = 36, 
	Invalid_Slot_Handle           = 37, 
	Invalid_CharMap_Handle        = 38, 
	Invalid_Cache_Handle          = 39, 
	Invalid_Stream_Handle         = 40, 
	Too_Many_Drivers              = 48, 
	Too_Many_Extensions           = 49, 
	Out_Of_Memory                 = 64, 
	Unlisted_Object               = 65, 
	Cannot_Open_Stream            = 81, 
	Invalid_Stream_Seek           = 82, 
	Invalid_Stream_Skip           = 83, 
	Invalid_Stream_Read           = 84, 
	Invalid_Stream_Operation      = 85, 
	Invalid_Frame_Operation       = 86, 
	Nested_Frame_Access           = 87, 
	Invalid_Frame_Read            = 88, 
	Raster_Uninitialized          = 96, 
	Raster_Corrupted              = 97, 
	Raster_Overflow               = 98, 
	Raster_Negative_Height        = 99, 
	Too_Many_Caches               = 112, 
	Invalid_Opcode                = 128, 
	Too_Few_Arguments             = 129, 
	Stack_Overflow                = 130, 
	Code_Overflow                 = 131, 
	Bad_Argument                  = 132, 
	Divide_By_Zero                = 133, 
	Invalid_Reference             = 134, 
	Debug_OpCode                  = 135, 
	ENDF_In_Exec_Stream           = 136, 
	Nested_DEFS                   = 137, 
	Invalid_CodeRange             = 138, 
	Execution_Too_Long            = 139, 
	Too_Many_Function_Defs        = 140, 
	Too_Many_Instruction_Defs     = 141, 
	Table_Missing                 = 142, 
	Horiz_Header_Missing          = 143, 
	Locations_Missing             = 144, 
	Name_Table_Missing            = 145, 
	CMap_Table_Missing            = 146, 
	Hmtx_Table_Missing            = 147, 
	Post_Table_Missing            = 148, 
	Invalid_Horiz_Metrics         = 149, 
	Invalid_CharMap_Format        = 150, 
	Invalid_PPem                  = 151, 
	Invalid_Vert_Metrics          = 152, 
	Could_Not_Find_Context        = 153, 
	Invalid_Post_Table_Format     = 154, 
	Invalid_Post_Table            = 155, 
	DEF_In_Glyf_Bytecode          = 156, 
	Missing_Bitmap                = 157, 
	Missing_SVG_Hooks             = 158, 
	Syntax_Error                  = 160, 
	Stack_Underflow               = 161, 
	Ignore                        = 162, 
	No_Unicode_Glyph_Name         = 163, 
	Glyph_Too_Big                 = 164, 
	Missing_Startfont_Field       = 176, 
	Missing_Font_Field            = 177, 
	Missing_Size_Field            = 178, 
	Missing_Fontboundingbox_Field = 179, 
	Missing_Chars_Field           = 180, 
	Missing_Startchar_Field       = 181, 
	Missing_Encoding_Field        = 182, 
	Missing_Bbx_Field             = 183, 
	Bbx_Too_Big                   = 184, 
	Corrupted_Font_Header         = 185, 
	Corrupted_Font_Glyphs         = 186, 
}

F26Dot6 :: distinct i64

Face :: ^Face_Rec

Face_Attach_Func :: proc "c" (face: ^Face_Rec, stream: ^Stream_Rec) -> Error

Face_Done_Func :: proc "c" (face: ^Face_Rec)

Face_Get_Advances_Func :: proc "c" (face: ^Face_Rec, first, count: u32, flags: i32, advances: ^Fixed) -> Error

Face_Get_Kerning_Func :: proc "c" (face: ^Face_Rec, left_glyph, right_glyph: u32, kerning: ^Vector) -> Error

Face_Init_Func :: proc "c" (stream: ^Stream_Rec, face: ^Face_Rec, typeface_index, num_params: i32, parameters: ^Parameter) -> Error

Face_Internal :: rawptr

Face_Rec :: struct {
	num_faces:           i64,
	face_index:          i64,
	face_flags:          i64,
	style_flags:         i64,
	num_glyphs:          i64,
	family_name:         cstring,
	style_name:          cstring,
	num_fixed_sizes:     i32,
	available_sizes:     [^]Bitmap_Size,
	num_charmaps:        i32,
	charmaps:            [^]^Char_Map_Rec,
	generic:             Generic,
	bbox:                B_Box,
	units_per_em:        u16,
	ascender:            i16,
	descender:           i16,
	height:              i16,
	max_advance_width:   i16,
	max_advance_height:  i16,
	underline_position:  i16,
	underline_thickness: i16,
	glyph:               ^Glyph_Slot_Rec,
	size:                ^Size_Rec,
	charmap:             ^Char_Map_Rec,
	driver:              ^Driver_Rec,
	memory:              ^Memory_Rec,
	stream:              ^Stream_Rec,
	sizes_list:          List_Rec,
	auto_hint:           Generic,
	extensions:          rawptr,
	internal:            rawptr,
}

Fixed :: distinct i64

Free_Func :: proc "c" (memory: ^Memory_Rec, block: rawptr)

Generic :: struct {
	data:      rawptr,
	finalizer: Generic_Finalizer,
}

Generic_Finalizer :: proc "c" (object: rawptr)

Glyph_Format :: enum i32 {
	None      = 0, 
	Composite = 1668246896, 
	Bitmap    = 1651078259, 
	Outline   = 1869968492, 
	Plotter   = 1886154612, 
	Svg       = 1398163232, 
}

Glyph_Load_Rec :: struct {
	outline:       Outline,
	extra_points:  ^Vector,
	extra_points2: ^Vector,
	num_subglyphs: u32,
	subglyphs:     ^Sub_Glyph_Rec,
}

Glyph_Loader :: ^Glyph_Loader_Rec

Glyph_Loader_Rec :: struct {
	memory:    ^Memory_Rec,
	points:    u32,
	contours:  u32,
	subglyphs: u32,
	extra:     Bool,
	base:      Glyph_Load_Rec,
	current:   Glyph_Load_Rec,
	other:     rawptr,
}

Glyph_Metrics :: struct {
	width:          Pos,
	height:         Pos,
	hori_bearing_x: Pos,
	hori_bearing_y: Pos,
	hori_advance:   Pos,
	vert_bearing_x: Pos,
	vert_bearing_y: Pos,
	vert_advance:   Pos,
}

Glyph_Slot :: ^Glyph_Slot_Rec

Glyph_Slot_Rec :: struct {
	library:             Library,
	face:                ^Face_Rec,
	next:                ^Glyph_Slot_Rec,
	glyph_index:         u32,
	generic:             Generic,
	metrics:             Glyph_Metrics,
	linear_hori_advance: Fixed,
	linear_vert_advance: Fixed,
	advance:             Vector,
	format:              Glyph_Format,
	bitmap:              Bitmap,
	bitmap_left:         i32,
	bitmap_top:          i32,
	outline:             Outline,
	num_subglyphs:       u32,
	subglyphs:           ^Sub_Glyph_Rec,
	control_data:        rawptr,
	control_len:         i64,
	lsb_delta:           Pos,
	rsb_delta:           Pos,
	other:               rawptr,
	internal:            rawptr,
}

Library :: distinct rawptr

List_Node :: ^List_Node_Rec

List_Node_Rec :: struct {
	prev: ^List_Node_Rec,
	next: ^List_Node_Rec,
	data: rawptr,
}

List_Rec :: struct {
	head: ^List_Node_Rec,
	tail: ^List_Node_Rec,
}

Load_Flag :: enum i32 {
	No_Scale                    = 0, 
	No_Hinting                  = 1, 
	Render                      = 2, 
	No_Bitmap                   = 3, 
	Vertical_Layout             = 4, 
	Force_Autohint              = 5, 
	Crop_Bitmap                 = 6, 
	Pedantic                    = 7, 
	Ignore_Global_Advance_Width = 9, 
	No_Recurse                  = 10, 
	Ignore_Transform            = 11, 
	Monochrome                  = 12, 
	Linear_Design               = 13, 
	S_Bits_Only                 = 14, 
	No_Autohint                 = 15, 
	Color                       = 20, 
	Compute_Metrics             = 21, 
	Bitmap_Metrics_Only         = 22, 
	No_SVG                      = 24, 
}

Load_Flags :: distinct bit_set[Load_Flag; i32]

Matrix :: struct {
	xx: Fixed,
	xy: Fixed,
	yx: Fixed,
	yy: Fixed,
}

Memory :: ^Memory_Rec

Memory_Rec :: struct {
	user:    rawptr,
	alloc:   Alloc_Func,
	free:    Free_Func,
	realloc: Realloc_Func,
}

Module :: ^Module_Rec

Module_Class :: struct {
	module_flags:     u64,
	module_size:      i64,
	module_name:      cstring,
	module_version:   Fixed,
	module_requires:  Fixed,
	module_interface: rawptr,
	module_init:      Module_Constructor,
	module_done:      Module_Destructor,
	get_interface:    Module_Requester,
}

Module_Constructor :: proc "c" (module: ^Module_Rec) -> Error

Module_Destructor :: proc "c" (module: ^Module_Rec)

Module_Rec :: struct {
	clazz:   ^Module_Class,
	library: Library,
	memory:  ^Memory_Rec,
}

Module_Requester :: proc "c" (module: ^Module_Rec, name: cstring) -> rawptr

Orientation :: enum u32 {
	TRUETYPE   = 0, 
	POSTSCRIPT = 1, 
	FILL_RIGHT = 0, 
	FILL_LEFT  = 1, 
	NONE       = 2, 
}

Outline :: struct {
	n_contours: i16,
	n_points:   i16,
	points:     ^Vector,
	tags:       ^u8,
	contours:   ^i16,
	flags:      i32,
}

Outline_Funcs :: struct {
	move_to:  proc "c" (to: ^Vector, user: rawptr) -> i32,
	line_to:  proc "c" (to: ^Vector, user: rawptr) -> i32,
	conic_to: proc "c" (control: ^Vector, to: ^Vector, user: rawptr) -> i32,
	cubic_to: proc "c" (control1, control2, to: ^Vector, user: rawptr) -> i32,
	shift:    i32,
	delta:    Pos,
}

Parameter :: struct {
	tag:  u64,
	data: rawptr,
}

Pos :: distinct i64

Raster :: distinct rawptr

Raster_BitSet_Func :: proc "c" (x: i32, y: i32, user: rawptr)

Raster_BitTest_Func :: proc "c" (x: i32, y: i32, user: rawptr) -> i32

Raster_DoneFunc :: proc "c" (raster: Raster)

Raster_Funcs :: struct {
	glyph_format:    Glyph_Format,
	raster_new:      Raster_NewFunc,
	raster_reset:    Raster_ResetFunc,
	raster_set_mode: Raster_SetModeFunc,
	raster_render:   Raster_RenderFunc,
	raster_done:     Raster_DoneFunc,
}

Raster_NewFunc :: proc "c" (memory: rawptr, raster: ^Raster) -> i32

Raster_Params :: struct {
	target:      ^Bitmap,
	source:      rawptr,
	flags:       i32,
	gray_spans:  SpanFunc,
	black_spans: SpanFunc,
	bit_test:    Raster_BitTest_Func,
	bit_set_:    Raster_BitSet_Func,
	user:        rawptr,
	clip_box:    BBox,
}

Raster_RenderFunc :: proc "c" (raster: Raster, params: ^Raster_Params) -> i32

Raster_ResetFunc :: proc "c" (raster: Raster, pool: [^]u8, pool_size: u32)

Raster_SetModeFunc :: proc "c" (raster: Raster, mode: u32, args: rawptr) -> i32

Realloc_Func :: proc "c" (memory: ^Memory_Rec, cur_size, new_size: i64, block: rawptr) -> rawptr

Render_Mode :: enum int {
	Normal = 0, 
	Light  = 1, 
	Mono   = 2, 
	LCD    = 3, 
	LCD_V  = 4, 
	Max    = 5, 
}

Size :: ^Size_Rec

Size_Done_Func :: proc "c" (size: ^Size_Rec)

Size_Init_Func :: proc "c" (size: ^Size_Rec) -> Error

Size_Internal :: rawptr

Size_Metrics :: struct {
	x_ppem:      u16,
	y_ppem:      u16,
	x_scale:     Fixed,
	y_scale:     Fixed,
	ascender:    Pos,
	descender:   Pos,
	height:      Pos,
	max_advance: Pos,
}

Size_Rec :: struct {
	face:     ^Face_Rec,
	generic:  Generic,
	metrics:  Size_Metrics,
	internal: rawptr,
}

Size_Request :: ^Size_Request_Rec

Size_Request_Func :: proc "c" (size: ^Size_Rec, req: ^Size_Request_Rec) -> Error

Size_Request_Rec :: struct {
	type:            Size_Request_Type,
	width:           i64,
	height:          i64,
	hori_resolution: u32,
	vert_resolution: u32,
}

Size_Request_Type :: enum int {
	Normal   = 0, 
	Real_Dim = 1, 
	B_Box    = 2, 
	Cell     = 3, 
	Scale    = 4, 
	Max      = 5, 
}

Size_Select_Func :: proc "c" (size: ^Size_Rec, size_index: u64) -> Error

Slot_Done_Func :: proc "c" (slot: ^Glyph_Slot_Rec)

Slot_Init_Func :: proc "c" (slot: ^Glyph_Slot_Rec) -> Error

Slot_Internal :: rawptr

Slot_Load_Func :: proc "c" (slot: ^Glyph_Slot_Rec, size: ^Size_Rec, glyph_index: u32, load_flags: i32) -> Error

Span :: struct {
	x:        i16,
	len:      u16,
	coverage: u8,
}

SpanFunc :: proc "c" (y: i32, count: i32, spans: ^Span, user: rawptr)

Stream :: ^Stream_Rec

Stream_Close_Func :: proc "c" (stream: ^Stream_Rec)

Stream_Desc :: struct {
	value:  i64,
	ponter: rawptr,
}

Stream_IO_Func :: proc "c" (stream: ^Stream_Rec, offset: u64, buffer: ^u8, count: u64) -> u64

Stream_Rec :: struct {
	base:       ^u8,
	size:       u64,
	pos:        u64,
	descriptor: Stream_Desc,
	pathname:   Stream_Desc,
	read:       Stream_IO_Func,
	close:      Stream_Close_Func,
	memory:     ^Memory_Rec,
	cursor:     ^u8,
	limit:      ^u8,
}

Sub_Glyph :: ^Sub_Glyph_Rec

Sub_Glyph_Rec :: struct {
	index:     i32,
	flags:     u16,
	arg1:      i32,
	arg2:      i32,
	transform: Matrix,
}

Vector :: struct {
	x: Pos,
	y: Pos,
}

FREETYPE_SHARED: bool : #config(FREETYPE_SHARED, false)

done_face :: proc "c" (face: ^Face_Rec) -> Error ---

done_free_type :: proc "c" (library: Library) -> Error ---

get_char_index :: proc "c" (face: ^Face_Rec, code: u64) -> u32 ---

get_first_char :: proc "c" (face: ^Face_Rec, agindex: ^u32) -> u64 ---

get_next_char :: proc "c" (face: ^Face_Rec, code: u64, agindex: ^u32) -> u64 ---

get_transform :: proc "c" (face: ^Face_Rec, _matrix: ^Matrix, delta: ^Vector) ---

init_free_type :: proc "c" (library: ^Library) -> Error ---

load_char :: proc "c" (face: ^Face_Rec, char_code: u64, load_flags: Load_Flags) -> Error ---

load_glyph :: proc "c" (face: ^Face_Rec, index: u32, flags: Load_Flags) -> Error ---

new_face :: proc "c" (library: Library, file_path_name: cstring, face_index: i64, face: ^^Face_Rec) -> Error ---

new_memory_face :: proc "c" (library: Library, file_base: ^u8, file_size, face_index: i64, face: ^^Face_Rec) -> Error ---

outline_check :: proc "c" (_outline: ^Outline) -> Error ---

outline_copy :: proc "c" (_source: ^Outline, _target: ^Outline) -> Error ---

outline_decompose :: proc "c" (outline: ^Outline, funcs: ^Outline_Funcs, user_data: rawptr) -> Error ---

outline_done :: proc "c" (library: Library, outline: ^Outline) -> Error ---

outline_embolden :: proc "c" (outline: ^Outline, strength: Pos) -> Error ---

outline_embolden_xy :: proc "c" (outline: ^Outline, xstrength: Pos, ystrength: Pos) -> Error ---

outline_get_bitmap :: proc "c" (library: Library, outline: ^Outline, abitmap: ^Bitmap) -> Error ---

outline_get_cbox :: proc "c" (_outline: ^Outline, _acbox: ^BBox) ---

outline_get_orientation :: proc "c" (outline: ^Outline) -> Orientation ---

outline_new :: proc "c" (library: Library, numPoints: u32, numContours: i32, anoutline: ^Outline) -> Error ---

outline_render :: proc "c" (library: Library, outline: ^Outline, params: ^Raster_Params) -> Error ---

outline_reverse :: proc "c" (outline: ^Outline) ---

outline_transform :: proc "c" (_outline: ^Outline, _matrix: ^Matrix) ---

outline_translate :: proc "c" (_outline: ^Outline, _xOffset: Pos, _yOffset: Pos) ---

render_glyph :: proc "c" (slot: ^Glyph_Slot_Rec, render_mode: Render_Mode) -> Error ---

request_size :: proc "c" (face: ^Face_Rec, req: ^Size_Request_Rec) -> Error ---

select_size :: proc "c" (face: ^Face_Rec, strike_index: i32) -> Error ---

set_char_size :: proc "c" (face: ^Face_Rec, char_width, char_height: F26Dot6, horz_resolution, vert_resolution: u32) -> Error ---

set_pixel_sizes :: proc "c" (face: ^Face_Rec, pixel_width, pixel_height: u32) -> Error ---

set_transform :: proc "c" (face: ^Face_Rec, _matrix: ^Matrix, delta: ^Vector) ---