Updating to zig 0.15.1

1 files changed, 0 insertions, 596 deletions

diff --git a/vendor/zgui/src/plot.zig b/vendor/zgui/src/plot.zig
deleted file mode 100644
index 8d210f4..0000000
--- a/vendor/zgui/src/plot.zig
+++ /dev/null
@@ -1,596 +0,0 @@
-//--------------------------------------------------------------------------------------------------
-const assert = @import("std").debug.assert;
-const gui = @import("gui.zig");
-//--------------------------------------------------------------------------------------------------
-pub fn init() void {
-    if (zguiPlot_GetCurrentContext() == null) {
-        _ = zguiPlot_CreateContext();
-    }
-}
-pub fn deinit() void {
-    if (zguiPlot_GetCurrentContext() != null) {
-        zguiPlot_DestroyContext(null);
-    }
-}
-const Context = *opaque {};
-
-extern fn zguiPlot_GetCurrentContext() ?Context;
-extern fn zguiPlot_CreateContext() Context;
-extern fn zguiPlot_DestroyContext(ctx: ?Context) void;
-//--------------------------------------------------------------------------------------------------
-pub const Marker = enum(i32) {
-    none = -1,
-    circle = 0,
-    square,
-    diamond,
-    up,
-    down,
-    left,
-    right,
-    cross,
-    plus,
-    asterisk,
-};
-
-pub const Colormap = enum(u32) {
-    deep,
-    dark,
-    pastel,
-    paired,
-    viridis,
-    plasma,
-    hot,
-    cool,
-    pink,
-    jet,
-    twilight,
-    rd_bu,
-    br_b_g,
-    pi_y_g,
-    spectral,
-    greys,
-};
-
-pub const Style = extern struct {
-    line_weight: f32,
-    marker: Marker,
-    marker_size: f32,
-    marker_weight: f32,
-    fill_alpha: f32,
-    error_bar_size: f32,
-    error_bar_weight: f32,
-    digital_bit_height: f32,
-    digital_bit_gap: f32,
-    plot_border_size: f32,
-    minor_alpha: f32,
-    major_tick_len: [2]f32,
-    minor_tick_len: [2]f32,
-    major_tick_size: [2]f32,
-    minor_tick_size: [2]f32,
-    major_grid_size: [2]f32,
-    minor_grid_size: [2]f32,
-    plot_padding: [2]f32,
-    label_padding: [2]f32,
-    legend_padding: [2]f32,
-    legend_inner_padding: [2]f32,
-    legend_spacing: [2]f32,
-    mouse_pos_padding: [2]f32,
-    annotation_padding: [2]f32,
-    fit_padding: [2]f32,
-    plot_default_size: [2]f32,
-    plot_min_size: [2]f32,
-
-    colors: [@typeInfo(StyleCol).Enum.fields.len][4]f32,
-    colormap: Colormap,
-
-    use_local_time: bool,
-    use_iso_8601: bool,
-    use_24h_clock: bool,
-
-    /// `pub fn init() Style`
-    pub const init = zguiPlotStyle_Init;
-    extern fn zguiPlotStyle_Init() Style;
-
-    pub fn getColor(style: Style, idx: StyleCol) [4]f32 {
-        return style.colors[@intFromEnum(idx)];
-    }
-    pub fn setColor(style: *Style, idx: StyleCol, color: [4]f32) void {
-        style.colors[@intFromEnum(idx)] = color;
-    }
-};
-/// `pub fn getStyle() *Style`
-pub const getStyle = zguiPlot_GetStyle;
-extern fn zguiPlot_GetStyle() *Style;
-//--------------------------------------------------------------------------------------------------
-pub const StyleCol = enum(u32) {
-    line,
-    fill,
-    marker_outline,
-    marker_fill,
-    error_bar,
-    frame_bg,
-    plot_bg,
-    plot_border,
-    legend_bg,
-    legend_border,
-    legend_text,
-    title_text,
-    inlay_text,
-    axis_text,
-    axis_grid,
-    axis_tick,
-    axis_bg,
-    axis_bg_hovered,
-    axis_bg_active,
-    selection,
-    crosshairs,
-};
-const PushStyleColor4f = struct {
-    idx: StyleCol,
-    c: [4]f32,
-};
-pub fn pushStyleColor4f(args: PushStyleColor4f) void {
-    zguiPlot_PushStyleColor4f(args.idx, &args.c);
-}
-const PushStyleColor1u = struct {
-    idx: StyleCol,
-    c: u32,
-};
-pub fn pushStyleColor1u(args: PushStyleColor1u) void {
-    zguiPlot_PushStyleColor1u(args.idx, args.c);
-}
-const PopStyleColor = struct {
-    count: i32 = 1,
-};
-pub fn popStyleColor(args: PopStyleColor) void {
-    zguiPlot_PopStyleColor(args.count);
-}
-extern fn zguiPlot_PushStyleColor4f(idx: StyleCol, col: *const [4]f32) void;
-extern fn zguiPlot_PushStyleColor1u(idx: StyleCol, col: u32) void;
-extern fn zguiPlot_PopStyleColor(count: i32) void;
-//--------------------------------------------------------------------------------------------------
-pub const StyleVar = enum(u32) {
-    line_weight, // 1f
-    marker, // 1i
-    marker_size, // 1f
-    marker_weight, // 1f
-    fill_alpha, // 1f
-    error_bar_size, // 1f
-    error_bar_weight, // 1f
-    digital_bit_height, // 1f
-    digital_bit_gap, // 1f
-    plot_border_size, // 1f
-    minor_alpha, // 1f
-    major_tick_len, // 2f
-    minor_tick_len, // 2f
-    major_tick_size, // 2f
-    minor_tick_size, // 2f
-    major_grid_size, // 2f
-    minor_grid_size, // 2f
-    plot_padding, // 2f
-    label_padding, // 2f
-    legend_padding, // 2f
-    legend_inner_padding, // 2f
-    legend_spacing, // 2f
-    mouse_pos_padding, // 2f
-    annotation_padding, // 2f
-    fit_padding, // 2f
-    plot_default_size, // 2f
-    plot_min_size, // 2f
-};
-const PushStyleVar1i = struct {
-    idx: StyleVar,
-    v: i32,
-};
-pub fn pushStyleVar1i(args: PushStyleVar1i) void {
-    zguiPlot_PushStyleVar1i(args.idx, args.v);
-}
-const PushStyleVar1f = struct {
-    idx: StyleVar,
-    v: f32,
-};
-pub fn pushStyleVar1f(args: PushStyleVar1f) void {
-    zguiPlot_PushStyleVar1f(args.idx, args.v);
-}
-const PushStyleVar2f = struct {
-    idx: StyleVar,
-    v: [2]f32,
-};
-pub fn pushStyleVar2f(args: PushStyleVar2f) void {
-    zguiPlot_PushStyleVar2f(args.idx, &args.v);
-}
-const PopStyleVar = struct {
-    count: i32 = 1,
-};
-pub fn popStyleVar(args: PopStyleVar) void {
-    zguiPlot_PopStyleVar(args.count);
-}
-extern fn zguiPlot_PushStyleVar1i(idx: StyleVar, v: i32) void;
-extern fn zguiPlot_PushStyleVar1f(idx: StyleVar, v: f32) void;
-extern fn zguiPlot_PushStyleVar2f(idx: StyleVar, v: *const [2]f32) void;
-extern fn zguiPlot_PopStyleVar(count: i32) void;
-//--------------------------------------------------------------------------------------------------
-pub const PlotLocation = packed struct(u32) {
-    north: bool = false,
-    south: bool = false,
-    west: bool = false,
-    east: bool = false,
-    _padding: u28 = 0,
-
-    pub const north_west = PlotLocation{ .north = true, .west = true };
-    pub const north_east = PlotLocation{ .north = true, .east = true };
-    pub const south_west = PlotLocation{ .south = true, .west = true };
-    pub const south_east = PlotLocation{ .south = true, .east = true };
-};
-pub const LegendFlags = packed struct(u32) {
-    no_buttons: bool = false,
-    no_highlight_item: bool = false,
-    no_highlight_axis: bool = false,
-    no_menus: bool = false,
-    outside: bool = false,
-    horizontal: bool = false,
-    _padding: u26 = 0,
-};
-pub fn setupLegend(location: PlotLocation, flags: LegendFlags) void {
-    zguiPlot_SetupLegend(location, flags);
-}
-extern fn zguiPlot_SetupLegend(location: PlotLocation, flags: LegendFlags) void;
-//--------------------------------------------------------------------------------------------------
-pub const AxisFlags = packed struct(u32) {
-    no_label: bool = false,
-    no_grid_lines: bool = false,
-    no_tick_marks: bool = false,
-    no_tick_labels: bool = false,
-    no_initial_fit: bool = false,
-    no_menus: bool = false,
-    no_side_switch: bool = false,
-    no_highlight: bool = false,
-    opposite: bool = false,
-    foreground: bool = false,
-    invert: bool = false,
-    auto_fit: bool = false,
-    range_fit: bool = false,
-    pan_stretch: bool = false,
-    lock_min: bool = false,
-    lock_max: bool = false,
-    _padding: u16 = 0,
-
-    pub const lock = AxisFlags{
-        .lock_min = true,
-        .lock_max = true,
-    };
-    pub const no_decorations = AxisFlags{
-        .no_label = true,
-        .no_grid_lines = true,
-        .no_tick_marks = true,
-        .no_tick_labels = true,
-    };
-    pub const aux_default = AxisFlags{
-        .no_grid_lines = true,
-        .opposite = true,
-    };
-};
-pub const Axis = enum(u32) { x1, x2, x3, y1, y2, y3 };
-pub const SetupAxis = struct {
-    label: ?[:0]const u8 = null,
-    flags: AxisFlags = .{},
-};
-pub fn setupAxis(axis: Axis, args: SetupAxis) void {
-    zguiPlot_SetupAxis(axis, if (args.label) |l| l else null, args.flags);
-}
-extern fn zguiPlot_SetupAxis(axis: Axis, label: ?[*:0]const u8, flags: AxisFlags) void;
-//----------------------------------------------------------------------------------------------
-pub const Condition = enum(u32) {
-    none = @intFromEnum(gui.Condition.none),
-    always = @intFromEnum(gui.Condition.always),
-    once = @intFromEnum(gui.Condition.once),
-};
-const SetupAxisLimits = struct {
-    min: f64,
-    max: f64,
-    cond: Condition = .once,
-};
-pub fn setupAxisLimits(axis: Axis, args: SetupAxisLimits) void {
-    zguiPlot_SetupAxisLimits(axis, args.min, args.max, args.cond);
-}
-extern fn zguiPlot_SetupAxisLimits(axis: Axis, min: f64, max: f64, cond: Condition) void;
-//----------------------------------------------------------------------------------------------
-/// `pub fn setupFinish() void`
-pub const setupFinish = zguiPlot_SetupFinish;
-extern fn zguiPlot_SetupFinish() void;
-//----------------------------------------------------------------------------------------------
-pub const Flags = packed struct(u32) {
-    no_title: bool = false,
-    no_legend: bool = false,
-    no_mouse_text: bool = false,
-    no_inputs: bool = false,
-    no_menus: bool = false,
-    no_box_select: bool = false,
-    no_child: bool = false,
-    no_frame: bool = false,
-    equal: bool = false,
-    crosshairs: bool = false,
-    _padding: u22 = 0,
-
-    pub const canvas_only = Flags{
-        .no_title = true,
-        .no_legend = true,
-        .no_menus = true,
-        .no_box_select = true,
-        .no_mouse_text = true,
-    };
-};
-pub const BeginPlot = struct {
-    w: f32 = -1.0,
-    h: f32 = 0.0,
-    flags: Flags = .{},
-};
-pub fn beginPlot(title_id: [:0]const u8, args: BeginPlot) bool {
-    return zguiPlot_BeginPlot(title_id, args.w, args.h, args.flags);
-}
-extern fn zguiPlot_BeginPlot(title_id: [*:0]const u8, width: f32, height: f32, flags: Flags) bool;
-//----------------------------------------------------------------------------------------------
-pub const LineFlags = packed struct(u32) {
-    _reserved0: bool = false,
-    _reserved1: bool = false,
-    _reserved2: bool = false,
-    _reserved3: bool = false,
-    _reserved4: bool = false,
-    _reserved5: bool = false,
-    _reserved6: bool = false,
-    _reserved7: bool = false,
-    _reserved8: bool = false,
-    _reserved9: bool = false,
-    segments: bool = false,
-    loop: bool = false,
-    skip_nan: bool = false,
-    no_clip: bool = false,
-    shaded: bool = false,
-    _padding: u17 = 0,
-};
-fn PlotLineValuesGen(comptime T: type) type {
-    return struct {
-        v: []const T,
-        xscale: f64 = 1.0,
-        xstart: f64 = 0.0,
-        flags: LineFlags = .{},
-        offset: i32 = 0,
-        stride: i32 = @sizeOf(T),
-    };
-}
-pub fn plotLineValues(label_id: [:0]const u8, comptime T: type, args: PlotLineValuesGen(T)) void {
-    zguiPlot_PlotLineValues(
-        label_id,
-        gui.typeToDataTypeEnum(T),
-        args.v.ptr,
-        @as(i32, @intCast(args.v.len)),
-        args.xscale,
-        args.xstart,
-        args.flags,
-        args.offset,
-        args.stride,
-    );
-}
-extern fn zguiPlot_PlotLineValues(
-    label_id: [*:0]const u8,
-    data_type: gui.DataType,
-    values: *const anyopaque,
-    count: i32,
-    xscale: f64,
-    xstart: f64,
-    flags: LineFlags,
-    offset: i32,
-    stride: i32,
-) void;
-//----------------------------------------------------------------------------------------------
-fn PlotLineGen(comptime T: type) type {
-    return struct {
-        xv: []const T,
-        yv: []const T,
-        flags: LineFlags = .{},
-        offset: i32 = 0,
-        stride: i32 = @sizeOf(T),
-    };
-}
-pub fn plotLine(label_id: [:0]const u8, comptime T: type, args: PlotLineGen(T)) void {
-    assert(args.xv.len == args.yv.len);
-    zguiPlot_PlotLine(
-        label_id,
-        gui.typeToDataTypeEnum(T),
-        args.xv.ptr,
-        args.yv.ptr,
-        @as(i32, @intCast(args.xv.len)),
-        args.flags,
-        args.offset,
-        args.stride,
-    );
-}
-extern fn zguiPlot_PlotLine(
-    label_id: [*:0]const u8,
-    data_type: gui.DataType,
-    xv: *const anyopaque,
-    yv: *const anyopaque,
-    count: i32,
-    flags: LineFlags,
-    offset: i32,
-    stride: i32,
-) void;
-//----------------------------------------------------------------------------------------------
-pub const ScatterFlags = packed struct(u32) {
-    _reserved0: bool = false,
-    _reserved1: bool = false,
-    _reserved2: bool = false,
-    _reserved3: bool = false,
-    _reserved4: bool = false,
-    _reserved5: bool = false,
-    _reserved6: bool = false,
-    _reserved7: bool = false,
-    _reserved8: bool = false,
-    _reserved9: bool = false,
-    no_clip: bool = false,
-    _padding: u21 = 0,
-};
-fn PlotScatterValuesGen(comptime T: type) type {
-    return struct {
-        v: []const T,
-        xscale: f64 = 1.0,
-        xstart: f64 = 0.0,
-        flags: ScatterFlags = .{},
-        offset: i32 = 0,
-        stride: i32 = @sizeOf(T),
-    };
-}
-pub fn plotScatterValues(label_id: [:0]const u8, comptime T: type, args: PlotScatterValuesGen(T)) void {
-    zguiPlot_PlotScatterValues(
-        label_id,
-        gui.typeToDataTypeEnum(T),
-        args.v.ptr,
-        @as(i32, @intCast(args.v.len)),
-        args.xscale,
-        args.xstart,
-        args.flags,
-        args.offset,
-        args.stride,
-    );
-}
-extern fn zguiPlot_PlotScatterValues(
-    label_id: [*:0]const u8,
-    data_type: gui.DataType,
-    values: *const anyopaque,
-    count: i32,
-    xscale: f64,
-    xstart: f64,
-    flags: ScatterFlags,
-    offset: i32,
-    stride: i32,
-) void;
-//----------------------------------------------------------------------------------------------
-fn PlotScatterGen(comptime T: type) type {
-    return struct {
-        xv: []const T,
-        yv: []const T,
-        flags: ScatterFlags = .{},
-        offset: i32 = 0,
-        stride: i32 = @sizeOf(T),
-    };
-}
-pub fn plotScatter(label_id: [:0]const u8, comptime T: type, args: PlotScatterGen(T)) void {
-    assert(args.xv.len == args.yv.len);
-    zguiPlot_PlotScatter(
-        label_id,
-        gui.typeToDataTypeEnum(T),
-        args.xv.ptr,
-        args.yv.ptr,
-        @as(i32, @intCast(args.xv.len)),
-        args.flags,
-        args.offset,
-        args.stride,
-    );
-}
-extern fn zguiPlot_PlotScatter(
-    label_id: [*:0]const u8,
-    data_type: gui.DataType,
-    xv: *const anyopaque,
-    yv: *const anyopaque,
-    count: i32,
-    flags: ScatterFlags,
-    offset: i32,
-    stride: i32,
-) void;
-
-pub const ShadedFlags = packed struct(u32) {
-    _padding: u32 = 0,
-};
-fn PlotShadedGen(comptime T: type) type {
-    return struct {
-        xv: []const T,
-        yv: []const T,
-        yref: f64 = 0.0,
-        flags: ShadedFlags = .{},
-        offset: i32 = 0,
-        stride: i32 = @sizeOf(T),
-    };
-}
-pub fn plotShaded(label_id: [:0]const u8, comptime T: type, args: PlotShadedGen(T)) void {
-    assert(args.xv.len == args.yv.len);
-    zguiPlot_PlotShaded(
-        label_id,
-        gui.typeToDataTypeEnum(T),
-        args.xv.ptr,
-        args.yv.ptr,
-        @as(i32, @intCast(args.xv.len)),
-        args.yref,
-        args.flags,
-        args.offset,
-        args.stride,
-    );
-}
-extern fn zguiPlot_PlotShaded(
-    label_id: [*:0]const u8,
-    data_type: gui.DataType,
-    xv: *const anyopaque,
-    yv: *const anyopaque,
-    count: i32,
-    yref: f64,
-    flags: ShadedFlags,
-    offset: i32,
-    stride: i32,
-) void;
-//----------------------------------------------------------------------------------------------
-pub const DragToolFlags = packed struct(u32) {
-    no_cursors: bool = false,
-    no_fit: bool = false,
-    no_no_inputs: bool = false,
-    delayed: bool = false,
-    _padding: u28 = 0,
-};
-const DragPoint = struct {
-    x: *f64,
-    y: *f64,
-    col: [4]f32,
-    size: f32 = 4,
-    flags: DragToolFlags = .{},
-};
-pub fn dragPoint(id: i32, args: DragPoint) bool {
-    return zguiPlot_DragPoint(
-        id,
-        args.x,
-        args.y,
-        &args.col,
-        args.size,
-        args.flags,
-    );
-}
-extern fn zguiPlot_DragPoint(id: i32, x: *f64, y: *f64, *const [4]f32, size: f32, flags: DragToolFlags) bool;
-//----------------------------------------------------------------------------------------------
-// PlotText
-const PlotTextFlags = packed struct(u32) {
-    vertical: bool = false,
-    _padding: u31 = 0,
-};
-const PlotText = struct {
-    x: f64,
-    y: f64,
-    pix_offset: [2]f32 = .{ 0, 0 },
-    flags: PlotTextFlags = .{},
-};
-pub fn plotText(text: [*:0]const u8, args: PlotText) void {
-    zguiPlot_PlotText(text, args.x, args.y, &args.pix_offset, args.flags);
-}
-extern fn zguiPlot_PlotText(
-    text: [*:0]const u8,
-    x: f64,
-    y: f64,
-    pix_offset: *const [2]f32,
-    flags: PlotTextFlags,
-) void;
-
-//----------------------------------------------------------------------------------------------
-/// `pub fn showDemoWindow(popen: ?*bool) void`
-pub const showDemoWindow = zguiPlot_ShowDemoWindow;
-extern fn zguiPlot_ShowDemoWindow(popen: ?*bool) void;
-//----------------------------------------------------------------------------------------------
-/// `pub fn endPlot() void`
-pub const endPlot = zguiPlot_EndPlot;
-extern fn zguiPlot_EndPlot() void;
-//----------------------------------------------------------------------------------------------