597 lines
17 KiB
Zig
597 lines
17 KiB
Zig
//--------------------------------------------------------------------------------------------------
|
|
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;
|
|
//----------------------------------------------------------------------------------------------
|