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.

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)¶

NextItemData (class)¶

NextItemData.__init__¶

def __init__(self) -> None

ImPlot3DNextItemData();

NextItemData.reset¶

def reset(self) -> None

void Reset();

(private API)

ColormapData (class)¶

Colormap data storage

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)¶

State information for plot items

Item.__init__¶

def __init__(self) -> None

ImPlot3DItem();

Legend (class)¶

Holds legend state

Legend.__init__¶

def __init__(self) -> None

ImPlot3DLegend();

Legend.reset¶

def reset(self) -> None

void Reset();

(private API)

ItemGroup (class)¶

Holds items

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)¶

Tick mark info

Tick.__init__¶

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

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

Ticker (class)¶

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)¶

Holds axis information

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)¶

Holds plot state information that must persist after EndPlot

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)¶

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

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

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);

Register or get an existing item from the current plot

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, text_end: Optional[str] = None) -> 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)