implot3d.internal

ImPlot3D’s internal API (implot3d_internal.h): the structures and helpers that ImPlot3D is built with.

It may change between versions of ImPlot3D.

The module imgui_bundle.implot3d.internal, the Python API of ImPlot3D, from bindings/imgui_bundle/implot3d/internal.pyi: 41 functions, 10 classes, 1 enums. Each entry gives the Python signature, then the C++ one, then the doc of the C++ header. The sections are the header’s.

implot3d_internal.h¶

`im_log10`¶

def im_log10(x: float) -> float

static inline double ImLog10(double x);

Computes the common (base-10) logarithm (private API)

`im_sinh`¶

def im_sinh(x: float) -> float

static inline double ImSinh(double x);

Computes the hyperbolic sine (private API)

`im_asinh`¶

def im_asinh(x: float) -> float

static inline double ImAsinh(double x);

Computes the inverse hyperbolic sine (private API)

Flips a flag in a flagset¶

`im_pos_mod`¶

def im_pos_mod(l: int, r: int) -> int

static inline int ImPosMod(int l, int r);

Returns always positive modulo (assumes r != 0) (private API)

`im_nan`¶

def im_nan(val: float) -> bool

static inline bool ImNan(double val);

Returns True if val is NAN (private API)

`im_nan_or_inf`¶

def im_nan_or_inf(val: float) -> bool

static inline bool ImNanOrInf(double val);

Returns True if val is NAN or INFINITY (private API)

`im_constrain_nan`¶

def im_constrain_nan(val: float) -> float

static inline double ImConstrainNan(double val);

Turns NANs to 0s (private API)

`im_constrain_inf`¶

def im_constrain_inf(val: float) -> float

static inline double ImConstrainInf(double val);

Turns infinity to floating point maximums
Clamped to half DBL_MAX to prevent overflow in size calculations (Max - Min) (private API)

`im_almost_equal`¶

def im_almost_equal(v1: float, v2: float, ulp: int = 2) -> bool

static inline bool ImAlmostEqual(double v1, double v2, int ulp = 2);

True if two numbers are approximately equal using units in the last place. (private API)

`im_alpha_u32`¶

def im_alpha_u32(col: ImU32, alpha: float) -> ImU32

static inline ImU32 ImAlphaU32(ImU32 col, float alpha);

Set alpha channel of 32-bit color from float in range [0.0 1.0] (private API)

`im_mix_u32`¶

def im_mix_u32(a: ImU32, b: ImU32, s: ImU32) -> ImU32

static inline ImU32 ImMixU32(ImU32 a, ImU32 b, ImU32 s);

Mix color a and b by factor s in [0 256] (private API)

Internal Enumerations¶

`MarkerInternal_` (enum)¶

enum ImPlot3DMarkerInternal_

Member	Value	C++
`im_plot3_d_marker_invalid`	-3	`ImPlot3DMarker_Invalid = -3, }`

`NextItemData` (class)¶

struct ImPlot3DNextItemData

Attribute	C++
`spec: Spec`	`ImPlot3DSpec Spec;`
`render_line: bool`	`bool RenderLine;`
`render_fill: bool`	`bool RenderFill;`
`render_marker_line: bool`	`bool RenderMarkerLine;`
`render_marker_fill: bool`	`bool RenderMarkerFill;`
`is_auto_fill: bool`	`bool IsAutoFill;`
`is_auto_line: bool`	`bool IsAutoLine;`
`hidden: bool`	`bool Hidden;`

`NextItemData.init`¶

def __init__(self) -> None

ImPlot3DNextItemData();

`NextItemData.reset`¶

def reset(self) -> None

void Reset();

(private API)

`ColormapData` (class)¶

struct ImPlot3DColormapData

Colormap data storage

Attribute	C++
`count: int`	`int Count;`

`ColormapData.init`¶

def __init__(self) -> None

ImPlot3DColormapData();

`ColormapData.append`¶

def append(self, name: str, keys: ImU32, count: int, qual: bool) -> int

int Append(const char* name, const ImU32* keys, int count, bool qual);

(private API)

`ColormapData.rebuild_tables`¶

def rebuild_tables(self) -> None

void RebuildTables();

(private API)

`ColormapData.is_qual`¶

def is_qual(self, cmap: Colormap) -> bool

inline bool IsQual(ImPlot3DColormap cmap) const;

(private API)

`ColormapData.get_name`¶

def get_name(self, cmap: Colormap) -> str

inline const char* GetName(ImPlot3DColormap cmap) const;

(private API)

`ColormapData.get_index`¶

def get_index(self, name: str) -> Colormap

inline ImPlot3DColormap GetIndex(const char* name) const;

(private API)

`ColormapData.get_keys`¶

def get_keys(self, cmap: Colormap) -> ImU32

inline const ImU32* GetKeys(ImPlot3DColormap cmap) const;

(private API)

`ColormapData.get_key_count`¶

def get_key_count(self, cmap: Colormap) -> int

inline int GetKeyCount(ImPlot3DColormap cmap) const;

(private API)

`ColormapData.get_key_color`¶

def get_key_color(self, cmap: Colormap, idx: int) -> ImU32

inline ImU32 GetKeyColor(ImPlot3DColormap cmap, int idx) const;

(private API)

`ColormapData.set_key_color`¶

def set_key_color(self, cmap: Colormap, idx: int, value: ImU32) -> None

inline void SetKeyColor(ImPlot3DColormap cmap, int idx, ImU32 value);

(private API)

`ColormapData.get_table`¶

def get_table(self, cmap: Colormap) -> ImU32

inline const ImU32* GetTable(ImPlot3DColormap cmap) const;

(private API)

`ColormapData.get_table_size`¶

def get_table_size(self, cmap: Colormap) -> int

inline int GetTableSize(ImPlot3DColormap cmap) const;

(private API)

`ColormapData.get_table_color`¶

def get_table_color(self, cmap: Colormap, idx: int) -> ImU32

inline ImU32 GetTableColor(ImPlot3DColormap cmap, int idx) const;

(private API)

`ColormapData.lerp_table`¶

def lerp_table(self, cmap: Colormap, t: float) -> ImU32

inline ImU32 LerpTable(ImPlot3DColormap cmap, float t) const;

(private API)

`Item` (class)¶

struct ImPlot3DItem

State information for plot items

Attribute	C++
`id_: ID`	`ImGuiID ID;`
`color: ImU32`	`ImU32 Color;`
`marker: Marker`	`ImPlot3DMarker Marker;`
`name_offset: int`	`int NameOffset;`
`show: bool`	`bool Show;`
`legend_hovered: bool`	`bool LegendHovered;`
`seen_this_frame: bool`	`bool SeenThisFrame;`

`Item.init`¶

def __init__(self) -> None

ImPlot3DItem();

`Legend` (class)¶

struct ImPlot3DLegend

Holds legend state

Attribute	C++
`flags: LegendFlags`	`ImPlot3DLegendFlags Flags;`
`previous_flags: LegendFlags`	`ImPlot3DLegendFlags PreviousFlags;`
`location: Location`	`ImPlot3DLocation Location;`
`previous_location: Location`	`ImPlot3DLocation PreviousLocation;`
`scroll: ImVec2`	`ImVec2 Scroll;`
`rect: ImRect`	`ImRect Rect;`
`rect_clamped: ImRect`	`ImRect RectClamped;`
`hovered: bool`	`bool Hovered;`
`held: bool`	`bool Held;`

`Legend.init`¶

def __init__(self) -> None

ImPlot3DLegend();

`Legend.reset`¶

def reset(self) -> None

void Reset();

(private API)

`ItemGroup` (class)¶

struct ImPlot3DItemGroup

Holds items

Attribute	C++
`id_: ID`	`ImGuiID ID;`
`legend: Legend`	`ImPlot3DLegend Legend;`
`colormap_idx: int`	`int ColormapIdx;`
`marker_idx: Marker`	`ImPlot3DMarker MarkerIdx;`

`ItemGroup.init`¶

def __init__(self) -> None

ImPlot3DItemGroup();

`ItemGroup.get_item_count`¶

def get_item_count(self) -> int

int GetItemCount() const;

(private API)

`ItemGroup.get_item_id`¶

def get_item_id(self, label_id: str) -> ID

ImGuiID GetItemID(const char* label_id);

(private API)

`ItemGroup.get_item`¶

@overload
def get_item(self, id_: ID) -> Item

@overload
def get_item(self, label_id: str) -> Item

ImPlot3DItem* GetItem(ImGuiID id);
ImPlot3DItem* GetItem(const char* label_id);

(private API)

`ItemGroup.get_or_add_item`¶

def get_or_add_item(self, id_: ID) -> Item

ImPlot3DItem* GetOrAddItem(ImGuiID id);

(private API)

`ItemGroup.get_item_by_index`¶

def get_item_by_index(self, i: int) -> Item

ImPlot3DItem* GetItemByIndex(int i);

(private API)

`ItemGroup.get_item_index`¶

def get_item_index(self, item: Item) -> int

int GetItemIndex(ImPlot3DItem* item);

(private API)

`ItemGroup.get_legend_count`¶

def get_legend_count(self) -> int

int GetLegendCount() const;

(private API)

`ItemGroup.get_legend_item`¶

def get_legend_item(self, i: int) -> Item

ImPlot3DItem* GetLegendItem(int i);

(private API)

`ItemGroup.get_legend_label`¶

def get_legend_label(self, i: int) -> str

const char* GetLegendLabel(int i);

(private API)

`ItemGroup.reset`¶

def reset(self) -> None

void Reset();

(private API)

`Tick` (class)¶

struct ImPlot3DTick

Tick mark info

Attribute	C++
`plot_pos: float`	`double PlotPos;`
`major: bool`	`bool Major;`
`show_label: bool`	`bool ShowLabel;`
`label_size: ImVec2`	`ImVec2 LabelSize;`
`text_offset: int`	`int TextOffset;`
`idx: int`	`int Idx;`

`Tick.init`¶

def __init__(self, value: float, major: bool, show_label: bool) -> None

ImPlot3DTick(double value, bool major, bool show_label);

`Ticker` (class)¶

struct ImPlot3DTicker

Collection of ticks

`Ticker.init`¶

def __init__(self) -> None

ImPlot3DTicker();

`Ticker.add_tick`¶

@overload
def add_tick(self, value: float, major: bool, show_label: bool, label: str) -> Tick

@overload
def add_tick(self, tick: Tick) -> Tick

ImPlot3DTick& AddTick(double value, bool major, bool show_label, const char* label);
inline ImPlot3DTick& AddTick(ImPlot3DTick tick);

(private API)

`Ticker.get_text`¶

@overload
def get_text(self, idx: int) -> str

@overload
def get_text(self, tick: Tick) -> str

const char* GetText(int idx) const;
const char* GetText(const ImPlot3DTick& tick) const;

(private API)

`Ticker.reset`¶

def reset(self) -> None

void Reset();

(private API)

`Ticker.tick_count`¶

def tick_count(self) -> int

int TickCount() const;

(private API)

`Axis` (class)¶

struct ImPlot3DAxis

Holds axis information

Attribute	C++
`flags: AxisFlags`	`ImPlot3DAxisFlags Flags;`
`previous_flags: AxisFlags`	`ImPlot3DAxisFlags PreviousFlags;`
`range: Range`	`ImPlot3DRange Range;`
`range_cond: Cond`	`ImPlot3DCond RangeCond;`
`ndc_scale: float`	`double NDCScale;`
`scale: Scale`	`ImPlot3DScale Scale;`
`ticker: Ticker`	`ImPlot3DTicker Ticker;`
`formatter_data: Any`	`void* FormatterData;`
`show_default_ticks: bool`	`bool ShowDefaultTicks;`
`transform_data: Any`	`void* TransformData;`	Custom transform data set by the user
`scaled_range: Range`	`ImPlot3DRange ScaledRange;`	Cached scaled range values
`fit_this_frame: bool`	`bool FitThisFrame;`
`fit_extents: Range`	`ImPlot3DRange FitExtents;`
`constraint_range: Range`	`ImPlot3DRange ConstraintRange;`
`constraint_zoom: Range`	`ImPlot3DRange ConstraintZoom;`
`hovered: bool`	`bool Hovered;`
`held: bool`	`bool Held;`
`color_bg: ImU32`	`ImU32 ColorBg;`
`color_hov: ImU32`	`ImU32 ColorHov;`
`color_act: ImU32`	`ImU32 ColorAct;`

`Axis.init`¶

def __init__(self) -> None

ImPlot3DAxis();

Constructor

`Axis.reset`¶

def reset(self) -> None

inline void Reset();

(private API)

`Axis.set_range`¶

def set_range(self, v1: float, v2: float) -> None

inline void SetRange(double v1, double v2);

(private API)

`Axis.set_min`¶

def set_min(self, _min: float, force: bool = False) -> bool

inline bool SetMin(double _min, bool force = false);

(private API)

`Axis.set_max`¶

def set_max(self, _max: float, force: bool = False) -> bool

inline bool SetMax(double _max, bool force = false);

(private API)

`Axis.constrain`¶

def constrain(self) -> None

inline void Constrain();

(private API)

`Axis.update_transform_cache`¶

def update_transform_cache(self) -> None

inline void UpdateTransformCache();

(private API)

`Axis.plot_to_ndc`¶

def plot_to_ndc(self, plt: float) -> float

inline double PlotToNDC(double plt) const;

(private API)

`Axis.ndc_to_plot`¶

def ndc_to_plot(self, t: float) -> float

inline double NDCToPlot(double t) const;

(private API)

`Axis.is_range_locked`¶

def is_range_locked(self) -> bool

inline bool IsRangeLocked() const;

(private API)

`Axis.is_locked_min`¶

def is_locked_min(self) -> bool

inline bool IsLockedMin() const;

(private API)

`Axis.is_locked_max`¶

def is_locked_max(self) -> bool

inline bool IsLockedMax() const;

(private API)

`Axis.is_locked`¶

def is_locked(self) -> bool

inline bool IsLocked() const;

(private API)

`Axis.is_input_locked_min`¶

def is_input_locked_min(self) -> bool

inline bool IsInputLockedMin() const;

(private API)

`Axis.is_input_locked_max`¶

def is_input_locked_max(self) -> bool

inline bool IsInputLockedMax() const;

(private API)

`Axis.is_input_locked`¶

def is_input_locked(self) -> bool

inline bool IsInputLocked() const;

(private API)

`Axis.is_pan_locked`¶

def is_pan_locked(self, increasing: bool) -> bool

inline bool IsPanLocked(bool increasing);

(private API)

`Axis.set_label`¶

def set_label(self, label: str) -> None

inline void SetLabel(const char* label);

(private API)

`Axis.get_label`¶

def get_label(self) -> str

inline const char* GetLabel() const;

(private API)

`Axis.ndc_size`¶

def ndc_size(self) -> float

inline double NDCSize() const;

(private API)

`Axis.set_aspect`¶

def set_aspect(self, units_per_ndc_unit: float) -> None

inline void SetAspect(double units_per_ndc_unit);

(private API)

`Axis.get_aspect`¶

def get_aspect(self) -> float

double GetAspect() const;

(private API)

`Axis.has_label`¶

def has_label(self) -> bool

bool HasLabel() const;

(private API)

`Axis.has_grid_lines`¶

def has_grid_lines(self) -> bool

bool HasGridLines() const;

(private API)

`Axis.has_tick_labels`¶

def has_tick_labels(self) -> bool

bool HasTickLabels() const;

(private API)

`Axis.has_tick_marks`¶

def has_tick_marks(self) -> bool

bool HasTickMarks() const;

(private API)

`Axis.is_auto_fitting`¶

def is_auto_fitting(self) -> bool

bool IsAutoFitting() const;

(private API)

`Axis.extend_fit`¶

def extend_fit(self, value: float) -> None

void ExtendFit(double value);

(private API)

`Axis.apply_fit`¶

def apply_fit(self) -> None

void ApplyFit();

(private API)

`Plot` (class)¶

struct ImPlot3DPlot

Holds plot state information that must persist after EndPlot

Attribute	C++
`id_: ID`	`ImGuiID ID;`
`flags: Flags`	`ImPlot3DFlags Flags;`
`previous_flags: Flags`	`ImPlot3DFlags PreviousFlags;`
`just_created: bool`	`bool JustCreated;`
`initialized: bool`	`bool Initialized;`
`frame_rect: ImRect`	`ImRect FrameRect;`	Outermost bounding rectangle that encapsulates whole the plot/title/padding/etc
`canvas_rect: ImRect`	`ImRect CanvasRect;`	Frame rectangle reduced by padding
`plot_rect: ImRect`	`ImRect PlotRect;`	Bounding rectangle for the actual plot area
`initial_rotation: Quat`	`ImPlot3DQuat InitialRotation;`	Initial rotation quaternion
`rotation: Quat`	`ImPlot3DQuat Rotation;`	Current rotation quaternion
`rotation_cond: Cond`	`ImPlot3DCond RotationCond;`
`animation_time: float`	`float AnimationTime;`	Remaining animation time
`rotation_animation_end: Quat`	`ImPlot3DQuat RotationAnimationEnd;`	End rotation for animation
`setup_locked: bool`	`bool SetupLocked;`
`hovered: bool`	`bool Hovered;`
`held: bool`	`bool Held;`
`held_edge_idx: int`	`int HeldEdgeIdx;`	Index of the edge being held
`held_plane_idx: int`	`int HeldPlaneIdx;`	Index of the plane being held
`drag_rotation_axis: Point`	`ImPlot3DPoint DragRotationAxis;`	Axis of rotation for the duration of a drag
`fit_this_frame: bool`	`bool FitThisFrame;`
`items: ItemGroup`	`ImPlot3DItemGroup Items;`
`context_click: bool`	`bool ContextClick;`	True if context button was clicked (to distinguish from double click)
`open_context_this_frame: bool`	`bool OpenContextThisFrame;`

`Plot.init`¶

def __init__(self) -> None

ImPlot3DPlot();

`Plot.set_title`¶

def set_title(self, title: str) -> None

inline void SetTitle(const char* title);

(private API)

`Plot.has_title`¶

def has_title(self) -> bool

inline bool HasTitle() const;

(private API)

`Plot.get_title`¶

def get_title(self) -> str

inline const char* GetTitle() const;

(private API)

`Plot.is_rotation_locked`¶

def is_rotation_locked(self) -> bool

inline bool IsRotationLocked() const;

(private API)

`Plot.extend_fit`¶

def extend_fit(self, point: Point) -> None

void ExtendFit(const ImPlot3DPoint& point);

Extends the fit range of all three axes to include the provided point (private API)

`Plot.range_min`¶

def range_min(self) -> Point

ImPlot3DPoint RangeMin() const;

Returns the minimum of the range in all three dimensions (private API)

`Plot.range_max`¶

def range_max(self) -> Point

ImPlot3DPoint RangeMax() const;

Returns the maximum of the range in all three dimensions (private API)

`Plot.range_center`¶

def range_center(self) -> Point

ImPlot3DPoint RangeCenter() const;

Returns the point at the center of the range in all three dimensions (private API)

`Plot.set_range`¶

def set_range(self, min: Point, max: Point) -> None

void SetRange(const ImPlot3DPoint& min, const ImPlot3DPoint& max);

Sets the range of all three axes (private API)

`Plot.get_view_scale`¶

def get_view_scale(self) -> float

float GetViewScale() const;

Returns the scale of the plot view (constant to convert from NDC coordinates to pixels coordinates) (private API)

`Plot.get_box_scale`¶

def get_box_scale(self) -> Point

ImPlot3DPoint GetBoxScale() const;

Returns the scale of the plot box in each dimension (private API)

`Plot.apply_equal_aspect`¶

def apply_equal_aspect(self, ref_axis: ImAxis3D) -> None

void ApplyEqualAspect(ImAxis3D ref_axis);

Applies equal aspect ratio constraint using the specified axis as reference.
Other axes are adjusted to match the reference axis’s aspect ratio (units per NDC unit). (private API)

`Context` (class)¶

struct ImPlot3DContext

Attribute	C++
`current_plot: Plot`	`ImPlot3DPlot* CurrentPlot;`
`current_items: ItemGroup`	`ImPlot3DItemGroup* CurrentItems;`
`current_item: Item`	`ImPlot3DItem* CurrentItem;`
`next_item_data: NextItemData`	`ImPlot3DNextItemData NextItemData;`
`style: Style`	`ImPlot3DStyle Style;`
`colormap_data: ColormapData`	`ImPlot3DColormapData ColormapData;`

`Context.init`¶

def __init__(self, next_item_data: Optional[NextItemData] = None, style: Optional[Style] = None, colormap_data: Optional[ColormapData] = None) -> None

Auto-generated default constructor with named params

Python bindings defaults:
If any of the params below is None, then its default value below will be used: * NextItemData: NextItemData() * Style: Style() * ColormapData: ColormapData()

Context Utils¶

`initialize_context`¶

def initialize_context(ctx: Context) -> None

IMPLOT3D_API void InitializeContext(ImPlot3DContext* ctx);

Initialize ImPlot3DContext

`reset_context`¶

def reset_context(ctx: Context) -> None

IMPLOT3D_API void ResetContext(ImPlot3DContext* ctx);

Reset ImPlot3DContext

Style Utils¶

`is_color_auto`¶

@overload
def is_color_auto(col: ImVec4Like) -> bool

@overload
def is_color_auto(idx: Col) -> bool

IMPLOT3D_API bool IsColorAuto(const ImVec4& col);
IMPLOT3D_API bool IsColorAuto(ImPlot3DCol idx);

`get_auto_color`¶

def get_auto_color(idx: Col) -> ImVec4

IMPLOT3D_API ImVec4 GetAutoColor(ImPlot3DCol idx);

`get_style_color_name`¶

def get_style_color_name(idx: Col) -> str

IMPLOT3D_API const char* GetStyleColorName(ImPlot3DCol idx);

Returns white or black text given background color¶

`calc_text_color`¶

@overload
def calc_text_color(bg: ImVec4Like) -> ImU32

@overload
def calc_text_color(bg: ImU32) -> ImU32

static inline ImU32 CalcTextColor(const ImVec4& bg);
static inline ImU32 CalcTextColor(ImU32 bg);

(private API)

`get_item_data`¶

def get_item_data() -> NextItemData

IMPLOT3D_API const ImPlot3DNextItemData& GetItemData();

Get styling data for next item (call between BeginItem/EndItem)

`get_colormap_color_u32`¶

def get_colormap_color_u32(idx: int, cmap: Colormap) -> ImU32

IMPLOT3D_API ImU32 GetColormapColorU32(int idx, ImPlot3DColormap cmap);

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

`next_colormap_color_u32`¶

def next_colormap_color_u32() -> ImU32

IMPLOT3D_API ImU32 NextColormapColorU32();

Returns the next unused colormap color and advances the colormap. Can be used to skip colors if desired

`render_color_bar`¶

def render_color_bar(colors: ImU32, size: int, draw_list: ImDrawList, bounds: ImRect, vert: bool, reversed: bool, continuous: bool) -> None

IMPLOT3D_API void RenderColorBar(const ImU32* colors, int size, ImDrawList& DrawList, const ImRect& bounds, bool vert, bool reversed, bool continuous);

Render a colormap bar

Item Utils¶

`begin_item`¶

def begin_item(label_id: str, spec: Optional[Spec] = None, item_col: Optional[ImVec4Like] = None, item_mkr: Optional[Marker] = None) -> bool

IMPLOT3D_API bool BeginItem(const char* label_id, const ImPlot3DSpec& spec = ImPlot3DSpec(), const ImVec4& item_col = IMPLOT3D_AUTO_COL, ImPlot3DMarker item_mkr = ImPlot3DMarker_Invalid);

Begins a new item. Returns False if the item should not be plotted

Python bindings defaults:
If any of the params below is None, then its default value below will be used: * spec: Spec() * item_col: IMPLOT3D_AUTO_COL * item_mkr: Marker_Invalid

`end_item`¶

def end_item() -> None

IMPLOT3D_API void EndItem();

`register_or_get_item`¶

def register_or_get_item(label_id: str, flags: ItemFlags, just_created: Optional[bool] = None) -> Tuple[Item, Optional[bool]]

IMPLOT3D_API ImPlot3DItem* RegisterOrGetItem(const char* label_id, ImPlot3DItemFlags flags, bool* just_created = nullptr);

`get_current_item`¶

def get_current_item() -> Item

IMPLOT3D_API ImPlot3DItem* GetCurrentItem();

Gets the current item from ImPlot3DContext

`bust_item_cache`¶

def bust_item_cache() -> None

IMPLOT3D_API void BustItemCache();

Busts the cache for every item for every plot in the current context

`add_text_rotated`¶

def add_text_rotated(draw_list: ImDrawList, pos: ImVec2Like, angle: float, col: ImU32, text_begin: str) -> None

IMPLOT3D_API void AddTextRotated(ImDrawList* draw_list, ImVec2 pos, float angle, ImU32 col, const char* text_begin, const char* text_end = nullptr);

TODO move to another place

Plot Utils¶

`get_current_plot`¶

def get_current_plot() -> Plot

IMPLOT3D_API ImPlot3DPlot* GetCurrentPlot();

Gets the current plot from ImPlot3DContext

`bust_plot_cache`¶

def bust_plot_cache() -> None

IMPLOT3D_API void BustPlotCache();

Busts the cache for every plot in the current context

`get_frame_pos`¶

def get_frame_pos() -> ImVec2

IMPLOT3D_API ImVec2 GetFramePos();

Get the current frame position (top-left) in pixels

`get_frame_size`¶

def get_frame_size() -> ImVec2

IMPLOT3D_API ImVec2 GetFrameSize();

Get the current frame size in pixels

`plot_to_ndc`¶

def plot_to_ndc(point: Point) -> Point

IMPLOT3D_API ImPlot3DPoint PlotToNDC(const ImPlot3DPoint& point);

Convert a position in the current plot’s coordinate system to the current plot’s normalized device coordinate system (NDC)
When the cube’s aspect ratio is [1,1,1], the NDC ranges from [-0.5, 0.5] along each axis

`ndc_to_plot`¶

def ndc_to_plot(point: Point) -> Point

IMPLOT3D_API ImPlot3DPoint NDCToPlot(const ImPlot3DPoint& point);

`ndc_to_pixels`¶

def ndc_to_pixels(point: Point) -> ImVec2

IMPLOT3D_API ImVec2 NDCToPixels(const ImPlot3DPoint& point);

Convert a position in the current plot’s NDC to pixels

`pixels_to_ndc_ray`¶

def pixels_to_ndc_ray(pix: ImVec2Like) -> Ray

IMPLOT3D_API ImPlot3DRay PixelsToNDCRay(const ImVec2& pix);

Convert a pixel coordinate to a ray in the NDC

`ndc_ray_to_plot_ray`¶

def ndc_ray_to_plot_ray(ray: Ray) -> Ray

IMPLOT3D_API ImPlot3DRay NDCRayToPlotRay(const ImPlot3DRay& ray);

Convert a ray in the NDC to a ray in the current plot’s coordinate system

Setup Utils¶

`setup_lock`¶

def setup_lock() -> None

IMPLOT3D_API void SetupLock();

Transforms¶

`transform_forward_log10`¶

def transform_forward_log10(v: float, param_1: Any) -> float

static inline double TransformForward_Log10(double v, void*);

(private API)

`transform_inverse_log10`¶

def transform_inverse_log10(v: float, param_1: Any) -> float

static inline double TransformInverse_Log10(double v, void*);

(private API)

`transform_forward_sym_log`¶

def transform_forward_sym_log(v: float, param_1: Any) -> float

static inline double TransformForward_SymLog(double v, void*);

(private API)

`transform_inverse_sym_log`¶

def transform_inverse_sym_log(v: float, param_1: Any) -> float

static inline double TransformInverse_SymLog(double v, void*);

(private API)

implot3d_internal.h¶

im_log10¶

im_sinh¶

im_asinh¶

Flips a flag in a flagset¶

im_pos_mod¶

im_nan¶

im_nan_or_inf¶

im_constrain_nan¶

im_constrain_inf¶

im_almost_equal¶

im_alpha_u32¶

im_mix_u32¶

Internal Enumerations¶

MarkerInternal_ (enum)¶

NextItemData (class)¶

NextItemData.__init__¶

NextItemData.reset¶

ColormapData (class)¶

ColormapData.__init__¶

ColormapData.append¶

ColormapData.rebuild_tables¶

ColormapData.is_qual¶

ColormapData.get_name¶

ColormapData.get_index¶

ColormapData.get_keys¶

ColormapData.get_key_count¶

ColormapData.get_key_color¶

ColormapData.set_key_color¶

ColormapData.get_table¶

ColormapData.get_table_size¶

ColormapData.get_table_color¶

ColormapData.lerp_table¶

Item (class)¶

Item.__init__¶

Legend (class)¶

Legend.__init__¶

Legend.reset¶

ItemGroup (class)¶

ItemGroup.__init__¶

ItemGroup.get_item_count¶

ItemGroup.get_item_id¶

ItemGroup.get_item¶

ItemGroup.get_or_add_item¶

ItemGroup.get_item_by_index¶

ItemGroup.get_item_index¶

ItemGroup.get_legend_count¶

ItemGroup.get_legend_item¶

ItemGroup.get_legend_label¶

ItemGroup.reset¶

Tick (class)¶

Tick.__init__¶

Ticker (class)¶

Ticker.__init__¶

Ticker.add_tick¶

Ticker.get_text¶

Ticker.reset¶

Ticker.tick_count¶

Axis (class)¶

Axis.__init__¶

Axis.reset¶

Axis.set_range¶

Axis.set_min¶

Axis.set_max¶

Axis.constrain¶

Axis.update_transform_cache¶

Axis.plot_to_ndc¶

Axis.ndc_to_plot¶

Axis.is_range_locked¶

Axis.is_locked_min¶

Axis.is_locked_max¶

Axis.is_locked¶

Axis.is_input_locked_min¶

Axis.is_input_locked_max¶

Axis.is_input_locked¶

Axis.is_pan_locked¶

Axis.set_label¶

Axis.get_label¶

Axis.ndc_size¶

`im_log10`¶

`im_sinh`¶

`im_asinh`¶

`im_pos_mod`¶

`im_nan`¶

`im_nan_or_inf`¶

`im_constrain_nan`¶

`im_constrain_inf`¶

`im_almost_equal`¶

`im_alpha_u32`¶

`im_mix_u32`¶

`MarkerInternal_` (enum)¶

`NextItemData` (class)¶

`NextItemData.init`¶

`NextItemData.reset`¶

`ColormapData` (class)¶

`ColormapData.init`¶

`ColormapData.append`¶

`ColormapData.rebuild_tables`¶

`ColormapData.is_qual`¶

`ColormapData.get_name`¶

`ColormapData.get_index`¶

`ColormapData.get_keys`¶

`ColormapData.get_key_count`¶

`ColormapData.get_key_color`¶

`ColormapData.set_key_color`¶

`ColormapData.get_table`¶

`ColormapData.get_table_size`¶

`ColormapData.get_table_color`¶

`ColormapData.lerp_table`¶

`Item` (class)¶

`Item.init`¶

`Legend` (class)¶

`Legend.init`¶

`Legend.reset`¶

`ItemGroup` (class)¶

`ItemGroup.init`¶

`ItemGroup.get_item_count`¶

`ItemGroup.get_item_id`¶

`ItemGroup.get_item`¶

`ItemGroup.get_or_add_item`¶

`ItemGroup.get_item_by_index`¶

`ItemGroup.get_item_index`¶

`ItemGroup.get_legend_count`¶

`ItemGroup.get_legend_item`¶

`ItemGroup.get_legend_label`¶

`ItemGroup.reset`¶

`Tick` (class)¶

`Tick.init`¶

`Ticker` (class)¶

`Ticker.init`¶

`Ticker.add_tick`¶

`Ticker.get_text`¶

`Ticker.reset`¶

`Ticker.tick_count`¶

`Axis` (class)¶

`Axis.init`¶

`Axis.reset`¶

`Axis.set_range`¶

`Axis.set_min`¶

`Axis.set_max`¶

`Axis.constrain`¶

`Axis.update_transform_cache`¶

`Axis.plot_to_ndc`¶

`Axis.ndc_to_plot`¶

`Axis.is_range_locked`¶

`Axis.is_locked_min`¶

`Axis.is_locked_max`¶

`Axis.is_locked`¶

`Axis.is_input_locked_min`¶

`Axis.is_input_locked_max`¶

`Axis.is_input_locked`¶

`Axis.is_pan_locked`¶

`Axis.set_label`¶

`Axis.get_label`¶

`Axis.ndc_size`¶

`Axis.set_aspect`¶

`Axis.get_aspect`¶

`Axis.has_label`¶

`Axis.has_grid_lines`¶