implot3d (C++)

ImPlot3D: 3D plots for Dear ImGui: lines, scatter, surfaces, meshes, rotated, panned and zoomed with the mouse.

Start with: ImPlot3D::BeginPlot, ImPlot3D::EndPlot, ImPlot3D::PlotLine, ImPlot3D::PlotScatter, ImPlot3D::SetupAxes.

implot3d.h¶

Flags & Enumerations¶

Prop_ (enum)¶

Plotting properties. These provide syntactic sugar for creating ImPlot3DSpec from (ImPlot3DProp,value) pairs

Flags_ (enum)¶

Flags for ImPlot3D::BeginPlot()

Cond_ (enum)¶

Represents a condition for SetupAxisLimits etc. (same as ImGuiCond, but we only support a subset of those enums)

Col_ (enum)¶

StyleVar_ (enum)¶

Plot styling variables

Marker_ (enum)¶

ItemFlags_ (enum)¶

Flags for items

ScatterFlags_ (enum)¶

Flags for PlotScatter

LineFlags_ (enum)¶

Flags for PlotLine

TriangleFlags_ (enum)¶

Flags for PlotTriangle

QuadFlags_ (enum)¶

Flags for PlotQuad

SurfaceFlags_ (enum)¶

Flags for PlotSurface

MeshFlags_ (enum)¶

Flags for PlotMesh

ImageFlags_ (enum)¶

Flags for PlotImage

DummyFlags_ (enum)¶

Flags for PlotDummy

LegendFlags_ (enum)¶

Flags for legends

Location_ (enum)¶

Used to position legend on a plot

AxisFlags_ (enum)¶

Flags for axis

ImAxis3D_ (enum)¶

Axis indices

ImPlane3D_ (enum)¶

Plane indices

Scale_ (enum)¶

Axis scale

Colormap_ (enum)¶

Colormaps

Specs API¶

Spec (struct)¶

Plot item styling specification. Provide these to PlotX functions to override styling, specify offsetting or stride, or set optional flags. This struct can be used in the following ways:

1. By declaring and defining a struct instance:

   ImPlot3DSpec spec;
   spec.LineColor = ImVec4(1,0,0,1);
   spec.LineWeight = 2.0;
   spec.Marker = ImPlot3DMarker_Circle;
   spec.Flags = ImPlot3DItemFlags_NoLegend | ImPlot3DLineFlags_Segments;
   ImPlot3D::PlotLine("MyLine", xs, ys, zs, 100, spec);

2. Inline using ImPlot3DProp,value pairs (order does NOT matter):

   ImPlot3D::PlotLine(“MyLine”, xs, ys, zs, 100, { ImPlot3DProp_LineColor, ImVec4(1,0,0,1),
   ImPlot3DProp_LineWeight, 2.0,
   ImPlot3DProp_Marker, ImPlot3DMarker_Circle,
   ImPlot3DProp_Flags, ImPlot3DItemFlags_NoLegend | ImPlot3DLineFlags_Segments

   });

Context¶

ImPlot3D::CreateContext¶

IMPLOT3D_API ImPlot3DContext* CreateContext();

Creates a new ImPlot3D context. Call this after ImGui::CreateContext

ImPlot3D::DestroyContext¶

IMPLOT3D_API void DestroyContext(ImPlot3DContext* ctx = nullptr);

Destroys an ImPlot3D context. Call this before ImGui::DestroyContext. None = destroy current context

ImPlot3D::GetCurrentContext¶

IMPLOT3D_API ImPlot3DContext* GetCurrentContext();

Returns the current ImPlot3D context. None if no context has been set

ImPlot3D::SetCurrentContext¶

IMPLOT3D_API void SetCurrentContext(ImPlot3DContext* ctx);

Sets the current ImPlot3D context

Begin/End Plot¶

ImPlot3D::BeginPlot¶

IMPLOT3D_API bool BeginPlot(const char* title_id, const ImVec2& size = ImVec2(-1, 0), ImPlot3DFlags flags = 0);

Starts a 3D plotting context. If this function returns True, EndPlot() MUST be called! You are encouraged to use the following convention:

if (ImPlot3D::BeginPlot(...)) {
    ImPlot3D::PlotLine(...);
    ...
    ImPlot3D::EndPlot();
}

Important notes:

• #title_id must be unique to the current ImGui ID scope. If you need to avoid ID collisions or don’t want to display a title in the plot, use double hashes (e.g. “MyPlot##HiddenIdText” or “##NoTitle”).

• #size is the frame size of the plot widget, not the plot area.

ImPlot3D::EndPlot¶

IMPLOT3D_API void EndPlot();

Only call if BeginPlot() returns True!

Setup¶

ImPlot3D::SetupAxis¶

IMPLOT3D_API void SetupAxis(ImAxis3D axis, const char* label = nullptr, ImPlot3DAxisFlags flags = 0);

Enables an axis or sets the label and/or flags for an existing axis. Leave #label = None for no label

The following API allows you to setup and customize various aspects of the current plot. The functions should be called immediately after BeginPlot() and before any other API calls. Typical usage is as follows:

if (ImPlot3D::BeginPlot(...)) {                     1) Begin a new plot
    ImPlot3D::SetupAxis(ImAxis3D_X, "My X-Axis");    2) Make Setup calls
    ImPlot3D::SetupAxis(ImAxis3D_Y, "My Y-Axis");
    ImPlot3D::SetupLegend(ImPlotLocation_North);
    ...
    ImPlot3D::SetupFinish();                        3) [Optional] Explicitly finish setup
    ImPlot3D::PlotLine(...);                        4) Plot items
    ...
    ImPlot3D::EndPlot();                            5) End the plot
}

Important notes:

• Always call Setup code at the top of your BeginPlot conditional statement.

• Setup is locked once you start plotting or explicitly call SetupFinish.
  Do NOT call Setup code after you begin plotting or after you make any non-Setup API calls (e.g. utils like PlotToPixels also lock Setup).

• Calling SetupFinish is OPTIONAL, but probably good practice. If you do not call it yourself, then the first subsequent plotting or utility function will call it for you.

ImPlot3D::SetupAxisLimits¶

IMPLOT3D_API void SetupAxisLimits(ImAxis3D axis, double v_min, double v_max, ImPlot3DCond cond = ImPlot3DCond_Once);

Sets an axis range limits. If ImPlot3DCond_Always is used, the axis limits will be locked.
Note: To invert an axis, use ImPlot3DAxisFlags_Invert with SetupAxis instead of swapping min/max

ImPlot3D::SetupAxisScale¶

IMPLOT3D_API void SetupAxisScale(ImAxis3D axis, ImPlot3DScale scale);

Sets an axis’ scale using built-in options

ImPlot3D::SetupAxisLimitsConstraints¶

IMPLOT3D_API void SetupAxisLimitsConstraints(ImAxis3D axis, double v_min, double v_max);

Sets an axis’ limits constraints. The axis will be constrained to never go below #v_min or above #v_max

ImPlot3D::SetupAxisZoomConstraints¶

IMPLOT3D_API void SetupAxisZoomConstraints(ImAxis3D axis, double zoom_min, double zoom_max);

Sets an axis’ zoom constraints. The zoom (axis range size: range.max - range.min) will be constrained between #zoom_min and #zoom_max

ImPlot3D::SetupAxes¶

IMPLOT3D_API void SetupAxes(const char* x_label, const char* y_label, const char* z_label, ImPlot3DAxisFlags x_flags = 0, ImPlot3DAxisFlags y_flags = 0, ImPlot3DAxisFlags z_flags = 0);

Sets the label and/or flags for primary X/Y/Z axes (shorthand for three calls to SetupAxis)

ImPlot3D::SetupAxesLimits¶

IMPLOT3D_API void SetupAxesLimits(double x_min, double x_max, double y_min, double y_max, double z_min, double z_max, ImPlot3DCond cond = ImPlot3DCond_Once);

Sets the X/Y/Z axes range limits. If ImPlot3DCond_Always is used, the axes limits will be locked (shorthand for three calls to SetupAxisLimits)

ImPlot3D::SetupBoxRotation¶

IMPLOT3D_API void SetupBoxRotation(double elevation, double azimuth, bool animate = false, ImPlot3DCond cond = ImPlot3DCond_Once);

IMPLOT3D_API void SetupBoxRotation(ImPlot3DQuat rotation, bool animate = false, ImPlot3DCond cond = ImPlot3DCond_Once);

Sets the plot box rotation given the elevation and azimuth angles in degrees. If ImPlot3DCond_Always is used, the rotation will be locked

ImPlot3D::SetupBoxInitialRotation¶

IMPLOT3D_API void SetupBoxInitialRotation(double elevation, double azimuth);

IMPLOT3D_API void SetupBoxInitialRotation(ImPlot3DQuat rotation);

Sets the plot box initial rotation given the elevation and azimuth angles in degrees. The initial rotation is the rotation the plot goes back to when a left mouse button double click happens

ImPlot3D::SetupBoxScale¶

IMPLOT3D_API void SetupBoxScale(double x, double y, double z);

Sets the plot box X/Y/Z scale. A scale of 1.0 is the default. Values greater than 1.0 enlarge the plot, while values between 0.0 and 1.0 shrink it

ImPlot3D::SetupLegend¶

IMPLOT3D_API void SetupLegend(ImPlot3DLocation location, ImPlot3DLegendFlags flags = 0);

Sets up the plot legend location and flags

Plot Items¶

ImPlot3D::PlotScatter¶

IMPLOT3D_TMP void PlotScatter(const char* label_id, const T* xs, const T* ys, const T* zs, int count, const ImPlot3DSpec& spec = ImPlot3DSpec());

Plots a scatter plot in 3D. Points are rendered as markers at the specified coordinates

Note: all array arguments must share the same dtype (e.g. xs = xs.astype(ys.dtype)).

The plotting API is provided below. Call these functions between
BeginPlot/EndPlot and after any Setup API calls.
The templated functions are explicitly instantiated in implot3d_items.cpp.
They are not intended to be used generically with custom types. You will get a linker error if you try! All functions support the following scalar types: float, double, ImS8, ImU8, ImS16, ImU16, ImS32, ImU32, ImS64, ImU64
If you need to plot custom or non-homogenous data you have a few options:

1. If your data is a simple struct/class (e.g. Vector3f), you can use striding.
   This is the most performant option if applicable.

   struct Vector3f { float X, Y, Z; };
   ...
   Vector3f data[42];
   ImPlot3D::PlotLine("line", &data[0].X, &data[0].Y, &data[0].Z, 42, {ImPlot3DProp_Stride, sizeof(Vector2f)});

2. If your data is in separate arrays or requires computation, you can copy/transform it into temporary float or double arrays before plotting.
   NB: All types are converted to double before plotting. You may lose information if you try plotting extremely large 64-bit integral types. Proceed with caution!

ImPlot3D::PlotLine¶

IMPLOT3D_TMP void PlotLine(const char* label_id, const T* xs, const T* ys, const T* zs, int count, const ImPlot3DSpec& spec = ImPlot3DSpec());

Plots a line in 3D. Consecutive points are connected with line segments

Note: all array arguments must share the same dtype (e.g. xs = xs.astype(ys.dtype)).

ImPlot3D::PlotTriangle¶

IMPLOT3D_TMP void PlotTriangle(const char* label_id, const T* xs, const T* ys, const T* zs, int count, const ImPlot3DSpec& spec = ImPlot3DSpec());

Plots triangles in 3D. Every 3 consecutive points define a triangle

Note: all array arguments must share the same dtype (e.g. xs = xs.astype(ys.dtype)).

ImPlot3D::PlotQuad¶

IMPLOT3D_TMP void PlotQuad(const char* label_id, const T* xs, const T* ys, const T* zs, int count, const ImPlot3DSpec& spec = ImPlot3DSpec());

Plots quads in 3D. Every 4 consecutive points define a quadrilateral

Note: all array arguments must share the same dtype (e.g. xs = xs.astype(ys.dtype)).

ImPlot3D::PlotSurface¶

IMPLOT3D_TMP void PlotSurface( const char* label_id, const T* xs, int xs_count, const T* ys, int ys_count, const T* zs, int zs_count, int x_count, int y_count, double scale_min = 0.0, double scale_max = 0.0, const ImPlot3DSpec& spec = ImPlot3DSpec() );

Plot the surface defined by a grid of vertices. The grid is defined by the x and y arrays, and the z array contains the height of each vertex.
A total of x_count * y_count vertices are expected for each array.
Leave #scale_min and #scale_max both at 0 for automatic color scaling, or set them to a predefined range.

Note: all array arguments must share the same dtype (e.g. xs = xs.astype(ys.dtype)).

A version of PlotSurface whose API is easier to port to Python (params xs_count, ys_count and zs_count are removed in the Python API, but are used in the bindings code generation)

Mesh (struct)¶

ImPlot3D::PlotMesh¶

IMPLOT3D_API void PlotMesh(const char* label_id, const Mesh& mesh, const ImPlot3DSpec& spec = ImPlot3DSpec());

ImPlot3D::PlotImage¶

IMPLOT3D_API void PlotImage(const char* label_id, ImTextureRef tex_ref, const ImPlot3DPoint& center, const ImPlot3DPoint& axis_u, const ImPlot3DPoint& axis_v, const ImVec2& uv0 = ImVec2(0, 0), const ImVec2& uv1 = ImVec2(1, 1), const ImVec4& tint_col = ImVec4(1, 1, 1, 1), const ImPlot3DSpec& spec = ImPlot3DSpec());

IMPLOT3D_API void PlotImage(const char* label_id, ImTextureRef tex_ref, const ImPlot3DPoint& p0, const ImPlot3DPoint& p1, const ImPlot3DPoint& p2, const ImPlot3DPoint& p3, const ImVec2& uv0 = ImVec2(0, 0), const ImVec2& uv1 = ImVec2(1, 0), const ImVec2& uv2 = ImVec2(1, 1), const ImVec2& uv3 = ImVec2(0, 1), const ImVec4& tint_col = ImVec4(1, 1, 1, 1), const ImPlot3DSpec& spec = ImPlot3DSpec());

Plots a rectangular image in 3D defined by its center and two direction vectors (axes).
#center is the center of the rectangle in plot coordinates.
#axis_u and #axis_v define the local axes and half-extents of the rectangle in 3D space.
The rectangle is formed by moving from the center along ±axis_u and ±axis_v.
#uv0 and #uv1 define the texture mapping.
#tint_col can be used to tint the image.

[/ADAPT_IMGUI_BUNDLE]

ImPlot3D::PlotText¶

IMPLOT3D_API void PlotText(const char* text, double x, double y, double z, double angle = 0.0, const ImVec2& pix_offset = ImVec2(0, 0));

Plots a centered text label at point x,y,z with optional rotation angle (in radians) and pixel offset

ImPlot3D::PlotDummy¶

IMPLOT3D_API void PlotDummy(const char* label_id, const ImPlot3DSpec& spec = ImPlot3DSpec());

Plots a dummy item (can be used to modify legend entry appearance when called after plotting an item, or add a dummy legend entry)

Plot Utils¶

ImPlot3D::PlotToPixels¶

IMPLOT3D_API ImVec2 PlotToPixels(const ImPlot3DPoint& point);

IMPLOT3D_API ImVec2 PlotToPixels(double x, double y, double z);

Convert a position in the current plot’s coordinate system to pixels

ImPlot3D::PixelsToPlotRay¶

IMPLOT3D_API ImPlot3DRay PixelsToPlotRay(const ImVec2& pix);

IMPLOT3D_API ImPlot3DRay PixelsToPlotRay(double x, double y);

Convert a pixel coordinate to a ray in the current plot’s coordinate system. Useful for 3D picking and intersection tests

ImPlot3D::PixelsToPlotPlane¶

IMPLOT3D_API ImPlot3DPoint PixelsToPlotPlane(const ImVec2& pix, ImPlane3D plane, bool mask = true);

IMPLOT3D_API ImPlot3DPoint PixelsToPlotPlane(double x, double y, ImPlane3D plane, bool mask = true);

Convert a pixel coordinate to a point on one of the plot box’s axis-aligned planes (XY, XZ, or YZ).
By default, the result is masked to the axis ranges. Set #mask=False to project to the infinite plane.
Returns ImPlot3DPoint(NAN, NAN, NAN) if the ray does not intersect the plane

ImPlot3D::GetPlotRectPos¶

IMPLOT3D_API ImVec2 GetPlotRectPos();

Get the current plot rect position (top-left) in absolute screen coordinates

ImPlot3D::GetPlotRectSize¶

IMPLOT3D_API ImVec2 GetPlotRectSize();

Get the current plot rect size in pixels

Miscellaneous¶

ImPlot3D::GetPlotDrawList¶

IMPLOT3D_API ImDrawList* GetPlotDrawList();

Returns the ImDrawList used for rendering plot items. Use this to add custom rendering inside plots

Styles API¶

Get current style¶

ImPlot3D::GetStyle¶

IMPLOT3D_API ImPlot3DStyle& GetStyle();

ImPlot3D::SetStyle¶

IMPLOT3D_API void SetStyle(const ImPlot3DStyle& style);

Set color styles¶

ImPlot3D::StyleColorsAuto¶

IMPLOT3D_API void StyleColorsAuto(ImPlot3DStyle* dst = nullptr);

Set colors with ImGui style

ImPlot3D::StyleColorsDark¶

IMPLOT3D_API void StyleColorsDark(ImPlot3DStyle* dst = nullptr);

Set colors with dark style

ImPlot3D::StyleColorsLight¶

IMPLOT3D_API void StyleColorsLight(ImPlot3DStyle* dst = nullptr);

Set colors with light style

ImPlot3D::StyleColorsClassic¶

IMPLOT3D_API void StyleColorsClassic(ImPlot3DStyle* dst = nullptr);

Set colors with classic style

ImPlot3D::PushStyleColor¶

IMPLOT3D_API void PushStyleColor(ImPlot3DCol idx, ImU32 col);

IMPLOT3D_API void PushStyleColor(ImPlot3DCol idx, const ImVec4& col);

Temporarily modify a style color. Don’t forget to call PopStyleColor!

ImPlot3D::PopStyleColor¶

IMPLOT3D_API void PopStyleColor(int count = 1);

Undo temporary style color modification(s). Undo multiple pushes at once by increasing count

ImPlot3D::PushStyleVar¶

IMPLOT3D_API void PushStyleVar(ImPlot3DStyleVar idx, int val);

IMPLOT3D_API void PushStyleVar(ImPlot3DStyleVar idx, float val);

IMPLOT3D_API void PushStyleVar(ImPlot3DStyleVar idx, const ImVec2& val);

Temporarily modify a style variable of int type. Don’t forget to call PopStyleVar!

ImPlot3D::PopStyleVar¶

IMPLOT3D_API void PopStyleVar(int count = 1);

Undo temporary style variable modification(s). Undo multiple pushes at once by increasing count

Get color¶

ImPlot3D::GetStyleColorVec4¶

IMPLOT3D_API ImVec4 GetStyleColorVec4(ImPlot3DCol idx);

ImPlot3D::GetStyleColorU32¶

IMPLOT3D_API ImU32 GetStyleColorU32(ImPlot3DCol idx);

ImPlot3D::NextMarker¶

IMPLOT3D_API ImPlot3DMarker NextMarker();

Returns the next marker and advances the marker for the current plot. You need to call this between Begin/EndPlot!

Colormaps¶

ImPlot3D::AddColormap¶

IMPLOT3D_API ImPlot3DColormap AddColormap(const char* name, const ImVec4* cols, int size, bool qual = true);

IMPLOT3D_API ImPlot3DColormap AddColormap(const char* name, const ImU32* cols, int size, bool qual = true);

Item styling is based on colormaps when the relevant ImPlot3DCol_XXX is set to
IMPLOT3D_AUTO_COL (default). Several built-in colormaps are available. You can add and then push/pop your own colormaps as well. To permanently set a colormap, modify the Colormap index member of your ImPlot3DStyle.
Colormap data will be ignored and a custom color will be used if you have done one of the following: 1) Modified an item style color in your ImPlot3DStyle to anything other than IMPLOT3D_AUTO_COL.
Add a new colormap. The color data will be copied. The colormap can be used by pushing either the returned index or the string name with PushColormap. The colormap name must be unique and the size must be greater than 1. You will receive an assert otherwise! By default colormaps are considered to be qualitative (i.e. discrete). If you want to create a continuous colormap, set #qual=False. This will treat the colors you provide as keys, and ImPlot3D will build a linearly interpolated lookup table. The memory footprint of this table will be exactly ((size-1)*255+1)*4 bytes.

ImPlot3D::GetColormapCount¶

IMPLOT3D_API int GetColormapCount();

Returns the number of available colormaps (i.e. the built-in + user-added count)

ImPlot3D::GetColormapName¶

IMPLOT3D_API const char* GetColormapName(ImPlot3DColormap cmap);

Returns a null terminated string name for a colormap given an index. Returns None if index is invalid

ImPlot3D::GetColormapIndex¶

IMPLOT3D_API ImPlot3DColormap GetColormapIndex(const char* name);

Returns an index number for a colormap given a valid string name. Returns -1 if name is invalid

ImPlot3D::PushColormap¶

IMPLOT3D_API void PushColormap(ImPlot3DColormap cmap);

IMPLOT3D_API void PushColormap(const char* name);

Temporarily switch to one of the built-in (i.e. ImPlot3DColormap_XXX) or user-added colormaps (i.e. a return value of AddColormap). Don’t forget to call PopColormap!

ImPlot3D::PopColormap¶

IMPLOT3D_API void PopColormap(int count = 1);

Undo temporary colormap modification(s). Undo multiple pushes at once by increasing count

ImPlot3D::NextColormapColor¶

IMPLOT3D_API ImVec4 NextColormapColor();

Returns the next color from the current colormap and advances the colormap for the current plot
Can also be used with no return value to skip colors if desired. You need to call it between Begin/EndPlot!

ImPlot3D::GetColormapSize¶

IMPLOT3D_API int GetColormapSize(ImPlot3DColormap cmap = IMPLOT3D_AUTO);

Returns the size of a colormap

ImPlot3D::GetColormapColor¶

IMPLOT3D_API ImVec4 GetColormapColor(int idx, ImPlot3DColormap cmap = IMPLOT3D_AUTO);

Returns a color from a colormap given an index >= 0 (modulo will be performed)

ImPlot3D::SampleColormap¶

IMPLOT3D_API ImVec4 SampleColormap(float t, ImPlot3DColormap cmap = IMPLOT3D_AUTO);

Sample a color from the current colormap given t between 0 and 1

Demo¶

ImPlot3D::ShowDemoWindow¶

IMPLOT3D_API void ShowDemoWindow(bool* p_open = nullptr);

Shows the ImPlot3D demo window

Add implot3d_demo.cpp to your sources to use methods in this section

ImPlot3D::ShowAllDemos¶

IMPLOT3D_API void ShowAllDemos();

Shows all ImPlot3D demos, without enclosing window

ImPlot3D::ShowDemoWindow_MaybeDocked¶

IMPLOT3D_API void ShowDemoWindow_MaybeDocked(bool create_window, bool* p_open = NULL, ImGuiWindowFlags initial_extra_flags = 0, ImVec2 window_pos = ImVec2(0, 0), ImVec2 window_size = ImVec2(0, 0));

ImPlot3D::ShowStyleEditor¶

IMPLOT3D_API void ShowStyleEditor(ImPlot3DStyle* ref = nullptr);

Shows ImPlot3D style editor block (not a window)

ImPlot3D::ShowStyleSelector¶

IMPLOT3D_API bool ShowStyleSelector(const char* label);

Shows ImPlot3D style selector and returns True if selection is changed (not a window)

ImPlot3D::ShowColormapSelector¶

IMPLOT3D_API bool ShowColormapSelector(const char* label);

Shows ImPlot3D colormap selector and returns True if selection is changed (not a window)

ImPlot3D::ShowMetricsWindow¶

IMPLOT3D_API void ShowMetricsWindow(bool* p_popen = nullptr);

Shows ImPlot3D metrics/debug information window.

ImPlot3D::ShowAboutWindow¶

IMPLOT3D_API void ShowAboutWindow(bool* p_open = nullptr);

Shows ImPlot3D about window.

ImPlot3DPoint¶

Point (struct)¶

ImPlot3DPoint: 3D vector to store points in 3D space

Point::ImPlot3DPoint¶

constexpr ImPlot3DPoint() : x(0.0), y(0.0), z(0.0);

constexpr ImPlot3DPoint(double _x, double _y, double _z) : x(_x), y(_y), z(_z);

Point::Dot¶

IMPLOT3D_API double Dot(const ImPlot3DPoint& rhs) const;

Dot product

Point::Cross¶

IMPLOT3D_API ImPlot3DPoint Cross(const ImPlot3DPoint& rhs) const;

Cross product

Point::Length¶

IMPLOT3D_API double Length() const;

Get vector length

Point::LengthSquared¶

IMPLOT3D_API double LengthSquared() const;

Get vector squared length

Point::Normalize¶

IMPLOT3D_API void Normalize();

Normalize to unit length

Point::Normalized¶

IMPLOT3D_API ImPlot3DPoint Normalized() const;

Return vector normalized to unit length

Point::IsNaN¶

IMPLOT3D_API bool IsNaN() const;

Check if the point is NaN

ImPlot3DRay¶

Ray (struct)¶

ImPlot3DRay: Represents a ray in 3D space with an origin and direction

ImPlot3DPlane¶

Plane (struct)¶

ImPlot3DPlane: Represents a plane in 3D space defined by a point and normal vector

ImPlot3DBox¶

Box (struct)¶

ImPlot3DBox: Axis-aligned bounding box in 3D space

Box::ImPlot3DBox¶

constexpr ImPlot3DBox() : Min(ImPlot3DPoint()), Max(ImPlot3DPoint());

constexpr ImPlot3DBox(const ImPlot3DPoint& min, const ImPlot3DPoint& max) : Min(min), Max(max);

Default constructor

Box::Expand¶

IMPLOT3D_API void Expand(const ImPlot3DPoint& point);

Method to expand the box to include a point

Box::Contains¶

IMPLOT3D_API bool Contains(const ImPlot3DPoint& point) const;

Method to check if a point is inside the box

Box::ClipLineSegment¶

IMPLOT3D_API bool ClipLineSegment(const ImPlot3DPoint& p0, const ImPlot3DPoint& p1, ImPlot3DPoint& p0_clipped, ImPlot3DPoint& p1_clipped) const;

Method to clip a line segment against the box

ImPlot3DRange¶

Range (struct)¶

ImPlot3DRange: Represents a 1D range with min and max values

Range::ImPlot3DRange¶

constexpr ImPlot3DRange() : Min(0.0), Max(0.0);

constexpr ImPlot3DRange(double min, double max) : Min(min), Max(max);

Range::Expand¶

IMPLOT3D_API void Expand(double value);

Expand range to include value

Range::Contains¶

IMPLOT3D_API bool Contains(double value) const;

Check if value is within range

Range::Size¶

double Size() const;

(private API)

Get range size

ImPlot3DQuat¶

Quat (struct)¶

ImPlot3DQuat: Quaternion for representing 3D rotations

Quat::ImPlot3DQuat¶

constexpr ImPlot3DQuat() : x(0.0), y(0.0), z(0.0), w(1.0);

constexpr ImPlot3DQuat(double _x, double _y, double _z, double _w) : x(_x), y(_y), z(_z), w(_w);

IMPLOT3D_API ImPlot3DQuat(double _angle, const ImPlot3DPoint& _axis);

Construct quaternion from angle-axis representation (angle in radians)

Quat::FromTwoVectors¶

IMPLOT3D_API static ImPlot3DQuat FromTwoVectors(const ImPlot3DPoint& v0, const ImPlot3DPoint& v1);

Create quaternion that rotates from v0 to v1

Quat::FromElAz¶

IMPLOT3D_API static ImPlot3DQuat FromElAz(double elevation, double azimuth);

Create quaternion from elevation and azimuth angles (in radians)

Quat::Length¶

IMPLOT3D_API double Length() const;

Get quaternion length

Quat::Normalized¶

IMPLOT3D_API ImPlot3DQuat Normalized() const;

Get normalized quaternion

Quat::Conjugate¶

IMPLOT3D_API ImPlot3DQuat Conjugate() const;

Conjugate of the quaternion

Quat::Inverse¶

IMPLOT3D_API ImPlot3DQuat Inverse() const;

Inverse of the quaternion

Quat::Normalize¶

IMPLOT3D_API ImPlot3DQuat& Normalize();

Normalize the quaternion in place

Quat::Slerp¶

IMPLOT3D_API static ImPlot3DQuat Slerp(const ImPlot3DQuat& q1, const ImPlot3DQuat& q2, double t);

Spherical linear interpolation between two quaternions (t in [0,1])

Quat::Dot¶

IMPLOT3D_API double Dot(const ImPlot3DQuat& rhs) const;

Get quaternion dot product

ImPlot3DStyle¶

Style (struct)¶

(has support for copy.copy)

Style::GetColor¶

inline ImVec4 GetColor(ImPlot3DCol idx) const;

(private API)

Style::SetColor¶

inline void SetColor(ImPlot3DCol idx, const ImVec4& col);

(private API)

Style::ImPlot3DStyle¶

IMPLOT3D_API ImPlot3DStyle();

ImPlot3DStyle(const ImPlot3DStyle& other) = default;

Constructor