Struct Plot3DUi 

pub struct Plot3DUi<'ui> { /* private fields */ }

Per-frame access helper mirroring dear-implot

This provides access to all 3D plotting functions. It is tied to the lifetime of the current ImGui frame and should be obtained via Plot3DContext::get_plot_ui().

Example

use dear_implot3d::*;

if let Some(_token) = plot_ui.begin_plot("My 3D Plot").build() {
    plot_ui.setup_axes("X", "Y", "Z", Axis3DFlags::NONE, Axis3DFlags::NONE, Axis3DFlags::NONE);

    let xs = [0.0, 1.0, 2.0];
    let ys = [0.0, 1.0, 0.0];
    let zs = [0.0, 0.5, 1.0];
    plot_ui.plot_line_f32("Line", &xs, &ys, &zs, Line3DFlags::NONE);
}

Implementations

impl Plot3DUi<'_>

pub fn show_all_demos(&self)

Show upstream ImPlot3D demos (from C++ demo).

This displays all available ImPlot3D demos in a single window. Useful for learning and testing the library.

pub fn show_demo_window(&self)

Show the main ImPlot3D demo window (C++ upstream).

This displays the main demo window with tabs for different plot types.

pub fn show_demo_window_with_flag(&self, p_open: &mut bool)

Show the main ImPlot3D demo window with a visibility flag.

pub fn show_style_editor(&self)

Show the ImPlot3D style editor window.

This displays a window for editing ImPlot3D style settings in real time.

pub fn show_metrics_window(&self)

Show the ImPlot3D metrics/debugger window.

This displays performance metrics and debugging information.

pub fn show_metrics_window_with_flag(&self, p_open: &mut bool)

Show the ImPlot3D metrics/debugger window with a visibility flag.

impl<'ui> Plot3DUi<'ui>

pub fn image_by_axes<'tex, T: Into<TextureRef<'tex>>>( &'ui self, label: impl Into<Cow<'ui, str>>, tex: T, center: [f32; 3], axis_u: [f32; 3], axis_v: [f32; 3], ) -> Image3DByAxesBuilder<'ui, 'tex>

Image oriented by center and axes

pub fn image_by_corners<'tex, T: Into<TextureRef<'tex>>>( &'ui self, label: impl Into<Cow<'ui, str>>, tex: T, p0: [f32; 3], p1: [f32; 3], p2: [f32; 3], p3: [f32; 3], ) -> Image3DByCornersBuilder<'ui, 'tex>

Image by 4 corner points (p0..p3)

impl<'ui> Plot3DUi<'ui>

pub fn mesh( &'ui self, label: impl Into<Cow<'ui, str>>, vertices: &'ui [[f32; 3]], indices: &'ui [u32], ) -> Mesh3DBuilder<'ui>

Start a mesh plot from vertices (x,y,z) and triangle indices

impl<'ui> Plot3DUi<'ui>

pub fn push_colormap(&self, cmap: impl Into<ColormapIndex>) -> ColormapToken<'_>

pub fn push_colormap_name(&self, name: &str) -> ColormapToken<'_>

impl Plot3DUi<'_>

pub fn colormap_color(&self, index: ColormapColorIndex) -> [f32; 4]

Return a color from this UI’s active ImPlot3D colormap.

pub fn next_colormap_color(&self) -> [f32; 4]

Return the next color from this UI’s current colormap and advance its color cursor.

impl<'ui> Plot3DUi<'ui>

pub unsafe fn with_next_plot3d_item_array_style<'a, R>( &self, style: Plot3DItemArrayStyle<'a>, f: impl FnOnce(&Plot3DUi<'ui>) -> R, ) -> R

Apply array-backed item styling to the next ImPlot3D submission executed inside f.

This is closure-scoped so borrowed slices stay valid for the entire next plot call and are restored even if f panics before submitting an item.

Safety

Every non-empty style array must contain enough elements for every index the submitted plot may read. Upstream accepts only pointers and carries no array lengths, so this cannot be validated by the wrapper.

impl<'ui> Plot3DUi<'ui>

pub fn push_style_color( &self, element: Plot3DColorElement, col: [f32; 4], ) -> StyleColorToken<'_>

Push a style color override to this ImPlot3D context’s stack.

pub fn push_style_color_element( &self, element: Plot3DColorElement, col: [f32; 4], ) -> StyleColorToken<'_>

Push a typed style color override.

pub fn push_style_var_f32( &self, var: Plot3DStyleVar, val: f32, ) -> StyleVarToken<'_>

Push a style variable (float variant).

pub fn push_style_var_marker(&self, marker: Marker3D) -> StyleVarToken<'_>

Push the default marker style variable.

pub fn push_style_var_vec2( &self, var: Plot3DStyleVar, val: [f32; 2], ) -> StyleVarToken<'_>

Push a style variable (Vec2 variant).

impl Plot3DUi<'_>

pub fn set_next_line_style(&self, col: [f32; 4], weight: f32)

Set the line style for the next ImPlot3D item submitted through this context.

pub fn set_next_fill_style(&self, col: [f32; 4], alpha_mod: f32)

Set the fill style for the next ImPlot3D item submitted through this context.

pub fn set_next_marker_style( &self, marker: Marker3D, size: f32, fill: [f32; 4], weight: f32, outline: [f32; 4], )

Set the marker style for the next ImPlot3D item submitted through this context.

impl<'ui> Plot3DUi<'ui>

pub fn surface_f32( &'ui self, label: impl Into<Cow<'ui, str>>, xs: &'ui [f32], ys: &'ui [f32], zs: &'ui [f32], ) -> Surface3DBuilder<'ui>

Start a surface plot (f32) from X/Y grid axes.

pub fn surface_f32_flat<S: AsRef<str>>( &self, label: S, xs_flat: &[f32], ys_flat: &[f32], zs: &[f32], x_count: usize, y_count: usize, scale_min: f64, scale_max: f64, flags: Surface3DFlags, ) -> Result<(), Plot3DError>

Submit a surface from already flattened, contiguous per-vertex arrays.

xs_flat, ys_flat, and zs must each contain exactly x_count * y_count values. The contiguous path does not accept an offset or stride; use Self::surface_f32_raw when the native layout is intentionally non-contiguous.

use dear_implot3d::{Plot3DError, Plot3DUi, Surface3DFlags};

fn submit(plot_ui: &Plot3DUi<'_>) -> Result<(), Plot3DError> {
    let xs = [0.0, 1.0, 0.0, 1.0];
    let ys = [0.0, 0.0, 1.0, 1.0];
    let zs = [0.0, 1.0, 1.0, 2.0];
    plot_ui.surface_f32_flat(
        "surface",
        &xs,
        &ys,
        &zs,
        2,
        2,
        0.0,
        0.0,
        Surface3DFlags::NONE,
    )
}

pub unsafe fn surface_f32_raw<S: AsRef<str>>( &self, label: S, xs: &[f32], ys: &[f32], zs: &[f32], x_count: usize, y_count: usize, scale_min: f64, scale_max: f64, flags: Surface3DFlags, layout: Plot3DDataLayout, ) -> Result<(), Plot3DError>

Submit a surface with an explicitly arbitrary native data layout.

Safety

The caller must ensure that every coordinate read performed by ImPlot3D from xs, ys, and zs using layout, x_count, and y_count addresses initialized, properly aligned, live f32 values. The slices need not be exactly x_count * y_count elements because a custom stride or offset may address a larger allocation.

Calling this arbitrary-layout API without an unsafe block is rejected:

use dear_implot3d::{Plot3DDataLayout, Plot3DUi, Surface3DFlags};

fn submit(plot_ui: &Plot3DUi<'_>) {
    let values = [0.0; 4];
    let _ = plot_ui.surface_f32_raw(
        "surface",
        &values,
        &values,
        &values,
        2,
        2,
        0.0,
        0.0,
        Surface3DFlags::NONE,
        Plot3DDataLayout::DEFAULT,
    );
}

impl<'ui> Plot3DUi<'ui>

pub fn begin_plot<S: AsRef<str>>(&self, title: S) -> Plot3DBuilder<'ui>

Builder to configure and begin a 3D plot

Returns a Plot3DBuilder that allows you to configure the plot before calling .build().

Example

use dear_implot3d::*;

if let Some(_token) = plot_ui
    .begin_plot("My Plot")
    .size([600.0, 400.0])
    .flags(Plot3DFlags::NO_LEGEND)
    .build()
{
    // Plot content here
}

pub fn plot_line_f32<S: AsRef<str>>( &self, label: S, xs: &[f32], ys: &[f32], zs: &[f32], flags: Line3DFlags, )

Convenience: plot a simple 3D line (f32)

This is a quick way to plot a line without using the builder pattern. For more control, use the plots::Line3D builder.

Arguments

• label - Label for the legend
• xs - X coordinates
• ys - Y coordinates
• zs - Z coordinates
• flags - Line flags (e.g., Line3DFlags::SEGMENTS, Line3DFlags::LOOP)

Example

use dear_implot3d::*;

let xs = [0.0, 1.0, 2.0];
let ys = [0.0, 1.0, 0.0];
let zs = [0.0, 0.5, 1.0];
plot_ui.plot_line_f32("Line", &xs, &ys, &zs, Line3DFlags::NONE);

pub unsafe fn plot_line_f32_raw<S: AsRef<str>>( &self, label: S, xs: &[f32], ys: &[f32], zs: &[f32], flags: Line3DFlags, layout: Plot3DDataLayout, )

Line plot (f32) with an explicit data layout.

Safety

For every submitted index, layout must address an initialized, properly aligned f32 within each coordinate allocation. All three allocations must remain alive for this call.

pub fn plot_line_f64<S: AsRef<str>>( &self, label: S, xs: &[f64], ys: &[f64], zs: &[f64], flags: Line3DFlags, )

Convenience: plot a simple 3D line (f64)

pub unsafe fn plot_line_f64_raw<S: AsRef<str>>( &self, label: S, xs: &[f64], ys: &[f64], zs: &[f64], flags: Line3DFlags, layout: Plot3DDataLayout, )

Line plot (f64) with an explicit data layout.

Safety

For every submitted index, layout must address an initialized, properly aligned f64 within each coordinate allocation. All three allocations must remain alive for this call.

pub fn plot_scatter_f32<S: AsRef<str>>( &self, label: S, xs: &[f32], ys: &[f32], zs: &[f32], flags: Scatter3DFlags, )

Convenience: plot a 3D scatter (f32)

pub unsafe fn plot_scatter_f32_raw<S: AsRef<str>>( &self, label: S, xs: &[f32], ys: &[f32], zs: &[f32], flags: Scatter3DFlags, layout: Plot3DDataLayout, )

Scatter plot (f32) with an explicit data layout.

Safety

For every submitted index, layout must address an initialized, properly aligned f32 within each coordinate allocation. All three allocations must remain alive for this call.

pub fn plot_scatter_f64<S: AsRef<str>>( &self, label: S, xs: &[f64], ys: &[f64], zs: &[f64], flags: Scatter3DFlags, )

Convenience: plot a 3D scatter (f64)

pub unsafe fn plot_scatter_f64_raw<S: AsRef<str>>( &self, label: S, xs: &[f64], ys: &[f64], zs: &[f64], flags: Scatter3DFlags, layout: Plot3DDataLayout, )

Scatter plot (f64) with an explicit data layout.

Safety

For every submitted index, layout must address an initialized, properly aligned f64 within each coordinate allocation. All three allocations must remain alive for this call.

pub fn plot_triangles_f32<S: AsRef<str>>( &self, label: S, xs: &[f32], ys: &[f32], zs: &[f32], flags: Triangle3DFlags, )

Convenience: plot triangles from interleaved xyz arrays (count must be multiple of 3)

pub unsafe fn plot_triangles_f32_raw<S: AsRef<str>>( &self, label: S, xs: &[f32], ys: &[f32], zs: &[f32], flags: Triangle3DFlags, layout: Plot3DDataLayout, )

Plot f32 triangle coordinates with an explicit data layout.

Safety

For every submitted index, layout must address an initialized, properly aligned f32 within each coordinate allocation. All three allocations must remain alive for this call.

pub fn plot_quads_f32<S: AsRef<str>>( &self, label: S, xs: &[f32], ys: &[f32], zs: &[f32], flags: Quad3DFlags, )

Convenience: plot quads from interleaved xyz arrays (count must be multiple of 4)

pub unsafe fn plot_quads_f32_raw<S: AsRef<str>>( &self, label: S, xs: &[f32], ys: &[f32], zs: &[f32], flags: Quad3DFlags, layout: Plot3DDataLayout, )

Plot f32 quad coordinates with an explicit data layout.

Safety

For every submitted index, layout must address an initialized, properly aligned f32 within each coordinate allocation. All three allocations must remain alive for this call.

pub fn plot_triangles_f64<S: AsRef<str>>( &self, label: S, xs: &[f64], ys: &[f64], zs: &[f64], flags: Triangle3DFlags, )

Convenience: plot triangles from interleaved xyz arrays (f64)

pub unsafe fn plot_triangles_f64_raw<S: AsRef<str>>( &self, label: S, xs: &[f64], ys: &[f64], zs: &[f64], flags: Triangle3DFlags, layout: Plot3DDataLayout, )

Plot f64 triangle coordinates with an explicit data layout.

Safety

For every submitted index, layout must address an initialized, properly aligned f64 within each coordinate allocation. All three allocations must remain alive for this call.

pub fn plot_quads_f64<S: AsRef<str>>( &self, label: S, xs: &[f64], ys: &[f64], zs: &[f64], flags: Quad3DFlags, )

Convenience: plot quads from interleaved xyz arrays (f64)

pub unsafe fn plot_quads_f64_raw<S: AsRef<str>>( &self, label: S, xs: &[f64], ys: &[f64], zs: &[f64], flags: Quad3DFlags, layout: Plot3DDataLayout, )

Plot f64 quad coordinates with an explicit data layout.

Safety

For every submitted index, layout must address an initialized, properly aligned f64 within each coordinate allocation. All three allocations must remain alive for this call.

impl<'ui> Plot3DUi<'ui>

Axis helpers

pub fn setup_axes( &self, x_label: &str, y_label: &str, z_label: &str, x_flags: Axis3DFlags, y_flags: Axis3DFlags, z_flags: Axis3DFlags, )

pub fn setup_axis(&self, axis: Axis3D, label: &str, flags: Axis3DFlags)

pub fn setup_axis_limits( &self, axis: Axis3D, min: f64, max: f64, cond: Plot3DCond, )

pub fn setup_axes_limits( &self, x_min: f64, x_max: f64, y_min: f64, y_max: f64, z_min: f64, z_max: f64, cond: Plot3DCond, )

pub fn setup_axis_limits_constraints( &self, axis: Axis3D, v_min: f64, v_max: f64, )

pub fn setup_axis_zoom_constraints(&self, axis: Axis3D, z_min: f64, z_max: f64)

pub fn setup_axis_ticks_values( &self, axis: Axis3D, values: &[f64], labels: Option<&[&str]>, keep_default: bool, )

Setup axis ticks using explicit positions and optional labels.

If labels is provided, it must have the same length as values.

pub fn setup_axis_ticks_range( &self, axis: Axis3D, v_min: f64, v_max: f64, n_ticks: usize, labels: Option<&[&str]>, keep_default: bool, )

pub fn setup_box_scale(&self, x: f32, y: f32, z: f32)

pub fn setup_box_rotation( &self, elevation: f32, azimuth: f32, animate: bool, cond: Plot3DCond, )

pub fn setup_box_initial_rotation(&self, elevation: f32, azimuth: f32)

pub fn plot_text( &self, text: &str, x: f32, y: f32, z: f32, angle: f32, pix_offset: [f32; 2], )

pub fn plot_to_pixels(&self, point: [f32; 3]) -> [f32; 2]

pub fn get_frame_pos(&self) -> [f32; 2]

pub fn get_frame_size(&self) -> [f32; 2]