@imgui-js-xyz/core
Version:
imgui.js for games
668 lines (667 loc) • 298 kB
TypeScript
// Generated by dts-bundle-generator v9.5.1
declare class EmscriptenClassHandle {
}
declare class EmscriptenRegisteredClass {
baseClass: any;
constructor_body: any;
downcast: number;
getActualType: () => any;
instancePrototype: EmscriptenClassHandle;
name: string;
pureVirtualFunctions: ((...args: any[]) => any)[];
rawDestructor: () => void;
upcast: number;
}
declare class EmscriptenRegisteredPointer {
destructorFunction: ((ptr: number) => void) | null;
isConst: boolean;
isReference: boolean;
isSmartPointer: boolean;
name: string;
pointeeType: any;
rawConstructor: any;
rawDestructor: any;
rawGetPointee: any;
rawShare: any;
registeredClass: EmscriptenRegisteredClass;
sharingPolicy: any;
fromWireType: (value: any) => any;
toWireType: (destructors: any[], value: any) => number;
}
declare class EmscriptenWireType {
ptr: number;
ptrType: EmscriptenRegisteredPointer;
count: {
value: number;
};
}
declare class EmscriptenClassReference {
$$: EmscriptenWireType;
}
declare class EmscriptenClass extends EmscriptenClassReference {
delete(): void;
}
interface EmscriptenModule$1 {
then<T extends EmscriptenModule$1>(callback: (value: T) => void): void;
ENVIRONMENT?: "WEB" | "WORKER" | "NODE" | "SHELL";
"arguments": any[];
thisProgram: string;
quit(status: number, toThrow: Error): void;
preRun: (() => void)[];
postRun: (() => void)[];
HEAP8: Int8Array;
HEAP16: Int16Array;
HEAP32: Int32Array;
HEAPU8: Uint8Array;
HEAPU16: Uint16Array;
HEAPU32: Uint32Array;
HEAPF32: Float32Array;
HEAPF64: Float64Array;
TOTAL_STACK: number;
TOTAL_MEMORY: number;
count_emval_handles(): number;
onRuntimeInitialized: () => void;
_malloc(size: number): number;
_free(ptr: number): number;
_memcpy(dst: number, src: number, num: number): number;
_memset(ptr: number, val: number, num: number): number;
}
declare function Module(Module?: Partial<Module$1>): Module$1;
export interface mallinfo {
arena: number;
ordblks: number;
smblks: number;
hblks: number;
hblkhd: number;
usmblks: number;
fsmblks: number;
uordblks: number;
fordblks: number;
keepcost: number;
}
export type ImAccess<T> = (value?: T) => T;
export type ImScalar<T> = [
T
];
export type ImTuple2<T> = [
T,
T
];
export type ImTuple3<T> = [
T,
T,
T
];
export type ImTuple4<T> = [
T,
T,
T,
T
];
// Enums/Flags (declared as int for compatibility with old C++, to allow using as flags and to not pollute the top of this file)
// - Tip: Use your programming IDE navigation facilities on the names in the _central column_ below to find the actual flags/enum lists!
// In Visual Studio IDE: CTRL+comma ("Edit.NavigateTo") can follow symbols in comments, whereas CTRL+F12 ("Edit.GoToImplementation") cannot.
// With Visual Assist installed: ALT+G ("VAssistX.GoToImplementation") can also follow symbols in comments.
export type ImGuiCol = number; // -> enum ImGuiCol_ // Enum: A color identifier for styling
export type ImGuiCond = number; // -> enum ImGuiCond_ // Enum: A condition for many Set*() functions
export type ImGuiDataType = number; // -> enum ImGuiDataType_ // Enum: A primary data type
export type ImGuiDir = number; // -> enum ImGuiDir_ // Enum: A cardinal direction
export type ImGuiKey = number; // -> enum ImGuiKey_ // Enum: A key identifier (ImGui-side enum)
export type ImGuiNavInput = number; // -> enum ImGuiNavInput_ // Enum: An input identifier for navigation
export type ImGuiMouseButton = number; // -> enum ImGuiMouseButton_ // Enum: A mouse button identifier (0=left, 1=right, 2=middle)
export type ImGuiMouseCursor = number; // -> enum ImGuiMouseCursor_ // Enum: A mouse cursor identifier
export type ImGuiSortDirection = number; // -> enum ImGuiSortDirection_ // Enum: A sorting direction (ascending or descending)
export type ImGuiStyleVar = number; // -> enum ImGuiStyleVar_ // Enum: A variable identifier for styling
export type ImGuiTableBgTarget = number; // -> enum ImGuiTableBgTarget_ // Enum: A color target for TableSetBgColor()
export type ImDrawFlags = number; // -> enum ImDrawFlags_ // Flags: for ImDrawList::AddRect(), AddRectFilled() etc.
export type ImDrawListFlags = number; // -> enum ImDrawListFlags_ // Flags: for ImDrawList
export type ImFontAtlasFlags = number; // -> enum ImFontAtlasFlags_ // Flags: for ImFontAtlas build
export type ImGuiBackendFlags = number; // -> enum ImGuiBackendFlags_ // Flags: for io.BackendFlags
export type ImGuiButtonFlags = number; // -> enum ImGuiButtonFlags_ // Flags: for InvisibleButton()
export type ImGuiColorEditFlags = number; // -> enum ImGuiColorEditFlags_ // Flags: for ColorEdit4(), ColorPicker4() etc.
export type ImGuiConfigFlags = number; // -> enum ImGuiConfigFlags_ // Flags: for io.ConfigFlags
export type ImGuiComboFlags = number; // -> enum ImGuiComboFlags_ // Flags: for BeginCombo()
export type ImGuiDragDropFlags = number; // -> enum ImGuiDragDropFlags_ // Flags: for BeginDragDropSource(), AcceptDragDropPayload()
export type ImGuiFocusedFlags = number; // -> enum ImGuiFocusedFlags_ // Flags: for IsWindowFocused()
export type ImGuiHoveredFlags = number; // -> enum ImGuiHoveredFlags_ // Flags: for IsItemHovered(), IsWindowHovered() etc.
export type ImGuiInputTextFlags = number; // -> enum ImGuiInputTextFlags_ // Flags: for InputText(), InputTextMultiline()
export type ImGuiKeyModFlags = number; // -> enum ImGuiKeyModFlags_ // Flags: for io.KeyMods (Ctrl/Shift/Alt/Super)
export type ImGuiPopupFlags = number; // -> enum ImGuiPopupFlags_ // Flags: for OpenPopup*(), BeginPopupContext*(), IsPopupOpen()
export type ImGuiSelectableFlags = number; // -> enum ImGuiSelectableFlags_ // Flags: for Selectable()
export type ImGuiSliderFlags = number; // -> enum ImGuiSliderFlags_ // Flags: for DragFloat(), DragInt(), SliderFloat(), SliderInt() etc.
export type ImGuiTabBarFlags = number; // -> enum ImGuiTabBarFlags_ // Flags: for BeginTabBar()
export type ImGuiTabItemFlags = number; // -> enum ImGuiTabItemFlags_ // Flags: for BeginTabItem()
export type ImGuiTableFlags = number; // -> enum ImGuiTableFlags_ // Flags: For BeginTable()
export type ImGuiTableColumnFlags = number; // -> enum ImGuiTableColumnFlags_// Flags: For TableSetupColumn()
export type ImGuiTableRowFlags = number; // -> enum ImGuiTableRowFlags_ // Flags: For TableNextRow()
export type ImGuiTreeNodeFlags = number; // -> enum ImGuiTreeNodeFlags_ // Flags: for TreeNode(), TreeNodeEx(), CollapsingHeader()
export type ImGuiViewportFlags = number; // -> enum ImGuiViewportFlags_ // Flags: for ImGuiViewport
export type ImGuiWindowFlags = number; // -> enum ImGuiWindowFlags_ // Flags: for Begin(), BeginChild()
// Other types
// #ifndef ImTextureID // ImTextureID [configurable type: override in imconfig.h with '#define ImTextureID xxx']
// typedef void* ImTextureID; // User data for rendering backend to identify a texture. This is whatever to you want it to be! read the FAQ about ImTextureID for details.
// #endif
export type ImTextureID = number;
// typedef unsigned int ImGuiID; // A unique ID used by widgets, typically hashed from a stack of string.
export type ImGuiID = number;
// typedef int (*ImGuiInputTextCallback)(ImGuiInputTextCallbackData* data); // Callback function for ImGui::InputText()
export type ImGuiInputTextCallback = (data: reference_ImGuiInputTextCallbackData) => number;
// typedef void (*ImGuiSizeCallback)(ImGuiSizeCallbackData* data); // Callback function for ImGui::SetNextWindowSizeConstraints()
export type ImGuiSizeCallback = (data: reference_ImGuiSizeCallbackData) => void;
// Character types
// (we generally use UTF-8 encoded string in the API. This is storage specifically for a decoded character used for keyboard input and display)
// typedef unsigned short ImWchar16; // A single decoded U16 character/code point. We encode them as multi bytes UTF-8 when used in strings.
export type ImWchar16 = number;
// typedef unsigned int ImWchar32; // A single decoded U32 character/code point. We encode them as multi bytes UTF-8 when used in strings.
export type ImWchar32 = number;
// #ifdef IMGUI_USE_WCHAR32 // ImWchar [configurable type: override in imconfig.h with '#define IMGUI_USE_WCHAR32' to support Unicode planes 1-16]
// typedef ImWchar32 ImWchar;
// #else
// typedef ImWchar16 ImWchar;
// #endif
export type ImWchar = number;
// Basic scalar data types
// typedef signed char ImS8; // 8-bit signed integer
// typedef unsigned char ImU8; // 8-bit unsigned integer
// typedef signed short ImS16; // 16-bit signed integer
export type ImS16 = number;
// typedef unsigned short ImU16; // 16-bit unsigned integer
// typedef signed int ImS32; // 32-bit signed integer == int
// typedef unsigned int ImU32; // 32-bit unsigned integer (often used to store packed colors)
export type ImU32 = number;
declare class WrapImGuiContext extends Emscripten$1.EmscriptenClass {
}
export interface interface_ImVec2 {
x: number;
y: number;
Set(x: number, y: number): this;
Copy(other: Readonly<interface_ImVec2>): this;
Equals(other: Readonly<interface_ImVec2>): boolean;
}
export interface reference_ImVec2 extends Emscripten$1.EmscriptenClassReference, interface_ImVec2 {
}
export interface interface_ImVec4 {
x: number;
y: number;
z: number;
w: number;
Set(x: number, y: number, z: number, w: number): this;
Copy(other: Readonly<interface_ImVec4>): this;
Equals(other: Readonly<interface_ImVec4>): boolean;
}
export interface reference_ImVec4 extends Emscripten$1.EmscriptenClassReference, interface_ImVec4 {
}
// Shared state of InputText(), passed to callback when a ImGuiInputTextFlags_Callback* flag is used and the corresponding callback is triggered.
export interface reference_ImGuiInputTextCallbackData extends Emscripten$1.EmscriptenClassReference {
// ImGuiInputTextFlags EventFlag; // One of ImGuiInputTextFlags_Callback* // Read-only
EventFlag: ImGuiInputTextFlags;
// ImGuiInputTextFlags Flags; // What user passed to InputText() // Read-only
Flags: ImGuiInputTextFlags;
// void* UserData; // What user passed to InputText() // Read-only
UserData: any;
// CharFilter event:
// ImWchar EventChar; // Character input // Read-write (replace character or set to zero)
EventChar: ImWchar;
// Completion,History,Always events:
// If you modify the buffer contents make sure you update 'BufTextLen' and set 'BufDirty' to true.
// ImGuiKey EventKey; // Key pressed (Up/Down/TAB) // Read-only
EventKey: ImGuiKey;
// char* Buf; // Current text buffer // Read-write (pointed data only, can't replace the actual pointer)
Buf: string;
// int BufTextLen; // Current text length in bytes // Read-write
BufTextLen: number;
// int BufSize; // Maximum text length in bytes // Read-only
BufSize: number;
// bool BufDirty; // Set if you modify Buf/BufTextLen!! // Write
BufDirty: boolean;
// int CursorPos; // // Read-write
CursorPos: number;
// int SelectionStart; // // Read-write (== to SelectionEnd when no selection)
SelectionStart: number;
// int SelectionEnd; // // Read-write
SelectionEnd: number;
// NB: Helper functions for text manipulation. Calling those function loses selection.
// IMGUI_API void DeleteChars(int pos, int bytes_count);
DeleteChars(pos: number, bytes_count: number): void;
// IMGUI_API void InsertChars(int pos, const char* text, const char* text_end = NULL);
InsertChars(pos: number, text: string): void;
// void SelectAll() { SelectionStart = 0; SelectionEnd = BufTextLen; }
SelectAll(): void;
// void ClearSelection() { SelectionStart = SelectionEnd = BufTextLen; }
ClearSelection(): void;
// bool HasSelection() const { return SelectionStart != SelectionEnd; }
HasSelection(): boolean;
}
// Resizing callback data to apply custom constraint. As enabled by SetNextWindowSizeConstraints(). Callback is called during the next Begin().
// NB: For basic min/max size constraint on each axis you don't need to use the callback! The SetNextWindowSizeConstraints() parameters are enough.
export interface reference_ImGuiSizeCallbackData extends Emscripten$1.EmscriptenClassReference {
// void* UserData; // Read-only. What user passed to SetNextWindowSizeConstraints()
// UserData: any;
// ImVec2 Pos; // Read-only. Window position, for reference.
Pos: Readonly<reference_ImVec2>;
// ImVec2 CurrentSize; // Read-only. Current window size.
CurrentSize: Readonly<reference_ImVec2>;
// ImVec2 DesiredSize; // Read-write. Desired size, based on user's mouse position. Write to this field to restrain resizing.
DesiredSize: reference_ImVec2;
}
declare class ImGuiListClipper extends Emscripten$1.EmscriptenClass {
public DisplayStart: number;
public DisplayEnd: number;
public ItemsCount: number;
// public StepNo: number;
// public ItemsFrozen: number;
public ItemsHeight: number;
public StartPosY: number;
// items_count: Use -1 to ignore (you can call Begin later). Use INT_MAX if you don't know how many items you have (in which case the cursor won't be advanced in the final step).
// items_height: Use -1.0f to be calculated automatically on first step. Otherwise pass in the distance between your items, typically GetTextLineHeightWithSpacing() or GetFrameHeightWithSpacing().
// If you don't specify an items_height, you NEED to call Step(). If you specify items_height you may call the old Begin()/End() api directly, but prefer calling Step().
// ImGuiListClipper(int items_count = -1, float items_height = -1.0f) { Begin(items_count, items_height); } // NB: Begin() initialize every fields (as we allow user to call Begin/End multiple times on a same instance if they want).
// ~ImGuiListClipper() { IM_ASSERT(ItemsCount == -1); } // Assert if user forgot to call End() or Step() until false.
// IMGUI_API void Begin(int items_count, float items_height = -1.0f); // Automatically called by constructor if you passed 'items_count' or by Step() in Step 1.
public Begin(items_count: number, items_height: number): void;
// IMGUI_API void End(); // Automatically called on the last call of Step() that returns false.
public End(): void;
// IMGUI_API bool Step(); // Call until it returns false. The DisplayStart/DisplayEnd fields will be set and you can process/draw those items.
public Step(): boolean;
}
export interface reference_ImGuiTableColumnSortSpecs extends Emscripten$1.EmscriptenClassReference {
// ImGuiID ColumnUserID; // User id of the column (if specified by a TableSetupColumn() call)
ColumnUserID: number;
// ImS16 ColumnIndex; // Index of the column
ColumnIndex: number;
// ImS16 SortOrder; // Index within parent ImGuiTableSortSpecs (always stored in order starting from 0, tables sorted on a single criteria will always have a 0 here)
SortOrder: number;
// ImGuiSortDirection SortDirection : 8; // ImGuiSortDirection_Ascending or ImGuiSortDirection_Descending (you can use this or SortSign, whichever is more convenient for your sort function)
SortDirection: number; // TODO: use an enum?
}
export interface reference_ImGuiTableSortSpecs extends Emscripten$1.EmscriptenClassReference {
//const ImGuiTableColumnSortSpecs* Specs; // Pointer to sort spec array.
//Specs: readonly reference_ImGuiTableColumnSortSpecs[];
GetSpec(idx: number): reference_ImGuiTableColumnSortSpecs;
//int SpecsCount; // Sort spec count. Most often 1. May be > 1 when ImGuiTableFlags_SortMulti is enabled. May be == 0 when ImGuiTableFlags_SortTristate is enabled.
SpecsCount: number; // TODO: make readonly?
//bool SpecsDirty; // Set to true when specs have changed since last time! Use this to sort again, then clear the flag.
SpecsDirty: boolean;
}
// You may modify the ImGui::GetStyle() main instance during initialization and before NewFrame().
// During the frame, prefer using ImGui::PushStyleVar(ImGuiStyleVar_XXXX)/PopStyleVar() to alter the main style values, and ImGui::PushStyleColor(ImGuiCol_XXX)/PopStyleColor() for colors.
export interface interface_ImGuiStyle {
// float Alpha; // Global alpha applies to everything in Dear ImGui.
// float DisabledAlpha; //
// ImVec2 WindowPadding; // Padding within a window.
// float WindowRounding; // Radius of window corners rounding. Set to 0.0f to have rectangular windows. Large values tend to lead to variety of artifacts and are not recommended.
// float WindowBorderSize; // Thickness of border around windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
// ImVec2 WindowMinSize; // Minimum window size. This is a global setting. If you want to constraint individual windows, use SetNextWindowSizeConstraints().
// ImVec2 WindowTitleAlign; // Alignment for title bar text. Defaults to (0.0f,0.5f) for left-aligned,vertically centered.
// ImGuiDir WindowMenuButtonPosition; // Side of the collapsing/docking button in the title bar (None/Left/Right). Defaults to ImGuiDir_Left.
// float ChildRounding; // Radius of child window corners rounding. Set to 0.0f to have rectangular windows.
// float ChildBorderSize; // Thickness of border around child windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
// float PopupRounding; // Radius of popup window corners rounding. (Note that tooltip windows use WindowRounding)
// float PopupBorderSize; // Thickness of border around popup/tooltip windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
// ImVec2 FramePadding; // Padding within a framed rectangle (used by most widgets).
// float FrameRounding; // Radius of frame corners rounding. Set to 0.0f to have rectangular frame (used by most widgets).
// float FrameBorderSize; // Thickness of border around frames. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
// ImVec2 ItemSpacing; // Horizontal and vertical spacing between widgets/lines.
// ImVec2 ItemInnerSpacing; // Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label).
// ImVec2 CellPadding; // Padding within a table cell
// ImVec2 TouchExtraPadding; // Expand reactive bounding box for touch-based system where touch position is not accurate enough. Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!
// float IndentSpacing; // Horizontal indentation when e.g. entering a tree node. Generally == (FontSize + FramePadding.x*2).
// float ColumnsMinSpacing; // Minimum horizontal spacing between two columns. Preferably > (FramePadding.x + 1).
// float ScrollbarSize; // Width of the vertical scrollbar, Height of the horizontal scrollbar.
// float ScrollbarRounding; // Radius of grab corners for scrollbar.
// float GrabMinSize; // Minimum width/height of a grab box for slider/scrollbar.
// float GrabRounding; // Radius of grabs corners rounding. Set to 0.0f to have rectangular slider grabs.
// float LogSliderDeadzone; // The size in pixels of the dead-zone around zero on logarithmic sliders that cross zero.
// float TabRounding; // Radius of upper corners of a tab. Set to 0.0f to have rectangular tabs.
// float TabBorderSize; // Thickness of border around tabs.
// float TabMinWidthForCloseButton; // Minimum width for close button to appears on an unselected tab when hovered. Set to 0.0f to always show when hovering, set to FLT_MAX to never show close button unless selected.
// ImGuiDir ColorButtonPosition; // Side of the color button in the ColorEdit4 widget (left/right). Defaults to ImGuiDir_Right.
// ImVec2 ButtonTextAlign; // Alignment of button text when button is larger than text. Defaults to (0.5f, 0.5f) (centered).
// ImVec2 SelectableTextAlign; // Alignment of selectable text. Defaults to (0.0f, 0.0f) (top-left aligned). It's generally important to keep this left-aligned if you want to lay multiple items on a same line.
// ImVec2 DisplayWindowPadding; // Window position are clamped to be visible within the display area or monitors by at least this amount. Only applies to regular windows.
// ImVec2 DisplaySafeAreaPadding; // If you cannot see the edges of your screen (e.g. on a TV) increase the safe area padding. Apply to popups/tooltips as well regular windows. NB: Prefer configuring your TV sets correctly!
// float MouseCursorScale; // Scale software rendered mouse cursor (when io.MouseDrawCursor is enabled). May be removed later.
// bool AntiAliasedLines; // Enable anti-aliased lines/borders. Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).
// bool AntiAliasedLinesUseTex; // Enable anti-aliased lines/borders using textures where possible. Require backend to render with bilinear filtering. Latched at the beginning of the frame (copied to ImDrawList).
// bool AntiAliasedFill; // Enable anti-aliased edges around filled shapes (rounded rectangles, circles, etc.). Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).
// float CurveTessellationTol; // Tessellation tolerance when using PathBezierCurveTo() without a specific number of segments. Decrease for highly tessellated curves (higher quality, more polygons), increase to reduce quality.
// float CircleTessellationMaxError; // Maximum error (in pixels) allowed when using AddCircle()/AddCircleFilled() or drawing rounded corner rectangles with no explicit segment count specified. Decrease for higher quality but more geometry.
// ImVec4 Colors[ImGuiCol_COUNT];
Alpha: number;
DisabledAlpha: number;
readonly WindowPadding: interface_ImVec2;
WindowRounding: number;
WindowBorderSize: number;
readonly WindowMinSize: interface_ImVec2;
readonly WindowTitleAlign: interface_ImVec2;
WindowMenuButtonPosition: ImGuiDir;
ChildRounding: number;
ChildBorderSize: number;
PopupRounding: number;
PopupBorderSize: number;
readonly FramePadding: interface_ImVec2;
FrameRounding: number;
FrameBorderSize: number;
readonly ItemSpacing: interface_ImVec2;
readonly ItemInnerSpacing: interface_ImVec2;
readonly TouchExtraPadding: interface_ImVec2;
readonly CellPadding: interface_ImVec2;
IndentSpacing: number;
ColumnsMinSpacing: number;
ScrollbarSize: number;
ScrollbarRounding: number;
GrabMinSize: number;
GrabRounding: number;
LogSliderDeadzone: number;
TabRounding: number;
TabBorderSize: number;
TabMinWidthForCloseButton: number;
ColorButtonPosition: number;
readonly ButtonTextAlign: interface_ImVec2;
readonly SelectableTextAlign: interface_ImVec2;
readonly DisplayWindowPadding: interface_ImVec2;
readonly DisplaySafeAreaPadding: interface_ImVec2;
MouseCursorScale: number;
AntiAliasedLines: boolean;
AntiAliasedLinesUseTex: boolean;
AntiAliasedFill: boolean;
CurveTessellationTol: number;
CircleTessellationMaxError: number;
_getAt_Colors(idx: number): interface_ImVec4;
_setAt_Colors(idx: number, value: Readonly<interface_ImVec4>): boolean;
// IMGUI_API ImGuiStyle();
// IMGUI_API void ScaleAllSizes(float scale_factor);
ScaleAllSizes(scale_factor: number): void;
}
declare class ImGuiStyle extends Emscripten$1.EmscriptenClass implements interface_ImGuiStyle {
Alpha: number;
DisabledAlpha: number;
readonly WindowPadding: reference_ImVec2;
WindowRounding: number;
WindowBorderSize: number;
readonly WindowMinSize: reference_ImVec2;
readonly WindowTitleAlign: reference_ImVec2;
WindowMenuButtonPosition: ImGuiDir;
ChildRounding: number;
ChildBorderSize: number;
PopupRounding: number;
PopupBorderSize: number;
readonly FramePadding: reference_ImVec2;
FrameRounding: number;
FrameBorderSize: number;
readonly ItemSpacing: reference_ImVec2;
readonly ItemInnerSpacing: reference_ImVec2;
readonly TouchExtraPadding: reference_ImVec2;
readonly CellPadding: reference_ImVec2;
IndentSpacing: number;
ColumnsMinSpacing: number;
ScrollbarSize: number;
ScrollbarRounding: number;
GrabMinSize: number;
GrabRounding: number;
LogSliderDeadzone: number;
TabRounding: number;
TabBorderSize: number;
TabMinWidthForCloseButton: number;
ColorButtonPosition: ImGuiDir;
readonly ButtonTextAlign: reference_ImVec2;
readonly SelectableTextAlign: reference_ImVec2;
readonly DisplayWindowPadding: reference_ImVec2;
readonly DisplaySafeAreaPadding: reference_ImVec2;
MouseCursorScale: number;
AntiAliasedLines: boolean;
AntiAliasedLinesUseTex: boolean;
AntiAliasedFill: boolean;
CurveTessellationTol: number;
CircleTessellationMaxError: number;
_getAt_Colors(idx: number): reference_ImVec4;
_setAt_Colors(idx: number, value: Readonly<interface_ImVec4>): boolean;
public ScaleAllSizes(scale_factor: number): void;
}
export interface reference_DragDropPayload extends Emscripten$1.EmscriptenClassReference {
}
export type ImDrawCallback = (parent_list: Readonly<reference_ImDrawList>, cmd: Readonly<reference_ImDrawCmd>) => void;
export interface reference_ImDrawCmd extends Emscripten$1.EmscriptenClassReference {
// unsigned int ElemCount; // Number of indices (multiple of 3) to be rendered as triangles. Vertices are stored in the callee ImDrawList's vtx_buffer[] array, indices in idx_buffer[].
readonly ElemCount: number;
// ImVec4 ClipRect; // Clipping rectangle (x1, y1, x2, y2)
readonly ClipRect: Readonly<reference_ImVec4>;
// ImTextureID TextureId; // User-provided texture ID. Set by user in ImfontAtlas::SetTexID() for fonts or passed to Image*() functions. Ignore if never using images or multiple fonts atlas.
readonly TextureId: ImTextureID;
// unsigned int VtxOffset; // Start offset in vertex buffer. Pre-1.71 or without ImGuiBackendFlags_RendererHasVtxOffset: always 0. With ImGuiBackendFlags_RendererHasVtxOffset: may be >0 to support meshes larger than 64K vertices with 16-bits indices.
readonly VtxOffset: number;
// unsigned int IdxOffset; // Start offset in index buffer. Always equal to sum of ElemCount drawn so far.
readonly IdxOffset: number;
}
export interface reference_ImDrawListSharedData extends Emscripten$1.EmscriptenClassReference {
}
export interface reference_ImDrawList extends Emscripten$1.EmscriptenClassReference {
IterateDrawCmds(callback: (draw_cmd: reference_ImDrawCmd, ElemStart: number) => void): void;
// This is what you have to render
// ImVector<ImDrawCmd> CmdBuffer; // Draw commands. Typically 1 command = 1 GPU draw call, unless the command is a callback.
// ImVector<ImDrawIdx> IdxBuffer; // Index buffer. Each command consume ImDrawCmd::ElemCount of those
readonly IdxBuffer: Uint8Array;
// ImVector<ImDrawVert> VtxBuffer; // Vertex buffer.
readonly VtxBuffer: Uint8Array;
// [Internal, used while building lists]
// ImDrawListFlags Flags; // Flags, you may poke into these to adjust anti-aliasing settings per-primitive.
Flags: ImDrawListFlags;
// const ImDrawListSharedData* _Data; // Pointer to shared draw data (you can use ImGui::GetDrawListSharedData() to get the one from current ImGui context)
// const char* _OwnerName; // Pointer to owner window's name for debugging
// unsigned int _VtxCurrentIdx; // [Internal] == VtxBuffer.Size
// ImDrawVert* _VtxWritePtr; // [Internal] point within VtxBuffer.Data after each add command (to avoid using the ImVector<> operators too much)
// ImDrawIdx* _IdxWritePtr; // [Internal] point within IdxBuffer.Data after each add command (to avoid using the ImVector<> operators too much)
// ImVector<ImVec4> _ClipRectStack; // [Internal]
// ImVector<ImTextureID> _TextureIdStack; // [Internal]
// ImVector<ImVec2> _Path; // [Internal] current path building
// int _ChannelsCurrent; // [Internal] current channel number (0)
// int _ChannelsCount; // [Internal] number of active channels (1+)
// ImVector<ImDrawChannel> _Channels; // [Internal] draw channels for columns API (not resized down so _ChannelsCount may be smaller than _Channels.Size)
// If you want to create ImDrawList instances, pass them ImGui::GetDrawListSharedData() or create and use your own ImDrawListSharedData (so you can use ImDrawList without ImGui)
// ImDrawList(const ImDrawListSharedData* shared_data) { _Data = shared_data; _OwnerName = NULL; Clear(); }
// ~ImDrawList() { ClearFreeMemory(); }
// IMGUI_API void PushClipRect(ImVec2 clip_rect_min, ImVec2 clip_rect_max, bool intersect_with_current_clip_rect = false); // Render-level scissoring. This is passed down to your render function but not used for CPU-side coarse clipping. Prefer using higher-level ImGui::PushClipRect() to affect logic (hit-testing and widget culling)
PushClipRect(clip_rect_min: Readonly<interface_ImVec2>, clip_rect_max: Readonly<interface_ImVec2>, intersect_with_current_clip_rect: boolean): void;
// IMGUI_API void PushClipRectFullScreen();
PushClipRectFullScreen(): void;
// IMGUI_API void PopClipRect();
PopClipRect(): void;
// IMGUI_API void PushTextureID(const ImTextureID& texture_id);
PushTextureID(texture_id: ImTextureID): void;
// IMGUI_API void PopTextureID();
PopTextureID(): void;
// inline ImVec2 GetClipRectMin() const { const ImVec4& cr = _ClipRectStack.back(); return ImVec2(cr.x, cr.y); }
GetClipRectMin(out: interface_ImVec2): typeof out;
// inline ImVec2 GetClipRectMax() const { const ImVec4& cr = _ClipRectStack.back(); return ImVec2(cr.z, cr.w); }
GetClipRectMax(out: interface_ImVec2): typeof out;
// Primitives
// IMGUI_API void AddLine(const ImVec2& a, const ImVec2& b, ImU32 col, float thickness = 1.0f);
AddLine(a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, col: ImU32, thickness: number): void;
// IMGUI_API void AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners_flags = ImDrawFlags_None, float thickness = 1.0f); // a: upper-left, b: lower-right, rounding_corners_flags: 4-bits corresponding to which corner to round
AddRect(a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, col: ImU32, rounding: number, rounding_corners_flags: ImDrawFlags, thickness: number): void;
// IMGUI_API void AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners_flags = ImDrawFlags_None); // a: upper-left, b: lower-right
AddRectFilled(a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, col: ImU32, rounding: number, rounding_corners_flags: ImDrawFlags): void;
// IMGUI_API void AddRectFilledMultiColor(const ImVec2& a, const ImVec2& b, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left);
AddRectFilledMultiColor(a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, col_upr_left: ImU32, col_upr_right: ImU32, col_bot_right: ImU32, col_bot_left: ImU32): void;
// IMGUI_API void AddQuad(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, ImU32 col, float thickness = 1.0f);
AddQuad(a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, c: Readonly<interface_ImVec2>, d: Readonly<interface_ImVec2>, col: ImU32, thickness: number): void;
// IMGUI_API void AddQuadFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, ImU32 col);
AddQuadFilled(a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, c: Readonly<interface_ImVec2>, d: Readonly<interface_ImVec2>, col: ImU32): void;
// IMGUI_API void AddTriangle(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col, float thickness = 1.0f);
AddTriangle(a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, c: Readonly<interface_ImVec2>, col: ImU32, thickness: number): void;
// IMGUI_API void AddTriangleFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col);
AddTriangleFilled(a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, c: Readonly<interface_ImVec2>, col: ImU32): void;
// IMGUI_API void AddCircle(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12, float thickness = 1.0f);
AddCircle(centre: Readonly<interface_ImVec2>, radius: number, col: ImU32, num_segments: number, thickness: number): void;
// IMGUI_API void AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12);
AddCircleFilled(centre: Readonly<interface_ImVec2>, radius: number, col: ImU32, num_segments: number): void;
// IMGUI_API void AddNgon(const ImVec2& center, float radius, ImU32 col, int num_segments, float thickness = 1.0f);
AddNgon(centre: Readonly<interface_ImVec2>, radius: number, col: ImU32, num_segments: number, thickness: number): void;
// IMGUI_API void AddNgonFilled(const ImVec2& center, float radius, ImU32 col, int num_segments);
AddNgonFilled(centre: Readonly<interface_ImVec2>, radius: number, col: ImU32, num_segments: number): void;
// IMGUI_API void AddText(const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL);
AddText_A(pos: Readonly<interface_ImVec2>, col: ImU32, text_begin: string): void;
// IMGUI_API void AddText(const ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL, float wrap_width = 0.0f, const ImVec4* cpu_fine_clip_rect = NULL);
AddText_B(font: reference_ImFont, font_size: number, pos: Readonly<interface_ImVec2>, col: ImU32, text_begin: string, wrap_width: number, cpu_fine_clip_rect: Readonly<interface_ImVec4> | null): void;
// IMGUI_API void AddImage(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a = ImVec2(0,0), const ImVec2& uv_b = ImVec2(1,1), ImU32 col = 0xFFFFFFFF);
AddImage(user_texture_id: ImTextureID, a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, uv_a: Readonly<interface_ImVec2>, uv_b: Readonly<interface_ImVec2>, col: ImU32): void;
// IMGUI_API void AddImageQuad(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a = ImVec2(0,0), const ImVec2& uv_b = ImVec2(1,0), const ImVec2& uv_c = ImVec2(1,1), const ImVec2& uv_d = ImVec2(0,1), ImU32 col = 0xFFFFFFFF);
AddImageQuad(user_texture_id: ImTextureID, a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, c: Readonly<interface_ImVec2>, d: Readonly<interface_ImVec2>, uv_a: Readonly<interface_ImVec2>, uv_b: Readonly<interface_ImVec2>, uv_c: Readonly<interface_ImVec2>, uv_d: Readonly<interface_ImVec2>, col: ImU32): void;
// IMGUI_API void AddImageRounded(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, ImU32 col, float rounding, int flags = ImDrawFlags_None);
AddImageRounded(user_texture_id: ImTextureID, a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, uv_a: Readonly<interface_ImVec2>, uv_b: Readonly<interface_ImVec2>, col: ImU32, rounding: number, flags: ImDrawFlags): void;
// IMGUI_API void AddPolyline(const ImVec2* points, const int num_points, ImU32 col, bool closed, float thickness);
AddPolyline(points: Readonly<interface_ImVec2>[], num_points: number, col: ImU32, flags: ImDrawFlags, thickness: number): void;
// IMGUI_API void AddConvexPolyFilled(const ImVec2* points, const int num_points, ImU32 col);
AddConvexPolyFilled(points: Readonly<interface_ImVec2>[], num_points: number, col: ImU32): void;
// IMGUI_API void AddBezierCubic(const ImVec2& pos0, const ImVec2& cp0, const ImVec2& cp1, const ImVec2& pos1, ImU32 col, float thickness, int num_segments = 0);
AddBezierCubic(pos0: Readonly<interface_ImVec2>, cp0: Readonly<interface_ImVec2>, cp1: Readonly<interface_ImVec2>, pos1: Readonly<interface_ImVec2>, col: ImU32, thickness: number, num_segments: number): void;
AddBezierQuadratic(pos0: Readonly<interface_ImVec2>, cp0: Readonly<interface_ImVec2>, cp1: Readonly<interface_ImVec2>, col: ImU32, thickness: number, num_segments: number): void;
// Stateful path API, add points then finish with PathFill() or PathStroke()
// inline void PathClear() { _Path.resize(0); }
PathClear(): void;
// inline void PathLineTo(const ImVec2& pos) { _Path.push_back(pos); }
PathLineTo(pos: Readonly<interface_ImVec2>): void;
// inline void PathLineToMergeDuplicate(const ImVec2& pos) { if (_Path.Size == 0 || memcmp(&_Path[_Path.Size-1], &pos, 8) != 0) _Path.push_back(pos); }
PathLineToMergeDuplicate(pos: Readonly<interface_ImVec2>): void;
// inline void PathFillConvex(ImU32 col) { AddConvexPolyFilled(_Path.Data, _Path.Size, col); PathClear(); }
PathFillConvex(col: ImU32): void;
// inline void PathStroke(ImU32 col, bool closed, float thickness = 1.0f) { AddPolyline(_Path.Data, _Path.Size, col, closed, thickness); PathClear(); }
PathStroke(col: ImU32, flags: ImDrawFlags, thickness: number): void;
// IMGUI_API void PathArcTo(const ImVec2& centre, float radius, float a_min, float a_max, int num_segments = 10);
PathArcTo(centre: Readonly<interface_ImVec2>, radius: number, a_min: number, a_max: number, num_segments: number): void;
// IMGUI_API void PathArcToFast(const ImVec2& centre, float radius, int a_min_of_12, int a_max_of_12); // Use precomputed angles for a 12 steps circle
PathArcToFast(centre: Readonly<interface_ImVec2>, radius: number, a_min_of_12: number, a_max_of_12: number): void;
// IMGUI_API void PathBezierCurveTo(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, int num_segments = 0);
PathBezierCubicCurveTo(p1: Readonly<interface_ImVec2>, p2: Readonly<interface_ImVec2>, p3: Readonly<interface_ImVec2>, num_segments: number): void;
PathBezierQuadraticCurveTo(p2: Readonly<interface_ImVec2>, p3: Readonly<interface_ImVec2>, num_segments: number): void;
// IMGUI_API void PathRect(const ImVec2& rect_min, const ImVec2& rect_max, float rounding = 0.0f, int flags = ImDrawFlags_None);
PathRect(rect_min: Readonly<interface_ImVec2>, rect_max: Readonly<interface_ImVec2>, rounding: number, flags: ImDrawFlags): void;
// Channels
// - Use to simulate layers. By switching channels to can render out-of-order (e.g. submit foreground primitives before background primitives)
// - Use to minimize draw calls (e.g. if going back-and-forth between multiple non-overlapping clipping rectangles, prefer to append into separate channels then merge at the end)
// IMGUI_API void ChannelsSplit(int channels_count);
ChannelsSplit(channels_count: number): void;
// IMGUI_API void ChannelsMerge();
ChannelsMerge(): void;
// IMGUI_API void ChannelsSetCurrent(int channel_index);
ChannelsSetCurrent(channel_index: number): void;
// Advanced
// IMGUI_API void AddCallback(ImDrawCallback callback, void* callback_data); // Your rendering function must check for 'UserCallback' in ImDrawCmd and call the function instead of rendering triangles.
AddCallback(callback: ImDrawCallback, callback_data: any): void;
// IMGUI_API void AddDrawCmd(); // This is useful if you need to forcefully create a new draw call (to allow for dependent rendering / blending). Otherwise primitives are merged into the same draw-call as much as possible
AddDrawCmd(): void;
// Internal helpers
// NB: all primitives needs to be reserved via PrimReserve() beforehand!
// IMGUI_API void Clear();
Clear(): void;
// IMGUI_API void ClearFreeMemory();
ClearFreeMemory(): void;
// IMGUI_API void PrimReserve(int idx_count, int vtx_count);
PrimReserve(idx_count: number, vtx_count: number): void;
PrimUnreserve(idx_count: number, vtx_count: number): void;
// IMGUI_API void PrimRect(const ImVec2& a, const ImVec2& b, ImU32 col); // Axis aligned rectangle (composed of two triangles)
PrimRect(a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, col: ImU32): void;
// IMGUI_API void PrimRectUV(const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, ImU32 col);
PrimRectUV(a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, uv_a: Readonly<interface_ImVec2>, uv_b: Readonly<interface_ImVec2>, col: ImU32): void;
// IMGUI_API void PrimQuadUV(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a, const ImVec2& uv_b, const ImVec2& uv_c, const ImVec2& uv_d, ImU32 col);
PrimQuadUV(a: Readonly<interface_ImVec2>, b: Readonly<interface_ImVec2>, c: Readonly<interface_ImVec2>, d: Readonly<interface_ImVec2>, uv_a: Readonly<interface_ImVec2>, uv_b: Readonly<interface_ImVec2>, uv_c: Readonly<interface_ImVec2>, uv_d: Readonly<interface_ImVec2>, col: ImU32): void;
// inline void PrimWriteVtx(const ImVec2& pos, const ImVec2& uv, ImU32 col){ _VtxWritePtr->pos = pos; _VtxWritePtr->uv = uv; _VtxWritePtr->col = col; _VtxWritePtr++; _VtxCurrentIdx++; }
PrimWriteVtx(pos: Readonly<interface_ImVec2>, us: Readonly<interface_ImVec2>, col: ImU32): void;
// inline void PrimWriteIdx(ImDrawIdx idx) { *_IdxWritePtr = idx; _IdxWritePtr++; }
PrimWriteIdx(idx: number): void;
// inline void PrimVtx(const ImVec2& pos, const ImVec2& uv, ImU32 col) { PrimWriteIdx((ImDrawIdx)_VtxCurrentIdx); PrimWriteVtx(pos, uv, col); }
PrimVtx(pos: Readonly<interface_ImVec2>, uv: Readonly<interface_ImVec2>, col: ImU32): void;
// IMGUI_API void UpdateClipRect();
UpdateClipRect(): void;
// IMGUI_API void UpdateTextureID();
UpdateTextureID(): void;
// IMGUI_API int _CalcCircleAutoSegmentCount(float radius) const;
_CalcCircleAutoSegmentCount(radius: number): number;
}
export interface reference_ImDrawData extends Emscripten$1.EmscriptenClassReference {
IterateDrawLists(callback: (draw_list: reference_ImDrawList) => void): void;
// bool Valid; // Only valid after Render() is called and before the next NewFrame() is called.
readonly Valid: boolean;
// ImDrawList** CmdLists;
// int CmdListsCount;
readonly CmdListsCount: number;
// int TotalVtxCount; // For convenience, sum of all cmd_lists vtx_buffer.Size
readonly TotalVtxCount: number;
// int TotalIdxCount; // For convenience, sum of all cmd_lists idx_buffer.Size
readonly TotalIdxCount: number;
// ImVec2 DisplayPos; // Upper-left position of the viewport to render (== upper-left of the orthogonal projection matrix to use)
readonly DisplayPos: Readonly<reference_ImVec2>;
// ImVec2 DisplaySize; // Size of the viewport to render (== io.DisplaySize for the main viewport) (DisplayPos + DisplaySize == lower-right of the orthogonal projection matrix to use)
readonly DisplaySize: Readonly<reference_ImVec2>;
// ImVec2 FramebufferScale; // Amount of pixels for each unit of DisplaySize. Based on io.DisplayFramebufferScale. Generally (1,1) on normal display, (2,2) on OSX with Retina display.
readonly FramebufferScale: Readonly<reference_ImVec2>;
// Functions
// ImDrawData() { Clear(); }
// void Clear() { Valid = false; CmdLists = NULL; CmdListsCount = TotalVtxCount = TotalIdxCount = 0; } // Draw lists are owned by the ImGuiContext and only pointed to here.
// IMGUI_API void DeIndexAllBuffers(); // For backward compatibility or convenience: convert all buffers from indexed to de-indexed, in case you cannot render indexed. Note: this is slow and most likely a waste of resources. Always prefer indexed rendering!
DeIndexAllBuffers(): void;
// IMGUI_API void ScaleClipRects(const ImVec2& fb_scale); // Helper to scale the ClipRect field of each ImDrawCmd. Use if your final output buffer is at a different scale than ImGui expects, or if there is a difference between your window resolution and framebuffer resolution.
ScaleClipRects(fb_scale: Readonly<interface_ImVec2>): void;
}
export interface reference_ImFont extends Emscripten$1.EmscriptenClassReference {
// Members: Hot ~62/78 bytes
// float FontSize; // <user set> // Height of characters, set during loading (don't change after loading)
FontSize: number;
// float Scale; // = 1.f // Base font scale, multiplied by the per-window font scale which you can adjust with SetFontScale()
Scale: number;
// ImVec2 DisplayOffset; // = (0.f,1.f) // Offset font rendering by xx pixels
readonly DisplayOffset: reference_ImVec2;
// ImVector<ImFontGlyph> Glyphs; // // All glyphs.
IterateGlyphs(callback: (cfg: reference_ImFontGlyph) => void): void;
// ImVector<float> IndexAdvanceX; // // Sparse. Glyphs->AdvanceX in a directly indexable way (more cache-friendly, for CalcTextSize functions which are often bottleneck in large UI).
// IndexAdvanceX: any;
// ImVector<unsigned short> IndexLookup; // // Sparse. Index glyphs by Unicode code-point.
// IndexLookup: any;
// const ImFontGlyph* FallbackGlyph; // == FindGlyph(FontFallbackChar)
// FallbackGlyph: any;
FallbackGlyph: Readonly<reference_ImFontGlyph> | null;
// float FallbackAdvanceX; // == FallbackGlyph->AdvanceX
FallbackAdvanceX: number;
// ImWchar FallbackChar; // = '?' // Replacement glyph if one isn't found. Only set via SetFallbackChar()
FallbackChar: number;
EllipsisChar: number;
DotChar: number;
// Members: Cold ~18/26 bytes
// short ConfigDataCount; // ~ 1 // Number of ImFontConfig involved in creating this font. Bigger than 1 when merging multiple font sources into one ImFont.
ConfigDataCount: number;
// ImFontConfig* ConfigData; // // Pointer within ContainerAtlas->ConfigData
// ConfigData: any;
IterateConfigData(callback: (cfg: interface_ImFontConfig) => void): void;
// ImFontAtlas* ContainerAtlas; // // What we has been loaded into
// ContainerAtlas: any;
// float Ascent, Descent; // // Ascent: distance from top to bottom of e.g. 'A' [0..FontSize]
Ascent: number;
Descent: number;
// int MetricsTotalSurface;// // Total surface in pixels to get an idea of the font rasterization/texture cost (not exact, we approximate the cost of padding between glyphs)
MetricsTotalSurface: number;
// Methods
// IMGUI_API ImFont();
// IMGUI_API ~ImFont();
// IMGUI_API void ClearOutputData();
ClearOutputData(): void;
// IMGUI_API void BuildLookupTable();
BuildLookupTable(): void;
// IMGUI_API const ImFontGlyph*FindGlyph(ImWchar c) const;
FindGlyph(c: number): Readonly<reference_ImFontGlyph> | null;
// IMGUI_API const ImFontGlyph*FindGlyphNoFallback(ImWchar c) const;
FindGlyphNoFallback(c: number): Readonly<reference_ImFontGlyph> | null;
// IMGUI_API void SetFallbackChar(ImWchar c);
// SetFallbackChar(c: number): void;
// float GetCharAdvance(ImWchar c) const { return ((int)c < IndexAdvanceX.Size) ? IndexAdvanceX[(int)c] : FallbackAdvanceX; }
GetCharAdvance(c: number): number;
// bool IsLoaded() const { return ContainerAtlas != NULL; }
IsLoaded(): boolean;
// const char* GetDebugName() const { return ConfigData ? ConfigData->Name : "<unknown>"; }
GetDebugName(): string;
// 'max_width' stops rendering after a certain width (could be turned into a 2d size). FLT_MAX to disable.
// 'wrap_width' enable automatic word-wrapping across multiple lines to fit into given width. 0.0f to disable.
// IMGUI_API ImVec2 CalcTextSizeA(float size, float max_width, float wrap_width, const char* text_begin, const char* text_end = NULL, const char** remaining = NULL) const; // utf8
CalcTextSizeA(size: number, max_width: number, wrap_width: number, text_begin: string, remaining: ImScalar<number> | null, out: interface_ImVec2): interface_ImVec2;
// IMGUI_API const char* CalcWordWrapPositionA(float scale, const char* text, const char* text_end, float wrap_width) const;
CalcWordWrapPositionA(scale: number, text: string, wrap_width: number): number;
// IMGUI_API void RenderChar(ImDrawList* draw_list, float size, ImVe