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