Updating to zig 0.15.1

10 files changed, 0 insertions, 8437 deletions

diff --git a/vendor/zgui/src/backend_dx12.zig b/vendor/zgui/src/backend_dx12.zig
deleted file mode 100644
index 22672e7..0000000
--- a/vendor/zgui/src/backend_dx12.zig
+++ /dev/null
@@ -1,59 +0,0 @@
-pub const D3D12_CPU_DESCRIPTOR_HANDLE = extern struct {
-    ptr: c_ulonglong,
-};
-
-pub const D3D12_GPU_DESCRIPTOR_HANDLE = extern struct {
-    ptr: c_ulonglong,
-};
-
-pub fn init(
-    device: *const anyopaque, // ID3D12Device
-    num_frames_in_flight: u32,
-    rtv_format: c_uint, // DXGI_FORMAT
-    cbv_srv_heap: *const anyopaque, // ID3D12DescriptorHeap
-    font_srv_cpu_desc_handle: D3D12_CPU_DESCRIPTOR_HANDLE,
-    font_srv_gpu_desc_handle: D3D12_GPU_DESCRIPTOR_HANDLE,
-) void {
-    if (!ImGui_ImplDX12_Init(
-        device,
-        num_frames_in_flight,
-        rtv_format,
-        cbv_srv_heap,
-        font_srv_cpu_desc_handle,
-        font_srv_gpu_desc_handle,
-    )) {
-        @panic("failed to init d3d12 for imgui");
-    }
-}
-
-pub fn deinit() void {
-    ImGui_ImplDX12_Shutdown();
-}
-
-pub fn newFrame() void {
-    ImGui_ImplDX12_NewFrame();
-}
-
-pub fn render(
-    draw_data: *const anyopaque, // *gui.DrawData
-    gfx_command_list: *const anyopaque, // *ID3D12GraphicsCommandList
-) void {
-    ImGui_ImplDX12_RenderDrawData(draw_data, gfx_command_list);
-}
-
-// Those functions are defined in 'imgui_impl_dx12.cpp`
-// (they include few custom changes).
-extern fn ImGui_ImplDX12_Init(
-    device: *const anyopaque, // ID3D12Device
-    num_frames_in_flight: u32,
-    rtv_format: u32, // DXGI_FORMAT
-    cbv_srv_heap: *const anyopaque, // ID3D12DescriptorHeap
-    font_srv_cpu_desc_handle: D3D12_CPU_DESCRIPTOR_HANDLE,
-    font_srv_gpu_desc_handle: D3D12_GPU_DESCRIPTOR_HANDLE,
-) bool;
-extern fn ImGui_ImplDX12_Shutdown() void;
-extern fn ImGui_ImplDX12_NewFrame() void;
-extern fn ImGui_ImplDX12_RenderDrawData(
-    draw_data: *const anyopaque, // *ImDrawData
-    graphics_command_list: *const anyopaque, // *ID3D12GraphicsCommandList
-) void;
diff --git a/vendor/zgui/src/backend_glfw.zig b/vendor/zgui/src/backend_glfw.zig
deleted file mode 100644
index 83603fe..0000000
--- a/vendor/zgui/src/backend_glfw.zig
+++ /dev/null
@@ -1,35 +0,0 @@
-const gui = @import("gui.zig");
-
-// This call will install GLFW callbacks to handle GUI interactions.
-// Those callbacks will chain-call user's previously installed callbacks, if any.
-// This means that custom user's callbacks need to be installed *before* calling zgpu.gui.init().
-pub fn init(
-    window: *const anyopaque, // zglfw.Window
-) void {
-    if (!ImGui_ImplGlfw_InitForOther(window, true)) {
-        unreachable;
-    }
-}
-
-pub fn initOpenGL(
-    window: *const anyopaque, // zglfw.Window
-) void {
-    if (!ImGui_ImplGlfw_InitForOpenGL(window, true)) {
-        unreachable;
-    }
-}
-
-pub fn deinit() void {
-    ImGui_ImplGlfw_Shutdown();
-}
-
-pub fn newFrame() void {
-    ImGui_ImplGlfw_NewFrame();
-}
-
-// Those functions are defined in `imgui_impl_glfw.cpp`
-// (they include few custom changes).
-extern fn ImGui_ImplGlfw_InitForOther(window: *const anyopaque, install_callbacks: bool) bool;
-extern fn ImGui_ImplGlfw_InitForOpenGL(window: *const anyopaque, install_callbacks: bool) bool;
-extern fn ImGui_ImplGlfw_NewFrame() void;
-extern fn ImGui_ImplGlfw_Shutdown() void;
diff --git a/vendor/zgui/src/backend_glfw_dx12.zig b/vendor/zgui/src/backend_glfw_dx12.zig
deleted file mode 100644
index 48c63cb..0000000
--- a/vendor/zgui/src/backend_glfw_dx12.zig
+++ /dev/null
@@ -1,45 +0,0 @@
-const gui = @import("gui.zig");
-const backend_glfw = @import("backend_glfw.zig");
-const backend_dx12 = @import("backend_dx12.zig");
-
-pub fn init(
-    window: *const anyopaque, // zglfw.Window
-    device: *const anyopaque, // ID3D12Device
-    num_frames_in_flight: u32,
-    rtv_format: c_uint, // DXGI_FORMAT
-    cbv_srv_heap: *const anyopaque, // ID3D12DescriptorHeap
-    font_srv_cpu_desc_handle: backend_dx12.D3D12_CPU_DESCRIPTOR_HANDLE,
-    font_srv_gpu_desc_handle: backend_dx12.D3D12_GPU_DESCRIPTOR_HANDLE,
-) void {
-    backend_glfw.init(window);
-    backend_dx12.init(
-        device,
-        num_frames_in_flight,
-        rtv_format,
-        cbv_srv_heap,
-        font_srv_cpu_desc_handle,
-        font_srv_gpu_desc_handle,
-    );
-}
-
-pub fn deinit() void {
-    backend_dx12.deinit();
-    backend_glfw.deinit();
-}
-
-pub fn newFrame(fb_width: u32, fb_height: u32) void {
-    backend_glfw.newFrame();
-    backend_dx12.newFrame();
-
-    gui.io.setDisplaySize(@as(f32, @floatFromInt(fb_width)), @as(f32, @floatFromInt(fb_height)));
-    gui.io.setDisplayFramebufferScale(1.0, 1.0);
-
-    gui.newFrame();
-}
-
-pub fn draw(
-    graphics_command_list: *const anyopaque, // *ID3D12GraphicsCommandList
-) void {
-    gui.render();
-    backend_dx12.render(gui.getDrawData(), graphics_command_list);
-}
diff --git a/vendor/zgui/src/backend_glfw_opengl.zig b/vendor/zgui/src/backend_glfw_opengl.zig
deleted file mode 100644
index cb94dc3..0000000
--- a/vendor/zgui/src/backend_glfw_opengl.zig
+++ /dev/null
@@ -1,44 +0,0 @@
-const gui = @import("gui.zig");
-const backend_glfw = @import("backend_glfw.zig");
-
-pub fn initWithGlSlVersion(
-    window: *const anyopaque, // zglfw.Window
-    glsl_version: ?[:0]const u8, // e.g. "#version 130"
-) void {
-    backend_glfw.initOpenGL(window);
-
-    ImGui_ImplOpenGL3_Init(@ptrCast(glsl_version));
-}
-
-pub fn init(
-    window: *const anyopaque, // zglfw.Window
-) void {
-    initWithGlSlVersion(window, null);
-}
-
-pub fn deinit() void {
-    ImGui_ImplOpenGL3_Shutdown();
-    backend_glfw.deinit();
-}
-
-pub fn newFrame(fb_width: u32, fb_height: u32) void {
-    backend_glfw.newFrame();
-    ImGui_ImplOpenGL3_NewFrame();
-
-    gui.io.setDisplaySize(@as(f32, @floatFromInt(fb_width)), @as(f32, @floatFromInt(fb_height)));
-    gui.io.setDisplayFramebufferScale(1.0, 1.0);
-
-    gui.newFrame();
-}
-
-pub fn draw() void {
-    gui.render();
-    ImGui_ImplOpenGL3_RenderDrawData(gui.getDrawData());
-}
-
-// Those functions are defined in 'imgui_impl_opengl3.cpp`
-// (they include few custom changes).
-extern fn ImGui_ImplOpenGL3_Init(glsl_version: [*c]const u8) void;
-extern fn ImGui_ImplOpenGL3_Shutdown() void;
-extern fn ImGui_ImplOpenGL3_NewFrame() void;
-extern fn ImGui_ImplOpenGL3_RenderDrawData(data: *const anyopaque) void;
diff --git a/vendor/zgui/src/backend_glfw_wgpu.zig b/vendor/zgui/src/backend_glfw_wgpu.zig
deleted file mode 100644
index e6fa517..0000000
--- a/vendor/zgui/src/backend_glfw_wgpu.zig
+++ /dev/null
@@ -1,67 +0,0 @@
-const gui = @import("gui.zig");
-const backend_glfw = @import("backend_glfw.zig");
-
-// This call will install GLFW callbacks to handle GUI interactions.
-// Those callbacks will chain-call user's previously installed callbacks, if any.
-// This means that custom user's callbacks need to be installed *before* calling zgpu.gui.init().
-pub fn init(
-    window: *const anyopaque, // zglfw.Window
-    wgpu_device: *const anyopaque, // wgpu.Device
-    wgpu_swap_chain_format: u32, // wgpu.TextureFormat
-    wgpu_depth_format: u32, // wgpu.TextureFormat
-) void {
-    backend_glfw.init(window);
-
-    var info = ImGui_ImplWGPU_InitInfo{
-        .device = wgpu_device,
-        .num_frames_in_flight = 1,
-        .rt_format = wgpu_swap_chain_format,
-        .depth_format = wgpu_depth_format,
-        .pipeline_multisample_state = .{},
-    };
-
-    if (!ImGui_ImplWGPU_Init(&info)) {
-        unreachable;
-    }
-}
-
-pub fn deinit() void {
-    ImGui_ImplWGPU_Shutdown();
-    backend_glfw.deinit();
-}
-
-pub fn newFrame(fb_width: u32, fb_height: u32) void {
-    ImGui_ImplWGPU_NewFrame();
-    backend_glfw.newFrame();
-
-    gui.io.setDisplaySize(@floatFromInt(fb_width), @floatFromInt(fb_height));
-    gui.io.setDisplayFramebufferScale(1.0, 1.0);
-
-    gui.newFrame();
-}
-
-pub fn draw(wgpu_render_pass: *const anyopaque) void {
-    gui.render();
-    ImGui_ImplWGPU_RenderDrawData(gui.getDrawData(), wgpu_render_pass);
-}
-
-pub const ImGui_ImplWGPU_InitInfo = extern struct {
-    device: *const anyopaque,
-    num_frames_in_flight: u32 = 1,
-    rt_format: u32,
-    depth_format: u32,
-
-    pipeline_multisample_state: extern struct {
-        next_in_chain: ?*const anyopaque = null,
-        count: u32 = 1,
-        mask: u32 = @bitCast(@as(i32, -1)),
-        alpha_to_coverage_enabled: bool = false,
-    },
-};
-
-// Those functions are defined in 'imgui_impl_wgpu.cpp`
-// (they include few custom changes).
-extern fn ImGui_ImplWGPU_Init(init_info: *ImGui_ImplWGPU_InitInfo) bool;
-extern fn ImGui_ImplWGPU_NewFrame() void;
-extern fn ImGui_ImplWGPU_RenderDrawData(draw_data: *const anyopaque, pass_encoder: *const anyopaque) void;
-extern fn ImGui_ImplWGPU_Shutdown() void;
diff --git a/vendor/zgui/src/backend_win32_dx12.zig b/vendor/zgui/src/backend_win32_dx12.zig
deleted file mode 100644
index 2cc5bf9..0000000
--- a/vendor/zgui/src/backend_win32_dx12.zig
+++ /dev/null
@@ -1,48 +0,0 @@
-const std = @import("std");
-
-const gui = @import("gui.zig");
-const backend_dx12 = @import("backend_dx12.zig");
-
-pub fn init(
-    hwnd: *const anyopaque, // HWND
-    d3d12_device: *const anyopaque, // ID3D12Device*
-    num_frames_in_flight: u16,
-    rtv_format: u32, // DXGI_FORMAT
-    cbv_srv_heap: *const anyopaque, // ID3D12DescriptorHeap*
-    font_srv_cpu_desc_handle: backend_dx12.D3D12_CPU_DESCRIPTOR_HANDLE,
-    font_srv_gpu_desc_handle: backend_dx12.D3D12_GPU_DESCRIPTOR_HANDLE,
-) void {
-    std.debug.assert(ImGui_ImplWin32_Init(hwnd));
-    backend_dx12.init(
-        d3d12_device,
-        num_frames_in_flight,
-        rtv_format,
-        cbv_srv_heap,
-        font_srv_cpu_desc_handle,
-        font_srv_gpu_desc_handle,
-    );
-}
-
-pub fn deinit() void {
-    backend_dx12.deinit();
-    ImGui_ImplWin32_Shutdown();
-}
-
-pub fn newFrame(fb_width: u32, fb_height: u32) void {
-    ImGui_ImplWin32_NewFrame();
-    backend_dx12.newFrame();
-
-    gui.io.setDisplaySize(@as(f32, @floatFromInt(fb_width)), @as(f32, @floatFromInt(fb_height)));
-    gui.io.setDisplayFramebufferScale(1.0, 1.0);
-
-    gui.newFrame();
-}
-
-pub fn draw(graphics_command_list: *const anyopaque) void {
-    gui.render();
-    backend_dx12.render(gui.getDrawData(), graphics_command_list);
-}
-
-extern fn ImGui_ImplWin32_Init(hwnd: *const anyopaque) bool;
-extern fn ImGui_ImplWin32_Shutdown() void;
-extern fn ImGui_ImplWin32_NewFrame() void;
diff --git a/vendor/zgui/src/gui.zig b/vendor/zgui/src/gui.zig
deleted file mode 100644
index 4bb4eac..0000000
--- a/vendor/zgui/src/gui.zig
+++ /dev/null
@@ -1,4580 +0,0 @@
-//--------------------------------------------------------------------------------------------------
-//
-// Zig bindings for 'dear imgui' library. Easy to use, hand-crafted API with default arguments,
-// named parameters and Zig style text formatting.
-//
-//--------------------------------------------------------------------------------------------------
-pub const plot = @import("plot.zig");
-pub const te = @import("te.zig");
-pub const backend = switch (@import("zgui_options").backend) {
-    .glfw_wgpu => @import("backend_glfw_wgpu.zig"),
-    .glfw_opengl3 => @import("backend_glfw_opengl.zig"),
-    .glfw_dx12 => @import("backend_glfw_dx12.zig"),
-    .glfw => @import("backend_glfw.zig"),
-    .win32_dx12 => @import("backend_win32_dx12.zig"),
-    .no_backend => .{},
-};
-const te_enabled = @import("zgui_options").with_te;
-//--------------------------------------------------------------------------------------------------
-const std = @import("std");
-const assert = std.debug.assert;
-//--------------------------------------------------------------------------------------------------
-pub const f32_min: f32 = 1.17549435082228750796873653722225e-38;
-pub const f32_max: f32 = 3.40282346638528859811704183484517e+38;
-//--------------------------------------------------------------------------------------------------
-pub const DrawIdx = u16;
-pub const DrawVert = extern struct {
-    pos: [2]f32,
-    uv: [2]f32,
-    color: u32,
-};
-//--------------------------------------------------------------------------------------------------
-
-pub fn init(allocator: std.mem.Allocator) void {
-    if (zguiGetCurrentContext() == null) {
-        mem_allocator = allocator;
-        mem_allocations = std.AutoHashMap(usize, usize).init(allocator);
-        mem_allocations.?.ensureTotalCapacity(32) catch @panic("zgui: out of memory");
-        zguiSetAllocatorFunctions(zguiMemAlloc, zguiMemFree);
-
-        _ = zguiCreateContext(null);
-
-        temp_buffer = std.ArrayList(u8).init(allocator);
-        temp_buffer.?.resize(3 * 1024 + 1) catch unreachable;
-
-        if (te_enabled) {
-            te.init();
-        }
-    }
-}
-pub fn deinit() void {
-    if (zguiGetCurrentContext() != null) {
-        temp_buffer.?.deinit();
-        zguiDestroyContext(null);
-
-        // Must be after destroy imgui context.
-        // And before allocation check
-        if (te_enabled) {
-            te.deinit();
-        }
-
-        if (mem_allocations.?.count() > 0) {
-            var it = mem_allocations.?.iterator();
-            while (it.next()) |kv| {
-                const address = kv.key_ptr.*;
-                const size = kv.value_ptr.*;
-                mem_allocator.?.free(@as([*]align(mem_alignment) u8, @ptrFromInt(address))[0..size]);
-                std.log.info(
-                    "[zgui] Possible memory leak or static memory usage detected: (address: 0x{x}, size: {d})",
-                    .{ address, size },
-                );
-            }
-            mem_allocations.?.clearAndFree();
-        }
-
-        assert(mem_allocations.?.count() == 0);
-        mem_allocations.?.deinit();
-        mem_allocations = null;
-        mem_allocator = null;
-    }
-}
-pub fn initNoContext(allocator: std.mem.Allocator) void {
-    if (temp_buffer == null) {
-        temp_buffer = std.ArrayList(u8).init(allocator);
-        temp_buffer.?.resize(3 * 1024 + 1) catch unreachable;
-    }
-}
-pub fn deinitNoContext() void {
-    if (temp_buffer) |buf| {
-        buf.deinit();
-    }
-}
-extern fn zguiCreateContext(shared_font_atlas: ?*const anyopaque) Context;
-extern fn zguiDestroyContext(ctx: ?Context) void;
-extern fn zguiGetCurrentContext() ?Context;
-//--------------------------------------------------------------------------------------------------
-var mem_allocator: ?std.mem.Allocator = null;
-var mem_allocations: ?std.AutoHashMap(usize, usize) = null;
-var mem_mutex: std.Thread.Mutex = .{};
-const mem_alignment = 16;
-
-fn zguiMemAlloc(size: usize, _: ?*anyopaque) callconv(.C) ?*anyopaque {
-    mem_mutex.lock();
-    defer mem_mutex.unlock();
-
-    const mem = mem_allocator.?.alignedAlloc(
-        u8,
-        mem_alignment,
-        size,
-    ) catch @panic("zgui: out of memory");
-
-    mem_allocations.?.put(@intFromPtr(mem.ptr), size) catch @panic("zgui: out of memory");
-
-    return mem.ptr;
-}
-
-fn zguiMemFree(maybe_ptr: ?*anyopaque, _: ?*anyopaque) callconv(.C) void {
-    if (maybe_ptr) |ptr| {
-        mem_mutex.lock();
-        defer mem_mutex.unlock();
-
-        if (mem_allocations != null) {
-            const size = mem_allocations.?.fetchRemove(@intFromPtr(ptr)).?.value;
-            const mem = @as([*]align(mem_alignment) u8, @ptrCast(@alignCast(ptr)))[0..size];
-            mem_allocator.?.free(mem);
-        }
-    }
-}
-
-extern fn zguiSetAllocatorFunctions(
-    alloc_func: ?*const fn (usize, ?*anyopaque) callconv(.C) ?*anyopaque,
-    free_func: ?*const fn (?*anyopaque, ?*anyopaque) callconv(.C) void,
-) void;
-//--------------------------------------------------------------------------------------------------
-pub const ConfigFlags = packed struct(c_int) {
-    nav_enable_keyboard: bool = false,
-    nav_enable_gamepad: bool = false,
-    nav_enable_set_mouse_pos: bool = false,
-    nav_no_capture_keyboard: bool = false,
-    no_mouse: bool = false,
-    no_mouse_cursor_change: bool = false,
-    dock_enable: bool = false,
-    _pading0: u3 = 0,
-    viewport_enable: bool = false,
-    _pading1: u3 = 0,
-    dpi_enable_scale_viewport: bool = false,
-    dpi_enable_scale_fonts: bool = false,
-    user_storage: u4 = 0,
-    is_srgb: bool = false,
-    is_touch_screen: bool = false,
-    _padding: u10 = 0,
-};
-
-pub const FontConfig = extern struct {
-    font_data: ?*anyopaque,
-    font_data_size: c_int,
-    font_data_owned_by_atlas: bool,
-    font_no: c_int,
-    size_pixels: f32,
-    oversample_h: c_int,
-    oversample_v: c_int,
-    pixel_snap_h: bool,
-    glyph_extra_spacing: [2]f32,
-    glyph_offset: [2]f32,
-    glyph_ranges: [*c]u16,
-    glyph_min_advance_x: f32,
-    glyph_max_advance_x: f32,
-    merge_mode: bool,
-    font_builder_flags: c_uint,
-    rasterizer_multiply: f32,
-    rasterizer_density: f32,
-    ellipsis_char: Wchar,
-    name: [40]u8,
-    dst_font: *Font,
-
-    pub fn init() FontConfig {
-        return zguiFontConfig_Init();
-    }
-    extern fn zguiFontConfig_Init() FontConfig;
-};
-
-pub const io = struct {
-    pub fn addFontFromFile(filename: [:0]const u8, size_pixels: f32) Font {
-        return zguiIoAddFontFromFile(filename, size_pixels);
-    }
-    extern fn zguiIoAddFontFromFile(filename: [*:0]const u8, size_pixels: f32) Font;
-
-    pub fn addFontFromFileWithConfig(
-        filename: [:0]const u8,
-        size_pixels: f32,
-        config: ?FontConfig,
-        ranges: ?[*]const Wchar,
-    ) Font {
-        return zguiIoAddFontFromFileWithConfig(filename, size_pixels, if (config) |c| &c else null, ranges);
-    }
-    extern fn zguiIoAddFontFromFileWithConfig(
-        filename: [*:0]const u8,
-        size_pixels: f32,
-        config: ?*const FontConfig,
-        ranges: ?[*]const Wchar,
-    ) Font;
-
-    pub fn addFontFromMemory(fontdata: []const u8, size_pixels: f32) Font {
-        return zguiIoAddFontFromMemory(fontdata.ptr, @intCast(fontdata.len), size_pixels);
-    }
-    extern fn zguiIoAddFontFromMemory(font_data: *const anyopaque, font_size: c_int, size_pixels: f32) Font;
-
-    pub fn addFontFromMemoryWithConfig(
-        fontdata: []const u8,
-        size_pixels: f32,
-        config: ?FontConfig,
-        ranges: ?[*]const Wchar,
-    ) Font {
-        return zguiIoAddFontFromMemoryWithConfig(
-            fontdata.ptr,
-            @intCast(fontdata.len),
-            size_pixels,
-            if (config) |c| &c else null,
-            ranges,
-        );
-    }
-    extern fn zguiIoAddFontFromMemoryWithConfig(
-        font_data: *const anyopaque,
-        font_size: c_int,
-        size_pixels: f32,
-        config: ?*const FontConfig,
-        ranges: ?[*]const Wchar,
-    ) Font;
-
-    pub fn getFont(index: u32) Font {
-        return zguiIoGetFont(index);
-    }
-    extern fn zguiIoGetFont(index: c_uint) Font;
-
-    /// `pub fn setDefaultFont(font: Font) void`
-    pub const setDefaultFont = zguiIoSetDefaultFont;
-    extern fn zguiIoSetDefaultFont(font: Font) void;
-
-    pub fn getFontsTextDataAsRgba32() struct {
-        width: i32,
-        height: i32,
-        pixels: ?[*]const u32,
-    } {
-        var width: i32 = undefined;
-        var height: i32 = undefined;
-        const ptr = zguiIoGetFontsTexDataAsRgba32(&width, &height);
-        return .{
-            .width = width,
-            .height = height,
-            .pixels = ptr,
-        };
-    }
-    extern fn zguiIoGetFontsTexDataAsRgba32(width: *c_int, height: *c_int) [*c]const u32;
-
-    /// `pub fn setFontsTexId(id:TextureIdent) set the backend Id for the fonts atlas
-    pub const setFontsTexId = zguiIoSetFontsTexId;
-    extern fn zguiIoSetFontsTexId(id: TextureIdent) void;
-
-    pub const getFontsTexId = zguiIoGetFontsTexId;
-    extern fn zguiIoGetFontsTexId() TextureIdent;
-
-    /// `pub fn zguiIoSetConfigWindowsMoveFromTitleBarOnly(bool) void`
-    pub const setConfigWindowsMoveFromTitleBarOnly = zguiIoSetConfigWindowsMoveFromTitleBarOnly;
-    extern fn zguiIoSetConfigWindowsMoveFromTitleBarOnly(enabled: bool) void;
-
-    /// `pub fn zguiIoGetWantCaptureMouse() bool`
-    pub const getWantCaptureMouse = zguiIoGetWantCaptureMouse;
-    extern fn zguiIoGetWantCaptureMouse() bool;
-
-    /// `pub fn zguiIoGetWantCaptureKeyboard() bool`
-    pub const getWantCaptureKeyboard = zguiIoGetWantCaptureKeyboard;
-    extern fn zguiIoGetWantCaptureKeyboard() bool;
-
-    /// `pub fn zguiIoGetWantTextInput() bool`
-    pub const getWantTextInput = zguiIoGetWantTextInput;
-    extern fn zguiIoGetWantTextInput() bool;
-
-    pub fn setIniFilename(filename: ?[*:0]const u8) void {
-        zguiIoSetIniFilename(filename);
-    }
-    extern fn zguiIoSetIniFilename(filename: ?[*:0]const u8) void;
-
-    /// `pub fn setDisplaySize(width: f32, height: f32) void`
-    pub const setDisplaySize = zguiIoSetDisplaySize;
-    extern fn zguiIoSetDisplaySize(width: f32, height: f32) void;
-
-    pub fn getDisplaySize() [2]f32 {
-        var size: [2]f32 = undefined;
-        zguiIoGetDisplaySize(&size);
-        return size;
-    }
-    extern fn zguiIoGetDisplaySize(size: *[2]f32) void;
-
-    /// `pub fn setDisplayFramebufferScale(sx: f32, sy: f32) void`
-    pub const setDisplayFramebufferScale = zguiIoSetDisplayFramebufferScale;
-    extern fn zguiIoSetDisplayFramebufferScale(sx: f32, sy: f32) void;
-
-    /// `pub fn setConfigFlags(flags: ConfigFlags) void`
-    pub const setConfigFlags = zguiIoSetConfigFlags;
-    extern fn zguiIoSetConfigFlags(flags: ConfigFlags) void;
-
-    /// `pub fn setDeltaTime(delta_time: f32) void`
-    pub const setDeltaTime = zguiIoSetDeltaTime;
-    extern fn zguiIoSetDeltaTime(delta_time: f32) void;
-
-    pub const addFocusEvent = zguiIoAddFocusEvent;
-    extern fn zguiIoAddFocusEvent(focused: bool) void;
-
-    pub const addMousePositionEvent = zguiIoAddMousePositionEvent;
-    extern fn zguiIoAddMousePositionEvent(x: f32, y: f32) void;
-
-    pub const addMouseButtonEvent = zguiIoAddMouseButtonEvent;
-    extern fn zguiIoAddMouseButtonEvent(button: MouseButton, down: bool) void;
-
-    pub const addMouseWheelEvent = zguiIoAddMouseWheelEvent;
-    extern fn zguiIoAddMouseWheelEvent(x: f32, y: f32) void;
-
-    pub const addKeyEvent = zguiIoAddKeyEvent;
-    extern fn zguiIoAddKeyEvent(key: Key, down: bool) void;
-
-    pub const addInputCharactersUTF8 = zguiIoAddInputCharactersUTF8;
-    extern fn zguiIoAddInputCharactersUTF8(utf8_chars: ?[*:0]const u8) void;
-
-    pub fn setKeyEventNativeData(key: Key, keycode: i32, scancode: i32) void {
-        zguiIoSetKeyEventNativeData(key, keycode, scancode);
-    }
-    extern fn zguiIoSetKeyEventNativeData(key: Key, keycode: c_int, scancode: c_int) void;
-
-    pub fn addCharacterEvent(char: i32) void {
-        zguiIoAddCharacterEvent(char);
-    }
-    extern fn zguiIoAddCharacterEvent(char: c_int) void;
-};
-
-pub fn setClipboardText(value: [:0]const u8) void {
-    zguiSetClipboardText(value.ptr);
-}
-pub fn getClipboardText() [:0]const u8 {
-    const value = zguiGetClipboardText();
-    return std.mem.span(value);
-}
-extern fn zguiSetClipboardText(text: [*:0]const u8) void;
-extern fn zguiGetClipboardText() [*:0]const u8;
-//--------------------------------------------------------------------------------------------------
-const Context = *opaque {};
-pub const DrawData = *extern struct {
-    valid: bool,
-    cmd_lists_count: c_int,
-    total_idx_count: c_int,
-    total_vtx_count: c_int,
-    cmd_lists: Vector(DrawList),
-    display_pos: [2]f32,
-    display_size: [2]f32,
-    framebuffer_scale: [2]f32,
-};
-pub const Font = *opaque {};
-pub const Ident = u32;
-pub const TextureIdent = *anyopaque;
-pub const Wchar = if (@import("zgui_options").use_wchar32) u32 else u16;
-pub const Key = enum(c_int) {
-    none = 0,
-    tab = 512,
-    left_arrow,
-    right_arrow,
-    up_arrow,
-    down_arrow,
-    page_up,
-    page_down,
-    home,
-    end,
-    insert,
-    delete,
-    back_space,
-    space,
-    enter,
-    escape,
-    left_ctrl,
-    left_shift,
-    left_alt,
-    left_super,
-    right_ctrl,
-    right_shift,
-    right_alt,
-    right_super,
-    menu,
-    zero,
-    one,
-    two,
-    three,
-    four,
-    five,
-    six,
-    seven,
-    eight,
-    nine,
-    a,
-    b,
-    c,
-    d,
-    e,
-    f,
-    g,
-    h,
-    i,
-    j,
-    k,
-    l,
-    m,
-    n,
-    o,
-    p,
-    q,
-    r,
-    s,
-    t,
-    u,
-    v,
-    w,
-    x,
-    y,
-    z,
-    f1,
-    f2,
-    f3,
-    f4,
-    f5,
-    f6,
-    f7,
-    f8,
-    f9,
-    f10,
-    f11,
-    f12,
-    f13,
-    f14,
-    f15,
-    f16,
-    f17,
-    f18,
-    f19,
-    f20,
-    f21,
-    f22,
-    f23,
-    f24,
-    apostrophe,
-    comma,
-    minus,
-    period,
-    slash,
-    semicolon,
-    equal,
-    left_bracket,
-    back_slash,
-    right_bracket,
-    grave_accent,
-    caps_lock,
-    scroll_lock,
-    num_lock,
-    print_screen,
-    pause,
-    keypad_0,
-    keypad_1,
-    keypad_2,
-    keypad_3,
-    keypad_4,
-    keypad_5,
-    keypad_6,
-    keypad_7,
-    keypad_8,
-    keypad_9,
-    keypad_decimal,
-    keypad_divide,
-    keypad_multiply,
-    keypad_subtract,
-    keypad_add,
-    keypad_enter,
-    keypad_equal,
-
-    app_back,
-    app_forward,
-
-    gamepad_start,
-    gamepad_back,
-    gamepad_faceleft,
-    gamepad_faceright,
-    gamepad_faceup,
-    gamepad_facedown,
-    gamepad_dpadleft,
-    gamepad_dpadright,
-    gamepad_dpadup,
-    gamepad_dpaddown,
-    gamepad_l1,
-    gamepad_r1,
-    gamepad_l2,
-    gamepad_r2,
-    gamepad_l3,
-    gamepad_r3,
-    gamepad_lstickleft,
-    gamepad_lstickright,
-    gamepad_lstickup,
-    gamepad_lstickdown,
-    gamepad_rstickleft,
-    gamepad_rstickright,
-    gamepad_rstickup,
-    gamepad_rstickdown,
-
-    mouse_left,
-    mouse_right,
-    mouse_middle,
-    mouse_x1,
-    mouse_x2,
-
-    mouse_wheel_x,
-    mouse_wheel_y,
-
-    mod_ctrl = 1 << 12,
-    mod_shift = 1 << 13,
-    mod_alt = 1 << 14,
-    mod_super = 1 << 15,
-    mod_mask_ = 0xf000,
-};
-
-//--------------------------------------------------------------------------------------------------
-pub const WindowFlags = packed struct(c_int) {
-    no_title_bar: bool = false,
-    no_resize: bool = false,
-    no_move: bool = false,
-    no_scrollbar: bool = false,
-    no_scroll_with_mouse: bool = false,
-    no_collapse: bool = false,
-    always_auto_resize: bool = false,
-    no_background: bool = false,
-    no_saved_settings: bool = false,
-    no_mouse_inputs: bool = false,
-    menu_bar: bool = false,
-    horizontal_scrollbar: bool = false,
-    no_focus_on_appearing: bool = false,
-    no_bring_to_front_on_focus: bool = false,
-    always_vertical_scrollbar: bool = false,
-    always_horizontal_scrollbar: bool = false,
-    no_nav_inputs: bool = false,
-    no_nav_focus: bool = false,
-    unsaved_document: bool = false,
-    no_docking: bool = false,
-    _padding: u12 = 0,
-
-    pub const no_nav = WindowFlags{ .no_nav_inputs = true, .no_nav_focus = true };
-    pub const no_decoration = WindowFlags{
-        .no_title_bar = true,
-        .no_resize = true,
-        .no_scrollbar = true,
-        .no_collapse = true,
-    };
-    pub const no_inputs = WindowFlags{
-        .no_mouse_inputs = true,
-        .no_nav_inputs = true,
-        .no_nav_focus = true,
-    };
-};
-
-pub const ChildFlags = packed struct(c_int) {
-    border: bool = false,
-    no_move: bool = false,
-    always_use_window_padding: bool = false,
-    resize_x: bool = false,
-    resize_y: bool = false,
-    auto_resize_x: bool = false,
-    auto_resize_y: bool = false,
-    always_auto_resize: bool = false,
-    frame_style: bool = false,
-    _padding: u23 = 0,
-};
-
-//--------------------------------------------------------------------------------------------------
-pub const SliderFlags = packed struct(c_int) {
-    _reserved0: bool = false,
-    _reserved1: bool = false,
-    _reserved2: bool = false,
-    _reserved3: bool = false,
-    always_clamp: bool = false,
-    logarithmic: bool = false,
-    no_round_to_format: bool = false,
-    no_input: bool = false,
-    _padding: u24 = 0,
-};
-//--------------------------------------------------------------------------------------------------
-pub const ButtonFlags = packed struct(c_int) {
-    mouse_button_left: bool = false,
-    mouse_button_right: bool = false,
-    mouse_button_middle: bool = false,
-    _padding: u29 = 0,
-};
-//--------------------------------------------------------------------------------------------------
-pub const Direction = enum(c_int) {
-    none = -1,
-    left = 0,
-    right = 1,
-    up = 2,
-    down = 3,
-};
-//--------------------------------------------------------------------------------------------------
-pub const DataType = enum(c_int) { I8, U8, I16, U16, I32, U32, I64, U64, F32, F64 };
-//--------------------------------------------------------------------------------------------------
-pub const Condition = enum(c_int) {
-    none = 0,
-    always = 1,
-    once = 2,
-    first_use_ever = 4,
-    appearing = 8,
-};
-//--------------------------------------------------------------------------------------------------
-//
-// Main
-//
-//--------------------------------------------------------------------------------------------------
-/// `pub fn newFrame() void`
-pub const newFrame = zguiNewFrame;
-extern fn zguiNewFrame() void;
-//--------------------------------------------------------------------------------------------------
-/// `pub fn render() void`
-pub const render = zguiRender;
-extern fn zguiRender() void;
-//--------------------------------------------------------------------------------------------------
-/// `pub fn getDrawData() DrawData`
-pub const getDrawData = zguiGetDrawData;
-extern fn zguiGetDrawData() DrawData;
-//--------------------------------------------------------------------------------------------------
-//
-// Demo, Debug, Information
-//
-//--------------------------------------------------------------------------------------------------
-/// `pub fn showDemoWindow(popen: ?*bool) void`
-pub const showDemoWindow = zguiShowDemoWindow;
-extern fn zguiShowDemoWindow(popen: ?*bool) void;
-//--------------------------------------------------------------------------------------------------
-//
-// Windows
-//
-//--------------------------------------------------------------------------------------------------
-const SetNextWindowPos = struct {
-    x: f32,
-    y: f32,
-    cond: Condition = .none,
-    pivot_x: f32 = 0.0,
-    pivot_y: f32 = 0.0,
-};
-pub fn setNextWindowPos(args: SetNextWindowPos) void {
-    zguiSetNextWindowPos(args.x, args.y, args.cond, args.pivot_x, args.pivot_y);
-}
-extern fn zguiSetNextWindowPos(x: f32, y: f32, cond: Condition, pivot_x: f32, pivot_y: f32) void;
-//--------------------------------------------------------------------------------------------------
-const SetNextWindowSize = struct {
-    w: f32,
-    h: f32,
-    cond: Condition = .none,
-};
-pub fn setNextWindowSize(args: SetNextWindowSize) void {
-    zguiSetNextWindowSize(args.w, args.h, args.cond);
-}
-extern fn zguiSetNextWindowSize(w: f32, h: f32, cond: Condition) void;
-//--------------------------------------------------------------------------------------------------
-const SetNextWindowCollapsed = struct {
-    collapsed: bool,
-    cond: Condition = .none,
-};
-pub fn setNextWindowCollapsed(args: SetNextWindowCollapsed) void {
-    zguiSetNextWindowCollapsed(args.collapsed, args.cond);
-}
-extern fn zguiSetNextWindowCollapsed(collapsed: bool, cond: Condition) void;
-//--------------------------------------------------------------------------------------------------
-/// `pub fn setNextWindowFocus() void`
-pub const setNextWindowFocus = zguiSetNextWindowFocus;
-extern fn zguiSetNextWindowFocus() void;
-//--------------------------------------------------------------------------------------------------
-const SetNextWindowBgAlpha = struct {
-    alpha: f32,
-};
-pub fn setNextWindowBgAlpha(args: SetNextWindowBgAlpha) void {
-    zguiSetNextWindowBgAlpha(args.alpha);
-}
-extern fn zguiSetNextWindowBgAlpha(alpha: f32) void;
-//--------------------------------------------------------------------------------------------------
-pub fn setWindowFocus(name: ?[:0]const u8) void {
-    zguiSetWindowFocus(name orelse null);
-}
-extern fn zguiSetWindowFocus(name: ?[*:0]const u8) void;
-//-------------------------------------------------------------------------------------------------
-pub fn setKeyboardFocusHere(offset: i32) void {
-    zguiSetKeyboardFocusHere(offset);
-}
-extern fn zguiSetKeyboardFocusHere(offset: c_int) void;
-
-//--------------------------------------------------------------------------------------------------
-const Begin = struct {
-    popen: ?*bool = null,
-    flags: WindowFlags = .{},
-};
-pub fn begin(name: [:0]const u8, args: Begin) bool {
-    return zguiBegin(name, args.popen, args.flags);
-}
-/// `pub fn end() void`
-pub const end = zguiEnd;
-extern fn zguiBegin(name: [*:0]const u8, popen: ?*bool, flags: WindowFlags) bool;
-extern fn zguiEnd() void;
-//--------------------------------------------------------------------------------------------------
-const BeginChild = struct {
-    w: f32 = 0.0,
-    h: f32 = 0.0,
-    child_flags: ChildFlags = .{},
-    window_flags: WindowFlags = .{},
-};
-pub fn beginChild(str_id: [:0]const u8, args: BeginChild) bool {
-    return zguiBeginChild(str_id, args.w, args.h, args.child_flags, args.window_flags);
-}
-pub fn beginChildId(id: Ident, args: BeginChild) bool {
-    return zguiBeginChildId(id, args.w, args.h, args.child_flags, args.window_flags);
-}
-/// `pub fn endChild() void`
-pub const endChild = zguiEndChild;
-extern fn zguiBeginChild(str_id: [*:0]const u8, w: f32, h: f32, flags: ChildFlags, window_flags: WindowFlags) bool;
-extern fn zguiBeginChildId(id: Ident, w: f32, h: f32, flags: ChildFlags, window_flags: WindowFlags) bool;
-extern fn zguiEndChild() void;
-//--------------------------------------------------------------------------------------------------
-/// `pub fn zguiGetScrollX() f32`
-pub const getScrollX = zguiGetScrollX;
-/// `pub fn zguiGetScrollY() f32`
-pub const getScrollY = zguiGetScrollY;
-/// `pub fn zguiSetScrollX(scroll_x: f32) void`
-pub const setScrollX = zguiSetScrollX;
-/// `pub fn zguiSetScrollY(scroll_y: f32) void`
-pub const setScrollY = zguiSetScrollY;
-/// `pub fn zguiGetScrollMaxX() f32`
-pub const getScrollMaxX = zguiGetScrollMaxX;
-/// `pub fn zguiGetScrollMaxY() f32`
-pub const getScrollMaxY = zguiGetScrollMaxY;
-extern fn zguiGetScrollX() f32;
-extern fn zguiGetScrollY() f32;
-extern fn zguiSetScrollX(scroll_x: f32) void;
-extern fn zguiSetScrollY(scroll_y: f32) void;
-extern fn zguiGetScrollMaxX() f32;
-extern fn zguiGetScrollMaxY() f32;
-const SetScrollHereX = struct {
-    center_x_ratio: f32 = 0.5,
-};
-const SetScrollHereY = struct {
-    center_y_ratio: f32 = 0.5,
-};
-pub fn setScrollHereX(args: SetScrollHereX) void {
-    zguiSetScrollHereX(args.center_x_ratio);
-}
-pub fn setScrollHereY(args: SetScrollHereY) void {
-    zguiSetScrollHereY(args.center_y_ratio);
-}
-const SetScrollFromPosX = struct {
-    local_x: f32,
-    center_x_ratio: f32 = 0.5,
-};
-const SetScrollFromPosY = struct {
-    local_y: f32,
-    center_y_ratio: f32 = 0.5,
-};
-pub fn setScrollFromPosX(args: SetScrollFromPosX) void {
-    zguiSetScrollFromPosX(args.local_x, args.center_x_ratio);
-}
-pub fn setScrollFromPosY(args: SetScrollFromPosY) void {
-    zguiSetScrollFromPosY(args.local_y, args.center_y_ratio);
-}
-extern fn zguiSetScrollHereX(center_x_ratio: f32) void;
-extern fn zguiSetScrollHereY(center_y_ratio: f32) void;
-extern fn zguiSetScrollFromPosX(local_x: f32, center_x_ratio: f32) void;
-extern fn zguiSetScrollFromPosY(local_y: f32, center_y_ratio: f32) void;
-//--------------------------------------------------------------------------------------------------
-pub const FocusedFlags = packed struct(c_int) {
-    child_windows: bool = false,
-    root_window: bool = false,
-    any_window: bool = false,
-    no_popup_hierarchy: bool = false,
-    dock_hierarchy: bool = false,
-    _padding: u27 = 0,
-
-    pub const root_and_child_windows = FocusedFlags{ .root_window = true, .child_windows = true };
-};
-//--------------------------------------------------------------------------------------------------
-pub const HoveredFlags = packed struct(c_int) {
-    child_windows: bool = false,
-    root_window: bool = false,
-    any_window: bool = false,
-    no_popup_hierarchy: bool = false,
-    dock_hierarchy: bool = false,
-    allow_when_blocked_by_popup: bool = false,
-    _reserved1: bool = false,
-    allow_when_blocked_by_active_item: bool = false,
-    allow_when_overlapped_by_item: bool = false,
-    allow_when_overlapped_by_window: bool = false,
-    allow_when_disabled: bool = false,
-    no_nav_override: bool = false,
-    for_tooltip: bool = false,
-    stationary: bool = false,
-    delay_none: bool = false,
-    delay_normal: bool = false,
-    delay_short: bool = false,
-    no_shared_delay: bool = false,
-    _padding: u14 = 0,
-
-    pub const rect_only = HoveredFlags{
-        .allow_when_blocked_by_popup = true,
-        .allow_when_blocked_by_active_item = true,
-        .allow_when_overlapped_by_item = true,
-        .allow_when_overlapped_by_window = true,
-    };
-    pub const root_and_child_windows = HoveredFlags{ .root_window = true, .child_windows = true };
-};
-//--------------------------------------------------------------------------------------------------
-/// `pub fn isWindowAppearing() bool`
-pub const isWindowAppearing = zguiIsWindowAppearing;
-/// `pub fn isWindowCollapsed() bool`
-pub const isWindowCollapsed = zguiIsWindowCollapsed;
-pub fn isWindowFocused(flags: FocusedFlags) bool {
-    return zguiIsWindowFocused(flags);
-}
-pub fn isWindowHovered(flags: HoveredFlags) bool {
-    return zguiIsWindowHovered(flags);
-}
-extern fn zguiIsWindowAppearing() bool;
-extern fn zguiIsWindowCollapsed() bool;
-extern fn zguiIsWindowFocused(flags: FocusedFlags) bool;
-extern fn zguiIsWindowHovered(flags: HoveredFlags) bool;
-//--------------------------------------------------------------------------------------------------
-pub fn getWindowPos() [2]f32 {
-    var pos: [2]f32 = undefined;
-    zguiGetWindowPos(&pos);
-    return pos;
-}
-pub fn getWindowSize() [2]f32 {
-    var size: [2]f32 = undefined;
-    zguiGetWindowSize(&size);
-    return size;
-}
-
-pub fn getContentRegionAvail() [2]f32 {
-    var size: [2]f32 = undefined;
-    zguiGetContentRegionAvail(&size);
-    return size;
-}
-
-pub fn getContentRegionMax() [2]f32 {
-    var size: [2]f32 = undefined;
-    zguiGetContentRegionMax(&size);
-    return size;
-}
-
-pub fn getWindowContentRegionMin() [2]f32 {
-    var size: [2]f32 = undefined;
-    zguiGetWindowContentRegionMin(&size);
-    return size;
-}
-
-pub fn getWindowContentRegionMax() [2]f32 {
-    var size: [2]f32 = undefined;
-    zguiGetWindowContentRegionMax(&size);
-    return size;
-}
-
-/// `pub fn getWindowWidth() f32`
-pub const getWindowWidth = zguiGetWindowWidth;
-/// `pub fn getWindowHeight() f32`
-pub const getWindowHeight = zguiGetWindowHeight;
-extern fn zguiGetWindowPos(pos: *[2]f32) void;
-extern fn zguiGetWindowSize(size: *[2]f32) void;
-extern fn zguiGetWindowWidth() f32;
-extern fn zguiGetWindowHeight() f32;
-extern fn zguiGetContentRegionAvail(size: *[2]f32) void;
-extern fn zguiGetContentRegionMax(size: *[2]f32) void;
-extern fn zguiGetWindowContentRegionMin(size: *[2]f32) void;
-extern fn zguiGetWindowContentRegionMax(size: *[2]f32) void;
-//--------------------------------------------------------------------------------------------------
-//
-// Docking
-//
-//--------------------------------------------------------------------------------------------------
-pub const DockNodeFlags = packed struct(c_int) {
-    keep_alive_only: bool = false,
-    _reserved: u1 = 0,
-    no_docking_over_central_node: bool = false,
-    passthru_central_node: bool = false,
-    no_docking_split: bool = false,
-    no_resize: bool = false,
-    auto_hide_tab_bar: bool = false,
-    no_undocking: bool = false,
-    _padding_0: u2 = 0,
-
-    // Extended enum entries from imgui_internal (unstable, subject to change, use at own risk)
-    dock_space: bool = false,
-    central_node: bool = false,
-    no_tab_bar: bool = false,
-    hidden_tab_bar: bool = false,
-    no_window_menu_button: bool = false,
-    no_close_button: bool = false,
-    no_resize_x: bool = false,
-    no_resize_y: bool = false,
-    docked_windows_in_focus_route: bool = false,
-    no_docking_split_other: bool = false,
-    no_docking_over_me: bool = false,
-    no_docking_over_other: bool = false,
-    no_docking_over_empty: bool = false,
-    _padding_1: u9 = 0,
-};
-extern fn zguiDockSpace(str_id: [*:0]const u8, size: *const [2]f32, flags: DockNodeFlags) Ident;
-
-pub fn DockSpace(str_id: [:0]const u8, size: [2]f32, flags: DockNodeFlags) Ident {
-    return zguiDockSpace(str_id.ptr, &size, flags);
-}
-extern fn zguiDockSpaceOverViewport(viewport: Viewport, flags: DockNodeFlags) Ident;
-pub const DockSpaceOverViewport = zguiDockSpaceOverViewport;
-
-//--------------------------------------------------------------------------------------------------
-//
-// DockBuilder (Unstable internal imgui API, subject to change, use at own risk)
-//
-//--------------------------------------------------------------------------------------------------
-pub fn dockBuilderDockWindow(window_name: [:0]const u8, node_id: Ident) void {
-    zguiDockBuilderDockWindow(window_name.ptr, node_id);
-}
-pub const dockBuilderAddNode = zguiDockBuilderAddNode;
-pub const dockBuilderRemoveNode = zguiDockBuilderRemoveNode;
-pub fn dockBuilderSetNodePos(node_id: Ident, pos: [2]f32) void {
-    zguiDockBuilderSetNodePos(node_id, &pos);
-}
-pub fn dockBuilderSetNodeSize(node_id: Ident, size: [2]f32) void {
-    zguiDockBuilderSetNodeSize(node_id, &size);
-}
-pub const dockBuilderSplitNode = zguiDockBuilderSplitNode;
-pub const dockBuilderFinish = zguiDockBuilderFinish;
-
-extern fn zguiDockBuilderDockWindow(window_name: [*:0]const u8, node_id: Ident) void;
-extern fn zguiDockBuilderAddNode(node_id: Ident, flags: DockNodeFlags) Ident;
-extern fn zguiDockBuilderRemoveNode(node_id: Ident) void;
-extern fn zguiDockBuilderSetNodePos(node_id: Ident, pos: *const [2]f32) void;
-extern fn zguiDockBuilderSetNodeSize(node_id: Ident, size: *const [2]f32) void;
-extern fn zguiDockBuilderSplitNode(
-    node_id: Ident,
-    split_dir: Direction,
-    size_ratio_for_node_at_dir: f32,
-    out_id_at_dir: ?*Ident,
-    out_id_at_opposite_dir: ?*Ident,
-) Ident;
-extern fn zguiDockBuilderFinish(node_id: Ident) void;
-
-//--------------------------------------------------------------------------------------------------
-//
-// Style
-//
-//--------------------------------------------------------------------------------------------------
-pub const Style = extern struct {
-    alpha: f32,
-    disabled_alpha: f32,
-    window_padding: [2]f32,
-    window_rounding: f32,
-    window_border_size: f32,
-    window_min_size: [2]f32,
-    window_title_align: [2]f32,
-    window_menu_button_position: Direction,
-    child_rounding: f32,
-    child_border_size: f32,
-    popup_rounding: f32,
-    popup_border_size: f32,
-    frame_padding: [2]f32,
-    frame_rounding: f32,
-    frame_border_size: f32,
-    item_spacing: [2]f32,
-    item_inner_spacing: [2]f32,
-    cell_padding: [2]f32,
-    touch_extra_padding: [2]f32,
-    indent_spacing: f32,
-    columns_min_spacing: f32,
-    scrollbar_size: f32,
-    scrollbar_rounding: f32,
-    grab_min_size: f32,
-    grab_rounding: f32,
-    log_slider_deadzone: f32,
-    tab_rounding: f32,
-    tab_border_size: f32,
-    tab_min_width_for_close_button: f32,
-    tab_bar_border_size: f32,
-    table_angled_header_angle: f32,
-    color_button_position: Direction,
-    button_text_align: [2]f32,
-    selectable_text_align: [2]f32,
-    separator_text_border_size: f32,
-    separator_text_align: [2]f32,
-    separator_text_padding: [2]f32,
-    display_window_padding: [2]f32,
-    display_safe_area_padding: [2]f32,
-    docking_separator_size: f32,
-    mouse_cursor_scale: f32,
-    anti_aliased_lines: bool,
-    anti_aliased_lines_use_tex: bool,
-    anti_aliased_fill: bool,
-    curve_tessellation_tol: f32,
-    circle_tessellation_max_error: f32,
-
-    colors: [@typeInfo(StyleCol).Enum.fields.len][4]f32,
-
-    hover_stationary_delay: f32,
-    hover_delay_short: f32,
-    hover_delay_normal: f32,
-
-    hover_flags_for_tooltip_mouse: HoveredFlags,
-    hover_flags_for_tooltip_nav: HoveredFlags,
-
-    /// `pub fn init() Style`
-    pub const init = zguiStyle_Init;
-    extern fn zguiStyle_Init() Style;
-
-    /// `pub fn scaleAllSizes(style: *Style, scale_factor: f32) void`
-    pub const scaleAllSizes = zguiStyle_ScaleAllSizes;
-    extern fn zguiStyle_ScaleAllSizes(style: *Style, scale_factor: f32) void;
-
-    pub fn getColor(style: Style, idx: StyleCol) [4]f32 {
-        return style.colors[@intCast(@intFromEnum(idx))];
-    }
-    pub fn setColor(style: *Style, idx: StyleCol, color: [4]f32) void {
-        style.colors[@intCast(@intFromEnum(idx))] = color;
-    }
-};
-/// `pub fn getStyle() *Style`
-pub const getStyle = zguiGetStyle;
-extern fn zguiGetStyle() *Style;
-//--------------------------------------------------------------------------------------------------
-pub const StyleCol = enum(c_int) {
-    text,
-    text_disabled,
-    window_bg,
-    child_bg,
-    popup_bg,
-    border,
-    border_shadow,
-    frame_bg,
-    frame_bg_hovered,
-    frame_bg_active,
-    title_bg,
-    title_bg_active,
-    title_bg_collapsed,
-    menu_bar_bg,
-    scrollbar_bg,
-    scrollbar_grab,
-    scrollbar_grab_hovered,
-    scrollbar_grab_active,
-    check_mark,
-    slider_grab,
-    slider_grab_active,
-    button,
-    button_hovered,
-    button_active,
-    header,
-    header_hovered,
-    header_active,
-    separator,
-    separator_hovered,
-    separator_active,
-    resize_grip,
-    resize_grip_hovered,
-    resize_grip_active,
-    tab,
-    tab_hovered,
-    tab_active,
-    tab_unfocused,
-    tab_unfocused_active,
-    docking_preview,
-    docking_empty_bg,
-    plot_lines,
-    plot_lines_hovered,
-    plot_histogram,
-    plot_histogram_hovered,
-    table_header_bg,
-    table_border_strong,
-    table_border_light,
-    table_row_bg,
-    table_row_bg_alt,
-    text_selected_bg,
-    drag_drop_target,
-    nav_highlight,
-    nav_windowing_highlight,
-    nav_windowing_dim_bg,
-    modal_window_dim_bg,
-};
-
-pub fn pushStyleColor4f(args: struct {
-    idx: StyleCol,
-    c: [4]f32,
-}) void {
-    zguiPushStyleColor4f(args.idx, &args.c);
-}
-extern fn zguiPushStyleColor4f(idx: StyleCol, col: *const [4]f32) void;
-
-pub fn pushStyleColor1u(args: struct {
-    idx: StyleCol,
-    c: u32,
-}) void {
-    zguiPushStyleColor1u(args.idx, args.c);
-}
-extern fn zguiPushStyleColor1u(idx: StyleCol, col: c_uint) void;
-
-pub fn popStyleColor(args: struct {
-    count: i32 = 1,
-}) void {
-    zguiPopStyleColor(args.count);
-}
-extern fn zguiPopStyleColor(count: c_int) void;
-
-/// `fn pushTextWrapPos(wrap_pos_x: f32) void`
-pub const pushTextWrapPos = zguiPushTextWrapPos;
-extern fn zguiPushTextWrapPos(wrap_pos_x: f32) void;
-
-/// `fn popTextWrapPos() void`
-pub const popTextWrapPos = zguiPopTextWrapPos;
-extern fn zguiPopTextWrapPos() void;
-
-//--------------------------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------------------------
-pub const StyleVar = enum(c_int) {
-    alpha, // 1f
-    disabled_alpha, // 1f
-    window_padding, // 2f
-    window_rounding, // 1f
-    window_border_size, // 1f
-    window_min_size, // 2f
-    window_title_align, // 2f
-    child_rounding, // 1f
-    child_border_size, // 1f
-    popup_rounding, // 1f
-    popup_border_size, // 1f
-    frame_padding, // 2f
-    frame_rounding, // 1f
-    frame_border_size, // 1f
-    item_spacing, // 2f
-    item_inner_spacing, // 2f
-    indent_spacing, // 1f
-    cell_padding, // 2f
-    scrollbar_size, // 1f
-    scrollbar_rounding, // 1f
-    grab_min_size, // 1f
-    grab_rounding, // 1f
-    tab_rounding, // 1f
-    tab_bar_border_size, // 1f
-    button_text_align, // 2f
-    selectable_text_align, // 2f
-    separator_text_border_size, // 1f
-    separator_text_align, // 2f
-    separator_text_padding, // 2f
-    docking_separator_size, // 1f
-};
-
-pub fn pushStyleVar1f(args: struct {
-    idx: StyleVar,
-    v: f32,
-}) void {
-    zguiPushStyleVar1f(args.idx, args.v);
-}
-extern fn zguiPushStyleVar1f(idx: StyleVar, v: f32) void;
-
-pub fn pushStyleVar2f(args: struct {
-    idx: StyleVar,
-    v: [2]f32,
-}) void {
-    zguiPushStyleVar2f(args.idx, &args.v);
-}
-extern fn zguiPushStyleVar2f(idx: StyleVar, v: *const [2]f32) void;
-
-pub fn popStyleVar(args: struct {
-    count: i32 = 1,
-}) void {
-    zguiPopStyleVar(args.count);
-}
-extern fn zguiPopStyleVar(count: c_int) void;
-
-//--------------------------------------------------------------------------------------------------
-/// `void pushItemWidth(item_width: f32) void`
-pub const pushItemWidth = zguiPushItemWidth;
-/// `void popItemWidth() void`
-pub const popItemWidth = zguiPopItemWidth;
-/// `void setNextItemWidth(item_width: f32) void`
-pub const setNextItemWidth = zguiSetNextItemWidth;
-/// `void setItemDefaultFocus() void`
-pub const setItemDefaultFocus = zguiSetItemDefaultFocus;
-extern fn zguiPushItemWidth(item_width: f32) void;
-extern fn zguiPopItemWidth() void;
-extern fn zguiSetNextItemWidth(item_width: f32) void;
-extern fn zguiSetItemDefaultFocus() void;
-//--------------------------------------------------------------------------------------------------
-/// `pub fn getFont() Font`
-pub const getFont = zguiGetFont;
-extern fn zguiGetFont() Font;
-/// `pub fn getFontSize() f32`
-pub const getFontSize = zguiGetFontSize;
-extern fn zguiGetFontSize() f32;
-/// `void pushFont(font: Font) void`
-pub const pushFont = zguiPushFont;
-extern fn zguiPushFont(font: Font) void;
-/// `void popFont() void`
-pub const popFont = zguiPopFont;
-extern fn zguiPopFont() void;
-
-pub fn getFontTexUvWhitePixel() [2]f32 {
-    var uv: [2]f32 = undefined;
-    zguiGetFontTexUvWhitePixel(&uv);
-    return uv;
-}
-extern fn zguiGetFontTexUvWhitePixel(uv: *[2]f32) void;
-//--------------------------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------------------------
-const BeginDisabled = struct {
-    disabled: bool = true,
-};
-pub fn beginDisabled(args: BeginDisabled) void {
-    zguiBeginDisabled(args.disabled);
-}
-/// `pub fn endDisabled() void`
-pub const endDisabled = zguiEndDisabled;
-extern fn zguiBeginDisabled(disabled: bool) void;
-extern fn zguiEndDisabled() void;
-//--------------------------------------------------------------------------------------------------
-//
-// Cursor / Layout
-//
-//--------------------------------------------------------------------------------------------------
-/// `pub fn separator() void`
-pub const separator = zguiSeparator;
-extern fn zguiSeparator() void;
-
-pub fn separatorText(label: [:0]const u8) void {
-    zguiSeparatorText(label);
-}
-extern fn zguiSeparatorText(label: [*:0]const u8) void;
-//--------------------------------------------------------------------------------------------------
-const SameLine = struct {
-    offset_from_start_x: f32 = 0.0,
-    spacing: f32 = -1.0,
-};
-pub fn sameLine(args: SameLine) void {
-    zguiSameLine(args.offset_from_start_x, args.spacing);
-}
-extern fn zguiSameLine(offset_from_start_x: f32, spacing: f32) void;
-//--------------------------------------------------------------------------------------------------
-/// `pub fn newLine() void`
-pub const newLine = zguiNewLine;
-extern fn zguiNewLine() void;
-//--------------------------------------------------------------------------------------------------
-/// `pub fn spacing() void`
-pub const spacing = zguiSpacing;
-extern fn zguiSpacing() void;
-//--------------------------------------------------------------------------------------------------
-const Dummy = struct {
-    w: f32,
-    h: f32,
-};
-pub fn dummy(args: Dummy) void {
-    zguiDummy(args.w, args.h);
-}
-extern fn zguiDummy(w: f32, h: f32) void;
-//--------------------------------------------------------------------------------------------------
-const Indent = struct {
-    indent_w: f32 = 0.0,
-};
-pub fn indent(args: Indent) void {
-    zguiIndent(args.indent_w);
-}
-const Unindent = struct {
-    indent_w: f32 = 0.0,
-};
-pub fn unindent(args: Unindent) void {
-    zguiUnindent(args.indent_w);
-}
-extern fn zguiIndent(indent_w: f32) void;
-extern fn zguiUnindent(indent_w: f32) void;
-//--------------------------------------------------------------------------------------------------
-/// `pub fn beginGroup() void`
-pub const beginGroup = zguiBeginGroup;
-extern fn zguiBeginGroup() void;
-/// `pub fn endGroup() void`
-pub const endGroup = zguiEndGroup;
-extern fn zguiEndGroup() void;
-//--------------------------------------------------------------------------------------------------
-pub fn getCursorPos() [2]f32 {
-    var pos: [2]f32 = undefined;
-    zguiGetCursorPos(&pos);
-    return pos;
-}
-/// `pub fn getCursorPosX() f32`
-pub const getCursorPosX = zguiGetCursorPosX;
-/// `pub fn getCursorPosY() f32`
-pub const getCursorPosY = zguiGetCursorPosY;
-extern fn zguiGetCursorPos(pos: *[2]f32) void;
-extern fn zguiGetCursorPosX() f32;
-extern fn zguiGetCursorPosY() f32;
-//--------------------------------------------------------------------------------------------------
-pub fn setCursorPos(local_pos: [2]f32) void {
-    zguiSetCursorPos(local_pos[0], local_pos[1]);
-}
-/// `pub fn setCursorPosX(local_x: f32) void`
-pub const setCursorPosX = zguiSetCursorPosX;
-/// `pub fn setCursorPosY(local_y: f32) void`
-pub const setCursorPosY = zguiSetCursorPosY;
-extern fn zguiSetCursorPos(local_x: f32, local_y: f32) void;
-extern fn zguiSetCursorPosX(local_x: f32) void;
-extern fn zguiSetCursorPosY(local_y: f32) void;
-//--------------------------------------------------------------------------------------------------
-pub fn getCursorStartPos() [2]f32 {
-    var pos: [2]f32 = undefined;
-    zguiGetCursorStartPos(&pos);
-    return pos;
-}
-pub fn getCursorScreenPos() [2]f32 {
-    var pos: [2]f32 = undefined;
-    zguiGetCursorScreenPos(&pos);
-    return pos;
-}
-pub fn setCursorScreenPos(screen_pos: [2]f32) void {
-    zguiSetCursorPos(screen_pos[0], screen_pos[1]);
-}
-extern fn zguiGetCursorStartPos(pos: *[2]f32) void;
-extern fn zguiGetCursorScreenPos(pos: *[2]f32) void;
-extern fn zguiSetCursorScreenPos(screen_x: f32, screen_y: f32) void;
-//--------------------------------------------------------------------------------------------------
-pub const Cursor = enum(c_int) {
-    none = -1,
-    arrow = 0,
-    text_input,
-    resize_all,
-    resize_ns,
-    resize_ew,
-    resize_nesw,
-    resize_nwse,
-    hand,
-    not_allowed,
-    count,
-};
-/// `pub fn getMouseCursor() MouseCursor`
-pub const getMouseCursor = zguiGetMouseCursor;
-/// `pub fn setMouseCursor(cursor: MouseCursor) void`
-pub const setMouseCursor = zguiSetMouseCursor;
-extern fn zguiGetMouseCursor() Cursor;
-extern fn zguiSetMouseCursor(cursor: Cursor) void;
-//--------------------------------------------------------------------------------------------------
-pub fn getMousePos() [2]f32 {
-    var pos: [2]f32 = undefined;
-    zguiGetMousePos(&pos);
-    return pos;
-}
-extern fn zguiGetMousePos(pos: *[2]f32) void;
-//--------------------------------------------------------------------------------------------------
-/// `pub fn alignTextToFramePadding() void`
-pub const alignTextToFramePadding = zguiAlignTextToFramePadding;
-/// `pub fn getTextLineHeight() f32`
-pub const getTextLineHeight = zguiGetTextLineHeight;
-/// `pub fn getTextLineHeightWithSpacing() f32`
-pub const getTextLineHeightWithSpacing = zguiGetTextLineHeightWithSpacing;
-/// `pub fn getFrameHeight() f32`
-pub const getFrameHeight = zguiGetFrameHeight;
-/// `pub fn getFrameHeightWithSpacing() f32`
-pub const getFrameHeightWithSpacing = zguiGetFrameHeightWithSpacing;
-extern fn zguiAlignTextToFramePadding() void;
-extern fn zguiGetTextLineHeight() f32;
-extern fn zguiGetTextLineHeightWithSpacing() f32;
-extern fn zguiGetFrameHeight() f32;
-extern fn zguiGetFrameHeightWithSpacing() f32;
-//--------------------------------------------------------------------------------------------------
-pub fn getItemRectMax() [2]f32 {
-    var rect: [2]f32 = undefined;
-    zguiGetItemRectMax(&rect);
-    return rect;
-}
-pub fn getItemRectMin() [2]f32 {
-    var rect: [2]f32 = undefined;
-    zguiGetItemRectMin(&rect);
-    return rect;
-}
-pub fn getItemRectSize() [2]f32 {
-    var rect: [2]f32 = undefined;
-    zguiGetItemRectSize(&rect);
-    return rect;
-}
-extern fn zguiGetItemRectMax(rect: *[2]f32) void;
-extern fn zguiGetItemRectMin(rect: *[2]f32) void;
-extern fn zguiGetItemRectSize(rect: *[2]f32) void;
-//--------------------------------------------------------------------------------------------------
-//
-// ID stack/scopes
-//
-//--------------------------------------------------------------------------------------------------
-pub fn pushStrId(str_id: []const u8) void {
-    zguiPushStrId(str_id.ptr, str_id.ptr + str_id.len);
-}
-extern fn zguiPushStrId(str_id_begin: [*]const u8, str_id_end: [*]const u8) void;
-
-pub fn pushStrIdZ(str_id: [:0]const u8) void {
-    zguiPushStrIdZ(str_id);
-}
-extern fn zguiPushStrIdZ(str_id: [*:0]const u8) void;
-
-pub fn pushPtrId(ptr_id: *const anyopaque) void {
-    zguiPushPtrId(ptr_id);
-}
-extern fn zguiPushPtrId(ptr_id: *const anyopaque) void;
-
-pub fn pushIntId(int_id: i32) void {
-    zguiPushIntId(int_id);
-}
-extern fn zguiPushIntId(int_id: c_int) void;
-
-/// `pub fn popId() void`
-pub const popId = zguiPopId;
-extern fn zguiPopId() void;
-
-pub fn getStrId(str_id: []const u8) Ident {
-    return zguiGetStrId(str_id.ptr, str_id.ptr + str_id.len);
-}
-extern fn zguiGetStrId(str_id_begin: [*]const u8, str_id_end: [*]const u8) Ident;
-
-pub fn getStrIdZ(str_id: [:0]const u8) Ident {
-    return zguiGetStrIdZ(str_id);
-}
-extern fn zguiGetStrIdZ(str_id: [*:0]const u8) Ident;
-
-pub fn getPtrId(ptr_id: *const anyopaque) Ident {
-    return zguiGetPtrId(ptr_id);
-}
-extern fn zguiGetPtrId(ptr_id: *const anyopaque) Ident;
-
-//--------------------------------------------------------------------------------------------------
-//
-// Widgets: Text
-//
-//--------------------------------------------------------------------------------------------------
-pub fn textUnformatted(txt: []const u8) void {
-    zguiTextUnformatted(txt.ptr, txt.ptr + txt.len);
-}
-pub fn textUnformattedColored(color: [4]f32, txt: []const u8) void {
-    pushStyleColor4f(.{ .idx = .text, .c = color });
-    textUnformatted(txt);
-    popStyleColor(.{});
-}
-//--------------------------------------------------------------------------------------------------
-pub fn text(comptime fmt: []const u8, args: anytype) void {
-    const result = format(fmt, args);
-    zguiTextUnformatted(result.ptr, result.ptr + result.len);
-}
-pub fn textColored(color: [4]f32, comptime fmt: []const u8, args: anytype) void {
-    pushStyleColor4f(.{ .idx = .text, .c = color });
-    text(fmt, args);
-    popStyleColor(.{});
-}
-extern fn zguiTextUnformatted(txt: [*]const u8, txt_end: [*]const u8) void;
-//--------------------------------------------------------------------------------------------------
-pub fn textDisabled(comptime fmt: []const u8, args: anytype) void {
-    zguiTextDisabled("%s", formatZ(fmt, args).ptr);
-}
-extern fn zguiTextDisabled(fmt: [*:0]const u8, ...) void;
-//--------------------------------------------------------------------------------------------------
-pub fn textWrapped(comptime fmt: []const u8, args: anytype) void {
-    zguiTextWrapped("%s", formatZ(fmt, args).ptr);
-}
-extern fn zguiTextWrapped(fmt: [*:0]const u8, ...) void;
-//--------------------------------------------------------------------------------------------------
-pub fn bulletText(comptime fmt: []const u8, args: anytype) void {
-    bullet();
-    text(fmt, args);
-}
-//--------------------------------------------------------------------------------------------------
-pub fn labelText(label: [:0]const u8, comptime fmt: []const u8, args: anytype) void {
-    zguiLabelText(label, "%s", formatZ(fmt, args).ptr);
-}
-extern fn zguiLabelText(label: [*:0]const u8, fmt: [*:0]const u8, ...) void;
-//--------------------------------------------------------------------------------------------------
-const CalcTextSize = struct {
-    hide_text_after_double_hash: bool = false,
-    wrap_width: f32 = -1.0,
-};
-pub fn calcTextSize(txt: []const u8, args: CalcTextSize) [2]f32 {
-    var w: f32 = undefined;
-    var h: f32 = undefined;
-    zguiCalcTextSize(
-        txt.ptr,
-        txt.ptr + txt.len,
-        args.hide_text_after_double_hash,
-        args.wrap_width,
-        &w,
-        &h,
-    );
-    return .{ w, h };
-}
-extern fn zguiCalcTextSize(
-    txt: [*]const u8,
-    txt_end: [*]const u8,
-    hide_text_after_double_hash: bool,
-    wrap_width: f32,
-    out_w: *f32,
-    out_h: *f32,
-) void;
-//--------------------------------------------------------------------------------------------------
-//
-// Widgets: Main
-//
-//--------------------------------------------------------------------------------------------------
-const Button = struct {
-    w: f32 = 0.0,
-    h: f32 = 0.0,
-};
-pub fn button(label: [:0]const u8, args: Button) bool {
-    return zguiButton(label, args.w, args.h);
-}
-extern fn zguiButton(label: [*:0]const u8, w: f32, h: f32) bool;
-//--------------------------------------------------------------------------------------------------
-pub fn smallButton(label: [:0]const u8) bool {
-    return zguiSmallButton(label);
-}
-extern fn zguiSmallButton(label: [*:0]const u8) bool;
-//--------------------------------------------------------------------------------------------------
-const InvisibleButton = struct {
-    w: f32,
-    h: f32,
-    flags: ButtonFlags = .{},
-};
-pub fn invisibleButton(str_id: [:0]const u8, args: InvisibleButton) bool {
-    return zguiInvisibleButton(str_id, args.w, args.h, args.flags);
-}
-extern fn zguiInvisibleButton(str_id: [*:0]const u8, w: f32, h: f32, flags: ButtonFlags) bool;
-//--------------------------------------------------------------------------------------------------
-const ArrowButton = struct {
-    dir: Direction,
-};
-pub fn arrowButton(label: [:0]const u8, args: ArrowButton) bool {
-    return zguiArrowButton(label, args.dir);
-}
-extern fn zguiArrowButton(label: [*:0]const u8, dir: Direction) bool;
-//--------------------------------------------------------------------------------------------------
-const Image = struct {
-    w: f32,
-    h: f32,
-    uv0: [2]f32 = .{ 0.0, 0.0 },
-    uv1: [2]f32 = .{ 1.0, 1.0 },
-    tint_col: [4]f32 = .{ 1.0, 1.0, 1.0, 1.0 },
-    border_col: [4]f32 = .{ 0.0, 0.0, 0.0, 0.0 },
-};
-pub fn image(user_texture_id: TextureIdent, args: Image) void {
-    zguiImage(user_texture_id, args.w, args.h, &args.uv0, &args.uv1, &args.tint_col, &args.border_col);
-}
-extern fn zguiImage(
-    user_texture_id: TextureIdent,
-    w: f32,
-    h: f32,
-    uv0: *const [2]f32,
-    uv1: *const [2]f32,
-    tint_col: *const [4]f32,
-    border_col: *const [4]f32,
-) void;
-//--------------------------------------------------------------------------------------------------
-const ImageButton = struct {
-    w: f32,
-    h: f32,
-    uv0: [2]f32 = .{ 0.0, 0.0 },
-    uv1: [2]f32 = .{ 1.0, 1.0 },
-    bg_col: [4]f32 = .{ 0.0, 0.0, 0.0, 0.0 },
-    tint_col: [4]f32 = .{ 1.0, 1.0, 1.0, 1.0 },
-};
-pub fn imageButton(str_id: [:0]const u8, user_texture_id: TextureIdent, args: ImageButton) bool {
-    return zguiImageButton(
-        str_id,
-        user_texture_id,
-        args.w,
-        args.h,
-        &args.uv0,
-        &args.uv1,
-        &args.bg_col,
-        &args.tint_col,
-    );
-}
-extern fn zguiImageButton(
-    str_id: [*:0]const u8,
-    user_texture_id: TextureIdent,
-    w: f32,
-    h: f32,
-    uv0: *const [2]f32,
-    uv1: *const [2]f32,
-    bg_col: *const [4]f32,
-    tint_col: *const [4]f32,
-) bool;
-//--------------------------------------------------------------------------------------------------
-/// `pub fn bullet() void`
-pub const bullet = zguiBullet;
-extern fn zguiBullet() void;
-//--------------------------------------------------------------------------------------------------
-pub fn radioButton(label: [:0]const u8, args: struct {
-    active: bool,
-}) bool {
-    return zguiRadioButton(label, args.active);
-}
-extern fn zguiRadioButton(label: [*:0]const u8, active: bool) bool;
-//--------------------------------------------------------------------------------------------------
-pub fn radioButtonStatePtr(label: [:0]const u8, args: struct {
-    v: *i32,
-    v_button: i32,
-}) bool {
-    return zguiRadioButtonStatePtr(label, args.v, args.v_button);
-}
-extern fn zguiRadioButtonStatePtr(label: [*:0]const u8, v: *c_int, v_button: c_int) bool;
-//--------------------------------------------------------------------------------------------------
-pub fn checkbox(label: [:0]const u8, args: struct {
-    v: *bool,
-}) bool {
-    return zguiCheckbox(label, args.v);
-}
-extern fn zguiCheckbox(label: [*:0]const u8, v: *bool) bool;
-//--------------------------------------------------------------------------------------------------
-pub fn checkboxBits(label: [:0]const u8, args: struct {
-    bits: *u32,
-    bits_value: u32,
-}) bool {
-    return zguiCheckboxBits(label, args.bits, args.bits_value);
-}
-extern fn zguiCheckboxBits(label: [*:0]const u8, bits: *c_uint, bits_value: c_uint) bool;
-//--------------------------------------------------------------------------------------------------
-const ProgressBar = struct {
-    fraction: f32,
-    w: f32 = -f32_min,
-    h: f32 = 0.0,
-    overlay: ?[:0]const u8 = null,
-};
-pub fn progressBar(args: ProgressBar) void {
-    zguiProgressBar(args.fraction, args.w, args.h, if (args.overlay) |o| o else null);
-}
-extern fn zguiProgressBar(fraction: f32, w: f32, h: f32, overlay: ?[*:0]const u8) void;
-//--------------------------------------------------------------------------------------------------
-//
-// Widgets: Combo Box
-//
-//--------------------------------------------------------------------------------------------------
-pub fn combo(label: [:0]const u8, args: struct {
-    current_item: *i32,
-    items_separated_by_zeros: [:0]const u8,
-    popup_max_height_in_items: i32 = -1,
-}) bool {
-    return zguiCombo(
-        label,
-        args.current_item,
-        args.items_separated_by_zeros,
-        args.popup_max_height_in_items,
-    );
-}
-/// creates a combo box directly from a pointer to an enum value using zig's
-/// comptime mechanics to infer the items for the list at compile time
-pub fn comboFromEnum(
-    label: [:0]const u8,
-    /// must be a pointer to an enum value (var my_enum: *FoodKinds = .Banana)
-    /// that is backed by some kind of integer that can safely cast into an
-    /// i32 (the underlying imgui restriction)
-    current_item: anytype,
-) bool {
-    const EnumType = @TypeOf(current_item.*);
-    const enum_type_info = switch (@typeInfo(EnumType)) {
-        .Enum => |enum_type_info| enum_type_info,
-        else => @compileError("Error: current_item must be a pointer-to-an-enum, not a " ++ @TypeOf(current_item)),
-    };
-
-    const FieldNameIndex = std.meta.Tuple(&.{ []const u8, i32 });
-    comptime var item_names: [:0]const u8 = "";
-    comptime var field_name_to_index_list: [enum_type_info.fields.len]FieldNameIndex = undefined;
-    comptime var index_to_enum: [enum_type_info.fields.len]EnumType = undefined;
-
-    comptime {
-        for (enum_type_info.fields, 0..) |f, i| {
-            item_names = item_names ++ f.name ++ "\x00";
-            const e: EnumType = @enumFromInt(f.value);
-            field_name_to_index_list[i] = .{ f.name, @intCast(i) };
-            index_to_enum[i] = e;
-        }
-    }
-
-    const field_name_to_index = std.StaticStringMap(i32).initComptime(&field_name_to_index_list);
-    var item: i32 = field_name_to_index.get(@tagName(current_item.*)).?;
-
-    const result = combo(label, .{
-        .items_separated_by_zeros = item_names,
-        .current_item = &item,
-    });
-
-    current_item.* = index_to_enum[@intCast(item)];
-
-    return result;
-}
-extern fn zguiCombo(
-    label: [*:0]const u8,
-    current_item: *c_int,
-    items_separated_by_zeros: [*:0]const u8,
-    popup_max_height_in_items: c_int,
-) bool;
-//--------------------------------------------------------------------------------------------------
-pub const ComboFlags = packed struct(c_int) {
-    popup_align_left: bool = false,
-    height_small: bool = false,
-    height_regular: bool = false,
-    height_large: bool = false,
-    height_largest: bool = false,
-    no_arrow_button: bool = false,
-    no_preview: bool = false,
-    width_fit_preview: bool = false,
-    _padding: u24 = 0,
-};
-//--------------------------------------------------------------------------------------------------
-const BeginCombo = struct {
-    preview_value: [*:0]const u8,
-    flags: ComboFlags = .{},
-};
-pub fn beginCombo(label: [:0]const u8, args: BeginCombo) bool {
-    return zguiBeginCombo(label, args.preview_value, args.flags);
-}
-extern fn zguiBeginCombo(label: [*:0]const u8, preview_value: ?[*:0]const u8, flags: ComboFlags) bool;
-//--------------------------------------------------------------------------------------------------
-/// `pub fn endCombo() void`
-pub const endCombo = zguiEndCombo;
-extern fn zguiEndCombo() void;
-//--------------------------------------------------------------------------------------------------
-//
-// Widgets: Drag Sliders
-//
-//--------------------------------------------------------------------------------------------------
-fn DragFloatGen(comptime T: type) type {
-    return struct {
-        v: *T,
-        speed: f32 = 1.0,
-        min: f32 = 0.0,
-        max: f32 = 0.0,
-        cfmt: [:0]const u8 = "%.3f",
-        flags: SliderFlags = .{},
-    };
-}
-//--------------------------------------------------------------------------------------------------
-const DragFloat = DragFloatGen(f32);
-pub fn dragFloat(label: [:0]const u8, args: DragFloat) bool {
-    return zguiDragFloat(
-        label,
-        args.v,
-        args.speed,
-        args.min,
-        args.max,
-        args.cfmt,
-        args.flags,
-    );
-}
-extern fn zguiDragFloat(
-    label: [*:0]const u8,
-    v: *f32,
-    speed: f32,
-    min: f32,
-    max: f32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-const DragFloat2 = DragFloatGen([2]f32);
-pub fn dragFloat2(label: [:0]const u8, args: DragFloat2) bool {
-    return zguiDragFloat2(label, args.v, args.speed, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiDragFloat2(
-    label: [*:0]const u8,
-    v: *[2]f32,
-    speed: f32,
-    min: f32,
-    max: f32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-const DragFloat3 = DragFloatGen([3]f32);
-pub fn dragFloat3(label: [:0]const u8, args: DragFloat3) bool {
-    return zguiDragFloat3(label, args.v, args.speed, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiDragFloat3(
-    label: [*:0]const u8,
-    v: *[3]f32,
-    speed: f32,
-    min: f32,
-    max: f32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-const DragFloat4 = DragFloatGen([4]f32);
-pub fn dragFloat4(label: [:0]const u8, args: DragFloat4) bool {
-    return zguiDragFloat4(label, args.v, args.speed, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiDragFloat4(
-    label: [*:0]const u8,
-    v: *[4]f32,
-    speed: f32,
-    min: f32,
-    max: f32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-const DragFloatRange2 = struct {
-    current_min: *f32,
-    current_max: *f32,
-    speed: f32 = 1.0,
-    min: f32 = 0.0,
-    max: f32 = 0.0,
-    cfmt: [:0]const u8 = "%.3f",
-    cfmt_max: ?[:0]const u8 = null,
-    flags: SliderFlags = .{},
-};
-pub fn dragFloatRange2(label: [:0]const u8, args: DragFloatRange2) bool {
-    return zguiDragFloatRange2(
-        label,
-        args.current_min,
-        args.current_max,
-        args.speed,
-        args.min,
-        args.max,
-        args.cfmt,
-        if (args.cfmt_max) |fm| fm else null,
-        args.flags,
-    );
-}
-extern fn zguiDragFloatRange2(
-    label: [*:0]const u8,
-    current_min: *f32,
-    current_max: *f32,
-    speed: f32,
-    min: f32,
-    max: f32,
-    cfmt: [*:0]const u8,
-    cfmt_max: ?[*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-fn DragIntGen(comptime T: type) type {
-    return struct {
-        v: *T,
-        speed: f32 = 1.0,
-        min: i32 = 0.0,
-        max: i32 = 0.0,
-        cfmt: [:0]const u8 = "%d",
-        flags: SliderFlags = .{},
-    };
-}
-//--------------------------------------------------------------------------------------------------
-const DragInt = DragIntGen(i32);
-pub fn dragInt(label: [:0]const u8, args: DragInt) bool {
-    return zguiDragInt(label, args.v, args.speed, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiDragInt(
-    label: [*:0]const u8,
-    v: *i32,
-    speed: f32,
-    min: i32,
-    max: i32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-const DragInt2 = DragIntGen([2]i32);
-pub fn dragInt2(label: [:0]const u8, args: DragInt2) bool {
-    return zguiDragInt2(label, args.v, args.speed, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiDragInt2(
-    label: [*:0]const u8,
-    v: *[2]i32,
-    speed: f32,
-    min: i32,
-    max: i32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-const DragInt3 = DragIntGen([3]i32);
-pub fn dragInt3(label: [:0]const u8, args: DragInt3) bool {
-    return zguiDragInt3(label, args.v, args.speed, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiDragInt3(
-    label: [*:0]const u8,
-    v: *[3]i32,
-    speed: f32,
-    min: i32,
-    max: i32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-const DragInt4 = DragIntGen([4]i32);
-pub fn dragInt4(label: [:0]const u8, args: DragInt4) bool {
-    return zguiDragInt4(label, args.v, args.speed, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiDragInt4(
-    label: [*:0]const u8,
-    v: *[4]i32,
-    speed: f32,
-    min: i32,
-    max: i32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-const DragIntRange2 = struct {
-    current_min: *i32,
-    current_max: *i32,
-    speed: f32 = 1.0,
-    min: i32 = 0.0,
-    max: i32 = 0.0,
-    cfmt: [:0]const u8 = "%d",
-    cfmt_max: ?[:0]const u8 = null,
-    flags: SliderFlags = .{},
-};
-pub fn dragIntRange2(label: [:0]const u8, args: DragIntRange2) bool {
-    return zguiDragIntRange2(
-        label,
-        args.current_min,
-        args.current_max,
-        args.speed,
-        args.min,
-        args.max,
-        args.cfmt,
-        if (args.cfmt_max) |fm| fm else null,
-        args.flags,
-    );
-}
-extern fn zguiDragIntRange2(
-    label: [*:0]const u8,
-    current_min: *i32,
-    current_max: *i32,
-    speed: f32,
-    min: i32,
-    max: i32,
-    cfmt: [*:0]const u8,
-    cfmt_max: ?[*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-fn DragScalarGen(comptime T: type) type {
-    return struct {
-        v: *T,
-        speed: f32 = 1.0,
-        min: ?T = null,
-        max: ?T = null,
-        cfmt: ?[:0]const u8 = null,
-        flags: SliderFlags = .{},
-    };
-}
-pub fn dragScalar(label: [:0]const u8, comptime T: type, args: DragScalarGen(T)) bool {
-    return zguiDragScalar(
-        label,
-        typeToDataTypeEnum(T),
-        args.v,
-        args.speed,
-        if (args.min) |vm| &vm else null,
-        if (args.max) |vm| &vm else null,
-        if (args.cfmt) |fmt| fmt else null,
-        args.flags,
-    );
-}
-extern fn zguiDragScalar(
-    label: [*:0]const u8,
-    data_type: DataType,
-    pdata: *anyopaque,
-    speed: f32,
-    pmin: ?*const anyopaque,
-    pmax: ?*const anyopaque,
-    cfmt: ?[*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-fn DragScalarNGen(comptime T: type) type {
-    const ScalarType = @typeInfo(T).Array.child;
-    return struct {
-        v: *T,
-        speed: f32 = 1.0,
-        min: ?ScalarType = null,
-        max: ?ScalarType = null,
-        cfmt: ?[:0]const u8 = null,
-        flags: SliderFlags = .{},
-    };
-}
-pub fn dragScalarN(label: [:0]const u8, comptime T: type, args: DragScalarNGen(T)) bool {
-    const ScalarType = @typeInfo(T).Array.child;
-    const components = @typeInfo(T).Array.len;
-    return zguiDragScalarN(
-        label,
-        typeToDataTypeEnum(ScalarType),
-        args.v,
-        components,
-        args.speed,
-        if (args.min) |vm| &vm else null,
-        if (args.max) |vm| &vm else null,
-        if (args.cfmt) |fmt| fmt else null,
-        args.flags,
-    );
-}
-extern fn zguiDragScalarN(
-    label: [*:0]const u8,
-    data_type: DataType,
-    pdata: *anyopaque,
-    components: i32,
-    speed: f32,
-    pmin: ?*const anyopaque,
-    pmax: ?*const anyopaque,
-    cfmt: ?[*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-//
-// Widgets: Regular Sliders
-//
-//--------------------------------------------------------------------------------------------------
-fn SliderFloatGen(comptime T: type) type {
-    return struct {
-        v: *T,
-        min: f32,
-        max: f32,
-        cfmt: [:0]const u8 = "%.3f",
-        flags: SliderFlags = .{},
-    };
-}
-
-pub fn sliderFloat(label: [:0]const u8, args: SliderFloatGen(f32)) bool {
-    return zguiSliderFloat(label, args.v, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiSliderFloat(
-    label: [*:0]const u8,
-    v: *f32,
-    min: f32,
-    max: f32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-
-pub fn sliderFloat2(label: [:0]const u8, args: SliderFloatGen([2]f32)) bool {
-    return zguiSliderFloat2(label, args.v, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiSliderFloat2(
-    label: [*:0]const u8,
-    v: *[2]f32,
-    min: f32,
-    max: f32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-
-pub fn sliderFloat3(label: [:0]const u8, args: SliderFloatGen([3]f32)) bool {
-    return zguiSliderFloat3(label, args.v, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiSliderFloat3(
-    label: [*:0]const u8,
-    v: *[3]f32,
-    min: f32,
-    max: f32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-
-pub fn sliderFloat4(label: [:0]const u8, args: SliderFloatGen([4]f32)) bool {
-    return zguiSliderFloat4(label, args.v, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiSliderFloat4(
-    label: [*:0]const u8,
-    v: *[4]f32,
-    min: f32,
-    max: f32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-
-//--------------------------------------------------------------------------------------------------
-fn SliderIntGen(comptime T: type) type {
-    return struct {
-        v: *T,
-        min: i32,
-        max: i32,
-        cfmt: [:0]const u8 = "%d",
-        flags: SliderFlags = .{},
-    };
-}
-
-pub fn sliderInt(label: [:0]const u8, args: SliderIntGen(i32)) bool {
-    return zguiSliderInt(label, args.v, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiSliderInt(
-    label: [*:0]const u8,
-    v: *c_int,
-    min: c_int,
-    max: c_int,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-
-pub fn sliderInt2(label: [:0]const u8, args: SliderIntGen([2]i32)) bool {
-    return zguiSliderInt2(label, args.v, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiSliderInt2(
-    label: [*:0]const u8,
-    v: *[2]c_int,
-    min: c_int,
-    max: c_int,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-
-pub fn sliderInt3(label: [:0]const u8, args: SliderIntGen([3]i32)) bool {
-    return zguiSliderInt3(label, args.v, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiSliderInt3(
-    label: [*:0]const u8,
-    v: *[3]c_int,
-    min: c_int,
-    max: c_int,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-
-pub fn sliderInt4(label: [:0]const u8, args: SliderIntGen([4]i32)) bool {
-    return zguiSliderInt4(label, args.v, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiSliderInt4(
-    label: [*:0]const u8,
-    v: *[4]c_int,
-    min: c_int,
-    max: c_int,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-
-//--------------------------------------------------------------------------------------------------
-fn SliderScalarGen(comptime T: type) type {
-    return struct {
-        v: *T,
-        min: T,
-        max: T,
-        cfmt: ?[:0]const u8 = null,
-        flags: SliderFlags = .{},
-    };
-}
-pub fn sliderScalar(label: [:0]const u8, comptime T: type, args: SliderScalarGen(T)) bool {
-    return zguiSliderScalar(
-        label,
-        typeToDataTypeEnum(T),
-        args.v,
-        &args.min,
-        &args.max,
-        if (args.cfmt) |fmt| fmt else null,
-        args.flags,
-    );
-}
-extern fn zguiSliderScalar(
-    label: [*:0]const u8,
-    data_type: DataType,
-    pdata: *anyopaque,
-    pmin: *const anyopaque,
-    pmax: *const anyopaque,
-    cfmt: ?[*:0]const u8,
-    flags: SliderFlags,
-) bool;
-
-//--------------------------------------------------------------------------------------------------
-fn SliderScalarNGen(comptime T: type) type {
-    const ScalarType = @typeInfo(T).Array.child;
-    return struct {
-        v: *T,
-        min: ScalarType,
-        max: ScalarType,
-        cfmt: ?[:0]const u8 = null,
-        flags: SliderFlags = .{},
-    };
-}
-pub fn sliderScalarN(label: [:0]const u8, comptime T: type, args: SliderScalarNGen(T)) bool {
-    const ScalarType = @typeInfo(T).Array.child;
-    const components = @typeInfo(T).Array.len;
-    return zguiSliderScalarN(
-        label,
-        typeToDataTypeEnum(ScalarType),
-        args.v,
-        components,
-        &args.min,
-        &args.max,
-        if (args.cfmt) |fmt| fmt else null,
-        args.flags,
-    );
-}
-extern fn zguiSliderScalarN(
-    label: [*:0]const u8,
-    data_type: DataType,
-    pdata: *anyopaque,
-    components: i32,
-    pmin: *const anyopaque,
-    pmax: *const anyopaque,
-    cfmt: ?[*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-pub fn vsliderFloat(label: [:0]const u8, args: struct {
-    w: f32,
-    h: f32,
-    v: *f32,
-    min: f32,
-    max: f32,
-    cfmt: [:0]const u8 = "%.3f",
-    flags: SliderFlags = .{},
-}) bool {
-    return zguiVSliderFloat(
-        label,
-        args.w,
-        args.h,
-        args.v,
-        args.min,
-        args.max,
-        args.cfmt,
-        args.flags,
-    );
-}
-extern fn zguiVSliderFloat(
-    label: [*:0]const u8,
-    w: f32,
-    h: f32,
-    v: *f32,
-    min: f32,
-    max: f32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-pub fn vsliderInt(label: [:0]const u8, args: struct {
-    w: f32,
-    h: f32,
-    v: *i32,
-    min: i32,
-    max: i32,
-    cfmt: [:0]const u8 = "%d",
-    flags: SliderFlags = .{},
-}) bool {
-    return zguiVSliderInt(label, args.w, args.h, args.v, args.min, args.max, args.cfmt, args.flags);
-}
-extern fn zguiVSliderInt(
-    label: [*:0]const u8,
-    w: f32,
-    h: f32,
-    v: *i32,
-    min: c_int,
-    max: c_int,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-fn VSliderScalarGen(comptime T: type) type {
-    return struct {
-        w: f32,
-        h: f32,
-        v: *T,
-        min: T,
-        max: T,
-        cfmt: ?[:0]const u8 = null,
-        flags: SliderFlags = .{},
-    };
-}
-pub fn vsliderScalar(label: [:0]const u8, comptime T: type, args: VSliderScalarGen(T)) bool {
-    return zguiVSliderScalar(
-        label,
-        args.w,
-        args.h,
-        typeToDataTypeEnum(T),
-        args.v,
-        &args.min,
-        &args.max,
-        if (args.cfmt) |fmt| fmt else null,
-        args.flags,
-    );
-}
-extern fn zguiVSliderScalar(
-    label: [*:0]const u8,
-    w: f32,
-    h: f32,
-    data_type: DataType,
-    pdata: *anyopaque,
-    pmin: *const anyopaque,
-    pmax: *const anyopaque,
-    cfmt: ?[*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-const SliderAngle = struct {
-    vrad: *f32,
-    deg_min: f32 = -360.0,
-    deg_max: f32 = 360.0,
-    cfmt: [:0]const u8 = "%.0f deg",
-    flags: SliderFlags = .{},
-};
-pub fn sliderAngle(label: [:0]const u8, args: SliderAngle) bool {
-    return zguiSliderAngle(
-        label,
-        args.vrad,
-        args.deg_min,
-        args.deg_max,
-        args.cfmt,
-        args.flags,
-    );
-}
-extern fn zguiSliderAngle(
-    label: [*:0]const u8,
-    vrad: *f32,
-    deg_min: f32,
-    deg_max: f32,
-    cfmt: [*:0]const u8,
-    flags: SliderFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-//
-// Widgets: Input with Keyboard
-//
-//--------------------------------------------------------------------------------------------------
-pub const InputTextFlags = packed struct(c_int) {
-    chars_decimal: bool = false,
-    chars_hexadecimal: bool = false,
-    chars_uppercase: bool = false,
-    chars_no_blank: bool = false,
-    auto_select_all: bool = false,
-    enter_returns_true: bool = false,
-    callback_completion: bool = false,
-    callback_history: bool = false,
-    callback_always: bool = false,
-    callback_char_filter: bool = false,
-    allow_tab_input: bool = false,
-    ctrl_enter_for_new_line: bool = false,
-    no_horizontal_scroll: bool = false,
-    always_overwrite: bool = false,
-    read_only: bool = false,
-    password: bool = false,
-    no_undo_redo: bool = false,
-    chars_scientific: bool = false,
-    callback_resize: bool = false,
-    callback_edit: bool = false,
-    escape_clears_all: bool = false,
-    _padding: u11 = 0,
-};
-//--------------------------------------------------------------------------------------------------
-pub const InputTextCallbackData = extern struct {
-    ctx: *Context,
-    event_flag: InputTextFlags,
-    flags: InputTextFlags,
-    user_data: ?*anyopaque,
-    event_char: Wchar,
-    event_key: Key,
-    buf: [*]u8,
-    buf_text_len: i32,
-    buf_size: i32,
-    buf_dirty: bool,
-    cursor_pos: i32,
-    selection_start: i32,
-    selection_end: i32,
-
-    /// `pub fn init() InputTextCallbackData`
-    pub const init = zguiInputTextCallbackData_Init;
-    extern fn zguiInputTextCallbackData_Init() InputTextCallbackData;
-
-    /// `pub fn deleteChars(data: *InputTextCallbackData, pos: i32, bytes_count: i32) void`
-    pub const deleteChars = zguiInputTextCallbackData_DeleteChars;
-    extern fn zguiInputTextCallbackData_DeleteChars(
-        data: *InputTextCallbackData,
-        pos: c_int,
-        bytes_count: c_int,
-    ) void;
-
-    pub fn insertChars(data: *InputTextCallbackData, pos: i32, txt: []const u8) void {
-        zguiInputTextCallbackData_InsertChars(data, pos, txt.ptr, txt.ptr + txt.len);
-    }
-    extern fn zguiInputTextCallbackData_InsertChars(
-        data: *InputTextCallbackData,
-        pos: c_int,
-        text: [*]const u8,
-        text_end: [*]const u8,
-    ) void;
-
-    pub fn selectAll(data: *InputTextCallbackData) void {
-        data.selection_start = 0;
-        data.selection_end = data.buf_text_len;
-    }
-
-    pub fn clearSelection(data: *InputTextCallbackData) void {
-        data.selection_start = data.buf_text_len;
-        data.selection_end = data.buf_text_len;
-    }
-
-    pub fn hasSelection(data: InputTextCallbackData) bool {
-        return data.selection_start != data.selection_end;
-    }
-};
-
-pub const InputTextCallback = *const fn (data: *InputTextCallbackData) i32;
-//--------------------------------------------------------------------------------------------------
-pub fn inputText(label: [:0]const u8, args: struct {
-    buf: [:0]u8,
-    flags: InputTextFlags = .{},
-    callback: ?InputTextCallback = null,
-    user_data: ?*anyopaque = null,
-}) bool {
-    return zguiInputText(
-        label,
-        args.buf.ptr,
-        args.buf.len + 1, // + 1 for sentinel
-        args.flags,
-        if (args.callback) |cb| cb else null,
-        args.user_data,
-    );
-}
-extern fn zguiInputText(
-    label: [*:0]const u8,
-    buf: [*]u8,
-    buf_size: usize,
-    flags: InputTextFlags,
-    callback: ?*const anyopaque,
-    user_data: ?*anyopaque,
-) bool;
-//--------------------------------------------------------------------------------------------------
-pub fn inputTextMultiline(label: [:0]const u8, args: struct {
-    buf: [:0]u8,
-    w: f32 = 0.0,
-    h: f32 = 0.0,
-    flags: InputTextFlags = .{},
-    callback: ?InputTextCallback = null,
-    user_data: ?*anyopaque = null,
-}) bool {
-    return zguiInputTextMultiline(
-        label,
-        args.buf.ptr,
-        args.buf.len + 1, // + 1 for sentinel
-        args.w,
-        args.h,
-        args.flags,
-        if (args.callback) |cb| cb else null,
-        args.user_data,
-    );
-}
-extern fn zguiInputTextMultiline(
-    label: [*:0]const u8,
-    buf: [*]u8,
-    buf_size: usize,
-    w: f32,
-    h: f32,
-    flags: InputTextFlags,
-    callback: ?*const anyopaque,
-    user_data: ?*anyopaque,
-) bool;
-//--------------------------------------------------------------------------------------------------
-pub fn inputTextWithHint(label: [:0]const u8, args: struct {
-    hint: [:0]const u8,
-    buf: [:0]u8,
-    flags: InputTextFlags = .{},
-    callback: ?InputTextCallback = null,
-    user_data: ?*anyopaque = null,
-}) bool {
-    return zguiInputTextWithHint(
-        label,
-        args.hint,
-        args.buf.ptr,
-        args.buf.len + 1, // + 1 for sentinel
-        args.flags,
-        if (args.callback) |cb| cb else null,
-        args.user_data,
-    );
-}
-extern fn zguiInputTextWithHint(
-    label: [*:0]const u8,
-    hint: [*:0]const u8,
-    buf: [*]u8,
-    buf_size: usize,
-    flags: InputTextFlags,
-    callback: ?*const anyopaque,
-    user_data: ?*anyopaque,
-) bool;
-//--------------------------------------------------------------------------------------------------
-pub fn inputFloat(label: [:0]const u8, args: struct {
-    v: *f32,
-    step: f32 = 0.0,
-    step_fast: f32 = 0.0,
-    cfmt: [:0]const u8 = "%.3f",
-    flags: InputTextFlags = .{},
-}) bool {
-    return zguiInputFloat(
-        label,
-        args.v,
-        args.step,
-        args.step_fast,
-        args.cfmt,
-        args.flags,
-    );
-}
-extern fn zguiInputFloat(
-    label: [*:0]const u8,
-    v: *f32,
-    step: f32,
-    step_fast: f32,
-    cfmt: [*:0]const u8,
-    flags: InputTextFlags,
-) bool;
-
-//--------------------------------------------------------------------------------------------------
-fn InputFloatGen(comptime T: type) type {
-    return struct {
-        v: *T,
-        cfmt: [:0]const u8 = "%.3f",
-        flags: InputTextFlags = .{},
-    };
-}
-pub fn inputFloat2(label: [:0]const u8, args: InputFloatGen([2]f32)) bool {
-    return zguiInputFloat2(label, args.v, args.cfmt, args.flags);
-}
-extern fn zguiInputFloat2(
-    label: [*:0]const u8,
-    v: *[2]f32,
-    cfmt: [*:0]const u8,
-    flags: InputTextFlags,
-) bool;
-
-pub fn inputFloat3(label: [:0]const u8, args: InputFloatGen([3]f32)) bool {
-    return zguiInputFloat3(label, args.v, args.cfmt, args.flags);
-}
-extern fn zguiInputFloat3(
-    label: [*:0]const u8,
-    v: *[3]f32,
-    cfmt: [*:0]const u8,
-    flags: InputTextFlags,
-) bool;
-
-pub fn inputFloat4(label: [:0]const u8, args: InputFloatGen([4]f32)) bool {
-    return zguiInputFloat4(label, args.v, args.cfmt, args.flags);
-}
-extern fn zguiInputFloat4(
-    label: [*:0]const u8,
-    v: *[4]f32,
-    cfmt: [*:0]const u8,
-    flags: InputTextFlags,
-) bool;
-
-//--------------------------------------------------------------------------------------------------
-pub fn inputInt(label: [:0]const u8, args: struct {
-    v: *i32,
-    step: i32 = 1,
-    step_fast: i32 = 100,
-    flags: InputTextFlags = .{},
-}) bool {
-    return zguiInputInt(label, args.v, args.step, args.step_fast, args.flags);
-}
-extern fn zguiInputInt(
-    label: [*:0]const u8,
-    v: *c_int,
-    step: c_int,
-    step_fast: c_int,
-    flags: InputTextFlags,
-) bool;
-
-//--------------------------------------------------------------------------------------------------
-fn InputIntGen(comptime T: type) type {
-    return struct {
-        v: *T,
-        flags: InputTextFlags = .{},
-    };
-}
-pub fn inputInt2(label: [:0]const u8, args: InputIntGen([2]i32)) bool {
-    return zguiInputInt2(label, args.v, args.flags);
-}
-extern fn zguiInputInt2(label: [*:0]const u8, v: *[2]c_int, flags: InputTextFlags) bool;
-
-pub fn inputInt3(label: [:0]const u8, args: InputIntGen([3]i32)) bool {
-    return zguiInputInt3(label, args.v, args.flags);
-}
-extern fn zguiInputInt3(label: [*:0]const u8, v: *[3]c_int, flags: InputTextFlags) bool;
-
-pub fn inputInt4(label: [:0]const u8, args: InputIntGen([4]i32)) bool {
-    return zguiInputInt4(label, args.v, args.flags);
-}
-extern fn zguiInputInt4(label: [*:0]const u8, v: *[4]c_int, flags: InputTextFlags) bool;
-
-//--------------------------------------------------------------------------------------------------
-const InputDouble = struct {
-    v: *f64,
-    step: f64 = 0.0,
-    step_fast: f64 = 0.0,
-    cfmt: [:0]const u8 = "%.6f",
-    flags: InputTextFlags = .{},
-};
-pub fn inputDouble(label: [:0]const u8, args: InputDouble) bool {
-    return zguiInputDouble(label, args.v, args.step, args.step_fast, args.cfmt, args.flags);
-}
-extern fn zguiInputDouble(
-    label: [*:0]const u8,
-    v: *f64,
-    step: f64,
-    step_fast: f64,
-    cfmt: [*:0]const u8,
-    flags: InputTextFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-fn InputScalarGen(comptime T: type) type {
-    return struct {
-        v: *T,
-        step: ?T = null,
-        step_fast: ?T = null,
-        cfmt: ?[:0]const u8 = null,
-        flags: InputTextFlags = .{},
-    };
-}
-pub fn inputScalar(label: [:0]const u8, comptime T: type, args: InputScalarGen(T)) bool {
-    return zguiInputScalar(
-        label,
-        typeToDataTypeEnum(T),
-        args.v,
-        if (args.step) |s| &s else null,
-        if (args.step_fast) |sf| &sf else null,
-        if (args.cfmt) |fmt| fmt else null,
-        args.flags,
-    );
-}
-extern fn zguiInputScalar(
-    label: [*:0]const u8,
-    data_type: DataType,
-    pdata: *anyopaque,
-    pstep: ?*const anyopaque,
-    pstep_fast: ?*const anyopaque,
-    cfmt: ?[*:0]const u8,
-    flags: InputTextFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-fn InputScalarNGen(comptime T: type) type {
-    const ScalarType = @typeInfo(T).Array.child;
-    return struct {
-        v: *T,
-        step: ?ScalarType = null,
-        step_fast: ?ScalarType = null,
-        cfmt: ?[:0]const u8 = null,
-        flags: InputTextFlags = .{},
-    };
-}
-pub fn inputScalarN(label: [:0]const u8, comptime T: type, args: InputScalarNGen(T)) bool {
-    const ScalarType = @typeInfo(T).Array.child;
-    const components = @typeInfo(T).Array.len;
-    return zguiInputScalarN(
-        label,
-        typeToDataTypeEnum(ScalarType),
-        args.v,
-        components,
-        if (args.step) |s| &s else null,
-        if (args.step_fast) |sf| &sf else null,
-        if (args.cfmt) |fmt| fmt else null,
-        args.flags,
-    );
-}
-extern fn zguiInputScalarN(
-    label: [*:0]const u8,
-    data_type: DataType,
-    pdata: *anyopaque,
-    components: i32,
-    pstep: ?*const anyopaque,
-    pstep_fast: ?*const anyopaque,
-    cfmt: ?[*:0]const u8,
-    flags: InputTextFlags,
-) bool;
-//--------------------------------------------------------------------------------------------------
-//
-// Widgets: Color Editor/Picker
-//
-//--------------------------------------------------------------------------------------------------
-pub const ColorEditFlags = packed struct(c_int) {
-    _reserved0: bool = false,
-    no_alpha: bool = false,
-    no_picker: bool = false,
-    no_options: bool = false,
-    no_small_preview: bool = false,
-    no_inputs: bool = false,
-    no_tooltip: bool = false,
-    no_label: bool = false,
-    no_side_preview: bool = false,
-    no_drag_drop: bool = false,
-    no_border: bool = false,
-
-    _reserved1: bool = false,
-    _reserved2: bool = false,
-    _reserved3: bool = false,
-    _reserved4: bool = false,
-    _reserved5: bool = false,
-
-    alpha_bar: bool = false,
-    alpha_preview: bool = false,
-    alpha_preview_half: bool = false,
-    hdr: bool = false,
-    display_rgb: bool = false,
-    display_hsv: bool = false,
-    display_hex: bool = false,
-    uint8: bool = false,
-    float: bool = false,
-    picker_hue_bar: bool = false,
-    picker_hue_wheel: bool = false,
-    input_rgb: bool = false,
-    input_hsv: bool = false,
-
-    _padding: u3 = 0,
-
-    pub const default_options = ColorEditFlags{
-        .uint8 = true,
-        .display_rgb = true,
-        .input_rgb = true,
-        .picker_hue_bar = true,
-    };
-};
-//--------------------------------------------------------------------------------------------------
-const ColorEdit3 = struct {
-    col: *[3]f32,
-    flags: ColorEditFlags = .{},
-};
-pub fn colorEdit3(label: [:0]const u8, args: ColorEdit3) bool {
-    return zguiColorEdit3(label, args.col, args.flags);
-}
-extern fn zguiColorEdit3(label: [*:0]const u8, col: *[3]f32, flags: ColorEditFlags) bool;
-//--------------------------------------------------------------------------------------------------
-const ColorEdit4 = struct {
-    col: *[4]f32,
-    flags: ColorEditFlags = .{},
-};
-pub fn colorEdit4(label: [:0]const u8, args: ColorEdit4) bool {
-    return zguiColorEdit4(label, args.col, args.flags);
-}
-extern fn zguiColorEdit4(label: [*:0]const u8, col: *[4]f32, flags: ColorEditFlags) bool;
-//--------------------------------------------------------------------------------------------------
-const ColorPicker3 = struct {
-    col: *[3]f32,
-    flags: ColorEditFlags = .{},
-};
-pub fn colorPicker3(label: [:0]const u8, args: ColorPicker3) bool {
-    return zguiColorPicker3(label, args.col, args.flags);
-}
-extern fn zguiColorPicker3(label: [*:0]const u8, col: *[3]f32, flags: ColorEditFlags) bool;
-//--------------------------------------------------------------------------------------------------
-const ColorPicker4 = struct {
-    col: *[4]f32,
-    flags: ColorEditFlags = .{},
-    ref_col: ?[*]const f32 = null,
-};
-pub fn colorPicker4(label: [:0]const u8, args: ColorPicker4) bool {
-    return zguiColorPicker4(
-        label,
-        args.col,
-        args.flags,
-        if (args.ref_col) |rc| rc else null,
-    );
-}
-extern fn zguiColorPicker4(
-    label: [*:0]const u8,
-    col: *[4]f32,
-    flags: ColorEditFlags,
-    ref_col: ?[*]const f32,
-) bool;
-//--------------------------------------------------------------------------------------------------
-const ColorButton = struct {
-    col: [4]f32,
-    flags: ColorEditFlags = .{},
-    w: f32 = 0.0,
-    h: f32 = 0.0,
-};
-pub fn colorButton(desc_id: [:0]const u8, args: ColorButton) bool {
-    return zguiColorButton(desc_id, &args.col, args.flags, args.w, args.h);
-}
-extern fn zguiColorButton(
-    desc_id: [*:0]const u8,
-    col: *const [4]f32,
-    flags: ColorEditFlags,
-    w: f32,
-    h: f32,
-) bool;
-//--------------------------------------------------------------------------------------------------
-//
-// Widgets: Trees
-//
-//--------------------------------------------------------------------------------------------------
-pub const TreeNodeFlags = packed struct(c_int) {
-    selected: bool = false,
-    framed: bool = false,
-    allow_overlap: bool = false,
-    no_tree_push_on_open: bool = false,
-    no_auto_open_on_log: bool = false,
-    default_open: bool = false,
-    open_on_double_click: bool = false,
-    open_on_arrow: bool = false,
-    leaf: bool = false,
-    bullet: bool = false,
-    frame_padding: bool = false,
-    span_avail_width: bool = false,
-    span_full_width: bool = false,
-    span_all_columns: bool = false,
-    nav_left_jumps_back_here: bool = false,
-    _padding: u17 = 0,
-
-    pub const collapsing_header = TreeNodeFlags{
-        .framed = true,
-        .no_tree_push_on_open = true,
-        .no_auto_open_on_log = true,
-    };
-};
-//--------------------------------------------------------------------------------------------------
-pub fn treeNode(label: [:0]const u8) bool {
-    return zguiTreeNode(label);
-}
-pub fn treeNodeFlags(label: [:0]const u8, flags: TreeNodeFlags) bool {
-    return zguiTreeNodeFlags(label, flags);
-}
-extern fn zguiTreeNode(label: [*:0]const u8) bool;
-extern fn zguiTreeNodeFlags(label: [*:0]const u8, flags: TreeNodeFlags) bool;
-//--------------------------------------------------------------------------------------------------
-pub fn treeNodeStrId(str_id: [:0]const u8, comptime fmt: []const u8, args: anytype) bool {
-    return zguiTreeNodeStrId(str_id, "%s", formatZ(fmt, args).ptr);
-}
-pub fn treeNodeStrIdFlags(
-    str_id: [:0]const u8,
-    flags: TreeNodeFlags,
-    comptime fmt: []const u8,
-    args: anytype,
-) bool {
-    return zguiTreeNodeStrIdFlags(str_id, flags, "%s", formatZ(fmt, args).ptr);
-}
-extern fn zguiTreeNodeStrId(str_id: [*:0]const u8, fmt: [*:0]const u8, ...) bool;
-extern fn zguiTreeNodeStrIdFlags(
-    str_id: [*:0]const u8,
-    flags: TreeNodeFlags,
-    fmt: [*:0]const u8,
-    ...,
-) bool;
-//--------------------------------------------------------------------------------------------------
-pub fn treeNodePtrId(ptr_id: *const anyopaque, comptime fmt: []const u8, args: anytype) bool {
-    return zguiTreeNodePtrId(ptr_id, "%s", formatZ(fmt, args).ptr);
-}
-pub fn treeNodePtrIdFlags(
-    ptr_id: *const anyopaque,
-    flags: TreeNodeFlags,
-    comptime fmt: []const u8,
-    args: anytype,
-) bool {
-    return zguiTreeNodePtrIdFlags(ptr_id, flags, "%s", formatZ(fmt, args).ptr);
-}
-extern fn zguiTreeNodePtrId(ptr_id: *const anyopaque, fmt: [*:0]const u8, ...) bool;
-extern fn zguiTreeNodePtrIdFlags(
-    ptr_id: *const anyopaque,
-    flags: TreeNodeFlags,
-    fmt: [*:0]const u8,
-    ...,
-) bool;
-//--------------------------------------------------------------------------------------------------
-pub fn treePushStrId(str_id: [:0]const u8) void {
-    zguiTreePushStrId(str_id);
-}
-pub fn treePushPtrId(ptr_id: *const anyopaque) void {
-    zguiTreePushPtrId(ptr_id);
-}
-extern fn zguiTreePushStrId(str_id: [*:0]const u8) void;
-extern fn zguiTreePushPtrId(ptr_id: *const anyopaque) void;
-//--------------------------------------------------------------------------------------------------
-/// `pub fn treePop() void`
-pub const treePop = zguiTreePop;
-extern fn zguiTreePop() void;
-//--------------------------------------------------------------------------------------------------
-const CollapsingHeaderStatePtr = struct {
-    pvisible: *bool,
-    flags: TreeNodeFlags = .{},
-};
-pub fn collapsingHeader(label: [:0]const u8, flags: TreeNodeFlags) bool {
-    return zguiCollapsingHeader(label, flags);
-}
-pub fn collapsingHeaderStatePtr(label: [:0]const u8, args: CollapsingHeaderStatePtr) bool {
-    return zguiCollapsingHeaderStatePtr(label, args.pvisible, args.flags);
-}
-extern fn zguiCollapsingHeader(label: [*:0]const u8, flags: TreeNodeFlags) bool;
-extern fn zguiCollapsingHeaderStatePtr(label: [*:0]const u8, pvisible: *bool, flags: TreeNodeFlags) bool;
-//--------------------------------------------------------------------------------------------------
-const SetNextItemOpen = struct {
-    is_open: bool,
-    cond: Condition = .none,
-};
-pub fn setNextItemOpen(args: SetNextItemOpen) void {
-    zguiSetNextItemOpen(args.is_open, args.cond);
-}
-extern fn zguiSetNextItemOpen(is_open: bool, cond: Condition) void;
-//--------------------------------------------------------------------------------------------------
-//
-// Selectables
-//
-//--------------------------------------------------------------------------------------------------
-pub const SelectableFlags = packed struct(c_int) {
-    dont_close_popups: bool = false,
-    span_all_columns: bool = false,
-    allow_double_click: bool = false,
-    disabled: bool = false,
-    allow_overlap: bool = false,
-    _padding: u27 = 0,
-};
-//--------------------------------------------------------------------------------------------------
-const Selectable = struct {
-    selected: bool = false,
-    flags: SelectableFlags = .{},
-    w: f32 = 0,
-    h: f32 = 0,
-};
-pub fn selectable(label: [:0]const u8, args: Selectable) bool {
-    return zguiSelectable(label, args.selected, args.flags, args.w, args.h);
-}
-extern fn zguiSelectable(
-    label: [*:0]const u8,
-    selected: bool,
-    flags: SelectableFlags,
-    w: f32,
-    h: f32,
-) bool;
-//--------------------------------------------------------------------------------------------------
-const SelectableStatePtr = struct {
-    pselected: *bool,
-    flags: SelectableFlags = .{},
-    w: f32 = 0,
-    h: f32 = 0,
-};
-pub fn selectableStatePtr(label: [:0]const u8, args: SelectableStatePtr) bool {
-    return zguiSelectableStatePtr(label, args.pselected, args.flags, args.w, args.h);
-}
-extern fn zguiSelectableStatePtr(
-    label: [*:0]const u8,
-    pselected: *bool,
-    flags: SelectableFlags,
-    w: f32,
-    h: f32,
-) bool;
-//--------------------------------------------------------------------------------------------------
-//
-// Widgets: List Boxes
-//
-//--------------------------------------------------------------------------------------------------
-const BeginListBox = struct {
-    w: f32 = 0.0,
-    h: f32 = 0.0,
-};
-pub fn beginListBox(label: [:0]const u8, args: BeginListBox) bool {
-    return zguiBeginListBox(label, args.w, args.h);
-}
-/// `pub fn endListBox() void`
-pub const endListBox = zguiEndListBox;
-extern fn zguiBeginListBox(label: [*:0]const u8, w: f32, h: f32) bool;
-extern fn zguiEndListBox() void;
-//--------------------------------------------------------------------------------------------------
-//
-// Widgets: Tables
-//
-//--------------------------------------------------------------------------------------------------
-pub const TableBorderFlags = packed struct(u4) {
-    inner_h: bool = false,
-    outer_h: bool = false,
-    inner_v: bool = false,
-    outer_v: bool = false,
-
-    pub const h = TableBorderFlags{
-        .inner_h = true,
-        .outer_h = true,
-    }; // Draw horizontal borders.
-    pub const v = TableBorderFlags{
-        .inner_v = true,
-        .outer_v = true,
-    }; // Draw vertical borders.
-    pub const inner = TableBorderFlags{
-        .inner_v = true,
-        .inner_h = true,
-    }; // Draw inner borders.
-    pub const outer = TableBorderFlags{
-        .outer_v = true,
-        .outer_h = true,
-    }; // Draw outer borders.
-    pub const all = TableBorderFlags{
-        .inner_v = true,
-        .inner_h = true,
-        .outer_v = true,
-        .outer_h = true,
-    }; // Draw all borders.
-};
-pub const TableFlags = packed struct(c_int) {
-    resizable: bool = false,
-    reorderable: bool = false,
-    hideable: bool = false,
-    sortable: bool = false,
-    no_saved_settings: bool = false,
-    context_menu_in_body: bool = false,
-    row_bg: bool = false,
-    borders: TableBorderFlags = .{},
-    no_borders_in_body: bool = false,
-    no_borders_in_body_until_resize: bool = false,
-
-    // Sizing Policy
-    sizing: enum(u3) {
-        none = 0,
-        fixed_fit = 1,
-        fixed_same = 2,
-        stretch_prop = 3,
-        stretch_same = 4,
-    } = .none,
-
-    // Sizing Extra Options
-    no_host_extend_x: bool = false,
-    no_host_extend_y: bool = false,
-    no_keep_columns_visible: bool = false,
-    precise_widths: bool = false,
-
-    // Clipping
-    no_clip: bool = false,
-
-    // Padding
-    pad_outer_x: bool = false,
-    no_pad_outer_x: bool = false,
-    no_pad_inner_x: bool = false,
-
-    // Scrolling
-    scroll_x: bool = false,
-    scroll_y: bool = false,
-
-    // Sorting
-    sort_multi: bool = false,
-    sort_tristate: bool = false,
-
-    _padding: u4 = 0,
-};
-
-pub const TableRowFlags = packed struct(c_int) {
-    headers: bool = false,
-
-    _padding: u31 = 0,
-};
-
-pub const TableColumnFlags = packed struct(c_int) {
-    // Input configuration flags
-    disabled: bool = false,
-    default_hide: bool = false,
-    default_sort: bool = false,
-    width_stretch: bool = false,
-    width_fixed: bool = false,
-    no_resize: bool = false,
-    no_reorder: bool = false,
-    no_hide: bool = false,
-    no_clip: bool = false,
-    no_sort: bool = false,
-    no_sort_ascending: bool = false,
-    no_sort_descending: bool = false,
-    no_header_label: bool = false,
-    no_header_width: bool = false,
-    prefer_sort_ascending: bool = false,
-    prefer_sort_descending: bool = false,
-    indent_enable: bool = false,
-    indent_disable: bool = false,
-
-    _padding0: u6 = 0,
-
-    // Output status flags, read-only via TableGetColumnFlags()
-    is_enabled: bool = false,
-    is_visible: bool = false,
-    is_sorted: bool = false,
-    is_hovered: bool = false,
-
-    _padding1: u4 = 0,
-};
-
-pub const TableColumnSortSpecs = extern struct {
-    user_id: Ident,
-    index: i16,
-    sort_order: i16,
-    sort_direction: enum(u8) {
-        none = 0,
-        ascending = 1, // Ascending = 0->9, A->Z etc.
-        descending = 2, // Descending = 9->0, Z->A etc.
-    },
-};
-
-pub const TableSortSpecs = *extern struct {
-    specs: [*]TableColumnSortSpecs,
-    count: c_int,
-    dirty: bool,
-};
-
-pub const TableBgTarget = enum(c_int) {
-    none = 0,
-    row_bg0 = 1,
-    row_bg1 = 2,
-    cell_bg = 3,
-};
-
-pub fn beginTable(name: [:0]const u8, args: struct {
-    column: i32,
-    flags: TableFlags = .{},
-    outer_size: [2]f32 = .{ 0, 0 },
-    inner_width: f32 = 0,
-}) bool {
-    return zguiBeginTable(name, args.column, args.flags, &args.outer_size, args.inner_width);
-}
-extern fn zguiBeginTable(
-    str_id: [*:0]const u8,
-    column: c_int,
-    flags: TableFlags,
-    outer_size: *const [2]f32,
-    inner_width: f32,
-) bool;
-
-pub fn endTable() void {
-    zguiEndTable();
-}
-extern fn zguiEndTable() void;
-
-pub const TableNextRow = struct {
-    row_flags: TableRowFlags = .{},
-    min_row_height: f32 = 0,
-};
-pub fn tableNextRow(args: TableNextRow) void {
-    zguiTableNextRow(args.row_flags, args.min_row_height);
-}
-extern fn zguiTableNextRow(row_flags: TableRowFlags, min_row_height: f32) void;
-
-pub const tableNextColumn = zguiTableNextColumn;
-extern fn zguiTableNextColumn() bool;
-
-pub const tableSetColumnIndex = zguiTableSetColumnIndex;
-extern fn zguiTableSetColumnIndex(column_n: i32) bool;
-
-pub const TableSetupColumn = struct {
-    flags: TableColumnFlags = .{},
-    init_width_or_height: f32 = 0,
-    user_id: Ident = 0,
-};
-pub fn tableSetupColumn(label: [:0]const u8, args: TableSetupColumn) void {
-    zguiTableSetupColumn(label, args.flags, args.init_width_or_height, args.user_id);
-}
-extern fn zguiTableSetupColumn(label: [*:0]const u8, flags: TableColumnFlags, init_width_or_height: f32, user_id: Ident) void;
-
-pub const tableSetupScrollFreeze = zguiTableSetupScrollFreeze;
-extern fn zguiTableSetupScrollFreeze(cols: i32, rows: i32) void;
-
-pub const tableHeadersRow = zguiTableHeadersRow;
-extern fn zguiTableHeadersRow() void;
-
-pub fn tableHeader(label: [:0]const u8) void {
-    zguiTableHeader(label);
-}
-extern fn zguiTableHeader(label: [*:0]const u8) void;
-
-pub const tableGetSortSpecs = zguiTableGetSortSpecs;
-extern fn zguiTableGetSortSpecs() ?TableSortSpecs;
-
-pub const tableGetColumnCount = zguiTableGetColumnCount;
-extern fn zguiTableGetColumnCount() i32;
-
-pub const tableGetColumnIndex = zguiTableGetColumnIndex;
-extern fn zguiTableGetColumnIndex() i32;
-
-pub const tableGetRowIndex = zguiTableGetRowIndex;
-extern fn zguiTableGetRowIndex() i32;
-
-pub const TableGetColumnName = struct {
-    column_n: i32 = -1,
-};
-pub fn tableGetColumnName(args: TableGetColumnName) [*:0]const u8 {
-    return zguiTableGetColumnName(args.column_n);
-}
-extern fn zguiTableGetColumnName(column_n: i32) [*:0]const u8;
-
-pub const TableGetColumnFlags = struct {
-    column_n: i32 = -1,
-};
-pub fn tableGetColumnFlags(args: TableGetColumnFlags) TableColumnFlags {
-    return zguiTableGetColumnFlags(args.column_n);
-}
-extern fn zguiTableGetColumnFlags(column_n: i32) TableColumnFlags;
-
-pub const tableSetColumnEnabled = zguiTableSetColumnEnabled;
-extern fn zguiTableSetColumnEnabled(column_n: i32, v: bool) void;
-
-pub fn tableSetBgColor(args: struct {
-    target: TableBgTarget,
-    color: u32,
-    column_n: i32 = -1,
-}) void {
-    zguiTableSetBgColor(args.target, args.color, args.column_n);
-}
-extern fn zguiTableSetBgColor(target: TableBgTarget, color: c_uint, column_n: c_int) void;
-
-//--------------------------------------------------------------------------------------------------
-//
-// Item/Widgets Utilities and Query Functions
-//
-//--------------------------------------------------------------------------------------------------
-pub fn isItemHovered(flags: HoveredFlags) bool {
-    return zguiIsItemHovered(flags);
-}
-/// `pub fn isItemActive() bool`
-pub const isItemActive = zguiIsItemActive;
-/// `pub fn isItemFocused() bool`
-pub const isItemFocused = zguiIsItemFocused;
-pub const MouseButton = enum(u32) {
-    left = 0,
-    right = 1,
-    middle = 2,
-};
-
-/// `pub fn isMouseDown(mouse_button: MouseButton) bool`
-pub const isMouseDown = zguiIsMouseDown;
-/// `pub fn isMouseClicked(mouse_button: MouseButton) bool`
-pub const isMouseClicked = zguiIsMouseClicked;
-/// `pub fn isMouseDoubleClicked(mouse_button: MouseButton) bool`
-pub const isMouseDoubleClicked = zguiIsMouseDoubleClicked;
-/// `pub fn isItemClicked(mouse_button: MouseButton) bool`
-pub const isItemClicked = zguiIsItemClicked;
-/// `pub fn isItemVisible() bool`
-pub const isItemVisible = zguiIsItemVisible;
-/// `pub fn isItemEdited() bool`
-pub const isItemEdited = zguiIsItemEdited;
-/// `pub fn isItemActivated() bool`
-pub const isItemActivated = zguiIsItemActivated;
-/// `pub fn isItemDeactivated bool`
-pub const isItemDeactivated = zguiIsItemDeactivated;
-/// `pub fn isItemDeactivatedAfterEdit() bool`
-pub const isItemDeactivatedAfterEdit = zguiIsItemDeactivatedAfterEdit;
-/// `pub fn isItemToggledOpen() bool`
-pub const isItemToggledOpen = zguiIsItemToggledOpen;
-/// `pub fn isAnyItemHovered() bool`
-pub const isAnyItemHovered = zguiIsAnyItemHovered;
-/// `pub fn isAnyItemActive() bool`
-pub const isAnyItemActive = zguiIsAnyItemActive;
-/// `pub fn isAnyItemFocused() bool`
-pub const isAnyItemFocused = zguiIsAnyItemFocused;
-extern fn zguiIsMouseDown(mouse_button: MouseButton) bool;
-extern fn zguiIsMouseClicked(mouse_button: MouseButton) bool;
-extern fn zguiIsMouseDoubleClicked(mouse_button: MouseButton) bool;
-extern fn zguiIsItemHovered(flags: HoveredFlags) bool;
-extern fn zguiIsItemActive() bool;
-extern fn zguiIsItemFocused() bool;
-extern fn zguiIsItemClicked(mouse_button: MouseButton) bool;
-extern fn zguiIsItemVisible() bool;
-extern fn zguiIsItemEdited() bool;
-extern fn zguiIsItemActivated() bool;
-extern fn zguiIsItemDeactivated() bool;
-extern fn zguiIsItemDeactivatedAfterEdit() bool;
-extern fn zguiIsItemToggledOpen() bool;
-extern fn zguiIsAnyItemHovered() bool;
-extern fn zguiIsAnyItemActive() bool;
-extern fn zguiIsAnyItemFocused() bool;
-//--------------------------------------------------------------------------------------------------
-//
-// Color Utilities
-//
-//--------------------------------------------------------------------------------------------------
-pub fn colorConvertU32ToFloat4(in: u32) [4]f32 {
-    var rgba: [4]f32 = undefined;
-    zguiColorConvertU32ToFloat4(in, &rgba);
-    return rgba;
-}
-
-pub fn colorConvertU32ToFloat3(in: u32) [3]f32 {
-    var rgba: [4]f32 = undefined;
-    zguiColorConvertU32ToFloat4(in, &rgba);
-    return .{ rgba[0], rgba[1], rgba[2] };
-}
-
-pub fn colorConvertFloat4ToU32(in: [4]f32) u32 {
-    return zguiColorConvertFloat4ToU32(&in);
-}
-
-pub fn colorConvertFloat3ToU32(in: [3]f32) u32 {
-    return colorConvertFloat4ToU32(.{ in[0], in[1], in[2], 1 });
-}
-
-pub fn colorConvertRgbToHsv(r: f32, g: f32, b: f32) [3]f32 {
-    var hsv: [3]f32 = undefined;
-    zguiColorConvertRGBtoHSV(r, g, b, &hsv[0], &hsv[1], &hsv[2]);
-    return hsv;
-}
-
-pub fn colorConvertHsvToRgb(h: f32, s: f32, v: f32) [3]f32 {
-    var rgb: [3]f32 = undefined;
-    zguiColorConvertHSVtoRGB(h, s, v, &rgb[0], &rgb[1], &rgb[2]);
-    return rgb;
-}
-
-extern fn zguiColorConvertU32ToFloat4(in: u32, rgba: *[4]f32) void;
-extern fn zguiColorConvertFloat4ToU32(in: *const [4]f32) u32;
-extern fn zguiColorConvertRGBtoHSV(r: f32, g: f32, b: f32, out_h: *f32, out_s: *f32, out_v: *f32) void;
-extern fn zguiColorConvertHSVtoRGB(h: f32, s: f32, v: f32, out_r: *f32, out_g: *f32, out_b: *f32) void;
-//--------------------------------------------------------------------------------------------------
-//
-// Inputs Utilities: Keyboard
-//
-//--------------------------------------------------------------------------------------------------
-pub fn isKeyDown(key: Key) bool {
-    return zguiIsKeyDown(key);
-}
-
-extern fn zguiIsKeyDown(key: Key) bool;
-//--------------------------------------------------------------------------------------------------
-//
-// Helpers
-//
-//--------------------------------------------------------------------------------------------------
-var temp_buffer: ?std.ArrayList(u8) = null;
-
-pub fn format(comptime fmt: []const u8, args: anytype) []const u8 {
-    const len = std.fmt.count(fmt, args);
-    if (len > temp_buffer.?.items.len) temp_buffer.?.resize(len + 64) catch unreachable;
-    return std.fmt.bufPrint(temp_buffer.?.items, fmt, args) catch unreachable;
-}
-pub fn formatZ(comptime fmt: []const u8, args: anytype) [:0]const u8 {
-    const len = std.fmt.count(fmt ++ "\x00", args);
-    if (len > temp_buffer.?.items.len) temp_buffer.?.resize(len + 64) catch unreachable;
-    return std.fmt.bufPrintZ(temp_buffer.?.items, fmt, args) catch unreachable;
-}
-//--------------------------------------------------------------------------------------------------
-pub fn typeToDataTypeEnum(comptime T: type) DataType {
-    return switch (T) {
-        i8 => .I8,
-        u8 => .U8,
-        i16 => .I16,
-        u16 => .U16,
-        i32 => .I32,
-        u32 => .U32,
-        i64 => .I64,
-        u64 => .U64,
-        f32 => .F32,
-        f64 => .F64,
-        usize => switch (@sizeOf(usize)) {
-            1 => .U8,
-            2 => .U16,
-            4 => .U32,
-            8 => .U64,
-            else => @compileError("Unsupported usize length"),
-        },
-        else => @compileError("Only fundamental scalar types allowed: " ++ @typeName(T)),
-    };
-}
-//--------------------------------------------------------------------------------------------------
-//
-// Menus
-//
-//--------------------------------------------------------------------------------------------------
-/// `pub fn beginMenuBar() bool`
-pub const beginMenuBar = zguiBeginMenuBar;
-/// `pub fn endMenuBar() void`
-pub const endMenuBar = zguiEndMenuBar;
-/// `pub fn beginMainMenuBar() bool`
-pub const beginMainMenuBar = zguiBeginMainMenuBar;
-/// `pub fn endMainMenuBar() void`
-pub const endMainMenuBar = zguiEndMainMenuBar;
-
-pub fn beginMenu(label: [:0]const u8, enabled: bool) bool {
-    return zguiBeginMenu(label, enabled);
-}
-/// `pub fn endMenu() void`
-pub const endMenu = zguiEndMenu;
-
-const MenuItem = struct {
-    shortcut: ?[:0]const u8 = null,
-    selected: bool = false,
-    enabled: bool = true,
-};
-pub fn menuItem(label: [:0]const u8, args: MenuItem) bool {
-    return zguiMenuItem(label, if (args.shortcut) |s| s.ptr else null, args.selected, args.enabled);
-}
-
-const MenuItemPtr = struct {
-    shortcut: ?[:0]const u8 = null,
-    selected: *bool,
-    enabled: bool = true,
-};
-pub fn menuItemPtr(label: [:0]const u8, args: MenuItemPtr) bool {
-    return zguiMenuItemPtr(label, if (args.shortcut) |s| s.ptr else null, args.selected, args.enabled);
-}
-
-extern fn zguiBeginMenuBar() bool;
-extern fn zguiEndMenuBar() void;
-extern fn zguiBeginMainMenuBar() bool;
-extern fn zguiEndMainMenuBar() void;
-extern fn zguiBeginMenu(label: [*:0]const u8, enabled: bool) bool;
-extern fn zguiEndMenu() void;
-extern fn zguiMenuItem(label: [*:0]const u8, shortcut: ?[*:0]const u8, selected: bool, enabled: bool) bool;
-extern fn zguiMenuItemPtr(label: [*:0]const u8, shortcut: ?[*:0]const u8, selected: *bool, enabled: bool) bool;
-//--------------------------------------------------------------------------------------------------
-//
-// Popups
-//
-//--------------------------------------------------------------------------------------------------
-/// `pub fn beginTooltip() bool`
-pub const beginTooltip = zguiBeginTooltip;
-/// `pub fn endTooltip() void`
-pub const endTooltip = zguiEndTooltip;
-extern fn zguiBeginTooltip() bool;
-extern fn zguiEndTooltip() void;
-
-/// `pub fn beginPopupContextWindow() bool`
-pub const beginPopupContextWindow = zguiBeginPopupContextWindow;
-/// `pub fn beginPopupContextItem() bool`
-pub const beginPopupContextItem = zguiBeginPopupContextItem;
-pub const PopupFlags = packed struct(c_int) {
-    mouse_button_left: bool = false,
-    mouse_button_right: bool = false,
-    mouse_button_middle: bool = false,
-
-    _reserved0: bool = false,
-    _reserved1: bool = false,
-
-    no_reopen: bool = false,
-    _reserved2: bool = false,
-    no_open_over_existing_popup: bool = false,
-    no_open_over_items: bool = false,
-    any_popup_id: bool = false,
-    any_popup_level: bool = false,
-    _padding: u21 = 0,
-
-    pub const any_popup = PopupFlags{ .any_popup_id = true, .any_popup_level = true };
-};
-pub fn beginPopupModal(name: [:0]const u8, args: Begin) bool {
-    return zguiBeginPopupModal(name, args.popen, args.flags);
-}
-pub fn openPopup(str_id: [:0]const u8, flags: PopupFlags) void {
-    zguiOpenPopup(str_id, flags);
-}
-/// `pub fn beginPopup(str_id: [:0]const u8, flags: WindowFlags) bool`
-pub const beginPopup = zguiBeginPopup;
-/// `pub fn endPopup() void`
-pub const endPopup = zguiEndPopup;
-/// `pub fn closeCurrentPopup() void`
-pub const closeCurrentPopup = zguiCloseCurrentPopup;
-extern fn zguiBeginPopupContextWindow() bool;
-extern fn zguiBeginPopupContextItem() bool;
-extern fn zguiBeginPopupModal(name: [*:0]const u8, popen: ?*bool, flags: WindowFlags) bool;
-extern fn zguiBeginPopup(str_id: [*:0]const u8, flags: WindowFlags) bool;
-extern fn zguiEndPopup() void;
-extern fn zguiOpenPopup(str_id: [*:0]const u8, flags: PopupFlags) void;
-extern fn zguiCloseCurrentPopup() void;
-//--------------------------------------------------------------------------------------------------
-//
-// Tabs
-//
-//--------------------------------------------------------------------------------------------------
-pub const TabBarFlags = packed struct(c_int) {
-    reorderable: bool = false,
-    auto_select_new_tabs: bool = false,
-    tab_list_popup_button: bool = false,
-    no_close_with_middle_mouse_button: bool = false,
-    no_tab_list_scrolling_buttons: bool = false,
-    no_tooltip: bool = false,
-    fitting_policy_resize_down: bool = false,
-    fitting_policy_scroll: bool = false,
-    _padding: u24 = 0,
-};
-pub const TabItemFlags = packed struct(c_int) {
-    unsaved_document: bool = false,
-    set_selected: bool = false,
-    no_close_with_middle_mouse_button: bool = false,
-    no_push_id: bool = false,
-    no_tooltip: bool = false,
-    no_reorder: bool = false,
-    leading: bool = false,
-    trailing: bool = false,
-    no_assumed_closure: bool = false,
-    _padding: u23 = 0,
-};
-pub fn beginTabBar(label: [:0]const u8, flags: TabBarFlags) bool {
-    return zguiBeginTabBar(label, flags);
-}
-const BeginTabItem = struct {
-    p_open: ?*bool = null,
-    flags: TabItemFlags = .{},
-};
-pub fn beginTabItem(label: [:0]const u8, args: BeginTabItem) bool {
-    return zguiBeginTabItem(label, args.p_open, args.flags);
-}
-/// `void endTabItem() void`
-pub const endTabItem = zguiEndTabItem;
-/// `void endTabBar() void`
-pub const endTabBar = zguiEndTabBar;
-pub fn setTabItemClosed(tab_or_docked_window_label: [:0]const u8) void {
-    zguiSetTabItemClosed(tab_or_docked_window_label);
-}
-
-extern fn zguiBeginTabBar(label: [*:0]const u8, flags: TabBarFlags) bool;
-extern fn zguiBeginTabItem(label: [*:0]const u8, p_open: ?*bool, flags: TabItemFlags) bool;
-extern fn zguiEndTabItem() void;
-extern fn zguiEndTabBar() void;
-extern fn zguiSetTabItemClosed(tab_or_docked_window_label: [*:0]const u8) void;
-//--------------------------------------------------------------------------------------------------
-//
-// Viewport
-//
-//--------------------------------------------------------------------------------------------------
-pub const Viewport = *opaque {
-    pub fn getPos(viewport: Viewport) [2]f32 {
-        var pos: [2]f32 = undefined;
-        zguiViewport_GetPos(viewport, &pos);
-        return pos;
-    }
-    extern fn zguiViewport_GetPos(viewport: Viewport, pos: *[2]f32) void;
-
-    pub fn getSize(viewport: Viewport) [2]f32 {
-        var pos: [2]f32 = undefined;
-        zguiViewport_GetSize(viewport, &pos);
-        return pos;
-    }
-    extern fn zguiViewport_GetSize(viewport: Viewport, size: *[2]f32) void;
-
-    pub fn getWorkPos(viewport: Viewport) [2]f32 {
-        var pos: [2]f32 = undefined;
-        zguiViewport_GetWorkPos(viewport, &pos);
-        return pos;
-    }
-    extern fn zguiViewport_GetWorkPos(viewport: Viewport, pos: *[2]f32) void;
-
-    pub fn getWorkSize(viewport: Viewport) [2]f32 {
-        var pos: [2]f32 = undefined;
-        zguiViewport_GetWorkSize(viewport, &pos);
-        return pos;
-    }
-    extern fn zguiViewport_GetWorkSize(viewport: Viewport, size: *[2]f32) void;
-
-    pub fn getCenter(viewport: Viewport) [2]f32 {
-        const pos = viewport.getPos();
-        const size = viewport.getSize();
-        return .{
-            pos[0] + size[0] * 0.5,
-            pos[1] + size[1] * 0.5,
-        };
-    }
-
-    pub fn getWorkCenter(viewport: Viewport) [2]f32 {
-        const pos = viewport.getWorkPos();
-        const size = viewport.getWorkSize();
-        return .{
-            pos[0] + size[0] * 0.5,
-            pos[1] + size[1] * 0.5,
-        };
-    }
-};
-pub const getMainViewport = zguiGetMainViewport;
-extern fn zguiGetMainViewport() Viewport;
-//--------------------------------------------------------------------------------------------------
-//
-// Mouse Input
-//
-//--------------------------------------------------------------------------------------------------
-pub const MouseDragDelta = struct {
-    lock_threshold: f32 = -1.0,
-};
-pub fn getMouseDragDelta(drag_button: MouseButton, args: MouseDragDelta) [2]f32 {
-    var delta: [2]f32 = undefined;
-    zguiGetMouseDragDelta(drag_button, args.lock_threshold, &delta);
-    return delta;
-}
-pub const resetMouseDragDelta = zguiResetMouseDragDelta;
-extern fn zguiGetMouseDragDelta(button: MouseButton, lock_threshold: f32, delta: *[2]f32) void;
-extern fn zguiResetMouseDragDelta(button: MouseButton) void;
-//--------------------------------------------------------------------------------------------------
-//
-// Drag and Drop
-//
-//--------------------------------------------------------------------------------------------------
-pub const DragDropFlags = packed struct(c_int) {
-    source_no_preview_tooltip: bool = false,
-    source_no_disable_hover: bool = false,
-    source_no_hold_open_to_others: bool = false,
-    source_allow_null_id: bool = false,
-    source_extern: bool = false,
-    source_auto_expire_payload: bool = false,
-
-    _padding0: u4 = 0,
-
-    accept_before_delivery: bool = false,
-    accept_no_draw_default_rect: bool = false,
-    accept_no_preview_tooltip: bool = false,
-
-    _padding1: u19 = 0,
-
-    pub const accept_peek_only = @This(){ .accept_before_delivery = true, .accept_no_draw_default_rect = true };
-};
-
-const Payload = extern struct {
-    data: *anyopaque = null,
-    data_size: c_int = 0,
-    source_id: c_uint = 0,
-    source_parent_id: c_uint = 0,
-    data_frame_count: c_int = -1,
-    data_type: [32:0]c_char,
-    preview: bool = false,
-    delivery: bool = false,
-
-    pub fn init() Payload {
-        var payload = Payload{};
-        payload.clear();
-        return payload;
-    }
-
-    /// `pub fn clear(payload: *Payload) void`
-    pub const clear = zguiImGuiPayload_Clear;
-    extern fn zguiImGuiPayload_Clear(payload: *Payload) void;
-
-    /// `pub fn isDataType(payload: *const Payload, type: [*:0]const u8) bool`
-    pub const isDataType = zguiImGuiPayload_IsDataType;
-    extern fn zguiImGuiPayload_IsDataType(payload: *const Payload, type: [*:0]const u8) bool;
-
-    /// `pub fn isPreview(payload: *const Payload) bool`
-    pub const isPreview = zguiImGuiPayload_IsPreview;
-    extern fn zguiImGuiPayload_IsPreview(payload: *const Payload) bool;
-
-    /// `pub fn isDelivery(payload: *const Payload) bool;
-    pub const isDelivery = zguiImGuiPayload_IsDelivery;
-    extern fn zguiImGuiPayload_IsDelivery(payload: *const Payload) bool;
-};
-
-pub fn beginDragDropSource(flags: DragDropFlags) bool {
-    return zguiBeginDragDropSource(flags);
-}
-
-/// Note: `payload_type` can be at most 32 characters long
-pub fn setDragDropPayload(payload_type: [*:0]const u8, data: []const u8, cond: Condition) bool {
-    return zguiSetDragDropPayload(payload_type, @alignCast(@ptrCast(data.ptr)), data.len, cond);
-}
-pub fn endDragDropSource() void {
-    zguiEndDragDropSource();
-}
-pub fn beginDragDropTarget() bool {
-    return zguiBeginDragDropTarget();
-}
-
-/// Note: `payload_type` can be at most 32 characters long
-pub fn acceptDragDropPayload(payload_type: [*:0]const u8, flags: DragDropFlags) ?*Payload {
-    return zguiAcceptDragDropPayload(payload_type, flags);
-}
-pub fn endDragDropTarget() void {
-    zguiEndDragDropTarget();
-}
-pub fn getDragDropPayload() ?*Payload {
-    return zguiGetDragDropPayload();
-}
-extern fn zguiBeginDragDropSource(flags: DragDropFlags) bool;
-extern fn zguiSetDragDropPayload(type: [*:0]const u8, data: *const anyopaque, sz: usize, cond: Condition) bool;
-extern fn zguiEndDragDropSource() void;
-extern fn zguiBeginDragDropTarget() bool;
-extern fn zguiAcceptDragDropPayload(type: [*:0]const u8, flags: DragDropFlags) [*c]Payload;
-extern fn zguiEndDragDropTarget() void;
-extern fn zguiGetDragDropPayload() [*c]Payload;
-//--------------------------------------------------------------------------------------------------
-//
-// DrawFlags
-//
-//--------------------------------------------------------------------------------------------------
-pub const DrawFlags = packed struct(c_int) {
-    closed: bool = false,
-    _padding0: u3 = 0,
-    round_corners_top_left: bool = false,
-    round_corners_top_right: bool = false,
-    round_corners_bottom_left: bool = false,
-    round_corners_bottom_right: bool = false,
-    round_corners_none: bool = false,
-    _padding1: u23 = 0,
-
-    pub const round_corners_top = DrawFlags{
-        .round_corners_top_left = true,
-        .round_corners_top_right = true,
-    };
-
-    pub const round_corners_bottom = DrawFlags{
-        .round_corners_bottom_left = true,
-        .round_corners_bottom_right = true,
-    };
-
-    pub const round_corners_left = DrawFlags{
-        .round_corners_top_left = true,
-        .round_corners_bottom_left = true,
-    };
-
-    pub const round_corners_right = DrawFlags{
-        .round_corners_top_right = true,
-        .round_corners_bottom_right = true,
-    };
-
-    pub const round_corners_all = DrawFlags{
-        .round_corners_top_left = true,
-        .round_corners_top_right = true,
-        .round_corners_bottom_left = true,
-        .round_corners_bottom_right = true,
-    };
-};
-
-pub const DrawCmd = extern struct {
-    clip_rect: [4]f32,
-    texture_id: TextureIdent,
-    vtx_offset: c_uint,
-    idx_offset: c_uint,
-    elem_count: c_uint,
-    user_callback: ?DrawCallback,
-    user_callback_data: ?*anyopaque,
-};
-
-pub const DrawCallback = *const fn (*const anyopaque, *const DrawCmd) callconv(.C) void;
-
-pub const getWindowDrawList = zguiGetWindowDrawList;
-pub const getBackgroundDrawList = zguiGetBackgroundDrawList;
-pub const getForegroundDrawList = zguiGetForegroundDrawList;
-
-pub const createDrawList = zguiCreateDrawList;
-pub fn destroyDrawList(draw_list: DrawList) void {
-    if (draw_list.getOwnerName()) |owner| {
-        @panic(format("zgui: illegally destroying DrawList of {s}", .{owner}));
-    }
-    zguiDestroyDrawList(draw_list);
-}
-
-extern fn zguiGetWindowDrawList() DrawList;
-extern fn zguiGetBackgroundDrawList() DrawList;
-extern fn zguiGetForegroundDrawList() DrawList;
-extern fn zguiCreateDrawList() DrawList;
-extern fn zguiDestroyDrawList(draw_list: DrawList) void;
-
-pub const DrawList = *opaque {
-    pub const getOwnerName = zguiDrawList_GetOwnerName;
-    extern fn zguiDrawList_GetOwnerName(draw_list: DrawList) ?[*:0]const u8;
-
-    pub fn reset(draw_list: DrawList) void {
-        if (draw_list.getOwnerName()) |owner| {
-            @panic(format("zgui: illegally resetting DrawList of {s}", .{owner}));
-        }
-        zguiDrawList_ResetForNewFrame(draw_list);
-    }
-    extern fn zguiDrawList_ResetForNewFrame(draw_list: DrawList) void;
-
-    pub fn clearMemory(draw_list: DrawList) void {
-        if (draw_list.getOwnerName()) |owner| {
-            @panic(format("zgui: illegally clearing memory DrawList of {s}", .{owner}));
-        }
-        zguiDrawList_ClearFreeMemory(draw_list);
-    }
-    extern fn zguiDrawList_ClearFreeMemory(draw_list: DrawList) void;
-
-    //----------------------------------------------------------------------------------------------
-    pub fn getVertexBufferLength(draw_list: DrawList) i32 {
-        return zguiDrawList_GetVertexBufferLength(draw_list);
-    }
-    extern fn zguiDrawList_GetVertexBufferLength(draw_list: DrawList) c_int;
-
-    pub const getVertexBufferData = zguiDrawList_GetVertexBufferData;
-    extern fn zguiDrawList_GetVertexBufferData(draw_list: DrawList) [*]DrawVert;
-    pub fn getVertexBuffer(draw_list: DrawList) []DrawVert {
-        const len: usize = @intCast(draw_list.getVertexBufferLength());
-        return draw_list.getVertexBufferData()[0..len];
-    }
-
-    pub fn getIndexBufferLength(draw_list: DrawList) i32 {
-        return zguiDrawList_GetIndexBufferLength(draw_list);
-    }
-    extern fn zguiDrawList_GetIndexBufferLength(draw_list: DrawList) c_int;
-
-    pub const getIndexBufferData = zguiDrawList_GetIndexBufferData;
-    extern fn zguiDrawList_GetIndexBufferData(draw_list: DrawList) [*]DrawIdx;
-    pub fn getIndexBuffer(draw_list: DrawList) []DrawIdx {
-        const len: usize = @intCast(draw_list.getIndexBufferLength());
-        return draw_list.getIndexBufferData()[0..len];
-    }
-
-    pub fn getCurrentIndex(draw_list: DrawList) u32 {
-        return zguiDrawList_GetCurrentIndex(draw_list);
-    }
-    extern fn zguiDrawList_GetCurrentIndex(draw_list: DrawList) c_uint;
-
-    pub fn getCmdBufferLength(draw_list: DrawList) i32 {
-        return zguiDrawList_GetCmdBufferLength(draw_list);
-    }
-    extern fn zguiDrawList_GetCmdBufferLength(draw_list: DrawList) c_int;
-
-    pub const getCmdBufferData = zguiDrawList_GetCmdBufferData;
-    extern fn zguiDrawList_GetCmdBufferData(draw_list: DrawList) [*]DrawCmd;
-    pub fn getCmdBuffer(draw_list: DrawList) []DrawCmd {
-        const len: usize = @intCast(draw_list.getCmdBufferLength());
-        return draw_list.getCmdBufferData()[0..len];
-    }
-
-    pub const DrawListFlags = packed struct(c_int) {
-        anti_aliased_lines: bool = false,
-        anti_aliased_lines_use_tex: bool = false,
-        anti_aliased_fill: bool = false,
-        allow_vtx_offset: bool = false,
-
-        _padding: u28 = 0,
-    };
-
-    pub const setDrawListFlags = zguiDrawList_SetFlags;
-    extern fn zguiDrawList_SetFlags(draw_list: DrawList, flags: DrawListFlags) void;
-    pub const getDrawListFlags = zguiDrawList_GetFlags;
-    extern fn zguiDrawList_GetFlags(draw_list: DrawList) DrawListFlags;
-
-    //----------------------------------------------------------------------------------------------
-    const ClipRect = struct {
-        pmin: [2]f32,
-        pmax: [2]f32,
-        intersect_with_current: bool = false,
-    };
-    pub fn pushClipRect(draw_list: DrawList, args: ClipRect) void {
-        zguiDrawList_PushClipRect(
-            draw_list,
-            &args.pmin,
-            &args.pmax,
-            args.intersect_with_current,
-        );
-    }
-    extern fn zguiDrawList_PushClipRect(
-        draw_list: DrawList,
-        clip_rect_min: *const [2]f32,
-        clip_rect_max: *const [2]f32,
-        intersect_with_current_clip_rect: bool,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub const pushClipRectFullScreen = zguiDrawList_PushClipRectFullScreen;
-    extern fn zguiDrawList_PushClipRectFullScreen(draw_list: DrawList) void;
-
-    pub const popClipRect = zguiDrawList_PopClipRect;
-    extern fn zguiDrawList_PopClipRect(draw_list: DrawList) void;
-    //----------------------------------------------------------------------------------------------
-    pub const pushTextureId = zguiDrawList_PushTextureId;
-    extern fn zguiDrawList_PushTextureId(draw_list: DrawList, texture_id: TextureIdent) void;
-
-    pub const popTextureId = zguiDrawList_PopTextureId;
-    extern fn zguiDrawList_PopTextureId(draw_list: DrawList) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn getClipRectMin(draw_list: DrawList) [2]f32 {
-        var v: [2]f32 = undefined;
-        zguiDrawList_GetClipRectMin(draw_list, &v);
-        return v;
-    }
-    extern fn zguiDrawList_GetClipRectMin(draw_list: DrawList, clip_min: *[2]f32) void;
-
-    pub fn getClipRectMax(draw_list: DrawList) [2]f32 {
-        var v: [2]f32 = undefined;
-        zguiDrawList_GetClipRectMax(draw_list, &v);
-        return v;
-    }
-    extern fn zguiDrawList_GetClipRectMax(draw_list: DrawList, clip_min: *[2]f32) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addLine(draw_list: DrawList, args: struct {
-        p1: [2]f32,
-        p2: [2]f32,
-        col: u32,
-        thickness: f32,
-    }) void {
-        zguiDrawList_AddLine(draw_list, &args.p1, &args.p2, args.col, args.thickness);
-    }
-    extern fn zguiDrawList_AddLine(
-        draw_list: DrawList,
-        p1: *const [2]f32,
-        p2: *const [2]f32,
-        col: u32,
-        thickness: f32,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addRect(draw_list: DrawList, args: struct {
-        pmin: [2]f32,
-        pmax: [2]f32,
-        col: u32,
-        rounding: f32 = 0.0,
-        flags: DrawFlags = .{},
-        thickness: f32 = 1.0,
-    }) void {
-        zguiDrawList_AddRect(
-            draw_list,
-            &args.pmin,
-            &args.pmax,
-            args.col,
-            args.rounding,
-            args.flags,
-            args.thickness,
-        );
-    }
-    extern fn zguiDrawList_AddRect(
-        draw_list: DrawList,
-        pmin: *const [2]f32,
-        pmax: *const [2]f32,
-        col: u32,
-        rounding: f32,
-        flags: DrawFlags,
-        thickness: f32,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addRectFilled(draw_list: DrawList, args: struct {
-        pmin: [2]f32,
-        pmax: [2]f32,
-        col: u32,
-        rounding: f32 = 0.0,
-        flags: DrawFlags = .{},
-    }) void {
-        zguiDrawList_AddRectFilled(
-            draw_list,
-            &args.pmin,
-            &args.pmax,
-            args.col,
-            args.rounding,
-            args.flags,
-        );
-    }
-    extern fn zguiDrawList_AddRectFilled(
-        draw_list: DrawList,
-        pmin: *const [2]f32,
-        pmax: *const [2]f32,
-        col: u32,
-        rounding: f32,
-        flags: DrawFlags,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addRectFilledMultiColor(draw_list: DrawList, args: struct {
-        pmin: [2]f32,
-        pmax: [2]f32,
-        col_upr_left: u32,
-        col_upr_right: u32,
-        col_bot_right: u32,
-        col_bot_left: u32,
-    }) void {
-        zguiDrawList_AddRectFilledMultiColor(
-            draw_list,
-            &args.pmin,
-            &args.pmax,
-            args.col_upr_left,
-            args.col_upr_right,
-            args.col_bot_right,
-            args.col_bot_left,
-        );
-    }
-    extern fn zguiDrawList_AddRectFilledMultiColor(
-        draw_list: DrawList,
-        pmin: *const [2]f32,
-        pmax: *const [2]f32,
-        col_upr_left: c_uint,
-        col_upr_right: c_uint,
-        col_bot_right: c_uint,
-        col_bot_left: c_uint,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addQuad(draw_list: DrawList, args: struct {
-        p1: [2]f32,
-        p2: [2]f32,
-        p3: [2]f32,
-        p4: [2]f32,
-        col: u32,
-        thickness: f32 = 1.0,
-    }) void {
-        zguiDrawList_AddQuad(
-            draw_list,
-            &args.p1,
-            &args.p2,
-            &args.p3,
-            &args.p4,
-            args.col,
-            args.thickness,
-        );
-    }
-    extern fn zguiDrawList_AddQuad(
-        draw_list: DrawList,
-        p1: *const [2]f32,
-        p2: *const [2]f32,
-        p3: *const [2]f32,
-        p4: *const [2]f32,
-        col: u32,
-        thickness: f32,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addQuadFilled(draw_list: DrawList, args: struct {
-        p1: [2]f32,
-        p2: [2]f32,
-        p3: [2]f32,
-        p4: [2]f32,
-        col: u32,
-    }) void {
-        zguiDrawList_AddQuadFilled(draw_list, &args.p1, &args.p2, &args.p3, &args.p4, args.col);
-    }
-    extern fn zguiDrawList_AddQuadFilled(
-        draw_list: DrawList,
-        p1: *const [2]f32,
-        p2: *const [2]f32,
-        p3: *const [2]f32,
-        p4: *const [2]f32,
-        col: u32,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addTriangle(draw_list: DrawList, args: struct {
-        p1: [2]f32,
-        p2: [2]f32,
-        p3: [2]f32,
-        col: u32,
-        thickness: f32 = 1.0,
-    }) void {
-        zguiDrawList_AddTriangle(draw_list, &args.p1, &args.p2, &args.p3, args.col, args.thickness);
-    }
-    extern fn zguiDrawList_AddTriangle(
-        draw_list: DrawList,
-        p1: *const [2]f32,
-        p2: *const [2]f32,
-        p3: *const [2]f32,
-        col: u32,
-        thickness: f32,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addTriangleFilled(draw_list: DrawList, args: struct {
-        p1: [2]f32,
-        p2: [2]f32,
-        p3: [2]f32,
-        col: u32,
-    }) void {
-        zguiDrawList_AddTriangleFilled(draw_list, &args.p1, &args.p2, &args.p3, args.col);
-    }
-    extern fn zguiDrawList_AddTriangleFilled(
-        draw_list: DrawList,
-        p1: *const [2]f32,
-        p2: *const [2]f32,
-        p3: *const [2]f32,
-        col: u32,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addCircle(draw_list: DrawList, args: struct {
-        p: [2]f32,
-        r: f32,
-        col: u32,
-        num_segments: i32 = 0,
-        thickness: f32 = 1.0,
-    }) void {
-        zguiDrawList_AddCircle(
-            draw_list,
-            &args.p,
-            args.r,
-            args.col,
-            args.num_segments,
-            args.thickness,
-        );
-    }
-    extern fn zguiDrawList_AddCircle(
-        draw_list: DrawList,
-        center: *const [2]f32,
-        radius: f32,
-        col: u32,
-        num_segments: c_int,
-        thickness: f32,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addCircleFilled(draw_list: DrawList, args: struct {
-        p: [2]f32,
-        r: f32,
-        col: u32,
-        num_segments: u16 = 0,
-    }) void {
-        zguiDrawList_AddCircleFilled(draw_list, &args.p, args.r, args.col, args.num_segments);
-    }
-    extern fn zguiDrawList_AddCircleFilled(
-        draw_list: DrawList,
-        center: *const [2]f32,
-        radius: f32,
-        col: u32,
-        num_segments: c_int,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addNgon(draw_list: DrawList, args: struct {
-        p: [2]f32,
-        r: f32,
-        col: u32,
-        num_segments: u32,
-        thickness: f32 = 1.0,
-    }) void {
-        zguiDrawList_AddNgon(
-            draw_list,
-            &args.p,
-            args.r,
-            args.col,
-            args.num_segments,
-            args.thickness,
-        );
-    }
-    extern fn zguiDrawList_AddNgon(
-        draw_list: DrawList,
-        center: *const [2]f32,
-        radius: f32,
-        col: u32,
-        num_segments: c_int,
-        thickness: f32,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addNgonFilled(draw_list: DrawList, args: struct {
-        p: [2]f32,
-        r: f32,
-        col: u32,
-        num_segments: u32,
-    }) void {
-        zguiDrawList_AddNgonFilled(draw_list, &args.p, args.r, args.col, args.num_segments);
-    }
-    extern fn zguiDrawList_AddNgonFilled(
-        draw_list: DrawList,
-        center: *const [2]f32,
-        radius: f32,
-        col: u32,
-        num_segments: c_int,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addText(draw_list: DrawList, pos: [2]f32, col: u32, comptime fmt: []const u8, args: anytype) void {
-        const txt = format(fmt, args);
-        draw_list.addTextUnformatted(pos, col, txt);
-    }
-    pub fn addTextUnformatted(draw_list: DrawList, pos: [2]f32, col: u32, txt: []const u8) void {
-        zguiDrawList_AddText(draw_list, &pos, col, txt.ptr, txt.ptr + txt.len);
-    }
-    extern fn zguiDrawList_AddText(
-        draw_list: DrawList,
-        pos: *const [2]f32,
-        col: u32,
-        text: [*]const u8,
-        text_end: [*]const u8,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addPolyline(draw_list: DrawList, points: []const [2]f32, args: struct {
-        col: u32,
-        flags: DrawFlags = .{},
-        thickness: f32 = 1.0,
-    }) void {
-        zguiDrawList_AddPolyline(
-            draw_list,
-            points.ptr,
-            @intCast(points.len),
-            args.col,
-            args.flags,
-            args.thickness,
-        );
-    }
-    extern fn zguiDrawList_AddPolyline(
-        draw_list: DrawList,
-        points: [*]const [2]f32,
-        num_points: c_int,
-        col: u32,
-        flags: DrawFlags,
-        thickness: f32,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addConvexPolyFilled(
-        draw_list: DrawList,
-        points: []const [2]f32,
-        col: u32,
-    ) void {
-        zguiDrawList_AddConvexPolyFilled(
-            draw_list,
-            points.ptr,
-            @intCast(points.len),
-            col,
-        );
-    }
-    extern fn zguiDrawList_AddConvexPolyFilled(
-        draw_list: DrawList,
-        points: [*]const [2]f32,
-        num_points: c_int,
-        col: u32,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addBezierCubic(draw_list: DrawList, args: struct {
-        p1: [2]f32,
-        p2: [2]f32,
-        p3: [2]f32,
-        p4: [2]f32,
-        col: u32,
-        thickness: f32 = 1.0,
-        num_segments: u32 = 0,
-    }) void {
-        zguiDrawList_AddBezierCubic(
-            draw_list,
-            &args.p1,
-            &args.p2,
-            &args.p3,
-            &args.p4,
-            args.col,
-            args.thickness,
-            args.num_segments,
-        );
-    }
-    extern fn zguiDrawList_AddBezierCubic(
-        draw_list: DrawList,
-        p1: *const [2]f32,
-        p2: *const [2]f32,
-        p3: *const [2]f32,
-        p4: *const [2]f32,
-        col: u32,
-        thickness: f32,
-        num_segments: c_int,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addBezierQuadratic(draw_list: DrawList, args: struct {
-        p1: [2]f32,
-        p2: [2]f32,
-        p3: [2]f32,
-        col: u32,
-        thickness: f32 = 1.0,
-        num_segments: u32 = 0,
-    }) void {
-        zguiDrawList_AddBezierQuadratic(
-            draw_list,
-            &args.p1,
-            &args.p2,
-            &args.p3,
-            args.col,
-            args.thickness,
-            args.num_segments,
-        );
-    }
-    extern fn zguiDrawList_AddBezierQuadratic(
-        draw_list: DrawList,
-        p1: *const [2]f32,
-        p2: *const [2]f32,
-        p3: *const [2]f32,
-        col: u32,
-        thickness: f32,
-        num_segments: c_int,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addImage(draw_list: DrawList, user_texture_id: TextureIdent, args: struct {
-        pmin: [2]f32,
-        pmax: [2]f32,
-        uvmin: [2]f32 = .{ 0, 0 },
-        uvmax: [2]f32 = .{ 1, 1 },
-        col: u32 = 0xff_ff_ff_ff,
-    }) void {
-        zguiDrawList_AddImage(
-            draw_list,
-            user_texture_id,
-            &args.pmin,
-            &args.pmax,
-            &args.uvmin,
-            &args.uvmax,
-            args.col,
-        );
-    }
-    extern fn zguiDrawList_AddImage(
-        draw_list: DrawList,
-        user_texture_id: TextureIdent,
-        pmin: *const [2]f32,
-        pmax: *const [2]f32,
-        uvmin: *const [2]f32,
-        uvmax: *const [2]f32,
-        col: u32,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addImageQuad(draw_list: DrawList, user_texture_id: TextureIdent, args: struct {
-        p1: [2]f32,
-        p2: [2]f32,
-        p3: [2]f32,
-        p4: [2]f32,
-        uv1: [2]f32 = .{ 0, 0 },
-        uv2: [2]f32 = .{ 1, 0 },
-        uv3: [2]f32 = .{ 1, 1 },
-        uv4: [2]f32 = .{ 0, 1 },
-        col: u32 = 0xff_ff_ff_ff,
-    }) void {
-        zguiDrawList_AddImageQuad(
-            draw_list,
-            user_texture_id,
-            &args.p1,
-            &args.p2,
-            &args.p3,
-            &args.p4,
-            &args.uv1,
-            &args.uv2,
-            &args.uv3,
-            &args.uv4,
-            args.col,
-        );
-    }
-    extern fn zguiDrawList_AddImageQuad(
-        draw_list: DrawList,
-        user_texture_id: TextureIdent,
-        p1: *const [2]f32,
-        p2: *const [2]f32,
-        p3: *const [2]f32,
-        p4: *const [2]f32,
-        uv1: *const [2]f32,
-        uv2: *const [2]f32,
-        uv3: *const [2]f32,
-        uv4: *const [2]f32,
-        col: u32,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn addImageRounded(draw_list: DrawList, user_texture_id: TextureIdent, args: struct {
-        pmin: [2]f32,
-        pmax: [2]f32,
-        uvmin: [2]f32 = .{ 0, 0 },
-        uvmax: [2]f32 = .{ 1, 1 },
-        col: u32 = 0xff_ff_ff_ff,
-        rounding: f32 = 4.0,
-        flags: DrawFlags = .{},
-    }) void {
-        zguiDrawList_AddImageRounded(
-            draw_list,
-            user_texture_id,
-            &args.pmin,
-            &args.pmax,
-            &args.uvmin,
-            &args.uvmax,
-            args.col,
-            args.rounding,
-            args.flags,
-        );
-    }
-    extern fn zguiDrawList_AddImageRounded(
-        draw_list: DrawList,
-        user_texture_id: TextureIdent,
-        pmin: *const [2]f32,
-        pmax: *const [2]f32,
-        uvmin: *const [2]f32,
-        uvmax: *const [2]f32,
-        col: u32,
-        rounding: f32,
-        flags: DrawFlags,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub const pathClear = zguiDrawList_PathClear;
-    extern fn zguiDrawList_PathClear(draw_list: DrawList) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn pathLineTo(draw_list: DrawList, pos: [2]f32) void {
-        zguiDrawList_PathLineTo(draw_list, &pos);
-    }
-    extern fn zguiDrawList_PathLineTo(draw_list: DrawList, pos: *const [2]f32) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn pathLineToMergeDuplicate(draw_list: DrawList, pos: [2]f32) void {
-        zguiDrawList_PathLineToMergeDuplicate(draw_list, &pos);
-    }
-    extern fn zguiDrawList_PathLineToMergeDuplicate(draw_list: DrawList, pos: *const [2]f32) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn pathFillConvex(draw_list: DrawList, col: u32) void {
-        return zguiDrawList_PathFillConvex(draw_list, col);
-    }
-    extern fn zguiDrawList_PathFillConvex(draw_list: DrawList, col: c_uint) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn pathStroke(draw_list: DrawList, args: struct {
-        col: u32,
-        flags: DrawFlags = .{},
-        thickness: f32 = 1.0,
-    }) void {
-        zguiDrawList_PathStroke(draw_list, args.col, args.flags, args.thickness);
-    }
-    extern fn zguiDrawList_PathStroke(draw_list: DrawList, col: u32, flags: DrawFlags, thickness: f32) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn pathArcTo(draw_list: DrawList, args: struct {
-        p: [2]f32,
-        r: f32,
-        amin: f32,
-        amax: f32,
-        num_segments: u16 = 0,
-    }) void {
-        zguiDrawList_PathArcTo(
-            draw_list,
-            &args.p,
-            args.r,
-            args.amin,
-            args.amax,
-            args.num_segments,
-        );
-    }
-    extern fn zguiDrawList_PathArcTo(
-        draw_list: DrawList,
-        center: *const [2]f32,
-        radius: f32,
-        amin: f32,
-        amax: f32,
-        num_segments: c_int,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn pathArcToFast(draw_list: DrawList, args: struct {
-        p: [2]f32,
-        r: f32,
-        amin_of_12: u16,
-        amax_of_12: u16,
-    }) void {
-        zguiDrawList_PathArcToFast(draw_list, &args.p, args.r, args.amin_of_12, args.amax_of_12);
-    }
-    extern fn zguiDrawList_PathArcToFast(
-        draw_list: DrawList,
-        center: *const [2]f32,
-        radius: f32,
-        a_min_of_12: c_int,
-        a_max_of_12: c_int,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn pathBezierCubicCurveTo(draw_list: DrawList, args: struct {
-        p2: [2]f32,
-        p3: [2]f32,
-        p4: [2]f32,
-        num_segments: u16 = 0,
-    }) void {
-        zguiDrawList_PathBezierCubicCurveTo(
-            draw_list,
-            &args.p2,
-            &args.p3,
-            &args.p4,
-            args.num_segments,
-        );
-    }
-    extern fn zguiDrawList_PathBezierCubicCurveTo(
-        draw_list: DrawList,
-        p2: *const [2]f32,
-        p3: *const [2]f32,
-        p4: *const [2]f32,
-        num_segments: c_int,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub fn pathBezierQuadraticCurveTo(draw_list: DrawList, args: struct {
-        p2: [2]f32,
-        p3: [2]f32,
-        num_segments: u16 = 0,
-    }) void {
-        zguiDrawList_PathBezierQuadraticCurveTo(draw_list, &args.p2, &args.p3, args.num_segments);
-    }
-    extern fn zguiDrawList_PathBezierQuadraticCurveTo(
-        draw_list: DrawList,
-        p2: *const [2]f32,
-        p3: *const [2]f32,
-        num_segments: c_int,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    const PathRect = struct {
-        bmin: [2]f32,
-        bmax: [2]f32,
-        rounding: f32 = 0.0,
-        flags: DrawFlags = .{},
-    };
-    pub fn pathRect(draw_list: DrawList, args: PathRect) void {
-        zguiDrawList_PathRect(draw_list, &args.bmin, &args.bmax, args.rounding, args.flags);
-    }
-    extern fn zguiDrawList_PathRect(
-        draw_list: DrawList,
-        rect_min: *const [2]f32,
-        rect_max: *const [2]f32,
-        rounding: f32,
-        flags: DrawFlags,
-    ) void;
-    //----------------------------------------------------------------------------------------------
-    pub const primReserve = zguiDrawList_PrimReserve;
-    extern fn zguiDrawList_PrimReserve(
-        draw_list: DrawList,
-        idx_count: i32,
-        vtx_count: i32,
-    ) void;
-
-    pub const primUnreserve = zguiDrawList_PrimUnreserve;
-    extern fn zguiDrawList_PrimUnreserve(
-        draw_list: DrawList,
-        idx_count: i32,
-        vtx_count: i32,
-    ) void;
-
-    pub fn primRect(
-        draw_list: DrawList,
-        a: [2]f32,
-        b: [2]f32,
-        col: u32,
-    ) void {
-        return zguiDrawList_PrimRect(draw_list, &a, &b, col);
-    }
-    extern fn zguiDrawList_PrimRect(
-        draw_list: DrawList,
-        a: *const [2]f32,
-        b: *const [2]f32,
-        col: u32,
-    ) void;
-
-    pub fn primRectUV(
-        draw_list: DrawList,
-        a: [2]f32,
-        b: [2]f32,
-        uv_a: [2]f32,
-        uv_b: [2]f32,
-        col: u32,
-    ) void {
-        return zguiDrawList_PrimRectUV(draw_list, &a, &b, &uv_a, &uv_b, col);
-    }
-    extern fn zguiDrawList_PrimRectUV(
-        draw_list: DrawList,
-        a: *const [2]f32,
-        b: *const [2]f32,
-        uv_a: *const [2]f32,
-        uv_b: *const [2]f32,
-        col: u32,
-    ) void;
-
-    pub fn primQuadUV(
-        draw_list: DrawList,
-        a: [2]f32,
-        b: [2]f32,
-        c: [2]f32,
-        d: [2]f32,
-        uv_a: [2]f32,
-        uv_b: [2]f32,
-        uv_c: [2]f32,
-        uv_d: [2]f32,
-        col: u32,
-    ) void {
-        return zguiDrawList_PrimQuadUV(draw_list, &a, &b, &c, &d, &uv_a, &uv_b, &uv_c, &uv_d, col);
-    }
-    extern fn zguiDrawList_PrimQuadUV(
-        draw_list: DrawList,
-        a: *const [2]f32,
-        b: *const [2]f32,
-        c: *const [2]f32,
-        d: *const [2]f32,
-        uv_a: *const [2]f32,
-        uv_b: *const [2]f32,
-        uv_c: *const [2]f32,
-        uv_d: *const [2]f32,
-        col: u32,
-    ) void;
-
-    pub fn primWriteVtx(
-        draw_list: DrawList,
-        pos: [2]f32,
-        uv: [2]f32,
-        col: u32,
-    ) void {
-        return zguiDrawList_PrimWriteVtx(draw_list, &pos, &uv, col);
-    }
-    extern fn zguiDrawList_PrimWriteVtx(
-        draw_list: DrawList,
-        pos: *const [2]f32,
-        uv: *const [2]f32,
-        col: u32,
-    ) void;
-
-    pub const primWriteIdx = zguiDrawList_PrimWriteIdx;
-    extern fn zguiDrawList_PrimWriteIdx(
-        draw_list: DrawList,
-        idx: DrawIdx,
-    ) void;
-
-    //----------------------------------------------------------------------------------------------
-
-    pub fn addCallback(draw_list: DrawList, callback: DrawCallback, callback_data: ?*anyopaque) void {
-        zguiDrawList_AddCallback(draw_list, callback, callback_data);
-    }
-    extern fn zguiDrawList_AddCallback(draw_list: DrawList, callback: DrawCallback, callback_data: ?*anyopaque) void;
-    pub fn addResetRenderStateCallback(draw_list: DrawList) void {
-        zguiDrawList_AddResetRenderStateCallback(draw_list);
-    }
-    extern fn zguiDrawList_AddResetRenderStateCallback(draw_list: DrawList) void;
-};
-
-fn Vector(comptime T: type) type {
-    return extern struct {
-        len: c_int,
-        capacity: c_int,
-        items: [*]T,
-    };
-}
-
-test {
-    const testing = std.testing;
-
-    testing.refAllDeclsRecursive(@This());
-
-    init(testing.allocator);
-    defer deinit();
-
-    io.setIniFilename(null);
-
-    _ = io.getFontsTextDataAsRgba32();
-
-    io.setDisplaySize(1, 1);
-
-    newFrame();
-
-    try testing.expect(begin("testing", .{}));
-    defer end();
-
-    const Testing = enum {
-        one,
-        two,
-        three,
-    };
-    var value = Testing.one;
-    _ = comboFromEnum("comboFromEnum", &value);
-}
diff --git a/vendor/zgui/src/plot.zig b/vendor/zgui/src/plot.zig
deleted file mode 100644
index 8d210f4..0000000
--- a/vendor/zgui/src/plot.zig
+++ /dev/null
@@ -1,596 +0,0 @@
-//--------------------------------------------------------------------------------------------------
-const assert = @import("std").debug.assert;
-const gui = @import("gui.zig");
-//--------------------------------------------------------------------------------------------------
-pub fn init() void {
-    if (zguiPlot_GetCurrentContext() == null) {
-        _ = zguiPlot_CreateContext();
-    }
-}
-pub fn deinit() void {
-    if (zguiPlot_GetCurrentContext() != null) {
-        zguiPlot_DestroyContext(null);
-    }
-}
-const Context = *opaque {};
-
-extern fn zguiPlot_GetCurrentContext() ?Context;
-extern fn zguiPlot_CreateContext() Context;
-extern fn zguiPlot_DestroyContext(ctx: ?Context) void;
-//--------------------------------------------------------------------------------------------------
-pub const Marker = enum(i32) {
-    none = -1,
-    circle = 0,
-    square,
-    diamond,
-    up,
-    down,
-    left,
-    right,
-    cross,
-    plus,
-    asterisk,
-};
-
-pub const Colormap = enum(u32) {
-    deep,
-    dark,
-    pastel,
-    paired,
-    viridis,
-    plasma,
-    hot,
-    cool,
-    pink,
-    jet,
-    twilight,
-    rd_bu,
-    br_b_g,
-    pi_y_g,
-    spectral,
-    greys,
-};
-
-pub const Style = extern struct {
-    line_weight: f32,
-    marker: Marker,
-    marker_size: f32,
-    marker_weight: f32,
-    fill_alpha: f32,
-    error_bar_size: f32,
-    error_bar_weight: f32,
-    digital_bit_height: f32,
-    digital_bit_gap: f32,
-    plot_border_size: f32,
-    minor_alpha: f32,
-    major_tick_len: [2]f32,
-    minor_tick_len: [2]f32,
-    major_tick_size: [2]f32,
-    minor_tick_size: [2]f32,
-    major_grid_size: [2]f32,
-    minor_grid_size: [2]f32,
-    plot_padding: [2]f32,
-    label_padding: [2]f32,
-    legend_padding: [2]f32,
-    legend_inner_padding: [2]f32,
-    legend_spacing: [2]f32,
-    mouse_pos_padding: [2]f32,
-    annotation_padding: [2]f32,
-    fit_padding: [2]f32,
-    plot_default_size: [2]f32,
-    plot_min_size: [2]f32,
-
-    colors: [@typeInfo(StyleCol).Enum.fields.len][4]f32,
-    colormap: Colormap,
-
-    use_local_time: bool,
-    use_iso_8601: bool,
-    use_24h_clock: bool,
-
-    /// `pub fn init() Style`
-    pub const init = zguiPlotStyle_Init;
-    extern fn zguiPlotStyle_Init() Style;
-
-    pub fn getColor(style: Style, idx: StyleCol) [4]f32 {
-        return style.colors[@intFromEnum(idx)];
-    }
-    pub fn setColor(style: *Style, idx: StyleCol, color: [4]f32) void {
-        style.colors[@intFromEnum(idx)] = color;
-    }
-};
-/// `pub fn getStyle() *Style`
-pub const getStyle = zguiPlot_GetStyle;
-extern fn zguiPlot_GetStyle() *Style;
-//--------------------------------------------------------------------------------------------------
-pub const StyleCol = enum(u32) {
-    line,
-    fill,
-    marker_outline,
-    marker_fill,
-    error_bar,
-    frame_bg,
-    plot_bg,
-    plot_border,
-    legend_bg,
-    legend_border,
-    legend_text,
-    title_text,
-    inlay_text,
-    axis_text,
-    axis_grid,
-    axis_tick,
-    axis_bg,
-    axis_bg_hovered,
-    axis_bg_active,
-    selection,
-    crosshairs,
-};
-const PushStyleColor4f = struct {
-    idx: StyleCol,
-    c: [4]f32,
-};
-pub fn pushStyleColor4f(args: PushStyleColor4f) void {
-    zguiPlot_PushStyleColor4f(args.idx, &args.c);
-}
-const PushStyleColor1u = struct {
-    idx: StyleCol,
-    c: u32,
-};
-pub fn pushStyleColor1u(args: PushStyleColor1u) void {
-    zguiPlot_PushStyleColor1u(args.idx, args.c);
-}
-const PopStyleColor = struct {
-    count: i32 = 1,
-};
-pub fn popStyleColor(args: PopStyleColor) void {
-    zguiPlot_PopStyleColor(args.count);
-}
-extern fn zguiPlot_PushStyleColor4f(idx: StyleCol, col: *const [4]f32) void;
-extern fn zguiPlot_PushStyleColor1u(idx: StyleCol, col: u32) void;
-extern fn zguiPlot_PopStyleColor(count: i32) void;
-//--------------------------------------------------------------------------------------------------
-pub const StyleVar = enum(u32) {
-    line_weight, // 1f
-    marker, // 1i
-    marker_size, // 1f
-    marker_weight, // 1f
-    fill_alpha, // 1f
-    error_bar_size, // 1f
-    error_bar_weight, // 1f
-    digital_bit_height, // 1f
-    digital_bit_gap, // 1f
-    plot_border_size, // 1f
-    minor_alpha, // 1f
-    major_tick_len, // 2f
-    minor_tick_len, // 2f
-    major_tick_size, // 2f
-    minor_tick_size, // 2f
-    major_grid_size, // 2f
-    minor_grid_size, // 2f
-    plot_padding, // 2f
-    label_padding, // 2f
-    legend_padding, // 2f
-    legend_inner_padding, // 2f
-    legend_spacing, // 2f
-    mouse_pos_padding, // 2f
-    annotation_padding, // 2f
-    fit_padding, // 2f
-    plot_default_size, // 2f
-    plot_min_size, // 2f
-};
-const PushStyleVar1i = struct {
-    idx: StyleVar,
-    v: i32,
-};
-pub fn pushStyleVar1i(args: PushStyleVar1i) void {
-    zguiPlot_PushStyleVar1i(args.idx, args.v);
-}
-const PushStyleVar1f = struct {
-    idx: StyleVar,
-    v: f32,
-};
-pub fn pushStyleVar1f(args: PushStyleVar1f) void {
-    zguiPlot_PushStyleVar1f(args.idx, args.v);
-}
-const PushStyleVar2f = struct {
-    idx: StyleVar,
-    v: [2]f32,
-};
-pub fn pushStyleVar2f(args: PushStyleVar2f) void {
-    zguiPlot_PushStyleVar2f(args.idx, &args.v);
-}
-const PopStyleVar = struct {
-    count: i32 = 1,
-};
-pub fn popStyleVar(args: PopStyleVar) void {
-    zguiPlot_PopStyleVar(args.count);
-}
-extern fn zguiPlot_PushStyleVar1i(idx: StyleVar, v: i32) void;
-extern fn zguiPlot_PushStyleVar1f(idx: StyleVar, v: f32) void;
-extern fn zguiPlot_PushStyleVar2f(idx: StyleVar, v: *const [2]f32) void;
-extern fn zguiPlot_PopStyleVar(count: i32) void;
-//--------------------------------------------------------------------------------------------------
-pub const PlotLocation = packed struct(u32) {
-    north: bool = false,
-    south: bool = false,
-    west: bool = false,
-    east: bool = false,
-    _padding: u28 = 0,
-
-    pub const north_west = PlotLocation{ .north = true, .west = true };
-    pub const north_east = PlotLocation{ .north = true, .east = true };
-    pub const south_west = PlotLocation{ .south = true, .west = true };
-    pub const south_east = PlotLocation{ .south = true, .east = true };
-};
-pub const LegendFlags = packed struct(u32) {
-    no_buttons: bool = false,
-    no_highlight_item: bool = false,
-    no_highlight_axis: bool = false,
-    no_menus: bool = false,
-    outside: bool = false,
-    horizontal: bool = false,
-    _padding: u26 = 0,
-};
-pub fn setupLegend(location: PlotLocation, flags: LegendFlags) void {
-    zguiPlot_SetupLegend(location, flags);
-}
-extern fn zguiPlot_SetupLegend(location: PlotLocation, flags: LegendFlags) void;
-//--------------------------------------------------------------------------------------------------
-pub const AxisFlags = packed struct(u32) {
-    no_label: bool = false,
-    no_grid_lines: bool = false,
-    no_tick_marks: bool = false,
-    no_tick_labels: bool = false,
-    no_initial_fit: bool = false,
-    no_menus: bool = false,
-    no_side_switch: bool = false,
-    no_highlight: bool = false,
-    opposite: bool = false,
-    foreground: bool = false,
-    invert: bool = false,
-    auto_fit: bool = false,
-    range_fit: bool = false,
-    pan_stretch: bool = false,
-    lock_min: bool = false,
-    lock_max: bool = false,
-    _padding: u16 = 0,
-
-    pub const lock = AxisFlags{
-        .lock_min = true,
-        .lock_max = true,
-    };
-    pub const no_decorations = AxisFlags{
-        .no_label = true,
-        .no_grid_lines = true,
-        .no_tick_marks = true,
-        .no_tick_labels = true,
-    };
-    pub const aux_default = AxisFlags{
-        .no_grid_lines = true,
-        .opposite = true,
-    };
-};
-pub const Axis = enum(u32) { x1, x2, x3, y1, y2, y3 };
-pub const SetupAxis = struct {
-    label: ?[:0]const u8 = null,
-    flags: AxisFlags = .{},
-};
-pub fn setupAxis(axis: Axis, args: SetupAxis) void {
-    zguiPlot_SetupAxis(axis, if (args.label) |l| l else null, args.flags);
-}
-extern fn zguiPlot_SetupAxis(axis: Axis, label: ?[*:0]const u8, flags: AxisFlags) void;
-//----------------------------------------------------------------------------------------------
-pub const Condition = enum(u32) {
-    none = @intFromEnum(gui.Condition.none),
-    always = @intFromEnum(gui.Condition.always),
-    once = @intFromEnum(gui.Condition.once),
-};
-const SetupAxisLimits = struct {
-    min: f64,
-    max: f64,
-    cond: Condition = .once,
-};
-pub fn setupAxisLimits(axis: Axis, args: SetupAxisLimits) void {
-    zguiPlot_SetupAxisLimits(axis, args.min, args.max, args.cond);
-}
-extern fn zguiPlot_SetupAxisLimits(axis: Axis, min: f64, max: f64, cond: Condition) void;
-//----------------------------------------------------------------------------------------------
-/// `pub fn setupFinish() void`
-pub const setupFinish = zguiPlot_SetupFinish;
-extern fn zguiPlot_SetupFinish() void;
-//----------------------------------------------------------------------------------------------
-pub const Flags = packed struct(u32) {
-    no_title: bool = false,
-    no_legend: bool = false,
-    no_mouse_text: bool = false,
-    no_inputs: bool = false,
-    no_menus: bool = false,
-    no_box_select: bool = false,
-    no_child: bool = false,
-    no_frame: bool = false,
-    equal: bool = false,
-    crosshairs: bool = false,
-    _padding: u22 = 0,
-
-    pub const canvas_only = Flags{
-        .no_title = true,
-        .no_legend = true,
-        .no_menus = true,
-        .no_box_select = true,
-        .no_mouse_text = true,
-    };
-};
-pub const BeginPlot = struct {
-    w: f32 = -1.0,
-    h: f32 = 0.0,
-    flags: Flags = .{},
-};
-pub fn beginPlot(title_id: [:0]const u8, args: BeginPlot) bool {
-    return zguiPlot_BeginPlot(title_id, args.w, args.h, args.flags);
-}
-extern fn zguiPlot_BeginPlot(title_id: [*:0]const u8, width: f32, height: f32, flags: Flags) bool;
-//----------------------------------------------------------------------------------------------
-pub const LineFlags = packed struct(u32) {
-    _reserved0: bool = false,
-    _reserved1: bool = false,
-    _reserved2: bool = false,
-    _reserved3: bool = false,
-    _reserved4: bool = false,
-    _reserved5: bool = false,
-    _reserved6: bool = false,
-    _reserved7: bool = false,
-    _reserved8: bool = false,
-    _reserved9: bool = false,
-    segments: bool = false,
-    loop: bool = false,
-    skip_nan: bool = false,
-    no_clip: bool = false,
-    shaded: bool = false,
-    _padding: u17 = 0,
-};
-fn PlotLineValuesGen(comptime T: type) type {
-    return struct {
-        v: []const T,
-        xscale: f64 = 1.0,
-        xstart: f64 = 0.0,
-        flags: LineFlags = .{},
-        offset: i32 = 0,
-        stride: i32 = @sizeOf(T),
-    };
-}
-pub fn plotLineValues(label_id: [:0]const u8, comptime T: type, args: PlotLineValuesGen(T)) void {
-    zguiPlot_PlotLineValues(
-        label_id,
-        gui.typeToDataTypeEnum(T),
-        args.v.ptr,
-        @as(i32, @intCast(args.v.len)),
-        args.xscale,
-        args.xstart,
-        args.flags,
-        args.offset,
-        args.stride,
-    );
-}
-extern fn zguiPlot_PlotLineValues(
-    label_id: [*:0]const u8,
-    data_type: gui.DataType,
-    values: *const anyopaque,
-    count: i32,
-    xscale: f64,
-    xstart: f64,
-    flags: LineFlags,
-    offset: i32,
-    stride: i32,
-) void;
-//----------------------------------------------------------------------------------------------
-fn PlotLineGen(comptime T: type) type {
-    return struct {
-        xv: []const T,
-        yv: []const T,
-        flags: LineFlags = .{},
-        offset: i32 = 0,
-        stride: i32 = @sizeOf(T),
-    };
-}
-pub fn plotLine(label_id: [:0]const u8, comptime T: type, args: PlotLineGen(T)) void {
-    assert(args.xv.len == args.yv.len);
-    zguiPlot_PlotLine(
-        label_id,
-        gui.typeToDataTypeEnum(T),
-        args.xv.ptr,
-        args.yv.ptr,
-        @as(i32, @intCast(args.xv.len)),
-        args.flags,
-        args.offset,
-        args.stride,
-    );
-}
-extern fn zguiPlot_PlotLine(
-    label_id: [*:0]const u8,
-    data_type: gui.DataType,
-    xv: *const anyopaque,
-    yv: *const anyopaque,
-    count: i32,
-    flags: LineFlags,
-    offset: i32,
-    stride: i32,
-) void;
-//----------------------------------------------------------------------------------------------
-pub const ScatterFlags = packed struct(u32) {
-    _reserved0: bool = false,
-    _reserved1: bool = false,
-    _reserved2: bool = false,
-    _reserved3: bool = false,
-    _reserved4: bool = false,
-    _reserved5: bool = false,
-    _reserved6: bool = false,
-    _reserved7: bool = false,
-    _reserved8: bool = false,
-    _reserved9: bool = false,
-    no_clip: bool = false,
-    _padding: u21 = 0,
-};
-fn PlotScatterValuesGen(comptime T: type) type {
-    return struct {
-        v: []const T,
-        xscale: f64 = 1.0,
-        xstart: f64 = 0.0,
-        flags: ScatterFlags = .{},
-        offset: i32 = 0,
-        stride: i32 = @sizeOf(T),
-    };
-}
-pub fn plotScatterValues(label_id: [:0]const u8, comptime T: type, args: PlotScatterValuesGen(T)) void {
-    zguiPlot_PlotScatterValues(
-        label_id,
-        gui.typeToDataTypeEnum(T),
-        args.v.ptr,
-        @as(i32, @intCast(args.v.len)),
-        args.xscale,
-        args.xstart,
-        args.flags,
-        args.offset,
-        args.stride,
-    );
-}
-extern fn zguiPlot_PlotScatterValues(
-    label_id: [*:0]const u8,
-    data_type: gui.DataType,
-    values: *const anyopaque,
-    count: i32,
-    xscale: f64,
-    xstart: f64,
-    flags: ScatterFlags,
-    offset: i32,
-    stride: i32,
-) void;
-//----------------------------------------------------------------------------------------------
-fn PlotScatterGen(comptime T: type) type {
-    return struct {
-        xv: []const T,
-        yv: []const T,
-        flags: ScatterFlags = .{},
-        offset: i32 = 0,
-        stride: i32 = @sizeOf(T),
-    };
-}
-pub fn plotScatter(label_id: [:0]const u8, comptime T: type, args: PlotScatterGen(T)) void {
-    assert(args.xv.len == args.yv.len);
-    zguiPlot_PlotScatter(
-        label_id,
-        gui.typeToDataTypeEnum(T),
-        args.xv.ptr,
-        args.yv.ptr,
-        @as(i32, @intCast(args.xv.len)),
-        args.flags,
-        args.offset,
-        args.stride,
-    );
-}
-extern fn zguiPlot_PlotScatter(
-    label_id: [*:0]const u8,
-    data_type: gui.DataType,
-    xv: *const anyopaque,
-    yv: *const anyopaque,
-    count: i32,
-    flags: ScatterFlags,
-    offset: i32,
-    stride: i32,
-) void;
-
-pub const ShadedFlags = packed struct(u32) {
-    _padding: u32 = 0,
-};
-fn PlotShadedGen(comptime T: type) type {
-    return struct {
-        xv: []const T,
-        yv: []const T,
-        yref: f64 = 0.0,
-        flags: ShadedFlags = .{},
-        offset: i32 = 0,
-        stride: i32 = @sizeOf(T),
-    };
-}
-pub fn plotShaded(label_id: [:0]const u8, comptime T: type, args: PlotShadedGen(T)) void {
-    assert(args.xv.len == args.yv.len);
-    zguiPlot_PlotShaded(
-        label_id,
-        gui.typeToDataTypeEnum(T),
-        args.xv.ptr,
-        args.yv.ptr,
-        @as(i32, @intCast(args.xv.len)),
-        args.yref,
-        args.flags,
-        args.offset,
-        args.stride,
-    );
-}
-extern fn zguiPlot_PlotShaded(
-    label_id: [*:0]const u8,
-    data_type: gui.DataType,
-    xv: *const anyopaque,
-    yv: *const anyopaque,
-    count: i32,
-    yref: f64,
-    flags: ShadedFlags,
-    offset: i32,
-    stride: i32,
-) void;
-//----------------------------------------------------------------------------------------------
-pub const DragToolFlags = packed struct(u32) {
-    no_cursors: bool = false,
-    no_fit: bool = false,
-    no_no_inputs: bool = false,
-    delayed: bool = false,
-    _padding: u28 = 0,
-};
-const DragPoint = struct {
-    x: *f64,
-    y: *f64,
-    col: [4]f32,
-    size: f32 = 4,
-    flags: DragToolFlags = .{},
-};
-pub fn dragPoint(id: i32, args: DragPoint) bool {
-    return zguiPlot_DragPoint(
-        id,
-        args.x,
-        args.y,
-        &args.col,
-        args.size,
-        args.flags,
-    );
-}
-extern fn zguiPlot_DragPoint(id: i32, x: *f64, y: *f64, *const [4]f32, size: f32, flags: DragToolFlags) bool;
-//----------------------------------------------------------------------------------------------
-// PlotText
-const PlotTextFlags = packed struct(u32) {
-    vertical: bool = false,
-    _padding: u31 = 0,
-};
-const PlotText = struct {
-    x: f64,
-    y: f64,
-    pix_offset: [2]f32 = .{ 0, 0 },
-    flags: PlotTextFlags = .{},
-};
-pub fn plotText(text: [*:0]const u8, args: PlotText) void {
-    zguiPlot_PlotText(text, args.x, args.y, &args.pix_offset, args.flags);
-}
-extern fn zguiPlot_PlotText(
-    text: [*:0]const u8,
-    x: f64,
-    y: f64,
-    pix_offset: *const [2]f32,
-    flags: PlotTextFlags,
-) void;
-
-//----------------------------------------------------------------------------------------------
-/// `pub fn showDemoWindow(popen: ?*bool) void`
-pub const showDemoWindow = zguiPlot_ShowDemoWindow;
-extern fn zguiPlot_ShowDemoWindow(popen: ?*bool) void;
-//----------------------------------------------------------------------------------------------
-/// `pub fn endPlot() void`
-pub const endPlot = zguiPlot_EndPlot;
-extern fn zguiPlot_EndPlot() void;
-//----------------------------------------------------------------------------------------------
diff --git a/vendor/zgui/src/te.zig b/vendor/zgui/src/te.zig
deleted file mode 100644
index efd1eab..0000000
--- a/vendor/zgui/src/te.zig
+++ /dev/null
@@ -1,255 +0,0 @@
-const std = @import("std");
-const zgui = @import("gui.zig");
-const te_enabled = @import("zgui_options").with_te;
-
-pub const Actions = enum(c_int) {
-    unknown = 0,
-    /// Move mouse
-    hover,
-    /// Move mouse and click
-    click,
-    /// Move mouse and double-click
-    double_click,
-    /// Check item if unchecked (Checkbox, MenuItem or any widget reporting ImGuiItemStatusFlags_Checkable)
-    check,
-    /// Uncheck item if checked
-    uncheck,
-    /// Open item if closed (TreeNode, BeginMenu or any widget reporting ImGuiItemStatusFlags_Openable)
-    open,
-    /// Close item if opened
-    close,
-    /// Start text inputing into a field (e.g. CTRL+Click on Drags/Slider, click on InputText etc.)
-    input,
-    /// Activate item with navigation
-    nav_activate,
-};
-
-pub const TestRunFlags = packed struct(c_int) {
-    /// Used internally to temporarily disable the GUI func (at the end of a test, etc)
-    gui_func_disable: bool = false,
-    /// Set when user selects "Run GUI func"
-    gui_func_only: bool = false,
-    no_success_mgs: bool = false,
-    no_stop_on_error: bool = false,
-    no_break_on_error: bool = false,
-    /// Disable input submission to let test submission raw input event (in order to test e.g. IO queue)
-    enable_raw_inputs: bool = false,
-    manual_run: bool = false,
-    command_line: bool = false,
-    _padding: u24 = 0,
-};
-
-pub const TestOpFlags = packed struct(c_int) {
-    // Don't check for HoveredId after aiming for a widget. A few situations may want this: while e.g. dragging or another items prevents hovering, or for items that don't use ItemHoverable()
-    no_check_hovered_id: bool = false,
-    /// Don't abort/error e.g. if the item cannot be found or the operation doesn't succeed.
-    no_error: bool = false,
-    /// Don't focus window when aiming at an item
-    no_focus_window: bool = false,
-    /// Disable automatically uncollapsing windows (useful when specifically testing Collapsing behaviors)
-    no_auto_uncollapse: bool = false,
-    /// Disable automatically opening intermediaries (e.g. ItemClick("Hello/OK") will automatically first open "Hello" if "OK" isn't found. Only works if ref is a string path.
-    no_auto_open_full_path: bool = false,
-    /// Used by recursing functions to indicate a second attempt
-    is_second_attempt: bool = false,
-    move_to_edge_l: bool = false, // Simple Dumb aiming helpers to test widget that care about clicking position. May need to replace will better functionalities.
-    move_to_edge_r: bool = false,
-    move_to_edge_u: bool = false,
-    move_to_edge_d: bool = false,
-    _padding: u22 = 0,
-};
-
-pub const CheckFlags = packed struct(c_int) {
-    silent_success: bool = false,
-    _padding: u31 = 0,
-};
-
-pub const RunSpeed = enum(c_int) {
-    /// Run tests as fast as possible (teleport mouse, skip delays, etc.)
-    fast = 0,
-    /// Run tests at human watchable speed (for debugging)
-    normal = 1,
-    /// Run tests with pauses between actions (for e.g. tutorials)
-    cinematic = 2,
-};
-
-pub const TestGroup = enum(c_int) {
-    unknown = -1,
-    tests = 0,
-    perfs = 1,
-};
-
-pub const Test = anyopaque;
-
-pub const TestEngine = opaque {
-    pub fn registerTest(
-        engine: *TestEngine,
-        category: [:0]const u8,
-        name: [:0]const u8,
-        src: std.builtin.SourceLocation,
-        comptime Callbacks: type,
-    ) *Test {
-        return zguiTe_RegisterTest(
-            engine,
-            category.ptr,
-            name.ptr,
-            src.file.ptr,
-            @intCast(src.line),
-            if (std.meta.hasFn(Callbacks, "gui"))
-                struct {
-                    fn f(context: *TestContext) callconv(.C) void {
-                        Callbacks.gui(context) catch undefined;
-                    }
-                }.f
-            else
-                null,
-            if (std.meta.hasFn(Callbacks, "run"))
-                struct {
-                    fn f(context: *TestContext) callconv(.C) void {
-                        Callbacks.run(context) catch undefined;
-                    }
-                }.f
-            else
-                null,
-        );
-    }
-
-    pub const showTestEngineWindows = zguiTe_ShowTestEngineWindows;
-    extern fn zguiTe_ShowTestEngineWindows(engine: *TestEngine, p_open: ?*bool) void;
-
-    pub const setRunSpeed = zguiTe_EngineSetRunSpeed;
-    extern fn zguiTe_EngineSetRunSpeed(engine: *TestEngine, speed: RunSpeed) void;
-
-    pub const stop = zguiTe_Stop;
-    extern fn zguiTe_Stop(engine: *TestEngine) void;
-
-    pub const tryAbortEngine = zguiTe_TryAbortEngine;
-    extern fn zguiTe_TryAbortEngine(engine: *TestEngine) void;
-
-    pub const postSwap = zguiTe_PostSwap;
-    extern fn zguiTe_PostSwap(engine: *TestEngine) void;
-
-    pub const isTestQueueEmpty = zguiTe_IsTestQueueEmpty;
-    extern fn zguiTe_IsTestQueueEmpty(engine: *TestEngine) bool;
-
-    pub const getResult = zguiTe_GetResult;
-    extern fn zguiTe_GetResult(engine: *TestEngine, count_tested: *c_int, count_success: *c_int) void;
-
-    pub const printResultSummary = zguiTe_PrintResultSummary;
-    extern fn zguiTe_PrintResultSummary(engine: *TestEngine) void;
-
-    pub fn queueTests(engine: *TestEngine, group: TestGroup, filter_str: [:0]const u8, run_flags: TestRunFlags) void {
-        zguiTe_QueueTests(engine, group, filter_str.ptr, run_flags);
-    }
-    extern fn zguiTe_QueueTests(engine: *TestEngine, group: TestGroup, filter_str: [*]const u8, run_flags: TestRunFlags) void;
-
-    pub fn exportJunitResult(engine: *TestEngine, filename: [:0]const u8) void {
-        zguiTe_EngineExportJunitResult(engine, filename.ptr);
-    }
-    extern fn zguiTe_EngineExportJunitResult(engine: *TestEngine, filename: [*]const u8) void;
-};
-
-pub const TestContext = opaque {
-    pub fn setRef(ctx: *TestContext, ref: [:0]const u8) void {
-        return zguiTe_ContextSetRef(ctx, ref.ptr);
-    }
-
-    pub fn windowFocus(ctx: *TestContext, ref: [:0]const u8) void {
-        return zguiTe_ContextWindowFocus(ctx, ref.ptr);
-    }
-
-    pub fn yield(ctx: *TestContext, frame_count: i32) void {
-        return zguiTe_ContextYield(ctx, frame_count);
-    }
-
-    pub fn itemAction(ctx: *TestContext, action: Actions, ref: [:0]const u8, flags: TestOpFlags, action_arg: ?*anyopaque) void {
-        return zguiTe_ContextItemAction(ctx, action, ref.ptr, flags, action_arg);
-    }
-
-    pub fn itemInputStrValue(ctx: *TestContext, ref: [:0]const u8, value: [:0]const u8) void {
-        return zguiTe_ContextItemInputStrValue(ctx, ref.ptr, value.ptr);
-    }
-
-    pub fn itemInputIntValue(ctx: *TestContext, ref: [:0]const u8, value: i32) void {
-        return zguiTe_ContextItemInputIntValue(ctx, ref.ptr, value);
-    }
-
-    pub fn itemInputFloatValue(ctx: *TestContext, ref: [:0]const u8, value: f32) void {
-        return zguiTe_ContextItemInputFloatValue(ctx, ref.ptr, value);
-    }
-
-    pub fn menuAction(ctx: *TestContext, action: Actions, ref: [*]const u8) void {
-        return zguiTe_ContextMenuAction(ctx, action, ref);
-    }
-
-    pub fn dragAndDrop(ctx: *TestContext, ref_src: [:0]const u8, ref_dst: [:0]const u8, button: zgui.MouseButton) void {
-        return zguiTe_ContextDragAndDrop(ctx, ref_src.ptr, ref_dst.ptr, button);
-    }
-
-    pub fn keyDown(ctx: *TestContext, key_chord: c_int) void {
-        return zguiTe_ContextKeyDown(ctx, key_chord);
-    }
-
-    pub fn keyUp(ctx: *TestContext, key_chord: c_int) void {
-        return zguiTe_ContextKeyUp(ctx, key_chord);
-    }
-
-    extern fn zguiTe_ContextSetRef(ctx: *TestContext, ref: [*]const u8) void;
-    extern fn zguiTe_ContextWindowFocus(ctx: *TestContext, ref: [*]const u8) void;
-    extern fn zguiTe_ContextYield(ctx: *TestContext, frame_count: c_int) void;
-    extern fn zguiTe_ContextMenuAction(ctx: *TestContext, action: Actions, ref: [*]const u8) void;
-    extern fn zguiTe_ContextItemAction(ctx: *TestContext, action: Actions, ref: [*]const u8, flags: TestOpFlags, action_arg: ?*anyopaque) void;
-    extern fn zguiTe_ContextItemInputStrValue(ctx: *TestContext, ref: [*]const u8, value: [*]const u8) void;
-    extern fn zguiTe_ContextItemInputIntValue(ctx: *TestContext, ref: [*]const u8, value: i32) void;
-    extern fn zguiTe_ContextItemInputFloatValue(ctx: *TestContext, ref: [*]const u8, value: f32) void;
-    extern fn zguiTe_ContextDragAndDrop(ctx: *TestContext, ref_src: [*]const u8, ref_dst: [*]const u8, button: zgui.MouseButton) void;
-    extern fn zguiTe_ContextKeyDown(ctx: *TestContext, key_chord: c_int) void;
-    extern fn zguiTe_ContextKeyUp(ctx: *TestContext, key_chord: c_int) void;
-};
-
-const ImGuiTestGuiFunc = fn (context: *TestContext) callconv(.C) void;
-const ImGuiTestTestFunc = fn (context: *TestContext) callconv(.C) void;
-
-pub const createContext = zguiTe_CreateContext;
-extern fn zguiTe_CreateContext() *TestEngine;
-
-pub const destroyContext = zguiTe_DestroyContext;
-extern fn zguiTe_DestroyContext(engine: *TestEngine) void;
-
-extern fn zguiTe_Check(filename: [*]const u8, func: [*]const u8, line: u32, flags: CheckFlags, resul: bool, expr: [*]const u8) bool;
-
-pub fn check(src: std.builtin.SourceLocation, flags: CheckFlags, resul: bool, expr: [:0]const u8) bool {
-    return zguiTe_Check(src.file.ptr, src.fn_name.ptr, src.line, flags, resul, expr.ptr);
-}
-
-pub extern fn zguiTe_RegisterTest(
-    engine: *TestEngine,
-    category: [*]const u8,
-    name: [*]const u8,
-    src: [*]const u8,
-    src_line: c_int,
-    gui_fce: ?*const ImGuiTestGuiFunc,
-    gui_test_fce: ?*const ImGuiTestTestFunc,
-) *Test;
-
-pub fn checkTestError(
-    src: std.builtin.SourceLocation,
-    err: anyerror,
-) void {
-    var buff: [128:0]u8 = undefined;
-    const msg = std.fmt.bufPrintZ(&buff, "Assert error: {}", .{err}) catch undefined;
-    _ = zguiTe_Check(src.file.ptr, src.fn_name.ptr, src.line, .{}, false, msg.ptr);
-}
-
-var _te_engine: ?*TestEngine = null;
-pub fn getTestEngine() ?*TestEngine {
-    return _te_engine;
-}
-
-pub fn init() void {
-    _te_engine = createContext();
-}
-
-pub fn deinit() void {
-    destroyContext(_te_engine.?);
-}
diff --git a/vendor/zgui/src/zgui.cpp b/vendor/zgui/src/zgui.cpp
deleted file mode 100644
index 658b009..0000000
--- a/vendor/zgui/src/zgui.cpp
+++ /dev/null
@@ -1,2708 +0,0 @@
-#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