From 963fae202108acd0498349e872e4811fa6c6aba0 Mon Sep 17 00:00:00 2001
From: Nic Gaffney <gaffney_nic@protonmail.com>
Date: Wed, 12 Jun 2024 21:15:52 -0500
Subject: Added imgui for configuration

---
 vendor/zgui/src/zgui.cpp | 2708 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 2708 insertions(+)
 create mode 100644 vendor/zgui/src/zgui.cpp

(limited to 'vendor/zgui/src/zgui.cpp')

diff --git a/vendor/zgui/src/zgui.cpp b/vendor/zgui/src/zgui.cpp
new file mode 100644
index 0000000..658b009
--- /dev/null
+++ b/vendor/zgui/src/zgui.cpp
@@ -0,0 +1,2708 @@
+#include "imgui.h"
+
+#if ZGUI_IMPLOT
+#include "implot.h"
+#endif
+
+#if ZGUI_TE
+#include "imgui_te_engine.h"
+#include "imgui_te_context.h"
+#include "imgui_te_ui.h"
+#include "imgui_te_utils.h"
+#include "imgui_te_exporters.h"
+#endif
+
+#include "imgui_internal.h"
+
+#ifndef ZGUI_API
+#define ZGUI_API
+#endif
+
+extern "C" {
+
+/*
+#include <stdio.h>
+
+ZGUI_API float zguiGetFloatMin(void) {
+    printf("__FLT_MIN__ %.32e\n", __FLT_MIN__);
+    return __FLT_MIN__;
+}
+
+ZGUI_API float zguiGetFloatMax(void) {
+    printf("__FLT_MAX__ %.32e\n", __FLT_MAX__);
+    return __FLT_MAX__;
+}
+*/
+
+ZGUI_API void zguiSetAllocatorFunctions(
+    void* (*alloc_func)(size_t, void*),
+    void (*free_func)(void*, void*)
+) {
+    ImGui::SetAllocatorFunctions(alloc_func, free_func, nullptr);
+}
+
+ZGUI_API void zguiSetNextWindowPos(float x, float y, ImGuiCond cond, float pivot_x, float pivot_y) {
+    ImGui::SetNextWindowPos({ x, y }, cond, { pivot_x, pivot_y });
+}
+
+ZGUI_API void zguiSetNextWindowSize(float w, float h, ImGuiCond cond) {
+    ImGui::SetNextWindowSize({ w, h }, cond);
+}
+
+ZGUI_API void zguiSetNextWindowCollapsed(bool collapsed, ImGuiCond cond) {
+    ImGui::SetNextWindowCollapsed(collapsed, cond);
+}
+
+ZGUI_API void zguiSetNextWindowFocus(void) {
+    ImGui::SetNextWindowFocus();
+}
+
+ZGUI_API void zguiSetNextWindowBgAlpha(float alpha) {
+    ImGui::SetNextWindowBgAlpha(alpha);
+}
+
+ZGUI_API void zguiSetWindowFocus(const char* name) {
+    ImGui::SetWindowFocus(name);
+}
+
+ZGUI_API void zguiSetKeyboardFocusHere(int offset) {
+    ImGui::SetKeyboardFocusHere(offset);
+}
+
+ZGUI_API bool zguiBegin(const char* name, bool* p_open, ImGuiWindowFlags flags) {
+    return ImGui::Begin(name, p_open, flags);
+}
+
+ZGUI_API void zguiEnd(void) {
+    ImGui::End();
+}
+
+ZGUI_API bool zguiBeginChild(const char* str_id, float w, float h, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags) {
+    return ImGui::BeginChild(str_id, { w, h }, child_flags, window_flags);
+}
+
+ZGUI_API bool zguiBeginChildId(ImGuiID id, float w, float h, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags) {
+    return ImGui::BeginChild(id, { w, h }, child_flags, window_flags);
+}
+
+ZGUI_API void zguiEndChild(void) {
+    ImGui::EndChild();
+}
+
+ZGUI_API float zguiGetScrollX(void) {
+    return ImGui::GetScrollX();
+}
+
+ZGUI_API float zguiGetScrollY(void) {
+    return ImGui::GetScrollY();
+}
+
+ZGUI_API void zguiSetScrollX(float scroll_x) {
+    ImGui::SetScrollX(scroll_x);
+}
+
+ZGUI_API void zguiSetScrollY(float scroll_y) {
+    ImGui::SetScrollY(scroll_y);
+}
+
+ZGUI_API float zguiGetScrollMaxX(void) {
+    return ImGui::GetScrollMaxX();
+}
+
+ZGUI_API float zguiGetScrollMaxY(void) {
+    return ImGui::GetScrollMaxY();
+}
+
+ZGUI_API void zguiSetScrollHereX(float center_x_ratio) {
+    ImGui::SetScrollHereX(center_x_ratio);
+}
+
+ZGUI_API void zguiSetScrollHereY(float center_y_ratio) {
+    ImGui::SetScrollHereY(center_y_ratio);
+}
+
+ZGUI_API void zguiSetScrollFromPosX(float local_x, float center_x_ratio) {
+    ImGui::SetScrollFromPosX(local_x, center_x_ratio);
+}
+
+ZGUI_API void zguiSetScrollFromPosY(float local_y, float center_y_ratio) {
+    ImGui::SetScrollFromPosY(local_y, center_y_ratio);
+}
+
+ZGUI_API bool zguiIsWindowAppearing(void) {
+    return ImGui::IsWindowAppearing();
+}
+
+ZGUI_API bool zguiIsWindowCollapsed(void) {
+    return ImGui::IsWindowCollapsed();
+}
+
+ZGUI_API bool zguiIsWindowFocused(ImGuiFocusedFlags flags) {
+    return ImGui::IsWindowFocused(flags);
+}
+
+ZGUI_API bool zguiIsWindowHovered(ImGuiHoveredFlags flags) {
+    return ImGui::IsWindowHovered(flags);
+}
+
+ZGUI_API void zguiGetWindowPos(float pos[2]) {
+    const ImVec2 p = ImGui::GetWindowPos();
+    pos[0] = p.x;
+    pos[1] = p.y;
+}
+
+ZGUI_API void zguiGetWindowSize(float size[2]) {
+    const ImVec2 s = ImGui::GetWindowSize();
+    size[0] = s.x;
+    size[1] = s.y;
+}
+
+ZGUI_API float zguiGetWindowWidth(void) {
+    return ImGui::GetWindowWidth();
+}
+
+ZGUI_API float zguiGetWindowHeight(void) {
+    return ImGui::GetWindowHeight();
+}
+
+ZGUI_API void zguiGetMouseDragDelta(ImGuiMouseButton button, float lock_threshold, float delta[2]) {
+    const ImVec2 d = ImGui::GetMouseDragDelta(button, lock_threshold);
+    delta[0] = d.x;
+    delta[1] = d.y;
+}
+
+ZGUI_API void zguiResetMouseDragDelta(ImGuiMouseButton button) {
+    ImGui::ResetMouseDragDelta(button);
+}
+
+ZGUI_API void zguiSpacing(void) {
+    ImGui::Spacing();
+}
+
+ZGUI_API void zguiNewLine(void) {
+    ImGui::NewLine();
+}
+
+ZGUI_API void zguiIndent(float indent_w) {
+    ImGui::Indent(indent_w);
+}
+
+ZGUI_API void zguiUnindent(float indent_w) {
+    ImGui::Unindent(indent_w);
+}
+
+ZGUI_API void zguiSeparator(void) {
+    ImGui::Separator();
+}
+
+ZGUI_API void zguiSeparatorText(const char* label) {
+    ImGui::SeparatorText(label);
+}
+
+ZGUI_API void zguiSameLine(float offset_from_start_x, float spacing) {
+    ImGui::SameLine(offset_from_start_x, spacing);
+}
+
+ZGUI_API void zguiDummy(float w, float h) {
+    ImGui::Dummy({ w, h });
+}
+
+ZGUI_API void zguiBeginGroup(void) {
+    ImGui::BeginGroup();
+}
+
+ZGUI_API void zguiEndGroup(void) {
+    ImGui::EndGroup();
+}
+
+ZGUI_API void zguiGetItemRectMax(float rect[2]) {
+    const ImVec2 r = ImGui::GetItemRectMax();
+    rect[0] = r.x;
+    rect[1] = r.y;
+}
+
+ZGUI_API void zguiGetItemRectMin(float rect[2]) {
+    const ImVec2 r = ImGui::GetItemRectMin();
+    rect[0] = r.x;
+    rect[1] = r.y;
+}
+
+ZGUI_API void zguiGetItemRectSize(float rect[2]) {
+    const ImVec2 r = ImGui::GetItemRectSize();
+    rect[0] = r.x;
+    rect[1] = r.y;
+}
+
+ZGUI_API void zguiGetCursorPos(float pos[2]) {
+    const ImVec2 p = ImGui::GetCursorPos();
+    pos[0] = p.x;
+    pos[1] = p.y;
+}
+
+ZGUI_API float zguiGetCursorPosX(void) {
+    return ImGui::GetCursorPosX();
+}
+
+ZGUI_API float zguiGetCursorPosY(void) {
+    return ImGui::GetCursorPosY();
+}
+
+ZGUI_API void zguiSetCursorPos(float local_x, float local_y) {
+    ImGui::SetCursorPos({ local_x, local_y });
+}
+
+ZGUI_API void zguiSetCursorPosX(float local_x) {
+    ImGui::SetCursorPosX(local_x);
+}
+
+ZGUI_API void zguiSetCursorPosY(float local_y) {
+    ImGui::SetCursorPosY(local_y);
+}
+
+ZGUI_API void zguiGetCursorStartPos(float pos[2]) {
+    const ImVec2 p = ImGui::GetCursorStartPos();
+    pos[0] = p.x;
+    pos[1] = p.y;
+}
+
+ZGUI_API void zguiGetCursorScreenPos(float pos[2]) {
+    const ImVec2 p = ImGui::GetCursorScreenPos();
+    pos[0] = p.x;
+    pos[1] = p.y;
+}
+
+ZGUI_API void zguiSetCursorScreenPos(float screen_x, float screen_y) {
+    ImGui::SetCursorScreenPos({ screen_x, screen_y });
+}
+
+ZGUI_API int zguiGetMouseCursor(void) {
+    return ImGui::GetMouseCursor();
+}
+
+ZGUI_API void zguiSetMouseCursor(int cursor) {
+    ImGui::SetMouseCursor(cursor);
+}
+
+ZGUI_API void zguiGetMousePos(float pos[2]) {
+    const ImVec2 p = ImGui::GetMousePos();
+    pos[0] = p.x;
+    pos[1] = p.y;
+}
+
+ZGUI_API void zguiAlignTextToFramePadding(void) {
+    ImGui::AlignTextToFramePadding();
+}
+
+ZGUI_API float zguiGetTextLineHeight(void) {
+    return ImGui::GetTextLineHeight();
+}
+
+ZGUI_API float zguiGetTextLineHeightWithSpacing(void) {
+    return ImGui::GetTextLineHeightWithSpacing();
+}
+
+ZGUI_API float zguiGetFrameHeight(void) {
+    return ImGui::GetFrameHeight();
+}
+
+ZGUI_API float zguiGetFrameHeightWithSpacing(void) {
+    return ImGui::GetFrameHeightWithSpacing();
+}
+
+ZGUI_API bool zguiDragFloat(
+    const char* label,
+    float* v,
+    float v_speed,
+    float v_min,
+    float v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::DragFloat(label, v, v_speed, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiDragFloat2(
+    const char* label,
+    float v[2],
+    float v_speed,
+    float v_min,
+    float v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::DragFloat2(label, v, v_speed, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiDragFloat3(
+    const char* label,
+    float v[3],
+    float v_speed,
+    float v_min,
+    float v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::DragFloat3(label, v, v_speed, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiDragFloat4(
+    const char* label,
+    float v[4],
+    float v_speed,
+    float v_min,
+    float v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::DragFloat4(label, v, v_speed, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiDragFloatRange2(
+    const char* label,
+    float* v_current_min,
+    float* v_current_max,
+    float v_speed,
+    float v_min,
+    float v_max,
+    const char* format,
+    const char* format_max,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::DragFloatRange2(
+        label,
+        v_current_min,
+        v_current_max,
+        v_speed,
+        v_min,
+        v_max,
+        format,
+        format_max,
+        flags
+    );
+}
+
+ZGUI_API bool zguiDragInt(
+    const char* label,
+    int* v,
+    float v_speed,
+    int v_min,
+    int v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::DragInt(label, v, v_speed, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiDragInt2(
+    const char* label,
+    int v[2],
+    float v_speed,
+    int v_min,
+    int v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::DragInt2(label, v, v_speed, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiDragInt3(
+    const char* label,
+    int v[3],
+    float v_speed,
+    int v_min,
+    int v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::DragInt3(label, v, v_speed, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiDragInt4(
+    const char* label,
+    int v[4],
+    float v_speed,
+    int v_min,
+    int v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::DragInt4(label, v, v_speed, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiDragIntRange2(
+    const char* label,
+    int* v_current_min,
+    int* v_current_max,
+    float v_speed,
+    int v_min,
+    int v_max,
+    const char* format,
+    const char* format_max,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::DragIntRange2(
+        label,
+        v_current_min,
+        v_current_max,
+        v_speed,
+        v_min,
+        v_max,
+        format,
+        format_max,
+        flags
+    );
+}
+
+ZGUI_API bool zguiDragScalar(
+    const char* label,
+    ImGuiDataType data_type,
+    void* p_data,
+    float v_speed,
+    const void* p_min,
+    const void* p_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::DragScalar(label, data_type, p_data, v_speed, p_min, p_max, format, flags);
+}
+
+ZGUI_API bool zguiDragScalarN(
+    const char* label,
+    ImGuiDataType data_type,
+    void* p_data,
+    int components,
+    float v_speed,
+    const void* p_min,
+    const void* p_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::DragScalarN(label, data_type, p_data, components, v_speed, p_min, p_max, format, flags);
+}
+
+ZGUI_API bool zguiBeginDragDropSource(ImGuiDragDropFlags flags = 0) {
+  return ImGui::BeginDragDropSource(flags);
+}
+ZGUI_API bool zguiSetDragDropPayload(
+    const char* type,
+    const void* data,
+    size_t sz,
+    ImGuiCond cond = 0
+) {
+  return ImGui::SetDragDropPayload(type, data, sz, cond);
+}
+ZGUI_API void zguiEndDragDropSource() {
+  return ImGui::EndDragDropSource();
+}
+ZGUI_API bool zguiBeginDragDropTarget() {
+  return ImGui::BeginDragDropTarget();
+}
+ZGUI_API const ImGuiPayload* zguiAcceptDragDropPayload(
+    const char* type,
+    ImGuiDragDropFlags flags = 0
+) {
+  return ImGui::AcceptDragDropPayload(type);
+}
+ZGUI_API void zguiEndDragDropTarget() {
+  return ImGui::EndDragDropTarget();
+}
+ZGUI_API const ImGuiPayload* zguiGetDragDropPayload() {
+  return ImGui::GetDragDropPayload();
+}
+
+ZGUI_API void zguiImGuiPayload_Clear(ImGuiPayload* payload) { payload->Clear(); }
+
+ZGUI_API bool zguiImGuiPayload_IsDataType(const ImGuiPayload* payload, const char* type) {
+  return payload->IsDataType(type);
+}
+
+ZGUI_API bool zguiImGuiPayload_IsPreview(const ImGuiPayload* payload) {
+  return payload->IsPreview();
+}
+
+ZGUI_API bool zguiImGuiPayload_IsDelivery(const ImGuiPayload* payload) {
+  return payload->IsDelivery();
+}
+
+
+ZGUI_API bool zguiCombo(
+    const char* label,
+    int* current_item,
+    const char* items_separated_by_zeros,
+    int popup_max_height_in_items
+) {
+    return ImGui::Combo(label, current_item, items_separated_by_zeros, popup_max_height_in_items);
+}
+
+ZGUI_API bool zguiBeginCombo(const char* label, const char* preview_value, ImGuiComboFlags flags) {
+    return ImGui::BeginCombo(label, preview_value, flags);
+}
+
+ZGUI_API void zguiEndCombo(void) {
+    ImGui::EndCombo();
+}
+
+ZGUI_API bool zguiBeginListBox(const char* label, float w, float h) {
+    return ImGui::BeginListBox(label, { w, h });
+}
+
+ZGUI_API void zguiEndListBox(void) {
+    ImGui::EndListBox();
+}
+
+ZGUI_API bool zguiSelectable(const char* label, bool selected, ImGuiSelectableFlags flags, float w, float h) {
+    return ImGui::Selectable(label, selected, flags, { w, h });
+}
+
+ZGUI_API bool zguiSelectableStatePtr(
+    const char* label,
+    bool* p_selected,
+    ImGuiSelectableFlags flags,
+    float w,
+    float h
+) {
+    return ImGui::Selectable(label, p_selected, flags, { w, h });
+}
+
+ZGUI_API bool zguiSliderFloat(
+    const char* label,
+    float* v,
+    float v_min,
+    float v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::SliderFloat(label, v, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiSliderFloat2(
+    const char* label,
+    float v[2],
+    float v_min,
+    float v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::SliderFloat2(label, v, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiSliderFloat3(
+    const char* label,
+    float v[3],
+    float v_min,
+    float v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::SliderFloat3(label, v, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiSliderFloat4(
+    const char* label,
+    float v[4],
+    float v_min,
+    float v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::SliderFloat4(label, v, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiSliderInt(
+    const char* label,
+    int* v,
+    int v_min,
+    int v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::SliderInt(label, v, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiSliderInt2(
+    const char* label,
+    int v[2],
+    int v_min,
+    int v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::SliderInt2(label, v, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiSliderInt3(
+    const char* label,
+    int v[3],
+    int v_min,
+    int v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::SliderInt3(label, v, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiSliderInt4(
+    const char* label,
+    int v[4],
+    int v_min,
+    int v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::SliderInt4(label, v, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiSliderScalar(
+    const char* label,
+    ImGuiDataType data_type,
+    void* p_data,
+    const void* p_min,
+    const void* p_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::SliderScalar(label, data_type, p_data, p_min, p_max, format, flags);
+}
+
+ZGUI_API bool zguiSliderScalarN(
+    const char* label,
+    ImGuiDataType data_type,
+    void* p_data,
+    int components,
+    const void* p_min,
+    const void* p_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::SliderScalarN(label, data_type, p_data, components, p_min, p_max, format, flags);
+}
+
+ZGUI_API bool zguiVSliderFloat(
+    const char* label,
+    float w,
+    float h,
+    float* v,
+    float v_min,
+    float v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::VSliderFloat(label, { w, h }, v, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiVSliderInt(
+    const char* label,
+    float w,
+    float h,
+    int* v,
+    int v_min,
+    int v_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::VSliderInt(label, { w, h }, v, v_min, v_max, format, flags);
+}
+
+ZGUI_API bool zguiVSliderScalar(
+    const char* label,
+    float w,
+    float h,
+    ImGuiDataType data_type,
+    void* p_data,
+    const void* p_min,
+    const void* p_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::VSliderScalar(label, { w, h }, data_type, p_data, p_min, p_max, format, flags);
+}
+
+ZGUI_API bool zguiSliderAngle(
+    const char* label,
+    float* v_rad,
+    float v_degrees_min,
+    float v_degrees_max,
+    const char* format,
+    ImGuiSliderFlags flags
+) {
+    return ImGui::SliderAngle(label, v_rad, v_degrees_min, v_degrees_max, format, flags);
+}
+
+ZGUI_API ImGuiInputTextCallbackData zguiInputTextCallbackData_Init(void) {
+    return ImGuiInputTextCallbackData();
+}
+
+ZGUI_API void zguiInputTextCallbackData_DeleteChars(
+    ImGuiInputTextCallbackData* data,
+    int pos,
+    int bytes_count
+) {
+    data->DeleteChars(pos, bytes_count);
+}
+
+ZGUI_API void zguiInputTextCallbackData_InsertChars(
+    ImGuiInputTextCallbackData* data,
+    int pos,
+    const char* text,
+    const char* text_end
+) {
+    data->InsertChars(pos, text, text_end);
+}
+
+ZGUI_API bool zguiInputText(
+    const char* label,
+    char* buf,
+    size_t buf_size,
+    ImGuiInputTextFlags flags,
+    ImGuiInputTextCallback callback,
+    void* user_data
+) {
+    return ImGui::InputText(label, buf, buf_size, flags, callback, user_data);
+}
+
+ZGUI_API bool zguiInputTextMultiline(
+    const char* label,
+    char* buf,
+    size_t buf_size,
+    float w,
+    float h,
+    ImGuiInputTextFlags flags,
+    ImGuiInputTextCallback callback,
+    void* user_data
+) {
+    return ImGui::InputTextMultiline(label, buf, buf_size, { w, h }, flags, callback, user_data);
+}
+
+ZGUI_API bool zguiInputTextWithHint(
+    const char* label,
+    const char* hint,
+    char* buf,
+    size_t buf_size,
+    ImGuiInputTextFlags flags,
+    ImGuiInputTextCallback callback,
+    void* user_data
+) {
+    return ImGui::InputTextWithHint(label, hint, buf, buf_size, flags, callback, user_data);
+}
+
+ZGUI_API bool zguiInputFloat(
+    const char* label,
+    float* v,
+    float step,
+    float step_fast,
+    const char* format,
+    ImGuiInputTextFlags flags
+) {
+    return ImGui::InputFloat(label, v, step, step_fast, format, flags);
+}
+
+ZGUI_API bool zguiInputFloat2(
+    const char* label,
+    float v[2],
+    const char* format,
+    ImGuiInputTextFlags flags
+) {
+    return ImGui::InputFloat2(label, v, format, flags);
+}
+
+ZGUI_API bool zguiInputFloat3(
+    const char* label,
+    float v[3],
+    const char* format,
+    ImGuiInputTextFlags flags
+) {
+    return ImGui::InputFloat3(label, v, format, flags);
+}
+
+ZGUI_API bool zguiInputFloat4(
+    const char* label,
+    float v[4],
+    const char* format,
+    ImGuiInputTextFlags flags
+) {
+    return ImGui::InputFloat4(label, v, format, flags);
+}
+
+ZGUI_API bool zguiInputInt(
+    const char* label,
+    int* v,
+    int step,
+    int step_fast,
+    ImGuiInputTextFlags flags
+) {
+    return ImGui::InputInt(label, v, step, step_fast, flags);
+}
+
+ZGUI_API bool zguiInputInt2(const char* label, int v[2], ImGuiInputTextFlags flags) {
+    return ImGui::InputInt2(label, v, flags);
+}
+
+ZGUI_API bool zguiInputInt3(const char* label, int v[3], ImGuiInputTextFlags flags) {
+    return ImGui::InputInt3(label, v, flags);
+}
+
+ZGUI_API bool zguiInputInt4(const char* label, int v[4], ImGuiInputTextFlags flags) {
+    return ImGui::InputInt4(label, v, flags);
+}
+
+ZGUI_API bool zguiInputDouble(
+    const char* label,
+    double* v,
+    double step,
+    double step_fast,
+    const char* format,
+    ImGuiInputTextFlags flags
+) {
+    return ImGui::InputDouble(label, v, step, step_fast, format, flags);
+}
+
+ZGUI_API bool zguiInputScalar(
+    const char* label,
+    ImGuiDataType data_type,
+    void* p_data,
+    const void* p_step,
+    const void* p_step_fast,
+    const char* format,
+    ImGuiInputTextFlags flags
+) {
+    return ImGui::InputScalar(label, data_type, p_data, p_step, p_step_fast, format, flags);
+}
+
+ZGUI_API bool zguiInputScalarN(
+    const char* label,
+    ImGuiDataType data_type,
+    void* p_data,
+    int components,
+    const void* p_step,
+    const void* p_step_fast,
+    const char* format,
+    ImGuiInputTextFlags flags
+) {
+    return ImGui::InputScalarN(label, data_type, p_data, components, p_step, p_step_fast, format, flags);
+}
+
+ZGUI_API bool zguiColorEdit3(const char* label, float col[3], ImGuiColorEditFlags flags) {
+    return ImGui::ColorEdit3(label, col, flags);
+}
+
+ZGUI_API bool zguiColorEdit4(const char* label, float col[4], ImGuiColorEditFlags flags) {
+    return ImGui::ColorEdit4(label, col, flags);
+}
+
+ZGUI_API bool zguiColorPicker3(const char* label, float col[3], ImGuiColorEditFlags flags) {
+    return ImGui::ColorPicker3(label, col, flags);
+}
+
+ZGUI_API bool zguiColorPicker4(const char* label, float col[4], ImGuiColorEditFlags flags, const float* ref_col) {
+    return ImGui::ColorPicker4(label, col, flags, ref_col);
+}
+
+ZGUI_API bool zguiColorButton(const char* desc_id, const float col[4], ImGuiColorEditFlags flags, float w, float h) {
+    return ImGui::ColorButton(desc_id, { col[0], col[1], col[2], col[3] }, flags, { w, h });
+}
+
+ZGUI_API void zguiTextUnformatted(const char* text, const char* text_end) {
+    ImGui::TextUnformatted(text, text_end);
+}
+
+ZGUI_API void zguiTextColored(const float col[4], const char* fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    ImGui::TextColoredV({ col[0], col[1], col[2], col[3] }, fmt, args);
+    va_end(args);
+}
+
+ZGUI_API void zguiTextDisabled(const char* fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    ImGui::TextDisabledV(fmt, args);
+    va_end(args);
+}
+
+ZGUI_API void zguiTextWrapped(const char* fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    ImGui::TextWrappedV(fmt, args);
+    va_end(args);
+}
+
+ZGUI_API void zguiBulletText(const char* fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    ImGui::BulletTextV(fmt, args);
+    va_end(args);
+}
+
+ZGUI_API void zguiLabelText(const char* label, const char* fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    ImGui::LabelTextV(label, fmt, args);
+    va_end(args);
+}
+
+ZGUI_API void zguiCalcTextSize(
+    const char* txt,
+    const char* txt_end,
+    bool hide_text_after_double_hash,
+    float wrap_width,
+    float* out_w,
+    float* out_h
+) {
+    assert(out_w && out_h);
+    const ImVec2 s = ImGui::CalcTextSize(txt, txt_end, hide_text_after_double_hash, wrap_width);
+    *out_w = s.x;
+    *out_h = s.y;
+}
+
+ZGUI_API bool zguiButton(const char* label, float x, float y) {
+    return ImGui::Button(label, { x, y });
+}
+
+ZGUI_API bool zguiSmallButton(const char* label) {
+    return ImGui::SmallButton(label);
+}
+
+ZGUI_API bool zguiInvisibleButton(const char* str_id, float w, float h, ImGuiButtonFlags flags) {
+    return ImGui::InvisibleButton(str_id, { w, h }, flags);
+}
+
+ZGUI_API bool zguiArrowButton(const char* str_id, ImGuiDir dir) {
+    return ImGui::ArrowButton(str_id, dir);
+}
+
+ZGUI_API void zguiImage(
+    ImTextureID user_texture_id,
+    float w,
+    float h,
+    const float uv0[2],
+    const float uv1[2],
+    const float tint_col[4],
+    const float border_col[4]
+) {
+    ImGui::Image(
+        user_texture_id,
+        { w, h },
+        { uv0[0], uv0[1] },
+        { uv1[0], uv1[1] },
+        { tint_col[0], tint_col[1], tint_col[2], tint_col[3] },
+        { border_col[0], border_col[1], border_col[2], border_col[3] }
+    );
+}
+
+ZGUI_API bool zguiImageButton(
+    const char* str_id,
+    ImTextureID user_texture_id,
+    float w,
+    float h,
+    const float uv0[2],
+    const float uv1[2],
+    const float bg_col[4],
+    const float tint_col[4]
+) {
+    return ImGui::ImageButton(
+        str_id,
+        user_texture_id,
+        { w, h },
+        { uv0[0], uv0[1] },
+        { uv1[0], uv1[1] },
+        { bg_col[0], bg_col[1], bg_col[2], bg_col[3] },
+        { tint_col[0], tint_col[1], tint_col[2], tint_col[3] }
+    );
+}
+
+ZGUI_API void zguiBullet(void) {
+    ImGui::Bullet();
+}
+
+ZGUI_API bool zguiRadioButton(const char* label, bool active) {
+    return ImGui::RadioButton(label, active);
+}
+
+ZGUI_API bool zguiRadioButtonStatePtr(const char* label, int* v, int v_button) {
+    return ImGui::RadioButton(label, v, v_button);
+}
+
+ZGUI_API bool zguiCheckbox(const char* label, bool* v) {
+    return ImGui::Checkbox(label, v);
+}
+
+ZGUI_API bool zguiCheckboxBits(const char* label, unsigned int* bits, unsigned int bits_value) {
+    return ImGui::CheckboxFlags(label, bits, bits_value);
+}
+
+ZGUI_API void zguiProgressBar(float fraction, float w, float h, const char* overlay) {
+    return ImGui::ProgressBar(fraction, { w, h }, overlay);
+}
+
+ZGUI_API ImGuiContext* zguiCreateContext(ImFontAtlas* shared_font_atlas) {
+    return ImGui::CreateContext(shared_font_atlas);
+}
+
+ZGUI_API void zguiDestroyContext(ImGuiContext* ctx) {
+    ImGui::DestroyContext(ctx);
+}
+
+ZGUI_API ImGuiContext* zguiGetCurrentContext(void) {
+    return ImGui::GetCurrentContext();
+}
+
+ZGUI_API void zguiSetCurrentContext(ImGuiContext* ctx) {
+    ImGui::SetCurrentContext(ctx);
+}
+
+ZGUI_API void zguiNewFrame(void) {
+    ImGui::NewFrame();
+}
+
+ZGUI_API void zguiRender(void) {
+    ImGui::Render();
+}
+
+ZGUI_API ImDrawData* zguiGetDrawData(void) {
+    return ImGui::GetDrawData();
+}
+
+ZGUI_API void zguiShowDemoWindow(bool* p_open) {
+    ImGui::ShowDemoWindow(p_open);
+}
+
+ZGUI_API void zguiBeginDisabled(bool disabled) {
+    ImGui::BeginDisabled(disabled);
+}
+
+ZGUI_API void zguiEndDisabled(void) {
+    ImGui::EndDisabled();
+}
+
+ZGUI_API ImGuiStyle* zguiGetStyle(void) {
+    return &ImGui::GetStyle();
+}
+
+ZGUI_API ImGuiStyle zguiStyle_Init(void) {
+    return ImGuiStyle();
+}
+
+ZGUI_API void zguiStyle_ScaleAllSizes(ImGuiStyle* style, float scale_factor) {
+    style->ScaleAllSizes(scale_factor);
+}
+
+ZGUI_API void zguiPushStyleColor4f(ImGuiCol idx, const float col[4]) {
+    ImGui::PushStyleColor(idx, { col[0], col[1], col[2], col[3] });
+}
+
+ZGUI_API void zguiPushStyleColor1u(ImGuiCol idx, ImU32 col) {
+    ImGui::PushStyleColor(idx, col);
+}
+
+ZGUI_API void zguiPopStyleColor(int count) {
+    ImGui::PopStyleColor(count);
+}
+
+ZGUI_API void zguiPushStyleVar1f(ImGuiStyleVar idx, float var) {
+    ImGui::PushStyleVar(idx, var);
+}
+
+ZGUI_API void zguiPushStyleVar2f(ImGuiStyleVar idx, const float var[2]) {
+    ImGui::PushStyleVar(idx, { var[0], var[1] });
+}
+
+ZGUI_API void zguiPopStyleVar(int count) {
+    ImGui::PopStyleVar(count);
+}
+
+ZGUI_API void zguiPushItemWidth(float item_width) {
+    ImGui::PushItemWidth(item_width);
+}
+
+ZGUI_API void zguiPopItemWidth(void) {
+    ImGui::PopItemWidth();
+}
+
+ZGUI_API void zguiSetNextItemWidth(float item_width) {
+    ImGui::SetNextItemWidth(item_width);
+}
+
+ZGUI_API void zguiSetItemDefaultFocus(void) {
+    ImGui::SetItemDefaultFocus();
+}
+
+ZGUI_API ImFont* zguiGetFont(void) {
+    return ImGui::GetFont();
+}
+
+ZGUI_API float zguiGetFontSize(void) {
+    return ImGui::GetFontSize();
+}
+
+ZGUI_API void zguiGetFontTexUvWhitePixel(float uv[2]) {
+    const ImVec2 cs = ImGui::GetFontTexUvWhitePixel();
+    uv[0] = cs[0];
+    uv[1] = cs[1];
+}
+
+ZGUI_API void zguiPushFont(ImFont* font) {
+    ImGui::PushFont(font);
+}
+
+ZGUI_API void zguiPopFont(void) {
+    ImGui::PopFont();
+}
+
+ZGUI_API bool zguiTreeNode(const char* label) {
+    return ImGui::TreeNode(label);
+}
+
+ZGUI_API bool zguiTreeNodeFlags(const char* label, ImGuiTreeNodeFlags flags) {
+    return ImGui::TreeNodeEx(label, flags);
+}
+
+ZGUI_API bool zguiTreeNodeStrId(const char* str_id, const char* fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    const bool ret = ImGui::TreeNodeV(str_id, fmt, args);
+    va_end(args);
+    return ret;
+}
+
+ZGUI_API bool zguiTreeNodeStrIdFlags(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    const bool ret = ImGui::TreeNodeExV(str_id, flags, fmt, args);
+    va_end(args);
+    return ret;
+}
+
+ZGUI_API bool zguiTreeNodePtrId(const void* ptr_id, const char* fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    const bool ret = ImGui::TreeNodeV(ptr_id, fmt, args);
+    va_end(args);
+    return ret;
+}
+
+ZGUI_API bool zguiTreeNodePtrIdFlags(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    const bool ret = ImGui::TreeNodeExV(ptr_id, flags, fmt, args);
+    va_end(args);
+    return ret;
+}
+
+ZGUI_API bool zguiCollapsingHeader(const char* label, ImGuiTreeNodeFlags flags) {
+    return ImGui::CollapsingHeader(label, flags);
+}
+
+ZGUI_API bool zguiCollapsingHeaderStatePtr(const char* label, bool* p_visible, ImGuiTreeNodeFlags flags) {
+    return ImGui::CollapsingHeader(label, p_visible, flags);
+}
+
+ZGUI_API void zguiSetNextItemOpen(bool is_open, ImGuiCond cond) {
+    ImGui::SetNextItemOpen(is_open, cond);
+}
+
+ZGUI_API void zguiTreePushStrId(const char* str_id) {
+    ImGui::TreePush(str_id);
+}
+
+ZGUI_API void zguiTreePushPtrId(const void* ptr_id) {
+    ImGui::TreePush(ptr_id);
+}
+
+ZGUI_API void zguiTreePop(void) {
+    ImGui::TreePop();
+}
+
+ZGUI_API void zguiPushStrId(const char* str_id_begin, const char* str_id_end) {
+    ImGui::PushID(str_id_begin, str_id_end);
+}
+
+ZGUI_API void zguiPushStrIdZ(const char* str_id) {
+    ImGui::PushID(str_id);
+}
+
+ZGUI_API void zguiPushPtrId(const void* ptr_id) {
+    ImGui::PushID(ptr_id);
+}
+
+ZGUI_API void zguiPushIntId(int int_id) {
+    ImGui::PushID(int_id);
+}
+
+ZGUI_API void zguiPopId(void) {
+    ImGui::PopID();
+}
+
+ZGUI_API ImGuiID zguiGetStrId(const char* str_id_begin, const char* str_id_end) {
+    return ImGui::GetID(str_id_begin, str_id_end);
+}
+
+ZGUI_API ImGuiID zguiGetStrIdZ(const char* str_id) {
+    return ImGui::GetID(str_id);
+}
+
+ZGUI_API ImGuiID zguiGetPtrId(const void* ptr_id) {
+    return ImGui::GetID(ptr_id);
+}
+
+ZGUI_API void zguiSetClipboardText(const char* text) {
+    ImGui::SetClipboardText(text);
+}
+
+ZGUI_API const char* zguiGetClipboardText(void) {
+    return ImGui::GetClipboardText();
+}
+
+ZGUI_API ImFont* zguiIoAddFontFromFileWithConfig(
+    const char* filename,
+    float size_pixels,
+    const ImFontConfig* config,
+    const ImWchar* ranges
+) {
+    return ImGui::GetIO().Fonts->AddFontFromFileTTF(filename, size_pixels, config, ranges);
+}
+
+ZGUI_API ImFont* zguiIoAddFontFromFile(const char* filename, float size_pixels) {
+    return ImGui::GetIO().Fonts->AddFontFromFileTTF(filename, size_pixels, nullptr, nullptr);
+}
+
+ZGUI_API ImFont* zguiIoAddFontFromMemoryWithConfig(
+    void* font_data,
+    int font_size,
+    float size_pixels,
+    const ImFontConfig* config,
+    const ImWchar* ranges
+) {
+    return ImGui::GetIO().Fonts->AddFontFromMemoryTTF(font_data, font_size, size_pixels, config, ranges);
+}
+
+ZGUI_API ImFont* zguiIoAddFontFromMemory(void* font_data, int font_size, float size_pixels) {
+    ImFontConfig config = ImFontConfig();
+    config.FontDataOwnedByAtlas = false;
+    return ImGui::GetIO().Fonts->AddFontFromMemoryTTF(font_data, font_size, size_pixels, &config, nullptr);
+}
+
+ZGUI_API ImFontConfig zguiFontConfig_Init(void) {
+    return ImFontConfig();
+}
+
+ZGUI_API ImFont* zguiIoGetFont(unsigned int index) {
+    return ImGui::GetIO().Fonts->Fonts[index];
+}
+
+ZGUI_API void zguiIoSetDefaultFont(ImFont* font) {
+    ImGui::GetIO().FontDefault = font;
+}
+
+ZGUI_API unsigned char *zguiIoGetFontsTexDataAsRgba32(int *width, int *height) {
+    unsigned char *font_pixels;
+    int font_width, font_height;
+    ImGui::GetIO().Fonts->GetTexDataAsRGBA32(&font_pixels, &font_width, &font_height);
+    *width = font_width;
+    *height = font_height;
+    return font_pixels;
+}
+
+ZGUI_API void zguiIoSetFontsTexId(ImTextureID id) {
+    ImGui::GetIO().Fonts->TexID = id;
+}
+
+ZGUI_API ImTextureID zguiIoGetFontsTexId(void) {
+    return ImGui::GetIO().Fonts->TexID;
+}
+
+ZGUI_API void zguiIoSetConfigWindowsMoveFromTitleBarOnly(bool enabled) {
+    ImGui::GetIO().ConfigWindowsMoveFromTitleBarOnly = enabled;
+}
+
+ZGUI_API bool zguiIoGetWantCaptureMouse(void) {
+    return ImGui::GetIO().WantCaptureMouse;
+}
+
+ZGUI_API bool zguiIoGetWantCaptureKeyboard(void) {
+    return ImGui::GetIO().WantCaptureKeyboard;
+}
+
+ZGUI_API bool zguiIoGetWantTextInput(void) {
+    return ImGui::GetIO().WantTextInput;
+}
+
+ZGUI_API void zguiIoSetIniFilename(const char* filename) {
+    ImGui::GetIO().IniFilename = filename;
+}
+
+ZGUI_API void zguiIoSetConfigFlags(ImGuiConfigFlags flags) {
+    ImGui::GetIO().ConfigFlags = flags;
+}
+
+ZGUI_API void zguiIoSetDisplaySize(float width, float height) {
+    ImGui::GetIO().DisplaySize = { width, height };
+}
+
+ZGUI_API void zguiIoGetDisplaySize(float size[2]) {
+    const ImVec2 ds = ImGui::GetIO().DisplaySize;
+    size[0] = ds[0];
+    size[1] = ds[1];
+}
+
+ZGUI_API void zguiIoSetDisplayFramebufferScale(float sx, float sy) {
+    ImGui::GetIO().DisplayFramebufferScale = { sx, sy };
+}
+
+ZGUI_API void zguiIoSetDeltaTime(float delta_time) {
+    ImGui::GetIO().DeltaTime = delta_time;
+}
+
+ZGUI_API void zguiIoAddFocusEvent(bool focused) {
+    ImGui::GetIO().AddFocusEvent(focused);
+}
+
+ZGUI_API void zguiIoAddMousePositionEvent(float x, float y) {
+    ImGui::GetIO().AddMousePosEvent(x, y);
+}
+
+ZGUI_API void zguiIoAddMouseButtonEvent(ImGuiMouseButton button, bool down) {
+    ImGui::GetIO().AddMouseButtonEvent(button, down);
+}
+
+ZGUI_API void zguiIoAddMouseWheelEvent(float x, float y) {
+    ImGui::GetIO().AddMouseWheelEvent(x, y);
+}
+
+ZGUI_API void zguiIoAddKeyEvent(ImGuiKey key, bool down) {
+    ImGui::GetIO().AddKeyEvent(key, down);
+}
+
+ZGUI_API void zguiIoAddInputCharactersUTF8(const char* utf8_chars) {
+    ImGui::GetIO().AddInputCharactersUTF8(utf8_chars);
+}
+
+ZGUI_API void zguiIoSetKeyEventNativeData(ImGuiKey key, int keycode, int scancode) {
+    ImGui::GetIO().SetKeyEventNativeData(key, keycode, scancode);
+}
+
+ZGUI_API void zguiIoAddCharacterEvent(unsigned int c) {
+    ImGui::GetIO().AddInputCharacter(c);
+}
+
+
+ZGUI_API bool zguiIsItemHovered(ImGuiHoveredFlags flags) {
+    return ImGui::IsItemHovered(flags);
+}
+
+ZGUI_API bool zguiIsItemActive(void) {
+    return ImGui::IsItemActive();
+}
+
+ZGUI_API bool zguiIsItemFocused(void) {
+    return ImGui::IsItemFocused();
+}
+
+ZGUI_API bool zguiIsItemClicked(ImGuiMouseButton mouse_button) {
+    return ImGui::IsItemClicked(mouse_button);
+}
+
+ZGUI_API bool zguiIsMouseDown(ImGuiMouseButton button) {
+    return ImGui::IsMouseDown(button);
+}
+
+ZGUI_API bool zguiIsMouseClicked(ImGuiMouseButton button) {
+    return ImGui::IsMouseClicked(button);
+}
+
+ZGUI_API bool zguiIsMouseDoubleClicked(ImGuiMouseButton button) {
+    return ImGui::IsMouseDoubleClicked(button);
+}
+
+ZGUI_API bool zguiIsItemVisible(void) {
+    return ImGui::IsItemVisible();
+}
+
+ZGUI_API bool zguiIsItemEdited(void) {
+    return ImGui::IsItemEdited();
+}
+
+ZGUI_API bool zguiIsItemActivated(void) {
+    return ImGui::IsItemActivated();
+}
+
+ZGUI_API bool zguiIsItemDeactivated(void) {
+    return ImGui::IsItemDeactivated();
+}
+
+ZGUI_API bool zguiIsItemDeactivatedAfterEdit(void) {
+    return ImGui::IsItemDeactivatedAfterEdit();
+}
+
+ZGUI_API bool zguiIsItemToggledOpen(void) {
+    return ImGui::IsItemToggledOpen();
+}
+
+ZGUI_API bool zguiIsAnyItemHovered(void) {
+    return ImGui::IsAnyItemHovered();
+}
+
+ZGUI_API bool zguiIsAnyItemActive(void) {
+    return ImGui::IsAnyItemActive();
+}
+
+ZGUI_API bool zguiIsAnyItemFocused(void) {
+    return ImGui::IsAnyItemFocused();
+}
+
+ZGUI_API void zguiGetContentRegionAvail(float pos[2]) {
+    const ImVec2 p = ImGui::GetContentRegionAvail();
+    pos[0] = p.x;
+    pos[1] = p.y;
+}
+
+ZGUI_API void zguiGetContentRegionMax(float pos[2]) {
+    const ImVec2 p = ImGui::GetContentRegionMax();
+    pos[0] = p.x;
+    pos[1] = p.y;
+}
+
+ZGUI_API void zguiGetWindowContentRegionMin(float pos[2]) {
+    const ImVec2 p = ImGui::GetWindowContentRegionMin();
+    pos[0] = p.x;
+    pos[1] = p.y;
+}
+
+ZGUI_API void zguiGetWindowContentRegionMax(float pos[2]) {
+    const ImVec2 p = ImGui::GetWindowContentRegionMax();
+    pos[0] = p.x;
+    pos[1] = p.y;
+}
+
+ZGUI_API void zguiPushTextWrapPos(float wrap_pos_x) {
+    ImGui::PushTextWrapPos(wrap_pos_x);
+}
+
+ZGUI_API void zguiPopTextWrapPos(void) {
+    ImGui::PopTextWrapPos();
+}
+
+ZGUI_API bool zguiBeginTabBar(const char* string, ImGuiTabBarFlags flags) {
+    return ImGui::BeginTabBar(string, flags);
+}
+
+ZGUI_API bool zguiBeginTabItem(const char* string, bool* p_open, ImGuiTabItemFlags flags) {
+    return ImGui::BeginTabItem(string, p_open, flags);
+}
+
+ZGUI_API void zguiEndTabItem(void) {
+    ImGui::EndTabItem();
+}
+
+ZGUI_API void zguiEndTabBar(void) {
+    ImGui::EndTabBar();
+}
+
+ZGUI_API void zguiSetTabItemClosed(const char* tab_or_docked_window_label) {
+    ImGui::SetTabItemClosed(tab_or_docked_window_label);
+}
+
+ZGUI_API bool zguiBeginMenuBar(void) {
+    return ImGui::BeginMenuBar();
+}
+
+ZGUI_API void zguiEndMenuBar(void) {
+    ImGui::EndMenuBar();
+}
+
+ZGUI_API bool zguiBeginMainMenuBar(void) {
+    return ImGui::BeginMainMenuBar();
+}
+
+ZGUI_API void zguiEndMainMenuBar(void) {
+    ImGui::EndMainMenuBar();
+}
+
+ZGUI_API bool zguiBeginMenu(const char* label, bool enabled) {
+    return ImGui::BeginMenu(label, enabled);
+}
+
+ZGUI_API void zguiEndMenu(void) {
+    ImGui::EndMenu();
+}
+
+ZGUI_API bool zguiMenuItem(const char* label, const char* shortcut, bool selected, bool enabled) {
+    return ImGui::MenuItem(label, shortcut, selected, enabled);
+}
+
+ZGUI_API bool zguiMenuItemPtr(const char* label, const char* shortcut, bool* selected, bool enabled) {
+    return ImGui::MenuItem(label, shortcut, selected, enabled);
+}
+
+ZGUI_API bool zguiBeginTooltip(void) {
+    return ImGui::BeginTooltip();
+}
+
+ZGUI_API void zguiEndTooltip(void) {
+    ImGui::EndTooltip();
+}
+
+ZGUI_API bool zguiBeginPopup(const char* str_id, ImGuiWindowFlags flags){
+    return ImGui::BeginPopup(str_id, flags);
+}
+
+ZGUI_API bool zguiBeginPopupContextWindow(void) {
+    return ImGui::BeginPopupContextWindow();
+}
+
+ZGUI_API bool zguiBeginPopupContextItem(void) {
+    return ImGui::BeginPopupContextItem();
+}
+
+ZGUI_API bool zguiBeginPopupModal(const char* name, bool* p_open, ImGuiWindowFlags flags) {
+    return ImGui::BeginPopupModal(name, p_open, flags);
+}
+
+ZGUI_API void zguiEndPopup(void) {
+    ImGui::EndPopup();
+}
+
+ZGUI_API void zguiOpenPopup(const char* str_id, ImGuiPopupFlags popup_flags) {
+    ImGui::OpenPopup(str_id, popup_flags);
+}
+
+ZGUI_API void zguiCloseCurrentPopup(void) {
+    ImGui::CloseCurrentPopup();
+}
+//--------------------------------------------------------------------------------------------------
+//
+// Tables
+//
+//--------------------------------------------------------------------------------------------------
+ZGUI_API bool zguiBeginTable(
+    const char* str_id,
+    int column,
+    ImGuiTableFlags flags,
+    const float outer_size[2],
+    float inner_width
+) {
+    return ImGui::BeginTable(str_id, column, flags, { outer_size[0], outer_size[1] }, inner_width);
+}
+
+ZGUI_API void zguiEndTable(void) {
+    ImGui::EndTable();
+}
+
+ZGUI_API void zguiTableNextRow(ImGuiTableRowFlags row_flags, float min_row_height) {
+    ImGui::TableNextRow(row_flags, min_row_height);
+}
+
+ZGUI_API bool zguiTableNextColumn(void) {
+    return ImGui::TableNextColumn();
+}
+
+ZGUI_API bool zguiTableSetColumnIndex(int column_n) {
+    return ImGui::TableSetColumnIndex(column_n);
+}
+
+ZGUI_API void zguiTableSetupColumn(
+    const char* label,
+    ImGuiTableColumnFlags flags,
+    float init_width_or_height,
+    ImGuiID user_id
+) {
+    ImGui::TableSetupColumn(label, flags, init_width_or_height, user_id);
+}
+
+ZGUI_API void zguiTableSetupScrollFreeze(int cols, int rows) {
+    ImGui::TableSetupScrollFreeze(cols, rows);
+}
+
+ZGUI_API void zguiTableHeadersRow(void) {
+    ImGui::TableHeadersRow();
+}
+
+ZGUI_API void zguiTableHeader(const char* label) {
+    ImGui::TableHeader(label);
+}
+
+ZGUI_API ImGuiTableSortSpecs* zguiTableGetSortSpecs(void) {
+    return ImGui::TableGetSortSpecs();
+}
+
+ZGUI_API int zguiTableGetColumnCount(void) {
+    return ImGui::TableGetColumnCount();
+}
+
+ZGUI_API int zguiTableGetColumnIndex(void) {
+    return ImGui::TableGetColumnIndex();
+}
+
+ZGUI_API int zguiTableGetRowIndex(void) {
+    return ImGui::TableGetRowIndex();
+}
+
+ZGUI_API const char* zguiTableGetColumnName(int column_n) {
+    return ImGui::TableGetColumnName(column_n);
+}
+
+ZGUI_API ImGuiTableColumnFlags zguiTableGetColumnFlags(int column_n) {
+    return ImGui::TableGetColumnFlags(column_n);
+}
+
+ZGUI_API void zguiTableSetColumnEnabled(int column_n, bool v) {
+    ImGui::TableSetColumnEnabled(column_n, v);
+}
+
+ZGUI_API void zguiTableSetBgColor(ImGuiTableBgTarget target, ImU32 color, int column_n) {
+    ImGui::TableSetBgColor(target, color, column_n);
+}
+//--------------------------------------------------------------------------------------------------
+//
+// Color Utilities
+//
+//--------------------------------------------------------------------------------------------------
+ZGUI_API void zguiColorConvertU32ToFloat4(ImU32 in, float rgba[4]) {
+    const ImVec4 c = ImGui::ColorConvertU32ToFloat4(in);
+    rgba[0] = c.x;
+    rgba[1] = c.y;
+    rgba[2] = c.z;
+    rgba[3] = c.w;
+}
+
+ZGUI_API ImU32 zguiColorConvertFloat4ToU32(const float in[4]) {
+    return ImGui::ColorConvertFloat4ToU32({ in[0], in[1], in[2], in[3] });
+}
+
+ZGUI_API void zguiColorConvertRGBtoHSV(float r, float g, float b, float* out_h, float* out_s, float* out_v) {
+    return ImGui::ColorConvertRGBtoHSV(r, g, b, *out_h, *out_s, *out_v);
+}
+
+ZGUI_API void zguiColorConvertHSVtoRGB(float h, float s, float v, float* out_r, float* out_g, float* out_b) {
+    return ImGui::ColorConvertHSVtoRGB(h, s, v, *out_r, *out_g, *out_b);
+}
+//--------------------------------------------------------------------------------------------------
+//
+// Inputs Utilities: Keyboard
+//
+//--------------------------------------------------------------------------------------------------
+ZGUI_API bool zguiIsKeyDown(ImGuiKey key) {
+    return ImGui::IsKeyDown(key);
+}
+//--------------------------------------------------------------------------------------------------
+//
+// DrawList
+//
+//--------------------------------------------------------------------------------------------------
+ZGUI_API ImDrawList *zguiGetWindowDrawList(void) {
+    return ImGui::GetWindowDrawList();
+}
+
+ZGUI_API ImDrawList *zguiGetBackgroundDrawList(void) {
+    return ImGui::GetBackgroundDrawList();
+}
+
+ZGUI_API ImDrawList *zguiGetForegroundDrawList(void) {
+    return ImGui::GetForegroundDrawList();
+}
+
+ZGUI_API ImDrawList *zguiCreateDrawList(void) {
+    return IM_NEW(ImDrawList)(ImGui::GetDrawListSharedData());
+}
+
+ZGUI_API void zguiDestroyDrawList(ImDrawList *draw_list) {
+  IM_DELETE(draw_list);
+}
+
+ZGUI_API const char *zguiDrawList_GetOwnerName(ImDrawList *draw_list) {
+    return draw_list->_OwnerName;
+}
+
+ZGUI_API void zguiDrawList_ResetForNewFrame(ImDrawList *draw_list) {
+    draw_list->_ResetForNewFrame();
+}
+
+ZGUI_API void zguiDrawList_ClearFreeMemory(ImDrawList *draw_list) {
+    draw_list->_ClearFreeMemory();
+}
+
+ZGUI_API int zguiDrawList_GetVertexBufferLength(ImDrawList *draw_list) {
+    return draw_list->VtxBuffer.size();
+}
+ZGUI_API ImDrawVert *zguiDrawList_GetVertexBufferData(ImDrawList *draw_list) {
+    return draw_list->VtxBuffer.begin();
+}
+
+ZGUI_API int zguiDrawList_GetIndexBufferLength(ImDrawList *draw_list) {
+    return draw_list->IdxBuffer.size();
+}
+ZGUI_API ImDrawIdx *zguiDrawList_GetIndexBufferData(ImDrawList *draw_list) {
+    return draw_list->IdxBuffer.begin();
+}
+ZGUI_API unsigned int zguiDrawList_GetCurrentIndex(ImDrawList *draw_list) {
+    return draw_list->_VtxCurrentIdx;
+}
+
+ZGUI_API int zguiDrawList_GetCmdBufferLength(ImDrawList *draw_list) {
+    return draw_list->CmdBuffer.size();
+}
+ZGUI_API ImDrawCmd *zguiDrawList_GetCmdBufferData(ImDrawList *draw_list) {
+    return draw_list->CmdBuffer.begin();
+}
+
+ZGUI_API void zguiDrawList_SetFlags(ImDrawList *draw_list, ImDrawListFlags flags) {
+    draw_list->Flags = flags;
+}
+ZGUI_API ImDrawListFlags zguiDrawList_GetFlags(ImDrawList *draw_list) {
+    return draw_list->Flags;
+}
+
+ZGUI_API void zguiDrawList_PushClipRect(
+    ImDrawList* draw_list,
+    const float clip_rect_min[2],
+    const float clip_rect_max[2],
+    bool intersect_with_current_clip_rect
+) {
+    draw_list->PushClipRect(
+        { clip_rect_min[0], clip_rect_min[1] },
+        { clip_rect_max[0], clip_rect_max[1] },
+        intersect_with_current_clip_rect
+    );
+}
+
+ZGUI_API void zguiDrawList_PushClipRectFullScreen(ImDrawList* draw_list) {
+    draw_list->PushClipRectFullScreen();
+}
+
+ZGUI_API void zguiDrawList_PopClipRect(ImDrawList* draw_list) {
+    draw_list->PopClipRect();
+}
+
+ZGUI_API void zguiDrawList_PushTextureId(ImDrawList* draw_list, ImTextureID texture_id) {
+    draw_list->PushTextureID(texture_id);
+}
+
+ZGUI_API void zguiDrawList_PopTextureId(ImDrawList* draw_list) {
+    draw_list->PopTextureID();
+}
+
+ZGUI_API void zguiDrawList_GetClipRectMin(ImDrawList* draw_list, float clip_min[2]) {
+    const ImVec2 c = draw_list->GetClipRectMin();
+    clip_min[0] = c.x;
+    clip_min[1] = c.y;
+}
+
+ZGUI_API void zguiDrawList_GetClipRectMax(ImDrawList* draw_list, float clip_max[2]) {
+    const ImVec2 c = draw_list->GetClipRectMax();
+    clip_max[0] = c.x;
+    clip_max[1] = c.y;
+}
+
+ZGUI_API void zguiDrawList_AddLine(
+    ImDrawList* draw_list,
+    const float p1[2],
+    const float p2[2],
+    ImU32 col,
+    float thickness
+) {
+    draw_list->AddLine({ p1[0], p1[1] }, { p2[0], p2[1] }, col, thickness);
+}
+
+ZGUI_API void zguiDrawList_AddRect(
+    ImDrawList* draw_list,
+    const float pmin[2],
+    const float pmax[2],
+    ImU32 col,
+    float rounding,
+    ImDrawFlags flags,
+    float thickness
+) {
+    draw_list->AddRect({ pmin[0], pmin[1] }, { pmax[0], pmax[1] }, col, rounding, flags, thickness);
+}
+
+ZGUI_API void zguiDrawList_AddRectFilled(
+    ImDrawList* draw_list,
+    const float pmin[2],
+    const float pmax[2],
+    ImU32 col,
+    float rounding,
+    ImDrawFlags flags
+) {
+    draw_list->AddRectFilled({ pmin[0], pmin[1] }, { pmax[0], pmax[1] }, col, rounding, flags);
+}
+
+ZGUI_API void zguiDrawList_AddRectFilledMultiColor(
+    ImDrawList* draw_list,
+    const float pmin[2],
+    const float pmax[2],
+    ImU32 col_upr_left,
+    ImU32 col_upr_right,
+    ImU32 col_bot_right,
+    ImU32 col_bot_left
+) {
+    draw_list->AddRectFilledMultiColor(
+        { pmin[0], pmin[1] },
+        { pmax[0], pmax[1] },
+        col_upr_left,
+        col_upr_right,
+        col_bot_right,
+        col_bot_left
+    );
+}
+
+ZGUI_API void zguiDrawList_AddQuad(
+    ImDrawList* draw_list,
+    const float p1[2],
+    const float p2[2],
+    const float p3[2],
+    const float p4[2],
+    ImU32 col,
+    float thickness
+) {
+    draw_list->AddQuad({ p1[0], p1[1] }, { p2[0], p2[1] }, { p3[0], p3[1] }, { p4[0], p4[1] }, col, thickness);
+}
+
+ZGUI_API void zguiDrawList_AddQuadFilled(
+    ImDrawList* draw_list,
+    const float p1[2],
+    const float p2[2],
+    const float p3[2],
+    const float p4[2],
+    ImU32 col
+) {
+    draw_list->AddQuadFilled({ p1[0], p1[1] }, { p2[0], p2[1] }, { p3[0], p3[1] }, { p4[0], p4[1] }, col);
+}
+
+ZGUI_API void zguiDrawList_AddTriangle(
+    ImDrawList* draw_list,
+    const float p1[2],
+    const float p2[2],
+    const float p3[2],
+    ImU32 col,
+    float thickness
+) {
+    draw_list->AddTriangle({ p1[0], p1[1] }, { p2[0], p2[1] }, { p3[0], p3[1] }, col, thickness);
+}
+
+ZGUI_API void zguiDrawList_AddTriangleFilled(
+    ImDrawList* draw_list,
+    const float p1[2],
+    const float p2[2],
+    const float p3[2],
+    ImU32 col
+) {
+    draw_list->AddTriangleFilled({ p1[0], p1[1] }, { p2[0], p2[1] }, { p3[0], p3[1] }, col);
+}
+
+ZGUI_API void zguiDrawList_AddCircle(
+    ImDrawList* draw_list,
+    const float center[2],
+    float radius,
+    ImU32 col,
+    int num_segments,
+    float thickness
+) {
+    draw_list->AddCircle({ center[0], center[1] }, radius, col, num_segments, thickness);
+}
+
+ZGUI_API void zguiDrawList_AddCircleFilled(
+    ImDrawList* draw_list,
+    const float center[2],
+    float radius,
+    ImU32 col,
+    int num_segments
+) {
+    draw_list->AddCircleFilled({ center[0], center[1] }, radius, col, num_segments);
+}
+
+ZGUI_API void zguiDrawList_AddNgon(
+    ImDrawList* draw_list,
+    const float center[2],
+    float radius,
+    ImU32 col,
+    int num_segments,
+    float thickness
+) {
+    draw_list->AddNgon({ center[0], center[1] }, radius, col, num_segments, thickness);
+}
+
+ZGUI_API void zguiDrawList_AddNgonFilled(
+    ImDrawList* draw_list,
+    const float center[2],
+    float radius,
+    ImU32 col,
+    int num_segments
+) {
+    draw_list->AddNgonFilled({ center[0], center[1] }, radius, col, num_segments);
+}
+
+ZGUI_API void zguiDrawList_AddText(
+    ImDrawList* draw_list,
+    const float pos[2],
+    ImU32 col,
+    const char* text_begin,
+    const char* text_end
+) {
+    draw_list->AddText({ pos[0], pos[1] }, col, text_begin, text_end);
+}
+
+ZGUI_API void zguiDrawList_AddPolyline(
+    ImDrawList* draw_list,
+    const float points[][2],
+    int num_points,
+    ImU32 col,
+    ImDrawFlags flags,
+    float thickness
+) {
+    draw_list->AddPolyline((const ImVec2*)&points[0][0], num_points, col, flags, thickness);
+}
+
+ZGUI_API void zguiDrawList_AddConvexPolyFilled(
+    ImDrawList* draw_list,
+    const float points[][2],
+    int num_points,
+    ImU32 col
+) {
+    draw_list->AddConvexPolyFilled((const ImVec2*)&points[0][0], num_points, col);
+}
+
+ZGUI_API void zguiDrawList_AddBezierCubic(
+    ImDrawList* draw_list,
+    const float p1[2],
+    const float p2[2],
+    const float p3[2],
+    const float p4[2],
+    ImU32 col,
+    float thickness,
+    int num_segments
+) {
+    draw_list->AddBezierCubic(
+        { p1[0], p1[1] }, { p2[0], p2[1] }, { p3[0], p3[1] }, { p4[0], p4[1] }, col, thickness, num_segments
+    );
+}
+
+ZGUI_API void zguiDrawList_AddBezierQuadratic(
+    ImDrawList* draw_list,
+    const float p1[2],
+    const float p2[2],
+    const float p3[2],
+    ImU32 col,
+    float thickness,
+    int num_segments
+) {
+    draw_list->AddBezierQuadratic(
+        { p1[0], p1[1] }, { p2[0], p2[1] }, { p3[0], p3[1] }, col, thickness, num_segments
+    );
+}
+
+ZGUI_API void zguiDrawList_AddImage(
+    ImDrawList* draw_list,
+    ImTextureID user_texture_id,
+    const float pmin[2],
+    const float pmax[2],
+    const float uvmin[2],
+    const float uvmax[2],
+    ImU32 col
+) {
+    draw_list->AddImage(
+        user_texture_id,
+        { pmin[0], pmin[1] },
+        { pmax[0], pmax[1] },
+        { uvmin[0], uvmin[1] },
+        { uvmax[0], uvmax[1] },
+        col
+    );
+}
+
+ZGUI_API void zguiDrawList_AddImageQuad(
+    ImDrawList* draw_list,
+    ImTextureID user_texture_id,
+    const float p1[2],
+    const float p2[2],
+    const float p3[2],
+    const float p4[2],
+    const float uv1[2],
+    const float uv2[2],
+    const float uv3[2],
+    const float uv4[2],
+    ImU32 col
+) {
+    draw_list->AddImageQuad(
+        user_texture_id,
+        { p1[0], p1[1] },
+        { p2[0], p2[1] },
+        { p3[0], p3[1] },
+        { p4[0], p4[1] },
+        { uv1[0], uv1[1] },
+        { uv2[0], uv2[1] },
+        { uv3[0], uv3[1] },
+        { uv4[0], uv4[1] },
+        col
+    );
+}
+
+ZGUI_API void zguiDrawList_AddImageRounded(
+    ImDrawList* draw_list,
+    ImTextureID user_texture_id,
+    const float pmin[2],
+    const float pmax[2],
+    const float uvmin[2],
+    const float uvmax[2],
+    ImU32 col,
+    float rounding,
+    ImDrawFlags flags
+) {
+    draw_list->AddImageRounded(
+        user_texture_id,
+        { pmin[0], pmin[1] },
+        { pmax[0], pmax[1] },
+        { uvmin[0], uvmin[1] },
+        { uvmax[0], uvmax[1] },
+        col,
+        rounding,
+        flags
+    );
+}
+
+ZGUI_API void zguiDrawList_PathClear(ImDrawList* draw_list) {
+    draw_list->PathClear();
+}
+
+ZGUI_API void zguiDrawList_PathLineTo(ImDrawList* draw_list, const float pos[2]) {
+    draw_list->PathLineTo({ pos[0], pos[1] });
+}
+
+ZGUI_API void zguiDrawList_PathLineToMergeDuplicate(ImDrawList* draw_list, const float pos[2]) {
+    draw_list->PathLineToMergeDuplicate({ pos[0], pos[1] });
+}
+
+ZGUI_API void zguiDrawList_PathFillConvex(ImDrawList* draw_list, ImU32 col) {
+    draw_list->PathFillConvex(col);
+}
+
+ZGUI_API void zguiDrawList_PathStroke(ImDrawList* draw_list, ImU32 col, ImDrawFlags flags, float thickness) {
+    draw_list->PathStroke(col, flags, thickness);
+}
+
+ZGUI_API void zguiDrawList_PathArcTo(
+    ImDrawList* draw_list,
+    const float center[2],
+    float radius,
+    float a_min,
+    float a_max,
+    int num_segments
+) {
+    draw_list->PathArcTo({ center[0], center[1] }, radius, a_min, a_max, num_segments);
+}
+
+ZGUI_API void zguiDrawList_PathArcToFast(
+    ImDrawList* draw_list,
+    const float center[2],
+    float radius,
+    int a_min_of_12,
+    int a_max_of_12
+) {
+    draw_list->PathArcToFast({ center[0], center[1] }, radius, a_min_of_12, a_max_of_12);
+}
+
+ZGUI_API void zguiDrawList_PathBezierCubicCurveTo(
+    ImDrawList* draw_list,
+    const float p2[2],
+    const float p3[2],
+    const float p4[2],
+    int num_segments
+) {
+    draw_list->PathBezierCubicCurveTo({ p2[0], p2[1] }, { p3[0], p3[1] }, { p4[0], p4[1] }, num_segments);
+}
+
+ZGUI_API void zguiDrawList_PathBezierQuadraticCurveTo(
+    ImDrawList* draw_list,
+    const float p2[2],
+    const float p3[2],
+    int num_segments
+) {
+    draw_list->PathBezierQuadraticCurveTo({ p2[0], p2[1] }, { p3[0], p3[1] }, num_segments);
+}
+
+ZGUI_API void zguiDrawList_PathRect(
+    ImDrawList* draw_list,
+    const float rect_min[2],
+    const float rect_max[2],
+    float rounding,
+    ImDrawFlags flags
+) {
+    draw_list->PathRect({ rect_min[0], rect_min[1] }, { rect_max[0], rect_max[1] }, rounding, flags);
+}
+
+ZGUI_API void zguiDrawList_PrimReserve( ImDrawList* draw_list, int idx_count, int vtx_count) {
+    draw_list->PrimReserve(idx_count, vtx_count);
+}
+
+ZGUI_API void zguiDrawList_PrimUnreserve( ImDrawList* draw_list, int idx_count, int vtx_count) {
+    draw_list->PrimUnreserve(idx_count, vtx_count);
+}
+
+ZGUI_API void zguiDrawList_PrimRect(
+    ImDrawList* draw_list,
+    const float a[2],
+    const float b[2],
+    ImU32 col
+) {
+    draw_list->PrimRect({ a[0], a[1] }, { b[0], b[1] }, col);
+}
+
+ZGUI_API void zguiDrawList_PrimRectUV(
+    ImDrawList* draw_list,
+    const float a[2],
+    const float b[2],
+    const float uv_a[2],
+    const float uv_b[2],
+    ImU32 col
+) {
+    draw_list->PrimRectUV({ a[0], a[1] }, { b[0], b[1] }, { uv_a[0], uv_a[1] }, { uv_b[0], uv_b[1] }, col);
+}
+
+ZGUI_API void zguiDrawList_PrimQuadUV(
+    ImDrawList* draw_list,
+    const float a[2],
+    const float b[2],
+    const float c[2],
+    const float d[2],
+    const float uv_a[2],
+    const float uv_b[2],
+    const float uv_c[2],
+    const float uv_d[2],
+    ImU32 col
+) {
+    draw_list->PrimQuadUV(
+        { a[0], a[1] }, { b[0], b[1] }, { c[0], c[1] }, { d[0], d[1] },
+        { uv_a[0], uv_a[1] }, { uv_b[0], uv_b[1] }, { uv_c[0], uv_c[1] }, { uv_d[0], uv_d[1] },
+        col
+    );
+}
+
+ZGUI_API void zguiDrawList_PrimWriteVtx(
+    ImDrawList* draw_list,
+    const float pos[2],
+    const float uv[2],
+    ImU32 col
+) {
+    draw_list->PrimWriteVtx({ pos[0], pos[1] }, { uv[0], uv[1] }, col);
+}
+
+ZGUI_API void zguiDrawList_PrimWriteIdx( ImDrawList* draw_list, ImDrawIdx idx) {
+    draw_list->PrimWriteIdx(idx);
+}
+
+ZGUI_API void zguiDrawList_AddCallback(ImDrawList* draw_list, ImDrawCallback callback, void* callback_data) {
+    draw_list->AddCallback(callback, callback_data);
+}
+
+ZGUI_API void zguiDrawList_AddResetRenderStateCallback(ImDrawList* draw_list) {
+    draw_list->AddCallback(ImDrawCallback_ResetRenderState, NULL);
+}
+//--------------------------------------------------------------------------------------------------
+//
+// Viewport
+//
+//--------------------------------------------------------------------------------------------------
+ZGUI_API ImGuiViewport* zguiGetMainViewport(void) {
+    return ImGui::GetMainViewport();
+}
+
+ZGUI_API void zguiViewport_GetPos(ImGuiViewport* viewport, float p[2]) {
+    const ImVec2 pos = viewport->Pos;
+    p[0] = pos.x;
+    p[1] = pos.y;
+}
+
+ZGUI_API void zguiViewport_GetSize(ImGuiViewport* viewport, float p[2]) {
+    const ImVec2 sz = viewport->Size;
+    p[0] = sz.x;
+    p[1] = sz.y;
+}
+
+ZGUI_API void zguiViewport_GetWorkPos(ImGuiViewport* viewport, float p[2]) {
+    const ImVec2 pos = viewport->WorkPos;
+    p[0] = pos.x;
+    p[1] = pos.y;
+}
+
+ZGUI_API void zguiViewport_GetWorkSize(ImGuiViewport* viewport, float p[2]) {
+    const ImVec2 sz = viewport->WorkSize;
+    p[0] = sz.x;
+    p[1] = sz.y;
+}
+
+//--------------------------------------------------------------------------------------------------
+//
+// Docking
+//
+//--------------------------------------------------------------------------------------------------
+ZGUI_API ImGuiID zguiDockSpace(const char* str_id, float size[2], ImGuiDockNodeFlags flags) {
+    return ImGui::DockSpace(ImGui::GetID(str_id), {size[0], size[1]}, flags);
+}
+
+ZGUI_API ImGuiID zguiDockSpaceOverViewport(const ImGuiViewport* viewport, ImGuiDockNodeFlags dockspace_flags) {
+    return ImGui::DockSpaceOverViewport(viewport, dockspace_flags);
+}
+
+
+//--------------------------------------------------------------------------------------------------
+//
+// DockBuilder (Unstable internal imgui API, subject to change, use at own risk)
+//
+//--------------------------------------------------------------------------------------------------
+ZGUI_API void zguiDockBuilderDockWindow(const char* window_name, ImGuiID node_id) {
+    ImGui::DockBuilderDockWindow(window_name, node_id);
+}
+
+ZGUI_API ImGuiID zguiDockBuilderAddNode(ImGuiID node_id, ImGuiDockNodeFlags flags) {
+    return ImGui::DockBuilderAddNode(node_id, flags);
+}
+
+ZGUI_API void zguiDockBuilderRemoveNode(ImGuiID node_id) {
+    ImGui::DockBuilderRemoveNode(node_id);
+}
+
+ZGUI_API void zguiDockBuilderSetNodePos(ImGuiID node_id, float pos[2]) {
+    ImGui::DockBuilderSetNodePos(node_id, {pos[0], pos[1]});
+}
+
+ZGUI_API void zguiDockBuilderSetNodeSize(ImGuiID node_id, float size[2]) {
+    ImGui::DockBuilderSetNodeSize(node_id, {size[0], size[1]});
+}
+
+ZGUI_API ImGuiID zguiDockBuilderSplitNode(
+    ImGuiID node_id,
+    ImGuiDir split_dir,
+    float size_ratio_for_node_at_dir,
+    ImGuiID* out_id_at_dir,
+    ImGuiID* out_id_at_opposite_dir
+) {
+    return ImGui::DockBuilderSplitNode(
+        node_id,
+        split_dir,
+        size_ratio_for_node_at_dir,
+        out_id_at_dir,
+        out_id_at_opposite_dir
+    );
+}
+
+ZGUI_API void zguiDockBuilderFinish(ImGuiID node_id) {
+    ImGui::DockBuilderFinish(node_id);
+}
+
+
+#if ZGUI_IMPLOT
+//--------------------------------------------------------------------------------------------------
+//
+// ImPlot
+//
+//--------------------------------------------------------------------------------------------------
+ZGUI_API ImPlotContext* zguiPlot_CreateContext(void) {
+    return ImPlot::CreateContext();
+}
+
+ZGUI_API void zguiPlot_DestroyContext(ImPlotContext* ctx) {
+    ImPlot::DestroyContext(ctx);
+}
+
+ZGUI_API ImPlotContext* zguiPlot_GetCurrentContext(void) {
+    return ImPlot::GetCurrentContext();
+}
+
+ZGUI_API ImPlotStyle zguiPlotStyle_Init(void) {
+    return ImPlotStyle();
+}
+
+ZGUI_API ImPlotStyle* zguiPlot_GetStyle(void) {
+    return &ImPlot::GetStyle();
+}
+
+ZGUI_API void zguiPlot_PushStyleColor4f(ImPlotCol idx, const float col[4]) {
+    ImPlot::PushStyleColor(idx, { col[0], col[1], col[2], col[3] });
+}
+
+ZGUI_API void zguiPlot_PushStyleColor1u(ImPlotCol idx, ImU32 col) {
+    ImPlot::PushStyleColor(idx, col);
+}
+
+ZGUI_API void zguiPlot_PopStyleColor(int count) {
+    ImPlot::PopStyleColor(count);
+}
+
+ZGUI_API void zguiPlot_PushStyleVar1i(ImPlotStyleVar idx, int var) {
+    ImPlot::PushStyleVar(idx, var);
+}
+
+ZGUI_API void zguiPlot_PushStyleVar1f(ImPlotStyleVar idx, float var) {
+    ImPlot::PushStyleVar(idx, var);
+}
+
+ZGUI_API void zguiPlot_PushStyleVar2f(ImPlotStyleVar idx, const float var[2]) {
+    ImPlot::PushStyleVar(idx, { var[0], var[1] });
+}
+
+ZGUI_API void zguiPlot_PopStyleVar(int count) {
+    ImPlot::PopStyleVar(count);
+}
+
+ZGUI_API void zguiPlot_SetupLegend(ImPlotLocation location, ImPlotLegendFlags flags) {
+    ImPlot::SetupLegend(location, flags);
+}
+
+ZGUI_API void zguiPlot_SetupAxis(ImAxis axis, const char* label, ImPlotAxisFlags flags) {
+    ImPlot::SetupAxis(axis, label, flags);
+}
+
+ZGUI_API void zguiPlot_SetupAxisLimits(ImAxis axis, double v_min, double v_max, ImPlotCond cond) {
+    ImPlot::SetupAxisLimits(axis, v_min, v_max, cond);
+}
+
+ZGUI_API void zguiPlot_SetupFinish(void) {
+    ImPlot::SetupFinish();
+}
+
+ZGUI_API bool zguiPlot_BeginPlot(const char* title_id, float width, float height, ImPlotFlags flags) {
+    return ImPlot::BeginPlot(title_id, { width, height }, flags);
+}
+
+ZGUI_API void zguiPlot_PlotLineValues(
+    const char* label_id,
+    ImGuiDataType data_type,
+    const void* values,
+    int count,
+    double xscale,
+    double x0,
+    ImPlotLineFlags flags,
+    int offset,
+    int stride
+) {
+    if (data_type == ImGuiDataType_S8)
+        ImPlot::PlotLine(label_id, (const ImS8*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U8)
+        ImPlot::PlotLine(label_id, (const ImU8*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_S16)
+        ImPlot::PlotLine(label_id, (const ImS16*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U16)
+        ImPlot::PlotLine(label_id, (const ImU16*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_S32)
+        ImPlot::PlotLine(label_id, (const ImS32*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U32)
+        ImPlot::PlotLine(label_id, (const ImU32*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_Float)
+        ImPlot::PlotLine(label_id, (const float*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_Double)
+        ImPlot::PlotLine(label_id, (const double*)values, count, xscale, x0, flags, offset, stride);
+    else
+        assert(false);
+}
+
+ZGUI_API void zguiPlot_PlotLine(
+    const char* label_id,
+    ImGuiDataType data_type,
+    const void* xv,
+    const void* yv,
+    int count,
+    ImPlotLineFlags flags,
+    int offset,
+    int stride
+) {
+    if (data_type == ImGuiDataType_S8)
+        ImPlot::PlotLine(label_id, (const ImS8*)xv, (const ImS8*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U8)
+        ImPlot::PlotLine(label_id, (const ImU8*)xv, (const ImU8*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_S16)
+        ImPlot::PlotLine(label_id, (const ImS16*)xv, (const ImS16*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U16)
+        ImPlot::PlotLine(label_id, (const ImU16*)xv, (const ImU16*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_S32)
+        ImPlot::PlotLine(label_id, (const ImS32*)xv, (const ImS32*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U32)
+        ImPlot::PlotLine(label_id, (const ImU32*)xv, (const ImU32*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_Float)
+        ImPlot::PlotLine(label_id, (const float*)xv, (const float*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_Double)
+        ImPlot::PlotLine(label_id, (const double*)xv, (const double*)yv, count, flags, offset, stride);
+    else
+        assert(false);
+}
+
+ZGUI_API void zguiPlot_PlotScatter(
+    const char* label_id,
+    ImGuiDataType data_type,
+    const void* xv,
+    const void* yv,
+    int count,
+    ImPlotScatterFlags flags,
+    int offset,
+    int stride
+) {
+    if (data_type == ImGuiDataType_S8)
+        ImPlot::PlotScatter(label_id, (const ImS8*)xv, (const ImS8*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U8)
+        ImPlot::PlotScatter(label_id, (const ImU8*)xv, (const ImU8*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_S16)
+        ImPlot::PlotScatter(label_id, (const ImS16*)xv, (const ImS16*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U16)
+        ImPlot::PlotScatter(label_id, (const ImU16*)xv, (const ImU16*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_S32)
+        ImPlot::PlotScatter(label_id, (const ImS32*)xv, (const ImS32*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U32)
+        ImPlot::PlotScatter(label_id, (const ImU32*)xv, (const ImU32*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_Float)
+        ImPlot::PlotScatter(label_id, (const float*)xv, (const float*)yv, count, flags, offset, stride);
+    else if (data_type == ImGuiDataType_Double)
+        ImPlot::PlotScatter(label_id, (const double*)xv, (const double*)yv, count, flags, offset, stride);
+    else
+        assert(false);
+}
+
+ZGUI_API void zguiPlot_PlotScatterValues(
+    const char* label_id,
+    ImGuiDataType data_type,
+    const void* values,
+    int count,
+    double xscale,
+    double x0,
+    ImPlotScatterFlags flags,
+    int offset,
+    int stride
+) {
+    if (data_type == ImGuiDataType_S8)
+        ImPlot::PlotScatter(label_id, (const ImS8*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U8)
+        ImPlot::PlotScatter(label_id, (const ImU8*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_S16)
+        ImPlot::PlotScatter(label_id, (const ImS16*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U16)
+        ImPlot::PlotScatter(label_id, (const ImU16*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_S32)
+        ImPlot::PlotScatter(label_id, (const ImS32*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U32)
+        ImPlot::PlotScatter(label_id, (const ImU32*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_Float)
+        ImPlot::PlotScatter(label_id, (const float*)values, count, xscale, x0, flags, offset, stride);
+    else if (data_type == ImGuiDataType_Double)
+        ImPlot::PlotScatter(label_id, (const double*)values, count, xscale, x0, flags, offset, stride);
+    else
+        assert(false);
+}
+
+ZGUI_API void zguiPlot_PlotShaded(
+    const char* label_id,
+    ImGuiDataType data_type,
+    const void* xv,
+    const void* yv,
+    int count,
+    double yref,
+    ImPlotShadedFlags flags,
+    int offset,
+    int stride
+) {
+    if (data_type == ImGuiDataType_S8)
+        ImPlot::PlotShaded(label_id, (const ImS8*)xv, (const ImS8*)yv, count, yref, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U8)
+        ImPlot::PlotShaded(label_id, (const ImU8*)xv, (const ImU8*)yv, count, yref, flags, offset, stride);
+    else if (data_type == ImGuiDataType_S16)
+        ImPlot::PlotShaded(label_id, (const ImS16*)xv, (const ImS16*)yv, count, yref, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U16)
+        ImPlot::PlotShaded(label_id, (const ImU16*)xv, (const ImU16*)yv, count, yref, flags, offset, stride);
+    else if (data_type == ImGuiDataType_S32)
+        ImPlot::PlotShaded(label_id, (const ImS32*)xv, (const ImS32*)yv, count, yref, flags, offset, stride);
+    else if (data_type == ImGuiDataType_U32)
+        ImPlot::PlotShaded(label_id, (const ImU32*)xv, (const ImU32*)yv, count, yref, flags, offset, stride);
+    else if (data_type == ImGuiDataType_Float)
+        ImPlot::PlotShaded(label_id, (const float*)xv, (const float*)yv, count, yref, flags, offset, stride);
+    else if (data_type == ImGuiDataType_Double)
+        ImPlot::PlotShaded(label_id, (const double*)xv, (const double*)yv, count, yref, flags, offset, stride);
+    else
+        assert(false);
+}
+
+ZGUI_API void zguiPlot_ShowDemoWindow(bool* p_open) {
+    ImPlot::ShowDemoWindow(p_open);
+}
+
+ZGUI_API void zguiPlot_EndPlot(void) {
+    ImPlot::EndPlot();
+}
+ZGUI_API bool zguiPlot_DragPoint(
+        int id,
+        double* x,
+        double* y,
+        float col[4],
+        float size,
+        ImPlotDragToolFlags flags
+) {
+    return ImPlot::DragPoint(
+        id,
+        x,
+        y,
+        (*(const ImVec4*)&(col[0])),
+        size,
+        flags
+    );
+}
+
+ZGUI_API void zguiPlot_PlotText(
+        const char* text,
+        double x, double y,
+        const float pix_offset[2],
+        ImPlotTextFlags flags=0
+) {
+    const ImVec2 p(pix_offset[0], pix_offset[1]);
+    ImPlot::PlotText(text, x, y, p, flags);
+}
+#endif /* #ifdef ZGUI_IMPLOT */
+
+//--------------------------------------------------------------------------------------------------
+} /* extern "C" */
+
+
+#if ZGUI_TE
+//--------------------------------------------------------------------------------------------------
+//
+// ImGUI Test Engine
+//
+//--------------------------------------------------------------------------------------------------
+extern "C"
+{
+
+    ZGUI_API void *zguiTe_CreateContext(void)
+    {
+        ImGuiTestEngine *e = ImGuiTestEngine_CreateContext();
+
+        ImGuiTestEngine_Start(e, ImGui::GetCurrentContext());
+        ImGuiTestEngine_InstallDefaultCrashHandler();
+
+        return e;
+    }
+
+    ZGUI_API void zguiTe_DestroyContext(ImGuiTestEngine *engine)
+    {
+        ImGuiTestEngine_DestroyContext(engine);
+    }
+
+    ZGUI_API void zguiTe_EngineSetRunSpeed(ImGuiTestEngine *engine, ImGuiTestRunSpeed speed)
+    {
+        ImGuiTestEngine_GetIO(engine).ConfigRunSpeed = speed;
+    }
+
+    ZGUI_API void zguiTe_EngineExportJunitResult(ImGuiTestEngine *engine, const char *filename)
+    {
+        ImGuiTestEngine_GetIO(engine).ExportResultsFilename = filename;
+        ImGuiTestEngine_GetIO(engine).ExportResultsFormat = ImGuiTestEngineExportFormat_JUnitXml;
+    }
+
+    ZGUI_API void zguiTe_TryAbortEngine(ImGuiTestEngine *engine)
+    {
+        ImGuiTestEngine_TryAbortEngine(engine);
+    }
+
+    ZGUI_API void zguiTe_Stop(ImGuiTestEngine *engine)
+    {
+        ImGuiTestEngine_Stop(engine);
+    }
+
+    ZGUI_API void zguiTe_PostSwap(ImGuiTestEngine *engine)
+    {
+        ImGuiTestEngine_PostSwap(engine);
+    }
+
+    ZGUI_API bool zguiTe_IsTestQueueEmpty(ImGuiTestEngine *engine)
+    {
+        return ImGuiTestEngine_IsTestQueueEmpty(engine);
+    }
+
+    ZGUI_API void zguiTe_GetResult(ImGuiTestEngine *engine, int *count_tested, int *count_success)
+    {
+        int ct = 0;
+        int cs = 0;
+        ImGuiTestEngine_GetResult(engine, ct, cs);
+        *count_tested = ct;
+        *count_success = cs;
+    }
+
+    ZGUI_API void zguiTe_PrintResultSummary(ImGuiTestEngine *engine)
+    {
+        ImGuiTestEngine_PrintResultSummary(engine);
+    }
+
+    ZGUI_API void zguiTe_QueueTests(ImGuiTestEngine *engine, ImGuiTestGroup group, const char *filter_str, ImGuiTestRunFlags run_flags)
+    {
+        ImGuiTestEngine_QueueTests(engine, group, filter_str, run_flags);
+    }
+
+    ZGUI_API void zguiTe_ShowTestEngineWindows(ImGuiTestEngine *engine, bool *p_open)
+    {
+        ImGuiTestEngine_ShowTestEngineWindows(engine, p_open);
+    }
+
+    ZGUI_API void *zguiTe_RegisterTest(ImGuiTestEngine *engine, const char *category, const char *name, const char *src_file, int src_line, ImGuiTestGuiFunc *gui_fce, ImGuiTestTestFunc *gui_test_fce)
+    {
+        auto t = ImGuiTestEngine_RegisterTest(engine, category, name, src_file, src_line);
+        t->GuiFunc = gui_fce;
+        t->TestFunc = gui_test_fce;
+        return t;
+    }
+
+    ZGUI_API bool zguiTe_Check(const char *file, const char *func, int line, ImGuiTestCheckFlags flags, bool result, const char *expr)
+    {
+        return ImGuiTestEngine_Check(file, func, line, flags, result, expr);
+    }
+
+    // CONTEXT
+
+    ZGUI_API void zguiTe_ContextSetRef(ImGuiTestContext *ctx, const char *ref)
+    {
+        ctx->SetRef(ref);
+    }
+
+    ZGUI_API void zguiTe_ContextWindowFocus(ImGuiTestContext *ctx, const char *ref)
+    {
+        ctx->WindowFocus(ref);
+    }
+
+    ZGUI_API void zguiTe_ContextItemAction(ImGuiTestContext *ctx, ImGuiTestAction action, const char *ref, ImGuiTestOpFlags flags = 0, void *action_arg = NULL)
+    {
+        ctx->ItemAction(action, ref, flags, action_arg);
+    }
+
+    ZGUI_API void zguiTe_ContextItemInputStrValue(ImGuiTestContext *ctx, const char *ref, const char *value)
+    {
+        ctx->ItemInputValue(ref, value);
+    }
+
+    ZGUI_API void zguiTe_ContextItemInputIntValue(ImGuiTestContext *ctx, const char *ref, int value)
+    {
+        ctx->ItemInputValue(ref, value);
+    }
+
+    ZGUI_API void zguiTe_ContextItemInputFloatValue(ImGuiTestContext *ctx, const char *ref, float value)
+    {
+        ctx->ItemInputValue(ref, value);
+    }
+
+    ZGUI_API void zguiTe_ContextYield(ImGuiTestContext *ctx, int frame_count)
+    {
+        ctx->Yield(frame_count);
+    }
+
+    ZGUI_API void zguiTe_ContextMenuAction(ImGuiTestContext *ctx, ImGuiTestAction action, const char *ref)
+    {
+        ctx->MenuAction(action, ref);
+    }
+
+    ZGUI_API void zguiTe_ContextDragAndDrop(ImGuiTestContext *ctx, const char *ref_src, const char *ref_dst, ImGuiMouseButton button)
+    {
+        ctx->ItemDragAndDrop(ref_src, ref_dst, button);
+    }
+
+    ZGUI_API void zguiTe_ContextKeyDown(ImGuiTestContext *ctx, ImGuiKeyChord key_chord)
+    {
+        ctx->KeyDown(key_chord);
+    }
+
+    ZGUI_API void zguiTe_ContextKeyUp(ImGuiTestContext *ctx, ImGuiKeyChord key_chord)
+    {
+        ctx->KeyUp(key_chord);
+    }
+
+} /* extern "C" */
+#endif
-- 
cgit v1.2.3