chore: import upstream snapshot with attribution

pkg/dcimgui/build.zig

@@ -0,0 +1,216 @@
+const std = @import("std");
+const NativeTargetInfo = std.zig.system.NativeTargetInfo;
+
+pub fn build(b: *std.Build) !void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+    const freetype = b.option(bool, "freetype", "Use Freetype") orelse false;
+    const backend_opengl3 = b.option(bool, "backend-opengl3", "OpenGL3 backend") orelse false;
+    const backend_metal = b.option(bool, "backend-metal", "Metal backend") orelse false;
+    const backend_osx = b.option(bool, "backend-osx", "OSX backend") orelse false;
+
+    // Build options
+    const options = b.addOptions();
+    options.addOption(bool, "freetype", freetype);
+    options.addOption(bool, "backend_opengl3", backend_opengl3);
+    options.addOption(bool, "backend_metal", backend_metal);
+    options.addOption(bool, "backend_osx", backend_osx);
+
+    // Main static lib
+    const lib = b.addLibrary(.{
+        .name = "dcimgui",
+        .root_module = b.createModule(.{
+            .target = target,
+            .optimize = optimize,
+        }),
+        .linkage = .static,
+    });
+    lib.linkLibC();
+    // On MSVC, we must not use linkLibCpp because Zig unconditionally
+    // passes -nostdinc++ and then adds its bundled libc++/libc++abi
+    // include paths, which conflict with MSVC's own C++ runtime headers.
+    // The MSVC SDK include directories (added via linkLibC) contain
+    // both C and C++ headers, so linkLibCpp is not needed.
+    if (target.result.abi != .msvc) {
+        lib.linkLibCpp();
+    }
+    b.installArtifact(lib);
+
+    // Zig module
+    const mod = b.addModule("dcimgui", .{
+        .root_source_file = b.path("main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    mod.addOptions("build_options", options);
+    mod.linkLibrary(lib);
+
+    // We need to add proper Apple SDKs to find stdlib headers
+    if (target.result.os.tag.isDarwin()) {
+        if (!target.query.isNative()) {
+            try @import("apple_sdk").addPaths(b, lib);
+        }
+    }
+
+    // Flags for C compilation, common to all.
+    var flags: std.ArrayList([]const u8) = .empty;
+    defer flags.deinit(b.allocator);
+    try flags.appendSlice(b.allocator, &.{
+        "-DIMGUI_HAS_DOCK=1",
+        "-DIMGUI_USE_WCHAR32=1",
+        "-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1",
+    });
+    if (target.result.abi == .msvc) {
+        try flags.appendSlice(b.allocator, &.{
+            "-fno-sanitize=undefined",
+            "-fno-sanitize-trap=undefined",
+        });
+    }
+    if (freetype) try flags.appendSlice(b.allocator, &.{
+        "-DIMGUI_ENABLE_FREETYPE=1",
+    });
+    if (backend_opengl3) try flags.appendSlice(b.allocator, &.{
+        "-DZIGPKG_IMGUI_ENABLE_OPENGL3=1",
+    });
+    if (target.result.os.tag == .windows) {
+        try flags.appendSlice(b.allocator, &.{
+            "-DIMGUI_IMPL_API=extern\t\"C\"\t__declspec(dllexport)",
+        });
+    } else {
+        try flags.appendSlice(b.allocator, &.{
+            "-DIMGUI_IMPL_API=extern\t\"C\"",
+        });
+    }
+    if (target.result.os.tag == .freebsd or target.result.abi == .musl) {
+        try flags.append(b.allocator, "-fPIC");
+    }
+
+    // Add the core Dear Imgui source files
+    if (b.lazyDependency("imgui", .{})) |upstream| {
+        lib.addIncludePath(upstream.path(""));
+        lib.addCSourceFiles(.{
+            .root = upstream.path(""),
+            .files = &.{
+                "imgui_demo.cpp",
+                "imgui_draw.cpp",
+                "imgui_tables.cpp",
+                "imgui_widgets.cpp",
+                "imgui.cpp",
+            },
+            .flags = flags.items,
+        });
+
+        lib.installHeadersDirectory(
+            upstream.path(""),
+            "",
+            .{ .include_extensions = &.{".h"} },
+        );
+
+        if (freetype) {
+            lib.addCSourceFile(.{
+                .file = upstream.path("misc/freetype/imgui_freetype.cpp"),
+                .flags = flags.items,
+            });
+
+            if (b.systemIntegrationOption("freetype", .{})) {
+                lib.linkSystemLibrary2("freetype2", dynamic_link_opts);
+            } else {
+                const freetype_dep = b.dependency("freetype", .{
+                    .target = target,
+                    .optimize = optimize,
+                    .@"enable-libpng" = true,
+                });
+                lib.linkLibrary(freetype_dep.artifact("freetype"));
+                if (freetype_dep.builder.lazyDependency(
+                    "freetype",
+                    .{},
+                )) |freetype_upstream| {
+                    mod.addIncludePath(freetype_upstream.path("include"));
+                }
+            }
+        }
+
+        if (backend_metal) {
+            lib.addCSourceFiles(.{
+                .root = upstream.path("backends"),
+                .files = &.{"imgui_impl_metal.mm"},
+                .flags = flags.items,
+            });
+            lib.installHeadersDirectory(
+                upstream.path("backends"),
+                "",
+                .{ .include_extensions = &.{"imgui_impl_metal.h"} },
+            );
+        }
+        if (backend_osx) {
+            lib.addCSourceFiles(.{
+                .root = upstream.path("backends"),
+                .files = &.{"imgui_impl_osx.mm"},
+                .flags = flags.items,
+            });
+            lib.installHeadersDirectory(
+                upstream.path("backends"),
+                "",
+                .{ .include_extensions = &.{"imgui_impl_osx.h"} },
+            );
+        }
+        if (backend_opengl3) {
+            lib.addCSourceFiles(.{
+                .root = upstream.path("backends"),
+                .files = &.{"imgui_impl_opengl3.cpp"},
+                .flags = flags.items,
+            });
+            lib.installHeadersDirectory(
+                upstream.path("backends"),
+                "",
+                .{ .include_extensions = &.{"imgui_impl_opengl3.h"} },
+            );
+        }
+    }
+
+    // Add the C bindings
+    if (b.lazyDependency("bindings", .{})) |upstream| {
+        lib.addIncludePath(upstream.path(""));
+        lib.addCSourceFiles(.{
+            .root = upstream.path(""),
+            .files = &.{
+                "dcimgui.cpp",
+                "dcimgui_internal.cpp",
+            },
+            .flags = flags.items,
+        });
+        lib.addCSourceFiles(.{
+            .root = b.path(""),
+            .files = &.{"ext.cpp"},
+            .flags = flags.items,
+        });
+
+        lib.installHeadersDirectory(
+            upstream.path(""),
+            "",
+            .{ .include_extensions = &.{".h"} },
+        );
+    }
+
+    const test_exe = b.addTest(.{
+        .name = "test",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("main.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
+    });
+    test_exe.root_module.addOptions("build_options", options);
+    test_exe.linkLibrary(lib);
+    const tests_run = b.addRunArtifact(test_exe);
+    const test_step = b.step("test", "Run tests");
+    test_step.dependOn(&tests_run.step);
+}
+
+// For dynamic linking, we prefer dynamic linking and to search by
+// mode first. Mode first will search all paths for a dynamic library
+// before falling back to static.
+const dynamic_link_opts: std.Build.Module.LinkSystemLibraryOptions = .{
+    .preferred_link_mode = .dynamic,
+    .search_strategy = .mode_first,
+};

pkg/dcimgui/build.zig.zon

@@ -0,0 +1,26 @@
+.{
+    .name = .dcimgui,
+    .version = "1.92.5", // -docking branch
+    .fingerprint = 0x1a25797442c6324f,
+    .paths = .{""},
+    .dependencies = .{
+        // The bindings and imgui versions below must match exactly.
+
+        .bindings = .{
+            // https://github.com/dearimgui/dear_bindings
+            .url = "https://deps.files.ghostty.org/DearBindings_v0.17_ImGui_v1.92.5-docking.tar.gz",
+            .hash = "N-V-__8AANT61wB--nJ95Gj_ctmzAtcjloZ__hRqNw5lC1Kr",
+            .lazy = true,
+        },
+
+        .imgui = .{
+            // https://github.com/ocornut/imgui
+            .url = "https://github.com/ocornut/imgui/archive/refs/tags/v1.92.5-docking.tar.gz",
+            .hash = "N-V-__8AAEbOfQBnvcFcCX2W5z7tDaN8vaNZGamEQtNOe0UI",
+            .lazy = true,
+        },
+
+        .apple_sdk = .{ .path = "../apple-sdk" },
+        .freetype = .{ .path = "../freetype" },
+    },
+}

pkg/dcimgui/ext.cpp

@@ -0,0 +1,53 @@
+#include "imgui.h"
+
+// This file contains custom extensions for functionality that isn't
+// properly supported by Dear Bindings yet. Namely:
+// https://github.com/dearimgui/dear_bindings/issues/55
+
+// Wrap this in a namespace to keep it separate from the C++ API
+namespace cimgui
+{
+#include "dcimgui.h"
+}
+
+extern "C"
+{
+CIMGUI_API void ImFontConfig_ImFontConfig(cimgui::ImFontConfig* self)
+{
+    static_assert(sizeof(cimgui::ImFontConfig) == sizeof(::ImFontConfig), "ImFontConfig size mismatch");
+    static_assert(alignof(cimgui::ImFontConfig) == alignof(::ImFontConfig), "ImFontConfig alignment mismatch");
+    ::ImFontConfig defaults;
+    *reinterpret_cast<::ImFontConfig*>(self) = defaults;
+}
+
+CIMGUI_API void ImGuiStyle_ImGuiStyle(cimgui::ImGuiStyle* self)
+{
+    static_assert(sizeof(cimgui::ImGuiStyle) == sizeof(::ImGuiStyle), "ImGuiStyle size mismatch");
+    static_assert(alignof(cimgui::ImGuiStyle) == alignof(::ImGuiStyle), "ImGuiStyle alignment mismatch");
+    ::ImGuiStyle defaults;
+    *reinterpret_cast<::ImGuiStyle*>(self) = defaults;
+}
+
+// Perform the OpenGL3 backend shutdown and then zero out the imgl3w
+// function pointer table. ImGui_ImplOpenGL3_Shutdown() calls
+// imgl3wShutdown() which dlcloses the GL library handles but does not
+// zero out the function pointers. A subsequent ImGui_ImplOpenGL3_Init()
+// sees the stale (non-null) pointers, skips loader re-initialization,
+// and crashes when calling through them. Zeroing the table forces the
+// next Init to reload the GL function pointers via imgl3wInit().
+#ifndef IMGUI_DISABLE
+#if __has_include("backends/imgui_impl_opengl3.h")
+#ifdef ZIGPKG_IMGUI_ENABLE_OPENGL3
+#include "backends/imgui_impl_opengl3.h"
+#include "backends/imgui_impl_opengl3_loader.h"
+
+CIMGUI_API void ImGui_ImplOpenGL3_ShutdownWithLoaderCleanup()
+{
+    ::ImGui_ImplOpenGL3_Shutdown();
+    memset(&imgl3wProcs, 0, sizeof(imgl3wProcs));
+}
+#endif // ZIGPKG_IMGUI_ENABLE_OPENGL3
+#endif // __has_include("backends/imgui_impl_opengl3.h")
+#endif // IMGUI_DISABLE
+
+}

pkg/dcimgui/main.zig

@@ -0,0 +1,77 @@
+pub const build_options = @import("build_options");
+
+pub const c = @cImport({
+    // This is set during the build so it also has to be set
+    // during import time to get the right types. Without this
+    // you get stack size mismatches on some structs.
+    @cDefine("IMGUI_USE_WCHAR32", "1");
+
+    @cDefine("IMGUI_HAS_DOCK", "1");
+    @cInclude("dcimgui.h");
+});
+
+// OpenGL3 backend
+pub extern fn ImGui_ImplOpenGL3_Init(glsl_version: ?[*:0]const u8) callconv(.c) bool;
+pub extern fn ImGui_ImplOpenGL3_Shutdown() callconv(.c) void;
+pub extern fn ImGui_ImplOpenGL3_NewFrame() callconv(.c) void;
+pub extern fn ImGui_ImplOpenGL3_RenderDrawData(draw_data: *c.ImDrawData) callconv(.c) void;
+
+// Extension: shutdown the OpenGL3 backend and zero out the imgl3w function
+// pointer table so a subsequent Init can re-initialize the loader.
+pub extern fn ImGui_ImplOpenGL3_ShutdownWithLoaderCleanup() callconv(.c) void;
+
+// Metal backend
+pub extern fn ImGui_ImplMetal_Init(device: *anyopaque) callconv(.c) bool;
+pub extern fn ImGui_ImplMetal_Shutdown() callconv(.c) void;
+pub extern fn ImGui_ImplMetal_NewFrame(render_pass_descriptor: *anyopaque) callconv(.c) void;
+pub extern fn ImGui_ImplMetal_RenderDrawData(draw_data: *c.ImDrawData, command_buffer: *anyopaque, command_encoder: *anyopaque) callconv(.c) void;
+
+// OSX
+pub extern fn ImGui_ImplOSX_Init(*anyopaque) callconv(.c) bool;
+pub extern fn ImGui_ImplOSX_Shutdown() callconv(.c) void;
+pub extern fn ImGui_ImplOSX_NewFrame(*anyopaque) callconv(.c) void;
+
+// Internal API types and functions from dcimgui_internal.h
+// We declare these manually because the internal header contains bitfields
+// that Zig's cImport cannot translate.
+pub const ImGuiDockNodeFlagsPrivate = struct {
+    pub const DockSpace: c.ImGuiDockNodeFlags = 1 << 10;
+    pub const CentralNode: c.ImGuiDockNodeFlags = 1 << 11;
+    pub const NoTabBar: c.ImGuiDockNodeFlags = 1 << 12;
+    pub const HiddenTabBar: c.ImGuiDockNodeFlags = 1 << 13;
+    pub const NoWindowMenuButton: c.ImGuiDockNodeFlags = 1 << 14;
+    pub const NoCloseButton: c.ImGuiDockNodeFlags = 1 << 15;
+    pub const NoResizeX: c.ImGuiDockNodeFlags = 1 << 16;
+    pub const NoResizeY: c.ImGuiDockNodeFlags = 1 << 17;
+    pub const DockedWindowsInFocusRoute: c.ImGuiDockNodeFlags = 1 << 18;
+    pub const NoDockingSplitOther: c.ImGuiDockNodeFlags = 1 << 19;
+    pub const NoDockingOverMe: c.ImGuiDockNodeFlags = 1 << 20;
+    pub const NoDockingOverOther: c.ImGuiDockNodeFlags = 1 << 21;
+    pub const NoDockingOverEmpty: c.ImGuiDockNodeFlags = 1 << 22;
+};
+pub extern fn ImGui_DockBuilderDockWindow(window_name: [*:0]const u8, node_id: c.ImGuiID) callconv(.c) void;
+pub extern fn ImGui_DockBuilderGetNode(node_id: c.ImGuiID) callconv(.c) ?*anyopaque;
+pub extern fn ImGui_DockBuilderGetCentralNode(node_id: c.ImGuiID) callconv(.c) ?*anyopaque;
+pub extern fn ImGui_DockBuilderAddNode() callconv(.c) c.ImGuiID;
+pub extern fn ImGui_DockBuilderAddNodeEx(node_id: c.ImGuiID, flags: c.ImGuiDockNodeFlags) callconv(.c) c.ImGuiID;
+pub extern fn ImGui_DockBuilderRemoveNode(node_id: c.ImGuiID) callconv(.c) void;
+pub extern fn ImGui_DockBuilderRemoveNodeDockedWindows(node_id: c.ImGuiID) callconv(.c) void;
+pub extern fn ImGui_DockBuilderRemoveNodeDockedWindowsEx(node_id: c.ImGuiID, clear_settings_refs: bool) callconv(.c) void;
+pub extern fn ImGui_DockBuilderRemoveNodeChildNodes(node_id: c.ImGuiID) callconv(.c) void;
+pub extern fn ImGui_DockBuilderSetNodePos(node_id: c.ImGuiID, pos: c.ImVec2) callconv(.c) void;
+pub extern fn ImGui_DockBuilderSetNodeSize(node_id: c.ImGuiID, size: c.ImVec2) callconv(.c) void;
+pub extern fn ImGui_DockBuilderSplitNode(node_id: c.ImGuiID, split_dir: c.ImGuiDir, size_ratio_for_node_at_dir: f32, out_id_at_dir: *c.ImGuiID, out_id_at_opposite_dir: *c.ImGuiID) callconv(.c) c.ImGuiID;
+pub extern fn ImGui_DockBuilderCopyDockSpace(src_dockspace_id: c.ImGuiID, dst_dockspace_id: c.ImGuiID, in_window_remap_pairs: *c.ImVector_const_charPtr) callconv(.c) void;
+pub extern fn ImGui_DockBuilderCopyNode(src_node_id: c.ImGuiID, dst_node_id: c.ImGuiID, out_node_remap_pairs: *c.ImVector_ImGuiID) callconv(.c) void;
+pub extern fn ImGui_DockBuilderCopyWindowSettings(src_name: [*:0]const u8, dst_name: [*:0]const u8) callconv(.c) void;
+pub extern fn ImGui_DockBuilderFinish(node_id: c.ImGuiID) callconv(.c) void;
+
+// Extension functions from ext.cpp
+pub const ext = struct {
+    pub extern fn ImFontConfig_ImFontConfig(self: *c.ImFontConfig) callconv(.c) void;
+    pub extern fn ImGuiStyle_ImGuiStyle(self: *c.ImGuiStyle) callconv(.c) void;
+};
+
+test {
+    _ = c;
+}